static NSExpression ToExpression(NSObject @object)
{
switch (@object)
{
case NSArray array:
return(ToExpression(array));
case NSString @string:
case NSNumber number:
case NSValue value:
return(NSExpression.FromConstant(@object));
case NSDictionary dict: {
var dictionary = new NSMutableDictionary();
foreach (var key in dict.Keys)
{
dictionary[key] = ToExpression(dict[key]);
}
return(NSExpression.FromConstant(dictionary));
}
}
if (@object == null || @object.Equals(NSNull.Null))
{
return(NSExpressionAdditions.FromConstant(null));
}
return(null);
}
public override void ViewDidLoad()
{
base.ViewDidLoad();
//MGLAccountManager.AccessToken = @"";
var mapView = new MGLMapView(
View.Bounds);
this.View.AddSubview(mapView);
mapView.WeakDelegate = this;
mapView.SetCenterCoordinate(new CLLocationCoordinate2D(21.028511, 105.804817), 11, false);
var temple = new MGLPointAnnotation
{
Title = "Temple of literature",
Subtitle = "Van Mieu - Quoc Tu Giam",
Coordinate = new CLLocationCoordinate2D(21.0276, 105.8355)
};
mapView.AddAnnotation(temple);
var newLayer = new MGLSymbolStyleLayer(Guid.NewGuid().ToString(), new MGLSource("xxx"))
{
IconImageName = NSExpression.FromConstant(new NSString("temple")),
IconOpacity = NSExpression.FromConstant(NSNumber.FromDouble(0.7))
};
}
private void initializePinsLayer()
{
// Just initialize with empty so that it's guaranteed that there are sources initiated
// when the pins collection is still null
var mapLockedPinsSource = new MGLShapeSource(mapLockedPinsSourceKey, new NSObject[]{}, null);
nStyle.AddSource(mapLockedPinsSource);
// Pins with bearings layer - configure elements
var mapLockedPinsLayer = new MGLSymbolStyleLayer(mapLockedPinsKey, mapLockedPinsSource) {
IconImageName = NSExpression.FromKeyPath(pin_image_key),
IconRotation = NSExpression.FromKeyPath(pin_rotation_key),
IconScale = NSExpression.FromKeyPath(pin_size_key),
IconRotationAlignment = NSExpression.FromConstant(NSObject.FromObject("map")), // Finally the map-lock flat = "map"
IconAllowsOverlap = NSExpression.FromConstant(NSObject.FromObject(true)) // Always overlap
};
nStyle.AddLayer(mapLockedPinsLayer);
// Just initialize with empty so that it's guaranteed that there are sources initiated
// when the pins collection is still null
var normalPinsSource = new MGLShapeSource(normalPinsSourceKey, new NSObject[] { }, null);
nStyle.AddSource(normalPinsSource);
// Normal pins layer - configure elements
var normalPinsLayer = new MGLSymbolStyleLayer(normalPinsKey, normalPinsSource) {
IconImageName = NSExpression.FromKeyPath(pin_image_key),
IconScale = NSExpression.FromKeyPath(pin_size_key),
IconOffset = NSExpression.FromKeyPath(pin_offset_key), //https://www.mapbox.com/mapbox-gl-js/style-spec/#layout-symbol-icon-offset
IconAnchor = NSExpression.FromConstant(NSObject.FromObject("bottom")), // https://www.mapbox.com/mapbox-gl-js/style-spec/#layout-symbol-icon-anchor = "bottom" or "center"
IconAllowsOverlap = NSExpression.FromConstant(NSObject.FromObject(true))
};
nStyle.AddLayer(normalPinsLayer);
}
public override void ViewDidLoad()
{
base.ViewDidLoad();
// Perform any additional setup after loading the view, typically from a nib.
var mapView = new MGLMapView(
View.Bounds,
new NSUrl("mapbox://styles/naxamtest/cj5kin5x21li42soxdx3mb1yt")
);
this.View.AddSubview(mapView);
mapView.WeakDelegate = this;
mapView.SetCenterCoordinate(new CLLocationCoordinate2D(21.028511, 105.804817), 11, false);
var temple = new MGLPointAnnotation()
{
Title = "Temple of literature",
Subtitle = "Van Mieu - Quoc Tu Giam",
Coordinate = new CLLocationCoordinate2D(21.0276, 105.8355)
};
mapView.AddAnnotation(temple);
var newLayer = new MGLSymbolStyleLayer(Guid.NewGuid().ToString(), new MGLSource("xxx"))
{
IconImageName = NSExpression.FromConstant(new NSString("temple")),
IconOpacity = NSExpression.FromConstant(NSNumber.FromDouble(0.7))
};
Debug.WriteLine(newLayer.IconImageName.ToString());
}
public void AggregatePropertiesTest()
{
var availableProperties = new List <string> {
"Collection"
};
using (var lower = NSExpression.FromConstant(new NSNumber(0)))
using (var upper = NSExpression.FromConstant(new NSNumber(5)))
using (var expression = NSExpression.FromAggregate(new NSExpression [] { lower, upper })) {
Assert.AreEqual(NSExpressionType.NSAggregate, expression.ExpressionType);
TestProperties(expression, availableProperties);
}
}
public NSPredicateEditorRowTemplate(
IEnumerable <string> leftExpressionsFromKeyPaths,
IEnumerable <string> rightExpressionsFromConstants,
IEnumerable <NSPredicateOperatorType> operators,
NSComparisonPredicateModifier modifier = NSComparisonPredicateModifier.Direct,
NSComparisonPredicateOptions options = NSComparisonPredicateOptions.None)
: this(
leftExpressionsFromKeyPaths.Select(k => NSExpression.FromKeyPath(k)),
rightExpressionsFromConstants.Select(k => NSExpression.FromConstant(new NSString(k))),
operators,
modifier,
options)
{
}
public object FromConstant(object input)
{
NSObject value = null;
switch (input)
{
case String stringValue:
value = new NSString(stringValue);
break;
}
using (var expression = NSExpression.FromConstant(value))
using (var result = expression.EvaluateWith(null, null) as NSObject)
return(result?.ToString());
}
public void UpdateLight(Light light)
{
var native = mapStyle.Light;
if (!string.IsNullOrWhiteSpace(light.Anchor))
{
native.Anchor = NSExpression.FromConstant(new NSString(light.Anchor));
}
if (light.Color != null)
{
native.Color = NSExpression.FromConstant(light.Color.Value.ToUIColor());
}
if (light.ColorTransition != null)
{
native.ColorTransition = light.ColorTransition.ToNative();
}
if (light.Intensity.HasValue)
{
native.Intensity = NSExpression.FromConstant(NSNumber.FromFloat(light.Intensity.Value));
}
if (light.IntensityTransition != null)
{
native.IntensityTransition = light.IntensityTransition.ToNative();
}
if (light.Position.HasValue)
{
var position = NSValue_MGLAdditions.ValueWithMGLSphericalPosition(null, new MGLSphericalPosition
{
radial = light.Position.Value.Radial,
azimuthal = light.Position.Value.Azimuthal,
polar = light.Position.Value.Polar
});
native.Position = NSExpression.FromConstant(position);
}
if (light.PositionTransition != null)
{
native.PositionTransition = light.PositionTransition.ToNative();
}
mapStyle.Light = native;
}
public void ShowBuilding(BuildingInfo buildingInfo)
{
if (map == null || mapStyle == null)
{
return;
}
var source = mapStyle.SourceWithIdentifier("composite");
if (source == null)
{
return;
}
var layer = new MGLFillExtrusionStyleLayer("mapbox-android-plugin-3d-buildings", source);
layer.SourceLayerIdentifier = "building";
// Filter out buildings that should not extrude.
//layer.Predicate = NSPredicate.FromFormat("extrude == 'true'");
// Set the fill extrusion height to the value for the building height attribute.
layer.FillExtrusionHeight = Expression.Interpolate(
Expression.Exponential(1),
Expression.Zoom(),
Expression.CreateStop(15, 0),
Expression.CreateStop(16, Expression.Get("height"))
).ToNative();
layer.FillExtrusionOpacity = NSExpression.FromConstant(NSNumber.FromFloat(buildingInfo.Opacity));
layer.FillExtrusionColor = NSExpression.FromConstant(buildingInfo.Color.ToUIColor());
layer.Visible = buildingInfo.IsVisible;
// Insert the fill extrusion layer below a POI label layer. If you aren’t sure what the layer is called, you can view the style in Mapbox Studio or iterate over the style’s layers property, printing out each layer’s identifier.
if (!string.IsNullOrWhiteSpace(buildingInfo.AboveLayerId))
{
var symbolLayer = mapStyle.LayerWithIdentifier(buildingInfo.AboveLayerId);
if (symbolLayer != null)
{
mapStyle.InsertLayerBelow(layer, symbolLayer);
return;
}
}
mapStyle.AddLayer(layer);
}
public void MinusSetPropertiesTest()
{
var availableProperties = new List <string> {
"LeftExpression", "RightExpression"
};
using (var llower = NSExpression.FromConstant(new NSNumber(0)))
using (var lupper = NSExpression.FromConstant(new NSNumber(5)))
using (var lh = NSExpression.FromAggregate(new NSExpression [] { llower, lupper }))
using (var rlower = NSExpression.FromConstant(new NSNumber(10)))
using (var rupper = NSExpression.FromConstant(new NSNumber(50)))
using (var rh = NSExpression.FromAggregate(new NSExpression [] { rlower, rupper }))
using (var expression = NSExpression.FromMinusSet(lh, rh)) {
Assert.AreEqual(NSExpressionType.MinusSet, expression.ExpressionType);
TestProperties(expression, availableProperties);
}
}
public static NSExpression FromRgba(NSExpression[] components)
{
var color = ColorFromRgb(components);
if (color != null)
{
return(NSExpression.FromConstant(color));
}
var colorClass = ObjCRuntime.Class.GetHandleIntrinsic(nameof(UIColor));
var colorExpression = NSExpression.FromConstant(ObjCRuntime.Runtime.GetNSObject(colorClass));
return(NSExpression.FromFunction(
colorExpression,
"colorWithRed:green:blue:alpha:",
components
));
}
private void initializeRoutesLayer()
{
// Just initialize with empty so that it's guaranteed that there are sources initiated
// when the routes collection is still null
var routeSource = new MGLShapeSource(line_source_key, new NSObject[] { }, null);
nStyle.AddSource(routeSource);
var borderLinesLayer = new MGLLineStyleLayer(border_line_layer_key, routeSource);
borderLinesLayer.LineColor = NSExpression.FromKeyPath(border_line_color_key);
borderLinesLayer.LineWidth = NSExpression.FromKeyPath(border_line_width_key);
borderLinesLayer.LineJoin = NSExpression.FromConstant(NSObject.FromObject("round"));
borderLinesLayer.LineCap = NSExpression.FromConstant(NSObject.FromObject("round"));
nStyle.AddLayer(borderLinesLayer);
var linesLayer = new MGLLineStyleLayer(line_layer_key, routeSource);
linesLayer.LineColor = NSExpression.FromKeyPath(line_color_key);
linesLayer.LineWidth = NSExpression.FromKeyPath(line_width_key);
linesLayer.LineJoin = NSExpression.FromConstant(NSObject.FromObject("round"));
linesLayer.LineCap = NSExpression.FromConstant(NSObject.FromObject("round"));
nStyle.AddLayer(linesLayer);
}
public static NSExpression FromRgb(NSExpression[] components)
{
var color = ColorFromRgb(components);
if (color != null)
{
return(NSExpression.FromConstant(color));
}
var colorClass = ObjCRuntime.Class.GetHandleIntrinsic(nameof(UIColor));
var colorExpression = NSExpression.FromConstant(ObjCRuntime.Runtime.GetNSObject(colorClass));
var alphaExpression = NSExpression.FromConstant(NSNumber.FromDouble(1));
var rgbaArguments = new NSExpression[components.Length + 1];
components.CopyTo(rgbaArguments, 0);
Array.ConstrainedCopy(new[] { alphaExpression }, 0, rgbaArguments, components.Length, 1);
return(NSExpression.FromFunction(
colorExpression,
"colorWithRed:green:blue:alpha:",
rgbaArguments
));
}
static NSExpression ToExpression(NSArray array)
{
var objects = SubArray(array, 0);
var @operator = objects[0].ToString();
var arguments = SubArray(objects, 1);
if (OperatorMap.TryGetValue(@operator, out var functionName))
{
var subexpressions = ToSubexpressions(arguments);
switch (functionName)
{
case "+":
if (subexpressions.Count > 2)
{
var sumArguments = NSExpression.FromAggregate(subexpressions.ToArray());
return(NSExpression.FromFunction("sum:", new[] { sumArguments }));
}
break;
case "^":
if (arguments[0].ToString() == "e")
{
functionName = @"exp:";
subexpressions = SubArray(subexpressions, 1);
}
break;
default:
break;
}
return(NSExpression.FromFunction(functionName, subexpressions.ToArray()));
}
else
{
switch (@operator)
{
case "collator":
return(NSExpression.FromFunction("MGL_FUNCTION", ToSubexpressions(objects).ToArray()));
case "literal":
if (arguments[0] is NSArray literalArray)
{
return(NSExpression.FromConstant(literalArray));
// WARNING This may be wrong
//var expressions = ToSubexpressions(SubArray(literalArray, 0));
//return NSExpression.FromAggregate(expressions.ToArray());
}
return(ToExpression(arguments[0]));
case "to-boolean": {
var operand = ToExpression(arguments[0]);
return(NSExpression.FromFunction(operand, "boolValue", new NSExpression[0]));
}
case "to-number":
case "number": {
var operand = ToExpression(arguments[0]);
if (arguments.Count == 1)
{
if (arguments[0] is NSNumber number)
{
return(NSExpression.FromFormat("%@", new NSObject[] { arguments[0] }));
}
return(NSExpression.FromFormat("CAST(%@, 'NSNumber')", new NSObject[] { operand }));
}
else
{
var innerArguments = SubArray(arguments, 1);
return(NSExpression.FromFunction(operand, "mgl_numberWithFallbackValues",
ToSubexpressions(innerArguments).ToArray()));
}
}
case "to-string":
case "string": {
var operand = ToExpression(arguments[0]);
return(NSExpression.FromFormat("CAST(%@, 'NSString')", new NSObject[] { operand }));
}
case "to-color":
case "color": {
var operand = ToExpression(arguments[0]);
if (arguments.Count == 1)
{
#if __IOS__
return(NSExpression.FromFormat("CAST(%@, 'UIColor')", new NSObject[] { operand }));
#else
return(NSExpression.FromFormat("CAST(%@, 'NSColor')", new NSObject[] { operand }));
#endif
}
return(NSExpression.FromFunction("MGL_FUNCTION", ToSubexpressions(objects).ToArray()));
}
case "to-rgba": {
var operand = ToExpression(arguments[0]);
return(NSExpression.FromFormat("CAST(noindex(%@), 'NSArray')", new NSObject[] { operand }));
}
case "get": {
if (arguments.Count == 2)
{
var operand = ToExpression(arguments[arguments.Count - 1]);
if (arguments[0] is NSString value)
{
return(NSExpression.FromFormat("%@.%K", new NSObject[] { operand, value }));
}
var keyExpression = ToExpression(arguments[0]);
return(NSExpression.FromFormat("%@.%@", new NSObject[] { operand, keyExpression }));
}
return(NSExpression.FromKeyPath(arguments[0].ToString()));
}
case "length": {
var subexpressions = ToSubexpressions(arguments);
var function = @"count:";
if (subexpressions[0].ExpressionType == NSExpressionType.ConstantValue &&
subexpressions[0].ConstantValue is NSString value)
{
function = "length:";
}
return(NSExpression.FromFunction(function, new NSExpression[] { subexpressions[0] }));
}
;
case "rgb": {
var subexpressions = ToSubexpressions(arguments);
return(UIColorAdditions.FromRgb(subexpressions.ToArray()));
}
case "rgba": {
var subexpressions = ToSubexpressions(arguments);
return(UIColorAdditions.FromRgba(subexpressions.ToArray()));
}
case "min":
case "max": {
var subexpressions = ToSubexpressions(arguments);
var subexpression = NSExpression.FromAggregate(subexpressions.ToArray());
return(NSExpression.FromFunction(@operator, new[] { subexpression }));
}
case "e": {
return(NSExpression.FromConstant(NSNumber.FromDouble(Math.E)));
}
case "pi": {
return(NSExpression.FromConstant(NSNumber.FromDouble(Math.PI)));
}
case "concat": {
var subexpressions = ToSubexpressions(arguments);
var subexpression = NSExpression.FromAggregate(subexpressions.ToArray());
return(NSExpression.FromFunction("mgl_join:", new[] { subexpression }));
}
case "at": {
var subexpressions = ToSubexpressions(arguments);
return(NSExpression.FromFunction("objectFrom:withIndex:",
new[] { subexpressions[1], subexpressions[0] }));
}
case "has": {
var subexpressions = ToSubexpressions(arguments);
var operand = subexpressions.Count > 1
? subexpressions[1]
: NSExpression.ExpressionForEvaluatedObject;
var key = subexpressions[0];
return(NSExpression.FromFunction("mgl_does:have:", new[] { operand, key }));
}
case "interpolate": {
var firstObject = arguments[0];
if (firstObject is NSArray == false)
{
return(null);
}
var interpolationOptions = SubArray((NSArray)firstObject);
var curveType = interpolationOptions[0].ToString();
var curveTypeExpression = ToExpression(interpolationOptions[0]);
NSObject curveParameters;
switch (curveType)
{
case "linear": {
var temp = new NSMutableArray(2);
temp.Add((NSString)"literal");
temp.Add(NSNumber.FromDouble(1.0));
curveParameters = temp.Copy();
temp.Dispose();
break;
}
case "exponential":
curveParameters = interpolationOptions[1];
break;
case "cubic-bezier": {
var temp = new NSMutableArray(5);
temp.Add((NSString)"literal");
temp.Add(interpolationOptions[1]);
temp.Add(interpolationOptions[2]);
temp.Add(interpolationOptions[3]);
temp.Add(interpolationOptions[4]);
curveParameters = temp.Copy();
temp.Dispose();
break;
}
default:
curveParameters = NSNull.Null;
break;
}
var curveParameterExpression = ToExpression(curveParameters);
arguments = SubArray(arguments, 1);
var inputExpression = ToExpression(arguments[0]);
var stopExpressions = SubArray(arguments, 1);
var stops = new NSMutableDictionary();
for (int i = 0; i < stopExpressions.Count; i++)
{
var keyExpression = stopExpressions[i++];
var valueExpression = ToExpression(stopExpressions[i]);
stops[keyExpression] = valueExpression;
}
var stopExpression = NSExpression.FromConstant(stops);
return(NSExpression.FromFunction("mgl_interpolate:withCurveType:parameters:stops:", new[]
{
inputExpression,
curveTypeExpression,
curveParameterExpression,
stopExpression
}));
}
case "step": {
var inputExpression = ToExpression(arguments[0]);
var stopExpressions = SubArray(arguments, 1);
NSExpression miniumExpression = null;
if (stopExpressions.Count % 2 == 1)
{
miniumExpression = ToExpression(stopExpressions[0]);
stopExpressions = SubArray(stopExpressions, 1);
}
var stops = new NSMutableDictionary();
for (int i = 0; i < stopExpressions.Count; i++)
{
var keyExpression = stopExpressions[i++];
var valueExpression = ToExpression(stopExpressions[i]);
if (miniumExpression == null)
{
miniumExpression = valueExpression;
continue;
}
stops[keyExpression] = valueExpression;
}
if (miniumExpression == null)
{
return(null);
}
var stopExpression = NSExpression.FromConstant(stops);
return(NSExpression.FromFunction("mgl_step:from:stops:", new[]
{
inputExpression,
miniumExpression,
stopExpression
}));
}
case "zoom": {
return(NSExpression_MGLAdditions.ZoomLevelVariableExpression(null));
}
case "heatmap-density": {
return(NSExpression_MGLAdditions.HeatmapDensityVariableExpression(null));
}
case "line-progress": {
return(NSExpression_MGLAdditions.LineProgressVariableExpression(null));
}
case "geometry-type": {
return(NSExpression_MGLAdditions.GeometryTypeVariableExpression(null));
}
case "id": {
return(NSExpression_MGLAdditions.FeatureIdentifierVariableExpression(null));
}
case "properties": {
return(NSExpression_MGLAdditions.FeatureAttributesVariableExpression(null));
}
case "var": {
return(NSExpression.FromVariable(arguments[0].ToString()));
}
case "case": {
var args = new NSMutableArray();
for (int i = 0; i < arguments.Count; i++)
{
if (i % 2 == 0 & i != arguments.Count - 1)
{
var predicate = ToPredicate(arguments[i]);
var arg = NSExpression.FromConstant(predicate);
args.Add(arg);
}
else
{
args.Add(ToExpression(arguments[i]));
}
}
if (args.Count == 3)
{
return(NSExpression.FromConditional(
(NSPredicate)ObjCRuntime.Runtime.GetNSObject <NSExpression>(args.ValueAt(0))
.ConstantValue,
ObjCRuntime.Runtime.GetNSObject <NSExpression>(args.ValueAt(1)),
ObjCRuntime.Runtime.GetNSObject <NSExpression>(args.ValueAt(2))));
}
return(NSExpression.FromFunction("MGL_IF",
NSArray.FromArray <NSExpression>((NSArray)args.Copy())));
}
case "match": {
var optionsArray = new NSMutableArray();
for (int i = 0; i < arguments.Count; i++)
{
NSExpression option = ToExpression(arguments[i]);
if (i > 0 && i < arguments.Count - 1 && !(i % 2 == 0) && arguments[i] is NSArray sub)
{
option = NSExpression.FromAggregate(ToSubexpressions(SubArray(sub)).ToArray());
}
optionsArray.Add(option);
}
return(NSExpression.FromFunction("MGL_MATCH",
NSArray.FromArray <NSExpression>((NSArray)optionsArray.Copy())));
}
case "format": {
var attributedExpressions = new List <NSExpression>();
for (int i = 0; i < arguments.Count; i += 2)
{
var expression = ToExpression(arguments[i]);
var attrs = new NSMutableDictionary();
if (i + 1 < arguments.Count)
{
attrs = NSMutableDictionary.FromDictionary(arguments[i + 1] as NSDictionary);
}
foreach (var key in attrs.Keys)
{
attrs[key] = ToExpression(attrs[key]);
}
var attributedExpression = new MGLAttributedExpression(expression, attrs);
attributedExpressions.Add(NSExpression.FromConstant(attributedExpression));
}
return(NSExpression.FromFunction("mgl_attributed:", attributedExpressions.ToArray()));
}
case "coalesce": {
var subexpressions = ToSubexpressions(arguments);
return(NSExpression.FromFormat("mgl_coalesce(%@)", subexpressions.ToArray()));
}
default: {
var subexpressions = ToSubexpressions(objects);
return(NSExpression.FromFunction(@"MGL_FUNCTION", subexpressions.ToArray()));
}
}
}
}
private NSCompoundPredicate FindMatches(string searchString)
{
/*
* Each searchString creates an OR predicate for: name, yearIntroduced, introPrice.
* Example if searchItems contains "Gladiolus 51.99 2001":
* - name CONTAINS[c] "gladiolus"
* - name CONTAINS[c] "gladiolus", yearIntroduced ==[c] 2001, introPrice ==[c] 51.99
* - name CONTAINS[c] "ginger", yearIntroduced ==[c] 2007, introPrice ==[c] 49.98
*/
var searchItemsPredicate = new List <NSPredicate>();
/*
* Below we use NSExpression represent expressions in our predicates.
* NSPredicate is made up of smaller, atomic parts:
* two NSExpressions (a left-hand value and a right-hand value).
*/
// Name field matching.
var titleExpression = NSExpression.FromKeyPath(ExpressionKeys.Title);
var searchStringExpression = NSExpression.FromConstant(new NSString(searchString));
var titleSearchComparisonPredicate = new NSComparisonPredicate(titleExpression,
searchStringExpression,
NSComparisonPredicateModifier.Direct,
NSPredicateOperatorType.Contains,
NSComparisonPredicateOptions.CaseInsensitive | NSComparisonPredicateOptions.DiacriticInsensitive);
searchItemsPredicate.Add(titleSearchComparisonPredicate);
var numberFormatter = new NSNumberFormatter
{
NumberStyle = NSNumberFormatterStyle.None,
FormatterBehavior = NSNumberFormatterBehavior.Default
};
// The `searchString` may fail to convert to a number.
var targetNumber = numberFormatter.NumberFromString(searchString);
if (targetNumber != null)
{
// Use `targetNumberExpression` in both the following predicates.
var targetNumberExpression = NSExpression.FromConstant(targetNumber);
// The `yearIntroduced` field matching.
var yearIntroducedExpression = NSExpression.FromKeyPath(ExpressionKeys.YearIntroduced);
var yearIntroducedPredicate = new NSComparisonPredicate(yearIntroducedExpression,
targetNumberExpression,
NSComparisonPredicateModifier.Direct,
NSPredicateOperatorType.EqualTo,
NSComparisonPredicateOptions.CaseInsensitive | NSComparisonPredicateOptions.DiacriticInsensitive);
searchItemsPredicate.Add(yearIntroducedPredicate);
// The `price` field matching.
var priceExpression = NSExpression.FromKeyPath(ExpressionKeys.IntroPrice);
var finalPredicate = new NSComparisonPredicate(priceExpression,
targetNumberExpression,
NSComparisonPredicateModifier.Direct,
NSPredicateOperatorType.EqualTo,
NSComparisonPredicateOptions.CaseInsensitive | NSComparisonPredicateOptions.DiacriticInsensitive);
searchItemsPredicate.Add(finalPredicate);
}
return(NSCompoundPredicate.CreateOrPredicate(searchItemsPredicate.ToArray()));
}
public void FromConstant()
{
using (var expression = NSExpression.FromConstant(new NSString("Foo")))
using (var result = expression.EvaluateWith(null, null) as NSString)
Assert.AreEqual("Foo", result.ToString());
}
static NSPredicate ToPredicate(NSObject @object)
{
if (@object == NSNumber.FromBoolean(true))
{
return(NSPredicate.FromValue(true));
}
if (@object == NSNumber.FromBoolean(false))
{
return(NSPredicate.FromValue(false));
}
if (@object is NSArray == false)
{
return(null);
}
var array = (NSArray)@object;
var objects = SubArray(array);
var op = objects[0].ToString();
if (MGLPredicateOperatorTypesByJSONOperator.TryGetValue(op, out var operatorType))
{
NSComparisonPredicateOptions options = 0;
if (objects.Count > 3)
{
var collatorExpression = SubArray((NSArray)objects[3]);
if (collatorExpression.Count != 2)
{
return(null);
}
var collator = (NSDictionary)collatorExpression[1];
if (false == collator.ContainsKey((NSString)"locale"))
{
if (collator.ValueForKey((NSString)"case-sensitive") == NSNumber.FromBoolean(false))
{
options |= NSComparisonPredicateOptions.CaseInsensitive;
}
if (collator.ValueForKey((NSString)"diacritic-sensitive") == NSNumber.FromBoolean(false))
{
options |= NSComparisonPredicateOptions.DiacriticInsensitive;
}
}
}
var subexpressions = ToSubexpressions(SubArray(objects, 1));
return(new NSComparisonPredicate(
subexpressions[0],
subexpressions[1],
NSComparisonPredicateModifier.Direct,
operatorType,
options
));
}
switch (op)
{
case "!": {
var subpredicates = ToSubpredicates(SubArray(objects, 1));
if (subpredicates.Count > 1)
{
var predicate = NSCompoundPredicate.CreateOrPredicate(subpredicates.ToArray());
return(NSCompoundPredicate.CreateNotPredicate(predicate));
}
return(NSPredicate.FromValue(true));
}
case "all": {
var subpredicates = ToSubpredicates(SubArray(objects, 1));
if (subpredicates.Count == 2)
{
if (subpredicates[0] is NSComparisonPredicate leftCondition &&
subpredicates[1] is NSComparisonPredicate rightCondition
)
{
NSExpression[] limits = null;
NSExpression leftConditionExpression = null;
if (leftCondition.PredicateOperatorType == NSPredicateOperatorType.GreaterThanOrEqualTo &&
rightCondition.PredicateOperatorType == NSPredicateOperatorType.LessThanOrEqualTo
)
{
limits = new NSExpression[]
{
leftCondition.RightExpression,
rightCondition.RightExpression
};
leftConditionExpression = leftCondition.LeftExpression;
}
else if (leftCondition.PredicateOperatorType == NSPredicateOperatorType.LessThanOrEqualTo &&
rightCondition.PredicateOperatorType ==
NSPredicateOperatorType.LessThanOrEqualTo
)
{
limits = new NSExpression[]
{
leftCondition.LeftExpression,
rightCondition.RightExpression
};
leftConditionExpression = leftCondition.RightExpression;
}
else if (leftCondition.PredicateOperatorType == NSPredicateOperatorType.LessThanOrEqualTo &&
rightCondition.PredicateOperatorType ==
NSPredicateOperatorType.GreaterThanOrEqualTo
)
{
limits = new NSExpression[]
{
leftCondition.LeftExpression,
rightCondition.LeftExpression
};
leftConditionExpression = leftCondition.RightExpression;
}
else if (leftCondition.PredicateOperatorType == NSPredicateOperatorType.GreaterThanOrEqualTo &&
rightCondition.PredicateOperatorType ==
NSPredicateOperatorType.GreaterThanOrEqualTo
)
{
limits = new NSExpression[]
{
leftCondition.RightExpression,
rightCondition.LeftExpression
};
leftConditionExpression = leftCondition.LeftExpression;
}
if (limits != null && leftConditionExpression != null)
{
return(NSPredicate.FromFormat("%@ BETWEEN %@", leftConditionExpression,
NSExpression.FromAggregate(limits)));
}
}
}
return(new NSCompoundPredicate(NSCompoundPredicateType.And, subpredicates.ToArray()));
}
case "any": {
var subpredicates = ToSubpredicates(SubArray(objects, 1));
return(new NSCompoundPredicate(NSCompoundPredicateType.Or, subpredicates.ToArray()));
}
default: {
var expression = ToExpression(array);
return(new NSComparisonPredicate(
expression,
NSExpression.FromConstant(NSNumber.FromBoolean(true)),
NSComparisonPredicateModifier.Direct,
NSPredicateOperatorType.EqualTo,
0
));
}
}
}
private MGLStyleLayer GetStyleLayer(StyleLayer styleLayer, NSString id)
{
if (string.IsNullOrEmpty(styleLayer.SourceId))
{
return(null);
}
var sourceId = styleLayer.SourceId.ToCustomId();
var source = MapView.Style.SourceWithIdentifier(sourceId);
if (source == null)
{
return(null);
}
if (styleLayer is CircleLayer circleLayer)
{
var newLayer = new MGLCircleStyleLayer(id, source)
{
CircleColor = NSExpression.FromConstant(circleLayer.CircleColor.ToUIColor()),
CircleOpacity = NSExpression.FromConstant(NSNumber.FromDouble(circleLayer.CircleOpacity)),
CircleRadius = NSExpression.FromConstant(NSNumber.FromDouble(circleLayer.CircleRadius))
};
if (circleLayer.StrokeColor is Color strokeColor)
{
newLayer.CircleStrokeColor = NSExpression.FromConstant(strokeColor.ToUIColor());
newLayer.CircleStrokeOpacity = NSExpression.FromConstant(NSNumber.FromDouble(circleLayer.StrokeOpacity));
newLayer.CircleStrokeWidth = NSExpression.FromConstant(NSNumber.FromDouble(circleLayer.StrokeWidth));
}
return(newLayer);
}
if (styleLayer is LineLayer lineLayer)
{
var newLayer = new MGLLineStyleLayer(id, source)
{
LineWidth = NSExpression.FromConstant(NSNumber.FromDouble(lineLayer.LineWidth)),
LineColor = NSExpression.FromConstant(lineLayer.LineColor.ToUIColor())
};
if (lineLayer.Dashes != null && lineLayer.Dashes.Length != 0)
{
var arr = new NSMutableArray <NSNumber>();
foreach (double dash in lineLayer.Dashes)
{
arr.Add(NSNumber.FromDouble(dash));
}
newLayer.LineDashPattern = NSExpression.FromConstant(arr);
}
//TODO lineCap
return(newLayer);
}
if (styleLayer is FillLayer fl)
{
var newLayer = new MGLFillStyleLayer(id, source)
{
FillColor = NSExpression.FromConstant(fl.FillColor.ToUIColor()),
FillOpacity = NSExpression.FromConstant(NSNumber.FromDouble(fl.FillOpacity))
};
return(newLayer);
}
if (styleLayer is SymbolLayer sl)
{
var newLayer = new MGLSymbolStyleLayer(id, source)
{
IconImageName = NSExpression.FromConstant(new NSString(sl.IconImageName)),
IconOpacity = NSExpression.FromConstant(NSNumber.FromDouble(sl.IconOpacity))
};
return(newLayer);
}
if (styleLayer is RasterStyleLayer rl)
{
var newLayer = new MGLRasterStyleLayer(id, source);
return(newLayer);
}
return(null);
}
