1 files changed, 22 insertions, 42 deletions
diff --git a/include/mbgl/style/conversion/data_driven_property_value.hpp b/include/mbgl/style/conversion/data_driven_property_value.hpp
index 07ed201c99..363134bd3e 100644
--- a/include/mbgl/style/conversion/data_driven_property_value.hpp
+++ b/include/mbgl/style/conversion/data_driven_property_value.hpp
@@ -6,74 +6,54 @@
 #include <mbgl/style/conversion/function.hpp>
 #include <mbgl/style/expression/is_expression.hpp>
 #include <mbgl/style/expression/is_constant.hpp>
-#include <mbgl/style/expression/find_zoom_curve.hpp>
 #include <mbgl/style/expression/literal.hpp>
 #include <mbgl/style/expression/value.hpp>
 #include <mbgl/style/expression/parsing_context.hpp>
 
-#include <unordered_set>
-
-
 namespace mbgl {
 namespace style {
 namespace conversion {
 
 template <class T>
 struct Converter<DataDrivenPropertyValue<T>> {
-
     optional<DataDrivenPropertyValue<T>> operator()(const Convertible& value, Error& error) const {
         using namespace mbgl::style::expression;
-        
+
         if (isUndefined(value)) {
             return DataDrivenPropertyValue<T>();
-        } else if (isExpression(value)) {
+        }
+
+        optional<PropertyExpression<T>> expression;
+
+        if (isExpression(value)) {
             ParsingContext ctx(valueTypeToExpressionType<T>());
-            ParseResult expression = ctx.parseLayerPropertyExpression(value);
-            if (!expression) {
+            ParseResult parsed = ctx.parseLayerPropertyExpression(value);
+            if (!parsed) {
                 error = { ctx.getCombinedErrors() };
                 return {};
             }
-            
-            bool featureConstant = isFeatureConstant(**expression);
-            bool zoomConstant = isZoomConstant(**expression);
-            
-            if (featureConstant && !zoomConstant) {
-                return DataDrivenPropertyValue<T>(CameraFunction<T>(std::move(*expression)));
-            } else if (!featureConstant && zoomConstant) {
-                return DataDrivenPropertyValue<T>(SourceFunction<T>(std::move(*expression)));
-            } else if (!featureConstant && !zoomConstant) {
-                return DataDrivenPropertyValue<T>(CompositeFunction<T>(std::move(*expression)));
-            } else {
-                auto literal = dynamic_cast<Literal*>(expression->get());
-                assert(literal);
-                optional<T> constant = fromExpressionValue<T>(literal->getValue());
-                if (!constant) {
-                    return {};
-                }
-                return DataDrivenPropertyValue<T>(*constant);
-            }
-        } else if (!isObject(value)) {
+            expression = PropertyExpression<T>(std::move(*parsed));
+        } else if (isObject(value)) {
+            expression = convertFunctionToExpression<T>(value, error);
+        } else {
             optional<T> constant = convert<T>(value, error);
             if (!constant) {
                 return {};
             }
             return DataDrivenPropertyValue<T>(*constant);
-        } else if (!objectMember(value, "property")) {
-            optional<CameraFunction<T>> function = convert<CameraFunction<T>>(value, error);
-            if (!function) {
-                return {};
-            }
-            return DataDrivenPropertyValue<T>(*function);
+        }
+
+        if (!expression) {
+            return {};
+        } else if (!(*expression).isFeatureConstant() || !(*expression).isZoomConstant()) {
+            return { std::move(*expression) };
         } else {
-            optional<CompositeFunction<T>> composite = convert<CompositeFunction<T>>(value, error);
-            if (composite) {
-                return DataDrivenPropertyValue<T>(*composite);
-            }
-            optional<SourceFunction<T>> source = convert<SourceFunction<T>>(value, error);
-            if (!source) {
+            optional<T> constant = fromExpressionValue<T>(
+                dynamic_cast<const Literal&>((*expression).getExpression()).getValue());
+            if (!constant) {
                 return {};
             }
-            return DataDrivenPropertyValue<T>(*source);
+            return DataDrivenPropertyValue<T>(*constant);
         }
     }
 };