[core] Unversal get/set API for generic Source properties

5 files changed, 74 insertions, 13 deletions

diff --git a/include/mbgl/style/conversion_impl.hpp b/include/mbgl/style/conversion_impl.hpp
index 7e57b551fa..9f3f636335 100644
--- a/include/mbgl/style/conversion_impl.hpp
+++ b/include/mbgl/style/conversion_impl.hpp
@@ -311,7 +311,7 @@ template <typename T>
 struct ValueFactory<T,
                     typename std::enable_if<(!std::is_enum<T>::value && !is_linear_container<T>::value &&
                                              !std::is_base_of<Serializable, T>::value)>::type> {
-    static Value make(const T& arg) { return {arg}; }
+    static Value make(T arg) { return {std::move(arg)}; }
 };
 
 template <typename T>
@@ -349,6 +349,12 @@ Value makeValue(T&& arg) {
 }
 
 template <typename T>
+Value makeValue(optional<T> arg) {
+    if (!arg) return NullValue();
+    return makeValue(std::move(*arg));
+}
+
+template <typename T>
 inline StyleProperty makeConstantStyleProperty(T&& value) {
     return {makeValue(std::forward<T>(value)), StyleProperty::Kind::Constant};
 }
diff --git a/include/mbgl/style/source.hpp b/include/mbgl/style/source.hpp
index 324528a744..cfb8e1f0dd 100644
--- a/include/mbgl/style/source.hpp
+++ b/include/mbgl/style/source.hpp
@@ -164,8 +164,10 @@ public:
     // identical platform-native peers.
     mapbox::base::TypeWrapper peer;
 
-    virtual mapbox::base::WeakPtr<Source> makeWeakPtr() = 0;
+    optional<conversion::Error> setProperty(const std::string& name, const conversion::Convertible& value);
+    Value getProperty(const std::string&) const;
 
+    virtual mapbox::base::WeakPtr<Source> makeWeakPtr() = 0;
     const SourceTypeInfo* getTypeInfo() const noexcept;
 
     Value serialize() const override;
@@ -177,6 +179,9 @@ protected:
     void serializeTileSet(Value&, const mbgl::Tileset&) const;
 
     virtual Mutable<Impl> createMutable() const noexcept = 0;
+    virtual optional<conversion::Error> setPropertyInternal(const std::string& name,
+                                                            const conversion::Convertible& value);
+    virtual Value getPropertyInternal(const std::string&) const;
 };
 
 } // namespace style
diff --git a/src/mbgl/sourcemanager/source_manager.cpp b/src/mbgl/sourcemanager/source_manager.cpp
index 742cedef2d..16241b41bc 100644
--- a/src/mbgl/sourcemanager/source_manager.cpp
+++ b/src/mbgl/sourcemanager/source_manager.cpp
@@ -11,13 +11,10 @@ std::unique_ptr<style::Source> SourceManager::createSource(const std::string& ty
                                                            const std::string& id,
                                                            const style::conversion::Convertible& value,
                                                            style::conversion::Error& error) noexcept {
-    SourceFactory* factory = getFactory(type);
-    if (factory) {
+    if (SourceFactory* factory = getFactory(type)) {
         return factory->createSource(id, value, error);
-    } else {
-        error.message = "Null factory for type: " + type;
     }
-    error.message = "Unsupported source type! " + error.message;
+    error.message = "Unsupported source type: " + type;
     return nullptr;
 }
 
diff --git a/src/mbgl/style/conversion/source.cpp b/src/mbgl/style/conversion/source.cpp
index 5c5da63171..14e020594a 100644
--- a/src/mbgl/style/conversion/source.cpp
+++ b/src/mbgl/style/conversion/source.cpp
@@ -31,11 +31,8 @@ optional<std::unique_ptr<Source>> Converter<std::unique_ptr<Source>>::operator()
     const std::string& tname = type.value();
 
     auto source = SourceManager::get()->createSource(tname, id, value, error);
-    if (source) {
-        return source;
-    } else {
-        return nullopt;
-    }
+    if (!source) return nullopt;
+    return source;
 }
 
 } // namespace conversion
diff --git a/src/mbgl/style/source.cpp b/src/mbgl/style/source.cpp
index 6ffaae0305..37eff9b121 100644
--- a/src/mbgl/style/source.cpp
+++ b/src/mbgl/style/source.cpp
@@ -1,3 +1,5 @@
+#include <mbgl/style/conversion/constant.hpp>
+#include <mbgl/style/conversion_impl.hpp>
 #include <mbgl/style/source.hpp>
 #include <mbgl/style/source_impl.hpp>
 #include <mbgl/style/source_observer.hpp>
@@ -82,6 +84,52 @@ void Source::dumpDebugLogs() const {
     Log::Info(Event::General, "Source::loaded: %d", loaded);
 }
 
+optional<conversion::Error> Source::setProperty(const std::string& name, const conversion::Convertible& value) {
+    using namespace conversion;
+    optional<Error> error = setPropertyInternal(name, value);
+    if (!error) return error; // Successfully set by the derived class implementation.
+    if (name == "volatile") {
+        if (auto isVolatile = convert<bool>(value, *error)) {
+            setVolatile(*isVolatile);
+            return nullopt;
+        }
+    } else if (name == "prefetch-zoom-delta") {
+        if (auto zoomDelta = convert<float>(value, *error)) {
+            setPrefetchZoomDelta(static_cast<uint8_t>(*zoomDelta));
+            return nullopt;
+        }
+    } else if (name == "max-overscale-factor-for-parent-tiles") {
+        if (auto zoomDelta = convert<float>(value, *error)) {
+            setMaxOverscaleFactorForParentTiles(static_cast<uint8_t>(*zoomDelta));
+            return nullopt;
+        }
+    } else if (name == "minimum-tile-update-interval") {
+        if (auto updateInterval = convert<float>(value, *error)) {
+            std::chrono::duration<float> seconds(*updateInterval);
+            setMinimumTileUpdateInterval(std::chrono::duration_cast<Duration>(seconds));
+            return nullopt;
+        }
+    }
+    return error;
+}
+
+Value Source::getProperty(const std::string& name) const {
+    using namespace conversion;
+    if (name == "type") return makeValue(getTypeInfo()->type);
+    if (name == "volatile") return makeValue(isVolatile());
+    if (name == "attribution") return makeValue(getAttribution());
+    if (name == "tile-size") return makeValue(getTileSize());
+    if (name == "prefetch-zoom-delta") return makeValue(getPrefetchZoomDelta());
+    if (name == "max-overscale-factor-for-parent-tiles") {
+        return makeValue(getMaxOverscaleFactorForParentTiles());
+    }
+    if (name == "minimum-tile-update-interval") {
+        auto seconds = std::chrono::duration_cast<std::chrono::duration<float>>(getMinimumTileUpdateInterval());
+        return makeValue(seconds.count());
+    }
+    return getPropertyInternal(name);
+}
+
 const SourceTypeInfo* Source::getTypeInfo() const noexcept {
     return baseImpl->getTypeInfo();
 }
@@ -111,7 +159,7 @@ void Source::serializeTileSet(Value& value, const mbgl::Tileset& tileset) const
     tiles.reserve(tileset.tiles.size());
     for (const auto& tile : tileset.tiles) tiles.emplace_back(tile);
 
-    json->insert({"tiles", tiles});
+    json->insert({"tiles", std::move(tiles)});
     json->insert({"minzoom", tileset.zoomRange.min});
     json->insert({"maxzoom", tileset.zoomRange.max});
     json->insert({"scheme", tilesetSchemeToString(tileset.scheme)});
@@ -139,5 +187,13 @@ uint16_t Source::getTileSize() const {
     return baseImpl->getTileSize();
 }
 
+optional<conversion::Error> Source::setPropertyInternal(const std::string& name, const conversion::Convertible&) {
+    return conversion::Error{"Cannot set property " + name + " for the source " + baseImpl->id};
+}
+
+Value Source::getPropertyInternal(const std::string&) const {
+    return NullValue();
+}
+
 } // namespace style
 } // namespace mbgl