include/Streams/Streams.hpp

Go to the documentation of this file.

#ifndef hpp_CPP_Streams_CPP_hpp
#define hpp_CPP_Streams_CPP_hpp

// We need types 
#include "../Types/Types.hpp"
// We need strings
#include "../Strings/Strings.hpp"

namespace Stream
{
    class BaseStream
    {
        // Constructors
    protected:
        BaseStream() {}
        virtual ~BaseStream() {}

        // Interface 
    public:
        virtual uint32 fullSize() const = 0;
        virtual bool endReached() const = 0;
        virtual uint32 currentPosition() const = 0;
        virtual bool setPosition(const uint32 & newPos) = 0;
        virtual bool goForward(const uint32 & skipAmount) = 0;
    };

    class InputStream : public BaseStream
    {
    protected:
        InputStream() {}

        // The interface 
    public:
        virtual uint32 read(void * const buffer, const uint32 & size) const throw() = 0;
    };

    class OutputStream : public BaseStream
    {
    protected:
        OutputStream() {}

        // The interface 
    public:
        virtual uint32 write(const void * const buffer, const uint32 & size) const throw() = 0;
    };

    template <class String>
    class LineSplitStream : public InputStream
    {
    protected:
        LineSplitStream() {}

        // The interface 
    public:
        virtual String readNextLine() const throw()
        {
            String s;
            tchar buffer[256];
            tchar ch;
            uint32 positionInBuffer = 0;

            while (!endReached())
            {
                if (!read(&ch, sizeof(ch)) != sizeof(ch)) break;
                if (ch == '\n') break;

                buffer[positionInBuffer++] = ch;

                if (positionInBuffer == 256)
                {
                    s += buffer; positionInBuffer = 0;
                }
            }

            if (positionInBuffer)
                s += buffer;

            return s;
        }
    };

    class InputFileStream : public LineSplitStream<Strings::FastString>
    {
    protected:
        typedef Strings::FastString String;

        // Members
    private:
        String     fileName;
        void    *  pFile;
        uint32     fileSize;

        // The interface
    public:
        virtual uint32 fullSize() const;
        virtual bool endReached() const;
        virtual uint32 currentPosition() const;
        virtual bool setPosition(const uint32 & newPos);
        virtual bool goForward(const uint32 & skipAmount);
        virtual uint32 read(void * const buffer, const uint32 & size) const throw();

        // Construction
    public:
        InputFileStream(const String & name);
        ~InputFileStream();

    private:
        InputFileStream(const InputFileStream &);
    };

    class MemoryBufferedStream : public InputStream
    {

        // Members
    private:
        const InputStream & inputStream;
        uint8       *       buffer;

        // The interface
    public:
        virtual uint32 fullSize() const  { return inputStream.fullSize();}
        virtual bool endReached() const  { return true; }
        virtual uint32 currentPosition() const { return inputStream.fullSize(); }
        virtual bool setPosition(const uint32 & newPos) { return false; }
        virtual bool goForward(const uint32 & skipAmount) { return false; }
        virtual uint32 read(void * const buffer, const uint32 & size) const throw() { return 0; }

        inline uint8 * getBuffer() { return buffer; }

        // Construction
    public:
        MemoryBufferedStream(const InputStream & is) : buffer(0), inputStream(is) 
        { 
            if (is.fullSize() < 0xfffffffe) 
            {
                buffer = new uint8[is.fullSize()];
                if (!buffer) return;
                if (is.read(buffer, is.fullSize()) != is.fullSize())
                {
                    delete buffer;
                    buffer = 0;
                }
            }
        }
        ~MemoryBufferedStream()     { if (buffer) delete[] buffer; buffer = 0; }

    private:
        MemoryBufferedStream(const MemoryBufferedStream &);
    };

    class MemoryBlockStream : public InputStream
    {

        // Members
    private:
        const uint8 *       buffer;
        uint32              length;
        uint32              position;

        // The interface
    public:
        virtual uint32 fullSize() const  { return length;}
        virtual bool endReached() const  { return position >= length; }
        virtual uint32 currentPosition() const { return position; }
        virtual bool setPosition(const uint32 & newPos) { if (newPos < length) { position = newPos; return true; } return false; }
        virtual bool goForward(const uint32 & skipAmount) { if (skipAmount + position > length) return false; position += skipAmount; return true; }
        virtual uint32 read(void * const _buffer, const uint32 & size) const throw() 
        { 
            uint32 amount = (uint32)(   ((int)length - (int)position) < (int)size ? ((int)length - (int)position) : (int)size   );
            memcpy(_buffer, &buffer[position], amount);
            return amount;
        }

        inline const uint8 * getBuffer() { return buffer; }

        // Construction
    public:
        MemoryBlockStream(const uint8 * data, const uint32 len) : buffer(data), length(len), position(0) 
        { 
        }
        ~MemoryBlockStream()     { buffer = 0; length = 0; position = 0;}

    private:
        MemoryBlockStream(const MemoryBlockStream &);
    };
}





#endif

(C) An X-Ryl669 project 2007

This document describes Unlimited Zooming Interface source code. UZI stands for Unlimited Zooming Interface, and source code license is