kgameproperty.h

/*
    This file is part of the KDE games library
    Copyright (C) 2001 Andreas Beckermann ([email protected])
    Copyright (C) 2001 Martin Heni (kde at heni-online.de)

    This library is free software; you can redistribute it and/or
    modify it under the terms of the GNU Library General Public
    License version 2 as published by the Free Software Foundation.

    This library is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
    Library General Public License for more details.

    You should have received a copy of the GNU Library General Public License
    along with this library; see the file COPYING.LIB.  If not, write to
    the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
    Boston, MA 02110-1301, USA.
*/

#ifndef __KGAMEPROPERTY_H_
#define __KGAMEPROPERTY_H_

#include <QDataStream>
#include <QDebug>

#include <typeinfo>
#include "libkdegamesprivate_export.h"

class KGame;
class KPlayer;
class KGamePropertyHandler;
using namespace std;

class KDEGAMESPRIVATE_EXPORT KGamePropertyBase
{
public:
    enum PropertyDataIds  { // these belong to KPlayer/KGame!
        //KPlayer
        IdGroup=1,
        IdUserId=2,
        IdAsyncInput=3,
        IdTurn=4,
        IdName=5,

        //KGame
        IdGameStatus=6,
        IdMaxPlayer=7,
        IdMinPlayer=8,

    // Input Grabbing
    IdGrabInput=16,
    IdReleaseInput=17,

        IdCommand, // Reserved for internal use
        IdUser=256,

        IdAutomatic=0x7000  // Id's from here on are automatically given (16bit)
    };

    enum PropertyCommandIds
    {
        // General
        CmdLock=1,

        // Array
        CmdAt=51,
        CmdResize=52,
        CmdFill=53,
        CmdSort=54,
        // List (could be the same id's actually)
        CmdInsert=61,
        CmdAppend=62,
        CmdRemove=63,
        CmdClear=64
    };

    enum PropertyPolicy
    {
        PolicyUndefined = 0,
        PolicyClean = 1,
        PolicyDirty = 2,
        PolicyLocal = 3
    };


    KGamePropertyBase(int id, KGamePropertyHandler* owner);

    KGamePropertyBase(int id, KGame* parent);
    KGamePropertyBase(int id, KPlayer* parent);

    KGamePropertyBase();

    virtual ~KGamePropertyBase();

    void setPolicy(PropertyPolicy p) { mFlags.bits.policy = p; }

    PropertyPolicy policy() const { return (PropertyPolicy)mFlags.bits.policy; }

    void setEmittingSignal(bool p)  { mFlags.bits.emitsignal=p; }

    bool isEmittingSignal() const { return mFlags.bits.emitsignal; }

    void setOptimized(bool p) { mFlags.bits.optimize = p ; }

    bool isOptimized() const { return mFlags.bits.optimize; }

    bool isDirty() const { return mFlags.bits.dirty; }

    bool isLocked() const { return mFlags.bits.locked; }

    bool lock();

    bool unlock(bool force=false);

    virtual void load(QDataStream& s) = 0;

    virtual void save(QDataStream& s) = 0;

    virtual void command(QDataStream &stream, int msgid, bool isSender=false);

    int id() const { return mId; }

    virtual const type_info* typeinfo() { return &typeid(this); }

    int registerData(int id, KGamePropertyHandler* owner,PropertyPolicy p, const QString& name=QString());

    int registerData(int id, KGamePropertyHandler* owner, const QString& name=QString());

        int registerData(int id, KGame* owner, const QString& name=QString());

        int registerData(int id, KPlayer* owner, const QString& name=QString());

        int registerData(KGamePropertyHandler* owner,PropertyPolicy p=PolicyUndefined, const QString& name=QString() );

    void unregisterData();


protected:
    void setLock(bool l);

    void setDirty(bool d) { mFlags.bits.dirty = d ; }

    bool sendProperty();

    bool sendProperty(const QByteArray& b);

    void emitSignal();

protected:
    KGamePropertyHandler* mOwner;

    // Having this as a union of the bitfield and the char
    // allows us to stream this quantity easily (if we need to)
    // At the moment it is not yet transmitted
    union Flags {
        char flag;
        struct {
            // unsigned char dosave : 1;   // do save this property
            // unsigned char delaytransmit : 1;   // do not send immediately on
                                             // change but a KPlayer:QTimer
                                             // sends it later on - fast
                                             // changing variables
            unsigned char emitsignal : 1; // KPlayer notifies on variable change (true)
            //unsigned char readonly : 1; // whether the property can be changed (false)
            unsigned char optimize : 1; // whether the property tries to optimize send/emit (false)
            unsigned char dirty: 1; // whether the property dirty (setLocal() was used)
            unsigned char policy : 2; // whether the property is always consistent (see PropertyPolicy)
            unsigned char locked: 1; // whether the property is locked (true)
        } bits;
    } mFlags;

private:
    friend class KGamePropertyHandler;
    void init();

private:
    int mId;

};

template<class type>
class KGameProperty  : public KGamePropertyBase
{
public:
// TODO: ID: Very ugly - better use something like parent()->propertyId() or so which assigns a free id automatically.
    KGameProperty(int id, KGamePropertyHandler* owner) : KGamePropertyBase(id, owner) { init(); }

    KGameProperty() : KGamePropertyBase() { init(); }

    virtual ~KGameProperty() {}

    void setValue(type v)
    {
        switch (policy()) {
            case PolicyClean:
                send(v);
                break;
            case PolicyDirty:
                changeValue(v);
                break;
            case PolicyLocal:
                setLocal(v);
                break;
            default: // NEVER!
                qCritical() << "Undefined Policy in property" << id();
                return;
        }
    }


    bool send(type v)
    {
        if (isOptimized() && mData == v) {
            return true;
        }
        if (isLocked()) {
            return false;
        }
        QByteArray b;
        QDataStream stream(&b, QIODevice::WriteOnly);
        stream << v;
        if (!sendProperty(b)) {
            setLocal(v);
            return false;
        }
        return true;
    }

    bool setLocal(type v)
    {
        if (isOptimized() && mData == v) {
            return false;
        }
        if (isLocked()) {
            return false;
        }
        mData = v;
        setDirty(true);
        if (isEmittingSignal()) {
            emitSignal();
        }
        return true;
    }

    void changeValue(type v)
    {
        send(v);
        setLocal(v);
    }

    void save(QDataStream &stream) override
    {
        stream << mData;
    }

    const type& value() const
    {
        return mData;
    }

    void load(QDataStream& s) override
    {
        s >> mData;
        setDirty(false);
        if (isEmittingSignal()) {
            emitSignal();
        }
    }

    const type& operator=(const type& t)
    {
        setValue(t);
        return value();
    }

    const type& operator=(const KGameProperty& property)
    {
        setValue(property.value());
        return value();
    }

    operator type() const { return value(); }

    const type_info* typeinfo() override { return &typeid(type); }

private:
    void init() { }

private:
    type mData;
};


typedef KGameProperty<int>   KGamePropertyInt;
typedef KGameProperty<unsigned int>   KGamePropertyUInt;
typedef KGameProperty<QString>   KGamePropertyQString;
typedef KGameProperty<qint8>   KGamePropertyBool;

#endif