sij/mapnik
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

use boost::ptr_containers to store Map elements

Browse source
This commit is contained in:
artemp 2012-07-09 08:44:56 +01:00
parent ee7f72dcce
commit 18633adc7e
13 changed files with 118 additions and 91 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

4
bindings/python/mapnik_map.cpp
View file

@ -62,8 +62,8 @@ struct map_pickle_suite : boost::python::pickle_suite
for (; it != end; ++it) for (; it != end; ++it)
{ {
std::string const& name = it->first; std::string const& name = it->first;
const mapnik::feature_type_style & style = it->second; const mapnik::feature_type_style * style = it->second;
boost::python::tuple style_pair = boost::python::make_tuple(name,style); boost::python::tuple style_pair = boost::python::make_tuple(name,*style);
s.append(style_pair); s.append(style_pair);
} }

2
demo/viewer/styles_model.cpp
View file

@ -312,6 +312,7 @@ StyleModel::StyleModel(boost::shared_ptr<mapnik::Map> map, QObject * parent)
: QAbstractItemModel(parent), : QAbstractItemModel(parent),
root_(new node(map_node(map))) root_(new node(map_node(map)))
{ {
/*
typedef std::map<std::string,mapnik::feature_type_style> style_type; typedef std::map<std::string,mapnik::feature_type_style> style_type;
style_type const & styles = map->styles(); style_type const & styles = map->styles();
style_type::const_iterator itr = styles.begin(); style_type::const_iterator itr = styles.begin();
@ -331,6 +332,7 @@ StyleModel::StyleModel(boost::shared_ptr<mapnik::Map> map, QObject * parent)
} }
} }
} }
*/
} }
StyleModel::~StyleModel() {} StyleModel::~StyleModel() {}

7
include/mapnik/feature_type_style.hpp
View file

@ -31,6 +31,7 @@
// boost // boost
#include <boost/optional.hpp> #include <boost/optional.hpp>
#include <boost/ptr_container/ptr_vector.hpp>
// stl // stl
#include <vector> #include <vector>
@ -45,7 +46,7 @@ enum filter_mode_enum {
DEFINE_ENUM( filter_mode_e, filter_mode_enum ); DEFINE_ENUM( filter_mode_e, filter_mode_enum );
typedef std::vector<rule> rules; typedef boost::ptr_vector<rule> rules;
typedef std::vector<rule*> rule_ptrs; typedef std::vector<rule*> rule_ptrs;
class MAPNIK_DECL feature_type_style class MAPNIK_DECL feature_type_style
@ -68,10 +69,10 @@ public:
feature_type_style(); feature_type_style();
feature_type_style(feature_type_style const& rhs, bool deep_copy = false); feature_type_style(feature_type_style const& rhs, bool deep_copy = false);
feature_type_style& operator=(feature_type_style const& rhs); feature_type_style& operator=(feature_type_style const& rhs);
void add_rule(rule const& rule); void add_rule(std::auto_ptr<rule> rule);
rules const& get_rules() const; rules const& get_rules() const;
rule_ptrs const& get_if_rules(double scale_denom); rule_ptrs const& get_if_rules(double scale_denom);

13
include/mapnik/map.hpp
View file

@ -33,6 +33,7 @@
// boost // boost
#include <boost/optional/optional.hpp> #include <boost/optional/optional.hpp>
#include <boost/ptr_container/ptr_map.hpp>
namespace mapnik namespace mapnik
{ {
@ -71,7 +72,7 @@ private:
int buffer_size_; int buffer_size_;
boost::optional<color> background_; boost::optional<color> background_;
boost::optional<std::string> background_image_; boost::optional<std::string> background_image_;
std::map<std::string,feature_type_style> styles_; boost::ptr_map<std::string,feature_type_style> styles_;
std::map<std::string,metawriter_ptr> metawriters_; std::map<std::string,metawriter_ptr> metawriters_;
std::map<std::string,font_set> fontsets_; std::map<std::string,font_set> fontsets_;
std::vector<layer> layers_; std::vector<layer> layers_;
@ -83,8 +84,8 @@ private:
public: public:
typedef std::map<std::string,feature_type_style>::const_iterator const_style_iterator; typedef boost::ptr_map<std::string,feature_type_style>::const_iterator const_style_iterator;
typedef std::map<std::string,feature_type_style>::iterator style_iterator; typedef boost::ptr_map<std::string,feature_type_style>::iterator style_iterator;
typedef std::map<std::string,font_set>::const_iterator const_fontset_iterator; typedef std::map<std::string,font_set>::const_iterator const_fontset_iterator;
typedef std::map<std::string,font_set>::iterator fontset_iterator; typedef std::map<std::string,font_set>::iterator fontset_iterator;
typedef std::map<std::string,metawriter_ptr>::const_iterator const_metawriter_iterator; typedef std::map<std::string,metawriter_ptr>::const_iterator const_metawriter_iterator;
@ -121,12 +122,12 @@ public:
/*! \brief Get all styles /*! \brief Get all styles
* @return Const reference to styles * @return Const reference to styles
*/ */
std::map<std::string,feature_type_style> const& styles() const; boost::ptr_map<std::string,feature_type_style> const& styles() const;
/*! \brief Get all styles /*! \brief Get all styles
* @return Non-constant reference to styles * @return Non-constant reference to styles
*/ */
std::map<std::string,feature_type_style> & styles(); boost::ptr_map<std::string,feature_type_style> & styles();
/*! \brief Get first iterator in styles. /*! \brief Get first iterator in styles.
* @return Constant style iterator. * @return Constant style iterator.
@ -154,7 +155,7 @@ public:
* @return true If success. * @return true If success.
* @return false If no success. * @return false If no success.
*/ */
bool insert_style(std::string const& name,feature_type_style const& style); bool insert_style(std::string const& name, std::auto_ptr<feature_type_style> style);
/*! \brief Remove a style from the map. /*! \brief Remove a style from the map.
* @param name The name of the style. * @param name The name of the style.

16
include/mapnik/raster_symbolizer.hpp
View file

@ -43,16 +43,22 @@ struct MAPNIK_DECL raster_symbolizer : public symbolizer_base
opacity_(1.0), opacity_(1.0),
colorizer_(), colorizer_(),
filter_factor_(-1), filter_factor_(-1),
mesh_size_(16) {} mesh_size_(16)
{
std::cout << "raster_symbolizer: default ctor called" << std::endl;
}
raster_symbolizer(const raster_symbolizer &rhs) raster_symbolizer(const raster_symbolizer &rhs)
: symbolizer_base(rhs), : symbolizer_base(rhs),
mode_(rhs.get_mode()), mode_(rhs.mode_),
scaling_(rhs.get_scaling()), scaling_(rhs.scaling_),
opacity_(rhs.get_opacity()), opacity_(rhs.opacity_),
colorizer_(rhs.colorizer_), colorizer_(rhs.colorizer_),
filter_factor_(rhs.filter_factor_), filter_factor_(rhs.filter_factor_),
mesh_size_(rhs.mesh_size_) {} mesh_size_(rhs.mesh_size_)
{
std::cout << "raster_symbolizer: copy ctor called" << std::endl;
}
std::string const& get_mode() const std::string const& get_mode() const
{ {

2
src/agg/process_markers_symbolizer.cpp
View file

@ -166,7 +166,7 @@ void agg_renderer<T>::process(markers_symbolizer const& sym,
detector_->has_placement(transformed_bbox)) detector_->has_placement(transformed_bbox))
{ {
svg_renderer.render(*ras_ptr, sl, renb, matrix, sym.get_opacity(), bbox); svg_renderer.render(*ras_ptr, sl, renb, matrix, sym.get_opacity(), bbox);
if (/* DEBUG */ 0) if (/* DEBUG */ 1)
{ {
debug_draw_box(buf, transformed_bbox, 0, 0, 0.0); debug_draw_box(buf, transformed_bbox, 0, 0, 0.0);
} }

4
src/agg/process_raster_symbolizer.cpp
View file

@ -67,13 +67,13 @@ void agg_renderer<T>::process(raster_symbolizer const& sym,
if (raster_width > 0 && raster_height > 0) if (raster_width > 0 && raster_height > 0)
{ {
double scale_factor = ext.width() / source->data_.width();
image_data_32 target_data(raster_width,raster_height); image_data_32 target_data(raster_width,raster_height);
raster target(target_ext, target_data); raster target(target_ext, target_data);
reproject_raster(target, *source, prj_trans, err_offs_x, err_offs_y, reproject_raster(target, *source, prj_trans, err_offs_x, err_offs_y,
sym.get_mesh_size(), sym.get_mesh_size(),
sym.calculate_filter_factor(), sym.calculate_filter_factor(),
scale_factor_, scale_factor,
sym.get_scaling()); sym.get_scaling());
composite(current_buffer_->data(), target.data_, sym.comp_op(), sym.get_opacity(), start_x, start_y, true); composite(current_buffer_->data(), target.data_, sym.comp_op(), sym.get_opacity(), start_x, start_y, true);

10
src/deepcopy.cpp
View file

@ -112,12 +112,12 @@ namespace mapnik { namespace util {
typedef std::map<std::string, feature_type_style> style_cont; typedef std::map<std::string, feature_type_style> style_cont;
typedef style_cont::value_type value_type; typedef style_cont::value_type value_type;
style_cont const& styles = map_in.styles(); //style_cont const& styles = map_in.styles();
BOOST_FOREACH ( value_type const& kv, styles ) //BOOST_FOREACH ( value_type const& kv, styles )
{ {
feature_type_style const& style_in = kv.second; // feature_type_style const& style_in = kv.second;
feature_type_style style_out(style_in,true); // deep copy //feature_type_style style_out(style_in,true); // deep copy
map_out.insert_style(kv.first, style_out); //map_out.insert_style(kv.first, style_out);
} }
} }

3
src/feature_style_processor.cpp
View file

@ -36,6 +36,7 @@
// boost // boost
#include <boost/foreach.hpp> #include <boost/foreach.hpp>
#include <boost/concept_check.hpp> #include <boost/concept_check.hpp>
//stl //stl
#include <vector> #include <vector>
@ -363,7 +364,7 @@ void feature_style_processor<Processor>::apply_to_layer(layer const& lay, Proces
continue; continue;
} }
const std::vector<rule>& rules=(*style).get_rules(); const boost::ptr_vector<rule>& rules=(*style).get_rules();
bool active_rules=false; bool active_rules=false;
BOOST_FOREACH(rule const& r, rules) BOOST_FOREACH(rule const& r, rules)

27
src/feature_type_style.cpp
View file

@ -43,21 +43,28 @@ feature_type_style::feature_type_style()
{} {}
feature_type_style::feature_type_style(feature_type_style const& rhs, bool deep_copy) feature_type_style::feature_type_style(feature_type_style const& rhs, bool deep_copy)
: filter_mode_(rhs.filter_mode_), :
filter_mode_(rhs.filter_mode_),
filters_(rhs.filters_), filters_(rhs.filters_),
direct_filters_(rhs.direct_filters_), direct_filters_(rhs.direct_filters_),
comp_op_(rhs.comp_op_), comp_op_(rhs.comp_op_),
scale_denom_validity_(-1), scale_denom_validity_(-1),
opacity_(rhs.opacity_) opacity_(rhs.opacity_)
{ {
if (!deep_copy) { if (!deep_copy)
{
//rules_= rhs.rules_.release();
rules_ = rhs.rules_; rules_ = rhs.rules_;
} else { }
rules::const_iterator it = rhs.rules_.begin(), else
end = rhs.rules_.end(); {
for(; it != end; ++it) {
rules_.push_back(rule(*it, deep_copy)); //rules::const_iterator it = rhs.rules_.begin(),
} // end = rhs.rules_.end();
//for(; it != end; ++it)
//{
// rules_.push_back(rule(*it, deep_copy));
// }
} }
} }
@ -73,9 +80,9 @@ feature_type_style& feature_type_style::operator=(feature_type_style const& rhs)
return *this; return *this;
} }
void feature_type_style::add_rule(rule const& rule) void feature_type_style::add_rule(std::auto_ptr<rule> r)
{ {
rules_.push_back(rule); rules_.push_back(r);
scale_denom_validity_ = -1; scale_denom_validity_ = -1;
} }

76
src/load_map.cpp
View file

@ -412,10 +412,10 @@ void map_parser::parse_style(Map & map, xml_node const& sty)
try try
{ {
name = sty.get_attr<std::string>("name"); name = sty.get_attr<std::string>("name");
feature_type_style style; std::auto_ptr<feature_type_style> style(new feature_type_style);
filter_mode_e filter_mode = sty.get_attr<filter_mode_e>("filter-mode", FILTER_ALL); filter_mode_e filter_mode = sty.get_attr<filter_mode_e>("filter-mode", FILTER_ALL);
style.set_filter_mode(filter_mode); style->set_filter_mode(filter_mode);
// compositing // compositing
optional<std::string> comp_op_name = sty.get_opt_attr<std::string>("comp-op"); optional<std::string> comp_op_name = sty.get_opt_attr<std::string>("comp-op");
@ -424,7 +424,7 @@ void map_parser::parse_style(Map & map, xml_node const& sty)
optional<composite_mode_e> comp_op = comp_op_from_string(*comp_op_name); optional<composite_mode_e> comp_op = comp_op_from_string(*comp_op_name);
if (comp_op) if (comp_op)
{ {
style.set_comp_op(*comp_op); style->set_comp_op(*comp_op);
} }
else else
{ {
@ -435,7 +435,7 @@ void map_parser::parse_style(Map & map, xml_node const& sty)
optional<float> opacity = sty.get_opt_attr<float>("opacity"); optional<float> opacity = sty.get_opt_attr<float>("opacity");
if (opacity) if (opacity)
{ {
style.set_opacity(*opacity); style->set_opacity(*opacity);
} }
// image filters // image filters
@ -453,7 +453,7 @@ void map_parser::parse_style(Map & map, xml_node const& sty)
bool result = boost::spirit::qi::phrase_parse(itr,end, bool result = boost::spirit::qi::phrase_parse(itr,end,
filter_grammar, filter_grammar,
boost::spirit::qi::ascii::space, boost::spirit::qi::ascii::space,
style.image_filters()); style->image_filters());
if (!result || itr!=end) if (!result || itr!=end)
{ {
throw config_error("failed to parse image-filters: '" + std::string(itr,end) + "'"); throw config_error("failed to parse image-filters: '" + std::string(itr,end) + "'");
@ -473,7 +473,7 @@ void map_parser::parse_style(Map & map, xml_node const& sty)
bool result = boost::spirit::qi::phrase_parse(itr,end, bool result = boost::spirit::qi::phrase_parse(itr,end,
filter_grammar, filter_grammar,
boost::spirit::qi::ascii::space, boost::spirit::qi::ascii::space,
style.direct_image_filters()); style->direct_image_filters());
if (!result || itr!=end) if (!result || itr!=end)
{ {
throw config_error("failed to parse direct-image-filters: '" + std::string(itr,end) + "'"); throw config_error("failed to parse direct-image-filters: '" + std::string(itr,end) + "'");
@ -488,12 +488,14 @@ void map_parser::parse_style(Map & map, xml_node const& sty)
{ {
if (ruleIter->is("Rule")) if (ruleIter->is("Rule"))
{ {
parse_rule(style, *ruleIter); parse_rule(*style, *ruleIter);
} }
} }
map.insert_style(name, style); map.insert_style(name, style);
} catch (const config_error & ex) { }
catch (const config_error & ex)
{
ex.append_context(std::string("in style '") + name + "'", sty); ex.append_context(std::string("in style '") + name + "'", sty);
throw; throw;
} }
@ -728,97 +730,97 @@ void map_parser::parse_layer(Map & map, xml_node const& lay)
} }
} }
void map_parser::parse_rule(feature_type_style & style, xml_node const& r) void map_parser::parse_rule(feature_type_style & style, xml_node const& node)
{ {
std::string name; std::string name;
try try
{ {
name = r.get_attr("name", std::string()); name = node.get_attr("name", std::string());
rule rule(name); std::auto_ptr<rule> r(new rule(name));
xml_node const* child = r.get_opt_child("Filter"); xml_node const* child = node.get_opt_child("Filter");
if (child) if (child)
{ {
rule.set_filter(child->get_value<expression_ptr>()); r->set_filter(child->get_value<expression_ptr>());
} }
if (r.has_child("ElseFilter")) if (node.has_child("ElseFilter"))
{ {
rule.set_else(true); r->set_else(true);
} }
if (r.has_child("AlsoFilter")) if (node.has_child("AlsoFilter"))
{ {
rule.set_also(true); r->set_also(true);
} }
child = r.get_opt_child("MinScaleDenominator"); child = node.get_opt_child("MinScaleDenominator");
if (child) if (child)
{ {
rule.set_min_scale(child->get_value<double>()); r->set_min_scale(child->get_value<double>());
} }
child = r.get_opt_child("MaxScaleDenominator"); child = node.get_opt_child("MaxScaleDenominator");
if (child) if (child)
{ {
rule.set_max_scale(child->get_value<double>()); r->set_max_scale(child->get_value<double>());
} }
xml_node::const_iterator symIter = r.begin(); xml_node::const_iterator symIter = node.begin();
xml_node::const_iterator endSym = r.end(); xml_node::const_iterator endSym = node.end();
for(;symIter != endSym; ++symIter) for(;symIter != endSym; ++symIter)
{ {
if (symIter->is("PointSymbolizer")) if (symIter->is("PointSymbolizer"))
{ {
parse_point_symbolizer(rule, *symIter); parse_point_symbolizer(*r, *symIter);
} }
else if (symIter->is("LinePatternSymbolizer")) else if (symIter->is("LinePatternSymbolizer"))
{ {
parse_line_pattern_symbolizer(rule, *symIter); parse_line_pattern_symbolizer(*r, *symIter);
} }
else if (symIter->is("PolygonPatternSymbolizer")) else if (symIter->is("PolygonPatternSymbolizer"))
{ {
parse_polygon_pattern_symbolizer(rule, *symIter); parse_polygon_pattern_symbolizer(*r, *symIter);
} }
else if (symIter->is("TextSymbolizer")) else if (symIter->is("TextSymbolizer"))
{ {
parse_text_symbolizer(rule, *symIter); parse_text_symbolizer(*r, *symIter);
} }
else if (symIter->is("ShieldSymbolizer")) else if (symIter->is("ShieldSymbolizer"))
{ {
parse_shield_symbolizer(rule, *symIter); parse_shield_symbolizer(*r, *symIter);
} }
else if (symIter->is("LineSymbolizer")) else if (symIter->is("LineSymbolizer"))
{ {
parse_line_symbolizer(rule, *symIter); parse_line_symbolizer(*r, *symIter);
} }
else if (symIter->is("PolygonSymbolizer")) else if (symIter->is("PolygonSymbolizer"))
{ {
parse_polygon_symbolizer(rule, *symIter); parse_polygon_symbolizer(*r, *symIter);
} }
else if (symIter->is("BuildingSymbolizer")) else if (symIter->is("BuildingSymbolizer"))
{ {
parse_building_symbolizer(rule, *symIter); parse_building_symbolizer(*r, *symIter);
} }
else if (symIter->is("RasterSymbolizer")) else if (symIter->is("RasterSymbolizer"))
{ {
parse_raster_symbolizer(rule, *symIter); parse_raster_symbolizer(*r, *symIter);
} }
else if (symIter->is("MarkersSymbolizer")) else if (symIter->is("MarkersSymbolizer"))
{ {
parse_markers_symbolizer(rule, *symIter); parse_markers_symbolizer(*r, *symIter);
} }
} }
style.add_rule(rule); style.add_rule(r);
} }
catch (const config_error & ex) catch (const config_error & ex)
{ {
if (!name.empty()) if (!name.empty())
{ {
ex.append_context(std::string("in rule '") + name + "'", r); ex.append_context(std::string("in rule '") + name + "'", node);
} }
throw; throw;
} }

33
src/map.cpp
View file

@ -31,6 +31,9 @@
#include <mapnik/config_error.hpp> #include <mapnik/config_error.hpp>
#include <mapnik/config.hpp> // for PROJ_ENVELOPE_POINTS #include <mapnik/config.hpp> // for PROJ_ENVELOPE_POINTS
#include <boost/ptr_container/ptr_map.hpp>
#include <boost/assign/ptr_map_inserter.hpp>
// boost // boost
#include <boost/make_shared.hpp> #include <boost/make_shared.hpp>
@ -90,7 +93,7 @@ Map::Map(const Map& rhs)
buffer_size_(rhs.buffer_size_), buffer_size_(rhs.buffer_size_),
background_(rhs.background_), background_(rhs.background_),
background_image_(rhs.background_image_), background_image_(rhs.background_image_),
styles_(rhs.styles_), //styles_(rhs.styles_),
metawriters_(rhs.metawriters_), metawriters_(rhs.metawriters_),
fontsets_(rhs.fontsets_), fontsets_(rhs.fontsets_),
layers_(rhs.layers_), layers_(rhs.layers_),
@ -109,7 +112,7 @@ Map& Map::operator=(const Map& rhs)
buffer_size_ = rhs.buffer_size_; buffer_size_ = rhs.buffer_size_;
background_=rhs.background_; background_=rhs.background_;
background_image_=rhs.background_image_; background_image_=rhs.background_image_;
styles_=rhs.styles_; //styles_=rhs.styles_;
metawriters_ = rhs.metawriters_; metawriters_ = rhs.metawriters_;
fontsets_ = rhs.fontsets_; fontsets_ = rhs.fontsets_;
layers_=rhs.layers_; layers_=rhs.layers_;
@ -120,12 +123,12 @@ Map& Map::operator=(const Map& rhs)
return *this; return *this;
} }
std::map<std::string,feature_type_style> const& Map::styles() const boost::ptr_map<std::string,feature_type_style> const& Map::styles() const
{ {
return styles_; return styles_;
} }
std::map<std::string,feature_type_style> & Map::styles() boost::ptr_map<std::string,feature_type_style> & Map::styles()
{ {
return styles_; return styles_;
} }
@ -150,9 +153,11 @@ Map::const_style_iterator Map::end_styles() const
return styles_.end(); return styles_.end();
} }
bool Map::insert_style(std::string const& name,feature_type_style const& style) bool Map::insert_style(std::string const& name, std::auto_ptr<feature_type_style> style)
{ {
return styles_.insert(make_pair(name,style)).second; //boost::assign::ptr_map_insert(styles_)(name,style);
styles_.insert(name,style);
return true; // FIXME
} }
void Map::remove_style(std::string const& name) void Map::remove_style(std::string const& name)
@ -162,9 +167,9 @@ void Map::remove_style(std::string const& name)
boost::optional<feature_type_style const&> Map::find_style(std::string const& name) const boost::optional<feature_type_style const&> Map::find_style(std::string const& name) const
{ {
std::map<std::string,feature_type_style>::const_iterator itr = styles_.find(name); boost::ptr_map<std::string,feature_type_style>::const_iterator itr = styles_.find(name);
if (itr != styles_.end()) if (itr != styles_.end())
return boost::optional<feature_type_style const&>(itr->second); return boost::optional<feature_type_style const&>(*itr->second);
else else
return boost::optional<feature_type_style const&>() ; return boost::optional<feature_type_style const&>() ;
} }
@ -634,13 +639,15 @@ void Map::init_metawriters()
Map::style_iterator styIter = begin_styles(); Map::style_iterator styIter = begin_styles();
Map::style_iterator styEnd = end_styles(); Map::style_iterator styEnd = end_styles();
for (; styIter!=styEnd; ++styIter) { for (; styIter!=styEnd; ++styIter) {
std::vector<rule>& rules = styIter->second.get_rules_nonconst(); boost::ptr_vector<rule>& rules = styIter->second->get_rules_nonconst();
std::vector<rule>::iterator ruleIter = rules.begin(); boost::ptr_vector<rule>::iterator ruleIter = rules.begin();
std::vector<rule>::iterator ruleEnd = rules.end(); boost::ptr_vector<rule>::iterator ruleEnd = rules.end();
for (; ruleIter!=ruleEnd; ++ruleIter) { for (; ruleIter!=ruleEnd; ++ruleIter)
{
rule::symbolizers::iterator symIter = ruleIter->begin(); rule::symbolizers::iterator symIter = ruleIter->begin();
rule::symbolizers::iterator symEnd = ruleIter->end(); rule::symbolizers::iterator symEnd = ruleIter->end();
for (; symIter!=symEnd; ++symIter) { for (; symIter!=symEnd; ++symIter)
{
boost::apply_visitor(d, *symIter); boost::apply_visitor(d, *symIter);
} }
} }

12
src/save_map.cpp
View file

@ -530,7 +530,7 @@ void serialize_rule( ptree & style_node, const rule & r, bool explicit_defaults)
void serialize_style( ptree & map_node, Map::const_style_iterator style_it, bool explicit_defaults ) void serialize_style( ptree & map_node, Map::const_style_iterator style_it, bool explicit_defaults )
{ {
feature_type_style const& style = style_it->second; feature_type_style const* style = style_it->second;
std::string const& name = style_it->first; std::string const& name = style_it->first;
ptree & style_node = map_node.push_back( ptree & style_node = map_node.push_back(
@ -539,19 +539,19 @@ void serialize_style( ptree & map_node, Map::const_style_iterator style_it, bool
set_attr(style_node, "name", name); set_attr(style_node, "name", name);
feature_type_style dfl; feature_type_style dfl;
filter_mode_e filter_mode = style.get_filter_mode(); filter_mode_e filter_mode = style->get_filter_mode();
if (filter_mode != dfl.get_filter_mode() || explicit_defaults) if (filter_mode != dfl.get_filter_mode() || explicit_defaults)
{ {
set_attr(style_node, "filter-mode", filter_mode); set_attr(style_node, "filter-mode", filter_mode);
} }
double opacity = style.get_opacity(); double opacity = style->get_opacity();
if (opacity != dfl.get_opacity() || explicit_defaults) if (opacity != dfl.get_opacity() || explicit_defaults)
{ {
set_attr(style_node, "opacity", opacity); set_attr(style_node, "opacity", opacity);
} }
boost::optional<composite_mode_e> comp_op = style.comp_op(); boost::optional<composite_mode_e> comp_op = style->comp_op();
if (comp_op) if (comp_op)
{ {
set_attr(style_node, "comp-op", *comp_op_to_string(*comp_op)); set_attr(style_node, "comp-op", *comp_op_to_string(*comp_op));
@ -561,8 +561,8 @@ void serialize_style( ptree & map_node, Map::const_style_iterator style_it, bool
set_attr(style_node, "comp-op", "src-over"); set_attr(style_node, "comp-op", "src-over");
} }
rules::const_iterator it = style.get_rules().begin(); rules::const_iterator it = style->get_rules().begin();
rules::const_iterator end = style.get_rules().end(); rules::const_iterator end = style->get_rules().end();
for (; it != end; ++it) for (; it != end; ++it)
{ {
serialize_rule( style_node, * it , explicit_defaults); serialize_rule( style_node, * it , explicit_defaults);