Changeset 1342

Timestamp:

10/19/09 10:22:11 (9 months ago)

Author:

artem

Message:

+ patch from Dane Springmeyer improves pickling support

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

Location:

trunk/bindings/python

Files:

• mapnik/__init__.py (modified) (1 diff)
• mapnik_python.cpp (modified) (3 diffs)
• mapnik_rule.cpp (modified) (5 diffs)
• mapnik_symbolizer.cpp (added)

trunk/bindings/python/mapnik/__init__.py

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

trunk/bindings/python/mapnik_python.cpp

@@ -47 +47 @@
 void export_datasource();
 void export_datasource_cache();
+void export_symbolizer();
 void export_point_symbolizer();
 void export_line_symbolizer();
@@ -295 +296 @@
     export_stroke();
     export_datasource_cache();
+    export_symbolizer();
     export_point_symbolizer();
     export_line_symbolizer();
@@ -471 +473 @@
     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>();
 }

trunk/bindings/python/mapnik_rule.cpp

@@ -44 +44 @@
 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
@@ -59 +183 @@
    {
         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
@@ -92 +215 @@
         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"));
+            }
         }    
 
@@ -102 +230 @@
         
         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 );
+        }        
    }
 
@@ -131 +260 @@
         .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,