From 3a48c60813b18c092c8d8d75c80a318bdd8859bb Mon Sep 17 00:00:00 2001
From: John Firebaugh <john.firebaugh@gmail.com>
Date: Wed, 31 Aug 2016 17:13:16 -0700
Subject: [PATCH] [core] Add missing classed paint property getter

---
 .../mbgl/style/layers/background_layer.hpp    |  6 +-
 include/mbgl/style/layers/circle_layer.hpp    | 14 ++---
 include/mbgl/style/layers/fill_layer.hpp      | 14 ++---
 include/mbgl/style/layers/layer.hpp.ejs       |  2 +-
 include/mbgl/style/layers/line_layer.hpp      | 20 +++----
 include/mbgl/style/layers/raster_layer.hpp    | 14 ++---
 include/mbgl/style/layers/symbol_layer.hpp    | 28 +++++-----
 src/mbgl/style/layers/background_layer.cpp    | 12 ++--
 src/mbgl/style/layers/circle_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             |  4 +-
 15 files changed, 149 insertions(+), 149 deletions(-)

diff --git a/include/mbgl/style/layers/background_layer.hpp b/include/mbgl/style/layers/background_layer.hpp
index 68aebfd37..c120b7f49 100644
--- a/include/mbgl/style/layers/background_layer.hpp
+++ b/include/mbgl/style/layers/background_layer.hpp
@@ -19,15 +19,15 @@ public:
     // Paint properties
 
     static PropertyValue<Color> getDefaultBackgroundColor();
-    PropertyValue<Color> getBackgroundColor() const;
+    PropertyValue<Color> getBackgroundColor(const optional<std::string>& klass = {}) const;
     void setBackgroundColor(PropertyValue<Color>, const optional<std::string>& klass = {});
 
     static PropertyValue<std::string> getDefaultBackgroundPattern();
-    PropertyValue<std::string> getBackgroundPattern() const;
+    PropertyValue<std::string> getBackgroundPattern(const optional<std::string>& klass = {}) const;
     void setBackgroundPattern(PropertyValue<std::string>, const optional<std::string>& klass = {});
 
     static PropertyValue<float> getDefaultBackgroundOpacity();
-    PropertyValue<float> getBackgroundOpacity() const;
+    PropertyValue<float> getBackgroundOpacity(const optional<std::string>& klass = {}) const;
     void setBackgroundOpacity(PropertyValue<float>, const optional<std::string>& klass = {});
 
     // Private implementation
diff --git a/include/mbgl/style/layers/circle_layer.hpp b/include/mbgl/style/layers/circle_layer.hpp
index 39ea61c5f..587f0023e 100644
--- a/include/mbgl/style/layers/circle_layer.hpp
+++ b/include/mbgl/style/layers/circle_layer.hpp
@@ -27,31 +27,31 @@ public:
     // Paint properties
 
     static PropertyValue<float> getDefaultCircleRadius();
-    PropertyValue<float> getCircleRadius() const;
+    PropertyValue<float> getCircleRadius(const optional<std::string>& klass = {}) const;
     void setCircleRadius(PropertyValue<float>, const optional<std::string>& klass = {});
 
     static PropertyValue<Color> getDefaultCircleColor();
-    PropertyValue<Color> getCircleColor() const;
+    PropertyValue<Color> getCircleColor(const optional<std::string>& klass = {}) const;
     void setCircleColor(PropertyValue<Color>, const optional<std::string>& klass = {});
 
     static PropertyValue<float> getDefaultCircleBlur();
-    PropertyValue<float> getCircleBlur() const;
+    PropertyValue<float> getCircleBlur(const optional<std::string>& klass = {}) const;
     void setCircleBlur(PropertyValue<float>, const optional<std::string>& klass = {});
 
     static PropertyValue<float> getDefaultCircleOpacity();
-    PropertyValue<float> getCircleOpacity() const;
+    PropertyValue<float> getCircleOpacity(const optional<std::string>& klass = {}) const;
     void setCircleOpacity(PropertyValue<float>, const optional<std::string>& klass = {});
 
     static PropertyValue<std::array<float, 2>> getDefaultCircleTranslate();
-    PropertyValue<std::array<float, 2>> getCircleTranslate() const;
+    PropertyValue<std::array<float, 2>> getCircleTranslate(const optional<std::string>& klass = {}) const;
     void setCircleTranslate(PropertyValue<std::array<float, 2>>, const optional<std::string>& klass = {});
 
     static PropertyValue<TranslateAnchorType> getDefaultCircleTranslateAnchor();
-    PropertyValue<TranslateAnchorType> getCircleTranslateAnchor() const;
+    PropertyValue<TranslateAnchorType> getCircleTranslateAnchor(const optional<std::string>& klass = {}) const;
     void setCircleTranslateAnchor(PropertyValue<TranslateAnchorType>, const optional<std::string>& klass = {});
 
     static PropertyValue<CirclePitchScaleType> getDefaultCirclePitchScale();
-    PropertyValue<CirclePitchScaleType> getCirclePitchScale() const;
+    PropertyValue<CirclePitchScaleType> getCirclePitchScale(const optional<std::string>& klass = {}) const;
     void setCirclePitchScale(PropertyValue<CirclePitchScaleType>, const optional<std::string>& klass = {});
 
     // Private implementation
diff --git a/include/mbgl/style/layers/fill_layer.hpp b/include/mbgl/style/layers/fill_layer.hpp
index 72bb7c498..4b9201641 100644
--- a/include/mbgl/style/layers/fill_layer.hpp
+++ b/include/mbgl/style/layers/fill_layer.hpp
@@ -27,31 +27,31 @@ public:
     // Paint properties
 
     static PropertyValue<bool> getDefaultFillAntialias();
-    PropertyValue<bool> getFillAntialias() const;
+    PropertyValue<bool> getFillAntialias(const optional<std::string>& klass = {}) const;
     void setFillAntialias(PropertyValue<bool>, const optional<std::string>& klass = {});
 
     static PropertyValue<float> getDefaultFillOpacity();
-    PropertyValue<float> getFillOpacity() const;
+    PropertyValue<float> getFillOpacity(const optional<std::string>& klass = {}) const;
     void setFillOpacity(PropertyValue<float>, const optional<std::string>& klass = {});
 
     static PropertyValue<Color> getDefaultFillColor();
-    PropertyValue<Color> getFillColor() const;
+    PropertyValue<Color> getFillColor(const optional<std::string>& klass = {}) const;
     void setFillColor(PropertyValue<Color>, const optional<std::string>& klass = {});
 
     static PropertyValue<Color> getDefaultFillOutlineColor();
-    PropertyValue<Color> getFillOutlineColor() const;
+    PropertyValue<Color> getFillOutlineColor(const optional<std::string>& klass = {}) const;
     void setFillOutlineColor(PropertyValue<Color>, const optional<std::string>& klass = {});
 
     static PropertyValue<std::array<float, 2>> getDefaultFillTranslate();
-    PropertyValue<std::array<float, 2>> getFillTranslate() const;
+    PropertyValue<std::array<float, 2>> getFillTranslate(const optional<std::string>& klass = {}) const;
     void setFillTranslate(PropertyValue<std::array<float, 2>>, const optional<std::string>& klass = {});
 
     static PropertyValue<TranslateAnchorType> getDefaultFillTranslateAnchor();
-    PropertyValue<TranslateAnchorType> getFillTranslateAnchor() const;
+    PropertyValue<TranslateAnchorType> getFillTranslateAnchor(const optional<std::string>& klass = {}) const;
     void setFillTranslateAnchor(PropertyValue<TranslateAnchorType>, const optional<std::string>& klass = {});
 
     static PropertyValue<std::string> getDefaultFillPattern();
-    PropertyValue<std::string> getFillPattern() const;
+    PropertyValue<std::string> getFillPattern(const optional<std::string>& klass = {}) const;
     void setFillPattern(PropertyValue<std::string>, const optional<std::string>& klass = {});
 
     // Private implementation
diff --git a/include/mbgl/style/layers/layer.hpp.ejs b/include/mbgl/style/layers/layer.hpp.ejs
index 9d542b75b..15d0fcee6 100644
--- a/include/mbgl/style/layers/layer.hpp.ejs
+++ b/include/mbgl/style/layers/layer.hpp.ejs
@@ -55,7 +55,7 @@ public:
 
 <% for (const property of paintProperties) { -%>
     static PropertyValue<<%- propertyType(property) %>> getDefault<%- camelize(property.name) %>();
-    PropertyValue<<%- propertyType(property) %>> get<%- camelize(property.name) %>() const;
+    PropertyValue<<%- propertyType(property) %>> get<%- camelize(property.name) %>(const optional<std::string>& klass = {}) const;
     void set<%- camelize(property.name) %>(PropertyValue<<%- propertyType(property) %>>, const optional<std::string>& klass = {});
 
 <% } -%>
diff --git a/include/mbgl/style/layers/line_layer.hpp b/include/mbgl/style/layers/line_layer.hpp
index 8549ad0a6..c3c1026bc 100644
--- a/include/mbgl/style/layers/line_layer.hpp
+++ b/include/mbgl/style/layers/line_layer.hpp
@@ -47,43 +47,43 @@ public:
     // Paint properties
 
     static PropertyValue<float> getDefaultLineOpacity();
-    PropertyValue<float> getLineOpacity() const;
+    PropertyValue<float> getLineOpacity(const optional<std::string>& klass = {}) const;
     void setLineOpacity(PropertyValue<float>, const optional<std::string>& klass = {});
 
     static PropertyValue<Color> getDefaultLineColor();
-    PropertyValue<Color> getLineColor() const;
+    PropertyValue<Color> getLineColor(const optional<std::string>& klass = {}) const;
     void setLineColor(PropertyValue<Color>, const optional<std::string>& klass = {});
 
     static PropertyValue<std::array<float, 2>> getDefaultLineTranslate();
-    PropertyValue<std::array<float, 2>> getLineTranslate() const;
+    PropertyValue<std::array<float, 2>> getLineTranslate(const optional<std::string>& klass = {}) const;
     void setLineTranslate(PropertyValue<std::array<float, 2>>, const optional<std::string>& klass = {});
 
     static PropertyValue<TranslateAnchorType> getDefaultLineTranslateAnchor();
-    PropertyValue<TranslateAnchorType> getLineTranslateAnchor() const;
+    PropertyValue<TranslateAnchorType> getLineTranslateAnchor(const optional<std::string>& klass = {}) const;
     void setLineTranslateAnchor(PropertyValue<TranslateAnchorType>, const optional<std::string>& klass = {});
 
     static PropertyValue<float> getDefaultLineWidth();
-    PropertyValue<float> getLineWidth() const;
+    PropertyValue<float> getLineWidth(const optional<std::string>& klass = {}) const;
     void setLineWidth(PropertyValue<float>, const optional<std::string>& klass = {});
 
     static PropertyValue<float> getDefaultLineGapWidth();
-    PropertyValue<float> getLineGapWidth() const;
+    PropertyValue<float> getLineGapWidth(const optional<std::string>& klass = {}) const;
     void setLineGapWidth(PropertyValue<float>, const optional<std::string>& klass = {});
 
     static PropertyValue<float> getDefaultLineOffset();
-    PropertyValue<float> getLineOffset() const;
+    PropertyValue<float> getLineOffset(const optional<std::string>& klass = {}) const;
     void setLineOffset(PropertyValue<float>, const optional<std::string>& klass = {});
 
     static PropertyValue<float> getDefaultLineBlur();
-    PropertyValue<float> getLineBlur() const;
+    PropertyValue<float> getLineBlur(const optional<std::string>& klass = {}) const;
     void setLineBlur(PropertyValue<float>, const optional<std::string>& klass = {});
 
     static PropertyValue<std::vector<float>> getDefaultLineDasharray();
-    PropertyValue<std::vector<float>> getLineDasharray() const;
+    PropertyValue<std::vector<float>> getLineDasharray(const optional<std::string>& klass = {}) const;
     void setLineDasharray(PropertyValue<std::vector<float>>, const optional<std::string>& klass = {});
 
     static PropertyValue<std::string> getDefaultLinePattern();
-    PropertyValue<std::string> getLinePattern() const;
+    PropertyValue<std::string> getLinePattern(const optional<std::string>& klass = {}) const;
     void setLinePattern(PropertyValue<std::string>, const optional<std::string>& klass = {});
 
     // Private implementation
diff --git a/include/mbgl/style/layers/raster_layer.hpp b/include/mbgl/style/layers/raster_layer.hpp
index c5479bd2a..ae6ec7f91 100644
--- a/include/mbgl/style/layers/raster_layer.hpp
+++ b/include/mbgl/style/layers/raster_layer.hpp
@@ -22,31 +22,31 @@ public:
     // Paint properties
 
     static PropertyValue<float> getDefaultRasterOpacity();
-    PropertyValue<float> getRasterOpacity() const;
+    PropertyValue<float> getRasterOpacity(const optional<std::string>& klass = {}) const;
     void setRasterOpacity(PropertyValue<float>, const optional<std::string>& klass = {});
 
     static PropertyValue<float> getDefaultRasterHueRotate();
-    PropertyValue<float> getRasterHueRotate() const;
+    PropertyValue<float> getRasterHueRotate(const optional<std::string>& klass = {}) const;
     void setRasterHueRotate(PropertyValue<float>, const optional<std::string>& klass = {});
 
     static PropertyValue<float> getDefaultRasterBrightnessMin();
-    PropertyValue<float> getRasterBrightnessMin() const;
+    PropertyValue<float> getRasterBrightnessMin(const optional<std::string>& klass = {}) const;
     void setRasterBrightnessMin(PropertyValue<float>, const optional<std::string>& klass = {});
 
     static PropertyValue<float> getDefaultRasterBrightnessMax();
-    PropertyValue<float> getRasterBrightnessMax() const;
+    PropertyValue<float> getRasterBrightnessMax(const optional<std::string>& klass = {}) const;
     void setRasterBrightnessMax(PropertyValue<float>, const optional<std::string>& klass = {});
 
     static PropertyValue<float> getDefaultRasterSaturation();
-    PropertyValue<float> getRasterSaturation() const;
+    PropertyValue<float> getRasterSaturation(const optional<std::string>& klass = {}) const;
     void setRasterSaturation(PropertyValue<float>, const optional<std::string>& klass = {});
 
     static PropertyValue<float> getDefaultRasterContrast();
-    PropertyValue<float> getRasterContrast() const;
+    PropertyValue<float> getRasterContrast(const optional<std::string>& klass = {}) const;
     void setRasterContrast(PropertyValue<float>, const optional<std::string>& klass = {});
 
     static PropertyValue<float> getDefaultRasterFadeDuration();
-    PropertyValue<float> getRasterFadeDuration() const;
+    PropertyValue<float> getRasterFadeDuration(const optional<std::string>& klass = {}) const;
     void setRasterFadeDuration(PropertyValue<float>, const optional<std::string>& klass = {});
 
     // Private implementation
diff --git a/include/mbgl/style/layers/symbol_layer.hpp b/include/mbgl/style/layers/symbol_layer.hpp
index 5d1882fd4..1e2e6ac45 100644
--- a/include/mbgl/style/layers/symbol_layer.hpp
+++ b/include/mbgl/style/layers/symbol_layer.hpp
@@ -167,59 +167,59 @@ public:
     // Paint properties
 
     static PropertyValue<float> getDefaultIconOpacity();
-    PropertyValue<float> getIconOpacity() const;
+    PropertyValue<float> getIconOpacity(const optional<std::string>& klass = {}) const;
     void setIconOpacity(PropertyValue<float>, const optional<std::string>& klass = {});
 
     static PropertyValue<Color> getDefaultIconColor();
-    PropertyValue<Color> getIconColor() const;
+    PropertyValue<Color> getIconColor(const optional<std::string>& klass = {}) const;
     void setIconColor(PropertyValue<Color>, const optional<std::string>& klass = {});
 
     static PropertyValue<Color> getDefaultIconHaloColor();
-    PropertyValue<Color> getIconHaloColor() const;
+    PropertyValue<Color> getIconHaloColor(const optional<std::string>& klass = {}) const;
     void setIconHaloColor(PropertyValue<Color>, const optional<std::string>& klass = {});
 
     static PropertyValue<float> getDefaultIconHaloWidth();
-    PropertyValue<float> getIconHaloWidth() const;
+    PropertyValue<float> getIconHaloWidth(const optional<std::string>& klass = {}) const;
     void setIconHaloWidth(PropertyValue<float>, const optional<std::string>& klass = {});
 
     static PropertyValue<float> getDefaultIconHaloBlur();
-    PropertyValue<float> getIconHaloBlur() const;
+    PropertyValue<float> getIconHaloBlur(const optional<std::string>& klass = {}) const;
     void setIconHaloBlur(PropertyValue<float>, const optional<std::string>& klass = {});
 
     static PropertyValue<std::array<float, 2>> getDefaultIconTranslate();
-    PropertyValue<std::array<float, 2>> getIconTranslate() const;
+    PropertyValue<std::array<float, 2>> getIconTranslate(const optional<std::string>& klass = {}) const;
     void setIconTranslate(PropertyValue<std::array<float, 2>>, const optional<std::string>& klass = {});
 
     static PropertyValue<TranslateAnchorType> getDefaultIconTranslateAnchor();
-    PropertyValue<TranslateAnchorType> getIconTranslateAnchor() const;
+    PropertyValue<TranslateAnchorType> getIconTranslateAnchor(const optional<std::string>& klass = {}) const;
     void setIconTranslateAnchor(PropertyValue<TranslateAnchorType>, const optional<std::string>& klass = {});
 
     static PropertyValue<float> getDefaultTextOpacity();
-    PropertyValue<float> getTextOpacity() const;
+    PropertyValue<float> getTextOpacity(const optional<std::string>& klass = {}) const;
     void setTextOpacity(PropertyValue<float>, const optional<std::string>& klass = {});
 
     static PropertyValue<Color> getDefaultTextColor();
-    PropertyValue<Color> getTextColor() const;
+    PropertyValue<Color> getTextColor(const optional<std::string>& klass = {}) const;
     void setTextColor(PropertyValue<Color>, const optional<std::string>& klass = {});
 
     static PropertyValue<Color> getDefaultTextHaloColor();
-    PropertyValue<Color> getTextHaloColor() const;
+    PropertyValue<Color> getTextHaloColor(const optional<std::string>& klass = {}) const;
     void setTextHaloColor(PropertyValue<Color>, const optional<std::string>& klass = {});
 
     static PropertyValue<float> getDefaultTextHaloWidth();
-    PropertyValue<float> getTextHaloWidth() const;
+    PropertyValue<float> getTextHaloWidth(const optional<std::string>& klass = {}) const;
     void setTextHaloWidth(PropertyValue<float>, const optional<std::string>& klass = {});
 
     static PropertyValue<float> getDefaultTextHaloBlur();
-    PropertyValue<float> getTextHaloBlur() const;
+    PropertyValue<float> getTextHaloBlur(const optional<std::string>& klass = {}) const;
     void setTextHaloBlur(PropertyValue<float>, const optional<std::string>& klass = {});
 
     static PropertyValue<std::array<float, 2>> getDefaultTextTranslate();
-    PropertyValue<std::array<float, 2>> getTextTranslate() const;
+    PropertyValue<std::array<float, 2>> getTextTranslate(const optional<std::string>& klass = {}) const;
     void setTextTranslate(PropertyValue<std::array<float, 2>>, const optional<std::string>& klass = {});
 
     static PropertyValue<TranslateAnchorType> getDefaultTextTranslateAnchor();
-    PropertyValue<TranslateAnchorType> getTextTranslateAnchor() const;
+    PropertyValue<TranslateAnchorType> getTextTranslateAnchor(const optional<std::string>& klass = {}) const;
     void setTextTranslateAnchor(PropertyValue<TranslateAnchorType>, const optional<std::string>& klass = {});
 
     // Private implementation
diff --git a/src/mbgl/style/layers/background_layer.cpp b/src/mbgl/style/layers/background_layer.cpp
index e5747e07c..25de2a943 100644
--- a/src/mbgl/style/layers/background_layer.cpp
+++ b/src/mbgl/style/layers/background_layer.cpp
@@ -41,8 +41,8 @@ PropertyValue<Color> BackgroundLayer::getDefaultBackgroundColor() {
     return { Color::black() };
 }
 
-PropertyValue<Color> BackgroundLayer::getBackgroundColor() const {
-    return impl->paint.backgroundColor.get();
+PropertyValue<Color> BackgroundLayer::getBackgroundColor(const optional<std::string>& klass) const {
+    return impl->paint.backgroundColor.get(klass);
 }
 
 void BackgroundLayer::setBackgroundColor(PropertyValue<Color> value, const optional<std::string>& klass) {
@@ -53,8 +53,8 @@ PropertyValue<std::string> BackgroundLayer::getDefaultBackgroundPattern() {
     return { "" };
 }
 
-PropertyValue<std::string> BackgroundLayer::getBackgroundPattern() const {
-    return impl->paint.backgroundPattern.get();
+PropertyValue<std::string> BackgroundLayer::getBackgroundPattern(const optional<std::string>& klass) const {
+    return impl->paint.backgroundPattern.get(klass);
 }
 
 void BackgroundLayer::setBackgroundPattern(PropertyValue<std::string> value, const optional<std::string>& klass) {
@@ -65,8 +65,8 @@ PropertyValue<float> BackgroundLayer::getDefaultBackgroundOpacity() {
     return { 1 };
 }
 
-PropertyValue<float> BackgroundLayer::getBackgroundOpacity() const {
-    return impl->paint.backgroundOpacity.get();
+PropertyValue<float> BackgroundLayer::getBackgroundOpacity(const optional<std::string>& klass) const {
+    return impl->paint.backgroundOpacity.get(klass);
 }
 
 void BackgroundLayer::setBackgroundOpacity(PropertyValue<float> value, const optional<std::string>& klass) {
diff --git a/src/mbgl/style/layers/circle_layer.cpp b/src/mbgl/style/layers/circle_layer.cpp
index 271a573f0..5fa29d9d3 100644
--- a/src/mbgl/style/layers/circle_layer.cpp
+++ b/src/mbgl/style/layers/circle_layer.cpp
@@ -65,8 +65,8 @@ PropertyValue<float> CircleLayer::getDefaultCircleRadius() {
     return { 5 };
 }
 
-PropertyValue<float> CircleLayer::getCircleRadius() const {
-    return impl->paint.circleRadius.get();
+PropertyValue<float> CircleLayer::getCircleRadius(const optional<std::string>& klass) const {
+    return impl->paint.circleRadius.get(klass);
 }
 
 void CircleLayer::setCircleRadius(PropertyValue<float> value, const optional<std::string>& klass) {
@@ -77,8 +77,8 @@ PropertyValue<Color> CircleLayer::getDefaultCircleColor() {
     return { Color::black() };
 }
 
-PropertyValue<Color> CircleLayer::getCircleColor() const {
-    return impl->paint.circleColor.get();
+PropertyValue<Color> CircleLayer::getCircleColor(const optional<std::string>& klass) const {
+    return impl->paint.circleColor.get(klass);
 }
 
 void CircleLayer::setCircleColor(PropertyValue<Color> value, const optional<std::string>& klass) {
@@ -89,8 +89,8 @@ PropertyValue<float> CircleLayer::getDefaultCircleBlur() {
     return { 0 };
 }
 
-PropertyValue<float> CircleLayer::getCircleBlur() const {
-    return impl->paint.circleBlur.get();
+PropertyValue<float> CircleLayer::getCircleBlur(const optional<std::string>& klass) const {
+    return impl->paint.circleBlur.get(klass);
 }
 
 void CircleLayer::setCircleBlur(PropertyValue<float> value, const optional<std::string>& klass) {
@@ -101,8 +101,8 @@ PropertyValue<float> CircleLayer::getDefaultCircleOpacity() {
     return { 1 };
 }
 
-PropertyValue<float> CircleLayer::getCircleOpacity() const {
-    return impl->paint.circleOpacity.get();
+PropertyValue<float> CircleLayer::getCircleOpacity(const optional<std::string>& klass) const {
+    return impl->paint.circleOpacity.get(klass);
 }
 
 void CircleLayer::setCircleOpacity(PropertyValue<float> value, const optional<std::string>& klass) {
@@ -113,8 +113,8 @@ PropertyValue<std::array<float, 2>> CircleLayer::getDefaultCircleTranslate() {
     return { {{ 0, 0 }} };
 }
 
-PropertyValue<std::array<float, 2>> CircleLayer::getCircleTranslate() const {
-    return impl->paint.circleTranslate.get();
+PropertyValue<std::array<float, 2>> CircleLayer::getCircleTranslate(const optional<std::string>& klass) const {
+    return impl->paint.circleTranslate.get(klass);
 }
 
 void CircleLayer::setCircleTranslate(PropertyValue<std::array<float, 2>> value, const optional<std::string>& klass) {
@@ -125,8 +125,8 @@ PropertyValue<TranslateAnchorType> CircleLayer::getDefaultCircleTranslateAnchor(
     return { TranslateAnchorType::Map };
 }
 
-PropertyValue<TranslateAnchorType> CircleLayer::getCircleTranslateAnchor() const {
-    return impl->paint.circleTranslateAnchor.get();
+PropertyValue<TranslateAnchorType> CircleLayer::getCircleTranslateAnchor(const optional<std::string>& klass) const {
+    return impl->paint.circleTranslateAnchor.get(klass);
 }
 
 void CircleLayer::setCircleTranslateAnchor(PropertyValue<TranslateAnchorType> value, const optional<std::string>& klass) {
@@ -137,8 +137,8 @@ PropertyValue<CirclePitchScaleType> CircleLayer::getDefaultCirclePitchScale() {
     return { CirclePitchScaleType::Map };
 }
 
-PropertyValue<CirclePitchScaleType> CircleLayer::getCirclePitchScale() const {
-    return impl->paint.circlePitchScale.get();
+PropertyValue<CirclePitchScaleType> CircleLayer::getCirclePitchScale(const optional<std::string>& klass) const {
+    return impl->paint.circlePitchScale.get(klass);
 }
 
 void CircleLayer::setCirclePitchScale(PropertyValue<CirclePitchScaleType> value, const optional<std::string>& klass) {
diff --git a/src/mbgl/style/layers/fill_layer.cpp b/src/mbgl/style/layers/fill_layer.cpp
index 36febd77e..6bc4b892e 100644
--- a/src/mbgl/style/layers/fill_layer.cpp
+++ b/src/mbgl/style/layers/fill_layer.cpp
@@ -65,8 +65,8 @@ PropertyValue<bool> FillLayer::getDefaultFillAntialias() {
     return { true };
 }
 
-PropertyValue<bool> FillLayer::getFillAntialias() const {
-    return impl->paint.fillAntialias.get();
+PropertyValue<bool> FillLayer::getFillAntialias(const optional<std::string>& klass) const {
+    return impl->paint.fillAntialias.get(klass);
 }
 
 void FillLayer::setFillAntialias(PropertyValue<bool> value, const optional<std::string>& klass) {
@@ -77,8 +77,8 @@ PropertyValue<float> FillLayer::getDefaultFillOpacity() {
     return { 1 };
 }
 
-PropertyValue<float> FillLayer::getFillOpacity() const {
-    return impl->paint.fillOpacity.get();
+PropertyValue<float> FillLayer::getFillOpacity(const optional<std::string>& klass) const {
+    return impl->paint.fillOpacity.get(klass);
 }
 
 void FillLayer::setFillOpacity(PropertyValue<float> value, const optional<std::string>& klass) {
@@ -89,8 +89,8 @@ PropertyValue<Color> FillLayer::getDefaultFillColor() {
     return { Color::black() };
 }
 
-PropertyValue<Color> FillLayer::getFillColor() const {
-    return impl->paint.fillColor.get();
+PropertyValue<Color> FillLayer::getFillColor(const optional<std::string>& klass) const {
+    return impl->paint.fillColor.get(klass);
 }
 
 void FillLayer::setFillColor(PropertyValue<Color> value, const optional<std::string>& klass) {
@@ -101,8 +101,8 @@ PropertyValue<Color> FillLayer::getDefaultFillOutlineColor() {
     return { {} };
 }
 
-PropertyValue<Color> FillLayer::getFillOutlineColor() const {
-    return impl->paint.fillOutlineColor.get();
+PropertyValue<Color> FillLayer::getFillOutlineColor(const optional<std::string>& klass) const {
+    return impl->paint.fillOutlineColor.get(klass);
 }
 
 void FillLayer::setFillOutlineColor(PropertyValue<Color> value, const optional<std::string>& klass) {
@@ -113,8 +113,8 @@ PropertyValue<std::array<float, 2>> FillLayer::getDefaultFillTranslate() {
     return { {{ 0, 0 }} };
 }
 
-PropertyValue<std::array<float, 2>> FillLayer::getFillTranslate() const {
-    return impl->paint.fillTranslate.get();
+PropertyValue<std::array<float, 2>> FillLayer::getFillTranslate(const optional<std::string>& klass) const {
+    return impl->paint.fillTranslate.get(klass);
 }
 
 void FillLayer::setFillTranslate(PropertyValue<std::array<float, 2>> value, const optional<std::string>& klass) {
@@ -125,8 +125,8 @@ PropertyValue<TranslateAnchorType> FillLayer::getDefaultFillTranslateAnchor() {
     return { TranslateAnchorType::Map };
 }
 
-PropertyValue<TranslateAnchorType> FillLayer::getFillTranslateAnchor() const {
-    return impl->paint.fillTranslateAnchor.get();
+PropertyValue<TranslateAnchorType> FillLayer::getFillTranslateAnchor(const optional<std::string>& klass) const {
+    return impl->paint.fillTranslateAnchor.get(klass);
 }
 
 void FillLayer::setFillTranslateAnchor(PropertyValue<TranslateAnchorType> value, const optional<std::string>& klass) {
@@ -137,8 +137,8 @@ PropertyValue<std::string> FillLayer::getDefaultFillPattern() {
     return { "" };
 }
 
-PropertyValue<std::string> FillLayer::getFillPattern() const {
-    return impl->paint.fillPattern.get();
+PropertyValue<std::string> FillLayer::getFillPattern(const optional<std::string>& klass) const {
+    return impl->paint.fillPattern.get(klass);
 }
 
 void FillLayer::setFillPattern(PropertyValue<std::string> value, const optional<std::string>& klass) {
diff --git a/src/mbgl/style/layers/layer.cpp.ejs b/src/mbgl/style/layers/layer.cpp.ejs
index 16a137a00..75a8de8e7 100644
--- a/src/mbgl/style/layers/layer.cpp.ejs
+++ b/src/mbgl/style/layers/layer.cpp.ejs
@@ -95,8 +95,8 @@ PropertyValue<<%- propertyType(property) %>> <%- camelize(type) %>Layer::getDefa
     return { <%- defaultValue(property) %> };
 }
 
-PropertyValue<<%- propertyType(property) %>> <%- camelize(type) %>Layer::get<%- camelize(property.name) %>() const {
-    return impl->paint.<%- camelizeWithLeadingLowercase(property.name) %>.get();
+PropertyValue<<%- propertyType(property) %>> <%- camelize(type) %>Layer::get<%- camelize(property.name) %>(const optional<std::string>& klass) const {
+    return impl->paint.<%- camelizeWithLeadingLowercase(property.name) %>.get(klass);
 }
 
 void <%- camelize(type) %>Layer::set<%- camelize(property.name) %>(PropertyValue<<%- propertyType(property) %>> value, const optional<std::string>& klass) {
diff --git a/src/mbgl/style/layers/line_layer.cpp b/src/mbgl/style/layers/line_layer.cpp
index 1594985b6..dbf4b682b 100644
--- a/src/mbgl/style/layers/line_layer.cpp
+++ b/src/mbgl/style/layers/line_layer.cpp
@@ -109,8 +109,8 @@ PropertyValue<float> LineLayer::getDefaultLineOpacity() {
     return { 1 };
 }
 
-PropertyValue<float> LineLayer::getLineOpacity() const {
-    return impl->paint.lineOpacity.get();
+PropertyValue<float> LineLayer::getLineOpacity(const optional<std::string>& klass) const {
+    return impl->paint.lineOpacity.get(klass);
 }
 
 void LineLayer::setLineOpacity(PropertyValue<float> value, const optional<std::string>& klass) {
@@ -121,8 +121,8 @@ PropertyValue<Color> LineLayer::getDefaultLineColor() {
     return { Color::black() };
 }
 
-PropertyValue<Color> LineLayer::getLineColor() const {
-    return impl->paint.lineColor.get();
+PropertyValue<Color> LineLayer::getLineColor(const optional<std::string>& klass) const {
+    return impl->paint.lineColor.get(klass);
 }
 
 void LineLayer::setLineColor(PropertyValue<Color> value, const optional<std::string>& klass) {
@@ -133,8 +133,8 @@ PropertyValue<std::array<float, 2>> LineLayer::getDefaultLineTranslate() {
     return { {{ 0, 0 }} };
 }
 
-PropertyValue<std::array<float, 2>> LineLayer::getLineTranslate() const {
-    return impl->paint.lineTranslate.get();
+PropertyValue<std::array<float, 2>> LineLayer::getLineTranslate(const optional<std::string>& klass) const {
+    return impl->paint.lineTranslate.get(klass);
 }
 
 void LineLayer::setLineTranslate(PropertyValue<std::array<float, 2>> value, const optional<std::string>& klass) {
@@ -145,8 +145,8 @@ PropertyValue<TranslateAnchorType> LineLayer::getDefaultLineTranslateAnchor() {
     return { TranslateAnchorType::Map };
 }
 
-PropertyValue<TranslateAnchorType> LineLayer::getLineTranslateAnchor() const {
-    return impl->paint.lineTranslateAnchor.get();
+PropertyValue<TranslateAnchorType> LineLayer::getLineTranslateAnchor(const optional<std::string>& klass) const {
+    return impl->paint.lineTranslateAnchor.get(klass);
 }
 
 void LineLayer::setLineTranslateAnchor(PropertyValue<TranslateAnchorType> value, const optional<std::string>& klass) {
@@ -157,8 +157,8 @@ PropertyValue<float> LineLayer::getDefaultLineWidth() {
     return { 1 };
 }
 
-PropertyValue<float> LineLayer::getLineWidth() const {
-    return impl->paint.lineWidth.get();
+PropertyValue<float> LineLayer::getLineWidth(const optional<std::string>& klass) const {
+    return impl->paint.lineWidth.get(klass);
 }
 
 void LineLayer::setLineWidth(PropertyValue<float> value, const optional<std::string>& klass) {
@@ -169,8 +169,8 @@ PropertyValue<float> LineLayer::getDefaultLineGapWidth() {
     return { 0 };
 }
 
-PropertyValue<float> LineLayer::getLineGapWidth() const {
-    return impl->paint.lineGapWidth.get();
+PropertyValue<float> LineLayer::getLineGapWidth(const optional<std::string>& klass) const {
+    return impl->paint.lineGapWidth.get(klass);
 }
 
 void LineLayer::setLineGapWidth(PropertyValue<float> value, const optional<std::string>& klass) {
@@ -181,8 +181,8 @@ PropertyValue<float> LineLayer::getDefaultLineOffset() {
     return { 0 };
 }
 
-PropertyValue<float> LineLayer::getLineOffset() const {
-    return impl->paint.lineOffset.get();
+PropertyValue<float> LineLayer::getLineOffset(const optional<std::string>& klass) const {
+    return impl->paint.lineOffset.get(klass);
 }
 
 void LineLayer::setLineOffset(PropertyValue<float> value, const optional<std::string>& klass) {
@@ -193,8 +193,8 @@ PropertyValue<float> LineLayer::getDefaultLineBlur() {
     return { 0 };
 }
 
-PropertyValue<float> LineLayer::getLineBlur() const {
-    return impl->paint.lineBlur.get();
+PropertyValue<float> LineLayer::getLineBlur(const optional<std::string>& klass) const {
+    return impl->paint.lineBlur.get(klass);
 }
 
 void LineLayer::setLineBlur(PropertyValue<float> value, const optional<std::string>& klass) {
@@ -205,8 +205,8 @@ PropertyValue<std::vector<float>> LineLayer::getDefaultLineDasharray() {
     return { {  } };
 }
 
-PropertyValue<std::vector<float>> LineLayer::getLineDasharray() const {
-    return impl->paint.lineDasharray.get();
+PropertyValue<std::vector<float>> LineLayer::getLineDasharray(const optional<std::string>& klass) const {
+    return impl->paint.lineDasharray.get(klass);
 }
 
 void LineLayer::setLineDasharray(PropertyValue<std::vector<float>> value, const optional<std::string>& klass) {
@@ -217,8 +217,8 @@ PropertyValue<std::string> LineLayer::getDefaultLinePattern() {
     return { "" };
 }
 
-PropertyValue<std::string> LineLayer::getLinePattern() const {
-    return impl->paint.linePattern.get();
+PropertyValue<std::string> LineLayer::getLinePattern(const optional<std::string>& klass) const {
+    return impl->paint.linePattern.get(klass);
 }
 
 void LineLayer::setLinePattern(PropertyValue<std::string> value, const optional<std::string>& klass) {
diff --git a/src/mbgl/style/layers/raster_layer.cpp b/src/mbgl/style/layers/raster_layer.cpp
index fc966f223..084b29ee3 100644
--- a/src/mbgl/style/layers/raster_layer.cpp
+++ b/src/mbgl/style/layers/raster_layer.cpp
@@ -48,8 +48,8 @@ PropertyValue<float> RasterLayer::getDefaultRasterOpacity() {
     return { 1 };
 }
 
-PropertyValue<float> RasterLayer::getRasterOpacity() const {
-    return impl->paint.rasterOpacity.get();
+PropertyValue<float> RasterLayer::getRasterOpacity(const optional<std::string>& klass) const {
+    return impl->paint.rasterOpacity.get(klass);
 }
 
 void RasterLayer::setRasterOpacity(PropertyValue<float> value, const optional<std::string>& klass) {
@@ -60,8 +60,8 @@ PropertyValue<float> RasterLayer::getDefaultRasterHueRotate() {
     return { 0 };
 }
 
-PropertyValue<float> RasterLayer::getRasterHueRotate() const {
-    return impl->paint.rasterHueRotate.get();
+PropertyValue<float> RasterLayer::getRasterHueRotate(const optional<std::string>& klass) const {
+    return impl->paint.rasterHueRotate.get(klass);
 }
 
 void RasterLayer::setRasterHueRotate(PropertyValue<float> value, const optional<std::string>& klass) {
@@ -72,8 +72,8 @@ PropertyValue<float> RasterLayer::getDefaultRasterBrightnessMin() {
     return { 0 };
 }
 
-PropertyValue<float> RasterLayer::getRasterBrightnessMin() const {
-    return impl->paint.rasterBrightnessMin.get();
+PropertyValue<float> RasterLayer::getRasterBrightnessMin(const optional<std::string>& klass) const {
+    return impl->paint.rasterBrightnessMin.get(klass);
 }
 
 void RasterLayer::setRasterBrightnessMin(PropertyValue<float> value, const optional<std::string>& klass) {
@@ -84,8 +84,8 @@ PropertyValue<float> RasterLayer::getDefaultRasterBrightnessMax() {
     return { 1 };
 }
 
-PropertyValue<float> RasterLayer::getRasterBrightnessMax() const {
-    return impl->paint.rasterBrightnessMax.get();
+PropertyValue<float> RasterLayer::getRasterBrightnessMax(const optional<std::string>& klass) const {
+    return impl->paint.rasterBrightnessMax.get(klass);
 }
 
 void RasterLayer::setRasterBrightnessMax(PropertyValue<float> value, const optional<std::string>& klass) {
@@ -96,8 +96,8 @@ PropertyValue<float> RasterLayer::getDefaultRasterSaturation() {
     return { 0 };
 }
 
-PropertyValue<float> RasterLayer::getRasterSaturation() const {
-    return impl->paint.rasterSaturation.get();
+PropertyValue<float> RasterLayer::getRasterSaturation(const optional<std::string>& klass) const {
+    return impl->paint.rasterSaturation.get(klass);
 }
 
 void RasterLayer::setRasterSaturation(PropertyValue<float> value, const optional<std::string>& klass) {
@@ -108,8 +108,8 @@ PropertyValue<float> RasterLayer::getDefaultRasterContrast() {
     return { 0 };
 }
 
-PropertyValue<float> RasterLayer::getRasterContrast() const {
-    return impl->paint.rasterContrast.get();
+PropertyValue<float> RasterLayer::getRasterContrast(const optional<std::string>& klass) const {
+    return impl->paint.rasterContrast.get(klass);
 }
 
 void RasterLayer::setRasterContrast(PropertyValue<float> value, const optional<std::string>& klass) {
@@ -120,8 +120,8 @@ PropertyValue<float> RasterLayer::getDefaultRasterFadeDuration() {
     return { 300 };
 }
 
-PropertyValue<float> RasterLayer::getRasterFadeDuration() const {
-    return impl->paint.rasterFadeDuration.get();
+PropertyValue<float> RasterLayer::getRasterFadeDuration(const optional<std::string>& klass) const {
+    return impl->paint.rasterFadeDuration.get(klass);
 }
 
 void RasterLayer::setRasterFadeDuration(PropertyValue<float> value, const optional<std::string>& klass) {
diff --git a/src/mbgl/style/layers/symbol_layer.cpp b/src/mbgl/style/layers/symbol_layer.cpp
index 7852969f7..78fbfda6d 100644
--- a/src/mbgl/style/layers/symbol_layer.cpp
+++ b/src/mbgl/style/layers/symbol_layer.cpp
@@ -439,8 +439,8 @@ PropertyValue<float> SymbolLayer::getDefaultIconOpacity() {
     return { 1 };
 }
 
-PropertyValue<float> SymbolLayer::getIconOpacity() const {
-    return impl->paint.iconOpacity.get();
+PropertyValue<float> SymbolLayer::getIconOpacity(const optional<std::string>& klass) const {
+    return impl->paint.iconOpacity.get(klass);
 }
 
 void SymbolLayer::setIconOpacity(PropertyValue<float> value, const optional<std::string>& klass) {
@@ -451,8 +451,8 @@ PropertyValue<Color> SymbolLayer::getDefaultIconColor() {
     return { Color::black() };
 }
 
-PropertyValue<Color> SymbolLayer::getIconColor() const {
-    return impl->paint.iconColor.get();
+PropertyValue<Color> SymbolLayer::getIconColor(const optional<std::string>& klass) const {
+    return impl->paint.iconColor.get(klass);
 }
 
 void SymbolLayer::setIconColor(PropertyValue<Color> value, const optional<std::string>& klass) {
@@ -463,8 +463,8 @@ PropertyValue<Color> SymbolLayer::getDefaultIconHaloColor() {
     return { {} };
 }
 
-PropertyValue<Color> SymbolLayer::getIconHaloColor() const {
-    return impl->paint.iconHaloColor.get();
+PropertyValue<Color> SymbolLayer::getIconHaloColor(const optional<std::string>& klass) const {
+    return impl->paint.iconHaloColor.get(klass);
 }
 
 void SymbolLayer::setIconHaloColor(PropertyValue<Color> value, const optional<std::string>& klass) {
@@ -475,8 +475,8 @@ PropertyValue<float> SymbolLayer::getDefaultIconHaloWidth() {
     return { 0 };
 }
 
-PropertyValue<float> SymbolLayer::getIconHaloWidth() const {
-    return impl->paint.iconHaloWidth.get();
+PropertyValue<float> SymbolLayer::getIconHaloWidth(const optional<std::string>& klass) const {
+    return impl->paint.iconHaloWidth.get(klass);
 }
 
 void SymbolLayer::setIconHaloWidth(PropertyValue<float> value, const optional<std::string>& klass) {
@@ -487,8 +487,8 @@ PropertyValue<float> SymbolLayer::getDefaultIconHaloBlur() {
     return { 0 };
 }
 
-PropertyValue<float> SymbolLayer::getIconHaloBlur() const {
-    return impl->paint.iconHaloBlur.get();
+PropertyValue<float> SymbolLayer::getIconHaloBlur(const optional<std::string>& klass) const {
+    return impl->paint.iconHaloBlur.get(klass);
 }
 
 void SymbolLayer::setIconHaloBlur(PropertyValue<float> value, const optional<std::string>& klass) {
@@ -499,8 +499,8 @@ PropertyValue<std::array<float, 2>> SymbolLayer::getDefaultIconTranslate() {
     return { {{ 0, 0 }} };
 }
 
-PropertyValue<std::array<float, 2>> SymbolLayer::getIconTranslate() const {
-    return impl->paint.iconTranslate.get();
+PropertyValue<std::array<float, 2>> SymbolLayer::getIconTranslate(const optional<std::string>& klass) const {
+    return impl->paint.iconTranslate.get(klass);
 }
 
 void SymbolLayer::setIconTranslate(PropertyValue<std::array<float, 2>> value, const optional<std::string>& klass) {
@@ -511,8 +511,8 @@ PropertyValue<TranslateAnchorType> SymbolLayer::getDefaultIconTranslateAnchor()
     return { TranslateAnchorType::Map };
 }
 
-PropertyValue<TranslateAnchorType> SymbolLayer::getIconTranslateAnchor() const {
-    return impl->paint.iconTranslateAnchor.get();
+PropertyValue<TranslateAnchorType> SymbolLayer::getIconTranslateAnchor(const optional<std::string>& klass) const {
+    return impl->paint.iconTranslateAnchor.get(klass);
 }
 
 void SymbolLayer::setIconTranslateAnchor(PropertyValue<TranslateAnchorType> value, const optional<std::string>& klass) {
@@ -523,8 +523,8 @@ PropertyValue<float> SymbolLayer::getDefaultTextOpacity() {
     return { 1 };
 }
 
-PropertyValue<float> SymbolLayer::getTextOpacity() const {
-    return impl->paint.textOpacity.get();
+PropertyValue<float> SymbolLayer::getTextOpacity(const optional<std::string>& klass) const {
+    return impl->paint.textOpacity.get(klass);
 }
 
 void SymbolLayer::setTextOpacity(PropertyValue<float> value, const optional<std::string>& klass) {
@@ -535,8 +535,8 @@ PropertyValue<Color> SymbolLayer::getDefaultTextColor() {
     return { Color::black() };
 }
 
-PropertyValue<Color> SymbolLayer::getTextColor() const {
-    return impl->paint.textColor.get();
+PropertyValue<Color> SymbolLayer::getTextColor(const optional<std::string>& klass) const {
+    return impl->paint.textColor.get(klass);
 }
 
 void SymbolLayer::setTextColor(PropertyValue<Color> value, const optional<std::string>& klass) {
@@ -547,8 +547,8 @@ PropertyValue<Color> SymbolLayer::getDefaultTextHaloColor() {
     return { {} };
 }
 
-PropertyValue<Color> SymbolLayer::getTextHaloColor() const {
-    return impl->paint.textHaloColor.get();
+PropertyValue<Color> SymbolLayer::getTextHaloColor(const optional<std::string>& klass) const {
+    return impl->paint.textHaloColor.get(klass);
 }
 
 void SymbolLayer::setTextHaloColor(PropertyValue<Color> value, const optional<std::string>& klass) {
@@ -559,8 +559,8 @@ PropertyValue<float> SymbolLayer::getDefaultTextHaloWidth() {
     return { 0 };
 }
 
-PropertyValue<float> SymbolLayer::getTextHaloWidth() const {
-    return impl->paint.textHaloWidth.get();
+PropertyValue<float> SymbolLayer::getTextHaloWidth(const optional<std::string>& klass) const {
+    return impl->paint.textHaloWidth.get(klass);
 }
 
 void SymbolLayer::setTextHaloWidth(PropertyValue<float> value, const optional<std::string>& klass) {
@@ -571,8 +571,8 @@ PropertyValue<float> SymbolLayer::getDefaultTextHaloBlur() {
     return { 0 };
 }
 
-PropertyValue<float> SymbolLayer::getTextHaloBlur() const {
-    return impl->paint.textHaloBlur.get();
+PropertyValue<float> SymbolLayer::getTextHaloBlur(const optional<std::string>& klass) const {
+    return impl->paint.textHaloBlur.get(klass);
 }
 
 void SymbolLayer::setTextHaloBlur(PropertyValue<float> value, const optional<std::string>& klass) {
@@ -583,8 +583,8 @@ PropertyValue<std::array<float, 2>> SymbolLayer::getDefaultTextTranslate() {
     return { {{ 0, 0 }} };
 }
 
-PropertyValue<std::array<float, 2>> SymbolLayer::getTextTranslate() const {
-    return impl->paint.textTranslate.get();
+PropertyValue<std::array<float, 2>> SymbolLayer::getTextTranslate(const optional<std::string>& klass) const {
+    return impl->paint.textTranslate.get(klass);
 }
 
 void SymbolLayer::setTextTranslate(PropertyValue<std::array<float, 2>> value, const optional<std::string>& klass) {
@@ -595,8 +595,8 @@ PropertyValue<TranslateAnchorType> SymbolLayer::getDefaultTextTranslateAnchor()
     return { TranslateAnchorType::Map };
 }
 
-PropertyValue<TranslateAnchorType> SymbolLayer::getTextTranslateAnchor() const {
-    return impl->paint.textTranslateAnchor.get();
+PropertyValue<TranslateAnchorType> SymbolLayer::getTextTranslateAnchor(const optional<std::string>& klass) const {
+    return impl->paint.textTranslateAnchor.get(klass);
 }
 
 void SymbolLayer::setTextTranslateAnchor(PropertyValue<TranslateAnchorType> value, const optional<std::string>& klass) {
diff --git a/src/mbgl/style/paint_property.hpp b/src/mbgl/style/paint_property.hpp
index 6da1ed53b..070751616 100644
--- a/src/mbgl/style/paint_property.hpp
+++ b/src/mbgl/style/paint_property.hpp
@@ -43,9 +43,9 @@ public:
         return values.find(ClassID::Default) == values.end();
     }
 
-    const PropertyValue<T>& get() const {
+    const PropertyValue<T>& get(const optional<std::string>& klass) const {
         static const PropertyValue<T> staticValue;
-        const auto it = values.find(ClassID::Default);
+        const auto it = values.find(klass ? ClassDictionary::Get().lookup(*klass) : ClassID::Default);
         return it == values.end() ? staticValue : it->second;
     }