Reflect mapnik::parameters + save_map_to_string() [WIP] [skip ci]

artemp · artemp · commit 91a878ca778b · 2024-05-23T08:49:58.000+01:00
diff --git a/setup.py b/setup.py
@@ -86,6 +86,7 @@ def check_output(args):
                "src/mapnik_logger.cpp",
                "src/mapnik_placement_finder.cpp",
                "src/mapnik_text_symbolizer.cpp",
+               "src/mapnik_parameters.cpp",
           ],
           extra_compile_args=extra_comp_args,
           extra_link_args=linkflags,
diff --git a/src/mapnik_map.cpp b/src/mapnik_map.cpp
@@ -29,6 +29,7 @@
 #include <mapnik/projection.hpp>
 #include <mapnik/view_transform.hpp>
 #include <mapnik/feature_type_style.hpp>
+#include "mapnik_value_converter.hpp"
 #include "python_optional.hpp"
 //pybind11
 #include <pybind11/pybind11.h>
@@ -46,11 +47,12 @@ using mapnik::Map;
 
 PYBIND11_MAKE_OPAQUE(std::vector<mapnik::layer>);
 PYBIND11_MAKE_OPAQUE(std::map<std::string, mapnik::feature_type_style>);
-
+PYBIND11_MAKE_OPAQUE(mapnik::parameters);
 
 namespace {
 std::vector<layer>& (Map::*set_layers)() =  &Map::layers;
 std::vector<layer> const& (Map::*get_layers)() const =  &Map::layers;
+mapnik::parameters const& (Map::*params_const)() const =  &Map::get_extra_parameters;
 mapnik::parameters& (Map::*params_nonconst)() =  &Map::get_extra_parameters;
 
 void insert_style(mapnik::Map & m, std::string const& name, mapnik::feature_type_style const& style)
@@ -368,8 +370,10 @@ void export_map(py::module const& m)
              ">>> m.zoom_to_box(extent)\n",
              py::arg("bounding_box")
             )
-
-        //.add_property("parameters",make_function(params_nonconst,return_value_policy<reference_existing_object>()),"TODO")
+        .def_property("parameters",
+                      params_const,
+                      params_nonconst,
+                      "extra parameters")
 
         .def_property("aspect_fix_mode",
                       &Map::get_aspect_fix_mode,
diff --git a/src/mapnik_parameters.cpp b/src/mapnik_parameters.cpp
@@ -27,213 +27,18 @@
 #include <mapnik/unicode.hpp>
 #include <mapnik/value.hpp>
 #include <mapnik/value/types.hpp>
-// stl
-#include <iterator>
+#include "mapnik_value_converter.hpp"
 //pybind11
 #include <pybind11/pybind11.h>
-
+#include <pybind11/stl.h>
+#include <pybind11/stl_bind.h>
 namespace py = pybind11;
 
 using mapnik::parameter;
 using mapnik::parameters;
 
-struct parameter_pickle_suite : boost::python::pickle_suite
-{
-    static boost::python::tuple
-    getinitargs(const parameter& p)
-    {
-        using namespace boost::python;
-        return boost::python::make_tuple(p.first,p.second);
-    }
-};
-
-struct parameters_pickle_suite : boost::python::pickle_suite
-{
-    static boost::python::tuple
-    getstate(const parameters& p)
-    {
-        using namespace boost::python;
-        dict d;
-        parameters::const_iterator pos=p.begin();
-        while(pos!=p.end())
-        {
-            d[pos->first] = pos->second;
-            ++pos;
-        }
-        return boost::python::make_tuple(d);
-    }
-
-    static void setstate(parameters& p, boost::python::tuple state)
-    {
-        using namespace boost::python;
-        if (len(state) != 1)
-        {
-            PyErr_SetObject(PyExc_ValueError,
-                            ("expected 1-item tuple in call to __setstate__; got %s"
-                             % state).ptr()
-                );
-            throw_error_already_set();
-        }
-
-        dict d = extract<dict>(state[0]);
-        boost::python::list keys = d.keys();
-        for (int i=0; i<len(keys); ++i)
-        {
-            std::string key = extract<std::string>(keys[i]);
-            object obj = d[key];
-            extract<std::string> ex0(obj);
-            extract<mapnik::value_integer> ex1(obj);
-            extract<double> ex2(obj);
-            extract<mapnik::value_unicode_string> ex3(obj);
-
-            // TODO - this is never hit - we need proper python string -> std::string to get invoked here
-            if (ex0.check())
-            {
-                p[key] = ex0();
-            }
-            else if (ex1.check())
-            {
-                p[key] = ex1();
-            }
-            else if (ex2.check())
-            {
-                p[key] = ex2();
-            }
-            else if (ex3.check())
-            {
-                std::string buffer;
-                mapnik::to_utf8(ex3(),buffer);
-                p[key] = buffer;
-            }
-            else
-            {
-                MAPNIK_LOG_DEBUG(bindings) << "parameters_pickle_suite: Could not unpickle key=" << key;
-            }
-        }
-    }
-};
-
-
-mapnik::value_holder get_params_by_key1(mapnik::parameters const& p, std::string const& key)
-{
-    parameters::const_iterator pos = p.find(key);
-    if (pos != p.end())
-    {
-        // will be auto-converted to proper python type by `mapnik_params_to_python`
-        return pos->second;
-    }
-    return mapnik::value_null();
-}
-
-mapnik::value_holder get_params_by_key2(mapnik::parameters const& p, std::string const& key)
-{
-    parameters::const_iterator pos = p.find(key);
-    if (pos == p.end())
-    {
-        PyErr_SetString(PyExc_KeyError, key.c_str());
-        boost::python::throw_error_already_set();
-    }
-    // will be auto-converted to proper python type by `mapnik_params_to_python`
-    return pos->second;
-}
-
-mapnik::parameter get_params_by_index(mapnik::parameters const& p, int index)
-{
-    if (index < 0 || static_cast<unsigned>(index) > p.size())
-    {
-        PyErr_SetString(PyExc_IndexError, "Index is out of range");
-        throw boost::python::error_already_set();
-    }
-
-    parameters::const_iterator itr = p.begin();
-    std::advance(itr, index);
-    if (itr != p.end())
-    {
-        return *itr;
-    }
-    PyErr_SetString(PyExc_IndexError, "Index is out of range");
-    throw boost::python::error_already_set();
-}
-
-std::size_t get_params_size(mapnik::parameters const& p)
-{
-    return p.size();
-}
-
-void add_parameter(mapnik::parameters & p, mapnik::parameter const& param)
-{
-    p[param.first] = param.second;
-}
-
-mapnik::value_holder get_param(mapnik::parameter const& p, int index)
-{
-    if (index == 0)
-    {
-        return p.first;
-    }
-    else if (index == 1)
-    {
-        return p.second;
-    }
-    else
-    {
-        PyErr_SetString(PyExc_IndexError, "Index is out of range");
-        throw boost::python::error_already_set();
-    }
-}
-
-std::shared_ptr<mapnik::parameter> create_parameter(mapnik::value_unicode_string const& key, mapnik::value_holder const& value)
-{
-    std::string key_utf8;
-    mapnik::to_utf8(key, key_utf8);
-    return std::make_shared<mapnik::parameter>(key_utf8,value);
-}
-
-bool contains(mapnik::parameters const& p, std::string const& key)
-{
-    parameters::const_iterator pos = p.find(key);
-    return pos != p.end();
-}
-
-// needed for Python_Unicode to std::string (utf8) conversion
-
-std::shared_ptr<mapnik::parameter> create_parameter_from_string(mapnik::value_unicode_string const& key, mapnik::value_unicode_string const& ustr)
-{
-    std::string key_utf8;
-    std::string ustr_utf8;
-    mapnik::to_utf8(key, key_utf8);
-    mapnik::to_utf8(ustr,ustr_utf8);
-    return std::make_shared<mapnik::parameter>(key_utf8, ustr_utf8);
-}
 
-void export_parameters()
+void export_parameters(py::module const& m)
 {
-    using namespace boost::python;
-    implicitly_convertible<std::string,mapnik::value_holder>();
-    implicitly_convertible<mapnik::value_null,mapnik::value_holder>();
-    implicitly_convertible<mapnik::value_integer,mapnik::value_holder>();
-    implicitly_convertible<mapnik::value_double,mapnik::value_holder>();
-
-    class_<parameter,std::shared_ptr<parameter> >("Parameter",no_init)
-        .def("__init__", make_constructor(create_parameter),
-             "Create a mapnik.Parameter from a pair of values, the first being a string\n"
-             "and the second being either a string, and integer, or a float")
-        .def("__init__", make_constructor(create_parameter_from_string),
-             "Create a mapnik.Parameter from a pair of values, the first being a string\n"
-             "and the second being either a string, and integer, or a float")
-
-        .def_pickle(parameter_pickle_suite())
-        .def("__getitem__",get_param)
-        ;
-
-    class_<parameters>("Parameters",init<>())
-        .def_pickle(parameters_pickle_suite())
-        .def("get",get_params_by_key1)
-        .def("__getitem__",get_params_by_key2)
-        .def("__getitem__",get_params_by_index)
-        .def("__len__",get_params_size)
-        .def("__contains__",contains)
-        .def("append",add_parameter)
-        .def("iteritems",iterator<parameters>())
-        ;
+    py::bind_map<mapnik::parameters>(m, "Parameters", py::module_local());
 }
diff --git a/src/mapnik_python.cpp b/src/mapnik_python.cpp
@@ -612,6 +612,7 @@ void export_style(py::module const&);
 void export_logger(py::module const&);
 void export_placement_finder(py::module const&);
 void export_text_symbolizer(py::module const&);
+void export_parameters(py::module const&);
 
 using mapnik::load_map;
 using mapnik::load_map_string;
@@ -647,6 +648,7 @@ PYBIND11_MODULE(_mapnik, m) {
     export_logger(m);
     export_placement_finder(m);
     export_text_symbolizer(m);
+    export_parameters(m);
 
     m.def("mapnik_version", &mapnik_version,"Get the Mapnik version number");
     m.def("mapnik_version_string", &mapnik_version_string,"Get the Mapnik version string");
@@ -801,6 +803,10 @@ PYBIND11_MODULE(_mapnik, m) {
           py::arg("filename"),
           py::arg("explicit_defaults") = false);
 
+    m.def("save_map_to_string", &save_map_to_string,
+          py::arg("Map"),
+          py::arg("explicit_defaults") = false);
+
     m.def("clear_cache", &clear_cache,
           "\n"
           "Clear all global caches of markers and mapped memory regions.\n"
diff --git a/test/python_tests/extra_map_props_test.py b/test/python_tests/extra_map_props_test.py
@@ -21,8 +21,8 @@ def test_arbitrary_parameters_attached_to_map(setup):
     assert m.parameters['integer'] ==  10
     assert m.parameters['decimal'] ==  .999
     m2 = mapnik.Map(256, 256)
-    for k, v in m.parameters:
-        m2.parameters.append(mapnik.Parameter(k, v))
+    for k, v in m.parameters.items():
+        m2.parameters[k] = v
     assert len(m2.parameters) ==  5
     assert m2.parameters['key'] ==  'value2'
     assert m2.parameters['key3'] ==  'value3'
@@ -42,8 +42,8 @@ def test_arbitrary_parameters_attached_to_map(setup):
 
 def test_serializing_arbitrary_parameters():
     m = mapnik.Map(256, 256)
-    m.parameters.append(mapnik.Parameter('width', m.width))
-    m.parameters.append(mapnik.Parameter('height', m.height))
+    m.parameters['width'] =  m.width
+    m.parameters['height'] = m.height
 
     m2 = mapnik.Map(1, 1)
     mapnik.load_map_from_string(m2, mapnik.save_map_to_string(m))
diff --git a/test/python_tests/parameters_test.py b/test/python_tests/parameters_test.py
@@ -2,51 +2,45 @@
 import mapnik
 
 def test_parameter_null():
-    p = mapnik.Parameter('key', None)
-    assert p[0] ==  'key'
-    assert p[1] ==  None
+    p = mapnik.Parameters()
+    p['key'] = None
+    assert p['key'] is None
 
 
 def test_parameter_string():
-    p = mapnik.Parameter('key', 'value')
-    assert p[0] ==  'key'
-    assert p[1] ==  'value'
+    p = mapnik.Parameters()
+    p['key'] = 'value'
+    assert p['key'] == 'value'
 
 
 def test_parameter_unicode():
-    p = mapnik.Parameter('key', u'value')
-    assert p[0] ==  'key'
-    assert p[1] ==  u'value'
+    p = mapnik.Parameters()
+    p['key'] =  u'value'
+    assert p['key'] ==  u'value'
 
 
 def test_parameter_integer():
-    p = mapnik.Parameter('int', sys.maxsize)
-    assert p[0] ==  'int'
-    assert p[1] ==  sys.maxsize
+    p = mapnik.Parameters()
+    p['int'] = sys.maxsize
+    assert p['int'] ==  sys.maxsize
 
 
 def test_parameter_double():
-    p = mapnik.Parameter('double', float(sys.maxsize))
-    assert p[0] ==  'double'
-    assert p[1] ==  float(sys.maxsize)
+    p = mapnik.Parameters()
+    p['double'] = float(sys.maxsize)
+    assert p['double'] ==  float(sys.maxsize)
 
 
 def test_parameter_boolean():
-    p = mapnik.Parameter('boolean', True)
-    assert p[0] ==  'boolean'
-    assert p[1] ==  True
-    assert bool(p[1]) ==  True
+    p = mapnik.Parameters()
+    p['boolean'] = True
+    assert p['boolean'] ==  True
+    assert bool(p['boolean']) ==  True
 
 
 def test_parameters():
-    params = mapnik.Parameters()
-    p = mapnik.Parameter('float', 1.0777)
-    assert p[0] ==  'float'
-    assert p[1] ==  1.0777
-
-    params.append(p)
-
-    assert params[0][0] ==  'float'
-    assert params[0][1] ==  1.0777
-
-    assert params.get('float') ==  1.0777
+    p = mapnik.Parameters()
+    p['float'] = 1.0777
+    p['int'] = 123456789
+    assert p['float'] == 1.0777
+    assert p['int'] == 123456789
