nxattribute_manager.hpp

Go to the documentation of this file.

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

#include <pni/core/utilities.hpp>
#include "nxattribute.hpp"
#include "../exceptions.hpp"

namespace pni{
namespace io{
namespace nx{    

    template<typename OTYPE>
    class nxattribute_manager
    {
        public:
            typedef nxattribute_manager<OTYPE> manager_type;
            typedef typename OTYPE::attribute_type attribute_type;
            typedef attribute_type value_type;
            typedef pni::core::container_iterator<const manager_type> iterator;
            typedef typename OTYPE::imp_type imp_type;
        private:
            typedef typename OTYPE::type_type type_imp;
            imp_type &_imp;
        public:
            nxattribute_manager(imp_type &imp):_imp(imp) {}

            //----------------------------------------------------------------
            template<
                     typename T,
                     typename CTYPE
                    > 
            attribute_type create(const pni::core::string &n, 
                                        const CTYPE &s,bool ov=false) const
            {
                pni::core::type_id_t tid = pni::core::type_id_map<T>::type_id;

                return attribute_type(_imp.attr(n,
                                                tid,
                                                type_imp::to_index_vector(s),
                                                ov));
            }
            
            //-----------------------------------------------------------------
            template<typename T> 
            attribute_type create(const pni::core::string &n,
                                  bool ov=false) const
            {
                return create<T>(n,pni::core::shape_t{1},ov);
            }

            //-----------------------------------------------------------------
            attribute_type operator[](const pni::core::string &n) const
            {
                return attribute_type(_imp.attr(n));
            }

            //-----------------------------------------------------------------
            attribute_type operator[](size_t i) const
            {
                return attribute_type(_imp.attr(i));
            }

            //-----------------------------------------------------------------
            void remove(const pni::core::string &n) const
            {
                _imp.del_attr(n);
            }

            //-----------------------------------------------------------------
            bool exists(const pni::core::string &n) const
            {
                return _imp.has_attr(n);
            }

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

            //-----------------------------------------------------------------
            iterator begin() const { return iterator(this); }

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


//end of namespace
}
}
}