PythonStdSetUtils.h

Go to the documentation of this file.

// PythonStdSetUtils.h:
// --------------------
//

#ifndef __PYIPSDKBASE_PYTHONSTDSETUTILS_H__
#define __PYIPSDKBASE_PYTHONSTDSETUTILS_H__

#include <set>
#include <boost/python/iterator.hpp>
#include <boost/python/self.hpp>
#include <boost/python/operators.hpp>
#include <boost/utility/enable_if.hpp>
#include <boost/type_traits/is_base_of.hpp>

namespace ipsdk {
namespace python {


// std::set to py set wrapper
template<class KeyType>
class py_set : public std::set<KeyType>, public boost::python::wrapper<std::set<KeyType> >
{
public:
    // some typedefs for convinience
    typedef std::set<KeyType> source_type;
    typedef py_set<KeyType> wrap_type;

    // constructors
    py_set<KeyType>() {
    }
    py_set<KeyType>(const source_type& s) {
        this->insert(s.begin(), s.end());
    }

    // element access
    bool contains(const KeyType key) {
        return this->count(key)>0;
    }

    // we must define add() for it gets explicit argument types
    bool add(const KeyType key) {
        return this->insert(key).second;
    }

    bool remove(const KeyType key) {
        if (!this->contains(key))
            return false;
        this->erase(key);
        return true;
    }

    // set operations
    source_type set_union(wrap_type &other) {
        source_type result;
        std::set_union(this->begin(), this->end(), other.begin(), other.end(),
            inserter(result, result.begin()));
        return result;
    }

    source_type set_intersection(wrap_type &other) {
        source_type result;
        std::set_intersection(this->begin(), this->end(), other.begin(), other.end(),
            inserter(result, result.begin()));
        return result;
    }

    source_type set_difference(wrap_type &other) {
        source_type result;
        std::set_difference(this->begin(), this->end(), other.begin(), other.end(),
            inserter(result, result.begin()));
        return result;
    }

    source_type set_symmetric_difference(wrap_type &other) {
        source_type result;
        std::set_symmetric_difference(this->begin(), this->end(), other.begin(), other.end(),
            inserter(result, result.begin()));
        return result;
    }

    // create string associated to object
    static std::string to_string(const std::set<KeyType>& cl)
    {
        typedef std::set<KeyType> Container;
        std::stringstream ss;
        ss << "[";
        bool first = true;
        for (typename Container::const_iterator
            i = cl.begin(), e = cl.end(); i != e; ++i) {
            if (first) {
                first = false;
            }
            else {
                ss << ", ";
            }
            const KeyType& curKey = *i;
            ss << curKey;
        }
        ss << "]";
        return ss.str();
    }
};

inline void block_hashing(boost::python::object) {
    // do something more intelligent here
    throw "objects of this type are unhashable";
}

// export mutable set
template<class KeyType> void
export_set(const char* py_name) {

    typedef py_set<KeyType> set_T;

    boost::python::class_<set_T >(py_name, "mutable set")
        .def("__len__", &set_T::size)
        .def("__contains__", &set_T::contains)
        .def("add", &set_T::add, "add element")
        .def("__delitem__", &set_T::remove)
        .def("remove", &set_T::remove, "remove element")
        .def("__iter__", boost::python::iterator<set_T>())
        .def("__hash__", &block_hashing)
        .def("union", &set_T::set_union, "set union")
        .def("__or__", &set_T::set_union, "set union")
        .def("intersection", &set_T::set_intersection, "set intersection")
        .def("__and__", &set_T::set_intersection, "set intersection")
        .def("difference", &set_T::set_difference, "elements not in second set")
        .def("__sub__", &set_T::set_difference, "set difference")
        .def("symmetric_difference", &set_T::set_symmetric_difference, "elements unique to either set")
        .def("__xor__", &set_T::set_symmetric_difference, "symmetric set difference")
        .def("__str__", &set_T::to_string)
        ;

    boost::python::implicitly_convertible<py_set<KeyType>, std::set<KeyType> >();
    boost::python::implicitly_convertible<std::set<KeyType>, py_set<KeyType> >();
}


} // end of namespace python
} // end of namespace ipsdk

#endif // __PYIPSDKBASE_PYTHONSTDSETUTILS_H__