1 files changed, 98 insertions, 0 deletions
diff --git a/src/mbgl/style/layers/symbol_layer_impl.hpp b/src/mbgl/style/layers/symbol_layer_impl.hpp
index a5b0332f6c..f937fccaa8 100644
--- a/src/mbgl/style/layers/symbol_layer_impl.hpp
+++ b/src/mbgl/style/layers/symbol_layer_impl.hpp
@@ -3,10 +3,104 @@
 #include <mbgl/style/layer_impl.hpp>
 #include <mbgl/style/layers/symbol_layer.hpp>
 #include <mbgl/style/layers/symbol_layer_properties.hpp>
+#include <mbgl/style/expression/format_expression.hpp>
+#include <mbgl/style/expression/formatted.hpp>
+#include <mbgl/style/expression/format_section_override.hpp>
 
 namespace mbgl {
 namespace style {
 
+template<typename PaintProperty>
+struct FormatSectionOverrides;
+
+template<typename... PaintProperty>
+struct FormatSectionOverrides<TypeList<PaintProperty...>> {
+    template<typename Property, typename T, typename U>
+    static void setOverride(const T& overrides, U& overridable) {
+        if (hasOverride<Property>(overrides.template get<TextField>())) {
+            auto override =
+                    std::make_unique<expression::FormatSectionOverride<typename Property::Type>>(Property::expressionType(),
+                                                                                                 std::move(overridable.template get<Property>()),
+                                                                                                 Property::name());
+            PropertyExpression<typename Property::Type> expr(std::move(override));
+            overridable.template get<Property>() = PossiblyEvaluatedPropertyValue<typename Property::Type>(std::move(expr));
+        }
+    }
+
+    template<typename T, typename U>
+    static void setOverrides(const T& overrides, U& overridable) {
+        util::ignore({(setOverride<PaintProperty>(overrides, overridable), 0)...});
+    }
+
+    template<typename Property, typename T, typename U>
+    static void updateOverride(T& evaluated, U& updated) {
+        auto property = evaluated.template get<Property>();
+        if (!property.isConstant()) {
+            const bool hasFormatSectionOverride = property.match(
+                    [] (const style::PropertyExpression<typename Property::Type>& e) {
+                        return e.getExpression().getKind() == expression::Kind::FormatSectionOverride;
+                    },
+                    [] (const auto&) {
+                        return false;
+                    });
+            if (hasFormatSectionOverride) {
+                updated.template get<Property>() = std::move(property);
+            }
+        }
+    }
+
+    template<typename T, typename U>
+    static void updateOverrides(T& evaluated, U& updated) {
+        util::ignore({(updateOverride<PaintProperty>(evaluated, updated), 0)...});
+    }
+
+    template<typename Property, typename FormattedProperty>
+    static bool hasOverride(const FormattedProperty& formatted) {
+        return formatted.match(
+                [] (const TextField::Type& t) {
+                    for (const auto& section : t.sections) {
+                        if (Property::hasOverride(section)) {
+                            return true;
+                        }
+                    }
+                    return false;
+                },
+                [] (const PropertyExpression<TextField::Type>& t) {
+                    if (t.getExpression().getKind() == expression::Kind::FormatExpression) {
+                        const auto* e = static_cast<const expression::FormatExpression*>(&t.getExpression());
+                        for (const auto& section : e->getSections()) {
+                            if (Property::hasOverride(section)) {
+                                return true;
+                            }
+                        }
+                    }
+                    return false;
+                },
+                [] (const auto&) {
+                    return false;
+                }
+         );
+    }
+
+    template <typename FormattedProperty>
+    static bool hasOverrides(const FormattedProperty& formatted) {
+        bool result = false;
+        util::ignore({ (result |= hasOverride<PaintProperty>(formatted))... });
+        return result;
+    }
+
+    template <typename PaintProperties>
+    static bool hasPaintPropertyDifference(const PaintProperties& lhs, const PaintProperties& rhs) {
+        bool result = false;
+        util::ignore({ (result |= lhs.template get<PaintProperty>().value.isConstant() &&
+                                  rhs.template get<PaintProperty>().value.isConstant() &&
+                                  (lhs.template get<PaintProperty>().value.asConstant() != rhs.template get<PaintProperty>().value.asConstant()))... });
+        return result;
+    }
+};
+
+using SymbolLayerPaintPropertyOverrides = FormatSectionOverrides<SymbolPaintProperties::OverridableProperties>;
+
 class SymbolLayer::Impl : public Layer::Impl {
 public:
     using Layer::Impl::Impl;
@@ -19,6 +113,10 @@ public:
     SymbolPaintProperties::Transitionable paint;
 
     DECLARE_LAYER_TYPE_INFO;
+
+private:
+    bool hasFormatSectionOverrides() const;
+    mutable optional<bool> hasFormatSectionOverrides_;
 };
 
 } // namespace style