DataBlock.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 __DATABLOCK_H__
#define __DATABLOCK_H__
#include <string>

#include "RNPlatform/Inc/SysTime.h"
#include "RNPlatform/Inc/MinimalRTTI.h"

namespace RNReplicaNet
{

class MessageHelper;
class DynamicMessageHelper;
class ReplicaNet;
class ReplicaObject;

const int kDataBlockReason_SomeoneJoined            = 0;    
const int kDataBlockReason_SomeoneLeft              = 1;    
const int kDataBlockReason_NormalPoll               = 2;    
const int kDataBlockReason_CalculateReplicaPoll     = 4;    
const int kDataBlockReason_CalculateMasterPoll      = 5;    
const int kDataBlockReason_MasterPrepAfterTakeover  = 6;    
const int kDataBlockReason_ReplicaCallBackPoll      = 7;    
const int kDataBlockReason_ReplicaPrepAfterTakeover = 8;    
const int kDataBlockReason_RecordingNormalPoll      = 9;    
const int kDataBlockReason_AfterDataBlocksReceived  = 10;   
struct DataBlockReason;

class DataBlock
{
friend class ReplicaObject;
public:
    RN_CLASS_MINIMAL_RTTI_BASE_CLASS()
    virtual int GetThisClassType(void); // Override this to assert if someone tries to directly query this base class. It should never happen.
    DataBlock();

    virtual ~DataBlock();

    virtual void Poll(DataBlockReason *reason = 0,const bool discardOlderIncluded = false,const unsigned int discardOrder = 0);

    virtual void ParseMessage(MessageHelper *message);

    void SetVariableName(const char *name = 0);

    void BindReplicaNet(ReplicaNet *current);

    void BindReplicaObject(ReplicaObject *object);

    void SetReliableFlag(bool reliable = false);

    bool GetReliableFlag(void) const;

    void SetCertainFlag(bool certain = false);

    bool GetCertainFlag(void) const;

    void SetOrderedFlag(bool ordered = false);

    bool GetOrderedFlag(void) const;

    void SetDiscardOlder(const int windowBits = 0);

    int GetDiscardOlder(void) const;

    void SetAutomaticUpdatesFlag(bool automatic = true);

    bool GetAutomaticUpdatesFlag(void) const;

    virtual void GiveDeltaHint(void *pdata,int dataLen);

    void GiveDeltaHint(float delta)
    {
        GiveDeltaHint(&delta,sizeof(delta));
    }

    enum ContinuityBreakTypes
    {
        kStop = 1,              
        kSuddenChange = 2,      
        kTeleport = 4           
    };

    virtual void ContinuityBreak(unsigned char breakTypes);

    void SetForceReflectionUpdate(const bool enable = false);

    bool GetForceReflectionUpdate(void);

    void SetReflectionMasterUpdate(const bool enable = false);

    bool GetReflectionMasterUpdate(void);

    virtual bool IsAttached(void *data);

    virtual bool IsAllocated(void) const;

    void SetIsAllocated(const bool isAllocated = true);


    void SetUpdateDelayMinimum(const float delay = 0.0f);

    float GetUpdateDelayMinimum(void) const;

    void SetForceSendMaximumUpdates(const int updates = 0);

    int GetForceSendMaximumUpdates(void) const;

    void SetForceSendTimeDelay(const float delay = 0.0f);

    float GetForceSendTimeDelay(void) const;

    void SetBand(const unsigned int band = 0);

    unsigned int GetBand(void) const;


    bool ShouldDiscard(MessageHelper *message);

    virtual void OwnerChanged(const int sessionID);

    bool GetDiscardThisUpdate(void) const;

protected:  // User defined DataBlocks have access to these variables.
    void SetID(int id);

    const char *GetROName(ReplicaObject *from = 0);

    void EmitBaseDebugInfo(const char *name,const char *className,DataBlockReason *reason);
    void EmitBaseDebugInfoUpdates(const char *name,const char *className,DataBlockReason *reason);

    std::string GetVariableName(void);

    short mID;
    ReplicaNet *mBoundReplicaNet;
    ReplicaObject *mBoundObject;
    bool mReliable;
    bool mCertain;
    bool mOrdered;
    bool mAutomaticUpdates;
    bool mIsAllocated;
    bool mDebugOn;
    char *mDebugText;
    float mUpdateDelayMinimum;
    int mForceSendMaximumUpdates;
    float mForceSendTimeDelay;
    char *mVariableName;
    unsigned int mBand;
    int mDiscardOlder;
    unsigned int mDiscardOlderMidPoint;
    unsigned int mDiscardOlderEndPoint;
    size_t mDiscardOlderRealSize;
    unsigned int mLocalisedOrderingSent;
    unsigned int mLocalisedOrderingReceived;
    bool mDiscardThisUpdate;

    bool mForceReflectionUpdate;
    bool mReflectionMasterUpdate;
};

struct DataBlockReason
{
public:
    DataBlockReason(int code = kDataBlockReason_NormalPoll,int session = -1,ReplicaObject *object = 0)
    {
        mReasonCode = code;
        mSessionReference = session;
        mObserver = object;
        mFloatValue = 0.0f;
        mFloatTime = -1.0f;
    }

    int mReasonCode;                        
    int mSessionReference;                  
    DynamicMessageHelper *mMessageHelper;   
    ReplicaObject *mObserver;               
    SysTimeType mFloatValue;                
    SysTimeType mFloatTime;
    SysTimeType mFloatLocalTime;
};

// This macro is used to finish any data block registration for a ReplicaObject
/* _RO_DO_REGISTERBLOCK_END macro starts here */
#define _RO_DO_REGISTERBLOCK_END()  \
        RegisterDataBlock(datablock);   \
    }
/* _RO_DO_REGISTERBLOCK_END macro ends here */

} // namespace RNReplicaNet

#endif