summaryrefslogtreecommitdiff
diff options
context:
space:
mode:
-rw-r--r--include/mbgl/style/conversion/function.hpp2
m---------mapbox-gl-js0
-rw-r--r--platform/darwin/src/MGLConversion.h135
-rw-r--r--platform/darwin/src/MGLStyleValue_Private.h256
-rw-r--r--platform/darwin/test/MGLStyleValueTests.swift280
-rw-r--r--platform/ios/ios.xcodeproj/project.pbxproj6
-rw-r--r--platform/macos/macos.xcodeproj/project.pbxproj4
7 files changed, 397 insertions, 286 deletions
diff --git a/include/mbgl/style/conversion/function.hpp b/include/mbgl/style/conversion/function.hpp
index 1f7a3fe778..a5979e6799 100644
--- a/include/mbgl/style/conversion/function.hpp
+++ b/include/mbgl/style/conversion/function.hpp
@@ -200,7 +200,7 @@ struct Converter<CameraFunction<T>> {
template <class T, class V>
Result<optional<T>> convertDefaultValue(const V& value) {
- auto defaultValueValue = objectMember(value, "defaultValue");
+ auto defaultValueValue = objectMember(value, "default");
if (!defaultValueValue) {
return {};
}
diff --git a/mapbox-gl-js b/mapbox-gl-js
-Subproject dee3911a7b5a1e8b2333d133a162af388673d1b
+Subproject abdd41a90f8d9f6985bcadf0d363d84149f6fa4
diff --git a/platform/darwin/src/MGLConversion.h b/platform/darwin/src/MGLConversion.h
new file mode 100644
index 0000000000..d51ebd775c
--- /dev/null
+++ b/platform/darwin/src/MGLConversion.h
@@ -0,0 +1,135 @@
+#import <Foundation/Foundation.h>
+
+#include <mbgl/util/logging.hpp>
+#include <mbgl/style/conversion.hpp>
+#include <mbgl/util/feature.hpp>
+#include <mbgl/util/optional.hpp>
+
+NS_ASSUME_NONNULL_BEGIN
+
+namespace mbgl {
+namespace style {
+namespace conversion {
+
+/**
+ A minimal wrapper class conforming to the requirements for `objectMember(v, name)` (see mbgl/style/conversion.hpp)
+ This is necessary because using `NSObject*` as the value type in `optional<NSObject*>` causes problems for the ARC,
+ due to things like `optional(const value_type& __v)`
+ */
+class OptionalNSObjectValue {
+public:
+ OptionalNSObjectValue(NSObject * _Nullable _value) : value(_value) {}
+
+ explicit operator bool() const {
+ return value;
+ }
+
+ NSObject * _Nullable operator*() {
+ NSCAssert(this, @"Expected non-null value.");
+ return value;
+ }
+private:
+ NSObject * _Nullable value;
+};
+
+inline bool isUndefined(const id value) {
+ return !value || value == [NSNull null];
+}
+
+inline bool isArray(const id value) {
+ return [value isKindOfClass:[NSArray class]];
+}
+
+inline bool isObject(const id value) {
+ return [value isKindOfClass:[NSDictionary class]];
+}
+
+inline std::size_t arrayLength(const id value) {
+ NSCAssert([value isKindOfClass:[NSArray class]], @"Value must be an NSArray for getLength().");
+ NSArray *array = value;
+ auto length = [array count];
+ NSCAssert(length <= std::numeric_limits<size_t>::max(), @"Array length out of bounds.");
+ return length;
+}
+
+inline NSObject *arrayMember(const id value, std::size_t i) {
+ NSCAssert([value isKindOfClass:[NSArray class]], @"Value must be an NSArray for get(int).");
+ NSCAssert(i < NSUIntegerMax, @"Index must be less than NSUIntegerMax");
+ return [value objectAtIndex: i];
+}
+
+inline OptionalNSObjectValue objectMember(const id value, const char *key) {
+ NSCAssert([value isKindOfClass:[NSDictionary class]], @"Value must be an NSDictionary for get(string).");
+ NSObject *member = [value objectForKey: @(key)];
+ if (member && member != [NSNull null]) {
+ return { member };
+ } else {
+ return { nullptr };
+ }
+}
+
+// Not implemented (unneeded for MGLStyleFunction conversion):
+// optional<Error> eachMember(const NSObject*, Fn&&)
+
+inline bool _isBool(const id value) {
+ if (![value isKindOfClass:[NSNumber class]]) return false;
+ // char: 32-bit boolean
+ // BOOL: 64-bit boolean
+ NSNumber *number = value;
+ return ((strcmp([number objCType], @encode(char)) == 0) ||
+ (strcmp([number objCType], @encode(BOOL)) == 0));
+}
+
+inline bool _isNumber(const id value) {
+ return [value isKindOfClass:[NSNumber class]] && !_isBool(value);
+}
+
+inline bool _isString(const id value) {
+ return [value isKindOfClass:[NSString class]];
+}
+
+inline optional<bool> toBool(const id value) {
+ if (_isBool(value)) {
+ return ((NSNumber *)value).boolValue;
+ } else {
+ return {};
+ }
+}
+
+inline optional<float> toNumber(const id value) {
+ if (_isNumber(value)) {
+ return ((NSNumber *)value).floatValue;
+ } else {
+ return {};
+ }
+}
+
+inline optional<std::string> toString(const id value) {
+ if (_isString(value)) {
+ return std::string(static_cast<const char *>([value UTF8String]));
+ } else {
+ return {};
+ }
+}
+
+inline optional<mbgl::Value> toValue(const id value) {
+ if (isUndefined(value)) {
+ return {};
+ } else if (_isBool(value)) {
+ return { *toBool(value) };
+ } else if ( _isString(value)) {
+ return { *toString(value) };
+ } else if (_isNumber(value)) {
+ // Need to cast to a double here as the float is otherwise considered a bool...
+ return { static_cast<double>(*toNumber(value)) };
+ } else {
+ return {};
+ }
+}
+
+} // namespace conversion
+} // namespace style
+} // namespace mbgl
+
+NS_ASSUME_NONNULL_END
+
diff --git a/platform/darwin/src/MGLStyleValue_Private.h b/platform/darwin/src/MGLStyleValue_Private.h
index 759c96c6bd..44d6f505ee 100644
--- a/platform/darwin/src/MGLStyleValue_Private.h
+++ b/platform/darwin/src/MGLStyleValue_Private.h
@@ -5,6 +5,10 @@
#import "NSValue+MGLStyleAttributeAdditions.h"
#import "MGLTypes.h"
+#import "MGLConversion.h"
+#include <mbgl/style/conversion/data_driven_property_value.hpp>
+#include <mbgl/style/conversion.hpp>
+
#import <mbgl/util/enum.hpp>
#include <mbgl/style/data_driven_property_value.hpp>
@@ -117,157 +121,11 @@ public:
mbgl::style::DataDrivenPropertyValue<MBGLType> toDataDrivenPropertyValue(MGLStyleValue<ObjCType> *value) {
if ([value isKindOfClass:[MGLStyleConstantValue class]]) {
return toMBGLConstantValue((MGLStyleConstantValue<ObjCType> *)value);
- } else if ([value isKindOfClass:[MGLCameraStyleFunction class]]) {
- MGLCameraStyleFunction<ObjCType> *cameraStyleFunction = (MGLCameraStyleFunction<ObjCType> *)value;
- switch (cameraStyleFunction.interpolationMode) {
- case MGLInterpolationModeExponential:
- return toMBGLExponentialCameraFunction(cameraStyleFunction);
- break;
- case MGLInterpolationModeInterval:
- return toMBGLIntervalCameraFunction(cameraStyleFunction);
- break;
- default:
- [NSException raise:NSInvalidArgumentException
- format:@"A camera function must use either exponential or interval stops."];
- return {};
- }
- } else if ([value isKindOfClass:[MGLSourceStyleFunction class]]) {
- MGLSourceStyleFunction<ObjCType> *sourceStyleFunction = (MGLSourceStyleFunction<ObjCType> *)value;
- switch (sourceStyleFunction.interpolationMode) {
- case MGLInterpolationModeExponential:
- return toMBGLExponentialSourceFunction(sourceStyleFunction);
- break;
- case MGLInterpolationModeInterval:
- return toMBGLIntervalSourceFunction(sourceStyleFunction);
- break;
- case MGLInterpolationModeCategorical:
- return toMBGLCategoricalSourceFunction(sourceStyleFunction);
- break;
- case MGLInterpolationModeIdentity:
- return toMBGLIdentitySourceFunction(sourceStyleFunction);
- break;
- default:
- [NSException raise:NSInvalidArgumentException
- format:@"A camera function must use exponential, interval, categorical, or identity stops."];
- return {};
- }
- } else if ([value isKindOfClass:[MGLCompositeStyleFunction class]]) {
- MGLCompositeStyleFunction<ObjCType> *compositeStyleFunction = (MGLCompositeStyleFunction<ObjCType> *)value;
- switch (compositeStyleFunction.interpolationMode) {
- case MGLInterpolationModeExponential: {
- __block std::map<float, std::map<float, MBGLType>> outerStops = {};
- [compositeStyleFunction.stops enumerateKeysAndObjectsUsingBlock:^(NSNumber * _Nonnull zoomKey, NSDictionary * _Nonnull stopValue, BOOL * _Nonnull stop) {
- std::map<float, MBGLType> stops = {};
- for (NSNumber *key in stopValue.allKeys) {
- NSCAssert([key isKindOfClass:[NSNumber class]], @"Stop keys should be NSNumbers");
- MGLStyleValue<ObjCType> *value = stopValue[key];
- NSCAssert([value isKindOfClass:[MGLStyleValue class]], @"Stops should be MGLStyleValues");
- auto mbglStopValue = toPropertyValue(value);
- NSCAssert(mbglStopValue.isConstant(), @"Stops must be constant");
- stops[key.floatValue] = mbglStopValue.asConstant();
- }
- outerStops[zoomKey.floatValue] = stops;
- }];
- mbgl::style::CompositeFunction<MBGLType> compositeFunction {
- compositeStyleFunction.attributeName.UTF8String,
- mbgl::style::CompositeExponentialStops<MBGLType> { outerStops, (float)compositeStyleFunction.interpolationBase }
- };
- if (compositeStyleFunction.defaultValue) {
- NSCAssert([compositeStyleFunction.defaultValue isKindOfClass:[MGLStyleConstantValue class]], @"Default value must be constant");
- MBGLType mbglValue;
- id mglValue = [(MGLStyleConstantValue<ObjCType> *)compositeStyleFunction.defaultValue rawValue];
- getMBGLValue(mglValue, mbglValue);
- compositeFunction.defaultValue = mbglValue;
- }
- return compositeFunction;
- }
- break;
- case MGLInterpolationModeInterval: {
- __block std::map<float, std::map<float, MBGLType>> outerStops = {};
- [compositeStyleFunction.stops enumerateKeysAndObjectsUsingBlock:^(NSNumber * _Nonnull zoomKey, NSDictionary * _Nonnull stopValue, BOOL * _Nonnull stop) {
- std::map<float, MBGLType> stops = {};
- for (NSNumber *key in stopValue.allKeys) {
- NSCAssert([key isKindOfClass:[NSNumber class]], @"Stop keys should be NSNumbers");
- MGLStyleValue<ObjCType> *value = stopValue[key];
- NSCAssert([value isKindOfClass:[MGLStyleValue class]], @"Stops should be MGLStyleValues");
- auto mbglStopValue = toPropertyValue(value);
- NSCAssert(mbglStopValue.isConstant(), @"Stops must be constant");
- stops[key.floatValue] = mbglStopValue.asConstant();
- }
- outerStops[zoomKey.floatValue] = stops;
- }];
- mbgl::style::CompositeFunction<MBGLType> compositeFunction {
- compositeStyleFunction.attributeName.UTF8String,
- mbgl::style::CompositeIntervalStops<MBGLType> { outerStops }
- };
- if (compositeStyleFunction.defaultValue) {
- NSCAssert([compositeStyleFunction.defaultValue isKindOfClass:[MGLStyleConstantValue class]], @"Default value must be constant");
- MBGLType mbglValue;
- id mglValue = [(MGLStyleConstantValue<ObjCType> *)compositeStyleFunction.defaultValue rawValue];
- getMBGLValue(mglValue, mbglValue);
- compositeFunction.defaultValue = mbglValue;
- }
- return compositeFunction;
- }
- break;
- case MGLInterpolationModeCategorical: {
- __block std::map<float, std::map<mbgl::style::CategoricalValue, MBGLType>> outerStops = {};
- [compositeStyleFunction.stops enumerateKeysAndObjectsUsingBlock:^(NSNumber * _Nonnull zoomKey, NSDictionary * _Nonnull stopValue, BOOL * _Nonnull stop) {
- __block std::map<mbgl::style::CategoricalValue, MBGLType> stops = {};
- [stopValue enumerateKeysAndObjectsUsingBlock:^(id _Nonnull categoryKey, MGLStyleValue<ObjCType> * _Nonnull innerValue, BOOL * _Nonnull stop) {
- NSCAssert([innerValue isKindOfClass:[MGLStyleValue class]], @"Stops should be MGLStyleValues");
- auto mbglStopValue = toPropertyValue(innerValue);
- NSCAssert(mbglStopValue.isConstant(), @"Stops must be constant");
-
- if ([categoryKey isKindOfClass:[NSString class]]) {
- const std::string& convertedValueKey = [((NSString *)categoryKey) UTF8String];
- stops[mbgl::style::CategoricalValue(convertedValueKey)] = mbglStopValue.asConstant();
- } else if ([categoryKey isKindOfClass:[NSNumber class]]) {
- NSNumber *key = (NSNumber *)categoryKey;
- if ((strcmp([key objCType], @encode(char)) == 0) ||
- (strcmp([key objCType], @encode(BOOL)) == 0)) {
- stops[mbgl::style::CategoricalValue((bool)[key boolValue])] = mbglStopValue.asConstant();
- } else if (strcmp([key objCType], @encode(double)) == 0 ||
- strcmp([key objCType], @encode(float)) == 0) {
- NSCAssert(mbglStopValue.isConstant(), @"Categorical stop keys must be strings, booleans, or integers");
- } else if ([key compare:@(0)] == NSOrderedDescending ||
- [key compare:@(0)] == NSOrderedSame ||
- [key compare:@(0)] == NSOrderedAscending) {
- stops[mbgl::style::CategoricalValue((int64_t)[key integerValue])] = mbglStopValue.asConstant();
- }
- }
- }];
- outerStops[zoomKey.floatValue] = stops;
- }];
- mbgl::style::CompositeFunction<MBGLType> compositeFunction {
- compositeStyleFunction.attributeName.UTF8String,
- mbgl::style::CompositeCategoricalStops<MBGLType> { outerStops }
- };
- if (compositeStyleFunction.defaultValue) {
- NSCAssert([compositeStyleFunction.defaultValue isKindOfClass:[MGLStyleConstantValue class]], @"Default value must be constant");
- MBGLType mbglValue;
- id mglValue = [(MGLStyleConstantValue<ObjCType> *)compositeStyleFunction.defaultValue rawValue];
- getMBGLValue(mglValue, mbglValue);
- compositeFunction.defaultValue = mbglValue;
- }
- return compositeFunction;
- }
- break;
- default:
- [NSException raise:NSInvalidArgumentException
- format:@"A composite function must use exponential, interval, or categorical stops."];
- return {};
- }
- return {};
- } else if ([value isMemberOfClass:[MGLStyleFunction class]]) {
- MGLStyleFunction<ObjCType> *styleFunction = (MGLStyleFunction<ObjCType> *)value;
- return toMBGLExponentialCameraFunction(styleFunction);
- } else if (value) {
- [NSException raise:@"MGLAbstractClassException" format:
- @"The style value %@ cannot be applied to the style. "
- @"Make sure the style value was created as a member of a concrete subclass of MGLStyleValue.",
- NSStringFromClass([value class])];
- return {};
+ } else if ([value isKindOfClass:[MGLStyleFunction class]]) {
+ auto rawValue = toRawStyleSpecValue((MGLStyleFunction<ObjCType> *) value);
+ auto result = mbgl::style::conversion::convert<mbgl::style::DataDrivenPropertyValue<MBGLType>>(rawValue);
+ NSCAssert(result, @(result.error().message.c_str()));
+ return *result;
} else {
return {};
}
@@ -322,6 +180,102 @@ private: // Private utilities for converting from mgl to mbgl values
getMBGLValue(value.rawValue, mbglValue);
return mbglValue;
}
+
+ NSObject* toRawStyleSpecValue(MGLColor *color) {
+ return @(color.mgl_color.stringify().c_str());
+ }
+
+ NSObject* toRawStyleSpecValue(NSObject *rawMGLValue) {
+ if ([rawMGLValue isKindOfClass:[NSValue class]]) {
+ const auto rawNSValue = (NSValue *)rawMGLValue;
+ if (strcmp([rawNSValue objCType], @encode(CGVector)) == 0) {
+ // offset [x, y]
+ std::array<float, 2> mglValue = rawNSValue.mgl_offsetArrayValue;
+ return [NSArray arrayWithObjects:@(mglValue[0]), @(mglValue[1]), nil];
+ }
+ }
+ // noop pass-through plain NSObject-based items
+ return rawMGLValue;
+ }
+
+ NSObject* toRawStyleSpecValue(MGLStyleFunction<ObjCType>* styleFunction) {
+ NSMutableDictionary * rawFunction = [NSMutableDictionary new];
+ // interpolationMode => type
+ switch (styleFunction.interpolationMode) {
+ case MGLInterpolationModeExponential:
+ rawFunction[@"type"] = @"exponential";
+ break;
+ case MGLInterpolationModeInterval:
+ rawFunction[@"type"] = @"interval";
+ break;
+ case MGLInterpolationModeCategorical:
+ rawFunction[@"type"] = @"categorical";
+ break;
+ case MGLInterpolationModeIdentity:
+ rawFunction[@"type"] = @"identity";
+ break;
+ }
+
+ // interpolationBase => base
+ if (styleFunction.interpolationBase) {
+ rawFunction[@"base"] = @(styleFunction.interpolationBase);
+ }
+
+ // stops and default value
+ if ([styleFunction isKindOfClass:[MGLCameraStyleFunction class]]) {
+ // zoom-only function (no default value)
+ __block NSMutableArray *stops = [[NSMutableArray alloc] init];
+ [styleFunction.stops enumerateKeysAndObjectsUsingBlock:^(NSNumber * _Nonnull zoomKey, MGLStyleConstantValue<ObjCType> * _Nonnull outputValue, BOOL * _Nonnull stop) {
+ NSArray *rawStop = @[zoomKey, toRawStyleSpecValue([outputValue rawValue])];
+ [stops addObject:rawStop];
+ }];
+ rawFunction[@"stops"] = stops;
+
+ } else if ([styleFunction isKindOfClass:[MGLSourceStyleFunction class]]) {
+ auto sourceStyleFunction = (MGLSourceStyleFunction<ObjCType> *)styleFunction;
+ rawFunction[@"property"] = sourceStyleFunction.attributeName;
+ // property-only function
+ __block NSMutableArray *stops = [[NSMutableArray alloc] init];
+ [styleFunction.stops enumerateKeysAndObjectsUsingBlock:^(NSObject * _Nonnull propertyKey, MGLStyleConstantValue<ObjCType> * _Nonnull outputValue, BOOL * _Nonnull stop) {
+ NSArray *rawStop = @[propertyKey, toRawStyleSpecValue([outputValue rawValue])];
+ [stops addObject:rawStop];
+ }];
+ rawFunction[@"stops"] = stops;
+
+ // defaultValue => default
+ if (sourceStyleFunction.defaultValue) {
+ NSCAssert([sourceStyleFunction.defaultValue isKindOfClass:[MGLStyleConstantValue class]], @"Default value must be constant");
+ rawFunction[@"default"] = toRawStyleSpecValue([(MGLStyleConstantValue<ObjCType> *)sourceStyleFunction.defaultValue rawValue]);
+ }
+ } else if ([styleFunction isKindOfClass:[MGLCompositeStyleFunction class]]) {
+ // zoom-and-property function
+ auto compositeStyleFunction = (MGLCompositeStyleFunction<ObjCType> *)styleFunction;
+ rawFunction[@"property"] = compositeStyleFunction.attributeName;
+
+ __block NSMutableArray *stops = [[NSMutableArray alloc] init];
+ [compositeStyleFunction.stops enumerateKeysAndObjectsUsingBlock:^(NSNumber * _Nonnull zoomKey, NSDictionary * _Nonnull stopValue, BOOL * _Nonnull stop) {
+ for (NSObject *valueKey in stopValue.allKeys) {
+ NSDictionary *stopKey = @{
+ @"zoom": zoomKey,
+ @"value": valueKey
+ };
+ MGLStyleConstantValue<ObjCType> *outputValue = stopValue[valueKey];
+ NSCAssert([outputValue isKindOfClass:[MGLStyleConstantValue<ObjCType> class]], @"Stop outputs should be MGLStyleConstantValues");
+ NSArray *rawStop = @[stopKey, toRawStyleSpecValue([outputValue rawValue])];
+ [stops addObject:rawStop];
+ }
+ }];
+ rawFunction[@"stops"] = stops;
+
+ // defaultValue => default
+ if (compositeStyleFunction.defaultValue) {
+ NSCAssert([compositeStyleFunction.defaultValue isKindOfClass:[MGLStyleConstantValue class]], @"Default value must be constant");
+ rawFunction[@"default"] = toRawStyleSpecValue([(MGLStyleConstantValue<ObjCType> *)compositeStyleFunction.defaultValue rawValue]);
+ }
+ }
+
+ return rawFunction;
+ }
mbgl::style::CameraFunction<MBGLType> toMBGLExponentialCameraFunction(MGLStyleFunction<ObjCType> *styleFunction) {
__block std::map<float, MBGLType> stops = {};
diff --git a/platform/darwin/test/MGLStyleValueTests.swift b/platform/darwin/test/MGLStyleValueTests.swift
index a8c4aaf71a..f965c31e40 100644
--- a/platform/darwin/test/MGLStyleValueTests.swift
+++ b/platform/darwin/test/MGLStyleValueTests.swift
@@ -1,8 +1,88 @@
import XCTest
import Mapbox
-
+#if os(iOS) || os(watchOS) || os(tvOS)
+typealias MGLColor = UIColor
+#elseif os(macOS)
+typealias MGLColor = NSColor
+#endif
+
extension MGLStyleValueTests {
+ func assertColorsEqualWithAccuracy(_ actual: MGLColor, _ expected: MGLColor, accuracy: Float = 1/255) {
+ var actualComponents : [CGFloat] = [0, 0, 0, 0]
+ var expectedComponents : [CGFloat] = [0, 0, 0, 0]
+ actual.getRed(&(actualComponents[0]), green: &(actualComponents[1]), blue: &(actualComponents[2]), alpha: &(actualComponents[3]))
+ expected.getRed(&(expectedComponents[0]), green: &(expectedComponents[1]), blue: &(expectedComponents[2]), alpha: &(expectedComponents[3]))
+ for (ac, ec) in zip(actualComponents, expectedComponents) {
+ XCTAssertEqualWithAccuracy(Float(ac), Float(ec), accuracy: accuracy)
+ }
+ }
+
+ func assertColorValuesEqual(_ actual: MGLStyleValue<MGLColor>, _ expected: MGLStyleValue<MGLColor>) {
+ guard type(of: actual) == type(of: expected) else {
+ XCTFail("Expected \(type(of: expected)), but found \(type(of: actual)) instead.")
+ return
+ }
+
+ if let actualConstant = actual as? MGLStyleConstantValue<MGLColor> {
+ assertColorsEqualWithAccuracy(actualConstant.rawValue, (expected as! MGLStyleConstantValue<MGLColor>).rawValue)
+ } else if let actualFunction = actual as? MGLStyleFunction<MGLColor>,
+ let expectedFunction = expected as? MGLStyleFunction<MGLColor> {
+
+ // unless we have stops, there's no need for a custom comparison - default to plain == assertion
+ guard let actualStops = actualFunction.stops, let expectedStops = expectedFunction.stops else {
+ XCTAssertEqual(actualFunction, expectedFunction)
+ return
+ }
+
+ guard expectedStops is [String: Any] || expectedStops is [Float:Any] else {
+ XCTFail("Stop levels must be String or Float.")
+ return
+ }
+
+ XCTAssertEqual(actualFunction.interpolationBase, expectedFunction.interpolationBase)
+ XCTAssertEqual(actualFunction.interpolationMode, expectedFunction.interpolationMode)
+ if let actualFunction = actualFunction as? MGLSourceStyleFunction<MGLColor>,
+ let expectedFunction = expectedFunction as? MGLSourceStyleFunction<MGLColor> {
+ XCTAssertEqual(actualFunction.defaultValue, expectedFunction.defaultValue)
+ } else if let actualFunction = actualFunction as? MGLCompositeStyleFunction<MGLColor>,
+ let expectedFunction = expectedFunction as? MGLCompositeStyleFunction<MGLColor> {
+ XCTAssertEqual(actualFunction.defaultValue, expectedFunction.defaultValue)
+ }
+
+ func assertStopEqual (_ actualValue: Any?, _ expectedValue: Any?) {
+ guard type(of: actualValue) == type(of: expectedValue) else {
+ XCTFail("Expected stop value of type \(type(of: expectedValue)), but found \(type(of: actualValue)) instead.")
+ return
+ }
+ if let actualValue = actualValue as? MGLStyleConstantValue<MGLColor>,
+ let expectedValue = expectedValue as? MGLStyleConstantValue<MGLColor> {
+ assertColorsEqualWithAccuracy(actualValue.rawValue, expectedValue.rawValue)
+ } else if let actualValue = actualValue as? MGLStyleConstantValue<AnyObject>,
+ let expectedValue = expectedValue as? MGLStyleConstantValue<AnyObject> {
+ XCTAssertEqual(actualValue, expectedValue)
+ } else {
+ XCTFail("Unsupported stop value type \(type(of: actualValue)).")
+ }
+ }
+
+ XCTAssertEqual(actualStops.count, expectedStops.count)
+ if let actualStops = actualStops as? [String:Any], let expectedStops = expectedStops as? [String: Any] {
+ for (key, value) in actualStops {
+ assertStopEqual(value, expectedStops[key])
+ }
+ } else if let actualStops = actualStops as? [Float:Any], let expectedStops = expectedStops as? [Float:Any] {
+ for (key, value) in actualStops {
+ assertStopEqual(value, expectedStops[key])
+ }
+ } else {
+ XCTFail("Expected stops of type \(type(of: Array(expectedStops.keys)).Index.self), but found \(type(of: Array(actualStops.keys)).Index.self) instead.")
+ return
+ }
+ } else {
+ XCTFail("MGLStyleValue<MGLColor> must be either a constant or a style function.")
+ }
+ }
func testConstantValues() {
let shapeSource = MGLShapeSource(identifier: "source", shape: nil, options: nil)
@@ -44,7 +124,7 @@ extension MGLStyleValueTests {
var circleTranslationTwo = CGVector(dx: 0, dy: 0)
let circleTranslationValueTwo = NSValue(bytes: &circleTranslationTwo, objCType: "{CGVector=dd}")
- let circleTranslationStops = [
+ let circleTranslationStops : [Float:MGLStyleValue<NSValue>] = [
0: MGLStyleValue<NSValue>(rawValue: circleTranslationValueOne),
10: MGLStyleValue<NSValue>(rawValue: circleTranslationValueTwo)
]
@@ -59,7 +139,7 @@ extension MGLStyleValueTests {
XCTAssertEqual(circleStyleLayer.circleTranslation, expectedCircleTranslationValue)
// non-data-driven (enumeration property value), camera function with MGLCircleScaleAlignment enum (NSValue) stop values
- let scaleAlignmentStops = [
+ let scaleAlignmentStops : [Float:MGLStyleValue<NSValue>] = [
0: MGLStyleValue(rawValue: NSValue(mglCircleScaleAlignment: .map)),
10: MGLStyleValue(rawValue: NSValue(mglCircleScaleAlignment: .viewport))
]
@@ -75,135 +155,67 @@ extension MGLStyleValueTests {
func testFunctionsWithDataDrivenProperties() {
let shapeSource = MGLShapeSource(identifier: "test", shape: nil, options: nil)
let circleStyleLayer = MGLCircleStyleLayer(identifier: "circleLayer", source: shapeSource)
-
- #if os(iOS) || os(watchOS) || os(tvOS)
-
- // data-driven, camera function with exponential color stop values
- let redGreenStops = [
- 0: MGLStyleValue<UIColor>(rawValue: .red),
- 10: MGLStyleValue<UIColor>(rawValue: .red),
- 15: MGLStyleValue<UIColor>(rawValue: .green)
- ]
- let expectedCircleColorValue = MGLStyleValue<UIColor>(
- interpolationMode: .exponential,
- cameraStops: redGreenStops,
- options: [.interpolationBase: 10.0]
- )
- circleStyleLayer.circleColor = expectedCircleColorValue
- XCTAssertEqual(circleStyleLayer.circleColor, expectedCircleColorValue)
-
- // data-driven, source function with categorical color stop values with string attribute keys
- let redOnlyStops = [
- "red": MGLStyleValue<UIColor>(rawValue: .red)
- ]
- let expectedRedCategoricalValue = MGLStyleValue<UIColor>(
- interpolationMode: .categorical,
- sourceStops: redOnlyStops,
- attributeName: "red",
- options: [.defaultValue: MGLStyleValue<UIColor>(rawValue: .cyan)]
- )
- circleStyleLayer.circleColor = expectedRedCategoricalValue
- XCTAssertEqual(circleStyleLayer.circleColor, expectedRedCategoricalValue)
-
- // data-driven, source function with categorical color stop values with integer attribute keys
- let greenOrangeStops = [
- 0: MGLStyleValue<UIColor>(rawValue: .green),
- 100: MGLStyleValue<UIColor>(rawValue: .orange)
- ]
- let expectedGreenOrangeCategoricalValue = MGLStyleValue<UIColor>(
- interpolationMode: .categorical,
- sourceStops: greenOrangeStops,
- attributeName: "temp",
- options: [.defaultValue: MGLStyleValue<UIColor>(rawValue: .red)]
- )
- circleStyleLayer.circleColor = expectedGreenOrangeCategoricalValue
- XCTAssertEqual(circleStyleLayer.circleColor, expectedGreenOrangeCategoricalValue)
-
- // data-driven, source function with exponential color stop values
- let expectedRedGreenSourceExponentialValue = MGLStyleValue<UIColor>(
- interpolationMode: .exponential,
- sourceStops: redGreenStops,
- attributeName: "temp",
- options: nil
- )
- circleStyleLayer.circleColor = expectedRedGreenSourceExponentialValue
- XCTAssertEqual(circleStyleLayer.circleColor, expectedRedGreenSourceExponentialValue)
-
- // data-driven, identity source function
- let expectedSourceIdentityValue = MGLStyleValue<UIColor>(
- interpolationMode: .identity,
- sourceStops: nil,
- attributeName: "size",
- options: [.defaultValue: MGLStyleValue<UIColor>(rawValue: .green)]
- )
- circleStyleLayer.circleColor = expectedSourceIdentityValue
- XCTAssertEqual(circleStyleLayer.circleColor, expectedSourceIdentityValue)
-
- #elseif os(macOS)
-
- // data-driven, camera function with exponential color stop values
- let redGreenStops = [
- 0: MGLStyleValue<NSColor>(rawValue: .red),
- 10: MGLStyleValue<NSColor>(rawValue: .red),
- 15: MGLStyleValue<NSColor>(rawValue: .green)
- ]
- let expectedCircleColorValue = MGLStyleValue<NSColor>(
- interpolationMode: .exponential,
- cameraStops: redGreenStops,
- options: [.interpolationBase: 10.0]
- )
- circleStyleLayer.circleColor = expectedCircleColorValue
- XCTAssertEqual(circleStyleLayer.circleColor, expectedCircleColorValue)
-
- // data-driven, source function with categorical color stop values with string typed keys
- let redOnlyStops = [
- "red": MGLStyleValue<NSColor>(rawValue: .red)
- ]
- let expectedRedCategoricalValue = MGLStyleValue<NSColor>(
- interpolationMode: .categorical,
-
- sourceStops: redOnlyStops,
- attributeName: "red",
- options: [.defaultValue: MGLStyleValue<NSColor>(rawValue: .cyan)]
- )
- circleStyleLayer.circleColor = expectedRedCategoricalValue
- XCTAssertEqual(circleStyleLayer.circleColor, expectedRedCategoricalValue)
-
- // data-driven, source function with categorical color stop values with integer attribute keys
- let greenOrangeStops = [
- 0: MGLStyleValue<NSColor>(rawValue: .green),
- 100: MGLStyleValue<NSColor>(rawValue: .orange)
- ]
- let expectedGreenOrangeCategoricalValue = MGLStyleValue<NSColor>(
- interpolationMode: .categorical,
- sourceStops: greenOrangeStops,
- attributeName: "temp",
- options: [.defaultValue: MGLStyleValue<NSColor>(rawValue: .red)]
- )
- circleStyleLayer.circleColor = expectedGreenOrangeCategoricalValue
- XCTAssertEqual(circleStyleLayer.circleColor, expectedGreenOrangeCategoricalValue)
-
- // data-driven, source function with exponential color stop values
- let expectedRedGreenSourceExponentialValue = MGLStyleValue<NSColor>(
- interpolationMode: .exponential,
- sourceStops: redGreenStops,
- attributeName: "temp",
- options: nil
- )
- circleStyleLayer.circleColor = expectedRedGreenSourceExponentialValue
- XCTAssertEqual(circleStyleLayer.circleColor, expectedRedGreenSourceExponentialValue)
-
- // data-driven, identity source function
- let expectedSourceIdentityValue = MGLStyleValue<NSColor>(
- interpolationMode: .identity,
- sourceStops: nil,
- attributeName: "size",
- options: nil
- )
- circleStyleLayer.circleColor = expectedSourceIdentityValue
- XCTAssertEqual(circleStyleLayer.circleColor, expectedSourceIdentityValue)
-
- #endif
+
+ // data-driven, camera function with exponential color stop values
+ let redGreenStops : [Float:MGLStyleValue<MGLColor>] = [
+ 0: MGLStyleValue<MGLColor>(rawValue: .red),
+ 10: MGLStyleValue<MGLColor>(rawValue: .red),
+ 15: MGLStyleValue<MGLColor>(rawValue: .green)
+ ]
+ let expectedCircleColorValue = MGLStyleValue<MGLColor>(
+ interpolationMode: .exponential,
+ cameraStops: redGreenStops,
+ options: [.interpolationBase: 10.0]
+ )
+ circleStyleLayer.circleColor = expectedCircleColorValue
+ assertColorValuesEqual(circleStyleLayer.circleColor as! MGLStyleFunction<MGLColor>, expectedCircleColorValue as! MGLStyleFunction<MGLColor>)
+
+ // data-driven, source function with categorical color stop values with string attribute keys
+ let redOnlyStops = [
+ "red": MGLStyleValue<MGLColor>(rawValue: .red)
+ ]
+ let expectedRedCategoricalValue = MGLStyleValue<MGLColor>(
+ interpolationMode: .categorical,
+ sourceStops: redOnlyStops,
+ attributeName: "red",
+ options: [.defaultValue: MGLStyleValue<MGLColor>(rawValue: .cyan)]
+ )
+ circleStyleLayer.circleColor = expectedRedCategoricalValue
+ assertColorValuesEqual(circleStyleLayer.circleColor, expectedRedCategoricalValue)
+
+ // data-driven, source function with categorical color stop values with integer attribute keys
+ let greenOrangeStops : [Float:MGLStyleValue<MGLColor>] = [
+ 0: MGLStyleValue<MGLColor>(rawValue: .green),
+ 100: MGLStyleValue<MGLColor>(rawValue: .orange)
+ ]
+ let expectedGreenOrangeCategoricalValue = MGLStyleValue<MGLColor>(
+ interpolationMode: .categorical,
+ sourceStops: greenOrangeStops,
+ attributeName: "temp",
+ options: [.defaultValue: MGLStyleValue<MGLColor>(rawValue: .red)]
+ )
+ circleStyleLayer.circleColor = expectedGreenOrangeCategoricalValue
+ assertColorValuesEqual(circleStyleLayer.circleColor, expectedGreenOrangeCategoricalValue)
+
+ // data-driven, source function with exponential color stop values
+ let expectedRedGreenSourceExponentialValue = MGLStyleValue<MGLColor>(
+ interpolationMode: .exponential,
+ sourceStops: redGreenStops,
+ attributeName: "temp",
+ options: nil
+ )
+ circleStyleLayer.circleColor = expectedRedGreenSourceExponentialValue
+ assertColorValuesEqual(circleStyleLayer.circleColor, expectedRedGreenSourceExponentialValue)
+
+ // data-driven, identity source function
+ let expectedSourceIdentityValue = MGLStyleValue<MGLColor>(
+ interpolationMode: .identity,
+ sourceStops: nil,
+ attributeName: "size",
+ options: [.defaultValue: MGLStyleValue<MGLColor>(rawValue: .green)]
+ )
+ circleStyleLayer.circleColor = expectedSourceIdentityValue
+ assertColorValuesEqual(circleStyleLayer.circleColor, expectedSourceIdentityValue)
// data-driven, source function with categorical color stop values with boolean attribute keys
let booleanCategoricalStops = [
@@ -223,7 +235,7 @@ extension MGLStyleValueTests {
let smallRadius = MGLStyleValue<NSNumber>(rawValue: 5)
let mediumRadius = MGLStyleValue<NSNumber>(rawValue: 10)
let largeRadius = MGLStyleValue<NSNumber>(rawValue: 20)
- let radiusCompositeCategoricalStops: [NSNumber: [String: MGLStyleValue<NSNumber>]] = [
+ let radiusCompositeCategoricalStops: [Float: [String: MGLStyleValue<NSNumber>]] = [
0: ["green": smallRadius],
10: ["green": smallRadius],
15: ["green": largeRadius],
@@ -240,7 +252,7 @@ extension MGLStyleValueTests {
XCTAssertEqual(circleStyleLayer.circleRadius, expectedCompositeCategoricalValue)
// data-driven, composite function with inner exponential color stop values nested in outer camera stops
- let radiusCompositeExponentialOrIntervalStops: [NSNumber: [NSNumber: MGLStyleValue<NSNumber>]] = [
+ let radiusCompositeExponentialOrIntervalStops: [Float: [Float: MGLStyleValue<NSNumber>]] = [
0: [0: smallRadius],
10: [200: smallRadius],
20: [200: largeRadius]
diff --git a/platform/ios/ios.xcodeproj/project.pbxproj b/platform/ios/ios.xcodeproj/project.pbxproj
index db078d0274..d08c52fcb3 100644
--- a/platform/ios/ios.xcodeproj/project.pbxproj
+++ b/platform/ios/ios.xcodeproj/project.pbxproj
@@ -7,6 +7,8 @@
objects = {
/* Begin PBXBuildFile section */
+ 1753ED421E53CE6F00A9FD90 /* MGLConversion.h in Headers */ = {isa = PBXBuildFile; fileRef = 1753ED411E53CE6F00A9FD90 /* MGLConversion.h */; };
+ 1753ED431E53CE6F00A9FD90 /* MGLConversion.h in Headers */ = {isa = PBXBuildFile; fileRef = 1753ED411E53CE6F00A9FD90 /* MGLConversion.h */; };
30E578171DAA85520050F07E /* UIImage+MGLAdditions.h in Headers */ = {isa = PBXBuildFile; fileRef = 30E578111DAA7D690050F07E /* UIImage+MGLAdditions.h */; };
30E578181DAA85520050F07E /* UIImage+MGLAdditions.h in Headers */ = {isa = PBXBuildFile; fileRef = 30E578111DAA7D690050F07E /* UIImage+MGLAdditions.h */; };
30E578191DAA855E0050F07E /* UIImage+MGLAdditions.mm in Sources */ = {isa = PBXBuildFile; fileRef = 30E578121DAA7D690050F07E /* UIImage+MGLAdditions.mm */; };
@@ -518,6 +520,7 @@
/* End PBXCopyFilesBuildPhase section */
/* Begin PBXFileReference section */
+ 1753ED411E53CE6F00A9FD90 /* MGLConversion.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = MGLConversion.h; sourceTree = "<group>"; };
20DABE861DF78148007AC5FF /* zh-Hans */ = {isa = PBXFileReference; lastKnownFileType = text.plist.strings; name = "zh-Hans"; path = "zh-Hans.lproj/Foundation.strings"; sourceTree = "<group>"; };
20DABE881DF78148007AC5FF /* zh-Hans */ = {isa = PBXFileReference; lastKnownFileType = text.plist.strings; name = "zh-Hans"; path = "zh-Hans.lproj/Localizable.strings"; sourceTree = "<group>"; };
20DABE8A1DF78149007AC5FF /* zh-Hans */ = {isa = PBXFileReference; lastKnownFileType = text.plist.strings; name = "zh-Hans"; path = "zh-Hans.lproj/Root.strings"; sourceTree = "<group>"; };
@@ -947,6 +950,7 @@
35599DA21D4682B60048254D /* Styling */ = {
isa = PBXGroup;
children = (
+ 1753ED411E53CE6F00A9FD90 /* MGLConversion.h */,
35599DB81D46AD7F0048254D /* Categories */,
353933F01D3FB6BA003F57D7 /* Layers */,
35136D491D4277EA00C20EFD /* Sources */,
@@ -1574,6 +1578,7 @@
DAD1656C1CF41981001FF4B9 /* MGLFeature.h in Headers */,
40EDA1C01CFE0E0200D9EA68 /* MGLAnnotationContainerView.h in Headers */,
DA88484F1CBAFB9800AB86E3 /* MGLAnnotationImage_Private.h in Headers */,
+ 1753ED421E53CE6F00A9FD90 /* MGLConversion.h in Headers */,
DA8847F21CBAFA5100AB86E3 /* MGLMapCamera.h in Headers */,
3538AA1D1D542239008EC33D /* MGLForegroundStyleLayer.h in Headers */,
DA8847F51CBAFA5100AB86E3 /* MGLOfflineRegion.h in Headers */,
@@ -1659,6 +1664,7 @@
DAF0D8141DFE0EC500B28378 /* MGLVectorSource_Private.h in Headers */,
DABFB8731CBE9A9900D62B32 /* Mapbox.h in Headers */,
357FE2DE1E02D2B20068B753 /* NSCoder+MGLAdditions.h in Headers */,
+ 1753ED431E53CE6F00A9FD90 /* MGLConversion.h in Headers */,
354B83971D2E873E005D9406 /* MGLUserLocationAnnotationView.h in Headers */,
DAF0D8111DFE0EA000B28378 /* MGLRasterSource_Private.h in Headers */,
DABFB86B1CBE99E500D62B32 /* MGLTilePyramidOfflineRegion.h in Headers */,
diff --git a/platform/macos/macos.xcodeproj/project.pbxproj b/platform/macos/macos.xcodeproj/project.pbxproj
index 7059897135..2619283712 100644
--- a/platform/macos/macos.xcodeproj/project.pbxproj
+++ b/platform/macos/macos.xcodeproj/project.pbxproj
@@ -7,6 +7,7 @@
objects = {
/* Begin PBXBuildFile section */
+ 1753ED401E53CE6100A9FD90 /* MGLConversion.h in Headers */ = {isa = PBXBuildFile; fileRef = 1753ED3F1E53CE5200A9FD90 /* MGLConversion.h */; };
30E5781B1DAA857E0050F07E /* NSImage+MGLAdditions.h in Headers */ = {isa = PBXBuildFile; fileRef = 30E578141DAA7D920050F07E /* NSImage+MGLAdditions.h */; };
3508EC641D749D39009B0EE4 /* NSExpression+MGLAdditions.h in Headers */ = {isa = PBXBuildFile; fileRef = 3508EC621D749D39009B0EE4 /* NSExpression+MGLAdditions.h */; };
3508EC651D749D39009B0EE4 /* NSExpression+MGLAdditions.mm in Sources */ = {isa = PBXBuildFile; fileRef = 3508EC631D749D39009B0EE4 /* NSExpression+MGLAdditions.mm */; };
@@ -258,6 +259,7 @@
/* End PBXCopyFilesBuildPhase section */
/* Begin PBXFileReference section */
+ 1753ED3F1E53CE5200A9FD90 /* MGLConversion.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = MGLConversion.h; sourceTree = "<group>"; };
30E578141DAA7D920050F07E /* NSImage+MGLAdditions.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = "NSImage+MGLAdditions.h"; path = "src/NSImage+MGLAdditions.h"; sourceTree = SOURCE_ROOT; };
3508EC621D749D39009B0EE4 /* NSExpression+MGLAdditions.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = "NSExpression+MGLAdditions.h"; sourceTree = "<group>"; };
3508EC631D749D39009B0EE4 /* NSExpression+MGLAdditions.mm */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.objcpp; path = "NSExpression+MGLAdditions.mm"; sourceTree = "<group>"; };
@@ -613,6 +615,7 @@
3527429B1D4C259500A1ECE6 /* Styling */ = {
isa = PBXGroup;
children = (
+ 1753ED3F1E53CE5200A9FD90 /* MGLConversion.h */,
352742791D4C235C00A1ECE6 /* Categories */,
35136D471D42295400C20EFD /* Layers */,
3527427E1D4C242B00A1ECE6 /* Sources */,
@@ -1007,6 +1010,7 @@
3508EC641D749D39009B0EE4 /* NSExpression+MGLAdditions.h in Headers */,
DAE6C38D1CC31E2A00DB3429 /* MGLOfflineRegion_Private.h in Headers */,
DA7DC9831DED647F0027472F /* MGLRasterSource_Private.h in Headers */,
+ 1753ED401E53CE6100A9FD90 /* MGLConversion.h in Headers */,
408AA8651DAEEE3400022900 /* MGLPolygon+MGLAdditions.h in Headers */,
DA8F259C1D51CB000010E6B5 /* MGLStyleValue_Private.h in Headers */,
DAE6C35B1CC31E0400DB3429 /* MGLAnnotation.h in Headers */,