+ patch from Dane Springmeyer improves pickling support

for mapnik.Map object ( needs some more work!!)

bindings/python/mapnik/__init__.py

@@ -241,6 +241,10 @@ class _Feature(Feature,_injector):
             attr[prop[0]] = prop[1]
         return attr
 
+class _Symbolizer(Symbolizer,_injector):
+    def symbol(self):
+        return getattr(self,self.type())()
+
 #class _Filter(Filter,_injector):
 #    """Mapnik Filter expression.
 #    

bindings/python/mapnik_python.cpp

@@ -46,6 +46,7 @@ void export_feature();
 void export_featureset();
 void export_datasource();
 void export_datasource_cache();
+void export_symbolizer();
 void export_point_symbolizer();
 void export_line_symbolizer();
 void export_line_pattern_symbolizer();
@@ -294,6 +295,7 @@ BOOST_PYTHON_MODULE(_mapnik)
     export_layer();
     export_stroke();
     export_datasource_cache();
+    export_symbolizer();
     export_point_symbolizer();
     export_line_symbolizer();
     export_line_pattern_symbolizer();
@@ -470,10 +472,6 @@ BOOST_PYTHON_MODULE(_mapnik)
     def("mapnik_svn_revision", &mapnik_svn_revision,"Get the Mapnik svn revision");
     def("has_cairo", &has_cairo, "Get cairo library status");
     def("has_pycairo", &has_pycairo, "Get pycairo module status");
-        
-    using mapnik::symbolizer;
-    class_<symbolizer>("Symbolizer",no_init)
-       ;
-    
+
     register_ptr_to_python<mapnik::filter_ptr>();
 }

bindings/python/mapnik_rule.cpp

@@ -43,9 +43,133 @@ using mapnik::raster_symbolizer;
 using mapnik::shield_symbolizer;
 using mapnik::text_symbolizer;
 using mapnik::building_symbolizer;
+using mapnik::markers_symbolizer;
 using mapnik::symbolizer;
 using mapnik::symbolizers;
 
+struct pickle_symbolizer : public boost::static_visitor<>
+{
+    public:
+        pickle_symbolizer( boost::python::list syms): 
+        syms_(syms) {}
+        
+        void operator () ( const  point_symbolizer & sym )
+        {
+            syms_.append(sym);
+        }
+    
+        void operator () ( const line_symbolizer & sym )
+        {
+            syms_.append(sym);
+        }
+    
+        void operator () ( const line_pattern_symbolizer & sym )
+        {
+            syms_.append(sym);
+        }
+    
+        void operator () ( const polygon_symbolizer & sym )
+        {
+            syms_.append(sym);
+        }
+    
+        void operator () ( const polygon_pattern_symbolizer & sym )
+        {
+            syms_.append(sym);
+        }
+    
+        void operator () ( const raster_symbolizer & sym )
+        {
+            syms_.append(sym);
+        }
+    
+        void operator () ( const shield_symbolizer & sym )
+        {
+            syms_.append(sym);
+        }
+    
+        void operator () ( const text_symbolizer & sym )
+        {
+            syms_.append(sym);
+        }
+    
+        void operator () ( const building_symbolizer & sym )
+        {
+            syms_.append(sym);
+        }
+    
+        void operator () ( markers_symbolizer const& )
+        {
+            //TODO
+        }
+
+    private:
+        boost::python::list syms_;
+
+};
+
+struct extract_symbolizer : public boost::static_visitor<>
+{
+    public:
+        extract_symbolizer( rule_type& r): 
+        r_(r) {}
+        
+        void operator () ( const  point_symbolizer & sym )
+        {
+            
+            r_.append(sym);
+        }
+    
+        void operator () ( const line_symbolizer & sym )
+        {
+            r_.append(sym);
+        }
+    
+        void operator () ( const line_pattern_symbolizer & sym )
+        {
+            r_.append(sym);
+        }
+    
+        void operator () ( const polygon_symbolizer & sym )
+        {
+            r_.append(sym);
+        }
+    
+        void operator () ( const polygon_pattern_symbolizer & sym )
+        {
+            r_.append(sym);
+        }
+    
+        void operator () ( const raster_symbolizer & sym )
+        {
+            r_.append(sym);
+        }
+    
+        void operator () ( const shield_symbolizer & sym )
+        {
+            r_.append(sym);
+        }
+    
+        void operator () ( const text_symbolizer & sym )
+        {
+            r_.append(sym);
+        }
+    
+        void operator () ( const building_symbolizer & sym )
+        {
+            r_.append(sym);
+        }
+    
+        void operator () ( markers_symbolizer const& )
+        {
+            //TODO
+        }
+
+    private:
+        rule_type& r_;
+
+};
+
 struct rule_pickle_suite : boost::python::pickle_suite
 {
    static boost::python::tuple
@@ -58,12 +182,11 @@ struct rule_pickle_suite : boost::python::pickle_suite
    getstate(const rule_type& r)
    {
         boost::python::list syms;
-        symbolizers::const_iterator it = r.begin();
-        symbolizers::const_iterator end = r.end();
-        for (; it != end; ++it)
-        {
-            syms.append( *it );    
-        }
+        
+        symbolizers::const_iterator begin = r.get_symbolizers().begin();
+        symbolizers::const_iterator end = r.get_symbolizers().end();        
+        pickle_symbolizer serializer( syms );
+        std::for_each( begin, end , boost::apply_visitor( serializer ));
         
         // Here the filter string is used rather than the actual Filter object
         // Need to look into how to get the Filter object
@@ -91,8 +214,13 @@ struct rule_pickle_suite : boost::python::pickle_suite
 
         if (state[1])
         {
-            std::string filter_expr=extract<std::string>(state[1]);
-            r.set_filter(mapnik::create_filter(filter_expr,"utf8"));
+            rule_type dfl;
+            std::string filter = extract<std::string>(state[1]);
+            std::string default_filter = dfl.get_filter()->to_string();
+            if ( filter != default_filter)
+            {
+                r.set_filter(mapnik::create_filter(filter,"utf8"));
+            }
         }    
 
         if (state[2])
@@ -101,11 +229,12 @@ struct rule_pickle_suite : boost::python::pickle_suite
         }    
         
         boost::python::list syms=extract<boost::python::list>(state[3]);
+        extract_symbolizer serializer( r );
         for (int i=0;i<len(syms);++i)
         {
-            r.append(extract<symbolizer>(syms[i]));
-        }
-        
+            symbolizer symbol = extract<symbolizer>(syms[i]);
+            boost::apply_visitor( serializer, symbol );
+        }        
    }
 
 };
@@ -130,8 +259,7 @@ void export_rule()
     class_<rule_type>("Rule",init<>("default constructor"))
         .def(init<std::string const&,
              boost::python::optional<std::string const&,double,double> >())
-        .def_pickle(rule_pickle_suite()
-           )
+        .def_pickle(rule_pickle_suite())
         .add_property("name",make_function
                       (&rule_type::get_name,
                        return_value_policy<copy_const_reference>()),

bindings/python/mapnik_symbolizer.cpp

@@ -0,0 +1,197 @@
+/*****************************************************************************
+ * 
+ * This file is part of Mapnik (c++ mapping toolkit)
+ *
+ * Copyright (C) 2006 Artem Pavlenko, Jean-Francois Doyon
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+ *
+ *****************************************************************************/
+//$Id$
+
+#include <boost/python.hpp>
+
+//symbolizer typdef here rather than mapnik/symbolizer.hpp
+#include <mapnik/rule.hpp>
+
+using mapnik::symbolizer;
+
+using mapnik::rule_type;
+using mapnik::point_symbolizer;
+using mapnik::line_symbolizer;
+using mapnik::line_pattern_symbolizer;
+using mapnik::polygon_symbolizer;
+using mapnik::polygon_pattern_symbolizer;
+using mapnik::raster_symbolizer;
+using mapnik::shield_symbolizer;
+using mapnik::text_symbolizer;
+using mapnik::building_symbolizer;
+using mapnik::markers_symbolizer;
+
+struct get_symbolizer_type : public boost::static_visitor<std::string>
+{
+    public:
+        get_symbolizer_type() {}
+        
+        std::string operator () ( const  point_symbolizer & sym )
+        {
+            return "point";
+        }
+    
+        std::string operator () ( const line_symbolizer & sym )
+        {
+            return "line";
+        }
+    
+        std::string operator () ( const line_pattern_symbolizer & sym )
+        {
+            return "line_pattern";
+        }
+    
+        std::string operator () ( const polygon_symbolizer & sym )
+        {
+            return "polygon";
+        }
+    
+        std::string operator () ( const polygon_pattern_symbolizer & sym )
+        {
+            return "polygon_pattern";
+        }
+    
+        std::string operator () ( const raster_symbolizer & sym )
+        {
+            return "raster";
+        }
+    
+        std::string operator () ( const shield_symbolizer & sym )
+        {
+            return "shield";
+        }
+    
+        std::string operator () ( const text_symbolizer & sym )
+        {
+            return "text";
+        }
+    
+        std::string operator () ( const building_symbolizer & sym )
+        {
+            return "building";
+        }
+    
+        std::string operator () ( const markers_symbolizer & sym )
+        {
+            return "markers";
+        }
+
+};
+
+std::string get_symbol_type(const symbolizer& symbol)
+{
+   get_symbolizer_type serializer;
+   std::string type = boost::apply_visitor( serializer, symbol );
+   return type;
+}
+
+const point_symbolizer& point_( const symbolizer& symbol )
+{
+    return boost::get<point_symbolizer>(symbol);
+}
+
+const line_symbolizer& line_( const symbolizer& symbol )
+{
+    return boost::get<line_symbolizer>(symbol);
+}
+
+const polygon_symbolizer& polygon_( const symbolizer& symbol )
+{
+    return boost::get<polygon_symbolizer>(symbol);
+}
+
+const raster_symbolizer& raster_( const symbolizer& symbol )
+{
+    return boost::get<raster_symbolizer>(symbol);
+}
+
+const text_symbolizer& text_( const symbolizer& symbol )
+{
+    return boost::get<text_symbolizer>(symbol);
+}
+
+const shield_symbolizer& shield_( const symbolizer& symbol )
+{
+    return boost::get<shield_symbolizer>(symbol);
+}
+
+const line_pattern_symbolizer& line_pattern_( const symbolizer& symbol )
+{
+    return boost::get<line_pattern_symbolizer>(symbol);
+}
+
+const polygon_pattern_symbolizer& polygon_pattern_( const symbolizer& symbol )
+{
+    return boost::get<polygon_pattern_symbolizer>(symbol);
+}
+
+const building_symbolizer& building_( const symbolizer& symbol )
+{
+    return boost::get<building_symbolizer>(symbol);
+}
+
+const markers_symbolizer& markers_( const symbolizer& symbol )
+{
+    return boost::get<markers_symbolizer>(symbol);
+}
+
+void export_symbolizer()
+{
+    using namespace boost::python;
+
+    class_<symbolizer>("Symbolizer",no_init)
+
+        .def("type",get_symbol_type)
+
+        .def("point",point_,
+            return_value_policy<copy_const_reference>())
+
+        .def("line",line_,
+            return_value_policy<copy_const_reference>())
+
+        .def("line_pattern",line_pattern_,
+            return_value_policy<copy_const_reference>())
+
+        .def("polygon",polygon_,
+            return_value_policy<copy_const_reference>())
+
+        .def("polygon_pattern",polygon_pattern_,
+            return_value_policy<copy_const_reference>())
+
+        .def("raster",raster_,
+            return_value_policy<copy_const_reference>())
+
+        .def("shield",shield_,
+            return_value_policy<copy_const_reference>())
+
+        .def("text",text_,
+            return_value_policy<copy_const_reference>())
+
+        .def("building",building_,
+            return_value_policy<copy_const_reference>())
+
+        .def("markers",markers_,
+            return_value_policy<copy_const_reference>())
+
+    ;
+}
+