From fcc9638f46f30d3aa0c004a550f830444669fd47 Mon Sep 17 00:00:00 2001 From: Artem Pavlenko Date: Tue, 3 May 2005 18:28:16 +0000 Subject: [PATCH] pre-scons update --- include/Makefile.am | 2 +- include/attribute.hh | 4 +- include/attribute_collector.hh | 28 +- include/comparison.hh | 212 ++++--------- include/expression.hh | 99 ++++-- include/feature.hh | 2 +- include/filter.hh | 56 ++-- include/filter_factory.hh | 52 +++ include/filter_parser.hh | 306 ++++++++++++++++++ include/filter_parser_ast.hh | 261 +++++++++++++++ include/filter_visitor.hh | 10 +- include/geometry.hh | 21 +- include/layer.hh | 2 +- include/line_symbolizer.hh | 100 +++--- include/local_datasource.hh | 47 +++ include/logical.hh | 109 ++++--- include/mapnik.hh | 7 +- include/math_expr.hh | 106 +++++++ include/spatial.hh | 106 +++---- include/style_cache.hh | 2 +- include/value.hh | 565 +++++++++++++++++++++++++++++++++ src/Makefile.am | 10 +- src/Makefile.in | 93 +++--- src/local_datasource.cc | 42 +++ src/render.cc | 4 +- src/shape/Makefile.am | 2 +- src/shape/Makefile.in | 4 +- src/style_cache.cc | 13 +- utils/shapeindex/Makefile.am | 1 + utils/shapeindex/Makefile.in | 5 +- 30 files changed, 1808 insertions(+), 463 deletions(-) create mode 100644 include/filter_factory.hh create mode 100644 include/filter_parser.hh create mode 100644 include/filter_parser_ast.hh create mode 100644 include/local_datasource.hh create mode 100644 include/math_expr.hh create mode 100644 include/value.hh create mode 100644 src/local_datasource.cc diff --git a/include/Makefile.am b/include/Makefile.am index a7907003e..7116aea38 100644 --- a/include/Makefile.am +++ b/include/Makefile.am @@ -1 +1 @@ -nobase_include_HEADERS = attribute.hh color.hh config.hh coord.hh coord_array.hh vertex_vector.hh ctrans.hh datasource.hh datasource_cache.hh factory.hh feature.hh query.hh filter.hh filter_visitor.hh envelope.hh gamma.hh geometry.hh geom_util.hh graphics.hh image_data.hh image_reader.hh image_util.hh layer.hh line_aa.hh map.hh mapnik.hh memory.hh params.hh plugin.hh line_symbolizer.hh polygon_symbolizer.hh image_symbolizer.hh pool.hh ptr.hh raster.hh render.hh scanline_aa.hh scanline.hh style.hh style_cache.hh style_factory.hh symbolizer.hh text.hh utils.hh vertex.hh vertex_transform.hh wkb.hh logical.hh rule.hh comparison.hh fill.hh spatial.hh expression.hh stroke.hh attribute_collector.hh colorcube.hh feature_type_style.hh +nobase_include_HEADERS = attribute.hh color.hh config.hh coord.hh coord_array.hh vertex_vector.hh ctrans.hh datasource.hh datasource_cache.hh factory.hh feature.hh query.hh filter.hh filter_visitor.hh envelope.hh gamma.hh geometry.hh geom_util.hh graphics.hh image_data.hh image_reader.hh image_util.hh layer.hh line_aa.hh map.hh mapnik.hh math_expr.hh memory.hh params.hh plugin.hh line_symbolizer.hh polygon_symbolizer.hh image_symbolizer.hh pool.hh ptr.hh raster.hh render.hh scanline_aa.hh scanline.hh style.hh style_cache.hh style_factory.hh symbolizer.hh text.hh utils.hh vertex.hh vertex_transform.hh wkb.hh logical.hh rule.hh comparison.hh fill.hh spatial.hh expression.hh stroke.hh attribute_collector.hh colorcube.hh feature_type_style.hh value.hh filter_parser.hh filter_factory.hh diff --git a/include/attribute.hh b/include/attribute.hh index 302a87fa8..7d9ebaf00 100644 --- a/include/attribute.hh +++ b/include/attribute.hh @@ -121,6 +121,7 @@ namespace mapnik { return ATraits::to_string(value_); } + attribute_base* clone() const { return new attribute_impl(value_); @@ -136,7 +137,8 @@ namespace mapnik public: attribute_base* base_; }; - + + template struct bad_attribute_cast : public std::bad_cast { diff --git a/include/attribute_collector.hh b/include/attribute_collector.hh index 7a081e533..96135b8a0 100644 --- a/include/attribute_collector.hh +++ b/include/attribute_collector.hh @@ -21,36 +21,40 @@ #ifndef ATTRIBUTE_COLLECTOR #define ATTROBUTE_COLLECTOR -#include "filter_visitor.hh" +#include "filter.hh" +#include "expression.hh" #include -#include "comparison.hh" namespace mapnik { - template - class attribute_collector : public filter_visitor + template + class attribute_collector : public filter_visitor { private: std::set names_; public: attribute_collector() {} - void visit(filter& filter) - { - property_filter* pf_; - if((pf_=dynamic_cast*>(&filter))) + void visit(filter& /*filter*/) + { + //not interested + } + void visit(expression& exp) + { + property* pf; + if ((pf = dynamic_cast*>(&exp))) { - names_.insert(pf_->name_); + names_.insert(pf->name()); } } - const std::set& property_names() const + std::set const& property_names() const { return names_; } virtual ~attribute_collector() {} private: - attribute_collector(const attribute_collector&); - attribute_collector& operator=(const attribute_collector&); + attribute_collector(attribute_collector const&); + attribute_collector& operator=(attribute_collector const&); }; } diff --git a/include/comparison.hh b/include/comparison.hh index 10676e0fc..29bb89867 100644 --- a/include/comparison.hh +++ b/include/comparison.hh @@ -24,186 +24,96 @@ #include "filter.hh" #include "expression.hh" -#include "feature.hh" #include "attribute.hh" namespace mapnik -{ - - template - struct property_filter : public filter { - const std::string name_; - explicit property_filter(const std::string& name) - : name_(name) {} - virtual ~property_filter() {} +{ + template + struct greater_than + { + bool operator() (T const& left, T const& right) const + { + return left > right; + } }; - template - struct property_is_equal_to : public property_filter + template + struct greater_than_or_equal { - using property_filter::name_; - T value_; - - property_is_equal_to(const std::string& name,const T& value) - : property_filter(name), value_(value) {} - - int type() const + bool operator() (T const& left, T const& right) const { - return filter::COMPARISON_OPS; + return left >= right; } - - bool pass(const Feature& feature) const + }; + template + struct less_than + { + bool operator() (T const& left, T const& right) const { - const attribute& attr=feature.attribute_by_name(name_); - bool result=false; - try - { - result=(value_ == attribute_cast(attr)) ? true:false; - } - catch (bad_attribute_cast& ex) - { - std::cerr<* clone() const + }; + template + struct less_than_or_equal + { + bool operator() (T const& left, T const& right) const { - return new property_is_equal_to(name_,value_); + return left <= right; } - - void accept(filter_visitor& v) + }; + template + struct equals + { + bool operator() (T const& left, T const& right) const { - v.visit(*this); + return left == right; } - - virtual ~property_is_equal_to() {} }; - template - struct property_is_greater_then : public property_filter - { - using property_filter::name_; - T value_; - property_is_greater_then(const std::string& name,const T& value) - : property_filter(name), value_(value) {} - - int type() const + template + struct not_equals + { + bool operator() (T const& left, T const& right) const { - return filter::COMPARISON_OPS; + return left != right; } - - bool pass(const Feature& feature) const - { - const attribute& attr=feature.attribute_by_name(name_); - bool result=false; - try - { - result = (value_ < attribute_cast(attr))?true:false; - } - catch (bad_attribute_cast& ex) - { - std::cerr<* clone() const - { - return new property_is_greater_then(name_,value_); - } - void accept(filter_visitor& v) - { - v.visit(*this); - } - - virtual ~property_is_greater_then() {} }; - template - struct property_is_less_then : public property_filter + template + struct compare_filter : public filter { - using property_filter::name_; - T value_; - property_is_less_then(const std::string& name,const T& value) - : property_filter(name), value_(value) {} + compare_filter(expression const& left, + expression const& right) + : filter(), + left_(left.clone()), right_(right.clone()) {} - int type() const - { - return filter::COMPARISON_OPS; - } + compare_filter(compare_filter const& other) + : filter(), + left_(other.left_->clone()),right_(other.right_->clone()) {} - bool pass(const Feature& feature) const + bool pass(const FeatureT& feature) const { - const attribute& attr=feature.attribute_by_name(name_); - bool result=false; - try - { - result=(value_ > attribute_cast(attr))?true:false; - } - catch (bad_attribute_cast& ex) - { - std::cerr<get_value(feature),right_->get_value(feature)); } - - filter* clone() const - { - return new property_is_less_then(name_,value_); - } - - void accept(filter_visitor& v) + void accept(filter_visitor& v) { + left_->accept(v); + right_->accept(v); v.visit(*this); } - virtual ~property_is_less_then() {} + filter* clone() const + { + return new compare_filter(*this); + } + virtual ~compare_filter() + { + delete left_; + delete right_; + } + private: + expression* left_; + expression* right_; }; - - template - struct property_is_between : public property_filter - { - using property_filter::name_; - T lo_value_; - T hi_value_; - - property_is_between(const std::string& name,const T& lo_value,const T& hi_value) - : property_filter(name), - lo_value_(lo_value), - hi_value_(hi_value) {} - - int type() const - { - return filter::COMPARISON_OPS; - } - - bool pass(const Feature& feature) const - { - const attribute& attr=feature.attribute_by_name(name_); - bool result=false; - try - { - T const& a=attribute_cast(attr); - result=(lo_value_ < a && a < hi_value_) ? true : false; - } - catch (bad_attribute_cast& ex) - { - std::cerr<* clone() const - { - return new property_is_between(name_,lo_value_,hi_value_); - } - - void accept(filter_visitor& v) - { - v.visit(*this); - } - - virtual ~property_is_between() {} - }; } #endif //COMPARISON_HH diff --git a/include/expression.hh b/include/expression.hh index 30e6941cb..0500c1e4b 100644 --- a/include/expression.hh +++ b/include/expression.hh @@ -16,48 +16,97 @@ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */ +//$Id$ + #ifndef EXPRESSION_HH #define EXPRESSION_HH +#include "value.hh" +#include "filter_visitor.hh" + namespace mapnik { - //arithmetic expressions - template - struct add + template class filter_visitor; + template + struct expression { - T operator()(T operand1,T operand2) const - { - return operand1 + operand2; - } + virtual value get_value(FeatureT const& feature) const=0; + virtual void accept(filter_visitor& v)=0; + virtual expression* clone() const=0; + virtual ~expression() {} }; - template - struct divide + template + class literal : public expression { - T operator()(T operand1,T operand2) const + public: + literal(int val) + : expression(), + value_(val) {} + literal(double val) + : expression(), + value_(val) {} + literal(std::string const& val) + : expression(), + value_(val) {} + literal(literal const& other) + : expression(), + value_(other.value_) {} + + value get_value(FeatureT const& /*feature*/) const { - assert(operand2); - return operand1 / operand2; + return value_; } + void accept(filter_visitor& v) + { + v.visit(*this); + } + expression* clone() const + { + return new literal(*this); + } + + ~literal() {} + private: + value value_; + }; - - template - struct mult + + + template + class property : public expression { - T operator() (T operand1,T operand2) const + public: + property(std::string const& name) + : expression(), + name_(name) {} + + property(property const& other) + : expression(), + name_(other.name_) {} + + value get_value(FeatureT const& feature) const { - return operand1 * operand2; + const attribute& attr=feature.attribute_by_name(name_); + return value(attr); } + void accept(filter_visitor& v) + { + v.visit(*this); + } + expression* clone() const + { + return new property(*this); + } + std::string const& name() const + { + return name_; + } + ~property() {} + private: + std::string name_; }; - template - struct sub - { - T operator() (T operand1,T operand2) const - { - return operand1 - operand2; - } - }; } #endif //EXPRESSION_HH diff --git a/include/feature.hh b/include/feature.hh index 93a65ed9f..da5e8e022 100644 --- a/include/feature.hh +++ b/include/feature.hh @@ -97,7 +97,7 @@ namespace mapnik typename attributes::const_iterator pos=attr_.find(name); if (pos!=attr_.end()) return pos->second; - static attribute empty; + static attribute empty(0); return empty; } diff --git a/include/filter.hh b/include/filter.hh index 434a135be..033cbb088 100644 --- a/include/filter.hh +++ b/include/filter.hh @@ -16,63 +16,47 @@ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */ -// $Id$ +//$Id$ #ifndef FILTER_HH #define FILTER_HH -#include "envelope.hh" -#include "feature.hh" #include "filter_visitor.hh" - +#include "feature.hh" namespace mapnik { typedef ref_ptr > filter_ptr; - template + template class filter_visitor; + template struct filter { - enum { - NULL_OPS, - SPATIAL_OPS, - COMPARISON_OPS, - LOGICAL_OPS, - FEATUREID_OPS - }; - - virtual int type() const=0; - virtual bool pass (const Feature& feature) const = 0; - virtual filter* clone() const = 0; - virtual void accept(filter_visitor& v) = 0; + virtual bool pass(const FeatureT& feature) const=0; + virtual filter* clone() const=0; + virtual void accept(filter_visitor& v) = 0; virtual ~filter() {} }; - - template - struct null_filter : public filter - { - typedef filter _Base_; - int type() const - { - return _Base_::NULL_OPS; - } - bool pass (const Feature&) const + + template + struct null_filter : public filter + { + + bool pass (const FeatureT&) const { return true; } - - _Base_* clone() const - { - return new null_filter; - } - - void accept(filter_visitor& v) + + filter* clone() const { - v.visit(*this); + return new null_filter; } + void accept(filter_visitor&) + {} + virtual ~null_filter() {} - ~null_filter() {} }; + } #endif //FILTER_HH diff --git a/include/filter_factory.hh b/include/filter_factory.hh new file mode 100644 index 000000000..7602762a7 --- /dev/null +++ b/include/filter_factory.hh @@ -0,0 +1,52 @@ +/* This file is part of Mapnik (c++ mapping toolkit) + * Copyright (C) 2005 Artem Pavlenko + * + * Mapnik is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or any later version. + * + * This program 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 General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. + */ + +//$Id$ + +#include "filter_parser.hh" + +using std::string; + +namespace mapnik +{ + template + class filter_factory + { + public: + filter_factory() {} + filter_ptr compile(string const& str) const + { + stack > > filters; + stack > > exps; + filter_grammar grammar(filters,exps); + char const *text = str.c_str(); + parse_info<> info = parse(text,text+strlen(text),grammar,space_p); + if (info.full && !filters.empty()) + { + cout<<"success parsing filter expression\n"; + return filters.top(); + } + else + { + cout << "failed at: \": " << info.stop << "\n"; + return filter_ptr(new null_filter()); + } + } + + }; +} diff --git a/include/filter_parser.hh b/include/filter_parser.hh new file mode 100644 index 000000000..dddc9ed6a --- /dev/null +++ b/include/filter_parser.hh @@ -0,0 +1,306 @@ +/* This file is part of Mapnik (c++ mapping toolkit) + * Copyright (C) 2005 Artem Pavlenko + * + * Mapnik is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or any later version. + * + * This program 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 General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. + */ + +//$Id$ + +#ifndef FILTER_PARSER_HH +#define FILTER_PARSER_HH + +#include +#include + +#include "value.hh" +#include "expression.hh" +#include "filter.hh" + +#include +#include + +using namespace boost::spirit; +using std::string; +using std::cout; +using std::stack; + +namespace mapnik +{ + template + struct push_integer + { + push_integer(stack > >& exprs) + : exprs_(exprs) {} + + void operator() (int val) const + { + cout << "push int("< >(new literal(val))); + } + stack > >& exprs_; + }; + + template + struct push_real + { + push_real(stack > >& exprs) + : exprs_(exprs) {} + void operator() (double val) const + { + cout << "push real("< >(new literal(val))); + } + stack > >& exprs_; + }; + + template + struct push_string + { + push_string(stack > >& exprs) + : exprs_(exprs) {} + + template + void operator() (Iter start,Iter end) const + { + string str(start,end); + cout << "push string("< >(new literal(str))); + } + stack > >& exprs_; + }; + + template + struct push_property + { + push_property(stack > >& exprs) + : exprs_(exprs) {} + + template + void operator() (Iter start,Iter end) const + { + string str(start,end); + cout << "property name ["< >(new property(str))); + } + stack > >& exprs_; + }; + + template + struct compose_expression + { + compose_expression(stack > >& exprs) + : exprs_(exprs) {} + + template + void operator() (Iter,Iter) const + { + if (exprs_.size()>=2) + { + ref_ptr > right = exprs_.top(); + exprs_.pop(); + ref_ptr > left = exprs_.top(); + exprs_.pop(); + if (left && right) + { + exprs_.push(ref_ptr >(new math_expr_b(*left,*right))); + } + } + } + stack > >& exprs_; + }; + + template + struct compose_filter + { + compose_filter(stack > >& filters, + stack > >& exprs) + : filters_(filters),exprs_(exprs) {} + + template + void operator() (Iter,Iter) const + { + if (exprs_.size()>=2) + { + ref_ptr > right = exprs_.top(); + exprs_.pop(); + ref_ptr > left = exprs_.top(); + exprs_.pop(); + if (left && right) + { + filters_.push(ref_ptr >(new compare_filter(*left,*right))); + } + } + } + stack > >& filters_; + stack > >& exprs_; + }; + + template + struct compose_and_filter + { + compose_and_filter(stack > >& filters) + : filters_(filters) {} + + template + void operator() (Iter,Iter) const + { + if (filters_.size()>=2) + { + ref_ptr > right = filters_.top(); + filters_.pop(); + ref_ptr > left = filters_.top(); + filters_.pop(); + if (left && right) + { + filters_.push(ref_ptr >(new logical_and(*left,*right))); + } + } + } + stack > >& filters_; + }; + + template + struct compose_or_filter + { + compose_or_filter(stack > >& filters) + : filters_(filters) {} + + template + void operator() (Iter,Iter) const + { + if (filters_.size()>=2) + { + ref_ptr > right = filters_.top(); + filters_.pop(); + ref_ptr > left = filters_.top(); + filters_.pop(); + if (left && right) + { + filters_.push(ref_ptr >(new logical_or(*left,*right))); + } + } + } + stack > >& filters_; + }; + + template + struct compose_not_filter + { + compose_not_filter(stack > >& filters) + : filters_(filters) {} + + template + void operator() (Iter,Iter) const + { + if (filters_.size()>=1) + { + ref_ptr > filter_ = filters_.top(); + filters_.pop(); + if (filter_) + { + filters_.push(ref_ptr >(new logical_not(*filter_))); + } + } + } + stack > >& filters_; + }; + + template + struct filter_grammar : public grammar > + { + filter_grammar(stack > >& filters_, + stack > >& exprs_) + : filters(filters_),exprs(exprs_) {} + + template + struct definition + { + definition(filter_grammar const& self) + { + + func1_op = "sqrt","sin","cos"; + func2_op = "min","max"; + spatial_op = "Equals","Disjoint","Touches","Within","Overlaps", + "Crosses","Intersects","Contains","DWithin","Beyond","BBOX"; + + number = strict_real_p [push_real(self.exprs)] + | int_p [push_integer(self.exprs)]; + string_ ='\''>> ( (alpha_p | '_') >> + * (alnum_p | '_' )) [push_string(self.exprs)] >> '\''; + property = '[' >> ( (alpha_p | '_') + >> * (alnum_p | '_' ))[push_property(self.exprs)]>>']'; + + literal = number | string_ | property; + + function = literal | ( func1_op >> '('>> literal >> ')') | + (func2_op >> '(' >> literal >>','>> literal >> ')'); + factor = function + | '(' >> or_expr >> ')' + | ( '-' >> factor) + ; + term = factor + >> *(('*' >> factor) [compose_expression >(self.exprs)] + | ('/' >> factor) [compose_expression >(self.exprs)]); + + expression = term >> *(('+' >> term) [compose_expression >(self.exprs)] + | ('-' >> term) [compose_expression >(self.exprs)]); + + relation = expression + >> *((">=" >> expression) + [compose_filter >(self.filters,self.exprs)] + | ('>' >> expression) + [compose_filter >(self.filters,self.exprs)] + | ('<' >> expression) + [compose_filter >(self.filters,self.exprs)] + | ("<=" >> expression) + [compose_filter >(self.filters,self.exprs)]); + + equation = relation >> *( ( '=' >> relation) + [compose_filter >(self.filters,self.exprs)] + | ( "<>" >> relation) + [compose_filter >(self.filters,self.exprs)]); + not_expr = equation | *(str_p("not") >> equation)[compose_not_filter(self.filters)]; + and_expr = not_expr >> *("and" >> not_expr)[compose_and_filter(self.filters)]; + or_expr = and_expr >> *("or" >> and_expr)[compose_or_filter(self.filters)]; + filter_statement = or_expr; + } + + boost::spirit::rule const& start() const + { + return filter_statement; + } + + boost::spirit::rule factor; + boost::spirit::rule term; + boost::spirit::rule expression; + boost::spirit::rule relation; + boost::spirit::rule equation; + boost::spirit::rule not_expr; + boost::spirit::rule and_expr; + boost::spirit::rule or_expr; + + boost::spirit::rule filter_statement; + boost::spirit::rule literal,number,string_,property,function; + symbols func1_op; + symbols func2_op; + symbols spatial_op; + }; + stack > >& filters; + stack > >& exprs; + }; + +} + +#endif //FILTER_PARSER_HH diff --git a/include/filter_parser_ast.hh b/include/filter_parser_ast.hh new file mode 100644 index 000000000..3e01f3d5f --- /dev/null +++ b/include/filter_parser_ast.hh @@ -0,0 +1,261 @@ +/* This file is part of Mapnik (c++ mapping toolkit) + * Copyright (C) 2005 Artem Pavlenko + * + * Mapnik is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or any later version. + * + * This program 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 General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. + */ + +//$Id$ + +#ifndef FILTER_PARSER_AST_HH +#define FILTER_PARSER_AST_HH + +#include +#include + +#include + +using namespace std; +using namespace boost::spirit; + +namespace mapnik +{ + struct filter_grammar_ast : public grammar + { + + static const int integerID = 1; + static const int realID = 2; + static const int stringID = 3; + static const int propertyID = 4; + static const int factorID = 5; + static const int termID = 6; + static const int expressionID = 7; + static const int relationID = 8; + static const int equationID = 9; + static const int and_exprID = 10; + static const int or_exprID = 11; + + template + struct definition + { + + definition(filter_grammar_ast const& /*self*/) + { + real = leaf_node_d[strict_real_p]; + integer = leaf_node_d[int_p]; + number = real | integer; + + string_ = inner_node_d['\''>> leaf_node_d[( (alpha_p | '_') >> + * (alnum_p | '_' ))] >> '\'']; + + property = inner_node_d['[' >> leaf_node_d[ ( (alpha_p | '_') >> * (alnum_p | '_' )) ] >> ']']; + + literal = number | string_ | property; + + factor = literal + | (root_node_d[str_p("not")] >> literal) + | inner_node_d[ch_p('(') >> or_expr >> ch_p(')') ] + | (root_node_d[ch_p('-')] >> factor) + ; + + term = factor + >> *((root_node_d[ch_p('*')] >> factor) | (root_node_d[ch_p('/')] >> factor)); + + expression = term >> *((root_node_d[ch_p('+')] >> term) | (root_node_d[ch_p('-')] >> term)); + relation = expression >> *((root_node_d[str_p(">=")] >> expression) + | (root_node_d[ch_p('>')] >> expression) + | (root_node_d[ch_p('<')] >> expression) + | (root_node_d[str_p("<=")] >> expression)); + + equation = relation >> *( (root_node_d[ch_p('=')] >> relation) + | (root_node_d[str_p("<>")] >> relation)); + and_expr = equation >> *(root_node_d[str_p("and")] >> equation); + or_expr = and_expr >> *(root_node_d[str_p("or")] >> and_expr); + + //spatial_op = str_p("Equals") | "Disjoint" | "Touches" | "Within" + // | "Overlaps" | "Crosses" | "Intersects" | "Contains" | "DWithin" | "Beyond" | "BBOX"; + + filter_statement = or_expr; + } + + rule const& start() const + { + return filter_statement; + } + + rule, parser_tag > factor; + rule, parser_tag > term; + rule, parser_tag > expression; + rule, parser_tag > relation; + rule, parser_tag > equation; + + rule, parser_tag > and_expr; + rule, parser_tag > or_expr; + + rule filter_statement; + rule literal,number; + + rule, parser_tag > integer; + rule, parser_tag > real; + rule, parser_tag > string_; + rule, parser_tag > property; + + + //rule spatial_op; + + }; + + }; + + class node_data + { + public: + enum { + Unknown=0, + Integer=1, + Real =2, + String =3, + Property=4 + }; + node_data() + : type_(Unknown) {} + + node_data(int type) + : type_(type) {} + + node_data(node_data const& other) + : type_(other.type_) {} + + node_data& operator=(node_data const& other) + { + if (this==&other) + return *this; + type_=other.type_; + return *this; + } + ~node_data() {} + private: + int type_; + }; + + typedef char const* iterator_t; + typedef node_val_data_factory factory_t; + typedef tree_match::tree_iterator iter_t; + + void process_node(iter_t const&,string&); + + void walk_ast_tree(tree_parse_info info,string& text) + { + process_node(info.trees.begin(),text); + } + + void process_node(iter_t const& i,string& text) + { + //cout << "In eval_expression. i->value = " << + // string(i->value.begin(), i->value.end()) << + // " i->children.size() = " << i->children.size() << endl; + //std::cout<value.id() == filter_grammar_ast::integerID) + { + assert(i->children.size()==0); + string integer(i->value.begin(), i->value.end()); + text+= integer; + } + else if (i->value.id() == filter_grammar_ast::realID) + { + assert(i->children.size()==0); + string real(i->value.begin(), i->value.end()); + text += real; + } + else if (i->value.id() == filter_grammar_ast::stringID) + { + assert(i->children.size()==0); + string str(i->value.begin(), i->value.end()); + text += str; + } + else if (i->value.id() == filter_grammar_ast::propertyID) + { + assert(i->children.size()==0); + string property_name(i->value.begin(), i->value.end()); + text += property_name; + } + else if (i->value.id() == filter_grammar_ast::expressionID) + { + assert(i->children.size() == 2); + assert(!i->children.begin()->value.is_root()); + process_node(i->children.begin(),text); + text += string(i->value.begin(), i->value.end()); + process_node(i->children.begin()+1,text); + + text +="\n"; + } + else if (i->value.id() == filter_grammar_ast::termID) + { + assert(i->children.size() == 2); + assert(!i->children.begin()->value.is_root()); + process_node(i->children.begin(),text); + text += string(i->value.begin(), i->value.end()); + process_node(i->children.begin()+1,text); + + text +="\n"; + + } + else if (i->value.id() == filter_grammar_ast::relationID) + { + assert(i->children.size() == 2); + assert(!i->children.begin()->value.is_root()); + process_node(i->children.begin(),text); + text += string(i->value.begin(), i->value.end()); + process_node(i->children.begin()+1,text); + + text +="\n"; + + } + else if (i->value.id() == filter_grammar_ast::equationID) + { + assert(i->children.size() == 2); + assert(!i->children.begin()->value.is_root()); + process_node(i->children.begin(),text); + text += string(i->value.begin(), i->value.end()); + process_node(i->children.begin()+1,text); + + text +="\n"; + } + else if (i->value.id() == filter_grammar_ast::and_exprID) + { + assert(i->children.size() == 2); + assert(!i->children.begin()->value.is_root()); + process_node(i->children.begin(),text); + text += string(i->value.begin(), i->value.end()); + process_node(i->children.begin()+1,text); + + text +="\n"; + } + else if (i->value.id() == filter_grammar_ast::or_exprID) + { + assert(i->children.size() == 2); + assert(!i->children.begin()->value.is_root()); + + process_node(i->children.begin(),text); + text += string(i->value.begin(), i->value.end()); + process_node(i->children.begin()+1,text); + + text +="\n"; + + } + } +} + +#endif //FILTER_PARSER_AST_HH diff --git a/include/filter_visitor.hh b/include/filter_visitor.hh index aa21738ab..5e697e89b 100644 --- a/include/filter_visitor.hh +++ b/include/filter_visitor.hh @@ -20,15 +20,17 @@ #define FILTER_VISITOR_HH #include "filter.hh" -#include "feature.hh" +#include "expression.hh" namespace mapnik { - template class filter; - template + template class filter; + template class expression; + template struct filter_visitor { - virtual void visit(filter& filter)=0; + virtual void visit(filter& filter)=0; + virtual void visit(expression&)=0; virtual ~filter_visitor() {} }; } diff --git a/include/geometry.hh b/include/geometry.hh index e8f8b0411..486dc8ca1 100644 --- a/include/geometry.hh +++ b/include/geometry.hh @@ -70,16 +70,7 @@ namespace mapnik { cont_.push_back(x,y,SEG_LINETO); } - - //unsigned vertex(double* x, double* y) - // { - // return cont_.get_vertex(itr_++,x,y); - // } - - //void rewind(unsigned ) - // { - // itr_=0; - // } + template class path_iterator { @@ -173,6 +164,16 @@ namespace mapnik return cont_.size(); } + unsigned vertex(double* x, double* y) + { + return cont_.get_vertex(itr_++,x,y); + } + + void rewind(unsigned ) + { + itr_=0; + } + virtual ~geometry() {} private: geometry(const geometry&); diff --git a/include/layer.hh b/include/layer.hh index 3b9f016f6..6c390e5c4 100644 --- a/include/layer.hh +++ b/include/layer.hh @@ -24,10 +24,10 @@ #include #include "feature.hh" #include "ptr.hh" +#include "datasource.hh" namespace mapnik { - class Layer { private: diff --git a/include/line_symbolizer.hh b/include/line_symbolizer.hh index 7e48378ef..c2b3568c0 100644 --- a/include/line_symbolizer.hh +++ b/include/line_symbolizer.hh @@ -21,28 +21,29 @@ #ifndef LINE_SYMBOLIZER_HH #define LINE_SYMBOLIZER_HH -//#include "agg_basics.h" -//#include "agg_rendering_buffer.h" -//#include "agg_rasterizer_scanline_aa.h" -//#include "agg_conv_stroke.h" -//#include "agg_conv_dash.h" -//#include "agg_conv_curve.h" -//#include "agg_conv_contour.h" -//#include "agg_conv_stroke.h" -//#include "agg_vcgen_stroke.h" -//#include "agg_conv_adaptor_vcgen.h" -//#include "agg_conv_smooth_poly1.h" -//#include "agg_conv_marker.h" -//#include "agg_arrowhead.h" -//#include "agg_vcgen_markers_term.h" -//#include "agg_scanline_p.h" -//#include "agg_renderer_scanline.h" -//#include "agg_pixfmt_rgba32.h" -//#include "agg_path_storage.h" -//#include "agg_renderer_outline_aa.h" -//#include "agg_rasterizer_outline_aa.h" -//#include "agg_rasterizer_outline.h" -//#include "agg_renderer_outline_image.h" +#include "agg_basics.h" +#include "agg_rendering_buffer.h" +#include "agg_rasterizer_scanline_aa.h" +#include "agg_conv_stroke.h" +#include "agg_conv_curve.h" +#include "agg_conv_dash.h" +#include "agg_conv_contour.h" +#include "agg_conv_stroke.h" +#include "agg_vcgen_stroke.h" +#include "agg_conv_adaptor_vcgen.h" +#include "agg_conv_smooth_poly1.h" +#include "agg_conv_marker.h" +#include "agg_arrowhead.h" +#include "agg_vcgen_markers_term.h" +#include "agg_scanline_p.h" +#include "agg_scanline_u.h" +#include "agg_renderer_scanline.h" +#include "agg_pixfmt_rgba32.h" +#include "agg_path_storage.h" +#include "agg_renderer_outline_aa.h" +#include "agg_rasterizer_outline_aa.h" +#include "agg_rasterizer_outline.h" +#include "agg_renderer_outline_image.h" #include "symbolizer.hh" #include "line_aa.hh" @@ -50,6 +51,7 @@ namespace mapnik { + struct LineSymbolizer : public SymbolizerImpl { private: @@ -68,14 +70,15 @@ namespace mapnik void render(geometry_type& geom, Image32& image) const { + typedef agg::renderer_base ren_base; - if (1) //width_ == 1.0) - { + if (width_ == 1.0) + { //typedef agg::renderer_outline_aa renderer_oaa; //typedef agg::rasterizer_outline_aa rasterizer_outline_aa; //agg::line_profile_aa prof; //prof.width(1.0); - //renderer_oaa ren_oaa(renb, prof); + //renderer_oaa ren_oaa(ren_base, prof); //rasterizer_outline_aa ras_oaa(ren_oaa); //ren_oaa.color(agg::rgba(r, g, b)); @@ -86,32 +89,37 @@ namespace mapnik else { - //typedef agg::renderer_base ren_base; - //agg::row_ptr_cache buf(image.raw_data(),image.width(),image.height(),image.width()*4); - //agg::pixfmt_rgba32 pixf(buf); - //ren_base renb(pixf); + typedef agg::renderer_base ren_base; + agg::row_ptr_cache buf(image.raw_data(),image.width(),image.height(),image.width()*4); + agg::pixfmt_rgba32 pixf(buf); + ren_base renb(pixf); - //double r=pen_.red()/255.0; - //double g=pen_.green()/255.0; - //double b=pen_.blue()/255.0; + double r=pen_.red()/255.0; + double g=pen_.green()/255.0; + double b=pen_.blue()/255.0; - //typedef agg::renderer_scanline_aa_solid renderer; - //renderer ren(renb); - //ren.color(agg::rgba(r, g, b)); + typedef agg::renderer_scanline_aa_solid renderer; + renderer ren(renb); - //agg::rasterizer_scanline_aa<> ras; - //agg::scanline_p8 sl; - //agg::conv_adaptor_vcgen, - // agg::vcgen_stroke,agg::null_markers> stroke(geom); - //stroke.generator().line_join(agg::round_join); - //stroke.generator().line_cap(agg::round_cap); - //stroke.generator().miter_limit(2.0); - //stroke.generator().width(width_); + + agg::rasterizer_scanline_aa<> ras; + agg::scanline_p8 sl; + + agg::conv_adaptor_vcgen, + agg::vcgen_stroke,agg::null_markers> stroke(geom); + stroke.generator().line_join(agg::round_join); + stroke.generator().line_cap(agg::round_cap); + stroke.generator().miter_limit(2.0); + stroke.generator().width(width_); + //ScanlineRasterizerAA rasterizer(image); + ras.add_path(stroke); //rasterizer.render, - // agg::vcgen_stroke,agg::null_markers> >(stroke,pen_); - //ras.add_path(stroke); - //agg::render_scanlines(ras, sl, ren); + // agg::vcgen_stroke,agg::null_markers> >(stroke,pen_); + ras.add_path(stroke); + ren.color(agg::rgba(r, g, b)); + + agg::render_scanlines(ras, sl, ren); } } diff --git a/include/local_datasource.hh b/include/local_datasource.hh new file mode 100644 index 000000000..219e71a05 --- /dev/null +++ b/include/local_datasource.hh @@ -0,0 +1,47 @@ +/* This file is part of Mapnik (c++ mapping toolkit) + * Copyright (C) 2005 Artem Pavlenko + * + * Mapnik is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or any later version. + * + * This program 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 General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. + */ + +//$Id$ + +#ifndef LOCAL_DATASOURCE_HH +#define LOCAL_DATASOURCE_HH + +#include "mapnik.hh" +#include + +namespace mapnik +{ + /* + class local_datasource : public datasource + { + public: + local_datasource(Parameters const& params); + int type() const; + static std::string name(); + featureset_ptr features(query const& q) const; + const Envelope& envelope() const; + virtual ~local_datasource(); + private: + static std::string name_; + Envelope extent_; + std::vector + }; + */ +} + +#endif //LOCAL_DATASOURCE_HH diff --git a/include/logical.hh b/include/logical.hh index 5c15e4d8d..bbb0036e4 100644 --- a/include/logical.hh +++ b/include/logical.hh @@ -16,40 +16,41 @@ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */ -//$Id: logical.hh 11 2005-03-16 19:46:18Z artem $ - +//$Id$ #ifndef LOGICAL_HH #define LOGICAL_HH #include "filter.hh" -#include "feature.hh" namespace mapnik { - template - struct logical_and : public filter + template + struct logical_and : public filter { - logical_and(const filter& filter1,const filter& filter2) - : filter1_(filter1.clone()), + logical_and(filter const& filter1, + filter const& filter2) + : filter(), + filter1_(filter1.clone()), filter2_(filter2.clone()) {} + + logical_and(logical_and const& other) + : filter(), + filter1_(other.filter1_->clone()), + filter2_(other.filter2_->clone()) {} - int type() const - { - return filter::LOGICAL_OPS; - } - - bool pass(const Feature& feature) const + bool pass(const FeatureT& feature) const { return (filter1_->pass(feature) && filter2_->pass(feature)); } - filter* clone() const + + filter* clone() const { - return new logical_and(*filter1_,*filter2_); + return new logical_and(*this); } - void accept(filter_visitor& v) + void accept(filter_visitor& v) { filter1_->accept(v); filter2_->accept(v); @@ -63,34 +64,41 @@ namespace mapnik } private: - filter* filter1_; - filter* filter2_; + filter* filter1_; + filter* filter2_; }; - template - struct logical_or : public filter + template + struct logical_or : public filter { - logical_or(const filter& filter1,const filter& filter2) - : filter1_(filter1.clone()), + logical_or(const filter& filter1,const filter& filter2) + : filter(), + filter1_(filter1.clone()), filter2_(filter2.clone()) {} + + logical_or(logical_or const& other) + : filter(), + filter1_(other.filter1_->clone()), + filter2_(other.filter2_->clone()) {} - int type() const + bool pass(const FeatureT& feature) const { - return filter::LOGICAL_OPS; + if (filter1_->pass(feature)) + { + return true; + } + else + { + return filter2_->pass(feature); + } + } + filter* clone() const + { + return new logical_or(*this); } - bool pass(const Feature& feature) const - { - return (filter1_->pass(feature) || - filter2_->pass(feature)); - } - filter* clone() const - { - return new logical_or(*filter1_,*filter2_); - } - - void accept(filter_visitor& v) + void accept(filter_visitor& v) { filter1_->accept(v); filter2_->accept(v); @@ -103,31 +111,36 @@ namespace mapnik delete filter2_; } private: - filter* filter1_; - filter* filter2_; + filter* filter1_; + filter* filter2_; }; - template - struct logical_not : public filter + template + struct logical_not : public filter { - logical_not(const filter& filter) - : filter_(filter.clone()) {} + logical_not(filter const& _filter) + : filter(), + filter_(_filter.clone()) {} + logical_not(logical_not const& other) + : filter(), + filter_(other.filter_->clone()) {} + int type() const { - return filter::LOGICAL_OPS; + return filter::LOGICAL_OPS; } - bool pass(const Feature& feature) const + bool pass(const FeatureT& feature) const { return !(filter_->pass(feature)); } - filter* clone() const + filter* clone() const { - return new logical_not(*filter_); + return new logical_not(*this); } - void accept(filter_visitor& v) + void accept(filter_visitor& v) { filter_->accept(v); v.visit(*this); @@ -138,8 +151,8 @@ namespace mapnik delete filter_; } private: - filter* filter_; + filter* filter_; }; } - + #endif //LOGICAL_HH diff --git a/include/mapnik.hh b/include/mapnik.hh index 278d09aeb..fa97fc37d 100644 --- a/include/mapnik.hh +++ b/include/mapnik.hh @@ -55,7 +55,12 @@ #include "map.hh" #include "colorcube.hh" #include "feature_type_style.hh" - +#include "filter_visitor.hh" +#include "math_expr.hh" +#include "value.hh" +#include "expression.hh" +#include "filter_parser.hh" +#include "filter_factory.hh" namespace mapnik { diff --git a/include/math_expr.hh b/include/math_expr.hh new file mode 100644 index 000000000..4940a457e --- /dev/null +++ b/include/math_expr.hh @@ -0,0 +1,106 @@ +/* This file is part of Mapnik (c++ mapping toolkit) + * Copyright (C) 2005 Artem Pavlenko + * + * Mapnik is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or any later version. + * + * This program 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 General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. + */ + +//$Id$ + +#ifndef MATH_EXPR_HH +#define MATH_EXPR_HH + +#include "expression.hh" + +namespace mapnik +{ + template + struct add + { + T operator () (T const& left, T const& right) + { + return left + right; + } + }; + + template + struct sub + { + T operator () (T const& left, T const& right) + { + return left - right; + } + }; + + template + struct mult + { + T operator () (T const& left, T const& right) + { + return left * right; + } + }; + + template + struct div + { + T operator () (T const& left, T const& right) + { + return left / right; + } + }; + + template + struct math_expr_b : public expression + { + math_expr_b(expression const& left, + expression const& right) + : expression(), + left_(left.clone()), + right_(right.clone()) {} + math_expr_b(math_expr_b const& other) + : expression(), + left_(other.left_->clone()), + right_(other.right_->clone()) {} + + value get_value(FeatureT const& feature) const + { + return Op ()(left_->get_value(feature),right_->get_value(feature)); + } + + void accept(filter_visitor& v) + { + left_->accept(v); + right_->accept(v); + v.visit(*this); + } + + expression* clone() const + { + return new math_expr_b(*this); + } + + ~math_expr_b() + { + delete left_; + delete right_; + } + private: + expression* left_; + expression* right_; + }; +}; + + +#endif // diff --git a/include/spatial.hh b/include/spatial.hh index 4e2e023fb..6c6e56dc1 100644 --- a/include/spatial.hh +++ b/include/spatial.hh @@ -20,151 +20,125 @@ #define SPATIAL_HH #include "filter.hh" +#include "filter_visitor.hh" namespace mapnik { - template - struct equals : public filter + + template + struct equals_ : public filter { - int type() const - { - return filter::SPATIAL_OPS; - } - - bool pass(const Feature& feature) const + + bool pass(const FeatureT& feature) const { return false; } - void accept(const filter_visitor& v) + void accept(const filter_visitor& v) { v.visit(*this); } }; - template - struct disjoint : public filter + template + struct disjoint : public filter { - int type() const - { - return filter::SPATIAL_OPS; - } + - bool pass(const Feature& feature) const + bool pass(const FeatureT& feature) const { return false; } - void accept(const filter_visitor& v) + void accept(const filter_visitor& v) { v.visit(*this); } }; - template - struct touches : public filter + template + struct touches : public filter { - int type() const - { - return filter::SPATIAL_OPS; - } + - bool pass(const Feature& feature) const + bool pass(const FeatureT& feature) const { return false; } - void accept(const filter_visitor& v) + void accept(const filter_visitor& v) { v.visit(*this); } }; - template - struct within : public filter + template + struct within : public filter { - int type() const - { - return filter::SPATIAL_OPS; - } - - bool pass(const Feature& feature) const + + bool pass(const FeatureT& feature) const { return false; } - void accept(const filter_visitor& v) + void accept(const filter_visitor& v) { v.visit(*this); } }; - template - struct overlaps : public filter + template + struct overlaps : public filter { - int type() const - { - return filter::SPATIAL_OPS; - } - - bool pass(const Feature& feature) const + + bool pass(const FeatureT& feature) const { return false; } - void accept(const filter_visitor& v) + void accept(const filter_visitor& v) { v.visit(*this); } }; - template - struct crosses : public filter + template + struct crosses : public filter { - int type() const - { - return filter::SPATIAL_OPS; - } + - bool pass(const Feature& feature) const + bool pass(const FeatureT& feature) const { return false; } - void accept(const filter_visitor& v) + void accept(const filter_visitor& v) { v.visit(*this); } }; - template - struct bbox : public filter + template + struct bbox : public filter { private: Envelope box_; public: bbox(const Envelope& box) : box_(box) {} + - int type() const - { - return filter::SPATIAL_OPS; - } - - bool pass(const Feature& feature) const + bool pass(const FeatureT& feature) const { return box_.contains(feature.get_geometry()->bbox()); } - std::string to_string() + + filter* clone() const { - return "BBOX filter"; + return new bbox(box_); } - filter* clone() const - { - return new bbox(box_); - } - void accept(const filter_visitor& v) + void accept(const filter_visitor& v) { v.visit(*this); } diff --git a/include/style_cache.hh b/include/style_cache.hh index da41242b2..bfb2c2a5d 100644 --- a/include/style_cache.hh +++ b/include/style_cache.hh @@ -56,7 +56,7 @@ namespace mapnik { public: static bool insert(const std::string& name,const feature_type_style& style); static void remove(const std::string& name); - static const feature_type_style& find(const std::string& name); + static feature_type_style find(const std::string& name); }; } diff --git a/include/value.hh b/include/value.hh new file mode 100644 index 000000000..219d06e4b --- /dev/null +++ b/include/value.hh @@ -0,0 +1,565 @@ +/* This file is part of Mapnik (c++ mapping toolkit) + * Copyright (C) 2005 Artem Pavlenko + * + * Mapnik is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or any later version. + * + * This program 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 General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. + */ + +//$Id$ + +#ifndef VALUE_HH +#define VALUE_HH + +#include +#include +#include "attribute.hh" +#include "expression.hh" + +using std::string; + +namespace mapnik +{ + class value + { + attribute data; + public: + value() + : data(0) {} + value(int value) + : data(value) {} + value(double value) + : data(value) {} + value(string const& value) + : data(value) {} + value(attribute const& attr) + : data(attr) {} + value(value const& other) + : data(other.data) {} + + ~value() {} + + bool is_int() const + { + return data.type() == typeid(int); + } + bool is_real() const + { + return data.type() == typeid(double); + } + bool is_string() const + { + return data.type() == typeid(std::string); + } + + int as_int() const + { + return attribute_cast(data); + } + + double as_real() const + { + return attribute_cast(data); + } + + string as_string() const + { + return attribute_cast(data); + } + + string to_string() const + { + return data.to_string(); + } + + bool operator<=(value const& other) const + { + if (is_int()) + { + if (other.is_int()) + { + return as_int() <= other.as_int(); + } + else if (other.is_real()) + { + return as_int() <= other.as_real(); + } + else + { + return to_string() <= other.as_string(); + } + } + else if (is_real()) + { + if (other.is_int()) + { + return as_real() <= other.as_int(); + } + else if (other.is_real()) + { + return as_real() <= other.as_real(); + } + else + { + return to_string() <= other.as_string(); + } + } + else + { + if (other.is_int()) + { + return as_string() <= other.to_string(); + } + else if (other.is_real()) + { + return as_string() <= other.to_string(); + } + else + { + return as_string() <= other.as_string(); + } + } + } + + bool operator<(value const& other) const + { + if (is_int()) + { + if (other.is_int()) + { + return as_int() < other.as_int(); + } + else if (other.is_real()) + { + return as_int() < other.as_real(); + } + else + { + return to_string() < other.as_string(); + } + } + else if (is_real()) + { + if (other.is_int()) + { + return as_real() < other.as_int(); + } + else if (other.is_real()) + { + return as_real() < other.as_real(); + } + else + { + return to_string() < other.as_string(); + } + } + else + { + if (other.is_int()) + { + return as_string() < other.to_string(); + } + else if (other.is_real()) + { + return as_string() < other.to_string(); + } + else + { + return as_string() < other.as_string(); + } + } + } + + bool operator>=(value const& other) const + { + if (is_int()) + { + if (other.is_int()) + { + return as_int() >= other.as_int(); + } + else if (other.is_real()) + { + return as_int() >= other.as_real(); + } + else + { + return to_string() >= other.as_string(); + } + } + else if (is_real()) + { + if (other.is_int()) + { + return as_real() >= other.as_int(); + } + else if (other.is_real()) + { + return as_real() >= other.as_real(); + } + else + { + return to_string() >= other.as_string(); + } + } + else + { + if (other.is_int()) + { + return as_string() >= other.to_string(); + } + else if (other.is_real()) + { + return as_string() >= other.to_string(); + } + else + { + return as_string() >= other.as_string(); + } + } + } + + bool operator>(value const& other) const + { + if (is_int()) + { + if (other.is_int()) + { + return as_int() > other.as_int(); + } + else if (other.is_real()) + { + return as_int() > other.as_real(); + } + else + { + return to_string() > other.as_string(); + } + } + else if (is_real()) + { + if (other.is_int()) + { + return as_real() > other.as_int(); + } + else if (other.is_real()) + { + return as_real() > other.as_real(); + } + else + { + return to_string() > other.as_string(); + } + } + else + { + if (other.is_int()) + { + return as_string() > other.to_string(); + } + else if (other.is_real()) + { + return as_string() > other.to_string(); + } + else + { + return as_string() > other.as_string(); + } + } + } + + bool operator!=(value const& other) const + { + if (is_int()) + { + if (other.is_int()) + { + return as_int() != other.as_int(); + } + else if (other.is_real()) + { + return as_int() != other.as_real(); + } + else + { + return to_string() != other.as_string(); + } + } + else if (is_real()) + { + if (other.is_int()) + { + return as_real() != other.as_int(); + } + else if (other.is_real()) + { + return as_real() != other.as_real(); + } + else + { + return to_string() != other.as_string(); + } + } + else + { + if (other.is_int()) + { + return as_string() != other.to_string(); + } + else if (other.is_real()) + { + return as_string() != other.to_string(); + } + else + { + return as_string() != other.as_string(); + } + } + } + + bool operator==(value const& other) const + { + if (is_int()) + { + if (other.is_int()) + { + return as_int() == other.as_int(); + } + else if (other.is_real()) + { + return as_int() == other.as_real(); + } + else + { + return to_string() == other.as_string(); + } + } + else if (is_real()) + { + if (other.is_int()) + { + return as_real() == other.as_int(); + } + else if (other.is_real()) + { + return as_real() == other.as_real(); + } + else + { + return to_string() == other.as_string(); + } + } + else + { + if (other.is_int()) + { + return as_string() == other.to_string(); + } + else if (other.is_real()) + { + return as_string() == other.to_string(); + } + else + { + return as_string() == other.as_string(); + } + } + } + + + value operator-() const + { + if (is_int()) + { + return -(as_int()); + } + else if (is_real()) + { + return -(as_real()); + } + return value(); + } + + value& operator+=(value const& other) + { + if (is_int()) + { + if (other.is_int()) + { + data = as_int() + other.as_int(); + } + else if (other.is_real()) + { + data = as_int() + other.as_real(); + } + else + { + data = to_string() + other.as_string(); + } + } + else if (is_real()) + { + if (other.is_int()) + { + data = as_real() + other.as_int(); + } + else if (other.is_real()) + { + data = as_real() + other.as_real(); + } + else + { + data = to_string() + other.as_string(); + } + } + else + { + if (other.is_int()) + { + data = as_string() + other.to_string(); + } + else if (other.is_real()) + { + data = as_string() + other.to_string(); + } + else + { + data = as_string() + other.as_string(); + } + } + return *this; + } + + value& operator-=(value const& other) + { + if (is_int()) + { + if (other.is_int()) + { + data = as_int() - other.as_int(); + } + else if (other.is_real()) + { + data = as_int() - other.as_real(); + } + } + else if (is_real()) + { + if (other.is_int()) + { + data = as_real() - other.as_int(); + } + else if (other.is_real()) + { + data = as_real() - other.as_real(); + } + } + + return *this; + } + + value& operator*=(value const& other) + { + if (is_int()) + { + if (other.is_int()) + { + data = as_int() * other.as_int(); + } + else if (other.is_real()) + { + data = as_int() * other.as_real(); + } + } + else if (is_real()) + { + if (other.is_int()) + { + data = as_real() * other.as_int(); + } + else if (other.is_real()) + { + data = as_real() * other.as_real(); + } + } + + return *this; + } + value& operator/=(value const& other) + { + if (is_int()) + { + if (other.is_int()) + { + data = as_int() / other.as_int(); + } + else if (other.is_real()) + { + data = as_int() / other.as_real(); + } + } + else if (is_real()) + { + if (other.is_int()) + { + data = as_real() / other.as_int(); + } + else if (other.is_real()) + { + data = as_real() / other.as_real(); + } + } + + return *this; + } + }; + + inline const value operator+(value const& p1,value const& p2) + { + value tmp(p1); + tmp+=p2; + return tmp; + } + + inline const value operator-(value const& p1,value const& p2) + { + value tmp(p1); + tmp-=p2; + return tmp; + } + + inline const value operator*(value const& p1,value const& p2) + { + value tmp(p1); + tmp*=p2; + return tmp; + } + + inline const value operator/(value const& p1,value const& p2) + { + value tmp(p1); + tmp/=p2; + return tmp; + } + + template + inline std::basic_ostream& + operator << (std::basic_ostream& out, + const value& p) + { + out << p.to_string(); + return out; + } +} + +#endif //VALUE_HH diff --git a/src/Makefile.am b/src/Makefile.am index 8e8afcf39..5b19d9f24 100644 --- a/src/Makefile.am +++ b/src/Makefile.am @@ -8,9 +8,13 @@ if BUILD_TIFF_READER libmapnik_la_SOURCES += tiff_reader.cc endif -libmapnik_la_CPPFLAGS = -I$(top_srcdir)/include $(FREETYPE2_CFLAGS) -libmapnik_la_CPPFLAGS += @INCLTDL@ -libmapnik_la_LIBADD = @LIBLTDL@ -lpthread -lpng -ljpeg $(FREETYPE2_LIBS) -lz -lm +SPIRIT_ROOT = "/home/artem/projects/spirit_1_8_2" + +libmapnik_la_CXXFLAGS = -I$(top_srcdir)/include $(FREETYPE2_CFLAGS) +libmapnik_la_CXXFLAGS += -I$//home/artem/projects/spirit_1_8_2 -I$//home/artem/projects/spirit_1_8_2/miniboost +libmapnik_la_CXXFLAGS += -I$//home/artem/projects/agg2/include +libmapnik_la_CXXFLAGS += @INCLTDL@ +libmapnik_la_LIBADD = @LIBLTDL@ -lpthread -lpng -ljpeg $(FREETYPE2_LIBS) -lz -lm -L$//home/artem/projects/agg2/src -lagg libmapnik_la_LDFLAGS= -version-info 0:0:0 $(TIFF_LDFLAGS) if SHAPE_DATASOURCE diff --git a/src/Makefile.in b/src/Makefile.in index 49c15a092..22bf5b0b6 100644 --- a/src/Makefile.in +++ b/src/Makefile.in @@ -220,9 +220,12 @@ libmapnik_la_SOURCES = color.cc datasource_cache.cc envelope.cc \ map.cc memory.cc params.cc plugin.cc png_reader.cc render.cc \ scanline_aa.cc scanline.cc style.cc style_cache.cc text.cc \ wkb.cc $(am__append_1) -libmapnik_la_CPPFLAGS = -I$(top_srcdir)/include $(FREETYPE2_CFLAGS) \ - @INCLTDL@ $(am__empty) -libmapnik_la_LIBADD = @LIBLTDL@ -lpthread -lpng -ljpeg $(FREETYPE2_LIBS) -lz -lm +SPIRIT_ROOT = "/home/artem/projects/spirit_1_8_2" +libmapnik_la_CXXFLAGS = -I$(top_srcdir)/include $(FREETYPE2_CFLAGS) \ + -I$//home/artem/projects/spirit_1_8_2 \ + -I$//home/artem/projects/spirit_1_8_2/miniboost \ + -I$//home/artem/projects/agg2/include @INCLTDL@ +libmapnik_la_LIBADD = @LIBLTDL@ -lpthread -lpng -ljpeg $(FREETYPE2_LIBS) -lz -lm -L$//home/artem/projects/agg2/src -lagg libmapnik_la_LDFLAGS = -version-info 0:0:0 $(TIFF_LDFLAGS) @SHAPE_DATASOURCE_TRUE@SHAPE_DATASOURCE_DIR = shape @RASTER_DATASOURCE_TRUE@RASTER_DATASOURCE_DIR = raster @@ -341,151 +344,151 @@ distclean-compile: @am__fastdepCXX_FALSE@ $(LTCXXCOMPILE) -c -o $@ $< libmapnik_la-color.lo: color.cc -@am__fastdepCXX_TRUE@ if $(LIBTOOL) --tag=CXX --mode=compile $(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(libmapnik_la_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) -MT libmapnik_la-color.lo -MD -MP -MF "$(DEPDIR)/libmapnik_la-color.Tpo" -c -o libmapnik_la-color.lo `test -f 'color.cc' || echo '$(srcdir)/'`color.cc; \ +@am__fastdepCXX_TRUE@ if $(LIBTOOL) --tag=CXX --mode=compile $(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libmapnik_la_CXXFLAGS) $(CXXFLAGS) -MT libmapnik_la-color.lo -MD -MP -MF "$(DEPDIR)/libmapnik_la-color.Tpo" -c -o libmapnik_la-color.lo `test -f 'color.cc' || echo '$(srcdir)/'`color.cc; \ @am__fastdepCXX_TRUE@ then mv -f "$(DEPDIR)/libmapnik_la-color.Tpo" "$(DEPDIR)/libmapnik_la-color.Plo"; else rm -f "$(DEPDIR)/libmapnik_la-color.Tpo"; exit 1; fi @AMDEP_TRUE@@am__fastdepCXX_FALSE@ source='color.cc' object='libmapnik_la-color.lo' libtool=yes @AMDEPBACKSLASH@ @AMDEP_TRUE@@am__fastdepCXX_FALSE@ DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@ -@am__fastdepCXX_FALSE@ $(LIBTOOL) --tag=CXX --mode=compile $(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(libmapnik_la_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) -c -o libmapnik_la-color.lo `test -f 'color.cc' || echo '$(srcdir)/'`color.cc +@am__fastdepCXX_FALSE@ $(LIBTOOL) --tag=CXX --mode=compile $(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libmapnik_la_CXXFLAGS) $(CXXFLAGS) -c -o libmapnik_la-color.lo `test -f 'color.cc' || echo '$(srcdir)/'`color.cc libmapnik_la-datasource_cache.lo: datasource_cache.cc -@am__fastdepCXX_TRUE@ if $(LIBTOOL) --tag=CXX --mode=compile $(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(libmapnik_la_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) -MT libmapnik_la-datasource_cache.lo -MD -MP -MF "$(DEPDIR)/libmapnik_la-datasource_cache.Tpo" -c -o libmapnik_la-datasource_cache.lo `test -f 'datasource_cache.cc' || echo '$(srcdir)/'`datasource_cache.cc; \ +@am__fastdepCXX_TRUE@ if $(LIBTOOL) --tag=CXX --mode=compile $(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libmapnik_la_CXXFLAGS) $(CXXFLAGS) -MT libmapnik_la-datasource_cache.lo -MD -MP -MF "$(DEPDIR)/libmapnik_la-datasource_cache.Tpo" -c -o libmapnik_la-datasource_cache.lo `test -f 'datasource_cache.cc' || echo '$(srcdir)/'`datasource_cache.cc; \ @am__fastdepCXX_TRUE@ then mv -f "$(DEPDIR)/libmapnik_la-datasource_cache.Tpo" "$(DEPDIR)/libmapnik_la-datasource_cache.Plo"; else rm -f "$(DEPDIR)/libmapnik_la-datasource_cache.Tpo"; exit 1; fi @AMDEP_TRUE@@am__fastdepCXX_FALSE@ source='datasource_cache.cc' object='libmapnik_la-datasource_cache.lo' libtool=yes @AMDEPBACKSLASH@ @AMDEP_TRUE@@am__fastdepCXX_FALSE@ DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@ -@am__fastdepCXX_FALSE@ $(LIBTOOL) --tag=CXX --mode=compile $(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(libmapnik_la_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) -c -o libmapnik_la-datasource_cache.lo `test -f 'datasource_cache.cc' || echo '$(srcdir)/'`datasource_cache.cc +@am__fastdepCXX_FALSE@ $(LIBTOOL) --tag=CXX --mode=compile $(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libmapnik_la_CXXFLAGS) $(CXXFLAGS) -c -o libmapnik_la-datasource_cache.lo `test -f 'datasource_cache.cc' || echo '$(srcdir)/'`datasource_cache.cc libmapnik_la-envelope.lo: envelope.cc -@am__fastdepCXX_TRUE@ if $(LIBTOOL) --tag=CXX --mode=compile $(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(libmapnik_la_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) -MT libmapnik_la-envelope.lo -MD -MP -MF "$(DEPDIR)/libmapnik_la-envelope.Tpo" -c -o libmapnik_la-envelope.lo `test -f 'envelope.cc' || echo '$(srcdir)/'`envelope.cc; \ +@am__fastdepCXX_TRUE@ if $(LIBTOOL) --tag=CXX --mode=compile $(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libmapnik_la_CXXFLAGS) $(CXXFLAGS) -MT libmapnik_la-envelope.lo -MD -MP -MF "$(DEPDIR)/libmapnik_la-envelope.Tpo" -c -o libmapnik_la-envelope.lo `test -f 'envelope.cc' || echo '$(srcdir)/'`envelope.cc; \ @am__fastdepCXX_TRUE@ then mv -f "$(DEPDIR)/libmapnik_la-envelope.Tpo" "$(DEPDIR)/libmapnik_la-envelope.Plo"; else rm -f "$(DEPDIR)/libmapnik_la-envelope.Tpo"; exit 1; fi @AMDEP_TRUE@@am__fastdepCXX_FALSE@ source='envelope.cc' object='libmapnik_la-envelope.lo' libtool=yes @AMDEPBACKSLASH@ @AMDEP_TRUE@@am__fastdepCXX_FALSE@ DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@ -@am__fastdepCXX_FALSE@ $(LIBTOOL) --tag=CXX --mode=compile $(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(libmapnik_la_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) -c -o libmapnik_la-envelope.lo `test -f 'envelope.cc' || echo '$(srcdir)/'`envelope.cc +@am__fastdepCXX_FALSE@ $(LIBTOOL) --tag=CXX --mode=compile $(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libmapnik_la_CXXFLAGS) $(CXXFLAGS) -c -o libmapnik_la-envelope.lo `test -f 'envelope.cc' || echo '$(srcdir)/'`envelope.cc libmapnik_la-graphics.lo: graphics.cc -@am__fastdepCXX_TRUE@ if $(LIBTOOL) --tag=CXX --mode=compile $(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(libmapnik_la_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) -MT libmapnik_la-graphics.lo -MD -MP -MF "$(DEPDIR)/libmapnik_la-graphics.Tpo" -c -o libmapnik_la-graphics.lo `test -f 'graphics.cc' || echo '$(srcdir)/'`graphics.cc; \ +@am__fastdepCXX_TRUE@ if $(LIBTOOL) --tag=CXX --mode=compile $(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libmapnik_la_CXXFLAGS) $(CXXFLAGS) -MT libmapnik_la-graphics.lo -MD -MP -MF "$(DEPDIR)/libmapnik_la-graphics.Tpo" -c -o libmapnik_la-graphics.lo `test -f 'graphics.cc' || echo '$(srcdir)/'`graphics.cc; \ @am__fastdepCXX_TRUE@ then mv -f "$(DEPDIR)/libmapnik_la-graphics.Tpo" "$(DEPDIR)/libmapnik_la-graphics.Plo"; else rm -f "$(DEPDIR)/libmapnik_la-graphics.Tpo"; exit 1; fi @AMDEP_TRUE@@am__fastdepCXX_FALSE@ source='graphics.cc' object='libmapnik_la-graphics.lo' libtool=yes @AMDEPBACKSLASH@ @AMDEP_TRUE@@am__fastdepCXX_FALSE@ DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@ -@am__fastdepCXX_FALSE@ $(LIBTOOL) --tag=CXX --mode=compile $(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(libmapnik_la_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) -c -o libmapnik_la-graphics.lo `test -f 'graphics.cc' || echo '$(srcdir)/'`graphics.cc +@am__fastdepCXX_FALSE@ $(LIBTOOL) --tag=CXX --mode=compile $(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libmapnik_la_CXXFLAGS) $(CXXFLAGS) -c -o libmapnik_la-graphics.lo `test -f 'graphics.cc' || echo '$(srcdir)/'`graphics.cc libmapnik_la-image_reader.lo: image_reader.cc -@am__fastdepCXX_TRUE@ if $(LIBTOOL) --tag=CXX --mode=compile $(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(libmapnik_la_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) -MT libmapnik_la-image_reader.lo -MD -MP -MF "$(DEPDIR)/libmapnik_la-image_reader.Tpo" -c -o libmapnik_la-image_reader.lo `test -f 'image_reader.cc' || echo '$(srcdir)/'`image_reader.cc; \ +@am__fastdepCXX_TRUE@ if $(LIBTOOL) --tag=CXX --mode=compile $(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libmapnik_la_CXXFLAGS) $(CXXFLAGS) -MT libmapnik_la-image_reader.lo -MD -MP -MF "$(DEPDIR)/libmapnik_la-image_reader.Tpo" -c -o libmapnik_la-image_reader.lo `test -f 'image_reader.cc' || echo '$(srcdir)/'`image_reader.cc; \ @am__fastdepCXX_TRUE@ then mv -f "$(DEPDIR)/libmapnik_la-image_reader.Tpo" "$(DEPDIR)/libmapnik_la-image_reader.Plo"; else rm -f "$(DEPDIR)/libmapnik_la-image_reader.Tpo"; exit 1; fi @AMDEP_TRUE@@am__fastdepCXX_FALSE@ source='image_reader.cc' object='libmapnik_la-image_reader.lo' libtool=yes @AMDEPBACKSLASH@ @AMDEP_TRUE@@am__fastdepCXX_FALSE@ DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@ -@am__fastdepCXX_FALSE@ $(LIBTOOL) --tag=CXX --mode=compile $(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(libmapnik_la_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) -c -o libmapnik_la-image_reader.lo `test -f 'image_reader.cc' || echo '$(srcdir)/'`image_reader.cc +@am__fastdepCXX_FALSE@ $(LIBTOOL) --tag=CXX --mode=compile $(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libmapnik_la_CXXFLAGS) $(CXXFLAGS) -c -o libmapnik_la-image_reader.lo `test -f 'image_reader.cc' || echo '$(srcdir)/'`image_reader.cc libmapnik_la-image_util.lo: image_util.cc -@am__fastdepCXX_TRUE@ if $(LIBTOOL) --tag=CXX --mode=compile $(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(libmapnik_la_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) -MT libmapnik_la-image_util.lo -MD -MP -MF "$(DEPDIR)/libmapnik_la-image_util.Tpo" -c -o libmapnik_la-image_util.lo `test -f 'image_util.cc' || echo '$(srcdir)/'`image_util.cc; \ +@am__fastdepCXX_TRUE@ if $(LIBTOOL) --tag=CXX --mode=compile $(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libmapnik_la_CXXFLAGS) $(CXXFLAGS) -MT libmapnik_la-image_util.lo -MD -MP -MF "$(DEPDIR)/libmapnik_la-image_util.Tpo" -c -o libmapnik_la-image_util.lo `test -f 'image_util.cc' || echo '$(srcdir)/'`image_util.cc; \ @am__fastdepCXX_TRUE@ then mv -f "$(DEPDIR)/libmapnik_la-image_util.Tpo" "$(DEPDIR)/libmapnik_la-image_util.Plo"; else rm -f "$(DEPDIR)/libmapnik_la-image_util.Tpo"; exit 1; fi @AMDEP_TRUE@@am__fastdepCXX_FALSE@ source='image_util.cc' object='libmapnik_la-image_util.lo' libtool=yes @AMDEPBACKSLASH@ @AMDEP_TRUE@@am__fastdepCXX_FALSE@ DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@ -@am__fastdepCXX_FALSE@ $(LIBTOOL) --tag=CXX --mode=compile $(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(libmapnik_la_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) -c -o libmapnik_la-image_util.lo `test -f 'image_util.cc' || echo '$(srcdir)/'`image_util.cc +@am__fastdepCXX_FALSE@ $(LIBTOOL) --tag=CXX --mode=compile $(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libmapnik_la_CXXFLAGS) $(CXXFLAGS) -c -o libmapnik_la-image_util.lo `test -f 'image_util.cc' || echo '$(srcdir)/'`image_util.cc libmapnik_la-layer.lo: layer.cc -@am__fastdepCXX_TRUE@ if $(LIBTOOL) --tag=CXX --mode=compile $(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(libmapnik_la_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) -MT libmapnik_la-layer.lo -MD -MP -MF "$(DEPDIR)/libmapnik_la-layer.Tpo" -c -o libmapnik_la-layer.lo `test -f 'layer.cc' || echo '$(srcdir)/'`layer.cc; \ +@am__fastdepCXX_TRUE@ if $(LIBTOOL) --tag=CXX --mode=compile $(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libmapnik_la_CXXFLAGS) $(CXXFLAGS) -MT libmapnik_la-layer.lo -MD -MP -MF "$(DEPDIR)/libmapnik_la-layer.Tpo" -c -o libmapnik_la-layer.lo `test -f 'layer.cc' || echo '$(srcdir)/'`layer.cc; \ @am__fastdepCXX_TRUE@ then mv -f "$(DEPDIR)/libmapnik_la-layer.Tpo" "$(DEPDIR)/libmapnik_la-layer.Plo"; else rm -f "$(DEPDIR)/libmapnik_la-layer.Tpo"; exit 1; fi @AMDEP_TRUE@@am__fastdepCXX_FALSE@ source='layer.cc' object='libmapnik_la-layer.lo' libtool=yes @AMDEPBACKSLASH@ @AMDEP_TRUE@@am__fastdepCXX_FALSE@ DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@ -@am__fastdepCXX_FALSE@ $(LIBTOOL) --tag=CXX --mode=compile $(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(libmapnik_la_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) -c -o libmapnik_la-layer.lo `test -f 'layer.cc' || echo '$(srcdir)/'`layer.cc +@am__fastdepCXX_FALSE@ $(LIBTOOL) --tag=CXX --mode=compile $(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libmapnik_la_CXXFLAGS) $(CXXFLAGS) -c -o libmapnik_la-layer.lo `test -f 'layer.cc' || echo '$(srcdir)/'`layer.cc libmapnik_la-line_aa.lo: line_aa.cc -@am__fastdepCXX_TRUE@ if $(LIBTOOL) --tag=CXX --mode=compile $(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(libmapnik_la_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) -MT libmapnik_la-line_aa.lo -MD -MP -MF "$(DEPDIR)/libmapnik_la-line_aa.Tpo" -c -o libmapnik_la-line_aa.lo `test -f 'line_aa.cc' || echo '$(srcdir)/'`line_aa.cc; \ +@am__fastdepCXX_TRUE@ if $(LIBTOOL) --tag=CXX --mode=compile $(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libmapnik_la_CXXFLAGS) $(CXXFLAGS) -MT libmapnik_la-line_aa.lo -MD -MP -MF "$(DEPDIR)/libmapnik_la-line_aa.Tpo" -c -o libmapnik_la-line_aa.lo `test -f 'line_aa.cc' || echo '$(srcdir)/'`line_aa.cc; \ @am__fastdepCXX_TRUE@ then mv -f "$(DEPDIR)/libmapnik_la-line_aa.Tpo" "$(DEPDIR)/libmapnik_la-line_aa.Plo"; else rm -f "$(DEPDIR)/libmapnik_la-line_aa.Tpo"; exit 1; fi @AMDEP_TRUE@@am__fastdepCXX_FALSE@ source='line_aa.cc' object='libmapnik_la-line_aa.lo' libtool=yes @AMDEPBACKSLASH@ @AMDEP_TRUE@@am__fastdepCXX_FALSE@ DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@ -@am__fastdepCXX_FALSE@ $(LIBTOOL) --tag=CXX --mode=compile $(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(libmapnik_la_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) -c -o libmapnik_la-line_aa.lo `test -f 'line_aa.cc' || echo '$(srcdir)/'`line_aa.cc +@am__fastdepCXX_FALSE@ $(LIBTOOL) --tag=CXX --mode=compile $(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libmapnik_la_CXXFLAGS) $(CXXFLAGS) -c -o libmapnik_la-line_aa.lo `test -f 'line_aa.cc' || echo '$(srcdir)/'`line_aa.cc libmapnik_la-map.lo: map.cc -@am__fastdepCXX_TRUE@ if $(LIBTOOL) --tag=CXX --mode=compile $(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(libmapnik_la_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) -MT libmapnik_la-map.lo -MD -MP -MF "$(DEPDIR)/libmapnik_la-map.Tpo" -c -o libmapnik_la-map.lo `test -f 'map.cc' || echo '$(srcdir)/'`map.cc; \ +@am__fastdepCXX_TRUE@ if $(LIBTOOL) --tag=CXX --mode=compile $(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libmapnik_la_CXXFLAGS) $(CXXFLAGS) -MT libmapnik_la-map.lo -MD -MP -MF "$(DEPDIR)/libmapnik_la-map.Tpo" -c -o libmapnik_la-map.lo `test -f 'map.cc' || echo '$(srcdir)/'`map.cc; \ @am__fastdepCXX_TRUE@ then mv -f "$(DEPDIR)/libmapnik_la-map.Tpo" "$(DEPDIR)/libmapnik_la-map.Plo"; else rm -f "$(DEPDIR)/libmapnik_la-map.Tpo"; exit 1; fi @AMDEP_TRUE@@am__fastdepCXX_FALSE@ source='map.cc' object='libmapnik_la-map.lo' libtool=yes @AMDEPBACKSLASH@ @AMDEP_TRUE@@am__fastdepCXX_FALSE@ DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@ -@am__fastdepCXX_FALSE@ $(LIBTOOL) --tag=CXX --mode=compile $(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(libmapnik_la_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) -c -o libmapnik_la-map.lo `test -f 'map.cc' || echo '$(srcdir)/'`map.cc +@am__fastdepCXX_FALSE@ $(LIBTOOL) --tag=CXX --mode=compile $(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libmapnik_la_CXXFLAGS) $(CXXFLAGS) -c -o libmapnik_la-map.lo `test -f 'map.cc' || echo '$(srcdir)/'`map.cc libmapnik_la-memory.lo: memory.cc -@am__fastdepCXX_TRUE@ if $(LIBTOOL) --tag=CXX --mode=compile $(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(libmapnik_la_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) -MT libmapnik_la-memory.lo -MD -MP -MF "$(DEPDIR)/libmapnik_la-memory.Tpo" -c -o libmapnik_la-memory.lo `test -f 'memory.cc' || echo '$(srcdir)/'`memory.cc; \ +@am__fastdepCXX_TRUE@ if $(LIBTOOL) --tag=CXX --mode=compile $(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libmapnik_la_CXXFLAGS) $(CXXFLAGS) -MT libmapnik_la-memory.lo -MD -MP -MF "$(DEPDIR)/libmapnik_la-memory.Tpo" -c -o libmapnik_la-memory.lo `test -f 'memory.cc' || echo '$(srcdir)/'`memory.cc; \ @am__fastdepCXX_TRUE@ then mv -f "$(DEPDIR)/libmapnik_la-memory.Tpo" "$(DEPDIR)/libmapnik_la-memory.Plo"; else rm -f "$(DEPDIR)/libmapnik_la-memory.Tpo"; exit 1; fi @AMDEP_TRUE@@am__fastdepCXX_FALSE@ source='memory.cc' object='libmapnik_la-memory.lo' libtool=yes @AMDEPBACKSLASH@ @AMDEP_TRUE@@am__fastdepCXX_FALSE@ DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@ -@am__fastdepCXX_FALSE@ $(LIBTOOL) --tag=CXX --mode=compile $(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(libmapnik_la_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) -c -o libmapnik_la-memory.lo `test -f 'memory.cc' || echo '$(srcdir)/'`memory.cc +@am__fastdepCXX_FALSE@ $(LIBTOOL) --tag=CXX --mode=compile $(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libmapnik_la_CXXFLAGS) $(CXXFLAGS) -c -o libmapnik_la-memory.lo `test -f 'memory.cc' || echo '$(srcdir)/'`memory.cc libmapnik_la-params.lo: params.cc -@am__fastdepCXX_TRUE@ if $(LIBTOOL) --tag=CXX --mode=compile $(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(libmapnik_la_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) -MT libmapnik_la-params.lo -MD -MP -MF "$(DEPDIR)/libmapnik_la-params.Tpo" -c -o libmapnik_la-params.lo `test -f 'params.cc' || echo '$(srcdir)/'`params.cc; \ +@am__fastdepCXX_TRUE@ if $(LIBTOOL) --tag=CXX --mode=compile $(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libmapnik_la_CXXFLAGS) $(CXXFLAGS) -MT libmapnik_la-params.lo -MD -MP -MF "$(DEPDIR)/libmapnik_la-params.Tpo" -c -o libmapnik_la-params.lo `test -f 'params.cc' || echo '$(srcdir)/'`params.cc; \ @am__fastdepCXX_TRUE@ then mv -f "$(DEPDIR)/libmapnik_la-params.Tpo" "$(DEPDIR)/libmapnik_la-params.Plo"; else rm -f "$(DEPDIR)/libmapnik_la-params.Tpo"; exit 1; fi @AMDEP_TRUE@@am__fastdepCXX_FALSE@ source='params.cc' object='libmapnik_la-params.lo' libtool=yes @AMDEPBACKSLASH@ @AMDEP_TRUE@@am__fastdepCXX_FALSE@ DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@ -@am__fastdepCXX_FALSE@ $(LIBTOOL) --tag=CXX --mode=compile $(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(libmapnik_la_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) -c -o libmapnik_la-params.lo `test -f 'params.cc' || echo '$(srcdir)/'`params.cc +@am__fastdepCXX_FALSE@ $(LIBTOOL) --tag=CXX --mode=compile $(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libmapnik_la_CXXFLAGS) $(CXXFLAGS) -c -o libmapnik_la-params.lo `test -f 'params.cc' || echo '$(srcdir)/'`params.cc libmapnik_la-plugin.lo: plugin.cc -@am__fastdepCXX_TRUE@ if $(LIBTOOL) --tag=CXX --mode=compile $(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(libmapnik_la_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) -MT libmapnik_la-plugin.lo -MD -MP -MF "$(DEPDIR)/libmapnik_la-plugin.Tpo" -c -o libmapnik_la-plugin.lo `test -f 'plugin.cc' || echo '$(srcdir)/'`plugin.cc; \ +@am__fastdepCXX_TRUE@ if $(LIBTOOL) --tag=CXX --mode=compile $(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libmapnik_la_CXXFLAGS) $(CXXFLAGS) -MT libmapnik_la-plugin.lo -MD -MP -MF "$(DEPDIR)/libmapnik_la-plugin.Tpo" -c -o libmapnik_la-plugin.lo `test -f 'plugin.cc' || echo '$(srcdir)/'`plugin.cc; \ @am__fastdepCXX_TRUE@ then mv -f "$(DEPDIR)/libmapnik_la-plugin.Tpo" "$(DEPDIR)/libmapnik_la-plugin.Plo"; else rm -f "$(DEPDIR)/libmapnik_la-plugin.Tpo"; exit 1; fi @AMDEP_TRUE@@am__fastdepCXX_FALSE@ source='plugin.cc' object='libmapnik_la-plugin.lo' libtool=yes @AMDEPBACKSLASH@ @AMDEP_TRUE@@am__fastdepCXX_FALSE@ DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@ -@am__fastdepCXX_FALSE@ $(LIBTOOL) --tag=CXX --mode=compile $(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(libmapnik_la_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) -c -o libmapnik_la-plugin.lo `test -f 'plugin.cc' || echo '$(srcdir)/'`plugin.cc +@am__fastdepCXX_FALSE@ $(LIBTOOL) --tag=CXX --mode=compile $(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libmapnik_la_CXXFLAGS) $(CXXFLAGS) -c -o libmapnik_la-plugin.lo `test -f 'plugin.cc' || echo '$(srcdir)/'`plugin.cc libmapnik_la-png_reader.lo: png_reader.cc -@am__fastdepCXX_TRUE@ if $(LIBTOOL) --tag=CXX --mode=compile $(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(libmapnik_la_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) -MT libmapnik_la-png_reader.lo -MD -MP -MF "$(DEPDIR)/libmapnik_la-png_reader.Tpo" -c -o libmapnik_la-png_reader.lo `test -f 'png_reader.cc' || echo '$(srcdir)/'`png_reader.cc; \ +@am__fastdepCXX_TRUE@ if $(LIBTOOL) --tag=CXX --mode=compile $(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libmapnik_la_CXXFLAGS) $(CXXFLAGS) -MT libmapnik_la-png_reader.lo -MD -MP -MF "$(DEPDIR)/libmapnik_la-png_reader.Tpo" -c -o libmapnik_la-png_reader.lo `test -f 'png_reader.cc' || echo '$(srcdir)/'`png_reader.cc; \ @am__fastdepCXX_TRUE@ then mv -f "$(DEPDIR)/libmapnik_la-png_reader.Tpo" "$(DEPDIR)/libmapnik_la-png_reader.Plo"; else rm -f "$(DEPDIR)/libmapnik_la-png_reader.Tpo"; exit 1; fi @AMDEP_TRUE@@am__fastdepCXX_FALSE@ source='png_reader.cc' object='libmapnik_la-png_reader.lo' libtool=yes @AMDEPBACKSLASH@ @AMDEP_TRUE@@am__fastdepCXX_FALSE@ DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@ -@am__fastdepCXX_FALSE@ $(LIBTOOL) --tag=CXX --mode=compile $(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(libmapnik_la_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) -c -o libmapnik_la-png_reader.lo `test -f 'png_reader.cc' || echo '$(srcdir)/'`png_reader.cc +@am__fastdepCXX_FALSE@ $(LIBTOOL) --tag=CXX --mode=compile $(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libmapnik_la_CXXFLAGS) $(CXXFLAGS) -c -o libmapnik_la-png_reader.lo `test -f 'png_reader.cc' || echo '$(srcdir)/'`png_reader.cc libmapnik_la-render.lo: render.cc -@am__fastdepCXX_TRUE@ if $(LIBTOOL) --tag=CXX --mode=compile $(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(libmapnik_la_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) -MT libmapnik_la-render.lo -MD -MP -MF "$(DEPDIR)/libmapnik_la-render.Tpo" -c -o libmapnik_la-render.lo `test -f 'render.cc' || echo '$(srcdir)/'`render.cc; \ +@am__fastdepCXX_TRUE@ if $(LIBTOOL) --tag=CXX --mode=compile $(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libmapnik_la_CXXFLAGS) $(CXXFLAGS) -MT libmapnik_la-render.lo -MD -MP -MF "$(DEPDIR)/libmapnik_la-render.Tpo" -c -o libmapnik_la-render.lo `test -f 'render.cc' || echo '$(srcdir)/'`render.cc; \ @am__fastdepCXX_TRUE@ then mv -f "$(DEPDIR)/libmapnik_la-render.Tpo" "$(DEPDIR)/libmapnik_la-render.Plo"; else rm -f "$(DEPDIR)/libmapnik_la-render.Tpo"; exit 1; fi @AMDEP_TRUE@@am__fastdepCXX_FALSE@ source='render.cc' object='libmapnik_la-render.lo' libtool=yes @AMDEPBACKSLASH@ @AMDEP_TRUE@@am__fastdepCXX_FALSE@ DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@ -@am__fastdepCXX_FALSE@ $(LIBTOOL) --tag=CXX --mode=compile $(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(libmapnik_la_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) -c -o libmapnik_la-render.lo `test -f 'render.cc' || echo '$(srcdir)/'`render.cc +@am__fastdepCXX_FALSE@ $(LIBTOOL) --tag=CXX --mode=compile $(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libmapnik_la_CXXFLAGS) $(CXXFLAGS) -c -o libmapnik_la-render.lo `test -f 'render.cc' || echo '$(srcdir)/'`render.cc libmapnik_la-scanline_aa.lo: scanline_aa.cc -@am__fastdepCXX_TRUE@ if $(LIBTOOL) --tag=CXX --mode=compile $(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(libmapnik_la_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) -MT libmapnik_la-scanline_aa.lo -MD -MP -MF "$(DEPDIR)/libmapnik_la-scanline_aa.Tpo" -c -o libmapnik_la-scanline_aa.lo `test -f 'scanline_aa.cc' || echo '$(srcdir)/'`scanline_aa.cc; \ +@am__fastdepCXX_TRUE@ if $(LIBTOOL) --tag=CXX --mode=compile $(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libmapnik_la_CXXFLAGS) $(CXXFLAGS) -MT libmapnik_la-scanline_aa.lo -MD -MP -MF "$(DEPDIR)/libmapnik_la-scanline_aa.Tpo" -c -o libmapnik_la-scanline_aa.lo `test -f 'scanline_aa.cc' || echo '$(srcdir)/'`scanline_aa.cc; \ @am__fastdepCXX_TRUE@ then mv -f "$(DEPDIR)/libmapnik_la-scanline_aa.Tpo" "$(DEPDIR)/libmapnik_la-scanline_aa.Plo"; else rm -f "$(DEPDIR)/libmapnik_la-scanline_aa.Tpo"; exit 1; fi @AMDEP_TRUE@@am__fastdepCXX_FALSE@ source='scanline_aa.cc' object='libmapnik_la-scanline_aa.lo' libtool=yes @AMDEPBACKSLASH@ @AMDEP_TRUE@@am__fastdepCXX_FALSE@ DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@ -@am__fastdepCXX_FALSE@ $(LIBTOOL) --tag=CXX --mode=compile $(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(libmapnik_la_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) -c -o libmapnik_la-scanline_aa.lo `test -f 'scanline_aa.cc' || echo '$(srcdir)/'`scanline_aa.cc +@am__fastdepCXX_FALSE@ $(LIBTOOL) --tag=CXX --mode=compile $(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libmapnik_la_CXXFLAGS) $(CXXFLAGS) -c -o libmapnik_la-scanline_aa.lo `test -f 'scanline_aa.cc' || echo '$(srcdir)/'`scanline_aa.cc libmapnik_la-scanline.lo: scanline.cc -@am__fastdepCXX_TRUE@ if $(LIBTOOL) --tag=CXX --mode=compile $(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(libmapnik_la_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) -MT libmapnik_la-scanline.lo -MD -MP -MF "$(DEPDIR)/libmapnik_la-scanline.Tpo" -c -o libmapnik_la-scanline.lo `test -f 'scanline.cc' || echo '$(srcdir)/'`scanline.cc; \ +@am__fastdepCXX_TRUE@ if $(LIBTOOL) --tag=CXX --mode=compile $(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libmapnik_la_CXXFLAGS) $(CXXFLAGS) -MT libmapnik_la-scanline.lo -MD -MP -MF "$(DEPDIR)/libmapnik_la-scanline.Tpo" -c -o libmapnik_la-scanline.lo `test -f 'scanline.cc' || echo '$(srcdir)/'`scanline.cc; \ @am__fastdepCXX_TRUE@ then mv -f "$(DEPDIR)/libmapnik_la-scanline.Tpo" "$(DEPDIR)/libmapnik_la-scanline.Plo"; else rm -f "$(DEPDIR)/libmapnik_la-scanline.Tpo"; exit 1; fi @AMDEP_TRUE@@am__fastdepCXX_FALSE@ source='scanline.cc' object='libmapnik_la-scanline.lo' libtool=yes @AMDEPBACKSLASH@ @AMDEP_TRUE@@am__fastdepCXX_FALSE@ DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@ -@am__fastdepCXX_FALSE@ $(LIBTOOL) --tag=CXX --mode=compile $(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(libmapnik_la_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) -c -o libmapnik_la-scanline.lo `test -f 'scanline.cc' || echo '$(srcdir)/'`scanline.cc +@am__fastdepCXX_FALSE@ $(LIBTOOL) --tag=CXX --mode=compile $(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libmapnik_la_CXXFLAGS) $(CXXFLAGS) -c -o libmapnik_la-scanline.lo `test -f 'scanline.cc' || echo '$(srcdir)/'`scanline.cc libmapnik_la-style.lo: style.cc -@am__fastdepCXX_TRUE@ if $(LIBTOOL) --tag=CXX --mode=compile $(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(libmapnik_la_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) -MT libmapnik_la-style.lo -MD -MP -MF "$(DEPDIR)/libmapnik_la-style.Tpo" -c -o libmapnik_la-style.lo `test -f 'style.cc' || echo '$(srcdir)/'`style.cc; \ +@am__fastdepCXX_TRUE@ if $(LIBTOOL) --tag=CXX --mode=compile $(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libmapnik_la_CXXFLAGS) $(CXXFLAGS) -MT libmapnik_la-style.lo -MD -MP -MF "$(DEPDIR)/libmapnik_la-style.Tpo" -c -o libmapnik_la-style.lo `test -f 'style.cc' || echo '$(srcdir)/'`style.cc; \ @am__fastdepCXX_TRUE@ then mv -f "$(DEPDIR)/libmapnik_la-style.Tpo" "$(DEPDIR)/libmapnik_la-style.Plo"; else rm -f "$(DEPDIR)/libmapnik_la-style.Tpo"; exit 1; fi @AMDEP_TRUE@@am__fastdepCXX_FALSE@ source='style.cc' object='libmapnik_la-style.lo' libtool=yes @AMDEPBACKSLASH@ @AMDEP_TRUE@@am__fastdepCXX_FALSE@ DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@ -@am__fastdepCXX_FALSE@ $(LIBTOOL) --tag=CXX --mode=compile $(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(libmapnik_la_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) -c -o libmapnik_la-style.lo `test -f 'style.cc' || echo '$(srcdir)/'`style.cc +@am__fastdepCXX_FALSE@ $(LIBTOOL) --tag=CXX --mode=compile $(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libmapnik_la_CXXFLAGS) $(CXXFLAGS) -c -o libmapnik_la-style.lo `test -f 'style.cc' || echo '$(srcdir)/'`style.cc libmapnik_la-style_cache.lo: style_cache.cc -@am__fastdepCXX_TRUE@ if $(LIBTOOL) --tag=CXX --mode=compile $(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(libmapnik_la_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) -MT libmapnik_la-style_cache.lo -MD -MP -MF "$(DEPDIR)/libmapnik_la-style_cache.Tpo" -c -o libmapnik_la-style_cache.lo `test -f 'style_cache.cc' || echo '$(srcdir)/'`style_cache.cc; \ +@am__fastdepCXX_TRUE@ if $(LIBTOOL) --tag=CXX --mode=compile $(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libmapnik_la_CXXFLAGS) $(CXXFLAGS) -MT libmapnik_la-style_cache.lo -MD -MP -MF "$(DEPDIR)/libmapnik_la-style_cache.Tpo" -c -o libmapnik_la-style_cache.lo `test -f 'style_cache.cc' || echo '$(srcdir)/'`style_cache.cc; \ @am__fastdepCXX_TRUE@ then mv -f "$(DEPDIR)/libmapnik_la-style_cache.Tpo" "$(DEPDIR)/libmapnik_la-style_cache.Plo"; else rm -f "$(DEPDIR)/libmapnik_la-style_cache.Tpo"; exit 1; fi @AMDEP_TRUE@@am__fastdepCXX_FALSE@ source='style_cache.cc' object='libmapnik_la-style_cache.lo' libtool=yes @AMDEPBACKSLASH@ @AMDEP_TRUE@@am__fastdepCXX_FALSE@ DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@ -@am__fastdepCXX_FALSE@ $(LIBTOOL) --tag=CXX --mode=compile $(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(libmapnik_la_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) -c -o libmapnik_la-style_cache.lo `test -f 'style_cache.cc' || echo '$(srcdir)/'`style_cache.cc +@am__fastdepCXX_FALSE@ $(LIBTOOL) --tag=CXX --mode=compile $(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libmapnik_la_CXXFLAGS) $(CXXFLAGS) -c -o libmapnik_la-style_cache.lo `test -f 'style_cache.cc' || echo '$(srcdir)/'`style_cache.cc libmapnik_la-text.lo: text.cc -@am__fastdepCXX_TRUE@ if $(LIBTOOL) --tag=CXX --mode=compile $(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(libmapnik_la_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) -MT libmapnik_la-text.lo -MD -MP -MF "$(DEPDIR)/libmapnik_la-text.Tpo" -c -o libmapnik_la-text.lo `test -f 'text.cc' || echo '$(srcdir)/'`text.cc; \ +@am__fastdepCXX_TRUE@ if $(LIBTOOL) --tag=CXX --mode=compile $(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libmapnik_la_CXXFLAGS) $(CXXFLAGS) -MT libmapnik_la-text.lo -MD -MP -MF "$(DEPDIR)/libmapnik_la-text.Tpo" -c -o libmapnik_la-text.lo `test -f 'text.cc' || echo '$(srcdir)/'`text.cc; \ @am__fastdepCXX_TRUE@ then mv -f "$(DEPDIR)/libmapnik_la-text.Tpo" "$(DEPDIR)/libmapnik_la-text.Plo"; else rm -f "$(DEPDIR)/libmapnik_la-text.Tpo"; exit 1; fi @AMDEP_TRUE@@am__fastdepCXX_FALSE@ source='text.cc' object='libmapnik_la-text.lo' libtool=yes @AMDEPBACKSLASH@ @AMDEP_TRUE@@am__fastdepCXX_FALSE@ DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@ -@am__fastdepCXX_FALSE@ $(LIBTOOL) --tag=CXX --mode=compile $(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(libmapnik_la_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) -c -o libmapnik_la-text.lo `test -f 'text.cc' || echo '$(srcdir)/'`text.cc +@am__fastdepCXX_FALSE@ $(LIBTOOL) --tag=CXX --mode=compile $(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libmapnik_la_CXXFLAGS) $(CXXFLAGS) -c -o libmapnik_la-text.lo `test -f 'text.cc' || echo '$(srcdir)/'`text.cc libmapnik_la-wkb.lo: wkb.cc -@am__fastdepCXX_TRUE@ if $(LIBTOOL) --tag=CXX --mode=compile $(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(libmapnik_la_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) -MT libmapnik_la-wkb.lo -MD -MP -MF "$(DEPDIR)/libmapnik_la-wkb.Tpo" -c -o libmapnik_la-wkb.lo `test -f 'wkb.cc' || echo '$(srcdir)/'`wkb.cc; \ +@am__fastdepCXX_TRUE@ if $(LIBTOOL) --tag=CXX --mode=compile $(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libmapnik_la_CXXFLAGS) $(CXXFLAGS) -MT libmapnik_la-wkb.lo -MD -MP -MF "$(DEPDIR)/libmapnik_la-wkb.Tpo" -c -o libmapnik_la-wkb.lo `test -f 'wkb.cc' || echo '$(srcdir)/'`wkb.cc; \ @am__fastdepCXX_TRUE@ then mv -f "$(DEPDIR)/libmapnik_la-wkb.Tpo" "$(DEPDIR)/libmapnik_la-wkb.Plo"; else rm -f "$(DEPDIR)/libmapnik_la-wkb.Tpo"; exit 1; fi @AMDEP_TRUE@@am__fastdepCXX_FALSE@ source='wkb.cc' object='libmapnik_la-wkb.lo' libtool=yes @AMDEPBACKSLASH@ @AMDEP_TRUE@@am__fastdepCXX_FALSE@ DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@ -@am__fastdepCXX_FALSE@ $(LIBTOOL) --tag=CXX --mode=compile $(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(libmapnik_la_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) -c -o libmapnik_la-wkb.lo `test -f 'wkb.cc' || echo '$(srcdir)/'`wkb.cc +@am__fastdepCXX_FALSE@ $(LIBTOOL) --tag=CXX --mode=compile $(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libmapnik_la_CXXFLAGS) $(CXXFLAGS) -c -o libmapnik_la-wkb.lo `test -f 'wkb.cc' || echo '$(srcdir)/'`wkb.cc libmapnik_la-tiff_reader.lo: tiff_reader.cc -@am__fastdepCXX_TRUE@ if $(LIBTOOL) --tag=CXX --mode=compile $(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(libmapnik_la_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) -MT libmapnik_la-tiff_reader.lo -MD -MP -MF "$(DEPDIR)/libmapnik_la-tiff_reader.Tpo" -c -o libmapnik_la-tiff_reader.lo `test -f 'tiff_reader.cc' || echo '$(srcdir)/'`tiff_reader.cc; \ +@am__fastdepCXX_TRUE@ if $(LIBTOOL) --tag=CXX --mode=compile $(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libmapnik_la_CXXFLAGS) $(CXXFLAGS) -MT libmapnik_la-tiff_reader.lo -MD -MP -MF "$(DEPDIR)/libmapnik_la-tiff_reader.Tpo" -c -o libmapnik_la-tiff_reader.lo `test -f 'tiff_reader.cc' || echo '$(srcdir)/'`tiff_reader.cc; \ @am__fastdepCXX_TRUE@ then mv -f "$(DEPDIR)/libmapnik_la-tiff_reader.Tpo" "$(DEPDIR)/libmapnik_la-tiff_reader.Plo"; else rm -f "$(DEPDIR)/libmapnik_la-tiff_reader.Tpo"; exit 1; fi @AMDEP_TRUE@@am__fastdepCXX_FALSE@ source='tiff_reader.cc' object='libmapnik_la-tiff_reader.lo' libtool=yes @AMDEPBACKSLASH@ @AMDEP_TRUE@@am__fastdepCXX_FALSE@ DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@ -@am__fastdepCXX_FALSE@ $(LIBTOOL) --tag=CXX --mode=compile $(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(libmapnik_la_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) -c -o libmapnik_la-tiff_reader.lo `test -f 'tiff_reader.cc' || echo '$(srcdir)/'`tiff_reader.cc +@am__fastdepCXX_FALSE@ $(LIBTOOL) --tag=CXX --mode=compile $(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libmapnik_la_CXXFLAGS) $(CXXFLAGS) -c -o libmapnik_la-tiff_reader.lo `test -f 'tiff_reader.cc' || echo '$(srcdir)/'`tiff_reader.cc mostlyclean-libtool: -rm -f *.lo diff --git a/src/local_datasource.cc b/src/local_datasource.cc new file mode 100644 index 000000000..cbf7fe421 --- /dev/null +++ b/src/local_datasource.cc @@ -0,0 +1,42 @@ +/* This file is part of Mapnik (c++ mapping toolkit) + * Copyright (C) 2005 Artem Pavlenko + * + * Mapnik is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or any later version. + * + * This program 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 General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. + */ + +//$Id$ + +#include "local_datasource.hh" + +namespace mapnik +{ + local_datasource::local_datasource(Parameters const& params) {} + local_datasource::~local_datasource() {} + std::string local_datasource::name_="local"; + std::string local_datasource::name() + { + return name_; + } + + const Envelope& local_datasource::envelope() const + { + return extent_; + } + + featureset_ptr features(query const& q) const + { + + } +} diff --git a/src/render.cc b/src/render.cc index c6cba3560..b5e96cdc9 100644 --- a/src/render.cc +++ b/src/render.cc @@ -44,7 +44,9 @@ namespace mapnik if (!ds) return; volatile named_style_cache* styles=named_style_cache::instance(); - const feature_type_style& style=styles->find(l.getStyle()); + + //get copy + feature_type_style style=styles->find(l.getStyle()); const std::vector& rules=style.rules(); diff --git a/src/shape/Makefile.am b/src/shape/Makefile.am index 992676c89..b06b910a9 100644 --- a/src/shape/Makefile.am +++ b/src/shape/Makefile.am @@ -5,4 +5,4 @@ shape_la_SOURCES = dbffile.cc shape.cc shape_io.cc shape_featureset.cc shape_ind shape_la_LIBDADD = shape_la_LDFLAGS = -module -version-info 0:0:0 -lpthread shape_la_CXXFLAGS = -I$(top_srcdir)/include - +shape_la_CXXFLAGS += -I$//home/artem/projects/spirit_1_8_2 -I$//home/artem/projects/spirit_1_8_2/miniboost diff --git a/src/shape/Makefile.in b/src/shape/Makefile.in index 432d35772..0aa58ceb4 100644 --- a/src/shape/Makefile.in +++ b/src/shape/Makefile.in @@ -203,7 +203,9 @@ plugins_LTLIBRARIES = shape.la shape_la_SOURCES = dbffile.cc shape.cc shape_io.cc shape_featureset.cc shape_index_featureset.hh dbffile.hh shapefile.cc shape_featureset.hh shape_io.hh shp_index.cc dbf_test.cc shapefile.hh shape.hh shape_index_featureset.cc shp_index.hh shape_la_LIBDADD = shape_la_LDFLAGS = -module -version-info 0:0:0 -lpthread -shape_la_CXXFLAGS = -I$(top_srcdir)/include +shape_la_CXXFLAGS = -I$(top_srcdir)/include \ + -I$//home/artem/projects/spirit_1_8_2 \ + -I$//home/artem/projects/spirit_1_8_2/miniboost all: all-am .SUFFIXES: diff --git a/src/style_cache.cc b/src/style_cache.cc index 972341b81..ac99944ac 100644 --- a/src/style_cache.cc +++ b/src/style_cache.cc @@ -70,15 +70,14 @@ namespace mapnik styles_.erase(name); } - const feature_type_style& named_style_cache::find(const std::string& name) + feature_type_style named_style_cache::find(const std::string& name) { Lock lock(&mutex_); std::map::iterator itr=styles_.find(name); - //if (itr!=styles_.end()) - // { - return itr->second; - //} - //static const Style default_style(ref_ptr(new LineSymbolizer(Color(255,0,0)))); - //return default_style; + if (itr!=styles_.end()) + { + return itr->second; + } + return feature_type_style(); } } diff --git a/utils/shapeindex/Makefile.am b/utils/shapeindex/Makefile.am index b66b7dbcc..fc42bb4f4 100644 --- a/utils/shapeindex/Makefile.am +++ b/utils/shapeindex/Makefile.am @@ -1,6 +1,7 @@ bin_PROGRAMS = shapeindex shapeindex_SOURCES = quadtree.cc quadtree.hh shapeindex.cc shapeindex_CXXFLAGS = -I$(srcdir)/../../include -I$(srcdir)/../../src/shape +shapeindex_CXXFLAGS += -I$//home/artem/projects/spirit_1_8_2 -I$//home/artem/projects/spirit_1_8_2/miniboost SHAPELIB = ../../src/shape/.libs/shape.a MAPNIKLIB = ../../src/.libs/libmapnik.a shapeindex_LDADD = $(SHAPELIB) $(MAPNIKLIB) diff --git a/utils/shapeindex/Makefile.in b/utils/shapeindex/Makefile.in index 0bd2e7a55..8410a8acb 100644 --- a/utils/shapeindex/Makefile.in +++ b/utils/shapeindex/Makefile.in @@ -158,7 +158,10 @@ sharedstatedir = @sharedstatedir@ sysconfdir = @sysconfdir@ target_alias = @target_alias@ shapeindex_SOURCES = quadtree.cc quadtree.hh shapeindex.cc -shapeindex_CXXFLAGS = -I$(srcdir)/../../include -I$(srcdir)/../../src/shape +shapeindex_CXXFLAGS = -I$(srcdir)/../../include \ + -I$(srcdir)/../../src/shape \ + -I$//home/artem/projects/spirit_1_8_2 \ + -I$//home/artem/projects/spirit_1_8_2/miniboost SHAPELIB = ../../src/shape/.libs/shape.a MAPNIKLIB = ../../src/.libs/libmapnik.a shapeindex_LDADD = $(SHAPELIB) $(MAPNIKLIB)