From 20712b7c84bd91bcf658d74bf25f3460354b5fd6 Mon Sep 17 00:00:00 2001
From: Fabian Guerra Soto <fabian.guerra@mapbox.com>
Date: Fri, 10 Mar 2017 11:33:31 -0800
Subject: Per-attribute transition properties on MGLStyleLayer (#8225)

* [ios, macos] new struct MGLTransition

* [ios] MGLTransition struct moved to MGLTypes.h

* [ios] MGLTransition implemented for style layer properties

* [ios, macos] added support for getting property transitions

* [ios, macos] updated to MGLDurationFromTimeInterval and MGLTimeIntervalFromDuration

* [ios, macos] added transition properties test

* [ios, macos] modified key strings imp

* [ios, macos] The impl for transition properties were changed to public methods

* [ios, macos] Changelog update

* [ios] Fixed layer space formatting

* [core] The name space was fixed for getters that returned TransitionOptions

* [ios, macos] Added rawLayer transition property tests

* [ios] Added a factory method for MGLTransition and transition-related methods to NSValue(MGLAdditions)

* [ios, macos] Copyedited changelog blurbs about transition properties
---
 src/mbgl/style/layers/background_layer.cpp     | 12 ++++++
 src/mbgl/style/layers/circle_layer.cpp         | 40 ++++++++++++++++++
 src/mbgl/style/layers/fill_extrusion_layer.cpp | 28 +++++++++++++
 src/mbgl/style/layers/fill_layer.cpp           | 28 +++++++++++++
 src/mbgl/style/layers/layer.cpp.ejs            |  4 ++
 src/mbgl/style/layers/line_layer.cpp           | 40 ++++++++++++++++++
 src/mbgl/style/layers/raster_layer.cpp         | 28 +++++++++++++
 src/mbgl/style/layers/symbol_layer.cpp         | 56 ++++++++++++++++++++++++++
 src/mbgl/style/paint_property.hpp              |  5 +++
 9 files changed, 241 insertions(+)

(limited to 'src')

diff --git a/src/mbgl/style/layers/background_layer.cpp b/src/mbgl/style/layers/background_layer.cpp
index 5a903f1b6b..e2a517b9f4 100644
--- a/src/mbgl/style/layers/background_layer.cpp
+++ b/src/mbgl/style/layers/background_layer.cpp
@@ -59,6 +59,10 @@ void BackgroundLayer::setBackgroundColorTransition(const TransitionOptions& valu
     impl->paint.setTransition<BackgroundColor>(value, klass);
 }
 
+TransitionOptions BackgroundLayer::getBackgroundColorTransition(const optional<std::string>& klass) const {
+    return impl->paint.getTransition<BackgroundColor>(klass);
+}
+
 PropertyValue<std::string> BackgroundLayer::getDefaultBackgroundPattern() {
     return { "" };
 }
@@ -78,6 +82,10 @@ void BackgroundLayer::setBackgroundPatternTransition(const TransitionOptions& va
     impl->paint.setTransition<BackgroundPattern>(value, klass);
 }
 
+TransitionOptions BackgroundLayer::getBackgroundPatternTransition(const optional<std::string>& klass) const {
+    return impl->paint.getTransition<BackgroundPattern>(klass);
+}
+
 PropertyValue<float> BackgroundLayer::getDefaultBackgroundOpacity() {
     return { 1 };
 }
@@ -97,5 +105,9 @@ void BackgroundLayer::setBackgroundOpacityTransition(const TransitionOptions& va
     impl->paint.setTransition<BackgroundOpacity>(value, klass);
 }
 
+TransitionOptions BackgroundLayer::getBackgroundOpacityTransition(const optional<std::string>& klass) const {
+    return impl->paint.getTransition<BackgroundOpacity>(klass);
+}
+
 } // namespace style
 } // namespace mbgl
diff --git a/src/mbgl/style/layers/circle_layer.cpp b/src/mbgl/style/layers/circle_layer.cpp
index 53248e9397..a628d7a417 100644
--- a/src/mbgl/style/layers/circle_layer.cpp
+++ b/src/mbgl/style/layers/circle_layer.cpp
@@ -88,6 +88,10 @@ void CircleLayer::setCircleRadiusTransition(const TransitionOptions& value, cons
     impl->paint.setTransition<CircleRadius>(value, klass);
 }
 
+TransitionOptions CircleLayer::getCircleRadiusTransition(const optional<std::string>& klass) const {
+    return impl->paint.getTransition<CircleRadius>(klass);
+}
+
 DataDrivenPropertyValue<Color> CircleLayer::getDefaultCircleColor() {
     return { Color::black() };
 }
@@ -111,6 +115,10 @@ void CircleLayer::setCircleColorTransition(const TransitionOptions& value, const
     impl->paint.setTransition<CircleColor>(value, klass);
 }
 
+TransitionOptions CircleLayer::getCircleColorTransition(const optional<std::string>& klass) const {
+    return impl->paint.getTransition<CircleColor>(klass);
+}
+
 DataDrivenPropertyValue<float> CircleLayer::getDefaultCircleBlur() {
     return { 0 };
 }
@@ -134,6 +142,10 @@ void CircleLayer::setCircleBlurTransition(const TransitionOptions& value, const
     impl->paint.setTransition<CircleBlur>(value, klass);
 }
 
+TransitionOptions CircleLayer::getCircleBlurTransition(const optional<std::string>& klass) const {
+    return impl->paint.getTransition<CircleBlur>(klass);
+}
+
 DataDrivenPropertyValue<float> CircleLayer::getDefaultCircleOpacity() {
     return { 1 };
 }
@@ -157,6 +169,10 @@ void CircleLayer::setCircleOpacityTransition(const TransitionOptions& value, con
     impl->paint.setTransition<CircleOpacity>(value, klass);
 }
 
+TransitionOptions CircleLayer::getCircleOpacityTransition(const optional<std::string>& klass) const {
+    return impl->paint.getTransition<CircleOpacity>(klass);
+}
+
 PropertyValue<std::array<float, 2>> CircleLayer::getDefaultCircleTranslate() {
     return { {{ 0, 0 }} };
 }
@@ -176,6 +192,10 @@ void CircleLayer::setCircleTranslateTransition(const TransitionOptions& value, c
     impl->paint.setTransition<CircleTranslate>(value, klass);
 }
 
+TransitionOptions CircleLayer::getCircleTranslateTransition(const optional<std::string>& klass) const {
+    return impl->paint.getTransition<CircleTranslate>(klass);
+}
+
 PropertyValue<TranslateAnchorType> CircleLayer::getDefaultCircleTranslateAnchor() {
     return { TranslateAnchorType::Map };
 }
@@ -195,6 +215,10 @@ void CircleLayer::setCircleTranslateAnchorTransition(const TransitionOptions& va
     impl->paint.setTransition<CircleTranslateAnchor>(value, klass);
 }
 
+TransitionOptions CircleLayer::getCircleTranslateAnchorTransition(const optional<std::string>& klass) const {
+    return impl->paint.getTransition<CircleTranslateAnchor>(klass);
+}
+
 PropertyValue<CirclePitchScaleType> CircleLayer::getDefaultCirclePitchScale() {
     return { CirclePitchScaleType::Map };
 }
@@ -214,6 +238,10 @@ void CircleLayer::setCirclePitchScaleTransition(const TransitionOptions& value,
     impl->paint.setTransition<CirclePitchScale>(value, klass);
 }
 
+TransitionOptions CircleLayer::getCirclePitchScaleTransition(const optional<std::string>& klass) const {
+    return impl->paint.getTransition<CirclePitchScale>(klass);
+}
+
 DataDrivenPropertyValue<float> CircleLayer::getDefaultCircleStrokeWidth() {
     return { 0 };
 }
@@ -237,6 +265,10 @@ void CircleLayer::setCircleStrokeWidthTransition(const TransitionOptions& value,
     impl->paint.setTransition<CircleStrokeWidth>(value, klass);
 }
 
+TransitionOptions CircleLayer::getCircleStrokeWidthTransition(const optional<std::string>& klass) const {
+    return impl->paint.getTransition<CircleStrokeWidth>(klass);
+}
+
 DataDrivenPropertyValue<Color> CircleLayer::getDefaultCircleStrokeColor() {
     return { Color::black() };
 }
@@ -260,6 +292,10 @@ void CircleLayer::setCircleStrokeColorTransition(const TransitionOptions& value,
     impl->paint.setTransition<CircleStrokeColor>(value, klass);
 }
 
+TransitionOptions CircleLayer::getCircleStrokeColorTransition(const optional<std::string>& klass) const {
+    return impl->paint.getTransition<CircleStrokeColor>(klass);
+}
+
 DataDrivenPropertyValue<float> CircleLayer::getDefaultCircleStrokeOpacity() {
     return { 1 };
 }
@@ -283,5 +319,9 @@ void CircleLayer::setCircleStrokeOpacityTransition(const TransitionOptions& valu
     impl->paint.setTransition<CircleStrokeOpacity>(value, klass);
 }
 
+TransitionOptions CircleLayer::getCircleStrokeOpacityTransition(const optional<std::string>& klass) const {
+    return impl->paint.getTransition<CircleStrokeOpacity>(klass);
+}
+
 } // namespace style
 } // namespace mbgl
diff --git a/src/mbgl/style/layers/fill_extrusion_layer.cpp b/src/mbgl/style/layers/fill_extrusion_layer.cpp
index 4672ede9b8..53f7fc0757 100644
--- a/src/mbgl/style/layers/fill_extrusion_layer.cpp
+++ b/src/mbgl/style/layers/fill_extrusion_layer.cpp
@@ -84,6 +84,10 @@ void FillExtrusionLayer::setFillExtrusionOpacityTransition(const TransitionOptio
     impl->paint.setTransition<FillExtrusionOpacity>(value, klass);
 }
 
+TransitionOptions FillExtrusionLayer::getFillExtrusionOpacityTransition(const optional<std::string>& klass) const {
+    return impl->paint.getTransition<FillExtrusionOpacity>(klass);
+}
+
 DataDrivenPropertyValue<Color> FillExtrusionLayer::getDefaultFillExtrusionColor() {
     return { Color::black() };
 }
@@ -107,6 +111,10 @@ void FillExtrusionLayer::setFillExtrusionColorTransition(const TransitionOptions
     impl->paint.setTransition<FillExtrusionColor>(value, klass);
 }
 
+TransitionOptions FillExtrusionLayer::getFillExtrusionColorTransition(const optional<std::string>& klass) const {
+    return impl->paint.getTransition<FillExtrusionColor>(klass);
+}
+
 PropertyValue<std::array<float, 2>> FillExtrusionLayer::getDefaultFillExtrusionTranslate() {
     return { {{ 0, 0 }} };
 }
@@ -126,6 +134,10 @@ void FillExtrusionLayer::setFillExtrusionTranslateTransition(const TransitionOpt
     impl->paint.setTransition<FillExtrusionTranslate>(value, klass);
 }
 
+TransitionOptions FillExtrusionLayer::getFillExtrusionTranslateTransition(const optional<std::string>& klass) const {
+    return impl->paint.getTransition<FillExtrusionTranslate>(klass);
+}
+
 PropertyValue<TranslateAnchorType> FillExtrusionLayer::getDefaultFillExtrusionTranslateAnchor() {
     return { TranslateAnchorType::Map };
 }
@@ -145,6 +157,10 @@ void FillExtrusionLayer::setFillExtrusionTranslateAnchorTransition(const Transit
     impl->paint.setTransition<FillExtrusionTranslateAnchor>(value, klass);
 }
 
+TransitionOptions FillExtrusionLayer::getFillExtrusionTranslateAnchorTransition(const optional<std::string>& klass) const {
+    return impl->paint.getTransition<FillExtrusionTranslateAnchor>(klass);
+}
+
 PropertyValue<std::string> FillExtrusionLayer::getDefaultFillExtrusionPattern() {
     return { "" };
 }
@@ -164,6 +180,10 @@ void FillExtrusionLayer::setFillExtrusionPatternTransition(const TransitionOptio
     impl->paint.setTransition<FillExtrusionPattern>(value, klass);
 }
 
+TransitionOptions FillExtrusionLayer::getFillExtrusionPatternTransition(const optional<std::string>& klass) const {
+    return impl->paint.getTransition<FillExtrusionPattern>(klass);
+}
+
 DataDrivenPropertyValue<float> FillExtrusionLayer::getDefaultFillExtrusionHeight() {
     return { 0 };
 }
@@ -187,6 +207,10 @@ void FillExtrusionLayer::setFillExtrusionHeightTransition(const TransitionOption
     impl->paint.setTransition<FillExtrusionHeight>(value, klass);
 }
 
+TransitionOptions FillExtrusionLayer::getFillExtrusionHeightTransition(const optional<std::string>& klass) const {
+    return impl->paint.getTransition<FillExtrusionHeight>(klass);
+}
+
 DataDrivenPropertyValue<float> FillExtrusionLayer::getDefaultFillExtrusionBase() {
     return { 0 };
 }
@@ -210,5 +234,9 @@ void FillExtrusionLayer::setFillExtrusionBaseTransition(const TransitionOptions&
     impl->paint.setTransition<FillExtrusionBase>(value, klass);
 }
 
+TransitionOptions FillExtrusionLayer::getFillExtrusionBaseTransition(const optional<std::string>& klass) const {
+    return impl->paint.getTransition<FillExtrusionBase>(klass);
+}
+
 } // namespace style
 } // namespace mbgl
diff --git a/src/mbgl/style/layers/fill_layer.cpp b/src/mbgl/style/layers/fill_layer.cpp
index dfa88b5b0f..34203a10c0 100644
--- a/src/mbgl/style/layers/fill_layer.cpp
+++ b/src/mbgl/style/layers/fill_layer.cpp
@@ -84,6 +84,10 @@ void FillLayer::setFillAntialiasTransition(const TransitionOptions& value, const
     impl->paint.setTransition<FillAntialias>(value, klass);
 }
 
+TransitionOptions FillLayer::getFillAntialiasTransition(const optional<std::string>& klass) const {
+    return impl->paint.getTransition<FillAntialias>(klass);
+}
+
 DataDrivenPropertyValue<float> FillLayer::getDefaultFillOpacity() {
     return { 1 };
 }
@@ -107,6 +111,10 @@ void FillLayer::setFillOpacityTransition(const TransitionOptions& value, const o
     impl->paint.setTransition<FillOpacity>(value, klass);
 }
 
+TransitionOptions FillLayer::getFillOpacityTransition(const optional<std::string>& klass) const {
+    return impl->paint.getTransition<FillOpacity>(klass);
+}
+
 DataDrivenPropertyValue<Color> FillLayer::getDefaultFillColor() {
     return { Color::black() };
 }
@@ -130,6 +138,10 @@ void FillLayer::setFillColorTransition(const TransitionOptions& value, const opt
     impl->paint.setTransition<FillColor>(value, klass);
 }
 
+TransitionOptions FillLayer::getFillColorTransition(const optional<std::string>& klass) const {
+    return impl->paint.getTransition<FillColor>(klass);
+}
+
 DataDrivenPropertyValue<Color> FillLayer::getDefaultFillOutlineColor() {
     return { {} };
 }
@@ -153,6 +165,10 @@ void FillLayer::setFillOutlineColorTransition(const TransitionOptions& value, co
     impl->paint.setTransition<FillOutlineColor>(value, klass);
 }
 
+TransitionOptions FillLayer::getFillOutlineColorTransition(const optional<std::string>& klass) const {
+    return impl->paint.getTransition<FillOutlineColor>(klass);
+}
+
 PropertyValue<std::array<float, 2>> FillLayer::getDefaultFillTranslate() {
     return { {{ 0, 0 }} };
 }
@@ -172,6 +188,10 @@ void FillLayer::setFillTranslateTransition(const TransitionOptions& value, const
     impl->paint.setTransition<FillTranslate>(value, klass);
 }
 
+TransitionOptions FillLayer::getFillTranslateTransition(const optional<std::string>& klass) const {
+    return impl->paint.getTransition<FillTranslate>(klass);
+}
+
 PropertyValue<TranslateAnchorType> FillLayer::getDefaultFillTranslateAnchor() {
     return { TranslateAnchorType::Map };
 }
@@ -191,6 +211,10 @@ void FillLayer::setFillTranslateAnchorTransition(const TransitionOptions& value,
     impl->paint.setTransition<FillTranslateAnchor>(value, klass);
 }
 
+TransitionOptions FillLayer::getFillTranslateAnchorTransition(const optional<std::string>& klass) const {
+    return impl->paint.getTransition<FillTranslateAnchor>(klass);
+}
+
 PropertyValue<std::string> FillLayer::getDefaultFillPattern() {
     return { "" };
 }
@@ -210,5 +234,9 @@ void FillLayer::setFillPatternTransition(const TransitionOptions& value, const o
     impl->paint.setTransition<FillPattern>(value, klass);
 }
 
+TransitionOptions FillLayer::getFillPatternTransition(const optional<std::string>& klass) const {
+    return impl->paint.getTransition<FillPattern>(klass);
+}
+
 } // namespace style
 } // namespace mbgl
diff --git a/src/mbgl/style/layers/layer.cpp.ejs b/src/mbgl/style/layers/layer.cpp.ejs
index 335573abf3..76c83f474a 100644
--- a/src/mbgl/style/layers/layer.cpp.ejs
+++ b/src/mbgl/style/layers/layer.cpp.ejs
@@ -130,6 +130,10 @@ void <%- camelize(type) %>Layer::set<%- camelize(property.name) %>(<%- propertyV
 void <%- camelize(type) %>Layer::set<%- camelize(property.name) %>Transition(const TransitionOptions& value, const optional<std::string>& klass) {
     impl->paint.setTransition<<%- camelize(property.name) %>>(value, klass);
 }
+
+TransitionOptions <%- camelize(type) %>Layer::get<%- camelize(property.name) %>Transition(const optional<std::string>& klass) const {
+    return impl->paint.getTransition<<%- camelize(property.name) %>>(klass);
+}
 <% } -%>
 
 } // namespace style
diff --git a/src/mbgl/style/layers/line_layer.cpp b/src/mbgl/style/layers/line_layer.cpp
index eaaa0fcd45..cfb68f3262 100644
--- a/src/mbgl/style/layers/line_layer.cpp
+++ b/src/mbgl/style/layers/line_layer.cpp
@@ -145,6 +145,10 @@ void LineLayer::setLineOpacityTransition(const TransitionOptions& value, const o
     impl->paint.setTransition<LineOpacity>(value, klass);
 }
 
+TransitionOptions LineLayer::getLineOpacityTransition(const optional<std::string>& klass) const {
+    return impl->paint.getTransition<LineOpacity>(klass);
+}
+
 DataDrivenPropertyValue<Color> LineLayer::getDefaultLineColor() {
     return { Color::black() };
 }
@@ -168,6 +172,10 @@ void LineLayer::setLineColorTransition(const TransitionOptions& value, const opt
     impl->paint.setTransition<LineColor>(value, klass);
 }
 
+TransitionOptions LineLayer::getLineColorTransition(const optional<std::string>& klass) const {
+    return impl->paint.getTransition<LineColor>(klass);
+}
+
 PropertyValue<std::array<float, 2>> LineLayer::getDefaultLineTranslate() {
     return { {{ 0, 0 }} };
 }
@@ -187,6 +195,10 @@ void LineLayer::setLineTranslateTransition(const TransitionOptions& value, const
     impl->paint.setTransition<LineTranslate>(value, klass);
 }
 
+TransitionOptions LineLayer::getLineTranslateTransition(const optional<std::string>& klass) const {
+    return impl->paint.getTransition<LineTranslate>(klass);
+}
+
 PropertyValue<TranslateAnchorType> LineLayer::getDefaultLineTranslateAnchor() {
     return { TranslateAnchorType::Map };
 }
@@ -206,6 +218,10 @@ void LineLayer::setLineTranslateAnchorTransition(const TransitionOptions& value,
     impl->paint.setTransition<LineTranslateAnchor>(value, klass);
 }
 
+TransitionOptions LineLayer::getLineTranslateAnchorTransition(const optional<std::string>& klass) const {
+    return impl->paint.getTransition<LineTranslateAnchor>(klass);
+}
+
 PropertyValue<float> LineLayer::getDefaultLineWidth() {
     return { 1 };
 }
@@ -225,6 +241,10 @@ void LineLayer::setLineWidthTransition(const TransitionOptions& value, const opt
     impl->paint.setTransition<LineWidth>(value, klass);
 }
 
+TransitionOptions LineLayer::getLineWidthTransition(const optional<std::string>& klass) const {
+    return impl->paint.getTransition<LineWidth>(klass);
+}
+
 DataDrivenPropertyValue<float> LineLayer::getDefaultLineGapWidth() {
     return { 0 };
 }
@@ -248,6 +268,10 @@ void LineLayer::setLineGapWidthTransition(const TransitionOptions& value, const
     impl->paint.setTransition<LineGapWidth>(value, klass);
 }
 
+TransitionOptions LineLayer::getLineGapWidthTransition(const optional<std::string>& klass) const {
+    return impl->paint.getTransition<LineGapWidth>(klass);
+}
+
 DataDrivenPropertyValue<float> LineLayer::getDefaultLineOffset() {
     return { 0 };
 }
@@ -271,6 +295,10 @@ void LineLayer::setLineOffsetTransition(const TransitionOptions& value, const op
     impl->paint.setTransition<LineOffset>(value, klass);
 }
 
+TransitionOptions LineLayer::getLineOffsetTransition(const optional<std::string>& klass) const {
+    return impl->paint.getTransition<LineOffset>(klass);
+}
+
 DataDrivenPropertyValue<float> LineLayer::getDefaultLineBlur() {
     return { 0 };
 }
@@ -294,6 +322,10 @@ void LineLayer::setLineBlurTransition(const TransitionOptions& value, const opti
     impl->paint.setTransition<LineBlur>(value, klass);
 }
 
+TransitionOptions LineLayer::getLineBlurTransition(const optional<std::string>& klass) const {
+    return impl->paint.getTransition<LineBlur>(klass);
+}
+
 PropertyValue<std::vector<float>> LineLayer::getDefaultLineDasharray() {
     return { {  } };
 }
@@ -313,6 +345,10 @@ void LineLayer::setLineDasharrayTransition(const TransitionOptions& value, const
     impl->paint.setTransition<LineDasharray>(value, klass);
 }
 
+TransitionOptions LineLayer::getLineDasharrayTransition(const optional<std::string>& klass) const {
+    return impl->paint.getTransition<LineDasharray>(klass);
+}
+
 PropertyValue<std::string> LineLayer::getDefaultLinePattern() {
     return { "" };
 }
@@ -332,5 +368,9 @@ void LineLayer::setLinePatternTransition(const TransitionOptions& value, const o
     impl->paint.setTransition<LinePattern>(value, klass);
 }
 
+TransitionOptions LineLayer::getLinePatternTransition(const optional<std::string>& klass) const {
+    return impl->paint.getTransition<LinePattern>(klass);
+}
+
 } // namespace style
 } // namespace mbgl
diff --git a/src/mbgl/style/layers/raster_layer.cpp b/src/mbgl/style/layers/raster_layer.cpp
index 2108a5c49f..dfdd13e63c 100644
--- a/src/mbgl/style/layers/raster_layer.cpp
+++ b/src/mbgl/style/layers/raster_layer.cpp
@@ -66,6 +66,10 @@ void RasterLayer::setRasterOpacityTransition(const TransitionOptions& value, con
     impl->paint.setTransition<RasterOpacity>(value, klass);
 }
 
+TransitionOptions RasterLayer::getRasterOpacityTransition(const optional<std::string>& klass) const {
+    return impl->paint.getTransition<RasterOpacity>(klass);
+}
+
 PropertyValue<float> RasterLayer::getDefaultRasterHueRotate() {
     return { 0 };
 }
@@ -85,6 +89,10 @@ void RasterLayer::setRasterHueRotateTransition(const TransitionOptions& value, c
     impl->paint.setTransition<RasterHueRotate>(value, klass);
 }
 
+TransitionOptions RasterLayer::getRasterHueRotateTransition(const optional<std::string>& klass) const {
+    return impl->paint.getTransition<RasterHueRotate>(klass);
+}
+
 PropertyValue<float> RasterLayer::getDefaultRasterBrightnessMin() {
     return { 0 };
 }
@@ -104,6 +112,10 @@ void RasterLayer::setRasterBrightnessMinTransition(const TransitionOptions& valu
     impl->paint.setTransition<RasterBrightnessMin>(value, klass);
 }
 
+TransitionOptions RasterLayer::getRasterBrightnessMinTransition(const optional<std::string>& klass) const {
+    return impl->paint.getTransition<RasterBrightnessMin>(klass);
+}
+
 PropertyValue<float> RasterLayer::getDefaultRasterBrightnessMax() {
     return { 1 };
 }
@@ -123,6 +135,10 @@ void RasterLayer::setRasterBrightnessMaxTransition(const TransitionOptions& valu
     impl->paint.setTransition<RasterBrightnessMax>(value, klass);
 }
 
+TransitionOptions RasterLayer::getRasterBrightnessMaxTransition(const optional<std::string>& klass) const {
+    return impl->paint.getTransition<RasterBrightnessMax>(klass);
+}
+
 PropertyValue<float> RasterLayer::getDefaultRasterSaturation() {
     return { 0 };
 }
@@ -142,6 +158,10 @@ void RasterLayer::setRasterSaturationTransition(const TransitionOptions& value,
     impl->paint.setTransition<RasterSaturation>(value, klass);
 }
 
+TransitionOptions RasterLayer::getRasterSaturationTransition(const optional<std::string>& klass) const {
+    return impl->paint.getTransition<RasterSaturation>(klass);
+}
+
 PropertyValue<float> RasterLayer::getDefaultRasterContrast() {
     return { 0 };
 }
@@ -161,6 +181,10 @@ void RasterLayer::setRasterContrastTransition(const TransitionOptions& value, co
     impl->paint.setTransition<RasterContrast>(value, klass);
 }
 
+TransitionOptions RasterLayer::getRasterContrastTransition(const optional<std::string>& klass) const {
+    return impl->paint.getTransition<RasterContrast>(klass);
+}
+
 PropertyValue<float> RasterLayer::getDefaultRasterFadeDuration() {
     return { 300 };
 }
@@ -180,5 +204,9 @@ void RasterLayer::setRasterFadeDurationTransition(const TransitionOptions& value
     impl->paint.setTransition<RasterFadeDuration>(value, klass);
 }
 
+TransitionOptions RasterLayer::getRasterFadeDurationTransition(const optional<std::string>& klass) const {
+    return impl->paint.getTransition<RasterFadeDuration>(klass);
+}
+
 } // namespace style
 } // namespace mbgl
diff --git a/src/mbgl/style/layers/symbol_layer.cpp b/src/mbgl/style/layers/symbol_layer.cpp
index d85b8c00e6..42bcf0e6b0 100644
--- a/src/mbgl/style/layers/symbol_layer.cpp
+++ b/src/mbgl/style/layers/symbol_layer.cpp
@@ -565,6 +565,10 @@ void SymbolLayer::setIconOpacityTransition(const TransitionOptions& value, const
     impl->paint.setTransition<IconOpacity>(value, klass);
 }
 
+TransitionOptions SymbolLayer::getIconOpacityTransition(const optional<std::string>& klass) const {
+    return impl->paint.getTransition<IconOpacity>(klass);
+}
+
 DataDrivenPropertyValue<Color> SymbolLayer::getDefaultIconColor() {
     return { Color::black() };
 }
@@ -588,6 +592,10 @@ void SymbolLayer::setIconColorTransition(const TransitionOptions& value, const o
     impl->paint.setTransition<IconColor>(value, klass);
 }
 
+TransitionOptions SymbolLayer::getIconColorTransition(const optional<std::string>& klass) const {
+    return impl->paint.getTransition<IconColor>(klass);
+}
+
 DataDrivenPropertyValue<Color> SymbolLayer::getDefaultIconHaloColor() {
     return { {} };
 }
@@ -611,6 +619,10 @@ void SymbolLayer::setIconHaloColorTransition(const TransitionOptions& value, con
     impl->paint.setTransition<IconHaloColor>(value, klass);
 }
 
+TransitionOptions SymbolLayer::getIconHaloColorTransition(const optional<std::string>& klass) const {
+    return impl->paint.getTransition<IconHaloColor>(klass);
+}
+
 DataDrivenPropertyValue<float> SymbolLayer::getDefaultIconHaloWidth() {
     return { 0 };
 }
@@ -634,6 +646,10 @@ void SymbolLayer::setIconHaloWidthTransition(const TransitionOptions& value, con
     impl->paint.setTransition<IconHaloWidth>(value, klass);
 }
 
+TransitionOptions SymbolLayer::getIconHaloWidthTransition(const optional<std::string>& klass) const {
+    return impl->paint.getTransition<IconHaloWidth>(klass);
+}
+
 DataDrivenPropertyValue<float> SymbolLayer::getDefaultIconHaloBlur() {
     return { 0 };
 }
@@ -657,6 +673,10 @@ void SymbolLayer::setIconHaloBlurTransition(const TransitionOptions& value, cons
     impl->paint.setTransition<IconHaloBlur>(value, klass);
 }
 
+TransitionOptions SymbolLayer::getIconHaloBlurTransition(const optional<std::string>& klass) const {
+    return impl->paint.getTransition<IconHaloBlur>(klass);
+}
+
 PropertyValue<std::array<float, 2>> SymbolLayer::getDefaultIconTranslate() {
     return { {{ 0, 0 }} };
 }
@@ -676,6 +696,10 @@ void SymbolLayer::setIconTranslateTransition(const TransitionOptions& value, con
     impl->paint.setTransition<IconTranslate>(value, klass);
 }
 
+TransitionOptions SymbolLayer::getIconTranslateTransition(const optional<std::string>& klass) const {
+    return impl->paint.getTransition<IconTranslate>(klass);
+}
+
 PropertyValue<TranslateAnchorType> SymbolLayer::getDefaultIconTranslateAnchor() {
     return { TranslateAnchorType::Map };
 }
@@ -695,6 +719,10 @@ void SymbolLayer::setIconTranslateAnchorTransition(const TransitionOptions& valu
     impl->paint.setTransition<IconTranslateAnchor>(value, klass);
 }
 
+TransitionOptions SymbolLayer::getIconTranslateAnchorTransition(const optional<std::string>& klass) const {
+    return impl->paint.getTransition<IconTranslateAnchor>(klass);
+}
+
 DataDrivenPropertyValue<float> SymbolLayer::getDefaultTextOpacity() {
     return { 1 };
 }
@@ -718,6 +746,10 @@ void SymbolLayer::setTextOpacityTransition(const TransitionOptions& value, const
     impl->paint.setTransition<TextOpacity>(value, klass);
 }
 
+TransitionOptions SymbolLayer::getTextOpacityTransition(const optional<std::string>& klass) const {
+    return impl->paint.getTransition<TextOpacity>(klass);
+}
+
 DataDrivenPropertyValue<Color> SymbolLayer::getDefaultTextColor() {
     return { Color::black() };
 }
@@ -741,6 +773,10 @@ void SymbolLayer::setTextColorTransition(const TransitionOptions& value, const o
     impl->paint.setTransition<TextColor>(value, klass);
 }
 
+TransitionOptions SymbolLayer::getTextColorTransition(const optional<std::string>& klass) const {
+    return impl->paint.getTransition<TextColor>(klass);
+}
+
 DataDrivenPropertyValue<Color> SymbolLayer::getDefaultTextHaloColor() {
     return { {} };
 }
@@ -764,6 +800,10 @@ void SymbolLayer::setTextHaloColorTransition(const TransitionOptions& value, con
     impl->paint.setTransition<TextHaloColor>(value, klass);
 }
 
+TransitionOptions SymbolLayer::getTextHaloColorTransition(const optional<std::string>& klass) const {
+    return impl->paint.getTransition<TextHaloColor>(klass);
+}
+
 DataDrivenPropertyValue<float> SymbolLayer::getDefaultTextHaloWidth() {
     return { 0 };
 }
@@ -787,6 +827,10 @@ void SymbolLayer::setTextHaloWidthTransition(const TransitionOptions& value, con
     impl->paint.setTransition<TextHaloWidth>(value, klass);
 }
 
+TransitionOptions SymbolLayer::getTextHaloWidthTransition(const optional<std::string>& klass) const {
+    return impl->paint.getTransition<TextHaloWidth>(klass);
+}
+
 DataDrivenPropertyValue<float> SymbolLayer::getDefaultTextHaloBlur() {
     return { 0 };
 }
@@ -810,6 +854,10 @@ void SymbolLayer::setTextHaloBlurTransition(const TransitionOptions& value, cons
     impl->paint.setTransition<TextHaloBlur>(value, klass);
 }
 
+TransitionOptions SymbolLayer::getTextHaloBlurTransition(const optional<std::string>& klass) const {
+    return impl->paint.getTransition<TextHaloBlur>(klass);
+}
+
 PropertyValue<std::array<float, 2>> SymbolLayer::getDefaultTextTranslate() {
     return { {{ 0, 0 }} };
 }
@@ -829,6 +877,10 @@ void SymbolLayer::setTextTranslateTransition(const TransitionOptions& value, con
     impl->paint.setTransition<TextTranslate>(value, klass);
 }
 
+TransitionOptions SymbolLayer::getTextTranslateTransition(const optional<std::string>& klass) const {
+    return impl->paint.getTransition<TextTranslate>(klass);
+}
+
 PropertyValue<TranslateAnchorType> SymbolLayer::getDefaultTextTranslateAnchor() {
     return { TranslateAnchorType::Map };
 }
@@ -848,5 +900,9 @@ void SymbolLayer::setTextTranslateAnchorTransition(const TransitionOptions& valu
     impl->paint.setTransition<TextTranslateAnchor>(value, klass);
 }
 
+TransitionOptions SymbolLayer::getTextTranslateAnchorTransition(const optional<std::string>& klass) const {
+    return impl->paint.getTransition<TextTranslateAnchor>(klass);
+}
+
 } // namespace style
 } // namespace mbgl
diff --git a/src/mbgl/style/paint_property.hpp b/src/mbgl/style/paint_property.hpp
index 599bbef1f4..d4a5ee4c76 100644
--- a/src/mbgl/style/paint_property.hpp
+++ b/src/mbgl/style/paint_property.hpp
@@ -225,6 +225,11 @@ public:
     void setTransition(const TransitionOptions& value, const optional<std::string>& klass) {
         cascading.template get<P>().setTransition(value, klass);
     }
+    
+    template <class P>
+    auto getTransition(const optional<std::string>& klass) const {
+        return cascading.template get<P>().getTransition(klass);
+    }
 
     void cascade(const CascadeParameters& parameters) {
         unevaluated = Unevaluated {
-- 
cgit v1.2.1