PythonSet.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.
 *
 * Redistribution and modification of this code is strictly prohibited.
 *
 * 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_PYTHONSET_H_
#define _MIRA_TOOLBOXES_PYTHON_PYTHONSET_H_

#include <set>
#include <Python.h>

#include <python/BoostPythonWrapper.h>

#include <error/Exceptions.h>

namespace mira { namespace python {


template<typename type>
struct PythonSetAccessor {
    using SetType = std::set<type>;
    static std::string str(const SetType& s) {
        std::stringstream ss;
        ss << '[';
        bool first = true;
        for(const auto& e : s) {
            if (!first)
                ss << ", ";
            first = false;
            ss << e;
            if(ss.fail())
                MIRA_THROW(XIO, "Failed to convert value into a string");
        }
        ss << ']';
        return ss.str();
    }

    static int size(const SetType& s) {
        return s.size();
    }

    static bool contains(const SetType& s, const type& key) {
        return s.count(key)>0; // s.contains(key) available since C++20 only
    }

    static void add(SetType& s, type key) {
        s.insert(std::move(key));
    }

    static void remove(SetType& s, const type& key) {
        if (!contains(s, key))
            MIRA_THROW(XAssertion, "Element not in set");
        s.erase(key);
    }

    static SetType set_union(const SetType& s, const SetType& other)
    {
        SetType result;
        std::set_union(s.begin(), s.end(), other.begin(), other.end(),
                       inserter(result, result.begin()));
        return result;
    }

    static SetType set_intersection(const SetType& s, const SetType& other)
    {
        SetType result;
        std::set_intersection(s.begin(), s.end(), other.begin(), other.end(),
                              inserter(result, result.begin()));
        return result;
    }

    static SetType set_difference(const SetType& s, const SetType& other)
    {
        SetType result;
        std::set_difference(s.begin(), s.end(), other.begin(), other.end(),
                            inserter(result, result.begin()));
        return result;
    }

    static SetType set_symmetric_difference(const SetType& s, const SetType& other)
    {
        SetType result;
        std::set_symmetric_difference(s.begin(), s.end(), other.begin(), other.end(),
                                      inserter(result, result.begin()));
        return result;
    }
};

inline void block_hashing(boost::python::object)
{
    MIRA_THROW(XInvalidParameter, "objects of type python object are unhashable");
}

#define MIRA_PYTHONCONNECTOR_PYTHONSET_FUNCTIONS(type, name, footerfunctions)                                             \
    class_<std::set<type> >(name, "mutable set")                                                                          \
        .def("__repr__",             &PythonSetAccessor<type>::str)                                                       \
        .def("__len__",              &PythonSetAccessor<type>::size)                                                      \
        .def("__contains__",         &PythonSetAccessor<type>::contains)                                                  \
        .def("add",                  &PythonSetAccessor<type>::add, "add element")                                        \
        .def("__delitem__",          &PythonSetAccessor<type>::remove)                                                    \
        .def("remove",               &PythonSetAccessor<type>::remove, "remove element")                                  \
        .def("__iter__",             boost::python::iterator<std::set<type> >())                                          \
        .def("__hash__",             block_hashing)                                                                       \
        .def("union",                &PythonSetAccessor<type>::set_union, "set union")                                    \
        .def("__or__",               &PythonSetAccessor<type>::set_union, "set union")                                    \
        .def("intersection",         &PythonSetAccessor<type>::set_intersection, "set intersection")                      \
        .def("__and__",              &PythonSetAccessor<type>::set_intersection, "set intersection")                      \
        .def("difference",           &PythonSetAccessor<type>::set_difference, "elements not in second set")              \
        .def("__sub__",              &PythonSetAccessor<type>::set_difference, "set difference")                          \
        .def("symmetric_difference", &PythonSetAccessor<type>::set_symmetric_difference, "elements unique to either set") \
        .def("__xor__",              &PythonSetAccessor<type>::set_symmetric_difference, "symmetric set difference")      \
        footerfunctions;


}} // namespace

#endif