Moving headers into include/sls (#212)

slsSupportLib/include/sls/DataSocket.h

@@ -0,0 +1,87 @@
+#pragma once
+
+#include "sls/TypeTraits.h"
+#include <cstddef>
+#include <cstdint>
+#include <iostream>
+#include <netdb.h>
+#include <numeric>
+#include <string>
+#include <vector>
+namespace sls {
+
+/* Base class for TCP socket, this is used to send data between detector, client
+   and receiver. Specific protocols inherit from this class.*/
+
+class DataSocket {
+  public:
+    DataSocket(int socketId);
+    DataSocket(DataSocket &&move) noexcept;
+    virtual ~DataSocket();
+    DataSocket &operator=(DataSocket &&move) noexcept;
+    void swap(DataSocket &other) noexcept;
+
+    // No copy since the class manage the underlying socket
+    DataSocket(const DataSocket &) = delete;
+    DataSocket &operator=(DataSocket const &) = delete;
+    int getSocketId() const { return sockfd_; }
+
+    int Send(const void *buffer, size_t size);
+
+    // Send everything that is not a vector or string by using address and
+    // sizeof
+    // TODO! We probably should restrict this even more to avoid bugs when
+    // we send object instead of data
+    template <typename T>
+    typename std::enable_if<
+        !is_vector<typename std::remove_reference<T>::type>::value &&
+            !std::is_same<typename std::remove_reference<T>::type,
+                          std::string>::value,
+        int>::type
+    Send(T &&data) {
+        return Send(&data, sizeof(data));
+    }
+
+    template <typename T> int Send(const std::vector<T> &vec) {
+        return Send(vec.data(), sizeof(T) * vec.size());
+    }
+
+    int Send(const std::string &s);
+
+    // Variadic template to send all arguments
+    template <class... Args> int SendAll(Args &&... args) {
+        auto l = std::initializer_list<int>{Send(args)...};
+        auto sum = std::accumulate(begin(l), end(l), 0);
+        return sum;
+    }
+    int Receive(void *buffer, size_t size);
+
+    template <typename T> int Receive(T &arg) {
+        return Receive(&arg, sizeof(arg));
+    }
+
+    template <typename T> int Receive(std::vector<T> &buff) {
+        return Receive(buff.data(), sizeof(T) * buff.size());
+    }
+
+    template <typename T> T Receive() {
+        T arg;
+        Receive(&arg, sizeof(arg));
+        return arg;
+    }
+
+    std::string Receive(size_t length);
+
+    int read(void *buffer, size_t size);
+    int write(void *buffer, size_t size);
+    int setTimeOut(int t_seconds);
+    int setReceiveTimeout(int us);
+    void close();
+    void shutDownSocket();
+    void shutdown();
+
+  private:
+    int sockfd_ = -1;
+};
+
+}; // namespace sls