[core] clang-tidy fixes
This commit is contained in:
@@ -1,2 +1,3 @@
|
||||
Checks: 'modernize-*,misc-static-assert,llvm-namespace-comment,-clang-analyzer-security.insecureAPI.rand,-clang-analyzer-core.uninitialized.UndefReturn,-clang-analyzer-core.StackAddressEscape,-clang-analyzer-core.CallAndMessage,-clang-diagnostic-unused-command-line-argument,-clang-analyzer-core.uninitialized.*,-clang-analyzer-core.NullDereference,-clang-analyzer-core.NonNullParamChecker'
|
||||
HeaderFilterRegex: '\/mbgl\/'
|
||||
WarningsAsErrors: '*'
|
||||
FormatStyle: file
|
||||
|
||||
@@ -197,7 +197,7 @@ int main(int argc, char *argv[]) {
|
||||
: region(region_),
|
||||
fileSource(fileSource_),
|
||||
loop(loop_),
|
||||
mergePath(mergePath_),
|
||||
mergePath(std::move(mergePath_)),
|
||||
start(util::now()) {
|
||||
}
|
||||
|
||||
|
||||
@@ -488,8 +488,8 @@ jobs:
|
||||
- image: mbgl/linux-clang-7:a5a3c52107
|
||||
working_directory: /src
|
||||
environment:
|
||||
LIBSYSCONFCPUS: 2
|
||||
JOBS: 2
|
||||
LIBSYSCONFCPUS: 4
|
||||
JOBS: 4
|
||||
BUILDTYPE: Debug
|
||||
steps:
|
||||
- install-dependencies: { ccache: false }
|
||||
|
||||
@@ -25,20 +25,20 @@ public:
|
||||
// Paint properties
|
||||
|
||||
static PropertyValue<Color> getDefaultBackgroundColor();
|
||||
PropertyValue<Color> getBackgroundColor() const;
|
||||
void setBackgroundColor(PropertyValue<Color>);
|
||||
const PropertyValue<Color>& getBackgroundColor() const;
|
||||
void setBackgroundColor(const PropertyValue<Color>&);
|
||||
void setBackgroundColorTransition(const TransitionOptions&);
|
||||
TransitionOptions getBackgroundColorTransition() const;
|
||||
|
||||
static PropertyValue<std::string> getDefaultBackgroundPattern();
|
||||
PropertyValue<std::string> getBackgroundPattern() const;
|
||||
void setBackgroundPattern(PropertyValue<std::string>);
|
||||
const PropertyValue<std::string>& getBackgroundPattern() const;
|
||||
void setBackgroundPattern(const PropertyValue<std::string>&);
|
||||
void setBackgroundPatternTransition(const TransitionOptions&);
|
||||
TransitionOptions getBackgroundPatternTransition() const;
|
||||
|
||||
static PropertyValue<float> getDefaultBackgroundOpacity();
|
||||
PropertyValue<float> getBackgroundOpacity() const;
|
||||
void setBackgroundOpacity(PropertyValue<float>);
|
||||
const PropertyValue<float>& getBackgroundOpacity() const;
|
||||
void setBackgroundOpacity(const PropertyValue<float>&);
|
||||
void setBackgroundOpacityTransition(const TransitionOptions&);
|
||||
TransitionOptions getBackgroundOpacityTransition() const;
|
||||
|
||||
|
||||
@@ -25,68 +25,68 @@ public:
|
||||
// Paint properties
|
||||
|
||||
static PropertyValue<float> getDefaultCircleRadius();
|
||||
PropertyValue<float> getCircleRadius() const;
|
||||
void setCircleRadius(PropertyValue<float>);
|
||||
const PropertyValue<float>& getCircleRadius() const;
|
||||
void setCircleRadius(const PropertyValue<float>&);
|
||||
void setCircleRadiusTransition(const TransitionOptions&);
|
||||
TransitionOptions getCircleRadiusTransition() const;
|
||||
|
||||
static PropertyValue<Color> getDefaultCircleColor();
|
||||
PropertyValue<Color> getCircleColor() const;
|
||||
void setCircleColor(PropertyValue<Color>);
|
||||
const PropertyValue<Color>& getCircleColor() const;
|
||||
void setCircleColor(const PropertyValue<Color>&);
|
||||
void setCircleColorTransition(const TransitionOptions&);
|
||||
TransitionOptions getCircleColorTransition() const;
|
||||
|
||||
static PropertyValue<float> getDefaultCircleBlur();
|
||||
PropertyValue<float> getCircleBlur() const;
|
||||
void setCircleBlur(PropertyValue<float>);
|
||||
const PropertyValue<float>& getCircleBlur() const;
|
||||
void setCircleBlur(const PropertyValue<float>&);
|
||||
void setCircleBlurTransition(const TransitionOptions&);
|
||||
TransitionOptions getCircleBlurTransition() const;
|
||||
|
||||
static PropertyValue<float> getDefaultCircleOpacity();
|
||||
PropertyValue<float> getCircleOpacity() const;
|
||||
void setCircleOpacity(PropertyValue<float>);
|
||||
const PropertyValue<float>& getCircleOpacity() const;
|
||||
void setCircleOpacity(const PropertyValue<float>&);
|
||||
void setCircleOpacityTransition(const TransitionOptions&);
|
||||
TransitionOptions getCircleOpacityTransition() const;
|
||||
|
||||
static PropertyValue<std::array<float, 2>> getDefaultCircleTranslate();
|
||||
PropertyValue<std::array<float, 2>> getCircleTranslate() const;
|
||||
void setCircleTranslate(PropertyValue<std::array<float, 2>>);
|
||||
const PropertyValue<std::array<float, 2>>& getCircleTranslate() const;
|
||||
void setCircleTranslate(const PropertyValue<std::array<float, 2>>&);
|
||||
void setCircleTranslateTransition(const TransitionOptions&);
|
||||
TransitionOptions getCircleTranslateTransition() const;
|
||||
|
||||
static PropertyValue<TranslateAnchorType> getDefaultCircleTranslateAnchor();
|
||||
PropertyValue<TranslateAnchorType> getCircleTranslateAnchor() const;
|
||||
void setCircleTranslateAnchor(PropertyValue<TranslateAnchorType>);
|
||||
const PropertyValue<TranslateAnchorType>& getCircleTranslateAnchor() const;
|
||||
void setCircleTranslateAnchor(const PropertyValue<TranslateAnchorType>&);
|
||||
void setCircleTranslateAnchorTransition(const TransitionOptions&);
|
||||
TransitionOptions getCircleTranslateAnchorTransition() const;
|
||||
|
||||
static PropertyValue<CirclePitchScaleType> getDefaultCirclePitchScale();
|
||||
PropertyValue<CirclePitchScaleType> getCirclePitchScale() const;
|
||||
void setCirclePitchScale(PropertyValue<CirclePitchScaleType>);
|
||||
const PropertyValue<CirclePitchScaleType>& getCirclePitchScale() const;
|
||||
void setCirclePitchScale(const PropertyValue<CirclePitchScaleType>&);
|
||||
void setCirclePitchScaleTransition(const TransitionOptions&);
|
||||
TransitionOptions getCirclePitchScaleTransition() const;
|
||||
|
||||
static PropertyValue<AlignmentType> getDefaultCirclePitchAlignment();
|
||||
PropertyValue<AlignmentType> getCirclePitchAlignment() const;
|
||||
void setCirclePitchAlignment(PropertyValue<AlignmentType>);
|
||||
const PropertyValue<AlignmentType>& getCirclePitchAlignment() const;
|
||||
void setCirclePitchAlignment(const PropertyValue<AlignmentType>&);
|
||||
void setCirclePitchAlignmentTransition(const TransitionOptions&);
|
||||
TransitionOptions getCirclePitchAlignmentTransition() const;
|
||||
|
||||
static PropertyValue<float> getDefaultCircleStrokeWidth();
|
||||
PropertyValue<float> getCircleStrokeWidth() const;
|
||||
void setCircleStrokeWidth(PropertyValue<float>);
|
||||
const PropertyValue<float>& getCircleStrokeWidth() const;
|
||||
void setCircleStrokeWidth(const PropertyValue<float>&);
|
||||
void setCircleStrokeWidthTransition(const TransitionOptions&);
|
||||
TransitionOptions getCircleStrokeWidthTransition() const;
|
||||
|
||||
static PropertyValue<Color> getDefaultCircleStrokeColor();
|
||||
PropertyValue<Color> getCircleStrokeColor() const;
|
||||
void setCircleStrokeColor(PropertyValue<Color>);
|
||||
const PropertyValue<Color>& getCircleStrokeColor() const;
|
||||
void setCircleStrokeColor(const PropertyValue<Color>&);
|
||||
void setCircleStrokeColorTransition(const TransitionOptions&);
|
||||
TransitionOptions getCircleStrokeColorTransition() const;
|
||||
|
||||
static PropertyValue<float> getDefaultCircleStrokeOpacity();
|
||||
PropertyValue<float> getCircleStrokeOpacity() const;
|
||||
void setCircleStrokeOpacity(PropertyValue<float>);
|
||||
const PropertyValue<float>& getCircleStrokeOpacity() const;
|
||||
void setCircleStrokeOpacity(const PropertyValue<float>&);
|
||||
void setCircleStrokeOpacityTransition(const TransitionOptions&);
|
||||
TransitionOptions getCircleStrokeOpacityTransition() const;
|
||||
|
||||
|
||||
@@ -25,50 +25,50 @@ public:
|
||||
// Paint properties
|
||||
|
||||
static PropertyValue<float> getDefaultFillExtrusionOpacity();
|
||||
PropertyValue<float> getFillExtrusionOpacity() const;
|
||||
void setFillExtrusionOpacity(PropertyValue<float>);
|
||||
const PropertyValue<float>& getFillExtrusionOpacity() const;
|
||||
void setFillExtrusionOpacity(const PropertyValue<float>&);
|
||||
void setFillExtrusionOpacityTransition(const TransitionOptions&);
|
||||
TransitionOptions getFillExtrusionOpacityTransition() const;
|
||||
|
||||
static PropertyValue<Color> getDefaultFillExtrusionColor();
|
||||
PropertyValue<Color> getFillExtrusionColor() const;
|
||||
void setFillExtrusionColor(PropertyValue<Color>);
|
||||
const PropertyValue<Color>& getFillExtrusionColor() const;
|
||||
void setFillExtrusionColor(const PropertyValue<Color>&);
|
||||
void setFillExtrusionColorTransition(const TransitionOptions&);
|
||||
TransitionOptions getFillExtrusionColorTransition() const;
|
||||
|
||||
static PropertyValue<std::array<float, 2>> getDefaultFillExtrusionTranslate();
|
||||
PropertyValue<std::array<float, 2>> getFillExtrusionTranslate() const;
|
||||
void setFillExtrusionTranslate(PropertyValue<std::array<float, 2>>);
|
||||
const PropertyValue<std::array<float, 2>>& getFillExtrusionTranslate() const;
|
||||
void setFillExtrusionTranslate(const PropertyValue<std::array<float, 2>>&);
|
||||
void setFillExtrusionTranslateTransition(const TransitionOptions&);
|
||||
TransitionOptions getFillExtrusionTranslateTransition() const;
|
||||
|
||||
static PropertyValue<TranslateAnchorType> getDefaultFillExtrusionTranslateAnchor();
|
||||
PropertyValue<TranslateAnchorType> getFillExtrusionTranslateAnchor() const;
|
||||
void setFillExtrusionTranslateAnchor(PropertyValue<TranslateAnchorType>);
|
||||
const PropertyValue<TranslateAnchorType>& getFillExtrusionTranslateAnchor() const;
|
||||
void setFillExtrusionTranslateAnchor(const PropertyValue<TranslateAnchorType>&);
|
||||
void setFillExtrusionTranslateAnchorTransition(const TransitionOptions&);
|
||||
TransitionOptions getFillExtrusionTranslateAnchorTransition() const;
|
||||
|
||||
static PropertyValue<std::string> getDefaultFillExtrusionPattern();
|
||||
PropertyValue<std::string> getFillExtrusionPattern() const;
|
||||
void setFillExtrusionPattern(PropertyValue<std::string>);
|
||||
const PropertyValue<std::string>& getFillExtrusionPattern() const;
|
||||
void setFillExtrusionPattern(const PropertyValue<std::string>&);
|
||||
void setFillExtrusionPatternTransition(const TransitionOptions&);
|
||||
TransitionOptions getFillExtrusionPatternTransition() const;
|
||||
|
||||
static PropertyValue<float> getDefaultFillExtrusionHeight();
|
||||
PropertyValue<float> getFillExtrusionHeight() const;
|
||||
void setFillExtrusionHeight(PropertyValue<float>);
|
||||
const PropertyValue<float>& getFillExtrusionHeight() const;
|
||||
void setFillExtrusionHeight(const PropertyValue<float>&);
|
||||
void setFillExtrusionHeightTransition(const TransitionOptions&);
|
||||
TransitionOptions getFillExtrusionHeightTransition() const;
|
||||
|
||||
static PropertyValue<float> getDefaultFillExtrusionBase();
|
||||
PropertyValue<float> getFillExtrusionBase() const;
|
||||
void setFillExtrusionBase(PropertyValue<float>);
|
||||
const PropertyValue<float>& getFillExtrusionBase() const;
|
||||
void setFillExtrusionBase(const PropertyValue<float>&);
|
||||
void setFillExtrusionBaseTransition(const TransitionOptions&);
|
||||
TransitionOptions getFillExtrusionBaseTransition() const;
|
||||
|
||||
static PropertyValue<bool> getDefaultFillExtrusionVerticalGradient();
|
||||
PropertyValue<bool> getFillExtrusionVerticalGradient() const;
|
||||
void setFillExtrusionVerticalGradient(PropertyValue<bool>);
|
||||
const PropertyValue<bool>& getFillExtrusionVerticalGradient() const;
|
||||
void setFillExtrusionVerticalGradient(const PropertyValue<bool>&);
|
||||
void setFillExtrusionVerticalGradientTransition(const TransitionOptions&);
|
||||
TransitionOptions getFillExtrusionVerticalGradientTransition() const;
|
||||
|
||||
|
||||
@@ -25,44 +25,44 @@ public:
|
||||
// Paint properties
|
||||
|
||||
static PropertyValue<bool> getDefaultFillAntialias();
|
||||
PropertyValue<bool> getFillAntialias() const;
|
||||
void setFillAntialias(PropertyValue<bool>);
|
||||
const PropertyValue<bool>& getFillAntialias() const;
|
||||
void setFillAntialias(const PropertyValue<bool>&);
|
||||
void setFillAntialiasTransition(const TransitionOptions&);
|
||||
TransitionOptions getFillAntialiasTransition() const;
|
||||
|
||||
static PropertyValue<float> getDefaultFillOpacity();
|
||||
PropertyValue<float> getFillOpacity() const;
|
||||
void setFillOpacity(PropertyValue<float>);
|
||||
const PropertyValue<float>& getFillOpacity() const;
|
||||
void setFillOpacity(const PropertyValue<float>&);
|
||||
void setFillOpacityTransition(const TransitionOptions&);
|
||||
TransitionOptions getFillOpacityTransition() const;
|
||||
|
||||
static PropertyValue<Color> getDefaultFillColor();
|
||||
PropertyValue<Color> getFillColor() const;
|
||||
void setFillColor(PropertyValue<Color>);
|
||||
const PropertyValue<Color>& getFillColor() const;
|
||||
void setFillColor(const PropertyValue<Color>&);
|
||||
void setFillColorTransition(const TransitionOptions&);
|
||||
TransitionOptions getFillColorTransition() const;
|
||||
|
||||
static PropertyValue<Color> getDefaultFillOutlineColor();
|
||||
PropertyValue<Color> getFillOutlineColor() const;
|
||||
void setFillOutlineColor(PropertyValue<Color>);
|
||||
const PropertyValue<Color>& getFillOutlineColor() const;
|
||||
void setFillOutlineColor(const PropertyValue<Color>&);
|
||||
void setFillOutlineColorTransition(const TransitionOptions&);
|
||||
TransitionOptions getFillOutlineColorTransition() const;
|
||||
|
||||
static PropertyValue<std::array<float, 2>> getDefaultFillTranslate();
|
||||
PropertyValue<std::array<float, 2>> getFillTranslate() const;
|
||||
void setFillTranslate(PropertyValue<std::array<float, 2>>);
|
||||
const PropertyValue<std::array<float, 2>>& getFillTranslate() const;
|
||||
void setFillTranslate(const PropertyValue<std::array<float, 2>>&);
|
||||
void setFillTranslateTransition(const TransitionOptions&);
|
||||
TransitionOptions getFillTranslateTransition() const;
|
||||
|
||||
static PropertyValue<TranslateAnchorType> getDefaultFillTranslateAnchor();
|
||||
PropertyValue<TranslateAnchorType> getFillTranslateAnchor() const;
|
||||
void setFillTranslateAnchor(PropertyValue<TranslateAnchorType>);
|
||||
const PropertyValue<TranslateAnchorType>& getFillTranslateAnchor() const;
|
||||
void setFillTranslateAnchor(const PropertyValue<TranslateAnchorType>&);
|
||||
void setFillTranslateAnchorTransition(const TransitionOptions&);
|
||||
TransitionOptions getFillTranslateAnchorTransition() const;
|
||||
|
||||
static PropertyValue<std::string> getDefaultFillPattern();
|
||||
PropertyValue<std::string> getFillPattern() const;
|
||||
void setFillPattern(PropertyValue<std::string>);
|
||||
const PropertyValue<std::string>& getFillPattern() const;
|
||||
void setFillPattern(const PropertyValue<std::string>&);
|
||||
void setFillPatternTransition(const TransitionOptions&);
|
||||
TransitionOptions getFillPatternTransition() const;
|
||||
|
||||
|
||||
@@ -26,32 +26,32 @@ public:
|
||||
// Paint properties
|
||||
|
||||
static PropertyValue<float> getDefaultHeatmapRadius();
|
||||
PropertyValue<float> getHeatmapRadius() const;
|
||||
void setHeatmapRadius(PropertyValue<float>);
|
||||
const PropertyValue<float>& getHeatmapRadius() const;
|
||||
void setHeatmapRadius(const PropertyValue<float>&);
|
||||
void setHeatmapRadiusTransition(const TransitionOptions&);
|
||||
TransitionOptions getHeatmapRadiusTransition() const;
|
||||
|
||||
static PropertyValue<float> getDefaultHeatmapWeight();
|
||||
PropertyValue<float> getHeatmapWeight() const;
|
||||
void setHeatmapWeight(PropertyValue<float>);
|
||||
const PropertyValue<float>& getHeatmapWeight() const;
|
||||
void setHeatmapWeight(const PropertyValue<float>&);
|
||||
void setHeatmapWeightTransition(const TransitionOptions&);
|
||||
TransitionOptions getHeatmapWeightTransition() const;
|
||||
|
||||
static PropertyValue<float> getDefaultHeatmapIntensity();
|
||||
PropertyValue<float> getHeatmapIntensity() const;
|
||||
void setHeatmapIntensity(PropertyValue<float>);
|
||||
const PropertyValue<float>& getHeatmapIntensity() const;
|
||||
void setHeatmapIntensity(const PropertyValue<float>&);
|
||||
void setHeatmapIntensityTransition(const TransitionOptions&);
|
||||
TransitionOptions getHeatmapIntensityTransition() const;
|
||||
|
||||
static ColorRampPropertyValue getDefaultHeatmapColor();
|
||||
ColorRampPropertyValue getHeatmapColor() const;
|
||||
void setHeatmapColor(ColorRampPropertyValue);
|
||||
const ColorRampPropertyValue& getHeatmapColor() const;
|
||||
void setHeatmapColor(const ColorRampPropertyValue&);
|
||||
void setHeatmapColorTransition(const TransitionOptions&);
|
||||
TransitionOptions getHeatmapColorTransition() const;
|
||||
|
||||
static PropertyValue<float> getDefaultHeatmapOpacity();
|
||||
PropertyValue<float> getHeatmapOpacity() const;
|
||||
void setHeatmapOpacity(PropertyValue<float>);
|
||||
const PropertyValue<float>& getHeatmapOpacity() const;
|
||||
void setHeatmapOpacity(const PropertyValue<float>&);
|
||||
void setHeatmapOpacityTransition(const TransitionOptions&);
|
||||
TransitionOptions getHeatmapOpacityTransition() const;
|
||||
|
||||
|
||||
@@ -25,38 +25,38 @@ public:
|
||||
// Paint properties
|
||||
|
||||
static PropertyValue<float> getDefaultHillshadeIlluminationDirection();
|
||||
PropertyValue<float> getHillshadeIlluminationDirection() const;
|
||||
void setHillshadeIlluminationDirection(PropertyValue<float>);
|
||||
const PropertyValue<float>& getHillshadeIlluminationDirection() const;
|
||||
void setHillshadeIlluminationDirection(const PropertyValue<float>&);
|
||||
void setHillshadeIlluminationDirectionTransition(const TransitionOptions&);
|
||||
TransitionOptions getHillshadeIlluminationDirectionTransition() const;
|
||||
|
||||
static PropertyValue<HillshadeIlluminationAnchorType> getDefaultHillshadeIlluminationAnchor();
|
||||
PropertyValue<HillshadeIlluminationAnchorType> getHillshadeIlluminationAnchor() const;
|
||||
void setHillshadeIlluminationAnchor(PropertyValue<HillshadeIlluminationAnchorType>);
|
||||
const PropertyValue<HillshadeIlluminationAnchorType>& getHillshadeIlluminationAnchor() const;
|
||||
void setHillshadeIlluminationAnchor(const PropertyValue<HillshadeIlluminationAnchorType>&);
|
||||
void setHillshadeIlluminationAnchorTransition(const TransitionOptions&);
|
||||
TransitionOptions getHillshadeIlluminationAnchorTransition() const;
|
||||
|
||||
static PropertyValue<float> getDefaultHillshadeExaggeration();
|
||||
PropertyValue<float> getHillshadeExaggeration() const;
|
||||
void setHillshadeExaggeration(PropertyValue<float>);
|
||||
const PropertyValue<float>& getHillshadeExaggeration() const;
|
||||
void setHillshadeExaggeration(const PropertyValue<float>&);
|
||||
void setHillshadeExaggerationTransition(const TransitionOptions&);
|
||||
TransitionOptions getHillshadeExaggerationTransition() const;
|
||||
|
||||
static PropertyValue<Color> getDefaultHillshadeShadowColor();
|
||||
PropertyValue<Color> getHillshadeShadowColor() const;
|
||||
void setHillshadeShadowColor(PropertyValue<Color>);
|
||||
const PropertyValue<Color>& getHillshadeShadowColor() const;
|
||||
void setHillshadeShadowColor(const PropertyValue<Color>&);
|
||||
void setHillshadeShadowColorTransition(const TransitionOptions&);
|
||||
TransitionOptions getHillshadeShadowColorTransition() const;
|
||||
|
||||
static PropertyValue<Color> getDefaultHillshadeHighlightColor();
|
||||
PropertyValue<Color> getHillshadeHighlightColor() const;
|
||||
void setHillshadeHighlightColor(PropertyValue<Color>);
|
||||
const PropertyValue<Color>& getHillshadeHighlightColor() const;
|
||||
void setHillshadeHighlightColor(const PropertyValue<Color>&);
|
||||
void setHillshadeHighlightColorTransition(const TransitionOptions&);
|
||||
TransitionOptions getHillshadeHighlightColorTransition() const;
|
||||
|
||||
static PropertyValue<Color> getDefaultHillshadeAccentColor();
|
||||
PropertyValue<Color> getHillshadeAccentColor() const;
|
||||
void setHillshadeAccentColor(PropertyValue<Color>);
|
||||
const PropertyValue<Color>& getHillshadeAccentColor() const;
|
||||
void setHillshadeAccentColor(const PropertyValue<Color>&);
|
||||
void setHillshadeAccentColorTransition(const TransitionOptions&);
|
||||
TransitionOptions getHillshadeAccentColorTransition() const;
|
||||
|
||||
|
||||
@@ -43,8 +43,8 @@ public:
|
||||
|
||||
<% for (const property of layoutProperties) { -%>
|
||||
static <%- propertyValueType(property) %> getDefault<%- camelize(property.name) %>();
|
||||
<%- propertyValueType(property) %> get<%- camelize(property.name) %>() const;
|
||||
void set<%- camelize(property.name) %>(<%- propertyValueType(property) %>);
|
||||
const <%- propertyValueType(property) %>& get<%- camelize(property.name) %>() const;
|
||||
void set<%- camelize(property.name) %>(const <%- propertyValueType(property) %>&);
|
||||
|
||||
<% } -%>
|
||||
<% } -%>
|
||||
@@ -52,8 +52,8 @@ public:
|
||||
|
||||
<% for (const property of paintProperties) { -%>
|
||||
static <%- propertyValueType(property) %> getDefault<%- camelize(property.name) %>();
|
||||
<%- propertyValueType(property) %> get<%- camelize(property.name) %>() const;
|
||||
void set<%- camelize(property.name) %>(<%- propertyValueType(property) %>);
|
||||
const <%- propertyValueType(property) %>& get<%- camelize(property.name) %>() const;
|
||||
void set<%- camelize(property.name) %>(const <%- propertyValueType(property) %>&);
|
||||
void set<%- camelize(property.name) %>Transition(const TransitionOptions&);
|
||||
TransitionOptions get<%- camelize(property.name) %>Transition() const;
|
||||
|
||||
|
||||
@@ -28,86 +28,86 @@ public:
|
||||
// Layout properties
|
||||
|
||||
static PropertyValue<LineCapType> getDefaultLineCap();
|
||||
PropertyValue<LineCapType> getLineCap() const;
|
||||
void setLineCap(PropertyValue<LineCapType>);
|
||||
const PropertyValue<LineCapType>& getLineCap() const;
|
||||
void setLineCap(const PropertyValue<LineCapType>&);
|
||||
|
||||
static PropertyValue<LineJoinType> getDefaultLineJoin();
|
||||
PropertyValue<LineJoinType> getLineJoin() const;
|
||||
void setLineJoin(PropertyValue<LineJoinType>);
|
||||
const PropertyValue<LineJoinType>& getLineJoin() const;
|
||||
void setLineJoin(const PropertyValue<LineJoinType>&);
|
||||
|
||||
static PropertyValue<float> getDefaultLineMiterLimit();
|
||||
PropertyValue<float> getLineMiterLimit() const;
|
||||
void setLineMiterLimit(PropertyValue<float>);
|
||||
const PropertyValue<float>& getLineMiterLimit() const;
|
||||
void setLineMiterLimit(const PropertyValue<float>&);
|
||||
|
||||
static PropertyValue<float> getDefaultLineRoundLimit();
|
||||
PropertyValue<float> getLineRoundLimit() const;
|
||||
void setLineRoundLimit(PropertyValue<float>);
|
||||
const PropertyValue<float>& getLineRoundLimit() const;
|
||||
void setLineRoundLimit(const PropertyValue<float>&);
|
||||
|
||||
// Paint properties
|
||||
|
||||
static PropertyValue<float> getDefaultLineOpacity();
|
||||
PropertyValue<float> getLineOpacity() const;
|
||||
void setLineOpacity(PropertyValue<float>);
|
||||
const PropertyValue<float>& getLineOpacity() const;
|
||||
void setLineOpacity(const PropertyValue<float>&);
|
||||
void setLineOpacityTransition(const TransitionOptions&);
|
||||
TransitionOptions getLineOpacityTransition() const;
|
||||
|
||||
static PropertyValue<Color> getDefaultLineColor();
|
||||
PropertyValue<Color> getLineColor() const;
|
||||
void setLineColor(PropertyValue<Color>);
|
||||
const PropertyValue<Color>& getLineColor() const;
|
||||
void setLineColor(const PropertyValue<Color>&);
|
||||
void setLineColorTransition(const TransitionOptions&);
|
||||
TransitionOptions getLineColorTransition() const;
|
||||
|
||||
static PropertyValue<std::array<float, 2>> getDefaultLineTranslate();
|
||||
PropertyValue<std::array<float, 2>> getLineTranslate() const;
|
||||
void setLineTranslate(PropertyValue<std::array<float, 2>>);
|
||||
const PropertyValue<std::array<float, 2>>& getLineTranslate() const;
|
||||
void setLineTranslate(const PropertyValue<std::array<float, 2>>&);
|
||||
void setLineTranslateTransition(const TransitionOptions&);
|
||||
TransitionOptions getLineTranslateTransition() const;
|
||||
|
||||
static PropertyValue<TranslateAnchorType> getDefaultLineTranslateAnchor();
|
||||
PropertyValue<TranslateAnchorType> getLineTranslateAnchor() const;
|
||||
void setLineTranslateAnchor(PropertyValue<TranslateAnchorType>);
|
||||
const PropertyValue<TranslateAnchorType>& getLineTranslateAnchor() const;
|
||||
void setLineTranslateAnchor(const PropertyValue<TranslateAnchorType>&);
|
||||
void setLineTranslateAnchorTransition(const TransitionOptions&);
|
||||
TransitionOptions getLineTranslateAnchorTransition() const;
|
||||
|
||||
static PropertyValue<float> getDefaultLineWidth();
|
||||
PropertyValue<float> getLineWidth() const;
|
||||
void setLineWidth(PropertyValue<float>);
|
||||
const PropertyValue<float>& getLineWidth() const;
|
||||
void setLineWidth(const PropertyValue<float>&);
|
||||
void setLineWidthTransition(const TransitionOptions&);
|
||||
TransitionOptions getLineWidthTransition() const;
|
||||
|
||||
static PropertyValue<float> getDefaultLineGapWidth();
|
||||
PropertyValue<float> getLineGapWidth() const;
|
||||
void setLineGapWidth(PropertyValue<float>);
|
||||
const PropertyValue<float>& getLineGapWidth() const;
|
||||
void setLineGapWidth(const PropertyValue<float>&);
|
||||
void setLineGapWidthTransition(const TransitionOptions&);
|
||||
TransitionOptions getLineGapWidthTransition() const;
|
||||
|
||||
static PropertyValue<float> getDefaultLineOffset();
|
||||
PropertyValue<float> getLineOffset() const;
|
||||
void setLineOffset(PropertyValue<float>);
|
||||
const PropertyValue<float>& getLineOffset() const;
|
||||
void setLineOffset(const PropertyValue<float>&);
|
||||
void setLineOffsetTransition(const TransitionOptions&);
|
||||
TransitionOptions getLineOffsetTransition() const;
|
||||
|
||||
static PropertyValue<float> getDefaultLineBlur();
|
||||
PropertyValue<float> getLineBlur() const;
|
||||
void setLineBlur(PropertyValue<float>);
|
||||
const PropertyValue<float>& getLineBlur() const;
|
||||
void setLineBlur(const PropertyValue<float>&);
|
||||
void setLineBlurTransition(const TransitionOptions&);
|
||||
TransitionOptions getLineBlurTransition() const;
|
||||
|
||||
static PropertyValue<std::vector<float>> getDefaultLineDasharray();
|
||||
PropertyValue<std::vector<float>> getLineDasharray() const;
|
||||
void setLineDasharray(PropertyValue<std::vector<float>>);
|
||||
const PropertyValue<std::vector<float>>& getLineDasharray() const;
|
||||
void setLineDasharray(const PropertyValue<std::vector<float>>&);
|
||||
void setLineDasharrayTransition(const TransitionOptions&);
|
||||
TransitionOptions getLineDasharrayTransition() const;
|
||||
|
||||
static PropertyValue<std::string> getDefaultLinePattern();
|
||||
PropertyValue<std::string> getLinePattern() const;
|
||||
void setLinePattern(PropertyValue<std::string>);
|
||||
const PropertyValue<std::string>& getLinePattern() const;
|
||||
void setLinePattern(const PropertyValue<std::string>&);
|
||||
void setLinePatternTransition(const TransitionOptions&);
|
||||
TransitionOptions getLinePatternTransition() const;
|
||||
|
||||
static ColorRampPropertyValue getDefaultLineGradient();
|
||||
ColorRampPropertyValue getLineGradient() const;
|
||||
void setLineGradient(ColorRampPropertyValue);
|
||||
const ColorRampPropertyValue& getLineGradient() const;
|
||||
void setLineGradient(const ColorRampPropertyValue&);
|
||||
void setLineGradientTransition(const TransitionOptions&);
|
||||
TransitionOptions getLineGradientTransition() const;
|
||||
|
||||
|
||||
@@ -25,50 +25,50 @@ public:
|
||||
// Paint properties
|
||||
|
||||
static PropertyValue<float> getDefaultRasterOpacity();
|
||||
PropertyValue<float> getRasterOpacity() const;
|
||||
void setRasterOpacity(PropertyValue<float>);
|
||||
const PropertyValue<float>& getRasterOpacity() const;
|
||||
void setRasterOpacity(const PropertyValue<float>&);
|
||||
void setRasterOpacityTransition(const TransitionOptions&);
|
||||
TransitionOptions getRasterOpacityTransition() const;
|
||||
|
||||
static PropertyValue<float> getDefaultRasterHueRotate();
|
||||
PropertyValue<float> getRasterHueRotate() const;
|
||||
void setRasterHueRotate(PropertyValue<float>);
|
||||
const PropertyValue<float>& getRasterHueRotate() const;
|
||||
void setRasterHueRotate(const PropertyValue<float>&);
|
||||
void setRasterHueRotateTransition(const TransitionOptions&);
|
||||
TransitionOptions getRasterHueRotateTransition() const;
|
||||
|
||||
static PropertyValue<float> getDefaultRasterBrightnessMin();
|
||||
PropertyValue<float> getRasterBrightnessMin() const;
|
||||
void setRasterBrightnessMin(PropertyValue<float>);
|
||||
const PropertyValue<float>& getRasterBrightnessMin() const;
|
||||
void setRasterBrightnessMin(const PropertyValue<float>&);
|
||||
void setRasterBrightnessMinTransition(const TransitionOptions&);
|
||||
TransitionOptions getRasterBrightnessMinTransition() const;
|
||||
|
||||
static PropertyValue<float> getDefaultRasterBrightnessMax();
|
||||
PropertyValue<float> getRasterBrightnessMax() const;
|
||||
void setRasterBrightnessMax(PropertyValue<float>);
|
||||
const PropertyValue<float>& getRasterBrightnessMax() const;
|
||||
void setRasterBrightnessMax(const PropertyValue<float>&);
|
||||
void setRasterBrightnessMaxTransition(const TransitionOptions&);
|
||||
TransitionOptions getRasterBrightnessMaxTransition() const;
|
||||
|
||||
static PropertyValue<float> getDefaultRasterSaturation();
|
||||
PropertyValue<float> getRasterSaturation() const;
|
||||
void setRasterSaturation(PropertyValue<float>);
|
||||
const PropertyValue<float>& getRasterSaturation() const;
|
||||
void setRasterSaturation(const PropertyValue<float>&);
|
||||
void setRasterSaturationTransition(const TransitionOptions&);
|
||||
TransitionOptions getRasterSaturationTransition() const;
|
||||
|
||||
static PropertyValue<float> getDefaultRasterContrast();
|
||||
PropertyValue<float> getRasterContrast() const;
|
||||
void setRasterContrast(PropertyValue<float>);
|
||||
const PropertyValue<float>& getRasterContrast() const;
|
||||
void setRasterContrast(const PropertyValue<float>&);
|
||||
void setRasterContrastTransition(const TransitionOptions&);
|
||||
TransitionOptions getRasterContrastTransition() const;
|
||||
|
||||
static PropertyValue<RasterResamplingType> getDefaultRasterResampling();
|
||||
PropertyValue<RasterResamplingType> getRasterResampling() const;
|
||||
void setRasterResampling(PropertyValue<RasterResamplingType>);
|
||||
const PropertyValue<RasterResamplingType>& getRasterResampling() const;
|
||||
void setRasterResampling(const PropertyValue<RasterResamplingType>&);
|
||||
void setRasterResamplingTransition(const TransitionOptions&);
|
||||
TransitionOptions getRasterResamplingTransition() const;
|
||||
|
||||
static PropertyValue<float> getDefaultRasterFadeDuration();
|
||||
PropertyValue<float> getRasterFadeDuration() const;
|
||||
void setRasterFadeDuration(PropertyValue<float>);
|
||||
const PropertyValue<float>& getRasterFadeDuration() const;
|
||||
void setRasterFadeDuration(const PropertyValue<float>&);
|
||||
void setRasterFadeDurationTransition(const TransitionOptions&);
|
||||
TransitionOptions getRasterFadeDurationTransition() const;
|
||||
|
||||
|
||||
@@ -27,244 +27,244 @@ public:
|
||||
// Layout properties
|
||||
|
||||
static PropertyValue<SymbolPlacementType> getDefaultSymbolPlacement();
|
||||
PropertyValue<SymbolPlacementType> getSymbolPlacement() const;
|
||||
void setSymbolPlacement(PropertyValue<SymbolPlacementType>);
|
||||
const PropertyValue<SymbolPlacementType>& getSymbolPlacement() const;
|
||||
void setSymbolPlacement(const PropertyValue<SymbolPlacementType>&);
|
||||
|
||||
static PropertyValue<float> getDefaultSymbolSpacing();
|
||||
PropertyValue<float> getSymbolSpacing() const;
|
||||
void setSymbolSpacing(PropertyValue<float>);
|
||||
const PropertyValue<float>& getSymbolSpacing() const;
|
||||
void setSymbolSpacing(const PropertyValue<float>&);
|
||||
|
||||
static PropertyValue<bool> getDefaultSymbolAvoidEdges();
|
||||
PropertyValue<bool> getSymbolAvoidEdges() const;
|
||||
void setSymbolAvoidEdges(PropertyValue<bool>);
|
||||
const PropertyValue<bool>& getSymbolAvoidEdges() const;
|
||||
void setSymbolAvoidEdges(const PropertyValue<bool>&);
|
||||
|
||||
static PropertyValue<SymbolZOrderType> getDefaultSymbolZOrder();
|
||||
PropertyValue<SymbolZOrderType> getSymbolZOrder() const;
|
||||
void setSymbolZOrder(PropertyValue<SymbolZOrderType>);
|
||||
const PropertyValue<SymbolZOrderType>& getSymbolZOrder() const;
|
||||
void setSymbolZOrder(const PropertyValue<SymbolZOrderType>&);
|
||||
|
||||
static PropertyValue<bool> getDefaultIconAllowOverlap();
|
||||
PropertyValue<bool> getIconAllowOverlap() const;
|
||||
void setIconAllowOverlap(PropertyValue<bool>);
|
||||
const PropertyValue<bool>& getIconAllowOverlap() const;
|
||||
void setIconAllowOverlap(const PropertyValue<bool>&);
|
||||
|
||||
static PropertyValue<bool> getDefaultIconIgnorePlacement();
|
||||
PropertyValue<bool> getIconIgnorePlacement() const;
|
||||
void setIconIgnorePlacement(PropertyValue<bool>);
|
||||
const PropertyValue<bool>& getIconIgnorePlacement() const;
|
||||
void setIconIgnorePlacement(const PropertyValue<bool>&);
|
||||
|
||||
static PropertyValue<bool> getDefaultIconOptional();
|
||||
PropertyValue<bool> getIconOptional() const;
|
||||
void setIconOptional(PropertyValue<bool>);
|
||||
const PropertyValue<bool>& getIconOptional() const;
|
||||
void setIconOptional(const PropertyValue<bool>&);
|
||||
|
||||
static PropertyValue<AlignmentType> getDefaultIconRotationAlignment();
|
||||
PropertyValue<AlignmentType> getIconRotationAlignment() const;
|
||||
void setIconRotationAlignment(PropertyValue<AlignmentType>);
|
||||
const PropertyValue<AlignmentType>& getIconRotationAlignment() const;
|
||||
void setIconRotationAlignment(const PropertyValue<AlignmentType>&);
|
||||
|
||||
static PropertyValue<float> getDefaultIconSize();
|
||||
PropertyValue<float> getIconSize() const;
|
||||
void setIconSize(PropertyValue<float>);
|
||||
const PropertyValue<float>& getIconSize() const;
|
||||
void setIconSize(const PropertyValue<float>&);
|
||||
|
||||
static PropertyValue<IconTextFitType> getDefaultIconTextFit();
|
||||
PropertyValue<IconTextFitType> getIconTextFit() const;
|
||||
void setIconTextFit(PropertyValue<IconTextFitType>);
|
||||
const PropertyValue<IconTextFitType>& getIconTextFit() const;
|
||||
void setIconTextFit(const PropertyValue<IconTextFitType>&);
|
||||
|
||||
static PropertyValue<std::array<float, 4>> getDefaultIconTextFitPadding();
|
||||
PropertyValue<std::array<float, 4>> getIconTextFitPadding() const;
|
||||
void setIconTextFitPadding(PropertyValue<std::array<float, 4>>);
|
||||
const PropertyValue<std::array<float, 4>>& getIconTextFitPadding() const;
|
||||
void setIconTextFitPadding(const PropertyValue<std::array<float, 4>>&);
|
||||
|
||||
static PropertyValue<std::string> getDefaultIconImage();
|
||||
PropertyValue<std::string> getIconImage() const;
|
||||
void setIconImage(PropertyValue<std::string>);
|
||||
const PropertyValue<std::string>& getIconImage() const;
|
||||
void setIconImage(const PropertyValue<std::string>&);
|
||||
|
||||
static PropertyValue<float> getDefaultIconRotate();
|
||||
PropertyValue<float> getIconRotate() const;
|
||||
void setIconRotate(PropertyValue<float>);
|
||||
const PropertyValue<float>& getIconRotate() const;
|
||||
void setIconRotate(const PropertyValue<float>&);
|
||||
|
||||
static PropertyValue<float> getDefaultIconPadding();
|
||||
PropertyValue<float> getIconPadding() const;
|
||||
void setIconPadding(PropertyValue<float>);
|
||||
const PropertyValue<float>& getIconPadding() const;
|
||||
void setIconPadding(const PropertyValue<float>&);
|
||||
|
||||
static PropertyValue<bool> getDefaultIconKeepUpright();
|
||||
PropertyValue<bool> getIconKeepUpright() const;
|
||||
void setIconKeepUpright(PropertyValue<bool>);
|
||||
const PropertyValue<bool>& getIconKeepUpright() const;
|
||||
void setIconKeepUpright(const PropertyValue<bool>&);
|
||||
|
||||
static PropertyValue<std::array<float, 2>> getDefaultIconOffset();
|
||||
PropertyValue<std::array<float, 2>> getIconOffset() const;
|
||||
void setIconOffset(PropertyValue<std::array<float, 2>>);
|
||||
const PropertyValue<std::array<float, 2>>& getIconOffset() const;
|
||||
void setIconOffset(const PropertyValue<std::array<float, 2>>&);
|
||||
|
||||
static PropertyValue<SymbolAnchorType> getDefaultIconAnchor();
|
||||
PropertyValue<SymbolAnchorType> getIconAnchor() const;
|
||||
void setIconAnchor(PropertyValue<SymbolAnchorType>);
|
||||
const PropertyValue<SymbolAnchorType>& getIconAnchor() const;
|
||||
void setIconAnchor(const PropertyValue<SymbolAnchorType>&);
|
||||
|
||||
static PropertyValue<AlignmentType> getDefaultIconPitchAlignment();
|
||||
PropertyValue<AlignmentType> getIconPitchAlignment() const;
|
||||
void setIconPitchAlignment(PropertyValue<AlignmentType>);
|
||||
const PropertyValue<AlignmentType>& getIconPitchAlignment() const;
|
||||
void setIconPitchAlignment(const PropertyValue<AlignmentType>&);
|
||||
|
||||
static PropertyValue<AlignmentType> getDefaultTextPitchAlignment();
|
||||
PropertyValue<AlignmentType> getTextPitchAlignment() const;
|
||||
void setTextPitchAlignment(PropertyValue<AlignmentType>);
|
||||
const PropertyValue<AlignmentType>& getTextPitchAlignment() const;
|
||||
void setTextPitchAlignment(const PropertyValue<AlignmentType>&);
|
||||
|
||||
static PropertyValue<AlignmentType> getDefaultTextRotationAlignment();
|
||||
PropertyValue<AlignmentType> getTextRotationAlignment() const;
|
||||
void setTextRotationAlignment(PropertyValue<AlignmentType>);
|
||||
const PropertyValue<AlignmentType>& getTextRotationAlignment() const;
|
||||
void setTextRotationAlignment(const PropertyValue<AlignmentType>&);
|
||||
|
||||
static PropertyValue<expression::Formatted> getDefaultTextField();
|
||||
PropertyValue<expression::Formatted> getTextField() const;
|
||||
void setTextField(PropertyValue<expression::Formatted>);
|
||||
const PropertyValue<expression::Formatted>& getTextField() const;
|
||||
void setTextField(const PropertyValue<expression::Formatted>&);
|
||||
|
||||
static PropertyValue<std::vector<std::string>> getDefaultTextFont();
|
||||
PropertyValue<std::vector<std::string>> getTextFont() const;
|
||||
void setTextFont(PropertyValue<std::vector<std::string>>);
|
||||
const PropertyValue<std::vector<std::string>>& getTextFont() const;
|
||||
void setTextFont(const PropertyValue<std::vector<std::string>>&);
|
||||
|
||||
static PropertyValue<float> getDefaultTextSize();
|
||||
PropertyValue<float> getTextSize() const;
|
||||
void setTextSize(PropertyValue<float>);
|
||||
const PropertyValue<float>& getTextSize() const;
|
||||
void setTextSize(const PropertyValue<float>&);
|
||||
|
||||
static PropertyValue<float> getDefaultTextMaxWidth();
|
||||
PropertyValue<float> getTextMaxWidth() const;
|
||||
void setTextMaxWidth(PropertyValue<float>);
|
||||
const PropertyValue<float>& getTextMaxWidth() const;
|
||||
void setTextMaxWidth(const PropertyValue<float>&);
|
||||
|
||||
static PropertyValue<float> getDefaultTextLineHeight();
|
||||
PropertyValue<float> getTextLineHeight() const;
|
||||
void setTextLineHeight(PropertyValue<float>);
|
||||
const PropertyValue<float>& getTextLineHeight() const;
|
||||
void setTextLineHeight(const PropertyValue<float>&);
|
||||
|
||||
static PropertyValue<float> getDefaultTextLetterSpacing();
|
||||
PropertyValue<float> getTextLetterSpacing() const;
|
||||
void setTextLetterSpacing(PropertyValue<float>);
|
||||
const PropertyValue<float>& getTextLetterSpacing() const;
|
||||
void setTextLetterSpacing(const PropertyValue<float>&);
|
||||
|
||||
static PropertyValue<TextJustifyType> getDefaultTextJustify();
|
||||
PropertyValue<TextJustifyType> getTextJustify() const;
|
||||
void setTextJustify(PropertyValue<TextJustifyType>);
|
||||
const PropertyValue<TextJustifyType>& getTextJustify() const;
|
||||
void setTextJustify(const PropertyValue<TextJustifyType>&);
|
||||
|
||||
static PropertyValue<float> getDefaultTextRadialOffset();
|
||||
PropertyValue<float> getTextRadialOffset() const;
|
||||
void setTextRadialOffset(PropertyValue<float>);
|
||||
const PropertyValue<float>& getTextRadialOffset() const;
|
||||
void setTextRadialOffset(const PropertyValue<float>&);
|
||||
|
||||
static PropertyValue<std::vector<TextVariableAnchorType>> getDefaultTextVariableAnchor();
|
||||
PropertyValue<std::vector<TextVariableAnchorType>> getTextVariableAnchor() const;
|
||||
void setTextVariableAnchor(PropertyValue<std::vector<TextVariableAnchorType>>);
|
||||
const PropertyValue<std::vector<TextVariableAnchorType>>& getTextVariableAnchor() const;
|
||||
void setTextVariableAnchor(const PropertyValue<std::vector<TextVariableAnchorType>>&);
|
||||
|
||||
static PropertyValue<SymbolAnchorType> getDefaultTextAnchor();
|
||||
PropertyValue<SymbolAnchorType> getTextAnchor() const;
|
||||
void setTextAnchor(PropertyValue<SymbolAnchorType>);
|
||||
const PropertyValue<SymbolAnchorType>& getTextAnchor() const;
|
||||
void setTextAnchor(const PropertyValue<SymbolAnchorType>&);
|
||||
|
||||
static PropertyValue<float> getDefaultTextMaxAngle();
|
||||
PropertyValue<float> getTextMaxAngle() const;
|
||||
void setTextMaxAngle(PropertyValue<float>);
|
||||
const PropertyValue<float>& getTextMaxAngle() const;
|
||||
void setTextMaxAngle(const PropertyValue<float>&);
|
||||
|
||||
static PropertyValue<float> getDefaultTextRotate();
|
||||
PropertyValue<float> getTextRotate() const;
|
||||
void setTextRotate(PropertyValue<float>);
|
||||
const PropertyValue<float>& getTextRotate() const;
|
||||
void setTextRotate(const PropertyValue<float>&);
|
||||
|
||||
static PropertyValue<float> getDefaultTextPadding();
|
||||
PropertyValue<float> getTextPadding() const;
|
||||
void setTextPadding(PropertyValue<float>);
|
||||
const PropertyValue<float>& getTextPadding() const;
|
||||
void setTextPadding(const PropertyValue<float>&);
|
||||
|
||||
static PropertyValue<bool> getDefaultTextKeepUpright();
|
||||
PropertyValue<bool> getTextKeepUpright() const;
|
||||
void setTextKeepUpright(PropertyValue<bool>);
|
||||
const PropertyValue<bool>& getTextKeepUpright() const;
|
||||
void setTextKeepUpright(const PropertyValue<bool>&);
|
||||
|
||||
static PropertyValue<TextTransformType> getDefaultTextTransform();
|
||||
PropertyValue<TextTransformType> getTextTransform() const;
|
||||
void setTextTransform(PropertyValue<TextTransformType>);
|
||||
const PropertyValue<TextTransformType>& getTextTransform() const;
|
||||
void setTextTransform(const PropertyValue<TextTransformType>&);
|
||||
|
||||
static PropertyValue<std::array<float, 2>> getDefaultTextOffset();
|
||||
PropertyValue<std::array<float, 2>> getTextOffset() const;
|
||||
void setTextOffset(PropertyValue<std::array<float, 2>>);
|
||||
const PropertyValue<std::array<float, 2>>& getTextOffset() const;
|
||||
void setTextOffset(const PropertyValue<std::array<float, 2>>&);
|
||||
|
||||
static PropertyValue<bool> getDefaultTextAllowOverlap();
|
||||
PropertyValue<bool> getTextAllowOverlap() const;
|
||||
void setTextAllowOverlap(PropertyValue<bool>);
|
||||
const PropertyValue<bool>& getTextAllowOverlap() const;
|
||||
void setTextAllowOverlap(const PropertyValue<bool>&);
|
||||
|
||||
static PropertyValue<bool> getDefaultTextIgnorePlacement();
|
||||
PropertyValue<bool> getTextIgnorePlacement() const;
|
||||
void setTextIgnorePlacement(PropertyValue<bool>);
|
||||
const PropertyValue<bool>& getTextIgnorePlacement() const;
|
||||
void setTextIgnorePlacement(const PropertyValue<bool>&);
|
||||
|
||||
static PropertyValue<bool> getDefaultTextOptional();
|
||||
PropertyValue<bool> getTextOptional() const;
|
||||
void setTextOptional(PropertyValue<bool>);
|
||||
const PropertyValue<bool>& getTextOptional() const;
|
||||
void setTextOptional(const PropertyValue<bool>&);
|
||||
|
||||
// Paint properties
|
||||
|
||||
static PropertyValue<float> getDefaultIconOpacity();
|
||||
PropertyValue<float> getIconOpacity() const;
|
||||
void setIconOpacity(PropertyValue<float>);
|
||||
const PropertyValue<float>& getIconOpacity() const;
|
||||
void setIconOpacity(const PropertyValue<float>&);
|
||||
void setIconOpacityTransition(const TransitionOptions&);
|
||||
TransitionOptions getIconOpacityTransition() const;
|
||||
|
||||
static PropertyValue<Color> getDefaultIconColor();
|
||||
PropertyValue<Color> getIconColor() const;
|
||||
void setIconColor(PropertyValue<Color>);
|
||||
const PropertyValue<Color>& getIconColor() const;
|
||||
void setIconColor(const PropertyValue<Color>&);
|
||||
void setIconColorTransition(const TransitionOptions&);
|
||||
TransitionOptions getIconColorTransition() const;
|
||||
|
||||
static PropertyValue<Color> getDefaultIconHaloColor();
|
||||
PropertyValue<Color> getIconHaloColor() const;
|
||||
void setIconHaloColor(PropertyValue<Color>);
|
||||
const PropertyValue<Color>& getIconHaloColor() const;
|
||||
void setIconHaloColor(const PropertyValue<Color>&);
|
||||
void setIconHaloColorTransition(const TransitionOptions&);
|
||||
TransitionOptions getIconHaloColorTransition() const;
|
||||
|
||||
static PropertyValue<float> getDefaultIconHaloWidth();
|
||||
PropertyValue<float> getIconHaloWidth() const;
|
||||
void setIconHaloWidth(PropertyValue<float>);
|
||||
const PropertyValue<float>& getIconHaloWidth() const;
|
||||
void setIconHaloWidth(const PropertyValue<float>&);
|
||||
void setIconHaloWidthTransition(const TransitionOptions&);
|
||||
TransitionOptions getIconHaloWidthTransition() const;
|
||||
|
||||
static PropertyValue<float> getDefaultIconHaloBlur();
|
||||
PropertyValue<float> getIconHaloBlur() const;
|
||||
void setIconHaloBlur(PropertyValue<float>);
|
||||
const PropertyValue<float>& getIconHaloBlur() const;
|
||||
void setIconHaloBlur(const PropertyValue<float>&);
|
||||
void setIconHaloBlurTransition(const TransitionOptions&);
|
||||
TransitionOptions getIconHaloBlurTransition() const;
|
||||
|
||||
static PropertyValue<std::array<float, 2>> getDefaultIconTranslate();
|
||||
PropertyValue<std::array<float, 2>> getIconTranslate() const;
|
||||
void setIconTranslate(PropertyValue<std::array<float, 2>>);
|
||||
const PropertyValue<std::array<float, 2>>& getIconTranslate() const;
|
||||
void setIconTranslate(const PropertyValue<std::array<float, 2>>&);
|
||||
void setIconTranslateTransition(const TransitionOptions&);
|
||||
TransitionOptions getIconTranslateTransition() const;
|
||||
|
||||
static PropertyValue<TranslateAnchorType> getDefaultIconTranslateAnchor();
|
||||
PropertyValue<TranslateAnchorType> getIconTranslateAnchor() const;
|
||||
void setIconTranslateAnchor(PropertyValue<TranslateAnchorType>);
|
||||
const PropertyValue<TranslateAnchorType>& getIconTranslateAnchor() const;
|
||||
void setIconTranslateAnchor(const PropertyValue<TranslateAnchorType>&);
|
||||
void setIconTranslateAnchorTransition(const TransitionOptions&);
|
||||
TransitionOptions getIconTranslateAnchorTransition() const;
|
||||
|
||||
static PropertyValue<float> getDefaultTextOpacity();
|
||||
PropertyValue<float> getTextOpacity() const;
|
||||
void setTextOpacity(PropertyValue<float>);
|
||||
const PropertyValue<float>& getTextOpacity() const;
|
||||
void setTextOpacity(const PropertyValue<float>&);
|
||||
void setTextOpacityTransition(const TransitionOptions&);
|
||||
TransitionOptions getTextOpacityTransition() const;
|
||||
|
||||
static PropertyValue<Color> getDefaultTextColor();
|
||||
PropertyValue<Color> getTextColor() const;
|
||||
void setTextColor(PropertyValue<Color>);
|
||||
const PropertyValue<Color>& getTextColor() const;
|
||||
void setTextColor(const PropertyValue<Color>&);
|
||||
void setTextColorTransition(const TransitionOptions&);
|
||||
TransitionOptions getTextColorTransition() const;
|
||||
|
||||
static PropertyValue<Color> getDefaultTextHaloColor();
|
||||
PropertyValue<Color> getTextHaloColor() const;
|
||||
void setTextHaloColor(PropertyValue<Color>);
|
||||
const PropertyValue<Color>& getTextHaloColor() const;
|
||||
void setTextHaloColor(const PropertyValue<Color>&);
|
||||
void setTextHaloColorTransition(const TransitionOptions&);
|
||||
TransitionOptions getTextHaloColorTransition() const;
|
||||
|
||||
static PropertyValue<float> getDefaultTextHaloWidth();
|
||||
PropertyValue<float> getTextHaloWidth() const;
|
||||
void setTextHaloWidth(PropertyValue<float>);
|
||||
const PropertyValue<float>& getTextHaloWidth() const;
|
||||
void setTextHaloWidth(const PropertyValue<float>&);
|
||||
void setTextHaloWidthTransition(const TransitionOptions&);
|
||||
TransitionOptions getTextHaloWidthTransition() const;
|
||||
|
||||
static PropertyValue<float> getDefaultTextHaloBlur();
|
||||
PropertyValue<float> getTextHaloBlur() const;
|
||||
void setTextHaloBlur(PropertyValue<float>);
|
||||
const PropertyValue<float>& getTextHaloBlur() const;
|
||||
void setTextHaloBlur(const PropertyValue<float>&);
|
||||
void setTextHaloBlurTransition(const TransitionOptions&);
|
||||
TransitionOptions getTextHaloBlurTransition() const;
|
||||
|
||||
static PropertyValue<std::array<float, 2>> getDefaultTextTranslate();
|
||||
PropertyValue<std::array<float, 2>> getTextTranslate() const;
|
||||
void setTextTranslate(PropertyValue<std::array<float, 2>>);
|
||||
const PropertyValue<std::array<float, 2>>& getTextTranslate() const;
|
||||
void setTextTranslate(const PropertyValue<std::array<float, 2>>&);
|
||||
void setTextTranslateTransition(const TransitionOptions&);
|
||||
TransitionOptions getTextTranslateTransition() const;
|
||||
|
||||
static PropertyValue<TranslateAnchorType> getDefaultTextTranslateAnchor();
|
||||
PropertyValue<TranslateAnchorType> getTextTranslateAnchor() const;
|
||||
void setTextTranslateAnchor(PropertyValue<TranslateAnchorType>);
|
||||
const PropertyValue<TranslateAnchorType>& getTextTranslateAnchor() const;
|
||||
void setTextTranslateAnchor(const PropertyValue<TranslateAnchorType>&);
|
||||
void setTextTranslateAnchorTransition(const TransitionOptions&);
|
||||
TransitionOptions getTextTranslateAnchorTransition() const;
|
||||
|
||||
|
||||
@@ -14,13 +14,14 @@
|
||||
#include <mbgl/util/stopwatch.hpp>
|
||||
|
||||
#include <cassert>
|
||||
#include <utility>
|
||||
|
||||
namespace mbgl {
|
||||
|
||||
class DefaultFileSource::Impl {
|
||||
public:
|
||||
Impl(std::shared_ptr<FileSource> assetFileSource_, std::string cachePath, uint64_t maximumCacheSize)
|
||||
: assetFileSource(assetFileSource_)
|
||||
: assetFileSource(std::move(assetFileSource_))
|
||||
, localFileSource(std::make_unique<LocalFileSource>())
|
||||
, offlineDatabase(std::make_unique<OfflineDatabase>(cachePath, maximumCacheSize)) {
|
||||
}
|
||||
|
||||
@@ -10,6 +10,7 @@
|
||||
#include <rapidjson/writer.h>
|
||||
|
||||
#include <cmath>
|
||||
#include <utility>
|
||||
|
||||
namespace mbgl {
|
||||
|
||||
@@ -33,7 +34,7 @@ OfflineTilePyramidRegionDefinition::OfflineTilePyramidRegionDefinition(
|
||||
// OfflineGeometryRegionDefinition
|
||||
|
||||
OfflineGeometryRegionDefinition::OfflineGeometryRegionDefinition(std::string styleURL_, Geometry<double> geometry_, double minZoom_, double maxZoom_, float pixelRatio_, bool includeIdeographs_)
|
||||
: styleURL(styleURL_)
|
||||
: styleURL(std::move(styleURL_))
|
||||
, geometry(std::move(geometry_))
|
||||
, minZoom(minZoom_)
|
||||
, maxZoom(maxZoom_)
|
||||
|
||||
@@ -180,7 +180,7 @@ std::vector<StyledText> BiDi::processStyledText(const StyledText& input, std::se
|
||||
|
||||
std::u16string BiDi::writeReverse(const std::u16string& input, std::size_t logicalStart, std::size_t logicalEnd) {
|
||||
UErrorCode errorCode = U_ZERO_ERROR;
|
||||
int32_t logicalLength = static_cast<int32_t>(logicalEnd - logicalStart);
|
||||
auto logicalLength = static_cast<int32_t>(logicalEnd - logicalStart);
|
||||
std::u16string outputText(logicalLength + 1, 0);
|
||||
|
||||
// UBIDI_DO_MIRRORING: Apply unicode mirroring of characters like parentheses
|
||||
|
||||
@@ -173,7 +173,7 @@ struct ToValue {
|
||||
} else {
|
||||
serializedSection.emplace("fontStack", mbgl::NullValue());
|
||||
}
|
||||
sections.push_back(serializedSection);
|
||||
sections.emplace_back(serializedSection);
|
||||
}
|
||||
serialized.emplace("sections", sections);
|
||||
|
||||
@@ -205,7 +205,7 @@ v8::Local<v8::Value> toJS(const Value& value) {
|
||||
}
|
||||
|
||||
void NodeExpression::Evaluate(const Nan::FunctionCallbackInfo<v8::Value>& info) {
|
||||
NodeExpression* nodeExpr = ObjectWrap::Unwrap<NodeExpression>(info.Holder());
|
||||
auto* nodeExpr = ObjectWrap::Unwrap<NodeExpression>(info.Holder());
|
||||
const std::unique_ptr<Expression>& expression = nodeExpr->expression;
|
||||
|
||||
if (info.Length() < 2 || !info[0]->IsObject()) {
|
||||
@@ -246,7 +246,7 @@ void NodeExpression::Evaluate(const Nan::FunctionCallbackInfo<v8::Value>& info)
|
||||
}
|
||||
|
||||
void NodeExpression::GetType(const Nan::FunctionCallbackInfo<v8::Value>& info) {
|
||||
NodeExpression* nodeExpr = ObjectWrap::Unwrap<NodeExpression>(info.Holder());
|
||||
auto* nodeExpr = ObjectWrap::Unwrap<NodeExpression>(info.Holder());
|
||||
const std::unique_ptr<Expression>& expression = nodeExpr->expression;
|
||||
|
||||
const type::Type type = expression->getType();
|
||||
@@ -255,19 +255,19 @@ void NodeExpression::GetType(const Nan::FunctionCallbackInfo<v8::Value>& info) {
|
||||
}
|
||||
|
||||
void NodeExpression::IsFeatureConstant(const Nan::FunctionCallbackInfo<v8::Value>& info) {
|
||||
NodeExpression* nodeExpr = ObjectWrap::Unwrap<NodeExpression>(info.Holder());
|
||||
auto* nodeExpr = ObjectWrap::Unwrap<NodeExpression>(info.Holder());
|
||||
const std::unique_ptr<Expression>& expression = nodeExpr->expression;
|
||||
info.GetReturnValue().Set(Nan::New(isFeatureConstant(*expression)));
|
||||
}
|
||||
|
||||
void NodeExpression::IsZoomConstant(const Nan::FunctionCallbackInfo<v8::Value>& info) {
|
||||
NodeExpression* nodeExpr = ObjectWrap::Unwrap<NodeExpression>(info.Holder());
|
||||
auto* nodeExpr = ObjectWrap::Unwrap<NodeExpression>(info.Holder());
|
||||
const std::unique_ptr<Expression>& expression = nodeExpr->expression;
|
||||
info.GetReturnValue().Set(Nan::New(isZoomConstant(*expression)));
|
||||
}
|
||||
|
||||
void NodeExpression::Serialize(const Nan::FunctionCallbackInfo<v8::Value>& info) {
|
||||
NodeExpression* nodeExpr = ObjectWrap::Unwrap<NodeExpression>(info.Holder());
|
||||
auto* nodeExpr = ObjectWrap::Unwrap<NodeExpression>(info.Holder());
|
||||
const std::unique_ptr<Expression>& expression = nodeExpr->expression;
|
||||
|
||||
const mbgl::Value serialized = expression->serialize();
|
||||
|
||||
@@ -47,9 +47,9 @@ public:
|
||||
}
|
||||
|
||||
private:
|
||||
v8::Local<v8::String> type(const char* type) {
|
||||
v8::Local<v8::String> type(const char* type_) {
|
||||
Nan::EscapableHandleScope scope;
|
||||
return scope.Escape(Nan::New(type).ToLocalChecked());
|
||||
return scope.Escape(Nan::New(type_).ToLocalChecked());
|
||||
}
|
||||
};
|
||||
|
||||
|
||||
@@ -1254,10 +1254,10 @@ std::unique_ptr<mbgl::AsyncRequest> NodeFileSource::request(const mbgl::Resource
|
||||
Nan::Set(instance, Nan::New("url").ToLocalChecked(), Nan::New(resource.url).ToLocalChecked());
|
||||
Nan::Set(instance, Nan::New("kind").ToLocalChecked(), Nan::New<v8::Integer>(resource.kind));
|
||||
|
||||
auto request = Nan::ObjectWrap::Unwrap<node_mbgl::NodeRequest>(instance);
|
||||
request->Execute();
|
||||
auto req = Nan::ObjectWrap::Unwrap<node_mbgl::NodeRequest>(instance);
|
||||
req->Execute();
|
||||
|
||||
return std::make_unique<node_mbgl::NodeRequest::NodeAsyncRequest>(request);
|
||||
return std::make_unique<node_mbgl::NodeRequest::NodeAsyncRequest>(req);
|
||||
}
|
||||
|
||||
} // namespace node_mbgl
|
||||
|
||||
201
scripts/clang-tidy-diff.py
Executable file
201
scripts/clang-tidy-diff.py
Executable file
@@ -0,0 +1,201 @@
|
||||
#!/usr/bin/env python
|
||||
#
|
||||
#===- clang-tidy-diff.py - ClangTidy Diff Checker ------------*- python -*--===#
|
||||
#
|
||||
# The LLVM Compiler Infrastructure
|
||||
#
|
||||
# This file is distributed under the University of Illinois Open Source
|
||||
# License. See LICENSE.TXT for details.
|
||||
#
|
||||
#===------------------------------------------------------------------------===#
|
||||
|
||||
r"""
|
||||
ClangTidy Diff Checker
|
||||
======================
|
||||
|
||||
This script reads input from a unified diff, runs clang-tidy on all changed
|
||||
files and outputs clang-tidy warnings in changed lines only. This is useful to
|
||||
detect clang-tidy regressions in the lines touched by a specific patch.
|
||||
Example usage for git/svn users:
|
||||
|
||||
git diff -U0 HEAD^ | clang-tidy-diff.py -p1
|
||||
svn diff --diff-cmd=diff -x-U0 | \
|
||||
clang-tidy-diff.py -fix -checks=-*,modernize-use-override
|
||||
|
||||
"""
|
||||
|
||||
import argparse
|
||||
import json
|
||||
import re
|
||||
import subprocess
|
||||
import sys
|
||||
import multiprocessing
|
||||
import os
|
||||
import threading
|
||||
|
||||
is_py2 = sys.version[0] == '2'
|
||||
|
||||
if is_py2:
|
||||
import Queue as queue
|
||||
else:
|
||||
import queue as queue
|
||||
|
||||
def run_tidy(command, lines_by_file, queue, failed_files):
|
||||
"""Takes filenames out of queue and runs clang-tidy on them."""
|
||||
while True:
|
||||
name = queue.get()
|
||||
|
||||
line_filter_json = json.dumps([{"name" : name, "lines" : lines_by_file[name]}], separators = (',', ':'))
|
||||
if sys.platform == 'win32':
|
||||
line_filter_json = re.sub(r'"', r'"""', line_filter_json)
|
||||
else:
|
||||
line_filter_json = "'" + line_filter_json + "'";
|
||||
|
||||
invocation = list(command)
|
||||
invocation.append('-line-filter=' + line_filter_json)
|
||||
invocation.append(name)
|
||||
|
||||
sys.stdout.write('Checking differences in {}...\n'.format(name))
|
||||
return_code = subprocess.call(' '.join(invocation), shell=True)
|
||||
if return_code != 0:
|
||||
failed_files.append(name)
|
||||
queue.task_done()
|
||||
|
||||
def main():
|
||||
parser = argparse.ArgumentParser(description=
|
||||
'Run clang-tidy against changed files, and '
|
||||
'output diagnostics only for modified '
|
||||
'lines.')
|
||||
parser.add_argument('-clang-tidy-binary', metavar='PATH',
|
||||
default='clang-tidy',
|
||||
help='path to clang-tidy binary')
|
||||
parser.add_argument('-p', metavar='NUM', default=0,
|
||||
help='strip the smallest prefix containing P slashes')
|
||||
parser.add_argument('-regex', metavar='PATTERN', default=None,
|
||||
help='custom pattern selecting file paths to check '
|
||||
'(case sensitive, overrides -iregex)')
|
||||
parser.add_argument('-iregex', metavar='PATTERN', default=
|
||||
r'.*\.(cpp|cc|c\+\+|cxx|c|cl|h|hpp|m|mm|inc)',
|
||||
help='custom pattern selecting file paths to check '
|
||||
'(case insensitive, overridden by -regex)')
|
||||
|
||||
parser.add_argument('-fix', action='store_true', default=False,
|
||||
help='apply suggested fixes')
|
||||
parser.add_argument('-checks',
|
||||
help='checks filter, when not specified, use clang-tidy '
|
||||
'default',
|
||||
default='')
|
||||
parser.add_argument('-path', dest='build_path',
|
||||
help='Path used to read a compile command database.')
|
||||
parser.add_argument('-extra-arg', dest='extra_arg',
|
||||
action='append', default=[],
|
||||
help='Additional argument to append to the compiler '
|
||||
'command line.')
|
||||
parser.add_argument('-extra-arg-before', dest='extra_arg_before',
|
||||
action='append', default=[],
|
||||
help='Additional argument to prepend to the compiler '
|
||||
'command line.')
|
||||
parser.add_argument('-j', type=int, default=0,
|
||||
help='number of tidy instances to be run in parallel.')
|
||||
parser.add_argument('-quiet', action='store_true', default=False,
|
||||
help='Run clang-tidy in quiet mode')
|
||||
clang_tidy_args = []
|
||||
argv = sys.argv[1:]
|
||||
if '--' in argv:
|
||||
clang_tidy_args.extend(argv[argv.index('--'):])
|
||||
argv = argv[:argv.index('--')]
|
||||
|
||||
args = parser.parse_args(argv)
|
||||
|
||||
# Extract changed lines for each file.
|
||||
filename = None
|
||||
lines_by_file = {}
|
||||
for line in sys.stdin:
|
||||
match = re.search('^\+\+\+\ \"?(.*?/){%s}([^ \t\n\"]*)' % args.p, line)
|
||||
if match:
|
||||
filename = match.group(2)
|
||||
if filename == None:
|
||||
continue
|
||||
|
||||
if args.regex is not None:
|
||||
if not re.match('^%s$' % args.regex, filename):
|
||||
continue
|
||||
else:
|
||||
if not re.match('^%s$' % args.iregex, filename, re.IGNORECASE):
|
||||
continue
|
||||
|
||||
match = re.search('^@@.*\+(\d+)(,(\d+))?', line)
|
||||
if match:
|
||||
start_line = int(match.group(1))
|
||||
line_count = 1
|
||||
if match.group(3):
|
||||
line_count = int(match.group(3))
|
||||
if line_count == 0:
|
||||
continue
|
||||
end_line = start_line + line_count - 1;
|
||||
lines_by_file.setdefault(filename, []).append([start_line, end_line])
|
||||
|
||||
if len(lines_by_file) == 0:
|
||||
print("No relevant changes found.")
|
||||
sys.exit(0)
|
||||
|
||||
# Run clang-tidy on files containing changes.
|
||||
command = [args.clang_tidy_binary]
|
||||
if args.fix:
|
||||
command.append('-fix')
|
||||
if args.checks != '':
|
||||
command.append('-checks=' + quote + args.checks + quote)
|
||||
if args.quiet:
|
||||
command.append('-quiet')
|
||||
if args.build_path is not None:
|
||||
command.append('-p=%s' % args.build_path)
|
||||
for arg in args.extra_arg:
|
||||
command.append('-extra-arg=%s' % arg)
|
||||
for arg in args.extra_arg_before:
|
||||
command.append('-extra-arg-before=%s' % arg)
|
||||
command.extend(clang_tidy_args)
|
||||
|
||||
try:
|
||||
invocation = list(command)
|
||||
invocation.append('-')
|
||||
subprocess.check_call(invocation)
|
||||
except:
|
||||
print("Unable to run clang-tidy: {}".format(' '.join(command)))
|
||||
sys.exit(1)
|
||||
|
||||
max_task = args.j
|
||||
if max_task == 0:
|
||||
max_task = multiprocessing.cpu_count()
|
||||
|
||||
return_code = 0
|
||||
try:
|
||||
# Spin up a bunch of tidy-launching threads.
|
||||
task_queue = queue.Queue(max_task)
|
||||
# List of files with a non-zero return code.
|
||||
failed_files = []
|
||||
for _ in range(max_task):
|
||||
t = threading.Thread(target=run_tidy,
|
||||
args=(command, lines_by_file, task_queue, failed_files))
|
||||
t.daemon = True
|
||||
t.start()
|
||||
|
||||
# Fill the queue with files.
|
||||
for name in lines_by_file:
|
||||
task_queue.put(name)
|
||||
|
||||
# Wait for all threads to be done.
|
||||
task_queue.join()
|
||||
if len(failed_files):
|
||||
return_code = 1
|
||||
|
||||
except KeyboardInterrupt:
|
||||
# This is a sad hack. Unfortunately subprocess goes
|
||||
# bonkers with ctrl-c and we start forking merrily.
|
||||
print('\nCtrl-C detected, goodbye.')
|
||||
os.kill(0, 9)
|
||||
return_code = 1
|
||||
|
||||
sys.exit(return_code)
|
||||
|
||||
if __name__ == '__main__':
|
||||
main()
|
||||
@@ -1,64 +1,31 @@
|
||||
#!/usr/bin/env bash
|
||||
|
||||
set -e
|
||||
set -o pipefail
|
||||
set -euo pipefail
|
||||
|
||||
CLANG_TIDY_PREFIX=${CLANG_TIDY_PREFIX:-$(scripts/mason.sh PREFIX clang-tidy VERSION 4.0.1)}
|
||||
CLANG_TIDY=${CLANG_TIDY:-${CLANG_TIDY_PREFIX}/bin/clang-tidy}
|
||||
CLANG_APPLY=${CLANG_APPLY:-${CLANG_TIDY_PREFIX}/bin/clang-apply-replacements}
|
||||
CLANG_TIDY_PREFIX=${CLANG_TIDY_PREFIX:-$(scripts/mason.sh PREFIX clang-tidy VERSION 7.0.0)}
|
||||
CLANG_TIDY=${CLANG_TIDY_PREFIX}/bin/clang-tidy
|
||||
CLANG_APPLY=${CLANG_TIDY_PREFIX}/bin/clang-apply-replacements
|
||||
|
||||
CLANG_FORMAT=${CLANG_FORMAT:-$(scripts/mason.sh PREFIX clang-format VERSION 4.0.1)/bin/clang-format}
|
||||
|
||||
for CLANG_FILE in "${CLANG_TIDY} ${CLANG_APPLY} ${CLANG_FORMAT}"; do
|
||||
command -v ${CLANG_TIDY} > /dev/null 2>&1 || {
|
||||
for CLANG_FILE in "${CLANG_TIDY}" "${CLANG_APPLY}"; do
|
||||
command -v "${CLANG_FILE}" > /dev/null 2>&1 || {
|
||||
echo "Can't find ${CLANG_FILE} in PATH."
|
||||
if [ -z ${CLANG_FILE} ]; then
|
||||
if [ -z "${CLANG_FILE}" ]; then
|
||||
echo "Alternatively, you can manually set ${!CLANG_FILE@}."
|
||||
fi
|
||||
exit 1
|
||||
}
|
||||
done
|
||||
|
||||
cd $1
|
||||
|
||||
export CDUP=$(git rev-parse --show-cdup)
|
||||
export CLANG_TIDY CLANG_APPLY CLANG_FORMAT
|
||||
|
||||
function run_clang_tidy() {
|
||||
FILES=$(git ls-files "src/mbgl/*.cpp" "platform/*.cpp" "test/*.cpp")
|
||||
${CLANG_TIDY_PREFIX}/share/run-clang-tidy.py -j ${JOBS} \
|
||||
-clang-tidy-binary ${CLANG_TIDY} \
|
||||
-clang-apply-replacements-binary ${CLANG_APPLY} \
|
||||
-fix ${FILES} 2>/dev/null || exit 1
|
||||
}
|
||||
|
||||
function run_clang_tidy_diff() {
|
||||
OUTPUT=$(git diff origin/$2 --src-prefix=${CDUP} --dst-prefix=${CDUP} | \
|
||||
${CLANG_TIDY_PREFIX}/share/clang-tidy-diff.py \
|
||||
-clang-tidy-binary ${CLANG_TIDY} \
|
||||
2>/dev/null)
|
||||
if [[ -n $OUTPUT ]] && [[ $OUTPUT != "No relevant changes found." ]]; then
|
||||
echo -e "${OUTPUT}"
|
||||
exit 1
|
||||
fi
|
||||
}
|
||||
|
||||
function run_clang_format() {
|
||||
echo "Running clang-format on $0..."
|
||||
DIFF_FILES=$(git diff origin/$2 --name-only *cpp)
|
||||
echo "${DIFF_FILES}" | xargs -I{} -P ${JOBS} bash -c 'run_clang_format' {}
|
||||
${CLANG_FORMAT} -i ${CDUP}/$0 || exit 1
|
||||
}
|
||||
|
||||
export -f run_clang_tidy run_clang_tidy_diff run_clang_format
|
||||
|
||||
echo "Running Clang checks... (this might take a while)"
|
||||
|
||||
if [[ -n $3 ]] && [[ $3 == "--diff" ]]; then
|
||||
run_clang_tidy_diff $@
|
||||
# XXX disabled until we run clang-format over the entire codebase.
|
||||
#run_clang_format $@
|
||||
echo "All checks pass!"
|
||||
if [[ -n ${3:-} ]] && [[ ${3:-} == "--diff" ]]; then
|
||||
git diff "origin/$2" | "scripts/clang-tidy-diff.py" \
|
||||
-clang-tidy-binary "${CLANG_TIDY}" \
|
||||
-p 1 -quiet -path "$1"
|
||||
else
|
||||
run_clang_tidy $@
|
||||
git ls-files "src/*.cpp" "test/*.cpp" "platform/*.cpp" "bin/*.cpp" | \
|
||||
xargs "${CLANG_TIDY_PREFIX}/share/run-clang-tidy.py" \
|
||||
-clang-tidy-binary "${CLANG_TIDY}" \
|
||||
-clang-apply-replacements-binary "${CLANG_APPLY}" \
|
||||
-quiet -p "$1" -fix
|
||||
fi
|
||||
|
||||
@@ -6,8 +6,7 @@
|
||||
|
||||
namespace mbgl {
|
||||
|
||||
Mailbox::Mailbox() {
|
||||
}
|
||||
Mailbox::Mailbox() = default;
|
||||
|
||||
Mailbox::Mailbox(Scheduler& scheduler_)
|
||||
: scheduler(&scheduler_) {
|
||||
|
||||
@@ -64,7 +64,7 @@ GeometryCollection AnnotationTileFeature::getGeometries() const {
|
||||
|
||||
class AnnotationTileLayerData {
|
||||
public:
|
||||
AnnotationTileLayerData(const std::string& name_) : name(name_) {
|
||||
AnnotationTileLayerData(std::string name_) : name(std::move(name_)) {
|
||||
}
|
||||
|
||||
const std::string name;
|
||||
|
||||
@@ -22,7 +22,7 @@ void LineAnnotationImpl::updateStyle(Style::Impl& style) const {
|
||||
layer = style.addLayer(std::move(newLayer), AnnotationManager::PointLayerID);
|
||||
}
|
||||
|
||||
LineLayer* lineLayer = static_cast<LineLayer*>(layer);
|
||||
auto* lineLayer = static_cast<LineLayer*>(layer);
|
||||
lineLayer->setLineOpacity(annotation.opacity);
|
||||
lineLayer->setLineWidth(annotation.width);
|
||||
lineLayer->setLineColor(annotation.color);
|
||||
|
||||
@@ -1,5 +1,6 @@
|
||||
#include <mbgl/layout/symbol_instance.hpp>
|
||||
#include <mbgl/style/layers/symbol_layer_properties.hpp>
|
||||
#include <utility>
|
||||
|
||||
namespace mbgl {
|
||||
|
||||
@@ -34,7 +35,7 @@ SymbolInstance::SymbolInstance(Anchor& anchor_,
|
||||
const IndexedSubfeature& indexedFeature,
|
||||
const std::size_t layoutFeatureIndex_,
|
||||
const std::size_t dataFeatureIndex_,
|
||||
const std::u16string& key_,
|
||||
std::u16string key_,
|
||||
const float overscaling,
|
||||
const float rotate,
|
||||
float radialTextOffset_) :
|
||||
@@ -52,7 +53,7 @@ SymbolInstance::SymbolInstance(Anchor& anchor_,
|
||||
dataFeatureIndex(dataFeatureIndex_),
|
||||
textOffset(textOffset_),
|
||||
iconOffset(iconOffset_),
|
||||
key(key_),
|
||||
key(std::move(key_)),
|
||||
textBoxScale(textBoxScale_),
|
||||
radialTextOffset(radialTextOffset_),
|
||||
singleLine(shapedTextOrientations.singleLine) {
|
||||
|
||||
@@ -40,7 +40,7 @@ public:
|
||||
const IndexedSubfeature&,
|
||||
const std::size_t layoutFeatureIndex,
|
||||
const std::size_t dataFeatureIndex,
|
||||
const std::u16string& key,
|
||||
std::u16string key,
|
||||
const float overscaling,
|
||||
const float rotate,
|
||||
float radialTextOffset);
|
||||
|
||||
@@ -117,8 +117,7 @@ SymbolLayout::SymbolLayout(const BucketParameters& parameters,
|
||||
FontStack baseFontStack = layout.evaluate<TextFont>(zoom, ft);
|
||||
|
||||
ft.formattedText = TaggedString();
|
||||
for (std::size_t j = 0; j < formatted.sections.size(); j++) {
|
||||
const auto& section = formatted.sections[j];
|
||||
for (const auto & section : formatted.sections) {
|
||||
std::string u8string = section.text;
|
||||
if (textTransform == TextTransformType::Uppercase) {
|
||||
u8string = platform::uppercase(u8string);
|
||||
|
||||
@@ -252,7 +252,7 @@ CameraOptions Map::cameraForGeometry(const Geometry<double>& geometry, const Edg
|
||||
|
||||
std::vector<LatLng> latLngs;
|
||||
forEachPoint(geometry, [&](const Point<double>& pt) {
|
||||
latLngs.push_back({ pt.y, pt.x });
|
||||
latLngs.emplace_back(pt.y, pt.x);
|
||||
});
|
||||
return cameraForLatLngs(latLngs, padding, bearing, pitch);
|
||||
}
|
||||
|
||||
@@ -203,8 +203,8 @@ void SymbolBucket::sortFeatures(const float angle) {
|
||||
std::sort(symbolInstanceIndexes.begin(), symbolInstanceIndexes.end(), [sin, cos, this](size_t &aIndex, size_t &bIndex) {
|
||||
const SymbolInstance& a = symbolInstances[aIndex];
|
||||
const SymbolInstance& b = symbolInstances[bIndex];
|
||||
const int32_t aRotated = static_cast<int32_t>(::lround(sin * a.anchor.point.x + cos * a.anchor.point.y));
|
||||
const int32_t bRotated = static_cast<int32_t>(::lround(sin * b.anchor.point.x + cos * b.anchor.point.y));
|
||||
const auto aRotated = static_cast<int32_t>(::lround(sin * a.anchor.point.x + cos * a.anchor.point.y));
|
||||
const auto bRotated = static_cast<int32_t>(::lround(sin * b.anchor.point.x + cos * b.anchor.point.y));
|
||||
return aRotated != bRotated ?
|
||||
aRotated < bRotated :
|
||||
a.dataFeatureIndex > b.dataFeatureIndex;
|
||||
|
||||
@@ -59,7 +59,7 @@ void RenderCustomLayer::render(PaintParameters& paintParameters, RenderSource*)
|
||||
}
|
||||
|
||||
// TODO: remove cast
|
||||
gl::Context& glContext = static_cast<gl::Context&>(paintParameters.context);
|
||||
auto& glContext = static_cast<gl::Context&>(paintParameters.context);
|
||||
const TransformState& state = paintParameters.state;
|
||||
|
||||
// Reset GL state to a known state so the CustomLayer always has a clean slate.
|
||||
|
||||
@@ -138,7 +138,7 @@ void RenderFillExtrusionLayer::render(PaintParameters& parameters, RenderSource*
|
||||
continue;
|
||||
}
|
||||
const auto fillPatternValue = evaluated.get<FillExtrusionPattern>().constantOr(mbgl::Faded<std::basic_string<char> >{"", ""});
|
||||
GeometryTile& geometryTile = static_cast<GeometryTile&>(tile.tile);
|
||||
auto& geometryTile = static_cast<GeometryTile&>(tile.tile);
|
||||
optional<ImagePosition> patternPosA = geometryTile.getPattern(fillPatternValue.from);
|
||||
optional<ImagePosition> patternPosB = geometryTile.getPattern(fillPatternValue.to);
|
||||
FillExtrusionBucket& bucket = *bucket_;
|
||||
|
||||
@@ -150,7 +150,7 @@ void RenderFillLayer::render(PaintParameters& parameters, RenderSource*) {
|
||||
}
|
||||
const auto fillPatternValue = evaluated.get<FillPattern>().constantOr(Faded<std::basic_string<char>>{"", ""});
|
||||
for (const RenderTile& tile : renderTiles) {
|
||||
GeometryTile& geometryTile = static_cast<GeometryTile&>(tile.tile);
|
||||
auto& geometryTile = static_cast<GeometryTile&>(tile.tile);
|
||||
optional<ImagePosition> patternPosA = geometryTile.getPattern(fillPatternValue.from);
|
||||
optional<ImagePosition> patternPosB = geometryTile.getPattern(fillPatternValue.to);
|
||||
|
||||
|
||||
@@ -61,7 +61,7 @@ void RenderHillshadeLayer::render(PaintParameters& parameters, RenderSource* src
|
||||
if (parameters.pass != RenderPass::Translucent && parameters.pass != RenderPass::Pass3D)
|
||||
return;
|
||||
|
||||
RenderRasterDEMSource* demsrc = static_cast<RenderRasterDEMSource*>(src);
|
||||
auto* demsrc = static_cast<RenderRasterDEMSource*>(src);
|
||||
const uint8_t TERRAIN_RGB_MAXZOOM = 15;
|
||||
const uint8_t maxzoom = demsrc != nullptr ? demsrc->getMaxZoom() : TERRAIN_RGB_MAXZOOM;
|
||||
|
||||
|
||||
@@ -126,7 +126,7 @@ void RenderLineLayer::render(PaintParameters& parameters, RenderSource*) {
|
||||
|
||||
} else if (!unevaluated.get<LinePattern>().isUndefined()) {
|
||||
const auto linePatternValue = evaluated.get<LinePattern>().constantOr(Faded<std::basic_string<char>>{ "", ""});
|
||||
GeometryTile& geometryTile = static_cast<GeometryTile&>(tile.tile);
|
||||
auto& geometryTile = static_cast<GeometryTile&>(tile.tile);
|
||||
const Size texsize = geometryTile.iconAtlasTexture->size;
|
||||
|
||||
optional<ImagePosition> posA = geometryTile.getPattern(linePatternValue.from);
|
||||
|
||||
@@ -127,7 +127,7 @@ void RenderRasterLayer::render(PaintParameters& parameters, RenderSource* source
|
||||
|
||||
const gfx::TextureFilterType filter = evaluated.get<RasterResampling>() == RasterResamplingType::Nearest ? gfx::TextureFilterType::Nearest : gfx::TextureFilterType::Linear;
|
||||
|
||||
if (RenderImageSource* imageSource = source->as<RenderImageSource>()) {
|
||||
if (auto* imageSource = source->as<RenderImageSource>()) {
|
||||
if (imageSource->isEnabled() && imageSource->isLoaded() && !imageSource->bucket->needsUpload()) {
|
||||
RasterBucket& bucket = *imageSource->bucket;
|
||||
assert(bucket.texture);
|
||||
|
||||
@@ -148,7 +148,7 @@ void RenderSymbolLayer::render(PaintParameters& parameters, RenderSource*) {
|
||||
};
|
||||
|
||||
assert(tile.tile.kind == Tile::Kind::Geometry);
|
||||
GeometryTile& geometryTile = static_cast<GeometryTile&>(tile.tile);
|
||||
auto& geometryTile = static_cast<GeometryTile&>(tile.tile);
|
||||
|
||||
if (bucket.hasIconData()) {
|
||||
auto values = iconPropertyValues(evaluated_, layout);
|
||||
|
||||
@@ -11,6 +11,7 @@
|
||||
#include <mbgl/tile/tile.hpp>
|
||||
|
||||
#include <mbgl/layermanager/layer_manager.hpp>
|
||||
#include <utility>
|
||||
|
||||
namespace mbgl {
|
||||
|
||||
@@ -50,7 +51,7 @@ std::unique_ptr<RenderSource> RenderSource::create(Immutable<Source::Impl> impl)
|
||||
static RenderSourceObserver nullObserver;
|
||||
|
||||
RenderSource::RenderSource(Immutable<style::Source::Impl> impl)
|
||||
: baseImpl(impl),
|
||||
: baseImpl(std::move(impl)),
|
||||
observer(&nullObserver) {
|
||||
}
|
||||
|
||||
|
||||
@@ -576,7 +576,7 @@ void Renderer::Impl::queryRenderedSymbols(std::unordered_map<std::string, std::v
|
||||
auto renderedSymbols = placement->getCollisionIndex().queryRenderedSymbols(geometry);
|
||||
std::vector<std::reference_wrapper<const RetainedQueryData>> bucketQueryData;
|
||||
for (auto entry : renderedSymbols) {
|
||||
bucketQueryData.push_back(placement->getQueryData(entry.first));
|
||||
bucketQueryData.emplace_back(placement->getQueryData(entry.first));
|
||||
}
|
||||
// Although symbol query is global, symbol results are only sortable within a bucket
|
||||
// For a predictable global sort renderItems, we sort the buckets based on their corresponding tile position
|
||||
|
||||
@@ -66,7 +66,7 @@ MAPBOX_ETERNAL_CONSTEXPR const auto extensionGetters = mapbox::eternal::hash_map
|
||||
{"expansion-zoom", &getClusterExpansionZoom}
|
||||
});
|
||||
|
||||
}
|
||||
} // namespace
|
||||
|
||||
RenderGeoJSONSource::RenderGeoJSONSource(Immutable<style::GeoJSONSource::Impl> impl_)
|
||||
: RenderSource(impl_) {
|
||||
|
||||
@@ -38,10 +38,10 @@ void RenderImageSource::startRender(PaintParameters& parameters) {
|
||||
|
||||
matrices.clear();
|
||||
|
||||
for (size_t i = 0; i < tileIds.size(); i++) {
|
||||
for (auto& tileId : tileIds) {
|
||||
mat4 matrix;
|
||||
matrix::identity(matrix);
|
||||
parameters.state.matrixFor(matrix, tileIds[i]);
|
||||
parameters.state.matrixFor(matrix, tileId);
|
||||
matrix::multiply(matrix, parameters.alignedProjMatrix, matrix);
|
||||
matrices.push_back(matrix);
|
||||
}
|
||||
@@ -167,7 +167,7 @@ void RenderImageSource::update(Immutable<style::Source::Impl> baseImpl_,
|
||||
auto idealTiles = util::tileCover(transformState, transformState.getZoom());
|
||||
for (auto tile : idealTiles) {
|
||||
if (tile.wrap != 0 && tileCover[0].canonical.isChildOf(tile.canonical)) {
|
||||
tileIds.push_back({ tile.wrap, tileCover[0].canonical });
|
||||
tileIds.emplace_back(tile.wrap, tileCover[0].canonical);
|
||||
hasVisibleTile = true;
|
||||
}
|
||||
else if (!hasVisibleTile) {
|
||||
|
||||
@@ -60,7 +60,7 @@ void RenderRasterDEMSource::update(Immutable<style::Source::Impl> baseImpl_,
|
||||
}
|
||||
|
||||
void RenderRasterDEMSource::onTileChanged(Tile& tile){
|
||||
RasterDEMTile& demtile = static_cast<RasterDEMTile&>(tile);
|
||||
auto& demtile = static_cast<RasterDEMTile&>(tile);
|
||||
|
||||
std::map<DEMTileNeighbors, DEMTileNeighbors> opposites = {
|
||||
{ DEMTileNeighbors::Left, DEMTileNeighbors::Right },
|
||||
@@ -104,13 +104,13 @@ void RenderRasterDEMSource::onTileChanged(Tile& tile){
|
||||
};
|
||||
|
||||
for (uint8_t i = 0; i < 8; i++) {
|
||||
DEMTileNeighbors mask = DEMTileNeighbors(std::pow(2,i));
|
||||
auto mask = DEMTileNeighbors(std::pow(2,i));
|
||||
// only backfill if this neighbor has not been previously backfilled
|
||||
if ((demtile.neighboringTiles & mask) != mask) {
|
||||
OverscaledTileID neighborid = getNeighbor(mask);
|
||||
Tile* renderableNeighbor = tilePyramid.getTile(neighborid);
|
||||
if (renderableNeighbor != nullptr && renderableNeighbor->isRenderable()) {
|
||||
RasterDEMTile& borderTile = static_cast<RasterDEMTile&>(*renderableNeighbor);
|
||||
auto& borderTile = static_cast<RasterDEMTile&>(*renderableNeighbor);
|
||||
demtile.backfillBorder(borderTile, mask);
|
||||
|
||||
// if the border tile has not been backfilled by a previous instance of the main
|
||||
|
||||
@@ -18,7 +18,7 @@ std::shared_ptr<FileSource> FileSource::getSharedFileSource(const ResourceOption
|
||||
it = it->second.expired() ? fileSources.erase(it) : ++it;
|
||||
}
|
||||
|
||||
const uint64_t context = reinterpret_cast<uint64_t>(options.platformContext());
|
||||
const auto context = reinterpret_cast<uint64_t>(options.platformContext());
|
||||
const std::string key = options.baseURL() + '|' + options.accessToken() + '|' + options.cachePath() + '|' + util::toString(context);
|
||||
|
||||
std::shared_ptr<mbgl::FileSource> fileSource;
|
||||
|
||||
@@ -233,7 +233,7 @@ optional<mbgl::Value> serializeLegacyFilter(const Convertible& values) {
|
||||
if (arrayValue) {
|
||||
result.push_back(*arrayValue);
|
||||
} else {
|
||||
result.push_back(NullValue());
|
||||
result.emplace_back(NullValue());
|
||||
}
|
||||
}
|
||||
return (mbgl::Value)result;
|
||||
|
||||
@@ -251,7 +251,7 @@ static optional<std::unique_ptr<Expression>> convertLiteral(type::Type type, con
|
||||
error.message = "value must be an array of numbers";
|
||||
return nullopt;
|
||||
}
|
||||
result.push_back(double(*number));
|
||||
result.emplace_back(double(*number));
|
||||
}
|
||||
return literal(result);
|
||||
},
|
||||
@@ -264,7 +264,7 @@ static optional<std::unique_ptr<Expression>> convertLiteral(type::Type type, con
|
||||
error.message = "value must be an array of strings";
|
||||
return nullopt;
|
||||
}
|
||||
result.push_back(*string);
|
||||
result.emplace_back(*string);
|
||||
}
|
||||
return literal(result);
|
||||
},
|
||||
|
||||
@@ -20,9 +20,9 @@ void CustomTileLoader::fetchTile(const OverscaledTileID& tileID, ActorRef<Custom
|
||||
auto tuple = std::make_tuple(tileID.overscaledZ, tileID.wrap, tileRef);
|
||||
tileCallbackMap.insert({ tileID.canonical, std::vector<OverscaledIDFunctionTuple>(1, tuple) });
|
||||
} else {
|
||||
for (auto iter = tileCallbacks->second.begin(); iter != tileCallbacks->second.end(); iter++) {
|
||||
if (std::get<0>(*iter) == tileID.overscaledZ && std::get<1>(*iter) == tileID.wrap ) {
|
||||
std::get<2>(*iter) = tileRef;
|
||||
for (auto& iter : tileCallbacks->second) {
|
||||
if (std::get<0>(iter) == tileID.overscaledZ && std::get<1>(iter) == tileID.wrap ) {
|
||||
std::get<2>(iter) = tileRef;
|
||||
return;
|
||||
}
|
||||
}
|
||||
@@ -70,8 +70,8 @@ void CustomTileLoader::setTileData(const CanonicalTileID& tileID, const GeoJSON&
|
||||
void CustomTileLoader::invalidateTile(const CanonicalTileID& tileID) {
|
||||
auto tileCallbacks = tileCallbackMap.find(tileID);
|
||||
if (tileCallbacks == tileCallbackMap.end()) { return; }
|
||||
for (auto iter = tileCallbacks->second.begin(); iter != tileCallbacks->second.end(); iter++) {
|
||||
auto actor = std::get<2>(*iter);
|
||||
for (auto& iter : tileCallbacks->second) {
|
||||
auto actor = std::get<2>(iter);
|
||||
actor.invoke(&CustomGeometryTile::invalidateTileData);
|
||||
invokeTileCancel(tileID);
|
||||
}
|
||||
@@ -82,20 +82,20 @@ void CustomTileLoader::invalidateTile(const CanonicalTileID& tileID) {
|
||||
void CustomTileLoader::invalidateRegion(const LatLngBounds& bounds, Range<uint8_t> ) {
|
||||
std::map<uint8_t, util::TileRange> tileRanges;
|
||||
|
||||
for (auto idtuple= tileCallbackMap.begin(); idtuple != tileCallbackMap.end(); idtuple++) {
|
||||
auto zoom = idtuple->first.z;
|
||||
for (auto& idtuple : tileCallbackMap) {
|
||||
auto zoom = idtuple.first.z;
|
||||
auto tileRange = tileRanges.find(zoom);
|
||||
if(tileRange == tileRanges.end()) {
|
||||
tileRange = tileRanges.emplace(std::make_pair(zoom, util::TileRange::fromLatLngBounds(bounds, zoom))).first;
|
||||
}
|
||||
if (tileRange->second.contains(idtuple->first)) {
|
||||
for (auto iter = idtuple->second.begin(); iter != idtuple->second.end(); iter++) {
|
||||
if (tileRange->second.contains(idtuple.first)) {
|
||||
for (auto iter = idtuple.second.begin(); iter != idtuple.second.end(); iter++) {
|
||||
auto actor = std::get<2>(*iter);
|
||||
actor.invoke(&CustomGeometryTile::invalidateTileData);
|
||||
invokeTileCancel(idtuple->first);
|
||||
dataCache.erase(idtuple->first);
|
||||
invokeTileCancel(idtuple.first);
|
||||
dataCache.erase(idtuple.first);
|
||||
}
|
||||
idtuple->second.clear();
|
||||
idtuple.second.clear();
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@@ -6,8 +6,8 @@ namespace style {
|
||||
namespace expression {
|
||||
|
||||
EvaluationResult Any::evaluate(const EvaluationContext& params) const {
|
||||
for (auto it = inputs.begin(); it != inputs.end(); it++) {
|
||||
const EvaluationResult result = (*it)->evaluate(params);
|
||||
for (const auto& input : inputs) {
|
||||
const EvaluationResult result = input->evaluate(params);
|
||||
if (!result) return result;
|
||||
if (result->get<bool>()) return EvaluationResult(true);
|
||||
}
|
||||
@@ -34,8 +34,8 @@ std::vector<optional<Value>> Any::possibleOutputs() const {
|
||||
|
||||
|
||||
EvaluationResult All::evaluate(const EvaluationContext& params) const {
|
||||
for (auto it = inputs.begin(); it != inputs.end(); it++) {
|
||||
const EvaluationResult result = (*it)->evaluate(params);
|
||||
for (const auto& input : inputs) {
|
||||
const EvaluationResult result = input->evaluate(params);
|
||||
if (!result) return result;
|
||||
if (!result->get<bool>()) return EvaluationResult(false);
|
||||
}
|
||||
|
||||
@@ -86,7 +86,7 @@ ParseResult Case::parse(const Convertible& value, ParsingContext& ctx) {
|
||||
outputType = (*output)->getType();
|
||||
}
|
||||
|
||||
branches.push_back(std::make_pair(std::move(*test), std::move(*output)));
|
||||
branches.emplace_back(std::move(*test), std::move(*output));
|
||||
}
|
||||
|
||||
assert(outputType);
|
||||
|
||||
@@ -113,7 +113,7 @@ mbgl::Value Coercion::serialize() const {
|
||||
// by string expressions that get implicitly coerced to "formatted".
|
||||
std::vector<mbgl::Value> serialized{{ std::string("format") }};
|
||||
serialized.push_back(inputs[0]->serialize());
|
||||
serialized.push_back(std::unordered_map<std::string, mbgl::Value>());
|
||||
serialized.emplace_back(std::unordered_map<std::string, mbgl::Value>());
|
||||
return serialized;
|
||||
} else {
|
||||
return Expression::serialize();
|
||||
|
||||
@@ -2,6 +2,7 @@
|
||||
#include <mbgl/style/expression/comparison.hpp>
|
||||
#include <mbgl/style/expression/dsl.hpp>
|
||||
#include <mbgl/style/conversion_impl.hpp>
|
||||
#include <utility>
|
||||
|
||||
namespace mbgl {
|
||||
namespace style {
|
||||
@@ -149,7 +150,7 @@ CollatorComparison::CollatorComparison(
|
||||
std::unique_ptr<Expression> rhs_,
|
||||
std::unique_ptr<Expression> collator_)
|
||||
: Expression(Kind::Comparison, type::Boolean),
|
||||
op(op_),
|
||||
op(std::move(op_)),
|
||||
compare(getCollatorComparisonFunction(op)),
|
||||
lhs(std::move(lhs_)),
|
||||
rhs(std::move(rhs_)),
|
||||
|
||||
@@ -41,7 +41,7 @@ std::unique_ptr<Expression> literal(Value value) {
|
||||
std::unique_ptr<Expression> literal(std::initializer_list<double> value) {
|
||||
std::vector<Value> values;
|
||||
for (auto i : value) {
|
||||
values.push_back(i);
|
||||
values.emplace_back(i);
|
||||
}
|
||||
return literal(values);
|
||||
}
|
||||
@@ -49,7 +49,7 @@ std::unique_ptr<Expression> literal(std::initializer_list<double> value) {
|
||||
std::unique_ptr<Expression> literal(std::initializer_list<const char *> value) {
|
||||
std::vector<Value> values;
|
||||
for (auto i : value) {
|
||||
values.push_back(std::string(i));
|
||||
values.emplace_back(std::string(i));
|
||||
}
|
||||
return literal(values);
|
||||
}
|
||||
|
||||
@@ -152,7 +152,7 @@ mbgl::Value FormatExpression::serialize() const {
|
||||
if (section.textColor) {
|
||||
options.emplace(kFormattedSectionTextColor, (*section.textColor)->serialize());
|
||||
}
|
||||
serialized.push_back(options);
|
||||
serialized.emplace_back(options);
|
||||
}
|
||||
return serialized;
|
||||
}
|
||||
|
||||
@@ -104,7 +104,7 @@ optional<Formatted> Converter<Formatted>::operator()(const Convertible& value, E
|
||||
}
|
||||
}
|
||||
|
||||
sections.push_back(FormattedSection(*sectionText, fontScale, textFont, textColor));
|
||||
sections.emplace_back(*sectionText, fontScale, textFont, textColor);
|
||||
}
|
||||
return Formatted(sections);
|
||||
} else if (optional<std::string> result = toString(value)) {
|
||||
|
||||
@@ -12,8 +12,8 @@ EvaluationResult Let::evaluate(const EvaluationContext& params) const {
|
||||
}
|
||||
|
||||
void Let::eachChild(const std::function<void(const Expression&)>& visit) const {
|
||||
for (auto it = bindings.begin(); it != bindings.end(); it++) {
|
||||
visit(*it->second);
|
||||
for (const auto& binding : bindings) {
|
||||
visit(*binding.second);
|
||||
}
|
||||
visit(*result);
|
||||
}
|
||||
|
||||
@@ -287,7 +287,7 @@ ParseResult parseMatch(const Convertible& value, ParsingContext& ctx) {
|
||||
outputType = (*output)->getType();
|
||||
}
|
||||
|
||||
branches.push_back(std::make_pair(std::move(labels), std::move(*output)));
|
||||
branches.emplace_back(std::move(labels), std::move(*output));
|
||||
}
|
||||
|
||||
auto input = ctx.parse(arrayMember(value, 1), 1, {type::Value});
|
||||
|
||||
@@ -46,13 +46,13 @@ EvaluationResult Step::evaluate(const EvaluationContext& params) const {
|
||||
|
||||
void Step::eachChild(const std::function<void(const Expression&)>& visit) const {
|
||||
visit(*input);
|
||||
for (auto it = stops.begin(); it != stops.end(); it++) {
|
||||
visit(*it->second);
|
||||
for (const auto& stop : stops) {
|
||||
visit(*stop.second);
|
||||
}
|
||||
}
|
||||
|
||||
void Step::eachStop(const std::function<void(double, const Expression&)>& visit) const {
|
||||
for (const auto &stop : stops) {
|
||||
for (const auto& stop : stops) {
|
||||
visit(stop.first, *stop.second);
|
||||
}
|
||||
}
|
||||
|
||||
@@ -171,7 +171,7 @@ mbgl::Value ValueConverter<mbgl::Value>::fromExpressionValue(const Value& value)
|
||||
options.emplace("text-color", fromExpressionValue(*section.textColor));
|
||||
}
|
||||
|
||||
serialized.push_back(options);
|
||||
serialized.emplace_back(options);
|
||||
}
|
||||
return serialized;
|
||||
},
|
||||
|
||||
@@ -66,11 +66,11 @@ PropertyValue<Color> BackgroundLayer::getDefaultBackgroundColor() {
|
||||
return { Color::black() };
|
||||
}
|
||||
|
||||
PropertyValue<Color> BackgroundLayer::getBackgroundColor() const {
|
||||
const PropertyValue<Color>& BackgroundLayer::getBackgroundColor() const {
|
||||
return impl().paint.template get<BackgroundColor>().value;
|
||||
}
|
||||
|
||||
void BackgroundLayer::setBackgroundColor(PropertyValue<Color> value) {
|
||||
void BackgroundLayer::setBackgroundColor(const PropertyValue<Color>& value) {
|
||||
if (value == getBackgroundColor())
|
||||
return;
|
||||
auto impl_ = mutableImpl();
|
||||
@@ -93,11 +93,11 @@ PropertyValue<std::string> BackgroundLayer::getDefaultBackgroundPattern() {
|
||||
return { "" };
|
||||
}
|
||||
|
||||
PropertyValue<std::string> BackgroundLayer::getBackgroundPattern() const {
|
||||
const PropertyValue<std::string>& BackgroundLayer::getBackgroundPattern() const {
|
||||
return impl().paint.template get<BackgroundPattern>().value;
|
||||
}
|
||||
|
||||
void BackgroundLayer::setBackgroundPattern(PropertyValue<std::string> value) {
|
||||
void BackgroundLayer::setBackgroundPattern(const PropertyValue<std::string>& value) {
|
||||
if (value == getBackgroundPattern())
|
||||
return;
|
||||
auto impl_ = mutableImpl();
|
||||
@@ -120,11 +120,11 @@ PropertyValue<float> BackgroundLayer::getDefaultBackgroundOpacity() {
|
||||
return { 1 };
|
||||
}
|
||||
|
||||
PropertyValue<float> BackgroundLayer::getBackgroundOpacity() const {
|
||||
const PropertyValue<float>& BackgroundLayer::getBackgroundOpacity() const {
|
||||
return impl().paint.template get<BackgroundOpacity>().value;
|
||||
}
|
||||
|
||||
void BackgroundLayer::setBackgroundOpacity(PropertyValue<float> value) {
|
||||
void BackgroundLayer::setBackgroundOpacity(const PropertyValue<float>& value) {
|
||||
if (value == getBackgroundOpacity())
|
||||
return;
|
||||
auto impl_ = mutableImpl();
|
||||
@@ -169,7 +169,7 @@ optional<Error> BackgroundLayer::setPaintProperty(const std::string& name, const
|
||||
return Error { "layer doesn't support this property" };
|
||||
}
|
||||
|
||||
Property property = static_cast<Property>(it->second);
|
||||
auto property = static_cast<Property>(it->second);
|
||||
|
||||
|
||||
if (property == Property::BackgroundColor) {
|
||||
|
||||
@@ -66,11 +66,11 @@ PropertyValue<float> CircleLayer::getDefaultCircleRadius() {
|
||||
return { 5 };
|
||||
}
|
||||
|
||||
PropertyValue<float> CircleLayer::getCircleRadius() const {
|
||||
const PropertyValue<float>& CircleLayer::getCircleRadius() const {
|
||||
return impl().paint.template get<CircleRadius>().value;
|
||||
}
|
||||
|
||||
void CircleLayer::setCircleRadius(PropertyValue<float> value) {
|
||||
void CircleLayer::setCircleRadius(const PropertyValue<float>& value) {
|
||||
if (value == getCircleRadius())
|
||||
return;
|
||||
auto impl_ = mutableImpl();
|
||||
@@ -93,11 +93,11 @@ PropertyValue<Color> CircleLayer::getDefaultCircleColor() {
|
||||
return { Color::black() };
|
||||
}
|
||||
|
||||
PropertyValue<Color> CircleLayer::getCircleColor() const {
|
||||
const PropertyValue<Color>& CircleLayer::getCircleColor() const {
|
||||
return impl().paint.template get<CircleColor>().value;
|
||||
}
|
||||
|
||||
void CircleLayer::setCircleColor(PropertyValue<Color> value) {
|
||||
void CircleLayer::setCircleColor(const PropertyValue<Color>& value) {
|
||||
if (value == getCircleColor())
|
||||
return;
|
||||
auto impl_ = mutableImpl();
|
||||
@@ -120,11 +120,11 @@ PropertyValue<float> CircleLayer::getDefaultCircleBlur() {
|
||||
return { 0 };
|
||||
}
|
||||
|
||||
PropertyValue<float> CircleLayer::getCircleBlur() const {
|
||||
const PropertyValue<float>& CircleLayer::getCircleBlur() const {
|
||||
return impl().paint.template get<CircleBlur>().value;
|
||||
}
|
||||
|
||||
void CircleLayer::setCircleBlur(PropertyValue<float> value) {
|
||||
void CircleLayer::setCircleBlur(const PropertyValue<float>& value) {
|
||||
if (value == getCircleBlur())
|
||||
return;
|
||||
auto impl_ = mutableImpl();
|
||||
@@ -147,11 +147,11 @@ PropertyValue<float> CircleLayer::getDefaultCircleOpacity() {
|
||||
return { 1 };
|
||||
}
|
||||
|
||||
PropertyValue<float> CircleLayer::getCircleOpacity() const {
|
||||
const PropertyValue<float>& CircleLayer::getCircleOpacity() const {
|
||||
return impl().paint.template get<CircleOpacity>().value;
|
||||
}
|
||||
|
||||
void CircleLayer::setCircleOpacity(PropertyValue<float> value) {
|
||||
void CircleLayer::setCircleOpacity(const PropertyValue<float>& value) {
|
||||
if (value == getCircleOpacity())
|
||||
return;
|
||||
auto impl_ = mutableImpl();
|
||||
@@ -174,11 +174,11 @@ PropertyValue<std::array<float, 2>> CircleLayer::getDefaultCircleTranslate() {
|
||||
return { {{ 0, 0 }} };
|
||||
}
|
||||
|
||||
PropertyValue<std::array<float, 2>> CircleLayer::getCircleTranslate() const {
|
||||
const PropertyValue<std::array<float, 2>>& CircleLayer::getCircleTranslate() const {
|
||||
return impl().paint.template get<CircleTranslate>().value;
|
||||
}
|
||||
|
||||
void CircleLayer::setCircleTranslate(PropertyValue<std::array<float, 2>> value) {
|
||||
void CircleLayer::setCircleTranslate(const PropertyValue<std::array<float, 2>>& value) {
|
||||
if (value == getCircleTranslate())
|
||||
return;
|
||||
auto impl_ = mutableImpl();
|
||||
@@ -201,11 +201,11 @@ PropertyValue<TranslateAnchorType> CircleLayer::getDefaultCircleTranslateAnchor(
|
||||
return { TranslateAnchorType::Map };
|
||||
}
|
||||
|
||||
PropertyValue<TranslateAnchorType> CircleLayer::getCircleTranslateAnchor() const {
|
||||
const PropertyValue<TranslateAnchorType>& CircleLayer::getCircleTranslateAnchor() const {
|
||||
return impl().paint.template get<CircleTranslateAnchor>().value;
|
||||
}
|
||||
|
||||
void CircleLayer::setCircleTranslateAnchor(PropertyValue<TranslateAnchorType> value) {
|
||||
void CircleLayer::setCircleTranslateAnchor(const PropertyValue<TranslateAnchorType>& value) {
|
||||
if (value == getCircleTranslateAnchor())
|
||||
return;
|
||||
auto impl_ = mutableImpl();
|
||||
@@ -228,11 +228,11 @@ PropertyValue<CirclePitchScaleType> CircleLayer::getDefaultCirclePitchScale() {
|
||||
return { CirclePitchScaleType::Map };
|
||||
}
|
||||
|
||||
PropertyValue<CirclePitchScaleType> CircleLayer::getCirclePitchScale() const {
|
||||
const PropertyValue<CirclePitchScaleType>& CircleLayer::getCirclePitchScale() const {
|
||||
return impl().paint.template get<CirclePitchScale>().value;
|
||||
}
|
||||
|
||||
void CircleLayer::setCirclePitchScale(PropertyValue<CirclePitchScaleType> value) {
|
||||
void CircleLayer::setCirclePitchScale(const PropertyValue<CirclePitchScaleType>& value) {
|
||||
if (value == getCirclePitchScale())
|
||||
return;
|
||||
auto impl_ = mutableImpl();
|
||||
@@ -255,11 +255,11 @@ PropertyValue<AlignmentType> CircleLayer::getDefaultCirclePitchAlignment() {
|
||||
return { AlignmentType::Viewport };
|
||||
}
|
||||
|
||||
PropertyValue<AlignmentType> CircleLayer::getCirclePitchAlignment() const {
|
||||
const PropertyValue<AlignmentType>& CircleLayer::getCirclePitchAlignment() const {
|
||||
return impl().paint.template get<CirclePitchAlignment>().value;
|
||||
}
|
||||
|
||||
void CircleLayer::setCirclePitchAlignment(PropertyValue<AlignmentType> value) {
|
||||
void CircleLayer::setCirclePitchAlignment(const PropertyValue<AlignmentType>& value) {
|
||||
if (value == getCirclePitchAlignment())
|
||||
return;
|
||||
auto impl_ = mutableImpl();
|
||||
@@ -282,11 +282,11 @@ PropertyValue<float> CircleLayer::getDefaultCircleStrokeWidth() {
|
||||
return { 0 };
|
||||
}
|
||||
|
||||
PropertyValue<float> CircleLayer::getCircleStrokeWidth() const {
|
||||
const PropertyValue<float>& CircleLayer::getCircleStrokeWidth() const {
|
||||
return impl().paint.template get<CircleStrokeWidth>().value;
|
||||
}
|
||||
|
||||
void CircleLayer::setCircleStrokeWidth(PropertyValue<float> value) {
|
||||
void CircleLayer::setCircleStrokeWidth(const PropertyValue<float>& value) {
|
||||
if (value == getCircleStrokeWidth())
|
||||
return;
|
||||
auto impl_ = mutableImpl();
|
||||
@@ -309,11 +309,11 @@ PropertyValue<Color> CircleLayer::getDefaultCircleStrokeColor() {
|
||||
return { Color::black() };
|
||||
}
|
||||
|
||||
PropertyValue<Color> CircleLayer::getCircleStrokeColor() const {
|
||||
const PropertyValue<Color>& CircleLayer::getCircleStrokeColor() const {
|
||||
return impl().paint.template get<CircleStrokeColor>().value;
|
||||
}
|
||||
|
||||
void CircleLayer::setCircleStrokeColor(PropertyValue<Color> value) {
|
||||
void CircleLayer::setCircleStrokeColor(const PropertyValue<Color>& value) {
|
||||
if (value == getCircleStrokeColor())
|
||||
return;
|
||||
auto impl_ = mutableImpl();
|
||||
@@ -336,11 +336,11 @@ PropertyValue<float> CircleLayer::getDefaultCircleStrokeOpacity() {
|
||||
return { 1 };
|
||||
}
|
||||
|
||||
PropertyValue<float> CircleLayer::getCircleStrokeOpacity() const {
|
||||
const PropertyValue<float>& CircleLayer::getCircleStrokeOpacity() const {
|
||||
return impl().paint.template get<CircleStrokeOpacity>().value;
|
||||
}
|
||||
|
||||
void CircleLayer::setCircleStrokeOpacity(PropertyValue<float> value) {
|
||||
void CircleLayer::setCircleStrokeOpacity(const PropertyValue<float>& value) {
|
||||
if (value == getCircleStrokeOpacity())
|
||||
return;
|
||||
auto impl_ = mutableImpl();
|
||||
@@ -417,7 +417,7 @@ optional<Error> CircleLayer::setPaintProperty(const std::string& name, const Con
|
||||
return Error { "layer doesn't support this property" };
|
||||
}
|
||||
|
||||
Property property = static_cast<Property>(it->second);
|
||||
auto property = static_cast<Property>(it->second);
|
||||
|
||||
|
||||
if (property == Property::CircleRadius || property == Property::CircleBlur || property == Property::CircleOpacity || property == Property::CircleStrokeWidth || property == Property::CircleStrokeOpacity) {
|
||||
|
||||
@@ -66,11 +66,11 @@ PropertyValue<float> FillExtrusionLayer::getDefaultFillExtrusionOpacity() {
|
||||
return { 1 };
|
||||
}
|
||||
|
||||
PropertyValue<float> FillExtrusionLayer::getFillExtrusionOpacity() const {
|
||||
const PropertyValue<float>& FillExtrusionLayer::getFillExtrusionOpacity() const {
|
||||
return impl().paint.template get<FillExtrusionOpacity>().value;
|
||||
}
|
||||
|
||||
void FillExtrusionLayer::setFillExtrusionOpacity(PropertyValue<float> value) {
|
||||
void FillExtrusionLayer::setFillExtrusionOpacity(const PropertyValue<float>& value) {
|
||||
if (value == getFillExtrusionOpacity())
|
||||
return;
|
||||
auto impl_ = mutableImpl();
|
||||
@@ -93,11 +93,11 @@ PropertyValue<Color> FillExtrusionLayer::getDefaultFillExtrusionColor() {
|
||||
return { Color::black() };
|
||||
}
|
||||
|
||||
PropertyValue<Color> FillExtrusionLayer::getFillExtrusionColor() const {
|
||||
const PropertyValue<Color>& FillExtrusionLayer::getFillExtrusionColor() const {
|
||||
return impl().paint.template get<FillExtrusionColor>().value;
|
||||
}
|
||||
|
||||
void FillExtrusionLayer::setFillExtrusionColor(PropertyValue<Color> value) {
|
||||
void FillExtrusionLayer::setFillExtrusionColor(const PropertyValue<Color>& value) {
|
||||
if (value == getFillExtrusionColor())
|
||||
return;
|
||||
auto impl_ = mutableImpl();
|
||||
@@ -120,11 +120,11 @@ PropertyValue<std::array<float, 2>> FillExtrusionLayer::getDefaultFillExtrusionT
|
||||
return { {{ 0, 0 }} };
|
||||
}
|
||||
|
||||
PropertyValue<std::array<float, 2>> FillExtrusionLayer::getFillExtrusionTranslate() const {
|
||||
const PropertyValue<std::array<float, 2>>& FillExtrusionLayer::getFillExtrusionTranslate() const {
|
||||
return impl().paint.template get<FillExtrusionTranslate>().value;
|
||||
}
|
||||
|
||||
void FillExtrusionLayer::setFillExtrusionTranslate(PropertyValue<std::array<float, 2>> value) {
|
||||
void FillExtrusionLayer::setFillExtrusionTranslate(const PropertyValue<std::array<float, 2>>& value) {
|
||||
if (value == getFillExtrusionTranslate())
|
||||
return;
|
||||
auto impl_ = mutableImpl();
|
||||
@@ -147,11 +147,11 @@ PropertyValue<TranslateAnchorType> FillExtrusionLayer::getDefaultFillExtrusionTr
|
||||
return { TranslateAnchorType::Map };
|
||||
}
|
||||
|
||||
PropertyValue<TranslateAnchorType> FillExtrusionLayer::getFillExtrusionTranslateAnchor() const {
|
||||
const PropertyValue<TranslateAnchorType>& FillExtrusionLayer::getFillExtrusionTranslateAnchor() const {
|
||||
return impl().paint.template get<FillExtrusionTranslateAnchor>().value;
|
||||
}
|
||||
|
||||
void FillExtrusionLayer::setFillExtrusionTranslateAnchor(PropertyValue<TranslateAnchorType> value) {
|
||||
void FillExtrusionLayer::setFillExtrusionTranslateAnchor(const PropertyValue<TranslateAnchorType>& value) {
|
||||
if (value == getFillExtrusionTranslateAnchor())
|
||||
return;
|
||||
auto impl_ = mutableImpl();
|
||||
@@ -174,11 +174,11 @@ PropertyValue<std::string> FillExtrusionLayer::getDefaultFillExtrusionPattern()
|
||||
return { "" };
|
||||
}
|
||||
|
||||
PropertyValue<std::string> FillExtrusionLayer::getFillExtrusionPattern() const {
|
||||
const PropertyValue<std::string>& FillExtrusionLayer::getFillExtrusionPattern() const {
|
||||
return impl().paint.template get<FillExtrusionPattern>().value;
|
||||
}
|
||||
|
||||
void FillExtrusionLayer::setFillExtrusionPattern(PropertyValue<std::string> value) {
|
||||
void FillExtrusionLayer::setFillExtrusionPattern(const PropertyValue<std::string>& value) {
|
||||
if (value == getFillExtrusionPattern())
|
||||
return;
|
||||
auto impl_ = mutableImpl();
|
||||
@@ -201,11 +201,11 @@ PropertyValue<float> FillExtrusionLayer::getDefaultFillExtrusionHeight() {
|
||||
return { 0 };
|
||||
}
|
||||
|
||||
PropertyValue<float> FillExtrusionLayer::getFillExtrusionHeight() const {
|
||||
const PropertyValue<float>& FillExtrusionLayer::getFillExtrusionHeight() const {
|
||||
return impl().paint.template get<FillExtrusionHeight>().value;
|
||||
}
|
||||
|
||||
void FillExtrusionLayer::setFillExtrusionHeight(PropertyValue<float> value) {
|
||||
void FillExtrusionLayer::setFillExtrusionHeight(const PropertyValue<float>& value) {
|
||||
if (value == getFillExtrusionHeight())
|
||||
return;
|
||||
auto impl_ = mutableImpl();
|
||||
@@ -228,11 +228,11 @@ PropertyValue<float> FillExtrusionLayer::getDefaultFillExtrusionBase() {
|
||||
return { 0 };
|
||||
}
|
||||
|
||||
PropertyValue<float> FillExtrusionLayer::getFillExtrusionBase() const {
|
||||
const PropertyValue<float>& FillExtrusionLayer::getFillExtrusionBase() const {
|
||||
return impl().paint.template get<FillExtrusionBase>().value;
|
||||
}
|
||||
|
||||
void FillExtrusionLayer::setFillExtrusionBase(PropertyValue<float> value) {
|
||||
void FillExtrusionLayer::setFillExtrusionBase(const PropertyValue<float>& value) {
|
||||
if (value == getFillExtrusionBase())
|
||||
return;
|
||||
auto impl_ = mutableImpl();
|
||||
@@ -255,11 +255,11 @@ PropertyValue<bool> FillExtrusionLayer::getDefaultFillExtrusionVerticalGradient(
|
||||
return { true };
|
||||
}
|
||||
|
||||
PropertyValue<bool> FillExtrusionLayer::getFillExtrusionVerticalGradient() const {
|
||||
const PropertyValue<bool>& FillExtrusionLayer::getFillExtrusionVerticalGradient() const {
|
||||
return impl().paint.template get<FillExtrusionVerticalGradient>().value;
|
||||
}
|
||||
|
||||
void FillExtrusionLayer::setFillExtrusionVerticalGradient(PropertyValue<bool> value) {
|
||||
void FillExtrusionLayer::setFillExtrusionVerticalGradient(const PropertyValue<bool>& value) {
|
||||
if (value == getFillExtrusionVerticalGradient())
|
||||
return;
|
||||
auto impl_ = mutableImpl();
|
||||
@@ -324,7 +324,7 @@ optional<Error> FillExtrusionLayer::setPaintProperty(const std::string& name, co
|
||||
return Error { "layer doesn't support this property" };
|
||||
}
|
||||
|
||||
Property property = static_cast<Property>(it->second);
|
||||
auto property = static_cast<Property>(it->second);
|
||||
|
||||
|
||||
if (property == Property::FillExtrusionOpacity) {
|
||||
|
||||
@@ -66,11 +66,11 @@ PropertyValue<bool> FillLayer::getDefaultFillAntialias() {
|
||||
return { true };
|
||||
}
|
||||
|
||||
PropertyValue<bool> FillLayer::getFillAntialias() const {
|
||||
const PropertyValue<bool>& FillLayer::getFillAntialias() const {
|
||||
return impl().paint.template get<FillAntialias>().value;
|
||||
}
|
||||
|
||||
void FillLayer::setFillAntialias(PropertyValue<bool> value) {
|
||||
void FillLayer::setFillAntialias(const PropertyValue<bool>& value) {
|
||||
if (value == getFillAntialias())
|
||||
return;
|
||||
auto impl_ = mutableImpl();
|
||||
@@ -93,11 +93,11 @@ PropertyValue<float> FillLayer::getDefaultFillOpacity() {
|
||||
return { 1 };
|
||||
}
|
||||
|
||||
PropertyValue<float> FillLayer::getFillOpacity() const {
|
||||
const PropertyValue<float>& FillLayer::getFillOpacity() const {
|
||||
return impl().paint.template get<FillOpacity>().value;
|
||||
}
|
||||
|
||||
void FillLayer::setFillOpacity(PropertyValue<float> value) {
|
||||
void FillLayer::setFillOpacity(const PropertyValue<float>& value) {
|
||||
if (value == getFillOpacity())
|
||||
return;
|
||||
auto impl_ = mutableImpl();
|
||||
@@ -120,11 +120,11 @@ PropertyValue<Color> FillLayer::getDefaultFillColor() {
|
||||
return { Color::black() };
|
||||
}
|
||||
|
||||
PropertyValue<Color> FillLayer::getFillColor() const {
|
||||
const PropertyValue<Color>& FillLayer::getFillColor() const {
|
||||
return impl().paint.template get<FillColor>().value;
|
||||
}
|
||||
|
||||
void FillLayer::setFillColor(PropertyValue<Color> value) {
|
||||
void FillLayer::setFillColor(const PropertyValue<Color>& value) {
|
||||
if (value == getFillColor())
|
||||
return;
|
||||
auto impl_ = mutableImpl();
|
||||
@@ -147,11 +147,11 @@ PropertyValue<Color> FillLayer::getDefaultFillOutlineColor() {
|
||||
return { {} };
|
||||
}
|
||||
|
||||
PropertyValue<Color> FillLayer::getFillOutlineColor() const {
|
||||
const PropertyValue<Color>& FillLayer::getFillOutlineColor() const {
|
||||
return impl().paint.template get<FillOutlineColor>().value;
|
||||
}
|
||||
|
||||
void FillLayer::setFillOutlineColor(PropertyValue<Color> value) {
|
||||
void FillLayer::setFillOutlineColor(const PropertyValue<Color>& value) {
|
||||
if (value == getFillOutlineColor())
|
||||
return;
|
||||
auto impl_ = mutableImpl();
|
||||
@@ -174,11 +174,11 @@ PropertyValue<std::array<float, 2>> FillLayer::getDefaultFillTranslate() {
|
||||
return { {{ 0, 0 }} };
|
||||
}
|
||||
|
||||
PropertyValue<std::array<float, 2>> FillLayer::getFillTranslate() const {
|
||||
const PropertyValue<std::array<float, 2>>& FillLayer::getFillTranslate() const {
|
||||
return impl().paint.template get<FillTranslate>().value;
|
||||
}
|
||||
|
||||
void FillLayer::setFillTranslate(PropertyValue<std::array<float, 2>> value) {
|
||||
void FillLayer::setFillTranslate(const PropertyValue<std::array<float, 2>>& value) {
|
||||
if (value == getFillTranslate())
|
||||
return;
|
||||
auto impl_ = mutableImpl();
|
||||
@@ -201,11 +201,11 @@ PropertyValue<TranslateAnchorType> FillLayer::getDefaultFillTranslateAnchor() {
|
||||
return { TranslateAnchorType::Map };
|
||||
}
|
||||
|
||||
PropertyValue<TranslateAnchorType> FillLayer::getFillTranslateAnchor() const {
|
||||
const PropertyValue<TranslateAnchorType>& FillLayer::getFillTranslateAnchor() const {
|
||||
return impl().paint.template get<FillTranslateAnchor>().value;
|
||||
}
|
||||
|
||||
void FillLayer::setFillTranslateAnchor(PropertyValue<TranslateAnchorType> value) {
|
||||
void FillLayer::setFillTranslateAnchor(const PropertyValue<TranslateAnchorType>& value) {
|
||||
if (value == getFillTranslateAnchor())
|
||||
return;
|
||||
auto impl_ = mutableImpl();
|
||||
@@ -228,11 +228,11 @@ PropertyValue<std::string> FillLayer::getDefaultFillPattern() {
|
||||
return { "" };
|
||||
}
|
||||
|
||||
PropertyValue<std::string> FillLayer::getFillPattern() const {
|
||||
const PropertyValue<std::string>& FillLayer::getFillPattern() const {
|
||||
return impl().paint.template get<FillPattern>().value;
|
||||
}
|
||||
|
||||
void FillLayer::setFillPattern(PropertyValue<std::string> value) {
|
||||
void FillLayer::setFillPattern(const PropertyValue<std::string>& value) {
|
||||
if (value == getFillPattern())
|
||||
return;
|
||||
auto impl_ = mutableImpl();
|
||||
@@ -293,7 +293,7 @@ optional<Error> FillLayer::setPaintProperty(const std::string& name, const Conve
|
||||
return Error { "layer doesn't support this property" };
|
||||
}
|
||||
|
||||
Property property = static_cast<Property>(it->second);
|
||||
auto property = static_cast<Property>(it->second);
|
||||
|
||||
|
||||
if (property == Property::FillAntialias) {
|
||||
|
||||
@@ -66,11 +66,11 @@ PropertyValue<float> HeatmapLayer::getDefaultHeatmapRadius() {
|
||||
return { 30 };
|
||||
}
|
||||
|
||||
PropertyValue<float> HeatmapLayer::getHeatmapRadius() const {
|
||||
const PropertyValue<float>& HeatmapLayer::getHeatmapRadius() const {
|
||||
return impl().paint.template get<HeatmapRadius>().value;
|
||||
}
|
||||
|
||||
void HeatmapLayer::setHeatmapRadius(PropertyValue<float> value) {
|
||||
void HeatmapLayer::setHeatmapRadius(const PropertyValue<float>& value) {
|
||||
if (value == getHeatmapRadius())
|
||||
return;
|
||||
auto impl_ = mutableImpl();
|
||||
@@ -93,11 +93,11 @@ PropertyValue<float> HeatmapLayer::getDefaultHeatmapWeight() {
|
||||
return { 1 };
|
||||
}
|
||||
|
||||
PropertyValue<float> HeatmapLayer::getHeatmapWeight() const {
|
||||
const PropertyValue<float>& HeatmapLayer::getHeatmapWeight() const {
|
||||
return impl().paint.template get<HeatmapWeight>().value;
|
||||
}
|
||||
|
||||
void HeatmapLayer::setHeatmapWeight(PropertyValue<float> value) {
|
||||
void HeatmapLayer::setHeatmapWeight(const PropertyValue<float>& value) {
|
||||
if (value == getHeatmapWeight())
|
||||
return;
|
||||
auto impl_ = mutableImpl();
|
||||
@@ -120,11 +120,11 @@ PropertyValue<float> HeatmapLayer::getDefaultHeatmapIntensity() {
|
||||
return { 1 };
|
||||
}
|
||||
|
||||
PropertyValue<float> HeatmapLayer::getHeatmapIntensity() const {
|
||||
const PropertyValue<float>& HeatmapLayer::getHeatmapIntensity() const {
|
||||
return impl().paint.template get<HeatmapIntensity>().value;
|
||||
}
|
||||
|
||||
void HeatmapLayer::setHeatmapIntensity(PropertyValue<float> value) {
|
||||
void HeatmapLayer::setHeatmapIntensity(const PropertyValue<float>& value) {
|
||||
if (value == getHeatmapIntensity())
|
||||
return;
|
||||
auto impl_ = mutableImpl();
|
||||
@@ -149,11 +149,11 @@ ColorRampPropertyValue HeatmapLayer::getDefaultHeatmapColor() {
|
||||
return *conversion::convertJSON<ColorRampPropertyValue>(rawValue, error);
|
||||
}
|
||||
|
||||
ColorRampPropertyValue HeatmapLayer::getHeatmapColor() const {
|
||||
const ColorRampPropertyValue& HeatmapLayer::getHeatmapColor() const {
|
||||
return impl().paint.template get<HeatmapColor>().value;
|
||||
}
|
||||
|
||||
void HeatmapLayer::setHeatmapColor(ColorRampPropertyValue value) {
|
||||
void HeatmapLayer::setHeatmapColor(const ColorRampPropertyValue& value) {
|
||||
if (value == getHeatmapColor())
|
||||
return;
|
||||
auto impl_ = mutableImpl();
|
||||
@@ -176,11 +176,11 @@ PropertyValue<float> HeatmapLayer::getDefaultHeatmapOpacity() {
|
||||
return { 1 };
|
||||
}
|
||||
|
||||
PropertyValue<float> HeatmapLayer::getHeatmapOpacity() const {
|
||||
const PropertyValue<float>& HeatmapLayer::getHeatmapOpacity() const {
|
||||
return impl().paint.template get<HeatmapOpacity>().value;
|
||||
}
|
||||
|
||||
void HeatmapLayer::setHeatmapOpacity(PropertyValue<float> value) {
|
||||
void HeatmapLayer::setHeatmapOpacity(const PropertyValue<float>& value) {
|
||||
if (value == getHeatmapOpacity())
|
||||
return;
|
||||
auto impl_ = mutableImpl();
|
||||
@@ -233,7 +233,7 @@ optional<Error> HeatmapLayer::setPaintProperty(const std::string& name, const Co
|
||||
return Error { "layer doesn't support this property" };
|
||||
}
|
||||
|
||||
Property property = static_cast<Property>(it->second);
|
||||
auto property = static_cast<Property>(it->second);
|
||||
|
||||
|
||||
if (property == Property::HeatmapRadius || property == Property::HeatmapWeight) {
|
||||
|
||||
@@ -66,11 +66,11 @@ PropertyValue<float> HillshadeLayer::getDefaultHillshadeIlluminationDirection()
|
||||
return { 335 };
|
||||
}
|
||||
|
||||
PropertyValue<float> HillshadeLayer::getHillshadeIlluminationDirection() const {
|
||||
const PropertyValue<float>& HillshadeLayer::getHillshadeIlluminationDirection() const {
|
||||
return impl().paint.template get<HillshadeIlluminationDirection>().value;
|
||||
}
|
||||
|
||||
void HillshadeLayer::setHillshadeIlluminationDirection(PropertyValue<float> value) {
|
||||
void HillshadeLayer::setHillshadeIlluminationDirection(const PropertyValue<float>& value) {
|
||||
if (value == getHillshadeIlluminationDirection())
|
||||
return;
|
||||
auto impl_ = mutableImpl();
|
||||
@@ -93,11 +93,11 @@ PropertyValue<HillshadeIlluminationAnchorType> HillshadeLayer::getDefaultHillsha
|
||||
return { HillshadeIlluminationAnchorType::Viewport };
|
||||
}
|
||||
|
||||
PropertyValue<HillshadeIlluminationAnchorType> HillshadeLayer::getHillshadeIlluminationAnchor() const {
|
||||
const PropertyValue<HillshadeIlluminationAnchorType>& HillshadeLayer::getHillshadeIlluminationAnchor() const {
|
||||
return impl().paint.template get<HillshadeIlluminationAnchor>().value;
|
||||
}
|
||||
|
||||
void HillshadeLayer::setHillshadeIlluminationAnchor(PropertyValue<HillshadeIlluminationAnchorType> value) {
|
||||
void HillshadeLayer::setHillshadeIlluminationAnchor(const PropertyValue<HillshadeIlluminationAnchorType>& value) {
|
||||
if (value == getHillshadeIlluminationAnchor())
|
||||
return;
|
||||
auto impl_ = mutableImpl();
|
||||
@@ -120,11 +120,11 @@ PropertyValue<float> HillshadeLayer::getDefaultHillshadeExaggeration() {
|
||||
return { 0.5 };
|
||||
}
|
||||
|
||||
PropertyValue<float> HillshadeLayer::getHillshadeExaggeration() const {
|
||||
const PropertyValue<float>& HillshadeLayer::getHillshadeExaggeration() const {
|
||||
return impl().paint.template get<HillshadeExaggeration>().value;
|
||||
}
|
||||
|
||||
void HillshadeLayer::setHillshadeExaggeration(PropertyValue<float> value) {
|
||||
void HillshadeLayer::setHillshadeExaggeration(const PropertyValue<float>& value) {
|
||||
if (value == getHillshadeExaggeration())
|
||||
return;
|
||||
auto impl_ = mutableImpl();
|
||||
@@ -147,11 +147,11 @@ PropertyValue<Color> HillshadeLayer::getDefaultHillshadeShadowColor() {
|
||||
return { Color::black() };
|
||||
}
|
||||
|
||||
PropertyValue<Color> HillshadeLayer::getHillshadeShadowColor() const {
|
||||
const PropertyValue<Color>& HillshadeLayer::getHillshadeShadowColor() const {
|
||||
return impl().paint.template get<HillshadeShadowColor>().value;
|
||||
}
|
||||
|
||||
void HillshadeLayer::setHillshadeShadowColor(PropertyValue<Color> value) {
|
||||
void HillshadeLayer::setHillshadeShadowColor(const PropertyValue<Color>& value) {
|
||||
if (value == getHillshadeShadowColor())
|
||||
return;
|
||||
auto impl_ = mutableImpl();
|
||||
@@ -174,11 +174,11 @@ PropertyValue<Color> HillshadeLayer::getDefaultHillshadeHighlightColor() {
|
||||
return { Color::white() };
|
||||
}
|
||||
|
||||
PropertyValue<Color> HillshadeLayer::getHillshadeHighlightColor() const {
|
||||
const PropertyValue<Color>& HillshadeLayer::getHillshadeHighlightColor() const {
|
||||
return impl().paint.template get<HillshadeHighlightColor>().value;
|
||||
}
|
||||
|
||||
void HillshadeLayer::setHillshadeHighlightColor(PropertyValue<Color> value) {
|
||||
void HillshadeLayer::setHillshadeHighlightColor(const PropertyValue<Color>& value) {
|
||||
if (value == getHillshadeHighlightColor())
|
||||
return;
|
||||
auto impl_ = mutableImpl();
|
||||
@@ -201,11 +201,11 @@ PropertyValue<Color> HillshadeLayer::getDefaultHillshadeAccentColor() {
|
||||
return { Color::black() };
|
||||
}
|
||||
|
||||
PropertyValue<Color> HillshadeLayer::getHillshadeAccentColor() const {
|
||||
const PropertyValue<Color>& HillshadeLayer::getHillshadeAccentColor() const {
|
||||
return impl().paint.template get<HillshadeAccentColor>().value;
|
||||
}
|
||||
|
||||
void HillshadeLayer::setHillshadeAccentColor(PropertyValue<Color> value) {
|
||||
void HillshadeLayer::setHillshadeAccentColor(const PropertyValue<Color>& value) {
|
||||
if (value == getHillshadeAccentColor())
|
||||
return;
|
||||
auto impl_ = mutableImpl();
|
||||
@@ -262,7 +262,7 @@ optional<Error> HillshadeLayer::setPaintProperty(const std::string& name, const
|
||||
return Error { "layer doesn't support this property" };
|
||||
}
|
||||
|
||||
Property property = static_cast<Property>(it->second);
|
||||
auto property = static_cast<Property>(it->second);
|
||||
|
||||
|
||||
if (property == Property::HillshadeIlluminationDirection || property == Property::HillshadeExaggeration) {
|
||||
|
||||
@@ -118,11 +118,11 @@ void <%- camelize(type) %>Layer::Impl::stringifyLayout(rapidjson::Writer<rapidjs
|
||||
return <%- camelize(property.name) %>::defaultValue();
|
||||
}
|
||||
|
||||
<%- propertyValueType(property) %> <%- camelize(type) %>Layer::get<%- camelize(property.name) %>() const {
|
||||
const <%- propertyValueType(property) %>& <%- camelize(type) %>Layer::get<%- camelize(property.name) %>() const {
|
||||
return impl().layout.get<<%- camelize(property.name) %>>();
|
||||
}
|
||||
|
||||
void <%- camelize(type) %>Layer::set<%- camelize(property.name) %>(<%- propertyValueType(property) %> value) {
|
||||
void <%- camelize(type) %>Layer::set<%- camelize(property.name) %>(const <%- propertyValueType(property) %>& value) {
|
||||
if (value == get<%- camelize(property.name) %>())
|
||||
return;
|
||||
auto impl_ = mutableImpl();
|
||||
@@ -144,11 +144,11 @@ void <%- camelize(type) %>Layer::set<%- camelize(property.name) %>(<%- propertyV
|
||||
<% } -%>
|
||||
}
|
||||
|
||||
<%- propertyValueType(property) %> <%- camelize(type) %>Layer::get<%- camelize(property.name) %>() const {
|
||||
const <%- propertyValueType(property) %>& <%- camelize(type) %>Layer::get<%- camelize(property.name) %>() const {
|
||||
return impl().paint.template get<<%- camelize(property.name) %>>().value;
|
||||
}
|
||||
|
||||
void <%- camelize(type) %>Layer::set<%- camelize(property.name) %>(<%- propertyValueType(property) %> value) {
|
||||
void <%- camelize(type) %>Layer::set<%- camelize(property.name) %>(const <%- propertyValueType(property) %>& value) {
|
||||
if (value == get<%- camelize(property.name) %>())
|
||||
return;
|
||||
auto impl_ = mutableImpl();
|
||||
@@ -193,7 +193,7 @@ optional<Error> <%- camelize(type) %>Layer::setPaintProperty(const std::string&
|
||||
return Error { "layer doesn't support this property" };
|
||||
}
|
||||
|
||||
Property property = static_cast<Property>(it->second);
|
||||
auto property = static_cast<Property>(it->second);
|
||||
|
||||
<%
|
||||
const paintConversions = {};
|
||||
@@ -260,7 +260,7 @@ optional<Error> <%- camelize(type) %>Layer::setLayoutProperty(const std::string&
|
||||
return Error { "layer doesn't support this property" };
|
||||
}
|
||||
|
||||
Property property = static_cast<Property>(it->second);
|
||||
auto property = static_cast<Property>(it->second);
|
||||
|
||||
<%
|
||||
const layoutConversions = {};
|
||||
|
||||
@@ -64,11 +64,11 @@ PropertyValue<LineCapType> LineLayer::getDefaultLineCap() {
|
||||
return LineCap::defaultValue();
|
||||
}
|
||||
|
||||
PropertyValue<LineCapType> LineLayer::getLineCap() const {
|
||||
const PropertyValue<LineCapType>& LineLayer::getLineCap() const {
|
||||
return impl().layout.get<LineCap>();
|
||||
}
|
||||
|
||||
void LineLayer::setLineCap(PropertyValue<LineCapType> value) {
|
||||
void LineLayer::setLineCap(const PropertyValue<LineCapType>& value) {
|
||||
if (value == getLineCap())
|
||||
return;
|
||||
auto impl_ = mutableImpl();
|
||||
@@ -80,11 +80,11 @@ PropertyValue<LineJoinType> LineLayer::getDefaultLineJoin() {
|
||||
return LineJoin::defaultValue();
|
||||
}
|
||||
|
||||
PropertyValue<LineJoinType> LineLayer::getLineJoin() const {
|
||||
const PropertyValue<LineJoinType>& LineLayer::getLineJoin() const {
|
||||
return impl().layout.get<LineJoin>();
|
||||
}
|
||||
|
||||
void LineLayer::setLineJoin(PropertyValue<LineJoinType> value) {
|
||||
void LineLayer::setLineJoin(const PropertyValue<LineJoinType>& value) {
|
||||
if (value == getLineJoin())
|
||||
return;
|
||||
auto impl_ = mutableImpl();
|
||||
@@ -96,11 +96,11 @@ PropertyValue<float> LineLayer::getDefaultLineMiterLimit() {
|
||||
return LineMiterLimit::defaultValue();
|
||||
}
|
||||
|
||||
PropertyValue<float> LineLayer::getLineMiterLimit() const {
|
||||
const PropertyValue<float>& LineLayer::getLineMiterLimit() const {
|
||||
return impl().layout.get<LineMiterLimit>();
|
||||
}
|
||||
|
||||
void LineLayer::setLineMiterLimit(PropertyValue<float> value) {
|
||||
void LineLayer::setLineMiterLimit(const PropertyValue<float>& value) {
|
||||
if (value == getLineMiterLimit())
|
||||
return;
|
||||
auto impl_ = mutableImpl();
|
||||
@@ -112,11 +112,11 @@ PropertyValue<float> LineLayer::getDefaultLineRoundLimit() {
|
||||
return LineRoundLimit::defaultValue();
|
||||
}
|
||||
|
||||
PropertyValue<float> LineLayer::getLineRoundLimit() const {
|
||||
const PropertyValue<float>& LineLayer::getLineRoundLimit() const {
|
||||
return impl().layout.get<LineRoundLimit>();
|
||||
}
|
||||
|
||||
void LineLayer::setLineRoundLimit(PropertyValue<float> value) {
|
||||
void LineLayer::setLineRoundLimit(const PropertyValue<float>& value) {
|
||||
if (value == getLineRoundLimit())
|
||||
return;
|
||||
auto impl_ = mutableImpl();
|
||||
@@ -131,11 +131,11 @@ PropertyValue<float> LineLayer::getDefaultLineOpacity() {
|
||||
return { 1 };
|
||||
}
|
||||
|
||||
PropertyValue<float> LineLayer::getLineOpacity() const {
|
||||
const PropertyValue<float>& LineLayer::getLineOpacity() const {
|
||||
return impl().paint.template get<LineOpacity>().value;
|
||||
}
|
||||
|
||||
void LineLayer::setLineOpacity(PropertyValue<float> value) {
|
||||
void LineLayer::setLineOpacity(const PropertyValue<float>& value) {
|
||||
if (value == getLineOpacity())
|
||||
return;
|
||||
auto impl_ = mutableImpl();
|
||||
@@ -158,11 +158,11 @@ PropertyValue<Color> LineLayer::getDefaultLineColor() {
|
||||
return { Color::black() };
|
||||
}
|
||||
|
||||
PropertyValue<Color> LineLayer::getLineColor() const {
|
||||
const PropertyValue<Color>& LineLayer::getLineColor() const {
|
||||
return impl().paint.template get<LineColor>().value;
|
||||
}
|
||||
|
||||
void LineLayer::setLineColor(PropertyValue<Color> value) {
|
||||
void LineLayer::setLineColor(const PropertyValue<Color>& value) {
|
||||
if (value == getLineColor())
|
||||
return;
|
||||
auto impl_ = mutableImpl();
|
||||
@@ -185,11 +185,11 @@ PropertyValue<std::array<float, 2>> LineLayer::getDefaultLineTranslate() {
|
||||
return { {{ 0, 0 }} };
|
||||
}
|
||||
|
||||
PropertyValue<std::array<float, 2>> LineLayer::getLineTranslate() const {
|
||||
const PropertyValue<std::array<float, 2>>& LineLayer::getLineTranslate() const {
|
||||
return impl().paint.template get<LineTranslate>().value;
|
||||
}
|
||||
|
||||
void LineLayer::setLineTranslate(PropertyValue<std::array<float, 2>> value) {
|
||||
void LineLayer::setLineTranslate(const PropertyValue<std::array<float, 2>>& value) {
|
||||
if (value == getLineTranslate())
|
||||
return;
|
||||
auto impl_ = mutableImpl();
|
||||
@@ -212,11 +212,11 @@ PropertyValue<TranslateAnchorType> LineLayer::getDefaultLineTranslateAnchor() {
|
||||
return { TranslateAnchorType::Map };
|
||||
}
|
||||
|
||||
PropertyValue<TranslateAnchorType> LineLayer::getLineTranslateAnchor() const {
|
||||
const PropertyValue<TranslateAnchorType>& LineLayer::getLineTranslateAnchor() const {
|
||||
return impl().paint.template get<LineTranslateAnchor>().value;
|
||||
}
|
||||
|
||||
void LineLayer::setLineTranslateAnchor(PropertyValue<TranslateAnchorType> value) {
|
||||
void LineLayer::setLineTranslateAnchor(const PropertyValue<TranslateAnchorType>& value) {
|
||||
if (value == getLineTranslateAnchor())
|
||||
return;
|
||||
auto impl_ = mutableImpl();
|
||||
@@ -239,11 +239,11 @@ PropertyValue<float> LineLayer::getDefaultLineWidth() {
|
||||
return { 1 };
|
||||
}
|
||||
|
||||
PropertyValue<float> LineLayer::getLineWidth() const {
|
||||
const PropertyValue<float>& LineLayer::getLineWidth() const {
|
||||
return impl().paint.template get<LineWidth>().value;
|
||||
}
|
||||
|
||||
void LineLayer::setLineWidth(PropertyValue<float> value) {
|
||||
void LineLayer::setLineWidth(const PropertyValue<float>& value) {
|
||||
if (value == getLineWidth())
|
||||
return;
|
||||
auto impl_ = mutableImpl();
|
||||
@@ -267,11 +267,11 @@ PropertyValue<float> LineLayer::getDefaultLineGapWidth() {
|
||||
return { 0 };
|
||||
}
|
||||
|
||||
PropertyValue<float> LineLayer::getLineGapWidth() const {
|
||||
const PropertyValue<float>& LineLayer::getLineGapWidth() const {
|
||||
return impl().paint.template get<LineGapWidth>().value;
|
||||
}
|
||||
|
||||
void LineLayer::setLineGapWidth(PropertyValue<float> value) {
|
||||
void LineLayer::setLineGapWidth(const PropertyValue<float>& value) {
|
||||
if (value == getLineGapWidth())
|
||||
return;
|
||||
auto impl_ = mutableImpl();
|
||||
@@ -294,11 +294,11 @@ PropertyValue<float> LineLayer::getDefaultLineOffset() {
|
||||
return { 0 };
|
||||
}
|
||||
|
||||
PropertyValue<float> LineLayer::getLineOffset() const {
|
||||
const PropertyValue<float>& LineLayer::getLineOffset() const {
|
||||
return impl().paint.template get<LineOffset>().value;
|
||||
}
|
||||
|
||||
void LineLayer::setLineOffset(PropertyValue<float> value) {
|
||||
void LineLayer::setLineOffset(const PropertyValue<float>& value) {
|
||||
if (value == getLineOffset())
|
||||
return;
|
||||
auto impl_ = mutableImpl();
|
||||
@@ -321,11 +321,11 @@ PropertyValue<float> LineLayer::getDefaultLineBlur() {
|
||||
return { 0 };
|
||||
}
|
||||
|
||||
PropertyValue<float> LineLayer::getLineBlur() const {
|
||||
const PropertyValue<float>& LineLayer::getLineBlur() const {
|
||||
return impl().paint.template get<LineBlur>().value;
|
||||
}
|
||||
|
||||
void LineLayer::setLineBlur(PropertyValue<float> value) {
|
||||
void LineLayer::setLineBlur(const PropertyValue<float>& value) {
|
||||
if (value == getLineBlur())
|
||||
return;
|
||||
auto impl_ = mutableImpl();
|
||||
@@ -348,11 +348,11 @@ PropertyValue<std::vector<float>> LineLayer::getDefaultLineDasharray() {
|
||||
return { { } };
|
||||
}
|
||||
|
||||
PropertyValue<std::vector<float>> LineLayer::getLineDasharray() const {
|
||||
const PropertyValue<std::vector<float>>& LineLayer::getLineDasharray() const {
|
||||
return impl().paint.template get<LineDasharray>().value;
|
||||
}
|
||||
|
||||
void LineLayer::setLineDasharray(PropertyValue<std::vector<float>> value) {
|
||||
void LineLayer::setLineDasharray(const PropertyValue<std::vector<float>>& value) {
|
||||
if (value == getLineDasharray())
|
||||
return;
|
||||
auto impl_ = mutableImpl();
|
||||
@@ -375,11 +375,11 @@ PropertyValue<std::string> LineLayer::getDefaultLinePattern() {
|
||||
return { "" };
|
||||
}
|
||||
|
||||
PropertyValue<std::string> LineLayer::getLinePattern() const {
|
||||
const PropertyValue<std::string>& LineLayer::getLinePattern() const {
|
||||
return impl().paint.template get<LinePattern>().value;
|
||||
}
|
||||
|
||||
void LineLayer::setLinePattern(PropertyValue<std::string> value) {
|
||||
void LineLayer::setLinePattern(const PropertyValue<std::string>& value) {
|
||||
if (value == getLinePattern())
|
||||
return;
|
||||
auto impl_ = mutableImpl();
|
||||
@@ -402,11 +402,11 @@ ColorRampPropertyValue LineLayer::getDefaultLineGradient() {
|
||||
return { {} };
|
||||
}
|
||||
|
||||
ColorRampPropertyValue LineLayer::getLineGradient() const {
|
||||
const ColorRampPropertyValue& LineLayer::getLineGradient() const {
|
||||
return impl().paint.template get<LineGradient>().value;
|
||||
}
|
||||
|
||||
void LineLayer::setLineGradient(ColorRampPropertyValue value) {
|
||||
void LineLayer::setLineGradient(const ColorRampPropertyValue& value) {
|
||||
if (value == getLineGradient())
|
||||
return;
|
||||
auto impl_ = mutableImpl();
|
||||
@@ -483,7 +483,7 @@ optional<Error> LineLayer::setPaintProperty(const std::string& name, const Conve
|
||||
return Error { "layer doesn't support this property" };
|
||||
}
|
||||
|
||||
Property property = static_cast<Property>(it->second);
|
||||
auto property = static_cast<Property>(it->second);
|
||||
|
||||
|
||||
if (property == Property::LineOpacity || property == Property::LineWidth || property == Property::LineGapWidth || property == Property::LineOffset || property == Property::LineBlur) {
|
||||
@@ -680,7 +680,7 @@ optional<Error> LineLayer::setLayoutProperty(const std::string& name, const Conv
|
||||
return Error { "layer doesn't support this property" };
|
||||
}
|
||||
|
||||
Property property = static_cast<Property>(it->second);
|
||||
auto property = static_cast<Property>(it->second);
|
||||
|
||||
|
||||
if (property == Property::LineCap) {
|
||||
|
||||
@@ -66,11 +66,11 @@ PropertyValue<float> RasterLayer::getDefaultRasterOpacity() {
|
||||
return { 1 };
|
||||
}
|
||||
|
||||
PropertyValue<float> RasterLayer::getRasterOpacity() const {
|
||||
const PropertyValue<float>& RasterLayer::getRasterOpacity() const {
|
||||
return impl().paint.template get<RasterOpacity>().value;
|
||||
}
|
||||
|
||||
void RasterLayer::setRasterOpacity(PropertyValue<float> value) {
|
||||
void RasterLayer::setRasterOpacity(const PropertyValue<float>& value) {
|
||||
if (value == getRasterOpacity())
|
||||
return;
|
||||
auto impl_ = mutableImpl();
|
||||
@@ -93,11 +93,11 @@ PropertyValue<float> RasterLayer::getDefaultRasterHueRotate() {
|
||||
return { 0 };
|
||||
}
|
||||
|
||||
PropertyValue<float> RasterLayer::getRasterHueRotate() const {
|
||||
const PropertyValue<float>& RasterLayer::getRasterHueRotate() const {
|
||||
return impl().paint.template get<RasterHueRotate>().value;
|
||||
}
|
||||
|
||||
void RasterLayer::setRasterHueRotate(PropertyValue<float> value) {
|
||||
void RasterLayer::setRasterHueRotate(const PropertyValue<float>& value) {
|
||||
if (value == getRasterHueRotate())
|
||||
return;
|
||||
auto impl_ = mutableImpl();
|
||||
@@ -120,11 +120,11 @@ PropertyValue<float> RasterLayer::getDefaultRasterBrightnessMin() {
|
||||
return { 0 };
|
||||
}
|
||||
|
||||
PropertyValue<float> RasterLayer::getRasterBrightnessMin() const {
|
||||
const PropertyValue<float>& RasterLayer::getRasterBrightnessMin() const {
|
||||
return impl().paint.template get<RasterBrightnessMin>().value;
|
||||
}
|
||||
|
||||
void RasterLayer::setRasterBrightnessMin(PropertyValue<float> value) {
|
||||
void RasterLayer::setRasterBrightnessMin(const PropertyValue<float>& value) {
|
||||
if (value == getRasterBrightnessMin())
|
||||
return;
|
||||
auto impl_ = mutableImpl();
|
||||
@@ -147,11 +147,11 @@ PropertyValue<float> RasterLayer::getDefaultRasterBrightnessMax() {
|
||||
return { 1 };
|
||||
}
|
||||
|
||||
PropertyValue<float> RasterLayer::getRasterBrightnessMax() const {
|
||||
const PropertyValue<float>& RasterLayer::getRasterBrightnessMax() const {
|
||||
return impl().paint.template get<RasterBrightnessMax>().value;
|
||||
}
|
||||
|
||||
void RasterLayer::setRasterBrightnessMax(PropertyValue<float> value) {
|
||||
void RasterLayer::setRasterBrightnessMax(const PropertyValue<float>& value) {
|
||||
if (value == getRasterBrightnessMax())
|
||||
return;
|
||||
auto impl_ = mutableImpl();
|
||||
@@ -174,11 +174,11 @@ PropertyValue<float> RasterLayer::getDefaultRasterSaturation() {
|
||||
return { 0 };
|
||||
}
|
||||
|
||||
PropertyValue<float> RasterLayer::getRasterSaturation() const {
|
||||
const PropertyValue<float>& RasterLayer::getRasterSaturation() const {
|
||||
return impl().paint.template get<RasterSaturation>().value;
|
||||
}
|
||||
|
||||
void RasterLayer::setRasterSaturation(PropertyValue<float> value) {
|
||||
void RasterLayer::setRasterSaturation(const PropertyValue<float>& value) {
|
||||
if (value == getRasterSaturation())
|
||||
return;
|
||||
auto impl_ = mutableImpl();
|
||||
@@ -201,11 +201,11 @@ PropertyValue<float> RasterLayer::getDefaultRasterContrast() {
|
||||
return { 0 };
|
||||
}
|
||||
|
||||
PropertyValue<float> RasterLayer::getRasterContrast() const {
|
||||
const PropertyValue<float>& RasterLayer::getRasterContrast() const {
|
||||
return impl().paint.template get<RasterContrast>().value;
|
||||
}
|
||||
|
||||
void RasterLayer::setRasterContrast(PropertyValue<float> value) {
|
||||
void RasterLayer::setRasterContrast(const PropertyValue<float>& value) {
|
||||
if (value == getRasterContrast())
|
||||
return;
|
||||
auto impl_ = mutableImpl();
|
||||
@@ -228,11 +228,11 @@ PropertyValue<RasterResamplingType> RasterLayer::getDefaultRasterResampling() {
|
||||
return { RasterResamplingType::Linear };
|
||||
}
|
||||
|
||||
PropertyValue<RasterResamplingType> RasterLayer::getRasterResampling() const {
|
||||
const PropertyValue<RasterResamplingType>& RasterLayer::getRasterResampling() const {
|
||||
return impl().paint.template get<RasterResampling>().value;
|
||||
}
|
||||
|
||||
void RasterLayer::setRasterResampling(PropertyValue<RasterResamplingType> value) {
|
||||
void RasterLayer::setRasterResampling(const PropertyValue<RasterResamplingType>& value) {
|
||||
if (value == getRasterResampling())
|
||||
return;
|
||||
auto impl_ = mutableImpl();
|
||||
@@ -255,11 +255,11 @@ PropertyValue<float> RasterLayer::getDefaultRasterFadeDuration() {
|
||||
return { 300 };
|
||||
}
|
||||
|
||||
PropertyValue<float> RasterLayer::getRasterFadeDuration() const {
|
||||
const PropertyValue<float>& RasterLayer::getRasterFadeDuration() const {
|
||||
return impl().paint.template get<RasterFadeDuration>().value;
|
||||
}
|
||||
|
||||
void RasterLayer::setRasterFadeDuration(PropertyValue<float> value) {
|
||||
void RasterLayer::setRasterFadeDuration(const PropertyValue<float>& value) {
|
||||
if (value == getRasterFadeDuration())
|
||||
return;
|
||||
auto impl_ = mutableImpl();
|
||||
@@ -324,7 +324,7 @@ optional<Error> RasterLayer::setPaintProperty(const std::string& name, const Con
|
||||
return Error { "layer doesn't support this property" };
|
||||
}
|
||||
|
||||
Property property = static_cast<Property>(it->second);
|
||||
auto property = static_cast<Property>(it->second);
|
||||
|
||||
|
||||
if (property == Property::RasterOpacity || property == Property::RasterHueRotate || property == Property::RasterBrightnessMin || property == Property::RasterBrightnessMax || property == Property::RasterSaturation || property == Property::RasterContrast || property == Property::RasterFadeDuration) {
|
||||
|
||||
@@ -64,11 +64,11 @@ PropertyValue<SymbolPlacementType> SymbolLayer::getDefaultSymbolPlacement() {
|
||||
return SymbolPlacement::defaultValue();
|
||||
}
|
||||
|
||||
PropertyValue<SymbolPlacementType> SymbolLayer::getSymbolPlacement() const {
|
||||
const PropertyValue<SymbolPlacementType>& SymbolLayer::getSymbolPlacement() const {
|
||||
return impl().layout.get<SymbolPlacement>();
|
||||
}
|
||||
|
||||
void SymbolLayer::setSymbolPlacement(PropertyValue<SymbolPlacementType> value) {
|
||||
void SymbolLayer::setSymbolPlacement(const PropertyValue<SymbolPlacementType>& value) {
|
||||
if (value == getSymbolPlacement())
|
||||
return;
|
||||
auto impl_ = mutableImpl();
|
||||
@@ -80,11 +80,11 @@ PropertyValue<float> SymbolLayer::getDefaultSymbolSpacing() {
|
||||
return SymbolSpacing::defaultValue();
|
||||
}
|
||||
|
||||
PropertyValue<float> SymbolLayer::getSymbolSpacing() const {
|
||||
const PropertyValue<float>& SymbolLayer::getSymbolSpacing() const {
|
||||
return impl().layout.get<SymbolSpacing>();
|
||||
}
|
||||
|
||||
void SymbolLayer::setSymbolSpacing(PropertyValue<float> value) {
|
||||
void SymbolLayer::setSymbolSpacing(const PropertyValue<float>& value) {
|
||||
if (value == getSymbolSpacing())
|
||||
return;
|
||||
auto impl_ = mutableImpl();
|
||||
@@ -96,11 +96,11 @@ PropertyValue<bool> SymbolLayer::getDefaultSymbolAvoidEdges() {
|
||||
return SymbolAvoidEdges::defaultValue();
|
||||
}
|
||||
|
||||
PropertyValue<bool> SymbolLayer::getSymbolAvoidEdges() const {
|
||||
const PropertyValue<bool>& SymbolLayer::getSymbolAvoidEdges() const {
|
||||
return impl().layout.get<SymbolAvoidEdges>();
|
||||
}
|
||||
|
||||
void SymbolLayer::setSymbolAvoidEdges(PropertyValue<bool> value) {
|
||||
void SymbolLayer::setSymbolAvoidEdges(const PropertyValue<bool>& value) {
|
||||
if (value == getSymbolAvoidEdges())
|
||||
return;
|
||||
auto impl_ = mutableImpl();
|
||||
@@ -112,11 +112,11 @@ PropertyValue<SymbolZOrderType> SymbolLayer::getDefaultSymbolZOrder() {
|
||||
return SymbolZOrder::defaultValue();
|
||||
}
|
||||
|
||||
PropertyValue<SymbolZOrderType> SymbolLayer::getSymbolZOrder() const {
|
||||
const PropertyValue<SymbolZOrderType>& SymbolLayer::getSymbolZOrder() const {
|
||||
return impl().layout.get<SymbolZOrder>();
|
||||
}
|
||||
|
||||
void SymbolLayer::setSymbolZOrder(PropertyValue<SymbolZOrderType> value) {
|
||||
void SymbolLayer::setSymbolZOrder(const PropertyValue<SymbolZOrderType>& value) {
|
||||
if (value == getSymbolZOrder())
|
||||
return;
|
||||
auto impl_ = mutableImpl();
|
||||
@@ -128,11 +128,11 @@ PropertyValue<bool> SymbolLayer::getDefaultIconAllowOverlap() {
|
||||
return IconAllowOverlap::defaultValue();
|
||||
}
|
||||
|
||||
PropertyValue<bool> SymbolLayer::getIconAllowOverlap() const {
|
||||
const PropertyValue<bool>& SymbolLayer::getIconAllowOverlap() const {
|
||||
return impl().layout.get<IconAllowOverlap>();
|
||||
}
|
||||
|
||||
void SymbolLayer::setIconAllowOverlap(PropertyValue<bool> value) {
|
||||
void SymbolLayer::setIconAllowOverlap(const PropertyValue<bool>& value) {
|
||||
if (value == getIconAllowOverlap())
|
||||
return;
|
||||
auto impl_ = mutableImpl();
|
||||
@@ -144,11 +144,11 @@ PropertyValue<bool> SymbolLayer::getDefaultIconIgnorePlacement() {
|
||||
return IconIgnorePlacement::defaultValue();
|
||||
}
|
||||
|
||||
PropertyValue<bool> SymbolLayer::getIconIgnorePlacement() const {
|
||||
const PropertyValue<bool>& SymbolLayer::getIconIgnorePlacement() const {
|
||||
return impl().layout.get<IconIgnorePlacement>();
|
||||
}
|
||||
|
||||
void SymbolLayer::setIconIgnorePlacement(PropertyValue<bool> value) {
|
||||
void SymbolLayer::setIconIgnorePlacement(const PropertyValue<bool>& value) {
|
||||
if (value == getIconIgnorePlacement())
|
||||
return;
|
||||
auto impl_ = mutableImpl();
|
||||
@@ -160,11 +160,11 @@ PropertyValue<bool> SymbolLayer::getDefaultIconOptional() {
|
||||
return IconOptional::defaultValue();
|
||||
}
|
||||
|
||||
PropertyValue<bool> SymbolLayer::getIconOptional() const {
|
||||
const PropertyValue<bool>& SymbolLayer::getIconOptional() const {
|
||||
return impl().layout.get<IconOptional>();
|
||||
}
|
||||
|
||||
void SymbolLayer::setIconOptional(PropertyValue<bool> value) {
|
||||
void SymbolLayer::setIconOptional(const PropertyValue<bool>& value) {
|
||||
if (value == getIconOptional())
|
||||
return;
|
||||
auto impl_ = mutableImpl();
|
||||
@@ -176,11 +176,11 @@ PropertyValue<AlignmentType> SymbolLayer::getDefaultIconRotationAlignment() {
|
||||
return IconRotationAlignment::defaultValue();
|
||||
}
|
||||
|
||||
PropertyValue<AlignmentType> SymbolLayer::getIconRotationAlignment() const {
|
||||
const PropertyValue<AlignmentType>& SymbolLayer::getIconRotationAlignment() const {
|
||||
return impl().layout.get<IconRotationAlignment>();
|
||||
}
|
||||
|
||||
void SymbolLayer::setIconRotationAlignment(PropertyValue<AlignmentType> value) {
|
||||
void SymbolLayer::setIconRotationAlignment(const PropertyValue<AlignmentType>& value) {
|
||||
if (value == getIconRotationAlignment())
|
||||
return;
|
||||
auto impl_ = mutableImpl();
|
||||
@@ -192,11 +192,11 @@ PropertyValue<float> SymbolLayer::getDefaultIconSize() {
|
||||
return IconSize::defaultValue();
|
||||
}
|
||||
|
||||
PropertyValue<float> SymbolLayer::getIconSize() const {
|
||||
const PropertyValue<float>& SymbolLayer::getIconSize() const {
|
||||
return impl().layout.get<IconSize>();
|
||||
}
|
||||
|
||||
void SymbolLayer::setIconSize(PropertyValue<float> value) {
|
||||
void SymbolLayer::setIconSize(const PropertyValue<float>& value) {
|
||||
if (value == getIconSize())
|
||||
return;
|
||||
auto impl_ = mutableImpl();
|
||||
@@ -208,11 +208,11 @@ PropertyValue<IconTextFitType> SymbolLayer::getDefaultIconTextFit() {
|
||||
return IconTextFit::defaultValue();
|
||||
}
|
||||
|
||||
PropertyValue<IconTextFitType> SymbolLayer::getIconTextFit() const {
|
||||
const PropertyValue<IconTextFitType>& SymbolLayer::getIconTextFit() const {
|
||||
return impl().layout.get<IconTextFit>();
|
||||
}
|
||||
|
||||
void SymbolLayer::setIconTextFit(PropertyValue<IconTextFitType> value) {
|
||||
void SymbolLayer::setIconTextFit(const PropertyValue<IconTextFitType>& value) {
|
||||
if (value == getIconTextFit())
|
||||
return;
|
||||
auto impl_ = mutableImpl();
|
||||
@@ -224,11 +224,11 @@ PropertyValue<std::array<float, 4>> SymbolLayer::getDefaultIconTextFitPadding()
|
||||
return IconTextFitPadding::defaultValue();
|
||||
}
|
||||
|
||||
PropertyValue<std::array<float, 4>> SymbolLayer::getIconTextFitPadding() const {
|
||||
const PropertyValue<std::array<float, 4>>& SymbolLayer::getIconTextFitPadding() const {
|
||||
return impl().layout.get<IconTextFitPadding>();
|
||||
}
|
||||
|
||||
void SymbolLayer::setIconTextFitPadding(PropertyValue<std::array<float, 4>> value) {
|
||||
void SymbolLayer::setIconTextFitPadding(const PropertyValue<std::array<float, 4>>& value) {
|
||||
if (value == getIconTextFitPadding())
|
||||
return;
|
||||
auto impl_ = mutableImpl();
|
||||
@@ -240,11 +240,11 @@ PropertyValue<std::string> SymbolLayer::getDefaultIconImage() {
|
||||
return IconImage::defaultValue();
|
||||
}
|
||||
|
||||
PropertyValue<std::string> SymbolLayer::getIconImage() const {
|
||||
const PropertyValue<std::string>& SymbolLayer::getIconImage() const {
|
||||
return impl().layout.get<IconImage>();
|
||||
}
|
||||
|
||||
void SymbolLayer::setIconImage(PropertyValue<std::string> value) {
|
||||
void SymbolLayer::setIconImage(const PropertyValue<std::string>& value) {
|
||||
if (value == getIconImage())
|
||||
return;
|
||||
auto impl_ = mutableImpl();
|
||||
@@ -256,11 +256,11 @@ PropertyValue<float> SymbolLayer::getDefaultIconRotate() {
|
||||
return IconRotate::defaultValue();
|
||||
}
|
||||
|
||||
PropertyValue<float> SymbolLayer::getIconRotate() const {
|
||||
const PropertyValue<float>& SymbolLayer::getIconRotate() const {
|
||||
return impl().layout.get<IconRotate>();
|
||||
}
|
||||
|
||||
void SymbolLayer::setIconRotate(PropertyValue<float> value) {
|
||||
void SymbolLayer::setIconRotate(const PropertyValue<float>& value) {
|
||||
if (value == getIconRotate())
|
||||
return;
|
||||
auto impl_ = mutableImpl();
|
||||
@@ -272,11 +272,11 @@ PropertyValue<float> SymbolLayer::getDefaultIconPadding() {
|
||||
return IconPadding::defaultValue();
|
||||
}
|
||||
|
||||
PropertyValue<float> SymbolLayer::getIconPadding() const {
|
||||
const PropertyValue<float>& SymbolLayer::getIconPadding() const {
|
||||
return impl().layout.get<IconPadding>();
|
||||
}
|
||||
|
||||
void SymbolLayer::setIconPadding(PropertyValue<float> value) {
|
||||
void SymbolLayer::setIconPadding(const PropertyValue<float>& value) {
|
||||
if (value == getIconPadding())
|
||||
return;
|
||||
auto impl_ = mutableImpl();
|
||||
@@ -288,11 +288,11 @@ PropertyValue<bool> SymbolLayer::getDefaultIconKeepUpright() {
|
||||
return IconKeepUpright::defaultValue();
|
||||
}
|
||||
|
||||
PropertyValue<bool> SymbolLayer::getIconKeepUpright() const {
|
||||
const PropertyValue<bool>& SymbolLayer::getIconKeepUpright() const {
|
||||
return impl().layout.get<IconKeepUpright>();
|
||||
}
|
||||
|
||||
void SymbolLayer::setIconKeepUpright(PropertyValue<bool> value) {
|
||||
void SymbolLayer::setIconKeepUpright(const PropertyValue<bool>& value) {
|
||||
if (value == getIconKeepUpright())
|
||||
return;
|
||||
auto impl_ = mutableImpl();
|
||||
@@ -304,11 +304,11 @@ PropertyValue<std::array<float, 2>> SymbolLayer::getDefaultIconOffset() {
|
||||
return IconOffset::defaultValue();
|
||||
}
|
||||
|
||||
PropertyValue<std::array<float, 2>> SymbolLayer::getIconOffset() const {
|
||||
const PropertyValue<std::array<float, 2>>& SymbolLayer::getIconOffset() const {
|
||||
return impl().layout.get<IconOffset>();
|
||||
}
|
||||
|
||||
void SymbolLayer::setIconOffset(PropertyValue<std::array<float, 2>> value) {
|
||||
void SymbolLayer::setIconOffset(const PropertyValue<std::array<float, 2>>& value) {
|
||||
if (value == getIconOffset())
|
||||
return;
|
||||
auto impl_ = mutableImpl();
|
||||
@@ -320,11 +320,11 @@ PropertyValue<SymbolAnchorType> SymbolLayer::getDefaultIconAnchor() {
|
||||
return IconAnchor::defaultValue();
|
||||
}
|
||||
|
||||
PropertyValue<SymbolAnchorType> SymbolLayer::getIconAnchor() const {
|
||||
const PropertyValue<SymbolAnchorType>& SymbolLayer::getIconAnchor() const {
|
||||
return impl().layout.get<IconAnchor>();
|
||||
}
|
||||
|
||||
void SymbolLayer::setIconAnchor(PropertyValue<SymbolAnchorType> value) {
|
||||
void SymbolLayer::setIconAnchor(const PropertyValue<SymbolAnchorType>& value) {
|
||||
if (value == getIconAnchor())
|
||||
return;
|
||||
auto impl_ = mutableImpl();
|
||||
@@ -336,11 +336,11 @@ PropertyValue<AlignmentType> SymbolLayer::getDefaultIconPitchAlignment() {
|
||||
return IconPitchAlignment::defaultValue();
|
||||
}
|
||||
|
||||
PropertyValue<AlignmentType> SymbolLayer::getIconPitchAlignment() const {
|
||||
const PropertyValue<AlignmentType>& SymbolLayer::getIconPitchAlignment() const {
|
||||
return impl().layout.get<IconPitchAlignment>();
|
||||
}
|
||||
|
||||
void SymbolLayer::setIconPitchAlignment(PropertyValue<AlignmentType> value) {
|
||||
void SymbolLayer::setIconPitchAlignment(const PropertyValue<AlignmentType>& value) {
|
||||
if (value == getIconPitchAlignment())
|
||||
return;
|
||||
auto impl_ = mutableImpl();
|
||||
@@ -352,11 +352,11 @@ PropertyValue<AlignmentType> SymbolLayer::getDefaultTextPitchAlignment() {
|
||||
return TextPitchAlignment::defaultValue();
|
||||
}
|
||||
|
||||
PropertyValue<AlignmentType> SymbolLayer::getTextPitchAlignment() const {
|
||||
const PropertyValue<AlignmentType>& SymbolLayer::getTextPitchAlignment() const {
|
||||
return impl().layout.get<TextPitchAlignment>();
|
||||
}
|
||||
|
||||
void SymbolLayer::setTextPitchAlignment(PropertyValue<AlignmentType> value) {
|
||||
void SymbolLayer::setTextPitchAlignment(const PropertyValue<AlignmentType>& value) {
|
||||
if (value == getTextPitchAlignment())
|
||||
return;
|
||||
auto impl_ = mutableImpl();
|
||||
@@ -368,11 +368,11 @@ PropertyValue<AlignmentType> SymbolLayer::getDefaultTextRotationAlignment() {
|
||||
return TextRotationAlignment::defaultValue();
|
||||
}
|
||||
|
||||
PropertyValue<AlignmentType> SymbolLayer::getTextRotationAlignment() const {
|
||||
const PropertyValue<AlignmentType>& SymbolLayer::getTextRotationAlignment() const {
|
||||
return impl().layout.get<TextRotationAlignment>();
|
||||
}
|
||||
|
||||
void SymbolLayer::setTextRotationAlignment(PropertyValue<AlignmentType> value) {
|
||||
void SymbolLayer::setTextRotationAlignment(const PropertyValue<AlignmentType>& value) {
|
||||
if (value == getTextRotationAlignment())
|
||||
return;
|
||||
auto impl_ = mutableImpl();
|
||||
@@ -384,11 +384,11 @@ PropertyValue<expression::Formatted> SymbolLayer::getDefaultTextField() {
|
||||
return TextField::defaultValue();
|
||||
}
|
||||
|
||||
PropertyValue<expression::Formatted> SymbolLayer::getTextField() const {
|
||||
const PropertyValue<expression::Formatted>& SymbolLayer::getTextField() const {
|
||||
return impl().layout.get<TextField>();
|
||||
}
|
||||
|
||||
void SymbolLayer::setTextField(PropertyValue<expression::Formatted> value) {
|
||||
void SymbolLayer::setTextField(const PropertyValue<expression::Formatted>& value) {
|
||||
if (value == getTextField())
|
||||
return;
|
||||
auto impl_ = mutableImpl();
|
||||
@@ -400,11 +400,11 @@ PropertyValue<std::vector<std::string>> SymbolLayer::getDefaultTextFont() {
|
||||
return TextFont::defaultValue();
|
||||
}
|
||||
|
||||
PropertyValue<std::vector<std::string>> SymbolLayer::getTextFont() const {
|
||||
const PropertyValue<std::vector<std::string>>& SymbolLayer::getTextFont() const {
|
||||
return impl().layout.get<TextFont>();
|
||||
}
|
||||
|
||||
void SymbolLayer::setTextFont(PropertyValue<std::vector<std::string>> value) {
|
||||
void SymbolLayer::setTextFont(const PropertyValue<std::vector<std::string>>& value) {
|
||||
if (value == getTextFont())
|
||||
return;
|
||||
auto impl_ = mutableImpl();
|
||||
@@ -416,11 +416,11 @@ PropertyValue<float> SymbolLayer::getDefaultTextSize() {
|
||||
return TextSize::defaultValue();
|
||||
}
|
||||
|
||||
PropertyValue<float> SymbolLayer::getTextSize() const {
|
||||
const PropertyValue<float>& SymbolLayer::getTextSize() const {
|
||||
return impl().layout.get<TextSize>();
|
||||
}
|
||||
|
||||
void SymbolLayer::setTextSize(PropertyValue<float> value) {
|
||||
void SymbolLayer::setTextSize(const PropertyValue<float>& value) {
|
||||
if (value == getTextSize())
|
||||
return;
|
||||
auto impl_ = mutableImpl();
|
||||
@@ -432,11 +432,11 @@ PropertyValue<float> SymbolLayer::getDefaultTextMaxWidth() {
|
||||
return TextMaxWidth::defaultValue();
|
||||
}
|
||||
|
||||
PropertyValue<float> SymbolLayer::getTextMaxWidth() const {
|
||||
const PropertyValue<float>& SymbolLayer::getTextMaxWidth() const {
|
||||
return impl().layout.get<TextMaxWidth>();
|
||||
}
|
||||
|
||||
void SymbolLayer::setTextMaxWidth(PropertyValue<float> value) {
|
||||
void SymbolLayer::setTextMaxWidth(const PropertyValue<float>& value) {
|
||||
if (value == getTextMaxWidth())
|
||||
return;
|
||||
auto impl_ = mutableImpl();
|
||||
@@ -448,11 +448,11 @@ PropertyValue<float> SymbolLayer::getDefaultTextLineHeight() {
|
||||
return TextLineHeight::defaultValue();
|
||||
}
|
||||
|
||||
PropertyValue<float> SymbolLayer::getTextLineHeight() const {
|
||||
const PropertyValue<float>& SymbolLayer::getTextLineHeight() const {
|
||||
return impl().layout.get<TextLineHeight>();
|
||||
}
|
||||
|
||||
void SymbolLayer::setTextLineHeight(PropertyValue<float> value) {
|
||||
void SymbolLayer::setTextLineHeight(const PropertyValue<float>& value) {
|
||||
if (value == getTextLineHeight())
|
||||
return;
|
||||
auto impl_ = mutableImpl();
|
||||
@@ -464,11 +464,11 @@ PropertyValue<float> SymbolLayer::getDefaultTextLetterSpacing() {
|
||||
return TextLetterSpacing::defaultValue();
|
||||
}
|
||||
|
||||
PropertyValue<float> SymbolLayer::getTextLetterSpacing() const {
|
||||
const PropertyValue<float>& SymbolLayer::getTextLetterSpacing() const {
|
||||
return impl().layout.get<TextLetterSpacing>();
|
||||
}
|
||||
|
||||
void SymbolLayer::setTextLetterSpacing(PropertyValue<float> value) {
|
||||
void SymbolLayer::setTextLetterSpacing(const PropertyValue<float>& value) {
|
||||
if (value == getTextLetterSpacing())
|
||||
return;
|
||||
auto impl_ = mutableImpl();
|
||||
@@ -480,11 +480,11 @@ PropertyValue<TextJustifyType> SymbolLayer::getDefaultTextJustify() {
|
||||
return TextJustify::defaultValue();
|
||||
}
|
||||
|
||||
PropertyValue<TextJustifyType> SymbolLayer::getTextJustify() const {
|
||||
const PropertyValue<TextJustifyType>& SymbolLayer::getTextJustify() const {
|
||||
return impl().layout.get<TextJustify>();
|
||||
}
|
||||
|
||||
void SymbolLayer::setTextJustify(PropertyValue<TextJustifyType> value) {
|
||||
void SymbolLayer::setTextJustify(const PropertyValue<TextJustifyType>& value) {
|
||||
if (value == getTextJustify())
|
||||
return;
|
||||
auto impl_ = mutableImpl();
|
||||
@@ -496,11 +496,11 @@ PropertyValue<float> SymbolLayer::getDefaultTextRadialOffset() {
|
||||
return TextRadialOffset::defaultValue();
|
||||
}
|
||||
|
||||
PropertyValue<float> SymbolLayer::getTextRadialOffset() const {
|
||||
const PropertyValue<float>& SymbolLayer::getTextRadialOffset() const {
|
||||
return impl().layout.get<TextRadialOffset>();
|
||||
}
|
||||
|
||||
void SymbolLayer::setTextRadialOffset(PropertyValue<float> value) {
|
||||
void SymbolLayer::setTextRadialOffset(const PropertyValue<float>& value) {
|
||||
if (value == getTextRadialOffset())
|
||||
return;
|
||||
auto impl_ = mutableImpl();
|
||||
@@ -512,11 +512,11 @@ PropertyValue<std::vector<TextVariableAnchorType>> SymbolLayer::getDefaultTextVa
|
||||
return TextVariableAnchor::defaultValue();
|
||||
}
|
||||
|
||||
PropertyValue<std::vector<TextVariableAnchorType>> SymbolLayer::getTextVariableAnchor() const {
|
||||
const PropertyValue<std::vector<TextVariableAnchorType>>& SymbolLayer::getTextVariableAnchor() const {
|
||||
return impl().layout.get<TextVariableAnchor>();
|
||||
}
|
||||
|
||||
void SymbolLayer::setTextVariableAnchor(PropertyValue<std::vector<TextVariableAnchorType>> value) {
|
||||
void SymbolLayer::setTextVariableAnchor(const PropertyValue<std::vector<TextVariableAnchorType>>& value) {
|
||||
if (value == getTextVariableAnchor())
|
||||
return;
|
||||
auto impl_ = mutableImpl();
|
||||
@@ -528,11 +528,11 @@ PropertyValue<SymbolAnchorType> SymbolLayer::getDefaultTextAnchor() {
|
||||
return TextAnchor::defaultValue();
|
||||
}
|
||||
|
||||
PropertyValue<SymbolAnchorType> SymbolLayer::getTextAnchor() const {
|
||||
const PropertyValue<SymbolAnchorType>& SymbolLayer::getTextAnchor() const {
|
||||
return impl().layout.get<TextAnchor>();
|
||||
}
|
||||
|
||||
void SymbolLayer::setTextAnchor(PropertyValue<SymbolAnchorType> value) {
|
||||
void SymbolLayer::setTextAnchor(const PropertyValue<SymbolAnchorType>& value) {
|
||||
if (value == getTextAnchor())
|
||||
return;
|
||||
auto impl_ = mutableImpl();
|
||||
@@ -544,11 +544,11 @@ PropertyValue<float> SymbolLayer::getDefaultTextMaxAngle() {
|
||||
return TextMaxAngle::defaultValue();
|
||||
}
|
||||
|
||||
PropertyValue<float> SymbolLayer::getTextMaxAngle() const {
|
||||
const PropertyValue<float>& SymbolLayer::getTextMaxAngle() const {
|
||||
return impl().layout.get<TextMaxAngle>();
|
||||
}
|
||||
|
||||
void SymbolLayer::setTextMaxAngle(PropertyValue<float> value) {
|
||||
void SymbolLayer::setTextMaxAngle(const PropertyValue<float>& value) {
|
||||
if (value == getTextMaxAngle())
|
||||
return;
|
||||
auto impl_ = mutableImpl();
|
||||
@@ -560,11 +560,11 @@ PropertyValue<float> SymbolLayer::getDefaultTextRotate() {
|
||||
return TextRotate::defaultValue();
|
||||
}
|
||||
|
||||
PropertyValue<float> SymbolLayer::getTextRotate() const {
|
||||
const PropertyValue<float>& SymbolLayer::getTextRotate() const {
|
||||
return impl().layout.get<TextRotate>();
|
||||
}
|
||||
|
||||
void SymbolLayer::setTextRotate(PropertyValue<float> value) {
|
||||
void SymbolLayer::setTextRotate(const PropertyValue<float>& value) {
|
||||
if (value == getTextRotate())
|
||||
return;
|
||||
auto impl_ = mutableImpl();
|
||||
@@ -576,11 +576,11 @@ PropertyValue<float> SymbolLayer::getDefaultTextPadding() {
|
||||
return TextPadding::defaultValue();
|
||||
}
|
||||
|
||||
PropertyValue<float> SymbolLayer::getTextPadding() const {
|
||||
const PropertyValue<float>& SymbolLayer::getTextPadding() const {
|
||||
return impl().layout.get<TextPadding>();
|
||||
}
|
||||
|
||||
void SymbolLayer::setTextPadding(PropertyValue<float> value) {
|
||||
void SymbolLayer::setTextPadding(const PropertyValue<float>& value) {
|
||||
if (value == getTextPadding())
|
||||
return;
|
||||
auto impl_ = mutableImpl();
|
||||
@@ -592,11 +592,11 @@ PropertyValue<bool> SymbolLayer::getDefaultTextKeepUpright() {
|
||||
return TextKeepUpright::defaultValue();
|
||||
}
|
||||
|
||||
PropertyValue<bool> SymbolLayer::getTextKeepUpright() const {
|
||||
const PropertyValue<bool>& SymbolLayer::getTextKeepUpright() const {
|
||||
return impl().layout.get<TextKeepUpright>();
|
||||
}
|
||||
|
||||
void SymbolLayer::setTextKeepUpright(PropertyValue<bool> value) {
|
||||
void SymbolLayer::setTextKeepUpright(const PropertyValue<bool>& value) {
|
||||
if (value == getTextKeepUpright())
|
||||
return;
|
||||
auto impl_ = mutableImpl();
|
||||
@@ -608,11 +608,11 @@ PropertyValue<TextTransformType> SymbolLayer::getDefaultTextTransform() {
|
||||
return TextTransform::defaultValue();
|
||||
}
|
||||
|
||||
PropertyValue<TextTransformType> SymbolLayer::getTextTransform() const {
|
||||
const PropertyValue<TextTransformType>& SymbolLayer::getTextTransform() const {
|
||||
return impl().layout.get<TextTransform>();
|
||||
}
|
||||
|
||||
void SymbolLayer::setTextTransform(PropertyValue<TextTransformType> value) {
|
||||
void SymbolLayer::setTextTransform(const PropertyValue<TextTransformType>& value) {
|
||||
if (value == getTextTransform())
|
||||
return;
|
||||
auto impl_ = mutableImpl();
|
||||
@@ -624,11 +624,11 @@ PropertyValue<std::array<float, 2>> SymbolLayer::getDefaultTextOffset() {
|
||||
return TextOffset::defaultValue();
|
||||
}
|
||||
|
||||
PropertyValue<std::array<float, 2>> SymbolLayer::getTextOffset() const {
|
||||
const PropertyValue<std::array<float, 2>>& SymbolLayer::getTextOffset() const {
|
||||
return impl().layout.get<TextOffset>();
|
||||
}
|
||||
|
||||
void SymbolLayer::setTextOffset(PropertyValue<std::array<float, 2>> value) {
|
||||
void SymbolLayer::setTextOffset(const PropertyValue<std::array<float, 2>>& value) {
|
||||
if (value == getTextOffset())
|
||||
return;
|
||||
auto impl_ = mutableImpl();
|
||||
@@ -640,11 +640,11 @@ PropertyValue<bool> SymbolLayer::getDefaultTextAllowOverlap() {
|
||||
return TextAllowOverlap::defaultValue();
|
||||
}
|
||||
|
||||
PropertyValue<bool> SymbolLayer::getTextAllowOverlap() const {
|
||||
const PropertyValue<bool>& SymbolLayer::getTextAllowOverlap() const {
|
||||
return impl().layout.get<TextAllowOverlap>();
|
||||
}
|
||||
|
||||
void SymbolLayer::setTextAllowOverlap(PropertyValue<bool> value) {
|
||||
void SymbolLayer::setTextAllowOverlap(const PropertyValue<bool>& value) {
|
||||
if (value == getTextAllowOverlap())
|
||||
return;
|
||||
auto impl_ = mutableImpl();
|
||||
@@ -656,11 +656,11 @@ PropertyValue<bool> SymbolLayer::getDefaultTextIgnorePlacement() {
|
||||
return TextIgnorePlacement::defaultValue();
|
||||
}
|
||||
|
||||
PropertyValue<bool> SymbolLayer::getTextIgnorePlacement() const {
|
||||
const PropertyValue<bool>& SymbolLayer::getTextIgnorePlacement() const {
|
||||
return impl().layout.get<TextIgnorePlacement>();
|
||||
}
|
||||
|
||||
void SymbolLayer::setTextIgnorePlacement(PropertyValue<bool> value) {
|
||||
void SymbolLayer::setTextIgnorePlacement(const PropertyValue<bool>& value) {
|
||||
if (value == getTextIgnorePlacement())
|
||||
return;
|
||||
auto impl_ = mutableImpl();
|
||||
@@ -672,11 +672,11 @@ PropertyValue<bool> SymbolLayer::getDefaultTextOptional() {
|
||||
return TextOptional::defaultValue();
|
||||
}
|
||||
|
||||
PropertyValue<bool> SymbolLayer::getTextOptional() const {
|
||||
const PropertyValue<bool>& SymbolLayer::getTextOptional() const {
|
||||
return impl().layout.get<TextOptional>();
|
||||
}
|
||||
|
||||
void SymbolLayer::setTextOptional(PropertyValue<bool> value) {
|
||||
void SymbolLayer::setTextOptional(const PropertyValue<bool>& value) {
|
||||
if (value == getTextOptional())
|
||||
return;
|
||||
auto impl_ = mutableImpl();
|
||||
@@ -691,11 +691,11 @@ PropertyValue<float> SymbolLayer::getDefaultIconOpacity() {
|
||||
return { 1 };
|
||||
}
|
||||
|
||||
PropertyValue<float> SymbolLayer::getIconOpacity() const {
|
||||
const PropertyValue<float>& SymbolLayer::getIconOpacity() const {
|
||||
return impl().paint.template get<IconOpacity>().value;
|
||||
}
|
||||
|
||||
void SymbolLayer::setIconOpacity(PropertyValue<float> value) {
|
||||
void SymbolLayer::setIconOpacity(const PropertyValue<float>& value) {
|
||||
if (value == getIconOpacity())
|
||||
return;
|
||||
auto impl_ = mutableImpl();
|
||||
@@ -718,11 +718,11 @@ PropertyValue<Color> SymbolLayer::getDefaultIconColor() {
|
||||
return { Color::black() };
|
||||
}
|
||||
|
||||
PropertyValue<Color> SymbolLayer::getIconColor() const {
|
||||
const PropertyValue<Color>& SymbolLayer::getIconColor() const {
|
||||
return impl().paint.template get<IconColor>().value;
|
||||
}
|
||||
|
||||
void SymbolLayer::setIconColor(PropertyValue<Color> value) {
|
||||
void SymbolLayer::setIconColor(const PropertyValue<Color>& value) {
|
||||
if (value == getIconColor())
|
||||
return;
|
||||
auto impl_ = mutableImpl();
|
||||
@@ -745,11 +745,11 @@ PropertyValue<Color> SymbolLayer::getDefaultIconHaloColor() {
|
||||
return { {} };
|
||||
}
|
||||
|
||||
PropertyValue<Color> SymbolLayer::getIconHaloColor() const {
|
||||
const PropertyValue<Color>& SymbolLayer::getIconHaloColor() const {
|
||||
return impl().paint.template get<IconHaloColor>().value;
|
||||
}
|
||||
|
||||
void SymbolLayer::setIconHaloColor(PropertyValue<Color> value) {
|
||||
void SymbolLayer::setIconHaloColor(const PropertyValue<Color>& value) {
|
||||
if (value == getIconHaloColor())
|
||||
return;
|
||||
auto impl_ = mutableImpl();
|
||||
@@ -772,11 +772,11 @@ PropertyValue<float> SymbolLayer::getDefaultIconHaloWidth() {
|
||||
return { 0 };
|
||||
}
|
||||
|
||||
PropertyValue<float> SymbolLayer::getIconHaloWidth() const {
|
||||
const PropertyValue<float>& SymbolLayer::getIconHaloWidth() const {
|
||||
return impl().paint.template get<IconHaloWidth>().value;
|
||||
}
|
||||
|
||||
void SymbolLayer::setIconHaloWidth(PropertyValue<float> value) {
|
||||
void SymbolLayer::setIconHaloWidth(const PropertyValue<float>& value) {
|
||||
if (value == getIconHaloWidth())
|
||||
return;
|
||||
auto impl_ = mutableImpl();
|
||||
@@ -799,11 +799,11 @@ PropertyValue<float> SymbolLayer::getDefaultIconHaloBlur() {
|
||||
return { 0 };
|
||||
}
|
||||
|
||||
PropertyValue<float> SymbolLayer::getIconHaloBlur() const {
|
||||
const PropertyValue<float>& SymbolLayer::getIconHaloBlur() const {
|
||||
return impl().paint.template get<IconHaloBlur>().value;
|
||||
}
|
||||
|
||||
void SymbolLayer::setIconHaloBlur(PropertyValue<float> value) {
|
||||
void SymbolLayer::setIconHaloBlur(const PropertyValue<float>& value) {
|
||||
if (value == getIconHaloBlur())
|
||||
return;
|
||||
auto impl_ = mutableImpl();
|
||||
@@ -826,11 +826,11 @@ PropertyValue<std::array<float, 2>> SymbolLayer::getDefaultIconTranslate() {
|
||||
return { {{ 0, 0 }} };
|
||||
}
|
||||
|
||||
PropertyValue<std::array<float, 2>> SymbolLayer::getIconTranslate() const {
|
||||
const PropertyValue<std::array<float, 2>>& SymbolLayer::getIconTranslate() const {
|
||||
return impl().paint.template get<IconTranslate>().value;
|
||||
}
|
||||
|
||||
void SymbolLayer::setIconTranslate(PropertyValue<std::array<float, 2>> value) {
|
||||
void SymbolLayer::setIconTranslate(const PropertyValue<std::array<float, 2>>& value) {
|
||||
if (value == getIconTranslate())
|
||||
return;
|
||||
auto impl_ = mutableImpl();
|
||||
@@ -853,11 +853,11 @@ PropertyValue<TranslateAnchorType> SymbolLayer::getDefaultIconTranslateAnchor()
|
||||
return { TranslateAnchorType::Map };
|
||||
}
|
||||
|
||||
PropertyValue<TranslateAnchorType> SymbolLayer::getIconTranslateAnchor() const {
|
||||
const PropertyValue<TranslateAnchorType>& SymbolLayer::getIconTranslateAnchor() const {
|
||||
return impl().paint.template get<IconTranslateAnchor>().value;
|
||||
}
|
||||
|
||||
void SymbolLayer::setIconTranslateAnchor(PropertyValue<TranslateAnchorType> value) {
|
||||
void SymbolLayer::setIconTranslateAnchor(const PropertyValue<TranslateAnchorType>& value) {
|
||||
if (value == getIconTranslateAnchor())
|
||||
return;
|
||||
auto impl_ = mutableImpl();
|
||||
@@ -880,11 +880,11 @@ PropertyValue<float> SymbolLayer::getDefaultTextOpacity() {
|
||||
return { 1 };
|
||||
}
|
||||
|
||||
PropertyValue<float> SymbolLayer::getTextOpacity() const {
|
||||
const PropertyValue<float>& SymbolLayer::getTextOpacity() const {
|
||||
return impl().paint.template get<TextOpacity>().value;
|
||||
}
|
||||
|
||||
void SymbolLayer::setTextOpacity(PropertyValue<float> value) {
|
||||
void SymbolLayer::setTextOpacity(const PropertyValue<float>& value) {
|
||||
if (value == getTextOpacity())
|
||||
return;
|
||||
auto impl_ = mutableImpl();
|
||||
@@ -907,11 +907,11 @@ PropertyValue<Color> SymbolLayer::getDefaultTextColor() {
|
||||
return { Color::black() };
|
||||
}
|
||||
|
||||
PropertyValue<Color> SymbolLayer::getTextColor() const {
|
||||
const PropertyValue<Color>& SymbolLayer::getTextColor() const {
|
||||
return impl().paint.template get<TextColor>().value;
|
||||
}
|
||||
|
||||
void SymbolLayer::setTextColor(PropertyValue<Color> value) {
|
||||
void SymbolLayer::setTextColor(const PropertyValue<Color>& value) {
|
||||
if (value == getTextColor())
|
||||
return;
|
||||
auto impl_ = mutableImpl();
|
||||
@@ -934,11 +934,11 @@ PropertyValue<Color> SymbolLayer::getDefaultTextHaloColor() {
|
||||
return { {} };
|
||||
}
|
||||
|
||||
PropertyValue<Color> SymbolLayer::getTextHaloColor() const {
|
||||
const PropertyValue<Color>& SymbolLayer::getTextHaloColor() const {
|
||||
return impl().paint.template get<TextHaloColor>().value;
|
||||
}
|
||||
|
||||
void SymbolLayer::setTextHaloColor(PropertyValue<Color> value) {
|
||||
void SymbolLayer::setTextHaloColor(const PropertyValue<Color>& value) {
|
||||
if (value == getTextHaloColor())
|
||||
return;
|
||||
auto impl_ = mutableImpl();
|
||||
@@ -961,11 +961,11 @@ PropertyValue<float> SymbolLayer::getDefaultTextHaloWidth() {
|
||||
return { 0 };
|
||||
}
|
||||
|
||||
PropertyValue<float> SymbolLayer::getTextHaloWidth() const {
|
||||
const PropertyValue<float>& SymbolLayer::getTextHaloWidth() const {
|
||||
return impl().paint.template get<TextHaloWidth>().value;
|
||||
}
|
||||
|
||||
void SymbolLayer::setTextHaloWidth(PropertyValue<float> value) {
|
||||
void SymbolLayer::setTextHaloWidth(const PropertyValue<float>& value) {
|
||||
if (value == getTextHaloWidth())
|
||||
return;
|
||||
auto impl_ = mutableImpl();
|
||||
@@ -988,11 +988,11 @@ PropertyValue<float> SymbolLayer::getDefaultTextHaloBlur() {
|
||||
return { 0 };
|
||||
}
|
||||
|
||||
PropertyValue<float> SymbolLayer::getTextHaloBlur() const {
|
||||
const PropertyValue<float>& SymbolLayer::getTextHaloBlur() const {
|
||||
return impl().paint.template get<TextHaloBlur>().value;
|
||||
}
|
||||
|
||||
void SymbolLayer::setTextHaloBlur(PropertyValue<float> value) {
|
||||
void SymbolLayer::setTextHaloBlur(const PropertyValue<float>& value) {
|
||||
if (value == getTextHaloBlur())
|
||||
return;
|
||||
auto impl_ = mutableImpl();
|
||||
@@ -1015,11 +1015,11 @@ PropertyValue<std::array<float, 2>> SymbolLayer::getDefaultTextTranslate() {
|
||||
return { {{ 0, 0 }} };
|
||||
}
|
||||
|
||||
PropertyValue<std::array<float, 2>> SymbolLayer::getTextTranslate() const {
|
||||
const PropertyValue<std::array<float, 2>>& SymbolLayer::getTextTranslate() const {
|
||||
return impl().paint.template get<TextTranslate>().value;
|
||||
}
|
||||
|
||||
void SymbolLayer::setTextTranslate(PropertyValue<std::array<float, 2>> value) {
|
||||
void SymbolLayer::setTextTranslate(const PropertyValue<std::array<float, 2>>& value) {
|
||||
if (value == getTextTranslate())
|
||||
return;
|
||||
auto impl_ = mutableImpl();
|
||||
@@ -1042,11 +1042,11 @@ PropertyValue<TranslateAnchorType> SymbolLayer::getDefaultTextTranslateAnchor()
|
||||
return { TranslateAnchorType::Map };
|
||||
}
|
||||
|
||||
PropertyValue<TranslateAnchorType> SymbolLayer::getTextTranslateAnchor() const {
|
||||
const PropertyValue<TranslateAnchorType>& SymbolLayer::getTextTranslateAnchor() const {
|
||||
return impl().paint.template get<TextTranslateAnchor>().value;
|
||||
}
|
||||
|
||||
void SymbolLayer::setTextTranslateAnchor(PropertyValue<TranslateAnchorType> value) {
|
||||
void SymbolLayer::setTextTranslateAnchor(const PropertyValue<TranslateAnchorType>& value) {
|
||||
if (value == getTextTranslateAnchor())
|
||||
return;
|
||||
auto impl_ = mutableImpl();
|
||||
@@ -1135,7 +1135,7 @@ optional<Error> SymbolLayer::setPaintProperty(const std::string& name, const Con
|
||||
return Error { "layer doesn't support this property" };
|
||||
}
|
||||
|
||||
Property property = static_cast<Property>(it->second);
|
||||
auto property = static_cast<Property>(it->second);
|
||||
|
||||
|
||||
if (property == Property::IconOpacity || property == Property::IconHaloWidth || property == Property::IconHaloBlur || property == Property::TextOpacity || property == Property::TextHaloWidth || property == Property::TextHaloBlur) {
|
||||
@@ -1417,7 +1417,7 @@ optional<Error> SymbolLayer::setLayoutProperty(const std::string& name, const Co
|
||||
return Error { "layer doesn't support this property" };
|
||||
}
|
||||
|
||||
Property property = static_cast<Property>(it->second);
|
||||
auto property = static_cast<Property>(it->second);
|
||||
|
||||
|
||||
if (property == Property::SymbolPlacement) {
|
||||
|
||||
@@ -48,7 +48,7 @@ void RasterSource::loadDescription(FileSource& fileSource) {
|
||||
return;
|
||||
}
|
||||
|
||||
const std::string& url = urlOrTileset.get<std::string>();
|
||||
const auto& url = urlOrTileset.get<std::string>();
|
||||
req = fileSource.request(Resource::source(url), [this, url](Response res) {
|
||||
if (res.error) {
|
||||
observer->onSourceError(*this, std::make_exception_ptr(std::runtime_error(res.error->message)));
|
||||
|
||||
@@ -45,7 +45,7 @@ void VectorSource::loadDescription(FileSource& fileSource) {
|
||||
return;
|
||||
}
|
||||
|
||||
const std::string& url = urlOrTileset.get<std::string>();
|
||||
const auto& url = urlOrTileset.get<std::string>();
|
||||
req = fileSource.request(Resource::source(url), [this, url](Response res) {
|
||||
if (res.error) {
|
||||
observer->onSourceError(*this, std::make_exception_ptr(std::runtime_error(res.error->message)));
|
||||
|
||||
@@ -59,8 +59,7 @@ void TileLayerIndex::findMatches(std::vector<SymbolInstance>& symbolInstances, c
|
||||
}
|
||||
}
|
||||
|
||||
CrossTileSymbolLayerIndex::CrossTileSymbolLayerIndex() {
|
||||
}
|
||||
CrossTileSymbolLayerIndex::CrossTileSymbolLayerIndex() = default;
|
||||
|
||||
/*
|
||||
* Sometimes when a user pans across the antimeridian the longitude value gets wrapped.
|
||||
@@ -163,7 +162,7 @@ bool CrossTileSymbolLayerIndex::removeStaleBuckets(const std::unordered_set<uint
|
||||
return tilesChanged;
|
||||
}
|
||||
|
||||
CrossTileSymbolIndex::CrossTileSymbolIndex() {}
|
||||
CrossTileSymbolIndex::CrossTileSymbolIndex() = default;
|
||||
|
||||
bool CrossTileSymbolIndex::addLayer(const RenderLayerSymbolInterface& symbolInterface, float lng) {
|
||||
|
||||
|
||||
@@ -185,8 +185,8 @@ struct bcp47_parser : qi::grammar<Iterator>
|
||||
};
|
||||
|
||||
LanguageTag LanguageTag::fromBCP47(const std::string& bcp47Tag) {
|
||||
typedef std::string::const_iterator iterator_type;
|
||||
typedef bcp47_parser<iterator_type> bcp47_parser;
|
||||
using iterator_type = std::string::const_iterator;
|
||||
using bcp47_parser = bcp47_parser<iterator_type>;
|
||||
|
||||
bcp47_parser parser;
|
||||
std::string::const_iterator iter = bcp47Tag.begin();
|
||||
|
||||
@@ -8,6 +8,7 @@
|
||||
#include <mbgl/renderer/buckets/symbol_bucket.hpp>
|
||||
#include <mbgl/renderer/bucket.hpp>
|
||||
#include <mbgl/util/math.hpp>
|
||||
#include <utility>
|
||||
|
||||
namespace mbgl {
|
||||
|
||||
@@ -62,7 +63,7 @@ Placement::Placement(const TransformState& state_, MapMode mapMode_, style::Tran
|
||||
: collisionIndex(state_)
|
||||
, state(state_)
|
||||
, mapMode(mapMode_)
|
||||
, transitionOptions(transitionOptions_)
|
||||
, transitionOptions(std::move(transitionOptions_))
|
||||
, collisionGroups(crossSourceCollisions)
|
||||
, prevPlacement(std::move(prevPlacement_))
|
||||
{
|
||||
@@ -80,7 +81,7 @@ void Placement::placeLayer(const RenderLayerSymbolInterface& symbolInterface, co
|
||||
continue;
|
||||
}
|
||||
assert(renderTile.tile.kind == Tile::Kind::Geometry);
|
||||
GeometryTile& geometryTile = static_cast<GeometryTile&>(renderTile.tile);
|
||||
auto& geometryTile = static_cast<GeometryTile&>(renderTile.tile);
|
||||
|
||||
auto bucket = symbolInterface.getSymbolBucket(renderTile);
|
||||
if (!bucket) {
|
||||
|
||||
@@ -8,6 +8,7 @@
|
||||
#include <mbgl/style/custom_tile_loader.hpp>
|
||||
|
||||
#include <mapbox/geojsonvt.hpp>
|
||||
#include <utility>
|
||||
|
||||
namespace mbgl {
|
||||
|
||||
@@ -19,7 +20,7 @@ CustomGeometryTile::CustomGeometryTile(const OverscaledTileID& overscaledTileID,
|
||||
: GeometryTile(overscaledTileID, sourceID_, parameters),
|
||||
necessity(TileNecessity::Optional),
|
||||
options(options_),
|
||||
loader(loader_),
|
||||
loader(std::move(loader_)),
|
||||
mailbox(std::make_shared<Mailbox>(*Scheduler::GetCurrent())),
|
||||
actorRef(*this, mailbox) {
|
||||
}
|
||||
|
||||
@@ -21,6 +21,7 @@
|
||||
#include <mbgl/util/stopwatch.hpp>
|
||||
|
||||
#include <unordered_set>
|
||||
#include <utility>
|
||||
|
||||
namespace mbgl {
|
||||
|
||||
@@ -29,7 +30,7 @@ using namespace style;
|
||||
GeometryTileWorker::GeometryTileWorker(ActorRef<GeometryTileWorker> self_,
|
||||
ActorRef<GeometryTile> parent_,
|
||||
OverscaledTileID id_,
|
||||
const std::string& sourceID_,
|
||||
std::string sourceID_,
|
||||
const std::atomic<bool>& obsolete_,
|
||||
const MapMode mode_,
|
||||
const float pixelRatio_,
|
||||
@@ -37,7 +38,7 @@ GeometryTileWorker::GeometryTileWorker(ActorRef<GeometryTileWorker> self_,
|
||||
: self(std::move(self_)),
|
||||
parent(std::move(parent_)),
|
||||
id(std::move(id_)),
|
||||
sourceID(sourceID_),
|
||||
sourceID(std::move(sourceID_)),
|
||||
obsolete(obsolete_),
|
||||
mode(mode_),
|
||||
pixelRatio(pixelRatio_),
|
||||
|
||||
@@ -32,7 +32,7 @@ public:
|
||||
GeometryTileWorker(ActorRef<GeometryTileWorker> self,
|
||||
ActorRef<GeometryTile> parent,
|
||||
OverscaledTileID,
|
||||
const std::string&,
|
||||
std::string,
|
||||
const std::atomic<bool>&,
|
||||
const MapMode,
|
||||
const float pixelRatio,
|
||||
|
||||
@@ -78,7 +78,7 @@ std::string toPaddedHex(T x) {
|
||||
return result;
|
||||
}
|
||||
|
||||
}
|
||||
} // namespace
|
||||
|
||||
std::string toHex(size_t value) {
|
||||
return toPaddedHex(value);
|
||||
|
||||
@@ -237,9 +237,7 @@ TileCover::TileCover(const Geometry<double>& geom, int32_t z, bool project/* = t
|
||||
: impl( std::make_unique<TileCover::Impl>(z, geom, project)) {
|
||||
}
|
||||
|
||||
TileCover::~TileCover() {
|
||||
|
||||
}
|
||||
TileCover::~TileCover() = default;
|
||||
|
||||
optional<UnwrappedTileID> TileCover::next() {
|
||||
return impl->next();
|
||||
|
||||
@@ -3,8 +3,8 @@
|
||||
|
||||
#include <functional>
|
||||
#include <cmath>
|
||||
#include <assert.h>
|
||||
#include <limits.h>
|
||||
#include <cassert>
|
||||
#include <climits>
|
||||
#include <algorithm>
|
||||
|
||||
namespace mbgl {
|
||||
|
||||
@@ -101,7 +101,7 @@ TEST(Actor, DestructionBlocksOnSend) {
|
||||
waited(false) {
|
||||
}
|
||||
|
||||
~TestScheduler() {
|
||||
~TestScheduler() override {
|
||||
EXPECT_TRUE(waited.load());
|
||||
}
|
||||
|
||||
|
||||
@@ -39,7 +39,7 @@ void main() {
|
||||
|
||||
class TestLayer : public mbgl::style::CustomLayerHost {
|
||||
public:
|
||||
void initialize() {
|
||||
void initialize() override {
|
||||
program = MBGL_CHECK_ERROR(glCreateProgram());
|
||||
vertexShader = MBGL_CHECK_ERROR(glCreateShader(GL_VERTEX_SHADER));
|
||||
fragmentShader = MBGL_CHECK_ERROR(glCreateShader(GL_FRAGMENT_SHADER));
|
||||
@@ -59,7 +59,7 @@ public:
|
||||
MBGL_CHECK_ERROR(glBufferData(GL_ARRAY_BUFFER, 6 * sizeof(GLfloat), triangle, GL_STATIC_DRAW));
|
||||
}
|
||||
|
||||
void render(const mbgl::style::CustomLayerRenderParameters&) {
|
||||
void render(const mbgl::style::CustomLayerRenderParameters&) override {
|
||||
MBGL_CHECK_ERROR(glUseProgram(program));
|
||||
MBGL_CHECK_ERROR(glBindBuffer(GL_ARRAY_BUFFER, buffer));
|
||||
MBGL_CHECK_ERROR(glEnableVertexAttribArray(a_pos));
|
||||
@@ -67,9 +67,9 @@ public:
|
||||
MBGL_CHECK_ERROR(glDrawArrays(GL_TRIANGLE_STRIP, 0, 3));
|
||||
}
|
||||
|
||||
void contextLost() {}
|
||||
void contextLost() override {}
|
||||
|
||||
void deinitialize() {
|
||||
void deinitialize() override {
|
||||
if (program) {
|
||||
MBGL_CHECK_ERROR(glDeleteBuffers(1, &buffer));
|
||||
MBGL_CHECK_ERROR(glDetachShader(program, vertexShader));
|
||||
|
||||
@@ -48,7 +48,7 @@ public:
|
||||
template <typename T = FileSource>
|
||||
MapTest(const std::string& cachePath, const std::string& assetPath,
|
||||
float pixelRatio = 1, MapMode mode = MapMode::Static,
|
||||
typename std::enable_if<std::is_same<T, DefaultFileSource>::value>::type* = 0)
|
||||
typename std::enable_if<std::is_same<T, DefaultFileSource>::value>::type* = nullptr)
|
||||
: fileSource(std::make_shared<T>(cachePath, assetPath))
|
||||
, frontend(pixelRatio, threadPool)
|
||||
, map(frontend, observer, fileSource, threadPool,
|
||||
|
||||
@@ -29,11 +29,11 @@ static int sqlite3_test_fs_close(sqlite3_file* pFile) {
|
||||
if (!sqlite3_test_fs_io) {
|
||||
return SQLITE_AUTH;
|
||||
}
|
||||
File* file = (File*)pFile;
|
||||
auto* file = (File*)pFile;
|
||||
const int rc = file->real->pMethods->xClose(file->real);
|
||||
if (rc == SQLITE_OK) {
|
||||
sqlite3_free((void*)file->base.pMethods);
|
||||
file->base.pMethods = 0;
|
||||
file->base.pMethods = nullptr;
|
||||
}
|
||||
return rc;
|
||||
}
|
||||
@@ -52,7 +52,7 @@ static int sqlite3_test_fs_read(sqlite3_file* pFile, void* zBuf, int iAmt, sqlit
|
||||
}
|
||||
sqlite3_test_fs_read_limit -= iAmt;
|
||||
}
|
||||
File* file = (File*)pFile;
|
||||
auto* file = (File*)pFile;
|
||||
return file->real->pMethods->xRead(file->real, zBuf, iAmt, iOfst);
|
||||
}
|
||||
|
||||
@@ -70,7 +70,7 @@ static int sqlite3_test_fs_write(sqlite3_file* pFile, const void* zBuf, int iAmt
|
||||
}
|
||||
sqlite3_test_fs_write_limit -= iAmt;
|
||||
}
|
||||
File* file = (File*)pFile;
|
||||
auto* file = (File*)pFile;
|
||||
return file->real->pMethods->xWrite(file->real, zBuf, iAmt, iOfst);
|
||||
}
|
||||
|
||||
@@ -81,7 +81,7 @@ static int sqlite3_test_fs_truncate(sqlite3_file* pFile, sqlite3_int64 size) {
|
||||
if (!sqlite3_test_fs_io) {
|
||||
return SQLITE_AUTH;
|
||||
}
|
||||
File* file = (File*)pFile;
|
||||
auto* file = (File*)pFile;
|
||||
return file->real->pMethods->xTruncate(file->real, size);
|
||||
}
|
||||
|
||||
@@ -92,7 +92,7 @@ static int sqlite3_test_fs_sync(sqlite3_file* pFile, int flags) {
|
||||
if (!sqlite3_test_fs_io) {
|
||||
return SQLITE_AUTH;
|
||||
}
|
||||
File* file = (File*)pFile;
|
||||
auto* file = (File*)pFile;
|
||||
return file->real->pMethods->xSync(file->real, flags);
|
||||
}
|
||||
|
||||
@@ -103,7 +103,7 @@ static int sqlite3_test_fs_file_size(sqlite3_file* pFile, sqlite3_int64* pSize)
|
||||
if (!sqlite3_test_fs_io) {
|
||||
return SQLITE_AUTH;
|
||||
}
|
||||
File* file = (File*)pFile;
|
||||
auto* file = (File*)pFile;
|
||||
return file->real->pMethods->xFileSize(file->real, pSize);
|
||||
}
|
||||
|
||||
@@ -111,7 +111,7 @@ static int sqlite3_test_fs_lock(sqlite3_file* pFile, int eLock) {
|
||||
if (sqlite3_test_fs_debug) {
|
||||
fprintf(stderr, "SQLite3: lock(%p, %d)\n", pFile, eLock);
|
||||
}
|
||||
File* file = (File*)pFile;
|
||||
auto* file = (File*)pFile;
|
||||
return file->real->pMethods->xLock(file->real, eLock);
|
||||
}
|
||||
|
||||
@@ -119,7 +119,7 @@ static int sqlite3_test_fs_unlock(sqlite3_file* pFile, int eLock) {
|
||||
if (sqlite3_test_fs_debug) {
|
||||
fprintf(stderr, "SQLite3: unlock(%p, %d)\n", pFile, eLock);
|
||||
}
|
||||
File* file = (File*)pFile;
|
||||
auto* file = (File*)pFile;
|
||||
return file->real->pMethods->xUnlock(file->real, eLock);
|
||||
}
|
||||
|
||||
@@ -127,7 +127,7 @@ static int sqlite3_test_fs_check_reserved_lock(sqlite3_file* pFile, int* pResOut
|
||||
if (sqlite3_test_fs_debug) {
|
||||
fprintf(stderr, "SQLite3: check_reserved_lock(%p)\n", pFile);
|
||||
}
|
||||
File* file = (File*)pFile;
|
||||
auto* file = (File*)pFile;
|
||||
return file->real->pMethods->xCheckReservedLock(file->real, pResOut);
|
||||
}
|
||||
|
||||
@@ -138,7 +138,7 @@ static int sqlite3_test_fs_file_control(sqlite3_file* pFile, int op, void* pArg)
|
||||
if (!sqlite3_test_fs_io) {
|
||||
return SQLITE_AUTH;
|
||||
}
|
||||
File* file = (File*)pFile;
|
||||
auto* file = (File*)pFile;
|
||||
return file->real->pMethods->xFileControl(file->real, op, pArg);
|
||||
}
|
||||
|
||||
@@ -149,7 +149,7 @@ static int sqlite3_test_fs_sector_size(sqlite3_file* pFile) {
|
||||
if (!sqlite3_test_fs_io) {
|
||||
return SQLITE_AUTH;
|
||||
}
|
||||
File* file = (File*)pFile;
|
||||
auto* file = (File*)pFile;
|
||||
return file->real->pMethods->xSectorSize(file->real);
|
||||
}
|
||||
|
||||
@@ -160,7 +160,7 @@ static int sqlite3_test_fs_device_characteristics(sqlite3_file* pFile) {
|
||||
if (!sqlite3_test_fs_io) {
|
||||
return SQLITE_AUTH;
|
||||
}
|
||||
File* file = (File*)pFile;
|
||||
auto* file = (File*)pFile;
|
||||
return file->real->pMethods->xDeviceCharacteristics(file->real);
|
||||
}
|
||||
|
||||
@@ -169,34 +169,34 @@ static int sqlite3_test_fs_open(sqlite3_vfs* vfs, const char* zName, sqlite3_fil
|
||||
fprintf(stderr, "SQLite3: open(name=%s, flags=%d) -> %p\n", zName, flags, pFile);
|
||||
}
|
||||
if (!sqlite3_test_fs_io) {
|
||||
pFile->pMethods = NULL;
|
||||
pFile->pMethods = nullptr;
|
||||
return SQLITE_AUTH;
|
||||
}
|
||||
if (!sqlite3_test_fs_file_open) {
|
||||
pFile->pMethods = NULL;
|
||||
pFile->pMethods = nullptr;
|
||||
return SQLITE_CANTOPEN;
|
||||
}
|
||||
|
||||
File* file = (File*)pFile;
|
||||
sqlite3_vfs* unix_fs = (sqlite3_vfs*)vfs->pAppData;
|
||||
auto* file = (File*)pFile;
|
||||
auto* unix_fs = (sqlite3_vfs*)vfs->pAppData;
|
||||
file->real = (sqlite3_file*)&file[1];
|
||||
|
||||
if (!sqlite3_test_fs_file_create) {
|
||||
int res;
|
||||
const int result = unix_fs->xAccess(vfs, zName, SQLITE_ACCESS_EXISTS, &res);
|
||||
if (result != SQLITE_OK) {
|
||||
pFile->pMethods = NULL;
|
||||
pFile->pMethods = nullptr;
|
||||
return result;
|
||||
}
|
||||
if (res != 1) {
|
||||
pFile->pMethods = NULL;
|
||||
pFile->pMethods = nullptr;
|
||||
return SQLITE_CANTOPEN;
|
||||
}
|
||||
}
|
||||
|
||||
const int status = unix_fs->xOpen(unix_fs, zName, file->real, flags, pOutFlags);
|
||||
if (file->real->pMethods) {
|
||||
sqlite3_io_methods* methods = (sqlite3_io_methods*)sqlite3_malloc(sizeof(sqlite3_io_methods));
|
||||
auto* methods = (sqlite3_io_methods*)sqlite3_malloc(sizeof(sqlite3_io_methods));
|
||||
memset(methods, 0, sizeof(sqlite3_io_methods));
|
||||
methods->iVersion = 1;
|
||||
methods->xClose = sqlite3_test_fs_close;
|
||||
@@ -223,7 +223,7 @@ static int sqlite3_test_fs_delete(sqlite3_vfs* vfs, const char *zPath, int dirSy
|
||||
if (!sqlite3_test_fs_io) {
|
||||
return SQLITE_AUTH;
|
||||
}
|
||||
sqlite3_vfs* unix_fs = (sqlite3_vfs*)vfs->pAppData;
|
||||
auto* unix_fs = (sqlite3_vfs*)vfs->pAppData;
|
||||
return unix_fs->xDelete(unix_fs, zPath, dirSync);
|
||||
}
|
||||
|
||||
@@ -234,7 +234,7 @@ static int sqlite3_test_fs_access(sqlite3_vfs* vfs, const char *zPath, int flags
|
||||
if (!sqlite3_test_fs_io) {
|
||||
return SQLITE_AUTH;
|
||||
}
|
||||
sqlite3_vfs* unix_fs = (sqlite3_vfs*)vfs->pAppData;
|
||||
auto* unix_fs = (sqlite3_vfs*)vfs->pAppData;
|
||||
return unix_fs->xAccess(unix_fs, zPath, flags, pResOut);
|
||||
}
|
||||
|
||||
@@ -243,12 +243,12 @@ namespace test {
|
||||
|
||||
SQLite3TestFS::SQLite3TestFS() {
|
||||
sqlite3_vfs* unix_fs = sqlite3_vfs_find("unix");
|
||||
if (unix_fs == 0) {
|
||||
if (unix_fs == nullptr) {
|
||||
abort();
|
||||
}
|
||||
|
||||
sqlite3_vfs* test_fs = (sqlite3_vfs*)sqlite3_malloc(sizeof(sqlite3_vfs));
|
||||
if (test_fs == 0) {
|
||||
auto* test_fs = (sqlite3_vfs*)sqlite3_malloc(sizeof(sqlite3_vfs));
|
||||
if (test_fs == nullptr) {
|
||||
abort();
|
||||
}
|
||||
memset(test_fs, 0, sizeof(sqlite3_vfs));
|
||||
|
||||
@@ -91,7 +91,7 @@ const Response response = [] {
|
||||
return res;
|
||||
}();
|
||||
|
||||
} // namespace
|
||||
} // namespace fixture
|
||||
|
||||
TEST(OfflineDatabase, TEST_REQUIRES_WRITE(Create)) {
|
||||
FixtureLog log;
|
||||
|
||||
@@ -117,10 +117,10 @@ TEST(Filter, EqualsType) {
|
||||
ASSERT_TRUE(filter(f, {{}}, {}, FeatureType::LineString, {}));
|
||||
ASSERT_FALSE(filter(f, {{}}, {}, FeatureType::Point, {}));
|
||||
|
||||
invalidFilter("[\"==\", \"$type\"]");
|
||||
invalidFilter("[\"==\", \"$type\", null]");
|
||||
invalidFilter("[\"==\", \"$type\", \"foo\", 1]");
|
||||
invalidFilter("[\"==\", \"$type\", \"foo\", \"Point\"]");
|
||||
invalidFilter(R"(["==", "$type"])");
|
||||
invalidFilter(R"(["==", "$type", null])");
|
||||
invalidFilter(R"(["==", "$type", "foo", 1])");
|
||||
invalidFilter(R"(["==", "$type", "foo", "Point"])");
|
||||
}
|
||||
|
||||
TEST(Filter, InType) {
|
||||
|
||||
@@ -19,11 +19,11 @@ static constexpr const size_t stubBitmapLength = 900;
|
||||
|
||||
class StubLocalGlyphRasterizer : public LocalGlyphRasterizer {
|
||||
public:
|
||||
bool canRasterizeGlyph(const FontStack&, GlyphID glyphID) {
|
||||
bool canRasterizeGlyph(const FontStack&, GlyphID glyphID) override {
|
||||
return util::i18n::allowsIdeographicBreaking(glyphID);
|
||||
}
|
||||
|
||||
Glyph rasterizeGlyph(const FontStack&, GlyphID glyphID) {
|
||||
Glyph rasterizeGlyph(const FontStack&, GlyphID glyphID) override {
|
||||
Glyph stub;
|
||||
stub.id = glyphID;
|
||||
|
||||
|
||||
@@ -15,7 +15,7 @@ namespace {
|
||||
PropertyMap properties;
|
||||
LineString<int16_t> emptyLine;
|
||||
|
||||
}
|
||||
} // namespace
|
||||
|
||||
class SymbolFeatureStub : public SymbolFeature {
|
||||
public:
|
||||
|
||||
@@ -6,7 +6,7 @@ using namespace mbgl::util;
|
||||
|
||||
class TestType {
|
||||
public:
|
||||
TestType() : i1(0), i2(1) {
|
||||
TestType() {
|
||||
str[0] = 'a';
|
||||
}
|
||||
|
||||
@@ -18,14 +18,14 @@ public:
|
||||
TestType(const TestType&) = delete;
|
||||
TestType& operator=(const TestType&) = delete;
|
||||
|
||||
int i1;
|
||||
int i2;
|
||||
int i1 = 0;
|
||||
int i2 = 1;
|
||||
char str[256];
|
||||
};
|
||||
|
||||
bool IsStackAllocated (const peer& a, const void* obj1) {
|
||||
uintptr_t a_ptr = (uintptr_t)(&a);
|
||||
uintptr_t obj = (uintptr_t)(obj1);
|
||||
auto a_ptr = (uintptr_t)(&a);
|
||||
auto obj = (uintptr_t)(obj1);
|
||||
return (obj >= a_ptr && obj < a_ptr + sizeof(peer));
|
||||
};
|
||||
|
||||
@@ -163,7 +163,7 @@ TEST(Peer, UniquePtr) {
|
||||
EXPECT_FALSE(u1.has_value());
|
||||
|
||||
peer u2;
|
||||
TestType * t3 = new TestType();
|
||||
auto* t3 = new TestType();
|
||||
u2 = std::unique_ptr<TestType>(t3);
|
||||
EXPECT_TRUE(u2.has_value());
|
||||
}
|
||||
|
||||
@@ -3,8 +3,8 @@
|
||||
#include <mbgl/map/transform.hpp>
|
||||
|
||||
#include <algorithm>
|
||||
#include <stdlib.h> /* srand, rand */
|
||||
#include <time.h> /* time */
|
||||
#include <cstdlib> /* srand, rand */
|
||||
#include <ctime> /* time */
|
||||
#include <gtest/gtest.h>
|
||||
|
||||
using namespace mbgl;
|
||||
@@ -314,9 +314,9 @@ TEST(TileCount, BoundsCrossingAntimeridian) {
|
||||
}
|
||||
|
||||
TEST(TileCover, DISABLED_FuzzPoly) {
|
||||
while(1)
|
||||
while(true)
|
||||
{
|
||||
std::srand (time(NULL));
|
||||
std::srand (time(nullptr));
|
||||
std::size_t len = std::rand() % 10000 + 3;
|
||||
Polygon<double> polygon;
|
||||
|
||||
@@ -342,9 +342,9 @@ TEST(TileCover, DISABLED_FuzzPoly) {
|
||||
}
|
||||
|
||||
TEST(TileCover, DISABLED_FuzzLine) {
|
||||
while(1)
|
||||
while(true)
|
||||
{
|
||||
std::srand (time(NULL));
|
||||
std::srand (time(nullptr));
|
||||
std::size_t len = std::rand() % 10000 + 3;
|
||||
MultiLineString<double> mls;
|
||||
|
||||
|
||||
Reference in New Issue
Block a user