tei/MapLibreParticleLab
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

[core] Use mbgl::underlying_type in style properties

Browse Source
This commit is contained in:
Bruno de Oliveira Abinader
2019-09-11 13:47:22 +03:00
parent 788508984f
commit 6fdf07e3a7
12 changed files with 228 additions and 216 deletions
Download Patch File Download Diff File Expand all files Collapse all files

15
src/mbgl/style/layers/background_layer.cpp
View File

@@ -9,6 +9,7 @@
#include <mbgl/style/conversion/transition_options.hpp>
#include <mbgl/style/conversion/json.hpp>
#include <mbgl/style/conversion_impl.hpp>
#include <mbgl/util/traits.hpp>
#include <mapbox/eternal.hpp>
@@ -147,7 +148,7 @@ TransitionOptions BackgroundLayer::getBackgroundPatternTransition() const {
using namespace conversion;
optional<Error> BackgroundLayer::setPaintProperty(const std::string& name, const Convertible& value) {
enum class Property : uint8_t {
enum class Property {
BackgroundColor,
BackgroundOpacity,
BackgroundPattern,
@@ -157,12 +158,12 @@ optional<Error> BackgroundLayer::setPaintProperty(const std::string& name, const
};
MAPBOX_ETERNAL_CONSTEXPR const auto properties = mapbox::eternal::hash_map<mapbox::eternal::string, uint8_t>({
{ "background-color", static_cast<uint8_t>(Property::BackgroundColor) },
{ "background-opacity", static_cast<uint8_t>(Property::BackgroundOpacity) },
{ "background-pattern", static_cast<uint8_t>(Property::BackgroundPattern) },
{ "background-color-transition", static_cast<uint8_t>(Property::BackgroundColorTransition) },
{ "background-opacity-transition", static_cast<uint8_t>(Property::BackgroundOpacityTransition) },
{ "background-pattern-transition", static_cast<uint8_t>(Property::BackgroundPatternTransition) }
{ "background-color", mbgl::underlying_type(Property::BackgroundColor) },
{ "background-opacity", mbgl::underlying_type(Property::BackgroundOpacity) },
{ "background-pattern", mbgl::underlying_type(Property::BackgroundPattern) },
{ "background-color-transition", mbgl::underlying_type(Property::BackgroundColorTransition) },
{ "background-opacity-transition", mbgl::underlying_type(Property::BackgroundOpacityTransition) },
{ "background-pattern-transition", mbgl::underlying_type(Property::BackgroundPatternTransition) }
});
const auto it = properties.find(name.c_str());

47
src/mbgl/style/layers/circle_layer.cpp
View File

@@ -9,6 +9,7 @@
#include <mbgl/style/conversion/transition_options.hpp>
#include <mbgl/style/conversion/json.hpp>
#include <mbgl/style/conversion_impl.hpp>
#include <mbgl/util/traits.hpp>
#include <mapbox/eternal.hpp>
@@ -363,7 +364,7 @@ TransitionOptions CircleLayer::getCircleTranslateAnchorTransition() const {
using namespace conversion;
optional<Error> CircleLayer::setPaintProperty(const std::string& name, const Convertible& value) {
enum class Property : uint8_t {
enum class Property {
CircleBlur,
CircleColor,
CircleOpacity,
@@ -389,28 +390,28 @@ optional<Error> CircleLayer::setPaintProperty(const std::string& name, const Con
};
MAPBOX_ETERNAL_CONSTEXPR const auto properties = mapbox::eternal::hash_map<mapbox::eternal::string, uint8_t>({
{ "circle-blur", static_cast<uint8_t>(Property::CircleBlur) },
{ "circle-color", static_cast<uint8_t>(Property::CircleColor) },
{ "circle-opacity", static_cast<uint8_t>(Property::CircleOpacity) },
{ "circle-pitch-alignment", static_cast<uint8_t>(Property::CirclePitchAlignment) },
{ "circle-pitch-scale", static_cast<uint8_t>(Property::CirclePitchScale) },
{ "circle-radius", static_cast<uint8_t>(Property::CircleRadius) },
{ "circle-stroke-color", static_cast<uint8_t>(Property::CircleStrokeColor) },
{ "circle-stroke-opacity", static_cast<uint8_t>(Property::CircleStrokeOpacity) },
{ "circle-stroke-width", static_cast<uint8_t>(Property::CircleStrokeWidth) },
{ "circle-translate", static_cast<uint8_t>(Property::CircleTranslate) },
{ "circle-translate-anchor", static_cast<uint8_t>(Property::CircleTranslateAnchor) },
{ "circle-blur-transition", static_cast<uint8_t>(Property::CircleBlurTransition) },
{ "circle-color-transition", static_cast<uint8_t>(Property::CircleColorTransition) },
{ "circle-opacity-transition", static_cast<uint8_t>(Property::CircleOpacityTransition) },
{ "circle-pitch-alignment-transition", static_cast<uint8_t>(Property::CirclePitchAlignmentTransition) },
{ "circle-pitch-scale-transition", static_cast<uint8_t>(Property::CirclePitchScaleTransition) },
{ "circle-radius-transition", static_cast<uint8_t>(Property::CircleRadiusTransition) },
{ "circle-stroke-color-transition", static_cast<uint8_t>(Property::CircleStrokeColorTransition) },
{ "circle-stroke-opacity-transition", static_cast<uint8_t>(Property::CircleStrokeOpacityTransition) },
{ "circle-stroke-width-transition", static_cast<uint8_t>(Property::CircleStrokeWidthTransition) },
{ "circle-translate-transition", static_cast<uint8_t>(Property::CircleTranslateTransition) },
{ "circle-translate-anchor-transition", static_cast<uint8_t>(Property::CircleTranslateAnchorTransition) }
{ "circle-blur", mbgl::underlying_type(Property::CircleBlur) },
{ "circle-color", mbgl::underlying_type(Property::CircleColor) },
{ "circle-opacity", mbgl::underlying_type(Property::CircleOpacity) },
{ "circle-pitch-alignment", mbgl::underlying_type(Property::CirclePitchAlignment) },
{ "circle-pitch-scale", mbgl::underlying_type(Property::CirclePitchScale) },
{ "circle-radius", mbgl::underlying_type(Property::CircleRadius) },
{ "circle-stroke-color", mbgl::underlying_type(Property::CircleStrokeColor) },
{ "circle-stroke-opacity", mbgl::underlying_type(Property::CircleStrokeOpacity) },
{ "circle-stroke-width", mbgl::underlying_type(Property::CircleStrokeWidth) },
{ "circle-translate", mbgl::underlying_type(Property::CircleTranslate) },
{ "circle-translate-anchor", mbgl::underlying_type(Property::CircleTranslateAnchor) },
{ "circle-blur-transition", mbgl::underlying_type(Property::CircleBlurTransition) },
{ "circle-color-transition", mbgl::underlying_type(Property::CircleColorTransition) },
{ "circle-opacity-transition", mbgl::underlying_type(Property::CircleOpacityTransition) },
{ "circle-pitch-alignment-transition", mbgl::underlying_type(Property::CirclePitchAlignmentTransition) },
{ "circle-pitch-scale-transition", mbgl::underlying_type(Property::CirclePitchScaleTransition) },
{ "circle-radius-transition", mbgl::underlying_type(Property::CircleRadiusTransition) },
{ "circle-stroke-color-transition", mbgl::underlying_type(Property::CircleStrokeColorTransition) },
{ "circle-stroke-opacity-transition", mbgl::underlying_type(Property::CircleStrokeOpacityTransition) },
{ "circle-stroke-width-transition", mbgl::underlying_type(Property::CircleStrokeWidthTransition) },
{ "circle-translate-transition", mbgl::underlying_type(Property::CircleTranslateTransition) },
{ "circle-translate-anchor-transition", mbgl::underlying_type(Property::CircleTranslateAnchorTransition) }
});
const auto it = properties.find(name.c_str());

35
src/mbgl/style/layers/fill_extrusion_layer.cpp
View File

@@ -9,6 +9,7 @@
#include <mbgl/style/conversion/transition_options.hpp>
#include <mbgl/style/conversion/json.hpp>
#include <mbgl/style/conversion_impl.hpp>
#include <mbgl/util/traits.hpp>
#include <mapbox/eternal.hpp>
@@ -282,7 +283,7 @@ TransitionOptions FillExtrusionLayer::getFillExtrusionVerticalGradientTransition
using namespace conversion;
optional<Error> FillExtrusionLayer::setPaintProperty(const std::string& name, const Convertible& value) {
enum class Property : uint8_t {
enum class Property {
FillExtrusionBase,
FillExtrusionColor,
FillExtrusionHeight,
@@ -302,22 +303,22 @@ optional<Error> FillExtrusionLayer::setPaintProperty(const std::string& name, co
};
MAPBOX_ETERNAL_CONSTEXPR const auto properties = mapbox::eternal::hash_map<mapbox::eternal::string, uint8_t>({
{ "fill-extrusion-base", static_cast<uint8_t>(Property::FillExtrusionBase) },
{ "fill-extrusion-color", static_cast<uint8_t>(Property::FillExtrusionColor) },
{ "fill-extrusion-height", static_cast<uint8_t>(Property::FillExtrusionHeight) },
{ "fill-extrusion-opacity", static_cast<uint8_t>(Property::FillExtrusionOpacity) },
{ "fill-extrusion-pattern", static_cast<uint8_t>(Property::FillExtrusionPattern) },
{ "fill-extrusion-translate", static_cast<uint8_t>(Property::FillExtrusionTranslate) },
{ "fill-extrusion-translate-anchor", static_cast<uint8_t>(Property::FillExtrusionTranslateAnchor) },
{ "fill-extrusion-vertical-gradient", static_cast<uint8_t>(Property::FillExtrusionVerticalGradient) },
{ "fill-extrusion-base-transition", static_cast<uint8_t>(Property::FillExtrusionBaseTransition) },
{ "fill-extrusion-color-transition", static_cast<uint8_t>(Property::FillExtrusionColorTransition) },
{ "fill-extrusion-height-transition", static_cast<uint8_t>(Property::FillExtrusionHeightTransition) },
{ "fill-extrusion-opacity-transition", static_cast<uint8_t>(Property::FillExtrusionOpacityTransition) },
{ "fill-extrusion-pattern-transition", static_cast<uint8_t>(Property::FillExtrusionPatternTransition) },
{ "fill-extrusion-translate-transition", static_cast<uint8_t>(Property::FillExtrusionTranslateTransition) },
{ "fill-extrusion-translate-anchor-transition", static_cast<uint8_t>(Property::FillExtrusionTranslateAnchorTransition) },
{ "fill-extrusion-vertical-gradient-transition", static_cast<uint8_t>(Property::FillExtrusionVerticalGradientTransition) }
{ "fill-extrusion-base", mbgl::underlying_type(Property::FillExtrusionBase) },
{ "fill-extrusion-color", mbgl::underlying_type(Property::FillExtrusionColor) },
{ "fill-extrusion-height", mbgl::underlying_type(Property::FillExtrusionHeight) },
{ "fill-extrusion-opacity", mbgl::underlying_type(Property::FillExtrusionOpacity) },
{ "fill-extrusion-pattern", mbgl::underlying_type(Property::FillExtrusionPattern) },
{ "fill-extrusion-translate", mbgl::underlying_type(Property::FillExtrusionTranslate) },
{ "fill-extrusion-translate-anchor", mbgl::underlying_type(Property::FillExtrusionTranslateAnchor) },
{ "fill-extrusion-vertical-gradient", mbgl::underlying_type(Property::FillExtrusionVerticalGradient) },
{ "fill-extrusion-base-transition", mbgl::underlying_type(Property::FillExtrusionBaseTransition) },
{ "fill-extrusion-color-transition", mbgl::underlying_type(Property::FillExtrusionColorTransition) },
{ "fill-extrusion-height-transition", mbgl::underlying_type(Property::FillExtrusionHeightTransition) },
{ "fill-extrusion-opacity-transition", mbgl::underlying_type(Property::FillExtrusionOpacityTransition) },
{ "fill-extrusion-pattern-transition", mbgl::underlying_type(Property::FillExtrusionPatternTransition) },
{ "fill-extrusion-translate-transition", mbgl::underlying_type(Property::FillExtrusionTranslateTransition) },
{ "fill-extrusion-translate-anchor-transition", mbgl::underlying_type(Property::FillExtrusionTranslateAnchorTransition) },
{ "fill-extrusion-vertical-gradient-transition", mbgl::underlying_type(Property::FillExtrusionVerticalGradientTransition) }
});
const auto it = properties.find(name.c_str());

31
src/mbgl/style/layers/fill_layer.cpp
View File

@@ -9,6 +9,7 @@
#include <mbgl/style/conversion/transition_options.hpp>
#include <mbgl/style/conversion/json.hpp>
#include <mbgl/style/conversion_impl.hpp>
#include <mbgl/util/traits.hpp>
#include <mapbox/eternal.hpp>
@@ -255,7 +256,7 @@ TransitionOptions FillLayer::getFillTranslateAnchorTransition() const {
using namespace conversion;
optional<Error> FillLayer::setPaintProperty(const std::string& name, const Convertible& value) {
enum class Property : uint8_t {
enum class Property {
FillAntialias,
FillColor,
FillOpacity,
@@ -273,20 +274,20 @@ optional<Error> FillLayer::setPaintProperty(const std::string& name, const Conve
};
MAPBOX_ETERNAL_CONSTEXPR const auto properties = mapbox::eternal::hash_map<mapbox::eternal::string, uint8_t>({
{ "fill-antialias", static_cast<uint8_t>(Property::FillAntialias) },
{ "fill-color", static_cast<uint8_t>(Property::FillColor) },
{ "fill-opacity", static_cast<uint8_t>(Property::FillOpacity) },
{ "fill-outline-color", static_cast<uint8_t>(Property::FillOutlineColor) },
{ "fill-pattern", static_cast<uint8_t>(Property::FillPattern) },
{ "fill-translate", static_cast<uint8_t>(Property::FillTranslate) },
{ "fill-translate-anchor", static_cast<uint8_t>(Property::FillTranslateAnchor) },
{ "fill-antialias-transition", static_cast<uint8_t>(Property::FillAntialiasTransition) },
{ "fill-color-transition", static_cast<uint8_t>(Property::FillColorTransition) },
{ "fill-opacity-transition", static_cast<uint8_t>(Property::FillOpacityTransition) },
{ "fill-outline-color-transition", static_cast<uint8_t>(Property::FillOutlineColorTransition) },
{ "fill-pattern-transition", static_cast<uint8_t>(Property::FillPatternTransition) },
{ "fill-translate-transition", static_cast<uint8_t>(Property::FillTranslateTransition) },
{ "fill-translate-anchor-transition", static_cast<uint8_t>(Property::FillTranslateAnchorTransition) }
{ "fill-antialias", mbgl::underlying_type(Property::FillAntialias) },
{ "fill-color", mbgl::underlying_type(Property::FillColor) },
{ "fill-opacity", mbgl::underlying_type(Property::FillOpacity) },
{ "fill-outline-color", mbgl::underlying_type(Property::FillOutlineColor) },
{ "fill-pattern", mbgl::underlying_type(Property::FillPattern) },
{ "fill-translate", mbgl::underlying_type(Property::FillTranslate) },
{ "fill-translate-anchor", mbgl::underlying_type(Property::FillTranslateAnchor) },
{ "fill-antialias-transition", mbgl::underlying_type(Property::FillAntialiasTransition) },
{ "fill-color-transition", mbgl::underlying_type(Property::FillColorTransition) },
{ "fill-opacity-transition", mbgl::underlying_type(Property::FillOpacityTransition) },
{ "fill-outline-color-transition", mbgl::underlying_type(Property::FillOutlineColorTransition) },
{ "fill-pattern-transition", mbgl::underlying_type(Property::FillPatternTransition) },
{ "fill-translate-transition", mbgl::underlying_type(Property::FillTranslateTransition) },
{ "fill-translate-anchor-transition", mbgl::underlying_type(Property::FillTranslateAnchorTransition) }
});
const auto it = properties.find(name.c_str());

23
src/mbgl/style/layers/heatmap_layer.cpp
View File

@@ -9,6 +9,7 @@
#include <mbgl/style/conversion/transition_options.hpp>
#include <mbgl/style/conversion/json.hpp>
#include <mbgl/style/conversion_impl.hpp>
#include <mbgl/util/traits.hpp>
#include <mapbox/eternal.hpp>
@@ -203,7 +204,7 @@ TransitionOptions HeatmapLayer::getHeatmapWeightTransition() const {
using namespace conversion;
optional<Error> HeatmapLayer::setPaintProperty(const std::string& name, const Convertible& value) {
enum class Property : uint8_t {
enum class Property {
HeatmapColor,
HeatmapIntensity,
HeatmapOpacity,
@@ -217,16 +218,16 @@ optional<Error> HeatmapLayer::setPaintProperty(const std::string& name, const Co
};
MAPBOX_ETERNAL_CONSTEXPR const auto properties = mapbox::eternal::hash_map<mapbox::eternal::string, uint8_t>({
{ "heatmap-color", static_cast<uint8_t>(Property::HeatmapColor) },
{ "heatmap-intensity", static_cast<uint8_t>(Property::HeatmapIntensity) },
{ "heatmap-opacity", static_cast<uint8_t>(Property::HeatmapOpacity) },
{ "heatmap-radius", static_cast<uint8_t>(Property::HeatmapRadius) },
{ "heatmap-weight", static_cast<uint8_t>(Property::HeatmapWeight) },
{ "heatmap-color-transition", static_cast<uint8_t>(Property::HeatmapColorTransition) },
{ "heatmap-intensity-transition", static_cast<uint8_t>(Property::HeatmapIntensityTransition) },
{ "heatmap-opacity-transition", static_cast<uint8_t>(Property::HeatmapOpacityTransition) },
{ "heatmap-radius-transition", static_cast<uint8_t>(Property::HeatmapRadiusTransition) },
{ "heatmap-weight-transition", static_cast<uint8_t>(Property::HeatmapWeightTransition) }
{ "heatmap-color", mbgl::underlying_type(Property::HeatmapColor) },
{ "heatmap-intensity", mbgl::underlying_type(Property::HeatmapIntensity) },
{ "heatmap-opacity", mbgl::underlying_type(Property::HeatmapOpacity) },
{ "heatmap-radius", mbgl::underlying_type(Property::HeatmapRadius) },
{ "heatmap-weight", mbgl::underlying_type(Property::HeatmapWeight) },
{ "heatmap-color-transition", mbgl::underlying_type(Property::HeatmapColorTransition) },
{ "heatmap-intensity-transition", mbgl::underlying_type(Property::HeatmapIntensityTransition) },
{ "heatmap-opacity-transition", mbgl::underlying_type(Property::HeatmapOpacityTransition) },
{ "heatmap-radius-transition", mbgl::underlying_type(Property::HeatmapRadiusTransition) },
{ "heatmap-weight-transition", mbgl::underlying_type(Property::HeatmapWeightTransition) }
});
const auto it = properties.find(name.c_str());

27
src/mbgl/style/layers/hillshade_layer.cpp
View File

@@ -9,6 +9,7 @@
#include <mbgl/style/conversion/transition_options.hpp>
#include <mbgl/style/conversion/json.hpp>
#include <mbgl/style/conversion_impl.hpp>
#include <mbgl/util/traits.hpp>
#include <mapbox/eternal.hpp>
@@ -228,7 +229,7 @@ TransitionOptions HillshadeLayer::getHillshadeShadowColorTransition() const {
using namespace conversion;
optional<Error> HillshadeLayer::setPaintProperty(const std::string& name, const Convertible& value) {
enum class Property : uint8_t {
enum class Property {
HillshadeAccentColor,
HillshadeExaggeration,
HillshadeHighlightColor,
@@ -244,18 +245,18 @@ optional<Error> HillshadeLayer::setPaintProperty(const std::string& name, const
};
MAPBOX_ETERNAL_CONSTEXPR const auto properties = mapbox::eternal::hash_map<mapbox::eternal::string, uint8_t>({
{ "hillshade-accent-color", static_cast<uint8_t>(Property::HillshadeAccentColor) },
{ "hillshade-exaggeration", static_cast<uint8_t>(Property::HillshadeExaggeration) },
{ "hillshade-highlight-color", static_cast<uint8_t>(Property::HillshadeHighlightColor) },
{ "hillshade-illumination-anchor", static_cast<uint8_t>(Property::HillshadeIlluminationAnchor) },
{ "hillshade-illumination-direction", static_cast<uint8_t>(Property::HillshadeIlluminationDirection) },
{ "hillshade-shadow-color", static_cast<uint8_t>(Property::HillshadeShadowColor) },
{ "hillshade-accent-color-transition", static_cast<uint8_t>(Property::HillshadeAccentColorTransition) },
{ "hillshade-exaggeration-transition", static_cast<uint8_t>(Property::HillshadeExaggerationTransition) },
{ "hillshade-highlight-color-transition", static_cast<uint8_t>(Property::HillshadeHighlightColorTransition) },
{ "hillshade-illumination-anchor-transition", static_cast<uint8_t>(Property::HillshadeIlluminationAnchorTransition) },
{ "hillshade-illumination-direction-transition", static_cast<uint8_t>(Property::HillshadeIlluminationDirectionTransition) },
{ "hillshade-shadow-color-transition", static_cast<uint8_t>(Property::HillshadeShadowColorTransition) }
{ "hillshade-accent-color", mbgl::underlying_type(Property::HillshadeAccentColor) },
{ "hillshade-exaggeration", mbgl::underlying_type(Property::HillshadeExaggeration) },
{ "hillshade-highlight-color", mbgl::underlying_type(Property::HillshadeHighlightColor) },
{ "hillshade-illumination-anchor", mbgl::underlying_type(Property::HillshadeIlluminationAnchor) },
{ "hillshade-illumination-direction", mbgl::underlying_type(Property::HillshadeIlluminationDirection) },
{ "hillshade-shadow-color", mbgl::underlying_type(Property::HillshadeShadowColor) },
{ "hillshade-accent-color-transition", mbgl::underlying_type(Property::HillshadeAccentColorTransition) },
{ "hillshade-exaggeration-transition", mbgl::underlying_type(Property::HillshadeExaggerationTransition) },
{ "hillshade-highlight-color-transition", mbgl::underlying_type(Property::HillshadeHighlightColorTransition) },
{ "hillshade-illumination-anchor-transition", mbgl::underlying_type(Property::HillshadeIlluminationAnchorTransition) },
{ "hillshade-illumination-direction-transition", mbgl::underlying_type(Property::HillshadeIlluminationDirectionTransition) },
{ "hillshade-shadow-color-transition", mbgl::underlying_type(Property::HillshadeShadowColorTransition) }
});
const auto it = properties.find(name.c_str());

9
src/mbgl/style/layers/layer.cpp.ejs
View File

@@ -14,6 +14,7 @@
#include <mbgl/style/conversion/transition_options.hpp>
#include <mbgl/style/conversion/json.hpp>
#include <mbgl/style/conversion_impl.hpp>
#include <mbgl/util/traits.hpp>
#include <mapbox/eternal.hpp>
@@ -176,7 +177,7 @@ TransitionOptions <%- camelize(type) %>Layer::get<%- camelize(property.name) %>T
using namespace conversion;
optional<Error> <%- camelize(type) %>Layer::setPaintProperty(const std::string& name, const Convertible& value) {
enum class Property : uint8_t {
enum class Property {
<% for (const property of paintProperties) { -%>
<%- camelize(property.name) %>,
<% } -%>
@@ -186,8 +187,8 @@ optional<Error> <%- camelize(type) %>Layer::setPaintProperty(const std::string&
};
MAPBOX_ETERNAL_CONSTEXPR const auto properties = mapbox::eternal::hash_map<mapbox::eternal::string, uint8_t>({
<%- paintProperties.map(p => `{ "${p.name}", static_cast<uint8_t>(Property::${camelize(p.name)}) }`).join(',\n ') %>,
<%- paintProperties.map(p => `{ "${p.name}-transition", static_cast<uint8_t>(Property::${camelize(p.name)}Transition) }`).join(',\n ') %>
<%- paintProperties.map(p => `{ "${p.name}", mbgl::underlying_type(Property::${camelize(p.name)}) }`).join(',\n ') %>,
<%- paintProperties.map(p => `{ "${p.name}-transition", mbgl::underlying_type(Property::${camelize(p.name)}Transition) }`).join(',\n ') %>
});
const auto it = properties.find(name.c_str());
@@ -254,7 +255,7 @@ optional<Error> <%- camelize(type) %>Layer::setLayoutProperty(const std::string&
<% } -%>
};
MAPBOX_ETERNAL_CONSTEXPR const auto properties = mapbox::eternal::hash_map<mapbox::eternal::string, uint8_t>({
<%- layoutProperties.map(p => `{ "${p.name}", static_cast<uint8_t>(Property::${camelize(p.name)}) }`).join(',\n ') %>
<%- layoutProperties.map(p => `{ "${p.name}", mbgl::underlying_type(Property::${camelize(p.name)}) }`).join(',\n ') %>
});
const auto it = properties.find(name.c_str());

55
src/mbgl/style/layers/line_layer.cpp
View File

@@ -9,6 +9,7 @@
#include <mbgl/style/conversion/transition_options.hpp>
#include <mbgl/style/conversion/json.hpp>
#include <mbgl/style/conversion_impl.hpp>
#include <mbgl/util/traits.hpp>
#include <mapbox/eternal.hpp>
@@ -429,7 +430,7 @@ TransitionOptions LineLayer::getLineWidthTransition() const {
using namespace conversion;
optional<Error> LineLayer::setPaintProperty(const std::string& name, const Convertible& value) {
enum class Property : uint8_t {
enum class Property {
LineBlur,
LineColor,
LineDasharray,
@@ -455,28 +456,28 @@ optional<Error> LineLayer::setPaintProperty(const std::string& name, const Conve
};
MAPBOX_ETERNAL_CONSTEXPR const auto properties = mapbox::eternal::hash_map<mapbox::eternal::string, uint8_t>({
{ "line-blur", static_cast<uint8_t>(Property::LineBlur) },
{ "line-color", static_cast<uint8_t>(Property::LineColor) },
{ "line-dasharray", static_cast<uint8_t>(Property::LineDasharray) },
{ "line-gap-width", static_cast<uint8_t>(Property::LineGapWidth) },
{ "line-gradient", static_cast<uint8_t>(Property::LineGradient) },
{ "line-offset", static_cast<uint8_t>(Property::LineOffset) },
{ "line-opacity", static_cast<uint8_t>(Property::LineOpacity) },
{ "line-pattern", static_cast<uint8_t>(Property::LinePattern) },
{ "line-translate", static_cast<uint8_t>(Property::LineTranslate) },
{ "line-translate-anchor", static_cast<uint8_t>(Property::LineTranslateAnchor) },
{ "line-width", static_cast<uint8_t>(Property::LineWidth) },
{ "line-blur-transition", static_cast<uint8_t>(Property::LineBlurTransition) },
{ "line-color-transition", static_cast<uint8_t>(Property::LineColorTransition) },
{ "line-dasharray-transition", static_cast<uint8_t>(Property::LineDasharrayTransition) },
{ "line-gap-width-transition", static_cast<uint8_t>(Property::LineGapWidthTransition) },
{ "line-gradient-transition", static_cast<uint8_t>(Property::LineGradientTransition) },
{ "line-offset-transition", static_cast<uint8_t>(Property::LineOffsetTransition) },
{ "line-opacity-transition", static_cast<uint8_t>(Property::LineOpacityTransition) },
{ "line-pattern-transition", static_cast<uint8_t>(Property::LinePatternTransition) },
{ "line-translate-transition", static_cast<uint8_t>(Property::LineTranslateTransition) },
{ "line-translate-anchor-transition", static_cast<uint8_t>(Property::LineTranslateAnchorTransition) },
{ "line-width-transition", static_cast<uint8_t>(Property::LineWidthTransition) }
{ "line-blur", mbgl::underlying_type(Property::LineBlur) },
{ "line-color", mbgl::underlying_type(Property::LineColor) },
{ "line-dasharray", mbgl::underlying_type(Property::LineDasharray) },
{ "line-gap-width", mbgl::underlying_type(Property::LineGapWidth) },
{ "line-gradient", mbgl::underlying_type(Property::LineGradient) },
{ "line-offset", mbgl::underlying_type(Property::LineOffset) },
{ "line-opacity", mbgl::underlying_type(Property::LineOpacity) },
{ "line-pattern", mbgl::underlying_type(Property::LinePattern) },
{ "line-translate", mbgl::underlying_type(Property::LineTranslate) },
{ "line-translate-anchor", mbgl::underlying_type(Property::LineTranslateAnchor) },
{ "line-width", mbgl::underlying_type(Property::LineWidth) },
{ "line-blur-transition", mbgl::underlying_type(Property::LineBlurTransition) },
{ "line-color-transition", mbgl::underlying_type(Property::LineColorTransition) },
{ "line-dasharray-transition", mbgl::underlying_type(Property::LineDasharrayTransition) },
{ "line-gap-width-transition", mbgl::underlying_type(Property::LineGapWidthTransition) },
{ "line-gradient-transition", mbgl::underlying_type(Property::LineGradientTransition) },
{ "line-offset-transition", mbgl::underlying_type(Property::LineOffsetTransition) },
{ "line-opacity-transition", mbgl::underlying_type(Property::LineOpacityTransition) },
{ "line-pattern-transition", mbgl::underlying_type(Property::LinePatternTransition) },
{ "line-translate-transition", mbgl::underlying_type(Property::LineTranslateTransition) },
{ "line-translate-anchor-transition", mbgl::underlying_type(Property::LineTranslateAnchorTransition) },
{ "line-width-transition", mbgl::underlying_type(Property::LineWidthTransition) }
});
const auto it = properties.find(name.c_str());
@@ -670,10 +671,10 @@ optional<Error> LineLayer::setLayoutProperty(const std::string& name, const Conv
LineRoundLimit,
};
MAPBOX_ETERNAL_CONSTEXPR const auto properties = mapbox::eternal::hash_map<mapbox::eternal::string, uint8_t>({
{ "line-cap", static_cast<uint8_t>(Property::LineCap) },
{ "line-join", static_cast<uint8_t>(Property::LineJoin) },
{ "line-miter-limit", static_cast<uint8_t>(Property::LineMiterLimit) },
{ "line-round-limit", static_cast<uint8_t>(Property::LineRoundLimit) }
{ "line-cap", mbgl::underlying_type(Property::LineCap) },
{ "line-join", mbgl::underlying_type(Property::LineJoin) },
{ "line-miter-limit", mbgl::underlying_type(Property::LineMiterLimit) },
{ "line-round-limit", mbgl::underlying_type(Property::LineRoundLimit) }
});
const auto it = properties.find(name.c_str());

35
src/mbgl/style/layers/raster_layer.cpp
View File

@@ -9,6 +9,7 @@
#include <mbgl/style/conversion/transition_options.hpp>
#include <mbgl/style/conversion/json.hpp>
#include <mbgl/style/conversion_impl.hpp>
#include <mbgl/util/traits.hpp>
#include <mapbox/eternal.hpp>
@@ -282,7 +283,7 @@ TransitionOptions RasterLayer::getRasterSaturationTransition() const {
using namespace conversion;
optional<Error> RasterLayer::setPaintProperty(const std::string& name, const Convertible& value) {
enum class Property : uint8_t {
enum class Property {
RasterBrightnessMax,
RasterBrightnessMin,
RasterContrast,
@@ -302,22 +303,22 @@ optional<Error> RasterLayer::setPaintProperty(const std::string& name, const Con
};
MAPBOX_ETERNAL_CONSTEXPR const auto properties = mapbox::eternal::hash_map<mapbox::eternal::string, uint8_t>({
{ "raster-brightness-max", static_cast<uint8_t>(Property::RasterBrightnessMax) },
{ "raster-brightness-min", static_cast<uint8_t>(Property::RasterBrightnessMin) },
{ "raster-contrast", static_cast<uint8_t>(Property::RasterContrast) },
{ "raster-fade-duration", static_cast<uint8_t>(Property::RasterFadeDuration) },
{ "raster-hue-rotate", static_cast<uint8_t>(Property::RasterHueRotate) },
{ "raster-opacity", static_cast<uint8_t>(Property::RasterOpacity) },
{ "raster-resampling", static_cast<uint8_t>(Property::RasterResampling) },
{ "raster-saturation", static_cast<uint8_t>(Property::RasterSaturation) },
{ "raster-brightness-max-transition", static_cast<uint8_t>(Property::RasterBrightnessMaxTransition) },
{ "raster-brightness-min-transition", static_cast<uint8_t>(Property::RasterBrightnessMinTransition) },
{ "raster-contrast-transition", static_cast<uint8_t>(Property::RasterContrastTransition) },
{ "raster-fade-duration-transition", static_cast<uint8_t>(Property::RasterFadeDurationTransition) },
{ "raster-hue-rotate-transition", static_cast<uint8_t>(Property::RasterHueRotateTransition) },
{ "raster-opacity-transition", static_cast<uint8_t>(Property::RasterOpacityTransition) },
{ "raster-resampling-transition", static_cast<uint8_t>(Property::RasterResamplingTransition) },
{ "raster-saturation-transition", static_cast<uint8_t>(Property::RasterSaturationTransition) }
{ "raster-brightness-max", mbgl::underlying_type(Property::RasterBrightnessMax) },
{ "raster-brightness-min", mbgl::underlying_type(Property::RasterBrightnessMin) },
{ "raster-contrast", mbgl::underlying_type(Property::RasterContrast) },
{ "raster-fade-duration", mbgl::underlying_type(Property::RasterFadeDuration) },
{ "raster-hue-rotate", mbgl::underlying_type(Property::RasterHueRotate) },
{ "raster-opacity", mbgl::underlying_type(Property::RasterOpacity) },
{ "raster-resampling", mbgl::underlying_type(Property::RasterResampling) },
{ "raster-saturation", mbgl::underlying_type(Property::RasterSaturation) },
{ "raster-brightness-max-transition", mbgl::underlying_type(Property::RasterBrightnessMaxTransition) },
{ "raster-brightness-min-transition", mbgl::underlying_type(Property::RasterBrightnessMinTransition) },
{ "raster-contrast-transition", mbgl::underlying_type(Property::RasterContrastTransition) },
{ "raster-fade-duration-transition", mbgl::underlying_type(Property::RasterFadeDurationTransition) },
{ "raster-hue-rotate-transition", mbgl::underlying_type(Property::RasterHueRotateTransition) },
{ "raster-opacity-transition", mbgl::underlying_type(Property::RasterOpacityTransition) },
{ "raster-resampling-transition", mbgl::underlying_type(Property::RasterResamplingTransition) },
{ "raster-saturation-transition", mbgl::underlying_type(Property::RasterSaturationTransition) }
});
const auto it = properties.find(name.c_str());

141
src/mbgl/style/layers/symbol_layer.cpp
View File

@@ -9,6 +9,7 @@
#include <mbgl/style/conversion/transition_options.hpp>
#include <mbgl/style/conversion/json.hpp>
#include <mbgl/style/conversion_impl.hpp>
#include <mbgl/util/traits.hpp>
#include <mapbox/eternal.hpp>
@@ -1101,7 +1102,7 @@ TransitionOptions SymbolLayer::getTextTranslateAnchorTransition() const {
using namespace conversion;
optional<Error> SymbolLayer::setPaintProperty(const std::string& name, const Convertible& value) {
enum class Property : uint8_t {
enum class Property {
IconColor,
IconHaloBlur,
IconHaloColor,
@@ -1133,34 +1134,34 @@ optional<Error> SymbolLayer::setPaintProperty(const std::string& name, const Con
};
MAPBOX_ETERNAL_CONSTEXPR const auto properties = mapbox::eternal::hash_map<mapbox::eternal::string, uint8_t>({
{ "icon-color", static_cast<uint8_t>(Property::IconColor) },
{ "icon-halo-blur", static_cast<uint8_t>(Property::IconHaloBlur) },
{ "icon-halo-color", static_cast<uint8_t>(Property::IconHaloColor) },
{ "icon-halo-width", static_cast<uint8_t>(Property::IconHaloWidth) },
{ "icon-opacity", static_cast<uint8_t>(Property::IconOpacity) },
{ "icon-translate", static_cast<uint8_t>(Property::IconTranslate) },
{ "icon-translate-anchor", static_cast<uint8_t>(Property::IconTranslateAnchor) },
{ "text-color", static_cast<uint8_t>(Property::TextColor) },
{ "text-halo-blur", static_cast<uint8_t>(Property::TextHaloBlur) },
{ "text-halo-color", static_cast<uint8_t>(Property::TextHaloColor) },
{ "text-halo-width", static_cast<uint8_t>(Property::TextHaloWidth) },
{ "text-opacity", static_cast<uint8_t>(Property::TextOpacity) },
{ "text-translate", static_cast<uint8_t>(Property::TextTranslate) },
{ "text-translate-anchor", static_cast<uint8_t>(Property::TextTranslateAnchor) },
{ "icon-color-transition", static_cast<uint8_t>(Property::IconColorTransition) },
{ "icon-halo-blur-transition", static_cast<uint8_t>(Property::IconHaloBlurTransition) },
{ "icon-halo-color-transition", static_cast<uint8_t>(Property::IconHaloColorTransition) },
{ "icon-halo-width-transition", static_cast<uint8_t>(Property::IconHaloWidthTransition) },
{ "icon-opacity-transition", static_cast<uint8_t>(Property::IconOpacityTransition) },
{ "icon-translate-transition", static_cast<uint8_t>(Property::IconTranslateTransition) },
{ "icon-translate-anchor-transition", static_cast<uint8_t>(Property::IconTranslateAnchorTransition) },
{ "text-color-transition", static_cast<uint8_t>(Property::TextColorTransition) },
{ "text-halo-blur-transition", static_cast<uint8_t>(Property::TextHaloBlurTransition) },
{ "text-halo-color-transition", static_cast<uint8_t>(Property::TextHaloColorTransition) },
{ "text-halo-width-transition", static_cast<uint8_t>(Property::TextHaloWidthTransition) },
{ "text-opacity-transition", static_cast<uint8_t>(Property::TextOpacityTransition) },
{ "text-translate-transition", static_cast<uint8_t>(Property::TextTranslateTransition) },
{ "text-translate-anchor-transition", static_cast<uint8_t>(Property::TextTranslateAnchorTransition) }
{ "icon-color", mbgl::underlying_type(Property::IconColor) },
{ "icon-halo-blur", mbgl::underlying_type(Property::IconHaloBlur) },
{ "icon-halo-color", mbgl::underlying_type(Property::IconHaloColor) },
{ "icon-halo-width", mbgl::underlying_type(Property::IconHaloWidth) },
{ "icon-opacity", mbgl::underlying_type(Property::IconOpacity) },
{ "icon-translate", mbgl::underlying_type(Property::IconTranslate) },
{ "icon-translate-anchor", mbgl::underlying_type(Property::IconTranslateAnchor) },
{ "text-color", mbgl::underlying_type(Property::TextColor) },
{ "text-halo-blur", mbgl::underlying_type(Property::TextHaloBlur) },
{ "text-halo-color", mbgl::underlying_type(Property::TextHaloColor) },
{ "text-halo-width", mbgl::underlying_type(Property::TextHaloWidth) },
{ "text-opacity", mbgl::underlying_type(Property::TextOpacity) },
{ "text-translate", mbgl::underlying_type(Property::TextTranslate) },
{ "text-translate-anchor", mbgl::underlying_type(Property::TextTranslateAnchor) },
{ "icon-color-transition", mbgl::underlying_type(Property::IconColorTransition) },
{ "icon-halo-blur-transition", mbgl::underlying_type(Property::IconHaloBlurTransition) },
{ "icon-halo-color-transition", mbgl::underlying_type(Property::IconHaloColorTransition) },
{ "icon-halo-width-transition", mbgl::underlying_type(Property::IconHaloWidthTransition) },
{ "icon-opacity-transition", mbgl::underlying_type(Property::IconOpacityTransition) },
{ "icon-translate-transition", mbgl::underlying_type(Property::IconTranslateTransition) },
{ "icon-translate-anchor-transition", mbgl::underlying_type(Property::IconTranslateAnchorTransition) },
{ "text-color-transition", mbgl::underlying_type(Property::TextColorTransition) },
{ "text-halo-blur-transition", mbgl::underlying_type(Property::TextHaloBlurTransition) },
{ "text-halo-color-transition", mbgl::underlying_type(Property::TextHaloColorTransition) },
{ "text-halo-width-transition", mbgl::underlying_type(Property::TextHaloWidthTransition) },
{ "text-opacity-transition", mbgl::underlying_type(Property::TextOpacityTransition) },
{ "text-translate-transition", mbgl::underlying_type(Property::TextTranslateTransition) },
{ "text-translate-anchor-transition", mbgl::underlying_type(Property::TextTranslateAnchorTransition) }
});
const auto it = properties.find(name.c_str());
@@ -1406,47 +1407,47 @@ optional<Error> SymbolLayer::setLayoutProperty(const std::string& name, const Co
TextWritingMode,
};
MAPBOX_ETERNAL_CONSTEXPR const auto properties = mapbox::eternal::hash_map<mapbox::eternal::string, uint8_t>({
{ "icon-allow-overlap", static_cast<uint8_t>(Property::IconAllowOverlap) },
{ "icon-anchor", static_cast<uint8_t>(Property::IconAnchor) },
{ "icon-ignore-placement", static_cast<uint8_t>(Property::IconIgnorePlacement) },
{ "icon-image", static_cast<uint8_t>(Property::IconImage) },
{ "icon-keep-upright", static_cast<uint8_t>(Property::IconKeepUpright) },
{ "icon-offset", static_cast<uint8_t>(Property::IconOffset) },
{ "icon-optional", static_cast<uint8_t>(Property::IconOptional) },
{ "icon-padding", static_cast<uint8_t>(Property::IconPadding) },
{ "icon-pitch-alignment", static_cast<uint8_t>(Property::IconPitchAlignment) },
{ "icon-rotate", static_cast<uint8_t>(Property::IconRotate) },
{ "icon-rotation-alignment", static_cast<uint8_t>(Property::IconRotationAlignment) },
{ "icon-size", static_cast<uint8_t>(Property::IconSize) },
{ "icon-text-fit", static_cast<uint8_t>(Property::IconTextFit) },
{ "icon-text-fit-padding", static_cast<uint8_t>(Property::IconTextFitPadding) },
{ "symbol-avoid-edges", static_cast<uint8_t>(Property::SymbolAvoidEdges) },
{ "symbol-placement", static_cast<uint8_t>(Property::SymbolPlacement) },
{ "symbol-sort-key", static_cast<uint8_t>(Property::SymbolSortKey) },
{ "symbol-spacing", static_cast<uint8_t>(Property::SymbolSpacing) },
{ "symbol-z-order", static_cast<uint8_t>(Property::SymbolZOrder) },
{ "text-allow-overlap", static_cast<uint8_t>(Property::TextAllowOverlap) },
{ "text-anchor", static_cast<uint8_t>(Property::TextAnchor) },
{ "text-field", static_cast<uint8_t>(Property::TextField) },
{ "text-font", static_cast<uint8_t>(Property::TextFont) },
{ "text-ignore-placement", static_cast<uint8_t>(Property::TextIgnorePlacement) },
{ "text-justify", static_cast<uint8_t>(Property::TextJustify) },
{ "text-keep-upright", static_cast<uint8_t>(Property::TextKeepUpright) },
{ "text-letter-spacing", static_cast<uint8_t>(Property::TextLetterSpacing) },
{ "text-line-height", static_cast<uint8_t>(Property::TextLineHeight) },
{ "text-max-angle", static_cast<uint8_t>(Property::TextMaxAngle) },
{ "text-max-width", static_cast<uint8_t>(Property::TextMaxWidth) },
{ "text-offset", static_cast<uint8_t>(Property::TextOffset) },
{ "text-optional", static_cast<uint8_t>(Property::TextOptional) },
{ "text-padding", static_cast<uint8_t>(Property::TextPadding) },
{ "text-pitch-alignment", static_cast<uint8_t>(Property::TextPitchAlignment) },
{ "text-radial-offset", static_cast<uint8_t>(Property::TextRadialOffset) },
{ "text-rotate", static_cast<uint8_t>(Property::TextRotate) },
{ "text-rotation-alignment", static_cast<uint8_t>(Property::TextRotationAlignment) },
{ "text-size", static_cast<uint8_t>(Property::TextSize) },
{ "text-transform", static_cast<uint8_t>(Property::TextTransform) },
{ "text-variable-anchor", static_cast<uint8_t>(Property::TextVariableAnchor) },
{ "text-writing-mode", static_cast<uint8_t>(Property::TextWritingMode) }
{ "icon-allow-overlap", mbgl::underlying_type(Property::IconAllowOverlap) },
{ "icon-anchor", mbgl::underlying_type(Property::IconAnchor) },
{ "icon-ignore-placement", mbgl::underlying_type(Property::IconIgnorePlacement) },
{ "icon-image", mbgl::underlying_type(Property::IconImage) },
{ "icon-keep-upright", mbgl::underlying_type(Property::IconKeepUpright) },
{ "icon-offset", mbgl::underlying_type(Property::IconOffset) },
{ "icon-optional", mbgl::underlying_type(Property::IconOptional) },
{ "icon-padding", mbgl::underlying_type(Property::IconPadding) },
{ "icon-pitch-alignment", mbgl::underlying_type(Property::IconPitchAlignment) },
{ "icon-rotate", mbgl::underlying_type(Property::IconRotate) },
{ "icon-rotation-alignment", mbgl::underlying_type(Property::IconRotationAlignment) },
{ "icon-size", mbgl::underlying_type(Property::IconSize) },
{ "icon-text-fit", mbgl::underlying_type(Property::IconTextFit) },
{ "icon-text-fit-padding", mbgl::underlying_type(Property::IconTextFitPadding) },
{ "symbol-avoid-edges", mbgl::underlying_type(Property::SymbolAvoidEdges) },
{ "symbol-placement", mbgl::underlying_type(Property::SymbolPlacement) },
{ "symbol-sort-key", mbgl::underlying_type(Property::SymbolSortKey) },
{ "symbol-spacing", mbgl::underlying_type(Property::SymbolSpacing) },
{ "symbol-z-order", mbgl::underlying_type(Property::SymbolZOrder) },
{ "text-allow-overlap", mbgl::underlying_type(Property::TextAllowOverlap) },
{ "text-anchor", mbgl::underlying_type(Property::TextAnchor) },
{ "text-field", mbgl::underlying_type(Property::TextField) },
{ "text-font", mbgl::underlying_type(Property::TextFont) },
{ "text-ignore-placement", mbgl::underlying_type(Property::TextIgnorePlacement) },
{ "text-justify", mbgl::underlying_type(Property::TextJustify) },
{ "text-keep-upright", mbgl::underlying_type(Property::TextKeepUpright) },
{ "text-letter-spacing", mbgl::underlying_type(Property::TextLetterSpacing) },
{ "text-line-height", mbgl::underlying_type(Property::TextLineHeight) },
{ "text-max-angle", mbgl::underlying_type(Property::TextMaxAngle) },
{ "text-max-width", mbgl::underlying_type(Property::TextMaxWidth) },
{ "text-offset", mbgl::underlying_type(Property::TextOffset) },
{ "text-optional", mbgl::underlying_type(Property::TextOptional) },
{ "text-padding", mbgl::underlying_type(Property::TextPadding) },
{ "text-pitch-alignment", mbgl::underlying_type(Property::TextPitchAlignment) },
{ "text-radial-offset", mbgl::underlying_type(Property::TextRadialOffset) },
{ "text-rotate", mbgl::underlying_type(Property::TextRotate) },
{ "text-rotation-alignment", mbgl::underlying_type(Property::TextRotationAlignment) },
{ "text-size", mbgl::underlying_type(Property::TextSize) },
{ "text-transform", mbgl::underlying_type(Property::TextTransform) },
{ "text-variable-anchor", mbgl::underlying_type(Property::TextVariableAnchor) },
{ "text-writing-mode", mbgl::underlying_type(Property::TextWritingMode) }
});
const auto it = properties.find(name.c_str());

19
src/mbgl/style/light.cpp
View File

@@ -8,6 +8,7 @@
#include <mbgl/style/conversion/transition_options.hpp>
#include <mbgl/style/conversion/json.hpp>
#include <mbgl/style/conversion_impl.hpp>
#include <mbgl/util/traits.hpp>
#include <mapbox/eternal.hpp>
@@ -34,7 +35,7 @@ Mutable<Light::Impl> Light::mutableImpl() const {
using namespace conversion;
optional<Error> Light::setProperty(const std::string& name, const Convertible& value) {
enum class Property : uint8_t {
enum class Property {
Anchor,
Color,
Intensity,
@@ -46,14 +47,14 @@ optional<Error> Light::setProperty(const std::string& name, const Convertible& v
};
MAPBOX_ETERNAL_CONSTEXPR const auto properties = mapbox::eternal::hash_map<mapbox::eternal::string, uint8_t>({
{ "anchor", static_cast<uint8_t>(Property::Anchor) },
{ "color", static_cast<uint8_t>(Property::Color) },
{ "intensity", static_cast<uint8_t>(Property::Intensity) },
{ "position", static_cast<uint8_t>(Property::Position) },
{ "anchor-transition", static_cast<uint8_t>(Property::AnchorTransition) },
{ "color-transition", static_cast<uint8_t>(Property::ColorTransition) },
{ "intensity-transition", static_cast<uint8_t>(Property::IntensityTransition) },
{ "position-transition", static_cast<uint8_t>(Property::PositionTransition) }
{ "anchor", mbgl::underlying_type(Property::Anchor) },
{ "color", mbgl::underlying_type(Property::Color) },
{ "intensity", mbgl::underlying_type(Property::Intensity) },
{ "position", mbgl::underlying_type(Property::Position) },
{ "anchor-transition", mbgl::underlying_type(Property::AnchorTransition) },
{ "color-transition", mbgl::underlying_type(Property::ColorTransition) },
{ "intensity-transition", mbgl::underlying_type(Property::IntensityTransition) },
{ "position-transition", mbgl::underlying_type(Property::PositionTransition) }
});
const auto it = properties.find(name.c_str());

7
src/mbgl/style/light.cpp.ejs
View File

@@ -11,6 +11,7 @@
#include <mbgl/style/conversion/transition_options.hpp>
#include <mbgl/style/conversion/json.hpp>
#include <mbgl/style/conversion_impl.hpp>
#include <mbgl/util/traits.hpp>
#include <mapbox/eternal.hpp>
@@ -37,7 +38,7 @@ Mutable<Light::Impl> Light::mutableImpl() const {
using namespace conversion;
optional<Error> Light::setProperty(const std::string& name, const Convertible& value) {
enum class Property : uint8_t {
enum class Property {
<% for (const property of properties) { -%>
<%- camelize(property.name) %>,
<% } -%>
@@ -47,8 +48,8 @@ optional<Error> Light::setProperty(const std::string& name, const Convertible& v
};
MAPBOX_ETERNAL_CONSTEXPR const auto properties = mapbox::eternal::hash_map<mapbox::eternal::string, uint8_t>({
<%- properties.map(p => `{ "${p.name}", static_cast<uint8_t>(Property::${camelize(p.name)}) }`).join(',\n ') %>,
<%- properties.map(p => `{ "${p.name}-transition", static_cast<uint8_t>(Property::${camelize(p.name)}Transition) }`).join(',\n ') %>
<%- properties.map(p => `{ "${p.name}", mbgl::underlying_type(Property::${camelize(p.name)}) }`).join(',\n ') %>,
<%- properties.map(p => `{ "${p.name}-transition", mbgl::underlying_type(Property::${camelize(p.name)}Transition) }`).join(',\n ') %>
});
const auto it = properties.find(name.c_str());