From 1dd35eface06c253c6e039b49942bdeb32991839 Mon Sep 17 00:00:00 2001 From: John Firebaugh Date: Thu, 28 Jun 2018 08:18:23 -0700 Subject: [core] Privatize Interpolate --- include/mbgl/style/expression/interpolate.hpp | 73 ++------------------------- include/mbgl/style/function/convert.hpp | 59 +++++++++------------- 2 files changed, 30 insertions(+), 102 deletions(-) (limited to 'include') diff --git a/include/mbgl/style/expression/interpolate.hpp b/include/mbgl/style/expression/interpolate.hpp index 1a98189e29..dcdfa302ba 100644 --- a/include/mbgl/style/expression/interpolate.hpp +++ b/include/mbgl/style/expression/interpolate.hpp @@ -79,74 +79,11 @@ protected: const std::map> stops; }; -template -class Interpolate : public InterpolateBase { -public: - Interpolate(type::Type type_, - Interpolator interpolator_, - std::unique_ptr input_, - std::map> stops_ - ) : InterpolateBase(std::move(type_), std::move(interpolator_), std::move(input_), std::move(stops_)) - { - static_assert(util::Interpolatable::value, "Interpolate expression requires an interpolatable value type."); - } - - EvaluationResult evaluate(const EvaluationContext& params) const override { - const EvaluationResult evaluatedInput = input->evaluate(params); - if (!evaluatedInput) { - return evaluatedInput.error(); - } - - float x = *fromExpressionValue(*evaluatedInput); - if (std::isnan(x)) { - return EvaluationError { "Input is not a number." }; - } - - if (stops.empty()) { - return EvaluationError { "No stops in exponential curve." }; - } - - auto it = stops.upper_bound(x); - if (it == stops.end()) { - return stops.rbegin()->second->evaluate(params); - } else if (it == stops.begin()) { - return stops.begin()->second->evaluate(params); - } else { - float t = interpolationFactor({ std::prev(it)->first, it->first }, x); - - if (t == 0.0f) { - return std::prev(it)->second->evaluate(params); - } - if (t == 1.0f) { - return it->second->evaluate(params); - } - - EvaluationResult lower = std::prev(it)->second->evaluate(params); - if (!lower) { - return lower.error(); - } - EvaluationResult upper = it->second->evaluate(params); - if (!upper) { - return upper.error(); - } - - if (!lower->is()) { - return EvaluationError { - "Expected value to be of type " + toString(valueTypeToExpressionType()) + - ", but found " + toString(typeOf(*lower)) + " instead." - }; - } - - if (!upper->is()) { - return EvaluationError { - "Expected value to be of type " + toString(valueTypeToExpressionType()) + - ", but found " + toString(typeOf(*upper)) + " instead." - }; - } - return util::interpolate(lower->get(), upper->get(), t); - } - } -}; +ParseResult createInterpolate(type::Type type, + Interpolator interpolator, + std::unique_ptr input, + std::map> stops, + ParsingContext& ctx); } // namespace expression } // namespace style diff --git a/include/mbgl/style/function/convert.hpp b/include/mbgl/style/function/convert.hpp index b34071d219..e5a5808e1d 100644 --- a/include/mbgl/style/function/convert.hpp +++ b/include/mbgl/style/function/convert.hpp @@ -91,22 +91,6 @@ struct Convert { return std::make_unique(message); } - template - static ParseResult makeInterpolate(type::Type type, - std::unique_ptr input, - std::map> convertedStops, - Interpolator interpolator) - { - ParseResult curve = ParseResult(std::make_unique>( - std::move(type), - std::move(interpolator), - std::move(input), - std::move(convertedStops) - )); - assert(curve); - return std::move(*curve); - } - template static ParseResult makeMatch(type::Type type, std::unique_ptr input, @@ -191,11 +175,12 @@ struct Convert { template static std::unique_ptr toExpression(const ExponentialStops& stops) { - ParseResult e = makeInterpolate::ExpressionType>( - valueTypeToExpressionType(), - makeZoom(), - convertStops(stops.stops), - ExponentialInterpolator(stops.base)); + ParsingContext ctx; + ParseResult e = createInterpolate(valueTypeToExpressionType(), + ExponentialInterpolator(stops.base), + makeZoom(), + convertStops(stops.stops), + ctx); assert(e); return std::move(*e); } @@ -214,10 +199,12 @@ struct Convert { static std::unique_ptr toExpression(const std::string& property, const ExponentialStops& stops) { - ParseResult e = makeInterpolate::ExpressionType>(valueTypeToExpressionType(), - makeGet(type::Number, property), - convertStops(stops.stops), - ExponentialInterpolator(stops.base)); + ParsingContext ctx; + ParseResult e = createInterpolate(valueTypeToExpressionType(), + ExponentialInterpolator(stops.base), + makeGet(type::Number, property), + convertStops(stops.stops), + ctx); assert(e); return std::move(*e); } @@ -247,10 +234,12 @@ struct Convert { template static typename std::enable_if_t::value, ParseResult> makeZoomCurve(std::map> stops) { - return makeInterpolate::ExpressionType>(valueTypeToExpressionType(), - makeZoom(), - std::move(stops), - ExponentialInterpolator(1.0)); + ParsingContext ctx; + return createInterpolate(valueTypeToExpressionType(), + ExponentialInterpolator(1.0), + makeZoom(), + std::move(stops), + ctx); } // non-interpolatable zoom curve @@ -264,13 +253,15 @@ struct Convert { static std::unique_ptr toExpression(const std::string& property, const CompositeExponentialStops& stops) { + ParsingContext ctx; + std::map> outerStops; for (const std::pair>& stop : stops.stops) { - std::unique_ptr get = makeGet(type::Number, property); - ParseResult innerInterpolate = makeInterpolate::ExpressionType>(valueTypeToExpressionType(), - std::move(get), - convertStops(stop.second), - ExponentialInterpolator(stops.base)); + ParseResult innerInterpolate = createInterpolate(valueTypeToExpressionType(), + ExponentialInterpolator(stops.base), + makeGet(type::Number, property), + convertStops(stop.second), + ctx); assert(innerInterpolate); outerStops.emplace(stop.first, std::move(*innerInterpolate)); } -- cgit v1.2.1