1 files changed, 13 insertions, 53 deletions
diff --git a/include/mbgl/style/conversion/function.hpp b/include/mbgl/style/conversion/function.hpp
index 5ddede324b..6bc75d7141 100644
--- a/include/mbgl/style/conversion/function.hpp
+++ b/include/mbgl/style/conversion/function.hpp
@@ -1,8 +1,6 @@
 #pragma once
 
-#include <mbgl/style/function/camera_function.hpp>
-#include <mbgl/style/function/source_function.hpp>
-#include <mbgl/style/function/composite_function.hpp>
+#include <mbgl/style/property_expression.hpp>
 #include <mbgl/style/conversion.hpp>
 #include <mbgl/style/conversion/constant.hpp>
 #include <mbgl/style/expression/expression.hpp>
@@ -12,66 +10,28 @@ namespace mbgl {
 namespace style {
 namespace conversion {
 
-template <class T>
-optional<optional<T>> convertDefaultValue(const Convertible& value, Error& error) {
-    auto defaultValueValue = objectMember(value, "default");
-    if (!defaultValueValue) {
-        return optional<T>();
-    }
+optional<std::unique_ptr<expression::Expression>> convertFunctionToExpression(expression::type::Type, const Convertible&, Error&);
 
-    auto defaultValue = convert<T>(*defaultValueValue, error);
-    if (!defaultValue) {
-        error = { R"(wrong type for "default": )" + error.message };
+template <class T>
+optional<PropertyExpression<T>> convertFunctionToExpression(const Convertible& value, Error& error) {
+    auto expression = convertFunctionToExpression(expression::valueTypeToExpressionType<T>(), value, error);
+    if (!expression) {
         return {};
     }
 
-    return { *defaultValue };
-}
-
-optional<std::unique_ptr<expression::Expression>> convertCameraFunctionToExpression(expression::type::Type, const Convertible&, Error&);
-optional<std::unique_ptr<expression::Expression>> convertSourceFunctionToExpression(expression::type::Type, const Convertible&, Error&);
-optional<std::unique_ptr<expression::Expression>> convertCompositeFunctionToExpression(expression::type::Type, const Convertible&, Error&);
+    optional<T> defaultValue;
 
-template <class T>
-struct Converter<CameraFunction<T>> {
-    optional<CameraFunction<T>> operator()(const Convertible& value, Error& error) const {
-        auto expression = convertCameraFunctionToExpression(expression::valueTypeToExpressionType<T>(), value, error);
-        if (!expression) {
-            return {};
-        }
-        return CameraFunction<T>(std::move(*expression), false);
-    }
-};
-
-template <class T>
-struct Converter<SourceFunction<T>> {
-    optional<SourceFunction<T>> operator()(const Convertible& value, Error& error) const {
-        auto expression = convertSourceFunctionToExpression(expression::valueTypeToExpressionType<T>(), value, error);
-        if (!expression) {
-            return {};
-        }
-        auto defaultValue = convertDefaultValue<T>(value, error);
+    auto defaultValueValue = objectMember(value, "default");
+    if (defaultValueValue) {
+        defaultValue = convert<T>(*defaultValueValue, error);
         if (!defaultValue) {
+            error = { R"(wrong type for "default": )" + error.message };
             return {};
         }
-        return SourceFunction<T>(std::move(*expression), *defaultValue);
     }
-};
 
-template <class T>
-struct Converter<CompositeFunction<T>> {
-    optional<CompositeFunction<T>> operator()(const Convertible& value, Error& error) const {
-        auto expression = convertCompositeFunctionToExpression(expression::valueTypeToExpressionType<T>(), value, error);
-        if (!expression) {
-            return {};
-        }
-        auto defaultValue = convertDefaultValue<T>(value, error);
-        if (!defaultValue) {
-            return {};
-        }
-        return CompositeFunction<T>(std::move(*expression), *defaultValue);
-    }
-};
+    return PropertyExpression<T>(std::move(*expression), defaultValue);
+}
 
 } // namespace conversion
 } // namespace style