Changeset 660

Timestamp:

02/27/08 13:50:59 (9 months ago)

Author:

tom

Message:

Add support for boolean values in filters, and reading of boolean
values from PostGIS data sources.

Location:

trunk

Files:

• include/mapnik/boolean_filter.hpp (added)
• include/mapnik/expression.hpp (modified) (1 diff)
• include/mapnik/filter_parser.hpp (modified) (12 diffs)
• include/mapnik/value.hpp (modified) (4 diffs)
• plugins/input/postgis/postgisfs.cpp (modified) (1 diff)

trunk/include/mapnik/expression.hpp

@@ -46 +46 @@
     {
     public:
+        literal(bool val)
+            : expression<FeatureT>(),
+              value_(val) {}
         literal(int val)
             : expression<FeatureT>(),

trunk/include/mapnik/filter_parser.hpp

@@ -34 +34 @@
 #include <mapnik/filter.hpp>
 #include <mapnik/regex_filter.hpp>
+#include <mapnik/boolean_filter.hpp>
 #include <mapnik/logical.hpp>
 
@@ -60 +61 @@
    using std::clog;
    using std::stack;
+
+    template <typename FeatureT>
+    struct push_boolean
+    {
+        push_boolean(stack<shared_ptr<expression<FeatureT> > >& exprs)
+            : exprs_(exprs) {}
+        
+        void operator() (std::string const& val) const
+        {
+            if (val == "true")
+                exprs_.push(shared_ptr<expression<FeatureT> >
+                            ( new literal<FeatureT>(true)));
+            else if (val == "false")
+                exprs_.push(shared_ptr<expression<FeatureT> >
+                            ( new literal<FeatureT>(false)));
+        }
+        stack<shared_ptr<expression<FeatureT> > >& exprs_;
+    };
 
    template <typename FeatureT>
@@ -204 +223 @@
          stack<shared_ptr<expression<FeatureT> > >& exprs_;
    };
-    
+      
+   template <typename FeatureT>
+   struct compose_boolean_filter
+   {
+         compose_boolean_filter(stack<shared_ptr<filter<FeatureT> > >& filters,
+                                stack<shared_ptr<expression<FeatureT> > >& exprs)
+            : filters_(filters),exprs_(exprs) {}
+
+         template <typename Iter>
+         void operator() (Iter,Iter) const
+         {
+            if (exprs_.size()>=1)
+            {
+               shared_ptr<expression<FeatureT> > exp = exprs_.top();
+               exprs_.pop();
+               if (exp)
+               {
+                  filters_.push(shared_ptr<filter<FeatureT> >(new boolean_filter<FeatureT>(*exp)));
+               }
+            }
+         }
+         stack<shared_ptr<filter<FeatureT> > >& filters_;
+         stack<shared_ptr<expression<FeatureT> > >& exprs_;
+   };
+
    template <typename FeatureT>
    struct compose_and_filter
@@ -298 +341 @@
                   spatial_op = "Equals","Disjoint","Touches","Within","Overlaps",
                      "Crosses","Intersects","Contains","DWithin","Beyond","BBOX";
-                  
+                  boolean_const = "true","false";
+
                   chset_t BaseChar (L"\x41-\x5A\x61-\x7A\xC0-\xD6\xD8-\xF6\xF8-\xFF\x100-\x131\x134-\x13E"
                                     L"\x141-\x148\x14A-\x17E\x180-\x1C3\x1CD-\x1F0\x1F4-\x1F5\x1FA-\x217"
@@ -369 +413 @@
                      | CombiningChar 
                      | Extender;
-                                
+                        
+                  boolean = boolean_const [push_boolean<FeatureT>(self.exprs)];
+        
                   number = strict_real_p [push_real<FeatureT>(self.exprs)] 
                      | int_p [push_integer<FeatureT>(self.exprs)];
@@ -376 +422 @@
                                      [push_string<FeatureT>(self.exprs,self.tr)],
                                      L'\'');
-                
+
                   property = L'[' >> ( (Letter | L'_' | L':') 
                                        >> *NameChar )[push_property<FeatureT>(self.exprs)] >> L']';
                 
-                  literal = number | string_ | property;
+                  literal = boolean | number | string_ | property;
                 
                   function = literal | ( func1_op >> L'('>> literal >> L')') | 
@@ -416 +462 @@
                                             [compose_filter<FeatureT,not_equals<value> >(self.filters,self.exprs)]);
 
-                  not_expr = equation | *(str_p(L"not") >> equation)[compose_not_filter<FeatureT>(self.filters)];
+                  cond_expr = equation | (expression)[compose_boolean_filter<FeatureT>(self.filters,self.exprs)];
+
+                  not_expr = cond_expr | *(str_p(L"not") >> cond_expr)[compose_not_filter<FeatureT>(self.filters)];
 
                   and_expr = not_expr >> *(L"and" >> not_expr)[compose_and_filter<FeatureT>(self.filters)];
@@ -430 +478 @@
                   BOOST_SPIRIT_DEBUG_RULE( relation );
                   BOOST_SPIRIT_DEBUG_RULE( equation );
+                  BOOST_SPIRIT_DEBUG_RULE( cond_expr );
                   BOOST_SPIRIT_DEBUG_RULE( not_expr );
                   BOOST_SPIRIT_DEBUG_RULE( and_expr );
@@ -436 +485 @@
                   BOOST_SPIRIT_DEBUG_RULE( filter_statement );   
                   BOOST_SPIRIT_DEBUG_RULE( literal );
+                  BOOST_SPIRIT_DEBUG_RULE( boolean );
                   BOOST_SPIRIT_DEBUG_RULE( number );
                   BOOST_SPIRIT_DEBUG_RULE( string_ );
@@ -454 +504 @@
                boost::spirit::rule<ScannerT> relation;
                boost::spirit::rule<ScannerT> equation;
+               boost::spirit::rule<ScannerT> cond_expr;
                boost::spirit::rule<ScannerT> not_expr;
                boost::spirit::rule<ScannerT> and_expr;
@@ -460 +511 @@
                boost::spirit::rule<ScannerT> filter_statement;   
                boost::spirit::rule<ScannerT> literal;
+               boost::spirit::rule<ScannerT> boolean;
                boost::spirit::rule<ScannerT> number;
                boost::spirit::rule<ScannerT> string_;
@@ -468 +520 @@
                symbols<string> func2_op;
                symbols<string> spatial_op;
+               symbols<string> boolean_const;
 
 

trunk/include/mapnik/value.hpp

@@ -27 +27 @@
 // mapnik
 #include <mapnik/unicode.hpp>
+#include <mapnik/config_error.hpp>
 // boost
 #include <boost/variant.hpp>
@@ -39 +40 @@
 namespace mapnik  {
    
-   typedef boost::variant<int,double,UnicodeString> value_base;
+   typedef boost::variant<bool,int,double,UnicodeString> value_base;
    
    namespace impl {
@@ -329 +330 @@
             }
       };
-    
+        
+      struct to_bool : public boost::static_visitor<bool>
+      {
+                
+            template <typename T>
+            bool operator() (T val) const
+            {
+               throw config_error("Boolean value expected");
+            }
+
+            bool operator() (bool val) const
+            {
+               return val;
+            }
+      };
+
       struct to_string : public boost::static_visitor<std::string>
       {
@@ -493 +509 @@
          }
 
+         bool to_bool() const
+         {
+            return boost::apply_visitor(impl::to_bool(),base_);
+         }
+
          std::string to_expression_string() const
          {

trunk/plugins/input/postgis/postgisfs.cpp

@@ -112 +112 @@
               int oid = rs_->getTypeOID(pos);
            
-              if (oid==23) //int4
+              if (oid==16) //bool
+              {
+                 boost::put(*feature,name,buf[0] != 0);
+              }
+              else if (oid==23) //int4
               {
                  int val = int4net(buf);