1 files changed, 67 insertions, 33 deletions

diff --git a/src/mbgl/style/layers/layer.cpp.ejs b/src/mbgl/style/layers/layer.cpp.ejs
index 2f690c3158..31a4332400 100644
--- a/src/mbgl/style/layers/layer.cpp.ejs
+++ b/src/mbgl/style/layers/layer.cpp.ejs
@@ -8,41 +8,40 @@
 #include <mbgl/style/layers/<%- type.replace('-', '_') %>_layer.hpp>
 #include <mbgl/style/layers/<%- type.replace('-', '_') %>_layer_impl.hpp>
 #include <mbgl/style/conversion/stringify.hpp>
+#include <mbgl/style/layer_observer.hpp>
 
 namespace mbgl {
 namespace style {
 
 <% if (type === 'background') { -%>
 <%- camelize(type) %>Layer::<%- camelize(type) %>Layer(const std::string& layerID)
-    : Layer(LayerType::<%- camelize(type) %>, std::make_unique<Impl>())
-    , impl(static_cast<Impl*>(baseImpl.get())) {
-    impl->id = layerID;
+    : Layer(makeMutable<Impl>(LayerType::<%- camelize(type) %>, layerID, std::string())) {
 }
 <% } else { -%>
 <%- camelize(type) %>Layer::<%- camelize(type) %>Layer(const std::string& layerID, const std::string& sourceID)
-    : Layer(LayerType::<%- camelize(type) %>, std::make_unique<Impl>())
-    , impl(static_cast<Impl*>(baseImpl.get())) {
-    impl->id = layerID;
-    impl->source = sourceID;
+    : Layer(makeMutable<Impl>(LayerType::<%- camelize(type) %>, layerID, sourceID)) {
 }
 <% } -%>
 
-<%- camelize(type) %>Layer::<%- camelize(type) %>Layer(const Impl& other)
-    : Layer(LayerType::<%- camelize(type) %>, std::make_unique<Impl>(other))
-    , impl(static_cast<Impl*>(baseImpl.get())) {
+<%- camelize(type) %>Layer::<%- camelize(type) %>Layer(Immutable<Impl> impl_)
+    : Layer(std::move(impl_)) {
 }
 
 <%- camelize(type) %>Layer::~<%- camelize(type) %>Layer() = default;
 
-std::unique_ptr<Layer> <%- camelize(type) %>Layer::Impl::clone() const {
-    return std::make_unique<<%- camelize(type) %>Layer>(*this);
+const <%- camelize(type) %>Layer::Impl& <%- camelize(type) %>Layer::impl() const {
+    return static_cast<const Impl&>(*baseImpl);
 }
 
-std::unique_ptr<Layer> <%- camelize(type) %>Layer::Impl::cloneRef(const std::string& id_) const {
-    auto result = std::make_unique<<%- camelize(type) %>Layer>(*this);
-    result->impl->id = id_;
-    result->impl->cascading = <%- camelize(type) %>PaintProperties::Cascading();
-    return std::move(result);
+Mutable<<%- camelize(type) %>Layer::Impl> <%- camelize(type) %>Layer::mutableImpl() const {
+    return makeMutable<Impl>(impl());
+}
+
+std::unique_ptr<Layer> <%- camelize(type) %>Layer::cloneRef(const std::string& id_) const {
+    auto impl_ = mutableImpl();
+    impl_->id = id_;
+    impl_->cascading = <%- camelize(type) %>PaintProperties::Cascading();
+    return std::make_unique<<%- camelize(type) %>Layer>(std::move(impl_));
 }
 
 <% if (layoutProperties.length) { -%>
@@ -58,31 +57,60 @@ void <%- camelize(type) %>Layer::Impl::stringifyLayout(rapidjson::Writer<rapidjs
 // Source
 
 const std::string& <%- camelize(type) %>Layer::getSourceID() const {
-    return impl->source;
+    return impl().source;
 }
 
 <% if (type !== 'raster') { -%>
 void <%- camelize(type) %>Layer::setSourceLayer(const std::string& sourceLayer) {
-    impl->sourceLayer = sourceLayer;
+    auto impl_ = mutableImpl();
+    impl_->sourceLayer = sourceLayer;
+    baseImpl = std::move(impl_);
 }
 
 const std::string& <%- camelize(type) %>Layer::getSourceLayer() const {
-    return impl->sourceLayer;
+    return impl().sourceLayer;
 }
 
 // Filter
 
 void <%- camelize(type) %>Layer::setFilter(const Filter& filter) {
-    impl->filter = filter;
-    impl->observer->onLayerFilterChanged(*this);
+    auto impl_ = mutableImpl();
+    impl_->filter = filter;
+    baseImpl = std::move(impl_);
+    observer->onLayerFilterChanged(*this);
 }
 
 const Filter& <%- camelize(type) %>Layer::getFilter() const {
-    return impl->filter;
+    return impl().filter;
 }
 <% } -%>
 <% } -%>
 
+// Visibility
+
+void <%- camelize(type) %>Layer::setVisibility(VisibilityType value) {
+    if (value == getVisibility())
+        return;
+    auto impl_ = mutableImpl();
+    impl_->visibility = value;
+    baseImpl = std::move(impl_);
+    observer->onLayerVisibilityChanged(*this);
+}
+
+// Zoom range
+
+void <%- camelize(type) %>Layer::setMinZoom(float minZoom) {
+    auto impl_ = mutableImpl();
+    impl_->minZoom = minZoom;
+    baseImpl = std::move(impl_);
+}
+
+void <%- camelize(type) %>Layer::setMaxZoom(float maxZoom) {
+    auto impl_ = mutableImpl();
+    impl_->maxZoom = maxZoom;
+    baseImpl = std::move(impl_);
+}
+
 // Layout properties
 
 <% for (const property of layoutProperties) { -%>
@@ -91,14 +119,16 @@ const Filter& <%- camelize(type) %>Layer::getFilter() const {
 }
 
 <%- propertyValueType(property) %> <%- camelize(type) %>Layer::get<%- camelize(property.name) %>() const {
-    return impl->layout.unevaluated.get<<%- camelize(property.name) %>>();
+    return impl().layout.unevaluated.get<<%- camelize(property.name) %>>();
 }
 
 void <%- camelize(type) %>Layer::set<%- camelize(property.name) %>(<%- propertyValueType(property) %> value) {
     if (value == get<%- camelize(property.name) %>())
         return;
-    impl->layout.unevaluated.get<<%- camelize(property.name) %>>() = value;
-    impl->observer->onLayerLayoutPropertyChanged(*this, "<%- property.name %>");
+    auto impl_ = mutableImpl();
+    impl_->layout.unevaluated.get<<%- camelize(property.name) %>>() = value;
+    baseImpl = std::move(impl_);
+    observer->onLayerLayoutPropertyChanged(*this, "<%- property.name %>");
 }
 <% } -%>
 
@@ -109,30 +139,34 @@ void <%- camelize(type) %>Layer::set<%- camelize(property.name) %>(<%- propertyV
 }
 
 <%- propertyValueType(property) %> <%- camelize(type) %>Layer::get<%- camelize(property.name) %>(const optional<std::string>& klass) const {
-    return impl->cascading.template get<<%- camelize(property.name) %>>().get(klass);
+    return impl().cascading.template get<<%- camelize(property.name) %>>().get(klass);
 }
 
 void <%- camelize(type) %>Layer::set<%- camelize(property.name) %>(<%- propertyValueType(property) %> value, const optional<std::string>& klass) {
     if (value == get<%- camelize(property.name) %>(klass))
         return;
-    impl->cascading.template get<<%- camelize(property.name) %>>().set(value, klass);
+    auto impl_ = mutableImpl();
+    impl_->cascading.template get<<%- camelize(property.name) %>>().set(value, klass);
+    baseImpl = std::move(impl_);
 <% if (isDataDriven(property)) { -%>
     if (value.isDataDriven()) {
-        impl->observer->onLayerDataDrivenPaintPropertyChanged(*this);
+        observer->onLayerDataDrivenPaintPropertyChanged(*this);
     } else {
-        impl->observer->onLayerPaintPropertyChanged(*this);
+        observer->onLayerPaintPropertyChanged(*this);
     }
 <% } else { -%>
-    impl->observer->onLayerPaintPropertyChanged(*this);
+    observer->onLayerPaintPropertyChanged(*this);
 <% } -%>
 }
 
 void <%- camelize(type) %>Layer::set<%- camelize(property.name) %>Transition(const TransitionOptions& value, const optional<std::string>& klass) {
-    impl->cascading.template get<<%- camelize(property.name) %>>().setTransition(value, klass);
+    auto impl_ = mutableImpl();
+    impl_->cascading.template get<<%- camelize(property.name) %>>().setTransition(value, klass);
+    baseImpl = std::move(impl_);
 }
 
 TransitionOptions <%- camelize(type) %>Layer::get<%- camelize(property.name) %>Transition(const optional<std::string>& klass) const {
-    return impl->cascading.template get<<%- camelize(property.name) %>>().getTransition(klass);
+    return impl().cascading.template get<<%- camelize(property.name) %>>().getTransition(klass);
 }
 <% } -%>