diff --git a/CHANGELOG.md b/CHANGELOG.md index 57ebfda65..a5c176354 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -27,6 +27,7 @@ For a complete change history, see the git log. - Slightly improved `sql_utils::table_from_sql` ([2587bb3](https://github.com/mapnik/mapnik/commit/2587bb3a1d8db397acfa8dcc2d332da3a8a9399f)) - Added wrappers for proper quoting in SQL query construction: `sql_utils::identifier`, `sql_utils::literal` ([7b21713](https://github.com/mapnik/mapnik/commit/7b217133e2749b82c2638551045c4edbece15086)) - Added two-argument `sql_utils::unquote`, `sql_utils::unquote_copy` that also collapse inner quotes ([a4e8ea2](https://github.com/mapnik/mapnik/commit/a4e8ea21be297d89bbf36ba594d6c661a7a9ac81)) +- Reworked mapnik::enumeration<...> ([#4372](https://github.com/mapnik/mapnik/pull/4372)) #### Plugins diff --git a/benchmark/src/test_png_encoding2.cpp b/benchmark/src/test_png_encoding2.cpp index 19897d180..5791b139c 100644 --- a/benchmark/src/test_png_encoding2.cpp +++ b/benchmark/src/test_png_encoding2.cpp @@ -1,5 +1,6 @@ #include "bench_framework.hpp" #include "compare_images.hpp" +#include class test : public benchmark::test_case { diff --git a/demo/c++/rundemo.cpp b/demo/c++/rundemo.cpp index c5b56cb3c..022442dec 100644 --- a/demo/c++/rundemo.cpp +++ b/demo/c++/rundemo.cpp @@ -131,8 +131,8 @@ int main(int, char**) line_symbolizer line_sym; put(line_sym, keys::stroke, color(171, 158, 137)); put(line_sym, keys::stroke_width, 2.0); - put(line_sym, keys::stroke_linecap, ROUND_CAP); - put(line_sym, keys::stroke_linejoin, ROUND_JOIN); + put(line_sym, keys::stroke_linecap, line_cap_enum::ROUND_CAP); + put(line_sym, keys::stroke_linejoin, line_join_enum::ROUND_JOIN); r.append(std::move(line_sym)); } roads34_style.add_rule(std::move(r)); @@ -148,8 +148,8 @@ int main(int, char**) line_symbolizer line_sym; put(line_sym, keys::stroke, color(171, 158, 137)); put(line_sym, keys::stroke_width, 4.0); - put(line_sym, keys::stroke_linecap, ROUND_CAP); - put(line_sym, keys::stroke_linejoin, ROUND_JOIN); + put(line_sym, keys::stroke_linecap, line_cap_enum::ROUND_CAP); + put(line_sym, keys::stroke_linejoin, line_join_enum::ROUND_JOIN); r.append(std::move(line_sym)); } roads2_style_1.add_rule(std::move(r)); @@ -164,8 +164,8 @@ int main(int, char**) line_symbolizer line_sym; put(line_sym, keys::stroke, color(255, 250, 115)); put(line_sym, keys::stroke_width, 2.0); - put(line_sym, keys::stroke_linecap, ROUND_CAP); - put(line_sym, keys::stroke_linejoin, ROUND_JOIN); + put(line_sym, keys::stroke_linecap, line_cap_enum::ROUND_CAP); + put(line_sym, keys::stroke_linejoin, line_join_enum::ROUND_JOIN); r.append(std::move(line_sym)); } roads2_style_2.add_rule(std::move(r)); @@ -181,8 +181,8 @@ int main(int, char**) line_symbolizer line_sym; put(line_sym, keys::stroke, color(188, 149, 28)); put(line_sym, keys::stroke_width, 7.0); - put(line_sym, keys::stroke_linecap, ROUND_CAP); - put(line_sym, keys::stroke_linejoin, ROUND_JOIN); + put(line_sym, keys::stroke_linecap, line_cap_enum::ROUND_CAP); + put(line_sym, keys::stroke_linejoin, line_join_enum::ROUND_JOIN); r.append(std::move(line_sym)); } roads1_style_1.add_rule(std::move(r)); @@ -197,8 +197,8 @@ int main(int, char**) line_symbolizer line_sym; put(line_sym, keys::stroke, color(242, 191, 36)); put(line_sym, keys::stroke_width, 5.0); - put(line_sym, keys::stroke_linecap, ROUND_CAP); - put(line_sym, keys::stroke_linejoin, ROUND_JOIN); + put(line_sym, keys::stroke_linecap, line_cap_enum::ROUND_CAP); + put(line_sym, keys::stroke_linejoin, line_join_enum::ROUND_JOIN); r.append(std::move(line_sym)); } roads1_style_2.add_rule(std::move(r)); diff --git a/include/mapnik/adaptive_smooth.hpp b/include/mapnik/adaptive_smooth.hpp index 0f5748f3c..ae088d460 100644 --- a/include/mapnik/adaptive_smooth.hpp +++ b/include/mapnik/adaptive_smooth.hpp @@ -4,6 +4,8 @@ #include #include +#include +#include MAPNIK_DISABLE_WARNING_PUSH #include #include "agg_conv_smooth_poly1.h" @@ -80,9 +82,9 @@ class smooth_converter { switch (algo) { - case SMOOTH_ALGORITHM_ADAPTIVE: + case smooth_algorithm_enum::SMOOTH_ALGORITHM_ADAPTIVE: return adaptive_impl_type(geom); - case SMOOTH_ALGORITHM_BASIC: + case smooth_algorithm_enum::SMOOTH_ALGORITHM_BASIC: default: break; } @@ -92,7 +94,7 @@ class smooth_converter public: smooth_converter(Geometry& geom) : geom_(geom) - , impl_(std::move(init_impl(SMOOTH_ALGORITHM_BASIC, geom))) + , impl_(std::move(init_impl(smooth_algorithm_enum::SMOOTH_ALGORITHM_BASIC, geom))) {} void algorithm(smooth_algorithm_enum algo) { impl_ = init_impl(algo, geom_); } diff --git a/include/mapnik/agg_helpers.hpp b/include/mapnik/agg_helpers.hpp index 00a419287..01f9a27e2 100644 --- a/include/mapnik/agg_helpers.hpp +++ b/include/mapnik/agg_helpers.hpp @@ -39,19 +39,19 @@ void set_gamma_method(T& ras_ptr, double gamma, gamma_method_enum method) { switch (method) { - case GAMMA_POWER: + case gamma_method_enum::GAMMA_POWER: ras_ptr->gamma(agg::gamma_power(gamma)); break; - case GAMMA_LINEAR: + case gamma_method_enum::GAMMA_LINEAR: ras_ptr->gamma(agg::gamma_linear(0.0, gamma)); break; - case GAMMA_NONE: + case gamma_method_enum::GAMMA_NONE: ras_ptr->gamma(agg::gamma_none()); break; - case GAMMA_THRESHOLD: + case gamma_method_enum::GAMMA_THRESHOLD: ras_ptr->gamma(agg::gamma_threshold(gamma)); break; - case GAMMA_MULTIPLY: + case gamma_method_enum::GAMMA_MULTIPLY: ras_ptr->gamma(agg::gamma_multiply(gamma)); break; default: diff --git a/include/mapnik/enumeration.hpp b/include/mapnik/enumeration.hpp index a0f08e3ac..943abdeb3 100644 --- a/include/mapnik/enumeration.hpp +++ b/include/mapnik/enumeration.hpp @@ -31,6 +31,13 @@ #include #include #include +#include +#include +#include +#include +#if __cpp_lib_string_view >= 201606L +#include +#endif #include @@ -51,9 +58,160 @@ class illegal_enum_value : public std::exception virtual const char* what() const noexcept { return what_.c_str(); } protected: - std::string what_; + const std::string what_; }; +namespace detail { +#if __cpp_lib_string_view >= 201606L +using mapnik_string_view = std::string_view; +#else +class mapnik_string_view // use std::string_view in C++17 +{ + public: + + template + constexpr mapnik_string_view(const char (&s)[N]) + : size_(N) + , data_(s) + {} + + constexpr mapnik_string_view(const char* s, std::size_t N) + : size_(N) + , data_(s) + {} + + constexpr char operator[](std::size_t index) const + { + return (index >= size_) ? throw std::out_of_range("Invalid index.") : data_[index]; + } + + constexpr char const* data() const { return data_; } + + private: + std::size_t size_; + const char* data_; +}; + +constexpr bool mapnik_string_view_equals(mapnik_string_view const& a, char const* b, std::size_t i) +{ + if (a[i] != b[i]) + { + return false; + } + else if (a[i] == 0 || b[i] == 0) + { + return true; + } + else + { + return mapnik_string_view_equals(a, b, i + 1); + } +} + +constexpr bool operator==(mapnik_string_view const& a, char const* b) +{ + return mapnik_string_view_equals(a, b, 0); +} +#endif + +template +using EnumStringT = std::tuple; + +template +using EnumMapT = std::array, N>; + +template +constexpr char const* EnumGetValue(EnumMapT const& map, EnumT key, std::size_t i = 0) +{ + if (i >= map.size()) + { + throw illegal_enum_value{"Enum value not present in map."}; + } + return (std::get<0>(map[i]) == key) ? std::get<1>(map[i]).data() : EnumGetValue(map, key, i + 1); +} + +template +constexpr EnumT EnumGetKey(EnumMapT const& map, char const* value, std::size_t i = 0) +{ + if (i >= map.size()) + { + throw illegal_enum_value{"Enum key not present in map."}; + } + return (std::get<1>(map[i]) == value) ? std::get<0>(map[i]) : EnumGetKey(map, value, i + 1); +} +} // namespace detail + +template (*F_LOOKUP)()> +struct MAPNIK_DECL enumeration +{ + using native_type = ENUM; + constexpr operator ENUM() const { return value_; } + // constexpr bool operator==(const enumeration_new& rhs) { return value_ == rhs.value_; } + void operator=(ENUM v) { value_ = v; } + void operator=(const enumeration& other) { value_ = other.value_; } + + enumeration() + : value_() + {} + + enumeration(ENUM v) + : value_(v) + {} + + void from_string(const std::string& str) { value_ = F_FROM_STRING(str.c_str()); } + std::string as_string() const { return F_TO_STRING(value_); } + static std::map lookupMap() { return F_LOOKUP(); } + + ENUM value_; +}; + +#define DEFINE_ENUM_FNCS(fnc_name, enum_class) \ + MAPNIK_DECL char const* fnc_name##_to_string(enum_class value); \ + MAPNIK_DECL enum_class fnc_name##_from_string(const char* value); \ + MAPNIK_DECL std::ostream& operator<<(std::ostream& stream, enum_class value); \ + MAPNIK_DECL std::map fnc_name##_lookup(); + +#define IMPLEMENT_ENUM_FNCS(fnc_name, enum_class) \ + char const* fnc_name##_to_string(enum_class value) \ + { \ + return mapnik::detail::EnumGetValue(fnc_name##_map, value); \ + } \ + enum_class fnc_name##_from_string(const char* value) \ + { \ + return mapnik::detail::EnumGetKey(fnc_name##_map, value); \ + } \ + std::ostream& operator<<(std::ostream& stream, enum_class value) \ + { \ + stream << fnc_name##_to_string(value); \ + return stream; \ + } \ + std::map fnc_name##_lookup() \ + { \ + std::map val_map; \ + std::transform( \ + fnc_name##_map.begin(), \ + fnc_name##_map.end(), \ + std::inserter(val_map, val_map.end()), \ + [](const mapnik::detail::EnumStringT& val) { \ + return std::pair{std::get<0>(val), std::string{std::get<1>(val).data()}}; \ + }); \ + return val_map; \ + } + +#define DEFINE_ENUM(type_alias, enum_class) \ + DEFINE_ENUM_FNCS(type_alias, enum_class) \ + using type_alias = enumeration; \ + extern template struct MAPNIK_DECL \ + enumeration; + +#define IMPLEMENT_ENUM(type_alias, enum_class) \ + IMPLEMENT_ENUM_FNCS(type_alias, enum_class) \ + template class MAPNIK_DECL \ + enumeration; + /** Slim wrapper for enumerations. It creates a new type from a native enum and * a char pointer array. It almost exactly behaves like a native enumeration * type. It supports string conversion through stream operators. This is useful @@ -133,159 +291,6 @@ class illegal_enum_value : public std::exception * @endcode */ -template -class MAPNIK_DECL enumeration -{ - public: - using native_type = ENUM; - - enumeration() - : value_() - {} - - enumeration(ENUM v) - : value_(v) - {} - - enumeration(enumeration const& other) - : value_(other.value_) - {} - - /** Assignment operator for native enum values. */ - void operator=(ENUM v) { value_ = v; } - - /** Assignment operator. */ - void operator=(enumeration const& other) { value_ = other.value_; } - - /** Conversion operator for native enum values. */ - operator ENUM() const { return value_; } - - enum Max { MAX = THE_MAX }; - - /** Converts @p str to an enum. - * @throw illegal_enum_value @p str is not a legal identifier. - * */ - void from_string(std::string const& str) - { - // TODO: Enum value strings with underscore are deprecated in Mapnik 3.x - // and support will be removed in Mapnik 4.x. - bool deprecated = false; - std::string str_copy(str); - if (str_copy.find('_') != std::string::npos) - { - std::replace(str_copy.begin(), str_copy.end(), '_', '-'); - deprecated = true; - } - for (unsigned i = 0; i < THE_MAX; ++i) - { - MAPNIK_DISABLE_WARNING_PUSH - MAPNIK_DISABLE_WARNING_UNKNOWN_PRAGMAS - MAPNIK_DISABLE_WARNING_PRAGMAS - MAPNIK_DISABLE_LONG_LONG - if (str_copy == our_strings_[i]) - MAPNIK_DISABLE_WARNING_POP - { - value_ = static_cast(i); - if (deprecated) - { - MAPNIK_LOG_ERROR(enumerations) - << "enumeration value (" << str - << ") using \"_\" is deprecated and will be removed in Mapnik 4.x, use '" << str_copy - << "' instead"; - } - return; - } - } - MAPNIK_DISABLE_WARNING_PUSH - MAPNIK_DISABLE_WARNING_UNKNOWN_PRAGMAS - MAPNIK_DISABLE_WARNING_PRAGMAS - MAPNIK_DISABLE_LONG_LONG - throw illegal_enum_value(std::string("Illegal enumeration value '") + str + "' for enum " + our_name_); - MAPNIK_DISABLE_WARNING_POP - } - - /** Returns the current value as a string identifier. */ - std::string as_string() const - { - MAPNIK_DISABLE_WARNING_PUSH - MAPNIK_DISABLE_WARNING_UNKNOWN_PRAGMAS - MAPNIK_DISABLE_WARNING_PRAGMAS - MAPNIK_DISABLE_LONG_LONG - return our_strings_[value_]; - MAPNIK_DISABLE_WARNING_POP - } - - /** Static helper function to iterate over valid identifiers. */ - static const char* get_string(unsigned i) { return our_strings_[i]; } - - /** Performs some simple checks and quits the application if - * any error is detected. Tries to print helpful error messages. - */ - static bool verify_mapnik_enum(const char* filename, unsigned line_no) - { - for (unsigned i = 0; i < THE_MAX; ++i) - { - if (our_strings_[i] == 0) - { - std::cerr << "### FATAL: Not enough strings for enum " << our_name_ << " defined in file '" << filename - << "' at line " << line_no; - } - } - if (std::string("") != our_strings_[THE_MAX]) - { - std::cerr << "### FATAL: The string array for enum " << our_name_ << " defined in file '" << filename - << "' at line " << line_no << " has too many items or is not terminated with an " - << "empty string"; - } - return true; - } - - private: - ENUM value_; - static const char** our_strings_; - static std::string our_name_; - static bool our_verified_flag_; -}; - -/** ostream operator for enumeration - * @relates mapnik::enumeration - */ -template -std::ostream& operator<<(std::ostream& os, const mapnik::enumeration& e) -{ - return os << e.as_string(); -} - } // namespace mapnik -/** Helper macro. - * @relates mapnik::enumeration - */ -#ifdef _MSC_VER -#define DEFINE_ENUM(name, e) \ - template enumeration; \ - using name = enumeration; -#else -#define DEFINE_ENUM(name, e) \ - using name = enumeration; \ - template<> \ - MAPNIK_DECL const char** name ::our_strings_; \ - template<> \ - MAPNIK_DECL std::string name ::our_name_; \ - template<> \ - MAPNIK_DECL bool name ::our_verified_flag_; -#endif - -/** Helper macro. Runs the verify_mapnik_enum() method during static initialization. - * @relates mapnik::enumeration - */ - -#define IMPLEMENT_ENUM(name, strings) \ - template<> \ - MAPNIK_DECL const char** name ::our_strings_ = strings; \ - template<> \ - MAPNIK_DECL std::string name ::our_name_ = #name; \ - template<> \ - MAPNIK_DECL bool name ::our_verified_flag_(name ::verify_mapnik_enum(__FILE__, __LINE__)); - #endif // MAPNIK_ENUMERATION_HPP diff --git a/include/mapnik/feature_style_processor_impl.hpp b/include/mapnik/feature_style_processor_impl.hpp index 0b569d065..801f3c255 100644 --- a/include/mapnik/feature_style_processor_impl.hpp +++ b/include/mapnik/feature_style_processor_impl.hpp @@ -592,7 +592,7 @@ void feature_style_processor::render_style(Processor& p, util::apply_visitor(symbolizer_dispatch(p, *feature, prj_trans), sym); } } - if (style->get_filter_mode() == FILTER_FIRST) + if (style->get_filter_mode() == filter_mode_enum::FILTER_FIRST) { // Stop iterating over rules and proceed with next feature. do_also = false; diff --git a/include/mapnik/feature_type_style.hpp b/include/mapnik/feature_type_style.hpp index 76a6c1b20..238622021 100644 --- a/include/mapnik/feature_type_style.hpp +++ b/include/mapnik/feature_type_style.hpp @@ -43,7 +43,7 @@ namespace mapnik { class rule; -enum filter_mode_enum { FILTER_ALL, FILTER_FIRST, filter_mode_enum_MAX }; +enum class filter_mode_enum { FILTER_ALL, FILTER_FIRST, filter_mode_enum_MAX }; DEFINE_ENUM(filter_mode_e, filter_mode_enum); diff --git a/include/mapnik/markers_placement.hpp b/include/mapnik/markers_placement.hpp index bb1a09be3..7af01b69c 100644 --- a/include/mapnik/markers_placement.hpp +++ b/include/mapnik/markers_placement.hpp @@ -46,26 +46,26 @@ class markers_placement_finder : util::noncopyable switch (marker_placement_enum(placement_type)) { default: - case MARKER_POINT_PLACEMENT: + case marker_placement_enum::MARKER_POINT_PLACEMENT: construct(&point_, locator, detector, params); break; - case MARKER_ANGLED_POINT_PLACEMENT: + case marker_placement_enum::MARKER_ANGLED_POINT_PLACEMENT: construct(&point_, locator, detector, params); point_.use_angle(true); break; - case MARKER_INTERIOR_PLACEMENT: + case marker_placement_enum::MARKER_INTERIOR_PLACEMENT: construct(&interior_, locator, detector, params); break; - case MARKER_LINE_PLACEMENT: + case marker_placement_enum::MARKER_LINE_PLACEMENT: construct(&line_, locator, detector, params); break; - case MARKER_VERTEX_FIRST_PLACEMENT: + case marker_placement_enum::MARKER_VERTEX_FIRST_PLACEMENT: construct(&vertex_first_, locator, detector, params); break; - case MARKER_VERTEX_LAST_PLACEMENT: + case marker_placement_enum::MARKER_VERTEX_LAST_PLACEMENT: construct(&vertex_last_, locator, detector, params); break; - case MARKER_POLYLABEL_PLACEMENT: + case marker_placement_enum::MARKER_POLYLABEL_PLACEMENT: construct(&polylabel_, locator, detector, params); break; } @@ -73,26 +73,26 @@ class markers_placement_finder : util::noncopyable ~markers_placement_finder() { - switch (marker_placement_enum(placement_type_)) + switch (marker_placement_enum{placement_type_}) { default: - case MARKER_POINT_PLACEMENT: - case MARKER_ANGLED_POINT_PLACEMENT: + case marker_placement_enum::MARKER_POINT_PLACEMENT: + case marker_placement_enum::MARKER_ANGLED_POINT_PLACEMENT: destroy(&point_); break; - case MARKER_INTERIOR_PLACEMENT: + case marker_placement_enum::MARKER_INTERIOR_PLACEMENT: destroy(&interior_); break; - case MARKER_LINE_PLACEMENT: + case marker_placement_enum::MARKER_LINE_PLACEMENT: destroy(&line_); break; - case MARKER_VERTEX_FIRST_PLACEMENT: + case marker_placement_enum::MARKER_VERTEX_FIRST_PLACEMENT: destroy(&vertex_first_); break; - case MARKER_VERTEX_LAST_PLACEMENT: + case marker_placement_enum::MARKER_VERTEX_LAST_PLACEMENT: destroy(&vertex_last_); break; - case MARKER_POLYLABEL_PLACEMENT: + case marker_placement_enum::MARKER_POLYLABEL_PLACEMENT: destroy(&polylabel_); break; } @@ -101,21 +101,21 @@ class markers_placement_finder : util::noncopyable // Get next point where the marker should be placed. Returns true if a place is found, false if none is found. bool get_point(double& x, double& y, double& angle, bool ignore_placement) { - switch (marker_placement_enum(placement_type_)) + switch (marker_placement_enum{placement_type_}) { default: - case MARKER_POINT_PLACEMENT: - case MARKER_ANGLED_POINT_PLACEMENT: + case marker_placement_enum::MARKER_POINT_PLACEMENT: + case marker_placement_enum::MARKER_ANGLED_POINT_PLACEMENT: return point_.get_point(x, y, angle, ignore_placement); - case MARKER_INTERIOR_PLACEMENT: + case marker_placement_enum::MARKER_INTERIOR_PLACEMENT: return interior_.get_point(x, y, angle, ignore_placement); - case MARKER_LINE_PLACEMENT: + case marker_placement_enum::MARKER_LINE_PLACEMENT: return line_.get_point(x, y, angle, ignore_placement); - case MARKER_VERTEX_FIRST_PLACEMENT: + case marker_placement_enum::MARKER_VERTEX_FIRST_PLACEMENT: return vertex_first_.get_point(x, y, angle, ignore_placement); - case MARKER_VERTEX_LAST_PLACEMENT: + case marker_placement_enum::MARKER_VERTEX_LAST_PLACEMENT: return vertex_last_.get_point(x, y, angle, ignore_placement); - case MARKER_POLYLABEL_PLACEMENT: + case marker_placement_enum::MARKER_POLYLABEL_PLACEMENT: return polylabel_.get_point(x, y, angle, ignore_placement); } } diff --git a/include/mapnik/markers_placements/basic.hpp b/include/mapnik/markers_placements/basic.hpp index 44d82509d..7a37cc5a1 100644 --- a/include/mapnik/markers_placements/basic.hpp +++ b/include/mapnik/markers_placements/basic.hpp @@ -32,7 +32,6 @@ #include MAPNIK_DISABLE_WARNING_PUSH #include -#include "agg_basics.h" #include "agg_trans_affine.h" MAPNIK_DISABLE_WARNING_POP @@ -72,32 +71,32 @@ class markers_basic_placement : util::noncopyable { switch (params_.direction) { - case DIRECTION_UP: + case direction_enum::DIRECTION_UP: angle = 0; return true; - case DIRECTION_DOWN: + case direction_enum::DIRECTION_DOWN: angle = util::pi; return true; - case DIRECTION_AUTO: + case direction_enum::DIRECTION_AUTO: angle = util::normalize_angle(angle); if (std::abs(angle) > util::pi / 2) angle += util::pi; return true; - case DIRECTION_AUTO_DOWN: + case direction_enum::DIRECTION_AUTO_DOWN: angle = util::normalize_angle(angle); if (std::abs(angle) < util::pi / 2) angle += util::pi; return true; - case DIRECTION_LEFT: + case direction_enum::DIRECTION_LEFT: angle += util::pi; return true; - case DIRECTION_LEFT_ONLY: + case direction_enum::DIRECTION_LEFT_ONLY: angle = util::normalize_angle(angle + util::pi); return std::fabs(angle) < util::pi / 2; - case DIRECTION_RIGHT_ONLY: + case direction_enum::DIRECTION_RIGHT_ONLY: angle = util::normalize_angle(angle); return std::fabs(angle) < util::pi / 2; - case DIRECTION_RIGHT: + case direction_enum::DIRECTION_RIGHT: default: return true; } diff --git a/include/mapnik/raster_colorizer.hpp b/include/mapnik/raster_colorizer.hpp index 217e6def7..9813c724a 100644 --- a/include/mapnik/raster_colorizer.hpp +++ b/include/mapnik/raster_colorizer.hpp @@ -57,7 +57,7 @@ class feature_impl; class raster; //! \brief Enumerates the modes of interpolation -enum colorizer_mode_enum : std::uint8_t { +enum class colorizer_mode_enum : std::uint8_t { COLORIZER_INHERIT = 0, //!< The stop inherits the mode from the colorizer COLORIZER_LINEAR = 1, //!< Linear interpolation between colors, each channel separately COLORIZER_DISCRETE = 2, //!< Single color for stop @@ -80,7 +80,7 @@ class MAPNIK_DECL colorizer_stop //! \param[in] mode The stop mode //! \param[in] _color The stop color colorizer_stop(float value = 0, - colorizer_mode mode = COLORIZER_INHERIT, + colorizer_mode mode = colorizer_mode_enum::COLORIZER_INHERIT, color const& _color = color(0, 0, 0, 0), std::string const& label = ""); @@ -146,7 +146,8 @@ class MAPNIK_DECL raster_colorizer { public: //! \brief Constructor - raster_colorizer(colorizer_mode mode = COLORIZER_LINEAR, color const& _color = color(0, 0, 0, 0)); + raster_colorizer(colorizer_mode mode = colorizer_mode_enum::COLORIZER_LINEAR, + color const& _color = color(0, 0, 0, 0)); //! \brief Destructor ~raster_colorizer(); @@ -158,7 +159,8 @@ class MAPNIK_DECL raster_colorizer void set_default_mode(colorizer_mode mode) { - default_mode_ = (mode == COLORIZER_INHERIT) ? COLORIZER_LINEAR : static_cast(mode); + default_mode_ = + (mode == colorizer_mode_enum::COLORIZER_INHERIT) ? colorizer_mode_enum::COLORIZER_LINEAR : mode.value_; } void set_default_mode_enum(colorizer_mode_enum mode) { set_default_mode(mode); } diff --git a/include/mapnik/renderer_common/process_point_symbolizer.hpp b/include/mapnik/renderer_common/process_point_symbolizer.hpp index b5a944d68..fc62855ec 100644 --- a/include/mapnik/renderer_common/process_point_symbolizer.hpp +++ b/include/mapnik/renderer_common/process_point_symbolizer.hpp @@ -52,28 +52,28 @@ void render_point_symbolizer(point_symbolizer const& sym, if (!mark->is()) { - value_double opacity = get(sym, feature, common.vars_); - value_bool allow_overlap = get(sym, feature, common.vars_); - value_bool ignore_placement = get(sym, feature, common.vars_); - point_placement_enum placement = + const value_double opacity = get(sym, feature, common.vars_); + const value_bool allow_overlap = get(sym, feature, common.vars_); + const value_bool ignore_placement = get(sym, feature, common.vars_); + const point_placement_enum placement = get(sym, feature, common.vars_); - box2d const& bbox = mark->bounding_box(); - coord2d center = bbox.center(); + const box2d& bbox = mark->bounding_box(); + const coord2d center = bbox.center(); agg::trans_affine tr; - auto image_transform = get_optional(sym, keys::image_transform); + const auto image_transform = get_optional(sym, keys::image_transform); if (image_transform) evaluate_transform(tr, feature, common.vars_, *image_transform, common.scale_factor_); - agg::trans_affine_translation recenter(-center.x, -center.y); - agg::trans_affine recenter_tr = recenter * tr; + const agg::trans_affine_translation recenter(-center.x, -center.y); + const agg::trans_affine recenter_tr = recenter * tr; box2d label_ext = bbox * recenter_tr * agg::trans_affine_scaling(common.scale_factor_); - mapnik::geometry::geometry const& geometry = feature.get_geometry(); + const mapnik::geometry::geometry& geometry = feature.get_geometry(); mapnik::geometry::point pt; geometry::geometry_types type = geometry::geometry_type(geometry); - if (placement == CENTROID_POINT_PLACEMENT || type == geometry::geometry_types::Point || + if (placement == point_placement_enum::CENTROID_POINT_PLACEMENT || type == geometry::geometry_types::Point || type == geometry::geometry_types::MultiPoint) { if (!geometry::centroid(geometry, pt)) diff --git a/include/mapnik/symbolizer.hpp b/include/mapnik/symbolizer.hpp index f6c93a32b..b24dab7e4 100644 --- a/include/mapnik/symbolizer.hpp +++ b/include/mapnik/symbolizer.hpp @@ -147,14 +147,14 @@ struct enum_traits static result_type from_string(std::string const& str) { return simplify_algorithm_from_string(str); } }; -#define ENUM_FROM_STRING(e) \ +#define ENUM_FROM_STRING(alias, e) \ template<> \ struct enum_traits \ { \ using result_type = boost::optional; \ static result_type from_string(std::string const& str) \ { \ - enumeration enum_; \ + enumeration enum_; \ try \ { \ enum_.from_string(str); \ @@ -166,26 +166,25 @@ struct enum_traits } \ } \ }; - -ENUM_FROM_STRING(line_cap_enum) -ENUM_FROM_STRING(line_join_enum) -ENUM_FROM_STRING(point_placement_enum) -ENUM_FROM_STRING(line_rasterizer_enum) -ENUM_FROM_STRING(marker_placement_enum) -ENUM_FROM_STRING(marker_multi_policy_enum) -ENUM_FROM_STRING(debug_symbolizer_mode_enum) -ENUM_FROM_STRING(pattern_alignment_enum) -ENUM_FROM_STRING(halo_rasterizer_enum) -ENUM_FROM_STRING(label_placement_enum) -ENUM_FROM_STRING(vertical_alignment_enum) -ENUM_FROM_STRING(horizontal_alignment_enum) -ENUM_FROM_STRING(justify_alignment_enum) -ENUM_FROM_STRING(text_transform_enum) -ENUM_FROM_STRING(text_upright_enum) -ENUM_FROM_STRING(direction_enum) -ENUM_FROM_STRING(gamma_method_enum) -ENUM_FROM_STRING(line_pattern_enum) -ENUM_FROM_STRING(smooth_algorithm_enum) +ENUM_FROM_STRING(line_cap_e, line_cap_enum) +ENUM_FROM_STRING(line_join_e, line_join_enum) +ENUM_FROM_STRING(point_placement_e, point_placement_enum) +ENUM_FROM_STRING(line_rasterizer_e, line_rasterizer_enum) +ENUM_FROM_STRING(marker_placement_e, marker_placement_enum) +ENUM_FROM_STRING(marker_multi_policy_e, marker_multi_policy_enum) +ENUM_FROM_STRING(debug_symbolizer_mode_e, debug_symbolizer_mode_enum) +ENUM_FROM_STRING(pattern_alignment_e, pattern_alignment_enum) +ENUM_FROM_STRING(halo_rasterizer_e, halo_rasterizer_enum) +ENUM_FROM_STRING(label_placement_e, label_placement_enum) +ENUM_FROM_STRING(vertical_alignment_e, vertical_alignment_enum) +ENUM_FROM_STRING(horizontal_alignment_e, horizontal_alignment_enum) +ENUM_FROM_STRING(justify_alignment_e, justify_alignment_enum) +ENUM_FROM_STRING(text_transform_e, text_transform_enum) +ENUM_FROM_STRING(text_upright_e, text_upright_enum) +ENUM_FROM_STRING(direction_e, direction_enum) +ENUM_FROM_STRING(gamma_method_e, gamma_method_enum) +ENUM_FROM_STRING(line_pattern_e, line_pattern_enum) +ENUM_FROM_STRING(smooth_algorithm_e, smooth_algorithm_enum) // enum template diff --git a/include/mapnik/symbolizer_base.hpp b/include/mapnik/symbolizer_base.hpp index acd92cb32..734a20f50 100644 --- a/include/mapnik/symbolizer_base.hpp +++ b/include/mapnik/symbolizer_base.hpp @@ -69,7 +69,7 @@ struct enumeration_wrapper enumeration_wrapper() = delete; template explicit enumeration_wrapper(T value_) - : value(value_) + : value(static_cast(value_)) {} inline bool operator==(enumeration_wrapper const& rhs) const { return value == rhs.value; } diff --git a/include/mapnik/symbolizer_default_values.hpp b/include/mapnik/symbolizer_default_values.hpp index 1835c04d3..a9b05f45b 100644 --- a/include/mapnik/symbolizer_default_values.hpp +++ b/include/mapnik/symbolizer_default_values.hpp @@ -50,7 +50,7 @@ struct symbolizer_default template<> struct symbolizer_default { - static gamma_method_enum value() { return GAMMA_POWER; } + static gamma_method_enum value() { return gamma_method_enum::GAMMA_POWER; } }; // opacity @@ -64,7 +64,7 @@ struct symbolizer_default template<> struct symbolizer_default { - static pattern_alignment_enum value() { return GLOBAL_ALIGNMENT; } + static pattern_alignment_enum value() { return pattern_alignment_enum::GLOBAL_ALIGNMENT; } }; // offset @@ -127,14 +127,14 @@ struct symbolizer_default template<> struct symbolizer_default { - static line_join_enum value() { return MITER_JOIN; } + static line_join_enum value() { return line_join_enum::MITER_JOIN; } }; // stroke-linecap template<> struct symbolizer_default { - static line_cap_enum value() { return BUTT_CAP; } + static line_cap_enum value() { return line_cap_enum::BUTT_CAP; } }; // stroke-gamma @@ -148,7 +148,7 @@ struct symbolizer_default template<> struct symbolizer_default { - static gamma_method_enum value() { return GAMMA_POWER; } + static gamma_method_enum value() { return gamma_method_enum::GAMMA_POWER; } }; // stroke-dashoffset @@ -173,7 +173,7 @@ struct symbolizer_default template<> struct symbolizer_default { - static line_rasterizer_enum value() { return RASTERIZER_FULL; } + static line_rasterizer_enum value() { return line_rasterizer_enum::RASTERIZER_FULL; } }; // transform @@ -315,7 +315,7 @@ struct symbolizer_default template<> struct symbolizer_default { - static halo_rasterizer_enum value() { return HALO_RASTERIZER_FULL; } + static halo_rasterizer_enum value() { return halo_rasterizer_enum::HALO_RASTERIZER_FULL; } }; // text-placements @@ -324,28 +324,28 @@ struct symbolizer_default template<> struct symbolizer_default { - static point_placement_enum value() { return CENTROID_POINT_PLACEMENT; } + static point_placement_enum value() { return point_placement_enum::CENTROID_POINT_PLACEMENT; } }; // marker placement template<> struct symbolizer_default { - static marker_placement_enum value() { return MARKER_POINT_PLACEMENT; } + static marker_placement_enum value() { return marker_placement_enum::MARKER_POINT_PLACEMENT; } }; // multi-policy template<> struct symbolizer_default { - static marker_multi_policy_enum value() { return MARKER_EACH_MULTI; } + static marker_multi_policy_enum value() { return marker_multi_policy_enum::MARKER_EACH_MULTI; } }; // direction template<> struct symbolizer_default { - static direction_enum value() { return DIRECTION_RIGHT; } + static direction_enum value() { return direction_enum::DIRECTION_RIGHT; } }; // placement @@ -380,7 +380,7 @@ struct symbolizer_default template<> struct symbolizer_default { - static line_pattern_enum value() { return LINE_PATTERN_WARP; } + static line_pattern_enum value() { return line_pattern_enum::LINE_PATTERN_WARP; } }; // extend @@ -393,7 +393,7 @@ struct symbolizer_default template<> struct symbolizer_default { - static smooth_algorithm_enum value() { return SMOOTH_ALGORITHM_BASIC; } + static smooth_algorithm_enum value() { return smooth_algorithm_enum::SMOOTH_ALGORITHM_BASIC; } }; } // namespace mapnik diff --git a/include/mapnik/symbolizer_enumerations.hpp b/include/mapnik/symbolizer_enumerations.hpp index 6131f0e46..8c2477f67 100644 --- a/include/mapnik/symbolizer_enumerations.hpp +++ b/include/mapnik/symbolizer_enumerations.hpp @@ -27,50 +27,43 @@ namespace mapnik { -enum line_cap_enum : std::uint8_t { BUTT_CAP, SQUARE_CAP, ROUND_CAP, line_cap_enum_MAX }; - +enum class line_cap_enum : std::uint8_t { BUTT_CAP, SQUARE_CAP, ROUND_CAP, line_cap_enum_MAX }; DEFINE_ENUM(line_cap_e, line_cap_enum); -enum line_join_enum : std::uint8_t { MITER_JOIN, MITER_REVERT_JOIN, ROUND_JOIN, BEVEL_JOIN, line_join_enum_MAX }; - +enum class line_join_enum : std::uint8_t { MITER_JOIN, MITER_REVERT_JOIN, ROUND_JOIN, BEVEL_JOIN, line_join_enum_MAX }; DEFINE_ENUM(line_join_e, line_join_enum); -enum line_rasterizer_enum : std::uint8_t { +enum class line_rasterizer_enum : std::uint8_t { RASTERIZER_FULL, // agg::renderer_scanline_aa_solid RASTERIZER_FAST, // agg::rasterizer_outline_aa, twice as fast but only good for thin lines line_rasterizer_enum_MAX }; - DEFINE_ENUM(line_rasterizer_e, line_rasterizer_enum); -enum halo_rasterizer_enum : std::uint8_t { HALO_RASTERIZER_FULL, HALO_RASTERIZER_FAST, halo_rasterizer_enum_MAX }; - +enum class halo_rasterizer_enum : std::uint8_t { HALO_RASTERIZER_FULL, HALO_RASTERIZER_FAST, halo_rasterizer_enum_MAX }; DEFINE_ENUM(halo_rasterizer_e, halo_rasterizer_enum); -enum point_placement_enum : std::uint8_t { +enum class point_placement_enum : std::uint8_t { CENTROID_POINT_PLACEMENT, INTERIOR_POINT_PLACEMENT, point_placement_enum_MAX }; - DEFINE_ENUM(point_placement_e, point_placement_enum); -enum pattern_alignment_enum : std::uint8_t { LOCAL_ALIGNMENT, GLOBAL_ALIGNMENT, pattern_alignment_enum_MAX }; - +enum class pattern_alignment_enum : std::uint8_t { LOCAL_ALIGNMENT, GLOBAL_ALIGNMENT, pattern_alignment_enum_MAX }; DEFINE_ENUM(pattern_alignment_e, pattern_alignment_enum); -enum debug_symbolizer_mode_enum : std::uint8_t { +enum class debug_symbolizer_mode_enum : std::uint8_t { DEBUG_SYM_MODE_COLLISION, DEBUG_SYM_MODE_VERTEX, DEBUG_SYM_MODE_RINGS, debug_symbolizer_mode_enum_MAX }; - DEFINE_ENUM(debug_symbolizer_mode_e, debug_symbolizer_mode_enum); // markers // TODO - consider merging with text_symbolizer label_placement_e -enum marker_placement_enum : std::uint8_t { +enum class marker_placement_enum : std::uint8_t { MARKER_POINT_PLACEMENT, MARKER_INTERIOR_PLACEMENT, MARKER_LINE_PLACEMENT, @@ -80,19 +73,17 @@ enum marker_placement_enum : std::uint8_t { MARKER_POLYLABEL_PLACEMENT, marker_placement_enum_MAX }; - DEFINE_ENUM(marker_placement_e, marker_placement_enum); -enum marker_multi_policy_enum : std::uint8_t { +enum class marker_multi_policy_enum : std::uint8_t { MARKER_EACH_MULTI, // each component in a multi gets its marker MARKER_WHOLE_MULTI, // consider all components of a multi as a whole MARKER_LARGEST_MULTI, // only the largest component of a multi gets a marker marker_multi_policy_enum_MAX }; - DEFINE_ENUM(marker_multi_policy_e, marker_multi_policy_enum); -enum text_transform_enum : std::uint8_t { +enum class text_transform_enum : std::uint8_t { NONE = 0, UPPERCASE, LOWERCASE, @@ -100,10 +91,9 @@ enum text_transform_enum : std::uint8_t { REVERSE, text_transform_enum_MAX }; - DEFINE_ENUM(text_transform_e, text_transform_enum); -enum label_placement_enum : std::uint8_t { +enum class label_placement_enum : std::uint8_t { POINT_PLACEMENT, LINE_PLACEMENT, VERTEX_PLACEMENT, @@ -113,14 +103,18 @@ enum label_placement_enum : std::uint8_t { ALTERNATING_GRID_PLACEMENT, label_placement_enum_MAX }; - DEFINE_ENUM(label_placement_e, label_placement_enum); -enum vertical_alignment_enum : std::uint8_t { V_TOP = 0, V_MIDDLE, V_BOTTOM, V_AUTO, vertical_alignment_enum_MAX }; - +enum class vertical_alignment_enum : std::uint8_t { + V_TOP = 0, + V_MIDDLE, + V_BOTTOM, + V_AUTO, + vertical_alignment_enum_MAX +}; DEFINE_ENUM(vertical_alignment_e, vertical_alignment_enum); -enum horizontal_alignment_enum : std::uint8_t { +enum class horizontal_alignment_enum : std::uint8_t { H_LEFT = 0, H_MIDDLE, H_RIGHT, @@ -128,14 +122,12 @@ enum horizontal_alignment_enum : std::uint8_t { H_ADJUST, horizontal_alignment_enum_MAX }; - DEFINE_ENUM(horizontal_alignment_e, horizontal_alignment_enum); -enum justify_alignment_enum : std::uint8_t { J_LEFT = 0, J_MIDDLE, J_RIGHT, J_AUTO, justify_alignment_enum_MAX }; - +enum class justify_alignment_enum : std::uint8_t { J_LEFT = 0, J_MIDDLE, J_RIGHT, J_AUTO, justify_alignment_enum_MAX }; DEFINE_ENUM(justify_alignment_e, justify_alignment_enum); -enum text_upright_enum : std::uint8_t { +enum class text_upright_enum : std::uint8_t { UPRIGHT_AUTO, UPRIGHT_AUTO_DOWN, UPRIGHT_LEFT, @@ -144,10 +136,9 @@ enum text_upright_enum : std::uint8_t { UPRIGHT_RIGHT_ONLY, text_upright_enum_MAX }; - DEFINE_ENUM(text_upright_e, text_upright_enum); -enum direction_enum : std::uint8_t { +enum class direction_enum : std::uint8_t { DIRECTION_LEFT, DIRECTION_RIGHT, DIRECTION_LEFT_ONLY, @@ -158,10 +149,9 @@ enum direction_enum : std::uint8_t { DIRECTION_DOWN, direction_enum_MAX }; - DEFINE_ENUM(direction_e, direction_enum); -enum gamma_method_enum : std::uint8_t { +enum class gamma_method_enum : std::uint8_t { GAMMA_POWER, // agg::gamma_power GAMMA_LINEAR, // agg::gamma_linear GAMMA_NONE, // agg::gamma_none @@ -169,19 +159,16 @@ enum gamma_method_enum : std::uint8_t { GAMMA_MULTIPLY, // agg::gamma_multiply gamma_method_enum_MAX }; - DEFINE_ENUM(gamma_method_e, gamma_method_enum); -enum line_pattern_enum : std::uint8_t { LINE_PATTERN_WARP, LINE_PATTERN_REPEAT, line_pattern_enum_MAX }; - +enum class line_pattern_enum : std::uint8_t { LINE_PATTERN_WARP, LINE_PATTERN_REPEAT, line_pattern_enum_MAX }; DEFINE_ENUM(line_pattern_e, line_pattern_enum); -enum smooth_algorithm_enum : std::uint8_t { +enum class smooth_algorithm_enum : std::uint8_t { SMOOTH_ALGORITHM_BASIC = 0, SMOOTH_ALGORITHM_ADAPTIVE, smooth_algorithm_enum_MAX }; - DEFINE_ENUM(smooth_algorithm_e, smooth_algorithm_enum); } // namespace mapnik diff --git a/include/mapnik/text/placement_finder_impl.hpp b/include/mapnik/text/placement_finder_impl.hpp index 432271b5f..fa8411402 100644 --- a/include/mapnik/text/placement_finder_impl.hpp +++ b/include/mapnik/text/placement_finder_impl.hpp @@ -65,12 +65,14 @@ bool placement_finder::find_line_placements(T& path, bool points) // horizontal_alignment_e halign = layouts_.back()->horizontal_alignment(); // halign == H_LEFT -> don't move - if (horizontal_alignment_ == H_MIDDLE || horizontal_alignment_ == H_AUTO || horizontal_alignment_ == H_ADJUST) + if (horizontal_alignment_ == horizontal_alignment_enum::H_MIDDLE || + horizontal_alignment_ == horizontal_alignment_enum::H_AUTO || + horizontal_alignment_ == horizontal_alignment_enum::H_ADJUST) { if (!pp.forward(spacing / 2.0)) continue; } - else if (horizontal_alignment_ == H_RIGHT) + else if (horizontal_alignment_ == horizontal_alignment_enum::H_RIGHT) { if (!pp.forward(pp.length())) continue; diff --git a/include/mapnik/text/properties_util.hpp b/include/mapnik/text/properties_util.hpp index 1cd4a0136..ade172348 100644 --- a/include/mapnik/text/properties_util.hpp +++ b/include/mapnik/text/properties_util.hpp @@ -46,7 +46,7 @@ struct is_mapnik_enumeration }; template -struct is_mapnik_enumeration::value>::type> +struct is_mapnik_enumeration::value>> { static constexpr bool value = true; }; @@ -117,7 +117,7 @@ struct set_property_from_xml_impl { target_enum_type e; e.from_string(*enum_str); - val = enumeration_wrapper(e); + val = enumeration_wrapper(e.value_); } } catch (...) diff --git a/include/mapnik/text/text_properties.hpp b/include/mapnik/text/text_properties.hpp index 187f3082e..7e157d24a 100644 --- a/include/mapnik/text/text_properties.hpp +++ b/include/mapnik/text/text_properties.hpp @@ -159,7 +159,7 @@ struct MAPNIK_DECL text_layout_properties struct text_properties_expressions { - symbolizer_base::value_type label_placement = enumeration_wrapper(POINT_PLACEMENT); + symbolizer_base::value_type label_placement = enumeration_wrapper(label_placement_enum::POINT_PLACEMENT); symbolizer_base::value_type label_spacing = 0.0; symbolizer_base::value_type label_position_tolerance = 0.0; symbolizer_base::value_type avoid_edges = false; @@ -171,7 +171,7 @@ struct text_properties_expressions symbolizer_base::value_type max_char_angle_delta = 22.5; symbolizer_base::value_type allow_overlap = false; symbolizer_base::value_type largest_bbox_only = true; - symbolizer_base::value_type upright = enumeration_wrapper(UPRIGHT_AUTO); + symbolizer_base::value_type upright = enumeration_wrapper(text_upright_enum::UPRIGHT_AUTO); symbolizer_base::value_type grid_cell_width = 0.0; symbolizer_base::value_type grid_cell_height = 0.0; }; diff --git a/include/mapnik/vertex_converters.hpp b/include/mapnik/vertex_converters.hpp index c56ba5a0d..c52daea9a 100644 --- a/include/mapnik/vertex_converters.hpp +++ b/include/mapnik/vertex_converters.hpp @@ -46,7 +46,6 @@ MAPNIK_DISABLE_WARNING_PUSH #include "agg_trans_affine.h" #include "agg_conv_clip_polygon.h" #include "agg_conv_clip_polyline.h" -#include "agg_conv_smooth_poly1.h" #include "agg_conv_stroke.h" #include "agg_conv_dash.h" #include "agg_conv_transform.h" @@ -156,30 +155,29 @@ struct converter_traits template void set_join_caps(Symbolizer const& sym, PathType& stroke, Feature const& feature, attributes const& vars) { - line_join_enum join = get(sym, feature, vars); + const line_join_enum join = get(sym, feature, vars); switch (join) { - case MITER_JOIN: + case line_join_enum::MITER_JOIN: stroke.generator().line_join(agg::miter_join); break; - case MITER_REVERT_JOIN: + case line_join_enum::MITER_REVERT_JOIN: stroke.generator().line_join(agg::miter_join); break; - case ROUND_JOIN: + case line_join_enum::ROUND_JOIN: stroke.generator().line_join(agg::round_join); break; default: stroke.generator().line_join(agg::bevel_join); } - line_cap_enum cap = get(sym, feature, vars); - + const line_cap_enum cap = get(sym, feature, vars); switch (cap) { - case BUTT_CAP: + case line_cap_enum::BUTT_CAP: stroke.generator().line_cap(agg::butt_cap); break; - case SQUARE_CAP: + case line_cap_enum::SQUARE_CAP: stroke.generator().line_cap(agg::square_cap); break; default: diff --git a/include/mapnik/well_known_srs.hpp b/include/mapnik/well_known_srs.hpp index 863768ea3..fe5a1772c 100644 --- a/include/mapnik/well_known_srs.hpp +++ b/include/mapnik/well_known_srs.hpp @@ -39,8 +39,7 @@ MAPNIK_DISABLE_WARNING_POP namespace mapnik { -enum well_known_srs_enum : std::uint8_t { WGS_84, WEB_MERC, well_known_srs_enum_MAX }; - +enum class well_known_srs_enum : std::uint8_t { WGS_84, WEB_MERC, well_known_srs_enum_MAX }; DEFINE_ENUM(well_known_srs_e, well_known_srs_enum); constexpr double EARTH_RADIUS = 6378137.0; diff --git a/include/mapnik/xml_attribute_cast.hpp b/include/mapnik/xml_attribute_cast.hpp index a2b434ea5..a39938e75 100644 --- a/include/mapnik/xml_attribute_cast.hpp +++ b/include/mapnik/xml_attribute_cast.hpp @@ -161,17 +161,20 @@ struct do_xml_attribute_cast } }; -// specialization for mapnik::enumeration -template -struct do_xml_attribute_cast> +// specialization for mapnik::enumeration<...> +template (*F_LOOKUP)()> +struct do_xml_attribute_cast> { - static inline boost::optional> xml_attribute_cast_impl(xml_tree const& /*tree*/, - std::string const& source) + using Enum = mapnik::enumeration; + static inline boost::optional xml_attribute_cast_impl(xml_tree const& /*tree*/, std::string const& source) { - using result_type = typename boost::optional>; + using result_type = typename boost::optional; try { - mapnik::enumeration e; + Enum e; e.from_string(source); return result_type(e); } diff --git a/src/agg/agg_renderer.cpp b/src/agg/agg_renderer.cpp index 812591b23..debd94a58 100644 --- a/src/agg/agg_renderer.cpp +++ b/src/agg/agg_renderer.cpp @@ -51,7 +51,6 @@ MAPNIK_DISABLE_WARNING_PUSH #include "agg_color_rgba.h" #include "agg_scanline_u.h" #include "agg_image_filters.h" -#include "agg_trans_bilinear.h" #include "agg_span_allocator.h" #include "agg_image_accessors.h" #include "agg_span_image_filter_rgba.h" @@ -74,8 +73,8 @@ agg_renderer::agg_renderer(Map const& m, T0& pixmap, double scale_factor , buffers_() , internal_buffers_(m.width(), m.height()) , inflated_buffer_() - , ras_ptr(new rasterizer) - , gamma_method_(GAMMA_POWER) + , ras_ptr(std::make_unique()) + , gamma_method_(gamma_method_enum::GAMMA_POWER) , gamma_(1.0) , common_(m, attributes(), offset_x, offset_y, m.width(), m.height(), scale_factor) { @@ -94,8 +93,8 @@ agg_renderer::agg_renderer(Map const& m, , buffers_() , internal_buffers_(req.width(), req.height()) , inflated_buffer_() - , ras_ptr(new rasterizer) - , gamma_method_(GAMMA_POWER) + , ras_ptr(std::make_unique()) + , gamma_method_(gamma_method_enum::GAMMA_POWER) , gamma_(1.0) , common_(m, req, vars, offset_x, offset_y, req.width(), req.height(), scale_factor) { @@ -113,8 +112,8 @@ agg_renderer::agg_renderer(Map const& m, , buffers_() , internal_buffers_(m.width(), m.height()) , inflated_buffer_() - , ras_ptr(new rasterizer) - , gamma_method_(GAMMA_POWER) + , ras_ptr(std::make_unique()) + , gamma_method_(gamma_method_enum::GAMMA_POWER) , gamma_(1.0) , common_(m, attributes(), offset_x, offset_y, m.width(), m.height(), scale_factor, detector) { @@ -405,10 +404,10 @@ struct agg_render_marker_visitor using renderer_type = agg::renderer_scanline_aa_solid; ras_ptr_->reset(); - if (gamma_method_ != GAMMA_POWER || gamma_ != 1.0) + if (gamma_method_ != gamma_method_enum::GAMMA_POWER || gamma_ != 1.0) { ras_ptr_->gamma(agg::gamma_power()); - gamma_method_ = GAMMA_POWER; + gamma_method_ = gamma_method_enum::GAMMA_POWER; gamma_ = 1.0; } agg::scanline_u8 sl; @@ -451,10 +450,10 @@ struct agg_render_marker_visitor using renderer_base = agg::renderer_base; ras_ptr_->reset(); - if (gamma_method_ != GAMMA_POWER || gamma_ != 1.0) + if (gamma_method_ != gamma_method_enum::GAMMA_POWER || gamma_ != 1.0) { ras_ptr_->gamma(agg::gamma_power()); - gamma_method_ = GAMMA_POWER; + gamma_method_ = gamma_method_enum::GAMMA_POWER; gamma_ = 1.0; } agg::scanline_u8 sl; diff --git a/src/agg/process_debug_symbolizer.cpp b/src/agg/process_debug_symbolizer.cpp index cbe761ebd..b00d29944 100644 --- a/src/agg/process_debug_symbolizer.cpp +++ b/src/agg/process_debug_symbolizer.cpp @@ -221,30 +221,34 @@ void agg_renderer::process(debug_symbolizer const& sym, proj_transform const& prj_trans) { debug_symbolizer_mode_enum mode = - get(sym, keys::mode, feature, common_.vars_, DEBUG_SYM_MODE_COLLISION); + get(sym, + keys::mode, + feature, + common_.vars_, + debug_symbolizer_mode_enum::DEBUG_SYM_MODE_COLLISION); ras_ptr->reset(); - if (gamma_method_ != GAMMA_POWER || gamma_ != 1.0) + if (gamma_method_ != gamma_method_enum::GAMMA_POWER || gamma_ != 1.0) { ras_ptr->gamma(agg::gamma_power()); - gamma_method_ = GAMMA_POWER; + gamma_method_ = gamma_method_enum::GAMMA_POWER; gamma_ = 1.0; } - if (mode == DEBUG_SYM_MODE_RINGS) + if (mode == debug_symbolizer_mode_enum::DEBUG_SYM_MODE_RINGS) { RingRenderer renderer(*ras_ptr, buffers_.top().get(), common_.t_, prj_trans); render_ring_visitor apply(renderer); mapnik::util::apply_visitor(apply, feature.get_geometry()); } - else if (mode == DEBUG_SYM_MODE_COLLISION) + else if (mode == debug_symbolizer_mode_enum::DEBUG_SYM_MODE_COLLISION) { for (auto const& n : *common_.detector_) { draw_rect(buffers_.top().get(), n.get().box); } } - else if (mode == DEBUG_SYM_MODE_VERTEX) + else if (mode == debug_symbolizer_mode_enum::DEBUG_SYM_MODE_VERTEX) { using apply_vertex_mode = apply_vertex_mode; apply_vertex_mode apply(buffers_.top().get(), common_.t_, prj_trans); diff --git a/src/agg/process_dot_symbolizer.cpp b/src/agg/process_dot_symbolizer.cpp index 97a328a9d..8c424e210 100644 --- a/src/agg/process_dot_symbolizer.cpp +++ b/src/agg/process_dot_symbolizer.cpp @@ -102,8 +102,8 @@ void agg_renderer::process(dot_symbolizer const& sym, { double width = 0.0; double height = 0.0; - bool has_width = has_key(sym, keys::width); - bool has_height = has_key(sym, keys::height); + const bool has_width = has_key(sym, keys::width); + const bool has_height = has_key(sym, keys::height); if (has_width && has_height) { width = get(sym, keys::width, feature, common_.vars_, 0.0); @@ -117,15 +117,15 @@ void agg_renderer::process(dot_symbolizer const& sym, { width = height = get(sym, keys::height, feature, common_.vars_, 0.0); } - double rx = width / 2.0 * common_.scale_factor_; - double ry = height / 2.0 * common_.scale_factor_; - double opacity = get(sym, keys::opacity, feature, common_.vars_, 1.0); - color const& fill = get(sym, keys::fill, feature, common_.vars_, mapnik::color(128, 128, 128)); + const double rx = width / 2.0 * common_.scale_factor_; + const double ry = height / 2.0 * common_.scale_factor_; + const double opacity = get(sym, keys::opacity, feature, common_.vars_, 1.0); + const color& fill = get(sym, keys::fill, feature, common_.vars_, mapnik::color(128, 128, 128)); ras_ptr->reset(); - if (gamma_method_ != GAMMA_POWER || gamma_ != 1.0) + if (gamma_method_ != gamma_method_enum::GAMMA_POWER || gamma_ != 1.0) { ras_ptr->gamma(agg::gamma_power()); - gamma_method_ = GAMMA_POWER; + gamma_method_ = gamma_method_enum::GAMMA_POWER; gamma_ = 1.0; } buffer_type& current_buffer = buffers_.top().get(); diff --git a/src/agg/process_group_symbolizer.cpp b/src/agg/process_group_symbolizer.cpp index 4bdba7098..77d9689b4 100644 --- a/src/agg/process_group_symbolizer.cpp +++ b/src/agg/process_group_symbolizer.cpp @@ -68,7 +68,12 @@ struct thunk_renderer : render_thunk_list_dispatch , ras_ptr_(ras_ptr) , buf_(buf) , common_(common) - , tex_(buf, HALO_RASTERIZER_FULL, src_over, src_over, common.scale_factor_, common.font_manager_.get_stroker()) + , tex_(buf, + halo_rasterizer_enum::HALO_RASTERIZER_FULL, + src_over, + src_over, + common.scale_factor_, + common.font_manager_.get_stroker()) {} virtual void operator()(vector_marker_render_thunk const& thunk) diff --git a/src/agg/process_line_pattern_symbolizer.cpp b/src/agg/process_line_pattern_symbolizer.cpp index a21217460..90dfe43fa 100644 --- a/src/agg/process_line_pattern_symbolizer.cpp +++ b/src/agg/process_line_pattern_symbolizer.cpp @@ -45,15 +45,9 @@ MAPNIK_DISABLE_WARNING_PUSH #include "agg_pixfmt_rgba.h" #include "agg_color_rgba.h" #include "agg_rendering_buffer.h" -#include "agg_rasterizer_outline.h" #include "agg_rasterizer_outline_aa.h" -#include "agg_scanline_u.h" -#include "agg_renderer_scanline.h" #include "agg_pattern_filters_rgba.h" -#include "agg_span_allocator.h" -#include "agg_span_pattern_rgba.h" #include "agg_renderer_outline_image.h" -#include "agg_image_accessors.h" MAPNIK_DISABLE_WARNING_POP namespace mapnik { @@ -216,17 +210,17 @@ struct agg_renderer_process_visitor_l line_pattern_enum pattern = get(sym_, feature_, common_.vars_); switch (pattern) { - case LINE_PATTERN_WARP: { + case line_pattern_enum::LINE_PATTERN_WARP: { warp_pattern pattern(pattern_image, common_, sym_, feature_, prj_trans_); render(pattern); break; } - case LINE_PATTERN_REPEAT: { + case line_pattern_enum::LINE_PATTERN_REPEAT: { repeat_pattern pattern(pattern_image, common_, sym_, feature_, prj_trans_); render(pattern); break; } - case line_pattern_enum_MAX: + case line_pattern_enum::line_pattern_enum_MAX: default: MAPNIK_LOG_ERROR(process_line_pattern_symbolizer) << "Incorrect line-pattern value."; } @@ -265,10 +259,10 @@ void agg_renderer::process(line_pattern_symbolizer const& sym, if (filename.empty()) return; ras_ptr->reset(); - if (gamma_method_ != GAMMA_POWER || gamma_ != 1.0) + if (gamma_method_ != gamma_method_enum::GAMMA_POWER || gamma_ != 1.0) { ras_ptr->gamma(agg::gamma_power()); - gamma_method_ = GAMMA_POWER; + gamma_method_ = gamma_method_enum::GAMMA_POWER; gamma_ = 1.0; } diff --git a/src/agg/process_line_symbolizer.cpp b/src/agg/process_line_symbolizer.cpp index cb48d3297..a6c4adb90 100644 --- a/src/agg/process_line_symbolizer.cpp +++ b/src/agg/process_line_symbolizer.cpp @@ -43,9 +43,6 @@ MAPNIK_DISABLE_WARNING_PUSH #include "agg_rasterizer_scanline_aa.h" #include "agg_scanline_u.h" #include "agg_renderer_scanline.h" -#include "agg_scanline_p.h" -#include "agg_conv_stroke.h" -#include "agg_conv_dash.h" #include "agg_renderer_outline_aa.h" #include "agg_rasterizer_outline_aa.h" MAPNIK_DISABLE_WARNING_POP @@ -59,30 +56,29 @@ namespace mapnik { template void set_join_caps_aa(Symbolizer const& sym, Rasterizer& ras, Feature& feature, attributes const& vars) { - line_join_enum join = get(sym, feature, vars); + const line_join_enum join = get(sym, feature, vars); switch (join) { - case MITER_JOIN: + case line_join_enum::MITER_JOIN: ras.line_join(agg::outline_miter_accurate_join); break; - case MITER_REVERT_JOIN: + case line_join_enum::MITER_REVERT_JOIN: ras.line_join(agg::outline_no_join); break; - case ROUND_JOIN: + case line_join_enum::ROUND_JOIN: ras.line_join(agg::outline_round_join); break; default: ras.line_join(agg::outline_no_join); } - line_cap_enum cap = get(sym, feature, vars); - + const line_cap_enum cap = get(sym, feature, vars); switch (cap) { - case BUTT_CAP: + case line_cap_enum::BUTT_CAP: ras.round_cap(false); break; - case SQUARE_CAP: + case line_cap_enum::SQUARE_CAP: ras.round_cap(false); break; default: @@ -97,10 +93,10 @@ void agg_renderer::process(line_symbolizer const& sym, { color const& col = get(sym, feature, common_.vars_); - unsigned r = col.red(); - unsigned g = col.green(); - unsigned b = col.blue(); - unsigned a = col.alpha(); + const unsigned r = col.red(); + const unsigned g = col.green(); + const unsigned b = col.blue(); + const unsigned a = col.alpha(); double gamma = get(sym, feature, common_.vars_); gamma_method_enum gamma_method = get(sym, feature, common_.vars_); @@ -136,13 +132,14 @@ void agg_renderer::process(line_symbolizer const& sym, box2d clip_box = clipping_extent(common_); - value_bool clip = get(sym, feature, common_.vars_); - value_double width = get(sym, feature, common_.vars_); - value_double opacity = get(sym, feature, common_.vars_); - value_double offset = get(sym, feature, common_.vars_); - value_double simplify_tolerance = get(sym, feature, common_.vars_); - value_double smooth = get(sym, feature, common_.vars_); - line_rasterizer_enum rasterizer_e = get(sym, feature, common_.vars_); + const value_bool clip = get(sym, feature, common_.vars_); + const value_double width = get(sym, feature, common_.vars_); + const value_double opacity = get(sym, feature, common_.vars_); + const value_double offset = get(sym, feature, common_.vars_); + const value_double simplify_tolerance = get(sym, feature, common_.vars_); + const value_double smooth = get(sym, feature, common_.vars_); + const line_rasterizer_enum rasterizer_e = + get(sym, feature, common_.vars_); if (clip) { double pad_per_pixel = static_cast(common_.query_extent_.width() / common_.width_); @@ -153,7 +150,7 @@ void agg_renderer::process(line_symbolizer const& sym, clip_box.pad(padding); } - if (rasterizer_e == RASTERIZER_FAST) + if (rasterizer_e == line_rasterizer_enum::RASTERIZER_FAST) { using renderer_type = agg::renderer_outline_aa; using rasterizer_type = agg::rasterizer_outline_aa; diff --git a/src/agg/process_polygon_symbolizer.cpp b/src/agg/process_polygon_symbolizer.cpp index 9711159a7..63c146acc 100644 --- a/src/agg/process_polygon_symbolizer.cpp +++ b/src/agg/process_polygon_symbolizer.cpp @@ -55,9 +55,9 @@ void agg_renderer::process(polygon_symbolizer const& sym, vertex_converter; ras_ptr->reset(); - double gamma = get(sym, keys::gamma, feature, common_.vars_, 1.0); + const double gamma = get(sym, keys::gamma, feature, common_.vars_, 1.0); gamma_method_enum gamma_method = - get(sym, keys::gamma_method, feature, common_.vars_, GAMMA_POWER); + get(sym, keys::gamma_method, feature, common_.vars_, gamma_method_enum::GAMMA_POWER); if (gamma != gamma_ || gamma_method != gamma_method_) { set_gamma_method(ras_ptr, gamma, gamma_method); diff --git a/src/agg/process_shield_symbolizer.cpp b/src/agg/process_shield_symbolizer.cpp index a88cae52f..222f577a9 100644 --- a/src/agg/process_shield_symbolizer.cpp +++ b/src/agg/process_shield_symbolizer.cpp @@ -37,28 +37,32 @@ void agg_renderer::process(shield_symbolizer const& sym, mapnik::feature_impl& feature, proj_transform const& prj_trans) { - box2d clip_box = clipping_extent(common_); + const box2d clip_box = clipping_extent(common_); agg::trans_affine tr; - auto transform = get_optional(sym, keys::geometry_transform); + const auto transform = get_optional(sym, keys::geometry_transform); if (transform) evaluate_transform(tr, feature, common_.vars_, *transform, common_.scale_factor_); - text_symbolizer_helper helper(sym, - feature, - common_.vars_, - prj_trans, - common_.width_, - common_.height_, - common_.scale_factor_, - common_.t_, - common_.font_manager_, - *common_.detector_, - clip_box, - tr); + const text_symbolizer_helper helper(sym, + feature, + common_.vars_, + prj_trans, + common_.width_, + common_.height_, + common_.scale_factor_, + common_.t_, + common_.font_manager_, + *common_.detector_, + clip_box, + tr); - halo_rasterizer_enum halo_rasterizer = - get(sym, keys::halo_rasterizer, feature, common_.vars_, HALO_RASTERIZER_FULL); - composite_mode_e comp_op = get(sym, keys::comp_op, feature, common_.vars_, src_over); - composite_mode_e halo_comp_op = get(sym, keys::halo_comp_op, feature, common_.vars_, src_over); + const halo_rasterizer_enum halo_rasterizer = get(sym, + keys::halo_rasterizer, + feature, + common_.vars_, + halo_rasterizer_enum::HALO_RASTERIZER_FULL); + const composite_mode_e comp_op = get(sym, keys::comp_op, feature, common_.vars_, src_over); + const composite_mode_e halo_comp_op = + get(sym, keys::halo_comp_op, feature, common_.vars_, src_over); agg_text_renderer ren(buffers_.top().get(), halo_rasterizer, comp_op, @@ -66,12 +70,12 @@ void agg_renderer::process(shield_symbolizer const& sym, common_.scale_factor_, common_.font_manager_.get_stroker()); - double opacity = get(sym, keys::opacity, feature, common_.vars_, 1.0); + const double opacity = get(sym, keys::opacity, feature, common_.vars_, 1.0); placements_list const& placements = helper.get(); for (auto const& glyphs : placements) { - marker_info_ptr mark = glyphs->get_marker(); + const marker_info_ptr mark = glyphs->get_marker(); if (mark) { render_marker(glyphs->marker_pos(), *mark->marker_, mark->transform_, opacity, comp_op); diff --git a/src/agg/process_text_symbolizer.cpp b/src/agg/process_text_symbolizer.cpp index 7a8dbec02..54bb45660 100644 --- a/src/agg/process_text_symbolizer.cpp +++ b/src/agg/process_text_symbolizer.cpp @@ -37,28 +37,32 @@ void agg_renderer::process(text_symbolizer const& sym, mapnik::feature_impl& feature, proj_transform const& prj_trans) { - box2d clip_box = clipping_extent(common_); + const box2d clip_box = clipping_extent(common_); agg::trans_affine tr; - auto transform = get_optional(sym, keys::geometry_transform); + const auto transform = get_optional(sym, keys::geometry_transform); if (transform) evaluate_transform(tr, feature, common_.vars_, *transform, common_.scale_factor_); - text_symbolizer_helper helper(sym, - feature, - common_.vars_, - prj_trans, - common_.width_, - common_.height_, - common_.scale_factor_, - common_.t_, - common_.font_manager_, - *common_.detector_, - clip_box, - tr); + const text_symbolizer_helper helper(sym, + feature, + common_.vars_, + prj_trans, + common_.width_, + common_.height_, + common_.scale_factor_, + common_.t_, + common_.font_manager_, + *common_.detector_, + clip_box, + tr); - halo_rasterizer_enum halo_rasterizer = - get(sym, keys::halo_rasterizer, feature, common_.vars_, HALO_RASTERIZER_FULL); - composite_mode_e comp_op = get(sym, keys::comp_op, feature, common_.vars_, src_over); - composite_mode_e halo_comp_op = get(sym, keys::halo_comp_op, feature, common_.vars_, src_over); + const halo_rasterizer_enum halo_rasterizer = get(sym, + keys::halo_rasterizer, + feature, + common_.vars_, + halo_rasterizer_enum::HALO_RASTERIZER_FULL); + const composite_mode_e comp_op = get(sym, keys::comp_op, feature, common_.vars_, src_over); + const composite_mode_e halo_comp_op = + get(sym, keys::halo_comp_op, feature, common_.vars_, src_over); agg_text_renderer ren(buffers_.top().get(), halo_rasterizer, comp_op, @@ -66,7 +70,7 @@ void agg_renderer::process(text_symbolizer const& sym, common_.scale_factor_, common_.font_manager_.get_stroker()); - auto halo_transform = get_optional(sym, keys::halo_transform); + const auto halo_transform = get_optional(sym, keys::halo_transform); if (halo_transform) { agg::trans_affine halo_affine_transform; diff --git a/src/cairo/cairo_context.cpp b/src/cairo/cairo_context.cpp index 7be3e4243..50a25018d 100644 --- a/src/cairo/cairo_context.cpp +++ b/src/cairo/cairo_context.cpp @@ -192,11 +192,11 @@ void cairo_context::set_operator(composite_mode_e comp_op) void cairo_context::set_line_join(line_join_e join) { - if (join == MITER_JOIN) + if (join == line_join_enum::MITER_JOIN) cairo_set_line_join(cairo_.get(), CAIRO_LINE_JOIN_MITER); - else if (join == MITER_REVERT_JOIN) + else if (join == line_join_enum::MITER_REVERT_JOIN) cairo_set_line_join(cairo_.get(), CAIRO_LINE_JOIN_MITER); - else if (join == ROUND_JOIN) + else if (join == line_join_enum::ROUND_JOIN) cairo_set_line_join(cairo_.get(), CAIRO_LINE_JOIN_ROUND); else cairo_set_line_join(cairo_.get(), CAIRO_LINE_JOIN_BEVEL); @@ -205,9 +205,9 @@ void cairo_context::set_line_join(line_join_e join) void cairo_context::set_line_cap(line_cap_e cap) { - if (cap == BUTT_CAP) + if (cap == line_cap_enum::BUTT_CAP) cairo_set_line_cap(cairo_.get(), CAIRO_LINE_CAP_BUTT); - else if (cap == SQUARE_CAP) + else if (cap == line_cap_enum::SQUARE_CAP) cairo_set_line_cap(cairo_.get(), CAIRO_LINE_CAP_SQUARE); else cairo_set_line_cap(cairo_.get(), CAIRO_LINE_CAP_ROUND); @@ -480,7 +480,7 @@ void cairo_context::add_text(glyph_positions const& pos, pixel_position new_pos = glyph_pos.pos + glyph.offset.rotate(glyph_pos.rot); glyph_path(glyph.glyph_index, pixel_position(sx + new_pos.x, sy - new_pos.y)); set_line_width(2.0 * halo_radius); - set_line_join(ROUND_JOIN); + set_line_join(line_join_enum::ROUND_JOIN); set_color(glyph.format->halo_fill, glyph.format->halo_opacity); stroke(); } diff --git a/src/cairo/process_debug_symbolizer.cpp b/src/cairo/process_debug_symbolizer.cpp index fa28bc9ac..00e57563a 100644 --- a/src/cairo/process_debug_symbolizer.cpp +++ b/src/cairo/process_debug_symbolizer.cpp @@ -96,23 +96,27 @@ void cairo_renderer::process(debug_symbolizer const& sym, cairo_save_restore guard(context_); debug_symbolizer_mode_enum mode = - get(sym, keys::mode, feature, common_.vars_, DEBUG_SYM_MODE_COLLISION); + get(sym, + keys::mode, + feature, + common_.vars_, + debug_symbolizer_mode_enum::DEBUG_SYM_MODE_COLLISION); context_.set_operator(src_over); context_.set_color(mapnik::color(255, 0, 0), 1.0); - context_.set_line_join(MITER_JOIN); - context_.set_line_cap(BUTT_CAP); + context_.set_line_join(line_join_enum::MITER_JOIN); + context_.set_line_cap(line_cap_enum::BUTT_CAP); context_.set_miter_limit(4.0); context_.set_line_width(1.0); - if (mode == DEBUG_SYM_MODE_COLLISION) + if (mode == debug_symbolizer_mode_enum::DEBUG_SYM_MODE_COLLISION) { for (auto& n : *common_.detector_) { render_debug_box(context_, n.get().box); } } - else if (mode == DEBUG_SYM_MODE_VERTEX) + else if (mode == debug_symbolizer_mode_enum::DEBUG_SYM_MODE_VERTEX) { using apply_vertex_mode = apply_vertex_mode; apply_vertex_mode apply(context_, common_.t_, prj_trans); diff --git a/src/cairo/process_line_pattern_symbolizer.cpp b/src/cairo/process_line_pattern_symbolizer.cpp index 0a2c3fcc1..7371bbbc3 100644 --- a/src/cairo/process_line_pattern_symbolizer.cpp +++ b/src/cairo/process_line_pattern_symbolizer.cpp @@ -216,20 +216,20 @@ void cairo_renderer::process(line_pattern_symbolizer const& sym, return; } - line_pattern_enum pattern = get(sym, feature, common_.vars_); + const line_pattern_enum pattern = get(sym, feature, common_.vars_); switch (pattern) { - case LINE_PATTERN_WARP: { + case line_pattern_enum::LINE_PATTERN_WARP: { warp_pattern pattern(*marker, common_, sym, feature, prj_trans); pattern.render(context_); break; } - case LINE_PATTERN_REPEAT: { + case line_pattern_enum::LINE_PATTERN_REPEAT: { repeat_pattern pattern(*marker, common_, sym, feature, prj_trans); pattern.render(context_); break; } - case line_pattern_enum_MAX: + case line_pattern_enum::line_pattern_enum_MAX: default: MAPNIK_LOG_ERROR(process_line_pattern_symbolizer) << "Incorrect line-pattern value."; } diff --git a/src/feature_type_style.cpp b/src/feature_type_style.cpp index 68587a413..092b1bfa6 100644 --- a/src/feature_type_style.cpp +++ b/src/feature_type_style.cpp @@ -20,21 +20,27 @@ * *****************************************************************************/ +#include +#include +#include #include #include #include -// boost - namespace mapnik { - -static const char* filter_mode_strings[] = {"all", "first", ""}; - -IMPLEMENT_ENUM(filter_mode_e, filter_mode_strings) +namespace { +using E = detail::EnumStringT; +constexpr detail::EnumMapT filter_mode_e_map{{ + E{filter_mode_enum::FILTER_ALL, "all"}, + E{filter_mode_enum::FILTER_FIRST, "first"}, + E{filter_mode_enum::filter_mode_enum_MAX, ""}, +}}; +} // namespace +IMPLEMENT_ENUM(filter_mode_e, filter_mode_enum); feature_type_style::feature_type_style() : rules_() - , filter_mode_(FILTER_ALL) + , filter_mode_(filter_mode_enum::FILTER_ALL) , filters_() , direct_filters_() , comp_op_() diff --git a/src/grid/process_line_pattern_symbolizer.cpp b/src/grid/process_line_pattern_symbolizer.cpp index 0d49c5224..e74d2598e 100644 --- a/src/grid/process_line_pattern_symbolizer.cpp +++ b/src/grid/process_line_pattern_symbolizer.cpp @@ -42,8 +42,6 @@ MAPNIK_DISABLE_WARNING_PUSH #include "agg_rasterizer_scanline_aa.h" #include "agg_renderer_scanline.h" #include "agg_scanline_bin.h" -#include "agg_conv_stroke.h" -#include "agg_conv_dash.h" MAPNIK_DISABLE_WARNING_POP // stl @@ -56,10 +54,10 @@ void grid_renderer::process(line_pattern_symbolizer const& sym, mapnik::feature_impl& feature, proj_transform const& prj_trans) { - std::string filename = get(sym, feature, common_.vars_); + const std::string filename = get(sym, feature, common_.vars_); if (filename.empty()) return; - std::shared_ptr mark = marker_cache::instance().find(filename, true); + const auto mark = marker_cache::instance().find(filename, true); if (mark->is()) return; @@ -70,10 +68,10 @@ void grid_renderer::process(line_pattern_symbolizer const& sym, return; } - value_bool clip = get(sym, feature, common_.vars_); - value_double offset = get(sym, feature, common_.vars_); - value_double simplify_tolerance = get(sym, feature, common_.vars_); - value_double smooth = get(sym, feature, common_.vars_); + const value_bool clip = get(sym, feature, common_.vars_); + const value_double offset = get(sym, feature, common_.vars_); + const value_double simplify_tolerance = get(sym, feature, common_.vars_); + const value_double smooth = get(sym, feature, common_.vars_); using pixfmt_type = typename grid_renderer_base_type::pixfmt_type; using color_type = typename grid_renderer_base_type::pixfmt_type::color_type; @@ -90,12 +88,12 @@ void grid_renderer::process(line_pattern_symbolizer const& sym, ras_ptr->reset(); line_pattern_enum pattern = get(sym, feature, common_.vars_); - std::size_t stroke_width = (pattern == LINE_PATTERN_WARP) - ? mark->width() - : get(sym, feature, common_.vars_); + const std::size_t stroke_width = (pattern == line_pattern_enum::LINE_PATTERN_WARP) + ? mark->width() + : get(sym, feature, common_.vars_); agg::trans_affine tr; - auto transform = get_optional(sym, keys::geometry_transform); + const auto transform = get_optional(sym, keys::geometry_transform); if (transform) { evaluate_transform(tr, feature, common_.vars_, *transform, common_.scale_factor_); @@ -104,10 +102,10 @@ void grid_renderer::process(line_pattern_symbolizer const& sym, box2d clipping_extent = common_.query_extent_; if (clip) { - double pad_per_pixel = static_cast(common_.query_extent_.width() / common_.width_); - double pixels = std::ceil( + const double pad_per_pixel = static_cast(common_.query_extent_.width() / common_.width_); + const double pixels = std::ceil( std::max(stroke_width / 2.0 + std::fabs(offset), (std::fabs(offset) * offset_converter_default_threshold))); - double padding = pad_per_pixel * pixels * common_.scale_factor_; + const double padding = pad_per_pixel * pixels * common_.scale_factor_; clipping_extent.pad(padding); } diff --git a/src/load_map.cpp b/src/load_map.cpp index 12833e568..5265d5a39 100644 --- a/src/load_map.cpp +++ b/src/load_map.cpp @@ -489,7 +489,7 @@ void map_parser::parse_style(Map& map, xml_node const& node) name = node.get_attr("name"); feature_type_style style; - filter_mode_e filter_mode = node.get_attr("filter-mode", FILTER_ALL); + filter_mode_e filter_mode = node.get_attr("filter-mode", filter_mode_enum::FILTER_ALL); style.set_filter_mode(filter_mode); // compositing @@ -1586,9 +1586,10 @@ bool map_parser::parse_raster_colorizer(raster_colorizer_ptr const& rc, xml_node try { // mode - colorizer_mode default_mode = node.get_attr("default-mode", COLORIZER_LINEAR); + colorizer_mode default_mode = + node.get_attr("default-mode", colorizer_mode_enum::COLORIZER_LINEAR); - if (default_mode == COLORIZER_INHERIT) + if (default_mode == colorizer_mode_enum::COLORIZER_INHERIT) { throw config_error("RasterColorizer mode must not be INHERIT. "); } @@ -1626,7 +1627,7 @@ bool map_parser::parse_raster_colorizer(raster_colorizer_ptr const& rc, xml_node } // mode default to INHERIT - colorizer_mode mode = n.get_attr("mode", COLORIZER_INHERIT); + colorizer_mode mode = n.get_attr("mode", colorizer_mode_enum::COLORIZER_INHERIT); // value is required, and it must be bigger than the previous optional val = n.get_opt_attr("value"); diff --git a/src/map.cpp b/src/map.cpp index ac77218cc..e10b10478 100644 --- a/src/map.cpp +++ b/src/map.cpp @@ -46,19 +46,22 @@ #include namespace mapnik { - -static const char* aspect_fix_mode_strings[] = {"GROW_BBOX", - "GROW_CANVAS", - "SHRINK_BBOX", - "SHRINK_CANVAS", - "ADJUST_BBOX_WIDTH", - "ADJUST_BBOX_HEIGHT", - "ADJUST_CANVAS_WIDTH", - "ADJUST_CANVAS_HEIGHT", - "RESPECT", - ""}; - -IMPLEMENT_ENUM(aspect_fix_mode_e, aspect_fix_mode_strings) +namespace { +using E = detail::EnumStringT; +constexpr detail::EnumMapT aspect_fix_mode_e_map{{ + E{Map::aspect_fix_mode::GROW_BBOX, "GROW_BBOX"}, + E{Map::aspect_fix_mode::GROW_CANVAS, "GROW_CANVAS"}, + E{Map::aspect_fix_mode::SHRINK_BBOX, "SHRINK_BBOX"}, + E{Map::aspect_fix_mode::SHRINK_CANVAS, "SHRINK_CANVAS"}, + E{Map::aspect_fix_mode::ADJUST_BBOX_WIDTH, "ADJUST_BBOX_WIDTH"}, + E{Map::aspect_fix_mode::ADJUST_BBOX_HEIGHT, "ADJUST_BBOX_HEIGHT"}, + E{Map::aspect_fix_mode::ADJUST_CANVAS_WIDTH, "ADJUST_CANVAS_WIDTH"}, + E{Map::aspect_fix_mode::ADJUST_CANVAS_HEIGHT, "ADJUST_CANVAS_HEIGHT"}, + E{Map::aspect_fix_mode::RESPECT, "RESPECT"}, + E{Map::aspect_fix_mode::aspect_fix_mode_MAX, ""}, +}}; +} // namespace +IMPLEMENT_ENUM(aspect_fix_mode_e, Map::aspect_fix_mode) Map::Map() : width_(400) diff --git a/src/marker_helpers.cpp b/src/marker_helpers.cpp index 7a5f9872a..709500e1d 100644 --- a/src/marker_helpers.cpp +++ b/src/marker_helpers.cpp @@ -240,7 +240,8 @@ void apply_markers_multi(feature_impl const& feature, get(sym, feature, vars); marker_placement_enum placement = get(sym, feature, vars); - if (placement == MARKER_POINT_PLACEMENT && multi_policy == MARKER_WHOLE_MULTI) + if (placement == marker_placement_enum::MARKER_POINT_PLACEMENT && + multi_policy == marker_multi_policy_enum::MARKER_WHOLE_MULTI) { geometry::point pt; // test if centroid is contained by bounding box @@ -252,9 +253,10 @@ void apply_markers_multi(feature_impl const& feature, converter.apply(va, proc); } } - else if ((placement == MARKER_POINT_PLACEMENT || placement == MARKER_INTERIOR_PLACEMENT || - placement == MARKER_POLYLABEL_PLACEMENT) && - multi_policy == MARKER_LARGEST_MULTI) + else if ((placement == marker_placement_enum::MARKER_POINT_PLACEMENT || + placement == marker_placement_enum::MARKER_INTERIOR_PLACEMENT || + placement == marker_placement_enum::MARKER_POLYLABEL_PLACEMENT) && + multi_policy == marker_multi_policy_enum::MARKER_LARGEST_MULTI) { // Only apply to path with largest envelope area // TODO: consider using true area for polygon types @@ -287,7 +289,8 @@ void apply_markers_multi(feature_impl const& feature, } else { - if (multi_policy != MARKER_EACH_MULTI && placement != MARKER_POINT_PLACEMENT) + if (multi_policy != marker_multi_policy_enum::MARKER_EACH_MULTI && + placement != marker_placement_enum::MARKER_POINT_PLACEMENT) { MAPNIK_LOG_WARN(marker_symbolizer) << "marker_multi_policy != 'each' has no effect with marker_placement != 'point'"; diff --git a/src/proj_transform.cpp b/src/proj_transform.cpp index 29be99f8b..33e6847f0 100644 --- a/src/proj_transform.cpp +++ b/src/proj_transform.cpp @@ -109,12 +109,12 @@ proj_transform::proj_transform(projection const& source, projection const& dest) bool known_trans = false; if (src_k && dest_k) { - if (*src_k == WGS_84 && *dest_k == WEB_MERC) + if (*src_k == well_known_srs_enum::WGS_84 && *dest_k == well_known_srs_enum::WEB_MERC) { wgs84_to_merc_ = true; known_trans = true; } - else if (*src_k == WEB_MERC && *dest_k == WGS_84) + else if (*src_k == well_known_srs_enum::WEB_MERC && *dest_k == well_known_srs_enum::WGS_84) { merc_to_wgs84_ = true; known_trans = true; diff --git a/src/raster_colorizer.cpp b/src/raster_colorizer.cpp index 1d4dae4ac..864aa9b23 100644 --- a/src/raster_colorizer.cpp +++ b/src/raster_colorizer.cpp @@ -36,10 +36,17 @@ namespace mapnik { //! \brief Strings for the colorizer_mode enumeration -static const char* colorizer_mode_strings[] = - {"inherit", "linear", "discrete", "exact", "linear-rgba", "linear-bgra", ""}; - -IMPLEMENT_ENUM(colorizer_mode, colorizer_mode_strings) +using colorizer_mode_str = detail::EnumStringT; +constexpr detail::EnumMapT colorizer_mode_map{{ + colorizer_mode_str{colorizer_mode_enum::COLORIZER_INHERIT, "inherit"}, + colorizer_mode_str{colorizer_mode_enum::COLORIZER_LINEAR, "linear"}, + colorizer_mode_str{colorizer_mode_enum::COLORIZER_DISCRETE, "discrete"}, + colorizer_mode_str{colorizer_mode_enum::COLORIZER_EXACT, "exact"}, + colorizer_mode_str{colorizer_mode_enum::COLORIZER_LINEAR_RGBA, "linear-rgba"}, + colorizer_mode_str{colorizer_mode_enum::COLORIZER_LINEAR_BGRA, "linear-bgra"}, + colorizer_mode_str{colorizer_mode_enum::colorizer_mode_enum_MAX, ""}, +}}; +IMPLEMENT_ENUM(colorizer_mode, colorizer_mode_enum) colorizer_stop::colorizer_stop(float val, colorizer_mode mode, color const& _color, std::string const& label) : value_(val) @@ -177,7 +184,7 @@ unsigned raster_colorizer::get_color(float val) const else { stopMode = stops_[stopIdx].get_mode(); - if (stopMode == COLORIZER_INHERIT) + if (stopMode == colorizer_mode_enum::COLORIZER_INHERIT) { stopMode = default_mode_; } @@ -206,7 +213,7 @@ unsigned raster_colorizer::get_color(float val) const switch (stopMode) { - case COLORIZER_LINEAR: { + case colorizer_mode_enum::COLORIZER_LINEAR: { // deal with this separately so we don't have to worry about div0 if (nextStopValue == stopValue) { @@ -228,7 +235,7 @@ unsigned raster_colorizer::get_color(float val) const } } break; - case COLORIZER_LINEAR_RGBA: { + case colorizer_mode_enum::COLORIZER_LINEAR_RGBA: { if (nextStopValue == stopValue) { return stopColor.rgba(); @@ -240,7 +247,7 @@ unsigned raster_colorizer::get_color(float val) const outputColor = color(colorStart + fraction * (colorEnd - colorStart)); } break; - case COLORIZER_LINEAR_BGRA: { + case colorizer_mode_enum::COLORIZER_LINEAR_BGRA: { if (nextStopValue == stopValue) { return stopColor.rgba(); @@ -255,10 +262,10 @@ unsigned raster_colorizer::get_color(float val) const std::swap(outputColor.red_, outputColor.blue_); } break; - case COLORIZER_DISCRETE: + case colorizer_mode_enum::COLORIZER_DISCRETE: outputColor = stopColor; break; - case COLORIZER_EXACT: + case colorizer_mode_enum::COLORIZER_EXACT: default: // approximately equal (within epsilon) if (std::fabs(val - stopValue) < epsilon_) diff --git a/src/renderer_common/pattern_alignment.cpp b/src/renderer_common/pattern_alignment.cpp index 96ac67088..c70fb3c1f 100644 --- a/src/renderer_common/pattern_alignment.cpp +++ b/src/renderer_common/pattern_alignment.cpp @@ -73,7 +73,7 @@ coord pattern_offset(symbolizer_base const& sym, coord reference_position(0, 0); pattern_alignment_enum alignment_type = get(sym, feature, common.vars_); - if (alignment_type == LOCAL_ALIGNMENT) + if (alignment_type == pattern_alignment_enum::LOCAL_ALIGNMENT) { apply_local_alignment apply(common.t_, prj_trans, reference_position.x, reference_position.y); util::apply_visitor(geometry::vertex_processor(apply), feature.get_geometry()); diff --git a/src/renderer_common/render_thunk_extractor.cpp b/src/renderer_common/render_thunk_extractor.cpp index 913f6f985..c5e626135 100644 --- a/src/renderer_common/render_thunk_extractor.cpp +++ b/src/renderer_common/render_thunk_extractor.cpp @@ -137,8 +137,11 @@ void render_thunk_extractor::extract_text_thunk(text_render_thunk::helper_ptr&& { double opacity = get(sym, keys::opacity, feature_, common_.vars_, 1.0); composite_mode_e comp_op = get(sym, keys::comp_op, feature_, common_.vars_, src_over); - halo_rasterizer_enum halo_rasterizer = - get(sym, keys::halo_rasterizer, feature_, common_.vars_, HALO_RASTERIZER_FULL); + halo_rasterizer_enum halo_rasterizer = get(sym, + keys::halo_rasterizer, + feature_, + common_.vars_, + halo_rasterizer_enum::HALO_RASTERIZER_FULL); text_render_thunk thunk(std::move(helper), opacity, comp_op, halo_rasterizer); thunks_.emplace_back(std::move(thunk)); diff --git a/src/svg/output/svg_output_attributes.cpp b/src/svg/output/svg_output_attributes.cpp index a3f6ed249..045182887 100644 --- a/src/svg/output/svg_output_attributes.cpp +++ b/src/svg/output/svg_output_attributes.cpp @@ -59,13 +59,13 @@ void path_output_attributes::set_stroke_linecap(line_cap_e stroke_linecap) { switch (stroke_linecap) { - case BUTT_CAP: + case line_cap_enum::BUTT_CAP: stroke_linecap_ = "butt"; break; - case SQUARE_CAP: + case line_cap_enum::SQUARE_CAP: stroke_linecap_ = "square"; break; - case ROUND_CAP: + case line_cap_enum::ROUND_CAP: stroke_linecap_ = "round"; break; default: @@ -77,16 +77,16 @@ void path_output_attributes::set_stroke_linejoin(line_join_e stroke_linejoin) { switch (stroke_linejoin) { - case MITER_JOIN: + case line_join_enum::MITER_JOIN: stroke_linejoin_ = "miter"; break; - case MITER_REVERT_JOIN: + case line_join_enum::MITER_REVERT_JOIN: stroke_linejoin_ = "miter"; break; - case ROUND_JOIN: + case line_join_enum::ROUND_JOIN: stroke_linejoin_ = "round"; break; - case BEVEL_JOIN: + case line_join_enum::BEVEL_JOIN: stroke_linejoin_ = "bevel"; break; default: diff --git a/src/symbolizer_enumerations.cpp b/src/symbolizer_enumerations.cpp index 15a65cc9b..927e48825 100644 --- a/src/symbolizer_enumerations.cpp +++ b/src/symbolizer_enumerations.cpp @@ -23,98 +23,202 @@ #include namespace mapnik { + // stroke -static const char* line_cap_strings[] = {"butt", "square", "round", ""}; +using line_cap_e_str = detail::EnumStringT; +constexpr detail::EnumMapT line_cap_e_map{{ + line_cap_e_str{line_cap_enum::BUTT_CAP, "butt"}, + line_cap_e_str{line_cap_enum::SQUARE_CAP, "square"}, + line_cap_e_str{line_cap_enum::ROUND_CAP, "round"}, + line_cap_e_str{line_cap_enum::line_cap_enum_MAX, ""}, +}}; +IMPLEMENT_ENUM(line_cap_e, line_cap_enum) -IMPLEMENT_ENUM(line_cap_e, line_cap_strings) - -static const char* line_join_strings[] = {"miter", "miter-revert", "round", "bevel", ""}; - -IMPLEMENT_ENUM(line_join_e, line_join_strings) +using line_join_e_str = detail::EnumStringT; +constexpr detail::EnumMapT line_join_e_map{{ + line_join_e_str{line_join_enum::MITER_JOIN, "miter"}, + line_join_e_str{line_join_enum::MITER_REVERT_JOIN, "miter-revert"}, + line_join_e_str{line_join_enum::ROUND_JOIN, "round"}, + line_join_e_str{line_join_enum::BEVEL_JOIN, "bevel"}, + line_join_e_str{line_join_enum::line_join_enum_MAX, ""}, +}}; +IMPLEMENT_ENUM(line_join_e, line_join_enum) // point symbolizer -static const char* point_placement_strings[] = {"centroid", "interior", ""}; - -IMPLEMENT_ENUM(point_placement_e, point_placement_strings) +using point_placement_e_str = detail::EnumStringT; +constexpr detail::EnumMapT point_placement_e_map{{ + point_placement_e_str{point_placement_enum::CENTROID_POINT_PLACEMENT, "centroid"}, + point_placement_e_str{point_placement_enum::INTERIOR_POINT_PLACEMENT, "interior"}, + point_placement_e_str{point_placement_enum::point_placement_enum_MAX, ""}, +}}; +IMPLEMENT_ENUM(point_placement_e, point_placement_enum) // line symbolizer -static const char* line_rasterizer_strings[] = {"full", "fast", ""}; -IMPLEMENT_ENUM(line_rasterizer_e, line_rasterizer_strings) +using line_rasterizer_e_str = detail::EnumStringT; +constexpr detail::EnumMapT line_rasterizer_e_map{{ + line_rasterizer_e_str{line_rasterizer_enum::RASTERIZER_FULL, "full"}, + line_rasterizer_e_str{line_rasterizer_enum::RASTERIZER_FAST, "fast"}, + line_rasterizer_e_str{line_rasterizer_enum::line_rasterizer_enum_MAX, ""}, +}}; +IMPLEMENT_ENUM(line_rasterizer_e, line_rasterizer_enum) // markers symbolizer -static const char* marker_placement_strings[] = - {"point", "interior", "line", "vertex-first", "vertex-last", "angled-point", "polylabel", ""}; +using marker_placement_e_str = detail::EnumStringT; +constexpr detail::EnumMapT marker_placement_e_map{{ + marker_placement_e_str{marker_placement_enum::MARKER_POINT_PLACEMENT, "point"}, + marker_placement_e_str{marker_placement_enum::MARKER_INTERIOR_PLACEMENT, "interior"}, + marker_placement_e_str{marker_placement_enum::MARKER_LINE_PLACEMENT, "line"}, + marker_placement_e_str{marker_placement_enum::MARKER_VERTEX_FIRST_PLACEMENT, "vertex-first"}, + marker_placement_e_str{marker_placement_enum::MARKER_VERTEX_LAST_PLACEMENT, "vertex-last"}, + marker_placement_e_str{marker_placement_enum::MARKER_ANGLED_POINT_PLACEMENT, "angled-point"}, + marker_placement_e_str{marker_placement_enum::MARKER_POLYLABEL_PLACEMENT, "polylabel"}, + marker_placement_e_str{marker_placement_enum::marker_placement_enum_MAX, ""}, +}}; +IMPLEMENT_ENUM(marker_placement_e, marker_placement_enum) -IMPLEMENT_ENUM(marker_placement_e, marker_placement_strings) - -static const char* marker_multi_policy_strings[] = {"each", "whole", "largest", ""}; - -IMPLEMENT_ENUM(marker_multi_policy_e, marker_multi_policy_strings) +using marker_multi_policy_e_str = detail::EnumStringT; +constexpr detail::EnumMapT marker_multi_policy_e_map{{ + marker_multi_policy_e_str{marker_multi_policy_enum::MARKER_EACH_MULTI, "each"}, + marker_multi_policy_e_str{marker_multi_policy_enum::MARKER_WHOLE_MULTI, "whole"}, + marker_multi_policy_e_str{marker_multi_policy_enum::MARKER_LARGEST_MULTI, "largest"}, + marker_multi_policy_e_str{marker_multi_policy_enum::marker_multi_policy_enum_MAX, ""}, +}}; +IMPLEMENT_ENUM(marker_multi_policy_e, marker_multi_policy_enum) // debug symbolizer -static const char* debug_symbolizer_mode_strings[] = {"collision", "vertex", "rings", ""}; - -IMPLEMENT_ENUM(debug_symbolizer_mode_e, debug_symbolizer_mode_strings) +using debug_symbolizer_mode_e_str = detail::EnumStringT; +constexpr detail::EnumMapT debug_symbolizer_mode_e_map{{ + debug_symbolizer_mode_e_str{debug_symbolizer_mode_enum::DEBUG_SYM_MODE_COLLISION, "collision"}, + debug_symbolizer_mode_e_str{debug_symbolizer_mode_enum::DEBUG_SYM_MODE_VERTEX, "vertex"}, + debug_symbolizer_mode_e_str{debug_symbolizer_mode_enum::DEBUG_SYM_MODE_RINGS, "rings"}, + debug_symbolizer_mode_e_str{debug_symbolizer_mode_enum::debug_symbolizer_mode_enum_MAX, ""}, +}}; +IMPLEMENT_ENUM(debug_symbolizer_mode_e, debug_symbolizer_mode_enum) // polygon pattern symbolizer -static const char* pattern_alignment_strings[] = {"local", // feature - "global", // map - ""}; - -IMPLEMENT_ENUM(pattern_alignment_e, pattern_alignment_strings) +using pattern_alignment_e_str = detail::EnumStringT; +constexpr detail::EnumMapT pattern_alignment_e_map{{ + pattern_alignment_e_str{pattern_alignment_enum::LOCAL_ALIGNMENT, "local"}, // feature + pattern_alignment_e_str{pattern_alignment_enum::GLOBAL_ALIGNMENT, "global"}, // map + pattern_alignment_e_str{pattern_alignment_enum::pattern_alignment_enum_MAX, ""}, +}}; +IMPLEMENT_ENUM(pattern_alignment_e, pattern_alignment_enum) // text -static const char* halo_rasterizer_strings[] = {"full", "fast", ""}; +using halo_rasterizer_e_str = detail::EnumStringT; +constexpr detail::EnumMapT halo_rasterizer_e_map{{ + halo_rasterizer_e_str{halo_rasterizer_enum::HALO_RASTERIZER_FULL, "full"}, + halo_rasterizer_e_str{halo_rasterizer_enum::HALO_RASTERIZER_FAST, "fast"}, + halo_rasterizer_e_str{halo_rasterizer_enum::halo_rasterizer_enum_MAX, ""}, +}}; +IMPLEMENT_ENUM(halo_rasterizer_e, halo_rasterizer_enum) -IMPLEMENT_ENUM(halo_rasterizer_e, halo_rasterizer_strings) +using label_placement_e_str = detail::EnumStringT; +constexpr detail::EnumMapT label_placement_e_map{{ + label_placement_e_str{label_placement_enum::POINT_PLACEMENT, "point"}, + label_placement_e_str{label_placement_enum::LINE_PLACEMENT, "line"}, + label_placement_e_str{label_placement_enum::VERTEX_PLACEMENT, "vertex"}, + label_placement_e_str{label_placement_enum::INTERIOR_PLACEMENT, "interior"}, + label_placement_e_str{label_placement_enum::POLYLABEL_PLACEMENT, "polylabel"}, + label_placement_e_str{label_placement_enum::GRID_PLACEMENT, "grid"}, + label_placement_e_str{label_placement_enum::ALTERNATING_GRID_PLACEMENT, "alternating-grid"}, + label_placement_e_str{label_placement_enum::label_placement_enum_MAX, ""}, +}}; +IMPLEMENT_ENUM(label_placement_e, label_placement_enum) -static const char* label_placement_strings[] = - {"point", "line", "vertex", "interior", "polylabel", "grid", "alternating-grid", ""}; +using vertical_alignment_e_str = detail::EnumStringT; +constexpr detail::EnumMapT vertical_alignment_e_map{{ + vertical_alignment_e_str{vertical_alignment_enum::V_TOP, "top"}, + vertical_alignment_e_str{vertical_alignment_enum::V_MIDDLE, "middle"}, + vertical_alignment_e_str{vertical_alignment_enum::V_BOTTOM, "bottom"}, + vertical_alignment_e_str{vertical_alignment_enum::V_AUTO, "auto"}, + vertical_alignment_e_str{vertical_alignment_enum::vertical_alignment_enum_MAX, ""}, +}}; +IMPLEMENT_ENUM(vertical_alignment_e, vertical_alignment_enum) -IMPLEMENT_ENUM(label_placement_e, label_placement_strings) +using horizontal_alignment_e_str = detail::EnumStringT; +constexpr detail::EnumMapT horizontal_alignment_e_map{{ + horizontal_alignment_e_str{horizontal_alignment_enum::H_LEFT, "left"}, + horizontal_alignment_e_str{horizontal_alignment_enum::H_MIDDLE, "middle"}, + horizontal_alignment_e_str{horizontal_alignment_enum::H_RIGHT, "right"}, + horizontal_alignment_e_str{horizontal_alignment_enum::H_AUTO, "auto"}, + horizontal_alignment_e_str{horizontal_alignment_enum::H_ADJUST, "adjust"}, + horizontal_alignment_e_str{horizontal_alignment_enum::horizontal_alignment_enum_MAX, ""}, +}}; +IMPLEMENT_ENUM(horizontal_alignment_e, horizontal_alignment_enum) -static const char* vertical_alignment_strings[] = {"top", "middle", "bottom", "auto", ""}; +using justify_alignment_e_str = detail::EnumStringT; +constexpr detail::EnumMapT justify_alignment_e_map{{ + justify_alignment_e_str{justify_alignment_enum::J_LEFT, "left"}, + justify_alignment_e_str{justify_alignment_enum::J_MIDDLE, "center"}, // not 'middle' in order to match CSS + justify_alignment_e_str{justify_alignment_enum::J_RIGHT, "right"}, + justify_alignment_e_str{justify_alignment_enum::J_AUTO, "auto"}, + justify_alignment_e_str{justify_alignment_enum::justify_alignment_enum_MAX, ""}, +}}; +IMPLEMENT_ENUM(justify_alignment_e, justify_alignment_enum) -IMPLEMENT_ENUM(vertical_alignment_e, vertical_alignment_strings) +using text_transform_e_str = detail::EnumStringT; +constexpr detail::EnumMapT text_transform_e_map{{ + text_transform_e_str{text_transform_enum::NONE, "none"}, + text_transform_e_str{text_transform_enum::UPPERCASE, "uppercase"}, + text_transform_e_str{text_transform_enum::LOWERCASE, "lowercase"}, + text_transform_e_str{text_transform_enum::CAPITALIZE, "capitalize"}, + text_transform_e_str{text_transform_enum::REVERSE, "reverse"}, + text_transform_e_str{text_transform_enum::text_transform_enum_MAX, ""}, +}}; +IMPLEMENT_ENUM(text_transform_e, text_transform_enum) -static const char* horizontal_alignment_strings[] = {"left", "middle", "right", "auto", "adjust", ""}; +using text_upright_e_str = detail::EnumStringT; +constexpr detail::EnumMapT text_upright_e_map{{ + text_upright_e_str{text_upright_enum::UPRIGHT_AUTO, "auto"}, + text_upright_e_str{text_upright_enum::UPRIGHT_AUTO_DOWN, "auto-down"}, + text_upright_e_str{text_upright_enum::UPRIGHT_LEFT, "left"}, + text_upright_e_str{text_upright_enum::UPRIGHT_RIGHT, "right"}, + text_upright_e_str{text_upright_enum::UPRIGHT_LEFT_ONLY, "left-only"}, + text_upright_e_str{text_upright_enum::UPRIGHT_RIGHT_ONLY, "right-only"}, + text_upright_e_str{text_upright_enum::text_upright_enum_MAX, ""}, +}}; +IMPLEMENT_ENUM(text_upright_e, text_upright_enum) -IMPLEMENT_ENUM(horizontal_alignment_e, horizontal_alignment_strings) +using direction_e_str = detail::EnumStringT; +constexpr detail::EnumMapT direction_e_map{{ + direction_e_str{direction_enum::DIRECTION_LEFT, "left"}, + direction_e_str{direction_enum::DIRECTION_RIGHT, "right"}, + direction_e_str{direction_enum::DIRECTION_LEFT_ONLY, "left-only"}, + direction_e_str{direction_enum::DIRECTION_RIGHT_ONLY, "right-only"}, + direction_e_str{direction_enum::DIRECTION_AUTO, "auto"}, + direction_e_str{direction_enum::DIRECTION_AUTO_DOWN, "auto-down"}, + direction_e_str{direction_enum::DIRECTION_UP, "up"}, + direction_e_str{direction_enum::DIRECTION_DOWN, "down"}, + direction_e_str{direction_enum::direction_enum_MAX, ""}, +}}; +IMPLEMENT_ENUM(direction_e, direction_enum) -static const char* justify_alignment_strings[] = {"left", - "center", // not 'middle' in order to match CSS - "right", - "auto", - ""}; +using gamma_method_e_str = detail::EnumStringT; +constexpr detail::EnumMapT gamma_method_e_map{{ + gamma_method_e_str{gamma_method_enum::GAMMA_POWER, "power"}, // agg::gamma_power + gamma_method_e_str{gamma_method_enum::GAMMA_LINEAR, "linear"}, // agg::gamma_linear + gamma_method_e_str{gamma_method_enum::GAMMA_NONE, "none"}, // agg::gamma_none + gamma_method_e_str{gamma_method_enum::GAMMA_THRESHOLD, "threshold"}, // agg::gamma_threshold + gamma_method_e_str{gamma_method_enum::GAMMA_MULTIPLY, "multiply"}, // agg::gamma_multiply" + gamma_method_e_str{gamma_method_enum::gamma_method_enum_MAX, ""}, +}}; +IMPLEMENT_ENUM(gamma_method_e, gamma_method_enum) -IMPLEMENT_ENUM(justify_alignment_e, justify_alignment_strings) +using line_pattern_e_str = detail::EnumStringT; +constexpr detail::EnumMapT line_pattern_e_map{{ + line_pattern_e_str{line_pattern_enum::LINE_PATTERN_WARP, "warp"}, + line_pattern_e_str{line_pattern_enum::LINE_PATTERN_REPEAT, "repeat"}, + line_pattern_e_str{line_pattern_enum::line_pattern_enum_MAX, ""}, +}}; +IMPLEMENT_ENUM(line_pattern_e, line_pattern_enum) -static const char* text_transform_strings[] = {"none", "uppercase", "lowercase", "capitalize", "reverse", ""}; - -IMPLEMENT_ENUM(text_transform_e, text_transform_strings) - -static const char* text_upright_strings[] = {"auto", "auto-down", "left", "right", "left-only", "right-only", ""}; -IMPLEMENT_ENUM(text_upright_e, text_upright_strings) - -static const char* direction_strings[] = - {"left", "right", "left-only", "right-only", "auto", "auto-down", "up", "down", ""}; -IMPLEMENT_ENUM(direction_e, direction_strings) - -static const char* gamma_method_strings[] = {"power", // agg::gamma_power - "linear", // agg::gamma_linear - "none", // agg::gamma_none - "threshold", // agg::gamma_threshold - "multiply", // agg::gamma_multiply", - ""}; - -IMPLEMENT_ENUM(gamma_method_e, gamma_method_strings) - -static const char* line_pattern_strings[] = {"warp", "repeat", ""}; - -IMPLEMENT_ENUM(line_pattern_e, line_pattern_strings) - -static const char* smooth_algorithm_strings[] = {"basic", "adaptive", ""}; - -IMPLEMENT_ENUM(smooth_algorithm_e, smooth_algorithm_strings) +using smooth_algorithm_e_str = detail::EnumStringT; +constexpr detail::EnumMapT smooth_algorithm_e_map{{ + smooth_algorithm_e_str{smooth_algorithm_enum::SMOOTH_ALGORITHM_BASIC, "basic"}, + smooth_algorithm_e_str{smooth_algorithm_enum::SMOOTH_ALGORITHM_ADAPTIVE, "adaptive"}, + smooth_algorithm_e_str{smooth_algorithm_enum::smooth_algorithm_enum_MAX, ""}, +}}; +IMPLEMENT_ENUM(smooth_algorithm_e, smooth_algorithm_enum) } // namespace mapnik diff --git a/src/symbolizer_keys.cpp b/src/symbolizer_keys.cpp index 83cc42ba9..6e3372683 100644 --- a/src/symbolizer_keys.cpp +++ b/src/symbolizer_keys.cpp @@ -36,13 +36,10 @@ static const property_meta_type key_meta[const_max_key] = { property_meta_type{"gamma", nullptr, property_types::target_double}, property_meta_type{"gamma-method", nullptr, property_types::target_gamma_method}, property_meta_type{"opacity", nullptr, property_types::target_double}, - property_meta_type{"alignment", - [](enumeration_wrapper e) { - return enumeration( - pattern_alignment_enum(e.value)) - .as_string(); - }, - property_types::target_pattern_alignment}, + property_meta_type{ + "alignment", + [](enumeration_wrapper e) { return pattern_alignment_e(pattern_alignment_enum(e.value)).as_string(); }, + property_types::target_pattern_alignment}, property_meta_type{"offset", nullptr, property_types::target_double}, property_meta_type{"comp-op", [](enumeration_wrapper e) { return *comp_op_to_string(composite_mode_e(e.value)); }, @@ -54,14 +51,10 @@ static const property_meta_type key_meta[const_max_key] = { property_meta_type{"stroke-width", nullptr, property_types::target_double}, property_meta_type{"stroke-opacity", nullptr, property_types::target_double}, property_meta_type{"stroke-linejoin", - [](enumeration_wrapper e) { - return enumeration(line_join_enum(e.value)).as_string(); - }, + [](enumeration_wrapper e) { return line_join_e(line_join_enum(e.value)).as_string(); }, property_types::target_line_join}, property_meta_type{"stroke-linecap", - [](enumeration_wrapper e) { - return enumeration(line_cap_enum(e.value)).as_string(); - }, + [](enumeration_wrapper e) { return line_cap_e(line_cap_enum(e.value)).as_string(); }, property_types::target_line_cap}, property_meta_type{"stroke-gamma", nullptr, property_types::target_double}, property_meta_type{"stroke-gamma-method", nullptr, property_types::target_gamma_method}, @@ -71,12 +64,9 @@ static const property_meta_type key_meta[const_max_key] = { property_meta_type{"geometry-transform", nullptr, property_types::target_transform}, // TODO - should be called 'line-rasterizer' but for back compat with 2.3.x we keep as 'rasterizer' // https://github.com/mapnik/mapnik/issues/2503 - property_meta_type{ - "rasterizer", - [](enumeration_wrapper e) { - return enumeration(line_rasterizer_enum(e.value)).as_string(); - }, - property_types::target_double}, + property_meta_type{"rasterizer", + [](enumeration_wrapper e) { return line_rasterizer_e(line_rasterizer_enum(e.value)).as_string(); }, + property_types::target_double}, property_meta_type{"transform", nullptr, property_types::target_transform}, property_meta_type{"spacing", nullptr, property_types::target_double}, property_meta_type{"spacing-offset", nullptr, property_types::target_double}, @@ -97,50 +87,32 @@ static const property_meta_type key_meta[const_max_key] = { property_meta_type{"mesh-size", nullptr, property_types::target_double}, property_meta_type{"premultiplied", nullptr, property_types::target_bool}, property_meta_type{"smooth", nullptr, property_types::target_double}, - property_meta_type{"smooth-algorithm", - [](enumeration_wrapper e) { - return enumeration( - smooth_algorithm_enum(e.value)) - .as_string(); - }, - property_types::target_smooth_algorithm}, + property_meta_type{ + "smooth-algorithm", + [](enumeration_wrapper e) { return smooth_algorithm_e(smooth_algorithm_enum(e.value)).as_string(); }, + property_types::target_smooth_algorithm}, property_meta_type{"simplify-algorithm", [](enumeration_wrapper e) { return *simplify_algorithm_to_string(simplify_algorithm_e(e.value)); }, property_types::target_simplify_algorithm}, property_meta_type{"simplify", nullptr, property_types::target_double}, - property_meta_type{ - "halo-rasterizer", - [](enumeration_wrapper e) { - return enumeration(halo_rasterizer_enum(e.value)).as_string(); - }, - property_types::target_halo_rasterizer}, + property_meta_type{"halo-rasterizer", + [](enumeration_wrapper e) { return halo_rasterizer_e(halo_rasterizer_enum(e.value)).as_string(); }, + property_types::target_halo_rasterizer}, property_meta_type{"text-placements", nullptr, property_types::target_double}, - property_meta_type{ - "placement", - [](enumeration_wrapper e) { - return enumeration(label_placement_enum(e.value)).as_string(); - }, - property_types::target_placement}, - property_meta_type{"placement", // FIXME - change property name - [](enumeration_wrapper e) { - return enumeration( - marker_placement_enum(e.value)) - .as_string(); - }, - property_types::target_markers_placement}, - property_meta_type{"multi-policy", - [](enumeration_wrapper e) { - return enumeration( - marker_multi_policy_enum(e.value)) - .as_string(); - }, - property_types::target_markers_multipolicy}, + property_meta_type{"placement", + [](enumeration_wrapper e) { return label_placement_e(label_placement_enum(e.value)).as_string(); }, + property_types::target_placement}, property_meta_type{ "placement", // FIXME - change property name - [](enumeration_wrapper e) { - return enumeration(point_placement_enum(e.value)).as_string(); - }, - property_types::target_double}, + [](enumeration_wrapper e) { return marker_placement_e(marker_placement_enum(e.value)).as_string(); }, + property_types::target_markers_placement}, + property_meta_type{ + "multi-policy", + [](enumeration_wrapper e) { return marker_multi_policy_e(marker_multi_policy_enum(e.value)).as_string(); }, + property_types::target_markers_multipolicy}, + property_meta_type{"placement", // FIXME - change property name + [](enumeration_wrapper e) { return point_placement_e(point_placement_enum(e.value)).as_string(); }, + property_types::target_double}, property_meta_type{"colorizer", nullptr, property_types::target_colorizer}, property_meta_type{"halo-transform", nullptr, property_types::target_transform}, property_meta_type{"num-columns", nullptr, property_types::target_integer}, @@ -152,53 +124,33 @@ static const property_meta_type key_meta[const_max_key] = { property_meta_type{"halo-comp-op", [](enumeration_wrapper e) { return *comp_op_to_string(composite_mode_e(e.value)); }, property_types::target_halo_comp_op}, + property_meta_type{"text-transform", + [](enumeration_wrapper e) { return text_transform_e(text_transform_enum(e.value)).as_string(); }, + property_types::target_text_transform}, property_meta_type{ - "text-transform", - [](enumeration_wrapper e) { - return enumeration(text_transform_enum(e.value)).as_string(); - }, - property_types::target_text_transform}, - property_meta_type{"horizontal-alignment", - [](enumeration_wrapper e) { - return enumeration( - horizontal_alignment_enum(e.value)) - .as_string(); - }, - property_types::target_horizontal_alignment}, - property_meta_type{"justify-alignment", - [](enumeration_wrapper e) { - return enumeration( - justify_alignment_enum(e.value)) - .as_string(); - }, - property_types::target_justify_alignment}, - property_meta_type{"vertical-alignment", - [](enumeration_wrapper e) { - return enumeration( - vertical_alignment_enum(e.value)) - .as_string(); - }, - property_types::target_vertical_alignment}, + "horizontal-alignment", + [](enumeration_wrapper e) { return horizontal_alignment_e(horizontal_alignment_enum(e.value)).as_string(); }, + property_types::target_horizontal_alignment}, property_meta_type{ - "upright", - [](enumeration_wrapper e) { - return enumeration(text_upright_enum(e.value)).as_string(); - }, - property_types::target_upright}, + "justify-alignment", + [](enumeration_wrapper e) { return justify_alignment_e(justify_alignment_enum(e.value)).as_string(); }, + property_types::target_justify_alignment}, + property_meta_type{ + "vertical-alignment", + [](enumeration_wrapper e) { return vertical_alignment_e(vertical_alignment_enum(e.value)).as_string(); }, + property_types::target_vertical_alignment}, + property_meta_type{"upright", + [](enumeration_wrapper e) { return text_upright_e(text_upright_enum(e.value)).as_string(); }, + property_types::target_upright}, property_meta_type{"direction", - [](enumeration_wrapper e) { - return enumeration(direction_enum(e.value)).as_string(); - }, + [](enumeration_wrapper e) { return direction_e(direction_enum(e.value)).as_string(); }, property_types::target_direction}, property_meta_type{"avoid-edges", nullptr, property_types::target_bool}, property_meta_type{"font-feature-settings", nullptr, property_types::target_font_feature_settings}, property_meta_type{"extend", nullptr, property_types::target_double}, - property_meta_type{ - "line-pattern", - [](enumeration_wrapper e) { - return enumeration(line_pattern_enum(e.value)).as_string(); - }, - property_types::target_line_pattern}, + property_meta_type{"line-pattern", + [](enumeration_wrapper e) { return line_pattern_e(line_pattern_enum(e.value)).as_string(); }, + property_types::target_line_pattern}, }; diff --git a/src/text/formatting/text.cpp b/src/text/formatting/text.cpp index 6ba205f18..37b971f12 100644 --- a/src/text/formatting/text.cpp +++ b/src/text/formatting/text.cpp @@ -61,16 +61,16 @@ void text_node::apply(evaluated_format_properties_ptr const& p, util::apply_visitor(evaluate(feature, vars), *text_).to_unicode(); switch (p->text_transform) { - case UPPERCASE: + case text_transform_enum::UPPERCASE: text_str.toUpper(); break; - case LOWERCASE: + case text_transform_enum::LOWERCASE: text_str.toLower(); break; - case REVERSE: + case text_transform_enum::REVERSE: text_str.reverse(); break; - case CAPITALIZE: + case text_transform_enum::CAPITALIZE: #if !UCONFIG_NO_BREAK_ITERATION // note: requires BreakIterator support in ICU which is optional text_str.toTitle(nullptr); diff --git a/src/text/placement_finder.cpp b/src/text/placement_finder.cpp index dd127b6b4..e33463113 100644 --- a/src/text/placement_finder.cpp +++ b/src/text/placement_finder.cpp @@ -97,7 +97,7 @@ placement_finder::placement_finder(feature_impl const& feature, , marker_unlocked_(false) , marker_displacement_() , move_dx_(0.0) - , horizontal_alignment_(H_LEFT) + , horizontal_alignment_(horizontal_alignment_enum::H_LEFT) {} bool placement_finder::next_position() @@ -135,23 +135,23 @@ bool placement_finder::next_position() text_upright_e placement_finder::simplify_upright(text_upright_e upright, double angle) const { - if (upright == UPRIGHT_AUTO) + if (upright == text_upright_enum::UPRIGHT_AUTO) { angle = util::normalize_angle(angle); - return std::abs(angle) > util::tau / 4 ? UPRIGHT_LEFT : UPRIGHT_RIGHT; + return std::abs(angle) > util::tau / 4 ? text_upright_enum::UPRIGHT_LEFT : text_upright_enum::UPRIGHT_RIGHT; } - if (upright == UPRIGHT_AUTO_DOWN) + if (upright == text_upright_enum::UPRIGHT_AUTO_DOWN) { angle = util::normalize_angle(angle); - return std::abs(angle) < util::tau / 4 ? UPRIGHT_LEFT : UPRIGHT_RIGHT; + return std::abs(angle) < util::tau / 4 ? text_upright_enum::UPRIGHT_LEFT : text_upright_enum::UPRIGHT_RIGHT; } - if (upright == UPRIGHT_LEFT_ONLY) + if (upright == text_upright_enum::UPRIGHT_LEFT_ONLY) { - return UPRIGHT_LEFT; + return text_upright_enum::UPRIGHT_LEFT; } - if (upright == UPRIGHT_RIGHT_ONLY) + if (upright == text_upright_enum::UPRIGHT_RIGHT_ONLY) { - return UPRIGHT_RIGHT; + return text_upright_enum::UPRIGHT_RIGHT; } return upright; } @@ -270,12 +270,12 @@ bool placement_finder::single_line_placement(vertex_cache& pp, text_upright_e or text_layout const& layout = *layout_ptr; pixel_position align_offset = layout.alignment_offset(); pixel_position const& layout_displacement = layout.displacement(); - double sign = (real_orientation == UPRIGHT_LEFT) ? -1 : 1; + double sign = (real_orientation == text_upright_enum::UPRIGHT_LEFT) ? -1 : 1; // double offset = 0 - (layout_displacement.y + 0.5 * sign * layout.height()); double offset = layout_displacement.y - 0.5 * sign * layout.height(); double adjust_character_spacing = .0; double layout_width = layout.width(); - bool adjust = layout.horizontal_alignment() == H_ADJUST; + bool adjust = layout.horizontal_alignment() == horizontal_alignment_enum::H_ADJUST; if (adjust) { @@ -371,23 +371,30 @@ bool placement_finder::single_line_placement(vertex_cache& pp, text_upright_e or if (upside_down_glyph_count > static_cast(layouts_.text().length() / 2)) { - if (orientation == UPRIGHT_AUTO) + if (orientation == text_upright_enum::UPRIGHT_AUTO) { // Try again with opposite orientation begin.restore(); - return single_line_placement(pp, real_orientation == UPRIGHT_RIGHT ? UPRIGHT_LEFT : UPRIGHT_RIGHT); + return single_line_placement(pp, + real_orientation == text_upright_enum::UPRIGHT_RIGHT + ? text_upright_enum::UPRIGHT_LEFT + : text_upright_enum::UPRIGHT_RIGHT); } // upright==left-only or right-only and more than 50% of characters upside down => no placement - else if (orientation == UPRIGHT_LEFT_ONLY || orientation == UPRIGHT_RIGHT_ONLY) + else if (orientation == text_upright_enum::UPRIGHT_LEFT_ONLY || + orientation == text_upright_enum::UPRIGHT_RIGHT_ONLY) { return false; } } - else if (orientation == UPRIGHT_AUTO_DOWN) + else if (orientation == text_upright_enum::UPRIGHT_AUTO_DOWN) { // Try again with opposite orientation begin.restore(); - return single_line_placement(pp, real_orientation == UPRIGHT_RIGHT ? UPRIGHT_LEFT : UPRIGHT_RIGHT); + return single_line_placement(pp, + real_orientation == text_upright_enum::UPRIGHT_RIGHT + ? text_upright_enum::UPRIGHT_LEFT + : text_upright_enum::UPRIGHT_RIGHT); } box2d label_box; @@ -424,7 +431,7 @@ void placement_finder::path_move_dx(vertex_cache& pp, double dx) double placement_finder::get_spacing(double path_length, double layout_width) const { int num_labels = 1; - if (horizontal_alignment_ != H_ADJUST && text_props_->label_spacing > 0) + if (horizontal_alignment_ != horizontal_alignment_enum::H_ADJUST && text_props_->label_spacing > 0) { num_labels = static_cast(std::floor(path_length / (text_props_->label_spacing * scale_factor_ + layout_width))); diff --git a/src/text/renderer.cpp b/src/text/renderer.cpp index 190c18be0..1c3a37c9f 100644 --- a/src/text/renderer.cpp +++ b/src/text/renderer.cpp @@ -32,22 +32,6 @@ #include #include -#include -MAPNIK_DISABLE_WARNING_PUSH -#include -#include "agg_rendering_buffer.h" -#include "agg_pixfmt_rgba.h" -#include "agg_color_rgba.h" -#include "agg_scanline_u.h" -#include "agg_image_filters.h" -#include "agg_trans_bilinear.h" -#include "agg_span_allocator.h" -#include "agg_image_accessors.h" -#include "agg_span_image_filter_rgba.h" -#include "agg_renderer_base.h" -#include "agg_renderer_scanline.h" -MAPNIK_DISABLE_WARNING_POP - namespace mapnik { text_renderer::text_renderer(halo_rasterizer_e rasterizer, @@ -225,7 +209,7 @@ void agg_text_renderer::render(glyph_positions const& pos) if (!error) { FT_Glyph_Transform(g, &halo_matrix, &start_halo); - if (rasterizer_ == HALO_RASTERIZER_FULL) + if (rasterizer_ == halo_rasterizer_enum::HALO_RASTERIZER_FULL) { stroker_->init(halo_radius); FT_Glyph_Stroke(&g, stroker_->get(), 1); @@ -479,7 +463,7 @@ void grid_text_renderer::render_halo_id(unsigned char* buffer, template grid_text_renderer::grid_text_renderer(pixmap_type& pixmap, composite_mode_e comp_op, double scale_factor) - : text_renderer(HALO_RASTERIZER_FAST, comp_op, src_over, scale_factor) + : text_renderer(halo_rasterizer_enum::HALO_RASTERIZER_FAST, comp_op, src_over, scale_factor) , pixmap_(pixmap) {} diff --git a/src/text/symbolizer_helpers.cpp b/src/text/symbolizer_helpers.cpp index 7cc145edb..6348dc763 100644 --- a/src/text/symbolizer_helpers.cpp +++ b/src/text/symbolizer_helpers.cpp @@ -277,11 +277,11 @@ void base_symbolizer_helper::initialize_points() const switch (how_placed) { - case LINE_PLACEMENT: + case label_placement_enum::LINE_PLACEMENT: point_placement_ = false; return; - case GRID_PLACEMENT: - case ALTERNATING_GRID_PLACEMENT: + case label_placement_enum::GRID_PLACEMENT: + case label_placement_enum::ALTERNATING_GRID_PLACEMENT: point_placement_ = true; // Points for grid placement are generated in text_symbolizer_helper // because base_symbolizer_helper doesn't have the vertex converter. @@ -296,7 +296,7 @@ void base_symbolizer_helper::initialize_points() const for (auto const& geom : geometries_to_process_) { - if (how_placed == VERTEX_PLACEMENT) + if (how_placed == label_placement_enum::VERTEX_PLACEMENT) { using apply_vertex_placement = detail::apply_vertex_placement>; apply_vertex_placement apply(points_, t_, prj_trans_); @@ -317,7 +317,7 @@ void base_symbolizer_helper::initialize_points() const geometry::line_string_vertex_adapter va(line); success = label::middle_point(va, label_x, label_y); } - else if (how_placed == POINT_PLACEMENT || type == geometry::geometry_types::Point) + else if (how_placed == label_placement_enum::POINT_PLACEMENT || type == geometry::geometry_types::Point) { geometry::point pt; if (geometry::centroid(geom, pt)) @@ -335,7 +335,7 @@ void base_symbolizer_helper::initialize_points() const using transform_group_type = geometry::strategy_group; transform_group_type transform_group(ps, vs); geometry::polygon tranformed_poly(geometry::transform(poly, transform_group)); - if (how_placed == INTERIOR_PLACEMENT) + if (how_placed == label_placement_enum::INTERIOR_PLACEMENT) { geometry::point pt; if (geometry::interior(tranformed_poly, scale_factor_, pt)) @@ -343,7 +343,7 @@ void base_symbolizer_helper::initialize_points() const points_.emplace_back(pt.x, pt.y); } } - else if (how_placed == POLYLABEL_PLACEMENT) + else if (how_placed == label_placement_enum::POLYLABEL_PLACEMENT) { double precision = geometry::polylabel_precision(tranformed_poly, scale_factor_); geometry::point pt; @@ -408,7 +408,8 @@ void text_symbolizer_helper::init_converters() if (clip) { label_placement_enum how_placed = text_props_->label_placement; - if (how_placed == GRID_PLACEMENT || how_placed == ALTERNATING_GRID_PLACEMENT) + if (how_placed == label_placement_enum::GRID_PLACEMENT || + how_placed == label_placement_enum::ALTERNATING_GRID_PLACEMENT) { converter_.template set(); } @@ -618,11 +619,11 @@ void text_symbolizer_helper::initialize_points() const { label_placement_enum how_placed = text_props_->label_placement; - if (how_placed == GRID_PLACEMENT) + if (how_placed == label_placement_enum::GRID_PLACEMENT) { initialize_grid_points(); } - else if (how_placed == ALTERNATING_GRID_PLACEMENT) + else if (how_placed == label_placement_enum::ALTERNATING_GRID_PLACEMENT) { initialize_grid_points(); } diff --git a/src/text/text_layout.cpp b/src/text/text_layout.cpp index e091e1429..3be71243a 100644 --- a/src/text/text_layout.cpp +++ b/src/text/text_layout.cpp @@ -466,32 +466,32 @@ void text_layout::shape_text(text_line& line) void text_layout::init_auto_alignment() { - if (valign_ == V_AUTO) + if (valign_ == vertical_alignment_enum::V_AUTO) { if (displacement_.y > 0.0) - valign_ = V_BOTTOM; + valign_ = vertical_alignment_enum::V_BOTTOM; else if (displacement_.y < 0.0) - valign_ = V_TOP; + valign_ = vertical_alignment_enum::V_TOP; else - valign_ = V_MIDDLE; + valign_ = vertical_alignment_enum::V_MIDDLE; } - if (halign_ == H_AUTO) + if (halign_ == horizontal_alignment_enum::H_AUTO) { if (displacement_.x > 0.0) - halign_ = H_RIGHT; + halign_ = horizontal_alignment_enum::H_RIGHT; else if (displacement_.x < 0.0) - halign_ = H_LEFT; + halign_ = horizontal_alignment_enum::H_LEFT; else - halign_ = H_MIDDLE; + halign_ = horizontal_alignment_enum::H_MIDDLE; } - if (jalign_ == J_AUTO) + if (jalign_ == justify_alignment_enum::J_AUTO) { if (displacement_.x > 0.0) - jalign_ = J_LEFT; + jalign_ = justify_alignment_enum::J_LEFT; else if (displacement_.x < 0.0) - jalign_ = J_RIGHT; + jalign_ = justify_alignment_enum::J_RIGHT; else - jalign_ = J_MIDDLE; + jalign_ = justify_alignment_enum::J_MIDDLE; } } @@ -499,20 +499,20 @@ pixel_position text_layout::alignment_offset() const { pixel_position result(0, 0); // if needed, adjust for desired vertical alignment - if (valign_ == V_TOP) + if (valign_ == vertical_alignment_enum::V_TOP) { result.y = -0.5 * height(); // move center up by 1/2 the total height } - else if (valign_ == V_BOTTOM) + else if (valign_ == vertical_alignment_enum::V_BOTTOM) { result.y = 0.5 * height(); // move center down by the 1/2 the total height } // set horizontal position to middle of text - if (halign_ == H_LEFT) + if (halign_ == horizontal_alignment_enum::H_LEFT) { result.x = -0.5 * width(); // move center left by 1/2 the string width } - else if (halign_ == H_RIGHT) + else if (halign_ == horizontal_alignment_enum::H_RIGHT) { result.x = 0.5 * width(); // move center right by 1/2 the string width } @@ -521,11 +521,11 @@ pixel_position text_layout::alignment_offset() const double text_layout::jalign_offset(double line_width) const { - if (jalign_ == J_MIDDLE) + if (jalign_ == justify_alignment_enum::J_MIDDLE) return -(line_width / 2.0); - if (jalign_ == J_LEFT) + if (jalign_ == justify_alignment_enum::J_LEFT) return -(width() / 2.0); - if (jalign_ == J_RIGHT) + if (jalign_ == justify_alignment_enum::J_RIGHT) return (width() / 2.0) - line_width; return 0; } diff --git a/src/text/text_properties.cpp b/src/text/text_properties.cpp index 633fb6e1d..bccd76b29 100644 --- a/src/text/text_properties.cpp +++ b/src/text/text_properties.cpp @@ -252,9 +252,9 @@ void text_symbolizer_properties::add_expressions(expression_set& output) const } text_layout_properties::text_layout_properties() - : halign(enumeration_wrapper(H_AUTO)) - , jalign(enumeration_wrapper(J_AUTO)) - , valign(enumeration_wrapper(V_AUTO)) + : halign(enumeration_wrapper(static_cast(horizontal_alignment_enum::H_AUTO))) + , jalign(enumeration_wrapper(static_cast(justify_alignment_enum::J_AUTO))) + , valign(enumeration_wrapper(static_cast(vertical_alignment_enum::V_AUTO))) {} void text_layout_properties::from_xml(xml_node const& node, fontset_map const& fontsets) @@ -343,7 +343,7 @@ format_properties::format_properties() , fill(color(0, 0, 0)) , halo_fill(color(255, 255, 255)) , halo_radius(0.0) - , text_transform(enumeration_wrapper(NONE)) + , text_transform(enumeration_wrapper(static_cast(text_transform_enum::NONE))) , ff_settings() {} diff --git a/src/well_known_srs.cpp b/src/well_known_srs.cpp index d8d30a2c8..2efb7a5d0 100644 --- a/src/well_known_srs.cpp +++ b/src/well_known_srs.cpp @@ -35,10 +35,11 @@ MAPNIK_DISABLE_WARNING_POP #include namespace mapnik { +constexpr const char MAPNIK_GEOGRAPHIC_PROJ_STR[10]{"epsg:4326"}; +extern std::string const MAPNIK_GEOGRAPHIC_PROJ = MAPNIK_GEOGRAPHIC_PROJ_STR; // wgs84 -extern std::string const MAPNIK_GEOGRAPHIC_PROJ = "epsg:4326"; // wgs84 - -extern std::string const MAPNIK_WEBMERCATOR_PROJ = "epsg:3857"; // webmercator +constexpr const char MAPNIK_WEBMERCATOR_PROJ_STR[10]{"epsg:3857"}; +extern std::string const MAPNIK_WEBMERCATOR_PROJ = MAPNIK_WEBMERCATOR_PROJ_STR; // webmercator static const char* well_known_srs_strings[] = {MAPNIK_GEOGRAPHIC_PROJ.c_str(), MAPNIK_WEBMERCATOR_PROJ.c_str(), ""}; @@ -46,11 +47,11 @@ boost::optional is_well_known_srs(std::string const& srs) { if (srs == MAPNIK_GEOGRAPHIC_PROJ) { - return boost::optional(mapnik::WGS_84); + return boost::optional(mapnik::well_known_srs_enum::WGS_84); } else if (srs == MAPNIK_WEBMERCATOR_PROJ) { - return boost::optional(mapnik::WEB_MERC); + return boost::optional(mapnik::well_known_srs_enum::WEB_MERC); } return boost::optional(); } @@ -69,7 +70,13 @@ boost::optional is_known_geographic(std::string const& srs) return boost::optional(); } -IMPLEMENT_ENUM(well_known_srs_e, well_known_srs_strings) +using well_known_srs_e_str = mapnik::detail::EnumStringT; +constexpr detail::EnumMapT well_known_srs_e_map{{ + well_known_srs_e_str{well_known_srs_enum::WGS_84, detail::mapnik_string_view{MAPNIK_GEOGRAPHIC_PROJ_STR}}, + well_known_srs_e_str{well_known_srs_enum::WEB_MERC, MAPNIK_WEBMERCATOR_PROJ_STR}, + well_known_srs_e_str{well_known_srs_enum::well_known_srs_enum_MAX, ""}, +}}; +IMPLEMENT_ENUM(well_known_srs_e, well_known_srs_enum) bool lonlat2merc(double& x, double& y) { diff --git a/src/xml_tree.cpp b/src/xml_tree.cpp index efce20e6d..2cc8d58f5 100644 --- a/src/xml_tree.cpp +++ b/src/xml_tree.cpp @@ -42,6 +42,7 @@ namespace mapnik { class boolean_type; + template struct name_trait { @@ -74,22 +75,26 @@ DEFINE_NAME_TRAIT(color, "color") DEFINE_NAME_TRAIT(expression_ptr, "expression_ptr") DEFINE_NAME_TRAIT(font_feature_settings, "font-feature-settings") -template -struct name_trait> +template (*F_LOOKUP)()> +struct name_trait> { - using Enum = enumeration; - + using Enum = mapnik::enumeration; static std::string name() { std::string value_list("one of ["); - for (unsigned i = 0; i < Enum::MAX; ++i) + const auto lookup{Enum::lookupMap()}; + for (auto it = lookup.cbegin(); it != lookup.cend(); it++) { - value_list += Enum::get_string(i); - if (i + 1 < Enum::MAX) + value_list += it->second; + if (std::next(it) != lookup.cend()) + { value_list += ", "; + } } - value_list += "]"; - + value_list += ']'; return value_list; } }; diff --git a/test/unit/numerics/enumeration.cpp b/test/unit/numerics/enumeration.cpp index 1f425e8ea..f4ba2f3a3 100644 --- a/test/unit/numerics/enumeration.cpp +++ b/test/unit/numerics/enumeration.cpp @@ -6,7 +6,7 @@ TEST_CASE("enumeration") { - mapnik::line_cap_e e(mapnik::ROUND_CAP); + mapnik::line_cap_e e(mapnik::line_cap_enum::ROUND_CAP); CHECK(e.as_string() == "round"); // note: test the << operator, which calls `as_string` internally // is not used in mapnik, but kept for back compat diff --git a/test/unit/symbolizer/marker_placement_vertex_last.cpp b/test/unit/symbolizer/marker_placement_vertex_last.cpp index 418b449dc..1ee9f22b6 100644 --- a/test/unit/symbolizer/marker_placement_vertex_last.cpp +++ b/test/unit/symbolizer/marker_placement_vertex_last.cpp @@ -27,7 +27,7 @@ TEST_CASE("marker placement vertex last") 0, false, false, - DIRECTION_AUTO, + direction_enum::DIRECTION_AUTO, 1.0}; placement_type placement(va, detector, params); @@ -54,7 +54,7 @@ TEST_CASE("marker placement vertex last") 0, false, false, - DIRECTION_AUTO, + direction_enum::DIRECTION_AUTO, 1.0}; placement_type placement(va, detector, params); @@ -89,7 +89,7 @@ TEST_CASE("marker placement vertex last") 0, false, false, - DIRECTION_AUTO, + direction_enum::DIRECTION_AUTO, 1.0}; placement_type placement(va, detector, params); @@ -128,7 +128,7 @@ TEST_CASE("marker placement vertex last") 0, false, false, - DIRECTION_AUTO, + direction_enum::DIRECTION_AUTO, 1.0}; placement_type placement(va, detector, params); diff --git a/test/unit/symbolizer/markers_point_placement.cpp b/test/unit/symbolizer/markers_point_placement.cpp index 61f87a564..7c7cd807a 100644 --- a/test/unit/symbolizer/markers_point_placement.cpp +++ b/test/unit/symbolizer/markers_point_placement.cpp @@ -27,7 +27,7 @@ TEST_CASE("marker placement point") 0, false, false, - DIRECTION_AUTO, + direction_enum::DIRECTION_AUTO, 1.0}; placement_type placement(va, detector, params); @@ -54,7 +54,7 @@ TEST_CASE("marker placement point") 0, false, false, - DIRECTION_AUTO, + direction_enum::DIRECTION_AUTO, 1.0}; placement_type placement(va, detector, params); @@ -89,7 +89,7 @@ TEST_CASE("marker placement point") 0, false, false, - DIRECTION_AUTO, + direction_enum::DIRECTION_AUTO, 1.0}; placement_type placement(va, detector, params); @@ -124,7 +124,7 @@ TEST_CASE("marker placement point") 0, false, false, - DIRECTION_AUTO, + direction_enum::DIRECTION_AUTO, 1.0}; placement_type placement(va, detector, params); diff --git a/test/unit/symbolizer/symbolizer_test.cpp b/test/unit/symbolizer/symbolizer_test.cpp index 847409ea2..daad679f9 100644 --- a/test/unit/symbolizer/symbolizer_test.cpp +++ b/test/unit/symbolizer/symbolizer_test.cpp @@ -12,13 +12,13 @@ TEST_CASE("symbolizer") { try { - marker_multi_policy_enum policy_in = MARKER_WHOLE_MULTI; - REQUIRE(policy_in == MARKER_WHOLE_MULTI); + marker_multi_policy_enum policy_in = marker_multi_policy_enum::MARKER_WHOLE_MULTI; + REQUIRE(policy_in == marker_multi_policy_enum::MARKER_WHOLE_MULTI); markers_symbolizer sym; put(sym, keys::markers_multipolicy, policy_in); REQUIRE(sym.properties.count(keys::markers_multipolicy) == static_cast(1)); marker_multi_policy_enum policy_out = get(sym, keys::markers_multipolicy); - REQUIRE(policy_out == MARKER_WHOLE_MULTI); + REQUIRE(policy_out == marker_multi_policy_enum::MARKER_WHOLE_MULTI); } catch (std::exception const& ex) {