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

fix a slew of -Wsign-conversion, -Wconversion, -Wunused-argument warnings

Browse source
This commit is contained in:
Dane Springmeyer 2015-06-15 19:36:36 -07:00
parent 48d4bfb170
commit b2c85e0c65
87 changed files with 352 additions and 235 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

8
include/mapnik/attribute_collector.hpp
View file

@ -43,6 +43,8 @@
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wunused-local-typedef"
#pragma GCC diagnostic ignored "-Wshadow"
#pragma GCC diagnostic ignored "-Wsign-conversion"
#pragma GCC diagnostic ignored "-Wconversion"
#include <boost/algorithm/string/replace.hpp>
#pragma GCC diagnostic pop
@ -275,8 +277,8 @@ inline void group_attribute_collector::operator() (group_symbolizer const& sym)
}
// get indexed column names
int start = get<value_integer>(sym, keys::start_column);
int end = start + get<value_integer>(sym, keys::num_columns);
value_integer start = get<value_integer>(sym, keys::start_column);
value_integer end = start + get<value_integer>(sym, keys::num_columns);
for (auto const& col_name : group_columns)
{
if (expand_index_columns_ && col_name.find('%') != std::string::npos)
@ -287,7 +289,7 @@ inline void group_attribute_collector::operator() (group_symbolizer const& sym)
if (col_name.size() > 1)
{
// Indexed column name. add column name for each index value.
for (int col_idx = start; col_idx < end; ++col_idx)
for (value_integer col_idx = start; col_idx < end; ++col_idx)
{
std::string col_idx_str;
if (mapnik::util::to_string(col_idx_str,col_idx))

4
include/mapnik/cairo/cairo_context.hpp
View file

@ -124,12 +124,12 @@ class cairo_pattern : private util::noncopyable
public:
explicit cairo_pattern(image_rgba8 const& data, double opacity = 1.0)
{
int pixels = data.width() * data.height();
std::size_t pixels = data.width() * data.height();
const unsigned int *in_ptr = data.data();
const unsigned int *in_end = in_ptr + pixels;
unsigned int *out_ptr;
surface_ = cairo_image_surface_create(CAIRO_FORMAT_ARGB32, data.width(), data.height());
surface_ = cairo_image_surface_create(CAIRO_FORMAT_ARGB32, static_cast<int>(data.width()), static_cast<int>(data.height()));
out_ptr = reinterpret_cast<unsigned int *>(cairo_image_surface_get_data(surface_));

8
include/mapnik/css_color_grammar.hpp
View file

@ -49,10 +49,10 @@
BOOST_FUSION_ADAPT_ADT(
mapnik::color,
(unsigned, unsigned, obj.red(), obj.set_red(val))
(unsigned, unsigned, obj.green(), obj.set_green(val))
(unsigned, unsigned, obj.blue(), obj.set_blue(val))
(unsigned, unsigned, obj.alpha(), obj.set_alpha(val))
(unsigned, unsigned, obj.red(), obj.set_red(mapnik::safe_cast<uint8_t>(val)))
(unsigned, unsigned, obj.green(), obj.set_green(mapnik::safe_cast<uint8_t>(val)))
(unsigned, unsigned, obj.blue(), obj.set_blue(mapnik::safe_cast<uint8_t>(val)))
(unsigned, unsigned, obj.alpha(), obj.set_alpha(mapnik::safe_cast<uint8_t>(val)))
)
namespace mapnik

2
include/mapnik/expression_grammar.hpp
View file

@ -35,6 +35,8 @@
#pragma GCC diagnostic ignored "-Wunused-parameter"
#pragma GCC diagnostic ignored "-Wunused-local-typedef"
#pragma GCC diagnostic ignored "-Wshadow"
#pragma GCC diagnostic ignored "-Wsign-conversion"
#pragma GCC diagnostic ignored "-Wconversion"
#include <boost/spirit/include/qi.hpp>
#include <boost/spirit/include/support_locals.hpp>
#include <boost/spirit/include/phoenix_function.hpp>

3
include/mapnik/geometry_adapters.hpp
View file

@ -29,6 +29,9 @@
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wunused-local-typedef"
#pragma GCC diagnostic ignored "-Wshadow"
#pragma GCC diagnostic ignored "-Wsign-conversion"
#pragma GCC diagnostic ignored "-Wconversion"
#pragma GCC diagnostic ignored "-Wunused-parameter"
#undef B0
#include <boost/geometry/geometries/register/linestring.hpp>
#include <boost/geometry/geometries/register/point.hpp>

2
include/mapnik/geometry_centroid.hpp
View file

@ -50,7 +50,7 @@ struct geometry_centroid
return false;
}
result_type operator() (geometry_collection<T> const& collection) const
result_type operator() (geometry_collection<T> const&) const
{
return false;
}

4
include/mapnik/geometry_correct.hpp
View file

@ -32,6 +32,8 @@
#pragma GCC diagnostic ignored "-Wunused-variable"
#pragma GCC diagnostic ignored "-Wunused-local-typedef"
#pragma GCC diagnostic ignored "-Wshadow"
#pragma GCC diagnostic ignored "-Wsign-conversion"
#pragma GCC diagnostic ignored "-Wconversion"
#include <boost/geometry/algorithms/correct.hpp>
#pragma GCC diagnostic pop
@ -73,7 +75,7 @@ struct geometry_correct
}
template <typename T>
result_type operator() (T & geom) const
result_type operator() (T &) const
{
//no-op
}

2
include/mapnik/geometry_reprojection_impl.hpp
View file

@ -195,7 +195,7 @@ struct geom_reproj_copy_visitor {
geometry<T> operator() (line_string<T> const& ls)
{
geometry<T> geom; // default empty
int intial_err = n_err_;
unsigned int intial_err = n_err_;
line_string<T> new_ls = reproject_internal(ls, proj_trans_, n_err_);
if (n_err_ > intial_err || new_ls.empty()) return geom;
geom = std::move(new_ls);

9
include/mapnik/grid/grid.hpp
View file

@ -33,6 +33,7 @@
#include <mapnik/feature.hpp>
#include <mapnik/feature_factory.hpp>
#include <mapnik/util/conversions.hpp>
#include <mapnik/safe_cast.hpp>
// stl
#include <map>
@ -191,12 +192,16 @@ public:
if (ext0.intersects(ext1))
{
box2d<int> box = ext0.intersect(ext1);
for (std::size_t y = box.miny(); y < box.maxy(); ++y)
std::size_t miny = safe_cast<std::size_t>(box.miny());
std::size_t maxy = safe_cast<std::size_t>(box.maxy());
std::size_t minx = safe_cast<std::size_t>(box.minx());
std::size_t maxx = safe_cast<std::size_t>(box.maxx());
for (std::size_t y = miny; y < maxy; ++y)
{
value_type* row_to = data_.get_row(y);
image_rgba8::pixel_type const * row_from = data.get_row(y - y0);
for (std::size_t x = box.minx(); x < box.maxx(); ++x)
for (std::size_t x = minx; x < maxx; ++x)
{
image_rgba8::pixel_type rgba = row_from[x - x0];
unsigned a = (rgba >> 24) & 0xff;

8
include/mapnik/grid/grid_pixfmt.hpp
View file

@ -24,9 +24,15 @@
#define MAPNIK_GRID_PIXFMT_HPP
#include <string>
#include <mapnik/grid/grid_rendering_buffer.hpp>
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wunused-parameter"
#pragma GCC diagnostic ignored "-Wsign-conversion"
#pragma GCC diagnostic ignored "-Wconversion"
#include "agg_basics.h"
#include <mapnik/grid/grid_pixel.hpp>
#include <mapnik/grid/grid_rendering_buffer.hpp>
#pragma GCC diagnostic pop
namespace mapnik
{

7
include/mapnik/grid/grid_renderer_base.hpp
View file

@ -23,9 +23,14 @@
#ifndef MAPNIK_GRID_RENDERER_BASE_HPP
#define MAPNIK_GRID_RENDERER_BASE_HPP
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wunused-parameter"
#pragma GCC diagnostic ignored "-Wsign-conversion"
#pragma GCC diagnostic ignored "-Wconversion"
#include "agg_renderer_base.h"
#include <mapnik/grid/grid_pixfmt.hpp>
#include <mapnik/grid/grid_pixel.hpp>
#pragma GCC diagnostic pop
#include <mapnik/grid/grid_pixfmt.hpp>
namespace mapnik {

80
include/mapnik/image_filter.hpp
View file

@ -34,6 +34,8 @@
#pragma GCC diagnostic ignored "-Wc++11-narrowing"
#pragma GCC diagnostic ignored "-Wunused-local-typedef"
#pragma GCC diagnostic ignored "-Wshadow"
#pragma GCC diagnostic ignored "-Wsign-conversion"
#pragma GCC diagnostic ignored "-Wconversion"
#include <boost/gil/gil_all.hpp>
#pragma GCC diagnostic pop
@ -252,10 +254,10 @@ void apply_convolution_3x3(Src const& src_view, Dst & dst_view, Filter const& fi
typename Src::x_iterator dst_it = dst_view.row_begin(0);
// top row
for (int x = 0 ; x < src_view.width(); ++x)
for (std::size_t x = 0 ; x < static_cast<std::size_t>(src_view.width()); ++x)
{
(*dst_it)[3] = src_loc[loc11][3]; // Dst.a = Src.a
for (int i = 0; i < 3; ++i)
for (std::size_t i = 0; i < 3; ++i)
{
bits32f p[9];
@ -273,7 +275,7 @@ void apply_convolution_3x3(Src const& src_view, Dst & dst_view, Filter const& fi
p[6] = src_loc[loc02][i];
}
if ( x == src_view.width()-1)
if ( x == static_cast<std::size_t>(src_view.width())-1)
{
p[5] = p[4];
p[8] = p[7];
@ -294,15 +296,15 @@ void apply_convolution_3x3(Src const& src_view, Dst & dst_view, Filter const& fi
++dst_it;
}
// carrige-return
src_loc += point2<std::ptrdiff_t>(-src_view.width(),1);
src_loc += point2<std::ptrdiff_t>(-static_cast<std::size_t>(src_view.width()),1);
// 1... height-1 rows
for (int y = 1; y<src_view.height()-1; ++y)
for (std::size_t y = 1; y<static_cast<std::size_t>(src_view.height())-1; ++y)
{
for (int x = 0; x < src_view.width(); ++x)
for (std::size_t x = 0; x < static_cast<std::size_t>(src_view.width()); ++x)
{
(*dst_it)[3] = src_loc[loc11][3]; // Dst.a = Src.a
for (int i = 0; i < 3; ++i)
for (std::size_t i = 0; i < 3; ++i)
{
bits32f p[9];
@ -323,7 +325,7 @@ void apply_convolution_3x3(Src const& src_view, Dst & dst_view, Filter const& fi
p[6] = src_loc[loc02][i];
}
if ( x == src_view.width() - 1)
if ( x == static_cast<std::size_t>(src_view.width()) - 1)
{
p[2] = p[1];
p[5] = p[4];
@ -341,15 +343,15 @@ void apply_convolution_3x3(Src const& src_view, Dst & dst_view, Filter const& fi
++src_loc.x();
}
// carrige-return
src_loc += point2<std::ptrdiff_t>(-src_view.width(),1);
src_loc += point2<std::ptrdiff_t>(-static_cast<std::size_t>(src_view.width()),1);
}
// bottom row
//src_loc = src_view.xy_at(0,src_view.height()-1);
for (int x = 0 ; x < src_view.width(); ++x)
//src_loc = src_view.xy_at(0,static_cast<std::size_t>(src_view.height())-1);
for (std::size_t x = 0 ; x < static_cast<std::size_t>(src_view.width()); ++x)
{
(*dst_it)[3] = src_loc[loc11][3]; // Dst.a = Src.a
for (int i = 0; i < 3; ++i)
for (std::size_t i = 0; i < 3; ++i)
{
bits32f p[9];
@ -367,7 +369,7 @@ void apply_convolution_3x3(Src const& src_view, Dst & dst_view, Filter const& fi
p[3] = src_loc[loc01][i];
}
if ( x == src_view.width()-1)
if ( x == static_cast<std::size_t>(src_view.width())-1)
{
p[2] = p[1];
p[5] = p[4];
@ -429,10 +431,10 @@ void apply_filter(Src & src, color_to_alpha const& op)
double cr = static_cast<double>(op.color.red())/255.0;
double cg = static_cast<double>(op.color.green())/255.0;
double cb = static_cast<double>(op.color.blue())/255.0;
for (int y=0; y<src_view.height(); ++y)
for (std::size_t y=0; y<static_cast<std::size_t>(src_view.height()); ++y)
{
rgba8_view_t::x_iterator src_it = src_view.row_begin(y);
for (int x=0; x<src_view.width(); ++x)
rgba8_view_t::x_iterator src_it = src_view.row_begin(static_cast<long>(y));
for (std::size_t x=0; x<static_cast<std::size_t>(src_view.width()); ++x)
{
uint8_t & r = get_color(src_it[x], red_t());
uint8_t & g = get_color(src_it[x], green_t());
@ -490,10 +492,10 @@ void apply_filter(Src & src, colorize_alpha const& op)
mapnik::filter::color_stop const& stop = op[0];
mapnik::color const& c = stop.color;
rgba8_view_t src_view = rgba8_view(src);
for (int y=0; y<src_view.height(); ++y)
for (std::size_t y=0; y<static_cast<std::size_t>(src_view.height()); ++y)
{
rgba8_view_t::x_iterator src_it = src_view.row_begin(y);
for (int x=0; x<src_view.width(); ++x)
rgba8_view_t::x_iterator src_it = src_view.row_begin(static_cast<long>(y));
for (std::size_t x=0; x<static_cast<std::size_t>(src_view.width()); ++x)
{
uint8_t & r = get_color(src_it[x], red_t());
uint8_t & g = get_color(src_it[x], green_t());
@ -531,10 +533,10 @@ void apply_filter(Src & src, colorize_alpha const& op)
if (grad_lut.build_lut())
{
rgba8_view_t src_view = rgba8_view(src);
for (int y=0; y<src_view.height(); ++y)
for (std::size_t y=0; y<static_cast<std::size_t>(src_view.height()); ++y)
{
rgba8_view_t::x_iterator src_it = src_view.row_begin(y);
for (int x=0; x<src_view.width(); ++x)
rgba8_view_t::x_iterator src_it = src_view.row_begin(static_cast<long>(y));
for (std::size_t x=0; x<static_cast<std::size_t>(src_view.width()); ++x)
{
uint8_t & r = get_color(src_it[x], red_t());
uint8_t & g = get_color(src_it[x], green_t());
@ -596,10 +598,10 @@ void apply_filter(Src & src, scale_hsla const& transform)
if (tinting || set_alpha)
{
rgba8_view_t src_view = rgba8_view(src);
for (int y=0; y<src_view.height(); ++y)
for (std::size_t y=0; y<static_cast<std::size_t>(src_view.height()); ++y)
{
rgba8_view_t::x_iterator src_it = src_view.row_begin(y);
for (int x=0; x<src_view.width(); ++x)
rgba8_view_t::x_iterator src_it = src_view.row_begin(static_cast<long>(y));
for (std::size_t x=0; x<static_cast<std::size_t>(src_view.width()); ++x)
{
uint8_t & r = get_color(src_it[x], red_t());
uint8_t & g = get_color(src_it[x], green_t());
@ -679,10 +681,10 @@ void apply_filter(Src & src, gray const& /*op*/)
rgba8_view_t src_view = rgba8_view(src);
for (int y=0; y<src_view.height(); ++y)
for (std::size_t y=0; y<static_cast<std::size_t>(src_view.height()); ++y)
{
rgba8_view_t::x_iterator src_it = src_view.row_begin(y);
for (int x=0; x<src_view.width(); ++x)
rgba8_view_t::x_iterator src_it = src_view.row_begin(static_cast<long>(y));
for (std::size_t x=0; x<static_cast<std::size_t>(src_view.width()); ++x)
{
// formula taken from boost/gil/color_convert.hpp:rgb_to_luminance
uint8_t & r = get_color(src_it[x], red_t());
@ -697,22 +699,22 @@ void apply_filter(Src & src, gray const& /*op*/)
template <typename Src, typename Dst>
void x_gradient_impl(Src const& src_view, Dst const& dst_view)
{
for (int y=0; y<src_view.height(); ++y)
for (std::size_t y=0; y<static_cast<std::size_t>(src_view.height()); ++y)
{
typename Src::x_iterator src_it = src_view.row_begin(y);
typename Dst::x_iterator dst_it = dst_view.row_begin(y);
typename Src::x_iterator src_it = src_view.row_begin(static_cast<long>(y));
typename Dst::x_iterator dst_it = dst_view.row_begin(static_cast<long>(y));
dst_it[0][0] = 128 + (src_it[0][0] - src_it[1][0]) / 2;
dst_it[0][1] = 128 + (src_it[0][1] - src_it[1][1]) / 2;
dst_it[0][2] = 128 + (src_it[0][2] - src_it[1][2]) / 2;
dst_it[dst_view.width()-1][0] = 128 + (src_it[src_view.width()-2][0] - src_it[src_view.width()-1][0]) / 2;
dst_it[dst_view.width()-1][1] = 128 + (src_it[src_view.width()-2][1] - src_it[src_view.width()-1][1]) / 2;
dst_it[dst_view.width()-1][2] = 128 + (src_it[src_view.width()-2][2] - src_it[src_view.width()-1][2]) / 2;
dst_it[dst_view.width()-1][0] = 128 + (src_it[static_cast<std::size_t>(src_view.width())-2][0] - src_it[static_cast<std::size_t>(src_view.width())-1][0]) / 2;
dst_it[dst_view.width()-1][1] = 128 + (src_it[static_cast<std::size_t>(src_view.width())-2][1] - src_it[static_cast<std::size_t>(src_view.width())-1][1]) / 2;
dst_it[dst_view.width()-1][2] = 128 + (src_it[static_cast<std::size_t>(src_view.width())-2][2] - src_it[static_cast<std::size_t>(src_view.width())-1][2]) / 2;
dst_it[0][3] = dst_it[src_view.width()-1][3] = 255;
dst_it[0][3] = dst_it[static_cast<std::size_t>(src_view.width())-1][3] = 255;
for (int x=1; x<src_view.width()-1; ++x)
for (std::size_t x=1; x<static_cast<std::size_t>(src_view.width())-1; ++x)
{
dst_it[x][0] = 128 + (src_it[x-1][0] - src_it[x+1][0]) / 2;
dst_it[x][1] = 128 + (src_it[x-1][1] - src_it[x+1][1]) / 2;
@ -744,10 +746,10 @@ void apply_filter(Src & src, invert const& /*op*/)
rgba8_view_t src_view = rgba8_view(src);
for (int y=0; y<src_view.height(); ++y)
for (std::size_t y=0; y<static_cast<std::size_t>(src_view.height()); ++y)
{
rgba8_view_t::x_iterator src_it = src_view.row_begin(y);
for (int x=0; x<src_view.width(); ++x)
rgba8_view_t::x_iterator src_it = src_view.row_begin(static_cast<long>(y));
for (std::size_t x=0; x<static_cast<std::size_t>(src_view.width()); ++x)
{
// we only work with premultiplied source,
// thus all color values must be <= alpha

2
include/mapnik/image_filter_grammar.hpp
View file

@ -28,6 +28,8 @@
#pragma GCC diagnostic ignored "-Wunused-parameter"
#pragma GCC diagnostic ignored "-Wunused-local-typedef"
#pragma GCC diagnostic ignored "-Wshadow"
#pragma GCC diagnostic ignored "-Wsign-conversion"
#pragma GCC diagnostic ignored "-Wconversion"
#include <boost/spirit/include/qi.hpp>
#include <boost/fusion/include/adapt_struct.hpp>
#pragma GCC diagnostic pop

3
include/mapnik/image_filter_grammar_impl.hpp
View file

@ -25,7 +25,10 @@
#include <mapnik/image_filter_grammar.hpp>
// spirit
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wsign-conversion"
#include <boost/spirit/include/phoenix.hpp>
#pragma GCC diagnostic pop
namespace mapnik {

34
include/mapnik/image_null.hpp
View file

@ -42,34 +42,34 @@ public:
private:
public:
image() {}
image(int width,
int height,
bool initialize = true,
bool premultiplied = false,
bool painted = false) {}
image(image<null_t> const& rhs) {}
image(image<null_t> && rhs) noexcept {}
image<null_t>& operator=(image<null_t> rhs) { return *this; }
image(int /*width*/,
int /*height*/,
bool /*initialize*/ = true,
bool /*premultiplied*/ = false,
bool /*painted*/ = false) {}
image(image<null_t> const&) {}
image(image<null_t> &&) noexcept {}
image<null_t>& operator=(image<null_t>) { return *this; }
image<null_t>const& operator=(image<null_t> const& rhs) const { return rhs; }
bool operator==(image<null_t> const& rhs) const { return true; }
bool operator<(image<null_t> const& rhs) const { return false; }
bool operator==(image<null_t> const&) const { return true; }
bool operator<(image<null_t> const&) const { return false; }
std::size_t width() const { return 0; }
std::size_t height() const { return 0; }
std::size_t size() const { return 0; }
std::size_t row_size() const { return 0; }
void set(pixel_type const& t) { throw std::runtime_error("Can not set values for null image"); }
pixel_type& operator() (std::size_t i, std::size_t j) { throw std::runtime_error("Can not get or set values for null image"); }
pixel_type const& operator() (std::size_t i, std::size_t j) const { throw std::runtime_error("Can not get or set values for null image"); }
void set(pixel_type const&) { throw std::runtime_error("Can not set values for null image"); }
pixel_type& operator() (std::size_t, std::size_t) { throw std::runtime_error("Can not get or set values for null image"); }
pixel_type const& operator() (std::size_t, std::size_t) const { throw std::runtime_error("Can not get or set values for null image"); }
unsigned const char* bytes() const { return nullptr; }
unsigned char* bytes() {return nullptr; }
double get_offset() const { return 0.0; }
void set_offset(double set) {}
void set_offset(double) {}
double get_scaling() const { return 1.0; }
void set_scaling(double set) {}
void set_scaling(double) {}
bool get_premultiplied() const { return false; }
void set_premultiplied(bool set) {}
void painted(bool painted) {}
void set_premultiplied(bool) {}
void painted(bool) {}
bool painted() const { return false; }
image_dtype get_dtype() const { return dtype; }
};

14
include/mapnik/image_view_null.hpp
View file

@ -40,20 +40,20 @@ public:
image_view() {}
~image_view() {};
image_view(image_view<image_null> const& rhs) {}
image_view<image_null> & operator=(image_view<image_null> const& rhs) { return *this; }
bool operator==(image_view<image_null> const& rhs) const { return true; }
bool operator<(image_view<image_null> const& rhs) const { return false; }
image_view(image_view<image_null> const&) {}
image_view<image_null> & operator=(image_view<image_null> const&) { return *this; }
bool operator==(image_view<image_null> const&) const { return true; }
bool operator<(image_view<image_null> const&) const { return false; }
std::size_t x() const { return 0; }
std::size_t y() const { return 0; }
std::size_t width() const { return 0; }
std::size_t height() const { return 0; }
pixel_type operator() (std::size_t i, std::size_t j) const { throw std::runtime_error("Can not get from a null image view"); }
pixel_type operator() (std::size_t, std::size_t) const { throw std::runtime_error("Can not get from a null image view"); }
std::size_t size() const { return 0; }
std::size_t row_size() const { return 0; }
const pixel_type* get_row(std::size_t row) const { return nullptr; }
const pixel_type* get_row(std::size_t row, std::size_t x0) const { return nullptr; }
const pixel_type* get_row(std::size_t) const { return nullptr; }
const pixel_type* get_row(std::size_t, std::size_t) const { return nullptr; }
bool get_premultiplied() const { return false; }
double get_offset() const { return 0.0; }
double get_scaling() const { return 1.0; }

3
include/mapnik/json/error_handler.hpp
View file

@ -25,7 +25,10 @@
#include <string>
#include <sstream>
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wsign-conversion"
#include <boost/spirit/home/support/info.hpp>
#pragma GCC diagnostic pop
namespace mapnik { namespace json {

2
include/mapnik/json/extract_bounding_box_grammar.hpp
View file

@ -33,6 +33,8 @@
#pragma GCC diagnostic ignored "-Wunused-parameter"
#pragma GCC diagnostic ignored "-Wunused-local-typedef"
#pragma GCC diagnostic ignored "-Wshadow"
#pragma GCC diagnostic ignored "-Wsign-conversion"
#pragma GCC diagnostic ignored "-Wconversion"
#include <boost/spirit/include/qi.hpp>
#include <boost/spirit/include/phoenix_function.hpp>
#include <boost/fusion/adapted/std_tuple.hpp>

4
include/mapnik/json/feature_generator_grammar.hpp
View file

@ -84,8 +84,8 @@ template <typename T>
struct get_id
{
using feature_type = T;
using result_type = int;
int operator() (feature_type const& f) const
using result_type = mapnik::value_integer;
result_type operator() (feature_type const& f) const
{
return f.id();
}

5
include/mapnik/json/feature_grammar.hpp
View file

@ -31,10 +31,13 @@
#include <mapnik/value.hpp>
#include <mapnik/json/generic_json.hpp>
#include <mapnik/json/value_converters.hpp>
// spirit::qi
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wsign-conversion"
#include <boost/spirit/include/qi.hpp>
#include <boost/spirit/include/phoenix.hpp>
#include <boost/spirit/include/support_line_pos_iterator.hpp>
#pragma GCC diagnostic pop
namespace mapnik { namespace json {

2
include/mapnik/json/generic_json.hpp
View file

@ -31,6 +31,8 @@
#pragma GCC diagnostic ignored "-Wunused-parameter"
#pragma GCC diagnostic ignored "-Wunused-local-typedef"
#pragma GCC diagnostic ignored "-Wshadow"
#pragma GCC diagnostic ignored "-Wsign-conversion"
#pragma GCC diagnostic ignored "-Wconversion"
#include <boost/spirit/include/qi.hpp>
#include <boost/spirit/include/phoenix.hpp>
#pragma GCC diagnostic pop

2
include/mapnik/json/geometry_generator_grammar.hpp
View file

@ -33,6 +33,8 @@
#pragma GCC diagnostic ignored "-Wunused-parameter"
#pragma GCC diagnostic ignored "-Wunused-local-typedef"
#pragma GCC diagnostic ignored "-Wshadow"
#pragma GCC diagnostic ignored "-Wsign-conversion"
#pragma GCC diagnostic ignored "-Wconversion"
#include <boost/spirit/include/karma.hpp>
#include <boost/spirit/include/phoenix_function.hpp>
#include <boost/math/special_functions/trunc.hpp> // for vc++ and android whose c++11 libs lack std::trunc

2
include/mapnik/json/positions_grammar.hpp
View file

@ -34,6 +34,8 @@
#pragma GCC diagnostic ignored "-Wunused-parameter"
#pragma GCC diagnostic ignored "-Wunused-local-typedef"
#pragma GCC diagnostic ignored "-Wshadow"
#pragma GCC diagnostic ignored "-Wsign-conversion"
#pragma GCC diagnostic ignored "-Wconversion"
#include <boost/spirit/include/qi.hpp>
#include <boost/spirit/include/phoenix_function.hpp>
#include <boost/fusion/adapted/std_tuple.hpp>

2
include/mapnik/json/properties_generator_grammar.hpp
View file

@ -32,6 +32,8 @@
#pragma GCC diagnostic ignored "-Wunused-parameter"
#pragma GCC diagnostic ignored "-Wunused-local-typedef"
#pragma GCC diagnostic ignored "-Wshadow"
#pragma GCC diagnostic ignored "-Wsign-conversion"
#pragma GCC diagnostic ignored "-Wconversion"
#include <boost/spirit/include/karma.hpp>
#include <boost/spirit/include/phoenix.hpp>
#include <boost/spirit/include/phoenix_function.hpp>

2
include/mapnik/json/topojson_grammar.hpp
View file

@ -34,6 +34,8 @@
#pragma GCC diagnostic ignored "-Wunused-parameter"
#pragma GCC diagnostic ignored "-Wunused-local-typedef"
#pragma GCC diagnostic ignored "-Wshadow"
#pragma GCC diagnostic ignored "-Wsign-conversion"
#pragma GCC diagnostic ignored "-Wconversion"
#include <boost/spirit/include/qi.hpp>
#include <boost/spirit/include/phoenix_function.hpp>
#pragma GCC diagnostic pop

18
include/mapnik/marker.hpp
View file

@ -70,19 +70,19 @@ public:
box2d<double> bounding_box() const
{
double width = bitmap_data_.width();
double height = bitmap_data_.height();
return box2d<double>(0, 0, width, height);
std::size_t width = bitmap_data_.width();
std::size_t height = bitmap_data_.height();
return box2d<double>(static_cast<double>(0), static_cast<double>(0), static_cast<double>(width), static_cast<double>(height));
}
inline std::size_t width() const
inline double width() const
{
return bitmap_data_.width();
return static_cast<double>(bitmap_data_.width());
}
inline std::size_t height() const
inline double height() const
{
return bitmap_data_.height();
return static_cast<double>(bitmap_data_.height());
}
image_rgba8 const& get_data() const
@ -169,7 +169,7 @@ struct get_marker_width_visitor
template <typename T>
double operator()(T const& data) const
{
return static_cast<double>(data.width());
return data.width();
}
};
@ -178,7 +178,7 @@ struct get_marker_height_visitor
template <typename T>
double operator()(T const& data) const
{
return static_cast<double>(data.height());
return data.height();
}
};

3
include/mapnik/palette.hpp
View file

@ -30,6 +30,8 @@
#define USE_DENSE_HASH_MAP
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wsign-conversion"
#ifdef USE_DENSE_HASH_MAP
#include <mapnik/sparsehash/dense_hash_map>
using rgba_hash_table = google::dense_hash_map<unsigned int, unsigned char>;
@ -37,6 +39,7 @@
#include <boost/unordered_map.hpp>
using rgba_hash_table = boost::unordered_map<unsigned int, unsigned char>;
#endif
#pragma GCC diagnostic pop
// stl
#include <vector>

2
include/mapnik/params_impl.hpp
View file

@ -34,6 +34,8 @@
#pragma GCC diagnostic ignored "-Wunused-parameter"
#pragma GCC diagnostic ignored "-Wunused-local-typedef"
#pragma GCC diagnostic ignored "-Wshadow"
#pragma GCC diagnostic ignored "-Wsign-conversion"
#pragma GCC diagnostic ignored "-Wconversion"
#include <boost/optional.hpp>
#include <boost/lexical_cast.hpp>
#pragma GCC diagnostic pop

2
include/mapnik/path.hpp
View file

@ -124,7 +124,7 @@ struct vertex_adapter : private util::noncopyable
unsigned vertex(double* x, double* y) const
{
return path_.cont_.get_vertex(itr_++,x,y);
return path_.cont_.get_vertex(static_cast<unsigned>(itr_++),x,y);
}
unsigned vertex(std::size_t index, double* x, double* y) const

2
include/mapnik/path_expression_grammar.hpp
View file

@ -31,6 +31,8 @@
#pragma GCC diagnostic ignored "-Wunused-parameter"
#pragma GCC diagnostic ignored "-Wunused-local-typedef"
#pragma GCC diagnostic ignored "-Wshadow"
#pragma GCC diagnostic ignored "-Wsign-conversion"
#pragma GCC diagnostic ignored "-Wconversion"
#include <boost/spirit/include/qi.hpp>
#pragma GCC diagnostic pop

2
include/mapnik/proj_strategy.hpp
View file

@ -32,6 +32,8 @@
#pragma GCC diagnostic ignored "-Wunused-parameter"
#pragma GCC diagnostic ignored "-Wunused-local-typedef"
#pragma GCC diagnostic ignored "-Wshadow"
#pragma GCC diagnostic ignored "-Wsign-conversion"
#pragma GCC diagnostic ignored "-Wconversion"
#include <boost/geometry/core/coordinate_type.hpp>
#include <boost/geometry/core/access.hpp>
#include <boost/numeric/conversion/cast.hpp>

2
include/mapnik/quad_tree.hpp
View file

@ -32,6 +32,8 @@
#pragma GCC diagnostic ignored "-Wunused-parameter"
#pragma GCC diagnostic ignored "-Wunused-local-typedef"
#pragma GCC diagnostic ignored "-Wshadow"
#pragma GCC diagnostic ignored "-Wsign-conversion"
#pragma GCC diagnostic ignored "-Wconversion"
#include <boost/ptr_container/ptr_vector.hpp>
#pragma GCC diagnostic pop

2
include/mapnik/renderer_common/pattern_alignment.hpp
View file

@ -51,7 +51,7 @@ struct apply_local_alignment
}
template <typename Adapter>
void operator() (Adapter & va)
void operator() (Adapter &)
{
// no-op
}

8
include/mapnik/renderer_common/process_group_symbolizer.hpp
View file

@ -280,9 +280,9 @@ void render_group_symbolizer(group_symbolizer const& sym,
// run feature or sub feature through the group rules & symbolizers
// for each index value in the range
int start = get<value_integer>(sym, keys::start_column);
int end = start + get<value_integer>(sym, keys::num_columns);
for (int col_idx = start; col_idx < end; ++col_idx)
value_integer start = get<value_integer>(sym, keys::start_column);
value_integer end = start + get<value_integer>(sym, keys::num_columns);
for (value_integer col_idx = start; col_idx < end; ++col_idx)
{
// create sub feature with indexed column values
feature_ptr sub_feature = feature_factory::create(sub_feature_ctx, col_idx);
@ -295,7 +295,7 @@ void render_group_symbolizer(group_symbolizer const& sym,
if (col_name.size() == 1)
{
// column name is '%' by itself, so give the index as the value
sub_feature->put(col_name, (value_integer)col_idx);
sub_feature->put(col_name, col_idx);
}
else
{

2
include/mapnik/sql_utils.hpp
View file

@ -31,6 +31,8 @@
#pragma GCC diagnostic ignored "-Wunused-parameter"
#pragma GCC diagnostic ignored "-Wunused-local-typedef"
#pragma GCC diagnostic ignored "-Wshadow"
#pragma GCC diagnostic ignored "-Wsign-conversion"
#pragma GCC diagnostic ignored "-Wconversion"
#include <boost/algorithm/string/replace.hpp>
#pragma GCC diagnostic pop

2
include/mapnik/svg/geometry_svg_generator.hpp
View file

@ -38,6 +38,8 @@
#pragma GCC diagnostic ignored "-Wunused-parameter"
#pragma GCC diagnostic ignored "-Wunused-local-typedef"
#pragma GCC diagnostic ignored "-Wshadow"
#pragma GCC diagnostic ignored "-Wsign-conversion"
#pragma GCC diagnostic ignored "-Wconversion"
#include <boost/spirit/include/karma.hpp>
#include <boost/spirit/include/phoenix_core.hpp>
#include <boost/spirit/include/phoenix_operator.hpp>

2
include/mapnik/svg/output/svg_output_grammars.hpp
View file

@ -41,6 +41,8 @@ namespace mapnik { namespace svg {
#pragma GCC diagnostic ignored "-Wunused-parameter"
#pragma GCC diagnostic ignored "-Wunused-local-typedef"
#pragma GCC diagnostic ignored "-Wshadow"
#pragma GCC diagnostic ignored "-Wsign-conversion"
#pragma GCC diagnostic ignored "-Wconversion"
#include <boost/spirit/include/karma_nonterminal.hpp>
#include <boost/spirit/include/karma_rule.hpp>
#include <boost/fusion/adapted/struct.hpp>

2
include/mapnik/svg/output/svg_output_grammars_impl.hpp
View file

@ -31,6 +31,8 @@
#pragma GCC diagnostic ignored "-Wunused-parameter"
#pragma GCC diagnostic ignored "-Wunused-local-typedef"
#pragma GCC diagnostic ignored "-Wshadow"
#pragma GCC diagnostic ignored "-Wsign-conversion"
#pragma GCC diagnostic ignored "-Wconversion"
#include <boost/spirit/include/karma.hpp>
#include <boost/fusion/include/std_pair.hpp>
#pragma GCC diagnostic pop

9
include/mapnik/svg/svg_converter.hpp
View file

@ -27,6 +27,7 @@
#include <mapnik/svg/svg_path_attributes.hpp>
#include <mapnik/svg/svg_path_adapter.hpp>
#include <mapnik/util/noncopyable.hpp>
#include <mapnik/safe_cast.hpp>
// agg
#include "agg_path_storage.h"
@ -57,8 +58,8 @@ public:
void begin_path()
{
unsigned idx = source_.start_new_path();
attributes_.add(path_attributes(cur_attr(), idx));
std::size_t idx = source_.start_new_path();
attributes_.add(path_attributes(cur_attr(), safe_cast<unsigned>(idx)));
}
void end_path()
@ -91,7 +92,7 @@ public:
double y2 = 0.0;
if(source_.total_vertices())
{
source_.vertex(source_.total_vertices() - 1, &x2, &y2);
source_.vertex(safe_cast<unsigned>(source_.total_vertices() - 1), &x2, &y2);
if(rel) x += x2;
source_.line_to(x, y2);
}
@ -103,7 +104,7 @@ public:
double y2 = 0.0;
if(source_.total_vertices())
{
source_.vertex(source_.total_vertices() - 1, &x2, &y2);
source_.vertex(safe_cast<unsigned>(source_.total_vertices() - 1), &x2, &y2);
if(rel) y += y2;
source_.line_to(x2, y);
}

16
include/mapnik/svg/svg_path_adapter.hpp
View file

@ -26,6 +26,8 @@
// mapnik
#include <mapnik/util/noncopyable.hpp>
#include <mapnik/box2d.hpp>
#include <mapnik/safe_cast.hpp>
// agg
#include "agg_math.h"
#include "agg_array.h"
@ -53,7 +55,7 @@ public:
// Make path functions
//--------------------------------------------------------------------
unsigned start_new_path();
std::size_t start_new_path();
void move_to(double x, double y);
void move_rel(double dx, double dy);
@ -112,7 +114,7 @@ public:
const container_type& vertices() const { return vertices_; }
container_type& vertices() { return vertices_; }
unsigned total_vertices() const;
std::size_t total_vertices() const;
void rel_to_abs(double* x, double* y) const;
@ -263,7 +265,7 @@ private:
//------------------------------------------------------------------------
template<class VC>
unsigned path_adapter<VC>::start_new_path()
std::size_t path_adapter<VC>::start_new_path()
{
if(!is_stop(vertices_.last_command()))
{
@ -547,7 +549,7 @@ inline void path_adapter<VC>::close_polygon(unsigned flags)
//------------------------------------------------------------------------
template<class VC>
inline unsigned path_adapter<VC>::total_vertices() const
inline std::size_t path_adapter<VC>::total_vertices() const
{
return vertices_.total_vertices();
}
@ -886,7 +888,7 @@ public:
{
return vertices_.size() ?
vertices_[vertices_.size() - 1].cmd :
(unsigned)path_cmd_stop;
path_cmd_stop;
}
unsigned last_vertex(double* x, double* y) const
@ -896,7 +898,7 @@ public:
*x = *y = 0.0;
return path_cmd_stop;
}
return vertex(vertices_.size() - 1, x, y);
return vertex(safe_cast<unsigned>(vertices_.size() - 1), x, y);
}
unsigned prev_vertex(double* x, double* y) const
@ -906,7 +908,7 @@ public:
*x = *y = 0.0;
return path_cmd_stop;
}
return vertex(vertices_.size() - 2, x, y);
return vertex(safe_cast<unsigned>(vertices_.size() - 2), x, y);
}
double last_x() const

2
include/mapnik/svg/svg_path_commands.hpp
View file

@ -31,6 +31,8 @@
#pragma GCC diagnostic ignored "-Wunused-parameter"
#pragma GCC diagnostic ignored "-Wunused-local-typedef"
#pragma GCC diagnostic ignored "-Wshadow"
#pragma GCC diagnostic ignored "-Wsign-conversion"
#pragma GCC diagnostic ignored "-Wconversion"
#include <boost/spirit/include/qi.hpp>
#include <boost/spirit/include/phoenix_function.hpp>
#include <boost/spirit/include/phoenix_core.hpp>

8
include/mapnik/svg/svg_renderer_agg.hpp
View file

@ -27,10 +27,16 @@
#include <mapnik/svg/svg_path_attributes.hpp>
#include <mapnik/gradient.hpp>
#include <mapnik/box2d.hpp>
#include <mapnik/value_types.hpp>
#include <mapnik/util/noncopyable.hpp>
#if defined(GRID_RENDERER)
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wunused-parameter"
#pragma GCC diagnostic ignored "-Wsign-conversion"
#pragma GCC diagnostic ignored "-Wconversion"
#include <mapnik/grid/grid_pixel.hpp>
#pragma GCC diagnostic pop
#endif
// agg
@ -341,7 +347,7 @@ public:
void render_id(Rasterizer& ras,
Scanline& sl,
Renderer& ren,
int feature_id,
mapnik::value_integer feature_id,
agg::trans_affine const& mtx,
double /*opacity*/,
box2d<double> const& /*symbol_bbox*/)

2
include/mapnik/svg/svg_transform_grammar.hpp
View file

@ -34,6 +34,8 @@
#pragma GCC diagnostic ignored "-Wunused-parameter"
#pragma GCC diagnostic ignored "-Wunused-local-typedef"
#pragma GCC diagnostic ignored "-Wshadow"
#pragma GCC diagnostic ignored "-Wsign-conversion"
#pragma GCC diagnostic ignored "-Wconversion"
#include <boost/spirit/include/qi.hpp>
#include <boost/spirit/include/phoenix_function.hpp>
#include <boost/spirit/include/phoenix_core.hpp>

2
include/mapnik/text/face.hpp
View file

@ -87,7 +87,7 @@ public:
void set_character_sizes(double size);
void set_unscaled_character_sizes();
unsigned size() const { return faces_.size(); }
std::size_t size() const { return faces_.size(); }
iterator begin() { return faces_.begin(); }
iterator end() { return faces_.end(); }
private:

2
include/mapnik/text/placements/list.hpp
View file

@ -38,7 +38,7 @@ public:
virtual void add_expressions(expression_set & output) const;
text_symbolizer_properties & add();
text_symbolizer_properties & get(unsigned i);
unsigned size() const;
std::size_t size() const;
static text_placements_ptr from_xml(xml_node const& xml, fontset_map const& fontsets, bool is_shield);
private:
std::vector<text_symbolizer_properties> list_;

2
include/mapnik/text/symbolizer_helpers.hpp
View file

@ -90,7 +90,7 @@ protected:
view_transform const& t_;
box2d<double> dims_;
box2d<double> const& query_extent_;
float scale_factor_;
double scale_factor_;
//Processing
// Remaining geometries to be processed.

2
include/mapnik/util/container_adapter.hpp
View file

@ -32,6 +32,8 @@
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wunused-local-typedef"
#pragma GCC diagnostic ignored "-Wshadow"
#pragma GCC diagnostic ignored "-Wsign-conversion"
#pragma GCC diagnostic ignored "-Wconversion"
#include <boost/spirit/include/support_container.hpp>
#pragma GCC diagnostic pop

2
include/mapnik/util/hsl.hpp
View file

@ -59,7 +59,7 @@ inline double hue_to_rgb(double m1, double m2, double h)
inline void hsl2rgb(double h, double s, double l,
double & r, double & g, double & b) {
if (!s) {
if (s == 0.0) {
r = g = b = l;
}
else

2
include/mapnik/util/path_iterator.hpp
View file

@ -111,7 +111,7 @@ private:
void increment()
{
std::get<0>(v_) = vertices_->cont_.get_vertex(pos_++, &std::get<1>(v_), &std::get<2>(v_));
std::get<0>(v_) = vertices_->cont_.get_vertex(static_cast<unsigned>(pos_++), &std::get<1>(v_), &std::get<2>(v_));
}
bool equal( path_iterator const& other) const

2
include/mapnik/vertex_converters.hpp
View file

@ -325,7 +325,7 @@ struct converters_helper<Dispatcher>
template <typename Converter>
static void set(Dispatcher &, std::size_t) {}
template <typename Geometry, typename Processor>
static void forward(Dispatcher & disp, Geometry & geom, Processor & proc)
static void forward(Dispatcher &, Geometry & geom, Processor & proc)
{
proc.add_path(geom);
}

2
include/mapnik/wkt/wkt_generator_grammar.hpp
View file

@ -34,6 +34,8 @@
#pragma GCC diagnostic ignored "-Wunused-parameter"
#pragma GCC diagnostic ignored "-Wunused-local-typedef"
#pragma GCC diagnostic ignored "-Wshadow"
#pragma GCC diagnostic ignored "-Wsign-conversion"
#pragma GCC diagnostic ignored "-Wconversion"
#include <boost/spirit/include/karma.hpp>
#include <boost/spirit/include/phoenix_function.hpp>
#include <boost/math/special_functions/trunc.hpp> // for vc++ and android whose c++11 libs lack std::trunc

2
include/mapnik/wkt/wkt_grammar.hpp
View file

@ -30,6 +30,8 @@
#pragma GCC diagnostic ignored "-Wunused-parameter"
#pragma GCC diagnostic ignored "-Wunused-local-typedef"
#pragma GCC diagnostic ignored "-Wshadow"
#pragma GCC diagnostic ignored "-Wsign-conversion"
#pragma GCC diagnostic ignored "-Wconversion"
#include <boost/assert.hpp>
#include <boost/spirit/include/qi.hpp>
#include <boost/spirit/include/phoenix_function.hpp>

9
include/mapnik/xml_attribute_cast.hpp
View file

@ -37,7 +37,10 @@
#include <mapnik/text/font_feature_settings.hpp>
// boost
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wsign-conversion"
#include <boost/optional.hpp>
#pragma GCC diagnostic pop
// stl
#include <string>
@ -166,7 +169,7 @@ struct do_xml_attribute_cast<mapnik::enumeration<T,MAX> >
template <>
struct do_xml_attribute_cast<mapnik::color>
{
static inline boost::optional<mapnik::color> xml_attribute_cast_impl(xml_tree const& tree, std::string const& source)
static inline boost::optional<mapnik::color> xml_attribute_cast_impl(xml_tree const&, std::string const& source)
{
return parse_color(source);
}
@ -176,7 +179,7 @@ struct do_xml_attribute_cast<mapnik::color>
template <>
struct do_xml_attribute_cast<std::string>
{
static inline boost::optional<std::string> xml_attribute_cast_impl(xml_tree const& /*tree*/, std::string const& source)
static inline boost::optional<std::string> xml_attribute_cast_impl(xml_tree const&, std::string const& source)
{
return boost::optional<std::string>(source);
}
@ -206,7 +209,7 @@ struct do_xml_attribute_cast<mapnik::expression_ptr>
template <>
struct do_xml_attribute_cast<mapnik::font_feature_settings>
{
static inline boost::optional<mapnik::font_feature_settings> xml_attribute_cast_impl(xml_tree const& tree, std::string const& source)
static inline boost::optional<mapnik::font_feature_settings> xml_attribute_cast_impl(xml_tree const&, std::string const& source)
{
return mapnik::font_feature_settings(source);
}

2
include/mapnik/xml_tree.hpp
View file

@ -36,7 +36,7 @@ namespace mapnik
class MAPNIK_DECL xml_tree
{
public:
xml_tree(std::string const& encoding="utf8");
xml_tree();
void set_filename(std::string const& fn);
std::string const& filename() const;
xml_node &root();

1
plugins/input/csv/csv_utils.hpp
View file

@ -26,6 +26,7 @@
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wunused-parameter"
#pragma GCC diagnostic ignored "-Wunused-local-typedef"
#pragma GCC diagnostic ignored "-Wsign-conversion"
#include <boost/algorithm/string.hpp>
#pragma GCC diagnostic pop

2
plugins/input/geojson/geojson_datasource.hpp
View file

@ -40,6 +40,8 @@
#pragma GCC diagnostic ignored "-Wunused-variable"
#pragma GCC diagnostic ignored "-Wunused-local-typedef"
#pragma GCC diagnostic ignored "-Wshadow"
#pragma GCC diagnostic ignored "-Wsign-conversion"
#pragma GCC diagnostic ignored "-Wconversion"
#include <boost/version.hpp>
#include <boost/geometry/index/rtree.hpp>
#pragma GCC diagnostic pop

1
plugins/input/shape/dbfile.cpp
View file

@ -32,6 +32,7 @@
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wunused-parameter"
#pragma GCC diagnostic ignored "-Wunused-local-typedef"
#pragma GCC diagnostic ignored "-Wshadow"
#include <boost/spirit/include/qi.hpp>
#ifdef SHAPE_MEMORY_MAPPED_FILE
#include <boost/interprocess/mapped_region.hpp>

8
plugins/input/shape/dbfile.hpp
View file

@ -29,11 +29,11 @@
#include <mapnik/unicode.hpp>
#ifdef SHAPE_MEMORY_MAPPED_FILE
#include <mapnik/mapped_memory_cache.hpp>
#endif
// boost
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wshadow"
#include <boost/interprocess/streams/bufferstream.hpp>
#pragma GCC diagnostic pop
#endif
// stl
#include <vector>

5
plugins/input/shape/shapefile.hpp
View file

@ -34,9 +34,12 @@
#include <mapnik/util/utf_conv_win.hpp>
#include <mapnik/box2d.hpp>
#ifdef SHAPE_MEMORY_MAPPED_FILE
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wshadow"
#include <boost/interprocess/mapped_region.hpp>
#include <mapnik/mapped_memory_cache.hpp>
#include <boost/interprocess/streams/bufferstream.hpp>
#pragma GCC diagnostic pop
#include <mapnik/mapped_memory_cache.hpp>
#endif
#include <mapnik/util/noncopyable.hpp>

2
plugins/input/topojson/topojson_datasource.hpp
View file

@ -40,6 +40,8 @@
#pragma GCC diagnostic ignored "-Wunused-variable"
#pragma GCC diagnostic ignored "-Wunused-local-typedef"
#pragma GCC diagnostic ignored "-Wshadow"
#pragma GCC diagnostic ignored "-Wsign-conversion"
#pragma GCC diagnostic ignored "-Wconversion"
#include <boost/geometry/geometries/geometries.hpp>
#include <boost/geometry.hpp>
#include <boost/version.hpp>

8
plugins/input/topojson/topojson_featureset.cpp
View file

@ -132,7 +132,7 @@ struct feature_generator
{
index_type index = line.ring;
index_type arc_index = index < 0 ? std::abs(index) - 1 : index;
if (arc_index < num_arcs_)
if (arc_index >= 0 && arc_index < static_cast<int>(num_arcs_))
{
auto const& arcs = topo_.arcs[arc_index];
double px = 0, py = 0;
@ -168,7 +168,7 @@ struct feature_generator
for (auto const& index : multi_line.rings)
{
index_type arc_index = index < 0 ? std::abs(index) - 1 : index;
if (arc_index < num_arcs_)
if (arc_index >= 0 && arc_index < static_cast<int>(num_arcs_))
{
hit = true;
double px = 0, py = 0;
@ -216,7 +216,7 @@ struct feature_generator
double px = 0, py = 0;
bool reverse = index < 0;
index_type arc_index = reverse ? std::abs(index) - 1 : index;
if (arc_index < num_arcs_)
if (arc_index >= 0 && arc_index < static_cast<int>(num_arcs_))
{
hit = true;
auto const& arcs = topo_.arcs[arc_index];
@ -296,7 +296,7 @@ struct feature_generator
double px = 0, py = 0;
bool reverse = index < 0;
index_type arc_index = reverse ? std::abs(index) - 1 : index;
if (arc_index < num_arcs_)
if (arc_index >= 0 && arc_index < static_cast<int>(num_arcs_))
{
hit = true;
auto const& arcs = topo_.arcs[arc_index];

12
src/agg/agg_renderer.cpp
View file

@ -128,16 +128,16 @@ struct setup_agg_bg_visitor
void operator() (marker_rgba8 const& marker)
{
mapnik::image_rgba8 const& bg_image = marker.get_data();
int w = bg_image.width();
int h = bg_image.height();
std::size_t w = bg_image.width();
std::size_t h = bg_image.height();
if ( w > 0 && h > 0)
{
// repeat background-image both vertically and horizontally
unsigned x_steps = static_cast<unsigned>(std::ceil(common_.width_/double(w)));
unsigned y_steps = static_cast<unsigned>(std::ceil(common_.height_/double(h)));
for (unsigned x=0;x<x_steps;++x)
std::size_t x_steps = static_cast<std::size_t>(std::ceil(common_.width_/double(w)));
std::size_t y_steps = static_cast<std::size_t>(std::ceil(common_.height_/double(h)));
for (std::size_t x=0;x<x_steps;++x)
{
for (unsigned y=0;y<y_steps;++y)
for (std::size_t y=0;y<y_steps;++y)
{
composite(pixmap_, bg_image, mode_, opacity_, x*w, y*h);
}

4
src/cairo/cairo_context.cpp
View file

@ -486,9 +486,9 @@ void cairo_context::add_text(glyph_positions const& pos,
matrix.y0 = 0;
set_font_matrix(matrix);
set_font_face(manager, glyph.face);
pixel_position pos = glyph_pos.pos + glyph.offset.rotate(glyph_pos.rot);
pixel_position new_pos = glyph_pos.pos + glyph.offset.rotate(glyph_pos.rot);
set_color(glyph.format->fill, glyph.format->text_opacity);
show_glyph(glyph.glyph_index, pixel_position(sx + pos.x, sy - pos.y));
show_glyph(glyph.glyph_index, pixel_position(sx + new_pos.x, sy - new_pos.y));
}
}

16
src/cairo/cairo_renderer.cpp
View file

@ -110,16 +110,16 @@ struct setup_marker_visitor
void operator() (marker_rgba8 const& marker)
{
mapnik::image_rgba8 const& bg_image = marker.get_data();
int w = bg_image.width();
int h = bg_image.height();
std::size_t w = bg_image.width();
std::size_t h = bg_image.height();
if ( w > 0 && h > 0)
{
// repeat background-image both vertically and horizontally
unsigned x_steps = unsigned(std::ceil(common_.width_/double(w)));
unsigned y_steps = unsigned(std::ceil(common_.height_/double(h)));
for (unsigned x=0;x<x_steps;++x)
std::size_t x_steps = std::size_t(std::ceil(common_.width_/double(w)));
std::size_t y_steps = std::size_t(std::ceil(common_.height_/double(h)));
for (std::size_t x=0;x<x_steps;++x)
{
for (unsigned y=0;y<y_steps;++y)
for (std::size_t y=0;y<y_steps;++y)
{
agg::trans_affine matrix = agg::trans_affine_translation(
x*w,
@ -191,13 +191,13 @@ void cairo_renderer<T>::end_layer_processing(layer const&)
}
template <typename T>
void cairo_renderer<T>::start_style_processing(feature_type_style const& st)
void cairo_renderer<T>::start_style_processing(feature_type_style const&)
{
MAPNIK_LOG_DEBUG(cairo_renderer) << "cairo_renderer:start style processing";
}
template <typename T>
void cairo_renderer<T>::end_style_processing(feature_type_style const& st)
void cairo_renderer<T>::end_style_processing(feature_type_style const&)
{
MAPNIK_LOG_DEBUG(cairo_renderer) << "cairo_renderer:end style processing";
}

12
src/cairo/process_line_pattern_symbolizer.cpp
View file

@ -43,8 +43,8 @@ struct cairo_renderer_process_visitor_l
cairo_renderer_process_visitor_l(renderer_common const& common,
line_pattern_symbolizer const& sym,
mapnik::feature_impl & feature,
unsigned & width,
unsigned & height)
std::size_t & width,
std::size_t & height)
: common_(common),
sym_(sym),
feature_(feature),
@ -81,8 +81,8 @@ struct cairo_renderer_process_visitor_l
renderer_common const& common_;
line_pattern_symbolizer const& sym_;
mapnik::feature_impl & feature_;
unsigned & width_;
unsigned & height_;
std::size_t & width_;
std::size_t & height_;
};
template <typename T>
@ -106,8 +106,8 @@ void cairo_renderer<T>::process(line_pattern_symbolizer const& sym,
if (marker->is<mapnik::marker_null>()) return;
unsigned width = marker->width();
unsigned height = marker->height();
std::size_t width = marker->width();
std::size_t height = marker->height();
cairo_save_restore guard(context_);
context_.set_operator(comp_op);

2
src/cairo/process_markers_symbolizer.cpp
View file

@ -59,7 +59,7 @@ struct vector_markers_dispatch_cairo : public vector_markers_dispatch<Detector>
double scale_factor,
feature_impl & feature,
mapnik::attributes const& vars,
bool snap_to_pixels,
bool /* snap_to_pixels */, // only used in agg renderer currently
RendererContext const& renderer_context)
: vector_markers_dispatch<Detector>(src, marker_trans, sym, detector, scale_factor, feature, vars),
path_(path),

2
src/color.cpp
View file

@ -33,6 +33,8 @@
#pragma GCC diagnostic ignored "-Wunused-parameter"
#pragma GCC diagnostic ignored "-Wunused-local-typedef"
#pragma GCC diagnostic ignored "-Wshadow"
#pragma GCC diagnostic ignored "-Wsign-conversion"
#pragma GCC diagnostic ignored "-Wconversion"
#include <boost/spirit/include/karma.hpp>
#include <boost/spirit/include/phoenix_statement.hpp>
#include <boost/spirit/include/phoenix_core.hpp>

2
src/conversions.cpp
View file

@ -34,6 +34,8 @@
#pragma GCC diagnostic ignored "-Wunused-parameter"
#pragma GCC diagnostic ignored "-Wunused-local-typedef"
#pragma GCC diagnostic ignored "-Wshadow"
#pragma GCC diagnostic ignored "-Wsign-conversion"
#pragma GCC diagnostic ignored "-Wconversion"
#include <boost/spirit/include/qi.hpp>
#ifdef MAPNIK_KARMA_TO_STRING
#include <boost/spirit/include/karma.hpp>

2
src/grid/process_line_pattern_symbolizer.cpp
View file

@ -82,7 +82,7 @@ void grid_renderer<T>::process(line_pattern_symbolizer const& sym,
ras_ptr->reset();
int stroke_width = mark->width();
std::size_t stroke_width = mark->width();
agg::trans_affine tr;
auto transform = get_optional<transform_type>(sym, keys::geometry_transform);

7
src/group/group_layout_manager.cpp
View file

@ -23,6 +23,7 @@
// mapnik
#include <mapnik/group/group_layout_manager.hpp>
#include <mapnik/util/variant.hpp>
#include <mapnik/safe_cast.hpp>
// std
#include <cmath>
@ -85,7 +86,7 @@ struct process_layout
}
bound_box layout_box;
size_t middle_ifirst = (member_boxes_.size() - 1) >> 1;
int middle_ifirst = safe_cast<int>((member_boxes_.size() - 1) >> 1);
int top_i = 0;
int bottom_i = 0;
if (middle_ifirst % 2 == 0)
@ -102,8 +103,8 @@ struct process_layout
while (bottom_i >= 0 && top_i >= 0 && top_i < static_cast<int>(member_offsets_.size()))
{
layout_box.expand_to_include(make_horiz_pair(top_i, layout_box.miny() - y_margin, -1, x_margin, layout.get_max_difference()));
layout_box.expand_to_include(make_horiz_pair(bottom_i, layout_box.maxy() + y_margin, 1, x_margin, layout.get_max_difference()));
layout_box.expand_to_include(make_horiz_pair(static_cast<std::size_t>(top_i), layout_box.miny() - y_margin, -1, x_margin, layout.get_max_difference()));
layout_box.expand_to_include(make_horiz_pair(static_cast<std::size_t>(bottom_i), layout_box.maxy() + y_margin, 1, x_margin, layout.get_max_difference()));
top_i -= 2;
bottom_i += 2;
}

12
src/image_copy.cpp
View file

@ -50,10 +50,10 @@ struct visitor_image_copy
template <typename T1>
T0 operator() (T1 const& src)
{
T0 dst(src.width(), src.height(), false);
for (unsigned y = 0; y < dst.height(); ++y)
T0 dst(safe_cast<int>(src.width()), safe_cast<int>(src.height()), false);
for (std::size_t y = 0; y < dst.height(); ++y)
{
for (unsigned x = 0; x < dst.width(); ++x)
for (std::size_t x = 0; x < dst.width(); ++x)
{
dst(x,y) = safe_cast<dst_type>(src(x,y));
}
@ -95,12 +95,12 @@ struct visitor_image_copy_so
{
double src_offset = src.get_offset();
double src_scaling = src.get_scaling();
T0 dst(src.width(), src.height(), false);
T0 dst(safe_cast<int>(src.width()), safe_cast<int>(src.height()), false);
dst.set_scaling(scaling_);
dst.set_offset(offset_);
for (unsigned y = 0; y < dst.height(); ++y)
for (std::size_t y = 0; y < dst.height(); ++y)
{
for (unsigned x = 0; x < dst.width(); ++x)
for (std::size_t x = 0; x < dst.width(); ++x)
{
double scaled_src_val = (safe_cast<double>(src(x,y)) * src_scaling) + src_offset;
double dst_val = (scaled_src_val - offset_) / scaling_;

2
src/image_filter_types.cpp
View file

@ -30,6 +30,8 @@
#pragma GCC diagnostic ignored "-Wunused-local-typedef"
#pragma GCC diagnostic ignored "-Wmissing-field-initializers"
#pragma GCC diagnostic ignored "-Wshadow"
#pragma GCC diagnostic ignored "-Wsign-conversion"
#pragma GCC diagnostic ignored "-Wconversion"
#include <boost/spirit/include/karma.hpp>
#pragma GCC diagnostic pop

60
src/image_util.cpp
View file

@ -489,7 +489,7 @@ struct premultiply_visitor
{
if (!data.get_premultiplied())
{
agg::rendering_buffer buffer(data.bytes(),data.width(),data.height(),data.row_size());
agg::rendering_buffer buffer(data.bytes(),safe_cast<unsigned>(data.width()),safe_cast<unsigned>(data.height()),safe_cast<int>(data.row_size()));
agg::pixfmt_rgba32 pixf(buffer);
pixf.premultiply();
data.set_premultiplied(true);
@ -511,7 +511,7 @@ struct demultiply_visitor
{
if (data.get_premultiplied())
{
agg::rendering_buffer buffer(data.bytes(),data.width(),data.height(),data.row_size());
agg::rendering_buffer buffer(data.bytes(),safe_cast<unsigned>(data.width()),safe_cast<unsigned>(data.height()),safe_cast<int>(data.row_size()));
agg::pixfmt_rgba32_pre pixf(buffer);
pixf.demultiply();
data.set_premultiplied(false);
@ -641,12 +641,12 @@ struct visitor_apply_opacity
for (std::size_t x = 0; x < data.width(); ++x)
{
pixel_type rgba = row_to[x];
pixel_type a = static_cast<pixel_type>(((rgba >> 24) & 0xff) * opacity_);
pixel_type a = static_cast<pixel_type>(((rgba >> 24u) & 0xff) * opacity_);
pixel_type r = rgba & 0xff;
pixel_type g = (rgba >> 8 ) & 0xff;
pixel_type b = (rgba >> 16) & 0xff;
pixel_type g = (rgba >> 8u ) & 0xff;
pixel_type b = (rgba >> 16u) & 0xff;
row_to[x] = (a << 24)| (b << 16) | (g << 8) | (r) ;
row_to[x] = (a << 24u) | (b << 16u) | (g << 8u) | (r) ;
}
}
}
@ -713,13 +713,13 @@ struct visitor_set_grayscale_to_alpha
{
pixel_type rgba = row_from[x];
pixel_type r = rgba & 0xff;
pixel_type g = (rgba >> 8 ) & 0xff;
pixel_type b = (rgba >> 16) & 0xff;
pixel_type g = (rgba >> 8u) & 0xff;
pixel_type b = (rgba >> 16u) & 0xff;
// magic numbers for grayscale
pixel_type a = static_cast<pixel_type>(std::ceil((r * .3) + (g * .59) + (b * .11)));
row_from[x] = (a << 24)| (255 << 16) | (255 << 8) | (255) ;
row_from[x] = (a << 24u) | (255 << 16u) | (255 << 8u) | (255u) ;
}
}
}
@ -752,7 +752,10 @@ struct visitor_set_grayscale_to_alpha_c
// magic numbers for grayscale
pixel_type a = static_cast<pixel_type>(std::ceil((r * .3) + (g * .59) + (b * .11)));
row_from[x] = (a << 24)| (c_.blue() << 16) | (c_.green() << 8) | (c_.red()) ;
row_from[x] = static_cast<unsigned>(a << 24u) |
static_cast<unsigned>(c_.blue() << 16u) |
static_cast<unsigned>(c_.green() << 8u) |
static_cast<unsigned>(c_.red() );
}
}
}
@ -1217,9 +1220,10 @@ struct visitor_composite_pixel
if (mapnik::check_bounds(data, x_, y_))
{
image_rgba8::pixel_type rgba = data(x_,y_);
value_type ca = static_cast<unsigned>(((c_ >> 24) & 0xff) * opacity_);
value_type cb = (c_ >> 16 ) & 0xff;
value_type cg = (c_ >> 8) & 0xff;
// TODO use std::round for consistent rounding
value_type ca = safe_cast<value_type>(((c_ >> 24u) & 0xff) * opacity_);
value_type cb = (c_ >> 16u) & 0xff;
value_type cg = (c_ >> 8u) & 0xff;
value_type cr = (c_ & 0xff);
blender_type::blend_pix(comp_op_, reinterpret_cast<value_type*>(&rgba), cr, cg, cb, ca, cover_);
data(x_,y_) = rgba;
@ -1227,7 +1231,7 @@ struct visitor_composite_pixel
}
template <typename T>
void operator() (T & data) const
void operator() (T &) const
{
throw std::runtime_error("Composite pixel is not supported for this data type");
}
@ -1237,7 +1241,7 @@ private:
composite_mode_e comp_op_;
std::size_t const x_;
std::size_t const y_;
int const c_;
unsigned const c_;
unsigned const cover_;
};
@ -2082,7 +2086,7 @@ struct visitor_view_to_stream
for (std::size_t i=0;i<view.height();i++)
{
os_.write(reinterpret_cast<const char*>(view.get_row(i)),
view.row_size());
safe_cast<std::streamsize>(view.row_size()));
}
}
@ -2251,11 +2255,11 @@ MAPNIK_DECL std::size_t compare<image_rgba8>(image_rgba8 const& im1, image_rgba8
unsigned rgba = row_from[x];
unsigned rgba2 = row_from2[x];
unsigned r = rgba & 0xff;
unsigned g = (rgba >> 8 ) & 0xff;
unsigned b = (rgba >> 16) & 0xff;
unsigned g = (rgba >> 8u) & 0xff;
unsigned b = (rgba >> 16u) & 0xff;
unsigned r2 = rgba2 & 0xff;
unsigned g2 = (rgba2 >> 8 ) & 0xff;
unsigned b2 = (rgba2 >> 16) & 0xff;
unsigned g2 = (rgba2 >> 8u) & 0xff;
unsigned b2 = (rgba2 >> 16u) & 0xff;
if (std::abs(static_cast<int>(r - r2)) > static_cast<int>(threshold) ||
std::abs(static_cast<int>(g - g2)) > static_cast<int>(threshold) ||
std::abs(static_cast<int>(b - b2)) > static_cast<int>(threshold)) {
@ -2263,8 +2267,8 @@ MAPNIK_DECL std::size_t compare<image_rgba8>(image_rgba8 const& im1, image_rgba8
continue;
}
if (alpha) {
unsigned a = (rgba >> 24) & 0xff;
unsigned a2 = (rgba2 >> 24) & 0xff;
unsigned a = (rgba >> 24u) & 0xff;
unsigned a2 = (rgba2 >> 24u) & 0xff;
if (std::abs(static_cast<int>(a - a2)) > static_cast<int>(threshold)) {
++difference;
continue;
@ -2289,11 +2293,11 @@ MAPNIK_DECL std::size_t compare<image_rgba8>(image_rgba8 const& im1, image_rgba8
unsigned rgba = row_from[x];
unsigned rgba2 = row_from2[x];
unsigned r = rgba & 0xff;
unsigned g = (rgba >> 8 ) & 0xff;
unsigned b = (rgba >> 16) & 0xff;
unsigned g = (rgba >> 8u) & 0xff;
unsigned b = (rgba >> 16u) & 0xff;
unsigned r2 = rgba2 & 0xff;
unsigned g2 = (rgba2 >> 8 ) & 0xff;
unsigned b2 = (rgba2 >> 16) & 0xff;
unsigned g2 = (rgba2 >> 8u) & 0xff;
unsigned b2 = (rgba2 >> 16u) & 0xff;
if (std::abs(static_cast<int>(r - r2)) > static_cast<int>(threshold) ||
std::abs(static_cast<int>(g - g2)) > static_cast<int>(threshold) ||
std::abs(static_cast<int>(b - b2)) > static_cast<int>(threshold)) {
@ -2301,8 +2305,8 @@ MAPNIK_DECL std::size_t compare<image_rgba8>(image_rgba8 const& im1, image_rgba8
continue;
}
if (alpha) {
unsigned a = (rgba >> 24) & 0xff;
unsigned a2 = (rgba2 >> 24) & 0xff;
unsigned a = (rgba >> 24u) & 0xff;
unsigned a2 = (rgba2 >> 24u) & 0xff;
if (std::abs(static_cast<int>(a - a2)) > static_cast<int>(threshold)) {
++difference;
continue;

4
src/image_view_any.cpp
View file

@ -47,7 +47,7 @@ struct get_view_height_visitor
struct get_view_size_visitor
{
template <typename T>
unsigned operator()(T const& data) const
std::size_t operator()(T const& data) const
{
return data.size();
}
@ -65,7 +65,7 @@ struct get_view_dtype_visitor
struct get_view_row_size_visitor
{
template <typename T>
unsigned operator()(T const& data) const
std::size_t operator()(T const& data) const
{
return data.row_size();
}

12
src/load_map.cpp
View file

@ -80,7 +80,7 @@ using boost::optional;
constexpr unsigned name2int(const char *str, int off = 0)
{
return !str[off] ? 5381 : (name2int(str, off+1)*33) ^ str[off];
return !str[off] ? 5381 : (name2int(str, off+1)*33) ^ static_cast<unsigned>(str[off]);
}
class map_parser : util::noncopyable
@ -147,8 +147,7 @@ private:
void load_map(Map & map, std::string const& filename, bool strict, std::string base_path)
{
// TODO - use xml encoding?
xml_tree tree("utf8");
xml_tree tree;
tree.set_filename(filename);
read_xml(filename, tree.root());
map_parser parser(map, strict, filename);
@ -157,8 +156,7 @@ void load_map(Map & map, std::string const& filename, bool strict, std::string b
void load_map_string(Map & map, std::string const& str, bool strict, std::string base_path)
{
// TODO - use xml encoding?
xml_tree tree("utf8");
xml_tree tree;
if (!base_path.empty())
{
read_xml_string(str, tree.root(), base_path); // accept base_path passed into function
@ -237,7 +235,7 @@ void map_parser::parse_map(Map & map, xml_node const& node, std::string const& b
}
map.set_srs(srs);
optional<unsigned> buffer_size = map_node.get_opt_attr<unsigned>("buffer-size");
optional<int> buffer_size = map_node.get_opt_attr<int>("buffer-size");
if (buffer_size)
{
map.set_buffer_size(*buffer_size);
@ -648,7 +646,7 @@ void map_parser::parse_layer(Map & map, xml_node const& node)
lyr.set_group_by(* group_by);
}
optional<unsigned> buffer_size = node.get_opt_attr<unsigned>("buffer-size");
optional<int> buffer_size = node.get_opt_attr<int>("buffer-size");
if (buffer_size)
{
lyr.set_buffer_size(*buffer_size);

4
src/marker_cache.cpp
View file

@ -126,13 +126,13 @@ struct visitor_create_marker
return mapnik::marker(mapnik::marker_rgba8(data));
}
marker operator() (image_null & data)
marker operator() (image_null &)
{
throw std::runtime_error("Can not make marker from null image data type");
}
template <typename T>
marker operator() (T & data)
marker operator() (T &)
{
throw std::runtime_error("Can not make marker from this data type");
}

1
src/renderer_common.cpp
View file

@ -25,6 +25,7 @@
#include <mapnik/map.hpp>
#include <mapnik/request.hpp>
#include <mapnik/attribute.hpp>
#include <mapnik/safe_cast.hpp>
namespace mapnik {

51
src/save_map.cpp
View file

@ -465,13 +465,12 @@ void serialize_fontset( ptree & map_node, std::string const& name, font_set cons
set_attr(fontset_node, "name", name);
for (auto const& name : fontset.get_face_names())
for (auto const& face_name : fontset.get_face_names())
{
ptree & font_node = fontset_node.push_back(
ptree::value_type("Font", ptree()))->second;
set_attr(font_node, "face-name", name);
set_attr(font_node, "face-name", face_name);
}
}
void serialize_datasource( ptree & layer_node, datasource_ptr datasource)
@ -507,63 +506,63 @@ void serialize_parameters( ptree & map_node, mapnik::parameters const& params)
}
}
void serialize_layer( ptree & map_node, const layer & layer, bool explicit_defaults )
void serialize_layer( ptree & map_node, layer const& lyr, bool explicit_defaults )
{
ptree & layer_node = map_node.push_back(
ptree::value_type("Layer", ptree()))->second;
if ( layer.name() != "" )
if ( lyr.name() != "" )
{
set_attr( layer_node, "name", layer.name() );
set_attr( layer_node, "name", lyr.name() );
}
if ( layer.srs() != "" )
if ( lyr.srs() != "" )
{
set_attr( layer_node, "srs", layer.srs() );
set_attr( layer_node, "srs", lyr.srs() );
}
if ( !layer.active() || explicit_defaults )
if ( !lyr.active() || explicit_defaults )
{
set_attr/*<bool>*/( layer_node, "status", layer.active() );
set_attr/*<bool>*/( layer_node, "status", lyr.active() );
}
if ( layer.clear_label_cache() || explicit_defaults )
if ( lyr.clear_label_cache() || explicit_defaults )
{
set_attr/*<bool>*/( layer_node, "clear-label-cache", layer.clear_label_cache() );
set_attr/*<bool>*/( layer_node, "clear-label-cache", lyr.clear_label_cache() );
}
if ( layer.minimum_scale_denominator() )
if ( lyr.minimum_scale_denominator() != 0 || explicit_defaults )
{
set_attr( layer_node, "minimum_scale_denominator", layer.minimum_scale_denominator() );
set_attr( layer_node, "minimum_scale_denominator", lyr.minimum_scale_denominator() );
}
if ( layer.maximum_scale_denominator() != std::numeric_limits<double>::max() )
if ( lyr.maximum_scale_denominator() != std::numeric_limits<double>::max() || explicit_defaults )
{
set_attr( layer_node, "maximum_scale_denominator", layer.maximum_scale_denominator() );
set_attr( layer_node, "maximum_scale_denominator", lyr.maximum_scale_denominator() );
}
if ( layer.queryable() || explicit_defaults )
if ( lyr.queryable() || explicit_defaults )
{
set_attr( layer_node, "queryable", layer.queryable() );
set_attr( layer_node, "queryable", lyr.queryable() );
}
if ( layer.cache_features() || explicit_defaults )
if ( lyr.cache_features() || explicit_defaults )
{
set_attr/*<bool>*/( layer_node, "cache-features", layer.cache_features() );
set_attr/*<bool>*/( layer_node, "cache-features", lyr.cache_features() );
}
if ( layer.group_by() != "" || explicit_defaults )
if ( lyr.group_by() != "" || explicit_defaults )
{
set_attr( layer_node, "group-by", layer.group_by() );
set_attr( layer_node, "group-by", lyr.group_by() );
}
boost::optional<int> const& buffer_size = layer.buffer_size();
boost::optional<int> const& buffer_size = lyr.buffer_size();
if ( buffer_size || explicit_defaults)
{
set_attr( layer_node, "buffer-size", *buffer_size );
}
optional<box2d<double> > const& maximum_extent = layer.maximum_extent();
optional<box2d<double> > const& maximum_extent = lyr.maximum_extent();
if ( maximum_extent)
{
std::ostringstream s;
@ -573,7 +572,7 @@ void serialize_layer( ptree & map_node, const layer & layer, bool explicit_defau
set_attr( layer_node, "maximum-extent", s.str() );
}
for (auto const& name : layer.styles())
for (auto const& name : lyr.styles())
{
boost::property_tree::ptree & style_node = layer_node.push_back(
boost::property_tree::ptree::value_type("StyleName",
@ -581,7 +580,7 @@ void serialize_layer( ptree & map_node, const layer & layer, bool explicit_defau
style_node.put_value(name);
}
datasource_ptr datasource = layer.datasource();
datasource_ptr datasource = lyr.datasource();
if ( datasource )
{
serialize_datasource( layer_node, datasource );

2
src/svg/output/svg_generator.cpp
View file

@ -32,6 +32,8 @@
#pragma GCC diagnostic ignored "-Wunused-parameter"
#pragma GCC diagnostic ignored "-Wunused-local-typedef"
#pragma GCC diagnostic ignored "-Wshadow"
#pragma GCC diagnostic ignored "-Wsign-conversion"
#pragma GCC diagnostic ignored "-Wconversion"
#include <boost/spirit/include/karma.hpp>
#pragma GCC diagnostic pop

4
src/svg/svg_parser.cpp
View file

@ -25,6 +25,7 @@
#include <mapnik/svg/svg_parser.hpp>
#include <mapnik/svg/svg_path_parser.hpp>
#include <mapnik/config_error.hpp>
#include <mapnik/safe_cast.hpp>
#include "agg_ellipse.h"
#include "agg_rounded_rect.h"
@ -34,6 +35,7 @@
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wunused-parameter"
#pragma GCC diagnostic ignored "-Wunused-local-typedef"
#pragma GCC diagnostic ignored "-Wsign-conversion"
#include <boost/spirit/include/qi.hpp>
#include <boost/spirit/include/phoenix_core.hpp>
#include <boost/spirit/include/phoenix_operator.hpp>
@ -1075,7 +1077,7 @@ void svg_parser::parse(std::string const& filename)
void svg_parser::parse_from_string(std::string const& svg)
{
xmlTextReaderPtr reader = xmlReaderForMemory(svg.c_str(),svg.size(),nullptr,nullptr,
xmlTextReaderPtr reader = xmlReaderForMemory(svg.c_str(),safe_cast<int>(svg.size()),nullptr,nullptr,
(XML_PARSE_NOBLANKS | XML_PARSE_NOCDATA | XML_PARSE_NOERROR | XML_PARSE_NOWARNING));
if (reader == nullptr)
{

2
src/text/formatting/text.cpp
View file

@ -46,7 +46,7 @@ void text_node::to_xml(ptree & xml) const
new_node.put_value(to_expression_string(*text_));
}
node_ptr text_node::from_xml(xml_node const& xml, fontset_map const& fontsets)
node_ptr text_node::from_xml(xml_node const& xml, fontset_map const&)
{
return std::make_shared<text_node>(xml.get_value<expression_ptr>());
}

2
src/text/placements/dummy.cpp
View file

@ -33,7 +33,7 @@ bool text_placement_info_dummy::next() const
}
text_placement_info_ptr text_placements_dummy::get_placement_info(
double scale_factor, feature_impl const& feature, attributes const& vars) const
double scale_factor, feature_impl const&, attributes const&) const
{
return std::make_shared<text_placement_info_dummy>(this, scale_factor);
}

4
src/text/placements/list.cpp
View file

@ -65,7 +65,7 @@ text_symbolizer_properties & text_placements_list::get(unsigned i)
}
text_placement_info_ptr text_placements_list::get_placement_info(double scale_factor, feature_impl const& feature, attributes const& vars) const
text_placement_info_ptr text_placements_list::get_placement_info(double scale_factor, feature_impl const&, attributes const&) const
{
return std::make_shared<text_placement_info_list>(this, scale_factor);
}
@ -83,7 +83,7 @@ void text_placements_list::add_expressions(expression_set & output) const
}
}
unsigned text_placements_list::size() const
std::size_t text_placements_list::size() const
{
return list_.size();
}

4
src/text/placements/simple.cpp
View file

@ -35,6 +35,8 @@
#pragma GCC diagnostic ignored "-Wunused-parameter"
#pragma GCC diagnostic ignored "-Wunused-local-typedef"
#pragma GCC diagnostic ignored "-Wmissing-field-initializers"
#pragma GCC diagnostic ignored "-Wsign-conversion"
#pragma GCC diagnostic ignored "-Wconversion"
#include <boost/spirit/include/qi.hpp>
#include <boost/spirit/include/phoenix_core.hpp>
#include <boost/spirit/include/phoenix_stl.hpp>
@ -185,7 +187,7 @@ namespace detail {
}
template <typename T>
std::string operator() (T const& val) const
std::string operator() (T const&) const
{
return "";
}

2
src/text/symbolizer_helpers.cpp
View file

@ -342,7 +342,7 @@ public:
}
template <typename T>
bool operator()(T const & geo) const
bool operator()(T const&) const
{
return false;
}

4
src/xml_tree.cpp
View file

@ -68,6 +68,7 @@ struct name_trait
DEFINE_NAME_TRAIT( double, "double")
DEFINE_NAME_TRAIT( float, "float")
DEFINE_NAME_TRAIT( unsigned, "unsigned")
DEFINE_NAME_TRAIT( int, "int")
DEFINE_NAME_TRAIT( boolean_type, "boolean_type")
#ifdef BIGINT
DEFINE_NAME_TRAIT( mapnik::value_integer, "long long" )
@ -98,7 +99,7 @@ struct name_trait< mapnik::enumeration<ENUM, MAX> >
}
};
xml_tree::xml_tree(std::string const& encoding)
xml_tree::xml_tree()
: node_(*this, "<root>"),
file_()
{
@ -413,6 +414,7 @@ std::string xml_node::line_to_string() const
compile_get_opt_attr(boolean_type);
compile_get_opt_attr(std::string);
compile_get_opt_attr(int);
compile_get_opt_attr(unsigned);
compile_get_opt_attr(mapnik::value_integer);
compile_get_opt_attr(float);

2
test/unit/serialization/xml_parser_trim.cpp
View file

@ -21,7 +21,7 @@ TEST_CASE("xml parser") {
" </Layer>"
"</Map>");
mapnik::xml_tree tree("utf8");
mapnik::xml_tree tree;
tree.set_filename("xml_datasource_parameter_trim.cpp");
REQUIRE_NOTHROW(read_xml_string(xml, tree.root(), ""));