mapnik/include/mapnik/evaluate_global_attributes.hpp
2017-05-05 13:02:01 +02:00

333 lines
9.7 KiB
C++

/*****************************************************************************
*
* This file is part of Mapnik (c++ mapping toolkit)
*
* Copyright (C) 2017 Artem Pavlenko
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2.1 of the License, or (at your option) any later version.
*
* This library 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
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the Free Software
* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
*
*****************************************************************************/
#ifndef MAPNIK_EVALUATE_GLOBAL_ATTRIBUTES_HPP
#define MAPNIK_EVALUATE_GLOBAL_ATTRIBUTES_HPP
#include <mapnik/map.hpp>
#include <mapnik/rule.hpp>
#include <mapnik/feature_type_style.hpp>
#include <mapnik/symbolizer.hpp>
#include <mapnik/attribute.hpp>
#include <mapnik/expression_node.hpp>
#include <mapnik/color_factory.hpp>
#include <mapnik/util/noncopyable.hpp>
#include <mapnik/function_call.hpp>
#include <mapnik/util/variant.hpp>
namespace mapnik {
namespace {
template <typename T, typename Attributes>
struct evaluate_expression
{
using value_type = T;
explicit evaluate_expression(Attributes const& attrs)
: attrs_(attrs) {}
value_type operator() (attribute const&) const
{
throw std::runtime_error("can't evaluate feature attributes in this context");
}
value_type operator() (global_attribute const& attr) const
{
auto itr = attrs_.find(attr.name);
if (itr != attrs_.end())
{
return itr->second;
}
return value_type();// throw?
}
value_type operator() (geometry_type_attribute const&) const
{
throw std::runtime_error("can't evaluate geometry_type attributes in this context");
}
value_type operator() (binary_node<tags::logical_and> const & x) const
{
return (util::apply_visitor(*this, x.left).to_bool())
&& (util::apply_visitor(*this, x.right).to_bool());
}
value_type operator() (binary_node<tags::logical_or> const & x) const
{
return (util::apply_visitor(*this,x.left).to_bool())
|| (util::apply_visitor(*this,x.right).to_bool());
}
template <typename Tag>
value_type operator() (binary_node<Tag> const& x) const
{
typename make_op<Tag>::type operation;
return operation(util::apply_visitor(*this, x.left),
util::apply_visitor(*this, x.right));
}
template <typename Tag>
value_type operator() (unary_node<Tag> const& x) const
{
typename make_op<Tag>::type func;
return func(util::apply_visitor(*this, x.expr));
}
value_type operator() (unary_node<tags::logical_not> const& x) const
{
return ! (util::apply_visitor(*this,x.expr).to_bool());
}
value_type operator() (regex_match_node const& x) const
{
value_type v = util::apply_visitor(*this, x.expr);
return x.apply(v);
}
value_type operator() (regex_replace_node const& x) const
{
value_type v = util::apply_visitor(*this, x.expr);
return x.apply(v);
}
value_type operator() (unary_function_call const& call) const
{
value_type arg = util::apply_visitor(*this, call.arg);
return call.fun(arg);
}
value_type operator() (binary_function_call const& call) const
{
value_type arg1 = util::apply_visitor(*this, call.arg1);
value_type arg2 = util::apply_visitor(*this, call.arg2);
return call.fun(arg1, arg2);
}
template <typename ValueType>
value_type operator() (ValueType const& val) const
{
return value_type(val);
}
Attributes const& attrs_;
};
template <typename T>
struct evaluate_expression<T, boost::none_t>
{
using value_type = T;
evaluate_expression(boost::none_t) {}
value_type operator() (attribute const&) const
{
throw std::runtime_error("can't evaluate feature attributes in this context");
}
value_type operator() (global_attribute const&) const
{
throw std::runtime_error("can't evaluate feature attributes in this context");
}
value_type operator() (geometry_type_attribute const&) const
{
throw std::runtime_error("can't evaluate geometry_type attributes in this context");
}
value_type operator() (binary_node<tags::logical_and> const & x) const
{
return (util::apply_visitor(*this, x.left).to_bool())
&& (util::apply_visitor(*this, x.right).to_bool());
}
value_type operator() (binary_node<tags::logical_or> const & x) const
{
return (util::apply_visitor(*this,x.left).to_bool())
|| (util::apply_visitor(*this,x.right).to_bool());
}
template <typename Tag>
value_type operator() (binary_node<Tag> const& x) const
{
typename make_op<Tag>::type operation;
return operation(util::apply_visitor(*this, x.left),
util::apply_visitor(*this, x.right));
}
template <typename Tag>
value_type operator() (unary_node<Tag> const& x) const
{
typename make_op<Tag>::type func;
return func(util::apply_visitor(*this, x.expr));
}
value_type operator() (unary_node<tags::logical_not> const& x) const
{
return ! (util::apply_visitor(*this,x.expr).to_bool());
}
value_type operator() (regex_match_node const& x) const
{
value_type v = util::apply_visitor(*this, x.expr);
return x.apply(v);
}
value_type operator() (regex_replace_node const& x) const
{
value_type v = util::apply_visitor(*this, x.expr);
return x.apply(v);
}
value_type operator() (unary_function_call const& call) const
{
value_type arg = util::apply_visitor(*this, call.arg);
return call.fun(arg);
}
value_type operator() (binary_function_call const& call) const
{
value_type arg1 = util::apply_visitor(*this, call.arg1);
value_type arg2 = util::apply_visitor(*this, call.arg2);
return call.fun(arg1, arg2);
}
template <typename ValueType>
value_type operator() (ValueType const& val) const
{
return value_type(val);
}
};
struct assign_value
{
template<typename Attributes>
static void apply(symbolizer_base::value_type & val, expression_ptr const& expr, Attributes const& attrs, property_types target )
{
switch (target)
{
case property_types::target_color:
{
// evaluate expression as a string then parse as css color
std::string str = util::apply_visitor(mapnik::evaluate_expression<mapnik::value,
Attributes>(attrs),*expr).to_string();
try { val = parse_color(str); }
catch (...) { val = color(0,0,0);}
break;
}
case property_types::target_double:
{
val = util::apply_visitor(mapnik::evaluate_expression<mapnik::value, Attributes>(attrs),*expr).to_double();
break;
}
case property_types::target_integer:
{
val = util::apply_visitor(mapnik::evaluate_expression<mapnik::value, Attributes>(attrs),*expr).to_int();
break;
}
case property_types::target_bool:
{
val = util::apply_visitor(mapnik::evaluate_expression<mapnik::value, Attributes>(attrs),*expr).to_bool();
break;
}
default: // no-op
break;
}
}
};
}
template <typename T>
std::tuple<T,bool> pre_evaluate_expression (expression_ptr const& expr)
{
try
{
return std::make_tuple(util::apply_visitor(mapnik::evaluate_expression<T, boost::none_t>(boost::none),*expr), true);
}
catch (...)
{
return std::make_tuple(T(),false);
}
}
struct evaluate_global_attributes : util::noncopyable
{
template <typename Attributes>
struct evaluator
{
evaluator(symbolizer_base::cont_type::value_type & prop, Attributes const& attrs)
: prop_(prop),
attrs_(attrs) {}
void operator() (expression_ptr const& expr) const
{
auto const& meta = get_meta(prop_.first);
assign_value::apply(prop_.second, expr, attrs_, std::get<2>(meta));
}
template <typename T>
void operator() (T const&) const
{
// no-op
}
symbolizer_base::cont_type::value_type & prop_;
Attributes const& attrs_;
};
template <typename Attributes>
struct extract_symbolizer
{
extract_symbolizer(Attributes const& attrs)
: attrs_(attrs) {}
template <typename Symbolizer>
void operator() (Symbolizer & sym) const
{
for (auto & prop : sym.properties)
{
util::apply_visitor(evaluator<Attributes>(prop, attrs_), prop.second);
}
}
Attributes const& attrs_;
};
template <typename Attributes>
static void apply(Map & m, Attributes const& attrs)
{
for ( auto & val : m.styles() )
{
for (auto & rule : val.second.get_rules_nonconst())
{
for (auto & sym : rule)
{
util::apply_visitor(extract_symbolizer<Attributes>(attrs), sym);
}
}
}
}
};
}
#endif // MAPNIK_EVALUATE_GLOBAL_ATTRIBUTES_HPP