[core, node, darwin, qt] Remove support for paint classes

1 files changed, 63 insertions, 63 deletions

diff --git a/src/mbgl/style/layers/raster_layer.cpp b/src/mbgl/style/layers/raster_layer.cpp
index fc28672abd..a7a32768b6 100644
--- a/src/mbgl/style/layers/raster_layer.cpp
+++ b/src/mbgl/style/layers/raster_layer.cpp
@@ -76,189 +76,189 @@ PropertyValue<float> RasterLayer::getDefaultRasterOpacity() {
     return { 1 };
 }
 
-PropertyValue<float> RasterLayer::getRasterOpacity(const optional<std::string>& klass) const {
-    return impl().paint.template get<RasterOpacity>().get(klass);
+PropertyValue<float> RasterLayer::getRasterOpacity() const {
+    return impl().paint.template get<RasterOpacity>().value;
 }
 
-void RasterLayer::setRasterOpacity(PropertyValue<float> value, const optional<std::string>& klass) {
-    if (value == getRasterOpacity(klass))
+void RasterLayer::setRasterOpacity(PropertyValue<float> value) {
+    if (value == getRasterOpacity())
         return;
     auto impl_ = mutableImpl();
-    impl_->paint.template get<RasterOpacity>().set(value, klass);
+    impl_->paint.template get<RasterOpacity>().value = value;
     baseImpl = std::move(impl_);
     observer->onLayerPaintPropertyChanged(*this);
 }
 
-void RasterLayer::setRasterOpacityTransition(const TransitionOptions& value, const optional<std::string>& klass) {
+void RasterLayer::setRasterOpacityTransition(const TransitionOptions& options) {
     auto impl_ = mutableImpl();
-    impl_->paint.template get<RasterOpacity>().setTransition(value, klass);
+    impl_->paint.template get<RasterOpacity>().options = options;
     baseImpl = std::move(impl_);
 }
 
-TransitionOptions RasterLayer::getRasterOpacityTransition(const optional<std::string>& klass) const {
-    return impl().paint.template get<RasterOpacity>().getTransition(klass);
+TransitionOptions RasterLayer::getRasterOpacityTransition() const {
+    return impl().paint.template get<RasterOpacity>().options;
 }
 
 PropertyValue<float> RasterLayer::getDefaultRasterHueRotate() {
     return { 0 };
 }
 
-PropertyValue<float> RasterLayer::getRasterHueRotate(const optional<std::string>& klass) const {
-    return impl().paint.template get<RasterHueRotate>().get(klass);
+PropertyValue<float> RasterLayer::getRasterHueRotate() const {
+    return impl().paint.template get<RasterHueRotate>().value;
 }
 
-void RasterLayer::setRasterHueRotate(PropertyValue<float> value, const optional<std::string>& klass) {
-    if (value == getRasterHueRotate(klass))
+void RasterLayer::setRasterHueRotate(PropertyValue<float> value) {
+    if (value == getRasterHueRotate())
         return;
     auto impl_ = mutableImpl();
-    impl_->paint.template get<RasterHueRotate>().set(value, klass);
+    impl_->paint.template get<RasterHueRotate>().value = value;
     baseImpl = std::move(impl_);
     observer->onLayerPaintPropertyChanged(*this);
 }
 
-void RasterLayer::setRasterHueRotateTransition(const TransitionOptions& value, const optional<std::string>& klass) {
+void RasterLayer::setRasterHueRotateTransition(const TransitionOptions& options) {
     auto impl_ = mutableImpl();
-    impl_->paint.template get<RasterHueRotate>().setTransition(value, klass);
+    impl_->paint.template get<RasterHueRotate>().options = options;
     baseImpl = std::move(impl_);
 }
 
-TransitionOptions RasterLayer::getRasterHueRotateTransition(const optional<std::string>& klass) const {
-    return impl().paint.template get<RasterHueRotate>().getTransition(klass);
+TransitionOptions RasterLayer::getRasterHueRotateTransition() const {
+    return impl().paint.template get<RasterHueRotate>().options;
 }
 
 PropertyValue<float> RasterLayer::getDefaultRasterBrightnessMin() {
     return { 0 };
 }
 
-PropertyValue<float> RasterLayer::getRasterBrightnessMin(const optional<std::string>& klass) const {
-    return impl().paint.template get<RasterBrightnessMin>().get(klass);
+PropertyValue<float> RasterLayer::getRasterBrightnessMin() const {
+    return impl().paint.template get<RasterBrightnessMin>().value;
 }
 
-void RasterLayer::setRasterBrightnessMin(PropertyValue<float> value, const optional<std::string>& klass) {
-    if (value == getRasterBrightnessMin(klass))
+void RasterLayer::setRasterBrightnessMin(PropertyValue<float> value) {
+    if (value == getRasterBrightnessMin())
         return;
     auto impl_ = mutableImpl();
-    impl_->paint.template get<RasterBrightnessMin>().set(value, klass);
+    impl_->paint.template get<RasterBrightnessMin>().value = value;
     baseImpl = std::move(impl_);
     observer->onLayerPaintPropertyChanged(*this);
 }
 
-void RasterLayer::setRasterBrightnessMinTransition(const TransitionOptions& value, const optional<std::string>& klass) {
+void RasterLayer::setRasterBrightnessMinTransition(const TransitionOptions& options) {
     auto impl_ = mutableImpl();
-    impl_->paint.template get<RasterBrightnessMin>().setTransition(value, klass);
+    impl_->paint.template get<RasterBrightnessMin>().options = options;
     baseImpl = std::move(impl_);
 }
 
-TransitionOptions RasterLayer::getRasterBrightnessMinTransition(const optional<std::string>& klass) const {
-    return impl().paint.template get<RasterBrightnessMin>().getTransition(klass);
+TransitionOptions RasterLayer::getRasterBrightnessMinTransition() const {
+    return impl().paint.template get<RasterBrightnessMin>().options;
 }
 
 PropertyValue<float> RasterLayer::getDefaultRasterBrightnessMax() {
     return { 1 };
 }
 
-PropertyValue<float> RasterLayer::getRasterBrightnessMax(const optional<std::string>& klass) const {
-    return impl().paint.template get<RasterBrightnessMax>().get(klass);
+PropertyValue<float> RasterLayer::getRasterBrightnessMax() const {
+    return impl().paint.template get<RasterBrightnessMax>().value;
 }
 
-void RasterLayer::setRasterBrightnessMax(PropertyValue<float> value, const optional<std::string>& klass) {
-    if (value == getRasterBrightnessMax(klass))
+void RasterLayer::setRasterBrightnessMax(PropertyValue<float> value) {
+    if (value == getRasterBrightnessMax())
         return;
     auto impl_ = mutableImpl();
-    impl_->paint.template get<RasterBrightnessMax>().set(value, klass);
+    impl_->paint.template get<RasterBrightnessMax>().value = value;
     baseImpl = std::move(impl_);
     observer->onLayerPaintPropertyChanged(*this);
 }
 
-void RasterLayer::setRasterBrightnessMaxTransition(const TransitionOptions& value, const optional<std::string>& klass) {
+void RasterLayer::setRasterBrightnessMaxTransition(const TransitionOptions& options) {
     auto impl_ = mutableImpl();
-    impl_->paint.template get<RasterBrightnessMax>().setTransition(value, klass);
+    impl_->paint.template get<RasterBrightnessMax>().options = options;
     baseImpl = std::move(impl_);
 }
 
-TransitionOptions RasterLayer::getRasterBrightnessMaxTransition(const optional<std::string>& klass) const {
-    return impl().paint.template get<RasterBrightnessMax>().getTransition(klass);
+TransitionOptions RasterLayer::getRasterBrightnessMaxTransition() const {
+    return impl().paint.template get<RasterBrightnessMax>().options;
 }
 
 PropertyValue<float> RasterLayer::getDefaultRasterSaturation() {
     return { 0 };
 }
 
-PropertyValue<float> RasterLayer::getRasterSaturation(const optional<std::string>& klass) const {
-    return impl().paint.template get<RasterSaturation>().get(klass);
+PropertyValue<float> RasterLayer::getRasterSaturation() const {
+    return impl().paint.template get<RasterSaturation>().value;
 }
 
-void RasterLayer::setRasterSaturation(PropertyValue<float> value, const optional<std::string>& klass) {
-    if (value == getRasterSaturation(klass))
+void RasterLayer::setRasterSaturation(PropertyValue<float> value) {
+    if (value == getRasterSaturation())
         return;
     auto impl_ = mutableImpl();
-    impl_->paint.template get<RasterSaturation>().set(value, klass);
+    impl_->paint.template get<RasterSaturation>().value = value;
     baseImpl = std::move(impl_);
     observer->onLayerPaintPropertyChanged(*this);
 }
 
-void RasterLayer::setRasterSaturationTransition(const TransitionOptions& value, const optional<std::string>& klass) {
+void RasterLayer::setRasterSaturationTransition(const TransitionOptions& options) {
     auto impl_ = mutableImpl();
-    impl_->paint.template get<RasterSaturation>().setTransition(value, klass);
+    impl_->paint.template get<RasterSaturation>().options = options;
     baseImpl = std::move(impl_);
 }
 
-TransitionOptions RasterLayer::getRasterSaturationTransition(const optional<std::string>& klass) const {
-    return impl().paint.template get<RasterSaturation>().getTransition(klass);
+TransitionOptions RasterLayer::getRasterSaturationTransition() const {
+    return impl().paint.template get<RasterSaturation>().options;
 }
 
 PropertyValue<float> RasterLayer::getDefaultRasterContrast() {
     return { 0 };
 }
 
-PropertyValue<float> RasterLayer::getRasterContrast(const optional<std::string>& klass) const {
-    return impl().paint.template get<RasterContrast>().get(klass);
+PropertyValue<float> RasterLayer::getRasterContrast() const {
+    return impl().paint.template get<RasterContrast>().value;
 }
 
-void RasterLayer::setRasterContrast(PropertyValue<float> value, const optional<std::string>& klass) {
-    if (value == getRasterContrast(klass))
+void RasterLayer::setRasterContrast(PropertyValue<float> value) {
+    if (value == getRasterContrast())
         return;
     auto impl_ = mutableImpl();
-    impl_->paint.template get<RasterContrast>().set(value, klass);
+    impl_->paint.template get<RasterContrast>().value = value;
     baseImpl = std::move(impl_);
     observer->onLayerPaintPropertyChanged(*this);
 }
 
-void RasterLayer::setRasterContrastTransition(const TransitionOptions& value, const optional<std::string>& klass) {
+void RasterLayer::setRasterContrastTransition(const TransitionOptions& options) {
     auto impl_ = mutableImpl();
-    impl_->paint.template get<RasterContrast>().setTransition(value, klass);
+    impl_->paint.template get<RasterContrast>().options = options;
     baseImpl = std::move(impl_);
 }
 
-TransitionOptions RasterLayer::getRasterContrastTransition(const optional<std::string>& klass) const {
-    return impl().paint.template get<RasterContrast>().getTransition(klass);
+TransitionOptions RasterLayer::getRasterContrastTransition() const {
+    return impl().paint.template get<RasterContrast>().options;
 }
 
 PropertyValue<float> RasterLayer::getDefaultRasterFadeDuration() {
     return { 300 };
 }
 
-PropertyValue<float> RasterLayer::getRasterFadeDuration(const optional<std::string>& klass) const {
-    return impl().paint.template get<RasterFadeDuration>().get(klass);
+PropertyValue<float> RasterLayer::getRasterFadeDuration() const {
+    return impl().paint.template get<RasterFadeDuration>().value;
 }
 
-void RasterLayer::setRasterFadeDuration(PropertyValue<float> value, const optional<std::string>& klass) {
-    if (value == getRasterFadeDuration(klass))
+void RasterLayer::setRasterFadeDuration(PropertyValue<float> value) {
+    if (value == getRasterFadeDuration())
         return;
     auto impl_ = mutableImpl();
-    impl_->paint.template get<RasterFadeDuration>().set(value, klass);
+    impl_->paint.template get<RasterFadeDuration>().value = value;
     baseImpl = std::move(impl_);
     observer->onLayerPaintPropertyChanged(*this);
 }
 
-void RasterLayer::setRasterFadeDurationTransition(const TransitionOptions& value, const optional<std::string>& klass) {
+void RasterLayer::setRasterFadeDurationTransition(const TransitionOptions& options) {
     auto impl_ = mutableImpl();
-    impl_->paint.template get<RasterFadeDuration>().setTransition(value, klass);
+    impl_->paint.template get<RasterFadeDuration>().options = options;
     baseImpl = std::move(impl_);
 }
 
-TransitionOptions RasterLayer::getRasterFadeDurationTransition(const optional<std::string>& klass) const {
-    return impl().paint.template get<RasterFadeDuration>().getTransition(klass);
+TransitionOptions RasterLayer::getRasterFadeDurationTransition() const {
+    return impl().paint.template get<RasterFadeDuration>().options;
 }
 
 } // namespace style