ivl/details/array/impl/specialization/array_class.hpp

/* This file is part of the ivl C++ library <http://image.ntua.gr/ivl>.
   A C++ template library extending syntax towards mathematical notation.

   Copyright (C) 2012 Yannis Avrithis <iavr@image.ntua.gr>
   Copyright (C) 2012 Kimon Kontosis <kimonas@image.ntua.gr>

   ivl is free software; you can redistribute it and/or modify
   it under the terms of the GNU Lesser General Public License 
   version 3 as published by the Free Software Foundation.

   Alternatively, you can redistribute it and/or modify it under the terms 
   of the GNU General Public License version 2 as published by the Free 
   Software Foundation.

   ivl is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  
   See the GNU General Public License for more details.

   You should have received a copy of the GNU General Public License 
   and a copy of the GNU Lesser General Public License along 
   with ivl. If not, see <http://www.gnu.org/licenses/>. */


// data::normal is defined in data_base.hpp

template <class T, class OPTS = data::mem<> >
class array:

        public array_common_base<array<T, OPTS> >,

        public std::vector<T>
{
private:
        typedef array_common_base<array<T, OPTS> > common_base_class;

public:
        typedef typename types::t_not<types::is_bool<T> >::type has_c_ptr;

        typedef typename common_base_class::data_type data_type;

        typedef array <T, OPTS> this_type;

        typedef this_type this_array_type;

        typedef this_type array_type;

        typedef T elem_type;

        typedef typename this_type::derived_type derived_type;

        typedef typename common_base_class::base_class base_class;

        typedef size_t size_type;

        typedef ptrdiff_t diff_type;

        using base_class::derived;

        typedef typename std::vector<T>::iterator iterator;
        typedef typename std::vector<T>::const_iterator const_iterator;
        typedef typename std::vector<T>::reverse_iterator reverse_iterator;
        typedef typename std::vector<T>::
                const_reverse_iterator const_reverse_iterator;
        using std::vector<T>::begin;
        using std::vector<T>::end;
        using std::vector<T>::rbegin;
        using std::vector<T>::rend;

        typedef iterator best_iterator;
        typedef typename const_iterator::reference const_reference;
        typedef typename iterator::reference reference;
        typedef reference best_reference;

        using common_base_class::assign; // vector assign is not used
        // left here along with array.assign() for now, however might be removed.
        using std::vector<T>::assign;

        void clear()
        {
                std::vector<T>().swap(static_cast<std::vector<T>&>(*this));
        }

        void swap(std::vector<T>& v)
        {
                std::vector<T>::swap(v);
        }

        //TODO: fix
        template<class J, class D>
        void swap(array<J, D>& a)
        {
                this->derived() = a.derived();
        }
        /*template <class J, class D, class P>
        void swap(array_nd<J, D, P>& a)
        {
                // error: can't swap array with array_nd.
                throw(ecomp);
        }*/

        //TODO: what happens with resize? with base members. do resolve.
        //in need, create resize function here that does the right thing.
        using std::vector<T>::resize;

        void reshape(size_t len) { resize(len); }
        void reshape(size_t len, const T& s) { resize(len, s); }



        void init() { this->clear(); }

        void init(size_t count) { this->resize(count); /* does not need to keep data */ }

        void init(int count) { this->init(size_t(count)); }

        void init(long int count) { this->init(size_t(count)); }

        void init(size_t count, const T& s) { std::vector<T>::assign(count, s); }

        void init(size_t count, const T *ptr) { std::vector<T>::assign(ptr, ptr + count); }

        template <class J>
        void init(const internal::tuple_rvalue<J>& r)
                { this->clear(); r.tuple_output(internal::reftpl(*this)); }

        void init(const array& a) { std::vector<T>::assign(a.begin(), a.end()); }

        template <class J, class S>
        void init(const array<J, S>& a, size_t n) 
        {
                std::vector<T>::resize(n > 0 ? n : a.length());
                ivl::copy_out(*this, a);
        }

        template <class J, class S>
        void init(const array<J, S>& a)
        {
                // This implementation needs us to be careful.
                // while  : std::vector<T>(a.begin(), a.end()) { } is always valid,
                // it consumes double time of iteration for non-random-access arrays.
                // so we will have to specialize it.
                std::vector<T>::resize(0);
                array_details::
                        vector_initializer<array<T, S>::has_random_access::value>
                        ::operate(static_cast<std::vector<T>&>(*this), a);
        }

        template <class J, class S>
        void init(size_t count, const array<J, S>& a)
        {
                std::vector<T>::resize(count);
                this->init_size_with(a);
        }
                
        /*
        void resize(size_t sz)
        {
                if(sz == 0)
                        std::vector<T>().swap(static_cast<std::vector<T>&>(*this));
                else
                        std::vector<T>::resize(sz);
        }

        void resize(size_t sz, const T& s)
        {
                if(sz == 0)
                        std::vector<T>().swap(static_cast<std::vector<T>&>(*this));
                else
                        std::vector<T>::resize(sz, s);
        }
        */
        /*
        void reset(size_t sz, const T s = T())
        {
                if(sz == 0 || sz > std::vector<T>::capacity()
                        || sz < std::vector<T>::capacity() / 2)
                        std::vector<T>().swap(static_cast<std::vector<T>&>(*this));
                else
                        std::vector<T>::resize(0);

                std::vector<T>::resize(sz, s);
        }
        */

        typedef ptrdiff_t iter_border_walker;

        // TODO:
        // warning: since bit vector does not return an actual pointer
        // this function is deceiving cause it doesn't return an actual c_ptr!
        // the solution to remove c_ptr from vector is not an option.
        // to remove it from bool vector is an option, or another option
        // is to get the bitmap data some way.
        // also would we need to have the pseudo pointer in some occasions?
        // by let's say another function, ptr(). ?
        typename std::vector<T>::pointer c_ptr()
                { return &(std::vector<T>::operator[](0)); }
        typename std::vector<T>::const_pointer c_ptr() const
                { return &(std::vector<T>::operator[](0)); }

        //TODO: explain this better.
        size_t length() const { return std::vector<T>::size(); }
        size_type size() const { return length(); }
        size_t numel() const { return length(); }
        iter_border_walker first_to_last() const { return this->length() - 1; }
        iter_border_walker begin_to_end() const { return this->length(); }


        typename std::vector<T>::const_reference operator[](size_t offset) const
        {
                CHECK(offset >= 0 && offset < length(), erange);
                return std::vector<T>::operator[](offset);
        }
        typename std::vector<T>::reference operator[](size_t offset)
        {
                CHECK(offset >= 0 && offset < length(), erange);
                return std::vector<T>::operator[](offset);
        }

        using common_base_class::operator[];


        array() { }

        explicit array(size_t count) : std::vector<T>(count) { }

        explicit array(int count) : std::vector<T>(size_t(count)) { }

        explicit array(long int count) : std::vector<T>(size_t(count)) { }

        array(size_t count, const T& s) : std::vector<T>(count, s) { }

        array(size_t count, const T *ptr) : std::vector<T>(ptr, ptr + count) { }


        template<class S, int J>
        array(S (&arr)[J]) : std::vector<T>(arr, arr + J) { }


        template <class J>
        array(const internal::tuple_rvalue<J>& r)
                { r.tuple_output(internal::reftpl(*this)); }

        array(const array& a) : std::vector<T>(a.begin(), a.end()) { }

        template <class J, class S>
        inline
        array(const array<J, S>& a, size_t n) :
                std::vector<T>(n > 0 ? n : a.length())
        {
                ivl::copy_out(*this, a);
        }


        template <class J, class S>
        array(const array<J, S>& a)
        {
                // This implementation needs us to be careful.
                // while  : std::vector<T>(a.begin(), a.end()) { } is always valid,
                // it consumes double time of iteration for non-random-access arrays.
                // so we will have to specialize it.
                array_details::
                        vector_initializer<array<T, S>::has_random_access::value>
                        ::operate(static_cast<std::vector<T>&>(*this), a);
        }

        template <class J, class S>
        array(size_t count, const array<J, S>& a) : std::vector<T>(count)
        {
                this->init_size_with(a);
        }





        ~array() { }


        template<class K>
        derived_type& operator=(const K& k)
        {
                common_base_class::operator=(k);
                return derived();
        }
        //using common_base_class::operator=;
        this_type& operator=(const this_type& a) // LEFT IN THE CONST MODE FOR A COPY CONSTRUCTOR!
        {
                // if(this != &a) TODO: make this a rule: make clear that ...
                // Note: the data class handles the check: if(this != &a),
                // and only IF needed, so there is no case of cpu waste
                common_base_class::operator=(a);
                return *this;
        }


        /*
        template<class S, class K>
        derived_type& operator=(const ivl::array<T, S, K>& a)
        {
                common_base_class::operator=(a);
                return derived();
        }

        derived_type& operator=(const T& s)
        */



};