struct sbtsWData
{
	short length, pointer;
	short opcode;
	short packetSize;
	char  *data;

	/// Constructor
	sbtsWData( ):data( 0 ), length( 0 ), opcode( 0 ), pointer( 0 ) { }

	 // Destructor
	~sbtsWData( ) {
		clear( );
	}

	void Initialise( unsigned short newLength, unsigned short newOpcode ) {
		
		packetSize = newLength;
		setLength( newLength );
		opcode = newOpcode;
	}	

	void clear( ) {
    if( data )
      delete [] data;
		data = 0;
		opcode = 0;
	}

	short GetPacketSize() { return packetSize; }

	void setLength( unsigned short newlength )
	{
	    if( (newlength > length) | (data==0) ) {
		clear( );
		data = new char[newlength];
		}else 
		{		
			pointer = 0; opcode = 0;
		}
		length=newlength;
	}

	template < class type > inline sbtsWData & operator<<( const type &newData  ) {
    writeData( newData );
    return *this;
	}
	  template < class type > inline sbtsWData & operator>>( type &newData ) {
		readData( newData );
		return *this;
	}
  
	inline sbtsWData & operator<<( const char * newData ) {
		writeData( newData );
		return *this;
	}
	inline sbtsWData & operator>>( char * newData ) {
		readData( newData );
		return *this;
	}
  
	inline short & writeData( const void * newData, const short datalength ) {
		return pointer = writeDataAt( pointer, newData, datalength );
	}
	inline short & readData( void * newData, const short datalength ) {
		return pointer = readDataAt( pointer, newData, datalength );
	}

	template < class type > inline short & writeData( const type &newData ) {
		return pointer = writeDataAt( pointer, newData );
	}
	template < class type > inline short & readData( type &newData ) {
		return pointer = readDataAt( pointer, newData );
	}

	inline short & writeData( const char * newData ) {
		return pointer = writeDataAt( pointer, newData );
	}
	inline short & readData( char * newData ) {
		return pointer = readDataAt( pointer, newData );
	}

	inline short writeDataAt( const short offset, const char * newData ) {
		short dlen = strlen( newData ) + 1;
		WPAssert( offset + dlen <= length );
		memcpy( data + offset, newData, dlen );
		return offset + dlen;
	}
	inline short readDataAt( const short offset, char * newData ) {
		short dlen = strlen( (char *)data + offset ) + 1; 
		WPAssert( offset + dlen <= length );
		memcpy( newData, data + offset, dlen );
		return offset + dlen;
	}

	template < class type > inline short writeDataAt( const short offset, const type &newData ) {
		WPAssert( offset + sizeof( type ) <= length );
		memcpy( data + offset, &newData, sizeof( type ) );
		return offset + sizeof( type );
	}
	template < class type > inline short readDataAt( const short offset, type &newData ) const {
		WPAssert( offset + sizeof( type ) <= length );
		memcpy( &newData, data + offset, sizeof( type ) );
		return offset + sizeof( type );
	}

	inline short writeDataAt( const short offset, const std::string &newData ) {
		short dlen = newData.length( ) + 1; // trailing zero is included
		WPAssert( offset + dlen <= length );
		memcpy( data + offset, newData.c_str( ), dlen );
		return offset + dlen;
	}

	inline short readDataAt( const short offset, std::string &newData ) {
		newData = (char *) data + offset;
		short dlen = newData.length( ) + 1;
		WPAssert( offset + dlen <= length );
		return offset + dlen;
	}
  
	inline short writeDataAt( const short offset, const void * newData, const short datalength ) {
		WPAssert( offset + datalength <= length );
		memcpy( data + offset, newData, datalength );
		return offset + datalength;
	}

	inline short readDataAt( const short offset, void * newData, const short datalength ) const {
		WPAssert( offset + datalength <= length );
		memcpy( newData, data + offset, datalength );
		return offset + datalength;
	}
};