Add TCP support (#12)

Reviewed-on: #12
Co-authored-by: Persson-dev <sim16.prib@gmail.com>
Co-committed-by: Persson-dev <sim16.prib@gmail.com>

include/sp/extensions/tcp/TcpListener.h

@@ -0,0 +1,65 @@
+#pragma once
+
+#include <sp/extensions/tcp/TcpSocket.h>
+
+namespace sp {
+namespace io {
+
+/**
+ * \class TcpListener
+ */
+class TcpListener : private NonCopyable {
+  public:
+	/**
+	 * \brief Starts listening for guests to connect
+	 * \param port The port to listen to
+	 * \param maxConnexions The maximum amount of connexion that can happen at the same time. \n
+	 * Every other guests will be kicked if this amount is reached.
+	 * \return Whether this action was succesfull
+	 */
+	TcpListener(std::uint16_t a_Port, int a_MaxConnexions);
+
+	/**
+	 * \brief Default destructor
+	 */
+	~TcpListener();
+
+	/**
+	 * \brief Tries to accept an incoming request to connect
+	 * \return the new socket if a new connexion was accepted or nullptr
+	 */
+	std::unique_ptr<TcpSocket> Accept();
+
+	/**
+	 * \brief Closes the socket
+	 */
+	void Close();
+
+	/**
+	 * \brief Allows to set the socket in non blocking/blocking mode
+	 * \param a_Blocking If set to true, every call to Read will wait until the socket receives something
+	 * \return true if the operation was successful
+	 */
+	bool SetBlocking(bool a_Blocking);
+
+	/**
+	 * \brief Getter of the m_Port member
+	 * \return The port which the socket listen to
+	 */
+	std::uint16_t GetListeningPort() const;
+
+	/**
+	 * \brief Getter of the m_MaxConnections member
+	 * \return The maximum amount of connexions that can happen at the same time.
+	 */
+	int GetMaximumConnections() const;
+
+  private:
+	SocketHandle m_Handle;
+	std::uint16_t m_Port;
+	int m_MaxConnections;
+};
+
+
+}  // namespace io
+}  // namespace sp

include/sp/extensions/tcp/TcpSocket.h

@@ -0,0 +1,86 @@
+#pragma once
+
+#include <sp/common/NonCopyable.h>
+#include <sp/io/IOInterface.h>
+
+namespace sp {
+namespace io {
+
+using SocketHandle = int;
+
+struct TcpTag {};
+
+class SocketError : public std::exception {
+  private:
+	std::string m_Error;
+
+  public:
+	SocketError(std::string&& a_Msg) : m_Error(std::move(a_Msg)) {}
+
+	virtual const char* what() const noexcept override {
+		return m_Error.c_str();
+	}
+};
+
+template <>
+class IOInterface<TcpTag> : private NonCopyable {
+  public:
+	/**
+	 * \enum Status
+	 * \brief Describes the state of a socket
+	 */
+	enum class Status {
+		/** The socket is connected */
+		Connected,
+		/** The socket is not connected */
+		Disconnected,
+		/** Something bad happened */
+		Error,
+	};
+
+	IOInterface();
+	IOInterface(const std::string& a_Host, std::uint16_t a_Port);
+	IOInterface(IOInterface&& a_Other);
+	IOInterface& operator=(IOInterface&& a_Other);
+	virtual ~IOInterface();
+
+	DataBuffer Read(std::size_t a_Amount);
+	void Write(const sp::DataBuffer& a_Data);
+
+	/**
+	 * \brief Allows to set the socket in non blocking/blocking mode
+	 * \param a_Block If set to true, every call to Read will wait until the socket receives something
+	 * \return true if the operation was successful
+	 */
+	bool SetBlocking(bool a_Block);
+
+	/**
+	 * \brief Getter of the m_Status member
+	 * \return The TcpSocket::Status of this socket
+	 */
+	Status GetStatus() const;
+
+	/**
+	 * \brief Disconnects the socket from the remote
+	 * \note Does nothing if the socket is not connected. \n
+	 * 	This function is also called by the destructor.
+	 */
+	void Disconnect();
+
+
+  private:
+	SocketHandle m_Handle;
+	Status m_Status;
+
+	void Connect(const std::string& a_Host, std::uint16_t a_Port);
+
+	friend class TcpListener;
+};
+
+/**
+ * \typedef TcpSocket
+ */
+using TcpSocket = IOInterface<TcpTag>;
+
+}  // namespace io
+}  // namespace sp