// (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 |