/home/chris/Projects/eval/create_execution_context_definition.hpp

Go to the documentation of this file.

// Copyright (C) 2008 Christian Hoermann (0oo0oo0.c@gmail.com)
//
// Distributed under the Boost Software License, Version 1.0. (See
// accompanying file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)


#include <utility>
#include <set>
#include <string>
#include <cctype>
#include <typeinfo>

#include <boost/type_traits/is_same.hpp>
#include <boost/type_traits/is_polymorphic.hpp>
#include <boost/type_traits/is_base_of.hpp>
#include <boost/type_traits/is_convertible.hpp>
#include <boost/static_assert.hpp>

#include "execution_context.hpp"




class EVAL_EXECUTION_CONTEXT_NAME : public eval::execution_context
{
public:
    EVAL_EXECUTION_CONTEXT_NAME()
      : eval::execution_context()
    {
    }

  
    virtual ~EVAL_EXECUTION_CONTEXT_NAME()
    {
    }

protected:

    virtual void register_functions();

    virtual void register_methods_and_ctors();

    virtual void register_types();

    virtual void register_conversions();

private:

    EVAL_EXECUTION_CONTEXT_NAME(const EVAL_EXECUTION_CONTEXT_NAME& e);
    EVAL_EXECUTION_CONTEXT_NAME& operator=(const EVAL_EXECUTION_CONTEXT_NAME& rhs);
};



#define EVAL_NOTHING /* expand to nothing */
#define EVAL_BRACKET_OPEN (
#define EVAL_BRACKET_CLOSE )



// This file defines the primary macros. All macros are initially set empty.
// The idea is that we change the macros' definitions throughout this file
// and include the .epp files in these different contexts.
#include "detail/reset_execution_context_macros.hpp"

// The macros below can all be completely written in terms of the primary macros
// and hence need only be defined once.

#ifndef EVAL_EXECUTION_CONTEXT_DEFINITION_H
#define EVAL_EXECUTION_CONTEXT_DEFINITION_H

#   define EVAL_REGISTER_TYPE(T) \
            EVAL_REGISTER_TYPE_RENAME(T, T)

#   define EVAL_REGISTER_FUNCTION(f) \
            EVAL_REGISTER_FUNCTION_RENAME(f, f)

#   define EVAL_REGISTER_FUNCTION_RENAME(f, name) \
            EVAL_REGISTER_FUNCTION_IMPL(EVAL_NOTHING, f, EVAL_NOTHING, name)

#   define EVAL_REGISTER_FUNCTION_OVERLOADED(RvT, ArgT, f) \
            EVAL_REGISTER_FUNCTION_OVERLOADED_RENAME(RvT, ArgT, f, f)

#   define EVAL_REGISTER_FUNCTION_OVERLOADED_RENAME(RvT, ArgT, f, name) \
            EVAL_REGISTER_FUNCTION_IMPL(static_cast<RvT (*) ArgT > EVAL_BRACKET_OPEN,       \
                                        f, EVAL_BRACKET_CLOSE, name)

#   define EVAL_REGISTER_METHOD(m) \
            EVAL_REGISTER_METHOD_RENAME(m, m)

#   define EVAL_REGISTER_METHOD_OVERLOADED(RvT, ArgT, m) \
            EVAL_REGISTER_METHOD_OVERLOADED_RENAME(RvT, ArgT, m, m)

#   define EVAL_REGISTER_STATIC_METHOD(m) \
            EVAL_REGISTER_STATIC_METHOD_RENAME(m, m)

#   define EVAL_REGISTER_STATIC_METHOD_RENAME(m, name) \
            EVAL_REGISTER_STATIC_METHOD_IMPL(EVAL_NOTHING, m, EVAL_NOTHING, name)

#   define EVAL_REGISTER_STATIC_METHOD_OVERLOADED(RvT, ArgT, m) \
            EVAL_REGISTER_STATIC_METHOD_OVERLOADED_RENAME(RvT, ArgT, m, m)

#   define EVAL_REGISTER_STATIC_METHOD_OVERLOADED_RENAME(RvT, ArgT, m, name) \
            EVAL_REGISTER_STATIC_METHOD_IMPL(static_cast<RvT (*) ArgT > EVAL_BRACKET_OPEN,  \
                                             m, EVAL_BRACKET_CLOSE, name)



namespace eval
{
    namespace detail
    {
        std::string remove_spaces(const char *str)
        {
            std::string rv;
            for( ; *str; str++)
            {
                if(!std::isspace(*str))
                {
                    rv += *str;
                }
            }
            return rv;
        }
    }
}



#endif // include guard

void inline EVAL_EXECUTION_CONTEXT_NAME::register_functions()
{
#undef EVAL_REGISTER_FUNCTION_IMPL
#define EVAL_REGISTER_FUNCTION_IMPL(begin_cast, f, end_cast, name) \
    _functions.insert(std::pair<std::string, eval::fwrap>(eval::detail::remove_spaces(#name),  \
                                                eval::fwrap( begin_cast &f end_cast )));

#   include "detail/include_eval_include_files.hpp"

#   include "detail/reset_execution_context_macros.hpp"

}




namespace eval
{
    namespace detail
    {
        namespace EVAL_EXECUTION_CONTEXT_NAME
        {
            template<typename BaseT, typename SuperT>
            class methods_and_ctors_for_type
            {
                BOOST_STATIC_ASSERT(sizeof(BaseT) == 0);
            };

#undef EVAL_REGISTER_TYPE_RENAME                     
#define EVAL_REGISTER_TYPE_RENAME(T, name) \
            template<typename SuperT>                                                       \
            class methods_and_ctors_for_type<T, SuperT>                                     \
            {                                                                               \
            public:                                                                         \
                typedef T BaseT;                                                            \
                                                                                            \
                /* static methods go into both methods and static_store2 */                 \
                static void add_to(std::string type_name, object_method_store *methods,     \
                                   std::multimap<std::string, fwrap> *ctor_store,           \
                                   std::multimap<std::string, fwrap> *static_store2)        \
                {                                                                           \
                    std::set<std::string> methods_added;                                    \
                    std::pair<std::set<std::string>::iterator, bool> set_rv;

            
                    // constructors not inherited
#undef EVAL_INHERIT_FROM
#define EVAL_INHERIT_FROM(T) \
                    methods_and_ctors_for_type<T, SuperT>::add_to(type_name, methods, 0,    \
                                                                  static_store2);

#undef EVAL_REGISTER_CONSTRUCTOR
#define EVAL_REGISTER_CONSTRUCTOR(ArgT) \
                    if(ctor_store)                                                          \
                    {                                                                       \
                        ctor_store->insert(std::pair<std::string, eval::fwrap>(             \
                                           type_name,                                       \
                                           eval::fwrap::wrap_ctor<BaseT, void (*) ArgT>()));\
                    }

#undef EVAL_REGISTER_CONSTRUCTOR_RENAME
#define EVAL_REGISTER_CONSTRUCTOR_RENAME(ArgT, name) \
                    if(ctor_store)                                                          \
                    {                                                                       \
                        ctor_store->insert(std::pair<std::string, eval::fwrap>(             \
                                           eval::detail::remove_spaces(#name),              \
                                           eval::fwrap::wrap_ctor<BaseT, void (*) ArgT>()));\
                    }

#undef EVAL_REGISTER_METHOD_RENAME
#define EVAL_REGISTER_METHOD_RENAME(m, name) \
                    set_rv = methods_added.insert(eval::detail::remove_spaces(#name));      \
                    if(set_rv.second == true)                                               \
                    {                                                                       \
                        /* New element was added to the set, hence we need to remove */     \
                        /* all methods with this name (i.e. this class may have      */     \
                        /* specialized an inherited method)                          */     \
                        methods->delete_methods(eval::detail::remove_spaces(#name));        \
                    }                                                                       \
                    methods->add_method(eval::detail::remove_spaces(#name),                 \
                                        fwrap(&SuperT::m));

#undef EVAL_REGISTER_METHOD_OVERLOADED_RENAME
#define EVAL_REGISTER_METHOD_OVERLOADED_RENAME(RvT, ArgT, m, name) \
                    set_rv = methods_added.insert(eval::detail::remove_spaces(#name));      \
                    if(set_rv.second == true)                                               \
                    {                                                                       \
                        /* New element was added to the set, hence we need to remove */     \
                        /* all methods with this name (i.e. this class may have      */     \
                        /* specialized an inherited method)                          */     \
                        methods->delete_methods(eval::detail::remove_spaces(#name));        \
                    }                                                                       \
                    methods->add_method(eval::detail::remove_spaces(#name),                 \
                                    fwrap(static_cast<RvT (SuperT::*) ArgT>(&SuperT::m)));


#undef EVAL_REGISTER_STATIC_METHOD_IMPL
#define EVAL_REGISTER_STATIC_METHOD_IMPL(begin_cast, m, end_cast, name) \
                    set_rv = methods_added.insert(eval::detail::remove_spaces(#name));      \
                    if(set_rv.second == true)                                               \
                    {                                                                       \
                        /* New element was added to the set, hence we need to remove */     \
                        /* all methods with this name (i.e. this class may have      */     \
                        /* specialized an inherited method)                          */     \
                        methods->delete_methods(eval::detail::remove_spaces(#name));        \
                        std::pair<std::multimap<std::string, eval::fwrap>::iterator,        \
                                  std::multimap<std::string, eval::fwrap>::iterator         \
                                 > static_remove_range;                                     \
                        static_remove_range = static_store2->equal_range(type_name + "::"   \
                                                    + eval::detail::remove_spaces(#name));  \
                        static_store2->erase(static_remove_range.first,                     \
                                             static_remove_range.second);                   \
                    }                                                                       \
                    methods->add_static_method(eval::detail::remove_spaces(#name),          \
                                               fwrap(begin_cast &SuperT::m end_cast));      \
                    static_store2->insert(std::pair<std::string, eval::fwrap>(              \
                                     type_name + "::" + eval::detail::remove_spaces(#name), \
                                     fwrap(begin_cast &SuperT::m end_cast)));


#undef EVAL_END_TYPE
#define EVAL_END_TYPE \
                }                                                                           \
            };

#           include "detail/include_eval_include_files.hpp"

#           include "detail/reset_execution_context_macros.hpp"


        }
    }
}


void inline EVAL_EXECUTION_CONTEXT_NAME::register_methods_and_ctors()
{
#undef EVAL_REGISTER_TYPE_RENAME
#define EVAL_REGISTER_TYPE_RENAME(T, name) \
    {                                                                                       \
        eval::detail::object_method_store *m;                                               \
        m = new eval::detail::object_method_store(eval::detail::remove_spaces(#name));      \
        _objects.insert(std::pair<const std::type_info *,                                   \
                                    eval::detail::object_method_store *>(&typeid(T), m));   \
        eval::detail::EVAL_EXECUTION_CONTEXT_NAME::methods_and_ctors_for_type<T, T>         \
                                    ::add_to(eval::detail::remove_spaces(#name), m,         \
                                             &_functions, &_functions);                     \
    }

#   include "detail/include_eval_include_files.hpp"

#   include "detail/reset_execution_context_macros.hpp"
}


void inline EVAL_EXECUTION_CONTEXT_NAME::register_types()
{
#undef EVAL_REGISTER_TYPE_RENAME
#define EVAL_REGISTER_TYPE_RENAME(T, name) \
    _types.insert(std::pair<std::string, const std::type_info *>(                           \
                                        eval::detail::remove_spaces(#name), &typeid(T)));

#   include "detail/include_eval_include_files.hpp"

#   include "detail/reset_execution_context_macros.hpp"
}


namespace eval
{
    namespace detail
    {
        namespace EVAL_EXECUTION_CONTEXT_NAME
        {
            template<typename CurrentT, typename DesiredT>
            inline val ptr_convert(val& v)
            {
                // The intention is that a ptr conversion will always result in a val which
                // internally references (points to) memory belonging to the original val.
                if(v.is_const())
                {
                    const CurrentT *curr = val_cast_ptr<const CurrentT>(v);
                    const DesiredT *converted = curr;
                    return val(converted, UNMANAGED_PTR);
                }
                else
                {
                    CurrentT *curr = val_cast_ptr<CurrentT>(v);
                    DesiredT *converted = curr;
                    return val(converted, UNMANAGED_PTR);
                }
            }

            template<typename CurrentT, typename DesiredT>
            inline val dynamic_ptr_convert(val& v)
            {
                if(v.is_const())
                {
                    const CurrentT *curr = val_cast_ptr<const CurrentT>(v);
                    return val(dynamic_cast<const DesiredT *>(curr), UNMANAGED_PTR);
                }
                else
                {
                    CurrentT *curr = val_cast_ptr<CurrentT>(v);
                    return val(dynamic_cast<DesiredT *>(curr), UNMANAGED_PTR);
                }
            }

            template<typename CurrentT, typename DesiredT>
            inline val value_convert(val& v)
            {
                BOOST_STATIC_ASSERT((boost::is_convertible<CurrentT, DesiredT>::value));

                const CurrentT& curr = *val_cast_ptr<const CurrentT>(v);
                // The next line is perhaps sub-optimal, since it would work even with
                // an explicit constructor. That's why the pre-requirement for this
                // function is that is_convertible<CurrentT, DesiredT> is true,
                // which should respect explicitness of constructors.
                // Also note that the conversion may require an implicit call to a conversion
                // function, followed by a copy construction, if direct construction is
                // not possible.
                DesiredT *new_ptr = new DesiredT(curr);
                return val(new_ptr, TRANSFER_OWNERSHIP);
            }

            template<typename CurrentT, typename DesiredT>
            inline val ptr_value_convert(val& v)
            {
                const CurrentT *curr = val_cast_ptr<const CurrentT>(v);
                DesiredT *new_ptr = new DesiredT(curr);
                return val(new_ptr, TRANSFER_OWNERSHIP);
            }

                
            template<typename CurrentT, typename DesiredT>
            inline execution_context::val_convert_t get_ptr_convert_fn(const boost::true_type&)
            {   
                return &ptr_convert<CurrentT, DesiredT>;
            }

            template<typename CurrentT, typename DesiredT>
            inline execution_context::val_convert_t get_ptr_convert_fn(const boost::false_type&)
            {   
                return 0;
            }

            template<typename CurrentT, typename DesiredT>
            inline execution_context::val_convert_t
            get_dynamic_ptr_convert_fn(const boost::true_type&)
            {   
                return &dynamic_ptr_convert<CurrentT, DesiredT>;
            }

            template<typename CurrentT, typename DesiredT>
            inline execution_context::val_convert_t
            get_dynamic_ptr_convert_fn(const boost::false_type&)
            {   
                return 0;
            }

            template<typename CurrentT, typename DesiredT>
            inline execution_context::val_convert_t
            get_value_convert_fn(const boost::true_type&)
            {   
                return &value_convert<CurrentT, DesiredT>;
            }

            template<typename CurrentT, typename DesiredT>
            inline execution_context::val_convert_t
            get_value_convert_fn(const boost::false_type&)
            {   
                return 0;
            }

            template<typename CurrentT, typename DesiredT>
            inline execution_context::val_convert_t
            get_ptr_value_convert_fn(const boost::true_type&)
            {   
                return &ptr_value_convert<CurrentT, DesiredT>;
            }

            template<typename CurrentT, typename DesiredT>
            inline execution_context::val_convert_t
            get_ptr_value_convert_fn(const boost::false_type&)
            {   
                return 0;
            }

            // We return 0 if CurrentT and DesiredT are the same type, despite the fact
            // that they are obviously trivially convertible. The reason is that
            // is_convertible<A, B> will fail to compile if B has a private converting constructor.
            // Unfortunately, this may still cause problems in some cases, but at least the
            // (arguably) most common case (a private copy constructor) should not cause errors.
            template<typename CurrentT, typename DesiredT>
            inline execution_context::val_convert_t
            get_value_convert_fn_if_not_same(const boost::true_type&)
            {   
                return 0;
            }

            template<typename CurrentT, typename DesiredT>
            inline execution_context::val_convert_t
            get_value_convert_fn_if_not_same(const boost::false_type&)
            {
                execution_context::val_convert_t rv;
                rv = get_value_convert_fn<CurrentT, DesiredT>(
                                                      boost::is_convertible<const CurrentT&,
                                                                            DesiredT>());
                if(!rv)
                {
                    rv = get_ptr_value_convert_fn<CurrentT, DesiredT>(
                                              boost::is_convertible<const CurrentT *, DesiredT>());
                }
                return rv;
            }

    
            template<typename DesiredT>
            inline void add_val_convert_for_type(
                std::map<type_info_conversion_store, execution_context::val_convert_t>& ptr_conv,
                std::map<type_info_conversion_store, execution_context::val_convert_t>& value_conv)
            {
                execution_context::val_convert_t conv_p;

#undef EVAL_REGISTER_TYPE_RENAME
#define EVAL_REGISTER_TYPE_RENAME(T, name) \
                conv_p = get_ptr_convert_fn<T, DesiredT>(                                   \
                                                boost::is_convertible<T *, DesiredT *>());  \
                if(!conv_p)                                                                 \
                {                                                                           \
                    conv_p = get_dynamic_ptr_convert_fn<T, DesiredT>(                       \
                                boost::integral_constant                                    \
                                            <bool, boost::is_base_of<T, DesiredT>::value    \
                                                   && boost::is_polymorphic<T>::value       \
                                            >());                                           \
                }                                                                           \
                                                                                            \
                if(conv_p)                                                                  \
                {                                                                           \
                    ptr_conv.insert(std::make_pair(                                         \
                                 type_info_conversion_store(&typeid(T), &typeid(DesiredT)), \
                                 conv_p));                                                  \
                }                                                                           \
                                                                                            \
                conv_p = get_value_convert_fn_if_not_same<T, DesiredT>(                     \
                                                           boost::is_same<T, DesiredT>());  \
                if(conv_p)                                                                  \
                {                                                                           \
                    value_conv.insert(std::make_pair(                                       \
                                 type_info_conversion_store(&typeid(T), &typeid(DesiredT)), \
                                 conv_p));                                                  \
                }


#               include "detail/include_eval_include_files.hpp"

#               include "detail/reset_execution_context_macros.hpp"
            }


        }
    }
}

void inline EVAL_EXECUTION_CONTEXT_NAME::register_conversions()
{
#undef EVAL_REGISTER_TYPE_RENAME
#define EVAL_REGISTER_TYPE_RENAME(T, name) \
    eval::detail::EVAL_EXECUTION_CONTEXT_NAME::add_val_convert_for_type<T>                  \
                                                   (_ptr_conversions, _value_conversions);

#   include "detail/include_eval_include_files.hpp"

#   include "detail/reset_execution_context_macros.hpp"

}


#undef EVAL_NOTHING
#undef EVAL_BRACKET_OPEN
#undef EVAL_BRACKET_CLOSE

---