vmemorystream.h

Go to the documentation of this file.

/*
Copyright c1997-2014 Trygve Isaacson. All rights reserved.
This file is part of the Code Vault version 4.1
http://www.bombaydigital.com/
License: MIT. See LICENSE.md in the Vault top level directory.
*/

#ifndef vmemorystream_h
#define vmemorystream_h

#include "vstream.h"

class VMemoryStream : public VStream {
    public:

        static const Vs64 kIncrement2x = 0;             
        static const Vs64 kDefaultBufferSize = 32768;   
        typedef enum { kAllocatedByOperatorNew, kAllocatedByMalloc, kAllocatedOnStack, kAllocatedUnknown } BufferAllocationType;

        VMemoryStream(Vs64 initialBufferSize = kDefaultBufferSize, Vs64 resizeIncrement = kIncrement2x);
        /*
        Copy construction and assignment semantics: If the other stream owns its buffer, then
        the copy gets a brand new copied buffer; if the other stream doesn't own its buffer,
        then the copy also refers to the same buffer which it also does not own. When making
        a copy of a buffer, we try to use the same allocation type, but if the original buffer
        is on the stack, the copy is made on the heap.
        @param other the other VMemoryStream that we are initialized from
        */
        VMemoryStream(const VMemoryStream& other);
        VMemoryStream(Vu8* buffer, BufferAllocationType allocationType, bool adoptsBuffer, Vs64 suppliedBufferSize, Vs64 suppliedEOFOffset, Vs64 resizeIncrement = kIncrement2x);
        virtual ~VMemoryStream();

        VMemoryStream& operator=(const VMemoryStream& other);

        // Required VStream method overrides:
        virtual Vs64 read(Vu8* targetBuffer, Vs64 numBytesToRead);
        virtual Vs64 write(const Vu8* buffer, Vs64 numBytesToWrite);
        virtual void flush();
        virtual bool skip(Vs64 numBytesToSkip);
        virtual bool seek(Vs64 offset, int whence);
        virtual Vs64 getIOOffset() const;
        virtual Vs64 available() const;

        // Methods we define for callers who know what kind of stream they have:
        void adoptBuffer(Vu8* buffer, BufferAllocationType allocationType, bool adoptsBuffer, Vs64 suppliedBufferSize, Vs64 suppliedEOFOffset);
        void orphanBuffer();
        Vu8* getBuffer() const;
        Vs64 getBufferSize() const;
        Vs64 getEOFOffset() const;
        void setEOF(Vs64 eofOffset);
        friend bool operator==(const VMemoryStream& m1, const VMemoryStream& m2);

    protected:

        /*
        These methods are ONLY overridden by buffer-based subclasses,
        for example VMemoryStream. They are called by the friend function
        streamCopy() so that it can efficiently copy data directly to/from
        streams that have data buffers (namely, VMemoryStream).
        */

        virtual Vu8* _getReadIOPtr() const;
        virtual Vu8* _getWriteIOPtr() const;
        virtual Vs64 _prepareToRead(Vs64 numBytesToRead) const;
        virtual void _prepareToWrite(Vs64 numBytesToWrite);
        virtual void _finishRead(Vs64 numBytesRead);
        virtual void _finishWrite(Vs64 numBytesWritten);

        void _assertInvariant() const;

        Vs64                    mBufferSize;        
        Vs64                    mIOOffset;          
        Vs64                    mEOFOffset;         
        Vs64                    mResizeIncrement;   
        bool                    mOwnsBuffer;        
        BufferAllocationType    mAllocationType;    
        Vu8*                    mBuffer;            

    private:

        Vu8* _createNewBuffer(Vs64 bufferSize, BufferAllocationType& newAllocationType);
        void _releaseBuffer();
};

class VReadOnlyMemoryStream : public VMemoryStream {
    public:

        VReadOnlyMemoryStream(Vu8* buffer, Vs64 suppliedEOFOffset);
        VReadOnlyMemoryStream(const VReadOnlyMemoryStream& other);
        virtual ~VReadOnlyMemoryStream() {}

        VReadOnlyMemoryStream& operator=(const VReadOnlyMemoryStream& other);

        void adoptBuffer(Vu8* buffer, BufferAllocationType allocationType, Vs64 suppliedBufferSize, Vs64 suppliedEOFOffset);

        virtual Vs64 write(const Vu8* buffer, Vs64 numBytesToWrite);
        virtual void flush();
};

#endif /* vmemorystream_h */