// Copyright David Abrahams 2001. Permission to copy, use,
// modify, sell and distribute this software is granted provided this
// copyright notice appears in all copies. This software is provided
// "as is" without express or implied warranty, and with no claim as
// to its suitability for any purpose.

// This module exercises the converters exposed in m1 at a low level
// by exposing raw Python extension functions that use wrap<> and
// unwrap<> objects.

// Seems to be neccessary to suppress an ICE with MSVC
#include <boost/mpl/comparison/less.hpp>

#include <boost/python/convert.hpp>
#include <boost/python/module.hpp>
#include "simple_type.hpp"

using boost::python::wrap;
using boost::python::unwrap;

extern "C"
{
    // Get a simple (by value) from the argument, and return the
    // string it holds.
    PyObject*
    unwrap_simple(PyObject* self, PyObject* args)
    {
        PyObject* p;
        if (!PyArg_ParseTuple(args, "O", &p))
            return 0;

        boost::python::unwrap<simple> in(p);
        if (!in)
            return 0;
    
        simple x = *in;
    
        return PyString_FromString(x.s);
    }

    // Likewise, but demands that its possible to get a non-const
    // reference to the simple.
    PyObject*
    unwrap_simple_ref(PyObject* self, PyObject* args)
    {
        PyObject* p;
        if (!PyArg_ParseTuple(args, "O", &p))
            return 0;

        unwrap<simple&> in(p);
        if (!in)
            return 0;
    
        simple& x = *in;
    
        return PyString_FromString(x.s);
    }

    // Likewise, with a const reference to the simple object.
    PyObject*
    unwrap_simple_const_ref(PyObject* self, PyObject* args)
    {
        PyObject* p;
        if (!PyArg_ParseTuple(args, "O", &p))
            return 0;
    
        unwrap<simple const&> in(p);
        if (!in)
            return 0;
    
        simple const& x = *in;
    
        return PyString_FromString(x.s);
    }

    // Get an int (by value) from the argument, and convert it to a
    // Python Int.
    PyObject*
    unwrap_int(PyObject* self, PyObject* args)
    {
        PyObject* p;
        if (!PyArg_ParseTuple(args, "O", &p))
            return 0;
    
        unwrap<int> in(p);
        if (!in)
            return 0;
    
        int x = *in;
    
        return PyInt_FromLong(x);
    }

    // Get a non-const reference to an int from the argument
    PyObject*
    unwrap_int_ref(PyObject* self, PyObject* args)
    {
        PyObject* p;
        if (!PyArg_ParseTuple(args, "O", &p))
            return 0;
    
        unwrap<int&> in(p);
        if (!in)
            return 0;
    
        int& x = *in;
    
        return PyInt_FromLong(x);
    }

    // Get a const reference to an  int from the argument.
    PyObject*
    unwrap_int_const_ref(PyObject* self, PyObject* args)
    {
        PyObject* p;
        if (!PyArg_ParseTuple(args, "O", &p))
            return 0;
    
        unwrap<int&> in(p);
        if (!in)
            return 0;
    
        int const& x = *in;
    
        return PyInt_FromLong(x);
    }

    // -------------------
}

// MSVC6 bug workaround
template <class T> struct xxxx;

// rewrap<T> extracts a T from the argument, then converts the T back
// to a PyObject* and returns it.
template <class T>
PyObject*
rewrap(PyObject* self, PyObject* args, xxxx<T>* = 0)
{
    PyObject* p;
    if (!PyArg_ParseTuple(args, "O", &p))
        return 0;

    boost::python::unwrap<T> in(p);
    if (!in)
        return 0;

    boost::python::wrap<T> out;
    if (!out)
        return 0;
    
    T x = *in;
    return out(x);
}

extern "C"
{
    //
    // Use rewrap<T> to test simple, simple&, simple const&, int,
    // int&, int const&
    //
    PyObject*
    wrap_simple(PyObject* self, PyObject* args)
    {
        return rewrap<simple>(self, args);
    }

    PyObject*
    wrap_simple_ref(PyObject* self, PyObject* args)
    {
        return rewrap<simple&>(self, args);
    }

    PyObject*
    wrap_simple_const_ref(PyObject* self, PyObject* args)
    {
        return rewrap<simple const&>(self, args);
    }

    PyObject*
    wrap_int(PyObject* self, PyObject* args)
    {
        return rewrap<int>(self, args);
    }

    PyObject*
    wrap_int_ref(PyObject* self, PyObject* args)
    {
        return rewrap<int&>(self, args);
    }

    PyObject*
    wrap_int_const_ref(PyObject* self, PyObject* args)
    {
        return rewrap<int const&>(self, args);
    }
}

PyMethodDef initial_methods[] =
{
    { "unwrap_int", unwrap_int, METH_VARARGS, 0 },
    { "unwrap_int_ref", unwrap_int_ref, METH_VARARGS, 0 },
    { "unwrap_int_const_ref", unwrap_int_const_ref, METH_VARARGS, 0 },
    { "unwrap_simple", unwrap_simple, METH_VARARGS, 0 },
    { "unwrap_simple_ref", unwrap_simple_ref, METH_VARARGS, 0 },
    { "unwrap_simple_const_ref", unwrap_simple_const_ref, METH_VARARGS, 0 },

    { "wrap_int", wrap_int, METH_VARARGS, 0 },
    { "wrap_int_ref", wrap_int_ref, METH_VARARGS, 0 },
    { "wrap_int_const_ref", wrap_int_const_ref, METH_VARARGS, 0 },
    { "wrap_simple", wrap_simple, METH_VARARGS, 0 },
    { "wrap_simple_ref", wrap_simple_ref, METH_VARARGS, 0 },
    { "wrap_simple_const_ref", wrap_simple_const_ref, METH_VARARGS, 0 },
    { 0, 0, 0, 0 }
};

BOOST_PYTHON_MODULE_INIT(m2)
{
    Py_InitModule(const_cast<char*>("m2"), initial_methods);
}

#include "module_tail.cpp"