certi libCERTI/MessageBuffer.cc libCERTI/Messag...

[certi-cvs]

CVSROOT:        /sources/certi
Module name:    certi
Changes by:     Eric NOULARD <erk>      08/02/15 13:24:07

Modified files:
        libCERTI       : MessageBuffer.cc MessageBuffer.hh 
        test/utility   : CertiUtilTests.cc 

Log message:
        MessageBuffer update

CVSWeb URLs:
http://cvs.savannah.gnu.org/viewcvs/certi/libCERTI/MessageBuffer.cc?cvsroot=certi&r1=3.1&r2=3.2
http://cvs.savannah.gnu.org/viewcvs/certi/libCERTI/MessageBuffer.hh?cvsroot=certi&r1=3.2&r2=3.3
http://cvs.savannah.gnu.org/viewcvs/certi/test/utility/CertiUtilTests.cc?cvsroot=certi&r1=1.3&r2=1.4

Patches:
Index: libCERTI/MessageBuffer.cc
===================================================================
RCS file: /sources/certi/certi/libCERTI/MessageBuffer.cc,v
retrieving revision 3.1
retrieving revision 3.2
diff -u -b -r3.1 -r3.2
--- libCERTI/MessageBuffer.cc   14 Feb 2008 15:29:58 -0000      3.1
+++ libCERTI/MessageBuffer.cc   15 Feb 2008 13:24:06 -0000      3.2
@@ -22,9 +22,40 @@
 #include "MessageBuffer.hh"
 #include <cassert>
 #include <sstream>
+#include <iomanip>
 
 namespace certi {
 
+const bool 
+MessageBuffer::HostIsBigEndian() {
+#ifdef HOST_IS_BIG_ENDIAN
+       return true;
+#else    
+       return false;
+#endif
+}
+
+const bool 
+MessageBuffer::HostIsLittleEndian() {
+#ifdef HOST_IS_BIG_ENDIAN
+       return false;
+#else    
+       return true;
+#endif
+}
+
+void
+MessageBuffer::show(const void* data, uint32_t n) {
+   uint32_t i;
+   const uint8_t* u8data = reinterpret_cast<const uint8_t*>(data);
+   for (i=0;i<n;++i) {
+          if ((0==(i%2))&&(i>0)) {
+                          printf(" ");
+          }
+          printf("%02X",u8data[i]);      
+   }   
+}
+
 void MessageBuffer::initialize() {
        buffer = NULL;
        bufferMaxSize = DEFAULT_MESSAGE_BUFFER_SIZE;
@@ -87,19 +118,11 @@
 }
 
 void MessageBuffer::assumeBufferIsBigEndian() {
-#ifdef HOST_IS_BIG_ENDIAN
-       this->bufferHasMyEndianness = true;
-#else    
-       this->bufferHasMyEndianness = false;
-#endif
+       this->bufferHasMyEndianness = HostIsBigEndian();
 } /* end of MessageBuffer::assumeBufferIsBigEndian() */
 
 void MessageBuffer::assumeBufferIsLittleEndian() {
-#ifdef HOST_IS_BIG_ENDIAN
-       this->bufferHasMyEndianness = false;
-#else    
-       this->bufferHasMyEndianness = true;
-#endif    
+       this->bufferHasMyEndianness = HostIsLittleEndian();    
 } /* end of MessageBuffer::assumeBufferIsLittleEndian() */
 
 void MessageBuffer::resetBuffer() {
@@ -258,9 +281,10 @@
        } else {
                buffer_uint32 = reinterpret_cast<uint32_t*>(buffer+writeOffset);
                data32 = reinterpret_cast<const uint32_t*>(data);
-               for (i=0; i<2*n; ++i) {
-                       buffer_uint32[i] = CERTI_UINT32_SWAP_BYTES(data32[i]);
-                       writeOffset += 4;
+               for (i=0; i<n; ++i) {
+                       buffer_uint32[i] = CERTI_UINT32_SWAP_BYTES(data32[i+1]);
+                       buffer_uint32[i+1] = CERTI_UINT32_SWAP_BYTES(data32[i]);
+                       writeOffset += 8;
                }
        }
        return (writeOffset-8*n);
@@ -287,9 +311,10 @@
        } else {
                buffer_uint32 = reinterpret_cast<uint32_t*>(buffer+readOffset);
                data32 = reinterpret_cast<uint32_t*>(data);
-               for (i=0; i<2*n; ++i) {
-                       data32[i] = CERTI_UINT32_SWAP_BYTES(buffer_uint32[i]);
-                       readOffset += 4;
+               for (i=0; i<n; ++i) {
+                       data32[i+1] = CERTI_UINT32_SWAP_BYTES(buffer_uint32[i]);
+                       data32[i] = CERTI_UINT32_SWAP_BYTES(buffer_uint32[i+1]);
+                       readOffset += 8;
                }
        }
        return (readOffset-8*n);
@@ -319,5 +344,37 @@
        return read_uint64s(data64,n);
 }
 
+int32_t
+MessageBuffer::write_string(const std::string& str) {
+   write_int32(str.length());
+   write_chars(str.c_str(),str.length());
+}
+  
+std::string 
+MessageBuffer::read_string() {
+ std::string retval;
+ int32_t len;
+ char* buf;
+ 
+ read_int32(&len);
+ buf = new char[len+1];
+ read_chars(buf,len);
+ /* terminate the string */
+ buf[len] = '\0';
+ /* build an std::string and retrun it */
+ retval = std::string(buf);
+ delete[] buf;
+ return retval;
+}
+
+MessageBuffer::operator const void*(){
+       return buffer;
+}
+
+MessageBuffer::operator void*() {
+       return buffer;
+}
+
+
 } // certi
 

Index: libCERTI/MessageBuffer.hh
===================================================================
RCS file: /sources/certi/certi/libCERTI/MessageBuffer.hh,v
retrieving revision 3.2
retrieving revision 3.3
diff -u -b -r3.2 -r3.3
--- libCERTI/MessageBuffer.hh   14 Feb 2008 15:49:40 -0000      3.2
+++ libCERTI/MessageBuffer.hh   15 Feb 2008 13:24:07 -0000      3.3
@@ -42,6 +42,21 @@
 class CERTI_EXPORT MessageBuffer
 {
 public:
+
+  /**
+   * Return true if the host is BidEndian
+   */
+  static const bool HostIsBigEndian();
+  /**
+        * Return true if the host is LittleEndian
+        */
+  static const bool HostIsLittleEndian();
+  
+  /**
+   * Show n bytes of data content in hexa on ostream. 
+   */
+  static void show(const void* data, uint32_t n);
+  
   /**
    * Default message buffer constructor.
    * The default message buffer size is DEFAULT_MESSAGE_BUFFER_SIZE.
@@ -185,11 +200,30 @@
   
   DECLARE_SINGLE_READ_WRITE(double,)    
   
-  MessageBuffer& operator<<(uint8_t data) {
+  int32_t
+  write_string(const std::string& str);
+  
+  std::string 
+  read_string();
+  
+  MessageBuffer& operator<<(const uint8_t data) {
          this->write_uint8(data);
          return *this;
   }
 
+  /**
+   * Cast operator to const void*
+   * to be used (for example) in send system call.
+   */
+  
+  operator const void *();
+  
+  /**
+   * Cast operator to void*
+   * To be used (for example) in recv system call.
+   */
+  operator void *();
+
 private: 
   /** The buffer itself */
   uint8_t*         buffer;  

Index: test/utility/CertiUtilTests.cc
===================================================================
RCS file: /sources/certi/certi/test/utility/CertiUtilTests.cc,v
retrieving revision 1.3
retrieving revision 1.4
diff -u -b -r1.3 -r1.4
--- test/utility/CertiUtilTests.cc      14 Feb 2008 15:29:58 -0000      1.3
+++ test/utility/CertiUtilTests.cc      15 Feb 2008 13:24:07 -0000      1.4
@@ -30,6 +30,7 @@
 #include "PrettyDebug.hh"
 #include "MessageBuffer.hh"
 #include <cassert>
+#include <string>
 
 #include "Clock.hh"
 void clockTests(certi::Clock& aClock) {
@@ -52,6 +53,7 @@
 #endif
 
 void messageBufferTests(certi::MessageBuffer& MsgBuf) {
+       std::string    stdstr = "a std:string";
        const char*   str = "bouhlala";
        uint8_t  u8   =  232;
        int8_t   i8   = -125;
@@ -64,6 +66,7 @@
        float    f32  = 3.1415927;
        double   d64  = 2.7182818;
        char*    vstr = NULL;   
+       std::string  vstdstr;
        uint8_t  vu8   = 0;
        int8_t   vi8   = 0;
        uint16_t vu16  = 0;
@@ -75,8 +78,8 @@
        float    vf32  = 0.0;
        double   vd64  = 0.0;   
        cout << "Testing MessageBuffer class BEGIN..."<<endl;
-       cout << "    Default MessageBuffer MaxSize               ="<< 
MsgBuf.maxSize() <<endl;
-       cout << "    Current (initially void) MessageBuffer size ="<< 
MsgBuf.size()<<endl;
+       cout << "    Default MessageBuffer MaxSize               = "<< 
MsgBuf.maxSize() <<endl;
+       cout << "    Current (initially void) MessageBuffer size = "<< 
MsgBuf.size()<<endl;
        cout << "    Encoding to buffer..." <<endl;
        cout << "    bytes string = " << str << endl;
        MsgBuf.write_uint32(strlen(str)+1);
@@ -91,6 +94,8 @@
        MsgBuf.write_int64(i64);
        MsgBuf.write_float(f32);
        MsgBuf.write_double(d64);
+       cout << "    std::string = " << stdstr << endl;
+       MsgBuf.write_string(stdstr);
        cout << "    Current MessageBuffer size                  = "<< 
MsgBuf.size()<<endl;
        cout << "    Decoding from buffer..." <<endl;
        MsgBuf.read_uint32(&vu32);
@@ -108,12 +113,48 @@
        MsgBuf.read_int64(&vi64); assert(vi64==i64);
        MsgBuf.read_float(&vf32); assert(vf32==f32);
        MsgBuf.read_double(&vd64); assert(vd64==d64);
+       vstdstr  = MsgBuf.read_string(); assert(vstdstr==stdstr);
+       cout << "    std::string = " << vstdstr << endl;
     cout << "    All encoded/decoded values are equal." << endl;
+       cout << "    Now reset buffer." << endl;
+       MsgBuf.resetBuffer();
+       cout << "    Re-write on buffer..." << endl;
+       MsgBuf.write_uint8(u8);  cout << "        Written <"; 
certi::MessageBuffer::show(&u8,1); cout << ">" << endl;
+       MsgBuf.write_uint16(u16);cout << "        Written <"; 
certi::MessageBuffer::show(&u16,2); cout << ">" << endl;
+       MsgBuf.write_uint32(u32);cout << "        Written <"; 
certi::MessageBuffer::show(&u32,4); cout << ">" << endl;
+       MsgBuf.write_uint64(u64);cout << "        Written <"; 
certi::MessageBuffer::show(&u64,8); cout << ">" << endl;
+       MsgBuf.write_int8(i8);cout << "        Written <"; 
certi::MessageBuffer::show(&i8,1); cout << ">" << endl;
+       MsgBuf.write_int16(i16);cout << "        Written <"; 
certi::MessageBuffer::show(&i16,2); cout << ">" << endl;
+       MsgBuf.write_int32(i32);cout << "        Written <"; 
certi::MessageBuffer::show(&i32,4); cout << ">" << endl;
+       MsgBuf.write_int64(i64);cout << "        Written <"; 
certi::MessageBuffer::show(&i64,8); cout << ">" << endl;
+       MsgBuf.write_float(f32);cout << "        Written <"; 
certi::MessageBuffer::show(&f32,4); cout << ">" << endl;
+       MsgBuf.write_double(d64);cout << "        Written <"; 
certi::MessageBuffer::show(&d64,8); cout << ">" << endl;
+
+       cout << "    ...and assume it is ";    
+       if (certi::MessageBuffer::HostIsBigEndian()) {
+               cout << "Little Endian";
+               MsgBuf.assumeBufferIsLittleEndian();
+               cout << " whereas the host was big" << endl;
+       }
+       if (certi::MessageBuffer::HostIsLittleEndian()) {
+               cout << "Big Endian";
+               MsgBuf.assumeBufferIsBigEndian();
+               cout << " whereas the host was little" << endl;
+       }
+       MsgBuf.read_uint8(&vu8);  cout << "        Read  <"; 
certi::MessageBuffer::show(&vu8,1); cout << ">" << endl;
+       MsgBuf.read_uint16(&vu16);cout << "        Read <"; 
certi::MessageBuffer::show(&vu16,2); cout << ">" << endl;
+       MsgBuf.read_uint32(&vu32);cout << "        Read <"; 
certi::MessageBuffer::show(&vu32,4); cout << ">" << endl;
+       MsgBuf.read_uint64(&vu64);cout << "        Read <"; 
certi::MessageBuffer::show(&vu64,8); cout << ">" << endl;
+       MsgBuf.read_int8(&vi8);cout << "        Read <"; 
certi::MessageBuffer::show(&vi8,1); cout << ">" << endl;
+       MsgBuf.read_int16(&vi16);cout << "        Read <"; 
certi::MessageBuffer::show(&vi16,2); cout << ">" << endl;
+       MsgBuf.read_int32(&vi32);cout << "        Read <"; 
certi::MessageBuffer::show(&vi32,4); cout << ">" << endl;
+       MsgBuf.read_int64(&vi64);cout << "        Read <"; 
certi::MessageBuffer::show(&vi64,8); cout << ">" << endl;
+       MsgBuf.read_float(&vf32);cout << "        Read <"; 
certi::MessageBuffer::show(&vf32,4); cout << ">" << endl;
+       MsgBuf.read_double(&vd64);cout << "        Read <"; 
certi::MessageBuffer::show(&vd64,8); cout << ">" << endl;
     
        cout << "Testing MessageBuffer class END."<<endl;
 } /* end of messageBufferTests */
 
-
 int
 main(int argc, char **argv)
 {      
@@ -127,13 +168,14 @@
 
     cout << "CERTI Utility Tests->BEGIN..."<< endl ;
 
-       cout << "    Host is " << 
-#ifdef HOST_IS_BIG_ENDIAN
-         "Big Endian"
-#else
-         "Little Endian"
-#endif
-            << endl;   
+       cout << "    Host is ";
+       if (certi::MessageBuffer::HostIsBigEndian()) {
+               cout << "Big Endian";
+       }
+       if (certi::MessageBuffer::HostIsLittleEndian()) {
+               cout << "Little Endian";
+       }
+       cout << endl;   
     messageBufferTests(MsgBuf);
 #ifdef HAVE_TSC_CLOCK
     clockTests(tscClk);