object_list.h

Go to the documentation of this file.

#pragma once
#include "interop/util/type_traits.h"
#include "interop/util/linear_hierarchy.h"

namespace illumina {
namespace interop {


    template<class T, class Base>
    class object_list_node : public Base
    {
        typedef object_list_node<T,Base> this_t;
    protected:
        typedef typename Base::base_t node_t;
    protected:
        T& get_ref()
        {
            return m_object;
        }
        const T& get_ref()const
        {
            return m_object;
        }
        template<typename UnaryOp>
        static void visit(this_t& node, UnaryOp& op)
        {
            op(node.m_object);
            node_t::visit(node, op);
        }
        template<typename UnaryOp>
        static void visit(this_t& node, const UnaryOp& op)
        {
            op(node.m_object);
            node_t::visit(node, op);
        }
        template<typename UnaryOp>
        static void visit(const this_t& node, UnaryOp& op)
        {
            op(node.m_object);
            node_t::visit(node, op);
        }
        template<typename UnaryOp>
        static void visit(const this_t& node, const UnaryOp& op)
        {
            op(node.m_object);
            node_t::visit(node, op);
        }

    private:
        T m_object;
    };

    struct last_node
    {
        typedef last_node base_t;
        template<typename UnaryOp>
        static void visit(const last_node&, const UnaryOp&){}
    };

    template<class TypeList>
    class object_list : protected hierarchy::linear_hierarchy<TypeList, interop::object_list_node, last_node>
    {
        typedef last_node root_type;
        typedef hierarchy::linear_hierarchy<TypeList, interop::object_list_node, root_type> parent_t;
    public:
        template<class T>
        T& get()
        {
            typedef typename hierarchy::base_at<T, TypeList, interop::object_list_node, root_type>::result_t current_t;
            return current_t::get_ref();
        }
        template<class T>
        const T& get()const
        {
            typedef typename hierarchy::base_at<T, TypeList, interop::object_list_node, root_type>::result_t current_t;
            return current_t::get_ref();
        }
        template<typename UnaryOp>
        void apply(UnaryOp& op)
        {
            parent_t::visit(*this, op);
        }
        template<typename UnaryOp>
        void apply(UnaryOp& op)const
        {
            parent_t::visit(*this, op);
        }
        template<typename UnaryOp>
        void apply(const UnaryOp& op)
        {
            parent_t::visit(*this, op);
        }
        template<typename UnaryOp>
        void apply(const UnaryOp& op)const
        {
            parent_t::visit(*this, op);
        }
    };

}
}