Moved the Event Horizon Communications to this project.

include/ehs/io/socket/ehc/Fragments.h

@@ -0,0 +1,43 @@
+#pragma once
+
+#include "Utils.h"
+
+#include <ehs/Serializer.h>
+
+namespace ehs
+{
+	class Fragments
+	{
+	private:
+		Header header;
+		Serializer<UInt_64>* data;
+		UInt_64 size;
+
+	public:
+		~Fragments();
+
+		Fragments();
+
+		Fragments(const Header &header, const Serializer<UInt_64> &payload);
+
+        Fragments(const Header &header, UInt_64 size);
+
+		Fragments(Fragments &&frags) noexcept;
+
+		Fragments(const Fragments &frags);
+
+		Fragments &operator=(Fragments &&frags) noexcept;
+
+		Fragments &operator=(const Fragments &frags);
+
+		operator Serializer<UInt_64> *() const;
+
+		Header GetHeader() const;
+
+		UInt_64 Size() const;
+
+		bool IsComplete() const;
+
+		Packet Combine() const;
+	};
+}

include/ehs/io/socket/ehc/NetEnd.h

@@ -0,0 +1,134 @@
+#pragma once
+
+#include "Utils.h"
+#include "Fragments.h"
+
+#include <ehs/Str.h>
+#include <ehs/Vector.h>
+#include <ehs/Serializer.h>
+#include <ehs/io/socket/Socket.h>
+
+namespace ehs
+{
+	class EHC;
+
+	class NetEnd
+	{
+	private:
+		friend class EHC;
+
+		EHC* owner;
+		EndDisp disposition;
+		UInt_64 hashName;
+		Str_8 name;
+		Status status;
+		Architecture arch;
+		Char_8 token[64];
+		UInt_64 nextSendId;
+		Vector<Insurance> sent;
+		UInt_64 nextRecvId;
+		Vector<Fragments> received;
+		AddrType type;
+		Str_8 address;
+		UInt_16 port;
+		float deltaDuration;
+		float deltaRate;
+		float timeout;
+		float lastPing;
+        float oldLatency;
+		float latency;
+		UInt_64 queueSlot;
+
+	public:
+		NetEnd();
+
+		NetEnd(EndDisp disposition, Str_8 id, Architecture arch, AddrType type, Str_8 address, UInt_16 port);
+
+		NetEnd(AddrType type, Str_8 address, UInt_16 port);
+
+		NetEnd(NetEnd &&end) noexcept;
+
+		NetEnd(const NetEnd &end);
+
+		NetEnd &operator=(NetEnd &&end) noexcept;
+
+		NetEnd &operator=(const NetEnd &end);
+
+		EndDisp GetDisposition() const;
+
+		UInt_64 GetHashName() const;
+
+		Str_8 GetName() const;
+
+		Status GetStatus() const;
+
+		Architecture GetArchitecture() const;
+
+		UInt_64 GetNextSendId() const;
+
+		/// Sends data to the remote endpoint.
+		/// @param [in] deltaLocked Whether or not to match the remote endpoint's delta time to prevent overloading the client. This will drop data if delta time does not match.
+		/// @param [in] encrypted Whether or not to encrypt this data before sending to the remote endpoint.
+		/// @param [in] ensure Whether or not to ensure the data was received by the remote endpoint.
+		/// @param [in] sys The system hash id to execute an operation from.
+		/// @param [in] op The operation hash id in the system to execute.
+		/// @param [in] payload Additional parameters and data to send to the remote endpoint.
+		void Send(bool deltaLocked, bool encrypted, bool ensure, UInt_64 sys, UInt_64 op, const Serializer<UInt_64>& payload);
+
+		/// Sends data to the remote endpoint.
+		/// @param [in] deltaLocked Whether or not to match the remote endpoint's delta time to prevent overloading the client. This will drop data if delta time does not match.
+		/// @param [in] encrypted Whether or not to encrypt this data before sending to the remote endpoint.
+		/// @param [in] ensure Whether or not to ensure the data was received by the remote endpoint.
+		/// @param [in] sys The system string id to execute an operation from.
+		/// @param [in] op The operation string id in the system to execute.
+		/// @param [in] payload Additional parameters and data to send to the remote endpoint.
+		void Send(bool deltaLocked, bool encrypted, bool ensure, const Str_8& sys, const Str_8& op, const Serializer<UInt_64>& payload);
+
+		UInt_64 GetNextRecvId() const;
+
+		Str_8 GetAddress() const;
+
+		UInt_16 GetPort() const;
+
+		void SetDeltaRate(float newDeltaRate);
+
+		float GetDeltaRate() const;
+
+		float GetTimeout() const;
+
+		float GetLastPing() const;
+
+		void SendLatency();
+
+		float GetLatency() const;
+
+		UInt_64 GetQueueSlot() const;
+
+	private:
+		void Poll(float delta);
+
+		void SetStatus(Status newStatus);
+
+		void RemoveInsurance(UInt_64 msgId, UInt_64 fragment);
+
+		void AddReceived(const Header& header, const Serializer<>& payload);
+
+		Vector<Fragments>* GetReceived();
+
+		void Ping(float delta);
+
+		void Pong(float delta);
+
+		void SetLatency(float newLatency);
+
+		void SetQueueSlot(UInt_64 slot);
+
+		Fragments FragmentData(const Header& header, const Serializer<>& data);
+
+		void Send(const Header& header, const Serializer<>& payload);
+
+		bool SortingNeeded() const;
+
+		void SortReceived();
+	};
+}

include/ehs/io/socket/ehc/NetOp.h

@@ -0,0 +1,42 @@
+#pragma once
+
+#include <ehs/Str.h>
+#include <ehs/Serializer.h>
+
+namespace ehs
+{
+	class EHC;
+	class NetSystem;
+	class NetEnd;
+
+	class NetOp
+	{
+	private:
+		friend class NetSystem;
+
+		UInt_64 hashId;
+		Str_8 id;
+
+	public:
+		virtual ~NetOp() = default;
+
+		NetOp();
+
+		NetOp(Str_8 id);
+
+		NetOp(NetOp &&op) noexcept;
+
+		NetOp(const NetOp &op);
+
+		NetOp &operator=(NetOp &&op) noexcept;
+
+		NetOp &operator=(const NetOp &op);
+
+		Str_8 GetId() const;
+
+		UInt_64 GetHashId() const;
+
+	private:
+		virtual void Process(EHC *ehc, NetEnd *endpoint, NetSystem *sys, Serializer<UInt_64> &payload);
+	};
+}

include/ehs/io/socket/ehc/NetSystem.h

@@ -0,0 +1,48 @@
+#pragma once
+
+#include <ehs/Str.h>
+#include <ehs/Array.h>
+#include <ehs/Serializer.h>
+
+namespace ehs
+{
+	class EHC;
+	class NetEnd;
+	class NetOp;
+
+	class NetSystem
+	{
+	private:
+		friend class EHC;
+
+		UInt_64 hashId;
+		Str_8 id;
+		Array<NetOp*> ops;
+
+	public:
+		virtual ~NetSystem();
+
+		NetSystem();
+
+		NetSystem(Str_8 id);
+
+		NetSystem(NetSystem &&sys) noexcept;
+
+		NetSystem(const NetSystem &sys);
+
+		NetSystem &operator=(NetSystem &&sys) noexcept;
+
+		NetSystem &operator=(const NetSystem &sys);
+
+		Str_8 GetId() const;
+
+		UInt_64 GetHashId() const;
+
+		bool HasOperation(UInt_64 hashId) const;
+
+		bool AddOperation(NetOp *op);
+
+	private:
+		void Execute(EHC *ehc, NetEnd *endpoint, UInt_64 hashId, Serializer<UInt_64> &payload);
+	};
+}

include/ehs/io/socket/ehc/Utils.h

@@ -0,0 +1,54 @@
+#pragma once
+
+#include <ehs/Serializer.h>
+
+namespace ehs
+{
+	enum class EndDisp : UInt_8
+	{
+		ENDPOINT,
+		SERVICE
+	};
+
+	enum class Status : UInt_8
+	{
+		ACTIVE,
+		PENDING,
+		IN_LOCAL_QUEUE,
+		IN_REMOTE_QUEUE,
+	};
+
+	struct Header
+	{
+		bool encrypted = true;
+		UInt_64 id = 0;
+		UInt_64 fragments = 0;
+		UInt_64 fragment = 0;
+		bool ensure = false;
+		EndDisp disposition = EndDisp::ENDPOINT;
+		Char_8 token[64] = {};
+		UInt_64 system = 0;
+		UInt_64 op = 0;
+	};
+
+	struct Packet
+	{
+		Header header;
+		Serializer<UInt_64> payload;
+	};
+
+    struct Insurance
+    {
+        Header header;
+        Serializer<UInt_64> payload;
+        float lastResend;
+    };
+}
+
+#ifndef COMMS_IPV4_PAYLOAD
+	#define COMMS_IPV4_PAYLOAD (EHS_IPV4_UDP_PAYLOAD - (UInt_16)sizeof(Header))
+#endif
+
+#ifndef COMMS_IPV6_PAYLOAD
+	#define COMMS_IPV6_PAYLOAD (EHS_IPV6_UDP_PAYLOAD - (UInt_16)sizeof(Header))
+#endif