flat_group.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: Sep 10, 2014
//     Author: Eugen Wintersberger <eugen.wintersberger@desy.de>
//
#pragma once

#include <vector>
#include "algorithms/is_valid.hpp"
#include "algorithms/is_group.hpp"
#include "algorithms/as_group.hpp"
#include "nxobject_traits.hpp"

namespace pni{
namespace io{
namespace nx{



    template<typename GTYPE> class flat_group
    {
        public:
            typedef  GTYPE group_type;
            typedef typename nxobject_trait<nximp_code_map<group_type>::icode>::object_type value_type;
            typedef std::vector<value_type> container_type;
            typedef typename container_type::iterator iterator;
            typedef typename container_type::const_iterator const_iterator;
        private:
            container_type _container;

            void append_children(const group_type &parent)
            {
                for(auto c: parent) //will throw invalid_object_error or 
                                    //object_error
                {
                    //add the child to the container
                    _container.push_back(c);

                    //if the child is a group recusively call append_children
                    if(is_group(c)) append_children(as_group(c));
                }
            }
        public:
            //====================public types==================================
            explicit flat_group(const group_type &parent):
                _container()
            { 
                if(!is_valid(parent))
                    throw invalid_object_error(EXCEPTION_RECORD,
                    "Cannot create an flat group from an invalid object!");
                append_children(parent); 
            }

            //------------------------------------------------------------------
            value_type operator[](size_t index) const noexcept
            {
                return _container[index];
            }

            //------------------------------------------------------------------
            value_type &operator[](size_t index) noexcept
            {
                return _container[index];
            }

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

            //------------------------------------------------------------------
            iterator begin() noexcept
            {
                return _container.begin();
            }

            //------------------------------------------------------------------
            iterator end() noexcept
            {
                return _container.end();
            }

            //------------------------------------------------------------------
            const_iterator begin() const noexcept
            {
                return _container.begin();
            }

            //------------------------------------------------------------------
            const_iterator end() const noexcept
            {
                return _container.end();
            }
    };

    //-------------------------------------------------------------------------
    template<
             template<nximp_code> class GTYPE,
             nximp_code IMPID
            >
    flat_group<GTYPE<IMPID>> make_flat(const GTYPE<IMPID> &group)
    {
        return flat_group<GTYPE<IMPID>>(group);
    }

    //-------------------------------------------------------------------------
    template<
             typename GTYPE,
             typename FTYPE,
             typename ATYPE,
             typename LTYPE
            >

    flat_group<GTYPE> make_flat(const nxobject<GTYPE,FTYPE,ATYPE,LTYPE> &object)
    {
        return flat_group<GTYPE>(as_group(object));
    }


//end of namespace
}
}
}