cel_stream.h

Go to the documentation of this file.

//----------------------------------------------------------------------------
//
// (C) 2003-2006 Celartem Technology Inc. All rights reserved.
//----------------------------------------------------------------------------

#ifndef _cel_stream_h_
#define _cel_stream_h_

#include "cel_types.h"
#include "cel_referable.h"
#include "cel_string.h"
#include "cel_datatraits.h"
#include "cel_exception.h"
#include "cel_lockable.h"

namespace Celartem
{
    typedef void (*DuplicateStreamCallback)(
        void* inContext,
        size_t inBytesCopied,
        size_t inMaximumBytesToCopy);

    //========================================================================
    class Stream : public Referable, public Lockable
    {
    public:
        virtual size_t readBytes(
            void *buffer, size_t inSize, bool wouldBlock = false) = 0;

        virtual void writeBytes(const void *buffer, size_t inSize) = 0;

        virtual void flushBuffer() = 0;

        virtual bool isEof() const = 0;

        virtual size_t duplicateStream(
            Stream *inStream,
            size_t inBufferSize = 1024,
            DuplicateStreamCallback inCallback = NULL,
            void* inCallbackContext = NULL);

        virtual size_t duplicateStreamBytes(
            Stream *inStream,
            size_t inMaximumByteSize,
            size_t inBufferSize = 1024,
            DuplicateStreamCallback inCallback = NULL,
            void* inCallbackContext = NULL);
    };

    //========================================================================
    template<typename T, StoragePolicy storagePolicy>
    struct WriteData
    {
        static void writeData(
            Stream *inStream, const T& n, Endian inEndian = endianHost);
    };

    template<typename T>
    struct WriteData<T, notToBeStored>
    {
        static void writeData(
            Stream *inStream, const T& n, Endian inEndian = endianHost)
        {
            celThrow2(
                errNotPermitted,
                "The object should not be stored in the storage or it might lack DataTraits implementation for the type.");
        }
    };

    template<typename T>
    struct WriteData<T, byCopyBytes>
    {
        static void writeData(
            Stream *inStream, const T& n, Endian inEndian = endianHost)
        {
            inStream->writeBytes(&n, sizeof(T));
        }
    };

    template<typename T>
    struct WriteData<T, bySwapCopyBytes>
    {
        static void writeData(
            Stream *inStream, const T& n, Endian inEndian = endianHost)
        {
            u8 buffer[sizeof(T)];
            write<T>(buffer, n, inEndian);
            inStream->writeBytes(buffer, sizeof(T));
        }
    };

    template<typename T>
    struct WriteData<T, byClassMethods>
    {
        static void writeData(
            Stream *inStream, const T& n, Endian inEndian = endianHost)
        {
            n.serialize(inStream, 0, inEndian);
        }
    };

    //------------------------------------------------------------------------
    template<typename T, StoragePolicy storagePolicy>
    struct ReadData
    {
        static T readData(Stream *inStream, Endian inEndian = endianHost);
    };

    template<typename T>
    struct ReadData<T, notToBeStored>
    {
        static T readData(
            Stream *inStream, Endian inEndian = endianHost)
        {
            celThrow2(
                errNotPermitted,
                "The object should not be load from the storage.");
            return T();
        }
    };

    template<typename T>
    struct ReadData<T, byCopyBytes>
    {
        static T readData(
            Stream *inStream, Endian inEndian = endianHost)
        {
            T tmp;
            inStream->readBytes(&tmp, sizeof(T), true);
            return tmp;
        }
    };

    template<typename T>
    struct ReadData<T, bySwapCopyBytes>
    {
        static T readData(
            Stream *inStream, Endian inEndian = endianHost)
        {
            u8 buffer[sizeof(T)];
            inStream->readBytes(buffer, sizeof(T), true);
            return read<T>(buffer, inEndian);
        }
    };

    template<typename T>
    struct ReadData<T, byClassMethods>
    {
        static T readData(
            Stream *inStream, Endian inEndian = endianHost)
        {
            T t;
            t.deserialize(inStream, 0, inEndian);
            return t;
        }
    };

    //========================================================================
    template<typename T>
    void write(
        Stream *inStream, const T& n, Endian inEndian /*= endianHost*/)
    {
        WriteData<T, DataTraits<T>::storagePolicy>::writeData(
            inStream, n, inEndian);
    }

    template<typename T>
    T read(
        Stream *inStream, Endian inEndian /*= endianHost*/)
    {
        return ReadData<T, DataTraits<T>::storagePolicy>::readData(
            inStream, inEndian);
    }

    //========================================================================
    class NullStream : public Stream
    {
    public:
        static AutoPtr<NullStream> create()
        {
            return new NullStream();
        }
        
        virtual size_t readBytes(
            void *buffer, size_t inSize, bool wouldBlock = false)
        {
            celThrow2(errNotImplemented,
                "NullStream::readBytes should not be called.");
        }
        
        virtual void writeBytes(const void *buffer, size_t inSize)
        {
            // do nothing
        }
        
        virtual void flushBuffer()
        {
            // do nothing
        }
        
        virtual bool isEof() const
        {
            // always EOF.
            return true;
        }
        
        virtual void lock() const {}
        virtual void unlock() const {}
    
    private:
        NullStream() {}
    };
    
    //========================================================================
    class ByteCounterStream : public Stream
    {
    public:
        static AutoPtr<ByteCounterStream> create(Stream* inStream)
        {
            return new ByteCounterStream(inStream);
        }
        
        size_t getNumOfBytesRead() const {return m_bytesRead;}
        
        size_t getNumOfBytesWritten() const {return m_bytesWritten;}

        void resetByteRead() {m_bytesRead = 0;}

        void resetByteWritten() {m_bytesWritten = 0;}

        virtual size_t readBytes(
            void *buffer, size_t inSize, bool wouldBlock = false)
        {
            size_t sizeRead = m_stream->readBytes(buffer, inSize, wouldBlock);
            m_bytesRead += sizeRead;
            return sizeRead;
        }
        virtual void writeBytes(const void *buffer, size_t inSize)
        {
            m_stream->writeBytes(buffer, inSize);
            m_bytesWritten += inSize;
        }
        
        virtual void flushBuffer() {m_stream->flushBuffer();}
        
        virtual bool isEof() const {return m_stream->isEof();}

        virtual void lock() const {m_stream->lock();}
        
        virtual void unlock() const {m_stream->unlock();}

    private:
        // This reduces the risk of inproper use of this class.
        ByteCounterStream(Stream* inStream)
            : m_stream(inStream), m_bytesRead(0), m_bytesWritten(0)
        {}
        ByteCounterStream();
        ByteCounterStream(ByteCounterStream& inRef);
        ByteCounterStream& operator=(ByteCounterStream& inRef);

        AutoPtr<Stream> m_stream;
        size_t m_bytesRead;
        size_t m_bytesWritten;
    };

    //========================================================================
    class PartialStream : public Stream
    {
    public:
        static AutoPtr<PartialStream> create(Stream* inStream, uint64_t inSize)
        {
            return new PartialStream(inStream, inSize);
        }

        virtual size_t readBytes(
            void *buffer, size_t inSize, bool wouldBlock = false)
        {
            uint64_t bytes = m_bytesProcessed + inSize;
            if(bytes > m_size)
            {
                if(wouldBlock)
                    celThrow2(errReadFailed, "Cannot read so many bytes!");
                inSize = (size_t)(m_size - m_bytesProcessed);
            }
            size_t sizeRead = m_stream->readBytes(buffer, inSize, wouldBlock);
            m_bytesProcessed += sizeRead;
            return sizeRead;
        }
        
        virtual void writeBytes(const void *buffer, size_t inSize)
        {
            if(m_bytesProcessed + inSize > m_size)
                celThrow2(errReadFailed, "Cannot write so many bytes!");
            m_stream->writeBytes(buffer, inSize);
            m_bytesProcessed += inSize;
        }
        
        virtual void flushBuffer()
        {
            m_stream->flushBuffer();
        }
        
        virtual bool isEof() const
        {
            if(m_bytesProcessed >= m_size)
                return true;
            return m_stream->isEof();
        }

        virtual void lock() const {m_stream->lock();}
        
        virtual void unlock() const {m_stream->unlock();}

    private:
        // This reduces the risk of inproper use of this class.
        PartialStream(Stream* inStream, uint64_t inSize)
            : m_stream(inStream), m_size(inSize), m_bytesProcessed(0)
        {}
        PartialStream();
        PartialStream(PartialStream& inRef);
        PartialStream& operator=(PartialStream& inRef);

        AutoPtr<Stream> m_stream;
        uint64_t m_size;
        uint64_t m_bytesProcessed;
    };

} // namespace Celartem

#endif // _cel_stream_h_

---

This document is automatically generated using doxygen 1.5.4 at Fri Jun 27 18:21:55 2008.