ivl/details/array/impl/specialization/ref_val_repeat_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/>. */


template <class T,
         class DERIVED_INFO
         >
class array<T, data::ref_val_repeat<DERIVED_INFO> >
        :
        public array_common_base<array<T,
                data::ref_val_repeat<DERIVED_INFO> > >
{

private:
        typedef array_common_base<array<T,
                data::ref_val_repeat<DERIVED_INFO> > > common_base_class;

        size_t len;
        const T* val;

public:
        typedef array 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;

        void setval(const T& val)
        {
                this->val = &val;
        }

        void resize(size_t len)
        {
                this->len = len;
        }

        class const_iterator
        {
                size_t i;
                const T* val;
        public:

                // iterator_traits
                typedef std::random_access_iterator_tag iterator_category;
                typedef T value_type;
                typedef ptrdiff_t difference_type;
                typedef const value_type* pointer;
                typedef value_type reference;

                const_iterator() { }
                const_iterator(const const_iterator& it) : i(it.i), val(it.val) { }
                const_iterator(size_t i, const T* val) : i(i), val(val) { }

                const_iterator& operator++() { ++i; return *this; }
                const_iterator& operator--() { --i; return *this; }

                const_iterator operator++(int) { return const_iterator(i++); }
                const_iterator operator--(int) { return const_iterator(i++); }

                // random access
                const_iterator operator +(const difference_type i) const
                        { return const_iterator(this->i + i, val); }
                const_iterator operator -(const difference_type i) const
                        { return const_iterator(this->i - i, val); }
                const_iterator& operator +=(const difference_type i)
                        { this->i += i; return *this; }
                const_iterator& operator -=(const difference_type i)
                        { this->i -= i; return *this; }

                const T operator *() const { return *val; }

                const T* operator ->() const { return val; }

                const T operator [] (size_t j) const { return *val; }

                const_iterator& operator=(const const_iterator& it)
                        { i = it.i; val = it.val; return *this; }

                bool operator==(const const_iterator& it) const { return i == it.i; }
                bool operator!=(const const_iterator& it) const { return i != it.i; }

        };

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

        typedef std::reverse_iterator<const_iterator> const_reverse_iterator;

        typedef ptrdiff_t iter_border_walker;

        const_iterator begin() const { return const_iterator(0, val); }
        const_iterator end() const { return const_iterator(len, val); }
        const_reverse_iterator rbegin() const { return const_iterator(len, val); }
        const_reverse_iterator rend() const { return const_iterator(0, val); }


        size_t length() const { return len; }
        size_type size() const { return length(); }
        size_t numel() const { return length(); }
        iter_border_walker first_to_last() { return this->length() - 1; }
        iter_border_walker begin_to_end() { return this->length(); }


        const T& operator[](size_t offset) const {
                CHECK(offset >= 0 && offset < length(), erange);
                return *val;
        }

        array() : len(0) { }

        explicit array(size_t count) : len(count) { }

        explicit array(int count) : len(count) { }

        explicit array(long int count) : len(count) { }

        array(size_t count, const T& s) : len(count), val(&s) { }

        array(size_t count, const T *ptr) : len(count), val(ptr) { }

        array(const this_type& a) : len(a.len), val(a.val) { }

        template <class J, class S>
        array(const array<J, S>& a, size_t n) : len(n) { }

        template <class J, class S>
        array(const array<J, S>& a) : len(a.length()) { }

        template <class J, class S>
        array(size_t count, const array<J, S>& a) : len(count) { }
        //TODO: ensure (in this but more importantly in other classes
        // that the same rule is applied to all (count, array) - (array, count) pairs.
        // i have in mind some rule that, in one case, the minimum (or maximum)
        // of array length, n is used. Ensure that this doesnt hold.


        ~array() { }

        void init(size_t count, const T& s) { len = count; val = &s; }

        void init(const this_type& a) { len = a.len; val = a.val; }


        this_type& operator=(const this_type& o)
                { len = o.len; val = o.val; return *this; }
};