// 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)
#include 
#include 
#include 
#include 
#include 
#include 
#include 

template 
struct by_value
{
    static T rewrap(T x)
    {
        return x;
    }
    static int size(void)
    {
        return sizeof(T);
    }
};

template 
struct by_const_reference
{
    static T rewrap(T const& x)
    {
        return x;
    }
};

template 
struct by_reference
{
    static T rewrap(T& x)
    {
        return x;
    }
};

using boost::python::def;
using boost::python::handle;
using boost::python::object;
using boost::python::borrowed;

// Used to test that arbitrary handles can be returned
handle get_type(handle x)
{
    return handle(borrowed(x->ob_type));
}

handle return_null_handle()
{
    return handle();
}

char const* rewrap_value_mutable_cstring(char* x) { return x; }

object identity_(object x) { return x; }

BOOST_PYTHON_MODULE(builtin_converters_ext)
{    
    def("get_type", get_type);
    def("return_null_handle", return_null_handle);

// These methods are used solely for getting some C++ type sizes
    def("bool_size", by_value::size);
    def("char_size", by_value::size);
    def("int_size", by_value::size);
    def("short_size", by_value::size);
    def("long_size", by_value::size);
#ifdef HAVE_LONG_LONG
    def("long_long_size", by_value::size);
#endif

    def("rewrap_value_bool", by_value::rewrap);
    def("rewrap_value_char", by_value::rewrap);
    def("rewrap_value_signed_char", by_value::rewrap);
    def("rewrap_value_unsigned_char", by_value::rewrap);
    def("rewrap_value_int", by_value::rewrap);
    def("rewrap_value_unsigned_int", by_value::rewrap);
    def("rewrap_value_short", by_value::rewrap);
    def("rewrap_value_unsigned_short", by_value::rewrap);
    def("rewrap_value_long", by_value::rewrap);
    def("rewrap_value_unsigned_long", by_value::rewrap);
// using Python's macro instead of Boost's - we don't seem to get the
// config right all the time.
#ifdef HAVE_LONG_LONG
    def("rewrap_value_long_long", by_value::rewrap);
    def("rewrap_value_unsigned_long_long", by_value::rewrap);
# endif 
    def("rewrap_value_float", by_value::rewrap);
    def("rewrap_value_double", by_value::rewrap);
    def("rewrap_value_long_double", by_value::rewrap);
    def("rewrap_value_complex_float", by_value::rewrap);
    def("rewrap_value_complex_double", by_value::rewrap);
    def("rewrap_value_complex_long_double", by_value::rewrap);
    def("rewrap_value_wstring",
# if defined(BOOST_NO_STD_WSTRING) || !defined(Py_USING_UNICODE)
        identity_
# else 
        by_value::rewrap
# endif 
    );
    def("rewrap_value_string",
# if defined(BOOST_NO_STD_WSTRING) || !defined(Py_USING_UNICODE)
        identity_
# else 
        by_value::rewrap
# endif 
    );
    def("rewrap_value_string", by_value::rewrap);
    def("rewrap_value_cstring", by_value::rewrap);
    def("rewrap_value_handle", by_value::rewrap);
    def("rewrap_value_object", by_value::rewrap);

        // Expose this to illustrate our failings ;-). See test_builtin_converters.py
    def("rewrap_value_mutable_cstring", rewrap_value_mutable_cstring);


    def("rewrap_const_reference_bool", by_const_reference::rewrap);
    def("rewrap_const_reference_char", by_const_reference::rewrap);
    def("rewrap_const_reference_signed_char", by_const_reference::rewrap);
    def("rewrap_const_reference_unsigned_char", by_const_reference::rewrap);
    def("rewrap_const_reference_int", by_const_reference::rewrap);
    def("rewrap_const_reference_unsigned_int", by_const_reference::rewrap);
    def("rewrap_const_reference_short", by_const_reference::rewrap);
    def("rewrap_const_reference_unsigned_short", by_const_reference::rewrap);
    def("rewrap_const_reference_long", by_const_reference::rewrap);
    def("rewrap_const_reference_unsigned_long", by_const_reference::rewrap);
// using Python's macro instead of Boost's - we don't seem to get the
// config right all the time.
# ifdef HAVE_LONG_LONG
    def("rewrap_const_reference_long_long", by_const_reference::rewrap);
    def("rewrap_const_reference_unsigned_long_long", by_const_reference::rewrap);
# endif
    def("rewrap_const_reference_float", by_const_reference::rewrap);
    def("rewrap_const_reference_double", by_const_reference::rewrap);
    def("rewrap_const_reference_long_double", by_const_reference::rewrap);
    def("rewrap_const_reference_complex_float", by_const_reference::rewrap);
    def("rewrap_const_reference_complex_double", by_const_reference::rewrap);
    def("rewrap_const_reference_complex_long_double", by_const_reference::rewrap);
    def("rewrap_const_reference_string", by_const_reference::rewrap);
    def("rewrap_const_reference_cstring", by_const_reference::rewrap);
    def("rewrap_const_reference_handle", by_const_reference::rewrap);
    def("rewrap_const_reference_object", by_const_reference::rewrap);
    def("rewrap_reference_object", by_reference::rewrap);
}