← Back to branch summary

~ubuntu-branches/ubuntu/trusty/mapnik/trusty

« back to all changes in this revision

Viewing changes to include/mapnik/filter_parser.hpp

  • Committer: Bazaar Package Importer
  • Author(s): Andres Rodriguez
  • Date: 2009-05-20 15:39:58 UTC
  • mfrom: (3.1.2 squeeze)
  • Revision ID: james.westby@ubuntu.com-20090520153958-cf6z1ql9zva4y4dq
Tags: 0.6.0-1ubuntu1
https://launchpad.net/bugs/378819
* Merge from debian unstable (LP: #378819), remaining changes:
  - debian/control:
    + Change bdeps from python2.5-dev to python-all-dev (>= 2.5)
    + Change XS-Python-Version from 2.5 to >= 2.5
  - debian/rules:
    + Various changes to enable python2.5 and python2.6 builds
* debian/patches/libtool2_2.diff Dropped. Included upsteam.
* Removed quilt support.

Show diffs side-by-side

added added

removed removed

Lines of Context:
include/mapnik/filter_parser.hpp
27
27
#define FILTER_PARSER_HPP
28
28
// mapnik
29
29
#include <mapnik/value.hpp>
 
30
#include <mapnik/unicode.hpp>
30
31
#include <mapnik/comparison.hpp>
31
32
#include <mapnik/math_expr.hpp>
32
33
#include <mapnik/expression.hpp>
33
34
#include <mapnik/filter.hpp>
34
35
#include <mapnik/regex_filter.hpp>
 
36
#include <mapnik/boolean_filter.hpp>
35
37
#include <mapnik/logical.hpp>
36
38
 
37
39
// boost
38
 
//#define BOOST_SPIRIT_DEBUG
 
40
 
 
41
// XML Debugging output
 
42
#ifdef MAPNIK_XML_DEBUG
 
43
#define BOOST_SPIRIT_DEBUG
 
44
#endif
 
45
 
 
46
#include <boost/version.hpp>
39
47
#include <boost/shared_ptr.hpp>
40
 
#include <boost/spirit/core.hpp>
41
 
#include <boost/spirit/symbols.hpp>
42
 
#include <boost/spirit/utility/confix.hpp>
43
 
#include <boost/spirit/utility/escape_char.hpp>
44
 
#include <boost/spirit/utility/chset.hpp> 
 
48
 
 
49
#if BOOST_VERSION < 103800
 
50
  #include <boost/spirit/core.hpp>
 
51
  #include <boost/spirit/symbols.hpp>
 
52
  #include <boost/spirit/utility/confix.hpp>
 
53
  #include <boost/spirit/utility/escape_char.hpp>
 
54
  #include <boost/spirit/utility/chset.hpp> 
 
55
#else
 
56
  #define BOOST_SPIRIT_USE_OLD_NAMESPACE
 
57
  #include <boost/spirit/include/classic_core.hpp>
 
58
  #include <boost/spirit/include/classic_symbols.hpp>
 
59
  #include <boost/spirit/include/classic_confix.hpp>
 
60
  #include <boost/spirit/include/classic_escape_char.hpp>
 
61
  #include <boost/spirit/include/classic_chset.hpp> 
 
62
#endif
45
63
 
46
64
// stl
47
65
#include <stack>
52
70
 
53
71
namespace mapnik
54
72
{    
55
 
    using std::string;
56
 
    using std::clog;
57
 
    using std::stack;
 
73
   using std::string;
 
74
   using std::clog;
 
75
   using std::stack;
58
76
 
59
77
    template <typename FeatureT>
60
 
    struct push_integer
 
78
    struct push_boolean
61
79
    {
62
 
        push_integer(stack<shared_ptr<expression<FeatureT> > >& exprs)
 
80
        push_boolean(stack<shared_ptr<expression<FeatureT> > >& exprs)
63
81
            : exprs_(exprs) {}
64
82
        
65
 
        void operator() (int val) const
 
83
        void operator() (std::string const& val) const
66
84
        {
 
85
            if (val == "true")
 
86
                exprs_.push(shared_ptr<expression<FeatureT> >
 
87
                            ( new literal<FeatureT>(true)));
 
88
            else if (val == "false")
 
89
                exprs_.push(shared_ptr<expression<FeatureT> >
 
90
                            ( new literal<FeatureT>(false)));
 
91
        }
 
92
        stack<shared_ptr<expression<FeatureT> > >& exprs_;
 
93
    };
 
94
 
 
95
   template <typename FeatureT>
 
96
   struct push_integer
 
97
   {
 
98
         push_integer(stack<shared_ptr<expression<FeatureT> > >& exprs)
 
99
            : exprs_(exprs) {}
 
100
        
 
101
         void operator() (int val) const
 
102
         {
67
103
            exprs_.push(shared_ptr<expression<FeatureT> >
68
104
                        ( new literal<FeatureT>(val)));
69
 
        }
70
 
        stack<shared_ptr<expression<FeatureT> > >& exprs_;
71
 
    };
 
105
         }
 
106
         stack<shared_ptr<expression<FeatureT> > >& exprs_;
 
107
   };
72
108
   
73
 
    template <typename FeatureT>
74
 
    struct push_real
75
 
    {
76
 
        push_real(stack<shared_ptr<expression<FeatureT> > >& exprs)
 
109
   template <typename FeatureT>
 
110
   struct push_real
 
111
   {
 
112
         push_real(stack<shared_ptr<expression<FeatureT> > >& exprs)
77
113
            : exprs_(exprs) {}
78
 
        void operator() (double val) const
79
 
        {
 
114
         void operator() (double val) const
 
115
         {
80
116
            exprs_.push(shared_ptr<expression<FeatureT> >(new literal<FeatureT>(val)));
81
 
        }
82
 
        stack<shared_ptr<expression<FeatureT> > >& exprs_;
83
 
    };
84
 
    
85
 
    template <typename FeatureT>
86
 
    struct push_string
87
 
    {
88
 
        push_string(stack<shared_ptr<expression<FeatureT> > >& exprs)
89
 
            : exprs_(exprs) {}
90
 
        
91
 
        template <typename Iter>
92
 
        void operator() (Iter start,Iter end) const
93
 
        {
94
 
            std::wstring str(start,end);
95
 
            std::wstring quote = L"\\";
96
 
            std::wstring::size_type idx;
97
 
            idx = str.find(quote);
98
 
            while (idx != string::npos)
99
 
            {                   
100
 
                str.erase(idx,1);
101
 
                idx = str.find(quote);
102
 
            }
103
 
            exprs_.push(shared_ptr<expression<FeatureT> >(new literal<FeatureT>(str)));
104
 
        }
105
 
        stack<shared_ptr<expression<FeatureT> > >& exprs_;
106
 
    };
107
 
    
108
 
    template <typename FeatureT>
109
 
    struct push_property
110
 
    {
111
 
        push_property(stack<shared_ptr<expression<FeatureT> > >& exprs)
112
 
            : exprs_(exprs) {}
113
 
        
114
 
        template <typename Iter>
115
 
        void operator() (Iter start,Iter end) const
116
 
        {
 
117
         }
 
118
         stack<shared_ptr<expression<FeatureT> > >& exprs_;
 
119
   };
 
120
    
 
121
   template <typename FeatureT>
 
122
   struct push_string
 
123
   {
 
124
         push_string(stack<shared_ptr<expression<FeatureT> > >& exprs, transcoder const& tr)
 
125
            : exprs_(exprs),
 
126
              tr_(tr) {}
 
127
         
 
128
         template <typename Iter>
 
129
         void operator() (Iter start,Iter end) const
 
130
         {
 
131
            UnicodeString unicode = tr_.transcode(std::string(start,end).c_str());
 
132
            exprs_.push(shared_ptr<expression<FeatureT> >(new literal<FeatureT>(unicode)));
 
133
         }
 
134
         stack<shared_ptr<expression<FeatureT> > >& exprs_;
 
135
         transcoder const& tr_;
 
136
   };
 
137
    
 
138
   template <typename FeatureT>
 
139
   struct push_property
 
140
   {
 
141
         push_property(stack<shared_ptr<expression<FeatureT> > >& exprs)
 
142
            : exprs_(exprs) {}
 
143
        
 
144
         template <typename Iter>
 
145
         void operator() (Iter start,Iter end) const
 
146
         {
117
147
            string str(start,end);
118
148
            exprs_.push(shared_ptr<expression<FeatureT> >(new property<FeatureT>(str)));
119
 
        }
120
 
        stack<shared_ptr<expression<FeatureT> > >& exprs_;
121
 
    };
 
149
         }
 
150
         stack<shared_ptr<expression<FeatureT> > >& exprs_;
 
151
   };
122
152
 
123
 
    template <typename FeatureT,typename Op>
124
 
    struct compose_expression
125
 
    {
126
 
        compose_expression(stack<shared_ptr<expression<FeatureT> > >& exprs)
 
153
   template <typename FeatureT,typename Op>
 
154
   struct compose_expression
 
155
   {
 
156
         compose_expression(stack<shared_ptr<expression<FeatureT> > >& exprs)
127
157
            : exprs_(exprs) {}
128
158
 
129
 
        template <typename Iter>
130
 
        void operator() (Iter,Iter) const
131
 
        {
 
159
         template <typename Iter>
 
160
         void operator() (Iter,Iter) const
 
161
         {
132
162
            if (exprs_.size()>=2)
133
163
            {
134
 
                shared_ptr<expression<FeatureT> > right = exprs_.top();
135
 
                exprs_.pop();
136
 
                shared_ptr<expression<FeatureT> > left = exprs_.top();
137
 
                exprs_.pop();
138
 
                if (left && right)
139
 
                {
140
 
                    exprs_.push(shared_ptr<expression<FeatureT> >
141
 
                                (new mapnik::math_expr_b<FeatureT,Op>(*left,*right)));
142
 
                }
 
164
               shared_ptr<expression<FeatureT> > right = exprs_.top();
 
165
               exprs_.pop();
 
166
               shared_ptr<expression<FeatureT> > left = exprs_.top();
 
167
               exprs_.pop();
 
168
               if (left && right)
 
169
               {
 
170
                  exprs_.push(shared_ptr<expression<FeatureT> >
 
171
                              (new mapnik::math_expr_b<FeatureT,Op>(*left,*right)));
 
172
               }
143
173
            }
144
 
        }
145
 
        stack<shared_ptr<expression<FeatureT> > >& exprs_;
146
 
    };
 
174
         }
 
175
         stack<shared_ptr<expression<FeatureT> > >& exprs_;
 
176
   };
147
177
    
148
 
    template <typename FeatureT>
149
 
    struct compose_regex
150
 
    {
151
 
        compose_regex(stack<shared_ptr<filter<FeatureT> > >& filters,
152
 
                      stack<shared_ptr<expression<FeatureT> > >& exprs)
 
178
   template <typename FeatureT>
 
179
   struct compose_regex
 
180
   {
 
181
         compose_regex(stack<shared_ptr<filter<FeatureT> > >& filters,
 
182
                       stack<shared_ptr<expression<FeatureT> > >& exprs)
153
183
            : filters_(filters),exprs_(exprs) {}
154
184
 
155
 
        template <typename Iter>
156
 
        void operator() (Iter start,Iter end) const
157
 
        {
 
185
         template <typename Iter>
 
186
         void operator() (Iter start,Iter end) const
 
187
         {
158
188
            if (exprs_.size()>=1)
159
189
            {
160
 
                shared_ptr<expression<FeatureT> > exp = exprs_.top();
161
 
                exprs_.pop();
162
 
                if (exp)
163
 
                {                   
164
 
                    std::string pattern(start,end);
165
 
                    try 
166
 
                    {
167
 
                        filters_.push(shared_ptr<filter<FeatureT> >
168
 
                                      (new regex_filter<FeatureT>(*exp,pattern)));
169
 
                    }
170
 
                    catch (...)//boost::regex_error& ex)
171
 
                    {
172
 
                        clog<<"error\n";//ex.what()<<"\n";
173
 
                    }
 
190
               shared_ptr<expression<FeatureT> > exp = exprs_.top();
 
191
               exprs_.pop();
 
192
               if (exp)
 
193
               {                    
 
194
                  std::string pattern(start,end);
 
195
                  try 
 
196
                  {
 
197
                     filters_.push(shared_ptr<filter<FeatureT> >
 
198
                                   (new regex_filter<FeatureT>(*exp,pattern)));
 
199
                  }
 
200
                  catch (...)//boost::regex_error& ex)
 
201
                  {
 
202
                     clog<<"error\n";//ex.what()<<"\n";
 
203
                  }
174
204
                    
175
 
                }
 
205
               }
176
206
            }
177
 
        }
178
 
        stack<shared_ptr<filter<FeatureT> > >& filters_;
179
 
        stack<shared_ptr<expression<FeatureT> > >& exprs_;
180
 
    };
 
207
         }
 
208
         stack<shared_ptr<filter<FeatureT> > >& filters_;
 
209
         stack<shared_ptr<expression<FeatureT> > >& exprs_;
 
210
   };
181
211
 
182
212
  
183
 
    template <typename FeatureT,typename Op>
184
 
    struct compose_filter
185
 
    {
186
 
        compose_filter(stack<shared_ptr<filter<FeatureT> > >& filters,
187
 
                       stack<shared_ptr<expression<FeatureT> > >& exprs)
 
213
   template <typename FeatureT,typename Op>
 
214
   struct compose_filter
 
215
   {
 
216
         compose_filter(stack<shared_ptr<filter<FeatureT> > >& filters,
 
217
                        stack<shared_ptr<expression<FeatureT> > >& exprs)
188
218
            : filters_(filters),exprs_(exprs) {}
189
219
 
190
 
        template <typename Iter>
191
 
        void operator() (Iter,Iter) const
192
 
        {
 
220
         template <typename Iter>
 
221
         void operator() (Iter,Iter) const
 
222
         {
193
223
            if (exprs_.size()>=2)
194
224
            {
195
 
                shared_ptr<expression<FeatureT> > right = exprs_.top();
196
 
                exprs_.pop();
197
 
                shared_ptr<expression<FeatureT> > left = exprs_.top();
198
 
                exprs_.pop();
199
 
                if (left && right)
200
 
                {
201
 
                    filters_.push(shared_ptr<filter<FeatureT> >(new compare_filter<FeatureT,Op>(*left,*right)));
202
 
                }
203
 
            }
204
 
        }
205
 
        stack<shared_ptr<filter<FeatureT> > >& filters_;
206
 
        stack<shared_ptr<expression<FeatureT> > >& exprs_;
207
 
    };
208
 
    
209
 
    template <typename FeatureT>
210
 
    struct compose_and_filter
211
 
    {
212
 
        compose_and_filter(stack<shared_ptr<filter<FeatureT> > >& filters)
213
 
            : filters_(filters) {}
214
 
 
215
 
        template <typename Iter>
216
 
        void operator() (Iter,Iter) const
217
 
        {
218
 
            if (filters_.size()>=2)
219
 
            {
220
 
                shared_ptr<filter<FeatureT> > right = filters_.top();
221
 
                filters_.pop();
222
 
                shared_ptr<filter<FeatureT> > left = filters_.top();
223
 
                filters_.pop();
224
 
                if (left && right)
225
 
                {
226
 
                    filters_.push(shared_ptr<filter<FeatureT> >
227
 
                                  (new logical_and<FeatureT>(*left,*right)));
228
 
                }
229
 
            }
230
 
        }
231
 
        stack<shared_ptr<filter<FeatureT> > >& filters_;
232
 
    };
233
 
    
234
 
    template <typename FeatureT>
235
 
    struct compose_or_filter
236
 
    {
237
 
        compose_or_filter(stack<shared_ptr<filter<FeatureT> > >& filters)
238
 
            : filters_(filters) {}
239
 
 
240
 
        template <typename Iter>
241
 
        void operator() (Iter,Iter) const
242
 
        {
243
 
            if (filters_.size()>=2)
244
 
            {
245
 
                shared_ptr<filter<FeatureT> > right = filters_.top();
246
 
                filters_.pop();
247
 
                shared_ptr<filter<FeatureT> > left = filters_.top();
248
 
                filters_.pop();
249
 
                if (left && right)
250
 
                {
251
 
                    filters_.push(shared_ptr<filter<FeatureT> >
252
 
                                  (new logical_or<FeatureT>(*left,*right)));
253
 
                }
254
 
            }
255
 
        }
256
 
        stack<shared_ptr<filter<FeatureT> > >& filters_;
257
 
    };
258
 
    
259
 
    template <typename FeatureT>
260
 
    struct compose_not_filter
261
 
    {
262
 
        compose_not_filter(stack<shared_ptr<filter<FeatureT> > >& filters)
263
 
            : filters_(filters) {}
264
 
 
265
 
        template <typename Iter>
266
 
        void operator() (Iter,Iter) const
267
 
        {
 
225
               shared_ptr<expression<FeatureT> > right = exprs_.top();
 
226
               exprs_.pop();
 
227
               shared_ptr<expression<FeatureT> > left = exprs_.top();
 
228
               exprs_.pop();
 
229
               if (left && right)
 
230
               {
 
231
                  filters_.push(shared_ptr<filter<FeatureT> >(new compare_filter<FeatureT,Op>(*left,*right)));
 
232
               }
 
233
            }
 
234
         }
 
235
         stack<shared_ptr<filter<FeatureT> > >& filters_;
 
236
         stack<shared_ptr<expression<FeatureT> > >& exprs_;
 
237
   };
 
238
      
 
239
   template <typename FeatureT>
 
240
   struct compose_boolean_filter
 
241
   {
 
242
         compose_boolean_filter(stack<shared_ptr<filter<FeatureT> > >& filters,
 
243
                                stack<shared_ptr<expression<FeatureT> > >& exprs)
 
244
            : filters_(filters),exprs_(exprs) {}
 
245
 
 
246
         template <typename Iter>
 
247
         void operator() (Iter,Iter) const
 
248
         {
 
249
            if (exprs_.size()>=1)
 
250
            {
 
251
               shared_ptr<expression<FeatureT> > exp = exprs_.top();
 
252
               exprs_.pop();
 
253
               if (exp)
 
254
               {
 
255
                  filters_.push(shared_ptr<filter<FeatureT> >(new boolean_filter<FeatureT>(*exp)));
 
256
               }
 
257
            }
 
258
         }
 
259
         stack<shared_ptr<filter<FeatureT> > >& filters_;
 
260
         stack<shared_ptr<expression<FeatureT> > >& exprs_;
 
261
   };
 
262
 
 
263
   template <typename FeatureT>
 
264
   struct compose_and_filter
 
265
   {
 
266
         compose_and_filter(stack<shared_ptr<filter<FeatureT> > >& filters)
 
267
            : filters_(filters) {}
 
268
 
 
269
         template <typename Iter>
 
270
         void operator() (Iter,Iter) const
 
271
         {
 
272
            if (filters_.size()>=2)
 
273
            {
 
274
               shared_ptr<filter<FeatureT> > right = filters_.top();
 
275
               filters_.pop();
 
276
               shared_ptr<filter<FeatureT> > left = filters_.top();
 
277
               filters_.pop();
 
278
               if (left && right)
 
279
               {
 
280
                  filters_.push(shared_ptr<filter<FeatureT> >
 
281
                                (new logical_and<FeatureT>(*left,*right)));
 
282
               }
 
283
            }
 
284
         }
 
285
         stack<shared_ptr<filter<FeatureT> > >& filters_;
 
286
   };
 
287
    
 
288
   template <typename FeatureT>
 
289
   struct compose_or_filter
 
290
   {
 
291
         compose_or_filter(stack<shared_ptr<filter<FeatureT> > >& filters)
 
292
            : filters_(filters) {}
 
293
 
 
294
         template <typename Iter>
 
295
         void operator() (Iter,Iter) const
 
296
         {
 
297
            if (filters_.size()>=2)
 
298
            {
 
299
               shared_ptr<filter<FeatureT> > right = filters_.top();
 
300
               filters_.pop();
 
301
               shared_ptr<filter<FeatureT> > left = filters_.top();
 
302
               filters_.pop();
 
303
               if (left && right)
 
304
               {
 
305
                  filters_.push(shared_ptr<filter<FeatureT> >
 
306
                                (new logical_or<FeatureT>(*left,*right)));
 
307
               }
 
308
            }
 
309
         }
 
310
         stack<shared_ptr<filter<FeatureT> > >& filters_;
 
311
   };
 
312
    
 
313
   template <typename FeatureT>
 
314
   struct compose_not_filter
 
315
   {
 
316
         compose_not_filter(stack<shared_ptr<filter<FeatureT> > >& filters)
 
317
            : filters_(filters) {}
 
318
 
 
319
         template <typename Iter>
 
320
         void operator() (Iter,Iter) const
 
321
         {
268
322
            if (filters_.size()>=1)
269
323
            {
270
 
                shared_ptr<filter<FeatureT> > filter_ = filters_.top();
271
 
                filters_.pop();
272
 
                if (filter_)
273
 
                {
274
 
                    filters_.push(shared_ptr<filter<FeatureT> >(new logical_not<FeatureT>(*filter_)));
275
 
                }
 
324
               shared_ptr<filter<FeatureT> > filter_ = filters_.top();
 
325
               filters_.pop();
 
326
               if (filter_)
 
327
               {
 
328
                  filters_.push(shared_ptr<filter<FeatureT> >(new logical_not<FeatureT>(*filter_)));
 
329
               }
276
330
            }
277
 
        }
278
 
        stack<shared_ptr<filter<FeatureT> > >& filters_;
279
 
    };
 
331
         }
 
332
         stack<shared_ptr<filter<FeatureT> > >& filters_;
 
333
   };
280
334
    
281
 
    template <typename FeatureT>
282
 
    struct filter_grammar : public grammar<filter_grammar<FeatureT> >
283
 
    {
284
 
        filter_grammar(stack<shared_ptr<filter<FeatureT> > >& filters_,
285
 
                       stack<shared_ptr<expression<FeatureT> > >& exprs_)
286
 
            : filters(filters_),exprs(exprs_) {}
287
 
        
288
 
        template <typename ScannerT>
289
 
        struct definition
290
 
        {
291
 
            definition(filter_grammar const& self)
292
 
            {   
293
 
                typedef boost::spirit::chset<wchar_t> chset_t;
294
 
 
295
 
                func1_op = "sqrt","sin","cos";
296
 
                func2_op = "min","max";
297
 
                spatial_op = "Equals","Disjoint","Touches","Within","Overlaps",
298
 
                    "Crosses","Intersects","Contains","DWithin","Beyond","BBOX";
299
 
                
300
 
                chset_t BaseChar (L"\x41-\x5A\x61-\x7A\xC0-\xD6\xD8-\xF6\xF8-\xFF\x100-\x131\x134-\x13E"
301
 
                                  L"\x141-\x148\x14A-\x17E\x180-\x1C3\x1CD-\x1F0\x1F4-\x1F5\x1FA-\x217"
302
 
                                  L"\x250-\x2A8\x2BB-\x2C1\x386\x388-\x38A\x38C\x38E-\x3A1\x3A3-\x3CE"
303
 
                                  L"\x3D0-\x3D6\x3DA\x3DC\x3DE\x3E0\x3E2-\x3F3\x401-\x40C\x40E-\x44F"
304
 
                                  L"\x451-\x45C\x45E-\x481\x490-\x4C4\x4C7-\x4C8\x4CB-\x4CC\x4D0-\x4EB"
305
 
                                  L"\x4EE-\x4F5\x4F8-\x4F9\x531-\x556\x559\x561-\x586\x5D0-\x5EA"
306
 
                                  L"\x5F0-\x5F2\x621-\x63A\x641-\x64A\x671-\x6B7\x6BA-\x6BE\x6C0-\x6CE"
307
 
                                  L"\x6D0-\x6D3\x6D5\x6E5-\x6E6\x905-\x939\x93D\x958-\x961\x985-\x98C"
308
 
                                  L"\x98F-\x990\x993-\x9A8\x9AA-\x9B0\x9B2\x9B6-\x9B9\x9DC-\x9DD"
309
 
                                  L"\x9DF-\x9E1\x9F0-\x9F1\xA05-\xA0A\xA0F-\xA10\xA13-\xA28\xA2A-\xA30"
310
 
                                  L"\xA32-\xA33\xA35-\xA36\xA38-\xA39\xA59-\xA5C\xA5E\xA72-\xA74"
311
 
                                  L"\xA85-\xA8B\xA8D\xA8F-\xA91\xA93-\xAA8\xAAA-\xAB0\xAB2-\xAB3"
312
 
                                  L"\xAB5-\xAB9\xABD\xAE0\xB05-\xB0C\xB0F-\xB10\xB13-\xB28\xB2A-\xB30"
313
 
                                  L"\xB32-\xB33\xB36-\xB39\xB3D\xB5C-\xB5D\xB5F-\xB61\xB85-\xB8A"
314
 
                                  L"\xB8E-\xB90\xB92-\xB95\xB99-\xB9A\xB9C\xB9E-\xB9F\xBA3-\xBA4"
315
 
                                  L"\xBA8-\xBAA\xBAE-\xBB5\xBB7-\xBB9\xC05-\xC0C\xC0E-\xC10\xC12-\xC28"
316
 
                                  L"\xC2A-\xC33\xC35-\xC39\xC60-\xC61\xC85-\xC8C\xC8E-\xC90\xC92-\xCA8"
317
 
                                  L"\xCAA-\xCB3\xCB5-\xCB9\xCDE\xCE0-\xCE1\xD05-\xD0C\xD0E-\xD10"
318
 
                                  L"\xD12-\xD28\xD2A-\xD39\xD60-\xD61\xE01-\xE2E\xE30\xE32-\xE33"
319
 
                                  L"\xE40-\xE45\xE81-\xE82\xE84\xE87-\xE88\xE8A\xE8D\xE94-\xE97"
320
 
                                  L"\xE99-\xE9F\xEA1-\xEA3\xEA5\xEA7\xEAA-\xEAB\xEAD-\xEAE\xEB0"
321
 
                                  L"\xEB2-\xEB3\xEBD\xEC0-\xEC4\xF40-\xF47\xF49-\xF69\x10A0-\x10C5"
322
 
                                  L"\x10D0-\x10F6\x1100\x1102-\x1103\x1105-\x1107\x1109\x110B-\x110C"
323
 
                                  L"\x110E-\x1112\x113C\x113E\x1140\x114C\x114E\x1150\x1154-\x1155"
324
 
                                  L"\x1159\x115F-\x1161\x1163\x1165\x1167\x1169\x116D-\x116E"
325
 
                                  L"\x1172-\x1173\x1175\x119E\x11A8\x11AB\x11AE-\x11AF\x11B7-\x11B8"
326
 
                                  L"\x11BA\x11BC-\x11C2\x11EB\x11F0\x11F9\x1E00-\x1E9B\x1EA0-\x1EF9"
327
 
                                  L"\x1F00-\x1F15\x1F18-\x1F1D\x1F20-\x1F45\x1F48-\x1F4D\x1F50-\x1F57"
328
 
                                  L"\x1F59\x1F5B\x1F5D\x1F5F-\x1F7D\x1F80-\x1FB4\x1FB6-\x1FBC\x1FBE"
329
 
                                  L"\x1FC2-\x1FC4\x1FC6-\x1FCC\x1FD0-\x1FD3\x1FD6-\x1FDB\x1FE0-\x1FEC"
330
 
                                  L"\x1FF2-\x1FF4\x1FF6-\x1FFC\x2126\x212A-\x212B\x212E\x2180-\x2182"
331
 
                                  L"\x3041-\x3094\x30A1-\x30FA\x3105-\x312C\xAC00-\xD7A3");
 
335
   template <typename FeatureT>
 
336
   struct filter_grammar : public grammar<filter_grammar<FeatureT> >
 
337
   {
 
338
         filter_grammar(stack<shared_ptr<filter<FeatureT> > >& filters_,
 
339
                        stack<shared_ptr<expression<FeatureT> > >& exprs_,
 
340
                        transcoder const& tr_)
 
341
            : filters(filters_),
 
342
              exprs(exprs_),
 
343
              tr(tr_) {}
 
344
         
 
345
         template <typename ScannerT>
 
346
         struct definition
 
347
         {
 
348
               definition(filter_grammar const& self)
 
349
               {        
 
350
                  typedef boost::spirit::chset<wchar_t> chset_t;
 
351
 
 
352
                  func1_op = "sqrt","sin","cos";
 
353
                  func2_op = "min","max";
 
354
                  spatial_op = "Equals","Disjoint","Touches","Within","Overlaps",
 
355
                     "Crosses","Intersects","Contains","DWithin","Beyond","BBOX";
 
356
                  boolean_const = "true","false";
 
357
 
 
358
                  chset_t BaseChar (L"\x41-\x5A\x61-\x7A\xC0-\xD6\xD8-\xF6\xF8-\xFF\x100-\x131\x134-\x13E"
 
359
                                    L"\x141-\x148\x14A-\x17E\x180-\x1C3\x1CD-\x1F0\x1F4-\x1F5\x1FA-\x217"
 
360
                                    L"\x250-\x2A8\x2BB-\x2C1\x386\x388-\x38A\x38C\x38E-\x3A1\x3A3-\x3CE"
 
361
                                    L"\x3D0-\x3D6\x3DA\x3DC\x3DE\x3E0\x3E2-\x3F3\x401-\x40C\x40E-\x44F"
 
362
                                    L"\x451-\x45C\x45E-\x481\x490-\x4C4\x4C7-\x4C8\x4CB-\x4CC\x4D0-\x4EB"
 
363
                                    L"\x4EE-\x4F5\x4F8-\x4F9\x531-\x556\x559\x561-\x586\x5D0-\x5EA"
 
364
                                    L"\x5F0-\x5F2\x621-\x63A\x641-\x64A\x671-\x6B7\x6BA-\x6BE\x6C0-\x6CE"
 
365
                                    L"\x6D0-\x6D3\x6D5\x6E5-\x6E6\x905-\x939\x93D\x958-\x961\x985-\x98C"
 
366
                                    L"\x98F-\x990\x993-\x9A8\x9AA-\x9B0\x9B2\x9B6-\x9B9\x9DC-\x9DD"
 
367
                                    L"\x9DF-\x9E1\x9F0-\x9F1\xA05-\xA0A\xA0F-\xA10\xA13-\xA28\xA2A-\xA30"
 
368
                                    L"\xA32-\xA33\xA35-\xA36\xA38-\xA39\xA59-\xA5C\xA5E\xA72-\xA74"
 
369
                                    L"\xA85-\xA8B\xA8D\xA8F-\xA91\xA93-\xAA8\xAAA-\xAB0\xAB2-\xAB3"
 
370
                                    L"\xAB5-\xAB9\xABD\xAE0\xB05-\xB0C\xB0F-\xB10\xB13-\xB28\xB2A-\xB30"
 
371
                                    L"\xB32-\xB33\xB36-\xB39\xB3D\xB5C-\xB5D\xB5F-\xB61\xB85-\xB8A"
 
372
                                    L"\xB8E-\xB90\xB92-\xB95\xB99-\xB9A\xB9C\xB9E-\xB9F\xBA3-\xBA4"
 
373
                                    L"\xBA8-\xBAA\xBAE-\xBB5\xBB7-\xBB9\xC05-\xC0C\xC0E-\xC10\xC12-\xC28"
 
374
                                    L"\xC2A-\xC33\xC35-\xC39\xC60-\xC61\xC85-\xC8C\xC8E-\xC90\xC92-\xCA8"
 
375
                                    L"\xCAA-\xCB3\xCB5-\xCB9\xCDE\xCE0-\xCE1\xD05-\xD0C\xD0E-\xD10"
 
376
                                    L"\xD12-\xD28\xD2A-\xD39\xD60-\xD61\xE01-\xE2E\xE30\xE32-\xE33"
 
377
                                    L"\xE40-\xE45\xE81-\xE82\xE84\xE87-\xE88\xE8A\xE8D\xE94-\xE97"
 
378
                                    L"\xE99-\xE9F\xEA1-\xEA3\xEA5\xEA7\xEAA-\xEAB\xEAD-\xEAE\xEB0"
 
379
                                    L"\xEB2-\xEB3\xEBD\xEC0-\xEC4\xF40-\xF47\xF49-\xF69\x10A0-\x10C5"
 
380
                                    L"\x10D0-\x10F6\x1100\x1102-\x1103\x1105-\x1107\x1109\x110B-\x110C"
 
381
                                    L"\x110E-\x1112\x113C\x113E\x1140\x114C\x114E\x1150\x1154-\x1155"
 
382
                                    L"\x1159\x115F-\x1161\x1163\x1165\x1167\x1169\x116D-\x116E"
 
383
                                    L"\x1172-\x1173\x1175\x119E\x11A8\x11AB\x11AE-\x11AF\x11B7-\x11B8"
 
384
                                    L"\x11BA\x11BC-\x11C2\x11EB\x11F0\x11F9\x1E00-\x1E9B\x1EA0-\x1EF9"
 
385
                                    L"\x1F00-\x1F15\x1F18-\x1F1D\x1F20-\x1F45\x1F48-\x1F4D\x1F50-\x1F57"
 
386
                                    L"\x1F59\x1F5B\x1F5D\x1F5F-\x1F7D\x1F80-\x1FB4\x1FB6-\x1FBC\x1FBE"
 
387
                                    L"\x1FC2-\x1FC4\x1FC6-\x1FCC\x1FD0-\x1FD3\x1FD6-\x1FDB\x1FE0-\x1FEC"
 
388
                                    L"\x1FF2-\x1FF4\x1FF6-\x1FFC\x2126\x212A-\x212B\x212E\x2180-\x2182"
 
389
                                    L"\x3041-\x3094\x30A1-\x30FA\x3105-\x312C\xAC00-\xD7A3");
332
390
            
333
 
                chset_t Ideographic(L"\x4E00-\x9FA5\x3007\x3021-\x3029");
334
 
                chset_t Letter = BaseChar | Ideographic;
335
 
            
336
 
                chset_t CombiningChar(L"\x0300-\x0345\x0360-\x0361\x0483-\x0486\x0591-\x05A1\x05A3-\x05B9"
337
 
                                      L"\x05BB-\x05BD\x05BF\x05C1-\x05C2\x05C4\x064B-\x0652\x0670"
338
 
                                      L"\x06D6-\x06DC\x06DD-\x06DF\x06E0-\x06E4\x06E7-\x06E8\x06EA-\x06ED"
339
 
                                      L"\x0901-\x0903\x093C\x093E-\x094C\x094D\x0951-\x0954\x0962-\x0963"
340
 
                                      L"\x0981-\x0983\x09BC\x09BE\x09BF\x09C0-\x09C4\x09C7-\x09C8"
341
 
                                      L"\x09CB-\x09CD\x09D7\x09E2-\x09E3\x0A02\x0A3C\x0A3E\x0A3F"
342
 
                                      L"\x0A40-\x0A42\x0A47-\x0A48\x0A4B-\x0A4D\x0A70-\x0A71\x0A81-\x0A83"
343
 
                                      L"\x0ABC\x0ABE-\x0AC5\x0AC7-\x0AC9\x0ACB-\x0ACD\x0B01-\x0B03\x0B3C"
344
 
                                      L"\x0B3E-\x0B43\x0B47-\x0B48\x0B4B-\x0B4D\x0B56-\x0B57\x0B82-\x0B83"
345
 
                                      L"\x0BBE-\x0BC2\x0BC6-\x0BC8\x0BCA-\x0BCD\x0BD7\x0C01-\x0C03"
346
 
                                      L"\x0C3E-\x0C44\x0C46-\x0C48\x0C4A-\x0C4D\x0C55-\x0C56\x0C82-\x0C83"
347
 
                                      L"\x0CBE-\x0CC4\x0CC6-\x0CC8\x0CCA-\x0CCD\x0CD5-\x0CD6\x0D02-\x0D03"
348
 
                                      L"\x0D3E-\x0D43\x0D46-\x0D48\x0D4A-\x0D4D\x0D57\x0E31\x0E34-\x0E3A"
349
 
                                      L"\x0E47-\x0E4E\x0EB1\x0EB4-\x0EB9\x0EBB-\x0EBC\x0EC8-\x0ECD"
350
 
                                      L"\x0F18-\x0F19\x0F35\x0F37\x0F39\x0F3E\x0F3F\x0F71-\x0F84"
351
 
                                      L"\x0F86-\x0F8B\x0F90-\x0F95\x0F97\x0F99-\x0FAD\x0FB1-\x0FB7\x0FB9"
352
 
                                      L"\x20D0-\x20DC\x20E1\x302A-\x302F\x3099\x309A");
353
 
            
354
 
                chset_t Digit(L"\x0030-\x0039\x0660-\x0669\x06F0-\x06F9\x0966-\x096F\x09E6-\x09EF"
355
 
                              L"\x0A66-\x0A6F\x0AE6-\x0AEF\x0B66-\x0B6F\x0BE7-\x0BEF\x0C66-\x0C6F"
356
 
                              L"\x0CE6-\x0CEF\x0D66-\x0D6F\x0E50-\x0E59\x0ED0-\x0ED9\x0F20-\x0F29");
357
 
                
358
 
                chset_t Extender(L"\x00B7\x02D0\x02D1\x0387\x0640\x0E46\x0EC6\x3005\x3031-\x3035"
359
 
                                 L"\x309D-\x309E\x30FC-\x30FE");
360
 
                
361
 
                chset_t NameChar =
362
 
                    Letter 
363
 
                    | Digit 
364
 
                    | L'.'
365
 
                    | L'-'
366
 
                    | L'_'
367
 
                    | L':'
368
 
                    | CombiningChar 
369
 
                    | Extender;
370
 
                                
371
 
                number = strict_real_p [push_real<FeatureT>(self.exprs)] 
372
 
                    | int_p [push_integer<FeatureT>(self.exprs)];
373
 
                
374
 
                string_ = confix_p(L'\'',(*lex_escape_ch_p)
375
 
                                   [push_string<FeatureT>(self.exprs)],
376
 
                                   L'\'');
377
 
                
378
 
                property = L'[' >> ( (Letter | L'_' | L':') 
379
 
                                     >> *NameChar )[push_property<FeatureT>(self.exprs)] >> L']';
380
 
                
381
 
                literal = number | string_ | property;
382
 
                
383
 
                function = literal | ( func1_op >> L'('>> literal >> L')') | 
384
 
                    (func2_op >> L'(' >> literal >> L','>> literal >> L')');
385
 
                
386
 
                factor = function 
387
 
                    | L'(' >> or_expr >> L')'
388
 
                    | ( L'-' >> factor) 
389
 
                    ;
390
 
                term = factor
391
 
                    >> *((L'*' >> factor) [compose_expression<FeatureT,mapnik::mult<value> >(self.exprs)] 
392
 
                         | (L'/' >> factor) [compose_expression<FeatureT,mapnik::div<value> >(self.exprs)]);
393
 
                
394
 
                expression = term >> *((L'+' >> term) [compose_expression<FeatureT,mapnik::add<value> >(self.exprs)] 
395
 
                                       | (L'-' >> term) [compose_expression<FeatureT,mapnik::sub<value> >(self.exprs)]);
396
 
 
397
 
                regex = str_p(L".match")>>L'('>>confix_p(L'\'',(*lex_escape_ch_p)
398
 
                                                         [compose_regex<FeatureT>(self.filters,self.exprs)],
399
 
                                                         L'\'') >>L')';
400
 
 
401
 
                relation   = expression 
402
 
                    >> *((L">=" >> expression) 
403
 
                         [compose_filter<FeatureT,greater_than_or_equal<value> >(self.filters,self.exprs)]
404
 
                         | (L'>' >> expression)
405
 
                         [compose_filter<FeatureT,mapnik::greater_than<value> >(self.filters,self.exprs)]
406
 
                         | (L'<' >> expression)
407
 
                         [compose_filter<FeatureT,mapnik::less_than<value> >(self.filters,self.exprs)]
408
 
                         | (L"<=" >> expression)
409
 
                         [compose_filter<FeatureT,less_than_or_equal<value> >(self.filters,self.exprs)]
410
 
                         | regex );
411
 
 
412
 
                equation = relation >> *( ( L'=' >> relation)
413
 
                                          [compose_filter<FeatureT,mapnik::equals<value> >(self.filters,self.exprs)]
414
 
                                          | ( L"<>" >> relation)
415
 
                                          [compose_filter<FeatureT,not_equals<value> >(self.filters,self.exprs)]);
416
 
 
417
 
                not_expr = equation | *(str_p(L"not") >> equation)[compose_not_filter<FeatureT>(self.filters)];
418
 
 
419
 
                and_expr = not_expr >> *(L"and" >> not_expr)[compose_and_filter<FeatureT>(self.filters)];
420
 
 
421
 
                or_expr  = and_expr >> *(L"or" >> and_expr)[compose_or_filter<FeatureT>(self.filters)];
422
 
 
423
 
                filter_statement = or_expr >> *(space_p) >> end_p;      
 
391
                  chset_t Ideographic(L"\x4E00-\x9FA5\x3007\x3021-\x3029");
 
392
                  chset_t Letter = BaseChar | Ideographic;
 
393
            
 
394
                  chset_t CombiningChar(L"\x0300-\x0345\x0360-\x0361\x0483-\x0486\x0591-\x05A1\x05A3-\x05B9"
 
395
                                        L"\x05BB-\x05BD\x05BF\x05C1-\x05C2\x05C4\x064B-\x0652\x0670"
 
396
                                        L"\x06D6-\x06DC\x06DD-\x06DF\x06E0-\x06E4\x06E7-\x06E8\x06EA-\x06ED"
 
397
                                        L"\x0901-\x0903\x093C\x093E-\x094C\x094D\x0951-\x0954\x0962-\x0963"
 
398
                                        L"\x0981-\x0983\x09BC\x09BE\x09BF\x09C0-\x09C4\x09C7-\x09C8"
 
399
                                        L"\x09CB-\x09CD\x09D7\x09E2-\x09E3\x0A02\x0A3C\x0A3E\x0A3F"
 
400
                                        L"\x0A40-\x0A42\x0A47-\x0A48\x0A4B-\x0A4D\x0A70-\x0A71\x0A81-\x0A83"
 
401
                                        L"\x0ABC\x0ABE-\x0AC5\x0AC7-\x0AC9\x0ACB-\x0ACD\x0B01-\x0B03\x0B3C"
 
402
                                        L"\x0B3E-\x0B43\x0B47-\x0B48\x0B4B-\x0B4D\x0B56-\x0B57\x0B82-\x0B83"
 
403
                                        L"\x0BBE-\x0BC2\x0BC6-\x0BC8\x0BCA-\x0BCD\x0BD7\x0C01-\x0C03"
 
404
                                        L"\x0C3E-\x0C44\x0C46-\x0C48\x0C4A-\x0C4D\x0C55-\x0C56\x0C82-\x0C83"
 
405
                                        L"\x0CBE-\x0CC4\x0CC6-\x0CC8\x0CCA-\x0CCD\x0CD5-\x0CD6\x0D02-\x0D03"
 
406
                                        L"\x0D3E-\x0D43\x0D46-\x0D48\x0D4A-\x0D4D\x0D57\x0E31\x0E34-\x0E3A"
 
407
                                        L"\x0E47-\x0E4E\x0EB1\x0EB4-\x0EB9\x0EBB-\x0EBC\x0EC8-\x0ECD"
 
408
                                        L"\x0F18-\x0F19\x0F35\x0F37\x0F39\x0F3E\x0F3F\x0F71-\x0F84"
 
409
                                        L"\x0F86-\x0F8B\x0F90-\x0F95\x0F97\x0F99-\x0FAD\x0FB1-\x0FB7\x0FB9"
 
410
                                        L"\x20D0-\x20DC\x20E1\x302A-\x302F\x3099\x309A");
 
411
            
 
412
                  chset_t Digit(L"\x0030-\x0039\x0660-\x0669\x06F0-\x06F9\x0966-\x096F\x09E6-\x09EF"
 
413
                                L"\x0A66-\x0A6F\x0AE6-\x0AEF\x0B66-\x0B6F\x0BE7-\x0BEF\x0C66-\x0C6F"
 
414
                                L"\x0CE6-\x0CEF\x0D66-\x0D6F\x0E50-\x0E59\x0ED0-\x0ED9\x0F20-\x0F29");
 
415
                
 
416
                  chset_t Extender(L"\x00B7\x02D0\x02D1\x0387\x0640\x0E46\x0EC6\x3005\x3031-\x3035"
 
417
                                   L"\x309D-\x309E\x30FC-\x30FE");
 
418
                
 
419
                  chset_t NameChar =
 
420
                     Letter 
 
421
                     | Digit 
 
422
                     | L'.'
 
423
                     | L'-'
 
424
                     | L'_'
 
425
                     | L':'
 
426
                     | CombiningChar 
 
427
                     | Extender;
 
428
                        
 
429
                  boolean = boolean_const [push_boolean<FeatureT>(self.exprs)];
 
430
        
 
431
                  number = strict_real_p [push_real<FeatureT>(self.exprs)] 
 
432
                     | int_p [push_integer<FeatureT>(self.exprs)];
 
433
                
 
434
                  string_ = confix_p(L'\'',(*lex_escape_ch_p)
 
435
                                     [push_string<FeatureT>(self.exprs,self.tr)],
 
436
                                     L'\'');
 
437
 
 
438
                  property = L'[' >> ( (Letter | Digit | L'_' | L':') 
 
439
                                       >> *NameChar )[push_property<FeatureT>(self.exprs)] >> L']';
 
440
                
 
441
                  literal = boolean | number | string_ | property;
 
442
                
 
443
                  function = literal | ( func1_op >> L'('>> literal >> L')') | 
 
444
                     (func2_op >> L'(' >> literal >> L','>> literal >> L')');
 
445
                
 
446
                  factor = function 
 
447
                     | L'(' >> or_expr >> L')'
 
448
                     | ( L'-' >> factor) 
 
449
                     ;
 
450
                  term = factor
 
451
                     >> *((L'*' >> factor) [compose_expression<FeatureT,mapnik::mult<value> >(self.exprs)] 
 
452
                          | (L'/' >> factor) [compose_expression<FeatureT,mapnik::div<value> >(self.exprs)]
 
453
                          | (L'%' >> factor) [compose_expression<FeatureT,mapnik::mod<value> >(self.exprs)]);
 
454
                
 
455
                  expression = term >> *((L'+' >> term) [compose_expression<FeatureT,mapnik::add<value> >(self.exprs)] 
 
456
                                         | (L'-' >> term) [compose_expression<FeatureT,mapnik::sub<value> >(self.exprs)]);
 
457
 
 
458
                  regex = str_p(L".match")>>L'('>>confix_p(L'\'',(*lex_escape_ch_p)
 
459
                                                           [compose_regex<FeatureT>(self.filters,self.exprs)],
 
460
                                                           L'\'') >>L')';
 
461
 
 
462
                  relation   = expression 
 
463
                     >> *((L">=" >> expression) 
 
464
                          [compose_filter<FeatureT,greater_than_or_equal<value> >(self.filters,self.exprs)]
 
465
                          | (L'>' >> expression)
 
466
                          [compose_filter<FeatureT,mapnik::greater_than<value> >(self.filters,self.exprs)]
 
467
                          | (L'<' >> expression)
 
468
                          [compose_filter<FeatureT,mapnik::less_than<value> >(self.filters,self.exprs)]
 
469
                          | (L"<=" >> expression)
 
470
                          [compose_filter<FeatureT,less_than_or_equal<value> >(self.filters,self.exprs)]
 
471
                          | regex );
 
472
 
 
473
                  equation = relation >> *( ( L'=' >> relation)
 
474
                                            [compose_filter<FeatureT,mapnik::equals<value> >(self.filters,self.exprs)]
 
475
                                            | ( L"<>" >> relation)
 
476
                                            [compose_filter<FeatureT,not_equals<value> >(self.filters,self.exprs)]);
 
477
 
 
478
                  cond_expr = equation | (expression)[compose_boolean_filter<FeatureT>(self.filters,self.exprs)];
 
479
 
 
480
                  not_expr = cond_expr | *(str_p(L"not") >> cond_expr)[compose_not_filter<FeatureT>(self.filters)];
 
481
 
 
482
                  and_expr = not_expr >> *(L"and" >> not_expr)[compose_and_filter<FeatureT>(self.filters)];
 
483
 
 
484
                  or_expr  = and_expr >> *(L"or" >> and_expr)[compose_or_filter<FeatureT>(self.filters)];
 
485
 
 
486
                  filter_statement = or_expr >> *(space_p) >> end_p;    
424
487
 
425
488
#ifdef BOOST_SPIRIT_DEBUG
426
 
                BOOST_SPIRIT_DEBUG_RULE( factor ); 
427
 
                BOOST_SPIRIT_DEBUG_RULE( term );
428
 
                BOOST_SPIRIT_DEBUG_RULE( expression );
429
 
                BOOST_SPIRIT_DEBUG_RULE( relation );
430
 
                BOOST_SPIRIT_DEBUG_RULE( equation );
431
 
                BOOST_SPIRIT_DEBUG_RULE( not_expr );
432
 
                BOOST_SPIRIT_DEBUG_RULE( and_expr );
433
 
                BOOST_SPIRIT_DEBUG_RULE( or_expr );
 
489
                  BOOST_SPIRIT_DEBUG_RULE( factor ); 
 
490
                  BOOST_SPIRIT_DEBUG_RULE( term );
 
491
                  BOOST_SPIRIT_DEBUG_RULE( expression );
 
492
                  BOOST_SPIRIT_DEBUG_RULE( relation );
 
493
                  BOOST_SPIRIT_DEBUG_RULE( equation );
 
494
                  BOOST_SPIRIT_DEBUG_RULE( cond_expr );
 
495
                  BOOST_SPIRIT_DEBUG_RULE( not_expr );
 
496
                  BOOST_SPIRIT_DEBUG_RULE( and_expr );
 
497
                  BOOST_SPIRIT_DEBUG_RULE( or_expr );
434
498
 
435
 
                BOOST_SPIRIT_DEBUG_RULE( filter_statement );   
436
 
                BOOST_SPIRIT_DEBUG_RULE( literal );
437
 
                BOOST_SPIRIT_DEBUG_RULE( number );
438
 
                BOOST_SPIRIT_DEBUG_RULE( string_ );
439
 
                BOOST_SPIRIT_DEBUG_RULE( property );
440
 
                BOOST_SPIRIT_DEBUG_RULE( function );
441
 
                BOOST_SPIRIT_DEBUG_RULE( regex );
 
499
                  BOOST_SPIRIT_DEBUG_RULE( filter_statement );   
 
500
                  BOOST_SPIRIT_DEBUG_RULE( literal );
 
501
                  BOOST_SPIRIT_DEBUG_RULE( boolean );
 
502
                  BOOST_SPIRIT_DEBUG_RULE( number );
 
503
                  BOOST_SPIRIT_DEBUG_RULE( string_ );
 
504
                  BOOST_SPIRIT_DEBUG_RULE( property );
 
505
                  BOOST_SPIRIT_DEBUG_RULE( function );
 
506
                  BOOST_SPIRIT_DEBUG_RULE( regex );
442
507
#endif
443
 
            }
 
508
               }
444
509
            
445
 
            boost::spirit::rule<ScannerT> const& start() const
446
 
            {
447
 
                return filter_statement;
448
 
            }
 
510
               boost::spirit::rule<ScannerT> const& start() const
 
511
               {
 
512
                  return filter_statement;
 
513
               }
449
514
                    
450
 
            boost::spirit::rule<ScannerT> factor; 
451
 
            boost::spirit::rule<ScannerT> term;
452
 
            boost::spirit::rule<ScannerT> expression;
453
 
            boost::spirit::rule<ScannerT> relation;
454
 
            boost::spirit::rule<ScannerT> equation;
455
 
            boost::spirit::rule<ScannerT> not_expr;
456
 
            boost::spirit::rule<ScannerT> and_expr;
457
 
            boost::spirit::rule<ScannerT> or_expr;
458
 
            
459
 
            boost::spirit::rule<ScannerT> filter_statement;   
460
 
            boost::spirit::rule<ScannerT> literal;
461
 
            boost::spirit::rule<ScannerT> number;
462
 
            boost::spirit::rule<ScannerT> string_;
463
 
            boost::spirit::rule<ScannerT> property;
464
 
            boost::spirit::rule<ScannerT> function;
465
 
            boost::spirit::rule<ScannerT> regex;
466
 
            symbols<string> func1_op;
467
 
            symbols<string> func2_op;
468
 
            symbols<string> spatial_op;
469
 
 
470
 
 
471
 
        };
472
 
        stack<shared_ptr<filter<FeatureT> > >& filters;
473
 
        stack<shared_ptr<expression<FeatureT> > >& exprs;
474
 
    };    
 
515
               boost::spirit::rule<ScannerT> factor; 
 
516
               boost::spirit::rule<ScannerT> term;
 
517
               boost::spirit::rule<ScannerT> expression;
 
518
               boost::spirit::rule<ScannerT> relation;
 
519
               boost::spirit::rule<ScannerT> equation;
 
520
               boost::spirit::rule<ScannerT> cond_expr;
 
521
               boost::spirit::rule<ScannerT> not_expr;
 
522
               boost::spirit::rule<ScannerT> and_expr;
 
523
               boost::spirit::rule<ScannerT> or_expr;
 
524
              
 
525
               boost::spirit::rule<ScannerT> filter_statement;   
 
526
               boost::spirit::rule<ScannerT> literal;
 
527
               boost::spirit::rule<ScannerT> boolean;
 
528
               boost::spirit::rule<ScannerT> number;
 
529
               boost::spirit::rule<ScannerT> string_;
 
530
               boost::spirit::rule<ScannerT> property;
 
531
               boost::spirit::rule<ScannerT> function;
 
532
               boost::spirit::rule<ScannerT> regex;
 
533
               symbols<string> func1_op;
 
534
               symbols<string> func2_op;
 
535
               symbols<string> spatial_op;
 
536
               symbols<string> boolean_const;
 
537
 
 
538
 
 
539
         };
 
540
         stack<shared_ptr<filter<FeatureT> > >& filters;
 
541
         stack<shared_ptr<expression<FeatureT> > >& exprs;
 
542
         transcoder const& tr;
 
543
   };    
475
544
}
476
545
 
477
546
#endif //FILTER_PARSER_HPP