kgameproperty.h

Go to the documentation of this file.

/*
    This file is part of the KDE games library
    Copyright (C) 2001 Andreas Beckermann (b_mann@gmx.de)
    Copyright (C) 2001 Martin Heni (martin@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.h>

#include <kdebug.h>
#include <typeinfo>
#include <kdemacros.h>
class KGame;
class KPlayer;
class KGamePropertyHandler;
using namespace std;

class KDE_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, QString name=0);

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

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

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

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

        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!
                                kdError(11001) << "Undefined Policy in property " << id() << endl;
                                return;
                }
        }


        bool send(type v)
        {
                if (isOptimized() && mData == v) {
                        return true;
                }
                if (isLocked()) {
                        return false;
                }
                QByteArray b;
                QDataStream stream(b, IO_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);
        }

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

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

        virtual void load(QDataStream& s)
        {
                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(); }

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

private:
        void init() { }

private:
        type mData;
};


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

#endif

---