[Cppunit-cvs] cppunit2/src/opentest serializer.cpp,1.1,1.2

[Baptiste L. <bl...@us...>]

Update of /cvsroot/cppunit/cppunit2/src/opentest
In directory sc8-pr-cvs1.sourceforge.net:/tmp/cvs-serv25409/src/opentest

Modified Files:
	serializer.cpp 
Log Message:
Extracted packet management to handle the dual packet cursor cleanly (cursor for serialization and transport).

Index: serializer.cpp
===================================================================
RCS file: /cvsroot/cppunit/cppunit2/src/opentest/serializer.cpp,v
retrieving revision 1.1
retrieving revision 1.2
diff -C2 -d -r1.1 -r1.2
*** serializer.cpp	24 Jun 2005 08:23:50 -0000	1.1
--- serializer.cpp	26 Jun 2005 19:41:15 -0000	1.2
***************
*** 4,7 ****
--- 4,8 ----
   
  namespace OpenTest {
+ 
  /*
  0x20:  0x21:! 0x22:" 0x23:# 0x24:$ 0x25:% 0x26:& 0x27:' 0x28:( 0x29:) 0x2a:* 0x2b:+ 0x2c:, 0x2d:- 0x2e:. 0x2f:/ 
***************
*** 40,108 ****
  };
  
  
! 
! Stream::Stream() 
!    : current_( buffers_.begin() )
!    , currentData_( 0 )
!    , endData_( 0 )
!    , writeBufferSize_( 16384 )
!    , error_( 0 )
  {
  }
  
! Stream::~Stream() 
  {
!    while ( !buffers_.empty() )
     {
!       delete[] (unsigned char *)buffers_.back().data_;
!       buffers_.pop_back();
     }
  }
  
  
! bool 
! Stream::inError() const
  {
!    return error_ != 0;
  }
  
! Stream &
! Stream::setError( const char *errorMessage )
  {
!    if ( !error_ )
!       error_ = errorMessage;
!    return *this;
  }
  
  
! void 
! Stream::addBuffer( unsigned int length, 
!                    const void *data )
  {
!    write( data, length );
  
!    current_ = buffers_.begin();
!    currentData_ = current_->data_;
!    endData_ = currentData_ + length;
  }
  
  
  unsigned char 
! Stream::readNextByte()
  {
!    if ( currentData_ != endData_ )
!       return *currentData_++;
! 
!    if ( current_ != buffers_.end() )
     {
!       ++current_;
!       if ( current_ != buffers_.end() )
        {
!          currentData_ = current_->data_;
!          endData_ = currentData_ + current_->length_;
!          CPPTL_ASSERT_MESSAGE( currentData_ != endData_, 
!                                "invariant violation: 0 length data buffer" );
!          return *currentData_++;
        }
     }
     return ccEndBuffer;
--- 41,115 ----
  };
  
+ // //////////////////////////////////////////////////////////////////
+ // //////////////////////////////////////////////////////////////////
+ // class Packets
+ // //////////////////////////////////////////////////////////////////
+ // //////////////////////////////////////////////////////////////////
  
! Packets::Packets()
!    : packetsHead_( 0 )
!    , defaultPacketSize_( 16384 )
  {
  }
  
! Packets::~Packets()
  {
!    Packet *current = packetsHead_;
!    while ( current )
     {
!       Packet *toDelete = current;
!       current = current->next_;
!       delete toDelete;
     }
  }
  
  
! void 
! Packets::beginMessage()
  {
!    appendPacketIfFull( externalPos_ );
!    MessagePacket message;
!    message.position_ = externalPos_;
!    message.length_ = 0;
!    messages_.push_back( message );
  }
  
! 
! void 
! Packets::received( void *data, Pos length )
  {
!    write( externalPos_, static_cast<Byte *>( data ), length );
  }
  
  
! unsigned int 
! Packets::send( void *dest, 
!                Pos availableLength )
  {
!    return read( externalPos_, static_cast<Byte *>( dest ), availableLength );
! }
  
! 
! void 
! Packets::endMessage()
! {
!    CPPTL_ASSERT_MESSAGE( !messages_.empty()  &&  messages_.back().length_ == 0, 
!                          "No message started." );
!    messages_.back().length_ = distance( messages_.back().position_, externalPos_ );
  }
  
  
  unsigned char 
! Packets::serializationReadNextByte()
  {
!    if ( serializePos_ )
     {
!       if ( serializePos_.currentData_ == serializePos_.packet_->endInitialized_ )
        {
!          if ( serializePos_.packet_->next_ == 0 )
!             return ccEndBuffer;
!          serializePos_.seekToNextPacket();
        }
+       return *(serializePos_.currentData_++);
     }
     return ccEndBuffer;
***************
*** 110,202 ****
  
  void 
! Stream::ungetLastByte()
  {
!    if ( current_ != buffers_.end() )
!    {
!       if ( current_->data_ != currentData_ )
!       {
!          --currentData_;
!          return;
!       }
!       CPPTL_ASSERT_MESSAGE( current_ != buffers_.begin(), 
!                             "No byte to 'unput'" );
!       --current_;
!       endData_ = current_->data_ + current_->length_;
!       currentData_ =  endData_ - 1;
!    }
  }
  
  void 
! Stream::read( void *buffer, unsigned int length )
  {
!    unsigned char *target = static_cast<unsigned char *>( buffer );
!    unsigned int lengthToCopy = CPPTL_MIN( length, endData_ - currentData_ );
!    memcpy( target, currentData_, lengthToCopy );
!    length -= lengthToCopy;
!    currentData_ += lengthToCopy;
!    if ( length != 0 ) // there was not enough data, use next buffers
     {
!       target += lengthToCopy;
!       ++current_;
!       while ( current_ != buffers_.end() )
!       {
!          lengthToCopy = CPPTL_MIN( length, current_->length_ );
!          memcpy( target, current_->data_, lengthToCopy );
!          target += lengthToCopy;
!          length -= lengthToCopy;
!          if ( length == 0 )
!          {
!             currentData_ = current_->data_ + lengthToCopy;
!             endData_ = current_->data_ + current_->length_;
!             break;
!          }
!          ++current_;
!       }
!       if ( length != 0 )
!       {
!          setError( "Attempted to read beyond buffer end." );
!          currentData_ = endData_;
!       }
     }
  }
  
  
! void 
! Stream::write( unsigned char byte )
  {
!    if ( currentData_ != endData_ )
!       *currentData_++ = byte;
     else
!       write( &byte, 1 );
  }
  
  
  void 
! Stream::write( const void *buffer, unsigned int length )
  {
     if ( length == 0 )
        return;
  
!    const unsigned char *source = static_cast<const unsigned char *>( buffer );
!    unsigned int availableLength = endData_ - currentData_;
!    if ( availableLength < length )
     {
!       memcpy( currentData_, source, availableLength );
!       source += availableLength;
!       length -= availableLength;
     }
  
-    unsigned int newBufferLength = length + writeBufferSize_;
-    BufferData dataBuffer;
-    dataBuffer.length_ = newBufferLength;
-    typedef unsigned char BufferElementType;
-    unsigned char *newData = new BufferElementType[ newBufferLength ];
-    memcpy( newData, source, length );
-    dataBuffer.data_ = newData;
-    buffers_.push_back( dataBuffer );
  
!    current_ = buffers_.end() - 1;
!    currentData_ = newData + length;
!    endData_ = newData + newBufferLength;
  }
  
--- 117,308 ----
  
  void 
! Packets::serializationUngetLastByte()
  {
!    CPPTL_ASSERT_MESSAGE( serializePos_, "No byte to unget" );
!    if ( serializePos_.currentData_ > serializePos_.packet_->begin_ )
!       --serializePos_.currentData_;
!    else
!       serializePos_.seekBeforeEndOfPreviousPacket();
! }
! 
! bool 
! Packets::serializationRead( void *buffer, 
!                             Pos length )
! {
!    return read( serializePos_, static_cast<Byte *>( buffer ), length ) == length;
  }
  
  void 
! Packets::serializationWrite( const void *buffer, 
!                              Pos length )
  {
!    write( serializePos_, static_cast<const Byte *>( buffer ), length );
! }
! 
! void 
! Packets::serializationWrite( unsigned char byte )
! {
! }
! 
! 
! void 
! Packets::appendPacketIfFull( PacketPos &pos )
! {
!    if ( !pos  ||  pos.currentData_ == pos.packet_->end_ )
     {
!       Packet *packet = new Packet( defaultPacketSize_, pos.packet_ );
!       if ( !packetsHead_ )
!          packetsHead_ = packet;
!       pos = PacketPos( packet );
!       if ( !serializePos_ )
!          serializePos_ = pos;
!       if ( !externalPos_ )
!          externalPos_ = pos;
     }
  }
  
  
! Packets::Pos 
! Packets::distance( const PacketPos &begin, 
!                    const PacketPos &end ) const
  {
!    Pos dist = 0;
!    for ( Packet *current = begin.packet_; current != end.packet_; current = current->next_ )
!       dist += current->length();
!    if ( begin.packet_ != end.packet_ )
!    {
!       dist += begin.packet_->end_ - begin.currentData_;
!       dist += end.offset();
!    }
     else
!       dist += end.currentData_ - begin.currentData_;
!    return dist;
  }
  
  
  void 
! Packets::write( PacketPos &pos, const Byte *data, Pos length )
  {
     if ( length == 0 )
        return;
  
!    if ( !pos )
!       appendPacketIfFull( pos );
! 
!    Pos writeLength  = CPPTL_MIN( pos.availableForWriting(), length );
!    memcpy( pos.currentData_, data, writeLength );
!    length -= writeLength;
!    pos.currentData_ += writeLength;
!    pos.packet_->endInitialized_ += writeLength;
!    while ( length > 0 )
     {
!       data += writeLength;
!       CPPTL_ASSERT_MESSAGE( pos.currenData_ == pos.packet_->end_, 
!                             "Should be at the end of the current packet" );
!       appendPacketIfFull( pos );
!       writeLength  = CPPTL_MIN( pos.packet_->length(), length );
!       memcpy( pos.packet_->begin_, data, writeLength );
!       length -= writeLength;
!       pos.packet_->endInitialized_ += writeLength;
!       pos.currentData_ = pos.packet_->offset( writeLength );
     }
+ }
  
  
! Packets::Pos 
! Packets::read( PacketPos &pos, Byte *data, Pos length )
! {
!    if ( !pos )
!       return 0;
! 
!    Pos initialLength = length;
!    while ( length > 0 )
!    {
!       pos.seekToNextPacketIfAtEnd();
!       Pos readLength = CPPTL_MIN( length, pos.availableForReading() );
!       if ( readLength == 0 )
!          break;
!       memcpy( data, pos.currentData_, readLength );
!       length -= readLength;
!       pos.currentData_ += readLength;
!       data += readLength;
!    }
!    return initialLength - length;
! }
! 
! 
! 
! 
! // //////////////////////////////////////////////////////////////////
! // //////////////////////////////////////////////////////////////////
! // class Stream
! // //////////////////////////////////////////////////////////////////
! // //////////////////////////////////////////////////////////////////
! 
! 
! 
! Stream::Stream() 
!    : error_( 0 )
! {
! }
! 
! Stream::~Stream() 
! {
! }
! 
! 
! Packets &
! Stream::packets()
! {
!    return packets_;
! }
! 
! 
! bool 
! Stream::inError() const
! {
!    return error_ != 0;
! }
! 
! Stream &
! Stream::setError( const char *errorMessage )
! {
!    if ( !error_ )
!       error_ = errorMessage;
!    return *this;
! }
! 
! 
! unsigned char 
! Stream::readNextByte()
! {
!    return packets_.serializationReadNextByte();
! }
! 
! void 
! Stream::ungetLastByte()
! {
!    packets_.serializationUngetLastByte();
! }
! 
! void 
! Stream::read( void *buffer, unsigned int length )
! {
!    if ( !packets_.serializationRead( buffer, length ) )
!       setError( "Attempted to read beyond buffer end." );
! }
! 
! 
! void 
! Stream::write( unsigned char byte )
! {
!    packets_.serializationWrite( byte );
! }
! 
! 
! void 
! Stream::write( const void *buffer, unsigned int length )
! {
!    packets_.serializationWrite( buffer, length );
  }