[ios, macos] Cleaned up expression conversion

6 files changed, 70 insertions, 70 deletions

diff --git a/platform/darwin/src/NSArray+MGLAdditions.mm b/platform/darwin/src/NSArray+MGLAdditions.mm
index f2c5a096cc..8ec344f580 100644
--- a/platform/darwin/src/NSArray+MGLAdditions.mm
+++ b/platform/darwin/src/NSArray+MGLAdditions.mm
@@ -17,9 +17,9 @@
             vector.push_back(propertyMap);
         } else {
             NSExpression *expression = [NSExpression expressionForConstantValue:value];
-            vector.push_back([expression mgl_filterValue]);
+            vector.push_back(expression.mgl_constantMBGLValue);
         }
-    }    
+    }
     return vector;
 }
 
diff --git a/platform/darwin/src/NSComparisonPredicate+MGLAdditions.mm b/platform/darwin/src/NSComparisonPredicate+MGLAdditions.mm
index 58390b0b81..58b37fae0e 100644
--- a/platform/darwin/src/NSComparisonPredicate+MGLAdditions.mm
+++ b/platform/darwin/src/NSComparisonPredicate+MGLAdditions.mm
@@ -105,7 +105,7 @@
             }
             mbgl::style::InFilter inFilter;
             inFilter.key = leftExpression.keyPath.UTF8String;
-            inFilter.values = rightExpression.mgl_filterValues;
+            inFilter.values = rightExpression.mgl_aggregateMBGLValue;
             return inFilter;
         }
         case NSContainsPredicateOperatorType: {
@@ -119,7 +119,7 @@
             }
             mbgl::style::InFilter inFilter;
             inFilter.key = rightExpression.keyPath.UTF8String;
-            inFilter.values = leftExpression.mgl_filterValues;
+            inFilter.values = leftExpression.mgl_aggregateMBGLValue;
             return inFilter;
         }
         case NSBetweenPredicateOperatorType: {
@@ -131,7 +131,7 @@
                 [NSException raise:NSInvalidArgumentException
                             format:@"Right side of BETWEEN predicate must be an array."]; // not NSSet
             }
-            auto values = rightExpression.mgl_filterValues;
+            auto values = rightExpression.mgl_aggregateMBGLValue;
             if (values.size() != 2) {
                 [NSException raise:NSInvalidArgumentException
                             format:@"Right side of BETWEEN predicate must have two items."];
@@ -182,9 +182,9 @@
     NSExpressionType rightType = rightExpression.expressionType;
     mbgl::Value value;
     if (leftType == NSKeyPathExpressionType && rightType == NSConstantValueExpressionType) {
-        value = rightExpression.mgl_filterValue;
+        value = rightExpression.mgl_constantMBGLValue;
     } else if (leftType == NSConstantValueExpressionType && rightType == NSKeyPathExpressionType) {
-        value = leftExpression.mgl_filterValue;
+        value = leftExpression.mgl_constantMBGLValue;
     } else {
         [NSException raise:NSInvalidArgumentException
                     format:@"Comparison predicate must compare an attribute (as a key path) to a constant or vice versa."];
diff --git a/platform/darwin/src/NSDictionary+MGLAdditions.mm b/platform/darwin/src/NSDictionary+MGLAdditions.mm
index 1023e91a48..aad7fd8810 100644
--- a/platform/darwin/src/NSDictionary+MGLAdditions.mm
+++ b/platform/darwin/src/NSDictionary+MGLAdditions.mm
@@ -15,7 +15,7 @@
             propertyMap[[key UTF8String]] = [array mgl_vector];
         } else {
             NSExpression *expression = [NSExpression expressionForConstantValue:self[key]];
-            propertyMap[[key UTF8String]] = [expression mgl_filterValue];
+            propertyMap[[key UTF8String]] = expression.mgl_constantMBGLValue;
         }
     }
     return propertyMap;
diff --git a/platform/darwin/src/NSExpression+MGLAdditions.h b/platform/darwin/src/NSExpression+MGLAdditions.h
index 6d0fff5760..c60d6d78ba 100644
--- a/platform/darwin/src/NSExpression+MGLAdditions.h
+++ b/platform/darwin/src/NSExpression+MGLAdditions.h
@@ -2,10 +2,14 @@
 
 #include <mbgl/style/filter.hpp>
 
+NS_ASSUME_NONNULL_BEGIN
+
 @interface NSExpression (MGLAdditions)
 
-- (mbgl::Value)mgl_filterValue;
-- (std::vector<mbgl::Value>)mgl_filterValues;
-- (mbgl::FeatureIdentifier)mgl_featureIdentifier;
+@property (nonatomic, readonly) mbgl::Value mgl_constantMBGLValue;
+@property (nonatomic, readonly) std::vector<mbgl::Value> mgl_aggregateMBGLValue;
+@property (nonatomic, readonly) mbgl::FeatureIdentifier mgl_featureIdentifier;
 
 @end
+
+NS_ASSUME_NONNULL_END
diff --git a/platform/darwin/src/NSExpression+MGLAdditions.mm b/platform/darwin/src/NSExpression+MGLAdditions.mm
index 97f3e11dba..f11a1919cf 100644
--- a/platform/darwin/src/NSExpression+MGLAdditions.mm
+++ b/platform/darwin/src/NSExpression+MGLAdditions.mm
@@ -2,31 +2,25 @@
 
 @implementation NSExpression (MGLAdditions)
 
-- (std::vector<mbgl::Value>)mgl_filterValues
-{
+- (std::vector<mbgl::Value>)mgl_aggregateMBGLValue {
     if ([self.constantValue isKindOfClass:[NSArray class]] || [self.constantValue isKindOfClass:[NSSet class]]) {
         std::vector<mbgl::Value> convertedValues;
-        for (id item in self.constantValue) {
-            id constantValue = item;
-            if ([item isKindOfClass:[NSExpression class]]) {
-                constantValue = [constantValue constantValue];
+        for (id value in self.constantValue) {
+            NSExpression *expression = value;
+            if (![expression isKindOfClass:[NSExpression class]]) {
+                expression = [NSExpression expressionForConstantValue:expression];
             }
-            convertedValues.push_back([self mgl_convertedValueWithValue:constantValue]);
+            convertedValues.push_back(expression.mgl_constantMBGLValue);
         }
         return convertedValues;
     }
     [NSException raise:NSInvalidArgumentException
                 format:@"Constant value expression must contain an array or set."];
-    return { };
-}
-
-- (mbgl::Value)mgl_filterValue
-{
-    return [self mgl_convertedValueWithValue:self.constantValue];
+    return {};
 }
 
-- (mbgl::Value)mgl_convertedValueWithValue:(id)value
-{
+- (mbgl::Value)mgl_constantMBGLValue {
+    id value = self.constantValue;
     if ([value isKindOfClass:NSString.class]) {
         return { std::string([(NSString *)value UTF8String]) };
     } else if ([value isKindOfClass:NSNumber.class]) {
@@ -66,30 +60,26 @@
         [NSException raise:NSInvalidArgumentException
                     format:@"Can’t convert %s:%@ to mbgl::Value", [value objCType], value];
     }
-    return { };
+    return {};
 }
 
-- (mbgl::FeatureIdentifier)mgl_featureIdentifier
-{
-    id value = self.constantValue;
-    mbgl::Value mbglValue = [self mgl_filterValue];
+- (mbgl::FeatureIdentifier)mgl_featureIdentifier {
+    mbgl::Value mbglValue = self.mgl_constantMBGLValue;
     
-    if ([value isKindOfClass:NSString.class]) {
+    if (mbglValue.is<std::string>()) {
         return mbglValue.get<std::string>();
-    } else if ([value isKindOfClass:NSNumber.class]) {
-        NSNumber *number = (NSNumber *)value;
-        if ((strcmp([number objCType], @encode(char)) == 0) ||
-            (strcmp([number objCType], @encode(BOOL)) == 0)) {
-            return mbglValue.get<bool>();
-        } else if ( strcmp([number objCType], @encode(double)) == 0 ||
-                    strcmp([number objCType], @encode(float)) == 0) {
-            return mbglValue.get<double>();
-        } else if ([number compare:@(0)] == NSOrderedDescending ||
-                   [number compare:@(0)] == NSOrderedSame) {
-            return mbglValue.get<uint64_t>();
-        } else if ([number compare:@(0)] == NSOrderedAscending) {
-            return mbglValue.get<int64_t>();
-        }
+    }
+    if (mbglValue.is<bool>()) {
+        return mbglValue.get<bool>();
+    }
+    if (mbglValue.is<double>()) {
+        return mbglValue.get<double>();
+    }
+    if (mbglValue.is<uint64_t>()) {
+        return mbglValue.get<uint64_t>();
+    }
+    if (mbglValue.is<int64_t>()) {
+        return mbglValue.get<int64_t>();
     }
     
     return {};
diff --git a/platform/darwin/test/MGLExpressionTests.mm b/platform/darwin/test/MGLExpressionTests.mm
index e78f87a99b..00b57c15f0 100644
--- a/platform/darwin/test/MGLExpressionTests.mm
+++ b/platform/darwin/test/MGLExpressionTests.mm
@@ -28,27 +28,35 @@
 - (void)testExpressionConversionString
 {
     NSComparisonPredicate *predicate = [self equalityComparisonPredicateWithRightConstantValue:@"bar"];
-    mbgl::Value convertedValue = predicate.rightExpression.mgl_filterValue;
-    XCTAssert(convertedValue.is<std::string>() == true);
+    mbgl::Value convertedValue = predicate.rightExpression.mgl_constantMBGLValue;
+    XCTAssertTrue(convertedValue.is<std::string>());
     XCTAssertEqualObjects(@(convertedValue.get<std::string>().c_str()), @"bar");
 }
 
+- (void)testExpressionConversionStringWithUnicode
+{
+    NSComparisonPredicate *predicate = [self equalityComparisonPredicateWithRightConstantValue:@"🆔🆗🇦🇶"];
+    mbgl::Value convertedValue = predicate.rightExpression.mgl_constantMBGLValue;
+    XCTAssertTrue(convertedValue.is<std::string>());
+    XCTAssertEqual(convertedValue.get<std::string>(), "🆔🆗🇦🇶");
+}
+
 #pragma mark - Boolean Tests
 
 - (void)testExpressionConversionBooleanTrue
 {
     NSComparisonPredicate *predicate = [self equalityComparisonPredicateWithRightConstantValue:@YES];
-    mbgl::Value convertedValue = predicate.rightExpression.mgl_filterValue;
-    XCTAssert(convertedValue.is<bool>() == true);
-    XCTAssert(convertedValue.get<bool>() == true);
+    mbgl::Value convertedValue = predicate.rightExpression.mgl_constantMBGLValue;
+    XCTAssertTrue(convertedValue.is<bool>());
+    XCTAssertEqual(convertedValue.get<bool>(), true);
 }
 
 - (void)testExpressionConversionBooleanFalse
 {
     NSComparisonPredicate *predicate = [self equalityComparisonPredicateWithRightConstantValue:@NO];
-    mbgl::Value convertedValue = predicate.rightExpression.mgl_filterValue;
-    XCTAssert(convertedValue.is<bool>() == true);
-    XCTAssert(convertedValue.get<bool>() == false);
+    mbgl::Value convertedValue = predicate.rightExpression.mgl_constantMBGLValue;
+    XCTAssertTrue(convertedValue.is<bool>());
+    XCTAssertEqual(convertedValue.get<bool>(), false);
 }
 
 #pragma mark - Floating Point Tests
@@ -59,12 +67,12 @@
     mbgl::Value convertedValue;
 
     predicate = [self equalityComparisonPredicateWithRightConstantValue:[NSNumber numberWithDouble:DBL_MIN]];
-    convertedValue = predicate.rightExpression.mgl_filterValue;
+    convertedValue = predicate.rightExpression.mgl_constantMBGLValue;
     XCTAssertTrue(convertedValue.is<double>());
     XCTAssertEqual(convertedValue.get<double>(), DBL_MIN);
 
     predicate = [self equalityComparisonPredicateWithRightConstantValue:[NSNumber numberWithDouble:DBL_MAX]];
-    convertedValue = predicate.rightExpression.mgl_filterValue;
+    convertedValue = predicate.rightExpression.mgl_constantMBGLValue;
     XCTAssertTrue(convertedValue.is<double>());
     XCTAssertEqual(convertedValue.get<double>(), DBL_MAX);
 }
@@ -72,7 +80,7 @@
 - (void)testExpressionConversionFloat
 {
     // Because we can't guarantee precision when using float, and because
-    // we warn the user to this effect in mgl_convertedValueWithValue:,
+    // we warn the user to this effect in -[NSExpression mgl_constantMBGLValue],
     // we just check that things are in the ballpark here with integer values
     // and some lower-precision checks.
 
@@ -80,26 +88,24 @@
     mbgl::Value convertedValue;
 
     predicate = [self equalityComparisonPredicateWithRightConstantValue:[NSNumber numberWithFloat:-1]];
-    convertedValue = predicate.rightExpression.mgl_filterValue;
+    convertedValue = predicate.rightExpression.mgl_constantMBGLValue;
     XCTAssertTrue(convertedValue.is<double>());
     XCTAssertEqual(convertedValue.get<double>(), -1);
 
     predicate = [self equalityComparisonPredicateWithRightConstantValue:[NSNumber numberWithFloat:1]];
-    convertedValue = predicate.rightExpression.mgl_filterValue;
+    convertedValue = predicate.rightExpression.mgl_constantMBGLValue;
     XCTAssertTrue(convertedValue.is<double>());
     XCTAssertEqual(convertedValue.get<double>(), 1);
 
     predicate = [self equalityComparisonPredicateWithRightConstantValue:[NSNumber numberWithFloat:-23.232342]];
-    convertedValue = predicate.rightExpression.mgl_filterValue;
+    convertedValue = predicate.rightExpression.mgl_constantMBGLValue;
     XCTAssertTrue(convertedValue.is<double>());
-    XCTAssertLessThan(-23.24, convertedValue.get<double>());
-    XCTAssertGreaterThan(-23.23, convertedValue.get<double>());
+    XCTAssertEqualWithAccuracy(convertedValue.get<double>(), -23.232342, 0.000001);
 
     predicate = [self equalityComparisonPredicateWithRightConstantValue:[NSNumber numberWithFloat:23.232342]];
-    convertedValue = predicate.rightExpression.mgl_filterValue;
+    convertedValue = predicate.rightExpression.mgl_constantMBGLValue;
     XCTAssertTrue(convertedValue.is<double>());
-    XCTAssertLessThan(23.23, convertedValue.get<double>());
-    XCTAssertGreaterThan(23.24, convertedValue.get<double>());
+    XCTAssertEqualWithAccuracy(convertedValue.get<double>(), 23.232342, 0.000001);
 }
 
 #pragma mark - Integer Tests
@@ -132,7 +138,7 @@
     for (NSNumber *min in minValues)
     {
         predicate = [self equalityComparisonPredicateWithRightConstantValue:min];
-        convertedValue = predicate.rightExpression.mgl_filterValue;
+        convertedValue = predicate.rightExpression.mgl_constantMBGLValue;
         XCTAssertTrue(convertedValue.is<int64_t>());
         XCTAssertEqual(convertedValue.get<int64_t>(), min.longLongValue);
     }
@@ -144,7 +150,7 @@
     for (NSNumber *max in maxValues)
     {
         predicate = [self equalityComparisonPredicateWithRightConstantValue:max];
-        convertedValue = predicate.rightExpression.mgl_filterValue;
+        convertedValue = predicate.rightExpression.mgl_constantMBGLValue;
         XCTAssertTrue(convertedValue.is<uint64_t>());
         XCTAssertEqual(convertedValue.get<uint64_t>(), max.unsignedLongLongValue);
     }
@@ -179,7 +185,7 @@
     for (NSNumber *min in minValues)
     {
         predicate = [self equalityComparisonPredicateWithRightConstantValue:min];
-        convertedValue = predicate.rightExpression.mgl_filterValue;
+        convertedValue = predicate.rightExpression.mgl_constantMBGLValue;
         XCTAssertTrue(convertedValue.is<uint64_t>());
         XCTAssertEqual(convertedValue.get<uint64_t>(), min.unsignedLongLongValue);
     }
@@ -191,7 +197,7 @@
     for (NSNumber *max in maxValues)
     {
         predicate = [self equalityComparisonPredicateWithRightConstantValue:max];
-        convertedValue = predicate.rightExpression.mgl_filterValue;
+        convertedValue = predicate.rightExpression.mgl_constantMBGLValue;
         XCTAssertTrue(convertedValue.is<uint64_t>());
         XCTAssertEqual(convertedValue.get<uint64_t>(), max.unsignedLongLongValue);
     }
@@ -202,7 +208,7 @@
 - (void)testExpressionConversionNull
 {
     NSComparisonPredicate *predicate = [self equalityComparisonPredicateWithRightConstantValue:[NSNull null]];
-    mbgl::Value convertedValue = predicate.rightExpression.mgl_filterValue;
+    mbgl::Value convertedValue = predicate.rightExpression.mgl_constantMBGLValue;
     XCTAssertTrue(convertedValue.is<mbgl::NullValue>());
 }