WIP

slsSupportLib/include/DataSocket.h

@@ -4,6 +4,7 @@
 #include <cstdint>
 #include <netdb.h>
 #include <string>
+#include <numeric>
 namespace sls {
 
 class DataSocket {
@@ -16,13 +17,30 @@ class DataSocket {
     DataSocket(const DataSocket &) = delete;
     DataSocket &operator=(DataSocket const &) = delete;
     int getSocketId() const { return socketId_; }
-    int sendData(const void *buffer, size_t size);
 
-    template <typename T> int sendData(T &&data) {
-        return sendData(&data, sizeof(data));
+    int Send(const void *buffer, size_t size);
+    template <typename T> int Send(T &&data) {
+        return Send(&data, sizeof(data));
+    }
+
+    // Trick to send all
+    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> T Receive() {
+        T arg;
+        Receive(&arg, sizeof(arg));
+        return arg;
     }
 
-    int receiveData(void *buffer, size_t size);
     int read(void *buffer, size_t size);
     int write(void *buffer, size_t size);
     int setTimeOut(int t_seconds);

slsSupportLib/include/ServerInterface2.h

@@ -22,23 +22,10 @@ class ServerInterface2 : public DataSocket {
     }
 
     template <typename T> int sendResult(T &&retval) {
-        sendData(defs::OK);
-        sendData(retval);
+        Send(defs::OK);
+        Send(retval);
         return defs::OK;
     }
-
-    int receiveArg(void *arg, int sizeofArg);
-
-    template <typename T> int receiveArg(T &arg) {
-        return receiveArg(&arg, sizeof(arg));
-    }
-    template <typename T> T receive() {
-        T arg;
-        receiveArg(&arg, sizeof(arg));
-        return arg;
-    }
-
-  private:
 };
 
 } // namespace sls

slsSupportLib/src/ClientSocket.cpp

@@ -62,19 +62,19 @@ int ClientSocket::sendCommandThenRead(int fnum, const void *args,
                                       size_t args_size, void *retval,
                                       size_t retval_size) {
     int ret = slsDetectorDefs::FAIL;
-    sendData(&fnum, sizeof(fnum));
-    sendData(args, args_size);
+    Send(&fnum, sizeof(fnum));
+    Send(args, args_size);
     readReply(ret, retval, retval_size);
     return ret;
 }
 
 void ClientSocket::readReply(int &ret, void *retval, size_t retval_size) {
 
-    read(&ret, sizeof(ret));
+    Receive(&ret, sizeof(ret));
     if (ret == slsDetectorDefs::FAIL) {
         char mess[MAX_STR_LENGTH]{};
         // get error message
-        read(mess, sizeof(mess));
+        Receive(mess, sizeof(mess));
         // Do we need to know hostname here?
         // In that case save it???
         if (socketType == "Receiver") {
@@ -86,7 +86,7 @@ void ClientSocket::readReply(int &ret, void *retval, size_t retval_size) {
         }
     }
     // get retval
-    read(retval, retval_size);
+    Receive(retval, retval_size);
 }
 
 }; // namespace sls

slsSupportLib/src/DataSocket.cpp

@@ -42,9 +42,8 @@ DataSocket &DataSocket::operator=(DataSocket &&move) noexcept {
     return *this;
 }
 
-int DataSocket::receiveData(void *buffer, size_t size) {
+int DataSocket::Receive(void *buffer, size_t size) {
     // TODO!(Erik) Add sleep? how many reties?
-    assert(size > 0);
     int bytes_expected = static_cast<int>(size); // signed size
     int bytes_read = 0;
     while (bytes_read < bytes_expected) {
@@ -65,7 +64,7 @@ int DataSocket::receiveData(void *buffer, size_t size) {
     }
 }
 
-int DataSocket::sendData(const void *buffer, size_t size) {
+int DataSocket::Send(const void *buffer, size_t size) {
     int bytes_sent = 0;
     int data_size = static_cast<int>(size); // signed size
     while (bytes_sent < (data_size)) {

slsSupportLib/src/ServerInterface2.cpp

@@ -21,18 +21,4 @@ int ServerInterface2::sendResult(int ret, void *retval, int retvalSize,
     return ret;
 }
 
-int ServerInterface2::receiveArg(void *arg, int sizeofArg) {
-    assert(sizeofArg > 0);
-    int bytes_read = receiveData(arg, sizeofArg);
-    if (bytes_read == sizeofArg) {
-        return defs::OK;
-    } else {
-        std::ostringstream ss;
-        ss << "TCP socket error read " << bytes_read << " bytes instead of "
-           << sizeofArg << " bytes";
-
-        throw sls::SocketError(ss.str());
-    }
-}
-
 } // namespace sls

slsSupportLib/tests/test-Sockets.cpp

@@ -10,14 +10,14 @@ std::vector<char> server() {
     auto server = sls::ServerSocket(1950);
     auto s = server.accept();
     std::vector<char> buffer(100, '\0');
-    s.receiveData(buffer.data(), buffer.size());
+    s.Receive(buffer.data(), buffer.size());
     std::cout << "ServerReceived: " << std::string(buffer.begin(), buffer.end())
               << '\n';
     
     std::vector<char> to_send(100, '\0');
     to_send[0] = 'O';
     to_send[1] = 'K';
-    s.sendData(to_send.data(), to_send.size());
+    s.Send(to_send.data(), to_send.size());
     s.close();
     return buffer;
 }
@@ -31,8 +31,8 @@ TEST_CASE("The server recive the same message as we send", "[support]") {
     auto s = std::async(std::launch::async, server);
     std::this_thread::sleep_for(std::chrono::milliseconds(100));
     auto client = sls::DetectorSocket("localhost", 1950);
-    client.sendData(sent_message.data(), sent_message.size());
-    client.receiveData(received_message.data(), received_message.size());
+    client.Send(sent_message.data(), sent_message.size());
+    client.Receive(received_message.data(), received_message.size());
     client.close();
     auto server_message = s.get();