InStream.h

Go to the documentation of this file.

#ifndef INSTREAM_H_
#define INSTREAM_H_

#include "utils/Str.h"

class InStream
{
public:

    virtual ~InStream()
    {}
    ;

    virtual InStream& read( char* buffer, size_t num ) = 0;


    virtual const char* getName() = 0;

    virtual bool isReadable() = 0;

    InStream& readChar( signed char& value )
    {
        return read( ( char* )&value, sizeof( value ) );
    }

    InStream& readCharHex( signed char& byte );

    InStream& readUCharHex( unsigned char& byte );

    // Fills buffer until: buffer size is exceeded, or (CR/LF) character is received
    // Leading LF characters are skipped.
    virtual InStream& readLine( char* buf, unsigned int bufsize );

    InStream& readShort( short& value )
    {
        return read( ( char* )&value, sizeof( value ) );
    }

    InStream& readShort( unsigned short& value )
    {
        return read( ( char* )&value, sizeof( value ) );
    }

    InStream& readShortHex( short& word );

    InStream& readUShortHex( unsigned short& value );

    InStream& readUShortCompact( unsigned short& value );

    InStream& readInt24( int& medInt )
    {
        InStream& result = read( ( char* ) & medInt, 3 );
        if( ( medInt & 0x00800000 ) == 0 )
        {
            medInt &=  0x00FFFFFF;
        }
        else
        {
            medInt |=  0xFF000000;
        }
        return result;
    }

    InStream& readInt( int& value )
    {
        return read( ( char* )&value, sizeof( value ) );
    }

    InStream& readLongLong( long long& value )
    {
        return read( ( char* )&value, sizeof( value ) );
    }

    InStream& readLongLongCompact( long long& value );

    InStream& readFloat( float& value )
    {
        return read( ( char* )&value, sizeof( value ) );
    }

    InStream& readFloat2( float& value )
    {
        value = 0;
        return read( ( ( char* )&value ) + 2, 2 );
    }

    InStream& readFloat3( float& value )
    {
        value = 0;
        return read( ( ( char* )&value ) + 1, 3 );
    }

    InStream& readDouble( double& value )
    {
        return read( ( char* )&value, sizeof( value ) );
    }

    virtual InStream& readUntil( char* buf, unsigned int num, unsigned char match );

    virtual bool eof() = 0;

    size_t bytesRead()
    {
        return lastRead_;
    }

    size_t getBytesRead()
    {
        return lastRead_;
    }

    size_t getTotalBytesRead()
    {
        return totalBytesRead_;
    }

protected:

    InStream()
        : lastRead_( 0 ),
          totalBytesRead_( 0 )
    {}
    ;

    inline void zeroBytesRead()
    {
        lastRead_ = 0;
    }

    inline void incBytesRead()
    {
        ++lastRead_;
        ++totalBytesRead_;
    }

    inline void incBytesRead( size_t incRead )
    {
        lastRead_ += incRead;
        totalBytesRead_ += incRead;
    }

    inline void setBytesRead( size_t lastRead )
    {
        lastRead_ = lastRead;
        totalBytesRead_ += lastRead;
    }

    inline void zeroTotalBytesRead()
    {
        zeroBytesRead();
        totalBytesRead_ = 0;
    }

private:

    size_t lastRead_;

    size_t totalBytesRead_;

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

};

class NullInStream: public InStream
{
public:

    virtual InStream& read( char* buffer, unsigned int num )
    {
        return *this;
    }

    virtual bool isReadable()
    {
        return false;
    }

    virtual bool eof()
    {
        return true;
    }

};

#endif /*INSTREAM_H_*/