room.h

Go to the documentation of this file.

// © 2019-2024 Diarkis Inc. All rights reserved.
 
#pragma once
 
#include "diarkis/common.h"
#include "diarkis/logging/LoggerFactory.h"
#include "diarkis/network/tcp.h"
#include "diarkis/network/udp.h"
#include "diarkis/system/result.h"
using namespace Diarkis::Network;
 
// ADD NAMESPACE NAME TAG
namespace Diarkis
{
namespace Modules
{
class IDiarkisRoom
{
   public:
    virtual ~IDiarkisRoom() {}
 
    virtual void SetLoggerFactory(const std::shared_ptr<IDiarkisLoggerFactory>& loggerFactory, const Diarkis::StdString& loggerNameSuffix) = 0;
 
    virtual bool SetupAsTcp(const std::shared_ptr<IDiarkisTcp>& tcp) = 0;
 
    virtual bool SetupAsUdp(const std::shared_ptr<IDiarkisUdp>& udp) = 0;
 
    virtual bool SetTcp(const std::shared_ptr<IDiarkisTcp>& tcp) = 0;
 
    virtual bool SetUdp(const std::shared_ptr<IDiarkisUdp>& udp) = 0;
 
    virtual std::shared_ptr<IDiarkisEvent<const DiarkisRoomCreationEventArgs&>> GetCreateEvent() = 0;
 
    virtual std::shared_ptr<IDiarkisEvent<const DiarkisRoomJoinEventArgs&>> GetJoinEvent() = 0;
 
    virtual std::shared_ptr<IDiarkisEvent<const DiarkisRoomSuccessEventArgs&>> GetLeaveEvent() = 0;
 
    virtual std::shared_ptr<IDiarkisEvent<void*>> GetMigrateStartEvent() = 0;
 
    virtual std::shared_ptr<IDiarkisEvent<const DiarkisRoomMigrateCompleteEventArgs&>> GetMigrateCompleteEvent() = 0;
 
    virtual std::shared_ptr<IDiarkisEvent<const DiarkisPayloadEventArgs&>> GetMemberJoinEvent() = 0;
 
    virtual std::shared_ptr<IDiarkisEvent<const DiarkisPayloadEventArgs&>> GetMemberLeaveEvent() = 0;
 
    virtual std::shared_ptr<IDiarkisEvent<const DiarkisPayloadEventArgs&>> GetMemberBroadcastEvent() = 0;
 
    virtual std::shared_ptr<IDiarkisEvent<const DiarkisPayloadEventArgs&>> GetMemberMessageEvent() = 0;
 
    virtual std::shared_ptr<IDiarkisEvent<const DiarkisPayloadEventArgs&>> GetMemberExclusiveBroadcastEvent() = 0;
    virtual std::shared_ptr<IDiarkisEvent<const DiarkisPayloadEventArgs&>> GetMemberExclusiveMessageEvent() = 0;
 
    virtual std::shared_ptr<IDiarkisEvent<const DiarkisRoomSuccessEventArgs&>> GetUpdatePropertiesEvent() = 0;
 
    virtual std::shared_ptr<IDiarkisEvent<const DiarkisRoomPropertiesEventArgs&>> GetGetPropertiesEvent() = 0;
 
    virtual std::shared_ptr<IDiarkisEvent<const DiarkisRoomPropertiesEventArgs&>> GetUpdateSyncPropertiesEvent() = 0;
 
    virtual std::shared_ptr<IDiarkisEvent<const DiarkisRoomIncrementPropertyEventArgs&>> GetIncrementPropertyEvent() = 0;
 
    virtual std::shared_ptr<IDiarkisEvent<const DiarkisRoomIncrementPropertySyncEventArgs&>> GetIncrementPropertySyncEvent() = 0;
 
    virtual std::shared_ptr<IDiarkisEvent<const DiarkisRoomGetOwnerIDEventArgs&>> GetOwnerIDEvent() = 0;
 
    virtual std::shared_ptr<IDiarkisEvent<const DiarkisRoomMemberIDsEventArgs&>> GetMemberIDSEvent() = 0;
 
    virtual std::shared_ptr<IDiarkisEvent<const DiarkisRoomNumberOfMembersEventArgs&>> GetNumberOfMembersEvent() = 0;
 
    virtual std::shared_ptr<IDiarkisEvent<const DiarkisRoomPayloadEventArgs&>> GetRegisterEvent() = 0;
 
    virtual std::shared_ptr<IDiarkisEvent<const DiarkisRoomFindByTypeEventArgs&>> GetFindByTypeEvnet() = 0;
 
    virtual std::shared_ptr<IDiarkisEvent<const DiarkisRoomPayloadEventArgs&>> GetReserveEvent() = 0;
 
    virtual std::shared_ptr<IDiarkisEvent<const DiarkisRoomPayloadEventArgs&>> GetCancelReservationEvent() = 0;
 
    virtual std::shared_ptr<IDiarkisEvent<const DiarkisRoomPayloadEventArgs&>> GetChatSyncResponseEvent() = 0;
 
    virtual std::shared_ptr<IDiarkisEvent<const DiarkisRoomChatEventArgs&>> GetChatSyncEvent() = 0;
 
    virtual std::shared_ptr<IDiarkisEvent<const DiarkisRoomChatLogEventArgs&>> GetChatLogEvent() = 0;
 
    virtual std::shared_ptr<IDiarkisEvent<const DiarkisP2PEventArgs&>> GetStartP2PSyncEvent() = 0;
 
    virtual std::shared_ptr<IDiarkisEvent<const DiarkisRoomGetOwnerIDEventArgs&>> GetOwnerChangeEvent() = 0;
 
    virtual std::shared_ptr<IDiarkisEvent<const DiarkisRoomObjectUpdateEventArgs&>> GetObjectUpdateEvent() = 0;
 
    virtual std::shared_ptr<IDiarkisEvent<const DiarkisRoomObjectUpdateResponseEventArgs&>> GetObjectUpdateResponseEvent() = 0;
 
    virtual std::shared_ptr<IDiarkisEvent<const DiarkisPayloadEventArgs&>> GetRelayEvent() = 0;
 
    virtual std::shared_ptr<IDiarkisEvent<const DiarkisPayloadEventArgs&>> GetRelayToEvent() = 0;
 
    virtual std::shared_ptr<IDiarkisEvent<void*>> GetOfflineEvent() = 0;
 
    virtual Diarkis::System::Result Create(uint16_t maxMembers, bool allowEmpty, bool join, uint16_t ttl, uint32_t interval = 200) = 0;
 
    virtual Diarkis::System::Result Join(const char* roomID, const uint8_t* message, size_t messageSize) = 0;
 
    virtual Diarkis::System::Result Join(const Diarkis::StdString& roomID, const Diarkis::StdVector<uint8_t>& message) = 0;
 
    virtual Diarkis::System::Result JoinRandom(uint16_t maxMembers,
                                               uint16_t ttl,
                                               const uint8_t* message,
                                               size_t messageSize,
                                               uint32_t interval = 200,
                                               bool allowEmpty = false) = 0;
 
    virtual Diarkis::System::Result JoinRandom(uint16_t maxMembers,
                                               uint16_t ttl,
                                               const Diarkis::StdVector<uint8_t>& message,
                                               uint32_t interval = 200,
                                               bool allowEmpty = false) = 0;
 
    virtual Diarkis::System::Result Leave(const char* roomID, const uint8_t* message, size_t messageSize) = 0;
 
    virtual Diarkis::System::Result Leave(const Diarkis::StdString& roomID, const Diarkis::StdVector<uint8_t>& message) = 0;
 
    virtual Diarkis::System::Result BroadcastTo(const char* roomID, const uint8_t* message, size_t messageSize, bool reliable = true) = 0;
 
    virtual Diarkis::System::Result BroadcastTo(const Diarkis::StdString& roomID, const Diarkis::StdVector<uint8_t>& message, bool reliable = true) = 0;
 
    virtual Diarkis::System::Result ExclusiveBroadcastTo(const Diarkis::StdString& roomID,
                                                         const Diarkis::StdVector<uint8_t>& message,
                                                         bool reliable = true) = 0;
    virtual Diarkis::System::Result ExclusiveBroadcastTo(const char* roomID, const uint8_t* message, size_t messageSize, bool reliable = true) = 0;
    virtual Diarkis::System::Result ExclusiveMessageTo(const Diarkis::StdString& roomID,
                                                       const Diarkis::StdVector<Diarkis::StdString>& memberIDs,
                                                       const Diarkis::StdVector<uint8_t>& message,
                                                       bool reliable = true) = 0;
    virtual Diarkis::System::Result ExclusiveMessageTo(const char* roomID,
                                                       const char** memberIDs,
                                                       size_t memberIDsCount,
                                                       const uint8_t* message,
                                                       size_t messageSize,
                                                       bool reliable = true) = 0;
 
    virtual Diarkis::System::Result MessageTo(const char* roomID,
                                              const char** memberIDs,
                                              size_t memberIDsCount,
                                              const uint8_t* message,
                                              size_t messageSize,
                                              bool reliable = true) = 0;
 
    virtual Diarkis::System::Result MessageTo(const Diarkis::StdString& roomID,
                                              const Diarkis::StdVector<Diarkis::StdString>& memberIDs,
                                              const Diarkis::StdVector<uint8_t>& message,
                                              bool reliable = true) = 0;
 
    virtual Diarkis::System::Result Relay(const uint8_t* message, size_t messageSize, bool reliable = true) = 0;
 
    virtual Diarkis::System::Result Relay(const Diarkis::StdVector<uint8_t>& message, bool reliable = true) = 0;
 
    virtual Diarkis::System::Result RelayTo(const char* roomID,
                                            const char** memberIDs,
                                            size_t memberIDsCount,
                                            const uint8_t* message,
                                            size_t messageSize,
                                            bool reliable = true) = 0;
 
    virtual Diarkis::System::Result RelayTo(const Diarkis::StdString& roomID,
                                            const Diarkis::StdVector<Diarkis::StdString>& memberIDs,
                                            const Diarkis::StdVector<uint8_t>& message,
                                            bool reliable = true) = 0;
 
    virtual Diarkis::System::Result UpdateProperties(const char* roomID,
                                                     const Diarkis::StdUnorderedMap<Diarkis::StdString, Diarkis::StdVector<uint8_t>>& properties,
                                                     bool sync = false) = 0;
 
    virtual Diarkis::System::Result UpdateProperties(const Diarkis::StdString& roomID,
                                                     const Diarkis::StdUnorderedMap<Diarkis::StdString, Diarkis::StdVector<uint8_t>>& properties,
                                                     bool sync = false) = 0;
 
    virtual Diarkis::System::Result GetProperties(const char* roomID, const char** propertyNames, size_t propertyCount) = 0;
 
    virtual Diarkis::System::Result GetProperties(const Diarkis::StdString& roomID, const Diarkis::StdVector<Diarkis::StdString>& propertyNames) = 0;
 
    virtual Diarkis::System::Result IncrementProperty(const char* propertyName, int64_t delta, bool sync) = 0;
 
    virtual Diarkis::System::Result IncrementProperty(Diarkis::StdString propertyName, int64_t delta, bool sync) = 0;
 
    virtual Diarkis::System::Result GetOwnerID() = 0;
 
    virtual Diarkis::System::Result GetMemberIDs() = 0;
 
    virtual Diarkis::System::Result GetNumberOfMembers(const char* roomID) = 0;
 
    virtual Diarkis::System::Result GetNumberOfMembers(const Diarkis::StdString& roomID) = 0;
 
    virtual Diarkis::System::Result Migrate() = 0;
 
    virtual Diarkis::System::Result Move(Diarkis::StdString roomID_,
                                         const Diarkis::StdVector<uint8_t>& leaveMessage,
                                         const Diarkis::StdVector<uint8_t>& joinMessage) = 0;
 
    virtual Diarkis::System::Result Register(uint32_t roomType, const char* roomName, const char* roomMetadata) = 0;
 
    virtual Diarkis::System::Result Register(uint32_t roomType, const Diarkis::StdString& roomName, const Diarkis::StdString& roomMetadata) = 0;
 
    virtual Diarkis::System::Result FindRoomsByType(uint32_t roomType, uint32_t limit) = 0;
 
    virtual Diarkis::System::Result Reserve(const char** userIDs, size_t userIDsSize) = 0;
 
    virtual Diarkis::System::Result Reserve(const Diarkis::StdVector<Diarkis::StdString>& userIDs) = 0;
 
    virtual Diarkis::System::Result CancelReservation(const char* cancelRoomID, const char** userIDs, size_t userIDsSize) = 0;
 
    virtual Diarkis::System::Result CancelReservation(const Diarkis::StdString& cancelRoomID, const Diarkis::StdVector<Diarkis::StdString>& userIDs) = 0;
 
    virtual Diarkis::System::Result CancelReservation(const Diarkis::StdVector<Diarkis::StdString>& userIDs) = 0;
 
    virtual Diarkis::System::Result SendChatMessage(const char* message) = 0;
 
    virtual Diarkis::System::Result SendChatMessage(const Diarkis::StdString& message) = 0;
 
    virtual Diarkis::System::Result GetChatLog() = 0;
 
    virtual Diarkis::System::Result StartP2PSync(uint8_t linkedClients = 0) = 0;
 
    virtual Diarkis::System::Result UpdateObject(RoomObjectMode mode,
                                                 const Diarkis::StdString& name,
                                                 const Diarkis::StdUnorderedMap<Diarkis::StdString, double>& obj,
                                                 bool reliable = true) = 0;
 
    virtual const Diarkis::StdString& GetRoomID() = 0;
 
    virtual void SetRoomID(const char* roomID) = 0;
 
    virtual void SetRoomID(const Diarkis::StdString& roomID) = 0;
 
    virtual void RegisterCustomMessagePush(uint8_t version, uint16_t command, std::function<void(const Diarkis::StdVector<uint8_t>&)> callback) = 0;
};
 
extern "C"
{
    DIARKIS_EXPORT IDiarkisRoom* DiarkisCreateRoom();
}
 
}  // namespace Modules
}  // namespace Diarkis
   // ADD NAMESPACE } TAG