BaseArray.h

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


#ifndef CMR_BASE_ARRAY_INCLUDED
#define CMR_BASE_ARRAY_INCLUDED

#include "Allocator.h"

namespace commore
{

    const size_t ARRAY_INITIAL_SIZE = 2;

    class CMREXD BaseArray
    {
    protected:
        Byte* data_;
        size_t size_;
        size_t reserved_;
        BaseArray();
        Byte* add_(size_t nb, size_t item_size, Byte* data, FunctionConstructor c, FunctionDestructor d);

        void clear_(size_t item_size, FunctionDestructor d, bool all);

        void resize_(int new_size, size_t item_size, FunctionConstructor c, FunctionDestructor d);

        Byte* at_(size_t i, size_t item_size);
        const Byte* at_(size_t i, size_t item_size) const;

        size_t reserve_(size_t nb, size_t item_size, FunctionConstructor c, FunctionDestructor d);


        Byte* data()
        {
            return data_;
        }
        const Byte* data() const
        {
            return data_;
        }
    public:

        class CMREXD iterator
        {
            friend class BaseArray;
        protected:
            iterator();
            Byte* current_data_;
            size_t size_;
            size_t current_index_;
        public:
            Dummy& get_dummy() const;
            Byte* get_data();
            bool more() const;
            size_t index() const
            {
                return current_index_;
            }
            operator bool () const
            {
                return more();
            }
        };
        class CMREXD const_iterator
        {
            friend class BaseArray;
        protected:
            const_iterator();
            Byte* current_data_;
            size_t size_;
            size_t current_index_;
        public:
            const Dummy& get_dummy() const;
            const Byte* get_data() const;
            bool more() const;
            size_t index() const
            {
                return current_index_;
            }
            operator bool () const
            {
                return more();
            }
        };

        static bool next_(iterator& i, size_t item_size);
        static bool next_(const_iterator& i, size_t item_size);
    public:

        void splice(BaseArray& array);

        size_t size() const;

        size_t reserved() const;

    protected:

        void  begin_(iterator&);
        //iterator  end();
        void  begin_(const_iterator&) const;
        //const_iterator  end() const;

    };

}

#endif