/home/chris/Projects/eval/fwrap.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)



#ifndef BOOST_PP_IS_ITERATING

#   ifndef EVAL_FWRAP_H
#       define EVAL_FWRAP_H


#       include <vector>
#       include <stdexcept>
#       include <typeinfo>

#       include <boost/static_assert.hpp>
#       include <boost/type_traits/is_reference.hpp>
#       include <boost/type_traits/is_pointer.hpp>
#       include <boost/type_traits/is_const.hpp>
#       include <boost/type_traits/is_integral.hpp>
#       include <boost/type_traits/is_floating_point.hpp>
#       include <boost/preprocessor/repetition.hpp>
#       include <boost/preprocessor/punctuation/comma_if.hpp>
#       include <boost/preprocessor/iteration/iterate.hpp>

#       include "val.hpp"

#       ifndef EVAL_FWRAP_MAX_NUM_OF_ARGS
#           define EVAL_FWRAP_MAX_NUM_OF_ARGS 10 
#       endif


namespace eval
{
    typedef std::vector<val> fwrap_args;

    class null_ptr_exception : public std::logic_error
    {
    public:
        explicit null_ptr_exception(const std::string& err)
          : std::logic_error("eval::null_ptr_exception: " + err)
        {
        }
    };

    class arity_mismatch_exception : public std::logic_error
    {
    public:
        arity_mismatch_exception(int num_args_required, int num_args_supplied)
          : std::logic_error(std::string("eval::arity_mismatch_exception: Expected ")
                             + detail::stringify(&num_args_required) + " arguments (got "
                             + detail::stringify(&num_args_supplied) + ")")
        {
        }
    };

    enum fwrap_fn_type {
        FWRAP_CONST_METHOD = 1,
        FWRAP_METHOD,
        FWRAP_CONSTRUCTOR,
        FWRAP_FUNCTION
       
    };


    class arg_info
    {
    public:
        arg_info(const std::type_info *type, bool is_const, bool is_pointer, bool is_reference)
          : _type(type), _is_const(is_const), _is_pointer(is_pointer), _is_reference(is_reference)
        {
        }

   
        const std::type_info& type() const
        {
            return *_type;
        }

        bool is_const() const
        {
            return _is_const;
        }

        bool is_pointer() const
        {
            return _is_pointer;
        }

        bool is_reference() const
        {
            return _is_reference;
        }

        bool is_void() const
        {
            return *_type == typeid(void) && !is_pointer();
        }
    private:
        const std::type_info *_type;
        bool _is_const;
        bool _is_pointer;
        bool _is_reference;
    };


    namespace detail
    {
        template<typename T>
        class val_cast_ptr_or_ref
        {
        public:
            static T cast(val& v)
            {
                return *val_cast_ptr<const T>(v);
            }
        };

        template<typename T>
        class val_cast_ptr_or_ref<T *>
        {
        public:
            static T *cast(val& v)
            {
                if(v.empty())
                {
                    return 0;
                }
                else
                {
                    return val_cast_ptr<T>(v);
                }
            }
        };

        template<typename T>
        class val_cast_ptr_or_ref<T&>
        {
        public:
            static T& cast(val& v)
            {
                return *val_cast_ptr<T>(v);
            }
        };



        template<typename T>
        inline val create_val(T& x, const boost::true_type&)
        {
            return val(&x, UNMANAGED_PTR);
        }

        template<typename T>
        inline val create_val(T& x, const boost::false_type&)
        {
            T *new_x = new T(x);
            return val(new_x, TRANSFER_OWNERSHIP);
        }

        template<typename T>
        inline val create_val(T *x, const boost::false_type&)
        {
            return val(x, UNMANAGED_PTR);
        }

        template<typename T>
        class arg_info_generator
        {
        public:
            static arg_info make_arg_info()
            {
                return arg_info(&typeid(T), true, false, false);
            }
        };

        template<typename T>
        class arg_info_generator<T *>
        {
        public:
            static arg_info make_arg_info()
            {
                return arg_info(&typeid(T), boost::is_const<T>::value, true, false);
            }
        };

        template<typename T>
        class arg_info_generator<T&>
        {
        public:
            static arg_info make_arg_info()
            {
                return arg_info(&typeid(T), boost::is_const<T>::value, false, true);
            }
        };



    



#       define BOOST_PP_ITERATION_LIMITS (0, EVAL_FWRAP_MAX_NUM_OF_ARGS)
#       define BOOST_PP_FILENAME_1 "fwrap.hpp" // this file
#       include BOOST_PP_ITERATE()

#   endif // EVAL_FWRAP_H

#else // BOOST_PP_IS_ITERATING

#   define n BOOST_PP_ITERATION()


#   if n == 0 // Define the abstract base classes and primary specializations

        class fwrap_store_base
        {
        public:
            virtual val call(fwrap_args &args) const = 0;
            virtual const fwrap_store_base *clone() const = 0;
            virtual unsigned int arity() const = 0;
            virtual fwrap_fn_type fn_type() const = 0;
            virtual arg_info get_rv_info() const = 0;
            virtual void get_arg_info(std::vector<arg_info> &vec) const = 0;

            virtual ~fwrap_store_base()
            {
            }
        };


        template<typename T>
        class func_store : public fwrap_store_base
        {
             BOOST_STATIC_ASSERT(sizeof(T) == 0);
        };

        template<typename ObjT, typename T>
        class ctor_store : public fwrap_store_base
        {
            BOOST_STATIC_ASSERT(sizeof(ObjT) == 0);
        };


#   endif

    // Looping starts here.
    // We specialize func_store and ctor_store

#   define ARG_INFO_PUSH_BACK(z, n, vec_name) \
                vec_name.push_back(detail::arg_info_generator<T ## n>::make_arg_info());



#   define ARGS_PRINT(z, n, vec_name) detail::val_cast_ptr_or_ref<T ## n>::cast(vec_name[n])

        template<typename RvT
                 BOOST_PP_COMMA_IF(n)
                 BOOST_PP_ENUM_PARAMS(n, typename T)>
        class func_store<RvT (*)(BOOST_PP_ENUM_PARAMS(n, T))> : public fwrap_store_base
        {
        public:
            explicit func_store(RvT (*f)(BOOST_PP_ENUM_PARAMS(n, T)))
              : _f(f)
            {                
            }

            virtual val call(fwrap_args& args) const
            {
                if(args.size() != n)
                {
                    throw arity_mismatch_exception(n, args.size());
                }
                RvT rv(_f(BOOST_PP_ENUM(n, ARGS_PRINT, args)));
                return detail::create_val(rv, boost::is_reference<RvT>());
            }

            virtual const fwrap_store_base *clone() const
            {
                return new func_store<RvT (*)(BOOST_PP_ENUM_PARAMS(n, T))>(_f);
            }

            virtual unsigned int arity() const
            {
                return n;
            }

            virtual fwrap_fn_type fn_type() const
            {
                return FWRAP_FUNCTION;
            }

            virtual arg_info get_rv_info() const
            {
                return detail::arg_info_generator<RvT>::make_arg_info();
            }

            virtual void get_arg_info(std::vector<arg_info>& vec) const
            {
                vec.clear();
                BOOST_PP_REPEAT(n, ARG_INFO_PUSH_BACK, vec)
            }
        private:
            RvT (*_f)(BOOST_PP_ENUM_PARAMS(n, T));
        };





        template<BOOST_PP_ENUM_PARAMS(n, typename T)>
        class func_store<void (*)(BOOST_PP_ENUM_PARAMS(n, T))> : public fwrap_store_base
        {
        public:
            explicit func_store(void (*f)(BOOST_PP_ENUM_PARAMS(n, T)))
              : _f(f)
            {                
            }

            virtual val call(fwrap_args& args) const
            {
                if(args.size() != n)
                {
                    throw arity_mismatch_exception(n, args.size());
                }
                _f(BOOST_PP_ENUM(n, ARGS_PRINT, args));
                return val();
            }

            virtual const fwrap_store_base *clone() const
            {
                return new func_store<void (*)(BOOST_PP_ENUM_PARAMS(n, T))>(_f);
            }

            virtual unsigned int arity() const
            {
                return n;
            }

            virtual fwrap_fn_type fn_type() const
            {
                return FWRAP_FUNCTION;
            }

            virtual arg_info get_rv_info() const
            {
                return detail::arg_info_generator<void>::make_arg_info();
            }

            virtual void get_arg_info(std::vector<arg_info>& vec) const
            {
                vec.clear();
                BOOST_PP_REPEAT(n, ARG_INFO_PUSH_BACK, vec)
            }
        private:
            void (*_f)(BOOST_PP_ENUM_PARAMS(n, T));
        };



#   define ARGS_PRINT_METHOD(z, n, vec_name) \
                detail::val_cast_ptr_or_ref<T ## n>::cast(vec_name[n + 1])


        template<typename ObjT,
                 typename RvT
                 BOOST_PP_COMMA_IF(n)
                 BOOST_PP_ENUM_PARAMS(n, typename T)>
        class func_store<RvT (ObjT::*)(BOOST_PP_ENUM_PARAMS(n, T))> : public fwrap_store_base
        {
        public:
            explicit func_store(RvT (ObjT::*m)(BOOST_PP_ENUM_PARAMS(n, T)))
              : _m(m)
            {                
            }

            virtual val call(fwrap_args& args) const
            {
                if(args.size() != n + 1) // always need the object as well
                {
                    throw arity_mismatch_exception(n + 1, args.size());
                }
                ObjT *o = eval::val_cast_ptr<ObjT>(args[0]);
                RvT rv((o->*_m)(BOOST_PP_ENUM(n, ARGS_PRINT_METHOD, args)));
                return detail::create_val(rv, boost::is_reference<RvT>());
            }

            virtual const fwrap_store_base *clone() const
            {
                return new func_store<RvT (ObjT::*)(BOOST_PP_ENUM_PARAMS(n, T))>(_m);
            }

            virtual unsigned int arity() const
            {
                return n + 1;
            }

            virtual fwrap_fn_type fn_type() const
            {
                return FWRAP_METHOD;
            }

            virtual arg_info get_rv_info() const
            {
                return detail::arg_info_generator<RvT>::make_arg_info();
            }

            virtual void get_arg_info(std::vector<arg_info>& vec) const
            {
                vec.clear();
                vec.push_back(detail::arg_info_generator<ObjT *>::make_arg_info());
                BOOST_PP_REPEAT(n, ARG_INFO_PUSH_BACK, vec)
            }

        private:
            RvT (ObjT::*_m)(BOOST_PP_ENUM_PARAMS(n, T));
        };




        template<typename ObjT,
                 typename RvT
                 BOOST_PP_COMMA_IF(n)
                 BOOST_PP_ENUM_PARAMS(n, typename T)>
        class func_store<RvT (ObjT::*)(BOOST_PP_ENUM_PARAMS(n, T)) const> : public fwrap_store_base
        {
        public:
            explicit func_store(RvT (ObjT::*m)(BOOST_PP_ENUM_PARAMS(n, T)) const)
              : _m(m)
            {                
            }

            virtual val call(fwrap_args& args) const
            {
                if(args.size() != n + 1) // always need the object as well
                {
                    throw arity_mismatch_exception(n + 1, args.size());
                }
                const ObjT *o = eval::val_cast_ptr<const ObjT>(args[0]);
                RvT rv((o->*_m)(BOOST_PP_ENUM(n, ARGS_PRINT_METHOD, args)));
                return detail::create_val(rv, boost::is_reference<RvT>());
            }

            virtual const fwrap_store_base *clone() const
            {
                return new func_store<RvT (ObjT::*)(BOOST_PP_ENUM_PARAMS(n, T)) const>(_m);
            }

            virtual unsigned int arity() const
            {
                return n + 1;
            }

            virtual fwrap_fn_type fn_type() const
            {
                return FWRAP_CONST_METHOD;
            }

            virtual arg_info get_rv_info() const
            {
                return detail::arg_info_generator<RvT>::make_arg_info();
            }

            virtual void get_arg_info(std::vector<arg_info>& vec) const
            {
                vec.clear();
                vec.push_back(detail::arg_info_generator<const ObjT *>::make_arg_info());
                BOOST_PP_REPEAT(n, ARG_INFO_PUSH_BACK, vec)
            }

        private:
            RvT (ObjT::*_m)(BOOST_PP_ENUM_PARAMS(n, T)) const;
        };




        template<typename ObjT
                 BOOST_PP_COMMA_IF(n)
                 BOOST_PP_ENUM_PARAMS(n, typename T)>
        class func_store<void (ObjT::*)(BOOST_PP_ENUM_PARAMS(n, T))> : public fwrap_store_base
        {
        public:
            explicit func_store(void (ObjT::*m)(BOOST_PP_ENUM_PARAMS(n, T)))
              : _m(m)
            {                
            }

            virtual val call(fwrap_args& args) const
            {
                if(args.size() != n + 1) // always need the object as well
                {
                    throw arity_mismatch_exception(n + 1, args.size());
                }
                ObjT *o = eval::val_cast_ptr<ObjT>(args[0]);
                (o->*_m)(BOOST_PP_ENUM(n, ARGS_PRINT_METHOD, args));
                return val();
            }

            virtual const fwrap_store_base *clone() const
            {
                return new func_store<void (ObjT::*)(BOOST_PP_ENUM_PARAMS(n, T))>(_m);
            }

            virtual unsigned int arity() const
            {
                return n + 1;
            }

            virtual fwrap_fn_type fn_type() const
            {
                return FWRAP_METHOD;
            }

            virtual arg_info get_rv_info() const
            {
                return detail::arg_info_generator<void>::make_arg_info();
            }

            virtual void get_arg_info(std::vector<arg_info>& vec) const
            {
                vec.clear();
                vec.push_back(detail::arg_info_generator<ObjT *>::make_arg_info());
                BOOST_PP_REPEAT(n, ARG_INFO_PUSH_BACK, vec)
            }

        private:
            void (ObjT::*_m)(BOOST_PP_ENUM_PARAMS(n, T));
        };





        template<typename ObjT
                 BOOST_PP_COMMA_IF(n)
                 BOOST_PP_ENUM_PARAMS(n, typename T)>
        class func_store<void (ObjT::*)(BOOST_PP_ENUM_PARAMS(n, T)) const>
                                                                          : public fwrap_store_base
        {
        public:
            explicit func_store(void (ObjT::*m)(BOOST_PP_ENUM_PARAMS(n, T)) const)
              : _m(m)
            {                
            }

            virtual val call(fwrap_args& args) const
            {
                if(args.size() != n + 1) // always need the object as well
                {
                    throw arity_mismatch_exception(n + 1, args.size());
                }
                const ObjT *o = eval::val_cast_ptr<const ObjT>(args[0]);
                (o->*_m)(BOOST_PP_ENUM(n, ARGS_PRINT_METHOD, args));
                return val();
            }

            virtual const fwrap_store_base *clone() const
            {
                return new func_store<void (ObjT::*)(BOOST_PP_ENUM_PARAMS(n, T)) const>(_m);
            }

            virtual unsigned int arity() const
            {
                return n + 1;
            }

            virtual fwrap_fn_type fn_type() const
            {
                return FWRAP_CONST_METHOD;
            }

            virtual arg_info get_rv_info() const
            {
                return detail::arg_info_generator<void>::make_arg_info();
            }

            virtual void get_arg_info(std::vector<arg_info>& vec) const
            {
                vec.clear();
                vec.push_back(detail::arg_info_generator<const ObjT *>::make_arg_info());
                BOOST_PP_REPEAT(n, ARG_INFO_PUSH_BACK, vec)
            }

        private:
            void (ObjT::*_m)(BOOST_PP_ENUM_PARAMS(n, T)) const;
        };




#   define ARGS_PRINT_CTOR(z, n, vec_name) detail::val_cast_ptr_or_ref<T ## n>::cast(vec_name[n])

        template<typename ObjT
                 BOOST_PP_COMMA_IF(n)
                 BOOST_PP_ENUM_PARAMS(n, typename T)>
        class ctor_store<ObjT, void (*)(BOOST_PP_ENUM_PARAMS(n, T))> : public fwrap_store_base
        {
        public:
            ctor_store()
            {                
            }

            virtual val call(fwrap_args& args) const
            {
                if(args.size() != n)
                {
                    throw arity_mismatch_exception(n, args.size());
                }
                ObjT *o = new ObjT(BOOST_PP_ENUM(n, ARGS_PRINT_CTOR, args));
                return val(o, TRANSFER_OWNERSHIP);
            }

            virtual const fwrap_store_base *clone() const
            {
                return new ctor_store<ObjT, void (*)(BOOST_PP_ENUM_PARAMS(n, T))>();
            }

            virtual unsigned int arity() const
            {
                return n;
            }

            virtual fwrap_fn_type fn_type() const
            {
                return FWRAP_CONSTRUCTOR;
            }

            virtual arg_info get_rv_info() const
            {
                return detail::arg_info_generator<ObjT *>::make_arg_info();
            }

            virtual void get_arg_info(std::vector<arg_info>& vec) const
            {
                vec.clear();
                BOOST_PP_REPEAT(n, ARG_INFO_PUSH_BACK, vec)
            }
        };






#   if n == EVAL_FWRAP_MAX_NUM_OF_ARGS // all partial specializations completed

    } // namespace detail

    class fwrap
    {
    public:
        template<typename ObjT, typename T>
        static fwrap wrap_ctor()
        {
            return fwrap(new detail::ctor_store<ObjT, T>(), USE_PRIVATE_CONSTRUCTOR);
        }


        template<typename T>
        explicit fwrap(T fp)
          : _store(fp ? new detail::func_store<T>(fp) : 0)
        {
        }

        fwrap()
          : _store(0)
        {
        }

        fwrap(const fwrap& other)
          : _store(other._store ? other._store->clone() : 0)
        {
        }

        void swap(fwrap& other)
        {
            std::swap(_store, other._store);
        }

        fwrap& operator=(fwrap rhs)
        {
            rhs.swap(*this);
            return *this;
        }

        bool is_null() const
        {
            return !_store;
        }

        val operator()(fwrap_args& args) const
        {
            if(is_null())
            {
                throw null_ptr_exception("operator() on null fwrap");
            }
            return _store->call(args);
        }

        unsigned int arity() const
        {
            if(is_null())
            {
                throw null_ptr_exception("arity of null fwrap");
            }
            return _store->arity();
        }

        fwrap_fn_type fn_type() const
        {
            if(is_null())
            {
                throw null_ptr_exception("fn_type of null fwrap");
            }
            return _store->fn_type();
        }

        arg_info get_rv_info() const
        {
            if(is_null())
            {
                throw null_ptr_exception("get_rv_info of null fwrap");
            }
            return _store->get_rv_info();
        }

        void get_arg_info(std::vector<arg_info>& vec) const
        {
            if(is_null())
            {
                throw null_ptr_exception("get_arg_info of null fwrap");
            }
            _store->get_arg_info(vec);
        }

        ~fwrap()
        {
            delete _store;
        }
    private:
        enum ctor_overload_resolution
        {
            USE_PRIVATE_CONSTRUCTOR
        };

        explicit fwrap(const detail::fwrap_store_base *store, const ctor_overload_resolution&)
          : _store(store)
        {
        }

        const detail::fwrap_store_base *_store;
    };

} // namespace eval
#   endif


#   undef ARGS_PRINT
#   undef ARGS_PRINT_METHOD
#   undef ARGS_PRINT_CTOR
#   undef ARG_INFO_PUSH_PACK
#   undef ObjT_ARG_INFO_PUSH_BACK
#   undef n

#endif // BOOST_PP_IS_ITERATING

---