archive-gh-me/mapnik
1
0
Fork 0
mirror of https://github.com/mapnik/mapnik.git synced 2025-12-08 20:13:09 +00:00
Code Issues Projects Releases Wiki Activity

convert symbolizer properties to use util::variant

Browse Source
This commit is contained in:
artemp 2014-08-11 13:24:53 +01:00
parent aac69d0b34
commit 9bfb41a39f
12 changed files with 130 additions and 141 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

16
bindings/python/mapnik_symbolizer.cpp
View File

@ -49,6 +49,7 @@
#include <mapnik/group/group_layout.hpp>
#include <mapnik/group/group_rule.hpp>
#include <mapnik/group/group_symbolizer_properties.hpp>
#include <mapnik/util/variant.hpp>
// stl
#include <sstream>
@ -103,7 +104,7 @@ std::shared_ptr<mapnik::symbolizer_base::value_type> numeric_wrapper(const objec
return result;
}
struct extract_python_object : public boost::static_visitor<boost::python::object>
struct extract_python_object : public mapnik::util::static_visitor<boost::python::object>
{
using result_type = boost::python::object;
@ -121,7 +122,7 @@ boost::python::object __getitem__(mapnik::symbolizer_base const& sym, std::strin
const_iterator itr = sym.properties.find(key);
if (itr != sym.properties.end())
{
return boost::apply_visitor(extract_python_object(), itr->second);
return mapnik::util::apply_visitor(extract_python_object(), itr->second);
}
//mapnik::property_meta_type const& meta = mapnik::get_meta(key);
//return boost::apply_visitor(extract_python_object(), std::get<1>(meta));
@ -138,18 +139,9 @@ std::string get_symbolizer_type(symbolizer const& sym)
return mapnik::symbolizer_name(sym); // FIXME - do we need this ?
}
struct symbolizer_hash_visitor : public boost::static_visitor<std::size_t>
{
template <typename T>
std::size_t operator() (T const& sym) const
{
return mapnik::symbolizer_hash::value(sym);
}
};
std::size_t hash_impl(symbolizer const& sym)
{
return boost::apply_visitor(symbolizer_hash_visitor(), sym);
return boost::apply_visitor(mapnik::symbolizer_hash_visitor(), sym);
}
template <typename T>

5
include/mapnik/attribute_collector.hpp
View File

@ -37,6 +37,7 @@
#include <mapnik/group/group_symbolizer_properties.hpp>
#include <mapnik/group/group_rule.hpp>
#include <mapnik/util/conversions.hpp>
#include <mapnik/util/variant.hpp>
// boost
#include <boost/variant/static_visitor.hpp>
@ -169,7 +170,7 @@ struct symbolizer_attributes : public boost::static_visitor<>
{
for (auto const& prop : sym.properties)
{
boost::apply_visitor(f_attrs_, prop.second);
util::apply_visitor(f_attrs_, prop.second);
}
}
@ -190,7 +191,7 @@ struct symbolizer_attributes : public boost::static_visitor<>
}
for (auto const& prop : sym.properties)
{
boost::apply_visitor(f_attrs_, prop.second);
util::apply_visitor(f_attrs_, prop.second);
}
}

44
include/mapnik/symbolizer.hpp
View File

@ -41,7 +41,7 @@
#include <mapnik/attribute.hpp>
#include <mapnik/symbolizer_enumerations.hpp>
#include <mapnik/util/dasharray_parser.hpp>
#include <mapnik/util/variant.hpp>
// stl
#include <type_traits>
#include <algorithm>
@ -49,8 +49,6 @@
#include <vector>
#include <string>
#include <functional>
// boost
#include <boost/variant/variant_fwd.hpp>
namespace agg { struct trans_affine; }
@ -92,19 +90,19 @@ using text_placements_ptr = std::shared_ptr<text_placements>;
struct MAPNIK_DECL symbolizer_base
{
using value_type = boost::variant<value_bool,
value_integer,
enumeration_wrapper,
value_double,
std::string,
color,
expression_ptr,
path_expression_ptr,
transform_type,
text_placements_ptr,
dash_array,
raster_colorizer_ptr,
group_symbolizer_properties_ptr>;
using value_type = util::variant<value_bool,
value_integer,
enumeration_wrapper,
value_double,
std::string,
color,
expression_ptr,
path_expression_ptr,
transform_type,
text_placements_ptr,
dash_array,
raster_colorizer_ptr,
group_symbolizer_properties_ptr>;
using key_type = mapnik::keys;
using cont_type = std::map<key_type, value_type>;
cont_type properties;
@ -112,7 +110,7 @@ struct MAPNIK_DECL symbolizer_base
inline bool is_expression(symbolizer_base::value_type const& val)
{
return (val.which() == 6);
return (val.get_type_index() == 6);
}
// symbolizer properties target types
@ -391,7 +389,7 @@ struct evaluate_expression_wrapper<mapnik::dash_array>
};
template <typename T>
struct extract_value : public boost::static_visitor<T>
struct extract_value : public util::static_visitor<T>
{
using result_type = T;
@ -431,7 +429,7 @@ struct extract_value : public boost::static_visitor<T>
};
template <typename T1>
struct extract_raw_value : public boost::static_visitor<T1>
struct extract_raw_value : public util::static_visitor<T1>
{
using result_type = T1;
@ -472,7 +470,7 @@ MAPNIK_DECL T get(symbolizer_base const& sym, keys key, mapnik::feature_impl con
const_iterator itr = sym.properties.find(key);
if (itr != sym.properties.end())
{
return boost::apply_visitor(extract_value<T>(feature,vars), itr->second);
return util::apply_visitor(extract_value<T>(feature,vars), itr->second);
}
return _default_value;
}
@ -484,7 +482,7 @@ MAPNIK_DECL boost::optional<T> get_optional(symbolizer_base const& sym, keys key
const_iterator itr = sym.properties.find(key);
if (itr != sym.properties.end())
{
return boost::apply_visitor(extract_value<T>(feature,vars), itr->second);
return util::apply_visitor(extract_value<T>(feature,vars), itr->second);
}
return boost::optional<T>();
}
@ -496,7 +494,7 @@ MAPNIK_DECL T get(symbolizer_base const& sym, keys key, T const& _default_value
const_iterator itr = sym.properties.find(key);
if (itr != sym.properties.end())
{
return boost::apply_visitor(extract_raw_value<T>(), itr->second);
return util::apply_visitor(extract_raw_value<T>(), itr->second);
}
return _default_value;
}
@ -508,7 +506,7 @@ MAPNIK_DECL boost::optional<T> get_optional(symbolizer_base const& sym, keys key
const_iterator itr = sym.properties.find(key);
if (itr != sym.properties.end())
{
return boost::apply_visitor(extract_raw_value<T>(), itr->second);
return util::apply_visitor(extract_raw_value<T>(), itr->second);
}
return boost::optional<T>();
}

9
include/mapnik/symbolizer_hash.hpp
View File

@ -25,8 +25,7 @@
// mapnik
#include <mapnik/symbolizer.hpp>
// boost
#include <boost/variant/static_visitor.hpp>
#include <mapnik/util/variant.hpp>
// stl
#include <typeinfo>
#include <typeindex>
@ -34,7 +33,7 @@
namespace mapnik {
struct property_value_hash_visitor : boost::static_visitor<std::size_t>
struct property_value_hash_visitor : util::static_visitor<std::size_t>
{
std::size_t operator() (color val) const
{
@ -72,13 +71,13 @@ struct symbolizer_hash
for (auto const& prop : sym.properties)
{
seed ^= std::hash<std::size_t>()(static_cast<std::size_t>(prop.first));
seed ^= boost::apply_visitor(property_value_hash_visitor(), prop.second);
seed ^= util::apply_visitor(property_value_hash_visitor(), prop.second);
}
return seed;
}
};
struct hash_visitor : boost::static_visitor<std::size_t>
struct symbolizer_hash_visitor : boost::static_visitor<std::size_t>
{
template <typename Symbolizer>
std::size_t operator() (Symbolizer const& sym) const

5
include/mapnik/symbolizer_utils.hpp
View File

@ -37,6 +37,7 @@
#include <mapnik/config_error.hpp>
#include <mapnik/evaluate_global_attributes.hpp>
#include <mapnik/parse_transform.hpp>
#include <mapnik/util/variant.hpp>
// boost
#include <boost/variant/apply_visitor.hpp>
@ -142,7 +143,7 @@ inline std::string symbolizer_name(symbolizer const& sym)
template <typename Meta>
class symbolizer_property_value_string : public boost::static_visitor<std::string>
class symbolizer_property_value_string : public util::static_visitor<std::string>
{
public:
symbolizer_property_value_string (Meta const& meta)
@ -246,7 +247,7 @@ struct symbolizer_to_json : public boost::static_visitor<std::string>
if (first) first = false;
else ss << ",";
ss << "\"" << std::get<0>(meta) << "\":";
ss << boost::apply_visitor(symbolizer_property_value_string<property_meta_type>(meta),prop.second);
ss << util::apply_visitor(symbolizer_property_value_string<property_meta_type>(meta),prop.second);
}
ss << "}}";
return ss.str();

6
include/mapnik/transform_expression.hpp
View File

@ -201,16 +201,14 @@ struct is_null_transform_node : public mapnik::util::static_visitor<bool>
return val.is_null();
}
bool operator() (value_null const& val) const
bool operator() (value_null const&) const
{
boost::ignore_unused_variable_warning(val);
return true;
}
template <typename T>
bool operator() (T const& val) const
bool operator() (T const&) const
{
boost::ignore_unused_variable_warning(val);
return false;
}

8
src/save_map.cpp
View File

@ -45,7 +45,7 @@
#include <mapnik/group/group_rule.hpp>
#include <mapnik/group/group_layout.hpp>
#include <mapnik/group/group_symbolizer_properties.hpp>
#include <mapnik/util/variant.hpp>
// boost
#include <boost/algorithm/string.hpp>
#include <boost/optional.hpp>
@ -240,9 +240,9 @@ private:
{
for (auto const& prop : sym.properties)
{
boost::apply_visitor(serialize_symbolizer_property<property_meta_type>(
get_meta(prop.first), sym_node, explicit_defaults_),
prop.second);
util::apply_visitor(serialize_symbolizer_property<property_meta_type>(
get_meta(prop.first), sym_node, explicit_defaults_),
prop.second);
}
}
ptree & rule_;

36
src/text/formatting/format.cpp
View File

@ -103,14 +103,14 @@ void format_node::apply(evaluated_format_properties_ptr p, feature_impl const& f
{
evaluated_format_properties_ptr new_properties = std::make_shared<detail::evaluated_format_properties>(*p);
if (text_size) new_properties->text_size = boost::apply_visitor(extract_value<value_double>(feature,attrs), *text_size);
if (character_spacing) new_properties->character_spacing = boost::apply_visitor(extract_value<value_double>(feature,attrs), *character_spacing);
if (line_spacing) new_properties->line_spacing = boost::apply_visitor(extract_value<value_double>(feature,attrs), *line_spacing);
if (text_opacity) new_properties->text_opacity = boost::apply_visitor(extract_value<value_double>(feature,attrs), *text_opacity);
if (halo_radius) new_properties->halo_radius = boost::apply_visitor(extract_value<value_double>(feature,attrs), *halo_radius);
if (fill) new_properties->fill = boost::apply_visitor(extract_value<color>(feature,attrs), *fill);
if (halo_fill) new_properties->halo_fill = boost::apply_visitor(extract_value<color>(feature,attrs), *halo_fill);
if (text_transform) new_properties->text_transform = boost::apply_visitor(extract_value<text_transform_enum>(feature,attrs), *text_transform);
if (text_size) new_properties->text_size = util::apply_visitor(extract_value<value_double>(feature,attrs), *text_size);
if (character_spacing) new_properties->character_spacing = util::apply_visitor(extract_value<value_double>(feature,attrs), *character_spacing);
if (line_spacing) new_properties->line_spacing = util::apply_visitor(extract_value<value_double>(feature,attrs), *line_spacing);
if (text_opacity) new_properties->text_opacity = util::apply_visitor(extract_value<value_double>(feature,attrs), *text_opacity);
if (halo_radius) new_properties->halo_radius = util::apply_visitor(extract_value<value_double>(feature,attrs), *halo_radius);
if (fill) new_properties->fill = util::apply_visitor(extract_value<color>(feature,attrs), *fill);
if (halo_fill) new_properties->halo_fill = util::apply_visitor(extract_value<color>(feature,attrs), *halo_fill);
if (text_transform) new_properties->text_transform = util::apply_visitor(extract_value<text_transform_enum>(feature,attrs), *text_transform);
if (fontset)
{
@ -143,16 +143,16 @@ node_ptr format_node::get_child() const
void format_node::add_expressions(expression_set & output) const
{
if (text_size && is_expression(*text_size)) output.insert(boost::get<expression_ptr>(*text_size));
if (character_spacing && is_expression(*character_spacing)) output.insert(boost::get<expression_ptr>(*character_spacing));
if (line_spacing && is_expression(*line_spacing)) output.insert(boost::get<expression_ptr>(*line_spacing));
if (halo_radius && is_expression(*halo_radius)) output.insert(boost::get<expression_ptr>(*halo_radius));
if (text_opacity && is_expression(*text_opacity)) output.insert(boost::get<expression_ptr>(*text_opacity));
//if (halo_opacity && is_expression(*halo_opacity)) output.insert(boost::get<expression_ptr>(*halo_opacity));
if (wrap_before && is_expression(*wrap_before)) output.insert(boost::get<expression_ptr>(*wrap_before));
if (fill && is_expression(*fill)) output.insert(boost::get<expression_ptr>(*fill));
if (halo_fill && is_expression(*halo_fill)) output.insert(boost::get<expression_ptr>(*halo_fill));
if (text_transform && is_expression(*text_transform)) output.insert(boost::get<expression_ptr>(*text_transform));
if (text_size && is_expression(*text_size)) output.insert(util::get<expression_ptr>(*text_size));
if (character_spacing && is_expression(*character_spacing)) output.insert(util::get<expression_ptr>(*character_spacing));
if (line_spacing && is_expression(*line_spacing)) output.insert(util::get<expression_ptr>(*line_spacing));
if (halo_radius && is_expression(*halo_radius)) output.insert(util::get<expression_ptr>(*halo_radius));
if (text_opacity && is_expression(*text_opacity)) output.insert(util::get<expression_ptr>(*text_opacity));
//if (halo_opacity && is_expression(*halo_opacity)) output.insert(util::get<expression_ptr>(*halo_opacity));
if (wrap_before && is_expression(*wrap_before)) output.insert(util::get<expression_ptr>(*wrap_before));
if (fill && is_expression(*fill)) output.insert(util::get<expression_ptr>(*fill));
if (halo_fill && is_expression(*halo_fill)) output.insert(util::get<expression_ptr>(*halo_fill));
if (text_transform && is_expression(*text_transform)) output.insert(util::get<expression_ptr>(*text_transform));
if (child_) child_->add_expressions(output);
}

20
src/text/formatting/layout.cpp
View File

@ -121,16 +121,16 @@ node_ptr layout_node::get_child() const
void layout_node::add_expressions(expression_set & output) const
{
if (dx && is_expression(*dx)) output.insert(boost::get<expression_ptr>(*dx));
if (dy && is_expression(*dy)) output.insert(boost::get<expression_ptr>(*dy));
if (orientation && is_expression(*orientation)) output.insert(boost::get<expression_ptr>(*orientation));
if (wrap_width && is_expression(*wrap_width)) output.insert(boost::get<expression_ptr>(*wrap_width));
if (wrap_before && is_expression(*wrap_before)) output.insert(boost::get<expression_ptr>(*wrap_before));
if (rotate_displacement && is_expression(*rotate_displacement)) output.insert(boost::get<expression_ptr>(*rotate_displacement));
if (text_ratio && is_expression(*text_ratio)) output.insert(boost::get<expression_ptr>(*text_ratio));
if (halign && is_expression(*halign)) output.insert(boost::get<expression_ptr>(*halign));
if (valign && is_expression(*valign)) output.insert(boost::get<expression_ptr>(*valign));
if (jalign && is_expression(*jalign)) output.insert(boost::get<expression_ptr>(*jalign));
if (dx && is_expression(*dx)) output.insert(util::get<expression_ptr>(*dx));
if (dy && is_expression(*dy)) output.insert(util::get<expression_ptr>(*dy));
if (orientation && is_expression(*orientation)) output.insert(util::get<expression_ptr>(*orientation));
if (wrap_width && is_expression(*wrap_width)) output.insert(util::get<expression_ptr>(*wrap_width));
if (wrap_before && is_expression(*wrap_before)) output.insert(util::get<expression_ptr>(*wrap_before));
if (rotate_displacement && is_expression(*rotate_displacement)) output.insert(util::get<expression_ptr>(*rotate_displacement));
if (text_ratio && is_expression(*text_ratio)) output.insert(util::get<expression_ptr>(*text_ratio));
if (halign && is_expression(*halign)) output.insert(util::get<expression_ptr>(*halign));
if (valign && is_expression(*valign)) output.insert(util::get<expression_ptr>(*valign));
if (jalign && is_expression(*jalign)) output.insert(util::get<expression_ptr>(*jalign));
if (child_) child_->add_expressions(output);
}

4
src/text/properties_util.cpp
View File

@ -25,7 +25,7 @@
namespace mapnik { namespace detail {
struct property_serializer : public boost::static_visitor<>
struct property_serializer : public util::static_visitor<>
{
property_serializer(std::string const& name, boost::property_tree::ptree & node)
: name_(name),
@ -80,7 +80,7 @@ struct property_serializer : public boost::static_visitor<>
void serialize_property(std::string const& name, symbolizer_base::value_type const& val, boost::property_tree::ptree & node)
{
boost::apply_visitor(detail::property_serializer(name,node), val);
util::apply_visitor(detail::property_serializer(name,node), val);
}
}

18
src/text/text_layout.cpp
View File

@ -235,21 +235,21 @@ void text_layout::shape_text(text_line & line)
void text_layout::evaluate_properties(feature_impl const& feature, attributes const& attrs)
{
// dx,dy
double dx = boost::apply_visitor(extract_value<value_double>(feature,attrs), properties_.dx);
double dy = boost::apply_visitor(extract_value<value_double>(feature,attrs), properties_.dy);
double dx = util::apply_visitor(extract_value<value_double>(feature,attrs), properties_.dx);
double dy = util::apply_visitor(extract_value<value_double>(feature,attrs), properties_.dy);
displacement_ = properties_.displacement_evaluator_(dx,dy);
wrap_width_ = boost::apply_visitor(extract_value<value_double>(feature,attrs), properties_.wrap_width);
wrap_width_ = util::apply_visitor(extract_value<value_double>(feature,attrs), properties_.wrap_width);
double angle = boost::apply_visitor(extract_value<value_double>(feature,attrs), properties_.orientation);
double angle = util::apply_visitor(extract_value<value_double>(feature,attrs), properties_.orientation);
orientation_.init(angle * M_PI/ 180.0);
wrap_before_ = boost::apply_visitor(extract_value<value_bool>(feature,attrs), properties_.wrap_before);
rotate_displacement_ = boost::apply_visitor(extract_value<value_bool>(feature,attrs), properties_.rotate_displacement);
wrap_before_ = util::apply_visitor(extract_value<value_bool>(feature,attrs), properties_.wrap_before);
rotate_displacement_ = util::apply_visitor(extract_value<value_bool>(feature,attrs), properties_.rotate_displacement);
valign_ = boost::apply_visitor(extract_value<vertical_alignment_enum>(feature,attrs),properties_.valign);
halign_ = boost::apply_visitor(extract_value<horizontal_alignment_enum>(feature,attrs),properties_.halign);
jalign_ = boost::apply_visitor(extract_value<justify_alignment_enum>(feature,attrs),properties_.jalign);
valign_ = util::apply_visitor(extract_value<vertical_alignment_enum>(feature,attrs),properties_.valign);
halign_ = util::apply_visitor(extract_value<horizontal_alignment_enum>(feature,attrs),properties_.halign);
jalign_ = util::apply_visitor(extract_value<justify_alignment_enum>(feature,attrs),properties_.jalign);
}

100
src/text/text_properties.cpp
View File

@ -58,17 +58,17 @@ text_symbolizer_properties::text_symbolizer_properties()
void text_symbolizer_properties::evaluate_text_properties(feature_impl const& feature, attributes const& attrs)
{
label_placement = boost::apply_visitor(extract_value<label_placement_enum>(feature,attrs), expressions.label_placement);
label_spacing = boost::apply_visitor(extract_value<value_double>(feature,attrs), expressions.label_spacing);
label_position_tolerance = boost::apply_visitor(extract_value<value_double>(feature,attrs), expressions.label_position_tolerance);
avoid_edges = boost::apply_visitor(extract_value<value_bool>(feature,attrs), expressions.avoid_edges);
minimum_distance = boost::apply_visitor(extract_value<value_double>(feature,attrs), expressions.minimum_distance);
minimum_padding = boost::apply_visitor(extract_value<value_double>(feature,attrs), expressions.minimum_padding);
minimum_path_length = boost::apply_visitor(extract_value<value_double>(feature,attrs), expressions.minimum_path_length);
max_char_angle_delta = boost::apply_visitor(extract_value<value_double>(feature,attrs), expressions.max_char_angle_delta) * M_PI/180;
allow_overlap = boost::apply_visitor(extract_value<value_bool>(feature,attrs), expressions.allow_overlap);
largest_bbox_only = boost::apply_visitor(extract_value<value_bool>(feature,attrs), expressions.largest_bbox_only);
upright = boost::apply_visitor(extract_value<text_upright_enum>(feature,attrs), expressions.upright);
label_placement = util::apply_visitor(extract_value<label_placement_enum>(feature,attrs), expressions.label_placement);
label_spacing = util::apply_visitor(extract_value<value_double>(feature,attrs), expressions.label_spacing);
label_position_tolerance = util::apply_visitor(extract_value<value_double>(feature,attrs), expressions.label_position_tolerance);
avoid_edges = util::apply_visitor(extract_value<value_bool>(feature,attrs), expressions.avoid_edges);
minimum_distance = util::apply_visitor(extract_value<value_double>(feature,attrs), expressions.minimum_distance);
minimum_padding = util::apply_visitor(extract_value<value_double>(feature,attrs), expressions.minimum_padding);
minimum_path_length = util::apply_visitor(extract_value<value_double>(feature,attrs), expressions.minimum_path_length);
max_char_angle_delta = util::apply_visitor(extract_value<value_double>(feature,attrs), expressions.max_char_angle_delta) * M_PI/180;
allow_overlap = util::apply_visitor(extract_value<value_bool>(feature,attrs), expressions.allow_overlap);
largest_bbox_only = util::apply_visitor(extract_value<value_bool>(feature,attrs), expressions.largest_bbox_only);
upright = util::apply_visitor(extract_value<text_upright_enum>(feature,attrs), expressions.upright);
}
void text_symbolizer_properties::process(text_layout & output, feature_impl const& feature, attributes const& attrs) //const
@ -81,15 +81,15 @@ void text_symbolizer_properties::process(text_layout & output, feature_impl cons
//evaluate format properties
evaluated_format_properties_ptr format = std::make_shared<detail::evaluated_format_properties>();
format->text_size = boost::apply_visitor(extract_value<value_double>(feature,attrs), format_defaults.text_size);
format->character_spacing = boost::apply_visitor(extract_value<value_double>(feature,attrs), format_defaults.character_spacing);
format->line_spacing = boost::apply_visitor(extract_value<value_double>(feature,attrs), format_defaults.line_spacing);
format->text_opacity = boost::apply_visitor(extract_value<value_double>(feature,attrs), format_defaults.text_opacity);
format->halo_opacity = boost::apply_visitor(extract_value<value_double>(feature,attrs), format_defaults.halo_opacity);
format->halo_radius = boost::apply_visitor(extract_value<value_double>(feature,attrs), format_defaults.halo_radius);
format->fill = boost::apply_visitor(extract_value<color>(feature,attrs), format_defaults.fill);
format->halo_fill = boost::apply_visitor(extract_value<color>(feature,attrs), format_defaults.halo_fill);
format->text_transform = boost::apply_visitor(extract_value<text_transform_enum>(feature,attrs), format_defaults.text_transform);
format->text_size = util::apply_visitor(extract_value<value_double>(feature,attrs), format_defaults.text_size);
format->character_spacing = util::apply_visitor(extract_value<value_double>(feature,attrs), format_defaults.character_spacing);
format->line_spacing = util::apply_visitor(extract_value<value_double>(feature,attrs), format_defaults.line_spacing);
format->text_opacity = util::apply_visitor(extract_value<value_double>(feature,attrs), format_defaults.text_opacity);
format->halo_opacity = util::apply_visitor(extract_value<value_double>(feature,attrs), format_defaults.halo_opacity);
format->halo_radius = util::apply_visitor(extract_value<value_double>(feature,attrs), format_defaults.halo_radius);
format->fill = util::apply_visitor(extract_value<color>(feature,attrs), format_defaults.fill);
format->halo_fill = util::apply_visitor(extract_value<color>(feature,attrs), format_defaults.halo_fill);
format->text_transform = util::apply_visitor(extract_value<text_transform_enum>(feature,attrs), format_defaults.text_transform);
format->face_name = format_defaults.face_name;
format->fontset = format_defaults.fontset;
@ -196,17 +196,17 @@ void text_symbolizer_properties::to_xml(boost::property_tree::ptree &node,
void text_symbolizer_properties::add_expressions(expression_set & output) const
{
if (is_expression(expressions.label_placement)) output.insert(boost::get<expression_ptr>(expressions.label_placement));
if (is_expression(expressions.label_spacing)) output.insert(boost::get<expression_ptr>(expressions.label_spacing));
if (is_expression(expressions.label_position_tolerance)) output.insert(boost::get<expression_ptr>(expressions.label_position_tolerance));
if (is_expression(expressions.avoid_edges)) output.insert(boost::get<expression_ptr>(expressions.avoid_edges));
if (is_expression(expressions.minimum_distance)) output.insert(boost::get<expression_ptr>(expressions.minimum_distance));
if (is_expression(expressions.minimum_padding)) output.insert(boost::get<expression_ptr>(expressions.minimum_padding));
if (is_expression(expressions.minimum_path_length)) output.insert(boost::get<expression_ptr>(expressions.minimum_path_length));
if (is_expression(expressions.max_char_angle_delta)) output.insert(boost::get<expression_ptr>(expressions.max_char_angle_delta));
if (is_expression(expressions.allow_overlap)) output.insert(boost::get<expression_ptr>(expressions.allow_overlap));
if (is_expression(expressions.largest_bbox_only)) output.insert(boost::get<expression_ptr>(expressions.largest_bbox_only));
if (is_expression(expressions.upright)) output.insert(boost::get<expression_ptr>(expressions.upright));
if (is_expression(expressions.label_placement)) output.insert(util::get<expression_ptr>(expressions.label_placement));
if (is_expression(expressions.label_spacing)) output.insert(util::get<expression_ptr>(expressions.label_spacing));
if (is_expression(expressions.label_position_tolerance)) output.insert(util::get<expression_ptr>(expressions.label_position_tolerance));
if (is_expression(expressions.avoid_edges)) output.insert(util::get<expression_ptr>(expressions.avoid_edges));
if (is_expression(expressions.minimum_distance)) output.insert(util::get<expression_ptr>(expressions.minimum_distance));
if (is_expression(expressions.minimum_padding)) output.insert(util::get<expression_ptr>(expressions.minimum_padding));
if (is_expression(expressions.minimum_path_length)) output.insert(util::get<expression_ptr>(expressions.minimum_path_length));
if (is_expression(expressions.max_char_angle_delta)) output.insert(util::get<expression_ptr>(expressions.max_char_angle_delta));
if (is_expression(expressions.allow_overlap)) output.insert(util::get<expression_ptr>(expressions.allow_overlap));
if (is_expression(expressions.largest_bbox_only)) output.insert(util::get<expression_ptr>(expressions.largest_bbox_only));
if (is_expression(expressions.upright)) output.insert(util::get<expression_ptr>(expressions.upright));
layout_defaults.add_expressions(output);
format_defaults.add_expressions(output);
@ -256,16 +256,16 @@ void text_layout_properties::to_xml(boost::property_tree::ptree & node,
void text_layout_properties::add_expressions(expression_set & output) const
{
if (is_expression(dx)) output.insert(boost::get<expression_ptr>(dx));
if (is_expression(dy)) output.insert(boost::get<expression_ptr>(dy));
if (is_expression(orientation)) output.insert(boost::get<expression_ptr>(orientation));
if (is_expression(wrap_width)) output.insert(boost::get<expression_ptr>(wrap_width));
if (is_expression(wrap_before)) output.insert(boost::get<expression_ptr>(wrap_before));
if (is_expression(rotate_displacement)) output.insert(boost::get<expression_ptr>(rotate_displacement));
if (is_expression(text_ratio)) output.insert(boost::get<expression_ptr>(text_ratio));
if (is_expression(halign)) output.insert(boost::get<expression_ptr>(halign));
if (is_expression(valign)) output.insert(boost::get<expression_ptr>(valign));
if (is_expression(jalign)) output.insert(boost::get<expression_ptr>(jalign));
if (is_expression(dx)) output.insert(util::get<expression_ptr>(dx));
if (is_expression(dy)) output.insert(util::get<expression_ptr>(dy));
if (is_expression(orientation)) output.insert(util::get<expression_ptr>(orientation));
if (is_expression(wrap_width)) output.insert(util::get<expression_ptr>(wrap_width));
if (is_expression(wrap_before)) output.insert(util::get<expression_ptr>(wrap_before));
if (is_expression(rotate_displacement)) output.insert(util::get<expression_ptr>(rotate_displacement));
if (is_expression(text_ratio)) output.insert(util::get<expression_ptr>(text_ratio));
if (is_expression(halign)) output.insert(util::get<expression_ptr>(halign));
if (is_expression(valign)) output.insert(util::get<expression_ptr>(valign));
if (is_expression(jalign)) output.insert(util::get<expression_ptr>(jalign));
}
// text format properties
@ -346,15 +346,15 @@ void format_properties::to_xml(boost::property_tree::ptree & node, bool explicit
void format_properties::add_expressions(expression_set & output) const
{
if (is_expression(text_size)) output.insert(boost::get<expression_ptr>(text_size));
if (is_expression(character_spacing)) output.insert(boost::get<expression_ptr>(character_spacing));
if (is_expression(line_spacing)) output.insert(boost::get<expression_ptr>(line_spacing));
if (is_expression(halo_radius)) output.insert(boost::get<expression_ptr>(halo_radius));
if (is_expression(text_opacity)) output.insert(boost::get<expression_ptr>(text_opacity));
if (is_expression(halo_opacity)) output.insert(boost::get<expression_ptr>(halo_opacity));
if (is_expression(fill)) output.insert(boost::get<expression_ptr>(fill));
if (is_expression(halo_fill)) output.insert(boost::get<expression_ptr>(halo_fill));
if (is_expression(text_transform)) output.insert(boost::get<expression_ptr>(text_transform));
if (is_expression(text_size)) output.insert(util::get<expression_ptr>(text_size));
if (is_expression(character_spacing)) output.insert(util::get<expression_ptr>(character_spacing));
if (is_expression(line_spacing)) output.insert(util::get<expression_ptr>(line_spacing));
if (is_expression(halo_radius)) output.insert(util::get<expression_ptr>(halo_radius));
if (is_expression(text_opacity)) output.insert(util::get<expression_ptr>(text_opacity));
if (is_expression(halo_opacity)) output.insert(util::get<expression_ptr>(halo_opacity));
if (is_expression(fill)) output.insert(util::get<expression_ptr>(fill));
if (is_expression(halo_fill)) output.insert(util::get<expression_ptr>(halo_fill));
if (is_expression(text_transform)) output.insert(util::get<expression_ptr>(text_transform));
}