function_pack.hpp

Go to the documentation of this file.

/*
    Copyright 2005-2007 Adobe Systems Incorporated
    Distributed under the MIT License (see accompanying file LICENSE_1_0_0.txt
    or a copy at http://opensource.adobe.com/licenses.html)
*/

/******************************************************************************/

#ifndef ADOBE_FUNCTION_PACK_HPP
#define ADOBE_FUNCTION_PACK_HPP

#include <adobe/config.hpp>

#include <stdexcept>
#include <sstream>

#include <boost/bind.hpp>
#include <boost/static_assert.hpp>
#include <boost/type_traits.hpp>
#include <boost/utility/enable_if.hpp>

#include <adobe/any_regular.hpp>
#include <adobe/array.hpp>
#include <adobe/closed_hash.hpp>
#include <adobe/dictionary.hpp>
#include <adobe/empty.hpp>
#include <adobe/function_traits.hpp>
#include <adobe/string.hpp>
#include <adobe/virtual_machine.hpp>

/******************************************************************************/

namespace adobe {

/******************************************************************************/
#ifndef ADOBE_NO_DOCUMENTATION
namespace implementation {

/******************************************************************************/
template <typename T>
struct undecorate
{ typedef T type; };

template <typename T>
struct undecorate<const T>
{ typedef T type; };

template <typename T>
struct undecorate<T&>
{ typedef T type; };

template <typename T>
struct undecorate<const T&>
{ typedef T type; };

/******************************************************************************/

inline any_regular_t& find_arg(dictionary_t& named_argument_set, name_t arg_name)
{
    dictionary_t::iterator arg(named_argument_set.find(arg_name));

    if (arg == named_argument_set.end())
        throw std::runtime_error(make_string("No value for named argument '", arg_name.c_str(), "'"));

    return arg->second;
}

inline const any_regular_t& find_arg(const dictionary_t& named_argument_set, name_t arg_name)
{
    return find_arg(const_cast<dictionary_t&>(named_argument_set), arg_name);
}

inline any_regular_t& find_arg(array_t& argument_set, std::size_t index)
{
    if (argument_set.size() < (index + 1))
    {
        std::stringstream error;

        error << "No value for unnamed argument " << (index + 1);

        throw std::runtime_error(error.str());
    }

    return argument_set[index];
}

inline const any_regular_t& find_arg(const array_t& argument_set, std::size_t index)
{
    return find_arg(const_cast<array_t&>(argument_set), index);
}

/******************************************************************************/

#define ADOBE_FUNCTION_UNNAMED_ARG(param_index) \
find_arg(argument_set, (param_index - 1)).cast<typename undecorate<typename traits_type::arg##param_index##_type>::type>()

#define ADOBE_FUNCTION_NAMED_ARG(param_index) \
find_arg(named_argument_set, name##param_index##_m).cast<typename undecorate<typename traits_type::arg##param_index##_type>::type>()

/******************************************************************************/

template <typename T>
struct novoid
{ typedef T type; };

template <>
struct novoid<void>
{ typedef adobe::empty_t type; };

/******************************************************************************/

template <typename F>
inline typename boost::disable_if<boost::is_same<typename F::result_type,
                                                 void>,
                                  typename F::result_type>::type
invoke_novoid(const F& f)
{
    return f();
}

template <typename F>
inline typename boost::enable_if<boost::is_same<typename F::result_type,
                                                void>,
                                 adobe::empty_t>::type
invoke_novoid(const F& f)
{
    f();

    return adobe::empty_t();
}

/******************************************************************************/

template <typename F, std::size_t Arity>
struct function_pack_helper;

/******************************************************************************/

template <typename F>
struct function_pack_helper<F, 0>
{
    typedef function_traits<F>                        traits_type;
    typedef typename traits_type::result_type         traits_result_type;
    typedef typename novoid<traits_result_type>::type result_type;

    explicit function_pack_helper(const F& f) :
        f_m(f)
    { }

    template <typename T>
    result_type operator()(const T&) const
    {
        return invoke_novoid(boost::bind(f_m));
    }

private:
    typename traits_type::function_type f_m;
};

/******************************************************************************/

template <typename F>
struct function_pack_helper<F, 1>
{
    typedef function_traits<F>                        traits_type;
    typedef typename traits_type::result_type         traits_result_type;
    typedef typename novoid<traits_result_type>::type result_type;

    explicit function_pack_helper(const F& f,
                                  name_t   arg1_name = name_t()) :
        f_m(f),
        name1_m(arg1_name)
    { }

    result_type operator()(const array_t& argument_set) const
    {
        return invoke_novoid(boost::bind(f_m, ADOBE_FUNCTION_UNNAMED_ARG(1)));
    }

    result_type operator()(const dictionary_t& named_argument_set) const
    {
        return invoke_novoid(boost::bind(f_m, ADOBE_FUNCTION_NAMED_ARG(1)));
    }

private:
    typename traits_type::function_type f_m;
    name_t name1_m;
};

/******************************************************************************/

template <typename F>
struct function_pack_helper<F, 2>
{
    typedef function_traits<F>                        traits_type;
    typedef typename traits_type::result_type         traits_result_type;
    typedef typename novoid<traits_result_type>::type result_type;

    explicit function_pack_helper(const F& f,
                                  name_t   arg1_name = name_t(), name_t arg2_name = name_t()) :
        f_m(f),
        name1_m(arg1_name), name2_m(arg2_name)
    { }

    result_type operator()(const array_t& argument_set) const
    {
        return invoke_novoid(boost::bind(f_m,
                                         ADOBE_FUNCTION_UNNAMED_ARG(1), ADOBE_FUNCTION_UNNAMED_ARG(2)));
    }

    result_type operator()(const dictionary_t& named_argument_set) const
    {
        return invoke_novoid(boost::bind(f_m,
                                         ADOBE_FUNCTION_NAMED_ARG(1), ADOBE_FUNCTION_NAMED_ARG(2)));
    }

private:
    typename traits_type::function_type f_m;
    name_t name1_m;
    name_t name2_m;
};

/******************************************************************************/

template <typename F>
struct function_pack_helper<F, 3>
{
    typedef function_traits<F>                        traits_type;
    typedef typename traits_type::result_type         traits_result_type;
    typedef typename novoid<traits_result_type>::type result_type;

    explicit function_pack_helper(const F& f,
                                  name_t   arg1_name = name_t(), name_t arg2_name = name_t(),
                                  name_t   arg3_name = name_t()) :
        f_m(f),
        name1_m(arg1_name), name2_m(arg2_name), name3_m(arg3_name)
    { }

    result_type operator()(const array_t& argument_set) const
    {
        return invoke_novoid(boost::bind(f_m,
                                         ADOBE_FUNCTION_UNNAMED_ARG(1), ADOBE_FUNCTION_UNNAMED_ARG(2),
                                         ADOBE_FUNCTION_UNNAMED_ARG(3)));
    }

    result_type operator()(const dictionary_t& named_argument_set) const
    {
        return invoke_novoid(boost::bind(f_m,
                                         ADOBE_FUNCTION_NAMED_ARG(1), ADOBE_FUNCTION_NAMED_ARG(2),
                                         ADOBE_FUNCTION_NAMED_ARG(3)));
    }

private:
    typename traits_type::function_type f_m;
    name_t name1_m;
    name_t name2_m;
    name_t name3_m;
};

/******************************************************************************/

template <typename F>
struct function_pack_helper<F, 4>
{
    typedef function_traits<F>                        traits_type;
    typedef typename traits_type::result_type         traits_result_type;
    typedef typename novoid<traits_result_type>::type result_type;

    explicit function_pack_helper(const F& f,
                                  name_t   arg1_name = name_t(), name_t arg2_name = name_t(),
                                  name_t   arg3_name = name_t(), name_t arg4_name = name_t()) :
        f_m(f),
        name1_m(arg1_name), name2_m(arg2_name), name3_m(arg3_name), name4_m(arg4_name)
    { }

    result_type operator()(const array_t& argument_set) const
    {
        return invoke_novoid(boost::bind(f_m,
                                         ADOBE_FUNCTION_UNNAMED_ARG(1), ADOBE_FUNCTION_UNNAMED_ARG(2),
                                         ADOBE_FUNCTION_UNNAMED_ARG(3), ADOBE_FUNCTION_UNNAMED_ARG(4)));
    }

    result_type operator()(const dictionary_t& named_argument_set) const
    {
        return invoke_novoid(boost::bind(f_m,
                                         ADOBE_FUNCTION_NAMED_ARG(1), ADOBE_FUNCTION_NAMED_ARG(2),
                                         ADOBE_FUNCTION_NAMED_ARG(3), ADOBE_FUNCTION_NAMED_ARG(4)));
    }

private:
    typename traits_type::function_type f_m;
    name_t name1_m;
    name_t name2_m;
    name_t name3_m;
    name_t name4_m;
};

/******************************************************************************/

template <typename F>
struct function_pack_helper<F, 5>
{
    typedef function_traits<F>                        traits_type;
    typedef typename traits_type::result_type         traits_result_type;
    typedef typename novoid<traits_result_type>::type result_type;

    explicit function_pack_helper(const F& f,
                                  name_t   arg1_name = name_t(), name_t arg2_name = name_t(),
                                  name_t   arg3_name = name_t(), name_t arg4_name = name_t(),
                                  name_t   arg5_name = name_t()) :
        f_m(f),
        name1_m(arg1_name), name2_m(arg2_name), name3_m(arg3_name), name4_m(arg4_name),
        name5_m(arg5_name)
    { }

    result_type operator()(const array_t& argument_set) const
    {
        return invoke_novoid(boost::bind(f_m,
                                         ADOBE_FUNCTION_UNNAMED_ARG(1), ADOBE_FUNCTION_UNNAMED_ARG(2),
                                         ADOBE_FUNCTION_UNNAMED_ARG(3), ADOBE_FUNCTION_UNNAMED_ARG(4),
                                         ADOBE_FUNCTION_UNNAMED_ARG(5)));
    }

    result_type operator()(const dictionary_t& named_argument_set) const
    {
        return invoke_novoid(boost::bind(f_m,
                                         ADOBE_FUNCTION_NAMED_ARG(1), ADOBE_FUNCTION_NAMED_ARG(2),
                                         ADOBE_FUNCTION_NAMED_ARG(3), ADOBE_FUNCTION_NAMED_ARG(4),
                                         ADOBE_FUNCTION_NAMED_ARG(5)));
    }

private:
    typename traits_type::function_type f_m;
    name_t name1_m;
    name_t name2_m;
    name_t name3_m;
    name_t name4_m;
    name_t name5_m;
};

/******************************************************************************/

template <typename F>
struct function_pack_helper<F, 6>
{
    typedef function_traits<F>                        traits_type;
    typedef typename traits_type::result_type         traits_result_type;
    typedef typename novoid<traits_result_type>::type result_type;

    explicit function_pack_helper(const F& f,
                                  name_t   arg1_name = name_t(), name_t arg2_name = name_t(),
                                  name_t   arg3_name = name_t(), name_t arg4_name = name_t(),
                                  name_t   arg5_name = name_t(), name_t arg6_name = name_t()) :
        f_m(f),
        name1_m(arg1_name), name2_m(arg2_name), name3_m(arg3_name), name4_m(arg4_name),
        name5_m(arg5_name), name6_m(arg6_name)
    { }

    result_type operator()(const array_t& argument_set) const
    {
        return invoke_novoid(boost::bind(f_m,
                                         ADOBE_FUNCTION_UNNAMED_ARG(1), ADOBE_FUNCTION_UNNAMED_ARG(2),
                                         ADOBE_FUNCTION_UNNAMED_ARG(3), ADOBE_FUNCTION_UNNAMED_ARG(4),
                                         ADOBE_FUNCTION_UNNAMED_ARG(5), ADOBE_FUNCTION_UNNAMED_ARG(6)));
    }

    result_type operator()(const dictionary_t& named_argument_set) const
    {
        return invoke_novoid(boost::bind(f_m,
                                         ADOBE_FUNCTION_NAMED_ARG(1), ADOBE_FUNCTION_NAMED_ARG(2),
                                         ADOBE_FUNCTION_NAMED_ARG(3), ADOBE_FUNCTION_NAMED_ARG(4),
                                         ADOBE_FUNCTION_NAMED_ARG(5), ADOBE_FUNCTION_NAMED_ARG(6)));
    }

private:
    typename traits_type::function_type f_m;
    name_t name1_m;
    name_t name2_m;
    name_t name3_m;
    name_t name4_m;
    name_t name5_m;
    name_t name6_m;
};

/******************************************************************************/

template <typename F>
struct function_pack_helper<F, 7>
{
    typedef function_traits<F>                        traits_type;
    typedef typename traits_type::result_type         traits_result_type;
    typedef typename novoid<traits_result_type>::type result_type;

    explicit function_pack_helper(const F& f,
                                  name_t   arg1_name = name_t(), name_t arg2_name = name_t(),
                                  name_t   arg3_name = name_t(), name_t arg4_name = name_t(),
                                  name_t   arg5_name = name_t(), name_t arg6_name = name_t(),
                                  name_t   arg7_name = name_t()) :
        f_m(f),
        name1_m(arg1_name), name2_m(arg2_name), name3_m(arg3_name), name4_m(arg4_name),
        name5_m(arg5_name), name6_m(arg6_name), name7_m(arg7_name)
    { }

    result_type operator()(const array_t& argument_set) const
    {
        return invoke_novoid(boost::bind(f_m,
                                         ADOBE_FUNCTION_UNNAMED_ARG(1), ADOBE_FUNCTION_UNNAMED_ARG(2),
                                         ADOBE_FUNCTION_UNNAMED_ARG(3), ADOBE_FUNCTION_UNNAMED_ARG(4),
                                         ADOBE_FUNCTION_UNNAMED_ARG(5), ADOBE_FUNCTION_UNNAMED_ARG(6),
                                         ADOBE_FUNCTION_UNNAMED_ARG(7)));
    }

    result_type operator()(const dictionary_t& named_argument_set) const
    {
        return invoke_novoid(boost::bind(f_m,
                                         ADOBE_FUNCTION_NAMED_ARG(1), ADOBE_FUNCTION_NAMED_ARG(2),
                                         ADOBE_FUNCTION_NAMED_ARG(3), ADOBE_FUNCTION_NAMED_ARG(4),
                                         ADOBE_FUNCTION_NAMED_ARG(5), ADOBE_FUNCTION_NAMED_ARG(6),
                                         ADOBE_FUNCTION_NAMED_ARG(7)));
    }

private:
    typename traits_type::function_type f_m;
    name_t name1_m;
    name_t name2_m;
    name_t name3_m;
    name_t name4_m;
    name_t name5_m;
    name_t name6_m;
    name_t name7_m;
};

/******************************************************************************/

#undef ADOBE_FUNCTION_UNNAMED_ARG
#undef ADOBE_FUNCTION_NAMED_ARG

/******************************************************************************/

template <typename T>
any_regular_t wrap_regular(const T& x)
{ return any_regular_t(x); }

template <>
inline any_regular_t wrap_regular<any_regular_t>(const any_regular_t& x)
{ return x; }

/******************************************************************************/

} // namespace implementation
// ADOBE_NO_DOCUMENTATION
#endif
/******************************************************************************/

template <typename F>
inline implementation::function_pack_helper<F, 0>
named_bind(const F& f)
{
    BOOST_STATIC_ASSERT((function_traits<F>::arity == 0));

    return implementation::function_pack_helper<F, 0>(f);
}

template <typename F>
inline implementation::function_pack_helper<F, 1>
named_bind(const F& f,
           name_t arg1_name)
{
    BOOST_STATIC_ASSERT((function_traits<F>::arity == 1));

    return implementation::function_pack_helper<F, 1>(f,
                                                      arg1_name);
}

template <typename F>
inline implementation::function_pack_helper<F, 2>
named_bind(const F& f,
           name_t arg1_name, name_t arg2_name)
{
    BOOST_STATIC_ASSERT((function_traits<F>::arity == 2));

    return implementation::function_pack_helper<F, 2>(f,
                                                      arg1_name,
                                                      arg2_name);
}

template <typename F>
inline implementation::function_pack_helper<F, 3>
named_bind(const F& f,
           name_t arg1_name, name_t arg2_name, name_t arg3_name)
{
    BOOST_STATIC_ASSERT((function_traits<F>::arity == 3));

    return implementation::function_pack_helper<F, 3>(f,
                                                      arg1_name,
                                                      arg2_name,
                                                      arg3_name);
}

template <typename F>
inline implementation::function_pack_helper<F, 4>
named_bind(const F& f,
           name_t arg1_name, name_t arg2_name, name_t arg3_name, name_t arg4_name)
{
    BOOST_STATIC_ASSERT((function_traits<F>::arity == 4));

    return implementation::function_pack_helper<F, 4>(f,
                                                      arg1_name,
                                                      arg2_name,
                                                      arg3_name,
                                                      arg4_name);
}

template <typename F>
inline implementation::function_pack_helper<F, 5>
named_bind(const F& f,
           name_t arg1_name, name_t arg2_name, name_t arg3_name, name_t arg4_name,
           name_t arg5_name)
{
    BOOST_STATIC_ASSERT((function_traits<F>::arity == 5));

    return implementation::function_pack_helper<F, 5>(f,
                                                      arg1_name,
                                                      arg2_name,
                                                      arg3_name,
                                                      arg4_name,
                                                      arg5_name);
}

template <typename F>
inline implementation::function_pack_helper<F, 6>
named_bind(const F& f,
           name_t arg1_name, name_t arg2_name, name_t arg3_name, name_t arg4_name,
           name_t arg5_name, name_t arg6_name)
{
    BOOST_STATIC_ASSERT((function_traits<F>::arity == 6));

    return implementation::function_pack_helper<F, 6>(f,
                                                      arg1_name,
                                                      arg2_name,
                                                      arg3_name,
                                                      arg4_name,
                                                      arg5_name,
                                                      arg6_name);
}

template <typename F>
inline implementation::function_pack_helper<F, 7>
named_bind(const F& f,
           name_t arg1_name, name_t arg2_name, name_t arg3_name, name_t arg4_name,
           name_t arg5_name, name_t arg6_name, name_t arg7_name)
{
    BOOST_STATIC_ASSERT((function_traits<F>::arity == 7));

    return implementation::function_pack_helper<F, 7>(f,
                                                      arg1_name,
                                                      arg2_name,
                                                      arg3_name,
                                                      arg4_name,
                                                      arg5_name,
                                                      arg6_name,
                                                      arg7_name);
}

/******************************************************************************/
struct function_pack_t
{
#ifndef ADOBE_NO_DOCUMENTATION
private:
    typedef boost::function<any_regular_t (const dictionary_t&)> dictionary_function_t;
    typedef boost::function<any_regular_t (const array_t&)>      array_function_t;
#endif

public:
    template <typename F>
    void register_function(name_t name, const F& f)
    {
        // We can't check arity here because unnamed argument functions
        // pass through this, which could be of any arity.

        attach_unnamed(name,
                       implementation::function_pack_helper<F, function_traits<F>::arity>(f));
    }

    template <typename F>
    void register_named0_function(name_t name, const F& f)
    {
        attach_named(name, named_bind(f));
    }

    template <typename F>
    void register_function(name_t name, const F& f, name_t arg1_name)
    {
        attach_named(name,
                     named_bind(f, arg1_name));
    }

    template <typename F>
    void register_function(name_t name, const F& f, name_t arg1_name, name_t arg2_name)
    {
        attach_named(name, named_bind(f,
                                      arg1_name, arg2_name));
    }

    template <typename F>
    void register_function(name_t name, const F& f, name_t arg1_name, name_t arg2_name, name_t arg3_name)
    {
        attach_named(name, named_bind(f,
                                      arg1_name, arg2_name, arg3_name));
    }

    template <typename F>
    void register_function(name_t name, const F& f,
                           name_t arg1_name, name_t arg2_name, name_t arg3_name, name_t arg4_name)
    {
        attach_named(name, named_bind(f,
                                      arg1_name, arg2_name, arg3_name, arg4_name));
    }

    template <typename F>
    void register_function(name_t name, const F& f,
                           name_t arg1_name, name_t arg2_name, name_t arg3_name, name_t arg4_name,
                           name_t arg5_name)
    {
        BOOST_STATIC_ASSERT((function_traits<F>::arity == 5));

        attach_named(name, named_bind(f,
                                      arg1_name, arg2_name, arg3_name, arg4_name,
                                      arg5_name));
    }

    template <typename F>
    void register_function(name_t name, const F& f,
                           name_t arg1_name, name_t arg2_name, name_t arg3_name, name_t arg4_name,
                           name_t arg5_name, name_t arg6_name)
    {
        attach_named(name, named_bind(f,
                                      arg1_name, arg2_name, arg3_name, arg4_name,
                                      arg5_name, arg6_name));
    }

    template <typename F>
    void register_function(name_t name, const F& f,
                           name_t arg1_name, name_t arg2_name, name_t arg3_name, name_t arg4_name,
                           name_t arg5_name, name_t arg6_name, name_t arg7_name)
    {
        attach_named(name, named_bind(f,
                                      arg1_name, arg2_name, arg3_name, arg4_name,
                                      arg5_name, arg6_name, arg7_name));
    }

    any_regular_t operator()(name_t function, const array_t& argument_set) const
    {
        return find_unnamed(function)->second(argument_set);
    }

    any_regular_t operator()(name_t function, const dictionary_t& named_argument_set) const
    {
        return find_named(function)->second(named_argument_set);
    }

    any_regular_t operator()(name_t function, array_t& argument_set) const
    {
        return find_unnamed(function)->second(argument_set);
    }

    any_regular_t operator()(name_t function, dictionary_t& named_argument_set) const
    {
        return find_named(function)->second(named_argument_set);
    }

    any_regular_t operator()(const array_t& argument_set) const
    {
        adobe::name_t function;

        if (!argument_set.empty())
            argument_set[0].cast<adobe::name_t>(function);

        return (*this)(function, argument_set);
    }

    any_regular_t operator()(const dictionary_t& named_argument_set) const
    {
        adobe::name_t function;

        get_value(named_argument_set, adobe::static_name_t("command"), function);

        return (*this)(function, named_argument_set);
    }

    any_regular_t operator()(array_t& argument_set) const
    {
        adobe::name_t function;

        if (!argument_set.empty())
            argument_set[0].cast<adobe::name_t>(function);

        return (*this)(function, argument_set);
    }

    any_regular_t operator()(dictionary_t& named_argument_set) const
    {
        adobe::name_t function;

        get_value(named_argument_set, adobe::static_name_t("command"), function);

        return (*this)(function, named_argument_set);
    }

    void register_unnamed(name_t name, const array_function_t& f)
    {
        array_function_map_m.insert(array_function_map_t::value_type(name, f));
    }

    void register_named(name_t name, const dictionary_function_t& f)
    {
        dictionary_function_map_m.insert(dictionary_function_map_t::value_type(name, f));
    }

    void clear()
    {
        dictionary_function_map_m.clear();
        array_function_map_m.clear();
    }

#ifndef ADOBE_NO_DOCUMENTATION
private:
    typedef closed_hash_map<name_t, dictionary_function_t>       dictionary_function_map_t;
    typedef closed_hash_map<name_t, array_function_t>            array_function_map_t;

    dictionary_function_map_t::const_iterator find_named(name_t function) const
    {
        if (function == name_t())
            throw std::runtime_error("find_named: no function name specified");

        dictionary_function_map_t::const_iterator found(dictionary_function_map_m.find(function));

        if (found == dictionary_function_map_m.end())
            throw std::runtime_error(make_string("find_named: function '",
                                                 function.c_str(),
                                                 "' not found"));

        return found;
    }

    array_function_map_t::const_iterator find_unnamed(name_t function) const
    {
        if (function == name_t())
            throw std::runtime_error("find_named: no function name specified");

        array_function_map_t::const_iterator found(array_function_map_m.find(function));

        if (found == array_function_map_m.end())
            throw std::runtime_error(make_string("find_unnamed: function '",
                                                 function.c_str(),
                                                 "' not found"));

        return found;
    }

    template <typename T>
    void attach_unnamed(name_t name, T helper)
    {
        typename T::result_type (T::*proc)(const array_t&) const = &T::operator();

        array_function_map_m.insert(
            array_function_map_t::value_type(name,
                boost::bind(&implementation::wrap_regular<typename T::result_type>,
                            boost::bind(proc, helper, _1))));
    }

    template <typename T>
    void attach_named(name_t name, T helper)
    {
        typename T::result_type (T::*proc)(const dictionary_t&) const = &T::operator();

        dictionary_function_map_m.insert(
            dictionary_function_map_t::value_type(name,
                boost::bind(&implementation::wrap_regular<typename T::result_type>,
                            boost::bind(proc, helper, _1))));
    }

    dictionary_function_map_t dictionary_function_map_m;
    array_function_map_t      array_function_map_m;
// ADOBE_NO_DOCUMENTATION
#endif
};

/******************************************************************************/
inline void attach(virtual_machine_t& vm, const function_pack_t& pack)
{
    vm.set_array_function_lookup(boost::cref(pack));
    vm.set_dictionary_function_lookup(boost::cref(pack));
}

/******************************************************************************/

} // namespace adobe

/******************************************************************************/

#endif

/******************************************************************************/