ReadyEvent.h

Go to the documentation of this file.

#include "NativeFeatureIncludes.h"
#if _RAKNET_SUPPORT_ReadyEvent==1

#ifndef __READY_EVENT_H
#define __READY_EVENT_H

#include "PluginInterface2.h"
#include "DS_OrderedList.h"

namespace RakNet {

class RakPeerInterface;


enum ReadyEventSystemStatus
{
    RES_NOT_WAITING,
    RES_WAITING,
    RES_READY,
    RES_ALL_READY,

    RES_UNKNOWN_EVENT,
};

class ReadyEvent : public PluginInterface2
{
public:
    // GetInstance() and DestroyInstance(instance*)
    STATIC_FACTORY_DECLARATIONS(ReadyEvent)

    // Constructor
    ReadyEvent();

    // Destructor
    virtual ~ReadyEvent();

    // --------------------------------------------------------------------------------------------
    // User functions
    // --------------------------------------------------------------------------------------------
    bool SetEvent(int eventId, bool isReady);

    bool ForceCompletion(int eventId);

    bool DeleteEvent(int eventId);

    bool IsEventSet(int eventId);

    bool IsEventCompletionProcessing(int eventId) const;

    bool IsEventCompleted(int eventId) const;

    bool HasEvent(int eventId);

    unsigned GetEventListSize(void) const;

    int GetEventAtIndex(unsigned index) const;

    bool AddToWaitList(int eventId, SystemAddress address);
    
    bool RemoveFromWaitList(int eventId, SystemAddress address);

    bool IsInWaitList(int eventId, SystemAddress address);
    
    unsigned GetRemoteWaitListSize(int eventId) const;

    SystemAddress GetFromWaitListAtIndex(int eventId, unsigned index) const;
        
    ReadyEventSystemStatus GetReadyStatus(int eventId, SystemAddress address);

    void SetSendChannel(unsigned char newChannel);

    // ---------------------------- ALL INTERNAL AFTER HERE ----------------------------
    struct RemoteSystem
    {
        MessageID lastSentStatus, lastReceivedStatus;
        SystemAddress systemAddress;
    };
    static int RemoteSystemCompBySystemAddress( const SystemAddress &key, const RemoteSystem &data );
    struct ReadyEventNode
    {
        int eventId; // Sorted on this
        MessageID eventStatus;
        DataStructures::OrderedList<SystemAddress,RemoteSystem,ReadyEvent::RemoteSystemCompBySystemAddress> systemList;
    };
    static int ReadyEventNodeComp( const int &key, ReadyEvent::ReadyEventNode * const &data );


protected:
    // --------------------------------------------------------------------------------------------
    // Packet handling functions
    // --------------------------------------------------------------------------------------------
    virtual PluginReceiveResult OnReceive(Packet *packet);
    virtual void OnClosedConnection(const SystemAddress &systemAddress, RakNetGUID rakNetGUID, PI2_LostConnectionReason lostConnectionReason );
    virtual void OnRakPeerShutdown(void);
    
    void Clear(void);
    /*
    bool AnyWaitersCompleted(unsigned eventIndex) const;
    bool AllWaitersCompleted(unsigned eventIndex) const;
    bool AllWaitersReady(unsigned eventIndex) const;
    void SendAllReady(unsigned eventId, SystemAddress address);
    void BroadcastAllReady(unsigned eventIndex);
    void SendReadyStateQuery(unsigned eventId, SystemAddress address);
    void BroadcastReadyUpdate(unsigned eventIndex);
    bool AddToWaitListInternal(unsigned eventIndex, SystemAddress address);
    bool IsLocked(unsigned eventIndex) const;
    bool IsAllReadyByIndex(unsigned eventIndex) const;
    */

    void SendReadyStateQuery(unsigned eventId, SystemAddress address);
    void SendReadyUpdate(unsigned eventIndex, unsigned systemIndex, bool forceIfNotDefault);
    void BroadcastReadyUpdate(unsigned eventIndex, bool forceIfNotDefault);
    void RemoveFromAllLists(SystemAddress address);
    void OnReadyEventQuery(Packet *packet);
    void PushCompletionPacket(unsigned eventId);
    bool AddToWaitListInternal(unsigned eventIndex, SystemAddress address);
    void OnReadyEventForceAllSet(Packet *packet);
    void OnReadyEventPacketUpdate(Packet *packet);
    void UpdateReadyStatus(unsigned eventIndex);
    bool IsEventCompletedByIndex(unsigned eventIndex) const;
    unsigned CreateNewEvent(int eventId, bool isReady);
    bool SetEventByIndex(int eventIndex, bool isReady);

    DataStructures::OrderedList<int, ReadyEventNode*, ReadyEvent::ReadyEventNodeComp> readyEventNodeList;
    unsigned char channel;
};

} // namespace RakNet

#endif

#endif // _RAKNET_SUPPORT_*