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 */
#ifndef __REPLICAOBJECT_H__
#define __REPLICAOBJECT_H__
#include "RNPlatform/Inc/DLLExportAPI.h"

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

#include "RNPlatform/Inc/ThreadClass.h"

namespace RNReplicaNet
{

class ReplicaNet;
class ReplicaNetPrivate;
class DataBlock;
struct s_RO_RegistryBlock;

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

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

    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);

    void GiveDeltaHint(float &variable,float delta);

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

    void UpdateSetReliable(void);

    void UpdateSetCertain(void);

    void UpdateSetUnreliable(void);

    bool UpdateIsReliable(void);

    bool UpdateIsCertain(void);

    bool UpdateIsUnreliable(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 SetPropagateToSessionDistanceDefault(const float distance = kReplicaObject_InfiniteDistance);

    float GetPropagateToSessionDistance(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(void);

    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;

protected:
    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_SetupPropagateDistance(void);
    virtual void _Internal_SetupPropagateDistanceDefault(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);

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 float 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;
    int mTryingToGiveTo;
    bool mObjectHasBeenAdded;   
    bool mEnableLoadBalancing;
    float mLoadScore;
    bool mEnableLoadBalancingDefault;
    float mLoadScoreDefault;
    int mReflectSessionID;      
    float mDistanceToSessionPropagate;
    float mDistanceToSessionPropagateDefault;
    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;
    float mDistanceBasedPollTime;
    float 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;
    float mDelayDeleteTime; // The local time to do the delete
    bool mUpdateSendDormant;

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

    unsigned int mBand;
};

} // namespace RNReplicaNet

#endif

---