fix linking problems from python

include/mapnik/layer.hpp

@@ -205,7 +205,6 @@ public:
     void reset_buffer_size();
     ~layer();
 private:
-    friend void swap(layer & lhs, layer & rhs);
     std::string name_;
     std::string srs_;
     double min_zoom_;

include/mapnik/rule.hpp

@@ -85,8 +85,6 @@ public:
         syms_.reserve(size);
     }
 
-private:
-    friend void swap(rule & lhs, rule & rhs);
 };
 
 }

src/feature_type_style.cpp

@@ -61,21 +61,16 @@ feature_type_style::feature_type_style(feature_type_style const& rhs)
 }
 
 feature_type_style& feature_type_style::operator=(feature_type_style rhs)
-{
-    swap(*this, rhs);
-    return *this;
-}
-
-void swap( feature_type_style & lhs, feature_type_style & rhs)
 {
     using std::swap;
-    std::swap(lhs.rules_, rhs.rules_);
-    std::swap(lhs.filter_mode_, rhs.filter_mode_);
-    std::swap(lhs.filters_, rhs.filters_);
-    std::swap(lhs.direct_filters_, rhs.direct_filters_);
-    std::swap(lhs.comp_op_, rhs.comp_op_);
-    std::swap(lhs.opacity_, rhs.opacity_);
-    std::swap(lhs.image_filters_inflate_, rhs.image_filters_inflate_);
+    std::swap(this->rules_, rhs.rules_);
+    std::swap(this->filter_mode_, rhs.filter_mode_);
+    std::swap(this->filters_, rhs.filters_);
+    std::swap(this->direct_filters_, rhs.direct_filters_);
+    std::swap(this->comp_op_, rhs.comp_op_);
+    std::swap(this->opacity_, rhs.opacity_);
+    std::swap(this->image_filters_inflate_, rhs.image_filters_inflate_);
+    return *this;
 }
 
 bool feature_type_style::operator==(feature_type_style const& rhs) const

src/layer.cpp

@@ -73,27 +73,22 @@ layer::layer(layer && rhs)
       maximum_extent_(std::move(rhs.maximum_extent_)) {}
 
 layer& layer::operator=(layer rhs)
-{
-    swap(*this, rhs);
-    return *this;
-}
-
-void swap(layer & lhs, layer & rhs)
 {
     using std::swap;
-    std::swap(lhs.name_,rhs.name_);
-    std::swap(lhs.srs_, rhs.srs_);
-    std::swap(lhs.min_zoom_, rhs.min_zoom_);
-    std::swap(lhs.max_zoom_,rhs.max_zoom_);
-    std::swap(lhs.active_, rhs.active_);
-    std::swap(lhs.queryable_, rhs.queryable_);
-    std::swap(lhs.clear_label_cache_, rhs.clear_label_cache_);
-    std::swap(lhs.cache_features_, rhs.cache_features_);
-    std::swap(lhs.group_by_, rhs.group_by_);
-    std::swap(lhs.styles_, rhs.styles_);
-    std::swap(lhs.ds_, rhs.ds_);
-    std::swap(lhs.buffer_size_, rhs.buffer_size_);
-    std::swap(lhs.maximum_extent_, rhs.maximum_extent_);
+    std::swap(this->name_,rhs.name_);
+    std::swap(this->srs_, rhs.srs_);
+    std::swap(this->min_zoom_, rhs.min_zoom_);
+    std::swap(this->max_zoom_,rhs.max_zoom_);
+    std::swap(this->active_, rhs.active_);
+    std::swap(this->queryable_, rhs.queryable_);
+    std::swap(this->clear_label_cache_, rhs.clear_label_cache_);
+    std::swap(this->cache_features_, rhs.cache_features_);
+    std::swap(this->group_by_, rhs.group_by_);
+    std::swap(this->styles_, rhs.styles_);
+    std::swap(this->ds_, rhs.ds_);
+    std::swap(this->buffer_size_, rhs.buffer_size_);
+    std::swap(this->maximum_extent_, rhs.maximum_extent_);
+    return *this;
 }
 
 bool layer::operator==(layer const& rhs) const

src/rule.cpp

@@ -61,7 +61,14 @@ rule::rule(rule const& rhs)
 
 rule& rule::operator=(rule rhs)
 {
-    swap(*this, rhs);
+    using std::swap;
+    swap(this->name_, rhs.name_);
+    swap(this->min_scale_, rhs.min_scale_);
+    swap(this->max_scale_, rhs.max_scale_);
+    swap(this->syms_, rhs.syms_);
+    swap(this->filter_, rhs.filter_);
+    swap(this->else_filter_, rhs.else_filter_);
+    swap(this->also_filter_, rhs.also_filter_);
     return *this;
 }
 
@@ -76,18 +83,6 @@ bool rule::operator==(rule const& rhs) const
         (also_filter_ == rhs.also_filter_);
 }
 
-void swap(rule & lhs, rule & rhs)
-{
-    using std::swap;
-    swap(lhs.name_, rhs.name_);
-    swap(lhs.min_scale_, rhs.min_scale_);
-    swap(lhs.max_scale_, rhs.max_scale_);
-    swap(lhs.syms_, rhs.syms_);
-    swap(lhs.filter_, rhs.filter_);
-    swap(lhs.else_filter_, rhs.else_filter_);
-    swap(lhs.also_filter_, rhs.also_filter_);
-}
-
 void rule::set_max_scale(double scale)
 {
     max_scale_=scale;