Simple-Protocol-Lib/include/sp/protocol/message/MessageInterfacesImpl.h

#pragma once

#include <sp/common/ByteSwapping.h>

namespace sp {
namespace details {


// ID retrieval chunk
template <typename TBase, typename TId>
class MessageInterfaceIdTypeBase : public TBase {
  public:
	using MsgIdType = TId;
	MsgIdType GetId() const {
		return GetIdImpl();
	}

  protected:
	virtual MsgIdType GetIdImpl() const = 0;
};

// Big endian serialisation chunk
template <typename TBase>
class MessageInterfaceBigEndian : public TBase {
  protected:
	template <typename T>
	void ReadData(T& value, DataBuffer& buffer) {
		buffer >> value;
		FromNetwork(value);
	}

	template <typename T>
	void WriteData(T value, DataBuffer& buffer) const {
		ToNetwork(value);
		buffer << value;
	}
};

// Little endian serialisation chunk
template <typename TBase>
class MessageInterfaceLittleEndian : public TBase {
  protected:
	template <typename T>
	void ReadData(T& value, DataBuffer& buffer) {
		buffer >> value;
		TrySwapBytes(value);
		FromNetwork(value);
	}

	template <typename T>
	void WriteData(const T& value, DataBuffer& buffer) {
		ToNetwork(value);
		TrySwapBytes(value);
		buffer << value;
	}
};

// Read functionality chunk
template <typename TBase>
class MessageInterfaceReadBase : public TBase {
  public:
	void Read(DataBuffer& buffer) {
		return ReadImpl(buffer);
	}

  protected:
	virtual void ReadImpl(DataBuffer& buffer) = 0;
};

// Write functionality chunk
template <typename TBase>
class MessageInterfaceWriteBase : public TBase {
  public:
	void Write(DataBuffer& buffer) const {
		WriteImpl(buffer);
	}

	// helper
	DataBuffer Write() const {
		DataBuffer buffer;
		this->Write(buffer);
		return buffer;
	}

  protected:
	virtual void WriteImpl(DataBuffer& buffer) const = 0;
};

// Handler functionality chunk
template <typename TBase, typename THandler>
class MessageInterfaceHandlerBase : public TBase {
  public:
	using HandlerType = typename THandler::HandlerT;

	void Dispatch(HandlerType& handler) const {
		DispatchImpl(handler);
	}

  protected:
	virtual void DispatchImpl(HandlerType& handler) const = 0;
};

// Validity functionality chunk
template <typename TBase>
class MessageInterfaceValidityBase : public TBase {
  public:
	bool Valid() const {
		return ValidImpl();
	}

  protected:
	virtual bool ValidImpl() const = 0;
};

// Writing id functionality chunk
template <typename TBase>
class MessageInterfaceWriteIdBase : public TBase {
  public:
	void Write(DataBuffer& buffer) const {
		buffer << VarInt{this->GetId()};
		this->WriteImpl(buffer);
	}

	// helper
	DataBuffer Write() const {
		DataBuffer buffer;
		this->Write(buffer);
		return buffer;
	}
};

// Debug print functionality chunk
template <typename TBase>
class MessageInterfaceToStringBase : public TBase {
  public:
	friend std::ostream& operator<<(std::ostream& a_Stream, const MessageInterfaceToStringBase& a_Message) {
		return a_Message.OpOutImpl(a_Stream);
	}

  protected:
	virtual std::ostream& OpOutImpl(std::ostream& a_Stream) const = 0;
};

}  // namespace details
}  // namespace sp