FM / object

/usr/include/boost/python/object

Name	Size	Mode	Actions
add_to_namespace.hpp	780	0644	edit dl rm
class.hpp	2112	0644	edit dl rm
class_detail.hpp	634	0644	edit dl rm
class_metadata.hpp	9096	0644	edit dl rm
class_wrapper.hpp	1616	0644	edit dl rm
enum_base.hpp	1095	0644	edit dl rm
find_instance.hpp	844	0644	edit dl rm
forward.hpp	2297	0644	edit dl rm
function.hpp	2259	0644	edit dl rm
function_doc_signature.hpp	1514	0644	edit dl rm
function_handle.hpp	1439	0644	edit dl rm
function_object.hpp	1418	0644	edit dl rm
inheritance.hpp	3542	0644	edit dl rm
inheritance_query.hpp	617	0644	edit dl rm
instance.hpp	1282	0644	edit dl rm
iterator.hpp	7139	0644	edit dl rm
iterator_core.hpp	545	0644	edit dl rm
life_support.hpp	530	0644	edit dl rm
make_holder.hpp	3526	0644	edit dl rm
make_instance.hpp	2501	0644	edit dl rm
make_ptr_instance.hpp	2292	0644	edit dl rm
pickle_support.hpp	3185	0644	edit dl rm
pointer_holder.hpp	6523	0644	edit dl rm
py_function.hpp	4509	0644	edit dl rm
stl_iterator_core.hpp	851	0644	edit dl rm
value_holder.hpp	5008	0644	edit dl rm
value_holder_fwd.hpp	522	0644	edit dl rm

Edit: /usr/include/boost/python/object/make_instance.hpp (2501B)

# include <boost/python/detail/prefix.hpp>
# include <boost/python/object/instance.hpp>
# include <boost/python/converter/registered.hpp>
# include <boost/python/detail/decref_guard.hpp>
# include <boost/python/detail/type_traits.hpp>
# include <boost/python/detail/none.hpp>
# include <boost/mpl/assert.hpp>
# include <boost/mpl/or.hpp>

namespace boost { namespace python { namespace objects {

template <class T, class Holder, class Derived>
struct make_instance_impl
{
    typedef objects::instance<Holder> instance_t;
        
    template <class Arg>
    static inline PyObject* execute(Arg& x)
    {
        BOOST_MPL_ASSERT((mpl::or_<boost::python::detail::is_class<T>,
                boost::python::detail::is_union<T> >));

PyTypeObject* type = Derived::get_class_object(x);

if (type == 0)
            return python::detail::none();

PyObject* raw_result = type->tp_alloc(
            type, objects::additional_instance_size<Holder>::value);
          
        if (raw_result != 0)
        {
            python::detail::decref_guard protect(raw_result);
            
            instance_t* instance = (instance_t*)raw_result;
            
            // construct the new C++ object and install the pointer
            // in the Python object.
            Derived::construct(&instance->storage, (PyObject*)instance, x)->install(raw_result);
              
            // Note the position of the internally-stored Holder,
            // for the sake of destruction
            Py_SET_SIZE(instance, offsetof(instance_t, storage));

// Release ownership of the python object
            protect.cancel();
        }
        return raw_result;
    }
};

template <class T, class Holder>
struct make_instance
    : make_instance_impl<T, Holder, make_instance<T,Holder> >
{
    template <class U>
    static inline PyTypeObject* get_class_object(U&)
    {
        return converter::registered<T>::converters.get_class_object();
    }
    
    static inline Holder* construct(void* storage, PyObject* instance, reference_wrapper<T const> x)
    {
        return new (storage) Holder(instance, x);
    }
};

}}} // namespace boost::python::object

#endif // MAKE_INSTANCE_DWA200296_HPP

// Copyright David Abrahams 2002. // 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 MAKE_INSTANCE_DWA200296_HPP # define MAKE_INSTANCE_DWA200296_HPP # include # include # include # include # include # include # include # include namespace boost { namespace python { namespace objects { template struct make_instance_impl { typedef objects::instance instance_t; template static inline PyObject* execute(Arg& x) { BOOST_MPL_ASSERT((mpl::or_, boost::python::detail::is_union >)); PyTypeObject* type = Derived::get_class_object(x); if (type == 0) return python::detail::none(); PyObject* raw_result = type->tp_alloc( type, objects::additional_instance_size::value); if (raw_result != 0) { python::detail::decref_guard protect(raw_result); instance_t* instance = (instance_t*)raw_result; // construct the new C++ object and install the pointer // in the Python object. Derived::construct(&instance->storage, (PyObject*)instance, x)->install(raw_result); // Note the position of the internally-stored Holder, // for the sake of destruction Py_SET_SIZE(instance, offsetof(instance_t, storage)); // Release ownership of the python object protect.cancel(); } return raw_result; } }; template struct make_instance : make_instance_impl > { template static inline PyTypeObject* get_class_object(U&) { return converter::registered::converters.get_class_object(); } static inline Holder* construct(void* storage, PyObject* instance, reference_wrapper x) { return new (storage) Holder(instance, x); } }; }}} // namespace boost::python::object #endif // MAKE_INSTANCE_DWA200296_HPP