PropertyManager.hh

#ifndef OPENMESH_PYTHON_PROPERTYMANAGER_HH
#define OPENMESH_PYTHON_PROPERTYMANAGER_HH

#include "Python/Bindings.hh"
#include "OpenMesh/Core/Utils/PropertyManager.hh"

namespace OpenMesh {
namespace Python {

BOOST_PYTHON_MEMBER_FUNCTION_OVERLOADS(retain_overloads, retain, 0, 1)


template <class PropertyManager, class IndexHandle>
object propman_get_item(PropertyManager& _self, IndexHandle _handle) {
        return _self[_handle];
}

template <class PropertyManager, class IndexHandle>
void propman_set_item(PropertyManager& _self, IndexHandle _handle, object _value) {
        _self[_handle] = _value;
}

template <class PropertyManager, class Iterator>
void propman_set_range(PropertyManager& _self, Iterator _it, object _value) {
        try {
                while (true) {
                        _self[_it.next()] = _value;
                }
        }
        catch (error_already_set exception) {
                // This is expected behavior
                PyErr_Clear();
        }
}

template <class PropertyManager, class Mesh>
bool property_exists(Mesh& _mesh, const char *_propname) {
        return PropertyManager::propertyExists(_mesh, _propname);
}

template <class PropHandle, class IndexHandle, class Iterator>
void expose_property_manager(const char *_name) {
        // Convenience typedef
        typedef PropertyManager<PropHandle, PolyConnectivity> PropertyManager;

        // Function pointers
        void (PropertyManager::*retain)(bool) = &PropertyManager::retain;

        object (*getitem)(PropertyManager&, IndexHandle        ) = &propman_get_item;
        void   (*setitem)(PropertyManager&, IndexHandle, object) = &propman_set_item;

        void (*set_range)(PropertyManager&, Iterator, object) = &propman_set_range;

        bool (*property_exists_poly)(PolyMesh&, const char *) = &property_exists<PropertyManager, PolyMesh>;
        bool (*property_exists_tri )(TriMesh&,  const char *) = &property_exists<PropertyManager, TriMesh >;

        // Expose property manager
        class_<PropertyManager, boost::noncopyable>(_name)
                .def(init<PolyMesh&, const char *, optional<bool> >()[with_custodian_and_ward<1,2>()])
                .def(init<TriMesh&,  const char *, optional<bool> >()[with_custodian_and_ward<1,2>()])

                .def("swap", &PropertyManager::swap)
                .def("is_valid", &PropertyManager::isValid)

                .def("__bool__", &PropertyManager::operator bool)
                .def("__nonzero__", &PropertyManager::operator bool)

                .def("get_raw_property", &PropertyManager::getRawProperty, return_value_policy<copy_const_reference>())
                .def("get_name", &PropertyManager::getName, return_value_policy<copy_const_reference>())
                .def("get_mesh", &PropertyManager::getMesh, return_value_policy<reference_existing_object>())

                .def("retain", retain, retain_overloads())

                .def("__getitem__", getitem)
                .def("__setitem__", setitem)

                .def("set_range", set_range)

                .def("property_exists", property_exists_poly)
                .def("property_exists", property_exists_tri)
                .staticmethod("property_exists")
                ;
}

} // namespace OpenMesh
} // namespace Python

#endif