OutStream.h

Go to the documentation of this file.

#ifndef OUTSTREAM_H_
#define OUTSTREAM_H_

#include "utils/Str.h"
#include <cstdio>
class OutStream
{
public:

    virtual ~OutStream()
    {}
    ;

    virtual OutStream& write( const char* buffer, size_t num ) = 0;

    virtual OutStream& writeHex( const char* buffer, size_t num );

    virtual bool isWritable() = 0;

    virtual OutStream& write( const char* buffer )
    {
        return write( buffer, strlen( buffer ) );
    }

    virtual OutStream& writeHex( const char* buffer )
    {
        return writeHex( buffer, strlen( buffer ) );
    }

    OutStream& operator << ( const Str buffer )
    {
        return write( buffer.cStr(), buffer.length() );
    };

    OutStream& operator << ( const char buffer[] )
    {
        return write( buffer );
    }

    OutStream& operator << ( const char byte )
    {
        return writeChar( byte );
    }

    OutStream& operator << ( const signed char byte )
    {
        return writeChar( byte );
    }

    OutStream& operator << ( const unsigned char byte )
    {
        return writeChar( byte );
    }

    OutStream& operator << ( const int number )
    {
        return writeInteger( number );
    }

    OutStream& writeChar( const signed char value )
    {
        return write( ( char* )&value, sizeof( value ) );
    }

    OutStream& writeCharHex( const signed char byte );

    OutStream& writeUCharHex( const unsigned char byte );

    OutStream& writeInteger( const int number, const unsigned int radix = 10 );
    OutStream& writeNumber( const double number, const unsigned int radix = 10 );

    OutStream& writeShort( const short value )
    {
        return write( ( const char* )&value, sizeof( value ) );
    }

    OutStream& writeShortHex( const short word );

    OutStream& writeUShortHex( const unsigned short word );

    OutStream& writeUShortCompact( const unsigned short& value );

    OutStream& writeInt24( const int medInt )
    {
        return write( ( const char* )&medInt, 3 );
    }

    OutStream& writeInt( const int value )
    {
        return write( ( const char* )&value, sizeof( value ) );
    }

    OutStream& writeLongLong( const long long value )
    {
        return write( ( const char* )&value, sizeof( value ) );
    }

    OutStream& writeLongLongCompact( const long long& value );

    OutStream& writeFloat( const float value )
    {
        return write( ( const char* )&value, sizeof( value ) );
    }

    OutStream& writeFloat2( const float value )
    {
        return write( ( ( const char* )&value ) + 2, 2 );
    }

    OutStream& writeFloat3( const float value )
    {
        return write( ( ( const char* )&value ) + 1, 3 );
    }

    OutStream& writeDouble( const double value )
    {
        return write( ( const char* )&value, sizeof( value ) );
    }

    OutStream& writeDouble6( const double value )
    {
        return write( ( ( const char* )&value ) + 2, 6 );
    }

    size_t bytesWritten()
    {
        return lastWritten_;
    }

protected:

    OutStream()
        : lastWritten_( 0 )
    {}
    ;

    size_t lastWritten_;

    static const unsigned char HEX_CHARS[];

private:
    // Note that the copy constructor below is private and not given a body.
    // Any attempt to call it will return a compiler error.
    OutStream( const OutStream& old ); // disallow copy constructor

};

class NullOutStream: public OutStream
{
public:

    virtual OutStream& write( const char* buffer, unsigned int num )
    {
        return *this;
    }

    virtual bool isWritable()
    {
        return false;
    }

};


#endif /*OUTSTREAM_H_*/