[certi-cvs] certi libCERTI/MessageBuffer.cc libCERTI/Messag...

[certi-cvs]

CVSROOT:        /sources/certi
Module name:    certi
Changes by:     Eric NOULARD <erk>      08/03/03 15:15:09

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

Log message:
        Update MessageBuffer

CVSWeb URLs:
http://cvs.savannah.gnu.org/viewcvs/certi/libCERTI/MessageBuffer.cc?cvsroot=certi&r1=3.6&r2=3.7
http://cvs.savannah.gnu.org/viewcvs/certi/libCERTI/MessageBuffer.hh?cvsroot=certi&r1=3.5&r2=3.6
http://cvs.savannah.gnu.org/viewcvs/certi/test/utility/CertiUtilTests.cc?cvsroot=certi&r1=1.7&r2=1.8

Patches:
Index: libCERTI/MessageBuffer.cc
===================================================================
RCS file: /sources/certi/certi/libCERTI/MessageBuffer.cc,v
retrieving revision 3.6
retrieving revision 3.7
diff -u -b -r3.6 -r3.7
--- libCERTI/MessageBuffer.cc   29 Feb 2008 11:54:54 -0000      3.6
+++ libCERTI/MessageBuffer.cc   3 Mar 2008 15:15:08 -0000       3.7
@@ -20,12 +20,15 @@
 // ----------------------------------------------------------------------------
 
 #include "MessageBuffer.hh"
+#include "PrettyDebug.hh"
 #include <cassert>
 #include <sstream>
 #include <iomanip>
 
 namespace certi {
 
+static PrettyDebug D("MB","MB::");
+
 const bool 
 MessageBuffer::HostIsBigEndian() {
 #ifdef HOST_IS_BIG_ENDIAN
@@ -56,6 +59,8 @@
    }   
 }
 
+const uint8_t MessageBuffer::reservedBytes = 5;
+
 void MessageBuffer::initialize() {
        buffer = NULL;
        bufferMaxSize = DEFAULT_MESSAGE_BUFFER_SIZE;
@@ -99,15 +104,9 @@
                        memcpy(buffer, oldbuf, writeOffset);
                        delete[] oldbuf;
                        oldbuf = NULL;
-               }
-       }
-       
-       /* set up buffer endianess */
-       if ((HostIsBigEndian() && bufferHasMyEndianness) ||
-           (HostIsLittleEndian())) {
-          buffer[0] = 0x01;       
        } else {
-          buffer[0] = 0x00;
+                       updateReservedBytes();
+               }
        }
 } /* end of MessageBuffer::MessageBuffer(uint32_t) */
 
@@ -139,6 +138,7 @@
        bufferHasMyEndianness = true;
        writeOffset           = reservedBytes;
        readOffset            = reservedBytes;
+       updateReservedBytes();
 } /* MessageBuffer::resetBuffer() */
 
 uint32_t MessageBuffer::resize(uint32_t newSize) {
@@ -158,6 +158,7 @@
 }
 
 void MessageBuffer::assumeSizeFromReservedBytes() {
+       uint32_t toBeAssumedSize;
        /* verify endianity from reserved byte 0 */
        if (buffer[0]==0x01) {
                assumeBufferIsBigEndian();
@@ -166,11 +167,26 @@
        }
        /* read size from reserved bytes 1..4 */
        readOffset = 1;
-       assumeSize(this->read_uint32());
-}
-
+       toBeAssumedSize = this->read_uint32();
+       /* reallocation may be needed */
+       reallocate(toBeAssumedSize);
+       assumeSize(toBeAssumedSize);
+} /* end of assumeSizeFromReservedBytes */
+
+void MessageBuffer::setSizeInReservedBytes(uint32_t n) {
+       uint32_t oldWR_Offset;
+       /* backup write Offset */
+       oldWR_Offset = writeOffset;
+       /* update size in reserved bytes */
+       writeOffset  = 1;
+       D.Out(pdTrace,"setSizeInReservedBytes(%u)",n);
+       write_uint32(n);
+       /* restore writeOffset */
+       writeOffset  = oldWR_Offset;    
+} /* end of setSizeInReservedBytes */
 
 int32_t MessageBuffer::write_uint8s(const uint8_t* data, uint32_t n) {
+    D.Out(pdTrace,"write_uint8s(%p = [%u ...] , %d)",data,data[0],n);
 
        if (n >= (bufferMaxSize - writeOffset)) {
                /* reallocate buffer on-demand */
@@ -185,10 +201,9 @@
 } /* end of MessageBuffer::write_uint8s(uint8_t*, uint32_t) */
 
 int32_t MessageBuffer::read_uint8s(uint8_t* data, uint32_t n) {
-
        if (n + readOffset > writeOffset) {
                std::stringstream smsg;
-               smsg << __func__ << "invalid read of siwritePtrze <" << n
+               smsg << __func__ << "::invalid read of siwritePtrze <" << n
                                << "> inside a buffer of readable size <"
                                << (int32_t)writeOffset-readOffset << "> 
(writeOffset="
                                <<writeOffset << ",readOffset="<<readOffset 
<<").";
@@ -197,12 +212,14 @@
 
        memcpy(data, buffer+readOffset, n);
        readOffset += n;
+       D.Out(pdTrace,"read_uint8s(%p = [%u ...], %d)",data,data[0],n);
        return (readOffset-n);
 } /* end of MessageBuffer::read_uint8s(uint8_t*, uint32_t) */
 
 int32_t MessageBuffer::write_uint16s(const uint16_t* data, uint32_t n) {
        uint32_t i;
        uint16_t an_uint16;
+       D.Out(pdTrace,"write_uint16s(%p = [%u ...], %d)",data,data[0],n);
 
        if ((2*n) >= (bufferMaxSize - writeOffset)) {
                /* reallocate buffer on-demand */
@@ -230,7 +247,7 @@
 
        if (2*n + readOffset > writeOffset) {
                std::stringstream smsg;
-               smsg << __func__ << "invalid read of size <" << 2*n
+               smsg << __func__ << "::invalid read of size <" << 2*n
                                << "> inside a buffer of readable size <"
                                << (int32_t)writeOffset-readOffset << "> 
(writeOffset="
                                <<writeOffset << ",readOffset="<<readOffset 
<<").";
@@ -248,12 +265,15 @@
                        readOffset += 2;
                }
        }
+       
+       D.Out(pdTrace,"read_uint16s(%p = [%u ...], %d)",data,data[0],n);
        return (readOffset-2*n);
 } /* end of MessageBuffer::read_uint16s(uint16_t*, uint32_t) */
 
 int32_t MessageBuffer::write_uint32s(const uint32_t* data, uint32_t n) {
        uint32_t i;
        uint32_t an_uint32;
+       D.Out(pdTrace,"write_uint32s(%p = [%u ...] , %d)",data,data[0],n);
 
        if ((4*n) >= (bufferMaxSize - writeOffset)) {
                /* reallocate buffer on-demand */
@@ -281,7 +301,7 @@
 
        if (4*n + readOffset > writeOffset) {
                std::stringstream smsg;
-               smsg << __func__ << "invalid read of size <" << 4*n
+               smsg << __func__ << "::invalid read of size <" << 4*n
                                << "> inside a buffer of readable size <"
                                << (int32_t)writeOffset-readOffset << "> 
(writeOffset="
                                <<writeOffset << ",readOffset="<<readOffset 
<<").";
@@ -293,15 +313,15 @@
                memcpy(data, buffer+readOffset, 4*n);
                readOffset += 4*n;
        } else {
-               
                for (i=0; i<n; ++i) {
                        memcpy(&an_uint32,buffer+readOffset,4);
                        data[i] = CERTI_UINT32_SWAP_BYTES(an_uint32);
                        readOffset += 4;
                }
        }
+       D.Out(pdTrace,"read_uint32s(%p = [%u ...], %d)",data,data[0],n);
        return (readOffset-4*n);
-}
+} /* end of read_uint32s */
 
 int32_t MessageBuffer::write_uint64s(const uint64_t* data, uint32_t n) {
        uint32_t i;
@@ -311,6 +331,8 @@
        } a_deux32;
        uint32_t an_uint32;
 
+       D.Out(pdTrace,"write_uint64s(%p , %d)",data,n);
+       
        if ((8*n) >= (bufferMaxSize - writeOffset)) {
                /* reallocate buffer on-demand */
                reallocate(bufferMaxSize+ (8*n)-(bufferMaxSize - writeOffset)
@@ -333,7 +355,7 @@
                }
        }
        return (writeOffset-8*n);
-}
+} /* end of write_uint64s */
 
 int32_t MessageBuffer::read_uint64s(uint64_t* data, uint32_t n) {
        uint32_t i;
@@ -342,10 +364,11 @@
                        uint64_t    ui64;
        } a_deux32;
        uint32_t an_uint32;     
+       D.Out(pdTrace,"read_uint64s(%p , %d)",data,n);
 
        if (8*n + readOffset > writeOffset) {
                std::stringstream smsg;
-               smsg << __func__ << "invalid read of size <" << 4*n
+               smsg << __func__ << "::invalid read of size <" << 4*n
                                << "> inside a buffer of readable size <"
                                << (int32_t)writeOffset-readOffset << "> 
(writeOffset="
                                <<writeOffset << ",readOffset="<<readOffset 
<<").";
@@ -374,24 +397,28 @@
 
 int32_t MessageBuffer::write_floats(const float* data, uint32_t n) {
        const uint32_t* data32;
+       D.Out(pdTrace,"write_floats(%p = [%f ...], %d)",data,data[0],n);
        data32 = reinterpret_cast<const uint32_t*>(data);       
        return write_uint32s(data32,n);
 }
 
 int32_t MessageBuffer::read_floats(float* data, uint32_t n) {
        uint32_t* data32;
+       D.Out(pdTrace,"read_floats(%p , %d)",data,n);
        data32 = reinterpret_cast<uint32_t*>(data);     
        return read_uint32s(data32,n);  
 }
 
 int32_t MessageBuffer::write_doubles(const double* data, uint32_t n) {
        const uint64_t* data64;
+       D.Out(pdTrace,"write_doubles(%p = [%f ...], %d)",data,data[0],n);       
        data64 = reinterpret_cast<const uint64_t*>(data);       
        return write_uint64s(data64,n); 
 }
 
 int32_t MessageBuffer::read_doubles(double* data, uint32_t n) {
        uint64_t* data64;
+       D.Out(pdTrace,"read_doubles(%p , %d)",data,n);
        data64 = reinterpret_cast<uint64_t*>(data);     
        return read_uint64s(data64,n);
 }
@@ -400,7 +427,7 @@
 MessageBuffer::write_string(const std::string& str) {
    write_int32(str.length());
    return write_chars(str.c_str(),str.length());
-}
+} /* end of write_string */
   
 std::string 
 MessageBuffer::read_string() {
@@ -417,7 +444,19 @@
  retval = std::string(buf);
  delete[] buf;
  return retval;
-}
+} /* end of read_string */
+
+void MessageBuffer::updateReservedBytes() {
+       /* set up buffer endianess */
+       if ((HostIsBigEndian() && bufferHasMyEndianness) ||
+           (HostIsLittleEndian() && !bufferHasMyEndianness)) {
+          buffer[0] = 0x01;       
+       } else {
+          buffer[0] = 0x00;
+       }
+    /* set up size */  
+       setSizeInReservedBytes(size()); 
+} /* end of updateReservedBytes */
 
 void*
 MessageBuffer::operator ()(uint32_t offset) {  

Index: libCERTI/MessageBuffer.hh
===================================================================
RCS file: /sources/certi/certi/libCERTI/MessageBuffer.hh,v
retrieving revision 3.5
retrieving revision 3.6
diff -u -b -r3.5 -r3.6
--- libCERTI/MessageBuffer.hh   29 Feb 2008 11:54:54 -0000      3.5
+++ libCERTI/MessageBuffer.hh   3 Mar 2008 15:15:09 -0000       3.6
@@ -65,7 +65,7 @@
         * The 4 following bytes is for an uint32_t which
         * may be used to store the buffer size
         */ 
-       static const uint8_t reservedBytes = 5;
+       static const uint8_t reservedBytes;
 
        /**
         * Default message buffer constructor.
@@ -254,6 +254,8 @@
                return *this;
        }
        
+       void updateReservedBytes();
+       
        /*
         * Pseudo index operator.
         * This will be used in send/receive socket call.
@@ -283,6 +285,7 @@
 
        void initialize();
        void reallocate(uint32_t n);
+       void setSizeInReservedBytes(uint32_t n);
 };
 
 } // certi

Index: test/utility/CertiUtilTests.cc
===================================================================
RCS file: /sources/certi/certi/test/utility/CertiUtilTests.cc,v
retrieving revision 1.7
retrieving revision 1.8
diff -u -b -r1.7 -r1.8
--- test/utility/CertiUtilTests.cc      29 Feb 2008 11:54:54 -0000      1.7
+++ test/utility/CertiUtilTests.cc      3 Mar 2008 15:15:09 -0000       1.8
@@ -51,6 +51,7 @@
 #endif
 
 void messageBufferTests(certi::MessageBuffer& MsgBuf) {
+       certi::MessageBuffer MsgBuf2;
        std::string    stdstr = "a std:string";
        const char*   str = "a char* string";
        uint8_t  u8   =  232;
@@ -200,6 +201,27 @@
        vstdstr = "";
        vstdstr = MsgBuf.read_string();
        cout << "    (re)Read String is   " << vstdstr << endl;
+       
+       cout << "    preparing a buffer for network send..." <<endl;
+       MsgBuf.reset();
+       MsgBuf.write_uint32(u32);
+       MsgBuf.write_uint8(u8);
+       MsgBuf.write_uint16(u16);
+       MsgBuf.updateReservedBytes();
+       cout << "    now (pseudo) sending a buffer of size " << MsgBuf.size() 
<< " bytes ..." << endl;
+       memcpy(MsgBuf2(0),MsgBuf(0),MsgBuf.reservedBytes);      
+       printf("MsgBuf = 
");MsgBuf.show(MsgBuf(0),MsgBuf.reservedBytes);printf("\n");
+       printf("MsgBuf = 
");MsgBuf2.show(MsgBuf(0),MsgBuf2.reservedBytes);printf("\n");
+       cout << "    now (pseudo) receiving buffer header of " << (uint32_t) 
MsgBuf.reservedBytes << " bytes ..." << endl;
+       cout << "    reconstruct receive buffer size from buffer header ..." 
<<endl;
+       MsgBuf2.assumeSizeFromReservedBytes();
+       cout << "    seems to contain " << MsgBuf2.size() << " bytes..."<<endl;
+       cout << "    now (pseudo) receiving buffer content ..." <<endl;
+       
memcpy(MsgBuf2(MsgBuf.reservedBytes),MsgBuf(MsgBuf.reservedBytes),MsgBuf2.size());
+       cout << "    reading buffer content..." <<endl;
+       vu32 = MsgBuf.read_uint32(); assert(vu32==u32);
+       vu8  = MsgBuf.read_uint8(); assert(vu8==u8);
+       vu16 = MsgBuf.read_uint16(); assert(vu16==u16);
        cout << "Testing MessageBuffer class END."<<endl;
 } /* end of messageBufferTests */