ivl/details/array/impl/specialization/empty_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::empty<DERIVED_INFO> > :
        public array_common_base<array<T, data::empty<DERIVED_INFO> > >
{

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

protected:

public:
        typedef array this_type;

        typedef this_type this_array_type;

        typedef this_type array_type;

        typedef T elem_type;

        typedef const T& const_reference;
        typedef const_reference best_reference;

        typedef typename this_type::derived_type derived_type;

        typedef typename common_base_class::base_class base_class;

        typedef size_t size_type;

        using base_class::derived;

        struct iter_border_walker {
                iter_border_walker() {}
                iter_border_walker(ptrdiff_t) {}
                template <class IT>
                iter_border_walker(const IT&, const IT&) {}
        };

        class const_iterator
        : public types::border_walker_iterator_identifier
        {
        public:
                // iterator_traits
                typedef std::random_access_iterator_tag iterator_category;
                typedef typename types::remove_const<T>::type value_type;
                typedef ptrdiff_t difference_type;
                typedef const value_type* pointer;
                typedef const value_type& reference;

                // border_walker
                typedef typename array::iter_border_walker iter_border_walker;

                const_iterator() { }
                const_iterator(const const_iterator& it) { }

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

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

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

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

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

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

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

                bool operator==(const const_iterator& it) const { return true; }
                bool operator!=(const const_iterator& it) const { return false; }

        };

        typedef const_iterator best_iterator;

        typedef std::reverse_iterator<const_iterator> const_reverse_iterator;

        const_iterator begin() const { return const_iterator(); }
        const_iterator end() const { return const_iterator(); }
        const_reverse_iterator rbegin() const { return const_iterator(); }
        const_reverse_iterator rend() const { return const_iterator(); }

        //TODO: explain this better.
        size_t length() const { return 0; }
        size_type size() const { return 0; }
        size_t numel() const { return 0; }
        iter_border_walker first_to_last() { return iter_border_walker(); }
        iter_border_walker begin_to_end() { return iter_border_walker(); }






        T operator[] (size_t i) const { return T(); }
        static derived_type instance;


        array() { }

        array(const this_type& a) { }

        ~array() { }

        this_type& operator=(const this_type& a) // LEFT IN THE CONST MODE FOR A COPY CONSTRUCTOR!
        {
        }


};

template<class T>
inline
array<T, data::empty<> > empty()
{
        return array<T, data::empty<> >();
}