CommBuffer.h

//
// Copyright (c) 2006-2014 Raphael David / CANTOR
//


#ifndef CMR_COMM_BUFFER_INCLUDED
#define CMR_COMM_BUFFER_INCLUDED

#include "Commore.h"
#include "List.h"

namespace commore
{
    class CMREXD CommBuffer
    {

        typedef CommBuffer* PCommBuffer;

    public:
        class Page;
        typedef Page* PPage;

    private :
        class DictionaryManager
        {
            friend class CommBuffer;

        private :
            ListAString attributes;
        public :
            DictionaryManager();
        private:
            DictionaryManager(const DictionaryManager&);//forbidden=>not implemented

        public :
            int get_element_pos(const AString& elmt) const;
            AString get_element_at(int pos) const;
            bool add_element(const AString& elmt);
            size_t size() const
            {
                return attributes.size();
            }

        private:
            void clear();
            void splice(DictionaryManager& src);

        };

        mutable DictionaryManager dictionary_manager_;

    public:
        CommBuffer();
        CommBuffer(size_t page_size);
        CommBuffer(const CommBuffer& C);
        CommBuffer& operator=(const CommBuffer& C);
        ~CommBuffer();

    public:

        class Page
        {
        public:
            enum
            {
                HEADER_SIZE = 21,
                NB_FLAGS = 4,
                VERSION = 1
            };

            enum Flags
            {
                NO_FLAG      = 'x',
                COMPRESSED   = 'c',
                CRYPTED      = 'i',
                ASCII        = 'a'
            };

        public :
            //HEADER
            bool is_last_page_;
            int version_;
            Byte flags_[NB_FLAGS];

            PCommBuffer cont_;
            size_t size_;
            size_t page_size_;
            PPage next_;
            enum { DECLARED_DATA_SIZE = 4 };
            Byte s_[DECLARED_DATA_SIZE];
            Page() : next_(0) {}

        public :
            static bool decodeHeader(Byte* header , int* version, Byte flag[], size_t* size, int* chunkTag);

            void  update_header();
            bool  update_from_header();
            void  set_is_last_page(bool value)
            {
                is_last_page_ = value;
            };
            bool  is_last_page() const
            {
                return is_last_page_;
            }

            bool  push_flag(Byte flag);
            void  clear_flag(Byte flag);
            bool  has_flag(Byte flag);
            void  clear_flags();

            size_t get_size() const
            {
                return size_;
            }
            Byte* get() const
            {
                return (Byte*)s_;
            }
        };

        struct Pos
        {
            PPage current_page_;
            size_t current_pos_;
            bool on_first_page_;
            Pos() : current_page_(0), current_pos_(0), on_first_page_(true) {}
        };

        class CMREXD PageIterator
        {
        public:
            PageIterator(const CommBuffer& buf);
        public:
            Page* next();
            bool hasNext() const
            {
                return p_ != 0;
            }
        private:
            Page* p_;
        };
        friend class PageIterator;

    public:
        bool operator== (const CommBuffer& C) const;
        bool operator!= (const CommBuffer& C) const;
        void  set_size(size_t size)
        {
            total_size_ = size;
        }
        size_t  size() const
        {
            return total_size_;
        }
        void  clear();
        bool  is_ascii() const
        {
            return is_ascii_;
        }
        void  set_is_ascii(bool is_ascii)
        {
            is_ascii_ = is_ascii;
        }
        void  update_ascii_flags();


        void update_headers();


        Byte* allocate(size_t& size);

        Byte* allocate_in_new_page(size_t size, bool reserveHeader);

        size_t  add_size(size_t size);

        void  splice(CommBuffer& x);
        void  dump() const;
        void  rewind();

        long  write_byte(const Byte* b, size_t size);
        long  write_raw(const Byte* b, size_t size);
        long  read_byte(Byte* b, size_t size) const;

        long  write_using_dictionary(const AString& v);
        long  write(const AString& v);
        long  write(const String& v);
        long  write(const StringBuffer& v);
        long  write(const Blob& v);
        long  write(const TimePeriod& v);
        long  write(const TimeDate& v);
        long  write(const Symbol& v);
        long  write(const Tuple& v);
        long  write(const Bool& v);
        long  write(const Int& v);
        long  write(const UInt& v);
        long  write(const long& v);
        long  write(const unsigned long& v);
        long  write(const Long& v);
        long  write(const ULong& v);
        long  write(const Short& v);
        long  write(const UShort& v);
        long  write(const Float& v);
        long  write(const Double& v);
        long  write(const ArrayInt& v);
        long  write(const ArrayLong& v);
        long  write(const ArrayFloat& v);
        long  write(const ArrayDouble& v);
        long  write(const ListBool& v);
        long  write(const ListInt& v);
        long  write(const ListUInt& v);
        long  write(const ListLong& v);
        long  write(const ListULong& v);
        long  write(const ListShort& v);
        long  write(const ListUShort& v);
        long  write(const ListFloat& v);
        long  write(const ListDouble& v);
        long  write(const ListAString& v);
        long  write(const ListString& v);
        long  write(const ListStringBuffer& v);
        long  write(const ListTimePeriod& v);
        long  write(const ListTimeDate& v);
        long  write(const ListBlob& v);
        long  write(const ListSymbol& v);
        long  write(const ListTuple& v);
        long  write(const ListArrayInt& v);
        long  write(const ListArrayLong& v);
        long  write(const ListArrayFloat& v);
        long  write(const ListArrayDouble& v);


        long  read_using_dictionary(AString& v) const;
        long  read(AString& v) const;
        long  read(String& v) const;
        long  read(StringBuffer& v) const;
        long  read(Blob& v) const;
        long  read(TimePeriod& v) const;
        long  read(TimeDate& v) const;
        long  read(Symbol& v) const;
        long  read(Tuple& v) const;
        long  read(Bool& v) const;
        long  read(Int& v) const;
        long  read(UInt& v) const;
        long  read(long& v) const;
        long  read(unsigned long& v) const;
        long  read(Long& v) const;
        long  read(ULong& v) const;
        long  read(Short& v) const;
        long  read(UShort& v) const;
        long  read(Float& v) const;
        long  read(Double& v) const;
        long  read(ArrayInt& v) const;
        long  read(ArrayLong& v) const;
        long  read(ArrayFloat& v) const;
        long  read(ArrayDouble& v) const;
        long  read(ListBool& v) const;
        long  read(ListInt& v) const;
        long  read(ListUInt& v) const;
        long  read(ListLong& v) const;
        long  read(ListULong& v) const;
        long  read(ListShort& v) const;
        long  read(ListUShort& v) const;
        long  read(ListFloat& v) const;
        long  read(ListDouble& v) const;
        long  read(ListAString& v) const;
        long  read(ListString& v) const;
        long  read(ListStringBuffer& v) const;
        long  read(ListTimePeriod& v) const;
        long  read(ListTimeDate& v) const;
        long  read(ListBlob& v) const;
        long  read(ListSymbol& v) const;
        long  read(ListTuple& v) const;
        long  read(ListArrayInt& v) const;
        long  read(ListArrayLong& v) const;
        long  read(ListArrayFloat& v) const;
        long  read(ListArrayDouble& v) const;
        Pos get_pos() const;
        void set_pos(const Pos& pos);
        long write(OBStream& o) const;
        long read(IBStream& o);
        long write_file(const Path& file_name) const;
        long read_file(const Path& file_name);

        AString to_string() const;

    private:
        void  add_page_(bool reserveHeader);
        void  add_page_(size_t size, bool reserveHeader);

    private:
        size_t default_page_size_;
        size_t total_size_;
        PPage first_;
        PPage last_;
        mutable     Pos pos_;
        bool is_ascii_;

    public :

        PPage get_last()
        {
            return last_;
        }

        enum
        {
            DEFAULT_PAGE_SIZE = 4096, /* bigger than HEADER_SIZE */
        };
    };
};

#endif