nxattribute.hpp

Go to the documentation of this file.

//
// Declaration of Nexus object 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/>.
// ===========================================================================
//
// Created on: Feb 11, 2012
//     Author: Eugen Wintersberger <eugen.wintersberger@desy.de>
//

#pragma once

#include <pni/core/types.hpp>
#include <pni/core/error.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 "nximp_map.hpp"
#include "nxobject_traits.hpp"
#include "nxobject_type.hpp"
#include "algorithms/as_attribute.hpp"
#include "../exceptions.hpp"


namespace pni{
namespace io{
namespace nx{
 
    template<nximp_code IMPID> 
    class nxattribute
    {
        public:
            typedef typename nximp_map<IMPID>::attribute_imp   implementation_type;
            typedef typename nximp_map<IMPID>::type_imp type_type;
            typedef nxattribute<IMPID>                attribute_type;
        private:
            implementation_type _imp;  
           
            //-----------------------------------------------------------------
            template<typename ATYPE> 
            void _write_array(const ATYPE &a) const
            {
                using namespace pni::core;
                check_allocation_state(a,EXCEPTION_RECORD);
                check_equal_size(a,*this,EXCEPTION_RECORD);

                _imp.write(pni::core::type_id(a),a.data());
            }
            
            //-----------------------------------------------------------------
            template<typename ATYPE> 
            void _read_array(ATYPE &a) const
            {
                using namespace pni::core;
                check_allocation_state(a,EXCEPTION_RECORD);
                check_equal_size(a,*this,EXCEPTION_RECORD);


                _imp.read(pni::core::type_id(a),a.data());
            }

        public:
            //==========constructors and destructors============================
            explicit nxattribute() noexcept:_imp(){}
            
            //------------------------------------------------------------------
            explicit nxattribute(implementation_type &&i):_imp(std::move(i)) 
            { }

            //----------------------------------------------------------------
            nxattribute(const typename nxobject_trait<IMPID>::object_type &o):
                _imp()
            {
                *this = o;
            }
            
            //===================assignment operators===========================
            attribute_type &operator=(const typename
                    nxobject_trait<IMPID>::object_type &o)
            {
                *this = as_attribute(o);
                return *this;
            }

            //====================IO methods====================================
            template<
                     typename STORAGE,
                     typename IMAP,
                     typename IPA
                    >
            void write(const pni::core::mdarray<STORAGE,IMAP,IPA> &o) const
            {
                _write_array(o);
            }

            //----------------------------------------------------------------
            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 pni::core::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);
                }
            }

            //----------------------------------------------------------------
            template<typename T>
            void write(size_t n,const T *data) const
            {
                using namespace pni::core;
                static_assert(!std::is_pointer<T>::value,"no const pointer");
                
                if(n!=size())
                    throw size_mismatch_error(EXCEPTION_RECORD,
                            "Memory and attribute size do not match!");

                _imp.write(type_id_map<T>::type_id,data);
            }

            //----------------------------------------------------------------
            template<typename T>
            void write(const std::vector<T> &data) const
            {
                write(data.size(),data.data());
            }

            //-----------------------------------------------------------------
            template<typename T > 
            void write(const T &value) const
            {
                using namespace pni::core;
                static_assert(!std::is_pointer<T>::value,"no const pointer");

                if(size()!=1)
                    throw size_mismatch_error(EXCEPTION_RECORD,
                            "Field is not scalar!");

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


            //------------------------------------------------------------------
            void write(const char *value) const
            {
                pni::core::string s(value);
                write(s);
            }

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

            //-----------------------------------------------------------------
            template<
                     typename STORAGE,
                     typename IMAP,
                     typename IPA
                    > 
            void read(pni::core::mdarray<STORAGE,IMAP,IPA> &o) const
            {
                _read_array(o);
            }
            
            //-----------------------------------------------------------------
            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 pni::core::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(pni::core::array &a) const
            {
                _read_array(a);
            }
            

            //-----------------------------------------------------------------
            template<typename T> 
            void read(T &value) const
            {
                using namespace pni::core;
                if(size()!=1)
                    throw size_mismatch_error(EXCEPTION_RECORD,
                            "Try to read a scalar from an array field!");

                _imp.read(type_id_map<T>::type_id,&value);
            }

            //---------------------------------------------------------------
            template<typename T>
            void read(size_t n,T *value) const
            {
                using namespace pni::core;
                if(n!=size())
                    throw size_mismatch_error(EXCEPTION_RECORD,
                            "Memory and attribute size do not match!");

                _imp.read(type_id_map<T>::type_id,value);
            }

            //---------------------------------------------------------------
            template<typename T>
            void read(std::vector<T> &data) const
            {
                read(data.size(),data.data());
            }

            //============simple maintenance methods========================
            template<typename CTYPE> 
            CTYPE shape() const
            {
                using namespace pni::core;
                if(!is_valid())
                    throw invalid_object_error(EXCEPTION_RECORD,
                            "Cannot get shape from invalid attribute!");
                return type_type::template from_index_vector<CTYPE>(_imp.shape());
            }

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

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

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

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

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

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

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

            //-----------------------------------------------------------------
            template<typename ...ITYPES>
            attribute_type operator()(ITYPES ...indices) const
            {
                //generate a copy of the attribute
                attribute_type a(*this);

                //generate a selection vector
                typename type_type::selection_vector_type selection{pni::core::slice(indices)...};

                //apply the selection
                a._imp.apply_selection(selection);

                return a;

            }

            //-----------------------------------------------------------------
            attribute_type operator()(const std::vector<pni::core::slice> &indices) const
            {
                //generate a copy of the attribute
                attribute_type a(*this);

                //generate a selection vector
                typename type_type::selection_vector_type selection(indices.size());
                std::copy(indices.begin(),indices.end(),selection.begin());

                //apply the selection
                a._imp.apply_selection(selection);

                return a;
            }

            //-----------------------------------------------------------------
            typename nxobject_trait<IMPID>::object_type parent() const
            {
                using namespace pni::core;
                typedef typename nxobject_trait<IMPID>::group_type group_type;
                typedef typename nxobject_trait<IMPID>::field_type field_type;
                typedef typename nximp_map<IMPID>::group_imp group_imp_type;
                typedef typename nximp_map<IMPID>::field_imp field_imp_type;

                typename nximp_map<IMPID>::object_imp p = _imp.parent();

                if(p.nxobject_type() == nxobject_type::NXFIELD)
                    return field_type(field_imp_type(std::move(p)));
                else if(p.nxobject_type() == nxobject_type::NXGROUP)
                    return group_type(group_imp_type(std::move(p)));
                else
                    throw type_error(EXCEPTION_RECORD,
                             "Cannot convert parent type");

            }

    };

//end of namespace
}
}
}