ReplicaObject.h

/* START_LICENSE_HEADER

Copyright (C) 2000 Martin Piper, original design and program code
Copyright (C) 2001 Replica Software

This program file is copyright (C) Replica Software and can only be used under license.
For more information visit: http://www.replicanet.com/
Or email: info@replicanet.com

END_LICENSE_HEADER */
#include "RNPlatform/Inc/MemoryTracking.h"
#ifndef __REPLICAOBJECT_H__
#define __REPLICAOBJECT_H__

#include <vector>
#include <list>
#include <set>

#include "RNPlatform/Inc/ThreadClass.h"
#include "RNPlatform/Inc/SysTime.h"
#include "RNReplicaNet/Inc/DataBlock.h"

namespace RNReplicaNet
{

class ReplicaNet;
class ReplicaNetPrivate;
struct s_RO_RegistryBlock;

const float kReplicaObject_InfiniteDistance = -1.0f;    
const int kReplicaObjectUnknownUniqueID = -1;

class ReplicaObject : private MutexClass
{
public:
    enum PacketType
    {
        kPacket_Unreliable = 0,
        kPacket_Reliable = 1,
        kPacket_Certain = 2,
        kPacket_Ordered = 3
    };

    ReplicaObject();

    virtual ~ReplicaObject();

    bool IsReplica(void) const;

    bool IsMaster(void) const;

    bool IsPublished(void) const;

    void Publish(void);

    void Unpublish(void);

    virtual const int GetClassID(void) = 0;

    virtual void SetRegistered(bool flag = true) = 0;

    virtual bool GetRegistered(void) = 0;

    int GetUniqueID(void);

    int GetSessionID(void);

    ReplicaNet *GetBoundReplicaNet(void);

    virtual bool ApproveFault(void);

    virtual bool ApproveMigration(void);

    virtual void OwnerChange(void);

    void GiveOwnership(int sessionID);

    void RequestOwnership(void);

    virtual float CalculateDistanceToObject(ReplicaObject *object);

    float GetDistanceToObject(ReplicaObject *object);

    virtual void SetOpaquePointer(void *data);

    virtual void *GetOpaquePointer(void *data = 0);

    DataBlock *FindDataBlock(void *pdata);

    template<typename dataBlockType , typename dataType>
    dataBlockType *FindDataBlock(dataType &member)
    {
        DataBlock *datablock = FindDataBlock(&member);
        if (!datablock)
        {
            return 0;
        }
        if (datablock->IsClassType(dataBlockType::StaticThisClassType()))
        {
            dataBlockType *realBlock = (dataBlockType*)(datablock);
            return realBlock;
        }
        return 0;
    }

    void GiveDeltaHint(float &variable,float delta);

    void ContinuityBreak(float &variable,unsigned char breakTypes);

    void UpdateSetReliable(void);

    void UpdateSetCertain(void);

    void UpdateSetUnreliable(void);

    void UpdateSetOrdered(void);

    bool UpdateIsReliable(void);

    bool UpdateIsCertain(void);

    bool UpdateIsUnreliable(void);

    bool UpdateIsOrdered(void);

    void SetLoadBalancing(const bool enable = false);

    void SetLoadBalancingDefault(const bool defaultValue = false);

    bool GetLoadBalancing(void);

    void SetLoadScore(const float load = 0.0f);

    void SetLoadScoreDefault(const float defaultLoad = 0.0f);

    float GetLoadScore(void);

    virtual void PostObjectCreate(void);

    virtual void UserRegisterDataBlocks(void);

    void AddAutoRegisterDataBlock(DataBlock *const dataBlock);

    void SetMessageReflectionID(const int sessionID = kReplicaObjectUnknownUniqueID);

    int GetMessageReflectionID(void) const;

    void SetPropagateToSessionDistance(const float distance = kReplicaObject_InfiniteDistance);

    void SetPropagateToSessionDistanceInclude(const float distance = kReplicaObject_InfiniteDistance);

    void SetPropagateToSessionDistanceExclude(const float distance = kReplicaObject_InfiniteDistance);

    void SetPropagateToSessionDistanceDefault(const float distance = kReplicaObject_InfiniteDistance);

    void SetPropagateToSessionDistanceIncludeDefault(const float distance = kReplicaObject_InfiniteDistance);

    void SetPropagateToSessionDistanceExcludeDefault(const float distance = kReplicaObject_InfiniteDistance);

    float GetPropagateToSessionDistance(void) const;

    float GetPropagateToSessionDistanceInclude(void) const;

    float GetPropagateToSessionDistanceExclude(void) const;

    void SetPropagateToSessionDistanceRecalculationDelay(const float delay = 0.1f);

    static ReplicaObject *AllocateForReplicaNet(void);

    static void DeleteForReplicaNet(ReplicaObject *object);


    void SetSessionPropagationFilter(const bool enable = false);

    bool GetSessionPropagationFilter(void) const;

    void GetSessionPropagationSet(std::set<int> &theSet);

    bool SessionPropagationAddSession(const int sessionID);

    bool SessionPropagationRemoveSession(const int sessionID);

    virtual void DataBlockPacketDataReceived(const DataBlock *datablock);

    virtual void DataBlockPacketDataReceivedPost(const DataBlock *datablock);

    virtual s_RO_RegistryBlock *GetRegistryBlock(void) const = 0;

    void DataSend(const int sessionid,const void *data,const int length,const PacketType type = kPacket_Reliable,const unsigned int band = 0);

    virtual void CallBackDataReceive(const int fromsessionid,const void *data,const int length,const PacketType type);

    int GetProcessingDataBlocksFromSessionID(void);

    virtual void CallbackObjectUnpublishPre(void);

    virtual void CallbackObjectUnpublishPost(void);

    bool GetNewSessionIDAndUniqueID(RNReplicaNet::ReplicaNet *toBindTo = 0);

    void DelayedDelete(const float delaySeconds = 0.0f);

    void DelayedDeleteCancel(void);

    bool GetDelayedDelete(void);

    bool GetDelayedDelete(float &delaySeconds);

    void UpdateSendDormant(const bool dormant = false);

    bool GetUpdateSendDormant(void) const;

    void UpdateSendDormantDelay(const bool dormant = false,const float delaySeconds = 0.0f);

    void UpdateSendDormantDelayCancel(void);

    bool GetUpdateSendDormantDelay(bool &dormant,float &delaySeconds) const;

    virtual void UpdateSendDormantDelayStateChange(const bool dormant);

    void SetBand(const unsigned int band = 0);

    unsigned int GetBand(void) const;

    static void SetDelayIDFetch(const bool delay = false);

    static bool GetDelayIDFetch(void);

    static void SetDelayBind(const bool delay = false);

    static bool GetDelayBind(void);

protected:
    // Default is to do nothing as it is set in the ctor
    // Otherwise it is used to set an update type by using a macroed function call specified in the ROLCompiler commands
    virtual void _Internal_GetUpdateType(void) {}
    virtual void _Internal_SetupLoadBalance(void) {}
    virtual void _Internal_SetupLoadBalanceScore(void) {}
    virtual void _Internal_SetupLoadBalanceDefault(void) {}
    virtual void _Internal_SetupLoadBalanceScoreDefault(void) {}
    virtual void _Internal_SetupOpaquePointer(void) {}
    virtual void _Internal_SetupPropagateToSessionDistanceRecalculationDelay(void) {}
    virtual void _Internal_SetupPropagateDistance(void) {}
    virtual void _Internal_SetupPropagateDistanceDefault(void) {}
    virtual void _Internal_SetupPropagateDistanceInclude(void) {}
    virtual void _Internal_SetupPropagateDistanceIncludeDefault(void) {}
    virtual void _Internal_SetupPropagateDistanceExclude(void) {}
    virtual void _Internal_SetupPropagateDistanceExcludeDefault(void) {}
    virtual void _Internal_SetupBand(void) {}

    // This sets the internal debugging full name
    void _Internal_SetFullyQualifiedName(const char *name = 0);
    const char *_Internal_GetFullyQualifiedName(void);
    // Debugging emit functions
    void _DebugInternal_EmitClassCreate(const int packetSize,const int toSession);
    void _DebugInternal_EmitClassDelete(const int packetSize,const int toSession);
    void _DebugInternal_EmitClassUnpublish(const int packetSize,const int toSession);

    virtual void RegisterDataBlock(DataBlock *block);

    virtual void SetNumExpectedDataBlocks(const int expected);

    virtual int GetNumExpectedDataBlocks(void);

private:
friend class ReplicaNet;            /* ReplicaNet has direct access to ReplicaObject classes */
friend class ReplicaNetPrivate;     /* ReplicaNet has direct access to ReplicaObject classes */
friend struct SessionUnique;        /* ReplicaNet has direct access to ReplicaObject classes */
friend class DataBlock;

// Functions
    // Safe to call multiple times
    virtual void PreRegisterDataBlocks(void);   
    // Do not call, except from within PreRegisterDataBlocks()
    virtual void RegisterDataBlocks(void);  
    void PollInternalForDistance(const SysTimeType localTime,ReplicaObject *observer,const int sessionID);


// Variables
    bool mIsMaster;     
    int mUniqueID;      
    int mSessionID;     
    ReplicaNet *mBoundReplicaNet;   
    bool mBeingDeleted;
protected:
    bool mDataBlocksRegistered;
private:
    bool mFlagForLaterMigration;    
    void *mOpaquePointer;
    bool mOpaquePointerSet;
    bool mIsReliable;
    bool mIsCertain;
    bool mIsOrdered;
    int mTryingToGiveTo;
    bool mObjectHasBeenAdded;   
    bool mEnableLoadBalancing;
    float mLoadScore;
    bool mEnableLoadBalancingDefault;
    float mLoadScoreDefault;
    int mReflectSessionID;      
    float mDistanceToSessionPropagate;
    float mDistanceToSessionPropagateDefault;
    float mDistanceToSessionPropagateOuter;
    float mDistanceToSessionPropagateOuterDefault;
    bool mSessionPropagationFilter;

    std::vector<DataBlock *> mAutoRegister;
    // std::vector is used for mDataBlocks to allow fast constant time lookups by index.
    std::vector<DataBlock *> mDataBlocks;   
    std::set<int> mSessionPropagationFilterIDs;
    // These delay slots are for those pending create class or delete class messages that have not been sent yet.
    std::set<int> mSessionPropagationFilterDelaySlotAdd;
    std::set<int> mSessionPropagationFilterDelaySlotRemove;

    // Distance based optimisations
    bool mEnableDistanceBased;
    SysTimeType mDistanceBasedPollTime;
    SysTimeType mDistanceBasedLastTime;

    bool mMasterOrReplicaDataBlockPollDone;

    char *mFullyQualifiedName;
    bool mPostObjectCreateDone;
    
    std::set<int> mObserverFor;     // The session IDs that are using this object as an observer

    int mProcessingDataBlocksFromSessionID;
    bool mDelayDelete;
    float mDelayDeleteSeconds;
    SysTimeType mDelayDeleteTime;   // The local time to do the delete
    bool mUpdateSendDormant;

    bool mDormantDelayActive;
    bool mDormantDelayState;
    float mDormantDelaySeconds;
    SysTimeType mDormantDelayTime;

    unsigned int mBand;

    bool mGetNewSessionIDAndUniqueIDCalled;

    static bool mDelayIDFetch;
    static bool mDelayBind;
};

} // namespace RNReplicaNet

#endif