array_factory.hpp

//
// (c) Copyright 2014 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: Mar 12, 2014
//     Author: Eugen Wintersberger <eugen.wintersberger@desy.de>
//
#pragma once

#include <boost/mpl/arithmetic.hpp>
#include <boost/mpl/times.hpp>
#include <boost/mpl/vector.hpp>
#include <boost/mpl/size_t.hpp>
#include <boost/lexical_cast.hpp>

#include "../utilities/container_utils.hpp"

namespace pni{
namespace core{


    //-------------------------------------------------------------------------
    template<typename ATYPE> struct array_factory
    {
        typedef ATYPE array_type;
        typedef typename array_type::value_type value_type;
        typedef typename array_type::map_type map_type;
        typedef typename array_type::storage_type storage_type;


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

        template<typename STYPE> 
        static array_type create(const STYPE &s,
                                 value_type def_val = value_type())
        {
            //create the index map
            auto map = map_utils<map_type>::create(s);
            auto storage = container_utils<storage_type>::create(map.max_elements());
            std::fill(storage.begin(),storage.end(),def_val);
            
            return array_type(std::move(map),std::move(storage));
        }

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

        template<typename STYPE,
                 typename DTYPE
                >
        static array_type create(const STYPE &s,const DTYPE &data)
        {
            auto map = map_utils<map_type>::create(s);
            if(map.max_elements() != data.size())
                throw size_mismatch_error(EXCEPTION_RECORD,
                        "Total number of elements from map ("
                        +boost::lexical_cast<string>(map.max_elements())+
                        ") does not match data size ("
                        +boost::lexical_cast<string>(data.size())+")!");

            auto storage = container_utils<storage_type>::create(data.size());
            std::copy(data.begin(),data.end(),storage.begin());
            return array_type(std::move(map),std::move(storage));
        }

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

        template<
                 typename IT,
                 typename DT
                >
        static array_type create(std::initializer_list<IT> shape,
                                 std::initializer_list<DT> data)
        {
            auto map = map_utils<map_type>::create(shape);
            if(map.max_elements() != data.size())
                throw size_mismatch_error(EXCEPTION_RECORD,
                        "Total number of elements from map ("
                        +boost::lexical_cast<string>(map.max_elements())+
                        "does not match data size ("
                        +boost::lexical_cast<string>(data.size())+")!");

            auto storage = container_utils<storage_type>::create(data.size());
            std::copy(data.begin(),data.end(),storage.begin());
            return array_type(std::move(map),std::move(storage));
        }
        
    };
    
//end of namespace
}
}