Array.h

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


#ifndef CMR_ARRAY_INCLUDED
#define CMR_ARRAY_INCLUDED

#include "BaseArray.h"

namespace commore
{
    template< class T, class A> class  Array : public BaseArray
    {
    public:
        typedef T value_type;

        Array() {}
        Array(size_t nb)
        {
            reserve_(nb, sizeof(T), A::constructor, A::destructor);
        }
        Array(const Array& v) : BaseArray()
        {
            reserve(v.reserved());
            add_(v.size(), sizeof(T), (Byte*)v.data_, A::constructor, A::destructor);
        }
        Array<T, A>& operator=(const Array<T, A>& v)
        {
            clear();
            add_(v.size(), sizeof(T), (Byte*)v.data_, A::constructor, A::destructor);
            return *this;
        }
        ~Array()
        {
            clear();
        }
        void clear(bool all = true)
        {
            clear_(sizeof(T), A::destructor, all);
        }
        void resize(int n)
        {
            resize_(n, sizeof(T), A::constructor, A::destructor);
        }
        T& add()
        {
            return *(T*)add_(1, sizeof(T), 0, A::constructor, A::destructor);
        }
        T& add(const T& v)
        {
            return *(T*)add_(1, sizeof(T), (Byte*)&v, A::constructor, A::destructor);
        }
        const T* get_at(int pos) const
        {
            return (const T*)at_(pos, sizeof(T));
        }
        T* get_at(int pos)
        {
            return (T*)at_(pos, sizeof(T));
        }
        T& operator [](int pos)
        {
            return *get_at(pos);
        }
        const T& operator [](int pos) const
        {
            return *get_at(pos);
        }
        size_t reserve(size_t nb)
        {
            return reserve_(nb, sizeof(T), A::constructor, A::destructor);
        }
        int compare(const  Array<T, A>& a) const
        {
            return compare(a, A::comparator);
        }
        bool operator< (const Array<T, A>& a) const
        {
            return compare(a, A::comparator) < 0;
        }
        bool operator== (const Array<T, A>& l) const
        {
            return compare(l, A::comparator) == 0;
        }

        CMREXD AString& toString(AString& dst) const;


        CMREXD long  read_xml(IBStream& i);
        CMREXD long  write_xml(OBStream& o) const;
        
        CMREXD int   write(const Path& file) const;
        CMREXD int   read(const Path& file);
        CMREXD int   write_xml(const Path& file) const;
        CMREXD int   read_xml(const Path& file);
        CMREXD AString& to_xml_string(AString& s) const;
        CMREXD  long  from_xml_string(const AString& s);


        int compare(const Array<T, A>& a, FunctionComparator cmor) const
        {
            int r = (int)size() - (int)a.size();
            if (r == 0)
            {
                const_iterator i1 = begin();
                const_iterator i2 = a.begin();
                while (r == 0 && i1 && i2)
                {
                    r = cmor(i1.get_dummy(), i2.get_dummy());
                    i1++;
                    i2++;
                }
            }
            return r;
        }

        class iterator : public BaseArray::iterator
        {
        public:
            bool next()
            {
                return BaseArray::next_(*this, sizeof(T));
            }
            T& current()
            {
                return *(T*)get_data();
            }
            iterator& operator++()
            {
                next();
                return *this;
            }
            iterator  operator++(int)
            {
                iterator tmp = *this;
                next();
                return tmp;
            }
            T& operator*()
            {
                return current();
            }
        };
        class const_iterator : public BaseArray::const_iterator
        {
        public:
            bool next()
            {
                return BaseArray::next_(*this, sizeof(T));
            }
            const T& current()
            {
                return *(T*)get_data();
            }
            const_iterator& operator++()
            {
                next();
                return *this;
            }
            const_iterator  operator++(int)
            {
                const_iterator tmp = *this;
                next();
                return tmp;
            }
            const T& operator*()
            {
                return current();
            }
        };

        iterator begin()
        {
            iterator i;
            begin_(i);
            return i;
        }
        const_iterator begin() const
        {
            const_iterator i;
            begin_(i);
            return i;
        }

        const_iterator cbegin() const
        {
            return begin();
        }

    };
}

#endif