Allow predicates to test whether a feature lies within a given shape

platform/darwin/docs/guides/For Style Authors.md.ejs

@@ -361,6 +361,7 @@ In style specification | Method, function, or predicate type | Format string syn
 `case`                 | `+[NSExpression expressionForConditional:trueExpression:falseExpression:]` or `MGL_IF` or `+[NSExpression mgl_expressionForConditional:trueExpression:falseExpresssion:]` | `TERNARY(1 = 2, YES, NO)` or `MGL_IF(1 = 2, YES, 2 = 2, YES, NO)`
 `coalesce`             | `mgl_coalesce:` | `mgl_coalesce({x, y, z})`
 `match`                | `MGL_MATCH` or `+[NSExpression mgl_expressionForMatchingExpression:inDictionary:defaultExpression:]` | `MGL_MATCH(x, 0, 'zero match', 1, 'one match', 'two match', 'default')`
+`within`               | `NSInPredicateOperatorType` | `SELF IN %@` or `%@ CONTAINS SELF` where `%@` is an `MGLShape`
 `interpolate`          | `mgl_interpolate:withCurveType:parameters:stops:` or `+[NSExpression mgl_expressionForInterpolatingExpression:withCurveType:parameters:stops:]` |
 `step`                 | `mgl_step:from:stops:` or `+[NSExpression mgl_expressionForSteppingExpression:fromExpression:stops:]` |
 `let`                  | `mgl_expressionWithContext:` | `MGL_LET('ios', 11, 'macos', 10.13, $ios + $macos)`

platform/darwin/docs/guides/Predicates and Expressions.md

@@ -55,6 +55,18 @@ The following aggregate operators are supported:
 `NSInPredicateOperatorType`       | `key IN { 'iOS', 'macOS', 'tvOS', 'watchOS' }`
 `NSContainsPredicateOperatorType` | `{ 'iOS', 'macOS', 'tvOS', 'watchOS' } CONTAINS key`
 
+You can use the `IN` and `CONTAINS` operators to test whether a value appears in a collection, whether a string is a substring of a larger string, or whether the evaluated feature (`SELF`) lies within a given `MGLShape` or `MGLFeature`. For example, to show one delicious local chain of sandwich shops, but not similarly named steakhouses and pizzerias:
+
+```objc
+MGLPolygon *cincinnati = [MGLPolygon polygonWithCoordinates:cincinnatiCoordinates count:sizeof(cincinnatiCoordinates) / sizeof(cincinnatiCoordinates[0])];
+deliLayer.predicate = [NSPredicate predicateWithFormat:@"class = 'food_and_drink' AND name CONTAINS 'Izzy' AND SELF IN %@", cincinnati];
+```
+
+```swift
+let cincinnati = MGLPolygon(coordinates: &cincinnatiCoordinates, count: UInt(cincinnatiCoordinates.count))
+deliLayer.predicate = NSPredicate(format: "class = 'food_and_drink' AND name CONTAINS 'Izzy' AND SELF IN %@", cincinnati)
+```
+
 The following combinations of comparison operators and modifiers are supported:
 
 `NSComparisonPredicateModifier` | `NSPredicateOperatorType`           | Format string syntax

platform/darwin/src/MGLConversion.h

@@ -1,3 +1,5 @@
+#import "MGLShape_Private.h"
+
 #include <mbgl/style/conversion_impl.hpp>
 
 NS_ASSUME_NONNULL_BEGIN
@@ -124,9 +126,21 @@ class ConversionTraits<Holder> {
         }
     }
 
-    static optional<GeoJSON> toGeoJSON(const Holder&, Error& error) {
-        error = { "toGeoJSON not implemented" };
-        return {};
+    static optional<GeoJSON> toGeoJSON(const Holder& holder, Error& error) {
+        id object = holder.value;
+        if ([object isKindOfClass:[NSDictionary class]]) {
+            NSError *serializationError;
+            NSData *data = [NSJSONSerialization dataWithJSONObject:object options:0 error:&serializationError];
+            if (serializationError) {
+                error = { std::string(serializationError.localizedDescription.UTF8String) };
+                return {};
+            }
+            NSString *string = [[NSString alloc] initWithData:data encoding:NSUTF8StringEncoding];
+            return mapbox::geojson::parse(string.UTF8String);
+        } else {
+            error = { std::string([NSString stringWithFormat:@"%@ is not a GeoJSON object.", object].UTF8String) };
+            return {};
+        }
     }
 
 private:

platform/darwin/src/MGLFeature.mm

@@ -352,19 +352,20 @@ - (NSDictionary *)geoJSONDictionary {
 class GeometryEvaluator {
 private:
     const mbgl::PropertyMap *shared_properties;
+    const bool is_in_feature;
 
 public:
-    GeometryEvaluator(const mbgl::PropertyMap *properties = nullptr):
-        shared_properties(properties)
+    GeometryEvaluator(const mbgl::PropertyMap *properties = nullptr, const bool isInFeature = false):
+        shared_properties(properties),
+        is_in_feature(isInFeature)
     {}
 
-    MGLShape <MGLFeature> * operator()(const mbgl::EmptyGeometry &) const {
-        MGLEmptyFeature *feature = [[MGLEmptyFeature alloc] init];
-        return feature;
+    MGLShape * operator()(const mbgl::EmptyGeometry &) const {
+        return is_in_feature ? [[MGLEmptyFeature alloc] init] : [[MGLShape alloc] init];
     }
 
-    MGLShape <MGLFeature> * operator()(const mbgl::Point<T> &geometry) const {
-        Class pointFeatureClass = [MGLPointFeature class];
+    MGLShape * operator()(const mbgl::Point<T> &geometry) const {
+        Class shapeClass = is_in_feature ? [MGLPointFeature class] : [MGLPointAnnotation class];
 
         // If we're dealing with a cluster, we should change the class type.
         // This could be generic and build the subclass at runtime if it turns
@@ -375,59 +376,64 @@ - (NSDictionary *)geoJSONDictionary {
                 auto clusterValue = clusterIt->second;
                 if (clusterValue.template is<bool>()) {
                     if (clusterValue.template get<bool>()) {
-                        pointFeatureClass = [MGLPointFeatureCluster class];
+                        shapeClass = [MGLPointFeatureCluster class];
                     }
                 }
             }
         }
 
-        MGLPointFeature *feature = [[pointFeatureClass alloc] init];
-        feature.coordinate = toLocationCoordinate2D(geometry);
-        return feature;
+        MGLPointAnnotation *shape = [[shapeClass alloc] init];
+        shape.coordinate = toLocationCoordinate2D(geometry);
+        return shape;
     }
 
-    MGLShape <MGLFeature> * operator()(const mbgl::LineString<T> &geometry) const {
+    MGLShape * operator()(const mbgl::LineString<T> &geometry) const {
         std::vector<CLLocationCoordinate2D> coordinates = toLocationCoordinates2D(geometry);
-        return [MGLPolylineFeature polylineWithCoordinates:&coordinates[0] count:coordinates.size()];
+        Class shapeClass = is_in_feature ? [MGLPolylineFeature class] : [MGLPolyline class];
+        return [shapeClass polylineWithCoordinates:&coordinates[0] count:coordinates.size()];
     }
 
-    MGLShape <MGLFeature> * operator()(const mbgl::Polygon<T> &geometry) const {
-        return toShape<MGLPolygonFeature>(geometry);
+    MGLShape * operator()(const mbgl::Polygon<T> &geometry) const {
+        return toShape<MGLPolygon, MGLPolygonFeature>(geometry, is_in_feature);
     }
 
-    MGLShape <MGLFeature> * operator()(const mbgl::MultiPoint<T> &geometry) const {
+    MGLShape * operator()(const mbgl::MultiPoint<T> &geometry) const {
         std::vector<CLLocationCoordinate2D> coordinates = toLocationCoordinates2D(geometry);
-        return [[MGLPointCollectionFeature alloc] initWithCoordinates:&coordinates[0] count:coordinates.size()];
+        Class shapeClass = is_in_feature ? [MGLPointCollectionFeature class] : [MGLPointCollection class];
+        return [[shapeClass alloc] initWithCoordinates:&coordinates[0] count:coordinates.size()];
     }
 
-    MGLShape <MGLFeature> * operator()(const mbgl::MultiLineString<T> &geometry) const {
+    MGLShape * operator()(const mbgl::MultiLineString<T> &geometry) const {
         NSMutableArray *polylines = [NSMutableArray arrayWithCapacity:geometry.size()];
         for (auto &lineString : geometry) {
             std::vector<CLLocationCoordinate2D> coordinates = toLocationCoordinates2D(lineString);
             MGLPolyline *polyline = [MGLPolyline polylineWithCoordinates:&coordinates[0] count:coordinates.size()];
             [polylines addObject:polyline];
         }
 
-        return [MGLMultiPolylineFeature multiPolylineWithPolylines:polylines];
+        Class shapeClass = is_in_feature ? [MGLMultiPolylineFeature class] : [MGLMultiPolyline class];
+        return [shapeClass multiPolylineWithPolylines:polylines];
     }
 
-    MGLShape <MGLFeature> * operator()(const mbgl::MultiPolygon<T> &geometry) const {
+    MGLShape * operator()(const mbgl::MultiPolygon<T> &geometry) const {
         NSMutableArray *polygons = [NSMutableArray arrayWithCapacity:geometry.size()];
         for (auto &polygon : geometry) {
-            [polygons addObject:toShape(polygon)];
+            [polygons addObject:toShape(polygon, false)];
         }
 
-        return [MGLMultiPolygonFeature multiPolygonWithPolygons:polygons];
+        Class shapeClass = is_in_feature ? [MGLMultiPolygonFeature class] : [MGLMultiPolygon class];
+        return [shapeClass multiPolygonWithPolygons:polygons];
     }
 
-    MGLShape <MGLFeature> * operator()(const mapbox::geometry::geometry_collection<T> &collection) const {
+    MGLShape * operator()(const mapbox::geometry::geometry_collection<T> &collection) const {
         NSMutableArray *shapes = [NSMutableArray arrayWithCapacity:collection.size()];
         for (auto &geometry : collection) {
             // This is very much like the transformation that happens in MGLFeaturesFromMBGLFeatures(), but these are raw geometries with no associated feature IDs or attributes.
-            MGLShape <MGLFeature> *shape = mapbox::geometry::geometry<T>::visit(geometry, *this);
+            MGLShape *shape = mapbox::geometry::geometry<T>::visit(geometry, *this);
             [shapes addObject:shape];
         }
-        return [MGLShapeCollectionFeature shapeCollectionWithShapes:shapes];
+        Class shapeClass = is_in_feature ? [MGLShapeCollectionFeature class] : [MGLShapeCollection class];
+        return [shapeClass shapeCollectionWithShapes:shapes];
     }
 
 private:
@@ -442,8 +448,8 @@ static CLLocationCoordinate2D toLocationCoordinate2D(const mbgl::Point<T> &point
         return coordinates;
     }
 
-    template<typename U = MGLPolygon>
-    static U *toShape(const mbgl::Polygon<T> &geometry) {
+    template<typename U = MGLPolygon, typename V = MGLPolygonFeature>
+    static U *toShape(const mbgl::Polygon<T> &geometry, const bool isInFeature) {
         auto &linearRing = geometry.front();
         std::vector<CLLocationCoordinate2D> coordinates = toLocationCoordinates2D(linearRing);
         NSMutableArray *innerPolygons;
@@ -457,16 +463,17 @@ static CLLocationCoordinate2D toLocationCoordinate2D(const mbgl::Point<T> &point
             }
         }
 
-        return [U polygonWithCoordinates:&coordinates[0] count:coordinates.size() interiorPolygons:innerPolygons];
+        Class shapeClass = isInFeature ? [V class] : [U class];
+        return [shapeClass polygonWithCoordinates:&coordinates[0] count:coordinates.size() interiorPolygons:innerPolygons];
     }
 };
 
 template <typename T>
 class GeoJSONEvaluator {
 public:
-    MGLShape <MGLFeature> * operator()(const mbgl::Geometry<T> &geometry) const {
+    MGLShape * operator()(const mbgl::Geometry<T> &geometry) const {
         GeometryEvaluator<T> evaluator;
-        MGLShape <MGLFeature> *shape = mapbox::geometry::geometry<T>::visit(geometry, evaluator);
+        MGLShape *shape = mapbox::geometry::geometry<T>::visit(geometry, evaluator);
         return shape;
     }
 
@@ -507,8 +514,8 @@ static CLLocationCoordinate2D toLocationCoordinate2D(const mbgl::Point<T> &point
         ValueEvaluator evaluator;
         attributes[@(pair.first.c_str())] = mbgl::Value::visit(value, evaluator);
     }
-    GeometryEvaluator<double> evaluator(&feature.properties);
-    MGLShape <MGLFeature> *shape = mapbox::geometry::geometry<double>::visit(feature.geometry, evaluator);
+    GeometryEvaluator<double> evaluator(&feature.properties, true);
+    MGLShape <MGLFeature> *shape = (MGLShape <MGLFeature> *)mapbox::geometry::geometry<double>::visit(feature.geometry, evaluator);
     if (!feature.id.is<mapbox::feature::null_value_t>()) {
         shape.identifier = mbgl::FeatureIdentifier::visit(feature.id, ValueEvaluator());
     }

platform/darwin/src/MGLShape.h

@@ -29,6 +29,12 @@ NS_ASSUME_NONNULL_BEGIN
  shapes collectively using a concrete instance of `MGLVectorStyleLayer`.
  Alternatively, you can add some kinds of shapes directly to a map view as
  annotations or overlays.
+
+ You can filter the features in a `MGLVectorStyleLayer` or vary their layout or
+ paint attributes based on the features’ geographies. Pass an `MGLShape` into an
+ `NSPredicate` with the format `SELF IN %@` or `%@ CONTAINS SELF` and set the
+ `MGLVectorStyleLayer.predicate` property to that predicate, or set a layout or
+ paint attribute to a similarly formatted `NSExpression`.
  */
 MGL_EXPORT
 @interface MGLShape : NSObject <MGLAnnotation, NSSecureCoding>

platform/darwin/src/NSComparisonPredicate+MGLAdditions.mm

@@ -161,6 +161,9 @@ - (id)mgl_jsonExpressionObject {
             return @[op, leftHandPredicate.mgl_jsonExpressionObject, rightHandPredicate.mgl_jsonExpressionObject];
         }
         case NSInPredicateOperatorType: {
+            if (self.leftExpression.expressionType == NSEvaluatedObjectExpressionType) {
+                return @[@"within", self.rightExpression.mgl_jsonExpressionObject];
+            }
             // An “in” expression comparing two string literals is unfortunately
             // misinterpreted as a legacy “in” filter due to ambiguity. Wrap one
             // argument in a “literal” expression to force an expression.

platform/darwin/src/NSExpression+MGLAdditions.mm

@@ -1,5 +1,6 @@
 #import "MGLFoundation_Private.h"
 #import "MGLGeometry_Private.h"
+#import "MGLShape_Private.h"
 #import "NSExpression+MGLPrivateAdditions.h"
 
 #import "MGLTypes.h"
@@ -539,6 +540,14 @@ - (id)mgl_has:(id)element {
 
 @end
 
+@implementation MGLShape (MGLExpressionAdditions)
+
+- (id)mgl_jsonExpressionObject {
+    return self.geoJSONDictionary;
+}
+
+@end
+
 @implementation NSExpression (MGLAdditions)
 
 + (NSExpression *)zoomLevelVariableExpression {
@@ -659,11 +668,24 @@ + (instancetype)expressionWithMGLJSONObject:(id)object {
     if ([object isKindOfClass:[NSString class]] ||
         [object isKindOfClass:[NSNumber class]] ||
         [object isKindOfClass:[NSValue class]] ||
-        [object isKindOfClass:[MGLColor class]]) {
+        [object isKindOfClass:[MGLColor class]] ||
+        [object isKindOfClass:[MGLShape class]]) {
         return [NSExpression expressionForConstantValue:object];
     }
 
     if ([object isKindOfClass:[NSDictionary class]]) {
+        if (object[@"type"]) {
+            NSError *error;
+            NSData *shapeData = [NSJSONSerialization dataWithJSONObject:object options:0 error:&error];
+            MGLShape *shape;
+            if (shapeData && !error) {
+                shape = [MGLShape shapeWithData:shapeData encoding:NSUTF8StringEncoding error:&error];
+            }
+            if (shape && !error) {
+                return [NSExpression expressionForConstantValue:shape];
+            }
+        }
+
         NSMutableDictionary *dictionary = [NSMutableDictionary dictionaryWithCapacity:[object count]];
         [object enumerateKeysAndObjectsUsingBlock:^(id _Nonnull key, id _Nonnull obj, BOOL * _Nonnull stop) {
             dictionary[key] = [NSExpression expressionWithMGLJSONObject:obj];
@@ -1031,6 +1053,10 @@ - (id)mgl_jsonExpressionObject {
                 } 
                 return @[jsonObject, attributedDictionary];
             }
+            if ([constantValue isKindOfClass:[MGLShape class]]) {
+                MGLShape *shape = (MGLShape *)constantValue;
+                return shape.geoJSONDictionary;
+            }
             return self.constantValue;
         }
 

platform/darwin/src/NSPredicate+MGLAdditions.mm

@@ -155,6 +155,14 @@ + (instancetype)predicateWithMGLJSONObject:(id)object {
         NSArray *subpredicates = MGLSubpredicatesWithJSONObjects([objects subarrayWithRange:NSMakeRange(1, objects.count - 1)]);
         return [NSCompoundPredicate orPredicateWithSubpredicates:subpredicates];
     }
+    if ([op isEqualToString:@"within"]) {
+        NSArray *subexpressions = MGLSubexpressionsWithJSONObjects([objects subarrayWithRange:NSMakeRange(1, objects.count - 1)]);
+        return [NSComparisonPredicate predicateWithLeftExpression:[NSExpression expressionForEvaluatedObject]
+                                                  rightExpression:subexpressions[0]
+                                                         modifier:NSDirectPredicateModifier
+                                                             type:NSInPredicateOperatorType
+                                                          options:0];
+    }
 
     NSExpression *expression = [NSExpression expressionWithMGLJSONObject:object];
     return [NSComparisonPredicate predicateWithLeftExpression:expression