vector.hpp

Go to the documentation of this file.

// This file is a part of NiHu, a C++ BEM template library.
//
// Copyright (C) 2012-2014  Peter Fiala <fiala@hit.bme.hu>
// Copyright (C) 2012-2014  Peter Rucz <rucz@hit.bme.hu>
//
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
//
// This program 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
// along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
#ifndef VECTOR_HPP_INCLUDED
#define VECTOR_HPP_INCLUDED
 
#include "integer.hpp"
#include "sequence.hpp"
 
#include <tuple>
 
namespace tmp
{
    struct vector_tag;
 
    template <class...Args>
    struct vector
    {
        typedef vector type;
        typedef vector_tag tag;
 
        typedef std::tuple<Args...> impl;
    };
 
    namespace internal
    {
        template <>
        struct empty_impl<vector_tag> : vector<> {};
    
        template <>
        struct at_impl<vector_tag>
        {
            template <class Seq, class Pos>
            struct apply : std::tuple_element<Pos::value, typename Seq::impl> {};
        };
    } // namespace internal
 
    template <class Seq, class Pos>
    struct vector_iterator
    {
        typedef vector_iterator type;
    };
 
    template <class Seq, class Pos>
    struct next<vector_iterator<Seq, Pos> > :
        vector_iterator<Seq, typename next<Pos>::type> {};
 
    template <class Seq, class Pos>
    struct prev<vector_iterator<Seq, Pos> > :
        vector_iterator<Seq, typename prev<Pos>::type> {};
 
    namespace internal
    {
        template <>
        struct size_impl<vector_tag>
        {
            template <class Seq>
            struct apply : integer<int, std::tuple_size<typename Seq::impl>::value> {};
        };
    }
 
    template <class Seq, class Pos>
    struct deref<vector_iterator<Seq, Pos> > : at<Seq, Pos> {};
 
    namespace internal
    {
        template <>
        struct begin_impl<vector_tag>
        {
            template <class Vect>
            struct apply
            {
                typedef vector_iterator<Vect, integer<int, 0> > type;
            };
        };
 
        template <>
        struct end_impl<vector_tag>
        {
            template <class Vect>
            struct apply
            {
                typedef vector_iterator<
                    Vect,
                    typename size_impl<vector_tag>::template apply<Vect>::type
                > type;
            };
        };
 
        template <>
        struct clear_impl<vector_tag>
        {
            template <class Seq>
            struct apply : vector<> {};
        };
 
        template <class Vect, class T>
        struct vector_push_front;
 
        template <class...Args, class T>
        struct vector_push_front<vector<Args...>, T> : vector<T, Args...> {};
 
        template <>
        struct push_front_impl<vector_tag>
        {
            template <class Vect, class T>
            struct apply : vector_push_front<Vect, T> {};
        };
 
        template <class Vect, class T>
        struct vector_push_back;
 
        template <class...Args, class T>
        struct vector_push_back<vector<Args...>, T> : vector<Args..., T> {};
 
        template <>
        struct push_back_impl<vector_tag>
        {
            template <class Seq, class T>
            struct apply : vector_push_back<Seq, T> {};
        };
 
 
        template <class Vect>
        struct vector_pop_front;
 
        template <class...Args, class T>
        struct vector_pop_front<vector<T, Args...> > : vector<Args...> {};
 
        template <>
        struct pop_front_impl<vector_tag>
        {
            template <class Seq>
            struct apply : vector_pop_front<Seq> {};
        };
 
    } // namespace internal
} // namespace tmp
 
#endif /* VECTOR_HPP_INCLUDED */