tei/MapLibreParticleLab
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

[ios, macos] Cleaned up expression conversion

Browse Source
This commit is contained in:
Minh Nguyễn
2016-12-26 15:07:43 -08:00
committed by Minh Nguyễn
parent e6132d248b
commit aef36956ee
8 changed files with 95 additions and 92 deletions
Download Patch File Download Diff File Expand all files Collapse all files

4
platform/darwin/src/NSArray+MGLAdditions.mm
View File

@@ -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;
}

10
platform/darwin/src/NSComparisonPredicate+MGLAdditions.mm
View File

@@ -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."];

2
platform/darwin/src/NSDictionary+MGLAdditions.mm
View File

@@ -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;

10
platform/darwin/src/NSExpression+MGLAdditions.h
View File

@@ -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

60
platform/darwin/src/NSExpression+MGLAdditions.mm
View File

@@ -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 { };
return {};
}
- (mbgl::Value)mgl_filterValue
{
return [self mgl_convertedValueWithValue:self.constantValue];
}
- (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 {};

34
platform/darwin/src/NSPredicate+MGLAdditions.mm
View File

@@ -5,7 +5,7 @@
class FilterEvaluator {
public:
NSArray* getPredicates(std::vector<mbgl::style::Filter> filters) {
NSArray *getPredicates(std::vector<mbgl::style::Filter> filters) {
NSMutableArray *predicates = [NSMutableArray arrayWithCapacity:filters.size()];
for (auto filter : filters) {
[predicates addObject:mbgl::style::Filter::visit(filter, FilterEvaluator())];
@@ -13,52 +13,52 @@ public:
return predicates;
}
NSArray* getValues(std::vector<mbgl::Value> values) {
NSExpression *getValues(std::vector<mbgl::Value> values) {
NSMutableArray *array = [NSMutableArray arrayWithCapacity:values.size()];
for (auto value : values) {
id constantValue = mbgl::Value::visit(value, ValueEvaluator());
[array addObject:[NSExpression expressionForConstantValue:constantValue]];
}
return array;
return [NSExpression expressionForAggregate:array];
}
NSPredicate* operator()(mbgl::style::NullFilter filter) {
NSPredicate *operator()(mbgl::style::NullFilter filter) {
return nil;
}
NSPredicate* operator()(mbgl::style::EqualsFilter filter) {
NSPredicate *operator()(mbgl::style::EqualsFilter filter) {
return [NSPredicate predicateWithFormat:@"%K == %@", @(filter.key.c_str()), mbgl::Value::visit(filter.value, ValueEvaluator())];
}
NSPredicate* operator()(mbgl::style::NotEqualsFilter filter) {
NSPredicate *operator()(mbgl::style::NotEqualsFilter filter) {
return [NSPredicate predicateWithFormat:@"%K != %@", @(filter.key.c_str()), mbgl::Value::visit(filter.value, ValueEvaluator())];
}
NSPredicate* operator()(mbgl::style::GreaterThanFilter filter) {
NSPredicate *operator()(mbgl::style::GreaterThanFilter filter) {
return [NSPredicate predicateWithFormat:@"%K > %@", @(filter.key.c_str()), mbgl::Value::visit(filter.value, ValueEvaluator())];
}
NSPredicate* operator()(mbgl::style::GreaterThanEqualsFilter filter) {
NSPredicate *operator()(mbgl::style::GreaterThanEqualsFilter filter) {
return [NSPredicate predicateWithFormat:@"%K >= %@", @(filter.key.c_str()), mbgl::Value::visit(filter.value, ValueEvaluator())];
}
NSPredicate* operator()(mbgl::style::LessThanFilter filter) {
NSPredicate *operator()(mbgl::style::LessThanFilter filter) {
return [NSPredicate predicateWithFormat:@"%K < %@", @(filter.key.c_str()), mbgl::Value::visit(filter.value, ValueEvaluator())];
}
NSPredicate* operator()(mbgl::style::LessThanEqualsFilter filter) {
NSPredicate *operator()(mbgl::style::LessThanEqualsFilter filter) {
return [NSPredicate predicateWithFormat:@"%K <= %@", @(filter.key.c_str()), mbgl::Value::visit(filter.value, ValueEvaluator())];
}
NSPredicate* operator()(mbgl::style::InFilter filter) {
NSPredicate *operator()(mbgl::style::InFilter filter) {
return [NSPredicate predicateWithFormat:@"%K IN %@", @(filter.key.c_str()), getValues(filter.values)];
}
NSPredicate* operator()(mbgl::style::NotInFilter filter) {
NSPredicate *operator()(mbgl::style::NotInFilter filter) {
return [NSPredicate predicateWithFormat:@"NOT %K IN %@", @(filter.key.c_str()), getValues(filter.values)];
}
NSPredicate* operator()(mbgl::style::AnyFilter filter) {
NSPredicate *operator()(mbgl::style::AnyFilter filter) {
NSArray *subpredicates = getPredicates(filter.filters);
if (subpredicates.count) {
return [NSCompoundPredicate orPredicateWithSubpredicates:subpredicates];
@@ -66,7 +66,7 @@ public:
return [NSPredicate predicateWithValue:NO];
}
NSPredicate* operator()(mbgl::style::AllFilter filter) {
NSPredicate *operator()(mbgl::style::AllFilter filter) {
// Convert [all, [>=, key, lower], [<=, key, upper]] to key BETWEEN {lower, upper}
if (filter.filters.size() == 2) {
auto leftFilter = filter.filters[0];
@@ -108,7 +108,7 @@ public:
return [NSPredicate predicateWithValue:YES];
}
NSPredicate* operator()(mbgl::style::NoneFilter filter) {
NSPredicate *operator()(mbgl::style::NoneFilter filter) {
NSArray *subpredicates = getPredicates(filter.filters);
if (subpredicates.count > 1) {
NSCompoundPredicate *predicate = [NSCompoundPredicate orPredicateWithSubpredicates:subpredicates];
@@ -120,11 +120,11 @@ public:
}
}
NSPredicate* operator()(mbgl::style::HasFilter filter) {
NSPredicate *operator()(mbgl::style::HasFilter filter) {
return [NSPredicate predicateWithFormat:@"%K != nil", @(filter.key.c_str())];
}
NSPredicate* operator()(mbgl::style::NotHasFilter filter) {
NSPredicate *operator()(mbgl::style::NotHasFilter filter) {
return [NSPredicate predicateWithFormat:@"%K == nil", @(filter.key.c_str())];
}

54
platform/darwin/test/MGLExpressionTests.mm
View File

@@ -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>());
}

13
platform/darwin/test/MGLPredicateTests.mm
View File

@@ -369,9 +369,9 @@ namespace mbgl {
[self testSymmetryWithFormat:@"a > 1" reverseFormat:@"1 < a" mustRoundTrip:YES];
[self testSymmetryWithFormat:@"a >= 1" reverseFormat:@"1 <= a" mustRoundTrip:YES];
[self testSymmetryWithFormat:@"a BETWEEN {1, 2}" reverseFormat:nil mustRoundTrip:YES];
[self testSymmetryWithFormat:@"a BETWEEN {1, 2}" reverseFormat:@"1 <= a && 2 >= a" mustRoundTrip:YES];
[self testSymmetryWithPredicate:[NSPredicate predicateWithFormat:@"a BETWEEN %@", @[@1, @2]]
reversePredicate:nil
reversePredicate:[NSPredicate predicateWithFormat:@"1 <= a && 2 >= a"]
mustRoundTrip:YES];
XCTAssertThrowsSpecificNamed([NSPredicate predicateWithFormat:@"{1, 2} BETWEEN a"].mgl_filter, NSException, NSInvalidArgumentException);
NSPredicate *betweenSetPredicate = [NSPredicate predicateWithFormat:@"a BETWEEN %@", [NSSet setWithObjects:@1, @2, nil]];
@@ -384,9 +384,11 @@ namespace mbgl {
reversePredicate:[NSPredicate predicateWithFormat:@"%@ CONTAINS a", @[@1, @2]]
mustRoundTrip:YES];
[self testSymmetryWithFormat:@"{1, 2} CONTAINS a" reverseFormat:@"a IN {1, 2}" mustRoundTrip:NO];
// The reverse formats here are a bit backwards because we canonicalize
// a reverse CONTAINS to a forward IN.
[self testSymmetryWithFormat:@"{1, 2} CONTAINS a" reverseFormat:@"{1, 2} CONTAINS a" mustRoundTrip:NO];
[self testSymmetryWithPredicate:[NSPredicate predicateWithFormat:@"%@ CONTAINS a", @[@1, @2]]
reversePredicate:[NSPredicate predicateWithFormat:@"a IN %@", @[@1, @2]]
reversePredicate:[NSPredicate predicateWithFormat:@"%@ CONTAINS a", @[@1, @2]]
mustRoundTrip:NO];
}
@@ -400,7 +402,8 @@ namespace mbgl {
auto forwardFilter = forwardPredicate.mgl_filter;
NSPredicate *forwardPredicateAfter = [NSPredicate mgl_predicateWithFilter:forwardFilter];
if (mustRoundTrip) {
// Aggregates should round-trip, but for some reason only their format strings do.
// A collection of ints may turn into an aggregate of longs, for
// example, so compare formats instead of the predicates themselves.
XCTAssertEqualObjects(forwardPredicate.predicateFormat, forwardPredicateAfter.predicateFormat);
}