Buffer.h

Go to the documentation of this file.

#ifndef ARXX_BUFFER_H
#define ARXX_BUFFER_H

#include <set>
#include <stdexcept>
#include <string>
#include <vector>

#include "Common.h"

namespace Arxx
{
    class Buffer
    {
        friend std::string sIndentation(Arxx::Buffer * pBuffer);
    public:
        typedef unsigned char value_type;
        
        typedef value_type & reference;
        
        typedef value_type * pointer;
        
        typedef const value_type const_value_type;
        
        typedef const_value_type * const_pointer;
        
        typedef Arxx::u4byte size_type;
        
        class Marker
        {
        public:
            typedef enum
            {
                LEFT,
                RIGHT
            } Alignment;
            
            typedef enum
            {
                BEGIN = 0,
                END = 0xFFFFFFFF
            } Position;
            
            Marker(const Arxx::Buffer & Buffer, Arxx::Buffer::size_type stPosition = 0, Arxx::Buffer::Marker::Alignment Alignment = LEFT);
            
            ~Marker(void);
            
            Arxx::Buffer::size_type stGetPosition(void) const;
            
            void vSetPosition(Arxx::Buffer::size_type stPosition);
            
            Arxx::Buffer::Marker::Alignment GetAlignment(void) const;
            
            void vSetAlignment(Arxx::Buffer::Marker::Alignment Alignment);
            
            bool bIsValid(void) const;
        private:
            const Arxx::Buffer * m_pBuffer;
            
            Arxx::Buffer::size_type m_stPosition;
            
            Alignment m_Alignment;
            
            void vInvalidateBuffer(void);
        };
        
        friend class Arxx::Buffer::Marker;
        
        Buffer(void);
        
        Buffer(Buffer & Buffer, size_type stPosition, size_type stLength);
        
        virtual ~Buffer(void);
        
        size_type stGetLength(void) const;
        
        void vSetLength(size_type stLength = 0);
        
        void vInsert(size_type stPosition, size_type stDataLength, const_pointer Data = 0);
        
        void vDelete(size_type stPosition, size_type stLength);
        
        value_type operator[](size_type stIndex) const;
        
        reference operator[](size_type stIndex);
        
        const_pointer GetBegin(void) const;
    protected:
        static const size_type m_stDataUpdated;
        
        static const size_type m_stDataDeleted;
        
        static const size_type m_stDataInserted;
    private:
        Buffer(const Buffer & Buffer);
        
        Buffer & operator=(const Buffer & Buffer);
        
        Buffer * m_pSupBuffer;
        
        pointer m_Begin;
        
        size_type m_stLength;
        
        size_type m_stCapacity;
        
        mutable std::set< Arxx::Buffer::Marker * > m_Markers;
        
        size_type m_stPosition;
        
        class SubBuffer;
        std::vector< SubBuffer * > m_SubBuffers;
        
        bool m_bChanging;
        
        void vRegister(Buffer & Buffer);
        
        void vUnregister(Buffer & Buffer);
        
        void vRegister(Arxx::Buffer::Marker & Marker) const;
        
        void vUnregister(Arxx::Buffer::Marker & Marker) const;
        
        void vWrite(Arxx::Buffer & Buffer, Arxx::Buffer::size_type stPosition, Arxx::Buffer::size_type stDataLength, Arxx::Buffer::const_pointer Data = 0);
        
        void vParentDataChanged(size_type stChangeMode, size_type stPosition, size_type stLength);
    };
    
    std::ostream & operator<<(std::ostream & OStream, const Arxx::Buffer & Buffer);
};

#endif

---