object_creator.hpp

#ifndef VECTOR_CREATOR
#define VECTOR_CREATOR
 
#include <boost/fusion/container/vector.hpp>
#include <boost/mpl/vector.hpp>
#include <boost/mpl/push_back.hpp>
#include <boost/type_traits/remove_reference.hpp>
#include <boost/mpl/range_c.hpp>
#include <type_traits>
#include "util_debug.hpp"
#include "check_no_pointers.hpp"
#include "util/for_each_ref.hpp"
#include <iostream>
 
template<typename v>
struct check_types
{
    size_t & ret;
 
    check_types(size_t & ret)
    :ret(ret)
    {
        ret = PNP::NO_POINTERS;
    }
 
    template<typename T>
    void operator()(T& t)
    {
        typedef typename std::remove_all_extents< typename boost::mpl::at<v,boost::mpl::int_<T::value> >::type>::type tpy;
 
        // if it is a pointer make no sense
        if (std::is_pointer<tpy>::value == true)
        {ret = PNP::POINTERS;return;}
 
        // if it is an l-value reference make no send
        if (std::is_lvalue_reference<tpy>::value == true)
        {ret = PNP::POINTERS;return;}
 
        // if it is an r-value reference make no send
        if (std::is_rvalue_reference<tpy>::value == true)
        {ret = PNP::POINTERS;return;}
 
        if (std::is_fundamental<tpy>::value == true)
        {return;}
 
        // check that T has a method called noPointers
        switch (check_no_pointers<tpy>::value())
        {
            case PNP::UNKNOWN:
            {
#ifndef DISABLE_ALL_RTTI
                std::cerr << "Warning: " << __FILE__ << ":" << __LINE__ << " impossible to check the type " << demangle(typeid(tpy).name()) << " please consider to add a static method \"static bool noPointers()\" \n" ;
#endif
                ret = PNP::UNKNOWN;
                break;
            }
            case PNP::POINTERS:
            {
                ret = PNP::POINTERS;
                break;
            }
            default:
            {
 
            }
        }
    }
};
 
template<typename v,typename p_ele,bool to_push>
struct conditional_push
{
    typedef typename boost::mpl::push_front<v,p_ele>::type type;
};
 
template<typename v,typename p_ele>
struct conditional_push<v,p_ele,false>
{
    typedef v type;
};
 
template<typename v, int p1, int... prp>
struct noPointers_sequence_impl
{
    // Object we are analyzing
    typedef typename std::remove_reference<typename std::remove_pointer<typename boost::mpl::at< v,boost::mpl::int_<p1> >::type>::type>::type obj_type;
 
    // analyze the other properties, returning the output vector
    typedef typename noPointers_sequence_impl<v ,prp...>::type v_step;
 
    // push on the vector the element p1
    typedef typename conditional_push<v_step, boost::mpl::int_<p1>, !has_noPointers<obj_type>::value && !std::is_fundamental<obj_type>::value >::type type;
};
 
template<typename v, int p1>
struct noPointers_sequence_impl<v,p1>
{
    // Object we are analyzing
    typedef typename std::remove_reference< typename std::remove_pointer<typename boost::mpl::at< v,boost::mpl::int_<p1> >::type>::type>::type obj_type;
 
    // push on the vector the element p1
    typedef typename conditional_push<boost::mpl::vector<>, boost::mpl::int_<p1>, !has_noPointers<obj_type>::value && !std::is_fundamental<obj_type>::value >::type type;
};
 
template<typename v, int... prp>
struct noPointers_sequence
{
    typedef typename noPointers_sequence_impl<v,prp...>::type type;
};
 
 
template<typename v>
struct object
{
    typedef v type;
    typedef typename boost::fusion::result_of::size<v>::type size_tpy;
 
    type data;
 
    static bool noPointers()
    {
        size_t ret;
        check_types<v> ct(ret);
 
        boost::mpl::for_each_ref< boost::mpl::range_c<int,0, boost::fusion::result_of::size<v>::type::value > > (ct);
 
        return ret;
    }
 
    static const int max_prop = size_tpy::value;
};
 
template<typename v, typename vc, int... prp>
struct object_creator_impl
{
};
 
template<typename v, typename vc, int p1, int... prp>
struct object_creator_impl<v,vc,p1,prp...>
{
    typedef typename object_creator_impl<v,vc,prp... >::type vc_step;
 
    typedef typename boost::remove_reference< typename boost::mpl::at< v,boost::mpl::int_<p1> >::type>::type ele;
 
    // push on the vector the element p1
    typedef typename boost::mpl::push_front<vc_step, ele >::type type;
};
 
template<typename v, typename vc, int prp>
struct object_creator_impl<v,vc,prp>
{
    typedef typename boost::remove_reference< typename boost::mpl::at< v,boost::mpl::int_<prp> >::type>::type ele;
 
    // push on the vector the element p1
    typedef typename boost::mpl::push_front<vc, ele >::type type;
};
 
template<typename v, int... prp>
struct object_creator
{
    typedef typename boost::fusion::result_of::as_vector<typename object_creator_impl<v,boost::mpl::vector<>,prp... >::type>::type type;
};
 
template<typename v>
struct object_creator<v>
{
    typedef v type;
};
 
 
template<typename v, typename vc, int... prp>
struct object_creator_chunking_impl
{
};
 
template<typename v, typename vc, int p1, int... prp>
struct object_creator_chunking_impl<v,vc,p1,prp...>
{
    typedef typename object_creator_chunking_impl<v,vc,prp... >::type vc_step;
 
    typedef typename boost::remove_reference< typename boost::mpl::at< v,boost::mpl::int_<p1> >::type>::type ele_array;
 
    // Element without array
    typedef typename ele_array::value_type ele;
 
    // push on the vector the element p1
    typedef typename boost::mpl::push_front<vc_step, ele >::type type;
};
 
template <typename T>
struct object_creator_chunking_encapsulator
{
    typedef T type;
};
 
template <typename type>
struct get_base_type_for_object_creator_chunking
{
    typedef object_creator_chunking_encapsulator<typename type::value_type> ele;
};
 
 
template <unsigned int N1, std::size_t N2, typename T>
struct get_base_type_for_object_creator_chunking< std::array<T, N2>[N1] >
{
    typedef object_creator_chunking_encapsulator<T[N1]> ele;
};
 
 
template<typename v, typename vc, int prp>
struct object_creator_chunking_impl<v,vc,prp>
{
    typedef typename boost::remove_reference< typename boost::mpl::at< v,boost::mpl::int_<prp> >::type>::type ele_array;
 
    // Element without array
    typedef typename get_base_type_for_object_creator_chunking<ele_array>::ele ele;
 
    // push on the vector the element p1
    typedef typename boost::mpl::push_front<vc, typename ele::type >::type type;
};
 
 
template<typename v, int... prp>
struct object_creator_chunking
{
    typedef typename boost::fusion::result_of::as_vector<typename object_creator_chunking_impl<v,boost::mpl::vector<>,prp... >::type>::type type;
};
 
 
template<typename v>
struct object_creator_chunking<v>
{
    typedef v type;
};
 
#endif