From 713299c429ab494e4cc3347d9dcd76b67ba2522c Mon Sep 17 00:00:00 2001 From: Alexander Shalamov Date: Tue, 25 Feb 2020 10:19:56 +0200 Subject: [core] Add layer serialization method --- include/mbgl/style/filter.hpp | 2 + include/mbgl/style/layer.hpp | 2 + include/mbgl/style/layers/layer.hpp.ejs | 1 + src/mbgl/style/layer.cpp | 48 +++++++++++++++++++++++ src/mbgl/style/layers/layer.cpp.ejs | 69 ++++++++++++++++++++++----------- 5 files changed, 100 insertions(+), 22 deletions(-) diff --git a/include/mbgl/style/filter.hpp b/include/mbgl/style/filter.hpp index c9dc9fb1ec..e0623a20d4 100644 --- a/include/mbgl/style/filter.hpp +++ b/include/mbgl/style/filter.hpp @@ -28,6 +28,8 @@ public: bool operator()(const expression::EvaluationContext& context) const; + operator bool() const { return expression || legacyFilter; } + friend bool operator==(const Filter& lhs, const Filter& rhs) { if (!lhs.expression || !rhs.expression) { return lhs.expression == rhs.expression; diff --git a/include/mbgl/style/layer.hpp b/include/mbgl/style/layer.hpp index c80312bc23..840ef9ce88 100644 --- a/include/mbgl/style/layer.hpp +++ b/include/mbgl/style/layer.hpp @@ -114,6 +114,7 @@ public: optional setVisibility(const conversion::Convertible& value); virtual StyleProperty getProperty(const std::string&) const = 0; + virtual Value serialize() const; // Private implementation // TODO : We should not have public mutable data members. @@ -140,6 +141,7 @@ public: protected: virtual Mutable mutableBaseImpl() const = 0; + void serializeProperty(Value&, const StyleProperty&, const char* propertyName, bool isPaint) const; LayerObserver* observer; mapbox::base::WeakPtrFactory weakFactory {this}; diff --git a/include/mbgl/style/layers/layer.hpp.ejs b/include/mbgl/style/layers/layer.hpp.ejs index 3709f53bee..aecbe25601 100644 --- a/include/mbgl/style/layers/layer.hpp.ejs +++ b/include/mbgl/style/layers/layer.hpp.ejs @@ -40,6 +40,7 @@ public: optional setProperty(const std::string& name, const conversion::Convertible& value) final; StyleProperty getProperty(const std::string& name) const final; + Value serialize() const final; <% if (layoutProperties.length) { -%> // Layout properties diff --git a/src/mbgl/style/layer.cpp b/src/mbgl/style/layer.cpp index 04a897022c..3183d84ab5 100644 --- a/src/mbgl/style/layer.cpp +++ b/src/mbgl/style/layer.cpp @@ -91,6 +91,54 @@ void Layer::setMaxZoom(float maxZoom) { observer->onLayerChanged(*this); } +Value Layer::serialize() const { + mapbox::base::ValueObject result; + result.emplace(std::make_pair("id", getID())); + result.emplace(std::make_pair("type", Layer::getTypeInfo()->type)); + + auto source = getSourceID(); + if (!source.empty()) { + result.emplace(std::make_pair("source", std::move(source))); + } + + auto sourceLayer = getSourceLayer(); + if (!sourceLayer.empty()) { + result.emplace(std::make_pair("source-layer", std::move(sourceLayer))); + } + + if (getFilter()) { + result.emplace(std::make_pair("filter", getFilter().serialize())); + } + + if (getMinZoom() != -std::numeric_limits::infinity()) { + result.emplace(std::make_pair("minzoom", getMinZoom())); + } + + if (getMaxZoom() != std::numeric_limits::infinity()) { + result.emplace(std::make_pair("maxzoom", getMaxZoom())); + } + + if (getVisibility() == VisibilityType::None) { + result["layout"] = mapbox::base::ValueObject{std::make_pair("visibility", "none")}; + } + + return result; +} + +void Layer::serializeProperty(Value& out, const StyleProperty& property, const char* propertyName, bool isPaint) const { + assert(out.getObject()); + auto& object = *(out.getObject()); + std::string propertyType = isPaint ? "paint" : "layout"; + auto it = object.find(propertyType); + auto pair = std::make_pair(std::string(propertyName), Value{property.getValue()}); + if (it != object.end()) { + assert(it->second.getObject()); + it->second.getObject()->emplace(std::move(pair)); + } else { + object[propertyType] = mapbox::base::ValueObject{{std::move(pair)}}; + } +} + void Layer::setObserver(LayerObserver* observer_) { observer = observer_ ? observer_ : &nullObserver; } diff --git a/src/mbgl/style/layers/layer.cpp.ejs b/src/mbgl/style/layers/layer.cpp.ejs index e74e7ab345..a17b9e803c 100644 --- a/src/mbgl/style/layers/layer.cpp.ejs +++ b/src/mbgl/style/layers/layer.cpp.ejs @@ -200,6 +200,8 @@ using namespace conversion; namespace { +constexpr uint8_t kPaintPropertyCount = <%- paintProperties.length * 2 -%>u; + enum class Property : uint8_t { <% for (const property of paintProperties) { -%> <%- camelize(property.name) %>, @@ -207,8 +209,12 @@ enum class Property : uint8_t { <% for (const property of paintProperties) { -%> <%- camelize(property.name) %>Transition, <% } -%> -<% for (const property of layoutProperties) { -%> - <%- camelize(property.name) %>, +<% for (let i = 0; i < layoutProperties.length; ++i) { -%> +<% if (i===0) { -%> + <%- camelize(layoutProperties[i].name) %> = kPaintPropertyCount, +<% } else { -%> + <%- camelize(layoutProperties[i].name) %>, +<% } -%> <% } -%> }; @@ -225,8 +231,46 @@ MAPBOX_ETERNAL_CONSTEXPR const auto layerProperties = mapbox::eternal::hash_map< <%- paintProperties.map(p => `{"${p.name}-transition", toUint8(Property::${camelize(p.name)}Transition)}`).join(',\n ') %>, <%- layoutProperties.map(p => `{"${p.name}", toUint8(Property::${camelize(p.name)})}`).join(',\n ') %>}); <% } -%> + +StyleProperty getLayerProperty(const <%- camelize(type) %>Layer& layer, Property property) { + switch (property) { +<% for (const property of paintProperties) { -%> + case Property::<%- camelize(property.name) %>: + return makeStyleProperty(layer.get<%- camelize(property.name) %>()); +<% } -%> +<% for (const property of paintProperties) { -%> + case Property::<%- camelize(property.name) %>Transition: + return makeStyleProperty(layer.get<%- camelize(property.name) %>Transition()); +<% } -%> +<% for (const property of layoutProperties) { -%> + case Property::<%- camelize(property.name) %>: + return makeStyleProperty(layer.get<%- camelize(property.name) %>()); +<% } -%> + } + return {}; +} + +StyleProperty getLayerProperty(const <%- camelize(type) -%>Layer& layer, const std::string& name) { + const auto it = layerProperties.find(name.c_str()); + if (it == layerProperties.end()) { + return {}; + } + return getLayerProperty(layer, static_cast(it->second)); +} + } // namespace +Value <%- camelize(type) %>Layer::serialize() const { + auto result = Layer::serialize(); + assert(result.getObject()); + for (const auto& property : layerProperties) { + auto styleProperty = getLayerProperty(*this, static_cast(property.second)); + if (styleProperty.getKind() == StyleProperty::Kind::Undefined) continue; + serializeProperty(result, styleProperty, property.first.c_str(), property.second < kPaintPropertyCount); + } + return result; +} + optional <%- camelize(type) %>Layer::setProperty(const std::string& name, const Convertible& value) { const auto it = layerProperties.find(name.c_str()); if (it == layerProperties.end()) { @@ -289,26 +333,7 @@ optional <%- camelize(type) %>Layer::setProperty(const std::string& name, } StyleProperty <%- camelize(type) %>Layer::getProperty(const std::string& name) const { - const auto it = layerProperties.find(name.c_str()); - if (it == layerProperties.end()) { - return {}; - } - - switch (static_cast(it->second)) { -<% for (const property of paintProperties) { -%> - case Property::<%- camelize(property.name) %>: - return makeStyleProperty(get<%- camelize(property.name) %>()); -<% } -%> -<% for (const property of paintProperties) { -%> - case Property::<%- camelize(property.name) %>Transition: - return makeStyleProperty(get<%- camelize(property.name) %>Transition()); -<% } -%> -<% for (const property of layoutProperties) { -%> - case Property::<%- camelize(property.name) %>: - return makeStyleProperty(get<%- camelize(property.name) %>()); -<% } -%> - } - return {}; + return getLayerProperty(*this, name); } Mutable <%- camelize(type) %>Layer::mutableBaseImpl() const { -- cgit v1.2.1