remove spurious std::move's (clang - moving a temporary object prevents copy elision [-Wpessimizing-move])

artemp · artemp · commit df4226a825ca · 2015-06-02T14:26:35.000+01:00
diff --git a/include/mapnik/feature.hpp b/include/mapnik/feature.hpp
@@ -115,13 +115,13 @@ class MAPNIK_DECL feature_impl : private util::noncopyable
     template <typename T>
     inline void put(context_type::key_type const& key, T const& val)
     {
-        put(key, std::move(value(val)));
+        put(key, value(val));
     }
 
     template <typename T>
     inline void put_new(context_type::key_type const& key, T const& val)
     {
-        put_new(key,std::move(value(val)));
+        put_new(key, value(val));
     }
 
     inline void put(context_type::key_type const& key, value && val)
diff --git a/include/mapnik/renderer_common/process_point_symbolizer.hpp b/include/mapnik/renderer_common/process_point_symbolizer.hpp
@@ -46,9 +46,9 @@ void render_point_symbolizer(point_symbolizer const &sym,
 {
     std::string filename = get<std::string,keys::file>(sym,feature, common.vars_);
     std::shared_ptr<mapnik::marker const> mark = filename.empty()
-       ? std::make_shared<mapnik::marker const>(std::move(mapnik::marker_rgba8()))
+       ? std::make_shared<mapnik::marker const>(mapnik::marker_rgba8())
        : marker_cache::instance().find(filename, true);
-    
+
     if (!mark->is<mapnik::marker_null>())
     {
         value_double opacity = get<value_double,keys::opacity>(sym, feature, common.vars_);
diff --git a/include/mapnik/util/geometry_to_wkb.hpp b/include/mapnik/util/geometry_to_wkb.hpp
@@ -141,7 +141,7 @@ wkb_buffer_ptr point_wkb( geometry::point<double> const& pt, wkbByteOrder byte_o
     write(ss, pt.x, 8, byte_order);
     write(ss, pt.y, 8, byte_order);
     assert(ss.good());
-    return std::move(wkb);
+    return wkb;
 }
 
 wkb_buffer_ptr line_string_wkb(geometry::line_string<double> const& line, wkbByteOrder byte_order)
@@ -161,7 +161,7 @@ wkb_buffer_ptr line_string_wkb(geometry::line_string<double> const& line, wkbByt
         write(ss, pt.y, 8, byte_order);
     }
     assert(ss.good());
-    return std::move(wkb);
+    return wkb;
 }
 
 wkb_buffer_ptr polygon_wkb( geometry::polygon<double> const& poly, wkbByteOrder byte_order)
@@ -199,7 +199,7 @@ wkb_buffer_ptr polygon_wkb( geometry::polygon<double> const& poly, wkbByteOrder
     }
 
     assert(ss.good());
-    return std::move(wkb);
+    return wkb;
 }
 
 wkb_buffer_ptr multi_point_wkb( geometry::multi_point<double> const& multi_pt, wkbByteOrder byte_order)
@@ -218,7 +218,7 @@ wkb_buffer_ptr multi_point_wkb( geometry::multi_point<double> const& multi_pt, w
         write(ss, pt.y, 8, byte_order);
     }
     assert(ss.good());
-    return std::move(wkb);
+    return wkb;
 }
 
 
@@ -296,7 +296,7 @@ wkb_buffer_ptr multi_geom_wkb(MultiGeometry const& multi_geom, wkbByteOrder byte
         ss.write(wkb->buffer(), wkb->size());
     }
 
-    return std::move(multi_wkb);
+    return multi_wkb;
 }
 } // ns detail
 
@@ -305,7 +305,7 @@ using wkb_buffer_ptr = detail::wkb_buffer_ptr;
 template<typename GeometryType>
 wkb_buffer_ptr to_wkb(GeometryType const& geom, wkbByteOrder byte_order )
 {
-    return std::move(detail::geometry_to_wkb(byte_order)(geom));
+    return detail::geometry_to_wkb(byte_order)(geom);
 }
 
 }}
diff --git a/include/mapnik/value.hpp b/include/mapnik/value.hpp
@@ -751,7 +751,7 @@ struct to_unicode
         util::to_string(str,val);
         return value_unicode_string(str.c_str());
     }
-    
+
     value_unicode_string operator() (value_bool val) const
     {
         if (val) {
@@ -833,7 +833,7 @@ class value : public value_base
 
     template <typename T>
     value ( T && val)
-        : value_base(std::move(typename detail::mapnik_value_type<T>::type(val))) {}
+        : value_base(typename detail::mapnik_value_type<T>::type(val)) {}
 
     value & operator=( value const& other) = default;
 
diff --git a/plugins/input/ogr/ogr_converter.cpp b/plugins/input/ogr/ogr_converter.cpp
@@ -107,8 +107,7 @@ mapnik::geometry::multi_line_string<double> ogr_converter::convert_multilinestri
     geom.reserve(num_geometries);
     for (int i = 0; i < num_geometries; ++i)
     {
-        geom.emplace_back(std::move(
-            convert_linestring(static_cast<OGRLineString*>(ogr_geom->getGeometryRef(i)))));
+        geom.emplace_back(convert_linestring(static_cast<OGRLineString*>(ogr_geom->getGeometryRef(i))));
     }
     return geom;
 }
@@ -150,8 +149,7 @@ mapnik::geometry::multi_polygon<double> ogr_converter::convert_multipolygon(OGRM
     geom.reserve(num_geometries);
     for (int i = 0; i < num_geometries; ++i)
     {
-        geom.emplace_back(std::move(
-            convert_polygon(static_cast<OGRPolygon*>(ogr_geom->getGeometryRef(i)))));
+        geom.emplace_back(convert_polygon(static_cast<OGRPolygon*>(ogr_geom->getGeometryRef(i))));
     }
     return geom;
 }
@@ -166,7 +164,7 @@ mapnik::geometry::geometry_collection<double> ogr_converter::convert_collection(
         OGRGeometry* g = ogr_geom->getGeometryRef(i);
         if (g != nullptr)
         {
-            geom.emplace_back(std::move(convert_geometry(g)));
+            geom.emplace_back(convert_geometry(g));
         }
     }
     return geom;
diff --git a/plugins/input/shape/shapefile.hpp b/plugins/input/shape/shapefile.hpp
@@ -72,8 +72,8 @@ template <typename Tag>
 struct shape_record
 {
     typename Tag::data_type data;
-    size_t size;
-    mutable size_t pos;
+    std::size_t size;
+    mutable std::size_t pos;
 
     explicit shape_record(size_t size_)
         : data(Tag::alloc(size_)),
@@ -129,6 +129,8 @@ struct shape_record
     {
         return (size - pos);
     }
+
+    std::size_t length() {return size;}
 };
 
 class shape_file : mapnik::util::noncopyable
diff --git a/src/image_copy.cpp b/src/image_copy.cpp
@@ -42,8 +42,8 @@ template <typename T0>
 struct visitor_image_copy
 {
     using dst_type = typename T0::pixel_type;
-    
-    T0 operator() (image_null const&) 
+
+    T0 operator() (image_null const&)
     {
         throw std::runtime_error("Can not cast a null image");
     }
@@ -52,7 +52,7 @@ struct visitor_image_copy
     {
         return T0(src);
     }
-    
+
     template <typename T1>
     T0 operator() (T1 const& src)
     {
@@ -69,7 +69,7 @@ struct visitor_image_copy
                 {
                     dst(x,y) = std::numeric_limits<dst_type>::min();
                 }
-                catch(positive_overflow&) 
+                catch(positive_overflow&)
                 {
                     dst(x,y) = std::numeric_limits<dst_type>::max();
                 }
@@ -83,11 +83,11 @@ template <typename T0>
 struct visitor_image_copy_so
 {
     using dst_type = typename T0::pixel_type;
-    
+
     visitor_image_copy_so(double offset, double scaling)
         : offset_(offset), scaling_(scaling) {}
 
-    T0 operator() (image_null const&) 
+    T0 operator() (image_null const&)
     {
         throw std::runtime_error("Can not cast a null image");
     }
@@ -101,12 +101,12 @@ struct visitor_image_copy_so
         else
         {
             T0 dst(src);
-            dst.set_scaling(scaling_); 
-            dst.set_offset(offset_); 
+            dst.set_scaling(scaling_);
+            dst.set_offset(offset_);
             return T0(std::move(dst));
         }
     }
-    
+
     template <typename T1>
     T0 operator() (T1 const& src)
     {
@@ -129,7 +129,7 @@ struct visitor_image_copy_so
                 {
                     dst(x,y) = std::numeric_limits<dst_type>::min();
                 }
-                catch(positive_overflow&) 
+                catch(positive_overflow&)
                 {
                     dst(x,y) = std::numeric_limits<dst_type>::max();
                 }
@@ -327,27 +327,27 @@ MAPNIK_DECL image_any image_copy(image_any const& data, image_dtype type, double
     switch (type)
     {
         case image_dtype_rgba8:
-            return image_any(std::move(image_copy<image_rgba8>(data, offset, scaling)));
+            return image_any(image_copy<image_rgba8>(data, offset, scaling));
         case image_dtype_gray8:
-            return image_any(std::move(image_copy<image_gray8>(data, offset, scaling)));
+            return image_any(image_copy<image_gray8>(data, offset, scaling));
         case image_dtype_gray8s:
-            return image_any(std::move(image_copy<image_gray8s>(data, offset, scaling)));
+            return image_any(image_copy<image_gray8s>(data, offset, scaling));
         case image_dtype_gray16:
-            return image_any(std::move(image_copy<image_gray16>(data, offset, scaling)));
+            return image_any(image_copy<image_gray16>(data, offset, scaling));
         case image_dtype_gray16s:
-            return image_any(std::move(image_copy<image_gray16s>(data, offset, scaling)));
+            return image_any(image_copy<image_gray16s>(data, offset, scaling));
         case image_dtype_gray32:
-            return image_any(std::move(image_copy<image_gray32>(data, offset, scaling)));
+            return image_any(image_copy<image_gray32>(data, offset, scaling));
         case image_dtype_gray32s:
-            return image_any(std::move(image_copy<image_gray32s>(data, offset, scaling)));
+            return image_any(image_copy<image_gray32s>(data, offset, scaling));
         case image_dtype_gray32f:
-            return image_any(std::move(image_copy<image_gray32f>(data, offset, scaling)));
+            return image_any(image_copy<image_gray32f>(data, offset, scaling));
         case image_dtype_gray64:
-            return image_any(std::move(image_copy<image_gray64>(data, offset, scaling)));
+            return image_any(image_copy<image_gray64>(data, offset, scaling));
         case image_dtype_gray64s:
-            return image_any(std::move(image_copy<image_gray64s>(data, offset, scaling)));
+            return image_any(image_copy<image_gray64s>(data, offset, scaling));
         case image_dtype_gray64f:
-            return image_any(std::move(image_copy<image_gray64f>(data, offset, scaling)));
+            return image_any(image_copy<image_gray64f>(data, offset, scaling));
         case image_dtype_null:
             throw std::runtime_error("Can not cast a null image");
         case IMAGE_DTYPE_MAX:
diff --git a/src/map.cpp b/src/map.cpp
@@ -309,7 +309,7 @@ bool Map::load_fonts()
         mapnik::util::file file(file_path);
         if (file.open())
         {
-            auto item = font_memory_cache_.emplace(file_path, std::make_pair(std::move(file.data()),file.size()));
+            auto item = font_memory_cache_.emplace(file_path, std::make_pair(file.data(),file.size()));
             if (item.second) result = true;
         }
     }
diff --git a/src/text/symbolizer_helpers.cpp b/src/text/symbolizer_helpers.cpp
@@ -90,14 +90,14 @@ struct split_multi_geometries
     {
         for ( auto const& pt : multi_pt )
         {
-            cont_.push_back(std::move(base_symbolizer_helper::geometry_cref(std::cref(pt))));
+            cont_.push_back(base_symbolizer_helper::geometry_cref(std::cref(pt)));
         }
     }
     void operator() (geometry::multi_line_string<double> const& multi_line) const
     {
         for ( auto const& line : multi_line )
         {
-            cont_.push_back(std::move(base_symbolizer_helper::geometry_cref(std::cref(line))));
+            cont_.push_back(base_symbolizer_helper::geometry_cref(std::cref(line)));
         }
     }
 
@@ -108,12 +108,12 @@ struct split_multi_geometries
             box2d<double> bbox = t_.forward(geometry::envelope(poly), prj_trans_);
             if (bbox.width() >= minimum_path_length_)
             {
-                cont_.push_back(std::move(base_symbolizer_helper::geometry_cref(std::cref(poly))));
+                cont_.push_back(base_symbolizer_helper::geometry_cref(std::cref(poly)));
             }
         }
         else
         {
-            cont_.push_back(std::move(base_symbolizer_helper::geometry_cref(std::cref(poly))));
+            cont_.push_back(base_symbolizer_helper::geometry_cref(std::cref(poly)));
         }
     }
 
@@ -136,7 +136,7 @@ struct split_multi_geometries
     template <typename Geometry>
     void operator() (Geometry const& geom) const
     {
-        cont_.push_back(std::move(base_symbolizer_helper::geometry_cref(std::cref(geom))));
+        cont_.push_back(base_symbolizer_helper::geometry_cref(std::cref(geom)));
     }
 
     container_type & cont_;
diff --git a/src/wkb.cpp b/src/wkb.cpp
diff --git a/test/unit/core/exceptions_test.cpp b/test/unit/core/exceptions_test.cpp

Original file line number	Diff line number	Diff line change
`@@ -115,13 +115,13 @@ class MAPNIK_DECL feature_impl : private util::noncopyable`
`115`	`115`	`template <typename T>`
`116`	`116`	`inline void put(context_type::key_type const& key, T const& val)`
`117`	`117`	`{`
`118`		`- put(key, std::move(value(val)));`
	`118`	`+ put(key, value(val));`
`119`	`119`	`}`
`120`	`120`
`121`	`121`	`template <typename T>`
`122`	`122`	`inline void put_new(context_type::key_type const& key, T const& val)`
`123`	`123`	`{`
`124`		`- put_new(key,std::move(value(val)));`
	`124`	`+ put_new(key, value(val));`
`125`	`125`	`}`
`126`	`126`
`127`	`127`	`inline void put(context_type::key_type const& key, value && val)`
Original file line number	Diff line number	Diff line change
`@@ -46,9 +46,9 @@ void render_point_symbolizer(point_symbolizer const &sym,`
`46`	`46`	`{`
`47`	`47`	`std::string filename = get<std::string,keys::file>(sym,feature, common.vars_);`
`48`	`48`	`std::shared_ptr<mapnik::marker const> mark = filename.empty()`
`49`		`- ? std::make_shared<mapnik::marker const>(std::move(mapnik::marker_rgba8()))`
	`49`	`+ ? std::make_shared<mapnik::marker const>(mapnik::marker_rgba8())`
`50`	`50`	`: marker_cache::instance().find(filename, true);`
`51`		`-`
	`51`	`+`
`52`	`52`	`if (!mark->is<mapnik::marker_null>())`
`53`	`53`	`{`
`54`	`54`	`value_double opacity = get<value_double,keys::opacity>(sym, feature, common.vars_);`
Original file line number	Diff line number	Diff line change
`@@ -141,7 +141,7 @@ wkb_buffer_ptr point_wkb( geometry::point<double> const& pt, wkbByteOrder byte_o`
`141`	`141`	`write(ss, pt.x, 8, byte_order);`
`142`	`142`	`write(ss, pt.y, 8, byte_order);`
`143`	`143`	`assert(ss.good());`
`144`		`- return std::move(wkb);`
	`144`	`+ return wkb;`
`145`	`145`	`}`
`146`	`146`
`147`	`147`	`wkb_buffer_ptr line_string_wkb(geometry::line_string<double> const& line, wkbByteOrder byte_order)`
`@@ -161,7 +161,7 @@ wkb_buffer_ptr line_string_wkb(geometry::line_string<double> const& line, wkbByt`
`161`	`161`	`write(ss, pt.y, 8, byte_order);`
`162`	`162`	`}`
`163`	`163`	`assert(ss.good());`
`164`		`- return std::move(wkb);`
	`164`	`+ return wkb;`
`165`	`165`	`}`
`166`	`166`
`167`	`167`	`wkb_buffer_ptr polygon_wkb( geometry::polygon<double> const& poly, wkbByteOrder byte_order)`
`@@ -199,7 +199,7 @@ wkb_buffer_ptr polygon_wkb( geometry::polygon<double> const& poly, wkbByteOrder`
`199`	`199`	`}`
`200`	`200`
`201`	`201`	`assert(ss.good());`
`202`		`- return std::move(wkb);`
	`202`	`+ return wkb;`
`203`	`203`	`}`
`204`	`204`
`205`	`205`	`wkb_buffer_ptr multi_point_wkb( geometry::multi_point<double> const& multi_pt, wkbByteOrder byte_order)`
`@@ -218,7 +218,7 @@ wkb_buffer_ptr multi_point_wkb( geometry::multi_point<double> const& multi_pt, w`
`218`	`218`	`write(ss, pt.y, 8, byte_order);`
`219`	`219`	`}`
`220`	`220`	`assert(ss.good());`
`221`		`- return std::move(wkb);`
	`221`	`+ return wkb;`
`222`	`222`	`}`
`223`	`223`
`224`	`224`
`@@ -296,7 +296,7 @@ wkb_buffer_ptr multi_geom_wkb(MultiGeometry const& multi_geom, wkbByteOrder byte`
`296`	`296`	`ss.write(wkb->buffer(), wkb->size());`
`297`	`297`	`}`
`298`	`298`
`299`		`- return std::move(multi_wkb);`
	`299`	`+ return multi_wkb;`
`300`	`300`	`}`
`301`	`301`	`} // ns detail`
`302`	`302`
`@@ -305,7 +305,7 @@ using wkb_buffer_ptr = detail::wkb_buffer_ptr;`
`305`	`305`	`template<typename GeometryType>`
`306`	`306`	`wkb_buffer_ptr to_wkb(GeometryType const& geom, wkbByteOrder byte_order )`
`307`	`307`	`{`
`308`		`- return std::move(detail::geometry_to_wkb(byte_order)(geom));`
	`308`	`+ return detail::geometry_to_wkb(byte_order)(geom);`
`309`	`309`	`}`
`310`	`310`
`311`	`311`	`}}`
Original file line number	Diff line number	Diff line change
`@@ -751,7 +751,7 @@ struct to_unicode`
`751`	`751`	`util::to_string(str,val);`
`752`	`752`	`return value_unicode_string(str.c_str());`
`753`	`753`	`}`
`754`		`-`
	`754`	`+`
`755`	`755`	`value_unicode_string operator() (value_bool val) const`
`756`	`756`	`{`
`757`	`757`	`if (val) {`
`@@ -833,7 +833,7 @@ class value : public value_base`
`833`	`833`
`834`	`834`	`template <typename T>`
`835`	`835`	`value ( T && val)`
`836`		`- : value_base(std::move(typename detail::mapnik_value_type<T>::type(val))) {}`
	`836`	`+ : value_base(typename detail::mapnik_value_type<T>::type(val)) {}`
`837`	`837`
`838`	`838`	`value & operator=( value const& other) = default;`
`839`	`839`
Original file line number	Diff line number	Diff line change
`@@ -107,8 +107,7 @@ mapnik::geometry::multi_line_string<double> ogr_converter::convert_multilinestri`
`107`	`107`	`geom.reserve(num_geometries);`
`108`	`108`	`for (int i = 0; i < num_geometries; ++i)`
`109`	`109`	`{`
`110`		`- geom.emplace_back(std::move(`
`111`		`- convert_linestring(static_cast<OGRLineString*>(ogr_geom->getGeometryRef(i)))));`
	`110`	`+ geom.emplace_back(convert_linestring(static_cast<OGRLineString*>(ogr_geom->getGeometryRef(i))));`
`112`	`111`	`}`
`113`	`112`	`return geom;`
`114`	`113`	`}`
`@@ -150,8 +149,7 @@ mapnik::geometry::multi_polygon<double> ogr_converter::convert_multipolygon(OGRM`
`150`	`149`	`geom.reserve(num_geometries);`
`151`	`150`	`for (int i = 0; i < num_geometries; ++i)`
`152`	`151`	`{`
`153`		`- geom.emplace_back(std::move(`
`154`		`- convert_polygon(static_cast<OGRPolygon*>(ogr_geom->getGeometryRef(i)))));`
	`152`	`+ geom.emplace_back(convert_polygon(static_cast<OGRPolygon*>(ogr_geom->getGeometryRef(i))));`
`155`	`153`	`}`
`156`	`154`	`return geom;`
`157`	`155`	`}`
`@@ -166,7 +164,7 @@ mapnik::geometry::geometry_collection<double> ogr_converter::convert_collection(`
`166`	`164`	`OGRGeometry* g = ogr_geom->getGeometryRef(i);`
`167`	`165`	`if (g != nullptr)`
`168`	`166`	`{`
`169`		`- geom.emplace_back(std::move(convert_geometry(g)));`
	`167`	`+ geom.emplace_back(convert_geometry(g));`
`170`	`168`	`}`
`171`	`169`	`}`
`172`	`170`	`return geom;`
Original file line number	Diff line number	Diff line change
`@@ -72,8 +72,8 @@ template <typename Tag>`
`72`	`72`	`struct shape_record`
`73`	`73`	`{`
`74`	`74`	`typename Tag::data_type data;`
`75`		`- size_t size;`
`76`		`- mutable size_t pos;`
	`75`	`+ std::size_t size;`
	`76`	`+ mutable std::size_t pos;`
`77`	`77`
`78`	`78`	`explicit shape_record(size_t size_)`
`79`	`79`	`: data(Tag::alloc(size_)),`
`@@ -129,6 +129,8 @@ struct shape_record`
`129`	`129`	`{`
`130`	`130`	`return (size - pos);`
`131`	`131`	`}`
	`132`	`+`
	`133`	`+ std::size_t length() {return size;}`
`132`	`134`	`};`
`133`	`135`
`134`	`136`	`class shape_file : mapnik::util::noncopyable`
Original file line number	Diff line number	Diff line change
`@@ -42,8 +42,8 @@ template <typename T0>`
`42`	`42`	`struct visitor_image_copy`
`43`	`43`	`{`
`44`	`44`	`using dst_type = typename T0::pixel_type;`
`45`		`-`
`46`		`- T0 operator() (image_null const&)`
	`45`	`+`
	`46`	`+ T0 operator() (image_null const&)`
`47`	`47`	`{`
`48`	`48`	`throw std::runtime_error("Can not cast a null image");`
`49`	`49`	`}`
`@@ -52,7 +52,7 @@ struct visitor_image_copy`
`52`	`52`	`{`
`53`	`53`	`return T0(src);`
`54`	`54`	`}`
`55`		`-`
	`55`	`+`
`56`	`56`	`template <typename T1>`
`57`	`57`	`T0 operator() (T1 const& src)`
`58`	`58`	`{`
`@@ -69,7 +69,7 @@ struct visitor_image_copy`
`69`	`69`	`{`
`70`	`70`	`dst(x,y) = std::numeric_limits<dst_type>::min();`
`71`	`71`	`}`
`72`		`- catch(positive_overflow&)`
	`72`	`+ catch(positive_overflow&)`
`73`	`73`	`{`
`74`	`74`	`dst(x,y) = std::numeric_limits<dst_type>::max();`
`75`	`75`	`}`
`@@ -83,11 +83,11 @@ template <typename T0>`
`83`	`83`	`struct visitor_image_copy_so`
`84`	`84`	`{`
`85`	`85`	`using dst_type = typename T0::pixel_type;`
`86`		`-`
	`86`	`+`
`87`	`87`	`visitor_image_copy_so(double offset, double scaling)`
`88`	`88`	`: offset_(offset), scaling_(scaling) {}`
`89`	`89`
`90`		`- T0 operator() (image_null const&)`
	`90`	`+ T0 operator() (image_null const&)`
`91`	`91`	`{`
`92`	`92`	`throw std::runtime_error("Can not cast a null image");`
`93`	`93`	`}`
`@@ -101,12 +101,12 @@ struct visitor_image_copy_so`
`101`	`101`	`else`
`102`	`102`	`{`
`103`	`103`	`T0 dst(src);`
`104`		`- dst.set_scaling(scaling_);`
`105`		`- dst.set_offset(offset_);`
	`104`	`+ dst.set_scaling(scaling_);`
	`105`	`+ dst.set_offset(offset_);`
`106`	`106`	`return T0(std::move(dst));`
`107`	`107`	`}`
`108`	`108`	`}`
`109`		`-`
	`109`	`+`
`110`	`110`	`template <typename T1>`
`111`	`111`	`T0 operator() (T1 const& src)`
`112`	`112`	`{`
`@@ -129,7 +129,7 @@ struct visitor_image_copy_so`
`129`	`129`	`{`
`130`	`130`	`dst(x,y) = std::numeric_limits<dst_type>::min();`
`131`	`131`	`}`
`132`		`- catch(positive_overflow&)`
	`132`	`+ catch(positive_overflow&)`
`133`	`133`	`{`
`134`	`134`	`dst(x,y) = std::numeric_limits<dst_type>::max();`
`135`	`135`	`}`
`@@ -327,27 +327,27 @@ MAPNIK_DECL image_any image_copy(image_any const& data, image_dtype type, double`
`327`	`327`	`switch (type)`
`328`	`328`	`{`
`329`	`329`	`case image_dtype_rgba8:`
`330`		`- return image_any(std::move(image_copy<image_rgba8>(data, offset, scaling)));`
	`330`	`+ return image_any(image_copy<image_rgba8>(data, offset, scaling));`
`331`	`331`	`case image_dtype_gray8:`
`332`		`- return image_any(std::move(image_copy<image_gray8>(data, offset, scaling)));`
	`332`	`+ return image_any(image_copy<image_gray8>(data, offset, scaling));`
`333`	`333`	`case image_dtype_gray8s:`
`334`		`- return image_any(std::move(image_copy<image_gray8s>(data, offset, scaling)));`
	`334`	`+ return image_any(image_copy<image_gray8s>(data, offset, scaling));`
`335`	`335`	`case image_dtype_gray16:`
`336`		`- return image_any(std::move(image_copy<image_gray16>(data, offset, scaling)));`
	`336`	`+ return image_any(image_copy<image_gray16>(data, offset, scaling));`
`337`	`337`	`case image_dtype_gray16s:`
`338`		`- return image_any(std::move(image_copy<image_gray16s>(data, offset, scaling)));`
	`338`	`+ return image_any(image_copy<image_gray16s>(data, offset, scaling));`
`339`	`339`	`case image_dtype_gray32:`
`340`		`- return image_any(std::move(image_copy<image_gray32>(data, offset, scaling)));`
	`340`	`+ return image_any(image_copy<image_gray32>(data, offset, scaling));`
`341`	`341`	`case image_dtype_gray32s:`
`342`		`- return image_any(std::move(image_copy<image_gray32s>(data, offset, scaling)));`
	`342`	`+ return image_any(image_copy<image_gray32s>(data, offset, scaling));`
`343`	`343`	`case image_dtype_gray32f:`
`344`		`- return image_any(std::move(image_copy<image_gray32f>(data, offset, scaling)));`
	`344`	`+ return image_any(image_copy<image_gray32f>(data, offset, scaling));`
`345`	`345`	`case image_dtype_gray64:`
`346`		`- return image_any(std::move(image_copy<image_gray64>(data, offset, scaling)));`
	`346`	`+ return image_any(image_copy<image_gray64>(data, offset, scaling));`
`347`	`347`	`case image_dtype_gray64s:`
`348`		`- return image_any(std::move(image_copy<image_gray64s>(data, offset, scaling)));`
	`348`	`+ return image_any(image_copy<image_gray64s>(data, offset, scaling));`
`349`	`349`	`case image_dtype_gray64f:`
`350`		`- return image_any(std::move(image_copy<image_gray64f>(data, offset, scaling)));`
	`350`	`+ return image_any(image_copy<image_gray64f>(data, offset, scaling));`
`351`	`351`	`case image_dtype_null:`
`352`	`352`	`throw std::runtime_error("Can not cast a null image");`
`353`	`353`	`case IMAGE_DTYPE_MAX:`
Original file line number	Diff line number	Diff line change
`@@ -309,7 +309,7 @@ bool Map::load_fonts()`
`309`	`309`	`mapnik::util::file file(file_path);`
`310`	`310`	`if (file.open())`
`311`	`311`	`{`
`312`		`- auto item = font_memory_cache_.emplace(file_path, std::make_pair(std::move(file.data()),file.size()));`
	`312`	`+ auto item = font_memory_cache_.emplace(file_path, std::make_pair(file.data(),file.size()));`
`313`	`313`	`if (item.second) result = true;`
`314`	`314`	`}`
`315`	`315`	`}`
Original file line number	Diff line number	Diff line change
`@@ -90,14 +90,14 @@ struct split_multi_geometries`
`90`	`90`	`{`
`91`	`91`	`for ( auto const& pt : multi_pt )`
`92`	`92`	`{`
`93`		`- cont_.push_back(std::move(base_symbolizer_helper::geometry_cref(std::cref(pt))));`
	`93`	`+ cont_.push_back(base_symbolizer_helper::geometry_cref(std::cref(pt)));`
`94`	`94`	`}`
`95`	`95`	`}`
`96`	`96`	`void operator() (geometry::multi_line_string<double> const& multi_line) const`
`97`	`97`	`{`
`98`	`98`	`for ( auto const& line : multi_line )`
`99`	`99`	`{`
`100`		`- cont_.push_back(std::move(base_symbolizer_helper::geometry_cref(std::cref(line))));`
	`100`	`+ cont_.push_back(base_symbolizer_helper::geometry_cref(std::cref(line)));`
`101`	`101`	`}`
`102`	`102`	`}`
`103`	`103`
`@@ -108,12 +108,12 @@ struct split_multi_geometries`
`108`	`108`	`box2d<double> bbox = t_.forward(geometry::envelope(poly), prj_trans_);`
`109`	`109`	`if (bbox.width() >= minimum_path_length_)`
`110`	`110`	`{`
`111`		`- cont_.push_back(std::move(base_symbolizer_helper::geometry_cref(std::cref(poly))));`
	`111`	`+ cont_.push_back(base_symbolizer_helper::geometry_cref(std::cref(poly)));`
`112`	`112`	`}`
`113`	`113`	`}`
`114`	`114`	`else`
`115`	`115`	`{`
`116`		`- cont_.push_back(std::move(base_symbolizer_helper::geometry_cref(std::cref(poly))));`
	`116`	`+ cont_.push_back(base_symbolizer_helper::geometry_cref(std::cref(poly)));`
`117`	`117`	`}`
`118`	`118`	`}`
`119`	`119`
`@@ -136,7 +136,7 @@ struct split_multi_geometries`
`136`	`136`	`template <typename Geometry>`
`137`	`137`	`void operator() (Geometry const& geom) const`
`138`	`138`	`{`
`139`		`- cont_.push_back(std::move(base_symbolizer_helper::geometry_cref(std::cref(geom))));`
	`139`	`+ cont_.push_back(base_symbolizer_helper::geometry_cref(std::cref(geom)));`
`140`	`140`	`}`
`141`	`141`
`142`	`142`	`container_type & cont_;`