ReadyEvent.h

Go to the documentation of this file.

/*
 *  Original work: Copyright (c) 2014, Oculus VR, Inc.
 *  All rights reserved.
 *
 *  This source code is licensed under the BSD-style license found in the
 *  RakNet License.txt file in the licenses directory of this source tree. An additional grant 
 *  of patent rights can be found in the RakNet Patents.txt file in the same directory.
 *
 *
 *  Modified work: Copyright (c) 2017, SLikeSoft UG (haftungsbeschränkt)
 *
 *  This source code was modified by SLikeSoft. Modifications are licensed under the MIT-style
 *  license found in the license.txt file in the root directory of this source tree.
 */



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

#ifndef __READY_EVENT_H
#define __READY_EVENT_H

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

namespace SLNet {

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

    void 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, RakNetGUID guid);
    
    bool RemoveFromWaitList(int eventId, RakNetGUID guid);

    bool IsInWaitList(int eventId, RakNetGUID guid);
    
    unsigned GetRemoteWaitListSize(int eventId) const;

    RakNetGUID GetFromWaitListAtIndex(int eventId, unsigned index) const;
        
    ReadyEventSystemStatus GetReadyStatus(int eventId, RakNetGUID guid);

    void SetSendChannel(unsigned char newChannel);

    // ---------------------------- ALL INTERNAL AFTER HERE ----------------------------
    struct RemoteSystem
    {
        MessageID lastSentStatus, lastReceivedStatus;
        RakNetGUID rakNetGuid;
    };
    static int RemoteSystemCompByGuid( const RakNetGUID &key, const RemoteSystem &data );
    struct ReadyEventNode
    {
        int eventId; // Sorted on this
        MessageID eventStatus;
        DataStructures::OrderedList<RakNetGUID,RemoteSystem,ReadyEvent::RemoteSystemCompByGuid> 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, RakNetGUID guid);
    void BroadcastAllReady(unsigned eventIndex);
    void SendReadyStateQuery(unsigned eventId, RakNetGUID guid);
    void BroadcastReadyUpdate(unsigned eventIndex);
    bool AddToWaitListInternal(unsigned eventIndex, RakNetGUID guid);
    bool IsLocked(unsigned eventIndex) const;
    bool IsAllReadyByIndex(unsigned eventIndex) const;
    */

    void SendReadyStateQuery(unsigned eventId, RakNetGUID guid);
    void SendReadyUpdate(unsigned eventIndex, unsigned systemIndex, bool forceIfNotDefault);
    void BroadcastReadyUpdate(unsigned eventIndex, bool forceIfNotDefault);
    void RemoveFromAllLists(RakNetGUID guid);
    void OnReadyEventQuery(Packet *packet);
    void PushCompletionPacket(unsigned eventId);
    bool AddToWaitListInternal(unsigned eventIndex, RakNetGUID guid);
    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 SLNet

#endif

#endif // _RAKNET_SUPPORT_*