1 files changed, 109 insertions, 0 deletions
diff --git a/include/mbgl/style/function/composite_function.hpp b/include/mbgl/style/function/composite_function.hpp
new file mode 100644
index 0000000000..169a455435
--- /dev/null
+++ b/include/mbgl/style/function/composite_function.hpp
@@ -0,0 +1,109 @@
+#pragma once
+
+#include <mbgl/style/function/exponential_stops.hpp>
+#include <mbgl/style/function/interval_stops.hpp>
+#include <mbgl/style/function/categorical_stops.hpp>
+#include <mbgl/util/interpolate.hpp>
+#include <mbgl/util/range.hpp>
+#include <mbgl/util/variant.hpp>
+
+#include <string>
+#include <tuple>
+
+namespace mbgl {
+
+class GeometryTileFeature;
+
+namespace style {
+
+// A CompositeFunction consists of an outer zoom function whose stop range values are
+// "inner" source functions. It provides the GL Native implementation of
+// "zoom-and-property" functions from the style spec.
+
+template <class T>
+class CompositeFunction {
+public:
+    using InnerStops = std::conditional_t<
+        util::Interpolatable<T>,
+        variant<
+            ExponentialStops<T>,
+            IntervalStops<T>,
+            CategoricalStops<T>>,
+        variant<
+            IntervalStops<T>,
+            CategoricalStops<T>>>;
+
+    using Stops = std::conditional_t<
+        util::Interpolatable<T>,
+        variant<
+            std::map<float, ExponentialStops<T>>,
+            std::map<float, IntervalStops<T>>,
+            std::map<float, CategoricalStops<T>>>,
+        variant<
+            std::map<float, IntervalStops<T>>,
+            std::map<float, CategoricalStops<T>>>>;
+
+    CompositeFunction(std::string property_, Stops stops_)
+        : property(std::move(property_)),
+          stops(std::move(stops_)) {
+    }
+
+    std::tuple<Range<float>, Range<InnerStops>>
+    coveringRanges(float zoom) const {
+        return stops.match(
+            [&] (const auto& s) {
+                assert(!s.empty());
+                auto minIt = s.lower_bound(zoom);
+                auto maxIt = s.upper_bound(zoom);
+                if (minIt != s.begin()) {
+                    minIt--;
+                }
+                return std::make_tuple(
+                    Range<float> {
+                        minIt == s.end() ? s.rbegin()->first : minIt->first,
+                        maxIt == s.end() ? s.rbegin()->first : maxIt->first
+                    },
+                    Range<InnerStops> {
+                        minIt == s.end() ? s.rbegin()->second : minIt->second,
+                        maxIt == s.end() ? s.rbegin()->second : maxIt->second
+                    }
+                );
+            }
+        );
+    }
+
+    Range<T> evaluate(Range<InnerStops> coveringStops,
+                      const GeometryTileFeature& feature) const {
+        optional<Value> v = feature.getValue(property);
+        if (!v) {
+            return { T(), T() };
+        }
+        auto eval = [&] (const auto& s) {
+            return s.evaluate(*v);
+        };
+        return Range<T> {
+            coveringStops.min.match(eval),
+            coveringStops.max.match(eval)
+        };
+    }
+
+    T evaluate(float zoom, const GeometryTileFeature& feature) const {
+        std::tuple<Range<float>, Range<InnerStops>> ranges = coveringRanges(zoom);
+        Range<T> resultRange = evaluate(std::get<1>(ranges), feature);
+        return util::interpolate(
+            resultRange.min,
+            resultRange.max,
+            util::interpolationFactor(1.0f, std::get<0>(ranges), zoom));
+    }
+
+    friend bool operator==(const CompositeFunction& lhs,
+                           const CompositeFunction& rhs) {
+        return lhs.property == rhs.property && lhs.stops == rhs.stops;
+    }
+
+    std::string property;
+    Stops stops;
+};
+
+} // namespace style
+} // namespace mbgl