// (C) Copyright 2006 Douglas Gregor <doug.gregor -at- gmail.com> // Use, modification and distribution is subject to 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) // Authors: Douglas Gregor #ifndef BOOST_MPI_PYTHON_SKELETON_AND_CONTENT_HPP #define BOOST_MPI_PYTHON_SKELETON_AND_CONTENT_HPP /** @file skeleton_and_content.hpp * * This file reflects the skeleton/content facilities into Python. */ #include <boost/python.hpp> #include <boost/mpi.hpp> #include <boost/function/function1.hpp> #define BOOST_MPI_PYTHON_FORWARD_ONLY #include <boost/mpi/python.hpp> #include <boost/mpi/python/serialize.hpp> namespace boost { namespace mpi { namespace python { /** * INTERNAL ONLY * * This @c content class is a wrapper around the C++ "content" * retrieved from get_content. This wrapper is only needed to store a * copy of the Python object on which get_content() was called. */ class content : public boost::mpi::content { typedef boost::mpi::content inherited; public: content(const inherited& base, boost::python::object object) : inherited(base), object(object) { } inherited& base() { return *this; } const inherited& base() const { return *this; } boost::python::object object; }; /** * INTERNAL ONLY * * A class specific to the Python bindings that mimics the behavior of * the skeleton_proxy<T> template. In the case of Python skeletons, we * only need to know the object (and its type) to transmit the * skeleton. This is the only user-visible skeleton proxy type, * although instantiations of its derived classes (@c * skeleton_proxy<T>) will be returned from the Python skeleton() * function. */ class skeleton_proxy_base { public: skeleton_proxy_base(const boost::python::object& object) : object(object) { } boost::python::object object; }; /** * INTERNAL ONLY * * The templated @c skeleton_proxy class represents a skeleton proxy * in Python. The only data is stored in the @c skeleton_proxy_base * class (which is the type actually exposed as @c skeleton_proxy in * Python). However, the type of @c skeleton_proxy<T> is important for * (de-)serialization of @c skeleton_proxy<T>'s for transmission. */ template<typename T> class skeleton_proxy : public skeleton_proxy_base { public: skeleton_proxy(const boost::python::object& object) : skeleton_proxy_base(object) { } }; namespace detail { using boost::python::object; using boost::python::extract; extern BOOST_MPI_DECL boost::python::object skeleton_proxy_base_type; template<typename T> struct skeleton_saver { void operator()(packed_oarchive& ar, const object& obj, const unsigned int) { packed_skeleton_oarchive pso(ar); pso << extract<T&>(obj.attr("object"))(); } }; template<typename T> struct skeleton_loader { void operator()(packed_iarchive& ar, object& obj, const unsigned int) { packed_skeleton_iarchive psi(ar); extract<skeleton_proxy<T>&> proxy(obj); if (!proxy.check()) obj = object(skeleton_proxy<T>(object(T()))); psi >> extract<T&>(obj.attr("object"))(); } }; /** * The @c skeleton_content_handler structure contains all of the * information required to extract a skeleton and content from a * Python object with a certain C++ type. */ struct skeleton_content_handler { function1<object, const object&> get_skeleton_proxy; function1<content, const object&> get_content; }; /** * A function object that extracts the skeleton from of a Python * object, which is actually a wrapped C++ object of type T. */ template<typename T> struct do_get_skeleton_proxy { object operator()(object value) { return object(skeleton_proxy<T>(value)); } }; /** * A function object that extracts the content of a Python object, * which is actually a wrapped C++ object of type T. */ template<typename T> struct do_get_content { content operator()(object value_obj) { T& value = extract<T&>(value_obj)(); return content(boost::mpi::get_content(value), value_obj); } }; /** * Determine if a skeleton and content handler for @p type has * already been registered. */ BOOST_MPI_PYTHON_DECL bool skeleton_and_content_handler_registered(PyTypeObject* type); /** * Register a skeleton/content handler with a particular Python type * (which actually wraps a C++ type). */ BOOST_MPI_PYTHON_DECL void register_skeleton_and_content_handler(PyTypeObject*, const skeleton_content_handler&); } // end namespace detail template<typename T> void register_skeleton_and_content(const T& value, PyTypeObject* type) { using boost::python::detail::direct_serialization_table; using boost::python::detail::get_direct_serialization_table; using namespace boost::python; // Determine the type if (!type) type = object(value).ptr()->ob_type; // Don't re-register the same type. if (detail::skeleton_and_content_handler_registered(type)) return; // Register the skeleton proxy type { boost::python::scope proxy_scope(detail::skeleton_proxy_base_type); std::string name("skeleton_proxy<"); name += typeid(T).name(); name += ">"; class_<skeleton_proxy<T>, bases<skeleton_proxy_base> >(name.c_str(), no_init); } // Register the saver and loader for the associated skeleton and // proxy, to allow (de-)serialization of skeletons via the proxy. direct_serialization_table<packed_iarchive, packed_oarchive>& table = get_direct_serialization_table<packed_iarchive, packed_oarchive>(); table.register_type(detail::skeleton_saver<T>(), detail::skeleton_loader<T>(), skeleton_proxy<T>(object(value))); // Register the rest of the skeleton/content mechanism, including // handlers that extract a skeleton proxy from a Python object and // extract the content from a Python object. detail::skeleton_content_handler handler; handler.get_skeleton_proxy = detail::do_get_skeleton_proxy<T>(); handler.get_content = detail::do_get_content<T>(); detail::register_skeleton_and_content_handler(type, handler); } } } } // end namespace boost::mpi::python #endif // BOOST_MPI_PYTHON_SKELETON_AND_CONTENT_HPP