container_utils.hpp

//
// (c) Copyright 2013 DESY, Eugen Wintersberger <eugen.wintersberger@desy.de>
//
// This file is part of libpnicore.
//
// libpnicore 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 2 of the License, or
// (at your option) any later version.
//
// libpnicore 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 libpnicore.  If not, see <http://www.gnu.org/licenses/>.
//
// ============================================================================
//
// Created on: Nov 07, 2013
//     Author: Eugen Wintersberger <eugen.wintersberger@desy.de>
//

#pragma once

#include <iostream>
#include <sstream>
#include <tuple>
#include "../error/exceptions.hpp"
#include "sfinae_macros.hpp"

namespace pni{
namespace core{


    template<typename CTYPE> 
    struct container_utils
    {
        typedef CTYPE container_type;
        typedef typename CTYPE::value_type value_type;

        //---------------------------------------------------------------------

        static container_type create(size_t n,
                                     value_type default_value=value_type())
        {
            container_type c(n);
            std::fill(c.begin(),c.end(),default_value);
            return c;
        }

        //---------------------------------------------------------------------

        template<
                 typename ITERT,
                 typename = enable_if<or_t<not_t<is_pod<ITERT>>,is_ptr<ITERT>>>
                >
        static container_type create(ITERT begin,ITERT end)
        {
            container_type c(std::distance(begin,end));
            std::copy(begin,end,c.begin());
            return c;
        }

        //---------------------------------------------------------------------

        template<
                 typename OCTYPE,
                 typename = enable_if<not_t<is_pod<OCTYPE>>>
                >
        static container_type create(const OCTYPE &o)
        {
            container_type c(o.size());
            std::copy(o.begin(),o.end(),c.begin());
            return c;
        }

        //---------------------------------------------------------------------

        template<typename T>
        static container_type create(const std::initializer_list<T> &list)
        {
            container_type c(list.size());
            std::copy(list.begin(),list.end(),c.begin());
            return c;
        }
    };

    //-------------------------------------------------------------------------
    template<
             typename T,
             size_t   N
            > 
    struct container_utils<std::array<T,N>>
    {
        typedef std::array<T,N> container_type;
        typedef T value_type;

        //---------------------------------------------------------------------

        static container_type create(size_t n,
                                     value_type default_value=value_type())
        {
            if(n!=N)
            {
                std::stringstream message;
                message<<"Number of elements ("<<n<<") not supported by ";
                message<<"array type which has ("<<N<<")!";
                throw size_mismatch_error(EXCEPTION_RECORD,message.str());
            }

            container_type v;
            std::fill(v.begin(),v.end(),default_value);
            return v;
        }

        //---------------------------------------------------------------------

        template<
                 typename ITERT,
                 typename = enable_if<or_t<
                            not_t<is_pod<ITERT>>,is_ptr<ITERT> 
                            >>
                >
        static container_type create(ITERT begin,ITERT end)
        {
            if(N!=std::distance(begin,end))
            {
                std::stringstream message;
                message<<"Iterators span ("<<std::distance(begin,end)<<")";
                message<<" only ("<<N<<") supported by the array type!";
                throw size_mismatch_error(EXCEPTION_RECORD,message.str());
            }

            container_type v;
            std::copy(begin,end,v.begin());
            return v;
        }

        //---------------------------------------------------------------------

        template<
                 typename OCTYPE,
                 typename = enable_if<not_t<is_pod<OCTYPE>>>
                >
        static container_type create(const OCTYPE &o)
        {
           if(o.size() != N)
           {
               std::stringstream message;
               message<<"Original container has ("<<o.size()<<") elements, ";
               message<<"array supports only ("<<N<<")!";
               throw size_mismatch_error(EXCEPTION_RECORD,message.str());
           }

           container_type v;
           std::copy(o.begin(),o.end(),v.begin());
           return v;
        }

        //---------------------------------------------------------------------
        static container_type create(const std::array<T,N> &c)
        {
            return c;
        }

        //---------------------------------------------------------------------

        template<typename ET>
        static container_type create(const std::initializer_list<ET> &list)
        {
            if(list.size()!=N)
            {
                std::stringstream message;
                message<<"Initializer list has ("<<list.size()<<") elements, ";
                message<<"array supports only ("<<N<<")!";
                throw size_mismatch_error(EXCEPTION_RECORD,message.str());
            }

            container_type v;
            std::copy(list.begin(),list.end(),v.begin());
            return v;
        }
    };

    //=========================================================================
    // implementation of a variadic function template to check the size of a set
    // of containers passed as variadic input arguments
    //=========================================================================
   
    //-------------------------------------------------------------------------
    template<typename STYPE>
    bool check_size(STYPE)
    {
        return true;
    }

    //-------------------------------------------------------------------------
    template<
             typename    STYPE,
             typename    CTYPE,
             typename ...CTYPES
            >
    bool check_size(STYPE s,const CTYPE &c,const CTYPES& ...cs)
    {
        return s!=c.size()?false:check_size(c.size(),cs...);
    }

    //-------------------------------------------------------------------------

    template<
             typename    CTYPE,
             typename ...CTYPES
            >
    bool check_equal_size(const CTYPE &c,const CTYPES& ...cs)
    {
        return check_size(c.size(),cs...);
    }



//end of namespace
}
}