array.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: Jan 11, 2013
//     Author: Eugen Wintersberger <eugen.wintersberger@desy.de>
//
#pragma once
#include<iostream>
#include<memory>

#include "../error/exceptions.hpp"
#include "../error/exception_utils.hpp"
#include "../types/types.hpp"
#include "../arrays.hpp"
#include "array_holder.hpp"
#include "array_iterator.hpp"
#include "../algorithms.hpp"


namespace pni{
namespace core{



    class array //the type erasure
    {
        private:
            typedef std::unique_ptr<array_holder_interface> pointer_type;
            
            //----------------------------------------------------------------
            static void _throw_not_allocated_error(const exception_record &r)
            {
                throw memory_not_allocated_error(r,
                        "Instance of data_object holds no data!");
            }

            //----------------------------------------------------------------
            static void _check_pointer(const pointer_type &ptr,
                                  const exception_record &r)
            {
                if(!ptr)
                    _throw_not_allocated_error(r);
            }

            pointer_type _ptr; 
        public:
            //====================public types=================================
            typedef value value_type; 
            typedef array_iterator<0> iterator; 
            typedef array_iterator<1> const_iterator; 
            typedef array_holder_interface::element_index element_index;
            typedef array_holder_interface::view_index view_index;
            typedef size_t size_type; 
            //===================constructors and destructor===================
            array():_ptr(nullptr) {}

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

            template<typename T,
                     //this template expression is necessary to avoid that this
                     //constructor is callend when data_object itself is to be
                     //copied (see below for the correct copy constructor)
                     typename  = typename std::enable_if<
                                       !std::is_same<array,typename
                                       std::remove_reference<T>::type >::value 
                                       >::type
                    > 
            explicit array(const T &o):_ptr(new array_holder<T>(o))
            { }

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

            template<typename T,
                     //this template expression is necessary to avoid that this
                     //constructor is used when a data_object by itself is to be
                     //moved (seel below for the correct move constructor)
                     typename = typename std::enable_if<
                                       !std::is_same<array,typename
                                       std::remove_reference<T>::type >::value 
                                       >::type
                    > 
            explicit array(T &&o):
                _ptr(new array_holder<typename std::remove_cv<
                                typename std::remove_reference<T>::type>::type>
                                (std::forward<T>(o)))
            { }


            //------------------------------------------------------------------
            array(const array &e);
            //------------------------------------------------------------------
            array(array &&e);

            //==============assignment operators===============================
            array &operator=(const array &a);

            //-----------------------------------------------------------------
            array &operator=(array &&a);

            //=====================public member functions=====================
            type_id_t type_id() const;
            
            //-----------------------------------------------------------------
            size_t rank() const;

            //-----------------------------------------------------------------
            shape_t shape() const;

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

            template<typename CTYPE> CTYPE shape() const;

            //-----------------------------------------------------------------
            size_t size() const; 


            //-----------------------------------------------------------------
            value operator[](size_t i) const;

            //-----------------------------------------------------------------
            value at(size_t i) const;

            //-----------------------------------------------------------------
            value_ref operator[](size_t i);

            //-----------------------------------------------------------------
            value_ref at(size_t i);

            //-----------------------------------------------------------------
            value_ref operator()(const element_index &index);

            //-----------------------------------------------------------------
            value operator()(const element_index &index) const;

            //-----------------------------------------------------------------
            string type_name() const;

            //-----------------------------------------------------------------
            iterator begin() { return iterator(this,0); }

            //-----------------------------------------------------------------
            iterator end() { return iterator(this,size()); }

            //-----------------------------------------------------------------
            const_iterator begin() const { return const_iterator(this,0); }

            //-----------------------------------------------------------------
            const_iterator end() const { return const_iterator(this,size()); }

            //-----------------------------------------------------------------
            const void *data() const;

            //-----------------------------------------------------------------
            void *data() ;
            
    };

    //======================implementation of template members=================
    template<typename CTYPE> CTYPE array::shape() const
    {
        shape_t s = this->shape();
        CTYPE c(s.size());
        std::copy(s.begin(),s.end(),c.begin());
        return c;
    }

    //-------------------------------------------------------------------------
    type_id_t type_id(const array &a);

//end of namespace
}
}