00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020
00021
00022
00023
00024
00025
00026 #ifndef FILTER_PARSER_HPP
00027 #define FILTER_PARSER_HPP
00028
00029 #include <mapnik/value.hpp>
00030 #include <mapnik/unicode.hpp>
00031 #include <mapnik/comparison.hpp>
00032 #include <mapnik/math_expr.hpp>
00033 #include <mapnik/expression.hpp>
00034 #include <mapnik/filter.hpp>
00035 #include <mapnik/regex_filter.hpp>
00036 #include <mapnik/boolean_filter.hpp>
00037 #include <mapnik/logical.hpp>
00038
00039
00040 #ifdef MAPNIK_DEBUG
00041 #define BOOST_SPIRIT_DEBUG
00042 #endif
00043
00044 #include <boost/shared_ptr.hpp>
00045 #include <boost/spirit/core.hpp>
00046 #include <boost/spirit/symbols.hpp>
00047 #include <boost/spirit/utility/confix.hpp>
00048 #include <boost/spirit/utility/escape_char.hpp>
00049 #include <boost/spirit/utility/chset.hpp>
00050
00051
00052 #include <stack>
00053 #include <iostream>
00054
00055 using namespace boost::spirit;
00056 using boost::shared_ptr;
00057
00058 namespace mapnik
00059 {
00060 using std::string;
00061 using std::clog;
00062 using std::stack;
00063
00064 template <typename FeatureT>
00065 struct push_boolean
00066 {
00067 push_boolean(stack<shared_ptr<expression<FeatureT> > >& exprs)
00068 : exprs_(exprs) {}
00069
00070 void operator() (std::string const& val) const
00071 {
00072 if (val == "true")
00073 exprs_.push(shared_ptr<expression<FeatureT> >
00074 ( new literal<FeatureT>(true)));
00075 else if (val == "false")
00076 exprs_.push(shared_ptr<expression<FeatureT> >
00077 ( new literal<FeatureT>(false)));
00078 }
00079 stack<shared_ptr<expression<FeatureT> > >& exprs_;
00080 };
00081
00082 template <typename FeatureT>
00083 struct push_integer
00084 {
00085 push_integer(stack<shared_ptr<expression<FeatureT> > >& exprs)
00086 : exprs_(exprs) {}
00087
00088 void operator() (int val) const
00089 {
00090 exprs_.push(shared_ptr<expression<FeatureT> >
00091 ( new literal<FeatureT>(val)));
00092 }
00093 stack<shared_ptr<expression<FeatureT> > >& exprs_;
00094 };
00095
00096 template <typename FeatureT>
00097 struct push_real
00098 {
00099 push_real(stack<shared_ptr<expression<FeatureT> > >& exprs)
00100 : exprs_(exprs) {}
00101 void operator() (double val) const
00102 {
00103 exprs_.push(shared_ptr<expression<FeatureT> >(new literal<FeatureT>(val)));
00104 }
00105 stack<shared_ptr<expression<FeatureT> > >& exprs_;
00106 };
00107
00108 template <typename FeatureT>
00109 struct push_string
00110 {
00111 push_string(stack<shared_ptr<expression<FeatureT> > >& exprs, transcoder const& tr)
00112 : exprs_(exprs),
00113 tr_(tr) {}
00114
00115 template <typename Iter>
00116 void operator() (Iter start,Iter end) const
00117 {
00118 UnicodeString unicode = tr_.transcode(std::string(start,end).c_str());
00119 exprs_.push(shared_ptr<expression<FeatureT> >(new literal<FeatureT>(unicode)));
00120 }
00121 stack<shared_ptr<expression<FeatureT> > >& exprs_;
00122 transcoder const& tr_;
00123 };
00124
00125 template <typename FeatureT>
00126 struct push_property
00127 {
00128 push_property(stack<shared_ptr<expression<FeatureT> > >& exprs)
00129 : exprs_(exprs) {}
00130
00131 template <typename Iter>
00132 void operator() (Iter start,Iter end) const
00133 {
00134 string str(start,end);
00135 exprs_.push(shared_ptr<expression<FeatureT> >(new property<FeatureT>(str)));
00136 }
00137 stack<shared_ptr<expression<FeatureT> > >& exprs_;
00138 };
00139
00140 template <typename FeatureT,typename Op>
00141 struct compose_expression
00142 {
00143 compose_expression(stack<shared_ptr<expression<FeatureT> > >& exprs)
00144 : exprs_(exprs) {}
00145
00146 template <typename Iter>
00147 void operator() (Iter,Iter) const
00148 {
00149 if (exprs_.size()>=2)
00150 {
00151 shared_ptr<expression<FeatureT> > right = exprs_.top();
00152 exprs_.pop();
00153 shared_ptr<expression<FeatureT> > left = exprs_.top();
00154 exprs_.pop();
00155 if (left && right)
00156 {
00157 exprs_.push(shared_ptr<expression<FeatureT> >
00158 (new mapnik::math_expr_b<FeatureT,Op>(*left,*right)));
00159 }
00160 }
00161 }
00162 stack<shared_ptr<expression<FeatureT> > >& exprs_;
00163 };
00164
00165 template <typename FeatureT>
00166 struct compose_regex
00167 {
00168 compose_regex(stack<shared_ptr<filter<FeatureT> > >& filters,
00169 stack<shared_ptr<expression<FeatureT> > >& exprs)
00170 : filters_(filters),exprs_(exprs) {}
00171
00172 template <typename Iter>
00173 void operator() (Iter start,Iter end) const
00174 {
00175 if (exprs_.size()>=1)
00176 {
00177 shared_ptr<expression<FeatureT> > exp = exprs_.top();
00178 exprs_.pop();
00179 if (exp)
00180 {
00181 std::string pattern(start,end);
00182 try
00183 {
00184 filters_.push(shared_ptr<filter<FeatureT> >
00185 (new regex_filter<FeatureT>(*exp,pattern)));
00186 }
00187 catch (...)
00188 {
00189 clog<<"error\n";
00190 }
00191
00192 }
00193 }
00194 }
00195 stack<shared_ptr<filter<FeatureT> > >& filters_;
00196 stack<shared_ptr<expression<FeatureT> > >& exprs_;
00197 };
00198
00199
00200 template <typename FeatureT,typename Op>
00201 struct compose_filter
00202 {
00203 compose_filter(stack<shared_ptr<filter<FeatureT> > >& filters,
00204 stack<shared_ptr<expression<FeatureT> > >& exprs)
00205 : filters_(filters),exprs_(exprs) {}
00206
00207 template <typename Iter>
00208 void operator() (Iter,Iter) const
00209 {
00210 if (exprs_.size()>=2)
00211 {
00212 shared_ptr<expression<FeatureT> > right = exprs_.top();
00213 exprs_.pop();
00214 shared_ptr<expression<FeatureT> > left = exprs_.top();
00215 exprs_.pop();
00216 if (left && right)
00217 {
00218 filters_.push(shared_ptr<filter<FeatureT> >(new compare_filter<FeatureT,Op>(*left,*right)));
00219 }
00220 }
00221 }
00222 stack<shared_ptr<filter<FeatureT> > >& filters_;
00223 stack<shared_ptr<expression<FeatureT> > >& exprs_;
00224 };
00225
00226 template <typename FeatureT>
00227 struct compose_boolean_filter
00228 {
00229 compose_boolean_filter(stack<shared_ptr<filter<FeatureT> > >& filters,
00230 stack<shared_ptr<expression<FeatureT> > >& exprs)
00231 : filters_(filters),exprs_(exprs) {}
00232
00233 template <typename Iter>
00234 void operator() (Iter,Iter) const
00235 {
00236 if (exprs_.size()>=1)
00237 {
00238 shared_ptr<expression<FeatureT> > exp = exprs_.top();
00239 exprs_.pop();
00240 if (exp)
00241 {
00242 filters_.push(shared_ptr<filter<FeatureT> >(new boolean_filter<FeatureT>(*exp)));
00243 }
00244 }
00245 }
00246 stack<shared_ptr<filter<FeatureT> > >& filters_;
00247 stack<shared_ptr<expression<FeatureT> > >& exprs_;
00248 };
00249
00250 template <typename FeatureT>
00251 struct compose_and_filter
00252 {
00253 compose_and_filter(stack<shared_ptr<filter<FeatureT> > >& filters)
00254 : filters_(filters) {}
00255
00256 template <typename Iter>
00257 void operator() (Iter,Iter) const
00258 {
00259 if (filters_.size()>=2)
00260 {
00261 shared_ptr<filter<FeatureT> > right = filters_.top();
00262 filters_.pop();
00263 shared_ptr<filter<FeatureT> > left = filters_.top();
00264 filters_.pop();
00265 if (left && right)
00266 {
00267 filters_.push(shared_ptr<filter<FeatureT> >
00268 (new logical_and<FeatureT>(*left,*right)));
00269 }
00270 }
00271 }
00272 stack<shared_ptr<filter<FeatureT> > >& filters_;
00273 };
00274
00275 template <typename FeatureT>
00276 struct compose_or_filter
00277 {
00278 compose_or_filter(stack<shared_ptr<filter<FeatureT> > >& filters)
00279 : filters_(filters) {}
00280
00281 template <typename Iter>
00282 void operator() (Iter,Iter) const
00283 {
00284 if (filters_.size()>=2)
00285 {
00286 shared_ptr<filter<FeatureT> > right = filters_.top();
00287 filters_.pop();
00288 shared_ptr<filter<FeatureT> > left = filters_.top();
00289 filters_.pop();
00290 if (left && right)
00291 {
00292 filters_.push(shared_ptr<filter<FeatureT> >
00293 (new logical_or<FeatureT>(*left,*right)));
00294 }
00295 }
00296 }
00297 stack<shared_ptr<filter<FeatureT> > >& filters_;
00298 };
00299
00300 template <typename FeatureT>
00301 struct compose_not_filter
00302 {
00303 compose_not_filter(stack<shared_ptr<filter<FeatureT> > >& filters)
00304 : filters_(filters) {}
00305
00306 template <typename Iter>
00307 void operator() (Iter,Iter) const
00308 {
00309 if (filters_.size()>=1)
00310 {
00311 shared_ptr<filter<FeatureT> > filter_ = filters_.top();
00312 filters_.pop();
00313 if (filter_)
00314 {
00315 filters_.push(shared_ptr<filter<FeatureT> >(new logical_not<FeatureT>(*filter_)));
00316 }
00317 }
00318 }
00319 stack<shared_ptr<filter<FeatureT> > >& filters_;
00320 };
00321
00322 template <typename FeatureT>
00323 struct filter_grammar : public grammar<filter_grammar<FeatureT> >
00324 {
00325 filter_grammar(stack<shared_ptr<filter<FeatureT> > >& filters_,
00326 stack<shared_ptr<expression<FeatureT> > >& exprs_,
00327 transcoder const& tr_)
00328 : filters(filters_),
00329 exprs(exprs_),
00330 tr(tr_) {}
00331
00332 template <typename ScannerT>
00333 struct definition
00334 {
00335 definition(filter_grammar const& self)
00336 {
00337 typedef boost::spirit::chset<wchar_t> chset_t;
00338
00339 func1_op = "sqrt","sin","cos";
00340 func2_op = "min","max";
00341 spatial_op = "Equals","Disjoint","Touches","Within","Overlaps",
00342 "Crosses","Intersects","Contains","DWithin","Beyond","BBOX";
00343 boolean_const = "true","false";
00344
00345 chset_t BaseChar (L"\x41-\x5A\x61-\x7A\xC0-\xD6\xD8-\xF6\xF8-\xFF\x100-\x131\x134-\x13E"
00346 L"\x141-\x148\x14A-\x17E\x180-\x1C3\x1CD-\x1F0\x1F4-\x1F5\x1FA-\x217"
00347 L"\x250-\x2A8\x2BB-\x2C1\x386\x388-\x38A\x38C\x38E-\x3A1\x3A3-\x3CE"
00348 L"\x3D0-\x3D6\x3DA\x3DC\x3DE\x3E0\x3E2-\x3F3\x401-\x40C\x40E-\x44F"
00349 L"\x451-\x45C\x45E-\x481\x490-\x4C4\x4C7-\x4C8\x4CB-\x4CC\x4D0-\x4EB"
00350 L"\x4EE-\x4F5\x4F8-\x4F9\x531-\x556\x559\x561-\x586\x5D0-\x5EA"
00351 L"\x5F0-\x5F2\x621-\x63A\x641-\x64A\x671-\x6B7\x6BA-\x6BE\x6C0-\x6CE"
00352 L"\x6D0-\x6D3\x6D5\x6E5-\x6E6\x905-\x939\x93D\x958-\x961\x985-\x98C"
00353 L"\x98F-\x990\x993-\x9A8\x9AA-\x9B0\x9B2\x9B6-\x9B9\x9DC-\x9DD"
00354 L"\x9DF-\x9E1\x9F0-\x9F1\xA05-\xA0A\xA0F-\xA10\xA13-\xA28\xA2A-\xA30"
00355 L"\xA32-\xA33\xA35-\xA36\xA38-\xA39\xA59-\xA5C\xA5E\xA72-\xA74"
00356 L"\xA85-\xA8B\xA8D\xA8F-\xA91\xA93-\xAA8\xAAA-\xAB0\xAB2-\xAB3"
00357 L"\xAB5-\xAB9\xABD\xAE0\xB05-\xB0C\xB0F-\xB10\xB13-\xB28\xB2A-\xB30"
00358 L"\xB32-\xB33\xB36-\xB39\xB3D\xB5C-\xB5D\xB5F-\xB61\xB85-\xB8A"
00359 L"\xB8E-\xB90\xB92-\xB95\xB99-\xB9A\xB9C\xB9E-\xB9F\xBA3-\xBA4"
00360 L"\xBA8-\xBAA\xBAE-\xBB5\xBB7-\xBB9\xC05-\xC0C\xC0E-\xC10\xC12-\xC28"
00361 L"\xC2A-\xC33\xC35-\xC39\xC60-\xC61\xC85-\xC8C\xC8E-\xC90\xC92-\xCA8"
00362 L"\xCAA-\xCB3\xCB5-\xCB9\xCDE\xCE0-\xCE1\xD05-\xD0C\xD0E-\xD10"
00363 L"\xD12-\xD28\xD2A-\xD39\xD60-\xD61\xE01-\xE2E\xE30\xE32-\xE33"
00364 L"\xE40-\xE45\xE81-\xE82\xE84\xE87-\xE88\xE8A\xE8D\xE94-\xE97"
00365 L"\xE99-\xE9F\xEA1-\xEA3\xEA5\xEA7\xEAA-\xEAB\xEAD-\xEAE\xEB0"
00366 L"\xEB2-\xEB3\xEBD\xEC0-\xEC4\xF40-\xF47\xF49-\xF69\x10A0-\x10C5"
00367 L"\x10D0-\x10F6\x1100\x1102-\x1103\x1105-\x1107\x1109\x110B-\x110C"
00368 L"\x110E-\x1112\x113C\x113E\x1140\x114C\x114E\x1150\x1154-\x1155"
00369 L"\x1159\x115F-\x1161\x1163\x1165\x1167\x1169\x116D-\x116E"
00370 L"\x1172-\x1173\x1175\x119E\x11A8\x11AB\x11AE-\x11AF\x11B7-\x11B8"
00371 L"\x11BA\x11BC-\x11C2\x11EB\x11F0\x11F9\x1E00-\x1E9B\x1EA0-\x1EF9"
00372 L"\x1F00-\x1F15\x1F18-\x1F1D\x1F20-\x1F45\x1F48-\x1F4D\x1F50-\x1F57"
00373 L"\x1F59\x1F5B\x1F5D\x1F5F-\x1F7D\x1F80-\x1FB4\x1FB6-\x1FBC\x1FBE"
00374 L"\x1FC2-\x1FC4\x1FC6-\x1FCC\x1FD0-\x1FD3\x1FD6-\x1FDB\x1FE0-\x1FEC"
00375 L"\x1FF2-\x1FF4\x1FF6-\x1FFC\x2126\x212A-\x212B\x212E\x2180-\x2182"
00376 L"\x3041-\x3094\x30A1-\x30FA\x3105-\x312C\xAC00-\xD7A3");
00377
00378 chset_t Ideographic(L"\x4E00-\x9FA5\x3007\x3021-\x3029");
00379 chset_t Letter = BaseChar | Ideographic;
00380
00381 chset_t CombiningChar(L"\x0300-\x0345\x0360-\x0361\x0483-\x0486\x0591-\x05A1\x05A3-\x05B9"
00382 L"\x05BB-\x05BD\x05BF\x05C1-\x05C2\x05C4\x064B-\x0652\x0670"
00383 L"\x06D6-\x06DC\x06DD-\x06DF\x06E0-\x06E4\x06E7-\x06E8\x06EA-\x06ED"
00384 L"\x0901-\x0903\x093C\x093E-\x094C\x094D\x0951-\x0954\x0962-\x0963"
00385 L"\x0981-\x0983\x09BC\x09BE\x09BF\x09C0-\x09C4\x09C7-\x09C8"
00386 L"\x09CB-\x09CD\x09D7\x09E2-\x09E3\x0A02\x0A3C\x0A3E\x0A3F"
00387 L"\x0A40-\x0A42\x0A47-\x0A48\x0A4B-\x0A4D\x0A70-\x0A71\x0A81-\x0A83"
00388 L"\x0ABC\x0ABE-\x0AC5\x0AC7-\x0AC9\x0ACB-\x0ACD\x0B01-\x0B03\x0B3C"
00389 L"\x0B3E-\x0B43\x0B47-\x0B48\x0B4B-\x0B4D\x0B56-\x0B57\x0B82-\x0B83"
00390 L"\x0BBE-\x0BC2\x0BC6-\x0BC8\x0BCA-\x0BCD\x0BD7\x0C01-\x0C03"
00391 L"\x0C3E-\x0C44\x0C46-\x0C48\x0C4A-\x0C4D\x0C55-\x0C56\x0C82-\x0C83"
00392 L"\x0CBE-\x0CC4\x0CC6-\x0CC8\x0CCA-\x0CCD\x0CD5-\x0CD6\x0D02-\x0D03"
00393 L"\x0D3E-\x0D43\x0D46-\x0D48\x0D4A-\x0D4D\x0D57\x0E31\x0E34-\x0E3A"
00394 L"\x0E47-\x0E4E\x0EB1\x0EB4-\x0EB9\x0EBB-\x0EBC\x0EC8-\x0ECD"
00395 L"\x0F18-\x0F19\x0F35\x0F37\x0F39\x0F3E\x0F3F\x0F71-\x0F84"
00396 L"\x0F86-\x0F8B\x0F90-\x0F95\x0F97\x0F99-\x0FAD\x0FB1-\x0FB7\x0FB9"
00397 L"\x20D0-\x20DC\x20E1\x302A-\x302F\x3099\x309A");
00398
00399 chset_t Digit(L"\x0030-\x0039\x0660-\x0669\x06F0-\x06F9\x0966-\x096F\x09E6-\x09EF"
00400 L"\x0A66-\x0A6F\x0AE6-\x0AEF\x0B66-\x0B6F\x0BE7-\x0BEF\x0C66-\x0C6F"
00401 L"\x0CE6-\x0CEF\x0D66-\x0D6F\x0E50-\x0E59\x0ED0-\x0ED9\x0F20-\x0F29");
00402
00403 chset_t Extender(L"\x00B7\x02D0\x02D1\x0387\x0640\x0E46\x0EC6\x3005\x3031-\x3035"
00404 L"\x309D-\x309E\x30FC-\x30FE");
00405
00406 chset_t NameChar =
00407 Letter
00408 | Digit
00409 | L'.'
00410 | L'-'
00411 | L'_'
00412 | L':'
00413 | CombiningChar
00414 | Extender;
00415
00416 boolean = boolean_const [push_boolean<FeatureT>(self.exprs)];
00417
00418 number = strict_real_p [push_real<FeatureT>(self.exprs)]
00419 | int_p [push_integer<FeatureT>(self.exprs)];
00420
00421 string_ = confix_p(L'\'',(*lex_escape_ch_p)
00422 [push_string<FeatureT>(self.exprs,self.tr)],
00423 L'\'');
00424
00425 property = L'[' >> ( (Letter | L'_' | L':')
00426 >> *NameChar )[push_property<FeatureT>(self.exprs)] >> L']';
00427
00428 literal = boolean | number | string_ | property;
00429
00430 function = literal | ( func1_op >> L'('>> literal >> L')') |
00431 (func2_op >> L'(' >> literal >> L','>> literal >> L')');
00432
00433 factor = function
00434 | L'(' >> or_expr >> L')'
00435 | ( L'-' >> factor)
00436 ;
00437 term = factor
00438 >> *((L'*' >> factor) [compose_expression<FeatureT,mapnik::mult<value> >(self.exprs)]
00439 | (L'/' >> factor) [compose_expression<FeatureT,mapnik::div<value> >(self.exprs)]);
00440
00441 expression = term >> *((L'+' >> term) [compose_expression<FeatureT,mapnik::add<value> >(self.exprs)]
00442 | (L'-' >> term) [compose_expression<FeatureT,mapnik::sub<value> >(self.exprs)]);
00443
00444 regex = str_p(L".match")>>L'('>>confix_p(L'\'',(*lex_escape_ch_p)
00445 [compose_regex<FeatureT>(self.filters,self.exprs)],
00446 L'\'') >>L')';
00447
00448 relation = expression
00449 >> *((L">=" >> expression)
00450 [compose_filter<FeatureT,greater_than_or_equal<value> >(self.filters,self.exprs)]
00451 | (L'>' >> expression)
00452 [compose_filter<FeatureT,mapnik::greater_than<value> >(self.filters,self.exprs)]
00453 | (L'<' >> expression)
00454 [compose_filter<FeatureT,mapnik::less_than<value> >(self.filters,self.exprs)]
00455 | (L"<=" >> expression)
00456 [compose_filter<FeatureT,less_than_or_equal<value> >(self.filters,self.exprs)]
00457 | regex );
00458
00459 equation = relation >> *( ( L'=' >> relation)
00460 [compose_filter<FeatureT,mapnik::equals<value> >(self.filters,self.exprs)]
00461 | ( L"<>" >> relation)
00462 [compose_filter<FeatureT,not_equals<value> >(self.filters,self.exprs)]);
00463
00464 cond_expr = equation | (expression)[compose_boolean_filter<FeatureT>(self.filters,self.exprs)];
00465
00466 not_expr = cond_expr | *(str_p(L"not") >> cond_expr)[compose_not_filter<FeatureT>(self.filters)];
00467
00468 and_expr = not_expr >> *(L"and" >> not_expr)[compose_and_filter<FeatureT>(self.filters)];
00469
00470 or_expr = and_expr >> *(L"or" >> and_expr)[compose_or_filter<FeatureT>(self.filters)];
00471
00472 filter_statement = or_expr >> *(space_p) >> end_p;
00473
00474 #ifdef BOOST_SPIRIT_DEBUG
00475 BOOST_SPIRIT_DEBUG_RULE( factor );
00476 BOOST_SPIRIT_DEBUG_RULE( term );
00477 BOOST_SPIRIT_DEBUG_RULE( expression );
00478 BOOST_SPIRIT_DEBUG_RULE( relation );
00479 BOOST_SPIRIT_DEBUG_RULE( equation );
00480 BOOST_SPIRIT_DEBUG_RULE( cond_expr );
00481 BOOST_SPIRIT_DEBUG_RULE( not_expr );
00482 BOOST_SPIRIT_DEBUG_RULE( and_expr );
00483 BOOST_SPIRIT_DEBUG_RULE( or_expr );
00484
00485 BOOST_SPIRIT_DEBUG_RULE( filter_statement );
00486 BOOST_SPIRIT_DEBUG_RULE( literal );
00487 BOOST_SPIRIT_DEBUG_RULE( boolean );
00488 BOOST_SPIRIT_DEBUG_RULE( number );
00489 BOOST_SPIRIT_DEBUG_RULE( string_ );
00490 BOOST_SPIRIT_DEBUG_RULE( property );
00491 BOOST_SPIRIT_DEBUG_RULE( function );
00492 BOOST_SPIRIT_DEBUG_RULE( regex );
00493 #endif
00494 }
00495
00496 boost::spirit::rule<ScannerT> const& start() const
00497 {
00498 return filter_statement;
00499 }
00500
00501 boost::spirit::rule<ScannerT> factor;
00502 boost::spirit::rule<ScannerT> term;
00503 boost::spirit::rule<ScannerT> expression;
00504 boost::spirit::rule<ScannerT> relation;
00505 boost::spirit::rule<ScannerT> equation;
00506 boost::spirit::rule<ScannerT> cond_expr;
00507 boost::spirit::rule<ScannerT> not_expr;
00508 boost::spirit::rule<ScannerT> and_expr;
00509 boost::spirit::rule<ScannerT> or_expr;
00510
00511 boost::spirit::rule<ScannerT> filter_statement;
00512 boost::spirit::rule<ScannerT> literal;
00513 boost::spirit::rule<ScannerT> boolean;
00514 boost::spirit::rule<ScannerT> number;
00515 boost::spirit::rule<ScannerT> string_;
00516 boost::spirit::rule<ScannerT> property;
00517 boost::spirit::rule<ScannerT> function;
00518 boost::spirit::rule<ScannerT> regex;
00519 symbols<string> func1_op;
00520 symbols<string> func2_op;
00521 symbols<string> spatial_op;
00522 symbols<string> boolean_const;
00523
00524
00525 };
00526 stack<shared_ptr<filter<FeatureT> > >& filters;
00527 stack<shared_ptr<expression<FeatureT> > >& exprs;
00528 transcoder const& tr;
00529 };
00530 }
00531
00532 #endif //FILTER_PARSER_HPP