BoostOptionalWrapper.h

Go to the documentation of this file.

/*
 * Copyright (C) by
 *   MetraLabs GmbH (MLAB), GERMANY
 * and
 *   Neuroinformatics and Cognitive Robotics Labs (NICR) at TU Ilmenau, GERMANY
 * All rights reserved.
 *
 * Contact: info@mira-project.org
 *
 * Commercial Usage:
 *   Licensees holding valid commercial licenses may use this file in
 *   accordance with the commercial license agreement provided with the
 *   software or, alternatively, in accordance with the terms contained in
 *   a written agreement between you and MLAB or NICR.
 *
 * GNU General Public License Usage:
 *   Alternatively, this file may be used under the terms of the GNU
 *   General Public License version 3.0 as published by the Free Software
 *   Foundation and appearing in the file LICENSE.GPL3 included in the
 *   packaging of this file. Please review the following information to
 *   ensure the GNU General Public License version 3.0 requirements will be
 *   met: http://www.gnu.org/copyleft/gpl.html.
 *   Alternatively you may (at your option) use any later version of the GNU
 *   General Public License if such license has been publicly approved by
 *   MLAB and NICR (or its successors, if any).
 *
 * IN NO EVENT SHALL "MLAB" OR "NICR" BE LIABLE TO ANY PARTY FOR DIRECT,
 * INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES ARISING OUT OF
 * THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, EVEN IF "MLAB" OR
 * "NICR" HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 *
 * "MLAB" AND "NICR" SPECIFICALLY DISCLAIM ANY WARRANTIES, INCLUDING,
 * BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND
 * FITNESS FOR A PARTICULAR PURPOSE. THE SOFTWARE PROVIDED HEREUNDER IS
 * ON AN "AS IS" BASIS, AND "MLAB" AND "NICR" HAVE NO OBLIGATION TO
 * PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS OR MODIFICATIONS.
 */

#ifndef _MIRA_TOOLBOXES_PYTHON_BOOSTOPTIONALWRAPPER_H_
#define _MIRA_TOOLBOXES_PYTHON_BOOSTOPTIONALWRAPPER_H_

#include <python/BoostPythonWrapper.h>

namespace mira { namespace python {


template <typename T, typename TfromPy>
struct object_from_python
{
    object_from_python()
    {
        boost::python::converter::registry::push_back(&TfromPy::convertible, &TfromPy::construct, boost::python::type_id<T>());
    }
};

template <typename T, typename TtoPy, typename TfromPy>
struct register_python_conversion
{
    register_python_conversion()
    {
        boost::python::to_python_converter<T, TtoPy>();
        object_from_python<T, TfromPy>();
    }
};

template <typename T>
struct python_optional : public boost::noncopyable
{
    struct optional_to_python
    {
        static PyObject * convert(const boost::optional<T>& value)
        {
            return (value ? boost::python::incref(boost::python::object(value.get()).ptr()) : boost::python::detail::none());
        }
    };

    struct optional_from_python
    {
         static void * convertible(PyObject * source)
         {
            using namespace boost::python::converter;

            if (source == Py_None) return source;

            const registration& converters(registered<T>::converters);

            if (implicit_rvalue_convertible_from_python(source, converters))
            {
                rvalue_from_python_stage1_data data = rvalue_from_python_stage1(source, converters);
                return rvalue_from_python_stage2(source, data, converters);
            }
            return nullptr;
         }

         static void construct(PyObject * source, boost::python::converter::rvalue_from_python_stage1_data * data)
         {
            using namespace boost::python::converter;

            void * const storage = ((rvalue_from_python_storage<T> *)data)->storage.bytes;

            if (data->convertible == source)        // == None
            {
                new (storage) boost::optional<T>(); // A Boost uninitialized value
            }
            else
            {
                new (storage) boost::optional<T>(*static_cast<T *>(data->convertible));
            }

            data->convertible = storage;
         }
    };

    explicit python_optional()
    {
        register_python_conversion<boost::optional<T>, optional_to_python, optional_from_python>();
    }
};


}} // namespace

#endif