exodus/1NiM-WatingRoom-WatchController
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

refactoring message

Browse Source
This commit is contained in:
Gustice
2025-11-10 10:43:13 +01:00
parent 598f1262d7
commit f064794499
13 changed files with 1968 additions and 1626 deletions
Download Patch File Download Diff File Expand all files Collapse all files
components/spit/include/SPITObject.h
+5 -4
View File
@@ -15,10 +15,11 @@
#define SPITOBJECT_H
#include "SPITType.h"
#include "SPIT_Message.h"
#include "spit_message.hpp"
#include "SpitRepo.hpp"
using namespace std;
using namespace spit;
class SPITObjectListener;
@@ -138,9 +139,9 @@ class SPITObject {
bool setDelay(long long p_Delay);
bool setDuration(long long p_Duration);
bool setMessageOP(SPIT_Message::ReportSPITObject *p_ReportSPITObject);
void fillMessageOP(SPIT_Message::ReportSPITObject &p_ReportSPITObject);
void fillMessageOP(SPIT_Message::RemoveSPITObject &p_RemoveSPITObject);
bool setMessageOP(Message::ReportObject *p_ReportSPITObject);
void fillMessageOP(Message::ReportObject &p_ReportSPITObject);
void fillMessageOP(Message::RemoveObject &p_RemoveSPITObject);
};
#endif /* SPITOBJECT_H */
components/spit/include/SPITType.h
+5 -4
View File
@@ -15,10 +15,11 @@
#define SPITTYPE_H
#include "SPITSocket.h"
#include "SPIT_Message.h"
#include "spit_message.hpp"
#include "SpitRepo.hpp"
using namespace std;
using namespace spit;
class SPITTypeListener;
@@ -96,9 +97,9 @@ class SPITType {
*/
bool setActionAssigned(bool p_ActionAssigned);
bool setMessageOP(SPIT_Message::ReportSPITType &reportSpitType);
void fillMessageOP(SPIT_Message::ReportSPITType &smReportSpitType) const;
void fillMessageOP(SPIT_Message::RemoveSPITType &smRemoveSpitType) const;
bool setMessageOP(Message::ReportType &reportSpitType);
void fillMessageOP(Message::ReportType &smReportSpitType) const;
void fillMessageOP(Message::RemoveType &smRemoveSpitType) const;
};
#endif /* SPITTYPE_H */
components/spit/include/SPIT_Client.h
+24 -23
View File
@@ -19,12 +19,13 @@
#include "SPITPlayer.h"
#include "SPITSocket.h"
#include "SPITType.h"
#include "SPIT_Message.h"
#include "spit_message.hpp"
#include "SpitRepo.hpp"
#include <memory>
#include <vector>
using namespace std;
using namespace spit;
class SPIT_Client : I_SAD_Client {
@@ -112,7 +113,7 @@ class SPIT_Client : I_SAD_Client {
uint8_t m_MessageNumber_Send{1};
int m_MessageNumber_Received{-1}; // set to -1 because the first received message will set the number (1..255)
vector<unique_ptr<SPIT_Message>> m_OvertakingSPIT_Messages;
vector<unique_ptr<Message>> m_OvertakingSPIT_Messages;
// Server's info filled by parseConnectAnswer
string m_ServerID{};
@@ -173,7 +174,7 @@ class SPIT_Client : I_SAD_Client {
// Reconnect to the server when connection is lost see eventConnectionStatus and eventServerDetected
bool _doReconnect{}; // true = on eventServerDetected connect to the server identified by m_ServerID
public:
int sendSPITMessage(SPIT_Message::OPPart & spitMessageOPPart);
int sendSPITMessage(Message::OPPart & spitMessageOPPart);
//--------------- ServerAutoDetection SAD ---------------
public:
@@ -209,13 +210,13 @@ class SPIT_Client : I_SAD_Client {
private:
void disconnectInternal(Connection p_Cause);
void resetMessageNumberReceived();
void parseSPIT_Message(unique_ptr<SPIT_Message> p_SPITMessage);
void checkParseSPIT_Message(unique_ptr<SPIT_Message> p_SPITMessage);
void addOvertakingSPIT_Message(unique_ptr<SPIT_Message> p_SPIT_Message);
void parseConnectAnswer(SPIT_Message::ConnectAnswer &p_ConnectAnswer);
void parseDisconnect(SPIT_Message::Disconnect &p_Disconnect);
void parseWatchdog(SPIT_Message::Watchdog &p_Watchdog);
void parseWatchdogAnswer(SPIT_Message::WatchdogAnswer &p_WatchdogAnswer);
void parseSPIT_Message(unique_ptr<Message> p_SPITMessage);
void checkParseSPIT_Message(unique_ptr<Message> p_SPITMessage);
void addOvertakingSPIT_Message(unique_ptr<Message> p_SPIT_Message);
void parseConnectAnswer(Message::ConnectAnswer &p_ConnectAnswer);
void parseDisconnect(Message::Disconnect &p_Disconnect);
void parseWatchdog(Message::Watchdog &p_Watchdog);
void parseWatchdogAnswer(Message::WatchdogAnswer &p_WatchdogAnswer);
public:
/** Used internally*/
@@ -224,8 +225,8 @@ class SPIT_Client : I_SAD_Client {
void eventWatchdogLost();
//--------------- SPIT Project ---------------
private:
void parseReportSPITProject(SPIT_Message::ReportSPITProject &p_ReportSPITProject);
void parseCloseSPITProject(SPIT_Message::CloseSPITProject &p_CloseSPITProject);
void parseReportSPITProject(Message::ReportProject &p_ReportSPITProject);
void parseCloseSPITProject(Message::CloseProject &p_CloseSPITProject);
public:
/** Returns the SPITServer's project ID - may be the same as the project's name*/
@@ -236,9 +237,9 @@ class SPIT_Client : I_SAD_Client {
int getServerFramesPerSecond();
private:
void parseRequestProjectTransfer(SPIT_Message::RequestProjectTransfer &p_RequestProjectTransfer);
void parseStartProjectTransfer(SPIT_Message::StartProjectTransfer &p_StartProjectTransfer);
void parseEndProjectTransfer(SPIT_Message::EndProjectTransfer &p_EndProjectTransfer);
void parseRequestProjectTransfer(Message::RequestProjectTransfer &p_RequestProjectTransfer);
void parseStartProjectTransfer(Message::StartProjectTransfer &p_StartProjectTransfer);
void parseEndProjectTransfer(Message::EndProjectTransfer &p_EndProjectTransfer);
public:
static void sendProject(SPIT_Client *p_PtrSPIT_Client);
@@ -274,8 +275,8 @@ class SPIT_Client : I_SAD_Client {
private:
// receive SPITTypes
void parseReportSPITType(SPIT_Message::ReportSPITType &p_ReportSPITType);
void parseRemoveSPITType(SPIT_Message::RemoveSPITType &p_RemoveSPITType);
void parseReportSPITType(Message::ReportType &p_ReportSPITType);
void parseRemoveSPITType(Message::RemoveType &p_RemoveSPITType);
int sendSPITTypeInternal(SPITType &p_SPITType);
public:
@@ -297,8 +298,8 @@ class SPIT_Client : I_SAD_Client {
public:
//--------------- SPIT Objects ---------------
private:
void parseReportSPITObject(SPIT_Message::ReportSPITObject &p_ReportSPITObject);
void parseRemoveSPITObject(SPIT_Message::RemoveSPITObject &p_RemoveSPITObject);
void parseReportSPITObject(Message::ReportObject &p_ReportSPITObject);
void parseRemoveSPITObject(Message::RemoveObject &p_RemoveSPITObject);
int sendSPITObjectInternal(SPITObject *ptrSPITObject);
public:
@@ -320,10 +321,10 @@ class SPIT_Client : I_SAD_Client {
public:
//--------------- Play SPIT Objects ---------------
private:
void parsePlaySPITStart(SPIT_Message::PlaySPITStart &p_PlaySPITStart);
void parsePlaySPITObject(SPIT_Message::PlaySPITObject &p_PlaySPITObject);
void parsePlaySPITEnd(SPIT_Message::PlaySPITEnd &p_PlaySPITEnd);
void parseReportPlayStatus(SPIT_Message::ReportPlayStatus &p_ReportPlayStatus);
void parsePlaySPITStart(Message::PlayStart &p_PlaySPITStart);
void parsePlaySPITObject(Message::PlayObject &p_PlaySPITObject);
void parsePlaySPITEnd(Message::PlayEnd &p_PlaySPITEnd);
void parseReportPlayStatus(Message::ReportPlayStatus &p_ReportPlayStatus);
public:
//--------- Remote ----------
components/spit/include/SPIT_Message.h → components/spit/include/spit_message.hpp
+133 -132
View File
@@ -5,14 +5,12 @@
*/
/*
* File: SPIT_Message.h
* File: Message.h
* Author: Hagi
*
* Created on 3. April 2019, 08:51
*/
#ifndef SPIT_MESSAGE_H
#define SPIT_MESSAGE_H
#pragma once
#include <cstdlib>
#include <memory>
@@ -23,7 +21,9 @@ using namespace std;
static const string SPITID = "#spit#";
class SPIT_Message {
namespace spit {
class Message {
//----------- Header -----------
public:
class Header {
@@ -33,85 +33,86 @@ class SPIT_Message {
Header();
private:
string m_SPITID;
int m_SPITVersion{SPITVERSION};
unsigned char m_MessageNumber{};
int m_BytesCount{BYTESLENGTH};
string m_ServerID{};
string m_ClientID{};
int m_OPFlag{-1};
int m_ParseOffset{};
string mID;
int mVersion{SPITVERSION};
unsigned char mMessageNumber{};
int mBytesCount{BYTESLENGTH};
string mServerID{};
string mClientID{};
int mOpFlag{-1};
int mParseOffset{};
public:
string getSPITID() const { return m_SPITID; }
int getSPITVersion() const { return m_SPITVersion; }
unsigned char getMessageNumber() const { return m_MessageNumber; }
int getBytesCount() const { return m_BytesCount; }
string getServerID() const { return m_ServerID; }
string getClientID() const { return m_ClientID; }
int getOPFlag() const { return m_OPFlag; }
string getSPITID() const { return mID; }
int getSPITVersion() const { return mVersion; }
unsigned char getMessageNumber() const { return mMessageNumber; }
int getBytesCount() const { return mBytesCount; }
string getServerID() const { return mServerID; }
string getClientID() const { return mClientID; }
int getType() const { return mOpFlag; }
// Receive
bool parse(const std::vector<char> &message);
// Send
Header(int p_SPITVersion, int p_OPFlag);
void setMessageNumber(unsigned char p_MessageNumber) { m_MessageNumber = p_MessageNumber; }
void setServerID(string p_ID) { m_ServerID = p_ID; }
void setClientID(string p_ID) { m_ClientID = p_ID; }
void setOPFlag(int p_OPFlag) { m_OPFlag = p_OPFlag; }
Header(int p_SPITVersion, int pOpFlag);
void setMessageNumber(unsigned char p_MessageNumber) { mMessageNumber = p_MessageNumber; }
void setServerID(string p_ID) { mServerID = p_ID; }
void setClientID(string p_ID) { mClientID = p_ID; }
void setOPFlag(int pOpFlag) { mOpFlag = pOpFlag; }
bool fillBytes(std::vector<char> &message);
};
//----------- OPPart -----------
public:
class OPPart {
// Members
protected:
unique_ptr<Header> m_Header{};
int m_ParseOffset{};
int m_BytesCount;
unique_ptr<Header> mHeader{};
int mParseOffset{};
int mBytesCount;
public:
virtual ~OPPart();
Header *getHeader() const { return m_Header.get(); }
int getBytesCount() const { return m_BytesCount; }
Header *getHeader() const { return mHeader.get(); }
int getBytesCount() const { return mBytesCount; }
void setServerInfoInHeader(string clientId, string serverId) {
if (!m_Header)
if (!mHeader) {
return;
m_Header->setClientID(clientId);
m_Header->setServerID(serverId);
}
mHeader->setClientID(clientId);
mHeader->setServerID(serverId);
}
void setMessageNumber(uint8_t no) {
if (!m_Header)
if (!mHeader) {
return;
m_Header->setMessageNumber(no);
}
mHeader->setMessageNumber(no);
}
const string getServerID() const {
if (!m_Header) {
if (!mHeader) {
return "";
}
return m_Header->getServerID();
return mHeader->getServerID();
}
const string getClientID() const {
if (!m_Header) {
if (!mHeader) {
return "";
}
return m_Header->getClientID();
return mHeader->getClientID();
}
int getOPFlag() const {
if (!m_Header) {
int getType() const {
if (!mHeader) {
return -1;
}
return m_Header->getOPFlag();
return mHeader->getType();
}
// Receive
OPPart(unique_ptr<Header> p_Header, int p_OPFlag, int size);
OPPart(unique_ptr<Header> p_Header, int pOpFlag, int size);
void setHeader(int opFlag);
virtual bool parse(const std::vector<char> &message) = 0;
@@ -120,7 +121,7 @@ class SPIT_Message {
virtual bool fillBytes(std::vector<char> &message) = 0;
};
//----------- SPIT_Message -----------
//----------- Message -----------
public:
static constexpr int SPITVERSION = 1;
@@ -140,7 +141,7 @@ class SPIT_Message {
static constexpr char VALUEFLAG_INCREASE = 0x01; // increase the value
static constexpr char VALUEFLAG_DECREASE = 0x02; // decrease the value
SPIT_Message() = default;
Message() = default;
// Members
private:
@@ -148,18 +149,18 @@ class SPIT_Message {
// Receive
public:
SPIT_Message(std::vector<char> message);
Message(std::vector<char> message);
const Header *getHeader() const { return m_OPPart->getHeader(); }
int getOPFlag() const {
int getType() const {
if (!m_OPPart || !m_OPPart->getHeader()) {
return -1;
}
return m_OPPart->getHeader()->getOPFlag();
return m_OPPart->getHeader()->getType();
}
const OPPart *getOPPart() const { return m_OPPart.get(); }
template<typename T>
T &getOPPartAs() const { return *reinterpret_cast<T *>(m_OPPart.get()); }
T &getAs() const { return *reinterpret_cast<T *>(m_OPPart.get()); }
private:
bool parse(std::vector<char> message);
@@ -294,9 +295,9 @@ class SPIT_Message {
//------------------------------ SPITProject ----------------------------------
//----------- ReportSPITProject -----------
//----------- ReportProject -----------
class ReportSPITProject : public OPPart {
class ReportProject : public OPPart {
public:
static constexpr int OPFLAG = 11;
static constexpr int BYTESLENGTH = 113;
@@ -308,22 +309,22 @@ class SPIT_Message {
// Receive
public:
ReportSPITProject(const ReportSPITProject &orig);
ReportSPITProject(unique_ptr<Header> p_Header);
ReportProject(const ReportProject &orig);
ReportProject(unique_ptr<Header> p_Header);
bool parse(const std::vector<char> &message);
const string getProjectID() const { return m_ProjectID; }
const string getProjectName() const { return m_ProjectName; }
int getFramesPerSecond() const { return m_FramesPerSecond; }
// Send
ReportSPITProject(string p_ProjectID, string p_ProjectName);
ReportProject(string p_ProjectID, string p_ProjectName);
void setFramesPerSecond(const int p_FramesPerSecond) { m_FramesPerSecond = p_FramesPerSecond; }
bool fillBytes(std::vector<char> &message);
};
//----------- CloseSPITProject -----------
//----------- CloseProject -----------
class CloseSPITProject : public OPPart {
class CloseProject : public OPPart {
public:
static constexpr int OPFLAG = 13;
static constexpr int BYTESLENGTH = 45;
@@ -332,15 +333,15 @@ class SPIT_Message {
string m_ProjectID{};
public:
CloseSPITProject(const CloseSPITProject &orig);
CloseProject(const CloseProject &orig);
// Receive
CloseSPITProject(unique_ptr<Header> p_Header);
CloseProject(unique_ptr<Header> p_Header);
bool parse(const std::vector<char> &message);
const string getProjectID() const {
return m_ProjectID;
}
// Send
CloseSPITProject(string projectID);
CloseProject(string projectID);
bool fillBytes(std::vector<char> &message);
};
@@ -392,8 +393,8 @@ class SPIT_Message {
//---------------------------- SPIT_Types ----------------------------------
//----------- ReportSPITType -----------
class ReportSPITType : public OPPart {
//----------- ReportType -----------
class ReportType : public OPPart {
public:
static constexpr int OPFLAG = 21;
static constexpr int BYTESLENGTH = 168;
@@ -406,13 +407,13 @@ class SPIT_Message {
bool m_ServerProjectIndepended{};
string m_SPITTypeGroupName{};
string m_SPITTypeName{};
long long m_Delay{};
long long m_Duration{};
uint64_t m_Delay{};
uint64_t m_Duration{};
public:
ReportSPITType(const ReportSPITType &orig);
ReportType(const ReportType &orig);
// Receive
ReportSPITType(unique_ptr<Header> p_Header);
ReportType(unique_ptr<Header> p_Header);
bool parse(const std::vector<char> &message);
bool getConfirmed() const { return m_Confirmed; }
@@ -422,11 +423,11 @@ class SPIT_Message {
bool getServerProjectIndepended() const { return m_ServerProjectIndepended; }
const string getGroupName() const { return m_SPITTypeGroupName; }
const string getName() const { return m_SPITTypeName; }
long long getDelay() const { return m_Delay; }
long long getDuration() const { return m_Duration; }
uint64_t getDelay() const { return m_Delay; }
uint64_t getDuration() const { return m_Duration; }
// Send
ReportSPITType();
ReportType();
void setConfirmed(bool p_Confirmed) { m_Confirmed = p_Confirmed; }
void setID(string p_ID) { m_SPITTypeID = p_ID; }
void setFixed(bool p_Fixed) { m_Fixed = p_Fixed; }
@@ -434,15 +435,15 @@ class SPIT_Message {
void setServerProjectIndepended(bool p_ProjectIndpended) { m_ServerProjectIndepended = p_ProjectIndpended; }
void setGroupName(string p_GroupName) { m_SPITTypeGroupName = p_GroupName; }
void setName(string p_Name) { m_SPITTypeName = p_Name; }
void setDelay(long long p_Delay) { m_Delay = p_Delay; }
void setDuration(long long p_Duration) { m_Duration = p_Duration; }
void setDelay(uint64_t p_Delay) { m_Delay = p_Delay; }
void setDuration(uint64_t p_Duration) { m_Duration = p_Duration; }
bool fillBytes(std::vector<char> &message);
};
//----------- RemoveSPITType -----------
//----------- RemoveType -----------
class RemoveSPITType : public OPPart {
class RemoveType : public OPPart {
public:
static constexpr int OPFLAG = 23;
static constexpr int BYTESLENGTH = 45;
@@ -451,24 +452,24 @@ class SPIT_Message {
string m_SPITTypeID{};
public:
RemoveSPITType(const RemoveSPITType &orig);
RemoveType(const RemoveType &orig);
// Receive
RemoveSPITType(unique_ptr<Header> p_Header);
RemoveType(unique_ptr<Header> p_Header);
bool parse(const std::vector<char> &message);
const string getID() const { return m_SPITTypeID; }
// Send
RemoveSPITType();
RemoveType();
void setID(string p_ID) { m_SPITTypeID = p_ID; }
bool fillBytes(std::vector<char> &message);
};
//---------------------------- SPITObjects ----------------------------------
//----------- ReportSPITObject -----------
//----------- ReportObject -----------
class ReportSPITObject : public OPPart {
class ReportObject : public OPPart {
public:
static constexpr int OPFLAG = 31;
static constexpr int BYTESLENGTH = 339;
@@ -481,22 +482,22 @@ class SPIT_Message {
string m_SPITObjectName{};
string m_SPITTypeID{};
string m_ServerParams{};
long long m_FrameStart{};
long long m_FrameLength{};
long long m_FrameFadeInLength{};
long long m_FrameFadeOutLength{};
uint64_t m_FrameStart{};
uint64_t m_FrameLength{};
uint64_t m_FrameFadeInLength{};
uint64_t m_FrameFadeOutLength{};
int m_ValueFactor{};
char m_ValueUse{VALUEUSE_DISCARD};
int m_Track{};
string m_Remark{};
long long m_Delay{};
long long m_Duration{};
uint64_t m_Delay{};
uint64_t m_Duration{};
bool m_ActionAssigned{};
public:
ReportSPITObject(const ReportSPITObject &orig);
ReportObject(const ReportObject &orig);
// Receive
ReportSPITObject(unique_ptr<Header> p_Header);
ReportObject(unique_ptr<Header> p_Header);
bool parse(const std::vector<char> &message);
bool getConfirmed() const { return m_Confirmed; }
@@ -506,20 +507,20 @@ class SPIT_Message {
const string getName() const { return m_SPITObjectName; }
const string getSPITTypeID() const { return m_SPITTypeID; }
const string getServerParams() const { return m_ServerParams; }
long long getFrameStart() const { return m_FrameStart; }
long long getFrameLength() const { return m_FrameLength; }
long long getFrameFadeInLength() const { return m_FrameFadeInLength; }
long long getFrameFadeOutLength() const { return m_FrameFadeOutLength; }
uint64_t getFrameStart() const { return m_FrameStart; }
uint64_t getFrameLength() const { return m_FrameLength; }
uint64_t getFrameFadeInLength() const { return m_FrameFadeInLength; }
uint64_t getFrameFadeOutLength() const { return m_FrameFadeOutLength; }
int getValueFactor() const { return m_ValueFactor; }
char getValueUse() const { return m_ValueUse; }
int getTrack() const { return m_Track; }
const string getRemark() const { return m_Remark; }
long long getDelay() const { return m_Delay; }
long long getDuration() const { return m_Duration; }
uint64_t getDelay() const { return m_Delay; }
uint64_t getDuration() const { return m_Duration; }
bool getActionAssigned() const { return m_ActionAssigned; }
// Send
public:
ReportSPITObject();
ReportObject();
void setConfirmed(bool p_Confirmed) { m_Confirmed = p_Confirmed; };
void setID(string p_ID) { m_SPITObjectID = p_ID; };
@@ -528,23 +529,23 @@ class SPIT_Message {
void setName(string p_Name) { m_SPITObjectName = p_Name; };
void setSPITTypeID(string p_ID) { m_SPITTypeID = p_ID; };
void setServerParams(string p_Parameters) { m_ServerParams = p_Parameters; };
void setFrameStart(long long p_StartTime) { m_FrameStart = p_StartTime; };
void setFrameLength(long long p_Length) { m_FrameLength = p_Length; };
void setFrameFadeInLength(long long p_FadeInTime) { m_FrameFadeInLength = p_FadeInTime; };
void setFrameFadeOutLength(long long p_FadeOutTime) { m_FrameFadeOutLength = p_FadeOutTime; };
void setFrameStart(uint64_t p_StartTime) { m_FrameStart = p_StartTime; };
void setFrameLength(uint64_t p_Length) { m_FrameLength = p_Length; };
void setFrameFadeInLength(uint64_t p_FadeInTime) { m_FrameFadeInLength = p_FadeInTime; };
void setFrameFadeOutLength(uint64_t p_FadeOutTime) { m_FrameFadeOutLength = p_FadeOutTime; };
void setValueFactor(int p_Volume) { m_ValueFactor = p_Volume; };
void setValueUse(char p_ValueUse) { m_ValueUse = p_ValueUse; };
void setTrack(int p_Track) { m_Track = p_Track; };
void setRemark(string p_Description) { m_Remark = p_Description; };
void setDelay(long long p_Delay);
void setDuration(long long p_Duration);
void setDelay(uint64_t p_Delay);
void setDuration(uint64_t p_Duration);
void setActionAssigned(bool p_ActionAssigned) { m_ActionAssigned = p_ActionAssigned; }
bool fillBytes(std::vector<char> &message);
};
//----------- RemoveSPITObject -----------
//----------- RemoveObject -----------
class RemoveSPITObject : public OPPart {
class RemoveObject : public OPPart {
public:
static constexpr int OPFLAG = 33;
static constexpr int BYTESLENGTH = 45;
@@ -553,24 +554,24 @@ class SPIT_Message {
string m_SPITObjectID{};
public:
RemoveSPITObject(const RemoveSPITObject &orig);
RemoveObject(const RemoveObject &orig);
// Receive
RemoveSPITObject(unique_ptr<Header> p_Header);
RemoveObject(unique_ptr<Header> p_Header);
bool parse(const std::vector<char> &message);
const string getID() const { return m_SPITObjectID; }
// Send
public:
RemoveSPITObject();
RemoveObject();
void setID(string p_ID) { m_SPITObjectID = p_ID; }
bool fillBytes(std::vector<char> &message);
};
//---------------------------- SPITPlayer ----------------------------------
//----------- PlaySPITStart -----------
//----------- PlayStart -----------
class PlaySPITStart : public OPPart {
class PlayStart : public OPPart {
public:
static constexpr int OPFLAG = 37;
static constexpr int BYTESLENGTH = 119;
@@ -580,30 +581,30 @@ class SPIT_Message {
string m_PlayerName{};
char m_PlayerType{};
bool m_PlayerIsRunning{};
long long m_Time; // Frames
uint64_t m_Time; // Frames
public:
PlaySPITStart(const PlaySPITStart &orig);
PlayStart(const PlayStart &orig);
// Receive
PlaySPITStart(unique_ptr<Header> p_Header);
PlayStart(unique_ptr<Header> p_Header);
bool parse(const std::vector<char> &message);
const string getPlayerID() const { return m_PlayerID; }
const string getPlayerName() const { return m_PlayerName; }
char getPlayerType() const { return m_PlayerType; }
bool getPlayerIsRunning() const { return m_PlayerIsRunning; }
long long getTime() const { return m_Time; }
uint64_t getTime() const { return m_Time; }
// Send
PlaySPITStart(string p_PlayerID, string p_PlayerName, char p_PlayerType);
PlayStart(string p_PlayerID, string p_PlayerName, char p_PlayerType);
void setPlayerIsRunning(bool p_IsPlaying) { m_PlayerIsRunning = p_IsPlaying; }
void setTime(long long p_Time) { m_Time = p_Time; }
void setTime(uint64_t p_Time) { m_Time = p_Time; }
bool fillBytes(std::vector<char> &message);
};
//----------- PlaySPITObject -----------
//----------- PlayObject -----------
class PlaySPITObject : public OPPart {
class PlayObject : public OPPart {
public:
static constexpr int OPFLAG = 38;
static constexpr int BYTESLENGTH = 100;
@@ -611,37 +612,37 @@ class SPIT_Message {
private:
string m_PlayerID{};
string m_SPITObjectID{};
long long m_FrameInsideObject{}; // Frames
uint64_t m_FrameInsideObject{}; // Frames
bool m_PlayPrePosition{};
int m_Value{};
char m_ValueFlag{VALUEFLAG_DIRECT};
public:
PlaySPITObject(const PlaySPITObject &orig);
PlayObject(const PlayObject &orig);
// Receive
PlaySPITObject(unique_ptr<Header> p_Header);
PlayObject(unique_ptr<Header> p_Header);
bool parse(const std::vector<char> &message);
const string getPlayerID() const { return m_PlayerID; }
const string getSPITObjectID() const { return m_SPITObjectID; }
long long getFrameInsideObject() const { return m_FrameInsideObject; }
uint64_t getFrameInsideObject() const { return m_FrameInsideObject; }
bool getPlayPrePosition() const { return m_PlayPrePosition; }
int getValue() const { return m_Value; }
char getValueFlag() const { return m_ValueFlag; }
// Send
PlaySPITObject();
PlayObject();
void setPlayerID(string p_PlayerID) { m_PlayerID = p_PlayerID; }
void setID(string p_ID) { m_SPITObjectID = p_ID; }
void setFrameInsideObject(long long p_TimeInside) { m_FrameInsideObject = p_TimeInside; }
void setFrameInsideObject(uint64_t p_TimeInside) { m_FrameInsideObject = p_TimeInside; }
void setPlayPrePosition(bool p_PlayOldPosition) { m_PlayPrePosition = p_PlayOldPosition; }
void setValue(int p_Value) { m_Value = p_Value; }
void setValueFlag(char p_ValueFlag) { m_ValueFlag = p_ValueFlag; }
bool fillBytes(std::vector<char> &message);
};
//----------- PlaySPITEnd -----------
class PlaySPITEnd : public OPPart {
//----------- PlayEnd -----------
class PlayEnd : public OPPart {
public:
static constexpr int OPFLAG = 39;
static constexpr int BYTESLENGTH = 45;
@@ -650,19 +651,18 @@ class SPIT_Message {
string m_PlayerID{};
public:
PlaySPITEnd(const PlaySPITEnd &orig);
PlayEnd(const PlayEnd &orig);
// Receive
PlaySPITEnd(unique_ptr<Header> p_Header);
PlayEnd(unique_ptr<Header> p_Header);
bool parse(const std::vector<char> &message);
const string getPlayerID() const { return m_PlayerID; }
// Send
PlaySPITEnd(string p_PlayerID);
PlayEnd(string p_PlayerID);
bool fillBytes(std::vector<char> &message);
};
//----------- ReportPlayStatus -----------
class ReportPlayStatus : public OPPart {
public:
static constexpr int OPFLAG = 40;
@@ -670,7 +670,7 @@ class SPIT_Message {
private:
string m_SPITObjectID{};
long long m_FrameInsideObject{}; // Frames
uint64_t m_FrameInsideObject{};
int m_Value{};
public:
@@ -680,13 +680,13 @@ class SPIT_Message {
bool parse(const std::vector<char> &message);
const string getID() const { return m_SPITObjectID; }
long long getFrameInsideObject() const { return m_FrameInsideObject; }
uint64_t getFrameInsideObject() const { return m_FrameInsideObject; }
int getValue() const { return m_Value; }
// Send
ReportPlayStatus();
void setID(string p_ID);
void setFrameInsideObject(long long p_TimeInside);
void setFrameInsideObject(uint64_t p_TimeInside);
void setValue(int p_Value);
bool fillBytes(std::vector<char> &message);
};
@@ -695,11 +695,11 @@ class SPIT_Message {
public:
static bool isSystemLittleEndian();
static optional<int> getInt(const std::vector<char> &message, int &offset);
static optional<long long> getLong(const std::vector<char> &message, int &offset);
static optional<uint64_t> getLong(const std::vector<char> &message, int &offset);
static optional<bool> getBoolean(const std::vector<char> &message, int &offset);
static optional<char> getByte(const std::vector<char> &message, int &offset);
static int setInt(int value, std::vector<char> &message, int offset);
static int setLong(long long value, std::vector<char> &message, int offset);
static int setLong(uint64_t value, std::vector<char> &message, int offset);
static int setBoolean(bool value, std::vector<char> &message, int offset);
static int setByte(int value, std::vector<char> &message, int offset);
@@ -725,4 +725,5 @@ class SPIT_Message {
*/
static int setString(string p_String, std::vector<char> &message, int p_Offset, int p_Length);
};
#endif /* SPIT_MESSAGE_H */
}