1 files changed, 38 insertions, 26 deletions
diff --git a/src/mbgl/style/layout_property.hpp b/src/mbgl/style/layout_property.hpp
index db1a1ebf28..6ea06ce556 100644
--- a/src/mbgl/style/layout_property.hpp
+++ b/src/mbgl/style/layout_property.hpp
@@ -1,43 +1,55 @@
 #pragma once
 
-#include <mbgl/style/property_value.hpp>
-#include <mbgl/style/property_parsing.hpp>
 #include <mbgl/style/property_evaluator.hpp>
-
-#include <utility>
+#include <mbgl/util/indexed_tuple.hpp>
 
 namespace mbgl {
 namespace style {
 
-template <typename T>
+class PropertyEvaluationParameters;
+
+template <class T>
 class LayoutProperty {
 public:
-    explicit LayoutProperty(T v)
-        : value(std::move(v)),
-          defaultValue(value) {}
-
-    const PropertyValue<T>& get() const {
-        return currentValue;
-    }
+    using EvaluatorType = PropertyEvaluator<T>;
+    using UnevaluatedType = PropertyValue<T>;
+    using EvaluatedType = T;
+};
 
-    void set(const PropertyValue<T>& value_) {
-        currentValue = value_;
+template <class... Ps>
+class LayoutProperties {
+public:
+    using Properties = TypeList<Ps...>;
+    using EvaluatedTypes = TypeList<typename Ps::EvaluatedType...>;
+    using UnevaluatedTypes = TypeList<typename Ps::UnevaluatedType...>;
+
+    template <class TypeList>
+    using Tuple = IndexedTuple<Properties, TypeList>;
+
+    class Evaluated : public Tuple<EvaluatedTypes> {
+    public:
+        using Tuple<EvaluatedTypes>::Tuple;
+    };
+
+    class Unevaluated : public Tuple<UnevaluatedTypes> {
+    public:
+        using Tuple<UnevaluatedTypes>::Tuple;
+    };
+
+    template <class P>
+    auto evaluate(const PropertyEvaluationParameters& parameters) const {
+        using Evaluator = typename P::EvaluatorType;
+        return unevaluated.template get<P>()
+            .evaluate(Evaluator(parameters, P::defaultValue()));
     }
 
-    void calculate(const CalculationParameters& parameters) {
-        if (currentValue) {
-            PropertyEvaluator<T> evaluator(parameters, defaultValue);
-            value = PropertyValue<T>::visit(currentValue, evaluator);
-        }
+    Evaluated evaluate(const PropertyEvaluationParameters& parameters) const {
+        return Evaluated {
+            evaluate<Ps>(parameters)...
+        };
     }
 
-    // TODO: remove / privatize
-    operator T() const { return value; }
-    T value;
-
-private:
-    T defaultValue;
-    PropertyValue<T> currentValue;
+    Unevaluated unevaluated;
 };
 
 } // namespace style