nxfield.hpp

Go to the documentation of this file.

//
// Declaration of the NXfield template
//
// (c) Copyright 2011 DESY, Eugen Wintersberger <eugen.wintersberger@desy.de>
//
// This file is part of libpniio.
//
// libpniio 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.
//
// libpniio 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 libpniio.  If not, see <http://www.gnu.org/licenses/>.
//************************************************************************
//
// Declaration of the NXfield template
//
// Created on: Jul 3, 2011
//     Author: Eugen Wintersberger <eugen.wintersberger@desy.de>
//
#pragma once

#include <sstream>

#include <pni/core/types.hpp>
#include <pni/core/arrays/mdarray.hpp>
#include <pni/core/arrays/array_view.hpp>
#include <pni/core/arrays/slice.hpp>
#include <pni/core/type_erasures/array.hpp>
#include <pni/core/error.hpp>

#include "nxattribute_manager.hpp"
#include "nxobject_traits.hpp"
#include "algorithms/as_field.hpp"


namespace pni{
namespace io{
namespace nx{    



    template<nximp_code IMPID> class nxfield
    {
        public:
            typedef typename nximp_map<IMPID>::field_imp imp_type;
            typedef typename nximp_map<IMPID>::type_imp  type_type;
            typedef nxfield<IMPID>              field_type;
            typedef typename nxobject_trait<IMPID>::attribute_type
                attribute_type;
        private:
            imp_type _imp;

            static pni::core::string 
            _shape_mismatch_error_message(const pni::core::shape_t &ashape,
                                          const pni::core::shape_t &fshape) 
            {
                std::stringstream ss;
                ss<<"Array shape ( ";
                for(auto v: ashape) ss<<v<<" ";
                ss<<") and field shape ( ";
                for(auto v: fshape) ss<<v<<" ";
                ss<<") do not match!";

                return ss.str();
            }


            //-----------------------------------------------------------------
            template<typename ATYPE> 
            void _read_array(ATYPE &a) const
            {
                using namespace pni::core;
                
                typedef typename type_type::index_vector_type index_vector_type;
                check_allocation_state(a,EXCEPTION_RECORD);
                check_equal_size(a,*this,EXCEPTION_RECORD);

                _imp.read(pni::core::type_id(a),
                          a.template shape<index_vector_type>(),a.data());

            }

            //-----------------------------------------------------------------
            template<typename ATYPE> 
            void _write_array(const ATYPE &a) const
            {
                using namespace pni::core;
                
                typedef typename type_type::index_vector_type index_vector_type;
                check_allocation_state(a,EXCEPTION_RECORD);
                check_equal_size(a,*this,EXCEPTION_RECORD);

                _imp.write(pni::core::type_id(a),
                           a.template shape<index_vector_type>(),a.data()); 
            }


        public:
            //===================public attributes=============================
            nxattribute_manager<field_type> attributes;
            //============constructors and destructors=========================
            explicit nxfield():
                _imp(),
                attributes(_imp)
            { }

            //-----------------------------------------------------------------
            nxfield(const field_type &o):
                _imp(o._imp),
                attributes(_imp)
            { }

            //-----------------------------------------------------------------
            nxfield(field_type &&o):
                _imp(std::move(o._imp)),
                attributes(_imp)
            { }

            //-----------------------------------------------------------------
            explicit nxfield(imp_type &&o):
                _imp(std::move(o)),
                attributes(_imp)
            {}

            //-----------------------------------------------------------------
            nxfield(const typename nxobject_trait<IMPID>::object_type &o):
                _imp(),
                attributes(_imp)
            {
                *this = o;
            }


            //-----------------------------------------------------------------
            ~nxfield() 
            { 
                _imp.clear_selections(); 
            }
            
            //===============assignment operator===============================
            field_type &operator=(const field_type &f)
            {
                if(this == &f) return *this;

                _imp = f._imp;
                return *this;
            }

            //----------------------------------------------------------------
            field_type &operator=(field_type &&f)
            {
                if(this == &f) return *this;
                
                _imp = std::move(f._imp);
                return *this;
            }

            //-----------------------------------------------------------------
            field_type &operator=(const typename nxobject_trait<IMPID>::object_type &o)
            {
                *this = as_field(o);
                return *this;
            }


            //=================dataset inquiry methods=========================
            template<typename CTYPE> CTYPE shape() const 
            {
                return type_type::template from_index_vector<CTYPE>(_imp.shape()); 
            }

            //-----------------------------------------------------------------
            size_t size() const 
            { 
                return _imp.size(); 
            }

            //-----------------------------------------------------------------
            pni::core::type_id_t type_id() const 
            { 
                return _imp.type_id(); 
            }

            //-----------------------------------------------------------------
            typename nxobject_trait<IMPID>::object_type parent() const
            {
                typedef typename nxobject_trait<IMPID>::group_type group_type;
                typedef typename nximp_map<IMPID>::group_imp group_imp_type;

                return group_type(group_imp_type(_imp.parent()));
            }
            
            //-----------------------------------------------------------------
            void grow(const size_t &e,const size_t &n=1) 
            {
                    _imp.grow(e,n);
            }

            //-----------------------------------------------------------------
            size_t rank() const 
            { 
                return _imp.rank(); 
            }

            //=============methods for reading data============================

            template<typename T> void read(T &value) const
            {
                using namespace pni::core;
                
                typedef typename type_type::index_vector_type index_vector_type;
                if(size() != 1)
                    throw size_mismatch_error(EXCEPTION_RECORD,
                                              "Field is not scalar!");

                _imp.read(type_id_map<T>::type_id,index_vector_type{1},&value);
            }
           
            //-----------------------------------------------------------------
            template<typename T> 
            void read(size_t n,T *values) const
            {
                using namespace pni::core;
                typedef typename type_type::index_vector_type index_vector_type;
                if(n!=size())
                    throw size_mismatch_error(EXCEPTION_RECORD,
                            "Field size does not match memory size!");

                _imp.read(type_id_map<T>::type_id,index_vector_type{n},values);
            }
            
            //-----------------------------------------------------------------
            template<typename T>
            void read(std::vector<T> &data) const
            {
                read(data.size(),data.data());
            }


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

            template<
                     typename STORAGE,
                     typename IMAP,
                     typename IPA
                    >
            void read(pni::core::mdarray<STORAGE,IMAP,IPA> &array) const
            {
                _read_array(array);
            }

            //-----------------------------------------------------------------
            template<typename ATYPE>
            void read(pni::core::array_view<ATYPE> &v) const
            {
                if(v.is_contiguous())
                    _read_array(v);
                else
                {
                    typedef typename ATYPE::value_type value_type;
                    typedef dynamic_array<value_type> buffer_type;
                    auto buffer = buffer_type::create(v.template shape<pni::core::shape_t>());
                    _read_array(buffer);
                    std::copy(buffer.begin(),buffer.end(),v.begin());
                }
            }
            
            //-----------------------------------------------------------------
            template<typename ATYPE>
            void read(pni::core::array_view<ATYPE> &&v) const
            {
                read(v);
            }

            //-----------------------------------------------------------------
            void read(array &a) const
            {
                _read_array(a);
            }

           
            //=================methods for writing data========================

            template<typename T> void write(const T &value) const
            {
                using namespace pni::core;
                typedef typename type_type::index_vector_type index_vector_type;
                static_assert(!std::is_pointer<T>::value,"no pointer");
                if(_imp.size()!=1) 
                    throw size_mismatch_error(EXCEPTION_RECORD,
                                              "Field is not scalar!");

                _imp.write(type_id_map<T>::type_id,index_vector_type({1}),&value);
            }

            //-----------------------------------------------------------------
            template<typename T> void write(size_t n,const T *value) const
            {
                using namespace pni::core;
                typedef typename type_type::index_vector_type index_vector_type;

                if(n!=size())
                    throw size_mismatch_error(EXCEPTION_RECORD,
                            "Field size does not match memory size!");

#ifdef __clang__ 
                _imp.write(type_id_map<T>::type_id,index_vector_type{n},
                           static_cast<const void*>(value));
#else
                _imp.write(type_id_map<T>::type_id,index_vector_type{{n}},
                           static_cast<const void*>(value));
#endif
            }
            
            //-----------------------------------------------------------------
            template<typename T>
            void write(const std::vector<T> &data) const
            {
                write(data.size(),data.data());
            }

            //----------------------------------------------------------------
            template<
                     typename STORAGE,
                     typename IMAP,
                     typename IPA
                    >
            void write(const pni::core::mdarray<STORAGE,IMAP,IPA> &a) const
            {
                _write_array(a);
            }

            //-----------------------------------------------------------------
            template<typename ATYPE>
            void write(const pni::core::array_view<ATYPE> &v) const
            {
                if(v.is_contiguous())
                    _write_array(v);
                else
                {
                    typedef typename ATYPE::value_type value_type;
                    typedef dynamic_array<value_type> array_type;
                    auto buffer =  array_type::create(v.template shape<pni::core::shape_t>());
                    std::copy(v.begin(),v.end(),buffer.begin());
                    write(buffer);
                }

            }

           
            //-----------------------------------------------------------------
            void write(const char *value) const
            {
                string s(value);
                write(s);

            }

            //-----------------------------------------------------------------
            void write(const pni::core::array &a) const
            {
                _write_array(a);
            }

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

            template<typename ...ITYPES>
            field_type operator()(ITYPES ...indices) const
            {
                typedef std::vector<pni::core::slice> container_type;
                field_type new_field(*this);

                new_field._imp.apply_selection(container_type({pni::core::slice(indices)...}));

                return new_field;
            }

            //---------------------------------------------------------------
            field_type operator()() 
            {
                _imp.clear_selections();
                return *this;
            }


            //---------------------------------------------------------------
            field_type operator()(const std::vector<pni::core::slice> &selection)  const
            {
                field_type new_field(*this);
                new_field._imp.apply_selection(selection);
                return new_field;
            }

            //---------------------------------------------------------------
            pni::core::string name() const 
            { 
                return _imp.name(); 
            }

            //---------------------------------------------------------------
            pni::core::string filename() const 
            {
                return _imp.filename();
            }

            //---------------------------------------------------------------
            void close() 
            { 
                _imp.close(); 
            }

            //---------------------------------------------------------------
            bool is_valid() const noexcept 
            { 
                return _imp.is_valid(); 
            }

    };


//end of namespace
}
}
}