Changeset 7230 in orxonox.OLD for trunk/src/lib/network

Timestamp:

Mar 21, 2006, 3:20:36 PM (19 years ago)

Author:

bensch

Message:

orxonox/trunk: merged the std::branche back

Location:

trunk/src/lib/network

Files:

• converter.cc (modified) (5 diffs)
• converter.h (modified) (1 diff)
• synchronizeable.h (modified) (6 diffs)

trunk/src/lib/network/converter.cc

@@ -159 +159 @@
   if ( length< INTSIZE )
   {
-    PRINTF(1)("Byte Array to small\n");
+    PRINTF(1)("Byte Array to small : %d\n", length);
     return 0;
   }
@@ -457 +457 @@
  * @return: the used number of bytes in byte array
  */
-int Converter::stringToByteArray( const char * s, byte * a, int length, int maxLength )
-{
-  if ( length+INTSIZE > maxLength )
-  {
-    PRINTF(1)("Byte array is too small (%d) to store %d bytes\n", maxLength, length+INTSIZE);
+int Converter::stringToByteArray( const std::string & s, byte * a, int maxLength )
+{
+  if ( s.length()+INTSIZE > maxLength )
+  {
+    PRINTF(1)("Byte array is too small (%d) to store %d bytes\n", maxLength, s.length()+INTSIZE);
     return -1;
   }
 
-  int n = Converter::intToByteArray( length, a, maxLength );
-
-  memcpy( a+INTSIZE, s, length );
-
-  return length + INTSIZE;
+  int n = Converter::intToByteArray( s.length(), a, maxLength );
+
+  memcpy( a+INTSIZE, s.c_str(), s.length() );
+
+  return s.length() + INTSIZE;
 }
 
@@ -479 +479 @@
  * @return: the number of read bytes in byte array
  */
-int Converter::byteArrayToString( const byte * a, char * s, int maxLength )
+int Converter::byteArrayToString( const byte * a, std::string&s, int maxLength )
 {
   int length;
@@ -488 +488 @@
   if ( length+1 > maxLength )
   {
-    PRINTF(1)("There is not enough space in string (%d) to store %d bytes\n", maxLength, length+1 );
-    strncpy(s,"",maxLength);
+    PRINTF(1)("something went wrong length > remaining bytes in buffer\n" );
+    s = "";
     return -1;
   }
 
-  memcpy( s, a+n, length );
-  s[length] = '\0';
+  s[0] = '\0';
+  s.append( (char*)a+n, length );
 
   return n+length;
 }
 
+#if 0
 /**
  * reads a string out of a byte array and allocates memory for string
@@ -525 +526 @@
   return n+length;
 }
-
+#endif
 
 

trunk/src/lib/network/converter.h

@@ -34 +34 @@
     static int _byteArrayToInt(const byte* a, int* x);
 
-    static int stringToByteArray(const char* s, byte* a, int length, int maxLength);
-    static int byteArrayToString(const byte* a, char* s, int maxLength);
-    static int byteArrayToStringM(const byte* a, char*& s );
+    static int stringToByteArray(const std::string & s, byte* a, int maxLength);
+    static int byteArrayToString(const byte* a, std::string&s, int maxLength);
+//    static int byteArrayToStringM(const byte* a, char*& s );
 
     //Test

trunk/src/lib/network/synchronizeable.h

@@ -199 +199 @@
 }
 #define SYNCHELP_WRITE_STRING(s,n) { SYNCHELP_WRITE_DEBUG(n); \
-                                if (s!=NULL) {\
                                 __synchelp_write_n = \
-                                Converter::stringToByteArray( s, data+__synchelp_write_i, strlen(s), maxLength-__synchelp_write_i ); \
-                                assert( __synchelp_write_n == strlen(s)+INTSIZE ); \
-                                } else {\
-                                __synchelp_write_n = \
-                                Converter::stringToByteArray( "", data+__synchelp_write_i, strlen(""), maxLength-__synchelp_write_i ); \
-                                assert( __synchelp_write_n == strlen("")+INTSIZE ); } \
+                                Converter::stringToByteArray( s, data+__synchelp_write_i, maxLength-__synchelp_write_i ); \
+                                assert( __synchelp_write_n == ((std::string)s).length()+INTSIZE ); \
                                 if ( __synchelp_write_n <= 0) \
 { \
@@ -216 +211 @@
 #define SYNCHELP_WRITE_N        __synchelp_write_i
 #define SYNCHELP_WRITE_FKT(f,n)   { SYNCHELP_WRITE_DEBUG(n); \
-                                  __synchelp_write_i += \
+                                  PRINTF(0)("calling %s with %d left\n", #f, maxLength - __synchelp_write_i);  \
+                                  byte * spos = data+__synchelp_write_i;  \
+                                  if (maxLength - __synchelp_write_i < INTSIZE) \
+{ \
+                                    PRINTF(1)("Buffer is too small to store more data\n"); \
+                                    return 0; \
+} \
+                                  __synchelp_write_i += INTSIZE; \
+                                  __synchelp_write_n = \
                                   f( data+__synchelp_write_i, maxLength-__synchelp_write_i ); \
+                                  __synchelp_write_i += __synchelp_write_n;  \
+                                  Converter::intToByteArray( __synchelp_write_n, spos, INTSIZE ); \
                                 }
 
@@ -244 +249 @@
                                     __synchelp_read_i += __synchelp_read_n; \
 }
-#define SYNCHELP_READ_STRING(s,l,n)    {SYNCHELP_READ_DEBUG(n); \
-                                    __synchelp_read_n = Converter::byteArrayToString( data+__synchelp_read_i, s, l );  \
-                                    assert( __synchelp_read_n == strlen(s)+INTSIZE ) ;\
+#define SYNCHELP_READ_STRING(s,n)    {SYNCHELP_READ_DEBUG(n); \
+                                    __synchelp_read_n = Converter::byteArrayToString( data+__synchelp_read_i, s, length-__synchelp_read_i );  \
+                                    assert( __synchelp_read_n == s.length()+INTSIZE ) ;\
                                     if ( __synchelp_read_n <0 )  \
 { \
@@ -254 +259 @@
                                     __synchelp_read_i += __synchelp_read_n; \
 }
+#if 0 //not needed any more
 #define SYNCHELP_READ_STRINGM(s,n)    { SYNCHELP_READ_DEBUG(n); \
                                     __synchelp_read_n = Converter::byteArrayToStringM( data+__synchelp_read_i, s );  \
@@ -264 +270 @@
                                     __synchelp_read_i += __synchelp_read_n; \
 }
+#endif
 #define SYNCHELP_READ_BYTE(b,n)      { SYNCHELP_READ_DEBUG(n); \
                                     if ( length-__synchelp_read_i < 1 ) \
@@ -274 +281 @@
 }
 #define SYNCHELP_READ_FKT(f,n)   { SYNCHELP_READ_DEBUG(n); \
+                                  int s; \
+                                  if ( length-__synchelp_read_i < INTSIZE ) \
+{ \
+                                      PRINTF(1)("There is not enough data to read an int\n");  \
+                                      return 0; \
+} \
+                                    __synchelp_read_n = Converter::byteArrayToInt( data+__synchelp_read_i, &s );  \
+                                    assert( __synchelp_read_n == INTSIZE ); \
+                                    __synchelp_read_i += __synchelp_read_n; \
                                   __synchelp_read_i += \
-                                  f( data+__synchelp_read_i, length-__synchelp_read_i, sender); \
+                                  f( data+__synchelp_read_i, s, sender); \
                                   }
 #define SYNCHELP_READ_REMAINING() ( length-__synchelp_read_i )