From a230b5d20949d9ba5b31f4d762ae88af4c5ee8f5 Mon Sep 17 00:00:00 2001 From: Thomas Van Lenten Date: Tue, 21 Jun 2016 08:25:28 -0400 Subject: Rename methods to avoid ObjC KVC collisions. (#1699) Note: Breaking API change on the Dictionary classes. The numeric value classes were using "Value" in the naming, but this silently collided with the KVC category on NSObject; meaning KVC code could break up a keypath and call these selectors with the wrong types leading to crashes (even though the code all would compile cleanly). - Rename the methods to use the "type" instead of literal "Value". - Update all the impls and tests. - Enable the warning that will catch issues like this in the future. Fixes https://github.com/google/protobuf/issues/1616 --- objectivec/GPBDictionary.h | 1063 ++++++----- objectivec/GPBDictionary.m | 1876 ++++++++++---------- objectivec/GPBProtocolBuffers.m | 8 + objectivec/Tests/GPBDictionaryTests+Bool.m | 1020 +++++------ objectivec/Tests/GPBDictionaryTests+Int32.m | 2044 +++++++++++----------- objectivec/Tests/GPBDictionaryTests+Int64.m | 2044 +++++++++++----------- objectivec/Tests/GPBDictionaryTests+String.m | 2036 ++++++++++----------- objectivec/Tests/GPBDictionaryTests+UInt32.m | 2044 +++++++++++----------- objectivec/Tests/GPBDictionaryTests+UInt64.m | 2044 +++++++++++----------- objectivec/Tests/GPBDictionaryTests.pddm | 428 ++--- objectivec/Tests/GPBMessageTests+Serialization.m | 88 +- objectivec/Tests/GPBMessageTests.m | 8 +- objectivec/Tests/GPBSwiftTests.swift | 40 +- objectivec/Tests/GPBTestUtilities.m | 30 +- 14 files changed, 7448 insertions(+), 7325 deletions(-) diff --git a/objectivec/GPBDictionary.h b/objectivec/GPBDictionary.h index b98aaa1f..f7959960 100644 --- a/objectivec/GPBDictionary.h +++ b/objectivec/GPBDictionary.h @@ -37,13 +37,16 @@ // Note: These are not meant to be subclassed. -NS_ASSUME_NONNULL_BEGIN +// Note on naming: for the classes holding numeric values, a more natural +// naming of the method might be things like "-valueForKey:", +// "-setValue:forKey:"; etc. But those selectors are also defined by Key Value +// Coding (KVC) as categories on NSObject. So "overloading" the selectors with +// other meanings can cause warnings (based on compiler settings), but more +// importantly, some of those selector get called as KVC breaks up keypaths. +// So if those selectors are used, using KVC will compile cleanly, but could +// crash as it invokes those selectors with the wrong types of arguments. -// Disable -Woverriding-method-mismatch until resolving the accidental conflict -// with NSObject's KVC category. -// https://github.com/google/protobuf/issues/1616 opened to resolve this. -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Woverriding-method-mismatch" +NS_ASSUME_NONNULL_BEGIN //%PDDM-EXPAND DECLARE_DICTIONARIES() // This block of code is generated, do not edit it directly. @@ -55,30 +58,32 @@ NS_ASSUME_NONNULL_BEGIN @property(nonatomic, readonly) NSUInteger count; + (instancetype)dictionary; -+ (instancetype)dictionaryWithValue:(uint32_t)value - forKey:(uint32_t)key; -+ (instancetype)dictionaryWithValues:(const uint32_t [])values - forKeys:(const uint32_t [])keys - count:(NSUInteger)count; ++ (instancetype)dictionaryWithUInt32:(uint32_t)value + forKey:(uint32_t)key; ++ (instancetype)dictionaryWithUInt32s:(const uint32_t [])values + forKeys:(const uint32_t [])keys + count:(NSUInteger)count; + (instancetype)dictionaryWithDictionary:(GPBUInt32UInt32Dictionary *)dictionary; + (instancetype)dictionaryWithCapacity:(NSUInteger)numItems; -- (instancetype)initWithValues:(const uint32_t [])values - forKeys:(const uint32_t [])keys - count:(NSUInteger)count NS_DESIGNATED_INITIALIZER; +- (instancetype)initWithUInt32s:(const uint32_t [])values + forKeys:(const uint32_t [])keys + count:(NSUInteger)count NS_DESIGNATED_INITIALIZER; - (instancetype)initWithDictionary:(GPBUInt32UInt32Dictionary *)dictionary; - (instancetype)initWithCapacity:(NSUInteger)numItems; -- (BOOL)valueForKey:(uint32_t)key value:(nullable uint32_t *)value; +// Returns YES/NO to indicate if the key was found or not, filling in the value +// only when the key was found. +- (BOOL)getUInt32:(nullable uint32_t *)value forKey:(uint32_t)key; -- (void)enumerateKeysAndValuesUsingBlock: +- (void)enumerateKeysAndUInt32sUsingBlock: (void (^)(uint32_t key, uint32_t value, BOOL *stop))block; - (void)addEntriesFromDictionary:(GPBUInt32UInt32Dictionary *)otherDictionary; -- (void)setValue:(uint32_t)value forKey:(uint32_t)key; +- (void)setUInt32:(uint32_t)value forKey:(uint32_t)key; -- (void)removeValueForKey:(uint32_t)aKey; +- (void)removeUInt32ForKey:(uint32_t)aKey; - (void)removeAll; @end @@ -90,30 +95,32 @@ NS_ASSUME_NONNULL_BEGIN @property(nonatomic, readonly) NSUInteger count; + (instancetype)dictionary; -+ (instancetype)dictionaryWithValue:(int32_t)value ++ (instancetype)dictionaryWithInt32:(int32_t)value forKey:(uint32_t)key; -+ (instancetype)dictionaryWithValues:(const int32_t [])values ++ (instancetype)dictionaryWithInt32s:(const int32_t [])values forKeys:(const uint32_t [])keys count:(NSUInteger)count; + (instancetype)dictionaryWithDictionary:(GPBUInt32Int32Dictionary *)dictionary; + (instancetype)dictionaryWithCapacity:(NSUInteger)numItems; -- (instancetype)initWithValues:(const int32_t [])values +- (instancetype)initWithInt32s:(const int32_t [])values forKeys:(const uint32_t [])keys count:(NSUInteger)count NS_DESIGNATED_INITIALIZER; - (instancetype)initWithDictionary:(GPBUInt32Int32Dictionary *)dictionary; - (instancetype)initWithCapacity:(NSUInteger)numItems; -- (BOOL)valueForKey:(uint32_t)key value:(nullable int32_t *)value; +// Returns YES/NO to indicate if the key was found or not, filling in the value +// only when the key was found. +- (BOOL)getInt32:(nullable int32_t *)value forKey:(uint32_t)key; -- (void)enumerateKeysAndValuesUsingBlock: +- (void)enumerateKeysAndInt32sUsingBlock: (void (^)(uint32_t key, int32_t value, BOOL *stop))block; - (void)addEntriesFromDictionary:(GPBUInt32Int32Dictionary *)otherDictionary; -- (void)setValue:(int32_t)value forKey:(uint32_t)key; +- (void)setInt32:(int32_t)value forKey:(uint32_t)key; -- (void)removeValueForKey:(uint32_t)aKey; +- (void)removeInt32ForKey:(uint32_t)aKey; - (void)removeAll; @end @@ -125,30 +132,32 @@ NS_ASSUME_NONNULL_BEGIN @property(nonatomic, readonly) NSUInteger count; + (instancetype)dictionary; -+ (instancetype)dictionaryWithValue:(uint64_t)value - forKey:(uint32_t)key; -+ (instancetype)dictionaryWithValues:(const uint64_t [])values - forKeys:(const uint32_t [])keys - count:(NSUInteger)count; ++ (instancetype)dictionaryWithUInt64:(uint64_t)value + forKey:(uint32_t)key; ++ (instancetype)dictionaryWithUInt64s:(const uint64_t [])values + forKeys:(const uint32_t [])keys + count:(NSUInteger)count; + (instancetype)dictionaryWithDictionary:(GPBUInt32UInt64Dictionary *)dictionary; + (instancetype)dictionaryWithCapacity:(NSUInteger)numItems; -- (instancetype)initWithValues:(const uint64_t [])values - forKeys:(const uint32_t [])keys - count:(NSUInteger)count NS_DESIGNATED_INITIALIZER; +- (instancetype)initWithUInt64s:(const uint64_t [])values + forKeys:(const uint32_t [])keys + count:(NSUInteger)count NS_DESIGNATED_INITIALIZER; - (instancetype)initWithDictionary:(GPBUInt32UInt64Dictionary *)dictionary; - (instancetype)initWithCapacity:(NSUInteger)numItems; -- (BOOL)valueForKey:(uint32_t)key value:(nullable uint64_t *)value; +// Returns YES/NO to indicate if the key was found or not, filling in the value +// only when the key was found. +- (BOOL)getUInt64:(nullable uint64_t *)value forKey:(uint32_t)key; -- (void)enumerateKeysAndValuesUsingBlock: +- (void)enumerateKeysAndUInt64sUsingBlock: (void (^)(uint32_t key, uint64_t value, BOOL *stop))block; - (void)addEntriesFromDictionary:(GPBUInt32UInt64Dictionary *)otherDictionary; -- (void)setValue:(uint64_t)value forKey:(uint32_t)key; +- (void)setUInt64:(uint64_t)value forKey:(uint32_t)key; -- (void)removeValueForKey:(uint32_t)aKey; +- (void)removeUInt64ForKey:(uint32_t)aKey; - (void)removeAll; @end @@ -160,30 +169,32 @@ NS_ASSUME_NONNULL_BEGIN @property(nonatomic, readonly) NSUInteger count; + (instancetype)dictionary; -+ (instancetype)dictionaryWithValue:(int64_t)value ++ (instancetype)dictionaryWithInt64:(int64_t)value forKey:(uint32_t)key; -+ (instancetype)dictionaryWithValues:(const int64_t [])values ++ (instancetype)dictionaryWithInt64s:(const int64_t [])values forKeys:(const uint32_t [])keys count:(NSUInteger)count; + (instancetype)dictionaryWithDictionary:(GPBUInt32Int64Dictionary *)dictionary; + (instancetype)dictionaryWithCapacity:(NSUInteger)numItems; -- (instancetype)initWithValues:(const int64_t [])values +- (instancetype)initWithInt64s:(const int64_t [])values forKeys:(const uint32_t [])keys count:(NSUInteger)count NS_DESIGNATED_INITIALIZER; - (instancetype)initWithDictionary:(GPBUInt32Int64Dictionary *)dictionary; - (instancetype)initWithCapacity:(NSUInteger)numItems; -- (BOOL)valueForKey:(uint32_t)key value:(nullable int64_t *)value; +// Returns YES/NO to indicate if the key was found or not, filling in the value +// only when the key was found. +- (BOOL)getInt64:(nullable int64_t *)value forKey:(uint32_t)key; -- (void)enumerateKeysAndValuesUsingBlock: +- (void)enumerateKeysAndInt64sUsingBlock: (void (^)(uint32_t key, int64_t value, BOOL *stop))block; - (void)addEntriesFromDictionary:(GPBUInt32Int64Dictionary *)otherDictionary; -- (void)setValue:(int64_t)value forKey:(uint32_t)key; +- (void)setInt64:(int64_t)value forKey:(uint32_t)key; -- (void)removeValueForKey:(uint32_t)aKey; +- (void)removeInt64ForKey:(uint32_t)aKey; - (void)removeAll; @end @@ -195,30 +206,32 @@ NS_ASSUME_NONNULL_BEGIN @property(nonatomic, readonly) NSUInteger count; + (instancetype)dictionary; -+ (instancetype)dictionaryWithValue:(BOOL)value - forKey:(uint32_t)key; -+ (instancetype)dictionaryWithValues:(const BOOL [])values - forKeys:(const uint32_t [])keys - count:(NSUInteger)count; ++ (instancetype)dictionaryWithBool:(BOOL)value + forKey:(uint32_t)key; ++ (instancetype)dictionaryWithBools:(const BOOL [])values + forKeys:(const uint32_t [])keys + count:(NSUInteger)count; + (instancetype)dictionaryWithDictionary:(GPBUInt32BoolDictionary *)dictionary; + (instancetype)dictionaryWithCapacity:(NSUInteger)numItems; -- (instancetype)initWithValues:(const BOOL [])values - forKeys:(const uint32_t [])keys - count:(NSUInteger)count NS_DESIGNATED_INITIALIZER; +- (instancetype)initWithBools:(const BOOL [])values + forKeys:(const uint32_t [])keys + count:(NSUInteger)count NS_DESIGNATED_INITIALIZER; - (instancetype)initWithDictionary:(GPBUInt32BoolDictionary *)dictionary; - (instancetype)initWithCapacity:(NSUInteger)numItems; -- (BOOL)valueForKey:(uint32_t)key value:(nullable BOOL *)value; +// Returns YES/NO to indicate if the key was found or not, filling in the value +// only when the key was found. +- (BOOL)getBool:(nullable BOOL *)value forKey:(uint32_t)key; -- (void)enumerateKeysAndValuesUsingBlock: +- (void)enumerateKeysAndBoolsUsingBlock: (void (^)(uint32_t key, BOOL value, BOOL *stop))block; - (void)addEntriesFromDictionary:(GPBUInt32BoolDictionary *)otherDictionary; -- (void)setValue:(BOOL)value forKey:(uint32_t)key; +- (void)setBool:(BOOL)value forKey:(uint32_t)key; -- (void)removeValueForKey:(uint32_t)aKey; +- (void)removeBoolForKey:(uint32_t)aKey; - (void)removeAll; @end @@ -230,30 +243,32 @@ NS_ASSUME_NONNULL_BEGIN @property(nonatomic, readonly) NSUInteger count; + (instancetype)dictionary; -+ (instancetype)dictionaryWithValue:(float)value ++ (instancetype)dictionaryWithFloat:(float)value forKey:(uint32_t)key; -+ (instancetype)dictionaryWithValues:(const float [])values ++ (instancetype)dictionaryWithFloats:(const float [])values forKeys:(const uint32_t [])keys count:(NSUInteger)count; + (instancetype)dictionaryWithDictionary:(GPBUInt32FloatDictionary *)dictionary; + (instancetype)dictionaryWithCapacity:(NSUInteger)numItems; -- (instancetype)initWithValues:(const float [])values +- (instancetype)initWithFloats:(const float [])values forKeys:(const uint32_t [])keys count:(NSUInteger)count NS_DESIGNATED_INITIALIZER; - (instancetype)initWithDictionary:(GPBUInt32FloatDictionary *)dictionary; - (instancetype)initWithCapacity:(NSUInteger)numItems; -- (BOOL)valueForKey:(uint32_t)key value:(nullable float *)value; +// Returns YES/NO to indicate if the key was found or not, filling in the value +// only when the key was found. +- (BOOL)getFloat:(nullable float *)value forKey:(uint32_t)key; -- (void)enumerateKeysAndValuesUsingBlock: +- (void)enumerateKeysAndFloatsUsingBlock: (void (^)(uint32_t key, float value, BOOL *stop))block; - (void)addEntriesFromDictionary:(GPBUInt32FloatDictionary *)otherDictionary; -- (void)setValue:(float)value forKey:(uint32_t)key; +- (void)setFloat:(float)value forKey:(uint32_t)key; -- (void)removeValueForKey:(uint32_t)aKey; +- (void)removeFloatForKey:(uint32_t)aKey; - (void)removeAll; @end @@ -265,30 +280,32 @@ NS_ASSUME_NONNULL_BEGIN @property(nonatomic, readonly) NSUInteger count; + (instancetype)dictionary; -+ (instancetype)dictionaryWithValue:(double)value - forKey:(uint32_t)key; -+ (instancetype)dictionaryWithValues:(const double [])values - forKeys:(const uint32_t [])keys - count:(NSUInteger)count; ++ (instancetype)dictionaryWithDouble:(double)value + forKey:(uint32_t)key; ++ (instancetype)dictionaryWithDoubles:(const double [])values + forKeys:(const uint32_t [])keys + count:(NSUInteger)count; + (instancetype)dictionaryWithDictionary:(GPBUInt32DoubleDictionary *)dictionary; + (instancetype)dictionaryWithCapacity:(NSUInteger)numItems; -- (instancetype)initWithValues:(const double [])values - forKeys:(const uint32_t [])keys - count:(NSUInteger)count NS_DESIGNATED_INITIALIZER; +- (instancetype)initWithDoubles:(const double [])values + forKeys:(const uint32_t [])keys + count:(NSUInteger)count NS_DESIGNATED_INITIALIZER; - (instancetype)initWithDictionary:(GPBUInt32DoubleDictionary *)dictionary; - (instancetype)initWithCapacity:(NSUInteger)numItems; -- (BOOL)valueForKey:(uint32_t)key value:(nullable double *)value; +// Returns YES/NO to indicate if the key was found or not, filling in the value +// only when the key was found. +- (BOOL)getDouble:(nullable double *)value forKey:(uint32_t)key; -- (void)enumerateKeysAndValuesUsingBlock: +- (void)enumerateKeysAndDoublesUsingBlock: (void (^)(uint32_t key, double value, BOOL *stop))block; - (void)addEntriesFromDictionary:(GPBUInt32DoubleDictionary *)otherDictionary; -- (void)setValue:(double)value forKey:(uint32_t)key; +- (void)setDouble:(double)value forKey:(uint32_t)key; -- (void)removeValueForKey:(uint32_t)aKey; +- (void)removeDoubleForKey:(uint32_t)aKey; - (void)removeAll; @end @@ -326,15 +343,19 @@ NS_ASSUME_NONNULL_BEGIN // is not a valid enumerator as defined by validationFunc. If the actual value is // desired, use "raw" version of the method. -- (BOOL)valueForKey:(uint32_t)key value:(nullable int32_t *)value; +// Returns YES/NO to indicate if the key was found or not, filling in the value +// only when the key was found. +- (BOOL)getEnum:(nullable int32_t *)value forKey:(uint32_t)key; -- (void)enumerateKeysAndValuesUsingBlock: +- (void)enumerateKeysAndEnumsUsingBlock: (void (^)(uint32_t key, int32_t value, BOOL *stop))block; // These methods bypass the validationFunc to provide access to values that were not // known at the time the binary was compiled. -- (BOOL)valueForKey:(uint32_t)key rawValue:(nullable int32_t *)rawValue; +// Returns YES/NO to indicate if the key was found or not, filling in the value +// only when the key was found. +- (BOOL)getRawValue:(nullable int32_t *)rawValue forKey:(uint32_t)key; - (void)enumerateKeysAndRawValuesUsingBlock: (void (^)(uint32_t key, int32_t rawValue, BOOL *stop))block; @@ -346,7 +367,7 @@ NS_ASSUME_NONNULL_BEGIN // to the default value. Use the rawValue methods below to assign non enumerator // values. -- (void)setValue:(int32_t)value forKey:(uint32_t)key; +- (void)setEnum:(int32_t)value forKey:(uint32_t)key; // This method bypass the validationFunc to provide setting of values that were not // known at the time the binary was compiled. @@ -354,7 +375,7 @@ NS_ASSUME_NONNULL_BEGIN // No validation applies to these methods. -- (void)removeValueForKey:(uint32_t)aKey; +- (void)removeEnumForKey:(uint32_t)aKey; - (void)removeAll; @end @@ -401,30 +422,32 @@ NS_ASSUME_NONNULL_BEGIN @property(nonatomic, readonly) NSUInteger count; + (instancetype)dictionary; -+ (instancetype)dictionaryWithValue:(uint32_t)value - forKey:(int32_t)key; -+ (instancetype)dictionaryWithValues:(const uint32_t [])values - forKeys:(const int32_t [])keys - count:(NSUInteger)count; ++ (instancetype)dictionaryWithUInt32:(uint32_t)value + forKey:(int32_t)key; ++ (instancetype)dictionaryWithUInt32s:(const uint32_t [])values + forKeys:(const int32_t [])keys + count:(NSUInteger)count; + (instancetype)dictionaryWithDictionary:(GPBInt32UInt32Dictionary *)dictionary; + (instancetype)dictionaryWithCapacity:(NSUInteger)numItems; -- (instancetype)initWithValues:(const uint32_t [])values - forKeys:(const int32_t [])keys - count:(NSUInteger)count NS_DESIGNATED_INITIALIZER; +- (instancetype)initWithUInt32s:(const uint32_t [])values + forKeys:(const int32_t [])keys + count:(NSUInteger)count NS_DESIGNATED_INITIALIZER; - (instancetype)initWithDictionary:(GPBInt32UInt32Dictionary *)dictionary; - (instancetype)initWithCapacity:(NSUInteger)numItems; -- (BOOL)valueForKey:(int32_t)key value:(nullable uint32_t *)value; +// Returns YES/NO to indicate if the key was found or not, filling in the value +// only when the key was found. +- (BOOL)getUInt32:(nullable uint32_t *)value forKey:(int32_t)key; -- (void)enumerateKeysAndValuesUsingBlock: +- (void)enumerateKeysAndUInt32sUsingBlock: (void (^)(int32_t key, uint32_t value, BOOL *stop))block; - (void)addEntriesFromDictionary:(GPBInt32UInt32Dictionary *)otherDictionary; -- (void)setValue:(uint32_t)value forKey:(int32_t)key; +- (void)setUInt32:(uint32_t)value forKey:(int32_t)key; -- (void)removeValueForKey:(int32_t)aKey; +- (void)removeUInt32ForKey:(int32_t)aKey; - (void)removeAll; @end @@ -436,30 +459,32 @@ NS_ASSUME_NONNULL_BEGIN @property(nonatomic, readonly) NSUInteger count; + (instancetype)dictionary; -+ (instancetype)dictionaryWithValue:(int32_t)value ++ (instancetype)dictionaryWithInt32:(int32_t)value forKey:(int32_t)key; -+ (instancetype)dictionaryWithValues:(const int32_t [])values ++ (instancetype)dictionaryWithInt32s:(const int32_t [])values forKeys:(const int32_t [])keys count:(NSUInteger)count; + (instancetype)dictionaryWithDictionary:(GPBInt32Int32Dictionary *)dictionary; + (instancetype)dictionaryWithCapacity:(NSUInteger)numItems; -- (instancetype)initWithValues:(const int32_t [])values +- (instancetype)initWithInt32s:(const int32_t [])values forKeys:(const int32_t [])keys count:(NSUInteger)count NS_DESIGNATED_INITIALIZER; - (instancetype)initWithDictionary:(GPBInt32Int32Dictionary *)dictionary; - (instancetype)initWithCapacity:(NSUInteger)numItems; -- (BOOL)valueForKey:(int32_t)key value:(nullable int32_t *)value; +// Returns YES/NO to indicate if the key was found or not, filling in the value +// only when the key was found. +- (BOOL)getInt32:(nullable int32_t *)value forKey:(int32_t)key; -- (void)enumerateKeysAndValuesUsingBlock: +- (void)enumerateKeysAndInt32sUsingBlock: (void (^)(int32_t key, int32_t value, BOOL *stop))block; - (void)addEntriesFromDictionary:(GPBInt32Int32Dictionary *)otherDictionary; -- (void)setValue:(int32_t)value forKey:(int32_t)key; +- (void)setInt32:(int32_t)value forKey:(int32_t)key; -- (void)removeValueForKey:(int32_t)aKey; +- (void)removeInt32ForKey:(int32_t)aKey; - (void)removeAll; @end @@ -471,30 +496,32 @@ NS_ASSUME_NONNULL_BEGIN @property(nonatomic, readonly) NSUInteger count; + (instancetype)dictionary; -+ (instancetype)dictionaryWithValue:(uint64_t)value - forKey:(int32_t)key; -+ (instancetype)dictionaryWithValues:(const uint64_t [])values - forKeys:(const int32_t [])keys - count:(NSUInteger)count; ++ (instancetype)dictionaryWithUInt64:(uint64_t)value + forKey:(int32_t)key; ++ (instancetype)dictionaryWithUInt64s:(const uint64_t [])values + forKeys:(const int32_t [])keys + count:(NSUInteger)count; + (instancetype)dictionaryWithDictionary:(GPBInt32UInt64Dictionary *)dictionary; + (instancetype)dictionaryWithCapacity:(NSUInteger)numItems; -- (instancetype)initWithValues:(const uint64_t [])values - forKeys:(const int32_t [])keys - count:(NSUInteger)count NS_DESIGNATED_INITIALIZER; +- (instancetype)initWithUInt64s:(const uint64_t [])values + forKeys:(const int32_t [])keys + count:(NSUInteger)count NS_DESIGNATED_INITIALIZER; - (instancetype)initWithDictionary:(GPBInt32UInt64Dictionary *)dictionary; - (instancetype)initWithCapacity:(NSUInteger)numItems; -- (BOOL)valueForKey:(int32_t)key value:(nullable uint64_t *)value; +// Returns YES/NO to indicate if the key was found or not, filling in the value +// only when the key was found. +- (BOOL)getUInt64:(nullable uint64_t *)value forKey:(int32_t)key; -- (void)enumerateKeysAndValuesUsingBlock: +- (void)enumerateKeysAndUInt64sUsingBlock: (void (^)(int32_t key, uint64_t value, BOOL *stop))block; - (void)addEntriesFromDictionary:(GPBInt32UInt64Dictionary *)otherDictionary; -- (void)setValue:(uint64_t)value forKey:(int32_t)key; +- (void)setUInt64:(uint64_t)value forKey:(int32_t)key; -- (void)removeValueForKey:(int32_t)aKey; +- (void)removeUInt64ForKey:(int32_t)aKey; - (void)removeAll; @end @@ -506,30 +533,32 @@ NS_ASSUME_NONNULL_BEGIN @property(nonatomic, readonly) NSUInteger count; + (instancetype)dictionary; -+ (instancetype)dictionaryWithValue:(int64_t)value ++ (instancetype)dictionaryWithInt64:(int64_t)value forKey:(int32_t)key; -+ (instancetype)dictionaryWithValues:(const int64_t [])values ++ (instancetype)dictionaryWithInt64s:(const int64_t [])values forKeys:(const int32_t [])keys count:(NSUInteger)count; + (instancetype)dictionaryWithDictionary:(GPBInt32Int64Dictionary *)dictionary; + (instancetype)dictionaryWithCapacity:(NSUInteger)numItems; -- (instancetype)initWithValues:(const int64_t [])values +- (instancetype)initWithInt64s:(const int64_t [])values forKeys:(const int32_t [])keys count:(NSUInteger)count NS_DESIGNATED_INITIALIZER; - (instancetype)initWithDictionary:(GPBInt32Int64Dictionary *)dictionary; - (instancetype)initWithCapacity:(NSUInteger)numItems; -- (BOOL)valueForKey:(int32_t)key value:(nullable int64_t *)value; +// Returns YES/NO to indicate if the key was found or not, filling in the value +// only when the key was found. +- (BOOL)getInt64:(nullable int64_t *)value forKey:(int32_t)key; -- (void)enumerateKeysAndValuesUsingBlock: +- (void)enumerateKeysAndInt64sUsingBlock: (void (^)(int32_t key, int64_t value, BOOL *stop))block; - (void)addEntriesFromDictionary:(GPBInt32Int64Dictionary *)otherDictionary; -- (void)setValue:(int64_t)value forKey:(int32_t)key; +- (void)setInt64:(int64_t)value forKey:(int32_t)key; -- (void)removeValueForKey:(int32_t)aKey; +- (void)removeInt64ForKey:(int32_t)aKey; - (void)removeAll; @end @@ -541,30 +570,32 @@ NS_ASSUME_NONNULL_BEGIN @property(nonatomic, readonly) NSUInteger count; + (instancetype)dictionary; -+ (instancetype)dictionaryWithValue:(BOOL)value - forKey:(int32_t)key; -+ (instancetype)dictionaryWithValues:(const BOOL [])values - forKeys:(const int32_t [])keys - count:(NSUInteger)count; ++ (instancetype)dictionaryWithBool:(BOOL)value + forKey:(int32_t)key; ++ (instancetype)dictionaryWithBools:(const BOOL [])values + forKeys:(const int32_t [])keys + count:(NSUInteger)count; + (instancetype)dictionaryWithDictionary:(GPBInt32BoolDictionary *)dictionary; + (instancetype)dictionaryWithCapacity:(NSUInteger)numItems; -- (instancetype)initWithValues:(const BOOL [])values - forKeys:(const int32_t [])keys - count:(NSUInteger)count NS_DESIGNATED_INITIALIZER; +- (instancetype)initWithBools:(const BOOL [])values + forKeys:(const int32_t [])keys + count:(NSUInteger)count NS_DESIGNATED_INITIALIZER; - (instancetype)initWithDictionary:(GPBInt32BoolDictionary *)dictionary; - (instancetype)initWithCapacity:(NSUInteger)numItems; -- (BOOL)valueForKey:(int32_t)key value:(nullable BOOL *)value; +// Returns YES/NO to indicate if the key was found or not, filling in the value +// only when the key was found. +- (BOOL)getBool:(nullable BOOL *)value forKey:(int32_t)key; -- (void)enumerateKeysAndValuesUsingBlock: +- (void)enumerateKeysAndBoolsUsingBlock: (void (^)(int32_t key, BOOL value, BOOL *stop))block; - (void)addEntriesFromDictionary:(GPBInt32BoolDictionary *)otherDictionary; -- (void)setValue:(BOOL)value forKey:(int32_t)key; +- (void)setBool:(BOOL)value forKey:(int32_t)key; -- (void)removeValueForKey:(int32_t)aKey; +- (void)removeBoolForKey:(int32_t)aKey; - (void)removeAll; @end @@ -576,30 +607,32 @@ NS_ASSUME_NONNULL_BEGIN @property(nonatomic, readonly) NSUInteger count; + (instancetype)dictionary; -+ (instancetype)dictionaryWithValue:(float)value ++ (instancetype)dictionaryWithFloat:(float)value forKey:(int32_t)key; -+ (instancetype)dictionaryWithValues:(const float [])values ++ (instancetype)dictionaryWithFloats:(const float [])values forKeys:(const int32_t [])keys count:(NSUInteger)count; + (instancetype)dictionaryWithDictionary:(GPBInt32FloatDictionary *)dictionary; + (instancetype)dictionaryWithCapacity:(NSUInteger)numItems; -- (instancetype)initWithValues:(const float [])values +- (instancetype)initWithFloats:(const float [])values forKeys:(const int32_t [])keys count:(NSUInteger)count NS_DESIGNATED_INITIALIZER; - (instancetype)initWithDictionary:(GPBInt32FloatDictionary *)dictionary; - (instancetype)initWithCapacity:(NSUInteger)numItems; -- (BOOL)valueForKey:(int32_t)key value:(nullable float *)value; +// Returns YES/NO to indicate if the key was found or not, filling in the value +// only when the key was found. +- (BOOL)getFloat:(nullable float *)value forKey:(int32_t)key; -- (void)enumerateKeysAndValuesUsingBlock: +- (void)enumerateKeysAndFloatsUsingBlock: (void (^)(int32_t key, float value, BOOL *stop))block; - (void)addEntriesFromDictionary:(GPBInt32FloatDictionary *)otherDictionary; -- (void)setValue:(float)value forKey:(int32_t)key; +- (void)setFloat:(float)value forKey:(int32_t)key; -- (void)removeValueForKey:(int32_t)aKey; +- (void)removeFloatForKey:(int32_t)aKey; - (void)removeAll; @end @@ -611,30 +644,32 @@ NS_ASSUME_NONNULL_BEGIN @property(nonatomic, readonly) NSUInteger count; + (instancetype)dictionary; -+ (instancetype)dictionaryWithValue:(double)value - forKey:(int32_t)key; -+ (instancetype)dictionaryWithValues:(const double [])values - forKeys:(const int32_t [])keys - count:(NSUInteger)count; ++ (instancetype)dictionaryWithDouble:(double)value + forKey:(int32_t)key; ++ (instancetype)dictionaryWithDoubles:(const double [])values + forKeys:(const int32_t [])keys + count:(NSUInteger)count; + (instancetype)dictionaryWithDictionary:(GPBInt32DoubleDictionary *)dictionary; + (instancetype)dictionaryWithCapacity:(NSUInteger)numItems; -- (instancetype)initWithValues:(const double [])values - forKeys:(const int32_t [])keys - count:(NSUInteger)count NS_DESIGNATED_INITIALIZER; +- (instancetype)initWithDoubles:(const double [])values + forKeys:(const int32_t [])keys + count:(NSUInteger)count NS_DESIGNATED_INITIALIZER; - (instancetype)initWithDictionary:(GPBInt32DoubleDictionary *)dictionary; - (instancetype)initWithCapacity:(NSUInteger)numItems; -- (BOOL)valueForKey:(int32_t)key value:(nullable double *)value; +// Returns YES/NO to indicate if the key was found or not, filling in the value +// only when the key was found. +- (BOOL)getDouble:(nullable double *)value forKey:(int32_t)key; -- (void)enumerateKeysAndValuesUsingBlock: +- (void)enumerateKeysAndDoublesUsingBlock: (void (^)(int32_t key, double value, BOOL *stop))block; - (void)addEntriesFromDictionary:(GPBInt32DoubleDictionary *)otherDictionary; -- (void)setValue:(double)value forKey:(int32_t)key; +- (void)setDouble:(double)value forKey:(int32_t)key; -- (void)removeValueForKey:(int32_t)aKey; +- (void)removeDoubleForKey:(int32_t)aKey; - (void)removeAll; @end @@ -672,15 +707,19 @@ NS_ASSUME_NONNULL_BEGIN // is not a valid enumerator as defined by validationFunc. If the actual value is // desired, use "raw" version of the method. -- (BOOL)valueForKey:(int32_t)key value:(nullable int32_t *)value; +// Returns YES/NO to indicate if the key was found or not, filling in the value +// only when the key was found. +- (BOOL)getEnum:(nullable int32_t *)value forKey:(int32_t)key; -- (void)enumerateKeysAndValuesUsingBlock: +- (void)enumerateKeysAndEnumsUsingBlock: (void (^)(int32_t key, int32_t value, BOOL *stop))block; // These methods bypass the validationFunc to provide access to values that were not // known at the time the binary was compiled. -- (BOOL)valueForKey:(int32_t)key rawValue:(nullable int32_t *)rawValue; +// Returns YES/NO to indicate if the key was found or not, filling in the value +// only when the key was found. +- (BOOL)getRawValue:(nullable int32_t *)rawValue forKey:(int32_t)key; - (void)enumerateKeysAndRawValuesUsingBlock: (void (^)(int32_t key, int32_t rawValue, BOOL *stop))block; @@ -692,7 +731,7 @@ NS_ASSUME_NONNULL_BEGIN // to the default value. Use the rawValue methods below to assign non enumerator // values. -- (void)setValue:(int32_t)value forKey:(int32_t)key; +- (void)setEnum:(int32_t)value forKey:(int32_t)key; // This method bypass the validationFunc to provide setting of values that were not // known at the time the binary was compiled. @@ -700,7 +739,7 @@ NS_ASSUME_NONNULL_BEGIN // No validation applies to these methods. -- (void)removeValueForKey:(int32_t)aKey; +- (void)removeEnumForKey:(int32_t)aKey; - (void)removeAll; @end @@ -747,30 +786,32 @@ NS_ASSUME_NONNULL_BEGIN @property(nonatomic, readonly) NSUInteger count; + (instancetype)dictionary; -+ (instancetype)dictionaryWithValue:(uint32_t)value - forKey:(uint64_t)key; -+ (instancetype)dictionaryWithValues:(const uint32_t [])values - forKeys:(const uint64_t [])keys - count:(NSUInteger)count; ++ (instancetype)dictionaryWithUInt32:(uint32_t)value + forKey:(uint64_t)key; ++ (instancetype)dictionaryWithUInt32s:(const uint32_t [])values + forKeys:(const uint64_t [])keys + count:(NSUInteger)count; + (instancetype)dictionaryWithDictionary:(GPBUInt64UInt32Dictionary *)dictionary; + (instancetype)dictionaryWithCapacity:(NSUInteger)numItems; -- (instancetype)initWithValues:(const uint32_t [])values - forKeys:(const uint64_t [])keys - count:(NSUInteger)count NS_DESIGNATED_INITIALIZER; +- (instancetype)initWithUInt32s:(const uint32_t [])values + forKeys:(const uint64_t [])keys + count:(NSUInteger)count NS_DESIGNATED_INITIALIZER; - (instancetype)initWithDictionary:(GPBUInt64UInt32Dictionary *)dictionary; - (instancetype)initWithCapacity:(NSUInteger)numItems; -- (BOOL)valueForKey:(uint64_t)key value:(nullable uint32_t *)value; +// Returns YES/NO to indicate if the key was found or not, filling in the value +// only when the key was found. +- (BOOL)getUInt32:(nullable uint32_t *)value forKey:(uint64_t)key; -- (void)enumerateKeysAndValuesUsingBlock: +- (void)enumerateKeysAndUInt32sUsingBlock: (void (^)(uint64_t key, uint32_t value, BOOL *stop))block; - (void)addEntriesFromDictionary:(GPBUInt64UInt32Dictionary *)otherDictionary; -- (void)setValue:(uint32_t)value forKey:(uint64_t)key; +- (void)setUInt32:(uint32_t)value forKey:(uint64_t)key; -- (void)removeValueForKey:(uint64_t)aKey; +- (void)removeUInt32ForKey:(uint64_t)aKey; - (void)removeAll; @end @@ -782,30 +823,32 @@ NS_ASSUME_NONNULL_BEGIN @property(nonatomic, readonly) NSUInteger count; + (instancetype)dictionary; -+ (instancetype)dictionaryWithValue:(int32_t)value ++ (instancetype)dictionaryWithInt32:(int32_t)value forKey:(uint64_t)key; -+ (instancetype)dictionaryWithValues:(const int32_t [])values ++ (instancetype)dictionaryWithInt32s:(const int32_t [])values forKeys:(const uint64_t [])keys count:(NSUInteger)count; + (instancetype)dictionaryWithDictionary:(GPBUInt64Int32Dictionary *)dictionary; + (instancetype)dictionaryWithCapacity:(NSUInteger)numItems; -- (instancetype)initWithValues:(const int32_t [])values +- (instancetype)initWithInt32s:(const int32_t [])values forKeys:(const uint64_t [])keys count:(NSUInteger)count NS_DESIGNATED_INITIALIZER; - (instancetype)initWithDictionary:(GPBUInt64Int32Dictionary *)dictionary; - (instancetype)initWithCapacity:(NSUInteger)numItems; -- (BOOL)valueForKey:(uint64_t)key value:(nullable int32_t *)value; +// Returns YES/NO to indicate if the key was found or not, filling in the value +// only when the key was found. +- (BOOL)getInt32:(nullable int32_t *)value forKey:(uint64_t)key; -- (void)enumerateKeysAndValuesUsingBlock: +- (void)enumerateKeysAndInt32sUsingBlock: (void (^)(uint64_t key, int32_t value, BOOL *stop))block; - (void)addEntriesFromDictionary:(GPBUInt64Int32Dictionary *)otherDictionary; -- (void)setValue:(int32_t)value forKey:(uint64_t)key; +- (void)setInt32:(int32_t)value forKey:(uint64_t)key; -- (void)removeValueForKey:(uint64_t)aKey; +- (void)removeInt32ForKey:(uint64_t)aKey; - (void)removeAll; @end @@ -817,30 +860,32 @@ NS_ASSUME_NONNULL_BEGIN @property(nonatomic, readonly) NSUInteger count; + (instancetype)dictionary; -+ (instancetype)dictionaryWithValue:(uint64_t)value - forKey:(uint64_t)key; -+ (instancetype)dictionaryWithValues:(const uint64_t [])values - forKeys:(const uint64_t [])keys - count:(NSUInteger)count; ++ (instancetype)dictionaryWithUInt64:(uint64_t)value + forKey:(uint64_t)key; ++ (instancetype)dictionaryWithUInt64s:(const uint64_t [])values + forKeys:(const uint64_t [])keys + count:(NSUInteger)count; + (instancetype)dictionaryWithDictionary:(GPBUInt64UInt64Dictionary *)dictionary; + (instancetype)dictionaryWithCapacity:(NSUInteger)numItems; -- (instancetype)initWithValues:(const uint64_t [])values - forKeys:(const uint64_t [])keys - count:(NSUInteger)count NS_DESIGNATED_INITIALIZER; +- (instancetype)initWithUInt64s:(const uint64_t [])values + forKeys:(const uint64_t [])keys + count:(NSUInteger)count NS_DESIGNATED_INITIALIZER; - (instancetype)initWithDictionary:(GPBUInt64UInt64Dictionary *)dictionary; - (instancetype)initWithCapacity:(NSUInteger)numItems; -- (BOOL)valueForKey:(uint64_t)key value:(nullable uint64_t *)value; +// Returns YES/NO to indicate if the key was found or not, filling in the value +// only when the key was found. +- (BOOL)getUInt64:(nullable uint64_t *)value forKey:(uint64_t)key; -- (void)enumerateKeysAndValuesUsingBlock: +- (void)enumerateKeysAndUInt64sUsingBlock: (void (^)(uint64_t key, uint64_t value, BOOL *stop))block; - (void)addEntriesFromDictionary:(GPBUInt64UInt64Dictionary *)otherDictionary; -- (void)setValue:(uint64_t)value forKey:(uint64_t)key; +- (void)setUInt64:(uint64_t)value forKey:(uint64_t)key; -- (void)removeValueForKey:(uint64_t)aKey; +- (void)removeUInt64ForKey:(uint64_t)aKey; - (void)removeAll; @end @@ -852,30 +897,32 @@ NS_ASSUME_NONNULL_BEGIN @property(nonatomic, readonly) NSUInteger count; + (instancetype)dictionary; -+ (instancetype)dictionaryWithValue:(int64_t)value ++ (instancetype)dictionaryWithInt64:(int64_t)value forKey:(uint64_t)key; -+ (instancetype)dictionaryWithValues:(const int64_t [])values ++ (instancetype)dictionaryWithInt64s:(const int64_t [])values forKeys:(const uint64_t [])keys count:(NSUInteger)count; + (instancetype)dictionaryWithDictionary:(GPBUInt64Int64Dictionary *)dictionary; + (instancetype)dictionaryWithCapacity:(NSUInteger)numItems; -- (instancetype)initWithValues:(const int64_t [])values +- (instancetype)initWithInt64s:(const int64_t [])values forKeys:(const uint64_t [])keys count:(NSUInteger)count NS_DESIGNATED_INITIALIZER; - (instancetype)initWithDictionary:(GPBUInt64Int64Dictionary *)dictionary; - (instancetype)initWithCapacity:(NSUInteger)numItems; -- (BOOL)valueForKey:(uint64_t)key value:(nullable int64_t *)value; +// Returns YES/NO to indicate if the key was found or not, filling in the value +// only when the key was found. +- (BOOL)getInt64:(nullable int64_t *)value forKey:(uint64_t)key; -- (void)enumerateKeysAndValuesUsingBlock: +- (void)enumerateKeysAndInt64sUsingBlock: (void (^)(uint64_t key, int64_t value, BOOL *stop))block; - (void)addEntriesFromDictionary:(GPBUInt64Int64Dictionary *)otherDictionary; -- (void)setValue:(int64_t)value forKey:(uint64_t)key; +- (void)setInt64:(int64_t)value forKey:(uint64_t)key; -- (void)removeValueForKey:(uint64_t)aKey; +- (void)removeInt64ForKey:(uint64_t)aKey; - (void)removeAll; @end @@ -887,30 +934,32 @@ NS_ASSUME_NONNULL_BEGIN @property(nonatomic, readonly) NSUInteger count; + (instancetype)dictionary; -+ (instancetype)dictionaryWithValue:(BOOL)value - forKey:(uint64_t)key; -+ (instancetype)dictionaryWithValues:(const BOOL [])values - forKeys:(const uint64_t [])keys - count:(NSUInteger)count; ++ (instancetype)dictionaryWithBool:(BOOL)value + forKey:(uint64_t)key; ++ (instancetype)dictionaryWithBools:(const BOOL [])values + forKeys:(const uint64_t [])keys + count:(NSUInteger)count; + (instancetype)dictionaryWithDictionary:(GPBUInt64BoolDictionary *)dictionary; + (instancetype)dictionaryWithCapacity:(NSUInteger)numItems; -- (instancetype)initWithValues:(const BOOL [])values - forKeys:(const uint64_t [])keys - count:(NSUInteger)count NS_DESIGNATED_INITIALIZER; +- (instancetype)initWithBools:(const BOOL [])values + forKeys:(const uint64_t [])keys + count:(NSUInteger)count NS_DESIGNATED_INITIALIZER; - (instancetype)initWithDictionary:(GPBUInt64BoolDictionary *)dictionary; - (instancetype)initWithCapacity:(NSUInteger)numItems; -- (BOOL)valueForKey:(uint64_t)key value:(nullable BOOL *)value; +// Returns YES/NO to indicate if the key was found or not, filling in the value +// only when the key was found. +- (BOOL)getBool:(nullable BOOL *)value forKey:(uint64_t)key; -- (void)enumerateKeysAndValuesUsingBlock: +- (void)enumerateKeysAndBoolsUsingBlock: (void (^)(uint64_t key, BOOL value, BOOL *stop))block; - (void)addEntriesFromDictionary:(GPBUInt64BoolDictionary *)otherDictionary; -- (void)setValue:(BOOL)value forKey:(uint64_t)key; +- (void)setBool:(BOOL)value forKey:(uint64_t)key; -- (void)removeValueForKey:(uint64_t)aKey; +- (void)removeBoolForKey:(uint64_t)aKey; - (void)removeAll; @end @@ -922,30 +971,32 @@ NS_ASSUME_NONNULL_BEGIN @property(nonatomic, readonly) NSUInteger count; + (instancetype)dictionary; -+ (instancetype)dictionaryWithValue:(float)value ++ (instancetype)dictionaryWithFloat:(float)value forKey:(uint64_t)key; -+ (instancetype)dictionaryWithValues:(const float [])values ++ (instancetype)dictionaryWithFloats:(const float [])values forKeys:(const uint64_t [])keys count:(NSUInteger)count; + (instancetype)dictionaryWithDictionary:(GPBUInt64FloatDictionary *)dictionary; + (instancetype)dictionaryWithCapacity:(NSUInteger)numItems; -- (instancetype)initWithValues:(const float [])values +- (instancetype)initWithFloats:(const float [])values forKeys:(const uint64_t [])keys count:(NSUInteger)count NS_DESIGNATED_INITIALIZER; - (instancetype)initWithDictionary:(GPBUInt64FloatDictionary *)dictionary; - (instancetype)initWithCapacity:(NSUInteger)numItems; -- (BOOL)valueForKey:(uint64_t)key value:(nullable float *)value; +// Returns YES/NO to indicate if the key was found or not, filling in the value +// only when the key was found. +- (BOOL)getFloat:(nullable float *)value forKey:(uint64_t)key; -- (void)enumerateKeysAndValuesUsingBlock: +- (void)enumerateKeysAndFloatsUsingBlock: (void (^)(uint64_t key, float value, BOOL *stop))block; - (void)addEntriesFromDictionary:(GPBUInt64FloatDictionary *)otherDictionary; -- (void)setValue:(float)value forKey:(uint64_t)key; +- (void)setFloat:(float)value forKey:(uint64_t)key; -- (void)removeValueForKey:(uint64_t)aKey; +- (void)removeFloatForKey:(uint64_t)aKey; - (void)removeAll; @end @@ -957,30 +1008,32 @@ NS_ASSUME_NONNULL_BEGIN @property(nonatomic, readonly) NSUInteger count; + (instancetype)dictionary; -+ (instancetype)dictionaryWithValue:(double)value - forKey:(uint64_t)key; -+ (instancetype)dictionaryWithValues:(const double [])values - forKeys:(const uint64_t [])keys - count:(NSUInteger)count; ++ (instancetype)dictionaryWithDouble:(double)value + forKey:(uint64_t)key; ++ (instancetype)dictionaryWithDoubles:(const double [])values + forKeys:(const uint64_t [])keys + count:(NSUInteger)count; + (instancetype)dictionaryWithDictionary:(GPBUInt64DoubleDictionary *)dictionary; + (instancetype)dictionaryWithCapacity:(NSUInteger)numItems; -- (instancetype)initWithValues:(const double [])values - forKeys:(const uint64_t [])keys - count:(NSUInteger)count NS_DESIGNATED_INITIALIZER; +- (instancetype)initWithDoubles:(const double [])values + forKeys:(const uint64_t [])keys + count:(NSUInteger)count NS_DESIGNATED_INITIALIZER; - (instancetype)initWithDictionary:(GPBUInt64DoubleDictionary *)dictionary; - (instancetype)initWithCapacity:(NSUInteger)numItems; -- (BOOL)valueForKey:(uint64_t)key value:(nullable double *)value; +// Returns YES/NO to indicate if the key was found or not, filling in the value +// only when the key was found. +- (BOOL)getDouble:(nullable double *)value forKey:(uint64_t)key; -- (void)enumerateKeysAndValuesUsingBlock: +- (void)enumerateKeysAndDoublesUsingBlock: (void (^)(uint64_t key, double value, BOOL *stop))block; - (void)addEntriesFromDictionary:(GPBUInt64DoubleDictionary *)otherDictionary; -- (void)setValue:(double)value forKey:(uint64_t)key; +- (void)setDouble:(double)value forKey:(uint64_t)key; -- (void)removeValueForKey:(uint64_t)aKey; +- (void)removeDoubleForKey:(uint64_t)aKey; - (void)removeAll; @end @@ -1018,15 +1071,19 @@ NS_ASSUME_NONNULL_BEGIN // is not a valid enumerator as defined by validationFunc. If the actual value is // desired, use "raw" version of the method. -- (BOOL)valueForKey:(uint64_t)key value:(nullable int32_t *)value; +// Returns YES/NO to indicate if the key was found or not, filling in the value +// only when the key was found. +- (BOOL)getEnum:(nullable int32_t *)value forKey:(uint64_t)key; -- (void)enumerateKeysAndValuesUsingBlock: +- (void)enumerateKeysAndEnumsUsingBlock: (void (^)(uint64_t key, int32_t value, BOOL *stop))block; // These methods bypass the validationFunc to provide access to values that were not // known at the time the binary was compiled. -- (BOOL)valueForKey:(uint64_t)key rawValue:(nullable int32_t *)rawValue; +// Returns YES/NO to indicate if the key was found or not, filling in the value +// only when the key was found. +- (BOOL)getRawValue:(nullable int32_t *)rawValue forKey:(uint64_t)key; - (void)enumerateKeysAndRawValuesUsingBlock: (void (^)(uint64_t key, int32_t rawValue, BOOL *stop))block; @@ -1038,7 +1095,7 @@ NS_ASSUME_NONNULL_BEGIN // to the default value. Use the rawValue methods below to assign non enumerator // values. -- (void)setValue:(int32_t)value forKey:(uint64_t)key; +- (void)setEnum:(int32_t)value forKey:(uint64_t)key; // This method bypass the validationFunc to provide setting of values that were not // known at the time the binary was compiled. @@ -1046,7 +1103,7 @@ NS_ASSUME_NONNULL_BEGIN // No validation applies to these methods. -- (void)removeValueForKey:(uint64_t)aKey; +- (void)removeEnumForKey:(uint64_t)aKey; - (void)removeAll; @end @@ -1093,30 +1150,32 @@ NS_ASSUME_NONNULL_BEGIN @property(nonatomic, readonly) NSUInteger count; + (instancetype)dictionary; -+ (instancetype)dictionaryWithValue:(uint32_t)value - forKey:(int64_t)key; -+ (instancetype)dictionaryWithValues:(const uint32_t [])values - forKeys:(const int64_t [])keys - count:(NSUInteger)count; ++ (instancetype)dictionaryWithUInt32:(uint32_t)value + forKey:(int64_t)key; ++ (instancetype)dictionaryWithUInt32s:(const uint32_t [])values + forKeys:(const int64_t [])keys + count:(NSUInteger)count; + (instancetype)dictionaryWithDictionary:(GPBInt64UInt32Dictionary *)dictionary; + (instancetype)dictionaryWithCapacity:(NSUInteger)numItems; -- (instancetype)initWithValues:(const uint32_t [])values - forKeys:(const int64_t [])keys - count:(NSUInteger)count NS_DESIGNATED_INITIALIZER; +- (instancetype)initWithUInt32s:(const uint32_t [])values + forKeys:(const int64_t [])keys + count:(NSUInteger)count NS_DESIGNATED_INITIALIZER; - (instancetype)initWithDictionary:(GPBInt64UInt32Dictionary *)dictionary; - (instancetype)initWithCapacity:(NSUInteger)numItems; -- (BOOL)valueForKey:(int64_t)key value:(nullable uint32_t *)value; +// Returns YES/NO to indicate if the key was found or not, filling in the value +// only when the key was found. +- (BOOL)getUInt32:(nullable uint32_t *)value forKey:(int64_t)key; -- (void)enumerateKeysAndValuesUsingBlock: +- (void)enumerateKeysAndUInt32sUsingBlock: (void (^)(int64_t key, uint32_t value, BOOL *stop))block; - (void)addEntriesFromDictionary:(GPBInt64UInt32Dictionary *)otherDictionary; -- (void)setValue:(uint32_t)value forKey:(int64_t)key; +- (void)setUInt32:(uint32_t)value forKey:(int64_t)key; -- (void)removeValueForKey:(int64_t)aKey; +- (void)removeUInt32ForKey:(int64_t)aKey; - (void)removeAll; @end @@ -1128,30 +1187,32 @@ NS_ASSUME_NONNULL_BEGIN @property(nonatomic, readonly) NSUInteger count; + (instancetype)dictionary; -+ (instancetype)dictionaryWithValue:(int32_t)value ++ (instancetype)dictionaryWithInt32:(int32_t)value forKey:(int64_t)key; -+ (instancetype)dictionaryWithValues:(const int32_t [])values ++ (instancetype)dictionaryWithInt32s:(const int32_t [])values forKeys:(const int64_t [])keys count:(NSUInteger)count; + (instancetype)dictionaryWithDictionary:(GPBInt64Int32Dictionary *)dictionary; + (instancetype)dictionaryWithCapacity:(NSUInteger)numItems; -- (instancetype)initWithValues:(const int32_t [])values +- (instancetype)initWithInt32s:(const int32_t [])values forKeys:(const int64_t [])keys count:(NSUInteger)count NS_DESIGNATED_INITIALIZER; - (instancetype)initWithDictionary:(GPBInt64Int32Dictionary *)dictionary; - (instancetype)initWithCapacity:(NSUInteger)numItems; -- (BOOL)valueForKey:(int64_t)key value:(nullable int32_t *)value; +// Returns YES/NO to indicate if the key was found or not, filling in the value +// only when the key was found. +- (BOOL)getInt32:(nullable int32_t *)value forKey:(int64_t)key; -- (void)enumerateKeysAndValuesUsingBlock: +- (void)enumerateKeysAndInt32sUsingBlock: (void (^)(int64_t key, int32_t value, BOOL *stop))block; - (void)addEntriesFromDictionary:(GPBInt64Int32Dictionary *)otherDictionary; -- (void)setValue:(int32_t)value forKey:(int64_t)key; +- (void)setInt32:(int32_t)value forKey:(int64_t)key; -- (void)removeValueForKey:(int64_t)aKey; +- (void)removeInt32ForKey:(int64_t)aKey; - (void)removeAll; @end @@ -1163,30 +1224,32 @@ NS_ASSUME_NONNULL_BEGIN @property(nonatomic, readonly) NSUInteger count; + (instancetype)dictionary; -+ (instancetype)dictionaryWithValue:(uint64_t)value - forKey:(int64_t)key; -+ (instancetype)dictionaryWithValues:(const uint64_t [])values - forKeys:(const int64_t [])keys - count:(NSUInteger)count; ++ (instancetype)dictionaryWithUInt64:(uint64_t)value + forKey:(int64_t)key; ++ (instancetype)dictionaryWithUInt64s:(const uint64_t [])values + forKeys:(const int64_t [])keys + count:(NSUInteger)count; + (instancetype)dictionaryWithDictionary:(GPBInt64UInt64Dictionary *)dictionary; + (instancetype)dictionaryWithCapacity:(NSUInteger)numItems; -- (instancetype)initWithValues:(const uint64_t [])values - forKeys:(const int64_t [])keys - count:(NSUInteger)count NS_DESIGNATED_INITIALIZER; +- (instancetype)initWithUInt64s:(const uint64_t [])values + forKeys:(const int64_t [])keys + count:(NSUInteger)count NS_DESIGNATED_INITIALIZER; - (instancetype)initWithDictionary:(GPBInt64UInt64Dictionary *)dictionary; - (instancetype)initWithCapacity:(NSUInteger)numItems; -- (BOOL)valueForKey:(int64_t)key value:(nullable uint64_t *)value; +// Returns YES/NO to indicate if the key was found or not, filling in the value +// only when the key was found. +- (BOOL)getUInt64:(nullable uint64_t *)value forKey:(int64_t)key; -- (void)enumerateKeysAndValuesUsingBlock: +- (void)enumerateKeysAndUInt64sUsingBlock: (void (^)(int64_t key, uint64_t value, BOOL *stop))block; - (void)addEntriesFromDictionary:(GPBInt64UInt64Dictionary *)otherDictionary; -- (void)setValue:(uint64_t)value forKey:(int64_t)key; +- (void)setUInt64:(uint64_t)value forKey:(int64_t)key; -- (void)removeValueForKey:(int64_t)aKey; +- (void)removeUInt64ForKey:(int64_t)aKey; - (void)removeAll; @end @@ -1198,30 +1261,32 @@ NS_ASSUME_NONNULL_BEGIN @property(nonatomic, readonly) NSUInteger count; + (instancetype)dictionary; -+ (instancetype)dictionaryWithValue:(int64_t)value ++ (instancetype)dictionaryWithInt64:(int64_t)value forKey:(int64_t)key; -+ (instancetype)dictionaryWithValues:(const int64_t [])values ++ (instancetype)dictionaryWithInt64s:(const int64_t [])values forKeys:(const int64_t [])keys count:(NSUInteger)count; + (instancetype)dictionaryWithDictionary:(GPBInt64Int64Dictionary *)dictionary; + (instancetype)dictionaryWithCapacity:(NSUInteger)numItems; -- (instancetype)initWithValues:(const int64_t [])values +- (instancetype)initWithInt64s:(const int64_t [])values forKeys:(const int64_t [])keys count:(NSUInteger)count NS_DESIGNATED_INITIALIZER; - (instancetype)initWithDictionary:(GPBInt64Int64Dictionary *)dictionary; - (instancetype)initWithCapacity:(NSUInteger)numItems; -- (BOOL)valueForKey:(int64_t)key value:(nullable int64_t *)value; +// Returns YES/NO to indicate if the key was found or not, filling in the value +// only when the key was found. +- (BOOL)getInt64:(nullable int64_t *)value forKey:(int64_t)key; -- (void)enumerateKeysAndValuesUsingBlock: +- (void)enumerateKeysAndInt64sUsingBlock: (void (^)(int64_t key, int64_t value, BOOL *stop))block; - (void)addEntriesFromDictionary:(GPBInt64Int64Dictionary *)otherDictionary; -- (void)setValue:(int64_t)value forKey:(int64_t)key; +- (void)setInt64:(int64_t)value forKey:(int64_t)key; -- (void)removeValueForKey:(int64_t)aKey; +- (void)removeInt64ForKey:(int64_t)aKey; - (void)removeAll; @end @@ -1233,30 +1298,32 @@ NS_ASSUME_NONNULL_BEGIN @property(nonatomic, readonly) NSUInteger count; + (instancetype)dictionary; -+ (instancetype)dictionaryWithValue:(BOOL)value - forKey:(int64_t)key; -+ (instancetype)dictionaryWithValues:(const BOOL [])values - forKeys:(const int64_t [])keys - count:(NSUInteger)count; ++ (instancetype)dictionaryWithBool:(BOOL)value + forKey:(int64_t)key; ++ (instancetype)dictionaryWithBools:(const BOOL [])values + forKeys:(const int64_t [])keys + count:(NSUInteger)count; + (instancetype)dictionaryWithDictionary:(GPBInt64BoolDictionary *)dictionary; + (instancetype)dictionaryWithCapacity:(NSUInteger)numItems; -- (instancetype)initWithValues:(const BOOL [])values - forKeys:(const int64_t [])keys - count:(NSUInteger)count NS_DESIGNATED_INITIALIZER; +- (instancetype)initWithBools:(const BOOL [])values + forKeys:(const int64_t [])keys + count:(NSUInteger)count NS_DESIGNATED_INITIALIZER; - (instancetype)initWithDictionary:(GPBInt64BoolDictionary *)dictionary; - (instancetype)initWithCapacity:(NSUInteger)numItems; -- (BOOL)valueForKey:(int64_t)key value:(nullable BOOL *)value; +// Returns YES/NO to indicate if the key was found or not, filling in the value +// only when the key was found. +- (BOOL)getBool:(nullable BOOL *)value forKey:(int64_t)key; -- (void)enumerateKeysAndValuesUsingBlock: +- (void)enumerateKeysAndBoolsUsingBlock: (void (^)(int64_t key, BOOL value, BOOL *stop))block; - (void)addEntriesFromDictionary:(GPBInt64BoolDictionary *)otherDictionary; -- (void)setValue:(BOOL)value forKey:(int64_t)key; +- (void)setBool:(BOOL)value forKey:(int64_t)key; -- (void)removeValueForKey:(int64_t)aKey; +- (void)removeBoolForKey:(int64_t)aKey; - (void)removeAll; @end @@ -1268,30 +1335,32 @@ NS_ASSUME_NONNULL_BEGIN @property(nonatomic, readonly) NSUInteger count; + (instancetype)dictionary; -+ (instancetype)dictionaryWithValue:(float)value ++ (instancetype)dictionaryWithFloat:(float)value forKey:(int64_t)key; -+ (instancetype)dictionaryWithValues:(const float [])values ++ (instancetype)dictionaryWithFloats:(const float [])values forKeys:(const int64_t [])keys count:(NSUInteger)count; + (instancetype)dictionaryWithDictionary:(GPBInt64FloatDictionary *)dictionary; + (instancetype)dictionaryWithCapacity:(NSUInteger)numItems; -- (instancetype)initWithValues:(const float [])values +- (instancetype)initWithFloats:(const float [])values forKeys:(const int64_t [])keys count:(NSUInteger)count NS_DESIGNATED_INITIALIZER; - (instancetype)initWithDictionary:(GPBInt64FloatDictionary *)dictionary; - (instancetype)initWithCapacity:(NSUInteger)numItems; -- (BOOL)valueForKey:(int64_t)key value:(nullable float *)value; +// Returns YES/NO to indicate if the key was found or not, filling in the value +// only when the key was found. +- (BOOL)getFloat:(nullable float *)value forKey:(int64_t)key; -- (void)enumerateKeysAndValuesUsingBlock: +- (void)enumerateKeysAndFloatsUsingBlock: (void (^)(int64_t key, float value, BOOL *stop))block; - (void)addEntriesFromDictionary:(GPBInt64FloatDictionary *)otherDictionary; -- (void)setValue:(float)value forKey:(int64_t)key; +- (void)setFloat:(float)value forKey:(int64_t)key; -- (void)removeValueForKey:(int64_t)aKey; +- (void)removeFloatForKey:(int64_t)aKey; - (void)removeAll; @end @@ -1303,30 +1372,32 @@ NS_ASSUME_NONNULL_BEGIN @property(nonatomic, readonly) NSUInteger count; + (instancetype)dictionary; -+ (instancetype)dictionaryWithValue:(double)value - forKey:(int64_t)key; -+ (instancetype)dictionaryWithValues:(const double [])values - forKeys:(const int64_t [])keys - count:(NSUInteger)count; ++ (instancetype)dictionaryWithDouble:(double)value + forKey:(int64_t)key; ++ (instancetype)dictionaryWithDoubles:(const double [])values + forKeys:(const int64_t [])keys + count:(NSUInteger)count; + (instancetype)dictionaryWithDictionary:(GPBInt64DoubleDictionary *)dictionary; + (instancetype)dictionaryWithCapacity:(NSUInteger)numItems; -- (instancetype)initWithValues:(const double [])values - forKeys:(const int64_t [])keys - count:(NSUInteger)count NS_DESIGNATED_INITIALIZER; +- (instancetype)initWithDoubles:(const double [])values + forKeys:(const int64_t [])keys + count:(NSUInteger)count NS_DESIGNATED_INITIALIZER; - (instancetype)initWithDictionary:(GPBInt64DoubleDictionary *)dictionary; - (instancetype)initWithCapacity:(NSUInteger)numItems; -- (BOOL)valueForKey:(int64_t)key value:(nullable double *)value; +// Returns YES/NO to indicate if the key was found or not, filling in the value +// only when the key was found. +- (BOOL)getDouble:(nullable double *)value forKey:(int64_t)key; -- (void)enumerateKeysAndValuesUsingBlock: +- (void)enumerateKeysAndDoublesUsingBlock: (void (^)(int64_t key, double value, BOOL *stop))block; - (void)addEntriesFromDictionary:(GPBInt64DoubleDictionary *)otherDictionary; -- (void)setValue:(double)value forKey:(int64_t)key; +- (void)setDouble:(double)value forKey:(int64_t)key; -- (void)removeValueForKey:(int64_t)aKey; +- (void)removeDoubleForKey:(int64_t)aKey; - (void)removeAll; @end @@ -1364,15 +1435,19 @@ NS_ASSUME_NONNULL_BEGIN // is not a valid enumerator as defined by validationFunc. If the actual value is // desired, use "raw" version of the method. -- (BOOL)valueForKey:(int64_t)key value:(nullable int32_t *)value; +// Returns YES/NO to indicate if the key was found or not, filling in the value +// only when the key was found. +- (BOOL)getEnum:(nullable int32_t *)value forKey:(int64_t)key; -- (void)enumerateKeysAndValuesUsingBlock: +- (void)enumerateKeysAndEnumsUsingBlock: (void (^)(int64_t key, int32_t value, BOOL *stop))block; // These methods bypass the validationFunc to provide access to values that were not // known at the time the binary was compiled. -- (BOOL)valueForKey:(int64_t)key rawValue:(nullable int32_t *)rawValue; +// Returns YES/NO to indicate if the key was found or not, filling in the value +// only when the key was found. +- (BOOL)getRawValue:(nullable int32_t *)rawValue forKey:(int64_t)key; - (void)enumerateKeysAndRawValuesUsingBlock: (void (^)(int64_t key, int32_t rawValue, BOOL *stop))block; @@ -1384,7 +1459,7 @@ NS_ASSUME_NONNULL_BEGIN // to the default value. Use the rawValue methods below to assign non enumerator // values. -- (void)setValue:(int32_t)value forKey:(int64_t)key; +- (void)setEnum:(int32_t)value forKey:(int64_t)key; // This method bypass the validationFunc to provide setting of values that were not // known at the time the binary was compiled. @@ -1392,7 +1467,7 @@ NS_ASSUME_NONNULL_BEGIN // No validation applies to these methods. -- (void)removeValueForKey:(int64_t)aKey; +- (void)removeEnumForKey:(int64_t)aKey; - (void)removeAll; @end @@ -1439,30 +1514,32 @@ NS_ASSUME_NONNULL_BEGIN @property(nonatomic, readonly) NSUInteger count; + (instancetype)dictionary; -+ (instancetype)dictionaryWithValue:(uint32_t)value - forKey:(BOOL)key; -+ (instancetype)dictionaryWithValues:(const uint32_t [])values - forKeys:(const BOOL [])keys - count:(NSUInteger)count; ++ (instancetype)dictionaryWithUInt32:(uint32_t)value + forKey:(BOOL)key; ++ (instancetype)dictionaryWithUInt32s:(const uint32_t [])values + forKeys:(const BOOL [])keys + count:(NSUInteger)count; + (instancetype)dictionaryWithDictionary:(GPBBoolUInt32Dictionary *)dictionary; + (instancetype)dictionaryWithCapacity:(NSUInteger)numItems; -- (instancetype)initWithValues:(const uint32_t [])values - forKeys:(const BOOL [])keys - count:(NSUInteger)count NS_DESIGNATED_INITIALIZER; +- (instancetype)initWithUInt32s:(const uint32_t [])values + forKeys:(const BOOL [])keys + count:(NSUInteger)count NS_DESIGNATED_INITIALIZER; - (instancetype)initWithDictionary:(GPBBoolUInt32Dictionary *)dictionary; - (instancetype)initWithCapacity:(NSUInteger)numItems; -- (BOOL)valueForKey:(BOOL)key value:(nullable uint32_t *)value; +// Returns YES/NO to indicate if the key was found or not, filling in the value +// only when the key was found. +- (BOOL)getUInt32:(nullable uint32_t *)value forKey:(BOOL)key; -- (void)enumerateKeysAndValuesUsingBlock: +- (void)enumerateKeysAndUInt32sUsingBlock: (void (^)(BOOL key, uint32_t value, BOOL *stop))block; - (void)addEntriesFromDictionary:(GPBBoolUInt32Dictionary *)otherDictionary; -- (void)setValue:(uint32_t)value forKey:(BOOL)key; +- (void)setUInt32:(uint32_t)value forKey:(BOOL)key; -- (void)removeValueForKey:(BOOL)aKey; +- (void)removeUInt32ForKey:(BOOL)aKey; - (void)removeAll; @end @@ -1474,30 +1551,32 @@ NS_ASSUME_NONNULL_BEGIN @property(nonatomic, readonly) NSUInteger count; + (instancetype)dictionary; -+ (instancetype)dictionaryWithValue:(int32_t)value ++ (instancetype)dictionaryWithInt32:(int32_t)value forKey:(BOOL)key; -+ (instancetype)dictionaryWithValues:(const int32_t [])values ++ (instancetype)dictionaryWithInt32s:(const int32_t [])values forKeys:(const BOOL [])keys count:(NSUInteger)count; + (instancetype)dictionaryWithDictionary:(GPBBoolInt32Dictionary *)dictionary; + (instancetype)dictionaryWithCapacity:(NSUInteger)numItems; -- (instancetype)initWithValues:(const int32_t [])values +- (instancetype)initWithInt32s:(const int32_t [])values forKeys:(const BOOL [])keys count:(NSUInteger)count NS_DESIGNATED_INITIALIZER; - (instancetype)initWithDictionary:(GPBBoolInt32Dictionary *)dictionary; - (instancetype)initWithCapacity:(NSUInteger)numItems; -- (BOOL)valueForKey:(BOOL)key value:(nullable int32_t *)value; +// Returns YES/NO to indicate if the key was found or not, filling in the value +// only when the key was found. +- (BOOL)getInt32:(nullable int32_t *)value forKey:(BOOL)key; -- (void)enumerateKeysAndValuesUsingBlock: +- (void)enumerateKeysAndInt32sUsingBlock: (void (^)(BOOL key, int32_t value, BOOL *stop))block; - (void)addEntriesFromDictionary:(GPBBoolInt32Dictionary *)otherDictionary; -- (void)setValue:(int32_t)value forKey:(BOOL)key; +- (void)setInt32:(int32_t)value forKey:(BOOL)key; -- (void)removeValueForKey:(BOOL)aKey; +- (void)removeInt32ForKey:(BOOL)aKey; - (void)removeAll; @end @@ -1509,30 +1588,32 @@ NS_ASSUME_NONNULL_BEGIN @property(nonatomic, readonly) NSUInteger count; + (instancetype)dictionary; -+ (instancetype)dictionaryWithValue:(uint64_t)value - forKey:(BOOL)key; -+ (instancetype)dictionaryWithValues:(const uint64_t [])values - forKeys:(const BOOL [])keys - count:(NSUInteger)count; ++ (instancetype)dictionaryWithUInt64:(uint64_t)value + forKey:(BOOL)key; ++ (instancetype)dictionaryWithUInt64s:(const uint64_t [])values + forKeys:(const BOOL [])keys + count:(NSUInteger)count; + (instancetype)dictionaryWithDictionary:(GPBBoolUInt64Dictionary *)dictionary; + (instancetype)dictionaryWithCapacity:(NSUInteger)numItems; -- (instancetype)initWithValues:(const uint64_t [])values - forKeys:(const BOOL [])keys - count:(NSUInteger)count NS_DESIGNATED_INITIALIZER; +- (instancetype)initWithUInt64s:(const uint64_t [])values + forKeys:(const BOOL [])keys + count:(NSUInteger)count NS_DESIGNATED_INITIALIZER; - (instancetype)initWithDictionary:(GPBBoolUInt64Dictionary *)dictionary; - (instancetype)initWithCapacity:(NSUInteger)numItems; -- (BOOL)valueForKey:(BOOL)key value:(nullable uint64_t *)value; +// Returns YES/NO to indicate if the key was found or not, filling in the value +// only when the key was found. +- (BOOL)getUInt64:(nullable uint64_t *)value forKey:(BOOL)key; -- (void)enumerateKeysAndValuesUsingBlock: +- (void)enumerateKeysAndUInt64sUsingBlock: (void (^)(BOOL key, uint64_t value, BOOL *stop))block; - (void)addEntriesFromDictionary:(GPBBoolUInt64Dictionary *)otherDictionary; -- (void)setValue:(uint64_t)value forKey:(BOOL)key; +- (void)setUInt64:(uint64_t)value forKey:(BOOL)key; -- (void)removeValueForKey:(BOOL)aKey; +- (void)removeUInt64ForKey:(BOOL)aKey; - (void)removeAll; @end @@ -1544,30 +1625,32 @@ NS_ASSUME_NONNULL_BEGIN @property(nonatomic, readonly) NSUInteger count; + (instancetype)dictionary; -+ (instancetype)dictionaryWithValue:(int64_t)value ++ (instancetype)dictionaryWithInt64:(int64_t)value forKey:(BOOL)key; -+ (instancetype)dictionaryWithValues:(const int64_t [])values ++ (instancetype)dictionaryWithInt64s:(const int64_t [])values forKeys:(const BOOL [])keys count:(NSUInteger)count; + (instancetype)dictionaryWithDictionary:(GPBBoolInt64Dictionary *)dictionary; + (instancetype)dictionaryWithCapacity:(NSUInteger)numItems; -- (instancetype)initWithValues:(const int64_t [])values +- (instancetype)initWithInt64s:(const int64_t [])values forKeys:(const BOOL [])keys count:(NSUInteger)count NS_DESIGNATED_INITIALIZER; - (instancetype)initWithDictionary:(GPBBoolInt64Dictionary *)dictionary; - (instancetype)initWithCapacity:(NSUInteger)numItems; -- (BOOL)valueForKey:(BOOL)key value:(nullable int64_t *)value; +// Returns YES/NO to indicate if the key was found or not, filling in the value +// only when the key was found. +- (BOOL)getInt64:(nullable int64_t *)value forKey:(BOOL)key; -- (void)enumerateKeysAndValuesUsingBlock: +- (void)enumerateKeysAndInt64sUsingBlock: (void (^)(BOOL key, int64_t value, BOOL *stop))block; - (void)addEntriesFromDictionary:(GPBBoolInt64Dictionary *)otherDictionary; -- (void)setValue:(int64_t)value forKey:(BOOL)key; +- (void)setInt64:(int64_t)value forKey:(BOOL)key; -- (void)removeValueForKey:(BOOL)aKey; +- (void)removeInt64ForKey:(BOOL)aKey; - (void)removeAll; @end @@ -1579,30 +1662,32 @@ NS_ASSUME_NONNULL_BEGIN @property(nonatomic, readonly) NSUInteger count; + (instancetype)dictionary; -+ (instancetype)dictionaryWithValue:(BOOL)value - forKey:(BOOL)key; -+ (instancetype)dictionaryWithValues:(const BOOL [])values - forKeys:(const BOOL [])keys - count:(NSUInteger)count; ++ (instancetype)dictionaryWithBool:(BOOL)value + forKey:(BOOL)key; ++ (instancetype)dictionaryWithBools:(const BOOL [])values + forKeys:(const BOOL [])keys + count:(NSUInteger)count; + (instancetype)dictionaryWithDictionary:(GPBBoolBoolDictionary *)dictionary; + (instancetype)dictionaryWithCapacity:(NSUInteger)numItems; -- (instancetype)initWithValues:(const BOOL [])values - forKeys:(const BOOL [])keys - count:(NSUInteger)count NS_DESIGNATED_INITIALIZER; +- (instancetype)initWithBools:(const BOOL [])values + forKeys:(const BOOL [])keys + count:(NSUInteger)count NS_DESIGNATED_INITIALIZER; - (instancetype)initWithDictionary:(GPBBoolBoolDictionary *)dictionary; - (instancetype)initWithCapacity:(NSUInteger)numItems; -- (BOOL)valueForKey:(BOOL)key value:(nullable BOOL *)value; +// Returns YES/NO to indicate if the key was found or not, filling in the value +// only when the key was found. +- (BOOL)getBool:(nullable BOOL *)value forKey:(BOOL)key; -- (void)enumerateKeysAndValuesUsingBlock: +- (void)enumerateKeysAndBoolsUsingBlock: (void (^)(BOOL key, BOOL value, BOOL *stop))block; - (void)addEntriesFromDictionary:(GPBBoolBoolDictionary *)otherDictionary; -- (void)setValue:(BOOL)value forKey:(BOOL)key; +- (void)setBool:(BOOL)value forKey:(BOOL)key; -- (void)removeValueForKey:(BOOL)aKey; +- (void)removeBoolForKey:(BOOL)aKey; - (void)removeAll; @end @@ -1614,30 +1699,32 @@ NS_ASSUME_NONNULL_BEGIN @property(nonatomic, readonly) NSUInteger count; + (instancetype)dictionary; -+ (instancetype)dictionaryWithValue:(float)value ++ (instancetype)dictionaryWithFloat:(float)value forKey:(BOOL)key; -+ (instancetype)dictionaryWithValues:(const float [])values ++ (instancetype)dictionaryWithFloats:(const float [])values forKeys:(const BOOL [])keys count:(NSUInteger)count; + (instancetype)dictionaryWithDictionary:(GPBBoolFloatDictionary *)dictionary; + (instancetype)dictionaryWithCapacity:(NSUInteger)numItems; -- (instancetype)initWithValues:(const float [])values +- (instancetype)initWithFloats:(const float [])values forKeys:(const BOOL [])keys count:(NSUInteger)count NS_DESIGNATED_INITIALIZER; - (instancetype)initWithDictionary:(GPBBoolFloatDictionary *)dictionary; - (instancetype)initWithCapacity:(NSUInteger)numItems; -- (BOOL)valueForKey:(BOOL)key value:(nullable float *)value; +// Returns YES/NO to indicate if the key was found or not, filling in the value +// only when the key was found. +- (BOOL)getFloat:(nullable float *)value forKey:(BOOL)key; -- (void)enumerateKeysAndValuesUsingBlock: +- (void)enumerateKeysAndFloatsUsingBlock: (void (^)(BOOL key, float value, BOOL *stop))block; - (void)addEntriesFromDictionary:(GPBBoolFloatDictionary *)otherDictionary; -- (void)setValue:(float)value forKey:(BOOL)key; +- (void)setFloat:(float)value forKey:(BOOL)key; -- (void)removeValueForKey:(BOOL)aKey; +- (void)removeFloatForKey:(BOOL)aKey; - (void)removeAll; @end @@ -1649,30 +1736,32 @@ NS_ASSUME_NONNULL_BEGIN @property(nonatomic, readonly) NSUInteger count; + (instancetype)dictionary; -+ (instancetype)dictionaryWithValue:(double)value - forKey:(BOOL)key; -+ (instancetype)dictionaryWithValues:(const double [])values - forKeys:(const BOOL [])keys - count:(NSUInteger)count; ++ (instancetype)dictionaryWithDouble:(double)value + forKey:(BOOL)key; ++ (instancetype)dictionaryWithDoubles:(const double [])values + forKeys:(const BOOL [])keys + count:(NSUInteger)count; + (instancetype)dictionaryWithDictionary:(GPBBoolDoubleDictionary *)dictionary; + (instancetype)dictionaryWithCapacity:(NSUInteger)numItems; -- (instancetype)initWithValues:(const double [])values - forKeys:(const BOOL [])keys - count:(NSUInteger)count NS_DESIGNATED_INITIALIZER; +- (instancetype)initWithDoubles:(const double [])values + forKeys:(const BOOL [])keys + count:(NSUInteger)count NS_DESIGNATED_INITIALIZER; - (instancetype)initWithDictionary:(GPBBoolDoubleDictionary *)dictionary; - (instancetype)initWithCapacity:(NSUInteger)numItems; -- (BOOL)valueForKey:(BOOL)key value:(nullable double *)value; +// Returns YES/NO to indicate if the key was found or not, filling in the value +// only when the key was found. +- (BOOL)getDouble:(nullable double *)value forKey:(BOOL)key; -- (void)enumerateKeysAndValuesUsingBlock: +- (void)enumerateKeysAndDoublesUsingBlock: (void (^)(BOOL key, double value, BOOL *stop))block; - (void)addEntriesFromDictionary:(GPBBoolDoubleDictionary *)otherDictionary; -- (void)setValue:(double)value forKey:(BOOL)key; +- (void)setDouble:(double)value forKey:(BOOL)key; -- (void)removeValueForKey:(BOOL)aKey; +- (void)removeDoubleForKey:(BOOL)aKey; - (void)removeAll; @end @@ -1710,15 +1799,19 @@ NS_ASSUME_NONNULL_BEGIN // is not a valid enumerator as defined by validationFunc. If the actual value is // desired, use "raw" version of the method. -- (BOOL)valueForKey:(BOOL)key value:(nullable int32_t *)value; +// Returns YES/NO to indicate if the key was found or not, filling in the value +// only when the key was found. +- (BOOL)getEnum:(nullable int32_t *)value forKey:(BOOL)key; -- (void)enumerateKeysAndValuesUsingBlock: +- (void)enumerateKeysAndEnumsUsingBlock: (void (^)(BOOL key, int32_t value, BOOL *stop))block; // These methods bypass the validationFunc to provide access to values that were not // known at the time the binary was compiled. -- (BOOL)valueForKey:(BOOL)key rawValue:(nullable int32_t *)rawValue; +// Returns YES/NO to indicate if the key was found or not, filling in the value +// only when the key was found. +- (BOOL)getRawValue:(nullable int32_t *)rawValue forKey:(BOOL)key; - (void)enumerateKeysAndRawValuesUsingBlock: (void (^)(BOOL key, int32_t rawValue, BOOL *stop))block; @@ -1730,7 +1823,7 @@ NS_ASSUME_NONNULL_BEGIN // to the default value. Use the rawValue methods below to assign non enumerator // values. -- (void)setValue:(int32_t)value forKey:(BOOL)key; +- (void)setEnum:(int32_t)value forKey:(BOOL)key; // This method bypass the validationFunc to provide setting of values that were not // known at the time the binary was compiled. @@ -1738,7 +1831,7 @@ NS_ASSUME_NONNULL_BEGIN // No validation applies to these methods. -- (void)removeValueForKey:(BOOL)aKey; +- (void)removeEnumForKey:(BOOL)aKey; - (void)removeAll; @end @@ -1785,30 +1878,32 @@ NS_ASSUME_NONNULL_BEGIN @property(nonatomic, readonly) NSUInteger count; + (instancetype)dictionary; -+ (instancetype)dictionaryWithValue:(uint32_t)value - forKey:(NSString *)key; -+ (instancetype)dictionaryWithValues:(const uint32_t [])values - forKeys:(const NSString * GPB_UNSAFE_UNRETAINED [])keys - count:(NSUInteger)count; ++ (instancetype)dictionaryWithUInt32:(uint32_t)value + forKey:(NSString *)key; ++ (instancetype)dictionaryWithUInt32s:(const uint32_t [])values + forKeys:(const NSString * GPB_UNSAFE_UNRETAINED [])keys + count:(NSUInteger)count; + (instancetype)dictionaryWithDictionary:(GPBStringUInt32Dictionary *)dictionary; + (instancetype)dictionaryWithCapacity:(NSUInteger)numItems; -- (instancetype)initWithValues:(const uint32_t [])values - forKeys:(const NSString * GPB_UNSAFE_UNRETAINED [])keys - count:(NSUInteger)count NS_DESIGNATED_INITIALIZER; +- (instancetype)initWithUInt32s:(const uint32_t [])values + forKeys:(const NSString * GPB_UNSAFE_UNRETAINED [])keys + count:(NSUInteger)count NS_DESIGNATED_INITIALIZER; - (instancetype)initWithDictionary:(GPBStringUInt32Dictionary *)dictionary; - (instancetype)initWithCapacity:(NSUInteger)numItems; -- (BOOL)valueForKey:(NSString *)key value:(nullable uint32_t *)value; +// Returns YES/NO to indicate if the key was found or not, filling in the value +// only when the key was found. +- (BOOL)getUInt32:(nullable uint32_t *)value forKey:(NSString *)key; -- (void)enumerateKeysAndValuesUsingBlock: +- (void)enumerateKeysAndUInt32sUsingBlock: (void (^)(NSString *key, uint32_t value, BOOL *stop))block; - (void)addEntriesFromDictionary:(GPBStringUInt32Dictionary *)otherDictionary; -- (void)setValue:(uint32_t)value forKey:(NSString *)key; +- (void)setUInt32:(uint32_t)value forKey:(NSString *)key; -- (void)removeValueForKey:(NSString *)aKey; +- (void)removeUInt32ForKey:(NSString *)aKey; - (void)removeAll; @end @@ -1820,30 +1915,32 @@ NS_ASSUME_NONNULL_BEGIN @property(nonatomic, readonly) NSUInteger count; + (instancetype)dictionary; -+ (instancetype)dictionaryWithValue:(int32_t)value ++ (instancetype)dictionaryWithInt32:(int32_t)value forKey:(NSString *)key; -+ (instancetype)dictionaryWithValues:(const int32_t [])values ++ (instancetype)dictionaryWithInt32s:(const int32_t [])values forKeys:(const NSString * GPB_UNSAFE_UNRETAINED [])keys count:(NSUInteger)count; + (instancetype)dictionaryWithDictionary:(GPBStringInt32Dictionary *)dictionary; + (instancetype)dictionaryWithCapacity:(NSUInteger)numItems; -- (instancetype)initWithValues:(const int32_t [])values +- (instancetype)initWithInt32s:(const int32_t [])values forKeys:(const NSString * GPB_UNSAFE_UNRETAINED [])keys count:(NSUInteger)count NS_DESIGNATED_INITIALIZER; - (instancetype)initWithDictionary:(GPBStringInt32Dictionary *)dictionary; - (instancetype)initWithCapacity:(NSUInteger)numItems; -- (BOOL)valueForKey:(NSString *)key value:(nullable int32_t *)value; +// Returns YES/NO to indicate if the key was found or not, filling in the value +// only when the key was found. +- (BOOL)getInt32:(nullable int32_t *)value forKey:(NSString *)key; -- (void)enumerateKeysAndValuesUsingBlock: +- (void)enumerateKeysAndInt32sUsingBlock: (void (^)(NSString *key, int32_t value, BOOL *stop))block; - (void)addEntriesFromDictionary:(GPBStringInt32Dictionary *)otherDictionary; -- (void)setValue:(int32_t)value forKey:(NSString *)key; +- (void)setInt32:(int32_t)value forKey:(NSString *)key; -- (void)removeValueForKey:(NSString *)aKey; +- (void)removeInt32ForKey:(NSString *)aKey; - (void)removeAll; @end @@ -1855,30 +1952,32 @@ NS_ASSUME_NONNULL_BEGIN @property(nonatomic, readonly) NSUInteger count; + (instancetype)dictionary; -+ (instancetype)dictionaryWithValue:(uint64_t)value - forKey:(NSString *)key; -+ (instancetype)dictionaryWithValues:(const uint64_t [])values - forKeys:(const NSString * GPB_UNSAFE_UNRETAINED [])keys - count:(NSUInteger)count; ++ (instancetype)dictionaryWithUInt64:(uint64_t)value + forKey:(NSString *)key; ++ (instancetype)dictionaryWithUInt64s:(const uint64_t [])values + forKeys:(const NSString * GPB_UNSAFE_UNRETAINED [])keys + count:(NSUInteger)count; + (instancetype)dictionaryWithDictionary:(GPBStringUInt64Dictionary *)dictionary; + (instancetype)dictionaryWithCapacity:(NSUInteger)numItems; -- (instancetype)initWithValues:(const uint64_t [])values - forKeys:(const NSString * GPB_UNSAFE_UNRETAINED [])keys - count:(NSUInteger)count NS_DESIGNATED_INITIALIZER; +- (instancetype)initWithUInt64s:(const uint64_t [])values + forKeys:(const NSString * GPB_UNSAFE_UNRETAINED [])keys + count:(NSUInteger)count NS_DESIGNATED_INITIALIZER; - (instancetype)initWithDictionary:(GPBStringUInt64Dictionary *)dictionary; - (instancetype)initWithCapacity:(NSUInteger)numItems; -- (BOOL)valueForKey:(NSString *)key value:(nullable uint64_t *)value; +// Returns YES/NO to indicate if the key was found or not, filling in the value +// only when the key was found. +- (BOOL)getUInt64:(nullable uint64_t *)value forKey:(NSString *)key; -- (void)enumerateKeysAndValuesUsingBlock: +- (void)enumerateKeysAndUInt64sUsingBlock: (void (^)(NSString *key, uint64_t value, BOOL *stop))block; - (void)addEntriesFromDictionary:(GPBStringUInt64Dictionary *)otherDictionary; -- (void)setValue:(uint64_t)value forKey:(NSString *)key; +- (void)setUInt64:(uint64_t)value forKey:(NSString *)key; -- (void)removeValueForKey:(NSString *)aKey; +- (void)removeUInt64ForKey:(NSString *)aKey; - (void)removeAll; @end @@ -1890,30 +1989,32 @@ NS_ASSUME_NONNULL_BEGIN @property(nonatomic, readonly) NSUInteger count; + (instancetype)dictionary; -+ (instancetype)dictionaryWithValue:(int64_t)value ++ (instancetype)dictionaryWithInt64:(int64_t)value forKey:(NSString *)key; -+ (instancetype)dictionaryWithValues:(const int64_t [])values ++ (instancetype)dictionaryWithInt64s:(const int64_t [])values forKeys:(const NSString * GPB_UNSAFE_UNRETAINED [])keys count:(NSUInteger)count; + (instancetype)dictionaryWithDictionary:(GPBStringInt64Dictionary *)dictionary; + (instancetype)dictionaryWithCapacity:(NSUInteger)numItems; -- (instancetype)initWithValues:(const int64_t [])values +- (instancetype)initWithInt64s:(const int64_t [])values forKeys:(const NSString * GPB_UNSAFE_UNRETAINED [])keys count:(NSUInteger)count NS_DESIGNATED_INITIALIZER; - (instancetype)initWithDictionary:(GPBStringInt64Dictionary *)dictionary; - (instancetype)initWithCapacity:(NSUInteger)numItems; -- (BOOL)valueForKey:(NSString *)key value:(nullable int64_t *)value; +// Returns YES/NO to indicate if the key was found or not, filling in the value +// only when the key was found. +- (BOOL)getInt64:(nullable int64_t *)value forKey:(NSString *)key; -- (void)enumerateKeysAndValuesUsingBlock: +- (void)enumerateKeysAndInt64sUsingBlock: (void (^)(NSString *key, int64_t value, BOOL *stop))block; - (void)addEntriesFromDictionary:(GPBStringInt64Dictionary *)otherDictionary; -- (void)setValue:(int64_t)value forKey:(NSString *)key; +- (void)setInt64:(int64_t)value forKey:(NSString *)key; -- (void)removeValueForKey:(NSString *)aKey; +- (void)removeInt64ForKey:(NSString *)aKey; - (void)removeAll; @end @@ -1925,30 +2026,32 @@ NS_ASSUME_NONNULL_BEGIN @property(nonatomic, readonly) NSUInteger count; + (instancetype)dictionary; -+ (instancetype)dictionaryWithValue:(BOOL)value - forKey:(NSString *)key; -+ (instancetype)dictionaryWithValues:(const BOOL [])values - forKeys:(const NSString * GPB_UNSAFE_UNRETAINED [])keys - count:(NSUInteger)count; ++ (instancetype)dictionaryWithBool:(BOOL)value + forKey:(NSString *)key; ++ (instancetype)dictionaryWithBools:(const BOOL [])values + forKeys:(const NSString * GPB_UNSAFE_UNRETAINED [])keys + count:(NSUInteger)count; + (instancetype)dictionaryWithDictionary:(GPBStringBoolDictionary *)dictionary; + (instancetype)dictionaryWithCapacity:(NSUInteger)numItems; -- (instancetype)initWithValues:(const BOOL [])values - forKeys:(const NSString * GPB_UNSAFE_UNRETAINED [])keys - count:(NSUInteger)count NS_DESIGNATED_INITIALIZER; +- (instancetype)initWithBools:(const BOOL [])values + forKeys:(const NSString * GPB_UNSAFE_UNRETAINED [])keys + count:(NSUInteger)count NS_DESIGNATED_INITIALIZER; - (instancetype)initWithDictionary:(GPBStringBoolDictionary *)dictionary; - (instancetype)initWithCapacity:(NSUInteger)numItems; -- (BOOL)valueForKey:(NSString *)key value:(nullable BOOL *)value; +// Returns YES/NO to indicate if the key was found or not, filling in the value +// only when the key was found. +- (BOOL)getBool:(nullable BOOL *)value forKey:(NSString *)key; -- (void)enumerateKeysAndValuesUsingBlock: +- (void)enumerateKeysAndBoolsUsingBlock: (void (^)(NSString *key, BOOL value, BOOL *stop))block; - (void)addEntriesFromDictionary:(GPBStringBoolDictionary *)otherDictionary; -- (void)setValue:(BOOL)value forKey:(NSString *)key; +- (void)setBool:(BOOL)value forKey:(NSString *)key; -- (void)removeValueForKey:(NSString *)aKey; +- (void)removeBoolForKey:(NSString *)aKey; - (void)removeAll; @end @@ -1960,30 +2063,32 @@ NS_ASSUME_NONNULL_BEGIN @property(nonatomic, readonly) NSUInteger count; + (instancetype)dictionary; -+ (instancetype)dictionaryWithValue:(float)value ++ (instancetype)dictionaryWithFloat:(float)value forKey:(NSString *)key; -+ (instancetype)dictionaryWithValues:(const float [])values ++ (instancetype)dictionaryWithFloats:(const float [])values forKeys:(const NSString * GPB_UNSAFE_UNRETAINED [])keys count:(NSUInteger)count; + (instancetype)dictionaryWithDictionary:(GPBStringFloatDictionary *)dictionary; + (instancetype)dictionaryWithCapacity:(NSUInteger)numItems; -- (instancetype)initWithValues:(const float [])values +- (instancetype)initWithFloats:(const float [])values forKeys:(const NSString * GPB_UNSAFE_UNRETAINED [])keys count:(NSUInteger)count NS_DESIGNATED_INITIALIZER; - (instancetype)initWithDictionary:(GPBStringFloatDictionary *)dictionary; - (instancetype)initWithCapacity:(NSUInteger)numItems; -- (BOOL)valueForKey:(NSString *)key value:(nullable float *)value; +// Returns YES/NO to indicate if the key was found or not, filling in the value +// only when the key was found. +- (BOOL)getFloat:(nullable float *)value forKey:(NSString *)key; -- (void)enumerateKeysAndValuesUsingBlock: +- (void)enumerateKeysAndFloatsUsingBlock: (void (^)(NSString *key, float value, BOOL *stop))block; - (void)addEntriesFromDictionary:(GPBStringFloatDictionary *)otherDictionary; -- (void)setValue:(float)value forKey:(NSString *)key; +- (void)setFloat:(float)value forKey:(NSString *)key; -- (void)removeValueForKey:(NSString *)aKey; +- (void)removeFloatForKey:(NSString *)aKey; - (void)removeAll; @end @@ -1995,30 +2100,32 @@ NS_ASSUME_NONNULL_BEGIN @property(nonatomic, readonly) NSUInteger count; + (instancetype)dictionary; -+ (instancetype)dictionaryWithValue:(double)value - forKey:(NSString *)key; -+ (instancetype)dictionaryWithValues:(const double [])values - forKeys:(const NSString * GPB_UNSAFE_UNRETAINED [])keys - count:(NSUInteger)count; ++ (instancetype)dictionaryWithDouble:(double)value + forKey:(NSString *)key; ++ (instancetype)dictionaryWithDoubles:(const double [])values + forKeys:(const NSString * GPB_UNSAFE_UNRETAINED [])keys + count:(NSUInteger)count; + (instancetype)dictionaryWithDictionary:(GPBStringDoubleDictionary *)dictionary; + (instancetype)dictionaryWithCapacity:(NSUInteger)numItems; -- (instancetype)initWithValues:(const double [])values - forKeys:(const NSString * GPB_UNSAFE_UNRETAINED [])keys - count:(NSUInteger)count NS_DESIGNATED_INITIALIZER; +- (instancetype)initWithDoubles:(const double [])values + forKeys:(const NSString * GPB_UNSAFE_UNRETAINED [])keys + count:(NSUInteger)count NS_DESIGNATED_INITIALIZER; - (instancetype)initWithDictionary:(GPBStringDoubleDictionary *)dictionary; - (instancetype)initWithCapacity:(NSUInteger)numItems; -- (BOOL)valueForKey:(NSString *)key value:(nullable double *)value; +// Returns YES/NO to indicate if the key was found or not, filling in the value +// only when the key was found. +- (BOOL)getDouble:(nullable double *)value forKey:(NSString *)key; -- (void)enumerateKeysAndValuesUsingBlock: +- (void)enumerateKeysAndDoublesUsingBlock: (void (^)(NSString *key, double value, BOOL *stop))block; - (void)addEntriesFromDictionary:(GPBStringDoubleDictionary *)otherDictionary; -- (void)setValue:(double)value forKey:(NSString *)key; +- (void)setDouble:(double)value forKey:(NSString *)key; -- (void)removeValueForKey:(NSString *)aKey; +- (void)removeDoubleForKey:(NSString *)aKey; - (void)removeAll; @end @@ -2056,15 +2163,19 @@ NS_ASSUME_NONNULL_BEGIN // is not a valid enumerator as defined by validationFunc. If the actual value is // desired, use "raw" version of the method. -- (BOOL)valueForKey:(NSString *)key value:(nullable int32_t *)value; +// Returns YES/NO to indicate if the key was found or not, filling in the value +// only when the key was found. +- (BOOL)getEnum:(nullable int32_t *)value forKey:(NSString *)key; -- (void)enumerateKeysAndValuesUsingBlock: +- (void)enumerateKeysAndEnumsUsingBlock: (void (^)(NSString *key, int32_t value, BOOL *stop))block; // These methods bypass the validationFunc to provide access to values that were not // known at the time the binary was compiled. -- (BOOL)valueForKey:(NSString *)key rawValue:(nullable int32_t *)rawValue; +// Returns YES/NO to indicate if the key was found or not, filling in the value +// only when the key was found. +- (BOOL)getRawValue:(nullable int32_t *)rawValue forKey:(NSString *)key; - (void)enumerateKeysAndRawValuesUsingBlock: (void (^)(NSString *key, int32_t rawValue, BOOL *stop))block; @@ -2076,7 +2187,7 @@ NS_ASSUME_NONNULL_BEGIN // to the default value. Use the rawValue methods below to assign non enumerator // values. -- (void)setValue:(int32_t)value forKey:(NSString *)key; +- (void)setEnum:(int32_t)value forKey:(NSString *)key; // This method bypass the validationFunc to provide setting of values that were not // known at the time the binary was compiled. @@ -2084,15 +2195,13 @@ NS_ASSUME_NONNULL_BEGIN // No validation applies to these methods. -- (void)removeValueForKey:(NSString *)aKey; +- (void)removeEnumForKey:(NSString *)aKey; - (void)removeAll; @end //%PDDM-EXPAND-END DECLARE_DICTIONARIES() -#pragma clang diagnostic pop - NS_ASSUME_NONNULL_END //%PDDM-DEFINE DECLARE_DICTIONARIES() @@ -2115,15 +2224,17 @@ NS_ASSUME_NONNULL_END //%DICTIONARY_KEY_TO_POD_INTERFACE(KEY_NAME, KEY_TYPE, KisP, KHELPER, Double, double) //%DICTIONARY_KEY_TO_ENUM_INTERFACE(KEY_NAME, KEY_TYPE, KisP, KHELPER, Enum, int32_t) //%PDDM-DEFINE DICTIONARY_KEY_TO_POD_INTERFACE(KEY_NAME, KEY_TYPE, KisP, KHELPER, VALUE_NAME, VALUE_TYPE) -//%DICTIONARY_COMMON_INTERFACE(KEY_NAME, KEY_TYPE, KisP, KHELPER, VALUE_NAME, VALUE_TYPE, POD, value) +//%DICTIONARY_COMMON_INTERFACE(KEY_NAME, KEY_TYPE, KisP, KHELPER, VALUE_NAME, VALUE_TYPE, POD, VALUE_NAME, value) //%PDDM-DEFINE DICTIONARY_POD_KEY_TO_OBJECT_INTERFACE(KEY_NAME, KEY_TYPE, VALUE_NAME, VALUE_TYPE) -//%DICTIONARY_COMMON_INTERFACE(KEY_NAME, KEY_TYPE, , POD, VALUE_NAME, VALUE_TYPE, OBJECT, object) -//%PDDM-DEFINE VALUE_FOR_KEY_POD(KEY_TYPE, VALUE_TYPE) -//%- (BOOL)valueForKey:(KEY_TYPE)key value:(nullable VALUE_TYPE *)value; -//%PDDM-DEFINE VALUE_FOR_KEY_OBJECT(KEY_TYPE, VALUE_TYPE) +//%DICTIONARY_COMMON_INTERFACE(KEY_NAME, KEY_TYPE, , POD, VALUE_NAME, VALUE_TYPE, OBJECT, Object, object) +//%PDDM-DEFINE VALUE_FOR_KEY_POD(KEY_TYPE, VALUE_TYPE, VNAME) +//%// Returns YES/NO to indicate if the key was found or not, filling in the value +//%// only when the key was found. +//%- (BOOL)get##VNAME##:(nullable VALUE_TYPE *)value forKey:(KEY_TYPE)key; +//%PDDM-DEFINE VALUE_FOR_KEY_OBJECT(KEY_TYPE, VALUE_TYPE, VNAME) //%- (VALUE_TYPE)objectForKey:(KEY_TYPE)key; -//%PDDM-DEFINE VALUE_FOR_KEY_Enum(KEY_TYPE, VALUE_TYPE) -//%VALUE_FOR_KEY_POD(KEY_TYPE, VALUE_TYPE) +//%PDDM-DEFINE VALUE_FOR_KEY_Enum(KEY_TYPE, VALUE_TYPE, VNAME) +//%VALUE_FOR_KEY_POD(KEY_TYPE, VALUE_TYPE, VNAME) //%PDDM-DEFINE ARRAY_ARG_MODIFIERPOD() // Nothing //%PDDM-DEFINE ARRAY_ARG_MODIFIEREnum() @@ -2136,7 +2247,7 @@ NS_ASSUME_NONNULL_END //%GPB##KEY_NAME##VALUE_NAME##Dictionary //%PDDM-DEFINE DICTIONARY_CLASS_DECLOBJECT(KEY_NAME, VALUE_NAME, VALUE_TYPE) //%GPB##KEY_NAME##VALUE_NAME##Dictionary<__covariant VALUE_TYPE> -//%PDDM-DEFINE DICTIONARY_COMMON_INTERFACE(KEY_NAME, KEY_TYPE, KisP, KHELPER, VALUE_NAME, VALUE_TYPE, VHELPER, VNAME) +//%PDDM-DEFINE DICTIONARY_COMMON_INTERFACE(KEY_NAME, KEY_TYPE, KisP, KHELPER, VALUE_NAME, VALUE_TYPE, VHELPER, VNAME, VNAME_VAR) //%#pragma mark - KEY_NAME -> VALUE_NAME //% //%@interface DICTIONARY_CLASS_DECL##VHELPER(KEY_NAME, VALUE_NAME, VALUE_TYPE) : NSObject @@ -2144,25 +2255,25 @@ NS_ASSUME_NONNULL_END //%@property(nonatomic, readonly) NSUInteger count; //% //%+ (instancetype)dictionary; -//%+ (instancetype)dictionaryWith##VNAME$u##:(VALUE_TYPE)##VNAME +//%+ (instancetype)dictionaryWith##VNAME##:(VALUE_TYPE)##VNAME_VAR //% ##VNAME$S## forKey:(KEY_TYPE##KisP$S##KisP)key; -//%+ (instancetype)dictionaryWith##VNAME$u##s:(const VALUE_TYPE ARRAY_ARG_MODIFIER##VHELPER()[])##VNAME##s +//%+ (instancetype)dictionaryWith##VNAME##s:(const VALUE_TYPE ARRAY_ARG_MODIFIER##VHELPER()[])##VNAME_VAR##s //% ##VNAME$S## forKeys:(const KEY_TYPE##KisP$S##KisP ARRAY_ARG_MODIFIER##KHELPER()[])keys //% ##VNAME$S## count:(NSUInteger)count; //%+ (instancetype)dictionaryWithDictionary:(GPB##KEY_NAME##VALUE_NAME##Dictionary *)dictionary; //%+ (instancetype)dictionaryWithCapacity:(NSUInteger)numItems; //% -//%- (instancetype)initWith##VNAME$u##s:(const VALUE_TYPE ARRAY_ARG_MODIFIER##VHELPER()[])##VNAME##s +//%- (instancetype)initWith##VNAME##s:(const VALUE_TYPE ARRAY_ARG_MODIFIER##VHELPER()[])##VNAME_VAR##s //% ##VNAME$S## forKeys:(const KEY_TYPE##KisP$S##KisP ARRAY_ARG_MODIFIER##KHELPER()[])keys //% ##VNAME$S## count:(NSUInteger)count NS_DESIGNATED_INITIALIZER; //%- (instancetype)initWithDictionary:(GPB##KEY_NAME##VALUE_NAME##Dictionary *)dictionary; //%- (instancetype)initWithCapacity:(NSUInteger)numItems; //% -//%DICTIONARY_IMMUTABLE_INTERFACE(KEY_NAME, KEY_TYPE, KisP, VALUE_NAME, VALUE_TYPE, VHELPER, VNAME) +//%DICTIONARY_IMMUTABLE_INTERFACE(KEY_NAME, KEY_TYPE, KisP, VALUE_NAME, VALUE_TYPE, VHELPER, VNAME, VNAME_VAR) //% //%- (void)addEntriesFromDictionary:(GPB##KEY_NAME##VALUE_NAME##Dictionary *)otherDictionary; //% -//%DICTIONARY_MUTABLE_INTERFACE(KEY_NAME, KEY_TYPE, KisP, VALUE_NAME, VALUE_TYPE, VHELPER, VNAME) +//%DICTIONARY_MUTABLE_INTERFACE(KEY_NAME, KEY_TYPE, KisP, VALUE_NAME, VALUE_TYPE, VHELPER, VNAME, VNAME_VAR) //% //%@end //% @@ -2203,12 +2314,14 @@ NS_ASSUME_NONNULL_END //%// is not a valid enumerator as defined by validationFunc. If the actual value is //%// desired, use "raw" version of the method. //% -//%DICTIONARY_IMMUTABLE_INTERFACE(KEY_NAME, KEY_TYPE, KisP, VALUE_NAME, VALUE_TYPE, VHELPER, value) +//%DICTIONARY_IMMUTABLE_INTERFACE(KEY_NAME, KEY_TYPE, KisP, VALUE_NAME, VALUE_TYPE, VHELPER, Enum, value) //% //%// These methods bypass the validationFunc to provide access to values that were not //%// known at the time the binary was compiled. //% -//%- (BOOL)valueForKey:(KEY_TYPE##KisP$S##KisP)key rawValue:(nullable VALUE_TYPE *)rawValue; +//%// Returns YES/NO to indicate if the key was found or not, filling in the value +//%// only when the key was found. +//%- (BOOL)getRawValue:(nullable VALUE_TYPE *)rawValue forKey:(KEY_TYPE##KisP$S##KisP)key; //% //%- (void)enumerateKeysAndRawValuesUsingBlock: //% (void (^)(KEY_TYPE KisP##key, VALUE_TYPE rawValue, BOOL *stop))block; @@ -2220,21 +2333,21 @@ NS_ASSUME_NONNULL_END //%// to the default value. Use the rawValue methods below to assign non enumerator //%// values. //% -//%DICTIONARY_MUTABLE_INTERFACE(KEY_NAME, KEY_TYPE, KisP, VALUE_NAME, VALUE_TYPE, VHELPER, value) +//%DICTIONARY_MUTABLE_INTERFACE(KEY_NAME, KEY_TYPE, KisP, VALUE_NAME, VALUE_TYPE, VHELPER, Enum, value) //% //%@end //% -//%PDDM-DEFINE DICTIONARY_IMMUTABLE_INTERFACE(KEY_NAME, KEY_TYPE, KisP, VALUE_NAME, VALUE_TYPE, VHELPER, VNAME) -//%VALUE_FOR_KEY_##VHELPER(KEY_TYPE##KisP$S##KisP, VALUE_TYPE) +//%PDDM-DEFINE DICTIONARY_IMMUTABLE_INTERFACE(KEY_NAME, KEY_TYPE, KisP, VALUE_NAME, VALUE_TYPE, VHELPER, VNAME, VNAME_VAR) +//%VALUE_FOR_KEY_##VHELPER(KEY_TYPE##KisP$S##KisP, VALUE_TYPE, VNAME) //% -//%- (void)enumerateKeysAnd##VNAME$u##sUsingBlock: -//% (void (^)(KEY_TYPE KisP##key, VALUE_TYPE VNAME, BOOL *stop))block; +//%- (void)enumerateKeysAnd##VNAME##sUsingBlock: +//% (void (^)(KEY_TYPE KisP##key, VALUE_TYPE VNAME_VAR, BOOL *stop))block; -//%PDDM-DEFINE DICTIONARY_MUTABLE_INTERFACE(KEY_NAME, KEY_TYPE, KisP, VALUE_NAME, VALUE_TYPE, VHELPER, VNAME) -//%- (void)set##VNAME$u##:(VALUE_TYPE)##VNAME forKey:(KEY_TYPE##KisP$S##KisP)key; +//%PDDM-DEFINE DICTIONARY_MUTABLE_INTERFACE(KEY_NAME, KEY_TYPE, KisP, VALUE_NAME, VALUE_TYPE, VHELPER, VNAME, VNAME_VAR) +//%- (void)set##VNAME##:(VALUE_TYPE)##VNAME_VAR forKey:(KEY_TYPE##KisP$S##KisP)key; //%DICTIONARY_EXTRA_MUTABLE_METHODS_##VHELPER(KEY_NAME, KEY_TYPE, KisP, VALUE_NAME, VALUE_TYPE) -//%- (void)remove##VNAME$u##ForKey:(KEY_TYPE##KisP$S##KisP)aKey; +//%- (void)remove##VNAME##ForKey:(KEY_TYPE##KisP$S##KisP)aKey; //%- (void)removeAll; //%PDDM-DEFINE DICTIONARY_EXTRA_MUTABLE_METHODS_POD(KEY_NAME, KEY_TYPE, KisP, VALUE_NAME, VALUE_TYPE) diff --git a/objectivec/GPBDictionary.m b/objectivec/GPBDictionary.m index bceb3a99..fd8bd1ce 100644 --- a/objectivec/GPBDictionary.m +++ b/objectivec/GPBDictionary.m @@ -577,12 +577,12 @@ void GPBDictionaryReadEntry(id mapDictionary, //%DICTIONARY_KEY_TO_ENUM_IMPL(KEY_NAME, KEY_TYPE, KisP, Enum, int32_t, KHELPER) //%PDDM-DEFINE DICTIONARY_KEY_TO_POD_IMPL(KEY_NAME, KEY_TYPE, KisP, VALUE_NAME, VALUE_TYPE, KHELPER) -//%DICTIONARY_COMMON_IMPL(KEY_NAME, KEY_TYPE, KisP, VALUE_NAME, VALUE_TYPE, KHELPER, POD, value) +//%DICTIONARY_COMMON_IMPL(KEY_NAME, KEY_TYPE, KisP, VALUE_NAME, VALUE_TYPE, KHELPER, POD, VALUE_NAME, value) //%PDDM-DEFINE DICTIONARY_POD_KEY_TO_OBJECT_IMPL(KEY_NAME, KEY_TYPE, VALUE_NAME, VALUE_TYPE) -//%DICTIONARY_COMMON_IMPL(KEY_NAME, KEY_TYPE, , VALUE_NAME, VALUE_TYPE, POD, OBJECT, object) +//%DICTIONARY_COMMON_IMPL(KEY_NAME, KEY_TYPE, , VALUE_NAME, VALUE_TYPE, POD, OBJECT, Object, object) -//%PDDM-DEFINE DICTIONARY_COMMON_IMPL(KEY_NAME, KEY_TYPE, KisP, VALUE_NAME, VALUE_TYPE, KHELPER, VHELPER, VNAME) +//%PDDM-DEFINE DICTIONARY_COMMON_IMPL(KEY_NAME, KEY_TYPE, KisP, VALUE_NAME, VALUE_TYPE, KHELPER, VHELPER, VNAME, VNAME_VAR) //%#pragma mark - KEY_NAME -> VALUE_NAME //% //%@implementation GPB##KEY_NAME##VALUE_NAME##Dictionary { @@ -591,24 +591,24 @@ void GPBDictionaryReadEntry(id mapDictionary, //%} //% //%+ (instancetype)dictionary { -//% return [[[self alloc] initWith##VNAME$u##s:NULL forKeys:NULL count:0] autorelease]; +//% return [[[self alloc] initWith##VNAME##s:NULL forKeys:NULL count:0] autorelease]; //%} //% -//%+ (instancetype)dictionaryWith##VNAME$u##:(VALUE_TYPE)##VNAME +//%+ (instancetype)dictionaryWith##VNAME##:(VALUE_TYPE)##VNAME_VAR //% ##VNAME$S## forKey:(KEY_TYPE##KisP$S##KisP)key { -//% // Cast is needed so the compiler knows what class we are invoking initWith##VNAME$u##s:forKeys:count: +//% // Cast is needed so the compiler knows what class we are invoking initWith##VNAME##s:forKeys:count: //% // on to get the type correct. -//% return [[(GPB##KEY_NAME##VALUE_NAME##Dictionary*)[self alloc] initWith##VNAME$u##s:&##VNAME +//% return [[(GPB##KEY_NAME##VALUE_NAME##Dictionary*)[self alloc] initWith##VNAME##s:&##VNAME_VAR //% KEY_NAME$S VALUE_NAME$S ##VNAME$S## forKeys:&key //% KEY_NAME$S VALUE_NAME$S ##VNAME$S## count:1] autorelease]; //%} //% -//%+ (instancetype)dictionaryWith##VNAME$u##s:(const VALUE_TYPE [])##VNAME##s +//%+ (instancetype)dictionaryWith##VNAME##s:(const VALUE_TYPE [])##VNAME_VAR##s //% ##VNAME$S## forKeys:(const KEY_TYPE##KisP$S##KisP [])keys //% ##VNAME$S## count:(NSUInteger)count { -//% // Cast is needed so the compiler knows what class we are invoking initWith##VNAME$u##s:forKeys:count: +//% // Cast is needed so the compiler knows what class we are invoking initWith##VNAME##s:forKeys:count: //% // on to get the type correct. -//% return [[(GPB##KEY_NAME##VALUE_NAME##Dictionary*)[self alloc] initWith##VNAME$u##s:##VNAME##s +//% return [[(GPB##KEY_NAME##VALUE_NAME##Dictionary*)[self alloc] initWith##VNAME##s:##VNAME_VAR##s //% KEY_NAME$S VALUE_NAME$S forKeys:keys //% KEY_NAME$S VALUE_NAME$S count:count] autorelease]; //%} @@ -624,18 +624,18 @@ void GPBDictionaryReadEntry(id mapDictionary, //%} //% //%- (instancetype)init { -//% return [self initWith##VNAME$u##s:NULL forKeys:NULL count:0]; +//% return [self initWith##VNAME##s:NULL forKeys:NULL count:0]; //%} //% -//%- (instancetype)initWith##VNAME$u##s:(const VALUE_TYPE [])##VNAME##s +//%- (instancetype)initWith##VNAME##s:(const VALUE_TYPE [])##VNAME_VAR##s //% ##VNAME$S## forKeys:(const KEY_TYPE##KisP$S##KisP [])keys //% ##VNAME$S## count:(NSUInteger)count { //% self = [super init]; //% if (self) { //% _dictionary = [[NSMutableDictionary alloc] init]; -//% if (count && VNAME##s && keys) { +//% if (count && VNAME_VAR##s && keys) { //% for (NSUInteger i = 0; i < count; ++i) { -//%DICTIONARY_VALIDATE_VALUE_##VHELPER(VNAME##s[i], ______)##DICTIONARY_VALIDATE_KEY_##KHELPER(keys[i], ______) [_dictionary setObject:WRAPPED##VHELPER(VNAME##s[i]) forKey:WRAPPED##KHELPER(keys[i])]; +//%DICTIONARY_VALIDATE_VALUE_##VHELPER(VNAME_VAR##s[i], ______)##DICTIONARY_VALIDATE_KEY_##KHELPER(keys[i], ______) [_dictionary setObject:WRAPPED##VHELPER(VNAME_VAR##s[i]) forKey:WRAPPED##KHELPER(keys[i])]; //% } //% } //% } @@ -643,7 +643,7 @@ void GPBDictionaryReadEntry(id mapDictionary, //%} //% //%- (instancetype)initWithDictionary:(GPB##KEY_NAME##VALUE_NAME##Dictionary *)dictionary { -//% self = [self initWith##VNAME$u##s:NULL forKeys:NULL count:0]; +//% self = [self initWith##VNAME##s:NULL forKeys:NULL count:0]; //% if (self) { //% if (dictionary) { //% [_dictionary addEntriesFromDictionary:dictionary->_dictionary]; @@ -654,14 +654,14 @@ void GPBDictionaryReadEntry(id mapDictionary, //% //%- (instancetype)initWithCapacity:(NSUInteger)numItems { //% #pragma unused(numItems) -//% return [self initWith##VNAME$u##s:NULL forKeys:NULL count:0]; +//% return [self initWith##VNAME##s:NULL forKeys:NULL count:0]; //%} //% -//%DICTIONARY_IMMUTABLE_CORE(KEY_NAME, KEY_TYPE, KisP, VALUE_NAME, VALUE_TYPE, KHELPER, VHELPER, VNAME, ) +//%DICTIONARY_IMMUTABLE_CORE(KEY_NAME, KEY_TYPE, KisP, VALUE_NAME, VALUE_TYPE, KHELPER, VHELPER, VNAME, VNAME_VAR, ) //% //%VALUE_FOR_KEY_##VHELPER(KEY_TYPE##KisP$S##KisP, VALUE_NAME, VALUE_TYPE, KHELPER) //% -//%DICTIONARY_MUTABLE_CORE(KEY_NAME, KEY_TYPE, KisP, VALUE_NAME, VALUE_TYPE, KHELPER, VHELPER, VNAME, ) +//%DICTIONARY_MUTABLE_CORE(KEY_NAME, KEY_TYPE, KisP, VALUE_NAME, VALUE_TYPE, KHELPER, VHELPER, VNAME, VNAME_VAR, ) //% //%@end //% @@ -771,9 +771,9 @@ void GPBDictionaryReadEntry(id mapDictionary, //% return [self initWithValidationFunction:func rawValues:NULL forKeys:NULL count:0]; //%} //% -//%DICTIONARY_IMMUTABLE_CORE(KEY_NAME, KEY_TYPE, KisP, VALUE_NAME, VALUE_TYPE, KHELPER, VHELPER, value, Raw) +//%DICTIONARY_IMMUTABLE_CORE(KEY_NAME, KEY_TYPE, KisP, VALUE_NAME, VALUE_TYPE, KHELPER, VHELPER, Value, value, Raw) //% -//%- (BOOL)valueForKey:(KEY_TYPE##KisP$S##KisP)key value:(VALUE_TYPE *)value { +//%- (BOOL)getEnum:(VALUE_TYPE *)value forKey:(KEY_TYPE##KisP$S##KisP)key { //% NSNumber *wrapped = [_dictionary objectForKey:WRAPPED##KHELPER(key)]; //% if (wrapped && value) { //% VALUE_TYPE result = UNWRAP##VALUE_NAME(wrapped); @@ -785,7 +785,7 @@ void GPBDictionaryReadEntry(id mapDictionary, //% return (wrapped != NULL); //%} //% -//%- (BOOL)valueForKey:(KEY_TYPE##KisP$S##KisP)key rawValue:(VALUE_TYPE *)rawValue { +//%- (BOOL)getRawValue:(VALUE_TYPE *)rawValue forKey:(KEY_TYPE##KisP$S##KisP)key { //% NSNumber *wrapped = [_dictionary objectForKey:WRAPPED##KHELPER(key)]; //% if (wrapped && rawValue) { //% *rawValue = UNWRAP##VALUE_NAME(wrapped); @@ -793,7 +793,7 @@ void GPBDictionaryReadEntry(id mapDictionary, //% return (wrapped != NULL); //%} //% -//%- (void)enumerateKeysAndValuesUsingBlock: +//%- (void)enumerateKeysAndEnumsUsingBlock: //% (void (^)(KEY_TYPE KisP##key, VALUE_TYPE value, BOOL *stop))block { //% GPBEnumValidationFunc func = _validationFunc; //% [_dictionary enumerateKeysAndObjectsUsingBlock:^(ENUM_TYPE##KHELPER(KEY_TYPE)##aKey, @@ -807,9 +807,9 @@ void GPBDictionaryReadEntry(id mapDictionary, //% }]; //%} //% -//%DICTIONARY_MUTABLE_CORE(KEY_NAME, KEY_TYPE, KisP, VALUE_NAME, VALUE_TYPE, KHELPER, VHELPER, value, Raw) +//%DICTIONARY_MUTABLE_CORE2(KEY_NAME, KEY_TYPE, KisP, VALUE_NAME, VALUE_TYPE, KHELPER, VHELPER, Value, Enum, value, Raw) //% -//%- (void)setValue:(VALUE_TYPE)value forKey:(KEY_TYPE##KisP$S##KisP)key { +//%- (void)setEnum:(VALUE_TYPE)value forKey:(KEY_TYPE##KisP$S##KisP)key { //%DICTIONARY_VALIDATE_KEY_##KHELPER(key, ) if (!_validationFunc(value)) { //% [NSException raise:NSInvalidArgumentException //% format:@"GPB##KEY_NAME##VALUE_NAME##Dictionary: Attempt to set an unknown enum value (%d)", @@ -825,7 +825,7 @@ void GPBDictionaryReadEntry(id mapDictionary, //%@end //% -//%PDDM-DEFINE DICTIONARY_IMMUTABLE_CORE(KEY_NAME, KEY_TYPE, KisP, VALUE_NAME, VALUE_TYPE, KHELPER, VHELPER, VNAME, ACCESSOR_NAME) +//%PDDM-DEFINE DICTIONARY_IMMUTABLE_CORE(KEY_NAME, KEY_TYPE, KisP, VALUE_NAME, VALUE_TYPE, KHELPER, VHELPER, VNAME, VNAME_VAR, ACCESSOR_NAME) //%- (void)dealloc { //% NSAssert(!_autocreator, //% @"%@: Autocreator must be cleared before release, autocreator: %@", @@ -861,12 +861,12 @@ void GPBDictionaryReadEntry(id mapDictionary, //% return _dictionary.count; //%} //% -//%- (void)enumerateKeysAnd##ACCESSOR_NAME##VNAME$u##sUsingBlock: -//% (void (^)(KEY_TYPE KisP##key, VALUE_TYPE VNAME, BOOL *stop))block { +//%- (void)enumerateKeysAnd##ACCESSOR_NAME##VNAME##sUsingBlock: +//% (void (^)(KEY_TYPE KisP##key, VALUE_TYPE VNAME_VAR, BOOL *stop))block { //% [_dictionary enumerateKeysAndObjectsUsingBlock:^(ENUM_TYPE##KHELPER(KEY_TYPE)##aKey, -//% ENUM_TYPE##VHELPER(VALUE_TYPE)##a##VNAME$u, +//% ENUM_TYPE##VHELPER(VALUE_TYPE)##a##VNAME_VAR$u, //% BOOL *stop) { -//% block(UNWRAP##KEY_NAME(aKey), UNWRAP##VALUE_NAME(a##VNAME$u), stop); +//% block(UNWRAP##KEY_NAME(aKey), UNWRAP##VALUE_NAME(a##VNAME_VAR$u), stop); //% }]; //%} //% @@ -880,11 +880,11 @@ void GPBDictionaryReadEntry(id mapDictionary, //% GPBDataType keyDataType = field.mapKeyDataType; //% __block size_t result = 0; //% [_dictionary enumerateKeysAndObjectsUsingBlock:^(ENUM_TYPE##KHELPER(KEY_TYPE)##aKey, -//% ENUM_TYPE##VHELPER(VALUE_TYPE)##a##VNAME$u##, +//% ENUM_TYPE##VHELPER(VALUE_TYPE)##a##VNAME_VAR$u##, //% BOOL *stop) { //% #pragma unused(stop) //% size_t msgSize = ComputeDict##KEY_NAME##FieldSize(UNWRAP##KEY_NAME(aKey), kMapKeyFieldNumber, keyDataType); -//% msgSize += ComputeDict##VALUE_NAME##FieldSize(UNWRAP##VALUE_NAME(a##VNAME$u), kMapValueFieldNumber, valueDataType); +//% msgSize += ComputeDict##VALUE_NAME##FieldSize(UNWRAP##VALUE_NAME(a##VNAME_VAR$u), kMapValueFieldNumber, valueDataType); //% result += GPBComputeRawVarint32SizeForInteger(msgSize) + msgSize; //% }]; //% size_t tagSize = GPBComputeWireFormatTagSize(GPBFieldNumber(field), GPBDataTypeMessage); @@ -898,18 +898,18 @@ void GPBDictionaryReadEntry(id mapDictionary, //% GPBDataType keyDataType = field.mapKeyDataType; //% uint32_t tag = GPBWireFormatMakeTag(GPBFieldNumber(field), GPBWireFormatLengthDelimited); //% [_dictionary enumerateKeysAndObjectsUsingBlock:^(ENUM_TYPE##KHELPER(KEY_TYPE)##aKey, -//% ENUM_TYPE##VHELPER(VALUE_TYPE)##a##VNAME$u, +//% ENUM_TYPE##VHELPER(VALUE_TYPE)##a##VNAME_VAR$u, //% BOOL *stop) { //% #pragma unused(stop) //% // Write the tag. //% [outputStream writeInt32NoTag:tag]; //% // Write the size of the message. //% size_t msgSize = ComputeDict##KEY_NAME##FieldSize(UNWRAP##KEY_NAME(aKey), kMapKeyFieldNumber, keyDataType); -//% msgSize += ComputeDict##VALUE_NAME##FieldSize(UNWRAP##VALUE_NAME(a##VNAME$u), kMapValueFieldNumber, valueDataType); +//% msgSize += ComputeDict##VALUE_NAME##FieldSize(UNWRAP##VALUE_NAME(a##VNAME_VAR$u), kMapValueFieldNumber, valueDataType); //% [outputStream writeInt32NoTag:(int32_t)msgSize]; //% // Write the fields. //% WriteDict##KEY_NAME##Field(outputStream, UNWRAP##KEY_NAME(aKey), kMapKeyFieldNumber, keyDataType); -//% WriteDict##VALUE_NAME##Field(outputStream, UNWRAP##VALUE_NAME(a##VNAME$u), kMapValueFieldNumber, valueDataType); +//% WriteDict##VALUE_NAME##Field(outputStream, UNWRAP##VALUE_NAME(a##VNAME_VAR$u), kMapValueFieldNumber, valueDataType); //% }]; //%} //% @@ -919,12 +919,14 @@ void GPBDictionaryReadEntry(id mapDictionary, //%} //% //%- (void)enumerateForTextFormat:(void (^)(id keyObj, id valueObj))block { -//% [self enumerateKeysAnd##ACCESSOR_NAME##VNAME$u##sUsingBlock:^(KEY_TYPE KisP##key, VALUE_TYPE VNAME, BOOL *stop) { +//% [self enumerateKeysAnd##ACCESSOR_NAME##VNAME##sUsingBlock:^(KEY_TYPE KisP##key, VALUE_TYPE VNAME_VAR, BOOL *stop) { //% #pragma unused(stop) -//% block(TEXT_FORMAT_OBJ##KEY_NAME(key), TEXT_FORMAT_OBJ##VALUE_NAME(VNAME)); +//% block(TEXT_FORMAT_OBJ##KEY_NAME(key), TEXT_FORMAT_OBJ##VALUE_NAME(VNAME_VAR)); //% }]; //%} -//%PDDM-DEFINE DICTIONARY_MUTABLE_CORE(KEY_NAME, KEY_TYPE, KisP, VALUE_NAME, VALUE_TYPE, KHELPER, VHELPER, VNAME, ACCESSOR_NAME) +//%PDDM-DEFINE DICTIONARY_MUTABLE_CORE(KEY_NAME, KEY_TYPE, KisP, VALUE_NAME, VALUE_TYPE, KHELPER, VHELPER, VNAME, VNAME_VAR, ACCESSOR_NAME) +//%DICTIONARY_MUTABLE_CORE2(KEY_NAME, KEY_TYPE, KisP, VALUE_NAME, VALUE_TYPE, KHELPER, VHELPER, VNAME, VNAME, VNAME_VAR, ACCESSOR_NAME) +//%PDDM-DEFINE DICTIONARY_MUTABLE_CORE2(KEY_NAME, KEY_TYPE, KisP, VALUE_NAME, VALUE_TYPE, KHELPER, VHELPER, VNAME, VNAME_REMOVE, VNAME_VAR, ACCESSOR_NAME) //%- (void)add##ACCESSOR_NAME##EntriesFromDictionary:(GPB##KEY_NAME##VALUE_NAME##Dictionary *)otherDictionary { //% if (otherDictionary) { //% [_dictionary addEntriesFromDictionary:otherDictionary->_dictionary]; @@ -934,14 +936,14 @@ void GPBDictionaryReadEntry(id mapDictionary, //% } //%} //% -//%- (void)set##ACCESSOR_NAME##VNAME$u##:(VALUE_TYPE)VNAME forKey:(KEY_TYPE##KisP$S##KisP)key { -//%DICTIONARY_VALIDATE_VALUE_##VHELPER(VNAME, )##DICTIONARY_VALIDATE_KEY_##KHELPER(key, ) [_dictionary setObject:WRAPPED##VHELPER(VNAME) forKey:WRAPPED##KHELPER(key)]; +//%- (void)set##ACCESSOR_NAME##VNAME##:(VALUE_TYPE)VNAME_VAR forKey:(KEY_TYPE##KisP$S##KisP)key { +//%DICTIONARY_VALIDATE_VALUE_##VHELPER(VNAME_VAR, )##DICTIONARY_VALIDATE_KEY_##KHELPER(key, ) [_dictionary setObject:WRAPPED##VHELPER(VNAME_VAR) forKey:WRAPPED##KHELPER(key)]; //% if (_autocreator) { //% GPBAutocreatedDictionaryModified(_autocreator, self); //% } //%} //% -//%- (void)remove##VNAME$u##ForKey:(KEY_TYPE##KisP$S##KisP)aKey { +//%- (void)remove##VNAME_REMOVE##ForKey:(KEY_TYPE##KisP$S##KisP)aKey { //% [_dictionary removeObjectForKey:WRAPPED##KHELPER(aKey)]; //%} //% @@ -954,11 +956,11 @@ void GPBDictionaryReadEntry(id mapDictionary, // //%PDDM-DEFINE DICTIONARY_BOOL_KEY_TO_POD_IMPL(VALUE_NAME, VALUE_TYPE) -//%DICTIONARY_BOOL_KEY_TO_VALUE_IMPL(VALUE_NAME, VALUE_TYPE, POD, value) +//%DICTIONARY_BOOL_KEY_TO_VALUE_IMPL(VALUE_NAME, VALUE_TYPE, POD, VALUE_NAME, value) //%PDDM-DEFINE DICTIONARY_BOOL_KEY_TO_OBJECT_IMPL(VALUE_NAME, VALUE_TYPE) -//%DICTIONARY_BOOL_KEY_TO_VALUE_IMPL(VALUE_NAME, VALUE_TYPE, OBJECT, object) +//%DICTIONARY_BOOL_KEY_TO_VALUE_IMPL(VALUE_NAME, VALUE_TYPE, OBJECT, Object, object) -//%PDDM-DEFINE DICTIONARY_BOOL_KEY_TO_VALUE_IMPL(VALUE_NAME, VALUE_TYPE, HELPER, VNAME) +//%PDDM-DEFINE DICTIONARY_BOOL_KEY_TO_VALUE_IMPL(VALUE_NAME, VALUE_TYPE, HELPER, VNAME, VNAME_VAR) //%#pragma mark - Bool -> VALUE_NAME //% //%@implementation GPBBool##VALUE_NAME##Dictionary { @@ -967,24 +969,24 @@ void GPBDictionaryReadEntry(id mapDictionary, //%BOOL_DICT_HAS_STORAGE_##HELPER()} //% //%+ (instancetype)dictionary { -//% return [[[self alloc] initWith##VNAME$u##s:NULL forKeys:NULL count:0] autorelease]; +//% return [[[self alloc] initWith##VNAME##s:NULL forKeys:NULL count:0] autorelease]; //%} //% -//%+ (instancetype)dictionaryWith##VNAME$u##:(VALUE_TYPE)VNAME +//%+ (instancetype)dictionaryWith##VNAME##:(VALUE_TYPE)VNAME_VAR //% ##VNAME$S## forKey:(BOOL)key { -//% // Cast is needed so the compiler knows what class we are invoking initWith##VNAME$u##s:forKeys:count: +//% // Cast is needed so the compiler knows what class we are invoking initWith##VNAME##s:forKeys:count: //% // on to get the type correct. -//% return [[(GPBBool##VALUE_NAME##Dictionary*)[self alloc] initWith##VNAME$u##s:&##VNAME +//% return [[(GPBBool##VALUE_NAME##Dictionary*)[self alloc] initWith##VNAME##s:&##VNAME_VAR //% VALUE_NAME$S ##VNAME$S## forKeys:&key //% VALUE_NAME$S ##VNAME$S## count:1] autorelease]; //%} //% -//%+ (instancetype)dictionaryWith##VNAME$u##s:(const VALUE_TYPE [])##VNAME##s +//%+ (instancetype)dictionaryWith##VNAME##s:(const VALUE_TYPE [])##VNAME_VAR##s //% ##VNAME$S## forKeys:(const BOOL [])keys //% ##VNAME$S## count:(NSUInteger)count { -//% // Cast is needed so the compiler knows what class we are invoking initWith##VNAME$u##s:forKeys:count: +//% // Cast is needed so the compiler knows what class we are invoking initWith##VNAME##s:forKeys:count: //% // on to get the type correct. -//% return [[(GPBBool##VALUE_NAME##Dictionary*)[self alloc] initWith##VNAME$u##s:##VNAME##s +//% return [[(GPBBool##VALUE_NAME##Dictionary*)[self alloc] initWith##VNAME##s:##VNAME_VAR##s //% VALUE_NAME$S ##VNAME$S## forKeys:keys //% VALUE_NAME$S ##VNAME$S## count:count] autorelease]; //%} @@ -1000,14 +1002,14 @@ void GPBDictionaryReadEntry(id mapDictionary, //%} //% //%- (instancetype)init { -//% return [self initWith##VNAME$u##s:NULL forKeys:NULL count:0]; +//% return [self initWith##VNAME##s:NULL forKeys:NULL count:0]; //%} //% //%BOOL_DICT_INITS_##HELPER(VALUE_NAME, VALUE_TYPE) //% //%- (instancetype)initWithCapacity:(NSUInteger)numItems { //% #pragma unused(numItems) -//% return [self initWith##VNAME$u##s:NULL forKeys:NULL count:0]; +//% return [self initWith##VNAME##s:NULL forKeys:NULL count:0]; //%} //% //%BOOL_DICT_DEALLOC##HELPER() @@ -1055,7 +1057,7 @@ void GPBDictionaryReadEntry(id mapDictionary, //% return (BOOL_DICT_W_HAS##HELPER(0, ) ? 1 : 0) + (BOOL_DICT_W_HAS##HELPER(1, ) ? 1 : 0); //%} //% -//%BOOL_VALUE_FOR_KEY_##HELPER(VALUE_TYPE) +//%BOOL_VALUE_FOR_KEY_##HELPER(VALUE_NAME, VALUE_TYPE) //% //%BOOL_SET_GPBVALUE_FOR_KEY_##HELPER(VALUE_NAME, VALUE_TYPE, VisP) //% @@ -1068,8 +1070,8 @@ void GPBDictionaryReadEntry(id mapDictionary, //% } //%} //% -//%- (void)enumerateKeysAnd##VNAME$u##sUsingBlock: -//% (void (^)(BOOL key, VALUE_TYPE VNAME, BOOL *stop))block { +//%- (void)enumerateKeysAnd##VNAME##sUsingBlock: +//% (void (^)(BOOL key, VALUE_TYPE VNAME_VAR, BOOL *stop))block { //% BOOL stop = NO; //% if (BOOL_DICT_HAS##HELPER(0, )) { //% block(NO, _values[0], &stop); @@ -1126,7 +1128,7 @@ void GPBDictionaryReadEntry(id mapDictionary, // //%PDDM-DEFINE VALUE_FOR_KEY_POD(KEY_TYPE, VALUE_NAME, VALUE_TYPE, KHELPER) -//%- (BOOL)valueForKey:(KEY_TYPE)key value:(VALUE_TYPE *)value { +//%- (BOOL)get##VALUE_NAME##:(nullable VALUE_TYPE *)value forKey:(KEY_TYPE)key { //% NSNumber *wrapped = [_dictionary objectForKey:WRAPPED##KHELPER(key)]; //% if (wrapped && value) { //% *value = UNWRAP##VALUE_NAME(wrapped); @@ -1216,9 +1218,9 @@ void GPBDictionaryReadEntry(id mapDictionary, //% BOOL _valueSet[2]; //% //%PDDM-DEFINE BOOL_DICT_INITS_POD(VALUE_NAME, VALUE_TYPE) -//%- (instancetype)initWithValues:(const VALUE_TYPE [])values -//% forKeys:(const BOOL [])keys -//% count:(NSUInteger)count { +//%- (instancetype)initWith##VALUE_NAME##s:(const VALUE_TYPE [])values +//% ##VALUE_NAME$S## forKeys:(const BOOL [])keys +//% ##VALUE_NAME$S## count:(NSUInteger)count { //% self = [super init]; //% if (self) { //% for (NSUInteger i = 0; i < count; ++i) { @@ -1231,7 +1233,7 @@ void GPBDictionaryReadEntry(id mapDictionary, //%} //% //%- (instancetype)initWithDictionary:(GPBBool##VALUE_NAME##Dictionary *)dictionary { -//% self = [self initWithValues:NULL forKeys:NULL count:0]; +//% self = [self initWith##VALUE_NAME##s:NULL forKeys:NULL count:0]; //% if (self) { //% if (dictionary) { //% for (int i = 0; i < 2; ++i) { @@ -1257,8 +1259,8 @@ void GPBDictionaryReadEntry(id mapDictionary, //%BOOL_DICT_HASPOD(IDX, REF) //%PDDM-DEFINE BOOL_DICT_HASPOD(IDX, REF) //%REF##_valueSet[IDX] -//%PDDM-DEFINE BOOL_VALUE_FOR_KEY_POD(VALUE_TYPE) -//%- (BOOL)valueForKey:(BOOL)key value:(VALUE_TYPE *)value { +//%PDDM-DEFINE BOOL_VALUE_FOR_KEY_POD(VALUE_NAME, VALUE_TYPE) +//%- (BOOL)get##VALUE_NAME##:(VALUE_TYPE *)value forKey:(BOOL)key { //% int idx = (key ? 1 : 0); //% if (_valueSet[idx]) { //% if (value) { @@ -1290,7 +1292,7 @@ void GPBDictionaryReadEntry(id mapDictionary, //% } //%} //% -//%- (void)setValue:(VALUE_TYPE)value forKey:(BOOL)key { +//%- (void)set##VALUE_NAME:(VALUE_TYPE)value forKey:(BOOL)key { //% int idx = (key ? 1 : 0); //% _values[idx] = value; //% _valueSet[idx] = YES; @@ -1299,7 +1301,7 @@ void GPBDictionaryReadEntry(id mapDictionary, //% } //%} //% -//%- (void)removeValueForKey:(BOOL)aKey { +//%- (void)remove##VALUE_NAME##ForKey:(BOOL)aKey { //% _valueSet[aKey ? 1 : 0] = NO; //%} //% @@ -1460,7 +1462,7 @@ void GPBDictionaryReadEntry(id mapDictionary, //%(BOOL_DICT_HASOBJECT(IDX, REF)) //%PDDM-DEFINE BOOL_DICT_HASOBJECT(IDX, REF) //%REF##_values[IDX] != nil -//%PDDM-DEFINE BOOL_VALUE_FOR_KEY_OBJECT(VALUE_TYPE) +//%PDDM-DEFINE BOOL_VALUE_FOR_KEY_OBJECT(VALUE_NAME, VALUE_TYPE) //%- (VALUE_TYPE)objectForKey:(BOOL)key { //% return _values[key ? 1 : 0]; //%} @@ -1527,24 +1529,24 @@ void GPBDictionaryReadEntry(id mapDictionary, } + (instancetype)dictionary { - return [[[self alloc] initWithValues:NULL forKeys:NULL count:0] autorelease]; + return [[[self alloc] initWithUInt32s:NULL forKeys:NULL count:0] autorelease]; } -+ (instancetype)dictionaryWithValue:(uint32_t)value - forKey:(uint32_t)key { - // Cast is needed so the compiler knows what class we are invoking initWithValues:forKeys:count: ++ (instancetype)dictionaryWithUInt32:(uint32_t)value + forKey:(uint32_t)key { + // Cast is needed so the compiler knows what class we are invoking initWithUInt32s:forKeys:count: // on to get the type correct. - return [[(GPBUInt32UInt32Dictionary*)[self alloc] initWithValues:&value - forKeys:&key - count:1] autorelease]; + return [[(GPBUInt32UInt32Dictionary*)[self alloc] initWithUInt32s:&value + forKeys:&key + count:1] autorelease]; } -+ (instancetype)dictionaryWithValues:(const uint32_t [])values - forKeys:(const uint32_t [])keys - count:(NSUInteger)count { - // Cast is needed so the compiler knows what class we are invoking initWithValues:forKeys:count: ++ (instancetype)dictionaryWithUInt32s:(const uint32_t [])values + forKeys:(const uint32_t [])keys + count:(NSUInteger)count { + // Cast is needed so the compiler knows what class we are invoking initWithUInt32s:forKeys:count: // on to get the type correct. - return [[(GPBUInt32UInt32Dictionary*)[self alloc] initWithValues:values + return [[(GPBUInt32UInt32Dictionary*)[self alloc] initWithUInt32s:values forKeys:keys count:count] autorelease]; } @@ -1560,12 +1562,12 @@ void GPBDictionaryReadEntry(id mapDictionary, } - (instancetype)init { - return [self initWithValues:NULL forKeys:NULL count:0]; + return [self initWithUInt32s:NULL forKeys:NULL count:0]; } -- (instancetype)initWithValues:(const uint32_t [])values - forKeys:(const uint32_t [])keys - count:(NSUInteger)count { +- (instancetype)initWithUInt32s:(const uint32_t [])values + forKeys:(const uint32_t [])keys + count:(NSUInteger)count { self = [super init]; if (self) { _dictionary = [[NSMutableDictionary alloc] init]; @@ -1579,7 +1581,7 @@ void GPBDictionaryReadEntry(id mapDictionary, } - (instancetype)initWithDictionary:(GPBUInt32UInt32Dictionary *)dictionary { - self = [self initWithValues:NULL forKeys:NULL count:0]; + self = [self initWithUInt32s:NULL forKeys:NULL count:0]; if (self) { if (dictionary) { [_dictionary addEntriesFromDictionary:dictionary->_dictionary]; @@ -1590,7 +1592,7 @@ void GPBDictionaryReadEntry(id mapDictionary, - (instancetype)initWithCapacity:(NSUInteger)numItems { #pragma unused(numItems) - return [self initWithValues:NULL forKeys:NULL count:0]; + return [self initWithUInt32s:NULL forKeys:NULL count:0]; } - (void)dealloc { @@ -1628,7 +1630,7 @@ void GPBDictionaryReadEntry(id mapDictionary, return _dictionary.count; } -- (void)enumerateKeysAndValuesUsingBlock: +- (void)enumerateKeysAndUInt32sUsingBlock: (void (^)(uint32_t key, uint32_t value, BOOL *stop))block { [_dictionary enumerateKeysAndObjectsUsingBlock:^(NSNumber *aKey, NSNumber *aValue, @@ -1686,13 +1688,13 @@ void GPBDictionaryReadEntry(id mapDictionary, } - (void)enumerateForTextFormat:(void (^)(id keyObj, id valueObj))block { - [self enumerateKeysAndValuesUsingBlock:^(uint32_t key, uint32_t value, BOOL *stop) { + [self enumerateKeysAndUInt32sUsingBlock:^(uint32_t key, uint32_t value, BOOL *stop) { #pragma unused(stop) block([NSString stringWithFormat:@"%u", key], [NSString stringWithFormat:@"%u", value]); }]; } -- (BOOL)valueForKey:(uint32_t)key value:(uint32_t *)value { +- (BOOL)getUInt32:(nullable uint32_t *)value forKey:(uint32_t)key { NSNumber *wrapped = [_dictionary objectForKey:@(key)]; if (wrapped && value) { *value = [wrapped unsignedIntValue]; @@ -1709,14 +1711,14 @@ void GPBDictionaryReadEntry(id mapDictionary, } } -- (void)setValue:(uint32_t)value forKey:(uint32_t)key { +- (void)setUInt32:(uint32_t)value forKey:(uint32_t)key { [_dictionary setObject:@(value) forKey:@(key)]; if (_autocreator) { GPBAutocreatedDictionaryModified(_autocreator, self); } } -- (void)removeValueForKey:(uint32_t)aKey { +- (void)removeUInt32ForKey:(uint32_t)aKey { [_dictionary removeObjectForKey:@(aKey)]; } @@ -1734,24 +1736,24 @@ void GPBDictionaryReadEntry(id mapDictionary, } + (instancetype)dictionary { - return [[[self alloc] initWithValues:NULL forKeys:NULL count:0] autorelease]; + return [[[self alloc] initWithInt32s:NULL forKeys:NULL count:0] autorelease]; } -+ (instancetype)dictionaryWithValue:(int32_t)value ++ (instancetype)dictionaryWithInt32:(int32_t)value forKey:(uint32_t)key { - // Cast is needed so the compiler knows what class we are invoking initWithValues:forKeys:count: + // Cast is needed so the compiler knows what class we are invoking initWithInt32s:forKeys:count: // on to get the type correct. - return [[(GPBUInt32Int32Dictionary*)[self alloc] initWithValues:&value + return [[(GPBUInt32Int32Dictionary*)[self alloc] initWithInt32s:&value forKeys:&key count:1] autorelease]; } -+ (instancetype)dictionaryWithValues:(const int32_t [])values ++ (instancetype)dictionaryWithInt32s:(const int32_t [])values forKeys:(const uint32_t [])keys count:(NSUInteger)count { - // Cast is needed so the compiler knows what class we are invoking initWithValues:forKeys:count: + // Cast is needed so the compiler knows what class we are invoking initWithInt32s:forKeys:count: // on to get the type correct. - return [[(GPBUInt32Int32Dictionary*)[self alloc] initWithValues:values + return [[(GPBUInt32Int32Dictionary*)[self alloc] initWithInt32s:values forKeys:keys count:count] autorelease]; } @@ -1767,10 +1769,10 @@ void GPBDictionaryReadEntry(id mapDictionary, } - (instancetype)init { - return [self initWithValues:NULL forKeys:NULL count:0]; + return [self initWithInt32s:NULL forKeys:NULL count:0]; } -- (instancetype)initWithValues:(const int32_t [])values +- (instancetype)initWithInt32s:(const int32_t [])values forKeys:(const uint32_t [])keys count:(NSUInteger)count { self = [super init]; @@ -1786,7 +1788,7 @@ void GPBDictionaryReadEntry(id mapDictionary, } - (instancetype)initWithDictionary:(GPBUInt32Int32Dictionary *)dictionary { - self = [self initWithValues:NULL forKeys:NULL count:0]; + self = [self initWithInt32s:NULL forKeys:NULL count:0]; if (self) { if (dictionary) { [_dictionary addEntriesFromDictionary:dictionary->_dictionary]; @@ -1797,7 +1799,7 @@ void GPBDictionaryReadEntry(id mapDictionary, - (instancetype)initWithCapacity:(NSUInteger)numItems { #pragma unused(numItems) - return [self initWithValues:NULL forKeys:NULL count:0]; + return [self initWithInt32s:NULL forKeys:NULL count:0]; } - (void)dealloc { @@ -1835,7 +1837,7 @@ void GPBDictionaryReadEntry(id mapDictionary, return _dictionary.count; } -- (void)enumerateKeysAndValuesUsingBlock: +- (void)enumerateKeysAndInt32sUsingBlock: (void (^)(uint32_t key, int32_t value, BOOL *stop))block { [_dictionary enumerateKeysAndObjectsUsingBlock:^(NSNumber *aKey, NSNumber *aValue, @@ -1893,13 +1895,13 @@ void GPBDictionaryReadEntry(id mapDictionary, } - (void)enumerateForTextFormat:(void (^)(id keyObj, id valueObj))block { - [self enumerateKeysAndValuesUsingBlock:^(uint32_t key, int32_t value, BOOL *stop) { + [self enumerateKeysAndInt32sUsingBlock:^(uint32_t key, int32_t value, BOOL *stop) { #pragma unused(stop) block([NSString stringWithFormat:@"%u", key], [NSString stringWithFormat:@"%d", value]); }]; } -- (BOOL)valueForKey:(uint32_t)key value:(int32_t *)value { +- (BOOL)getInt32:(nullable int32_t *)value forKey:(uint32_t)key { NSNumber *wrapped = [_dictionary objectForKey:@(key)]; if (wrapped && value) { *value = [wrapped intValue]; @@ -1916,14 +1918,14 @@ void GPBDictionaryReadEntry(id mapDictionary, } } -- (void)setValue:(int32_t)value forKey:(uint32_t)key { +- (void)setInt32:(int32_t)value forKey:(uint32_t)key { [_dictionary setObject:@(value) forKey:@(key)]; if (_autocreator) { GPBAutocreatedDictionaryModified(_autocreator, self); } } -- (void)removeValueForKey:(uint32_t)aKey { +- (void)removeInt32ForKey:(uint32_t)aKey { [_dictionary removeObjectForKey:@(aKey)]; } @@ -1941,24 +1943,24 @@ void GPBDictionaryReadEntry(id mapDictionary, } + (instancetype)dictionary { - return [[[self alloc] initWithValues:NULL forKeys:NULL count:0] autorelease]; + return [[[self alloc] initWithUInt64s:NULL forKeys:NULL count:0] autorelease]; } -+ (instancetype)dictionaryWithValue:(uint64_t)value - forKey:(uint32_t)key { - // Cast is needed so the compiler knows what class we are invoking initWithValues:forKeys:count: ++ (instancetype)dictionaryWithUInt64:(uint64_t)value + forKey:(uint32_t)key { + // Cast is needed so the compiler knows what class we are invoking initWithUInt64s:forKeys:count: // on to get the type correct. - return [[(GPBUInt32UInt64Dictionary*)[self alloc] initWithValues:&value - forKeys:&key - count:1] autorelease]; + return [[(GPBUInt32UInt64Dictionary*)[self alloc] initWithUInt64s:&value + forKeys:&key + count:1] autorelease]; } -+ (instancetype)dictionaryWithValues:(const uint64_t [])values - forKeys:(const uint32_t [])keys - count:(NSUInteger)count { - // Cast is needed so the compiler knows what class we are invoking initWithValues:forKeys:count: ++ (instancetype)dictionaryWithUInt64s:(const uint64_t [])values + forKeys:(const uint32_t [])keys + count:(NSUInteger)count { + // Cast is needed so the compiler knows what class we are invoking initWithUInt64s:forKeys:count: // on to get the type correct. - return [[(GPBUInt32UInt64Dictionary*)[self alloc] initWithValues:values + return [[(GPBUInt32UInt64Dictionary*)[self alloc] initWithUInt64s:values forKeys:keys count:count] autorelease]; } @@ -1974,12 +1976,12 @@ void GPBDictionaryReadEntry(id mapDictionary, } - (instancetype)init { - return [self initWithValues:NULL forKeys:NULL count:0]; + return [self initWithUInt64s:NULL forKeys:NULL count:0]; } -- (instancetype)initWithValues:(const uint64_t [])values - forKeys:(const uint32_t [])keys - count:(NSUInteger)count { +- (instancetype)initWithUInt64s:(const uint64_t [])values + forKeys:(const uint32_t [])keys + count:(NSUInteger)count { self = [super init]; if (self) { _dictionary = [[NSMutableDictionary alloc] init]; @@ -1993,7 +1995,7 @@ void GPBDictionaryReadEntry(id mapDictionary, } - (instancetype)initWithDictionary:(GPBUInt32UInt64Dictionary *)dictionary { - self = [self initWithValues:NULL forKeys:NULL count:0]; + self = [self initWithUInt64s:NULL forKeys:NULL count:0]; if (self) { if (dictionary) { [_dictionary addEntriesFromDictionary:dictionary->_dictionary]; @@ -2004,7 +2006,7 @@ void GPBDictionaryReadEntry(id mapDictionary, - (instancetype)initWithCapacity:(NSUInteger)numItems { #pragma unused(numItems) - return [self initWithValues:NULL forKeys:NULL count:0]; + return [self initWithUInt64s:NULL forKeys:NULL count:0]; } - (void)dealloc { @@ -2042,7 +2044,7 @@ void GPBDictionaryReadEntry(id mapDictionary, return _dictionary.count; } -- (void)enumerateKeysAndValuesUsingBlock: +- (void)enumerateKeysAndUInt64sUsingBlock: (void (^)(uint32_t key, uint64_t value, BOOL *stop))block { [_dictionary enumerateKeysAndObjectsUsingBlock:^(NSNumber *aKey, NSNumber *aValue, @@ -2100,13 +2102,13 @@ void GPBDictionaryReadEntry(id mapDictionary, } - (void)enumerateForTextFormat:(void (^)(id keyObj, id valueObj))block { - [self enumerateKeysAndValuesUsingBlock:^(uint32_t key, uint64_t value, BOOL *stop) { + [self enumerateKeysAndUInt64sUsingBlock:^(uint32_t key, uint64_t value, BOOL *stop) { #pragma unused(stop) block([NSString stringWithFormat:@"%u", key], [NSString stringWithFormat:@"%llu", value]); }]; } -- (BOOL)valueForKey:(uint32_t)key value:(uint64_t *)value { +- (BOOL)getUInt64:(nullable uint64_t *)value forKey:(uint32_t)key { NSNumber *wrapped = [_dictionary objectForKey:@(key)]; if (wrapped && value) { *value = [wrapped unsignedLongLongValue]; @@ -2123,14 +2125,14 @@ void GPBDictionaryReadEntry(id mapDictionary, } } -- (void)setValue:(uint64_t)value forKey:(uint32_t)key { +- (void)setUInt64:(uint64_t)value forKey:(uint32_t)key { [_dictionary setObject:@(value) forKey:@(key)]; if (_autocreator) { GPBAutocreatedDictionaryModified(_autocreator, self); } } -- (void)removeValueForKey:(uint32_t)aKey { +- (void)removeUInt64ForKey:(uint32_t)aKey { [_dictionary removeObjectForKey:@(aKey)]; } @@ -2148,24 +2150,24 @@ void GPBDictionaryReadEntry(id mapDictionary, } + (instancetype)dictionary { - return [[[self alloc] initWithValues:NULL forKeys:NULL count:0] autorelease]; + return [[[self alloc] initWithInt64s:NULL forKeys:NULL count:0] autorelease]; } -+ (instancetype)dictionaryWithValue:(int64_t)value ++ (instancetype)dictionaryWithInt64:(int64_t)value forKey:(uint32_t)key { - // Cast is needed so the compiler knows what class we are invoking initWithValues:forKeys:count: + // Cast is needed so the compiler knows what class we are invoking initWithInt64s:forKeys:count: // on to get the type correct. - return [[(GPBUInt32Int64Dictionary*)[self alloc] initWithValues:&value + return [[(GPBUInt32Int64Dictionary*)[self alloc] initWithInt64s:&value forKeys:&key count:1] autorelease]; } -+ (instancetype)dictionaryWithValues:(const int64_t [])values ++ (instancetype)dictionaryWithInt64s:(const int64_t [])values forKeys:(const uint32_t [])keys count:(NSUInteger)count { - // Cast is needed so the compiler knows what class we are invoking initWithValues:forKeys:count: + // Cast is needed so the compiler knows what class we are invoking initWithInt64s:forKeys:count: // on to get the type correct. - return [[(GPBUInt32Int64Dictionary*)[self alloc] initWithValues:values + return [[(GPBUInt32Int64Dictionary*)[self alloc] initWithInt64s:values forKeys:keys count:count] autorelease]; } @@ -2181,10 +2183,10 @@ void GPBDictionaryReadEntry(id mapDictionary, } - (instancetype)init { - return [self initWithValues:NULL forKeys:NULL count:0]; + return [self initWithInt64s:NULL forKeys:NULL count:0]; } -- (instancetype)initWithValues:(const int64_t [])values +- (instancetype)initWithInt64s:(const int64_t [])values forKeys:(const uint32_t [])keys count:(NSUInteger)count { self = [super init]; @@ -2200,7 +2202,7 @@ void GPBDictionaryReadEntry(id mapDictionary, } - (instancetype)initWithDictionary:(GPBUInt32Int64Dictionary *)dictionary { - self = [self initWithValues:NULL forKeys:NULL count:0]; + self = [self initWithInt64s:NULL forKeys:NULL count:0]; if (self) { if (dictionary) { [_dictionary addEntriesFromDictionary:dictionary->_dictionary]; @@ -2211,7 +2213,7 @@ void GPBDictionaryReadEntry(id mapDictionary, - (instancetype)initWithCapacity:(NSUInteger)numItems { #pragma unused(numItems) - return [self initWithValues:NULL forKeys:NULL count:0]; + return [self initWithInt64s:NULL forKeys:NULL count:0]; } - (void)dealloc { @@ -2249,7 +2251,7 @@ void GPBDictionaryReadEntry(id mapDictionary, return _dictionary.count; } -- (void)enumerateKeysAndValuesUsingBlock: +- (void)enumerateKeysAndInt64sUsingBlock: (void (^)(uint32_t key, int64_t value, BOOL *stop))block { [_dictionary enumerateKeysAndObjectsUsingBlock:^(NSNumber *aKey, NSNumber *aValue, @@ -2307,13 +2309,13 @@ void GPBDictionaryReadEntry(id mapDictionary, } - (void)enumerateForTextFormat:(void (^)(id keyObj, id valueObj))block { - [self enumerateKeysAndValuesUsingBlock:^(uint32_t key, int64_t value, BOOL *stop) { + [self enumerateKeysAndInt64sUsingBlock:^(uint32_t key, int64_t value, BOOL *stop) { #pragma unused(stop) block([NSString stringWithFormat:@"%u", key], [NSString stringWithFormat:@"%lld", value]); }]; } -- (BOOL)valueForKey:(uint32_t)key value:(int64_t *)value { +- (BOOL)getInt64:(nullable int64_t *)value forKey:(uint32_t)key { NSNumber *wrapped = [_dictionary objectForKey:@(key)]; if (wrapped && value) { *value = [wrapped longLongValue]; @@ -2330,14 +2332,14 @@ void GPBDictionaryReadEntry(id mapDictionary, } } -- (void)setValue:(int64_t)value forKey:(uint32_t)key { +- (void)setInt64:(int64_t)value forKey:(uint32_t)key { [_dictionary setObject:@(value) forKey:@(key)]; if (_autocreator) { GPBAutocreatedDictionaryModified(_autocreator, self); } } -- (void)removeValueForKey:(uint32_t)aKey { +- (void)removeInt64ForKey:(uint32_t)aKey { [_dictionary removeObjectForKey:@(aKey)]; } @@ -2355,24 +2357,24 @@ void GPBDictionaryReadEntry(id mapDictionary, } + (instancetype)dictionary { - return [[[self alloc] initWithValues:NULL forKeys:NULL count:0] autorelease]; + return [[[self alloc] initWithBools:NULL forKeys:NULL count:0] autorelease]; } -+ (instancetype)dictionaryWithValue:(BOOL)value - forKey:(uint32_t)key { - // Cast is needed so the compiler knows what class we are invoking initWithValues:forKeys:count: ++ (instancetype)dictionaryWithBool:(BOOL)value + forKey:(uint32_t)key { + // Cast is needed so the compiler knows what class we are invoking initWithBools:forKeys:count: // on to get the type correct. - return [[(GPBUInt32BoolDictionary*)[self alloc] initWithValues:&value - forKeys:&key - count:1] autorelease]; + return [[(GPBUInt32BoolDictionary*)[self alloc] initWithBools:&value + forKeys:&key + count:1] autorelease]; } -+ (instancetype)dictionaryWithValues:(const BOOL [])values - forKeys:(const uint32_t [])keys - count:(NSUInteger)count { - // Cast is needed so the compiler knows what class we are invoking initWithValues:forKeys:count: ++ (instancetype)dictionaryWithBools:(const BOOL [])values + forKeys:(const uint32_t [])keys + count:(NSUInteger)count { + // Cast is needed so the compiler knows what class we are invoking initWithBools:forKeys:count: // on to get the type correct. - return [[(GPBUInt32BoolDictionary*)[self alloc] initWithValues:values + return [[(GPBUInt32BoolDictionary*)[self alloc] initWithBools:values forKeys:keys count:count] autorelease]; } @@ -2388,12 +2390,12 @@ void GPBDictionaryReadEntry(id mapDictionary, } - (instancetype)init { - return [self initWithValues:NULL forKeys:NULL count:0]; + return [self initWithBools:NULL forKeys:NULL count:0]; } -- (instancetype)initWithValues:(const BOOL [])values - forKeys:(const uint32_t [])keys - count:(NSUInteger)count { +- (instancetype)initWithBools:(const BOOL [])values + forKeys:(const uint32_t [])keys + count:(NSUInteger)count { self = [super init]; if (self) { _dictionary = [[NSMutableDictionary alloc] init]; @@ -2407,7 +2409,7 @@ void GPBDictionaryReadEntry(id mapDictionary, } - (instancetype)initWithDictionary:(GPBUInt32BoolDictionary *)dictionary { - self = [self initWithValues:NULL forKeys:NULL count:0]; + self = [self initWithBools:NULL forKeys:NULL count:0]; if (self) { if (dictionary) { [_dictionary addEntriesFromDictionary:dictionary->_dictionary]; @@ -2418,7 +2420,7 @@ void GPBDictionaryReadEntry(id mapDictionary, - (instancetype)initWithCapacity:(NSUInteger)numItems { #pragma unused(numItems) - return [self initWithValues:NULL forKeys:NULL count:0]; + return [self initWithBools:NULL forKeys:NULL count:0]; } - (void)dealloc { @@ -2456,7 +2458,7 @@ void GPBDictionaryReadEntry(id mapDictionary, return _dictionary.count; } -- (void)enumerateKeysAndValuesUsingBlock: +- (void)enumerateKeysAndBoolsUsingBlock: (void (^)(uint32_t key, BOOL value, BOOL *stop))block { [_dictionary enumerateKeysAndObjectsUsingBlock:^(NSNumber *aKey, NSNumber *aValue, @@ -2514,13 +2516,13 @@ void GPBDictionaryReadEntry(id mapDictionary, } - (void)enumerateForTextFormat:(void (^)(id keyObj, id valueObj))block { - [self enumerateKeysAndValuesUsingBlock:^(uint32_t key, BOOL value, BOOL *stop) { + [self enumerateKeysAndBoolsUsingBlock:^(uint32_t key, BOOL value, BOOL *stop) { #pragma unused(stop) block([NSString stringWithFormat:@"%u", key], (value ? @"true" : @"false")); }]; } -- (BOOL)valueForKey:(uint32_t)key value:(BOOL *)value { +- (BOOL)getBool:(nullable BOOL *)value forKey:(uint32_t)key { NSNumber *wrapped = [_dictionary objectForKey:@(key)]; if (wrapped && value) { *value = [wrapped boolValue]; @@ -2537,14 +2539,14 @@ void GPBDictionaryReadEntry(id mapDictionary, } } -- (void)setValue:(BOOL)value forKey:(uint32_t)key { +- (void)setBool:(BOOL)value forKey:(uint32_t)key { [_dictionary setObject:@(value) forKey:@(key)]; if (_autocreator) { GPBAutocreatedDictionaryModified(_autocreator, self); } } -- (void)removeValueForKey:(uint32_t)aKey { +- (void)removeBoolForKey:(uint32_t)aKey { [_dictionary removeObjectForKey:@(aKey)]; } @@ -2562,24 +2564,24 @@ void GPBDictionaryReadEntry(id mapDictionary, } + (instancetype)dictionary { - return [[[self alloc] initWithValues:NULL forKeys:NULL count:0] autorelease]; + return [[[self alloc] initWithFloats:NULL forKeys:NULL count:0] autorelease]; } -+ (instancetype)dictionaryWithValue:(float)value ++ (instancetype)dictionaryWithFloat:(float)value forKey:(uint32_t)key { - // Cast is needed so the compiler knows what class we are invoking initWithValues:forKeys:count: + // Cast is needed so the compiler knows what class we are invoking initWithFloats:forKeys:count: // on to get the type correct. - return [[(GPBUInt32FloatDictionary*)[self alloc] initWithValues:&value + return [[(GPBUInt32FloatDictionary*)[self alloc] initWithFloats:&value forKeys:&key count:1] autorelease]; } -+ (instancetype)dictionaryWithValues:(const float [])values ++ (instancetype)dictionaryWithFloats:(const float [])values forKeys:(const uint32_t [])keys count:(NSUInteger)count { - // Cast is needed so the compiler knows what class we are invoking initWithValues:forKeys:count: + // Cast is needed so the compiler knows what class we are invoking initWithFloats:forKeys:count: // on to get the type correct. - return [[(GPBUInt32FloatDictionary*)[self alloc] initWithValues:values + return [[(GPBUInt32FloatDictionary*)[self alloc] initWithFloats:values forKeys:keys count:count] autorelease]; } @@ -2595,10 +2597,10 @@ void GPBDictionaryReadEntry(id mapDictionary, } - (instancetype)init { - return [self initWithValues:NULL forKeys:NULL count:0]; + return [self initWithFloats:NULL forKeys:NULL count:0]; } -- (instancetype)initWithValues:(const float [])values +- (instancetype)initWithFloats:(const float [])values forKeys:(const uint32_t [])keys count:(NSUInteger)count { self = [super init]; @@ -2614,7 +2616,7 @@ void GPBDictionaryReadEntry(id mapDictionary, } - (instancetype)initWithDictionary:(GPBUInt32FloatDictionary *)dictionary { - self = [self initWithValues:NULL forKeys:NULL count:0]; + self = [self initWithFloats:NULL forKeys:NULL count:0]; if (self) { if (dictionary) { [_dictionary addEntriesFromDictionary:dictionary->_dictionary]; @@ -2625,7 +2627,7 @@ void GPBDictionaryReadEntry(id mapDictionary, - (instancetype)initWithCapacity:(NSUInteger)numItems { #pragma unused(numItems) - return [self initWithValues:NULL forKeys:NULL count:0]; + return [self initWithFloats:NULL forKeys:NULL count:0]; } - (void)dealloc { @@ -2663,7 +2665,7 @@ void GPBDictionaryReadEntry(id mapDictionary, return _dictionary.count; } -- (void)enumerateKeysAndValuesUsingBlock: +- (void)enumerateKeysAndFloatsUsingBlock: (void (^)(uint32_t key, float value, BOOL *stop))block { [_dictionary enumerateKeysAndObjectsUsingBlock:^(NSNumber *aKey, NSNumber *aValue, @@ -2721,13 +2723,13 @@ void GPBDictionaryReadEntry(id mapDictionary, } - (void)enumerateForTextFormat:(void (^)(id keyObj, id valueObj))block { - [self enumerateKeysAndValuesUsingBlock:^(uint32_t key, float value, BOOL *stop) { + [self enumerateKeysAndFloatsUsingBlock:^(uint32_t key, float value, BOOL *stop) { #pragma unused(stop) block([NSString stringWithFormat:@"%u", key], [NSString stringWithFormat:@"%.*g", FLT_DIG, value]); }]; } -- (BOOL)valueForKey:(uint32_t)key value:(float *)value { +- (BOOL)getFloat:(nullable float *)value forKey:(uint32_t)key { NSNumber *wrapped = [_dictionary objectForKey:@(key)]; if (wrapped && value) { *value = [wrapped floatValue]; @@ -2744,14 +2746,14 @@ void GPBDictionaryReadEntry(id mapDictionary, } } -- (void)setValue:(float)value forKey:(uint32_t)key { +- (void)setFloat:(float)value forKey:(uint32_t)key { [_dictionary setObject:@(value) forKey:@(key)]; if (_autocreator) { GPBAutocreatedDictionaryModified(_autocreator, self); } } -- (void)removeValueForKey:(uint32_t)aKey { +- (void)removeFloatForKey:(uint32_t)aKey { [_dictionary removeObjectForKey:@(aKey)]; } @@ -2769,24 +2771,24 @@ void GPBDictionaryReadEntry(id mapDictionary, } + (instancetype)dictionary { - return [[[self alloc] initWithValues:NULL forKeys:NULL count:0] autorelease]; + return [[[self alloc] initWithDoubles:NULL forKeys:NULL count:0] autorelease]; } -+ (instancetype)dictionaryWithValue:(double)value - forKey:(uint32_t)key { - // Cast is needed so the compiler knows what class we are invoking initWithValues:forKeys:count: ++ (instancetype)dictionaryWithDouble:(double)value + forKey:(uint32_t)key { + // Cast is needed so the compiler knows what class we are invoking initWithDoubles:forKeys:count: // on to get the type correct. - return [[(GPBUInt32DoubleDictionary*)[self alloc] initWithValues:&value - forKeys:&key - count:1] autorelease]; + return [[(GPBUInt32DoubleDictionary*)[self alloc] initWithDoubles:&value + forKeys:&key + count:1] autorelease]; } -+ (instancetype)dictionaryWithValues:(const double [])values - forKeys:(const uint32_t [])keys - count:(NSUInteger)count { - // Cast is needed so the compiler knows what class we are invoking initWithValues:forKeys:count: ++ (instancetype)dictionaryWithDoubles:(const double [])values + forKeys:(const uint32_t [])keys + count:(NSUInteger)count { + // Cast is needed so the compiler knows what class we are invoking initWithDoubles:forKeys:count: // on to get the type correct. - return [[(GPBUInt32DoubleDictionary*)[self alloc] initWithValues:values + return [[(GPBUInt32DoubleDictionary*)[self alloc] initWithDoubles:values forKeys:keys count:count] autorelease]; } @@ -2802,12 +2804,12 @@ void GPBDictionaryReadEntry(id mapDictionary, } - (instancetype)init { - return [self initWithValues:NULL forKeys:NULL count:0]; + return [self initWithDoubles:NULL forKeys:NULL count:0]; } -- (instancetype)initWithValues:(const double [])values - forKeys:(const uint32_t [])keys - count:(NSUInteger)count { +- (instancetype)initWithDoubles:(const double [])values + forKeys:(const uint32_t [])keys + count:(NSUInteger)count { self = [super init]; if (self) { _dictionary = [[NSMutableDictionary alloc] init]; @@ -2821,7 +2823,7 @@ void GPBDictionaryReadEntry(id mapDictionary, } - (instancetype)initWithDictionary:(GPBUInt32DoubleDictionary *)dictionary { - self = [self initWithValues:NULL forKeys:NULL count:0]; + self = [self initWithDoubles:NULL forKeys:NULL count:0]; if (self) { if (dictionary) { [_dictionary addEntriesFromDictionary:dictionary->_dictionary]; @@ -2832,7 +2834,7 @@ void GPBDictionaryReadEntry(id mapDictionary, - (instancetype)initWithCapacity:(NSUInteger)numItems { #pragma unused(numItems) - return [self initWithValues:NULL forKeys:NULL count:0]; + return [self initWithDoubles:NULL forKeys:NULL count:0]; } - (void)dealloc { @@ -2870,7 +2872,7 @@ void GPBDictionaryReadEntry(id mapDictionary, return _dictionary.count; } -- (void)enumerateKeysAndValuesUsingBlock: +- (void)enumerateKeysAndDoublesUsingBlock: (void (^)(uint32_t key, double value, BOOL *stop))block { [_dictionary enumerateKeysAndObjectsUsingBlock:^(NSNumber *aKey, NSNumber *aValue, @@ -2928,13 +2930,13 @@ void GPBDictionaryReadEntry(id mapDictionary, } - (void)enumerateForTextFormat:(void (^)(id keyObj, id valueObj))block { - [self enumerateKeysAndValuesUsingBlock:^(uint32_t key, double value, BOOL *stop) { + [self enumerateKeysAndDoublesUsingBlock:^(uint32_t key, double value, BOOL *stop) { #pragma unused(stop) block([NSString stringWithFormat:@"%u", key], [NSString stringWithFormat:@"%.*lg", DBL_DIG, value]); }]; } -- (BOOL)valueForKey:(uint32_t)key value:(double *)value { +- (BOOL)getDouble:(nullable double *)value forKey:(uint32_t)key { NSNumber *wrapped = [_dictionary objectForKey:@(key)]; if (wrapped && value) { *value = [wrapped doubleValue]; @@ -2951,14 +2953,14 @@ void GPBDictionaryReadEntry(id mapDictionary, } } -- (void)setValue:(double)value forKey:(uint32_t)key { +- (void)setDouble:(double)value forKey:(uint32_t)key { [_dictionary setObject:@(value) forKey:@(key)]; if (_autocreator) { GPBAutocreatedDictionaryModified(_autocreator, self); } } -- (void)removeValueForKey:(uint32_t)aKey { +- (void)removeDoubleForKey:(uint32_t)aKey { [_dictionary removeObjectForKey:@(aKey)]; } @@ -3181,7 +3183,7 @@ void GPBDictionaryReadEntry(id mapDictionary, }]; } -- (BOOL)valueForKey:(uint32_t)key value:(int32_t *)value { +- (BOOL)getEnum:(int32_t *)value forKey:(uint32_t)key { NSNumber *wrapped = [_dictionary objectForKey:@(key)]; if (wrapped && value) { int32_t result = [wrapped intValue]; @@ -3193,7 +3195,7 @@ void GPBDictionaryReadEntry(id mapDictionary, return (wrapped != NULL); } -- (BOOL)valueForKey:(uint32_t)key rawValue:(int32_t *)rawValue { +- (BOOL)getRawValue:(int32_t *)rawValue forKey:(uint32_t)key { NSNumber *wrapped = [_dictionary objectForKey:@(key)]; if (wrapped && rawValue) { *rawValue = [wrapped intValue]; @@ -3201,7 +3203,7 @@ void GPBDictionaryReadEntry(id mapDictionary, return (wrapped != NULL); } -- (void)enumerateKeysAndValuesUsingBlock: +- (void)enumerateKeysAndEnumsUsingBlock: (void (^)(uint32_t key, int32_t value, BOOL *stop))block { GPBEnumValidationFunc func = _validationFunc; [_dictionary enumerateKeysAndObjectsUsingBlock:^(NSNumber *aKey, @@ -3231,7 +3233,7 @@ void GPBDictionaryReadEntry(id mapDictionary, } } -- (void)removeValueForKey:(uint32_t)aKey { +- (void)removeEnumForKey:(uint32_t)aKey { [_dictionary removeObjectForKey:@(aKey)]; } @@ -3239,7 +3241,7 @@ void GPBDictionaryReadEntry(id mapDictionary, [_dictionary removeAllObjects]; } -- (void)setValue:(int32_t)value forKey:(uint32_t)key { +- (void)setEnum:(int32_t)value forKey:(uint32_t)key { if (!_validationFunc(value)) { [NSException raise:NSInvalidArgumentException format:@"GPBUInt32EnumDictionary: Attempt to set an unknown enum value (%d)", @@ -3500,24 +3502,24 @@ void GPBDictionaryReadEntry(id mapDictionary, } + (instancetype)dictionary { - return [[[self alloc] initWithValues:NULL forKeys:NULL count:0] autorelease]; + return [[[self alloc] initWithUInt32s:NULL forKeys:NULL count:0] autorelease]; } -+ (instancetype)dictionaryWithValue:(uint32_t)value - forKey:(int32_t)key { - // Cast is needed so the compiler knows what class we are invoking initWithValues:forKeys:count: ++ (instancetype)dictionaryWithUInt32:(uint32_t)value + forKey:(int32_t)key { + // Cast is needed so the compiler knows what class we are invoking initWithUInt32s:forKeys:count: // on to get the type correct. - return [[(GPBInt32UInt32Dictionary*)[self alloc] initWithValues:&value - forKeys:&key - count:1] autorelease]; + return [[(GPBInt32UInt32Dictionary*)[self alloc] initWithUInt32s:&value + forKeys:&key + count:1] autorelease]; } -+ (instancetype)dictionaryWithValues:(const uint32_t [])values - forKeys:(const int32_t [])keys - count:(NSUInteger)count { - // Cast is needed so the compiler knows what class we are invoking initWithValues:forKeys:count: ++ (instancetype)dictionaryWithUInt32s:(const uint32_t [])values + forKeys:(const int32_t [])keys + count:(NSUInteger)count { + // Cast is needed so the compiler knows what class we are invoking initWithUInt32s:forKeys:count: // on to get the type correct. - return [[(GPBInt32UInt32Dictionary*)[self alloc] initWithValues:values + return [[(GPBInt32UInt32Dictionary*)[self alloc] initWithUInt32s:values forKeys:keys count:count] autorelease]; } @@ -3533,12 +3535,12 @@ void GPBDictionaryReadEntry(id mapDictionary, } - (instancetype)init { - return [self initWithValues:NULL forKeys:NULL count:0]; + return [self initWithUInt32s:NULL forKeys:NULL count:0]; } -- (instancetype)initWithValues:(const uint32_t [])values - forKeys:(const int32_t [])keys - count:(NSUInteger)count { +- (instancetype)initWithUInt32s:(const uint32_t [])values + forKeys:(const int32_t [])keys + count:(NSUInteger)count { self = [super init]; if (self) { _dictionary = [[NSMutableDictionary alloc] init]; @@ -3552,7 +3554,7 @@ void GPBDictionaryReadEntry(id mapDictionary, } - (instancetype)initWithDictionary:(GPBInt32UInt32Dictionary *)dictionary { - self = [self initWithValues:NULL forKeys:NULL count:0]; + self = [self initWithUInt32s:NULL forKeys:NULL count:0]; if (self) { if (dictionary) { [_dictionary addEntriesFromDictionary:dictionary->_dictionary]; @@ -3563,7 +3565,7 @@ void GPBDictionaryReadEntry(id mapDictionary, - (instancetype)initWithCapacity:(NSUInteger)numItems { #pragma unused(numItems) - return [self initWithValues:NULL forKeys:NULL count:0]; + return [self initWithUInt32s:NULL forKeys:NULL count:0]; } - (void)dealloc { @@ -3601,7 +3603,7 @@ void GPBDictionaryReadEntry(id mapDictionary, return _dictionary.count; } -- (void)enumerateKeysAndValuesUsingBlock: +- (void)enumerateKeysAndUInt32sUsingBlock: (void (^)(int32_t key, uint32_t value, BOOL *stop))block { [_dictionary enumerateKeysAndObjectsUsingBlock:^(NSNumber *aKey, NSNumber *aValue, @@ -3659,13 +3661,13 @@ void GPBDictionaryReadEntry(id mapDictionary, } - (void)enumerateForTextFormat:(void (^)(id keyObj, id valueObj))block { - [self enumerateKeysAndValuesUsingBlock:^(int32_t key, uint32_t value, BOOL *stop) { + [self enumerateKeysAndUInt32sUsingBlock:^(int32_t key, uint32_t value, BOOL *stop) { #pragma unused(stop) block([NSString stringWithFormat:@"%d", key], [NSString stringWithFormat:@"%u", value]); }]; } -- (BOOL)valueForKey:(int32_t)key value:(uint32_t *)value { +- (BOOL)getUInt32:(nullable uint32_t *)value forKey:(int32_t)key { NSNumber *wrapped = [_dictionary objectForKey:@(key)]; if (wrapped && value) { *value = [wrapped unsignedIntValue]; @@ -3682,14 +3684,14 @@ void GPBDictionaryReadEntry(id mapDictionary, } } -- (void)setValue:(uint32_t)value forKey:(int32_t)key { +- (void)setUInt32:(uint32_t)value forKey:(int32_t)key { [_dictionary setObject:@(value) forKey:@(key)]; if (_autocreator) { GPBAutocreatedDictionaryModified(_autocreator, self); } } -- (void)removeValueForKey:(int32_t)aKey { +- (void)removeUInt32ForKey:(int32_t)aKey { [_dictionary removeObjectForKey:@(aKey)]; } @@ -3707,24 +3709,24 @@ void GPBDictionaryReadEntry(id mapDictionary, } + (instancetype)dictionary { - return [[[self alloc] initWithValues:NULL forKeys:NULL count:0] autorelease]; + return [[[self alloc] initWithInt32s:NULL forKeys:NULL count:0] autorelease]; } -+ (instancetype)dictionaryWithValue:(int32_t)value ++ (instancetype)dictionaryWithInt32:(int32_t)value forKey:(int32_t)key { - // Cast is needed so the compiler knows what class we are invoking initWithValues:forKeys:count: + // Cast is needed so the compiler knows what class we are invoking initWithInt32s:forKeys:count: // on to get the type correct. - return [[(GPBInt32Int32Dictionary*)[self alloc] initWithValues:&value + return [[(GPBInt32Int32Dictionary*)[self alloc] initWithInt32s:&value forKeys:&key count:1] autorelease]; } -+ (instancetype)dictionaryWithValues:(const int32_t [])values ++ (instancetype)dictionaryWithInt32s:(const int32_t [])values forKeys:(const int32_t [])keys count:(NSUInteger)count { - // Cast is needed so the compiler knows what class we are invoking initWithValues:forKeys:count: + // Cast is needed so the compiler knows what class we are invoking initWithInt32s:forKeys:count: // on to get the type correct. - return [[(GPBInt32Int32Dictionary*)[self alloc] initWithValues:values + return [[(GPBInt32Int32Dictionary*)[self alloc] initWithInt32s:values forKeys:keys count:count] autorelease]; } @@ -3740,10 +3742,10 @@ void GPBDictionaryReadEntry(id mapDictionary, } - (instancetype)init { - return [self initWithValues:NULL forKeys:NULL count:0]; + return [self initWithInt32s:NULL forKeys:NULL count:0]; } -- (instancetype)initWithValues:(const int32_t [])values +- (instancetype)initWithInt32s:(const int32_t [])values forKeys:(const int32_t [])keys count:(NSUInteger)count { self = [super init]; @@ -3759,7 +3761,7 @@ void GPBDictionaryReadEntry(id mapDictionary, } - (instancetype)initWithDictionary:(GPBInt32Int32Dictionary *)dictionary { - self = [self initWithValues:NULL forKeys:NULL count:0]; + self = [self initWithInt32s:NULL forKeys:NULL count:0]; if (self) { if (dictionary) { [_dictionary addEntriesFromDictionary:dictionary->_dictionary]; @@ -3770,7 +3772,7 @@ void GPBDictionaryReadEntry(id mapDictionary, - (instancetype)initWithCapacity:(NSUInteger)numItems { #pragma unused(numItems) - return [self initWithValues:NULL forKeys:NULL count:0]; + return [self initWithInt32s:NULL forKeys:NULL count:0]; } - (void)dealloc { @@ -3808,7 +3810,7 @@ void GPBDictionaryReadEntry(id mapDictionary, return _dictionary.count; } -- (void)enumerateKeysAndValuesUsingBlock: +- (void)enumerateKeysAndInt32sUsingBlock: (void (^)(int32_t key, int32_t value, BOOL *stop))block { [_dictionary enumerateKeysAndObjectsUsingBlock:^(NSNumber *aKey, NSNumber *aValue, @@ -3866,13 +3868,13 @@ void GPBDictionaryReadEntry(id mapDictionary, } - (void)enumerateForTextFormat:(void (^)(id keyObj, id valueObj))block { - [self enumerateKeysAndValuesUsingBlock:^(int32_t key, int32_t value, BOOL *stop) { + [self enumerateKeysAndInt32sUsingBlock:^(int32_t key, int32_t value, BOOL *stop) { #pragma unused(stop) block([NSString stringWithFormat:@"%d", key], [NSString stringWithFormat:@"%d", value]); }]; } -- (BOOL)valueForKey:(int32_t)key value:(int32_t *)value { +- (BOOL)getInt32:(nullable int32_t *)value forKey:(int32_t)key { NSNumber *wrapped = [_dictionary objectForKey:@(key)]; if (wrapped && value) { *value = [wrapped intValue]; @@ -3889,14 +3891,14 @@ void GPBDictionaryReadEntry(id mapDictionary, } } -- (void)setValue:(int32_t)value forKey:(int32_t)key { +- (void)setInt32:(int32_t)value forKey:(int32_t)key { [_dictionary setObject:@(value) forKey:@(key)]; if (_autocreator) { GPBAutocreatedDictionaryModified(_autocreator, self); } } -- (void)removeValueForKey:(int32_t)aKey { +- (void)removeInt32ForKey:(int32_t)aKey { [_dictionary removeObjectForKey:@(aKey)]; } @@ -3914,24 +3916,24 @@ void GPBDictionaryReadEntry(id mapDictionary, } + (instancetype)dictionary { - return [[[self alloc] initWithValues:NULL forKeys:NULL count:0] autorelease]; + return [[[self alloc] initWithUInt64s:NULL forKeys:NULL count:0] autorelease]; } -+ (instancetype)dictionaryWithValue:(uint64_t)value - forKey:(int32_t)key { - // Cast is needed so the compiler knows what class we are invoking initWithValues:forKeys:count: ++ (instancetype)dictionaryWithUInt64:(uint64_t)value + forKey:(int32_t)key { + // Cast is needed so the compiler knows what class we are invoking initWithUInt64s:forKeys:count: // on to get the type correct. - return [[(GPBInt32UInt64Dictionary*)[self alloc] initWithValues:&value - forKeys:&key - count:1] autorelease]; + return [[(GPBInt32UInt64Dictionary*)[self alloc] initWithUInt64s:&value + forKeys:&key + count:1] autorelease]; } -+ (instancetype)dictionaryWithValues:(const uint64_t [])values - forKeys:(const int32_t [])keys - count:(NSUInteger)count { - // Cast is needed so the compiler knows what class we are invoking initWithValues:forKeys:count: ++ (instancetype)dictionaryWithUInt64s:(const uint64_t [])values + forKeys:(const int32_t [])keys + count:(NSUInteger)count { + // Cast is needed so the compiler knows what class we are invoking initWithUInt64s:forKeys:count: // on to get the type correct. - return [[(GPBInt32UInt64Dictionary*)[self alloc] initWithValues:values + return [[(GPBInt32UInt64Dictionary*)[self alloc] initWithUInt64s:values forKeys:keys count:count] autorelease]; } @@ -3947,12 +3949,12 @@ void GPBDictionaryReadEntry(id mapDictionary, } - (instancetype)init { - return [self initWithValues:NULL forKeys:NULL count:0]; + return [self initWithUInt64s:NULL forKeys:NULL count:0]; } -- (instancetype)initWithValues:(const uint64_t [])values - forKeys:(const int32_t [])keys - count:(NSUInteger)count { +- (instancetype)initWithUInt64s:(const uint64_t [])values + forKeys:(const int32_t [])keys + count:(NSUInteger)count { self = [super init]; if (self) { _dictionary = [[NSMutableDictionary alloc] init]; @@ -3966,7 +3968,7 @@ void GPBDictionaryReadEntry(id mapDictionary, } - (instancetype)initWithDictionary:(GPBInt32UInt64Dictionary *)dictionary { - self = [self initWithValues:NULL forKeys:NULL count:0]; + self = [self initWithUInt64s:NULL forKeys:NULL count:0]; if (self) { if (dictionary) { [_dictionary addEntriesFromDictionary:dictionary->_dictionary]; @@ -3977,7 +3979,7 @@ void GPBDictionaryReadEntry(id mapDictionary, - (instancetype)initWithCapacity:(NSUInteger)numItems { #pragma unused(numItems) - return [self initWithValues:NULL forKeys:NULL count:0]; + return [self initWithUInt64s:NULL forKeys:NULL count:0]; } - (void)dealloc { @@ -4015,7 +4017,7 @@ void GPBDictionaryReadEntry(id mapDictionary, return _dictionary.count; } -- (void)enumerateKeysAndValuesUsingBlock: +- (void)enumerateKeysAndUInt64sUsingBlock: (void (^)(int32_t key, uint64_t value, BOOL *stop))block { [_dictionary enumerateKeysAndObjectsUsingBlock:^(NSNumber *aKey, NSNumber *aValue, @@ -4073,13 +4075,13 @@ void GPBDictionaryReadEntry(id mapDictionary, } - (void)enumerateForTextFormat:(void (^)(id keyObj, id valueObj))block { - [self enumerateKeysAndValuesUsingBlock:^(int32_t key, uint64_t value, BOOL *stop) { + [self enumerateKeysAndUInt64sUsingBlock:^(int32_t key, uint64_t value, BOOL *stop) { #pragma unused(stop) block([NSString stringWithFormat:@"%d", key], [NSString stringWithFormat:@"%llu", value]); }]; } -- (BOOL)valueForKey:(int32_t)key value:(uint64_t *)value { +- (BOOL)getUInt64:(nullable uint64_t *)value forKey:(int32_t)key { NSNumber *wrapped = [_dictionary objectForKey:@(key)]; if (wrapped && value) { *value = [wrapped unsignedLongLongValue]; @@ -4096,14 +4098,14 @@ void GPBDictionaryReadEntry(id mapDictionary, } } -- (void)setValue:(uint64_t)value forKey:(int32_t)key { +- (void)setUInt64:(uint64_t)value forKey:(int32_t)key { [_dictionary setObject:@(value) forKey:@(key)]; if (_autocreator) { GPBAutocreatedDictionaryModified(_autocreator, self); } } -- (void)removeValueForKey:(int32_t)aKey { +- (void)removeUInt64ForKey:(int32_t)aKey { [_dictionary removeObjectForKey:@(aKey)]; } @@ -4121,24 +4123,24 @@ void GPBDictionaryReadEntry(id mapDictionary, } + (instancetype)dictionary { - return [[[self alloc] initWithValues:NULL forKeys:NULL count:0] autorelease]; + return [[[self alloc] initWithInt64s:NULL forKeys:NULL count:0] autorelease]; } -+ (instancetype)dictionaryWithValue:(int64_t)value ++ (instancetype)dictionaryWithInt64:(int64_t)value forKey:(int32_t)key { - // Cast is needed so the compiler knows what class we are invoking initWithValues:forKeys:count: + // Cast is needed so the compiler knows what class we are invoking initWithInt64s:forKeys:count: // on to get the type correct. - return [[(GPBInt32Int64Dictionary*)[self alloc] initWithValues:&value + return [[(GPBInt32Int64Dictionary*)[self alloc] initWithInt64s:&value forKeys:&key count:1] autorelease]; } -+ (instancetype)dictionaryWithValues:(const int64_t [])values ++ (instancetype)dictionaryWithInt64s:(const int64_t [])values forKeys:(const int32_t [])keys count:(NSUInteger)count { - // Cast is needed so the compiler knows what class we are invoking initWithValues:forKeys:count: + // Cast is needed so the compiler knows what class we are invoking initWithInt64s:forKeys:count: // on to get the type correct. - return [[(GPBInt32Int64Dictionary*)[self alloc] initWithValues:values + return [[(GPBInt32Int64Dictionary*)[self alloc] initWithInt64s:values forKeys:keys count:count] autorelease]; } @@ -4154,10 +4156,10 @@ void GPBDictionaryReadEntry(id mapDictionary, } - (instancetype)init { - return [self initWithValues:NULL forKeys:NULL count:0]; + return [self initWithInt64s:NULL forKeys:NULL count:0]; } -- (instancetype)initWithValues:(const int64_t [])values +- (instancetype)initWithInt64s:(const int64_t [])values forKeys:(const int32_t [])keys count:(NSUInteger)count { self = [super init]; @@ -4173,7 +4175,7 @@ void GPBDictionaryReadEntry(id mapDictionary, } - (instancetype)initWithDictionary:(GPBInt32Int64Dictionary *)dictionary { - self = [self initWithValues:NULL forKeys:NULL count:0]; + self = [self initWithInt64s:NULL forKeys:NULL count:0]; if (self) { if (dictionary) { [_dictionary addEntriesFromDictionary:dictionary->_dictionary]; @@ -4184,7 +4186,7 @@ void GPBDictionaryReadEntry(id mapDictionary, - (instancetype)initWithCapacity:(NSUInteger)numItems { #pragma unused(numItems) - return [self initWithValues:NULL forKeys:NULL count:0]; + return [self initWithInt64s:NULL forKeys:NULL count:0]; } - (void)dealloc { @@ -4222,7 +4224,7 @@ void GPBDictionaryReadEntry(id mapDictionary, return _dictionary.count; } -- (void)enumerateKeysAndValuesUsingBlock: +- (void)enumerateKeysAndInt64sUsingBlock: (void (^)(int32_t key, int64_t value, BOOL *stop))block { [_dictionary enumerateKeysAndObjectsUsingBlock:^(NSNumber *aKey, NSNumber *aValue, @@ -4280,13 +4282,13 @@ void GPBDictionaryReadEntry(id mapDictionary, } - (void)enumerateForTextFormat:(void (^)(id keyObj, id valueObj))block { - [self enumerateKeysAndValuesUsingBlock:^(int32_t key, int64_t value, BOOL *stop) { + [self enumerateKeysAndInt64sUsingBlock:^(int32_t key, int64_t value, BOOL *stop) { #pragma unused(stop) block([NSString stringWithFormat:@"%d", key], [NSString stringWithFormat:@"%lld", value]); }]; } -- (BOOL)valueForKey:(int32_t)key value:(int64_t *)value { +- (BOOL)getInt64:(nullable int64_t *)value forKey:(int32_t)key { NSNumber *wrapped = [_dictionary objectForKey:@(key)]; if (wrapped && value) { *value = [wrapped longLongValue]; @@ -4303,14 +4305,14 @@ void GPBDictionaryReadEntry(id mapDictionary, } } -- (void)setValue:(int64_t)value forKey:(int32_t)key { +- (void)setInt64:(int64_t)value forKey:(int32_t)key { [_dictionary setObject:@(value) forKey:@(key)]; if (_autocreator) { GPBAutocreatedDictionaryModified(_autocreator, self); } } -- (void)removeValueForKey:(int32_t)aKey { +- (void)removeInt64ForKey:(int32_t)aKey { [_dictionary removeObjectForKey:@(aKey)]; } @@ -4328,24 +4330,24 @@ void GPBDictionaryReadEntry(id mapDictionary, } + (instancetype)dictionary { - return [[[self alloc] initWithValues:NULL forKeys:NULL count:0] autorelease]; + return [[[self alloc] initWithBools:NULL forKeys:NULL count:0] autorelease]; } -+ (instancetype)dictionaryWithValue:(BOOL)value - forKey:(int32_t)key { - // Cast is needed so the compiler knows what class we are invoking initWithValues:forKeys:count: ++ (instancetype)dictionaryWithBool:(BOOL)value + forKey:(int32_t)key { + // Cast is needed so the compiler knows what class we are invoking initWithBools:forKeys:count: // on to get the type correct. - return [[(GPBInt32BoolDictionary*)[self alloc] initWithValues:&value - forKeys:&key - count:1] autorelease]; + return [[(GPBInt32BoolDictionary*)[self alloc] initWithBools:&value + forKeys:&key + count:1] autorelease]; } -+ (instancetype)dictionaryWithValues:(const BOOL [])values - forKeys:(const int32_t [])keys - count:(NSUInteger)count { - // Cast is needed so the compiler knows what class we are invoking initWithValues:forKeys:count: ++ (instancetype)dictionaryWithBools:(const BOOL [])values + forKeys:(const int32_t [])keys + count:(NSUInteger)count { + // Cast is needed so the compiler knows what class we are invoking initWithBools:forKeys:count: // on to get the type correct. - return [[(GPBInt32BoolDictionary*)[self alloc] initWithValues:values + return [[(GPBInt32BoolDictionary*)[self alloc] initWithBools:values forKeys:keys count:count] autorelease]; } @@ -4361,12 +4363,12 @@ void GPBDictionaryReadEntry(id mapDictionary, } - (instancetype)init { - return [self initWithValues:NULL forKeys:NULL count:0]; + return [self initWithBools:NULL forKeys:NULL count:0]; } -- (instancetype)initWithValues:(const BOOL [])values - forKeys:(const int32_t [])keys - count:(NSUInteger)count { +- (instancetype)initWithBools:(const BOOL [])values + forKeys:(const int32_t [])keys + count:(NSUInteger)count { self = [super init]; if (self) { _dictionary = [[NSMutableDictionary alloc] init]; @@ -4380,7 +4382,7 @@ void GPBDictionaryReadEntry(id mapDictionary, } - (instancetype)initWithDictionary:(GPBInt32BoolDictionary *)dictionary { - self = [self initWithValues:NULL forKeys:NULL count:0]; + self = [self initWithBools:NULL forKeys:NULL count:0]; if (self) { if (dictionary) { [_dictionary addEntriesFromDictionary:dictionary->_dictionary]; @@ -4391,7 +4393,7 @@ void GPBDictionaryReadEntry(id mapDictionary, - (instancetype)initWithCapacity:(NSUInteger)numItems { #pragma unused(numItems) - return [self initWithValues:NULL forKeys:NULL count:0]; + return [self initWithBools:NULL forKeys:NULL count:0]; } - (void)dealloc { @@ -4429,7 +4431,7 @@ void GPBDictionaryReadEntry(id mapDictionary, return _dictionary.count; } -- (void)enumerateKeysAndValuesUsingBlock: +- (void)enumerateKeysAndBoolsUsingBlock: (void (^)(int32_t key, BOOL value, BOOL *stop))block { [_dictionary enumerateKeysAndObjectsUsingBlock:^(NSNumber *aKey, NSNumber *aValue, @@ -4487,13 +4489,13 @@ void GPBDictionaryReadEntry(id mapDictionary, } - (void)enumerateForTextFormat:(void (^)(id keyObj, id valueObj))block { - [self enumerateKeysAndValuesUsingBlock:^(int32_t key, BOOL value, BOOL *stop) { + [self enumerateKeysAndBoolsUsingBlock:^(int32_t key, BOOL value, BOOL *stop) { #pragma unused(stop) block([NSString stringWithFormat:@"%d", key], (value ? @"true" : @"false")); }]; } -- (BOOL)valueForKey:(int32_t)key value:(BOOL *)value { +- (BOOL)getBool:(nullable BOOL *)value forKey:(int32_t)key { NSNumber *wrapped = [_dictionary objectForKey:@(key)]; if (wrapped && value) { *value = [wrapped boolValue]; @@ -4510,14 +4512,14 @@ void GPBDictionaryReadEntry(id mapDictionary, } } -- (void)setValue:(BOOL)value forKey:(int32_t)key { +- (void)setBool:(BOOL)value forKey:(int32_t)key { [_dictionary setObject:@(value) forKey:@(key)]; if (_autocreator) { GPBAutocreatedDictionaryModified(_autocreator, self); } } -- (void)removeValueForKey:(int32_t)aKey { +- (void)removeBoolForKey:(int32_t)aKey { [_dictionary removeObjectForKey:@(aKey)]; } @@ -4535,24 +4537,24 @@ void GPBDictionaryReadEntry(id mapDictionary, } + (instancetype)dictionary { - return [[[self alloc] initWithValues:NULL forKeys:NULL count:0] autorelease]; + return [[[self alloc] initWithFloats:NULL forKeys:NULL count:0] autorelease]; } -+ (instancetype)dictionaryWithValue:(float)value ++ (instancetype)dictionaryWithFloat:(float)value forKey:(int32_t)key { - // Cast is needed so the compiler knows what class we are invoking initWithValues:forKeys:count: + // Cast is needed so the compiler knows what class we are invoking initWithFloats:forKeys:count: // on to get the type correct. - return [[(GPBInt32FloatDictionary*)[self alloc] initWithValues:&value + return [[(GPBInt32FloatDictionary*)[self alloc] initWithFloats:&value forKeys:&key count:1] autorelease]; } -+ (instancetype)dictionaryWithValues:(const float [])values ++ (instancetype)dictionaryWithFloats:(const float [])values forKeys:(const int32_t [])keys count:(NSUInteger)count { - // Cast is needed so the compiler knows what class we are invoking initWithValues:forKeys:count: + // Cast is needed so the compiler knows what class we are invoking initWithFloats:forKeys:count: // on to get the type correct. - return [[(GPBInt32FloatDictionary*)[self alloc] initWithValues:values + return [[(GPBInt32FloatDictionary*)[self alloc] initWithFloats:values forKeys:keys count:count] autorelease]; } @@ -4568,10 +4570,10 @@ void GPBDictionaryReadEntry(id mapDictionary, } - (instancetype)init { - return [self initWithValues:NULL forKeys:NULL count:0]; + return [self initWithFloats:NULL forKeys:NULL count:0]; } -- (instancetype)initWithValues:(const float [])values +- (instancetype)initWithFloats:(const float [])values forKeys:(const int32_t [])keys count:(NSUInteger)count { self = [super init]; @@ -4587,7 +4589,7 @@ void GPBDictionaryReadEntry(id mapDictionary, } - (instancetype)initWithDictionary:(GPBInt32FloatDictionary *)dictionary { - self = [self initWithValues:NULL forKeys:NULL count:0]; + self = [self initWithFloats:NULL forKeys:NULL count:0]; if (self) { if (dictionary) { [_dictionary addEntriesFromDictionary:dictionary->_dictionary]; @@ -4598,7 +4600,7 @@ void GPBDictionaryReadEntry(id mapDictionary, - (instancetype)initWithCapacity:(NSUInteger)numItems { #pragma unused(numItems) - return [self initWithValues:NULL forKeys:NULL count:0]; + return [self initWithFloats:NULL forKeys:NULL count:0]; } - (void)dealloc { @@ -4636,7 +4638,7 @@ void GPBDictionaryReadEntry(id mapDictionary, return _dictionary.count; } -- (void)enumerateKeysAndValuesUsingBlock: +- (void)enumerateKeysAndFloatsUsingBlock: (void (^)(int32_t key, float value, BOOL *stop))block { [_dictionary enumerateKeysAndObjectsUsingBlock:^(NSNumber *aKey, NSNumber *aValue, @@ -4694,13 +4696,13 @@ void GPBDictionaryReadEntry(id mapDictionary, } - (void)enumerateForTextFormat:(void (^)(id keyObj, id valueObj))block { - [self enumerateKeysAndValuesUsingBlock:^(int32_t key, float value, BOOL *stop) { + [self enumerateKeysAndFloatsUsingBlock:^(int32_t key, float value, BOOL *stop) { #pragma unused(stop) block([NSString stringWithFormat:@"%d", key], [NSString stringWithFormat:@"%.*g", FLT_DIG, value]); }]; } -- (BOOL)valueForKey:(int32_t)key value:(float *)value { +- (BOOL)getFloat:(nullable float *)value forKey:(int32_t)key { NSNumber *wrapped = [_dictionary objectForKey:@(key)]; if (wrapped && value) { *value = [wrapped floatValue]; @@ -4717,14 +4719,14 @@ void GPBDictionaryReadEntry(id mapDictionary, } } -- (void)setValue:(float)value forKey:(int32_t)key { +- (void)setFloat:(float)value forKey:(int32_t)key { [_dictionary setObject:@(value) forKey:@(key)]; if (_autocreator) { GPBAutocreatedDictionaryModified(_autocreator, self); } } -- (void)removeValueForKey:(int32_t)aKey { +- (void)removeFloatForKey:(int32_t)aKey { [_dictionary removeObjectForKey:@(aKey)]; } @@ -4742,24 +4744,24 @@ void GPBDictionaryReadEntry(id mapDictionary, } + (instancetype)dictionary { - return [[[self alloc] initWithValues:NULL forKeys:NULL count:0] autorelease]; + return [[[self alloc] initWithDoubles:NULL forKeys:NULL count:0] autorelease]; } -+ (instancetype)dictionaryWithValue:(double)value - forKey:(int32_t)key { - // Cast is needed so the compiler knows what class we are invoking initWithValues:forKeys:count: ++ (instancetype)dictionaryWithDouble:(double)value + forKey:(int32_t)key { + // Cast is needed so the compiler knows what class we are invoking initWithDoubles:forKeys:count: // on to get the type correct. - return [[(GPBInt32DoubleDictionary*)[self alloc] initWithValues:&value - forKeys:&key - count:1] autorelease]; + return [[(GPBInt32DoubleDictionary*)[self alloc] initWithDoubles:&value + forKeys:&key + count:1] autorelease]; } -+ (instancetype)dictionaryWithValues:(const double [])values - forKeys:(const int32_t [])keys - count:(NSUInteger)count { - // Cast is needed so the compiler knows what class we are invoking initWithValues:forKeys:count: ++ (instancetype)dictionaryWithDoubles:(const double [])values + forKeys:(const int32_t [])keys + count:(NSUInteger)count { + // Cast is needed so the compiler knows what class we are invoking initWithDoubles:forKeys:count: // on to get the type correct. - return [[(GPBInt32DoubleDictionary*)[self alloc] initWithValues:values + return [[(GPBInt32DoubleDictionary*)[self alloc] initWithDoubles:values forKeys:keys count:count] autorelease]; } @@ -4775,12 +4777,12 @@ void GPBDictionaryReadEntry(id mapDictionary, } - (instancetype)init { - return [self initWithValues:NULL forKeys:NULL count:0]; + return [self initWithDoubles:NULL forKeys:NULL count:0]; } -- (instancetype)initWithValues:(const double [])values - forKeys:(const int32_t [])keys - count:(NSUInteger)count { +- (instancetype)initWithDoubles:(const double [])values + forKeys:(const int32_t [])keys + count:(NSUInteger)count { self = [super init]; if (self) { _dictionary = [[NSMutableDictionary alloc] init]; @@ -4794,7 +4796,7 @@ void GPBDictionaryReadEntry(id mapDictionary, } - (instancetype)initWithDictionary:(GPBInt32DoubleDictionary *)dictionary { - self = [self initWithValues:NULL forKeys:NULL count:0]; + self = [self initWithDoubles:NULL forKeys:NULL count:0]; if (self) { if (dictionary) { [_dictionary addEntriesFromDictionary:dictionary->_dictionary]; @@ -4805,7 +4807,7 @@ void GPBDictionaryReadEntry(id mapDictionary, - (instancetype)initWithCapacity:(NSUInteger)numItems { #pragma unused(numItems) - return [self initWithValues:NULL forKeys:NULL count:0]; + return [self initWithDoubles:NULL forKeys:NULL count:0]; } - (void)dealloc { @@ -4843,7 +4845,7 @@ void GPBDictionaryReadEntry(id mapDictionary, return _dictionary.count; } -- (void)enumerateKeysAndValuesUsingBlock: +- (void)enumerateKeysAndDoublesUsingBlock: (void (^)(int32_t key, double value, BOOL *stop))block { [_dictionary enumerateKeysAndObjectsUsingBlock:^(NSNumber *aKey, NSNumber *aValue, @@ -4901,13 +4903,13 @@ void GPBDictionaryReadEntry(id mapDictionary, } - (void)enumerateForTextFormat:(void (^)(id keyObj, id valueObj))block { - [self enumerateKeysAndValuesUsingBlock:^(int32_t key, double value, BOOL *stop) { + [self enumerateKeysAndDoublesUsingBlock:^(int32_t key, double value, BOOL *stop) { #pragma unused(stop) block([NSString stringWithFormat:@"%d", key], [NSString stringWithFormat:@"%.*lg", DBL_DIG, value]); }]; } -- (BOOL)valueForKey:(int32_t)key value:(double *)value { +- (BOOL)getDouble:(nullable double *)value forKey:(int32_t)key { NSNumber *wrapped = [_dictionary objectForKey:@(key)]; if (wrapped && value) { *value = [wrapped doubleValue]; @@ -4924,14 +4926,14 @@ void GPBDictionaryReadEntry(id mapDictionary, } } -- (void)setValue:(double)value forKey:(int32_t)key { +- (void)setDouble:(double)value forKey:(int32_t)key { [_dictionary setObject:@(value) forKey:@(key)]; if (_autocreator) { GPBAutocreatedDictionaryModified(_autocreator, self); } } -- (void)removeValueForKey:(int32_t)aKey { +- (void)removeDoubleForKey:(int32_t)aKey { [_dictionary removeObjectForKey:@(aKey)]; } @@ -5154,7 +5156,7 @@ void GPBDictionaryReadEntry(id mapDictionary, }]; } -- (BOOL)valueForKey:(int32_t)key value:(int32_t *)value { +- (BOOL)getEnum:(int32_t *)value forKey:(int32_t)key { NSNumber *wrapped = [_dictionary objectForKey:@(key)]; if (wrapped && value) { int32_t result = [wrapped intValue]; @@ -5166,7 +5168,7 @@ void GPBDictionaryReadEntry(id mapDictionary, return (wrapped != NULL); } -- (BOOL)valueForKey:(int32_t)key rawValue:(int32_t *)rawValue { +- (BOOL)getRawValue:(int32_t *)rawValue forKey:(int32_t)key { NSNumber *wrapped = [_dictionary objectForKey:@(key)]; if (wrapped && rawValue) { *rawValue = [wrapped intValue]; @@ -5174,7 +5176,7 @@ void GPBDictionaryReadEntry(id mapDictionary, return (wrapped != NULL); } -- (void)enumerateKeysAndValuesUsingBlock: +- (void)enumerateKeysAndEnumsUsingBlock: (void (^)(int32_t key, int32_t value, BOOL *stop))block { GPBEnumValidationFunc func = _validationFunc; [_dictionary enumerateKeysAndObjectsUsingBlock:^(NSNumber *aKey, @@ -5204,7 +5206,7 @@ void GPBDictionaryReadEntry(id mapDictionary, } } -- (void)removeValueForKey:(int32_t)aKey { +- (void)removeEnumForKey:(int32_t)aKey { [_dictionary removeObjectForKey:@(aKey)]; } @@ -5212,7 +5214,7 @@ void GPBDictionaryReadEntry(id mapDictionary, [_dictionary removeAllObjects]; } -- (void)setValue:(int32_t)value forKey:(int32_t)key { +- (void)setEnum:(int32_t)value forKey:(int32_t)key { if (!_validationFunc(value)) { [NSException raise:NSInvalidArgumentException format:@"GPBInt32EnumDictionary: Attempt to set an unknown enum value (%d)", @@ -5473,24 +5475,24 @@ void GPBDictionaryReadEntry(id mapDictionary, } + (instancetype)dictionary { - return [[[self alloc] initWithValues:NULL forKeys:NULL count:0] autorelease]; + return [[[self alloc] initWithUInt32s:NULL forKeys:NULL count:0] autorelease]; } -+ (instancetype)dictionaryWithValue:(uint32_t)value - forKey:(uint64_t)key { - // Cast is needed so the compiler knows what class we are invoking initWithValues:forKeys:count: ++ (instancetype)dictionaryWithUInt32:(uint32_t)value + forKey:(uint64_t)key { + // Cast is needed so the compiler knows what class we are invoking initWithUInt32s:forKeys:count: // on to get the type correct. - return [[(GPBUInt64UInt32Dictionary*)[self alloc] initWithValues:&value - forKeys:&key - count:1] autorelease]; + return [[(GPBUInt64UInt32Dictionary*)[self alloc] initWithUInt32s:&value + forKeys:&key + count:1] autorelease]; } -+ (instancetype)dictionaryWithValues:(const uint32_t [])values - forKeys:(const uint64_t [])keys - count:(NSUInteger)count { - // Cast is needed so the compiler knows what class we are invoking initWithValues:forKeys:count: ++ (instancetype)dictionaryWithUInt32s:(const uint32_t [])values + forKeys:(const uint64_t [])keys + count:(NSUInteger)count { + // Cast is needed so the compiler knows what class we are invoking initWithUInt32s:forKeys:count: // on to get the type correct. - return [[(GPBUInt64UInt32Dictionary*)[self alloc] initWithValues:values + return [[(GPBUInt64UInt32Dictionary*)[self alloc] initWithUInt32s:values forKeys:keys count:count] autorelease]; } @@ -5506,12 +5508,12 @@ void GPBDictionaryReadEntry(id mapDictionary, } - (instancetype)init { - return [self initWithValues:NULL forKeys:NULL count:0]; + return [self initWithUInt32s:NULL forKeys:NULL count:0]; } -- (instancetype)initWithValues:(const uint32_t [])values - forKeys:(const uint64_t [])keys - count:(NSUInteger)count { +- (instancetype)initWithUInt32s:(const uint32_t [])values + forKeys:(const uint64_t [])keys + count:(NSUInteger)count { self = [super init]; if (self) { _dictionary = [[NSMutableDictionary alloc] init]; @@ -5525,7 +5527,7 @@ void GPBDictionaryReadEntry(id mapDictionary, } - (instancetype)initWithDictionary:(GPBUInt64UInt32Dictionary *)dictionary { - self = [self initWithValues:NULL forKeys:NULL count:0]; + self = [self initWithUInt32s:NULL forKeys:NULL count:0]; if (self) { if (dictionary) { [_dictionary addEntriesFromDictionary:dictionary->_dictionary]; @@ -5536,7 +5538,7 @@ void GPBDictionaryReadEntry(id mapDictionary, - (instancetype)initWithCapacity:(NSUInteger)numItems { #pragma unused(numItems) - return [self initWithValues:NULL forKeys:NULL count:0]; + return [self initWithUInt32s:NULL forKeys:NULL count:0]; } - (void)dealloc { @@ -5574,7 +5576,7 @@ void GPBDictionaryReadEntry(id mapDictionary, return _dictionary.count; } -- (void)enumerateKeysAndValuesUsingBlock: +- (void)enumerateKeysAndUInt32sUsingBlock: (void (^)(uint64_t key, uint32_t value, BOOL *stop))block { [_dictionary enumerateKeysAndObjectsUsingBlock:^(NSNumber *aKey, NSNumber *aValue, @@ -5632,13 +5634,13 @@ void GPBDictionaryReadEntry(id mapDictionary, } - (void)enumerateForTextFormat:(void (^)(id keyObj, id valueObj))block { - [self enumerateKeysAndValuesUsingBlock:^(uint64_t key, uint32_t value, BOOL *stop) { + [self enumerateKeysAndUInt32sUsingBlock:^(uint64_t key, uint32_t value, BOOL *stop) { #pragma unused(stop) block([NSString stringWithFormat:@"%llu", key], [NSString stringWithFormat:@"%u", value]); }]; } -- (BOOL)valueForKey:(uint64_t)key value:(uint32_t *)value { +- (BOOL)getUInt32:(nullable uint32_t *)value forKey:(uint64_t)key { NSNumber *wrapped = [_dictionary objectForKey:@(key)]; if (wrapped && value) { *value = [wrapped unsignedIntValue]; @@ -5655,14 +5657,14 @@ void GPBDictionaryReadEntry(id mapDictionary, } } -- (void)setValue:(uint32_t)value forKey:(uint64_t)key { +- (void)setUInt32:(uint32_t)value forKey:(uint64_t)key { [_dictionary setObject:@(value) forKey:@(key)]; if (_autocreator) { GPBAutocreatedDictionaryModified(_autocreator, self); } } -- (void)removeValueForKey:(uint64_t)aKey { +- (void)removeUInt32ForKey:(uint64_t)aKey { [_dictionary removeObjectForKey:@(aKey)]; } @@ -5680,24 +5682,24 @@ void GPBDictionaryReadEntry(id mapDictionary, } + (instancetype)dictionary { - return [[[self alloc] initWithValues:NULL forKeys:NULL count:0] autorelease]; + return [[[self alloc] initWithInt32s:NULL forKeys:NULL count:0] autorelease]; } -+ (instancetype)dictionaryWithValue:(int32_t)value ++ (instancetype)dictionaryWithInt32:(int32_t)value forKey:(uint64_t)key { - // Cast is needed so the compiler knows what class we are invoking initWithValues:forKeys:count: + // Cast is needed so the compiler knows what class we are invoking initWithInt32s:forKeys:count: // on to get the type correct. - return [[(GPBUInt64Int32Dictionary*)[self alloc] initWithValues:&value + return [[(GPBUInt64Int32Dictionary*)[self alloc] initWithInt32s:&value forKeys:&key count:1] autorelease]; } -+ (instancetype)dictionaryWithValues:(const int32_t [])values ++ (instancetype)dictionaryWithInt32s:(const int32_t [])values forKeys:(const uint64_t [])keys count:(NSUInteger)count { - // Cast is needed so the compiler knows what class we are invoking initWithValues:forKeys:count: + // Cast is needed so the compiler knows what class we are invoking initWithInt32s:forKeys:count: // on to get the type correct. - return [[(GPBUInt64Int32Dictionary*)[self alloc] initWithValues:values + return [[(GPBUInt64Int32Dictionary*)[self alloc] initWithInt32s:values forKeys:keys count:count] autorelease]; } @@ -5713,10 +5715,10 @@ void GPBDictionaryReadEntry(id mapDictionary, } - (instancetype)init { - return [self initWithValues:NULL forKeys:NULL count:0]; + return [self initWithInt32s:NULL forKeys:NULL count:0]; } -- (instancetype)initWithValues:(const int32_t [])values +- (instancetype)initWithInt32s:(const int32_t [])values forKeys:(const uint64_t [])keys count:(NSUInteger)count { self = [super init]; @@ -5732,7 +5734,7 @@ void GPBDictionaryReadEntry(id mapDictionary, } - (instancetype)initWithDictionary:(GPBUInt64Int32Dictionary *)dictionary { - self = [self initWithValues:NULL forKeys:NULL count:0]; + self = [self initWithInt32s:NULL forKeys:NULL count:0]; if (self) { if (dictionary) { [_dictionary addEntriesFromDictionary:dictionary->_dictionary]; @@ -5743,7 +5745,7 @@ void GPBDictionaryReadEntry(id mapDictionary, - (instancetype)initWithCapacity:(NSUInteger)numItems { #pragma unused(numItems) - return [self initWithValues:NULL forKeys:NULL count:0]; + return [self initWithInt32s:NULL forKeys:NULL count:0]; } - (void)dealloc { @@ -5781,7 +5783,7 @@ void GPBDictionaryReadEntry(id mapDictionary, return _dictionary.count; } -- (void)enumerateKeysAndValuesUsingBlock: +- (void)enumerateKeysAndInt32sUsingBlock: (void (^)(uint64_t key, int32_t value, BOOL *stop))block { [_dictionary enumerateKeysAndObjectsUsingBlock:^(NSNumber *aKey, NSNumber *aValue, @@ -5839,13 +5841,13 @@ void GPBDictionaryReadEntry(id mapDictionary, } - (void)enumerateForTextFormat:(void (^)(id keyObj, id valueObj))block { - [self enumerateKeysAndValuesUsingBlock:^(uint64_t key, int32_t value, BOOL *stop) { + [self enumerateKeysAndInt32sUsingBlock:^(uint64_t key, int32_t value, BOOL *stop) { #pragma unused(stop) block([NSString stringWithFormat:@"%llu", key], [NSString stringWithFormat:@"%d", value]); }]; } -- (BOOL)valueForKey:(uint64_t)key value:(int32_t *)value { +- (BOOL)getInt32:(nullable int32_t *)value forKey:(uint64_t)key { NSNumber *wrapped = [_dictionary objectForKey:@(key)]; if (wrapped && value) { *value = [wrapped intValue]; @@ -5862,14 +5864,14 @@ void GPBDictionaryReadEntry(id mapDictionary, } } -- (void)setValue:(int32_t)value forKey:(uint64_t)key { +- (void)setInt32:(int32_t)value forKey:(uint64_t)key { [_dictionary setObject:@(value) forKey:@(key)]; if (_autocreator) { GPBAutocreatedDictionaryModified(_autocreator, self); } } -- (void)removeValueForKey:(uint64_t)aKey { +- (void)removeInt32ForKey:(uint64_t)aKey { [_dictionary removeObjectForKey:@(aKey)]; } @@ -5887,24 +5889,24 @@ void GPBDictionaryReadEntry(id mapDictionary, } + (instancetype)dictionary { - return [[[self alloc] initWithValues:NULL forKeys:NULL count:0] autorelease]; + return [[[self alloc] initWithUInt64s:NULL forKeys:NULL count:0] autorelease]; } -+ (instancetype)dictionaryWithValue:(uint64_t)value - forKey:(uint64_t)key { - // Cast is needed so the compiler knows what class we are invoking initWithValues:forKeys:count: ++ (instancetype)dictionaryWithUInt64:(uint64_t)value + forKey:(uint64_t)key { + // Cast is needed so the compiler knows what class we are invoking initWithUInt64s:forKeys:count: // on to get the type correct. - return [[(GPBUInt64UInt64Dictionary*)[self alloc] initWithValues:&value - forKeys:&key - count:1] autorelease]; + return [[(GPBUInt64UInt64Dictionary*)[self alloc] initWithUInt64s:&value + forKeys:&key + count:1] autorelease]; } -+ (instancetype)dictionaryWithValues:(const uint64_t [])values - forKeys:(const uint64_t [])keys - count:(NSUInteger)count { - // Cast is needed so the compiler knows what class we are invoking initWithValues:forKeys:count: ++ (instancetype)dictionaryWithUInt64s:(const uint64_t [])values + forKeys:(const uint64_t [])keys + count:(NSUInteger)count { + // Cast is needed so the compiler knows what class we are invoking initWithUInt64s:forKeys:count: // on to get the type correct. - return [[(GPBUInt64UInt64Dictionary*)[self alloc] initWithValues:values + return [[(GPBUInt64UInt64Dictionary*)[self alloc] initWithUInt64s:values forKeys:keys count:count] autorelease]; } @@ -5920,12 +5922,12 @@ void GPBDictionaryReadEntry(id mapDictionary, } - (instancetype)init { - return [self initWithValues:NULL forKeys:NULL count:0]; + return [self initWithUInt64s:NULL forKeys:NULL count:0]; } -- (instancetype)initWithValues:(const uint64_t [])values - forKeys:(const uint64_t [])keys - count:(NSUInteger)count { +- (instancetype)initWithUInt64s:(const uint64_t [])values + forKeys:(const uint64_t [])keys + count:(NSUInteger)count { self = [super init]; if (self) { _dictionary = [[NSMutableDictionary alloc] init]; @@ -5939,7 +5941,7 @@ void GPBDictionaryReadEntry(id mapDictionary, } - (instancetype)initWithDictionary:(GPBUInt64UInt64Dictionary *)dictionary { - self = [self initWithValues:NULL forKeys:NULL count:0]; + self = [self initWithUInt64s:NULL forKeys:NULL count:0]; if (self) { if (dictionary) { [_dictionary addEntriesFromDictionary:dictionary->_dictionary]; @@ -5950,7 +5952,7 @@ void GPBDictionaryReadEntry(id mapDictionary, - (instancetype)initWithCapacity:(NSUInteger)numItems { #pragma unused(numItems) - return [self initWithValues:NULL forKeys:NULL count:0]; + return [self initWithUInt64s:NULL forKeys:NULL count:0]; } - (void)dealloc { @@ -5988,7 +5990,7 @@ void GPBDictionaryReadEntry(id mapDictionary, return _dictionary.count; } -- (void)enumerateKeysAndValuesUsingBlock: +- (void)enumerateKeysAndUInt64sUsingBlock: (void (^)(uint64_t key, uint64_t value, BOOL *stop))block { [_dictionary enumerateKeysAndObjectsUsingBlock:^(NSNumber *aKey, NSNumber *aValue, @@ -6046,13 +6048,13 @@ void GPBDictionaryReadEntry(id mapDictionary, } - (void)enumerateForTextFormat:(void (^)(id keyObj, id valueObj))block { - [self enumerateKeysAndValuesUsingBlock:^(uint64_t key, uint64_t value, BOOL *stop) { + [self enumerateKeysAndUInt64sUsingBlock:^(uint64_t key, uint64_t value, BOOL *stop) { #pragma unused(stop) block([NSString stringWithFormat:@"%llu", key], [NSString stringWithFormat:@"%llu", value]); }]; } -- (BOOL)valueForKey:(uint64_t)key value:(uint64_t *)value { +- (BOOL)getUInt64:(nullable uint64_t *)value forKey:(uint64_t)key { NSNumber *wrapped = [_dictionary objectForKey:@(key)]; if (wrapped && value) { *value = [wrapped unsignedLongLongValue]; @@ -6069,14 +6071,14 @@ void GPBDictionaryReadEntry(id mapDictionary, } } -- (void)setValue:(uint64_t)value forKey:(uint64_t)key { +- (void)setUInt64:(uint64_t)value forKey:(uint64_t)key { [_dictionary setObject:@(value) forKey:@(key)]; if (_autocreator) { GPBAutocreatedDictionaryModified(_autocreator, self); } } -- (void)removeValueForKey:(uint64_t)aKey { +- (void)removeUInt64ForKey:(uint64_t)aKey { [_dictionary removeObjectForKey:@(aKey)]; } @@ -6094,24 +6096,24 @@ void GPBDictionaryReadEntry(id mapDictionary, } + (instancetype)dictionary { - return [[[self alloc] initWithValues:NULL forKeys:NULL count:0] autorelease]; + return [[[self alloc] initWithInt64s:NULL forKeys:NULL count:0] autorelease]; } -+ (instancetype)dictionaryWithValue:(int64_t)value ++ (instancetype)dictionaryWithInt64:(int64_t)value forKey:(uint64_t)key { - // Cast is needed so the compiler knows what class we are invoking initWithValues:forKeys:count: + // Cast is needed so the compiler knows what class we are invoking initWithInt64s:forKeys:count: // on to get the type correct. - return [[(GPBUInt64Int64Dictionary*)[self alloc] initWithValues:&value + return [[(GPBUInt64Int64Dictionary*)[self alloc] initWithInt64s:&value forKeys:&key count:1] autorelease]; } -+ (instancetype)dictionaryWithValues:(const int64_t [])values ++ (instancetype)dictionaryWithInt64s:(const int64_t [])values forKeys:(const uint64_t [])keys count:(NSUInteger)count { - // Cast is needed so the compiler knows what class we are invoking initWithValues:forKeys:count: + // Cast is needed so the compiler knows what class we are invoking initWithInt64s:forKeys:count: // on to get the type correct. - return [[(GPBUInt64Int64Dictionary*)[self alloc] initWithValues:values + return [[(GPBUInt64Int64Dictionary*)[self alloc] initWithInt64s:values forKeys:keys count:count] autorelease]; } @@ -6127,10 +6129,10 @@ void GPBDictionaryReadEntry(id mapDictionary, } - (instancetype)init { - return [self initWithValues:NULL forKeys:NULL count:0]; + return [self initWithInt64s:NULL forKeys:NULL count:0]; } -- (instancetype)initWithValues:(const int64_t [])values +- (instancetype)initWithInt64s:(const int64_t [])values forKeys:(const uint64_t [])keys count:(NSUInteger)count { self = [super init]; @@ -6146,7 +6148,7 @@ void GPBDictionaryReadEntry(id mapDictionary, } - (instancetype)initWithDictionary:(GPBUInt64Int64Dictionary *)dictionary { - self = [self initWithValues:NULL forKeys:NULL count:0]; + self = [self initWithInt64s:NULL forKeys:NULL count:0]; if (self) { if (dictionary) { [_dictionary addEntriesFromDictionary:dictionary->_dictionary]; @@ -6157,7 +6159,7 @@ void GPBDictionaryReadEntry(id mapDictionary, - (instancetype)initWithCapacity:(NSUInteger)numItems { #pragma unused(numItems) - return [self initWithValues:NULL forKeys:NULL count:0]; + return [self initWithInt64s:NULL forKeys:NULL count:0]; } - (void)dealloc { @@ -6195,7 +6197,7 @@ void GPBDictionaryReadEntry(id mapDictionary, return _dictionary.count; } -- (void)enumerateKeysAndValuesUsingBlock: +- (void)enumerateKeysAndInt64sUsingBlock: (void (^)(uint64_t key, int64_t value, BOOL *stop))block { [_dictionary enumerateKeysAndObjectsUsingBlock:^(NSNumber *aKey, NSNumber *aValue, @@ -6253,13 +6255,13 @@ void GPBDictionaryReadEntry(id mapDictionary, } - (void)enumerateForTextFormat:(void (^)(id keyObj, id valueObj))block { - [self enumerateKeysAndValuesUsingBlock:^(uint64_t key, int64_t value, BOOL *stop) { + [self enumerateKeysAndInt64sUsingBlock:^(uint64_t key, int64_t value, BOOL *stop) { #pragma unused(stop) block([NSString stringWithFormat:@"%llu", key], [NSString stringWithFormat:@"%lld", value]); }]; } -- (BOOL)valueForKey:(uint64_t)key value:(int64_t *)value { +- (BOOL)getInt64:(nullable int64_t *)value forKey:(uint64_t)key { NSNumber *wrapped = [_dictionary objectForKey:@(key)]; if (wrapped && value) { *value = [wrapped longLongValue]; @@ -6276,14 +6278,14 @@ void GPBDictionaryReadEntry(id mapDictionary, } } -- (void)setValue:(int64_t)value forKey:(uint64_t)key { +- (void)setInt64:(int64_t)value forKey:(uint64_t)key { [_dictionary setObject:@(value) forKey:@(key)]; if (_autocreator) { GPBAutocreatedDictionaryModified(_autocreator, self); } } -- (void)removeValueForKey:(uint64_t)aKey { +- (void)removeInt64ForKey:(uint64_t)aKey { [_dictionary removeObjectForKey:@(aKey)]; } @@ -6301,24 +6303,24 @@ void GPBDictionaryReadEntry(id mapDictionary, } + (instancetype)dictionary { - return [[[self alloc] initWithValues:NULL forKeys:NULL count:0] autorelease]; + return [[[self alloc] initWithBools:NULL forKeys:NULL count:0] autorelease]; } -+ (instancetype)dictionaryWithValue:(BOOL)value - forKey:(uint64_t)key { - // Cast is needed so the compiler knows what class we are invoking initWithValues:forKeys:count: ++ (instancetype)dictionaryWithBool:(BOOL)value + forKey:(uint64_t)key { + // Cast is needed so the compiler knows what class we are invoking initWithBools:forKeys:count: // on to get the type correct. - return [[(GPBUInt64BoolDictionary*)[self alloc] initWithValues:&value - forKeys:&key - count:1] autorelease]; + return [[(GPBUInt64BoolDictionary*)[self alloc] initWithBools:&value + forKeys:&key + count:1] autorelease]; } -+ (instancetype)dictionaryWithValues:(const BOOL [])values - forKeys:(const uint64_t [])keys - count:(NSUInteger)count { - // Cast is needed so the compiler knows what class we are invoking initWithValues:forKeys:count: ++ (instancetype)dictionaryWithBools:(const BOOL [])values + forKeys:(const uint64_t [])keys + count:(NSUInteger)count { + // Cast is needed so the compiler knows what class we are invoking initWithBools:forKeys:count: // on to get the type correct. - return [[(GPBUInt64BoolDictionary*)[self alloc] initWithValues:values + return [[(GPBUInt64BoolDictionary*)[self alloc] initWithBools:values forKeys:keys count:count] autorelease]; } @@ -6334,12 +6336,12 @@ void GPBDictionaryReadEntry(id mapDictionary, } - (instancetype)init { - return [self initWithValues:NULL forKeys:NULL count:0]; + return [self initWithBools:NULL forKeys:NULL count:0]; } -- (instancetype)initWithValues:(const BOOL [])values - forKeys:(const uint64_t [])keys - count:(NSUInteger)count { +- (instancetype)initWithBools:(const BOOL [])values + forKeys:(const uint64_t [])keys + count:(NSUInteger)count { self = [super init]; if (self) { _dictionary = [[NSMutableDictionary alloc] init]; @@ -6353,7 +6355,7 @@ void GPBDictionaryReadEntry(id mapDictionary, } - (instancetype)initWithDictionary:(GPBUInt64BoolDictionary *)dictionary { - self = [self initWithValues:NULL forKeys:NULL count:0]; + self = [self initWithBools:NULL forKeys:NULL count:0]; if (self) { if (dictionary) { [_dictionary addEntriesFromDictionary:dictionary->_dictionary]; @@ -6364,7 +6366,7 @@ void GPBDictionaryReadEntry(id mapDictionary, - (instancetype)initWithCapacity:(NSUInteger)numItems { #pragma unused(numItems) - return [self initWithValues:NULL forKeys:NULL count:0]; + return [self initWithBools:NULL forKeys:NULL count:0]; } - (void)dealloc { @@ -6402,7 +6404,7 @@ void GPBDictionaryReadEntry(id mapDictionary, return _dictionary.count; } -- (void)enumerateKeysAndValuesUsingBlock: +- (void)enumerateKeysAndBoolsUsingBlock: (void (^)(uint64_t key, BOOL value, BOOL *stop))block { [_dictionary enumerateKeysAndObjectsUsingBlock:^(NSNumber *aKey, NSNumber *aValue, @@ -6460,13 +6462,13 @@ void GPBDictionaryReadEntry(id mapDictionary, } - (void)enumerateForTextFormat:(void (^)(id keyObj, id valueObj))block { - [self enumerateKeysAndValuesUsingBlock:^(uint64_t key, BOOL value, BOOL *stop) { + [self enumerateKeysAndBoolsUsingBlock:^(uint64_t key, BOOL value, BOOL *stop) { #pragma unused(stop) block([NSString stringWithFormat:@"%llu", key], (value ? @"true" : @"false")); }]; } -- (BOOL)valueForKey:(uint64_t)key value:(BOOL *)value { +- (BOOL)getBool:(nullable BOOL *)value forKey:(uint64_t)key { NSNumber *wrapped = [_dictionary objectForKey:@(key)]; if (wrapped && value) { *value = [wrapped boolValue]; @@ -6483,14 +6485,14 @@ void GPBDictionaryReadEntry(id mapDictionary, } } -- (void)setValue:(BOOL)value forKey:(uint64_t)key { +- (void)setBool:(BOOL)value forKey:(uint64_t)key { [_dictionary setObject:@(value) forKey:@(key)]; if (_autocreator) { GPBAutocreatedDictionaryModified(_autocreator, self); } } -- (void)removeValueForKey:(uint64_t)aKey { +- (void)removeBoolForKey:(uint64_t)aKey { [_dictionary removeObjectForKey:@(aKey)]; } @@ -6508,24 +6510,24 @@ void GPBDictionaryReadEntry(id mapDictionary, } + (instancetype)dictionary { - return [[[self alloc] initWithValues:NULL forKeys:NULL count:0] autorelease]; + return [[[self alloc] initWithFloats:NULL forKeys:NULL count:0] autorelease]; } -+ (instancetype)dictionaryWithValue:(float)value ++ (instancetype)dictionaryWithFloat:(float)value forKey:(uint64_t)key { - // Cast is needed so the compiler knows what class we are invoking initWithValues:forKeys:count: + // Cast is needed so the compiler knows what class we are invoking initWithFloats:forKeys:count: // on to get the type correct. - return [[(GPBUInt64FloatDictionary*)[self alloc] initWithValues:&value + return [[(GPBUInt64FloatDictionary*)[self alloc] initWithFloats:&value forKeys:&key count:1] autorelease]; } -+ (instancetype)dictionaryWithValues:(const float [])values ++ (instancetype)dictionaryWithFloats:(const float [])values forKeys:(const uint64_t [])keys count:(NSUInteger)count { - // Cast is needed so the compiler knows what class we are invoking initWithValues:forKeys:count: + // Cast is needed so the compiler knows what class we are invoking initWithFloats:forKeys:count: // on to get the type correct. - return [[(GPBUInt64FloatDictionary*)[self alloc] initWithValues:values + return [[(GPBUInt64FloatDictionary*)[self alloc] initWithFloats:values forKeys:keys count:count] autorelease]; } @@ -6541,10 +6543,10 @@ void GPBDictionaryReadEntry(id mapDictionary, } - (instancetype)init { - return [self initWithValues:NULL forKeys:NULL count:0]; + return [self initWithFloats:NULL forKeys:NULL count:0]; } -- (instancetype)initWithValues:(const float [])values +- (instancetype)initWithFloats:(const float [])values forKeys:(const uint64_t [])keys count:(NSUInteger)count { self = [super init]; @@ -6560,7 +6562,7 @@ void GPBDictionaryReadEntry(id mapDictionary, } - (instancetype)initWithDictionary:(GPBUInt64FloatDictionary *)dictionary { - self = [self initWithValues:NULL forKeys:NULL count:0]; + self = [self initWithFloats:NULL forKeys:NULL count:0]; if (self) { if (dictionary) { [_dictionary addEntriesFromDictionary:dictionary->_dictionary]; @@ -6571,7 +6573,7 @@ void GPBDictionaryReadEntry(id mapDictionary, - (instancetype)initWithCapacity:(NSUInteger)numItems { #pragma unused(numItems) - return [self initWithValues:NULL forKeys:NULL count:0]; + return [self initWithFloats:NULL forKeys:NULL count:0]; } - (void)dealloc { @@ -6609,7 +6611,7 @@ void GPBDictionaryReadEntry(id mapDictionary, return _dictionary.count; } -- (void)enumerateKeysAndValuesUsingBlock: +- (void)enumerateKeysAndFloatsUsingBlock: (void (^)(uint64_t key, float value, BOOL *stop))block { [_dictionary enumerateKeysAndObjectsUsingBlock:^(NSNumber *aKey, NSNumber *aValue, @@ -6667,13 +6669,13 @@ void GPBDictionaryReadEntry(id mapDictionary, } - (void)enumerateForTextFormat:(void (^)(id keyObj, id valueObj))block { - [self enumerateKeysAndValuesUsingBlock:^(uint64_t key, float value, BOOL *stop) { + [self enumerateKeysAndFloatsUsingBlock:^(uint64_t key, float value, BOOL *stop) { #pragma unused(stop) block([NSString stringWithFormat:@"%llu", key], [NSString stringWithFormat:@"%.*g", FLT_DIG, value]); }]; } -- (BOOL)valueForKey:(uint64_t)key value:(float *)value { +- (BOOL)getFloat:(nullable float *)value forKey:(uint64_t)key { NSNumber *wrapped = [_dictionary objectForKey:@(key)]; if (wrapped && value) { *value = [wrapped floatValue]; @@ -6690,14 +6692,14 @@ void GPBDictionaryReadEntry(id mapDictionary, } } -- (void)setValue:(float)value forKey:(uint64_t)key { +- (void)setFloat:(float)value forKey:(uint64_t)key { [_dictionary setObject:@(value) forKey:@(key)]; if (_autocreator) { GPBAutocreatedDictionaryModified(_autocreator, self); } } -- (void)removeValueForKey:(uint64_t)aKey { +- (void)removeFloatForKey:(uint64_t)aKey { [_dictionary removeObjectForKey:@(aKey)]; } @@ -6715,24 +6717,24 @@ void GPBDictionaryReadEntry(id mapDictionary, } + (instancetype)dictionary { - return [[[self alloc] initWithValues:NULL forKeys:NULL count:0] autorelease]; + return [[[self alloc] initWithDoubles:NULL forKeys:NULL count:0] autorelease]; } -+ (instancetype)dictionaryWithValue:(double)value - forKey:(uint64_t)key { - // Cast is needed so the compiler knows what class we are invoking initWithValues:forKeys:count: ++ (instancetype)dictionaryWithDouble:(double)value + forKey:(uint64_t)key { + // Cast is needed so the compiler knows what class we are invoking initWithDoubles:forKeys:count: // on to get the type correct. - return [[(GPBUInt64DoubleDictionary*)[self alloc] initWithValues:&value - forKeys:&key - count:1] autorelease]; + return [[(GPBUInt64DoubleDictionary*)[self alloc] initWithDoubles:&value + forKeys:&key + count:1] autorelease]; } -+ (instancetype)dictionaryWithValues:(const double [])values - forKeys:(const uint64_t [])keys - count:(NSUInteger)count { - // Cast is needed so the compiler knows what class we are invoking initWithValues:forKeys:count: ++ (instancetype)dictionaryWithDoubles:(const double [])values + forKeys:(const uint64_t [])keys + count:(NSUInteger)count { + // Cast is needed so the compiler knows what class we are invoking initWithDoubles:forKeys:count: // on to get the type correct. - return [[(GPBUInt64DoubleDictionary*)[self alloc] initWithValues:values + return [[(GPBUInt64DoubleDictionary*)[self alloc] initWithDoubles:values forKeys:keys count:count] autorelease]; } @@ -6748,12 +6750,12 @@ void GPBDictionaryReadEntry(id mapDictionary, } - (instancetype)init { - return [self initWithValues:NULL forKeys:NULL count:0]; + return [self initWithDoubles:NULL forKeys:NULL count:0]; } -- (instancetype)initWithValues:(const double [])values - forKeys:(const uint64_t [])keys - count:(NSUInteger)count { +- (instancetype)initWithDoubles:(const double [])values + forKeys:(const uint64_t [])keys + count:(NSUInteger)count { self = [super init]; if (self) { _dictionary = [[NSMutableDictionary alloc] init]; @@ -6767,7 +6769,7 @@ void GPBDictionaryReadEntry(id mapDictionary, } - (instancetype)initWithDictionary:(GPBUInt64DoubleDictionary *)dictionary { - self = [self initWithValues:NULL forKeys:NULL count:0]; + self = [self initWithDoubles:NULL forKeys:NULL count:0]; if (self) { if (dictionary) { [_dictionary addEntriesFromDictionary:dictionary->_dictionary]; @@ -6778,7 +6780,7 @@ void GPBDictionaryReadEntry(id mapDictionary, - (instancetype)initWithCapacity:(NSUInteger)numItems { #pragma unused(numItems) - return [self initWithValues:NULL forKeys:NULL count:0]; + return [self initWithDoubles:NULL forKeys:NULL count:0]; } - (void)dealloc { @@ -6816,7 +6818,7 @@ void GPBDictionaryReadEntry(id mapDictionary, return _dictionary.count; } -- (void)enumerateKeysAndValuesUsingBlock: +- (void)enumerateKeysAndDoublesUsingBlock: (void (^)(uint64_t key, double value, BOOL *stop))block { [_dictionary enumerateKeysAndObjectsUsingBlock:^(NSNumber *aKey, NSNumber *aValue, @@ -6874,13 +6876,13 @@ void GPBDictionaryReadEntry(id mapDictionary, } - (void)enumerateForTextFormat:(void (^)(id keyObj, id valueObj))block { - [self enumerateKeysAndValuesUsingBlock:^(uint64_t key, double value, BOOL *stop) { + [self enumerateKeysAndDoublesUsingBlock:^(uint64_t key, double value, BOOL *stop) { #pragma unused(stop) block([NSString stringWithFormat:@"%llu", key], [NSString stringWithFormat:@"%.*lg", DBL_DIG, value]); }]; } -- (BOOL)valueForKey:(uint64_t)key value:(double *)value { +- (BOOL)getDouble:(nullable double *)value forKey:(uint64_t)key { NSNumber *wrapped = [_dictionary objectForKey:@(key)]; if (wrapped && value) { *value = [wrapped doubleValue]; @@ -6897,14 +6899,14 @@ void GPBDictionaryReadEntry(id mapDictionary, } } -- (void)setValue:(double)value forKey:(uint64_t)key { +- (void)setDouble:(double)value forKey:(uint64_t)key { [_dictionary setObject:@(value) forKey:@(key)]; if (_autocreator) { GPBAutocreatedDictionaryModified(_autocreator, self); } } -- (void)removeValueForKey:(uint64_t)aKey { +- (void)removeDoubleForKey:(uint64_t)aKey { [_dictionary removeObjectForKey:@(aKey)]; } @@ -7127,7 +7129,7 @@ void GPBDictionaryReadEntry(id mapDictionary, }]; } -- (BOOL)valueForKey:(uint64_t)key value:(int32_t *)value { +- (BOOL)getEnum:(int32_t *)value forKey:(uint64_t)key { NSNumber *wrapped = [_dictionary objectForKey:@(key)]; if (wrapped && value) { int32_t result = [wrapped intValue]; @@ -7139,7 +7141,7 @@ void GPBDictionaryReadEntry(id mapDictionary, return (wrapped != NULL); } -- (BOOL)valueForKey:(uint64_t)key rawValue:(int32_t *)rawValue { +- (BOOL)getRawValue:(int32_t *)rawValue forKey:(uint64_t)key { NSNumber *wrapped = [_dictionary objectForKey:@(key)]; if (wrapped && rawValue) { *rawValue = [wrapped intValue]; @@ -7147,7 +7149,7 @@ void GPBDictionaryReadEntry(id mapDictionary, return (wrapped != NULL); } -- (void)enumerateKeysAndValuesUsingBlock: +- (void)enumerateKeysAndEnumsUsingBlock: (void (^)(uint64_t key, int32_t value, BOOL *stop))block { GPBEnumValidationFunc func = _validationFunc; [_dictionary enumerateKeysAndObjectsUsingBlock:^(NSNumber *aKey, @@ -7177,7 +7179,7 @@ void GPBDictionaryReadEntry(id mapDictionary, } } -- (void)removeValueForKey:(uint64_t)aKey { +- (void)removeEnumForKey:(uint64_t)aKey { [_dictionary removeObjectForKey:@(aKey)]; } @@ -7185,7 +7187,7 @@ void GPBDictionaryReadEntry(id mapDictionary, [_dictionary removeAllObjects]; } -- (void)setValue:(int32_t)value forKey:(uint64_t)key { +- (void)setEnum:(int32_t)value forKey:(uint64_t)key { if (!_validationFunc(value)) { [NSException raise:NSInvalidArgumentException format:@"GPBUInt64EnumDictionary: Attempt to set an unknown enum value (%d)", @@ -7446,24 +7448,24 @@ void GPBDictionaryReadEntry(id mapDictionary, } + (instancetype)dictionary { - return [[[self alloc] initWithValues:NULL forKeys:NULL count:0] autorelease]; + return [[[self alloc] initWithUInt32s:NULL forKeys:NULL count:0] autorelease]; } -+ (instancetype)dictionaryWithValue:(uint32_t)value - forKey:(int64_t)key { - // Cast is needed so the compiler knows what class we are invoking initWithValues:forKeys:count: ++ (instancetype)dictionaryWithUInt32:(uint32_t)value + forKey:(int64_t)key { + // Cast is needed so the compiler knows what class we are invoking initWithUInt32s:forKeys:count: // on to get the type correct. - return [[(GPBInt64UInt32Dictionary*)[self alloc] initWithValues:&value - forKeys:&key - count:1] autorelease]; + return [[(GPBInt64UInt32Dictionary*)[self alloc] initWithUInt32s:&value + forKeys:&key + count:1] autorelease]; } -+ (instancetype)dictionaryWithValues:(const uint32_t [])values - forKeys:(const int64_t [])keys - count:(NSUInteger)count { - // Cast is needed so the compiler knows what class we are invoking initWithValues:forKeys:count: ++ (instancetype)dictionaryWithUInt32s:(const uint32_t [])values + forKeys:(const int64_t [])keys + count:(NSUInteger)count { + // Cast is needed so the compiler knows what class we are invoking initWithUInt32s:forKeys:count: // on to get the type correct. - return [[(GPBInt64UInt32Dictionary*)[self alloc] initWithValues:values + return [[(GPBInt64UInt32Dictionary*)[self alloc] initWithUInt32s:values forKeys:keys count:count] autorelease]; } @@ -7479,12 +7481,12 @@ void GPBDictionaryReadEntry(id mapDictionary, } - (instancetype)init { - return [self initWithValues:NULL forKeys:NULL count:0]; + return [self initWithUInt32s:NULL forKeys:NULL count:0]; } -- (instancetype)initWithValues:(const uint32_t [])values - forKeys:(const int64_t [])keys - count:(NSUInteger)count { +- (instancetype)initWithUInt32s:(const uint32_t [])values + forKeys:(const int64_t [])keys + count:(NSUInteger)count { self = [super init]; if (self) { _dictionary = [[NSMutableDictionary alloc] init]; @@ -7498,7 +7500,7 @@ void GPBDictionaryReadEntry(id mapDictionary, } - (instancetype)initWithDictionary:(GPBInt64UInt32Dictionary *)dictionary { - self = [self initWithValues:NULL forKeys:NULL count:0]; + self = [self initWithUInt32s:NULL forKeys:NULL count:0]; if (self) { if (dictionary) { [_dictionary addEntriesFromDictionary:dictionary->_dictionary]; @@ -7509,7 +7511,7 @@ void GPBDictionaryReadEntry(id mapDictionary, - (instancetype)initWithCapacity:(NSUInteger)numItems { #pragma unused(numItems) - return [self initWithValues:NULL forKeys:NULL count:0]; + return [self initWithUInt32s:NULL forKeys:NULL count:0]; } - (void)dealloc { @@ -7547,7 +7549,7 @@ void GPBDictionaryReadEntry(id mapDictionary, return _dictionary.count; } -- (void)enumerateKeysAndValuesUsingBlock: +- (void)enumerateKeysAndUInt32sUsingBlock: (void (^)(int64_t key, uint32_t value, BOOL *stop))block { [_dictionary enumerateKeysAndObjectsUsingBlock:^(NSNumber *aKey, NSNumber *aValue, @@ -7605,13 +7607,13 @@ void GPBDictionaryReadEntry(id mapDictionary, } - (void)enumerateForTextFormat:(void (^)(id keyObj, id valueObj))block { - [self enumerateKeysAndValuesUsingBlock:^(int64_t key, uint32_t value, BOOL *stop) { + [self enumerateKeysAndUInt32sUsingBlock:^(int64_t key, uint32_t value, BOOL *stop) { #pragma unused(stop) block([NSString stringWithFormat:@"%lld", key], [NSString stringWithFormat:@"%u", value]); }]; } -- (BOOL)valueForKey:(int64_t)key value:(uint32_t *)value { +- (BOOL)getUInt32:(nullable uint32_t *)value forKey:(int64_t)key { NSNumber *wrapped = [_dictionary objectForKey:@(key)]; if (wrapped && value) { *value = [wrapped unsignedIntValue]; @@ -7628,14 +7630,14 @@ void GPBDictionaryReadEntry(id mapDictionary, } } -- (void)setValue:(uint32_t)value forKey:(int64_t)key { +- (void)setUInt32:(uint32_t)value forKey:(int64_t)key { [_dictionary setObject:@(value) forKey:@(key)]; if (_autocreator) { GPBAutocreatedDictionaryModified(_autocreator, self); } } -- (void)removeValueForKey:(int64_t)aKey { +- (void)removeUInt32ForKey:(int64_t)aKey { [_dictionary removeObjectForKey:@(aKey)]; } @@ -7653,24 +7655,24 @@ void GPBDictionaryReadEntry(id mapDictionary, } + (instancetype)dictionary { - return [[[self alloc] initWithValues:NULL forKeys:NULL count:0] autorelease]; + return [[[self alloc] initWithInt32s:NULL forKeys:NULL count:0] autorelease]; } -+ (instancetype)dictionaryWithValue:(int32_t)value ++ (instancetype)dictionaryWithInt32:(int32_t)value forKey:(int64_t)key { - // Cast is needed so the compiler knows what class we are invoking initWithValues:forKeys:count: + // Cast is needed so the compiler knows what class we are invoking initWithInt32s:forKeys:count: // on to get the type correct. - return [[(GPBInt64Int32Dictionary*)[self alloc] initWithValues:&value + return [[(GPBInt64Int32Dictionary*)[self alloc] initWithInt32s:&value forKeys:&key count:1] autorelease]; } -+ (instancetype)dictionaryWithValues:(const int32_t [])values ++ (instancetype)dictionaryWithInt32s:(const int32_t [])values forKeys:(const int64_t [])keys count:(NSUInteger)count { - // Cast is needed so the compiler knows what class we are invoking initWithValues:forKeys:count: + // Cast is needed so the compiler knows what class we are invoking initWithInt32s:forKeys:count: // on to get the type correct. - return [[(GPBInt64Int32Dictionary*)[self alloc] initWithValues:values + return [[(GPBInt64Int32Dictionary*)[self alloc] initWithInt32s:values forKeys:keys count:count] autorelease]; } @@ -7686,10 +7688,10 @@ void GPBDictionaryReadEntry(id mapDictionary, } - (instancetype)init { - return [self initWithValues:NULL forKeys:NULL count:0]; + return [self initWithInt32s:NULL forKeys:NULL count:0]; } -- (instancetype)initWithValues:(const int32_t [])values +- (instancetype)initWithInt32s:(const int32_t [])values forKeys:(const int64_t [])keys count:(NSUInteger)count { self = [super init]; @@ -7705,7 +7707,7 @@ void GPBDictionaryReadEntry(id mapDictionary, } - (instancetype)initWithDictionary:(GPBInt64Int32Dictionary *)dictionary { - self = [self initWithValues:NULL forKeys:NULL count:0]; + self = [self initWithInt32s:NULL forKeys:NULL count:0]; if (self) { if (dictionary) { [_dictionary addEntriesFromDictionary:dictionary->_dictionary]; @@ -7716,7 +7718,7 @@ void GPBDictionaryReadEntry(id mapDictionary, - (instancetype)initWithCapacity:(NSUInteger)numItems { #pragma unused(numItems) - return [self initWithValues:NULL forKeys:NULL count:0]; + return [self initWithInt32s:NULL forKeys:NULL count:0]; } - (void)dealloc { @@ -7754,7 +7756,7 @@ void GPBDictionaryReadEntry(id mapDictionary, return _dictionary.count; } -- (void)enumerateKeysAndValuesUsingBlock: +- (void)enumerateKeysAndInt32sUsingBlock: (void (^)(int64_t key, int32_t value, BOOL *stop))block { [_dictionary enumerateKeysAndObjectsUsingBlock:^(NSNumber *aKey, NSNumber *aValue, @@ -7812,13 +7814,13 @@ void GPBDictionaryReadEntry(id mapDictionary, } - (void)enumerateForTextFormat:(void (^)(id keyObj, id valueObj))block { - [self enumerateKeysAndValuesUsingBlock:^(int64_t key, int32_t value, BOOL *stop) { + [self enumerateKeysAndInt32sUsingBlock:^(int64_t key, int32_t value, BOOL *stop) { #pragma unused(stop) block([NSString stringWithFormat:@"%lld", key], [NSString stringWithFormat:@"%d", value]); }]; } -- (BOOL)valueForKey:(int64_t)key value:(int32_t *)value { +- (BOOL)getInt32:(nullable int32_t *)value forKey:(int64_t)key { NSNumber *wrapped = [_dictionary objectForKey:@(key)]; if (wrapped && value) { *value = [wrapped intValue]; @@ -7835,14 +7837,14 @@ void GPBDictionaryReadEntry(id mapDictionary, } } -- (void)setValue:(int32_t)value forKey:(int64_t)key { +- (void)setInt32:(int32_t)value forKey:(int64_t)key { [_dictionary setObject:@(value) forKey:@(key)]; if (_autocreator) { GPBAutocreatedDictionaryModified(_autocreator, self); } } -- (void)removeValueForKey:(int64_t)aKey { +- (void)removeInt32ForKey:(int64_t)aKey { [_dictionary removeObjectForKey:@(aKey)]; } @@ -7860,24 +7862,24 @@ void GPBDictionaryReadEntry(id mapDictionary, } + (instancetype)dictionary { - return [[[self alloc] initWithValues:NULL forKeys:NULL count:0] autorelease]; + return [[[self alloc] initWithUInt64s:NULL forKeys:NULL count:0] autorelease]; } -+ (instancetype)dictionaryWithValue:(uint64_t)value - forKey:(int64_t)key { - // Cast is needed so the compiler knows what class we are invoking initWithValues:forKeys:count: ++ (instancetype)dictionaryWithUInt64:(uint64_t)value + forKey:(int64_t)key { + // Cast is needed so the compiler knows what class we are invoking initWithUInt64s:forKeys:count: // on to get the type correct. - return [[(GPBInt64UInt64Dictionary*)[self alloc] initWithValues:&value - forKeys:&key - count:1] autorelease]; + return [[(GPBInt64UInt64Dictionary*)[self alloc] initWithUInt64s:&value + forKeys:&key + count:1] autorelease]; } -+ (instancetype)dictionaryWithValues:(const uint64_t [])values - forKeys:(const int64_t [])keys - count:(NSUInteger)count { - // Cast is needed so the compiler knows what class we are invoking initWithValues:forKeys:count: ++ (instancetype)dictionaryWithUInt64s:(const uint64_t [])values + forKeys:(const int64_t [])keys + count:(NSUInteger)count { + // Cast is needed so the compiler knows what class we are invoking initWithUInt64s:forKeys:count: // on to get the type correct. - return [[(GPBInt64UInt64Dictionary*)[self alloc] initWithValues:values + return [[(GPBInt64UInt64Dictionary*)[self alloc] initWithUInt64s:values forKeys:keys count:count] autorelease]; } @@ -7893,12 +7895,12 @@ void GPBDictionaryReadEntry(id mapDictionary, } - (instancetype)init { - return [self initWithValues:NULL forKeys:NULL count:0]; + return [self initWithUInt64s:NULL forKeys:NULL count:0]; } -- (instancetype)initWithValues:(const uint64_t [])values - forKeys:(const int64_t [])keys - count:(NSUInteger)count { +- (instancetype)initWithUInt64s:(const uint64_t [])values + forKeys:(const int64_t [])keys + count:(NSUInteger)count { self = [super init]; if (self) { _dictionary = [[NSMutableDictionary alloc] init]; @@ -7912,7 +7914,7 @@ void GPBDictionaryReadEntry(id mapDictionary, } - (instancetype)initWithDictionary:(GPBInt64UInt64Dictionary *)dictionary { - self = [self initWithValues:NULL forKeys:NULL count:0]; + self = [self initWithUInt64s:NULL forKeys:NULL count:0]; if (self) { if (dictionary) { [_dictionary addEntriesFromDictionary:dictionary->_dictionary]; @@ -7923,7 +7925,7 @@ void GPBDictionaryReadEntry(id mapDictionary, - (instancetype)initWithCapacity:(NSUInteger)numItems { #pragma unused(numItems) - return [self initWithValues:NULL forKeys:NULL count:0]; + return [self initWithUInt64s:NULL forKeys:NULL count:0]; } - (void)dealloc { @@ -7961,7 +7963,7 @@ void GPBDictionaryReadEntry(id mapDictionary, return _dictionary.count; } -- (void)enumerateKeysAndValuesUsingBlock: +- (void)enumerateKeysAndUInt64sUsingBlock: (void (^)(int64_t key, uint64_t value, BOOL *stop))block { [_dictionary enumerateKeysAndObjectsUsingBlock:^(NSNumber *aKey, NSNumber *aValue, @@ -8019,13 +8021,13 @@ void GPBDictionaryReadEntry(id mapDictionary, } - (void)enumerateForTextFormat:(void (^)(id keyObj, id valueObj))block { - [self enumerateKeysAndValuesUsingBlock:^(int64_t key, uint64_t value, BOOL *stop) { + [self enumerateKeysAndUInt64sUsingBlock:^(int64_t key, uint64_t value, BOOL *stop) { #pragma unused(stop) block([NSString stringWithFormat:@"%lld", key], [NSString stringWithFormat:@"%llu", value]); }]; } -- (BOOL)valueForKey:(int64_t)key value:(uint64_t *)value { +- (BOOL)getUInt64:(nullable uint64_t *)value forKey:(int64_t)key { NSNumber *wrapped = [_dictionary objectForKey:@(key)]; if (wrapped && value) { *value = [wrapped unsignedLongLongValue]; @@ -8042,14 +8044,14 @@ void GPBDictionaryReadEntry(id mapDictionary, } } -- (void)setValue:(uint64_t)value forKey:(int64_t)key { +- (void)setUInt64:(uint64_t)value forKey:(int64_t)key { [_dictionary setObject:@(value) forKey:@(key)]; if (_autocreator) { GPBAutocreatedDictionaryModified(_autocreator, self); } } -- (void)removeValueForKey:(int64_t)aKey { +- (void)removeUInt64ForKey:(int64_t)aKey { [_dictionary removeObjectForKey:@(aKey)]; } @@ -8067,24 +8069,24 @@ void GPBDictionaryReadEntry(id mapDictionary, } + (instancetype)dictionary { - return [[[self alloc] initWithValues:NULL forKeys:NULL count:0] autorelease]; + return [[[self alloc] initWithInt64s:NULL forKeys:NULL count:0] autorelease]; } -+ (instancetype)dictionaryWithValue:(int64_t)value ++ (instancetype)dictionaryWithInt64:(int64_t)value forKey:(int64_t)key { - // Cast is needed so the compiler knows what class we are invoking initWithValues:forKeys:count: + // Cast is needed so the compiler knows what class we are invoking initWithInt64s:forKeys:count: // on to get the type correct. - return [[(GPBInt64Int64Dictionary*)[self alloc] initWithValues:&value + return [[(GPBInt64Int64Dictionary*)[self alloc] initWithInt64s:&value forKeys:&key count:1] autorelease]; } -+ (instancetype)dictionaryWithValues:(const int64_t [])values ++ (instancetype)dictionaryWithInt64s:(const int64_t [])values forKeys:(const int64_t [])keys count:(NSUInteger)count { - // Cast is needed so the compiler knows what class we are invoking initWithValues:forKeys:count: + // Cast is needed so the compiler knows what class we are invoking initWithInt64s:forKeys:count: // on to get the type correct. - return [[(GPBInt64Int64Dictionary*)[self alloc] initWithValues:values + return [[(GPBInt64Int64Dictionary*)[self alloc] initWithInt64s:values forKeys:keys count:count] autorelease]; } @@ -8100,10 +8102,10 @@ void GPBDictionaryReadEntry(id mapDictionary, } - (instancetype)init { - return [self initWithValues:NULL forKeys:NULL count:0]; + return [self initWithInt64s:NULL forKeys:NULL count:0]; } -- (instancetype)initWithValues:(const int64_t [])values +- (instancetype)initWithInt64s:(const int64_t [])values forKeys:(const int64_t [])keys count:(NSUInteger)count { self = [super init]; @@ -8119,7 +8121,7 @@ void GPBDictionaryReadEntry(id mapDictionary, } - (instancetype)initWithDictionary:(GPBInt64Int64Dictionary *)dictionary { - self = [self initWithValues:NULL forKeys:NULL count:0]; + self = [self initWithInt64s:NULL forKeys:NULL count:0]; if (self) { if (dictionary) { [_dictionary addEntriesFromDictionary:dictionary->_dictionary]; @@ -8130,7 +8132,7 @@ void GPBDictionaryReadEntry(id mapDictionary, - (instancetype)initWithCapacity:(NSUInteger)numItems { #pragma unused(numItems) - return [self initWithValues:NULL forKeys:NULL count:0]; + return [self initWithInt64s:NULL forKeys:NULL count:0]; } - (void)dealloc { @@ -8168,7 +8170,7 @@ void GPBDictionaryReadEntry(id mapDictionary, return _dictionary.count; } -- (void)enumerateKeysAndValuesUsingBlock: +- (void)enumerateKeysAndInt64sUsingBlock: (void (^)(int64_t key, int64_t value, BOOL *stop))block { [_dictionary enumerateKeysAndObjectsUsingBlock:^(NSNumber *aKey, NSNumber *aValue, @@ -8226,13 +8228,13 @@ void GPBDictionaryReadEntry(id mapDictionary, } - (void)enumerateForTextFormat:(void (^)(id keyObj, id valueObj))block { - [self enumerateKeysAndValuesUsingBlock:^(int64_t key, int64_t value, BOOL *stop) { + [self enumerateKeysAndInt64sUsingBlock:^(int64_t key, int64_t value, BOOL *stop) { #pragma unused(stop) block([NSString stringWithFormat:@"%lld", key], [NSString stringWithFormat:@"%lld", value]); }]; } -- (BOOL)valueForKey:(int64_t)key value:(int64_t *)value { +- (BOOL)getInt64:(nullable int64_t *)value forKey:(int64_t)key { NSNumber *wrapped = [_dictionary objectForKey:@(key)]; if (wrapped && value) { *value = [wrapped longLongValue]; @@ -8249,14 +8251,14 @@ void GPBDictionaryReadEntry(id mapDictionary, } } -- (void)setValue:(int64_t)value forKey:(int64_t)key { +- (void)setInt64:(int64_t)value forKey:(int64_t)key { [_dictionary setObject:@(value) forKey:@(key)]; if (_autocreator) { GPBAutocreatedDictionaryModified(_autocreator, self); } } -- (void)removeValueForKey:(int64_t)aKey { +- (void)removeInt64ForKey:(int64_t)aKey { [_dictionary removeObjectForKey:@(aKey)]; } @@ -8274,24 +8276,24 @@ void GPBDictionaryReadEntry(id mapDictionary, } + (instancetype)dictionary { - return [[[self alloc] initWithValues:NULL forKeys:NULL count:0] autorelease]; + return [[[self alloc] initWithBools:NULL forKeys:NULL count:0] autorelease]; } -+ (instancetype)dictionaryWithValue:(BOOL)value - forKey:(int64_t)key { - // Cast is needed so the compiler knows what class we are invoking initWithValues:forKeys:count: ++ (instancetype)dictionaryWithBool:(BOOL)value + forKey:(int64_t)key { + // Cast is needed so the compiler knows what class we are invoking initWithBools:forKeys:count: // on to get the type correct. - return [[(GPBInt64BoolDictionary*)[self alloc] initWithValues:&value - forKeys:&key - count:1] autorelease]; + return [[(GPBInt64BoolDictionary*)[self alloc] initWithBools:&value + forKeys:&key + count:1] autorelease]; } -+ (instancetype)dictionaryWithValues:(const BOOL [])values - forKeys:(const int64_t [])keys - count:(NSUInteger)count { - // Cast is needed so the compiler knows what class we are invoking initWithValues:forKeys:count: ++ (instancetype)dictionaryWithBools:(const BOOL [])values + forKeys:(const int64_t [])keys + count:(NSUInteger)count { + // Cast is needed so the compiler knows what class we are invoking initWithBools:forKeys:count: // on to get the type correct. - return [[(GPBInt64BoolDictionary*)[self alloc] initWithValues:values + return [[(GPBInt64BoolDictionary*)[self alloc] initWithBools:values forKeys:keys count:count] autorelease]; } @@ -8307,12 +8309,12 @@ void GPBDictionaryReadEntry(id mapDictionary, } - (instancetype)init { - return [self initWithValues:NULL forKeys:NULL count:0]; + return [self initWithBools:NULL forKeys:NULL count:0]; } -- (instancetype)initWithValues:(const BOOL [])values - forKeys:(const int64_t [])keys - count:(NSUInteger)count { +- (instancetype)initWithBools:(const BOOL [])values + forKeys:(const int64_t [])keys + count:(NSUInteger)count { self = [super init]; if (self) { _dictionary = [[NSMutableDictionary alloc] init]; @@ -8326,7 +8328,7 @@ void GPBDictionaryReadEntry(id mapDictionary, } - (instancetype)initWithDictionary:(GPBInt64BoolDictionary *)dictionary { - self = [self initWithValues:NULL forKeys:NULL count:0]; + self = [self initWithBools:NULL forKeys:NULL count:0]; if (self) { if (dictionary) { [_dictionary addEntriesFromDictionary:dictionary->_dictionary]; @@ -8337,7 +8339,7 @@ void GPBDictionaryReadEntry(id mapDictionary, - (instancetype)initWithCapacity:(NSUInteger)numItems { #pragma unused(numItems) - return [self initWithValues:NULL forKeys:NULL count:0]; + return [self initWithBools:NULL forKeys:NULL count:0]; } - (void)dealloc { @@ -8375,7 +8377,7 @@ void GPBDictionaryReadEntry(id mapDictionary, return _dictionary.count; } -- (void)enumerateKeysAndValuesUsingBlock: +- (void)enumerateKeysAndBoolsUsingBlock: (void (^)(int64_t key, BOOL value, BOOL *stop))block { [_dictionary enumerateKeysAndObjectsUsingBlock:^(NSNumber *aKey, NSNumber *aValue, @@ -8433,13 +8435,13 @@ void GPBDictionaryReadEntry(id mapDictionary, } - (void)enumerateForTextFormat:(void (^)(id keyObj, id valueObj))block { - [self enumerateKeysAndValuesUsingBlock:^(int64_t key, BOOL value, BOOL *stop) { + [self enumerateKeysAndBoolsUsingBlock:^(int64_t key, BOOL value, BOOL *stop) { #pragma unused(stop) block([NSString stringWithFormat:@"%lld", key], (value ? @"true" : @"false")); }]; } -- (BOOL)valueForKey:(int64_t)key value:(BOOL *)value { +- (BOOL)getBool:(nullable BOOL *)value forKey:(int64_t)key { NSNumber *wrapped = [_dictionary objectForKey:@(key)]; if (wrapped && value) { *value = [wrapped boolValue]; @@ -8456,14 +8458,14 @@ void GPBDictionaryReadEntry(id mapDictionary, } } -- (void)setValue:(BOOL)value forKey:(int64_t)key { +- (void)setBool:(BOOL)value forKey:(int64_t)key { [_dictionary setObject:@(value) forKey:@(key)]; if (_autocreator) { GPBAutocreatedDictionaryModified(_autocreator, self); } } -- (void)removeValueForKey:(int64_t)aKey { +- (void)removeBoolForKey:(int64_t)aKey { [_dictionary removeObjectForKey:@(aKey)]; } @@ -8481,24 +8483,24 @@ void GPBDictionaryReadEntry(id mapDictionary, } + (instancetype)dictionary { - return [[[self alloc] initWithValues:NULL forKeys:NULL count:0] autorelease]; + return [[[self alloc] initWithFloats:NULL forKeys:NULL count:0] autorelease]; } -+ (instancetype)dictionaryWithValue:(float)value ++ (instancetype)dictionaryWithFloat:(float)value forKey:(int64_t)key { - // Cast is needed so the compiler knows what class we are invoking initWithValues:forKeys:count: + // Cast is needed so the compiler knows what class we are invoking initWithFloats:forKeys:count: // on to get the type correct. - return [[(GPBInt64FloatDictionary*)[self alloc] initWithValues:&value + return [[(GPBInt64FloatDictionary*)[self alloc] initWithFloats:&value forKeys:&key count:1] autorelease]; } -+ (instancetype)dictionaryWithValues:(const float [])values ++ (instancetype)dictionaryWithFloats:(const float [])values forKeys:(const int64_t [])keys count:(NSUInteger)count { - // Cast is needed so the compiler knows what class we are invoking initWithValues:forKeys:count: + // Cast is needed so the compiler knows what class we are invoking initWithFloats:forKeys:count: // on to get the type correct. - return [[(GPBInt64FloatDictionary*)[self alloc] initWithValues:values + return [[(GPBInt64FloatDictionary*)[self alloc] initWithFloats:values forKeys:keys count:count] autorelease]; } @@ -8514,10 +8516,10 @@ void GPBDictionaryReadEntry(id mapDictionary, } - (instancetype)init { - return [self initWithValues:NULL forKeys:NULL count:0]; + return [self initWithFloats:NULL forKeys:NULL count:0]; } -- (instancetype)initWithValues:(const float [])values +- (instancetype)initWithFloats:(const float [])values forKeys:(const int64_t [])keys count:(NSUInteger)count { self = [super init]; @@ -8533,7 +8535,7 @@ void GPBDictionaryReadEntry(id mapDictionary, } - (instancetype)initWithDictionary:(GPBInt64FloatDictionary *)dictionary { - self = [self initWithValues:NULL forKeys:NULL count:0]; + self = [self initWithFloats:NULL forKeys:NULL count:0]; if (self) { if (dictionary) { [_dictionary addEntriesFromDictionary:dictionary->_dictionary]; @@ -8544,7 +8546,7 @@ void GPBDictionaryReadEntry(id mapDictionary, - (instancetype)initWithCapacity:(NSUInteger)numItems { #pragma unused(numItems) - return [self initWithValues:NULL forKeys:NULL count:0]; + return [self initWithFloats:NULL forKeys:NULL count:0]; } - (void)dealloc { @@ -8582,7 +8584,7 @@ void GPBDictionaryReadEntry(id mapDictionary, return _dictionary.count; } -- (void)enumerateKeysAndValuesUsingBlock: +- (void)enumerateKeysAndFloatsUsingBlock: (void (^)(int64_t key, float value, BOOL *stop))block { [_dictionary enumerateKeysAndObjectsUsingBlock:^(NSNumber *aKey, NSNumber *aValue, @@ -8640,13 +8642,13 @@ void GPBDictionaryReadEntry(id mapDictionary, } - (void)enumerateForTextFormat:(void (^)(id keyObj, id valueObj))block { - [self enumerateKeysAndValuesUsingBlock:^(int64_t key, float value, BOOL *stop) { + [self enumerateKeysAndFloatsUsingBlock:^(int64_t key, float value, BOOL *stop) { #pragma unused(stop) block([NSString stringWithFormat:@"%lld", key], [NSString stringWithFormat:@"%.*g", FLT_DIG, value]); }]; } -- (BOOL)valueForKey:(int64_t)key value:(float *)value { +- (BOOL)getFloat:(nullable float *)value forKey:(int64_t)key { NSNumber *wrapped = [_dictionary objectForKey:@(key)]; if (wrapped && value) { *value = [wrapped floatValue]; @@ -8663,14 +8665,14 @@ void GPBDictionaryReadEntry(id mapDictionary, } } -- (void)setValue:(float)value forKey:(int64_t)key { +- (void)setFloat:(float)value forKey:(int64_t)key { [_dictionary setObject:@(value) forKey:@(key)]; if (_autocreator) { GPBAutocreatedDictionaryModified(_autocreator, self); } } -- (void)removeValueForKey:(int64_t)aKey { +- (void)removeFloatForKey:(int64_t)aKey { [_dictionary removeObjectForKey:@(aKey)]; } @@ -8688,24 +8690,24 @@ void GPBDictionaryReadEntry(id mapDictionary, } + (instancetype)dictionary { - return [[[self alloc] initWithValues:NULL forKeys:NULL count:0] autorelease]; + return [[[self alloc] initWithDoubles:NULL forKeys:NULL count:0] autorelease]; } -+ (instancetype)dictionaryWithValue:(double)value - forKey:(int64_t)key { - // Cast is needed so the compiler knows what class we are invoking initWithValues:forKeys:count: ++ (instancetype)dictionaryWithDouble:(double)value + forKey:(int64_t)key { + // Cast is needed so the compiler knows what class we are invoking initWithDoubles:forKeys:count: // on to get the type correct. - return [[(GPBInt64DoubleDictionary*)[self alloc] initWithValues:&value - forKeys:&key - count:1] autorelease]; + return [[(GPBInt64DoubleDictionary*)[self alloc] initWithDoubles:&value + forKeys:&key + count:1] autorelease]; } -+ (instancetype)dictionaryWithValues:(const double [])values - forKeys:(const int64_t [])keys - count:(NSUInteger)count { - // Cast is needed so the compiler knows what class we are invoking initWithValues:forKeys:count: ++ (instancetype)dictionaryWithDoubles:(const double [])values + forKeys:(const int64_t [])keys + count:(NSUInteger)count { + // Cast is needed so the compiler knows what class we are invoking initWithDoubles:forKeys:count: // on to get the type correct. - return [[(GPBInt64DoubleDictionary*)[self alloc] initWithValues:values + return [[(GPBInt64DoubleDictionary*)[self alloc] initWithDoubles:values forKeys:keys count:count] autorelease]; } @@ -8721,12 +8723,12 @@ void GPBDictionaryReadEntry(id mapDictionary, } - (instancetype)init { - return [self initWithValues:NULL forKeys:NULL count:0]; + return [self initWithDoubles:NULL forKeys:NULL count:0]; } -- (instancetype)initWithValues:(const double [])values - forKeys:(const int64_t [])keys - count:(NSUInteger)count { +- (instancetype)initWithDoubles:(const double [])values + forKeys:(const int64_t [])keys + count:(NSUInteger)count { self = [super init]; if (self) { _dictionary = [[NSMutableDictionary alloc] init]; @@ -8740,7 +8742,7 @@ void GPBDictionaryReadEntry(id mapDictionary, } - (instancetype)initWithDictionary:(GPBInt64DoubleDictionary *)dictionary { - self = [self initWithValues:NULL forKeys:NULL count:0]; + self = [self initWithDoubles:NULL forKeys:NULL count:0]; if (self) { if (dictionary) { [_dictionary addEntriesFromDictionary:dictionary->_dictionary]; @@ -8751,7 +8753,7 @@ void GPBDictionaryReadEntry(id mapDictionary, - (instancetype)initWithCapacity:(NSUInteger)numItems { #pragma unused(numItems) - return [self initWithValues:NULL forKeys:NULL count:0]; + return [self initWithDoubles:NULL forKeys:NULL count:0]; } - (void)dealloc { @@ -8789,7 +8791,7 @@ void GPBDictionaryReadEntry(id mapDictionary, return _dictionary.count; } -- (void)enumerateKeysAndValuesUsingBlock: +- (void)enumerateKeysAndDoublesUsingBlock: (void (^)(int64_t key, double value, BOOL *stop))block { [_dictionary enumerateKeysAndObjectsUsingBlock:^(NSNumber *aKey, NSNumber *aValue, @@ -8847,13 +8849,13 @@ void GPBDictionaryReadEntry(id mapDictionary, } - (void)enumerateForTextFormat:(void (^)(id keyObj, id valueObj))block { - [self enumerateKeysAndValuesUsingBlock:^(int64_t key, double value, BOOL *stop) { + [self enumerateKeysAndDoublesUsingBlock:^(int64_t key, double value, BOOL *stop) { #pragma unused(stop) block([NSString stringWithFormat:@"%lld", key], [NSString stringWithFormat:@"%.*lg", DBL_DIG, value]); }]; } -- (BOOL)valueForKey:(int64_t)key value:(double *)value { +- (BOOL)getDouble:(nullable double *)value forKey:(int64_t)key { NSNumber *wrapped = [_dictionary objectForKey:@(key)]; if (wrapped && value) { *value = [wrapped doubleValue]; @@ -8870,14 +8872,14 @@ void GPBDictionaryReadEntry(id mapDictionary, } } -- (void)setValue:(double)value forKey:(int64_t)key { +- (void)setDouble:(double)value forKey:(int64_t)key { [_dictionary setObject:@(value) forKey:@(key)]; if (_autocreator) { GPBAutocreatedDictionaryModified(_autocreator, self); } } -- (void)removeValueForKey:(int64_t)aKey { +- (void)removeDoubleForKey:(int64_t)aKey { [_dictionary removeObjectForKey:@(aKey)]; } @@ -9100,7 +9102,7 @@ void GPBDictionaryReadEntry(id mapDictionary, }]; } -- (BOOL)valueForKey:(int64_t)key value:(int32_t *)value { +- (BOOL)getEnum:(int32_t *)value forKey:(int64_t)key { NSNumber *wrapped = [_dictionary objectForKey:@(key)]; if (wrapped && value) { int32_t result = [wrapped intValue]; @@ -9112,7 +9114,7 @@ void GPBDictionaryReadEntry(id mapDictionary, return (wrapped != NULL); } -- (BOOL)valueForKey:(int64_t)key rawValue:(int32_t *)rawValue { +- (BOOL)getRawValue:(int32_t *)rawValue forKey:(int64_t)key { NSNumber *wrapped = [_dictionary objectForKey:@(key)]; if (wrapped && rawValue) { *rawValue = [wrapped intValue]; @@ -9120,7 +9122,7 @@ void GPBDictionaryReadEntry(id mapDictionary, return (wrapped != NULL); } -- (void)enumerateKeysAndValuesUsingBlock: +- (void)enumerateKeysAndEnumsUsingBlock: (void (^)(int64_t key, int32_t value, BOOL *stop))block { GPBEnumValidationFunc func = _validationFunc; [_dictionary enumerateKeysAndObjectsUsingBlock:^(NSNumber *aKey, @@ -9150,7 +9152,7 @@ void GPBDictionaryReadEntry(id mapDictionary, } } -- (void)removeValueForKey:(int64_t)aKey { +- (void)removeEnumForKey:(int64_t)aKey { [_dictionary removeObjectForKey:@(aKey)]; } @@ -9158,7 +9160,7 @@ void GPBDictionaryReadEntry(id mapDictionary, [_dictionary removeAllObjects]; } -- (void)setValue:(int32_t)value forKey:(int64_t)key { +- (void)setEnum:(int32_t)value forKey:(int64_t)key { if (!_validationFunc(value)) { [NSException raise:NSInvalidArgumentException format:@"GPBInt64EnumDictionary: Attempt to set an unknown enum value (%d)", @@ -9419,24 +9421,24 @@ void GPBDictionaryReadEntry(id mapDictionary, } + (instancetype)dictionary { - return [[[self alloc] initWithValues:NULL forKeys:NULL count:0] autorelease]; + return [[[self alloc] initWithUInt32s:NULL forKeys:NULL count:0] autorelease]; } -+ (instancetype)dictionaryWithValue:(uint32_t)value - forKey:(NSString *)key { - // Cast is needed so the compiler knows what class we are invoking initWithValues:forKeys:count: ++ (instancetype)dictionaryWithUInt32:(uint32_t)value + forKey:(NSString *)key { + // Cast is needed so the compiler knows what class we are invoking initWithUInt32s:forKeys:count: // on to get the type correct. - return [[(GPBStringUInt32Dictionary*)[self alloc] initWithValues:&value - forKeys:&key - count:1] autorelease]; + return [[(GPBStringUInt32Dictionary*)[self alloc] initWithUInt32s:&value + forKeys:&key + count:1] autorelease]; } -+ (instancetype)dictionaryWithValues:(const uint32_t [])values - forKeys:(const NSString * [])keys - count:(NSUInteger)count { - // Cast is needed so the compiler knows what class we are invoking initWithValues:forKeys:count: ++ (instancetype)dictionaryWithUInt32s:(const uint32_t [])values + forKeys:(const NSString * [])keys + count:(NSUInteger)count { + // Cast is needed so the compiler knows what class we are invoking initWithUInt32s:forKeys:count: // on to get the type correct. - return [[(GPBStringUInt32Dictionary*)[self alloc] initWithValues:values + return [[(GPBStringUInt32Dictionary*)[self alloc] initWithUInt32s:values forKeys:keys count:count] autorelease]; } @@ -9452,12 +9454,12 @@ void GPBDictionaryReadEntry(id mapDictionary, } - (instancetype)init { - return [self initWithValues:NULL forKeys:NULL count:0]; + return [self initWithUInt32s:NULL forKeys:NULL count:0]; } -- (instancetype)initWithValues:(const uint32_t [])values - forKeys:(const NSString * [])keys - count:(NSUInteger)count { +- (instancetype)initWithUInt32s:(const uint32_t [])values + forKeys:(const NSString * [])keys + count:(NSUInteger)count { self = [super init]; if (self) { _dictionary = [[NSMutableDictionary alloc] init]; @@ -9475,7 +9477,7 @@ void GPBDictionaryReadEntry(id mapDictionary, } - (instancetype)initWithDictionary:(GPBStringUInt32Dictionary *)dictionary { - self = [self initWithValues:NULL forKeys:NULL count:0]; + self = [self initWithUInt32s:NULL forKeys:NULL count:0]; if (self) { if (dictionary) { [_dictionary addEntriesFromDictionary:dictionary->_dictionary]; @@ -9486,7 +9488,7 @@ void GPBDictionaryReadEntry(id mapDictionary, - (instancetype)initWithCapacity:(NSUInteger)numItems { #pragma unused(numItems) - return [self initWithValues:NULL forKeys:NULL count:0]; + return [self initWithUInt32s:NULL forKeys:NULL count:0]; } - (void)dealloc { @@ -9524,7 +9526,7 @@ void GPBDictionaryReadEntry(id mapDictionary, return _dictionary.count; } -- (void)enumerateKeysAndValuesUsingBlock: +- (void)enumerateKeysAndUInt32sUsingBlock: (void (^)(NSString *key, uint32_t value, BOOL *stop))block { [_dictionary enumerateKeysAndObjectsUsingBlock:^(NSString *aKey, NSNumber *aValue, @@ -9582,13 +9584,13 @@ void GPBDictionaryReadEntry(id mapDictionary, } - (void)enumerateForTextFormat:(void (^)(id keyObj, id valueObj))block { - [self enumerateKeysAndValuesUsingBlock:^(NSString *key, uint32_t value, BOOL *stop) { + [self enumerateKeysAndUInt32sUsingBlock:^(NSString *key, uint32_t value, BOOL *stop) { #pragma unused(stop) block(key, [NSString stringWithFormat:@"%u", value]); }]; } -- (BOOL)valueForKey:(NSString *)key value:(uint32_t *)value { +- (BOOL)getUInt32:(nullable uint32_t *)value forKey:(NSString *)key { NSNumber *wrapped = [_dictionary objectForKey:key]; if (wrapped && value) { *value = [wrapped unsignedIntValue]; @@ -9605,7 +9607,7 @@ void GPBDictionaryReadEntry(id mapDictionary, } } -- (void)setValue:(uint32_t)value forKey:(NSString *)key { +- (void)setUInt32:(uint32_t)value forKey:(NSString *)key { if (!key) { [NSException raise:NSInvalidArgumentException format:@"Attempting to add nil key to a Dictionary"]; @@ -9616,7 +9618,7 @@ void GPBDictionaryReadEntry(id mapDictionary, } } -- (void)removeValueForKey:(NSString *)aKey { +- (void)removeUInt32ForKey:(NSString *)aKey { [_dictionary removeObjectForKey:aKey]; } @@ -9634,24 +9636,24 @@ void GPBDictionaryReadEntry(id mapDictionary, } + (instancetype)dictionary { - return [[[self alloc] initWithValues:NULL forKeys:NULL count:0] autorelease]; + return [[[self alloc] initWithInt32s:NULL forKeys:NULL count:0] autorelease]; } -+ (instancetype)dictionaryWithValue:(int32_t)value ++ (instancetype)dictionaryWithInt32:(int32_t)value forKey:(NSString *)key { - // Cast is needed so the compiler knows what class we are invoking initWithValues:forKeys:count: + // Cast is needed so the compiler knows what class we are invoking initWithInt32s:forKeys:count: // on to get the type correct. - return [[(GPBStringInt32Dictionary*)[self alloc] initWithValues:&value + return [[(GPBStringInt32Dictionary*)[self alloc] initWithInt32s:&value forKeys:&key count:1] autorelease]; } -+ (instancetype)dictionaryWithValues:(const int32_t [])values ++ (instancetype)dictionaryWithInt32s:(const int32_t [])values forKeys:(const NSString * [])keys count:(NSUInteger)count { - // Cast is needed so the compiler knows what class we are invoking initWithValues:forKeys:count: + // Cast is needed so the compiler knows what class we are invoking initWithInt32s:forKeys:count: // on to get the type correct. - return [[(GPBStringInt32Dictionary*)[self alloc] initWithValues:values + return [[(GPBStringInt32Dictionary*)[self alloc] initWithInt32s:values forKeys:keys count:count] autorelease]; } @@ -9667,10 +9669,10 @@ void GPBDictionaryReadEntry(id mapDictionary, } - (instancetype)init { - return [self initWithValues:NULL forKeys:NULL count:0]; + return [self initWithInt32s:NULL forKeys:NULL count:0]; } -- (instancetype)initWithValues:(const int32_t [])values +- (instancetype)initWithInt32s:(const int32_t [])values forKeys:(const NSString * [])keys count:(NSUInteger)count { self = [super init]; @@ -9690,7 +9692,7 @@ void GPBDictionaryReadEntry(id mapDictionary, } - (instancetype)initWithDictionary:(GPBStringInt32Dictionary *)dictionary { - self = [self initWithValues:NULL forKeys:NULL count:0]; + self = [self initWithInt32s:NULL forKeys:NULL count:0]; if (self) { if (dictionary) { [_dictionary addEntriesFromDictionary:dictionary->_dictionary]; @@ -9701,7 +9703,7 @@ void GPBDictionaryReadEntry(id mapDictionary, - (instancetype)initWithCapacity:(NSUInteger)numItems { #pragma unused(numItems) - return [self initWithValues:NULL forKeys:NULL count:0]; + return [self initWithInt32s:NULL forKeys:NULL count:0]; } - (void)dealloc { @@ -9739,7 +9741,7 @@ void GPBDictionaryReadEntry(id mapDictionary, return _dictionary.count; } -- (void)enumerateKeysAndValuesUsingBlock: +- (void)enumerateKeysAndInt32sUsingBlock: (void (^)(NSString *key, int32_t value, BOOL *stop))block { [_dictionary enumerateKeysAndObjectsUsingBlock:^(NSString *aKey, NSNumber *aValue, @@ -9797,13 +9799,13 @@ void GPBDictionaryReadEntry(id mapDictionary, } - (void)enumerateForTextFormat:(void (^)(id keyObj, id valueObj))block { - [self enumerateKeysAndValuesUsingBlock:^(NSString *key, int32_t value, BOOL *stop) { + [self enumerateKeysAndInt32sUsingBlock:^(NSString *key, int32_t value, BOOL *stop) { #pragma unused(stop) block(key, [NSString stringWithFormat:@"%d", value]); }]; } -- (BOOL)valueForKey:(NSString *)key value:(int32_t *)value { +- (BOOL)getInt32:(nullable int32_t *)value forKey:(NSString *)key { NSNumber *wrapped = [_dictionary objectForKey:key]; if (wrapped && value) { *value = [wrapped intValue]; @@ -9820,7 +9822,7 @@ void GPBDictionaryReadEntry(id mapDictionary, } } -- (void)setValue:(int32_t)value forKey:(NSString *)key { +- (void)setInt32:(int32_t)value forKey:(NSString *)key { if (!key) { [NSException raise:NSInvalidArgumentException format:@"Attempting to add nil key to a Dictionary"]; @@ -9831,7 +9833,7 @@ void GPBDictionaryReadEntry(id mapDictionary, } } -- (void)removeValueForKey:(NSString *)aKey { +- (void)removeInt32ForKey:(NSString *)aKey { [_dictionary removeObjectForKey:aKey]; } @@ -9849,24 +9851,24 @@ void GPBDictionaryReadEntry(id mapDictionary, } + (instancetype)dictionary { - return [[[self alloc] initWithValues:NULL forKeys:NULL count:0] autorelease]; + return [[[self alloc] initWithUInt64s:NULL forKeys:NULL count:0] autorelease]; } -+ (instancetype)dictionaryWithValue:(uint64_t)value - forKey:(NSString *)key { - // Cast is needed so the compiler knows what class we are invoking initWithValues:forKeys:count: ++ (instancetype)dictionaryWithUInt64:(uint64_t)value + forKey:(NSString *)key { + // Cast is needed so the compiler knows what class we are invoking initWithUInt64s:forKeys:count: // on to get the type correct. - return [[(GPBStringUInt64Dictionary*)[self alloc] initWithValues:&value - forKeys:&key - count:1] autorelease]; + return [[(GPBStringUInt64Dictionary*)[self alloc] initWithUInt64s:&value + forKeys:&key + count:1] autorelease]; } -+ (instancetype)dictionaryWithValues:(const uint64_t [])values - forKeys:(const NSString * [])keys - count:(NSUInteger)count { - // Cast is needed so the compiler knows what class we are invoking initWithValues:forKeys:count: ++ (instancetype)dictionaryWithUInt64s:(const uint64_t [])values + forKeys:(const NSString * [])keys + count:(NSUInteger)count { + // Cast is needed so the compiler knows what class we are invoking initWithUInt64s:forKeys:count: // on to get the type correct. - return [[(GPBStringUInt64Dictionary*)[self alloc] initWithValues:values + return [[(GPBStringUInt64Dictionary*)[self alloc] initWithUInt64s:values forKeys:keys count:count] autorelease]; } @@ -9882,12 +9884,12 @@ void GPBDictionaryReadEntry(id mapDictionary, } - (instancetype)init { - return [self initWithValues:NULL forKeys:NULL count:0]; + return [self initWithUInt64s:NULL forKeys:NULL count:0]; } -- (instancetype)initWithValues:(const uint64_t [])values - forKeys:(const NSString * [])keys - count:(NSUInteger)count { +- (instancetype)initWithUInt64s:(const uint64_t [])values + forKeys:(const NSString * [])keys + count:(NSUInteger)count { self = [super init]; if (self) { _dictionary = [[NSMutableDictionary alloc] init]; @@ -9905,7 +9907,7 @@ void GPBDictionaryReadEntry(id mapDictionary, } - (instancetype)initWithDictionary:(GPBStringUInt64Dictionary *)dictionary { - self = [self initWithValues:NULL forKeys:NULL count:0]; + self = [self initWithUInt64s:NULL forKeys:NULL count:0]; if (self) { if (dictionary) { [_dictionary addEntriesFromDictionary:dictionary->_dictionary]; @@ -9916,7 +9918,7 @@ void GPBDictionaryReadEntry(id mapDictionary, - (instancetype)initWithCapacity:(NSUInteger)numItems { #pragma unused(numItems) - return [self initWithValues:NULL forKeys:NULL count:0]; + return [self initWithUInt64s:NULL forKeys:NULL count:0]; } - (void)dealloc { @@ -9954,7 +9956,7 @@ void GPBDictionaryReadEntry(id mapDictionary, return _dictionary.count; } -- (void)enumerateKeysAndValuesUsingBlock: +- (void)enumerateKeysAndUInt64sUsingBlock: (void (^)(NSString *key, uint64_t value, BOOL *stop))block { [_dictionary enumerateKeysAndObjectsUsingBlock:^(NSString *aKey, NSNumber *aValue, @@ -10012,13 +10014,13 @@ void GPBDictionaryReadEntry(id mapDictionary, } - (void)enumerateForTextFormat:(void (^)(id keyObj, id valueObj))block { - [self enumerateKeysAndValuesUsingBlock:^(NSString *key, uint64_t value, BOOL *stop) { + [self enumerateKeysAndUInt64sUsingBlock:^(NSString *key, uint64_t value, BOOL *stop) { #pragma unused(stop) block(key, [NSString stringWithFormat:@"%llu", value]); }]; } -- (BOOL)valueForKey:(NSString *)key value:(uint64_t *)value { +- (BOOL)getUInt64:(nullable uint64_t *)value forKey:(NSString *)key { NSNumber *wrapped = [_dictionary objectForKey:key]; if (wrapped && value) { *value = [wrapped unsignedLongLongValue]; @@ -10035,7 +10037,7 @@ void GPBDictionaryReadEntry(id mapDictionary, } } -- (void)setValue:(uint64_t)value forKey:(NSString *)key { +- (void)setUInt64:(uint64_t)value forKey:(NSString *)key { if (!key) { [NSException raise:NSInvalidArgumentException format:@"Attempting to add nil key to a Dictionary"]; @@ -10046,7 +10048,7 @@ void GPBDictionaryReadEntry(id mapDictionary, } } -- (void)removeValueForKey:(NSString *)aKey { +- (void)removeUInt64ForKey:(NSString *)aKey { [_dictionary removeObjectForKey:aKey]; } @@ -10064,24 +10066,24 @@ void GPBDictionaryReadEntry(id mapDictionary, } + (instancetype)dictionary { - return [[[self alloc] initWithValues:NULL forKeys:NULL count:0] autorelease]; + return [[[self alloc] initWithInt64s:NULL forKeys:NULL count:0] autorelease]; } -+ (instancetype)dictionaryWithValue:(int64_t)value ++ (instancetype)dictionaryWithInt64:(int64_t)value forKey:(NSString *)key { - // Cast is needed so the compiler knows what class we are invoking initWithValues:forKeys:count: + // Cast is needed so the compiler knows what class we are invoking initWithInt64s:forKeys:count: // on to get the type correct. - return [[(GPBStringInt64Dictionary*)[self alloc] initWithValues:&value + return [[(GPBStringInt64Dictionary*)[self alloc] initWithInt64s:&value forKeys:&key count:1] autorelease]; } -+ (instancetype)dictionaryWithValues:(const int64_t [])values ++ (instancetype)dictionaryWithInt64s:(const int64_t [])values forKeys:(const NSString * [])keys count:(NSUInteger)count { - // Cast is needed so the compiler knows what class we are invoking initWithValues:forKeys:count: + // Cast is needed so the compiler knows what class we are invoking initWithInt64s:forKeys:count: // on to get the type correct. - return [[(GPBStringInt64Dictionary*)[self alloc] initWithValues:values + return [[(GPBStringInt64Dictionary*)[self alloc] initWithInt64s:values forKeys:keys count:count] autorelease]; } @@ -10097,10 +10099,10 @@ void GPBDictionaryReadEntry(id mapDictionary, } - (instancetype)init { - return [self initWithValues:NULL forKeys:NULL count:0]; + return [self initWithInt64s:NULL forKeys:NULL count:0]; } -- (instancetype)initWithValues:(const int64_t [])values +- (instancetype)initWithInt64s:(const int64_t [])values forKeys:(const NSString * [])keys count:(NSUInteger)count { self = [super init]; @@ -10120,7 +10122,7 @@ void GPBDictionaryReadEntry(id mapDictionary, } - (instancetype)initWithDictionary:(GPBStringInt64Dictionary *)dictionary { - self = [self initWithValues:NULL forKeys:NULL count:0]; + self = [self initWithInt64s:NULL forKeys:NULL count:0]; if (self) { if (dictionary) { [_dictionary addEntriesFromDictionary:dictionary->_dictionary]; @@ -10131,7 +10133,7 @@ void GPBDictionaryReadEntry(id mapDictionary, - (instancetype)initWithCapacity:(NSUInteger)numItems { #pragma unused(numItems) - return [self initWithValues:NULL forKeys:NULL count:0]; + return [self initWithInt64s:NULL forKeys:NULL count:0]; } - (void)dealloc { @@ -10169,7 +10171,7 @@ void GPBDictionaryReadEntry(id mapDictionary, return _dictionary.count; } -- (void)enumerateKeysAndValuesUsingBlock: +- (void)enumerateKeysAndInt64sUsingBlock: (void (^)(NSString *key, int64_t value, BOOL *stop))block { [_dictionary enumerateKeysAndObjectsUsingBlock:^(NSString *aKey, NSNumber *aValue, @@ -10227,13 +10229,13 @@ void GPBDictionaryReadEntry(id mapDictionary, } - (void)enumerateForTextFormat:(void (^)(id keyObj, id valueObj))block { - [self enumerateKeysAndValuesUsingBlock:^(NSString *key, int64_t value, BOOL *stop) { + [self enumerateKeysAndInt64sUsingBlock:^(NSString *key, int64_t value, BOOL *stop) { #pragma unused(stop) block(key, [NSString stringWithFormat:@"%lld", value]); }]; } -- (BOOL)valueForKey:(NSString *)key value:(int64_t *)value { +- (BOOL)getInt64:(nullable int64_t *)value forKey:(NSString *)key { NSNumber *wrapped = [_dictionary objectForKey:key]; if (wrapped && value) { *value = [wrapped longLongValue]; @@ -10250,7 +10252,7 @@ void GPBDictionaryReadEntry(id mapDictionary, } } -- (void)setValue:(int64_t)value forKey:(NSString *)key { +- (void)setInt64:(int64_t)value forKey:(NSString *)key { if (!key) { [NSException raise:NSInvalidArgumentException format:@"Attempting to add nil key to a Dictionary"]; @@ -10261,7 +10263,7 @@ void GPBDictionaryReadEntry(id mapDictionary, } } -- (void)removeValueForKey:(NSString *)aKey { +- (void)removeInt64ForKey:(NSString *)aKey { [_dictionary removeObjectForKey:aKey]; } @@ -10279,24 +10281,24 @@ void GPBDictionaryReadEntry(id mapDictionary, } + (instancetype)dictionary { - return [[[self alloc] initWithValues:NULL forKeys:NULL count:0] autorelease]; + return [[[self alloc] initWithBools:NULL forKeys:NULL count:0] autorelease]; } -+ (instancetype)dictionaryWithValue:(BOOL)value - forKey:(NSString *)key { - // Cast is needed so the compiler knows what class we are invoking initWithValues:forKeys:count: ++ (instancetype)dictionaryWithBool:(BOOL)value + forKey:(NSString *)key { + // Cast is needed so the compiler knows what class we are invoking initWithBools:forKeys:count: // on to get the type correct. - return [[(GPBStringBoolDictionary*)[self alloc] initWithValues:&value - forKeys:&key - count:1] autorelease]; + return [[(GPBStringBoolDictionary*)[self alloc] initWithBools:&value + forKeys:&key + count:1] autorelease]; } -+ (instancetype)dictionaryWithValues:(const BOOL [])values - forKeys:(const NSString * [])keys - count:(NSUInteger)count { - // Cast is needed so the compiler knows what class we are invoking initWithValues:forKeys:count: ++ (instancetype)dictionaryWithBools:(const BOOL [])values + forKeys:(const NSString * [])keys + count:(NSUInteger)count { + // Cast is needed so the compiler knows what class we are invoking initWithBools:forKeys:count: // on to get the type correct. - return [[(GPBStringBoolDictionary*)[self alloc] initWithValues:values + return [[(GPBStringBoolDictionary*)[self alloc] initWithBools:values forKeys:keys count:count] autorelease]; } @@ -10312,12 +10314,12 @@ void GPBDictionaryReadEntry(id mapDictionary, } - (instancetype)init { - return [self initWithValues:NULL forKeys:NULL count:0]; + return [self initWithBools:NULL forKeys:NULL count:0]; } -- (instancetype)initWithValues:(const BOOL [])values - forKeys:(const NSString * [])keys - count:(NSUInteger)count { +- (instancetype)initWithBools:(const BOOL [])values + forKeys:(const NSString * [])keys + count:(NSUInteger)count { self = [super init]; if (self) { _dictionary = [[NSMutableDictionary alloc] init]; @@ -10335,7 +10337,7 @@ void GPBDictionaryReadEntry(id mapDictionary, } - (instancetype)initWithDictionary:(GPBStringBoolDictionary *)dictionary { - self = [self initWithValues:NULL forKeys:NULL count:0]; + self = [self initWithBools:NULL forKeys:NULL count:0]; if (self) { if (dictionary) { [_dictionary addEntriesFromDictionary:dictionary->_dictionary]; @@ -10346,7 +10348,7 @@ void GPBDictionaryReadEntry(id mapDictionary, - (instancetype)initWithCapacity:(NSUInteger)numItems { #pragma unused(numItems) - return [self initWithValues:NULL forKeys:NULL count:0]; + return [self initWithBools:NULL forKeys:NULL count:0]; } - (void)dealloc { @@ -10384,7 +10386,7 @@ void GPBDictionaryReadEntry(id mapDictionary, return _dictionary.count; } -- (void)enumerateKeysAndValuesUsingBlock: +- (void)enumerateKeysAndBoolsUsingBlock: (void (^)(NSString *key, BOOL value, BOOL *stop))block { [_dictionary enumerateKeysAndObjectsUsingBlock:^(NSString *aKey, NSNumber *aValue, @@ -10442,13 +10444,13 @@ void GPBDictionaryReadEntry(id mapDictionary, } - (void)enumerateForTextFormat:(void (^)(id keyObj, id valueObj))block { - [self enumerateKeysAndValuesUsingBlock:^(NSString *key, BOOL value, BOOL *stop) { + [self enumerateKeysAndBoolsUsingBlock:^(NSString *key, BOOL value, BOOL *stop) { #pragma unused(stop) block(key, (value ? @"true" : @"false")); }]; } -- (BOOL)valueForKey:(NSString *)key value:(BOOL *)value { +- (BOOL)getBool:(nullable BOOL *)value forKey:(NSString *)key { NSNumber *wrapped = [_dictionary objectForKey:key]; if (wrapped && value) { *value = [wrapped boolValue]; @@ -10465,7 +10467,7 @@ void GPBDictionaryReadEntry(id mapDictionary, } } -- (void)setValue:(BOOL)value forKey:(NSString *)key { +- (void)setBool:(BOOL)value forKey:(NSString *)key { if (!key) { [NSException raise:NSInvalidArgumentException format:@"Attempting to add nil key to a Dictionary"]; @@ -10476,7 +10478,7 @@ void GPBDictionaryReadEntry(id mapDictionary, } } -- (void)removeValueForKey:(NSString *)aKey { +- (void)removeBoolForKey:(NSString *)aKey { [_dictionary removeObjectForKey:aKey]; } @@ -10494,24 +10496,24 @@ void GPBDictionaryReadEntry(id mapDictionary, } + (instancetype)dictionary { - return [[[self alloc] initWithValues:NULL forKeys:NULL count:0] autorelease]; + return [[[self alloc] initWithFloats:NULL forKeys:NULL count:0] autorelease]; } -+ (instancetype)dictionaryWithValue:(float)value ++ (instancetype)dictionaryWithFloat:(float)value forKey:(NSString *)key { - // Cast is needed so the compiler knows what class we are invoking initWithValues:forKeys:count: + // Cast is needed so the compiler knows what class we are invoking initWithFloats:forKeys:count: // on to get the type correct. - return [[(GPBStringFloatDictionary*)[self alloc] initWithValues:&value + return [[(GPBStringFloatDictionary*)[self alloc] initWithFloats:&value forKeys:&key count:1] autorelease]; } -+ (instancetype)dictionaryWithValues:(const float [])values ++ (instancetype)dictionaryWithFloats:(const float [])values forKeys:(const NSString * [])keys count:(NSUInteger)count { - // Cast is needed so the compiler knows what class we are invoking initWithValues:forKeys:count: + // Cast is needed so the compiler knows what class we are invoking initWithFloats:forKeys:count: // on to get the type correct. - return [[(GPBStringFloatDictionary*)[self alloc] initWithValues:values + return [[(GPBStringFloatDictionary*)[self alloc] initWithFloats:values forKeys:keys count:count] autorelease]; } @@ -10527,10 +10529,10 @@ void GPBDictionaryReadEntry(id mapDictionary, } - (instancetype)init { - return [self initWithValues:NULL forKeys:NULL count:0]; + return [self initWithFloats:NULL forKeys:NULL count:0]; } -- (instancetype)initWithValues:(const float [])values +- (instancetype)initWithFloats:(const float [])values forKeys:(const NSString * [])keys count:(NSUInteger)count { self = [super init]; @@ -10550,7 +10552,7 @@ void GPBDictionaryReadEntry(id mapDictionary, } - (instancetype)initWithDictionary:(GPBStringFloatDictionary *)dictionary { - self = [self initWithValues:NULL forKeys:NULL count:0]; + self = [self initWithFloats:NULL forKeys:NULL count:0]; if (self) { if (dictionary) { [_dictionary addEntriesFromDictionary:dictionary->_dictionary]; @@ -10561,7 +10563,7 @@ void GPBDictionaryReadEntry(id mapDictionary, - (instancetype)initWithCapacity:(NSUInteger)numItems { #pragma unused(numItems) - return [self initWithValues:NULL forKeys:NULL count:0]; + return [self initWithFloats:NULL forKeys:NULL count:0]; } - (void)dealloc { @@ -10599,7 +10601,7 @@ void GPBDictionaryReadEntry(id mapDictionary, return _dictionary.count; } -- (void)enumerateKeysAndValuesUsingBlock: +- (void)enumerateKeysAndFloatsUsingBlock: (void (^)(NSString *key, float value, BOOL *stop))block { [_dictionary enumerateKeysAndObjectsUsingBlock:^(NSString *aKey, NSNumber *aValue, @@ -10657,13 +10659,13 @@ void GPBDictionaryReadEntry(id mapDictionary, } - (void)enumerateForTextFormat:(void (^)(id keyObj, id valueObj))block { - [self enumerateKeysAndValuesUsingBlock:^(NSString *key, float value, BOOL *stop) { + [self enumerateKeysAndFloatsUsingBlock:^(NSString *key, float value, BOOL *stop) { #pragma unused(stop) block(key, [NSString stringWithFormat:@"%.*g", FLT_DIG, value]); }]; } -- (BOOL)valueForKey:(NSString *)key value:(float *)value { +- (BOOL)getFloat:(nullable float *)value forKey:(NSString *)key { NSNumber *wrapped = [_dictionary objectForKey:key]; if (wrapped && value) { *value = [wrapped floatValue]; @@ -10680,7 +10682,7 @@ void GPBDictionaryReadEntry(id mapDictionary, } } -- (void)setValue:(float)value forKey:(NSString *)key { +- (void)setFloat:(float)value forKey:(NSString *)key { if (!key) { [NSException raise:NSInvalidArgumentException format:@"Attempting to add nil key to a Dictionary"]; @@ -10691,7 +10693,7 @@ void GPBDictionaryReadEntry(id mapDictionary, } } -- (void)removeValueForKey:(NSString *)aKey { +- (void)removeFloatForKey:(NSString *)aKey { [_dictionary removeObjectForKey:aKey]; } @@ -10709,24 +10711,24 @@ void GPBDictionaryReadEntry(id mapDictionary, } + (instancetype)dictionary { - return [[[self alloc] initWithValues:NULL forKeys:NULL count:0] autorelease]; + return [[[self alloc] initWithDoubles:NULL forKeys:NULL count:0] autorelease]; } -+ (instancetype)dictionaryWithValue:(double)value - forKey:(NSString *)key { - // Cast is needed so the compiler knows what class we are invoking initWithValues:forKeys:count: ++ (instancetype)dictionaryWithDouble:(double)value + forKey:(NSString *)key { + // Cast is needed so the compiler knows what class we are invoking initWithDoubles:forKeys:count: // on to get the type correct. - return [[(GPBStringDoubleDictionary*)[self alloc] initWithValues:&value - forKeys:&key - count:1] autorelease]; + return [[(GPBStringDoubleDictionary*)[self alloc] initWithDoubles:&value + forKeys:&key + count:1] autorelease]; } -+ (instancetype)dictionaryWithValues:(const double [])values - forKeys:(const NSString * [])keys - count:(NSUInteger)count { - // Cast is needed so the compiler knows what class we are invoking initWithValues:forKeys:count: ++ (instancetype)dictionaryWithDoubles:(const double [])values + forKeys:(const NSString * [])keys + count:(NSUInteger)count { + // Cast is needed so the compiler knows what class we are invoking initWithDoubles:forKeys:count: // on to get the type correct. - return [[(GPBStringDoubleDictionary*)[self alloc] initWithValues:values + return [[(GPBStringDoubleDictionary*)[self alloc] initWithDoubles:values forKeys:keys count:count] autorelease]; } @@ -10742,12 +10744,12 @@ void GPBDictionaryReadEntry(id mapDictionary, } - (instancetype)init { - return [self initWithValues:NULL forKeys:NULL count:0]; + return [self initWithDoubles:NULL forKeys:NULL count:0]; } -- (instancetype)initWithValues:(const double [])values - forKeys:(const NSString * [])keys - count:(NSUInteger)count { +- (instancetype)initWithDoubles:(const double [])values + forKeys:(const NSString * [])keys + count:(NSUInteger)count { self = [super init]; if (self) { _dictionary = [[NSMutableDictionary alloc] init]; @@ -10765,7 +10767,7 @@ void GPBDictionaryReadEntry(id mapDictionary, } - (instancetype)initWithDictionary:(GPBStringDoubleDictionary *)dictionary { - self = [self initWithValues:NULL forKeys:NULL count:0]; + self = [self initWithDoubles:NULL forKeys:NULL count:0]; if (self) { if (dictionary) { [_dictionary addEntriesFromDictionary:dictionary->_dictionary]; @@ -10776,7 +10778,7 @@ void GPBDictionaryReadEntry(id mapDictionary, - (instancetype)initWithCapacity:(NSUInteger)numItems { #pragma unused(numItems) - return [self initWithValues:NULL forKeys:NULL count:0]; + return [self initWithDoubles:NULL forKeys:NULL count:0]; } - (void)dealloc { @@ -10814,7 +10816,7 @@ void GPBDictionaryReadEntry(id mapDictionary, return _dictionary.count; } -- (void)enumerateKeysAndValuesUsingBlock: +- (void)enumerateKeysAndDoublesUsingBlock: (void (^)(NSString *key, double value, BOOL *stop))block { [_dictionary enumerateKeysAndObjectsUsingBlock:^(NSString *aKey, NSNumber *aValue, @@ -10872,13 +10874,13 @@ void GPBDictionaryReadEntry(id mapDictionary, } - (void)enumerateForTextFormat:(void (^)(id keyObj, id valueObj))block { - [self enumerateKeysAndValuesUsingBlock:^(NSString *key, double value, BOOL *stop) { + [self enumerateKeysAndDoublesUsingBlock:^(NSString *key, double value, BOOL *stop) { #pragma unused(stop) block(key, [NSString stringWithFormat:@"%.*lg", DBL_DIG, value]); }]; } -- (BOOL)valueForKey:(NSString *)key value:(double *)value { +- (BOOL)getDouble:(nullable double *)value forKey:(NSString *)key { NSNumber *wrapped = [_dictionary objectForKey:key]; if (wrapped && value) { *value = [wrapped doubleValue]; @@ -10895,7 +10897,7 @@ void GPBDictionaryReadEntry(id mapDictionary, } } -- (void)setValue:(double)value forKey:(NSString *)key { +- (void)setDouble:(double)value forKey:(NSString *)key { if (!key) { [NSException raise:NSInvalidArgumentException format:@"Attempting to add nil key to a Dictionary"]; @@ -10906,7 +10908,7 @@ void GPBDictionaryReadEntry(id mapDictionary, } } -- (void)removeValueForKey:(NSString *)aKey { +- (void)removeDoubleForKey:(NSString *)aKey { [_dictionary removeObjectForKey:aKey]; } @@ -11133,7 +11135,7 @@ void GPBDictionaryReadEntry(id mapDictionary, }]; } -- (BOOL)valueForKey:(NSString *)key value:(int32_t *)value { +- (BOOL)getEnum:(int32_t *)value forKey:(NSString *)key { NSNumber *wrapped = [_dictionary objectForKey:key]; if (wrapped && value) { int32_t result = [wrapped intValue]; @@ -11145,7 +11147,7 @@ void GPBDictionaryReadEntry(id mapDictionary, return (wrapped != NULL); } -- (BOOL)valueForKey:(NSString *)key rawValue:(int32_t *)rawValue { +- (BOOL)getRawValue:(int32_t *)rawValue forKey:(NSString *)key { NSNumber *wrapped = [_dictionary objectForKey:key]; if (wrapped && rawValue) { *rawValue = [wrapped intValue]; @@ -11153,7 +11155,7 @@ void GPBDictionaryReadEntry(id mapDictionary, return (wrapped != NULL); } -- (void)enumerateKeysAndValuesUsingBlock: +- (void)enumerateKeysAndEnumsUsingBlock: (void (^)(NSString *key, int32_t value, BOOL *stop))block { GPBEnumValidationFunc func = _validationFunc; [_dictionary enumerateKeysAndObjectsUsingBlock:^(NSString *aKey, @@ -11187,7 +11189,7 @@ void GPBDictionaryReadEntry(id mapDictionary, } } -- (void)removeValueForKey:(NSString *)aKey { +- (void)removeEnumForKey:(NSString *)aKey { [_dictionary removeObjectForKey:aKey]; } @@ -11195,7 +11197,7 @@ void GPBDictionaryReadEntry(id mapDictionary, [_dictionary removeAllObjects]; } -- (void)setValue:(int32_t)value forKey:(NSString *)key { +- (void)setEnum:(int32_t)value forKey:(NSString *)key { if (!key) { [NSException raise:NSInvalidArgumentException format:@"Attempting to add nil key to a Dictionary"]; @@ -11229,26 +11231,26 @@ void GPBDictionaryReadEntry(id mapDictionary, } + (instancetype)dictionary { - return [[[self alloc] initWithValues:NULL forKeys:NULL count:0] autorelease]; + return [[[self alloc] initWithUInt32s:NULL forKeys:NULL count:0] autorelease]; } -+ (instancetype)dictionaryWithValue:(uint32_t)value - forKey:(BOOL)key { - // Cast is needed so the compiler knows what class we are invoking initWithValues:forKeys:count: ++ (instancetype)dictionaryWithUInt32:(uint32_t)value + forKey:(BOOL)key { + // Cast is needed so the compiler knows what class we are invoking initWithUInt32s:forKeys:count: // on to get the type correct. - return [[(GPBBoolUInt32Dictionary*)[self alloc] initWithValues:&value - forKeys:&key - count:1] autorelease]; + return [[(GPBBoolUInt32Dictionary*)[self alloc] initWithUInt32s:&value + forKeys:&key + count:1] autorelease]; } -+ (instancetype)dictionaryWithValues:(const uint32_t [])values - forKeys:(const BOOL [])keys - count:(NSUInteger)count { - // Cast is needed so the compiler knows what class we are invoking initWithValues:forKeys:count: ++ (instancetype)dictionaryWithUInt32s:(const uint32_t [])values + forKeys:(const BOOL [])keys + count:(NSUInteger)count { + // Cast is needed so the compiler knows what class we are invoking initWithUInt32s:forKeys:count: // on to get the type correct. - return [[(GPBBoolUInt32Dictionary*)[self alloc] initWithValues:values - forKeys:keys - count:count] autorelease]; + return [[(GPBBoolUInt32Dictionary*)[self alloc] initWithUInt32s:values + forKeys:keys + count:count] autorelease]; } + (instancetype)dictionaryWithDictionary:(GPBBoolUInt32Dictionary *)dictionary { @@ -11262,12 +11264,12 @@ void GPBDictionaryReadEntry(id mapDictionary, } - (instancetype)init { - return [self initWithValues:NULL forKeys:NULL count:0]; + return [self initWithUInt32s:NULL forKeys:NULL count:0]; } -- (instancetype)initWithValues:(const uint32_t [])values - forKeys:(const BOOL [])keys - count:(NSUInteger)count { +- (instancetype)initWithUInt32s:(const uint32_t [])values + forKeys:(const BOOL [])keys + count:(NSUInteger)count { self = [super init]; if (self) { for (NSUInteger i = 0; i < count; ++i) { @@ -11280,7 +11282,7 @@ void GPBDictionaryReadEntry(id mapDictionary, } - (instancetype)initWithDictionary:(GPBBoolUInt32Dictionary *)dictionary { - self = [self initWithValues:NULL forKeys:NULL count:0]; + self = [self initWithUInt32s:NULL forKeys:NULL count:0]; if (self) { if (dictionary) { for (int i = 0; i < 2; ++i) { @@ -11296,7 +11298,7 @@ void GPBDictionaryReadEntry(id mapDictionary, - (instancetype)initWithCapacity:(NSUInteger)numItems { #pragma unused(numItems) - return [self initWithValues:NULL forKeys:NULL count:0]; + return [self initWithUInt32s:NULL forKeys:NULL count:0]; } #if !defined(NS_BLOCK_ASSERTIONS) @@ -11351,7 +11353,7 @@ void GPBDictionaryReadEntry(id mapDictionary, return (_valueSet[0] ? 1 : 0) + (_valueSet[1] ? 1 : 0); } -- (BOOL)valueForKey:(BOOL)key value:(uint32_t *)value { +- (BOOL)getUInt32:(uint32_t *)value forKey:(BOOL)key { int idx = (key ? 1 : 0); if (_valueSet[idx]) { if (value) { @@ -11378,7 +11380,7 @@ void GPBDictionaryReadEntry(id mapDictionary, } } -- (void)enumerateKeysAndValuesUsingBlock: +- (void)enumerateKeysAndUInt32sUsingBlock: (void (^)(BOOL key, uint32_t value, BOOL *stop))block { BOOL stop = NO; if (_valueSet[0]) { @@ -11439,7 +11441,7 @@ void GPBDictionaryReadEntry(id mapDictionary, } } -- (void)setValue:(uint32_t)value forKey:(BOOL)key { +- (void)setUInt32:(uint32_t)value forKey:(BOOL)key { int idx = (key ? 1 : 0); _values[idx] = value; _valueSet[idx] = YES; @@ -11448,7 +11450,7 @@ void GPBDictionaryReadEntry(id mapDictionary, } } -- (void)removeValueForKey:(BOOL)aKey { +- (void)removeUInt32ForKey:(BOOL)aKey { _valueSet[aKey ? 1 : 0] = NO; } @@ -11471,24 +11473,24 @@ void GPBDictionaryReadEntry(id mapDictionary, } + (instancetype)dictionary { - return [[[self alloc] initWithValues:NULL forKeys:NULL count:0] autorelease]; + return [[[self alloc] initWithInt32s:NULL forKeys:NULL count:0] autorelease]; } -+ (instancetype)dictionaryWithValue:(int32_t)value ++ (instancetype)dictionaryWithInt32:(int32_t)value forKey:(BOOL)key { - // Cast is needed so the compiler knows what class we are invoking initWithValues:forKeys:count: + // Cast is needed so the compiler knows what class we are invoking initWithInt32s:forKeys:count: // on to get the type correct. - return [[(GPBBoolInt32Dictionary*)[self alloc] initWithValues:&value + return [[(GPBBoolInt32Dictionary*)[self alloc] initWithInt32s:&value forKeys:&key count:1] autorelease]; } -+ (instancetype)dictionaryWithValues:(const int32_t [])values ++ (instancetype)dictionaryWithInt32s:(const int32_t [])values forKeys:(const BOOL [])keys count:(NSUInteger)count { - // Cast is needed so the compiler knows what class we are invoking initWithValues:forKeys:count: + // Cast is needed so the compiler knows what class we are invoking initWithInt32s:forKeys:count: // on to get the type correct. - return [[(GPBBoolInt32Dictionary*)[self alloc] initWithValues:values + return [[(GPBBoolInt32Dictionary*)[self alloc] initWithInt32s:values forKeys:keys count:count] autorelease]; } @@ -11504,10 +11506,10 @@ void GPBDictionaryReadEntry(id mapDictionary, } - (instancetype)init { - return [self initWithValues:NULL forKeys:NULL count:0]; + return [self initWithInt32s:NULL forKeys:NULL count:0]; } -- (instancetype)initWithValues:(const int32_t [])values +- (instancetype)initWithInt32s:(const int32_t [])values forKeys:(const BOOL [])keys count:(NSUInteger)count { self = [super init]; @@ -11522,7 +11524,7 @@ void GPBDictionaryReadEntry(id mapDictionary, } - (instancetype)initWithDictionary:(GPBBoolInt32Dictionary *)dictionary { - self = [self initWithValues:NULL forKeys:NULL count:0]; + self = [self initWithInt32s:NULL forKeys:NULL count:0]; if (self) { if (dictionary) { for (int i = 0; i < 2; ++i) { @@ -11538,7 +11540,7 @@ void GPBDictionaryReadEntry(id mapDictionary, - (instancetype)initWithCapacity:(NSUInteger)numItems { #pragma unused(numItems) - return [self initWithValues:NULL forKeys:NULL count:0]; + return [self initWithInt32s:NULL forKeys:NULL count:0]; } #if !defined(NS_BLOCK_ASSERTIONS) @@ -11593,7 +11595,7 @@ void GPBDictionaryReadEntry(id mapDictionary, return (_valueSet[0] ? 1 : 0) + (_valueSet[1] ? 1 : 0); } -- (BOOL)valueForKey:(BOOL)key value:(int32_t *)value { +- (BOOL)getInt32:(int32_t *)value forKey:(BOOL)key { int idx = (key ? 1 : 0); if (_valueSet[idx]) { if (value) { @@ -11620,7 +11622,7 @@ void GPBDictionaryReadEntry(id mapDictionary, } } -- (void)enumerateKeysAndValuesUsingBlock: +- (void)enumerateKeysAndInt32sUsingBlock: (void (^)(BOOL key, int32_t value, BOOL *stop))block { BOOL stop = NO; if (_valueSet[0]) { @@ -11681,7 +11683,7 @@ void GPBDictionaryReadEntry(id mapDictionary, } } -- (void)setValue:(int32_t)value forKey:(BOOL)key { +- (void)setInt32:(int32_t)value forKey:(BOOL)key { int idx = (key ? 1 : 0); _values[idx] = value; _valueSet[idx] = YES; @@ -11690,7 +11692,7 @@ void GPBDictionaryReadEntry(id mapDictionary, } } -- (void)removeValueForKey:(BOOL)aKey { +- (void)removeInt32ForKey:(BOOL)aKey { _valueSet[aKey ? 1 : 0] = NO; } @@ -11713,26 +11715,26 @@ void GPBDictionaryReadEntry(id mapDictionary, } + (instancetype)dictionary { - return [[[self alloc] initWithValues:NULL forKeys:NULL count:0] autorelease]; + return [[[self alloc] initWithUInt64s:NULL forKeys:NULL count:0] autorelease]; } -+ (instancetype)dictionaryWithValue:(uint64_t)value - forKey:(BOOL)key { - // Cast is needed so the compiler knows what class we are invoking initWithValues:forKeys:count: ++ (instancetype)dictionaryWithUInt64:(uint64_t)value + forKey:(BOOL)key { + // Cast is needed so the compiler knows what class we are invoking initWithUInt64s:forKeys:count: // on to get the type correct. - return [[(GPBBoolUInt64Dictionary*)[self alloc] initWithValues:&value - forKeys:&key - count:1] autorelease]; + return [[(GPBBoolUInt64Dictionary*)[self alloc] initWithUInt64s:&value + forKeys:&key + count:1] autorelease]; } -+ (instancetype)dictionaryWithValues:(const uint64_t [])values - forKeys:(const BOOL [])keys - count:(NSUInteger)count { - // Cast is needed so the compiler knows what class we are invoking initWithValues:forKeys:count: ++ (instancetype)dictionaryWithUInt64s:(const uint64_t [])values + forKeys:(const BOOL [])keys + count:(NSUInteger)count { + // Cast is needed so the compiler knows what class we are invoking initWithUInt64s:forKeys:count: // on to get the type correct. - return [[(GPBBoolUInt64Dictionary*)[self alloc] initWithValues:values - forKeys:keys - count:count] autorelease]; + return [[(GPBBoolUInt64Dictionary*)[self alloc] initWithUInt64s:values + forKeys:keys + count:count] autorelease]; } + (instancetype)dictionaryWithDictionary:(GPBBoolUInt64Dictionary *)dictionary { @@ -11746,12 +11748,12 @@ void GPBDictionaryReadEntry(id mapDictionary, } - (instancetype)init { - return [self initWithValues:NULL forKeys:NULL count:0]; + return [self initWithUInt64s:NULL forKeys:NULL count:0]; } -- (instancetype)initWithValues:(const uint64_t [])values - forKeys:(const BOOL [])keys - count:(NSUInteger)count { +- (instancetype)initWithUInt64s:(const uint64_t [])values + forKeys:(const BOOL [])keys + count:(NSUInteger)count { self = [super init]; if (self) { for (NSUInteger i = 0; i < count; ++i) { @@ -11764,7 +11766,7 @@ void GPBDictionaryReadEntry(id mapDictionary, } - (instancetype)initWithDictionary:(GPBBoolUInt64Dictionary *)dictionary { - self = [self initWithValues:NULL forKeys:NULL count:0]; + self = [self initWithUInt64s:NULL forKeys:NULL count:0]; if (self) { if (dictionary) { for (int i = 0; i < 2; ++i) { @@ -11780,7 +11782,7 @@ void GPBDictionaryReadEntry(id mapDictionary, - (instancetype)initWithCapacity:(NSUInteger)numItems { #pragma unused(numItems) - return [self initWithValues:NULL forKeys:NULL count:0]; + return [self initWithUInt64s:NULL forKeys:NULL count:0]; } #if !defined(NS_BLOCK_ASSERTIONS) @@ -11835,7 +11837,7 @@ void GPBDictionaryReadEntry(id mapDictionary, return (_valueSet[0] ? 1 : 0) + (_valueSet[1] ? 1 : 0); } -- (BOOL)valueForKey:(BOOL)key value:(uint64_t *)value { +- (BOOL)getUInt64:(uint64_t *)value forKey:(BOOL)key { int idx = (key ? 1 : 0); if (_valueSet[idx]) { if (value) { @@ -11862,7 +11864,7 @@ void GPBDictionaryReadEntry(id mapDictionary, } } -- (void)enumerateKeysAndValuesUsingBlock: +- (void)enumerateKeysAndUInt64sUsingBlock: (void (^)(BOOL key, uint64_t value, BOOL *stop))block { BOOL stop = NO; if (_valueSet[0]) { @@ -11923,7 +11925,7 @@ void GPBDictionaryReadEntry(id mapDictionary, } } -- (void)setValue:(uint64_t)value forKey:(BOOL)key { +- (void)setUInt64:(uint64_t)value forKey:(BOOL)key { int idx = (key ? 1 : 0); _values[idx] = value; _valueSet[idx] = YES; @@ -11932,7 +11934,7 @@ void GPBDictionaryReadEntry(id mapDictionary, } } -- (void)removeValueForKey:(BOOL)aKey { +- (void)removeUInt64ForKey:(BOOL)aKey { _valueSet[aKey ? 1 : 0] = NO; } @@ -11955,24 +11957,24 @@ void GPBDictionaryReadEntry(id mapDictionary, } + (instancetype)dictionary { - return [[[self alloc] initWithValues:NULL forKeys:NULL count:0] autorelease]; + return [[[self alloc] initWithInt64s:NULL forKeys:NULL count:0] autorelease]; } -+ (instancetype)dictionaryWithValue:(int64_t)value ++ (instancetype)dictionaryWithInt64:(int64_t)value forKey:(BOOL)key { - // Cast is needed so the compiler knows what class we are invoking initWithValues:forKeys:count: + // Cast is needed so the compiler knows what class we are invoking initWithInt64s:forKeys:count: // on to get the type correct. - return [[(GPBBoolInt64Dictionary*)[self alloc] initWithValues:&value + return [[(GPBBoolInt64Dictionary*)[self alloc] initWithInt64s:&value forKeys:&key count:1] autorelease]; } -+ (instancetype)dictionaryWithValues:(const int64_t [])values ++ (instancetype)dictionaryWithInt64s:(const int64_t [])values forKeys:(const BOOL [])keys count:(NSUInteger)count { - // Cast is needed so the compiler knows what class we are invoking initWithValues:forKeys:count: + // Cast is needed so the compiler knows what class we are invoking initWithInt64s:forKeys:count: // on to get the type correct. - return [[(GPBBoolInt64Dictionary*)[self alloc] initWithValues:values + return [[(GPBBoolInt64Dictionary*)[self alloc] initWithInt64s:values forKeys:keys count:count] autorelease]; } @@ -11988,10 +11990,10 @@ void GPBDictionaryReadEntry(id mapDictionary, } - (instancetype)init { - return [self initWithValues:NULL forKeys:NULL count:0]; + return [self initWithInt64s:NULL forKeys:NULL count:0]; } -- (instancetype)initWithValues:(const int64_t [])values +- (instancetype)initWithInt64s:(const int64_t [])values forKeys:(const BOOL [])keys count:(NSUInteger)count { self = [super init]; @@ -12006,7 +12008,7 @@ void GPBDictionaryReadEntry(id mapDictionary, } - (instancetype)initWithDictionary:(GPBBoolInt64Dictionary *)dictionary { - self = [self initWithValues:NULL forKeys:NULL count:0]; + self = [self initWithInt64s:NULL forKeys:NULL count:0]; if (self) { if (dictionary) { for (int i = 0; i < 2; ++i) { @@ -12022,7 +12024,7 @@ void GPBDictionaryReadEntry(id mapDictionary, - (instancetype)initWithCapacity:(NSUInteger)numItems { #pragma unused(numItems) - return [self initWithValues:NULL forKeys:NULL count:0]; + return [self initWithInt64s:NULL forKeys:NULL count:0]; } #if !defined(NS_BLOCK_ASSERTIONS) @@ -12077,7 +12079,7 @@ void GPBDictionaryReadEntry(id mapDictionary, return (_valueSet[0] ? 1 : 0) + (_valueSet[1] ? 1 : 0); } -- (BOOL)valueForKey:(BOOL)key value:(int64_t *)value { +- (BOOL)getInt64:(int64_t *)value forKey:(BOOL)key { int idx = (key ? 1 : 0); if (_valueSet[idx]) { if (value) { @@ -12104,7 +12106,7 @@ void GPBDictionaryReadEntry(id mapDictionary, } } -- (void)enumerateKeysAndValuesUsingBlock: +- (void)enumerateKeysAndInt64sUsingBlock: (void (^)(BOOL key, int64_t value, BOOL *stop))block { BOOL stop = NO; if (_valueSet[0]) { @@ -12165,7 +12167,7 @@ void GPBDictionaryReadEntry(id mapDictionary, } } -- (void)setValue:(int64_t)value forKey:(BOOL)key { +- (void)setInt64:(int64_t)value forKey:(BOOL)key { int idx = (key ? 1 : 0); _values[idx] = value; _valueSet[idx] = YES; @@ -12174,7 +12176,7 @@ void GPBDictionaryReadEntry(id mapDictionary, } } -- (void)removeValueForKey:(BOOL)aKey { +- (void)removeInt64ForKey:(BOOL)aKey { _valueSet[aKey ? 1 : 0] = NO; } @@ -12197,26 +12199,26 @@ void GPBDictionaryReadEntry(id mapDictionary, } + (instancetype)dictionary { - return [[[self alloc] initWithValues:NULL forKeys:NULL count:0] autorelease]; + return [[[self alloc] initWithBools:NULL forKeys:NULL count:0] autorelease]; } -+ (instancetype)dictionaryWithValue:(BOOL)value - forKey:(BOOL)key { - // Cast is needed so the compiler knows what class we are invoking initWithValues:forKeys:count: ++ (instancetype)dictionaryWithBool:(BOOL)value + forKey:(BOOL)key { + // Cast is needed so the compiler knows what class we are invoking initWithBools:forKeys:count: // on to get the type correct. - return [[(GPBBoolBoolDictionary*)[self alloc] initWithValues:&value - forKeys:&key - count:1] autorelease]; + return [[(GPBBoolBoolDictionary*)[self alloc] initWithBools:&value + forKeys:&key + count:1] autorelease]; } -+ (instancetype)dictionaryWithValues:(const BOOL [])values - forKeys:(const BOOL [])keys - count:(NSUInteger)count { - // Cast is needed so the compiler knows what class we are invoking initWithValues:forKeys:count: ++ (instancetype)dictionaryWithBools:(const BOOL [])values + forKeys:(const BOOL [])keys + count:(NSUInteger)count { + // Cast is needed so the compiler knows what class we are invoking initWithBools:forKeys:count: // on to get the type correct. - return [[(GPBBoolBoolDictionary*)[self alloc] initWithValues:values - forKeys:keys - count:count] autorelease]; + return [[(GPBBoolBoolDictionary*)[self alloc] initWithBools:values + forKeys:keys + count:count] autorelease]; } + (instancetype)dictionaryWithDictionary:(GPBBoolBoolDictionary *)dictionary { @@ -12230,12 +12232,12 @@ void GPBDictionaryReadEntry(id mapDictionary, } - (instancetype)init { - return [self initWithValues:NULL forKeys:NULL count:0]; + return [self initWithBools:NULL forKeys:NULL count:0]; } -- (instancetype)initWithValues:(const BOOL [])values - forKeys:(const BOOL [])keys - count:(NSUInteger)count { +- (instancetype)initWithBools:(const BOOL [])values + forKeys:(const BOOL [])keys + count:(NSUInteger)count { self = [super init]; if (self) { for (NSUInteger i = 0; i < count; ++i) { @@ -12248,7 +12250,7 @@ void GPBDictionaryReadEntry(id mapDictionary, } - (instancetype)initWithDictionary:(GPBBoolBoolDictionary *)dictionary { - self = [self initWithValues:NULL forKeys:NULL count:0]; + self = [self initWithBools:NULL forKeys:NULL count:0]; if (self) { if (dictionary) { for (int i = 0; i < 2; ++i) { @@ -12264,7 +12266,7 @@ void GPBDictionaryReadEntry(id mapDictionary, - (instancetype)initWithCapacity:(NSUInteger)numItems { #pragma unused(numItems) - return [self initWithValues:NULL forKeys:NULL count:0]; + return [self initWithBools:NULL forKeys:NULL count:0]; } #if !defined(NS_BLOCK_ASSERTIONS) @@ -12319,7 +12321,7 @@ void GPBDictionaryReadEntry(id mapDictionary, return (_valueSet[0] ? 1 : 0) + (_valueSet[1] ? 1 : 0); } -- (BOOL)valueForKey:(BOOL)key value:(BOOL *)value { +- (BOOL)getBool:(BOOL *)value forKey:(BOOL)key { int idx = (key ? 1 : 0); if (_valueSet[idx]) { if (value) { @@ -12346,7 +12348,7 @@ void GPBDictionaryReadEntry(id mapDictionary, } } -- (void)enumerateKeysAndValuesUsingBlock: +- (void)enumerateKeysAndBoolsUsingBlock: (void (^)(BOOL key, BOOL value, BOOL *stop))block { BOOL stop = NO; if (_valueSet[0]) { @@ -12407,7 +12409,7 @@ void GPBDictionaryReadEntry(id mapDictionary, } } -- (void)setValue:(BOOL)value forKey:(BOOL)key { +- (void)setBool:(BOOL)value forKey:(BOOL)key { int idx = (key ? 1 : 0); _values[idx] = value; _valueSet[idx] = YES; @@ -12416,7 +12418,7 @@ void GPBDictionaryReadEntry(id mapDictionary, } } -- (void)removeValueForKey:(BOOL)aKey { +- (void)removeBoolForKey:(BOOL)aKey { _valueSet[aKey ? 1 : 0] = NO; } @@ -12439,24 +12441,24 @@ void GPBDictionaryReadEntry(id mapDictionary, } + (instancetype)dictionary { - return [[[self alloc] initWithValues:NULL forKeys:NULL count:0] autorelease]; + return [[[self alloc] initWithFloats:NULL forKeys:NULL count:0] autorelease]; } -+ (instancetype)dictionaryWithValue:(float)value ++ (instancetype)dictionaryWithFloat:(float)value forKey:(BOOL)key { - // Cast is needed so the compiler knows what class we are invoking initWithValues:forKeys:count: + // Cast is needed so the compiler knows what class we are invoking initWithFloats:forKeys:count: // on to get the type correct. - return [[(GPBBoolFloatDictionary*)[self alloc] initWithValues:&value + return [[(GPBBoolFloatDictionary*)[self alloc] initWithFloats:&value forKeys:&key count:1] autorelease]; } -+ (instancetype)dictionaryWithValues:(const float [])values ++ (instancetype)dictionaryWithFloats:(const float [])values forKeys:(const BOOL [])keys count:(NSUInteger)count { - // Cast is needed so the compiler knows what class we are invoking initWithValues:forKeys:count: + // Cast is needed so the compiler knows what class we are invoking initWithFloats:forKeys:count: // on to get the type correct. - return [[(GPBBoolFloatDictionary*)[self alloc] initWithValues:values + return [[(GPBBoolFloatDictionary*)[self alloc] initWithFloats:values forKeys:keys count:count] autorelease]; } @@ -12472,10 +12474,10 @@ void GPBDictionaryReadEntry(id mapDictionary, } - (instancetype)init { - return [self initWithValues:NULL forKeys:NULL count:0]; + return [self initWithFloats:NULL forKeys:NULL count:0]; } -- (instancetype)initWithValues:(const float [])values +- (instancetype)initWithFloats:(const float [])values forKeys:(const BOOL [])keys count:(NSUInteger)count { self = [super init]; @@ -12490,7 +12492,7 @@ void GPBDictionaryReadEntry(id mapDictionary, } - (instancetype)initWithDictionary:(GPBBoolFloatDictionary *)dictionary { - self = [self initWithValues:NULL forKeys:NULL count:0]; + self = [self initWithFloats:NULL forKeys:NULL count:0]; if (self) { if (dictionary) { for (int i = 0; i < 2; ++i) { @@ -12506,7 +12508,7 @@ void GPBDictionaryReadEntry(id mapDictionary, - (instancetype)initWithCapacity:(NSUInteger)numItems { #pragma unused(numItems) - return [self initWithValues:NULL forKeys:NULL count:0]; + return [self initWithFloats:NULL forKeys:NULL count:0]; } #if !defined(NS_BLOCK_ASSERTIONS) @@ -12561,7 +12563,7 @@ void GPBDictionaryReadEntry(id mapDictionary, return (_valueSet[0] ? 1 : 0) + (_valueSet[1] ? 1 : 0); } -- (BOOL)valueForKey:(BOOL)key value:(float *)value { +- (BOOL)getFloat:(float *)value forKey:(BOOL)key { int idx = (key ? 1 : 0); if (_valueSet[idx]) { if (value) { @@ -12588,7 +12590,7 @@ void GPBDictionaryReadEntry(id mapDictionary, } } -- (void)enumerateKeysAndValuesUsingBlock: +- (void)enumerateKeysAndFloatsUsingBlock: (void (^)(BOOL key, float value, BOOL *stop))block { BOOL stop = NO; if (_valueSet[0]) { @@ -12649,7 +12651,7 @@ void GPBDictionaryReadEntry(id mapDictionary, } } -- (void)setValue:(float)value forKey:(BOOL)key { +- (void)setFloat:(float)value forKey:(BOOL)key { int idx = (key ? 1 : 0); _values[idx] = value; _valueSet[idx] = YES; @@ -12658,7 +12660,7 @@ void GPBDictionaryReadEntry(id mapDictionary, } } -- (void)removeValueForKey:(BOOL)aKey { +- (void)removeFloatForKey:(BOOL)aKey { _valueSet[aKey ? 1 : 0] = NO; } @@ -12681,26 +12683,26 @@ void GPBDictionaryReadEntry(id mapDictionary, } + (instancetype)dictionary { - return [[[self alloc] initWithValues:NULL forKeys:NULL count:0] autorelease]; + return [[[self alloc] initWithDoubles:NULL forKeys:NULL count:0] autorelease]; } -+ (instancetype)dictionaryWithValue:(double)value - forKey:(BOOL)key { - // Cast is needed so the compiler knows what class we are invoking initWithValues:forKeys:count: ++ (instancetype)dictionaryWithDouble:(double)value + forKey:(BOOL)key { + // Cast is needed so the compiler knows what class we are invoking initWithDoubles:forKeys:count: // on to get the type correct. - return [[(GPBBoolDoubleDictionary*)[self alloc] initWithValues:&value - forKeys:&key - count:1] autorelease]; + return [[(GPBBoolDoubleDictionary*)[self alloc] initWithDoubles:&value + forKeys:&key + count:1] autorelease]; } -+ (instancetype)dictionaryWithValues:(const double [])values - forKeys:(const BOOL [])keys - count:(NSUInteger)count { - // Cast is needed so the compiler knows what class we are invoking initWithValues:forKeys:count: ++ (instancetype)dictionaryWithDoubles:(const double [])values + forKeys:(const BOOL [])keys + count:(NSUInteger)count { + // Cast is needed so the compiler knows what class we are invoking initWithDoubles:forKeys:count: // on to get the type correct. - return [[(GPBBoolDoubleDictionary*)[self alloc] initWithValues:values - forKeys:keys - count:count] autorelease]; + return [[(GPBBoolDoubleDictionary*)[self alloc] initWithDoubles:values + forKeys:keys + count:count] autorelease]; } + (instancetype)dictionaryWithDictionary:(GPBBoolDoubleDictionary *)dictionary { @@ -12714,12 +12716,12 @@ void GPBDictionaryReadEntry(id mapDictionary, } - (instancetype)init { - return [self initWithValues:NULL forKeys:NULL count:0]; + return [self initWithDoubles:NULL forKeys:NULL count:0]; } -- (instancetype)initWithValues:(const double [])values - forKeys:(const BOOL [])keys - count:(NSUInteger)count { +- (instancetype)initWithDoubles:(const double [])values + forKeys:(const BOOL [])keys + count:(NSUInteger)count { self = [super init]; if (self) { for (NSUInteger i = 0; i < count; ++i) { @@ -12732,7 +12734,7 @@ void GPBDictionaryReadEntry(id mapDictionary, } - (instancetype)initWithDictionary:(GPBBoolDoubleDictionary *)dictionary { - self = [self initWithValues:NULL forKeys:NULL count:0]; + self = [self initWithDoubles:NULL forKeys:NULL count:0]; if (self) { if (dictionary) { for (int i = 0; i < 2; ++i) { @@ -12748,7 +12750,7 @@ void GPBDictionaryReadEntry(id mapDictionary, - (instancetype)initWithCapacity:(NSUInteger)numItems { #pragma unused(numItems) - return [self initWithValues:NULL forKeys:NULL count:0]; + return [self initWithDoubles:NULL forKeys:NULL count:0]; } #if !defined(NS_BLOCK_ASSERTIONS) @@ -12803,7 +12805,7 @@ void GPBDictionaryReadEntry(id mapDictionary, return (_valueSet[0] ? 1 : 0) + (_valueSet[1] ? 1 : 0); } -- (BOOL)valueForKey:(BOOL)key value:(double *)value { +- (BOOL)getDouble:(double *)value forKey:(BOOL)key { int idx = (key ? 1 : 0); if (_valueSet[idx]) { if (value) { @@ -12830,7 +12832,7 @@ void GPBDictionaryReadEntry(id mapDictionary, } } -- (void)enumerateKeysAndValuesUsingBlock: +- (void)enumerateKeysAndDoublesUsingBlock: (void (^)(BOOL key, double value, BOOL *stop))block { BOOL stop = NO; if (_valueSet[0]) { @@ -12891,7 +12893,7 @@ void GPBDictionaryReadEntry(id mapDictionary, } } -- (void)setValue:(double)value forKey:(BOOL)key { +- (void)setDouble:(double)value forKey:(BOOL)key { int idx = (key ? 1 : 0); _values[idx] = value; _valueSet[idx] = YES; @@ -12900,7 +12902,7 @@ void GPBDictionaryReadEntry(id mapDictionary, } } -- (void)removeValueForKey:(BOOL)aKey { +- (void)removeDoubleForKey:(BOOL)aKey { _valueSet[aKey ? 1 : 0] = NO; } @@ -13335,7 +13337,7 @@ void GPBDictionaryReadEntry(id mapDictionary, return (_valueSet[0] ? 1 : 0) + (_valueSet[1] ? 1 : 0); } -- (BOOL)valueForKey:(BOOL)key value:(int32_t*)value { +- (BOOL)getEnum:(int32_t*)value forKey:(BOOL)key { int idx = (key ? 1 : 0); if (_valueSet[idx]) { if (value) { @@ -13350,7 +13352,7 @@ void GPBDictionaryReadEntry(id mapDictionary, return NO; } -- (BOOL)valueForKey:(BOOL)key rawValue:(int32_t*)rawValue { +- (BOOL)getRawValue:(int32_t*)rawValue forKey:(BOOL)key { int idx = (key ? 1 : 0); if (_valueSet[idx]) { if (rawValue) { @@ -13361,7 +13363,7 @@ void GPBDictionaryReadEntry(id mapDictionary, return NO; } -- (void)enumerateKeysAndValuesUsingBlock: +- (void)enumerateKeysAndRawValuesUsingBlock: (void (^)(BOOL key, int32_t value, BOOL *stop))block { BOOL stop = NO; if (_valueSet[0]) { @@ -13372,7 +13374,7 @@ void GPBDictionaryReadEntry(id mapDictionary, } } -- (void)enumerateKeysAndRawValuesUsingBlock: +- (void)enumerateKeysAndEnumsUsingBlock: (void (^)(BOOL key, int32_t rawValue, BOOL *stop))block { BOOL stop = NO; GPBEnumValidationFunc func = _validationFunc; @@ -13477,7 +13479,7 @@ void GPBDictionaryReadEntry(id mapDictionary, } } -- (void)setValue:(int32_t)value forKey:(BOOL)key { +- (void)setEnum:(int32_t)value forKey:(BOOL)key { if (!_validationFunc(value)) { [NSException raise:NSInvalidArgumentException format:@"GPBBoolEnumDictionary: Attempt to set an unknown enum value (%d)", @@ -13500,7 +13502,7 @@ void GPBDictionaryReadEntry(id mapDictionary, } } -- (void)removeValueForKey:(BOOL)aKey { +- (void)removeEnumForKey:(BOOL)aKey { _valueSet[aKey ? 1 : 0] = NO; } diff --git a/objectivec/GPBProtocolBuffers.m b/objectivec/GPBProtocolBuffers.m index 8512af7e..73939391 100644 --- a/objectivec/GPBProtocolBuffers.m +++ b/objectivec/GPBProtocolBuffers.m @@ -31,6 +31,14 @@ // If you want to build protocol buffers in your own project without adding the // project dependency, you can just add this file. + +// This warning seems to treat code differently when it is #imported than when +// it is inline in the file. GPBDictionary.m compiles cleanly in other targets, +// but when #imported here it triggers a bunch of warnings that don't make +// much sense, and don't trigger when compiled directly. So we shut off the +// warnings here. +#pragma clang diagnostic ignored "-Wnullability-completeness" + #import "GPBArray.m" #import "GPBCodedInputStream.m" #import "GPBCodedOutputStream.m" diff --git a/objectivec/Tests/GPBDictionaryTests+Bool.m b/objectivec/Tests/GPBDictionaryTests+Bool.m index afa3d11c..0dbe07b6 100644 --- a/objectivec/Tests/GPBDictionaryTests+Bool.m +++ b/objectivec/Tests/GPBDictionaryTests+Bool.m @@ -54,8 +54,8 @@ GPBBoolUInt32Dictionary *dict = [[GPBBoolUInt32Dictionary alloc] init]; XCTAssertNotNil(dict); XCTAssertEqual(dict.count, 0U); - XCTAssertFalse([dict valueForKey:YES value:NULL]); - [dict enumerateKeysAndValuesUsingBlock:^(BOOL aKey, uint32_t aValue, BOOL *stop) { + XCTAssertFalse([dict getUInt32:NULL forKey:YES]); + [dict enumerateKeysAndUInt32sUsingBlock:^(BOOL aKey, uint32_t aValue, BOOL *stop) { #pragma unused(aKey, aValue, stop) XCTFail(@"Shouldn't get here!"); }]; @@ -63,15 +63,15 @@ } - (void)testOne { - GPBBoolUInt32Dictionary *dict = [GPBBoolUInt32Dictionary dictionaryWithValue:100U forKey:YES]; + GPBBoolUInt32Dictionary *dict = [GPBBoolUInt32Dictionary dictionaryWithUInt32:100U forKey:YES]; XCTAssertNotNil(dict); XCTAssertEqual(dict.count, 1U); uint32_t value; - XCTAssertTrue([dict valueForKey:YES value:NULL]); - XCTAssertTrue([dict valueForKey:YES value:&value]); + XCTAssertTrue([dict getUInt32:NULL forKey:YES]); + XCTAssertTrue([dict getUInt32:&value forKey:YES]); XCTAssertEqual(value, 100U); - XCTAssertFalse([dict valueForKey:NO value:NULL]); - [dict enumerateKeysAndValuesUsingBlock:^(BOOL aKey, uint32_t aValue, BOOL *stop) { + XCTAssertFalse([dict getUInt32:NULL forKey:NO]); + [dict enumerateKeysAndUInt32sUsingBlock:^(BOOL aKey, uint32_t aValue, BOOL *stop) { XCTAssertEqual(aKey, YES); XCTAssertEqual(aValue, 100U); XCTAssertNotEqual(stop, NULL); @@ -82,23 +82,23 @@ const BOOL kKeys[] = { YES, NO }; const uint32_t kValues[] = { 100U, 101U }; GPBBoolUInt32Dictionary *dict = - [[GPBBoolUInt32Dictionary alloc] initWithValues:kValues - forKeys:kKeys - count:GPBARRAYSIZE(kValues)]; + [[GPBBoolUInt32Dictionary alloc] initWithUInt32s:kValues + forKeys:kKeys + count:GPBARRAYSIZE(kValues)]; XCTAssertNotNil(dict); XCTAssertEqual(dict.count, 2U); uint32_t value; - XCTAssertTrue([dict valueForKey:YES value:NULL]); - XCTAssertTrue([dict valueForKey:YES value:&value]); + XCTAssertTrue([dict getUInt32:NULL forKey:YES]); + XCTAssertTrue([dict getUInt32:&value forKey:YES]); XCTAssertEqual(value, 100U); - XCTAssertTrue([dict valueForKey:NO value:NULL]); - XCTAssertTrue([dict valueForKey:NO value:&value]); + XCTAssertTrue([dict getUInt32:NULL forKey:NO]); + XCTAssertTrue([dict getUInt32:&value forKey:NO]); XCTAssertEqual(value, 101U); __block NSUInteger idx = 0; BOOL *seenKeys = malloc(2 * sizeof(BOOL)); uint32_t *seenValues = malloc(2 * sizeof(uint32_t)); - [dict enumerateKeysAndValuesUsingBlock:^(BOOL aKey, uint32_t aValue, BOOL *stop) { + [dict enumerateKeysAndUInt32sUsingBlock:^(BOOL aKey, uint32_t aValue, BOOL *stop) { XCTAssertLessThan(idx, 2U); seenKeys[idx] = aKey; seenValues[idx] = aValue; @@ -120,7 +120,7 @@ // Stopping the enumeration. idx = 0; - [dict enumerateKeysAndValuesUsingBlock:^(BOOL aKey, uint32_t aValue, BOOL *stop) { + [dict enumerateKeysAndUInt32sUsingBlock:^(BOOL aKey, uint32_t aValue, BOOL *stop) { #pragma unused(aKey, aValue) if (idx == 0) *stop = YES; XCTAssertNotEqual(idx, 2U); @@ -136,29 +136,29 @@ const uint32_t kValues2[] = { 101U, 100U }; const uint32_t kValues3[] = { 101U }; GPBBoolUInt32Dictionary *dict1 = - [[GPBBoolUInt32Dictionary alloc] initWithValues:kValues1 - forKeys:kKeys1 - count:GPBARRAYSIZE(kValues1)]; + [[GPBBoolUInt32Dictionary alloc] initWithUInt32s:kValues1 + forKeys:kKeys1 + count:GPBARRAYSIZE(kValues1)]; XCTAssertNotNil(dict1); GPBBoolUInt32Dictionary *dict1prime = - [[GPBBoolUInt32Dictionary alloc] initWithValues:kValues1 - forKeys:kKeys1 - count:GPBARRAYSIZE(kValues1)]; + [[GPBBoolUInt32Dictionary alloc] initWithUInt32s:kValues1 + forKeys:kKeys1 + count:GPBARRAYSIZE(kValues1)]; XCTAssertNotNil(dict1prime); GPBBoolUInt32Dictionary *dict2 = - [[GPBBoolUInt32Dictionary alloc] initWithValues:kValues2 - forKeys:kKeys1 - count:GPBARRAYSIZE(kValues2)]; + [[GPBBoolUInt32Dictionary alloc] initWithUInt32s:kValues2 + forKeys:kKeys1 + count:GPBARRAYSIZE(kValues2)]; XCTAssertNotNil(dict2); GPBBoolUInt32Dictionary *dict3 = - [[GPBBoolUInt32Dictionary alloc] initWithValues:kValues1 - forKeys:kKeys2 - count:GPBARRAYSIZE(kValues1)]; + [[GPBBoolUInt32Dictionary alloc] initWithUInt32s:kValues1 + forKeys:kKeys2 + count:GPBARRAYSIZE(kValues1)]; XCTAssertNotNil(dict3); GPBBoolUInt32Dictionary *dict4 = - [[GPBBoolUInt32Dictionary alloc] initWithValues:kValues3 - forKeys:kKeys1 - count:GPBARRAYSIZE(kValues3)]; + [[GPBBoolUInt32Dictionary alloc] initWithUInt32s:kValues3 + forKeys:kKeys1 + count:GPBARRAYSIZE(kValues3)]; XCTAssertNotNil(dict4); // 1/1Prime should be different objects, but equal. @@ -187,9 +187,9 @@ const BOOL kKeys[] = { YES, NO }; const uint32_t kValues[] = { 100U, 101U }; GPBBoolUInt32Dictionary *dict = - [[GPBBoolUInt32Dictionary alloc] initWithValues:kValues - forKeys:kKeys - count:GPBARRAYSIZE(kValues)]; + [[GPBBoolUInt32Dictionary alloc] initWithUInt32s:kValues + forKeys:kKeys + count:GPBARRAYSIZE(kValues)]; XCTAssertNotNil(dict); GPBBoolUInt32Dictionary *dict2 = [dict copy]; @@ -208,9 +208,9 @@ const BOOL kKeys[] = { YES, NO }; const uint32_t kValues[] = { 100U, 101U }; GPBBoolUInt32Dictionary *dict = - [[GPBBoolUInt32Dictionary alloc] initWithValues:kValues - forKeys:kKeys - count:GPBARRAYSIZE(kValues)]; + [[GPBBoolUInt32Dictionary alloc] initWithUInt32s:kValues + forKeys:kKeys + count:GPBARRAYSIZE(kValues)]; XCTAssertNotNil(dict); GPBBoolUInt32Dictionary *dict2 = @@ -228,25 +228,25 @@ XCTAssertNotNil(dict); XCTAssertEqual(dict.count, 0U); - [dict setValue:100U forKey:YES]; + [dict setUInt32:100U forKey:YES]; XCTAssertEqual(dict.count, 1U); const BOOL kKeys[] = { NO }; const uint32_t kValues[] = { 101U }; GPBBoolUInt32Dictionary *dict2 = - [[GPBBoolUInt32Dictionary alloc] initWithValues:kValues - forKeys:kKeys - count:GPBARRAYSIZE(kValues)]; + [[GPBBoolUInt32Dictionary alloc] initWithUInt32s:kValues + forKeys:kKeys + count:GPBARRAYSIZE(kValues)]; XCTAssertNotNil(dict2); [dict addEntriesFromDictionary:dict2]; XCTAssertEqual(dict.count, 2U); uint32_t value; - XCTAssertTrue([dict valueForKey:YES value:NULL]); - XCTAssertTrue([dict valueForKey:YES value:&value]); + XCTAssertTrue([dict getUInt32:NULL forKey:YES]); + XCTAssertTrue([dict getUInt32:&value forKey:YES]); XCTAssertEqual(value, 100U); - XCTAssertTrue([dict valueForKey:NO value:NULL]); - XCTAssertTrue([dict valueForKey:NO value:&value]); + XCTAssertTrue([dict getUInt32:NULL forKey:NO]); + XCTAssertTrue([dict getUInt32:&value forKey:NO]); XCTAssertEqual(value, 101U); [dict2 release]; } @@ -255,32 +255,32 @@ const BOOL kKeys[] = { YES, NO}; const uint32_t kValues[] = { 100U, 101U }; GPBBoolUInt32Dictionary *dict = - [[GPBBoolUInt32Dictionary alloc] initWithValues:kValues - forKeys:kKeys - count:GPBARRAYSIZE(kValues)]; + [[GPBBoolUInt32Dictionary alloc] initWithUInt32s:kValues + forKeys:kKeys + count:GPBARRAYSIZE(kValues)]; XCTAssertNotNil(dict); XCTAssertEqual(dict.count, 2U); - [dict removeValueForKey:NO]; + [dict removeUInt32ForKey:NO]; XCTAssertEqual(dict.count, 1U); uint32_t value; - XCTAssertTrue([dict valueForKey:YES value:NULL]); - XCTAssertTrue([dict valueForKey:YES value:&value]); + XCTAssertTrue([dict getUInt32:NULL forKey:YES]); + XCTAssertTrue([dict getUInt32:&value forKey:YES]); XCTAssertEqual(value, 100U); - XCTAssertFalse([dict valueForKey:NO value:NULL]); + XCTAssertFalse([dict getUInt32:NULL forKey:NO]); // Remove again does nothing. - [dict removeValueForKey:NO]; + [dict removeUInt32ForKey:NO]; XCTAssertEqual(dict.count, 1U); - XCTAssertTrue([dict valueForKey:YES value:NULL]); - XCTAssertTrue([dict valueForKey:YES value:&value]); + XCTAssertTrue([dict getUInt32:NULL forKey:YES]); + XCTAssertTrue([dict getUInt32:&value forKey:YES]); XCTAssertEqual(value, 100U); - XCTAssertFalse([dict valueForKey:NO value:NULL]); + XCTAssertFalse([dict getUInt32:NULL forKey:NO]); [dict removeAll]; XCTAssertEqual(dict.count, 0U); - XCTAssertFalse([dict valueForKey:YES value:NULL]); - XCTAssertFalse([dict valueForKey:NO value:NULL]); + XCTAssertFalse([dict getUInt32:NULL forKey:YES]); + XCTAssertFalse([dict getUInt32:NULL forKey:NO]); [dict release]; } @@ -288,51 +288,51 @@ const BOOL kKeys[] = { YES, NO }; const uint32_t kValues[] = { 100U, 101U }; GPBBoolUInt32Dictionary *dict = - [[GPBBoolUInt32Dictionary alloc] initWithValues:kValues - forKeys:kKeys - count:GPBARRAYSIZE(kValues)]; + [[GPBBoolUInt32Dictionary alloc] initWithUInt32s:kValues + forKeys:kKeys + count:GPBARRAYSIZE(kValues)]; XCTAssertNotNil(dict); XCTAssertEqual(dict.count, 2U); uint32_t value; - XCTAssertTrue([dict valueForKey:YES value:NULL]); - XCTAssertTrue([dict valueForKey:YES value:&value]); + XCTAssertTrue([dict getUInt32:NULL forKey:YES]); + XCTAssertTrue([dict getUInt32:&value forKey:YES]); XCTAssertEqual(value, 100U); - XCTAssertTrue([dict valueForKey:NO value:NULL]); - XCTAssertTrue([dict valueForKey:NO value:&value]); + XCTAssertTrue([dict getUInt32:NULL forKey:NO]); + XCTAssertTrue([dict getUInt32:&value forKey:NO]); XCTAssertEqual(value, 101U); - [dict setValue:101U forKey:YES]; + [dict setUInt32:101U forKey:YES]; XCTAssertEqual(dict.count, 2U); - XCTAssertTrue([dict valueForKey:YES value:NULL]); - XCTAssertTrue([dict valueForKey:YES value:&value]); + XCTAssertTrue([dict getUInt32:NULL forKey:YES]); + XCTAssertTrue([dict getUInt32:&value forKey:YES]); XCTAssertEqual(value, 101U); - XCTAssertTrue([dict valueForKey:NO value:NULL]); - XCTAssertTrue([dict valueForKey:NO value:&value]); + XCTAssertTrue([dict getUInt32:NULL forKey:NO]); + XCTAssertTrue([dict getUInt32:&value forKey:NO]); XCTAssertEqual(value, 101U); - [dict setValue:100U forKey:NO]; + [dict setUInt32:100U forKey:NO]; XCTAssertEqual(dict.count, 2U); - XCTAssertTrue([dict valueForKey:YES value:NULL]); - XCTAssertTrue([dict valueForKey:YES value:&value]); + XCTAssertTrue([dict getUInt32:NULL forKey:YES]); + XCTAssertTrue([dict getUInt32:&value forKey:YES]); XCTAssertEqual(value, 101U); - XCTAssertTrue([dict valueForKey:NO value:NULL]); - XCTAssertTrue([dict valueForKey:NO value:&value]); + XCTAssertTrue([dict getUInt32:NULL forKey:NO]); + XCTAssertTrue([dict getUInt32:&value forKey:NO]); XCTAssertEqual(value, 100U); const BOOL kKeys2[] = { NO, YES }; const uint32_t kValues2[] = { 101U, 100U }; GPBBoolUInt32Dictionary *dict2 = - [[GPBBoolUInt32Dictionary alloc] initWithValues:kValues2 - forKeys:kKeys2 - count:GPBARRAYSIZE(kValues2)]; + [[GPBBoolUInt32Dictionary alloc] initWithUInt32s:kValues2 + forKeys:kKeys2 + count:GPBARRAYSIZE(kValues2)]; XCTAssertNotNil(dict2); [dict addEntriesFromDictionary:dict2]; XCTAssertEqual(dict.count, 2U); - XCTAssertTrue([dict valueForKey:YES value:NULL]); - XCTAssertTrue([dict valueForKey:YES value:&value]); + XCTAssertTrue([dict getUInt32:NULL forKey:YES]); + XCTAssertTrue([dict getUInt32:&value forKey:YES]); XCTAssertEqual(value, 100U); - XCTAssertTrue([dict valueForKey:NO value:NULL]); - XCTAssertTrue([dict valueForKey:NO value:&value]); + XCTAssertTrue([dict getUInt32:NULL forKey:NO]); + XCTAssertTrue([dict getUInt32:&value forKey:NO]); XCTAssertEqual(value, 101U); [dict2 release]; @@ -355,8 +355,8 @@ GPBBoolInt32Dictionary *dict = [[GPBBoolInt32Dictionary alloc] init]; XCTAssertNotNil(dict); XCTAssertEqual(dict.count, 0U); - XCTAssertFalse([dict valueForKey:YES value:NULL]); - [dict enumerateKeysAndValuesUsingBlock:^(BOOL aKey, int32_t aValue, BOOL *stop) { + XCTAssertFalse([dict getInt32:NULL forKey:YES]); + [dict enumerateKeysAndInt32sUsingBlock:^(BOOL aKey, int32_t aValue, BOOL *stop) { #pragma unused(aKey, aValue, stop) XCTFail(@"Shouldn't get here!"); }]; @@ -364,15 +364,15 @@ } - (void)testOne { - GPBBoolInt32Dictionary *dict = [GPBBoolInt32Dictionary dictionaryWithValue:200 forKey:YES]; + GPBBoolInt32Dictionary *dict = [GPBBoolInt32Dictionary dictionaryWithInt32:200 forKey:YES]; XCTAssertNotNil(dict); XCTAssertEqual(dict.count, 1U); int32_t value; - XCTAssertTrue([dict valueForKey:YES value:NULL]); - XCTAssertTrue([dict valueForKey:YES value:&value]); + XCTAssertTrue([dict getInt32:NULL forKey:YES]); + XCTAssertTrue([dict getInt32:&value forKey:YES]); XCTAssertEqual(value, 200); - XCTAssertFalse([dict valueForKey:NO value:NULL]); - [dict enumerateKeysAndValuesUsingBlock:^(BOOL aKey, int32_t aValue, BOOL *stop) { + XCTAssertFalse([dict getInt32:NULL forKey:NO]); + [dict enumerateKeysAndInt32sUsingBlock:^(BOOL aKey, int32_t aValue, BOOL *stop) { XCTAssertEqual(aKey, YES); XCTAssertEqual(aValue, 200); XCTAssertNotEqual(stop, NULL); @@ -383,23 +383,23 @@ const BOOL kKeys[] = { YES, NO }; const int32_t kValues[] = { 200, 201 }; GPBBoolInt32Dictionary *dict = - [[GPBBoolInt32Dictionary alloc] initWithValues:kValues + [[GPBBoolInt32Dictionary alloc] initWithInt32s:kValues forKeys:kKeys count:GPBARRAYSIZE(kValues)]; XCTAssertNotNil(dict); XCTAssertEqual(dict.count, 2U); int32_t value; - XCTAssertTrue([dict valueForKey:YES value:NULL]); - XCTAssertTrue([dict valueForKey:YES value:&value]); + XCTAssertTrue([dict getInt32:NULL forKey:YES]); + XCTAssertTrue([dict getInt32:&value forKey:YES]); XCTAssertEqual(value, 200); - XCTAssertTrue([dict valueForKey:NO value:NULL]); - XCTAssertTrue([dict valueForKey:NO value:&value]); + XCTAssertTrue([dict getInt32:NULL forKey:NO]); + XCTAssertTrue([dict getInt32:&value forKey:NO]); XCTAssertEqual(value, 201); __block NSUInteger idx = 0; BOOL *seenKeys = malloc(2 * sizeof(BOOL)); int32_t *seenValues = malloc(2 * sizeof(int32_t)); - [dict enumerateKeysAndValuesUsingBlock:^(BOOL aKey, int32_t aValue, BOOL *stop) { + [dict enumerateKeysAndInt32sUsingBlock:^(BOOL aKey, int32_t aValue, BOOL *stop) { XCTAssertLessThan(idx, 2U); seenKeys[idx] = aKey; seenValues[idx] = aValue; @@ -421,7 +421,7 @@ // Stopping the enumeration. idx = 0; - [dict enumerateKeysAndValuesUsingBlock:^(BOOL aKey, int32_t aValue, BOOL *stop) { + [dict enumerateKeysAndInt32sUsingBlock:^(BOOL aKey, int32_t aValue, BOOL *stop) { #pragma unused(aKey, aValue) if (idx == 0) *stop = YES; XCTAssertNotEqual(idx, 2U); @@ -437,27 +437,27 @@ const int32_t kValues2[] = { 201, 200 }; const int32_t kValues3[] = { 201 }; GPBBoolInt32Dictionary *dict1 = - [[GPBBoolInt32Dictionary alloc] initWithValues:kValues1 + [[GPBBoolInt32Dictionary alloc] initWithInt32s:kValues1 forKeys:kKeys1 count:GPBARRAYSIZE(kValues1)]; XCTAssertNotNil(dict1); GPBBoolInt32Dictionary *dict1prime = - [[GPBBoolInt32Dictionary alloc] initWithValues:kValues1 + [[GPBBoolInt32Dictionary alloc] initWithInt32s:kValues1 forKeys:kKeys1 count:GPBARRAYSIZE(kValues1)]; XCTAssertNotNil(dict1prime); GPBBoolInt32Dictionary *dict2 = - [[GPBBoolInt32Dictionary alloc] initWithValues:kValues2 + [[GPBBoolInt32Dictionary alloc] initWithInt32s:kValues2 forKeys:kKeys1 count:GPBARRAYSIZE(kValues2)]; XCTAssertNotNil(dict2); GPBBoolInt32Dictionary *dict3 = - [[GPBBoolInt32Dictionary alloc] initWithValues:kValues1 + [[GPBBoolInt32Dictionary alloc] initWithInt32s:kValues1 forKeys:kKeys2 count:GPBARRAYSIZE(kValues1)]; XCTAssertNotNil(dict3); GPBBoolInt32Dictionary *dict4 = - [[GPBBoolInt32Dictionary alloc] initWithValues:kValues3 + [[GPBBoolInt32Dictionary alloc] initWithInt32s:kValues3 forKeys:kKeys1 count:GPBARRAYSIZE(kValues3)]; XCTAssertNotNil(dict4); @@ -488,7 +488,7 @@ const BOOL kKeys[] = { YES, NO }; const int32_t kValues[] = { 200, 201 }; GPBBoolInt32Dictionary *dict = - [[GPBBoolInt32Dictionary alloc] initWithValues:kValues + [[GPBBoolInt32Dictionary alloc] initWithInt32s:kValues forKeys:kKeys count:GPBARRAYSIZE(kValues)]; XCTAssertNotNil(dict); @@ -509,7 +509,7 @@ const BOOL kKeys[] = { YES, NO }; const int32_t kValues[] = { 200, 201 }; GPBBoolInt32Dictionary *dict = - [[GPBBoolInt32Dictionary alloc] initWithValues:kValues + [[GPBBoolInt32Dictionary alloc] initWithInt32s:kValues forKeys:kKeys count:GPBARRAYSIZE(kValues)]; XCTAssertNotNil(dict); @@ -529,13 +529,13 @@ XCTAssertNotNil(dict); XCTAssertEqual(dict.count, 0U); - [dict setValue:200 forKey:YES]; + [dict setInt32:200 forKey:YES]; XCTAssertEqual(dict.count, 1U); const BOOL kKeys[] = { NO }; const int32_t kValues[] = { 201 }; GPBBoolInt32Dictionary *dict2 = - [[GPBBoolInt32Dictionary alloc] initWithValues:kValues + [[GPBBoolInt32Dictionary alloc] initWithInt32s:kValues forKeys:kKeys count:GPBARRAYSIZE(kValues)]; XCTAssertNotNil(dict2); @@ -543,11 +543,11 @@ XCTAssertEqual(dict.count, 2U); int32_t value; - XCTAssertTrue([dict valueForKey:YES value:NULL]); - XCTAssertTrue([dict valueForKey:YES value:&value]); + XCTAssertTrue([dict getInt32:NULL forKey:YES]); + XCTAssertTrue([dict getInt32:&value forKey:YES]); XCTAssertEqual(value, 200); - XCTAssertTrue([dict valueForKey:NO value:NULL]); - XCTAssertTrue([dict valueForKey:NO value:&value]); + XCTAssertTrue([dict getInt32:NULL forKey:NO]); + XCTAssertTrue([dict getInt32:&value forKey:NO]); XCTAssertEqual(value, 201); [dict2 release]; } @@ -556,32 +556,32 @@ const BOOL kKeys[] = { YES, NO}; const int32_t kValues[] = { 200, 201 }; GPBBoolInt32Dictionary *dict = - [[GPBBoolInt32Dictionary alloc] initWithValues:kValues + [[GPBBoolInt32Dictionary alloc] initWithInt32s:kValues forKeys:kKeys count:GPBARRAYSIZE(kValues)]; XCTAssertNotNil(dict); XCTAssertEqual(dict.count, 2U); - [dict removeValueForKey:NO]; + [dict removeInt32ForKey:NO]; XCTAssertEqual(dict.count, 1U); int32_t value; - XCTAssertTrue([dict valueForKey:YES value:NULL]); - XCTAssertTrue([dict valueForKey:YES value:&value]); + XCTAssertTrue([dict getInt32:NULL forKey:YES]); + XCTAssertTrue([dict getInt32:&value forKey:YES]); XCTAssertEqual(value, 200); - XCTAssertFalse([dict valueForKey:NO value:NULL]); + XCTAssertFalse([dict getInt32:NULL forKey:NO]); // Remove again does nothing. - [dict removeValueForKey:NO]; + [dict removeInt32ForKey:NO]; XCTAssertEqual(dict.count, 1U); - XCTAssertTrue([dict valueForKey:YES value:NULL]); - XCTAssertTrue([dict valueForKey:YES value:&value]); + XCTAssertTrue([dict getInt32:NULL forKey:YES]); + XCTAssertTrue([dict getInt32:&value forKey:YES]); XCTAssertEqual(value, 200); - XCTAssertFalse([dict valueForKey:NO value:NULL]); + XCTAssertFalse([dict getInt32:NULL forKey:NO]); [dict removeAll]; XCTAssertEqual(dict.count, 0U); - XCTAssertFalse([dict valueForKey:YES value:NULL]); - XCTAssertFalse([dict valueForKey:NO value:NULL]); + XCTAssertFalse([dict getInt32:NULL forKey:YES]); + XCTAssertFalse([dict getInt32:NULL forKey:NO]); [dict release]; } @@ -589,51 +589,51 @@ const BOOL kKeys[] = { YES, NO }; const int32_t kValues[] = { 200, 201 }; GPBBoolInt32Dictionary *dict = - [[GPBBoolInt32Dictionary alloc] initWithValues:kValues - forKeys:kKeys - count:GPBARRAYSIZE(kValues)]; + [[GPBBoolInt32Dictionary alloc] initWithInt32s:kValues + forKeys:kKeys + count:GPBARRAYSIZE(kValues)]; XCTAssertNotNil(dict); XCTAssertEqual(dict.count, 2U); int32_t value; - XCTAssertTrue([dict valueForKey:YES value:NULL]); - XCTAssertTrue([dict valueForKey:YES value:&value]); + XCTAssertTrue([dict getInt32:NULL forKey:YES]); + XCTAssertTrue([dict getInt32:&value forKey:YES]); XCTAssertEqual(value, 200); - XCTAssertTrue([dict valueForKey:NO value:NULL]); - XCTAssertTrue([dict valueForKey:NO value:&value]); + XCTAssertTrue([dict getInt32:NULL forKey:NO]); + XCTAssertTrue([dict getInt32:&value forKey:NO]); XCTAssertEqual(value, 201); - [dict setValue:201 forKey:YES]; + [dict setInt32:201 forKey:YES]; XCTAssertEqual(dict.count, 2U); - XCTAssertTrue([dict valueForKey:YES value:NULL]); - XCTAssertTrue([dict valueForKey:YES value:&value]); + XCTAssertTrue([dict getInt32:NULL forKey:YES]); + XCTAssertTrue([dict getInt32:&value forKey:YES]); XCTAssertEqual(value, 201); - XCTAssertTrue([dict valueForKey:NO value:NULL]); - XCTAssertTrue([dict valueForKey:NO value:&value]); + XCTAssertTrue([dict getInt32:NULL forKey:NO]); + XCTAssertTrue([dict getInt32:&value forKey:NO]); XCTAssertEqual(value, 201); - [dict setValue:200 forKey:NO]; + [dict setInt32:200 forKey:NO]; XCTAssertEqual(dict.count, 2U); - XCTAssertTrue([dict valueForKey:YES value:NULL]); - XCTAssertTrue([dict valueForKey:YES value:&value]); + XCTAssertTrue([dict getInt32:NULL forKey:YES]); + XCTAssertTrue([dict getInt32:&value forKey:YES]); XCTAssertEqual(value, 201); - XCTAssertTrue([dict valueForKey:NO value:NULL]); - XCTAssertTrue([dict valueForKey:NO value:&value]); + XCTAssertTrue([dict getInt32:NULL forKey:NO]); + XCTAssertTrue([dict getInt32:&value forKey:NO]); XCTAssertEqual(value, 200); const BOOL kKeys2[] = { NO, YES }; const int32_t kValues2[] = { 201, 200 }; GPBBoolInt32Dictionary *dict2 = - [[GPBBoolInt32Dictionary alloc] initWithValues:kValues2 + [[GPBBoolInt32Dictionary alloc] initWithInt32s:kValues2 forKeys:kKeys2 count:GPBARRAYSIZE(kValues2)]; XCTAssertNotNil(dict2); [dict addEntriesFromDictionary:dict2]; XCTAssertEqual(dict.count, 2U); - XCTAssertTrue([dict valueForKey:YES value:NULL]); - XCTAssertTrue([dict valueForKey:YES value:&value]); + XCTAssertTrue([dict getInt32:NULL forKey:YES]); + XCTAssertTrue([dict getInt32:&value forKey:YES]); XCTAssertEqual(value, 200); - XCTAssertTrue([dict valueForKey:NO value:NULL]); - XCTAssertTrue([dict valueForKey:NO value:&value]); + XCTAssertTrue([dict getInt32:NULL forKey:NO]); + XCTAssertTrue([dict getInt32:&value forKey:NO]); XCTAssertEqual(value, 201); [dict2 release]; @@ -656,8 +656,8 @@ GPBBoolUInt64Dictionary *dict = [[GPBBoolUInt64Dictionary alloc] init]; XCTAssertNotNil(dict); XCTAssertEqual(dict.count, 0U); - XCTAssertFalse([dict valueForKey:YES value:NULL]); - [dict enumerateKeysAndValuesUsingBlock:^(BOOL aKey, uint64_t aValue, BOOL *stop) { + XCTAssertFalse([dict getUInt64:NULL forKey:YES]); + [dict enumerateKeysAndUInt64sUsingBlock:^(BOOL aKey, uint64_t aValue, BOOL *stop) { #pragma unused(aKey, aValue, stop) XCTFail(@"Shouldn't get here!"); }]; @@ -665,15 +665,15 @@ } - (void)testOne { - GPBBoolUInt64Dictionary *dict = [GPBBoolUInt64Dictionary dictionaryWithValue:300U forKey:YES]; + GPBBoolUInt64Dictionary *dict = [GPBBoolUInt64Dictionary dictionaryWithUInt64:300U forKey:YES]; XCTAssertNotNil(dict); XCTAssertEqual(dict.count, 1U); uint64_t value; - XCTAssertTrue([dict valueForKey:YES value:NULL]); - XCTAssertTrue([dict valueForKey:YES value:&value]); + XCTAssertTrue([dict getUInt64:NULL forKey:YES]); + XCTAssertTrue([dict getUInt64:&value forKey:YES]); XCTAssertEqual(value, 300U); - XCTAssertFalse([dict valueForKey:NO value:NULL]); - [dict enumerateKeysAndValuesUsingBlock:^(BOOL aKey, uint64_t aValue, BOOL *stop) { + XCTAssertFalse([dict getUInt64:NULL forKey:NO]); + [dict enumerateKeysAndUInt64sUsingBlock:^(BOOL aKey, uint64_t aValue, BOOL *stop) { XCTAssertEqual(aKey, YES); XCTAssertEqual(aValue, 300U); XCTAssertNotEqual(stop, NULL); @@ -684,23 +684,23 @@ const BOOL kKeys[] = { YES, NO }; const uint64_t kValues[] = { 300U, 301U }; GPBBoolUInt64Dictionary *dict = - [[GPBBoolUInt64Dictionary alloc] initWithValues:kValues - forKeys:kKeys - count:GPBARRAYSIZE(kValues)]; + [[GPBBoolUInt64Dictionary alloc] initWithUInt64s:kValues + forKeys:kKeys + count:GPBARRAYSIZE(kValues)]; XCTAssertNotNil(dict); XCTAssertEqual(dict.count, 2U); uint64_t value; - XCTAssertTrue([dict valueForKey:YES value:NULL]); - XCTAssertTrue([dict valueForKey:YES value:&value]); + XCTAssertTrue([dict getUInt64:NULL forKey:YES]); + XCTAssertTrue([dict getUInt64:&value forKey:YES]); XCTAssertEqual(value, 300U); - XCTAssertTrue([dict valueForKey:NO value:NULL]); - XCTAssertTrue([dict valueForKey:NO value:&value]); + XCTAssertTrue([dict getUInt64:NULL forKey:NO]); + XCTAssertTrue([dict getUInt64:&value forKey:NO]); XCTAssertEqual(value, 301U); __block NSUInteger idx = 0; BOOL *seenKeys = malloc(2 * sizeof(BOOL)); uint64_t *seenValues = malloc(2 * sizeof(uint64_t)); - [dict enumerateKeysAndValuesUsingBlock:^(BOOL aKey, uint64_t aValue, BOOL *stop) { + [dict enumerateKeysAndUInt64sUsingBlock:^(BOOL aKey, uint64_t aValue, BOOL *stop) { XCTAssertLessThan(idx, 2U); seenKeys[idx] = aKey; seenValues[idx] = aValue; @@ -722,7 +722,7 @@ // Stopping the enumeration. idx = 0; - [dict enumerateKeysAndValuesUsingBlock:^(BOOL aKey, uint64_t aValue, BOOL *stop) { + [dict enumerateKeysAndUInt64sUsingBlock:^(BOOL aKey, uint64_t aValue, BOOL *stop) { #pragma unused(aKey, aValue) if (idx == 0) *stop = YES; XCTAssertNotEqual(idx, 2U); @@ -738,29 +738,29 @@ const uint64_t kValues2[] = { 301U, 300U }; const uint64_t kValues3[] = { 301U }; GPBBoolUInt64Dictionary *dict1 = - [[GPBBoolUInt64Dictionary alloc] initWithValues:kValues1 - forKeys:kKeys1 - count:GPBARRAYSIZE(kValues1)]; + [[GPBBoolUInt64Dictionary alloc] initWithUInt64s:kValues1 + forKeys:kKeys1 + count:GPBARRAYSIZE(kValues1)]; XCTAssertNotNil(dict1); GPBBoolUInt64Dictionary *dict1prime = - [[GPBBoolUInt64Dictionary alloc] initWithValues:kValues1 - forKeys:kKeys1 - count:GPBARRAYSIZE(kValues1)]; + [[GPBBoolUInt64Dictionary alloc] initWithUInt64s:kValues1 + forKeys:kKeys1 + count:GPBARRAYSIZE(kValues1)]; XCTAssertNotNil(dict1prime); GPBBoolUInt64Dictionary *dict2 = - [[GPBBoolUInt64Dictionary alloc] initWithValues:kValues2 - forKeys:kKeys1 - count:GPBARRAYSIZE(kValues2)]; + [[GPBBoolUInt64Dictionary alloc] initWithUInt64s:kValues2 + forKeys:kKeys1 + count:GPBARRAYSIZE(kValues2)]; XCTAssertNotNil(dict2); GPBBoolUInt64Dictionary *dict3 = - [[GPBBoolUInt64Dictionary alloc] initWithValues:kValues1 - forKeys:kKeys2 - count:GPBARRAYSIZE(kValues1)]; + [[GPBBoolUInt64Dictionary alloc] initWithUInt64s:kValues1 + forKeys:kKeys2 + count:GPBARRAYSIZE(kValues1)]; XCTAssertNotNil(dict3); GPBBoolUInt64Dictionary *dict4 = - [[GPBBoolUInt64Dictionary alloc] initWithValues:kValues3 - forKeys:kKeys1 - count:GPBARRAYSIZE(kValues3)]; + [[GPBBoolUInt64Dictionary alloc] initWithUInt64s:kValues3 + forKeys:kKeys1 + count:GPBARRAYSIZE(kValues3)]; XCTAssertNotNil(dict4); // 1/1Prime should be different objects, but equal. @@ -789,9 +789,9 @@ const BOOL kKeys[] = { YES, NO }; const uint64_t kValues[] = { 300U, 301U }; GPBBoolUInt64Dictionary *dict = - [[GPBBoolUInt64Dictionary alloc] initWithValues:kValues - forKeys:kKeys - count:GPBARRAYSIZE(kValues)]; + [[GPBBoolUInt64Dictionary alloc] initWithUInt64s:kValues + forKeys:kKeys + count:GPBARRAYSIZE(kValues)]; XCTAssertNotNil(dict); GPBBoolUInt64Dictionary *dict2 = [dict copy]; @@ -810,9 +810,9 @@ const BOOL kKeys[] = { YES, NO }; const uint64_t kValues[] = { 300U, 301U }; GPBBoolUInt64Dictionary *dict = - [[GPBBoolUInt64Dictionary alloc] initWithValues:kValues - forKeys:kKeys - count:GPBARRAYSIZE(kValues)]; + [[GPBBoolUInt64Dictionary alloc] initWithUInt64s:kValues + forKeys:kKeys + count:GPBARRAYSIZE(kValues)]; XCTAssertNotNil(dict); GPBBoolUInt64Dictionary *dict2 = @@ -830,25 +830,25 @@ XCTAssertNotNil(dict); XCTAssertEqual(dict.count, 0U); - [dict setValue:300U forKey:YES]; + [dict setUInt64:300U forKey:YES]; XCTAssertEqual(dict.count, 1U); const BOOL kKeys[] = { NO }; const uint64_t kValues[] = { 301U }; GPBBoolUInt64Dictionary *dict2 = - [[GPBBoolUInt64Dictionary alloc] initWithValues:kValues - forKeys:kKeys - count:GPBARRAYSIZE(kValues)]; + [[GPBBoolUInt64Dictionary alloc] initWithUInt64s:kValues + forKeys:kKeys + count:GPBARRAYSIZE(kValues)]; XCTAssertNotNil(dict2); [dict addEntriesFromDictionary:dict2]; XCTAssertEqual(dict.count, 2U); uint64_t value; - XCTAssertTrue([dict valueForKey:YES value:NULL]); - XCTAssertTrue([dict valueForKey:YES value:&value]); + XCTAssertTrue([dict getUInt64:NULL forKey:YES]); + XCTAssertTrue([dict getUInt64:&value forKey:YES]); XCTAssertEqual(value, 300U); - XCTAssertTrue([dict valueForKey:NO value:NULL]); - XCTAssertTrue([dict valueForKey:NO value:&value]); + XCTAssertTrue([dict getUInt64:NULL forKey:NO]); + XCTAssertTrue([dict getUInt64:&value forKey:NO]); XCTAssertEqual(value, 301U); [dict2 release]; } @@ -857,32 +857,32 @@ const BOOL kKeys[] = { YES, NO}; const uint64_t kValues[] = { 300U, 301U }; GPBBoolUInt64Dictionary *dict = - [[GPBBoolUInt64Dictionary alloc] initWithValues:kValues - forKeys:kKeys - count:GPBARRAYSIZE(kValues)]; + [[GPBBoolUInt64Dictionary alloc] initWithUInt64s:kValues + forKeys:kKeys + count:GPBARRAYSIZE(kValues)]; XCTAssertNotNil(dict); XCTAssertEqual(dict.count, 2U); - [dict removeValueForKey:NO]; + [dict removeUInt64ForKey:NO]; XCTAssertEqual(dict.count, 1U); uint64_t value; - XCTAssertTrue([dict valueForKey:YES value:NULL]); - XCTAssertTrue([dict valueForKey:YES value:&value]); + XCTAssertTrue([dict getUInt64:NULL forKey:YES]); + XCTAssertTrue([dict getUInt64:&value forKey:YES]); XCTAssertEqual(value, 300U); - XCTAssertFalse([dict valueForKey:NO value:NULL]); + XCTAssertFalse([dict getUInt64:NULL forKey:NO]); // Remove again does nothing. - [dict removeValueForKey:NO]; + [dict removeUInt64ForKey:NO]; XCTAssertEqual(dict.count, 1U); - XCTAssertTrue([dict valueForKey:YES value:NULL]); - XCTAssertTrue([dict valueForKey:YES value:&value]); + XCTAssertTrue([dict getUInt64:NULL forKey:YES]); + XCTAssertTrue([dict getUInt64:&value forKey:YES]); XCTAssertEqual(value, 300U); - XCTAssertFalse([dict valueForKey:NO value:NULL]); + XCTAssertFalse([dict getUInt64:NULL forKey:NO]); [dict removeAll]; XCTAssertEqual(dict.count, 0U); - XCTAssertFalse([dict valueForKey:YES value:NULL]); - XCTAssertFalse([dict valueForKey:NO value:NULL]); + XCTAssertFalse([dict getUInt64:NULL forKey:YES]); + XCTAssertFalse([dict getUInt64:NULL forKey:NO]); [dict release]; } @@ -890,51 +890,51 @@ const BOOL kKeys[] = { YES, NO }; const uint64_t kValues[] = { 300U, 301U }; GPBBoolUInt64Dictionary *dict = - [[GPBBoolUInt64Dictionary alloc] initWithValues:kValues - forKeys:kKeys - count:GPBARRAYSIZE(kValues)]; + [[GPBBoolUInt64Dictionary alloc] initWithUInt64s:kValues + forKeys:kKeys + count:GPBARRAYSIZE(kValues)]; XCTAssertNotNil(dict); XCTAssertEqual(dict.count, 2U); uint64_t value; - XCTAssertTrue([dict valueForKey:YES value:NULL]); - XCTAssertTrue([dict valueForKey:YES value:&value]); + XCTAssertTrue([dict getUInt64:NULL forKey:YES]); + XCTAssertTrue([dict getUInt64:&value forKey:YES]); XCTAssertEqual(value, 300U); - XCTAssertTrue([dict valueForKey:NO value:NULL]); - XCTAssertTrue([dict valueForKey:NO value:&value]); + XCTAssertTrue([dict getUInt64:NULL forKey:NO]); + XCTAssertTrue([dict getUInt64:&value forKey:NO]); XCTAssertEqual(value, 301U); - [dict setValue:301U forKey:YES]; + [dict setUInt64:301U forKey:YES]; XCTAssertEqual(dict.count, 2U); - XCTAssertTrue([dict valueForKey:YES value:NULL]); - XCTAssertTrue([dict valueForKey:YES value:&value]); + XCTAssertTrue([dict getUInt64:NULL forKey:YES]); + XCTAssertTrue([dict getUInt64:&value forKey:YES]); XCTAssertEqual(value, 301U); - XCTAssertTrue([dict valueForKey:NO value:NULL]); - XCTAssertTrue([dict valueForKey:NO value:&value]); + XCTAssertTrue([dict getUInt64:NULL forKey:NO]); + XCTAssertTrue([dict getUInt64:&value forKey:NO]); XCTAssertEqual(value, 301U); - [dict setValue:300U forKey:NO]; + [dict setUInt64:300U forKey:NO]; XCTAssertEqual(dict.count, 2U); - XCTAssertTrue([dict valueForKey:YES value:NULL]); - XCTAssertTrue([dict valueForKey:YES value:&value]); + XCTAssertTrue([dict getUInt64:NULL forKey:YES]); + XCTAssertTrue([dict getUInt64:&value forKey:YES]); XCTAssertEqual(value, 301U); - XCTAssertTrue([dict valueForKey:NO value:NULL]); - XCTAssertTrue([dict valueForKey:NO value:&value]); + XCTAssertTrue([dict getUInt64:NULL forKey:NO]); + XCTAssertTrue([dict getUInt64:&value forKey:NO]); XCTAssertEqual(value, 300U); const BOOL kKeys2[] = { NO, YES }; const uint64_t kValues2[] = { 301U, 300U }; GPBBoolUInt64Dictionary *dict2 = - [[GPBBoolUInt64Dictionary alloc] initWithValues:kValues2 - forKeys:kKeys2 - count:GPBARRAYSIZE(kValues2)]; + [[GPBBoolUInt64Dictionary alloc] initWithUInt64s:kValues2 + forKeys:kKeys2 + count:GPBARRAYSIZE(kValues2)]; XCTAssertNotNil(dict2); [dict addEntriesFromDictionary:dict2]; XCTAssertEqual(dict.count, 2U); - XCTAssertTrue([dict valueForKey:YES value:NULL]); - XCTAssertTrue([dict valueForKey:YES value:&value]); + XCTAssertTrue([dict getUInt64:NULL forKey:YES]); + XCTAssertTrue([dict getUInt64:&value forKey:YES]); XCTAssertEqual(value, 300U); - XCTAssertTrue([dict valueForKey:NO value:NULL]); - XCTAssertTrue([dict valueForKey:NO value:&value]); + XCTAssertTrue([dict getUInt64:NULL forKey:NO]); + XCTAssertTrue([dict getUInt64:&value forKey:NO]); XCTAssertEqual(value, 301U); [dict2 release]; @@ -957,8 +957,8 @@ GPBBoolInt64Dictionary *dict = [[GPBBoolInt64Dictionary alloc] init]; XCTAssertNotNil(dict); XCTAssertEqual(dict.count, 0U); - XCTAssertFalse([dict valueForKey:YES value:NULL]); - [dict enumerateKeysAndValuesUsingBlock:^(BOOL aKey, int64_t aValue, BOOL *stop) { + XCTAssertFalse([dict getInt64:NULL forKey:YES]); + [dict enumerateKeysAndInt64sUsingBlock:^(BOOL aKey, int64_t aValue, BOOL *stop) { #pragma unused(aKey, aValue, stop) XCTFail(@"Shouldn't get here!"); }]; @@ -966,15 +966,15 @@ } - (void)testOne { - GPBBoolInt64Dictionary *dict = [GPBBoolInt64Dictionary dictionaryWithValue:400 forKey:YES]; + GPBBoolInt64Dictionary *dict = [GPBBoolInt64Dictionary dictionaryWithInt64:400 forKey:YES]; XCTAssertNotNil(dict); XCTAssertEqual(dict.count, 1U); int64_t value; - XCTAssertTrue([dict valueForKey:YES value:NULL]); - XCTAssertTrue([dict valueForKey:YES value:&value]); + XCTAssertTrue([dict getInt64:NULL forKey:YES]); + XCTAssertTrue([dict getInt64:&value forKey:YES]); XCTAssertEqual(value, 400); - XCTAssertFalse([dict valueForKey:NO value:NULL]); - [dict enumerateKeysAndValuesUsingBlock:^(BOOL aKey, int64_t aValue, BOOL *stop) { + XCTAssertFalse([dict getInt64:NULL forKey:NO]); + [dict enumerateKeysAndInt64sUsingBlock:^(BOOL aKey, int64_t aValue, BOOL *stop) { XCTAssertEqual(aKey, YES); XCTAssertEqual(aValue, 400); XCTAssertNotEqual(stop, NULL); @@ -985,23 +985,23 @@ const BOOL kKeys[] = { YES, NO }; const int64_t kValues[] = { 400, 401 }; GPBBoolInt64Dictionary *dict = - [[GPBBoolInt64Dictionary alloc] initWithValues:kValues + [[GPBBoolInt64Dictionary alloc] initWithInt64s:kValues forKeys:kKeys count:GPBARRAYSIZE(kValues)]; XCTAssertNotNil(dict); XCTAssertEqual(dict.count, 2U); int64_t value; - XCTAssertTrue([dict valueForKey:YES value:NULL]); - XCTAssertTrue([dict valueForKey:YES value:&value]); + XCTAssertTrue([dict getInt64:NULL forKey:YES]); + XCTAssertTrue([dict getInt64:&value forKey:YES]); XCTAssertEqual(value, 400); - XCTAssertTrue([dict valueForKey:NO value:NULL]); - XCTAssertTrue([dict valueForKey:NO value:&value]); + XCTAssertTrue([dict getInt64:NULL forKey:NO]); + XCTAssertTrue([dict getInt64:&value forKey:NO]); XCTAssertEqual(value, 401); __block NSUInteger idx = 0; BOOL *seenKeys = malloc(2 * sizeof(BOOL)); int64_t *seenValues = malloc(2 * sizeof(int64_t)); - [dict enumerateKeysAndValuesUsingBlock:^(BOOL aKey, int64_t aValue, BOOL *stop) { + [dict enumerateKeysAndInt64sUsingBlock:^(BOOL aKey, int64_t aValue, BOOL *stop) { XCTAssertLessThan(idx, 2U); seenKeys[idx] = aKey; seenValues[idx] = aValue; @@ -1023,7 +1023,7 @@ // Stopping the enumeration. idx = 0; - [dict enumerateKeysAndValuesUsingBlock:^(BOOL aKey, int64_t aValue, BOOL *stop) { + [dict enumerateKeysAndInt64sUsingBlock:^(BOOL aKey, int64_t aValue, BOOL *stop) { #pragma unused(aKey, aValue) if (idx == 0) *stop = YES; XCTAssertNotEqual(idx, 2U); @@ -1039,27 +1039,27 @@ const int64_t kValues2[] = { 401, 400 }; const int64_t kValues3[] = { 401 }; GPBBoolInt64Dictionary *dict1 = - [[GPBBoolInt64Dictionary alloc] initWithValues:kValues1 + [[GPBBoolInt64Dictionary alloc] initWithInt64s:kValues1 forKeys:kKeys1 count:GPBARRAYSIZE(kValues1)]; XCTAssertNotNil(dict1); GPBBoolInt64Dictionary *dict1prime = - [[GPBBoolInt64Dictionary alloc] initWithValues:kValues1 + [[GPBBoolInt64Dictionary alloc] initWithInt64s:kValues1 forKeys:kKeys1 count:GPBARRAYSIZE(kValues1)]; XCTAssertNotNil(dict1prime); GPBBoolInt64Dictionary *dict2 = - [[GPBBoolInt64Dictionary alloc] initWithValues:kValues2 + [[GPBBoolInt64Dictionary alloc] initWithInt64s:kValues2 forKeys:kKeys1 count:GPBARRAYSIZE(kValues2)]; XCTAssertNotNil(dict2); GPBBoolInt64Dictionary *dict3 = - [[GPBBoolInt64Dictionary alloc] initWithValues:kValues1 + [[GPBBoolInt64Dictionary alloc] initWithInt64s:kValues1 forKeys:kKeys2 count:GPBARRAYSIZE(kValues1)]; XCTAssertNotNil(dict3); GPBBoolInt64Dictionary *dict4 = - [[GPBBoolInt64Dictionary alloc] initWithValues:kValues3 + [[GPBBoolInt64Dictionary alloc] initWithInt64s:kValues3 forKeys:kKeys1 count:GPBARRAYSIZE(kValues3)]; XCTAssertNotNil(dict4); @@ -1090,7 +1090,7 @@ const BOOL kKeys[] = { YES, NO }; const int64_t kValues[] = { 400, 401 }; GPBBoolInt64Dictionary *dict = - [[GPBBoolInt64Dictionary alloc] initWithValues:kValues + [[GPBBoolInt64Dictionary alloc] initWithInt64s:kValues forKeys:kKeys count:GPBARRAYSIZE(kValues)]; XCTAssertNotNil(dict); @@ -1111,7 +1111,7 @@ const BOOL kKeys[] = { YES, NO }; const int64_t kValues[] = { 400, 401 }; GPBBoolInt64Dictionary *dict = - [[GPBBoolInt64Dictionary alloc] initWithValues:kValues + [[GPBBoolInt64Dictionary alloc] initWithInt64s:kValues forKeys:kKeys count:GPBARRAYSIZE(kValues)]; XCTAssertNotNil(dict); @@ -1131,13 +1131,13 @@ XCTAssertNotNil(dict); XCTAssertEqual(dict.count, 0U); - [dict setValue:400 forKey:YES]; + [dict setInt64:400 forKey:YES]; XCTAssertEqual(dict.count, 1U); const BOOL kKeys[] = { NO }; const int64_t kValues[] = { 401 }; GPBBoolInt64Dictionary *dict2 = - [[GPBBoolInt64Dictionary alloc] initWithValues:kValues + [[GPBBoolInt64Dictionary alloc] initWithInt64s:kValues forKeys:kKeys count:GPBARRAYSIZE(kValues)]; XCTAssertNotNil(dict2); @@ -1145,11 +1145,11 @@ XCTAssertEqual(dict.count, 2U); int64_t value; - XCTAssertTrue([dict valueForKey:YES value:NULL]); - XCTAssertTrue([dict valueForKey:YES value:&value]); + XCTAssertTrue([dict getInt64:NULL forKey:YES]); + XCTAssertTrue([dict getInt64:&value forKey:YES]); XCTAssertEqual(value, 400); - XCTAssertTrue([dict valueForKey:NO value:NULL]); - XCTAssertTrue([dict valueForKey:NO value:&value]); + XCTAssertTrue([dict getInt64:NULL forKey:NO]); + XCTAssertTrue([dict getInt64:&value forKey:NO]); XCTAssertEqual(value, 401); [dict2 release]; } @@ -1158,32 +1158,32 @@ const BOOL kKeys[] = { YES, NO}; const int64_t kValues[] = { 400, 401 }; GPBBoolInt64Dictionary *dict = - [[GPBBoolInt64Dictionary alloc] initWithValues:kValues + [[GPBBoolInt64Dictionary alloc] initWithInt64s:kValues forKeys:kKeys count:GPBARRAYSIZE(kValues)]; XCTAssertNotNil(dict); XCTAssertEqual(dict.count, 2U); - [dict removeValueForKey:NO]; + [dict removeInt64ForKey:NO]; XCTAssertEqual(dict.count, 1U); int64_t value; - XCTAssertTrue([dict valueForKey:YES value:NULL]); - XCTAssertTrue([dict valueForKey:YES value:&value]); + XCTAssertTrue([dict getInt64:NULL forKey:YES]); + XCTAssertTrue([dict getInt64:&value forKey:YES]); XCTAssertEqual(value, 400); - XCTAssertFalse([dict valueForKey:NO value:NULL]); + XCTAssertFalse([dict getInt64:NULL forKey:NO]); // Remove again does nothing. - [dict removeValueForKey:NO]; + [dict removeInt64ForKey:NO]; XCTAssertEqual(dict.count, 1U); - XCTAssertTrue([dict valueForKey:YES value:NULL]); - XCTAssertTrue([dict valueForKey:YES value:&value]); + XCTAssertTrue([dict getInt64:NULL forKey:YES]); + XCTAssertTrue([dict getInt64:&value forKey:YES]); XCTAssertEqual(value, 400); - XCTAssertFalse([dict valueForKey:NO value:NULL]); + XCTAssertFalse([dict getInt64:NULL forKey:NO]); [dict removeAll]; XCTAssertEqual(dict.count, 0U); - XCTAssertFalse([dict valueForKey:YES value:NULL]); - XCTAssertFalse([dict valueForKey:NO value:NULL]); + XCTAssertFalse([dict getInt64:NULL forKey:YES]); + XCTAssertFalse([dict getInt64:NULL forKey:NO]); [dict release]; } @@ -1191,51 +1191,51 @@ const BOOL kKeys[] = { YES, NO }; const int64_t kValues[] = { 400, 401 }; GPBBoolInt64Dictionary *dict = - [[GPBBoolInt64Dictionary alloc] initWithValues:kValues - forKeys:kKeys - count:GPBARRAYSIZE(kValues)]; + [[GPBBoolInt64Dictionary alloc] initWithInt64s:kValues + forKeys:kKeys + count:GPBARRAYSIZE(kValues)]; XCTAssertNotNil(dict); XCTAssertEqual(dict.count, 2U); int64_t value; - XCTAssertTrue([dict valueForKey:YES value:NULL]); - XCTAssertTrue([dict valueForKey:YES value:&value]); + XCTAssertTrue([dict getInt64:NULL forKey:YES]); + XCTAssertTrue([dict getInt64:&value forKey:YES]); XCTAssertEqual(value, 400); - XCTAssertTrue([dict valueForKey:NO value:NULL]); - XCTAssertTrue([dict valueForKey:NO value:&value]); + XCTAssertTrue([dict getInt64:NULL forKey:NO]); + XCTAssertTrue([dict getInt64:&value forKey:NO]); XCTAssertEqual(value, 401); - [dict setValue:401 forKey:YES]; + [dict setInt64:401 forKey:YES]; XCTAssertEqual(dict.count, 2U); - XCTAssertTrue([dict valueForKey:YES value:NULL]); - XCTAssertTrue([dict valueForKey:YES value:&value]); + XCTAssertTrue([dict getInt64:NULL forKey:YES]); + XCTAssertTrue([dict getInt64:&value forKey:YES]); XCTAssertEqual(value, 401); - XCTAssertTrue([dict valueForKey:NO value:NULL]); - XCTAssertTrue([dict valueForKey:NO value:&value]); + XCTAssertTrue([dict getInt64:NULL forKey:NO]); + XCTAssertTrue([dict getInt64:&value forKey:NO]); XCTAssertEqual(value, 401); - [dict setValue:400 forKey:NO]; + [dict setInt64:400 forKey:NO]; XCTAssertEqual(dict.count, 2U); - XCTAssertTrue([dict valueForKey:YES value:NULL]); - XCTAssertTrue([dict valueForKey:YES value:&value]); + XCTAssertTrue([dict getInt64:NULL forKey:YES]); + XCTAssertTrue([dict getInt64:&value forKey:YES]); XCTAssertEqual(value, 401); - XCTAssertTrue([dict valueForKey:NO value:NULL]); - XCTAssertTrue([dict valueForKey:NO value:&value]); + XCTAssertTrue([dict getInt64:NULL forKey:NO]); + XCTAssertTrue([dict getInt64:&value forKey:NO]); XCTAssertEqual(value, 400); const BOOL kKeys2[] = { NO, YES }; const int64_t kValues2[] = { 401, 400 }; GPBBoolInt64Dictionary *dict2 = - [[GPBBoolInt64Dictionary alloc] initWithValues:kValues2 + [[GPBBoolInt64Dictionary alloc] initWithInt64s:kValues2 forKeys:kKeys2 count:GPBARRAYSIZE(kValues2)]; XCTAssertNotNil(dict2); [dict addEntriesFromDictionary:dict2]; XCTAssertEqual(dict.count, 2U); - XCTAssertTrue([dict valueForKey:YES value:NULL]); - XCTAssertTrue([dict valueForKey:YES value:&value]); + XCTAssertTrue([dict getInt64:NULL forKey:YES]); + XCTAssertTrue([dict getInt64:&value forKey:YES]); XCTAssertEqual(value, 400); - XCTAssertTrue([dict valueForKey:NO value:NULL]); - XCTAssertTrue([dict valueForKey:NO value:&value]); + XCTAssertTrue([dict getInt64:NULL forKey:NO]); + XCTAssertTrue([dict getInt64:&value forKey:NO]); XCTAssertEqual(value, 401); [dict2 release]; @@ -1258,8 +1258,8 @@ GPBBoolBoolDictionary *dict = [[GPBBoolBoolDictionary alloc] init]; XCTAssertNotNil(dict); XCTAssertEqual(dict.count, 0U); - XCTAssertFalse([dict valueForKey:YES value:NULL]); - [dict enumerateKeysAndValuesUsingBlock:^(BOOL aKey, BOOL aValue, BOOL *stop) { + XCTAssertFalse([dict getBool:NULL forKey:YES]); + [dict enumerateKeysAndBoolsUsingBlock:^(BOOL aKey, BOOL aValue, BOOL *stop) { #pragma unused(aKey, aValue, stop) XCTFail(@"Shouldn't get here!"); }]; @@ -1267,15 +1267,15 @@ } - (void)testOne { - GPBBoolBoolDictionary *dict = [GPBBoolBoolDictionary dictionaryWithValue:NO forKey:YES]; + GPBBoolBoolDictionary *dict = [GPBBoolBoolDictionary dictionaryWithBool:NO forKey:YES]; XCTAssertNotNil(dict); XCTAssertEqual(dict.count, 1U); BOOL value; - XCTAssertTrue([dict valueForKey:YES value:NULL]); - XCTAssertTrue([dict valueForKey:YES value:&value]); + XCTAssertTrue([dict getBool:NULL forKey:YES]); + XCTAssertTrue([dict getBool:&value forKey:YES]); XCTAssertEqual(value, NO); - XCTAssertFalse([dict valueForKey:NO value:NULL]); - [dict enumerateKeysAndValuesUsingBlock:^(BOOL aKey, BOOL aValue, BOOL *stop) { + XCTAssertFalse([dict getBool:NULL forKey:NO]); + [dict enumerateKeysAndBoolsUsingBlock:^(BOOL aKey, BOOL aValue, BOOL *stop) { XCTAssertEqual(aKey, YES); XCTAssertEqual(aValue, NO); XCTAssertNotEqual(stop, NULL); @@ -1286,23 +1286,23 @@ const BOOL kKeys[] = { YES, NO }; const BOOL kValues[] = { NO, YES }; GPBBoolBoolDictionary *dict = - [[GPBBoolBoolDictionary alloc] initWithValues:kValues - forKeys:kKeys - count:GPBARRAYSIZE(kValues)]; + [[GPBBoolBoolDictionary alloc] initWithBools:kValues + forKeys:kKeys + count:GPBARRAYSIZE(kValues)]; XCTAssertNotNil(dict); XCTAssertEqual(dict.count, 2U); BOOL value; - XCTAssertTrue([dict valueForKey:YES value:NULL]); - XCTAssertTrue([dict valueForKey:YES value:&value]); + XCTAssertTrue([dict getBool:NULL forKey:YES]); + XCTAssertTrue([dict getBool:&value forKey:YES]); XCTAssertEqual(value, NO); - XCTAssertTrue([dict valueForKey:NO value:NULL]); - XCTAssertTrue([dict valueForKey:NO value:&value]); + XCTAssertTrue([dict getBool:NULL forKey:NO]); + XCTAssertTrue([dict getBool:&value forKey:NO]); XCTAssertEqual(value, YES); __block NSUInteger idx = 0; BOOL *seenKeys = malloc(2 * sizeof(BOOL)); BOOL *seenValues = malloc(2 * sizeof(BOOL)); - [dict enumerateKeysAndValuesUsingBlock:^(BOOL aKey, BOOL aValue, BOOL *stop) { + [dict enumerateKeysAndBoolsUsingBlock:^(BOOL aKey, BOOL aValue, BOOL *stop) { XCTAssertLessThan(idx, 2U); seenKeys[idx] = aKey; seenValues[idx] = aValue; @@ -1324,7 +1324,7 @@ // Stopping the enumeration. idx = 0; - [dict enumerateKeysAndValuesUsingBlock:^(BOOL aKey, BOOL aValue, BOOL *stop) { + [dict enumerateKeysAndBoolsUsingBlock:^(BOOL aKey, BOOL aValue, BOOL *stop) { #pragma unused(aKey, aValue) if (idx == 0) *stop = YES; XCTAssertNotEqual(idx, 2U); @@ -1340,29 +1340,29 @@ const BOOL kValues2[] = { YES, NO }; const BOOL kValues3[] = { YES }; GPBBoolBoolDictionary *dict1 = - [[GPBBoolBoolDictionary alloc] initWithValues:kValues1 - forKeys:kKeys1 - count:GPBARRAYSIZE(kValues1)]; + [[GPBBoolBoolDictionary alloc] initWithBools:kValues1 + forKeys:kKeys1 + count:GPBARRAYSIZE(kValues1)]; XCTAssertNotNil(dict1); GPBBoolBoolDictionary *dict1prime = - [[GPBBoolBoolDictionary alloc] initWithValues:kValues1 - forKeys:kKeys1 - count:GPBARRAYSIZE(kValues1)]; + [[GPBBoolBoolDictionary alloc] initWithBools:kValues1 + forKeys:kKeys1 + count:GPBARRAYSIZE(kValues1)]; XCTAssertNotNil(dict1prime); GPBBoolBoolDictionary *dict2 = - [[GPBBoolBoolDictionary alloc] initWithValues:kValues2 - forKeys:kKeys1 - count:GPBARRAYSIZE(kValues2)]; + [[GPBBoolBoolDictionary alloc] initWithBools:kValues2 + forKeys:kKeys1 + count:GPBARRAYSIZE(kValues2)]; XCTAssertNotNil(dict2); GPBBoolBoolDictionary *dict3 = - [[GPBBoolBoolDictionary alloc] initWithValues:kValues1 - forKeys:kKeys2 - count:GPBARRAYSIZE(kValues1)]; + [[GPBBoolBoolDictionary alloc] initWithBools:kValues1 + forKeys:kKeys2 + count:GPBARRAYSIZE(kValues1)]; XCTAssertNotNil(dict3); GPBBoolBoolDictionary *dict4 = - [[GPBBoolBoolDictionary alloc] initWithValues:kValues3 - forKeys:kKeys1 - count:GPBARRAYSIZE(kValues3)]; + [[GPBBoolBoolDictionary alloc] initWithBools:kValues3 + forKeys:kKeys1 + count:GPBARRAYSIZE(kValues3)]; XCTAssertNotNil(dict4); // 1/1Prime should be different objects, but equal. @@ -1391,9 +1391,9 @@ const BOOL kKeys[] = { YES, NO }; const BOOL kValues[] = { NO, YES }; GPBBoolBoolDictionary *dict = - [[GPBBoolBoolDictionary alloc] initWithValues:kValues - forKeys:kKeys - count:GPBARRAYSIZE(kValues)]; + [[GPBBoolBoolDictionary alloc] initWithBools:kValues + forKeys:kKeys + count:GPBARRAYSIZE(kValues)]; XCTAssertNotNil(dict); GPBBoolBoolDictionary *dict2 = [dict copy]; @@ -1412,9 +1412,9 @@ const BOOL kKeys[] = { YES, NO }; const BOOL kValues[] = { NO, YES }; GPBBoolBoolDictionary *dict = - [[GPBBoolBoolDictionary alloc] initWithValues:kValues - forKeys:kKeys - count:GPBARRAYSIZE(kValues)]; + [[GPBBoolBoolDictionary alloc] initWithBools:kValues + forKeys:kKeys + count:GPBARRAYSIZE(kValues)]; XCTAssertNotNil(dict); GPBBoolBoolDictionary *dict2 = @@ -1432,25 +1432,25 @@ XCTAssertNotNil(dict); XCTAssertEqual(dict.count, 0U); - [dict setValue:NO forKey:YES]; + [dict setBool:NO forKey:YES]; XCTAssertEqual(dict.count, 1U); const BOOL kKeys[] = { NO }; const BOOL kValues[] = { YES }; GPBBoolBoolDictionary *dict2 = - [[GPBBoolBoolDictionary alloc] initWithValues:kValues - forKeys:kKeys - count:GPBARRAYSIZE(kValues)]; + [[GPBBoolBoolDictionary alloc] initWithBools:kValues + forKeys:kKeys + count:GPBARRAYSIZE(kValues)]; XCTAssertNotNil(dict2); [dict addEntriesFromDictionary:dict2]; XCTAssertEqual(dict.count, 2U); BOOL value; - XCTAssertTrue([dict valueForKey:YES value:NULL]); - XCTAssertTrue([dict valueForKey:YES value:&value]); + XCTAssertTrue([dict getBool:NULL forKey:YES]); + XCTAssertTrue([dict getBool:&value forKey:YES]); XCTAssertEqual(value, NO); - XCTAssertTrue([dict valueForKey:NO value:NULL]); - XCTAssertTrue([dict valueForKey:NO value:&value]); + XCTAssertTrue([dict getBool:NULL forKey:NO]); + XCTAssertTrue([dict getBool:&value forKey:NO]); XCTAssertEqual(value, YES); [dict2 release]; } @@ -1459,32 +1459,32 @@ const BOOL kKeys[] = { YES, NO}; const BOOL kValues[] = { NO, YES }; GPBBoolBoolDictionary *dict = - [[GPBBoolBoolDictionary alloc] initWithValues:kValues - forKeys:kKeys - count:GPBARRAYSIZE(kValues)]; + [[GPBBoolBoolDictionary alloc] initWithBools:kValues + forKeys:kKeys + count:GPBARRAYSIZE(kValues)]; XCTAssertNotNil(dict); XCTAssertEqual(dict.count, 2U); - [dict removeValueForKey:NO]; + [dict removeBoolForKey:NO]; XCTAssertEqual(dict.count, 1U); BOOL value; - XCTAssertTrue([dict valueForKey:YES value:NULL]); - XCTAssertTrue([dict valueForKey:YES value:&value]); + XCTAssertTrue([dict getBool:NULL forKey:YES]); + XCTAssertTrue([dict getBool:&value forKey:YES]); XCTAssertEqual(value, NO); - XCTAssertFalse([dict valueForKey:NO value:NULL]); + XCTAssertFalse([dict getBool:NULL forKey:NO]); // Remove again does nothing. - [dict removeValueForKey:NO]; + [dict removeBoolForKey:NO]; XCTAssertEqual(dict.count, 1U); - XCTAssertTrue([dict valueForKey:YES value:NULL]); - XCTAssertTrue([dict valueForKey:YES value:&value]); + XCTAssertTrue([dict getBool:NULL forKey:YES]); + XCTAssertTrue([dict getBool:&value forKey:YES]); XCTAssertEqual(value, NO); - XCTAssertFalse([dict valueForKey:NO value:NULL]); + XCTAssertFalse([dict getBool:NULL forKey:NO]); [dict removeAll]; XCTAssertEqual(dict.count, 0U); - XCTAssertFalse([dict valueForKey:YES value:NULL]); - XCTAssertFalse([dict valueForKey:NO value:NULL]); + XCTAssertFalse([dict getBool:NULL forKey:YES]); + XCTAssertFalse([dict getBool:NULL forKey:NO]); [dict release]; } @@ -1492,51 +1492,51 @@ const BOOL kKeys[] = { YES, NO }; const BOOL kValues[] = { NO, YES }; GPBBoolBoolDictionary *dict = - [[GPBBoolBoolDictionary alloc] initWithValues:kValues - forKeys:kKeys - count:GPBARRAYSIZE(kValues)]; + [[GPBBoolBoolDictionary alloc] initWithBools:kValues + forKeys:kKeys + count:GPBARRAYSIZE(kValues)]; XCTAssertNotNil(dict); XCTAssertEqual(dict.count, 2U); BOOL value; - XCTAssertTrue([dict valueForKey:YES value:NULL]); - XCTAssertTrue([dict valueForKey:YES value:&value]); + XCTAssertTrue([dict getBool:NULL forKey:YES]); + XCTAssertTrue([dict getBool:&value forKey:YES]); XCTAssertEqual(value, NO); - XCTAssertTrue([dict valueForKey:NO value:NULL]); - XCTAssertTrue([dict valueForKey:NO value:&value]); + XCTAssertTrue([dict getBool:NULL forKey:NO]); + XCTAssertTrue([dict getBool:&value forKey:NO]); XCTAssertEqual(value, YES); - [dict setValue:YES forKey:YES]; + [dict setBool:YES forKey:YES]; XCTAssertEqual(dict.count, 2U); - XCTAssertTrue([dict valueForKey:YES value:NULL]); - XCTAssertTrue([dict valueForKey:YES value:&value]); + XCTAssertTrue([dict getBool:NULL forKey:YES]); + XCTAssertTrue([dict getBool:&value forKey:YES]); XCTAssertEqual(value, YES); - XCTAssertTrue([dict valueForKey:NO value:NULL]); - XCTAssertTrue([dict valueForKey:NO value:&value]); + XCTAssertTrue([dict getBool:NULL forKey:NO]); + XCTAssertTrue([dict getBool:&value forKey:NO]); XCTAssertEqual(value, YES); - [dict setValue:NO forKey:NO]; + [dict setBool:NO forKey:NO]; XCTAssertEqual(dict.count, 2U); - XCTAssertTrue([dict valueForKey:YES value:NULL]); - XCTAssertTrue([dict valueForKey:YES value:&value]); + XCTAssertTrue([dict getBool:NULL forKey:YES]); + XCTAssertTrue([dict getBool:&value forKey:YES]); XCTAssertEqual(value, YES); - XCTAssertTrue([dict valueForKey:NO value:NULL]); - XCTAssertTrue([dict valueForKey:NO value:&value]); + XCTAssertTrue([dict getBool:NULL forKey:NO]); + XCTAssertTrue([dict getBool:&value forKey:NO]); XCTAssertEqual(value, NO); const BOOL kKeys2[] = { NO, YES }; const BOOL kValues2[] = { YES, NO }; GPBBoolBoolDictionary *dict2 = - [[GPBBoolBoolDictionary alloc] initWithValues:kValues2 - forKeys:kKeys2 - count:GPBARRAYSIZE(kValues2)]; + [[GPBBoolBoolDictionary alloc] initWithBools:kValues2 + forKeys:kKeys2 + count:GPBARRAYSIZE(kValues2)]; XCTAssertNotNil(dict2); [dict addEntriesFromDictionary:dict2]; XCTAssertEqual(dict.count, 2U); - XCTAssertTrue([dict valueForKey:YES value:NULL]); - XCTAssertTrue([dict valueForKey:YES value:&value]); + XCTAssertTrue([dict getBool:NULL forKey:YES]); + XCTAssertTrue([dict getBool:&value forKey:YES]); XCTAssertEqual(value, NO); - XCTAssertTrue([dict valueForKey:NO value:NULL]); - XCTAssertTrue([dict valueForKey:NO value:&value]); + XCTAssertTrue([dict getBool:NULL forKey:NO]); + XCTAssertTrue([dict getBool:&value forKey:NO]); XCTAssertEqual(value, YES); [dict2 release]; @@ -1559,8 +1559,8 @@ GPBBoolFloatDictionary *dict = [[GPBBoolFloatDictionary alloc] init]; XCTAssertNotNil(dict); XCTAssertEqual(dict.count, 0U); - XCTAssertFalse([dict valueForKey:YES value:NULL]); - [dict enumerateKeysAndValuesUsingBlock:^(BOOL aKey, float aValue, BOOL *stop) { + XCTAssertFalse([dict getFloat:NULL forKey:YES]); + [dict enumerateKeysAndFloatsUsingBlock:^(BOOL aKey, float aValue, BOOL *stop) { #pragma unused(aKey, aValue, stop) XCTFail(@"Shouldn't get here!"); }]; @@ -1568,15 +1568,15 @@ } - (void)testOne { - GPBBoolFloatDictionary *dict = [GPBBoolFloatDictionary dictionaryWithValue:500.f forKey:YES]; + GPBBoolFloatDictionary *dict = [GPBBoolFloatDictionary dictionaryWithFloat:500.f forKey:YES]; XCTAssertNotNil(dict); XCTAssertEqual(dict.count, 1U); float value; - XCTAssertTrue([dict valueForKey:YES value:NULL]); - XCTAssertTrue([dict valueForKey:YES value:&value]); + XCTAssertTrue([dict getFloat:NULL forKey:YES]); + XCTAssertTrue([dict getFloat:&value forKey:YES]); XCTAssertEqual(value, 500.f); - XCTAssertFalse([dict valueForKey:NO value:NULL]); - [dict enumerateKeysAndValuesUsingBlock:^(BOOL aKey, float aValue, BOOL *stop) { + XCTAssertFalse([dict getFloat:NULL forKey:NO]); + [dict enumerateKeysAndFloatsUsingBlock:^(BOOL aKey, float aValue, BOOL *stop) { XCTAssertEqual(aKey, YES); XCTAssertEqual(aValue, 500.f); XCTAssertNotEqual(stop, NULL); @@ -1587,23 +1587,23 @@ const BOOL kKeys[] = { YES, NO }; const float kValues[] = { 500.f, 501.f }; GPBBoolFloatDictionary *dict = - [[GPBBoolFloatDictionary alloc] initWithValues:kValues + [[GPBBoolFloatDictionary alloc] initWithFloats:kValues forKeys:kKeys count:GPBARRAYSIZE(kValues)]; XCTAssertNotNil(dict); XCTAssertEqual(dict.count, 2U); float value; - XCTAssertTrue([dict valueForKey:YES value:NULL]); - XCTAssertTrue([dict valueForKey:YES value:&value]); + XCTAssertTrue([dict getFloat:NULL forKey:YES]); + XCTAssertTrue([dict getFloat:&value forKey:YES]); XCTAssertEqual(value, 500.f); - XCTAssertTrue([dict valueForKey:NO value:NULL]); - XCTAssertTrue([dict valueForKey:NO value:&value]); + XCTAssertTrue([dict getFloat:NULL forKey:NO]); + XCTAssertTrue([dict getFloat:&value forKey:NO]); XCTAssertEqual(value, 501.f); __block NSUInteger idx = 0; BOOL *seenKeys = malloc(2 * sizeof(BOOL)); float *seenValues = malloc(2 * sizeof(float)); - [dict enumerateKeysAndValuesUsingBlock:^(BOOL aKey, float aValue, BOOL *stop) { + [dict enumerateKeysAndFloatsUsingBlock:^(BOOL aKey, float aValue, BOOL *stop) { XCTAssertLessThan(idx, 2U); seenKeys[idx] = aKey; seenValues[idx] = aValue; @@ -1625,7 +1625,7 @@ // Stopping the enumeration. idx = 0; - [dict enumerateKeysAndValuesUsingBlock:^(BOOL aKey, float aValue, BOOL *stop) { + [dict enumerateKeysAndFloatsUsingBlock:^(BOOL aKey, float aValue, BOOL *stop) { #pragma unused(aKey, aValue) if (idx == 0) *stop = YES; XCTAssertNotEqual(idx, 2U); @@ -1641,27 +1641,27 @@ const float kValues2[] = { 501.f, 500.f }; const float kValues3[] = { 501.f }; GPBBoolFloatDictionary *dict1 = - [[GPBBoolFloatDictionary alloc] initWithValues:kValues1 + [[GPBBoolFloatDictionary alloc] initWithFloats:kValues1 forKeys:kKeys1 count:GPBARRAYSIZE(kValues1)]; XCTAssertNotNil(dict1); GPBBoolFloatDictionary *dict1prime = - [[GPBBoolFloatDictionary alloc] initWithValues:kValues1 + [[GPBBoolFloatDictionary alloc] initWithFloats:kValues1 forKeys:kKeys1 count:GPBARRAYSIZE(kValues1)]; XCTAssertNotNil(dict1prime); GPBBoolFloatDictionary *dict2 = - [[GPBBoolFloatDictionary alloc] initWithValues:kValues2 + [[GPBBoolFloatDictionary alloc] initWithFloats:kValues2 forKeys:kKeys1 count:GPBARRAYSIZE(kValues2)]; XCTAssertNotNil(dict2); GPBBoolFloatDictionary *dict3 = - [[GPBBoolFloatDictionary alloc] initWithValues:kValues1 + [[GPBBoolFloatDictionary alloc] initWithFloats:kValues1 forKeys:kKeys2 count:GPBARRAYSIZE(kValues1)]; XCTAssertNotNil(dict3); GPBBoolFloatDictionary *dict4 = - [[GPBBoolFloatDictionary alloc] initWithValues:kValues3 + [[GPBBoolFloatDictionary alloc] initWithFloats:kValues3 forKeys:kKeys1 count:GPBARRAYSIZE(kValues3)]; XCTAssertNotNil(dict4); @@ -1692,7 +1692,7 @@ const BOOL kKeys[] = { YES, NO }; const float kValues[] = { 500.f, 501.f }; GPBBoolFloatDictionary *dict = - [[GPBBoolFloatDictionary alloc] initWithValues:kValues + [[GPBBoolFloatDictionary alloc] initWithFloats:kValues forKeys:kKeys count:GPBARRAYSIZE(kValues)]; XCTAssertNotNil(dict); @@ -1713,7 +1713,7 @@ const BOOL kKeys[] = { YES, NO }; const float kValues[] = { 500.f, 501.f }; GPBBoolFloatDictionary *dict = - [[GPBBoolFloatDictionary alloc] initWithValues:kValues + [[GPBBoolFloatDictionary alloc] initWithFloats:kValues forKeys:kKeys count:GPBARRAYSIZE(kValues)]; XCTAssertNotNil(dict); @@ -1733,13 +1733,13 @@ XCTAssertNotNil(dict); XCTAssertEqual(dict.count, 0U); - [dict setValue:500.f forKey:YES]; + [dict setFloat:500.f forKey:YES]; XCTAssertEqual(dict.count, 1U); const BOOL kKeys[] = { NO }; const float kValues[] = { 501.f }; GPBBoolFloatDictionary *dict2 = - [[GPBBoolFloatDictionary alloc] initWithValues:kValues + [[GPBBoolFloatDictionary alloc] initWithFloats:kValues forKeys:kKeys count:GPBARRAYSIZE(kValues)]; XCTAssertNotNil(dict2); @@ -1747,11 +1747,11 @@ XCTAssertEqual(dict.count, 2U); float value; - XCTAssertTrue([dict valueForKey:YES value:NULL]); - XCTAssertTrue([dict valueForKey:YES value:&value]); + XCTAssertTrue([dict getFloat:NULL forKey:YES]); + XCTAssertTrue([dict getFloat:&value forKey:YES]); XCTAssertEqual(value, 500.f); - XCTAssertTrue([dict valueForKey:NO value:NULL]); - XCTAssertTrue([dict valueForKey:NO value:&value]); + XCTAssertTrue([dict getFloat:NULL forKey:NO]); + XCTAssertTrue([dict getFloat:&value forKey:NO]); XCTAssertEqual(value, 501.f); [dict2 release]; } @@ -1760,32 +1760,32 @@ const BOOL kKeys[] = { YES, NO}; const float kValues[] = { 500.f, 501.f }; GPBBoolFloatDictionary *dict = - [[GPBBoolFloatDictionary alloc] initWithValues:kValues + [[GPBBoolFloatDictionary alloc] initWithFloats:kValues forKeys:kKeys count:GPBARRAYSIZE(kValues)]; XCTAssertNotNil(dict); XCTAssertEqual(dict.count, 2U); - [dict removeValueForKey:NO]; + [dict removeFloatForKey:NO]; XCTAssertEqual(dict.count, 1U); float value; - XCTAssertTrue([dict valueForKey:YES value:NULL]); - XCTAssertTrue([dict valueForKey:YES value:&value]); + XCTAssertTrue([dict getFloat:NULL forKey:YES]); + XCTAssertTrue([dict getFloat:&value forKey:YES]); XCTAssertEqual(value, 500.f); - XCTAssertFalse([dict valueForKey:NO value:NULL]); + XCTAssertFalse([dict getFloat:NULL forKey:NO]); // Remove again does nothing. - [dict removeValueForKey:NO]; + [dict removeFloatForKey:NO]; XCTAssertEqual(dict.count, 1U); - XCTAssertTrue([dict valueForKey:YES value:NULL]); - XCTAssertTrue([dict valueForKey:YES value:&value]); + XCTAssertTrue([dict getFloat:NULL forKey:YES]); + XCTAssertTrue([dict getFloat:&value forKey:YES]); XCTAssertEqual(value, 500.f); - XCTAssertFalse([dict valueForKey:NO value:NULL]); + XCTAssertFalse([dict getFloat:NULL forKey:NO]); [dict removeAll]; XCTAssertEqual(dict.count, 0U); - XCTAssertFalse([dict valueForKey:YES value:NULL]); - XCTAssertFalse([dict valueForKey:NO value:NULL]); + XCTAssertFalse([dict getFloat:NULL forKey:YES]); + XCTAssertFalse([dict getFloat:NULL forKey:NO]); [dict release]; } @@ -1793,51 +1793,51 @@ const BOOL kKeys[] = { YES, NO }; const float kValues[] = { 500.f, 501.f }; GPBBoolFloatDictionary *dict = - [[GPBBoolFloatDictionary alloc] initWithValues:kValues - forKeys:kKeys - count:GPBARRAYSIZE(kValues)]; + [[GPBBoolFloatDictionary alloc] initWithFloats:kValues + forKeys:kKeys + count:GPBARRAYSIZE(kValues)]; XCTAssertNotNil(dict); XCTAssertEqual(dict.count, 2U); float value; - XCTAssertTrue([dict valueForKey:YES value:NULL]); - XCTAssertTrue([dict valueForKey:YES value:&value]); + XCTAssertTrue([dict getFloat:NULL forKey:YES]); + XCTAssertTrue([dict getFloat:&value forKey:YES]); XCTAssertEqual(value, 500.f); - XCTAssertTrue([dict valueForKey:NO value:NULL]); - XCTAssertTrue([dict valueForKey:NO value:&value]); + XCTAssertTrue([dict getFloat:NULL forKey:NO]); + XCTAssertTrue([dict getFloat:&value forKey:NO]); XCTAssertEqual(value, 501.f); - [dict setValue:501.f forKey:YES]; + [dict setFloat:501.f forKey:YES]; XCTAssertEqual(dict.count, 2U); - XCTAssertTrue([dict valueForKey:YES value:NULL]); - XCTAssertTrue([dict valueForKey:YES value:&value]); + XCTAssertTrue([dict getFloat:NULL forKey:YES]); + XCTAssertTrue([dict getFloat:&value forKey:YES]); XCTAssertEqual(value, 501.f); - XCTAssertTrue([dict valueForKey:NO value:NULL]); - XCTAssertTrue([dict valueForKey:NO value:&value]); + XCTAssertTrue([dict getFloat:NULL forKey:NO]); + XCTAssertTrue([dict getFloat:&value forKey:NO]); XCTAssertEqual(value, 501.f); - [dict setValue:500.f forKey:NO]; + [dict setFloat:500.f forKey:NO]; XCTAssertEqual(dict.count, 2U); - XCTAssertTrue([dict valueForKey:YES value:NULL]); - XCTAssertTrue([dict valueForKey:YES value:&value]); + XCTAssertTrue([dict getFloat:NULL forKey:YES]); + XCTAssertTrue([dict getFloat:&value forKey:YES]); XCTAssertEqual(value, 501.f); - XCTAssertTrue([dict valueForKey:NO value:NULL]); - XCTAssertTrue([dict valueForKey:NO value:&value]); + XCTAssertTrue([dict getFloat:NULL forKey:NO]); + XCTAssertTrue([dict getFloat:&value forKey:NO]); XCTAssertEqual(value, 500.f); const BOOL kKeys2[] = { NO, YES }; const float kValues2[] = { 501.f, 500.f }; GPBBoolFloatDictionary *dict2 = - [[GPBBoolFloatDictionary alloc] initWithValues:kValues2 + [[GPBBoolFloatDictionary alloc] initWithFloats:kValues2 forKeys:kKeys2 count:GPBARRAYSIZE(kValues2)]; XCTAssertNotNil(dict2); [dict addEntriesFromDictionary:dict2]; XCTAssertEqual(dict.count, 2U); - XCTAssertTrue([dict valueForKey:YES value:NULL]); - XCTAssertTrue([dict valueForKey:YES value:&value]); + XCTAssertTrue([dict getFloat:NULL forKey:YES]); + XCTAssertTrue([dict getFloat:&value forKey:YES]); XCTAssertEqual(value, 500.f); - XCTAssertTrue([dict valueForKey:NO value:NULL]); - XCTAssertTrue([dict valueForKey:NO value:&value]); + XCTAssertTrue([dict getFloat:NULL forKey:NO]); + XCTAssertTrue([dict getFloat:&value forKey:NO]); XCTAssertEqual(value, 501.f); [dict2 release]; @@ -1860,8 +1860,8 @@ GPBBoolDoubleDictionary *dict = [[GPBBoolDoubleDictionary alloc] init]; XCTAssertNotNil(dict); XCTAssertEqual(dict.count, 0U); - XCTAssertFalse([dict valueForKey:YES value:NULL]); - [dict enumerateKeysAndValuesUsingBlock:^(BOOL aKey, double aValue, BOOL *stop) { + XCTAssertFalse([dict getDouble:NULL forKey:YES]); + [dict enumerateKeysAndDoublesUsingBlock:^(BOOL aKey, double aValue, BOOL *stop) { #pragma unused(aKey, aValue, stop) XCTFail(@"Shouldn't get here!"); }]; @@ -1869,15 +1869,15 @@ } - (void)testOne { - GPBBoolDoubleDictionary *dict = [GPBBoolDoubleDictionary dictionaryWithValue:600. forKey:YES]; + GPBBoolDoubleDictionary *dict = [GPBBoolDoubleDictionary dictionaryWithDouble:600. forKey:YES]; XCTAssertNotNil(dict); XCTAssertEqual(dict.count, 1U); double value; - XCTAssertTrue([dict valueForKey:YES value:NULL]); - XCTAssertTrue([dict valueForKey:YES value:&value]); + XCTAssertTrue([dict getDouble:NULL forKey:YES]); + XCTAssertTrue([dict getDouble:&value forKey:YES]); XCTAssertEqual(value, 600.); - XCTAssertFalse([dict valueForKey:NO value:NULL]); - [dict enumerateKeysAndValuesUsingBlock:^(BOOL aKey, double aValue, BOOL *stop) { + XCTAssertFalse([dict getDouble:NULL forKey:NO]); + [dict enumerateKeysAndDoublesUsingBlock:^(BOOL aKey, double aValue, BOOL *stop) { XCTAssertEqual(aKey, YES); XCTAssertEqual(aValue, 600.); XCTAssertNotEqual(stop, NULL); @@ -1888,23 +1888,23 @@ const BOOL kKeys[] = { YES, NO }; const double kValues[] = { 600., 601. }; GPBBoolDoubleDictionary *dict = - [[GPBBoolDoubleDictionary alloc] initWithValues:kValues - forKeys:kKeys - count:GPBARRAYSIZE(kValues)]; + [[GPBBoolDoubleDictionary alloc] initWithDoubles:kValues + forKeys:kKeys + count:GPBARRAYSIZE(kValues)]; XCTAssertNotNil(dict); XCTAssertEqual(dict.count, 2U); double value; - XCTAssertTrue([dict valueForKey:YES value:NULL]); - XCTAssertTrue([dict valueForKey:YES value:&value]); + XCTAssertTrue([dict getDouble:NULL forKey:YES]); + XCTAssertTrue([dict getDouble:&value forKey:YES]); XCTAssertEqual(value, 600.); - XCTAssertTrue([dict valueForKey:NO value:NULL]); - XCTAssertTrue([dict valueForKey:NO value:&value]); + XCTAssertTrue([dict getDouble:NULL forKey:NO]); + XCTAssertTrue([dict getDouble:&value forKey:NO]); XCTAssertEqual(value, 601.); __block NSUInteger idx = 0; BOOL *seenKeys = malloc(2 * sizeof(BOOL)); double *seenValues = malloc(2 * sizeof(double)); - [dict enumerateKeysAndValuesUsingBlock:^(BOOL aKey, double aValue, BOOL *stop) { + [dict enumerateKeysAndDoublesUsingBlock:^(BOOL aKey, double aValue, BOOL *stop) { XCTAssertLessThan(idx, 2U); seenKeys[idx] = aKey; seenValues[idx] = aValue; @@ -1926,7 +1926,7 @@ // Stopping the enumeration. idx = 0; - [dict enumerateKeysAndValuesUsingBlock:^(BOOL aKey, double aValue, BOOL *stop) { + [dict enumerateKeysAndDoublesUsingBlock:^(BOOL aKey, double aValue, BOOL *stop) { #pragma unused(aKey, aValue) if (idx == 0) *stop = YES; XCTAssertNotEqual(idx, 2U); @@ -1942,29 +1942,29 @@ const double kValues2[] = { 601., 600. }; const double kValues3[] = { 601. }; GPBBoolDoubleDictionary *dict1 = - [[GPBBoolDoubleDictionary alloc] initWithValues:kValues1 - forKeys:kKeys1 - count:GPBARRAYSIZE(kValues1)]; + [[GPBBoolDoubleDictionary alloc] initWithDoubles:kValues1 + forKeys:kKeys1 + count:GPBARRAYSIZE(kValues1)]; XCTAssertNotNil(dict1); GPBBoolDoubleDictionary *dict1prime = - [[GPBBoolDoubleDictionary alloc] initWithValues:kValues1 - forKeys:kKeys1 - count:GPBARRAYSIZE(kValues1)]; + [[GPBBoolDoubleDictionary alloc] initWithDoubles:kValues1 + forKeys:kKeys1 + count:GPBARRAYSIZE(kValues1)]; XCTAssertNotNil(dict1prime); GPBBoolDoubleDictionary *dict2 = - [[GPBBoolDoubleDictionary alloc] initWithValues:kValues2 - forKeys:kKeys1 - count:GPBARRAYSIZE(kValues2)]; + [[GPBBoolDoubleDictionary alloc] initWithDoubles:kValues2 + forKeys:kKeys1 + count:GPBARRAYSIZE(kValues2)]; XCTAssertNotNil(dict2); GPBBoolDoubleDictionary *dict3 = - [[GPBBoolDoubleDictionary alloc] initWithValues:kValues1 - forKeys:kKeys2 - count:GPBARRAYSIZE(kValues1)]; + [[GPBBoolDoubleDictionary alloc] initWithDoubles:kValues1 + forKeys:kKeys2 + count:GPBARRAYSIZE(kValues1)]; XCTAssertNotNil(dict3); GPBBoolDoubleDictionary *dict4 = - [[GPBBoolDoubleDictionary alloc] initWithValues:kValues3 - forKeys:kKeys1 - count:GPBARRAYSIZE(kValues3)]; + [[GPBBoolDoubleDictionary alloc] initWithDoubles:kValues3 + forKeys:kKeys1 + count:GPBARRAYSIZE(kValues3)]; XCTAssertNotNil(dict4); // 1/1Prime should be different objects, but equal. @@ -1993,9 +1993,9 @@ const BOOL kKeys[] = { YES, NO }; const double kValues[] = { 600., 601. }; GPBBoolDoubleDictionary *dict = - [[GPBBoolDoubleDictionary alloc] initWithValues:kValues - forKeys:kKeys - count:GPBARRAYSIZE(kValues)]; + [[GPBBoolDoubleDictionary alloc] initWithDoubles:kValues + forKeys:kKeys + count:GPBARRAYSIZE(kValues)]; XCTAssertNotNil(dict); GPBBoolDoubleDictionary *dict2 = [dict copy]; @@ -2014,9 +2014,9 @@ const BOOL kKeys[] = { YES, NO }; const double kValues[] = { 600., 601. }; GPBBoolDoubleDictionary *dict = - [[GPBBoolDoubleDictionary alloc] initWithValues:kValues - forKeys:kKeys - count:GPBARRAYSIZE(kValues)]; + [[GPBBoolDoubleDictionary alloc] initWithDoubles:kValues + forKeys:kKeys + count:GPBARRAYSIZE(kValues)]; XCTAssertNotNil(dict); GPBBoolDoubleDictionary *dict2 = @@ -2034,25 +2034,25 @@ XCTAssertNotNil(dict); XCTAssertEqual(dict.count, 0U); - [dict setValue:600. forKey:YES]; + [dict setDouble:600. forKey:YES]; XCTAssertEqual(dict.count, 1U); const BOOL kKeys[] = { NO }; const double kValues[] = { 601. }; GPBBoolDoubleDictionary *dict2 = - [[GPBBoolDoubleDictionary alloc] initWithValues:kValues - forKeys:kKeys - count:GPBARRAYSIZE(kValues)]; + [[GPBBoolDoubleDictionary alloc] initWithDoubles:kValues + forKeys:kKeys + count:GPBARRAYSIZE(kValues)]; XCTAssertNotNil(dict2); [dict addEntriesFromDictionary:dict2]; XCTAssertEqual(dict.count, 2U); double value; - XCTAssertTrue([dict valueForKey:YES value:NULL]); - XCTAssertTrue([dict valueForKey:YES value:&value]); + XCTAssertTrue([dict getDouble:NULL forKey:YES]); + XCTAssertTrue([dict getDouble:&value forKey:YES]); XCTAssertEqual(value, 600.); - XCTAssertTrue([dict valueForKey:NO value:NULL]); - XCTAssertTrue([dict valueForKey:NO value:&value]); + XCTAssertTrue([dict getDouble:NULL forKey:NO]); + XCTAssertTrue([dict getDouble:&value forKey:NO]); XCTAssertEqual(value, 601.); [dict2 release]; } @@ -2061,32 +2061,32 @@ const BOOL kKeys[] = { YES, NO}; const double kValues[] = { 600., 601. }; GPBBoolDoubleDictionary *dict = - [[GPBBoolDoubleDictionary alloc] initWithValues:kValues - forKeys:kKeys - count:GPBARRAYSIZE(kValues)]; + [[GPBBoolDoubleDictionary alloc] initWithDoubles:kValues + forKeys:kKeys + count:GPBARRAYSIZE(kValues)]; XCTAssertNotNil(dict); XCTAssertEqual(dict.count, 2U); - [dict removeValueForKey:NO]; + [dict removeDoubleForKey:NO]; XCTAssertEqual(dict.count, 1U); double value; - XCTAssertTrue([dict valueForKey:YES value:NULL]); - XCTAssertTrue([dict valueForKey:YES value:&value]); + XCTAssertTrue([dict getDouble:NULL forKey:YES]); + XCTAssertTrue([dict getDouble:&value forKey:YES]); XCTAssertEqual(value, 600.); - XCTAssertFalse([dict valueForKey:NO value:NULL]); + XCTAssertFalse([dict getDouble:NULL forKey:NO]); // Remove again does nothing. - [dict removeValueForKey:NO]; + [dict removeDoubleForKey:NO]; XCTAssertEqual(dict.count, 1U); - XCTAssertTrue([dict valueForKey:YES value:NULL]); - XCTAssertTrue([dict valueForKey:YES value:&value]); + XCTAssertTrue([dict getDouble:NULL forKey:YES]); + XCTAssertTrue([dict getDouble:&value forKey:YES]); XCTAssertEqual(value, 600.); - XCTAssertFalse([dict valueForKey:NO value:NULL]); + XCTAssertFalse([dict getDouble:NULL forKey:NO]); [dict removeAll]; XCTAssertEqual(dict.count, 0U); - XCTAssertFalse([dict valueForKey:YES value:NULL]); - XCTAssertFalse([dict valueForKey:NO value:NULL]); + XCTAssertFalse([dict getDouble:NULL forKey:YES]); + XCTAssertFalse([dict getDouble:NULL forKey:NO]); [dict release]; } @@ -2094,51 +2094,51 @@ const BOOL kKeys[] = { YES, NO }; const double kValues[] = { 600., 601. }; GPBBoolDoubleDictionary *dict = - [[GPBBoolDoubleDictionary alloc] initWithValues:kValues - forKeys:kKeys - count:GPBARRAYSIZE(kValues)]; + [[GPBBoolDoubleDictionary alloc] initWithDoubles:kValues + forKeys:kKeys + count:GPBARRAYSIZE(kValues)]; XCTAssertNotNil(dict); XCTAssertEqual(dict.count, 2U); double value; - XCTAssertTrue([dict valueForKey:YES value:NULL]); - XCTAssertTrue([dict valueForKey:YES value:&value]); + XCTAssertTrue([dict getDouble:NULL forKey:YES]); + XCTAssertTrue([dict getDouble:&value forKey:YES]); XCTAssertEqual(value, 600.); - XCTAssertTrue([dict valueForKey:NO value:NULL]); - XCTAssertTrue([dict valueForKey:NO value:&value]); + XCTAssertTrue([dict getDouble:NULL forKey:NO]); + XCTAssertTrue([dict getDouble:&value forKey:NO]); XCTAssertEqual(value, 601.); - [dict setValue:601. forKey:YES]; + [dict setDouble:601. forKey:YES]; XCTAssertEqual(dict.count, 2U); - XCTAssertTrue([dict valueForKey:YES value:NULL]); - XCTAssertTrue([dict valueForKey:YES value:&value]); + XCTAssertTrue([dict getDouble:NULL forKey:YES]); + XCTAssertTrue([dict getDouble:&value forKey:YES]); XCTAssertEqual(value, 601.); - XCTAssertTrue([dict valueForKey:NO value:NULL]); - XCTAssertTrue([dict valueForKey:NO value:&value]); + XCTAssertTrue([dict getDouble:NULL forKey:NO]); + XCTAssertTrue([dict getDouble:&value forKey:NO]); XCTAssertEqual(value, 601.); - [dict setValue:600. forKey:NO]; + [dict setDouble:600. forKey:NO]; XCTAssertEqual(dict.count, 2U); - XCTAssertTrue([dict valueForKey:YES value:NULL]); - XCTAssertTrue([dict valueForKey:YES value:&value]); + XCTAssertTrue([dict getDouble:NULL forKey:YES]); + XCTAssertTrue([dict getDouble:&value forKey:YES]); XCTAssertEqual(value, 601.); - XCTAssertTrue([dict valueForKey:NO value:NULL]); - XCTAssertTrue([dict valueForKey:NO value:&value]); + XCTAssertTrue([dict getDouble:NULL forKey:NO]); + XCTAssertTrue([dict getDouble:&value forKey:NO]); XCTAssertEqual(value, 600.); const BOOL kKeys2[] = { NO, YES }; const double kValues2[] = { 601., 600. }; GPBBoolDoubleDictionary *dict2 = - [[GPBBoolDoubleDictionary alloc] initWithValues:kValues2 - forKeys:kKeys2 - count:GPBARRAYSIZE(kValues2)]; + [[GPBBoolDoubleDictionary alloc] initWithDoubles:kValues2 + forKeys:kKeys2 + count:GPBARRAYSIZE(kValues2)]; XCTAssertNotNil(dict2); [dict addEntriesFromDictionary:dict2]; XCTAssertEqual(dict.count, 2U); - XCTAssertTrue([dict valueForKey:YES value:NULL]); - XCTAssertTrue([dict valueForKey:YES value:&value]); + XCTAssertTrue([dict getDouble:NULL forKey:YES]); + XCTAssertTrue([dict getDouble:&value forKey:YES]); XCTAssertEqual(value, 600.); - XCTAssertTrue([dict valueForKey:NO value:NULL]); - XCTAssertTrue([dict valueForKey:NO value:&value]); + XCTAssertTrue([dict getDouble:NULL forKey:NO]); + XCTAssertTrue([dict getDouble:&value forKey:NO]); XCTAssertEqual(value, 601.); [dict2 release]; @@ -2378,8 +2378,8 @@ const NSString* kObjects[] = { @"abc", @"def" }; GPBBoolObjectDictionary *dict = [[GPBBoolObjectDictionary alloc] initWithObjects:kObjects - forKeys:kKeys - count:GPBARRAYSIZE(kObjects)]; + forKeys:kKeys + count:GPBARRAYSIZE(kObjects)]; XCTAssertNotNil(dict); XCTAssertEqual(dict.count, 2U); XCTAssertEqualObjects([dict objectForKey:YES], @"abc"); diff --git a/objectivec/Tests/GPBDictionaryTests+Int32.m b/objectivec/Tests/GPBDictionaryTests+Int32.m index 54dd2ed7..c539bdc2 100644 --- a/objectivec/Tests/GPBDictionaryTests+Int32.m +++ b/objectivec/Tests/GPBDictionaryTests+Int32.m @@ -45,10 +45,10 @@ // To let the testing macros work, add some extra methods to simplify things. @interface GPBInt32EnumDictionary (TestingTweak) -+ (instancetype)dictionaryWithValue:(int32_t)value forKey:(int32_t)key; -- (instancetype)initWithValues:(const int32_t [])values - forKeys:(const int32_t [])keys - count:(NSUInteger)count; ++ (instancetype)dictionaryWithEnum:(int32_t)value forKey:(int32_t)key; +- (instancetype)initWithEnums:(const int32_t [])values + forKeys:(const int32_t [])keys + count:(NSUInteger)count; @end static BOOL TestingEnum_IsValidValue(int32_t value) { @@ -64,7 +64,7 @@ static BOOL TestingEnum_IsValidValue(int32_t value) { } @implementation GPBInt32EnumDictionary (TestingTweak) -+ (instancetype)dictionaryWithValue:(int32_t)value forKey:(int32_t)key { ++ (instancetype)dictionaryWithEnum:(int32_t)value forKey:(int32_t)key { // Cast is needed to compiler knows what class we are invoking initWithValues: on to get the // type correct. return [[(GPBInt32EnumDictionary*)[self alloc] initWithValidationFunction:TestingEnum_IsValidValue @@ -72,9 +72,9 @@ static BOOL TestingEnum_IsValidValue(int32_t value) { forKeys:&key count:1] autorelease]; } -- (instancetype)initWithValues:(const int32_t [])values - forKeys:(const int32_t [])keys - count:(NSUInteger)count { +- (instancetype)initWithEnums:(const int32_t [])values + forKeys:(const int32_t [])keys + count:(NSUInteger)count { return [self initWithValidationFunction:TestingEnum_IsValidValue rawValues:values forKeys:keys @@ -94,8 +94,8 @@ static BOOL TestingEnum_IsValidValue(int32_t value) { GPBInt32UInt32Dictionary *dict = [[GPBInt32UInt32Dictionary alloc] init]; XCTAssertNotNil(dict); XCTAssertEqual(dict.count, 0U); - XCTAssertFalse([dict valueForKey:11 value:NULL]); - [dict enumerateKeysAndValuesUsingBlock:^(int32_t aKey, uint32_t aValue, BOOL *stop) { + XCTAssertFalse([dict getUInt32:NULL forKey:11]); + [dict enumerateKeysAndUInt32sUsingBlock:^(int32_t aKey, uint32_t aValue, BOOL *stop) { #pragma unused(aKey, aValue, stop) XCTFail(@"Shouldn't get here!"); }]; @@ -103,15 +103,15 @@ static BOOL TestingEnum_IsValidValue(int32_t value) { } - (void)testOne { - GPBInt32UInt32Dictionary *dict = [GPBInt32UInt32Dictionary dictionaryWithValue:100U forKey:11]; + GPBInt32UInt32Dictionary *dict = [GPBInt32UInt32Dictionary dictionaryWithUInt32:100U forKey:11]; XCTAssertNotNil(dict); XCTAssertEqual(dict.count, 1U); uint32_t value; - XCTAssertTrue([dict valueForKey:11 value:NULL]); - XCTAssertTrue([dict valueForKey:11 value:&value]); + XCTAssertTrue([dict getUInt32:NULL forKey:11]); + XCTAssertTrue([dict getUInt32:&value forKey:11]); XCTAssertEqual(value, 100U); - XCTAssertFalse([dict valueForKey:12 value:NULL]); - [dict enumerateKeysAndValuesUsingBlock:^(int32_t aKey, uint32_t aValue, BOOL *stop) { + XCTAssertFalse([dict getUInt32:NULL forKey:12]); + [dict enumerateKeysAndUInt32sUsingBlock:^(int32_t aKey, uint32_t aValue, BOOL *stop) { XCTAssertEqual(aKey, 11); XCTAssertEqual(aValue, 100U); XCTAssertNotEqual(stop, NULL); @@ -122,27 +122,27 @@ static BOOL TestingEnum_IsValidValue(int32_t value) { const int32_t kKeys[] = { 11, 12, 13 }; const uint32_t kValues[] = { 100U, 101U, 102U }; GPBInt32UInt32Dictionary *dict = - [[GPBInt32UInt32Dictionary alloc] initWithValues:kValues - forKeys:kKeys - count:GPBARRAYSIZE(kValues)]; + [[GPBInt32UInt32Dictionary alloc] initWithUInt32s:kValues + forKeys:kKeys + count:GPBARRAYSIZE(kValues)]; XCTAssertNotNil(dict); XCTAssertEqual(dict.count, 3U); uint32_t value; - XCTAssertTrue([dict valueForKey:11 value:NULL]); - XCTAssertTrue([dict valueForKey:11 value:&value]); + XCTAssertTrue([dict getUInt32:NULL forKey:11]); + XCTAssertTrue([dict getUInt32:&value forKey:11]); XCTAssertEqual(value, 100U); - XCTAssertTrue([dict valueForKey:12 value:NULL]); - XCTAssertTrue([dict valueForKey:12 value:&value]); + XCTAssertTrue([dict getUInt32:NULL forKey:12]); + XCTAssertTrue([dict getUInt32:&value forKey:12]); XCTAssertEqual(value, 101U); - XCTAssertTrue([dict valueForKey:13 value:NULL]); - XCTAssertTrue([dict valueForKey:13 value:&value]); + XCTAssertTrue([dict getUInt32:NULL forKey:13]); + XCTAssertTrue([dict getUInt32:&value forKey:13]); XCTAssertEqual(value, 102U); - XCTAssertFalse([dict valueForKey:14 value:NULL]); + XCTAssertFalse([dict getUInt32:NULL forKey:14]); __block NSUInteger idx = 0; int32_t *seenKeys = malloc(3 * sizeof(int32_t)); uint32_t *seenValues = malloc(3 * sizeof(uint32_t)); - [dict enumerateKeysAndValuesUsingBlock:^(int32_t aKey, uint32_t aValue, BOOL *stop) { + [dict enumerateKeysAndUInt32sUsingBlock:^(int32_t aKey, uint32_t aValue, BOOL *stop) { XCTAssertLessThan(idx, 3U); seenKeys[idx] = aKey; seenValues[idx] = aValue; @@ -164,7 +164,7 @@ static BOOL TestingEnum_IsValidValue(int32_t value) { // Stopping the enumeration. idx = 0; - [dict enumerateKeysAndValuesUsingBlock:^(int32_t aKey, uint32_t aValue, BOOL *stop) { + [dict enumerateKeysAndUInt32sUsingBlock:^(int32_t aKey, uint32_t aValue, BOOL *stop) { #pragma unused(aKey, aValue) if (idx == 1) *stop = YES; XCTAssertNotEqual(idx, 2U); @@ -180,29 +180,29 @@ static BOOL TestingEnum_IsValidValue(int32_t value) { const uint32_t kValues2[] = { 100U, 103U, 102U }; const uint32_t kValues3[] = { 100U, 101U, 102U, 103U }; GPBInt32UInt32Dictionary *dict1 = - [[GPBInt32UInt32Dictionary alloc] initWithValues:kValues1 - forKeys:kKeys1 - count:GPBARRAYSIZE(kValues1)]; + [[GPBInt32UInt32Dictionary alloc] initWithUInt32s:kValues1 + forKeys:kKeys1 + count:GPBARRAYSIZE(kValues1)]; XCTAssertNotNil(dict1); GPBInt32UInt32Dictionary *dict1prime = - [[GPBInt32UInt32Dictionary alloc] initWithValues:kValues1 - forKeys:kKeys1 - count:GPBARRAYSIZE(kValues1)]; + [[GPBInt32UInt32Dictionary alloc] initWithUInt32s:kValues1 + forKeys:kKeys1 + count:GPBARRAYSIZE(kValues1)]; XCTAssertNotNil(dict1prime); GPBInt32UInt32Dictionary *dict2 = - [[GPBInt32UInt32Dictionary alloc] initWithValues:kValues2 - forKeys:kKeys1 - count:GPBARRAYSIZE(kValues2)]; + [[GPBInt32UInt32Dictionary alloc] initWithUInt32s:kValues2 + forKeys:kKeys1 + count:GPBARRAYSIZE(kValues2)]; XCTAssertNotNil(dict2); GPBInt32UInt32Dictionary *dict3 = - [[GPBInt32UInt32Dictionary alloc] initWithValues:kValues1 - forKeys:kKeys2 - count:GPBARRAYSIZE(kValues1)]; + [[GPBInt32UInt32Dictionary alloc] initWithUInt32s:kValues1 + forKeys:kKeys2 + count:GPBARRAYSIZE(kValues1)]; XCTAssertNotNil(dict3); GPBInt32UInt32Dictionary *dict4 = - [[GPBInt32UInt32Dictionary alloc] initWithValues:kValues3 - forKeys:kKeys1 - count:GPBARRAYSIZE(kValues3)]; + [[GPBInt32UInt32Dictionary alloc] initWithUInt32s:kValues3 + forKeys:kKeys1 + count:GPBARRAYSIZE(kValues3)]; XCTAssertNotNil(dict4); // 1/1Prime should be different objects, but equal. @@ -231,9 +231,9 @@ static BOOL TestingEnum_IsValidValue(int32_t value) { const int32_t kKeys[] = { 11, 12, 13, 14 }; const uint32_t kValues[] = { 100U, 101U, 102U, 103U }; GPBInt32UInt32Dictionary *dict = - [[GPBInt32UInt32Dictionary alloc] initWithValues:kValues - forKeys:kKeys - count:GPBARRAYSIZE(kValues)]; + [[GPBInt32UInt32Dictionary alloc] initWithUInt32s:kValues + forKeys:kKeys + count:GPBARRAYSIZE(kValues)]; XCTAssertNotNil(dict); GPBInt32UInt32Dictionary *dict2 = [dict copy]; @@ -252,9 +252,9 @@ static BOOL TestingEnum_IsValidValue(int32_t value) { const int32_t kKeys[] = { 11, 12, 13, 14 }; const uint32_t kValues[] = { 100U, 101U, 102U, 103U }; GPBInt32UInt32Dictionary *dict = - [[GPBInt32UInt32Dictionary alloc] initWithValues:kValues - forKeys:kKeys - count:GPBARRAYSIZE(kValues)]; + [[GPBInt32UInt32Dictionary alloc] initWithUInt32s:kValues + forKeys:kKeys + count:GPBARRAYSIZE(kValues)]; XCTAssertNotNil(dict); GPBInt32UInt32Dictionary *dict2 = @@ -272,31 +272,31 @@ static BOOL TestingEnum_IsValidValue(int32_t value) { XCTAssertNotNil(dict); XCTAssertEqual(dict.count, 0U); - [dict setValue:100U forKey:11]; + [dict setUInt32:100U forKey:11]; XCTAssertEqual(dict.count, 1U); const int32_t kKeys[] = { 12, 13, 14 }; const uint32_t kValues[] = { 101U, 102U, 103U }; GPBInt32UInt32Dictionary *dict2 = - [[GPBInt32UInt32Dictionary alloc] initWithValues:kValues - forKeys:kKeys - count:GPBARRAYSIZE(kValues)]; + [[GPBInt32UInt32Dictionary alloc] initWithUInt32s:kValues + forKeys:kKeys + count:GPBARRAYSIZE(kValues)]; XCTAssertNotNil(dict2); [dict addEntriesFromDictionary:dict2]; XCTAssertEqual(dict.count, 4U); uint32_t value; - XCTAssertTrue([dict valueForKey:11 value:NULL]); - XCTAssertTrue([dict valueForKey:11 value:&value]); + XCTAssertTrue([dict getUInt32:NULL forKey:11]); + XCTAssertTrue([dict getUInt32:&value forKey:11]); XCTAssertEqual(value, 100U); - XCTAssertTrue([dict valueForKey:12 value:NULL]); - XCTAssertTrue([dict valueForKey:12 value:&value]); + XCTAssertTrue([dict getUInt32:NULL forKey:12]); + XCTAssertTrue([dict getUInt32:&value forKey:12]); XCTAssertEqual(value, 101U); - XCTAssertTrue([dict valueForKey:13 value:NULL]); - XCTAssertTrue([dict valueForKey:13 value:&value]); + XCTAssertTrue([dict getUInt32:NULL forKey:13]); + XCTAssertTrue([dict getUInt32:&value forKey:13]); XCTAssertEqual(value, 102U); - XCTAssertTrue([dict valueForKey:14 value:NULL]); - XCTAssertTrue([dict valueForKey:14 value:&value]); + XCTAssertTrue([dict getUInt32:NULL forKey:14]); + XCTAssertTrue([dict getUInt32:&value forKey:14]); XCTAssertEqual(value, 103U); [dict2 release]; } @@ -305,57 +305,57 @@ static BOOL TestingEnum_IsValidValue(int32_t value) { const int32_t kKeys[] = { 11, 12, 13, 14 }; const uint32_t kValues[] = { 100U, 101U, 102U, 103U }; GPBInt32UInt32Dictionary *dict = - [[GPBInt32UInt32Dictionary alloc] initWithValues:kValues - forKeys:kKeys - count:GPBARRAYSIZE(kValues)]; + [[GPBInt32UInt32Dictionary alloc] initWithUInt32s:kValues + forKeys:kKeys + count:GPBARRAYSIZE(kValues)]; XCTAssertNotNil(dict); XCTAssertEqual(dict.count, 4U); - [dict removeValueForKey:12]; + [dict removeUInt32ForKey:12]; XCTAssertEqual(dict.count, 3U); uint32_t value; - XCTAssertTrue([dict valueForKey:11 value:NULL]); - XCTAssertTrue([dict valueForKey:11 value:&value]); + XCTAssertTrue([dict getUInt32:NULL forKey:11]); + XCTAssertTrue([dict getUInt32:&value forKey:11]); XCTAssertEqual(value, 100U); - XCTAssertFalse([dict valueForKey:12 value:NULL]); - XCTAssertTrue([dict valueForKey:13 value:NULL]); - XCTAssertTrue([dict valueForKey:13 value:&value]); + XCTAssertFalse([dict getUInt32:NULL forKey:12]); + XCTAssertTrue([dict getUInt32:NULL forKey:13]); + XCTAssertTrue([dict getUInt32:&value forKey:13]); XCTAssertEqual(value, 102U); - XCTAssertTrue([dict valueForKey:14 value:NULL]); - XCTAssertTrue([dict valueForKey:14 value:&value]); + XCTAssertTrue([dict getUInt32:NULL forKey:14]); + XCTAssertTrue([dict getUInt32:&value forKey:14]); XCTAssertEqual(value, 103U); // Remove again does nothing. - [dict removeValueForKey:12]; + [dict removeUInt32ForKey:12]; XCTAssertEqual(dict.count, 3U); - XCTAssertTrue([dict valueForKey:11 value:NULL]); - XCTAssertTrue([dict valueForKey:11 value:&value]); + XCTAssertTrue([dict getUInt32:NULL forKey:11]); + XCTAssertTrue([dict getUInt32:&value forKey:11]); XCTAssertEqual(value, 100U); - XCTAssertFalse([dict valueForKey:12 value:NULL]); - XCTAssertTrue([dict valueForKey:13 value:NULL]); - XCTAssertTrue([dict valueForKey:13 value:&value]); + XCTAssertFalse([dict getUInt32:NULL forKey:12]); + XCTAssertTrue([dict getUInt32:NULL forKey:13]); + XCTAssertTrue([dict getUInt32:&value forKey:13]); XCTAssertEqual(value, 102U); - XCTAssertTrue([dict valueForKey:14 value:NULL]); - XCTAssertTrue([dict valueForKey:14 value:&value]); + XCTAssertTrue([dict getUInt32:NULL forKey:14]); + XCTAssertTrue([dict getUInt32:&value forKey:14]); XCTAssertEqual(value, 103U); - [dict removeValueForKey:14]; + [dict removeUInt32ForKey:14]; XCTAssertEqual(dict.count, 2U); - XCTAssertTrue([dict valueForKey:11 value:NULL]); - XCTAssertTrue([dict valueForKey:11 value:&value]); + XCTAssertTrue([dict getUInt32:NULL forKey:11]); + XCTAssertTrue([dict getUInt32:&value forKey:11]); XCTAssertEqual(value, 100U); - XCTAssertFalse([dict valueForKey:12 value:NULL]); - XCTAssertTrue([dict valueForKey:13 value:NULL]); - XCTAssertTrue([dict valueForKey:13 value:&value]); + XCTAssertFalse([dict getUInt32:NULL forKey:12]); + XCTAssertTrue([dict getUInt32:NULL forKey:13]); + XCTAssertTrue([dict getUInt32:&value forKey:13]); XCTAssertEqual(value, 102U); - XCTAssertFalse([dict valueForKey:14 value:NULL]); + XCTAssertFalse([dict getUInt32:NULL forKey:14]); [dict removeAll]; XCTAssertEqual(dict.count, 0U); - XCTAssertFalse([dict valueForKey:11 value:NULL]); - XCTAssertFalse([dict valueForKey:12 value:NULL]); - XCTAssertFalse([dict valueForKey:13 value:NULL]); - XCTAssertFalse([dict valueForKey:14 value:NULL]); + XCTAssertFalse([dict getUInt32:NULL forKey:11]); + XCTAssertFalse([dict getUInt32:NULL forKey:12]); + XCTAssertFalse([dict getUInt32:NULL forKey:13]); + XCTAssertFalse([dict getUInt32:NULL forKey:14]); [dict release]; } @@ -363,75 +363,75 @@ static BOOL TestingEnum_IsValidValue(int32_t value) { const int32_t kKeys[] = { 11, 12, 13, 14 }; const uint32_t kValues[] = { 100U, 101U, 102U, 103U }; GPBInt32UInt32Dictionary *dict = - [[GPBInt32UInt32Dictionary alloc] initWithValues:kValues - forKeys:kKeys - count:GPBARRAYSIZE(kValues)]; + [[GPBInt32UInt32Dictionary alloc] initWithUInt32s:kValues + forKeys:kKeys + count:GPBARRAYSIZE(kValues)]; XCTAssertNotNil(dict); XCTAssertEqual(dict.count, 4U); uint32_t value; - XCTAssertTrue([dict valueForKey:11 value:NULL]); - XCTAssertTrue([dict valueForKey:11 value:&value]); + XCTAssertTrue([dict getUInt32:NULL forKey:11]); + XCTAssertTrue([dict getUInt32:&value forKey:11]); XCTAssertEqual(value, 100U); - XCTAssertTrue([dict valueForKey:12 value:NULL]); - XCTAssertTrue([dict valueForKey:12 value:&value]); + XCTAssertTrue([dict getUInt32:NULL forKey:12]); + XCTAssertTrue([dict getUInt32:&value forKey:12]); XCTAssertEqual(value, 101U); - XCTAssertTrue([dict valueForKey:13 value:NULL]); - XCTAssertTrue([dict valueForKey:13 value:&value]); + XCTAssertTrue([dict getUInt32:NULL forKey:13]); + XCTAssertTrue([dict getUInt32:&value forKey:13]); XCTAssertEqual(value, 102U); - XCTAssertTrue([dict valueForKey:14 value:NULL]); - XCTAssertTrue([dict valueForKey:14 value:&value]); + XCTAssertTrue([dict getUInt32:NULL forKey:14]); + XCTAssertTrue([dict getUInt32:&value forKey:14]); XCTAssertEqual(value, 103U); - [dict setValue:103U forKey:11]; + [dict setUInt32:103U forKey:11]; XCTAssertEqual(dict.count, 4U); - XCTAssertTrue([dict valueForKey:11 value:NULL]); - XCTAssertTrue([dict valueForKey:11 value:&value]); + XCTAssertTrue([dict getUInt32:NULL forKey:11]); + XCTAssertTrue([dict getUInt32:&value forKey:11]); XCTAssertEqual(value, 103U); - XCTAssertTrue([dict valueForKey:12 value:NULL]); - XCTAssertTrue([dict valueForKey:12 value:&value]); + XCTAssertTrue([dict getUInt32:NULL forKey:12]); + XCTAssertTrue([dict getUInt32:&value forKey:12]); XCTAssertEqual(value, 101U); - XCTAssertTrue([dict valueForKey:13 value:NULL]); - XCTAssertTrue([dict valueForKey:13 value:&value]); + XCTAssertTrue([dict getUInt32:NULL forKey:13]); + XCTAssertTrue([dict getUInt32:&value forKey:13]); XCTAssertEqual(value, 102U); - XCTAssertTrue([dict valueForKey:14 value:NULL]); - XCTAssertTrue([dict valueForKey:14 value:&value]); + XCTAssertTrue([dict getUInt32:NULL forKey:14]); + XCTAssertTrue([dict getUInt32:&value forKey:14]); XCTAssertEqual(value, 103U); - [dict setValue:101U forKey:14]; + [dict setUInt32:101U forKey:14]; XCTAssertEqual(dict.count, 4U); - XCTAssertTrue([dict valueForKey:11 value:NULL]); - XCTAssertTrue([dict valueForKey:11 value:&value]); + XCTAssertTrue([dict getUInt32:NULL forKey:11]); + XCTAssertTrue([dict getUInt32:&value forKey:11]); XCTAssertEqual(value, 103U); - XCTAssertTrue([dict valueForKey:12 value:NULL]); - XCTAssertTrue([dict valueForKey:12 value:&value]); + XCTAssertTrue([dict getUInt32:NULL forKey:12]); + XCTAssertTrue([dict getUInt32:&value forKey:12]); XCTAssertEqual(value, 101U); - XCTAssertTrue([dict valueForKey:13 value:NULL]); - XCTAssertTrue([dict valueForKey:13 value:&value]); + XCTAssertTrue([dict getUInt32:NULL forKey:13]); + XCTAssertTrue([dict getUInt32:&value forKey:13]); XCTAssertEqual(value, 102U); - XCTAssertTrue([dict valueForKey:14 value:NULL]); - XCTAssertTrue([dict valueForKey:14 value:&value]); + XCTAssertTrue([dict getUInt32:NULL forKey:14]); + XCTAssertTrue([dict getUInt32:&value forKey:14]); XCTAssertEqual(value, 101U); const int32_t kKeys2[] = { 12, 13 }; const uint32_t kValues2[] = { 102U, 100U }; GPBInt32UInt32Dictionary *dict2 = - [[GPBInt32UInt32Dictionary alloc] initWithValues:kValues2 - forKeys:kKeys2 - count:GPBARRAYSIZE(kValues2)]; + [[GPBInt32UInt32Dictionary alloc] initWithUInt32s:kValues2 + forKeys:kKeys2 + count:GPBARRAYSIZE(kValues2)]; XCTAssertNotNil(dict2); [dict addEntriesFromDictionary:dict2]; XCTAssertEqual(dict.count, 4U); - XCTAssertTrue([dict valueForKey:11 value:NULL]); - XCTAssertTrue([dict valueForKey:11 value:&value]); + XCTAssertTrue([dict getUInt32:NULL forKey:11]); + XCTAssertTrue([dict getUInt32:&value forKey:11]); XCTAssertEqual(value, 103U); - XCTAssertTrue([dict valueForKey:12 value:NULL]); - XCTAssertTrue([dict valueForKey:12 value:&value]); + XCTAssertTrue([dict getUInt32:NULL forKey:12]); + XCTAssertTrue([dict getUInt32:&value forKey:12]); XCTAssertEqual(value, 102U); - XCTAssertTrue([dict valueForKey:13 value:NULL]); - XCTAssertTrue([dict valueForKey:13 value:&value]); + XCTAssertTrue([dict getUInt32:NULL forKey:13]); + XCTAssertTrue([dict getUInt32:&value forKey:13]); XCTAssertEqual(value, 100U); - XCTAssertTrue([dict valueForKey:14 value:NULL]); - XCTAssertTrue([dict valueForKey:14 value:&value]); + XCTAssertTrue([dict getUInt32:NULL forKey:14]); + XCTAssertTrue([dict getUInt32:&value forKey:14]); XCTAssertEqual(value, 101U); [dict2 release]; @@ -451,8 +451,8 @@ static BOOL TestingEnum_IsValidValue(int32_t value) { GPBInt32Int32Dictionary *dict = [[GPBInt32Int32Dictionary alloc] init]; XCTAssertNotNil(dict); XCTAssertEqual(dict.count, 0U); - XCTAssertFalse([dict valueForKey:11 value:NULL]); - [dict enumerateKeysAndValuesUsingBlock:^(int32_t aKey, int32_t aValue, BOOL *stop) { + XCTAssertFalse([dict getInt32:NULL forKey:11]); + [dict enumerateKeysAndInt32sUsingBlock:^(int32_t aKey, int32_t aValue, BOOL *stop) { #pragma unused(aKey, aValue, stop) XCTFail(@"Shouldn't get here!"); }]; @@ -460,15 +460,15 @@ static BOOL TestingEnum_IsValidValue(int32_t value) { } - (void)testOne { - GPBInt32Int32Dictionary *dict = [GPBInt32Int32Dictionary dictionaryWithValue:200 forKey:11]; + GPBInt32Int32Dictionary *dict = [GPBInt32Int32Dictionary dictionaryWithInt32:200 forKey:11]; XCTAssertNotNil(dict); XCTAssertEqual(dict.count, 1U); int32_t value; - XCTAssertTrue([dict valueForKey:11 value:NULL]); - XCTAssertTrue([dict valueForKey:11 value:&value]); + XCTAssertTrue([dict getInt32:NULL forKey:11]); + XCTAssertTrue([dict getInt32:&value forKey:11]); XCTAssertEqual(value, 200); - XCTAssertFalse([dict valueForKey:12 value:NULL]); - [dict enumerateKeysAndValuesUsingBlock:^(int32_t aKey, int32_t aValue, BOOL *stop) { + XCTAssertFalse([dict getInt32:NULL forKey:12]); + [dict enumerateKeysAndInt32sUsingBlock:^(int32_t aKey, int32_t aValue, BOOL *stop) { XCTAssertEqual(aKey, 11); XCTAssertEqual(aValue, 200); XCTAssertNotEqual(stop, NULL); @@ -479,27 +479,27 @@ static BOOL TestingEnum_IsValidValue(int32_t value) { const int32_t kKeys[] = { 11, 12, 13 }; const int32_t kValues[] = { 200, 201, 202 }; GPBInt32Int32Dictionary *dict = - [[GPBInt32Int32Dictionary alloc] initWithValues:kValues + [[GPBInt32Int32Dictionary alloc] initWithInt32s:kValues forKeys:kKeys count:GPBARRAYSIZE(kValues)]; XCTAssertNotNil(dict); XCTAssertEqual(dict.count, 3U); int32_t value; - XCTAssertTrue([dict valueForKey:11 value:NULL]); - XCTAssertTrue([dict valueForKey:11 value:&value]); + XCTAssertTrue([dict getInt32:NULL forKey:11]); + XCTAssertTrue([dict getInt32:&value forKey:11]); XCTAssertEqual(value, 200); - XCTAssertTrue([dict valueForKey:12 value:NULL]); - XCTAssertTrue([dict valueForKey:12 value:&value]); + XCTAssertTrue([dict getInt32:NULL forKey:12]); + XCTAssertTrue([dict getInt32:&value forKey:12]); XCTAssertEqual(value, 201); - XCTAssertTrue([dict valueForKey:13 value:NULL]); - XCTAssertTrue([dict valueForKey:13 value:&value]); + XCTAssertTrue([dict getInt32:NULL forKey:13]); + XCTAssertTrue([dict getInt32:&value forKey:13]); XCTAssertEqual(value, 202); - XCTAssertFalse([dict valueForKey:14 value:NULL]); + XCTAssertFalse([dict getInt32:NULL forKey:14]); __block NSUInteger idx = 0; int32_t *seenKeys = malloc(3 * sizeof(int32_t)); int32_t *seenValues = malloc(3 * sizeof(int32_t)); - [dict enumerateKeysAndValuesUsingBlock:^(int32_t aKey, int32_t aValue, BOOL *stop) { + [dict enumerateKeysAndInt32sUsingBlock:^(int32_t aKey, int32_t aValue, BOOL *stop) { XCTAssertLessThan(idx, 3U); seenKeys[idx] = aKey; seenValues[idx] = aValue; @@ -521,7 +521,7 @@ static BOOL TestingEnum_IsValidValue(int32_t value) { // Stopping the enumeration. idx = 0; - [dict enumerateKeysAndValuesUsingBlock:^(int32_t aKey, int32_t aValue, BOOL *stop) { + [dict enumerateKeysAndInt32sUsingBlock:^(int32_t aKey, int32_t aValue, BOOL *stop) { #pragma unused(aKey, aValue) if (idx == 1) *stop = YES; XCTAssertNotEqual(idx, 2U); @@ -537,27 +537,27 @@ static BOOL TestingEnum_IsValidValue(int32_t value) { const int32_t kValues2[] = { 200, 203, 202 }; const int32_t kValues3[] = { 200, 201, 202, 203 }; GPBInt32Int32Dictionary *dict1 = - [[GPBInt32Int32Dictionary alloc] initWithValues:kValues1 + [[GPBInt32Int32Dictionary alloc] initWithInt32s:kValues1 forKeys:kKeys1 count:GPBARRAYSIZE(kValues1)]; XCTAssertNotNil(dict1); GPBInt32Int32Dictionary *dict1prime = - [[GPBInt32Int32Dictionary alloc] initWithValues:kValues1 + [[GPBInt32Int32Dictionary alloc] initWithInt32s:kValues1 forKeys:kKeys1 count:GPBARRAYSIZE(kValues1)]; XCTAssertNotNil(dict1prime); GPBInt32Int32Dictionary *dict2 = - [[GPBInt32Int32Dictionary alloc] initWithValues:kValues2 + [[GPBInt32Int32Dictionary alloc] initWithInt32s:kValues2 forKeys:kKeys1 count:GPBARRAYSIZE(kValues2)]; XCTAssertNotNil(dict2); GPBInt32Int32Dictionary *dict3 = - [[GPBInt32Int32Dictionary alloc] initWithValues:kValues1 + [[GPBInt32Int32Dictionary alloc] initWithInt32s:kValues1 forKeys:kKeys2 count:GPBARRAYSIZE(kValues1)]; XCTAssertNotNil(dict3); GPBInt32Int32Dictionary *dict4 = - [[GPBInt32Int32Dictionary alloc] initWithValues:kValues3 + [[GPBInt32Int32Dictionary alloc] initWithInt32s:kValues3 forKeys:kKeys1 count:GPBARRAYSIZE(kValues3)]; XCTAssertNotNil(dict4); @@ -588,7 +588,7 @@ static BOOL TestingEnum_IsValidValue(int32_t value) { const int32_t kKeys[] = { 11, 12, 13, 14 }; const int32_t kValues[] = { 200, 201, 202, 203 }; GPBInt32Int32Dictionary *dict = - [[GPBInt32Int32Dictionary alloc] initWithValues:kValues + [[GPBInt32Int32Dictionary alloc] initWithInt32s:kValues forKeys:kKeys count:GPBARRAYSIZE(kValues)]; XCTAssertNotNil(dict); @@ -609,7 +609,7 @@ static BOOL TestingEnum_IsValidValue(int32_t value) { const int32_t kKeys[] = { 11, 12, 13, 14 }; const int32_t kValues[] = { 200, 201, 202, 203 }; GPBInt32Int32Dictionary *dict = - [[GPBInt32Int32Dictionary alloc] initWithValues:kValues + [[GPBInt32Int32Dictionary alloc] initWithInt32s:kValues forKeys:kKeys count:GPBARRAYSIZE(kValues)]; XCTAssertNotNil(dict); @@ -629,13 +629,13 @@ static BOOL TestingEnum_IsValidValue(int32_t value) { XCTAssertNotNil(dict); XCTAssertEqual(dict.count, 0U); - [dict setValue:200 forKey:11]; + [dict setInt32:200 forKey:11]; XCTAssertEqual(dict.count, 1U); const int32_t kKeys[] = { 12, 13, 14 }; const int32_t kValues[] = { 201, 202, 203 }; GPBInt32Int32Dictionary *dict2 = - [[GPBInt32Int32Dictionary alloc] initWithValues:kValues + [[GPBInt32Int32Dictionary alloc] initWithInt32s:kValues forKeys:kKeys count:GPBARRAYSIZE(kValues)]; XCTAssertNotNil(dict2); @@ -643,17 +643,17 @@ static BOOL TestingEnum_IsValidValue(int32_t value) { XCTAssertEqual(dict.count, 4U); int32_t value; - XCTAssertTrue([dict valueForKey:11 value:NULL]); - XCTAssertTrue([dict valueForKey:11 value:&value]); + XCTAssertTrue([dict getInt32:NULL forKey:11]); + XCTAssertTrue([dict getInt32:&value forKey:11]); XCTAssertEqual(value, 200); - XCTAssertTrue([dict valueForKey:12 value:NULL]); - XCTAssertTrue([dict valueForKey:12 value:&value]); + XCTAssertTrue([dict getInt32:NULL forKey:12]); + XCTAssertTrue([dict getInt32:&value forKey:12]); XCTAssertEqual(value, 201); - XCTAssertTrue([dict valueForKey:13 value:NULL]); - XCTAssertTrue([dict valueForKey:13 value:&value]); + XCTAssertTrue([dict getInt32:NULL forKey:13]); + XCTAssertTrue([dict getInt32:&value forKey:13]); XCTAssertEqual(value, 202); - XCTAssertTrue([dict valueForKey:14 value:NULL]); - XCTAssertTrue([dict valueForKey:14 value:&value]); + XCTAssertTrue([dict getInt32:NULL forKey:14]); + XCTAssertTrue([dict getInt32:&value forKey:14]); XCTAssertEqual(value, 203); [dict2 release]; } @@ -662,57 +662,57 @@ static BOOL TestingEnum_IsValidValue(int32_t value) { const int32_t kKeys[] = { 11, 12, 13, 14 }; const int32_t kValues[] = { 200, 201, 202, 203 }; GPBInt32Int32Dictionary *dict = - [[GPBInt32Int32Dictionary alloc] initWithValues:kValues - forKeys:kKeys - count:GPBARRAYSIZE(kValues)]; + [[GPBInt32Int32Dictionary alloc] initWithInt32s:kValues + forKeys:kKeys + count:GPBARRAYSIZE(kValues)]; XCTAssertNotNil(dict); XCTAssertEqual(dict.count, 4U); - [dict removeValueForKey:12]; + [dict removeInt32ForKey:12]; XCTAssertEqual(dict.count, 3U); int32_t value; - XCTAssertTrue([dict valueForKey:11 value:NULL]); - XCTAssertTrue([dict valueForKey:11 value:&value]); + XCTAssertTrue([dict getInt32:NULL forKey:11]); + XCTAssertTrue([dict getInt32:&value forKey:11]); XCTAssertEqual(value, 200); - XCTAssertFalse([dict valueForKey:12 value:NULL]); - XCTAssertTrue([dict valueForKey:13 value:NULL]); - XCTAssertTrue([dict valueForKey:13 value:&value]); + XCTAssertFalse([dict getInt32:NULL forKey:12]); + XCTAssertTrue([dict getInt32:NULL forKey:13]); + XCTAssertTrue([dict getInt32:&value forKey:13]); XCTAssertEqual(value, 202); - XCTAssertTrue([dict valueForKey:14 value:NULL]); - XCTAssertTrue([dict valueForKey:14 value:&value]); + XCTAssertTrue([dict getInt32:NULL forKey:14]); + XCTAssertTrue([dict getInt32:&value forKey:14]); XCTAssertEqual(value, 203); // Remove again does nothing. - [dict removeValueForKey:12]; + [dict removeInt32ForKey:12]; XCTAssertEqual(dict.count, 3U); - XCTAssertTrue([dict valueForKey:11 value:NULL]); - XCTAssertTrue([dict valueForKey:11 value:&value]); + XCTAssertTrue([dict getInt32:NULL forKey:11]); + XCTAssertTrue([dict getInt32:&value forKey:11]); XCTAssertEqual(value, 200); - XCTAssertFalse([dict valueForKey:12 value:NULL]); - XCTAssertTrue([dict valueForKey:13 value:NULL]); - XCTAssertTrue([dict valueForKey:13 value:&value]); + XCTAssertFalse([dict getInt32:NULL forKey:12]); + XCTAssertTrue([dict getInt32:NULL forKey:13]); + XCTAssertTrue([dict getInt32:&value forKey:13]); XCTAssertEqual(value, 202); - XCTAssertTrue([dict valueForKey:14 value:NULL]); - XCTAssertTrue([dict valueForKey:14 value:&value]); + XCTAssertTrue([dict getInt32:NULL forKey:14]); + XCTAssertTrue([dict getInt32:&value forKey:14]); XCTAssertEqual(value, 203); - [dict removeValueForKey:14]; + [dict removeInt32ForKey:14]; XCTAssertEqual(dict.count, 2U); - XCTAssertTrue([dict valueForKey:11 value:NULL]); - XCTAssertTrue([dict valueForKey:11 value:&value]); + XCTAssertTrue([dict getInt32:NULL forKey:11]); + XCTAssertTrue([dict getInt32:&value forKey:11]); XCTAssertEqual(value, 200); - XCTAssertFalse([dict valueForKey:12 value:NULL]); - XCTAssertTrue([dict valueForKey:13 value:NULL]); - XCTAssertTrue([dict valueForKey:13 value:&value]); + XCTAssertFalse([dict getInt32:NULL forKey:12]); + XCTAssertTrue([dict getInt32:NULL forKey:13]); + XCTAssertTrue([dict getInt32:&value forKey:13]); XCTAssertEqual(value, 202); - XCTAssertFalse([dict valueForKey:14 value:NULL]); + XCTAssertFalse([dict getInt32:NULL forKey:14]); [dict removeAll]; XCTAssertEqual(dict.count, 0U); - XCTAssertFalse([dict valueForKey:11 value:NULL]); - XCTAssertFalse([dict valueForKey:12 value:NULL]); - XCTAssertFalse([dict valueForKey:13 value:NULL]); - XCTAssertFalse([dict valueForKey:14 value:NULL]); + XCTAssertFalse([dict getInt32:NULL forKey:11]); + XCTAssertFalse([dict getInt32:NULL forKey:12]); + XCTAssertFalse([dict getInt32:NULL forKey:13]); + XCTAssertFalse([dict getInt32:NULL forKey:14]); [dict release]; } @@ -720,75 +720,75 @@ static BOOL TestingEnum_IsValidValue(int32_t value) { const int32_t kKeys[] = { 11, 12, 13, 14 }; const int32_t kValues[] = { 200, 201, 202, 203 }; GPBInt32Int32Dictionary *dict = - [[GPBInt32Int32Dictionary alloc] initWithValues:kValues - forKeys:kKeys - count:GPBARRAYSIZE(kValues)]; + [[GPBInt32Int32Dictionary alloc] initWithInt32s:kValues + forKeys:kKeys + count:GPBARRAYSIZE(kValues)]; XCTAssertNotNil(dict); XCTAssertEqual(dict.count, 4U); int32_t value; - XCTAssertTrue([dict valueForKey:11 value:NULL]); - XCTAssertTrue([dict valueForKey:11 value:&value]); + XCTAssertTrue([dict getInt32:NULL forKey:11]); + XCTAssertTrue([dict getInt32:&value forKey:11]); XCTAssertEqual(value, 200); - XCTAssertTrue([dict valueForKey:12 value:NULL]); - XCTAssertTrue([dict valueForKey:12 value:&value]); + XCTAssertTrue([dict getInt32:NULL forKey:12]); + XCTAssertTrue([dict getInt32:&value forKey:12]); XCTAssertEqual(value, 201); - XCTAssertTrue([dict valueForKey:13 value:NULL]); - XCTAssertTrue([dict valueForKey:13 value:&value]); + XCTAssertTrue([dict getInt32:NULL forKey:13]); + XCTAssertTrue([dict getInt32:&value forKey:13]); XCTAssertEqual(value, 202); - XCTAssertTrue([dict valueForKey:14 value:NULL]); - XCTAssertTrue([dict valueForKey:14 value:&value]); + XCTAssertTrue([dict getInt32:NULL forKey:14]); + XCTAssertTrue([dict getInt32:&value forKey:14]); XCTAssertEqual(value, 203); - [dict setValue:203 forKey:11]; + [dict setInt32:203 forKey:11]; XCTAssertEqual(dict.count, 4U); - XCTAssertTrue([dict valueForKey:11 value:NULL]); - XCTAssertTrue([dict valueForKey:11 value:&value]); + XCTAssertTrue([dict getInt32:NULL forKey:11]); + XCTAssertTrue([dict getInt32:&value forKey:11]); XCTAssertEqual(value, 203); - XCTAssertTrue([dict valueForKey:12 value:NULL]); - XCTAssertTrue([dict valueForKey:12 value:&value]); + XCTAssertTrue([dict getInt32:NULL forKey:12]); + XCTAssertTrue([dict getInt32:&value forKey:12]); XCTAssertEqual(value, 201); - XCTAssertTrue([dict valueForKey:13 value:NULL]); - XCTAssertTrue([dict valueForKey:13 value:&value]); + XCTAssertTrue([dict getInt32:NULL forKey:13]); + XCTAssertTrue([dict getInt32:&value forKey:13]); XCTAssertEqual(value, 202); - XCTAssertTrue([dict valueForKey:14 value:NULL]); - XCTAssertTrue([dict valueForKey:14 value:&value]); + XCTAssertTrue([dict getInt32:NULL forKey:14]); + XCTAssertTrue([dict getInt32:&value forKey:14]); XCTAssertEqual(value, 203); - [dict setValue:201 forKey:14]; + [dict setInt32:201 forKey:14]; XCTAssertEqual(dict.count, 4U); - XCTAssertTrue([dict valueForKey:11 value:NULL]); - XCTAssertTrue([dict valueForKey:11 value:&value]); + XCTAssertTrue([dict getInt32:NULL forKey:11]); + XCTAssertTrue([dict getInt32:&value forKey:11]); XCTAssertEqual(value, 203); - XCTAssertTrue([dict valueForKey:12 value:NULL]); - XCTAssertTrue([dict valueForKey:12 value:&value]); + XCTAssertTrue([dict getInt32:NULL forKey:12]); + XCTAssertTrue([dict getInt32:&value forKey:12]); XCTAssertEqual(value, 201); - XCTAssertTrue([dict valueForKey:13 value:NULL]); - XCTAssertTrue([dict valueForKey:13 value:&value]); + XCTAssertTrue([dict getInt32:NULL forKey:13]); + XCTAssertTrue([dict getInt32:&value forKey:13]); XCTAssertEqual(value, 202); - XCTAssertTrue([dict valueForKey:14 value:NULL]); - XCTAssertTrue([dict valueForKey:14 value:&value]); + XCTAssertTrue([dict getInt32:NULL forKey:14]); + XCTAssertTrue([dict getInt32:&value forKey:14]); XCTAssertEqual(value, 201); const int32_t kKeys2[] = { 12, 13 }; const int32_t kValues2[] = { 202, 200 }; GPBInt32Int32Dictionary *dict2 = - [[GPBInt32Int32Dictionary alloc] initWithValues:kValues2 + [[GPBInt32Int32Dictionary alloc] initWithInt32s:kValues2 forKeys:kKeys2 count:GPBARRAYSIZE(kValues2)]; XCTAssertNotNil(dict2); [dict addEntriesFromDictionary:dict2]; XCTAssertEqual(dict.count, 4U); - XCTAssertTrue([dict valueForKey:11 value:NULL]); - XCTAssertTrue([dict valueForKey:11 value:&value]); + XCTAssertTrue([dict getInt32:NULL forKey:11]); + XCTAssertTrue([dict getInt32:&value forKey:11]); XCTAssertEqual(value, 203); - XCTAssertTrue([dict valueForKey:12 value:NULL]); - XCTAssertTrue([dict valueForKey:12 value:&value]); + XCTAssertTrue([dict getInt32:NULL forKey:12]); + XCTAssertTrue([dict getInt32:&value forKey:12]); XCTAssertEqual(value, 202); - XCTAssertTrue([dict valueForKey:13 value:NULL]); - XCTAssertTrue([dict valueForKey:13 value:&value]); + XCTAssertTrue([dict getInt32:NULL forKey:13]); + XCTAssertTrue([dict getInt32:&value forKey:13]); XCTAssertEqual(value, 200); - XCTAssertTrue([dict valueForKey:14 value:NULL]); - XCTAssertTrue([dict valueForKey:14 value:&value]); + XCTAssertTrue([dict getInt32:NULL forKey:14]); + XCTAssertTrue([dict getInt32:&value forKey:14]); XCTAssertEqual(value, 201); [dict2 release]; @@ -808,8 +808,8 @@ static BOOL TestingEnum_IsValidValue(int32_t value) { GPBInt32UInt64Dictionary *dict = [[GPBInt32UInt64Dictionary alloc] init]; XCTAssertNotNil(dict); XCTAssertEqual(dict.count, 0U); - XCTAssertFalse([dict valueForKey:11 value:NULL]); - [dict enumerateKeysAndValuesUsingBlock:^(int32_t aKey, uint64_t aValue, BOOL *stop) { + XCTAssertFalse([dict getUInt64:NULL forKey:11]); + [dict enumerateKeysAndUInt64sUsingBlock:^(int32_t aKey, uint64_t aValue, BOOL *stop) { #pragma unused(aKey, aValue, stop) XCTFail(@"Shouldn't get here!"); }]; @@ -817,15 +817,15 @@ static BOOL TestingEnum_IsValidValue(int32_t value) { } - (void)testOne { - GPBInt32UInt64Dictionary *dict = [GPBInt32UInt64Dictionary dictionaryWithValue:300U forKey:11]; + GPBInt32UInt64Dictionary *dict = [GPBInt32UInt64Dictionary dictionaryWithUInt64:300U forKey:11]; XCTAssertNotNil(dict); XCTAssertEqual(dict.count, 1U); uint64_t value; - XCTAssertTrue([dict valueForKey:11 value:NULL]); - XCTAssertTrue([dict valueForKey:11 value:&value]); + XCTAssertTrue([dict getUInt64:NULL forKey:11]); + XCTAssertTrue([dict getUInt64:&value forKey:11]); XCTAssertEqual(value, 300U); - XCTAssertFalse([dict valueForKey:12 value:NULL]); - [dict enumerateKeysAndValuesUsingBlock:^(int32_t aKey, uint64_t aValue, BOOL *stop) { + XCTAssertFalse([dict getUInt64:NULL forKey:12]); + [dict enumerateKeysAndUInt64sUsingBlock:^(int32_t aKey, uint64_t aValue, BOOL *stop) { XCTAssertEqual(aKey, 11); XCTAssertEqual(aValue, 300U); XCTAssertNotEqual(stop, NULL); @@ -836,27 +836,27 @@ static BOOL TestingEnum_IsValidValue(int32_t value) { const int32_t kKeys[] = { 11, 12, 13 }; const uint64_t kValues[] = { 300U, 301U, 302U }; GPBInt32UInt64Dictionary *dict = - [[GPBInt32UInt64Dictionary alloc] initWithValues:kValues - forKeys:kKeys - count:GPBARRAYSIZE(kValues)]; + [[GPBInt32UInt64Dictionary alloc] initWithUInt64s:kValues + forKeys:kKeys + count:GPBARRAYSIZE(kValues)]; XCTAssertNotNil(dict); XCTAssertEqual(dict.count, 3U); uint64_t value; - XCTAssertTrue([dict valueForKey:11 value:NULL]); - XCTAssertTrue([dict valueForKey:11 value:&value]); + XCTAssertTrue([dict getUInt64:NULL forKey:11]); + XCTAssertTrue([dict getUInt64:&value forKey:11]); XCTAssertEqual(value, 300U); - XCTAssertTrue([dict valueForKey:12 value:NULL]); - XCTAssertTrue([dict valueForKey:12 value:&value]); + XCTAssertTrue([dict getUInt64:NULL forKey:12]); + XCTAssertTrue([dict getUInt64:&value forKey:12]); XCTAssertEqual(value, 301U); - XCTAssertTrue([dict valueForKey:13 value:NULL]); - XCTAssertTrue([dict valueForKey:13 value:&value]); + XCTAssertTrue([dict getUInt64:NULL forKey:13]); + XCTAssertTrue([dict getUInt64:&value forKey:13]); XCTAssertEqual(value, 302U); - XCTAssertFalse([dict valueForKey:14 value:NULL]); + XCTAssertFalse([dict getUInt64:NULL forKey:14]); __block NSUInteger idx = 0; int32_t *seenKeys = malloc(3 * sizeof(int32_t)); uint64_t *seenValues = malloc(3 * sizeof(uint64_t)); - [dict enumerateKeysAndValuesUsingBlock:^(int32_t aKey, uint64_t aValue, BOOL *stop) { + [dict enumerateKeysAndUInt64sUsingBlock:^(int32_t aKey, uint64_t aValue, BOOL *stop) { XCTAssertLessThan(idx, 3U); seenKeys[idx] = aKey; seenValues[idx] = aValue; @@ -878,7 +878,7 @@ static BOOL TestingEnum_IsValidValue(int32_t value) { // Stopping the enumeration. idx = 0; - [dict enumerateKeysAndValuesUsingBlock:^(int32_t aKey, uint64_t aValue, BOOL *stop) { + [dict enumerateKeysAndUInt64sUsingBlock:^(int32_t aKey, uint64_t aValue, BOOL *stop) { #pragma unused(aKey, aValue) if (idx == 1) *stop = YES; XCTAssertNotEqual(idx, 2U); @@ -894,29 +894,29 @@ static BOOL TestingEnum_IsValidValue(int32_t value) { const uint64_t kValues2[] = { 300U, 303U, 302U }; const uint64_t kValues3[] = { 300U, 301U, 302U, 303U }; GPBInt32UInt64Dictionary *dict1 = - [[GPBInt32UInt64Dictionary alloc] initWithValues:kValues1 - forKeys:kKeys1 - count:GPBARRAYSIZE(kValues1)]; + [[GPBInt32UInt64Dictionary alloc] initWithUInt64s:kValues1 + forKeys:kKeys1 + count:GPBARRAYSIZE(kValues1)]; XCTAssertNotNil(dict1); GPBInt32UInt64Dictionary *dict1prime = - [[GPBInt32UInt64Dictionary alloc] initWithValues:kValues1 - forKeys:kKeys1 - count:GPBARRAYSIZE(kValues1)]; + [[GPBInt32UInt64Dictionary alloc] initWithUInt64s:kValues1 + forKeys:kKeys1 + count:GPBARRAYSIZE(kValues1)]; XCTAssertNotNil(dict1prime); GPBInt32UInt64Dictionary *dict2 = - [[GPBInt32UInt64Dictionary alloc] initWithValues:kValues2 - forKeys:kKeys1 - count:GPBARRAYSIZE(kValues2)]; + [[GPBInt32UInt64Dictionary alloc] initWithUInt64s:kValues2 + forKeys:kKeys1 + count:GPBARRAYSIZE(kValues2)]; XCTAssertNotNil(dict2); GPBInt32UInt64Dictionary *dict3 = - [[GPBInt32UInt64Dictionary alloc] initWithValues:kValues1 - forKeys:kKeys2 - count:GPBARRAYSIZE(kValues1)]; + [[GPBInt32UInt64Dictionary alloc] initWithUInt64s:kValues1 + forKeys:kKeys2 + count:GPBARRAYSIZE(kValues1)]; XCTAssertNotNil(dict3); GPBInt32UInt64Dictionary *dict4 = - [[GPBInt32UInt64Dictionary alloc] initWithValues:kValues3 - forKeys:kKeys1 - count:GPBARRAYSIZE(kValues3)]; + [[GPBInt32UInt64Dictionary alloc] initWithUInt64s:kValues3 + forKeys:kKeys1 + count:GPBARRAYSIZE(kValues3)]; XCTAssertNotNil(dict4); // 1/1Prime should be different objects, but equal. @@ -945,9 +945,9 @@ static BOOL TestingEnum_IsValidValue(int32_t value) { const int32_t kKeys[] = { 11, 12, 13, 14 }; const uint64_t kValues[] = { 300U, 301U, 302U, 303U }; GPBInt32UInt64Dictionary *dict = - [[GPBInt32UInt64Dictionary alloc] initWithValues:kValues - forKeys:kKeys - count:GPBARRAYSIZE(kValues)]; + [[GPBInt32UInt64Dictionary alloc] initWithUInt64s:kValues + forKeys:kKeys + count:GPBARRAYSIZE(kValues)]; XCTAssertNotNil(dict); GPBInt32UInt64Dictionary *dict2 = [dict copy]; @@ -966,9 +966,9 @@ static BOOL TestingEnum_IsValidValue(int32_t value) { const int32_t kKeys[] = { 11, 12, 13, 14 }; const uint64_t kValues[] = { 300U, 301U, 302U, 303U }; GPBInt32UInt64Dictionary *dict = - [[GPBInt32UInt64Dictionary alloc] initWithValues:kValues - forKeys:kKeys - count:GPBARRAYSIZE(kValues)]; + [[GPBInt32UInt64Dictionary alloc] initWithUInt64s:kValues + forKeys:kKeys + count:GPBARRAYSIZE(kValues)]; XCTAssertNotNil(dict); GPBInt32UInt64Dictionary *dict2 = @@ -986,31 +986,31 @@ static BOOL TestingEnum_IsValidValue(int32_t value) { XCTAssertNotNil(dict); XCTAssertEqual(dict.count, 0U); - [dict setValue:300U forKey:11]; + [dict setUInt64:300U forKey:11]; XCTAssertEqual(dict.count, 1U); const int32_t kKeys[] = { 12, 13, 14 }; const uint64_t kValues[] = { 301U, 302U, 303U }; GPBInt32UInt64Dictionary *dict2 = - [[GPBInt32UInt64Dictionary alloc] initWithValues:kValues - forKeys:kKeys - count:GPBARRAYSIZE(kValues)]; + [[GPBInt32UInt64Dictionary alloc] initWithUInt64s:kValues + forKeys:kKeys + count:GPBARRAYSIZE(kValues)]; XCTAssertNotNil(dict2); [dict addEntriesFromDictionary:dict2]; XCTAssertEqual(dict.count, 4U); uint64_t value; - XCTAssertTrue([dict valueForKey:11 value:NULL]); - XCTAssertTrue([dict valueForKey:11 value:&value]); + XCTAssertTrue([dict getUInt64:NULL forKey:11]); + XCTAssertTrue([dict getUInt64:&value forKey:11]); XCTAssertEqual(value, 300U); - XCTAssertTrue([dict valueForKey:12 value:NULL]); - XCTAssertTrue([dict valueForKey:12 value:&value]); + XCTAssertTrue([dict getUInt64:NULL forKey:12]); + XCTAssertTrue([dict getUInt64:&value forKey:12]); XCTAssertEqual(value, 301U); - XCTAssertTrue([dict valueForKey:13 value:NULL]); - XCTAssertTrue([dict valueForKey:13 value:&value]); + XCTAssertTrue([dict getUInt64:NULL forKey:13]); + XCTAssertTrue([dict getUInt64:&value forKey:13]); XCTAssertEqual(value, 302U); - XCTAssertTrue([dict valueForKey:14 value:NULL]); - XCTAssertTrue([dict valueForKey:14 value:&value]); + XCTAssertTrue([dict getUInt64:NULL forKey:14]); + XCTAssertTrue([dict getUInt64:&value forKey:14]); XCTAssertEqual(value, 303U); [dict2 release]; } @@ -1019,57 +1019,57 @@ static BOOL TestingEnum_IsValidValue(int32_t value) { const int32_t kKeys[] = { 11, 12, 13, 14 }; const uint64_t kValues[] = { 300U, 301U, 302U, 303U }; GPBInt32UInt64Dictionary *dict = - [[GPBInt32UInt64Dictionary alloc] initWithValues:kValues - forKeys:kKeys - count:GPBARRAYSIZE(kValues)]; + [[GPBInt32UInt64Dictionary alloc] initWithUInt64s:kValues + forKeys:kKeys + count:GPBARRAYSIZE(kValues)]; XCTAssertNotNil(dict); XCTAssertEqual(dict.count, 4U); - [dict removeValueForKey:12]; + [dict removeUInt64ForKey:12]; XCTAssertEqual(dict.count, 3U); uint64_t value; - XCTAssertTrue([dict valueForKey:11 value:NULL]); - XCTAssertTrue([dict valueForKey:11 value:&value]); + XCTAssertTrue([dict getUInt64:NULL forKey:11]); + XCTAssertTrue([dict getUInt64:&value forKey:11]); XCTAssertEqual(value, 300U); - XCTAssertFalse([dict valueForKey:12 value:NULL]); - XCTAssertTrue([dict valueForKey:13 value:NULL]); - XCTAssertTrue([dict valueForKey:13 value:&value]); + XCTAssertFalse([dict getUInt64:NULL forKey:12]); + XCTAssertTrue([dict getUInt64:NULL forKey:13]); + XCTAssertTrue([dict getUInt64:&value forKey:13]); XCTAssertEqual(value, 302U); - XCTAssertTrue([dict valueForKey:14 value:NULL]); - XCTAssertTrue([dict valueForKey:14 value:&value]); + XCTAssertTrue([dict getUInt64:NULL forKey:14]); + XCTAssertTrue([dict getUInt64:&value forKey:14]); XCTAssertEqual(value, 303U); // Remove again does nothing. - [dict removeValueForKey:12]; + [dict removeUInt64ForKey:12]; XCTAssertEqual(dict.count, 3U); - XCTAssertTrue([dict valueForKey:11 value:NULL]); - XCTAssertTrue([dict valueForKey:11 value:&value]); + XCTAssertTrue([dict getUInt64:NULL forKey:11]); + XCTAssertTrue([dict getUInt64:&value forKey:11]); XCTAssertEqual(value, 300U); - XCTAssertFalse([dict valueForKey:12 value:NULL]); - XCTAssertTrue([dict valueForKey:13 value:NULL]); - XCTAssertTrue([dict valueForKey:13 value:&value]); + XCTAssertFalse([dict getUInt64:NULL forKey:12]); + XCTAssertTrue([dict getUInt64:NULL forKey:13]); + XCTAssertTrue([dict getUInt64:&value forKey:13]); XCTAssertEqual(value, 302U); - XCTAssertTrue([dict valueForKey:14 value:NULL]); - XCTAssertTrue([dict valueForKey:14 value:&value]); + XCTAssertTrue([dict getUInt64:NULL forKey:14]); + XCTAssertTrue([dict getUInt64:&value forKey:14]); XCTAssertEqual(value, 303U); - [dict removeValueForKey:14]; + [dict removeUInt64ForKey:14]; XCTAssertEqual(dict.count, 2U); - XCTAssertTrue([dict valueForKey:11 value:NULL]); - XCTAssertTrue([dict valueForKey:11 value:&value]); + XCTAssertTrue([dict getUInt64:NULL forKey:11]); + XCTAssertTrue([dict getUInt64:&value forKey:11]); XCTAssertEqual(value, 300U); - XCTAssertFalse([dict valueForKey:12 value:NULL]); - XCTAssertTrue([dict valueForKey:13 value:NULL]); - XCTAssertTrue([dict valueForKey:13 value:&value]); + XCTAssertFalse([dict getUInt64:NULL forKey:12]); + XCTAssertTrue([dict getUInt64:NULL forKey:13]); + XCTAssertTrue([dict getUInt64:&value forKey:13]); XCTAssertEqual(value, 302U); - XCTAssertFalse([dict valueForKey:14 value:NULL]); + XCTAssertFalse([dict getUInt64:NULL forKey:14]); [dict removeAll]; XCTAssertEqual(dict.count, 0U); - XCTAssertFalse([dict valueForKey:11 value:NULL]); - XCTAssertFalse([dict valueForKey:12 value:NULL]); - XCTAssertFalse([dict valueForKey:13 value:NULL]); - XCTAssertFalse([dict valueForKey:14 value:NULL]); + XCTAssertFalse([dict getUInt64:NULL forKey:11]); + XCTAssertFalse([dict getUInt64:NULL forKey:12]); + XCTAssertFalse([dict getUInt64:NULL forKey:13]); + XCTAssertFalse([dict getUInt64:NULL forKey:14]); [dict release]; } @@ -1077,75 +1077,75 @@ static BOOL TestingEnum_IsValidValue(int32_t value) { const int32_t kKeys[] = { 11, 12, 13, 14 }; const uint64_t kValues[] = { 300U, 301U, 302U, 303U }; GPBInt32UInt64Dictionary *dict = - [[GPBInt32UInt64Dictionary alloc] initWithValues:kValues - forKeys:kKeys - count:GPBARRAYSIZE(kValues)]; + [[GPBInt32UInt64Dictionary alloc] initWithUInt64s:kValues + forKeys:kKeys + count:GPBARRAYSIZE(kValues)]; XCTAssertNotNil(dict); XCTAssertEqual(dict.count, 4U); uint64_t value; - XCTAssertTrue([dict valueForKey:11 value:NULL]); - XCTAssertTrue([dict valueForKey:11 value:&value]); + XCTAssertTrue([dict getUInt64:NULL forKey:11]); + XCTAssertTrue([dict getUInt64:&value forKey:11]); XCTAssertEqual(value, 300U); - XCTAssertTrue([dict valueForKey:12 value:NULL]); - XCTAssertTrue([dict valueForKey:12 value:&value]); + XCTAssertTrue([dict getUInt64:NULL forKey:12]); + XCTAssertTrue([dict getUInt64:&value forKey:12]); XCTAssertEqual(value, 301U); - XCTAssertTrue([dict valueForKey:13 value:NULL]); - XCTAssertTrue([dict valueForKey:13 value:&value]); + XCTAssertTrue([dict getUInt64:NULL forKey:13]); + XCTAssertTrue([dict getUInt64:&value forKey:13]); XCTAssertEqual(value, 302U); - XCTAssertTrue([dict valueForKey:14 value:NULL]); - XCTAssertTrue([dict valueForKey:14 value:&value]); + XCTAssertTrue([dict getUInt64:NULL forKey:14]); + XCTAssertTrue([dict getUInt64:&value forKey:14]); XCTAssertEqual(value, 303U); - [dict setValue:303U forKey:11]; + [dict setUInt64:303U forKey:11]; XCTAssertEqual(dict.count, 4U); - XCTAssertTrue([dict valueForKey:11 value:NULL]); - XCTAssertTrue([dict valueForKey:11 value:&value]); + XCTAssertTrue([dict getUInt64:NULL forKey:11]); + XCTAssertTrue([dict getUInt64:&value forKey:11]); XCTAssertEqual(value, 303U); - XCTAssertTrue([dict valueForKey:12 value:NULL]); - XCTAssertTrue([dict valueForKey:12 value:&value]); + XCTAssertTrue([dict getUInt64:NULL forKey:12]); + XCTAssertTrue([dict getUInt64:&value forKey:12]); XCTAssertEqual(value, 301U); - XCTAssertTrue([dict valueForKey:13 value:NULL]); - XCTAssertTrue([dict valueForKey:13 value:&value]); + XCTAssertTrue([dict getUInt64:NULL forKey:13]); + XCTAssertTrue([dict getUInt64:&value forKey:13]); XCTAssertEqual(value, 302U); - XCTAssertTrue([dict valueForKey:14 value:NULL]); - XCTAssertTrue([dict valueForKey:14 value:&value]); + XCTAssertTrue([dict getUInt64:NULL forKey:14]); + XCTAssertTrue([dict getUInt64:&value forKey:14]); XCTAssertEqual(value, 303U); - [dict setValue:301U forKey:14]; + [dict setUInt64:301U forKey:14]; XCTAssertEqual(dict.count, 4U); - XCTAssertTrue([dict valueForKey:11 value:NULL]); - XCTAssertTrue([dict valueForKey:11 value:&value]); + XCTAssertTrue([dict getUInt64:NULL forKey:11]); + XCTAssertTrue([dict getUInt64:&value forKey:11]); XCTAssertEqual(value, 303U); - XCTAssertTrue([dict valueForKey:12 value:NULL]); - XCTAssertTrue([dict valueForKey:12 value:&value]); + XCTAssertTrue([dict getUInt64:NULL forKey:12]); + XCTAssertTrue([dict getUInt64:&value forKey:12]); XCTAssertEqual(value, 301U); - XCTAssertTrue([dict valueForKey:13 value:NULL]); - XCTAssertTrue([dict valueForKey:13 value:&value]); + XCTAssertTrue([dict getUInt64:NULL forKey:13]); + XCTAssertTrue([dict getUInt64:&value forKey:13]); XCTAssertEqual(value, 302U); - XCTAssertTrue([dict valueForKey:14 value:NULL]); - XCTAssertTrue([dict valueForKey:14 value:&value]); + XCTAssertTrue([dict getUInt64:NULL forKey:14]); + XCTAssertTrue([dict getUInt64:&value forKey:14]); XCTAssertEqual(value, 301U); const int32_t kKeys2[] = { 12, 13 }; const uint64_t kValues2[] = { 302U, 300U }; GPBInt32UInt64Dictionary *dict2 = - [[GPBInt32UInt64Dictionary alloc] initWithValues:kValues2 - forKeys:kKeys2 - count:GPBARRAYSIZE(kValues2)]; + [[GPBInt32UInt64Dictionary alloc] initWithUInt64s:kValues2 + forKeys:kKeys2 + count:GPBARRAYSIZE(kValues2)]; XCTAssertNotNil(dict2); [dict addEntriesFromDictionary:dict2]; XCTAssertEqual(dict.count, 4U); - XCTAssertTrue([dict valueForKey:11 value:NULL]); - XCTAssertTrue([dict valueForKey:11 value:&value]); + XCTAssertTrue([dict getUInt64:NULL forKey:11]); + XCTAssertTrue([dict getUInt64:&value forKey:11]); XCTAssertEqual(value, 303U); - XCTAssertTrue([dict valueForKey:12 value:NULL]); - XCTAssertTrue([dict valueForKey:12 value:&value]); + XCTAssertTrue([dict getUInt64:NULL forKey:12]); + XCTAssertTrue([dict getUInt64:&value forKey:12]); XCTAssertEqual(value, 302U); - XCTAssertTrue([dict valueForKey:13 value:NULL]); - XCTAssertTrue([dict valueForKey:13 value:&value]); + XCTAssertTrue([dict getUInt64:NULL forKey:13]); + XCTAssertTrue([dict getUInt64:&value forKey:13]); XCTAssertEqual(value, 300U); - XCTAssertTrue([dict valueForKey:14 value:NULL]); - XCTAssertTrue([dict valueForKey:14 value:&value]); + XCTAssertTrue([dict getUInt64:NULL forKey:14]); + XCTAssertTrue([dict getUInt64:&value forKey:14]); XCTAssertEqual(value, 301U); [dict2 release]; @@ -1165,8 +1165,8 @@ static BOOL TestingEnum_IsValidValue(int32_t value) { GPBInt32Int64Dictionary *dict = [[GPBInt32Int64Dictionary alloc] init]; XCTAssertNotNil(dict); XCTAssertEqual(dict.count, 0U); - XCTAssertFalse([dict valueForKey:11 value:NULL]); - [dict enumerateKeysAndValuesUsingBlock:^(int32_t aKey, int64_t aValue, BOOL *stop) { + XCTAssertFalse([dict getInt64:NULL forKey:11]); + [dict enumerateKeysAndInt64sUsingBlock:^(int32_t aKey, int64_t aValue, BOOL *stop) { #pragma unused(aKey, aValue, stop) XCTFail(@"Shouldn't get here!"); }]; @@ -1174,15 +1174,15 @@ static BOOL TestingEnum_IsValidValue(int32_t value) { } - (void)testOne { - GPBInt32Int64Dictionary *dict = [GPBInt32Int64Dictionary dictionaryWithValue:400 forKey:11]; + GPBInt32Int64Dictionary *dict = [GPBInt32Int64Dictionary dictionaryWithInt64:400 forKey:11]; XCTAssertNotNil(dict); XCTAssertEqual(dict.count, 1U); int64_t value; - XCTAssertTrue([dict valueForKey:11 value:NULL]); - XCTAssertTrue([dict valueForKey:11 value:&value]); + XCTAssertTrue([dict getInt64:NULL forKey:11]); + XCTAssertTrue([dict getInt64:&value forKey:11]); XCTAssertEqual(value, 400); - XCTAssertFalse([dict valueForKey:12 value:NULL]); - [dict enumerateKeysAndValuesUsingBlock:^(int32_t aKey, int64_t aValue, BOOL *stop) { + XCTAssertFalse([dict getInt64:NULL forKey:12]); + [dict enumerateKeysAndInt64sUsingBlock:^(int32_t aKey, int64_t aValue, BOOL *stop) { XCTAssertEqual(aKey, 11); XCTAssertEqual(aValue, 400); XCTAssertNotEqual(stop, NULL); @@ -1193,27 +1193,27 @@ static BOOL TestingEnum_IsValidValue(int32_t value) { const int32_t kKeys[] = { 11, 12, 13 }; const int64_t kValues[] = { 400, 401, 402 }; GPBInt32Int64Dictionary *dict = - [[GPBInt32Int64Dictionary alloc] initWithValues:kValues + [[GPBInt32Int64Dictionary alloc] initWithInt64s:kValues forKeys:kKeys count:GPBARRAYSIZE(kValues)]; XCTAssertNotNil(dict); XCTAssertEqual(dict.count, 3U); int64_t value; - XCTAssertTrue([dict valueForKey:11 value:NULL]); - XCTAssertTrue([dict valueForKey:11 value:&value]); + XCTAssertTrue([dict getInt64:NULL forKey:11]); + XCTAssertTrue([dict getInt64:&value forKey:11]); XCTAssertEqual(value, 400); - XCTAssertTrue([dict valueForKey:12 value:NULL]); - XCTAssertTrue([dict valueForKey:12 value:&value]); + XCTAssertTrue([dict getInt64:NULL forKey:12]); + XCTAssertTrue([dict getInt64:&value forKey:12]); XCTAssertEqual(value, 401); - XCTAssertTrue([dict valueForKey:13 value:NULL]); - XCTAssertTrue([dict valueForKey:13 value:&value]); + XCTAssertTrue([dict getInt64:NULL forKey:13]); + XCTAssertTrue([dict getInt64:&value forKey:13]); XCTAssertEqual(value, 402); - XCTAssertFalse([dict valueForKey:14 value:NULL]); + XCTAssertFalse([dict getInt64:NULL forKey:14]); __block NSUInteger idx = 0; int32_t *seenKeys = malloc(3 * sizeof(int32_t)); int64_t *seenValues = malloc(3 * sizeof(int64_t)); - [dict enumerateKeysAndValuesUsingBlock:^(int32_t aKey, int64_t aValue, BOOL *stop) { + [dict enumerateKeysAndInt64sUsingBlock:^(int32_t aKey, int64_t aValue, BOOL *stop) { XCTAssertLessThan(idx, 3U); seenKeys[idx] = aKey; seenValues[idx] = aValue; @@ -1235,7 +1235,7 @@ static BOOL TestingEnum_IsValidValue(int32_t value) { // Stopping the enumeration. idx = 0; - [dict enumerateKeysAndValuesUsingBlock:^(int32_t aKey, int64_t aValue, BOOL *stop) { + [dict enumerateKeysAndInt64sUsingBlock:^(int32_t aKey, int64_t aValue, BOOL *stop) { #pragma unused(aKey, aValue) if (idx == 1) *stop = YES; XCTAssertNotEqual(idx, 2U); @@ -1251,27 +1251,27 @@ static BOOL TestingEnum_IsValidValue(int32_t value) { const int64_t kValues2[] = { 400, 403, 402 }; const int64_t kValues3[] = { 400, 401, 402, 403 }; GPBInt32Int64Dictionary *dict1 = - [[GPBInt32Int64Dictionary alloc] initWithValues:kValues1 + [[GPBInt32Int64Dictionary alloc] initWithInt64s:kValues1 forKeys:kKeys1 count:GPBARRAYSIZE(kValues1)]; XCTAssertNotNil(dict1); GPBInt32Int64Dictionary *dict1prime = - [[GPBInt32Int64Dictionary alloc] initWithValues:kValues1 + [[GPBInt32Int64Dictionary alloc] initWithInt64s:kValues1 forKeys:kKeys1 count:GPBARRAYSIZE(kValues1)]; XCTAssertNotNil(dict1prime); GPBInt32Int64Dictionary *dict2 = - [[GPBInt32Int64Dictionary alloc] initWithValues:kValues2 + [[GPBInt32Int64Dictionary alloc] initWithInt64s:kValues2 forKeys:kKeys1 count:GPBARRAYSIZE(kValues2)]; XCTAssertNotNil(dict2); GPBInt32Int64Dictionary *dict3 = - [[GPBInt32Int64Dictionary alloc] initWithValues:kValues1 + [[GPBInt32Int64Dictionary alloc] initWithInt64s:kValues1 forKeys:kKeys2 count:GPBARRAYSIZE(kValues1)]; XCTAssertNotNil(dict3); GPBInt32Int64Dictionary *dict4 = - [[GPBInt32Int64Dictionary alloc] initWithValues:kValues3 + [[GPBInt32Int64Dictionary alloc] initWithInt64s:kValues3 forKeys:kKeys1 count:GPBARRAYSIZE(kValues3)]; XCTAssertNotNil(dict4); @@ -1302,7 +1302,7 @@ static BOOL TestingEnum_IsValidValue(int32_t value) { const int32_t kKeys[] = { 11, 12, 13, 14 }; const int64_t kValues[] = { 400, 401, 402, 403 }; GPBInt32Int64Dictionary *dict = - [[GPBInt32Int64Dictionary alloc] initWithValues:kValues + [[GPBInt32Int64Dictionary alloc] initWithInt64s:kValues forKeys:kKeys count:GPBARRAYSIZE(kValues)]; XCTAssertNotNil(dict); @@ -1323,7 +1323,7 @@ static BOOL TestingEnum_IsValidValue(int32_t value) { const int32_t kKeys[] = { 11, 12, 13, 14 }; const int64_t kValues[] = { 400, 401, 402, 403 }; GPBInt32Int64Dictionary *dict = - [[GPBInt32Int64Dictionary alloc] initWithValues:kValues + [[GPBInt32Int64Dictionary alloc] initWithInt64s:kValues forKeys:kKeys count:GPBARRAYSIZE(kValues)]; XCTAssertNotNil(dict); @@ -1343,13 +1343,13 @@ static BOOL TestingEnum_IsValidValue(int32_t value) { XCTAssertNotNil(dict); XCTAssertEqual(dict.count, 0U); - [dict setValue:400 forKey:11]; + [dict setInt64:400 forKey:11]; XCTAssertEqual(dict.count, 1U); const int32_t kKeys[] = { 12, 13, 14 }; const int64_t kValues[] = { 401, 402, 403 }; GPBInt32Int64Dictionary *dict2 = - [[GPBInt32Int64Dictionary alloc] initWithValues:kValues + [[GPBInt32Int64Dictionary alloc] initWithInt64s:kValues forKeys:kKeys count:GPBARRAYSIZE(kValues)]; XCTAssertNotNil(dict2); @@ -1357,17 +1357,17 @@ static BOOL TestingEnum_IsValidValue(int32_t value) { XCTAssertEqual(dict.count, 4U); int64_t value; - XCTAssertTrue([dict valueForKey:11 value:NULL]); - XCTAssertTrue([dict valueForKey:11 value:&value]); + XCTAssertTrue([dict getInt64:NULL forKey:11]); + XCTAssertTrue([dict getInt64:&value forKey:11]); XCTAssertEqual(value, 400); - XCTAssertTrue([dict valueForKey:12 value:NULL]); - XCTAssertTrue([dict valueForKey:12 value:&value]); + XCTAssertTrue([dict getInt64:NULL forKey:12]); + XCTAssertTrue([dict getInt64:&value forKey:12]); XCTAssertEqual(value, 401); - XCTAssertTrue([dict valueForKey:13 value:NULL]); - XCTAssertTrue([dict valueForKey:13 value:&value]); + XCTAssertTrue([dict getInt64:NULL forKey:13]); + XCTAssertTrue([dict getInt64:&value forKey:13]); XCTAssertEqual(value, 402); - XCTAssertTrue([dict valueForKey:14 value:NULL]); - XCTAssertTrue([dict valueForKey:14 value:&value]); + XCTAssertTrue([dict getInt64:NULL forKey:14]); + XCTAssertTrue([dict getInt64:&value forKey:14]); XCTAssertEqual(value, 403); [dict2 release]; } @@ -1376,57 +1376,57 @@ static BOOL TestingEnum_IsValidValue(int32_t value) { const int32_t kKeys[] = { 11, 12, 13, 14 }; const int64_t kValues[] = { 400, 401, 402, 403 }; GPBInt32Int64Dictionary *dict = - [[GPBInt32Int64Dictionary alloc] initWithValues:kValues - forKeys:kKeys - count:GPBARRAYSIZE(kValues)]; + [[GPBInt32Int64Dictionary alloc] initWithInt64s:kValues + forKeys:kKeys + count:GPBARRAYSIZE(kValues)]; XCTAssertNotNil(dict); XCTAssertEqual(dict.count, 4U); - [dict removeValueForKey:12]; + [dict removeInt64ForKey:12]; XCTAssertEqual(dict.count, 3U); int64_t value; - XCTAssertTrue([dict valueForKey:11 value:NULL]); - XCTAssertTrue([dict valueForKey:11 value:&value]); + XCTAssertTrue([dict getInt64:NULL forKey:11]); + XCTAssertTrue([dict getInt64:&value forKey:11]); XCTAssertEqual(value, 400); - XCTAssertFalse([dict valueForKey:12 value:NULL]); - XCTAssertTrue([dict valueForKey:13 value:NULL]); - XCTAssertTrue([dict valueForKey:13 value:&value]); + XCTAssertFalse([dict getInt64:NULL forKey:12]); + XCTAssertTrue([dict getInt64:NULL forKey:13]); + XCTAssertTrue([dict getInt64:&value forKey:13]); XCTAssertEqual(value, 402); - XCTAssertTrue([dict valueForKey:14 value:NULL]); - XCTAssertTrue([dict valueForKey:14 value:&value]); + XCTAssertTrue([dict getInt64:NULL forKey:14]); + XCTAssertTrue([dict getInt64:&value forKey:14]); XCTAssertEqual(value, 403); // Remove again does nothing. - [dict removeValueForKey:12]; + [dict removeInt64ForKey:12]; XCTAssertEqual(dict.count, 3U); - XCTAssertTrue([dict valueForKey:11 value:NULL]); - XCTAssertTrue([dict valueForKey:11 value:&value]); + XCTAssertTrue([dict getInt64:NULL forKey:11]); + XCTAssertTrue([dict getInt64:&value forKey:11]); XCTAssertEqual(value, 400); - XCTAssertFalse([dict valueForKey:12 value:NULL]); - XCTAssertTrue([dict valueForKey:13 value:NULL]); - XCTAssertTrue([dict valueForKey:13 value:&value]); + XCTAssertFalse([dict getInt64:NULL forKey:12]); + XCTAssertTrue([dict getInt64:NULL forKey:13]); + XCTAssertTrue([dict getInt64:&value forKey:13]); XCTAssertEqual(value, 402); - XCTAssertTrue([dict valueForKey:14 value:NULL]); - XCTAssertTrue([dict valueForKey:14 value:&value]); + XCTAssertTrue([dict getInt64:NULL forKey:14]); + XCTAssertTrue([dict getInt64:&value forKey:14]); XCTAssertEqual(value, 403); - [dict removeValueForKey:14]; + [dict removeInt64ForKey:14]; XCTAssertEqual(dict.count, 2U); - XCTAssertTrue([dict valueForKey:11 value:NULL]); - XCTAssertTrue([dict valueForKey:11 value:&value]); + XCTAssertTrue([dict getInt64:NULL forKey:11]); + XCTAssertTrue([dict getInt64:&value forKey:11]); XCTAssertEqual(value, 400); - XCTAssertFalse([dict valueForKey:12 value:NULL]); - XCTAssertTrue([dict valueForKey:13 value:NULL]); - XCTAssertTrue([dict valueForKey:13 value:&value]); + XCTAssertFalse([dict getInt64:NULL forKey:12]); + XCTAssertTrue([dict getInt64:NULL forKey:13]); + XCTAssertTrue([dict getInt64:&value forKey:13]); XCTAssertEqual(value, 402); - XCTAssertFalse([dict valueForKey:14 value:NULL]); + XCTAssertFalse([dict getInt64:NULL forKey:14]); [dict removeAll]; XCTAssertEqual(dict.count, 0U); - XCTAssertFalse([dict valueForKey:11 value:NULL]); - XCTAssertFalse([dict valueForKey:12 value:NULL]); - XCTAssertFalse([dict valueForKey:13 value:NULL]); - XCTAssertFalse([dict valueForKey:14 value:NULL]); + XCTAssertFalse([dict getInt64:NULL forKey:11]); + XCTAssertFalse([dict getInt64:NULL forKey:12]); + XCTAssertFalse([dict getInt64:NULL forKey:13]); + XCTAssertFalse([dict getInt64:NULL forKey:14]); [dict release]; } @@ -1434,75 +1434,75 @@ static BOOL TestingEnum_IsValidValue(int32_t value) { const int32_t kKeys[] = { 11, 12, 13, 14 }; const int64_t kValues[] = { 400, 401, 402, 403 }; GPBInt32Int64Dictionary *dict = - [[GPBInt32Int64Dictionary alloc] initWithValues:kValues - forKeys:kKeys - count:GPBARRAYSIZE(kValues)]; + [[GPBInt32Int64Dictionary alloc] initWithInt64s:kValues + forKeys:kKeys + count:GPBARRAYSIZE(kValues)]; XCTAssertNotNil(dict); XCTAssertEqual(dict.count, 4U); int64_t value; - XCTAssertTrue([dict valueForKey:11 value:NULL]); - XCTAssertTrue([dict valueForKey:11 value:&value]); + XCTAssertTrue([dict getInt64:NULL forKey:11]); + XCTAssertTrue([dict getInt64:&value forKey:11]); XCTAssertEqual(value, 400); - XCTAssertTrue([dict valueForKey:12 value:NULL]); - XCTAssertTrue([dict valueForKey:12 value:&value]); + XCTAssertTrue([dict getInt64:NULL forKey:12]); + XCTAssertTrue([dict getInt64:&value forKey:12]); XCTAssertEqual(value, 401); - XCTAssertTrue([dict valueForKey:13 value:NULL]); - XCTAssertTrue([dict valueForKey:13 value:&value]); + XCTAssertTrue([dict getInt64:NULL forKey:13]); + XCTAssertTrue([dict getInt64:&value forKey:13]); XCTAssertEqual(value, 402); - XCTAssertTrue([dict valueForKey:14 value:NULL]); - XCTAssertTrue([dict valueForKey:14 value:&value]); + XCTAssertTrue([dict getInt64:NULL forKey:14]); + XCTAssertTrue([dict getInt64:&value forKey:14]); XCTAssertEqual(value, 403); - [dict setValue:403 forKey:11]; + [dict setInt64:403 forKey:11]; XCTAssertEqual(dict.count, 4U); - XCTAssertTrue([dict valueForKey:11 value:NULL]); - XCTAssertTrue([dict valueForKey:11 value:&value]); + XCTAssertTrue([dict getInt64:NULL forKey:11]); + XCTAssertTrue([dict getInt64:&value forKey:11]); XCTAssertEqual(value, 403); - XCTAssertTrue([dict valueForKey:12 value:NULL]); - XCTAssertTrue([dict valueForKey:12 value:&value]); + XCTAssertTrue([dict getInt64:NULL forKey:12]); + XCTAssertTrue([dict getInt64:&value forKey:12]); XCTAssertEqual(value, 401); - XCTAssertTrue([dict valueForKey:13 value:NULL]); - XCTAssertTrue([dict valueForKey:13 value:&value]); + XCTAssertTrue([dict getInt64:NULL forKey:13]); + XCTAssertTrue([dict getInt64:&value forKey:13]); XCTAssertEqual(value, 402); - XCTAssertTrue([dict valueForKey:14 value:NULL]); - XCTAssertTrue([dict valueForKey:14 value:&value]); + XCTAssertTrue([dict getInt64:NULL forKey:14]); + XCTAssertTrue([dict getInt64:&value forKey:14]); XCTAssertEqual(value, 403); - [dict setValue:401 forKey:14]; + [dict setInt64:401 forKey:14]; XCTAssertEqual(dict.count, 4U); - XCTAssertTrue([dict valueForKey:11 value:NULL]); - XCTAssertTrue([dict valueForKey:11 value:&value]); + XCTAssertTrue([dict getInt64:NULL forKey:11]); + XCTAssertTrue([dict getInt64:&value forKey:11]); XCTAssertEqual(value, 403); - XCTAssertTrue([dict valueForKey:12 value:NULL]); - XCTAssertTrue([dict valueForKey:12 value:&value]); + XCTAssertTrue([dict getInt64:NULL forKey:12]); + XCTAssertTrue([dict getInt64:&value forKey:12]); XCTAssertEqual(value, 401); - XCTAssertTrue([dict valueForKey:13 value:NULL]); - XCTAssertTrue([dict valueForKey:13 value:&value]); + XCTAssertTrue([dict getInt64:NULL forKey:13]); + XCTAssertTrue([dict getInt64:&value forKey:13]); XCTAssertEqual(value, 402); - XCTAssertTrue([dict valueForKey:14 value:NULL]); - XCTAssertTrue([dict valueForKey:14 value:&value]); + XCTAssertTrue([dict getInt64:NULL forKey:14]); + XCTAssertTrue([dict getInt64:&value forKey:14]); XCTAssertEqual(value, 401); const int32_t kKeys2[] = { 12, 13 }; const int64_t kValues2[] = { 402, 400 }; GPBInt32Int64Dictionary *dict2 = - [[GPBInt32Int64Dictionary alloc] initWithValues:kValues2 + [[GPBInt32Int64Dictionary alloc] initWithInt64s:kValues2 forKeys:kKeys2 count:GPBARRAYSIZE(kValues2)]; XCTAssertNotNil(dict2); [dict addEntriesFromDictionary:dict2]; XCTAssertEqual(dict.count, 4U); - XCTAssertTrue([dict valueForKey:11 value:NULL]); - XCTAssertTrue([dict valueForKey:11 value:&value]); + XCTAssertTrue([dict getInt64:NULL forKey:11]); + XCTAssertTrue([dict getInt64:&value forKey:11]); XCTAssertEqual(value, 403); - XCTAssertTrue([dict valueForKey:12 value:NULL]); - XCTAssertTrue([dict valueForKey:12 value:&value]); + XCTAssertTrue([dict getInt64:NULL forKey:12]); + XCTAssertTrue([dict getInt64:&value forKey:12]); XCTAssertEqual(value, 402); - XCTAssertTrue([dict valueForKey:13 value:NULL]); - XCTAssertTrue([dict valueForKey:13 value:&value]); + XCTAssertTrue([dict getInt64:NULL forKey:13]); + XCTAssertTrue([dict getInt64:&value forKey:13]); XCTAssertEqual(value, 400); - XCTAssertTrue([dict valueForKey:14 value:NULL]); - XCTAssertTrue([dict valueForKey:14 value:&value]); + XCTAssertTrue([dict getInt64:NULL forKey:14]); + XCTAssertTrue([dict getInt64:&value forKey:14]); XCTAssertEqual(value, 401); [dict2 release]; @@ -1522,8 +1522,8 @@ static BOOL TestingEnum_IsValidValue(int32_t value) { GPBInt32BoolDictionary *dict = [[GPBInt32BoolDictionary alloc] init]; XCTAssertNotNil(dict); XCTAssertEqual(dict.count, 0U); - XCTAssertFalse([dict valueForKey:11 value:NULL]); - [dict enumerateKeysAndValuesUsingBlock:^(int32_t aKey, BOOL aValue, BOOL *stop) { + XCTAssertFalse([dict getBool:NULL forKey:11]); + [dict enumerateKeysAndBoolsUsingBlock:^(int32_t aKey, BOOL aValue, BOOL *stop) { #pragma unused(aKey, aValue, stop) XCTFail(@"Shouldn't get here!"); }]; @@ -1531,15 +1531,15 @@ static BOOL TestingEnum_IsValidValue(int32_t value) { } - (void)testOne { - GPBInt32BoolDictionary *dict = [GPBInt32BoolDictionary dictionaryWithValue:YES forKey:11]; + GPBInt32BoolDictionary *dict = [GPBInt32BoolDictionary dictionaryWithBool:YES forKey:11]; XCTAssertNotNil(dict); XCTAssertEqual(dict.count, 1U); BOOL value; - XCTAssertTrue([dict valueForKey:11 value:NULL]); - XCTAssertTrue([dict valueForKey:11 value:&value]); + XCTAssertTrue([dict getBool:NULL forKey:11]); + XCTAssertTrue([dict getBool:&value forKey:11]); XCTAssertEqual(value, YES); - XCTAssertFalse([dict valueForKey:12 value:NULL]); - [dict enumerateKeysAndValuesUsingBlock:^(int32_t aKey, BOOL aValue, BOOL *stop) { + XCTAssertFalse([dict getBool:NULL forKey:12]); + [dict enumerateKeysAndBoolsUsingBlock:^(int32_t aKey, BOOL aValue, BOOL *stop) { XCTAssertEqual(aKey, 11); XCTAssertEqual(aValue, YES); XCTAssertNotEqual(stop, NULL); @@ -1550,27 +1550,27 @@ static BOOL TestingEnum_IsValidValue(int32_t value) { const int32_t kKeys[] = { 11, 12, 13 }; const BOOL kValues[] = { YES, YES, NO }; GPBInt32BoolDictionary *dict = - [[GPBInt32BoolDictionary alloc] initWithValues:kValues - forKeys:kKeys - count:GPBARRAYSIZE(kValues)]; + [[GPBInt32BoolDictionary alloc] initWithBools:kValues + forKeys:kKeys + count:GPBARRAYSIZE(kValues)]; XCTAssertNotNil(dict); XCTAssertEqual(dict.count, 3U); BOOL value; - XCTAssertTrue([dict valueForKey:11 value:NULL]); - XCTAssertTrue([dict valueForKey:11 value:&value]); + XCTAssertTrue([dict getBool:NULL forKey:11]); + XCTAssertTrue([dict getBool:&value forKey:11]); XCTAssertEqual(value, YES); - XCTAssertTrue([dict valueForKey:12 value:NULL]); - XCTAssertTrue([dict valueForKey:12 value:&value]); + XCTAssertTrue([dict getBool:NULL forKey:12]); + XCTAssertTrue([dict getBool:&value forKey:12]); XCTAssertEqual(value, YES); - XCTAssertTrue([dict valueForKey:13 value:NULL]); - XCTAssertTrue([dict valueForKey:13 value:&value]); + XCTAssertTrue([dict getBool:NULL forKey:13]); + XCTAssertTrue([dict getBool:&value forKey:13]); XCTAssertEqual(value, NO); - XCTAssertFalse([dict valueForKey:14 value:NULL]); + XCTAssertFalse([dict getBool:NULL forKey:14]); __block NSUInteger idx = 0; int32_t *seenKeys = malloc(3 * sizeof(int32_t)); BOOL *seenValues = malloc(3 * sizeof(BOOL)); - [dict enumerateKeysAndValuesUsingBlock:^(int32_t aKey, BOOL aValue, BOOL *stop) { + [dict enumerateKeysAndBoolsUsingBlock:^(int32_t aKey, BOOL aValue, BOOL *stop) { XCTAssertLessThan(idx, 3U); seenKeys[idx] = aKey; seenValues[idx] = aValue; @@ -1592,7 +1592,7 @@ static BOOL TestingEnum_IsValidValue(int32_t value) { // Stopping the enumeration. idx = 0; - [dict enumerateKeysAndValuesUsingBlock:^(int32_t aKey, BOOL aValue, BOOL *stop) { + [dict enumerateKeysAndBoolsUsingBlock:^(int32_t aKey, BOOL aValue, BOOL *stop) { #pragma unused(aKey, aValue) if (idx == 1) *stop = YES; XCTAssertNotEqual(idx, 2U); @@ -1608,29 +1608,29 @@ static BOOL TestingEnum_IsValidValue(int32_t value) { const BOOL kValues2[] = { YES, NO, NO }; const BOOL kValues3[] = { YES, YES, NO, NO }; GPBInt32BoolDictionary *dict1 = - [[GPBInt32BoolDictionary alloc] initWithValues:kValues1 - forKeys:kKeys1 - count:GPBARRAYSIZE(kValues1)]; + [[GPBInt32BoolDictionary alloc] initWithBools:kValues1 + forKeys:kKeys1 + count:GPBARRAYSIZE(kValues1)]; XCTAssertNotNil(dict1); GPBInt32BoolDictionary *dict1prime = - [[GPBInt32BoolDictionary alloc] initWithValues:kValues1 - forKeys:kKeys1 - count:GPBARRAYSIZE(kValues1)]; + [[GPBInt32BoolDictionary alloc] initWithBools:kValues1 + forKeys:kKeys1 + count:GPBARRAYSIZE(kValues1)]; XCTAssertNotNil(dict1prime); GPBInt32BoolDictionary *dict2 = - [[GPBInt32BoolDictionary alloc] initWithValues:kValues2 - forKeys:kKeys1 - count:GPBARRAYSIZE(kValues2)]; + [[GPBInt32BoolDictionary alloc] initWithBools:kValues2 + forKeys:kKeys1 + count:GPBARRAYSIZE(kValues2)]; XCTAssertNotNil(dict2); GPBInt32BoolDictionary *dict3 = - [[GPBInt32BoolDictionary alloc] initWithValues:kValues1 - forKeys:kKeys2 - count:GPBARRAYSIZE(kValues1)]; + [[GPBInt32BoolDictionary alloc] initWithBools:kValues1 + forKeys:kKeys2 + count:GPBARRAYSIZE(kValues1)]; XCTAssertNotNil(dict3); GPBInt32BoolDictionary *dict4 = - [[GPBInt32BoolDictionary alloc] initWithValues:kValues3 - forKeys:kKeys1 - count:GPBARRAYSIZE(kValues3)]; + [[GPBInt32BoolDictionary alloc] initWithBools:kValues3 + forKeys:kKeys1 + count:GPBARRAYSIZE(kValues3)]; XCTAssertNotNil(dict4); // 1/1Prime should be different objects, but equal. @@ -1659,9 +1659,9 @@ static BOOL TestingEnum_IsValidValue(int32_t value) { const int32_t kKeys[] = { 11, 12, 13, 14 }; const BOOL kValues[] = { YES, YES, NO, NO }; GPBInt32BoolDictionary *dict = - [[GPBInt32BoolDictionary alloc] initWithValues:kValues - forKeys:kKeys - count:GPBARRAYSIZE(kValues)]; + [[GPBInt32BoolDictionary alloc] initWithBools:kValues + forKeys:kKeys + count:GPBARRAYSIZE(kValues)]; XCTAssertNotNil(dict); GPBInt32BoolDictionary *dict2 = [dict copy]; @@ -1680,9 +1680,9 @@ static BOOL TestingEnum_IsValidValue(int32_t value) { const int32_t kKeys[] = { 11, 12, 13, 14 }; const BOOL kValues[] = { YES, YES, NO, NO }; GPBInt32BoolDictionary *dict = - [[GPBInt32BoolDictionary alloc] initWithValues:kValues - forKeys:kKeys - count:GPBARRAYSIZE(kValues)]; + [[GPBInt32BoolDictionary alloc] initWithBools:kValues + forKeys:kKeys + count:GPBARRAYSIZE(kValues)]; XCTAssertNotNil(dict); GPBInt32BoolDictionary *dict2 = @@ -1700,31 +1700,31 @@ static BOOL TestingEnum_IsValidValue(int32_t value) { XCTAssertNotNil(dict); XCTAssertEqual(dict.count, 0U); - [dict setValue:YES forKey:11]; + [dict setBool:YES forKey:11]; XCTAssertEqual(dict.count, 1U); const int32_t kKeys[] = { 12, 13, 14 }; const BOOL kValues[] = { YES, NO, NO }; GPBInt32BoolDictionary *dict2 = - [[GPBInt32BoolDictionary alloc] initWithValues:kValues - forKeys:kKeys - count:GPBARRAYSIZE(kValues)]; + [[GPBInt32BoolDictionary alloc] initWithBools:kValues + forKeys:kKeys + count:GPBARRAYSIZE(kValues)]; XCTAssertNotNil(dict2); [dict addEntriesFromDictionary:dict2]; XCTAssertEqual(dict.count, 4U); BOOL value; - XCTAssertTrue([dict valueForKey:11 value:NULL]); - XCTAssertTrue([dict valueForKey:11 value:&value]); + XCTAssertTrue([dict getBool:NULL forKey:11]); + XCTAssertTrue([dict getBool:&value forKey:11]); XCTAssertEqual(value, YES); - XCTAssertTrue([dict valueForKey:12 value:NULL]); - XCTAssertTrue([dict valueForKey:12 value:&value]); + XCTAssertTrue([dict getBool:NULL forKey:12]); + XCTAssertTrue([dict getBool:&value forKey:12]); XCTAssertEqual(value, YES); - XCTAssertTrue([dict valueForKey:13 value:NULL]); - XCTAssertTrue([dict valueForKey:13 value:&value]); + XCTAssertTrue([dict getBool:NULL forKey:13]); + XCTAssertTrue([dict getBool:&value forKey:13]); XCTAssertEqual(value, NO); - XCTAssertTrue([dict valueForKey:14 value:NULL]); - XCTAssertTrue([dict valueForKey:14 value:&value]); + XCTAssertTrue([dict getBool:NULL forKey:14]); + XCTAssertTrue([dict getBool:&value forKey:14]); XCTAssertEqual(value, NO); [dict2 release]; } @@ -1733,57 +1733,57 @@ static BOOL TestingEnum_IsValidValue(int32_t value) { const int32_t kKeys[] = { 11, 12, 13, 14 }; const BOOL kValues[] = { YES, YES, NO, NO }; GPBInt32BoolDictionary *dict = - [[GPBInt32BoolDictionary alloc] initWithValues:kValues - forKeys:kKeys - count:GPBARRAYSIZE(kValues)]; + [[GPBInt32BoolDictionary alloc] initWithBools:kValues + forKeys:kKeys + count:GPBARRAYSIZE(kValues)]; XCTAssertNotNil(dict); XCTAssertEqual(dict.count, 4U); - [dict removeValueForKey:12]; + [dict removeBoolForKey:12]; XCTAssertEqual(dict.count, 3U); BOOL value; - XCTAssertTrue([dict valueForKey:11 value:NULL]); - XCTAssertTrue([dict valueForKey:11 value:&value]); + XCTAssertTrue([dict getBool:NULL forKey:11]); + XCTAssertTrue([dict getBool:&value forKey:11]); XCTAssertEqual(value, YES); - XCTAssertFalse([dict valueForKey:12 value:NULL]); - XCTAssertTrue([dict valueForKey:13 value:NULL]); - XCTAssertTrue([dict valueForKey:13 value:&value]); + XCTAssertFalse([dict getBool:NULL forKey:12]); + XCTAssertTrue([dict getBool:NULL forKey:13]); + XCTAssertTrue([dict getBool:&value forKey:13]); XCTAssertEqual(value, NO); - XCTAssertTrue([dict valueForKey:14 value:NULL]); - XCTAssertTrue([dict valueForKey:14 value:&value]); + XCTAssertTrue([dict getBool:NULL forKey:14]); + XCTAssertTrue([dict getBool:&value forKey:14]); XCTAssertEqual(value, NO); // Remove again does nothing. - [dict removeValueForKey:12]; + [dict removeBoolForKey:12]; XCTAssertEqual(dict.count, 3U); - XCTAssertTrue([dict valueForKey:11 value:NULL]); - XCTAssertTrue([dict valueForKey:11 value:&value]); + XCTAssertTrue([dict getBool:NULL forKey:11]); + XCTAssertTrue([dict getBool:&value forKey:11]); XCTAssertEqual(value, YES); - XCTAssertFalse([dict valueForKey:12 value:NULL]); - XCTAssertTrue([dict valueForKey:13 value:NULL]); - XCTAssertTrue([dict valueForKey:13 value:&value]); + XCTAssertFalse([dict getBool:NULL forKey:12]); + XCTAssertTrue([dict getBool:NULL forKey:13]); + XCTAssertTrue([dict getBool:&value forKey:13]); XCTAssertEqual(value, NO); - XCTAssertTrue([dict valueForKey:14 value:NULL]); - XCTAssertTrue([dict valueForKey:14 value:&value]); + XCTAssertTrue([dict getBool:NULL forKey:14]); + XCTAssertTrue([dict getBool:&value forKey:14]); XCTAssertEqual(value, NO); - [dict removeValueForKey:14]; + [dict removeBoolForKey:14]; XCTAssertEqual(dict.count, 2U); - XCTAssertTrue([dict valueForKey:11 value:NULL]); - XCTAssertTrue([dict valueForKey:11 value:&value]); + XCTAssertTrue([dict getBool:NULL forKey:11]); + XCTAssertTrue([dict getBool:&value forKey:11]); XCTAssertEqual(value, YES); - XCTAssertFalse([dict valueForKey:12 value:NULL]); - XCTAssertTrue([dict valueForKey:13 value:NULL]); - XCTAssertTrue([dict valueForKey:13 value:&value]); + XCTAssertFalse([dict getBool:NULL forKey:12]); + XCTAssertTrue([dict getBool:NULL forKey:13]); + XCTAssertTrue([dict getBool:&value forKey:13]); XCTAssertEqual(value, NO); - XCTAssertFalse([dict valueForKey:14 value:NULL]); + XCTAssertFalse([dict getBool:NULL forKey:14]); [dict removeAll]; XCTAssertEqual(dict.count, 0U); - XCTAssertFalse([dict valueForKey:11 value:NULL]); - XCTAssertFalse([dict valueForKey:12 value:NULL]); - XCTAssertFalse([dict valueForKey:13 value:NULL]); - XCTAssertFalse([dict valueForKey:14 value:NULL]); + XCTAssertFalse([dict getBool:NULL forKey:11]); + XCTAssertFalse([dict getBool:NULL forKey:12]); + XCTAssertFalse([dict getBool:NULL forKey:13]); + XCTAssertFalse([dict getBool:NULL forKey:14]); [dict release]; } @@ -1791,75 +1791,75 @@ static BOOL TestingEnum_IsValidValue(int32_t value) { const int32_t kKeys[] = { 11, 12, 13, 14 }; const BOOL kValues[] = { YES, YES, NO, NO }; GPBInt32BoolDictionary *dict = - [[GPBInt32BoolDictionary alloc] initWithValues:kValues - forKeys:kKeys - count:GPBARRAYSIZE(kValues)]; + [[GPBInt32BoolDictionary alloc] initWithBools:kValues + forKeys:kKeys + count:GPBARRAYSIZE(kValues)]; XCTAssertNotNil(dict); XCTAssertEqual(dict.count, 4U); BOOL value; - XCTAssertTrue([dict valueForKey:11 value:NULL]); - XCTAssertTrue([dict valueForKey:11 value:&value]); + XCTAssertTrue([dict getBool:NULL forKey:11]); + XCTAssertTrue([dict getBool:&value forKey:11]); XCTAssertEqual(value, YES); - XCTAssertTrue([dict valueForKey:12 value:NULL]); - XCTAssertTrue([dict valueForKey:12 value:&value]); + XCTAssertTrue([dict getBool:NULL forKey:12]); + XCTAssertTrue([dict getBool:&value forKey:12]); XCTAssertEqual(value, YES); - XCTAssertTrue([dict valueForKey:13 value:NULL]); - XCTAssertTrue([dict valueForKey:13 value:&value]); + XCTAssertTrue([dict getBool:NULL forKey:13]); + XCTAssertTrue([dict getBool:&value forKey:13]); XCTAssertEqual(value, NO); - XCTAssertTrue([dict valueForKey:14 value:NULL]); - XCTAssertTrue([dict valueForKey:14 value:&value]); + XCTAssertTrue([dict getBool:NULL forKey:14]); + XCTAssertTrue([dict getBool:&value forKey:14]); XCTAssertEqual(value, NO); - [dict setValue:NO forKey:11]; + [dict setBool:NO forKey:11]; XCTAssertEqual(dict.count, 4U); - XCTAssertTrue([dict valueForKey:11 value:NULL]); - XCTAssertTrue([dict valueForKey:11 value:&value]); + XCTAssertTrue([dict getBool:NULL forKey:11]); + XCTAssertTrue([dict getBool:&value forKey:11]); XCTAssertEqual(value, NO); - XCTAssertTrue([dict valueForKey:12 value:NULL]); - XCTAssertTrue([dict valueForKey:12 value:&value]); + XCTAssertTrue([dict getBool:NULL forKey:12]); + XCTAssertTrue([dict getBool:&value forKey:12]); XCTAssertEqual(value, YES); - XCTAssertTrue([dict valueForKey:13 value:NULL]); - XCTAssertTrue([dict valueForKey:13 value:&value]); + XCTAssertTrue([dict getBool:NULL forKey:13]); + XCTAssertTrue([dict getBool:&value forKey:13]); XCTAssertEqual(value, NO); - XCTAssertTrue([dict valueForKey:14 value:NULL]); - XCTAssertTrue([dict valueForKey:14 value:&value]); + XCTAssertTrue([dict getBool:NULL forKey:14]); + XCTAssertTrue([dict getBool:&value forKey:14]); XCTAssertEqual(value, NO); - [dict setValue:YES forKey:14]; + [dict setBool:YES forKey:14]; XCTAssertEqual(dict.count, 4U); - XCTAssertTrue([dict valueForKey:11 value:NULL]); - XCTAssertTrue([dict valueForKey:11 value:&value]); + XCTAssertTrue([dict getBool:NULL forKey:11]); + XCTAssertTrue([dict getBool:&value forKey:11]); XCTAssertEqual(value, NO); - XCTAssertTrue([dict valueForKey:12 value:NULL]); - XCTAssertTrue([dict valueForKey:12 value:&value]); + XCTAssertTrue([dict getBool:NULL forKey:12]); + XCTAssertTrue([dict getBool:&value forKey:12]); XCTAssertEqual(value, YES); - XCTAssertTrue([dict valueForKey:13 value:NULL]); - XCTAssertTrue([dict valueForKey:13 value:&value]); + XCTAssertTrue([dict getBool:NULL forKey:13]); + XCTAssertTrue([dict getBool:&value forKey:13]); XCTAssertEqual(value, NO); - XCTAssertTrue([dict valueForKey:14 value:NULL]); - XCTAssertTrue([dict valueForKey:14 value:&value]); + XCTAssertTrue([dict getBool:NULL forKey:14]); + XCTAssertTrue([dict getBool:&value forKey:14]); XCTAssertEqual(value, YES); const int32_t kKeys2[] = { 12, 13 }; const BOOL kValues2[] = { NO, YES }; GPBInt32BoolDictionary *dict2 = - [[GPBInt32BoolDictionary alloc] initWithValues:kValues2 - forKeys:kKeys2 - count:GPBARRAYSIZE(kValues2)]; + [[GPBInt32BoolDictionary alloc] initWithBools:kValues2 + forKeys:kKeys2 + count:GPBARRAYSIZE(kValues2)]; XCTAssertNotNil(dict2); [dict addEntriesFromDictionary:dict2]; XCTAssertEqual(dict.count, 4U); - XCTAssertTrue([dict valueForKey:11 value:NULL]); - XCTAssertTrue([dict valueForKey:11 value:&value]); + XCTAssertTrue([dict getBool:NULL forKey:11]); + XCTAssertTrue([dict getBool:&value forKey:11]); XCTAssertEqual(value, NO); - XCTAssertTrue([dict valueForKey:12 value:NULL]); - XCTAssertTrue([dict valueForKey:12 value:&value]); + XCTAssertTrue([dict getBool:NULL forKey:12]); + XCTAssertTrue([dict getBool:&value forKey:12]); XCTAssertEqual(value, NO); - XCTAssertTrue([dict valueForKey:13 value:NULL]); - XCTAssertTrue([dict valueForKey:13 value:&value]); + XCTAssertTrue([dict getBool:NULL forKey:13]); + XCTAssertTrue([dict getBool:&value forKey:13]); XCTAssertEqual(value, YES); - XCTAssertTrue([dict valueForKey:14 value:NULL]); - XCTAssertTrue([dict valueForKey:14 value:&value]); + XCTAssertTrue([dict getBool:NULL forKey:14]); + XCTAssertTrue([dict getBool:&value forKey:14]); XCTAssertEqual(value, YES); [dict2 release]; @@ -1879,8 +1879,8 @@ static BOOL TestingEnum_IsValidValue(int32_t value) { GPBInt32FloatDictionary *dict = [[GPBInt32FloatDictionary alloc] init]; XCTAssertNotNil(dict); XCTAssertEqual(dict.count, 0U); - XCTAssertFalse([dict valueForKey:11 value:NULL]); - [dict enumerateKeysAndValuesUsingBlock:^(int32_t aKey, float aValue, BOOL *stop) { + XCTAssertFalse([dict getFloat:NULL forKey:11]); + [dict enumerateKeysAndFloatsUsingBlock:^(int32_t aKey, float aValue, BOOL *stop) { #pragma unused(aKey, aValue, stop) XCTFail(@"Shouldn't get here!"); }]; @@ -1888,15 +1888,15 @@ static BOOL TestingEnum_IsValidValue(int32_t value) { } - (void)testOne { - GPBInt32FloatDictionary *dict = [GPBInt32FloatDictionary dictionaryWithValue:500.f forKey:11]; + GPBInt32FloatDictionary *dict = [GPBInt32FloatDictionary dictionaryWithFloat:500.f forKey:11]; XCTAssertNotNil(dict); XCTAssertEqual(dict.count, 1U); float value; - XCTAssertTrue([dict valueForKey:11 value:NULL]); - XCTAssertTrue([dict valueForKey:11 value:&value]); + XCTAssertTrue([dict getFloat:NULL forKey:11]); + XCTAssertTrue([dict getFloat:&value forKey:11]); XCTAssertEqual(value, 500.f); - XCTAssertFalse([dict valueForKey:12 value:NULL]); - [dict enumerateKeysAndValuesUsingBlock:^(int32_t aKey, float aValue, BOOL *stop) { + XCTAssertFalse([dict getFloat:NULL forKey:12]); + [dict enumerateKeysAndFloatsUsingBlock:^(int32_t aKey, float aValue, BOOL *stop) { XCTAssertEqual(aKey, 11); XCTAssertEqual(aValue, 500.f); XCTAssertNotEqual(stop, NULL); @@ -1907,27 +1907,27 @@ static BOOL TestingEnum_IsValidValue(int32_t value) { const int32_t kKeys[] = { 11, 12, 13 }; const float kValues[] = { 500.f, 501.f, 502.f }; GPBInt32FloatDictionary *dict = - [[GPBInt32FloatDictionary alloc] initWithValues:kValues + [[GPBInt32FloatDictionary alloc] initWithFloats:kValues forKeys:kKeys count:GPBARRAYSIZE(kValues)]; XCTAssertNotNil(dict); XCTAssertEqual(dict.count, 3U); float value; - XCTAssertTrue([dict valueForKey:11 value:NULL]); - XCTAssertTrue([dict valueForKey:11 value:&value]); + XCTAssertTrue([dict getFloat:NULL forKey:11]); + XCTAssertTrue([dict getFloat:&value forKey:11]); XCTAssertEqual(value, 500.f); - XCTAssertTrue([dict valueForKey:12 value:NULL]); - XCTAssertTrue([dict valueForKey:12 value:&value]); + XCTAssertTrue([dict getFloat:NULL forKey:12]); + XCTAssertTrue([dict getFloat:&value forKey:12]); XCTAssertEqual(value, 501.f); - XCTAssertTrue([dict valueForKey:13 value:NULL]); - XCTAssertTrue([dict valueForKey:13 value:&value]); + XCTAssertTrue([dict getFloat:NULL forKey:13]); + XCTAssertTrue([dict getFloat:&value forKey:13]); XCTAssertEqual(value, 502.f); - XCTAssertFalse([dict valueForKey:14 value:NULL]); + XCTAssertFalse([dict getFloat:NULL forKey:14]); __block NSUInteger idx = 0; int32_t *seenKeys = malloc(3 * sizeof(int32_t)); float *seenValues = malloc(3 * sizeof(float)); - [dict enumerateKeysAndValuesUsingBlock:^(int32_t aKey, float aValue, BOOL *stop) { + [dict enumerateKeysAndFloatsUsingBlock:^(int32_t aKey, float aValue, BOOL *stop) { XCTAssertLessThan(idx, 3U); seenKeys[idx] = aKey; seenValues[idx] = aValue; @@ -1949,7 +1949,7 @@ static BOOL TestingEnum_IsValidValue(int32_t value) { // Stopping the enumeration. idx = 0; - [dict enumerateKeysAndValuesUsingBlock:^(int32_t aKey, float aValue, BOOL *stop) { + [dict enumerateKeysAndFloatsUsingBlock:^(int32_t aKey, float aValue, BOOL *stop) { #pragma unused(aKey, aValue) if (idx == 1) *stop = YES; XCTAssertNotEqual(idx, 2U); @@ -1965,27 +1965,27 @@ static BOOL TestingEnum_IsValidValue(int32_t value) { const float kValues2[] = { 500.f, 503.f, 502.f }; const float kValues3[] = { 500.f, 501.f, 502.f, 503.f }; GPBInt32FloatDictionary *dict1 = - [[GPBInt32FloatDictionary alloc] initWithValues:kValues1 + [[GPBInt32FloatDictionary alloc] initWithFloats:kValues1 forKeys:kKeys1 count:GPBARRAYSIZE(kValues1)]; XCTAssertNotNil(dict1); GPBInt32FloatDictionary *dict1prime = - [[GPBInt32FloatDictionary alloc] initWithValues:kValues1 + [[GPBInt32FloatDictionary alloc] initWithFloats:kValues1 forKeys:kKeys1 count:GPBARRAYSIZE(kValues1)]; XCTAssertNotNil(dict1prime); GPBInt32FloatDictionary *dict2 = - [[GPBInt32FloatDictionary alloc] initWithValues:kValues2 + [[GPBInt32FloatDictionary alloc] initWithFloats:kValues2 forKeys:kKeys1 count:GPBARRAYSIZE(kValues2)]; XCTAssertNotNil(dict2); GPBInt32FloatDictionary *dict3 = - [[GPBInt32FloatDictionary alloc] initWithValues:kValues1 + [[GPBInt32FloatDictionary alloc] initWithFloats:kValues1 forKeys:kKeys2 count:GPBARRAYSIZE(kValues1)]; XCTAssertNotNil(dict3); GPBInt32FloatDictionary *dict4 = - [[GPBInt32FloatDictionary alloc] initWithValues:kValues3 + [[GPBInt32FloatDictionary alloc] initWithFloats:kValues3 forKeys:kKeys1 count:GPBARRAYSIZE(kValues3)]; XCTAssertNotNil(dict4); @@ -2016,7 +2016,7 @@ static BOOL TestingEnum_IsValidValue(int32_t value) { const int32_t kKeys[] = { 11, 12, 13, 14 }; const float kValues[] = { 500.f, 501.f, 502.f, 503.f }; GPBInt32FloatDictionary *dict = - [[GPBInt32FloatDictionary alloc] initWithValues:kValues + [[GPBInt32FloatDictionary alloc] initWithFloats:kValues forKeys:kKeys count:GPBARRAYSIZE(kValues)]; XCTAssertNotNil(dict); @@ -2037,7 +2037,7 @@ static BOOL TestingEnum_IsValidValue(int32_t value) { const int32_t kKeys[] = { 11, 12, 13, 14 }; const float kValues[] = { 500.f, 501.f, 502.f, 503.f }; GPBInt32FloatDictionary *dict = - [[GPBInt32FloatDictionary alloc] initWithValues:kValues + [[GPBInt32FloatDictionary alloc] initWithFloats:kValues forKeys:kKeys count:GPBARRAYSIZE(kValues)]; XCTAssertNotNil(dict); @@ -2057,13 +2057,13 @@ static BOOL TestingEnum_IsValidValue(int32_t value) { XCTAssertNotNil(dict); XCTAssertEqual(dict.count, 0U); - [dict setValue:500.f forKey:11]; + [dict setFloat:500.f forKey:11]; XCTAssertEqual(dict.count, 1U); const int32_t kKeys[] = { 12, 13, 14 }; const float kValues[] = { 501.f, 502.f, 503.f }; GPBInt32FloatDictionary *dict2 = - [[GPBInt32FloatDictionary alloc] initWithValues:kValues + [[GPBInt32FloatDictionary alloc] initWithFloats:kValues forKeys:kKeys count:GPBARRAYSIZE(kValues)]; XCTAssertNotNil(dict2); @@ -2071,17 +2071,17 @@ static BOOL TestingEnum_IsValidValue(int32_t value) { XCTAssertEqual(dict.count, 4U); float value; - XCTAssertTrue([dict valueForKey:11 value:NULL]); - XCTAssertTrue([dict valueForKey:11 value:&value]); + XCTAssertTrue([dict getFloat:NULL forKey:11]); + XCTAssertTrue([dict getFloat:&value forKey:11]); XCTAssertEqual(value, 500.f); - XCTAssertTrue([dict valueForKey:12 value:NULL]); - XCTAssertTrue([dict valueForKey:12 value:&value]); + XCTAssertTrue([dict getFloat:NULL forKey:12]); + XCTAssertTrue([dict getFloat:&value forKey:12]); XCTAssertEqual(value, 501.f); - XCTAssertTrue([dict valueForKey:13 value:NULL]); - XCTAssertTrue([dict valueForKey:13 value:&value]); + XCTAssertTrue([dict getFloat:NULL forKey:13]); + XCTAssertTrue([dict getFloat:&value forKey:13]); XCTAssertEqual(value, 502.f); - XCTAssertTrue([dict valueForKey:14 value:NULL]); - XCTAssertTrue([dict valueForKey:14 value:&value]); + XCTAssertTrue([dict getFloat:NULL forKey:14]); + XCTAssertTrue([dict getFloat:&value forKey:14]); XCTAssertEqual(value, 503.f); [dict2 release]; } @@ -2090,57 +2090,57 @@ static BOOL TestingEnum_IsValidValue(int32_t value) { const int32_t kKeys[] = { 11, 12, 13, 14 }; const float kValues[] = { 500.f, 501.f, 502.f, 503.f }; GPBInt32FloatDictionary *dict = - [[GPBInt32FloatDictionary alloc] initWithValues:kValues - forKeys:kKeys - count:GPBARRAYSIZE(kValues)]; + [[GPBInt32FloatDictionary alloc] initWithFloats:kValues + forKeys:kKeys + count:GPBARRAYSIZE(kValues)]; XCTAssertNotNil(dict); XCTAssertEqual(dict.count, 4U); - [dict removeValueForKey:12]; + [dict removeFloatForKey:12]; XCTAssertEqual(dict.count, 3U); float value; - XCTAssertTrue([dict valueForKey:11 value:NULL]); - XCTAssertTrue([dict valueForKey:11 value:&value]); + XCTAssertTrue([dict getFloat:NULL forKey:11]); + XCTAssertTrue([dict getFloat:&value forKey:11]); XCTAssertEqual(value, 500.f); - XCTAssertFalse([dict valueForKey:12 value:NULL]); - XCTAssertTrue([dict valueForKey:13 value:NULL]); - XCTAssertTrue([dict valueForKey:13 value:&value]); + XCTAssertFalse([dict getFloat:NULL forKey:12]); + XCTAssertTrue([dict getFloat:NULL forKey:13]); + XCTAssertTrue([dict getFloat:&value forKey:13]); XCTAssertEqual(value, 502.f); - XCTAssertTrue([dict valueForKey:14 value:NULL]); - XCTAssertTrue([dict valueForKey:14 value:&value]); + XCTAssertTrue([dict getFloat:NULL forKey:14]); + XCTAssertTrue([dict getFloat:&value forKey:14]); XCTAssertEqual(value, 503.f); // Remove again does nothing. - [dict removeValueForKey:12]; + [dict removeFloatForKey:12]; XCTAssertEqual(dict.count, 3U); - XCTAssertTrue([dict valueForKey:11 value:NULL]); - XCTAssertTrue([dict valueForKey:11 value:&value]); + XCTAssertTrue([dict getFloat:NULL forKey:11]); + XCTAssertTrue([dict getFloat:&value forKey:11]); XCTAssertEqual(value, 500.f); - XCTAssertFalse([dict valueForKey:12 value:NULL]); - XCTAssertTrue([dict valueForKey:13 value:NULL]); - XCTAssertTrue([dict valueForKey:13 value:&value]); + XCTAssertFalse([dict getFloat:NULL forKey:12]); + XCTAssertTrue([dict getFloat:NULL forKey:13]); + XCTAssertTrue([dict getFloat:&value forKey:13]); XCTAssertEqual(value, 502.f); - XCTAssertTrue([dict valueForKey:14 value:NULL]); - XCTAssertTrue([dict valueForKey:14 value:&value]); + XCTAssertTrue([dict getFloat:NULL forKey:14]); + XCTAssertTrue([dict getFloat:&value forKey:14]); XCTAssertEqual(value, 503.f); - [dict removeValueForKey:14]; + [dict removeFloatForKey:14]; XCTAssertEqual(dict.count, 2U); - XCTAssertTrue([dict valueForKey:11 value:NULL]); - XCTAssertTrue([dict valueForKey:11 value:&value]); + XCTAssertTrue([dict getFloat:NULL forKey:11]); + XCTAssertTrue([dict getFloat:&value forKey:11]); XCTAssertEqual(value, 500.f); - XCTAssertFalse([dict valueForKey:12 value:NULL]); - XCTAssertTrue([dict valueForKey:13 value:NULL]); - XCTAssertTrue([dict valueForKey:13 value:&value]); + XCTAssertFalse([dict getFloat:NULL forKey:12]); + XCTAssertTrue([dict getFloat:NULL forKey:13]); + XCTAssertTrue([dict getFloat:&value forKey:13]); XCTAssertEqual(value, 502.f); - XCTAssertFalse([dict valueForKey:14 value:NULL]); + XCTAssertFalse([dict getFloat:NULL forKey:14]); [dict removeAll]; XCTAssertEqual(dict.count, 0U); - XCTAssertFalse([dict valueForKey:11 value:NULL]); - XCTAssertFalse([dict valueForKey:12 value:NULL]); - XCTAssertFalse([dict valueForKey:13 value:NULL]); - XCTAssertFalse([dict valueForKey:14 value:NULL]); + XCTAssertFalse([dict getFloat:NULL forKey:11]); + XCTAssertFalse([dict getFloat:NULL forKey:12]); + XCTAssertFalse([dict getFloat:NULL forKey:13]); + XCTAssertFalse([dict getFloat:NULL forKey:14]); [dict release]; } @@ -2148,75 +2148,75 @@ static BOOL TestingEnum_IsValidValue(int32_t value) { const int32_t kKeys[] = { 11, 12, 13, 14 }; const float kValues[] = { 500.f, 501.f, 502.f, 503.f }; GPBInt32FloatDictionary *dict = - [[GPBInt32FloatDictionary alloc] initWithValues:kValues - forKeys:kKeys - count:GPBARRAYSIZE(kValues)]; + [[GPBInt32FloatDictionary alloc] initWithFloats:kValues + forKeys:kKeys + count:GPBARRAYSIZE(kValues)]; XCTAssertNotNil(dict); XCTAssertEqual(dict.count, 4U); float value; - XCTAssertTrue([dict valueForKey:11 value:NULL]); - XCTAssertTrue([dict valueForKey:11 value:&value]); + XCTAssertTrue([dict getFloat:NULL forKey:11]); + XCTAssertTrue([dict getFloat:&value forKey:11]); XCTAssertEqual(value, 500.f); - XCTAssertTrue([dict valueForKey:12 value:NULL]); - XCTAssertTrue([dict valueForKey:12 value:&value]); + XCTAssertTrue([dict getFloat:NULL forKey:12]); + XCTAssertTrue([dict getFloat:&value forKey:12]); XCTAssertEqual(value, 501.f); - XCTAssertTrue([dict valueForKey:13 value:NULL]); - XCTAssertTrue([dict valueForKey:13 value:&value]); + XCTAssertTrue([dict getFloat:NULL forKey:13]); + XCTAssertTrue([dict getFloat:&value forKey:13]); XCTAssertEqual(value, 502.f); - XCTAssertTrue([dict valueForKey:14 value:NULL]); - XCTAssertTrue([dict valueForKey:14 value:&value]); + XCTAssertTrue([dict getFloat:NULL forKey:14]); + XCTAssertTrue([dict getFloat:&value forKey:14]); XCTAssertEqual(value, 503.f); - [dict setValue:503.f forKey:11]; + [dict setFloat:503.f forKey:11]; XCTAssertEqual(dict.count, 4U); - XCTAssertTrue([dict valueForKey:11 value:NULL]); - XCTAssertTrue([dict valueForKey:11 value:&value]); + XCTAssertTrue([dict getFloat:NULL forKey:11]); + XCTAssertTrue([dict getFloat:&value forKey:11]); XCTAssertEqual(value, 503.f); - XCTAssertTrue([dict valueForKey:12 value:NULL]); - XCTAssertTrue([dict valueForKey:12 value:&value]); + XCTAssertTrue([dict getFloat:NULL forKey:12]); + XCTAssertTrue([dict getFloat:&value forKey:12]); XCTAssertEqual(value, 501.f); - XCTAssertTrue([dict valueForKey:13 value:NULL]); - XCTAssertTrue([dict valueForKey:13 value:&value]); + XCTAssertTrue([dict getFloat:NULL forKey:13]); + XCTAssertTrue([dict getFloat:&value forKey:13]); XCTAssertEqual(value, 502.f); - XCTAssertTrue([dict valueForKey:14 value:NULL]); - XCTAssertTrue([dict valueForKey:14 value:&value]); + XCTAssertTrue([dict getFloat:NULL forKey:14]); + XCTAssertTrue([dict getFloat:&value forKey:14]); XCTAssertEqual(value, 503.f); - [dict setValue:501.f forKey:14]; + [dict setFloat:501.f forKey:14]; XCTAssertEqual(dict.count, 4U); - XCTAssertTrue([dict valueForKey:11 value:NULL]); - XCTAssertTrue([dict valueForKey:11 value:&value]); + XCTAssertTrue([dict getFloat:NULL forKey:11]); + XCTAssertTrue([dict getFloat:&value forKey:11]); XCTAssertEqual(value, 503.f); - XCTAssertTrue([dict valueForKey:12 value:NULL]); - XCTAssertTrue([dict valueForKey:12 value:&value]); + XCTAssertTrue([dict getFloat:NULL forKey:12]); + XCTAssertTrue([dict getFloat:&value forKey:12]); XCTAssertEqual(value, 501.f); - XCTAssertTrue([dict valueForKey:13 value:NULL]); - XCTAssertTrue([dict valueForKey:13 value:&value]); + XCTAssertTrue([dict getFloat:NULL forKey:13]); + XCTAssertTrue([dict getFloat:&value forKey:13]); XCTAssertEqual(value, 502.f); - XCTAssertTrue([dict valueForKey:14 value:NULL]); - XCTAssertTrue([dict valueForKey:14 value:&value]); + XCTAssertTrue([dict getFloat:NULL forKey:14]); + XCTAssertTrue([dict getFloat:&value forKey:14]); XCTAssertEqual(value, 501.f); const int32_t kKeys2[] = { 12, 13 }; const float kValues2[] = { 502.f, 500.f }; GPBInt32FloatDictionary *dict2 = - [[GPBInt32FloatDictionary alloc] initWithValues:kValues2 + [[GPBInt32FloatDictionary alloc] initWithFloats:kValues2 forKeys:kKeys2 count:GPBARRAYSIZE(kValues2)]; XCTAssertNotNil(dict2); [dict addEntriesFromDictionary:dict2]; XCTAssertEqual(dict.count, 4U); - XCTAssertTrue([dict valueForKey:11 value:NULL]); - XCTAssertTrue([dict valueForKey:11 value:&value]); + XCTAssertTrue([dict getFloat:NULL forKey:11]); + XCTAssertTrue([dict getFloat:&value forKey:11]); XCTAssertEqual(value, 503.f); - XCTAssertTrue([dict valueForKey:12 value:NULL]); - XCTAssertTrue([dict valueForKey:12 value:&value]); + XCTAssertTrue([dict getFloat:NULL forKey:12]); + XCTAssertTrue([dict getFloat:&value forKey:12]); XCTAssertEqual(value, 502.f); - XCTAssertTrue([dict valueForKey:13 value:NULL]); - XCTAssertTrue([dict valueForKey:13 value:&value]); + XCTAssertTrue([dict getFloat:NULL forKey:13]); + XCTAssertTrue([dict getFloat:&value forKey:13]); XCTAssertEqual(value, 500.f); - XCTAssertTrue([dict valueForKey:14 value:NULL]); - XCTAssertTrue([dict valueForKey:14 value:&value]); + XCTAssertTrue([dict getFloat:NULL forKey:14]); + XCTAssertTrue([dict getFloat:&value forKey:14]); XCTAssertEqual(value, 501.f); [dict2 release]; @@ -2236,8 +2236,8 @@ static BOOL TestingEnum_IsValidValue(int32_t value) { GPBInt32DoubleDictionary *dict = [[GPBInt32DoubleDictionary alloc] init]; XCTAssertNotNil(dict); XCTAssertEqual(dict.count, 0U); - XCTAssertFalse([dict valueForKey:11 value:NULL]); - [dict enumerateKeysAndValuesUsingBlock:^(int32_t aKey, double aValue, BOOL *stop) { + XCTAssertFalse([dict getDouble:NULL forKey:11]); + [dict enumerateKeysAndDoublesUsingBlock:^(int32_t aKey, double aValue, BOOL *stop) { #pragma unused(aKey, aValue, stop) XCTFail(@"Shouldn't get here!"); }]; @@ -2245,15 +2245,15 @@ static BOOL TestingEnum_IsValidValue(int32_t value) { } - (void)testOne { - GPBInt32DoubleDictionary *dict = [GPBInt32DoubleDictionary dictionaryWithValue:600. forKey:11]; + GPBInt32DoubleDictionary *dict = [GPBInt32DoubleDictionary dictionaryWithDouble:600. forKey:11]; XCTAssertNotNil(dict); XCTAssertEqual(dict.count, 1U); double value; - XCTAssertTrue([dict valueForKey:11 value:NULL]); - XCTAssertTrue([dict valueForKey:11 value:&value]); + XCTAssertTrue([dict getDouble:NULL forKey:11]); + XCTAssertTrue([dict getDouble:&value forKey:11]); XCTAssertEqual(value, 600.); - XCTAssertFalse([dict valueForKey:12 value:NULL]); - [dict enumerateKeysAndValuesUsingBlock:^(int32_t aKey, double aValue, BOOL *stop) { + XCTAssertFalse([dict getDouble:NULL forKey:12]); + [dict enumerateKeysAndDoublesUsingBlock:^(int32_t aKey, double aValue, BOOL *stop) { XCTAssertEqual(aKey, 11); XCTAssertEqual(aValue, 600.); XCTAssertNotEqual(stop, NULL); @@ -2264,27 +2264,27 @@ static BOOL TestingEnum_IsValidValue(int32_t value) { const int32_t kKeys[] = { 11, 12, 13 }; const double kValues[] = { 600., 601., 602. }; GPBInt32DoubleDictionary *dict = - [[GPBInt32DoubleDictionary alloc] initWithValues:kValues - forKeys:kKeys - count:GPBARRAYSIZE(kValues)]; + [[GPBInt32DoubleDictionary alloc] initWithDoubles:kValues + forKeys:kKeys + count:GPBARRAYSIZE(kValues)]; XCTAssertNotNil(dict); XCTAssertEqual(dict.count, 3U); double value; - XCTAssertTrue([dict valueForKey:11 value:NULL]); - XCTAssertTrue([dict valueForKey:11 value:&value]); + XCTAssertTrue([dict getDouble:NULL forKey:11]); + XCTAssertTrue([dict getDouble:&value forKey:11]); XCTAssertEqual(value, 600.); - XCTAssertTrue([dict valueForKey:12 value:NULL]); - XCTAssertTrue([dict valueForKey:12 value:&value]); + XCTAssertTrue([dict getDouble:NULL forKey:12]); + XCTAssertTrue([dict getDouble:&value forKey:12]); XCTAssertEqual(value, 601.); - XCTAssertTrue([dict valueForKey:13 value:NULL]); - XCTAssertTrue([dict valueForKey:13 value:&value]); + XCTAssertTrue([dict getDouble:NULL forKey:13]); + XCTAssertTrue([dict getDouble:&value forKey:13]); XCTAssertEqual(value, 602.); - XCTAssertFalse([dict valueForKey:14 value:NULL]); + XCTAssertFalse([dict getDouble:NULL forKey:14]); __block NSUInteger idx = 0; int32_t *seenKeys = malloc(3 * sizeof(int32_t)); double *seenValues = malloc(3 * sizeof(double)); - [dict enumerateKeysAndValuesUsingBlock:^(int32_t aKey, double aValue, BOOL *stop) { + [dict enumerateKeysAndDoublesUsingBlock:^(int32_t aKey, double aValue, BOOL *stop) { XCTAssertLessThan(idx, 3U); seenKeys[idx] = aKey; seenValues[idx] = aValue; @@ -2306,7 +2306,7 @@ static BOOL TestingEnum_IsValidValue(int32_t value) { // Stopping the enumeration. idx = 0; - [dict enumerateKeysAndValuesUsingBlock:^(int32_t aKey, double aValue, BOOL *stop) { + [dict enumerateKeysAndDoublesUsingBlock:^(int32_t aKey, double aValue, BOOL *stop) { #pragma unused(aKey, aValue) if (idx == 1) *stop = YES; XCTAssertNotEqual(idx, 2U); @@ -2322,29 +2322,29 @@ static BOOL TestingEnum_IsValidValue(int32_t value) { const double kValues2[] = { 600., 603., 602. }; const double kValues3[] = { 600., 601., 602., 603. }; GPBInt32DoubleDictionary *dict1 = - [[GPBInt32DoubleDictionary alloc] initWithValues:kValues1 - forKeys:kKeys1 - count:GPBARRAYSIZE(kValues1)]; + [[GPBInt32DoubleDictionary alloc] initWithDoubles:kValues1 + forKeys:kKeys1 + count:GPBARRAYSIZE(kValues1)]; XCTAssertNotNil(dict1); GPBInt32DoubleDictionary *dict1prime = - [[GPBInt32DoubleDictionary alloc] initWithValues:kValues1 - forKeys:kKeys1 - count:GPBARRAYSIZE(kValues1)]; + [[GPBInt32DoubleDictionary alloc] initWithDoubles:kValues1 + forKeys:kKeys1 + count:GPBARRAYSIZE(kValues1)]; XCTAssertNotNil(dict1prime); GPBInt32DoubleDictionary *dict2 = - [[GPBInt32DoubleDictionary alloc] initWithValues:kValues2 - forKeys:kKeys1 - count:GPBARRAYSIZE(kValues2)]; + [[GPBInt32DoubleDictionary alloc] initWithDoubles:kValues2 + forKeys:kKeys1 + count:GPBARRAYSIZE(kValues2)]; XCTAssertNotNil(dict2); GPBInt32DoubleDictionary *dict3 = - [[GPBInt32DoubleDictionary alloc] initWithValues:kValues1 - forKeys:kKeys2 - count:GPBARRAYSIZE(kValues1)]; + [[GPBInt32DoubleDictionary alloc] initWithDoubles:kValues1 + forKeys:kKeys2 + count:GPBARRAYSIZE(kValues1)]; XCTAssertNotNil(dict3); GPBInt32DoubleDictionary *dict4 = - [[GPBInt32DoubleDictionary alloc] initWithValues:kValues3 - forKeys:kKeys1 - count:GPBARRAYSIZE(kValues3)]; + [[GPBInt32DoubleDictionary alloc] initWithDoubles:kValues3 + forKeys:kKeys1 + count:GPBARRAYSIZE(kValues3)]; XCTAssertNotNil(dict4); // 1/1Prime should be different objects, but equal. @@ -2373,9 +2373,9 @@ static BOOL TestingEnum_IsValidValue(int32_t value) { const int32_t kKeys[] = { 11, 12, 13, 14 }; const double kValues[] = { 600., 601., 602., 603. }; GPBInt32DoubleDictionary *dict = - [[GPBInt32DoubleDictionary alloc] initWithValues:kValues - forKeys:kKeys - count:GPBARRAYSIZE(kValues)]; + [[GPBInt32DoubleDictionary alloc] initWithDoubles:kValues + forKeys:kKeys + count:GPBARRAYSIZE(kValues)]; XCTAssertNotNil(dict); GPBInt32DoubleDictionary *dict2 = [dict copy]; @@ -2394,9 +2394,9 @@ static BOOL TestingEnum_IsValidValue(int32_t value) { const int32_t kKeys[] = { 11, 12, 13, 14 }; const double kValues[] = { 600., 601., 602., 603. }; GPBInt32DoubleDictionary *dict = - [[GPBInt32DoubleDictionary alloc] initWithValues:kValues - forKeys:kKeys - count:GPBARRAYSIZE(kValues)]; + [[GPBInt32DoubleDictionary alloc] initWithDoubles:kValues + forKeys:kKeys + count:GPBARRAYSIZE(kValues)]; XCTAssertNotNil(dict); GPBInt32DoubleDictionary *dict2 = @@ -2414,31 +2414,31 @@ static BOOL TestingEnum_IsValidValue(int32_t value) { XCTAssertNotNil(dict); XCTAssertEqual(dict.count, 0U); - [dict setValue:600. forKey:11]; + [dict setDouble:600. forKey:11]; XCTAssertEqual(dict.count, 1U); const int32_t kKeys[] = { 12, 13, 14 }; const double kValues[] = { 601., 602., 603. }; GPBInt32DoubleDictionary *dict2 = - [[GPBInt32DoubleDictionary alloc] initWithValues:kValues - forKeys:kKeys - count:GPBARRAYSIZE(kValues)]; + [[GPBInt32DoubleDictionary alloc] initWithDoubles:kValues + forKeys:kKeys + count:GPBARRAYSIZE(kValues)]; XCTAssertNotNil(dict2); [dict addEntriesFromDictionary:dict2]; XCTAssertEqual(dict.count, 4U); double value; - XCTAssertTrue([dict valueForKey:11 value:NULL]); - XCTAssertTrue([dict valueForKey:11 value:&value]); + XCTAssertTrue([dict getDouble:NULL forKey:11]); + XCTAssertTrue([dict getDouble:&value forKey:11]); XCTAssertEqual(value, 600.); - XCTAssertTrue([dict valueForKey:12 value:NULL]); - XCTAssertTrue([dict valueForKey:12 value:&value]); + XCTAssertTrue([dict getDouble:NULL forKey:12]); + XCTAssertTrue([dict getDouble:&value forKey:12]); XCTAssertEqual(value, 601.); - XCTAssertTrue([dict valueForKey:13 value:NULL]); - XCTAssertTrue([dict valueForKey:13 value:&value]); + XCTAssertTrue([dict getDouble:NULL forKey:13]); + XCTAssertTrue([dict getDouble:&value forKey:13]); XCTAssertEqual(value, 602.); - XCTAssertTrue([dict valueForKey:14 value:NULL]); - XCTAssertTrue([dict valueForKey:14 value:&value]); + XCTAssertTrue([dict getDouble:NULL forKey:14]); + XCTAssertTrue([dict getDouble:&value forKey:14]); XCTAssertEqual(value, 603.); [dict2 release]; } @@ -2447,57 +2447,57 @@ static BOOL TestingEnum_IsValidValue(int32_t value) { const int32_t kKeys[] = { 11, 12, 13, 14 }; const double kValues[] = { 600., 601., 602., 603. }; GPBInt32DoubleDictionary *dict = - [[GPBInt32DoubleDictionary alloc] initWithValues:kValues - forKeys:kKeys - count:GPBARRAYSIZE(kValues)]; + [[GPBInt32DoubleDictionary alloc] initWithDoubles:kValues + forKeys:kKeys + count:GPBARRAYSIZE(kValues)]; XCTAssertNotNil(dict); XCTAssertEqual(dict.count, 4U); - [dict removeValueForKey:12]; + [dict removeDoubleForKey:12]; XCTAssertEqual(dict.count, 3U); double value; - XCTAssertTrue([dict valueForKey:11 value:NULL]); - XCTAssertTrue([dict valueForKey:11 value:&value]); + XCTAssertTrue([dict getDouble:NULL forKey:11]); + XCTAssertTrue([dict getDouble:&value forKey:11]); XCTAssertEqual(value, 600.); - XCTAssertFalse([dict valueForKey:12 value:NULL]); - XCTAssertTrue([dict valueForKey:13 value:NULL]); - XCTAssertTrue([dict valueForKey:13 value:&value]); + XCTAssertFalse([dict getDouble:NULL forKey:12]); + XCTAssertTrue([dict getDouble:NULL forKey:13]); + XCTAssertTrue([dict getDouble:&value forKey:13]); XCTAssertEqual(value, 602.); - XCTAssertTrue([dict valueForKey:14 value:NULL]); - XCTAssertTrue([dict valueForKey:14 value:&value]); + XCTAssertTrue([dict getDouble:NULL forKey:14]); + XCTAssertTrue([dict getDouble:&value forKey:14]); XCTAssertEqual(value, 603.); // Remove again does nothing. - [dict removeValueForKey:12]; + [dict removeDoubleForKey:12]; XCTAssertEqual(dict.count, 3U); - XCTAssertTrue([dict valueForKey:11 value:NULL]); - XCTAssertTrue([dict valueForKey:11 value:&value]); + XCTAssertTrue([dict getDouble:NULL forKey:11]); + XCTAssertTrue([dict getDouble:&value forKey:11]); XCTAssertEqual(value, 600.); - XCTAssertFalse([dict valueForKey:12 value:NULL]); - XCTAssertTrue([dict valueForKey:13 value:NULL]); - XCTAssertTrue([dict valueForKey:13 value:&value]); + XCTAssertFalse([dict getDouble:NULL forKey:12]); + XCTAssertTrue([dict getDouble:NULL forKey:13]); + XCTAssertTrue([dict getDouble:&value forKey:13]); XCTAssertEqual(value, 602.); - XCTAssertTrue([dict valueForKey:14 value:NULL]); - XCTAssertTrue([dict valueForKey:14 value:&value]); + XCTAssertTrue([dict getDouble:NULL forKey:14]); + XCTAssertTrue([dict getDouble:&value forKey:14]); XCTAssertEqual(value, 603.); - [dict removeValueForKey:14]; + [dict removeDoubleForKey:14]; XCTAssertEqual(dict.count, 2U); - XCTAssertTrue([dict valueForKey:11 value:NULL]); - XCTAssertTrue([dict valueForKey:11 value:&value]); + XCTAssertTrue([dict getDouble:NULL forKey:11]); + XCTAssertTrue([dict getDouble:&value forKey:11]); XCTAssertEqual(value, 600.); - XCTAssertFalse([dict valueForKey:12 value:NULL]); - XCTAssertTrue([dict valueForKey:13 value:NULL]); - XCTAssertTrue([dict valueForKey:13 value:&value]); + XCTAssertFalse([dict getDouble:NULL forKey:12]); + XCTAssertTrue([dict getDouble:NULL forKey:13]); + XCTAssertTrue([dict getDouble:&value forKey:13]); XCTAssertEqual(value, 602.); - XCTAssertFalse([dict valueForKey:14 value:NULL]); + XCTAssertFalse([dict getDouble:NULL forKey:14]); [dict removeAll]; XCTAssertEqual(dict.count, 0U); - XCTAssertFalse([dict valueForKey:11 value:NULL]); - XCTAssertFalse([dict valueForKey:12 value:NULL]); - XCTAssertFalse([dict valueForKey:13 value:NULL]); - XCTAssertFalse([dict valueForKey:14 value:NULL]); + XCTAssertFalse([dict getDouble:NULL forKey:11]); + XCTAssertFalse([dict getDouble:NULL forKey:12]); + XCTAssertFalse([dict getDouble:NULL forKey:13]); + XCTAssertFalse([dict getDouble:NULL forKey:14]); [dict release]; } @@ -2505,75 +2505,75 @@ static BOOL TestingEnum_IsValidValue(int32_t value) { const int32_t kKeys[] = { 11, 12, 13, 14 }; const double kValues[] = { 600., 601., 602., 603. }; GPBInt32DoubleDictionary *dict = - [[GPBInt32DoubleDictionary alloc] initWithValues:kValues - forKeys:kKeys - count:GPBARRAYSIZE(kValues)]; + [[GPBInt32DoubleDictionary alloc] initWithDoubles:kValues + forKeys:kKeys + count:GPBARRAYSIZE(kValues)]; XCTAssertNotNil(dict); XCTAssertEqual(dict.count, 4U); double value; - XCTAssertTrue([dict valueForKey:11 value:NULL]); - XCTAssertTrue([dict valueForKey:11 value:&value]); + XCTAssertTrue([dict getDouble:NULL forKey:11]); + XCTAssertTrue([dict getDouble:&value forKey:11]); XCTAssertEqual(value, 600.); - XCTAssertTrue([dict valueForKey:12 value:NULL]); - XCTAssertTrue([dict valueForKey:12 value:&value]); + XCTAssertTrue([dict getDouble:NULL forKey:12]); + XCTAssertTrue([dict getDouble:&value forKey:12]); XCTAssertEqual(value, 601.); - XCTAssertTrue([dict valueForKey:13 value:NULL]); - XCTAssertTrue([dict valueForKey:13 value:&value]); + XCTAssertTrue([dict getDouble:NULL forKey:13]); + XCTAssertTrue([dict getDouble:&value forKey:13]); XCTAssertEqual(value, 602.); - XCTAssertTrue([dict valueForKey:14 value:NULL]); - XCTAssertTrue([dict valueForKey:14 value:&value]); + XCTAssertTrue([dict getDouble:NULL forKey:14]); + XCTAssertTrue([dict getDouble:&value forKey:14]); XCTAssertEqual(value, 603.); - [dict setValue:603. forKey:11]; + [dict setDouble:603. forKey:11]; XCTAssertEqual(dict.count, 4U); - XCTAssertTrue([dict valueForKey:11 value:NULL]); - XCTAssertTrue([dict valueForKey:11 value:&value]); + XCTAssertTrue([dict getDouble:NULL forKey:11]); + XCTAssertTrue([dict getDouble:&value forKey:11]); XCTAssertEqual(value, 603.); - XCTAssertTrue([dict valueForKey:12 value:NULL]); - XCTAssertTrue([dict valueForKey:12 value:&value]); + XCTAssertTrue([dict getDouble:NULL forKey:12]); + XCTAssertTrue([dict getDouble:&value forKey:12]); XCTAssertEqual(value, 601.); - XCTAssertTrue([dict valueForKey:13 value:NULL]); - XCTAssertTrue([dict valueForKey:13 value:&value]); + XCTAssertTrue([dict getDouble:NULL forKey:13]); + XCTAssertTrue([dict getDouble:&value forKey:13]); XCTAssertEqual(value, 602.); - XCTAssertTrue([dict valueForKey:14 value:NULL]); - XCTAssertTrue([dict valueForKey:14 value:&value]); + XCTAssertTrue([dict getDouble:NULL forKey:14]); + XCTAssertTrue([dict getDouble:&value forKey:14]); XCTAssertEqual(value, 603.); - [dict setValue:601. forKey:14]; + [dict setDouble:601. forKey:14]; XCTAssertEqual(dict.count, 4U); - XCTAssertTrue([dict valueForKey:11 value:NULL]); - XCTAssertTrue([dict valueForKey:11 value:&value]); + XCTAssertTrue([dict getDouble:NULL forKey:11]); + XCTAssertTrue([dict getDouble:&value forKey:11]); XCTAssertEqual(value, 603.); - XCTAssertTrue([dict valueForKey:12 value:NULL]); - XCTAssertTrue([dict valueForKey:12 value:&value]); + XCTAssertTrue([dict getDouble:NULL forKey:12]); + XCTAssertTrue([dict getDouble:&value forKey:12]); XCTAssertEqual(value, 601.); - XCTAssertTrue([dict valueForKey:13 value:NULL]); - XCTAssertTrue([dict valueForKey:13 value:&value]); + XCTAssertTrue([dict getDouble:NULL forKey:13]); + XCTAssertTrue([dict getDouble:&value forKey:13]); XCTAssertEqual(value, 602.); - XCTAssertTrue([dict valueForKey:14 value:NULL]); - XCTAssertTrue([dict valueForKey:14 value:&value]); + XCTAssertTrue([dict getDouble:NULL forKey:14]); + XCTAssertTrue([dict getDouble:&value forKey:14]); XCTAssertEqual(value, 601.); const int32_t kKeys2[] = { 12, 13 }; const double kValues2[] = { 602., 600. }; GPBInt32DoubleDictionary *dict2 = - [[GPBInt32DoubleDictionary alloc] initWithValues:kValues2 - forKeys:kKeys2 - count:GPBARRAYSIZE(kValues2)]; + [[GPBInt32DoubleDictionary alloc] initWithDoubles:kValues2 + forKeys:kKeys2 + count:GPBARRAYSIZE(kValues2)]; XCTAssertNotNil(dict2); [dict addEntriesFromDictionary:dict2]; XCTAssertEqual(dict.count, 4U); - XCTAssertTrue([dict valueForKey:11 value:NULL]); - XCTAssertTrue([dict valueForKey:11 value:&value]); + XCTAssertTrue([dict getDouble:NULL forKey:11]); + XCTAssertTrue([dict getDouble:&value forKey:11]); XCTAssertEqual(value, 603.); - XCTAssertTrue([dict valueForKey:12 value:NULL]); - XCTAssertTrue([dict valueForKey:12 value:&value]); + XCTAssertTrue([dict getDouble:NULL forKey:12]); + XCTAssertTrue([dict getDouble:&value forKey:12]); XCTAssertEqual(value, 602.); - XCTAssertTrue([dict valueForKey:13 value:NULL]); - XCTAssertTrue([dict valueForKey:13 value:&value]); + XCTAssertTrue([dict getDouble:NULL forKey:13]); + XCTAssertTrue([dict getDouble:&value forKey:13]); XCTAssertEqual(value, 600.); - XCTAssertTrue([dict valueForKey:14 value:NULL]); - XCTAssertTrue([dict valueForKey:14 value:&value]); + XCTAssertTrue([dict getDouble:NULL forKey:14]); + XCTAssertTrue([dict getDouble:&value forKey:14]); XCTAssertEqual(value, 601.); [dict2 release]; @@ -2593,8 +2593,8 @@ static BOOL TestingEnum_IsValidValue(int32_t value) { GPBInt32EnumDictionary *dict = [[GPBInt32EnumDictionary alloc] init]; XCTAssertNotNil(dict); XCTAssertEqual(dict.count, 0U); - XCTAssertFalse([dict valueForKey:11 value:NULL]); - [dict enumerateKeysAndValuesUsingBlock:^(int32_t aKey, int32_t aValue, BOOL *stop) { + XCTAssertFalse([dict getEnum:NULL forKey:11]); + [dict enumerateKeysAndEnumsUsingBlock:^(int32_t aKey, int32_t aValue, BOOL *stop) { #pragma unused(aKey, aValue, stop) XCTFail(@"Shouldn't get here!"); }]; @@ -2602,15 +2602,15 @@ static BOOL TestingEnum_IsValidValue(int32_t value) { } - (void)testOne { - GPBInt32EnumDictionary *dict = [GPBInt32EnumDictionary dictionaryWithValue:700 forKey:11]; + GPBInt32EnumDictionary *dict = [GPBInt32EnumDictionary dictionaryWithEnum:700 forKey:11]; XCTAssertNotNil(dict); XCTAssertEqual(dict.count, 1U); int32_t value; - XCTAssertTrue([dict valueForKey:11 value:NULL]); - XCTAssertTrue([dict valueForKey:11 value:&value]); + XCTAssertTrue([dict getEnum:NULL forKey:11]); + XCTAssertTrue([dict getEnum:&value forKey:11]); XCTAssertEqual(value, 700); - XCTAssertFalse([dict valueForKey:12 value:NULL]); - [dict enumerateKeysAndValuesUsingBlock:^(int32_t aKey, int32_t aValue, BOOL *stop) { + XCTAssertFalse([dict getEnum:NULL forKey:12]); + [dict enumerateKeysAndEnumsUsingBlock:^(int32_t aKey, int32_t aValue, BOOL *stop) { XCTAssertEqual(aKey, 11); XCTAssertEqual(aValue, 700); XCTAssertNotEqual(stop, NULL); @@ -2621,27 +2621,27 @@ static BOOL TestingEnum_IsValidValue(int32_t value) { const int32_t kKeys[] = { 11, 12, 13 }; const int32_t kValues[] = { 700, 701, 702 }; GPBInt32EnumDictionary *dict = - [[GPBInt32EnumDictionary alloc] initWithValues:kValues - forKeys:kKeys - count:GPBARRAYSIZE(kValues)]; + [[GPBInt32EnumDictionary alloc] initWithEnums:kValues + forKeys:kKeys + count:GPBARRAYSIZE(kValues)]; XCTAssertNotNil(dict); XCTAssertEqual(dict.count, 3U); int32_t value; - XCTAssertTrue([dict valueForKey:11 value:NULL]); - XCTAssertTrue([dict valueForKey:11 value:&value]); + XCTAssertTrue([dict getEnum:NULL forKey:11]); + XCTAssertTrue([dict getEnum:&value forKey:11]); XCTAssertEqual(value, 700); - XCTAssertTrue([dict valueForKey:12 value:NULL]); - XCTAssertTrue([dict valueForKey:12 value:&value]); + XCTAssertTrue([dict getEnum:NULL forKey:12]); + XCTAssertTrue([dict getEnum:&value forKey:12]); XCTAssertEqual(value, 701); - XCTAssertTrue([dict valueForKey:13 value:NULL]); - XCTAssertTrue([dict valueForKey:13 value:&value]); + XCTAssertTrue([dict getEnum:NULL forKey:13]); + XCTAssertTrue([dict getEnum:&value forKey:13]); XCTAssertEqual(value, 702); - XCTAssertFalse([dict valueForKey:14 value:NULL]); + XCTAssertFalse([dict getEnum:NULL forKey:14]); __block NSUInteger idx = 0; int32_t *seenKeys = malloc(3 * sizeof(int32_t)); int32_t *seenValues = malloc(3 * sizeof(int32_t)); - [dict enumerateKeysAndValuesUsingBlock:^(int32_t aKey, int32_t aValue, BOOL *stop) { + [dict enumerateKeysAndEnumsUsingBlock:^(int32_t aKey, int32_t aValue, BOOL *stop) { XCTAssertLessThan(idx, 3U); seenKeys[idx] = aKey; seenValues[idx] = aValue; @@ -2663,7 +2663,7 @@ static BOOL TestingEnum_IsValidValue(int32_t value) { // Stopping the enumeration. idx = 0; - [dict enumerateKeysAndValuesUsingBlock:^(int32_t aKey, int32_t aValue, BOOL *stop) { + [dict enumerateKeysAndEnumsUsingBlock:^(int32_t aKey, int32_t aValue, BOOL *stop) { #pragma unused(aKey, aValue) if (idx == 1) *stop = YES; XCTAssertNotEqual(idx, 2U); @@ -2679,29 +2679,29 @@ static BOOL TestingEnum_IsValidValue(int32_t value) { const int32_t kValues2[] = { 700, 703, 702 }; const int32_t kValues3[] = { 700, 701, 702, 703 }; GPBInt32EnumDictionary *dict1 = - [[GPBInt32EnumDictionary alloc] initWithValues:kValues1 - forKeys:kKeys1 - count:GPBARRAYSIZE(kValues1)]; + [[GPBInt32EnumDictionary alloc] initWithEnums:kValues1 + forKeys:kKeys1 + count:GPBARRAYSIZE(kValues1)]; XCTAssertNotNil(dict1); GPBInt32EnumDictionary *dict1prime = - [[GPBInt32EnumDictionary alloc] initWithValues:kValues1 - forKeys:kKeys1 - count:GPBARRAYSIZE(kValues1)]; + [[GPBInt32EnumDictionary alloc] initWithEnums:kValues1 + forKeys:kKeys1 + count:GPBARRAYSIZE(kValues1)]; XCTAssertNotNil(dict1prime); GPBInt32EnumDictionary *dict2 = - [[GPBInt32EnumDictionary alloc] initWithValues:kValues2 - forKeys:kKeys1 - count:GPBARRAYSIZE(kValues2)]; + [[GPBInt32EnumDictionary alloc] initWithEnums:kValues2 + forKeys:kKeys1 + count:GPBARRAYSIZE(kValues2)]; XCTAssertNotNil(dict2); GPBInt32EnumDictionary *dict3 = - [[GPBInt32EnumDictionary alloc] initWithValues:kValues1 - forKeys:kKeys2 - count:GPBARRAYSIZE(kValues1)]; + [[GPBInt32EnumDictionary alloc] initWithEnums:kValues1 + forKeys:kKeys2 + count:GPBARRAYSIZE(kValues1)]; XCTAssertNotNil(dict3); GPBInt32EnumDictionary *dict4 = - [[GPBInt32EnumDictionary alloc] initWithValues:kValues3 - forKeys:kKeys1 - count:GPBARRAYSIZE(kValues3)]; + [[GPBInt32EnumDictionary alloc] initWithEnums:kValues3 + forKeys:kKeys1 + count:GPBARRAYSIZE(kValues3)]; XCTAssertNotNil(dict4); // 1/1Prime should be different objects, but equal. @@ -2730,9 +2730,9 @@ static BOOL TestingEnum_IsValidValue(int32_t value) { const int32_t kKeys[] = { 11, 12, 13, 14 }; const int32_t kValues[] = { 700, 701, 702, 703 }; GPBInt32EnumDictionary *dict = - [[GPBInt32EnumDictionary alloc] initWithValues:kValues - forKeys:kKeys - count:GPBARRAYSIZE(kValues)]; + [[GPBInt32EnumDictionary alloc] initWithEnums:kValues + forKeys:kKeys + count:GPBARRAYSIZE(kValues)]; XCTAssertNotNil(dict); GPBInt32EnumDictionary *dict2 = [dict copy]; @@ -2751,9 +2751,9 @@ static BOOL TestingEnum_IsValidValue(int32_t value) { const int32_t kKeys[] = { 11, 12, 13, 14 }; const int32_t kValues[] = { 700, 701, 702, 703 }; GPBInt32EnumDictionary *dict = - [[GPBInt32EnumDictionary alloc] initWithValues:kValues - forKeys:kKeys - count:GPBARRAYSIZE(kValues)]; + [[GPBInt32EnumDictionary alloc] initWithEnums:kValues + forKeys:kKeys + count:GPBARRAYSIZE(kValues)]; XCTAssertNotNil(dict); GPBInt32EnumDictionary *dict2 = @@ -2771,31 +2771,31 @@ static BOOL TestingEnum_IsValidValue(int32_t value) { XCTAssertNotNil(dict); XCTAssertEqual(dict.count, 0U); - [dict setValue:700 forKey:11]; + [dict setEnum:700 forKey:11]; XCTAssertEqual(dict.count, 1U); const int32_t kKeys[] = { 12, 13, 14 }; const int32_t kValues[] = { 701, 702, 703 }; GPBInt32EnumDictionary *dict2 = - [[GPBInt32EnumDictionary alloc] initWithValues:kValues - forKeys:kKeys - count:GPBARRAYSIZE(kValues)]; + [[GPBInt32EnumDictionary alloc] initWithEnums:kValues + forKeys:kKeys + count:GPBARRAYSIZE(kValues)]; XCTAssertNotNil(dict2); [dict addRawEntriesFromDictionary:dict2]; XCTAssertEqual(dict.count, 4U); int32_t value; - XCTAssertTrue([dict valueForKey:11 value:NULL]); - XCTAssertTrue([dict valueForKey:11 value:&value]); + XCTAssertTrue([dict getEnum:NULL forKey:11]); + XCTAssertTrue([dict getEnum:&value forKey:11]); XCTAssertEqual(value, 700); - XCTAssertTrue([dict valueForKey:12 value:NULL]); - XCTAssertTrue([dict valueForKey:12 value:&value]); + XCTAssertTrue([dict getEnum:NULL forKey:12]); + XCTAssertTrue([dict getEnum:&value forKey:12]); XCTAssertEqual(value, 701); - XCTAssertTrue([dict valueForKey:13 value:NULL]); - XCTAssertTrue([dict valueForKey:13 value:&value]); + XCTAssertTrue([dict getEnum:NULL forKey:13]); + XCTAssertTrue([dict getEnum:&value forKey:13]); XCTAssertEqual(value, 702); - XCTAssertTrue([dict valueForKey:14 value:NULL]); - XCTAssertTrue([dict valueForKey:14 value:&value]); + XCTAssertTrue([dict getEnum:NULL forKey:14]); + XCTAssertTrue([dict getEnum:&value forKey:14]); XCTAssertEqual(value, 703); [dict2 release]; } @@ -2804,57 +2804,57 @@ static BOOL TestingEnum_IsValidValue(int32_t value) { const int32_t kKeys[] = { 11, 12, 13, 14 }; const int32_t kValues[] = { 700, 701, 702, 703 }; GPBInt32EnumDictionary *dict = - [[GPBInt32EnumDictionary alloc] initWithValues:kValues - forKeys:kKeys - count:GPBARRAYSIZE(kValues)]; + [[GPBInt32EnumDictionary alloc] initWithEnums:kValues + forKeys:kKeys + count:GPBARRAYSIZE(kValues)]; XCTAssertNotNil(dict); XCTAssertEqual(dict.count, 4U); - [dict removeValueForKey:12]; + [dict removeEnumForKey:12]; XCTAssertEqual(dict.count, 3U); int32_t value; - XCTAssertTrue([dict valueForKey:11 value:NULL]); - XCTAssertTrue([dict valueForKey:11 value:&value]); + XCTAssertTrue([dict getEnum:NULL forKey:11]); + XCTAssertTrue([dict getEnum:&value forKey:11]); XCTAssertEqual(value, 700); - XCTAssertFalse([dict valueForKey:12 value:NULL]); - XCTAssertTrue([dict valueForKey:13 value:NULL]); - XCTAssertTrue([dict valueForKey:13 value:&value]); + XCTAssertFalse([dict getEnum:NULL forKey:12]); + XCTAssertTrue([dict getEnum:NULL forKey:13]); + XCTAssertTrue([dict getEnum:&value forKey:13]); XCTAssertEqual(value, 702); - XCTAssertTrue([dict valueForKey:14 value:NULL]); - XCTAssertTrue([dict valueForKey:14 value:&value]); + XCTAssertTrue([dict getEnum:NULL forKey:14]); + XCTAssertTrue([dict getEnum:&value forKey:14]); XCTAssertEqual(value, 703); // Remove again does nothing. - [dict removeValueForKey:12]; + [dict removeEnumForKey:12]; XCTAssertEqual(dict.count, 3U); - XCTAssertTrue([dict valueForKey:11 value:NULL]); - XCTAssertTrue([dict valueForKey:11 value:&value]); + XCTAssertTrue([dict getEnum:NULL forKey:11]); + XCTAssertTrue([dict getEnum:&value forKey:11]); XCTAssertEqual(value, 700); - XCTAssertFalse([dict valueForKey:12 value:NULL]); - XCTAssertTrue([dict valueForKey:13 value:NULL]); - XCTAssertTrue([dict valueForKey:13 value:&value]); + XCTAssertFalse([dict getEnum:NULL forKey:12]); + XCTAssertTrue([dict getEnum:NULL forKey:13]); + XCTAssertTrue([dict getEnum:&value forKey:13]); XCTAssertEqual(value, 702); - XCTAssertTrue([dict valueForKey:14 value:NULL]); - XCTAssertTrue([dict valueForKey:14 value:&value]); + XCTAssertTrue([dict getEnum:NULL forKey:14]); + XCTAssertTrue([dict getEnum:&value forKey:14]); XCTAssertEqual(value, 703); - [dict removeValueForKey:14]; + [dict removeEnumForKey:14]; XCTAssertEqual(dict.count, 2U); - XCTAssertTrue([dict valueForKey:11 value:NULL]); - XCTAssertTrue([dict valueForKey:11 value:&value]); + XCTAssertTrue([dict getEnum:NULL forKey:11]); + XCTAssertTrue([dict getEnum:&value forKey:11]); XCTAssertEqual(value, 700); - XCTAssertFalse([dict valueForKey:12 value:NULL]); - XCTAssertTrue([dict valueForKey:13 value:NULL]); - XCTAssertTrue([dict valueForKey:13 value:&value]); + XCTAssertFalse([dict getEnum:NULL forKey:12]); + XCTAssertTrue([dict getEnum:NULL forKey:13]); + XCTAssertTrue([dict getEnum:&value forKey:13]); XCTAssertEqual(value, 702); - XCTAssertFalse([dict valueForKey:14 value:NULL]); + XCTAssertFalse([dict getEnum:NULL forKey:14]); [dict removeAll]; XCTAssertEqual(dict.count, 0U); - XCTAssertFalse([dict valueForKey:11 value:NULL]); - XCTAssertFalse([dict valueForKey:12 value:NULL]); - XCTAssertFalse([dict valueForKey:13 value:NULL]); - XCTAssertFalse([dict valueForKey:14 value:NULL]); + XCTAssertFalse([dict getEnum:NULL forKey:11]); + XCTAssertFalse([dict getEnum:NULL forKey:12]); + XCTAssertFalse([dict getEnum:NULL forKey:13]); + XCTAssertFalse([dict getEnum:NULL forKey:14]); [dict release]; } @@ -2862,75 +2862,75 @@ static BOOL TestingEnum_IsValidValue(int32_t value) { const int32_t kKeys[] = { 11, 12, 13, 14 }; const int32_t kValues[] = { 700, 701, 702, 703 }; GPBInt32EnumDictionary *dict = - [[GPBInt32EnumDictionary alloc] initWithValues:kValues - forKeys:kKeys - count:GPBARRAYSIZE(kValues)]; + [[GPBInt32EnumDictionary alloc] initWithEnums:kValues + forKeys:kKeys + count:GPBARRAYSIZE(kValues)]; XCTAssertNotNil(dict); XCTAssertEqual(dict.count, 4U); int32_t value; - XCTAssertTrue([dict valueForKey:11 value:NULL]); - XCTAssertTrue([dict valueForKey:11 value:&value]); + XCTAssertTrue([dict getEnum:NULL forKey:11]); + XCTAssertTrue([dict getEnum:&value forKey:11]); XCTAssertEqual(value, 700); - XCTAssertTrue([dict valueForKey:12 value:NULL]); - XCTAssertTrue([dict valueForKey:12 value:&value]); + XCTAssertTrue([dict getEnum:NULL forKey:12]); + XCTAssertTrue([dict getEnum:&value forKey:12]); XCTAssertEqual(value, 701); - XCTAssertTrue([dict valueForKey:13 value:NULL]); - XCTAssertTrue([dict valueForKey:13 value:&value]); + XCTAssertTrue([dict getEnum:NULL forKey:13]); + XCTAssertTrue([dict getEnum:&value forKey:13]); XCTAssertEqual(value, 702); - XCTAssertTrue([dict valueForKey:14 value:NULL]); - XCTAssertTrue([dict valueForKey:14 value:&value]); + XCTAssertTrue([dict getEnum:NULL forKey:14]); + XCTAssertTrue([dict getEnum:&value forKey:14]); XCTAssertEqual(value, 703); - [dict setValue:703 forKey:11]; + [dict setEnum:703 forKey:11]; XCTAssertEqual(dict.count, 4U); - XCTAssertTrue([dict valueForKey:11 value:NULL]); - XCTAssertTrue([dict valueForKey:11 value:&value]); + XCTAssertTrue([dict getEnum:NULL forKey:11]); + XCTAssertTrue([dict getEnum:&value forKey:11]); XCTAssertEqual(value, 703); - XCTAssertTrue([dict valueForKey:12 value:NULL]); - XCTAssertTrue([dict valueForKey:12 value:&value]); + XCTAssertTrue([dict getEnum:NULL forKey:12]); + XCTAssertTrue([dict getEnum:&value forKey:12]); XCTAssertEqual(value, 701); - XCTAssertTrue([dict valueForKey:13 value:NULL]); - XCTAssertTrue([dict valueForKey:13 value:&value]); + XCTAssertTrue([dict getEnum:NULL forKey:13]); + XCTAssertTrue([dict getEnum:&value forKey:13]); XCTAssertEqual(value, 702); - XCTAssertTrue([dict valueForKey:14 value:NULL]); - XCTAssertTrue([dict valueForKey:14 value:&value]); + XCTAssertTrue([dict getEnum:NULL forKey:14]); + XCTAssertTrue([dict getEnum:&value forKey:14]); XCTAssertEqual(value, 703); - [dict setValue:701 forKey:14]; + [dict setEnum:701 forKey:14]; XCTAssertEqual(dict.count, 4U); - XCTAssertTrue([dict valueForKey:11 value:NULL]); - XCTAssertTrue([dict valueForKey:11 value:&value]); + XCTAssertTrue([dict getEnum:NULL forKey:11]); + XCTAssertTrue([dict getEnum:&value forKey:11]); XCTAssertEqual(value, 703); - XCTAssertTrue([dict valueForKey:12 value:NULL]); - XCTAssertTrue([dict valueForKey:12 value:&value]); + XCTAssertTrue([dict getEnum:NULL forKey:12]); + XCTAssertTrue([dict getEnum:&value forKey:12]); XCTAssertEqual(value, 701); - XCTAssertTrue([dict valueForKey:13 value:NULL]); - XCTAssertTrue([dict valueForKey:13 value:&value]); + XCTAssertTrue([dict getEnum:NULL forKey:13]); + XCTAssertTrue([dict getEnum:&value forKey:13]); XCTAssertEqual(value, 702); - XCTAssertTrue([dict valueForKey:14 value:NULL]); - XCTAssertTrue([dict valueForKey:14 value:&value]); + XCTAssertTrue([dict getEnum:NULL forKey:14]); + XCTAssertTrue([dict getEnum:&value forKey:14]); XCTAssertEqual(value, 701); const int32_t kKeys2[] = { 12, 13 }; const int32_t kValues2[] = { 702, 700 }; GPBInt32EnumDictionary *dict2 = - [[GPBInt32EnumDictionary alloc] initWithValues:kValues2 - forKeys:kKeys2 - count:GPBARRAYSIZE(kValues2)]; + [[GPBInt32EnumDictionary alloc] initWithEnums:kValues2 + forKeys:kKeys2 + count:GPBARRAYSIZE(kValues2)]; XCTAssertNotNil(dict2); [dict addRawEntriesFromDictionary:dict2]; XCTAssertEqual(dict.count, 4U); - XCTAssertTrue([dict valueForKey:11 value:NULL]); - XCTAssertTrue([dict valueForKey:11 value:&value]); + XCTAssertTrue([dict getEnum:NULL forKey:11]); + XCTAssertTrue([dict getEnum:&value forKey:11]); XCTAssertEqual(value, 703); - XCTAssertTrue([dict valueForKey:12 value:NULL]); - XCTAssertTrue([dict valueForKey:12 value:&value]); + XCTAssertTrue([dict getEnum:NULL forKey:12]); + XCTAssertTrue([dict getEnum:&value forKey:12]); XCTAssertEqual(value, 702); - XCTAssertTrue([dict valueForKey:13 value:NULL]); - XCTAssertTrue([dict valueForKey:13 value:&value]); + XCTAssertTrue([dict getEnum:NULL forKey:13]); + XCTAssertTrue([dict getEnum:&value forKey:13]); XCTAssertEqual(value, 700); - XCTAssertTrue([dict valueForKey:14 value:NULL]); - XCTAssertTrue([dict valueForKey:14 value:&value]); + XCTAssertTrue([dict getEnum:NULL forKey:14]); + XCTAssertTrue([dict getEnum:&value forKey:14]); XCTAssertEqual(value, 701); [dict2 release]; @@ -2958,24 +2958,24 @@ static BOOL TestingEnum_IsValidValue(int32_t value) { XCTAssertEqual(dict.count, 3U); XCTAssertTrue(dict.validationFunc == TestingEnum_IsValidValue); // Pointer comparison int32_t value; - XCTAssertTrue([dict valueForKey:11 rawValue:NULL]); - XCTAssertTrue([dict valueForKey:11 rawValue:&value]); + XCTAssertTrue([dict getRawValue:NULL forKey:11]); + XCTAssertTrue([dict getRawValue:&value forKey:11]); XCTAssertEqual(value, 700); - XCTAssertTrue([dict valueForKey:12 value:NULL]); - XCTAssertTrue([dict valueForKey:12 value:&value]); + XCTAssertTrue([dict getEnum:NULL forKey:12]); + XCTAssertTrue([dict getEnum:&value forKey:12]); XCTAssertEqual(value, kGPBUnrecognizedEnumeratorValue); - XCTAssertTrue([dict valueForKey:12 rawValue:NULL]); - XCTAssertTrue([dict valueForKey:12 rawValue:&value]); + XCTAssertTrue([dict getRawValue:NULL forKey:12]); + XCTAssertTrue([dict getRawValue:&value forKey:12]); XCTAssertEqual(value, 801); - XCTAssertTrue([dict valueForKey:13 rawValue:NULL]); - XCTAssertTrue([dict valueForKey:13 rawValue:&value]); + XCTAssertTrue([dict getRawValue:NULL forKey:13]); + XCTAssertTrue([dict getRawValue:&value forKey:13]); XCTAssertEqual(value, 702); - XCTAssertFalse([dict valueForKey:14 rawValue:NULL]); + XCTAssertFalse([dict getRawValue:NULL forKey:14]); __block NSUInteger idx = 0; int32_t *seenKeys = malloc(3 * sizeof(int32_t)); int32_t *seenValues = malloc(3 * sizeof(int32_t)); - [dict enumerateKeysAndValuesUsingBlock:^(int32_t aKey, int32_t aValue, BOOL *stop) { + [dict enumerateKeysAndEnumsUsingBlock:^(int32_t aKey, int32_t aValue, BOOL *stop) { XCTAssertLessThan(idx, 3U); seenKeys[idx] = aKey; seenValues[idx] = aValue; @@ -3136,7 +3136,7 @@ static BOOL TestingEnum_IsValidValue(int32_t value) { XCTAssertNotNil(dict); XCTAssertEqual(dict.count, 0U); - XCTAssertThrowsSpecificNamed([dict setValue:801 forKey:12], // Unknown + XCTAssertThrowsSpecificNamed([dict setEnum:801 forKey:12], // Unknown NSException, NSInvalidArgumentException); XCTAssertEqual(dict.count, 0U); [dict setRawValue:801 forKey:12]; // Unknown @@ -3145,31 +3145,31 @@ static BOOL TestingEnum_IsValidValue(int32_t value) { const int32_t kKeys[] = { 11, 13, 14 }; const int32_t kValues[] = { 700, 702, 803 }; // Unknown GPBInt32EnumDictionary *dict2 = - [[GPBInt32EnumDictionary alloc] initWithValues:kValues - forKeys:kKeys - count:GPBARRAYSIZE(kValues)]; + [[GPBInt32EnumDictionary alloc] initWithEnums:kValues + forKeys:kKeys + count:GPBARRAYSIZE(kValues)]; XCTAssertNotNil(dict2); [dict addRawEntriesFromDictionary:dict2]; XCTAssertEqual(dict.count, 4U); int32_t value; - XCTAssertTrue([dict valueForKey:11 value:NULL]); - XCTAssertTrue([dict valueForKey:11 value:&value]); + XCTAssertTrue([dict getEnum:NULL forKey:11]); + XCTAssertTrue([dict getEnum:&value forKey:11]); XCTAssertEqual(value, 700); - XCTAssertTrue([dict valueForKey:12 value:NULL]); - XCTAssertTrue([dict valueForKey:12 value:&value]); + XCTAssertTrue([dict getEnum:NULL forKey:12]); + XCTAssertTrue([dict getEnum:&value forKey:12]); XCTAssertEqual(value, kGPBUnrecognizedEnumeratorValue); - XCTAssertTrue([dict valueForKey:12 rawValue:NULL]); - XCTAssertTrue([dict valueForKey:12 rawValue:&value]); + XCTAssertTrue([dict getRawValue:NULL forKey:12]); + XCTAssertTrue([dict getRawValue:&value forKey:12]); XCTAssertEqual(value, 801); - XCTAssertTrue([dict valueForKey:13 value:NULL]); - XCTAssertTrue([dict valueForKey:13 value:&value]); + XCTAssertTrue([dict getEnum:NULL forKey:13]); + XCTAssertTrue([dict getEnum:&value forKey:13]); XCTAssertEqual(value, 702); - XCTAssertTrue([dict valueForKey:14 value:NULL]); - XCTAssertTrue([dict valueForKey:14 value:&value]); + XCTAssertTrue([dict getEnum:NULL forKey:14]); + XCTAssertTrue([dict getEnum:&value forKey:14]); XCTAssertEqual(value, kGPBUnrecognizedEnumeratorValue); - XCTAssertTrue([dict valueForKey:14 rawValue:NULL]); - XCTAssertTrue([dict valueForKey:14 rawValue:&value]); + XCTAssertTrue([dict getRawValue:NULL forKey:14]); + XCTAssertTrue([dict getRawValue:&value forKey:14]); XCTAssertEqual(value, 803); [dict2 release]; } @@ -3185,51 +3185,51 @@ static BOOL TestingEnum_IsValidValue(int32_t value) { XCTAssertNotNil(dict); XCTAssertEqual(dict.count, 4U); - [dict removeValueForKey:12]; + [dict removeEnumForKey:12]; XCTAssertEqual(dict.count, 3U); int32_t value; - XCTAssertTrue([dict valueForKey:11 value:NULL]); - XCTAssertTrue([dict valueForKey:11 value:&value]); + XCTAssertTrue([dict getEnum:NULL forKey:11]); + XCTAssertTrue([dict getEnum:&value forKey:11]); XCTAssertEqual(value, 700); - XCTAssertFalse([dict valueForKey:12 value:NULL]); - XCTAssertTrue([dict valueForKey:13 value:NULL]); - XCTAssertTrue([dict valueForKey:13 value:&value]); + XCTAssertFalse([dict getEnum:NULL forKey:12]); + XCTAssertTrue([dict getEnum:NULL forKey:13]); + XCTAssertTrue([dict getEnum:&value forKey:13]); XCTAssertEqual(value, 702); - XCTAssertTrue([dict valueForKey:14 rawValue:NULL]); - XCTAssertTrue([dict valueForKey:14 rawValue:&value]); + XCTAssertTrue([dict getRawValue:NULL forKey:14]); + XCTAssertTrue([dict getRawValue:&value forKey:14]); XCTAssertEqual(value, 803); // Remove again does nothing. - [dict removeValueForKey:12]; + [dict removeEnumForKey:12]; XCTAssertEqual(dict.count, 3U); - XCTAssertTrue([dict valueForKey:11 value:NULL]); - XCTAssertTrue([dict valueForKey:11 value:&value]); + XCTAssertTrue([dict getEnum:NULL forKey:11]); + XCTAssertTrue([dict getEnum:&value forKey:11]); XCTAssertEqual(value, 700); - XCTAssertFalse([dict valueForKey:12 value:NULL]); - XCTAssertTrue([dict valueForKey:13 value:NULL]); - XCTAssertTrue([dict valueForKey:13 value:&value]); + XCTAssertFalse([dict getEnum:NULL forKey:12]); + XCTAssertTrue([dict getEnum:NULL forKey:13]); + XCTAssertTrue([dict getEnum:&value forKey:13]); XCTAssertEqual(value, 702); - XCTAssertTrue([dict valueForKey:14 rawValue:NULL]); - XCTAssertTrue([dict valueForKey:14 rawValue:&value]); + XCTAssertTrue([dict getRawValue:NULL forKey:14]); + XCTAssertTrue([dict getRawValue:&value forKey:14]); XCTAssertEqual(value, 803); - [dict removeValueForKey:14]; + [dict removeEnumForKey:14]; XCTAssertEqual(dict.count, 2U); - XCTAssertTrue([dict valueForKey:11 value:NULL]); - XCTAssertTrue([dict valueForKey:11 value:&value]); + XCTAssertTrue([dict getEnum:NULL forKey:11]); + XCTAssertTrue([dict getEnum:&value forKey:11]); XCTAssertEqual(value, 700); - XCTAssertFalse([dict valueForKey:12 value:NULL]); - XCTAssertTrue([dict valueForKey:13 value:NULL]); - XCTAssertTrue([dict valueForKey:13 value:&value]); + XCTAssertFalse([dict getEnum:NULL forKey:12]); + XCTAssertTrue([dict getEnum:NULL forKey:13]); + XCTAssertTrue([dict getEnum:&value forKey:13]); XCTAssertEqual(value, 702); - XCTAssertFalse([dict valueForKey:14 value:NULL]); + XCTAssertFalse([dict getEnum:NULL forKey:14]); [dict removeAll]; XCTAssertEqual(dict.count, 0U); - XCTAssertFalse([dict valueForKey:11 value:NULL]); - XCTAssertFalse([dict valueForKey:12 value:NULL]); - XCTAssertFalse([dict valueForKey:13 value:NULL]); - XCTAssertFalse([dict valueForKey:14 value:NULL]); + XCTAssertFalse([dict getEnum:NULL forKey:11]); + XCTAssertFalse([dict getEnum:NULL forKey:12]); + XCTAssertFalse([dict getEnum:NULL forKey:13]); + XCTAssertFalse([dict getEnum:NULL forKey:14]); [dict release]; } @@ -3244,63 +3244,63 @@ static BOOL TestingEnum_IsValidValue(int32_t value) { XCTAssertNotNil(dict); XCTAssertEqual(dict.count, 4U); int32_t value; - XCTAssertTrue([dict valueForKey:11 value:NULL]); - XCTAssertTrue([dict valueForKey:11 value:&value]); + XCTAssertTrue([dict getEnum:NULL forKey:11]); + XCTAssertTrue([dict getEnum:&value forKey:11]); XCTAssertEqual(value, 700); - XCTAssertTrue([dict valueForKey:12 rawValue:NULL]); - XCTAssertTrue([dict valueForKey:12 rawValue:&value]); + XCTAssertTrue([dict getRawValue:NULL forKey:12]); + XCTAssertTrue([dict getRawValue:&value forKey:12]); XCTAssertEqual(value, 801); - XCTAssertTrue([dict valueForKey:13 value:NULL]); - XCTAssertTrue([dict valueForKey:13 value:&value]); + XCTAssertTrue([dict getEnum:NULL forKey:13]); + XCTAssertTrue([dict getEnum:&value forKey:13]); XCTAssertEqual(value, 702); - XCTAssertTrue([dict valueForKey:14 rawValue:NULL]); - XCTAssertTrue([dict valueForKey:14 rawValue:&value]); + XCTAssertTrue([dict getRawValue:NULL forKey:14]); + XCTAssertTrue([dict getRawValue:&value forKey:14]); XCTAssertEqual(value, 803); - XCTAssertThrowsSpecificNamed([dict setValue:803 forKey:11], // Unknown + XCTAssertThrowsSpecificNamed([dict setEnum:803 forKey:11], // Unknown NSException, NSInvalidArgumentException); XCTAssertEqual(dict.count, 4U); - XCTAssertTrue([dict valueForKey:11 value:NULL]); - XCTAssertTrue([dict valueForKey:11 value:&value]); + XCTAssertTrue([dict getEnum:NULL forKey:11]); + XCTAssertTrue([dict getEnum:&value forKey:11]); XCTAssertEqual(value, 700); - XCTAssertTrue([dict valueForKey:12 rawValue:NULL]); - XCTAssertTrue([dict valueForKey:12 rawValue:&value]); + XCTAssertTrue([dict getRawValue:NULL forKey:12]); + XCTAssertTrue([dict getRawValue:&value forKey:12]); XCTAssertEqual(value, 801); - XCTAssertTrue([dict valueForKey:13 value:NULL]); - XCTAssertTrue([dict valueForKey:13 value:&value]); + XCTAssertTrue([dict getEnum:NULL forKey:13]); + XCTAssertTrue([dict getEnum:&value forKey:13]); XCTAssertEqual(value, 702); - XCTAssertTrue([dict valueForKey:14 rawValue:NULL]); - XCTAssertTrue([dict valueForKey:14 rawValue:&value]); + XCTAssertTrue([dict getRawValue:NULL forKey:14]); + XCTAssertTrue([dict getRawValue:&value forKey:14]); XCTAssertEqual(value, 803); [dict setRawValue:803 forKey:11]; // Unknown XCTAssertEqual(dict.count, 4U); - XCTAssertTrue([dict valueForKey:11 rawValue:NULL]); - XCTAssertTrue([dict valueForKey:11 rawValue:&value]); + XCTAssertTrue([dict getRawValue:NULL forKey:11]); + XCTAssertTrue([dict getRawValue:&value forKey:11]); XCTAssertEqual(value, 803); - XCTAssertTrue([dict valueForKey:12 rawValue:NULL]); - XCTAssertTrue([dict valueForKey:12 rawValue:&value]); + XCTAssertTrue([dict getRawValue:NULL forKey:12]); + XCTAssertTrue([dict getRawValue:&value forKey:12]); XCTAssertEqual(value, 801); - XCTAssertTrue([dict valueForKey:13 value:NULL]); - XCTAssertTrue([dict valueForKey:13 value:&value]); + XCTAssertTrue([dict getEnum:NULL forKey:13]); + XCTAssertTrue([dict getEnum:&value forKey:13]); XCTAssertEqual(value, 702); - XCTAssertTrue([dict valueForKey:14 rawValue:NULL]); - XCTAssertTrue([dict valueForKey:14 rawValue:&value]); + XCTAssertTrue([dict getRawValue:NULL forKey:14]); + XCTAssertTrue([dict getRawValue:&value forKey:14]); XCTAssertEqual(value, 803); [dict setRawValue:700 forKey:14]; XCTAssertEqual(dict.count, 4U); - XCTAssertTrue([dict valueForKey:11 rawValue:NULL]); - XCTAssertTrue([dict valueForKey:11 rawValue:&value]); + XCTAssertTrue([dict getRawValue:NULL forKey:11]); + XCTAssertTrue([dict getRawValue:&value forKey:11]); XCTAssertEqual(value, 803); - XCTAssertTrue([dict valueForKey:12 rawValue:NULL]); - XCTAssertTrue([dict valueForKey:12 rawValue:&value]); + XCTAssertTrue([dict getRawValue:NULL forKey:12]); + XCTAssertTrue([dict getRawValue:&value forKey:12]); XCTAssertEqual(value, 801); - XCTAssertTrue([dict valueForKey:13 value:NULL]); - XCTAssertTrue([dict valueForKey:13 value:&value]); + XCTAssertTrue([dict getEnum:NULL forKey:13]); + XCTAssertTrue([dict getEnum:&value forKey:13]); XCTAssertEqual(value, 702); - XCTAssertTrue([dict valueForKey:14 value:NULL]); - XCTAssertTrue([dict valueForKey:14 value:&value]); + XCTAssertTrue([dict getEnum:NULL forKey:14]); + XCTAssertTrue([dict getEnum:&value forKey:14]); XCTAssertEqual(value, 700); const int32_t kKeys2[] = { 12, 13 }; @@ -3313,17 +3313,17 @@ static BOOL TestingEnum_IsValidValue(int32_t value) { XCTAssertNotNil(dict2); [dict addRawEntriesFromDictionary:dict2]; XCTAssertEqual(dict.count, 4U); - XCTAssertTrue([dict valueForKey:11 rawValue:NULL]); - XCTAssertTrue([dict valueForKey:11 rawValue:&value]); + XCTAssertTrue([dict getRawValue:NULL forKey:11]); + XCTAssertTrue([dict getRawValue:&value forKey:11]); XCTAssertEqual(value, 803); - XCTAssertTrue([dict valueForKey:12 value:NULL]); - XCTAssertTrue([dict valueForKey:12 value:&value]); + XCTAssertTrue([dict getEnum:NULL forKey:12]); + XCTAssertTrue([dict getEnum:&value forKey:12]); XCTAssertEqual(value, 702); - XCTAssertTrue([dict valueForKey:13 rawValue:NULL]); - XCTAssertTrue([dict valueForKey:13 rawValue:&value]); + XCTAssertTrue([dict getRawValue:NULL forKey:13]); + XCTAssertTrue([dict getRawValue:&value forKey:13]); XCTAssertEqual(value, 801); - XCTAssertTrue([dict valueForKey:14 value:NULL]); - XCTAssertTrue([dict valueForKey:14 value:&value]); + XCTAssertTrue([dict getEnum:NULL forKey:14]); + XCTAssertTrue([dict getEnum:&value forKey:14]); XCTAssertEqual(value, 700); [dict2 release]; @@ -3559,8 +3559,8 @@ static BOOL TestingEnum_IsValidValue(int32_t value) { const NSString* kObjects[] = { @"abc", @"def", @"ghi", @"jkl" }; GPBInt32ObjectDictionary *dict = [[GPBInt32ObjectDictionary alloc] initWithObjects:kObjects - forKeys:kKeys - count:GPBARRAYSIZE(kObjects)]; + forKeys:kKeys + count:GPBARRAYSIZE(kObjects)]; XCTAssertNotNil(dict); XCTAssertEqual(dict.count, 4U); @@ -3600,8 +3600,8 @@ static BOOL TestingEnum_IsValidValue(int32_t value) { const NSString* kObjects[] = { @"abc", @"def", @"ghi", @"jkl" }; GPBInt32ObjectDictionary *dict = [[GPBInt32ObjectDictionary alloc] initWithObjects:kObjects - forKeys:kKeys - count:GPBARRAYSIZE(kObjects)]; + forKeys:kKeys + count:GPBARRAYSIZE(kObjects)]; XCTAssertNotNil(dict); XCTAssertEqual(dict.count, 4U); XCTAssertEqualObjects([dict objectForKey:11], @"abc"); diff --git a/objectivec/Tests/GPBDictionaryTests+Int64.m b/objectivec/Tests/GPBDictionaryTests+Int64.m index 66bc6487..b90cdf8c 100644 --- a/objectivec/Tests/GPBDictionaryTests+Int64.m +++ b/objectivec/Tests/GPBDictionaryTests+Int64.m @@ -45,10 +45,10 @@ // To let the testing macros work, add some extra methods to simplify things. @interface GPBInt64EnumDictionary (TestingTweak) -+ (instancetype)dictionaryWithValue:(int32_t)value forKey:(int64_t)key; -- (instancetype)initWithValues:(const int32_t [])values - forKeys:(const int64_t [])keys - count:(NSUInteger)count; ++ (instancetype)dictionaryWithEnum:(int32_t)value forKey:(int64_t)key; +- (instancetype)initWithEnums:(const int32_t [])values + forKeys:(const int64_t [])keys + count:(NSUInteger)count; @end static BOOL TestingEnum_IsValidValue(int32_t value) { @@ -64,7 +64,7 @@ static BOOL TestingEnum_IsValidValue(int32_t value) { } @implementation GPBInt64EnumDictionary (TestingTweak) -+ (instancetype)dictionaryWithValue:(int32_t)value forKey:(int64_t)key { ++ (instancetype)dictionaryWithEnum:(int32_t)value forKey:(int64_t)key { // Cast is needed to compiler knows what class we are invoking initWithValues: on to get the // type correct. return [[(GPBInt64EnumDictionary*)[self alloc] initWithValidationFunction:TestingEnum_IsValidValue @@ -72,9 +72,9 @@ static BOOL TestingEnum_IsValidValue(int32_t value) { forKeys:&key count:1] autorelease]; } -- (instancetype)initWithValues:(const int32_t [])values - forKeys:(const int64_t [])keys - count:(NSUInteger)count { +- (instancetype)initWithEnums:(const int32_t [])values + forKeys:(const int64_t [])keys + count:(NSUInteger)count { return [self initWithValidationFunction:TestingEnum_IsValidValue rawValues:values forKeys:keys @@ -94,8 +94,8 @@ static BOOL TestingEnum_IsValidValue(int32_t value) { GPBInt64UInt32Dictionary *dict = [[GPBInt64UInt32Dictionary alloc] init]; XCTAssertNotNil(dict); XCTAssertEqual(dict.count, 0U); - XCTAssertFalse([dict valueForKey:21LL value:NULL]); - [dict enumerateKeysAndValuesUsingBlock:^(int64_t aKey, uint32_t aValue, BOOL *stop) { + XCTAssertFalse([dict getUInt32:NULL forKey:21LL]); + [dict enumerateKeysAndUInt32sUsingBlock:^(int64_t aKey, uint32_t aValue, BOOL *stop) { #pragma unused(aKey, aValue, stop) XCTFail(@"Shouldn't get here!"); }]; @@ -103,15 +103,15 @@ static BOOL TestingEnum_IsValidValue(int32_t value) { } - (void)testOne { - GPBInt64UInt32Dictionary *dict = [GPBInt64UInt32Dictionary dictionaryWithValue:100U forKey:21LL]; + GPBInt64UInt32Dictionary *dict = [GPBInt64UInt32Dictionary dictionaryWithUInt32:100U forKey:21LL]; XCTAssertNotNil(dict); XCTAssertEqual(dict.count, 1U); uint32_t value; - XCTAssertTrue([dict valueForKey:21LL value:NULL]); - XCTAssertTrue([dict valueForKey:21LL value:&value]); + XCTAssertTrue([dict getUInt32:NULL forKey:21LL]); + XCTAssertTrue([dict getUInt32:&value forKey:21LL]); XCTAssertEqual(value, 100U); - XCTAssertFalse([dict valueForKey:22LL value:NULL]); - [dict enumerateKeysAndValuesUsingBlock:^(int64_t aKey, uint32_t aValue, BOOL *stop) { + XCTAssertFalse([dict getUInt32:NULL forKey:22LL]); + [dict enumerateKeysAndUInt32sUsingBlock:^(int64_t aKey, uint32_t aValue, BOOL *stop) { XCTAssertEqual(aKey, 21LL); XCTAssertEqual(aValue, 100U); XCTAssertNotEqual(stop, NULL); @@ -122,27 +122,27 @@ static BOOL TestingEnum_IsValidValue(int32_t value) { const int64_t kKeys[] = { 21LL, 22LL, 23LL }; const uint32_t kValues[] = { 100U, 101U, 102U }; GPBInt64UInt32Dictionary *dict = - [[GPBInt64UInt32Dictionary alloc] initWithValues:kValues - forKeys:kKeys - count:GPBARRAYSIZE(kValues)]; + [[GPBInt64UInt32Dictionary alloc] initWithUInt32s:kValues + forKeys:kKeys + count:GPBARRAYSIZE(kValues)]; XCTAssertNotNil(dict); XCTAssertEqual(dict.count, 3U); uint32_t value; - XCTAssertTrue([dict valueForKey:21LL value:NULL]); - XCTAssertTrue([dict valueForKey:21LL value:&value]); + XCTAssertTrue([dict getUInt32:NULL forKey:21LL]); + XCTAssertTrue([dict getUInt32:&value forKey:21LL]); XCTAssertEqual(value, 100U); - XCTAssertTrue([dict valueForKey:22LL value:NULL]); - XCTAssertTrue([dict valueForKey:22LL value:&value]); + XCTAssertTrue([dict getUInt32:NULL forKey:22LL]); + XCTAssertTrue([dict getUInt32:&value forKey:22LL]); XCTAssertEqual(value, 101U); - XCTAssertTrue([dict valueForKey:23LL value:NULL]); - XCTAssertTrue([dict valueForKey:23LL value:&value]); + XCTAssertTrue([dict getUInt32:NULL forKey:23LL]); + XCTAssertTrue([dict getUInt32:&value forKey:23LL]); XCTAssertEqual(value, 102U); - XCTAssertFalse([dict valueForKey:24LL value:NULL]); + XCTAssertFalse([dict getUInt32:NULL forKey:24LL]); __block NSUInteger idx = 0; int64_t *seenKeys = malloc(3 * sizeof(int64_t)); uint32_t *seenValues = malloc(3 * sizeof(uint32_t)); - [dict enumerateKeysAndValuesUsingBlock:^(int64_t aKey, uint32_t aValue, BOOL *stop) { + [dict enumerateKeysAndUInt32sUsingBlock:^(int64_t aKey, uint32_t aValue, BOOL *stop) { XCTAssertLessThan(idx, 3U); seenKeys[idx] = aKey; seenValues[idx] = aValue; @@ -164,7 +164,7 @@ static BOOL TestingEnum_IsValidValue(int32_t value) { // Stopping the enumeration. idx = 0; - [dict enumerateKeysAndValuesUsingBlock:^(int64_t aKey, uint32_t aValue, BOOL *stop) { + [dict enumerateKeysAndUInt32sUsingBlock:^(int64_t aKey, uint32_t aValue, BOOL *stop) { #pragma unused(aKey, aValue) if (idx == 1) *stop = YES; XCTAssertNotEqual(idx, 2U); @@ -180,29 +180,29 @@ static BOOL TestingEnum_IsValidValue(int32_t value) { const uint32_t kValues2[] = { 100U, 103U, 102U }; const uint32_t kValues3[] = { 100U, 101U, 102U, 103U }; GPBInt64UInt32Dictionary *dict1 = - [[GPBInt64UInt32Dictionary alloc] initWithValues:kValues1 - forKeys:kKeys1 - count:GPBARRAYSIZE(kValues1)]; + [[GPBInt64UInt32Dictionary alloc] initWithUInt32s:kValues1 + forKeys:kKeys1 + count:GPBARRAYSIZE(kValues1)]; XCTAssertNotNil(dict1); GPBInt64UInt32Dictionary *dict1prime = - [[GPBInt64UInt32Dictionary alloc] initWithValues:kValues1 - forKeys:kKeys1 - count:GPBARRAYSIZE(kValues1)]; + [[GPBInt64UInt32Dictionary alloc] initWithUInt32s:kValues1 + forKeys:kKeys1 + count:GPBARRAYSIZE(kValues1)]; XCTAssertNotNil(dict1prime); GPBInt64UInt32Dictionary *dict2 = - [[GPBInt64UInt32Dictionary alloc] initWithValues:kValues2 - forKeys:kKeys1 - count:GPBARRAYSIZE(kValues2)]; + [[GPBInt64UInt32Dictionary alloc] initWithUInt32s:kValues2 + forKeys:kKeys1 + count:GPBARRAYSIZE(kValues2)]; XCTAssertNotNil(dict2); GPBInt64UInt32Dictionary *dict3 = - [[GPBInt64UInt32Dictionary alloc] initWithValues:kValues1 - forKeys:kKeys2 - count:GPBARRAYSIZE(kValues1)]; + [[GPBInt64UInt32Dictionary alloc] initWithUInt32s:kValues1 + forKeys:kKeys2 + count:GPBARRAYSIZE(kValues1)]; XCTAssertNotNil(dict3); GPBInt64UInt32Dictionary *dict4 = - [[GPBInt64UInt32Dictionary alloc] initWithValues:kValues3 - forKeys:kKeys1 - count:GPBARRAYSIZE(kValues3)]; + [[GPBInt64UInt32Dictionary alloc] initWithUInt32s:kValues3 + forKeys:kKeys1 + count:GPBARRAYSIZE(kValues3)]; XCTAssertNotNil(dict4); // 1/1Prime should be different objects, but equal. @@ -231,9 +231,9 @@ static BOOL TestingEnum_IsValidValue(int32_t value) { const int64_t kKeys[] = { 21LL, 22LL, 23LL, 24LL }; const uint32_t kValues[] = { 100U, 101U, 102U, 103U }; GPBInt64UInt32Dictionary *dict = - [[GPBInt64UInt32Dictionary alloc] initWithValues:kValues - forKeys:kKeys - count:GPBARRAYSIZE(kValues)]; + [[GPBInt64UInt32Dictionary alloc] initWithUInt32s:kValues + forKeys:kKeys + count:GPBARRAYSIZE(kValues)]; XCTAssertNotNil(dict); GPBInt64UInt32Dictionary *dict2 = [dict copy]; @@ -252,9 +252,9 @@ static BOOL TestingEnum_IsValidValue(int32_t value) { const int64_t kKeys[] = { 21LL, 22LL, 23LL, 24LL }; const uint32_t kValues[] = { 100U, 101U, 102U, 103U }; GPBInt64UInt32Dictionary *dict = - [[GPBInt64UInt32Dictionary alloc] initWithValues:kValues - forKeys:kKeys - count:GPBARRAYSIZE(kValues)]; + [[GPBInt64UInt32Dictionary alloc] initWithUInt32s:kValues + forKeys:kKeys + count:GPBARRAYSIZE(kValues)]; XCTAssertNotNil(dict); GPBInt64UInt32Dictionary *dict2 = @@ -272,31 +272,31 @@ static BOOL TestingEnum_IsValidValue(int32_t value) { XCTAssertNotNil(dict); XCTAssertEqual(dict.count, 0U); - [dict setValue:100U forKey:21LL]; + [dict setUInt32:100U forKey:21LL]; XCTAssertEqual(dict.count, 1U); const int64_t kKeys[] = { 22LL, 23LL, 24LL }; const uint32_t kValues[] = { 101U, 102U, 103U }; GPBInt64UInt32Dictionary *dict2 = - [[GPBInt64UInt32Dictionary alloc] initWithValues:kValues - forKeys:kKeys - count:GPBARRAYSIZE(kValues)]; + [[GPBInt64UInt32Dictionary alloc] initWithUInt32s:kValues + forKeys:kKeys + count:GPBARRAYSIZE(kValues)]; XCTAssertNotNil(dict2); [dict addEntriesFromDictionary:dict2]; XCTAssertEqual(dict.count, 4U); uint32_t value; - XCTAssertTrue([dict valueForKey:21LL value:NULL]); - XCTAssertTrue([dict valueForKey:21LL value:&value]); + XCTAssertTrue([dict getUInt32:NULL forKey:21LL]); + XCTAssertTrue([dict getUInt32:&value forKey:21LL]); XCTAssertEqual(value, 100U); - XCTAssertTrue([dict valueForKey:22LL value:NULL]); - XCTAssertTrue([dict valueForKey:22LL value:&value]); + XCTAssertTrue([dict getUInt32:NULL forKey:22LL]); + XCTAssertTrue([dict getUInt32:&value forKey:22LL]); XCTAssertEqual(value, 101U); - XCTAssertTrue([dict valueForKey:23LL value:NULL]); - XCTAssertTrue([dict valueForKey:23LL value:&value]); + XCTAssertTrue([dict getUInt32:NULL forKey:23LL]); + XCTAssertTrue([dict getUInt32:&value forKey:23LL]); XCTAssertEqual(value, 102U); - XCTAssertTrue([dict valueForKey:24LL value:NULL]); - XCTAssertTrue([dict valueForKey:24LL value:&value]); + XCTAssertTrue([dict getUInt32:NULL forKey:24LL]); + XCTAssertTrue([dict getUInt32:&value forKey:24LL]); XCTAssertEqual(value, 103U); [dict2 release]; } @@ -305,57 +305,57 @@ static BOOL TestingEnum_IsValidValue(int32_t value) { const int64_t kKeys[] = { 21LL, 22LL, 23LL, 24LL }; const uint32_t kValues[] = { 100U, 101U, 102U, 103U }; GPBInt64UInt32Dictionary *dict = - [[GPBInt64UInt32Dictionary alloc] initWithValues:kValues - forKeys:kKeys - count:GPBARRAYSIZE(kValues)]; + [[GPBInt64UInt32Dictionary alloc] initWithUInt32s:kValues + forKeys:kKeys + count:GPBARRAYSIZE(kValues)]; XCTAssertNotNil(dict); XCTAssertEqual(dict.count, 4U); - [dict removeValueForKey:22LL]; + [dict removeUInt32ForKey:22LL]; XCTAssertEqual(dict.count, 3U); uint32_t value; - XCTAssertTrue([dict valueForKey:21LL value:NULL]); - XCTAssertTrue([dict valueForKey:21LL value:&value]); + XCTAssertTrue([dict getUInt32:NULL forKey:21LL]); + XCTAssertTrue([dict getUInt32:&value forKey:21LL]); XCTAssertEqual(value, 100U); - XCTAssertFalse([dict valueForKey:22LL value:NULL]); - XCTAssertTrue([dict valueForKey:23LL value:NULL]); - XCTAssertTrue([dict valueForKey:23LL value:&value]); + XCTAssertFalse([dict getUInt32:NULL forKey:22LL]); + XCTAssertTrue([dict getUInt32:NULL forKey:23LL]); + XCTAssertTrue([dict getUInt32:&value forKey:23LL]); XCTAssertEqual(value, 102U); - XCTAssertTrue([dict valueForKey:24LL value:NULL]); - XCTAssertTrue([dict valueForKey:24LL value:&value]); + XCTAssertTrue([dict getUInt32:NULL forKey:24LL]); + XCTAssertTrue([dict getUInt32:&value forKey:24LL]); XCTAssertEqual(value, 103U); // Remove again does nothing. - [dict removeValueForKey:22LL]; + [dict removeUInt32ForKey:22LL]; XCTAssertEqual(dict.count, 3U); - XCTAssertTrue([dict valueForKey:21LL value:NULL]); - XCTAssertTrue([dict valueForKey:21LL value:&value]); + XCTAssertTrue([dict getUInt32:NULL forKey:21LL]); + XCTAssertTrue([dict getUInt32:&value forKey:21LL]); XCTAssertEqual(value, 100U); - XCTAssertFalse([dict valueForKey:22LL value:NULL]); - XCTAssertTrue([dict valueForKey:23LL value:NULL]); - XCTAssertTrue([dict valueForKey:23LL value:&value]); + XCTAssertFalse([dict getUInt32:NULL forKey:22LL]); + XCTAssertTrue([dict getUInt32:NULL forKey:23LL]); + XCTAssertTrue([dict getUInt32:&value forKey:23LL]); XCTAssertEqual(value, 102U); - XCTAssertTrue([dict valueForKey:24LL value:NULL]); - XCTAssertTrue([dict valueForKey:24LL value:&value]); + XCTAssertTrue([dict getUInt32:NULL forKey:24LL]); + XCTAssertTrue([dict getUInt32:&value forKey:24LL]); XCTAssertEqual(value, 103U); - [dict removeValueForKey:24LL]; + [dict removeUInt32ForKey:24LL]; XCTAssertEqual(dict.count, 2U); - XCTAssertTrue([dict valueForKey:21LL value:NULL]); - XCTAssertTrue([dict valueForKey:21LL value:&value]); + XCTAssertTrue([dict getUInt32:NULL forKey:21LL]); + XCTAssertTrue([dict getUInt32:&value forKey:21LL]); XCTAssertEqual(value, 100U); - XCTAssertFalse([dict valueForKey:22LL value:NULL]); - XCTAssertTrue([dict valueForKey:23LL value:NULL]); - XCTAssertTrue([dict valueForKey:23LL value:&value]); + XCTAssertFalse([dict getUInt32:NULL forKey:22LL]); + XCTAssertTrue([dict getUInt32:NULL forKey:23LL]); + XCTAssertTrue([dict getUInt32:&value forKey:23LL]); XCTAssertEqual(value, 102U); - XCTAssertFalse([dict valueForKey:24LL value:NULL]); + XCTAssertFalse([dict getUInt32:NULL forKey:24LL]); [dict removeAll]; XCTAssertEqual(dict.count, 0U); - XCTAssertFalse([dict valueForKey:21LL value:NULL]); - XCTAssertFalse([dict valueForKey:22LL value:NULL]); - XCTAssertFalse([dict valueForKey:23LL value:NULL]); - XCTAssertFalse([dict valueForKey:24LL value:NULL]); + XCTAssertFalse([dict getUInt32:NULL forKey:21LL]); + XCTAssertFalse([dict getUInt32:NULL forKey:22LL]); + XCTAssertFalse([dict getUInt32:NULL forKey:23LL]); + XCTAssertFalse([dict getUInt32:NULL forKey:24LL]); [dict release]; } @@ -363,75 +363,75 @@ static BOOL TestingEnum_IsValidValue(int32_t value) { const int64_t kKeys[] = { 21LL, 22LL, 23LL, 24LL }; const uint32_t kValues[] = { 100U, 101U, 102U, 103U }; GPBInt64UInt32Dictionary *dict = - [[GPBInt64UInt32Dictionary alloc] initWithValues:kValues - forKeys:kKeys - count:GPBARRAYSIZE(kValues)]; + [[GPBInt64UInt32Dictionary alloc] initWithUInt32s:kValues + forKeys:kKeys + count:GPBARRAYSIZE(kValues)]; XCTAssertNotNil(dict); XCTAssertEqual(dict.count, 4U); uint32_t value; - XCTAssertTrue([dict valueForKey:21LL value:NULL]); - XCTAssertTrue([dict valueForKey:21LL value:&value]); + XCTAssertTrue([dict getUInt32:NULL forKey:21LL]); + XCTAssertTrue([dict getUInt32:&value forKey:21LL]); XCTAssertEqual(value, 100U); - XCTAssertTrue([dict valueForKey:22LL value:NULL]); - XCTAssertTrue([dict valueForKey:22LL value:&value]); + XCTAssertTrue([dict getUInt32:NULL forKey:22LL]); + XCTAssertTrue([dict getUInt32:&value forKey:22LL]); XCTAssertEqual(value, 101U); - XCTAssertTrue([dict valueForKey:23LL value:NULL]); - XCTAssertTrue([dict valueForKey:23LL value:&value]); + XCTAssertTrue([dict getUInt32:NULL forKey:23LL]); + XCTAssertTrue([dict getUInt32:&value forKey:23LL]); XCTAssertEqual(value, 102U); - XCTAssertTrue([dict valueForKey:24LL value:NULL]); - XCTAssertTrue([dict valueForKey:24LL value:&value]); + XCTAssertTrue([dict getUInt32:NULL forKey:24LL]); + XCTAssertTrue([dict getUInt32:&value forKey:24LL]); XCTAssertEqual(value, 103U); - [dict setValue:103U forKey:21LL]; + [dict setUInt32:103U forKey:21LL]; XCTAssertEqual(dict.count, 4U); - XCTAssertTrue([dict valueForKey:21LL value:NULL]); - XCTAssertTrue([dict valueForKey:21LL value:&value]); + XCTAssertTrue([dict getUInt32:NULL forKey:21LL]); + XCTAssertTrue([dict getUInt32:&value forKey:21LL]); XCTAssertEqual(value, 103U); - XCTAssertTrue([dict valueForKey:22LL value:NULL]); - XCTAssertTrue([dict valueForKey:22LL value:&value]); + XCTAssertTrue([dict getUInt32:NULL forKey:22LL]); + XCTAssertTrue([dict getUInt32:&value forKey:22LL]); XCTAssertEqual(value, 101U); - XCTAssertTrue([dict valueForKey:23LL value:NULL]); - XCTAssertTrue([dict valueForKey:23LL value:&value]); + XCTAssertTrue([dict getUInt32:NULL forKey:23LL]); + XCTAssertTrue([dict getUInt32:&value forKey:23LL]); XCTAssertEqual(value, 102U); - XCTAssertTrue([dict valueForKey:24LL value:NULL]); - XCTAssertTrue([dict valueForKey:24LL value:&value]); + XCTAssertTrue([dict getUInt32:NULL forKey:24LL]); + XCTAssertTrue([dict getUInt32:&value forKey:24LL]); XCTAssertEqual(value, 103U); - [dict setValue:101U forKey:24LL]; + [dict setUInt32:101U forKey:24LL]; XCTAssertEqual(dict.count, 4U); - XCTAssertTrue([dict valueForKey:21LL value:NULL]); - XCTAssertTrue([dict valueForKey:21LL value:&value]); + XCTAssertTrue([dict getUInt32:NULL forKey:21LL]); + XCTAssertTrue([dict getUInt32:&value forKey:21LL]); XCTAssertEqual(value, 103U); - XCTAssertTrue([dict valueForKey:22LL value:NULL]); - XCTAssertTrue([dict valueForKey:22LL value:&value]); + XCTAssertTrue([dict getUInt32:NULL forKey:22LL]); + XCTAssertTrue([dict getUInt32:&value forKey:22LL]); XCTAssertEqual(value, 101U); - XCTAssertTrue([dict valueForKey:23LL value:NULL]); - XCTAssertTrue([dict valueForKey:23LL value:&value]); + XCTAssertTrue([dict getUInt32:NULL forKey:23LL]); + XCTAssertTrue([dict getUInt32:&value forKey:23LL]); XCTAssertEqual(value, 102U); - XCTAssertTrue([dict valueForKey:24LL value:NULL]); - XCTAssertTrue([dict valueForKey:24LL value:&value]); + XCTAssertTrue([dict getUInt32:NULL forKey:24LL]); + XCTAssertTrue([dict getUInt32:&value forKey:24LL]); XCTAssertEqual(value, 101U); const int64_t kKeys2[] = { 22LL, 23LL }; const uint32_t kValues2[] = { 102U, 100U }; GPBInt64UInt32Dictionary *dict2 = - [[GPBInt64UInt32Dictionary alloc] initWithValues:kValues2 - forKeys:kKeys2 - count:GPBARRAYSIZE(kValues2)]; + [[GPBInt64UInt32Dictionary alloc] initWithUInt32s:kValues2 + forKeys:kKeys2 + count:GPBARRAYSIZE(kValues2)]; XCTAssertNotNil(dict2); [dict addEntriesFromDictionary:dict2]; XCTAssertEqual(dict.count, 4U); - XCTAssertTrue([dict valueForKey:21LL value:NULL]); - XCTAssertTrue([dict valueForKey:21LL value:&value]); + XCTAssertTrue([dict getUInt32:NULL forKey:21LL]); + XCTAssertTrue([dict getUInt32:&value forKey:21LL]); XCTAssertEqual(value, 103U); - XCTAssertTrue([dict valueForKey:22LL value:NULL]); - XCTAssertTrue([dict valueForKey:22LL value:&value]); + XCTAssertTrue([dict getUInt32:NULL forKey:22LL]); + XCTAssertTrue([dict getUInt32:&value forKey:22LL]); XCTAssertEqual(value, 102U); - XCTAssertTrue([dict valueForKey:23LL value:NULL]); - XCTAssertTrue([dict valueForKey:23LL value:&value]); + XCTAssertTrue([dict getUInt32:NULL forKey:23LL]); + XCTAssertTrue([dict getUInt32:&value forKey:23LL]); XCTAssertEqual(value, 100U); - XCTAssertTrue([dict valueForKey:24LL value:NULL]); - XCTAssertTrue([dict valueForKey:24LL value:&value]); + XCTAssertTrue([dict getUInt32:NULL forKey:24LL]); + XCTAssertTrue([dict getUInt32:&value forKey:24LL]); XCTAssertEqual(value, 101U); [dict2 release]; @@ -451,8 +451,8 @@ static BOOL TestingEnum_IsValidValue(int32_t value) { GPBInt64Int32Dictionary *dict = [[GPBInt64Int32Dictionary alloc] init]; XCTAssertNotNil(dict); XCTAssertEqual(dict.count, 0U); - XCTAssertFalse([dict valueForKey:21LL value:NULL]); - [dict enumerateKeysAndValuesUsingBlock:^(int64_t aKey, int32_t aValue, BOOL *stop) { + XCTAssertFalse([dict getInt32:NULL forKey:21LL]); + [dict enumerateKeysAndInt32sUsingBlock:^(int64_t aKey, int32_t aValue, BOOL *stop) { #pragma unused(aKey, aValue, stop) XCTFail(@"Shouldn't get here!"); }]; @@ -460,15 +460,15 @@ static BOOL TestingEnum_IsValidValue(int32_t value) { } - (void)testOne { - GPBInt64Int32Dictionary *dict = [GPBInt64Int32Dictionary dictionaryWithValue:200 forKey:21LL]; + GPBInt64Int32Dictionary *dict = [GPBInt64Int32Dictionary dictionaryWithInt32:200 forKey:21LL]; XCTAssertNotNil(dict); XCTAssertEqual(dict.count, 1U); int32_t value; - XCTAssertTrue([dict valueForKey:21LL value:NULL]); - XCTAssertTrue([dict valueForKey:21LL value:&value]); + XCTAssertTrue([dict getInt32:NULL forKey:21LL]); + XCTAssertTrue([dict getInt32:&value forKey:21LL]); XCTAssertEqual(value, 200); - XCTAssertFalse([dict valueForKey:22LL value:NULL]); - [dict enumerateKeysAndValuesUsingBlock:^(int64_t aKey, int32_t aValue, BOOL *stop) { + XCTAssertFalse([dict getInt32:NULL forKey:22LL]); + [dict enumerateKeysAndInt32sUsingBlock:^(int64_t aKey, int32_t aValue, BOOL *stop) { XCTAssertEqual(aKey, 21LL); XCTAssertEqual(aValue, 200); XCTAssertNotEqual(stop, NULL); @@ -479,27 +479,27 @@ static BOOL TestingEnum_IsValidValue(int32_t value) { const int64_t kKeys[] = { 21LL, 22LL, 23LL }; const int32_t kValues[] = { 200, 201, 202 }; GPBInt64Int32Dictionary *dict = - [[GPBInt64Int32Dictionary alloc] initWithValues:kValues + [[GPBInt64Int32Dictionary alloc] initWithInt32s:kValues forKeys:kKeys count:GPBARRAYSIZE(kValues)]; XCTAssertNotNil(dict); XCTAssertEqual(dict.count, 3U); int32_t value; - XCTAssertTrue([dict valueForKey:21LL value:NULL]); - XCTAssertTrue([dict valueForKey:21LL value:&value]); + XCTAssertTrue([dict getInt32:NULL forKey:21LL]); + XCTAssertTrue([dict getInt32:&value forKey:21LL]); XCTAssertEqual(value, 200); - XCTAssertTrue([dict valueForKey:22LL value:NULL]); - XCTAssertTrue([dict valueForKey:22LL value:&value]); + XCTAssertTrue([dict getInt32:NULL forKey:22LL]); + XCTAssertTrue([dict getInt32:&value forKey:22LL]); XCTAssertEqual(value, 201); - XCTAssertTrue([dict valueForKey:23LL value:NULL]); - XCTAssertTrue([dict valueForKey:23LL value:&value]); + XCTAssertTrue([dict getInt32:NULL forKey:23LL]); + XCTAssertTrue([dict getInt32:&value forKey:23LL]); XCTAssertEqual(value, 202); - XCTAssertFalse([dict valueForKey:24LL value:NULL]); + XCTAssertFalse([dict getInt32:NULL forKey:24LL]); __block NSUInteger idx = 0; int64_t *seenKeys = malloc(3 * sizeof(int64_t)); int32_t *seenValues = malloc(3 * sizeof(int32_t)); - [dict enumerateKeysAndValuesUsingBlock:^(int64_t aKey, int32_t aValue, BOOL *stop) { + [dict enumerateKeysAndInt32sUsingBlock:^(int64_t aKey, int32_t aValue, BOOL *stop) { XCTAssertLessThan(idx, 3U); seenKeys[idx] = aKey; seenValues[idx] = aValue; @@ -521,7 +521,7 @@ static BOOL TestingEnum_IsValidValue(int32_t value) { // Stopping the enumeration. idx = 0; - [dict enumerateKeysAndValuesUsingBlock:^(int64_t aKey, int32_t aValue, BOOL *stop) { + [dict enumerateKeysAndInt32sUsingBlock:^(int64_t aKey, int32_t aValue, BOOL *stop) { #pragma unused(aKey, aValue) if (idx == 1) *stop = YES; XCTAssertNotEqual(idx, 2U); @@ -537,27 +537,27 @@ static BOOL TestingEnum_IsValidValue(int32_t value) { const int32_t kValues2[] = { 200, 203, 202 }; const int32_t kValues3[] = { 200, 201, 202, 203 }; GPBInt64Int32Dictionary *dict1 = - [[GPBInt64Int32Dictionary alloc] initWithValues:kValues1 + [[GPBInt64Int32Dictionary alloc] initWithInt32s:kValues1 forKeys:kKeys1 count:GPBARRAYSIZE(kValues1)]; XCTAssertNotNil(dict1); GPBInt64Int32Dictionary *dict1prime = - [[GPBInt64Int32Dictionary alloc] initWithValues:kValues1 + [[GPBInt64Int32Dictionary alloc] initWithInt32s:kValues1 forKeys:kKeys1 count:GPBARRAYSIZE(kValues1)]; XCTAssertNotNil(dict1prime); GPBInt64Int32Dictionary *dict2 = - [[GPBInt64Int32Dictionary alloc] initWithValues:kValues2 + [[GPBInt64Int32Dictionary alloc] initWithInt32s:kValues2 forKeys:kKeys1 count:GPBARRAYSIZE(kValues2)]; XCTAssertNotNil(dict2); GPBInt64Int32Dictionary *dict3 = - [[GPBInt64Int32Dictionary alloc] initWithValues:kValues1 + [[GPBInt64Int32Dictionary alloc] initWithInt32s:kValues1 forKeys:kKeys2 count:GPBARRAYSIZE(kValues1)]; XCTAssertNotNil(dict3); GPBInt64Int32Dictionary *dict4 = - [[GPBInt64Int32Dictionary alloc] initWithValues:kValues3 + [[GPBInt64Int32Dictionary alloc] initWithInt32s:kValues3 forKeys:kKeys1 count:GPBARRAYSIZE(kValues3)]; XCTAssertNotNil(dict4); @@ -588,7 +588,7 @@ static BOOL TestingEnum_IsValidValue(int32_t value) { const int64_t kKeys[] = { 21LL, 22LL, 23LL, 24LL }; const int32_t kValues[] = { 200, 201, 202, 203 }; GPBInt64Int32Dictionary *dict = - [[GPBInt64Int32Dictionary alloc] initWithValues:kValues + [[GPBInt64Int32Dictionary alloc] initWithInt32s:kValues forKeys:kKeys count:GPBARRAYSIZE(kValues)]; XCTAssertNotNil(dict); @@ -609,7 +609,7 @@ static BOOL TestingEnum_IsValidValue(int32_t value) { const int64_t kKeys[] = { 21LL, 22LL, 23LL, 24LL }; const int32_t kValues[] = { 200, 201, 202, 203 }; GPBInt64Int32Dictionary *dict = - [[GPBInt64Int32Dictionary alloc] initWithValues:kValues + [[GPBInt64Int32Dictionary alloc] initWithInt32s:kValues forKeys:kKeys count:GPBARRAYSIZE(kValues)]; XCTAssertNotNil(dict); @@ -629,13 +629,13 @@ static BOOL TestingEnum_IsValidValue(int32_t value) { XCTAssertNotNil(dict); XCTAssertEqual(dict.count, 0U); - [dict setValue:200 forKey:21LL]; + [dict setInt32:200 forKey:21LL]; XCTAssertEqual(dict.count, 1U); const int64_t kKeys[] = { 22LL, 23LL, 24LL }; const int32_t kValues[] = { 201, 202, 203 }; GPBInt64Int32Dictionary *dict2 = - [[GPBInt64Int32Dictionary alloc] initWithValues:kValues + [[GPBInt64Int32Dictionary alloc] initWithInt32s:kValues forKeys:kKeys count:GPBARRAYSIZE(kValues)]; XCTAssertNotNil(dict2); @@ -643,17 +643,17 @@ static BOOL TestingEnum_IsValidValue(int32_t value) { XCTAssertEqual(dict.count, 4U); int32_t value; - XCTAssertTrue([dict valueForKey:21LL value:NULL]); - XCTAssertTrue([dict valueForKey:21LL value:&value]); + XCTAssertTrue([dict getInt32:NULL forKey:21LL]); + XCTAssertTrue([dict getInt32:&value forKey:21LL]); XCTAssertEqual(value, 200); - XCTAssertTrue([dict valueForKey:22LL value:NULL]); - XCTAssertTrue([dict valueForKey:22LL value:&value]); + XCTAssertTrue([dict getInt32:NULL forKey:22LL]); + XCTAssertTrue([dict getInt32:&value forKey:22LL]); XCTAssertEqual(value, 201); - XCTAssertTrue([dict valueForKey:23LL value:NULL]); - XCTAssertTrue([dict valueForKey:23LL value:&value]); + XCTAssertTrue([dict getInt32:NULL forKey:23LL]); + XCTAssertTrue([dict getInt32:&value forKey:23LL]); XCTAssertEqual(value, 202); - XCTAssertTrue([dict valueForKey:24LL value:NULL]); - XCTAssertTrue([dict valueForKey:24LL value:&value]); + XCTAssertTrue([dict getInt32:NULL forKey:24LL]); + XCTAssertTrue([dict getInt32:&value forKey:24LL]); XCTAssertEqual(value, 203); [dict2 release]; } @@ -662,57 +662,57 @@ static BOOL TestingEnum_IsValidValue(int32_t value) { const int64_t kKeys[] = { 21LL, 22LL, 23LL, 24LL }; const int32_t kValues[] = { 200, 201, 202, 203 }; GPBInt64Int32Dictionary *dict = - [[GPBInt64Int32Dictionary alloc] initWithValues:kValues - forKeys:kKeys - count:GPBARRAYSIZE(kValues)]; + [[GPBInt64Int32Dictionary alloc] initWithInt32s:kValues + forKeys:kKeys + count:GPBARRAYSIZE(kValues)]; XCTAssertNotNil(dict); XCTAssertEqual(dict.count, 4U); - [dict removeValueForKey:22LL]; + [dict removeInt32ForKey:22LL]; XCTAssertEqual(dict.count, 3U); int32_t value; - XCTAssertTrue([dict valueForKey:21LL value:NULL]); - XCTAssertTrue([dict valueForKey:21LL value:&value]); + XCTAssertTrue([dict getInt32:NULL forKey:21LL]); + XCTAssertTrue([dict getInt32:&value forKey:21LL]); XCTAssertEqual(value, 200); - XCTAssertFalse([dict valueForKey:22LL value:NULL]); - XCTAssertTrue([dict valueForKey:23LL value:NULL]); - XCTAssertTrue([dict valueForKey:23LL value:&value]); + XCTAssertFalse([dict getInt32:NULL forKey:22LL]); + XCTAssertTrue([dict getInt32:NULL forKey:23LL]); + XCTAssertTrue([dict getInt32:&value forKey:23LL]); XCTAssertEqual(value, 202); - XCTAssertTrue([dict valueForKey:24LL value:NULL]); - XCTAssertTrue([dict valueForKey:24LL value:&value]); + XCTAssertTrue([dict getInt32:NULL forKey:24LL]); + XCTAssertTrue([dict getInt32:&value forKey:24LL]); XCTAssertEqual(value, 203); // Remove again does nothing. - [dict removeValueForKey:22LL]; + [dict removeInt32ForKey:22LL]; XCTAssertEqual(dict.count, 3U); - XCTAssertTrue([dict valueForKey:21LL value:NULL]); - XCTAssertTrue([dict valueForKey:21LL value:&value]); + XCTAssertTrue([dict getInt32:NULL forKey:21LL]); + XCTAssertTrue([dict getInt32:&value forKey:21LL]); XCTAssertEqual(value, 200); - XCTAssertFalse([dict valueForKey:22LL value:NULL]); - XCTAssertTrue([dict valueForKey:23LL value:NULL]); - XCTAssertTrue([dict valueForKey:23LL value:&value]); + XCTAssertFalse([dict getInt32:NULL forKey:22LL]); + XCTAssertTrue([dict getInt32:NULL forKey:23LL]); + XCTAssertTrue([dict getInt32:&value forKey:23LL]); XCTAssertEqual(value, 202); - XCTAssertTrue([dict valueForKey:24LL value:NULL]); - XCTAssertTrue([dict valueForKey:24LL value:&value]); + XCTAssertTrue([dict getInt32:NULL forKey:24LL]); + XCTAssertTrue([dict getInt32:&value forKey:24LL]); XCTAssertEqual(value, 203); - [dict removeValueForKey:24LL]; + [dict removeInt32ForKey:24LL]; XCTAssertEqual(dict.count, 2U); - XCTAssertTrue([dict valueForKey:21LL value:NULL]); - XCTAssertTrue([dict valueForKey:21LL value:&value]); + XCTAssertTrue([dict getInt32:NULL forKey:21LL]); + XCTAssertTrue([dict getInt32:&value forKey:21LL]); XCTAssertEqual(value, 200); - XCTAssertFalse([dict valueForKey:22LL value:NULL]); - XCTAssertTrue([dict valueForKey:23LL value:NULL]); - XCTAssertTrue([dict valueForKey:23LL value:&value]); + XCTAssertFalse([dict getInt32:NULL forKey:22LL]); + XCTAssertTrue([dict getInt32:NULL forKey:23LL]); + XCTAssertTrue([dict getInt32:&value forKey:23LL]); XCTAssertEqual(value, 202); - XCTAssertFalse([dict valueForKey:24LL value:NULL]); + XCTAssertFalse([dict getInt32:NULL forKey:24LL]); [dict removeAll]; XCTAssertEqual(dict.count, 0U); - XCTAssertFalse([dict valueForKey:21LL value:NULL]); - XCTAssertFalse([dict valueForKey:22LL value:NULL]); - XCTAssertFalse([dict valueForKey:23LL value:NULL]); - XCTAssertFalse([dict valueForKey:24LL value:NULL]); + XCTAssertFalse([dict getInt32:NULL forKey:21LL]); + XCTAssertFalse([dict getInt32:NULL forKey:22LL]); + XCTAssertFalse([dict getInt32:NULL forKey:23LL]); + XCTAssertFalse([dict getInt32:NULL forKey:24LL]); [dict release]; } @@ -720,75 +720,75 @@ static BOOL TestingEnum_IsValidValue(int32_t value) { const int64_t kKeys[] = { 21LL, 22LL, 23LL, 24LL }; const int32_t kValues[] = { 200, 201, 202, 203 }; GPBInt64Int32Dictionary *dict = - [[GPBInt64Int32Dictionary alloc] initWithValues:kValues - forKeys:kKeys - count:GPBARRAYSIZE(kValues)]; + [[GPBInt64Int32Dictionary alloc] initWithInt32s:kValues + forKeys:kKeys + count:GPBARRAYSIZE(kValues)]; XCTAssertNotNil(dict); XCTAssertEqual(dict.count, 4U); int32_t value; - XCTAssertTrue([dict valueForKey:21LL value:NULL]); - XCTAssertTrue([dict valueForKey:21LL value:&value]); + XCTAssertTrue([dict getInt32:NULL forKey:21LL]); + XCTAssertTrue([dict getInt32:&value forKey:21LL]); XCTAssertEqual(value, 200); - XCTAssertTrue([dict valueForKey:22LL value:NULL]); - XCTAssertTrue([dict valueForKey:22LL value:&value]); + XCTAssertTrue([dict getInt32:NULL forKey:22LL]); + XCTAssertTrue([dict getInt32:&value forKey:22LL]); XCTAssertEqual(value, 201); - XCTAssertTrue([dict valueForKey:23LL value:NULL]); - XCTAssertTrue([dict valueForKey:23LL value:&value]); + XCTAssertTrue([dict getInt32:NULL forKey:23LL]); + XCTAssertTrue([dict getInt32:&value forKey:23LL]); XCTAssertEqual(value, 202); - XCTAssertTrue([dict valueForKey:24LL value:NULL]); - XCTAssertTrue([dict valueForKey:24LL value:&value]); + XCTAssertTrue([dict getInt32:NULL forKey:24LL]); + XCTAssertTrue([dict getInt32:&value forKey:24LL]); XCTAssertEqual(value, 203); - [dict setValue:203 forKey:21LL]; + [dict setInt32:203 forKey:21LL]; XCTAssertEqual(dict.count, 4U); - XCTAssertTrue([dict valueForKey:21LL value:NULL]); - XCTAssertTrue([dict valueForKey:21LL value:&value]); + XCTAssertTrue([dict getInt32:NULL forKey:21LL]); + XCTAssertTrue([dict getInt32:&value forKey:21LL]); XCTAssertEqual(value, 203); - XCTAssertTrue([dict valueForKey:22LL value:NULL]); - XCTAssertTrue([dict valueForKey:22LL value:&value]); + XCTAssertTrue([dict getInt32:NULL forKey:22LL]); + XCTAssertTrue([dict getInt32:&value forKey:22LL]); XCTAssertEqual(value, 201); - XCTAssertTrue([dict valueForKey:23LL value:NULL]); - XCTAssertTrue([dict valueForKey:23LL value:&value]); + XCTAssertTrue([dict getInt32:NULL forKey:23LL]); + XCTAssertTrue([dict getInt32:&value forKey:23LL]); XCTAssertEqual(value, 202); - XCTAssertTrue([dict valueForKey:24LL value:NULL]); - XCTAssertTrue([dict valueForKey:24LL value:&value]); + XCTAssertTrue([dict getInt32:NULL forKey:24LL]); + XCTAssertTrue([dict getInt32:&value forKey:24LL]); XCTAssertEqual(value, 203); - [dict setValue:201 forKey:24LL]; + [dict setInt32:201 forKey:24LL]; XCTAssertEqual(dict.count, 4U); - XCTAssertTrue([dict valueForKey:21LL value:NULL]); - XCTAssertTrue([dict valueForKey:21LL value:&value]); + XCTAssertTrue([dict getInt32:NULL forKey:21LL]); + XCTAssertTrue([dict getInt32:&value forKey:21LL]); XCTAssertEqual(value, 203); - XCTAssertTrue([dict valueForKey:22LL value:NULL]); - XCTAssertTrue([dict valueForKey:22LL value:&value]); + XCTAssertTrue([dict getInt32:NULL forKey:22LL]); + XCTAssertTrue([dict getInt32:&value forKey:22LL]); XCTAssertEqual(value, 201); - XCTAssertTrue([dict valueForKey:23LL value:NULL]); - XCTAssertTrue([dict valueForKey:23LL value:&value]); + XCTAssertTrue([dict getInt32:NULL forKey:23LL]); + XCTAssertTrue([dict getInt32:&value forKey:23LL]); XCTAssertEqual(value, 202); - XCTAssertTrue([dict valueForKey:24LL value:NULL]); - XCTAssertTrue([dict valueForKey:24LL value:&value]); + XCTAssertTrue([dict getInt32:NULL forKey:24LL]); + XCTAssertTrue([dict getInt32:&value forKey:24LL]); XCTAssertEqual(value, 201); const int64_t kKeys2[] = { 22LL, 23LL }; const int32_t kValues2[] = { 202, 200 }; GPBInt64Int32Dictionary *dict2 = - [[GPBInt64Int32Dictionary alloc] initWithValues:kValues2 + [[GPBInt64Int32Dictionary alloc] initWithInt32s:kValues2 forKeys:kKeys2 count:GPBARRAYSIZE(kValues2)]; XCTAssertNotNil(dict2); [dict addEntriesFromDictionary:dict2]; XCTAssertEqual(dict.count, 4U); - XCTAssertTrue([dict valueForKey:21LL value:NULL]); - XCTAssertTrue([dict valueForKey:21LL value:&value]); + XCTAssertTrue([dict getInt32:NULL forKey:21LL]); + XCTAssertTrue([dict getInt32:&value forKey:21LL]); XCTAssertEqual(value, 203); - XCTAssertTrue([dict valueForKey:22LL value:NULL]); - XCTAssertTrue([dict valueForKey:22LL value:&value]); + XCTAssertTrue([dict getInt32:NULL forKey:22LL]); + XCTAssertTrue([dict getInt32:&value forKey:22LL]); XCTAssertEqual(value, 202); - XCTAssertTrue([dict valueForKey:23LL value:NULL]); - XCTAssertTrue([dict valueForKey:23LL value:&value]); + XCTAssertTrue([dict getInt32:NULL forKey:23LL]); + XCTAssertTrue([dict getInt32:&value forKey:23LL]); XCTAssertEqual(value, 200); - XCTAssertTrue([dict valueForKey:24LL value:NULL]); - XCTAssertTrue([dict valueForKey:24LL value:&value]); + XCTAssertTrue([dict getInt32:NULL forKey:24LL]); + XCTAssertTrue([dict getInt32:&value forKey:24LL]); XCTAssertEqual(value, 201); [dict2 release]; @@ -808,8 +808,8 @@ static BOOL TestingEnum_IsValidValue(int32_t value) { GPBInt64UInt64Dictionary *dict = [[GPBInt64UInt64Dictionary alloc] init]; XCTAssertNotNil(dict); XCTAssertEqual(dict.count, 0U); - XCTAssertFalse([dict valueForKey:21LL value:NULL]); - [dict enumerateKeysAndValuesUsingBlock:^(int64_t aKey, uint64_t aValue, BOOL *stop) { + XCTAssertFalse([dict getUInt64:NULL forKey:21LL]); + [dict enumerateKeysAndUInt64sUsingBlock:^(int64_t aKey, uint64_t aValue, BOOL *stop) { #pragma unused(aKey, aValue, stop) XCTFail(@"Shouldn't get here!"); }]; @@ -817,15 +817,15 @@ static BOOL TestingEnum_IsValidValue(int32_t value) { } - (void)testOne { - GPBInt64UInt64Dictionary *dict = [GPBInt64UInt64Dictionary dictionaryWithValue:300U forKey:21LL]; + GPBInt64UInt64Dictionary *dict = [GPBInt64UInt64Dictionary dictionaryWithUInt64:300U forKey:21LL]; XCTAssertNotNil(dict); XCTAssertEqual(dict.count, 1U); uint64_t value; - XCTAssertTrue([dict valueForKey:21LL value:NULL]); - XCTAssertTrue([dict valueForKey:21LL value:&value]); + XCTAssertTrue([dict getUInt64:NULL forKey:21LL]); + XCTAssertTrue([dict getUInt64:&value forKey:21LL]); XCTAssertEqual(value, 300U); - XCTAssertFalse([dict valueForKey:22LL value:NULL]); - [dict enumerateKeysAndValuesUsingBlock:^(int64_t aKey, uint64_t aValue, BOOL *stop) { + XCTAssertFalse([dict getUInt64:NULL forKey:22LL]); + [dict enumerateKeysAndUInt64sUsingBlock:^(int64_t aKey, uint64_t aValue, BOOL *stop) { XCTAssertEqual(aKey, 21LL); XCTAssertEqual(aValue, 300U); XCTAssertNotEqual(stop, NULL); @@ -836,27 +836,27 @@ static BOOL TestingEnum_IsValidValue(int32_t value) { const int64_t kKeys[] = { 21LL, 22LL, 23LL }; const uint64_t kValues[] = { 300U, 301U, 302U }; GPBInt64UInt64Dictionary *dict = - [[GPBInt64UInt64Dictionary alloc] initWithValues:kValues - forKeys:kKeys - count:GPBARRAYSIZE(kValues)]; + [[GPBInt64UInt64Dictionary alloc] initWithUInt64s:kValues + forKeys:kKeys + count:GPBARRAYSIZE(kValues)]; XCTAssertNotNil(dict); XCTAssertEqual(dict.count, 3U); uint64_t value; - XCTAssertTrue([dict valueForKey:21LL value:NULL]); - XCTAssertTrue([dict valueForKey:21LL value:&value]); + XCTAssertTrue([dict getUInt64:NULL forKey:21LL]); + XCTAssertTrue([dict getUInt64:&value forKey:21LL]); XCTAssertEqual(value, 300U); - XCTAssertTrue([dict valueForKey:22LL value:NULL]); - XCTAssertTrue([dict valueForKey:22LL value:&value]); + XCTAssertTrue([dict getUInt64:NULL forKey:22LL]); + XCTAssertTrue([dict getUInt64:&value forKey:22LL]); XCTAssertEqual(value, 301U); - XCTAssertTrue([dict valueForKey:23LL value:NULL]); - XCTAssertTrue([dict valueForKey:23LL value:&value]); + XCTAssertTrue([dict getUInt64:NULL forKey:23LL]); + XCTAssertTrue([dict getUInt64:&value forKey:23LL]); XCTAssertEqual(value, 302U); - XCTAssertFalse([dict valueForKey:24LL value:NULL]); + XCTAssertFalse([dict getUInt64:NULL forKey:24LL]); __block NSUInteger idx = 0; int64_t *seenKeys = malloc(3 * sizeof(int64_t)); uint64_t *seenValues = malloc(3 * sizeof(uint64_t)); - [dict enumerateKeysAndValuesUsingBlock:^(int64_t aKey, uint64_t aValue, BOOL *stop) { + [dict enumerateKeysAndUInt64sUsingBlock:^(int64_t aKey, uint64_t aValue, BOOL *stop) { XCTAssertLessThan(idx, 3U); seenKeys[idx] = aKey; seenValues[idx] = aValue; @@ -878,7 +878,7 @@ static BOOL TestingEnum_IsValidValue(int32_t value) { // Stopping the enumeration. idx = 0; - [dict enumerateKeysAndValuesUsingBlock:^(int64_t aKey, uint64_t aValue, BOOL *stop) { + [dict enumerateKeysAndUInt64sUsingBlock:^(int64_t aKey, uint64_t aValue, BOOL *stop) { #pragma unused(aKey, aValue) if (idx == 1) *stop = YES; XCTAssertNotEqual(idx, 2U); @@ -894,29 +894,29 @@ static BOOL TestingEnum_IsValidValue(int32_t value) { const uint64_t kValues2[] = { 300U, 303U, 302U }; const uint64_t kValues3[] = { 300U, 301U, 302U, 303U }; GPBInt64UInt64Dictionary *dict1 = - [[GPBInt64UInt64Dictionary alloc] initWithValues:kValues1 - forKeys:kKeys1 - count:GPBARRAYSIZE(kValues1)]; + [[GPBInt64UInt64Dictionary alloc] initWithUInt64s:kValues1 + forKeys:kKeys1 + count:GPBARRAYSIZE(kValues1)]; XCTAssertNotNil(dict1); GPBInt64UInt64Dictionary *dict1prime = - [[GPBInt64UInt64Dictionary alloc] initWithValues:kValues1 - forKeys:kKeys1 - count:GPBARRAYSIZE(kValues1)]; + [[GPBInt64UInt64Dictionary alloc] initWithUInt64s:kValues1 + forKeys:kKeys1 + count:GPBARRAYSIZE(kValues1)]; XCTAssertNotNil(dict1prime); GPBInt64UInt64Dictionary *dict2 = - [[GPBInt64UInt64Dictionary alloc] initWithValues:kValues2 - forKeys:kKeys1 - count:GPBARRAYSIZE(kValues2)]; + [[GPBInt64UInt64Dictionary alloc] initWithUInt64s:kValues2 + forKeys:kKeys1 + count:GPBARRAYSIZE(kValues2)]; XCTAssertNotNil(dict2); GPBInt64UInt64Dictionary *dict3 = - [[GPBInt64UInt64Dictionary alloc] initWithValues:kValues1 - forKeys:kKeys2 - count:GPBARRAYSIZE(kValues1)]; + [[GPBInt64UInt64Dictionary alloc] initWithUInt64s:kValues1 + forKeys:kKeys2 + count:GPBARRAYSIZE(kValues1)]; XCTAssertNotNil(dict3); GPBInt64UInt64Dictionary *dict4 = - [[GPBInt64UInt64Dictionary alloc] initWithValues:kValues3 - forKeys:kKeys1 - count:GPBARRAYSIZE(kValues3)]; + [[GPBInt64UInt64Dictionary alloc] initWithUInt64s:kValues3 + forKeys:kKeys1 + count:GPBARRAYSIZE(kValues3)]; XCTAssertNotNil(dict4); // 1/1Prime should be different objects, but equal. @@ -945,9 +945,9 @@ static BOOL TestingEnum_IsValidValue(int32_t value) { const int64_t kKeys[] = { 21LL, 22LL, 23LL, 24LL }; const uint64_t kValues[] = { 300U, 301U, 302U, 303U }; GPBInt64UInt64Dictionary *dict = - [[GPBInt64UInt64Dictionary alloc] initWithValues:kValues - forKeys:kKeys - count:GPBARRAYSIZE(kValues)]; + [[GPBInt64UInt64Dictionary alloc] initWithUInt64s:kValues + forKeys:kKeys + count:GPBARRAYSIZE(kValues)]; XCTAssertNotNil(dict); GPBInt64UInt64Dictionary *dict2 = [dict copy]; @@ -966,9 +966,9 @@ static BOOL TestingEnum_IsValidValue(int32_t value) { const int64_t kKeys[] = { 21LL, 22LL, 23LL, 24LL }; const uint64_t kValues[] = { 300U, 301U, 302U, 303U }; GPBInt64UInt64Dictionary *dict = - [[GPBInt64UInt64Dictionary alloc] initWithValues:kValues - forKeys:kKeys - count:GPBARRAYSIZE(kValues)]; + [[GPBInt64UInt64Dictionary alloc] initWithUInt64s:kValues + forKeys:kKeys + count:GPBARRAYSIZE(kValues)]; XCTAssertNotNil(dict); GPBInt64UInt64Dictionary *dict2 = @@ -986,31 +986,31 @@ static BOOL TestingEnum_IsValidValue(int32_t value) { XCTAssertNotNil(dict); XCTAssertEqual(dict.count, 0U); - [dict setValue:300U forKey:21LL]; + [dict setUInt64:300U forKey:21LL]; XCTAssertEqual(dict.count, 1U); const int64_t kKeys[] = { 22LL, 23LL, 24LL }; const uint64_t kValues[] = { 301U, 302U, 303U }; GPBInt64UInt64Dictionary *dict2 = - [[GPBInt64UInt64Dictionary alloc] initWithValues:kValues - forKeys:kKeys - count:GPBARRAYSIZE(kValues)]; + [[GPBInt64UInt64Dictionary alloc] initWithUInt64s:kValues + forKeys:kKeys + count:GPBARRAYSIZE(kValues)]; XCTAssertNotNil(dict2); [dict addEntriesFromDictionary:dict2]; XCTAssertEqual(dict.count, 4U); uint64_t value; - XCTAssertTrue([dict valueForKey:21LL value:NULL]); - XCTAssertTrue([dict valueForKey:21LL value:&value]); + XCTAssertTrue([dict getUInt64:NULL forKey:21LL]); + XCTAssertTrue([dict getUInt64:&value forKey:21LL]); XCTAssertEqual(value, 300U); - XCTAssertTrue([dict valueForKey:22LL value:NULL]); - XCTAssertTrue([dict valueForKey:22LL value:&value]); + XCTAssertTrue([dict getUInt64:NULL forKey:22LL]); + XCTAssertTrue([dict getUInt64:&value forKey:22LL]); XCTAssertEqual(value, 301U); - XCTAssertTrue([dict valueForKey:23LL value:NULL]); - XCTAssertTrue([dict valueForKey:23LL value:&value]); + XCTAssertTrue([dict getUInt64:NULL forKey:23LL]); + XCTAssertTrue([dict getUInt64:&value forKey:23LL]); XCTAssertEqual(value, 302U); - XCTAssertTrue([dict valueForKey:24LL value:NULL]); - XCTAssertTrue([dict valueForKey:24LL value:&value]); + XCTAssertTrue([dict getUInt64:NULL forKey:24LL]); + XCTAssertTrue([dict getUInt64:&value forKey:24LL]); XCTAssertEqual(value, 303U); [dict2 release]; } @@ -1019,57 +1019,57 @@ static BOOL TestingEnum_IsValidValue(int32_t value) { const int64_t kKeys[] = { 21LL, 22LL, 23LL, 24LL }; const uint64_t kValues[] = { 300U, 301U, 302U, 303U }; GPBInt64UInt64Dictionary *dict = - [[GPBInt64UInt64Dictionary alloc] initWithValues:kValues - forKeys:kKeys - count:GPBARRAYSIZE(kValues)]; + [[GPBInt64UInt64Dictionary alloc] initWithUInt64s:kValues + forKeys:kKeys + count:GPBARRAYSIZE(kValues)]; XCTAssertNotNil(dict); XCTAssertEqual(dict.count, 4U); - [dict removeValueForKey:22LL]; + [dict removeUInt64ForKey:22LL]; XCTAssertEqual(dict.count, 3U); uint64_t value; - XCTAssertTrue([dict valueForKey:21LL value:NULL]); - XCTAssertTrue([dict valueForKey:21LL value:&value]); + XCTAssertTrue([dict getUInt64:NULL forKey:21LL]); + XCTAssertTrue([dict getUInt64:&value forKey:21LL]); XCTAssertEqual(value, 300U); - XCTAssertFalse([dict valueForKey:22LL value:NULL]); - XCTAssertTrue([dict valueForKey:23LL value:NULL]); - XCTAssertTrue([dict valueForKey:23LL value:&value]); + XCTAssertFalse([dict getUInt64:NULL forKey:22LL]); + XCTAssertTrue([dict getUInt64:NULL forKey:23LL]); + XCTAssertTrue([dict getUInt64:&value forKey:23LL]); XCTAssertEqual(value, 302U); - XCTAssertTrue([dict valueForKey:24LL value:NULL]); - XCTAssertTrue([dict valueForKey:24LL value:&value]); + XCTAssertTrue([dict getUInt64:NULL forKey:24LL]); + XCTAssertTrue([dict getUInt64:&value forKey:24LL]); XCTAssertEqual(value, 303U); // Remove again does nothing. - [dict removeValueForKey:22LL]; + [dict removeUInt64ForKey:22LL]; XCTAssertEqual(dict.count, 3U); - XCTAssertTrue([dict valueForKey:21LL value:NULL]); - XCTAssertTrue([dict valueForKey:21LL value:&value]); + XCTAssertTrue([dict getUInt64:NULL forKey:21LL]); + XCTAssertTrue([dict getUInt64:&value forKey:21LL]); XCTAssertEqual(value, 300U); - XCTAssertFalse([dict valueForKey:22LL value:NULL]); - XCTAssertTrue([dict valueForKey:23LL value:NULL]); - XCTAssertTrue([dict valueForKey:23LL value:&value]); + XCTAssertFalse([dict getUInt64:NULL forKey:22LL]); + XCTAssertTrue([dict getUInt64:NULL forKey:23LL]); + XCTAssertTrue([dict getUInt64:&value forKey:23LL]); XCTAssertEqual(value, 302U); - XCTAssertTrue([dict valueForKey:24LL value:NULL]); - XCTAssertTrue([dict valueForKey:24LL value:&value]); + XCTAssertTrue([dict getUInt64:NULL forKey:24LL]); + XCTAssertTrue([dict getUInt64:&value forKey:24LL]); XCTAssertEqual(value, 303U); - [dict removeValueForKey:24LL]; + [dict removeUInt64ForKey:24LL]; XCTAssertEqual(dict.count, 2U); - XCTAssertTrue([dict valueForKey:21LL value:NULL]); - XCTAssertTrue([dict valueForKey:21LL value:&value]); + XCTAssertTrue([dict getUInt64:NULL forKey:21LL]); + XCTAssertTrue([dict getUInt64:&value forKey:21LL]); XCTAssertEqual(value, 300U); - XCTAssertFalse([dict valueForKey:22LL value:NULL]); - XCTAssertTrue([dict valueForKey:23LL value:NULL]); - XCTAssertTrue([dict valueForKey:23LL value:&value]); + XCTAssertFalse([dict getUInt64:NULL forKey:22LL]); + XCTAssertTrue([dict getUInt64:NULL forKey:23LL]); + XCTAssertTrue([dict getUInt64:&value forKey:23LL]); XCTAssertEqual(value, 302U); - XCTAssertFalse([dict valueForKey:24LL value:NULL]); + XCTAssertFalse([dict getUInt64:NULL forKey:24LL]); [dict removeAll]; XCTAssertEqual(dict.count, 0U); - XCTAssertFalse([dict valueForKey:21LL value:NULL]); - XCTAssertFalse([dict valueForKey:22LL value:NULL]); - XCTAssertFalse([dict valueForKey:23LL value:NULL]); - XCTAssertFalse([dict valueForKey:24LL value:NULL]); + XCTAssertFalse([dict getUInt64:NULL forKey:21LL]); + XCTAssertFalse([dict getUInt64:NULL forKey:22LL]); + XCTAssertFalse([dict getUInt64:NULL forKey:23LL]); + XCTAssertFalse([dict getUInt64:NULL forKey:24LL]); [dict release]; } @@ -1077,75 +1077,75 @@ static BOOL TestingEnum_IsValidValue(int32_t value) { const int64_t kKeys[] = { 21LL, 22LL, 23LL, 24LL }; const uint64_t kValues[] = { 300U, 301U, 302U, 303U }; GPBInt64UInt64Dictionary *dict = - [[GPBInt64UInt64Dictionary alloc] initWithValues:kValues - forKeys:kKeys - count:GPBARRAYSIZE(kValues)]; + [[GPBInt64UInt64Dictionary alloc] initWithUInt64s:kValues + forKeys:kKeys + count:GPBARRAYSIZE(kValues)]; XCTAssertNotNil(dict); XCTAssertEqual(dict.count, 4U); uint64_t value; - XCTAssertTrue([dict valueForKey:21LL value:NULL]); - XCTAssertTrue([dict valueForKey:21LL value:&value]); + XCTAssertTrue([dict getUInt64:NULL forKey:21LL]); + XCTAssertTrue([dict getUInt64:&value forKey:21LL]); XCTAssertEqual(value, 300U); - XCTAssertTrue([dict valueForKey:22LL value:NULL]); - XCTAssertTrue([dict valueForKey:22LL value:&value]); + XCTAssertTrue([dict getUInt64:NULL forKey:22LL]); + XCTAssertTrue([dict getUInt64:&value forKey:22LL]); XCTAssertEqual(value, 301U); - XCTAssertTrue([dict valueForKey:23LL value:NULL]); - XCTAssertTrue([dict valueForKey:23LL value:&value]); + XCTAssertTrue([dict getUInt64:NULL forKey:23LL]); + XCTAssertTrue([dict getUInt64:&value forKey:23LL]); XCTAssertEqual(value, 302U); - XCTAssertTrue([dict valueForKey:24LL value:NULL]); - XCTAssertTrue([dict valueForKey:24LL value:&value]); + XCTAssertTrue([dict getUInt64:NULL forKey:24LL]); + XCTAssertTrue([dict getUInt64:&value forKey:24LL]); XCTAssertEqual(value, 303U); - [dict setValue:303U forKey:21LL]; + [dict setUInt64:303U forKey:21LL]; XCTAssertEqual(dict.count, 4U); - XCTAssertTrue([dict valueForKey:21LL value:NULL]); - XCTAssertTrue([dict valueForKey:21LL value:&value]); + XCTAssertTrue([dict getUInt64:NULL forKey:21LL]); + XCTAssertTrue([dict getUInt64:&value forKey:21LL]); XCTAssertEqual(value, 303U); - XCTAssertTrue([dict valueForKey:22LL value:NULL]); - XCTAssertTrue([dict valueForKey:22LL value:&value]); + XCTAssertTrue([dict getUInt64:NULL forKey:22LL]); + XCTAssertTrue([dict getUInt64:&value forKey:22LL]); XCTAssertEqual(value, 301U); - XCTAssertTrue([dict valueForKey:23LL value:NULL]); - XCTAssertTrue([dict valueForKey:23LL value:&value]); + XCTAssertTrue([dict getUInt64:NULL forKey:23LL]); + XCTAssertTrue([dict getUInt64:&value forKey:23LL]); XCTAssertEqual(value, 302U); - XCTAssertTrue([dict valueForKey:24LL value:NULL]); - XCTAssertTrue([dict valueForKey:24LL value:&value]); + XCTAssertTrue([dict getUInt64:NULL forKey:24LL]); + XCTAssertTrue([dict getUInt64:&value forKey:24LL]); XCTAssertEqual(value, 303U); - [dict setValue:301U forKey:24LL]; + [dict setUInt64:301U forKey:24LL]; XCTAssertEqual(dict.count, 4U); - XCTAssertTrue([dict valueForKey:21LL value:NULL]); - XCTAssertTrue([dict valueForKey:21LL value:&value]); + XCTAssertTrue([dict getUInt64:NULL forKey:21LL]); + XCTAssertTrue([dict getUInt64:&value forKey:21LL]); XCTAssertEqual(value, 303U); - XCTAssertTrue([dict valueForKey:22LL value:NULL]); - XCTAssertTrue([dict valueForKey:22LL value:&value]); + XCTAssertTrue([dict getUInt64:NULL forKey:22LL]); + XCTAssertTrue([dict getUInt64:&value forKey:22LL]); XCTAssertEqual(value, 301U); - XCTAssertTrue([dict valueForKey:23LL value:NULL]); - XCTAssertTrue([dict valueForKey:23LL value:&value]); + XCTAssertTrue([dict getUInt64:NULL forKey:23LL]); + XCTAssertTrue([dict getUInt64:&value forKey:23LL]); XCTAssertEqual(value, 302U); - XCTAssertTrue([dict valueForKey:24LL value:NULL]); - XCTAssertTrue([dict valueForKey:24LL value:&value]); + XCTAssertTrue([dict getUInt64:NULL forKey:24LL]); + XCTAssertTrue([dict getUInt64:&value forKey:24LL]); XCTAssertEqual(value, 301U); const int64_t kKeys2[] = { 22LL, 23LL }; const uint64_t kValues2[] = { 302U, 300U }; GPBInt64UInt64Dictionary *dict2 = - [[GPBInt64UInt64Dictionary alloc] initWithValues:kValues2 - forKeys:kKeys2 - count:GPBARRAYSIZE(kValues2)]; + [[GPBInt64UInt64Dictionary alloc] initWithUInt64s:kValues2 + forKeys:kKeys2 + count:GPBARRAYSIZE(kValues2)]; XCTAssertNotNil(dict2); [dict addEntriesFromDictionary:dict2]; XCTAssertEqual(dict.count, 4U); - XCTAssertTrue([dict valueForKey:21LL value:NULL]); - XCTAssertTrue([dict valueForKey:21LL value:&value]); + XCTAssertTrue([dict getUInt64:NULL forKey:21LL]); + XCTAssertTrue([dict getUInt64:&value forKey:21LL]); XCTAssertEqual(value, 303U); - XCTAssertTrue([dict valueForKey:22LL value:NULL]); - XCTAssertTrue([dict valueForKey:22LL value:&value]); + XCTAssertTrue([dict getUInt64:NULL forKey:22LL]); + XCTAssertTrue([dict getUInt64:&value forKey:22LL]); XCTAssertEqual(value, 302U); - XCTAssertTrue([dict valueForKey:23LL value:NULL]); - XCTAssertTrue([dict valueForKey:23LL value:&value]); + XCTAssertTrue([dict getUInt64:NULL forKey:23LL]); + XCTAssertTrue([dict getUInt64:&value forKey:23LL]); XCTAssertEqual(value, 300U); - XCTAssertTrue([dict valueForKey:24LL value:NULL]); - XCTAssertTrue([dict valueForKey:24LL value:&value]); + XCTAssertTrue([dict getUInt64:NULL forKey:24LL]); + XCTAssertTrue([dict getUInt64:&value forKey:24LL]); XCTAssertEqual(value, 301U); [dict2 release]; @@ -1165,8 +1165,8 @@ static BOOL TestingEnum_IsValidValue(int32_t value) { GPBInt64Int64Dictionary *dict = [[GPBInt64Int64Dictionary alloc] init]; XCTAssertNotNil(dict); XCTAssertEqual(dict.count, 0U); - XCTAssertFalse([dict valueForKey:21LL value:NULL]); - [dict enumerateKeysAndValuesUsingBlock:^(int64_t aKey, int64_t aValue, BOOL *stop) { + XCTAssertFalse([dict getInt64:NULL forKey:21LL]); + [dict enumerateKeysAndInt64sUsingBlock:^(int64_t aKey, int64_t aValue, BOOL *stop) { #pragma unused(aKey, aValue, stop) XCTFail(@"Shouldn't get here!"); }]; @@ -1174,15 +1174,15 @@ static BOOL TestingEnum_IsValidValue(int32_t value) { } - (void)testOne { - GPBInt64Int64Dictionary *dict = [GPBInt64Int64Dictionary dictionaryWithValue:400 forKey:21LL]; + GPBInt64Int64Dictionary *dict = [GPBInt64Int64Dictionary dictionaryWithInt64:400 forKey:21LL]; XCTAssertNotNil(dict); XCTAssertEqual(dict.count, 1U); int64_t value; - XCTAssertTrue([dict valueForKey:21LL value:NULL]); - XCTAssertTrue([dict valueForKey:21LL value:&value]); + XCTAssertTrue([dict getInt64:NULL forKey:21LL]); + XCTAssertTrue([dict getInt64:&value forKey:21LL]); XCTAssertEqual(value, 400); - XCTAssertFalse([dict valueForKey:22LL value:NULL]); - [dict enumerateKeysAndValuesUsingBlock:^(int64_t aKey, int64_t aValue, BOOL *stop) { + XCTAssertFalse([dict getInt64:NULL forKey:22LL]); + [dict enumerateKeysAndInt64sUsingBlock:^(int64_t aKey, int64_t aValue, BOOL *stop) { XCTAssertEqual(aKey, 21LL); XCTAssertEqual(aValue, 400); XCTAssertNotEqual(stop, NULL); @@ -1193,27 +1193,27 @@ static BOOL TestingEnum_IsValidValue(int32_t value) { const int64_t kKeys[] = { 21LL, 22LL, 23LL }; const int64_t kValues[] = { 400, 401, 402 }; GPBInt64Int64Dictionary *dict = - [[GPBInt64Int64Dictionary alloc] initWithValues:kValues + [[GPBInt64Int64Dictionary alloc] initWithInt64s:kValues forKeys:kKeys count:GPBARRAYSIZE(kValues)]; XCTAssertNotNil(dict); XCTAssertEqual(dict.count, 3U); int64_t value; - XCTAssertTrue([dict valueForKey:21LL value:NULL]); - XCTAssertTrue([dict valueForKey:21LL value:&value]); + XCTAssertTrue([dict getInt64:NULL forKey:21LL]); + XCTAssertTrue([dict getInt64:&value forKey:21LL]); XCTAssertEqual(value, 400); - XCTAssertTrue([dict valueForKey:22LL value:NULL]); - XCTAssertTrue([dict valueForKey:22LL value:&value]); + XCTAssertTrue([dict getInt64:NULL forKey:22LL]); + XCTAssertTrue([dict getInt64:&value forKey:22LL]); XCTAssertEqual(value, 401); - XCTAssertTrue([dict valueForKey:23LL value:NULL]); - XCTAssertTrue([dict valueForKey:23LL value:&value]); + XCTAssertTrue([dict getInt64:NULL forKey:23LL]); + XCTAssertTrue([dict getInt64:&value forKey:23LL]); XCTAssertEqual(value, 402); - XCTAssertFalse([dict valueForKey:24LL value:NULL]); + XCTAssertFalse([dict getInt64:NULL forKey:24LL]); __block NSUInteger idx = 0; int64_t *seenKeys = malloc(3 * sizeof(int64_t)); int64_t *seenValues = malloc(3 * sizeof(int64_t)); - [dict enumerateKeysAndValuesUsingBlock:^(int64_t aKey, int64_t aValue, BOOL *stop) { + [dict enumerateKeysAndInt64sUsingBlock:^(int64_t aKey, int64_t aValue, BOOL *stop) { XCTAssertLessThan(idx, 3U); seenKeys[idx] = aKey; seenValues[idx] = aValue; @@ -1235,7 +1235,7 @@ static BOOL TestingEnum_IsValidValue(int32_t value) { // Stopping the enumeration. idx = 0; - [dict enumerateKeysAndValuesUsingBlock:^(int64_t aKey, int64_t aValue, BOOL *stop) { + [dict enumerateKeysAndInt64sUsingBlock:^(int64_t aKey, int64_t aValue, BOOL *stop) { #pragma unused(aKey, aValue) if (idx == 1) *stop = YES; XCTAssertNotEqual(idx, 2U); @@ -1251,27 +1251,27 @@ static BOOL TestingEnum_IsValidValue(int32_t value) { const int64_t kValues2[] = { 400, 403, 402 }; const int64_t kValues3[] = { 400, 401, 402, 403 }; GPBInt64Int64Dictionary *dict1 = - [[GPBInt64Int64Dictionary alloc] initWithValues:kValues1 + [[GPBInt64Int64Dictionary alloc] initWithInt64s:kValues1 forKeys:kKeys1 count:GPBARRAYSIZE(kValues1)]; XCTAssertNotNil(dict1); GPBInt64Int64Dictionary *dict1prime = - [[GPBInt64Int64Dictionary alloc] initWithValues:kValues1 + [[GPBInt64Int64Dictionary alloc] initWithInt64s:kValues1 forKeys:kKeys1 count:GPBARRAYSIZE(kValues1)]; XCTAssertNotNil(dict1prime); GPBInt64Int64Dictionary *dict2 = - [[GPBInt64Int64Dictionary alloc] initWithValues:kValues2 + [[GPBInt64Int64Dictionary alloc] initWithInt64s:kValues2 forKeys:kKeys1 count:GPBARRAYSIZE(kValues2)]; XCTAssertNotNil(dict2); GPBInt64Int64Dictionary *dict3 = - [[GPBInt64Int64Dictionary alloc] initWithValues:kValues1 + [[GPBInt64Int64Dictionary alloc] initWithInt64s:kValues1 forKeys:kKeys2 count:GPBARRAYSIZE(kValues1)]; XCTAssertNotNil(dict3); GPBInt64Int64Dictionary *dict4 = - [[GPBInt64Int64Dictionary alloc] initWithValues:kValues3 + [[GPBInt64Int64Dictionary alloc] initWithInt64s:kValues3 forKeys:kKeys1 count:GPBARRAYSIZE(kValues3)]; XCTAssertNotNil(dict4); @@ -1302,7 +1302,7 @@ static BOOL TestingEnum_IsValidValue(int32_t value) { const int64_t kKeys[] = { 21LL, 22LL, 23LL, 24LL }; const int64_t kValues[] = { 400, 401, 402, 403 }; GPBInt64Int64Dictionary *dict = - [[GPBInt64Int64Dictionary alloc] initWithValues:kValues + [[GPBInt64Int64Dictionary alloc] initWithInt64s:kValues forKeys:kKeys count:GPBARRAYSIZE(kValues)]; XCTAssertNotNil(dict); @@ -1323,7 +1323,7 @@ static BOOL TestingEnum_IsValidValue(int32_t value) { const int64_t kKeys[] = { 21LL, 22LL, 23LL, 24LL }; const int64_t kValues[] = { 400, 401, 402, 403 }; GPBInt64Int64Dictionary *dict = - [[GPBInt64Int64Dictionary alloc] initWithValues:kValues + [[GPBInt64Int64Dictionary alloc] initWithInt64s:kValues forKeys:kKeys count:GPBARRAYSIZE(kValues)]; XCTAssertNotNil(dict); @@ -1343,13 +1343,13 @@ static BOOL TestingEnum_IsValidValue(int32_t value) { XCTAssertNotNil(dict); XCTAssertEqual(dict.count, 0U); - [dict setValue:400 forKey:21LL]; + [dict setInt64:400 forKey:21LL]; XCTAssertEqual(dict.count, 1U); const int64_t kKeys[] = { 22LL, 23LL, 24LL }; const int64_t kValues[] = { 401, 402, 403 }; GPBInt64Int64Dictionary *dict2 = - [[GPBInt64Int64Dictionary alloc] initWithValues:kValues + [[GPBInt64Int64Dictionary alloc] initWithInt64s:kValues forKeys:kKeys count:GPBARRAYSIZE(kValues)]; XCTAssertNotNil(dict2); @@ -1357,17 +1357,17 @@ static BOOL TestingEnum_IsValidValue(int32_t value) { XCTAssertEqual(dict.count, 4U); int64_t value; - XCTAssertTrue([dict valueForKey:21LL value:NULL]); - XCTAssertTrue([dict valueForKey:21LL value:&value]); + XCTAssertTrue([dict getInt64:NULL forKey:21LL]); + XCTAssertTrue([dict getInt64:&value forKey:21LL]); XCTAssertEqual(value, 400); - XCTAssertTrue([dict valueForKey:22LL value:NULL]); - XCTAssertTrue([dict valueForKey:22LL value:&value]); + XCTAssertTrue([dict getInt64:NULL forKey:22LL]); + XCTAssertTrue([dict getInt64:&value forKey:22LL]); XCTAssertEqual(value, 401); - XCTAssertTrue([dict valueForKey:23LL value:NULL]); - XCTAssertTrue([dict valueForKey:23LL value:&value]); + XCTAssertTrue([dict getInt64:NULL forKey:23LL]); + XCTAssertTrue([dict getInt64:&value forKey:23LL]); XCTAssertEqual(value, 402); - XCTAssertTrue([dict valueForKey:24LL value:NULL]); - XCTAssertTrue([dict valueForKey:24LL value:&value]); + XCTAssertTrue([dict getInt64:NULL forKey:24LL]); + XCTAssertTrue([dict getInt64:&value forKey:24LL]); XCTAssertEqual(value, 403); [dict2 release]; } @@ -1376,57 +1376,57 @@ static BOOL TestingEnum_IsValidValue(int32_t value) { const int64_t kKeys[] = { 21LL, 22LL, 23LL, 24LL }; const int64_t kValues[] = { 400, 401, 402, 403 }; GPBInt64Int64Dictionary *dict = - [[GPBInt64Int64Dictionary alloc] initWithValues:kValues - forKeys:kKeys - count:GPBARRAYSIZE(kValues)]; + [[GPBInt64Int64Dictionary alloc] initWithInt64s:kValues + forKeys:kKeys + count:GPBARRAYSIZE(kValues)]; XCTAssertNotNil(dict); XCTAssertEqual(dict.count, 4U); - [dict removeValueForKey:22LL]; + [dict removeInt64ForKey:22LL]; XCTAssertEqual(dict.count, 3U); int64_t value; - XCTAssertTrue([dict valueForKey:21LL value:NULL]); - XCTAssertTrue([dict valueForKey:21LL value:&value]); + XCTAssertTrue([dict getInt64:NULL forKey:21LL]); + XCTAssertTrue([dict getInt64:&value forKey:21LL]); XCTAssertEqual(value, 400); - XCTAssertFalse([dict valueForKey:22LL value:NULL]); - XCTAssertTrue([dict valueForKey:23LL value:NULL]); - XCTAssertTrue([dict valueForKey:23LL value:&value]); + XCTAssertFalse([dict getInt64:NULL forKey:22LL]); + XCTAssertTrue([dict getInt64:NULL forKey:23LL]); + XCTAssertTrue([dict getInt64:&value forKey:23LL]); XCTAssertEqual(value, 402); - XCTAssertTrue([dict valueForKey:24LL value:NULL]); - XCTAssertTrue([dict valueForKey:24LL value:&value]); + XCTAssertTrue([dict getInt64:NULL forKey:24LL]); + XCTAssertTrue([dict getInt64:&value forKey:24LL]); XCTAssertEqual(value, 403); // Remove again does nothing. - [dict removeValueForKey:22LL]; + [dict removeInt64ForKey:22LL]; XCTAssertEqual(dict.count, 3U); - XCTAssertTrue([dict valueForKey:21LL value:NULL]); - XCTAssertTrue([dict valueForKey:21LL value:&value]); + XCTAssertTrue([dict getInt64:NULL forKey:21LL]); + XCTAssertTrue([dict getInt64:&value forKey:21LL]); XCTAssertEqual(value, 400); - XCTAssertFalse([dict valueForKey:22LL value:NULL]); - XCTAssertTrue([dict valueForKey:23LL value:NULL]); - XCTAssertTrue([dict valueForKey:23LL value:&value]); + XCTAssertFalse([dict getInt64:NULL forKey:22LL]); + XCTAssertTrue([dict getInt64:NULL forKey:23LL]); + XCTAssertTrue([dict getInt64:&value forKey:23LL]); XCTAssertEqual(value, 402); - XCTAssertTrue([dict valueForKey:24LL value:NULL]); - XCTAssertTrue([dict valueForKey:24LL value:&value]); + XCTAssertTrue([dict getInt64:NULL forKey:24LL]); + XCTAssertTrue([dict getInt64:&value forKey:24LL]); XCTAssertEqual(value, 403); - [dict removeValueForKey:24LL]; + [dict removeInt64ForKey:24LL]; XCTAssertEqual(dict.count, 2U); - XCTAssertTrue([dict valueForKey:21LL value:NULL]); - XCTAssertTrue([dict valueForKey:21LL value:&value]); + XCTAssertTrue([dict getInt64:NULL forKey:21LL]); + XCTAssertTrue([dict getInt64:&value forKey:21LL]); XCTAssertEqual(value, 400); - XCTAssertFalse([dict valueForKey:22LL value:NULL]); - XCTAssertTrue([dict valueForKey:23LL value:NULL]); - XCTAssertTrue([dict valueForKey:23LL value:&value]); + XCTAssertFalse([dict getInt64:NULL forKey:22LL]); + XCTAssertTrue([dict getInt64:NULL forKey:23LL]); + XCTAssertTrue([dict getInt64:&value forKey:23LL]); XCTAssertEqual(value, 402); - XCTAssertFalse([dict valueForKey:24LL value:NULL]); + XCTAssertFalse([dict getInt64:NULL forKey:24LL]); [dict removeAll]; XCTAssertEqual(dict.count, 0U); - XCTAssertFalse([dict valueForKey:21LL value:NULL]); - XCTAssertFalse([dict valueForKey:22LL value:NULL]); - XCTAssertFalse([dict valueForKey:23LL value:NULL]); - XCTAssertFalse([dict valueForKey:24LL value:NULL]); + XCTAssertFalse([dict getInt64:NULL forKey:21LL]); + XCTAssertFalse([dict getInt64:NULL forKey:22LL]); + XCTAssertFalse([dict getInt64:NULL forKey:23LL]); + XCTAssertFalse([dict getInt64:NULL forKey:24LL]); [dict release]; } @@ -1434,75 +1434,75 @@ static BOOL TestingEnum_IsValidValue(int32_t value) { const int64_t kKeys[] = { 21LL, 22LL, 23LL, 24LL }; const int64_t kValues[] = { 400, 401, 402, 403 }; GPBInt64Int64Dictionary *dict = - [[GPBInt64Int64Dictionary alloc] initWithValues:kValues - forKeys:kKeys - count:GPBARRAYSIZE(kValues)]; + [[GPBInt64Int64Dictionary alloc] initWithInt64s:kValues + forKeys:kKeys + count:GPBARRAYSIZE(kValues)]; XCTAssertNotNil(dict); XCTAssertEqual(dict.count, 4U); int64_t value; - XCTAssertTrue([dict valueForKey:21LL value:NULL]); - XCTAssertTrue([dict valueForKey:21LL value:&value]); + XCTAssertTrue([dict getInt64:NULL forKey:21LL]); + XCTAssertTrue([dict getInt64:&value forKey:21LL]); XCTAssertEqual(value, 400); - XCTAssertTrue([dict valueForKey:22LL value:NULL]); - XCTAssertTrue([dict valueForKey:22LL value:&value]); + XCTAssertTrue([dict getInt64:NULL forKey:22LL]); + XCTAssertTrue([dict getInt64:&value forKey:22LL]); XCTAssertEqual(value, 401); - XCTAssertTrue([dict valueForKey:23LL value:NULL]); - XCTAssertTrue([dict valueForKey:23LL value:&value]); + XCTAssertTrue([dict getInt64:NULL forKey:23LL]); + XCTAssertTrue([dict getInt64:&value forKey:23LL]); XCTAssertEqual(value, 402); - XCTAssertTrue([dict valueForKey:24LL value:NULL]); - XCTAssertTrue([dict valueForKey:24LL value:&value]); + XCTAssertTrue([dict getInt64:NULL forKey:24LL]); + XCTAssertTrue([dict getInt64:&value forKey:24LL]); XCTAssertEqual(value, 403); - [dict setValue:403 forKey:21LL]; + [dict setInt64:403 forKey:21LL]; XCTAssertEqual(dict.count, 4U); - XCTAssertTrue([dict valueForKey:21LL value:NULL]); - XCTAssertTrue([dict valueForKey:21LL value:&value]); + XCTAssertTrue([dict getInt64:NULL forKey:21LL]); + XCTAssertTrue([dict getInt64:&value forKey:21LL]); XCTAssertEqual(value, 403); - XCTAssertTrue([dict valueForKey:22LL value:NULL]); - XCTAssertTrue([dict valueForKey:22LL value:&value]); + XCTAssertTrue([dict getInt64:NULL forKey:22LL]); + XCTAssertTrue([dict getInt64:&value forKey:22LL]); XCTAssertEqual(value, 401); - XCTAssertTrue([dict valueForKey:23LL value:NULL]); - XCTAssertTrue([dict valueForKey:23LL value:&value]); + XCTAssertTrue([dict getInt64:NULL forKey:23LL]); + XCTAssertTrue([dict getInt64:&value forKey:23LL]); XCTAssertEqual(value, 402); - XCTAssertTrue([dict valueForKey:24LL value:NULL]); - XCTAssertTrue([dict valueForKey:24LL value:&value]); + XCTAssertTrue([dict getInt64:NULL forKey:24LL]); + XCTAssertTrue([dict getInt64:&value forKey:24LL]); XCTAssertEqual(value, 403); - [dict setValue:401 forKey:24LL]; + [dict setInt64:401 forKey:24LL]; XCTAssertEqual(dict.count, 4U); - XCTAssertTrue([dict valueForKey:21LL value:NULL]); - XCTAssertTrue([dict valueForKey:21LL value:&value]); + XCTAssertTrue([dict getInt64:NULL forKey:21LL]); + XCTAssertTrue([dict getInt64:&value forKey:21LL]); XCTAssertEqual(value, 403); - XCTAssertTrue([dict valueForKey:22LL value:NULL]); - XCTAssertTrue([dict valueForKey:22LL value:&value]); + XCTAssertTrue([dict getInt64:NULL forKey:22LL]); + XCTAssertTrue([dict getInt64:&value forKey:22LL]); XCTAssertEqual(value, 401); - XCTAssertTrue([dict valueForKey:23LL value:NULL]); - XCTAssertTrue([dict valueForKey:23LL value:&value]); + XCTAssertTrue([dict getInt64:NULL forKey:23LL]); + XCTAssertTrue([dict getInt64:&value forKey:23LL]); XCTAssertEqual(value, 402); - XCTAssertTrue([dict valueForKey:24LL value:NULL]); - XCTAssertTrue([dict valueForKey:24LL value:&value]); + XCTAssertTrue([dict getInt64:NULL forKey:24LL]); + XCTAssertTrue([dict getInt64:&value forKey:24LL]); XCTAssertEqual(value, 401); const int64_t kKeys2[] = { 22LL, 23LL }; const int64_t kValues2[] = { 402, 400 }; GPBInt64Int64Dictionary *dict2 = - [[GPBInt64Int64Dictionary alloc] initWithValues:kValues2 + [[GPBInt64Int64Dictionary alloc] initWithInt64s:kValues2 forKeys:kKeys2 count:GPBARRAYSIZE(kValues2)]; XCTAssertNotNil(dict2); [dict addEntriesFromDictionary:dict2]; XCTAssertEqual(dict.count, 4U); - XCTAssertTrue([dict valueForKey:21LL value:NULL]); - XCTAssertTrue([dict valueForKey:21LL value:&value]); + XCTAssertTrue([dict getInt64:NULL forKey:21LL]); + XCTAssertTrue([dict getInt64:&value forKey:21LL]); XCTAssertEqual(value, 403); - XCTAssertTrue([dict valueForKey:22LL value:NULL]); - XCTAssertTrue([dict valueForKey:22LL value:&value]); + XCTAssertTrue([dict getInt64:NULL forKey:22LL]); + XCTAssertTrue([dict getInt64:&value forKey:22LL]); XCTAssertEqual(value, 402); - XCTAssertTrue([dict valueForKey:23LL value:NULL]); - XCTAssertTrue([dict valueForKey:23LL value:&value]); + XCTAssertTrue([dict getInt64:NULL forKey:23LL]); + XCTAssertTrue([dict getInt64:&value forKey:23LL]); XCTAssertEqual(value, 400); - XCTAssertTrue([dict valueForKey:24LL value:NULL]); - XCTAssertTrue([dict valueForKey:24LL value:&value]); + XCTAssertTrue([dict getInt64:NULL forKey:24LL]); + XCTAssertTrue([dict getInt64:&value forKey:24LL]); XCTAssertEqual(value, 401); [dict2 release]; @@ -1522,8 +1522,8 @@ static BOOL TestingEnum_IsValidValue(int32_t value) { GPBInt64BoolDictionary *dict = [[GPBInt64BoolDictionary alloc] init]; XCTAssertNotNil(dict); XCTAssertEqual(dict.count, 0U); - XCTAssertFalse([dict valueForKey:21LL value:NULL]); - [dict enumerateKeysAndValuesUsingBlock:^(int64_t aKey, BOOL aValue, BOOL *stop) { + XCTAssertFalse([dict getBool:NULL forKey:21LL]); + [dict enumerateKeysAndBoolsUsingBlock:^(int64_t aKey, BOOL aValue, BOOL *stop) { #pragma unused(aKey, aValue, stop) XCTFail(@"Shouldn't get here!"); }]; @@ -1531,15 +1531,15 @@ static BOOL TestingEnum_IsValidValue(int32_t value) { } - (void)testOne { - GPBInt64BoolDictionary *dict = [GPBInt64BoolDictionary dictionaryWithValue:YES forKey:21LL]; + GPBInt64BoolDictionary *dict = [GPBInt64BoolDictionary dictionaryWithBool:YES forKey:21LL]; XCTAssertNotNil(dict); XCTAssertEqual(dict.count, 1U); BOOL value; - XCTAssertTrue([dict valueForKey:21LL value:NULL]); - XCTAssertTrue([dict valueForKey:21LL value:&value]); + XCTAssertTrue([dict getBool:NULL forKey:21LL]); + XCTAssertTrue([dict getBool:&value forKey:21LL]); XCTAssertEqual(value, YES); - XCTAssertFalse([dict valueForKey:22LL value:NULL]); - [dict enumerateKeysAndValuesUsingBlock:^(int64_t aKey, BOOL aValue, BOOL *stop) { + XCTAssertFalse([dict getBool:NULL forKey:22LL]); + [dict enumerateKeysAndBoolsUsingBlock:^(int64_t aKey, BOOL aValue, BOOL *stop) { XCTAssertEqual(aKey, 21LL); XCTAssertEqual(aValue, YES); XCTAssertNotEqual(stop, NULL); @@ -1550,27 +1550,27 @@ static BOOL TestingEnum_IsValidValue(int32_t value) { const int64_t kKeys[] = { 21LL, 22LL, 23LL }; const BOOL kValues[] = { YES, YES, NO }; GPBInt64BoolDictionary *dict = - [[GPBInt64BoolDictionary alloc] initWithValues:kValues - forKeys:kKeys - count:GPBARRAYSIZE(kValues)]; + [[GPBInt64BoolDictionary alloc] initWithBools:kValues + forKeys:kKeys + count:GPBARRAYSIZE(kValues)]; XCTAssertNotNil(dict); XCTAssertEqual(dict.count, 3U); BOOL value; - XCTAssertTrue([dict valueForKey:21LL value:NULL]); - XCTAssertTrue([dict valueForKey:21LL value:&value]); + XCTAssertTrue([dict getBool:NULL forKey:21LL]); + XCTAssertTrue([dict getBool:&value forKey:21LL]); XCTAssertEqual(value, YES); - XCTAssertTrue([dict valueForKey:22LL value:NULL]); - XCTAssertTrue([dict valueForKey:22LL value:&value]); + XCTAssertTrue([dict getBool:NULL forKey:22LL]); + XCTAssertTrue([dict getBool:&value forKey:22LL]); XCTAssertEqual(value, YES); - XCTAssertTrue([dict valueForKey:23LL value:NULL]); - XCTAssertTrue([dict valueForKey:23LL value:&value]); + XCTAssertTrue([dict getBool:NULL forKey:23LL]); + XCTAssertTrue([dict getBool:&value forKey:23LL]); XCTAssertEqual(value, NO); - XCTAssertFalse([dict valueForKey:24LL value:NULL]); + XCTAssertFalse([dict getBool:NULL forKey:24LL]); __block NSUInteger idx = 0; int64_t *seenKeys = malloc(3 * sizeof(int64_t)); BOOL *seenValues = malloc(3 * sizeof(BOOL)); - [dict enumerateKeysAndValuesUsingBlock:^(int64_t aKey, BOOL aValue, BOOL *stop) { + [dict enumerateKeysAndBoolsUsingBlock:^(int64_t aKey, BOOL aValue, BOOL *stop) { XCTAssertLessThan(idx, 3U); seenKeys[idx] = aKey; seenValues[idx] = aValue; @@ -1592,7 +1592,7 @@ static BOOL TestingEnum_IsValidValue(int32_t value) { // Stopping the enumeration. idx = 0; - [dict enumerateKeysAndValuesUsingBlock:^(int64_t aKey, BOOL aValue, BOOL *stop) { + [dict enumerateKeysAndBoolsUsingBlock:^(int64_t aKey, BOOL aValue, BOOL *stop) { #pragma unused(aKey, aValue) if (idx == 1) *stop = YES; XCTAssertNotEqual(idx, 2U); @@ -1608,29 +1608,29 @@ static BOOL TestingEnum_IsValidValue(int32_t value) { const BOOL kValues2[] = { YES, NO, NO }; const BOOL kValues3[] = { YES, YES, NO, NO }; GPBInt64BoolDictionary *dict1 = - [[GPBInt64BoolDictionary alloc] initWithValues:kValues1 - forKeys:kKeys1 - count:GPBARRAYSIZE(kValues1)]; + [[GPBInt64BoolDictionary alloc] initWithBools:kValues1 + forKeys:kKeys1 + count:GPBARRAYSIZE(kValues1)]; XCTAssertNotNil(dict1); GPBInt64BoolDictionary *dict1prime = - [[GPBInt64BoolDictionary alloc] initWithValues:kValues1 - forKeys:kKeys1 - count:GPBARRAYSIZE(kValues1)]; + [[GPBInt64BoolDictionary alloc] initWithBools:kValues1 + forKeys:kKeys1 + count:GPBARRAYSIZE(kValues1)]; XCTAssertNotNil(dict1prime); GPBInt64BoolDictionary *dict2 = - [[GPBInt64BoolDictionary alloc] initWithValues:kValues2 - forKeys:kKeys1 - count:GPBARRAYSIZE(kValues2)]; + [[GPBInt64BoolDictionary alloc] initWithBools:kValues2 + forKeys:kKeys1 + count:GPBARRAYSIZE(kValues2)]; XCTAssertNotNil(dict2); GPBInt64BoolDictionary *dict3 = - [[GPBInt64BoolDictionary alloc] initWithValues:kValues1 - forKeys:kKeys2 - count:GPBARRAYSIZE(kValues1)]; + [[GPBInt64BoolDictionary alloc] initWithBools:kValues1 + forKeys:kKeys2 + count:GPBARRAYSIZE(kValues1)]; XCTAssertNotNil(dict3); GPBInt64BoolDictionary *dict4 = - [[GPBInt64BoolDictionary alloc] initWithValues:kValues3 - forKeys:kKeys1 - count:GPBARRAYSIZE(kValues3)]; + [[GPBInt64BoolDictionary alloc] initWithBools:kValues3 + forKeys:kKeys1 + count:GPBARRAYSIZE(kValues3)]; XCTAssertNotNil(dict4); // 1/1Prime should be different objects, but equal. @@ -1659,9 +1659,9 @@ static BOOL TestingEnum_IsValidValue(int32_t value) { const int64_t kKeys[] = { 21LL, 22LL, 23LL, 24LL }; const BOOL kValues[] = { YES, YES, NO, NO }; GPBInt64BoolDictionary *dict = - [[GPBInt64BoolDictionary alloc] initWithValues:kValues - forKeys:kKeys - count:GPBARRAYSIZE(kValues)]; + [[GPBInt64BoolDictionary alloc] initWithBools:kValues + forKeys:kKeys + count:GPBARRAYSIZE(kValues)]; XCTAssertNotNil(dict); GPBInt64BoolDictionary *dict2 = [dict copy]; @@ -1680,9 +1680,9 @@ static BOOL TestingEnum_IsValidValue(int32_t value) { const int64_t kKeys[] = { 21LL, 22LL, 23LL, 24LL }; const BOOL kValues[] = { YES, YES, NO, NO }; GPBInt64BoolDictionary *dict = - [[GPBInt64BoolDictionary alloc] initWithValues:kValues - forKeys:kKeys - count:GPBARRAYSIZE(kValues)]; + [[GPBInt64BoolDictionary alloc] initWithBools:kValues + forKeys:kKeys + count:GPBARRAYSIZE(kValues)]; XCTAssertNotNil(dict); GPBInt64BoolDictionary *dict2 = @@ -1700,31 +1700,31 @@ static BOOL TestingEnum_IsValidValue(int32_t value) { XCTAssertNotNil(dict); XCTAssertEqual(dict.count, 0U); - [dict setValue:YES forKey:21LL]; + [dict setBool:YES forKey:21LL]; XCTAssertEqual(dict.count, 1U); const int64_t kKeys[] = { 22LL, 23LL, 24LL }; const BOOL kValues[] = { YES, NO, NO }; GPBInt64BoolDictionary *dict2 = - [[GPBInt64BoolDictionary alloc] initWithValues:kValues - forKeys:kKeys - count:GPBARRAYSIZE(kValues)]; + [[GPBInt64BoolDictionary alloc] initWithBools:kValues + forKeys:kKeys + count:GPBARRAYSIZE(kValues)]; XCTAssertNotNil(dict2); [dict addEntriesFromDictionary:dict2]; XCTAssertEqual(dict.count, 4U); BOOL value; - XCTAssertTrue([dict valueForKey:21LL value:NULL]); - XCTAssertTrue([dict valueForKey:21LL value:&value]); + XCTAssertTrue([dict getBool:NULL forKey:21LL]); + XCTAssertTrue([dict getBool:&value forKey:21LL]); XCTAssertEqual(value, YES); - XCTAssertTrue([dict valueForKey:22LL value:NULL]); - XCTAssertTrue([dict valueForKey:22LL value:&value]); + XCTAssertTrue([dict getBool:NULL forKey:22LL]); + XCTAssertTrue([dict getBool:&value forKey:22LL]); XCTAssertEqual(value, YES); - XCTAssertTrue([dict valueForKey:23LL value:NULL]); - XCTAssertTrue([dict valueForKey:23LL value:&value]); + XCTAssertTrue([dict getBool:NULL forKey:23LL]); + XCTAssertTrue([dict getBool:&value forKey:23LL]); XCTAssertEqual(value, NO); - XCTAssertTrue([dict valueForKey:24LL value:NULL]); - XCTAssertTrue([dict valueForKey:24LL value:&value]); + XCTAssertTrue([dict getBool:NULL forKey:24LL]); + XCTAssertTrue([dict getBool:&value forKey:24LL]); XCTAssertEqual(value, NO); [dict2 release]; } @@ -1733,57 +1733,57 @@ static BOOL TestingEnum_IsValidValue(int32_t value) { const int64_t kKeys[] = { 21LL, 22LL, 23LL, 24LL }; const BOOL kValues[] = { YES, YES, NO, NO }; GPBInt64BoolDictionary *dict = - [[GPBInt64BoolDictionary alloc] initWithValues:kValues - forKeys:kKeys - count:GPBARRAYSIZE(kValues)]; + [[GPBInt64BoolDictionary alloc] initWithBools:kValues + forKeys:kKeys + count:GPBARRAYSIZE(kValues)]; XCTAssertNotNil(dict); XCTAssertEqual(dict.count, 4U); - [dict removeValueForKey:22LL]; + [dict removeBoolForKey:22LL]; XCTAssertEqual(dict.count, 3U); BOOL value; - XCTAssertTrue([dict valueForKey:21LL value:NULL]); - XCTAssertTrue([dict valueForKey:21LL value:&value]); + XCTAssertTrue([dict getBool:NULL forKey:21LL]); + XCTAssertTrue([dict getBool:&value forKey:21LL]); XCTAssertEqual(value, YES); - XCTAssertFalse([dict valueForKey:22LL value:NULL]); - XCTAssertTrue([dict valueForKey:23LL value:NULL]); - XCTAssertTrue([dict valueForKey:23LL value:&value]); + XCTAssertFalse([dict getBool:NULL forKey:22LL]); + XCTAssertTrue([dict getBool:NULL forKey:23LL]); + XCTAssertTrue([dict getBool:&value forKey:23LL]); XCTAssertEqual(value, NO); - XCTAssertTrue([dict valueForKey:24LL value:NULL]); - XCTAssertTrue([dict valueForKey:24LL value:&value]); + XCTAssertTrue([dict getBool:NULL forKey:24LL]); + XCTAssertTrue([dict getBool:&value forKey:24LL]); XCTAssertEqual(value, NO); // Remove again does nothing. - [dict removeValueForKey:22LL]; + [dict removeBoolForKey:22LL]; XCTAssertEqual(dict.count, 3U); - XCTAssertTrue([dict valueForKey:21LL value:NULL]); - XCTAssertTrue([dict valueForKey:21LL value:&value]); + XCTAssertTrue([dict getBool:NULL forKey:21LL]); + XCTAssertTrue([dict getBool:&value forKey:21LL]); XCTAssertEqual(value, YES); - XCTAssertFalse([dict valueForKey:22LL value:NULL]); - XCTAssertTrue([dict valueForKey:23LL value:NULL]); - XCTAssertTrue([dict valueForKey:23LL value:&value]); + XCTAssertFalse([dict getBool:NULL forKey:22LL]); + XCTAssertTrue([dict getBool:NULL forKey:23LL]); + XCTAssertTrue([dict getBool:&value forKey:23LL]); XCTAssertEqual(value, NO); - XCTAssertTrue([dict valueForKey:24LL value:NULL]); - XCTAssertTrue([dict valueForKey:24LL value:&value]); + XCTAssertTrue([dict getBool:NULL forKey:24LL]); + XCTAssertTrue([dict getBool:&value forKey:24LL]); XCTAssertEqual(value, NO); - [dict removeValueForKey:24LL]; + [dict removeBoolForKey:24LL]; XCTAssertEqual(dict.count, 2U); - XCTAssertTrue([dict valueForKey:21LL value:NULL]); - XCTAssertTrue([dict valueForKey:21LL value:&value]); + XCTAssertTrue([dict getBool:NULL forKey:21LL]); + XCTAssertTrue([dict getBool:&value forKey:21LL]); XCTAssertEqual(value, YES); - XCTAssertFalse([dict valueForKey:22LL value:NULL]); - XCTAssertTrue([dict valueForKey:23LL value:NULL]); - XCTAssertTrue([dict valueForKey:23LL value:&value]); + XCTAssertFalse([dict getBool:NULL forKey:22LL]); + XCTAssertTrue([dict getBool:NULL forKey:23LL]); + XCTAssertTrue([dict getBool:&value forKey:23LL]); XCTAssertEqual(value, NO); - XCTAssertFalse([dict valueForKey:24LL value:NULL]); + XCTAssertFalse([dict getBool:NULL forKey:24LL]); [dict removeAll]; XCTAssertEqual(dict.count, 0U); - XCTAssertFalse([dict valueForKey:21LL value:NULL]); - XCTAssertFalse([dict valueForKey:22LL value:NULL]); - XCTAssertFalse([dict valueForKey:23LL value:NULL]); - XCTAssertFalse([dict valueForKey:24LL value:NULL]); + XCTAssertFalse([dict getBool:NULL forKey:21LL]); + XCTAssertFalse([dict getBool:NULL forKey:22LL]); + XCTAssertFalse([dict getBool:NULL forKey:23LL]); + XCTAssertFalse([dict getBool:NULL forKey:24LL]); [dict release]; } @@ -1791,75 +1791,75 @@ static BOOL TestingEnum_IsValidValue(int32_t value) { const int64_t kKeys[] = { 21LL, 22LL, 23LL, 24LL }; const BOOL kValues[] = { YES, YES, NO, NO }; GPBInt64BoolDictionary *dict = - [[GPBInt64BoolDictionary alloc] initWithValues:kValues - forKeys:kKeys - count:GPBARRAYSIZE(kValues)]; + [[GPBInt64BoolDictionary alloc] initWithBools:kValues + forKeys:kKeys + count:GPBARRAYSIZE(kValues)]; XCTAssertNotNil(dict); XCTAssertEqual(dict.count, 4U); BOOL value; - XCTAssertTrue([dict valueForKey:21LL value:NULL]); - XCTAssertTrue([dict valueForKey:21LL value:&value]); + XCTAssertTrue([dict getBool:NULL forKey:21LL]); + XCTAssertTrue([dict getBool:&value forKey:21LL]); XCTAssertEqual(value, YES); - XCTAssertTrue([dict valueForKey:22LL value:NULL]); - XCTAssertTrue([dict valueForKey:22LL value:&value]); + XCTAssertTrue([dict getBool:NULL forKey:22LL]); + XCTAssertTrue([dict getBool:&value forKey:22LL]); XCTAssertEqual(value, YES); - XCTAssertTrue([dict valueForKey:23LL value:NULL]); - XCTAssertTrue([dict valueForKey:23LL value:&value]); + XCTAssertTrue([dict getBool:NULL forKey:23LL]); + XCTAssertTrue([dict getBool:&value forKey:23LL]); XCTAssertEqual(value, NO); - XCTAssertTrue([dict valueForKey:24LL value:NULL]); - XCTAssertTrue([dict valueForKey:24LL value:&value]); + XCTAssertTrue([dict getBool:NULL forKey:24LL]); + XCTAssertTrue([dict getBool:&value forKey:24LL]); XCTAssertEqual(value, NO); - [dict setValue:NO forKey:21LL]; + [dict setBool:NO forKey:21LL]; XCTAssertEqual(dict.count, 4U); - XCTAssertTrue([dict valueForKey:21LL value:NULL]); - XCTAssertTrue([dict valueForKey:21LL value:&value]); + XCTAssertTrue([dict getBool:NULL forKey:21LL]); + XCTAssertTrue([dict getBool:&value forKey:21LL]); XCTAssertEqual(value, NO); - XCTAssertTrue([dict valueForKey:22LL value:NULL]); - XCTAssertTrue([dict valueForKey:22LL value:&value]); + XCTAssertTrue([dict getBool:NULL forKey:22LL]); + XCTAssertTrue([dict getBool:&value forKey:22LL]); XCTAssertEqual(value, YES); - XCTAssertTrue([dict valueForKey:23LL value:NULL]); - XCTAssertTrue([dict valueForKey:23LL value:&value]); + XCTAssertTrue([dict getBool:NULL forKey:23LL]); + XCTAssertTrue([dict getBool:&value forKey:23LL]); XCTAssertEqual(value, NO); - XCTAssertTrue([dict valueForKey:24LL value:NULL]); - XCTAssertTrue([dict valueForKey:24LL value:&value]); + XCTAssertTrue([dict getBool:NULL forKey:24LL]); + XCTAssertTrue([dict getBool:&value forKey:24LL]); XCTAssertEqual(value, NO); - [dict setValue:YES forKey:24LL]; + [dict setBool:YES forKey:24LL]; XCTAssertEqual(dict.count, 4U); - XCTAssertTrue([dict valueForKey:21LL value:NULL]); - XCTAssertTrue([dict valueForKey:21LL value:&value]); + XCTAssertTrue([dict getBool:NULL forKey:21LL]); + XCTAssertTrue([dict getBool:&value forKey:21LL]); XCTAssertEqual(value, NO); - XCTAssertTrue([dict valueForKey:22LL value:NULL]); - XCTAssertTrue([dict valueForKey:22LL value:&value]); + XCTAssertTrue([dict getBool:NULL forKey:22LL]); + XCTAssertTrue([dict getBool:&value forKey:22LL]); XCTAssertEqual(value, YES); - XCTAssertTrue([dict valueForKey:23LL value:NULL]); - XCTAssertTrue([dict valueForKey:23LL value:&value]); + XCTAssertTrue([dict getBool:NULL forKey:23LL]); + XCTAssertTrue([dict getBool:&value forKey:23LL]); XCTAssertEqual(value, NO); - XCTAssertTrue([dict valueForKey:24LL value:NULL]); - XCTAssertTrue([dict valueForKey:24LL value:&value]); + XCTAssertTrue([dict getBool:NULL forKey:24LL]); + XCTAssertTrue([dict getBool:&value forKey:24LL]); XCTAssertEqual(value, YES); const int64_t kKeys2[] = { 22LL, 23LL }; const BOOL kValues2[] = { NO, YES }; GPBInt64BoolDictionary *dict2 = - [[GPBInt64BoolDictionary alloc] initWithValues:kValues2 - forKeys:kKeys2 - count:GPBARRAYSIZE(kValues2)]; + [[GPBInt64BoolDictionary alloc] initWithBools:kValues2 + forKeys:kKeys2 + count:GPBARRAYSIZE(kValues2)]; XCTAssertNotNil(dict2); [dict addEntriesFromDictionary:dict2]; XCTAssertEqual(dict.count, 4U); - XCTAssertTrue([dict valueForKey:21LL value:NULL]); - XCTAssertTrue([dict valueForKey:21LL value:&value]); + XCTAssertTrue([dict getBool:NULL forKey:21LL]); + XCTAssertTrue([dict getBool:&value forKey:21LL]); XCTAssertEqual(value, NO); - XCTAssertTrue([dict valueForKey:22LL value:NULL]); - XCTAssertTrue([dict valueForKey:22LL value:&value]); + XCTAssertTrue([dict getBool:NULL forKey:22LL]); + XCTAssertTrue([dict getBool:&value forKey:22LL]); XCTAssertEqual(value, NO); - XCTAssertTrue([dict valueForKey:23LL value:NULL]); - XCTAssertTrue([dict valueForKey:23LL value:&value]); + XCTAssertTrue([dict getBool:NULL forKey:23LL]); + XCTAssertTrue([dict getBool:&value forKey:23LL]); XCTAssertEqual(value, YES); - XCTAssertTrue([dict valueForKey:24LL value:NULL]); - XCTAssertTrue([dict valueForKey:24LL value:&value]); + XCTAssertTrue([dict getBool:NULL forKey:24LL]); + XCTAssertTrue([dict getBool:&value forKey:24LL]); XCTAssertEqual(value, YES); [dict2 release]; @@ -1879,8 +1879,8 @@ static BOOL TestingEnum_IsValidValue(int32_t value) { GPBInt64FloatDictionary *dict = [[GPBInt64FloatDictionary alloc] init]; XCTAssertNotNil(dict); XCTAssertEqual(dict.count, 0U); - XCTAssertFalse([dict valueForKey:21LL value:NULL]); - [dict enumerateKeysAndValuesUsingBlock:^(int64_t aKey, float aValue, BOOL *stop) { + XCTAssertFalse([dict getFloat:NULL forKey:21LL]); + [dict enumerateKeysAndFloatsUsingBlock:^(int64_t aKey, float aValue, BOOL *stop) { #pragma unused(aKey, aValue, stop) XCTFail(@"Shouldn't get here!"); }]; @@ -1888,15 +1888,15 @@ static BOOL TestingEnum_IsValidValue(int32_t value) { } - (void)testOne { - GPBInt64FloatDictionary *dict = [GPBInt64FloatDictionary dictionaryWithValue:500.f forKey:21LL]; + GPBInt64FloatDictionary *dict = [GPBInt64FloatDictionary dictionaryWithFloat:500.f forKey:21LL]; XCTAssertNotNil(dict); XCTAssertEqual(dict.count, 1U); float value; - XCTAssertTrue([dict valueForKey:21LL value:NULL]); - XCTAssertTrue([dict valueForKey:21LL value:&value]); + XCTAssertTrue([dict getFloat:NULL forKey:21LL]); + XCTAssertTrue([dict getFloat:&value forKey:21LL]); XCTAssertEqual(value, 500.f); - XCTAssertFalse([dict valueForKey:22LL value:NULL]); - [dict enumerateKeysAndValuesUsingBlock:^(int64_t aKey, float aValue, BOOL *stop) { + XCTAssertFalse([dict getFloat:NULL forKey:22LL]); + [dict enumerateKeysAndFloatsUsingBlock:^(int64_t aKey, float aValue, BOOL *stop) { XCTAssertEqual(aKey, 21LL); XCTAssertEqual(aValue, 500.f); XCTAssertNotEqual(stop, NULL); @@ -1907,27 +1907,27 @@ static BOOL TestingEnum_IsValidValue(int32_t value) { const int64_t kKeys[] = { 21LL, 22LL, 23LL }; const float kValues[] = { 500.f, 501.f, 502.f }; GPBInt64FloatDictionary *dict = - [[GPBInt64FloatDictionary alloc] initWithValues:kValues + [[GPBInt64FloatDictionary alloc] initWithFloats:kValues forKeys:kKeys count:GPBARRAYSIZE(kValues)]; XCTAssertNotNil(dict); XCTAssertEqual(dict.count, 3U); float value; - XCTAssertTrue([dict valueForKey:21LL value:NULL]); - XCTAssertTrue([dict valueForKey:21LL value:&value]); + XCTAssertTrue([dict getFloat:NULL forKey:21LL]); + XCTAssertTrue([dict getFloat:&value forKey:21LL]); XCTAssertEqual(value, 500.f); - XCTAssertTrue([dict valueForKey:22LL value:NULL]); - XCTAssertTrue([dict valueForKey:22LL value:&value]); + XCTAssertTrue([dict getFloat:NULL forKey:22LL]); + XCTAssertTrue([dict getFloat:&value forKey:22LL]); XCTAssertEqual(value, 501.f); - XCTAssertTrue([dict valueForKey:23LL value:NULL]); - XCTAssertTrue([dict valueForKey:23LL value:&value]); + XCTAssertTrue([dict getFloat:NULL forKey:23LL]); + XCTAssertTrue([dict getFloat:&value forKey:23LL]); XCTAssertEqual(value, 502.f); - XCTAssertFalse([dict valueForKey:24LL value:NULL]); + XCTAssertFalse([dict getFloat:NULL forKey:24LL]); __block NSUInteger idx = 0; int64_t *seenKeys = malloc(3 * sizeof(int64_t)); float *seenValues = malloc(3 * sizeof(float)); - [dict enumerateKeysAndValuesUsingBlock:^(int64_t aKey, float aValue, BOOL *stop) { + [dict enumerateKeysAndFloatsUsingBlock:^(int64_t aKey, float aValue, BOOL *stop) { XCTAssertLessThan(idx, 3U); seenKeys[idx] = aKey; seenValues[idx] = aValue; @@ -1949,7 +1949,7 @@ static BOOL TestingEnum_IsValidValue(int32_t value) { // Stopping the enumeration. idx = 0; - [dict enumerateKeysAndValuesUsingBlock:^(int64_t aKey, float aValue, BOOL *stop) { + [dict enumerateKeysAndFloatsUsingBlock:^(int64_t aKey, float aValue, BOOL *stop) { #pragma unused(aKey, aValue) if (idx == 1) *stop = YES; XCTAssertNotEqual(idx, 2U); @@ -1965,27 +1965,27 @@ static BOOL TestingEnum_IsValidValue(int32_t value) { const float kValues2[] = { 500.f, 503.f, 502.f }; const float kValues3[] = { 500.f, 501.f, 502.f, 503.f }; GPBInt64FloatDictionary *dict1 = - [[GPBInt64FloatDictionary alloc] initWithValues:kValues1 + [[GPBInt64FloatDictionary alloc] initWithFloats:kValues1 forKeys:kKeys1 count:GPBARRAYSIZE(kValues1)]; XCTAssertNotNil(dict1); GPBInt64FloatDictionary *dict1prime = - [[GPBInt64FloatDictionary alloc] initWithValues:kValues1 + [[GPBInt64FloatDictionary alloc] initWithFloats:kValues1 forKeys:kKeys1 count:GPBARRAYSIZE(kValues1)]; XCTAssertNotNil(dict1prime); GPBInt64FloatDictionary *dict2 = - [[GPBInt64FloatDictionary alloc] initWithValues:kValues2 + [[GPBInt64FloatDictionary alloc] initWithFloats:kValues2 forKeys:kKeys1 count:GPBARRAYSIZE(kValues2)]; XCTAssertNotNil(dict2); GPBInt64FloatDictionary *dict3 = - [[GPBInt64FloatDictionary alloc] initWithValues:kValues1 + [[GPBInt64FloatDictionary alloc] initWithFloats:kValues1 forKeys:kKeys2 count:GPBARRAYSIZE(kValues1)]; XCTAssertNotNil(dict3); GPBInt64FloatDictionary *dict4 = - [[GPBInt64FloatDictionary alloc] initWithValues:kValues3 + [[GPBInt64FloatDictionary alloc] initWithFloats:kValues3 forKeys:kKeys1 count:GPBARRAYSIZE(kValues3)]; XCTAssertNotNil(dict4); @@ -2016,7 +2016,7 @@ static BOOL TestingEnum_IsValidValue(int32_t value) { const int64_t kKeys[] = { 21LL, 22LL, 23LL, 24LL }; const float kValues[] = { 500.f, 501.f, 502.f, 503.f }; GPBInt64FloatDictionary *dict = - [[GPBInt64FloatDictionary alloc] initWithValues:kValues + [[GPBInt64FloatDictionary alloc] initWithFloats:kValues forKeys:kKeys count:GPBARRAYSIZE(kValues)]; XCTAssertNotNil(dict); @@ -2037,7 +2037,7 @@ static BOOL TestingEnum_IsValidValue(int32_t value) { const int64_t kKeys[] = { 21LL, 22LL, 23LL, 24LL }; const float kValues[] = { 500.f, 501.f, 502.f, 503.f }; GPBInt64FloatDictionary *dict = - [[GPBInt64FloatDictionary alloc] initWithValues:kValues + [[GPBInt64FloatDictionary alloc] initWithFloats:kValues forKeys:kKeys count:GPBARRAYSIZE(kValues)]; XCTAssertNotNil(dict); @@ -2057,13 +2057,13 @@ static BOOL TestingEnum_IsValidValue(int32_t value) { XCTAssertNotNil(dict); XCTAssertEqual(dict.count, 0U); - [dict setValue:500.f forKey:21LL]; + [dict setFloat:500.f forKey:21LL]; XCTAssertEqual(dict.count, 1U); const int64_t kKeys[] = { 22LL, 23LL, 24LL }; const float kValues[] = { 501.f, 502.f, 503.f }; GPBInt64FloatDictionary *dict2 = - [[GPBInt64FloatDictionary alloc] initWithValues:kValues + [[GPBInt64FloatDictionary alloc] initWithFloats:kValues forKeys:kKeys count:GPBARRAYSIZE(kValues)]; XCTAssertNotNil(dict2); @@ -2071,17 +2071,17 @@ static BOOL TestingEnum_IsValidValue(int32_t value) { XCTAssertEqual(dict.count, 4U); float value; - XCTAssertTrue([dict valueForKey:21LL value:NULL]); - XCTAssertTrue([dict valueForKey:21LL value:&value]); + XCTAssertTrue([dict getFloat:NULL forKey:21LL]); + XCTAssertTrue([dict getFloat:&value forKey:21LL]); XCTAssertEqual(value, 500.f); - XCTAssertTrue([dict valueForKey:22LL value:NULL]); - XCTAssertTrue([dict valueForKey:22LL value:&value]); + XCTAssertTrue([dict getFloat:NULL forKey:22LL]); + XCTAssertTrue([dict getFloat:&value forKey:22LL]); XCTAssertEqual(value, 501.f); - XCTAssertTrue([dict valueForKey:23LL value:NULL]); - XCTAssertTrue([dict valueForKey:23LL value:&value]); + XCTAssertTrue([dict getFloat:NULL forKey:23LL]); + XCTAssertTrue([dict getFloat:&value forKey:23LL]); XCTAssertEqual(value, 502.f); - XCTAssertTrue([dict valueForKey:24LL value:NULL]); - XCTAssertTrue([dict valueForKey:24LL value:&value]); + XCTAssertTrue([dict getFloat:NULL forKey:24LL]); + XCTAssertTrue([dict getFloat:&value forKey:24LL]); XCTAssertEqual(value, 503.f); [dict2 release]; } @@ -2090,57 +2090,57 @@ static BOOL TestingEnum_IsValidValue(int32_t value) { const int64_t kKeys[] = { 21LL, 22LL, 23LL, 24LL }; const float kValues[] = { 500.f, 501.f, 502.f, 503.f }; GPBInt64FloatDictionary *dict = - [[GPBInt64FloatDictionary alloc] initWithValues:kValues - forKeys:kKeys - count:GPBARRAYSIZE(kValues)]; + [[GPBInt64FloatDictionary alloc] initWithFloats:kValues + forKeys:kKeys + count:GPBARRAYSIZE(kValues)]; XCTAssertNotNil(dict); XCTAssertEqual(dict.count, 4U); - [dict removeValueForKey:22LL]; + [dict removeFloatForKey:22LL]; XCTAssertEqual(dict.count, 3U); float value; - XCTAssertTrue([dict valueForKey:21LL value:NULL]); - XCTAssertTrue([dict valueForKey:21LL value:&value]); + XCTAssertTrue([dict getFloat:NULL forKey:21LL]); + XCTAssertTrue([dict getFloat:&value forKey:21LL]); XCTAssertEqual(value, 500.f); - XCTAssertFalse([dict valueForKey:22LL value:NULL]); - XCTAssertTrue([dict valueForKey:23LL value:NULL]); - XCTAssertTrue([dict valueForKey:23LL value:&value]); + XCTAssertFalse([dict getFloat:NULL forKey:22LL]); + XCTAssertTrue([dict getFloat:NULL forKey:23LL]); + XCTAssertTrue([dict getFloat:&value forKey:23LL]); XCTAssertEqual(value, 502.f); - XCTAssertTrue([dict valueForKey:24LL value:NULL]); - XCTAssertTrue([dict valueForKey:24LL value:&value]); + XCTAssertTrue([dict getFloat:NULL forKey:24LL]); + XCTAssertTrue([dict getFloat:&value forKey:24LL]); XCTAssertEqual(value, 503.f); // Remove again does nothing. - [dict removeValueForKey:22LL]; + [dict removeFloatForKey:22LL]; XCTAssertEqual(dict.count, 3U); - XCTAssertTrue([dict valueForKey:21LL value:NULL]); - XCTAssertTrue([dict valueForKey:21LL value:&value]); + XCTAssertTrue([dict getFloat:NULL forKey:21LL]); + XCTAssertTrue([dict getFloat:&value forKey:21LL]); XCTAssertEqual(value, 500.f); - XCTAssertFalse([dict valueForKey:22LL value:NULL]); - XCTAssertTrue([dict valueForKey:23LL value:NULL]); - XCTAssertTrue([dict valueForKey:23LL value:&value]); + XCTAssertFalse([dict getFloat:NULL forKey:22LL]); + XCTAssertTrue([dict getFloat:NULL forKey:23LL]); + XCTAssertTrue([dict getFloat:&value forKey:23LL]); XCTAssertEqual(value, 502.f); - XCTAssertTrue([dict valueForKey:24LL value:NULL]); - XCTAssertTrue([dict valueForKey:24LL value:&value]); + XCTAssertTrue([dict getFloat:NULL forKey:24LL]); + XCTAssertTrue([dict getFloat:&value forKey:24LL]); XCTAssertEqual(value, 503.f); - [dict removeValueForKey:24LL]; + [dict removeFloatForKey:24LL]; XCTAssertEqual(dict.count, 2U); - XCTAssertTrue([dict valueForKey:21LL value:NULL]); - XCTAssertTrue([dict valueForKey:21LL value:&value]); + XCTAssertTrue([dict getFloat:NULL forKey:21LL]); + XCTAssertTrue([dict getFloat:&value forKey:21LL]); XCTAssertEqual(value, 500.f); - XCTAssertFalse([dict valueForKey:22LL value:NULL]); - XCTAssertTrue([dict valueForKey:23LL value:NULL]); - XCTAssertTrue([dict valueForKey:23LL value:&value]); + XCTAssertFalse([dict getFloat:NULL forKey:22LL]); + XCTAssertTrue([dict getFloat:NULL forKey:23LL]); + XCTAssertTrue([dict getFloat:&value forKey:23LL]); XCTAssertEqual(value, 502.f); - XCTAssertFalse([dict valueForKey:24LL value:NULL]); + XCTAssertFalse([dict getFloat:NULL forKey:24LL]); [dict removeAll]; XCTAssertEqual(dict.count, 0U); - XCTAssertFalse([dict valueForKey:21LL value:NULL]); - XCTAssertFalse([dict valueForKey:22LL value:NULL]); - XCTAssertFalse([dict valueForKey:23LL value:NULL]); - XCTAssertFalse([dict valueForKey:24LL value:NULL]); + XCTAssertFalse([dict getFloat:NULL forKey:21LL]); + XCTAssertFalse([dict getFloat:NULL forKey:22LL]); + XCTAssertFalse([dict getFloat:NULL forKey:23LL]); + XCTAssertFalse([dict getFloat:NULL forKey:24LL]); [dict release]; } @@ -2148,75 +2148,75 @@ static BOOL TestingEnum_IsValidValue(int32_t value) { const int64_t kKeys[] = { 21LL, 22LL, 23LL, 24LL }; const float kValues[] = { 500.f, 501.f, 502.f, 503.f }; GPBInt64FloatDictionary *dict = - [[GPBInt64FloatDictionary alloc] initWithValues:kValues - forKeys:kKeys - count:GPBARRAYSIZE(kValues)]; + [[GPBInt64FloatDictionary alloc] initWithFloats:kValues + forKeys:kKeys + count:GPBARRAYSIZE(kValues)]; XCTAssertNotNil(dict); XCTAssertEqual(dict.count, 4U); float value; - XCTAssertTrue([dict valueForKey:21LL value:NULL]); - XCTAssertTrue([dict valueForKey:21LL value:&value]); + XCTAssertTrue([dict getFloat:NULL forKey:21LL]); + XCTAssertTrue([dict getFloat:&value forKey:21LL]); XCTAssertEqual(value, 500.f); - XCTAssertTrue([dict valueForKey:22LL value:NULL]); - XCTAssertTrue([dict valueForKey:22LL value:&value]); + XCTAssertTrue([dict getFloat:NULL forKey:22LL]); + XCTAssertTrue([dict getFloat:&value forKey:22LL]); XCTAssertEqual(value, 501.f); - XCTAssertTrue([dict valueForKey:23LL value:NULL]); - XCTAssertTrue([dict valueForKey:23LL value:&value]); + XCTAssertTrue([dict getFloat:NULL forKey:23LL]); + XCTAssertTrue([dict getFloat:&value forKey:23LL]); XCTAssertEqual(value, 502.f); - XCTAssertTrue([dict valueForKey:24LL value:NULL]); - XCTAssertTrue([dict valueForKey:24LL value:&value]); + XCTAssertTrue([dict getFloat:NULL forKey:24LL]); + XCTAssertTrue([dict getFloat:&value forKey:24LL]); XCTAssertEqual(value, 503.f); - [dict setValue:503.f forKey:21LL]; + [dict setFloat:503.f forKey:21LL]; XCTAssertEqual(dict.count, 4U); - XCTAssertTrue([dict valueForKey:21LL value:NULL]); - XCTAssertTrue([dict valueForKey:21LL value:&value]); + XCTAssertTrue([dict getFloat:NULL forKey:21LL]); + XCTAssertTrue([dict getFloat:&value forKey:21LL]); XCTAssertEqual(value, 503.f); - XCTAssertTrue([dict valueForKey:22LL value:NULL]); - XCTAssertTrue([dict valueForKey:22LL value:&value]); + XCTAssertTrue([dict getFloat:NULL forKey:22LL]); + XCTAssertTrue([dict getFloat:&value forKey:22LL]); XCTAssertEqual(value, 501.f); - XCTAssertTrue([dict valueForKey:23LL value:NULL]); - XCTAssertTrue([dict valueForKey:23LL value:&value]); + XCTAssertTrue([dict getFloat:NULL forKey:23LL]); + XCTAssertTrue([dict getFloat:&value forKey:23LL]); XCTAssertEqual(value, 502.f); - XCTAssertTrue([dict valueForKey:24LL value:NULL]); - XCTAssertTrue([dict valueForKey:24LL value:&value]); + XCTAssertTrue([dict getFloat:NULL forKey:24LL]); + XCTAssertTrue([dict getFloat:&value forKey:24LL]); XCTAssertEqual(value, 503.f); - [dict setValue:501.f forKey:24LL]; + [dict setFloat:501.f forKey:24LL]; XCTAssertEqual(dict.count, 4U); - XCTAssertTrue([dict valueForKey:21LL value:NULL]); - XCTAssertTrue([dict valueForKey:21LL value:&value]); + XCTAssertTrue([dict getFloat:NULL forKey:21LL]); + XCTAssertTrue([dict getFloat:&value forKey:21LL]); XCTAssertEqual(value, 503.f); - XCTAssertTrue([dict valueForKey:22LL value:NULL]); - XCTAssertTrue([dict valueForKey:22LL value:&value]); + XCTAssertTrue([dict getFloat:NULL forKey:22LL]); + XCTAssertTrue([dict getFloat:&value forKey:22LL]); XCTAssertEqual(value, 501.f); - XCTAssertTrue([dict valueForKey:23LL value:NULL]); - XCTAssertTrue([dict valueForKey:23LL value:&value]); + XCTAssertTrue([dict getFloat:NULL forKey:23LL]); + XCTAssertTrue([dict getFloat:&value forKey:23LL]); XCTAssertEqual(value, 502.f); - XCTAssertTrue([dict valueForKey:24LL value:NULL]); - XCTAssertTrue([dict valueForKey:24LL value:&value]); + XCTAssertTrue([dict getFloat:NULL forKey:24LL]); + XCTAssertTrue([dict getFloat:&value forKey:24LL]); XCTAssertEqual(value, 501.f); const int64_t kKeys2[] = { 22LL, 23LL }; const float kValues2[] = { 502.f, 500.f }; GPBInt64FloatDictionary *dict2 = - [[GPBInt64FloatDictionary alloc] initWithValues:kValues2 + [[GPBInt64FloatDictionary alloc] initWithFloats:kValues2 forKeys:kKeys2 count:GPBARRAYSIZE(kValues2)]; XCTAssertNotNil(dict2); [dict addEntriesFromDictionary:dict2]; XCTAssertEqual(dict.count, 4U); - XCTAssertTrue([dict valueForKey:21LL value:NULL]); - XCTAssertTrue([dict valueForKey:21LL value:&value]); + XCTAssertTrue([dict getFloat:NULL forKey:21LL]); + XCTAssertTrue([dict getFloat:&value forKey:21LL]); XCTAssertEqual(value, 503.f); - XCTAssertTrue([dict valueForKey:22LL value:NULL]); - XCTAssertTrue([dict valueForKey:22LL value:&value]); + XCTAssertTrue([dict getFloat:NULL forKey:22LL]); + XCTAssertTrue([dict getFloat:&value forKey:22LL]); XCTAssertEqual(value, 502.f); - XCTAssertTrue([dict valueForKey:23LL value:NULL]); - XCTAssertTrue([dict valueForKey:23LL value:&value]); + XCTAssertTrue([dict getFloat:NULL forKey:23LL]); + XCTAssertTrue([dict getFloat:&value forKey:23LL]); XCTAssertEqual(value, 500.f); - XCTAssertTrue([dict valueForKey:24LL value:NULL]); - XCTAssertTrue([dict valueForKey:24LL value:&value]); + XCTAssertTrue([dict getFloat:NULL forKey:24LL]); + XCTAssertTrue([dict getFloat:&value forKey:24LL]); XCTAssertEqual(value, 501.f); [dict2 release]; @@ -2236,8 +2236,8 @@ static BOOL TestingEnum_IsValidValue(int32_t value) { GPBInt64DoubleDictionary *dict = [[GPBInt64DoubleDictionary alloc] init]; XCTAssertNotNil(dict); XCTAssertEqual(dict.count, 0U); - XCTAssertFalse([dict valueForKey:21LL value:NULL]); - [dict enumerateKeysAndValuesUsingBlock:^(int64_t aKey, double aValue, BOOL *stop) { + XCTAssertFalse([dict getDouble:NULL forKey:21LL]); + [dict enumerateKeysAndDoublesUsingBlock:^(int64_t aKey, double aValue, BOOL *stop) { #pragma unused(aKey, aValue, stop) XCTFail(@"Shouldn't get here!"); }]; @@ -2245,15 +2245,15 @@ static BOOL TestingEnum_IsValidValue(int32_t value) { } - (void)testOne { - GPBInt64DoubleDictionary *dict = [GPBInt64DoubleDictionary dictionaryWithValue:600. forKey:21LL]; + GPBInt64DoubleDictionary *dict = [GPBInt64DoubleDictionary dictionaryWithDouble:600. forKey:21LL]; XCTAssertNotNil(dict); XCTAssertEqual(dict.count, 1U); double value; - XCTAssertTrue([dict valueForKey:21LL value:NULL]); - XCTAssertTrue([dict valueForKey:21LL value:&value]); + XCTAssertTrue([dict getDouble:NULL forKey:21LL]); + XCTAssertTrue([dict getDouble:&value forKey:21LL]); XCTAssertEqual(value, 600.); - XCTAssertFalse([dict valueForKey:22LL value:NULL]); - [dict enumerateKeysAndValuesUsingBlock:^(int64_t aKey, double aValue, BOOL *stop) { + XCTAssertFalse([dict getDouble:NULL forKey:22LL]); + [dict enumerateKeysAndDoublesUsingBlock:^(int64_t aKey, double aValue, BOOL *stop) { XCTAssertEqual(aKey, 21LL); XCTAssertEqual(aValue, 600.); XCTAssertNotEqual(stop, NULL); @@ -2264,27 +2264,27 @@ static BOOL TestingEnum_IsValidValue(int32_t value) { const int64_t kKeys[] = { 21LL, 22LL, 23LL }; const double kValues[] = { 600., 601., 602. }; GPBInt64DoubleDictionary *dict = - [[GPBInt64DoubleDictionary alloc] initWithValues:kValues - forKeys:kKeys - count:GPBARRAYSIZE(kValues)]; + [[GPBInt64DoubleDictionary alloc] initWithDoubles:kValues + forKeys:kKeys + count:GPBARRAYSIZE(kValues)]; XCTAssertNotNil(dict); XCTAssertEqual(dict.count, 3U); double value; - XCTAssertTrue([dict valueForKey:21LL value:NULL]); - XCTAssertTrue([dict valueForKey:21LL value:&value]); + XCTAssertTrue([dict getDouble:NULL forKey:21LL]); + XCTAssertTrue([dict getDouble:&value forKey:21LL]); XCTAssertEqual(value, 600.); - XCTAssertTrue([dict valueForKey:22LL value:NULL]); - XCTAssertTrue([dict valueForKey:22LL value:&value]); + XCTAssertTrue([dict getDouble:NULL forKey:22LL]); + XCTAssertTrue([dict getDouble:&value forKey:22LL]); XCTAssertEqual(value, 601.); - XCTAssertTrue([dict valueForKey:23LL value:NULL]); - XCTAssertTrue([dict valueForKey:23LL value:&value]); + XCTAssertTrue([dict getDouble:NULL forKey:23LL]); + XCTAssertTrue([dict getDouble:&value forKey:23LL]); XCTAssertEqual(value, 602.); - XCTAssertFalse([dict valueForKey:24LL value:NULL]); + XCTAssertFalse([dict getDouble:NULL forKey:24LL]); __block NSUInteger idx = 0; int64_t *seenKeys = malloc(3 * sizeof(int64_t)); double *seenValues = malloc(3 * sizeof(double)); - [dict enumerateKeysAndValuesUsingBlock:^(int64_t aKey, double aValue, BOOL *stop) { + [dict enumerateKeysAndDoublesUsingBlock:^(int64_t aKey, double aValue, BOOL *stop) { XCTAssertLessThan(idx, 3U); seenKeys[idx] = aKey; seenValues[idx] = aValue; @@ -2306,7 +2306,7 @@ static BOOL TestingEnum_IsValidValue(int32_t value) { // Stopping the enumeration. idx = 0; - [dict enumerateKeysAndValuesUsingBlock:^(int64_t aKey, double aValue, BOOL *stop) { + [dict enumerateKeysAndDoublesUsingBlock:^(int64_t aKey, double aValue, BOOL *stop) { #pragma unused(aKey, aValue) if (idx == 1) *stop = YES; XCTAssertNotEqual(idx, 2U); @@ -2322,29 +2322,29 @@ static BOOL TestingEnum_IsValidValue(int32_t value) { const double kValues2[] = { 600., 603., 602. }; const double kValues3[] = { 600., 601., 602., 603. }; GPBInt64DoubleDictionary *dict1 = - [[GPBInt64DoubleDictionary alloc] initWithValues:kValues1 - forKeys:kKeys1 - count:GPBARRAYSIZE(kValues1)]; + [[GPBInt64DoubleDictionary alloc] initWithDoubles:kValues1 + forKeys:kKeys1 + count:GPBARRAYSIZE(kValues1)]; XCTAssertNotNil(dict1); GPBInt64DoubleDictionary *dict1prime = - [[GPBInt64DoubleDictionary alloc] initWithValues:kValues1 - forKeys:kKeys1 - count:GPBARRAYSIZE(kValues1)]; + [[GPBInt64DoubleDictionary alloc] initWithDoubles:kValues1 + forKeys:kKeys1 + count:GPBARRAYSIZE(kValues1)]; XCTAssertNotNil(dict1prime); GPBInt64DoubleDictionary *dict2 = - [[GPBInt64DoubleDictionary alloc] initWithValues:kValues2 - forKeys:kKeys1 - count:GPBARRAYSIZE(kValues2)]; + [[GPBInt64DoubleDictionary alloc] initWithDoubles:kValues2 + forKeys:kKeys1 + count:GPBARRAYSIZE(kValues2)]; XCTAssertNotNil(dict2); GPBInt64DoubleDictionary *dict3 = - [[GPBInt64DoubleDictionary alloc] initWithValues:kValues1 - forKeys:kKeys2 - count:GPBARRAYSIZE(kValues1)]; + [[GPBInt64DoubleDictionary alloc] initWithDoubles:kValues1 + forKeys:kKeys2 + count:GPBARRAYSIZE(kValues1)]; XCTAssertNotNil(dict3); GPBInt64DoubleDictionary *dict4 = - [[GPBInt64DoubleDictionary alloc] initWithValues:kValues3 - forKeys:kKeys1 - count:GPBARRAYSIZE(kValues3)]; + [[GPBInt64DoubleDictionary alloc] initWithDoubles:kValues3 + forKeys:kKeys1 + count:GPBARRAYSIZE(kValues3)]; XCTAssertNotNil(dict4); // 1/1Prime should be different objects, but equal. @@ -2373,9 +2373,9 @@ static BOOL TestingEnum_IsValidValue(int32_t value) { const int64_t kKeys[] = { 21LL, 22LL, 23LL, 24LL }; const double kValues[] = { 600., 601., 602., 603. }; GPBInt64DoubleDictionary *dict = - [[GPBInt64DoubleDictionary alloc] initWithValues:kValues - forKeys:kKeys - count:GPBARRAYSIZE(kValues)]; + [[GPBInt64DoubleDictionary alloc] initWithDoubles:kValues + forKeys:kKeys + count:GPBARRAYSIZE(kValues)]; XCTAssertNotNil(dict); GPBInt64DoubleDictionary *dict2 = [dict copy]; @@ -2394,9 +2394,9 @@ static BOOL TestingEnum_IsValidValue(int32_t value) { const int64_t kKeys[] = { 21LL, 22LL, 23LL, 24LL }; const double kValues[] = { 600., 601., 602., 603. }; GPBInt64DoubleDictionary *dict = - [[GPBInt64DoubleDictionary alloc] initWithValues:kValues - forKeys:kKeys - count:GPBARRAYSIZE(kValues)]; + [[GPBInt64DoubleDictionary alloc] initWithDoubles:kValues + forKeys:kKeys + count:GPBARRAYSIZE(kValues)]; XCTAssertNotNil(dict); GPBInt64DoubleDictionary *dict2 = @@ -2414,31 +2414,31 @@ static BOOL TestingEnum_IsValidValue(int32_t value) { XCTAssertNotNil(dict); XCTAssertEqual(dict.count, 0U); - [dict setValue:600. forKey:21LL]; + [dict setDouble:600. forKey:21LL]; XCTAssertEqual(dict.count, 1U); const int64_t kKeys[] = { 22LL, 23LL, 24LL }; const double kValues[] = { 601., 602., 603. }; GPBInt64DoubleDictionary *dict2 = - [[GPBInt64DoubleDictionary alloc] initWithValues:kValues - forKeys:kKeys - count:GPBARRAYSIZE(kValues)]; + [[GPBInt64DoubleDictionary alloc] initWithDoubles:kValues + forKeys:kKeys + count:GPBARRAYSIZE(kValues)]; XCTAssertNotNil(dict2); [dict addEntriesFromDictionary:dict2]; XCTAssertEqual(dict.count, 4U); double value; - XCTAssertTrue([dict valueForKey:21LL value:NULL]); - XCTAssertTrue([dict valueForKey:21LL value:&value]); + XCTAssertTrue([dict getDouble:NULL forKey:21LL]); + XCTAssertTrue([dict getDouble:&value forKey:21LL]); XCTAssertEqual(value, 600.); - XCTAssertTrue([dict valueForKey:22LL value:NULL]); - XCTAssertTrue([dict valueForKey:22LL value:&value]); + XCTAssertTrue([dict getDouble:NULL forKey:22LL]); + XCTAssertTrue([dict getDouble:&value forKey:22LL]); XCTAssertEqual(value, 601.); - XCTAssertTrue([dict valueForKey:23LL value:NULL]); - XCTAssertTrue([dict valueForKey:23LL value:&value]); + XCTAssertTrue([dict getDouble:NULL forKey:23LL]); + XCTAssertTrue([dict getDouble:&value forKey:23LL]); XCTAssertEqual(value, 602.); - XCTAssertTrue([dict valueForKey:24LL value:NULL]); - XCTAssertTrue([dict valueForKey:24LL value:&value]); + XCTAssertTrue([dict getDouble:NULL forKey:24LL]); + XCTAssertTrue([dict getDouble:&value forKey:24LL]); XCTAssertEqual(value, 603.); [dict2 release]; } @@ -2447,57 +2447,57 @@ static BOOL TestingEnum_IsValidValue(int32_t value) { const int64_t kKeys[] = { 21LL, 22LL, 23LL, 24LL }; const double kValues[] = { 600., 601., 602., 603. }; GPBInt64DoubleDictionary *dict = - [[GPBInt64DoubleDictionary alloc] initWithValues:kValues - forKeys:kKeys - count:GPBARRAYSIZE(kValues)]; + [[GPBInt64DoubleDictionary alloc] initWithDoubles:kValues + forKeys:kKeys + count:GPBARRAYSIZE(kValues)]; XCTAssertNotNil(dict); XCTAssertEqual(dict.count, 4U); - [dict removeValueForKey:22LL]; + [dict removeDoubleForKey:22LL]; XCTAssertEqual(dict.count, 3U); double value; - XCTAssertTrue([dict valueForKey:21LL value:NULL]); - XCTAssertTrue([dict valueForKey:21LL value:&value]); + XCTAssertTrue([dict getDouble:NULL forKey:21LL]); + XCTAssertTrue([dict getDouble:&value forKey:21LL]); XCTAssertEqual(value, 600.); - XCTAssertFalse([dict valueForKey:22LL value:NULL]); - XCTAssertTrue([dict valueForKey:23LL value:NULL]); - XCTAssertTrue([dict valueForKey:23LL value:&value]); + XCTAssertFalse([dict getDouble:NULL forKey:22LL]); + XCTAssertTrue([dict getDouble:NULL forKey:23LL]); + XCTAssertTrue([dict getDouble:&value forKey:23LL]); XCTAssertEqual(value, 602.); - XCTAssertTrue([dict valueForKey:24LL value:NULL]); - XCTAssertTrue([dict valueForKey:24LL value:&value]); + XCTAssertTrue([dict getDouble:NULL forKey:24LL]); + XCTAssertTrue([dict getDouble:&value forKey:24LL]); XCTAssertEqual(value, 603.); // Remove again does nothing. - [dict removeValueForKey:22LL]; + [dict removeDoubleForKey:22LL]; XCTAssertEqual(dict.count, 3U); - XCTAssertTrue([dict valueForKey:21LL value:NULL]); - XCTAssertTrue([dict valueForKey:21LL value:&value]); + XCTAssertTrue([dict getDouble:NULL forKey:21LL]); + XCTAssertTrue([dict getDouble:&value forKey:21LL]); XCTAssertEqual(value, 600.); - XCTAssertFalse([dict valueForKey:22LL value:NULL]); - XCTAssertTrue([dict valueForKey:23LL value:NULL]); - XCTAssertTrue([dict valueForKey:23LL value:&value]); + XCTAssertFalse([dict getDouble:NULL forKey:22LL]); + XCTAssertTrue([dict getDouble:NULL forKey:23LL]); + XCTAssertTrue([dict getDouble:&value forKey:23LL]); XCTAssertEqual(value, 602.); - XCTAssertTrue([dict valueForKey:24LL value:NULL]); - XCTAssertTrue([dict valueForKey:24LL value:&value]); + XCTAssertTrue([dict getDouble:NULL forKey:24LL]); + XCTAssertTrue([dict getDouble:&value forKey:24LL]); XCTAssertEqual(value, 603.); - [dict removeValueForKey:24LL]; + [dict removeDoubleForKey:24LL]; XCTAssertEqual(dict.count, 2U); - XCTAssertTrue([dict valueForKey:21LL value:NULL]); - XCTAssertTrue([dict valueForKey:21LL value:&value]); + XCTAssertTrue([dict getDouble:NULL forKey:21LL]); + XCTAssertTrue([dict getDouble:&value forKey:21LL]); XCTAssertEqual(value, 600.); - XCTAssertFalse([dict valueForKey:22LL value:NULL]); - XCTAssertTrue([dict valueForKey:23LL value:NULL]); - XCTAssertTrue([dict valueForKey:23LL value:&value]); + XCTAssertFalse([dict getDouble:NULL forKey:22LL]); + XCTAssertTrue([dict getDouble:NULL forKey:23LL]); + XCTAssertTrue([dict getDouble:&value forKey:23LL]); XCTAssertEqual(value, 602.); - XCTAssertFalse([dict valueForKey:24LL value:NULL]); + XCTAssertFalse([dict getDouble:NULL forKey:24LL]); [dict removeAll]; XCTAssertEqual(dict.count, 0U); - XCTAssertFalse([dict valueForKey:21LL value:NULL]); - XCTAssertFalse([dict valueForKey:22LL value:NULL]); - XCTAssertFalse([dict valueForKey:23LL value:NULL]); - XCTAssertFalse([dict valueForKey:24LL value:NULL]); + XCTAssertFalse([dict getDouble:NULL forKey:21LL]); + XCTAssertFalse([dict getDouble:NULL forKey:22LL]); + XCTAssertFalse([dict getDouble:NULL forKey:23LL]); + XCTAssertFalse([dict getDouble:NULL forKey:24LL]); [dict release]; } @@ -2505,75 +2505,75 @@ static BOOL TestingEnum_IsValidValue(int32_t value) { const int64_t kKeys[] = { 21LL, 22LL, 23LL, 24LL }; const double kValues[] = { 600., 601., 602., 603. }; GPBInt64DoubleDictionary *dict = - [[GPBInt64DoubleDictionary alloc] initWithValues:kValues - forKeys:kKeys - count:GPBARRAYSIZE(kValues)]; + [[GPBInt64DoubleDictionary alloc] initWithDoubles:kValues + forKeys:kKeys + count:GPBARRAYSIZE(kValues)]; XCTAssertNotNil(dict); XCTAssertEqual(dict.count, 4U); double value; - XCTAssertTrue([dict valueForKey:21LL value:NULL]); - XCTAssertTrue([dict valueForKey:21LL value:&value]); + XCTAssertTrue([dict getDouble:NULL forKey:21LL]); + XCTAssertTrue([dict getDouble:&value forKey:21LL]); XCTAssertEqual(value, 600.); - XCTAssertTrue([dict valueForKey:22LL value:NULL]); - XCTAssertTrue([dict valueForKey:22LL value:&value]); + XCTAssertTrue([dict getDouble:NULL forKey:22LL]); + XCTAssertTrue([dict getDouble:&value forKey:22LL]); XCTAssertEqual(value, 601.); - XCTAssertTrue([dict valueForKey:23LL value:NULL]); - XCTAssertTrue([dict valueForKey:23LL value:&value]); + XCTAssertTrue([dict getDouble:NULL forKey:23LL]); + XCTAssertTrue([dict getDouble:&value forKey:23LL]); XCTAssertEqual(value, 602.); - XCTAssertTrue([dict valueForKey:24LL value:NULL]); - XCTAssertTrue([dict valueForKey:24LL value:&value]); + XCTAssertTrue([dict getDouble:NULL forKey:24LL]); + XCTAssertTrue([dict getDouble:&value forKey:24LL]); XCTAssertEqual(value, 603.); - [dict setValue:603. forKey:21LL]; + [dict setDouble:603. forKey:21LL]; XCTAssertEqual(dict.count, 4U); - XCTAssertTrue([dict valueForKey:21LL value:NULL]); - XCTAssertTrue([dict valueForKey:21LL value:&value]); + XCTAssertTrue([dict getDouble:NULL forKey:21LL]); + XCTAssertTrue([dict getDouble:&value forKey:21LL]); XCTAssertEqual(value, 603.); - XCTAssertTrue([dict valueForKey:22LL value:NULL]); - XCTAssertTrue([dict valueForKey:22LL value:&value]); + XCTAssertTrue([dict getDouble:NULL forKey:22LL]); + XCTAssertTrue([dict getDouble:&value forKey:22LL]); XCTAssertEqual(value, 601.); - XCTAssertTrue([dict valueForKey:23LL value:NULL]); - XCTAssertTrue([dict valueForKey:23LL value:&value]); + XCTAssertTrue([dict getDouble:NULL forKey:23LL]); + XCTAssertTrue([dict getDouble:&value forKey:23LL]); XCTAssertEqual(value, 602.); - XCTAssertTrue([dict valueForKey:24LL value:NULL]); - XCTAssertTrue([dict valueForKey:24LL value:&value]); + XCTAssertTrue([dict getDouble:NULL forKey:24LL]); + XCTAssertTrue([dict getDouble:&value forKey:24LL]); XCTAssertEqual(value, 603.); - [dict setValue:601. forKey:24LL]; + [dict setDouble:601. forKey:24LL]; XCTAssertEqual(dict.count, 4U); - XCTAssertTrue([dict valueForKey:21LL value:NULL]); - XCTAssertTrue([dict valueForKey:21LL value:&value]); + XCTAssertTrue([dict getDouble:NULL forKey:21LL]); + XCTAssertTrue([dict getDouble:&value forKey:21LL]); XCTAssertEqual(value, 603.); - XCTAssertTrue([dict valueForKey:22LL value:NULL]); - XCTAssertTrue([dict valueForKey:22LL value:&value]); + XCTAssertTrue([dict getDouble:NULL forKey:22LL]); + XCTAssertTrue([dict getDouble:&value forKey:22LL]); XCTAssertEqual(value, 601.); - XCTAssertTrue([dict valueForKey:23LL value:NULL]); - XCTAssertTrue([dict valueForKey:23LL value:&value]); + XCTAssertTrue([dict getDouble:NULL forKey:23LL]); + XCTAssertTrue([dict getDouble:&value forKey:23LL]); XCTAssertEqual(value, 602.); - XCTAssertTrue([dict valueForKey:24LL value:NULL]); - XCTAssertTrue([dict valueForKey:24LL value:&value]); + XCTAssertTrue([dict getDouble:NULL forKey:24LL]); + XCTAssertTrue([dict getDouble:&value forKey:24LL]); XCTAssertEqual(value, 601.); const int64_t kKeys2[] = { 22LL, 23LL }; const double kValues2[] = { 602., 600. }; GPBInt64DoubleDictionary *dict2 = - [[GPBInt64DoubleDictionary alloc] initWithValues:kValues2 - forKeys:kKeys2 - count:GPBARRAYSIZE(kValues2)]; + [[GPBInt64DoubleDictionary alloc] initWithDoubles:kValues2 + forKeys:kKeys2 + count:GPBARRAYSIZE(kValues2)]; XCTAssertNotNil(dict2); [dict addEntriesFromDictionary:dict2]; XCTAssertEqual(dict.count, 4U); - XCTAssertTrue([dict valueForKey:21LL value:NULL]); - XCTAssertTrue([dict valueForKey:21LL value:&value]); + XCTAssertTrue([dict getDouble:NULL forKey:21LL]); + XCTAssertTrue([dict getDouble:&value forKey:21LL]); XCTAssertEqual(value, 603.); - XCTAssertTrue([dict valueForKey:22LL value:NULL]); - XCTAssertTrue([dict valueForKey:22LL value:&value]); + XCTAssertTrue([dict getDouble:NULL forKey:22LL]); + XCTAssertTrue([dict getDouble:&value forKey:22LL]); XCTAssertEqual(value, 602.); - XCTAssertTrue([dict valueForKey:23LL value:NULL]); - XCTAssertTrue([dict valueForKey:23LL value:&value]); + XCTAssertTrue([dict getDouble:NULL forKey:23LL]); + XCTAssertTrue([dict getDouble:&value forKey:23LL]); XCTAssertEqual(value, 600.); - XCTAssertTrue([dict valueForKey:24LL value:NULL]); - XCTAssertTrue([dict valueForKey:24LL value:&value]); + XCTAssertTrue([dict getDouble:NULL forKey:24LL]); + XCTAssertTrue([dict getDouble:&value forKey:24LL]); XCTAssertEqual(value, 601.); [dict2 release]; @@ -2593,8 +2593,8 @@ static BOOL TestingEnum_IsValidValue(int32_t value) { GPBInt64EnumDictionary *dict = [[GPBInt64EnumDictionary alloc] init]; XCTAssertNotNil(dict); XCTAssertEqual(dict.count, 0U); - XCTAssertFalse([dict valueForKey:21LL value:NULL]); - [dict enumerateKeysAndValuesUsingBlock:^(int64_t aKey, int32_t aValue, BOOL *stop) { + XCTAssertFalse([dict getEnum:NULL forKey:21LL]); + [dict enumerateKeysAndEnumsUsingBlock:^(int64_t aKey, int32_t aValue, BOOL *stop) { #pragma unused(aKey, aValue, stop) XCTFail(@"Shouldn't get here!"); }]; @@ -2602,15 +2602,15 @@ static BOOL TestingEnum_IsValidValue(int32_t value) { } - (void)testOne { - GPBInt64EnumDictionary *dict = [GPBInt64EnumDictionary dictionaryWithValue:700 forKey:21LL]; + GPBInt64EnumDictionary *dict = [GPBInt64EnumDictionary dictionaryWithEnum:700 forKey:21LL]; XCTAssertNotNil(dict); XCTAssertEqual(dict.count, 1U); int32_t value; - XCTAssertTrue([dict valueForKey:21LL value:NULL]); - XCTAssertTrue([dict valueForKey:21LL value:&value]); + XCTAssertTrue([dict getEnum:NULL forKey:21LL]); + XCTAssertTrue([dict getEnum:&value forKey:21LL]); XCTAssertEqual(value, 700); - XCTAssertFalse([dict valueForKey:22LL value:NULL]); - [dict enumerateKeysAndValuesUsingBlock:^(int64_t aKey, int32_t aValue, BOOL *stop) { + XCTAssertFalse([dict getEnum:NULL forKey:22LL]); + [dict enumerateKeysAndEnumsUsingBlock:^(int64_t aKey, int32_t aValue, BOOL *stop) { XCTAssertEqual(aKey, 21LL); XCTAssertEqual(aValue, 700); XCTAssertNotEqual(stop, NULL); @@ -2621,27 +2621,27 @@ static BOOL TestingEnum_IsValidValue(int32_t value) { const int64_t kKeys[] = { 21LL, 22LL, 23LL }; const int32_t kValues[] = { 700, 701, 702 }; GPBInt64EnumDictionary *dict = - [[GPBInt64EnumDictionary alloc] initWithValues:kValues - forKeys:kKeys - count:GPBARRAYSIZE(kValues)]; + [[GPBInt64EnumDictionary alloc] initWithEnums:kValues + forKeys:kKeys + count:GPBARRAYSIZE(kValues)]; XCTAssertNotNil(dict); XCTAssertEqual(dict.count, 3U); int32_t value; - XCTAssertTrue([dict valueForKey:21LL value:NULL]); - XCTAssertTrue([dict valueForKey:21LL value:&value]); + XCTAssertTrue([dict getEnum:NULL forKey:21LL]); + XCTAssertTrue([dict getEnum:&value forKey:21LL]); XCTAssertEqual(value, 700); - XCTAssertTrue([dict valueForKey:22LL value:NULL]); - XCTAssertTrue([dict valueForKey:22LL value:&value]); + XCTAssertTrue([dict getEnum:NULL forKey:22LL]); + XCTAssertTrue([dict getEnum:&value forKey:22LL]); XCTAssertEqual(value, 701); - XCTAssertTrue([dict valueForKey:23LL value:NULL]); - XCTAssertTrue([dict valueForKey:23LL value:&value]); + XCTAssertTrue([dict getEnum:NULL forKey:23LL]); + XCTAssertTrue([dict getEnum:&value forKey:23LL]); XCTAssertEqual(value, 702); - XCTAssertFalse([dict valueForKey:24LL value:NULL]); + XCTAssertFalse([dict getEnum:NULL forKey:24LL]); __block NSUInteger idx = 0; int64_t *seenKeys = malloc(3 * sizeof(int64_t)); int32_t *seenValues = malloc(3 * sizeof(int32_t)); - [dict enumerateKeysAndValuesUsingBlock:^(int64_t aKey, int32_t aValue, BOOL *stop) { + [dict enumerateKeysAndEnumsUsingBlock:^(int64_t aKey, int32_t aValue, BOOL *stop) { XCTAssertLessThan(idx, 3U); seenKeys[idx] = aKey; seenValues[idx] = aValue; @@ -2663,7 +2663,7 @@ static BOOL TestingEnum_IsValidValue(int32_t value) { // Stopping the enumeration. idx = 0; - [dict enumerateKeysAndValuesUsingBlock:^(int64_t aKey, int32_t aValue, BOOL *stop) { + [dict enumerateKeysAndEnumsUsingBlock:^(int64_t aKey, int32_t aValue, BOOL *stop) { #pragma unused(aKey, aValue) if (idx == 1) *stop = YES; XCTAssertNotEqual(idx, 2U); @@ -2679,29 +2679,29 @@ static BOOL TestingEnum_IsValidValue(int32_t value) { const int32_t kValues2[] = { 700, 703, 702 }; const int32_t kValues3[] = { 700, 701, 702, 703 }; GPBInt64EnumDictionary *dict1 = - [[GPBInt64EnumDictionary alloc] initWithValues:kValues1 - forKeys:kKeys1 - count:GPBARRAYSIZE(kValues1)]; + [[GPBInt64EnumDictionary alloc] initWithEnums:kValues1 + forKeys:kKeys1 + count:GPBARRAYSIZE(kValues1)]; XCTAssertNotNil(dict1); GPBInt64EnumDictionary *dict1prime = - [[GPBInt64EnumDictionary alloc] initWithValues:kValues1 - forKeys:kKeys1 - count:GPBARRAYSIZE(kValues1)]; + [[GPBInt64EnumDictionary alloc] initWithEnums:kValues1 + forKeys:kKeys1 + count:GPBARRAYSIZE(kValues1)]; XCTAssertNotNil(dict1prime); GPBInt64EnumDictionary *dict2 = - [[GPBInt64EnumDictionary alloc] initWithValues:kValues2 - forKeys:kKeys1 - count:GPBARRAYSIZE(kValues2)]; + [[GPBInt64EnumDictionary alloc] initWithEnums:kValues2 + forKeys:kKeys1 + count:GPBARRAYSIZE(kValues2)]; XCTAssertNotNil(dict2); GPBInt64EnumDictionary *dict3 = - [[GPBInt64EnumDictionary alloc] initWithValues:kValues1 - forKeys:kKeys2 - count:GPBARRAYSIZE(kValues1)]; + [[GPBInt64EnumDictionary alloc] initWithEnums:kValues1 + forKeys:kKeys2 + count:GPBARRAYSIZE(kValues1)]; XCTAssertNotNil(dict3); GPBInt64EnumDictionary *dict4 = - [[GPBInt64EnumDictionary alloc] initWithValues:kValues3 - forKeys:kKeys1 - count:GPBARRAYSIZE(kValues3)]; + [[GPBInt64EnumDictionary alloc] initWithEnums:kValues3 + forKeys:kKeys1 + count:GPBARRAYSIZE(kValues3)]; XCTAssertNotNil(dict4); // 1/1Prime should be different objects, but equal. @@ -2730,9 +2730,9 @@ static BOOL TestingEnum_IsValidValue(int32_t value) { const int64_t kKeys[] = { 21LL, 22LL, 23LL, 24LL }; const int32_t kValues[] = { 700, 701, 702, 703 }; GPBInt64EnumDictionary *dict = - [[GPBInt64EnumDictionary alloc] initWithValues:kValues - forKeys:kKeys - count:GPBARRAYSIZE(kValues)]; + [[GPBInt64EnumDictionary alloc] initWithEnums:kValues + forKeys:kKeys + count:GPBARRAYSIZE(kValues)]; XCTAssertNotNil(dict); GPBInt64EnumDictionary *dict2 = [dict copy]; @@ -2751,9 +2751,9 @@ static BOOL TestingEnum_IsValidValue(int32_t value) { const int64_t kKeys[] = { 21LL, 22LL, 23LL, 24LL }; const int32_t kValues[] = { 700, 701, 702, 703 }; GPBInt64EnumDictionary *dict = - [[GPBInt64EnumDictionary alloc] initWithValues:kValues - forKeys:kKeys - count:GPBARRAYSIZE(kValues)]; + [[GPBInt64EnumDictionary alloc] initWithEnums:kValues + forKeys:kKeys + count:GPBARRAYSIZE(kValues)]; XCTAssertNotNil(dict); GPBInt64EnumDictionary *dict2 = @@ -2771,31 +2771,31 @@ static BOOL TestingEnum_IsValidValue(int32_t value) { XCTAssertNotNil(dict); XCTAssertEqual(dict.count, 0U); - [dict setValue:700 forKey:21LL]; + [dict setEnum:700 forKey:21LL]; XCTAssertEqual(dict.count, 1U); const int64_t kKeys[] = { 22LL, 23LL, 24LL }; const int32_t kValues[] = { 701, 702, 703 }; GPBInt64EnumDictionary *dict2 = - [[GPBInt64EnumDictionary alloc] initWithValues:kValues - forKeys:kKeys - count:GPBARRAYSIZE(kValues)]; + [[GPBInt64EnumDictionary alloc] initWithEnums:kValues + forKeys:kKeys + count:GPBARRAYSIZE(kValues)]; XCTAssertNotNil(dict2); [dict addRawEntriesFromDictionary:dict2]; XCTAssertEqual(dict.count, 4U); int32_t value; - XCTAssertTrue([dict valueForKey:21LL value:NULL]); - XCTAssertTrue([dict valueForKey:21LL value:&value]); + XCTAssertTrue([dict getEnum:NULL forKey:21LL]); + XCTAssertTrue([dict getEnum:&value forKey:21LL]); XCTAssertEqual(value, 700); - XCTAssertTrue([dict valueForKey:22LL value:NULL]); - XCTAssertTrue([dict valueForKey:22LL value:&value]); + XCTAssertTrue([dict getEnum:NULL forKey:22LL]); + XCTAssertTrue([dict getEnum:&value forKey:22LL]); XCTAssertEqual(value, 701); - XCTAssertTrue([dict valueForKey:23LL value:NULL]); - XCTAssertTrue([dict valueForKey:23LL value:&value]); + XCTAssertTrue([dict getEnum:NULL forKey:23LL]); + XCTAssertTrue([dict getEnum:&value forKey:23LL]); XCTAssertEqual(value, 702); - XCTAssertTrue([dict valueForKey:24LL value:NULL]); - XCTAssertTrue([dict valueForKey:24LL value:&value]); + XCTAssertTrue([dict getEnum:NULL forKey:24LL]); + XCTAssertTrue([dict getEnum:&value forKey:24LL]); XCTAssertEqual(value, 703); [dict2 release]; } @@ -2804,57 +2804,57 @@ static BOOL TestingEnum_IsValidValue(int32_t value) { const int64_t kKeys[] = { 21LL, 22LL, 23LL, 24LL }; const int32_t kValues[] = { 700, 701, 702, 703 }; GPBInt64EnumDictionary *dict = - [[GPBInt64EnumDictionary alloc] initWithValues:kValues - forKeys:kKeys - count:GPBARRAYSIZE(kValues)]; + [[GPBInt64EnumDictionary alloc] initWithEnums:kValues + forKeys:kKeys + count:GPBARRAYSIZE(kValues)]; XCTAssertNotNil(dict); XCTAssertEqual(dict.count, 4U); - [dict removeValueForKey:22LL]; + [dict removeEnumForKey:22LL]; XCTAssertEqual(dict.count, 3U); int32_t value; - XCTAssertTrue([dict valueForKey:21LL value:NULL]); - XCTAssertTrue([dict valueForKey:21LL value:&value]); + XCTAssertTrue([dict getEnum:NULL forKey:21LL]); + XCTAssertTrue([dict getEnum:&value forKey:21LL]); XCTAssertEqual(value, 700); - XCTAssertFalse([dict valueForKey:22LL value:NULL]); - XCTAssertTrue([dict valueForKey:23LL value:NULL]); - XCTAssertTrue([dict valueForKey:23LL value:&value]); + XCTAssertFalse([dict getEnum:NULL forKey:22LL]); + XCTAssertTrue([dict getEnum:NULL forKey:23LL]); + XCTAssertTrue([dict getEnum:&value forKey:23LL]); XCTAssertEqual(value, 702); - XCTAssertTrue([dict valueForKey:24LL value:NULL]); - XCTAssertTrue([dict valueForKey:24LL value:&value]); + XCTAssertTrue([dict getEnum:NULL forKey:24LL]); + XCTAssertTrue([dict getEnum:&value forKey:24LL]); XCTAssertEqual(value, 703); // Remove again does nothing. - [dict removeValueForKey:22LL]; + [dict removeEnumForKey:22LL]; XCTAssertEqual(dict.count, 3U); - XCTAssertTrue([dict valueForKey:21LL value:NULL]); - XCTAssertTrue([dict valueForKey:21LL value:&value]); + XCTAssertTrue([dict getEnum:NULL forKey:21LL]); + XCTAssertTrue([dict getEnum:&value forKey:21LL]); XCTAssertEqual(value, 700); - XCTAssertFalse([dict valueForKey:22LL value:NULL]); - XCTAssertTrue([dict valueForKey:23LL value:NULL]); - XCTAssertTrue([dict valueForKey:23LL value:&value]); + XCTAssertFalse([dict getEnum:NULL forKey:22LL]); + XCTAssertTrue([dict getEnum:NULL forKey:23LL]); + XCTAssertTrue([dict getEnum:&value forKey:23LL]); XCTAssertEqual(value, 702); - XCTAssertTrue([dict valueForKey:24LL value:NULL]); - XCTAssertTrue([dict valueForKey:24LL value:&value]); + XCTAssertTrue([dict getEnum:NULL forKey:24LL]); + XCTAssertTrue([dict getEnum:&value forKey:24LL]); XCTAssertEqual(value, 703); - [dict removeValueForKey:24LL]; + [dict removeEnumForKey:24LL]; XCTAssertEqual(dict.count, 2U); - XCTAssertTrue([dict valueForKey:21LL value:NULL]); - XCTAssertTrue([dict valueForKey:21LL value:&value]); + XCTAssertTrue([dict getEnum:NULL forKey:21LL]); + XCTAssertTrue([dict getEnum:&value forKey:21LL]); XCTAssertEqual(value, 700); - XCTAssertFalse([dict valueForKey:22LL value:NULL]); - XCTAssertTrue([dict valueForKey:23LL value:NULL]); - XCTAssertTrue([dict valueForKey:23LL value:&value]); + XCTAssertFalse([dict getEnum:NULL forKey:22LL]); + XCTAssertTrue([dict getEnum:NULL forKey:23LL]); + XCTAssertTrue([dict getEnum:&value forKey:23LL]); XCTAssertEqual(value, 702); - XCTAssertFalse([dict valueForKey:24LL value:NULL]); + XCTAssertFalse([dict getEnum:NULL forKey:24LL]); [dict removeAll]; XCTAssertEqual(dict.count, 0U); - XCTAssertFalse([dict valueForKey:21LL value:NULL]); - XCTAssertFalse([dict valueForKey:22LL value:NULL]); - XCTAssertFalse([dict valueForKey:23LL value:NULL]); - XCTAssertFalse([dict valueForKey:24LL value:NULL]); + XCTAssertFalse([dict getEnum:NULL forKey:21LL]); + XCTAssertFalse([dict getEnum:NULL forKey:22LL]); + XCTAssertFalse([dict getEnum:NULL forKey:23LL]); + XCTAssertFalse([dict getEnum:NULL forKey:24LL]); [dict release]; } @@ -2862,75 +2862,75 @@ static BOOL TestingEnum_IsValidValue(int32_t value) { const int64_t kKeys[] = { 21LL, 22LL, 23LL, 24LL }; const int32_t kValues[] = { 700, 701, 702, 703 }; GPBInt64EnumDictionary *dict = - [[GPBInt64EnumDictionary alloc] initWithValues:kValues - forKeys:kKeys - count:GPBARRAYSIZE(kValues)]; + [[GPBInt64EnumDictionary alloc] initWithEnums:kValues + forKeys:kKeys + count:GPBARRAYSIZE(kValues)]; XCTAssertNotNil(dict); XCTAssertEqual(dict.count, 4U); int32_t value; - XCTAssertTrue([dict valueForKey:21LL value:NULL]); - XCTAssertTrue([dict valueForKey:21LL value:&value]); + XCTAssertTrue([dict getEnum:NULL forKey:21LL]); + XCTAssertTrue([dict getEnum:&value forKey:21LL]); XCTAssertEqual(value, 700); - XCTAssertTrue([dict valueForKey:22LL value:NULL]); - XCTAssertTrue([dict valueForKey:22LL value:&value]); + XCTAssertTrue([dict getEnum:NULL forKey:22LL]); + XCTAssertTrue([dict getEnum:&value forKey:22LL]); XCTAssertEqual(value, 701); - XCTAssertTrue([dict valueForKey:23LL value:NULL]); - XCTAssertTrue([dict valueForKey:23LL value:&value]); + XCTAssertTrue([dict getEnum:NULL forKey:23LL]); + XCTAssertTrue([dict getEnum:&value forKey:23LL]); XCTAssertEqual(value, 702); - XCTAssertTrue([dict valueForKey:24LL value:NULL]); - XCTAssertTrue([dict valueForKey:24LL value:&value]); + XCTAssertTrue([dict getEnum:NULL forKey:24LL]); + XCTAssertTrue([dict getEnum:&value forKey:24LL]); XCTAssertEqual(value, 703); - [dict setValue:703 forKey:21LL]; + [dict setEnum:703 forKey:21LL]; XCTAssertEqual(dict.count, 4U); - XCTAssertTrue([dict valueForKey:21LL value:NULL]); - XCTAssertTrue([dict valueForKey:21LL value:&value]); + XCTAssertTrue([dict getEnum:NULL forKey:21LL]); + XCTAssertTrue([dict getEnum:&value forKey:21LL]); XCTAssertEqual(value, 703); - XCTAssertTrue([dict valueForKey:22LL value:NULL]); - XCTAssertTrue([dict valueForKey:22LL value:&value]); + XCTAssertTrue([dict getEnum:NULL forKey:22LL]); + XCTAssertTrue([dict getEnum:&value forKey:22LL]); XCTAssertEqual(value, 701); - XCTAssertTrue([dict valueForKey:23LL value:NULL]); - XCTAssertTrue([dict valueForKey:23LL value:&value]); + XCTAssertTrue([dict getEnum:NULL forKey:23LL]); + XCTAssertTrue([dict getEnum:&value forKey:23LL]); XCTAssertEqual(value, 702); - XCTAssertTrue([dict valueForKey:24LL value:NULL]); - XCTAssertTrue([dict valueForKey:24LL value:&value]); + XCTAssertTrue([dict getEnum:NULL forKey:24LL]); + XCTAssertTrue([dict getEnum:&value forKey:24LL]); XCTAssertEqual(value, 703); - [dict setValue:701 forKey:24LL]; + [dict setEnum:701 forKey:24LL]; XCTAssertEqual(dict.count, 4U); - XCTAssertTrue([dict valueForKey:21LL value:NULL]); - XCTAssertTrue([dict valueForKey:21LL value:&value]); + XCTAssertTrue([dict getEnum:NULL forKey:21LL]); + XCTAssertTrue([dict getEnum:&value forKey:21LL]); XCTAssertEqual(value, 703); - XCTAssertTrue([dict valueForKey:22LL value:NULL]); - XCTAssertTrue([dict valueForKey:22LL value:&value]); + XCTAssertTrue([dict getEnum:NULL forKey:22LL]); + XCTAssertTrue([dict getEnum:&value forKey:22LL]); XCTAssertEqual(value, 701); - XCTAssertTrue([dict valueForKey:23LL value:NULL]); - XCTAssertTrue([dict valueForKey:23LL value:&value]); + XCTAssertTrue([dict getEnum:NULL forKey:23LL]); + XCTAssertTrue([dict getEnum:&value forKey:23LL]); XCTAssertEqual(value, 702); - XCTAssertTrue([dict valueForKey:24LL value:NULL]); - XCTAssertTrue([dict valueForKey:24LL value:&value]); + XCTAssertTrue([dict getEnum:NULL forKey:24LL]); + XCTAssertTrue([dict getEnum:&value forKey:24LL]); XCTAssertEqual(value, 701); const int64_t kKeys2[] = { 22LL, 23LL }; const int32_t kValues2[] = { 702, 700 }; GPBInt64EnumDictionary *dict2 = - [[GPBInt64EnumDictionary alloc] initWithValues:kValues2 - forKeys:kKeys2 - count:GPBARRAYSIZE(kValues2)]; + [[GPBInt64EnumDictionary alloc] initWithEnums:kValues2 + forKeys:kKeys2 + count:GPBARRAYSIZE(kValues2)]; XCTAssertNotNil(dict2); [dict addRawEntriesFromDictionary:dict2]; XCTAssertEqual(dict.count, 4U); - XCTAssertTrue([dict valueForKey:21LL value:NULL]); - XCTAssertTrue([dict valueForKey:21LL value:&value]); + XCTAssertTrue([dict getEnum:NULL forKey:21LL]); + XCTAssertTrue([dict getEnum:&value forKey:21LL]); XCTAssertEqual(value, 703); - XCTAssertTrue([dict valueForKey:22LL value:NULL]); - XCTAssertTrue([dict valueForKey:22LL value:&value]); + XCTAssertTrue([dict getEnum:NULL forKey:22LL]); + XCTAssertTrue([dict getEnum:&value forKey:22LL]); XCTAssertEqual(value, 702); - XCTAssertTrue([dict valueForKey:23LL value:NULL]); - XCTAssertTrue([dict valueForKey:23LL value:&value]); + XCTAssertTrue([dict getEnum:NULL forKey:23LL]); + XCTAssertTrue([dict getEnum:&value forKey:23LL]); XCTAssertEqual(value, 700); - XCTAssertTrue([dict valueForKey:24LL value:NULL]); - XCTAssertTrue([dict valueForKey:24LL value:&value]); + XCTAssertTrue([dict getEnum:NULL forKey:24LL]); + XCTAssertTrue([dict getEnum:&value forKey:24LL]); XCTAssertEqual(value, 701); [dict2 release]; @@ -2958,24 +2958,24 @@ static BOOL TestingEnum_IsValidValue(int32_t value) { XCTAssertEqual(dict.count, 3U); XCTAssertTrue(dict.validationFunc == TestingEnum_IsValidValue); // Pointer comparison int32_t value; - XCTAssertTrue([dict valueForKey:21LL rawValue:NULL]); - XCTAssertTrue([dict valueForKey:21LL rawValue:&value]); + XCTAssertTrue([dict getRawValue:NULL forKey:21LL]); + XCTAssertTrue([dict getRawValue:&value forKey:21LL]); XCTAssertEqual(value, 700); - XCTAssertTrue([dict valueForKey:22LL value:NULL]); - XCTAssertTrue([dict valueForKey:22LL value:&value]); + XCTAssertTrue([dict getEnum:NULL forKey:22LL]); + XCTAssertTrue([dict getEnum:&value forKey:22LL]); XCTAssertEqual(value, kGPBUnrecognizedEnumeratorValue); - XCTAssertTrue([dict valueForKey:22LL rawValue:NULL]); - XCTAssertTrue([dict valueForKey:22LL rawValue:&value]); + XCTAssertTrue([dict getRawValue:NULL forKey:22LL]); + XCTAssertTrue([dict getRawValue:&value forKey:22LL]); XCTAssertEqual(value, 801); - XCTAssertTrue([dict valueForKey:23LL rawValue:NULL]); - XCTAssertTrue([dict valueForKey:23LL rawValue:&value]); + XCTAssertTrue([dict getRawValue:NULL forKey:23LL]); + XCTAssertTrue([dict getRawValue:&value forKey:23LL]); XCTAssertEqual(value, 702); - XCTAssertFalse([dict valueForKey:24LL rawValue:NULL]); + XCTAssertFalse([dict getRawValue:NULL forKey:24LL]); __block NSUInteger idx = 0; int64_t *seenKeys = malloc(3 * sizeof(int64_t)); int32_t *seenValues = malloc(3 * sizeof(int32_t)); - [dict enumerateKeysAndValuesUsingBlock:^(int64_t aKey, int32_t aValue, BOOL *stop) { + [dict enumerateKeysAndEnumsUsingBlock:^(int64_t aKey, int32_t aValue, BOOL *stop) { XCTAssertLessThan(idx, 3U); seenKeys[idx] = aKey; seenValues[idx] = aValue; @@ -3136,7 +3136,7 @@ static BOOL TestingEnum_IsValidValue(int32_t value) { XCTAssertNotNil(dict); XCTAssertEqual(dict.count, 0U); - XCTAssertThrowsSpecificNamed([dict setValue:801 forKey:22LL], // Unknown + XCTAssertThrowsSpecificNamed([dict setEnum:801 forKey:22LL], // Unknown NSException, NSInvalidArgumentException); XCTAssertEqual(dict.count, 0U); [dict setRawValue:801 forKey:22LL]; // Unknown @@ -3145,31 +3145,31 @@ static BOOL TestingEnum_IsValidValue(int32_t value) { const int64_t kKeys[] = { 21LL, 23LL, 24LL }; const int32_t kValues[] = { 700, 702, 803 }; // Unknown GPBInt64EnumDictionary *dict2 = - [[GPBInt64EnumDictionary alloc] initWithValues:kValues - forKeys:kKeys - count:GPBARRAYSIZE(kValues)]; + [[GPBInt64EnumDictionary alloc] initWithEnums:kValues + forKeys:kKeys + count:GPBARRAYSIZE(kValues)]; XCTAssertNotNil(dict2); [dict addRawEntriesFromDictionary:dict2]; XCTAssertEqual(dict.count, 4U); int32_t value; - XCTAssertTrue([dict valueForKey:21LL value:NULL]); - XCTAssertTrue([dict valueForKey:21LL value:&value]); + XCTAssertTrue([dict getEnum:NULL forKey:21LL]); + XCTAssertTrue([dict getEnum:&value forKey:21LL]); XCTAssertEqual(value, 700); - XCTAssertTrue([dict valueForKey:22LL value:NULL]); - XCTAssertTrue([dict valueForKey:22LL value:&value]); + XCTAssertTrue([dict getEnum:NULL forKey:22LL]); + XCTAssertTrue([dict getEnum:&value forKey:22LL]); XCTAssertEqual(value, kGPBUnrecognizedEnumeratorValue); - XCTAssertTrue([dict valueForKey:22LL rawValue:NULL]); - XCTAssertTrue([dict valueForKey:22LL rawValue:&value]); + XCTAssertTrue([dict getRawValue:NULL forKey:22LL]); + XCTAssertTrue([dict getRawValue:&value forKey:22LL]); XCTAssertEqual(value, 801); - XCTAssertTrue([dict valueForKey:23LL value:NULL]); - XCTAssertTrue([dict valueForKey:23LL value:&value]); + XCTAssertTrue([dict getEnum:NULL forKey:23LL]); + XCTAssertTrue([dict getEnum:&value forKey:23LL]); XCTAssertEqual(value, 702); - XCTAssertTrue([dict valueForKey:24LL value:NULL]); - XCTAssertTrue([dict valueForKey:24LL value:&value]); + XCTAssertTrue([dict getEnum:NULL forKey:24LL]); + XCTAssertTrue([dict getEnum:&value forKey:24LL]); XCTAssertEqual(value, kGPBUnrecognizedEnumeratorValue); - XCTAssertTrue([dict valueForKey:24LL rawValue:NULL]); - XCTAssertTrue([dict valueForKey:24LL rawValue:&value]); + XCTAssertTrue([dict getRawValue:NULL forKey:24LL]); + XCTAssertTrue([dict getRawValue:&value forKey:24LL]); XCTAssertEqual(value, 803); [dict2 release]; } @@ -3185,51 +3185,51 @@ static BOOL TestingEnum_IsValidValue(int32_t value) { XCTAssertNotNil(dict); XCTAssertEqual(dict.count, 4U); - [dict removeValueForKey:22LL]; + [dict removeEnumForKey:22LL]; XCTAssertEqual(dict.count, 3U); int32_t value; - XCTAssertTrue([dict valueForKey:21LL value:NULL]); - XCTAssertTrue([dict valueForKey:21LL value:&value]); + XCTAssertTrue([dict getEnum:NULL forKey:21LL]); + XCTAssertTrue([dict getEnum:&value forKey:21LL]); XCTAssertEqual(value, 700); - XCTAssertFalse([dict valueForKey:22LL value:NULL]); - XCTAssertTrue([dict valueForKey:23LL value:NULL]); - XCTAssertTrue([dict valueForKey:23LL value:&value]); + XCTAssertFalse([dict getEnum:NULL forKey:22LL]); + XCTAssertTrue([dict getEnum:NULL forKey:23LL]); + XCTAssertTrue([dict getEnum:&value forKey:23LL]); XCTAssertEqual(value, 702); - XCTAssertTrue([dict valueForKey:24LL rawValue:NULL]); - XCTAssertTrue([dict valueForKey:24LL rawValue:&value]); + XCTAssertTrue([dict getRawValue:NULL forKey:24LL]); + XCTAssertTrue([dict getRawValue:&value forKey:24LL]); XCTAssertEqual(value, 803); // Remove again does nothing. - [dict removeValueForKey:22LL]; + [dict removeEnumForKey:22LL]; XCTAssertEqual(dict.count, 3U); - XCTAssertTrue([dict valueForKey:21LL value:NULL]); - XCTAssertTrue([dict valueForKey:21LL value:&value]); + XCTAssertTrue([dict getEnum:NULL forKey:21LL]); + XCTAssertTrue([dict getEnum:&value forKey:21LL]); XCTAssertEqual(value, 700); - XCTAssertFalse([dict valueForKey:22LL value:NULL]); - XCTAssertTrue([dict valueForKey:23LL value:NULL]); - XCTAssertTrue([dict valueForKey:23LL value:&value]); + XCTAssertFalse([dict getEnum:NULL forKey:22LL]); + XCTAssertTrue([dict getEnum:NULL forKey:23LL]); + XCTAssertTrue([dict getEnum:&value forKey:23LL]); XCTAssertEqual(value, 702); - XCTAssertTrue([dict valueForKey:24LL rawValue:NULL]); - XCTAssertTrue([dict valueForKey:24LL rawValue:&value]); + XCTAssertTrue([dict getRawValue:NULL forKey:24LL]); + XCTAssertTrue([dict getRawValue:&value forKey:24LL]); XCTAssertEqual(value, 803); - [dict removeValueForKey:24LL]; + [dict removeEnumForKey:24LL]; XCTAssertEqual(dict.count, 2U); - XCTAssertTrue([dict valueForKey:21LL value:NULL]); - XCTAssertTrue([dict valueForKey:21LL value:&value]); + XCTAssertTrue([dict getEnum:NULL forKey:21LL]); + XCTAssertTrue([dict getEnum:&value forKey:21LL]); XCTAssertEqual(value, 700); - XCTAssertFalse([dict valueForKey:22LL value:NULL]); - XCTAssertTrue([dict valueForKey:23LL value:NULL]); - XCTAssertTrue([dict valueForKey:23LL value:&value]); + XCTAssertFalse([dict getEnum:NULL forKey:22LL]); + XCTAssertTrue([dict getEnum:NULL forKey:23LL]); + XCTAssertTrue([dict getEnum:&value forKey:23LL]); XCTAssertEqual(value, 702); - XCTAssertFalse([dict valueForKey:24LL value:NULL]); + XCTAssertFalse([dict getEnum:NULL forKey:24LL]); [dict removeAll]; XCTAssertEqual(dict.count, 0U); - XCTAssertFalse([dict valueForKey:21LL value:NULL]); - XCTAssertFalse([dict valueForKey:22LL value:NULL]); - XCTAssertFalse([dict valueForKey:23LL value:NULL]); - XCTAssertFalse([dict valueForKey:24LL value:NULL]); + XCTAssertFalse([dict getEnum:NULL forKey:21LL]); + XCTAssertFalse([dict getEnum:NULL forKey:22LL]); + XCTAssertFalse([dict getEnum:NULL forKey:23LL]); + XCTAssertFalse([dict getEnum:NULL forKey:24LL]); [dict release]; } @@ -3244,63 +3244,63 @@ static BOOL TestingEnum_IsValidValue(int32_t value) { XCTAssertNotNil(dict); XCTAssertEqual(dict.count, 4U); int32_t value; - XCTAssertTrue([dict valueForKey:21LL value:NULL]); - XCTAssertTrue([dict valueForKey:21LL value:&value]); + XCTAssertTrue([dict getEnum:NULL forKey:21LL]); + XCTAssertTrue([dict getEnum:&value forKey:21LL]); XCTAssertEqual(value, 700); - XCTAssertTrue([dict valueForKey:22LL rawValue:NULL]); - XCTAssertTrue([dict valueForKey:22LL rawValue:&value]); + XCTAssertTrue([dict getRawValue:NULL forKey:22LL]); + XCTAssertTrue([dict getRawValue:&value forKey:22LL]); XCTAssertEqual(value, 801); - XCTAssertTrue([dict valueForKey:23LL value:NULL]); - XCTAssertTrue([dict valueForKey:23LL value:&value]); + XCTAssertTrue([dict getEnum:NULL forKey:23LL]); + XCTAssertTrue([dict getEnum:&value forKey:23LL]); XCTAssertEqual(value, 702); - XCTAssertTrue([dict valueForKey:24LL rawValue:NULL]); - XCTAssertTrue([dict valueForKey:24LL rawValue:&value]); + XCTAssertTrue([dict getRawValue:NULL forKey:24LL]); + XCTAssertTrue([dict getRawValue:&value forKey:24LL]); XCTAssertEqual(value, 803); - XCTAssertThrowsSpecificNamed([dict setValue:803 forKey:21LL], // Unknown + XCTAssertThrowsSpecificNamed([dict setEnum:803 forKey:21LL], // Unknown NSException, NSInvalidArgumentException); XCTAssertEqual(dict.count, 4U); - XCTAssertTrue([dict valueForKey:21LL value:NULL]); - XCTAssertTrue([dict valueForKey:21LL value:&value]); + XCTAssertTrue([dict getEnum:NULL forKey:21LL]); + XCTAssertTrue([dict getEnum:&value forKey:21LL]); XCTAssertEqual(value, 700); - XCTAssertTrue([dict valueForKey:22LL rawValue:NULL]); - XCTAssertTrue([dict valueForKey:22LL rawValue:&value]); + XCTAssertTrue([dict getRawValue:NULL forKey:22LL]); + XCTAssertTrue([dict getRawValue:&value forKey:22LL]); XCTAssertEqual(value, 801); - XCTAssertTrue([dict valueForKey:23LL value:NULL]); - XCTAssertTrue([dict valueForKey:23LL value:&value]); + XCTAssertTrue([dict getEnum:NULL forKey:23LL]); + XCTAssertTrue([dict getEnum:&value forKey:23LL]); XCTAssertEqual(value, 702); - XCTAssertTrue([dict valueForKey:24LL rawValue:NULL]); - XCTAssertTrue([dict valueForKey:24LL rawValue:&value]); + XCTAssertTrue([dict getRawValue:NULL forKey:24LL]); + XCTAssertTrue([dict getRawValue:&value forKey:24LL]); XCTAssertEqual(value, 803); [dict setRawValue:803 forKey:21LL]; // Unknown XCTAssertEqual(dict.count, 4U); - XCTAssertTrue([dict valueForKey:21LL rawValue:NULL]); - XCTAssertTrue([dict valueForKey:21LL rawValue:&value]); + XCTAssertTrue([dict getRawValue:NULL forKey:21LL]); + XCTAssertTrue([dict getRawValue:&value forKey:21LL]); XCTAssertEqual(value, 803); - XCTAssertTrue([dict valueForKey:22LL rawValue:NULL]); - XCTAssertTrue([dict valueForKey:22LL rawValue:&value]); + XCTAssertTrue([dict getRawValue:NULL forKey:22LL]); + XCTAssertTrue([dict getRawValue:&value forKey:22LL]); XCTAssertEqual(value, 801); - XCTAssertTrue([dict valueForKey:23LL value:NULL]); - XCTAssertTrue([dict valueForKey:23LL value:&value]); + XCTAssertTrue([dict getEnum:NULL forKey:23LL]); + XCTAssertTrue([dict getEnum:&value forKey:23LL]); XCTAssertEqual(value, 702); - XCTAssertTrue([dict valueForKey:24LL rawValue:NULL]); - XCTAssertTrue([dict valueForKey:24LL rawValue:&value]); + XCTAssertTrue([dict getRawValue:NULL forKey:24LL]); + XCTAssertTrue([dict getRawValue:&value forKey:24LL]); XCTAssertEqual(value, 803); [dict setRawValue:700 forKey:24LL]; XCTAssertEqual(dict.count, 4U); - XCTAssertTrue([dict valueForKey:21LL rawValue:NULL]); - XCTAssertTrue([dict valueForKey:21LL rawValue:&value]); + XCTAssertTrue([dict getRawValue:NULL forKey:21LL]); + XCTAssertTrue([dict getRawValue:&value forKey:21LL]); XCTAssertEqual(value, 803); - XCTAssertTrue([dict valueForKey:22LL rawValue:NULL]); - XCTAssertTrue([dict valueForKey:22LL rawValue:&value]); + XCTAssertTrue([dict getRawValue:NULL forKey:22LL]); + XCTAssertTrue([dict getRawValue:&value forKey:22LL]); XCTAssertEqual(value, 801); - XCTAssertTrue([dict valueForKey:23LL value:NULL]); - XCTAssertTrue([dict valueForKey:23LL value:&value]); + XCTAssertTrue([dict getEnum:NULL forKey:23LL]); + XCTAssertTrue([dict getEnum:&value forKey:23LL]); XCTAssertEqual(value, 702); - XCTAssertTrue([dict valueForKey:24LL value:NULL]); - XCTAssertTrue([dict valueForKey:24LL value:&value]); + XCTAssertTrue([dict getEnum:NULL forKey:24LL]); + XCTAssertTrue([dict getEnum:&value forKey:24LL]); XCTAssertEqual(value, 700); const int64_t kKeys2[] = { 22LL, 23LL }; @@ -3313,17 +3313,17 @@ static BOOL TestingEnum_IsValidValue(int32_t value) { XCTAssertNotNil(dict2); [dict addRawEntriesFromDictionary:dict2]; XCTAssertEqual(dict.count, 4U); - XCTAssertTrue([dict valueForKey:21LL rawValue:NULL]); - XCTAssertTrue([dict valueForKey:21LL rawValue:&value]); + XCTAssertTrue([dict getRawValue:NULL forKey:21LL]); + XCTAssertTrue([dict getRawValue:&value forKey:21LL]); XCTAssertEqual(value, 803); - XCTAssertTrue([dict valueForKey:22LL value:NULL]); - XCTAssertTrue([dict valueForKey:22LL value:&value]); + XCTAssertTrue([dict getEnum:NULL forKey:22LL]); + XCTAssertTrue([dict getEnum:&value forKey:22LL]); XCTAssertEqual(value, 702); - XCTAssertTrue([dict valueForKey:23LL rawValue:NULL]); - XCTAssertTrue([dict valueForKey:23LL rawValue:&value]); + XCTAssertTrue([dict getRawValue:NULL forKey:23LL]); + XCTAssertTrue([dict getRawValue:&value forKey:23LL]); XCTAssertEqual(value, 801); - XCTAssertTrue([dict valueForKey:24LL value:NULL]); - XCTAssertTrue([dict valueForKey:24LL value:&value]); + XCTAssertTrue([dict getEnum:NULL forKey:24LL]); + XCTAssertTrue([dict getEnum:&value forKey:24LL]); XCTAssertEqual(value, 700); [dict2 release]; @@ -3559,8 +3559,8 @@ static BOOL TestingEnum_IsValidValue(int32_t value) { const NSString* kObjects[] = { @"abc", @"def", @"ghi", @"jkl" }; GPBInt64ObjectDictionary *dict = [[GPBInt64ObjectDictionary alloc] initWithObjects:kObjects - forKeys:kKeys - count:GPBARRAYSIZE(kObjects)]; + forKeys:kKeys + count:GPBARRAYSIZE(kObjects)]; XCTAssertNotNil(dict); XCTAssertEqual(dict.count, 4U); @@ -3600,8 +3600,8 @@ static BOOL TestingEnum_IsValidValue(int32_t value) { const NSString* kObjects[] = { @"abc", @"def", @"ghi", @"jkl" }; GPBInt64ObjectDictionary *dict = [[GPBInt64ObjectDictionary alloc] initWithObjects:kObjects - forKeys:kKeys - count:GPBARRAYSIZE(kObjects)]; + forKeys:kKeys + count:GPBARRAYSIZE(kObjects)]; XCTAssertNotNil(dict); XCTAssertEqual(dict.count, 4U); XCTAssertEqualObjects([dict objectForKey:21LL], @"abc"); diff --git a/objectivec/Tests/GPBDictionaryTests+String.m b/objectivec/Tests/GPBDictionaryTests+String.m index bfa10b19..5df1d51d 100644 --- a/objectivec/Tests/GPBDictionaryTests+String.m +++ b/objectivec/Tests/GPBDictionaryTests+String.m @@ -45,10 +45,10 @@ // To let the testing macros work, add some extra methods to simplify things. @interface GPBStringEnumDictionary (TestingTweak) -+ (instancetype)dictionaryWithValue:(int32_t)value forKey:(NSString *)key; -- (instancetype)initWithValues:(const int32_t [])values - forKeys:(const NSString * [])keys - count:(NSUInteger)count; ++ (instancetype)dictionaryWithEnum:(int32_t)value forKey:(NSString *)key; +- (instancetype)initWithEnums:(const int32_t [])values + forKeys:(const NSString * [])keys + count:(NSUInteger)count; @end static BOOL TestingEnum_IsValidValue(int32_t value) { @@ -64,7 +64,7 @@ static BOOL TestingEnum_IsValidValue(int32_t value) { } @implementation GPBStringEnumDictionary (TestingTweak) -+ (instancetype)dictionaryWithValue:(int32_t)value forKey:(NSString *)key { ++ (instancetype)dictionaryWithEnum:(int32_t)value forKey:(NSString *)key { // Cast is needed to compiler knows what class we are invoking initWithValues: on to get the // type correct. return [[(GPBStringEnumDictionary*)[self alloc] initWithValidationFunction:TestingEnum_IsValidValue @@ -72,9 +72,9 @@ static BOOL TestingEnum_IsValidValue(int32_t value) { forKeys:&key count:1] autorelease]; } -- (instancetype)initWithValues:(const int32_t [])values - forKeys:(const NSString * [])keys - count:(NSUInteger)count { +- (instancetype)initWithEnums:(const int32_t [])values + forKeys:(const NSString * [])keys + count:(NSUInteger)count { return [self initWithValidationFunction:TestingEnum_IsValidValue rawValues:values forKeys:keys @@ -94,8 +94,8 @@ static BOOL TestingEnum_IsValidValue(int32_t value) { GPBStringUInt32Dictionary *dict = [[GPBStringUInt32Dictionary alloc] init]; XCTAssertNotNil(dict); XCTAssertEqual(dict.count, 0U); - XCTAssertFalse([dict valueForKey:@"foo" value:NULL]); - [dict enumerateKeysAndValuesUsingBlock:^(NSString *aKey, uint32_t aValue, BOOL *stop) { + XCTAssertFalse([dict getUInt32:NULL forKey:@"foo"]); + [dict enumerateKeysAndUInt32sUsingBlock:^(NSString *aKey, uint32_t aValue, BOOL *stop) { #pragma unused(aKey, aValue, stop) XCTFail(@"Shouldn't get here!"); }]; @@ -103,15 +103,15 @@ static BOOL TestingEnum_IsValidValue(int32_t value) { } - (void)testOne { - GPBStringUInt32Dictionary *dict = [GPBStringUInt32Dictionary dictionaryWithValue:100U forKey:@"foo"]; + GPBStringUInt32Dictionary *dict = [GPBStringUInt32Dictionary dictionaryWithUInt32:100U forKey:@"foo"]; XCTAssertNotNil(dict); XCTAssertEqual(dict.count, 1U); uint32_t value; - XCTAssertTrue([dict valueForKey:@"foo" value:NULL]); - XCTAssertTrue([dict valueForKey:@"foo" value:&value]); + XCTAssertTrue([dict getUInt32:NULL forKey:@"foo"]); + XCTAssertTrue([dict getUInt32:&value forKey:@"foo"]); XCTAssertEqual(value, 100U); - XCTAssertFalse([dict valueForKey:@"bar" value:NULL]); - [dict enumerateKeysAndValuesUsingBlock:^(NSString *aKey, uint32_t aValue, BOOL *stop) { + XCTAssertFalse([dict getUInt32:NULL forKey:@"bar"]); + [dict enumerateKeysAndUInt32sUsingBlock:^(NSString *aKey, uint32_t aValue, BOOL *stop) { XCTAssertEqualObjects(aKey, @"foo"); XCTAssertEqual(aValue, 100U); XCTAssertNotEqual(stop, NULL); @@ -122,27 +122,27 @@ static BOOL TestingEnum_IsValidValue(int32_t value) { const NSString *kKeys[] = { @"foo", @"bar", @"baz" }; const uint32_t kValues[] = { 100U, 101U, 102U }; GPBStringUInt32Dictionary *dict = - [[GPBStringUInt32Dictionary alloc] initWithValues:kValues - forKeys:kKeys - count:GPBARRAYSIZE(kValues)]; + [[GPBStringUInt32Dictionary alloc] initWithUInt32s:kValues + forKeys:kKeys + count:GPBARRAYSIZE(kValues)]; XCTAssertNotNil(dict); XCTAssertEqual(dict.count, 3U); uint32_t value; - XCTAssertTrue([dict valueForKey:@"foo" value:NULL]); - XCTAssertTrue([dict valueForKey:@"foo" value:&value]); + XCTAssertTrue([dict getUInt32:NULL forKey:@"foo"]); + XCTAssertTrue([dict getUInt32:&value forKey:@"foo"]); XCTAssertEqual(value, 100U); - XCTAssertTrue([dict valueForKey:@"bar" value:NULL]); - XCTAssertTrue([dict valueForKey:@"bar" value:&value]); + XCTAssertTrue([dict getUInt32:NULL forKey:@"bar"]); + XCTAssertTrue([dict getUInt32:&value forKey:@"bar"]); XCTAssertEqual(value, 101U); - XCTAssertTrue([dict valueForKey:@"baz" value:NULL]); - XCTAssertTrue([dict valueForKey:@"baz" value:&value]); + XCTAssertTrue([dict getUInt32:NULL forKey:@"baz"]); + XCTAssertTrue([dict getUInt32:&value forKey:@"baz"]); XCTAssertEqual(value, 102U); - XCTAssertFalse([dict valueForKey:@"mumble" value:NULL]); + XCTAssertFalse([dict getUInt32:NULL forKey:@"mumble"]); __block NSUInteger idx = 0; NSString **seenKeys = malloc(3 * sizeof(NSString*)); uint32_t *seenValues = malloc(3 * sizeof(uint32_t)); - [dict enumerateKeysAndValuesUsingBlock:^(NSString *aKey, uint32_t aValue, BOOL *stop) { + [dict enumerateKeysAndUInt32sUsingBlock:^(NSString *aKey, uint32_t aValue, BOOL *stop) { XCTAssertLessThan(idx, 3U); seenKeys[idx] = aKey; seenValues[idx] = aValue; @@ -164,7 +164,7 @@ static BOOL TestingEnum_IsValidValue(int32_t value) { // Stopping the enumeration. idx = 0; - [dict enumerateKeysAndValuesUsingBlock:^(NSString *aKey, uint32_t aValue, BOOL *stop) { + [dict enumerateKeysAndUInt32sUsingBlock:^(NSString *aKey, uint32_t aValue, BOOL *stop) { #pragma unused(aKey, aValue) if (idx == 1) *stop = YES; XCTAssertNotEqual(idx, 2U); @@ -180,29 +180,29 @@ static BOOL TestingEnum_IsValidValue(int32_t value) { const uint32_t kValues2[] = { 100U, 103U, 102U }; const uint32_t kValues3[] = { 100U, 101U, 102U, 103U }; GPBStringUInt32Dictionary *dict1 = - [[GPBStringUInt32Dictionary alloc] initWithValues:kValues1 - forKeys:kKeys1 - count:GPBARRAYSIZE(kValues1)]; + [[GPBStringUInt32Dictionary alloc] initWithUInt32s:kValues1 + forKeys:kKeys1 + count:GPBARRAYSIZE(kValues1)]; XCTAssertNotNil(dict1); GPBStringUInt32Dictionary *dict1prime = - [[GPBStringUInt32Dictionary alloc] initWithValues:kValues1 - forKeys:kKeys1 - count:GPBARRAYSIZE(kValues1)]; + [[GPBStringUInt32Dictionary alloc] initWithUInt32s:kValues1 + forKeys:kKeys1 + count:GPBARRAYSIZE(kValues1)]; XCTAssertNotNil(dict1prime); GPBStringUInt32Dictionary *dict2 = - [[GPBStringUInt32Dictionary alloc] initWithValues:kValues2 - forKeys:kKeys1 - count:GPBARRAYSIZE(kValues2)]; + [[GPBStringUInt32Dictionary alloc] initWithUInt32s:kValues2 + forKeys:kKeys1 + count:GPBARRAYSIZE(kValues2)]; XCTAssertNotNil(dict2); GPBStringUInt32Dictionary *dict3 = - [[GPBStringUInt32Dictionary alloc] initWithValues:kValues1 - forKeys:kKeys2 - count:GPBARRAYSIZE(kValues1)]; + [[GPBStringUInt32Dictionary alloc] initWithUInt32s:kValues1 + forKeys:kKeys2 + count:GPBARRAYSIZE(kValues1)]; XCTAssertNotNil(dict3); GPBStringUInt32Dictionary *dict4 = - [[GPBStringUInt32Dictionary alloc] initWithValues:kValues3 - forKeys:kKeys1 - count:GPBARRAYSIZE(kValues3)]; + [[GPBStringUInt32Dictionary alloc] initWithUInt32s:kValues3 + forKeys:kKeys1 + count:GPBARRAYSIZE(kValues3)]; XCTAssertNotNil(dict4); // 1/1Prime should be different objects, but equal. @@ -231,9 +231,9 @@ static BOOL TestingEnum_IsValidValue(int32_t value) { const NSString *kKeys[] = { @"foo", @"bar", @"baz", @"mumble" }; const uint32_t kValues[] = { 100U, 101U, 102U, 103U }; GPBStringUInt32Dictionary *dict = - [[GPBStringUInt32Dictionary alloc] initWithValues:kValues - forKeys:kKeys - count:GPBARRAYSIZE(kValues)]; + [[GPBStringUInt32Dictionary alloc] initWithUInt32s:kValues + forKeys:kKeys + count:GPBARRAYSIZE(kValues)]; XCTAssertNotNil(dict); GPBStringUInt32Dictionary *dict2 = [dict copy]; @@ -252,9 +252,9 @@ static BOOL TestingEnum_IsValidValue(int32_t value) { const NSString *kKeys[] = { @"foo", @"bar", @"baz", @"mumble" }; const uint32_t kValues[] = { 100U, 101U, 102U, 103U }; GPBStringUInt32Dictionary *dict = - [[GPBStringUInt32Dictionary alloc] initWithValues:kValues - forKeys:kKeys - count:GPBARRAYSIZE(kValues)]; + [[GPBStringUInt32Dictionary alloc] initWithUInt32s:kValues + forKeys:kKeys + count:GPBARRAYSIZE(kValues)]; XCTAssertNotNil(dict); GPBStringUInt32Dictionary *dict2 = @@ -272,31 +272,31 @@ static BOOL TestingEnum_IsValidValue(int32_t value) { XCTAssertNotNil(dict); XCTAssertEqual(dict.count, 0U); - [dict setValue:100U forKey:@"foo"]; + [dict setUInt32:100U forKey:@"foo"]; XCTAssertEqual(dict.count, 1U); const NSString *kKeys[] = { @"bar", @"baz", @"mumble" }; const uint32_t kValues[] = { 101U, 102U, 103U }; GPBStringUInt32Dictionary *dict2 = - [[GPBStringUInt32Dictionary alloc] initWithValues:kValues - forKeys:kKeys - count:GPBARRAYSIZE(kValues)]; + [[GPBStringUInt32Dictionary alloc] initWithUInt32s:kValues + forKeys:kKeys + count:GPBARRAYSIZE(kValues)]; XCTAssertNotNil(dict2); [dict addEntriesFromDictionary:dict2]; XCTAssertEqual(dict.count, 4U); uint32_t value; - XCTAssertTrue([dict valueForKey:@"foo" value:NULL]); - XCTAssertTrue([dict valueForKey:@"foo" value:&value]); + XCTAssertTrue([dict getUInt32:NULL forKey:@"foo"]); + XCTAssertTrue([dict getUInt32:&value forKey:@"foo"]); XCTAssertEqual(value, 100U); - XCTAssertTrue([dict valueForKey:@"bar" value:NULL]); - XCTAssertTrue([dict valueForKey:@"bar" value:&value]); + XCTAssertTrue([dict getUInt32:NULL forKey:@"bar"]); + XCTAssertTrue([dict getUInt32:&value forKey:@"bar"]); XCTAssertEqual(value, 101U); - XCTAssertTrue([dict valueForKey:@"baz" value:NULL]); - XCTAssertTrue([dict valueForKey:@"baz" value:&value]); + XCTAssertTrue([dict getUInt32:NULL forKey:@"baz"]); + XCTAssertTrue([dict getUInt32:&value forKey:@"baz"]); XCTAssertEqual(value, 102U); - XCTAssertTrue([dict valueForKey:@"mumble" value:NULL]); - XCTAssertTrue([dict valueForKey:@"mumble" value:&value]); + XCTAssertTrue([dict getUInt32:NULL forKey:@"mumble"]); + XCTAssertTrue([dict getUInt32:&value forKey:@"mumble"]); XCTAssertEqual(value, 103U); [dict2 release]; } @@ -305,57 +305,57 @@ static BOOL TestingEnum_IsValidValue(int32_t value) { const NSString *kKeys[] = { @"foo", @"bar", @"baz", @"mumble" }; const uint32_t kValues[] = { 100U, 101U, 102U, 103U }; GPBStringUInt32Dictionary *dict = - [[GPBStringUInt32Dictionary alloc] initWithValues:kValues - forKeys:kKeys - count:GPBARRAYSIZE(kValues)]; + [[GPBStringUInt32Dictionary alloc] initWithUInt32s:kValues + forKeys:kKeys + count:GPBARRAYSIZE(kValues)]; XCTAssertNotNil(dict); XCTAssertEqual(dict.count, 4U); - [dict removeValueForKey:@"bar"]; + [dict removeUInt32ForKey:@"bar"]; XCTAssertEqual(dict.count, 3U); uint32_t value; - XCTAssertTrue([dict valueForKey:@"foo" value:NULL]); - XCTAssertTrue([dict valueForKey:@"foo" value:&value]); + XCTAssertTrue([dict getUInt32:NULL forKey:@"foo"]); + XCTAssertTrue([dict getUInt32:&value forKey:@"foo"]); XCTAssertEqual(value, 100U); - XCTAssertFalse([dict valueForKey:@"bar" value:NULL]); - XCTAssertTrue([dict valueForKey:@"baz" value:NULL]); - XCTAssertTrue([dict valueForKey:@"baz" value:&value]); + XCTAssertFalse([dict getUInt32:NULL forKey:@"bar"]); + XCTAssertTrue([dict getUInt32:NULL forKey:@"baz"]); + XCTAssertTrue([dict getUInt32:&value forKey:@"baz"]); XCTAssertEqual(value, 102U); - XCTAssertTrue([dict valueForKey:@"mumble" value:NULL]); - XCTAssertTrue([dict valueForKey:@"mumble" value:&value]); + XCTAssertTrue([dict getUInt32:NULL forKey:@"mumble"]); + XCTAssertTrue([dict getUInt32:&value forKey:@"mumble"]); XCTAssertEqual(value, 103U); // Remove again does nothing. - [dict removeValueForKey:@"bar"]; + [dict removeUInt32ForKey:@"bar"]; XCTAssertEqual(dict.count, 3U); - XCTAssertTrue([dict valueForKey:@"foo" value:NULL]); - XCTAssertTrue([dict valueForKey:@"foo" value:&value]); + XCTAssertTrue([dict getUInt32:NULL forKey:@"foo"]); + XCTAssertTrue([dict getUInt32:&value forKey:@"foo"]); XCTAssertEqual(value, 100U); - XCTAssertFalse([dict valueForKey:@"bar" value:NULL]); - XCTAssertTrue([dict valueForKey:@"baz" value:NULL]); - XCTAssertTrue([dict valueForKey:@"baz" value:&value]); + XCTAssertFalse([dict getUInt32:NULL forKey:@"bar"]); + XCTAssertTrue([dict getUInt32:NULL forKey:@"baz"]); + XCTAssertTrue([dict getUInt32:&value forKey:@"baz"]); XCTAssertEqual(value, 102U); - XCTAssertTrue([dict valueForKey:@"mumble" value:NULL]); - XCTAssertTrue([dict valueForKey:@"mumble" value:&value]); + XCTAssertTrue([dict getUInt32:NULL forKey:@"mumble"]); + XCTAssertTrue([dict getUInt32:&value forKey:@"mumble"]); XCTAssertEqual(value, 103U); - [dict removeValueForKey:@"mumble"]; + [dict removeUInt32ForKey:@"mumble"]; XCTAssertEqual(dict.count, 2U); - XCTAssertTrue([dict valueForKey:@"foo" value:NULL]); - XCTAssertTrue([dict valueForKey:@"foo" value:&value]); + XCTAssertTrue([dict getUInt32:NULL forKey:@"foo"]); + XCTAssertTrue([dict getUInt32:&value forKey:@"foo"]); XCTAssertEqual(value, 100U); - XCTAssertFalse([dict valueForKey:@"bar" value:NULL]); - XCTAssertTrue([dict valueForKey:@"baz" value:NULL]); - XCTAssertTrue([dict valueForKey:@"baz" value:&value]); + XCTAssertFalse([dict getUInt32:NULL forKey:@"bar"]); + XCTAssertTrue([dict getUInt32:NULL forKey:@"baz"]); + XCTAssertTrue([dict getUInt32:&value forKey:@"baz"]); XCTAssertEqual(value, 102U); - XCTAssertFalse([dict valueForKey:@"mumble" value:NULL]); + XCTAssertFalse([dict getUInt32:NULL forKey:@"mumble"]); [dict removeAll]; XCTAssertEqual(dict.count, 0U); - XCTAssertFalse([dict valueForKey:@"foo" value:NULL]); - XCTAssertFalse([dict valueForKey:@"bar" value:NULL]); - XCTAssertFalse([dict valueForKey:@"baz" value:NULL]); - XCTAssertFalse([dict valueForKey:@"mumble" value:NULL]); + XCTAssertFalse([dict getUInt32:NULL forKey:@"foo"]); + XCTAssertFalse([dict getUInt32:NULL forKey:@"bar"]); + XCTAssertFalse([dict getUInt32:NULL forKey:@"baz"]); + XCTAssertFalse([dict getUInt32:NULL forKey:@"mumble"]); [dict release]; } @@ -363,75 +363,75 @@ static BOOL TestingEnum_IsValidValue(int32_t value) { const NSString *kKeys[] = { @"foo", @"bar", @"baz", @"mumble" }; const uint32_t kValues[] = { 100U, 101U, 102U, 103U }; GPBStringUInt32Dictionary *dict = - [[GPBStringUInt32Dictionary alloc] initWithValues:kValues - forKeys:kKeys - count:GPBARRAYSIZE(kValues)]; + [[GPBStringUInt32Dictionary alloc] initWithUInt32s:kValues + forKeys:kKeys + count:GPBARRAYSIZE(kValues)]; XCTAssertNotNil(dict); XCTAssertEqual(dict.count, 4U); uint32_t value; - XCTAssertTrue([dict valueForKey:@"foo" value:NULL]); - XCTAssertTrue([dict valueForKey:@"foo" value:&value]); + XCTAssertTrue([dict getUInt32:NULL forKey:@"foo"]); + XCTAssertTrue([dict getUInt32:&value forKey:@"foo"]); XCTAssertEqual(value, 100U); - XCTAssertTrue([dict valueForKey:@"bar" value:NULL]); - XCTAssertTrue([dict valueForKey:@"bar" value:&value]); + XCTAssertTrue([dict getUInt32:NULL forKey:@"bar"]); + XCTAssertTrue([dict getUInt32:&value forKey:@"bar"]); XCTAssertEqual(value, 101U); - XCTAssertTrue([dict valueForKey:@"baz" value:NULL]); - XCTAssertTrue([dict valueForKey:@"baz" value:&value]); + XCTAssertTrue([dict getUInt32:NULL forKey:@"baz"]); + XCTAssertTrue([dict getUInt32:&value forKey:@"baz"]); XCTAssertEqual(value, 102U); - XCTAssertTrue([dict valueForKey:@"mumble" value:NULL]); - XCTAssertTrue([dict valueForKey:@"mumble" value:&value]); + XCTAssertTrue([dict getUInt32:NULL forKey:@"mumble"]); + XCTAssertTrue([dict getUInt32:&value forKey:@"mumble"]); XCTAssertEqual(value, 103U); - [dict setValue:103U forKey:@"foo"]; + [dict setUInt32:103U forKey:@"foo"]; XCTAssertEqual(dict.count, 4U); - XCTAssertTrue([dict valueForKey:@"foo" value:NULL]); - XCTAssertTrue([dict valueForKey:@"foo" value:&value]); + XCTAssertTrue([dict getUInt32:NULL forKey:@"foo"]); + XCTAssertTrue([dict getUInt32:&value forKey:@"foo"]); XCTAssertEqual(value, 103U); - XCTAssertTrue([dict valueForKey:@"bar" value:NULL]); - XCTAssertTrue([dict valueForKey:@"bar" value:&value]); + XCTAssertTrue([dict getUInt32:NULL forKey:@"bar"]); + XCTAssertTrue([dict getUInt32:&value forKey:@"bar"]); XCTAssertEqual(value, 101U); - XCTAssertTrue([dict valueForKey:@"baz" value:NULL]); - XCTAssertTrue([dict valueForKey:@"baz" value:&value]); + XCTAssertTrue([dict getUInt32:NULL forKey:@"baz"]); + XCTAssertTrue([dict getUInt32:&value forKey:@"baz"]); XCTAssertEqual(value, 102U); - XCTAssertTrue([dict valueForKey:@"mumble" value:NULL]); - XCTAssertTrue([dict valueForKey:@"mumble" value:&value]); + XCTAssertTrue([dict getUInt32:NULL forKey:@"mumble"]); + XCTAssertTrue([dict getUInt32:&value forKey:@"mumble"]); XCTAssertEqual(value, 103U); - [dict setValue:101U forKey:@"mumble"]; + [dict setUInt32:101U forKey:@"mumble"]; XCTAssertEqual(dict.count, 4U); - XCTAssertTrue([dict valueForKey:@"foo" value:NULL]); - XCTAssertTrue([dict valueForKey:@"foo" value:&value]); + XCTAssertTrue([dict getUInt32:NULL forKey:@"foo"]); + XCTAssertTrue([dict getUInt32:&value forKey:@"foo"]); XCTAssertEqual(value, 103U); - XCTAssertTrue([dict valueForKey:@"bar" value:NULL]); - XCTAssertTrue([dict valueForKey:@"bar" value:&value]); + XCTAssertTrue([dict getUInt32:NULL forKey:@"bar"]); + XCTAssertTrue([dict getUInt32:&value forKey:@"bar"]); XCTAssertEqual(value, 101U); - XCTAssertTrue([dict valueForKey:@"baz" value:NULL]); - XCTAssertTrue([dict valueForKey:@"baz" value:&value]); + XCTAssertTrue([dict getUInt32:NULL forKey:@"baz"]); + XCTAssertTrue([dict getUInt32:&value forKey:@"baz"]); XCTAssertEqual(value, 102U); - XCTAssertTrue([dict valueForKey:@"mumble" value:NULL]); - XCTAssertTrue([dict valueForKey:@"mumble" value:&value]); + XCTAssertTrue([dict getUInt32:NULL forKey:@"mumble"]); + XCTAssertTrue([dict getUInt32:&value forKey:@"mumble"]); XCTAssertEqual(value, 101U); const NSString *kKeys2[] = { @"bar", @"baz" }; const uint32_t kValues2[] = { 102U, 100U }; GPBStringUInt32Dictionary *dict2 = - [[GPBStringUInt32Dictionary alloc] initWithValues:kValues2 - forKeys:kKeys2 - count:GPBARRAYSIZE(kValues2)]; + [[GPBStringUInt32Dictionary alloc] initWithUInt32s:kValues2 + forKeys:kKeys2 + count:GPBARRAYSIZE(kValues2)]; XCTAssertNotNil(dict2); [dict addEntriesFromDictionary:dict2]; XCTAssertEqual(dict.count, 4U); - XCTAssertTrue([dict valueForKey:@"foo" value:NULL]); - XCTAssertTrue([dict valueForKey:@"foo" value:&value]); + XCTAssertTrue([dict getUInt32:NULL forKey:@"foo"]); + XCTAssertTrue([dict getUInt32:&value forKey:@"foo"]); XCTAssertEqual(value, 103U); - XCTAssertTrue([dict valueForKey:@"bar" value:NULL]); - XCTAssertTrue([dict valueForKey:@"bar" value:&value]); + XCTAssertTrue([dict getUInt32:NULL forKey:@"bar"]); + XCTAssertTrue([dict getUInt32:&value forKey:@"bar"]); XCTAssertEqual(value, 102U); - XCTAssertTrue([dict valueForKey:@"baz" value:NULL]); - XCTAssertTrue([dict valueForKey:@"baz" value:&value]); + XCTAssertTrue([dict getUInt32:NULL forKey:@"baz"]); + XCTAssertTrue([dict getUInt32:&value forKey:@"baz"]); XCTAssertEqual(value, 100U); - XCTAssertTrue([dict valueForKey:@"mumble" value:NULL]); - XCTAssertTrue([dict valueForKey:@"mumble" value:&value]); + XCTAssertTrue([dict getUInt32:NULL forKey:@"mumble"]); + XCTAssertTrue([dict getUInt32:&value forKey:@"mumble"]); XCTAssertEqual(value, 101U); [dict2 release]; @@ -451,8 +451,8 @@ static BOOL TestingEnum_IsValidValue(int32_t value) { GPBStringInt32Dictionary *dict = [[GPBStringInt32Dictionary alloc] init]; XCTAssertNotNil(dict); XCTAssertEqual(dict.count, 0U); - XCTAssertFalse([dict valueForKey:@"foo" value:NULL]); - [dict enumerateKeysAndValuesUsingBlock:^(NSString *aKey, int32_t aValue, BOOL *stop) { + XCTAssertFalse([dict getInt32:NULL forKey:@"foo"]); + [dict enumerateKeysAndInt32sUsingBlock:^(NSString *aKey, int32_t aValue, BOOL *stop) { #pragma unused(aKey, aValue, stop) XCTFail(@"Shouldn't get here!"); }]; @@ -460,15 +460,15 @@ static BOOL TestingEnum_IsValidValue(int32_t value) { } - (void)testOne { - GPBStringInt32Dictionary *dict = [GPBStringInt32Dictionary dictionaryWithValue:200 forKey:@"foo"]; + GPBStringInt32Dictionary *dict = [GPBStringInt32Dictionary dictionaryWithInt32:200 forKey:@"foo"]; XCTAssertNotNil(dict); XCTAssertEqual(dict.count, 1U); int32_t value; - XCTAssertTrue([dict valueForKey:@"foo" value:NULL]); - XCTAssertTrue([dict valueForKey:@"foo" value:&value]); + XCTAssertTrue([dict getInt32:NULL forKey:@"foo"]); + XCTAssertTrue([dict getInt32:&value forKey:@"foo"]); XCTAssertEqual(value, 200); - XCTAssertFalse([dict valueForKey:@"bar" value:NULL]); - [dict enumerateKeysAndValuesUsingBlock:^(NSString *aKey, int32_t aValue, BOOL *stop) { + XCTAssertFalse([dict getInt32:NULL forKey:@"bar"]); + [dict enumerateKeysAndInt32sUsingBlock:^(NSString *aKey, int32_t aValue, BOOL *stop) { XCTAssertEqualObjects(aKey, @"foo"); XCTAssertEqual(aValue, 200); XCTAssertNotEqual(stop, NULL); @@ -479,27 +479,27 @@ static BOOL TestingEnum_IsValidValue(int32_t value) { const NSString *kKeys[] = { @"foo", @"bar", @"baz" }; const int32_t kValues[] = { 200, 201, 202 }; GPBStringInt32Dictionary *dict = - [[GPBStringInt32Dictionary alloc] initWithValues:kValues + [[GPBStringInt32Dictionary alloc] initWithInt32s:kValues forKeys:kKeys count:GPBARRAYSIZE(kValues)]; XCTAssertNotNil(dict); XCTAssertEqual(dict.count, 3U); int32_t value; - XCTAssertTrue([dict valueForKey:@"foo" value:NULL]); - XCTAssertTrue([dict valueForKey:@"foo" value:&value]); + XCTAssertTrue([dict getInt32:NULL forKey:@"foo"]); + XCTAssertTrue([dict getInt32:&value forKey:@"foo"]); XCTAssertEqual(value, 200); - XCTAssertTrue([dict valueForKey:@"bar" value:NULL]); - XCTAssertTrue([dict valueForKey:@"bar" value:&value]); + XCTAssertTrue([dict getInt32:NULL forKey:@"bar"]); + XCTAssertTrue([dict getInt32:&value forKey:@"bar"]); XCTAssertEqual(value, 201); - XCTAssertTrue([dict valueForKey:@"baz" value:NULL]); - XCTAssertTrue([dict valueForKey:@"baz" value:&value]); + XCTAssertTrue([dict getInt32:NULL forKey:@"baz"]); + XCTAssertTrue([dict getInt32:&value forKey:@"baz"]); XCTAssertEqual(value, 202); - XCTAssertFalse([dict valueForKey:@"mumble" value:NULL]); + XCTAssertFalse([dict getInt32:NULL forKey:@"mumble"]); __block NSUInteger idx = 0; NSString **seenKeys = malloc(3 * sizeof(NSString*)); int32_t *seenValues = malloc(3 * sizeof(int32_t)); - [dict enumerateKeysAndValuesUsingBlock:^(NSString *aKey, int32_t aValue, BOOL *stop) { + [dict enumerateKeysAndInt32sUsingBlock:^(NSString *aKey, int32_t aValue, BOOL *stop) { XCTAssertLessThan(idx, 3U); seenKeys[idx] = aKey; seenValues[idx] = aValue; @@ -521,7 +521,7 @@ static BOOL TestingEnum_IsValidValue(int32_t value) { // Stopping the enumeration. idx = 0; - [dict enumerateKeysAndValuesUsingBlock:^(NSString *aKey, int32_t aValue, BOOL *stop) { + [dict enumerateKeysAndInt32sUsingBlock:^(NSString *aKey, int32_t aValue, BOOL *stop) { #pragma unused(aKey, aValue) if (idx == 1) *stop = YES; XCTAssertNotEqual(idx, 2U); @@ -537,27 +537,27 @@ static BOOL TestingEnum_IsValidValue(int32_t value) { const int32_t kValues2[] = { 200, 203, 202 }; const int32_t kValues3[] = { 200, 201, 202, 203 }; GPBStringInt32Dictionary *dict1 = - [[GPBStringInt32Dictionary alloc] initWithValues:kValues1 + [[GPBStringInt32Dictionary alloc] initWithInt32s:kValues1 forKeys:kKeys1 count:GPBARRAYSIZE(kValues1)]; XCTAssertNotNil(dict1); GPBStringInt32Dictionary *dict1prime = - [[GPBStringInt32Dictionary alloc] initWithValues:kValues1 + [[GPBStringInt32Dictionary alloc] initWithInt32s:kValues1 forKeys:kKeys1 count:GPBARRAYSIZE(kValues1)]; XCTAssertNotNil(dict1prime); GPBStringInt32Dictionary *dict2 = - [[GPBStringInt32Dictionary alloc] initWithValues:kValues2 + [[GPBStringInt32Dictionary alloc] initWithInt32s:kValues2 forKeys:kKeys1 count:GPBARRAYSIZE(kValues2)]; XCTAssertNotNil(dict2); GPBStringInt32Dictionary *dict3 = - [[GPBStringInt32Dictionary alloc] initWithValues:kValues1 + [[GPBStringInt32Dictionary alloc] initWithInt32s:kValues1 forKeys:kKeys2 count:GPBARRAYSIZE(kValues1)]; XCTAssertNotNil(dict3); GPBStringInt32Dictionary *dict4 = - [[GPBStringInt32Dictionary alloc] initWithValues:kValues3 + [[GPBStringInt32Dictionary alloc] initWithInt32s:kValues3 forKeys:kKeys1 count:GPBARRAYSIZE(kValues3)]; XCTAssertNotNil(dict4); @@ -588,7 +588,7 @@ static BOOL TestingEnum_IsValidValue(int32_t value) { const NSString *kKeys[] = { @"foo", @"bar", @"baz", @"mumble" }; const int32_t kValues[] = { 200, 201, 202, 203 }; GPBStringInt32Dictionary *dict = - [[GPBStringInt32Dictionary alloc] initWithValues:kValues + [[GPBStringInt32Dictionary alloc] initWithInt32s:kValues forKeys:kKeys count:GPBARRAYSIZE(kValues)]; XCTAssertNotNil(dict); @@ -609,7 +609,7 @@ static BOOL TestingEnum_IsValidValue(int32_t value) { const NSString *kKeys[] = { @"foo", @"bar", @"baz", @"mumble" }; const int32_t kValues[] = { 200, 201, 202, 203 }; GPBStringInt32Dictionary *dict = - [[GPBStringInt32Dictionary alloc] initWithValues:kValues + [[GPBStringInt32Dictionary alloc] initWithInt32s:kValues forKeys:kKeys count:GPBARRAYSIZE(kValues)]; XCTAssertNotNil(dict); @@ -629,13 +629,13 @@ static BOOL TestingEnum_IsValidValue(int32_t value) { XCTAssertNotNil(dict); XCTAssertEqual(dict.count, 0U); - [dict setValue:200 forKey:@"foo"]; + [dict setInt32:200 forKey:@"foo"]; XCTAssertEqual(dict.count, 1U); const NSString *kKeys[] = { @"bar", @"baz", @"mumble" }; const int32_t kValues[] = { 201, 202, 203 }; GPBStringInt32Dictionary *dict2 = - [[GPBStringInt32Dictionary alloc] initWithValues:kValues + [[GPBStringInt32Dictionary alloc] initWithInt32s:kValues forKeys:kKeys count:GPBARRAYSIZE(kValues)]; XCTAssertNotNil(dict2); @@ -643,17 +643,17 @@ static BOOL TestingEnum_IsValidValue(int32_t value) { XCTAssertEqual(dict.count, 4U); int32_t value; - XCTAssertTrue([dict valueForKey:@"foo" value:NULL]); - XCTAssertTrue([dict valueForKey:@"foo" value:&value]); + XCTAssertTrue([dict getInt32:NULL forKey:@"foo"]); + XCTAssertTrue([dict getInt32:&value forKey:@"foo"]); XCTAssertEqual(value, 200); - XCTAssertTrue([dict valueForKey:@"bar" value:NULL]); - XCTAssertTrue([dict valueForKey:@"bar" value:&value]); + XCTAssertTrue([dict getInt32:NULL forKey:@"bar"]); + XCTAssertTrue([dict getInt32:&value forKey:@"bar"]); XCTAssertEqual(value, 201); - XCTAssertTrue([dict valueForKey:@"baz" value:NULL]); - XCTAssertTrue([dict valueForKey:@"baz" value:&value]); + XCTAssertTrue([dict getInt32:NULL forKey:@"baz"]); + XCTAssertTrue([dict getInt32:&value forKey:@"baz"]); XCTAssertEqual(value, 202); - XCTAssertTrue([dict valueForKey:@"mumble" value:NULL]); - XCTAssertTrue([dict valueForKey:@"mumble" value:&value]); + XCTAssertTrue([dict getInt32:NULL forKey:@"mumble"]); + XCTAssertTrue([dict getInt32:&value forKey:@"mumble"]); XCTAssertEqual(value, 203); [dict2 release]; } @@ -662,57 +662,57 @@ static BOOL TestingEnum_IsValidValue(int32_t value) { const NSString *kKeys[] = { @"foo", @"bar", @"baz", @"mumble" }; const int32_t kValues[] = { 200, 201, 202, 203 }; GPBStringInt32Dictionary *dict = - [[GPBStringInt32Dictionary alloc] initWithValues:kValues - forKeys:kKeys - count:GPBARRAYSIZE(kValues)]; + [[GPBStringInt32Dictionary alloc] initWithInt32s:kValues + forKeys:kKeys + count:GPBARRAYSIZE(kValues)]; XCTAssertNotNil(dict); XCTAssertEqual(dict.count, 4U); - [dict removeValueForKey:@"bar"]; + [dict removeInt32ForKey:@"bar"]; XCTAssertEqual(dict.count, 3U); int32_t value; - XCTAssertTrue([dict valueForKey:@"foo" value:NULL]); - XCTAssertTrue([dict valueForKey:@"foo" value:&value]); + XCTAssertTrue([dict getInt32:NULL forKey:@"foo"]); + XCTAssertTrue([dict getInt32:&value forKey:@"foo"]); XCTAssertEqual(value, 200); - XCTAssertFalse([dict valueForKey:@"bar" value:NULL]); - XCTAssertTrue([dict valueForKey:@"baz" value:NULL]); - XCTAssertTrue([dict valueForKey:@"baz" value:&value]); + XCTAssertFalse([dict getInt32:NULL forKey:@"bar"]); + XCTAssertTrue([dict getInt32:NULL forKey:@"baz"]); + XCTAssertTrue([dict getInt32:&value forKey:@"baz"]); XCTAssertEqual(value, 202); - XCTAssertTrue([dict valueForKey:@"mumble" value:NULL]); - XCTAssertTrue([dict valueForKey:@"mumble" value:&value]); + XCTAssertTrue([dict getInt32:NULL forKey:@"mumble"]); + XCTAssertTrue([dict getInt32:&value forKey:@"mumble"]); XCTAssertEqual(value, 203); // Remove again does nothing. - [dict removeValueForKey:@"bar"]; + [dict removeInt32ForKey:@"bar"]; XCTAssertEqual(dict.count, 3U); - XCTAssertTrue([dict valueForKey:@"foo" value:NULL]); - XCTAssertTrue([dict valueForKey:@"foo" value:&value]); + XCTAssertTrue([dict getInt32:NULL forKey:@"foo"]); + XCTAssertTrue([dict getInt32:&value forKey:@"foo"]); XCTAssertEqual(value, 200); - XCTAssertFalse([dict valueForKey:@"bar" value:NULL]); - XCTAssertTrue([dict valueForKey:@"baz" value:NULL]); - XCTAssertTrue([dict valueForKey:@"baz" value:&value]); + XCTAssertFalse([dict getInt32:NULL forKey:@"bar"]); + XCTAssertTrue([dict getInt32:NULL forKey:@"baz"]); + XCTAssertTrue([dict getInt32:&value forKey:@"baz"]); XCTAssertEqual(value, 202); - XCTAssertTrue([dict valueForKey:@"mumble" value:NULL]); - XCTAssertTrue([dict valueForKey:@"mumble" value:&value]); + XCTAssertTrue([dict getInt32:NULL forKey:@"mumble"]); + XCTAssertTrue([dict getInt32:&value forKey:@"mumble"]); XCTAssertEqual(value, 203); - [dict removeValueForKey:@"mumble"]; + [dict removeInt32ForKey:@"mumble"]; XCTAssertEqual(dict.count, 2U); - XCTAssertTrue([dict valueForKey:@"foo" value:NULL]); - XCTAssertTrue([dict valueForKey:@"foo" value:&value]); + XCTAssertTrue([dict getInt32:NULL forKey:@"foo"]); + XCTAssertTrue([dict getInt32:&value forKey:@"foo"]); XCTAssertEqual(value, 200); - XCTAssertFalse([dict valueForKey:@"bar" value:NULL]); - XCTAssertTrue([dict valueForKey:@"baz" value:NULL]); - XCTAssertTrue([dict valueForKey:@"baz" value:&value]); + XCTAssertFalse([dict getInt32:NULL forKey:@"bar"]); + XCTAssertTrue([dict getInt32:NULL forKey:@"baz"]); + XCTAssertTrue([dict getInt32:&value forKey:@"baz"]); XCTAssertEqual(value, 202); - XCTAssertFalse([dict valueForKey:@"mumble" value:NULL]); + XCTAssertFalse([dict getInt32:NULL forKey:@"mumble"]); [dict removeAll]; XCTAssertEqual(dict.count, 0U); - XCTAssertFalse([dict valueForKey:@"foo" value:NULL]); - XCTAssertFalse([dict valueForKey:@"bar" value:NULL]); - XCTAssertFalse([dict valueForKey:@"baz" value:NULL]); - XCTAssertFalse([dict valueForKey:@"mumble" value:NULL]); + XCTAssertFalse([dict getInt32:NULL forKey:@"foo"]); + XCTAssertFalse([dict getInt32:NULL forKey:@"bar"]); + XCTAssertFalse([dict getInt32:NULL forKey:@"baz"]); + XCTAssertFalse([dict getInt32:NULL forKey:@"mumble"]); [dict release]; } @@ -720,75 +720,75 @@ static BOOL TestingEnum_IsValidValue(int32_t value) { const NSString *kKeys[] = { @"foo", @"bar", @"baz", @"mumble" }; const int32_t kValues[] = { 200, 201, 202, 203 }; GPBStringInt32Dictionary *dict = - [[GPBStringInt32Dictionary alloc] initWithValues:kValues - forKeys:kKeys - count:GPBARRAYSIZE(kValues)]; + [[GPBStringInt32Dictionary alloc] initWithInt32s:kValues + forKeys:kKeys + count:GPBARRAYSIZE(kValues)]; XCTAssertNotNil(dict); XCTAssertEqual(dict.count, 4U); int32_t value; - XCTAssertTrue([dict valueForKey:@"foo" value:NULL]); - XCTAssertTrue([dict valueForKey:@"foo" value:&value]); + XCTAssertTrue([dict getInt32:NULL forKey:@"foo"]); + XCTAssertTrue([dict getInt32:&value forKey:@"foo"]); XCTAssertEqual(value, 200); - XCTAssertTrue([dict valueForKey:@"bar" value:NULL]); - XCTAssertTrue([dict valueForKey:@"bar" value:&value]); + XCTAssertTrue([dict getInt32:NULL forKey:@"bar"]); + XCTAssertTrue([dict getInt32:&value forKey:@"bar"]); XCTAssertEqual(value, 201); - XCTAssertTrue([dict valueForKey:@"baz" value:NULL]); - XCTAssertTrue([dict valueForKey:@"baz" value:&value]); + XCTAssertTrue([dict getInt32:NULL forKey:@"baz"]); + XCTAssertTrue([dict getInt32:&value forKey:@"baz"]); XCTAssertEqual(value, 202); - XCTAssertTrue([dict valueForKey:@"mumble" value:NULL]); - XCTAssertTrue([dict valueForKey:@"mumble" value:&value]); + XCTAssertTrue([dict getInt32:NULL forKey:@"mumble"]); + XCTAssertTrue([dict getInt32:&value forKey:@"mumble"]); XCTAssertEqual(value, 203); - [dict setValue:203 forKey:@"foo"]; + [dict setInt32:203 forKey:@"foo"]; XCTAssertEqual(dict.count, 4U); - XCTAssertTrue([dict valueForKey:@"foo" value:NULL]); - XCTAssertTrue([dict valueForKey:@"foo" value:&value]); + XCTAssertTrue([dict getInt32:NULL forKey:@"foo"]); + XCTAssertTrue([dict getInt32:&value forKey:@"foo"]); XCTAssertEqual(value, 203); - XCTAssertTrue([dict valueForKey:@"bar" value:NULL]); - XCTAssertTrue([dict valueForKey:@"bar" value:&value]); + XCTAssertTrue([dict getInt32:NULL forKey:@"bar"]); + XCTAssertTrue([dict getInt32:&value forKey:@"bar"]); XCTAssertEqual(value, 201); - XCTAssertTrue([dict valueForKey:@"baz" value:NULL]); - XCTAssertTrue([dict valueForKey:@"baz" value:&value]); + XCTAssertTrue([dict getInt32:NULL forKey:@"baz"]); + XCTAssertTrue([dict getInt32:&value forKey:@"baz"]); XCTAssertEqual(value, 202); - XCTAssertTrue([dict valueForKey:@"mumble" value:NULL]); - XCTAssertTrue([dict valueForKey:@"mumble" value:&value]); + XCTAssertTrue([dict getInt32:NULL forKey:@"mumble"]); + XCTAssertTrue([dict getInt32:&value forKey:@"mumble"]); XCTAssertEqual(value, 203); - [dict setValue:201 forKey:@"mumble"]; + [dict setInt32:201 forKey:@"mumble"]; XCTAssertEqual(dict.count, 4U); - XCTAssertTrue([dict valueForKey:@"foo" value:NULL]); - XCTAssertTrue([dict valueForKey:@"foo" value:&value]); + XCTAssertTrue([dict getInt32:NULL forKey:@"foo"]); + XCTAssertTrue([dict getInt32:&value forKey:@"foo"]); XCTAssertEqual(value, 203); - XCTAssertTrue([dict valueForKey:@"bar" value:NULL]); - XCTAssertTrue([dict valueForKey:@"bar" value:&value]); + XCTAssertTrue([dict getInt32:NULL forKey:@"bar"]); + XCTAssertTrue([dict getInt32:&value forKey:@"bar"]); XCTAssertEqual(value, 201); - XCTAssertTrue([dict valueForKey:@"baz" value:NULL]); - XCTAssertTrue([dict valueForKey:@"baz" value:&value]); + XCTAssertTrue([dict getInt32:NULL forKey:@"baz"]); + XCTAssertTrue([dict getInt32:&value forKey:@"baz"]); XCTAssertEqual(value, 202); - XCTAssertTrue([dict valueForKey:@"mumble" value:NULL]); - XCTAssertTrue([dict valueForKey:@"mumble" value:&value]); + XCTAssertTrue([dict getInt32:NULL forKey:@"mumble"]); + XCTAssertTrue([dict getInt32:&value forKey:@"mumble"]); XCTAssertEqual(value, 201); const NSString *kKeys2[] = { @"bar", @"baz" }; const int32_t kValues2[] = { 202, 200 }; GPBStringInt32Dictionary *dict2 = - [[GPBStringInt32Dictionary alloc] initWithValues:kValues2 + [[GPBStringInt32Dictionary alloc] initWithInt32s:kValues2 forKeys:kKeys2 count:GPBARRAYSIZE(kValues2)]; XCTAssertNotNil(dict2); [dict addEntriesFromDictionary:dict2]; XCTAssertEqual(dict.count, 4U); - XCTAssertTrue([dict valueForKey:@"foo" value:NULL]); - XCTAssertTrue([dict valueForKey:@"foo" value:&value]); + XCTAssertTrue([dict getInt32:NULL forKey:@"foo"]); + XCTAssertTrue([dict getInt32:&value forKey:@"foo"]); XCTAssertEqual(value, 203); - XCTAssertTrue([dict valueForKey:@"bar" value:NULL]); - XCTAssertTrue([dict valueForKey:@"bar" value:&value]); + XCTAssertTrue([dict getInt32:NULL forKey:@"bar"]); + XCTAssertTrue([dict getInt32:&value forKey:@"bar"]); XCTAssertEqual(value, 202); - XCTAssertTrue([dict valueForKey:@"baz" value:NULL]); - XCTAssertTrue([dict valueForKey:@"baz" value:&value]); + XCTAssertTrue([dict getInt32:NULL forKey:@"baz"]); + XCTAssertTrue([dict getInt32:&value forKey:@"baz"]); XCTAssertEqual(value, 200); - XCTAssertTrue([dict valueForKey:@"mumble" value:NULL]); - XCTAssertTrue([dict valueForKey:@"mumble" value:&value]); + XCTAssertTrue([dict getInt32:NULL forKey:@"mumble"]); + XCTAssertTrue([dict getInt32:&value forKey:@"mumble"]); XCTAssertEqual(value, 201); [dict2 release]; @@ -808,8 +808,8 @@ static BOOL TestingEnum_IsValidValue(int32_t value) { GPBStringUInt64Dictionary *dict = [[GPBStringUInt64Dictionary alloc] init]; XCTAssertNotNil(dict); XCTAssertEqual(dict.count, 0U); - XCTAssertFalse([dict valueForKey:@"foo" value:NULL]); - [dict enumerateKeysAndValuesUsingBlock:^(NSString *aKey, uint64_t aValue, BOOL *stop) { + XCTAssertFalse([dict getUInt64:NULL forKey:@"foo"]); + [dict enumerateKeysAndUInt64sUsingBlock:^(NSString *aKey, uint64_t aValue, BOOL *stop) { #pragma unused(aKey, aValue, stop) XCTFail(@"Shouldn't get here!"); }]; @@ -817,15 +817,15 @@ static BOOL TestingEnum_IsValidValue(int32_t value) { } - (void)testOne { - GPBStringUInt64Dictionary *dict = [GPBStringUInt64Dictionary dictionaryWithValue:300U forKey:@"foo"]; + GPBStringUInt64Dictionary *dict = [GPBStringUInt64Dictionary dictionaryWithUInt64:300U forKey:@"foo"]; XCTAssertNotNil(dict); XCTAssertEqual(dict.count, 1U); uint64_t value; - XCTAssertTrue([dict valueForKey:@"foo" value:NULL]); - XCTAssertTrue([dict valueForKey:@"foo" value:&value]); + XCTAssertTrue([dict getUInt64:NULL forKey:@"foo"]); + XCTAssertTrue([dict getUInt64:&value forKey:@"foo"]); XCTAssertEqual(value, 300U); - XCTAssertFalse([dict valueForKey:@"bar" value:NULL]); - [dict enumerateKeysAndValuesUsingBlock:^(NSString *aKey, uint64_t aValue, BOOL *stop) { + XCTAssertFalse([dict getUInt64:NULL forKey:@"bar"]); + [dict enumerateKeysAndUInt64sUsingBlock:^(NSString *aKey, uint64_t aValue, BOOL *stop) { XCTAssertEqualObjects(aKey, @"foo"); XCTAssertEqual(aValue, 300U); XCTAssertNotEqual(stop, NULL); @@ -836,27 +836,27 @@ static BOOL TestingEnum_IsValidValue(int32_t value) { const NSString *kKeys[] = { @"foo", @"bar", @"baz" }; const uint64_t kValues[] = { 300U, 301U, 302U }; GPBStringUInt64Dictionary *dict = - [[GPBStringUInt64Dictionary alloc] initWithValues:kValues - forKeys:kKeys - count:GPBARRAYSIZE(kValues)]; + [[GPBStringUInt64Dictionary alloc] initWithUInt64s:kValues + forKeys:kKeys + count:GPBARRAYSIZE(kValues)]; XCTAssertNotNil(dict); XCTAssertEqual(dict.count, 3U); uint64_t value; - XCTAssertTrue([dict valueForKey:@"foo" value:NULL]); - XCTAssertTrue([dict valueForKey:@"foo" value:&value]); + XCTAssertTrue([dict getUInt64:NULL forKey:@"foo"]); + XCTAssertTrue([dict getUInt64:&value forKey:@"foo"]); XCTAssertEqual(value, 300U); - XCTAssertTrue([dict valueForKey:@"bar" value:NULL]); - XCTAssertTrue([dict valueForKey:@"bar" value:&value]); + XCTAssertTrue([dict getUInt64:NULL forKey:@"bar"]); + XCTAssertTrue([dict getUInt64:&value forKey:@"bar"]); XCTAssertEqual(value, 301U); - XCTAssertTrue([dict valueForKey:@"baz" value:NULL]); - XCTAssertTrue([dict valueForKey:@"baz" value:&value]); + XCTAssertTrue([dict getUInt64:NULL forKey:@"baz"]); + XCTAssertTrue([dict getUInt64:&value forKey:@"baz"]); XCTAssertEqual(value, 302U); - XCTAssertFalse([dict valueForKey:@"mumble" value:NULL]); + XCTAssertFalse([dict getUInt64:NULL forKey:@"mumble"]); __block NSUInteger idx = 0; NSString **seenKeys = malloc(3 * sizeof(NSString*)); uint64_t *seenValues = malloc(3 * sizeof(uint64_t)); - [dict enumerateKeysAndValuesUsingBlock:^(NSString *aKey, uint64_t aValue, BOOL *stop) { + [dict enumerateKeysAndUInt64sUsingBlock:^(NSString *aKey, uint64_t aValue, BOOL *stop) { XCTAssertLessThan(idx, 3U); seenKeys[idx] = aKey; seenValues[idx] = aValue; @@ -878,7 +878,7 @@ static BOOL TestingEnum_IsValidValue(int32_t value) { // Stopping the enumeration. idx = 0; - [dict enumerateKeysAndValuesUsingBlock:^(NSString *aKey, uint64_t aValue, BOOL *stop) { + [dict enumerateKeysAndUInt64sUsingBlock:^(NSString *aKey, uint64_t aValue, BOOL *stop) { #pragma unused(aKey, aValue) if (idx == 1) *stop = YES; XCTAssertNotEqual(idx, 2U); @@ -894,29 +894,29 @@ static BOOL TestingEnum_IsValidValue(int32_t value) { const uint64_t kValues2[] = { 300U, 303U, 302U }; const uint64_t kValues3[] = { 300U, 301U, 302U, 303U }; GPBStringUInt64Dictionary *dict1 = - [[GPBStringUInt64Dictionary alloc] initWithValues:kValues1 - forKeys:kKeys1 - count:GPBARRAYSIZE(kValues1)]; + [[GPBStringUInt64Dictionary alloc] initWithUInt64s:kValues1 + forKeys:kKeys1 + count:GPBARRAYSIZE(kValues1)]; XCTAssertNotNil(dict1); GPBStringUInt64Dictionary *dict1prime = - [[GPBStringUInt64Dictionary alloc] initWithValues:kValues1 - forKeys:kKeys1 - count:GPBARRAYSIZE(kValues1)]; + [[GPBStringUInt64Dictionary alloc] initWithUInt64s:kValues1 + forKeys:kKeys1 + count:GPBARRAYSIZE(kValues1)]; XCTAssertNotNil(dict1prime); GPBStringUInt64Dictionary *dict2 = - [[GPBStringUInt64Dictionary alloc] initWithValues:kValues2 - forKeys:kKeys1 - count:GPBARRAYSIZE(kValues2)]; + [[GPBStringUInt64Dictionary alloc] initWithUInt64s:kValues2 + forKeys:kKeys1 + count:GPBARRAYSIZE(kValues2)]; XCTAssertNotNil(dict2); GPBStringUInt64Dictionary *dict3 = - [[GPBStringUInt64Dictionary alloc] initWithValues:kValues1 - forKeys:kKeys2 - count:GPBARRAYSIZE(kValues1)]; + [[GPBStringUInt64Dictionary alloc] initWithUInt64s:kValues1 + forKeys:kKeys2 + count:GPBARRAYSIZE(kValues1)]; XCTAssertNotNil(dict3); GPBStringUInt64Dictionary *dict4 = - [[GPBStringUInt64Dictionary alloc] initWithValues:kValues3 - forKeys:kKeys1 - count:GPBARRAYSIZE(kValues3)]; + [[GPBStringUInt64Dictionary alloc] initWithUInt64s:kValues3 + forKeys:kKeys1 + count:GPBARRAYSIZE(kValues3)]; XCTAssertNotNil(dict4); // 1/1Prime should be different objects, but equal. @@ -945,9 +945,9 @@ static BOOL TestingEnum_IsValidValue(int32_t value) { const NSString *kKeys[] = { @"foo", @"bar", @"baz", @"mumble" }; const uint64_t kValues[] = { 300U, 301U, 302U, 303U }; GPBStringUInt64Dictionary *dict = - [[GPBStringUInt64Dictionary alloc] initWithValues:kValues - forKeys:kKeys - count:GPBARRAYSIZE(kValues)]; + [[GPBStringUInt64Dictionary alloc] initWithUInt64s:kValues + forKeys:kKeys + count:GPBARRAYSIZE(kValues)]; XCTAssertNotNil(dict); GPBStringUInt64Dictionary *dict2 = [dict copy]; @@ -966,9 +966,9 @@ static BOOL TestingEnum_IsValidValue(int32_t value) { const NSString *kKeys[] = { @"foo", @"bar", @"baz", @"mumble" }; const uint64_t kValues[] = { 300U, 301U, 302U, 303U }; GPBStringUInt64Dictionary *dict = - [[GPBStringUInt64Dictionary alloc] initWithValues:kValues - forKeys:kKeys - count:GPBARRAYSIZE(kValues)]; + [[GPBStringUInt64Dictionary alloc] initWithUInt64s:kValues + forKeys:kKeys + count:GPBARRAYSIZE(kValues)]; XCTAssertNotNil(dict); GPBStringUInt64Dictionary *dict2 = @@ -986,31 +986,31 @@ static BOOL TestingEnum_IsValidValue(int32_t value) { XCTAssertNotNil(dict); XCTAssertEqual(dict.count, 0U); - [dict setValue:300U forKey:@"foo"]; + [dict setUInt64:300U forKey:@"foo"]; XCTAssertEqual(dict.count, 1U); const NSString *kKeys[] = { @"bar", @"baz", @"mumble" }; const uint64_t kValues[] = { 301U, 302U, 303U }; GPBStringUInt64Dictionary *dict2 = - [[GPBStringUInt64Dictionary alloc] initWithValues:kValues - forKeys:kKeys - count:GPBARRAYSIZE(kValues)]; + [[GPBStringUInt64Dictionary alloc] initWithUInt64s:kValues + forKeys:kKeys + count:GPBARRAYSIZE(kValues)]; XCTAssertNotNil(dict2); [dict addEntriesFromDictionary:dict2]; XCTAssertEqual(dict.count, 4U); uint64_t value; - XCTAssertTrue([dict valueForKey:@"foo" value:NULL]); - XCTAssertTrue([dict valueForKey:@"foo" value:&value]); + XCTAssertTrue([dict getUInt64:NULL forKey:@"foo"]); + XCTAssertTrue([dict getUInt64:&value forKey:@"foo"]); XCTAssertEqual(value, 300U); - XCTAssertTrue([dict valueForKey:@"bar" value:NULL]); - XCTAssertTrue([dict valueForKey:@"bar" value:&value]); + XCTAssertTrue([dict getUInt64:NULL forKey:@"bar"]); + XCTAssertTrue([dict getUInt64:&value forKey:@"bar"]); XCTAssertEqual(value, 301U); - XCTAssertTrue([dict valueForKey:@"baz" value:NULL]); - XCTAssertTrue([dict valueForKey:@"baz" value:&value]); + XCTAssertTrue([dict getUInt64:NULL forKey:@"baz"]); + XCTAssertTrue([dict getUInt64:&value forKey:@"baz"]); XCTAssertEqual(value, 302U); - XCTAssertTrue([dict valueForKey:@"mumble" value:NULL]); - XCTAssertTrue([dict valueForKey:@"mumble" value:&value]); + XCTAssertTrue([dict getUInt64:NULL forKey:@"mumble"]); + XCTAssertTrue([dict getUInt64:&value forKey:@"mumble"]); XCTAssertEqual(value, 303U); [dict2 release]; } @@ -1019,57 +1019,57 @@ static BOOL TestingEnum_IsValidValue(int32_t value) { const NSString *kKeys[] = { @"foo", @"bar", @"baz", @"mumble" }; const uint64_t kValues[] = { 300U, 301U, 302U, 303U }; GPBStringUInt64Dictionary *dict = - [[GPBStringUInt64Dictionary alloc] initWithValues:kValues - forKeys:kKeys - count:GPBARRAYSIZE(kValues)]; + [[GPBStringUInt64Dictionary alloc] initWithUInt64s:kValues + forKeys:kKeys + count:GPBARRAYSIZE(kValues)]; XCTAssertNotNil(dict); XCTAssertEqual(dict.count, 4U); - [dict removeValueForKey:@"bar"]; + [dict removeUInt64ForKey:@"bar"]; XCTAssertEqual(dict.count, 3U); uint64_t value; - XCTAssertTrue([dict valueForKey:@"foo" value:NULL]); - XCTAssertTrue([dict valueForKey:@"foo" value:&value]); + XCTAssertTrue([dict getUInt64:NULL forKey:@"foo"]); + XCTAssertTrue([dict getUInt64:&value forKey:@"foo"]); XCTAssertEqual(value, 300U); - XCTAssertFalse([dict valueForKey:@"bar" value:NULL]); - XCTAssertTrue([dict valueForKey:@"baz" value:NULL]); - XCTAssertTrue([dict valueForKey:@"baz" value:&value]); + XCTAssertFalse([dict getUInt64:NULL forKey:@"bar"]); + XCTAssertTrue([dict getUInt64:NULL forKey:@"baz"]); + XCTAssertTrue([dict getUInt64:&value forKey:@"baz"]); XCTAssertEqual(value, 302U); - XCTAssertTrue([dict valueForKey:@"mumble" value:NULL]); - XCTAssertTrue([dict valueForKey:@"mumble" value:&value]); + XCTAssertTrue([dict getUInt64:NULL forKey:@"mumble"]); + XCTAssertTrue([dict getUInt64:&value forKey:@"mumble"]); XCTAssertEqual(value, 303U); // Remove again does nothing. - [dict removeValueForKey:@"bar"]; + [dict removeUInt64ForKey:@"bar"]; XCTAssertEqual(dict.count, 3U); - XCTAssertTrue([dict valueForKey:@"foo" value:NULL]); - XCTAssertTrue([dict valueForKey:@"foo" value:&value]); + XCTAssertTrue([dict getUInt64:NULL forKey:@"foo"]); + XCTAssertTrue([dict getUInt64:&value forKey:@"foo"]); XCTAssertEqual(value, 300U); - XCTAssertFalse([dict valueForKey:@"bar" value:NULL]); - XCTAssertTrue([dict valueForKey:@"baz" value:NULL]); - XCTAssertTrue([dict valueForKey:@"baz" value:&value]); + XCTAssertFalse([dict getUInt64:NULL forKey:@"bar"]); + XCTAssertTrue([dict getUInt64:NULL forKey:@"baz"]); + XCTAssertTrue([dict getUInt64:&value forKey:@"baz"]); XCTAssertEqual(value, 302U); - XCTAssertTrue([dict valueForKey:@"mumble" value:NULL]); - XCTAssertTrue([dict valueForKey:@"mumble" value:&value]); + XCTAssertTrue([dict getUInt64:NULL forKey:@"mumble"]); + XCTAssertTrue([dict getUInt64:&value forKey:@"mumble"]); XCTAssertEqual(value, 303U); - [dict removeValueForKey:@"mumble"]; + [dict removeUInt64ForKey:@"mumble"]; XCTAssertEqual(dict.count, 2U); - XCTAssertTrue([dict valueForKey:@"foo" value:NULL]); - XCTAssertTrue([dict valueForKey:@"foo" value:&value]); + XCTAssertTrue([dict getUInt64:NULL forKey:@"foo"]); + XCTAssertTrue([dict getUInt64:&value forKey:@"foo"]); XCTAssertEqual(value, 300U); - XCTAssertFalse([dict valueForKey:@"bar" value:NULL]); - XCTAssertTrue([dict valueForKey:@"baz" value:NULL]); - XCTAssertTrue([dict valueForKey:@"baz" value:&value]); + XCTAssertFalse([dict getUInt64:NULL forKey:@"bar"]); + XCTAssertTrue([dict getUInt64:NULL forKey:@"baz"]); + XCTAssertTrue([dict getUInt64:&value forKey:@"baz"]); XCTAssertEqual(value, 302U); - XCTAssertFalse([dict valueForKey:@"mumble" value:NULL]); + XCTAssertFalse([dict getUInt64:NULL forKey:@"mumble"]); [dict removeAll]; XCTAssertEqual(dict.count, 0U); - XCTAssertFalse([dict valueForKey:@"foo" value:NULL]); - XCTAssertFalse([dict valueForKey:@"bar" value:NULL]); - XCTAssertFalse([dict valueForKey:@"baz" value:NULL]); - XCTAssertFalse([dict valueForKey:@"mumble" value:NULL]); + XCTAssertFalse([dict getUInt64:NULL forKey:@"foo"]); + XCTAssertFalse([dict getUInt64:NULL forKey:@"bar"]); + XCTAssertFalse([dict getUInt64:NULL forKey:@"baz"]); + XCTAssertFalse([dict getUInt64:NULL forKey:@"mumble"]); [dict release]; } @@ -1077,75 +1077,75 @@ static BOOL TestingEnum_IsValidValue(int32_t value) { const NSString *kKeys[] = { @"foo", @"bar", @"baz", @"mumble" }; const uint64_t kValues[] = { 300U, 301U, 302U, 303U }; GPBStringUInt64Dictionary *dict = - [[GPBStringUInt64Dictionary alloc] initWithValues:kValues - forKeys:kKeys - count:GPBARRAYSIZE(kValues)]; + [[GPBStringUInt64Dictionary alloc] initWithUInt64s:kValues + forKeys:kKeys + count:GPBARRAYSIZE(kValues)]; XCTAssertNotNil(dict); XCTAssertEqual(dict.count, 4U); uint64_t value; - XCTAssertTrue([dict valueForKey:@"foo" value:NULL]); - XCTAssertTrue([dict valueForKey:@"foo" value:&value]); + XCTAssertTrue([dict getUInt64:NULL forKey:@"foo"]); + XCTAssertTrue([dict getUInt64:&value forKey:@"foo"]); XCTAssertEqual(value, 300U); - XCTAssertTrue([dict valueForKey:@"bar" value:NULL]); - XCTAssertTrue([dict valueForKey:@"bar" value:&value]); + XCTAssertTrue([dict getUInt64:NULL forKey:@"bar"]); + XCTAssertTrue([dict getUInt64:&value forKey:@"bar"]); XCTAssertEqual(value, 301U); - XCTAssertTrue([dict valueForKey:@"baz" value:NULL]); - XCTAssertTrue([dict valueForKey:@"baz" value:&value]); + XCTAssertTrue([dict getUInt64:NULL forKey:@"baz"]); + XCTAssertTrue([dict getUInt64:&value forKey:@"baz"]); XCTAssertEqual(value, 302U); - XCTAssertTrue([dict valueForKey:@"mumble" value:NULL]); - XCTAssertTrue([dict valueForKey:@"mumble" value:&value]); + XCTAssertTrue([dict getUInt64:NULL forKey:@"mumble"]); + XCTAssertTrue([dict getUInt64:&value forKey:@"mumble"]); XCTAssertEqual(value, 303U); - [dict setValue:303U forKey:@"foo"]; + [dict setUInt64:303U forKey:@"foo"]; XCTAssertEqual(dict.count, 4U); - XCTAssertTrue([dict valueForKey:@"foo" value:NULL]); - XCTAssertTrue([dict valueForKey:@"foo" value:&value]); + XCTAssertTrue([dict getUInt64:NULL forKey:@"foo"]); + XCTAssertTrue([dict getUInt64:&value forKey:@"foo"]); XCTAssertEqual(value, 303U); - XCTAssertTrue([dict valueForKey:@"bar" value:NULL]); - XCTAssertTrue([dict valueForKey:@"bar" value:&value]); + XCTAssertTrue([dict getUInt64:NULL forKey:@"bar"]); + XCTAssertTrue([dict getUInt64:&value forKey:@"bar"]); XCTAssertEqual(value, 301U); - XCTAssertTrue([dict valueForKey:@"baz" value:NULL]); - XCTAssertTrue([dict valueForKey:@"baz" value:&value]); + XCTAssertTrue([dict getUInt64:NULL forKey:@"baz"]); + XCTAssertTrue([dict getUInt64:&value forKey:@"baz"]); XCTAssertEqual(value, 302U); - XCTAssertTrue([dict valueForKey:@"mumble" value:NULL]); - XCTAssertTrue([dict valueForKey:@"mumble" value:&value]); + XCTAssertTrue([dict getUInt64:NULL forKey:@"mumble"]); + XCTAssertTrue([dict getUInt64:&value forKey:@"mumble"]); XCTAssertEqual(value, 303U); - [dict setValue:301U forKey:@"mumble"]; + [dict setUInt64:301U forKey:@"mumble"]; XCTAssertEqual(dict.count, 4U); - XCTAssertTrue([dict valueForKey:@"foo" value:NULL]); - XCTAssertTrue([dict valueForKey:@"foo" value:&value]); + XCTAssertTrue([dict getUInt64:NULL forKey:@"foo"]); + XCTAssertTrue([dict getUInt64:&value forKey:@"foo"]); XCTAssertEqual(value, 303U); - XCTAssertTrue([dict valueForKey:@"bar" value:NULL]); - XCTAssertTrue([dict valueForKey:@"bar" value:&value]); + XCTAssertTrue([dict getUInt64:NULL forKey:@"bar"]); + XCTAssertTrue([dict getUInt64:&value forKey:@"bar"]); XCTAssertEqual(value, 301U); - XCTAssertTrue([dict valueForKey:@"baz" value:NULL]); - XCTAssertTrue([dict valueForKey:@"baz" value:&value]); + XCTAssertTrue([dict getUInt64:NULL forKey:@"baz"]); + XCTAssertTrue([dict getUInt64:&value forKey:@"baz"]); XCTAssertEqual(value, 302U); - XCTAssertTrue([dict valueForKey:@"mumble" value:NULL]); - XCTAssertTrue([dict valueForKey:@"mumble" value:&value]); + XCTAssertTrue([dict getUInt64:NULL forKey:@"mumble"]); + XCTAssertTrue([dict getUInt64:&value forKey:@"mumble"]); XCTAssertEqual(value, 301U); const NSString *kKeys2[] = { @"bar", @"baz" }; const uint64_t kValues2[] = { 302U, 300U }; GPBStringUInt64Dictionary *dict2 = - [[GPBStringUInt64Dictionary alloc] initWithValues:kValues2 - forKeys:kKeys2 - count:GPBARRAYSIZE(kValues2)]; + [[GPBStringUInt64Dictionary alloc] initWithUInt64s:kValues2 + forKeys:kKeys2 + count:GPBARRAYSIZE(kValues2)]; XCTAssertNotNil(dict2); [dict addEntriesFromDictionary:dict2]; XCTAssertEqual(dict.count, 4U); - XCTAssertTrue([dict valueForKey:@"foo" value:NULL]); - XCTAssertTrue([dict valueForKey:@"foo" value:&value]); + XCTAssertTrue([dict getUInt64:NULL forKey:@"foo"]); + XCTAssertTrue([dict getUInt64:&value forKey:@"foo"]); XCTAssertEqual(value, 303U); - XCTAssertTrue([dict valueForKey:@"bar" value:NULL]); - XCTAssertTrue([dict valueForKey:@"bar" value:&value]); + XCTAssertTrue([dict getUInt64:NULL forKey:@"bar"]); + XCTAssertTrue([dict getUInt64:&value forKey:@"bar"]); XCTAssertEqual(value, 302U); - XCTAssertTrue([dict valueForKey:@"baz" value:NULL]); - XCTAssertTrue([dict valueForKey:@"baz" value:&value]); + XCTAssertTrue([dict getUInt64:NULL forKey:@"baz"]); + XCTAssertTrue([dict getUInt64:&value forKey:@"baz"]); XCTAssertEqual(value, 300U); - XCTAssertTrue([dict valueForKey:@"mumble" value:NULL]); - XCTAssertTrue([dict valueForKey:@"mumble" value:&value]); + XCTAssertTrue([dict getUInt64:NULL forKey:@"mumble"]); + XCTAssertTrue([dict getUInt64:&value forKey:@"mumble"]); XCTAssertEqual(value, 301U); [dict2 release]; @@ -1165,8 +1165,8 @@ static BOOL TestingEnum_IsValidValue(int32_t value) { GPBStringInt64Dictionary *dict = [[GPBStringInt64Dictionary alloc] init]; XCTAssertNotNil(dict); XCTAssertEqual(dict.count, 0U); - XCTAssertFalse([dict valueForKey:@"foo" value:NULL]); - [dict enumerateKeysAndValuesUsingBlock:^(NSString *aKey, int64_t aValue, BOOL *stop) { + XCTAssertFalse([dict getInt64:NULL forKey:@"foo"]); + [dict enumerateKeysAndInt64sUsingBlock:^(NSString *aKey, int64_t aValue, BOOL *stop) { #pragma unused(aKey, aValue, stop) XCTFail(@"Shouldn't get here!"); }]; @@ -1174,15 +1174,15 @@ static BOOL TestingEnum_IsValidValue(int32_t value) { } - (void)testOne { - GPBStringInt64Dictionary *dict = [GPBStringInt64Dictionary dictionaryWithValue:400 forKey:@"foo"]; + GPBStringInt64Dictionary *dict = [GPBStringInt64Dictionary dictionaryWithInt64:400 forKey:@"foo"]; XCTAssertNotNil(dict); XCTAssertEqual(dict.count, 1U); int64_t value; - XCTAssertTrue([dict valueForKey:@"foo" value:NULL]); - XCTAssertTrue([dict valueForKey:@"foo" value:&value]); + XCTAssertTrue([dict getInt64:NULL forKey:@"foo"]); + XCTAssertTrue([dict getInt64:&value forKey:@"foo"]); XCTAssertEqual(value, 400); - XCTAssertFalse([dict valueForKey:@"bar" value:NULL]); - [dict enumerateKeysAndValuesUsingBlock:^(NSString *aKey, int64_t aValue, BOOL *stop) { + XCTAssertFalse([dict getInt64:NULL forKey:@"bar"]); + [dict enumerateKeysAndInt64sUsingBlock:^(NSString *aKey, int64_t aValue, BOOL *stop) { XCTAssertEqualObjects(aKey, @"foo"); XCTAssertEqual(aValue, 400); XCTAssertNotEqual(stop, NULL); @@ -1193,27 +1193,27 @@ static BOOL TestingEnum_IsValidValue(int32_t value) { const NSString *kKeys[] = { @"foo", @"bar", @"baz" }; const int64_t kValues[] = { 400, 401, 402 }; GPBStringInt64Dictionary *dict = - [[GPBStringInt64Dictionary alloc] initWithValues:kValues + [[GPBStringInt64Dictionary alloc] initWithInt64s:kValues forKeys:kKeys count:GPBARRAYSIZE(kValues)]; XCTAssertNotNil(dict); XCTAssertEqual(dict.count, 3U); int64_t value; - XCTAssertTrue([dict valueForKey:@"foo" value:NULL]); - XCTAssertTrue([dict valueForKey:@"foo" value:&value]); + XCTAssertTrue([dict getInt64:NULL forKey:@"foo"]); + XCTAssertTrue([dict getInt64:&value forKey:@"foo"]); XCTAssertEqual(value, 400); - XCTAssertTrue([dict valueForKey:@"bar" value:NULL]); - XCTAssertTrue([dict valueForKey:@"bar" value:&value]); + XCTAssertTrue([dict getInt64:NULL forKey:@"bar"]); + XCTAssertTrue([dict getInt64:&value forKey:@"bar"]); XCTAssertEqual(value, 401); - XCTAssertTrue([dict valueForKey:@"baz" value:NULL]); - XCTAssertTrue([dict valueForKey:@"baz" value:&value]); + XCTAssertTrue([dict getInt64:NULL forKey:@"baz"]); + XCTAssertTrue([dict getInt64:&value forKey:@"baz"]); XCTAssertEqual(value, 402); - XCTAssertFalse([dict valueForKey:@"mumble" value:NULL]); + XCTAssertFalse([dict getInt64:NULL forKey:@"mumble"]); __block NSUInteger idx = 0; NSString **seenKeys = malloc(3 * sizeof(NSString*)); int64_t *seenValues = malloc(3 * sizeof(int64_t)); - [dict enumerateKeysAndValuesUsingBlock:^(NSString *aKey, int64_t aValue, BOOL *stop) { + [dict enumerateKeysAndInt64sUsingBlock:^(NSString *aKey, int64_t aValue, BOOL *stop) { XCTAssertLessThan(idx, 3U); seenKeys[idx] = aKey; seenValues[idx] = aValue; @@ -1235,7 +1235,7 @@ static BOOL TestingEnum_IsValidValue(int32_t value) { // Stopping the enumeration. idx = 0; - [dict enumerateKeysAndValuesUsingBlock:^(NSString *aKey, int64_t aValue, BOOL *stop) { + [dict enumerateKeysAndInt64sUsingBlock:^(NSString *aKey, int64_t aValue, BOOL *stop) { #pragma unused(aKey, aValue) if (idx == 1) *stop = YES; XCTAssertNotEqual(idx, 2U); @@ -1251,27 +1251,27 @@ static BOOL TestingEnum_IsValidValue(int32_t value) { const int64_t kValues2[] = { 400, 403, 402 }; const int64_t kValues3[] = { 400, 401, 402, 403 }; GPBStringInt64Dictionary *dict1 = - [[GPBStringInt64Dictionary alloc] initWithValues:kValues1 + [[GPBStringInt64Dictionary alloc] initWithInt64s:kValues1 forKeys:kKeys1 count:GPBARRAYSIZE(kValues1)]; XCTAssertNotNil(dict1); GPBStringInt64Dictionary *dict1prime = - [[GPBStringInt64Dictionary alloc] initWithValues:kValues1 + [[GPBStringInt64Dictionary alloc] initWithInt64s:kValues1 forKeys:kKeys1 count:GPBARRAYSIZE(kValues1)]; XCTAssertNotNil(dict1prime); GPBStringInt64Dictionary *dict2 = - [[GPBStringInt64Dictionary alloc] initWithValues:kValues2 + [[GPBStringInt64Dictionary alloc] initWithInt64s:kValues2 forKeys:kKeys1 count:GPBARRAYSIZE(kValues2)]; XCTAssertNotNil(dict2); GPBStringInt64Dictionary *dict3 = - [[GPBStringInt64Dictionary alloc] initWithValues:kValues1 + [[GPBStringInt64Dictionary alloc] initWithInt64s:kValues1 forKeys:kKeys2 count:GPBARRAYSIZE(kValues1)]; XCTAssertNotNil(dict3); GPBStringInt64Dictionary *dict4 = - [[GPBStringInt64Dictionary alloc] initWithValues:kValues3 + [[GPBStringInt64Dictionary alloc] initWithInt64s:kValues3 forKeys:kKeys1 count:GPBARRAYSIZE(kValues3)]; XCTAssertNotNil(dict4); @@ -1302,7 +1302,7 @@ static BOOL TestingEnum_IsValidValue(int32_t value) { const NSString *kKeys[] = { @"foo", @"bar", @"baz", @"mumble" }; const int64_t kValues[] = { 400, 401, 402, 403 }; GPBStringInt64Dictionary *dict = - [[GPBStringInt64Dictionary alloc] initWithValues:kValues + [[GPBStringInt64Dictionary alloc] initWithInt64s:kValues forKeys:kKeys count:GPBARRAYSIZE(kValues)]; XCTAssertNotNil(dict); @@ -1323,7 +1323,7 @@ static BOOL TestingEnum_IsValidValue(int32_t value) { const NSString *kKeys[] = { @"foo", @"bar", @"baz", @"mumble" }; const int64_t kValues[] = { 400, 401, 402, 403 }; GPBStringInt64Dictionary *dict = - [[GPBStringInt64Dictionary alloc] initWithValues:kValues + [[GPBStringInt64Dictionary alloc] initWithInt64s:kValues forKeys:kKeys count:GPBARRAYSIZE(kValues)]; XCTAssertNotNil(dict); @@ -1343,13 +1343,13 @@ static BOOL TestingEnum_IsValidValue(int32_t value) { XCTAssertNotNil(dict); XCTAssertEqual(dict.count, 0U); - [dict setValue:400 forKey:@"foo"]; + [dict setInt64:400 forKey:@"foo"]; XCTAssertEqual(dict.count, 1U); const NSString *kKeys[] = { @"bar", @"baz", @"mumble" }; const int64_t kValues[] = { 401, 402, 403 }; GPBStringInt64Dictionary *dict2 = - [[GPBStringInt64Dictionary alloc] initWithValues:kValues + [[GPBStringInt64Dictionary alloc] initWithInt64s:kValues forKeys:kKeys count:GPBARRAYSIZE(kValues)]; XCTAssertNotNil(dict2); @@ -1357,17 +1357,17 @@ static BOOL TestingEnum_IsValidValue(int32_t value) { XCTAssertEqual(dict.count, 4U); int64_t value; - XCTAssertTrue([dict valueForKey:@"foo" value:NULL]); - XCTAssertTrue([dict valueForKey:@"foo" value:&value]); + XCTAssertTrue([dict getInt64:NULL forKey:@"foo"]); + XCTAssertTrue([dict getInt64:&value forKey:@"foo"]); XCTAssertEqual(value, 400); - XCTAssertTrue([dict valueForKey:@"bar" value:NULL]); - XCTAssertTrue([dict valueForKey:@"bar" value:&value]); + XCTAssertTrue([dict getInt64:NULL forKey:@"bar"]); + XCTAssertTrue([dict getInt64:&value forKey:@"bar"]); XCTAssertEqual(value, 401); - XCTAssertTrue([dict valueForKey:@"baz" value:NULL]); - XCTAssertTrue([dict valueForKey:@"baz" value:&value]); + XCTAssertTrue([dict getInt64:NULL forKey:@"baz"]); + XCTAssertTrue([dict getInt64:&value forKey:@"baz"]); XCTAssertEqual(value, 402); - XCTAssertTrue([dict valueForKey:@"mumble" value:NULL]); - XCTAssertTrue([dict valueForKey:@"mumble" value:&value]); + XCTAssertTrue([dict getInt64:NULL forKey:@"mumble"]); + XCTAssertTrue([dict getInt64:&value forKey:@"mumble"]); XCTAssertEqual(value, 403); [dict2 release]; } @@ -1376,57 +1376,57 @@ static BOOL TestingEnum_IsValidValue(int32_t value) { const NSString *kKeys[] = { @"foo", @"bar", @"baz", @"mumble" }; const int64_t kValues[] = { 400, 401, 402, 403 }; GPBStringInt64Dictionary *dict = - [[GPBStringInt64Dictionary alloc] initWithValues:kValues - forKeys:kKeys - count:GPBARRAYSIZE(kValues)]; + [[GPBStringInt64Dictionary alloc] initWithInt64s:kValues + forKeys:kKeys + count:GPBARRAYSIZE(kValues)]; XCTAssertNotNil(dict); XCTAssertEqual(dict.count, 4U); - [dict removeValueForKey:@"bar"]; + [dict removeInt64ForKey:@"bar"]; XCTAssertEqual(dict.count, 3U); int64_t value; - XCTAssertTrue([dict valueForKey:@"foo" value:NULL]); - XCTAssertTrue([dict valueForKey:@"foo" value:&value]); + XCTAssertTrue([dict getInt64:NULL forKey:@"foo"]); + XCTAssertTrue([dict getInt64:&value forKey:@"foo"]); XCTAssertEqual(value, 400); - XCTAssertFalse([dict valueForKey:@"bar" value:NULL]); - XCTAssertTrue([dict valueForKey:@"baz" value:NULL]); - XCTAssertTrue([dict valueForKey:@"baz" value:&value]); + XCTAssertFalse([dict getInt64:NULL forKey:@"bar"]); + XCTAssertTrue([dict getInt64:NULL forKey:@"baz"]); + XCTAssertTrue([dict getInt64:&value forKey:@"baz"]); XCTAssertEqual(value, 402); - XCTAssertTrue([dict valueForKey:@"mumble" value:NULL]); - XCTAssertTrue([dict valueForKey:@"mumble" value:&value]); + XCTAssertTrue([dict getInt64:NULL forKey:@"mumble"]); + XCTAssertTrue([dict getInt64:&value forKey:@"mumble"]); XCTAssertEqual(value, 403); // Remove again does nothing. - [dict removeValueForKey:@"bar"]; + [dict removeInt64ForKey:@"bar"]; XCTAssertEqual(dict.count, 3U); - XCTAssertTrue([dict valueForKey:@"foo" value:NULL]); - XCTAssertTrue([dict valueForKey:@"foo" value:&value]); + XCTAssertTrue([dict getInt64:NULL forKey:@"foo"]); + XCTAssertTrue([dict getInt64:&value forKey:@"foo"]); XCTAssertEqual(value, 400); - XCTAssertFalse([dict valueForKey:@"bar" value:NULL]); - XCTAssertTrue([dict valueForKey:@"baz" value:NULL]); - XCTAssertTrue([dict valueForKey:@"baz" value:&value]); + XCTAssertFalse([dict getInt64:NULL forKey:@"bar"]); + XCTAssertTrue([dict getInt64:NULL forKey:@"baz"]); + XCTAssertTrue([dict getInt64:&value forKey:@"baz"]); XCTAssertEqual(value, 402); - XCTAssertTrue([dict valueForKey:@"mumble" value:NULL]); - XCTAssertTrue([dict valueForKey:@"mumble" value:&value]); + XCTAssertTrue([dict getInt64:NULL forKey:@"mumble"]); + XCTAssertTrue([dict getInt64:&value forKey:@"mumble"]); XCTAssertEqual(value, 403); - [dict removeValueForKey:@"mumble"]; + [dict removeInt64ForKey:@"mumble"]; XCTAssertEqual(dict.count, 2U); - XCTAssertTrue([dict valueForKey:@"foo" value:NULL]); - XCTAssertTrue([dict valueForKey:@"foo" value:&value]); + XCTAssertTrue([dict getInt64:NULL forKey:@"foo"]); + XCTAssertTrue([dict getInt64:&value forKey:@"foo"]); XCTAssertEqual(value, 400); - XCTAssertFalse([dict valueForKey:@"bar" value:NULL]); - XCTAssertTrue([dict valueForKey:@"baz" value:NULL]); - XCTAssertTrue([dict valueForKey:@"baz" value:&value]); + XCTAssertFalse([dict getInt64:NULL forKey:@"bar"]); + XCTAssertTrue([dict getInt64:NULL forKey:@"baz"]); + XCTAssertTrue([dict getInt64:&value forKey:@"baz"]); XCTAssertEqual(value, 402); - XCTAssertFalse([dict valueForKey:@"mumble" value:NULL]); + XCTAssertFalse([dict getInt64:NULL forKey:@"mumble"]); [dict removeAll]; XCTAssertEqual(dict.count, 0U); - XCTAssertFalse([dict valueForKey:@"foo" value:NULL]); - XCTAssertFalse([dict valueForKey:@"bar" value:NULL]); - XCTAssertFalse([dict valueForKey:@"baz" value:NULL]); - XCTAssertFalse([dict valueForKey:@"mumble" value:NULL]); + XCTAssertFalse([dict getInt64:NULL forKey:@"foo"]); + XCTAssertFalse([dict getInt64:NULL forKey:@"bar"]); + XCTAssertFalse([dict getInt64:NULL forKey:@"baz"]); + XCTAssertFalse([dict getInt64:NULL forKey:@"mumble"]); [dict release]; } @@ -1434,75 +1434,75 @@ static BOOL TestingEnum_IsValidValue(int32_t value) { const NSString *kKeys[] = { @"foo", @"bar", @"baz", @"mumble" }; const int64_t kValues[] = { 400, 401, 402, 403 }; GPBStringInt64Dictionary *dict = - [[GPBStringInt64Dictionary alloc] initWithValues:kValues - forKeys:kKeys - count:GPBARRAYSIZE(kValues)]; + [[GPBStringInt64Dictionary alloc] initWithInt64s:kValues + forKeys:kKeys + count:GPBARRAYSIZE(kValues)]; XCTAssertNotNil(dict); XCTAssertEqual(dict.count, 4U); int64_t value; - XCTAssertTrue([dict valueForKey:@"foo" value:NULL]); - XCTAssertTrue([dict valueForKey:@"foo" value:&value]); + XCTAssertTrue([dict getInt64:NULL forKey:@"foo"]); + XCTAssertTrue([dict getInt64:&value forKey:@"foo"]); XCTAssertEqual(value, 400); - XCTAssertTrue([dict valueForKey:@"bar" value:NULL]); - XCTAssertTrue([dict valueForKey:@"bar" value:&value]); + XCTAssertTrue([dict getInt64:NULL forKey:@"bar"]); + XCTAssertTrue([dict getInt64:&value forKey:@"bar"]); XCTAssertEqual(value, 401); - XCTAssertTrue([dict valueForKey:@"baz" value:NULL]); - XCTAssertTrue([dict valueForKey:@"baz" value:&value]); + XCTAssertTrue([dict getInt64:NULL forKey:@"baz"]); + XCTAssertTrue([dict getInt64:&value forKey:@"baz"]); XCTAssertEqual(value, 402); - XCTAssertTrue([dict valueForKey:@"mumble" value:NULL]); - XCTAssertTrue([dict valueForKey:@"mumble" value:&value]); + XCTAssertTrue([dict getInt64:NULL forKey:@"mumble"]); + XCTAssertTrue([dict getInt64:&value forKey:@"mumble"]); XCTAssertEqual(value, 403); - [dict setValue:403 forKey:@"foo"]; + [dict setInt64:403 forKey:@"foo"]; XCTAssertEqual(dict.count, 4U); - XCTAssertTrue([dict valueForKey:@"foo" value:NULL]); - XCTAssertTrue([dict valueForKey:@"foo" value:&value]); + XCTAssertTrue([dict getInt64:NULL forKey:@"foo"]); + XCTAssertTrue([dict getInt64:&value forKey:@"foo"]); XCTAssertEqual(value, 403); - XCTAssertTrue([dict valueForKey:@"bar" value:NULL]); - XCTAssertTrue([dict valueForKey:@"bar" value:&value]); + XCTAssertTrue([dict getInt64:NULL forKey:@"bar"]); + XCTAssertTrue([dict getInt64:&value forKey:@"bar"]); XCTAssertEqual(value, 401); - XCTAssertTrue([dict valueForKey:@"baz" value:NULL]); - XCTAssertTrue([dict valueForKey:@"baz" value:&value]); + XCTAssertTrue([dict getInt64:NULL forKey:@"baz"]); + XCTAssertTrue([dict getInt64:&value forKey:@"baz"]); XCTAssertEqual(value, 402); - XCTAssertTrue([dict valueForKey:@"mumble" value:NULL]); - XCTAssertTrue([dict valueForKey:@"mumble" value:&value]); + XCTAssertTrue([dict getInt64:NULL forKey:@"mumble"]); + XCTAssertTrue([dict getInt64:&value forKey:@"mumble"]); XCTAssertEqual(value, 403); - [dict setValue:401 forKey:@"mumble"]; + [dict setInt64:401 forKey:@"mumble"]; XCTAssertEqual(dict.count, 4U); - XCTAssertTrue([dict valueForKey:@"foo" value:NULL]); - XCTAssertTrue([dict valueForKey:@"foo" value:&value]); + XCTAssertTrue([dict getInt64:NULL forKey:@"foo"]); + XCTAssertTrue([dict getInt64:&value forKey:@"foo"]); XCTAssertEqual(value, 403); - XCTAssertTrue([dict valueForKey:@"bar" value:NULL]); - XCTAssertTrue([dict valueForKey:@"bar" value:&value]); + XCTAssertTrue([dict getInt64:NULL forKey:@"bar"]); + XCTAssertTrue([dict getInt64:&value forKey:@"bar"]); XCTAssertEqual(value, 401); - XCTAssertTrue([dict valueForKey:@"baz" value:NULL]); - XCTAssertTrue([dict valueForKey:@"baz" value:&value]); + XCTAssertTrue([dict getInt64:NULL forKey:@"baz"]); + XCTAssertTrue([dict getInt64:&value forKey:@"baz"]); XCTAssertEqual(value, 402); - XCTAssertTrue([dict valueForKey:@"mumble" value:NULL]); - XCTAssertTrue([dict valueForKey:@"mumble" value:&value]); + XCTAssertTrue([dict getInt64:NULL forKey:@"mumble"]); + XCTAssertTrue([dict getInt64:&value forKey:@"mumble"]); XCTAssertEqual(value, 401); const NSString *kKeys2[] = { @"bar", @"baz" }; const int64_t kValues2[] = { 402, 400 }; GPBStringInt64Dictionary *dict2 = - [[GPBStringInt64Dictionary alloc] initWithValues:kValues2 + [[GPBStringInt64Dictionary alloc] initWithInt64s:kValues2 forKeys:kKeys2 count:GPBARRAYSIZE(kValues2)]; XCTAssertNotNil(dict2); [dict addEntriesFromDictionary:dict2]; XCTAssertEqual(dict.count, 4U); - XCTAssertTrue([dict valueForKey:@"foo" value:NULL]); - XCTAssertTrue([dict valueForKey:@"foo" value:&value]); + XCTAssertTrue([dict getInt64:NULL forKey:@"foo"]); + XCTAssertTrue([dict getInt64:&value forKey:@"foo"]); XCTAssertEqual(value, 403); - XCTAssertTrue([dict valueForKey:@"bar" value:NULL]); - XCTAssertTrue([dict valueForKey:@"bar" value:&value]); + XCTAssertTrue([dict getInt64:NULL forKey:@"bar"]); + XCTAssertTrue([dict getInt64:&value forKey:@"bar"]); XCTAssertEqual(value, 402); - XCTAssertTrue([dict valueForKey:@"baz" value:NULL]); - XCTAssertTrue([dict valueForKey:@"baz" value:&value]); + XCTAssertTrue([dict getInt64:NULL forKey:@"baz"]); + XCTAssertTrue([dict getInt64:&value forKey:@"baz"]); XCTAssertEqual(value, 400); - XCTAssertTrue([dict valueForKey:@"mumble" value:NULL]); - XCTAssertTrue([dict valueForKey:@"mumble" value:&value]); + XCTAssertTrue([dict getInt64:NULL forKey:@"mumble"]); + XCTAssertTrue([dict getInt64:&value forKey:@"mumble"]); XCTAssertEqual(value, 401); [dict2 release]; @@ -1522,8 +1522,8 @@ static BOOL TestingEnum_IsValidValue(int32_t value) { GPBStringBoolDictionary *dict = [[GPBStringBoolDictionary alloc] init]; XCTAssertNotNil(dict); XCTAssertEqual(dict.count, 0U); - XCTAssertFalse([dict valueForKey:@"foo" value:NULL]); - [dict enumerateKeysAndValuesUsingBlock:^(NSString *aKey, BOOL aValue, BOOL *stop) { + XCTAssertFalse([dict getBool:NULL forKey:@"foo"]); + [dict enumerateKeysAndBoolsUsingBlock:^(NSString *aKey, BOOL aValue, BOOL *stop) { #pragma unused(aKey, aValue, stop) XCTFail(@"Shouldn't get here!"); }]; @@ -1531,15 +1531,15 @@ static BOOL TestingEnum_IsValidValue(int32_t value) { } - (void)testOne { - GPBStringBoolDictionary *dict = [GPBStringBoolDictionary dictionaryWithValue:YES forKey:@"foo"]; + GPBStringBoolDictionary *dict = [GPBStringBoolDictionary dictionaryWithBool:YES forKey:@"foo"]; XCTAssertNotNil(dict); XCTAssertEqual(dict.count, 1U); BOOL value; - XCTAssertTrue([dict valueForKey:@"foo" value:NULL]); - XCTAssertTrue([dict valueForKey:@"foo" value:&value]); + XCTAssertTrue([dict getBool:NULL forKey:@"foo"]); + XCTAssertTrue([dict getBool:&value forKey:@"foo"]); XCTAssertEqual(value, YES); - XCTAssertFalse([dict valueForKey:@"bar" value:NULL]); - [dict enumerateKeysAndValuesUsingBlock:^(NSString *aKey, BOOL aValue, BOOL *stop) { + XCTAssertFalse([dict getBool:NULL forKey:@"bar"]); + [dict enumerateKeysAndBoolsUsingBlock:^(NSString *aKey, BOOL aValue, BOOL *stop) { XCTAssertEqualObjects(aKey, @"foo"); XCTAssertEqual(aValue, YES); XCTAssertNotEqual(stop, NULL); @@ -1550,27 +1550,27 @@ static BOOL TestingEnum_IsValidValue(int32_t value) { const NSString *kKeys[] = { @"foo", @"bar", @"baz" }; const BOOL kValues[] = { YES, YES, NO }; GPBStringBoolDictionary *dict = - [[GPBStringBoolDictionary alloc] initWithValues:kValues - forKeys:kKeys - count:GPBARRAYSIZE(kValues)]; + [[GPBStringBoolDictionary alloc] initWithBools:kValues + forKeys:kKeys + count:GPBARRAYSIZE(kValues)]; XCTAssertNotNil(dict); XCTAssertEqual(dict.count, 3U); BOOL value; - XCTAssertTrue([dict valueForKey:@"foo" value:NULL]); - XCTAssertTrue([dict valueForKey:@"foo" value:&value]); + XCTAssertTrue([dict getBool:NULL forKey:@"foo"]); + XCTAssertTrue([dict getBool:&value forKey:@"foo"]); XCTAssertEqual(value, YES); - XCTAssertTrue([dict valueForKey:@"bar" value:NULL]); - XCTAssertTrue([dict valueForKey:@"bar" value:&value]); + XCTAssertTrue([dict getBool:NULL forKey:@"bar"]); + XCTAssertTrue([dict getBool:&value forKey:@"bar"]); XCTAssertEqual(value, YES); - XCTAssertTrue([dict valueForKey:@"baz" value:NULL]); - XCTAssertTrue([dict valueForKey:@"baz" value:&value]); + XCTAssertTrue([dict getBool:NULL forKey:@"baz"]); + XCTAssertTrue([dict getBool:&value forKey:@"baz"]); XCTAssertEqual(value, NO); - XCTAssertFalse([dict valueForKey:@"mumble" value:NULL]); + XCTAssertFalse([dict getBool:NULL forKey:@"mumble"]); __block NSUInteger idx = 0; NSString **seenKeys = malloc(3 * sizeof(NSString*)); BOOL *seenValues = malloc(3 * sizeof(BOOL)); - [dict enumerateKeysAndValuesUsingBlock:^(NSString *aKey, BOOL aValue, BOOL *stop) { + [dict enumerateKeysAndBoolsUsingBlock:^(NSString *aKey, BOOL aValue, BOOL *stop) { XCTAssertLessThan(idx, 3U); seenKeys[idx] = aKey; seenValues[idx] = aValue; @@ -1592,7 +1592,7 @@ static BOOL TestingEnum_IsValidValue(int32_t value) { // Stopping the enumeration. idx = 0; - [dict enumerateKeysAndValuesUsingBlock:^(NSString *aKey, BOOL aValue, BOOL *stop) { + [dict enumerateKeysAndBoolsUsingBlock:^(NSString *aKey, BOOL aValue, BOOL *stop) { #pragma unused(aKey, aValue) if (idx == 1) *stop = YES; XCTAssertNotEqual(idx, 2U); @@ -1608,29 +1608,29 @@ static BOOL TestingEnum_IsValidValue(int32_t value) { const BOOL kValues2[] = { YES, NO, NO }; const BOOL kValues3[] = { YES, YES, NO, NO }; GPBStringBoolDictionary *dict1 = - [[GPBStringBoolDictionary alloc] initWithValues:kValues1 - forKeys:kKeys1 - count:GPBARRAYSIZE(kValues1)]; + [[GPBStringBoolDictionary alloc] initWithBools:kValues1 + forKeys:kKeys1 + count:GPBARRAYSIZE(kValues1)]; XCTAssertNotNil(dict1); GPBStringBoolDictionary *dict1prime = - [[GPBStringBoolDictionary alloc] initWithValues:kValues1 - forKeys:kKeys1 - count:GPBARRAYSIZE(kValues1)]; + [[GPBStringBoolDictionary alloc] initWithBools:kValues1 + forKeys:kKeys1 + count:GPBARRAYSIZE(kValues1)]; XCTAssertNotNil(dict1prime); GPBStringBoolDictionary *dict2 = - [[GPBStringBoolDictionary alloc] initWithValues:kValues2 - forKeys:kKeys1 - count:GPBARRAYSIZE(kValues2)]; + [[GPBStringBoolDictionary alloc] initWithBools:kValues2 + forKeys:kKeys1 + count:GPBARRAYSIZE(kValues2)]; XCTAssertNotNil(dict2); GPBStringBoolDictionary *dict3 = - [[GPBStringBoolDictionary alloc] initWithValues:kValues1 - forKeys:kKeys2 - count:GPBARRAYSIZE(kValues1)]; + [[GPBStringBoolDictionary alloc] initWithBools:kValues1 + forKeys:kKeys2 + count:GPBARRAYSIZE(kValues1)]; XCTAssertNotNil(dict3); GPBStringBoolDictionary *dict4 = - [[GPBStringBoolDictionary alloc] initWithValues:kValues3 - forKeys:kKeys1 - count:GPBARRAYSIZE(kValues3)]; + [[GPBStringBoolDictionary alloc] initWithBools:kValues3 + forKeys:kKeys1 + count:GPBARRAYSIZE(kValues3)]; XCTAssertNotNil(dict4); // 1/1Prime should be different objects, but equal. @@ -1659,9 +1659,9 @@ static BOOL TestingEnum_IsValidValue(int32_t value) { const NSString *kKeys[] = { @"foo", @"bar", @"baz", @"mumble" }; const BOOL kValues[] = { YES, YES, NO, NO }; GPBStringBoolDictionary *dict = - [[GPBStringBoolDictionary alloc] initWithValues:kValues - forKeys:kKeys - count:GPBARRAYSIZE(kValues)]; + [[GPBStringBoolDictionary alloc] initWithBools:kValues + forKeys:kKeys + count:GPBARRAYSIZE(kValues)]; XCTAssertNotNil(dict); GPBStringBoolDictionary *dict2 = [dict copy]; @@ -1680,9 +1680,9 @@ static BOOL TestingEnum_IsValidValue(int32_t value) { const NSString *kKeys[] = { @"foo", @"bar", @"baz", @"mumble" }; const BOOL kValues[] = { YES, YES, NO, NO }; GPBStringBoolDictionary *dict = - [[GPBStringBoolDictionary alloc] initWithValues:kValues - forKeys:kKeys - count:GPBARRAYSIZE(kValues)]; + [[GPBStringBoolDictionary alloc] initWithBools:kValues + forKeys:kKeys + count:GPBARRAYSIZE(kValues)]; XCTAssertNotNil(dict); GPBStringBoolDictionary *dict2 = @@ -1700,31 +1700,31 @@ static BOOL TestingEnum_IsValidValue(int32_t value) { XCTAssertNotNil(dict); XCTAssertEqual(dict.count, 0U); - [dict setValue:YES forKey:@"foo"]; + [dict setBool:YES forKey:@"foo"]; XCTAssertEqual(dict.count, 1U); const NSString *kKeys[] = { @"bar", @"baz", @"mumble" }; const BOOL kValues[] = { YES, NO, NO }; GPBStringBoolDictionary *dict2 = - [[GPBStringBoolDictionary alloc] initWithValues:kValues - forKeys:kKeys - count:GPBARRAYSIZE(kValues)]; + [[GPBStringBoolDictionary alloc] initWithBools:kValues + forKeys:kKeys + count:GPBARRAYSIZE(kValues)]; XCTAssertNotNil(dict2); [dict addEntriesFromDictionary:dict2]; XCTAssertEqual(dict.count, 4U); BOOL value; - XCTAssertTrue([dict valueForKey:@"foo" value:NULL]); - XCTAssertTrue([dict valueForKey:@"foo" value:&value]); + XCTAssertTrue([dict getBool:NULL forKey:@"foo"]); + XCTAssertTrue([dict getBool:&value forKey:@"foo"]); XCTAssertEqual(value, YES); - XCTAssertTrue([dict valueForKey:@"bar" value:NULL]); - XCTAssertTrue([dict valueForKey:@"bar" value:&value]); + XCTAssertTrue([dict getBool:NULL forKey:@"bar"]); + XCTAssertTrue([dict getBool:&value forKey:@"bar"]); XCTAssertEqual(value, YES); - XCTAssertTrue([dict valueForKey:@"baz" value:NULL]); - XCTAssertTrue([dict valueForKey:@"baz" value:&value]); + XCTAssertTrue([dict getBool:NULL forKey:@"baz"]); + XCTAssertTrue([dict getBool:&value forKey:@"baz"]); XCTAssertEqual(value, NO); - XCTAssertTrue([dict valueForKey:@"mumble" value:NULL]); - XCTAssertTrue([dict valueForKey:@"mumble" value:&value]); + XCTAssertTrue([dict getBool:NULL forKey:@"mumble"]); + XCTAssertTrue([dict getBool:&value forKey:@"mumble"]); XCTAssertEqual(value, NO); [dict2 release]; } @@ -1733,57 +1733,57 @@ static BOOL TestingEnum_IsValidValue(int32_t value) { const NSString *kKeys[] = { @"foo", @"bar", @"baz", @"mumble" }; const BOOL kValues[] = { YES, YES, NO, NO }; GPBStringBoolDictionary *dict = - [[GPBStringBoolDictionary alloc] initWithValues:kValues - forKeys:kKeys - count:GPBARRAYSIZE(kValues)]; + [[GPBStringBoolDictionary alloc] initWithBools:kValues + forKeys:kKeys + count:GPBARRAYSIZE(kValues)]; XCTAssertNotNil(dict); XCTAssertEqual(dict.count, 4U); - [dict removeValueForKey:@"bar"]; + [dict removeBoolForKey:@"bar"]; XCTAssertEqual(dict.count, 3U); BOOL value; - XCTAssertTrue([dict valueForKey:@"foo" value:NULL]); - XCTAssertTrue([dict valueForKey:@"foo" value:&value]); + XCTAssertTrue([dict getBool:NULL forKey:@"foo"]); + XCTAssertTrue([dict getBool:&value forKey:@"foo"]); XCTAssertEqual(value, YES); - XCTAssertFalse([dict valueForKey:@"bar" value:NULL]); - XCTAssertTrue([dict valueForKey:@"baz" value:NULL]); - XCTAssertTrue([dict valueForKey:@"baz" value:&value]); + XCTAssertFalse([dict getBool:NULL forKey:@"bar"]); + XCTAssertTrue([dict getBool:NULL forKey:@"baz"]); + XCTAssertTrue([dict getBool:&value forKey:@"baz"]); XCTAssertEqual(value, NO); - XCTAssertTrue([dict valueForKey:@"mumble" value:NULL]); - XCTAssertTrue([dict valueForKey:@"mumble" value:&value]); + XCTAssertTrue([dict getBool:NULL forKey:@"mumble"]); + XCTAssertTrue([dict getBool:&value forKey:@"mumble"]); XCTAssertEqual(value, NO); // Remove again does nothing. - [dict removeValueForKey:@"bar"]; + [dict removeBoolForKey:@"bar"]; XCTAssertEqual(dict.count, 3U); - XCTAssertTrue([dict valueForKey:@"foo" value:NULL]); - XCTAssertTrue([dict valueForKey:@"foo" value:&value]); + XCTAssertTrue([dict getBool:NULL forKey:@"foo"]); + XCTAssertTrue([dict getBool:&value forKey:@"foo"]); XCTAssertEqual(value, YES); - XCTAssertFalse([dict valueForKey:@"bar" value:NULL]); - XCTAssertTrue([dict valueForKey:@"baz" value:NULL]); - XCTAssertTrue([dict valueForKey:@"baz" value:&value]); + XCTAssertFalse([dict getBool:NULL forKey:@"bar"]); + XCTAssertTrue([dict getBool:NULL forKey:@"baz"]); + XCTAssertTrue([dict getBool:&value forKey:@"baz"]); XCTAssertEqual(value, NO); - XCTAssertTrue([dict valueForKey:@"mumble" value:NULL]); - XCTAssertTrue([dict valueForKey:@"mumble" value:&value]); + XCTAssertTrue([dict getBool:NULL forKey:@"mumble"]); + XCTAssertTrue([dict getBool:&value forKey:@"mumble"]); XCTAssertEqual(value, NO); - [dict removeValueForKey:@"mumble"]; + [dict removeBoolForKey:@"mumble"]; XCTAssertEqual(dict.count, 2U); - XCTAssertTrue([dict valueForKey:@"foo" value:NULL]); - XCTAssertTrue([dict valueForKey:@"foo" value:&value]); + XCTAssertTrue([dict getBool:NULL forKey:@"foo"]); + XCTAssertTrue([dict getBool:&value forKey:@"foo"]); XCTAssertEqual(value, YES); - XCTAssertFalse([dict valueForKey:@"bar" value:NULL]); - XCTAssertTrue([dict valueForKey:@"baz" value:NULL]); - XCTAssertTrue([dict valueForKey:@"baz" value:&value]); + XCTAssertFalse([dict getBool:NULL forKey:@"bar"]); + XCTAssertTrue([dict getBool:NULL forKey:@"baz"]); + XCTAssertTrue([dict getBool:&value forKey:@"baz"]); XCTAssertEqual(value, NO); - XCTAssertFalse([dict valueForKey:@"mumble" value:NULL]); + XCTAssertFalse([dict getBool:NULL forKey:@"mumble"]); [dict removeAll]; XCTAssertEqual(dict.count, 0U); - XCTAssertFalse([dict valueForKey:@"foo" value:NULL]); - XCTAssertFalse([dict valueForKey:@"bar" value:NULL]); - XCTAssertFalse([dict valueForKey:@"baz" value:NULL]); - XCTAssertFalse([dict valueForKey:@"mumble" value:NULL]); + XCTAssertFalse([dict getBool:NULL forKey:@"foo"]); + XCTAssertFalse([dict getBool:NULL forKey:@"bar"]); + XCTAssertFalse([dict getBool:NULL forKey:@"baz"]); + XCTAssertFalse([dict getBool:NULL forKey:@"mumble"]); [dict release]; } @@ -1791,75 +1791,75 @@ static BOOL TestingEnum_IsValidValue(int32_t value) { const NSString *kKeys[] = { @"foo", @"bar", @"baz", @"mumble" }; const BOOL kValues[] = { YES, YES, NO, NO }; GPBStringBoolDictionary *dict = - [[GPBStringBoolDictionary alloc] initWithValues:kValues - forKeys:kKeys - count:GPBARRAYSIZE(kValues)]; + [[GPBStringBoolDictionary alloc] initWithBools:kValues + forKeys:kKeys + count:GPBARRAYSIZE(kValues)]; XCTAssertNotNil(dict); XCTAssertEqual(dict.count, 4U); BOOL value; - XCTAssertTrue([dict valueForKey:@"foo" value:NULL]); - XCTAssertTrue([dict valueForKey:@"foo" value:&value]); + XCTAssertTrue([dict getBool:NULL forKey:@"foo"]); + XCTAssertTrue([dict getBool:&value forKey:@"foo"]); XCTAssertEqual(value, YES); - XCTAssertTrue([dict valueForKey:@"bar" value:NULL]); - XCTAssertTrue([dict valueForKey:@"bar" value:&value]); + XCTAssertTrue([dict getBool:NULL forKey:@"bar"]); + XCTAssertTrue([dict getBool:&value forKey:@"bar"]); XCTAssertEqual(value, YES); - XCTAssertTrue([dict valueForKey:@"baz" value:NULL]); - XCTAssertTrue([dict valueForKey:@"baz" value:&value]); + XCTAssertTrue([dict getBool:NULL forKey:@"baz"]); + XCTAssertTrue([dict getBool:&value forKey:@"baz"]); XCTAssertEqual(value, NO); - XCTAssertTrue([dict valueForKey:@"mumble" value:NULL]); - XCTAssertTrue([dict valueForKey:@"mumble" value:&value]); + XCTAssertTrue([dict getBool:NULL forKey:@"mumble"]); + XCTAssertTrue([dict getBool:&value forKey:@"mumble"]); XCTAssertEqual(value, NO); - [dict setValue:NO forKey:@"foo"]; + [dict setBool:NO forKey:@"foo"]; XCTAssertEqual(dict.count, 4U); - XCTAssertTrue([dict valueForKey:@"foo" value:NULL]); - XCTAssertTrue([dict valueForKey:@"foo" value:&value]); + XCTAssertTrue([dict getBool:NULL forKey:@"foo"]); + XCTAssertTrue([dict getBool:&value forKey:@"foo"]); XCTAssertEqual(value, NO); - XCTAssertTrue([dict valueForKey:@"bar" value:NULL]); - XCTAssertTrue([dict valueForKey:@"bar" value:&value]); + XCTAssertTrue([dict getBool:NULL forKey:@"bar"]); + XCTAssertTrue([dict getBool:&value forKey:@"bar"]); XCTAssertEqual(value, YES); - XCTAssertTrue([dict valueForKey:@"baz" value:NULL]); - XCTAssertTrue([dict valueForKey:@"baz" value:&value]); + XCTAssertTrue([dict getBool:NULL forKey:@"baz"]); + XCTAssertTrue([dict getBool:&value forKey:@"baz"]); XCTAssertEqual(value, NO); - XCTAssertTrue([dict valueForKey:@"mumble" value:NULL]); - XCTAssertTrue([dict valueForKey:@"mumble" value:&value]); + XCTAssertTrue([dict getBool:NULL forKey:@"mumble"]); + XCTAssertTrue([dict getBool:&value forKey:@"mumble"]); XCTAssertEqual(value, NO); - [dict setValue:YES forKey:@"mumble"]; + [dict setBool:YES forKey:@"mumble"]; XCTAssertEqual(dict.count, 4U); - XCTAssertTrue([dict valueForKey:@"foo" value:NULL]); - XCTAssertTrue([dict valueForKey:@"foo" value:&value]); + XCTAssertTrue([dict getBool:NULL forKey:@"foo"]); + XCTAssertTrue([dict getBool:&value forKey:@"foo"]); XCTAssertEqual(value, NO); - XCTAssertTrue([dict valueForKey:@"bar" value:NULL]); - XCTAssertTrue([dict valueForKey:@"bar" value:&value]); + XCTAssertTrue([dict getBool:NULL forKey:@"bar"]); + XCTAssertTrue([dict getBool:&value forKey:@"bar"]); XCTAssertEqual(value, YES); - XCTAssertTrue([dict valueForKey:@"baz" value:NULL]); - XCTAssertTrue([dict valueForKey:@"baz" value:&value]); + XCTAssertTrue([dict getBool:NULL forKey:@"baz"]); + XCTAssertTrue([dict getBool:&value forKey:@"baz"]); XCTAssertEqual(value, NO); - XCTAssertTrue([dict valueForKey:@"mumble" value:NULL]); - XCTAssertTrue([dict valueForKey:@"mumble" value:&value]); + XCTAssertTrue([dict getBool:NULL forKey:@"mumble"]); + XCTAssertTrue([dict getBool:&value forKey:@"mumble"]); XCTAssertEqual(value, YES); const NSString *kKeys2[] = { @"bar", @"baz" }; const BOOL kValues2[] = { NO, YES }; GPBStringBoolDictionary *dict2 = - [[GPBStringBoolDictionary alloc] initWithValues:kValues2 - forKeys:kKeys2 - count:GPBARRAYSIZE(kValues2)]; + [[GPBStringBoolDictionary alloc] initWithBools:kValues2 + forKeys:kKeys2 + count:GPBARRAYSIZE(kValues2)]; XCTAssertNotNil(dict2); [dict addEntriesFromDictionary:dict2]; XCTAssertEqual(dict.count, 4U); - XCTAssertTrue([dict valueForKey:@"foo" value:NULL]); - XCTAssertTrue([dict valueForKey:@"foo" value:&value]); + XCTAssertTrue([dict getBool:NULL forKey:@"foo"]); + XCTAssertTrue([dict getBool:&value forKey:@"foo"]); XCTAssertEqual(value, NO); - XCTAssertTrue([dict valueForKey:@"bar" value:NULL]); - XCTAssertTrue([dict valueForKey:@"bar" value:&value]); + XCTAssertTrue([dict getBool:NULL forKey:@"bar"]); + XCTAssertTrue([dict getBool:&value forKey:@"bar"]); XCTAssertEqual(value, NO); - XCTAssertTrue([dict valueForKey:@"baz" value:NULL]); - XCTAssertTrue([dict valueForKey:@"baz" value:&value]); + XCTAssertTrue([dict getBool:NULL forKey:@"baz"]); + XCTAssertTrue([dict getBool:&value forKey:@"baz"]); XCTAssertEqual(value, YES); - XCTAssertTrue([dict valueForKey:@"mumble" value:NULL]); - XCTAssertTrue([dict valueForKey:@"mumble" value:&value]); + XCTAssertTrue([dict getBool:NULL forKey:@"mumble"]); + XCTAssertTrue([dict getBool:&value forKey:@"mumble"]); XCTAssertEqual(value, YES); [dict2 release]; @@ -1879,8 +1879,8 @@ static BOOL TestingEnum_IsValidValue(int32_t value) { GPBStringFloatDictionary *dict = [[GPBStringFloatDictionary alloc] init]; XCTAssertNotNil(dict); XCTAssertEqual(dict.count, 0U); - XCTAssertFalse([dict valueForKey:@"foo" value:NULL]); - [dict enumerateKeysAndValuesUsingBlock:^(NSString *aKey, float aValue, BOOL *stop) { + XCTAssertFalse([dict getFloat:NULL forKey:@"foo"]); + [dict enumerateKeysAndFloatsUsingBlock:^(NSString *aKey, float aValue, BOOL *stop) { #pragma unused(aKey, aValue, stop) XCTFail(@"Shouldn't get here!"); }]; @@ -1888,15 +1888,15 @@ static BOOL TestingEnum_IsValidValue(int32_t value) { } - (void)testOne { - GPBStringFloatDictionary *dict = [GPBStringFloatDictionary dictionaryWithValue:500.f forKey:@"foo"]; + GPBStringFloatDictionary *dict = [GPBStringFloatDictionary dictionaryWithFloat:500.f forKey:@"foo"]; XCTAssertNotNil(dict); XCTAssertEqual(dict.count, 1U); float value; - XCTAssertTrue([dict valueForKey:@"foo" value:NULL]); - XCTAssertTrue([dict valueForKey:@"foo" value:&value]); + XCTAssertTrue([dict getFloat:NULL forKey:@"foo"]); + XCTAssertTrue([dict getFloat:&value forKey:@"foo"]); XCTAssertEqual(value, 500.f); - XCTAssertFalse([dict valueForKey:@"bar" value:NULL]); - [dict enumerateKeysAndValuesUsingBlock:^(NSString *aKey, float aValue, BOOL *stop) { + XCTAssertFalse([dict getFloat:NULL forKey:@"bar"]); + [dict enumerateKeysAndFloatsUsingBlock:^(NSString *aKey, float aValue, BOOL *stop) { XCTAssertEqualObjects(aKey, @"foo"); XCTAssertEqual(aValue, 500.f); XCTAssertNotEqual(stop, NULL); @@ -1907,27 +1907,27 @@ static BOOL TestingEnum_IsValidValue(int32_t value) { const NSString *kKeys[] = { @"foo", @"bar", @"baz" }; const float kValues[] = { 500.f, 501.f, 502.f }; GPBStringFloatDictionary *dict = - [[GPBStringFloatDictionary alloc] initWithValues:kValues + [[GPBStringFloatDictionary alloc] initWithFloats:kValues forKeys:kKeys count:GPBARRAYSIZE(kValues)]; XCTAssertNotNil(dict); XCTAssertEqual(dict.count, 3U); float value; - XCTAssertTrue([dict valueForKey:@"foo" value:NULL]); - XCTAssertTrue([dict valueForKey:@"foo" value:&value]); + XCTAssertTrue([dict getFloat:NULL forKey:@"foo"]); + XCTAssertTrue([dict getFloat:&value forKey:@"foo"]); XCTAssertEqual(value, 500.f); - XCTAssertTrue([dict valueForKey:@"bar" value:NULL]); - XCTAssertTrue([dict valueForKey:@"bar" value:&value]); + XCTAssertTrue([dict getFloat:NULL forKey:@"bar"]); + XCTAssertTrue([dict getFloat:&value forKey:@"bar"]); XCTAssertEqual(value, 501.f); - XCTAssertTrue([dict valueForKey:@"baz" value:NULL]); - XCTAssertTrue([dict valueForKey:@"baz" value:&value]); + XCTAssertTrue([dict getFloat:NULL forKey:@"baz"]); + XCTAssertTrue([dict getFloat:&value forKey:@"baz"]); XCTAssertEqual(value, 502.f); - XCTAssertFalse([dict valueForKey:@"mumble" value:NULL]); + XCTAssertFalse([dict getFloat:NULL forKey:@"mumble"]); __block NSUInteger idx = 0; NSString **seenKeys = malloc(3 * sizeof(NSString*)); float *seenValues = malloc(3 * sizeof(float)); - [dict enumerateKeysAndValuesUsingBlock:^(NSString *aKey, float aValue, BOOL *stop) { + [dict enumerateKeysAndFloatsUsingBlock:^(NSString *aKey, float aValue, BOOL *stop) { XCTAssertLessThan(idx, 3U); seenKeys[idx] = aKey; seenValues[idx] = aValue; @@ -1949,7 +1949,7 @@ static BOOL TestingEnum_IsValidValue(int32_t value) { // Stopping the enumeration. idx = 0; - [dict enumerateKeysAndValuesUsingBlock:^(NSString *aKey, float aValue, BOOL *stop) { + [dict enumerateKeysAndFloatsUsingBlock:^(NSString *aKey, float aValue, BOOL *stop) { #pragma unused(aKey, aValue) if (idx == 1) *stop = YES; XCTAssertNotEqual(idx, 2U); @@ -1965,27 +1965,27 @@ static BOOL TestingEnum_IsValidValue(int32_t value) { const float kValues2[] = { 500.f, 503.f, 502.f }; const float kValues3[] = { 500.f, 501.f, 502.f, 503.f }; GPBStringFloatDictionary *dict1 = - [[GPBStringFloatDictionary alloc] initWithValues:kValues1 + [[GPBStringFloatDictionary alloc] initWithFloats:kValues1 forKeys:kKeys1 count:GPBARRAYSIZE(kValues1)]; XCTAssertNotNil(dict1); GPBStringFloatDictionary *dict1prime = - [[GPBStringFloatDictionary alloc] initWithValues:kValues1 + [[GPBStringFloatDictionary alloc] initWithFloats:kValues1 forKeys:kKeys1 count:GPBARRAYSIZE(kValues1)]; XCTAssertNotNil(dict1prime); GPBStringFloatDictionary *dict2 = - [[GPBStringFloatDictionary alloc] initWithValues:kValues2 + [[GPBStringFloatDictionary alloc] initWithFloats:kValues2 forKeys:kKeys1 count:GPBARRAYSIZE(kValues2)]; XCTAssertNotNil(dict2); GPBStringFloatDictionary *dict3 = - [[GPBStringFloatDictionary alloc] initWithValues:kValues1 + [[GPBStringFloatDictionary alloc] initWithFloats:kValues1 forKeys:kKeys2 count:GPBARRAYSIZE(kValues1)]; XCTAssertNotNil(dict3); GPBStringFloatDictionary *dict4 = - [[GPBStringFloatDictionary alloc] initWithValues:kValues3 + [[GPBStringFloatDictionary alloc] initWithFloats:kValues3 forKeys:kKeys1 count:GPBARRAYSIZE(kValues3)]; XCTAssertNotNil(dict4); @@ -2016,7 +2016,7 @@ static BOOL TestingEnum_IsValidValue(int32_t value) { const NSString *kKeys[] = { @"foo", @"bar", @"baz", @"mumble" }; const float kValues[] = { 500.f, 501.f, 502.f, 503.f }; GPBStringFloatDictionary *dict = - [[GPBStringFloatDictionary alloc] initWithValues:kValues + [[GPBStringFloatDictionary alloc] initWithFloats:kValues forKeys:kKeys count:GPBARRAYSIZE(kValues)]; XCTAssertNotNil(dict); @@ -2037,7 +2037,7 @@ static BOOL TestingEnum_IsValidValue(int32_t value) { const NSString *kKeys[] = { @"foo", @"bar", @"baz", @"mumble" }; const float kValues[] = { 500.f, 501.f, 502.f, 503.f }; GPBStringFloatDictionary *dict = - [[GPBStringFloatDictionary alloc] initWithValues:kValues + [[GPBStringFloatDictionary alloc] initWithFloats:kValues forKeys:kKeys count:GPBARRAYSIZE(kValues)]; XCTAssertNotNil(dict); @@ -2057,13 +2057,13 @@ static BOOL TestingEnum_IsValidValue(int32_t value) { XCTAssertNotNil(dict); XCTAssertEqual(dict.count, 0U); - [dict setValue:500.f forKey:@"foo"]; + [dict setFloat:500.f forKey:@"foo"]; XCTAssertEqual(dict.count, 1U); const NSString *kKeys[] = { @"bar", @"baz", @"mumble" }; const float kValues[] = { 501.f, 502.f, 503.f }; GPBStringFloatDictionary *dict2 = - [[GPBStringFloatDictionary alloc] initWithValues:kValues + [[GPBStringFloatDictionary alloc] initWithFloats:kValues forKeys:kKeys count:GPBARRAYSIZE(kValues)]; XCTAssertNotNil(dict2); @@ -2071,17 +2071,17 @@ static BOOL TestingEnum_IsValidValue(int32_t value) { XCTAssertEqual(dict.count, 4U); float value; - XCTAssertTrue([dict valueForKey:@"foo" value:NULL]); - XCTAssertTrue([dict valueForKey:@"foo" value:&value]); + XCTAssertTrue([dict getFloat:NULL forKey:@"foo"]); + XCTAssertTrue([dict getFloat:&value forKey:@"foo"]); XCTAssertEqual(value, 500.f); - XCTAssertTrue([dict valueForKey:@"bar" value:NULL]); - XCTAssertTrue([dict valueForKey:@"bar" value:&value]); + XCTAssertTrue([dict getFloat:NULL forKey:@"bar"]); + XCTAssertTrue([dict getFloat:&value forKey:@"bar"]); XCTAssertEqual(value, 501.f); - XCTAssertTrue([dict valueForKey:@"baz" value:NULL]); - XCTAssertTrue([dict valueForKey:@"baz" value:&value]); + XCTAssertTrue([dict getFloat:NULL forKey:@"baz"]); + XCTAssertTrue([dict getFloat:&value forKey:@"baz"]); XCTAssertEqual(value, 502.f); - XCTAssertTrue([dict valueForKey:@"mumble" value:NULL]); - XCTAssertTrue([dict valueForKey:@"mumble" value:&value]); + XCTAssertTrue([dict getFloat:NULL forKey:@"mumble"]); + XCTAssertTrue([dict getFloat:&value forKey:@"mumble"]); XCTAssertEqual(value, 503.f); [dict2 release]; } @@ -2090,57 +2090,57 @@ static BOOL TestingEnum_IsValidValue(int32_t value) { const NSString *kKeys[] = { @"foo", @"bar", @"baz", @"mumble" }; const float kValues[] = { 500.f, 501.f, 502.f, 503.f }; GPBStringFloatDictionary *dict = - [[GPBStringFloatDictionary alloc] initWithValues:kValues - forKeys:kKeys - count:GPBARRAYSIZE(kValues)]; + [[GPBStringFloatDictionary alloc] initWithFloats:kValues + forKeys:kKeys + count:GPBARRAYSIZE(kValues)]; XCTAssertNotNil(dict); XCTAssertEqual(dict.count, 4U); - [dict removeValueForKey:@"bar"]; + [dict removeFloatForKey:@"bar"]; XCTAssertEqual(dict.count, 3U); float value; - XCTAssertTrue([dict valueForKey:@"foo" value:NULL]); - XCTAssertTrue([dict valueForKey:@"foo" value:&value]); + XCTAssertTrue([dict getFloat:NULL forKey:@"foo"]); + XCTAssertTrue([dict getFloat:&value forKey:@"foo"]); XCTAssertEqual(value, 500.f); - XCTAssertFalse([dict valueForKey:@"bar" value:NULL]); - XCTAssertTrue([dict valueForKey:@"baz" value:NULL]); - XCTAssertTrue([dict valueForKey:@"baz" value:&value]); + XCTAssertFalse([dict getFloat:NULL forKey:@"bar"]); + XCTAssertTrue([dict getFloat:NULL forKey:@"baz"]); + XCTAssertTrue([dict getFloat:&value forKey:@"baz"]); XCTAssertEqual(value, 502.f); - XCTAssertTrue([dict valueForKey:@"mumble" value:NULL]); - XCTAssertTrue([dict valueForKey:@"mumble" value:&value]); + XCTAssertTrue([dict getFloat:NULL forKey:@"mumble"]); + XCTAssertTrue([dict getFloat:&value forKey:@"mumble"]); XCTAssertEqual(value, 503.f); // Remove again does nothing. - [dict removeValueForKey:@"bar"]; + [dict removeFloatForKey:@"bar"]; XCTAssertEqual(dict.count, 3U); - XCTAssertTrue([dict valueForKey:@"foo" value:NULL]); - XCTAssertTrue([dict valueForKey:@"foo" value:&value]); + XCTAssertTrue([dict getFloat:NULL forKey:@"foo"]); + XCTAssertTrue([dict getFloat:&value forKey:@"foo"]); XCTAssertEqual(value, 500.f); - XCTAssertFalse([dict valueForKey:@"bar" value:NULL]); - XCTAssertTrue([dict valueForKey:@"baz" value:NULL]); - XCTAssertTrue([dict valueForKey:@"baz" value:&value]); + XCTAssertFalse([dict getFloat:NULL forKey:@"bar"]); + XCTAssertTrue([dict getFloat:NULL forKey:@"baz"]); + XCTAssertTrue([dict getFloat:&value forKey:@"baz"]); XCTAssertEqual(value, 502.f); - XCTAssertTrue([dict valueForKey:@"mumble" value:NULL]); - XCTAssertTrue([dict valueForKey:@"mumble" value:&value]); + XCTAssertTrue([dict getFloat:NULL forKey:@"mumble"]); + XCTAssertTrue([dict getFloat:&value forKey:@"mumble"]); XCTAssertEqual(value, 503.f); - [dict removeValueForKey:@"mumble"]; + [dict removeFloatForKey:@"mumble"]; XCTAssertEqual(dict.count, 2U); - XCTAssertTrue([dict valueForKey:@"foo" value:NULL]); - XCTAssertTrue([dict valueForKey:@"foo" value:&value]); + XCTAssertTrue([dict getFloat:NULL forKey:@"foo"]); + XCTAssertTrue([dict getFloat:&value forKey:@"foo"]); XCTAssertEqual(value, 500.f); - XCTAssertFalse([dict valueForKey:@"bar" value:NULL]); - XCTAssertTrue([dict valueForKey:@"baz" value:NULL]); - XCTAssertTrue([dict valueForKey:@"baz" value:&value]); + XCTAssertFalse([dict getFloat:NULL forKey:@"bar"]); + XCTAssertTrue([dict getFloat:NULL forKey:@"baz"]); + XCTAssertTrue([dict getFloat:&value forKey:@"baz"]); XCTAssertEqual(value, 502.f); - XCTAssertFalse([dict valueForKey:@"mumble" value:NULL]); + XCTAssertFalse([dict getFloat:NULL forKey:@"mumble"]); [dict removeAll]; XCTAssertEqual(dict.count, 0U); - XCTAssertFalse([dict valueForKey:@"foo" value:NULL]); - XCTAssertFalse([dict valueForKey:@"bar" value:NULL]); - XCTAssertFalse([dict valueForKey:@"baz" value:NULL]); - XCTAssertFalse([dict valueForKey:@"mumble" value:NULL]); + XCTAssertFalse([dict getFloat:NULL forKey:@"foo"]); + XCTAssertFalse([dict getFloat:NULL forKey:@"bar"]); + XCTAssertFalse([dict getFloat:NULL forKey:@"baz"]); + XCTAssertFalse([dict getFloat:NULL forKey:@"mumble"]); [dict release]; } @@ -2148,75 +2148,75 @@ static BOOL TestingEnum_IsValidValue(int32_t value) { const NSString *kKeys[] = { @"foo", @"bar", @"baz", @"mumble" }; const float kValues[] = { 500.f, 501.f, 502.f, 503.f }; GPBStringFloatDictionary *dict = - [[GPBStringFloatDictionary alloc] initWithValues:kValues - forKeys:kKeys - count:GPBARRAYSIZE(kValues)]; + [[GPBStringFloatDictionary alloc] initWithFloats:kValues + forKeys:kKeys + count:GPBARRAYSIZE(kValues)]; XCTAssertNotNil(dict); XCTAssertEqual(dict.count, 4U); float value; - XCTAssertTrue([dict valueForKey:@"foo" value:NULL]); - XCTAssertTrue([dict valueForKey:@"foo" value:&value]); + XCTAssertTrue([dict getFloat:NULL forKey:@"foo"]); + XCTAssertTrue([dict getFloat:&value forKey:@"foo"]); XCTAssertEqual(value, 500.f); - XCTAssertTrue([dict valueForKey:@"bar" value:NULL]); - XCTAssertTrue([dict valueForKey:@"bar" value:&value]); + XCTAssertTrue([dict getFloat:NULL forKey:@"bar"]); + XCTAssertTrue([dict getFloat:&value forKey:@"bar"]); XCTAssertEqual(value, 501.f); - XCTAssertTrue([dict valueForKey:@"baz" value:NULL]); - XCTAssertTrue([dict valueForKey:@"baz" value:&value]); + XCTAssertTrue([dict getFloat:NULL forKey:@"baz"]); + XCTAssertTrue([dict getFloat:&value forKey:@"baz"]); XCTAssertEqual(value, 502.f); - XCTAssertTrue([dict valueForKey:@"mumble" value:NULL]); - XCTAssertTrue([dict valueForKey:@"mumble" value:&value]); + XCTAssertTrue([dict getFloat:NULL forKey:@"mumble"]); + XCTAssertTrue([dict getFloat:&value forKey:@"mumble"]); XCTAssertEqual(value, 503.f); - [dict setValue:503.f forKey:@"foo"]; + [dict setFloat:503.f forKey:@"foo"]; XCTAssertEqual(dict.count, 4U); - XCTAssertTrue([dict valueForKey:@"foo" value:NULL]); - XCTAssertTrue([dict valueForKey:@"foo" value:&value]); + XCTAssertTrue([dict getFloat:NULL forKey:@"foo"]); + XCTAssertTrue([dict getFloat:&value forKey:@"foo"]); XCTAssertEqual(value, 503.f); - XCTAssertTrue([dict valueForKey:@"bar" value:NULL]); - XCTAssertTrue([dict valueForKey:@"bar" value:&value]); + XCTAssertTrue([dict getFloat:NULL forKey:@"bar"]); + XCTAssertTrue([dict getFloat:&value forKey:@"bar"]); XCTAssertEqual(value, 501.f); - XCTAssertTrue([dict valueForKey:@"baz" value:NULL]); - XCTAssertTrue([dict valueForKey:@"baz" value:&value]); + XCTAssertTrue([dict getFloat:NULL forKey:@"baz"]); + XCTAssertTrue([dict getFloat:&value forKey:@"baz"]); XCTAssertEqual(value, 502.f); - XCTAssertTrue([dict valueForKey:@"mumble" value:NULL]); - XCTAssertTrue([dict valueForKey:@"mumble" value:&value]); + XCTAssertTrue([dict getFloat:NULL forKey:@"mumble"]); + XCTAssertTrue([dict getFloat:&value forKey:@"mumble"]); XCTAssertEqual(value, 503.f); - [dict setValue:501.f forKey:@"mumble"]; + [dict setFloat:501.f forKey:@"mumble"]; XCTAssertEqual(dict.count, 4U); - XCTAssertTrue([dict valueForKey:@"foo" value:NULL]); - XCTAssertTrue([dict valueForKey:@"foo" value:&value]); + XCTAssertTrue([dict getFloat:NULL forKey:@"foo"]); + XCTAssertTrue([dict getFloat:&value forKey:@"foo"]); XCTAssertEqual(value, 503.f); - XCTAssertTrue([dict valueForKey:@"bar" value:NULL]); - XCTAssertTrue([dict valueForKey:@"bar" value:&value]); + XCTAssertTrue([dict getFloat:NULL forKey:@"bar"]); + XCTAssertTrue([dict getFloat:&value forKey:@"bar"]); XCTAssertEqual(value, 501.f); - XCTAssertTrue([dict valueForKey:@"baz" value:NULL]); - XCTAssertTrue([dict valueForKey:@"baz" value:&value]); + XCTAssertTrue([dict getFloat:NULL forKey:@"baz"]); + XCTAssertTrue([dict getFloat:&value forKey:@"baz"]); XCTAssertEqual(value, 502.f); - XCTAssertTrue([dict valueForKey:@"mumble" value:NULL]); - XCTAssertTrue([dict valueForKey:@"mumble" value:&value]); + XCTAssertTrue([dict getFloat:NULL forKey:@"mumble"]); + XCTAssertTrue([dict getFloat:&value forKey:@"mumble"]); XCTAssertEqual(value, 501.f); const NSString *kKeys2[] = { @"bar", @"baz" }; const float kValues2[] = { 502.f, 500.f }; GPBStringFloatDictionary *dict2 = - [[GPBStringFloatDictionary alloc] initWithValues:kValues2 + [[GPBStringFloatDictionary alloc] initWithFloats:kValues2 forKeys:kKeys2 count:GPBARRAYSIZE(kValues2)]; XCTAssertNotNil(dict2); [dict addEntriesFromDictionary:dict2]; XCTAssertEqual(dict.count, 4U); - XCTAssertTrue([dict valueForKey:@"foo" value:NULL]); - XCTAssertTrue([dict valueForKey:@"foo" value:&value]); + XCTAssertTrue([dict getFloat:NULL forKey:@"foo"]); + XCTAssertTrue([dict getFloat:&value forKey:@"foo"]); XCTAssertEqual(value, 503.f); - XCTAssertTrue([dict valueForKey:@"bar" value:NULL]); - XCTAssertTrue([dict valueForKey:@"bar" value:&value]); + XCTAssertTrue([dict getFloat:NULL forKey:@"bar"]); + XCTAssertTrue([dict getFloat:&value forKey:@"bar"]); XCTAssertEqual(value, 502.f); - XCTAssertTrue([dict valueForKey:@"baz" value:NULL]); - XCTAssertTrue([dict valueForKey:@"baz" value:&value]); + XCTAssertTrue([dict getFloat:NULL forKey:@"baz"]); + XCTAssertTrue([dict getFloat:&value forKey:@"baz"]); XCTAssertEqual(value, 500.f); - XCTAssertTrue([dict valueForKey:@"mumble" value:NULL]); - XCTAssertTrue([dict valueForKey:@"mumble" value:&value]); + XCTAssertTrue([dict getFloat:NULL forKey:@"mumble"]); + XCTAssertTrue([dict getFloat:&value forKey:@"mumble"]); XCTAssertEqual(value, 501.f); [dict2 release]; @@ -2236,8 +2236,8 @@ static BOOL TestingEnum_IsValidValue(int32_t value) { GPBStringDoubleDictionary *dict = [[GPBStringDoubleDictionary alloc] init]; XCTAssertNotNil(dict); XCTAssertEqual(dict.count, 0U); - XCTAssertFalse([dict valueForKey:@"foo" value:NULL]); - [dict enumerateKeysAndValuesUsingBlock:^(NSString *aKey, double aValue, BOOL *stop) { + XCTAssertFalse([dict getDouble:NULL forKey:@"foo"]); + [dict enumerateKeysAndDoublesUsingBlock:^(NSString *aKey, double aValue, BOOL *stop) { #pragma unused(aKey, aValue, stop) XCTFail(@"Shouldn't get here!"); }]; @@ -2245,15 +2245,15 @@ static BOOL TestingEnum_IsValidValue(int32_t value) { } - (void)testOne { - GPBStringDoubleDictionary *dict = [GPBStringDoubleDictionary dictionaryWithValue:600. forKey:@"foo"]; + GPBStringDoubleDictionary *dict = [GPBStringDoubleDictionary dictionaryWithDouble:600. forKey:@"foo"]; XCTAssertNotNil(dict); XCTAssertEqual(dict.count, 1U); double value; - XCTAssertTrue([dict valueForKey:@"foo" value:NULL]); - XCTAssertTrue([dict valueForKey:@"foo" value:&value]); + XCTAssertTrue([dict getDouble:NULL forKey:@"foo"]); + XCTAssertTrue([dict getDouble:&value forKey:@"foo"]); XCTAssertEqual(value, 600.); - XCTAssertFalse([dict valueForKey:@"bar" value:NULL]); - [dict enumerateKeysAndValuesUsingBlock:^(NSString *aKey, double aValue, BOOL *stop) { + XCTAssertFalse([dict getDouble:NULL forKey:@"bar"]); + [dict enumerateKeysAndDoublesUsingBlock:^(NSString *aKey, double aValue, BOOL *stop) { XCTAssertEqualObjects(aKey, @"foo"); XCTAssertEqual(aValue, 600.); XCTAssertNotEqual(stop, NULL); @@ -2264,27 +2264,27 @@ static BOOL TestingEnum_IsValidValue(int32_t value) { const NSString *kKeys[] = { @"foo", @"bar", @"baz" }; const double kValues[] = { 600., 601., 602. }; GPBStringDoubleDictionary *dict = - [[GPBStringDoubleDictionary alloc] initWithValues:kValues - forKeys:kKeys - count:GPBARRAYSIZE(kValues)]; + [[GPBStringDoubleDictionary alloc] initWithDoubles:kValues + forKeys:kKeys + count:GPBARRAYSIZE(kValues)]; XCTAssertNotNil(dict); XCTAssertEqual(dict.count, 3U); double value; - XCTAssertTrue([dict valueForKey:@"foo" value:NULL]); - XCTAssertTrue([dict valueForKey:@"foo" value:&value]); + XCTAssertTrue([dict getDouble:NULL forKey:@"foo"]); + XCTAssertTrue([dict getDouble:&value forKey:@"foo"]); XCTAssertEqual(value, 600.); - XCTAssertTrue([dict valueForKey:@"bar" value:NULL]); - XCTAssertTrue([dict valueForKey:@"bar" value:&value]); + XCTAssertTrue([dict getDouble:NULL forKey:@"bar"]); + XCTAssertTrue([dict getDouble:&value forKey:@"bar"]); XCTAssertEqual(value, 601.); - XCTAssertTrue([dict valueForKey:@"baz" value:NULL]); - XCTAssertTrue([dict valueForKey:@"baz" value:&value]); + XCTAssertTrue([dict getDouble:NULL forKey:@"baz"]); + XCTAssertTrue([dict getDouble:&value forKey:@"baz"]); XCTAssertEqual(value, 602.); - XCTAssertFalse([dict valueForKey:@"mumble" value:NULL]); + XCTAssertFalse([dict getDouble:NULL forKey:@"mumble"]); __block NSUInteger idx = 0; NSString **seenKeys = malloc(3 * sizeof(NSString*)); double *seenValues = malloc(3 * sizeof(double)); - [dict enumerateKeysAndValuesUsingBlock:^(NSString *aKey, double aValue, BOOL *stop) { + [dict enumerateKeysAndDoublesUsingBlock:^(NSString *aKey, double aValue, BOOL *stop) { XCTAssertLessThan(idx, 3U); seenKeys[idx] = aKey; seenValues[idx] = aValue; @@ -2306,7 +2306,7 @@ static BOOL TestingEnum_IsValidValue(int32_t value) { // Stopping the enumeration. idx = 0; - [dict enumerateKeysAndValuesUsingBlock:^(NSString *aKey, double aValue, BOOL *stop) { + [dict enumerateKeysAndDoublesUsingBlock:^(NSString *aKey, double aValue, BOOL *stop) { #pragma unused(aKey, aValue) if (idx == 1) *stop = YES; XCTAssertNotEqual(idx, 2U); @@ -2322,29 +2322,29 @@ static BOOL TestingEnum_IsValidValue(int32_t value) { const double kValues2[] = { 600., 603., 602. }; const double kValues3[] = { 600., 601., 602., 603. }; GPBStringDoubleDictionary *dict1 = - [[GPBStringDoubleDictionary alloc] initWithValues:kValues1 - forKeys:kKeys1 - count:GPBARRAYSIZE(kValues1)]; + [[GPBStringDoubleDictionary alloc] initWithDoubles:kValues1 + forKeys:kKeys1 + count:GPBARRAYSIZE(kValues1)]; XCTAssertNotNil(dict1); GPBStringDoubleDictionary *dict1prime = - [[GPBStringDoubleDictionary alloc] initWithValues:kValues1 - forKeys:kKeys1 - count:GPBARRAYSIZE(kValues1)]; + [[GPBStringDoubleDictionary alloc] initWithDoubles:kValues1 + forKeys:kKeys1 + count:GPBARRAYSIZE(kValues1)]; XCTAssertNotNil(dict1prime); GPBStringDoubleDictionary *dict2 = - [[GPBStringDoubleDictionary alloc] initWithValues:kValues2 - forKeys:kKeys1 - count:GPBARRAYSIZE(kValues2)]; + [[GPBStringDoubleDictionary alloc] initWithDoubles:kValues2 + forKeys:kKeys1 + count:GPBARRAYSIZE(kValues2)]; XCTAssertNotNil(dict2); GPBStringDoubleDictionary *dict3 = - [[GPBStringDoubleDictionary alloc] initWithValues:kValues1 - forKeys:kKeys2 - count:GPBARRAYSIZE(kValues1)]; + [[GPBStringDoubleDictionary alloc] initWithDoubles:kValues1 + forKeys:kKeys2 + count:GPBARRAYSIZE(kValues1)]; XCTAssertNotNil(dict3); GPBStringDoubleDictionary *dict4 = - [[GPBStringDoubleDictionary alloc] initWithValues:kValues3 - forKeys:kKeys1 - count:GPBARRAYSIZE(kValues3)]; + [[GPBStringDoubleDictionary alloc] initWithDoubles:kValues3 + forKeys:kKeys1 + count:GPBARRAYSIZE(kValues3)]; XCTAssertNotNil(dict4); // 1/1Prime should be different objects, but equal. @@ -2373,9 +2373,9 @@ static BOOL TestingEnum_IsValidValue(int32_t value) { const NSString *kKeys[] = { @"foo", @"bar", @"baz", @"mumble" }; const double kValues[] = { 600., 601., 602., 603. }; GPBStringDoubleDictionary *dict = - [[GPBStringDoubleDictionary alloc] initWithValues:kValues - forKeys:kKeys - count:GPBARRAYSIZE(kValues)]; + [[GPBStringDoubleDictionary alloc] initWithDoubles:kValues + forKeys:kKeys + count:GPBARRAYSIZE(kValues)]; XCTAssertNotNil(dict); GPBStringDoubleDictionary *dict2 = [dict copy]; @@ -2394,9 +2394,9 @@ static BOOL TestingEnum_IsValidValue(int32_t value) { const NSString *kKeys[] = { @"foo", @"bar", @"baz", @"mumble" }; const double kValues[] = { 600., 601., 602., 603. }; GPBStringDoubleDictionary *dict = - [[GPBStringDoubleDictionary alloc] initWithValues:kValues - forKeys:kKeys - count:GPBARRAYSIZE(kValues)]; + [[GPBStringDoubleDictionary alloc] initWithDoubles:kValues + forKeys:kKeys + count:GPBARRAYSIZE(kValues)]; XCTAssertNotNil(dict); GPBStringDoubleDictionary *dict2 = @@ -2414,31 +2414,31 @@ static BOOL TestingEnum_IsValidValue(int32_t value) { XCTAssertNotNil(dict); XCTAssertEqual(dict.count, 0U); - [dict setValue:600. forKey:@"foo"]; + [dict setDouble:600. forKey:@"foo"]; XCTAssertEqual(dict.count, 1U); const NSString *kKeys[] = { @"bar", @"baz", @"mumble" }; const double kValues[] = { 601., 602., 603. }; GPBStringDoubleDictionary *dict2 = - [[GPBStringDoubleDictionary alloc] initWithValues:kValues - forKeys:kKeys - count:GPBARRAYSIZE(kValues)]; + [[GPBStringDoubleDictionary alloc] initWithDoubles:kValues + forKeys:kKeys + count:GPBARRAYSIZE(kValues)]; XCTAssertNotNil(dict2); [dict addEntriesFromDictionary:dict2]; XCTAssertEqual(dict.count, 4U); double value; - XCTAssertTrue([dict valueForKey:@"foo" value:NULL]); - XCTAssertTrue([dict valueForKey:@"foo" value:&value]); + XCTAssertTrue([dict getDouble:NULL forKey:@"foo"]); + XCTAssertTrue([dict getDouble:&value forKey:@"foo"]); XCTAssertEqual(value, 600.); - XCTAssertTrue([dict valueForKey:@"bar" value:NULL]); - XCTAssertTrue([dict valueForKey:@"bar" value:&value]); + XCTAssertTrue([dict getDouble:NULL forKey:@"bar"]); + XCTAssertTrue([dict getDouble:&value forKey:@"bar"]); XCTAssertEqual(value, 601.); - XCTAssertTrue([dict valueForKey:@"baz" value:NULL]); - XCTAssertTrue([dict valueForKey:@"baz" value:&value]); + XCTAssertTrue([dict getDouble:NULL forKey:@"baz"]); + XCTAssertTrue([dict getDouble:&value forKey:@"baz"]); XCTAssertEqual(value, 602.); - XCTAssertTrue([dict valueForKey:@"mumble" value:NULL]); - XCTAssertTrue([dict valueForKey:@"mumble" value:&value]); + XCTAssertTrue([dict getDouble:NULL forKey:@"mumble"]); + XCTAssertTrue([dict getDouble:&value forKey:@"mumble"]); XCTAssertEqual(value, 603.); [dict2 release]; } @@ -2447,57 +2447,57 @@ static BOOL TestingEnum_IsValidValue(int32_t value) { const NSString *kKeys[] = { @"foo", @"bar", @"baz", @"mumble" }; const double kValues[] = { 600., 601., 602., 603. }; GPBStringDoubleDictionary *dict = - [[GPBStringDoubleDictionary alloc] initWithValues:kValues - forKeys:kKeys - count:GPBARRAYSIZE(kValues)]; + [[GPBStringDoubleDictionary alloc] initWithDoubles:kValues + forKeys:kKeys + count:GPBARRAYSIZE(kValues)]; XCTAssertNotNil(dict); XCTAssertEqual(dict.count, 4U); - [dict removeValueForKey:@"bar"]; + [dict removeDoubleForKey:@"bar"]; XCTAssertEqual(dict.count, 3U); double value; - XCTAssertTrue([dict valueForKey:@"foo" value:NULL]); - XCTAssertTrue([dict valueForKey:@"foo" value:&value]); + XCTAssertTrue([dict getDouble:NULL forKey:@"foo"]); + XCTAssertTrue([dict getDouble:&value forKey:@"foo"]); XCTAssertEqual(value, 600.); - XCTAssertFalse([dict valueForKey:@"bar" value:NULL]); - XCTAssertTrue([dict valueForKey:@"baz" value:NULL]); - XCTAssertTrue([dict valueForKey:@"baz" value:&value]); + XCTAssertFalse([dict getDouble:NULL forKey:@"bar"]); + XCTAssertTrue([dict getDouble:NULL forKey:@"baz"]); + XCTAssertTrue([dict getDouble:&value forKey:@"baz"]); XCTAssertEqual(value, 602.); - XCTAssertTrue([dict valueForKey:@"mumble" value:NULL]); - XCTAssertTrue([dict valueForKey:@"mumble" value:&value]); + XCTAssertTrue([dict getDouble:NULL forKey:@"mumble"]); + XCTAssertTrue([dict getDouble:&value forKey:@"mumble"]); XCTAssertEqual(value, 603.); // Remove again does nothing. - [dict removeValueForKey:@"bar"]; + [dict removeDoubleForKey:@"bar"]; XCTAssertEqual(dict.count, 3U); - XCTAssertTrue([dict valueForKey:@"foo" value:NULL]); - XCTAssertTrue([dict valueForKey:@"foo" value:&value]); + XCTAssertTrue([dict getDouble:NULL forKey:@"foo"]); + XCTAssertTrue([dict getDouble:&value forKey:@"foo"]); XCTAssertEqual(value, 600.); - XCTAssertFalse([dict valueForKey:@"bar" value:NULL]); - XCTAssertTrue([dict valueForKey:@"baz" value:NULL]); - XCTAssertTrue([dict valueForKey:@"baz" value:&value]); + XCTAssertFalse([dict getDouble:NULL forKey:@"bar"]); + XCTAssertTrue([dict getDouble:NULL forKey:@"baz"]); + XCTAssertTrue([dict getDouble:&value forKey:@"baz"]); XCTAssertEqual(value, 602.); - XCTAssertTrue([dict valueForKey:@"mumble" value:NULL]); - XCTAssertTrue([dict valueForKey:@"mumble" value:&value]); + XCTAssertTrue([dict getDouble:NULL forKey:@"mumble"]); + XCTAssertTrue([dict getDouble:&value forKey:@"mumble"]); XCTAssertEqual(value, 603.); - [dict removeValueForKey:@"mumble"]; + [dict removeDoubleForKey:@"mumble"]; XCTAssertEqual(dict.count, 2U); - XCTAssertTrue([dict valueForKey:@"foo" value:NULL]); - XCTAssertTrue([dict valueForKey:@"foo" value:&value]); + XCTAssertTrue([dict getDouble:NULL forKey:@"foo"]); + XCTAssertTrue([dict getDouble:&value forKey:@"foo"]); XCTAssertEqual(value, 600.); - XCTAssertFalse([dict valueForKey:@"bar" value:NULL]); - XCTAssertTrue([dict valueForKey:@"baz" value:NULL]); - XCTAssertTrue([dict valueForKey:@"baz" value:&value]); + XCTAssertFalse([dict getDouble:NULL forKey:@"bar"]); + XCTAssertTrue([dict getDouble:NULL forKey:@"baz"]); + XCTAssertTrue([dict getDouble:&value forKey:@"baz"]); XCTAssertEqual(value, 602.); - XCTAssertFalse([dict valueForKey:@"mumble" value:NULL]); + XCTAssertFalse([dict getDouble:NULL forKey:@"mumble"]); [dict removeAll]; XCTAssertEqual(dict.count, 0U); - XCTAssertFalse([dict valueForKey:@"foo" value:NULL]); - XCTAssertFalse([dict valueForKey:@"bar" value:NULL]); - XCTAssertFalse([dict valueForKey:@"baz" value:NULL]); - XCTAssertFalse([dict valueForKey:@"mumble" value:NULL]); + XCTAssertFalse([dict getDouble:NULL forKey:@"foo"]); + XCTAssertFalse([dict getDouble:NULL forKey:@"bar"]); + XCTAssertFalse([dict getDouble:NULL forKey:@"baz"]); + XCTAssertFalse([dict getDouble:NULL forKey:@"mumble"]); [dict release]; } @@ -2505,75 +2505,75 @@ static BOOL TestingEnum_IsValidValue(int32_t value) { const NSString *kKeys[] = { @"foo", @"bar", @"baz", @"mumble" }; const double kValues[] = { 600., 601., 602., 603. }; GPBStringDoubleDictionary *dict = - [[GPBStringDoubleDictionary alloc] initWithValues:kValues - forKeys:kKeys - count:GPBARRAYSIZE(kValues)]; + [[GPBStringDoubleDictionary alloc] initWithDoubles:kValues + forKeys:kKeys + count:GPBARRAYSIZE(kValues)]; XCTAssertNotNil(dict); XCTAssertEqual(dict.count, 4U); double value; - XCTAssertTrue([dict valueForKey:@"foo" value:NULL]); - XCTAssertTrue([dict valueForKey:@"foo" value:&value]); + XCTAssertTrue([dict getDouble:NULL forKey:@"foo"]); + XCTAssertTrue([dict getDouble:&value forKey:@"foo"]); XCTAssertEqual(value, 600.); - XCTAssertTrue([dict valueForKey:@"bar" value:NULL]); - XCTAssertTrue([dict valueForKey:@"bar" value:&value]); + XCTAssertTrue([dict getDouble:NULL forKey:@"bar"]); + XCTAssertTrue([dict getDouble:&value forKey:@"bar"]); XCTAssertEqual(value, 601.); - XCTAssertTrue([dict valueForKey:@"baz" value:NULL]); - XCTAssertTrue([dict valueForKey:@"baz" value:&value]); + XCTAssertTrue([dict getDouble:NULL forKey:@"baz"]); + XCTAssertTrue([dict getDouble:&value forKey:@"baz"]); XCTAssertEqual(value, 602.); - XCTAssertTrue([dict valueForKey:@"mumble" value:NULL]); - XCTAssertTrue([dict valueForKey:@"mumble" value:&value]); + XCTAssertTrue([dict getDouble:NULL forKey:@"mumble"]); + XCTAssertTrue([dict getDouble:&value forKey:@"mumble"]); XCTAssertEqual(value, 603.); - [dict setValue:603. forKey:@"foo"]; + [dict setDouble:603. forKey:@"foo"]; XCTAssertEqual(dict.count, 4U); - XCTAssertTrue([dict valueForKey:@"foo" value:NULL]); - XCTAssertTrue([dict valueForKey:@"foo" value:&value]); + XCTAssertTrue([dict getDouble:NULL forKey:@"foo"]); + XCTAssertTrue([dict getDouble:&value forKey:@"foo"]); XCTAssertEqual(value, 603.); - XCTAssertTrue([dict valueForKey:@"bar" value:NULL]); - XCTAssertTrue([dict valueForKey:@"bar" value:&value]); + XCTAssertTrue([dict getDouble:NULL forKey:@"bar"]); + XCTAssertTrue([dict getDouble:&value forKey:@"bar"]); XCTAssertEqual(value, 601.); - XCTAssertTrue([dict valueForKey:@"baz" value:NULL]); - XCTAssertTrue([dict valueForKey:@"baz" value:&value]); + XCTAssertTrue([dict getDouble:NULL forKey:@"baz"]); + XCTAssertTrue([dict getDouble:&value forKey:@"baz"]); XCTAssertEqual(value, 602.); - XCTAssertTrue([dict valueForKey:@"mumble" value:NULL]); - XCTAssertTrue([dict valueForKey:@"mumble" value:&value]); + XCTAssertTrue([dict getDouble:NULL forKey:@"mumble"]); + XCTAssertTrue([dict getDouble:&value forKey:@"mumble"]); XCTAssertEqual(value, 603.); - [dict setValue:601. forKey:@"mumble"]; + [dict setDouble:601. forKey:@"mumble"]; XCTAssertEqual(dict.count, 4U); - XCTAssertTrue([dict valueForKey:@"foo" value:NULL]); - XCTAssertTrue([dict valueForKey:@"foo" value:&value]); + XCTAssertTrue([dict getDouble:NULL forKey:@"foo"]); + XCTAssertTrue([dict getDouble:&value forKey:@"foo"]); XCTAssertEqual(value, 603.); - XCTAssertTrue([dict valueForKey:@"bar" value:NULL]); - XCTAssertTrue([dict valueForKey:@"bar" value:&value]); + XCTAssertTrue([dict getDouble:NULL forKey:@"bar"]); + XCTAssertTrue([dict getDouble:&value forKey:@"bar"]); XCTAssertEqual(value, 601.); - XCTAssertTrue([dict valueForKey:@"baz" value:NULL]); - XCTAssertTrue([dict valueForKey:@"baz" value:&value]); + XCTAssertTrue([dict getDouble:NULL forKey:@"baz"]); + XCTAssertTrue([dict getDouble:&value forKey:@"baz"]); XCTAssertEqual(value, 602.); - XCTAssertTrue([dict valueForKey:@"mumble" value:NULL]); - XCTAssertTrue([dict valueForKey:@"mumble" value:&value]); + XCTAssertTrue([dict getDouble:NULL forKey:@"mumble"]); + XCTAssertTrue([dict getDouble:&value forKey:@"mumble"]); XCTAssertEqual(value, 601.); const NSString *kKeys2[] = { @"bar", @"baz" }; const double kValues2[] = { 602., 600. }; GPBStringDoubleDictionary *dict2 = - [[GPBStringDoubleDictionary alloc] initWithValues:kValues2 - forKeys:kKeys2 - count:GPBARRAYSIZE(kValues2)]; + [[GPBStringDoubleDictionary alloc] initWithDoubles:kValues2 + forKeys:kKeys2 + count:GPBARRAYSIZE(kValues2)]; XCTAssertNotNil(dict2); [dict addEntriesFromDictionary:dict2]; XCTAssertEqual(dict.count, 4U); - XCTAssertTrue([dict valueForKey:@"foo" value:NULL]); - XCTAssertTrue([dict valueForKey:@"foo" value:&value]); + XCTAssertTrue([dict getDouble:NULL forKey:@"foo"]); + XCTAssertTrue([dict getDouble:&value forKey:@"foo"]); XCTAssertEqual(value, 603.); - XCTAssertTrue([dict valueForKey:@"bar" value:NULL]); - XCTAssertTrue([dict valueForKey:@"bar" value:&value]); + XCTAssertTrue([dict getDouble:NULL forKey:@"bar"]); + XCTAssertTrue([dict getDouble:&value forKey:@"bar"]); XCTAssertEqual(value, 602.); - XCTAssertTrue([dict valueForKey:@"baz" value:NULL]); - XCTAssertTrue([dict valueForKey:@"baz" value:&value]); + XCTAssertTrue([dict getDouble:NULL forKey:@"baz"]); + XCTAssertTrue([dict getDouble:&value forKey:@"baz"]); XCTAssertEqual(value, 600.); - XCTAssertTrue([dict valueForKey:@"mumble" value:NULL]); - XCTAssertTrue([dict valueForKey:@"mumble" value:&value]); + XCTAssertTrue([dict getDouble:NULL forKey:@"mumble"]); + XCTAssertTrue([dict getDouble:&value forKey:@"mumble"]); XCTAssertEqual(value, 601.); [dict2 release]; @@ -2593,8 +2593,8 @@ static BOOL TestingEnum_IsValidValue(int32_t value) { GPBStringEnumDictionary *dict = [[GPBStringEnumDictionary alloc] init]; XCTAssertNotNil(dict); XCTAssertEqual(dict.count, 0U); - XCTAssertFalse([dict valueForKey:@"foo" value:NULL]); - [dict enumerateKeysAndValuesUsingBlock:^(NSString *aKey, int32_t aValue, BOOL *stop) { + XCTAssertFalse([dict getEnum:NULL forKey:@"foo"]); + [dict enumerateKeysAndEnumsUsingBlock:^(NSString *aKey, int32_t aValue, BOOL *stop) { #pragma unused(aKey, aValue, stop) XCTFail(@"Shouldn't get here!"); }]; @@ -2602,15 +2602,15 @@ static BOOL TestingEnum_IsValidValue(int32_t value) { } - (void)testOne { - GPBStringEnumDictionary *dict = [GPBStringEnumDictionary dictionaryWithValue:700 forKey:@"foo"]; + GPBStringEnumDictionary *dict = [GPBStringEnumDictionary dictionaryWithEnum:700 forKey:@"foo"]; XCTAssertNotNil(dict); XCTAssertEqual(dict.count, 1U); int32_t value; - XCTAssertTrue([dict valueForKey:@"foo" value:NULL]); - XCTAssertTrue([dict valueForKey:@"foo" value:&value]); + XCTAssertTrue([dict getEnum:NULL forKey:@"foo"]); + XCTAssertTrue([dict getEnum:&value forKey:@"foo"]); XCTAssertEqual(value, 700); - XCTAssertFalse([dict valueForKey:@"bar" value:NULL]); - [dict enumerateKeysAndValuesUsingBlock:^(NSString *aKey, int32_t aValue, BOOL *stop) { + XCTAssertFalse([dict getEnum:NULL forKey:@"bar"]); + [dict enumerateKeysAndEnumsUsingBlock:^(NSString *aKey, int32_t aValue, BOOL *stop) { XCTAssertEqualObjects(aKey, @"foo"); XCTAssertEqual(aValue, 700); XCTAssertNotEqual(stop, NULL); @@ -2621,27 +2621,27 @@ static BOOL TestingEnum_IsValidValue(int32_t value) { const NSString *kKeys[] = { @"foo", @"bar", @"baz" }; const int32_t kValues[] = { 700, 701, 702 }; GPBStringEnumDictionary *dict = - [[GPBStringEnumDictionary alloc] initWithValues:kValues - forKeys:kKeys - count:GPBARRAYSIZE(kValues)]; + [[GPBStringEnumDictionary alloc] initWithEnums:kValues + forKeys:kKeys + count:GPBARRAYSIZE(kValues)]; XCTAssertNotNil(dict); XCTAssertEqual(dict.count, 3U); int32_t value; - XCTAssertTrue([dict valueForKey:@"foo" value:NULL]); - XCTAssertTrue([dict valueForKey:@"foo" value:&value]); + XCTAssertTrue([dict getEnum:NULL forKey:@"foo"]); + XCTAssertTrue([dict getEnum:&value forKey:@"foo"]); XCTAssertEqual(value, 700); - XCTAssertTrue([dict valueForKey:@"bar" value:NULL]); - XCTAssertTrue([dict valueForKey:@"bar" value:&value]); + XCTAssertTrue([dict getEnum:NULL forKey:@"bar"]); + XCTAssertTrue([dict getEnum:&value forKey:@"bar"]); XCTAssertEqual(value, 701); - XCTAssertTrue([dict valueForKey:@"baz" value:NULL]); - XCTAssertTrue([dict valueForKey:@"baz" value:&value]); + XCTAssertTrue([dict getEnum:NULL forKey:@"baz"]); + XCTAssertTrue([dict getEnum:&value forKey:@"baz"]); XCTAssertEqual(value, 702); - XCTAssertFalse([dict valueForKey:@"mumble" value:NULL]); + XCTAssertFalse([dict getEnum:NULL forKey:@"mumble"]); __block NSUInteger idx = 0; NSString **seenKeys = malloc(3 * sizeof(NSString*)); int32_t *seenValues = malloc(3 * sizeof(int32_t)); - [dict enumerateKeysAndValuesUsingBlock:^(NSString *aKey, int32_t aValue, BOOL *stop) { + [dict enumerateKeysAndEnumsUsingBlock:^(NSString *aKey, int32_t aValue, BOOL *stop) { XCTAssertLessThan(idx, 3U); seenKeys[idx] = aKey; seenValues[idx] = aValue; @@ -2663,7 +2663,7 @@ static BOOL TestingEnum_IsValidValue(int32_t value) { // Stopping the enumeration. idx = 0; - [dict enumerateKeysAndValuesUsingBlock:^(NSString *aKey, int32_t aValue, BOOL *stop) { + [dict enumerateKeysAndEnumsUsingBlock:^(NSString *aKey, int32_t aValue, BOOL *stop) { #pragma unused(aKey, aValue) if (idx == 1) *stop = YES; XCTAssertNotEqual(idx, 2U); @@ -2679,29 +2679,29 @@ static BOOL TestingEnum_IsValidValue(int32_t value) { const int32_t kValues2[] = { 700, 703, 702 }; const int32_t kValues3[] = { 700, 701, 702, 703 }; GPBStringEnumDictionary *dict1 = - [[GPBStringEnumDictionary alloc] initWithValues:kValues1 - forKeys:kKeys1 - count:GPBARRAYSIZE(kValues1)]; + [[GPBStringEnumDictionary alloc] initWithEnums:kValues1 + forKeys:kKeys1 + count:GPBARRAYSIZE(kValues1)]; XCTAssertNotNil(dict1); GPBStringEnumDictionary *dict1prime = - [[GPBStringEnumDictionary alloc] initWithValues:kValues1 - forKeys:kKeys1 - count:GPBARRAYSIZE(kValues1)]; + [[GPBStringEnumDictionary alloc] initWithEnums:kValues1 + forKeys:kKeys1 + count:GPBARRAYSIZE(kValues1)]; XCTAssertNotNil(dict1prime); GPBStringEnumDictionary *dict2 = - [[GPBStringEnumDictionary alloc] initWithValues:kValues2 - forKeys:kKeys1 - count:GPBARRAYSIZE(kValues2)]; + [[GPBStringEnumDictionary alloc] initWithEnums:kValues2 + forKeys:kKeys1 + count:GPBARRAYSIZE(kValues2)]; XCTAssertNotNil(dict2); GPBStringEnumDictionary *dict3 = - [[GPBStringEnumDictionary alloc] initWithValues:kValues1 - forKeys:kKeys2 - count:GPBARRAYSIZE(kValues1)]; + [[GPBStringEnumDictionary alloc] initWithEnums:kValues1 + forKeys:kKeys2 + count:GPBARRAYSIZE(kValues1)]; XCTAssertNotNil(dict3); GPBStringEnumDictionary *dict4 = - [[GPBStringEnumDictionary alloc] initWithValues:kValues3 - forKeys:kKeys1 - count:GPBARRAYSIZE(kValues3)]; + [[GPBStringEnumDictionary alloc] initWithEnums:kValues3 + forKeys:kKeys1 + count:GPBARRAYSIZE(kValues3)]; XCTAssertNotNil(dict4); // 1/1Prime should be different objects, but equal. @@ -2730,9 +2730,9 @@ static BOOL TestingEnum_IsValidValue(int32_t value) { const NSString *kKeys[] = { @"foo", @"bar", @"baz", @"mumble" }; const int32_t kValues[] = { 700, 701, 702, 703 }; GPBStringEnumDictionary *dict = - [[GPBStringEnumDictionary alloc] initWithValues:kValues - forKeys:kKeys - count:GPBARRAYSIZE(kValues)]; + [[GPBStringEnumDictionary alloc] initWithEnums:kValues + forKeys:kKeys + count:GPBARRAYSIZE(kValues)]; XCTAssertNotNil(dict); GPBStringEnumDictionary *dict2 = [dict copy]; @@ -2751,9 +2751,9 @@ static BOOL TestingEnum_IsValidValue(int32_t value) { const NSString *kKeys[] = { @"foo", @"bar", @"baz", @"mumble" }; const int32_t kValues[] = { 700, 701, 702, 703 }; GPBStringEnumDictionary *dict = - [[GPBStringEnumDictionary alloc] initWithValues:kValues - forKeys:kKeys - count:GPBARRAYSIZE(kValues)]; + [[GPBStringEnumDictionary alloc] initWithEnums:kValues + forKeys:kKeys + count:GPBARRAYSIZE(kValues)]; XCTAssertNotNil(dict); GPBStringEnumDictionary *dict2 = @@ -2771,31 +2771,31 @@ static BOOL TestingEnum_IsValidValue(int32_t value) { XCTAssertNotNil(dict); XCTAssertEqual(dict.count, 0U); - [dict setValue:700 forKey:@"foo"]; + [dict setEnum:700 forKey:@"foo"]; XCTAssertEqual(dict.count, 1U); const NSString *kKeys[] = { @"bar", @"baz", @"mumble" }; const int32_t kValues[] = { 701, 702, 703 }; GPBStringEnumDictionary *dict2 = - [[GPBStringEnumDictionary alloc] initWithValues:kValues - forKeys:kKeys - count:GPBARRAYSIZE(kValues)]; + [[GPBStringEnumDictionary alloc] initWithEnums:kValues + forKeys:kKeys + count:GPBARRAYSIZE(kValues)]; XCTAssertNotNil(dict2); [dict addRawEntriesFromDictionary:dict2]; XCTAssertEqual(dict.count, 4U); int32_t value; - XCTAssertTrue([dict valueForKey:@"foo" value:NULL]); - XCTAssertTrue([dict valueForKey:@"foo" value:&value]); + XCTAssertTrue([dict getEnum:NULL forKey:@"foo"]); + XCTAssertTrue([dict getEnum:&value forKey:@"foo"]); XCTAssertEqual(value, 700); - XCTAssertTrue([dict valueForKey:@"bar" value:NULL]); - XCTAssertTrue([dict valueForKey:@"bar" value:&value]); + XCTAssertTrue([dict getEnum:NULL forKey:@"bar"]); + XCTAssertTrue([dict getEnum:&value forKey:@"bar"]); XCTAssertEqual(value, 701); - XCTAssertTrue([dict valueForKey:@"baz" value:NULL]); - XCTAssertTrue([dict valueForKey:@"baz" value:&value]); + XCTAssertTrue([dict getEnum:NULL forKey:@"baz"]); + XCTAssertTrue([dict getEnum:&value forKey:@"baz"]); XCTAssertEqual(value, 702); - XCTAssertTrue([dict valueForKey:@"mumble" value:NULL]); - XCTAssertTrue([dict valueForKey:@"mumble" value:&value]); + XCTAssertTrue([dict getEnum:NULL forKey:@"mumble"]); + XCTAssertTrue([dict getEnum:&value forKey:@"mumble"]); XCTAssertEqual(value, 703); [dict2 release]; } @@ -2804,57 +2804,57 @@ static BOOL TestingEnum_IsValidValue(int32_t value) { const NSString *kKeys[] = { @"foo", @"bar", @"baz", @"mumble" }; const int32_t kValues[] = { 700, 701, 702, 703 }; GPBStringEnumDictionary *dict = - [[GPBStringEnumDictionary alloc] initWithValues:kValues - forKeys:kKeys - count:GPBARRAYSIZE(kValues)]; + [[GPBStringEnumDictionary alloc] initWithEnums:kValues + forKeys:kKeys + count:GPBARRAYSIZE(kValues)]; XCTAssertNotNil(dict); XCTAssertEqual(dict.count, 4U); - [dict removeValueForKey:@"bar"]; + [dict removeEnumForKey:@"bar"]; XCTAssertEqual(dict.count, 3U); int32_t value; - XCTAssertTrue([dict valueForKey:@"foo" value:NULL]); - XCTAssertTrue([dict valueForKey:@"foo" value:&value]); + XCTAssertTrue([dict getEnum:NULL forKey:@"foo"]); + XCTAssertTrue([dict getEnum:&value forKey:@"foo"]); XCTAssertEqual(value, 700); - XCTAssertFalse([dict valueForKey:@"bar" value:NULL]); - XCTAssertTrue([dict valueForKey:@"baz" value:NULL]); - XCTAssertTrue([dict valueForKey:@"baz" value:&value]); + XCTAssertFalse([dict getEnum:NULL forKey:@"bar"]); + XCTAssertTrue([dict getEnum:NULL forKey:@"baz"]); + XCTAssertTrue([dict getEnum:&value forKey:@"baz"]); XCTAssertEqual(value, 702); - XCTAssertTrue([dict valueForKey:@"mumble" value:NULL]); - XCTAssertTrue([dict valueForKey:@"mumble" value:&value]); + XCTAssertTrue([dict getEnum:NULL forKey:@"mumble"]); + XCTAssertTrue([dict getEnum:&value forKey:@"mumble"]); XCTAssertEqual(value, 703); // Remove again does nothing. - [dict removeValueForKey:@"bar"]; + [dict removeEnumForKey:@"bar"]; XCTAssertEqual(dict.count, 3U); - XCTAssertTrue([dict valueForKey:@"foo" value:NULL]); - XCTAssertTrue([dict valueForKey:@"foo" value:&value]); + XCTAssertTrue([dict getEnum:NULL forKey:@"foo"]); + XCTAssertTrue([dict getEnum:&value forKey:@"foo"]); XCTAssertEqual(value, 700); - XCTAssertFalse([dict valueForKey:@"bar" value:NULL]); - XCTAssertTrue([dict valueForKey:@"baz" value:NULL]); - XCTAssertTrue([dict valueForKey:@"baz" value:&value]); + XCTAssertFalse([dict getEnum:NULL forKey:@"bar"]); + XCTAssertTrue([dict getEnum:NULL forKey:@"baz"]); + XCTAssertTrue([dict getEnum:&value forKey:@"baz"]); XCTAssertEqual(value, 702); - XCTAssertTrue([dict valueForKey:@"mumble" value:NULL]); - XCTAssertTrue([dict valueForKey:@"mumble" value:&value]); + XCTAssertTrue([dict getEnum:NULL forKey:@"mumble"]); + XCTAssertTrue([dict getEnum:&value forKey:@"mumble"]); XCTAssertEqual(value, 703); - [dict removeValueForKey:@"mumble"]; + [dict removeEnumForKey:@"mumble"]; XCTAssertEqual(dict.count, 2U); - XCTAssertTrue([dict valueForKey:@"foo" value:NULL]); - XCTAssertTrue([dict valueForKey:@"foo" value:&value]); + XCTAssertTrue([dict getEnum:NULL forKey:@"foo"]); + XCTAssertTrue([dict getEnum:&value forKey:@"foo"]); XCTAssertEqual(value, 700); - XCTAssertFalse([dict valueForKey:@"bar" value:NULL]); - XCTAssertTrue([dict valueForKey:@"baz" value:NULL]); - XCTAssertTrue([dict valueForKey:@"baz" value:&value]); + XCTAssertFalse([dict getEnum:NULL forKey:@"bar"]); + XCTAssertTrue([dict getEnum:NULL forKey:@"baz"]); + XCTAssertTrue([dict getEnum:&value forKey:@"baz"]); XCTAssertEqual(value, 702); - XCTAssertFalse([dict valueForKey:@"mumble" value:NULL]); + XCTAssertFalse([dict getEnum:NULL forKey:@"mumble"]); [dict removeAll]; XCTAssertEqual(dict.count, 0U); - XCTAssertFalse([dict valueForKey:@"foo" value:NULL]); - XCTAssertFalse([dict valueForKey:@"bar" value:NULL]); - XCTAssertFalse([dict valueForKey:@"baz" value:NULL]); - XCTAssertFalse([dict valueForKey:@"mumble" value:NULL]); + XCTAssertFalse([dict getEnum:NULL forKey:@"foo"]); + XCTAssertFalse([dict getEnum:NULL forKey:@"bar"]); + XCTAssertFalse([dict getEnum:NULL forKey:@"baz"]); + XCTAssertFalse([dict getEnum:NULL forKey:@"mumble"]); [dict release]; } @@ -2862,75 +2862,75 @@ static BOOL TestingEnum_IsValidValue(int32_t value) { const NSString *kKeys[] = { @"foo", @"bar", @"baz", @"mumble" }; const int32_t kValues[] = { 700, 701, 702, 703 }; GPBStringEnumDictionary *dict = - [[GPBStringEnumDictionary alloc] initWithValues:kValues - forKeys:kKeys - count:GPBARRAYSIZE(kValues)]; + [[GPBStringEnumDictionary alloc] initWithEnums:kValues + forKeys:kKeys + count:GPBARRAYSIZE(kValues)]; XCTAssertNotNil(dict); XCTAssertEqual(dict.count, 4U); int32_t value; - XCTAssertTrue([dict valueForKey:@"foo" value:NULL]); - XCTAssertTrue([dict valueForKey:@"foo" value:&value]); + XCTAssertTrue([dict getEnum:NULL forKey:@"foo"]); + XCTAssertTrue([dict getEnum:&value forKey:@"foo"]); XCTAssertEqual(value, 700); - XCTAssertTrue([dict valueForKey:@"bar" value:NULL]); - XCTAssertTrue([dict valueForKey:@"bar" value:&value]); + XCTAssertTrue([dict getEnum:NULL forKey:@"bar"]); + XCTAssertTrue([dict getEnum:&value forKey:@"bar"]); XCTAssertEqual(value, 701); - XCTAssertTrue([dict valueForKey:@"baz" value:NULL]); - XCTAssertTrue([dict valueForKey:@"baz" value:&value]); + XCTAssertTrue([dict getEnum:NULL forKey:@"baz"]); + XCTAssertTrue([dict getEnum:&value forKey:@"baz"]); XCTAssertEqual(value, 702); - XCTAssertTrue([dict valueForKey:@"mumble" value:NULL]); - XCTAssertTrue([dict valueForKey:@"mumble" value:&value]); + XCTAssertTrue([dict getEnum:NULL forKey:@"mumble"]); + XCTAssertTrue([dict getEnum:&value forKey:@"mumble"]); XCTAssertEqual(value, 703); - [dict setValue:703 forKey:@"foo"]; + [dict setEnum:703 forKey:@"foo"]; XCTAssertEqual(dict.count, 4U); - XCTAssertTrue([dict valueForKey:@"foo" value:NULL]); - XCTAssertTrue([dict valueForKey:@"foo" value:&value]); + XCTAssertTrue([dict getEnum:NULL forKey:@"foo"]); + XCTAssertTrue([dict getEnum:&value forKey:@"foo"]); XCTAssertEqual(value, 703); - XCTAssertTrue([dict valueForKey:@"bar" value:NULL]); - XCTAssertTrue([dict valueForKey:@"bar" value:&value]); + XCTAssertTrue([dict getEnum:NULL forKey:@"bar"]); + XCTAssertTrue([dict getEnum:&value forKey:@"bar"]); XCTAssertEqual(value, 701); - XCTAssertTrue([dict valueForKey:@"baz" value:NULL]); - XCTAssertTrue([dict valueForKey:@"baz" value:&value]); + XCTAssertTrue([dict getEnum:NULL forKey:@"baz"]); + XCTAssertTrue([dict getEnum:&value forKey:@"baz"]); XCTAssertEqual(value, 702); - XCTAssertTrue([dict valueForKey:@"mumble" value:NULL]); - XCTAssertTrue([dict valueForKey:@"mumble" value:&value]); + XCTAssertTrue([dict getEnum:NULL forKey:@"mumble"]); + XCTAssertTrue([dict getEnum:&value forKey:@"mumble"]); XCTAssertEqual(value, 703); - [dict setValue:701 forKey:@"mumble"]; + [dict setEnum:701 forKey:@"mumble"]; XCTAssertEqual(dict.count, 4U); - XCTAssertTrue([dict valueForKey:@"foo" value:NULL]); - XCTAssertTrue([dict valueForKey:@"foo" value:&value]); + XCTAssertTrue([dict getEnum:NULL forKey:@"foo"]); + XCTAssertTrue([dict getEnum:&value forKey:@"foo"]); XCTAssertEqual(value, 703); - XCTAssertTrue([dict valueForKey:@"bar" value:NULL]); - XCTAssertTrue([dict valueForKey:@"bar" value:&value]); + XCTAssertTrue([dict getEnum:NULL forKey:@"bar"]); + XCTAssertTrue([dict getEnum:&value forKey:@"bar"]); XCTAssertEqual(value, 701); - XCTAssertTrue([dict valueForKey:@"baz" value:NULL]); - XCTAssertTrue([dict valueForKey:@"baz" value:&value]); + XCTAssertTrue([dict getEnum:NULL forKey:@"baz"]); + XCTAssertTrue([dict getEnum:&value forKey:@"baz"]); XCTAssertEqual(value, 702); - XCTAssertTrue([dict valueForKey:@"mumble" value:NULL]); - XCTAssertTrue([dict valueForKey:@"mumble" value:&value]); + XCTAssertTrue([dict getEnum:NULL forKey:@"mumble"]); + XCTAssertTrue([dict getEnum:&value forKey:@"mumble"]); XCTAssertEqual(value, 701); const NSString *kKeys2[] = { @"bar", @"baz" }; const int32_t kValues2[] = { 702, 700 }; GPBStringEnumDictionary *dict2 = - [[GPBStringEnumDictionary alloc] initWithValues:kValues2 - forKeys:kKeys2 - count:GPBARRAYSIZE(kValues2)]; + [[GPBStringEnumDictionary alloc] initWithEnums:kValues2 + forKeys:kKeys2 + count:GPBARRAYSIZE(kValues2)]; XCTAssertNotNil(dict2); [dict addRawEntriesFromDictionary:dict2]; XCTAssertEqual(dict.count, 4U); - XCTAssertTrue([dict valueForKey:@"foo" value:NULL]); - XCTAssertTrue([dict valueForKey:@"foo" value:&value]); + XCTAssertTrue([dict getEnum:NULL forKey:@"foo"]); + XCTAssertTrue([dict getEnum:&value forKey:@"foo"]); XCTAssertEqual(value, 703); - XCTAssertTrue([dict valueForKey:@"bar" value:NULL]); - XCTAssertTrue([dict valueForKey:@"bar" value:&value]); + XCTAssertTrue([dict getEnum:NULL forKey:@"bar"]); + XCTAssertTrue([dict getEnum:&value forKey:@"bar"]); XCTAssertEqual(value, 702); - XCTAssertTrue([dict valueForKey:@"baz" value:NULL]); - XCTAssertTrue([dict valueForKey:@"baz" value:&value]); + XCTAssertTrue([dict getEnum:NULL forKey:@"baz"]); + XCTAssertTrue([dict getEnum:&value forKey:@"baz"]); XCTAssertEqual(value, 700); - XCTAssertTrue([dict valueForKey:@"mumble" value:NULL]); - XCTAssertTrue([dict valueForKey:@"mumble" value:&value]); + XCTAssertTrue([dict getEnum:NULL forKey:@"mumble"]); + XCTAssertTrue([dict getEnum:&value forKey:@"mumble"]); XCTAssertEqual(value, 701); [dict2 release]; @@ -2958,24 +2958,24 @@ static BOOL TestingEnum_IsValidValue(int32_t value) { XCTAssertEqual(dict.count, 3U); XCTAssertTrue(dict.validationFunc == TestingEnum_IsValidValue); // Pointer comparison int32_t value; - XCTAssertTrue([dict valueForKey:@"foo" rawValue:NULL]); - XCTAssertTrue([dict valueForKey:@"foo" rawValue:&value]); + XCTAssertTrue([dict getRawValue:NULL forKey:@"foo"]); + XCTAssertTrue([dict getRawValue:&value forKey:@"foo"]); XCTAssertEqual(value, 700); - XCTAssertTrue([dict valueForKey:@"bar" value:NULL]); - XCTAssertTrue([dict valueForKey:@"bar" value:&value]); + XCTAssertTrue([dict getEnum:NULL forKey:@"bar"]); + XCTAssertTrue([dict getEnum:&value forKey:@"bar"]); XCTAssertEqual(value, kGPBUnrecognizedEnumeratorValue); - XCTAssertTrue([dict valueForKey:@"bar" rawValue:NULL]); - XCTAssertTrue([dict valueForKey:@"bar" rawValue:&value]); + XCTAssertTrue([dict getRawValue:NULL forKey:@"bar"]); + XCTAssertTrue([dict getRawValue:&value forKey:@"bar"]); XCTAssertEqual(value, 801); - XCTAssertTrue([dict valueForKey:@"baz" rawValue:NULL]); - XCTAssertTrue([dict valueForKey:@"baz" rawValue:&value]); + XCTAssertTrue([dict getRawValue:NULL forKey:@"baz"]); + XCTAssertTrue([dict getRawValue:&value forKey:@"baz"]); XCTAssertEqual(value, 702); - XCTAssertFalse([dict valueForKey:@"mumble" rawValue:NULL]); + XCTAssertFalse([dict getRawValue:NULL forKey:@"mumble"]); __block NSUInteger idx = 0; NSString **seenKeys = malloc(3 * sizeof(NSString*)); int32_t *seenValues = malloc(3 * sizeof(int32_t)); - [dict enumerateKeysAndValuesUsingBlock:^(NSString *aKey, int32_t aValue, BOOL *stop) { + [dict enumerateKeysAndEnumsUsingBlock:^(NSString *aKey, int32_t aValue, BOOL *stop) { XCTAssertLessThan(idx, 3U); seenKeys[idx] = aKey; seenValues[idx] = aValue; @@ -3136,7 +3136,7 @@ static BOOL TestingEnum_IsValidValue(int32_t value) { XCTAssertNotNil(dict); XCTAssertEqual(dict.count, 0U); - XCTAssertThrowsSpecificNamed([dict setValue:801 forKey:@"bar"], // Unknown + XCTAssertThrowsSpecificNamed([dict setEnum:801 forKey:@"bar"], // Unknown NSException, NSInvalidArgumentException); XCTAssertEqual(dict.count, 0U); [dict setRawValue:801 forKey:@"bar"]; // Unknown @@ -3145,31 +3145,31 @@ static BOOL TestingEnum_IsValidValue(int32_t value) { const NSString *kKeys[] = { @"foo", @"baz", @"mumble" }; const int32_t kValues[] = { 700, 702, 803 }; // Unknown GPBStringEnumDictionary *dict2 = - [[GPBStringEnumDictionary alloc] initWithValues:kValues - forKeys:kKeys - count:GPBARRAYSIZE(kValues)]; + [[GPBStringEnumDictionary alloc] initWithEnums:kValues + forKeys:kKeys + count:GPBARRAYSIZE(kValues)]; XCTAssertNotNil(dict2); [dict addRawEntriesFromDictionary:dict2]; XCTAssertEqual(dict.count, 4U); int32_t value; - XCTAssertTrue([dict valueForKey:@"foo" value:NULL]); - XCTAssertTrue([dict valueForKey:@"foo" value:&value]); + XCTAssertTrue([dict getEnum:NULL forKey:@"foo"]); + XCTAssertTrue([dict getEnum:&value forKey:@"foo"]); XCTAssertEqual(value, 700); - XCTAssertTrue([dict valueForKey:@"bar" value:NULL]); - XCTAssertTrue([dict valueForKey:@"bar" value:&value]); + XCTAssertTrue([dict getEnum:NULL forKey:@"bar"]); + XCTAssertTrue([dict getEnum:&value forKey:@"bar"]); XCTAssertEqual(value, kGPBUnrecognizedEnumeratorValue); - XCTAssertTrue([dict valueForKey:@"bar" rawValue:NULL]); - XCTAssertTrue([dict valueForKey:@"bar" rawValue:&value]); + XCTAssertTrue([dict getRawValue:NULL forKey:@"bar"]); + XCTAssertTrue([dict getRawValue:&value forKey:@"bar"]); XCTAssertEqual(value, 801); - XCTAssertTrue([dict valueForKey:@"baz" value:NULL]); - XCTAssertTrue([dict valueForKey:@"baz" value:&value]); + XCTAssertTrue([dict getEnum:NULL forKey:@"baz"]); + XCTAssertTrue([dict getEnum:&value forKey:@"baz"]); XCTAssertEqual(value, 702); - XCTAssertTrue([dict valueForKey:@"mumble" value:NULL]); - XCTAssertTrue([dict valueForKey:@"mumble" value:&value]); + XCTAssertTrue([dict getEnum:NULL forKey:@"mumble"]); + XCTAssertTrue([dict getEnum:&value forKey:@"mumble"]); XCTAssertEqual(value, kGPBUnrecognizedEnumeratorValue); - XCTAssertTrue([dict valueForKey:@"mumble" rawValue:NULL]); - XCTAssertTrue([dict valueForKey:@"mumble" rawValue:&value]); + XCTAssertTrue([dict getRawValue:NULL forKey:@"mumble"]); + XCTAssertTrue([dict getRawValue:&value forKey:@"mumble"]); XCTAssertEqual(value, 803); [dict2 release]; } @@ -3185,51 +3185,51 @@ static BOOL TestingEnum_IsValidValue(int32_t value) { XCTAssertNotNil(dict); XCTAssertEqual(dict.count, 4U); - [dict removeValueForKey:@"bar"]; + [dict removeEnumForKey:@"bar"]; XCTAssertEqual(dict.count, 3U); int32_t value; - XCTAssertTrue([dict valueForKey:@"foo" value:NULL]); - XCTAssertTrue([dict valueForKey:@"foo" value:&value]); + XCTAssertTrue([dict getEnum:NULL forKey:@"foo"]); + XCTAssertTrue([dict getEnum:&value forKey:@"foo"]); XCTAssertEqual(value, 700); - XCTAssertFalse([dict valueForKey:@"bar" value:NULL]); - XCTAssertTrue([dict valueForKey:@"baz" value:NULL]); - XCTAssertTrue([dict valueForKey:@"baz" value:&value]); + XCTAssertFalse([dict getEnum:NULL forKey:@"bar"]); + XCTAssertTrue([dict getEnum:NULL forKey:@"baz"]); + XCTAssertTrue([dict getEnum:&value forKey:@"baz"]); XCTAssertEqual(value, 702); - XCTAssertTrue([dict valueForKey:@"mumble" rawValue:NULL]); - XCTAssertTrue([dict valueForKey:@"mumble" rawValue:&value]); + XCTAssertTrue([dict getRawValue:NULL forKey:@"mumble"]); + XCTAssertTrue([dict getRawValue:&value forKey:@"mumble"]); XCTAssertEqual(value, 803); // Remove again does nothing. - [dict removeValueForKey:@"bar"]; + [dict removeEnumForKey:@"bar"]; XCTAssertEqual(dict.count, 3U); - XCTAssertTrue([dict valueForKey:@"foo" value:NULL]); - XCTAssertTrue([dict valueForKey:@"foo" value:&value]); + XCTAssertTrue([dict getEnum:NULL forKey:@"foo"]); + XCTAssertTrue([dict getEnum:&value forKey:@"foo"]); XCTAssertEqual(value, 700); - XCTAssertFalse([dict valueForKey:@"bar" value:NULL]); - XCTAssertTrue([dict valueForKey:@"baz" value:NULL]); - XCTAssertTrue([dict valueForKey:@"baz" value:&value]); + XCTAssertFalse([dict getEnum:NULL forKey:@"bar"]); + XCTAssertTrue([dict getEnum:NULL forKey:@"baz"]); + XCTAssertTrue([dict getEnum:&value forKey:@"baz"]); XCTAssertEqual(value, 702); - XCTAssertTrue([dict valueForKey:@"mumble" rawValue:NULL]); - XCTAssertTrue([dict valueForKey:@"mumble" rawValue:&value]); + XCTAssertTrue([dict getRawValue:NULL forKey:@"mumble"]); + XCTAssertTrue([dict getRawValue:&value forKey:@"mumble"]); XCTAssertEqual(value, 803); - [dict removeValueForKey:@"mumble"]; + [dict removeEnumForKey:@"mumble"]; XCTAssertEqual(dict.count, 2U); - XCTAssertTrue([dict valueForKey:@"foo" value:NULL]); - XCTAssertTrue([dict valueForKey:@"foo" value:&value]); + XCTAssertTrue([dict getEnum:NULL forKey:@"foo"]); + XCTAssertTrue([dict getEnum:&value forKey:@"foo"]); XCTAssertEqual(value, 700); - XCTAssertFalse([dict valueForKey:@"bar" value:NULL]); - XCTAssertTrue([dict valueForKey:@"baz" value:NULL]); - XCTAssertTrue([dict valueForKey:@"baz" value:&value]); + XCTAssertFalse([dict getEnum:NULL forKey:@"bar"]); + XCTAssertTrue([dict getEnum:NULL forKey:@"baz"]); + XCTAssertTrue([dict getEnum:&value forKey:@"baz"]); XCTAssertEqual(value, 702); - XCTAssertFalse([dict valueForKey:@"mumble" value:NULL]); + XCTAssertFalse([dict getEnum:NULL forKey:@"mumble"]); [dict removeAll]; XCTAssertEqual(dict.count, 0U); - XCTAssertFalse([dict valueForKey:@"foo" value:NULL]); - XCTAssertFalse([dict valueForKey:@"bar" value:NULL]); - XCTAssertFalse([dict valueForKey:@"baz" value:NULL]); - XCTAssertFalse([dict valueForKey:@"mumble" value:NULL]); + XCTAssertFalse([dict getEnum:NULL forKey:@"foo"]); + XCTAssertFalse([dict getEnum:NULL forKey:@"bar"]); + XCTAssertFalse([dict getEnum:NULL forKey:@"baz"]); + XCTAssertFalse([dict getEnum:NULL forKey:@"mumble"]); [dict release]; } @@ -3244,63 +3244,63 @@ static BOOL TestingEnum_IsValidValue(int32_t value) { XCTAssertNotNil(dict); XCTAssertEqual(dict.count, 4U); int32_t value; - XCTAssertTrue([dict valueForKey:@"foo" value:NULL]); - XCTAssertTrue([dict valueForKey:@"foo" value:&value]); + XCTAssertTrue([dict getEnum:NULL forKey:@"foo"]); + XCTAssertTrue([dict getEnum:&value forKey:@"foo"]); XCTAssertEqual(value, 700); - XCTAssertTrue([dict valueForKey:@"bar" rawValue:NULL]); - XCTAssertTrue([dict valueForKey:@"bar" rawValue:&value]); + XCTAssertTrue([dict getRawValue:NULL forKey:@"bar"]); + XCTAssertTrue([dict getRawValue:&value forKey:@"bar"]); XCTAssertEqual(value, 801); - XCTAssertTrue([dict valueForKey:@"baz" value:NULL]); - XCTAssertTrue([dict valueForKey:@"baz" value:&value]); + XCTAssertTrue([dict getEnum:NULL forKey:@"baz"]); + XCTAssertTrue([dict getEnum:&value forKey:@"baz"]); XCTAssertEqual(value, 702); - XCTAssertTrue([dict valueForKey:@"mumble" rawValue:NULL]); - XCTAssertTrue([dict valueForKey:@"mumble" rawValue:&value]); + XCTAssertTrue([dict getRawValue:NULL forKey:@"mumble"]); + XCTAssertTrue([dict getRawValue:&value forKey:@"mumble"]); XCTAssertEqual(value, 803); - XCTAssertThrowsSpecificNamed([dict setValue:803 forKey:@"foo"], // Unknown + XCTAssertThrowsSpecificNamed([dict setEnum:803 forKey:@"foo"], // Unknown NSException, NSInvalidArgumentException); XCTAssertEqual(dict.count, 4U); - XCTAssertTrue([dict valueForKey:@"foo" value:NULL]); - XCTAssertTrue([dict valueForKey:@"foo" value:&value]); + XCTAssertTrue([dict getEnum:NULL forKey:@"foo"]); + XCTAssertTrue([dict getEnum:&value forKey:@"foo"]); XCTAssertEqual(value, 700); - XCTAssertTrue([dict valueForKey:@"bar" rawValue:NULL]); - XCTAssertTrue([dict valueForKey:@"bar" rawValue:&value]); + XCTAssertTrue([dict getRawValue:NULL forKey:@"bar"]); + XCTAssertTrue([dict getRawValue:&value forKey:@"bar"]); XCTAssertEqual(value, 801); - XCTAssertTrue([dict valueForKey:@"baz" value:NULL]); - XCTAssertTrue([dict valueForKey:@"baz" value:&value]); + XCTAssertTrue([dict getEnum:NULL forKey:@"baz"]); + XCTAssertTrue([dict getEnum:&value forKey:@"baz"]); XCTAssertEqual(value, 702); - XCTAssertTrue([dict valueForKey:@"mumble" rawValue:NULL]); - XCTAssertTrue([dict valueForKey:@"mumble" rawValue:&value]); + XCTAssertTrue([dict getRawValue:NULL forKey:@"mumble"]); + XCTAssertTrue([dict getRawValue:&value forKey:@"mumble"]); XCTAssertEqual(value, 803); [dict setRawValue:803 forKey:@"foo"]; // Unknown XCTAssertEqual(dict.count, 4U); - XCTAssertTrue([dict valueForKey:@"foo" rawValue:NULL]); - XCTAssertTrue([dict valueForKey:@"foo" rawValue:&value]); + XCTAssertTrue([dict getRawValue:NULL forKey:@"foo"]); + XCTAssertTrue([dict getRawValue:&value forKey:@"foo"]); XCTAssertEqual(value, 803); - XCTAssertTrue([dict valueForKey:@"bar" rawValue:NULL]); - XCTAssertTrue([dict valueForKey:@"bar" rawValue:&value]); + XCTAssertTrue([dict getRawValue:NULL forKey:@"bar"]); + XCTAssertTrue([dict getRawValue:&value forKey:@"bar"]); XCTAssertEqual(value, 801); - XCTAssertTrue([dict valueForKey:@"baz" value:NULL]); - XCTAssertTrue([dict valueForKey:@"baz" value:&value]); + XCTAssertTrue([dict getEnum:NULL forKey:@"baz"]); + XCTAssertTrue([dict getEnum:&value forKey:@"baz"]); XCTAssertEqual(value, 702); - XCTAssertTrue([dict valueForKey:@"mumble" rawValue:NULL]); - XCTAssertTrue([dict valueForKey:@"mumble" rawValue:&value]); + XCTAssertTrue([dict getRawValue:NULL forKey:@"mumble"]); + XCTAssertTrue([dict getRawValue:&value forKey:@"mumble"]); XCTAssertEqual(value, 803); [dict setRawValue:700 forKey:@"mumble"]; XCTAssertEqual(dict.count, 4U); - XCTAssertTrue([dict valueForKey:@"foo" rawValue:NULL]); - XCTAssertTrue([dict valueForKey:@"foo" rawValue:&value]); + XCTAssertTrue([dict getRawValue:NULL forKey:@"foo"]); + XCTAssertTrue([dict getRawValue:&value forKey:@"foo"]); XCTAssertEqual(value, 803); - XCTAssertTrue([dict valueForKey:@"bar" rawValue:NULL]); - XCTAssertTrue([dict valueForKey:@"bar" rawValue:&value]); + XCTAssertTrue([dict getRawValue:NULL forKey:@"bar"]); + XCTAssertTrue([dict getRawValue:&value forKey:@"bar"]); XCTAssertEqual(value, 801); - XCTAssertTrue([dict valueForKey:@"baz" value:NULL]); - XCTAssertTrue([dict valueForKey:@"baz" value:&value]); + XCTAssertTrue([dict getEnum:NULL forKey:@"baz"]); + XCTAssertTrue([dict getEnum:&value forKey:@"baz"]); XCTAssertEqual(value, 702); - XCTAssertTrue([dict valueForKey:@"mumble" value:NULL]); - XCTAssertTrue([dict valueForKey:@"mumble" value:&value]); + XCTAssertTrue([dict getEnum:NULL forKey:@"mumble"]); + XCTAssertTrue([dict getEnum:&value forKey:@"mumble"]); XCTAssertEqual(value, 700); const NSString *kKeys2[] = { @"bar", @"baz" }; @@ -3313,17 +3313,17 @@ static BOOL TestingEnum_IsValidValue(int32_t value) { XCTAssertNotNil(dict2); [dict addRawEntriesFromDictionary:dict2]; XCTAssertEqual(dict.count, 4U); - XCTAssertTrue([dict valueForKey:@"foo" rawValue:NULL]); - XCTAssertTrue([dict valueForKey:@"foo" rawValue:&value]); + XCTAssertTrue([dict getRawValue:NULL forKey:@"foo"]); + XCTAssertTrue([dict getRawValue:&value forKey:@"foo"]); XCTAssertEqual(value, 803); - XCTAssertTrue([dict valueForKey:@"bar" value:NULL]); - XCTAssertTrue([dict valueForKey:@"bar" value:&value]); + XCTAssertTrue([dict getEnum:NULL forKey:@"bar"]); + XCTAssertTrue([dict getEnum:&value forKey:@"bar"]); XCTAssertEqual(value, 702); - XCTAssertTrue([dict valueForKey:@"baz" rawValue:NULL]); - XCTAssertTrue([dict valueForKey:@"baz" rawValue:&value]); + XCTAssertTrue([dict getRawValue:NULL forKey:@"baz"]); + XCTAssertTrue([dict getRawValue:&value forKey:@"baz"]); XCTAssertEqual(value, 801); - XCTAssertTrue([dict valueForKey:@"mumble" value:NULL]); - XCTAssertTrue([dict valueForKey:@"mumble" value:&value]); + XCTAssertTrue([dict getEnum:NULL forKey:@"mumble"]); + XCTAssertTrue([dict getEnum:&value forKey:@"mumble"]); XCTAssertEqual(value, 700); [dict2 release]; diff --git a/objectivec/Tests/GPBDictionaryTests+UInt32.m b/objectivec/Tests/GPBDictionaryTests+UInt32.m index 499f2adb..1d3f6f78 100644 --- a/objectivec/Tests/GPBDictionaryTests+UInt32.m +++ b/objectivec/Tests/GPBDictionaryTests+UInt32.m @@ -45,10 +45,10 @@ // To let the testing macros work, add some extra methods to simplify things. @interface GPBUInt32EnumDictionary (TestingTweak) -+ (instancetype)dictionaryWithValue:(int32_t)value forKey:(uint32_t)key; -- (instancetype)initWithValues:(const int32_t [])values - forKeys:(const uint32_t [])keys - count:(NSUInteger)count; ++ (instancetype)dictionaryWithEnum:(int32_t)value forKey:(uint32_t)key; +- (instancetype)initWithEnums:(const int32_t [])values + forKeys:(const uint32_t [])keys + count:(NSUInteger)count; @end static BOOL TestingEnum_IsValidValue(int32_t value) { @@ -64,7 +64,7 @@ static BOOL TestingEnum_IsValidValue(int32_t value) { } @implementation GPBUInt32EnumDictionary (TestingTweak) -+ (instancetype)dictionaryWithValue:(int32_t)value forKey:(uint32_t)key { ++ (instancetype)dictionaryWithEnum:(int32_t)value forKey:(uint32_t)key { // Cast is needed to compiler knows what class we are invoking initWithValues: on to get the // type correct. return [[(GPBUInt32EnumDictionary*)[self alloc] initWithValidationFunction:TestingEnum_IsValidValue @@ -72,9 +72,9 @@ static BOOL TestingEnum_IsValidValue(int32_t value) { forKeys:&key count:1] autorelease]; } -- (instancetype)initWithValues:(const int32_t [])values - forKeys:(const uint32_t [])keys - count:(NSUInteger)count { +- (instancetype)initWithEnums:(const int32_t [])values + forKeys:(const uint32_t [])keys + count:(NSUInteger)count { return [self initWithValidationFunction:TestingEnum_IsValidValue rawValues:values forKeys:keys @@ -94,8 +94,8 @@ static BOOL TestingEnum_IsValidValue(int32_t value) { GPBUInt32UInt32Dictionary *dict = [[GPBUInt32UInt32Dictionary alloc] init]; XCTAssertNotNil(dict); XCTAssertEqual(dict.count, 0U); - XCTAssertFalse([dict valueForKey:1U value:NULL]); - [dict enumerateKeysAndValuesUsingBlock:^(uint32_t aKey, uint32_t aValue, BOOL *stop) { + XCTAssertFalse([dict getUInt32:NULL forKey:1U]); + [dict enumerateKeysAndUInt32sUsingBlock:^(uint32_t aKey, uint32_t aValue, BOOL *stop) { #pragma unused(aKey, aValue, stop) XCTFail(@"Shouldn't get here!"); }]; @@ -103,15 +103,15 @@ static BOOL TestingEnum_IsValidValue(int32_t value) { } - (void)testOne { - GPBUInt32UInt32Dictionary *dict = [GPBUInt32UInt32Dictionary dictionaryWithValue:100U forKey:1U]; + GPBUInt32UInt32Dictionary *dict = [GPBUInt32UInt32Dictionary dictionaryWithUInt32:100U forKey:1U]; XCTAssertNotNil(dict); XCTAssertEqual(dict.count, 1U); uint32_t value; - XCTAssertTrue([dict valueForKey:1U value:NULL]); - XCTAssertTrue([dict valueForKey:1U value:&value]); + XCTAssertTrue([dict getUInt32:NULL forKey:1U]); + XCTAssertTrue([dict getUInt32:&value forKey:1U]); XCTAssertEqual(value, 100U); - XCTAssertFalse([dict valueForKey:2U value:NULL]); - [dict enumerateKeysAndValuesUsingBlock:^(uint32_t aKey, uint32_t aValue, BOOL *stop) { + XCTAssertFalse([dict getUInt32:NULL forKey:2U]); + [dict enumerateKeysAndUInt32sUsingBlock:^(uint32_t aKey, uint32_t aValue, BOOL *stop) { XCTAssertEqual(aKey, 1U); XCTAssertEqual(aValue, 100U); XCTAssertNotEqual(stop, NULL); @@ -122,27 +122,27 @@ static BOOL TestingEnum_IsValidValue(int32_t value) { const uint32_t kKeys[] = { 1U, 2U, 3U }; const uint32_t kValues[] = { 100U, 101U, 102U }; GPBUInt32UInt32Dictionary *dict = - [[GPBUInt32UInt32Dictionary alloc] initWithValues:kValues - forKeys:kKeys - count:GPBARRAYSIZE(kValues)]; + [[GPBUInt32UInt32Dictionary alloc] initWithUInt32s:kValues + forKeys:kKeys + count:GPBARRAYSIZE(kValues)]; XCTAssertNotNil(dict); XCTAssertEqual(dict.count, 3U); uint32_t value; - XCTAssertTrue([dict valueForKey:1U value:NULL]); - XCTAssertTrue([dict valueForKey:1U value:&value]); + XCTAssertTrue([dict getUInt32:NULL forKey:1U]); + XCTAssertTrue([dict getUInt32:&value forKey:1U]); XCTAssertEqual(value, 100U); - XCTAssertTrue([dict valueForKey:2U value:NULL]); - XCTAssertTrue([dict valueForKey:2U value:&value]); + XCTAssertTrue([dict getUInt32:NULL forKey:2U]); + XCTAssertTrue([dict getUInt32:&value forKey:2U]); XCTAssertEqual(value, 101U); - XCTAssertTrue([dict valueForKey:3U value:NULL]); - XCTAssertTrue([dict valueForKey:3U value:&value]); + XCTAssertTrue([dict getUInt32:NULL forKey:3U]); + XCTAssertTrue([dict getUInt32:&value forKey:3U]); XCTAssertEqual(value, 102U); - XCTAssertFalse([dict valueForKey:4U value:NULL]); + XCTAssertFalse([dict getUInt32:NULL forKey:4U]); __block NSUInteger idx = 0; uint32_t *seenKeys = malloc(3 * sizeof(uint32_t)); uint32_t *seenValues = malloc(3 * sizeof(uint32_t)); - [dict enumerateKeysAndValuesUsingBlock:^(uint32_t aKey, uint32_t aValue, BOOL *stop) { + [dict enumerateKeysAndUInt32sUsingBlock:^(uint32_t aKey, uint32_t aValue, BOOL *stop) { XCTAssertLessThan(idx, 3U); seenKeys[idx] = aKey; seenValues[idx] = aValue; @@ -164,7 +164,7 @@ static BOOL TestingEnum_IsValidValue(int32_t value) { // Stopping the enumeration. idx = 0; - [dict enumerateKeysAndValuesUsingBlock:^(uint32_t aKey, uint32_t aValue, BOOL *stop) { + [dict enumerateKeysAndUInt32sUsingBlock:^(uint32_t aKey, uint32_t aValue, BOOL *stop) { #pragma unused(aKey, aValue) if (idx == 1) *stop = YES; XCTAssertNotEqual(idx, 2U); @@ -180,29 +180,29 @@ static BOOL TestingEnum_IsValidValue(int32_t value) { const uint32_t kValues2[] = { 100U, 103U, 102U }; const uint32_t kValues3[] = { 100U, 101U, 102U, 103U }; GPBUInt32UInt32Dictionary *dict1 = - [[GPBUInt32UInt32Dictionary alloc] initWithValues:kValues1 - forKeys:kKeys1 - count:GPBARRAYSIZE(kValues1)]; + [[GPBUInt32UInt32Dictionary alloc] initWithUInt32s:kValues1 + forKeys:kKeys1 + count:GPBARRAYSIZE(kValues1)]; XCTAssertNotNil(dict1); GPBUInt32UInt32Dictionary *dict1prime = - [[GPBUInt32UInt32Dictionary alloc] initWithValues:kValues1 - forKeys:kKeys1 - count:GPBARRAYSIZE(kValues1)]; + [[GPBUInt32UInt32Dictionary alloc] initWithUInt32s:kValues1 + forKeys:kKeys1 + count:GPBARRAYSIZE(kValues1)]; XCTAssertNotNil(dict1prime); GPBUInt32UInt32Dictionary *dict2 = - [[GPBUInt32UInt32Dictionary alloc] initWithValues:kValues2 - forKeys:kKeys1 - count:GPBARRAYSIZE(kValues2)]; + [[GPBUInt32UInt32Dictionary alloc] initWithUInt32s:kValues2 + forKeys:kKeys1 + count:GPBARRAYSIZE(kValues2)]; XCTAssertNotNil(dict2); GPBUInt32UInt32Dictionary *dict3 = - [[GPBUInt32UInt32Dictionary alloc] initWithValues:kValues1 - forKeys:kKeys2 - count:GPBARRAYSIZE(kValues1)]; + [[GPBUInt32UInt32Dictionary alloc] initWithUInt32s:kValues1 + forKeys:kKeys2 + count:GPBARRAYSIZE(kValues1)]; XCTAssertNotNil(dict3); GPBUInt32UInt32Dictionary *dict4 = - [[GPBUInt32UInt32Dictionary alloc] initWithValues:kValues3 - forKeys:kKeys1 - count:GPBARRAYSIZE(kValues3)]; + [[GPBUInt32UInt32Dictionary alloc] initWithUInt32s:kValues3 + forKeys:kKeys1 + count:GPBARRAYSIZE(kValues3)]; XCTAssertNotNil(dict4); // 1/1Prime should be different objects, but equal. @@ -231,9 +231,9 @@ static BOOL TestingEnum_IsValidValue(int32_t value) { const uint32_t kKeys[] = { 1U, 2U, 3U, 4U }; const uint32_t kValues[] = { 100U, 101U, 102U, 103U }; GPBUInt32UInt32Dictionary *dict = - [[GPBUInt32UInt32Dictionary alloc] initWithValues:kValues - forKeys:kKeys - count:GPBARRAYSIZE(kValues)]; + [[GPBUInt32UInt32Dictionary alloc] initWithUInt32s:kValues + forKeys:kKeys + count:GPBARRAYSIZE(kValues)]; XCTAssertNotNil(dict); GPBUInt32UInt32Dictionary *dict2 = [dict copy]; @@ -252,9 +252,9 @@ static BOOL TestingEnum_IsValidValue(int32_t value) { const uint32_t kKeys[] = { 1U, 2U, 3U, 4U }; const uint32_t kValues[] = { 100U, 101U, 102U, 103U }; GPBUInt32UInt32Dictionary *dict = - [[GPBUInt32UInt32Dictionary alloc] initWithValues:kValues - forKeys:kKeys - count:GPBARRAYSIZE(kValues)]; + [[GPBUInt32UInt32Dictionary alloc] initWithUInt32s:kValues + forKeys:kKeys + count:GPBARRAYSIZE(kValues)]; XCTAssertNotNil(dict); GPBUInt32UInt32Dictionary *dict2 = @@ -272,31 +272,31 @@ static BOOL TestingEnum_IsValidValue(int32_t value) { XCTAssertNotNil(dict); XCTAssertEqual(dict.count, 0U); - [dict setValue:100U forKey:1U]; + [dict setUInt32:100U forKey:1U]; XCTAssertEqual(dict.count, 1U); const uint32_t kKeys[] = { 2U, 3U, 4U }; const uint32_t kValues[] = { 101U, 102U, 103U }; GPBUInt32UInt32Dictionary *dict2 = - [[GPBUInt32UInt32Dictionary alloc] initWithValues:kValues - forKeys:kKeys - count:GPBARRAYSIZE(kValues)]; + [[GPBUInt32UInt32Dictionary alloc] initWithUInt32s:kValues + forKeys:kKeys + count:GPBARRAYSIZE(kValues)]; XCTAssertNotNil(dict2); [dict addEntriesFromDictionary:dict2]; XCTAssertEqual(dict.count, 4U); uint32_t value; - XCTAssertTrue([dict valueForKey:1U value:NULL]); - XCTAssertTrue([dict valueForKey:1U value:&value]); + XCTAssertTrue([dict getUInt32:NULL forKey:1U]); + XCTAssertTrue([dict getUInt32:&value forKey:1U]); XCTAssertEqual(value, 100U); - XCTAssertTrue([dict valueForKey:2U value:NULL]); - XCTAssertTrue([dict valueForKey:2U value:&value]); + XCTAssertTrue([dict getUInt32:NULL forKey:2U]); + XCTAssertTrue([dict getUInt32:&value forKey:2U]); XCTAssertEqual(value, 101U); - XCTAssertTrue([dict valueForKey:3U value:NULL]); - XCTAssertTrue([dict valueForKey:3U value:&value]); + XCTAssertTrue([dict getUInt32:NULL forKey:3U]); + XCTAssertTrue([dict getUInt32:&value forKey:3U]); XCTAssertEqual(value, 102U); - XCTAssertTrue([dict valueForKey:4U value:NULL]); - XCTAssertTrue([dict valueForKey:4U value:&value]); + XCTAssertTrue([dict getUInt32:NULL forKey:4U]); + XCTAssertTrue([dict getUInt32:&value forKey:4U]); XCTAssertEqual(value, 103U); [dict2 release]; } @@ -305,57 +305,57 @@ static BOOL TestingEnum_IsValidValue(int32_t value) { const uint32_t kKeys[] = { 1U, 2U, 3U, 4U }; const uint32_t kValues[] = { 100U, 101U, 102U, 103U }; GPBUInt32UInt32Dictionary *dict = - [[GPBUInt32UInt32Dictionary alloc] initWithValues:kValues - forKeys:kKeys - count:GPBARRAYSIZE(kValues)]; + [[GPBUInt32UInt32Dictionary alloc] initWithUInt32s:kValues + forKeys:kKeys + count:GPBARRAYSIZE(kValues)]; XCTAssertNotNil(dict); XCTAssertEqual(dict.count, 4U); - [dict removeValueForKey:2U]; + [dict removeUInt32ForKey:2U]; XCTAssertEqual(dict.count, 3U); uint32_t value; - XCTAssertTrue([dict valueForKey:1U value:NULL]); - XCTAssertTrue([dict valueForKey:1U value:&value]); + XCTAssertTrue([dict getUInt32:NULL forKey:1U]); + XCTAssertTrue([dict getUInt32:&value forKey:1U]); XCTAssertEqual(value, 100U); - XCTAssertFalse([dict valueForKey:2U value:NULL]); - XCTAssertTrue([dict valueForKey:3U value:NULL]); - XCTAssertTrue([dict valueForKey:3U value:&value]); + XCTAssertFalse([dict getUInt32:NULL forKey:2U]); + XCTAssertTrue([dict getUInt32:NULL forKey:3U]); + XCTAssertTrue([dict getUInt32:&value forKey:3U]); XCTAssertEqual(value, 102U); - XCTAssertTrue([dict valueForKey:4U value:NULL]); - XCTAssertTrue([dict valueForKey:4U value:&value]); + XCTAssertTrue([dict getUInt32:NULL forKey:4U]); + XCTAssertTrue([dict getUInt32:&value forKey:4U]); XCTAssertEqual(value, 103U); // Remove again does nothing. - [dict removeValueForKey:2U]; + [dict removeUInt32ForKey:2U]; XCTAssertEqual(dict.count, 3U); - XCTAssertTrue([dict valueForKey:1U value:NULL]); - XCTAssertTrue([dict valueForKey:1U value:&value]); + XCTAssertTrue([dict getUInt32:NULL forKey:1U]); + XCTAssertTrue([dict getUInt32:&value forKey:1U]); XCTAssertEqual(value, 100U); - XCTAssertFalse([dict valueForKey:2U value:NULL]); - XCTAssertTrue([dict valueForKey:3U value:NULL]); - XCTAssertTrue([dict valueForKey:3U value:&value]); + XCTAssertFalse([dict getUInt32:NULL forKey:2U]); + XCTAssertTrue([dict getUInt32:NULL forKey:3U]); + XCTAssertTrue([dict getUInt32:&value forKey:3U]); XCTAssertEqual(value, 102U); - XCTAssertTrue([dict valueForKey:4U value:NULL]); - XCTAssertTrue([dict valueForKey:4U value:&value]); + XCTAssertTrue([dict getUInt32:NULL forKey:4U]); + XCTAssertTrue([dict getUInt32:&value forKey:4U]); XCTAssertEqual(value, 103U); - [dict removeValueForKey:4U]; + [dict removeUInt32ForKey:4U]; XCTAssertEqual(dict.count, 2U); - XCTAssertTrue([dict valueForKey:1U value:NULL]); - XCTAssertTrue([dict valueForKey:1U value:&value]); + XCTAssertTrue([dict getUInt32:NULL forKey:1U]); + XCTAssertTrue([dict getUInt32:&value forKey:1U]); XCTAssertEqual(value, 100U); - XCTAssertFalse([dict valueForKey:2U value:NULL]); - XCTAssertTrue([dict valueForKey:3U value:NULL]); - XCTAssertTrue([dict valueForKey:3U value:&value]); + XCTAssertFalse([dict getUInt32:NULL forKey:2U]); + XCTAssertTrue([dict getUInt32:NULL forKey:3U]); + XCTAssertTrue([dict getUInt32:&value forKey:3U]); XCTAssertEqual(value, 102U); - XCTAssertFalse([dict valueForKey:4U value:NULL]); + XCTAssertFalse([dict getUInt32:NULL forKey:4U]); [dict removeAll]; XCTAssertEqual(dict.count, 0U); - XCTAssertFalse([dict valueForKey:1U value:NULL]); - XCTAssertFalse([dict valueForKey:2U value:NULL]); - XCTAssertFalse([dict valueForKey:3U value:NULL]); - XCTAssertFalse([dict valueForKey:4U value:NULL]); + XCTAssertFalse([dict getUInt32:NULL forKey:1U]); + XCTAssertFalse([dict getUInt32:NULL forKey:2U]); + XCTAssertFalse([dict getUInt32:NULL forKey:3U]); + XCTAssertFalse([dict getUInt32:NULL forKey:4U]); [dict release]; } @@ -363,75 +363,75 @@ static BOOL TestingEnum_IsValidValue(int32_t value) { const uint32_t kKeys[] = { 1U, 2U, 3U, 4U }; const uint32_t kValues[] = { 100U, 101U, 102U, 103U }; GPBUInt32UInt32Dictionary *dict = - [[GPBUInt32UInt32Dictionary alloc] initWithValues:kValues - forKeys:kKeys - count:GPBARRAYSIZE(kValues)]; + [[GPBUInt32UInt32Dictionary alloc] initWithUInt32s:kValues + forKeys:kKeys + count:GPBARRAYSIZE(kValues)]; XCTAssertNotNil(dict); XCTAssertEqual(dict.count, 4U); uint32_t value; - XCTAssertTrue([dict valueForKey:1U value:NULL]); - XCTAssertTrue([dict valueForKey:1U value:&value]); + XCTAssertTrue([dict getUInt32:NULL forKey:1U]); + XCTAssertTrue([dict getUInt32:&value forKey:1U]); XCTAssertEqual(value, 100U); - XCTAssertTrue([dict valueForKey:2U value:NULL]); - XCTAssertTrue([dict valueForKey:2U value:&value]); + XCTAssertTrue([dict getUInt32:NULL forKey:2U]); + XCTAssertTrue([dict getUInt32:&value forKey:2U]); XCTAssertEqual(value, 101U); - XCTAssertTrue([dict valueForKey:3U value:NULL]); - XCTAssertTrue([dict valueForKey:3U value:&value]); + XCTAssertTrue([dict getUInt32:NULL forKey:3U]); + XCTAssertTrue([dict getUInt32:&value forKey:3U]); XCTAssertEqual(value, 102U); - XCTAssertTrue([dict valueForKey:4U value:NULL]); - XCTAssertTrue([dict valueForKey:4U value:&value]); + XCTAssertTrue([dict getUInt32:NULL forKey:4U]); + XCTAssertTrue([dict getUInt32:&value forKey:4U]); XCTAssertEqual(value, 103U); - [dict setValue:103U forKey:1U]; + [dict setUInt32:103U forKey:1U]; XCTAssertEqual(dict.count, 4U); - XCTAssertTrue([dict valueForKey:1U value:NULL]); - XCTAssertTrue([dict valueForKey:1U value:&value]); + XCTAssertTrue([dict getUInt32:NULL forKey:1U]); + XCTAssertTrue([dict getUInt32:&value forKey:1U]); XCTAssertEqual(value, 103U); - XCTAssertTrue([dict valueForKey:2U value:NULL]); - XCTAssertTrue([dict valueForKey:2U value:&value]); + XCTAssertTrue([dict getUInt32:NULL forKey:2U]); + XCTAssertTrue([dict getUInt32:&value forKey:2U]); XCTAssertEqual(value, 101U); - XCTAssertTrue([dict valueForKey:3U value:NULL]); - XCTAssertTrue([dict valueForKey:3U value:&value]); + XCTAssertTrue([dict getUInt32:NULL forKey:3U]); + XCTAssertTrue([dict getUInt32:&value forKey:3U]); XCTAssertEqual(value, 102U); - XCTAssertTrue([dict valueForKey:4U value:NULL]); - XCTAssertTrue([dict valueForKey:4U value:&value]); + XCTAssertTrue([dict getUInt32:NULL forKey:4U]); + XCTAssertTrue([dict getUInt32:&value forKey:4U]); XCTAssertEqual(value, 103U); - [dict setValue:101U forKey:4U]; + [dict setUInt32:101U forKey:4U]; XCTAssertEqual(dict.count, 4U); - XCTAssertTrue([dict valueForKey:1U value:NULL]); - XCTAssertTrue([dict valueForKey:1U value:&value]); + XCTAssertTrue([dict getUInt32:NULL forKey:1U]); + XCTAssertTrue([dict getUInt32:&value forKey:1U]); XCTAssertEqual(value, 103U); - XCTAssertTrue([dict valueForKey:2U value:NULL]); - XCTAssertTrue([dict valueForKey:2U value:&value]); + XCTAssertTrue([dict getUInt32:NULL forKey:2U]); + XCTAssertTrue([dict getUInt32:&value forKey:2U]); XCTAssertEqual(value, 101U); - XCTAssertTrue([dict valueForKey:3U value:NULL]); - XCTAssertTrue([dict valueForKey:3U value:&value]); + XCTAssertTrue([dict getUInt32:NULL forKey:3U]); + XCTAssertTrue([dict getUInt32:&value forKey:3U]); XCTAssertEqual(value, 102U); - XCTAssertTrue([dict valueForKey:4U value:NULL]); - XCTAssertTrue([dict valueForKey:4U value:&value]); + XCTAssertTrue([dict getUInt32:NULL forKey:4U]); + XCTAssertTrue([dict getUInt32:&value forKey:4U]); XCTAssertEqual(value, 101U); const uint32_t kKeys2[] = { 2U, 3U }; const uint32_t kValues2[] = { 102U, 100U }; GPBUInt32UInt32Dictionary *dict2 = - [[GPBUInt32UInt32Dictionary alloc] initWithValues:kValues2 - forKeys:kKeys2 - count:GPBARRAYSIZE(kValues2)]; + [[GPBUInt32UInt32Dictionary alloc] initWithUInt32s:kValues2 + forKeys:kKeys2 + count:GPBARRAYSIZE(kValues2)]; XCTAssertNotNil(dict2); [dict addEntriesFromDictionary:dict2]; XCTAssertEqual(dict.count, 4U); - XCTAssertTrue([dict valueForKey:1U value:NULL]); - XCTAssertTrue([dict valueForKey:1U value:&value]); + XCTAssertTrue([dict getUInt32:NULL forKey:1U]); + XCTAssertTrue([dict getUInt32:&value forKey:1U]); XCTAssertEqual(value, 103U); - XCTAssertTrue([dict valueForKey:2U value:NULL]); - XCTAssertTrue([dict valueForKey:2U value:&value]); + XCTAssertTrue([dict getUInt32:NULL forKey:2U]); + XCTAssertTrue([dict getUInt32:&value forKey:2U]); XCTAssertEqual(value, 102U); - XCTAssertTrue([dict valueForKey:3U value:NULL]); - XCTAssertTrue([dict valueForKey:3U value:&value]); + XCTAssertTrue([dict getUInt32:NULL forKey:3U]); + XCTAssertTrue([dict getUInt32:&value forKey:3U]); XCTAssertEqual(value, 100U); - XCTAssertTrue([dict valueForKey:4U value:NULL]); - XCTAssertTrue([dict valueForKey:4U value:&value]); + XCTAssertTrue([dict getUInt32:NULL forKey:4U]); + XCTAssertTrue([dict getUInt32:&value forKey:4U]); XCTAssertEqual(value, 101U); [dict2 release]; @@ -451,8 +451,8 @@ static BOOL TestingEnum_IsValidValue(int32_t value) { GPBUInt32Int32Dictionary *dict = [[GPBUInt32Int32Dictionary alloc] init]; XCTAssertNotNil(dict); XCTAssertEqual(dict.count, 0U); - XCTAssertFalse([dict valueForKey:1U value:NULL]); - [dict enumerateKeysAndValuesUsingBlock:^(uint32_t aKey, int32_t aValue, BOOL *stop) { + XCTAssertFalse([dict getInt32:NULL forKey:1U]); + [dict enumerateKeysAndInt32sUsingBlock:^(uint32_t aKey, int32_t aValue, BOOL *stop) { #pragma unused(aKey, aValue, stop) XCTFail(@"Shouldn't get here!"); }]; @@ -460,15 +460,15 @@ static BOOL TestingEnum_IsValidValue(int32_t value) { } - (void)testOne { - GPBUInt32Int32Dictionary *dict = [GPBUInt32Int32Dictionary dictionaryWithValue:200 forKey:1U]; + GPBUInt32Int32Dictionary *dict = [GPBUInt32Int32Dictionary dictionaryWithInt32:200 forKey:1U]; XCTAssertNotNil(dict); XCTAssertEqual(dict.count, 1U); int32_t value; - XCTAssertTrue([dict valueForKey:1U value:NULL]); - XCTAssertTrue([dict valueForKey:1U value:&value]); + XCTAssertTrue([dict getInt32:NULL forKey:1U]); + XCTAssertTrue([dict getInt32:&value forKey:1U]); XCTAssertEqual(value, 200); - XCTAssertFalse([dict valueForKey:2U value:NULL]); - [dict enumerateKeysAndValuesUsingBlock:^(uint32_t aKey, int32_t aValue, BOOL *stop) { + XCTAssertFalse([dict getInt32:NULL forKey:2U]); + [dict enumerateKeysAndInt32sUsingBlock:^(uint32_t aKey, int32_t aValue, BOOL *stop) { XCTAssertEqual(aKey, 1U); XCTAssertEqual(aValue, 200); XCTAssertNotEqual(stop, NULL); @@ -479,27 +479,27 @@ static BOOL TestingEnum_IsValidValue(int32_t value) { const uint32_t kKeys[] = { 1U, 2U, 3U }; const int32_t kValues[] = { 200, 201, 202 }; GPBUInt32Int32Dictionary *dict = - [[GPBUInt32Int32Dictionary alloc] initWithValues:kValues + [[GPBUInt32Int32Dictionary alloc] initWithInt32s:kValues forKeys:kKeys count:GPBARRAYSIZE(kValues)]; XCTAssertNotNil(dict); XCTAssertEqual(dict.count, 3U); int32_t value; - XCTAssertTrue([dict valueForKey:1U value:NULL]); - XCTAssertTrue([dict valueForKey:1U value:&value]); + XCTAssertTrue([dict getInt32:NULL forKey:1U]); + XCTAssertTrue([dict getInt32:&value forKey:1U]); XCTAssertEqual(value, 200); - XCTAssertTrue([dict valueForKey:2U value:NULL]); - XCTAssertTrue([dict valueForKey:2U value:&value]); + XCTAssertTrue([dict getInt32:NULL forKey:2U]); + XCTAssertTrue([dict getInt32:&value forKey:2U]); XCTAssertEqual(value, 201); - XCTAssertTrue([dict valueForKey:3U value:NULL]); - XCTAssertTrue([dict valueForKey:3U value:&value]); + XCTAssertTrue([dict getInt32:NULL forKey:3U]); + XCTAssertTrue([dict getInt32:&value forKey:3U]); XCTAssertEqual(value, 202); - XCTAssertFalse([dict valueForKey:4U value:NULL]); + XCTAssertFalse([dict getInt32:NULL forKey:4U]); __block NSUInteger idx = 0; uint32_t *seenKeys = malloc(3 * sizeof(uint32_t)); int32_t *seenValues = malloc(3 * sizeof(int32_t)); - [dict enumerateKeysAndValuesUsingBlock:^(uint32_t aKey, int32_t aValue, BOOL *stop) { + [dict enumerateKeysAndInt32sUsingBlock:^(uint32_t aKey, int32_t aValue, BOOL *stop) { XCTAssertLessThan(idx, 3U); seenKeys[idx] = aKey; seenValues[idx] = aValue; @@ -521,7 +521,7 @@ static BOOL TestingEnum_IsValidValue(int32_t value) { // Stopping the enumeration. idx = 0; - [dict enumerateKeysAndValuesUsingBlock:^(uint32_t aKey, int32_t aValue, BOOL *stop) { + [dict enumerateKeysAndInt32sUsingBlock:^(uint32_t aKey, int32_t aValue, BOOL *stop) { #pragma unused(aKey, aValue) if (idx == 1) *stop = YES; XCTAssertNotEqual(idx, 2U); @@ -537,27 +537,27 @@ static BOOL TestingEnum_IsValidValue(int32_t value) { const int32_t kValues2[] = { 200, 203, 202 }; const int32_t kValues3[] = { 200, 201, 202, 203 }; GPBUInt32Int32Dictionary *dict1 = - [[GPBUInt32Int32Dictionary alloc] initWithValues:kValues1 + [[GPBUInt32Int32Dictionary alloc] initWithInt32s:kValues1 forKeys:kKeys1 count:GPBARRAYSIZE(kValues1)]; XCTAssertNotNil(dict1); GPBUInt32Int32Dictionary *dict1prime = - [[GPBUInt32Int32Dictionary alloc] initWithValues:kValues1 + [[GPBUInt32Int32Dictionary alloc] initWithInt32s:kValues1 forKeys:kKeys1 count:GPBARRAYSIZE(kValues1)]; XCTAssertNotNil(dict1prime); GPBUInt32Int32Dictionary *dict2 = - [[GPBUInt32Int32Dictionary alloc] initWithValues:kValues2 + [[GPBUInt32Int32Dictionary alloc] initWithInt32s:kValues2 forKeys:kKeys1 count:GPBARRAYSIZE(kValues2)]; XCTAssertNotNil(dict2); GPBUInt32Int32Dictionary *dict3 = - [[GPBUInt32Int32Dictionary alloc] initWithValues:kValues1 + [[GPBUInt32Int32Dictionary alloc] initWithInt32s:kValues1 forKeys:kKeys2 count:GPBARRAYSIZE(kValues1)]; XCTAssertNotNil(dict3); GPBUInt32Int32Dictionary *dict4 = - [[GPBUInt32Int32Dictionary alloc] initWithValues:kValues3 + [[GPBUInt32Int32Dictionary alloc] initWithInt32s:kValues3 forKeys:kKeys1 count:GPBARRAYSIZE(kValues3)]; XCTAssertNotNil(dict4); @@ -588,7 +588,7 @@ static BOOL TestingEnum_IsValidValue(int32_t value) { const uint32_t kKeys[] = { 1U, 2U, 3U, 4U }; const int32_t kValues[] = { 200, 201, 202, 203 }; GPBUInt32Int32Dictionary *dict = - [[GPBUInt32Int32Dictionary alloc] initWithValues:kValues + [[GPBUInt32Int32Dictionary alloc] initWithInt32s:kValues forKeys:kKeys count:GPBARRAYSIZE(kValues)]; XCTAssertNotNil(dict); @@ -609,7 +609,7 @@ static BOOL TestingEnum_IsValidValue(int32_t value) { const uint32_t kKeys[] = { 1U, 2U, 3U, 4U }; const int32_t kValues[] = { 200, 201, 202, 203 }; GPBUInt32Int32Dictionary *dict = - [[GPBUInt32Int32Dictionary alloc] initWithValues:kValues + [[GPBUInt32Int32Dictionary alloc] initWithInt32s:kValues forKeys:kKeys count:GPBARRAYSIZE(kValues)]; XCTAssertNotNil(dict); @@ -629,13 +629,13 @@ static BOOL TestingEnum_IsValidValue(int32_t value) { XCTAssertNotNil(dict); XCTAssertEqual(dict.count, 0U); - [dict setValue:200 forKey:1U]; + [dict setInt32:200 forKey:1U]; XCTAssertEqual(dict.count, 1U); const uint32_t kKeys[] = { 2U, 3U, 4U }; const int32_t kValues[] = { 201, 202, 203 }; GPBUInt32Int32Dictionary *dict2 = - [[GPBUInt32Int32Dictionary alloc] initWithValues:kValues + [[GPBUInt32Int32Dictionary alloc] initWithInt32s:kValues forKeys:kKeys count:GPBARRAYSIZE(kValues)]; XCTAssertNotNil(dict2); @@ -643,17 +643,17 @@ static BOOL TestingEnum_IsValidValue(int32_t value) { XCTAssertEqual(dict.count, 4U); int32_t value; - XCTAssertTrue([dict valueForKey:1U value:NULL]); - XCTAssertTrue([dict valueForKey:1U value:&value]); + XCTAssertTrue([dict getInt32:NULL forKey:1U]); + XCTAssertTrue([dict getInt32:&value forKey:1U]); XCTAssertEqual(value, 200); - XCTAssertTrue([dict valueForKey:2U value:NULL]); - XCTAssertTrue([dict valueForKey:2U value:&value]); + XCTAssertTrue([dict getInt32:NULL forKey:2U]); + XCTAssertTrue([dict getInt32:&value forKey:2U]); XCTAssertEqual(value, 201); - XCTAssertTrue([dict valueForKey:3U value:NULL]); - XCTAssertTrue([dict valueForKey:3U value:&value]); + XCTAssertTrue([dict getInt32:NULL forKey:3U]); + XCTAssertTrue([dict getInt32:&value forKey:3U]); XCTAssertEqual(value, 202); - XCTAssertTrue([dict valueForKey:4U value:NULL]); - XCTAssertTrue([dict valueForKey:4U value:&value]); + XCTAssertTrue([dict getInt32:NULL forKey:4U]); + XCTAssertTrue([dict getInt32:&value forKey:4U]); XCTAssertEqual(value, 203); [dict2 release]; } @@ -662,57 +662,57 @@ static BOOL TestingEnum_IsValidValue(int32_t value) { const uint32_t kKeys[] = { 1U, 2U, 3U, 4U }; const int32_t kValues[] = { 200, 201, 202, 203 }; GPBUInt32Int32Dictionary *dict = - [[GPBUInt32Int32Dictionary alloc] initWithValues:kValues - forKeys:kKeys - count:GPBARRAYSIZE(kValues)]; + [[GPBUInt32Int32Dictionary alloc] initWithInt32s:kValues + forKeys:kKeys + count:GPBARRAYSIZE(kValues)]; XCTAssertNotNil(dict); XCTAssertEqual(dict.count, 4U); - [dict removeValueForKey:2U]; + [dict removeInt32ForKey:2U]; XCTAssertEqual(dict.count, 3U); int32_t value; - XCTAssertTrue([dict valueForKey:1U value:NULL]); - XCTAssertTrue([dict valueForKey:1U value:&value]); + XCTAssertTrue([dict getInt32:NULL forKey:1U]); + XCTAssertTrue([dict getInt32:&value forKey:1U]); XCTAssertEqual(value, 200); - XCTAssertFalse([dict valueForKey:2U value:NULL]); - XCTAssertTrue([dict valueForKey:3U value:NULL]); - XCTAssertTrue([dict valueForKey:3U value:&value]); + XCTAssertFalse([dict getInt32:NULL forKey:2U]); + XCTAssertTrue([dict getInt32:NULL forKey:3U]); + XCTAssertTrue([dict getInt32:&value forKey:3U]); XCTAssertEqual(value, 202); - XCTAssertTrue([dict valueForKey:4U value:NULL]); - XCTAssertTrue([dict valueForKey:4U value:&value]); + XCTAssertTrue([dict getInt32:NULL forKey:4U]); + XCTAssertTrue([dict getInt32:&value forKey:4U]); XCTAssertEqual(value, 203); // Remove again does nothing. - [dict removeValueForKey:2U]; + [dict removeInt32ForKey:2U]; XCTAssertEqual(dict.count, 3U); - XCTAssertTrue([dict valueForKey:1U value:NULL]); - XCTAssertTrue([dict valueForKey:1U value:&value]); + XCTAssertTrue([dict getInt32:NULL forKey:1U]); + XCTAssertTrue([dict getInt32:&value forKey:1U]); XCTAssertEqual(value, 200); - XCTAssertFalse([dict valueForKey:2U value:NULL]); - XCTAssertTrue([dict valueForKey:3U value:NULL]); - XCTAssertTrue([dict valueForKey:3U value:&value]); + XCTAssertFalse([dict getInt32:NULL forKey:2U]); + XCTAssertTrue([dict getInt32:NULL forKey:3U]); + XCTAssertTrue([dict getInt32:&value forKey:3U]); XCTAssertEqual(value, 202); - XCTAssertTrue([dict valueForKey:4U value:NULL]); - XCTAssertTrue([dict valueForKey:4U value:&value]); + XCTAssertTrue([dict getInt32:NULL forKey:4U]); + XCTAssertTrue([dict getInt32:&value forKey:4U]); XCTAssertEqual(value, 203); - [dict removeValueForKey:4U]; + [dict removeInt32ForKey:4U]; XCTAssertEqual(dict.count, 2U); - XCTAssertTrue([dict valueForKey:1U value:NULL]); - XCTAssertTrue([dict valueForKey:1U value:&value]); + XCTAssertTrue([dict getInt32:NULL forKey:1U]); + XCTAssertTrue([dict getInt32:&value forKey:1U]); XCTAssertEqual(value, 200); - XCTAssertFalse([dict valueForKey:2U value:NULL]); - XCTAssertTrue([dict valueForKey:3U value:NULL]); - XCTAssertTrue([dict valueForKey:3U value:&value]); + XCTAssertFalse([dict getInt32:NULL forKey:2U]); + XCTAssertTrue([dict getInt32:NULL forKey:3U]); + XCTAssertTrue([dict getInt32:&value forKey:3U]); XCTAssertEqual(value, 202); - XCTAssertFalse([dict valueForKey:4U value:NULL]); + XCTAssertFalse([dict getInt32:NULL forKey:4U]); [dict removeAll]; XCTAssertEqual(dict.count, 0U); - XCTAssertFalse([dict valueForKey:1U value:NULL]); - XCTAssertFalse([dict valueForKey:2U value:NULL]); - XCTAssertFalse([dict valueForKey:3U value:NULL]); - XCTAssertFalse([dict valueForKey:4U value:NULL]); + XCTAssertFalse([dict getInt32:NULL forKey:1U]); + XCTAssertFalse([dict getInt32:NULL forKey:2U]); + XCTAssertFalse([dict getInt32:NULL forKey:3U]); + XCTAssertFalse([dict getInt32:NULL forKey:4U]); [dict release]; } @@ -720,75 +720,75 @@ static BOOL TestingEnum_IsValidValue(int32_t value) { const uint32_t kKeys[] = { 1U, 2U, 3U, 4U }; const int32_t kValues[] = { 200, 201, 202, 203 }; GPBUInt32Int32Dictionary *dict = - [[GPBUInt32Int32Dictionary alloc] initWithValues:kValues - forKeys:kKeys - count:GPBARRAYSIZE(kValues)]; + [[GPBUInt32Int32Dictionary alloc] initWithInt32s:kValues + forKeys:kKeys + count:GPBARRAYSIZE(kValues)]; XCTAssertNotNil(dict); XCTAssertEqual(dict.count, 4U); int32_t value; - XCTAssertTrue([dict valueForKey:1U value:NULL]); - XCTAssertTrue([dict valueForKey:1U value:&value]); + XCTAssertTrue([dict getInt32:NULL forKey:1U]); + XCTAssertTrue([dict getInt32:&value forKey:1U]); XCTAssertEqual(value, 200); - XCTAssertTrue([dict valueForKey:2U value:NULL]); - XCTAssertTrue([dict valueForKey:2U value:&value]); + XCTAssertTrue([dict getInt32:NULL forKey:2U]); + XCTAssertTrue([dict getInt32:&value forKey:2U]); XCTAssertEqual(value, 201); - XCTAssertTrue([dict valueForKey:3U value:NULL]); - XCTAssertTrue([dict valueForKey:3U value:&value]); + XCTAssertTrue([dict getInt32:NULL forKey:3U]); + XCTAssertTrue([dict getInt32:&value forKey:3U]); XCTAssertEqual(value, 202); - XCTAssertTrue([dict valueForKey:4U value:NULL]); - XCTAssertTrue([dict valueForKey:4U value:&value]); + XCTAssertTrue([dict getInt32:NULL forKey:4U]); + XCTAssertTrue([dict getInt32:&value forKey:4U]); XCTAssertEqual(value, 203); - [dict setValue:203 forKey:1U]; + [dict setInt32:203 forKey:1U]; XCTAssertEqual(dict.count, 4U); - XCTAssertTrue([dict valueForKey:1U value:NULL]); - XCTAssertTrue([dict valueForKey:1U value:&value]); + XCTAssertTrue([dict getInt32:NULL forKey:1U]); + XCTAssertTrue([dict getInt32:&value forKey:1U]); XCTAssertEqual(value, 203); - XCTAssertTrue([dict valueForKey:2U value:NULL]); - XCTAssertTrue([dict valueForKey:2U value:&value]); + XCTAssertTrue([dict getInt32:NULL forKey:2U]); + XCTAssertTrue([dict getInt32:&value forKey:2U]); XCTAssertEqual(value, 201); - XCTAssertTrue([dict valueForKey:3U value:NULL]); - XCTAssertTrue([dict valueForKey:3U value:&value]); + XCTAssertTrue([dict getInt32:NULL forKey:3U]); + XCTAssertTrue([dict getInt32:&value forKey:3U]); XCTAssertEqual(value, 202); - XCTAssertTrue([dict valueForKey:4U value:NULL]); - XCTAssertTrue([dict valueForKey:4U value:&value]); + XCTAssertTrue([dict getInt32:NULL forKey:4U]); + XCTAssertTrue([dict getInt32:&value forKey:4U]); XCTAssertEqual(value, 203); - [dict setValue:201 forKey:4U]; + [dict setInt32:201 forKey:4U]; XCTAssertEqual(dict.count, 4U); - XCTAssertTrue([dict valueForKey:1U value:NULL]); - XCTAssertTrue([dict valueForKey:1U value:&value]); + XCTAssertTrue([dict getInt32:NULL forKey:1U]); + XCTAssertTrue([dict getInt32:&value forKey:1U]); XCTAssertEqual(value, 203); - XCTAssertTrue([dict valueForKey:2U value:NULL]); - XCTAssertTrue([dict valueForKey:2U value:&value]); + XCTAssertTrue([dict getInt32:NULL forKey:2U]); + XCTAssertTrue([dict getInt32:&value forKey:2U]); XCTAssertEqual(value, 201); - XCTAssertTrue([dict valueForKey:3U value:NULL]); - XCTAssertTrue([dict valueForKey:3U value:&value]); + XCTAssertTrue([dict getInt32:NULL forKey:3U]); + XCTAssertTrue([dict getInt32:&value forKey:3U]); XCTAssertEqual(value, 202); - XCTAssertTrue([dict valueForKey:4U value:NULL]); - XCTAssertTrue([dict valueForKey:4U value:&value]); + XCTAssertTrue([dict getInt32:NULL forKey:4U]); + XCTAssertTrue([dict getInt32:&value forKey:4U]); XCTAssertEqual(value, 201); const uint32_t kKeys2[] = { 2U, 3U }; const int32_t kValues2[] = { 202, 200 }; GPBUInt32Int32Dictionary *dict2 = - [[GPBUInt32Int32Dictionary alloc] initWithValues:kValues2 + [[GPBUInt32Int32Dictionary alloc] initWithInt32s:kValues2 forKeys:kKeys2 count:GPBARRAYSIZE(kValues2)]; XCTAssertNotNil(dict2); [dict addEntriesFromDictionary:dict2]; XCTAssertEqual(dict.count, 4U); - XCTAssertTrue([dict valueForKey:1U value:NULL]); - XCTAssertTrue([dict valueForKey:1U value:&value]); + XCTAssertTrue([dict getInt32:NULL forKey:1U]); + XCTAssertTrue([dict getInt32:&value forKey:1U]); XCTAssertEqual(value, 203); - XCTAssertTrue([dict valueForKey:2U value:NULL]); - XCTAssertTrue([dict valueForKey:2U value:&value]); + XCTAssertTrue([dict getInt32:NULL forKey:2U]); + XCTAssertTrue([dict getInt32:&value forKey:2U]); XCTAssertEqual(value, 202); - XCTAssertTrue([dict valueForKey:3U value:NULL]); - XCTAssertTrue([dict valueForKey:3U value:&value]); + XCTAssertTrue([dict getInt32:NULL forKey:3U]); + XCTAssertTrue([dict getInt32:&value forKey:3U]); XCTAssertEqual(value, 200); - XCTAssertTrue([dict valueForKey:4U value:NULL]); - XCTAssertTrue([dict valueForKey:4U value:&value]); + XCTAssertTrue([dict getInt32:NULL forKey:4U]); + XCTAssertTrue([dict getInt32:&value forKey:4U]); XCTAssertEqual(value, 201); [dict2 release]; @@ -808,8 +808,8 @@ static BOOL TestingEnum_IsValidValue(int32_t value) { GPBUInt32UInt64Dictionary *dict = [[GPBUInt32UInt64Dictionary alloc] init]; XCTAssertNotNil(dict); XCTAssertEqual(dict.count, 0U); - XCTAssertFalse([dict valueForKey:1U value:NULL]); - [dict enumerateKeysAndValuesUsingBlock:^(uint32_t aKey, uint64_t aValue, BOOL *stop) { + XCTAssertFalse([dict getUInt64:NULL forKey:1U]); + [dict enumerateKeysAndUInt64sUsingBlock:^(uint32_t aKey, uint64_t aValue, BOOL *stop) { #pragma unused(aKey, aValue, stop) XCTFail(@"Shouldn't get here!"); }]; @@ -817,15 +817,15 @@ static BOOL TestingEnum_IsValidValue(int32_t value) { } - (void)testOne { - GPBUInt32UInt64Dictionary *dict = [GPBUInt32UInt64Dictionary dictionaryWithValue:300U forKey:1U]; + GPBUInt32UInt64Dictionary *dict = [GPBUInt32UInt64Dictionary dictionaryWithUInt64:300U forKey:1U]; XCTAssertNotNil(dict); XCTAssertEqual(dict.count, 1U); uint64_t value; - XCTAssertTrue([dict valueForKey:1U value:NULL]); - XCTAssertTrue([dict valueForKey:1U value:&value]); + XCTAssertTrue([dict getUInt64:NULL forKey:1U]); + XCTAssertTrue([dict getUInt64:&value forKey:1U]); XCTAssertEqual(value, 300U); - XCTAssertFalse([dict valueForKey:2U value:NULL]); - [dict enumerateKeysAndValuesUsingBlock:^(uint32_t aKey, uint64_t aValue, BOOL *stop) { + XCTAssertFalse([dict getUInt64:NULL forKey:2U]); + [dict enumerateKeysAndUInt64sUsingBlock:^(uint32_t aKey, uint64_t aValue, BOOL *stop) { XCTAssertEqual(aKey, 1U); XCTAssertEqual(aValue, 300U); XCTAssertNotEqual(stop, NULL); @@ -836,27 +836,27 @@ static BOOL TestingEnum_IsValidValue(int32_t value) { const uint32_t kKeys[] = { 1U, 2U, 3U }; const uint64_t kValues[] = { 300U, 301U, 302U }; GPBUInt32UInt64Dictionary *dict = - [[GPBUInt32UInt64Dictionary alloc] initWithValues:kValues - forKeys:kKeys - count:GPBARRAYSIZE(kValues)]; + [[GPBUInt32UInt64Dictionary alloc] initWithUInt64s:kValues + forKeys:kKeys + count:GPBARRAYSIZE(kValues)]; XCTAssertNotNil(dict); XCTAssertEqual(dict.count, 3U); uint64_t value; - XCTAssertTrue([dict valueForKey:1U value:NULL]); - XCTAssertTrue([dict valueForKey:1U value:&value]); + XCTAssertTrue([dict getUInt64:NULL forKey:1U]); + XCTAssertTrue([dict getUInt64:&value forKey:1U]); XCTAssertEqual(value, 300U); - XCTAssertTrue([dict valueForKey:2U value:NULL]); - XCTAssertTrue([dict valueForKey:2U value:&value]); + XCTAssertTrue([dict getUInt64:NULL forKey:2U]); + XCTAssertTrue([dict getUInt64:&value forKey:2U]); XCTAssertEqual(value, 301U); - XCTAssertTrue([dict valueForKey:3U value:NULL]); - XCTAssertTrue([dict valueForKey:3U value:&value]); + XCTAssertTrue([dict getUInt64:NULL forKey:3U]); + XCTAssertTrue([dict getUInt64:&value forKey:3U]); XCTAssertEqual(value, 302U); - XCTAssertFalse([dict valueForKey:4U value:NULL]); + XCTAssertFalse([dict getUInt64:NULL forKey:4U]); __block NSUInteger idx = 0; uint32_t *seenKeys = malloc(3 * sizeof(uint32_t)); uint64_t *seenValues = malloc(3 * sizeof(uint64_t)); - [dict enumerateKeysAndValuesUsingBlock:^(uint32_t aKey, uint64_t aValue, BOOL *stop) { + [dict enumerateKeysAndUInt64sUsingBlock:^(uint32_t aKey, uint64_t aValue, BOOL *stop) { XCTAssertLessThan(idx, 3U); seenKeys[idx] = aKey; seenValues[idx] = aValue; @@ -878,7 +878,7 @@ static BOOL TestingEnum_IsValidValue(int32_t value) { // Stopping the enumeration. idx = 0; - [dict enumerateKeysAndValuesUsingBlock:^(uint32_t aKey, uint64_t aValue, BOOL *stop) { + [dict enumerateKeysAndUInt64sUsingBlock:^(uint32_t aKey, uint64_t aValue, BOOL *stop) { #pragma unused(aKey, aValue) if (idx == 1) *stop = YES; XCTAssertNotEqual(idx, 2U); @@ -894,29 +894,29 @@ static BOOL TestingEnum_IsValidValue(int32_t value) { const uint64_t kValues2[] = { 300U, 303U, 302U }; const uint64_t kValues3[] = { 300U, 301U, 302U, 303U }; GPBUInt32UInt64Dictionary *dict1 = - [[GPBUInt32UInt64Dictionary alloc] initWithValues:kValues1 - forKeys:kKeys1 - count:GPBARRAYSIZE(kValues1)]; + [[GPBUInt32UInt64Dictionary alloc] initWithUInt64s:kValues1 + forKeys:kKeys1 + count:GPBARRAYSIZE(kValues1)]; XCTAssertNotNil(dict1); GPBUInt32UInt64Dictionary *dict1prime = - [[GPBUInt32UInt64Dictionary alloc] initWithValues:kValues1 - forKeys:kKeys1 - count:GPBARRAYSIZE(kValues1)]; + [[GPBUInt32UInt64Dictionary alloc] initWithUInt64s:kValues1 + forKeys:kKeys1 + count:GPBARRAYSIZE(kValues1)]; XCTAssertNotNil(dict1prime); GPBUInt32UInt64Dictionary *dict2 = - [[GPBUInt32UInt64Dictionary alloc] initWithValues:kValues2 - forKeys:kKeys1 - count:GPBARRAYSIZE(kValues2)]; + [[GPBUInt32UInt64Dictionary alloc] initWithUInt64s:kValues2 + forKeys:kKeys1 + count:GPBARRAYSIZE(kValues2)]; XCTAssertNotNil(dict2); GPBUInt32UInt64Dictionary *dict3 = - [[GPBUInt32UInt64Dictionary alloc] initWithValues:kValues1 - forKeys:kKeys2 - count:GPBARRAYSIZE(kValues1)]; + [[GPBUInt32UInt64Dictionary alloc] initWithUInt64s:kValues1 + forKeys:kKeys2 + count:GPBARRAYSIZE(kValues1)]; XCTAssertNotNil(dict3); GPBUInt32UInt64Dictionary *dict4 = - [[GPBUInt32UInt64Dictionary alloc] initWithValues:kValues3 - forKeys:kKeys1 - count:GPBARRAYSIZE(kValues3)]; + [[GPBUInt32UInt64Dictionary alloc] initWithUInt64s:kValues3 + forKeys:kKeys1 + count:GPBARRAYSIZE(kValues3)]; XCTAssertNotNil(dict4); // 1/1Prime should be different objects, but equal. @@ -945,9 +945,9 @@ static BOOL TestingEnum_IsValidValue(int32_t value) { const uint32_t kKeys[] = { 1U, 2U, 3U, 4U }; const uint64_t kValues[] = { 300U, 301U, 302U, 303U }; GPBUInt32UInt64Dictionary *dict = - [[GPBUInt32UInt64Dictionary alloc] initWithValues:kValues - forKeys:kKeys - count:GPBARRAYSIZE(kValues)]; + [[GPBUInt32UInt64Dictionary alloc] initWithUInt64s:kValues + forKeys:kKeys + count:GPBARRAYSIZE(kValues)]; XCTAssertNotNil(dict); GPBUInt32UInt64Dictionary *dict2 = [dict copy]; @@ -966,9 +966,9 @@ static BOOL TestingEnum_IsValidValue(int32_t value) { const uint32_t kKeys[] = { 1U, 2U, 3U, 4U }; const uint64_t kValues[] = { 300U, 301U, 302U, 303U }; GPBUInt32UInt64Dictionary *dict = - [[GPBUInt32UInt64Dictionary alloc] initWithValues:kValues - forKeys:kKeys - count:GPBARRAYSIZE(kValues)]; + [[GPBUInt32UInt64Dictionary alloc] initWithUInt64s:kValues + forKeys:kKeys + count:GPBARRAYSIZE(kValues)]; XCTAssertNotNil(dict); GPBUInt32UInt64Dictionary *dict2 = @@ -986,31 +986,31 @@ static BOOL TestingEnum_IsValidValue(int32_t value) { XCTAssertNotNil(dict); XCTAssertEqual(dict.count, 0U); - [dict setValue:300U forKey:1U]; + [dict setUInt64:300U forKey:1U]; XCTAssertEqual(dict.count, 1U); const uint32_t kKeys[] = { 2U, 3U, 4U }; const uint64_t kValues[] = { 301U, 302U, 303U }; GPBUInt32UInt64Dictionary *dict2 = - [[GPBUInt32UInt64Dictionary alloc] initWithValues:kValues - forKeys:kKeys - count:GPBARRAYSIZE(kValues)]; + [[GPBUInt32UInt64Dictionary alloc] initWithUInt64s:kValues + forKeys:kKeys + count:GPBARRAYSIZE(kValues)]; XCTAssertNotNil(dict2); [dict addEntriesFromDictionary:dict2]; XCTAssertEqual(dict.count, 4U); uint64_t value; - XCTAssertTrue([dict valueForKey:1U value:NULL]); - XCTAssertTrue([dict valueForKey:1U value:&value]); + XCTAssertTrue([dict getUInt64:NULL forKey:1U]); + XCTAssertTrue([dict getUInt64:&value forKey:1U]); XCTAssertEqual(value, 300U); - XCTAssertTrue([dict valueForKey:2U value:NULL]); - XCTAssertTrue([dict valueForKey:2U value:&value]); + XCTAssertTrue([dict getUInt64:NULL forKey:2U]); + XCTAssertTrue([dict getUInt64:&value forKey:2U]); XCTAssertEqual(value, 301U); - XCTAssertTrue([dict valueForKey:3U value:NULL]); - XCTAssertTrue([dict valueForKey:3U value:&value]); + XCTAssertTrue([dict getUInt64:NULL forKey:3U]); + XCTAssertTrue([dict getUInt64:&value forKey:3U]); XCTAssertEqual(value, 302U); - XCTAssertTrue([dict valueForKey:4U value:NULL]); - XCTAssertTrue([dict valueForKey:4U value:&value]); + XCTAssertTrue([dict getUInt64:NULL forKey:4U]); + XCTAssertTrue([dict getUInt64:&value forKey:4U]); XCTAssertEqual(value, 303U); [dict2 release]; } @@ -1019,57 +1019,57 @@ static BOOL TestingEnum_IsValidValue(int32_t value) { const uint32_t kKeys[] = { 1U, 2U, 3U, 4U }; const uint64_t kValues[] = { 300U, 301U, 302U, 303U }; GPBUInt32UInt64Dictionary *dict = - [[GPBUInt32UInt64Dictionary alloc] initWithValues:kValues - forKeys:kKeys - count:GPBARRAYSIZE(kValues)]; + [[GPBUInt32UInt64Dictionary alloc] initWithUInt64s:kValues + forKeys:kKeys + count:GPBARRAYSIZE(kValues)]; XCTAssertNotNil(dict); XCTAssertEqual(dict.count, 4U); - [dict removeValueForKey:2U]; + [dict removeUInt64ForKey:2U]; XCTAssertEqual(dict.count, 3U); uint64_t value; - XCTAssertTrue([dict valueForKey:1U value:NULL]); - XCTAssertTrue([dict valueForKey:1U value:&value]); + XCTAssertTrue([dict getUInt64:NULL forKey:1U]); + XCTAssertTrue([dict getUInt64:&value forKey:1U]); XCTAssertEqual(value, 300U); - XCTAssertFalse([dict valueForKey:2U value:NULL]); - XCTAssertTrue([dict valueForKey:3U value:NULL]); - XCTAssertTrue([dict valueForKey:3U value:&value]); + XCTAssertFalse([dict getUInt64:NULL forKey:2U]); + XCTAssertTrue([dict getUInt64:NULL forKey:3U]); + XCTAssertTrue([dict getUInt64:&value forKey:3U]); XCTAssertEqual(value, 302U); - XCTAssertTrue([dict valueForKey:4U value:NULL]); - XCTAssertTrue([dict valueForKey:4U value:&value]); + XCTAssertTrue([dict getUInt64:NULL forKey:4U]); + XCTAssertTrue([dict getUInt64:&value forKey:4U]); XCTAssertEqual(value, 303U); // Remove again does nothing. - [dict removeValueForKey:2U]; + [dict removeUInt64ForKey:2U]; XCTAssertEqual(dict.count, 3U); - XCTAssertTrue([dict valueForKey:1U value:NULL]); - XCTAssertTrue([dict valueForKey:1U value:&value]); + XCTAssertTrue([dict getUInt64:NULL forKey:1U]); + XCTAssertTrue([dict getUInt64:&value forKey:1U]); XCTAssertEqual(value, 300U); - XCTAssertFalse([dict valueForKey:2U value:NULL]); - XCTAssertTrue([dict valueForKey:3U value:NULL]); - XCTAssertTrue([dict valueForKey:3U value:&value]); + XCTAssertFalse([dict getUInt64:NULL forKey:2U]); + XCTAssertTrue([dict getUInt64:NULL forKey:3U]); + XCTAssertTrue([dict getUInt64:&value forKey:3U]); XCTAssertEqual(value, 302U); - XCTAssertTrue([dict valueForKey:4U value:NULL]); - XCTAssertTrue([dict valueForKey:4U value:&value]); + XCTAssertTrue([dict getUInt64:NULL forKey:4U]); + XCTAssertTrue([dict getUInt64:&value forKey:4U]); XCTAssertEqual(value, 303U); - [dict removeValueForKey:4U]; + [dict removeUInt64ForKey:4U]; XCTAssertEqual(dict.count, 2U); - XCTAssertTrue([dict valueForKey:1U value:NULL]); - XCTAssertTrue([dict valueForKey:1U value:&value]); + XCTAssertTrue([dict getUInt64:NULL forKey:1U]); + XCTAssertTrue([dict getUInt64:&value forKey:1U]); XCTAssertEqual(value, 300U); - XCTAssertFalse([dict valueForKey:2U value:NULL]); - XCTAssertTrue([dict valueForKey:3U value:NULL]); - XCTAssertTrue([dict valueForKey:3U value:&value]); + XCTAssertFalse([dict getUInt64:NULL forKey:2U]); + XCTAssertTrue([dict getUInt64:NULL forKey:3U]); + XCTAssertTrue([dict getUInt64:&value forKey:3U]); XCTAssertEqual(value, 302U); - XCTAssertFalse([dict valueForKey:4U value:NULL]); + XCTAssertFalse([dict getUInt64:NULL forKey:4U]); [dict removeAll]; XCTAssertEqual(dict.count, 0U); - XCTAssertFalse([dict valueForKey:1U value:NULL]); - XCTAssertFalse([dict valueForKey:2U value:NULL]); - XCTAssertFalse([dict valueForKey:3U value:NULL]); - XCTAssertFalse([dict valueForKey:4U value:NULL]); + XCTAssertFalse([dict getUInt64:NULL forKey:1U]); + XCTAssertFalse([dict getUInt64:NULL forKey:2U]); + XCTAssertFalse([dict getUInt64:NULL forKey:3U]); + XCTAssertFalse([dict getUInt64:NULL forKey:4U]); [dict release]; } @@ -1077,75 +1077,75 @@ static BOOL TestingEnum_IsValidValue(int32_t value) { const uint32_t kKeys[] = { 1U, 2U, 3U, 4U }; const uint64_t kValues[] = { 300U, 301U, 302U, 303U }; GPBUInt32UInt64Dictionary *dict = - [[GPBUInt32UInt64Dictionary alloc] initWithValues:kValues - forKeys:kKeys - count:GPBARRAYSIZE(kValues)]; + [[GPBUInt32UInt64Dictionary alloc] initWithUInt64s:kValues + forKeys:kKeys + count:GPBARRAYSIZE(kValues)]; XCTAssertNotNil(dict); XCTAssertEqual(dict.count, 4U); uint64_t value; - XCTAssertTrue([dict valueForKey:1U value:NULL]); - XCTAssertTrue([dict valueForKey:1U value:&value]); + XCTAssertTrue([dict getUInt64:NULL forKey:1U]); + XCTAssertTrue([dict getUInt64:&value forKey:1U]); XCTAssertEqual(value, 300U); - XCTAssertTrue([dict valueForKey:2U value:NULL]); - XCTAssertTrue([dict valueForKey:2U value:&value]); + XCTAssertTrue([dict getUInt64:NULL forKey:2U]); + XCTAssertTrue([dict getUInt64:&value forKey:2U]); XCTAssertEqual(value, 301U); - XCTAssertTrue([dict valueForKey:3U value:NULL]); - XCTAssertTrue([dict valueForKey:3U value:&value]); + XCTAssertTrue([dict getUInt64:NULL forKey:3U]); + XCTAssertTrue([dict getUInt64:&value forKey:3U]); XCTAssertEqual(value, 302U); - XCTAssertTrue([dict valueForKey:4U value:NULL]); - XCTAssertTrue([dict valueForKey:4U value:&value]); + XCTAssertTrue([dict getUInt64:NULL forKey:4U]); + XCTAssertTrue([dict getUInt64:&value forKey:4U]); XCTAssertEqual(value, 303U); - [dict setValue:303U forKey:1U]; + [dict setUInt64:303U forKey:1U]; XCTAssertEqual(dict.count, 4U); - XCTAssertTrue([dict valueForKey:1U value:NULL]); - XCTAssertTrue([dict valueForKey:1U value:&value]); + XCTAssertTrue([dict getUInt64:NULL forKey:1U]); + XCTAssertTrue([dict getUInt64:&value forKey:1U]); XCTAssertEqual(value, 303U); - XCTAssertTrue([dict valueForKey:2U value:NULL]); - XCTAssertTrue([dict valueForKey:2U value:&value]); + XCTAssertTrue([dict getUInt64:NULL forKey:2U]); + XCTAssertTrue([dict getUInt64:&value forKey:2U]); XCTAssertEqual(value, 301U); - XCTAssertTrue([dict valueForKey:3U value:NULL]); - XCTAssertTrue([dict valueForKey:3U value:&value]); + XCTAssertTrue([dict getUInt64:NULL forKey:3U]); + XCTAssertTrue([dict getUInt64:&value forKey:3U]); XCTAssertEqual(value, 302U); - XCTAssertTrue([dict valueForKey:4U value:NULL]); - XCTAssertTrue([dict valueForKey:4U value:&value]); + XCTAssertTrue([dict getUInt64:NULL forKey:4U]); + XCTAssertTrue([dict getUInt64:&value forKey:4U]); XCTAssertEqual(value, 303U); - [dict setValue:301U forKey:4U]; + [dict setUInt64:301U forKey:4U]; XCTAssertEqual(dict.count, 4U); - XCTAssertTrue([dict valueForKey:1U value:NULL]); - XCTAssertTrue([dict valueForKey:1U value:&value]); + XCTAssertTrue([dict getUInt64:NULL forKey:1U]); + XCTAssertTrue([dict getUInt64:&value forKey:1U]); XCTAssertEqual(value, 303U); - XCTAssertTrue([dict valueForKey:2U value:NULL]); - XCTAssertTrue([dict valueForKey:2U value:&value]); + XCTAssertTrue([dict getUInt64:NULL forKey:2U]); + XCTAssertTrue([dict getUInt64:&value forKey:2U]); XCTAssertEqual(value, 301U); - XCTAssertTrue([dict valueForKey:3U value:NULL]); - XCTAssertTrue([dict valueForKey:3U value:&value]); + XCTAssertTrue([dict getUInt64:NULL forKey:3U]); + XCTAssertTrue([dict getUInt64:&value forKey:3U]); XCTAssertEqual(value, 302U); - XCTAssertTrue([dict valueForKey:4U value:NULL]); - XCTAssertTrue([dict valueForKey:4U value:&value]); + XCTAssertTrue([dict getUInt64:NULL forKey:4U]); + XCTAssertTrue([dict getUInt64:&value forKey:4U]); XCTAssertEqual(value, 301U); const uint32_t kKeys2[] = { 2U, 3U }; const uint64_t kValues2[] = { 302U, 300U }; GPBUInt32UInt64Dictionary *dict2 = - [[GPBUInt32UInt64Dictionary alloc] initWithValues:kValues2 - forKeys:kKeys2 - count:GPBARRAYSIZE(kValues2)]; + [[GPBUInt32UInt64Dictionary alloc] initWithUInt64s:kValues2 + forKeys:kKeys2 + count:GPBARRAYSIZE(kValues2)]; XCTAssertNotNil(dict2); [dict addEntriesFromDictionary:dict2]; XCTAssertEqual(dict.count, 4U); - XCTAssertTrue([dict valueForKey:1U value:NULL]); - XCTAssertTrue([dict valueForKey:1U value:&value]); + XCTAssertTrue([dict getUInt64:NULL forKey:1U]); + XCTAssertTrue([dict getUInt64:&value forKey:1U]); XCTAssertEqual(value, 303U); - XCTAssertTrue([dict valueForKey:2U value:NULL]); - XCTAssertTrue([dict valueForKey:2U value:&value]); + XCTAssertTrue([dict getUInt64:NULL forKey:2U]); + XCTAssertTrue([dict getUInt64:&value forKey:2U]); XCTAssertEqual(value, 302U); - XCTAssertTrue([dict valueForKey:3U value:NULL]); - XCTAssertTrue([dict valueForKey:3U value:&value]); + XCTAssertTrue([dict getUInt64:NULL forKey:3U]); + XCTAssertTrue([dict getUInt64:&value forKey:3U]); XCTAssertEqual(value, 300U); - XCTAssertTrue([dict valueForKey:4U value:NULL]); - XCTAssertTrue([dict valueForKey:4U value:&value]); + XCTAssertTrue([dict getUInt64:NULL forKey:4U]); + XCTAssertTrue([dict getUInt64:&value forKey:4U]); XCTAssertEqual(value, 301U); [dict2 release]; @@ -1165,8 +1165,8 @@ static BOOL TestingEnum_IsValidValue(int32_t value) { GPBUInt32Int64Dictionary *dict = [[GPBUInt32Int64Dictionary alloc] init]; XCTAssertNotNil(dict); XCTAssertEqual(dict.count, 0U); - XCTAssertFalse([dict valueForKey:1U value:NULL]); - [dict enumerateKeysAndValuesUsingBlock:^(uint32_t aKey, int64_t aValue, BOOL *stop) { + XCTAssertFalse([dict getInt64:NULL forKey:1U]); + [dict enumerateKeysAndInt64sUsingBlock:^(uint32_t aKey, int64_t aValue, BOOL *stop) { #pragma unused(aKey, aValue, stop) XCTFail(@"Shouldn't get here!"); }]; @@ -1174,15 +1174,15 @@ static BOOL TestingEnum_IsValidValue(int32_t value) { } - (void)testOne { - GPBUInt32Int64Dictionary *dict = [GPBUInt32Int64Dictionary dictionaryWithValue:400 forKey:1U]; + GPBUInt32Int64Dictionary *dict = [GPBUInt32Int64Dictionary dictionaryWithInt64:400 forKey:1U]; XCTAssertNotNil(dict); XCTAssertEqual(dict.count, 1U); int64_t value; - XCTAssertTrue([dict valueForKey:1U value:NULL]); - XCTAssertTrue([dict valueForKey:1U value:&value]); + XCTAssertTrue([dict getInt64:NULL forKey:1U]); + XCTAssertTrue([dict getInt64:&value forKey:1U]); XCTAssertEqual(value, 400); - XCTAssertFalse([dict valueForKey:2U value:NULL]); - [dict enumerateKeysAndValuesUsingBlock:^(uint32_t aKey, int64_t aValue, BOOL *stop) { + XCTAssertFalse([dict getInt64:NULL forKey:2U]); + [dict enumerateKeysAndInt64sUsingBlock:^(uint32_t aKey, int64_t aValue, BOOL *stop) { XCTAssertEqual(aKey, 1U); XCTAssertEqual(aValue, 400); XCTAssertNotEqual(stop, NULL); @@ -1193,27 +1193,27 @@ static BOOL TestingEnum_IsValidValue(int32_t value) { const uint32_t kKeys[] = { 1U, 2U, 3U }; const int64_t kValues[] = { 400, 401, 402 }; GPBUInt32Int64Dictionary *dict = - [[GPBUInt32Int64Dictionary alloc] initWithValues:kValues + [[GPBUInt32Int64Dictionary alloc] initWithInt64s:kValues forKeys:kKeys count:GPBARRAYSIZE(kValues)]; XCTAssertNotNil(dict); XCTAssertEqual(dict.count, 3U); int64_t value; - XCTAssertTrue([dict valueForKey:1U value:NULL]); - XCTAssertTrue([dict valueForKey:1U value:&value]); + XCTAssertTrue([dict getInt64:NULL forKey:1U]); + XCTAssertTrue([dict getInt64:&value forKey:1U]); XCTAssertEqual(value, 400); - XCTAssertTrue([dict valueForKey:2U value:NULL]); - XCTAssertTrue([dict valueForKey:2U value:&value]); + XCTAssertTrue([dict getInt64:NULL forKey:2U]); + XCTAssertTrue([dict getInt64:&value forKey:2U]); XCTAssertEqual(value, 401); - XCTAssertTrue([dict valueForKey:3U value:NULL]); - XCTAssertTrue([dict valueForKey:3U value:&value]); + XCTAssertTrue([dict getInt64:NULL forKey:3U]); + XCTAssertTrue([dict getInt64:&value forKey:3U]); XCTAssertEqual(value, 402); - XCTAssertFalse([dict valueForKey:4U value:NULL]); + XCTAssertFalse([dict getInt64:NULL forKey:4U]); __block NSUInteger idx = 0; uint32_t *seenKeys = malloc(3 * sizeof(uint32_t)); int64_t *seenValues = malloc(3 * sizeof(int64_t)); - [dict enumerateKeysAndValuesUsingBlock:^(uint32_t aKey, int64_t aValue, BOOL *stop) { + [dict enumerateKeysAndInt64sUsingBlock:^(uint32_t aKey, int64_t aValue, BOOL *stop) { XCTAssertLessThan(idx, 3U); seenKeys[idx] = aKey; seenValues[idx] = aValue; @@ -1235,7 +1235,7 @@ static BOOL TestingEnum_IsValidValue(int32_t value) { // Stopping the enumeration. idx = 0; - [dict enumerateKeysAndValuesUsingBlock:^(uint32_t aKey, int64_t aValue, BOOL *stop) { + [dict enumerateKeysAndInt64sUsingBlock:^(uint32_t aKey, int64_t aValue, BOOL *stop) { #pragma unused(aKey, aValue) if (idx == 1) *stop = YES; XCTAssertNotEqual(idx, 2U); @@ -1251,27 +1251,27 @@ static BOOL TestingEnum_IsValidValue(int32_t value) { const int64_t kValues2[] = { 400, 403, 402 }; const int64_t kValues3[] = { 400, 401, 402, 403 }; GPBUInt32Int64Dictionary *dict1 = - [[GPBUInt32Int64Dictionary alloc] initWithValues:kValues1 + [[GPBUInt32Int64Dictionary alloc] initWithInt64s:kValues1 forKeys:kKeys1 count:GPBARRAYSIZE(kValues1)]; XCTAssertNotNil(dict1); GPBUInt32Int64Dictionary *dict1prime = - [[GPBUInt32Int64Dictionary alloc] initWithValues:kValues1 + [[GPBUInt32Int64Dictionary alloc] initWithInt64s:kValues1 forKeys:kKeys1 count:GPBARRAYSIZE(kValues1)]; XCTAssertNotNil(dict1prime); GPBUInt32Int64Dictionary *dict2 = - [[GPBUInt32Int64Dictionary alloc] initWithValues:kValues2 + [[GPBUInt32Int64Dictionary alloc] initWithInt64s:kValues2 forKeys:kKeys1 count:GPBARRAYSIZE(kValues2)]; XCTAssertNotNil(dict2); GPBUInt32Int64Dictionary *dict3 = - [[GPBUInt32Int64Dictionary alloc] initWithValues:kValues1 + [[GPBUInt32Int64Dictionary alloc] initWithInt64s:kValues1 forKeys:kKeys2 count:GPBARRAYSIZE(kValues1)]; XCTAssertNotNil(dict3); GPBUInt32Int64Dictionary *dict4 = - [[GPBUInt32Int64Dictionary alloc] initWithValues:kValues3 + [[GPBUInt32Int64Dictionary alloc] initWithInt64s:kValues3 forKeys:kKeys1 count:GPBARRAYSIZE(kValues3)]; XCTAssertNotNil(dict4); @@ -1302,7 +1302,7 @@ static BOOL TestingEnum_IsValidValue(int32_t value) { const uint32_t kKeys[] = { 1U, 2U, 3U, 4U }; const int64_t kValues[] = { 400, 401, 402, 403 }; GPBUInt32Int64Dictionary *dict = - [[GPBUInt32Int64Dictionary alloc] initWithValues:kValues + [[GPBUInt32Int64Dictionary alloc] initWithInt64s:kValues forKeys:kKeys count:GPBARRAYSIZE(kValues)]; XCTAssertNotNil(dict); @@ -1323,7 +1323,7 @@ static BOOL TestingEnum_IsValidValue(int32_t value) { const uint32_t kKeys[] = { 1U, 2U, 3U, 4U }; const int64_t kValues[] = { 400, 401, 402, 403 }; GPBUInt32Int64Dictionary *dict = - [[GPBUInt32Int64Dictionary alloc] initWithValues:kValues + [[GPBUInt32Int64Dictionary alloc] initWithInt64s:kValues forKeys:kKeys count:GPBARRAYSIZE(kValues)]; XCTAssertNotNil(dict); @@ -1343,13 +1343,13 @@ static BOOL TestingEnum_IsValidValue(int32_t value) { XCTAssertNotNil(dict); XCTAssertEqual(dict.count, 0U); - [dict setValue:400 forKey:1U]; + [dict setInt64:400 forKey:1U]; XCTAssertEqual(dict.count, 1U); const uint32_t kKeys[] = { 2U, 3U, 4U }; const int64_t kValues[] = { 401, 402, 403 }; GPBUInt32Int64Dictionary *dict2 = - [[GPBUInt32Int64Dictionary alloc] initWithValues:kValues + [[GPBUInt32Int64Dictionary alloc] initWithInt64s:kValues forKeys:kKeys count:GPBARRAYSIZE(kValues)]; XCTAssertNotNil(dict2); @@ -1357,17 +1357,17 @@ static BOOL TestingEnum_IsValidValue(int32_t value) { XCTAssertEqual(dict.count, 4U); int64_t value; - XCTAssertTrue([dict valueForKey:1U value:NULL]); - XCTAssertTrue([dict valueForKey:1U value:&value]); + XCTAssertTrue([dict getInt64:NULL forKey:1U]); + XCTAssertTrue([dict getInt64:&value forKey:1U]); XCTAssertEqual(value, 400); - XCTAssertTrue([dict valueForKey:2U value:NULL]); - XCTAssertTrue([dict valueForKey:2U value:&value]); + XCTAssertTrue([dict getInt64:NULL forKey:2U]); + XCTAssertTrue([dict getInt64:&value forKey:2U]); XCTAssertEqual(value, 401); - XCTAssertTrue([dict valueForKey:3U value:NULL]); - XCTAssertTrue([dict valueForKey:3U value:&value]); + XCTAssertTrue([dict getInt64:NULL forKey:3U]); + XCTAssertTrue([dict getInt64:&value forKey:3U]); XCTAssertEqual(value, 402); - XCTAssertTrue([dict valueForKey:4U value:NULL]); - XCTAssertTrue([dict valueForKey:4U value:&value]); + XCTAssertTrue([dict getInt64:NULL forKey:4U]); + XCTAssertTrue([dict getInt64:&value forKey:4U]); XCTAssertEqual(value, 403); [dict2 release]; } @@ -1376,57 +1376,57 @@ static BOOL TestingEnum_IsValidValue(int32_t value) { const uint32_t kKeys[] = { 1U, 2U, 3U, 4U }; const int64_t kValues[] = { 400, 401, 402, 403 }; GPBUInt32Int64Dictionary *dict = - [[GPBUInt32Int64Dictionary alloc] initWithValues:kValues - forKeys:kKeys - count:GPBARRAYSIZE(kValues)]; + [[GPBUInt32Int64Dictionary alloc] initWithInt64s:kValues + forKeys:kKeys + count:GPBARRAYSIZE(kValues)]; XCTAssertNotNil(dict); XCTAssertEqual(dict.count, 4U); - [dict removeValueForKey:2U]; + [dict removeInt64ForKey:2U]; XCTAssertEqual(dict.count, 3U); int64_t value; - XCTAssertTrue([dict valueForKey:1U value:NULL]); - XCTAssertTrue([dict valueForKey:1U value:&value]); + XCTAssertTrue([dict getInt64:NULL forKey:1U]); + XCTAssertTrue([dict getInt64:&value forKey:1U]); XCTAssertEqual(value, 400); - XCTAssertFalse([dict valueForKey:2U value:NULL]); - XCTAssertTrue([dict valueForKey:3U value:NULL]); - XCTAssertTrue([dict valueForKey:3U value:&value]); + XCTAssertFalse([dict getInt64:NULL forKey:2U]); + XCTAssertTrue([dict getInt64:NULL forKey:3U]); + XCTAssertTrue([dict getInt64:&value forKey:3U]); XCTAssertEqual(value, 402); - XCTAssertTrue([dict valueForKey:4U value:NULL]); - XCTAssertTrue([dict valueForKey:4U value:&value]); + XCTAssertTrue([dict getInt64:NULL forKey:4U]); + XCTAssertTrue([dict getInt64:&value forKey:4U]); XCTAssertEqual(value, 403); // Remove again does nothing. - [dict removeValueForKey:2U]; + [dict removeInt64ForKey:2U]; XCTAssertEqual(dict.count, 3U); - XCTAssertTrue([dict valueForKey:1U value:NULL]); - XCTAssertTrue([dict valueForKey:1U value:&value]); + XCTAssertTrue([dict getInt64:NULL forKey:1U]); + XCTAssertTrue([dict getInt64:&value forKey:1U]); XCTAssertEqual(value, 400); - XCTAssertFalse([dict valueForKey:2U value:NULL]); - XCTAssertTrue([dict valueForKey:3U value:NULL]); - XCTAssertTrue([dict valueForKey:3U value:&value]); + XCTAssertFalse([dict getInt64:NULL forKey:2U]); + XCTAssertTrue([dict getInt64:NULL forKey:3U]); + XCTAssertTrue([dict getInt64:&value forKey:3U]); XCTAssertEqual(value, 402); - XCTAssertTrue([dict valueForKey:4U value:NULL]); - XCTAssertTrue([dict valueForKey:4U value:&value]); + XCTAssertTrue([dict getInt64:NULL forKey:4U]); + XCTAssertTrue([dict getInt64:&value forKey:4U]); XCTAssertEqual(value, 403); - [dict removeValueForKey:4U]; + [dict removeInt64ForKey:4U]; XCTAssertEqual(dict.count, 2U); - XCTAssertTrue([dict valueForKey:1U value:NULL]); - XCTAssertTrue([dict valueForKey:1U value:&value]); + XCTAssertTrue([dict getInt64:NULL forKey:1U]); + XCTAssertTrue([dict getInt64:&value forKey:1U]); XCTAssertEqual(value, 400); - XCTAssertFalse([dict valueForKey:2U value:NULL]); - XCTAssertTrue([dict valueForKey:3U value:NULL]); - XCTAssertTrue([dict valueForKey:3U value:&value]); + XCTAssertFalse([dict getInt64:NULL forKey:2U]); + XCTAssertTrue([dict getInt64:NULL forKey:3U]); + XCTAssertTrue([dict getInt64:&value forKey:3U]); XCTAssertEqual(value, 402); - XCTAssertFalse([dict valueForKey:4U value:NULL]); + XCTAssertFalse([dict getInt64:NULL forKey:4U]); [dict removeAll]; XCTAssertEqual(dict.count, 0U); - XCTAssertFalse([dict valueForKey:1U value:NULL]); - XCTAssertFalse([dict valueForKey:2U value:NULL]); - XCTAssertFalse([dict valueForKey:3U value:NULL]); - XCTAssertFalse([dict valueForKey:4U value:NULL]); + XCTAssertFalse([dict getInt64:NULL forKey:1U]); + XCTAssertFalse([dict getInt64:NULL forKey:2U]); + XCTAssertFalse([dict getInt64:NULL forKey:3U]); + XCTAssertFalse([dict getInt64:NULL forKey:4U]); [dict release]; } @@ -1434,75 +1434,75 @@ static BOOL TestingEnum_IsValidValue(int32_t value) { const uint32_t kKeys[] = { 1U, 2U, 3U, 4U }; const int64_t kValues[] = { 400, 401, 402, 403 }; GPBUInt32Int64Dictionary *dict = - [[GPBUInt32Int64Dictionary alloc] initWithValues:kValues - forKeys:kKeys - count:GPBARRAYSIZE(kValues)]; + [[GPBUInt32Int64Dictionary alloc] initWithInt64s:kValues + forKeys:kKeys + count:GPBARRAYSIZE(kValues)]; XCTAssertNotNil(dict); XCTAssertEqual(dict.count, 4U); int64_t value; - XCTAssertTrue([dict valueForKey:1U value:NULL]); - XCTAssertTrue([dict valueForKey:1U value:&value]); + XCTAssertTrue([dict getInt64:NULL forKey:1U]); + XCTAssertTrue([dict getInt64:&value forKey:1U]); XCTAssertEqual(value, 400); - XCTAssertTrue([dict valueForKey:2U value:NULL]); - XCTAssertTrue([dict valueForKey:2U value:&value]); + XCTAssertTrue([dict getInt64:NULL forKey:2U]); + XCTAssertTrue([dict getInt64:&value forKey:2U]); XCTAssertEqual(value, 401); - XCTAssertTrue([dict valueForKey:3U value:NULL]); - XCTAssertTrue([dict valueForKey:3U value:&value]); + XCTAssertTrue([dict getInt64:NULL forKey:3U]); + XCTAssertTrue([dict getInt64:&value forKey:3U]); XCTAssertEqual(value, 402); - XCTAssertTrue([dict valueForKey:4U value:NULL]); - XCTAssertTrue([dict valueForKey:4U value:&value]); + XCTAssertTrue([dict getInt64:NULL forKey:4U]); + XCTAssertTrue([dict getInt64:&value forKey:4U]); XCTAssertEqual(value, 403); - [dict setValue:403 forKey:1U]; + [dict setInt64:403 forKey:1U]; XCTAssertEqual(dict.count, 4U); - XCTAssertTrue([dict valueForKey:1U value:NULL]); - XCTAssertTrue([dict valueForKey:1U value:&value]); + XCTAssertTrue([dict getInt64:NULL forKey:1U]); + XCTAssertTrue([dict getInt64:&value forKey:1U]); XCTAssertEqual(value, 403); - XCTAssertTrue([dict valueForKey:2U value:NULL]); - XCTAssertTrue([dict valueForKey:2U value:&value]); + XCTAssertTrue([dict getInt64:NULL forKey:2U]); + XCTAssertTrue([dict getInt64:&value forKey:2U]); XCTAssertEqual(value, 401); - XCTAssertTrue([dict valueForKey:3U value:NULL]); - XCTAssertTrue([dict valueForKey:3U value:&value]); + XCTAssertTrue([dict getInt64:NULL forKey:3U]); + XCTAssertTrue([dict getInt64:&value forKey:3U]); XCTAssertEqual(value, 402); - XCTAssertTrue([dict valueForKey:4U value:NULL]); - XCTAssertTrue([dict valueForKey:4U value:&value]); + XCTAssertTrue([dict getInt64:NULL forKey:4U]); + XCTAssertTrue([dict getInt64:&value forKey:4U]); XCTAssertEqual(value, 403); - [dict setValue:401 forKey:4U]; + [dict setInt64:401 forKey:4U]; XCTAssertEqual(dict.count, 4U); - XCTAssertTrue([dict valueForKey:1U value:NULL]); - XCTAssertTrue([dict valueForKey:1U value:&value]); + XCTAssertTrue([dict getInt64:NULL forKey:1U]); + XCTAssertTrue([dict getInt64:&value forKey:1U]); XCTAssertEqual(value, 403); - XCTAssertTrue([dict valueForKey:2U value:NULL]); - XCTAssertTrue([dict valueForKey:2U value:&value]); + XCTAssertTrue([dict getInt64:NULL forKey:2U]); + XCTAssertTrue([dict getInt64:&value forKey:2U]); XCTAssertEqual(value, 401); - XCTAssertTrue([dict valueForKey:3U value:NULL]); - XCTAssertTrue([dict valueForKey:3U value:&value]); + XCTAssertTrue([dict getInt64:NULL forKey:3U]); + XCTAssertTrue([dict getInt64:&value forKey:3U]); XCTAssertEqual(value, 402); - XCTAssertTrue([dict valueForKey:4U value:NULL]); - XCTAssertTrue([dict valueForKey:4U value:&value]); + XCTAssertTrue([dict getInt64:NULL forKey:4U]); + XCTAssertTrue([dict getInt64:&value forKey:4U]); XCTAssertEqual(value, 401); const uint32_t kKeys2[] = { 2U, 3U }; const int64_t kValues2[] = { 402, 400 }; GPBUInt32Int64Dictionary *dict2 = - [[GPBUInt32Int64Dictionary alloc] initWithValues:kValues2 + [[GPBUInt32Int64Dictionary alloc] initWithInt64s:kValues2 forKeys:kKeys2 count:GPBARRAYSIZE(kValues2)]; XCTAssertNotNil(dict2); [dict addEntriesFromDictionary:dict2]; XCTAssertEqual(dict.count, 4U); - XCTAssertTrue([dict valueForKey:1U value:NULL]); - XCTAssertTrue([dict valueForKey:1U value:&value]); + XCTAssertTrue([dict getInt64:NULL forKey:1U]); + XCTAssertTrue([dict getInt64:&value forKey:1U]); XCTAssertEqual(value, 403); - XCTAssertTrue([dict valueForKey:2U value:NULL]); - XCTAssertTrue([dict valueForKey:2U value:&value]); + XCTAssertTrue([dict getInt64:NULL forKey:2U]); + XCTAssertTrue([dict getInt64:&value forKey:2U]); XCTAssertEqual(value, 402); - XCTAssertTrue([dict valueForKey:3U value:NULL]); - XCTAssertTrue([dict valueForKey:3U value:&value]); + XCTAssertTrue([dict getInt64:NULL forKey:3U]); + XCTAssertTrue([dict getInt64:&value forKey:3U]); XCTAssertEqual(value, 400); - XCTAssertTrue([dict valueForKey:4U value:NULL]); - XCTAssertTrue([dict valueForKey:4U value:&value]); + XCTAssertTrue([dict getInt64:NULL forKey:4U]); + XCTAssertTrue([dict getInt64:&value forKey:4U]); XCTAssertEqual(value, 401); [dict2 release]; @@ -1522,8 +1522,8 @@ static BOOL TestingEnum_IsValidValue(int32_t value) { GPBUInt32BoolDictionary *dict = [[GPBUInt32BoolDictionary alloc] init]; XCTAssertNotNil(dict); XCTAssertEqual(dict.count, 0U); - XCTAssertFalse([dict valueForKey:1U value:NULL]); - [dict enumerateKeysAndValuesUsingBlock:^(uint32_t aKey, BOOL aValue, BOOL *stop) { + XCTAssertFalse([dict getBool:NULL forKey:1U]); + [dict enumerateKeysAndBoolsUsingBlock:^(uint32_t aKey, BOOL aValue, BOOL *stop) { #pragma unused(aKey, aValue, stop) XCTFail(@"Shouldn't get here!"); }]; @@ -1531,15 +1531,15 @@ static BOOL TestingEnum_IsValidValue(int32_t value) { } - (void)testOne { - GPBUInt32BoolDictionary *dict = [GPBUInt32BoolDictionary dictionaryWithValue:YES forKey:1U]; + GPBUInt32BoolDictionary *dict = [GPBUInt32BoolDictionary dictionaryWithBool:YES forKey:1U]; XCTAssertNotNil(dict); XCTAssertEqual(dict.count, 1U); BOOL value; - XCTAssertTrue([dict valueForKey:1U value:NULL]); - XCTAssertTrue([dict valueForKey:1U value:&value]); + XCTAssertTrue([dict getBool:NULL forKey:1U]); + XCTAssertTrue([dict getBool:&value forKey:1U]); XCTAssertEqual(value, YES); - XCTAssertFalse([dict valueForKey:2U value:NULL]); - [dict enumerateKeysAndValuesUsingBlock:^(uint32_t aKey, BOOL aValue, BOOL *stop) { + XCTAssertFalse([dict getBool:NULL forKey:2U]); + [dict enumerateKeysAndBoolsUsingBlock:^(uint32_t aKey, BOOL aValue, BOOL *stop) { XCTAssertEqual(aKey, 1U); XCTAssertEqual(aValue, YES); XCTAssertNotEqual(stop, NULL); @@ -1550,27 +1550,27 @@ static BOOL TestingEnum_IsValidValue(int32_t value) { const uint32_t kKeys[] = { 1U, 2U, 3U }; const BOOL kValues[] = { YES, YES, NO }; GPBUInt32BoolDictionary *dict = - [[GPBUInt32BoolDictionary alloc] initWithValues:kValues - forKeys:kKeys - count:GPBARRAYSIZE(kValues)]; + [[GPBUInt32BoolDictionary alloc] initWithBools:kValues + forKeys:kKeys + count:GPBARRAYSIZE(kValues)]; XCTAssertNotNil(dict); XCTAssertEqual(dict.count, 3U); BOOL value; - XCTAssertTrue([dict valueForKey:1U value:NULL]); - XCTAssertTrue([dict valueForKey:1U value:&value]); + XCTAssertTrue([dict getBool:NULL forKey:1U]); + XCTAssertTrue([dict getBool:&value forKey:1U]); XCTAssertEqual(value, YES); - XCTAssertTrue([dict valueForKey:2U value:NULL]); - XCTAssertTrue([dict valueForKey:2U value:&value]); + XCTAssertTrue([dict getBool:NULL forKey:2U]); + XCTAssertTrue([dict getBool:&value forKey:2U]); XCTAssertEqual(value, YES); - XCTAssertTrue([dict valueForKey:3U value:NULL]); - XCTAssertTrue([dict valueForKey:3U value:&value]); + XCTAssertTrue([dict getBool:NULL forKey:3U]); + XCTAssertTrue([dict getBool:&value forKey:3U]); XCTAssertEqual(value, NO); - XCTAssertFalse([dict valueForKey:4U value:NULL]); + XCTAssertFalse([dict getBool:NULL forKey:4U]); __block NSUInteger idx = 0; uint32_t *seenKeys = malloc(3 * sizeof(uint32_t)); BOOL *seenValues = malloc(3 * sizeof(BOOL)); - [dict enumerateKeysAndValuesUsingBlock:^(uint32_t aKey, BOOL aValue, BOOL *stop) { + [dict enumerateKeysAndBoolsUsingBlock:^(uint32_t aKey, BOOL aValue, BOOL *stop) { XCTAssertLessThan(idx, 3U); seenKeys[idx] = aKey; seenValues[idx] = aValue; @@ -1592,7 +1592,7 @@ static BOOL TestingEnum_IsValidValue(int32_t value) { // Stopping the enumeration. idx = 0; - [dict enumerateKeysAndValuesUsingBlock:^(uint32_t aKey, BOOL aValue, BOOL *stop) { + [dict enumerateKeysAndBoolsUsingBlock:^(uint32_t aKey, BOOL aValue, BOOL *stop) { #pragma unused(aKey, aValue) if (idx == 1) *stop = YES; XCTAssertNotEqual(idx, 2U); @@ -1608,29 +1608,29 @@ static BOOL TestingEnum_IsValidValue(int32_t value) { const BOOL kValues2[] = { YES, NO, NO }; const BOOL kValues3[] = { YES, YES, NO, NO }; GPBUInt32BoolDictionary *dict1 = - [[GPBUInt32BoolDictionary alloc] initWithValues:kValues1 - forKeys:kKeys1 - count:GPBARRAYSIZE(kValues1)]; + [[GPBUInt32BoolDictionary alloc] initWithBools:kValues1 + forKeys:kKeys1 + count:GPBARRAYSIZE(kValues1)]; XCTAssertNotNil(dict1); GPBUInt32BoolDictionary *dict1prime = - [[GPBUInt32BoolDictionary alloc] initWithValues:kValues1 - forKeys:kKeys1 - count:GPBARRAYSIZE(kValues1)]; + [[GPBUInt32BoolDictionary alloc] initWithBools:kValues1 + forKeys:kKeys1 + count:GPBARRAYSIZE(kValues1)]; XCTAssertNotNil(dict1prime); GPBUInt32BoolDictionary *dict2 = - [[GPBUInt32BoolDictionary alloc] initWithValues:kValues2 - forKeys:kKeys1 - count:GPBARRAYSIZE(kValues2)]; + [[GPBUInt32BoolDictionary alloc] initWithBools:kValues2 + forKeys:kKeys1 + count:GPBARRAYSIZE(kValues2)]; XCTAssertNotNil(dict2); GPBUInt32BoolDictionary *dict3 = - [[GPBUInt32BoolDictionary alloc] initWithValues:kValues1 - forKeys:kKeys2 - count:GPBARRAYSIZE(kValues1)]; + [[GPBUInt32BoolDictionary alloc] initWithBools:kValues1 + forKeys:kKeys2 + count:GPBARRAYSIZE(kValues1)]; XCTAssertNotNil(dict3); GPBUInt32BoolDictionary *dict4 = - [[GPBUInt32BoolDictionary alloc] initWithValues:kValues3 - forKeys:kKeys1 - count:GPBARRAYSIZE(kValues3)]; + [[GPBUInt32BoolDictionary alloc] initWithBools:kValues3 + forKeys:kKeys1 + count:GPBARRAYSIZE(kValues3)]; XCTAssertNotNil(dict4); // 1/1Prime should be different objects, but equal. @@ -1659,9 +1659,9 @@ static BOOL TestingEnum_IsValidValue(int32_t value) { const uint32_t kKeys[] = { 1U, 2U, 3U, 4U }; const BOOL kValues[] = { YES, YES, NO, NO }; GPBUInt32BoolDictionary *dict = - [[GPBUInt32BoolDictionary alloc] initWithValues:kValues - forKeys:kKeys - count:GPBARRAYSIZE(kValues)]; + [[GPBUInt32BoolDictionary alloc] initWithBools:kValues + forKeys:kKeys + count:GPBARRAYSIZE(kValues)]; XCTAssertNotNil(dict); GPBUInt32BoolDictionary *dict2 = [dict copy]; @@ -1680,9 +1680,9 @@ static BOOL TestingEnum_IsValidValue(int32_t value) { const uint32_t kKeys[] = { 1U, 2U, 3U, 4U }; const BOOL kValues[] = { YES, YES, NO, NO }; GPBUInt32BoolDictionary *dict = - [[GPBUInt32BoolDictionary alloc] initWithValues:kValues - forKeys:kKeys - count:GPBARRAYSIZE(kValues)]; + [[GPBUInt32BoolDictionary alloc] initWithBools:kValues + forKeys:kKeys + count:GPBARRAYSIZE(kValues)]; XCTAssertNotNil(dict); GPBUInt32BoolDictionary *dict2 = @@ -1700,31 +1700,31 @@ static BOOL TestingEnum_IsValidValue(int32_t value) { XCTAssertNotNil(dict); XCTAssertEqual(dict.count, 0U); - [dict setValue:YES forKey:1U]; + [dict setBool:YES forKey:1U]; XCTAssertEqual(dict.count, 1U); const uint32_t kKeys[] = { 2U, 3U, 4U }; const BOOL kValues[] = { YES, NO, NO }; GPBUInt32BoolDictionary *dict2 = - [[GPBUInt32BoolDictionary alloc] initWithValues:kValues - forKeys:kKeys - count:GPBARRAYSIZE(kValues)]; + [[GPBUInt32BoolDictionary alloc] initWithBools:kValues + forKeys:kKeys + count:GPBARRAYSIZE(kValues)]; XCTAssertNotNil(dict2); [dict addEntriesFromDictionary:dict2]; XCTAssertEqual(dict.count, 4U); BOOL value; - XCTAssertTrue([dict valueForKey:1U value:NULL]); - XCTAssertTrue([dict valueForKey:1U value:&value]); + XCTAssertTrue([dict getBool:NULL forKey:1U]); + XCTAssertTrue([dict getBool:&value forKey:1U]); XCTAssertEqual(value, YES); - XCTAssertTrue([dict valueForKey:2U value:NULL]); - XCTAssertTrue([dict valueForKey:2U value:&value]); + XCTAssertTrue([dict getBool:NULL forKey:2U]); + XCTAssertTrue([dict getBool:&value forKey:2U]); XCTAssertEqual(value, YES); - XCTAssertTrue([dict valueForKey:3U value:NULL]); - XCTAssertTrue([dict valueForKey:3U value:&value]); + XCTAssertTrue([dict getBool:NULL forKey:3U]); + XCTAssertTrue([dict getBool:&value forKey:3U]); XCTAssertEqual(value, NO); - XCTAssertTrue([dict valueForKey:4U value:NULL]); - XCTAssertTrue([dict valueForKey:4U value:&value]); + XCTAssertTrue([dict getBool:NULL forKey:4U]); + XCTAssertTrue([dict getBool:&value forKey:4U]); XCTAssertEqual(value, NO); [dict2 release]; } @@ -1733,57 +1733,57 @@ static BOOL TestingEnum_IsValidValue(int32_t value) { const uint32_t kKeys[] = { 1U, 2U, 3U, 4U }; const BOOL kValues[] = { YES, YES, NO, NO }; GPBUInt32BoolDictionary *dict = - [[GPBUInt32BoolDictionary alloc] initWithValues:kValues - forKeys:kKeys - count:GPBARRAYSIZE(kValues)]; + [[GPBUInt32BoolDictionary alloc] initWithBools:kValues + forKeys:kKeys + count:GPBARRAYSIZE(kValues)]; XCTAssertNotNil(dict); XCTAssertEqual(dict.count, 4U); - [dict removeValueForKey:2U]; + [dict removeBoolForKey:2U]; XCTAssertEqual(dict.count, 3U); BOOL value; - XCTAssertTrue([dict valueForKey:1U value:NULL]); - XCTAssertTrue([dict valueForKey:1U value:&value]); + XCTAssertTrue([dict getBool:NULL forKey:1U]); + XCTAssertTrue([dict getBool:&value forKey:1U]); XCTAssertEqual(value, YES); - XCTAssertFalse([dict valueForKey:2U value:NULL]); - XCTAssertTrue([dict valueForKey:3U value:NULL]); - XCTAssertTrue([dict valueForKey:3U value:&value]); + XCTAssertFalse([dict getBool:NULL forKey:2U]); + XCTAssertTrue([dict getBool:NULL forKey:3U]); + XCTAssertTrue([dict getBool:&value forKey:3U]); XCTAssertEqual(value, NO); - XCTAssertTrue([dict valueForKey:4U value:NULL]); - XCTAssertTrue([dict valueForKey:4U value:&value]); + XCTAssertTrue([dict getBool:NULL forKey:4U]); + XCTAssertTrue([dict getBool:&value forKey:4U]); XCTAssertEqual(value, NO); // Remove again does nothing. - [dict removeValueForKey:2U]; + [dict removeBoolForKey:2U]; XCTAssertEqual(dict.count, 3U); - XCTAssertTrue([dict valueForKey:1U value:NULL]); - XCTAssertTrue([dict valueForKey:1U value:&value]); + XCTAssertTrue([dict getBool:NULL forKey:1U]); + XCTAssertTrue([dict getBool:&value forKey:1U]); XCTAssertEqual(value, YES); - XCTAssertFalse([dict valueForKey:2U value:NULL]); - XCTAssertTrue([dict valueForKey:3U value:NULL]); - XCTAssertTrue([dict valueForKey:3U value:&value]); + XCTAssertFalse([dict getBool:NULL forKey:2U]); + XCTAssertTrue([dict getBool:NULL forKey:3U]); + XCTAssertTrue([dict getBool:&value forKey:3U]); XCTAssertEqual(value, NO); - XCTAssertTrue([dict valueForKey:4U value:NULL]); - XCTAssertTrue([dict valueForKey:4U value:&value]); + XCTAssertTrue([dict getBool:NULL forKey:4U]); + XCTAssertTrue([dict getBool:&value forKey:4U]); XCTAssertEqual(value, NO); - [dict removeValueForKey:4U]; + [dict removeBoolForKey:4U]; XCTAssertEqual(dict.count, 2U); - XCTAssertTrue([dict valueForKey:1U value:NULL]); - XCTAssertTrue([dict valueForKey:1U value:&value]); + XCTAssertTrue([dict getBool:NULL forKey:1U]); + XCTAssertTrue([dict getBool:&value forKey:1U]); XCTAssertEqual(value, YES); - XCTAssertFalse([dict valueForKey:2U value:NULL]); - XCTAssertTrue([dict valueForKey:3U value:NULL]); - XCTAssertTrue([dict valueForKey:3U value:&value]); + XCTAssertFalse([dict getBool:NULL forKey:2U]); + XCTAssertTrue([dict getBool:NULL forKey:3U]); + XCTAssertTrue([dict getBool:&value forKey:3U]); XCTAssertEqual(value, NO); - XCTAssertFalse([dict valueForKey:4U value:NULL]); + XCTAssertFalse([dict getBool:NULL forKey:4U]); [dict removeAll]; XCTAssertEqual(dict.count, 0U); - XCTAssertFalse([dict valueForKey:1U value:NULL]); - XCTAssertFalse([dict valueForKey:2U value:NULL]); - XCTAssertFalse([dict valueForKey:3U value:NULL]); - XCTAssertFalse([dict valueForKey:4U value:NULL]); + XCTAssertFalse([dict getBool:NULL forKey:1U]); + XCTAssertFalse([dict getBool:NULL forKey:2U]); + XCTAssertFalse([dict getBool:NULL forKey:3U]); + XCTAssertFalse([dict getBool:NULL forKey:4U]); [dict release]; } @@ -1791,75 +1791,75 @@ static BOOL TestingEnum_IsValidValue(int32_t value) { const uint32_t kKeys[] = { 1U, 2U, 3U, 4U }; const BOOL kValues[] = { YES, YES, NO, NO }; GPBUInt32BoolDictionary *dict = - [[GPBUInt32BoolDictionary alloc] initWithValues:kValues - forKeys:kKeys - count:GPBARRAYSIZE(kValues)]; + [[GPBUInt32BoolDictionary alloc] initWithBools:kValues + forKeys:kKeys + count:GPBARRAYSIZE(kValues)]; XCTAssertNotNil(dict); XCTAssertEqual(dict.count, 4U); BOOL value; - XCTAssertTrue([dict valueForKey:1U value:NULL]); - XCTAssertTrue([dict valueForKey:1U value:&value]); + XCTAssertTrue([dict getBool:NULL forKey:1U]); + XCTAssertTrue([dict getBool:&value forKey:1U]); XCTAssertEqual(value, YES); - XCTAssertTrue([dict valueForKey:2U value:NULL]); - XCTAssertTrue([dict valueForKey:2U value:&value]); + XCTAssertTrue([dict getBool:NULL forKey:2U]); + XCTAssertTrue([dict getBool:&value forKey:2U]); XCTAssertEqual(value, YES); - XCTAssertTrue([dict valueForKey:3U value:NULL]); - XCTAssertTrue([dict valueForKey:3U value:&value]); + XCTAssertTrue([dict getBool:NULL forKey:3U]); + XCTAssertTrue([dict getBool:&value forKey:3U]); XCTAssertEqual(value, NO); - XCTAssertTrue([dict valueForKey:4U value:NULL]); - XCTAssertTrue([dict valueForKey:4U value:&value]); + XCTAssertTrue([dict getBool:NULL forKey:4U]); + XCTAssertTrue([dict getBool:&value forKey:4U]); XCTAssertEqual(value, NO); - [dict setValue:NO forKey:1U]; + [dict setBool:NO forKey:1U]; XCTAssertEqual(dict.count, 4U); - XCTAssertTrue([dict valueForKey:1U value:NULL]); - XCTAssertTrue([dict valueForKey:1U value:&value]); + XCTAssertTrue([dict getBool:NULL forKey:1U]); + XCTAssertTrue([dict getBool:&value forKey:1U]); XCTAssertEqual(value, NO); - XCTAssertTrue([dict valueForKey:2U value:NULL]); - XCTAssertTrue([dict valueForKey:2U value:&value]); + XCTAssertTrue([dict getBool:NULL forKey:2U]); + XCTAssertTrue([dict getBool:&value forKey:2U]); XCTAssertEqual(value, YES); - XCTAssertTrue([dict valueForKey:3U value:NULL]); - XCTAssertTrue([dict valueForKey:3U value:&value]); + XCTAssertTrue([dict getBool:NULL forKey:3U]); + XCTAssertTrue([dict getBool:&value forKey:3U]); XCTAssertEqual(value, NO); - XCTAssertTrue([dict valueForKey:4U value:NULL]); - XCTAssertTrue([dict valueForKey:4U value:&value]); + XCTAssertTrue([dict getBool:NULL forKey:4U]); + XCTAssertTrue([dict getBool:&value forKey:4U]); XCTAssertEqual(value, NO); - [dict setValue:YES forKey:4U]; + [dict setBool:YES forKey:4U]; XCTAssertEqual(dict.count, 4U); - XCTAssertTrue([dict valueForKey:1U value:NULL]); - XCTAssertTrue([dict valueForKey:1U value:&value]); + XCTAssertTrue([dict getBool:NULL forKey:1U]); + XCTAssertTrue([dict getBool:&value forKey:1U]); XCTAssertEqual(value, NO); - XCTAssertTrue([dict valueForKey:2U value:NULL]); - XCTAssertTrue([dict valueForKey:2U value:&value]); + XCTAssertTrue([dict getBool:NULL forKey:2U]); + XCTAssertTrue([dict getBool:&value forKey:2U]); XCTAssertEqual(value, YES); - XCTAssertTrue([dict valueForKey:3U value:NULL]); - XCTAssertTrue([dict valueForKey:3U value:&value]); + XCTAssertTrue([dict getBool:NULL forKey:3U]); + XCTAssertTrue([dict getBool:&value forKey:3U]); XCTAssertEqual(value, NO); - XCTAssertTrue([dict valueForKey:4U value:NULL]); - XCTAssertTrue([dict valueForKey:4U value:&value]); + XCTAssertTrue([dict getBool:NULL forKey:4U]); + XCTAssertTrue([dict getBool:&value forKey:4U]); XCTAssertEqual(value, YES); const uint32_t kKeys2[] = { 2U, 3U }; const BOOL kValues2[] = { NO, YES }; GPBUInt32BoolDictionary *dict2 = - [[GPBUInt32BoolDictionary alloc] initWithValues:kValues2 - forKeys:kKeys2 - count:GPBARRAYSIZE(kValues2)]; + [[GPBUInt32BoolDictionary alloc] initWithBools:kValues2 + forKeys:kKeys2 + count:GPBARRAYSIZE(kValues2)]; XCTAssertNotNil(dict2); [dict addEntriesFromDictionary:dict2]; XCTAssertEqual(dict.count, 4U); - XCTAssertTrue([dict valueForKey:1U value:NULL]); - XCTAssertTrue([dict valueForKey:1U value:&value]); + XCTAssertTrue([dict getBool:NULL forKey:1U]); + XCTAssertTrue([dict getBool:&value forKey:1U]); XCTAssertEqual(value, NO); - XCTAssertTrue([dict valueForKey:2U value:NULL]); - XCTAssertTrue([dict valueForKey:2U value:&value]); + XCTAssertTrue([dict getBool:NULL forKey:2U]); + XCTAssertTrue([dict getBool:&value forKey:2U]); XCTAssertEqual(value, NO); - XCTAssertTrue([dict valueForKey:3U value:NULL]); - XCTAssertTrue([dict valueForKey:3U value:&value]); + XCTAssertTrue([dict getBool:NULL forKey:3U]); + XCTAssertTrue([dict getBool:&value forKey:3U]); XCTAssertEqual(value, YES); - XCTAssertTrue([dict valueForKey:4U value:NULL]); - XCTAssertTrue([dict valueForKey:4U value:&value]); + XCTAssertTrue([dict getBool:NULL forKey:4U]); + XCTAssertTrue([dict getBool:&value forKey:4U]); XCTAssertEqual(value, YES); [dict2 release]; @@ -1879,8 +1879,8 @@ static BOOL TestingEnum_IsValidValue(int32_t value) { GPBUInt32FloatDictionary *dict = [[GPBUInt32FloatDictionary alloc] init]; XCTAssertNotNil(dict); XCTAssertEqual(dict.count, 0U); - XCTAssertFalse([dict valueForKey:1U value:NULL]); - [dict enumerateKeysAndValuesUsingBlock:^(uint32_t aKey, float aValue, BOOL *stop) { + XCTAssertFalse([dict getFloat:NULL forKey:1U]); + [dict enumerateKeysAndFloatsUsingBlock:^(uint32_t aKey, float aValue, BOOL *stop) { #pragma unused(aKey, aValue, stop) XCTFail(@"Shouldn't get here!"); }]; @@ -1888,15 +1888,15 @@ static BOOL TestingEnum_IsValidValue(int32_t value) { } - (void)testOne { - GPBUInt32FloatDictionary *dict = [GPBUInt32FloatDictionary dictionaryWithValue:500.f forKey:1U]; + GPBUInt32FloatDictionary *dict = [GPBUInt32FloatDictionary dictionaryWithFloat:500.f forKey:1U]; XCTAssertNotNil(dict); XCTAssertEqual(dict.count, 1U); float value; - XCTAssertTrue([dict valueForKey:1U value:NULL]); - XCTAssertTrue([dict valueForKey:1U value:&value]); + XCTAssertTrue([dict getFloat:NULL forKey:1U]); + XCTAssertTrue([dict getFloat:&value forKey:1U]); XCTAssertEqual(value, 500.f); - XCTAssertFalse([dict valueForKey:2U value:NULL]); - [dict enumerateKeysAndValuesUsingBlock:^(uint32_t aKey, float aValue, BOOL *stop) { + XCTAssertFalse([dict getFloat:NULL forKey:2U]); + [dict enumerateKeysAndFloatsUsingBlock:^(uint32_t aKey, float aValue, BOOL *stop) { XCTAssertEqual(aKey, 1U); XCTAssertEqual(aValue, 500.f); XCTAssertNotEqual(stop, NULL); @@ -1907,27 +1907,27 @@ static BOOL TestingEnum_IsValidValue(int32_t value) { const uint32_t kKeys[] = { 1U, 2U, 3U }; const float kValues[] = { 500.f, 501.f, 502.f }; GPBUInt32FloatDictionary *dict = - [[GPBUInt32FloatDictionary alloc] initWithValues:kValues + [[GPBUInt32FloatDictionary alloc] initWithFloats:kValues forKeys:kKeys count:GPBARRAYSIZE(kValues)]; XCTAssertNotNil(dict); XCTAssertEqual(dict.count, 3U); float value; - XCTAssertTrue([dict valueForKey:1U value:NULL]); - XCTAssertTrue([dict valueForKey:1U value:&value]); + XCTAssertTrue([dict getFloat:NULL forKey:1U]); + XCTAssertTrue([dict getFloat:&value forKey:1U]); XCTAssertEqual(value, 500.f); - XCTAssertTrue([dict valueForKey:2U value:NULL]); - XCTAssertTrue([dict valueForKey:2U value:&value]); + XCTAssertTrue([dict getFloat:NULL forKey:2U]); + XCTAssertTrue([dict getFloat:&value forKey:2U]); XCTAssertEqual(value, 501.f); - XCTAssertTrue([dict valueForKey:3U value:NULL]); - XCTAssertTrue([dict valueForKey:3U value:&value]); + XCTAssertTrue([dict getFloat:NULL forKey:3U]); + XCTAssertTrue([dict getFloat:&value forKey:3U]); XCTAssertEqual(value, 502.f); - XCTAssertFalse([dict valueForKey:4U value:NULL]); + XCTAssertFalse([dict getFloat:NULL forKey:4U]); __block NSUInteger idx = 0; uint32_t *seenKeys = malloc(3 * sizeof(uint32_t)); float *seenValues = malloc(3 * sizeof(float)); - [dict enumerateKeysAndValuesUsingBlock:^(uint32_t aKey, float aValue, BOOL *stop) { + [dict enumerateKeysAndFloatsUsingBlock:^(uint32_t aKey, float aValue, BOOL *stop) { XCTAssertLessThan(idx, 3U); seenKeys[idx] = aKey; seenValues[idx] = aValue; @@ -1949,7 +1949,7 @@ static BOOL TestingEnum_IsValidValue(int32_t value) { // Stopping the enumeration. idx = 0; - [dict enumerateKeysAndValuesUsingBlock:^(uint32_t aKey, float aValue, BOOL *stop) { + [dict enumerateKeysAndFloatsUsingBlock:^(uint32_t aKey, float aValue, BOOL *stop) { #pragma unused(aKey, aValue) if (idx == 1) *stop = YES; XCTAssertNotEqual(idx, 2U); @@ -1965,27 +1965,27 @@ static BOOL TestingEnum_IsValidValue(int32_t value) { const float kValues2[] = { 500.f, 503.f, 502.f }; const float kValues3[] = { 500.f, 501.f, 502.f, 503.f }; GPBUInt32FloatDictionary *dict1 = - [[GPBUInt32FloatDictionary alloc] initWithValues:kValues1 + [[GPBUInt32FloatDictionary alloc] initWithFloats:kValues1 forKeys:kKeys1 count:GPBARRAYSIZE(kValues1)]; XCTAssertNotNil(dict1); GPBUInt32FloatDictionary *dict1prime = - [[GPBUInt32FloatDictionary alloc] initWithValues:kValues1 + [[GPBUInt32FloatDictionary alloc] initWithFloats:kValues1 forKeys:kKeys1 count:GPBARRAYSIZE(kValues1)]; XCTAssertNotNil(dict1prime); GPBUInt32FloatDictionary *dict2 = - [[GPBUInt32FloatDictionary alloc] initWithValues:kValues2 + [[GPBUInt32FloatDictionary alloc] initWithFloats:kValues2 forKeys:kKeys1 count:GPBARRAYSIZE(kValues2)]; XCTAssertNotNil(dict2); GPBUInt32FloatDictionary *dict3 = - [[GPBUInt32FloatDictionary alloc] initWithValues:kValues1 + [[GPBUInt32FloatDictionary alloc] initWithFloats:kValues1 forKeys:kKeys2 count:GPBARRAYSIZE(kValues1)]; XCTAssertNotNil(dict3); GPBUInt32FloatDictionary *dict4 = - [[GPBUInt32FloatDictionary alloc] initWithValues:kValues3 + [[GPBUInt32FloatDictionary alloc] initWithFloats:kValues3 forKeys:kKeys1 count:GPBARRAYSIZE(kValues3)]; XCTAssertNotNil(dict4); @@ -2016,7 +2016,7 @@ static BOOL TestingEnum_IsValidValue(int32_t value) { const uint32_t kKeys[] = { 1U, 2U, 3U, 4U }; const float kValues[] = { 500.f, 501.f, 502.f, 503.f }; GPBUInt32FloatDictionary *dict = - [[GPBUInt32FloatDictionary alloc] initWithValues:kValues + [[GPBUInt32FloatDictionary alloc] initWithFloats:kValues forKeys:kKeys count:GPBARRAYSIZE(kValues)]; XCTAssertNotNil(dict); @@ -2037,7 +2037,7 @@ static BOOL TestingEnum_IsValidValue(int32_t value) { const uint32_t kKeys[] = { 1U, 2U, 3U, 4U }; const float kValues[] = { 500.f, 501.f, 502.f, 503.f }; GPBUInt32FloatDictionary *dict = - [[GPBUInt32FloatDictionary alloc] initWithValues:kValues + [[GPBUInt32FloatDictionary alloc] initWithFloats:kValues forKeys:kKeys count:GPBARRAYSIZE(kValues)]; XCTAssertNotNil(dict); @@ -2057,13 +2057,13 @@ static BOOL TestingEnum_IsValidValue(int32_t value) { XCTAssertNotNil(dict); XCTAssertEqual(dict.count, 0U); - [dict setValue:500.f forKey:1U]; + [dict setFloat:500.f forKey:1U]; XCTAssertEqual(dict.count, 1U); const uint32_t kKeys[] = { 2U, 3U, 4U }; const float kValues[] = { 501.f, 502.f, 503.f }; GPBUInt32FloatDictionary *dict2 = - [[GPBUInt32FloatDictionary alloc] initWithValues:kValues + [[GPBUInt32FloatDictionary alloc] initWithFloats:kValues forKeys:kKeys count:GPBARRAYSIZE(kValues)]; XCTAssertNotNil(dict2); @@ -2071,17 +2071,17 @@ static BOOL TestingEnum_IsValidValue(int32_t value) { XCTAssertEqual(dict.count, 4U); float value; - XCTAssertTrue([dict valueForKey:1U value:NULL]); - XCTAssertTrue([dict valueForKey:1U value:&value]); + XCTAssertTrue([dict getFloat:NULL forKey:1U]); + XCTAssertTrue([dict getFloat:&value forKey:1U]); XCTAssertEqual(value, 500.f); - XCTAssertTrue([dict valueForKey:2U value:NULL]); - XCTAssertTrue([dict valueForKey:2U value:&value]); + XCTAssertTrue([dict getFloat:NULL forKey:2U]); + XCTAssertTrue([dict getFloat:&value forKey:2U]); XCTAssertEqual(value, 501.f); - XCTAssertTrue([dict valueForKey:3U value:NULL]); - XCTAssertTrue([dict valueForKey:3U value:&value]); + XCTAssertTrue([dict getFloat:NULL forKey:3U]); + XCTAssertTrue([dict getFloat:&value forKey:3U]); XCTAssertEqual(value, 502.f); - XCTAssertTrue([dict valueForKey:4U value:NULL]); - XCTAssertTrue([dict valueForKey:4U value:&value]); + XCTAssertTrue([dict getFloat:NULL forKey:4U]); + XCTAssertTrue([dict getFloat:&value forKey:4U]); XCTAssertEqual(value, 503.f); [dict2 release]; } @@ -2090,57 +2090,57 @@ static BOOL TestingEnum_IsValidValue(int32_t value) { const uint32_t kKeys[] = { 1U, 2U, 3U, 4U }; const float kValues[] = { 500.f, 501.f, 502.f, 503.f }; GPBUInt32FloatDictionary *dict = - [[GPBUInt32FloatDictionary alloc] initWithValues:kValues - forKeys:kKeys - count:GPBARRAYSIZE(kValues)]; + [[GPBUInt32FloatDictionary alloc] initWithFloats:kValues + forKeys:kKeys + count:GPBARRAYSIZE(kValues)]; XCTAssertNotNil(dict); XCTAssertEqual(dict.count, 4U); - [dict removeValueForKey:2U]; + [dict removeFloatForKey:2U]; XCTAssertEqual(dict.count, 3U); float value; - XCTAssertTrue([dict valueForKey:1U value:NULL]); - XCTAssertTrue([dict valueForKey:1U value:&value]); + XCTAssertTrue([dict getFloat:NULL forKey:1U]); + XCTAssertTrue([dict getFloat:&value forKey:1U]); XCTAssertEqual(value, 500.f); - XCTAssertFalse([dict valueForKey:2U value:NULL]); - XCTAssertTrue([dict valueForKey:3U value:NULL]); - XCTAssertTrue([dict valueForKey:3U value:&value]); + XCTAssertFalse([dict getFloat:NULL forKey:2U]); + XCTAssertTrue([dict getFloat:NULL forKey:3U]); + XCTAssertTrue([dict getFloat:&value forKey:3U]); XCTAssertEqual(value, 502.f); - XCTAssertTrue([dict valueForKey:4U value:NULL]); - XCTAssertTrue([dict valueForKey:4U value:&value]); + XCTAssertTrue([dict getFloat:NULL forKey:4U]); + XCTAssertTrue([dict getFloat:&value forKey:4U]); XCTAssertEqual(value, 503.f); // Remove again does nothing. - [dict removeValueForKey:2U]; + [dict removeFloatForKey:2U]; XCTAssertEqual(dict.count, 3U); - XCTAssertTrue([dict valueForKey:1U value:NULL]); - XCTAssertTrue([dict valueForKey:1U value:&value]); + XCTAssertTrue([dict getFloat:NULL forKey:1U]); + XCTAssertTrue([dict getFloat:&value forKey:1U]); XCTAssertEqual(value, 500.f); - XCTAssertFalse([dict valueForKey:2U value:NULL]); - XCTAssertTrue([dict valueForKey:3U value:NULL]); - XCTAssertTrue([dict valueForKey:3U value:&value]); + XCTAssertFalse([dict getFloat:NULL forKey:2U]); + XCTAssertTrue([dict getFloat:NULL forKey:3U]); + XCTAssertTrue([dict getFloat:&value forKey:3U]); XCTAssertEqual(value, 502.f); - XCTAssertTrue([dict valueForKey:4U value:NULL]); - XCTAssertTrue([dict valueForKey:4U value:&value]); + XCTAssertTrue([dict getFloat:NULL forKey:4U]); + XCTAssertTrue([dict getFloat:&value forKey:4U]); XCTAssertEqual(value, 503.f); - [dict removeValueForKey:4U]; + [dict removeFloatForKey:4U]; XCTAssertEqual(dict.count, 2U); - XCTAssertTrue([dict valueForKey:1U value:NULL]); - XCTAssertTrue([dict valueForKey:1U value:&value]); + XCTAssertTrue([dict getFloat:NULL forKey:1U]); + XCTAssertTrue([dict getFloat:&value forKey:1U]); XCTAssertEqual(value, 500.f); - XCTAssertFalse([dict valueForKey:2U value:NULL]); - XCTAssertTrue([dict valueForKey:3U value:NULL]); - XCTAssertTrue([dict valueForKey:3U value:&value]); + XCTAssertFalse([dict getFloat:NULL forKey:2U]); + XCTAssertTrue([dict getFloat:NULL forKey:3U]); + XCTAssertTrue([dict getFloat:&value forKey:3U]); XCTAssertEqual(value, 502.f); - XCTAssertFalse([dict valueForKey:4U value:NULL]); + XCTAssertFalse([dict getFloat:NULL forKey:4U]); [dict removeAll]; XCTAssertEqual(dict.count, 0U); - XCTAssertFalse([dict valueForKey:1U value:NULL]); - XCTAssertFalse([dict valueForKey:2U value:NULL]); - XCTAssertFalse([dict valueForKey:3U value:NULL]); - XCTAssertFalse([dict valueForKey:4U value:NULL]); + XCTAssertFalse([dict getFloat:NULL forKey:1U]); + XCTAssertFalse([dict getFloat:NULL forKey:2U]); + XCTAssertFalse([dict getFloat:NULL forKey:3U]); + XCTAssertFalse([dict getFloat:NULL forKey:4U]); [dict release]; } @@ -2148,75 +2148,75 @@ static BOOL TestingEnum_IsValidValue(int32_t value) { const uint32_t kKeys[] = { 1U, 2U, 3U, 4U }; const float kValues[] = { 500.f, 501.f, 502.f, 503.f }; GPBUInt32FloatDictionary *dict = - [[GPBUInt32FloatDictionary alloc] initWithValues:kValues - forKeys:kKeys - count:GPBARRAYSIZE(kValues)]; + [[GPBUInt32FloatDictionary alloc] initWithFloats:kValues + forKeys:kKeys + count:GPBARRAYSIZE(kValues)]; XCTAssertNotNil(dict); XCTAssertEqual(dict.count, 4U); float value; - XCTAssertTrue([dict valueForKey:1U value:NULL]); - XCTAssertTrue([dict valueForKey:1U value:&value]); + XCTAssertTrue([dict getFloat:NULL forKey:1U]); + XCTAssertTrue([dict getFloat:&value forKey:1U]); XCTAssertEqual(value, 500.f); - XCTAssertTrue([dict valueForKey:2U value:NULL]); - XCTAssertTrue([dict valueForKey:2U value:&value]); + XCTAssertTrue([dict getFloat:NULL forKey:2U]); + XCTAssertTrue([dict getFloat:&value forKey:2U]); XCTAssertEqual(value, 501.f); - XCTAssertTrue([dict valueForKey:3U value:NULL]); - XCTAssertTrue([dict valueForKey:3U value:&value]); + XCTAssertTrue([dict getFloat:NULL forKey:3U]); + XCTAssertTrue([dict getFloat:&value forKey:3U]); XCTAssertEqual(value, 502.f); - XCTAssertTrue([dict valueForKey:4U value:NULL]); - XCTAssertTrue([dict valueForKey:4U value:&value]); + XCTAssertTrue([dict getFloat:NULL forKey:4U]); + XCTAssertTrue([dict getFloat:&value forKey:4U]); XCTAssertEqual(value, 503.f); - [dict setValue:503.f forKey:1U]; + [dict setFloat:503.f forKey:1U]; XCTAssertEqual(dict.count, 4U); - XCTAssertTrue([dict valueForKey:1U value:NULL]); - XCTAssertTrue([dict valueForKey:1U value:&value]); + XCTAssertTrue([dict getFloat:NULL forKey:1U]); + XCTAssertTrue([dict getFloat:&value forKey:1U]); XCTAssertEqual(value, 503.f); - XCTAssertTrue([dict valueForKey:2U value:NULL]); - XCTAssertTrue([dict valueForKey:2U value:&value]); + XCTAssertTrue([dict getFloat:NULL forKey:2U]); + XCTAssertTrue([dict getFloat:&value forKey:2U]); XCTAssertEqual(value, 501.f); - XCTAssertTrue([dict valueForKey:3U value:NULL]); - XCTAssertTrue([dict valueForKey:3U value:&value]); + XCTAssertTrue([dict getFloat:NULL forKey:3U]); + XCTAssertTrue([dict getFloat:&value forKey:3U]); XCTAssertEqual(value, 502.f); - XCTAssertTrue([dict valueForKey:4U value:NULL]); - XCTAssertTrue([dict valueForKey:4U value:&value]); + XCTAssertTrue([dict getFloat:NULL forKey:4U]); + XCTAssertTrue([dict getFloat:&value forKey:4U]); XCTAssertEqual(value, 503.f); - [dict setValue:501.f forKey:4U]; + [dict setFloat:501.f forKey:4U]; XCTAssertEqual(dict.count, 4U); - XCTAssertTrue([dict valueForKey:1U value:NULL]); - XCTAssertTrue([dict valueForKey:1U value:&value]); + XCTAssertTrue([dict getFloat:NULL forKey:1U]); + XCTAssertTrue([dict getFloat:&value forKey:1U]); XCTAssertEqual(value, 503.f); - XCTAssertTrue([dict valueForKey:2U value:NULL]); - XCTAssertTrue([dict valueForKey:2U value:&value]); + XCTAssertTrue([dict getFloat:NULL forKey:2U]); + XCTAssertTrue([dict getFloat:&value forKey:2U]); XCTAssertEqual(value, 501.f); - XCTAssertTrue([dict valueForKey:3U value:NULL]); - XCTAssertTrue([dict valueForKey:3U value:&value]); + XCTAssertTrue([dict getFloat:NULL forKey:3U]); + XCTAssertTrue([dict getFloat:&value forKey:3U]); XCTAssertEqual(value, 502.f); - XCTAssertTrue([dict valueForKey:4U value:NULL]); - XCTAssertTrue([dict valueForKey:4U value:&value]); + XCTAssertTrue([dict getFloat:NULL forKey:4U]); + XCTAssertTrue([dict getFloat:&value forKey:4U]); XCTAssertEqual(value, 501.f); const uint32_t kKeys2[] = { 2U, 3U }; const float kValues2[] = { 502.f, 500.f }; GPBUInt32FloatDictionary *dict2 = - [[GPBUInt32FloatDictionary alloc] initWithValues:kValues2 + [[GPBUInt32FloatDictionary alloc] initWithFloats:kValues2 forKeys:kKeys2 count:GPBARRAYSIZE(kValues2)]; XCTAssertNotNil(dict2); [dict addEntriesFromDictionary:dict2]; XCTAssertEqual(dict.count, 4U); - XCTAssertTrue([dict valueForKey:1U value:NULL]); - XCTAssertTrue([dict valueForKey:1U value:&value]); + XCTAssertTrue([dict getFloat:NULL forKey:1U]); + XCTAssertTrue([dict getFloat:&value forKey:1U]); XCTAssertEqual(value, 503.f); - XCTAssertTrue([dict valueForKey:2U value:NULL]); - XCTAssertTrue([dict valueForKey:2U value:&value]); + XCTAssertTrue([dict getFloat:NULL forKey:2U]); + XCTAssertTrue([dict getFloat:&value forKey:2U]); XCTAssertEqual(value, 502.f); - XCTAssertTrue([dict valueForKey:3U value:NULL]); - XCTAssertTrue([dict valueForKey:3U value:&value]); + XCTAssertTrue([dict getFloat:NULL forKey:3U]); + XCTAssertTrue([dict getFloat:&value forKey:3U]); XCTAssertEqual(value, 500.f); - XCTAssertTrue([dict valueForKey:4U value:NULL]); - XCTAssertTrue([dict valueForKey:4U value:&value]); + XCTAssertTrue([dict getFloat:NULL forKey:4U]); + XCTAssertTrue([dict getFloat:&value forKey:4U]); XCTAssertEqual(value, 501.f); [dict2 release]; @@ -2236,8 +2236,8 @@ static BOOL TestingEnum_IsValidValue(int32_t value) { GPBUInt32DoubleDictionary *dict = [[GPBUInt32DoubleDictionary alloc] init]; XCTAssertNotNil(dict); XCTAssertEqual(dict.count, 0U); - XCTAssertFalse([dict valueForKey:1U value:NULL]); - [dict enumerateKeysAndValuesUsingBlock:^(uint32_t aKey, double aValue, BOOL *stop) { + XCTAssertFalse([dict getDouble:NULL forKey:1U]); + [dict enumerateKeysAndDoublesUsingBlock:^(uint32_t aKey, double aValue, BOOL *stop) { #pragma unused(aKey, aValue, stop) XCTFail(@"Shouldn't get here!"); }]; @@ -2245,15 +2245,15 @@ static BOOL TestingEnum_IsValidValue(int32_t value) { } - (void)testOne { - GPBUInt32DoubleDictionary *dict = [GPBUInt32DoubleDictionary dictionaryWithValue:600. forKey:1U]; + GPBUInt32DoubleDictionary *dict = [GPBUInt32DoubleDictionary dictionaryWithDouble:600. forKey:1U]; XCTAssertNotNil(dict); XCTAssertEqual(dict.count, 1U); double value; - XCTAssertTrue([dict valueForKey:1U value:NULL]); - XCTAssertTrue([dict valueForKey:1U value:&value]); + XCTAssertTrue([dict getDouble:NULL forKey:1U]); + XCTAssertTrue([dict getDouble:&value forKey:1U]); XCTAssertEqual(value, 600.); - XCTAssertFalse([dict valueForKey:2U value:NULL]); - [dict enumerateKeysAndValuesUsingBlock:^(uint32_t aKey, double aValue, BOOL *stop) { + XCTAssertFalse([dict getDouble:NULL forKey:2U]); + [dict enumerateKeysAndDoublesUsingBlock:^(uint32_t aKey, double aValue, BOOL *stop) { XCTAssertEqual(aKey, 1U); XCTAssertEqual(aValue, 600.); XCTAssertNotEqual(stop, NULL); @@ -2264,27 +2264,27 @@ static BOOL TestingEnum_IsValidValue(int32_t value) { const uint32_t kKeys[] = { 1U, 2U, 3U }; const double kValues[] = { 600., 601., 602. }; GPBUInt32DoubleDictionary *dict = - [[GPBUInt32DoubleDictionary alloc] initWithValues:kValues - forKeys:kKeys - count:GPBARRAYSIZE(kValues)]; + [[GPBUInt32DoubleDictionary alloc] initWithDoubles:kValues + forKeys:kKeys + count:GPBARRAYSIZE(kValues)]; XCTAssertNotNil(dict); XCTAssertEqual(dict.count, 3U); double value; - XCTAssertTrue([dict valueForKey:1U value:NULL]); - XCTAssertTrue([dict valueForKey:1U value:&value]); + XCTAssertTrue([dict getDouble:NULL forKey:1U]); + XCTAssertTrue([dict getDouble:&value forKey:1U]); XCTAssertEqual(value, 600.); - XCTAssertTrue([dict valueForKey:2U value:NULL]); - XCTAssertTrue([dict valueForKey:2U value:&value]); + XCTAssertTrue([dict getDouble:NULL forKey:2U]); + XCTAssertTrue([dict getDouble:&value forKey:2U]); XCTAssertEqual(value, 601.); - XCTAssertTrue([dict valueForKey:3U value:NULL]); - XCTAssertTrue([dict valueForKey:3U value:&value]); + XCTAssertTrue([dict getDouble:NULL forKey:3U]); + XCTAssertTrue([dict getDouble:&value forKey:3U]); XCTAssertEqual(value, 602.); - XCTAssertFalse([dict valueForKey:4U value:NULL]); + XCTAssertFalse([dict getDouble:NULL forKey:4U]); __block NSUInteger idx = 0; uint32_t *seenKeys = malloc(3 * sizeof(uint32_t)); double *seenValues = malloc(3 * sizeof(double)); - [dict enumerateKeysAndValuesUsingBlock:^(uint32_t aKey, double aValue, BOOL *stop) { + [dict enumerateKeysAndDoublesUsingBlock:^(uint32_t aKey, double aValue, BOOL *stop) { XCTAssertLessThan(idx, 3U); seenKeys[idx] = aKey; seenValues[idx] = aValue; @@ -2306,7 +2306,7 @@ static BOOL TestingEnum_IsValidValue(int32_t value) { // Stopping the enumeration. idx = 0; - [dict enumerateKeysAndValuesUsingBlock:^(uint32_t aKey, double aValue, BOOL *stop) { + [dict enumerateKeysAndDoublesUsingBlock:^(uint32_t aKey, double aValue, BOOL *stop) { #pragma unused(aKey, aValue) if (idx == 1) *stop = YES; XCTAssertNotEqual(idx, 2U); @@ -2322,29 +2322,29 @@ static BOOL TestingEnum_IsValidValue(int32_t value) { const double kValues2[] = { 600., 603., 602. }; const double kValues3[] = { 600., 601., 602., 603. }; GPBUInt32DoubleDictionary *dict1 = - [[GPBUInt32DoubleDictionary alloc] initWithValues:kValues1 - forKeys:kKeys1 - count:GPBARRAYSIZE(kValues1)]; + [[GPBUInt32DoubleDictionary alloc] initWithDoubles:kValues1 + forKeys:kKeys1 + count:GPBARRAYSIZE(kValues1)]; XCTAssertNotNil(dict1); GPBUInt32DoubleDictionary *dict1prime = - [[GPBUInt32DoubleDictionary alloc] initWithValues:kValues1 - forKeys:kKeys1 - count:GPBARRAYSIZE(kValues1)]; + [[GPBUInt32DoubleDictionary alloc] initWithDoubles:kValues1 + forKeys:kKeys1 + count:GPBARRAYSIZE(kValues1)]; XCTAssertNotNil(dict1prime); GPBUInt32DoubleDictionary *dict2 = - [[GPBUInt32DoubleDictionary alloc] initWithValues:kValues2 - forKeys:kKeys1 - count:GPBARRAYSIZE(kValues2)]; + [[GPBUInt32DoubleDictionary alloc] initWithDoubles:kValues2 + forKeys:kKeys1 + count:GPBARRAYSIZE(kValues2)]; XCTAssertNotNil(dict2); GPBUInt32DoubleDictionary *dict3 = - [[GPBUInt32DoubleDictionary alloc] initWithValues:kValues1 - forKeys:kKeys2 - count:GPBARRAYSIZE(kValues1)]; + [[GPBUInt32DoubleDictionary alloc] initWithDoubles:kValues1 + forKeys:kKeys2 + count:GPBARRAYSIZE(kValues1)]; XCTAssertNotNil(dict3); GPBUInt32DoubleDictionary *dict4 = - [[GPBUInt32DoubleDictionary alloc] initWithValues:kValues3 - forKeys:kKeys1 - count:GPBARRAYSIZE(kValues3)]; + [[GPBUInt32DoubleDictionary alloc] initWithDoubles:kValues3 + forKeys:kKeys1 + count:GPBARRAYSIZE(kValues3)]; XCTAssertNotNil(dict4); // 1/1Prime should be different objects, but equal. @@ -2373,9 +2373,9 @@ static BOOL TestingEnum_IsValidValue(int32_t value) { const uint32_t kKeys[] = { 1U, 2U, 3U, 4U }; const double kValues[] = { 600., 601., 602., 603. }; GPBUInt32DoubleDictionary *dict = - [[GPBUInt32DoubleDictionary alloc] initWithValues:kValues - forKeys:kKeys - count:GPBARRAYSIZE(kValues)]; + [[GPBUInt32DoubleDictionary alloc] initWithDoubles:kValues + forKeys:kKeys + count:GPBARRAYSIZE(kValues)]; XCTAssertNotNil(dict); GPBUInt32DoubleDictionary *dict2 = [dict copy]; @@ -2394,9 +2394,9 @@ static BOOL TestingEnum_IsValidValue(int32_t value) { const uint32_t kKeys[] = { 1U, 2U, 3U, 4U }; const double kValues[] = { 600., 601., 602., 603. }; GPBUInt32DoubleDictionary *dict = - [[GPBUInt32DoubleDictionary alloc] initWithValues:kValues - forKeys:kKeys - count:GPBARRAYSIZE(kValues)]; + [[GPBUInt32DoubleDictionary alloc] initWithDoubles:kValues + forKeys:kKeys + count:GPBARRAYSIZE(kValues)]; XCTAssertNotNil(dict); GPBUInt32DoubleDictionary *dict2 = @@ -2414,31 +2414,31 @@ static BOOL TestingEnum_IsValidValue(int32_t value) { XCTAssertNotNil(dict); XCTAssertEqual(dict.count, 0U); - [dict setValue:600. forKey:1U]; + [dict setDouble:600. forKey:1U]; XCTAssertEqual(dict.count, 1U); const uint32_t kKeys[] = { 2U, 3U, 4U }; const double kValues[] = { 601., 602., 603. }; GPBUInt32DoubleDictionary *dict2 = - [[GPBUInt32DoubleDictionary alloc] initWithValues:kValues - forKeys:kKeys - count:GPBARRAYSIZE(kValues)]; + [[GPBUInt32DoubleDictionary alloc] initWithDoubles:kValues + forKeys:kKeys + count:GPBARRAYSIZE(kValues)]; XCTAssertNotNil(dict2); [dict addEntriesFromDictionary:dict2]; XCTAssertEqual(dict.count, 4U); double value; - XCTAssertTrue([dict valueForKey:1U value:NULL]); - XCTAssertTrue([dict valueForKey:1U value:&value]); + XCTAssertTrue([dict getDouble:NULL forKey:1U]); + XCTAssertTrue([dict getDouble:&value forKey:1U]); XCTAssertEqual(value, 600.); - XCTAssertTrue([dict valueForKey:2U value:NULL]); - XCTAssertTrue([dict valueForKey:2U value:&value]); + XCTAssertTrue([dict getDouble:NULL forKey:2U]); + XCTAssertTrue([dict getDouble:&value forKey:2U]); XCTAssertEqual(value, 601.); - XCTAssertTrue([dict valueForKey:3U value:NULL]); - XCTAssertTrue([dict valueForKey:3U value:&value]); + XCTAssertTrue([dict getDouble:NULL forKey:3U]); + XCTAssertTrue([dict getDouble:&value forKey:3U]); XCTAssertEqual(value, 602.); - XCTAssertTrue([dict valueForKey:4U value:NULL]); - XCTAssertTrue([dict valueForKey:4U value:&value]); + XCTAssertTrue([dict getDouble:NULL forKey:4U]); + XCTAssertTrue([dict getDouble:&value forKey:4U]); XCTAssertEqual(value, 603.); [dict2 release]; } @@ -2447,57 +2447,57 @@ static BOOL TestingEnum_IsValidValue(int32_t value) { const uint32_t kKeys[] = { 1U, 2U, 3U, 4U }; const double kValues[] = { 600., 601., 602., 603. }; GPBUInt32DoubleDictionary *dict = - [[GPBUInt32DoubleDictionary alloc] initWithValues:kValues - forKeys:kKeys - count:GPBARRAYSIZE(kValues)]; + [[GPBUInt32DoubleDictionary alloc] initWithDoubles:kValues + forKeys:kKeys + count:GPBARRAYSIZE(kValues)]; XCTAssertNotNil(dict); XCTAssertEqual(dict.count, 4U); - [dict removeValueForKey:2U]; + [dict removeDoubleForKey:2U]; XCTAssertEqual(dict.count, 3U); double value; - XCTAssertTrue([dict valueForKey:1U value:NULL]); - XCTAssertTrue([dict valueForKey:1U value:&value]); + XCTAssertTrue([dict getDouble:NULL forKey:1U]); + XCTAssertTrue([dict getDouble:&value forKey:1U]); XCTAssertEqual(value, 600.); - XCTAssertFalse([dict valueForKey:2U value:NULL]); - XCTAssertTrue([dict valueForKey:3U value:NULL]); - XCTAssertTrue([dict valueForKey:3U value:&value]); + XCTAssertFalse([dict getDouble:NULL forKey:2U]); + XCTAssertTrue([dict getDouble:NULL forKey:3U]); + XCTAssertTrue([dict getDouble:&value forKey:3U]); XCTAssertEqual(value, 602.); - XCTAssertTrue([dict valueForKey:4U value:NULL]); - XCTAssertTrue([dict valueForKey:4U value:&value]); + XCTAssertTrue([dict getDouble:NULL forKey:4U]); + XCTAssertTrue([dict getDouble:&value forKey:4U]); XCTAssertEqual(value, 603.); // Remove again does nothing. - [dict removeValueForKey:2U]; + [dict removeDoubleForKey:2U]; XCTAssertEqual(dict.count, 3U); - XCTAssertTrue([dict valueForKey:1U value:NULL]); - XCTAssertTrue([dict valueForKey:1U value:&value]); + XCTAssertTrue([dict getDouble:NULL forKey:1U]); + XCTAssertTrue([dict getDouble:&value forKey:1U]); XCTAssertEqual(value, 600.); - XCTAssertFalse([dict valueForKey:2U value:NULL]); - XCTAssertTrue([dict valueForKey:3U value:NULL]); - XCTAssertTrue([dict valueForKey:3U value:&value]); + XCTAssertFalse([dict getDouble:NULL forKey:2U]); + XCTAssertTrue([dict getDouble:NULL forKey:3U]); + XCTAssertTrue([dict getDouble:&value forKey:3U]); XCTAssertEqual(value, 602.); - XCTAssertTrue([dict valueForKey:4U value:NULL]); - XCTAssertTrue([dict valueForKey:4U value:&value]); + XCTAssertTrue([dict getDouble:NULL forKey:4U]); + XCTAssertTrue([dict getDouble:&value forKey:4U]); XCTAssertEqual(value, 603.); - [dict removeValueForKey:4U]; + [dict removeDoubleForKey:4U]; XCTAssertEqual(dict.count, 2U); - XCTAssertTrue([dict valueForKey:1U value:NULL]); - XCTAssertTrue([dict valueForKey:1U value:&value]); + XCTAssertTrue([dict getDouble:NULL forKey:1U]); + XCTAssertTrue([dict getDouble:&value forKey:1U]); XCTAssertEqual(value, 600.); - XCTAssertFalse([dict valueForKey:2U value:NULL]); - XCTAssertTrue([dict valueForKey:3U value:NULL]); - XCTAssertTrue([dict valueForKey:3U value:&value]); + XCTAssertFalse([dict getDouble:NULL forKey:2U]); + XCTAssertTrue([dict getDouble:NULL forKey:3U]); + XCTAssertTrue([dict getDouble:&value forKey:3U]); XCTAssertEqual(value, 602.); - XCTAssertFalse([dict valueForKey:4U value:NULL]); + XCTAssertFalse([dict getDouble:NULL forKey:4U]); [dict removeAll]; XCTAssertEqual(dict.count, 0U); - XCTAssertFalse([dict valueForKey:1U value:NULL]); - XCTAssertFalse([dict valueForKey:2U value:NULL]); - XCTAssertFalse([dict valueForKey:3U value:NULL]); - XCTAssertFalse([dict valueForKey:4U value:NULL]); + XCTAssertFalse([dict getDouble:NULL forKey:1U]); + XCTAssertFalse([dict getDouble:NULL forKey:2U]); + XCTAssertFalse([dict getDouble:NULL forKey:3U]); + XCTAssertFalse([dict getDouble:NULL forKey:4U]); [dict release]; } @@ -2505,75 +2505,75 @@ static BOOL TestingEnum_IsValidValue(int32_t value) { const uint32_t kKeys[] = { 1U, 2U, 3U, 4U }; const double kValues[] = { 600., 601., 602., 603. }; GPBUInt32DoubleDictionary *dict = - [[GPBUInt32DoubleDictionary alloc] initWithValues:kValues - forKeys:kKeys - count:GPBARRAYSIZE(kValues)]; + [[GPBUInt32DoubleDictionary alloc] initWithDoubles:kValues + forKeys:kKeys + count:GPBARRAYSIZE(kValues)]; XCTAssertNotNil(dict); XCTAssertEqual(dict.count, 4U); double value; - XCTAssertTrue([dict valueForKey:1U value:NULL]); - XCTAssertTrue([dict valueForKey:1U value:&value]); + XCTAssertTrue([dict getDouble:NULL forKey:1U]); + XCTAssertTrue([dict getDouble:&value forKey:1U]); XCTAssertEqual(value, 600.); - XCTAssertTrue([dict valueForKey:2U value:NULL]); - XCTAssertTrue([dict valueForKey:2U value:&value]); + XCTAssertTrue([dict getDouble:NULL forKey:2U]); + XCTAssertTrue([dict getDouble:&value forKey:2U]); XCTAssertEqual(value, 601.); - XCTAssertTrue([dict valueForKey:3U value:NULL]); - XCTAssertTrue([dict valueForKey:3U value:&value]); + XCTAssertTrue([dict getDouble:NULL forKey:3U]); + XCTAssertTrue([dict getDouble:&value forKey:3U]); XCTAssertEqual(value, 602.); - XCTAssertTrue([dict valueForKey:4U value:NULL]); - XCTAssertTrue([dict valueForKey:4U value:&value]); + XCTAssertTrue([dict getDouble:NULL forKey:4U]); + XCTAssertTrue([dict getDouble:&value forKey:4U]); XCTAssertEqual(value, 603.); - [dict setValue:603. forKey:1U]; + [dict setDouble:603. forKey:1U]; XCTAssertEqual(dict.count, 4U); - XCTAssertTrue([dict valueForKey:1U value:NULL]); - XCTAssertTrue([dict valueForKey:1U value:&value]); + XCTAssertTrue([dict getDouble:NULL forKey:1U]); + XCTAssertTrue([dict getDouble:&value forKey:1U]); XCTAssertEqual(value, 603.); - XCTAssertTrue([dict valueForKey:2U value:NULL]); - XCTAssertTrue([dict valueForKey:2U value:&value]); + XCTAssertTrue([dict getDouble:NULL forKey:2U]); + XCTAssertTrue([dict getDouble:&value forKey:2U]); XCTAssertEqual(value, 601.); - XCTAssertTrue([dict valueForKey:3U value:NULL]); - XCTAssertTrue([dict valueForKey:3U value:&value]); + XCTAssertTrue([dict getDouble:NULL forKey:3U]); + XCTAssertTrue([dict getDouble:&value forKey:3U]); XCTAssertEqual(value, 602.); - XCTAssertTrue([dict valueForKey:4U value:NULL]); - XCTAssertTrue([dict valueForKey:4U value:&value]); + XCTAssertTrue([dict getDouble:NULL forKey:4U]); + XCTAssertTrue([dict getDouble:&value forKey:4U]); XCTAssertEqual(value, 603.); - [dict setValue:601. forKey:4U]; + [dict setDouble:601. forKey:4U]; XCTAssertEqual(dict.count, 4U); - XCTAssertTrue([dict valueForKey:1U value:NULL]); - XCTAssertTrue([dict valueForKey:1U value:&value]); + XCTAssertTrue([dict getDouble:NULL forKey:1U]); + XCTAssertTrue([dict getDouble:&value forKey:1U]); XCTAssertEqual(value, 603.); - XCTAssertTrue([dict valueForKey:2U value:NULL]); - XCTAssertTrue([dict valueForKey:2U value:&value]); + XCTAssertTrue([dict getDouble:NULL forKey:2U]); + XCTAssertTrue([dict getDouble:&value forKey:2U]); XCTAssertEqual(value, 601.); - XCTAssertTrue([dict valueForKey:3U value:NULL]); - XCTAssertTrue([dict valueForKey:3U value:&value]); + XCTAssertTrue([dict getDouble:NULL forKey:3U]); + XCTAssertTrue([dict getDouble:&value forKey:3U]); XCTAssertEqual(value, 602.); - XCTAssertTrue([dict valueForKey:4U value:NULL]); - XCTAssertTrue([dict valueForKey:4U value:&value]); + XCTAssertTrue([dict getDouble:NULL forKey:4U]); + XCTAssertTrue([dict getDouble:&value forKey:4U]); XCTAssertEqual(value, 601.); const uint32_t kKeys2[] = { 2U, 3U }; const double kValues2[] = { 602., 600. }; GPBUInt32DoubleDictionary *dict2 = - [[GPBUInt32DoubleDictionary alloc] initWithValues:kValues2 - forKeys:kKeys2 - count:GPBARRAYSIZE(kValues2)]; + [[GPBUInt32DoubleDictionary alloc] initWithDoubles:kValues2 + forKeys:kKeys2 + count:GPBARRAYSIZE(kValues2)]; XCTAssertNotNil(dict2); [dict addEntriesFromDictionary:dict2]; XCTAssertEqual(dict.count, 4U); - XCTAssertTrue([dict valueForKey:1U value:NULL]); - XCTAssertTrue([dict valueForKey:1U value:&value]); + XCTAssertTrue([dict getDouble:NULL forKey:1U]); + XCTAssertTrue([dict getDouble:&value forKey:1U]); XCTAssertEqual(value, 603.); - XCTAssertTrue([dict valueForKey:2U value:NULL]); - XCTAssertTrue([dict valueForKey:2U value:&value]); + XCTAssertTrue([dict getDouble:NULL forKey:2U]); + XCTAssertTrue([dict getDouble:&value forKey:2U]); XCTAssertEqual(value, 602.); - XCTAssertTrue([dict valueForKey:3U value:NULL]); - XCTAssertTrue([dict valueForKey:3U value:&value]); + XCTAssertTrue([dict getDouble:NULL forKey:3U]); + XCTAssertTrue([dict getDouble:&value forKey:3U]); XCTAssertEqual(value, 600.); - XCTAssertTrue([dict valueForKey:4U value:NULL]); - XCTAssertTrue([dict valueForKey:4U value:&value]); + XCTAssertTrue([dict getDouble:NULL forKey:4U]); + XCTAssertTrue([dict getDouble:&value forKey:4U]); XCTAssertEqual(value, 601.); [dict2 release]; @@ -2593,8 +2593,8 @@ static BOOL TestingEnum_IsValidValue(int32_t value) { GPBUInt32EnumDictionary *dict = [[GPBUInt32EnumDictionary alloc] init]; XCTAssertNotNil(dict); XCTAssertEqual(dict.count, 0U); - XCTAssertFalse([dict valueForKey:1U value:NULL]); - [dict enumerateKeysAndValuesUsingBlock:^(uint32_t aKey, int32_t aValue, BOOL *stop) { + XCTAssertFalse([dict getEnum:NULL forKey:1U]); + [dict enumerateKeysAndEnumsUsingBlock:^(uint32_t aKey, int32_t aValue, BOOL *stop) { #pragma unused(aKey, aValue, stop) XCTFail(@"Shouldn't get here!"); }]; @@ -2602,15 +2602,15 @@ static BOOL TestingEnum_IsValidValue(int32_t value) { } - (void)testOne { - GPBUInt32EnumDictionary *dict = [GPBUInt32EnumDictionary dictionaryWithValue:700 forKey:1U]; + GPBUInt32EnumDictionary *dict = [GPBUInt32EnumDictionary dictionaryWithEnum:700 forKey:1U]; XCTAssertNotNil(dict); XCTAssertEqual(dict.count, 1U); int32_t value; - XCTAssertTrue([dict valueForKey:1U value:NULL]); - XCTAssertTrue([dict valueForKey:1U value:&value]); + XCTAssertTrue([dict getEnum:NULL forKey:1U]); + XCTAssertTrue([dict getEnum:&value forKey:1U]); XCTAssertEqual(value, 700); - XCTAssertFalse([dict valueForKey:2U value:NULL]); - [dict enumerateKeysAndValuesUsingBlock:^(uint32_t aKey, int32_t aValue, BOOL *stop) { + XCTAssertFalse([dict getEnum:NULL forKey:2U]); + [dict enumerateKeysAndEnumsUsingBlock:^(uint32_t aKey, int32_t aValue, BOOL *stop) { XCTAssertEqual(aKey, 1U); XCTAssertEqual(aValue, 700); XCTAssertNotEqual(stop, NULL); @@ -2621,27 +2621,27 @@ static BOOL TestingEnum_IsValidValue(int32_t value) { const uint32_t kKeys[] = { 1U, 2U, 3U }; const int32_t kValues[] = { 700, 701, 702 }; GPBUInt32EnumDictionary *dict = - [[GPBUInt32EnumDictionary alloc] initWithValues:kValues - forKeys:kKeys - count:GPBARRAYSIZE(kValues)]; + [[GPBUInt32EnumDictionary alloc] initWithEnums:kValues + forKeys:kKeys + count:GPBARRAYSIZE(kValues)]; XCTAssertNotNil(dict); XCTAssertEqual(dict.count, 3U); int32_t value; - XCTAssertTrue([dict valueForKey:1U value:NULL]); - XCTAssertTrue([dict valueForKey:1U value:&value]); + XCTAssertTrue([dict getEnum:NULL forKey:1U]); + XCTAssertTrue([dict getEnum:&value forKey:1U]); XCTAssertEqual(value, 700); - XCTAssertTrue([dict valueForKey:2U value:NULL]); - XCTAssertTrue([dict valueForKey:2U value:&value]); + XCTAssertTrue([dict getEnum:NULL forKey:2U]); + XCTAssertTrue([dict getEnum:&value forKey:2U]); XCTAssertEqual(value, 701); - XCTAssertTrue([dict valueForKey:3U value:NULL]); - XCTAssertTrue([dict valueForKey:3U value:&value]); + XCTAssertTrue([dict getEnum:NULL forKey:3U]); + XCTAssertTrue([dict getEnum:&value forKey:3U]); XCTAssertEqual(value, 702); - XCTAssertFalse([dict valueForKey:4U value:NULL]); + XCTAssertFalse([dict getEnum:NULL forKey:4U]); __block NSUInteger idx = 0; uint32_t *seenKeys = malloc(3 * sizeof(uint32_t)); int32_t *seenValues = malloc(3 * sizeof(int32_t)); - [dict enumerateKeysAndValuesUsingBlock:^(uint32_t aKey, int32_t aValue, BOOL *stop) { + [dict enumerateKeysAndEnumsUsingBlock:^(uint32_t aKey, int32_t aValue, BOOL *stop) { XCTAssertLessThan(idx, 3U); seenKeys[idx] = aKey; seenValues[idx] = aValue; @@ -2663,7 +2663,7 @@ static BOOL TestingEnum_IsValidValue(int32_t value) { // Stopping the enumeration. idx = 0; - [dict enumerateKeysAndValuesUsingBlock:^(uint32_t aKey, int32_t aValue, BOOL *stop) { + [dict enumerateKeysAndEnumsUsingBlock:^(uint32_t aKey, int32_t aValue, BOOL *stop) { #pragma unused(aKey, aValue) if (idx == 1) *stop = YES; XCTAssertNotEqual(idx, 2U); @@ -2679,29 +2679,29 @@ static BOOL TestingEnum_IsValidValue(int32_t value) { const int32_t kValues2[] = { 700, 703, 702 }; const int32_t kValues3[] = { 700, 701, 702, 703 }; GPBUInt32EnumDictionary *dict1 = - [[GPBUInt32EnumDictionary alloc] initWithValues:kValues1 - forKeys:kKeys1 - count:GPBARRAYSIZE(kValues1)]; + [[GPBUInt32EnumDictionary alloc] initWithEnums:kValues1 + forKeys:kKeys1 + count:GPBARRAYSIZE(kValues1)]; XCTAssertNotNil(dict1); GPBUInt32EnumDictionary *dict1prime = - [[GPBUInt32EnumDictionary alloc] initWithValues:kValues1 - forKeys:kKeys1 - count:GPBARRAYSIZE(kValues1)]; + [[GPBUInt32EnumDictionary alloc] initWithEnums:kValues1 + forKeys:kKeys1 + count:GPBARRAYSIZE(kValues1)]; XCTAssertNotNil(dict1prime); GPBUInt32EnumDictionary *dict2 = - [[GPBUInt32EnumDictionary alloc] initWithValues:kValues2 - forKeys:kKeys1 - count:GPBARRAYSIZE(kValues2)]; + [[GPBUInt32EnumDictionary alloc] initWithEnums:kValues2 + forKeys:kKeys1 + count:GPBARRAYSIZE(kValues2)]; XCTAssertNotNil(dict2); GPBUInt32EnumDictionary *dict3 = - [[GPBUInt32EnumDictionary alloc] initWithValues:kValues1 - forKeys:kKeys2 - count:GPBARRAYSIZE(kValues1)]; + [[GPBUInt32EnumDictionary alloc] initWithEnums:kValues1 + forKeys:kKeys2 + count:GPBARRAYSIZE(kValues1)]; XCTAssertNotNil(dict3); GPBUInt32EnumDictionary *dict4 = - [[GPBUInt32EnumDictionary alloc] initWithValues:kValues3 - forKeys:kKeys1 - count:GPBARRAYSIZE(kValues3)]; + [[GPBUInt32EnumDictionary alloc] initWithEnums:kValues3 + forKeys:kKeys1 + count:GPBARRAYSIZE(kValues3)]; XCTAssertNotNil(dict4); // 1/1Prime should be different objects, but equal. @@ -2730,9 +2730,9 @@ static BOOL TestingEnum_IsValidValue(int32_t value) { const uint32_t kKeys[] = { 1U, 2U, 3U, 4U }; const int32_t kValues[] = { 700, 701, 702, 703 }; GPBUInt32EnumDictionary *dict = - [[GPBUInt32EnumDictionary alloc] initWithValues:kValues - forKeys:kKeys - count:GPBARRAYSIZE(kValues)]; + [[GPBUInt32EnumDictionary alloc] initWithEnums:kValues + forKeys:kKeys + count:GPBARRAYSIZE(kValues)]; XCTAssertNotNil(dict); GPBUInt32EnumDictionary *dict2 = [dict copy]; @@ -2751,9 +2751,9 @@ static BOOL TestingEnum_IsValidValue(int32_t value) { const uint32_t kKeys[] = { 1U, 2U, 3U, 4U }; const int32_t kValues[] = { 700, 701, 702, 703 }; GPBUInt32EnumDictionary *dict = - [[GPBUInt32EnumDictionary alloc] initWithValues:kValues - forKeys:kKeys - count:GPBARRAYSIZE(kValues)]; + [[GPBUInt32EnumDictionary alloc] initWithEnums:kValues + forKeys:kKeys + count:GPBARRAYSIZE(kValues)]; XCTAssertNotNil(dict); GPBUInt32EnumDictionary *dict2 = @@ -2771,31 +2771,31 @@ static BOOL TestingEnum_IsValidValue(int32_t value) { XCTAssertNotNil(dict); XCTAssertEqual(dict.count, 0U); - [dict setValue:700 forKey:1U]; + [dict setEnum:700 forKey:1U]; XCTAssertEqual(dict.count, 1U); const uint32_t kKeys[] = { 2U, 3U, 4U }; const int32_t kValues[] = { 701, 702, 703 }; GPBUInt32EnumDictionary *dict2 = - [[GPBUInt32EnumDictionary alloc] initWithValues:kValues - forKeys:kKeys - count:GPBARRAYSIZE(kValues)]; + [[GPBUInt32EnumDictionary alloc] initWithEnums:kValues + forKeys:kKeys + count:GPBARRAYSIZE(kValues)]; XCTAssertNotNil(dict2); [dict addRawEntriesFromDictionary:dict2]; XCTAssertEqual(dict.count, 4U); int32_t value; - XCTAssertTrue([dict valueForKey:1U value:NULL]); - XCTAssertTrue([dict valueForKey:1U value:&value]); + XCTAssertTrue([dict getEnum:NULL forKey:1U]); + XCTAssertTrue([dict getEnum:&value forKey:1U]); XCTAssertEqual(value, 700); - XCTAssertTrue([dict valueForKey:2U value:NULL]); - XCTAssertTrue([dict valueForKey:2U value:&value]); + XCTAssertTrue([dict getEnum:NULL forKey:2U]); + XCTAssertTrue([dict getEnum:&value forKey:2U]); XCTAssertEqual(value, 701); - XCTAssertTrue([dict valueForKey:3U value:NULL]); - XCTAssertTrue([dict valueForKey:3U value:&value]); + XCTAssertTrue([dict getEnum:NULL forKey:3U]); + XCTAssertTrue([dict getEnum:&value forKey:3U]); XCTAssertEqual(value, 702); - XCTAssertTrue([dict valueForKey:4U value:NULL]); - XCTAssertTrue([dict valueForKey:4U value:&value]); + XCTAssertTrue([dict getEnum:NULL forKey:4U]); + XCTAssertTrue([dict getEnum:&value forKey:4U]); XCTAssertEqual(value, 703); [dict2 release]; } @@ -2804,57 +2804,57 @@ static BOOL TestingEnum_IsValidValue(int32_t value) { const uint32_t kKeys[] = { 1U, 2U, 3U, 4U }; const int32_t kValues[] = { 700, 701, 702, 703 }; GPBUInt32EnumDictionary *dict = - [[GPBUInt32EnumDictionary alloc] initWithValues:kValues - forKeys:kKeys - count:GPBARRAYSIZE(kValues)]; + [[GPBUInt32EnumDictionary alloc] initWithEnums:kValues + forKeys:kKeys + count:GPBARRAYSIZE(kValues)]; XCTAssertNotNil(dict); XCTAssertEqual(dict.count, 4U); - [dict removeValueForKey:2U]; + [dict removeEnumForKey:2U]; XCTAssertEqual(dict.count, 3U); int32_t value; - XCTAssertTrue([dict valueForKey:1U value:NULL]); - XCTAssertTrue([dict valueForKey:1U value:&value]); + XCTAssertTrue([dict getEnum:NULL forKey:1U]); + XCTAssertTrue([dict getEnum:&value forKey:1U]); XCTAssertEqual(value, 700); - XCTAssertFalse([dict valueForKey:2U value:NULL]); - XCTAssertTrue([dict valueForKey:3U value:NULL]); - XCTAssertTrue([dict valueForKey:3U value:&value]); + XCTAssertFalse([dict getEnum:NULL forKey:2U]); + XCTAssertTrue([dict getEnum:NULL forKey:3U]); + XCTAssertTrue([dict getEnum:&value forKey:3U]); XCTAssertEqual(value, 702); - XCTAssertTrue([dict valueForKey:4U value:NULL]); - XCTAssertTrue([dict valueForKey:4U value:&value]); + XCTAssertTrue([dict getEnum:NULL forKey:4U]); + XCTAssertTrue([dict getEnum:&value forKey:4U]); XCTAssertEqual(value, 703); // Remove again does nothing. - [dict removeValueForKey:2U]; + [dict removeEnumForKey:2U]; XCTAssertEqual(dict.count, 3U); - XCTAssertTrue([dict valueForKey:1U value:NULL]); - XCTAssertTrue([dict valueForKey:1U value:&value]); + XCTAssertTrue([dict getEnum:NULL forKey:1U]); + XCTAssertTrue([dict getEnum:&value forKey:1U]); XCTAssertEqual(value, 700); - XCTAssertFalse([dict valueForKey:2U value:NULL]); - XCTAssertTrue([dict valueForKey:3U value:NULL]); - XCTAssertTrue([dict valueForKey:3U value:&value]); + XCTAssertFalse([dict getEnum:NULL forKey:2U]); + XCTAssertTrue([dict getEnum:NULL forKey:3U]); + XCTAssertTrue([dict getEnum:&value forKey:3U]); XCTAssertEqual(value, 702); - XCTAssertTrue([dict valueForKey:4U value:NULL]); - XCTAssertTrue([dict valueForKey:4U value:&value]); + XCTAssertTrue([dict getEnum:NULL forKey:4U]); + XCTAssertTrue([dict getEnum:&value forKey:4U]); XCTAssertEqual(value, 703); - [dict removeValueForKey:4U]; + [dict removeEnumForKey:4U]; XCTAssertEqual(dict.count, 2U); - XCTAssertTrue([dict valueForKey:1U value:NULL]); - XCTAssertTrue([dict valueForKey:1U value:&value]); + XCTAssertTrue([dict getEnum:NULL forKey:1U]); + XCTAssertTrue([dict getEnum:&value forKey:1U]); XCTAssertEqual(value, 700); - XCTAssertFalse([dict valueForKey:2U value:NULL]); - XCTAssertTrue([dict valueForKey:3U value:NULL]); - XCTAssertTrue([dict valueForKey:3U value:&value]); + XCTAssertFalse([dict getEnum:NULL forKey:2U]); + XCTAssertTrue([dict getEnum:NULL forKey:3U]); + XCTAssertTrue([dict getEnum:&value forKey:3U]); XCTAssertEqual(value, 702); - XCTAssertFalse([dict valueForKey:4U value:NULL]); + XCTAssertFalse([dict getEnum:NULL forKey:4U]); [dict removeAll]; XCTAssertEqual(dict.count, 0U); - XCTAssertFalse([dict valueForKey:1U value:NULL]); - XCTAssertFalse([dict valueForKey:2U value:NULL]); - XCTAssertFalse([dict valueForKey:3U value:NULL]); - XCTAssertFalse([dict valueForKey:4U value:NULL]); + XCTAssertFalse([dict getEnum:NULL forKey:1U]); + XCTAssertFalse([dict getEnum:NULL forKey:2U]); + XCTAssertFalse([dict getEnum:NULL forKey:3U]); + XCTAssertFalse([dict getEnum:NULL forKey:4U]); [dict release]; } @@ -2862,75 +2862,75 @@ static BOOL TestingEnum_IsValidValue(int32_t value) { const uint32_t kKeys[] = { 1U, 2U, 3U, 4U }; const int32_t kValues[] = { 700, 701, 702, 703 }; GPBUInt32EnumDictionary *dict = - [[GPBUInt32EnumDictionary alloc] initWithValues:kValues - forKeys:kKeys - count:GPBARRAYSIZE(kValues)]; + [[GPBUInt32EnumDictionary alloc] initWithEnums:kValues + forKeys:kKeys + count:GPBARRAYSIZE(kValues)]; XCTAssertNotNil(dict); XCTAssertEqual(dict.count, 4U); int32_t value; - XCTAssertTrue([dict valueForKey:1U value:NULL]); - XCTAssertTrue([dict valueForKey:1U value:&value]); + XCTAssertTrue([dict getEnum:NULL forKey:1U]); + XCTAssertTrue([dict getEnum:&value forKey:1U]); XCTAssertEqual(value, 700); - XCTAssertTrue([dict valueForKey:2U value:NULL]); - XCTAssertTrue([dict valueForKey:2U value:&value]); + XCTAssertTrue([dict getEnum:NULL forKey:2U]); + XCTAssertTrue([dict getEnum:&value forKey:2U]); XCTAssertEqual(value, 701); - XCTAssertTrue([dict valueForKey:3U value:NULL]); - XCTAssertTrue([dict valueForKey:3U value:&value]); + XCTAssertTrue([dict getEnum:NULL forKey:3U]); + XCTAssertTrue([dict getEnum:&value forKey:3U]); XCTAssertEqual(value, 702); - XCTAssertTrue([dict valueForKey:4U value:NULL]); - XCTAssertTrue([dict valueForKey:4U value:&value]); + XCTAssertTrue([dict getEnum:NULL forKey:4U]); + XCTAssertTrue([dict getEnum:&value forKey:4U]); XCTAssertEqual(value, 703); - [dict setValue:703 forKey:1U]; + [dict setEnum:703 forKey:1U]; XCTAssertEqual(dict.count, 4U); - XCTAssertTrue([dict valueForKey:1U value:NULL]); - XCTAssertTrue([dict valueForKey:1U value:&value]); + XCTAssertTrue([dict getEnum:NULL forKey:1U]); + XCTAssertTrue([dict getEnum:&value forKey:1U]); XCTAssertEqual(value, 703); - XCTAssertTrue([dict valueForKey:2U value:NULL]); - XCTAssertTrue([dict valueForKey:2U value:&value]); + XCTAssertTrue([dict getEnum:NULL forKey:2U]); + XCTAssertTrue([dict getEnum:&value forKey:2U]); XCTAssertEqual(value, 701); - XCTAssertTrue([dict valueForKey:3U value:NULL]); - XCTAssertTrue([dict valueForKey:3U value:&value]); + XCTAssertTrue([dict getEnum:NULL forKey:3U]); + XCTAssertTrue([dict getEnum:&value forKey:3U]); XCTAssertEqual(value, 702); - XCTAssertTrue([dict valueForKey:4U value:NULL]); - XCTAssertTrue([dict valueForKey:4U value:&value]); + XCTAssertTrue([dict getEnum:NULL forKey:4U]); + XCTAssertTrue([dict getEnum:&value forKey:4U]); XCTAssertEqual(value, 703); - [dict setValue:701 forKey:4U]; + [dict setEnum:701 forKey:4U]; XCTAssertEqual(dict.count, 4U); - XCTAssertTrue([dict valueForKey:1U value:NULL]); - XCTAssertTrue([dict valueForKey:1U value:&value]); + XCTAssertTrue([dict getEnum:NULL forKey:1U]); + XCTAssertTrue([dict getEnum:&value forKey:1U]); XCTAssertEqual(value, 703); - XCTAssertTrue([dict valueForKey:2U value:NULL]); - XCTAssertTrue([dict valueForKey:2U value:&value]); + XCTAssertTrue([dict getEnum:NULL forKey:2U]); + XCTAssertTrue([dict getEnum:&value forKey:2U]); XCTAssertEqual(value, 701); - XCTAssertTrue([dict valueForKey:3U value:NULL]); - XCTAssertTrue([dict valueForKey:3U value:&value]); + XCTAssertTrue([dict getEnum:NULL forKey:3U]); + XCTAssertTrue([dict getEnum:&value forKey:3U]); XCTAssertEqual(value, 702); - XCTAssertTrue([dict valueForKey:4U value:NULL]); - XCTAssertTrue([dict valueForKey:4U value:&value]); + XCTAssertTrue([dict getEnum:NULL forKey:4U]); + XCTAssertTrue([dict getEnum:&value forKey:4U]); XCTAssertEqual(value, 701); const uint32_t kKeys2[] = { 2U, 3U }; const int32_t kValues2[] = { 702, 700 }; GPBUInt32EnumDictionary *dict2 = - [[GPBUInt32EnumDictionary alloc] initWithValues:kValues2 - forKeys:kKeys2 - count:GPBARRAYSIZE(kValues2)]; + [[GPBUInt32EnumDictionary alloc] initWithEnums:kValues2 + forKeys:kKeys2 + count:GPBARRAYSIZE(kValues2)]; XCTAssertNotNil(dict2); [dict addRawEntriesFromDictionary:dict2]; XCTAssertEqual(dict.count, 4U); - XCTAssertTrue([dict valueForKey:1U value:NULL]); - XCTAssertTrue([dict valueForKey:1U value:&value]); + XCTAssertTrue([dict getEnum:NULL forKey:1U]); + XCTAssertTrue([dict getEnum:&value forKey:1U]); XCTAssertEqual(value, 703); - XCTAssertTrue([dict valueForKey:2U value:NULL]); - XCTAssertTrue([dict valueForKey:2U value:&value]); + XCTAssertTrue([dict getEnum:NULL forKey:2U]); + XCTAssertTrue([dict getEnum:&value forKey:2U]); XCTAssertEqual(value, 702); - XCTAssertTrue([dict valueForKey:3U value:NULL]); - XCTAssertTrue([dict valueForKey:3U value:&value]); + XCTAssertTrue([dict getEnum:NULL forKey:3U]); + XCTAssertTrue([dict getEnum:&value forKey:3U]); XCTAssertEqual(value, 700); - XCTAssertTrue([dict valueForKey:4U value:NULL]); - XCTAssertTrue([dict valueForKey:4U value:&value]); + XCTAssertTrue([dict getEnum:NULL forKey:4U]); + XCTAssertTrue([dict getEnum:&value forKey:4U]); XCTAssertEqual(value, 701); [dict2 release]; @@ -2958,24 +2958,24 @@ static BOOL TestingEnum_IsValidValue(int32_t value) { XCTAssertEqual(dict.count, 3U); XCTAssertTrue(dict.validationFunc == TestingEnum_IsValidValue); // Pointer comparison int32_t value; - XCTAssertTrue([dict valueForKey:1U rawValue:NULL]); - XCTAssertTrue([dict valueForKey:1U rawValue:&value]); + XCTAssertTrue([dict getRawValue:NULL forKey:1U]); + XCTAssertTrue([dict getRawValue:&value forKey:1U]); XCTAssertEqual(value, 700); - XCTAssertTrue([dict valueForKey:2U value:NULL]); - XCTAssertTrue([dict valueForKey:2U value:&value]); + XCTAssertTrue([dict getEnum:NULL forKey:2U]); + XCTAssertTrue([dict getEnum:&value forKey:2U]); XCTAssertEqual(value, kGPBUnrecognizedEnumeratorValue); - XCTAssertTrue([dict valueForKey:2U rawValue:NULL]); - XCTAssertTrue([dict valueForKey:2U rawValue:&value]); + XCTAssertTrue([dict getRawValue:NULL forKey:2U]); + XCTAssertTrue([dict getRawValue:&value forKey:2U]); XCTAssertEqual(value, 801); - XCTAssertTrue([dict valueForKey:3U rawValue:NULL]); - XCTAssertTrue([dict valueForKey:3U rawValue:&value]); + XCTAssertTrue([dict getRawValue:NULL forKey:3U]); + XCTAssertTrue([dict getRawValue:&value forKey:3U]); XCTAssertEqual(value, 702); - XCTAssertFalse([dict valueForKey:4U rawValue:NULL]); + XCTAssertFalse([dict getRawValue:NULL forKey:4U]); __block NSUInteger idx = 0; uint32_t *seenKeys = malloc(3 * sizeof(uint32_t)); int32_t *seenValues = malloc(3 * sizeof(int32_t)); - [dict enumerateKeysAndValuesUsingBlock:^(uint32_t aKey, int32_t aValue, BOOL *stop) { + [dict enumerateKeysAndEnumsUsingBlock:^(uint32_t aKey, int32_t aValue, BOOL *stop) { XCTAssertLessThan(idx, 3U); seenKeys[idx] = aKey; seenValues[idx] = aValue; @@ -3136,7 +3136,7 @@ static BOOL TestingEnum_IsValidValue(int32_t value) { XCTAssertNotNil(dict); XCTAssertEqual(dict.count, 0U); - XCTAssertThrowsSpecificNamed([dict setValue:801 forKey:2U], // Unknown + XCTAssertThrowsSpecificNamed([dict setEnum:801 forKey:2U], // Unknown NSException, NSInvalidArgumentException); XCTAssertEqual(dict.count, 0U); [dict setRawValue:801 forKey:2U]; // Unknown @@ -3145,31 +3145,31 @@ static BOOL TestingEnum_IsValidValue(int32_t value) { const uint32_t kKeys[] = { 1U, 3U, 4U }; const int32_t kValues[] = { 700, 702, 803 }; // Unknown GPBUInt32EnumDictionary *dict2 = - [[GPBUInt32EnumDictionary alloc] initWithValues:kValues - forKeys:kKeys - count:GPBARRAYSIZE(kValues)]; + [[GPBUInt32EnumDictionary alloc] initWithEnums:kValues + forKeys:kKeys + count:GPBARRAYSIZE(kValues)]; XCTAssertNotNil(dict2); [dict addRawEntriesFromDictionary:dict2]; XCTAssertEqual(dict.count, 4U); int32_t value; - XCTAssertTrue([dict valueForKey:1U value:NULL]); - XCTAssertTrue([dict valueForKey:1U value:&value]); + XCTAssertTrue([dict getEnum:NULL forKey:1U]); + XCTAssertTrue([dict getEnum:&value forKey:1U]); XCTAssertEqual(value, 700); - XCTAssertTrue([dict valueForKey:2U value:NULL]); - XCTAssertTrue([dict valueForKey:2U value:&value]); + XCTAssertTrue([dict getEnum:NULL forKey:2U]); + XCTAssertTrue([dict getEnum:&value forKey:2U]); XCTAssertEqual(value, kGPBUnrecognizedEnumeratorValue); - XCTAssertTrue([dict valueForKey:2U rawValue:NULL]); - XCTAssertTrue([dict valueForKey:2U rawValue:&value]); + XCTAssertTrue([dict getRawValue:NULL forKey:2U]); + XCTAssertTrue([dict getRawValue:&value forKey:2U]); XCTAssertEqual(value, 801); - XCTAssertTrue([dict valueForKey:3U value:NULL]); - XCTAssertTrue([dict valueForKey:3U value:&value]); + XCTAssertTrue([dict getEnum:NULL forKey:3U]); + XCTAssertTrue([dict getEnum:&value forKey:3U]); XCTAssertEqual(value, 702); - XCTAssertTrue([dict valueForKey:4U value:NULL]); - XCTAssertTrue([dict valueForKey:4U value:&value]); + XCTAssertTrue([dict getEnum:NULL forKey:4U]); + XCTAssertTrue([dict getEnum:&value forKey:4U]); XCTAssertEqual(value, kGPBUnrecognizedEnumeratorValue); - XCTAssertTrue([dict valueForKey:4U rawValue:NULL]); - XCTAssertTrue([dict valueForKey:4U rawValue:&value]); + XCTAssertTrue([dict getRawValue:NULL forKey:4U]); + XCTAssertTrue([dict getRawValue:&value forKey:4U]); XCTAssertEqual(value, 803); [dict2 release]; } @@ -3185,51 +3185,51 @@ static BOOL TestingEnum_IsValidValue(int32_t value) { XCTAssertNotNil(dict); XCTAssertEqual(dict.count, 4U); - [dict removeValueForKey:2U]; + [dict removeEnumForKey:2U]; XCTAssertEqual(dict.count, 3U); int32_t value; - XCTAssertTrue([dict valueForKey:1U value:NULL]); - XCTAssertTrue([dict valueForKey:1U value:&value]); + XCTAssertTrue([dict getEnum:NULL forKey:1U]); + XCTAssertTrue([dict getEnum:&value forKey:1U]); XCTAssertEqual(value, 700); - XCTAssertFalse([dict valueForKey:2U value:NULL]); - XCTAssertTrue([dict valueForKey:3U value:NULL]); - XCTAssertTrue([dict valueForKey:3U value:&value]); + XCTAssertFalse([dict getEnum:NULL forKey:2U]); + XCTAssertTrue([dict getEnum:NULL forKey:3U]); + XCTAssertTrue([dict getEnum:&value forKey:3U]); XCTAssertEqual(value, 702); - XCTAssertTrue([dict valueForKey:4U rawValue:NULL]); - XCTAssertTrue([dict valueForKey:4U rawValue:&value]); + XCTAssertTrue([dict getRawValue:NULL forKey:4U]); + XCTAssertTrue([dict getRawValue:&value forKey:4U]); XCTAssertEqual(value, 803); // Remove again does nothing. - [dict removeValueForKey:2U]; + [dict removeEnumForKey:2U]; XCTAssertEqual(dict.count, 3U); - XCTAssertTrue([dict valueForKey:1U value:NULL]); - XCTAssertTrue([dict valueForKey:1U value:&value]); + XCTAssertTrue([dict getEnum:NULL forKey:1U]); + XCTAssertTrue([dict getEnum:&value forKey:1U]); XCTAssertEqual(value, 700); - XCTAssertFalse([dict valueForKey:2U value:NULL]); - XCTAssertTrue([dict valueForKey:3U value:NULL]); - XCTAssertTrue([dict valueForKey:3U value:&value]); + XCTAssertFalse([dict getEnum:NULL forKey:2U]); + XCTAssertTrue([dict getEnum:NULL forKey:3U]); + XCTAssertTrue([dict getEnum:&value forKey:3U]); XCTAssertEqual(value, 702); - XCTAssertTrue([dict valueForKey:4U rawValue:NULL]); - XCTAssertTrue([dict valueForKey:4U rawValue:&value]); + XCTAssertTrue([dict getRawValue:NULL forKey:4U]); + XCTAssertTrue([dict getRawValue:&value forKey:4U]); XCTAssertEqual(value, 803); - [dict removeValueForKey:4U]; + [dict removeEnumForKey:4U]; XCTAssertEqual(dict.count, 2U); - XCTAssertTrue([dict valueForKey:1U value:NULL]); - XCTAssertTrue([dict valueForKey:1U value:&value]); + XCTAssertTrue([dict getEnum:NULL forKey:1U]); + XCTAssertTrue([dict getEnum:&value forKey:1U]); XCTAssertEqual(value, 700); - XCTAssertFalse([dict valueForKey:2U value:NULL]); - XCTAssertTrue([dict valueForKey:3U value:NULL]); - XCTAssertTrue([dict valueForKey:3U value:&value]); + XCTAssertFalse([dict getEnum:NULL forKey:2U]); + XCTAssertTrue([dict getEnum:NULL forKey:3U]); + XCTAssertTrue([dict getEnum:&value forKey:3U]); XCTAssertEqual(value, 702); - XCTAssertFalse([dict valueForKey:4U value:NULL]); + XCTAssertFalse([dict getEnum:NULL forKey:4U]); [dict removeAll]; XCTAssertEqual(dict.count, 0U); - XCTAssertFalse([dict valueForKey:1U value:NULL]); - XCTAssertFalse([dict valueForKey:2U value:NULL]); - XCTAssertFalse([dict valueForKey:3U value:NULL]); - XCTAssertFalse([dict valueForKey:4U value:NULL]); + XCTAssertFalse([dict getEnum:NULL forKey:1U]); + XCTAssertFalse([dict getEnum:NULL forKey:2U]); + XCTAssertFalse([dict getEnum:NULL forKey:3U]); + XCTAssertFalse([dict getEnum:NULL forKey:4U]); [dict release]; } @@ -3244,63 +3244,63 @@ static BOOL TestingEnum_IsValidValue(int32_t value) { XCTAssertNotNil(dict); XCTAssertEqual(dict.count, 4U); int32_t value; - XCTAssertTrue([dict valueForKey:1U value:NULL]); - XCTAssertTrue([dict valueForKey:1U value:&value]); + XCTAssertTrue([dict getEnum:NULL forKey:1U]); + XCTAssertTrue([dict getEnum:&value forKey:1U]); XCTAssertEqual(value, 700); - XCTAssertTrue([dict valueForKey:2U rawValue:NULL]); - XCTAssertTrue([dict valueForKey:2U rawValue:&value]); + XCTAssertTrue([dict getRawValue:NULL forKey:2U]); + XCTAssertTrue([dict getRawValue:&value forKey:2U]); XCTAssertEqual(value, 801); - XCTAssertTrue([dict valueForKey:3U value:NULL]); - XCTAssertTrue([dict valueForKey:3U value:&value]); + XCTAssertTrue([dict getEnum:NULL forKey:3U]); + XCTAssertTrue([dict getEnum:&value forKey:3U]); XCTAssertEqual(value, 702); - XCTAssertTrue([dict valueForKey:4U rawValue:NULL]); - XCTAssertTrue([dict valueForKey:4U rawValue:&value]); + XCTAssertTrue([dict getRawValue:NULL forKey:4U]); + XCTAssertTrue([dict getRawValue:&value forKey:4U]); XCTAssertEqual(value, 803); - XCTAssertThrowsSpecificNamed([dict setValue:803 forKey:1U], // Unknown + XCTAssertThrowsSpecificNamed([dict setEnum:803 forKey:1U], // Unknown NSException, NSInvalidArgumentException); XCTAssertEqual(dict.count, 4U); - XCTAssertTrue([dict valueForKey:1U value:NULL]); - XCTAssertTrue([dict valueForKey:1U value:&value]); + XCTAssertTrue([dict getEnum:NULL forKey:1U]); + XCTAssertTrue([dict getEnum:&value forKey:1U]); XCTAssertEqual(value, 700); - XCTAssertTrue([dict valueForKey:2U rawValue:NULL]); - XCTAssertTrue([dict valueForKey:2U rawValue:&value]); + XCTAssertTrue([dict getRawValue:NULL forKey:2U]); + XCTAssertTrue([dict getRawValue:&value forKey:2U]); XCTAssertEqual(value, 801); - XCTAssertTrue([dict valueForKey:3U value:NULL]); - XCTAssertTrue([dict valueForKey:3U value:&value]); + XCTAssertTrue([dict getEnum:NULL forKey:3U]); + XCTAssertTrue([dict getEnum:&value forKey:3U]); XCTAssertEqual(value, 702); - XCTAssertTrue([dict valueForKey:4U rawValue:NULL]); - XCTAssertTrue([dict valueForKey:4U rawValue:&value]); + XCTAssertTrue([dict getRawValue:NULL forKey:4U]); + XCTAssertTrue([dict getRawValue:&value forKey:4U]); XCTAssertEqual(value, 803); [dict setRawValue:803 forKey:1U]; // Unknown XCTAssertEqual(dict.count, 4U); - XCTAssertTrue([dict valueForKey:1U rawValue:NULL]); - XCTAssertTrue([dict valueForKey:1U rawValue:&value]); + XCTAssertTrue([dict getRawValue:NULL forKey:1U]); + XCTAssertTrue([dict getRawValue:&value forKey:1U]); XCTAssertEqual(value, 803); - XCTAssertTrue([dict valueForKey:2U rawValue:NULL]); - XCTAssertTrue([dict valueForKey:2U rawValue:&value]); + XCTAssertTrue([dict getRawValue:NULL forKey:2U]); + XCTAssertTrue([dict getRawValue:&value forKey:2U]); XCTAssertEqual(value, 801); - XCTAssertTrue([dict valueForKey:3U value:NULL]); - XCTAssertTrue([dict valueForKey:3U value:&value]); + XCTAssertTrue([dict getEnum:NULL forKey:3U]); + XCTAssertTrue([dict getEnum:&value forKey:3U]); XCTAssertEqual(value, 702); - XCTAssertTrue([dict valueForKey:4U rawValue:NULL]); - XCTAssertTrue([dict valueForKey:4U rawValue:&value]); + XCTAssertTrue([dict getRawValue:NULL forKey:4U]); + XCTAssertTrue([dict getRawValue:&value forKey:4U]); XCTAssertEqual(value, 803); [dict setRawValue:700 forKey:4U]; XCTAssertEqual(dict.count, 4U); - XCTAssertTrue([dict valueForKey:1U rawValue:NULL]); - XCTAssertTrue([dict valueForKey:1U rawValue:&value]); + XCTAssertTrue([dict getRawValue:NULL forKey:1U]); + XCTAssertTrue([dict getRawValue:&value forKey:1U]); XCTAssertEqual(value, 803); - XCTAssertTrue([dict valueForKey:2U rawValue:NULL]); - XCTAssertTrue([dict valueForKey:2U rawValue:&value]); + XCTAssertTrue([dict getRawValue:NULL forKey:2U]); + XCTAssertTrue([dict getRawValue:&value forKey:2U]); XCTAssertEqual(value, 801); - XCTAssertTrue([dict valueForKey:3U value:NULL]); - XCTAssertTrue([dict valueForKey:3U value:&value]); + XCTAssertTrue([dict getEnum:NULL forKey:3U]); + XCTAssertTrue([dict getEnum:&value forKey:3U]); XCTAssertEqual(value, 702); - XCTAssertTrue([dict valueForKey:4U value:NULL]); - XCTAssertTrue([dict valueForKey:4U value:&value]); + XCTAssertTrue([dict getEnum:NULL forKey:4U]); + XCTAssertTrue([dict getEnum:&value forKey:4U]); XCTAssertEqual(value, 700); const uint32_t kKeys2[] = { 2U, 3U }; @@ -3313,17 +3313,17 @@ static BOOL TestingEnum_IsValidValue(int32_t value) { XCTAssertNotNil(dict2); [dict addRawEntriesFromDictionary:dict2]; XCTAssertEqual(dict.count, 4U); - XCTAssertTrue([dict valueForKey:1U rawValue:NULL]); - XCTAssertTrue([dict valueForKey:1U rawValue:&value]); + XCTAssertTrue([dict getRawValue:NULL forKey:1U]); + XCTAssertTrue([dict getRawValue:&value forKey:1U]); XCTAssertEqual(value, 803); - XCTAssertTrue([dict valueForKey:2U value:NULL]); - XCTAssertTrue([dict valueForKey:2U value:&value]); + XCTAssertTrue([dict getEnum:NULL forKey:2U]); + XCTAssertTrue([dict getEnum:&value forKey:2U]); XCTAssertEqual(value, 702); - XCTAssertTrue([dict valueForKey:3U rawValue:NULL]); - XCTAssertTrue([dict valueForKey:3U rawValue:&value]); + XCTAssertTrue([dict getRawValue:NULL forKey:3U]); + XCTAssertTrue([dict getRawValue:&value forKey:3U]); XCTAssertEqual(value, 801); - XCTAssertTrue([dict valueForKey:4U value:NULL]); - XCTAssertTrue([dict valueForKey:4U value:&value]); + XCTAssertTrue([dict getEnum:NULL forKey:4U]); + XCTAssertTrue([dict getEnum:&value forKey:4U]); XCTAssertEqual(value, 700); [dict2 release]; @@ -3559,8 +3559,8 @@ static BOOL TestingEnum_IsValidValue(int32_t value) { const NSString* kObjects[] = { @"abc", @"def", @"ghi", @"jkl" }; GPBUInt32ObjectDictionary *dict = [[GPBUInt32ObjectDictionary alloc] initWithObjects:kObjects - forKeys:kKeys - count:GPBARRAYSIZE(kObjects)]; + forKeys:kKeys + count:GPBARRAYSIZE(kObjects)]; XCTAssertNotNil(dict); XCTAssertEqual(dict.count, 4U); @@ -3600,8 +3600,8 @@ static BOOL TestingEnum_IsValidValue(int32_t value) { const NSString* kObjects[] = { @"abc", @"def", @"ghi", @"jkl" }; GPBUInt32ObjectDictionary *dict = [[GPBUInt32ObjectDictionary alloc] initWithObjects:kObjects - forKeys:kKeys - count:GPBARRAYSIZE(kObjects)]; + forKeys:kKeys + count:GPBARRAYSIZE(kObjects)]; XCTAssertNotNil(dict); XCTAssertEqual(dict.count, 4U); XCTAssertEqualObjects([dict objectForKey:1U], @"abc"); diff --git a/objectivec/Tests/GPBDictionaryTests+UInt64.m b/objectivec/Tests/GPBDictionaryTests+UInt64.m index 327e1548..94c116f6 100644 --- a/objectivec/Tests/GPBDictionaryTests+UInt64.m +++ b/objectivec/Tests/GPBDictionaryTests+UInt64.m @@ -45,10 +45,10 @@ // To let the testing macros work, add some extra methods to simplify things. @interface GPBUInt64EnumDictionary (TestingTweak) -+ (instancetype)dictionaryWithValue:(int32_t)value forKey:(uint64_t)key; -- (instancetype)initWithValues:(const int32_t [])values - forKeys:(const uint64_t [])keys - count:(NSUInteger)count; ++ (instancetype)dictionaryWithEnum:(int32_t)value forKey:(uint64_t)key; +- (instancetype)initWithEnums:(const int32_t [])values + forKeys:(const uint64_t [])keys + count:(NSUInteger)count; @end static BOOL TestingEnum_IsValidValue(int32_t value) { @@ -64,7 +64,7 @@ static BOOL TestingEnum_IsValidValue(int32_t value) { } @implementation GPBUInt64EnumDictionary (TestingTweak) -+ (instancetype)dictionaryWithValue:(int32_t)value forKey:(uint64_t)key { ++ (instancetype)dictionaryWithEnum:(int32_t)value forKey:(uint64_t)key { // Cast is needed to compiler knows what class we are invoking initWithValues: on to get the // type correct. return [[(GPBUInt64EnumDictionary*)[self alloc] initWithValidationFunction:TestingEnum_IsValidValue @@ -72,9 +72,9 @@ static BOOL TestingEnum_IsValidValue(int32_t value) { forKeys:&key count:1] autorelease]; } -- (instancetype)initWithValues:(const int32_t [])values - forKeys:(const uint64_t [])keys - count:(NSUInteger)count { +- (instancetype)initWithEnums:(const int32_t [])values + forKeys:(const uint64_t [])keys + count:(NSUInteger)count { return [self initWithValidationFunction:TestingEnum_IsValidValue rawValues:values forKeys:keys @@ -94,8 +94,8 @@ static BOOL TestingEnum_IsValidValue(int32_t value) { GPBUInt64UInt32Dictionary *dict = [[GPBUInt64UInt32Dictionary alloc] init]; XCTAssertNotNil(dict); XCTAssertEqual(dict.count, 0U); - XCTAssertFalse([dict valueForKey:31ULL value:NULL]); - [dict enumerateKeysAndValuesUsingBlock:^(uint64_t aKey, uint32_t aValue, BOOL *stop) { + XCTAssertFalse([dict getUInt32:NULL forKey:31ULL]); + [dict enumerateKeysAndUInt32sUsingBlock:^(uint64_t aKey, uint32_t aValue, BOOL *stop) { #pragma unused(aKey, aValue, stop) XCTFail(@"Shouldn't get here!"); }]; @@ -103,15 +103,15 @@ static BOOL TestingEnum_IsValidValue(int32_t value) { } - (void)testOne { - GPBUInt64UInt32Dictionary *dict = [GPBUInt64UInt32Dictionary dictionaryWithValue:100U forKey:31ULL]; + GPBUInt64UInt32Dictionary *dict = [GPBUInt64UInt32Dictionary dictionaryWithUInt32:100U forKey:31ULL]; XCTAssertNotNil(dict); XCTAssertEqual(dict.count, 1U); uint32_t value; - XCTAssertTrue([dict valueForKey:31ULL value:NULL]); - XCTAssertTrue([dict valueForKey:31ULL value:&value]); + XCTAssertTrue([dict getUInt32:NULL forKey:31ULL]); + XCTAssertTrue([dict getUInt32:&value forKey:31ULL]); XCTAssertEqual(value, 100U); - XCTAssertFalse([dict valueForKey:32ULL value:NULL]); - [dict enumerateKeysAndValuesUsingBlock:^(uint64_t aKey, uint32_t aValue, BOOL *stop) { + XCTAssertFalse([dict getUInt32:NULL forKey:32ULL]); + [dict enumerateKeysAndUInt32sUsingBlock:^(uint64_t aKey, uint32_t aValue, BOOL *stop) { XCTAssertEqual(aKey, 31ULL); XCTAssertEqual(aValue, 100U); XCTAssertNotEqual(stop, NULL); @@ -122,27 +122,27 @@ static BOOL TestingEnum_IsValidValue(int32_t value) { const uint64_t kKeys[] = { 31ULL, 32ULL, 33ULL }; const uint32_t kValues[] = { 100U, 101U, 102U }; GPBUInt64UInt32Dictionary *dict = - [[GPBUInt64UInt32Dictionary alloc] initWithValues:kValues - forKeys:kKeys - count:GPBARRAYSIZE(kValues)]; + [[GPBUInt64UInt32Dictionary alloc] initWithUInt32s:kValues + forKeys:kKeys + count:GPBARRAYSIZE(kValues)]; XCTAssertNotNil(dict); XCTAssertEqual(dict.count, 3U); uint32_t value; - XCTAssertTrue([dict valueForKey:31ULL value:NULL]); - XCTAssertTrue([dict valueForKey:31ULL value:&value]); + XCTAssertTrue([dict getUInt32:NULL forKey:31ULL]); + XCTAssertTrue([dict getUInt32:&value forKey:31ULL]); XCTAssertEqual(value, 100U); - XCTAssertTrue([dict valueForKey:32ULL value:NULL]); - XCTAssertTrue([dict valueForKey:32ULL value:&value]); + XCTAssertTrue([dict getUInt32:NULL forKey:32ULL]); + XCTAssertTrue([dict getUInt32:&value forKey:32ULL]); XCTAssertEqual(value, 101U); - XCTAssertTrue([dict valueForKey:33ULL value:NULL]); - XCTAssertTrue([dict valueForKey:33ULL value:&value]); + XCTAssertTrue([dict getUInt32:NULL forKey:33ULL]); + XCTAssertTrue([dict getUInt32:&value forKey:33ULL]); XCTAssertEqual(value, 102U); - XCTAssertFalse([dict valueForKey:34ULL value:NULL]); + XCTAssertFalse([dict getUInt32:NULL forKey:34ULL]); __block NSUInteger idx = 0; uint64_t *seenKeys = malloc(3 * sizeof(uint64_t)); uint32_t *seenValues = malloc(3 * sizeof(uint32_t)); - [dict enumerateKeysAndValuesUsingBlock:^(uint64_t aKey, uint32_t aValue, BOOL *stop) { + [dict enumerateKeysAndUInt32sUsingBlock:^(uint64_t aKey, uint32_t aValue, BOOL *stop) { XCTAssertLessThan(idx, 3U); seenKeys[idx] = aKey; seenValues[idx] = aValue; @@ -164,7 +164,7 @@ static BOOL TestingEnum_IsValidValue(int32_t value) { // Stopping the enumeration. idx = 0; - [dict enumerateKeysAndValuesUsingBlock:^(uint64_t aKey, uint32_t aValue, BOOL *stop) { + [dict enumerateKeysAndUInt32sUsingBlock:^(uint64_t aKey, uint32_t aValue, BOOL *stop) { #pragma unused(aKey, aValue) if (idx == 1) *stop = YES; XCTAssertNotEqual(idx, 2U); @@ -180,29 +180,29 @@ static BOOL TestingEnum_IsValidValue(int32_t value) { const uint32_t kValues2[] = { 100U, 103U, 102U }; const uint32_t kValues3[] = { 100U, 101U, 102U, 103U }; GPBUInt64UInt32Dictionary *dict1 = - [[GPBUInt64UInt32Dictionary alloc] initWithValues:kValues1 - forKeys:kKeys1 - count:GPBARRAYSIZE(kValues1)]; + [[GPBUInt64UInt32Dictionary alloc] initWithUInt32s:kValues1 + forKeys:kKeys1 + count:GPBARRAYSIZE(kValues1)]; XCTAssertNotNil(dict1); GPBUInt64UInt32Dictionary *dict1prime = - [[GPBUInt64UInt32Dictionary alloc] initWithValues:kValues1 - forKeys:kKeys1 - count:GPBARRAYSIZE(kValues1)]; + [[GPBUInt64UInt32Dictionary alloc] initWithUInt32s:kValues1 + forKeys:kKeys1 + count:GPBARRAYSIZE(kValues1)]; XCTAssertNotNil(dict1prime); GPBUInt64UInt32Dictionary *dict2 = - [[GPBUInt64UInt32Dictionary alloc] initWithValues:kValues2 - forKeys:kKeys1 - count:GPBARRAYSIZE(kValues2)]; + [[GPBUInt64UInt32Dictionary alloc] initWithUInt32s:kValues2 + forKeys:kKeys1 + count:GPBARRAYSIZE(kValues2)]; XCTAssertNotNil(dict2); GPBUInt64UInt32Dictionary *dict3 = - [[GPBUInt64UInt32Dictionary alloc] initWithValues:kValues1 - forKeys:kKeys2 - count:GPBARRAYSIZE(kValues1)]; + [[GPBUInt64UInt32Dictionary alloc] initWithUInt32s:kValues1 + forKeys:kKeys2 + count:GPBARRAYSIZE(kValues1)]; XCTAssertNotNil(dict3); GPBUInt64UInt32Dictionary *dict4 = - [[GPBUInt64UInt32Dictionary alloc] initWithValues:kValues3 - forKeys:kKeys1 - count:GPBARRAYSIZE(kValues3)]; + [[GPBUInt64UInt32Dictionary alloc] initWithUInt32s:kValues3 + forKeys:kKeys1 + count:GPBARRAYSIZE(kValues3)]; XCTAssertNotNil(dict4); // 1/1Prime should be different objects, but equal. @@ -231,9 +231,9 @@ static BOOL TestingEnum_IsValidValue(int32_t value) { const uint64_t kKeys[] = { 31ULL, 32ULL, 33ULL, 34ULL }; const uint32_t kValues[] = { 100U, 101U, 102U, 103U }; GPBUInt64UInt32Dictionary *dict = - [[GPBUInt64UInt32Dictionary alloc] initWithValues:kValues - forKeys:kKeys - count:GPBARRAYSIZE(kValues)]; + [[GPBUInt64UInt32Dictionary alloc] initWithUInt32s:kValues + forKeys:kKeys + count:GPBARRAYSIZE(kValues)]; XCTAssertNotNil(dict); GPBUInt64UInt32Dictionary *dict2 = [dict copy]; @@ -252,9 +252,9 @@ static BOOL TestingEnum_IsValidValue(int32_t value) { const uint64_t kKeys[] = { 31ULL, 32ULL, 33ULL, 34ULL }; const uint32_t kValues[] = { 100U, 101U, 102U, 103U }; GPBUInt64UInt32Dictionary *dict = - [[GPBUInt64UInt32Dictionary alloc] initWithValues:kValues - forKeys:kKeys - count:GPBARRAYSIZE(kValues)]; + [[GPBUInt64UInt32Dictionary alloc] initWithUInt32s:kValues + forKeys:kKeys + count:GPBARRAYSIZE(kValues)]; XCTAssertNotNil(dict); GPBUInt64UInt32Dictionary *dict2 = @@ -272,31 +272,31 @@ static BOOL TestingEnum_IsValidValue(int32_t value) { XCTAssertNotNil(dict); XCTAssertEqual(dict.count, 0U); - [dict setValue:100U forKey:31ULL]; + [dict setUInt32:100U forKey:31ULL]; XCTAssertEqual(dict.count, 1U); const uint64_t kKeys[] = { 32ULL, 33ULL, 34ULL }; const uint32_t kValues[] = { 101U, 102U, 103U }; GPBUInt64UInt32Dictionary *dict2 = - [[GPBUInt64UInt32Dictionary alloc] initWithValues:kValues - forKeys:kKeys - count:GPBARRAYSIZE(kValues)]; + [[GPBUInt64UInt32Dictionary alloc] initWithUInt32s:kValues + forKeys:kKeys + count:GPBARRAYSIZE(kValues)]; XCTAssertNotNil(dict2); [dict addEntriesFromDictionary:dict2]; XCTAssertEqual(dict.count, 4U); uint32_t value; - XCTAssertTrue([dict valueForKey:31ULL value:NULL]); - XCTAssertTrue([dict valueForKey:31ULL value:&value]); + XCTAssertTrue([dict getUInt32:NULL forKey:31ULL]); + XCTAssertTrue([dict getUInt32:&value forKey:31ULL]); XCTAssertEqual(value, 100U); - XCTAssertTrue([dict valueForKey:32ULL value:NULL]); - XCTAssertTrue([dict valueForKey:32ULL value:&value]); + XCTAssertTrue([dict getUInt32:NULL forKey:32ULL]); + XCTAssertTrue([dict getUInt32:&value forKey:32ULL]); XCTAssertEqual(value, 101U); - XCTAssertTrue([dict valueForKey:33ULL value:NULL]); - XCTAssertTrue([dict valueForKey:33ULL value:&value]); + XCTAssertTrue([dict getUInt32:NULL forKey:33ULL]); + XCTAssertTrue([dict getUInt32:&value forKey:33ULL]); XCTAssertEqual(value, 102U); - XCTAssertTrue([dict valueForKey:34ULL value:NULL]); - XCTAssertTrue([dict valueForKey:34ULL value:&value]); + XCTAssertTrue([dict getUInt32:NULL forKey:34ULL]); + XCTAssertTrue([dict getUInt32:&value forKey:34ULL]); XCTAssertEqual(value, 103U); [dict2 release]; } @@ -305,57 +305,57 @@ static BOOL TestingEnum_IsValidValue(int32_t value) { const uint64_t kKeys[] = { 31ULL, 32ULL, 33ULL, 34ULL }; const uint32_t kValues[] = { 100U, 101U, 102U, 103U }; GPBUInt64UInt32Dictionary *dict = - [[GPBUInt64UInt32Dictionary alloc] initWithValues:kValues - forKeys:kKeys - count:GPBARRAYSIZE(kValues)]; + [[GPBUInt64UInt32Dictionary alloc] initWithUInt32s:kValues + forKeys:kKeys + count:GPBARRAYSIZE(kValues)]; XCTAssertNotNil(dict); XCTAssertEqual(dict.count, 4U); - [dict removeValueForKey:32ULL]; + [dict removeUInt32ForKey:32ULL]; XCTAssertEqual(dict.count, 3U); uint32_t value; - XCTAssertTrue([dict valueForKey:31ULL value:NULL]); - XCTAssertTrue([dict valueForKey:31ULL value:&value]); + XCTAssertTrue([dict getUInt32:NULL forKey:31ULL]); + XCTAssertTrue([dict getUInt32:&value forKey:31ULL]); XCTAssertEqual(value, 100U); - XCTAssertFalse([dict valueForKey:32ULL value:NULL]); - XCTAssertTrue([dict valueForKey:33ULL value:NULL]); - XCTAssertTrue([dict valueForKey:33ULL value:&value]); + XCTAssertFalse([dict getUInt32:NULL forKey:32ULL]); + XCTAssertTrue([dict getUInt32:NULL forKey:33ULL]); + XCTAssertTrue([dict getUInt32:&value forKey:33ULL]); XCTAssertEqual(value, 102U); - XCTAssertTrue([dict valueForKey:34ULL value:NULL]); - XCTAssertTrue([dict valueForKey:34ULL value:&value]); + XCTAssertTrue([dict getUInt32:NULL forKey:34ULL]); + XCTAssertTrue([dict getUInt32:&value forKey:34ULL]); XCTAssertEqual(value, 103U); // Remove again does nothing. - [dict removeValueForKey:32ULL]; + [dict removeUInt32ForKey:32ULL]; XCTAssertEqual(dict.count, 3U); - XCTAssertTrue([dict valueForKey:31ULL value:NULL]); - XCTAssertTrue([dict valueForKey:31ULL value:&value]); + XCTAssertTrue([dict getUInt32:NULL forKey:31ULL]); + XCTAssertTrue([dict getUInt32:&value forKey:31ULL]); XCTAssertEqual(value, 100U); - XCTAssertFalse([dict valueForKey:32ULL value:NULL]); - XCTAssertTrue([dict valueForKey:33ULL value:NULL]); - XCTAssertTrue([dict valueForKey:33ULL value:&value]); + XCTAssertFalse([dict getUInt32:NULL forKey:32ULL]); + XCTAssertTrue([dict getUInt32:NULL forKey:33ULL]); + XCTAssertTrue([dict getUInt32:&value forKey:33ULL]); XCTAssertEqual(value, 102U); - XCTAssertTrue([dict valueForKey:34ULL value:NULL]); - XCTAssertTrue([dict valueForKey:34ULL value:&value]); + XCTAssertTrue([dict getUInt32:NULL forKey:34ULL]); + XCTAssertTrue([dict getUInt32:&value forKey:34ULL]); XCTAssertEqual(value, 103U); - [dict removeValueForKey:34ULL]; + [dict removeUInt32ForKey:34ULL]; XCTAssertEqual(dict.count, 2U); - XCTAssertTrue([dict valueForKey:31ULL value:NULL]); - XCTAssertTrue([dict valueForKey:31ULL value:&value]); + XCTAssertTrue([dict getUInt32:NULL forKey:31ULL]); + XCTAssertTrue([dict getUInt32:&value forKey:31ULL]); XCTAssertEqual(value, 100U); - XCTAssertFalse([dict valueForKey:32ULL value:NULL]); - XCTAssertTrue([dict valueForKey:33ULL value:NULL]); - XCTAssertTrue([dict valueForKey:33ULL value:&value]); + XCTAssertFalse([dict getUInt32:NULL forKey:32ULL]); + XCTAssertTrue([dict getUInt32:NULL forKey:33ULL]); + XCTAssertTrue([dict getUInt32:&value forKey:33ULL]); XCTAssertEqual(value, 102U); - XCTAssertFalse([dict valueForKey:34ULL value:NULL]); + XCTAssertFalse([dict getUInt32:NULL forKey:34ULL]); [dict removeAll]; XCTAssertEqual(dict.count, 0U); - XCTAssertFalse([dict valueForKey:31ULL value:NULL]); - XCTAssertFalse([dict valueForKey:32ULL value:NULL]); - XCTAssertFalse([dict valueForKey:33ULL value:NULL]); - XCTAssertFalse([dict valueForKey:34ULL value:NULL]); + XCTAssertFalse([dict getUInt32:NULL forKey:31ULL]); + XCTAssertFalse([dict getUInt32:NULL forKey:32ULL]); + XCTAssertFalse([dict getUInt32:NULL forKey:33ULL]); + XCTAssertFalse([dict getUInt32:NULL forKey:34ULL]); [dict release]; } @@ -363,75 +363,75 @@ static BOOL TestingEnum_IsValidValue(int32_t value) { const uint64_t kKeys[] = { 31ULL, 32ULL, 33ULL, 34ULL }; const uint32_t kValues[] = { 100U, 101U, 102U, 103U }; GPBUInt64UInt32Dictionary *dict = - [[GPBUInt64UInt32Dictionary alloc] initWithValues:kValues - forKeys:kKeys - count:GPBARRAYSIZE(kValues)]; + [[GPBUInt64UInt32Dictionary alloc] initWithUInt32s:kValues + forKeys:kKeys + count:GPBARRAYSIZE(kValues)]; XCTAssertNotNil(dict); XCTAssertEqual(dict.count, 4U); uint32_t value; - XCTAssertTrue([dict valueForKey:31ULL value:NULL]); - XCTAssertTrue([dict valueForKey:31ULL value:&value]); + XCTAssertTrue([dict getUInt32:NULL forKey:31ULL]); + XCTAssertTrue([dict getUInt32:&value forKey:31ULL]); XCTAssertEqual(value, 100U); - XCTAssertTrue([dict valueForKey:32ULL value:NULL]); - XCTAssertTrue([dict valueForKey:32ULL value:&value]); + XCTAssertTrue([dict getUInt32:NULL forKey:32ULL]); + XCTAssertTrue([dict getUInt32:&value forKey:32ULL]); XCTAssertEqual(value, 101U); - XCTAssertTrue([dict valueForKey:33ULL value:NULL]); - XCTAssertTrue([dict valueForKey:33ULL value:&value]); + XCTAssertTrue([dict getUInt32:NULL forKey:33ULL]); + XCTAssertTrue([dict getUInt32:&value forKey:33ULL]); XCTAssertEqual(value, 102U); - XCTAssertTrue([dict valueForKey:34ULL value:NULL]); - XCTAssertTrue([dict valueForKey:34ULL value:&value]); + XCTAssertTrue([dict getUInt32:NULL forKey:34ULL]); + XCTAssertTrue([dict getUInt32:&value forKey:34ULL]); XCTAssertEqual(value, 103U); - [dict setValue:103U forKey:31ULL]; + [dict setUInt32:103U forKey:31ULL]; XCTAssertEqual(dict.count, 4U); - XCTAssertTrue([dict valueForKey:31ULL value:NULL]); - XCTAssertTrue([dict valueForKey:31ULL value:&value]); + XCTAssertTrue([dict getUInt32:NULL forKey:31ULL]); + XCTAssertTrue([dict getUInt32:&value forKey:31ULL]); XCTAssertEqual(value, 103U); - XCTAssertTrue([dict valueForKey:32ULL value:NULL]); - XCTAssertTrue([dict valueForKey:32ULL value:&value]); + XCTAssertTrue([dict getUInt32:NULL forKey:32ULL]); + XCTAssertTrue([dict getUInt32:&value forKey:32ULL]); XCTAssertEqual(value, 101U); - XCTAssertTrue([dict valueForKey:33ULL value:NULL]); - XCTAssertTrue([dict valueForKey:33ULL value:&value]); + XCTAssertTrue([dict getUInt32:NULL forKey:33ULL]); + XCTAssertTrue([dict getUInt32:&value forKey:33ULL]); XCTAssertEqual(value, 102U); - XCTAssertTrue([dict valueForKey:34ULL value:NULL]); - XCTAssertTrue([dict valueForKey:34ULL value:&value]); + XCTAssertTrue([dict getUInt32:NULL forKey:34ULL]); + XCTAssertTrue([dict getUInt32:&value forKey:34ULL]); XCTAssertEqual(value, 103U); - [dict setValue:101U forKey:34ULL]; + [dict setUInt32:101U forKey:34ULL]; XCTAssertEqual(dict.count, 4U); - XCTAssertTrue([dict valueForKey:31ULL value:NULL]); - XCTAssertTrue([dict valueForKey:31ULL value:&value]); + XCTAssertTrue([dict getUInt32:NULL forKey:31ULL]); + XCTAssertTrue([dict getUInt32:&value forKey:31ULL]); XCTAssertEqual(value, 103U); - XCTAssertTrue([dict valueForKey:32ULL value:NULL]); - XCTAssertTrue([dict valueForKey:32ULL value:&value]); + XCTAssertTrue([dict getUInt32:NULL forKey:32ULL]); + XCTAssertTrue([dict getUInt32:&value forKey:32ULL]); XCTAssertEqual(value, 101U); - XCTAssertTrue([dict valueForKey:33ULL value:NULL]); - XCTAssertTrue([dict valueForKey:33ULL value:&value]); + XCTAssertTrue([dict getUInt32:NULL forKey:33ULL]); + XCTAssertTrue([dict getUInt32:&value forKey:33ULL]); XCTAssertEqual(value, 102U); - XCTAssertTrue([dict valueForKey:34ULL value:NULL]); - XCTAssertTrue([dict valueForKey:34ULL value:&value]); + XCTAssertTrue([dict getUInt32:NULL forKey:34ULL]); + XCTAssertTrue([dict getUInt32:&value forKey:34ULL]); XCTAssertEqual(value, 101U); const uint64_t kKeys2[] = { 32ULL, 33ULL }; const uint32_t kValues2[] = { 102U, 100U }; GPBUInt64UInt32Dictionary *dict2 = - [[GPBUInt64UInt32Dictionary alloc] initWithValues:kValues2 - forKeys:kKeys2 - count:GPBARRAYSIZE(kValues2)]; + [[GPBUInt64UInt32Dictionary alloc] initWithUInt32s:kValues2 + forKeys:kKeys2 + count:GPBARRAYSIZE(kValues2)]; XCTAssertNotNil(dict2); [dict addEntriesFromDictionary:dict2]; XCTAssertEqual(dict.count, 4U); - XCTAssertTrue([dict valueForKey:31ULL value:NULL]); - XCTAssertTrue([dict valueForKey:31ULL value:&value]); + XCTAssertTrue([dict getUInt32:NULL forKey:31ULL]); + XCTAssertTrue([dict getUInt32:&value forKey:31ULL]); XCTAssertEqual(value, 103U); - XCTAssertTrue([dict valueForKey:32ULL value:NULL]); - XCTAssertTrue([dict valueForKey:32ULL value:&value]); + XCTAssertTrue([dict getUInt32:NULL forKey:32ULL]); + XCTAssertTrue([dict getUInt32:&value forKey:32ULL]); XCTAssertEqual(value, 102U); - XCTAssertTrue([dict valueForKey:33ULL value:NULL]); - XCTAssertTrue([dict valueForKey:33ULL value:&value]); + XCTAssertTrue([dict getUInt32:NULL forKey:33ULL]); + XCTAssertTrue([dict getUInt32:&value forKey:33ULL]); XCTAssertEqual(value, 100U); - XCTAssertTrue([dict valueForKey:34ULL value:NULL]); - XCTAssertTrue([dict valueForKey:34ULL value:&value]); + XCTAssertTrue([dict getUInt32:NULL forKey:34ULL]); + XCTAssertTrue([dict getUInt32:&value forKey:34ULL]); XCTAssertEqual(value, 101U); [dict2 release]; @@ -451,8 +451,8 @@ static BOOL TestingEnum_IsValidValue(int32_t value) { GPBUInt64Int32Dictionary *dict = [[GPBUInt64Int32Dictionary alloc] init]; XCTAssertNotNil(dict); XCTAssertEqual(dict.count, 0U); - XCTAssertFalse([dict valueForKey:31ULL value:NULL]); - [dict enumerateKeysAndValuesUsingBlock:^(uint64_t aKey, int32_t aValue, BOOL *stop) { + XCTAssertFalse([dict getInt32:NULL forKey:31ULL]); + [dict enumerateKeysAndInt32sUsingBlock:^(uint64_t aKey, int32_t aValue, BOOL *stop) { #pragma unused(aKey, aValue, stop) XCTFail(@"Shouldn't get here!"); }]; @@ -460,15 +460,15 @@ static BOOL TestingEnum_IsValidValue(int32_t value) { } - (void)testOne { - GPBUInt64Int32Dictionary *dict = [GPBUInt64Int32Dictionary dictionaryWithValue:200 forKey:31ULL]; + GPBUInt64Int32Dictionary *dict = [GPBUInt64Int32Dictionary dictionaryWithInt32:200 forKey:31ULL]; XCTAssertNotNil(dict); XCTAssertEqual(dict.count, 1U); int32_t value; - XCTAssertTrue([dict valueForKey:31ULL value:NULL]); - XCTAssertTrue([dict valueForKey:31ULL value:&value]); + XCTAssertTrue([dict getInt32:NULL forKey:31ULL]); + XCTAssertTrue([dict getInt32:&value forKey:31ULL]); XCTAssertEqual(value, 200); - XCTAssertFalse([dict valueForKey:32ULL value:NULL]); - [dict enumerateKeysAndValuesUsingBlock:^(uint64_t aKey, int32_t aValue, BOOL *stop) { + XCTAssertFalse([dict getInt32:NULL forKey:32ULL]); + [dict enumerateKeysAndInt32sUsingBlock:^(uint64_t aKey, int32_t aValue, BOOL *stop) { XCTAssertEqual(aKey, 31ULL); XCTAssertEqual(aValue, 200); XCTAssertNotEqual(stop, NULL); @@ -479,27 +479,27 @@ static BOOL TestingEnum_IsValidValue(int32_t value) { const uint64_t kKeys[] = { 31ULL, 32ULL, 33ULL }; const int32_t kValues[] = { 200, 201, 202 }; GPBUInt64Int32Dictionary *dict = - [[GPBUInt64Int32Dictionary alloc] initWithValues:kValues + [[GPBUInt64Int32Dictionary alloc] initWithInt32s:kValues forKeys:kKeys count:GPBARRAYSIZE(kValues)]; XCTAssertNotNil(dict); XCTAssertEqual(dict.count, 3U); int32_t value; - XCTAssertTrue([dict valueForKey:31ULL value:NULL]); - XCTAssertTrue([dict valueForKey:31ULL value:&value]); + XCTAssertTrue([dict getInt32:NULL forKey:31ULL]); + XCTAssertTrue([dict getInt32:&value forKey:31ULL]); XCTAssertEqual(value, 200); - XCTAssertTrue([dict valueForKey:32ULL value:NULL]); - XCTAssertTrue([dict valueForKey:32ULL value:&value]); + XCTAssertTrue([dict getInt32:NULL forKey:32ULL]); + XCTAssertTrue([dict getInt32:&value forKey:32ULL]); XCTAssertEqual(value, 201); - XCTAssertTrue([dict valueForKey:33ULL value:NULL]); - XCTAssertTrue([dict valueForKey:33ULL value:&value]); + XCTAssertTrue([dict getInt32:NULL forKey:33ULL]); + XCTAssertTrue([dict getInt32:&value forKey:33ULL]); XCTAssertEqual(value, 202); - XCTAssertFalse([dict valueForKey:34ULL value:NULL]); + XCTAssertFalse([dict getInt32:NULL forKey:34ULL]); __block NSUInteger idx = 0; uint64_t *seenKeys = malloc(3 * sizeof(uint64_t)); int32_t *seenValues = malloc(3 * sizeof(int32_t)); - [dict enumerateKeysAndValuesUsingBlock:^(uint64_t aKey, int32_t aValue, BOOL *stop) { + [dict enumerateKeysAndInt32sUsingBlock:^(uint64_t aKey, int32_t aValue, BOOL *stop) { XCTAssertLessThan(idx, 3U); seenKeys[idx] = aKey; seenValues[idx] = aValue; @@ -521,7 +521,7 @@ static BOOL TestingEnum_IsValidValue(int32_t value) { // Stopping the enumeration. idx = 0; - [dict enumerateKeysAndValuesUsingBlock:^(uint64_t aKey, int32_t aValue, BOOL *stop) { + [dict enumerateKeysAndInt32sUsingBlock:^(uint64_t aKey, int32_t aValue, BOOL *stop) { #pragma unused(aKey, aValue) if (idx == 1) *stop = YES; XCTAssertNotEqual(idx, 2U); @@ -537,27 +537,27 @@ static BOOL TestingEnum_IsValidValue(int32_t value) { const int32_t kValues2[] = { 200, 203, 202 }; const int32_t kValues3[] = { 200, 201, 202, 203 }; GPBUInt64Int32Dictionary *dict1 = - [[GPBUInt64Int32Dictionary alloc] initWithValues:kValues1 + [[GPBUInt64Int32Dictionary alloc] initWithInt32s:kValues1 forKeys:kKeys1 count:GPBARRAYSIZE(kValues1)]; XCTAssertNotNil(dict1); GPBUInt64Int32Dictionary *dict1prime = - [[GPBUInt64Int32Dictionary alloc] initWithValues:kValues1 + [[GPBUInt64Int32Dictionary alloc] initWithInt32s:kValues1 forKeys:kKeys1 count:GPBARRAYSIZE(kValues1)]; XCTAssertNotNil(dict1prime); GPBUInt64Int32Dictionary *dict2 = - [[GPBUInt64Int32Dictionary alloc] initWithValues:kValues2 + [[GPBUInt64Int32Dictionary alloc] initWithInt32s:kValues2 forKeys:kKeys1 count:GPBARRAYSIZE(kValues2)]; XCTAssertNotNil(dict2); GPBUInt64Int32Dictionary *dict3 = - [[GPBUInt64Int32Dictionary alloc] initWithValues:kValues1 + [[GPBUInt64Int32Dictionary alloc] initWithInt32s:kValues1 forKeys:kKeys2 count:GPBARRAYSIZE(kValues1)]; XCTAssertNotNil(dict3); GPBUInt64Int32Dictionary *dict4 = - [[GPBUInt64Int32Dictionary alloc] initWithValues:kValues3 + [[GPBUInt64Int32Dictionary alloc] initWithInt32s:kValues3 forKeys:kKeys1 count:GPBARRAYSIZE(kValues3)]; XCTAssertNotNil(dict4); @@ -588,7 +588,7 @@ static BOOL TestingEnum_IsValidValue(int32_t value) { const uint64_t kKeys[] = { 31ULL, 32ULL, 33ULL, 34ULL }; const int32_t kValues[] = { 200, 201, 202, 203 }; GPBUInt64Int32Dictionary *dict = - [[GPBUInt64Int32Dictionary alloc] initWithValues:kValues + [[GPBUInt64Int32Dictionary alloc] initWithInt32s:kValues forKeys:kKeys count:GPBARRAYSIZE(kValues)]; XCTAssertNotNil(dict); @@ -609,7 +609,7 @@ static BOOL TestingEnum_IsValidValue(int32_t value) { const uint64_t kKeys[] = { 31ULL, 32ULL, 33ULL, 34ULL }; const int32_t kValues[] = { 200, 201, 202, 203 }; GPBUInt64Int32Dictionary *dict = - [[GPBUInt64Int32Dictionary alloc] initWithValues:kValues + [[GPBUInt64Int32Dictionary alloc] initWithInt32s:kValues forKeys:kKeys count:GPBARRAYSIZE(kValues)]; XCTAssertNotNil(dict); @@ -629,13 +629,13 @@ static BOOL TestingEnum_IsValidValue(int32_t value) { XCTAssertNotNil(dict); XCTAssertEqual(dict.count, 0U); - [dict setValue:200 forKey:31ULL]; + [dict setInt32:200 forKey:31ULL]; XCTAssertEqual(dict.count, 1U); const uint64_t kKeys[] = { 32ULL, 33ULL, 34ULL }; const int32_t kValues[] = { 201, 202, 203 }; GPBUInt64Int32Dictionary *dict2 = - [[GPBUInt64Int32Dictionary alloc] initWithValues:kValues + [[GPBUInt64Int32Dictionary alloc] initWithInt32s:kValues forKeys:kKeys count:GPBARRAYSIZE(kValues)]; XCTAssertNotNil(dict2); @@ -643,17 +643,17 @@ static BOOL TestingEnum_IsValidValue(int32_t value) { XCTAssertEqual(dict.count, 4U); int32_t value; - XCTAssertTrue([dict valueForKey:31ULL value:NULL]); - XCTAssertTrue([dict valueForKey:31ULL value:&value]); + XCTAssertTrue([dict getInt32:NULL forKey:31ULL]); + XCTAssertTrue([dict getInt32:&value forKey:31ULL]); XCTAssertEqual(value, 200); - XCTAssertTrue([dict valueForKey:32ULL value:NULL]); - XCTAssertTrue([dict valueForKey:32ULL value:&value]); + XCTAssertTrue([dict getInt32:NULL forKey:32ULL]); + XCTAssertTrue([dict getInt32:&value forKey:32ULL]); XCTAssertEqual(value, 201); - XCTAssertTrue([dict valueForKey:33ULL value:NULL]); - XCTAssertTrue([dict valueForKey:33ULL value:&value]); + XCTAssertTrue([dict getInt32:NULL forKey:33ULL]); + XCTAssertTrue([dict getInt32:&value forKey:33ULL]); XCTAssertEqual(value, 202); - XCTAssertTrue([dict valueForKey:34ULL value:NULL]); - XCTAssertTrue([dict valueForKey:34ULL value:&value]); + XCTAssertTrue([dict getInt32:NULL forKey:34ULL]); + XCTAssertTrue([dict getInt32:&value forKey:34ULL]); XCTAssertEqual(value, 203); [dict2 release]; } @@ -662,57 +662,57 @@ static BOOL TestingEnum_IsValidValue(int32_t value) { const uint64_t kKeys[] = { 31ULL, 32ULL, 33ULL, 34ULL }; const int32_t kValues[] = { 200, 201, 202, 203 }; GPBUInt64Int32Dictionary *dict = - [[GPBUInt64Int32Dictionary alloc] initWithValues:kValues - forKeys:kKeys - count:GPBARRAYSIZE(kValues)]; + [[GPBUInt64Int32Dictionary alloc] initWithInt32s:kValues + forKeys:kKeys + count:GPBARRAYSIZE(kValues)]; XCTAssertNotNil(dict); XCTAssertEqual(dict.count, 4U); - [dict removeValueForKey:32ULL]; + [dict removeInt32ForKey:32ULL]; XCTAssertEqual(dict.count, 3U); int32_t value; - XCTAssertTrue([dict valueForKey:31ULL value:NULL]); - XCTAssertTrue([dict valueForKey:31ULL value:&value]); + XCTAssertTrue([dict getInt32:NULL forKey:31ULL]); + XCTAssertTrue([dict getInt32:&value forKey:31ULL]); XCTAssertEqual(value, 200); - XCTAssertFalse([dict valueForKey:32ULL value:NULL]); - XCTAssertTrue([dict valueForKey:33ULL value:NULL]); - XCTAssertTrue([dict valueForKey:33ULL value:&value]); + XCTAssertFalse([dict getInt32:NULL forKey:32ULL]); + XCTAssertTrue([dict getInt32:NULL forKey:33ULL]); + XCTAssertTrue([dict getInt32:&value forKey:33ULL]); XCTAssertEqual(value, 202); - XCTAssertTrue([dict valueForKey:34ULL value:NULL]); - XCTAssertTrue([dict valueForKey:34ULL value:&value]); + XCTAssertTrue([dict getInt32:NULL forKey:34ULL]); + XCTAssertTrue([dict getInt32:&value forKey:34ULL]); XCTAssertEqual(value, 203); // Remove again does nothing. - [dict removeValueForKey:32ULL]; + [dict removeInt32ForKey:32ULL]; XCTAssertEqual(dict.count, 3U); - XCTAssertTrue([dict valueForKey:31ULL value:NULL]); - XCTAssertTrue([dict valueForKey:31ULL value:&value]); + XCTAssertTrue([dict getInt32:NULL forKey:31ULL]); + XCTAssertTrue([dict getInt32:&value forKey:31ULL]); XCTAssertEqual(value, 200); - XCTAssertFalse([dict valueForKey:32ULL value:NULL]); - XCTAssertTrue([dict valueForKey:33ULL value:NULL]); - XCTAssertTrue([dict valueForKey:33ULL value:&value]); + XCTAssertFalse([dict getInt32:NULL forKey:32ULL]); + XCTAssertTrue([dict getInt32:NULL forKey:33ULL]); + XCTAssertTrue([dict getInt32:&value forKey:33ULL]); XCTAssertEqual(value, 202); - XCTAssertTrue([dict valueForKey:34ULL value:NULL]); - XCTAssertTrue([dict valueForKey:34ULL value:&value]); + XCTAssertTrue([dict getInt32:NULL forKey:34ULL]); + XCTAssertTrue([dict getInt32:&value forKey:34ULL]); XCTAssertEqual(value, 203); - [dict removeValueForKey:34ULL]; + [dict removeInt32ForKey:34ULL]; XCTAssertEqual(dict.count, 2U); - XCTAssertTrue([dict valueForKey:31ULL value:NULL]); - XCTAssertTrue([dict valueForKey:31ULL value:&value]); + XCTAssertTrue([dict getInt32:NULL forKey:31ULL]); + XCTAssertTrue([dict getInt32:&value forKey:31ULL]); XCTAssertEqual(value, 200); - XCTAssertFalse([dict valueForKey:32ULL value:NULL]); - XCTAssertTrue([dict valueForKey:33ULL value:NULL]); - XCTAssertTrue([dict valueForKey:33ULL value:&value]); + XCTAssertFalse([dict getInt32:NULL forKey:32ULL]); + XCTAssertTrue([dict getInt32:NULL forKey:33ULL]); + XCTAssertTrue([dict getInt32:&value forKey:33ULL]); XCTAssertEqual(value, 202); - XCTAssertFalse([dict valueForKey:34ULL value:NULL]); + XCTAssertFalse([dict getInt32:NULL forKey:34ULL]); [dict removeAll]; XCTAssertEqual(dict.count, 0U); - XCTAssertFalse([dict valueForKey:31ULL value:NULL]); - XCTAssertFalse([dict valueForKey:32ULL value:NULL]); - XCTAssertFalse([dict valueForKey:33ULL value:NULL]); - XCTAssertFalse([dict valueForKey:34ULL value:NULL]); + XCTAssertFalse([dict getInt32:NULL forKey:31ULL]); + XCTAssertFalse([dict getInt32:NULL forKey:32ULL]); + XCTAssertFalse([dict getInt32:NULL forKey:33ULL]); + XCTAssertFalse([dict getInt32:NULL forKey:34ULL]); [dict release]; } @@ -720,75 +720,75 @@ static BOOL TestingEnum_IsValidValue(int32_t value) { const uint64_t kKeys[] = { 31ULL, 32ULL, 33ULL, 34ULL }; const int32_t kValues[] = { 200, 201, 202, 203 }; GPBUInt64Int32Dictionary *dict = - [[GPBUInt64Int32Dictionary alloc] initWithValues:kValues - forKeys:kKeys - count:GPBARRAYSIZE(kValues)]; + [[GPBUInt64Int32Dictionary alloc] initWithInt32s:kValues + forKeys:kKeys + count:GPBARRAYSIZE(kValues)]; XCTAssertNotNil(dict); XCTAssertEqual(dict.count, 4U); int32_t value; - XCTAssertTrue([dict valueForKey:31ULL value:NULL]); - XCTAssertTrue([dict valueForKey:31ULL value:&value]); + XCTAssertTrue([dict getInt32:NULL forKey:31ULL]); + XCTAssertTrue([dict getInt32:&value forKey:31ULL]); XCTAssertEqual(value, 200); - XCTAssertTrue([dict valueForKey:32ULL value:NULL]); - XCTAssertTrue([dict valueForKey:32ULL value:&value]); + XCTAssertTrue([dict getInt32:NULL forKey:32ULL]); + XCTAssertTrue([dict getInt32:&value forKey:32ULL]); XCTAssertEqual(value, 201); - XCTAssertTrue([dict valueForKey:33ULL value:NULL]); - XCTAssertTrue([dict valueForKey:33ULL value:&value]); + XCTAssertTrue([dict getInt32:NULL forKey:33ULL]); + XCTAssertTrue([dict getInt32:&value forKey:33ULL]); XCTAssertEqual(value, 202); - XCTAssertTrue([dict valueForKey:34ULL value:NULL]); - XCTAssertTrue([dict valueForKey:34ULL value:&value]); + XCTAssertTrue([dict getInt32:NULL forKey:34ULL]); + XCTAssertTrue([dict getInt32:&value forKey:34ULL]); XCTAssertEqual(value, 203); - [dict setValue:203 forKey:31ULL]; + [dict setInt32:203 forKey:31ULL]; XCTAssertEqual(dict.count, 4U); - XCTAssertTrue([dict valueForKey:31ULL value:NULL]); - XCTAssertTrue([dict valueForKey:31ULL value:&value]); + XCTAssertTrue([dict getInt32:NULL forKey:31ULL]); + XCTAssertTrue([dict getInt32:&value forKey:31ULL]); XCTAssertEqual(value, 203); - XCTAssertTrue([dict valueForKey:32ULL value:NULL]); - XCTAssertTrue([dict valueForKey:32ULL value:&value]); + XCTAssertTrue([dict getInt32:NULL forKey:32ULL]); + XCTAssertTrue([dict getInt32:&value forKey:32ULL]); XCTAssertEqual(value, 201); - XCTAssertTrue([dict valueForKey:33ULL value:NULL]); - XCTAssertTrue([dict valueForKey:33ULL value:&value]); + XCTAssertTrue([dict getInt32:NULL forKey:33ULL]); + XCTAssertTrue([dict getInt32:&value forKey:33ULL]); XCTAssertEqual(value, 202); - XCTAssertTrue([dict valueForKey:34ULL value:NULL]); - XCTAssertTrue([dict valueForKey:34ULL value:&value]); + XCTAssertTrue([dict getInt32:NULL forKey:34ULL]); + XCTAssertTrue([dict getInt32:&value forKey:34ULL]); XCTAssertEqual(value, 203); - [dict setValue:201 forKey:34ULL]; + [dict setInt32:201 forKey:34ULL]; XCTAssertEqual(dict.count, 4U); - XCTAssertTrue([dict valueForKey:31ULL value:NULL]); - XCTAssertTrue([dict valueForKey:31ULL value:&value]); + XCTAssertTrue([dict getInt32:NULL forKey:31ULL]); + XCTAssertTrue([dict getInt32:&value forKey:31ULL]); XCTAssertEqual(value, 203); - XCTAssertTrue([dict valueForKey:32ULL value:NULL]); - XCTAssertTrue([dict valueForKey:32ULL value:&value]); + XCTAssertTrue([dict getInt32:NULL forKey:32ULL]); + XCTAssertTrue([dict getInt32:&value forKey:32ULL]); XCTAssertEqual(value, 201); - XCTAssertTrue([dict valueForKey:33ULL value:NULL]); - XCTAssertTrue([dict valueForKey:33ULL value:&value]); + XCTAssertTrue([dict getInt32:NULL forKey:33ULL]); + XCTAssertTrue([dict getInt32:&value forKey:33ULL]); XCTAssertEqual(value, 202); - XCTAssertTrue([dict valueForKey:34ULL value:NULL]); - XCTAssertTrue([dict valueForKey:34ULL value:&value]); + XCTAssertTrue([dict getInt32:NULL forKey:34ULL]); + XCTAssertTrue([dict getInt32:&value forKey:34ULL]); XCTAssertEqual(value, 201); const uint64_t kKeys2[] = { 32ULL, 33ULL }; const int32_t kValues2[] = { 202, 200 }; GPBUInt64Int32Dictionary *dict2 = - [[GPBUInt64Int32Dictionary alloc] initWithValues:kValues2 + [[GPBUInt64Int32Dictionary alloc] initWithInt32s:kValues2 forKeys:kKeys2 count:GPBARRAYSIZE(kValues2)]; XCTAssertNotNil(dict2); [dict addEntriesFromDictionary:dict2]; XCTAssertEqual(dict.count, 4U); - XCTAssertTrue([dict valueForKey:31ULL value:NULL]); - XCTAssertTrue([dict valueForKey:31ULL value:&value]); + XCTAssertTrue([dict getInt32:NULL forKey:31ULL]); + XCTAssertTrue([dict getInt32:&value forKey:31ULL]); XCTAssertEqual(value, 203); - XCTAssertTrue([dict valueForKey:32ULL value:NULL]); - XCTAssertTrue([dict valueForKey:32ULL value:&value]); + XCTAssertTrue([dict getInt32:NULL forKey:32ULL]); + XCTAssertTrue([dict getInt32:&value forKey:32ULL]); XCTAssertEqual(value, 202); - XCTAssertTrue([dict valueForKey:33ULL value:NULL]); - XCTAssertTrue([dict valueForKey:33ULL value:&value]); + XCTAssertTrue([dict getInt32:NULL forKey:33ULL]); + XCTAssertTrue([dict getInt32:&value forKey:33ULL]); XCTAssertEqual(value, 200); - XCTAssertTrue([dict valueForKey:34ULL value:NULL]); - XCTAssertTrue([dict valueForKey:34ULL value:&value]); + XCTAssertTrue([dict getInt32:NULL forKey:34ULL]); + XCTAssertTrue([dict getInt32:&value forKey:34ULL]); XCTAssertEqual(value, 201); [dict2 release]; @@ -808,8 +808,8 @@ static BOOL TestingEnum_IsValidValue(int32_t value) { GPBUInt64UInt64Dictionary *dict = [[GPBUInt64UInt64Dictionary alloc] init]; XCTAssertNotNil(dict); XCTAssertEqual(dict.count, 0U); - XCTAssertFalse([dict valueForKey:31ULL value:NULL]); - [dict enumerateKeysAndValuesUsingBlock:^(uint64_t aKey, uint64_t aValue, BOOL *stop) { + XCTAssertFalse([dict getUInt64:NULL forKey:31ULL]); + [dict enumerateKeysAndUInt64sUsingBlock:^(uint64_t aKey, uint64_t aValue, BOOL *stop) { #pragma unused(aKey, aValue, stop) XCTFail(@"Shouldn't get here!"); }]; @@ -817,15 +817,15 @@ static BOOL TestingEnum_IsValidValue(int32_t value) { } - (void)testOne { - GPBUInt64UInt64Dictionary *dict = [GPBUInt64UInt64Dictionary dictionaryWithValue:300U forKey:31ULL]; + GPBUInt64UInt64Dictionary *dict = [GPBUInt64UInt64Dictionary dictionaryWithUInt64:300U forKey:31ULL]; XCTAssertNotNil(dict); XCTAssertEqual(dict.count, 1U); uint64_t value; - XCTAssertTrue([dict valueForKey:31ULL value:NULL]); - XCTAssertTrue([dict valueForKey:31ULL value:&value]); + XCTAssertTrue([dict getUInt64:NULL forKey:31ULL]); + XCTAssertTrue([dict getUInt64:&value forKey:31ULL]); XCTAssertEqual(value, 300U); - XCTAssertFalse([dict valueForKey:32ULL value:NULL]); - [dict enumerateKeysAndValuesUsingBlock:^(uint64_t aKey, uint64_t aValue, BOOL *stop) { + XCTAssertFalse([dict getUInt64:NULL forKey:32ULL]); + [dict enumerateKeysAndUInt64sUsingBlock:^(uint64_t aKey, uint64_t aValue, BOOL *stop) { XCTAssertEqual(aKey, 31ULL); XCTAssertEqual(aValue, 300U); XCTAssertNotEqual(stop, NULL); @@ -836,27 +836,27 @@ static BOOL TestingEnum_IsValidValue(int32_t value) { const uint64_t kKeys[] = { 31ULL, 32ULL, 33ULL }; const uint64_t kValues[] = { 300U, 301U, 302U }; GPBUInt64UInt64Dictionary *dict = - [[GPBUInt64UInt64Dictionary alloc] initWithValues:kValues - forKeys:kKeys - count:GPBARRAYSIZE(kValues)]; + [[GPBUInt64UInt64Dictionary alloc] initWithUInt64s:kValues + forKeys:kKeys + count:GPBARRAYSIZE(kValues)]; XCTAssertNotNil(dict); XCTAssertEqual(dict.count, 3U); uint64_t value; - XCTAssertTrue([dict valueForKey:31ULL value:NULL]); - XCTAssertTrue([dict valueForKey:31ULL value:&value]); + XCTAssertTrue([dict getUInt64:NULL forKey:31ULL]); + XCTAssertTrue([dict getUInt64:&value forKey:31ULL]); XCTAssertEqual(value, 300U); - XCTAssertTrue([dict valueForKey:32ULL value:NULL]); - XCTAssertTrue([dict valueForKey:32ULL value:&value]); + XCTAssertTrue([dict getUInt64:NULL forKey:32ULL]); + XCTAssertTrue([dict getUInt64:&value forKey:32ULL]); XCTAssertEqual(value, 301U); - XCTAssertTrue([dict valueForKey:33ULL value:NULL]); - XCTAssertTrue([dict valueForKey:33ULL value:&value]); + XCTAssertTrue([dict getUInt64:NULL forKey:33ULL]); + XCTAssertTrue([dict getUInt64:&value forKey:33ULL]); XCTAssertEqual(value, 302U); - XCTAssertFalse([dict valueForKey:34ULL value:NULL]); + XCTAssertFalse([dict getUInt64:NULL forKey:34ULL]); __block NSUInteger idx = 0; uint64_t *seenKeys = malloc(3 * sizeof(uint64_t)); uint64_t *seenValues = malloc(3 * sizeof(uint64_t)); - [dict enumerateKeysAndValuesUsingBlock:^(uint64_t aKey, uint64_t aValue, BOOL *stop) { + [dict enumerateKeysAndUInt64sUsingBlock:^(uint64_t aKey, uint64_t aValue, BOOL *stop) { XCTAssertLessThan(idx, 3U); seenKeys[idx] = aKey; seenValues[idx] = aValue; @@ -878,7 +878,7 @@ static BOOL TestingEnum_IsValidValue(int32_t value) { // Stopping the enumeration. idx = 0; - [dict enumerateKeysAndValuesUsingBlock:^(uint64_t aKey, uint64_t aValue, BOOL *stop) { + [dict enumerateKeysAndUInt64sUsingBlock:^(uint64_t aKey, uint64_t aValue, BOOL *stop) { #pragma unused(aKey, aValue) if (idx == 1) *stop = YES; XCTAssertNotEqual(idx, 2U); @@ -894,29 +894,29 @@ static BOOL TestingEnum_IsValidValue(int32_t value) { const uint64_t kValues2[] = { 300U, 303U, 302U }; const uint64_t kValues3[] = { 300U, 301U, 302U, 303U }; GPBUInt64UInt64Dictionary *dict1 = - [[GPBUInt64UInt64Dictionary alloc] initWithValues:kValues1 - forKeys:kKeys1 - count:GPBARRAYSIZE(kValues1)]; + [[GPBUInt64UInt64Dictionary alloc] initWithUInt64s:kValues1 + forKeys:kKeys1 + count:GPBARRAYSIZE(kValues1)]; XCTAssertNotNil(dict1); GPBUInt64UInt64Dictionary *dict1prime = - [[GPBUInt64UInt64Dictionary alloc] initWithValues:kValues1 - forKeys:kKeys1 - count:GPBARRAYSIZE(kValues1)]; + [[GPBUInt64UInt64Dictionary alloc] initWithUInt64s:kValues1 + forKeys:kKeys1 + count:GPBARRAYSIZE(kValues1)]; XCTAssertNotNil(dict1prime); GPBUInt64UInt64Dictionary *dict2 = - [[GPBUInt64UInt64Dictionary alloc] initWithValues:kValues2 - forKeys:kKeys1 - count:GPBARRAYSIZE(kValues2)]; + [[GPBUInt64UInt64Dictionary alloc] initWithUInt64s:kValues2 + forKeys:kKeys1 + count:GPBARRAYSIZE(kValues2)]; XCTAssertNotNil(dict2); GPBUInt64UInt64Dictionary *dict3 = - [[GPBUInt64UInt64Dictionary alloc] initWithValues:kValues1 - forKeys:kKeys2 - count:GPBARRAYSIZE(kValues1)]; + [[GPBUInt64UInt64Dictionary alloc] initWithUInt64s:kValues1 + forKeys:kKeys2 + count:GPBARRAYSIZE(kValues1)]; XCTAssertNotNil(dict3); GPBUInt64UInt64Dictionary *dict4 = - [[GPBUInt64UInt64Dictionary alloc] initWithValues:kValues3 - forKeys:kKeys1 - count:GPBARRAYSIZE(kValues3)]; + [[GPBUInt64UInt64Dictionary alloc] initWithUInt64s:kValues3 + forKeys:kKeys1 + count:GPBARRAYSIZE(kValues3)]; XCTAssertNotNil(dict4); // 1/1Prime should be different objects, but equal. @@ -945,9 +945,9 @@ static BOOL TestingEnum_IsValidValue(int32_t value) { const uint64_t kKeys[] = { 31ULL, 32ULL, 33ULL, 34ULL }; const uint64_t kValues[] = { 300U, 301U, 302U, 303U }; GPBUInt64UInt64Dictionary *dict = - [[GPBUInt64UInt64Dictionary alloc] initWithValues:kValues - forKeys:kKeys - count:GPBARRAYSIZE(kValues)]; + [[GPBUInt64UInt64Dictionary alloc] initWithUInt64s:kValues + forKeys:kKeys + count:GPBARRAYSIZE(kValues)]; XCTAssertNotNil(dict); GPBUInt64UInt64Dictionary *dict2 = [dict copy]; @@ -966,9 +966,9 @@ static BOOL TestingEnum_IsValidValue(int32_t value) { const uint64_t kKeys[] = { 31ULL, 32ULL, 33ULL, 34ULL }; const uint64_t kValues[] = { 300U, 301U, 302U, 303U }; GPBUInt64UInt64Dictionary *dict = - [[GPBUInt64UInt64Dictionary alloc] initWithValues:kValues - forKeys:kKeys - count:GPBARRAYSIZE(kValues)]; + [[GPBUInt64UInt64Dictionary alloc] initWithUInt64s:kValues + forKeys:kKeys + count:GPBARRAYSIZE(kValues)]; XCTAssertNotNil(dict); GPBUInt64UInt64Dictionary *dict2 = @@ -986,31 +986,31 @@ static BOOL TestingEnum_IsValidValue(int32_t value) { XCTAssertNotNil(dict); XCTAssertEqual(dict.count, 0U); - [dict setValue:300U forKey:31ULL]; + [dict setUInt64:300U forKey:31ULL]; XCTAssertEqual(dict.count, 1U); const uint64_t kKeys[] = { 32ULL, 33ULL, 34ULL }; const uint64_t kValues[] = { 301U, 302U, 303U }; GPBUInt64UInt64Dictionary *dict2 = - [[GPBUInt64UInt64Dictionary alloc] initWithValues:kValues - forKeys:kKeys - count:GPBARRAYSIZE(kValues)]; + [[GPBUInt64UInt64Dictionary alloc] initWithUInt64s:kValues + forKeys:kKeys + count:GPBARRAYSIZE(kValues)]; XCTAssertNotNil(dict2); [dict addEntriesFromDictionary:dict2]; XCTAssertEqual(dict.count, 4U); uint64_t value; - XCTAssertTrue([dict valueForKey:31ULL value:NULL]); - XCTAssertTrue([dict valueForKey:31ULL value:&value]); + XCTAssertTrue([dict getUInt64:NULL forKey:31ULL]); + XCTAssertTrue([dict getUInt64:&value forKey:31ULL]); XCTAssertEqual(value, 300U); - XCTAssertTrue([dict valueForKey:32ULL value:NULL]); - XCTAssertTrue([dict valueForKey:32ULL value:&value]); + XCTAssertTrue([dict getUInt64:NULL forKey:32ULL]); + XCTAssertTrue([dict getUInt64:&value forKey:32ULL]); XCTAssertEqual(value, 301U); - XCTAssertTrue([dict valueForKey:33ULL value:NULL]); - XCTAssertTrue([dict valueForKey:33ULL value:&value]); + XCTAssertTrue([dict getUInt64:NULL forKey:33ULL]); + XCTAssertTrue([dict getUInt64:&value forKey:33ULL]); XCTAssertEqual(value, 302U); - XCTAssertTrue([dict valueForKey:34ULL value:NULL]); - XCTAssertTrue([dict valueForKey:34ULL value:&value]); + XCTAssertTrue([dict getUInt64:NULL forKey:34ULL]); + XCTAssertTrue([dict getUInt64:&value forKey:34ULL]); XCTAssertEqual(value, 303U); [dict2 release]; } @@ -1019,57 +1019,57 @@ static BOOL TestingEnum_IsValidValue(int32_t value) { const uint64_t kKeys[] = { 31ULL, 32ULL, 33ULL, 34ULL }; const uint64_t kValues[] = { 300U, 301U, 302U, 303U }; GPBUInt64UInt64Dictionary *dict = - [[GPBUInt64UInt64Dictionary alloc] initWithValues:kValues - forKeys:kKeys - count:GPBARRAYSIZE(kValues)]; + [[GPBUInt64UInt64Dictionary alloc] initWithUInt64s:kValues + forKeys:kKeys + count:GPBARRAYSIZE(kValues)]; XCTAssertNotNil(dict); XCTAssertEqual(dict.count, 4U); - [dict removeValueForKey:32ULL]; + [dict removeUInt64ForKey:32ULL]; XCTAssertEqual(dict.count, 3U); uint64_t value; - XCTAssertTrue([dict valueForKey:31ULL value:NULL]); - XCTAssertTrue([dict valueForKey:31ULL value:&value]); + XCTAssertTrue([dict getUInt64:NULL forKey:31ULL]); + XCTAssertTrue([dict getUInt64:&value forKey:31ULL]); XCTAssertEqual(value, 300U); - XCTAssertFalse([dict valueForKey:32ULL value:NULL]); - XCTAssertTrue([dict valueForKey:33ULL value:NULL]); - XCTAssertTrue([dict valueForKey:33ULL value:&value]); + XCTAssertFalse([dict getUInt64:NULL forKey:32ULL]); + XCTAssertTrue([dict getUInt64:NULL forKey:33ULL]); + XCTAssertTrue([dict getUInt64:&value forKey:33ULL]); XCTAssertEqual(value, 302U); - XCTAssertTrue([dict valueForKey:34ULL value:NULL]); - XCTAssertTrue([dict valueForKey:34ULL value:&value]); + XCTAssertTrue([dict getUInt64:NULL forKey:34ULL]); + XCTAssertTrue([dict getUInt64:&value forKey:34ULL]); XCTAssertEqual(value, 303U); // Remove again does nothing. - [dict removeValueForKey:32ULL]; + [dict removeUInt64ForKey:32ULL]; XCTAssertEqual(dict.count, 3U); - XCTAssertTrue([dict valueForKey:31ULL value:NULL]); - XCTAssertTrue([dict valueForKey:31ULL value:&value]); + XCTAssertTrue([dict getUInt64:NULL forKey:31ULL]); + XCTAssertTrue([dict getUInt64:&value forKey:31ULL]); XCTAssertEqual(value, 300U); - XCTAssertFalse([dict valueForKey:32ULL value:NULL]); - XCTAssertTrue([dict valueForKey:33ULL value:NULL]); - XCTAssertTrue([dict valueForKey:33ULL value:&value]); + XCTAssertFalse([dict getUInt64:NULL forKey:32ULL]); + XCTAssertTrue([dict getUInt64:NULL forKey:33ULL]); + XCTAssertTrue([dict getUInt64:&value forKey:33ULL]); XCTAssertEqual(value, 302U); - XCTAssertTrue([dict valueForKey:34ULL value:NULL]); - XCTAssertTrue([dict valueForKey:34ULL value:&value]); + XCTAssertTrue([dict getUInt64:NULL forKey:34ULL]); + XCTAssertTrue([dict getUInt64:&value forKey:34ULL]); XCTAssertEqual(value, 303U); - [dict removeValueForKey:34ULL]; + [dict removeUInt64ForKey:34ULL]; XCTAssertEqual(dict.count, 2U); - XCTAssertTrue([dict valueForKey:31ULL value:NULL]); - XCTAssertTrue([dict valueForKey:31ULL value:&value]); + XCTAssertTrue([dict getUInt64:NULL forKey:31ULL]); + XCTAssertTrue([dict getUInt64:&value forKey:31ULL]); XCTAssertEqual(value, 300U); - XCTAssertFalse([dict valueForKey:32ULL value:NULL]); - XCTAssertTrue([dict valueForKey:33ULL value:NULL]); - XCTAssertTrue([dict valueForKey:33ULL value:&value]); + XCTAssertFalse([dict getUInt64:NULL forKey:32ULL]); + XCTAssertTrue([dict getUInt64:NULL forKey:33ULL]); + XCTAssertTrue([dict getUInt64:&value forKey:33ULL]); XCTAssertEqual(value, 302U); - XCTAssertFalse([dict valueForKey:34ULL value:NULL]); + XCTAssertFalse([dict getUInt64:NULL forKey:34ULL]); [dict removeAll]; XCTAssertEqual(dict.count, 0U); - XCTAssertFalse([dict valueForKey:31ULL value:NULL]); - XCTAssertFalse([dict valueForKey:32ULL value:NULL]); - XCTAssertFalse([dict valueForKey:33ULL value:NULL]); - XCTAssertFalse([dict valueForKey:34ULL value:NULL]); + XCTAssertFalse([dict getUInt64:NULL forKey:31ULL]); + XCTAssertFalse([dict getUInt64:NULL forKey:32ULL]); + XCTAssertFalse([dict getUInt64:NULL forKey:33ULL]); + XCTAssertFalse([dict getUInt64:NULL forKey:34ULL]); [dict release]; } @@ -1077,75 +1077,75 @@ static BOOL TestingEnum_IsValidValue(int32_t value) { const uint64_t kKeys[] = { 31ULL, 32ULL, 33ULL, 34ULL }; const uint64_t kValues[] = { 300U, 301U, 302U, 303U }; GPBUInt64UInt64Dictionary *dict = - [[GPBUInt64UInt64Dictionary alloc] initWithValues:kValues - forKeys:kKeys - count:GPBARRAYSIZE(kValues)]; + [[GPBUInt64UInt64Dictionary alloc] initWithUInt64s:kValues + forKeys:kKeys + count:GPBARRAYSIZE(kValues)]; XCTAssertNotNil(dict); XCTAssertEqual(dict.count, 4U); uint64_t value; - XCTAssertTrue([dict valueForKey:31ULL value:NULL]); - XCTAssertTrue([dict valueForKey:31ULL value:&value]); + XCTAssertTrue([dict getUInt64:NULL forKey:31ULL]); + XCTAssertTrue([dict getUInt64:&value forKey:31ULL]); XCTAssertEqual(value, 300U); - XCTAssertTrue([dict valueForKey:32ULL value:NULL]); - XCTAssertTrue([dict valueForKey:32ULL value:&value]); + XCTAssertTrue([dict getUInt64:NULL forKey:32ULL]); + XCTAssertTrue([dict getUInt64:&value forKey:32ULL]); XCTAssertEqual(value, 301U); - XCTAssertTrue([dict valueForKey:33ULL value:NULL]); - XCTAssertTrue([dict valueForKey:33ULL value:&value]); + XCTAssertTrue([dict getUInt64:NULL forKey:33ULL]); + XCTAssertTrue([dict getUInt64:&value forKey:33ULL]); XCTAssertEqual(value, 302U); - XCTAssertTrue([dict valueForKey:34ULL value:NULL]); - XCTAssertTrue([dict valueForKey:34ULL value:&value]); + XCTAssertTrue([dict getUInt64:NULL forKey:34ULL]); + XCTAssertTrue([dict getUInt64:&value forKey:34ULL]); XCTAssertEqual(value, 303U); - [dict setValue:303U forKey:31ULL]; + [dict setUInt64:303U forKey:31ULL]; XCTAssertEqual(dict.count, 4U); - XCTAssertTrue([dict valueForKey:31ULL value:NULL]); - XCTAssertTrue([dict valueForKey:31ULL value:&value]); + XCTAssertTrue([dict getUInt64:NULL forKey:31ULL]); + XCTAssertTrue([dict getUInt64:&value forKey:31ULL]); XCTAssertEqual(value, 303U); - XCTAssertTrue([dict valueForKey:32ULL value:NULL]); - XCTAssertTrue([dict valueForKey:32ULL value:&value]); + XCTAssertTrue([dict getUInt64:NULL forKey:32ULL]); + XCTAssertTrue([dict getUInt64:&value forKey:32ULL]); XCTAssertEqual(value, 301U); - XCTAssertTrue([dict valueForKey:33ULL value:NULL]); - XCTAssertTrue([dict valueForKey:33ULL value:&value]); + XCTAssertTrue([dict getUInt64:NULL forKey:33ULL]); + XCTAssertTrue([dict getUInt64:&value forKey:33ULL]); XCTAssertEqual(value, 302U); - XCTAssertTrue([dict valueForKey:34ULL value:NULL]); - XCTAssertTrue([dict valueForKey:34ULL value:&value]); + XCTAssertTrue([dict getUInt64:NULL forKey:34ULL]); + XCTAssertTrue([dict getUInt64:&value forKey:34ULL]); XCTAssertEqual(value, 303U); - [dict setValue:301U forKey:34ULL]; + [dict setUInt64:301U forKey:34ULL]; XCTAssertEqual(dict.count, 4U); - XCTAssertTrue([dict valueForKey:31ULL value:NULL]); - XCTAssertTrue([dict valueForKey:31ULL value:&value]); + XCTAssertTrue([dict getUInt64:NULL forKey:31ULL]); + XCTAssertTrue([dict getUInt64:&value forKey:31ULL]); XCTAssertEqual(value, 303U); - XCTAssertTrue([dict valueForKey:32ULL value:NULL]); - XCTAssertTrue([dict valueForKey:32ULL value:&value]); + XCTAssertTrue([dict getUInt64:NULL forKey:32ULL]); + XCTAssertTrue([dict getUInt64:&value forKey:32ULL]); XCTAssertEqual(value, 301U); - XCTAssertTrue([dict valueForKey:33ULL value:NULL]); - XCTAssertTrue([dict valueForKey:33ULL value:&value]); + XCTAssertTrue([dict getUInt64:NULL forKey:33ULL]); + XCTAssertTrue([dict getUInt64:&value forKey:33ULL]); XCTAssertEqual(value, 302U); - XCTAssertTrue([dict valueForKey:34ULL value:NULL]); - XCTAssertTrue([dict valueForKey:34ULL value:&value]); + XCTAssertTrue([dict getUInt64:NULL forKey:34ULL]); + XCTAssertTrue([dict getUInt64:&value forKey:34ULL]); XCTAssertEqual(value, 301U); const uint64_t kKeys2[] = { 32ULL, 33ULL }; const uint64_t kValues2[] = { 302U, 300U }; GPBUInt64UInt64Dictionary *dict2 = - [[GPBUInt64UInt64Dictionary alloc] initWithValues:kValues2 - forKeys:kKeys2 - count:GPBARRAYSIZE(kValues2)]; + [[GPBUInt64UInt64Dictionary alloc] initWithUInt64s:kValues2 + forKeys:kKeys2 + count:GPBARRAYSIZE(kValues2)]; XCTAssertNotNil(dict2); [dict addEntriesFromDictionary:dict2]; XCTAssertEqual(dict.count, 4U); - XCTAssertTrue([dict valueForKey:31ULL value:NULL]); - XCTAssertTrue([dict valueForKey:31ULL value:&value]); + XCTAssertTrue([dict getUInt64:NULL forKey:31ULL]); + XCTAssertTrue([dict getUInt64:&value forKey:31ULL]); XCTAssertEqual(value, 303U); - XCTAssertTrue([dict valueForKey:32ULL value:NULL]); - XCTAssertTrue([dict valueForKey:32ULL value:&value]); + XCTAssertTrue([dict getUInt64:NULL forKey:32ULL]); + XCTAssertTrue([dict getUInt64:&value forKey:32ULL]); XCTAssertEqual(value, 302U); - XCTAssertTrue([dict valueForKey:33ULL value:NULL]); - XCTAssertTrue([dict valueForKey:33ULL value:&value]); + XCTAssertTrue([dict getUInt64:NULL forKey:33ULL]); + XCTAssertTrue([dict getUInt64:&value forKey:33ULL]); XCTAssertEqual(value, 300U); - XCTAssertTrue([dict valueForKey:34ULL value:NULL]); - XCTAssertTrue([dict valueForKey:34ULL value:&value]); + XCTAssertTrue([dict getUInt64:NULL forKey:34ULL]); + XCTAssertTrue([dict getUInt64:&value forKey:34ULL]); XCTAssertEqual(value, 301U); [dict2 release]; @@ -1165,8 +1165,8 @@ static BOOL TestingEnum_IsValidValue(int32_t value) { GPBUInt64Int64Dictionary *dict = [[GPBUInt64Int64Dictionary alloc] init]; XCTAssertNotNil(dict); XCTAssertEqual(dict.count, 0U); - XCTAssertFalse([dict valueForKey:31ULL value:NULL]); - [dict enumerateKeysAndValuesUsingBlock:^(uint64_t aKey, int64_t aValue, BOOL *stop) { + XCTAssertFalse([dict getInt64:NULL forKey:31ULL]); + [dict enumerateKeysAndInt64sUsingBlock:^(uint64_t aKey, int64_t aValue, BOOL *stop) { #pragma unused(aKey, aValue, stop) XCTFail(@"Shouldn't get here!"); }]; @@ -1174,15 +1174,15 @@ static BOOL TestingEnum_IsValidValue(int32_t value) { } - (void)testOne { - GPBUInt64Int64Dictionary *dict = [GPBUInt64Int64Dictionary dictionaryWithValue:400 forKey:31ULL]; + GPBUInt64Int64Dictionary *dict = [GPBUInt64Int64Dictionary dictionaryWithInt64:400 forKey:31ULL]; XCTAssertNotNil(dict); XCTAssertEqual(dict.count, 1U); int64_t value; - XCTAssertTrue([dict valueForKey:31ULL value:NULL]); - XCTAssertTrue([dict valueForKey:31ULL value:&value]); + XCTAssertTrue([dict getInt64:NULL forKey:31ULL]); + XCTAssertTrue([dict getInt64:&value forKey:31ULL]); XCTAssertEqual(value, 400); - XCTAssertFalse([dict valueForKey:32ULL value:NULL]); - [dict enumerateKeysAndValuesUsingBlock:^(uint64_t aKey, int64_t aValue, BOOL *stop) { + XCTAssertFalse([dict getInt64:NULL forKey:32ULL]); + [dict enumerateKeysAndInt64sUsingBlock:^(uint64_t aKey, int64_t aValue, BOOL *stop) { XCTAssertEqual(aKey, 31ULL); XCTAssertEqual(aValue, 400); XCTAssertNotEqual(stop, NULL); @@ -1193,27 +1193,27 @@ static BOOL TestingEnum_IsValidValue(int32_t value) { const uint64_t kKeys[] = { 31ULL, 32ULL, 33ULL }; const int64_t kValues[] = { 400, 401, 402 }; GPBUInt64Int64Dictionary *dict = - [[GPBUInt64Int64Dictionary alloc] initWithValues:kValues + [[GPBUInt64Int64Dictionary alloc] initWithInt64s:kValues forKeys:kKeys count:GPBARRAYSIZE(kValues)]; XCTAssertNotNil(dict); XCTAssertEqual(dict.count, 3U); int64_t value; - XCTAssertTrue([dict valueForKey:31ULL value:NULL]); - XCTAssertTrue([dict valueForKey:31ULL value:&value]); + XCTAssertTrue([dict getInt64:NULL forKey:31ULL]); + XCTAssertTrue([dict getInt64:&value forKey:31ULL]); XCTAssertEqual(value, 400); - XCTAssertTrue([dict valueForKey:32ULL value:NULL]); - XCTAssertTrue([dict valueForKey:32ULL value:&value]); + XCTAssertTrue([dict getInt64:NULL forKey:32ULL]); + XCTAssertTrue([dict getInt64:&value forKey:32ULL]); XCTAssertEqual(value, 401); - XCTAssertTrue([dict valueForKey:33ULL value:NULL]); - XCTAssertTrue([dict valueForKey:33ULL value:&value]); + XCTAssertTrue([dict getInt64:NULL forKey:33ULL]); + XCTAssertTrue([dict getInt64:&value forKey:33ULL]); XCTAssertEqual(value, 402); - XCTAssertFalse([dict valueForKey:34ULL value:NULL]); + XCTAssertFalse([dict getInt64:NULL forKey:34ULL]); __block NSUInteger idx = 0; uint64_t *seenKeys = malloc(3 * sizeof(uint64_t)); int64_t *seenValues = malloc(3 * sizeof(int64_t)); - [dict enumerateKeysAndValuesUsingBlock:^(uint64_t aKey, int64_t aValue, BOOL *stop) { + [dict enumerateKeysAndInt64sUsingBlock:^(uint64_t aKey, int64_t aValue, BOOL *stop) { XCTAssertLessThan(idx, 3U); seenKeys[idx] = aKey; seenValues[idx] = aValue; @@ -1235,7 +1235,7 @@ static BOOL TestingEnum_IsValidValue(int32_t value) { // Stopping the enumeration. idx = 0; - [dict enumerateKeysAndValuesUsingBlock:^(uint64_t aKey, int64_t aValue, BOOL *stop) { + [dict enumerateKeysAndInt64sUsingBlock:^(uint64_t aKey, int64_t aValue, BOOL *stop) { #pragma unused(aKey, aValue) if (idx == 1) *stop = YES; XCTAssertNotEqual(idx, 2U); @@ -1251,27 +1251,27 @@ static BOOL TestingEnum_IsValidValue(int32_t value) { const int64_t kValues2[] = { 400, 403, 402 }; const int64_t kValues3[] = { 400, 401, 402, 403 }; GPBUInt64Int64Dictionary *dict1 = - [[GPBUInt64Int64Dictionary alloc] initWithValues:kValues1 + [[GPBUInt64Int64Dictionary alloc] initWithInt64s:kValues1 forKeys:kKeys1 count:GPBARRAYSIZE(kValues1)]; XCTAssertNotNil(dict1); GPBUInt64Int64Dictionary *dict1prime = - [[GPBUInt64Int64Dictionary alloc] initWithValues:kValues1 + [[GPBUInt64Int64Dictionary alloc] initWithInt64s:kValues1 forKeys:kKeys1 count:GPBARRAYSIZE(kValues1)]; XCTAssertNotNil(dict1prime); GPBUInt64Int64Dictionary *dict2 = - [[GPBUInt64Int64Dictionary alloc] initWithValues:kValues2 + [[GPBUInt64Int64Dictionary alloc] initWithInt64s:kValues2 forKeys:kKeys1 count:GPBARRAYSIZE(kValues2)]; XCTAssertNotNil(dict2); GPBUInt64Int64Dictionary *dict3 = - [[GPBUInt64Int64Dictionary alloc] initWithValues:kValues1 + [[GPBUInt64Int64Dictionary alloc] initWithInt64s:kValues1 forKeys:kKeys2 count:GPBARRAYSIZE(kValues1)]; XCTAssertNotNil(dict3); GPBUInt64Int64Dictionary *dict4 = - [[GPBUInt64Int64Dictionary alloc] initWithValues:kValues3 + [[GPBUInt64Int64Dictionary alloc] initWithInt64s:kValues3 forKeys:kKeys1 count:GPBARRAYSIZE(kValues3)]; XCTAssertNotNil(dict4); @@ -1302,7 +1302,7 @@ static BOOL TestingEnum_IsValidValue(int32_t value) { const uint64_t kKeys[] = { 31ULL, 32ULL, 33ULL, 34ULL }; const int64_t kValues[] = { 400, 401, 402, 403 }; GPBUInt64Int64Dictionary *dict = - [[GPBUInt64Int64Dictionary alloc] initWithValues:kValues + [[GPBUInt64Int64Dictionary alloc] initWithInt64s:kValues forKeys:kKeys count:GPBARRAYSIZE(kValues)]; XCTAssertNotNil(dict); @@ -1323,7 +1323,7 @@ static BOOL TestingEnum_IsValidValue(int32_t value) { const uint64_t kKeys[] = { 31ULL, 32ULL, 33ULL, 34ULL }; const int64_t kValues[] = { 400, 401, 402, 403 }; GPBUInt64Int64Dictionary *dict = - [[GPBUInt64Int64Dictionary alloc] initWithValues:kValues + [[GPBUInt64Int64Dictionary alloc] initWithInt64s:kValues forKeys:kKeys count:GPBARRAYSIZE(kValues)]; XCTAssertNotNil(dict); @@ -1343,13 +1343,13 @@ static BOOL TestingEnum_IsValidValue(int32_t value) { XCTAssertNotNil(dict); XCTAssertEqual(dict.count, 0U); - [dict setValue:400 forKey:31ULL]; + [dict setInt64:400 forKey:31ULL]; XCTAssertEqual(dict.count, 1U); const uint64_t kKeys[] = { 32ULL, 33ULL, 34ULL }; const int64_t kValues[] = { 401, 402, 403 }; GPBUInt64Int64Dictionary *dict2 = - [[GPBUInt64Int64Dictionary alloc] initWithValues:kValues + [[GPBUInt64Int64Dictionary alloc] initWithInt64s:kValues forKeys:kKeys count:GPBARRAYSIZE(kValues)]; XCTAssertNotNil(dict2); @@ -1357,17 +1357,17 @@ static BOOL TestingEnum_IsValidValue(int32_t value) { XCTAssertEqual(dict.count, 4U); int64_t value; - XCTAssertTrue([dict valueForKey:31ULL value:NULL]); - XCTAssertTrue([dict valueForKey:31ULL value:&value]); + XCTAssertTrue([dict getInt64:NULL forKey:31ULL]); + XCTAssertTrue([dict getInt64:&value forKey:31ULL]); XCTAssertEqual(value, 400); - XCTAssertTrue([dict valueForKey:32ULL value:NULL]); - XCTAssertTrue([dict valueForKey:32ULL value:&value]); + XCTAssertTrue([dict getInt64:NULL forKey:32ULL]); + XCTAssertTrue([dict getInt64:&value forKey:32ULL]); XCTAssertEqual(value, 401); - XCTAssertTrue([dict valueForKey:33ULL value:NULL]); - XCTAssertTrue([dict valueForKey:33ULL value:&value]); + XCTAssertTrue([dict getInt64:NULL forKey:33ULL]); + XCTAssertTrue([dict getInt64:&value forKey:33ULL]); XCTAssertEqual(value, 402); - XCTAssertTrue([dict valueForKey:34ULL value:NULL]); - XCTAssertTrue([dict valueForKey:34ULL value:&value]); + XCTAssertTrue([dict getInt64:NULL forKey:34ULL]); + XCTAssertTrue([dict getInt64:&value forKey:34ULL]); XCTAssertEqual(value, 403); [dict2 release]; } @@ -1376,57 +1376,57 @@ static BOOL TestingEnum_IsValidValue(int32_t value) { const uint64_t kKeys[] = { 31ULL, 32ULL, 33ULL, 34ULL }; const int64_t kValues[] = { 400, 401, 402, 403 }; GPBUInt64Int64Dictionary *dict = - [[GPBUInt64Int64Dictionary alloc] initWithValues:kValues - forKeys:kKeys - count:GPBARRAYSIZE(kValues)]; + [[GPBUInt64Int64Dictionary alloc] initWithInt64s:kValues + forKeys:kKeys + count:GPBARRAYSIZE(kValues)]; XCTAssertNotNil(dict); XCTAssertEqual(dict.count, 4U); - [dict removeValueForKey:32ULL]; + [dict removeInt64ForKey:32ULL]; XCTAssertEqual(dict.count, 3U); int64_t value; - XCTAssertTrue([dict valueForKey:31ULL value:NULL]); - XCTAssertTrue([dict valueForKey:31ULL value:&value]); + XCTAssertTrue([dict getInt64:NULL forKey:31ULL]); + XCTAssertTrue([dict getInt64:&value forKey:31ULL]); XCTAssertEqual(value, 400); - XCTAssertFalse([dict valueForKey:32ULL value:NULL]); - XCTAssertTrue([dict valueForKey:33ULL value:NULL]); - XCTAssertTrue([dict valueForKey:33ULL value:&value]); + XCTAssertFalse([dict getInt64:NULL forKey:32ULL]); + XCTAssertTrue([dict getInt64:NULL forKey:33ULL]); + XCTAssertTrue([dict getInt64:&value forKey:33ULL]); XCTAssertEqual(value, 402); - XCTAssertTrue([dict valueForKey:34ULL value:NULL]); - XCTAssertTrue([dict valueForKey:34ULL value:&value]); + XCTAssertTrue([dict getInt64:NULL forKey:34ULL]); + XCTAssertTrue([dict getInt64:&value forKey:34ULL]); XCTAssertEqual(value, 403); // Remove again does nothing. - [dict removeValueForKey:32ULL]; + [dict removeInt64ForKey:32ULL]; XCTAssertEqual(dict.count, 3U); - XCTAssertTrue([dict valueForKey:31ULL value:NULL]); - XCTAssertTrue([dict valueForKey:31ULL value:&value]); + XCTAssertTrue([dict getInt64:NULL forKey:31ULL]); + XCTAssertTrue([dict getInt64:&value forKey:31ULL]); XCTAssertEqual(value, 400); - XCTAssertFalse([dict valueForKey:32ULL value:NULL]); - XCTAssertTrue([dict valueForKey:33ULL value:NULL]); - XCTAssertTrue([dict valueForKey:33ULL value:&value]); + XCTAssertFalse([dict getInt64:NULL forKey:32ULL]); + XCTAssertTrue([dict getInt64:NULL forKey:33ULL]); + XCTAssertTrue([dict getInt64:&value forKey:33ULL]); XCTAssertEqual(value, 402); - XCTAssertTrue([dict valueForKey:34ULL value:NULL]); - XCTAssertTrue([dict valueForKey:34ULL value:&value]); + XCTAssertTrue([dict getInt64:NULL forKey:34ULL]); + XCTAssertTrue([dict getInt64:&value forKey:34ULL]); XCTAssertEqual(value, 403); - [dict removeValueForKey:34ULL]; + [dict removeInt64ForKey:34ULL]; XCTAssertEqual(dict.count, 2U); - XCTAssertTrue([dict valueForKey:31ULL value:NULL]); - XCTAssertTrue([dict valueForKey:31ULL value:&value]); + XCTAssertTrue([dict getInt64:NULL forKey:31ULL]); + XCTAssertTrue([dict getInt64:&value forKey:31ULL]); XCTAssertEqual(value, 400); - XCTAssertFalse([dict valueForKey:32ULL value:NULL]); - XCTAssertTrue([dict valueForKey:33ULL value:NULL]); - XCTAssertTrue([dict valueForKey:33ULL value:&value]); + XCTAssertFalse([dict getInt64:NULL forKey:32ULL]); + XCTAssertTrue([dict getInt64:NULL forKey:33ULL]); + XCTAssertTrue([dict getInt64:&value forKey:33ULL]); XCTAssertEqual(value, 402); - XCTAssertFalse([dict valueForKey:34ULL value:NULL]); + XCTAssertFalse([dict getInt64:NULL forKey:34ULL]); [dict removeAll]; XCTAssertEqual(dict.count, 0U); - XCTAssertFalse([dict valueForKey:31ULL value:NULL]); - XCTAssertFalse([dict valueForKey:32ULL value:NULL]); - XCTAssertFalse([dict valueForKey:33ULL value:NULL]); - XCTAssertFalse([dict valueForKey:34ULL value:NULL]); + XCTAssertFalse([dict getInt64:NULL forKey:31ULL]); + XCTAssertFalse([dict getInt64:NULL forKey:32ULL]); + XCTAssertFalse([dict getInt64:NULL forKey:33ULL]); + XCTAssertFalse([dict getInt64:NULL forKey:34ULL]); [dict release]; } @@ -1434,75 +1434,75 @@ static BOOL TestingEnum_IsValidValue(int32_t value) { const uint64_t kKeys[] = { 31ULL, 32ULL, 33ULL, 34ULL }; const int64_t kValues[] = { 400, 401, 402, 403 }; GPBUInt64Int64Dictionary *dict = - [[GPBUInt64Int64Dictionary alloc] initWithValues:kValues - forKeys:kKeys - count:GPBARRAYSIZE(kValues)]; + [[GPBUInt64Int64Dictionary alloc] initWithInt64s:kValues + forKeys:kKeys + count:GPBARRAYSIZE(kValues)]; XCTAssertNotNil(dict); XCTAssertEqual(dict.count, 4U); int64_t value; - XCTAssertTrue([dict valueForKey:31ULL value:NULL]); - XCTAssertTrue([dict valueForKey:31ULL value:&value]); + XCTAssertTrue([dict getInt64:NULL forKey:31ULL]); + XCTAssertTrue([dict getInt64:&value forKey:31ULL]); XCTAssertEqual(value, 400); - XCTAssertTrue([dict valueForKey:32ULL value:NULL]); - XCTAssertTrue([dict valueForKey:32ULL value:&value]); + XCTAssertTrue([dict getInt64:NULL forKey:32ULL]); + XCTAssertTrue([dict getInt64:&value forKey:32ULL]); XCTAssertEqual(value, 401); - XCTAssertTrue([dict valueForKey:33ULL value:NULL]); - XCTAssertTrue([dict valueForKey:33ULL value:&value]); + XCTAssertTrue([dict getInt64:NULL forKey:33ULL]); + XCTAssertTrue([dict getInt64:&value forKey:33ULL]); XCTAssertEqual(value, 402); - XCTAssertTrue([dict valueForKey:34ULL value:NULL]); - XCTAssertTrue([dict valueForKey:34ULL value:&value]); + XCTAssertTrue([dict getInt64:NULL forKey:34ULL]); + XCTAssertTrue([dict getInt64:&value forKey:34ULL]); XCTAssertEqual(value, 403); - [dict setValue:403 forKey:31ULL]; + [dict setInt64:403 forKey:31ULL]; XCTAssertEqual(dict.count, 4U); - XCTAssertTrue([dict valueForKey:31ULL value:NULL]); - XCTAssertTrue([dict valueForKey:31ULL value:&value]); + XCTAssertTrue([dict getInt64:NULL forKey:31ULL]); + XCTAssertTrue([dict getInt64:&value forKey:31ULL]); XCTAssertEqual(value, 403); - XCTAssertTrue([dict valueForKey:32ULL value:NULL]); - XCTAssertTrue([dict valueForKey:32ULL value:&value]); + XCTAssertTrue([dict getInt64:NULL forKey:32ULL]); + XCTAssertTrue([dict getInt64:&value forKey:32ULL]); XCTAssertEqual(value, 401); - XCTAssertTrue([dict valueForKey:33ULL value:NULL]); - XCTAssertTrue([dict valueForKey:33ULL value:&value]); + XCTAssertTrue([dict getInt64:NULL forKey:33ULL]); + XCTAssertTrue([dict getInt64:&value forKey:33ULL]); XCTAssertEqual(value, 402); - XCTAssertTrue([dict valueForKey:34ULL value:NULL]); - XCTAssertTrue([dict valueForKey:34ULL value:&value]); + XCTAssertTrue([dict getInt64:NULL forKey:34ULL]); + XCTAssertTrue([dict getInt64:&value forKey:34ULL]); XCTAssertEqual(value, 403); - [dict setValue:401 forKey:34ULL]; + [dict setInt64:401 forKey:34ULL]; XCTAssertEqual(dict.count, 4U); - XCTAssertTrue([dict valueForKey:31ULL value:NULL]); - XCTAssertTrue([dict valueForKey:31ULL value:&value]); + XCTAssertTrue([dict getInt64:NULL forKey:31ULL]); + XCTAssertTrue([dict getInt64:&value forKey:31ULL]); XCTAssertEqual(value, 403); - XCTAssertTrue([dict valueForKey:32ULL value:NULL]); - XCTAssertTrue([dict valueForKey:32ULL value:&value]); + XCTAssertTrue([dict getInt64:NULL forKey:32ULL]); + XCTAssertTrue([dict getInt64:&value forKey:32ULL]); XCTAssertEqual(value, 401); - XCTAssertTrue([dict valueForKey:33ULL value:NULL]); - XCTAssertTrue([dict valueForKey:33ULL value:&value]); + XCTAssertTrue([dict getInt64:NULL forKey:33ULL]); + XCTAssertTrue([dict getInt64:&value forKey:33ULL]); XCTAssertEqual(value, 402); - XCTAssertTrue([dict valueForKey:34ULL value:NULL]); - XCTAssertTrue([dict valueForKey:34ULL value:&value]); + XCTAssertTrue([dict getInt64:NULL forKey:34ULL]); + XCTAssertTrue([dict getInt64:&value forKey:34ULL]); XCTAssertEqual(value, 401); const uint64_t kKeys2[] = { 32ULL, 33ULL }; const int64_t kValues2[] = { 402, 400 }; GPBUInt64Int64Dictionary *dict2 = - [[GPBUInt64Int64Dictionary alloc] initWithValues:kValues2 + [[GPBUInt64Int64Dictionary alloc] initWithInt64s:kValues2 forKeys:kKeys2 count:GPBARRAYSIZE(kValues2)]; XCTAssertNotNil(dict2); [dict addEntriesFromDictionary:dict2]; XCTAssertEqual(dict.count, 4U); - XCTAssertTrue([dict valueForKey:31ULL value:NULL]); - XCTAssertTrue([dict valueForKey:31ULL value:&value]); + XCTAssertTrue([dict getInt64:NULL forKey:31ULL]); + XCTAssertTrue([dict getInt64:&value forKey:31ULL]); XCTAssertEqual(value, 403); - XCTAssertTrue([dict valueForKey:32ULL value:NULL]); - XCTAssertTrue([dict valueForKey:32ULL value:&value]); + XCTAssertTrue([dict getInt64:NULL forKey:32ULL]); + XCTAssertTrue([dict getInt64:&value forKey:32ULL]); XCTAssertEqual(value, 402); - XCTAssertTrue([dict valueForKey:33ULL value:NULL]); - XCTAssertTrue([dict valueForKey:33ULL value:&value]); + XCTAssertTrue([dict getInt64:NULL forKey:33ULL]); + XCTAssertTrue([dict getInt64:&value forKey:33ULL]); XCTAssertEqual(value, 400); - XCTAssertTrue([dict valueForKey:34ULL value:NULL]); - XCTAssertTrue([dict valueForKey:34ULL value:&value]); + XCTAssertTrue([dict getInt64:NULL forKey:34ULL]); + XCTAssertTrue([dict getInt64:&value forKey:34ULL]); XCTAssertEqual(value, 401); [dict2 release]; @@ -1522,8 +1522,8 @@ static BOOL TestingEnum_IsValidValue(int32_t value) { GPBUInt64BoolDictionary *dict = [[GPBUInt64BoolDictionary alloc] init]; XCTAssertNotNil(dict); XCTAssertEqual(dict.count, 0U); - XCTAssertFalse([dict valueForKey:31ULL value:NULL]); - [dict enumerateKeysAndValuesUsingBlock:^(uint64_t aKey, BOOL aValue, BOOL *stop) { + XCTAssertFalse([dict getBool:NULL forKey:31ULL]); + [dict enumerateKeysAndBoolsUsingBlock:^(uint64_t aKey, BOOL aValue, BOOL *stop) { #pragma unused(aKey, aValue, stop) XCTFail(@"Shouldn't get here!"); }]; @@ -1531,15 +1531,15 @@ static BOOL TestingEnum_IsValidValue(int32_t value) { } - (void)testOne { - GPBUInt64BoolDictionary *dict = [GPBUInt64BoolDictionary dictionaryWithValue:YES forKey:31ULL]; + GPBUInt64BoolDictionary *dict = [GPBUInt64BoolDictionary dictionaryWithBool:YES forKey:31ULL]; XCTAssertNotNil(dict); XCTAssertEqual(dict.count, 1U); BOOL value; - XCTAssertTrue([dict valueForKey:31ULL value:NULL]); - XCTAssertTrue([dict valueForKey:31ULL value:&value]); + XCTAssertTrue([dict getBool:NULL forKey:31ULL]); + XCTAssertTrue([dict getBool:&value forKey:31ULL]); XCTAssertEqual(value, YES); - XCTAssertFalse([dict valueForKey:32ULL value:NULL]); - [dict enumerateKeysAndValuesUsingBlock:^(uint64_t aKey, BOOL aValue, BOOL *stop) { + XCTAssertFalse([dict getBool:NULL forKey:32ULL]); + [dict enumerateKeysAndBoolsUsingBlock:^(uint64_t aKey, BOOL aValue, BOOL *stop) { XCTAssertEqual(aKey, 31ULL); XCTAssertEqual(aValue, YES); XCTAssertNotEqual(stop, NULL); @@ -1550,27 +1550,27 @@ static BOOL TestingEnum_IsValidValue(int32_t value) { const uint64_t kKeys[] = { 31ULL, 32ULL, 33ULL }; const BOOL kValues[] = { YES, YES, NO }; GPBUInt64BoolDictionary *dict = - [[GPBUInt64BoolDictionary alloc] initWithValues:kValues - forKeys:kKeys - count:GPBARRAYSIZE(kValues)]; + [[GPBUInt64BoolDictionary alloc] initWithBools:kValues + forKeys:kKeys + count:GPBARRAYSIZE(kValues)]; XCTAssertNotNil(dict); XCTAssertEqual(dict.count, 3U); BOOL value; - XCTAssertTrue([dict valueForKey:31ULL value:NULL]); - XCTAssertTrue([dict valueForKey:31ULL value:&value]); + XCTAssertTrue([dict getBool:NULL forKey:31ULL]); + XCTAssertTrue([dict getBool:&value forKey:31ULL]); XCTAssertEqual(value, YES); - XCTAssertTrue([dict valueForKey:32ULL value:NULL]); - XCTAssertTrue([dict valueForKey:32ULL value:&value]); + XCTAssertTrue([dict getBool:NULL forKey:32ULL]); + XCTAssertTrue([dict getBool:&value forKey:32ULL]); XCTAssertEqual(value, YES); - XCTAssertTrue([dict valueForKey:33ULL value:NULL]); - XCTAssertTrue([dict valueForKey:33ULL value:&value]); + XCTAssertTrue([dict getBool:NULL forKey:33ULL]); + XCTAssertTrue([dict getBool:&value forKey:33ULL]); XCTAssertEqual(value, NO); - XCTAssertFalse([dict valueForKey:34ULL value:NULL]); + XCTAssertFalse([dict getBool:NULL forKey:34ULL]); __block NSUInteger idx = 0; uint64_t *seenKeys = malloc(3 * sizeof(uint64_t)); BOOL *seenValues = malloc(3 * sizeof(BOOL)); - [dict enumerateKeysAndValuesUsingBlock:^(uint64_t aKey, BOOL aValue, BOOL *stop) { + [dict enumerateKeysAndBoolsUsingBlock:^(uint64_t aKey, BOOL aValue, BOOL *stop) { XCTAssertLessThan(idx, 3U); seenKeys[idx] = aKey; seenValues[idx] = aValue; @@ -1592,7 +1592,7 @@ static BOOL TestingEnum_IsValidValue(int32_t value) { // Stopping the enumeration. idx = 0; - [dict enumerateKeysAndValuesUsingBlock:^(uint64_t aKey, BOOL aValue, BOOL *stop) { + [dict enumerateKeysAndBoolsUsingBlock:^(uint64_t aKey, BOOL aValue, BOOL *stop) { #pragma unused(aKey, aValue) if (idx == 1) *stop = YES; XCTAssertNotEqual(idx, 2U); @@ -1608,29 +1608,29 @@ static BOOL TestingEnum_IsValidValue(int32_t value) { const BOOL kValues2[] = { YES, NO, NO }; const BOOL kValues3[] = { YES, YES, NO, NO }; GPBUInt64BoolDictionary *dict1 = - [[GPBUInt64BoolDictionary alloc] initWithValues:kValues1 - forKeys:kKeys1 - count:GPBARRAYSIZE(kValues1)]; + [[GPBUInt64BoolDictionary alloc] initWithBools:kValues1 + forKeys:kKeys1 + count:GPBARRAYSIZE(kValues1)]; XCTAssertNotNil(dict1); GPBUInt64BoolDictionary *dict1prime = - [[GPBUInt64BoolDictionary alloc] initWithValues:kValues1 - forKeys:kKeys1 - count:GPBARRAYSIZE(kValues1)]; + [[GPBUInt64BoolDictionary alloc] initWithBools:kValues1 + forKeys:kKeys1 + count:GPBARRAYSIZE(kValues1)]; XCTAssertNotNil(dict1prime); GPBUInt64BoolDictionary *dict2 = - [[GPBUInt64BoolDictionary alloc] initWithValues:kValues2 - forKeys:kKeys1 - count:GPBARRAYSIZE(kValues2)]; + [[GPBUInt64BoolDictionary alloc] initWithBools:kValues2 + forKeys:kKeys1 + count:GPBARRAYSIZE(kValues2)]; XCTAssertNotNil(dict2); GPBUInt64BoolDictionary *dict3 = - [[GPBUInt64BoolDictionary alloc] initWithValues:kValues1 - forKeys:kKeys2 - count:GPBARRAYSIZE(kValues1)]; + [[GPBUInt64BoolDictionary alloc] initWithBools:kValues1 + forKeys:kKeys2 + count:GPBARRAYSIZE(kValues1)]; XCTAssertNotNil(dict3); GPBUInt64BoolDictionary *dict4 = - [[GPBUInt64BoolDictionary alloc] initWithValues:kValues3 - forKeys:kKeys1 - count:GPBARRAYSIZE(kValues3)]; + [[GPBUInt64BoolDictionary alloc] initWithBools:kValues3 + forKeys:kKeys1 + count:GPBARRAYSIZE(kValues3)]; XCTAssertNotNil(dict4); // 1/1Prime should be different objects, but equal. @@ -1659,9 +1659,9 @@ static BOOL TestingEnum_IsValidValue(int32_t value) { const uint64_t kKeys[] = { 31ULL, 32ULL, 33ULL, 34ULL }; const BOOL kValues[] = { YES, YES, NO, NO }; GPBUInt64BoolDictionary *dict = - [[GPBUInt64BoolDictionary alloc] initWithValues:kValues - forKeys:kKeys - count:GPBARRAYSIZE(kValues)]; + [[GPBUInt64BoolDictionary alloc] initWithBools:kValues + forKeys:kKeys + count:GPBARRAYSIZE(kValues)]; XCTAssertNotNil(dict); GPBUInt64BoolDictionary *dict2 = [dict copy]; @@ -1680,9 +1680,9 @@ static BOOL TestingEnum_IsValidValue(int32_t value) { const uint64_t kKeys[] = { 31ULL, 32ULL, 33ULL, 34ULL }; const BOOL kValues[] = { YES, YES, NO, NO }; GPBUInt64BoolDictionary *dict = - [[GPBUInt64BoolDictionary alloc] initWithValues:kValues - forKeys:kKeys - count:GPBARRAYSIZE(kValues)]; + [[GPBUInt64BoolDictionary alloc] initWithBools:kValues + forKeys:kKeys + count:GPBARRAYSIZE(kValues)]; XCTAssertNotNil(dict); GPBUInt64BoolDictionary *dict2 = @@ -1700,31 +1700,31 @@ static BOOL TestingEnum_IsValidValue(int32_t value) { XCTAssertNotNil(dict); XCTAssertEqual(dict.count, 0U); - [dict setValue:YES forKey:31ULL]; + [dict setBool:YES forKey:31ULL]; XCTAssertEqual(dict.count, 1U); const uint64_t kKeys[] = { 32ULL, 33ULL, 34ULL }; const BOOL kValues[] = { YES, NO, NO }; GPBUInt64BoolDictionary *dict2 = - [[GPBUInt64BoolDictionary alloc] initWithValues:kValues - forKeys:kKeys - count:GPBARRAYSIZE(kValues)]; + [[GPBUInt64BoolDictionary alloc] initWithBools:kValues + forKeys:kKeys + count:GPBARRAYSIZE(kValues)]; XCTAssertNotNil(dict2); [dict addEntriesFromDictionary:dict2]; XCTAssertEqual(dict.count, 4U); BOOL value; - XCTAssertTrue([dict valueForKey:31ULL value:NULL]); - XCTAssertTrue([dict valueForKey:31ULL value:&value]); + XCTAssertTrue([dict getBool:NULL forKey:31ULL]); + XCTAssertTrue([dict getBool:&value forKey:31ULL]); XCTAssertEqual(value, YES); - XCTAssertTrue([dict valueForKey:32ULL value:NULL]); - XCTAssertTrue([dict valueForKey:32ULL value:&value]); + XCTAssertTrue([dict getBool:NULL forKey:32ULL]); + XCTAssertTrue([dict getBool:&value forKey:32ULL]); XCTAssertEqual(value, YES); - XCTAssertTrue([dict valueForKey:33ULL value:NULL]); - XCTAssertTrue([dict valueForKey:33ULL value:&value]); + XCTAssertTrue([dict getBool:NULL forKey:33ULL]); + XCTAssertTrue([dict getBool:&value forKey:33ULL]); XCTAssertEqual(value, NO); - XCTAssertTrue([dict valueForKey:34ULL value:NULL]); - XCTAssertTrue([dict valueForKey:34ULL value:&value]); + XCTAssertTrue([dict getBool:NULL forKey:34ULL]); + XCTAssertTrue([dict getBool:&value forKey:34ULL]); XCTAssertEqual(value, NO); [dict2 release]; } @@ -1733,57 +1733,57 @@ static BOOL TestingEnum_IsValidValue(int32_t value) { const uint64_t kKeys[] = { 31ULL, 32ULL, 33ULL, 34ULL }; const BOOL kValues[] = { YES, YES, NO, NO }; GPBUInt64BoolDictionary *dict = - [[GPBUInt64BoolDictionary alloc] initWithValues:kValues - forKeys:kKeys - count:GPBARRAYSIZE(kValues)]; + [[GPBUInt64BoolDictionary alloc] initWithBools:kValues + forKeys:kKeys + count:GPBARRAYSIZE(kValues)]; XCTAssertNotNil(dict); XCTAssertEqual(dict.count, 4U); - [dict removeValueForKey:32ULL]; + [dict removeBoolForKey:32ULL]; XCTAssertEqual(dict.count, 3U); BOOL value; - XCTAssertTrue([dict valueForKey:31ULL value:NULL]); - XCTAssertTrue([dict valueForKey:31ULL value:&value]); + XCTAssertTrue([dict getBool:NULL forKey:31ULL]); + XCTAssertTrue([dict getBool:&value forKey:31ULL]); XCTAssertEqual(value, YES); - XCTAssertFalse([dict valueForKey:32ULL value:NULL]); - XCTAssertTrue([dict valueForKey:33ULL value:NULL]); - XCTAssertTrue([dict valueForKey:33ULL value:&value]); + XCTAssertFalse([dict getBool:NULL forKey:32ULL]); + XCTAssertTrue([dict getBool:NULL forKey:33ULL]); + XCTAssertTrue([dict getBool:&value forKey:33ULL]); XCTAssertEqual(value, NO); - XCTAssertTrue([dict valueForKey:34ULL value:NULL]); - XCTAssertTrue([dict valueForKey:34ULL value:&value]); + XCTAssertTrue([dict getBool:NULL forKey:34ULL]); + XCTAssertTrue([dict getBool:&value forKey:34ULL]); XCTAssertEqual(value, NO); // Remove again does nothing. - [dict removeValueForKey:32ULL]; + [dict removeBoolForKey:32ULL]; XCTAssertEqual(dict.count, 3U); - XCTAssertTrue([dict valueForKey:31ULL value:NULL]); - XCTAssertTrue([dict valueForKey:31ULL value:&value]); + XCTAssertTrue([dict getBool:NULL forKey:31ULL]); + XCTAssertTrue([dict getBool:&value forKey:31ULL]); XCTAssertEqual(value, YES); - XCTAssertFalse([dict valueForKey:32ULL value:NULL]); - XCTAssertTrue([dict valueForKey:33ULL value:NULL]); - XCTAssertTrue([dict valueForKey:33ULL value:&value]); + XCTAssertFalse([dict getBool:NULL forKey:32ULL]); + XCTAssertTrue([dict getBool:NULL forKey:33ULL]); + XCTAssertTrue([dict getBool:&value forKey:33ULL]); XCTAssertEqual(value, NO); - XCTAssertTrue([dict valueForKey:34ULL value:NULL]); - XCTAssertTrue([dict valueForKey:34ULL value:&value]); + XCTAssertTrue([dict getBool:NULL forKey:34ULL]); + XCTAssertTrue([dict getBool:&value forKey:34ULL]); XCTAssertEqual(value, NO); - [dict removeValueForKey:34ULL]; + [dict removeBoolForKey:34ULL]; XCTAssertEqual(dict.count, 2U); - XCTAssertTrue([dict valueForKey:31ULL value:NULL]); - XCTAssertTrue([dict valueForKey:31ULL value:&value]); + XCTAssertTrue([dict getBool:NULL forKey:31ULL]); + XCTAssertTrue([dict getBool:&value forKey:31ULL]); XCTAssertEqual(value, YES); - XCTAssertFalse([dict valueForKey:32ULL value:NULL]); - XCTAssertTrue([dict valueForKey:33ULL value:NULL]); - XCTAssertTrue([dict valueForKey:33ULL value:&value]); + XCTAssertFalse([dict getBool:NULL forKey:32ULL]); + XCTAssertTrue([dict getBool:NULL forKey:33ULL]); + XCTAssertTrue([dict getBool:&value forKey:33ULL]); XCTAssertEqual(value, NO); - XCTAssertFalse([dict valueForKey:34ULL value:NULL]); + XCTAssertFalse([dict getBool:NULL forKey:34ULL]); [dict removeAll]; XCTAssertEqual(dict.count, 0U); - XCTAssertFalse([dict valueForKey:31ULL value:NULL]); - XCTAssertFalse([dict valueForKey:32ULL value:NULL]); - XCTAssertFalse([dict valueForKey:33ULL value:NULL]); - XCTAssertFalse([dict valueForKey:34ULL value:NULL]); + XCTAssertFalse([dict getBool:NULL forKey:31ULL]); + XCTAssertFalse([dict getBool:NULL forKey:32ULL]); + XCTAssertFalse([dict getBool:NULL forKey:33ULL]); + XCTAssertFalse([dict getBool:NULL forKey:34ULL]); [dict release]; } @@ -1791,75 +1791,75 @@ static BOOL TestingEnum_IsValidValue(int32_t value) { const uint64_t kKeys[] = { 31ULL, 32ULL, 33ULL, 34ULL }; const BOOL kValues[] = { YES, YES, NO, NO }; GPBUInt64BoolDictionary *dict = - [[GPBUInt64BoolDictionary alloc] initWithValues:kValues - forKeys:kKeys - count:GPBARRAYSIZE(kValues)]; + [[GPBUInt64BoolDictionary alloc] initWithBools:kValues + forKeys:kKeys + count:GPBARRAYSIZE(kValues)]; XCTAssertNotNil(dict); XCTAssertEqual(dict.count, 4U); BOOL value; - XCTAssertTrue([dict valueForKey:31ULL value:NULL]); - XCTAssertTrue([dict valueForKey:31ULL value:&value]); + XCTAssertTrue([dict getBool:NULL forKey:31ULL]); + XCTAssertTrue([dict getBool:&value forKey:31ULL]); XCTAssertEqual(value, YES); - XCTAssertTrue([dict valueForKey:32ULL value:NULL]); - XCTAssertTrue([dict valueForKey:32ULL value:&value]); + XCTAssertTrue([dict getBool:NULL forKey:32ULL]); + XCTAssertTrue([dict getBool:&value forKey:32ULL]); XCTAssertEqual(value, YES); - XCTAssertTrue([dict valueForKey:33ULL value:NULL]); - XCTAssertTrue([dict valueForKey:33ULL value:&value]); + XCTAssertTrue([dict getBool:NULL forKey:33ULL]); + XCTAssertTrue([dict getBool:&value forKey:33ULL]); XCTAssertEqual(value, NO); - XCTAssertTrue([dict valueForKey:34ULL value:NULL]); - XCTAssertTrue([dict valueForKey:34ULL value:&value]); + XCTAssertTrue([dict getBool:NULL forKey:34ULL]); + XCTAssertTrue([dict getBool:&value forKey:34ULL]); XCTAssertEqual(value, NO); - [dict setValue:NO forKey:31ULL]; + [dict setBool:NO forKey:31ULL]; XCTAssertEqual(dict.count, 4U); - XCTAssertTrue([dict valueForKey:31ULL value:NULL]); - XCTAssertTrue([dict valueForKey:31ULL value:&value]); + XCTAssertTrue([dict getBool:NULL forKey:31ULL]); + XCTAssertTrue([dict getBool:&value forKey:31ULL]); XCTAssertEqual(value, NO); - XCTAssertTrue([dict valueForKey:32ULL value:NULL]); - XCTAssertTrue([dict valueForKey:32ULL value:&value]); + XCTAssertTrue([dict getBool:NULL forKey:32ULL]); + XCTAssertTrue([dict getBool:&value forKey:32ULL]); XCTAssertEqual(value, YES); - XCTAssertTrue([dict valueForKey:33ULL value:NULL]); - XCTAssertTrue([dict valueForKey:33ULL value:&value]); + XCTAssertTrue([dict getBool:NULL forKey:33ULL]); + XCTAssertTrue([dict getBool:&value forKey:33ULL]); XCTAssertEqual(value, NO); - XCTAssertTrue([dict valueForKey:34ULL value:NULL]); - XCTAssertTrue([dict valueForKey:34ULL value:&value]); + XCTAssertTrue([dict getBool:NULL forKey:34ULL]); + XCTAssertTrue([dict getBool:&value forKey:34ULL]); XCTAssertEqual(value, NO); - [dict setValue:YES forKey:34ULL]; + [dict setBool:YES forKey:34ULL]; XCTAssertEqual(dict.count, 4U); - XCTAssertTrue([dict valueForKey:31ULL value:NULL]); - XCTAssertTrue([dict valueForKey:31ULL value:&value]); + XCTAssertTrue([dict getBool:NULL forKey:31ULL]); + XCTAssertTrue([dict getBool:&value forKey:31ULL]); XCTAssertEqual(value, NO); - XCTAssertTrue([dict valueForKey:32ULL value:NULL]); - XCTAssertTrue([dict valueForKey:32ULL value:&value]); + XCTAssertTrue([dict getBool:NULL forKey:32ULL]); + XCTAssertTrue([dict getBool:&value forKey:32ULL]); XCTAssertEqual(value, YES); - XCTAssertTrue([dict valueForKey:33ULL value:NULL]); - XCTAssertTrue([dict valueForKey:33ULL value:&value]); + XCTAssertTrue([dict getBool:NULL forKey:33ULL]); + XCTAssertTrue([dict getBool:&value forKey:33ULL]); XCTAssertEqual(value, NO); - XCTAssertTrue([dict valueForKey:34ULL value:NULL]); - XCTAssertTrue([dict valueForKey:34ULL value:&value]); + XCTAssertTrue([dict getBool:NULL forKey:34ULL]); + XCTAssertTrue([dict getBool:&value forKey:34ULL]); XCTAssertEqual(value, YES); const uint64_t kKeys2[] = { 32ULL, 33ULL }; const BOOL kValues2[] = { NO, YES }; GPBUInt64BoolDictionary *dict2 = - [[GPBUInt64BoolDictionary alloc] initWithValues:kValues2 - forKeys:kKeys2 - count:GPBARRAYSIZE(kValues2)]; + [[GPBUInt64BoolDictionary alloc] initWithBools:kValues2 + forKeys:kKeys2 + count:GPBARRAYSIZE(kValues2)]; XCTAssertNotNil(dict2); [dict addEntriesFromDictionary:dict2]; XCTAssertEqual(dict.count, 4U); - XCTAssertTrue([dict valueForKey:31ULL value:NULL]); - XCTAssertTrue([dict valueForKey:31ULL value:&value]); + XCTAssertTrue([dict getBool:NULL forKey:31ULL]); + XCTAssertTrue([dict getBool:&value forKey:31ULL]); XCTAssertEqual(value, NO); - XCTAssertTrue([dict valueForKey:32ULL value:NULL]); - XCTAssertTrue([dict valueForKey:32ULL value:&value]); + XCTAssertTrue([dict getBool:NULL forKey:32ULL]); + XCTAssertTrue([dict getBool:&value forKey:32ULL]); XCTAssertEqual(value, NO); - XCTAssertTrue([dict valueForKey:33ULL value:NULL]); - XCTAssertTrue([dict valueForKey:33ULL value:&value]); + XCTAssertTrue([dict getBool:NULL forKey:33ULL]); + XCTAssertTrue([dict getBool:&value forKey:33ULL]); XCTAssertEqual(value, YES); - XCTAssertTrue([dict valueForKey:34ULL value:NULL]); - XCTAssertTrue([dict valueForKey:34ULL value:&value]); + XCTAssertTrue([dict getBool:NULL forKey:34ULL]); + XCTAssertTrue([dict getBool:&value forKey:34ULL]); XCTAssertEqual(value, YES); [dict2 release]; @@ -1879,8 +1879,8 @@ static BOOL TestingEnum_IsValidValue(int32_t value) { GPBUInt64FloatDictionary *dict = [[GPBUInt64FloatDictionary alloc] init]; XCTAssertNotNil(dict); XCTAssertEqual(dict.count, 0U); - XCTAssertFalse([dict valueForKey:31ULL value:NULL]); - [dict enumerateKeysAndValuesUsingBlock:^(uint64_t aKey, float aValue, BOOL *stop) { + XCTAssertFalse([dict getFloat:NULL forKey:31ULL]); + [dict enumerateKeysAndFloatsUsingBlock:^(uint64_t aKey, float aValue, BOOL *stop) { #pragma unused(aKey, aValue, stop) XCTFail(@"Shouldn't get here!"); }]; @@ -1888,15 +1888,15 @@ static BOOL TestingEnum_IsValidValue(int32_t value) { } - (void)testOne { - GPBUInt64FloatDictionary *dict = [GPBUInt64FloatDictionary dictionaryWithValue:500.f forKey:31ULL]; + GPBUInt64FloatDictionary *dict = [GPBUInt64FloatDictionary dictionaryWithFloat:500.f forKey:31ULL]; XCTAssertNotNil(dict); XCTAssertEqual(dict.count, 1U); float value; - XCTAssertTrue([dict valueForKey:31ULL value:NULL]); - XCTAssertTrue([dict valueForKey:31ULL value:&value]); + XCTAssertTrue([dict getFloat:NULL forKey:31ULL]); + XCTAssertTrue([dict getFloat:&value forKey:31ULL]); XCTAssertEqual(value, 500.f); - XCTAssertFalse([dict valueForKey:32ULL value:NULL]); - [dict enumerateKeysAndValuesUsingBlock:^(uint64_t aKey, float aValue, BOOL *stop) { + XCTAssertFalse([dict getFloat:NULL forKey:32ULL]); + [dict enumerateKeysAndFloatsUsingBlock:^(uint64_t aKey, float aValue, BOOL *stop) { XCTAssertEqual(aKey, 31ULL); XCTAssertEqual(aValue, 500.f); XCTAssertNotEqual(stop, NULL); @@ -1907,27 +1907,27 @@ static BOOL TestingEnum_IsValidValue(int32_t value) { const uint64_t kKeys[] = { 31ULL, 32ULL, 33ULL }; const float kValues[] = { 500.f, 501.f, 502.f }; GPBUInt64FloatDictionary *dict = - [[GPBUInt64FloatDictionary alloc] initWithValues:kValues + [[GPBUInt64FloatDictionary alloc] initWithFloats:kValues forKeys:kKeys count:GPBARRAYSIZE(kValues)]; XCTAssertNotNil(dict); XCTAssertEqual(dict.count, 3U); float value; - XCTAssertTrue([dict valueForKey:31ULL value:NULL]); - XCTAssertTrue([dict valueForKey:31ULL value:&value]); + XCTAssertTrue([dict getFloat:NULL forKey:31ULL]); + XCTAssertTrue([dict getFloat:&value forKey:31ULL]); XCTAssertEqual(value, 500.f); - XCTAssertTrue([dict valueForKey:32ULL value:NULL]); - XCTAssertTrue([dict valueForKey:32ULL value:&value]); + XCTAssertTrue([dict getFloat:NULL forKey:32ULL]); + XCTAssertTrue([dict getFloat:&value forKey:32ULL]); XCTAssertEqual(value, 501.f); - XCTAssertTrue([dict valueForKey:33ULL value:NULL]); - XCTAssertTrue([dict valueForKey:33ULL value:&value]); + XCTAssertTrue([dict getFloat:NULL forKey:33ULL]); + XCTAssertTrue([dict getFloat:&value forKey:33ULL]); XCTAssertEqual(value, 502.f); - XCTAssertFalse([dict valueForKey:34ULL value:NULL]); + XCTAssertFalse([dict getFloat:NULL forKey:34ULL]); __block NSUInteger idx = 0; uint64_t *seenKeys = malloc(3 * sizeof(uint64_t)); float *seenValues = malloc(3 * sizeof(float)); - [dict enumerateKeysAndValuesUsingBlock:^(uint64_t aKey, float aValue, BOOL *stop) { + [dict enumerateKeysAndFloatsUsingBlock:^(uint64_t aKey, float aValue, BOOL *stop) { XCTAssertLessThan(idx, 3U); seenKeys[idx] = aKey; seenValues[idx] = aValue; @@ -1949,7 +1949,7 @@ static BOOL TestingEnum_IsValidValue(int32_t value) { // Stopping the enumeration. idx = 0; - [dict enumerateKeysAndValuesUsingBlock:^(uint64_t aKey, float aValue, BOOL *stop) { + [dict enumerateKeysAndFloatsUsingBlock:^(uint64_t aKey, float aValue, BOOL *stop) { #pragma unused(aKey, aValue) if (idx == 1) *stop = YES; XCTAssertNotEqual(idx, 2U); @@ -1965,27 +1965,27 @@ static BOOL TestingEnum_IsValidValue(int32_t value) { const float kValues2[] = { 500.f, 503.f, 502.f }; const float kValues3[] = { 500.f, 501.f, 502.f, 503.f }; GPBUInt64FloatDictionary *dict1 = - [[GPBUInt64FloatDictionary alloc] initWithValues:kValues1 + [[GPBUInt64FloatDictionary alloc] initWithFloats:kValues1 forKeys:kKeys1 count:GPBARRAYSIZE(kValues1)]; XCTAssertNotNil(dict1); GPBUInt64FloatDictionary *dict1prime = - [[GPBUInt64FloatDictionary alloc] initWithValues:kValues1 + [[GPBUInt64FloatDictionary alloc] initWithFloats:kValues1 forKeys:kKeys1 count:GPBARRAYSIZE(kValues1)]; XCTAssertNotNil(dict1prime); GPBUInt64FloatDictionary *dict2 = - [[GPBUInt64FloatDictionary alloc] initWithValues:kValues2 + [[GPBUInt64FloatDictionary alloc] initWithFloats:kValues2 forKeys:kKeys1 count:GPBARRAYSIZE(kValues2)]; XCTAssertNotNil(dict2); GPBUInt64FloatDictionary *dict3 = - [[GPBUInt64FloatDictionary alloc] initWithValues:kValues1 + [[GPBUInt64FloatDictionary alloc] initWithFloats:kValues1 forKeys:kKeys2 count:GPBARRAYSIZE(kValues1)]; XCTAssertNotNil(dict3); GPBUInt64FloatDictionary *dict4 = - [[GPBUInt64FloatDictionary alloc] initWithValues:kValues3 + [[GPBUInt64FloatDictionary alloc] initWithFloats:kValues3 forKeys:kKeys1 count:GPBARRAYSIZE(kValues3)]; XCTAssertNotNil(dict4); @@ -2016,7 +2016,7 @@ static BOOL TestingEnum_IsValidValue(int32_t value) { const uint64_t kKeys[] = { 31ULL, 32ULL, 33ULL, 34ULL }; const float kValues[] = { 500.f, 501.f, 502.f, 503.f }; GPBUInt64FloatDictionary *dict = - [[GPBUInt64FloatDictionary alloc] initWithValues:kValues + [[GPBUInt64FloatDictionary alloc] initWithFloats:kValues forKeys:kKeys count:GPBARRAYSIZE(kValues)]; XCTAssertNotNil(dict); @@ -2037,7 +2037,7 @@ static BOOL TestingEnum_IsValidValue(int32_t value) { const uint64_t kKeys[] = { 31ULL, 32ULL, 33ULL, 34ULL }; const float kValues[] = { 500.f, 501.f, 502.f, 503.f }; GPBUInt64FloatDictionary *dict = - [[GPBUInt64FloatDictionary alloc] initWithValues:kValues + [[GPBUInt64FloatDictionary alloc] initWithFloats:kValues forKeys:kKeys count:GPBARRAYSIZE(kValues)]; XCTAssertNotNil(dict); @@ -2057,13 +2057,13 @@ static BOOL TestingEnum_IsValidValue(int32_t value) { XCTAssertNotNil(dict); XCTAssertEqual(dict.count, 0U); - [dict setValue:500.f forKey:31ULL]; + [dict setFloat:500.f forKey:31ULL]; XCTAssertEqual(dict.count, 1U); const uint64_t kKeys[] = { 32ULL, 33ULL, 34ULL }; const float kValues[] = { 501.f, 502.f, 503.f }; GPBUInt64FloatDictionary *dict2 = - [[GPBUInt64FloatDictionary alloc] initWithValues:kValues + [[GPBUInt64FloatDictionary alloc] initWithFloats:kValues forKeys:kKeys count:GPBARRAYSIZE(kValues)]; XCTAssertNotNil(dict2); @@ -2071,17 +2071,17 @@ static BOOL TestingEnum_IsValidValue(int32_t value) { XCTAssertEqual(dict.count, 4U); float value; - XCTAssertTrue([dict valueForKey:31ULL value:NULL]); - XCTAssertTrue([dict valueForKey:31ULL value:&value]); + XCTAssertTrue([dict getFloat:NULL forKey:31ULL]); + XCTAssertTrue([dict getFloat:&value forKey:31ULL]); XCTAssertEqual(value, 500.f); - XCTAssertTrue([dict valueForKey:32ULL value:NULL]); - XCTAssertTrue([dict valueForKey:32ULL value:&value]); + XCTAssertTrue([dict getFloat:NULL forKey:32ULL]); + XCTAssertTrue([dict getFloat:&value forKey:32ULL]); XCTAssertEqual(value, 501.f); - XCTAssertTrue([dict valueForKey:33ULL value:NULL]); - XCTAssertTrue([dict valueForKey:33ULL value:&value]); + XCTAssertTrue([dict getFloat:NULL forKey:33ULL]); + XCTAssertTrue([dict getFloat:&value forKey:33ULL]); XCTAssertEqual(value, 502.f); - XCTAssertTrue([dict valueForKey:34ULL value:NULL]); - XCTAssertTrue([dict valueForKey:34ULL value:&value]); + XCTAssertTrue([dict getFloat:NULL forKey:34ULL]); + XCTAssertTrue([dict getFloat:&value forKey:34ULL]); XCTAssertEqual(value, 503.f); [dict2 release]; } @@ -2090,57 +2090,57 @@ static BOOL TestingEnum_IsValidValue(int32_t value) { const uint64_t kKeys[] = { 31ULL, 32ULL, 33ULL, 34ULL }; const float kValues[] = { 500.f, 501.f, 502.f, 503.f }; GPBUInt64FloatDictionary *dict = - [[GPBUInt64FloatDictionary alloc] initWithValues:kValues - forKeys:kKeys - count:GPBARRAYSIZE(kValues)]; + [[GPBUInt64FloatDictionary alloc] initWithFloats:kValues + forKeys:kKeys + count:GPBARRAYSIZE(kValues)]; XCTAssertNotNil(dict); XCTAssertEqual(dict.count, 4U); - [dict removeValueForKey:32ULL]; + [dict removeFloatForKey:32ULL]; XCTAssertEqual(dict.count, 3U); float value; - XCTAssertTrue([dict valueForKey:31ULL value:NULL]); - XCTAssertTrue([dict valueForKey:31ULL value:&value]); + XCTAssertTrue([dict getFloat:NULL forKey:31ULL]); + XCTAssertTrue([dict getFloat:&value forKey:31ULL]); XCTAssertEqual(value, 500.f); - XCTAssertFalse([dict valueForKey:32ULL value:NULL]); - XCTAssertTrue([dict valueForKey:33ULL value:NULL]); - XCTAssertTrue([dict valueForKey:33ULL value:&value]); + XCTAssertFalse([dict getFloat:NULL forKey:32ULL]); + XCTAssertTrue([dict getFloat:NULL forKey:33ULL]); + XCTAssertTrue([dict getFloat:&value forKey:33ULL]); XCTAssertEqual(value, 502.f); - XCTAssertTrue([dict valueForKey:34ULL value:NULL]); - XCTAssertTrue([dict valueForKey:34ULL value:&value]); + XCTAssertTrue([dict getFloat:NULL forKey:34ULL]); + XCTAssertTrue([dict getFloat:&value forKey:34ULL]); XCTAssertEqual(value, 503.f); // Remove again does nothing. - [dict removeValueForKey:32ULL]; + [dict removeFloatForKey:32ULL]; XCTAssertEqual(dict.count, 3U); - XCTAssertTrue([dict valueForKey:31ULL value:NULL]); - XCTAssertTrue([dict valueForKey:31ULL value:&value]); + XCTAssertTrue([dict getFloat:NULL forKey:31ULL]); + XCTAssertTrue([dict getFloat:&value forKey:31ULL]); XCTAssertEqual(value, 500.f); - XCTAssertFalse([dict valueForKey:32ULL value:NULL]); - XCTAssertTrue([dict valueForKey:33ULL value:NULL]); - XCTAssertTrue([dict valueForKey:33ULL value:&value]); + XCTAssertFalse([dict getFloat:NULL forKey:32ULL]); + XCTAssertTrue([dict getFloat:NULL forKey:33ULL]); + XCTAssertTrue([dict getFloat:&value forKey:33ULL]); XCTAssertEqual(value, 502.f); - XCTAssertTrue([dict valueForKey:34ULL value:NULL]); - XCTAssertTrue([dict valueForKey:34ULL value:&value]); + XCTAssertTrue([dict getFloat:NULL forKey:34ULL]); + XCTAssertTrue([dict getFloat:&value forKey:34ULL]); XCTAssertEqual(value, 503.f); - [dict removeValueForKey:34ULL]; + [dict removeFloatForKey:34ULL]; XCTAssertEqual(dict.count, 2U); - XCTAssertTrue([dict valueForKey:31ULL value:NULL]); - XCTAssertTrue([dict valueForKey:31ULL value:&value]); + XCTAssertTrue([dict getFloat:NULL forKey:31ULL]); + XCTAssertTrue([dict getFloat:&value forKey:31ULL]); XCTAssertEqual(value, 500.f); - XCTAssertFalse([dict valueForKey:32ULL value:NULL]); - XCTAssertTrue([dict valueForKey:33ULL value:NULL]); - XCTAssertTrue([dict valueForKey:33ULL value:&value]); + XCTAssertFalse([dict getFloat:NULL forKey:32ULL]); + XCTAssertTrue([dict getFloat:NULL forKey:33ULL]); + XCTAssertTrue([dict getFloat:&value forKey:33ULL]); XCTAssertEqual(value, 502.f); - XCTAssertFalse([dict valueForKey:34ULL value:NULL]); + XCTAssertFalse([dict getFloat:NULL forKey:34ULL]); [dict removeAll]; XCTAssertEqual(dict.count, 0U); - XCTAssertFalse([dict valueForKey:31ULL value:NULL]); - XCTAssertFalse([dict valueForKey:32ULL value:NULL]); - XCTAssertFalse([dict valueForKey:33ULL value:NULL]); - XCTAssertFalse([dict valueForKey:34ULL value:NULL]); + XCTAssertFalse([dict getFloat:NULL forKey:31ULL]); + XCTAssertFalse([dict getFloat:NULL forKey:32ULL]); + XCTAssertFalse([dict getFloat:NULL forKey:33ULL]); + XCTAssertFalse([dict getFloat:NULL forKey:34ULL]); [dict release]; } @@ -2148,75 +2148,75 @@ static BOOL TestingEnum_IsValidValue(int32_t value) { const uint64_t kKeys[] = { 31ULL, 32ULL, 33ULL, 34ULL }; const float kValues[] = { 500.f, 501.f, 502.f, 503.f }; GPBUInt64FloatDictionary *dict = - [[GPBUInt64FloatDictionary alloc] initWithValues:kValues - forKeys:kKeys - count:GPBARRAYSIZE(kValues)]; + [[GPBUInt64FloatDictionary alloc] initWithFloats:kValues + forKeys:kKeys + count:GPBARRAYSIZE(kValues)]; XCTAssertNotNil(dict); XCTAssertEqual(dict.count, 4U); float value; - XCTAssertTrue([dict valueForKey:31ULL value:NULL]); - XCTAssertTrue([dict valueForKey:31ULL value:&value]); + XCTAssertTrue([dict getFloat:NULL forKey:31ULL]); + XCTAssertTrue([dict getFloat:&value forKey:31ULL]); XCTAssertEqual(value, 500.f); - XCTAssertTrue([dict valueForKey:32ULL value:NULL]); - XCTAssertTrue([dict valueForKey:32ULL value:&value]); + XCTAssertTrue([dict getFloat:NULL forKey:32ULL]); + XCTAssertTrue([dict getFloat:&value forKey:32ULL]); XCTAssertEqual(value, 501.f); - XCTAssertTrue([dict valueForKey:33ULL value:NULL]); - XCTAssertTrue([dict valueForKey:33ULL value:&value]); + XCTAssertTrue([dict getFloat:NULL forKey:33ULL]); + XCTAssertTrue([dict getFloat:&value forKey:33ULL]); XCTAssertEqual(value, 502.f); - XCTAssertTrue([dict valueForKey:34ULL value:NULL]); - XCTAssertTrue([dict valueForKey:34ULL value:&value]); + XCTAssertTrue([dict getFloat:NULL forKey:34ULL]); + XCTAssertTrue([dict getFloat:&value forKey:34ULL]); XCTAssertEqual(value, 503.f); - [dict setValue:503.f forKey:31ULL]; + [dict setFloat:503.f forKey:31ULL]; XCTAssertEqual(dict.count, 4U); - XCTAssertTrue([dict valueForKey:31ULL value:NULL]); - XCTAssertTrue([dict valueForKey:31ULL value:&value]); + XCTAssertTrue([dict getFloat:NULL forKey:31ULL]); + XCTAssertTrue([dict getFloat:&value forKey:31ULL]); XCTAssertEqual(value, 503.f); - XCTAssertTrue([dict valueForKey:32ULL value:NULL]); - XCTAssertTrue([dict valueForKey:32ULL value:&value]); + XCTAssertTrue([dict getFloat:NULL forKey:32ULL]); + XCTAssertTrue([dict getFloat:&value forKey:32ULL]); XCTAssertEqual(value, 501.f); - XCTAssertTrue([dict valueForKey:33ULL value:NULL]); - XCTAssertTrue([dict valueForKey:33ULL value:&value]); + XCTAssertTrue([dict getFloat:NULL forKey:33ULL]); + XCTAssertTrue([dict getFloat:&value forKey:33ULL]); XCTAssertEqual(value, 502.f); - XCTAssertTrue([dict valueForKey:34ULL value:NULL]); - XCTAssertTrue([dict valueForKey:34ULL value:&value]); + XCTAssertTrue([dict getFloat:NULL forKey:34ULL]); + XCTAssertTrue([dict getFloat:&value forKey:34ULL]); XCTAssertEqual(value, 503.f); - [dict setValue:501.f forKey:34ULL]; + [dict setFloat:501.f forKey:34ULL]; XCTAssertEqual(dict.count, 4U); - XCTAssertTrue([dict valueForKey:31ULL value:NULL]); - XCTAssertTrue([dict valueForKey:31ULL value:&value]); + XCTAssertTrue([dict getFloat:NULL forKey:31ULL]); + XCTAssertTrue([dict getFloat:&value forKey:31ULL]); XCTAssertEqual(value, 503.f); - XCTAssertTrue([dict valueForKey:32ULL value:NULL]); - XCTAssertTrue([dict valueForKey:32ULL value:&value]); + XCTAssertTrue([dict getFloat:NULL forKey:32ULL]); + XCTAssertTrue([dict getFloat:&value forKey:32ULL]); XCTAssertEqual(value, 501.f); - XCTAssertTrue([dict valueForKey:33ULL value:NULL]); - XCTAssertTrue([dict valueForKey:33ULL value:&value]); + XCTAssertTrue([dict getFloat:NULL forKey:33ULL]); + XCTAssertTrue([dict getFloat:&value forKey:33ULL]); XCTAssertEqual(value, 502.f); - XCTAssertTrue([dict valueForKey:34ULL value:NULL]); - XCTAssertTrue([dict valueForKey:34ULL value:&value]); + XCTAssertTrue([dict getFloat:NULL forKey:34ULL]); + XCTAssertTrue([dict getFloat:&value forKey:34ULL]); XCTAssertEqual(value, 501.f); const uint64_t kKeys2[] = { 32ULL, 33ULL }; const float kValues2[] = { 502.f, 500.f }; GPBUInt64FloatDictionary *dict2 = - [[GPBUInt64FloatDictionary alloc] initWithValues:kValues2 + [[GPBUInt64FloatDictionary alloc] initWithFloats:kValues2 forKeys:kKeys2 count:GPBARRAYSIZE(kValues2)]; XCTAssertNotNil(dict2); [dict addEntriesFromDictionary:dict2]; XCTAssertEqual(dict.count, 4U); - XCTAssertTrue([dict valueForKey:31ULL value:NULL]); - XCTAssertTrue([dict valueForKey:31ULL value:&value]); + XCTAssertTrue([dict getFloat:NULL forKey:31ULL]); + XCTAssertTrue([dict getFloat:&value forKey:31ULL]); XCTAssertEqual(value, 503.f); - XCTAssertTrue([dict valueForKey:32ULL value:NULL]); - XCTAssertTrue([dict valueForKey:32ULL value:&value]); + XCTAssertTrue([dict getFloat:NULL forKey:32ULL]); + XCTAssertTrue([dict getFloat:&value forKey:32ULL]); XCTAssertEqual(value, 502.f); - XCTAssertTrue([dict valueForKey:33ULL value:NULL]); - XCTAssertTrue([dict valueForKey:33ULL value:&value]); + XCTAssertTrue([dict getFloat:NULL forKey:33ULL]); + XCTAssertTrue([dict getFloat:&value forKey:33ULL]); XCTAssertEqual(value, 500.f); - XCTAssertTrue([dict valueForKey:34ULL value:NULL]); - XCTAssertTrue([dict valueForKey:34ULL value:&value]); + XCTAssertTrue([dict getFloat:NULL forKey:34ULL]); + XCTAssertTrue([dict getFloat:&value forKey:34ULL]); XCTAssertEqual(value, 501.f); [dict2 release]; @@ -2236,8 +2236,8 @@ static BOOL TestingEnum_IsValidValue(int32_t value) { GPBUInt64DoubleDictionary *dict = [[GPBUInt64DoubleDictionary alloc] init]; XCTAssertNotNil(dict); XCTAssertEqual(dict.count, 0U); - XCTAssertFalse([dict valueForKey:31ULL value:NULL]); - [dict enumerateKeysAndValuesUsingBlock:^(uint64_t aKey, double aValue, BOOL *stop) { + XCTAssertFalse([dict getDouble:NULL forKey:31ULL]); + [dict enumerateKeysAndDoublesUsingBlock:^(uint64_t aKey, double aValue, BOOL *stop) { #pragma unused(aKey, aValue, stop) XCTFail(@"Shouldn't get here!"); }]; @@ -2245,15 +2245,15 @@ static BOOL TestingEnum_IsValidValue(int32_t value) { } - (void)testOne { - GPBUInt64DoubleDictionary *dict = [GPBUInt64DoubleDictionary dictionaryWithValue:600. forKey:31ULL]; + GPBUInt64DoubleDictionary *dict = [GPBUInt64DoubleDictionary dictionaryWithDouble:600. forKey:31ULL]; XCTAssertNotNil(dict); XCTAssertEqual(dict.count, 1U); double value; - XCTAssertTrue([dict valueForKey:31ULL value:NULL]); - XCTAssertTrue([dict valueForKey:31ULL value:&value]); + XCTAssertTrue([dict getDouble:NULL forKey:31ULL]); + XCTAssertTrue([dict getDouble:&value forKey:31ULL]); XCTAssertEqual(value, 600.); - XCTAssertFalse([dict valueForKey:32ULL value:NULL]); - [dict enumerateKeysAndValuesUsingBlock:^(uint64_t aKey, double aValue, BOOL *stop) { + XCTAssertFalse([dict getDouble:NULL forKey:32ULL]); + [dict enumerateKeysAndDoublesUsingBlock:^(uint64_t aKey, double aValue, BOOL *stop) { XCTAssertEqual(aKey, 31ULL); XCTAssertEqual(aValue, 600.); XCTAssertNotEqual(stop, NULL); @@ -2264,27 +2264,27 @@ static BOOL TestingEnum_IsValidValue(int32_t value) { const uint64_t kKeys[] = { 31ULL, 32ULL, 33ULL }; const double kValues[] = { 600., 601., 602. }; GPBUInt64DoubleDictionary *dict = - [[GPBUInt64DoubleDictionary alloc] initWithValues:kValues - forKeys:kKeys - count:GPBARRAYSIZE(kValues)]; + [[GPBUInt64DoubleDictionary alloc] initWithDoubles:kValues + forKeys:kKeys + count:GPBARRAYSIZE(kValues)]; XCTAssertNotNil(dict); XCTAssertEqual(dict.count, 3U); double value; - XCTAssertTrue([dict valueForKey:31ULL value:NULL]); - XCTAssertTrue([dict valueForKey:31ULL value:&value]); + XCTAssertTrue([dict getDouble:NULL forKey:31ULL]); + XCTAssertTrue([dict getDouble:&value forKey:31ULL]); XCTAssertEqual(value, 600.); - XCTAssertTrue([dict valueForKey:32ULL value:NULL]); - XCTAssertTrue([dict valueForKey:32ULL value:&value]); + XCTAssertTrue([dict getDouble:NULL forKey:32ULL]); + XCTAssertTrue([dict getDouble:&value forKey:32ULL]); XCTAssertEqual(value, 601.); - XCTAssertTrue([dict valueForKey:33ULL value:NULL]); - XCTAssertTrue([dict valueForKey:33ULL value:&value]); + XCTAssertTrue([dict getDouble:NULL forKey:33ULL]); + XCTAssertTrue([dict getDouble:&value forKey:33ULL]); XCTAssertEqual(value, 602.); - XCTAssertFalse([dict valueForKey:34ULL value:NULL]); + XCTAssertFalse([dict getDouble:NULL forKey:34ULL]); __block NSUInteger idx = 0; uint64_t *seenKeys = malloc(3 * sizeof(uint64_t)); double *seenValues = malloc(3 * sizeof(double)); - [dict enumerateKeysAndValuesUsingBlock:^(uint64_t aKey, double aValue, BOOL *stop) { + [dict enumerateKeysAndDoublesUsingBlock:^(uint64_t aKey, double aValue, BOOL *stop) { XCTAssertLessThan(idx, 3U); seenKeys[idx] = aKey; seenValues[idx] = aValue; @@ -2306,7 +2306,7 @@ static BOOL TestingEnum_IsValidValue(int32_t value) { // Stopping the enumeration. idx = 0; - [dict enumerateKeysAndValuesUsingBlock:^(uint64_t aKey, double aValue, BOOL *stop) { + [dict enumerateKeysAndDoublesUsingBlock:^(uint64_t aKey, double aValue, BOOL *stop) { #pragma unused(aKey, aValue) if (idx == 1) *stop = YES; XCTAssertNotEqual(idx, 2U); @@ -2322,29 +2322,29 @@ static BOOL TestingEnum_IsValidValue(int32_t value) { const double kValues2[] = { 600., 603., 602. }; const double kValues3[] = { 600., 601., 602., 603. }; GPBUInt64DoubleDictionary *dict1 = - [[GPBUInt64DoubleDictionary alloc] initWithValues:kValues1 - forKeys:kKeys1 - count:GPBARRAYSIZE(kValues1)]; + [[GPBUInt64DoubleDictionary alloc] initWithDoubles:kValues1 + forKeys:kKeys1 + count:GPBARRAYSIZE(kValues1)]; XCTAssertNotNil(dict1); GPBUInt64DoubleDictionary *dict1prime = - [[GPBUInt64DoubleDictionary alloc] initWithValues:kValues1 - forKeys:kKeys1 - count:GPBARRAYSIZE(kValues1)]; + [[GPBUInt64DoubleDictionary alloc] initWithDoubles:kValues1 + forKeys:kKeys1 + count:GPBARRAYSIZE(kValues1)]; XCTAssertNotNil(dict1prime); GPBUInt64DoubleDictionary *dict2 = - [[GPBUInt64DoubleDictionary alloc] initWithValues:kValues2 - forKeys:kKeys1 - count:GPBARRAYSIZE(kValues2)]; + [[GPBUInt64DoubleDictionary alloc] initWithDoubles:kValues2 + forKeys:kKeys1 + count:GPBARRAYSIZE(kValues2)]; XCTAssertNotNil(dict2); GPBUInt64DoubleDictionary *dict3 = - [[GPBUInt64DoubleDictionary alloc] initWithValues:kValues1 - forKeys:kKeys2 - count:GPBARRAYSIZE(kValues1)]; + [[GPBUInt64DoubleDictionary alloc] initWithDoubles:kValues1 + forKeys:kKeys2 + count:GPBARRAYSIZE(kValues1)]; XCTAssertNotNil(dict3); GPBUInt64DoubleDictionary *dict4 = - [[GPBUInt64DoubleDictionary alloc] initWithValues:kValues3 - forKeys:kKeys1 - count:GPBARRAYSIZE(kValues3)]; + [[GPBUInt64DoubleDictionary alloc] initWithDoubles:kValues3 + forKeys:kKeys1 + count:GPBARRAYSIZE(kValues3)]; XCTAssertNotNil(dict4); // 1/1Prime should be different objects, but equal. @@ -2373,9 +2373,9 @@ static BOOL TestingEnum_IsValidValue(int32_t value) { const uint64_t kKeys[] = { 31ULL, 32ULL, 33ULL, 34ULL }; const double kValues[] = { 600., 601., 602., 603. }; GPBUInt64DoubleDictionary *dict = - [[GPBUInt64DoubleDictionary alloc] initWithValues:kValues - forKeys:kKeys - count:GPBARRAYSIZE(kValues)]; + [[GPBUInt64DoubleDictionary alloc] initWithDoubles:kValues + forKeys:kKeys + count:GPBARRAYSIZE(kValues)]; XCTAssertNotNil(dict); GPBUInt64DoubleDictionary *dict2 = [dict copy]; @@ -2394,9 +2394,9 @@ static BOOL TestingEnum_IsValidValue(int32_t value) { const uint64_t kKeys[] = { 31ULL, 32ULL, 33ULL, 34ULL }; const double kValues[] = { 600., 601., 602., 603. }; GPBUInt64DoubleDictionary *dict = - [[GPBUInt64DoubleDictionary alloc] initWithValues:kValues - forKeys:kKeys - count:GPBARRAYSIZE(kValues)]; + [[GPBUInt64DoubleDictionary alloc] initWithDoubles:kValues + forKeys:kKeys + count:GPBARRAYSIZE(kValues)]; XCTAssertNotNil(dict); GPBUInt64DoubleDictionary *dict2 = @@ -2414,31 +2414,31 @@ static BOOL TestingEnum_IsValidValue(int32_t value) { XCTAssertNotNil(dict); XCTAssertEqual(dict.count, 0U); - [dict setValue:600. forKey:31ULL]; + [dict setDouble:600. forKey:31ULL]; XCTAssertEqual(dict.count, 1U); const uint64_t kKeys[] = { 32ULL, 33ULL, 34ULL }; const double kValues[] = { 601., 602., 603. }; GPBUInt64DoubleDictionary *dict2 = - [[GPBUInt64DoubleDictionary alloc] initWithValues:kValues - forKeys:kKeys - count:GPBARRAYSIZE(kValues)]; + [[GPBUInt64DoubleDictionary alloc] initWithDoubles:kValues + forKeys:kKeys + count:GPBARRAYSIZE(kValues)]; XCTAssertNotNil(dict2); [dict addEntriesFromDictionary:dict2]; XCTAssertEqual(dict.count, 4U); double value; - XCTAssertTrue([dict valueForKey:31ULL value:NULL]); - XCTAssertTrue([dict valueForKey:31ULL value:&value]); + XCTAssertTrue([dict getDouble:NULL forKey:31ULL]); + XCTAssertTrue([dict getDouble:&value forKey:31ULL]); XCTAssertEqual(value, 600.); - XCTAssertTrue([dict valueForKey:32ULL value:NULL]); - XCTAssertTrue([dict valueForKey:32ULL value:&value]); + XCTAssertTrue([dict getDouble:NULL forKey:32ULL]); + XCTAssertTrue([dict getDouble:&value forKey:32ULL]); XCTAssertEqual(value, 601.); - XCTAssertTrue([dict valueForKey:33ULL value:NULL]); - XCTAssertTrue([dict valueForKey:33ULL value:&value]); + XCTAssertTrue([dict getDouble:NULL forKey:33ULL]); + XCTAssertTrue([dict getDouble:&value forKey:33ULL]); XCTAssertEqual(value, 602.); - XCTAssertTrue([dict valueForKey:34ULL value:NULL]); - XCTAssertTrue([dict valueForKey:34ULL value:&value]); + XCTAssertTrue([dict getDouble:NULL forKey:34ULL]); + XCTAssertTrue([dict getDouble:&value forKey:34ULL]); XCTAssertEqual(value, 603.); [dict2 release]; } @@ -2447,57 +2447,57 @@ static BOOL TestingEnum_IsValidValue(int32_t value) { const uint64_t kKeys[] = { 31ULL, 32ULL, 33ULL, 34ULL }; const double kValues[] = { 600., 601., 602., 603. }; GPBUInt64DoubleDictionary *dict = - [[GPBUInt64DoubleDictionary alloc] initWithValues:kValues - forKeys:kKeys - count:GPBARRAYSIZE(kValues)]; + [[GPBUInt64DoubleDictionary alloc] initWithDoubles:kValues + forKeys:kKeys + count:GPBARRAYSIZE(kValues)]; XCTAssertNotNil(dict); XCTAssertEqual(dict.count, 4U); - [dict removeValueForKey:32ULL]; + [dict removeDoubleForKey:32ULL]; XCTAssertEqual(dict.count, 3U); double value; - XCTAssertTrue([dict valueForKey:31ULL value:NULL]); - XCTAssertTrue([dict valueForKey:31ULL value:&value]); + XCTAssertTrue([dict getDouble:NULL forKey:31ULL]); + XCTAssertTrue([dict getDouble:&value forKey:31ULL]); XCTAssertEqual(value, 600.); - XCTAssertFalse([dict valueForKey:32ULL value:NULL]); - XCTAssertTrue([dict valueForKey:33ULL value:NULL]); - XCTAssertTrue([dict valueForKey:33ULL value:&value]); + XCTAssertFalse([dict getDouble:NULL forKey:32ULL]); + XCTAssertTrue([dict getDouble:NULL forKey:33ULL]); + XCTAssertTrue([dict getDouble:&value forKey:33ULL]); XCTAssertEqual(value, 602.); - XCTAssertTrue([dict valueForKey:34ULL value:NULL]); - XCTAssertTrue([dict valueForKey:34ULL value:&value]); + XCTAssertTrue([dict getDouble:NULL forKey:34ULL]); + XCTAssertTrue([dict getDouble:&value forKey:34ULL]); XCTAssertEqual(value, 603.); // Remove again does nothing. - [dict removeValueForKey:32ULL]; + [dict removeDoubleForKey:32ULL]; XCTAssertEqual(dict.count, 3U); - XCTAssertTrue([dict valueForKey:31ULL value:NULL]); - XCTAssertTrue([dict valueForKey:31ULL value:&value]); + XCTAssertTrue([dict getDouble:NULL forKey:31ULL]); + XCTAssertTrue([dict getDouble:&value forKey:31ULL]); XCTAssertEqual(value, 600.); - XCTAssertFalse([dict valueForKey:32ULL value:NULL]); - XCTAssertTrue([dict valueForKey:33ULL value:NULL]); - XCTAssertTrue([dict valueForKey:33ULL value:&value]); + XCTAssertFalse([dict getDouble:NULL forKey:32ULL]); + XCTAssertTrue([dict getDouble:NULL forKey:33ULL]); + XCTAssertTrue([dict getDouble:&value forKey:33ULL]); XCTAssertEqual(value, 602.); - XCTAssertTrue([dict valueForKey:34ULL value:NULL]); - XCTAssertTrue([dict valueForKey:34ULL value:&value]); + XCTAssertTrue([dict getDouble:NULL forKey:34ULL]); + XCTAssertTrue([dict getDouble:&value forKey:34ULL]); XCTAssertEqual(value, 603.); - [dict removeValueForKey:34ULL]; + [dict removeDoubleForKey:34ULL]; XCTAssertEqual(dict.count, 2U); - XCTAssertTrue([dict valueForKey:31ULL value:NULL]); - XCTAssertTrue([dict valueForKey:31ULL value:&value]); + XCTAssertTrue([dict getDouble:NULL forKey:31ULL]); + XCTAssertTrue([dict getDouble:&value forKey:31ULL]); XCTAssertEqual(value, 600.); - XCTAssertFalse([dict valueForKey:32ULL value:NULL]); - XCTAssertTrue([dict valueForKey:33ULL value:NULL]); - XCTAssertTrue([dict valueForKey:33ULL value:&value]); + XCTAssertFalse([dict getDouble:NULL forKey:32ULL]); + XCTAssertTrue([dict getDouble:NULL forKey:33ULL]); + XCTAssertTrue([dict getDouble:&value forKey:33ULL]); XCTAssertEqual(value, 602.); - XCTAssertFalse([dict valueForKey:34ULL value:NULL]); + XCTAssertFalse([dict getDouble:NULL forKey:34ULL]); [dict removeAll]; XCTAssertEqual(dict.count, 0U); - XCTAssertFalse([dict valueForKey:31ULL value:NULL]); - XCTAssertFalse([dict valueForKey:32ULL value:NULL]); - XCTAssertFalse([dict valueForKey:33ULL value:NULL]); - XCTAssertFalse([dict valueForKey:34ULL value:NULL]); + XCTAssertFalse([dict getDouble:NULL forKey:31ULL]); + XCTAssertFalse([dict getDouble:NULL forKey:32ULL]); + XCTAssertFalse([dict getDouble:NULL forKey:33ULL]); + XCTAssertFalse([dict getDouble:NULL forKey:34ULL]); [dict release]; } @@ -2505,75 +2505,75 @@ static BOOL TestingEnum_IsValidValue(int32_t value) { const uint64_t kKeys[] = { 31ULL, 32ULL, 33ULL, 34ULL }; const double kValues[] = { 600., 601., 602., 603. }; GPBUInt64DoubleDictionary *dict = - [[GPBUInt64DoubleDictionary alloc] initWithValues:kValues - forKeys:kKeys - count:GPBARRAYSIZE(kValues)]; + [[GPBUInt64DoubleDictionary alloc] initWithDoubles:kValues + forKeys:kKeys + count:GPBARRAYSIZE(kValues)]; XCTAssertNotNil(dict); XCTAssertEqual(dict.count, 4U); double value; - XCTAssertTrue([dict valueForKey:31ULL value:NULL]); - XCTAssertTrue([dict valueForKey:31ULL value:&value]); + XCTAssertTrue([dict getDouble:NULL forKey:31ULL]); + XCTAssertTrue([dict getDouble:&value forKey:31ULL]); XCTAssertEqual(value, 600.); - XCTAssertTrue([dict valueForKey:32ULL value:NULL]); - XCTAssertTrue([dict valueForKey:32ULL value:&value]); + XCTAssertTrue([dict getDouble:NULL forKey:32ULL]); + XCTAssertTrue([dict getDouble:&value forKey:32ULL]); XCTAssertEqual(value, 601.); - XCTAssertTrue([dict valueForKey:33ULL value:NULL]); - XCTAssertTrue([dict valueForKey:33ULL value:&value]); + XCTAssertTrue([dict getDouble:NULL forKey:33ULL]); + XCTAssertTrue([dict getDouble:&value forKey:33ULL]); XCTAssertEqual(value, 602.); - XCTAssertTrue([dict valueForKey:34ULL value:NULL]); - XCTAssertTrue([dict valueForKey:34ULL value:&value]); + XCTAssertTrue([dict getDouble:NULL forKey:34ULL]); + XCTAssertTrue([dict getDouble:&value forKey:34ULL]); XCTAssertEqual(value, 603.); - [dict setValue:603. forKey:31ULL]; + [dict setDouble:603. forKey:31ULL]; XCTAssertEqual(dict.count, 4U); - XCTAssertTrue([dict valueForKey:31ULL value:NULL]); - XCTAssertTrue([dict valueForKey:31ULL value:&value]); + XCTAssertTrue([dict getDouble:NULL forKey:31ULL]); + XCTAssertTrue([dict getDouble:&value forKey:31ULL]); XCTAssertEqual(value, 603.); - XCTAssertTrue([dict valueForKey:32ULL value:NULL]); - XCTAssertTrue([dict valueForKey:32ULL value:&value]); + XCTAssertTrue([dict getDouble:NULL forKey:32ULL]); + XCTAssertTrue([dict getDouble:&value forKey:32ULL]); XCTAssertEqual(value, 601.); - XCTAssertTrue([dict valueForKey:33ULL value:NULL]); - XCTAssertTrue([dict valueForKey:33ULL value:&value]); + XCTAssertTrue([dict getDouble:NULL forKey:33ULL]); + XCTAssertTrue([dict getDouble:&value forKey:33ULL]); XCTAssertEqual(value, 602.); - XCTAssertTrue([dict valueForKey:34ULL value:NULL]); - XCTAssertTrue([dict valueForKey:34ULL value:&value]); + XCTAssertTrue([dict getDouble:NULL forKey:34ULL]); + XCTAssertTrue([dict getDouble:&value forKey:34ULL]); XCTAssertEqual(value, 603.); - [dict setValue:601. forKey:34ULL]; + [dict setDouble:601. forKey:34ULL]; XCTAssertEqual(dict.count, 4U); - XCTAssertTrue([dict valueForKey:31ULL value:NULL]); - XCTAssertTrue([dict valueForKey:31ULL value:&value]); + XCTAssertTrue([dict getDouble:NULL forKey:31ULL]); + XCTAssertTrue([dict getDouble:&value forKey:31ULL]); XCTAssertEqual(value, 603.); - XCTAssertTrue([dict valueForKey:32ULL value:NULL]); - XCTAssertTrue([dict valueForKey:32ULL value:&value]); + XCTAssertTrue([dict getDouble:NULL forKey:32ULL]); + XCTAssertTrue([dict getDouble:&value forKey:32ULL]); XCTAssertEqual(value, 601.); - XCTAssertTrue([dict valueForKey:33ULL value:NULL]); - XCTAssertTrue([dict valueForKey:33ULL value:&value]); + XCTAssertTrue([dict getDouble:NULL forKey:33ULL]); + XCTAssertTrue([dict getDouble:&value forKey:33ULL]); XCTAssertEqual(value, 602.); - XCTAssertTrue([dict valueForKey:34ULL value:NULL]); - XCTAssertTrue([dict valueForKey:34ULL value:&value]); + XCTAssertTrue([dict getDouble:NULL forKey:34ULL]); + XCTAssertTrue([dict getDouble:&value forKey:34ULL]); XCTAssertEqual(value, 601.); const uint64_t kKeys2[] = { 32ULL, 33ULL }; const double kValues2[] = { 602., 600. }; GPBUInt64DoubleDictionary *dict2 = - [[GPBUInt64DoubleDictionary alloc] initWithValues:kValues2 - forKeys:kKeys2 - count:GPBARRAYSIZE(kValues2)]; + [[GPBUInt64DoubleDictionary alloc] initWithDoubles:kValues2 + forKeys:kKeys2 + count:GPBARRAYSIZE(kValues2)]; XCTAssertNotNil(dict2); [dict addEntriesFromDictionary:dict2]; XCTAssertEqual(dict.count, 4U); - XCTAssertTrue([dict valueForKey:31ULL value:NULL]); - XCTAssertTrue([dict valueForKey:31ULL value:&value]); + XCTAssertTrue([dict getDouble:NULL forKey:31ULL]); + XCTAssertTrue([dict getDouble:&value forKey:31ULL]); XCTAssertEqual(value, 603.); - XCTAssertTrue([dict valueForKey:32ULL value:NULL]); - XCTAssertTrue([dict valueForKey:32ULL value:&value]); + XCTAssertTrue([dict getDouble:NULL forKey:32ULL]); + XCTAssertTrue([dict getDouble:&value forKey:32ULL]); XCTAssertEqual(value, 602.); - XCTAssertTrue([dict valueForKey:33ULL value:NULL]); - XCTAssertTrue([dict valueForKey:33ULL value:&value]); + XCTAssertTrue([dict getDouble:NULL forKey:33ULL]); + XCTAssertTrue([dict getDouble:&value forKey:33ULL]); XCTAssertEqual(value, 600.); - XCTAssertTrue([dict valueForKey:34ULL value:NULL]); - XCTAssertTrue([dict valueForKey:34ULL value:&value]); + XCTAssertTrue([dict getDouble:NULL forKey:34ULL]); + XCTAssertTrue([dict getDouble:&value forKey:34ULL]); XCTAssertEqual(value, 601.); [dict2 release]; @@ -2593,8 +2593,8 @@ static BOOL TestingEnum_IsValidValue(int32_t value) { GPBUInt64EnumDictionary *dict = [[GPBUInt64EnumDictionary alloc] init]; XCTAssertNotNil(dict); XCTAssertEqual(dict.count, 0U); - XCTAssertFalse([dict valueForKey:31ULL value:NULL]); - [dict enumerateKeysAndValuesUsingBlock:^(uint64_t aKey, int32_t aValue, BOOL *stop) { + XCTAssertFalse([dict getEnum:NULL forKey:31ULL]); + [dict enumerateKeysAndEnumsUsingBlock:^(uint64_t aKey, int32_t aValue, BOOL *stop) { #pragma unused(aKey, aValue, stop) XCTFail(@"Shouldn't get here!"); }]; @@ -2602,15 +2602,15 @@ static BOOL TestingEnum_IsValidValue(int32_t value) { } - (void)testOne { - GPBUInt64EnumDictionary *dict = [GPBUInt64EnumDictionary dictionaryWithValue:700 forKey:31ULL]; + GPBUInt64EnumDictionary *dict = [GPBUInt64EnumDictionary dictionaryWithEnum:700 forKey:31ULL]; XCTAssertNotNil(dict); XCTAssertEqual(dict.count, 1U); int32_t value; - XCTAssertTrue([dict valueForKey:31ULL value:NULL]); - XCTAssertTrue([dict valueForKey:31ULL value:&value]); + XCTAssertTrue([dict getEnum:NULL forKey:31ULL]); + XCTAssertTrue([dict getEnum:&value forKey:31ULL]); XCTAssertEqual(value, 700); - XCTAssertFalse([dict valueForKey:32ULL value:NULL]); - [dict enumerateKeysAndValuesUsingBlock:^(uint64_t aKey, int32_t aValue, BOOL *stop) { + XCTAssertFalse([dict getEnum:NULL forKey:32ULL]); + [dict enumerateKeysAndEnumsUsingBlock:^(uint64_t aKey, int32_t aValue, BOOL *stop) { XCTAssertEqual(aKey, 31ULL); XCTAssertEqual(aValue, 700); XCTAssertNotEqual(stop, NULL); @@ -2621,27 +2621,27 @@ static BOOL TestingEnum_IsValidValue(int32_t value) { const uint64_t kKeys[] = { 31ULL, 32ULL, 33ULL }; const int32_t kValues[] = { 700, 701, 702 }; GPBUInt64EnumDictionary *dict = - [[GPBUInt64EnumDictionary alloc] initWithValues:kValues - forKeys:kKeys - count:GPBARRAYSIZE(kValues)]; + [[GPBUInt64EnumDictionary alloc] initWithEnums:kValues + forKeys:kKeys + count:GPBARRAYSIZE(kValues)]; XCTAssertNotNil(dict); XCTAssertEqual(dict.count, 3U); int32_t value; - XCTAssertTrue([dict valueForKey:31ULL value:NULL]); - XCTAssertTrue([dict valueForKey:31ULL value:&value]); + XCTAssertTrue([dict getEnum:NULL forKey:31ULL]); + XCTAssertTrue([dict getEnum:&value forKey:31ULL]); XCTAssertEqual(value, 700); - XCTAssertTrue([dict valueForKey:32ULL value:NULL]); - XCTAssertTrue([dict valueForKey:32ULL value:&value]); + XCTAssertTrue([dict getEnum:NULL forKey:32ULL]); + XCTAssertTrue([dict getEnum:&value forKey:32ULL]); XCTAssertEqual(value, 701); - XCTAssertTrue([dict valueForKey:33ULL value:NULL]); - XCTAssertTrue([dict valueForKey:33ULL value:&value]); + XCTAssertTrue([dict getEnum:NULL forKey:33ULL]); + XCTAssertTrue([dict getEnum:&value forKey:33ULL]); XCTAssertEqual(value, 702); - XCTAssertFalse([dict valueForKey:34ULL value:NULL]); + XCTAssertFalse([dict getEnum:NULL forKey:34ULL]); __block NSUInteger idx = 0; uint64_t *seenKeys = malloc(3 * sizeof(uint64_t)); int32_t *seenValues = malloc(3 * sizeof(int32_t)); - [dict enumerateKeysAndValuesUsingBlock:^(uint64_t aKey, int32_t aValue, BOOL *stop) { + [dict enumerateKeysAndEnumsUsingBlock:^(uint64_t aKey, int32_t aValue, BOOL *stop) { XCTAssertLessThan(idx, 3U); seenKeys[idx] = aKey; seenValues[idx] = aValue; @@ -2663,7 +2663,7 @@ static BOOL TestingEnum_IsValidValue(int32_t value) { // Stopping the enumeration. idx = 0; - [dict enumerateKeysAndValuesUsingBlock:^(uint64_t aKey, int32_t aValue, BOOL *stop) { + [dict enumerateKeysAndEnumsUsingBlock:^(uint64_t aKey, int32_t aValue, BOOL *stop) { #pragma unused(aKey, aValue) if (idx == 1) *stop = YES; XCTAssertNotEqual(idx, 2U); @@ -2679,29 +2679,29 @@ static BOOL TestingEnum_IsValidValue(int32_t value) { const int32_t kValues2[] = { 700, 703, 702 }; const int32_t kValues3[] = { 700, 701, 702, 703 }; GPBUInt64EnumDictionary *dict1 = - [[GPBUInt64EnumDictionary alloc] initWithValues:kValues1 - forKeys:kKeys1 - count:GPBARRAYSIZE(kValues1)]; + [[GPBUInt64EnumDictionary alloc] initWithEnums:kValues1 + forKeys:kKeys1 + count:GPBARRAYSIZE(kValues1)]; XCTAssertNotNil(dict1); GPBUInt64EnumDictionary *dict1prime = - [[GPBUInt64EnumDictionary alloc] initWithValues:kValues1 - forKeys:kKeys1 - count:GPBARRAYSIZE(kValues1)]; + [[GPBUInt64EnumDictionary alloc] initWithEnums:kValues1 + forKeys:kKeys1 + count:GPBARRAYSIZE(kValues1)]; XCTAssertNotNil(dict1prime); GPBUInt64EnumDictionary *dict2 = - [[GPBUInt64EnumDictionary alloc] initWithValues:kValues2 - forKeys:kKeys1 - count:GPBARRAYSIZE(kValues2)]; + [[GPBUInt64EnumDictionary alloc] initWithEnums:kValues2 + forKeys:kKeys1 + count:GPBARRAYSIZE(kValues2)]; XCTAssertNotNil(dict2); GPBUInt64EnumDictionary *dict3 = - [[GPBUInt64EnumDictionary alloc] initWithValues:kValues1 - forKeys:kKeys2 - count:GPBARRAYSIZE(kValues1)]; + [[GPBUInt64EnumDictionary alloc] initWithEnums:kValues1 + forKeys:kKeys2 + count:GPBARRAYSIZE(kValues1)]; XCTAssertNotNil(dict3); GPBUInt64EnumDictionary *dict4 = - [[GPBUInt64EnumDictionary alloc] initWithValues:kValues3 - forKeys:kKeys1 - count:GPBARRAYSIZE(kValues3)]; + [[GPBUInt64EnumDictionary alloc] initWithEnums:kValues3 + forKeys:kKeys1 + count:GPBARRAYSIZE(kValues3)]; XCTAssertNotNil(dict4); // 1/1Prime should be different objects, but equal. @@ -2730,9 +2730,9 @@ static BOOL TestingEnum_IsValidValue(int32_t value) { const uint64_t kKeys[] = { 31ULL, 32ULL, 33ULL, 34ULL }; const int32_t kValues[] = { 700, 701, 702, 703 }; GPBUInt64EnumDictionary *dict = - [[GPBUInt64EnumDictionary alloc] initWithValues:kValues - forKeys:kKeys - count:GPBARRAYSIZE(kValues)]; + [[GPBUInt64EnumDictionary alloc] initWithEnums:kValues + forKeys:kKeys + count:GPBARRAYSIZE(kValues)]; XCTAssertNotNil(dict); GPBUInt64EnumDictionary *dict2 = [dict copy]; @@ -2751,9 +2751,9 @@ static BOOL TestingEnum_IsValidValue(int32_t value) { const uint64_t kKeys[] = { 31ULL, 32ULL, 33ULL, 34ULL }; const int32_t kValues[] = { 700, 701, 702, 703 }; GPBUInt64EnumDictionary *dict = - [[GPBUInt64EnumDictionary alloc] initWithValues:kValues - forKeys:kKeys - count:GPBARRAYSIZE(kValues)]; + [[GPBUInt64EnumDictionary alloc] initWithEnums:kValues + forKeys:kKeys + count:GPBARRAYSIZE(kValues)]; XCTAssertNotNil(dict); GPBUInt64EnumDictionary *dict2 = @@ -2771,31 +2771,31 @@ static BOOL TestingEnum_IsValidValue(int32_t value) { XCTAssertNotNil(dict); XCTAssertEqual(dict.count, 0U); - [dict setValue:700 forKey:31ULL]; + [dict setEnum:700 forKey:31ULL]; XCTAssertEqual(dict.count, 1U); const uint64_t kKeys[] = { 32ULL, 33ULL, 34ULL }; const int32_t kValues[] = { 701, 702, 703 }; GPBUInt64EnumDictionary *dict2 = - [[GPBUInt64EnumDictionary alloc] initWithValues:kValues - forKeys:kKeys - count:GPBARRAYSIZE(kValues)]; + [[GPBUInt64EnumDictionary alloc] initWithEnums:kValues + forKeys:kKeys + count:GPBARRAYSIZE(kValues)]; XCTAssertNotNil(dict2); [dict addRawEntriesFromDictionary:dict2]; XCTAssertEqual(dict.count, 4U); int32_t value; - XCTAssertTrue([dict valueForKey:31ULL value:NULL]); - XCTAssertTrue([dict valueForKey:31ULL value:&value]); + XCTAssertTrue([dict getEnum:NULL forKey:31ULL]); + XCTAssertTrue([dict getEnum:&value forKey:31ULL]); XCTAssertEqual(value, 700); - XCTAssertTrue([dict valueForKey:32ULL value:NULL]); - XCTAssertTrue([dict valueForKey:32ULL value:&value]); + XCTAssertTrue([dict getEnum:NULL forKey:32ULL]); + XCTAssertTrue([dict getEnum:&value forKey:32ULL]); XCTAssertEqual(value, 701); - XCTAssertTrue([dict valueForKey:33ULL value:NULL]); - XCTAssertTrue([dict valueForKey:33ULL value:&value]); + XCTAssertTrue([dict getEnum:NULL forKey:33ULL]); + XCTAssertTrue([dict getEnum:&value forKey:33ULL]); XCTAssertEqual(value, 702); - XCTAssertTrue([dict valueForKey:34ULL value:NULL]); - XCTAssertTrue([dict valueForKey:34ULL value:&value]); + XCTAssertTrue([dict getEnum:NULL forKey:34ULL]); + XCTAssertTrue([dict getEnum:&value forKey:34ULL]); XCTAssertEqual(value, 703); [dict2 release]; } @@ -2804,57 +2804,57 @@ static BOOL TestingEnum_IsValidValue(int32_t value) { const uint64_t kKeys[] = { 31ULL, 32ULL, 33ULL, 34ULL }; const int32_t kValues[] = { 700, 701, 702, 703 }; GPBUInt64EnumDictionary *dict = - [[GPBUInt64EnumDictionary alloc] initWithValues:kValues - forKeys:kKeys - count:GPBARRAYSIZE(kValues)]; + [[GPBUInt64EnumDictionary alloc] initWithEnums:kValues + forKeys:kKeys + count:GPBARRAYSIZE(kValues)]; XCTAssertNotNil(dict); XCTAssertEqual(dict.count, 4U); - [dict removeValueForKey:32ULL]; + [dict removeEnumForKey:32ULL]; XCTAssertEqual(dict.count, 3U); int32_t value; - XCTAssertTrue([dict valueForKey:31ULL value:NULL]); - XCTAssertTrue([dict valueForKey:31ULL value:&value]); + XCTAssertTrue([dict getEnum:NULL forKey:31ULL]); + XCTAssertTrue([dict getEnum:&value forKey:31ULL]); XCTAssertEqual(value, 700); - XCTAssertFalse([dict valueForKey:32ULL value:NULL]); - XCTAssertTrue([dict valueForKey:33ULL value:NULL]); - XCTAssertTrue([dict valueForKey:33ULL value:&value]); + XCTAssertFalse([dict getEnum:NULL forKey:32ULL]); + XCTAssertTrue([dict getEnum:NULL forKey:33ULL]); + XCTAssertTrue([dict getEnum:&value forKey:33ULL]); XCTAssertEqual(value, 702); - XCTAssertTrue([dict valueForKey:34ULL value:NULL]); - XCTAssertTrue([dict valueForKey:34ULL value:&value]); + XCTAssertTrue([dict getEnum:NULL forKey:34ULL]); + XCTAssertTrue([dict getEnum:&value forKey:34ULL]); XCTAssertEqual(value, 703); // Remove again does nothing. - [dict removeValueForKey:32ULL]; + [dict removeEnumForKey:32ULL]; XCTAssertEqual(dict.count, 3U); - XCTAssertTrue([dict valueForKey:31ULL value:NULL]); - XCTAssertTrue([dict valueForKey:31ULL value:&value]); + XCTAssertTrue([dict getEnum:NULL forKey:31ULL]); + XCTAssertTrue([dict getEnum:&value forKey:31ULL]); XCTAssertEqual(value, 700); - XCTAssertFalse([dict valueForKey:32ULL value:NULL]); - XCTAssertTrue([dict valueForKey:33ULL value:NULL]); - XCTAssertTrue([dict valueForKey:33ULL value:&value]); + XCTAssertFalse([dict getEnum:NULL forKey:32ULL]); + XCTAssertTrue([dict getEnum:NULL forKey:33ULL]); + XCTAssertTrue([dict getEnum:&value forKey:33ULL]); XCTAssertEqual(value, 702); - XCTAssertTrue([dict valueForKey:34ULL value:NULL]); - XCTAssertTrue([dict valueForKey:34ULL value:&value]); + XCTAssertTrue([dict getEnum:NULL forKey:34ULL]); + XCTAssertTrue([dict getEnum:&value forKey:34ULL]); XCTAssertEqual(value, 703); - [dict removeValueForKey:34ULL]; + [dict removeEnumForKey:34ULL]; XCTAssertEqual(dict.count, 2U); - XCTAssertTrue([dict valueForKey:31ULL value:NULL]); - XCTAssertTrue([dict valueForKey:31ULL value:&value]); + XCTAssertTrue([dict getEnum:NULL forKey:31ULL]); + XCTAssertTrue([dict getEnum:&value forKey:31ULL]); XCTAssertEqual(value, 700); - XCTAssertFalse([dict valueForKey:32ULL value:NULL]); - XCTAssertTrue([dict valueForKey:33ULL value:NULL]); - XCTAssertTrue([dict valueForKey:33ULL value:&value]); + XCTAssertFalse([dict getEnum:NULL forKey:32ULL]); + XCTAssertTrue([dict getEnum:NULL forKey:33ULL]); + XCTAssertTrue([dict getEnum:&value forKey:33ULL]); XCTAssertEqual(value, 702); - XCTAssertFalse([dict valueForKey:34ULL value:NULL]); + XCTAssertFalse([dict getEnum:NULL forKey:34ULL]); [dict removeAll]; XCTAssertEqual(dict.count, 0U); - XCTAssertFalse([dict valueForKey:31ULL value:NULL]); - XCTAssertFalse([dict valueForKey:32ULL value:NULL]); - XCTAssertFalse([dict valueForKey:33ULL value:NULL]); - XCTAssertFalse([dict valueForKey:34ULL value:NULL]); + XCTAssertFalse([dict getEnum:NULL forKey:31ULL]); + XCTAssertFalse([dict getEnum:NULL forKey:32ULL]); + XCTAssertFalse([dict getEnum:NULL forKey:33ULL]); + XCTAssertFalse([dict getEnum:NULL forKey:34ULL]); [dict release]; } @@ -2862,75 +2862,75 @@ static BOOL TestingEnum_IsValidValue(int32_t value) { const uint64_t kKeys[] = { 31ULL, 32ULL, 33ULL, 34ULL }; const int32_t kValues[] = { 700, 701, 702, 703 }; GPBUInt64EnumDictionary *dict = - [[GPBUInt64EnumDictionary alloc] initWithValues:kValues - forKeys:kKeys - count:GPBARRAYSIZE(kValues)]; + [[GPBUInt64EnumDictionary alloc] initWithEnums:kValues + forKeys:kKeys + count:GPBARRAYSIZE(kValues)]; XCTAssertNotNil(dict); XCTAssertEqual(dict.count, 4U); int32_t value; - XCTAssertTrue([dict valueForKey:31ULL value:NULL]); - XCTAssertTrue([dict valueForKey:31ULL value:&value]); + XCTAssertTrue([dict getEnum:NULL forKey:31ULL]); + XCTAssertTrue([dict getEnum:&value forKey:31ULL]); XCTAssertEqual(value, 700); - XCTAssertTrue([dict valueForKey:32ULL value:NULL]); - XCTAssertTrue([dict valueForKey:32ULL value:&value]); + XCTAssertTrue([dict getEnum:NULL forKey:32ULL]); + XCTAssertTrue([dict getEnum:&value forKey:32ULL]); XCTAssertEqual(value, 701); - XCTAssertTrue([dict valueForKey:33ULL value:NULL]); - XCTAssertTrue([dict valueForKey:33ULL value:&value]); + XCTAssertTrue([dict getEnum:NULL forKey:33ULL]); + XCTAssertTrue([dict getEnum:&value forKey:33ULL]); XCTAssertEqual(value, 702); - XCTAssertTrue([dict valueForKey:34ULL value:NULL]); - XCTAssertTrue([dict valueForKey:34ULL value:&value]); + XCTAssertTrue([dict getEnum:NULL forKey:34ULL]); + XCTAssertTrue([dict getEnum:&value forKey:34ULL]); XCTAssertEqual(value, 703); - [dict setValue:703 forKey:31ULL]; + [dict setEnum:703 forKey:31ULL]; XCTAssertEqual(dict.count, 4U); - XCTAssertTrue([dict valueForKey:31ULL value:NULL]); - XCTAssertTrue([dict valueForKey:31ULL value:&value]); + XCTAssertTrue([dict getEnum:NULL forKey:31ULL]); + XCTAssertTrue([dict getEnum:&value forKey:31ULL]); XCTAssertEqual(value, 703); - XCTAssertTrue([dict valueForKey:32ULL value:NULL]); - XCTAssertTrue([dict valueForKey:32ULL value:&value]); + XCTAssertTrue([dict getEnum:NULL forKey:32ULL]); + XCTAssertTrue([dict getEnum:&value forKey:32ULL]); XCTAssertEqual(value, 701); - XCTAssertTrue([dict valueForKey:33ULL value:NULL]); - XCTAssertTrue([dict valueForKey:33ULL value:&value]); + XCTAssertTrue([dict getEnum:NULL forKey:33ULL]); + XCTAssertTrue([dict getEnum:&value forKey:33ULL]); XCTAssertEqual(value, 702); - XCTAssertTrue([dict valueForKey:34ULL value:NULL]); - XCTAssertTrue([dict valueForKey:34ULL value:&value]); + XCTAssertTrue([dict getEnum:NULL forKey:34ULL]); + XCTAssertTrue([dict getEnum:&value forKey:34ULL]); XCTAssertEqual(value, 703); - [dict setValue:701 forKey:34ULL]; + [dict setEnum:701 forKey:34ULL]; XCTAssertEqual(dict.count, 4U); - XCTAssertTrue([dict valueForKey:31ULL value:NULL]); - XCTAssertTrue([dict valueForKey:31ULL value:&value]); + XCTAssertTrue([dict getEnum:NULL forKey:31ULL]); + XCTAssertTrue([dict getEnum:&value forKey:31ULL]); XCTAssertEqual(value, 703); - XCTAssertTrue([dict valueForKey:32ULL value:NULL]); - XCTAssertTrue([dict valueForKey:32ULL value:&value]); + XCTAssertTrue([dict getEnum:NULL forKey:32ULL]); + XCTAssertTrue([dict getEnum:&value forKey:32ULL]); XCTAssertEqual(value, 701); - XCTAssertTrue([dict valueForKey:33ULL value:NULL]); - XCTAssertTrue([dict valueForKey:33ULL value:&value]); + XCTAssertTrue([dict getEnum:NULL forKey:33ULL]); + XCTAssertTrue([dict getEnum:&value forKey:33ULL]); XCTAssertEqual(value, 702); - XCTAssertTrue([dict valueForKey:34ULL value:NULL]); - XCTAssertTrue([dict valueForKey:34ULL value:&value]); + XCTAssertTrue([dict getEnum:NULL forKey:34ULL]); + XCTAssertTrue([dict getEnum:&value forKey:34ULL]); XCTAssertEqual(value, 701); const uint64_t kKeys2[] = { 32ULL, 33ULL }; const int32_t kValues2[] = { 702, 700 }; GPBUInt64EnumDictionary *dict2 = - [[GPBUInt64EnumDictionary alloc] initWithValues:kValues2 - forKeys:kKeys2 - count:GPBARRAYSIZE(kValues2)]; + [[GPBUInt64EnumDictionary alloc] initWithEnums:kValues2 + forKeys:kKeys2 + count:GPBARRAYSIZE(kValues2)]; XCTAssertNotNil(dict2); [dict addRawEntriesFromDictionary:dict2]; XCTAssertEqual(dict.count, 4U); - XCTAssertTrue([dict valueForKey:31ULL value:NULL]); - XCTAssertTrue([dict valueForKey:31ULL value:&value]); + XCTAssertTrue([dict getEnum:NULL forKey:31ULL]); + XCTAssertTrue([dict getEnum:&value forKey:31ULL]); XCTAssertEqual(value, 703); - XCTAssertTrue([dict valueForKey:32ULL value:NULL]); - XCTAssertTrue([dict valueForKey:32ULL value:&value]); + XCTAssertTrue([dict getEnum:NULL forKey:32ULL]); + XCTAssertTrue([dict getEnum:&value forKey:32ULL]); XCTAssertEqual(value, 702); - XCTAssertTrue([dict valueForKey:33ULL value:NULL]); - XCTAssertTrue([dict valueForKey:33ULL value:&value]); + XCTAssertTrue([dict getEnum:NULL forKey:33ULL]); + XCTAssertTrue([dict getEnum:&value forKey:33ULL]); XCTAssertEqual(value, 700); - XCTAssertTrue([dict valueForKey:34ULL value:NULL]); - XCTAssertTrue([dict valueForKey:34ULL value:&value]); + XCTAssertTrue([dict getEnum:NULL forKey:34ULL]); + XCTAssertTrue([dict getEnum:&value forKey:34ULL]); XCTAssertEqual(value, 701); [dict2 release]; @@ -2958,24 +2958,24 @@ static BOOL TestingEnum_IsValidValue(int32_t value) { XCTAssertEqual(dict.count, 3U); XCTAssertTrue(dict.validationFunc == TestingEnum_IsValidValue); // Pointer comparison int32_t value; - XCTAssertTrue([dict valueForKey:31ULL rawValue:NULL]); - XCTAssertTrue([dict valueForKey:31ULL rawValue:&value]); + XCTAssertTrue([dict getRawValue:NULL forKey:31ULL]); + XCTAssertTrue([dict getRawValue:&value forKey:31ULL]); XCTAssertEqual(value, 700); - XCTAssertTrue([dict valueForKey:32ULL value:NULL]); - XCTAssertTrue([dict valueForKey:32ULL value:&value]); + XCTAssertTrue([dict getEnum:NULL forKey:32ULL]); + XCTAssertTrue([dict getEnum:&value forKey:32ULL]); XCTAssertEqual(value, kGPBUnrecognizedEnumeratorValue); - XCTAssertTrue([dict valueForKey:32ULL rawValue:NULL]); - XCTAssertTrue([dict valueForKey:32ULL rawValue:&value]); + XCTAssertTrue([dict getRawValue:NULL forKey:32ULL]); + XCTAssertTrue([dict getRawValue:&value forKey:32ULL]); XCTAssertEqual(value, 801); - XCTAssertTrue([dict valueForKey:33ULL rawValue:NULL]); - XCTAssertTrue([dict valueForKey:33ULL rawValue:&value]); + XCTAssertTrue([dict getRawValue:NULL forKey:33ULL]); + XCTAssertTrue([dict getRawValue:&value forKey:33ULL]); XCTAssertEqual(value, 702); - XCTAssertFalse([dict valueForKey:34ULL rawValue:NULL]); + XCTAssertFalse([dict getRawValue:NULL forKey:34ULL]); __block NSUInteger idx = 0; uint64_t *seenKeys = malloc(3 * sizeof(uint64_t)); int32_t *seenValues = malloc(3 * sizeof(int32_t)); - [dict enumerateKeysAndValuesUsingBlock:^(uint64_t aKey, int32_t aValue, BOOL *stop) { + [dict enumerateKeysAndEnumsUsingBlock:^(uint64_t aKey, int32_t aValue, BOOL *stop) { XCTAssertLessThan(idx, 3U); seenKeys[idx] = aKey; seenValues[idx] = aValue; @@ -3136,7 +3136,7 @@ static BOOL TestingEnum_IsValidValue(int32_t value) { XCTAssertNotNil(dict); XCTAssertEqual(dict.count, 0U); - XCTAssertThrowsSpecificNamed([dict setValue:801 forKey:32ULL], // Unknown + XCTAssertThrowsSpecificNamed([dict setEnum:801 forKey:32ULL], // Unknown NSException, NSInvalidArgumentException); XCTAssertEqual(dict.count, 0U); [dict setRawValue:801 forKey:32ULL]; // Unknown @@ -3145,31 +3145,31 @@ static BOOL TestingEnum_IsValidValue(int32_t value) { const uint64_t kKeys[] = { 31ULL, 33ULL, 34ULL }; const int32_t kValues[] = { 700, 702, 803 }; // Unknown GPBUInt64EnumDictionary *dict2 = - [[GPBUInt64EnumDictionary alloc] initWithValues:kValues - forKeys:kKeys - count:GPBARRAYSIZE(kValues)]; + [[GPBUInt64EnumDictionary alloc] initWithEnums:kValues + forKeys:kKeys + count:GPBARRAYSIZE(kValues)]; XCTAssertNotNil(dict2); [dict addRawEntriesFromDictionary:dict2]; XCTAssertEqual(dict.count, 4U); int32_t value; - XCTAssertTrue([dict valueForKey:31ULL value:NULL]); - XCTAssertTrue([dict valueForKey:31ULL value:&value]); + XCTAssertTrue([dict getEnum:NULL forKey:31ULL]); + XCTAssertTrue([dict getEnum:&value forKey:31ULL]); XCTAssertEqual(value, 700); - XCTAssertTrue([dict valueForKey:32ULL value:NULL]); - XCTAssertTrue([dict valueForKey:32ULL value:&value]); + XCTAssertTrue([dict getEnum:NULL forKey:32ULL]); + XCTAssertTrue([dict getEnum:&value forKey:32ULL]); XCTAssertEqual(value, kGPBUnrecognizedEnumeratorValue); - XCTAssertTrue([dict valueForKey:32ULL rawValue:NULL]); - XCTAssertTrue([dict valueForKey:32ULL rawValue:&value]); + XCTAssertTrue([dict getRawValue:NULL forKey:32ULL]); + XCTAssertTrue([dict getRawValue:&value forKey:32ULL]); XCTAssertEqual(value, 801); - XCTAssertTrue([dict valueForKey:33ULL value:NULL]); - XCTAssertTrue([dict valueForKey:33ULL value:&value]); + XCTAssertTrue([dict getEnum:NULL forKey:33ULL]); + XCTAssertTrue([dict getEnum:&value forKey:33ULL]); XCTAssertEqual(value, 702); - XCTAssertTrue([dict valueForKey:34ULL value:NULL]); - XCTAssertTrue([dict valueForKey:34ULL value:&value]); + XCTAssertTrue([dict getEnum:NULL forKey:34ULL]); + XCTAssertTrue([dict getEnum:&value forKey:34ULL]); XCTAssertEqual(value, kGPBUnrecognizedEnumeratorValue); - XCTAssertTrue([dict valueForKey:34ULL rawValue:NULL]); - XCTAssertTrue([dict valueForKey:34ULL rawValue:&value]); + XCTAssertTrue([dict getRawValue:NULL forKey:34ULL]); + XCTAssertTrue([dict getRawValue:&value forKey:34ULL]); XCTAssertEqual(value, 803); [dict2 release]; } @@ -3185,51 +3185,51 @@ static BOOL TestingEnum_IsValidValue(int32_t value) { XCTAssertNotNil(dict); XCTAssertEqual(dict.count, 4U); - [dict removeValueForKey:32ULL]; + [dict removeEnumForKey:32ULL]; XCTAssertEqual(dict.count, 3U); int32_t value; - XCTAssertTrue([dict valueForKey:31ULL value:NULL]); - XCTAssertTrue([dict valueForKey:31ULL value:&value]); + XCTAssertTrue([dict getEnum:NULL forKey:31ULL]); + XCTAssertTrue([dict getEnum:&value forKey:31ULL]); XCTAssertEqual(value, 700); - XCTAssertFalse([dict valueForKey:32ULL value:NULL]); - XCTAssertTrue([dict valueForKey:33ULL value:NULL]); - XCTAssertTrue([dict valueForKey:33ULL value:&value]); + XCTAssertFalse([dict getEnum:NULL forKey:32ULL]); + XCTAssertTrue([dict getEnum:NULL forKey:33ULL]); + XCTAssertTrue([dict getEnum:&value forKey:33ULL]); XCTAssertEqual(value, 702); - XCTAssertTrue([dict valueForKey:34ULL rawValue:NULL]); - XCTAssertTrue([dict valueForKey:34ULL rawValue:&value]); + XCTAssertTrue([dict getRawValue:NULL forKey:34ULL]); + XCTAssertTrue([dict getRawValue:&value forKey:34ULL]); XCTAssertEqual(value, 803); // Remove again does nothing. - [dict removeValueForKey:32ULL]; + [dict removeEnumForKey:32ULL]; XCTAssertEqual(dict.count, 3U); - XCTAssertTrue([dict valueForKey:31ULL value:NULL]); - XCTAssertTrue([dict valueForKey:31ULL value:&value]); + XCTAssertTrue([dict getEnum:NULL forKey:31ULL]); + XCTAssertTrue([dict getEnum:&value forKey:31ULL]); XCTAssertEqual(value, 700); - XCTAssertFalse([dict valueForKey:32ULL value:NULL]); - XCTAssertTrue([dict valueForKey:33ULL value:NULL]); - XCTAssertTrue([dict valueForKey:33ULL value:&value]); + XCTAssertFalse([dict getEnum:NULL forKey:32ULL]); + XCTAssertTrue([dict getEnum:NULL forKey:33ULL]); + XCTAssertTrue([dict getEnum:&value forKey:33ULL]); XCTAssertEqual(value, 702); - XCTAssertTrue([dict valueForKey:34ULL rawValue:NULL]); - XCTAssertTrue([dict valueForKey:34ULL rawValue:&value]); + XCTAssertTrue([dict getRawValue:NULL forKey:34ULL]); + XCTAssertTrue([dict getRawValue:&value forKey:34ULL]); XCTAssertEqual(value, 803); - [dict removeValueForKey:34ULL]; + [dict removeEnumForKey:34ULL]; XCTAssertEqual(dict.count, 2U); - XCTAssertTrue([dict valueForKey:31ULL value:NULL]); - XCTAssertTrue([dict valueForKey:31ULL value:&value]); + XCTAssertTrue([dict getEnum:NULL forKey:31ULL]); + XCTAssertTrue([dict getEnum:&value forKey:31ULL]); XCTAssertEqual(value, 700); - XCTAssertFalse([dict valueForKey:32ULL value:NULL]); - XCTAssertTrue([dict valueForKey:33ULL value:NULL]); - XCTAssertTrue([dict valueForKey:33ULL value:&value]); + XCTAssertFalse([dict getEnum:NULL forKey:32ULL]); + XCTAssertTrue([dict getEnum:NULL forKey:33ULL]); + XCTAssertTrue([dict getEnum:&value forKey:33ULL]); XCTAssertEqual(value, 702); - XCTAssertFalse([dict valueForKey:34ULL value:NULL]); + XCTAssertFalse([dict getEnum:NULL forKey:34ULL]); [dict removeAll]; XCTAssertEqual(dict.count, 0U); - XCTAssertFalse([dict valueForKey:31ULL value:NULL]); - XCTAssertFalse([dict valueForKey:32ULL value:NULL]); - XCTAssertFalse([dict valueForKey:33ULL value:NULL]); - XCTAssertFalse([dict valueForKey:34ULL value:NULL]); + XCTAssertFalse([dict getEnum:NULL forKey:31ULL]); + XCTAssertFalse([dict getEnum:NULL forKey:32ULL]); + XCTAssertFalse([dict getEnum:NULL forKey:33ULL]); + XCTAssertFalse([dict getEnum:NULL forKey:34ULL]); [dict release]; } @@ -3244,63 +3244,63 @@ static BOOL TestingEnum_IsValidValue(int32_t value) { XCTAssertNotNil(dict); XCTAssertEqual(dict.count, 4U); int32_t value; - XCTAssertTrue([dict valueForKey:31ULL value:NULL]); - XCTAssertTrue([dict valueForKey:31ULL value:&value]); + XCTAssertTrue([dict getEnum:NULL forKey:31ULL]); + XCTAssertTrue([dict getEnum:&value forKey:31ULL]); XCTAssertEqual(value, 700); - XCTAssertTrue([dict valueForKey:32ULL rawValue:NULL]); - XCTAssertTrue([dict valueForKey:32ULL rawValue:&value]); + XCTAssertTrue([dict getRawValue:NULL forKey:32ULL]); + XCTAssertTrue([dict getRawValue:&value forKey:32ULL]); XCTAssertEqual(value, 801); - XCTAssertTrue([dict valueForKey:33ULL value:NULL]); - XCTAssertTrue([dict valueForKey:33ULL value:&value]); + XCTAssertTrue([dict getEnum:NULL forKey:33ULL]); + XCTAssertTrue([dict getEnum:&value forKey:33ULL]); XCTAssertEqual(value, 702); - XCTAssertTrue([dict valueForKey:34ULL rawValue:NULL]); - XCTAssertTrue([dict valueForKey:34ULL rawValue:&value]); + XCTAssertTrue([dict getRawValue:NULL forKey:34ULL]); + XCTAssertTrue([dict getRawValue:&value forKey:34ULL]); XCTAssertEqual(value, 803); - XCTAssertThrowsSpecificNamed([dict setValue:803 forKey:31ULL], // Unknown + XCTAssertThrowsSpecificNamed([dict setEnum:803 forKey:31ULL], // Unknown NSException, NSInvalidArgumentException); XCTAssertEqual(dict.count, 4U); - XCTAssertTrue([dict valueForKey:31ULL value:NULL]); - XCTAssertTrue([dict valueForKey:31ULL value:&value]); + XCTAssertTrue([dict getEnum:NULL forKey:31ULL]); + XCTAssertTrue([dict getEnum:&value forKey:31ULL]); XCTAssertEqual(value, 700); - XCTAssertTrue([dict valueForKey:32ULL rawValue:NULL]); - XCTAssertTrue([dict valueForKey:32ULL rawValue:&value]); + XCTAssertTrue([dict getRawValue:NULL forKey:32ULL]); + XCTAssertTrue([dict getRawValue:&value forKey:32ULL]); XCTAssertEqual(value, 801); - XCTAssertTrue([dict valueForKey:33ULL value:NULL]); - XCTAssertTrue([dict valueForKey:33ULL value:&value]); + XCTAssertTrue([dict getEnum:NULL forKey:33ULL]); + XCTAssertTrue([dict getEnum:&value forKey:33ULL]); XCTAssertEqual(value, 702); - XCTAssertTrue([dict valueForKey:34ULL rawValue:NULL]); - XCTAssertTrue([dict valueForKey:34ULL rawValue:&value]); + XCTAssertTrue([dict getRawValue:NULL forKey:34ULL]); + XCTAssertTrue([dict getRawValue:&value forKey:34ULL]); XCTAssertEqual(value, 803); [dict setRawValue:803 forKey:31ULL]; // Unknown XCTAssertEqual(dict.count, 4U); - XCTAssertTrue([dict valueForKey:31ULL rawValue:NULL]); - XCTAssertTrue([dict valueForKey:31ULL rawValue:&value]); + XCTAssertTrue([dict getRawValue:NULL forKey:31ULL]); + XCTAssertTrue([dict getRawValue:&value forKey:31ULL]); XCTAssertEqual(value, 803); - XCTAssertTrue([dict valueForKey:32ULL rawValue:NULL]); - XCTAssertTrue([dict valueForKey:32ULL rawValue:&value]); + XCTAssertTrue([dict getRawValue:NULL forKey:32ULL]); + XCTAssertTrue([dict getRawValue:&value forKey:32ULL]); XCTAssertEqual(value, 801); - XCTAssertTrue([dict valueForKey:33ULL value:NULL]); - XCTAssertTrue([dict valueForKey:33ULL value:&value]); + XCTAssertTrue([dict getEnum:NULL forKey:33ULL]); + XCTAssertTrue([dict getEnum:&value forKey:33ULL]); XCTAssertEqual(value, 702); - XCTAssertTrue([dict valueForKey:34ULL rawValue:NULL]); - XCTAssertTrue([dict valueForKey:34ULL rawValue:&value]); + XCTAssertTrue([dict getRawValue:NULL forKey:34ULL]); + XCTAssertTrue([dict getRawValue:&value forKey:34ULL]); XCTAssertEqual(value, 803); [dict setRawValue:700 forKey:34ULL]; XCTAssertEqual(dict.count, 4U); - XCTAssertTrue([dict valueForKey:31ULL rawValue:NULL]); - XCTAssertTrue([dict valueForKey:31ULL rawValue:&value]); + XCTAssertTrue([dict getRawValue:NULL forKey:31ULL]); + XCTAssertTrue([dict getRawValue:&value forKey:31ULL]); XCTAssertEqual(value, 803); - XCTAssertTrue([dict valueForKey:32ULL rawValue:NULL]); - XCTAssertTrue([dict valueForKey:32ULL rawValue:&value]); + XCTAssertTrue([dict getRawValue:NULL forKey:32ULL]); + XCTAssertTrue([dict getRawValue:&value forKey:32ULL]); XCTAssertEqual(value, 801); - XCTAssertTrue([dict valueForKey:33ULL value:NULL]); - XCTAssertTrue([dict valueForKey:33ULL value:&value]); + XCTAssertTrue([dict getEnum:NULL forKey:33ULL]); + XCTAssertTrue([dict getEnum:&value forKey:33ULL]); XCTAssertEqual(value, 702); - XCTAssertTrue([dict valueForKey:34ULL value:NULL]); - XCTAssertTrue([dict valueForKey:34ULL value:&value]); + XCTAssertTrue([dict getEnum:NULL forKey:34ULL]); + XCTAssertTrue([dict getEnum:&value forKey:34ULL]); XCTAssertEqual(value, 700); const uint64_t kKeys2[] = { 32ULL, 33ULL }; @@ -3313,17 +3313,17 @@ static BOOL TestingEnum_IsValidValue(int32_t value) { XCTAssertNotNil(dict2); [dict addRawEntriesFromDictionary:dict2]; XCTAssertEqual(dict.count, 4U); - XCTAssertTrue([dict valueForKey:31ULL rawValue:NULL]); - XCTAssertTrue([dict valueForKey:31ULL rawValue:&value]); + XCTAssertTrue([dict getRawValue:NULL forKey:31ULL]); + XCTAssertTrue([dict getRawValue:&value forKey:31ULL]); XCTAssertEqual(value, 803); - XCTAssertTrue([dict valueForKey:32ULL value:NULL]); - XCTAssertTrue([dict valueForKey:32ULL value:&value]); + XCTAssertTrue([dict getEnum:NULL forKey:32ULL]); + XCTAssertTrue([dict getEnum:&value forKey:32ULL]); XCTAssertEqual(value, 702); - XCTAssertTrue([dict valueForKey:33ULL rawValue:NULL]); - XCTAssertTrue([dict valueForKey:33ULL rawValue:&value]); + XCTAssertTrue([dict getRawValue:NULL forKey:33ULL]); + XCTAssertTrue([dict getRawValue:&value forKey:33ULL]); XCTAssertEqual(value, 801); - XCTAssertTrue([dict valueForKey:34ULL value:NULL]); - XCTAssertTrue([dict valueForKey:34ULL value:&value]); + XCTAssertTrue([dict getEnum:NULL forKey:34ULL]); + XCTAssertTrue([dict getEnum:&value forKey:34ULL]); XCTAssertEqual(value, 700); [dict2 release]; @@ -3559,8 +3559,8 @@ static BOOL TestingEnum_IsValidValue(int32_t value) { const NSString* kObjects[] = { @"abc", @"def", @"ghi", @"jkl" }; GPBUInt64ObjectDictionary *dict = [[GPBUInt64ObjectDictionary alloc] initWithObjects:kObjects - forKeys:kKeys - count:GPBARRAYSIZE(kObjects)]; + forKeys:kKeys + count:GPBARRAYSIZE(kObjects)]; XCTAssertNotNil(dict); XCTAssertEqual(dict.count, 4U); @@ -3600,8 +3600,8 @@ static BOOL TestingEnum_IsValidValue(int32_t value) { const NSString* kObjects[] = { @"abc", @"def", @"ghi", @"jkl" }; GPBUInt64ObjectDictionary *dict = [[GPBUInt64ObjectDictionary alloc] initWithObjects:kObjects - forKeys:kKeys - count:GPBARRAYSIZE(kObjects)]; + forKeys:kKeys + count:GPBARRAYSIZE(kObjects)]; XCTAssertNotNil(dict); XCTAssertEqual(dict.count, 4U); XCTAssertEqualObjects([dict objectForKey:31ULL], @"abc"); diff --git a/objectivec/Tests/GPBDictionaryTests.pddm b/objectivec/Tests/GPBDictionaryTests.pddm index 09512940..d6aa7211 100644 --- a/objectivec/Tests/GPBDictionaryTests.pddm +++ b/objectivec/Tests/GPBDictionaryTests.pddm @@ -69,8 +69,8 @@ //% DICTIONARY_CLASS_DECL##VHELPER(KEY_NAME, VALUE_NAME, VALUE_TYPE) *dict = [[GPB##KEY_NAME##VALUE_NAME##Dictionary alloc] init]; //% XCTAssertNotNil(dict); //% XCTAssertEqual(dict.count, 0U); -//%VALUE_NOT_FOUND##VHELPER(dict, KEY1) -//% [dict enumerateKeysAnd##VNAME$u##sUsingBlock:^(KEY_TYPE KisP##aKey, VALUE_TYPE a##VNAME$u, BOOL *stop) { +//%VALUE_NOT_FOUND##VHELPER(VALUE_NAME, dict, KEY1) +//% [dict enumerateKeysAnd##VALUE_NAME$u##sUsingBlock:^(KEY_TYPE KisP##aKey, VALUE_TYPE a##VNAME$u, BOOL *stop) { //% #pragma unused(aKey, a##VNAME$u, stop) //% XCTFail(@"Shouldn't get here!"); //% }]; @@ -78,12 +78,12 @@ //%} //% //%- (void)testOne { -//% DICTIONARY_CLASS_DECL##VHELPER(KEY_NAME, VALUE_NAME, VALUE_TYPE) *dict = [GPB##KEY_NAME##VALUE_NAME##Dictionary dictionaryWith##VNAME$u##:VAL1 forKey:KEY1]; +//% DICTIONARY_CLASS_DECL##VHELPER(KEY_NAME, VALUE_NAME, VALUE_TYPE) *dict = [GPB##KEY_NAME##VALUE_NAME##Dictionary dictionaryWith##VALUE_NAME$u##:VAL1 forKey:KEY1]; //% XCTAssertNotNil(dict); //% XCTAssertEqual(dict.count, 1U); -//%DECLARE_VALUE_STORAGE##VHELPER(VALUE_TYPE, VNAME)TEST_VALUE##VHELPER(dict, VNAME, KEY1, VAL1) -//%VALUE_NOT_FOUND##VHELPER(dict, KEY2) -//% [dict enumerateKeysAnd##VNAME$u##sUsingBlock:^(KEY_TYPE KisP##aKey, VALUE_TYPE a##VNAME$u, BOOL *stop) { +//%DECLARE_VALUE_STORAGE##VHELPER(VALUE_TYPE, VNAME)TEST_VALUE##VHELPER(VALUE_NAME, dict, VNAME, KEY1, VAL1) +//%VALUE_NOT_FOUND##VHELPER(VALUE_NAME, dict, KEY2) +//% [dict enumerateKeysAnd##VALUE_NAME$u##sUsingBlock:^(KEY_TYPE KisP##aKey, VALUE_TYPE a##VNAME$u, BOOL *stop) { //% XCTAssertEqual##KSUFFIX(aKey, KEY1); //% XCTAssertEqual##VSUFFIX(a##VNAME$u, VAL1); //% XCTAssertNotEqual(stop, NULL); @@ -94,20 +94,20 @@ //% const KEY_TYPE KisP##kKeys[] = { KEY1, KEY2, KEY3 }; //% const VALUE_TYPE k##VNAME$u##s[] = { VAL1, VAL2, VAL3 }; //% DICTIONARY_CLASS_DECL##VHELPER(KEY_NAME, VALUE_NAME, VALUE_TYPE) *dict = -//% [[GPB##KEY_NAME##VALUE_NAME##Dictionary alloc] initWith##VNAME$u##s:k##VNAME$u##s -//% KEY_NAME$S VALUE_NAME$S ##VNAME$S## forKeys:kKeys -//% KEY_NAME$S VALUE_NAME$S ##VNAME$S## count:GPBARRAYSIZE(k##VNAME$u##s)]; +//% [[GPB##KEY_NAME##VALUE_NAME##Dictionary alloc] initWith##VALUE_NAME$u##s:k##VNAME$u##s +//% KEY_NAME$S VALUE_NAME$S ##VALUE_NAME$S## forKeys:kKeys +//% KEY_NAME$S VALUE_NAME$S ##VALUE_NAME$S## count:GPBARRAYSIZE(k##VNAME$u##s)]; //% XCTAssertNotNil(dict); //% XCTAssertEqual(dict.count, 3U); -//%DECLARE_VALUE_STORAGE##VHELPER(VALUE_TYPE, VNAME)TEST_VALUE##VHELPER(dict, VNAME, KEY1, VAL1) -//%TEST_VALUE##VHELPER(dict, VNAME, KEY2, VAL2) -//%TEST_VALUE##VHELPER(dict, VNAME, KEY3, VAL3) -//%VALUE_NOT_FOUND##VHELPER(dict, KEY4) +//%DECLARE_VALUE_STORAGE##VHELPER(VALUE_TYPE, VNAME)TEST_VALUE##VHELPER(VALUE_NAME, dict, VNAME, KEY1, VAL1) +//%TEST_VALUE##VHELPER(VALUE_NAME, dict, VNAME, KEY2, VAL2) +//%TEST_VALUE##VHELPER(VALUE_NAME, dict, VNAME, KEY3, VAL3) +//%VALUE_NOT_FOUND##VHELPER(VALUE_NAME, dict, KEY4) //% //% __block NSUInteger idx = 0; //% KEY_TYPE KisP##*seenKeys = malloc(3 * sizeof(KEY_TYPE##KisP)); //% VALUE_TYPE *seen##VNAME$u##s = malloc(3 * sizeof(VALUE_TYPE)); -//% [dict enumerateKeysAnd##VNAME$u##sUsingBlock:^(KEY_TYPE KisP##aKey, VALUE_TYPE a##VNAME$u, BOOL *stop) { +//% [dict enumerateKeysAnd##VALUE_NAME$u##sUsingBlock:^(KEY_TYPE KisP##aKey, VALUE_TYPE a##VNAME$u, BOOL *stop) { //% XCTAssertLessThan(idx, 3U); //% seenKeys[idx] = aKey; //% seen##VNAME$u##s[idx] = a##VNAME$u##; @@ -129,7 +129,7 @@ //% //% // Stopping the enumeration. //% idx = 0; -//% [dict enumerateKeysAnd##VNAME$u##sUsingBlock:^(KEY_TYPE KisP##aKey, VALUE_TYPE a##VNAME$u, BOOL *stop) { +//% [dict enumerateKeysAnd##VALUE_NAME$u##sUsingBlock:^(KEY_TYPE KisP##aKey, VALUE_TYPE a##VNAME$u, BOOL *stop) { //% #pragma unused(aKey, a##VNAME$u) //% if (idx == 1) *stop = YES; //% XCTAssertNotEqual(idx, 2U); @@ -145,29 +145,29 @@ //% const VALUE_TYPE k##VNAME$u##s2[] = { VAL1, VAL4, VAL3 }; //% const VALUE_TYPE k##VNAME$u##s3[] = { VAL1, VAL2, VAL3, VAL4 }; //% DICTIONARY_CLASS_DECL##VHELPER(KEY_NAME, VALUE_NAME, VALUE_TYPE) *dict1 = -//% [[GPB##KEY_NAME##VALUE_NAME##Dictionary alloc] initWith##VNAME$u##s:k##VNAME$u##s1 -//% KEY_NAME$S VALUE_NAME$S ##VNAME$S## forKeys:kKeys1 -//% KEY_NAME$S VALUE_NAME$S ##VNAME$S## count:GPBARRAYSIZE(k##VNAME$u##s1)]; +//% [[GPB##KEY_NAME##VALUE_NAME##Dictionary alloc] initWith##VALUE_NAME##s:k##VNAME$u##s1 +//% KEY_NAME$S VALUE_NAME$S ##VALUE_NAME$S## forKeys:kKeys1 +//% KEY_NAME$S VALUE_NAME$S ##VALUE_NAME$S## count:GPBARRAYSIZE(k##VNAME$u##s1)]; //% XCTAssertNotNil(dict1); //% DICTIONARY_CLASS_DECL##VHELPER(KEY_NAME, VALUE_NAME, VALUE_TYPE) *dict1prime = -//% [[GPB##KEY_NAME##VALUE_NAME##Dictionary alloc] initWith##VNAME$u##s:k##VNAME$u##s1 -//% KEY_NAME$S VALUE_NAME$S ##VNAME$S## forKeys:kKeys1 -//% KEY_NAME$S VALUE_NAME$S ##VNAME$S## count:GPBARRAYSIZE(k##VNAME$u##s1)]; +//% [[GPB##KEY_NAME##VALUE_NAME##Dictionary alloc] initWith##VALUE_NAME##s:k##VNAME$u##s1 +//% KEY_NAME$S VALUE_NAME$S ##VALUE_NAME$S## forKeys:kKeys1 +//% KEY_NAME$S VALUE_NAME$S ##VALUE_NAME$S## count:GPBARRAYSIZE(k##VNAME$u##s1)]; //% XCTAssertNotNil(dict1prime); //% DICTIONARY_CLASS_DECL##VHELPER(KEY_NAME, VALUE_NAME, VALUE_TYPE) *dict2 = -//% [[GPB##KEY_NAME##VALUE_NAME##Dictionary alloc] initWith##VNAME$u##s:k##VNAME$u##s2 -//% KEY_NAME$S VALUE_NAME$S ##VNAME$S## forKeys:kKeys1 -//% KEY_NAME$S VALUE_NAME$S ##VNAME$S## count:GPBARRAYSIZE(k##VNAME$u##s2)]; +//% [[GPB##KEY_NAME##VALUE_NAME##Dictionary alloc] initWith##VALUE_NAME##s:k##VNAME$u##s2 +//% KEY_NAME$S VALUE_NAME$S ##VALUE_NAME$S## forKeys:kKeys1 +//% KEY_NAME$S VALUE_NAME$S ##VALUE_NAME$S## count:GPBARRAYSIZE(k##VNAME$u##s2)]; //% XCTAssertNotNil(dict2); //% DICTIONARY_CLASS_DECL##VHELPER(KEY_NAME, VALUE_NAME, VALUE_TYPE) *dict3 = -//% [[GPB##KEY_NAME##VALUE_NAME##Dictionary alloc] initWith##VNAME$u##s:k##VNAME$u##s1 -//% KEY_NAME$S VALUE_NAME$S ##VNAME$S## forKeys:kKeys2 -//% KEY_NAME$S VALUE_NAME$S ##VNAME$S## count:GPBARRAYSIZE(k##VNAME$u##s1)]; +//% [[GPB##KEY_NAME##VALUE_NAME##Dictionary alloc] initWith##VALUE_NAME##s:k##VNAME$u##s1 +//% KEY_NAME$S VALUE_NAME$S ##VALUE_NAME$S## forKeys:kKeys2 +//% KEY_NAME$S VALUE_NAME$S ##VALUE_NAME$S## count:GPBARRAYSIZE(k##VNAME$u##s1)]; //% XCTAssertNotNil(dict3); //% DICTIONARY_CLASS_DECL##VHELPER(KEY_NAME, VALUE_NAME, VALUE_TYPE) *dict4 = -//% [[GPB##KEY_NAME##VALUE_NAME##Dictionary alloc] initWith##VNAME$u##s:k##VNAME$u##s3 -//% KEY_NAME$S VALUE_NAME$S ##VNAME$S## forKeys:kKeys1 -//% KEY_NAME$S VALUE_NAME$S ##VNAME$S## count:GPBARRAYSIZE(k##VNAME$u##s3)]; +//% [[GPB##KEY_NAME##VALUE_NAME##Dictionary alloc] initWith##VALUE_NAME##s:k##VNAME$u##s3 +//% KEY_NAME$S VALUE_NAME$S ##VALUE_NAME$S## forKeys:kKeys1 +//% KEY_NAME$S VALUE_NAME$S ##VALUE_NAME$S## count:GPBARRAYSIZE(k##VNAME$u##s3)]; //% XCTAssertNotNil(dict4); //% //% // 1/1Prime should be different objects, but equal. @@ -196,9 +196,9 @@ //% const KEY_TYPE KisP##kKeys[] = { KEY1, KEY2, KEY3, KEY4 }; //% const VALUE_TYPE k##VNAME$u##s[] = { VAL1, VAL2, VAL3, VAL4 }; //% DICTIONARY_CLASS_DECL##VHELPER(KEY_NAME, VALUE_NAME, VALUE_TYPE) *dict = -//% [[GPB##KEY_NAME##VALUE_NAME##Dictionary alloc] initWith##VNAME$u##s:k##VNAME$u##s -//% KEY_NAME$S VALUE_NAME$S ##VNAME$S## forKeys:kKeys -//% KEY_NAME$S VALUE_NAME$S ##VNAME$S## count:GPBARRAYSIZE(k##VNAME$u##s)]; +//% [[GPB##KEY_NAME##VALUE_NAME##Dictionary alloc] initWith##VALUE_NAME##s:k##VNAME$u##s +//% KEY_NAME$S VALUE_NAME$S ##VALUE_NAME$S## forKeys:kKeys +//% KEY_NAME$S VALUE_NAME$S ##VALUE_NAME$S## count:GPBARRAYSIZE(k##VNAME$u##s)]; //% XCTAssertNotNil(dict); //% //% DICTIONARY_CLASS_DECL##VHELPER(KEY_NAME, VALUE_NAME, VALUE_TYPE) *dict2 = [dict copy]; @@ -217,9 +217,9 @@ //% const KEY_TYPE KisP##kKeys[] = { KEY1, KEY2, KEY3, KEY4 }; //% const VALUE_TYPE k##VNAME$u##s[] = { VAL1, VAL2, VAL3, VAL4 }; //% DICTIONARY_CLASS_DECL##VHELPER(KEY_NAME, VALUE_NAME, VALUE_TYPE) *dict = -//% [[GPB##KEY_NAME##VALUE_NAME##Dictionary alloc] initWith##VNAME$u##s:k##VNAME$u##s -//% KEY_NAME$S VALUE_NAME$S ##VNAME$S## forKeys:kKeys -//% KEY_NAME$S VALUE_NAME$S ##VNAME$S## count:GPBARRAYSIZE(k##VNAME$u##s)]; +//% [[GPB##KEY_NAME##VALUE_NAME##Dictionary alloc] initWith##VALUE_NAME##s:k##VNAME$u##s +//% KEY_NAME$S VALUE_NAME$S ##VALUE_NAME$S## forKeys:kKeys +//% KEY_NAME$S VALUE_NAME$S ##VALUE_NAME$S## count:GPBARRAYSIZE(k##VNAME$u##s)]; //% XCTAssertNotNil(dict); //% //% DICTIONARY_CLASS_DECL##VHELPER(KEY_NAME, VALUE_NAME, VALUE_TYPE) *dict2 = @@ -237,23 +237,23 @@ //% XCTAssertNotNil(dict); //% //% XCTAssertEqual(dict.count, 0U); -//% [dict set##VNAME$u##:VAL1 forKey:KEY1]; +//% [dict set##VALUE_NAME##:VAL1 forKey:KEY1]; //% XCTAssertEqual(dict.count, 1U); //% //% const KEY_TYPE KisP##kKeys[] = { KEY2, KEY3, KEY4 }; //% const VALUE_TYPE k##VNAME$u##s[] = { VAL2, VAL3, VAL4 }; //% DICTIONARY_CLASS_DECL##VHELPER(KEY_NAME, VALUE_NAME, VALUE_TYPE) *dict2 = -//% [[GPB##KEY_NAME##VALUE_NAME##Dictionary alloc] initWith##VNAME$u##s:k##VNAME$u##s -//% KEY_NAME$S VALUE_NAME$S ##VNAME$S## forKeys:kKeys -//% KEY_NAME$S VALUE_NAME$S ##VNAME$S## count:GPBARRAYSIZE(k##VNAME$u##s)]; +//% [[GPB##KEY_NAME##VALUE_NAME##Dictionary alloc] initWith##VALUE_NAME##s:k##VNAME$u##s +//% KEY_NAME$S VALUE_NAME$S ##VALUE_NAME$S## forKeys:kKeys +//% KEY_NAME$S VALUE_NAME$S ##VALUE_NAME$S## count:GPBARRAYSIZE(k##VNAME$u##s)]; //% XCTAssertNotNil(dict2); //% [dict add##VACCESSOR##EntriesFromDictionary:dict2]; //% XCTAssertEqual(dict.count, 4U); //% -//%DECLARE_VALUE_STORAGE##VHELPER(VALUE_TYPE, VNAME)TEST_VALUE##VHELPER(dict, VNAME, KEY1, VAL1) -//%TEST_VALUE##VHELPER(dict, VNAME, KEY2, VAL2) -//%TEST_VALUE##VHELPER(dict, VNAME, KEY3, VAL3) -//%TEST_VALUE##VHELPER(dict, VNAME, KEY4, VAL4) +//%DECLARE_VALUE_STORAGE##VHELPER(VALUE_TYPE, VNAME)TEST_VALUE##VHELPER(VALUE_NAME, dict, VNAME, KEY1, VAL1) +//%TEST_VALUE##VHELPER(VALUE_NAME, dict, VNAME, KEY2, VAL2) +//%TEST_VALUE##VHELPER(VALUE_NAME, dict, VNAME, KEY3, VAL3) +//%TEST_VALUE##VHELPER(VALUE_NAME, dict, VNAME, KEY4, VAL4) //% [dict2 release]; //%} //% @@ -261,40 +261,40 @@ //% const KEY_TYPE KisP##kKeys[] = { KEY1, KEY2, KEY3, KEY4 }; //% const VALUE_TYPE k##VNAME$u##s[] = { VAL1, VAL2, VAL3, VAL4 }; //% DICTIONARY_CLASS_DECL##VHELPER(KEY_NAME, VALUE_NAME, VALUE_TYPE) *dict = -//% [[GPB##KEY_NAME##VALUE_NAME##Dictionary alloc] initWith##VNAME$u##s:k##VNAME$u##s -//% KEY_NAME$S VALUE_NAME$S ##VNAME$S## forKeys:kKeys -//% KEY_NAME$S VALUE_NAME$S ##VNAME$S## count:GPBARRAYSIZE(k##VNAME$u##s)]; +//% [[GPB##KEY_NAME##VALUE_NAME##Dictionary alloc] initWith##VALUE_NAME##s:k##VNAME$u##s +//% KEY_NAME$S VALUE_NAME$S ##VALUE_NAME$S## forKeys:kKeys +//% KEY_NAME$S VALUE_NAME$S ##VALUE_NAME$S## count:GPBARRAYSIZE(k##VNAME$u##s)]; //% XCTAssertNotNil(dict); //% XCTAssertEqual(dict.count, 4U); //% -//% [dict remove##VNAME$u##ForKey:KEY2]; +//% [dict remove##VALUE_NAME##ForKey:KEY2]; //% XCTAssertEqual(dict.count, 3U); -//%DECLARE_VALUE_STORAGE##VHELPER(VALUE_TYPE, VNAME)TEST_VALUE##VHELPER(dict, VNAME, KEY1, VAL1) -//%VALUE_NOT_FOUND##VHELPER(dict, KEY2) -//%TEST_VALUE##VHELPER(dict, VNAME, KEY3, VAL3) -//%TEST_VALUE##VHELPER(dict, VNAME, KEY4, VAL4) +//%DECLARE_VALUE_STORAGE##VHELPER(VALUE_TYPE, VNAME)TEST_VALUE##VHELPER(VALUE_NAME, dict, VNAME, KEY1, VAL1) +//%VALUE_NOT_FOUND##VHELPER(VALUE_NAME, dict, KEY2) +//%TEST_VALUE##VHELPER(VALUE_NAME, dict, VNAME, KEY3, VAL3) +//%TEST_VALUE##VHELPER(VALUE_NAME, dict, VNAME, KEY4, VAL4) //% //% // Remove again does nothing. -//% [dict remove##VNAME$u##ForKey:KEY2]; +//% [dict remove##VALUE_NAME##ForKey:KEY2]; //% XCTAssertEqual(dict.count, 3U); -//%TEST_VALUE##VHELPER(dict, VNAME, KEY1, VAL1) -//%VALUE_NOT_FOUND##VHELPER(dict, KEY2) -//%TEST_VALUE##VHELPER(dict, VNAME, KEY3, VAL3) -//%TEST_VALUE##VHELPER(dict, VNAME, KEY4, VAL4) +//%TEST_VALUE##VHELPER(VALUE_NAME, dict, VNAME, KEY1, VAL1) +//%VALUE_NOT_FOUND##VHELPER(VALUE_NAME, dict, KEY2) +//%TEST_VALUE##VHELPER(VALUE_NAME, dict, VNAME, KEY3, VAL3) +//%TEST_VALUE##VHELPER(VALUE_NAME, dict, VNAME, KEY4, VAL4) //% -//% [dict remove##VNAME$u##ForKey:KEY4]; +//% [dict remove##VALUE_NAME##ForKey:KEY4]; //% XCTAssertEqual(dict.count, 2U); -//%TEST_VALUE##VHELPER(dict, VNAME, KEY1, VAL1) -//%VALUE_NOT_FOUND##VHELPER(dict, KEY2) -//%TEST_VALUE##VHELPER(dict, VNAME, KEY3, VAL3) -//%VALUE_NOT_FOUND##VHELPER(dict, KEY4) +//%TEST_VALUE##VHELPER(VALUE_NAME, dict, VNAME, KEY1, VAL1) +//%VALUE_NOT_FOUND##VHELPER(VALUE_NAME, dict, KEY2) +//%TEST_VALUE##VHELPER(VALUE_NAME, dict, VNAME, KEY3, VAL3) +//%VALUE_NOT_FOUND##VHELPER(VALUE_NAME, dict, KEY4) //% //% [dict removeAll]; //% XCTAssertEqual(dict.count, 0U); -//%VALUE_NOT_FOUND##VHELPER(dict, KEY1) -//%VALUE_NOT_FOUND##VHELPER(dict, KEY2) -//%VALUE_NOT_FOUND##VHELPER(dict, KEY3) -//%VALUE_NOT_FOUND##VHELPER(dict, KEY4) +//%VALUE_NOT_FOUND##VHELPER(VALUE_NAME, dict, KEY1) +//%VALUE_NOT_FOUND##VHELPER(VALUE_NAME, dict, KEY2) +//%VALUE_NOT_FOUND##VHELPER(VALUE_NAME, dict, KEY3) +//%VALUE_NOT_FOUND##VHELPER(VALUE_NAME, dict, KEY4) //% [dict release]; //%} //% @@ -302,43 +302,43 @@ //% const KEY_TYPE KisP##kKeys[] = { KEY1, KEY2, KEY3, KEY4 }; //% const VALUE_TYPE k##VNAME$u##s[] = { VAL1, VAL2, VAL3, VAL4 }; //% DICTIONARY_CLASS_DECL##VHELPER(KEY_NAME, VALUE_NAME, VALUE_TYPE) *dict = -//% [[GPB##KEY_NAME##VALUE_NAME##Dictionary alloc] initWith##VNAME$u##s:k##VNAME$u##s -//% KEY_NAME$S VALUE_NAME$S ##VNAME$S## forKeys:kKeys -//% KEY_NAME$S VALUE_NAME$S ##VNAME$S## count:GPBARRAYSIZE(k##VNAME$u##s)]; +//% [[GPB##KEY_NAME##VALUE_NAME##Dictionary alloc] initWith##VALUE_NAME##s:k##VNAME$u##s +//% KEY_NAME$S VALUE_NAME$S ##VALUE_NAME$S## forKeys:kKeys +//% KEY_NAME$S VALUE_NAME$S ##VALUE_NAME$S## count:GPBARRAYSIZE(k##VNAME$u##s)]; //% XCTAssertNotNil(dict); //% XCTAssertEqual(dict.count, 4U); -//%DECLARE_VALUE_STORAGE##VHELPER(VALUE_TYPE, VNAME)TEST_VALUE##VHELPER(dict, VNAME, KEY1, VAL1) -//%TEST_VALUE##VHELPER(dict, VNAME, KEY2, VAL2) -//%TEST_VALUE##VHELPER(dict, VNAME, KEY3, VAL3) -//%TEST_VALUE##VHELPER(dict, VNAME, KEY4, VAL4) +//%DECLARE_VALUE_STORAGE##VHELPER(VALUE_TYPE, VNAME)TEST_VALUE##VHELPER(VALUE_NAME, dict, VNAME, KEY1, VAL1) +//%TEST_VALUE##VHELPER(VALUE_NAME, dict, VNAME, KEY2, VAL2) +//%TEST_VALUE##VHELPER(VALUE_NAME, dict, VNAME, KEY3, VAL3) +//%TEST_VALUE##VHELPER(VALUE_NAME, dict, VNAME, KEY4, VAL4) //% -//% [dict set##VNAME$u##:VAL4 forKey:KEY1]; +//% [dict set##VALUE_NAME##:VAL4 forKey:KEY1]; //% XCTAssertEqual(dict.count, 4U); -//%TEST_VALUE##VHELPER(dict, VNAME, KEY1, VAL4) -//%TEST_VALUE##VHELPER(dict, VNAME, KEY2, VAL2) -//%TEST_VALUE##VHELPER(dict, VNAME, KEY3, VAL3) -//%TEST_VALUE##VHELPER(dict, VNAME, KEY4, VAL4) +//%TEST_VALUE##VHELPER(VALUE_NAME, dict, VNAME, KEY1, VAL4) +//%TEST_VALUE##VHELPER(VALUE_NAME, dict, VNAME, KEY2, VAL2) +//%TEST_VALUE##VHELPER(VALUE_NAME, dict, VNAME, KEY3, VAL3) +//%TEST_VALUE##VHELPER(VALUE_NAME, dict, VNAME, KEY4, VAL4) //% -//% [dict set##VNAME$u##:VAL2 forKey:KEY4]; +//% [dict set##VALUE_NAME##:VAL2 forKey:KEY4]; //% XCTAssertEqual(dict.count, 4U); -//%TEST_VALUE##VHELPER(dict, VNAME, KEY1, VAL4) -//%TEST_VALUE##VHELPER(dict, VNAME, KEY2, VAL2) -//%TEST_VALUE##VHELPER(dict, VNAME, KEY3, VAL3) -//%TEST_VALUE##VHELPER(dict, VNAME, KEY4, VAL2) +//%TEST_VALUE##VHELPER(VALUE_NAME, dict, VNAME, KEY1, VAL4) +//%TEST_VALUE##VHELPER(VALUE_NAME, dict, VNAME, KEY2, VAL2) +//%TEST_VALUE##VHELPER(VALUE_NAME, dict, VNAME, KEY3, VAL3) +//%TEST_VALUE##VHELPER(VALUE_NAME, dict, VNAME, KEY4, VAL2) //% //% const KEY_TYPE KisP##kKeys2[] = { KEY2, KEY3 }; //% const VALUE_TYPE k##VNAME$u##s2[] = { VAL3, VAL1 }; //% DICTIONARY_CLASS_DECL##VHELPER(KEY_NAME, VALUE_NAME, VALUE_TYPE) *dict2 = -//% [[GPB##KEY_NAME##VALUE_NAME##Dictionary alloc] initWith##VNAME$u##s:k##VNAME$u##s2 -//% KEY_NAME$S VALUE_NAME$S ##VNAME$S## forKeys:kKeys2 -//% KEY_NAME$S VALUE_NAME$S ##VNAME$S## count:GPBARRAYSIZE(k##VNAME$u##s2)]; +//% [[GPB##KEY_NAME##VALUE_NAME##Dictionary alloc] initWith##VALUE_NAME##s:k##VNAME$u##s2 +//% KEY_NAME$S VALUE_NAME$S ##VALUE_NAME$S## forKeys:kKeys2 +//% KEY_NAME$S VALUE_NAME$S ##VALUE_NAME$S## count:GPBARRAYSIZE(k##VNAME$u##s2)]; //% XCTAssertNotNil(dict2); //% [dict add##VACCESSOR##EntriesFromDictionary:dict2]; //% XCTAssertEqual(dict.count, 4U); -//%TEST_VALUE##VHELPER(dict, VNAME, KEY1, VAL4) -//%TEST_VALUE##VHELPER(dict, VNAME, KEY2, VAL3) -//%TEST_VALUE##VHELPER(dict, VNAME, KEY3, VAL1) -//%TEST_VALUE##VHELPER(dict, VNAME, KEY4, VAL2) +//%TEST_VALUE##VHELPER(VALUE_NAME, dict, VNAME, KEY1, VAL4) +//%TEST_VALUE##VHELPER(VALUE_NAME, dict, VNAME, KEY2, VAL3) +//%TEST_VALUE##VHELPER(VALUE_NAME, dict, VNAME, KEY3, VAL1) +//%TEST_VALUE##VHELPER(VALUE_NAME, dict, VNAME, KEY4, VAL2) //% //% [dict2 release]; //% [dict release]; @@ -369,15 +369,15 @@ //% XCTAssertEqual(dict.count, 3U); //% XCTAssertTrue(dict.validationFunc == TestingEnum_IsValidValue); // Pointer comparison //%DECLARE_VALUE_STORAGE##VHELPER(VALUE_TYPE, value)TEST_RAW_VALUE##VHELPER(dict, value, KEY1, VAL1) -//%TEST_VALUE##VHELPER(dict, value, KEY2, kGPBUnrecognizedEnumeratorValue) +//%TEST_VALUE##VHELPER(VALUE_NAME, dict, value, KEY2, kGPBUnrecognizedEnumeratorValue) //%TEST_RAW_VALUE##VHELPER(dict, value, KEY2, VAL2) //%TEST_RAW_VALUE##VHELPER(dict, value, KEY3, VAL3) -//%RAW_VALUE_NOT_FOUND##VHELPER(dict, KEY4) +//%RAW_VALUE_NOT_FOUND##VHELPER(VALUE_NAME, dict, KEY4) //% //% __block NSUInteger idx = 0; //% KEY_TYPE KisP##*seenKeys = malloc(3 * sizeof(KEY_TYPE##KisP)); //% VALUE_TYPE *seenValues = malloc(3 * sizeof(VALUE_TYPE)); -//% [dict enumerateKeysAndValuesUsingBlock:^(KEY_TYPE KisP##aKey, VALUE_TYPE aValue, BOOL *stop) { +//% [dict enumerateKeysAndEnumsUsingBlock:^(KEY_TYPE KisP##aKey, VALUE_TYPE aValue, BOOL *stop) { //% XCTAssertLessThan(idx, 3U); //% seenKeys[idx] = aKey; //% seenValues[idx] = aValue; @@ -538,7 +538,7 @@ //% XCTAssertNotNil(dict); //% //% XCTAssertEqual(dict.count, 0U); -//% XCTAssertThrowsSpecificNamed([dict setValue:VAL2 forKey:KEY2], // Unknown +//% XCTAssertThrowsSpecificNamed([dict setEnum:VAL2 forKey:KEY2], // Unknown //% NSException, NSInvalidArgumentException); //% XCTAssertEqual(dict.count, 0U); //% [dict setRawValue:VAL2 forKey:KEY2]; // Unknown @@ -547,18 +547,18 @@ //% const KEY_TYPE KisP##kKeys[] = { KEY1, KEY3, KEY4 }; //% const VALUE_TYPE kValues[] = { VAL1, VAL3, VAL4 }; // Unknown //% DICTIONARY_CLASS_DECL##VHELPER(KEY_NAME, VALUE_NAME, VALUE_TYPE) *dict2 = -//% [[GPB##KEY_NAME##VALUE_NAME##Dictionary alloc] initWithValues:kValues -//% KEY_NAME$S VALUE_NAME$S forKeys:kKeys -//% KEY_NAME$S VALUE_NAME$S count:GPBARRAYSIZE(kValues)]; +//% [[GPB##KEY_NAME##VALUE_NAME##Dictionary alloc] initWithEnums:kValues +//% KEY_NAME$S VALUE_NAME$S forKeys:kKeys +//% KEY_NAME$S VALUE_NAME$S count:GPBARRAYSIZE(kValues)]; //% XCTAssertNotNil(dict2); //% [dict addRawEntriesFromDictionary:dict2]; //% XCTAssertEqual(dict.count, 4U); //% -//%DECLARE_VALUE_STORAGE##VHELPER(VALUE_TYPE, value)TEST_VALUE##VHELPER(dict, value, KEY1, VAL1) -//%TEST_VALUE##VHELPER(dict, value, KEY2, kGPBUnrecognizedEnumeratorValue) +//%DECLARE_VALUE_STORAGE##VHELPER(VALUE_TYPE, value)TEST_VALUE##VHELPER(VALUE_NAME, dict, value, KEY1, VAL1) +//%TEST_VALUE##VHELPER(VALUE_NAME, dict, value, KEY2, kGPBUnrecognizedEnumeratorValue) //%TEST_RAW_VALUE##VHELPER(dict, value, KEY2, VAL2) -//%TEST_VALUE##VHELPER(dict, value, KEY3, VAL3) -//%TEST_VALUE##VHELPER(dict, value, KEY4, kGPBUnrecognizedEnumeratorValue) +//%TEST_VALUE##VHELPER(VALUE_NAME, dict, value, KEY3, VAL3) +//%TEST_VALUE##VHELPER(VALUE_NAME, dict, value, KEY4, kGPBUnrecognizedEnumeratorValue) //%TEST_RAW_VALUE##VHELPER(dict, value, KEY4, VAL4) //% [dict2 release]; //%} @@ -574,34 +574,34 @@ //% XCTAssertNotNil(dict); //% XCTAssertEqual(dict.count, 4U); //% -//% [dict removeValueForKey:KEY2]; +//% [dict removeEnumForKey:KEY2]; //% XCTAssertEqual(dict.count, 3U); -//%DECLARE_VALUE_STORAGE##VHELPER(VALUE_TYPE, value)TEST_VALUE##VHELPER(dict, value, KEY1, VAL1) -//%VALUE_NOT_FOUND##VHELPER(dict, KEY2) -//%TEST_VALUE##VHELPER(dict, value, KEY3, VAL3) +//%DECLARE_VALUE_STORAGE##VHELPER(VALUE_TYPE, value)TEST_VALUE##VHELPER(VALUE_NAME, dict, value, KEY1, VAL1) +//%VALUE_NOT_FOUND##VHELPER(VALUE_NAME, dict, KEY2) +//%TEST_VALUE##VHELPER(VALUE_NAME, dict, value, KEY3, VAL3) //%TEST_RAW_VALUE##VHELPER(dict, value, KEY4, VAL4) //% //% // Remove again does nothing. -//% [dict removeValueForKey:KEY2]; +//% [dict removeEnumForKey:KEY2]; //% XCTAssertEqual(dict.count, 3U); -//%TEST_VALUE##VHELPER(dict, value, KEY1, VAL1) -//%VALUE_NOT_FOUND##VHELPER(dict, KEY2) -//%TEST_VALUE##VHELPER(dict, value, KEY3, VAL3) +//%TEST_VALUE##VHELPER(VALUE_NAME, dict, value, KEY1, VAL1) +//%VALUE_NOT_FOUND##VHELPER(VALUE_NAME, dict, KEY2) +//%TEST_VALUE##VHELPER(VALUE_NAME, dict, value, KEY3, VAL3) //%TEST_RAW_VALUE##VHELPER(dict, value, KEY4, VAL4) //% -//% [dict removeValueForKey:KEY4]; +//% [dict removeEnumForKey:KEY4]; //% XCTAssertEqual(dict.count, 2U); -//%TEST_VALUE##VHELPER(dict, value, KEY1, VAL1) -//%VALUE_NOT_FOUND##VHELPER(dict, KEY2) -//%TEST_VALUE##VHELPER(dict, value, KEY3, VAL3) -//%VALUE_NOT_FOUND##VHELPER(dict, KEY4) +//%TEST_VALUE##VHELPER(VALUE_NAME, dict, value, KEY1, VAL1) +//%VALUE_NOT_FOUND##VHELPER(VALUE_NAME, dict, KEY2) +//%TEST_VALUE##VHELPER(VALUE_NAME, dict, value, KEY3, VAL3) +//%VALUE_NOT_FOUND##VHELPER(VALUE_NAME, dict, KEY4) //% //% [dict removeAll]; //% XCTAssertEqual(dict.count, 0U); -//%VALUE_NOT_FOUND##VHELPER(dict, KEY1) -//%VALUE_NOT_FOUND##VHELPER(dict, KEY2) -//%VALUE_NOT_FOUND##VHELPER(dict, KEY3) -//%VALUE_NOT_FOUND##VHELPER(dict, KEY4) +//%VALUE_NOT_FOUND##VHELPER(VALUE_NAME, dict, KEY1) +//%VALUE_NOT_FOUND##VHELPER(VALUE_NAME, dict, KEY2) +//%VALUE_NOT_FOUND##VHELPER(VALUE_NAME, dict, KEY3) +//%VALUE_NOT_FOUND##VHELPER(VALUE_NAME, dict, KEY4) //% [dict release]; //%} //% @@ -615,32 +615,32 @@ //% KEY_NAME$S VALUE_NAME$S count:GPBARRAYSIZE(kValues)]; //% XCTAssertNotNil(dict); //% XCTAssertEqual(dict.count, 4U); -//%DECLARE_VALUE_STORAGE##VHELPER(VALUE_TYPE, value)TEST_VALUE##VHELPER(dict, value, KEY1, VAL1) +//%DECLARE_VALUE_STORAGE##VHELPER(VALUE_TYPE, value)TEST_VALUE##VHELPER(VALUE_NAME, dict, value, KEY1, VAL1) //%TEST_RAW_VALUE##VHELPER(dict, value, KEY2, VAL2) -//%TEST_VALUE##VHELPER(dict, value, KEY3, VAL3) +//%TEST_VALUE##VHELPER(VALUE_NAME, dict, value, KEY3, VAL3) //%TEST_RAW_VALUE##VHELPER(dict, value, KEY4, VAL4) //% -//% XCTAssertThrowsSpecificNamed([dict setValue:VAL4 forKey:KEY1], // Unknown +//% XCTAssertThrowsSpecificNamed([dict setEnum:VAL4 forKey:KEY1], // Unknown //% NSException, NSInvalidArgumentException); //% XCTAssertEqual(dict.count, 4U); -//%TEST_VALUE##VHELPER(dict, value, KEY1, VAL1) +//%TEST_VALUE##VHELPER(VALUE_NAME, dict, value, KEY1, VAL1) //%TEST_RAW_VALUE##VHELPER(dict, value, KEY2, VAL2) -//%TEST_VALUE##VHELPER(dict, value, KEY3, VAL3) +//%TEST_VALUE##VHELPER(VALUE_NAME, dict, value, KEY3, VAL3) //%TEST_RAW_VALUE##VHELPER(dict, value, KEY4, VAL4) //% //% [dict setRawValue:VAL4 forKey:KEY1]; // Unknown //% XCTAssertEqual(dict.count, 4U); //%TEST_RAW_VALUE##VHELPER(dict, value, KEY1, VAL4) //%TEST_RAW_VALUE##VHELPER(dict, value, KEY2, VAL2) -//%TEST_VALUE##VHELPER(dict, value, KEY3, VAL3) +//%TEST_VALUE##VHELPER(VALUE_NAME, dict, value, KEY3, VAL3) //%TEST_RAW_VALUE##VHELPER(dict, value, KEY4, VAL4) //% //% [dict setRawValue:VAL1 forKey:KEY4]; //% XCTAssertEqual(dict.count, 4U); //%TEST_RAW_VALUE##VHELPER(dict, value, KEY1, VAL4) //%TEST_RAW_VALUE##VHELPER(dict, value, KEY2, VAL2) -//%TEST_VALUE##VHELPER(dict, value, KEY3, VAL3) -//%TEST_VALUE##VHELPER(dict, value, KEY4, VAL1) +//%TEST_VALUE##VHELPER(VALUE_NAME, dict, value, KEY3, VAL3) +//%TEST_VALUE##VHELPER(VALUE_NAME, dict, value, KEY4, VAL1) //% //% const KEY_TYPE KisP##kKeys2[] = { KEY2, KEY3 }; //% const VALUE_TYPE kValues2[] = { VAL3, VAL2 }; // Unknown @@ -653,9 +653,9 @@ //% [dict addRawEntriesFromDictionary:dict2]; //% XCTAssertEqual(dict.count, 4U); //%TEST_RAW_VALUE##VHELPER(dict, value, KEY1, VAL4) -//%TEST_VALUE##VHELPER(dict, value, KEY2, VAL3) +//%TEST_VALUE##VHELPER(VALUE_NAME, dict, value, KEY2, VAL3) //%TEST_RAW_VALUE##VHELPER(dict, value, KEY3, VAL2) -//%TEST_VALUE##VHELPER(dict, value, KEY4, VAL1) +//%TEST_VALUE##VHELPER(VALUE_NAME, dict, value, KEY4, VAL1) //% //% [dict2 release]; //% [dict release]; @@ -694,19 +694,19 @@ //%PDDM-DEFINE DECLARE_VALUE_STORAGEPOD(VALUE_TYPE, NAME) //% VALUE_TYPE NAME; //% -//%PDDM-DEFINE VALUE_NOT_FOUNDPOD(DICT, KEY) -//% XCTAssertFalse([DICT valueForKey:KEY value:NULL]); -//%PDDM-DEFINE TEST_VALUEPOD(DICT, STORAGE, KEY, VALUE) -//% XCTAssertTrue([DICT valueForKey:KEY value:NULL]); -//% XCTAssertTrue([DICT valueForKey:KEY value:&STORAGE]); +//%PDDM-DEFINE VALUE_NOT_FOUNDPOD(VALUE_NAME, DICT, KEY) +//% XCTAssertFalse([DICT get##VALUE_NAME##:NULL forKey:KEY]); +//%PDDM-DEFINE TEST_VALUEPOD(VALUE_NAME, DICT, STORAGE, KEY, VALUE) +//% XCTAssertTrue([DICT get##VALUE_NAME##:NULL forKey:KEY]); +//% XCTAssertTrue([DICT get##VALUE_NAME##:&STORAGE forKey:KEY]); //% XCTAssertEqual(STORAGE, VALUE); //%PDDM-DEFINE COMPARE_KEYS(KEY1, KEY2) //%KEY1 == KEY2 -//%PDDM-DEFINE RAW_VALUE_NOT_FOUNDPOD(DICT, KEY) -//% XCTAssertFalse([DICT valueForKey:KEY rawValue:NULL]); +//%PDDM-DEFINE RAW_VALUE_NOT_FOUNDPOD(VALUE_NAME, DICT, KEY) +//% XCTAssertFalse([DICT getRawValue:NULL forKey:KEY]); //%PDDM-DEFINE TEST_RAW_VALUEPOD(DICT, STORAGE, KEY, VALUE) -//% XCTAssertTrue([DICT valueForKey:KEY rawValue:NULL]); -//% XCTAssertTrue([DICT valueForKey:KEY rawValue:&STORAGE]); +//% XCTAssertTrue([DICT getRawValue:NULL forKey:KEY]); +//% XCTAssertTrue([DICT getRawValue:&STORAGE forKey:KEY]); //% XCTAssertEqual(STORAGE, VALUE); // @@ -715,9 +715,9 @@ //%PDDM-DEFINE DECLARE_VALUE_STORAGEOBJECT(VALUE_TYPE, NAME) // Empty -//%PDDM-DEFINE VALUE_NOT_FOUNDOBJECT(DICT, KEY) +//%PDDM-DEFINE VALUE_NOT_FOUNDOBJECT(VALUE_NAME, DICT, KEY) //% XCTAssertNil([DICT objectForKey:KEY]); -//%PDDM-DEFINE TEST_VALUEOBJECT(DICT, STORAGE, KEY, VALUE) +//%PDDM-DEFINE TEST_VALUEOBJECT(VALUE_NAME, DICT, STORAGE, KEY, VALUE) //% XCTAssertEqualObjects([DICT objectForKey:KEY], VALUE); //%PDDM-DEFINE COMPARE_KEYSObjects(KEY1, KEY2) //%[KEY1 isEqual:KEY2] @@ -729,10 +729,10 @@ //%PDDM-DEFINE TEST_HELPERS(KEY_NAME, KEY_TYPE, KisP) //%// To let the testing macros work, add some extra methods to simplify things. //%@interface GPB##KEY_NAME##EnumDictionary (TestingTweak) -//%+ (instancetype)dictionaryWithValue:(int32_t)value forKey:(KEY_TYPE##KisP$S##KisP)key; -//%- (instancetype)initWithValues:(const int32_t [])values -//% forKeys:(const KEY_TYPE##KisP$S##KisP [])keys -//% count:(NSUInteger)count; +//%+ (instancetype)dictionaryWithEnum:(int32_t)value forKey:(KEY_TYPE##KisP$S##KisP)key; +//%- (instancetype)initWithEnums:(const int32_t [])values +//% forKeys:(const KEY_TYPE##KisP$S##KisP [])keys +//% count:(NSUInteger)count; //%@end //% //%static BOOL TestingEnum_IsValidValue(int32_t value) { @@ -748,7 +748,7 @@ //%} //% //%@implementation GPB##KEY_NAME##EnumDictionary (TestingTweak) -//%+ (instancetype)dictionaryWithValue:(int32_t)value forKey:(KEY_TYPE##KisP$S##KisP)key { +//%+ (instancetype)dictionaryWithEnum:(int32_t)value forKey:(KEY_TYPE##KisP$S##KisP)key { //% // Cast is needed to compiler knows what class we are invoking initWithValues: on to get the //% // type correct. //% return [[(GPB##KEY_NAME##EnumDictionary*)[self alloc] initWithValidationFunction:TestingEnum_IsValidValue @@ -756,9 +756,9 @@ //% KEY_NAME$S forKeys:&key //% KEY_NAME$S count:1] autorelease]; //%} -//%- (instancetype)initWithValues:(const int32_t [])values -//% forKeys:(const KEY_TYPE##KisP$S##KisP [])keys -//% count:(NSUInteger)count { +//%- (instancetype)initWithEnums:(const int32_t [])values +//% forKeys:(const KEY_TYPE##KisP$S##KisP [])keys +//% count:(NSUInteger)count { //% return [self initWithValidationFunction:TestingEnum_IsValidValue //% rawValues:values //% forKeys:keys @@ -792,8 +792,8 @@ //% DICTIONARY_CLASS_DECL##VHELPER(KEY_NAME, VALUE_NAME, VALUE_TYPE) *dict = [[GPB##KEY_NAME##VALUE_NAME##Dictionary alloc] init]; //% XCTAssertNotNil(dict); //% XCTAssertEqual(dict.count, 0U); -//%VALUE_NOT_FOUND##VHELPER(dict, KEY1) -//% [dict enumerateKeysAnd##VNAME$u##sUsingBlock:^(KEY_TYPE KisP##aKey, VALUE_TYPE a##VNAME$u##, BOOL *stop) { +//%VALUE_NOT_FOUND##VHELPER(VALUE_NAME, dict, KEY1) +//% [dict enumerateKeysAnd##VALUE_NAME##sUsingBlock:^(KEY_TYPE KisP##aKey, VALUE_TYPE a##VNAME$u##, BOOL *stop) { //% #pragma unused(aKey, a##VNAME$u##, stop) //% XCTFail(@"Shouldn't get here!"); //% }]; @@ -801,12 +801,12 @@ //%} //% //%- (void)testOne { -//% DICTIONARY_CLASS_DECL##VHELPER(KEY_NAME, VALUE_NAME, VALUE_TYPE) *dict = [GPB##KEY_NAME##VALUE_NAME##Dictionary dictionaryWith##VNAME$u##:VAL1 forKey:KEY1]; +//% DICTIONARY_CLASS_DECL##VHELPER(KEY_NAME, VALUE_NAME, VALUE_TYPE) *dict = [GPB##KEY_NAME##VALUE_NAME##Dictionary dictionaryWith##VALUE_NAME$u##:VAL1 forKey:KEY1]; //% XCTAssertNotNil(dict); //% XCTAssertEqual(dict.count, 1U); -//%DECLARE_VALUE_STORAGE##VHELPER(VALUE_TYPE, VNAME)TEST_VALUE##VHELPER(dict, VNAME, KEY1, VAL1) -//%VALUE_NOT_FOUND##VHELPER(dict, KEY2) -//% [dict enumerateKeysAnd##VNAME$u##sUsingBlock:^(KEY_TYPE KisP##aKey, VALUE_TYPE a##VNAME$u, BOOL *stop) { +//%DECLARE_VALUE_STORAGE##VHELPER(VALUE_TYPE, VNAME)TEST_VALUE##VHELPER(VALUE_NAME, dict, VNAME, KEY1, VAL1) +//%VALUE_NOT_FOUND##VHELPER(VALUE_NAME, dict, KEY2) +//% [dict enumerateKeysAnd##VALUE_NAME$u##sUsingBlock:^(KEY_TYPE KisP##aKey, VALUE_TYPE a##VNAME$u, BOOL *stop) { //% XCTAssertEqual##KSUFFIX(aKey, KEY1); //% XCTAssertEqual##VSUFFIX(a##VNAME$u, VAL1); //% XCTAssertNotEqual(stop, NULL); @@ -817,18 +817,18 @@ //% const KEY_TYPE KisP##kKeys[] = { KEY1, KEY2 }; //% const VALUE_TYPE k##VNAME$u##s[] = { VAL1, VAL2 }; //% DICTIONARY_CLASS_DECL##VHELPER(KEY_NAME, VALUE_NAME, VALUE_TYPE) *dict = -//% [[GPB##KEY_NAME##VALUE_NAME##Dictionary alloc] initWith##VNAME$u##s:k##VNAME$u##s -//% KEY_NAME$S VALUE_NAME$S ##VNAME$S## forKeys:kKeys -//% KEY_NAME$S VALUE_NAME$S ##VNAME$S## count:GPBARRAYSIZE(k##VNAME$u##s)]; +//% [[GPB##KEY_NAME##VALUE_NAME##Dictionary alloc] initWith##VALUE_NAME##s:k##VNAME$u##s +//% KEY_NAME$S VALUE_NAME$S ##VALUE_NAME$S## forKeys:kKeys +//% KEY_NAME$S VALUE_NAME$S ##VALUE_NAME$S## count:GPBARRAYSIZE(k##VNAME$u##s)]; //% XCTAssertNotNil(dict); //% XCTAssertEqual(dict.count, 2U); -//%DECLARE_VALUE_STORAGE##VHELPER(VALUE_TYPE, VNAME)TEST_VALUE##VHELPER(dict, VNAME, KEY1, VAL1) -//%TEST_VALUE##VHELPER(dict, VNAME, KEY2, VAL2) +//%DECLARE_VALUE_STORAGE##VHELPER(VALUE_TYPE, VNAME)TEST_VALUE##VHELPER(VALUE_NAME, dict, VNAME, KEY1, VAL1) +//%TEST_VALUE##VHELPER(VALUE_NAME, dict, VNAME, KEY2, VAL2) //% //% __block NSUInteger idx = 0; //% KEY_TYPE KisP##*seenKeys = malloc(2 * sizeof(KEY_TYPE##KisP)); //% VALUE_TYPE *seen##VNAME$u##s = malloc(2 * sizeof(VALUE_TYPE)); -//% [dict enumerateKeysAnd##VNAME$u##sUsingBlock:^(KEY_TYPE KisP##aKey, VALUE_TYPE a##VNAME$u##, BOOL *stop) { +//% [dict enumerateKeysAnd##VALUE_NAME$u##sUsingBlock:^(KEY_TYPE KisP##aKey, VALUE_TYPE a##VNAME$u##, BOOL *stop) { //% XCTAssertLessThan(idx, 2U); //% seenKeys[idx] = aKey; //% seen##VNAME$u##s[idx] = a##VNAME$u; @@ -850,7 +850,7 @@ //% //% // Stopping the enumeration. //% idx = 0; -//% [dict enumerateKeysAnd##VNAME$u##sUsingBlock:^(KEY_TYPE KisP##aKey, VALUE_TYPE a##VNAME$u##, BOOL *stop) { +//% [dict enumerateKeysAnd##VALUE_NAME$u##sUsingBlock:^(KEY_TYPE KisP##aKey, VALUE_TYPE a##VNAME$u##, BOOL *stop) { //% #pragma unused(aKey, a##VNAME$u) //% if (idx == 0) *stop = YES; //% XCTAssertNotEqual(idx, 2U); @@ -866,29 +866,29 @@ //% const VALUE_TYPE k##VNAME$u##s2[] = { VAL2, VAL1 }; //% const VALUE_TYPE k##VNAME$u##s3[] = { VAL2 }; //% DICTIONARY_CLASS_DECL##VHELPER(KEY_NAME, VALUE_NAME, VALUE_TYPE) *dict1 = -//% [[GPB##KEY_NAME##VALUE_NAME##Dictionary alloc] initWith##VNAME$u##s:k##VNAME$u##s1 -//% KEY_NAME$S VALUE_NAME$S ##VNAME$S## forKeys:kKeys1 -//% KEY_NAME$S VALUE_NAME$S ##VNAME$S## count:GPBARRAYSIZE(k##VNAME$u##s1)]; +//% [[GPB##KEY_NAME##VALUE_NAME##Dictionary alloc] initWith##VALUE_NAME##s:k##VNAME$u##s1 +//% KEY_NAME$S VALUE_NAME$S ##VALUE_NAME$S## forKeys:kKeys1 +//% KEY_NAME$S VALUE_NAME$S ##VALUE_NAME$S## count:GPBARRAYSIZE(k##VNAME$u##s1)]; //% XCTAssertNotNil(dict1); //% DICTIONARY_CLASS_DECL##VHELPER(KEY_NAME, VALUE_NAME, VALUE_TYPE) *dict1prime = -//% [[GPB##KEY_NAME##VALUE_NAME##Dictionary alloc] initWith##VNAME$u##s:k##VNAME$u##s1 -//% KEY_NAME$S VALUE_NAME$S ##VNAME$S## forKeys:kKeys1 -//% KEY_NAME$S VALUE_NAME$S ##VNAME$S## count:GPBARRAYSIZE(k##VNAME$u##s1)]; +//% [[GPB##KEY_NAME##VALUE_NAME##Dictionary alloc] initWith##VALUE_NAME##s:k##VNAME$u##s1 +//% KEY_NAME$S VALUE_NAME$S ##VALUE_NAME$S## forKeys:kKeys1 +//% KEY_NAME$S VALUE_NAME$S ##VALUE_NAME$S## count:GPBARRAYSIZE(k##VNAME$u##s1)]; //% XCTAssertNotNil(dict1prime); //% DICTIONARY_CLASS_DECL##VHELPER(KEY_NAME, VALUE_NAME, VALUE_TYPE) *dict2 = -//% [[GPB##KEY_NAME##VALUE_NAME##Dictionary alloc] initWith##VNAME$u##s:k##VNAME$u##s2 -//% KEY_NAME$S VALUE_NAME$S ##VNAME$S## forKeys:kKeys1 -//% KEY_NAME$S VALUE_NAME$S ##VNAME$S## count:GPBARRAYSIZE(k##VNAME$u##s2)]; +//% [[GPB##KEY_NAME##VALUE_NAME##Dictionary alloc] initWith##VALUE_NAME##s:k##VNAME$u##s2 +//% KEY_NAME$S VALUE_NAME$S ##VALUE_NAME$S## forKeys:kKeys1 +//% KEY_NAME$S VALUE_NAME$S ##VALUE_NAME$S## count:GPBARRAYSIZE(k##VNAME$u##s2)]; //% XCTAssertNotNil(dict2); //% DICTIONARY_CLASS_DECL##VHELPER(KEY_NAME, VALUE_NAME, VALUE_TYPE) *dict3 = -//% [[GPB##KEY_NAME##VALUE_NAME##Dictionary alloc] initWith##VNAME$u##s:k##VNAME$u##s1 -//% KEY_NAME$S VALUE_NAME$S ##VNAME$S## forKeys:kKeys2 -//% KEY_NAME$S VALUE_NAME$S ##VNAME$S## count:GPBARRAYSIZE(k##VNAME$u##s1)]; +//% [[GPB##KEY_NAME##VALUE_NAME##Dictionary alloc] initWith##VALUE_NAME##s:k##VNAME$u##s1 +//% KEY_NAME$S VALUE_NAME$S ##VALUE_NAME$S## forKeys:kKeys2 +//% KEY_NAME$S VALUE_NAME$S ##VALUE_NAME$S## count:GPBARRAYSIZE(k##VNAME$u##s1)]; //% XCTAssertNotNil(dict3); //% DICTIONARY_CLASS_DECL##VHELPER(KEY_NAME, VALUE_NAME, VALUE_TYPE) *dict4 = -//% [[GPB##KEY_NAME##VALUE_NAME##Dictionary alloc] initWith##VNAME$u##s:k##VNAME$u##s3 -//% KEY_NAME$S VALUE_NAME$S ##VNAME$S## forKeys:kKeys1 -//% KEY_NAME$S VALUE_NAME$S ##VNAME$S## count:GPBARRAYSIZE(k##VNAME$u##s3)]; +//% [[GPB##KEY_NAME##VALUE_NAME##Dictionary alloc] initWith##VALUE_NAME##s:k##VNAME$u##s3 +//% KEY_NAME$S VALUE_NAME$S ##VALUE_NAME$S## forKeys:kKeys1 +//% KEY_NAME$S VALUE_NAME$S ##VALUE_NAME$S## count:GPBARRAYSIZE(k##VNAME$u##s3)]; //% XCTAssertNotNil(dict4); //% //% // 1/1Prime should be different objects, but equal. @@ -917,9 +917,9 @@ //% const KEY_TYPE KisP##kKeys[] = { KEY1, KEY2 }; //% const VALUE_TYPE k##VNAME$u##s[] = { VAL1, VAL2 }; //% DICTIONARY_CLASS_DECL##VHELPER(KEY_NAME, VALUE_NAME, VALUE_TYPE) *dict = -//% [[GPB##KEY_NAME##VALUE_NAME##Dictionary alloc] initWith##VNAME$u##s:k##VNAME$u##s -//% KEY_NAME$S VALUE_NAME$S ##VNAME$S## forKeys:kKeys -//% KEY_NAME$S VALUE_NAME$S ##VNAME$S## count:GPBARRAYSIZE(k##VNAME$u##s)]; +//% [[GPB##KEY_NAME##VALUE_NAME##Dictionary alloc] initWith##VALUE_NAME##s:k##VNAME$u##s +//% KEY_NAME$S VALUE_NAME$S ##VALUE_NAME$S## forKeys:kKeys +//% KEY_NAME$S VALUE_NAME$S ##VALUE_NAME$S## count:GPBARRAYSIZE(k##VNAME$u##s)]; //% XCTAssertNotNil(dict); //% //% DICTIONARY_CLASS_DECL##VHELPER(KEY_NAME, VALUE_NAME, VALUE_TYPE) *dict2 = [dict copy]; @@ -938,9 +938,9 @@ //% const KEY_TYPE KisP##kKeys[] = { KEY1, KEY2 }; //% const VALUE_TYPE k##VNAME$u##s[] = { VAL1, VAL2 }; //% DICTIONARY_CLASS_DECL##VHELPER(KEY_NAME, VALUE_NAME, VALUE_TYPE) *dict = -//% [[GPB##KEY_NAME##VALUE_NAME##Dictionary alloc] initWith##VNAME$u##s:k##VNAME$u##s -//% KEY_NAME$S VALUE_NAME$S ##VNAME$S## forKeys:kKeys -//% KEY_NAME$S VALUE_NAME$S ##VNAME$S## count:GPBARRAYSIZE(k##VNAME$u##s)]; +//% [[GPB##KEY_NAME##VALUE_NAME##Dictionary alloc] initWith##VALUE_NAME##s:k##VNAME$u##s +//% KEY_NAME$S VALUE_NAME$S ##VALUE_NAME$S## forKeys:kKeys +//% KEY_NAME$S VALUE_NAME$S ##VALUE_NAME$S## count:GPBARRAYSIZE(k##VNAME$u##s)]; //% XCTAssertNotNil(dict); //% //% DICTIONARY_CLASS_DECL##VHELPER(KEY_NAME, VALUE_NAME, VALUE_TYPE) *dict2 = @@ -958,21 +958,21 @@ //% XCTAssertNotNil(dict); //% //% XCTAssertEqual(dict.count, 0U); -//% [dict set##VNAME$u:VAL1 forKey:KEY1]; +//% [dict set##VALUE_NAME:VAL1 forKey:KEY1]; //% XCTAssertEqual(dict.count, 1U); //% //% const KEY_TYPE KisP##kKeys[] = { KEY2 }; //% const VALUE_TYPE k##VNAME$u##s[] = { VAL2 }; //% DICTIONARY_CLASS_DECL##VHELPER(KEY_NAME, VALUE_NAME, VALUE_TYPE) *dict2 = -//% [[GPB##KEY_NAME##VALUE_NAME##Dictionary alloc] initWith##VNAME$u##s:k##VNAME$u##s -//% KEY_NAME$S VALUE_NAME$S ##VNAME$S## forKeys:kKeys -//% KEY_NAME$S VALUE_NAME$S ##VNAME$S## count:GPBARRAYSIZE(k##VNAME$u##s)]; +//% [[GPB##KEY_NAME##VALUE_NAME##Dictionary alloc] initWith##VALUE_NAME##s:k##VNAME$u##s +//% KEY_NAME$S VALUE_NAME$S ##VALUE_NAME$S## forKeys:kKeys +//% KEY_NAME$S VALUE_NAME$S ##VALUE_NAME$S## count:GPBARRAYSIZE(k##VNAME$u##s)]; //% XCTAssertNotNil(dict2); //% [dict addEntriesFromDictionary:dict2]; //% XCTAssertEqual(dict.count, 2U); //% -//%DECLARE_VALUE_STORAGE##VHELPER(VALUE_TYPE, VNAME)TEST_VALUE##VHELPER(dict, VNAME, KEY1, VAL1) -//%TEST_VALUE##VHELPER(dict, VNAME, KEY2, VAL2) +//%DECLARE_VALUE_STORAGE##VHELPER(VALUE_TYPE, VNAME)TEST_VALUE##VHELPER(VALUE_NAME, dict, VNAME, KEY1, VAL1) +//%TEST_VALUE##VHELPER(VALUE_NAME, dict, VNAME, KEY2, VAL2) //% [dict2 release]; //%} //% @@ -980,27 +980,27 @@ //% const KEY_TYPE KisP##kKeys[] = { KEY1, KEY2}; //% const VALUE_TYPE k##VNAME$u##s[] = { VAL1, VAL2 }; //% DICTIONARY_CLASS_DECL##VHELPER(KEY_NAME, VALUE_NAME, VALUE_TYPE) *dict = -//% [[GPB##KEY_NAME##VALUE_NAME##Dictionary alloc] initWith##VNAME$u##s:k##VNAME$u##s -//% KEY_NAME$S VALUE_NAME$S ##VNAME$S## forKeys:kKeys -//% KEY_NAME$S VALUE_NAME$S ##VNAME$S## count:GPBARRAYSIZE(k##VNAME$u##s)]; +//% [[GPB##KEY_NAME##VALUE_NAME##Dictionary alloc] initWith##VALUE_NAME##s:k##VNAME$u##s +//% KEY_NAME$S VALUE_NAME$S ##VALUE_NAME$S## forKeys:kKeys +//% KEY_NAME$S VALUE_NAME$S ##VALUE_NAME$S## count:GPBARRAYSIZE(k##VNAME$u##s)]; //% XCTAssertNotNil(dict); //% XCTAssertEqual(dict.count, 2U); //% -//% [dict remove##VNAME$u##ForKey:KEY2]; +//% [dict remove##VALUE_NAME##ForKey:KEY2]; //% XCTAssertEqual(dict.count, 1U); -//%DECLARE_VALUE_STORAGE##VHELPER(VALUE_TYPE, VNAME)TEST_VALUE##VHELPER(dict, VNAME, KEY1, VAL1) -//%VALUE_NOT_FOUND##VHELPER(dict, KEY2) +//%DECLARE_VALUE_STORAGE##VHELPER(VALUE_TYPE, VNAME)TEST_VALUE##VHELPER(VALUE_NAME, dict, VNAME, KEY1, VAL1) +//%VALUE_NOT_FOUND##VHELPER(VALUE_NAME, dict, KEY2) //% //% // Remove again does nothing. -//% [dict remove##VNAME$u##ForKey:KEY2]; +//% [dict remove##VALUE_NAME##ForKey:KEY2]; //% XCTAssertEqual(dict.count, 1U); -//%TEST_VALUE##VHELPER(dict, VNAME, KEY1, VAL1) -//%VALUE_NOT_FOUND##VHELPER(dict, KEY2) +//%TEST_VALUE##VHELPER(VALUE_NAME, dict, VNAME, KEY1, VAL1) +//%VALUE_NOT_FOUND##VHELPER(VALUE_NAME, dict, KEY2) //% //% [dict removeAll]; //% XCTAssertEqual(dict.count, 0U); -//%VALUE_NOT_FOUND##VHELPER(dict, KEY1) -//%VALUE_NOT_FOUND##VHELPER(dict, KEY2) +//%VALUE_NOT_FOUND##VHELPER(VALUE_NAME, dict, KEY1) +//%VALUE_NOT_FOUND##VHELPER(VALUE_NAME, dict, KEY2) //% [dict release]; //%} //% @@ -1008,35 +1008,35 @@ //% const KEY_TYPE KisP##kKeys[] = { KEY1, KEY2 }; //% const VALUE_TYPE k##VNAME$u##s[] = { VAL1, VAL2 }; //% DICTIONARY_CLASS_DECL##VHELPER(KEY_NAME, VALUE_NAME, VALUE_TYPE) *dict = -//% [[GPB##KEY_NAME##VALUE_NAME##Dictionary alloc] initWith##VNAME$u##s:k##VNAME$u##s -//% KEY_NAME$S VALUE_NAME$S ##VNAME$S## forKeys:kKeys -//% KEY_NAME$S VALUE_NAME$S ##VNAME$S## count:GPBARRAYSIZE(k##VNAME$u##s)]; +//% [[GPB##KEY_NAME##VALUE_NAME##Dictionary alloc] initWith##VALUE_NAME##s:k##VNAME$u##s +//% KEY_NAME$S VALUE_NAME$S ##VALUE_NAME$S## forKeys:kKeys +//% KEY_NAME$S VALUE_NAME$S ##VALUE_NAME$S## count:GPBARRAYSIZE(k##VNAME$u##s)]; //% XCTAssertNotNil(dict); //% XCTAssertEqual(dict.count, 2U); -//%DECLARE_VALUE_STORAGE##VHELPER(VALUE_TYPE, VNAME)TEST_VALUE##VHELPER(dict, VNAME, KEY1, VAL1) -//%TEST_VALUE##VHELPER(dict, VNAME, KEY2, VAL2) +//%DECLARE_VALUE_STORAGE##VHELPER(VALUE_TYPE, VNAME)TEST_VALUE##VHELPER(VALUE_NAME, dict, VNAME, KEY1, VAL1) +//%TEST_VALUE##VHELPER(VALUE_NAME, dict, VNAME, KEY2, VAL2) //% -//% [dict set##VNAME$u##:VAL2 forKey:KEY1]; +//% [dict set##VALUE_NAME##:VAL2 forKey:KEY1]; //% XCTAssertEqual(dict.count, 2U); -//%TEST_VALUE##VHELPER(dict, VNAME, KEY1, VAL2) -//%TEST_VALUE##VHELPER(dict, VNAME, KEY2, VAL2) +//%TEST_VALUE##VHELPER(VALUE_NAME, dict, VNAME, KEY1, VAL2) +//%TEST_VALUE##VHELPER(VALUE_NAME, dict, VNAME, KEY2, VAL2) //% -//% [dict set##VNAME$u##:VAL1 forKey:KEY2]; +//% [dict set##VALUE_NAME##:VAL1 forKey:KEY2]; //% XCTAssertEqual(dict.count, 2U); -//%TEST_VALUE##VHELPER(dict, VNAME, KEY1, VAL2) -//%TEST_VALUE##VHELPER(dict, VNAME, KEY2, VAL1) +//%TEST_VALUE##VHELPER(VALUE_NAME, dict, VNAME, KEY1, VAL2) +//%TEST_VALUE##VHELPER(VALUE_NAME, dict, VNAME, KEY2, VAL1) //% //% const KEY_TYPE KisP##kKeys2[] = { KEY2, KEY1 }; //% const VALUE_TYPE k##VNAME$u##s2[] = { VAL2, VAL1 }; //% DICTIONARY_CLASS_DECL##VHELPER(KEY_NAME, VALUE_NAME, VALUE_TYPE) *dict2 = -//% [[GPB##KEY_NAME##VALUE_NAME##Dictionary alloc] initWith##VNAME$u##s:k##VNAME$u##s2 -//% KEY_NAME$S VALUE_NAME$S ##VNAME$S## forKeys:kKeys2 -//% KEY_NAME$S VALUE_NAME$S ##VNAME$S## count:GPBARRAYSIZE(k##VNAME$u##s2)]; +//% [[GPB##KEY_NAME##VALUE_NAME##Dictionary alloc] initWith##VALUE_NAME##s:k##VNAME$u##s2 +//% KEY_NAME$S VALUE_NAME$S ##VALUE_NAME$S## forKeys:kKeys2 +//% KEY_NAME$S VALUE_NAME$S ##VALUE_NAME$S## count:GPBARRAYSIZE(k##VNAME$u##s2)]; //% XCTAssertNotNil(dict2); //% [dict addEntriesFromDictionary:dict2]; //% XCTAssertEqual(dict.count, 2U); -//%TEST_VALUE##VHELPER(dict, VNAME, KEY1, VAL1) -//%TEST_VALUE##VHELPER(dict, VNAME, KEY2, VAL2) +//%TEST_VALUE##VHELPER(VALUE_NAME, dict, VNAME, KEY1, VAL1) +//%TEST_VALUE##VHELPER(VALUE_NAME, dict, VNAME, KEY2, VAL2) //% //% [dict2 release]; //% [dict release]; diff --git a/objectivec/Tests/GPBMessageTests+Serialization.m b/objectivec/Tests/GPBMessageTests+Serialization.m index fad9773a..763af2b0 100644 --- a/objectivec/Tests/GPBMessageTests+Serialization.m +++ b/objectivec/Tests/GPBMessageTests+Serialization.m @@ -987,7 +987,7 @@ static NSData *DataFromCStr(const char *str) { TestMap *msg = [[TestMap alloc] initWithData:data error:NULL]; XCTAssertEqual(msg.mapInt32Int32.count, 1U); int32_t val = 666; - XCTAssertTrue([msg.mapInt32Int32 valueForKey:1 value:&val]); + XCTAssertTrue([msg.mapInt32Int32 getInt32:&val forKey:1]); XCTAssertEqual(val, 1); [msg release]; @@ -1001,7 +1001,7 @@ static NSData *DataFromCStr(const char *str) { TestMap *msg = [[TestMap alloc] initWithData:data error:NULL]; XCTAssertEqual(msg.mapInt32Int32.count, 1U); int32_t val = 666; - XCTAssertTrue([msg.mapInt32Int32 valueForKey:2 value:&val]); + XCTAssertTrue([msg.mapInt32Int32 getInt32:&val forKey:2]); XCTAssertEqual(val, 1); [msg release]; @@ -1015,7 +1015,7 @@ static NSData *DataFromCStr(const char *str) { TestMap *msg = [[TestMap alloc] initWithData:data error:NULL]; XCTAssertEqual(msg.mapInt32Int32.count, 1U); int32_t val = 666; - XCTAssertTrue([msg.mapInt32Int32 valueForKey:2 value:&val]); + XCTAssertTrue([msg.mapInt32Int32 getInt32:&val forKey:2]); XCTAssertEqual(val, 1); [msg release]; @@ -1029,7 +1029,7 @@ static NSData *DataFromCStr(const char *str) { TestMap *msg = [[TestMap alloc] initWithData:data error:NULL]; XCTAssertEqual(msg.mapInt32Int32.count, 1U); int32_t val = 666; - XCTAssertTrue([msg.mapInt32Int32 valueForKey:1 value:&val]); + XCTAssertTrue([msg.mapInt32Int32 getInt32:&val forKey:1]); XCTAssertEqual(val, 2); [msg release]; @@ -1043,7 +1043,7 @@ static NSData *DataFromCStr(const char *str) { TestMap *msg = [[TestMap alloc] initWithData:data error:NULL]; XCTAssertEqual(msg.mapInt32Int32.count, 1U); int32_t val = 666; - XCTAssertTrue([msg.mapInt32Int32 valueForKey:0 value:&val]); + XCTAssertTrue([msg.mapInt32Int32 getInt32:&val forKey:0]); XCTAssertEqual(val, 1); [msg release]; @@ -1057,7 +1057,7 @@ static NSData *DataFromCStr(const char *str) { TestMap *msg = [[TestMap alloc] initWithData:data error:NULL]; XCTAssertEqual(msg.mapInt32Int32.count, 1U); int32_t val = 666; - XCTAssertTrue([msg.mapInt32Int32 valueForKey:1 value:&val]); + XCTAssertTrue([msg.mapInt32Int32 getInt32:&val forKey:1]); XCTAssertEqual(val, 0); [msg release]; @@ -1071,7 +1071,7 @@ static NSData *DataFromCStr(const char *str) { TestMap *msg = [[TestMap alloc] initWithData:data error:NULL]; XCTAssertEqual(msg.mapInt32Int32.count, 1U); int32_t val = 666; - XCTAssertTrue([msg.mapInt32Int32 valueForKey:2 value:&val]); + XCTAssertTrue([msg.mapInt32Int32 getInt32:&val forKey:2]); XCTAssertEqual(val, 3); [msg release]; @@ -1098,17 +1098,17 @@ static NSData *DataFromCStr(const char *str) { dictionaryWithValidationFunction:Proto2MapEnumPlusExtra_IsValidValue]; orig.unknownMapField = [GPBInt32EnumDictionary dictionaryWithValidationFunction:Proto2MapEnumPlusExtra_IsValidValue]; - [orig.knownMapField setValue:Proto2MapEnumPlusExtra_EProto2MapEnumFoo - forKey:0]; - [orig.unknownMapField setValue:Proto2MapEnumPlusExtra_EProto2MapEnumExtra - forKey:0]; + [orig.knownMapField setEnum:Proto2MapEnumPlusExtra_EProto2MapEnumFoo + forKey:0]; + [orig.unknownMapField setEnum:Proto2MapEnumPlusExtra_EProto2MapEnumExtra + forKey:0]; NSData *data = [orig data]; XCTAssertNotNil(data); TestEnumMap *msg1 = [TestEnumMap parseFromData:data error:NULL]; XCTAssertEqual(msg1.knownMapField.count, 1U); int32_t val = -1; - XCTAssertTrue([msg1.knownMapField valueForKey:0 value:&val]); + XCTAssertTrue([msg1.knownMapField getEnum:&val forKey:0]); XCTAssertEqual(val, Proto2MapEnum_Proto2MapEnumFoo); XCTAssertEqual(msg1.unknownFields.countOfFields, 1U); @@ -1117,11 +1117,11 @@ static NSData *DataFromCStr(const char *str) { [TestEnumMapPlusExtra parseFromData:data error:NULL]; val = -1; XCTAssertEqual(msg2.knownMapField.count, 1U); - XCTAssertTrue([msg2.knownMapField valueForKey:0 value:&val]); + XCTAssertTrue([msg2.knownMapField getEnum:&val forKey:0]); XCTAssertEqual(val, Proto2MapEnumPlusExtra_EProto2MapEnumFoo); val = -1; XCTAssertEqual(msg2.unknownMapField.count, 1U); - XCTAssertTrue([msg2.unknownMapField valueForKey:0 value:&val]); + XCTAssertTrue([msg2.unknownMapField getEnum:&val forKey:0]); XCTAssertEqual(val, Proto2MapEnumPlusExtra_EProto2MapEnumExtra); XCTAssertEqual(msg2.unknownFields.countOfFields, 0U); @@ -1137,32 +1137,32 @@ static NSData *DataFromCStr(const char *str) { // Key/Value data should result in different byte lengths on wire to ensure // everything is right. - [msg.mapInt32Int32 setValue:1000 forKey:200]; - [msg.mapInt32Int32 setValue:101 forKey:2001]; - [msg.mapInt64Int64 setValue:1002 forKey:202]; - [msg.mapInt64Int64 setValue:103 forKey:2003]; - [msg.mapUint32Uint32 setValue:1004 forKey:204]; - [msg.mapUint32Uint32 setValue:105 forKey:2005]; - [msg.mapUint64Uint64 setValue:1006 forKey:206]; - [msg.mapUint64Uint64 setValue:107 forKey:2007]; - [msg.mapSint32Sint32 setValue:1008 forKey:208]; - [msg.mapSint32Sint32 setValue:109 forKey:2009]; - [msg.mapSint64Sint64 setValue:1010 forKey:210]; - [msg.mapSint64Sint64 setValue:111 forKey:2011]; - [msg.mapFixed32Fixed32 setValue:1012 forKey:212]; - [msg.mapFixed32Fixed32 setValue:113 forKey:2013]; - [msg.mapFixed64Fixed64 setValue:1014 forKey:214]; - [msg.mapFixed64Fixed64 setValue:115 forKey:2015]; - [msg.mapSfixed32Sfixed32 setValue:1016 forKey:216]; - [msg.mapSfixed32Sfixed32 setValue:117 forKey:2017]; - [msg.mapSfixed64Sfixed64 setValue:1018 forKey:218]; - [msg.mapSfixed64Sfixed64 setValue:119 forKey:2019]; - [msg.mapInt32Float setValue:1020.f forKey:220]; - [msg.mapInt32Float setValue:121.f forKey:2021]; - [msg.mapInt32Double setValue:1022. forKey:222]; - [msg.mapInt32Double setValue:123. forKey:2023]; - [msg.mapBoolBool setValue:false forKey:true]; - [msg.mapBoolBool setValue:true forKey:false]; + [msg.mapInt32Int32 setInt32:1000 forKey:200]; + [msg.mapInt32Int32 setInt32:101 forKey:2001]; + [msg.mapInt64Int64 setInt64:1002 forKey:202]; + [msg.mapInt64Int64 setInt64:103 forKey:2003]; + [msg.mapUint32Uint32 setUInt32:1004 forKey:204]; + [msg.mapUint32Uint32 setUInt32:105 forKey:2005]; + [msg.mapUint64Uint64 setUInt64:1006 forKey:206]; + [msg.mapUint64Uint64 setUInt64:107 forKey:2007]; + [msg.mapSint32Sint32 setInt32:1008 forKey:208]; + [msg.mapSint32Sint32 setInt32:109 forKey:2009]; + [msg.mapSint64Sint64 setInt64:1010 forKey:210]; + [msg.mapSint64Sint64 setInt64:111 forKey:2011]; + [msg.mapFixed32Fixed32 setUInt32:1012 forKey:212]; + [msg.mapFixed32Fixed32 setUInt32:113 forKey:2013]; + [msg.mapFixed64Fixed64 setUInt64:1014 forKey:214]; + [msg.mapFixed64Fixed64 setUInt64:115 forKey:2015]; + [msg.mapSfixed32Sfixed32 setInt32:1016 forKey:216]; + [msg.mapSfixed32Sfixed32 setInt32:117 forKey:2017]; + [msg.mapSfixed64Sfixed64 setInt64:1018 forKey:218]; + [msg.mapSfixed64Sfixed64 setInt64:119 forKey:2019]; + [msg.mapInt32Float setFloat:1020.f forKey:220]; + [msg.mapInt32Float setFloat:121.f forKey:2021]; + [msg.mapInt32Double setDouble:1022. forKey:222]; + [msg.mapInt32Double setDouble:123. forKey:2023]; + [msg.mapBoolBool setBool:false forKey:true]; + [msg.mapBoolBool setBool:true forKey:false]; msg.mapStringString[@"224"] = @"1024"; msg.mapStringString[@"2025"] = @"125"; msg.mapStringBytes[@"226"] = DataFromCStr("1026"); @@ -1171,12 +1171,12 @@ static NSData *DataFromCStr(const char *str) { val1.optionalInt32 = 1028; Message2 *val2 = [[Message2 alloc] init]; val2.optionalInt32 = 129; - [msg.mapStringMessage setValue:val1 forKey:@"228"]; - [msg.mapStringMessage setValue:val2 forKey:@"2029"]; + [msg.mapStringMessage setObject:val1 forKey:@"228"]; + [msg.mapStringMessage setObject:val2 forKey:@"2029"]; [msg.mapInt32Bytes setObject:DataFromCStr("1030 bytes") forKey:230]; [msg.mapInt32Bytes setObject:DataFromCStr("131") forKey:2031]; - [msg.mapInt32Enum setValue:Message2_Enum_Bar forKey:232]; - [msg.mapInt32Enum setValue:Message2_Enum_Baz forKey:2033]; + [msg.mapInt32Enum setEnum:Message2_Enum_Bar forKey:232]; + [msg.mapInt32Enum setEnum:Message2_Enum_Baz forKey:2033]; Message2 *val3 = [[Message2 alloc] init]; val3.optionalInt32 = 1034; Message2 *val4 = [[Message2 alloc] init]; diff --git a/objectivec/Tests/GPBMessageTests.m b/objectivec/Tests/GPBMessageTests.m index 89d1fce2..a3c5a6b4 100644 --- a/objectivec/Tests/GPBMessageTests.m +++ b/objectivec/Tests/GPBMessageTests.m @@ -1171,7 +1171,7 @@ XCTAssertFalse([message2.a hasA]); // But adding an element to the map should. - [message.a.a.iToI setValue:100 forKey:200]; + [message.a.a.iToI setInt32:100 forKey:200]; XCTAssertTrue([message hasA]); XCTAssertTrue([message.a hasA]); XCTAssertEqual([message.a.a.iToI count], (NSUInteger)1); @@ -1190,7 +1190,7 @@ message1a.a.iToI = message1b.a.iToI; XCTAssertTrue([message1a hasA]); XCTAssertFalse([message1b hasA]); - [message1a.a.iToI setValue:1 forKey:2]; + [message1a.a.iToI setInt32:1 forKey:2]; XCTAssertTrue([message1a hasA]); XCTAssertTrue([message1b hasA]); XCTAssertEqual(message1a.a.iToI, message1b.a.iToI); @@ -1224,7 +1224,7 @@ // with different objects that are equal). TestRecursiveMessageWithRepeatedField *message3 = [TestRecursiveMessageWithRepeatedField message]; - message3.iToI = [GPBInt32Int32Dictionary dictionaryWithValue:10 forKey:20]; + message3.iToI = [GPBInt32Int32Dictionary dictionaryWithInt32:10 forKey:20]; message3.strToStr = [NSMutableDictionary dictionaryWithObject:@"abc" forKey:@"123"]; XCTAssertNotNil(message.iToI); @@ -1292,7 +1292,7 @@ XCTAssertFalse([message hasA]); GPBInt32Int32Dictionary *iToI = [message.a.iToI retain]; XCTAssertEqual(iToI->_autocreator, message.a); // Pointer comparision - message.a.iToI = [GPBInt32Int32Dictionary dictionaryWithValue:6 forKey:7]; + message.a.iToI = [GPBInt32Int32Dictionary dictionaryWithInt32:6 forKey:7]; XCTAssertTrue([message hasA]); XCTAssertNotEqual(message.a.iToI, iToI); // Pointer comparision XCTAssertNil(iToI->_autocreator); diff --git a/objectivec/Tests/GPBSwiftTests.swift b/objectivec/Tests/GPBSwiftTests.swift index 36ed2a62..474fde38 100644 --- a/objectivec/Tests/GPBSwiftTests.swift +++ b/objectivec/Tests/GPBSwiftTests.swift @@ -53,12 +53,12 @@ class GPBBridgeTests: XCTestCase { msg.repeatedStringArray.addObject("pqr") msg.repeatedEnumArray.addValue(Message2_Enum.Bar.rawValue) msg.repeatedEnumArray.addValue(Message2_Enum.Baz.rawValue) - msg.mapInt32Int32.setValue(400, forKey:500) - msg.mapInt32Int32.setValue(401, forKey:501) + msg.mapInt32Int32.setInt32(400, forKey:500) + msg.mapInt32Int32.setInt32(401, forKey:501) msg.mapStringString.setObject("foo", forKey:"bar") msg.mapStringString.setObject("abc", forKey:"xyz") - msg.mapInt32Enum.setValue(Message2_Enum.Bar.rawValue, forKey:600) - msg.mapInt32Enum.setValue(Message2_Enum.Baz.rawValue, forKey:601) + msg.mapInt32Enum.setEnum(Message2_Enum.Bar.rawValue, forKey:600) + msg.mapInt32Enum.setEnum(Message2_Enum.Baz.rawValue, forKey:601) // Check has*. XCTAssertTrue(msg.hasOptionalInt32) @@ -90,18 +90,18 @@ class GPBBridgeTests: XCTestCase { XCTAssertEqual(msg.repeatedEnumArray.valueAtIndex(1), Message2_Enum.Baz.rawValue) XCTAssertEqual(msg.repeatedInt64Array.count, UInt(0)) XCTAssertEqual(msg.mapInt32Int32.count, UInt(2)) - var intValue: Int32 = 0; - XCTAssertTrue(msg.mapInt32Int32.valueForKey(500, value:&intValue)) + var intValue: Int32 = 0 + XCTAssertTrue(msg.mapInt32Int32.getInt32(&intValue, forKey: 500)) XCTAssertEqual(intValue, Int32(400)) - XCTAssertTrue(msg.mapInt32Int32.valueForKey(501, value:&intValue)) + XCTAssertTrue(msg.mapInt32Int32.getInt32(&intValue, forKey: 501)) XCTAssertEqual(intValue, Int32(401)) XCTAssertEqual(msg.mapStringString.count, Int(2)) XCTAssertEqual(msg.mapStringString.objectForKey("bar") as? String, "foo") XCTAssertEqual(msg.mapStringString.objectForKey("xyz") as? String, "abc") XCTAssertEqual(msg.mapInt32Enum.count, UInt(2)) - XCTAssertTrue(msg.mapInt32Enum.valueForKey(600, value:&intValue)) + XCTAssertTrue(msg.mapInt32Enum.getEnum(&intValue, forKey:600)) XCTAssertEqual(intValue, Message2_Enum.Bar.rawValue) - XCTAssertTrue(msg.mapInt32Enum.valueForKey(601, value:&intValue)) + XCTAssertTrue(msg.mapInt32Enum.getEnum(&intValue, forKey:601)) XCTAssertEqual(intValue, Message2_Enum.Baz.rawValue) // Clearing a string with nil. @@ -151,11 +151,11 @@ class GPBBridgeTests: XCTestCase { msg.repeatedEnumArray.addValue(Message3_Enum.Bar.rawValue) msg.repeatedEnumArray.addRawValue(666) SetMessage3_OptionalEnum_RawValue(msg2, 666) - msg.mapInt32Int32.setValue(400, forKey:500) - msg.mapInt32Int32.setValue(401, forKey:501) + msg.mapInt32Int32.setInt32(400, forKey:500) + msg.mapInt32Int32.setInt32(401, forKey:501) msg.mapStringString.setObject("foo", forKey:"bar") msg.mapStringString.setObject("abc", forKey:"xyz") - msg.mapInt32Enum.setValue(Message2_Enum.Bar.rawValue, forKey:600) + msg.mapInt32Enum.setEnum(Message2_Enum.Bar.rawValue, forKey:600) // "proto3" syntax lets enum get unknown values. msg.mapInt32Enum.setRawValue(666, forKey:601) @@ -183,20 +183,20 @@ class GPBBridgeTests: XCTestCase { XCTAssertEqual(msg2.optionalEnum, Message3_Enum.GPBUnrecognizedEnumeratorValue) XCTAssertEqual(Message3_OptionalEnum_RawValue(msg2), Int32(666)) XCTAssertEqual(msg.mapInt32Int32.count, UInt(2)) - var intValue: Int32 = 0; - XCTAssertTrue(msg.mapInt32Int32.valueForKey(500, value:&intValue)) + var intValue: Int32 = 0 + XCTAssertTrue(msg.mapInt32Int32.getInt32(&intValue, forKey:500)) XCTAssertEqual(intValue, Int32(400)) - XCTAssertTrue(msg.mapInt32Int32.valueForKey(501, value:&intValue)) + XCTAssertTrue(msg.mapInt32Int32.getInt32(&intValue, forKey:501)) XCTAssertEqual(intValue, Int32(401)) XCTAssertEqual(msg.mapStringString.count, Int(2)) XCTAssertEqual(msg.mapStringString.objectForKey("bar") as? String, "foo") XCTAssertEqual(msg.mapStringString.objectForKey("xyz") as? String, "abc") XCTAssertEqual(msg.mapInt32Enum.count, UInt(2)) - XCTAssertTrue(msg.mapInt32Enum.valueForKey(600, value:&intValue)) + XCTAssertTrue(msg.mapInt32Enum.getEnum(&intValue, forKey:600)) XCTAssertEqual(intValue, Message2_Enum.Bar.rawValue) - XCTAssertTrue(msg.mapInt32Enum.valueForKey(601, value:&intValue)) + XCTAssertTrue(msg.mapInt32Enum.getEnum(&intValue, forKey:601)) XCTAssertEqual(intValue, Message3_Enum.GPBUnrecognizedEnumeratorValue.rawValue) - XCTAssertTrue(msg.mapInt32Enum.valueForKey(601, rawValue:&intValue)) + XCTAssertTrue(msg.mapInt32Enum.getRawValue(&intValue, forKey:601)) XCTAssertEqual(intValue, 666) // Clearing a string with nil. @@ -439,8 +439,8 @@ class GPBBridgeTests: XCTestCase { msg.optionalGroup.a = 102 msg.repeatedStringArray.addObject("abc") msg.repeatedStringArray.addObject("def") - msg.mapInt32Int32.setValue(200, forKey:300) - msg.mapInt32Int32.setValue(201, forKey:201) + msg.mapInt32Int32.setInt32(200, forKey:300) + msg.mapInt32Int32.setInt32(201, forKey:201) msg.mapStringString.setObject("foo", forKey:"bar") msg.mapStringString.setObject("abc", forKey:"xyz") diff --git a/objectivec/Tests/GPBTestUtilities.m b/objectivec/Tests/GPBTestUtilities.m index 726761a7..ebccaac9 100644 --- a/objectivec/Tests/GPBTestUtilities.m +++ b/objectivec/Tests/GPBTestUtilities.m @@ -1089,19 +1089,19 @@ const uint32_t kGPBDefaultRepeatCount = 2; - (void)setAllMapFields:(TestMap *)message numEntries:(uint32_t)count { for (uint32_t i = 0; i < count; i++) { - [message.mapInt32Int32 setValue:(i + 1) forKey:100 + i * 100]; - [message.mapInt64Int64 setValue:(i + 1) forKey:101 + i * 100]; - [message.mapUint32Uint32 setValue:(i + 1) forKey:102 + i * 100]; - [message.mapUint64Uint64 setValue:(i + 1) forKey:103 + i * 100]; - [message.mapSint32Sint32 setValue:(i + 1) forKey:104 + i * 100]; - [message.mapSint64Sint64 setValue:(i + 1) forKey:105 + i * 100]; - [message.mapFixed32Fixed32 setValue:(i + 1) forKey:106 + i * 100]; - [message.mapFixed64Fixed64 setValue:(i + 1) forKey:107 + i * 100]; - [message.mapSfixed32Sfixed32 setValue:(i + 1) forKey:108 + i * 100]; - [message.mapSfixed64Sfixed64 setValue:(i + 1) forKey:109 + i * 100]; - [message.mapInt32Float setValue:(i + 1) forKey:110 + i * 100]; - [message.mapInt32Double setValue:(i + 1) forKey:111 + i * 100]; - [message.mapBoolBool setValue:((i % 2) == 1) forKey:((i % 2) == 0)]; + [message.mapInt32Int32 setInt32:(i + 1) forKey:100 + i * 100]; + [message.mapInt64Int64 setInt64:(i + 1) forKey:101 + i * 100]; + [message.mapUint32Uint32 setUInt32:(i + 1) forKey:102 + i * 100]; + [message.mapUint64Uint64 setUInt64:(i + 1) forKey:103 + i * 100]; + [message.mapSint32Sint32 setInt32:(i + 1) forKey:104 + i * 100]; + [message.mapSint64Sint64 setInt64:(i + 1) forKey:105 + i * 100]; + [message.mapFixed32Fixed32 setUInt32:(i + 1) forKey:106 + i * 100]; + [message.mapFixed64Fixed64 setUInt64:(i + 1) forKey:107 + i * 100]; + [message.mapSfixed32Sfixed32 setInt32:(i + 1) forKey:108 + i * 100]; + [message.mapSfixed64Sfixed64 setInt64:(i + 1) forKey:109 + i * 100]; + [message.mapInt32Float setFloat:(i + 1) forKey:110 + i * 100]; + [message.mapInt32Double setDouble:(i + 1) forKey:111 + i * 100]; + [message.mapBoolBool setBool:((i % 2) == 1) forKey:((i % 2) == 0)]; NSString *keyStr = [[NSString alloc] initWithFormat:@"%d", 112 + i * 100]; NSString *dataStr = [[NSString alloc] initWithFormat:@"%d", i + 1]; @@ -1114,8 +1114,8 @@ const uint32_t kGPBDefaultRepeatCount = 2; [data release]; [message.mapInt32Enum - setValue:(i % 2) ? MapEnum_MapEnumBar : MapEnum_MapEnumBaz - forKey:114 + i * 100]; + setEnum:(i % 2) ? MapEnum_MapEnumBar : MapEnum_MapEnumBaz + forKey:114 + i * 100]; ForeignMessage *subMsg = [[ForeignMessage alloc] init]; subMsg.c = i + 1; -- cgit v1.2.3