CVS update of carob (include/JavaSocket.hpp src/JavaSocket.cpp)

    Date: Friday, February 24, 2006 @ 18:30:34
  Author: gilles
    Path: /cvsroot/carob/carob

Modified: include/JavaSocket.hpp (1.25 -> 1.26) src/JavaSocket.cpp (1.42
          -> 1.43)

Changed receive/sendFromSocket function to return void: they both throw 
exception in case of error, if they return, this is success
Added java-byte array serialization functions


------------------------+
 include/JavaSocket.hpp |   30 ++++++++++++----
 src/JavaSocket.cpp     |   87 ++++++++++++++++++++++++++---------------------
 2 files changed, 72 insertions(+), 45 deletions(-)


Index: carob/include/JavaSocket.hpp
diff -u carob/include/JavaSocket.hpp:1.25 carob/include/JavaSocket.hpp:1.26
--- carob/include/JavaSocket.hpp:1.25   Wed Feb  1 16:19:18 2006
+++ carob/include/JavaSocket.hpp        Fri Feb 24 18:30:33 2006
@@ -25,6 +25,8 @@
 #include "StringCodecs.hpp"
 #include "CarobException.hpp"
 
+#include "Common.hpp" // for java_byte: cannot forward declare typedefs
+
 #include <string>
 
 #include <netinet/in.h> //for in_addr_t
@@ -149,6 +151,22 @@
   void          readJavaBool(bool& b) const throw (SocketIOException,
                     UnexpectedException);
   /**
+   * Reads an array of bytes from the socket. The array must be allocated !
+   * @param length number of bytes to read
+   * @param data allocated array of (at least) length bytes
+   * @throws SocketIOException
+   */
+  void          readJavaBytes(int32_t length, java_byte* data) const
+                    throw (SocketIOException, UnexpectedException);
+  /**
+   * Writes an array of bytes to the socket.
+   * @param length number of bytes to write
+   * @param data array of (at least) length bytes
+   * @throws SocketIOException
+   */
+  void          writeJavaBytes(int32_t length, java_byte* data) const
+                    throw (SocketIOException, UnexpectedException);
+  /**
    * Gets the socket file descriptor
    * @return the file descriptor
    */
@@ -170,13 +188,12 @@
    * @param buf data to be send
    * @param len length of buf
    * @param flags send option, see recv man page
-   * @return true if the data could be send successfully
    * @throws SocketIOException
    */
-  bool          sendToSocket(const std::wstring& fctName,
+  void          sendToSocket(const std::wstring& fctName,
                     const std::wstring& objName, const void* buf, int len,
-                    int flags)
-                    const throw (SocketIOException, UnexpectedException);
+                    int flags) const throw (SocketIOException,
+                    UnexpectedException);
   /**
    * Wrapper around recv(...) function to handle errors and throw exceptions
    * @param fctName name of the calling function (for logging purposes)
@@ -184,10 +201,9 @@
    * @param buf buffer in which to put the received data in
    * @param len length of buf
    * @param flags send option, see send man page
-   * @return true if the data could be send successfully
-   * @throws SocketIOException
+   * @throws SocketIOException in case of error
    */
-  bool          receiveFromSocket(const std::wstring& fctName,
+  void          receiveFromSocket(const std::wstring& fctName,
                     const std::wstring& objName, 
                     void *buf, int len, int flags)
                     const throw (SocketIOException, UnexpectedException);
Index: carob/src/JavaSocket.cpp
diff -u carob/src/JavaSocket.cpp:1.42 carob/src/JavaSocket.cpp:1.43
--- carob/src/JavaSocket.cpp:1.42       Fri Feb 24 12:54:12 2006
+++ carob/src/JavaSocket.cpp    Fri Feb 24 18:30:33 2006
@@ -218,10 +218,8 @@
   int32_t netlen = htonl(utf8str.length());
 
   //First write number of bytes to follow as 
-  if (sendToSocket(fctName, L"UTF string", &netlen, sizeof(netlen), 
SOCKET_SEND_FLAGS))
-  {
-    sendToSocket(fctName, L"UTF string", utf8str.data(), utf8str.length(), 
SOCKET_SEND_FLAGS);
-  }
+  sendToSocket(fctName, L"UTF string", &netlen, sizeof(netlen), 
SOCKET_SEND_FLAGS);
+  sendToSocket(fctName, L"UTF string", utf8str.data(), utf8str.length(), 
SOCKET_SEND_FLAGS);
 
   return utf8str.length();
 }
@@ -236,24 +234,21 @@
   uint16_t lenRec;
   size_t sizeRead = 0;
   //First get size
-  if (receiveFromSocket(fctName, L"UTF string size", &lenRecNet, 
sizeof(lenRecNet), 0))
-  {
-    lenRec = ntohl(lenRecNet); // number of bytes to come
+  receiveFromSocket(fctName, L"UTF string size", &lenRecNet, 
sizeof(lenRecNet), 0);
+  lenRec = ntohl(lenRecNet); // number of bytes to come
 
-    uint8_t* utfStr = new uint8_t[lenRec];
-    if (receiveFromSocket(fctName, L"UTF string", utfStr, lenRec, 0))
-    {
-      const std::string received(reinterpret_cast<char*>(utfStr), lenRec);
+  uint8_t* utfStr = new uint8_t[lenRec];
+  receiveFromSocket(fctName, L"UTF string", utfStr, lenRec, 0);
+  const std::string received(reinterpret_cast<char*>(utfStr), lenRec);
 
-      try {
-        s = fromUTF8(received);
-      } catch (CodecException) {
-        delete[] utfStr; throw;
-      }
-      sizeRead = (size_t)lenRec;
-    }
-    delete[] utfStr;
+  try {
+    s = fromUTF8(received);
+  } catch (CodecException) {
+    delete[] utfStr; throw;
   }
+  sizeRead = (size_t)lenRec;
+
+  delete[] utfStr;
   return sizeRead;
 }
 
@@ -274,10 +269,8 @@
   // so we must convert it after reception
   int32_t rec = 0;
   
-  if (receiveFromSocket(fctName, L"Int32", &rec, sizeof(rec), 0))
-  {
-    i = ntohl(rec);
-  }
+  receiveFromSocket(fctName, L"Int32", &rec, sizeof(rec), 0);
+  i = ntohl(rec);
 }
 
 void JavaSocket::writeJavaLong(int64_t i) const throw (SocketIOException,
@@ -297,16 +290,14 @@
   // so we must convert it after reception
   int64_t rec = 0;
   
-  if (receiveFromSocket(fctName, L"Int64", &rec, sizeof(rec), 0))
-  {
-    i = ntohll(rec);
-  }
+  receiveFromSocket(fctName, L"Int64", &rec, sizeof(rec), 0);
+  i = ntohll(rec);
 }
 
 void JavaSocket::writeJavaBool(bool b) const throw (SocketIOException,
     UnexpectedException)
 {
-  wstring fctName(L"JavaSocket::WriteBoolean");
+  wstring fctName(L"JavaSocket::writeJavaBool");
   uint8_t byteToSend = b; // the implicit casts do it right
   //No byte order problem here: the only value read is '0' for false
   //all other values are true
@@ -316,11 +307,25 @@
 void JavaSocket::readJavaBool(bool& b) const throw (SocketIOException,
     UnexpectedException)
 {
-  wstring fctName(L"JavaSocket::ReadBoolean");
+  wstring fctName(L"JavaSocket::readJavaBool");
 
   uint8_t rec;
-  if (receiveFromSocket(fctName, L"Boolean", &rec, sizeof(rec), 0))
-    b = rec; // the implicit cast does it right
+  receiveFromSocket(fctName, L"Boolean", &rec, sizeof(rec), 0);
+  b = rec; // the implicit cast does it right
+}
+
+void JavaSocket::readJavaBytes(int32_t length, java_byte* data) const
+    throw (SocketIOException, UnexpectedException)
+{
+  wstring fctName(L"JavaSocket::readJavaBytes");
+  receiveFromSocket(fctName, L"JavaBytes", data, length, 0);
+}
+
+void JavaSocket::writeJavaBytes(int32_t length, java_byte* data) const
+    throw (SocketIOException, UnexpectedException)
+{
+  wstring fctName(L"JavaSocket::writeJavaBytes");
+  sendToSocket(fctName, L"JavaBytes", data, length, SOCKET_SEND_FLAGS);
 }
 
 int JavaSocket::recvFully(void *buf, const int len, const int flags)
@@ -345,21 +350,28 @@
   return len;
 }
 
-bool JavaSocket::sendToSocket(const wstring& fctName, const wstring& objName,
+void JavaSocket::sendToSocket(const wstring& fctName, const wstring& objName,
     const void* buf, int len, int flags) const
     throw (SocketIOException, UnexpectedException)
 {
+  // in non blocking mode, send will block until len bytes are send. So no need
+  // to loop here
   int ret = send(socketFd, buf, len, flags);
   if ( ret == -1 )
   {
-    wstring msg = L'(' + fctName + L"): could not write " + objName + L" to 
socket";
-    throw SocketIOException(msg);
-    return false;
+    throw SocketIOException(L'(' + fctName + L"): could not write "
+        + objName + L" to socket");
+  }
+  if (ret != len)
+  {
+    // should never happen
+    throw SocketIOException(L'(' + fctName + L"): only " + toWString(ret)
+        + L"/" + toWString(len) + L" bytes send while sending " + objName
+        + L" to socket");
   }
-  return true;
 }
 
-bool JavaSocket::receiveFromSocket(const wstring& fctName,
+void JavaSocket::receiveFromSocket(const wstring& fctName,
     const wstring& objName, void *buf, int len, int flags) const
     throw (SocketIOException, UnexpectedException)
 {
@@ -372,7 +384,6 @@
   {
     throw SocketIOException(fctName + L"Peer reset connection while reading 
integer.");
   }
-  return true;
 }
 
 const uint64_t JavaSocket::ntohll(const uint64_t &n) const