RPC4Plugin.h

Go to the documentation of this file.

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

#ifndef __RPC_4_PLUGIN_H
#define __RPC_4_PLUGIN_H

#include "PluginInterface2.h"
#include "PacketPriority.h"
#include "RakNetTypes.h"
#include "BitStream.h"
#include "RakString.h"
#include "NetworkIDObject.h"
#include "DS_Hash.h"
#include "DS_OrderedList.h"

#ifdef _MSC_VER
#pragma warning( push )
#endif


namespace RakNet
{
class RakPeerInterface;
class NetworkIDManager;

    enum RPCErrorCodes
    {
        RPC_ERROR_FUNCTION_NOT_REGISTERED,
    };

    class RAK_DLL_EXPORT RPC4GlobalRegistration
    {
    public:
        RPC4GlobalRegistration(const char* uniqueID, void ( *functionPointer ) ( RakNet::BitStream *userData, Packet *packet ));

        RPC4GlobalRegistration(const char* uniqueID, void ( *functionPointer ) ( RakNet::BitStream *userData, Packet *packet ), int callPriority);

        RPC4GlobalRegistration(const char* uniqueID, void ( *functionPointer ) ( RakNet::BitStream *userData, RakNet::BitStream *returnData, Packet *packet ));

        RPC4GlobalRegistration(const char* uniqueID, MessageID messageId);
    };

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

        // Constructor
        RPC4();

        // Destructor
        virtual ~RPC4();

        bool RegisterFunction(const char* uniqueID, void ( *functionPointer ) ( RakNet::BitStream *userData, Packet *packet ));

        void RegisterSlot(const char *sharedIdentifier, void ( *functionPointer ) ( RakNet::BitStream *userData, Packet *packet ), int callPriority);

        bool RegisterBlockingFunction(const char* uniqueID, void ( *functionPointer ) ( RakNet::BitStream *userData, RakNet::BitStream *returnData, Packet *packet ));

        void RegisterLocalCallback(const char* uniqueID, MessageID messageId);

        bool UnregisterFunction(const char* uniqueID);

        bool UnregisterBlockingFunction(const char* uniqueID);

        bool UnregisterLocalCallback(const char* uniqueID, MessageID messageId);

        bool UnregisterSlot(const char* sharedIdentifier);

        void CallLoopback( const char* uniqueID, RakNet::BitStream * bitStream );

        void Call( const char* uniqueID, RakNet::BitStream * bitStream, PacketPriority priority, PacketReliability reliability, char orderingChannel, const AddressOrGUID systemIdentifier, bool broadcast );

        bool CallBlocking( const char* uniqueID, RakNet::BitStream * bitStream, PacketPriority priority, PacketReliability reliability, char orderingChannel, const AddressOrGUID systemIdentifier, RakNet::BitStream *returnData );

        void Signal(const char *sharedIdentifier, RakNet::BitStream * bitStream, PacketPriority priority, PacketReliability reliability, char orderingChannel, const AddressOrGUID systemIdentifier, bool broadcast, bool invokeLocal);

        void InterruptSignal(void);

        struct LocalCallback
        {
            MessageID messageId;
            DataStructures::OrderedList<RakNet::RakString,RakNet::RakString> functions;
        };
        static int LocalCallbackComp(const MessageID &key, LocalCallback* const &data );

        // Callable object, along with priority to call relative to other objects
        struct LocalSlotObject
        {
            LocalSlotObject() {}
            LocalSlotObject(unsigned int _registrationCount,int _callPriority, void ( *_functionPointer ) ( RakNet::BitStream *userData, Packet *packet ))
            {registrationCount=_registrationCount;callPriority=_callPriority;functionPointer=_functionPointer;}
            ~LocalSlotObject() {}

            // Used so slots are called in the order they are registered
            unsigned int registrationCount;
            int callPriority;
            void ( *functionPointer ) ( RakNet::BitStream *userData, Packet *packet );
        };

        static int LocalSlotObjectComp( const LocalSlotObject &key, const LocalSlotObject &data );

        struct LocalSlot
        {
            DataStructures::OrderedList<LocalSlotObject,LocalSlotObject,LocalSlotObjectComp> slotObjects;
        };
        DataStructures::Hash<RakNet::RakString, LocalSlot*,256, RakNet::RakString::ToInteger> localSlots;

    protected:

        // --------------------------------------------------------------------------------------------
        // Packet handling functions
        // --------------------------------------------------------------------------------------------
        virtual void OnAttach(void);
        virtual PluginReceiveResult OnReceive(Packet *packet);

        DataStructures::Hash<RakNet::RakString, void ( * ) ( RakNet::BitStream *, Packet * ),64, RakNet::RakString::ToInteger> registeredNonblockingFunctions;
        DataStructures::Hash<RakNet::RakString, void ( * ) ( RakNet::BitStream *, RakNet::BitStream *, Packet * ),64, RakNet::RakString::ToInteger> registeredBlockingFunctions;
        DataStructures::OrderedList<MessageID,LocalCallback*,RPC4::LocalCallbackComp> localCallbacks;

        RakNet::BitStream blockingReturnValue;
        bool gotBlockingReturnValue;

        DataStructures::HashIndex GetLocalSlotIndex(const char *sharedIdentifier);

        unsigned int nextSlotRegistrationCount;

        bool interruptSignal;

        void InvokeSignal(DataStructures::HashIndex functionIndex, RakNet::BitStream *serializedParameters, Packet *packet);
    };

} // End namespace

#endif

#ifdef _MSC_VER
#pragma warning( pop )
#endif

#endif // _RAKNET_SUPPORT_*