nxgroup.hpp

Go to the documentation of this file.

//
// (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: Jul 1, 2011
//     Author: Eugen Wintersberger <eugen.wintersberger@desy.de>
//
#pragma once

#include <sstream>
#include <pni/core/types.hpp>
#include <pni/core/utilities.hpp>

#include "nxattribute_manager.hpp"
#include "nximp_map.hpp"
#include "nxobject_traits.hpp"
#include "nxfilter.hpp"
#include "../exceptions.hpp"
#include "nxlink.hpp"
#include "algorithms/as_group.hpp"


namespace pni{
namespace io{
namespace nx{



    template<nximp_code IMPID> class nxgroup
    {
            
        public:
            //===================public types==================================
            using imp_type  = typename nximp_map<IMPID>::group_imp;
            using type_type = typename nximp_map<IMPID>::type_imp;
            using group_type = nxgroup<IMPID>;

            using value_type = typename nxobject_trait<IMPID>::object_type;
            using iterator = pni::core::container_iterator<const group_type>;
            using field_type = typename nxobject_trait<IMPID>::field_type; 
            using attribute_type = typename nxobject_trait<IMPID>::attribute_type;
            using link_type = typename nxobject_trait<IMPID>::link_type;

        private:
            using field_imp_type = typename nximp_map<IMPID>::field_imp;
            using object_imp_type = typename nximp_map<IMPID>::object_imp;
            imp_type _imp;

            //===================private functions============================

            template<
                     typename CTYPE,
                     typename STYPE
                    > 
            CTYPE _create_auto_chunk(const STYPE &shape) const
            {
                auto chunk = pni::core::container_utils<CTYPE>::create(shape.size());

                std::copy(shape.begin(),shape.end(),chunk.begin());
                chunk.front()=1;

                return chunk;
            }

            //----------------------------------------------------------------
            template<
                     typename T,
                     typename CTYPE
                    >
            field_type _create_field(const pni::core::string &n,
                                     const CTYPE &shape,
                                     const CTYPE &chunk) const
            {
                return field_type(field_imp_type(_imp,n,
                                  pni::core::type_id_map<T>::type_id,
                                  type_type::to_index_vector(shape),
                                  type_type::to_index_vector(chunk)));

            }
           
            //----------------------------------------------------------------
            template<
                      typename T,
                      typename CTYPE,
                      typename FIMP
                    > 
            field_type
            _create_field(const pni::core::string &n,const CTYPE &shape,
                         const CTYPE &chunk,
                         const nxfilter<FIMP> &filter) const
            {
                return field_type(field_imp_type(_imp,n,
                                    pni::core::type_id_map<T>::type_id,
                                    type_type::to_index_vector(shape),
                                    type_type::to_index_vector(chunk),
                                    filter.imp()));
            }
        public:
            //==================public attributes==============================
            nxattribute_manager<group_type> attributes;
            //==============constructors and destructor========================
            explicit nxgroup():_imp(),attributes(_imp) { }

            //-----------------------------------------------------------------
            nxgroup(const group_type &o):
                _imp(o._imp),
                attributes(_imp)
            { }
            
            //-----------------------------------------------------------------
            nxgroup(group_type &&o):
                _imp(std::move(o._imp)),
                attributes(_imp)
            { }
           
            //-----------------------------------------------------------------
            explicit nxgroup(imp_type &&imp):
                _imp(std::move(imp)),
                attributes(_imp)
            { }

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

            //========================assignment operators=====================
            group_type &operator=(const group_type &g)
            {
                if(this == &g) return *this;

                _imp = g._imp;
                return *this;
            }

            //-----------------------------------------------------------------
            group_type &operator=(group_type &&g)
            {
                if(this == &g) return *this;

                _imp = std::move(g._imp);

                return *this;
            }

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

            //====================group creation methods=======================
            group_type create_group(const pni::core::string &n,
                                    const pni::core::string &type=pni::core::string()) const
            {
                //we need to do here two things
                //we have to check if the particular group type
                //exists and add a check object to the class

                group_type g = group_type(imp_type(_imp,n));

                //if the type string is not empty we write the 
                //appropriate attribute.
                if(!type.empty())
                    g.attributes.template create<pni::core::string>("NX_class").write(type);

                return g;
            }

            //----------------------------------------------------------------
            template<
                     typename T,
                     typename CTYPE = pni::core::shape_t
                    >
            field_type create_field(const pni::core::string &n,
                                    const CTYPE &shape={1}) const
            {
                using namespace pni::core;
                
                if(!shape.size())
                    throw size_mismatch_error(EXCEPTION_RECORD,
                            "Shape container must not be empty!");

                auto chunk = _create_auto_chunk<shape_t>(shape);
    
                return this->_create_field<T>(n,shape,chunk);
                
            }

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

            template<
                     typename T, 
                     typename CTYPE=pni::core::shape_t
                    > 
            field_type create_field(const pni::core::string &n,
                                    const CTYPE &shape,
                                    const CTYPE &chunk) const
            {
                return _create_field<T>(n,shape,chunk);
            }

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

            template<
                     typename T,
                     typename CTYPES,
                     typename FIMP
                    > 
            field_type create_field(const pni::core::string &n,
                                    const CTYPES &shape,
                                    const nxfilter<FIMP> &filter) const
            {
                using namespace pni::core;
                
                if(!shape.size())
                    throw size_mismatch_error(EXCEPTION_RECORD,
                            "Shape must not be empty!");

                auto chunk = _create_auto_chunk<shape_t>(shape);

                return _create_field<T>(n,shape,chunk,filter);

            }

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

            template<typename T,
                     typename CTYPES,
                     typename CTYPEC,
                     typename FIMP
                    > 
            field_type create_field(const pni::core::string &n,
                                    const CTYPES &s,
                                    const CTYPEC &cs,
                                    const nxfilter<FIMP> &filter) const
            {
                return _create_field<T>(n,s,cs,filter);
            }


            //===============methods to open objects===========================
            typename nxobject_trait<IMPID>::object_type 
            at(const pni::core::string &n) const
            {
                using namespace pni::core;
                
                if(find(n.begin(),n.end(),'/')!=n.end())
                    throw value_error(EXCEPTION_RECORD,
                            "Invalid character in object name!");

                //need to check the status of the link for the requested 
                //object - if the link is invalid we return a link
                //object.
                if(link_status(*this,n)==nxlink_status::INVALID)
                    return link_type(*this,n);


                object_imp_type object =  _imp.at(n);

                if(object.nxobject_type() == nxobject_type::NXFIELD)
                    return field_type(field_imp_type(std::move(object)));
                else if(object.nxobject_type() == nxobject_type::NXGROUP)
                    return group_type(imp_type(std::move(object)));
                else
                    throw type_error(EXCEPTION_RECORD,
                                     "Unknown Nexus object type!");

            }

            //-----------------------------------------------------------------
            typename nxobject_trait<IMPID>::object_type 
            operator[](const pni::core::string &n) const
            {
                return at(n);
            }

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

            //-----------------------------------------------------------------
            typename nxobject_trait<IMPID>::object_type parent() const
            {
                group_type g(imp_type(_imp.parent()));
                return g;
            }

            //-----------------------------------------------------------------
            typename nxobject_trait<IMPID>::object_type 
            at(size_t i) const
            {
                return this->at(link_name(*this,i));
            }

            //-----------------------------------------------------------------
            typename nxobject_trait<IMPID>::object_type 
            operator[](size_t i) const
            {
                return this->at(i);
            }

            //-----------------------------------------------------------------
            bool has_child(const pni::core::string &n) const
            { 
                if(n.find('/')==pni::core::string::npos)
                    return _imp.has_child(n); 
                else
                    return false;
            }

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

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

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

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

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

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

            //---------------------------------------------------------------
            const imp_type &imp() const noexcept{ return _imp; }


    };

    //=============comparison operators====================================
    template<nximp_code IMPID>
    bool operator==(const nxgroup<IMPID> &a,const nxgroup<IMPID> &b)
    {
        if(a.imp().object() == b.imp().object()) return true;
        return false;
    }

    //-----------------------------------------------------------------------
    template<nximp_code IMPID>
    bool operator!=(const nxgroup<IMPID> &a,const nxgroup<IMPID> &b)
    {
        if(a == b) return false;
        return true;
    }


//end of namespace
}
}
}