Linuxc/C ++ programming BASICS (36) poco: binaryreader implementation

I. binaryreader. H is defined as follows:

# Ifndef linyanwenbinaryreader_h _
# Define linyanwenbinaryreader_h _

# Include "poco/textconverter. H"
# Include "poco/Foundation. H"
# Include <vector>
# Include <istream>
Namespace linyanwen {
Class textencoding;
Class binaryreader
/// This class reads basic types (and STD: vectors thereof)
/// In binary form into an input stream.
/// It provides an extractor-based interface similar to istream.
/// The reader also supports automatic conversion from big-Endian
/// (Network byte order) to little-Endian and vice-versa.
/// Use a binarywriter to create a stream suitable for a binaryreader.
{
Public:
Enum streambyteorder
{
Native_byte_order = 1, // the host's native byte-order
Big_endian_byte_order = 2, // big-Endian (network) byte-order
Network_byte_order = 2, // big-Endian (network) byte-order
Little_endian_byte_order = 3, // little-Endian byte-order
Unspecified_byte_order = 4 // unknown, byte-order will be determined by reading the byte-order mark
};
Binaryreader (POCO: uint8 * _ buffer, Poco: uint32 _ size );
~ Binaryreader ();
Binaryreader & operator> (bool & value );
Binaryreader & operator> (char & value );
Binaryreader & operator> (unsigned char & value );
Binaryreader & operator> (signed Char & value );
Binaryreader & operator> (short & value );
Binaryreader & operator> (unsigned short & value );
Binaryreader & operator> (Int & value );
Binaryreader & operator> (unsigned Int & value );
Binaryreader & operator> (Long & value );
Binaryreader & operator> (unsigned long & value );
Binaryreader & operator> (float & value );
Binaryreader & operator> (double & value );
Binaryreader & operator> (STD: string & value );
/*************************************** */
Void read7bitencoded (POCO: uint32 & value );
Void readraw (STD: streamsize length, STD: string & value );
// Reads length bytes of raw data into value.
Void readraw (char * Buf, STD: streamsize length );
// Reads length bytes of raw data into Buf.
/*************************************** */
Bool good ();
PRIVATE:
Bool _ flipbytes;
Poco: textconverter * _ ptextconverter;
Poco: uint8 * buffer;
Poco: uint32 size;
Poco: int32 beg, end, cur;
};
Inline bool binaryreader: Good (){
Return cur <size; // note that cur starts from 0 and size starts from 1, so it is '<' rather than '<='
}
} // Namespace linyanwen

# Endif/* linyanwenbinaryreader_h _*/

 

Ii. binaryreader. cpp implementation:

# Include "linyanwenbinaryreader. H"
# Include "poco/binaryreader. H"
# Include "poco/byteorder. H"
# Include "poco/textencoding. H"
# Include <algorithm>
Namespace linyanwen {

Binaryreader: binaryreader (POCO: uint8 * _ buffer, Poco: uint32 _ SIZE): buffer (_ buffer), size (_ SIZE)
, Beg (0), cur (0), end (_ size), _ ptextconverter (0)
{
# If defined (poco_arch_big_endian)
_ Flipbytes = (binaryreader: network_byte_order = little_endian_byte_order );
# Else
_ Flipbytes = (binaryreader: network_byte_order = big_endian_byte_order );
# Endif
}
Binaryreader ::~ Binaryreader ()
{
Delete _ ptextconverter;
}

Binaryreader & binaryreader: Operator >>( bool & value)
{
// _ Istr. Read (char *) & Value, sizeof (value ));
* (Char *) & Value) = * (buffer + cur );
++ Cur;
Return * this;
}
Binaryreader & binaryreader: Operator >>( char & value)
{
// _ Istr. Read (char *) & Value, sizeof (value ));
* (Char *) & Value) = * (buffer + cur );
++ Cur;
Return * this;
}
Binaryreader & binaryreader: Operator> (unsigned char & value)
{
// _ Istr. Read (char *) & Value, sizeof (value ));
* (Char *) & Value) = * (buffer + cur );
++ Cur;
Return * this;
}
Binaryreader & binaryreader: Operator> (signed Char & value)
{
// _ Istr. Read (char *) & Value, sizeof (value ));
* (Char *) & Value) = * (buffer + cur );
++ Cur;
Return * this;
}
Binaryreader & binaryreader: Operator >>( short & value)
{
// _ Istr. Read (char *) & Value, sizeof (value ));
For (INT I = 0; I <sizeof (value); ++ I)
* (Char *) & Value + I) = * (buffer + cur + I );
Cur = cur + sizeof (value );
If (_ flipbytes) value = poco: byteorder: flipbytes (value );
Return * this;
}
Binaryreader & binaryreader: Operator >>( unsigned short & value)
{
// _ Istr. Read (char *) & Value, sizeof (value ));
For (INT I = 0; I <sizeof (value); ++ I)
* (Char *) & Value + I) = * (buffer + cur + I );
Cur = cur + sizeof (value );
If (_ flipbytes) value = poco: byteorder: flipbytes (value );
Return * this;
}
Binaryreader & binaryreader: Operator >>( Int & value)
{
// _ Istr. Read (char *) & Value, sizeof (value ));
For (INT I = 0; I <sizeof (value); ++ I)
* (Char *) & Value + I) = * (buffer + cur + I );
Cur = cur + sizeof (value );
If (_ flipbytes) value = poco: byteorder: flipbytes (value );
Return * this;
}
Binaryreader & binaryreader: Operator> (unsigned Int & value)
{
// _ Istr. Read (char *) & Value, sizeof (value ));
For (INT I = 0; I <sizeof (value); ++ I)
* (Char *) & Value + I) = * (buffer + cur + I );
Cur = cur + sizeof (value );
If (_ flipbytes) value = poco: byteorder: flipbytes (value );
Return * this;
}
Binaryreader & binaryreader: Operator >>( long & value)
{
// _ Istr. Read (char *) & Value, sizeof (value ));
For (INT I = 0; I <sizeof (value); ++ I)
* (Char *) & Value + I) = * (buffer + cur + I );
Cur = cur + sizeof (value );
# If defined (poco_long_is_64_bit)
If (_ flipbytes) value = poco: byteorder: flipbytes (POCO: int64) value );
# Else
If (_ flipbytes) value = poco: byteorder: flipbytes (POCO: int32) value );
# Endif
Return * this;
}
Binaryreader & binaryreader: Operator >>( unsigned long & value)
{
// _ Istr. Read (char *) & Value, sizeof (value ));
For (INT I = 0; I <sizeof (value); ++ I)
* (Char *) & Value + I) = * (buffer + cur + I );
Cur = cur + sizeof (value );
# If defined (poco_long_is_64_bit)
If (_ flipbytes) value = poco: byteorder: flipbytes (POCO: uint64) value );
# Else
If (_ flipbytes) value = poco: byteorder: flipbytes (POCO: uint32) value );
# Endif
Return * this;
}
Binaryreader & binaryreader: Operator >>( float & value)
{
If (_ flipbytes)
{
Char * PTR = (char *) & value;
PTR + = sizeof (value );
For (unsigned I = 0; I <sizeof (value); ++ I)
// _ Istr. Read (-- PTR, 1 );
* (-- PTR) = * (buffer + cur + I );
Cur = cur + sizeof (value );
}
Else
{
// _ Istr. Read (char *) & Value, sizeof (value ));
For (INT I = 0; I <sizeof (value); ++ I)
* (Char *) & Value + I) = * (buffer + cur + I );
Cur = cur + sizeof (value );
}
Return * this;
}
Binaryreader & binaryreader: Operator >>( double & value)
{
If (_ flipbytes)
{
Char * PTR = (char *) & value;
PTR + = sizeof (value );
For (unsigned I = 0; I <sizeof (value); ++ I)
// _ Istr. Read (-- PTR, 1 );
* (-- PTR) = * (buffer + cur + I );
Cur = cur + sizeof (value );
}
Else
{
// _ Istr. Read (char *) & Value, sizeof (value ));
For (INT I = 0; I <sizeof (value); ++ I)
* (Char *) & Value + I) = * (buffer + cur + I );
Cur = cur + sizeof (value );
}
Return * this;
}

Binaryreader & binaryreader: Operator> (STD: string & value)
{
Poco: uint32 size = 0;
Read7bitencoded (size );
Value. Clear ();
If (! Good () return * this;
Value. Reserve (size );
While (size --)
{
Char C;
// If (! _ Istr. Read (& C, 1). Good () break;
If (! Good () break;
* (Char *) & C) = * (buffer + cur );
++ Cur;
Value + = C;
}
If (_ ptextconverter)
{
STD: String converted;
_ Ptextconverter-> convert (value, converted );
STD: swap (value, converted );
}
Return * this;
}
Void binaryreader: read7bitencoded (POCO: uint32 & value)
{
Char C;
Value = 0;
Int S = 0;
Do
{
C = 0;
// _ Istr. Read (& C, 1 );
* (Char *) & C) = * (buffer + cur );
++ Cur;
Poco: uint32 x = (C & 0x7f );
X <= s;
Value + = X;
S + = 7;
}
While (C & 0x80 );
}

Void binaryreader: readraw (STD: streamsize length, STD: string & value)
{
Value. Clear ();
Value. Reserve (static_cast <STD: String: size_type> (length ));
While (length --)
{
Char C;
// If (! _ Istr. Read (& C, 1). Good () break;
If (! Good () break;
* (Char *) & C) = * (buffer + cur );
++ Cur;
Value + = C;
}
}
Void binaryreader: readraw (char * Buf, STD: streamsize length)
{
// _ Istr. Read (buffer, length );
For (INT I = 0; I <length; ++ I)
* (BUF + I) = * (buffer + cur + I );
Cur = cur + length;
}
} // Namespace linyanwen

 

Reprinted please indicate the source: zhujian blog, http://blog.csdn.net/linyanwen99/article/details/8599680