| OLD | NEW |
| 1 // Protocol Buffers - Google's data interchange format | 1 // Protocol Buffers - Google's data interchange format |
| 2 // Copyright 2015 Google Inc. All rights reserved. | 2 // Copyright 2015 Google Inc. All rights reserved. |
| 3 // https://developers.google.com/protocol-buffers/ | 3 // https://developers.google.com/protocol-buffers/ |
| 4 // | 4 // |
| 5 // Redistribution and use in source and binary forms, with or without | 5 // Redistribution and use in source and binary forms, with or without |
| 6 // modification, are permitted provided that the following conditions are | 6 // modification, are permitted provided that the following conditions are |
| 7 // met: | 7 // met: |
| 8 // | 8 // |
| 9 // * Redistributions of source code must retain the above copyright | 9 // * Redistributions of source code must retain the above copyright |
| 10 // notice, this list of conditions and the following disclaimer. | 10 // notice, this list of conditions and the following disclaimer. |
| (...skipping 14 matching lines...) Expand all Loading... |
| 25 // LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, | 25 // LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
| 26 // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY | 26 // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
| 27 // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT | 27 // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
| 28 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE | 28 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE |
| 29 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. | 29 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| 30 | 30 |
| 31 #import <Foundation/Foundation.h> | 31 #import <Foundation/Foundation.h> |
| 32 | 32 |
| 33 #import "GPBRuntimeTypes.h" | 33 #import "GPBRuntimeTypes.h" |
| 34 | 34 |
| 35 // These classes are used for repeated fields of basic data types. They are used
because |
| 36 // they perform better than boxing into NSNumbers in NSArrays. |
| 37 |
| 38 // Note: These are not meant to be subclassed. |
| 39 |
| 35 NS_ASSUME_NONNULL_BEGIN | 40 NS_ASSUME_NONNULL_BEGIN |
| 36 | 41 |
| 37 //%PDDM-EXPAND DECLARE_ARRAYS() | 42 //%PDDM-EXPAND DECLARE_ARRAYS() |
| 38 // This block of code is generated, do not edit it directly. | 43 // This block of code is generated, do not edit it directly. |
| 39 | 44 |
| 40 #pragma mark - Int32 | 45 #pragma mark - Int32 |
| 41 | 46 |
| 42 /** | |
| 43 * Class used for repeated fields of int32_t values. This performs better than | |
| 44 * boxing into NSNumbers in NSArrays. | |
| 45 * | |
| 46 * @note This class is not meant to be subclassed. | |
| 47 **/ | |
| 48 @interface GPBInt32Array : NSObject <NSCopying> | 47 @interface GPBInt32Array : NSObject <NSCopying> |
| 49 | 48 |
| 50 /** The number of elements contained in the array. */ | |
| 51 @property(nonatomic, readonly) NSUInteger count; | 49 @property(nonatomic, readonly) NSUInteger count; |
| 52 | 50 |
| 53 /** | |
| 54 * @return A newly instanced and empty GPBInt32Array. | |
| 55 **/ | |
| 56 + (instancetype)array; | 51 + (instancetype)array; |
| 57 | |
| 58 /** | |
| 59 * Creates and initializes a GPBInt32Array with the single element given. | |
| 60 * | |
| 61 * @param value The value to be placed in the array. | |
| 62 * | |
| 63 * @return A newly instanced GPBInt32Array with value in it. | |
| 64 **/ | |
| 65 + (instancetype)arrayWithValue:(int32_t)value; | 52 + (instancetype)arrayWithValue:(int32_t)value; |
| 66 | |
| 67 /** | |
| 68 * Creates and initializes a GPBInt32Array with the contents of the given | |
| 69 * array. | |
| 70 * | |
| 71 * @param array Array with the contents to be put into the new array. | |
| 72 * | |
| 73 * @return A newly instanced GPBInt32Array with the contents of array. | |
| 74 **/ | |
| 75 + (instancetype)arrayWithValueArray:(GPBInt32Array *)array; | 53 + (instancetype)arrayWithValueArray:(GPBInt32Array *)array; |
| 76 | |
| 77 /** | |
| 78 * Creates and initializes a GPBInt32Array with the given capacity. | |
| 79 * | |
| 80 * @param count The capacity needed for the array. | |
| 81 * | |
| 82 * @return A newly instanced GPBInt32Array with a capacity of count. | |
| 83 **/ | |
| 84 + (instancetype)arrayWithCapacity:(NSUInteger)count; | 54 + (instancetype)arrayWithCapacity:(NSUInteger)count; |
| 85 | 55 |
| 86 /** | |
| 87 * @return A newly initialized and empty GPBInt32Array. | |
| 88 **/ | |
| 89 - (instancetype)init NS_DESIGNATED_INITIALIZER; | 56 - (instancetype)init NS_DESIGNATED_INITIALIZER; |
| 90 | 57 // Initializes the array, copying the values. |
| 91 /** | |
| 92 * Initializes the array, copying the given values. | |
| 93 * | |
| 94 * @param values An array with the values to put inside this array. | |
| 95 * @param count The number of elements to copy into the array. | |
| 96 * | |
| 97 * @return A newly initialized GPBInt32Array with a copy of the values. | |
| 98 **/ | |
| 99 - (instancetype)initWithValues:(const int32_t [])values | 58 - (instancetype)initWithValues:(const int32_t [])values |
| 100 count:(NSUInteger)count; | 59 count:(NSUInteger)count; |
| 101 | |
| 102 /** | |
| 103 * Initializes the array, copying the given values. | |
| 104 * | |
| 105 * @param array An array with the values to put inside this array. | |
| 106 * | |
| 107 * @return A newly initialized GPBInt32Array with a copy of the values. | |
| 108 **/ | |
| 109 - (instancetype)initWithValueArray:(GPBInt32Array *)array; | 60 - (instancetype)initWithValueArray:(GPBInt32Array *)array; |
| 110 | |
| 111 /** | |
| 112 * Initializes the array with the given capacity. | |
| 113 * | |
| 114 * @param count The capacity needed for the array. | |
| 115 * | |
| 116 * @return A newly initialized GPBInt32Array with a capacity of count. | |
| 117 **/ | |
| 118 - (instancetype)initWithCapacity:(NSUInteger)count; | 61 - (instancetype)initWithCapacity:(NSUInteger)count; |
| 119 | 62 |
| 120 /** | |
| 121 * Gets the value at the given index. | |
| 122 * | |
| 123 * @param index The index of the value to get. | |
| 124 * | |
| 125 * @return The value at the given index. | |
| 126 **/ | |
| 127 - (int32_t)valueAtIndex:(NSUInteger)index; | 63 - (int32_t)valueAtIndex:(NSUInteger)index; |
| 128 | 64 |
| 129 /** | |
| 130 * Enumerates the values on this array with the given block. | |
| 131 * | |
| 132 * @param block The block to enumerate with. | |
| 133 * **value**: The current value being enumerated. | |
| 134 * **idx**: The index of the current value. | |
| 135 * **stop**: A pointer to a boolean that when set stops the enumeration. | |
| 136 **/ | |
| 137 - (void)enumerateValuesWithBlock:(void (^)(int32_t value, NSUInteger idx, BOOL *
stop))block; | 65 - (void)enumerateValuesWithBlock:(void (^)(int32_t value, NSUInteger idx, BOOL *
stop))block; |
| 138 | |
| 139 /** | |
| 140 * Enumerates the values on this array with the given block. | |
| 141 * | |
| 142 * @param opts Options to control the enumeration. | |
| 143 * @param block The block to enumerate with. | |
| 144 * **value**: The current value being enumerated. | |
| 145 * **idx**: The index of the current value. | |
| 146 * **stop**: A pointer to a boolean that when set stops the enumeration. | |
| 147 **/ | |
| 148 - (void)enumerateValuesWithOptions:(NSEnumerationOptions)opts | 66 - (void)enumerateValuesWithOptions:(NSEnumerationOptions)opts |
| 149 usingBlock:(void (^)(int32_t value, NSUInteger idx, BOOL
*stop))block; | 67 usingBlock:(void (^)(int32_t value, NSUInteger idx, BOOL
*stop))block; |
| 150 | 68 |
| 151 /** | |
| 152 * Adds a value to this array. | |
| 153 * | |
| 154 * @param value The value to add to this array. | |
| 155 **/ | |
| 156 - (void)addValue:(int32_t)value; | 69 - (void)addValue:(int32_t)value; |
| 157 | |
| 158 /** | |
| 159 * Adds values to this array. | |
| 160 * | |
| 161 * @param values The values to add to this array. | |
| 162 * @param count The number of elements to add. | |
| 163 **/ | |
| 164 - (void)addValues:(const int32_t [])values count:(NSUInteger)count; | 70 - (void)addValues:(const int32_t [])values count:(NSUInteger)count; |
| 165 | |
| 166 /** | |
| 167 * Adds the values from the given array to this array. | |
| 168 * | |
| 169 * @param array The array containing the elements to add to this array. | |
| 170 **/ | |
| 171 - (void)addValuesFromArray:(GPBInt32Array *)array; | 71 - (void)addValuesFromArray:(GPBInt32Array *)array; |
| 172 | 72 |
| 173 /** | |
| 174 * Inserts a value into the given position. | |
| 175 * | |
| 176 * @param value The value to add to this array. | |
| 177 * @param index The index into which to insert the value. | |
| 178 **/ | |
| 179 - (void)insertValue:(int32_t)value atIndex:(NSUInteger)index; | 73 - (void)insertValue:(int32_t)value atIndex:(NSUInteger)index; |
| 180 | 74 |
| 181 /** | |
| 182 * Replaces the value at the given index with the given value. | |
| 183 * | |
| 184 * @param index The index for which to replace the value. | |
| 185 * @param value The value to replace with. | |
| 186 **/ | |
| 187 - (void)replaceValueAtIndex:(NSUInteger)index withValue:(int32_t)value; | 75 - (void)replaceValueAtIndex:(NSUInteger)index withValue:(int32_t)value; |
| 188 | 76 |
| 189 /** | |
| 190 * Removes the value at the given index. | |
| 191 * | |
| 192 * @param index The index of the value to remove. | |
| 193 **/ | |
| 194 - (void)removeValueAtIndex:(NSUInteger)index; | 77 - (void)removeValueAtIndex:(NSUInteger)index; |
| 195 | |
| 196 /** | |
| 197 * Removes all the values from this array. | |
| 198 **/ | |
| 199 - (void)removeAll; | 78 - (void)removeAll; |
| 200 | 79 |
| 201 /** | |
| 202 * Exchanges the values between the given indexes. | |
| 203 * | |
| 204 * @param idx1 The index of the first element to exchange. | |
| 205 * @param idx2 The index of the second element to exchange. | |
| 206 **/ | |
| 207 - (void)exchangeValueAtIndex:(NSUInteger)idx1 | 80 - (void)exchangeValueAtIndex:(NSUInteger)idx1 |
| 208 withValueAtIndex:(NSUInteger)idx2; | 81 withValueAtIndex:(NSUInteger)idx2; |
| 209 | 82 |
| 210 @end | 83 @end |
| 211 | 84 |
| 212 #pragma mark - UInt32 | 85 #pragma mark - UInt32 |
| 213 | 86 |
| 214 /** | |
| 215 * Class used for repeated fields of uint32_t values. This performs better than | |
| 216 * boxing into NSNumbers in NSArrays. | |
| 217 * | |
| 218 * @note This class is not meant to be subclassed. | |
| 219 **/ | |
| 220 @interface GPBUInt32Array : NSObject <NSCopying> | 87 @interface GPBUInt32Array : NSObject <NSCopying> |
| 221 | 88 |
| 222 /** The number of elements contained in the array. */ | |
| 223 @property(nonatomic, readonly) NSUInteger count; | 89 @property(nonatomic, readonly) NSUInteger count; |
| 224 | 90 |
| 225 /** | |
| 226 * @return A newly instanced and empty GPBUInt32Array. | |
| 227 **/ | |
| 228 + (instancetype)array; | 91 + (instancetype)array; |
| 229 | |
| 230 /** | |
| 231 * Creates and initializes a GPBUInt32Array with the single element given. | |
| 232 * | |
| 233 * @param value The value to be placed in the array. | |
| 234 * | |
| 235 * @return A newly instanced GPBUInt32Array with value in it. | |
| 236 **/ | |
| 237 + (instancetype)arrayWithValue:(uint32_t)value; | 92 + (instancetype)arrayWithValue:(uint32_t)value; |
| 238 | |
| 239 /** | |
| 240 * Creates and initializes a GPBUInt32Array with the contents of the given | |
| 241 * array. | |
| 242 * | |
| 243 * @param array Array with the contents to be put into the new array. | |
| 244 * | |
| 245 * @return A newly instanced GPBUInt32Array with the contents of array. | |
| 246 **/ | |
| 247 + (instancetype)arrayWithValueArray:(GPBUInt32Array *)array; | 93 + (instancetype)arrayWithValueArray:(GPBUInt32Array *)array; |
| 248 | |
| 249 /** | |
| 250 * Creates and initializes a GPBUInt32Array with the given capacity. | |
| 251 * | |
| 252 * @param count The capacity needed for the array. | |
| 253 * | |
| 254 * @return A newly instanced GPBUInt32Array with a capacity of count. | |
| 255 **/ | |
| 256 + (instancetype)arrayWithCapacity:(NSUInteger)count; | 94 + (instancetype)arrayWithCapacity:(NSUInteger)count; |
| 257 | 95 |
| 258 /** | |
| 259 * @return A newly initialized and empty GPBUInt32Array. | |
| 260 **/ | |
| 261 - (instancetype)init NS_DESIGNATED_INITIALIZER; | 96 - (instancetype)init NS_DESIGNATED_INITIALIZER; |
| 262 | 97 // Initializes the array, copying the values. |
| 263 /** | |
| 264 * Initializes the array, copying the given values. | |
| 265 * | |
| 266 * @param values An array with the values to put inside this array. | |
| 267 * @param count The number of elements to copy into the array. | |
| 268 * | |
| 269 * @return A newly initialized GPBUInt32Array with a copy of the values. | |
| 270 **/ | |
| 271 - (instancetype)initWithValues:(const uint32_t [])values | 98 - (instancetype)initWithValues:(const uint32_t [])values |
| 272 count:(NSUInteger)count; | 99 count:(NSUInteger)count; |
| 273 | |
| 274 /** | |
| 275 * Initializes the array, copying the given values. | |
| 276 * | |
| 277 * @param array An array with the values to put inside this array. | |
| 278 * | |
| 279 * @return A newly initialized GPBUInt32Array with a copy of the values. | |
| 280 **/ | |
| 281 - (instancetype)initWithValueArray:(GPBUInt32Array *)array; | 100 - (instancetype)initWithValueArray:(GPBUInt32Array *)array; |
| 282 | |
| 283 /** | |
| 284 * Initializes the array with the given capacity. | |
| 285 * | |
| 286 * @param count The capacity needed for the array. | |
| 287 * | |
| 288 * @return A newly initialized GPBUInt32Array with a capacity of count. | |
| 289 **/ | |
| 290 - (instancetype)initWithCapacity:(NSUInteger)count; | 101 - (instancetype)initWithCapacity:(NSUInteger)count; |
| 291 | 102 |
| 292 /** | |
| 293 * Gets the value at the given index. | |
| 294 * | |
| 295 * @param index The index of the value to get. | |
| 296 * | |
| 297 * @return The value at the given index. | |
| 298 **/ | |
| 299 - (uint32_t)valueAtIndex:(NSUInteger)index; | 103 - (uint32_t)valueAtIndex:(NSUInteger)index; |
| 300 | 104 |
| 301 /** | |
| 302 * Enumerates the values on this array with the given block. | |
| 303 * | |
| 304 * @param block The block to enumerate with. | |
| 305 * **value**: The current value being enumerated. | |
| 306 * **idx**: The index of the current value. | |
| 307 * **stop**: A pointer to a boolean that when set stops the enumeration. | |
| 308 **/ | |
| 309 - (void)enumerateValuesWithBlock:(void (^)(uint32_t value, NSUInteger idx, BOOL
*stop))block; | 105 - (void)enumerateValuesWithBlock:(void (^)(uint32_t value, NSUInteger idx, BOOL
*stop))block; |
| 310 | |
| 311 /** | |
| 312 * Enumerates the values on this array with the given block. | |
| 313 * | |
| 314 * @param opts Options to control the enumeration. | |
| 315 * @param block The block to enumerate with. | |
| 316 * **value**: The current value being enumerated. | |
| 317 * **idx**: The index of the current value. | |
| 318 * **stop**: A pointer to a boolean that when set stops the enumeration. | |
| 319 **/ | |
| 320 - (void)enumerateValuesWithOptions:(NSEnumerationOptions)opts | 106 - (void)enumerateValuesWithOptions:(NSEnumerationOptions)opts |
| 321 usingBlock:(void (^)(uint32_t value, NSUInteger idx, BOO
L *stop))block; | 107 usingBlock:(void (^)(uint32_t value, NSUInteger idx, BOO
L *stop))block; |
| 322 | 108 |
| 323 /** | |
| 324 * Adds a value to this array. | |
| 325 * | |
| 326 * @param value The value to add to this array. | |
| 327 **/ | |
| 328 - (void)addValue:(uint32_t)value; | 109 - (void)addValue:(uint32_t)value; |
| 329 | |
| 330 /** | |
| 331 * Adds values to this array. | |
| 332 * | |
| 333 * @param values The values to add to this array. | |
| 334 * @param count The number of elements to add. | |
| 335 **/ | |
| 336 - (void)addValues:(const uint32_t [])values count:(NSUInteger)count; | 110 - (void)addValues:(const uint32_t [])values count:(NSUInteger)count; |
| 337 | |
| 338 /** | |
| 339 * Adds the values from the given array to this array. | |
| 340 * | |
| 341 * @param array The array containing the elements to add to this array. | |
| 342 **/ | |
| 343 - (void)addValuesFromArray:(GPBUInt32Array *)array; | 111 - (void)addValuesFromArray:(GPBUInt32Array *)array; |
| 344 | 112 |
| 345 /** | |
| 346 * Inserts a value into the given position. | |
| 347 * | |
| 348 * @param value The value to add to this array. | |
| 349 * @param index The index into which to insert the value. | |
| 350 **/ | |
| 351 - (void)insertValue:(uint32_t)value atIndex:(NSUInteger)index; | 113 - (void)insertValue:(uint32_t)value atIndex:(NSUInteger)index; |
| 352 | 114 |
| 353 /** | |
| 354 * Replaces the value at the given index with the given value. | |
| 355 * | |
| 356 * @param index The index for which to replace the value. | |
| 357 * @param value The value to replace with. | |
| 358 **/ | |
| 359 - (void)replaceValueAtIndex:(NSUInteger)index withValue:(uint32_t)value; | 115 - (void)replaceValueAtIndex:(NSUInteger)index withValue:(uint32_t)value; |
| 360 | 116 |
| 361 /** | |
| 362 * Removes the value at the given index. | |
| 363 * | |
| 364 * @param index The index of the value to remove. | |
| 365 **/ | |
| 366 - (void)removeValueAtIndex:(NSUInteger)index; | 117 - (void)removeValueAtIndex:(NSUInteger)index; |
| 367 | |
| 368 /** | |
| 369 * Removes all the values from this array. | |
| 370 **/ | |
| 371 - (void)removeAll; | 118 - (void)removeAll; |
| 372 | 119 |
| 373 /** | |
| 374 * Exchanges the values between the given indexes. | |
| 375 * | |
| 376 * @param idx1 The index of the first element to exchange. | |
| 377 * @param idx2 The index of the second element to exchange. | |
| 378 **/ | |
| 379 - (void)exchangeValueAtIndex:(NSUInteger)idx1 | 120 - (void)exchangeValueAtIndex:(NSUInteger)idx1 |
| 380 withValueAtIndex:(NSUInteger)idx2; | 121 withValueAtIndex:(NSUInteger)idx2; |
| 381 | 122 |
| 382 @end | 123 @end |
| 383 | 124 |
| 384 #pragma mark - Int64 | 125 #pragma mark - Int64 |
| 385 | 126 |
| 386 /** | |
| 387 * Class used for repeated fields of int64_t values. This performs better than | |
| 388 * boxing into NSNumbers in NSArrays. | |
| 389 * | |
| 390 * @note This class is not meant to be subclassed. | |
| 391 **/ | |
| 392 @interface GPBInt64Array : NSObject <NSCopying> | 127 @interface GPBInt64Array : NSObject <NSCopying> |
| 393 | 128 |
| 394 /** The number of elements contained in the array. */ | |
| 395 @property(nonatomic, readonly) NSUInteger count; | 129 @property(nonatomic, readonly) NSUInteger count; |
| 396 | 130 |
| 397 /** | |
| 398 * @return A newly instanced and empty GPBInt64Array. | |
| 399 **/ | |
| 400 + (instancetype)array; | 131 + (instancetype)array; |
| 401 | |
| 402 /** | |
| 403 * Creates and initializes a GPBInt64Array with the single element given. | |
| 404 * | |
| 405 * @param value The value to be placed in the array. | |
| 406 * | |
| 407 * @return A newly instanced GPBInt64Array with value in it. | |
| 408 **/ | |
| 409 + (instancetype)arrayWithValue:(int64_t)value; | 132 + (instancetype)arrayWithValue:(int64_t)value; |
| 410 | |
| 411 /** | |
| 412 * Creates and initializes a GPBInt64Array with the contents of the given | |
| 413 * array. | |
| 414 * | |
| 415 * @param array Array with the contents to be put into the new array. | |
| 416 * | |
| 417 * @return A newly instanced GPBInt64Array with the contents of array. | |
| 418 **/ | |
| 419 + (instancetype)arrayWithValueArray:(GPBInt64Array *)array; | 133 + (instancetype)arrayWithValueArray:(GPBInt64Array *)array; |
| 420 | |
| 421 /** | |
| 422 * Creates and initializes a GPBInt64Array with the given capacity. | |
| 423 * | |
| 424 * @param count The capacity needed for the array. | |
| 425 * | |
| 426 * @return A newly instanced GPBInt64Array with a capacity of count. | |
| 427 **/ | |
| 428 + (instancetype)arrayWithCapacity:(NSUInteger)count; | 134 + (instancetype)arrayWithCapacity:(NSUInteger)count; |
| 429 | 135 |
| 430 /** | |
| 431 * @return A newly initialized and empty GPBInt64Array. | |
| 432 **/ | |
| 433 - (instancetype)init NS_DESIGNATED_INITIALIZER; | 136 - (instancetype)init NS_DESIGNATED_INITIALIZER; |
| 434 | 137 // Initializes the array, copying the values. |
| 435 /** | |
| 436 * Initializes the array, copying the given values. | |
| 437 * | |
| 438 * @param values An array with the values to put inside this array. | |
| 439 * @param count The number of elements to copy into the array. | |
| 440 * | |
| 441 * @return A newly initialized GPBInt64Array with a copy of the values. | |
| 442 **/ | |
| 443 - (instancetype)initWithValues:(const int64_t [])values | 138 - (instancetype)initWithValues:(const int64_t [])values |
| 444 count:(NSUInteger)count; | 139 count:(NSUInteger)count; |
| 445 | |
| 446 /** | |
| 447 * Initializes the array, copying the given values. | |
| 448 * | |
| 449 * @param array An array with the values to put inside this array. | |
| 450 * | |
| 451 * @return A newly initialized GPBInt64Array with a copy of the values. | |
| 452 **/ | |
| 453 - (instancetype)initWithValueArray:(GPBInt64Array *)array; | 140 - (instancetype)initWithValueArray:(GPBInt64Array *)array; |
| 454 | |
| 455 /** | |
| 456 * Initializes the array with the given capacity. | |
| 457 * | |
| 458 * @param count The capacity needed for the array. | |
| 459 * | |
| 460 * @return A newly initialized GPBInt64Array with a capacity of count. | |
| 461 **/ | |
| 462 - (instancetype)initWithCapacity:(NSUInteger)count; | 141 - (instancetype)initWithCapacity:(NSUInteger)count; |
| 463 | 142 |
| 464 /** | |
| 465 * Gets the value at the given index. | |
| 466 * | |
| 467 * @param index The index of the value to get. | |
| 468 * | |
| 469 * @return The value at the given index. | |
| 470 **/ | |
| 471 - (int64_t)valueAtIndex:(NSUInteger)index; | 143 - (int64_t)valueAtIndex:(NSUInteger)index; |
| 472 | 144 |
| 473 /** | |
| 474 * Enumerates the values on this array with the given block. | |
| 475 * | |
| 476 * @param block The block to enumerate with. | |
| 477 * **value**: The current value being enumerated. | |
| 478 * **idx**: The index of the current value. | |
| 479 * **stop**: A pointer to a boolean that when set stops the enumeration. | |
| 480 **/ | |
| 481 - (void)enumerateValuesWithBlock:(void (^)(int64_t value, NSUInteger idx, BOOL *
stop))block; | 145 - (void)enumerateValuesWithBlock:(void (^)(int64_t value, NSUInteger idx, BOOL *
stop))block; |
| 482 | |
| 483 /** | |
| 484 * Enumerates the values on this array with the given block. | |
| 485 * | |
| 486 * @param opts Options to control the enumeration. | |
| 487 * @param block The block to enumerate with. | |
| 488 * **value**: The current value being enumerated. | |
| 489 * **idx**: The index of the current value. | |
| 490 * **stop**: A pointer to a boolean that when set stops the enumeration. | |
| 491 **/ | |
| 492 - (void)enumerateValuesWithOptions:(NSEnumerationOptions)opts | 146 - (void)enumerateValuesWithOptions:(NSEnumerationOptions)opts |
| 493 usingBlock:(void (^)(int64_t value, NSUInteger idx, BOOL
*stop))block; | 147 usingBlock:(void (^)(int64_t value, NSUInteger idx, BOOL
*stop))block; |
| 494 | 148 |
| 495 /** | |
| 496 * Adds a value to this array. | |
| 497 * | |
| 498 * @param value The value to add to this array. | |
| 499 **/ | |
| 500 - (void)addValue:(int64_t)value; | 149 - (void)addValue:(int64_t)value; |
| 501 | |
| 502 /** | |
| 503 * Adds values to this array. | |
| 504 * | |
| 505 * @param values The values to add to this array. | |
| 506 * @param count The number of elements to add. | |
| 507 **/ | |
| 508 - (void)addValues:(const int64_t [])values count:(NSUInteger)count; | 150 - (void)addValues:(const int64_t [])values count:(NSUInteger)count; |
| 509 | |
| 510 /** | |
| 511 * Adds the values from the given array to this array. | |
| 512 * | |
| 513 * @param array The array containing the elements to add to this array. | |
| 514 **/ | |
| 515 - (void)addValuesFromArray:(GPBInt64Array *)array; | 151 - (void)addValuesFromArray:(GPBInt64Array *)array; |
| 516 | 152 |
| 517 /** | |
| 518 * Inserts a value into the given position. | |
| 519 * | |
| 520 * @param value The value to add to this array. | |
| 521 * @param index The index into which to insert the value. | |
| 522 **/ | |
| 523 - (void)insertValue:(int64_t)value atIndex:(NSUInteger)index; | 153 - (void)insertValue:(int64_t)value atIndex:(NSUInteger)index; |
| 524 | 154 |
| 525 /** | |
| 526 * Replaces the value at the given index with the given value. | |
| 527 * | |
| 528 * @param index The index for which to replace the value. | |
| 529 * @param value The value to replace with. | |
| 530 **/ | |
| 531 - (void)replaceValueAtIndex:(NSUInteger)index withValue:(int64_t)value; | 155 - (void)replaceValueAtIndex:(NSUInteger)index withValue:(int64_t)value; |
| 532 | 156 |
| 533 /** | |
| 534 * Removes the value at the given index. | |
| 535 * | |
| 536 * @param index The index of the value to remove. | |
| 537 **/ | |
| 538 - (void)removeValueAtIndex:(NSUInteger)index; | 157 - (void)removeValueAtIndex:(NSUInteger)index; |
| 539 | |
| 540 /** | |
| 541 * Removes all the values from this array. | |
| 542 **/ | |
| 543 - (void)removeAll; | 158 - (void)removeAll; |
| 544 | 159 |
| 545 /** | |
| 546 * Exchanges the values between the given indexes. | |
| 547 * | |
| 548 * @param idx1 The index of the first element to exchange. | |
| 549 * @param idx2 The index of the second element to exchange. | |
| 550 **/ | |
| 551 - (void)exchangeValueAtIndex:(NSUInteger)idx1 | 160 - (void)exchangeValueAtIndex:(NSUInteger)idx1 |
| 552 withValueAtIndex:(NSUInteger)idx2; | 161 withValueAtIndex:(NSUInteger)idx2; |
| 553 | 162 |
| 554 @end | 163 @end |
| 555 | 164 |
| 556 #pragma mark - UInt64 | 165 #pragma mark - UInt64 |
| 557 | 166 |
| 558 /** | |
| 559 * Class used for repeated fields of uint64_t values. This performs better than | |
| 560 * boxing into NSNumbers in NSArrays. | |
| 561 * | |
| 562 * @note This class is not meant to be subclassed. | |
| 563 **/ | |
| 564 @interface GPBUInt64Array : NSObject <NSCopying> | 167 @interface GPBUInt64Array : NSObject <NSCopying> |
| 565 | 168 |
| 566 /** The number of elements contained in the array. */ | |
| 567 @property(nonatomic, readonly) NSUInteger count; | 169 @property(nonatomic, readonly) NSUInteger count; |
| 568 | 170 |
| 569 /** | |
| 570 * @return A newly instanced and empty GPBUInt64Array. | |
| 571 **/ | |
| 572 + (instancetype)array; | 171 + (instancetype)array; |
| 573 | |
| 574 /** | |
| 575 * Creates and initializes a GPBUInt64Array with the single element given. | |
| 576 * | |
| 577 * @param value The value to be placed in the array. | |
| 578 * | |
| 579 * @return A newly instanced GPBUInt64Array with value in it. | |
| 580 **/ | |
| 581 + (instancetype)arrayWithValue:(uint64_t)value; | 172 + (instancetype)arrayWithValue:(uint64_t)value; |
| 582 | |
| 583 /** | |
| 584 * Creates and initializes a GPBUInt64Array with the contents of the given | |
| 585 * array. | |
| 586 * | |
| 587 * @param array Array with the contents to be put into the new array. | |
| 588 * | |
| 589 * @return A newly instanced GPBUInt64Array with the contents of array. | |
| 590 **/ | |
| 591 + (instancetype)arrayWithValueArray:(GPBUInt64Array *)array; | 173 + (instancetype)arrayWithValueArray:(GPBUInt64Array *)array; |
| 592 | |
| 593 /** | |
| 594 * Creates and initializes a GPBUInt64Array with the given capacity. | |
| 595 * | |
| 596 * @param count The capacity needed for the array. | |
| 597 * | |
| 598 * @return A newly instanced GPBUInt64Array with a capacity of count. | |
| 599 **/ | |
| 600 + (instancetype)arrayWithCapacity:(NSUInteger)count; | 174 + (instancetype)arrayWithCapacity:(NSUInteger)count; |
| 601 | 175 |
| 602 /** | |
| 603 * @return A newly initialized and empty GPBUInt64Array. | |
| 604 **/ | |
| 605 - (instancetype)init NS_DESIGNATED_INITIALIZER; | 176 - (instancetype)init NS_DESIGNATED_INITIALIZER; |
| 606 | 177 // Initializes the array, copying the values. |
| 607 /** | |
| 608 * Initializes the array, copying the given values. | |
| 609 * | |
| 610 * @param values An array with the values to put inside this array. | |
| 611 * @param count The number of elements to copy into the array. | |
| 612 * | |
| 613 * @return A newly initialized GPBUInt64Array with a copy of the values. | |
| 614 **/ | |
| 615 - (instancetype)initWithValues:(const uint64_t [])values | 178 - (instancetype)initWithValues:(const uint64_t [])values |
| 616 count:(NSUInteger)count; | 179 count:(NSUInteger)count; |
| 617 | |
| 618 /** | |
| 619 * Initializes the array, copying the given values. | |
| 620 * | |
| 621 * @param array An array with the values to put inside this array. | |
| 622 * | |
| 623 * @return A newly initialized GPBUInt64Array with a copy of the values. | |
| 624 **/ | |
| 625 - (instancetype)initWithValueArray:(GPBUInt64Array *)array; | 180 - (instancetype)initWithValueArray:(GPBUInt64Array *)array; |
| 626 | |
| 627 /** | |
| 628 * Initializes the array with the given capacity. | |
| 629 * | |
| 630 * @param count The capacity needed for the array. | |
| 631 * | |
| 632 * @return A newly initialized GPBUInt64Array with a capacity of count. | |
| 633 **/ | |
| 634 - (instancetype)initWithCapacity:(NSUInteger)count; | 181 - (instancetype)initWithCapacity:(NSUInteger)count; |
| 635 | 182 |
| 636 /** | |
| 637 * Gets the value at the given index. | |
| 638 * | |
| 639 * @param index The index of the value to get. | |
| 640 * | |
| 641 * @return The value at the given index. | |
| 642 **/ | |
| 643 - (uint64_t)valueAtIndex:(NSUInteger)index; | 183 - (uint64_t)valueAtIndex:(NSUInteger)index; |
| 644 | 184 |
| 645 /** | |
| 646 * Enumerates the values on this array with the given block. | |
| 647 * | |
| 648 * @param block The block to enumerate with. | |
| 649 * **value**: The current value being enumerated. | |
| 650 * **idx**: The index of the current value. | |
| 651 * **stop**: A pointer to a boolean that when set stops the enumeration. | |
| 652 **/ | |
| 653 - (void)enumerateValuesWithBlock:(void (^)(uint64_t value, NSUInteger idx, BOOL
*stop))block; | 185 - (void)enumerateValuesWithBlock:(void (^)(uint64_t value, NSUInteger idx, BOOL
*stop))block; |
| 654 | |
| 655 /** | |
| 656 * Enumerates the values on this array with the given block. | |
| 657 * | |
| 658 * @param opts Options to control the enumeration. | |
| 659 * @param block The block to enumerate with. | |
| 660 * **value**: The current value being enumerated. | |
| 661 * **idx**: The index of the current value. | |
| 662 * **stop**: A pointer to a boolean that when set stops the enumeration. | |
| 663 **/ | |
| 664 - (void)enumerateValuesWithOptions:(NSEnumerationOptions)opts | 186 - (void)enumerateValuesWithOptions:(NSEnumerationOptions)opts |
| 665 usingBlock:(void (^)(uint64_t value, NSUInteger idx, BOO
L *stop))block; | 187 usingBlock:(void (^)(uint64_t value, NSUInteger idx, BOO
L *stop))block; |
| 666 | 188 |
| 667 /** | |
| 668 * Adds a value to this array. | |
| 669 * | |
| 670 * @param value The value to add to this array. | |
| 671 **/ | |
| 672 - (void)addValue:(uint64_t)value; | 189 - (void)addValue:(uint64_t)value; |
| 673 | |
| 674 /** | |
| 675 * Adds values to this array. | |
| 676 * | |
| 677 * @param values The values to add to this array. | |
| 678 * @param count The number of elements to add. | |
| 679 **/ | |
| 680 - (void)addValues:(const uint64_t [])values count:(NSUInteger)count; | 190 - (void)addValues:(const uint64_t [])values count:(NSUInteger)count; |
| 681 | |
| 682 /** | |
| 683 * Adds the values from the given array to this array. | |
| 684 * | |
| 685 * @param array The array containing the elements to add to this array. | |
| 686 **/ | |
| 687 - (void)addValuesFromArray:(GPBUInt64Array *)array; | 191 - (void)addValuesFromArray:(GPBUInt64Array *)array; |
| 688 | 192 |
| 689 /** | |
| 690 * Inserts a value into the given position. | |
| 691 * | |
| 692 * @param value The value to add to this array. | |
| 693 * @param index The index into which to insert the value. | |
| 694 **/ | |
| 695 - (void)insertValue:(uint64_t)value atIndex:(NSUInteger)index; | 193 - (void)insertValue:(uint64_t)value atIndex:(NSUInteger)index; |
| 696 | 194 |
| 697 /** | |
| 698 * Replaces the value at the given index with the given value. | |
| 699 * | |
| 700 * @param index The index for which to replace the value. | |
| 701 * @param value The value to replace with. | |
| 702 **/ | |
| 703 - (void)replaceValueAtIndex:(NSUInteger)index withValue:(uint64_t)value; | 195 - (void)replaceValueAtIndex:(NSUInteger)index withValue:(uint64_t)value; |
| 704 | 196 |
| 705 /** | |
| 706 * Removes the value at the given index. | |
| 707 * | |
| 708 * @param index The index of the value to remove. | |
| 709 **/ | |
| 710 - (void)removeValueAtIndex:(NSUInteger)index; | 197 - (void)removeValueAtIndex:(NSUInteger)index; |
| 711 | |
| 712 /** | |
| 713 * Removes all the values from this array. | |
| 714 **/ | |
| 715 - (void)removeAll; | 198 - (void)removeAll; |
| 716 | 199 |
| 717 /** | |
| 718 * Exchanges the values between the given indexes. | |
| 719 * | |
| 720 * @param idx1 The index of the first element to exchange. | |
| 721 * @param idx2 The index of the second element to exchange. | |
| 722 **/ | |
| 723 - (void)exchangeValueAtIndex:(NSUInteger)idx1 | 200 - (void)exchangeValueAtIndex:(NSUInteger)idx1 |
| 724 withValueAtIndex:(NSUInteger)idx2; | 201 withValueAtIndex:(NSUInteger)idx2; |
| 725 | 202 |
| 726 @end | 203 @end |
| 727 | 204 |
| 728 #pragma mark - Float | 205 #pragma mark - Float |
| 729 | 206 |
| 730 /** | |
| 731 * Class used for repeated fields of float values. This performs better than | |
| 732 * boxing into NSNumbers in NSArrays. | |
| 733 * | |
| 734 * @note This class is not meant to be subclassed. | |
| 735 **/ | |
| 736 @interface GPBFloatArray : NSObject <NSCopying> | 207 @interface GPBFloatArray : NSObject <NSCopying> |
| 737 | 208 |
| 738 /** The number of elements contained in the array. */ | |
| 739 @property(nonatomic, readonly) NSUInteger count; | 209 @property(nonatomic, readonly) NSUInteger count; |
| 740 | 210 |
| 741 /** | |
| 742 * @return A newly instanced and empty GPBFloatArray. | |
| 743 **/ | |
| 744 + (instancetype)array; | 211 + (instancetype)array; |
| 745 | |
| 746 /** | |
| 747 * Creates and initializes a GPBFloatArray with the single element given. | |
| 748 * | |
| 749 * @param value The value to be placed in the array. | |
| 750 * | |
| 751 * @return A newly instanced GPBFloatArray with value in it. | |
| 752 **/ | |
| 753 + (instancetype)arrayWithValue:(float)value; | 212 + (instancetype)arrayWithValue:(float)value; |
| 754 | |
| 755 /** | |
| 756 * Creates and initializes a GPBFloatArray with the contents of the given | |
| 757 * array. | |
| 758 * | |
| 759 * @param array Array with the contents to be put into the new array. | |
| 760 * | |
| 761 * @return A newly instanced GPBFloatArray with the contents of array. | |
| 762 **/ | |
| 763 + (instancetype)arrayWithValueArray:(GPBFloatArray *)array; | 213 + (instancetype)arrayWithValueArray:(GPBFloatArray *)array; |
| 764 | |
| 765 /** | |
| 766 * Creates and initializes a GPBFloatArray with the given capacity. | |
| 767 * | |
| 768 * @param count The capacity needed for the array. | |
| 769 * | |
| 770 * @return A newly instanced GPBFloatArray with a capacity of count. | |
| 771 **/ | |
| 772 + (instancetype)arrayWithCapacity:(NSUInteger)count; | 214 + (instancetype)arrayWithCapacity:(NSUInteger)count; |
| 773 | 215 |
| 774 /** | |
| 775 * @return A newly initialized and empty GPBFloatArray. | |
| 776 **/ | |
| 777 - (instancetype)init NS_DESIGNATED_INITIALIZER; | 216 - (instancetype)init NS_DESIGNATED_INITIALIZER; |
| 778 | 217 // Initializes the array, copying the values. |
| 779 /** | |
| 780 * Initializes the array, copying the given values. | |
| 781 * | |
| 782 * @param values An array with the values to put inside this array. | |
| 783 * @param count The number of elements to copy into the array. | |
| 784 * | |
| 785 * @return A newly initialized GPBFloatArray with a copy of the values. | |
| 786 **/ | |
| 787 - (instancetype)initWithValues:(const float [])values | 218 - (instancetype)initWithValues:(const float [])values |
| 788 count:(NSUInteger)count; | 219 count:(NSUInteger)count; |
| 789 | |
| 790 /** | |
| 791 * Initializes the array, copying the given values. | |
| 792 * | |
| 793 * @param array An array with the values to put inside this array. | |
| 794 * | |
| 795 * @return A newly initialized GPBFloatArray with a copy of the values. | |
| 796 **/ | |
| 797 - (instancetype)initWithValueArray:(GPBFloatArray *)array; | 220 - (instancetype)initWithValueArray:(GPBFloatArray *)array; |
| 798 | |
| 799 /** | |
| 800 * Initializes the array with the given capacity. | |
| 801 * | |
| 802 * @param count The capacity needed for the array. | |
| 803 * | |
| 804 * @return A newly initialized GPBFloatArray with a capacity of count. | |
| 805 **/ | |
| 806 - (instancetype)initWithCapacity:(NSUInteger)count; | 221 - (instancetype)initWithCapacity:(NSUInteger)count; |
| 807 | 222 |
| 808 /** | |
| 809 * Gets the value at the given index. | |
| 810 * | |
| 811 * @param index The index of the value to get. | |
| 812 * | |
| 813 * @return The value at the given index. | |
| 814 **/ | |
| 815 - (float)valueAtIndex:(NSUInteger)index; | 223 - (float)valueAtIndex:(NSUInteger)index; |
| 816 | 224 |
| 817 /** | |
| 818 * Enumerates the values on this array with the given block. | |
| 819 * | |
| 820 * @param block The block to enumerate with. | |
| 821 * **value**: The current value being enumerated. | |
| 822 * **idx**: The index of the current value. | |
| 823 * **stop**: A pointer to a boolean that when set stops the enumeration. | |
| 824 **/ | |
| 825 - (void)enumerateValuesWithBlock:(void (^)(float value, NSUInteger idx, BOOL *st
op))block; | 225 - (void)enumerateValuesWithBlock:(void (^)(float value, NSUInteger idx, BOOL *st
op))block; |
| 826 | |
| 827 /** | |
| 828 * Enumerates the values on this array with the given block. | |
| 829 * | |
| 830 * @param opts Options to control the enumeration. | |
| 831 * @param block The block to enumerate with. | |
| 832 * **value**: The current value being enumerated. | |
| 833 * **idx**: The index of the current value. | |
| 834 * **stop**: A pointer to a boolean that when set stops the enumeration. | |
| 835 **/ | |
| 836 - (void)enumerateValuesWithOptions:(NSEnumerationOptions)opts | 226 - (void)enumerateValuesWithOptions:(NSEnumerationOptions)opts |
| 837 usingBlock:(void (^)(float value, NSUInteger idx, BOOL *
stop))block; | 227 usingBlock:(void (^)(float value, NSUInteger idx, BOOL *
stop))block; |
| 838 | 228 |
| 839 /** | |
| 840 * Adds a value to this array. | |
| 841 * | |
| 842 * @param value The value to add to this array. | |
| 843 **/ | |
| 844 - (void)addValue:(float)value; | 229 - (void)addValue:(float)value; |
| 845 | |
| 846 /** | |
| 847 * Adds values to this array. | |
| 848 * | |
| 849 * @param values The values to add to this array. | |
| 850 * @param count The number of elements to add. | |
| 851 **/ | |
| 852 - (void)addValues:(const float [])values count:(NSUInteger)count; | 230 - (void)addValues:(const float [])values count:(NSUInteger)count; |
| 853 | |
| 854 /** | |
| 855 * Adds the values from the given array to this array. | |
| 856 * | |
| 857 * @param array The array containing the elements to add to this array. | |
| 858 **/ | |
| 859 - (void)addValuesFromArray:(GPBFloatArray *)array; | 231 - (void)addValuesFromArray:(GPBFloatArray *)array; |
| 860 | 232 |
| 861 /** | |
| 862 * Inserts a value into the given position. | |
| 863 * | |
| 864 * @param value The value to add to this array. | |
| 865 * @param index The index into which to insert the value. | |
| 866 **/ | |
| 867 - (void)insertValue:(float)value atIndex:(NSUInteger)index; | 233 - (void)insertValue:(float)value atIndex:(NSUInteger)index; |
| 868 | 234 |
| 869 /** | |
| 870 * Replaces the value at the given index with the given value. | |
| 871 * | |
| 872 * @param index The index for which to replace the value. | |
| 873 * @param value The value to replace with. | |
| 874 **/ | |
| 875 - (void)replaceValueAtIndex:(NSUInteger)index withValue:(float)value; | 235 - (void)replaceValueAtIndex:(NSUInteger)index withValue:(float)value; |
| 876 | 236 |
| 877 /** | |
| 878 * Removes the value at the given index. | |
| 879 * | |
| 880 * @param index The index of the value to remove. | |
| 881 **/ | |
| 882 - (void)removeValueAtIndex:(NSUInteger)index; | 237 - (void)removeValueAtIndex:(NSUInteger)index; |
| 883 | |
| 884 /** | |
| 885 * Removes all the values from this array. | |
| 886 **/ | |
| 887 - (void)removeAll; | 238 - (void)removeAll; |
| 888 | 239 |
| 889 /** | |
| 890 * Exchanges the values between the given indexes. | |
| 891 * | |
| 892 * @param idx1 The index of the first element to exchange. | |
| 893 * @param idx2 The index of the second element to exchange. | |
| 894 **/ | |
| 895 - (void)exchangeValueAtIndex:(NSUInteger)idx1 | 240 - (void)exchangeValueAtIndex:(NSUInteger)idx1 |
| 896 withValueAtIndex:(NSUInteger)idx2; | 241 withValueAtIndex:(NSUInteger)idx2; |
| 897 | 242 |
| 898 @end | 243 @end |
| 899 | 244 |
| 900 #pragma mark - Double | 245 #pragma mark - Double |
| 901 | 246 |
| 902 /** | |
| 903 * Class used for repeated fields of double values. This performs better than | |
| 904 * boxing into NSNumbers in NSArrays. | |
| 905 * | |
| 906 * @note This class is not meant to be subclassed. | |
| 907 **/ | |
| 908 @interface GPBDoubleArray : NSObject <NSCopying> | 247 @interface GPBDoubleArray : NSObject <NSCopying> |
| 909 | 248 |
| 910 /** The number of elements contained in the array. */ | |
| 911 @property(nonatomic, readonly) NSUInteger count; | 249 @property(nonatomic, readonly) NSUInteger count; |
| 912 | 250 |
| 913 /** | |
| 914 * @return A newly instanced and empty GPBDoubleArray. | |
| 915 **/ | |
| 916 + (instancetype)array; | 251 + (instancetype)array; |
| 917 | |
| 918 /** | |
| 919 * Creates and initializes a GPBDoubleArray with the single element given. | |
| 920 * | |
| 921 * @param value The value to be placed in the array. | |
| 922 * | |
| 923 * @return A newly instanced GPBDoubleArray with value in it. | |
| 924 **/ | |
| 925 + (instancetype)arrayWithValue:(double)value; | 252 + (instancetype)arrayWithValue:(double)value; |
| 926 | |
| 927 /** | |
| 928 * Creates and initializes a GPBDoubleArray with the contents of the given | |
| 929 * array. | |
| 930 * | |
| 931 * @param array Array with the contents to be put into the new array. | |
| 932 * | |
| 933 * @return A newly instanced GPBDoubleArray with the contents of array. | |
| 934 **/ | |
| 935 + (instancetype)arrayWithValueArray:(GPBDoubleArray *)array; | 253 + (instancetype)arrayWithValueArray:(GPBDoubleArray *)array; |
| 936 | |
| 937 /** | |
| 938 * Creates and initializes a GPBDoubleArray with the given capacity. | |
| 939 * | |
| 940 * @param count The capacity needed for the array. | |
| 941 * | |
| 942 * @return A newly instanced GPBDoubleArray with a capacity of count. | |
| 943 **/ | |
| 944 + (instancetype)arrayWithCapacity:(NSUInteger)count; | 254 + (instancetype)arrayWithCapacity:(NSUInteger)count; |
| 945 | 255 |
| 946 /** | |
| 947 * @return A newly initialized and empty GPBDoubleArray. | |
| 948 **/ | |
| 949 - (instancetype)init NS_DESIGNATED_INITIALIZER; | 256 - (instancetype)init NS_DESIGNATED_INITIALIZER; |
| 950 | 257 // Initializes the array, copying the values. |
| 951 /** | |
| 952 * Initializes the array, copying the given values. | |
| 953 * | |
| 954 * @param values An array with the values to put inside this array. | |
| 955 * @param count The number of elements to copy into the array. | |
| 956 * | |
| 957 * @return A newly initialized GPBDoubleArray with a copy of the values. | |
| 958 **/ | |
| 959 - (instancetype)initWithValues:(const double [])values | 258 - (instancetype)initWithValues:(const double [])values |
| 960 count:(NSUInteger)count; | 259 count:(NSUInteger)count; |
| 961 | |
| 962 /** | |
| 963 * Initializes the array, copying the given values. | |
| 964 * | |
| 965 * @param array An array with the values to put inside this array. | |
| 966 * | |
| 967 * @return A newly initialized GPBDoubleArray with a copy of the values. | |
| 968 **/ | |
| 969 - (instancetype)initWithValueArray:(GPBDoubleArray *)array; | 260 - (instancetype)initWithValueArray:(GPBDoubleArray *)array; |
| 970 | |
| 971 /** | |
| 972 * Initializes the array with the given capacity. | |
| 973 * | |
| 974 * @param count The capacity needed for the array. | |
| 975 * | |
| 976 * @return A newly initialized GPBDoubleArray with a capacity of count. | |
| 977 **/ | |
| 978 - (instancetype)initWithCapacity:(NSUInteger)count; | 261 - (instancetype)initWithCapacity:(NSUInteger)count; |
| 979 | 262 |
| 980 /** | |
| 981 * Gets the value at the given index. | |
| 982 * | |
| 983 * @param index The index of the value to get. | |
| 984 * | |
| 985 * @return The value at the given index. | |
| 986 **/ | |
| 987 - (double)valueAtIndex:(NSUInteger)index; | 263 - (double)valueAtIndex:(NSUInteger)index; |
| 988 | 264 |
| 989 /** | |
| 990 * Enumerates the values on this array with the given block. | |
| 991 * | |
| 992 * @param block The block to enumerate with. | |
| 993 * **value**: The current value being enumerated. | |
| 994 * **idx**: The index of the current value. | |
| 995 * **stop**: A pointer to a boolean that when set stops the enumeration. | |
| 996 **/ | |
| 997 - (void)enumerateValuesWithBlock:(void (^)(double value, NSUInteger idx, BOOL *s
top))block; | 265 - (void)enumerateValuesWithBlock:(void (^)(double value, NSUInteger idx, BOOL *s
top))block; |
| 998 | |
| 999 /** | |
| 1000 * Enumerates the values on this array with the given block. | |
| 1001 * | |
| 1002 * @param opts Options to control the enumeration. | |
| 1003 * @param block The block to enumerate with. | |
| 1004 * **value**: The current value being enumerated. | |
| 1005 * **idx**: The index of the current value. | |
| 1006 * **stop**: A pointer to a boolean that when set stops the enumeration. | |
| 1007 **/ | |
| 1008 - (void)enumerateValuesWithOptions:(NSEnumerationOptions)opts | 266 - (void)enumerateValuesWithOptions:(NSEnumerationOptions)opts |
| 1009 usingBlock:(void (^)(double value, NSUInteger idx, BOOL
*stop))block; | 267 usingBlock:(void (^)(double value, NSUInteger idx, BOOL
*stop))block; |
| 1010 | 268 |
| 1011 /** | |
| 1012 * Adds a value to this array. | |
| 1013 * | |
| 1014 * @param value The value to add to this array. | |
| 1015 **/ | |
| 1016 - (void)addValue:(double)value; | 269 - (void)addValue:(double)value; |
| 1017 | |
| 1018 /** | |
| 1019 * Adds values to this array. | |
| 1020 * | |
| 1021 * @param values The values to add to this array. | |
| 1022 * @param count The number of elements to add. | |
| 1023 **/ | |
| 1024 - (void)addValues:(const double [])values count:(NSUInteger)count; | 270 - (void)addValues:(const double [])values count:(NSUInteger)count; |
| 1025 | |
| 1026 /** | |
| 1027 * Adds the values from the given array to this array. | |
| 1028 * | |
| 1029 * @param array The array containing the elements to add to this array. | |
| 1030 **/ | |
| 1031 - (void)addValuesFromArray:(GPBDoubleArray *)array; | 271 - (void)addValuesFromArray:(GPBDoubleArray *)array; |
| 1032 | 272 |
| 1033 /** | |
| 1034 * Inserts a value into the given position. | |
| 1035 * | |
| 1036 * @param value The value to add to this array. | |
| 1037 * @param index The index into which to insert the value. | |
| 1038 **/ | |
| 1039 - (void)insertValue:(double)value atIndex:(NSUInteger)index; | 273 - (void)insertValue:(double)value atIndex:(NSUInteger)index; |
| 1040 | 274 |
| 1041 /** | |
| 1042 * Replaces the value at the given index with the given value. | |
| 1043 * | |
| 1044 * @param index The index for which to replace the value. | |
| 1045 * @param value The value to replace with. | |
| 1046 **/ | |
| 1047 - (void)replaceValueAtIndex:(NSUInteger)index withValue:(double)value; | 275 - (void)replaceValueAtIndex:(NSUInteger)index withValue:(double)value; |
| 1048 | 276 |
| 1049 /** | |
| 1050 * Removes the value at the given index. | |
| 1051 * | |
| 1052 * @param index The index of the value to remove. | |
| 1053 **/ | |
| 1054 - (void)removeValueAtIndex:(NSUInteger)index; | 277 - (void)removeValueAtIndex:(NSUInteger)index; |
| 1055 | |
| 1056 /** | |
| 1057 * Removes all the values from this array. | |
| 1058 **/ | |
| 1059 - (void)removeAll; | 278 - (void)removeAll; |
| 1060 | 279 |
| 1061 /** | |
| 1062 * Exchanges the values between the given indexes. | |
| 1063 * | |
| 1064 * @param idx1 The index of the first element to exchange. | |
| 1065 * @param idx2 The index of the second element to exchange. | |
| 1066 **/ | |
| 1067 - (void)exchangeValueAtIndex:(NSUInteger)idx1 | 280 - (void)exchangeValueAtIndex:(NSUInteger)idx1 |
| 1068 withValueAtIndex:(NSUInteger)idx2; | 281 withValueAtIndex:(NSUInteger)idx2; |
| 1069 | 282 |
| 1070 @end | 283 @end |
| 1071 | 284 |
| 1072 #pragma mark - Bool | 285 #pragma mark - Bool |
| 1073 | 286 |
| 1074 /** | |
| 1075 * Class used for repeated fields of BOOL values. This performs better than | |
| 1076 * boxing into NSNumbers in NSArrays. | |
| 1077 * | |
| 1078 * @note This class is not meant to be subclassed. | |
| 1079 **/ | |
| 1080 @interface GPBBoolArray : NSObject <NSCopying> | 287 @interface GPBBoolArray : NSObject <NSCopying> |
| 1081 | 288 |
| 1082 /** The number of elements contained in the array. */ | |
| 1083 @property(nonatomic, readonly) NSUInteger count; | 289 @property(nonatomic, readonly) NSUInteger count; |
| 1084 | 290 |
| 1085 /** | |
| 1086 * @return A newly instanced and empty GPBBoolArray. | |
| 1087 **/ | |
| 1088 + (instancetype)array; | 291 + (instancetype)array; |
| 1089 | |
| 1090 /** | |
| 1091 * Creates and initializes a GPBBoolArray with the single element given. | |
| 1092 * | |
| 1093 * @param value The value to be placed in the array. | |
| 1094 * | |
| 1095 * @return A newly instanced GPBBoolArray with value in it. | |
| 1096 **/ | |
| 1097 + (instancetype)arrayWithValue:(BOOL)value; | 292 + (instancetype)arrayWithValue:(BOOL)value; |
| 1098 | |
| 1099 /** | |
| 1100 * Creates and initializes a GPBBoolArray with the contents of the given | |
| 1101 * array. | |
| 1102 * | |
| 1103 * @param array Array with the contents to be put into the new array. | |
| 1104 * | |
| 1105 * @return A newly instanced GPBBoolArray with the contents of array. | |
| 1106 **/ | |
| 1107 + (instancetype)arrayWithValueArray:(GPBBoolArray *)array; | 293 + (instancetype)arrayWithValueArray:(GPBBoolArray *)array; |
| 1108 | |
| 1109 /** | |
| 1110 * Creates and initializes a GPBBoolArray with the given capacity. | |
| 1111 * | |
| 1112 * @param count The capacity needed for the array. | |
| 1113 * | |
| 1114 * @return A newly instanced GPBBoolArray with a capacity of count. | |
| 1115 **/ | |
| 1116 + (instancetype)arrayWithCapacity:(NSUInteger)count; | 294 + (instancetype)arrayWithCapacity:(NSUInteger)count; |
| 1117 | 295 |
| 1118 /** | |
| 1119 * @return A newly initialized and empty GPBBoolArray. | |
| 1120 **/ | |
| 1121 - (instancetype)init NS_DESIGNATED_INITIALIZER; | 296 - (instancetype)init NS_DESIGNATED_INITIALIZER; |
| 1122 | 297 // Initializes the array, copying the values. |
| 1123 /** | |
| 1124 * Initializes the array, copying the given values. | |
| 1125 * | |
| 1126 * @param values An array with the values to put inside this array. | |
| 1127 * @param count The number of elements to copy into the array. | |
| 1128 * | |
| 1129 * @return A newly initialized GPBBoolArray with a copy of the values. | |
| 1130 **/ | |
| 1131 - (instancetype)initWithValues:(const BOOL [])values | 298 - (instancetype)initWithValues:(const BOOL [])values |
| 1132 count:(NSUInteger)count; | 299 count:(NSUInteger)count; |
| 1133 | |
| 1134 /** | |
| 1135 * Initializes the array, copying the given values. | |
| 1136 * | |
| 1137 * @param array An array with the values to put inside this array. | |
| 1138 * | |
| 1139 * @return A newly initialized GPBBoolArray with a copy of the values. | |
| 1140 **/ | |
| 1141 - (instancetype)initWithValueArray:(GPBBoolArray *)array; | 300 - (instancetype)initWithValueArray:(GPBBoolArray *)array; |
| 1142 | |
| 1143 /** | |
| 1144 * Initializes the array with the given capacity. | |
| 1145 * | |
| 1146 * @param count The capacity needed for the array. | |
| 1147 * | |
| 1148 * @return A newly initialized GPBBoolArray with a capacity of count. | |
| 1149 **/ | |
| 1150 - (instancetype)initWithCapacity:(NSUInteger)count; | 301 - (instancetype)initWithCapacity:(NSUInteger)count; |
| 1151 | 302 |
| 1152 /** | |
| 1153 * Gets the value at the given index. | |
| 1154 * | |
| 1155 * @param index The index of the value to get. | |
| 1156 * | |
| 1157 * @return The value at the given index. | |
| 1158 **/ | |
| 1159 - (BOOL)valueAtIndex:(NSUInteger)index; | 303 - (BOOL)valueAtIndex:(NSUInteger)index; |
| 1160 | 304 |
| 1161 /** | |
| 1162 * Enumerates the values on this array with the given block. | |
| 1163 * | |
| 1164 * @param block The block to enumerate with. | |
| 1165 * **value**: The current value being enumerated. | |
| 1166 * **idx**: The index of the current value. | |
| 1167 * **stop**: A pointer to a boolean that when set stops the enumeration. | |
| 1168 **/ | |
| 1169 - (void)enumerateValuesWithBlock:(void (^)(BOOL value, NSUInteger idx, BOOL *sto
p))block; | 305 - (void)enumerateValuesWithBlock:(void (^)(BOOL value, NSUInteger idx, BOOL *sto
p))block; |
| 1170 | |
| 1171 /** | |
| 1172 * Enumerates the values on this array with the given block. | |
| 1173 * | |
| 1174 * @param opts Options to control the enumeration. | |
| 1175 * @param block The block to enumerate with. | |
| 1176 * **value**: The current value being enumerated. | |
| 1177 * **idx**: The index of the current value. | |
| 1178 * **stop**: A pointer to a boolean that when set stops the enumeration. | |
| 1179 **/ | |
| 1180 - (void)enumerateValuesWithOptions:(NSEnumerationOptions)opts | 306 - (void)enumerateValuesWithOptions:(NSEnumerationOptions)opts |
| 1181 usingBlock:(void (^)(BOOL value, NSUInteger idx, BOOL *s
top))block; | 307 usingBlock:(void (^)(BOOL value, NSUInteger idx, BOOL *s
top))block; |
| 1182 | 308 |
| 1183 /** | |
| 1184 * Adds a value to this array. | |
| 1185 * | |
| 1186 * @param value The value to add to this array. | |
| 1187 **/ | |
| 1188 - (void)addValue:(BOOL)value; | 309 - (void)addValue:(BOOL)value; |
| 1189 | |
| 1190 /** | |
| 1191 * Adds values to this array. | |
| 1192 * | |
| 1193 * @param values The values to add to this array. | |
| 1194 * @param count The number of elements to add. | |
| 1195 **/ | |
| 1196 - (void)addValues:(const BOOL [])values count:(NSUInteger)count; | 310 - (void)addValues:(const BOOL [])values count:(NSUInteger)count; |
| 1197 | |
| 1198 /** | |
| 1199 * Adds the values from the given array to this array. | |
| 1200 * | |
| 1201 * @param array The array containing the elements to add to this array. | |
| 1202 **/ | |
| 1203 - (void)addValuesFromArray:(GPBBoolArray *)array; | 311 - (void)addValuesFromArray:(GPBBoolArray *)array; |
| 1204 | 312 |
| 1205 /** | |
| 1206 * Inserts a value into the given position. | |
| 1207 * | |
| 1208 * @param value The value to add to this array. | |
| 1209 * @param index The index into which to insert the value. | |
| 1210 **/ | |
| 1211 - (void)insertValue:(BOOL)value atIndex:(NSUInteger)index; | 313 - (void)insertValue:(BOOL)value atIndex:(NSUInteger)index; |
| 1212 | 314 |
| 1213 /** | |
| 1214 * Replaces the value at the given index with the given value. | |
| 1215 * | |
| 1216 * @param index The index for which to replace the value. | |
| 1217 * @param value The value to replace with. | |
| 1218 **/ | |
| 1219 - (void)replaceValueAtIndex:(NSUInteger)index withValue:(BOOL)value; | 315 - (void)replaceValueAtIndex:(NSUInteger)index withValue:(BOOL)value; |
| 1220 | 316 |
| 1221 /** | |
| 1222 * Removes the value at the given index. | |
| 1223 * | |
| 1224 * @param index The index of the value to remove. | |
| 1225 **/ | |
| 1226 - (void)removeValueAtIndex:(NSUInteger)index; | 317 - (void)removeValueAtIndex:(NSUInteger)index; |
| 1227 | |
| 1228 /** | |
| 1229 * Removes all the values from this array. | |
| 1230 **/ | |
| 1231 - (void)removeAll; | 318 - (void)removeAll; |
| 1232 | 319 |
| 1233 /** | |
| 1234 * Exchanges the values between the given indexes. | |
| 1235 * | |
| 1236 * @param idx1 The index of the first element to exchange. | |
| 1237 * @param idx2 The index of the second element to exchange. | |
| 1238 **/ | |
| 1239 - (void)exchangeValueAtIndex:(NSUInteger)idx1 | 320 - (void)exchangeValueAtIndex:(NSUInteger)idx1 |
| 1240 withValueAtIndex:(NSUInteger)idx2; | 321 withValueAtIndex:(NSUInteger)idx2; |
| 1241 | 322 |
| 1242 @end | 323 @end |
| 1243 | 324 |
| 1244 #pragma mark - Enum | 325 #pragma mark - Enum |
| 1245 | 326 |
| 1246 /** | |
| 1247 * This class is used for repeated fields of int32_t values. This performs | |
| 1248 * better than boxing into NSNumbers in NSArrays. | |
| 1249 * | |
| 1250 * @note This class is not meant to be subclassed. | |
| 1251 **/ | |
| 1252 @interface GPBEnumArray : NSObject <NSCopying> | 327 @interface GPBEnumArray : NSObject <NSCopying> |
| 1253 | 328 |
| 1254 /** The number of elements contained in the array. */ | |
| 1255 @property(nonatomic, readonly) NSUInteger count; | 329 @property(nonatomic, readonly) NSUInteger count; |
| 1256 /** The validation function to check if the enums are valid. */ | |
| 1257 @property(nonatomic, readonly) GPBEnumValidationFunc validationFunc; | 330 @property(nonatomic, readonly) GPBEnumValidationFunc validationFunc; |
| 1258 | 331 |
| 1259 /** | |
| 1260 * @return A newly instanced and empty GPBEnumArray. | |
| 1261 **/ | |
| 1262 + (instancetype)array; | 332 + (instancetype)array; |
| 1263 | |
| 1264 /** | |
| 1265 * Creates and initializes a GPBEnumArray with the enum validation function | |
| 1266 * given. | |
| 1267 * | |
| 1268 * @param func The enum validation function for the array. | |
| 1269 * | |
| 1270 * @return A newly instanced GPBEnumArray. | |
| 1271 **/ | |
| 1272 + (instancetype)arrayWithValidationFunction:(nullable GPBEnumValidationFunc)func
; | 333 + (instancetype)arrayWithValidationFunction:(nullable GPBEnumValidationFunc)func
; |
| 1273 | |
| 1274 /** | |
| 1275 * Creates and initializes a GPBEnumArray with the enum validation function | |
| 1276 * given and the single raw value given. | |
| 1277 * | |
| 1278 * @param func The enum validation function for the array. | |
| 1279 * @param value The raw value to add to this array. | |
| 1280 * | |
| 1281 * @return A newly instanced GPBEnumArray. | |
| 1282 **/ | |
| 1283 + (instancetype)arrayWithValidationFunction:(nullable GPBEnumValidationFunc)func | 334 + (instancetype)arrayWithValidationFunction:(nullable GPBEnumValidationFunc)func |
| 1284 rawValue:(int32_t)value; | 335 rawValue:(int32_t)value; |
| 1285 | |
| 1286 /** | |
| 1287 * Creates and initializes a GPBEnumArray that adds the elements from the | |
| 1288 * given array. | |
| 1289 * | |
| 1290 * @param array Array containing the values to add to the new array. | |
| 1291 * | |
| 1292 * @return A newly instanced GPBEnumArray. | |
| 1293 **/ | |
| 1294 + (instancetype)arrayWithValueArray:(GPBEnumArray *)array; | 336 + (instancetype)arrayWithValueArray:(GPBEnumArray *)array; |
| 1295 | |
| 1296 /** | |
| 1297 * Creates and initializes a GPBEnumArray with the given enum validation | |
| 1298 * function and with the givencapacity. | |
| 1299 * | |
| 1300 * @param func The enum validation function for the array. | |
| 1301 * @param count The capacity needed for the array. | |
| 1302 * | |
| 1303 * @return A newly instanced GPBEnumArray with a capacity of count. | |
| 1304 **/ | |
| 1305 + (instancetype)arrayWithValidationFunction:(nullable GPBEnumValidationFunc)func | 337 + (instancetype)arrayWithValidationFunction:(nullable GPBEnumValidationFunc)func |
| 1306 capacity:(NSUInteger)count; | 338 capacity:(NSUInteger)count; |
| 1307 | 339 |
| 1308 /** | |
| 1309 * Initializes the array with the given enum validation function. | |
| 1310 * | |
| 1311 * @param func The enum validation function for the array. | |
| 1312 * | |
| 1313 * @return A newly initialized GPBEnumArray with a copy of the values. | |
| 1314 **/ | |
| 1315 - (instancetype)initWithValidationFunction:(nullable GPBEnumValidationFunc)func | 340 - (instancetype)initWithValidationFunction:(nullable GPBEnumValidationFunc)func |
| 1316 NS_DESIGNATED_INITIALIZER; | 341 NS_DESIGNATED_INITIALIZER; |
| 1317 | 342 |
| 1318 /** | 343 // Initializes the array, copying the values. |
| 1319 * Initializes the array, copying the given values. | |
| 1320 * | |
| 1321 * @param func The enum validation function for the array. | |
| 1322 * @param values An array with the values to put inside this array. | |
| 1323 * @param count The number of elements to copy into the array. | |
| 1324 * | |
| 1325 * @return A newly initialized GPBEnumArray with a copy of the values. | |
| 1326 **/ | |
| 1327 - (instancetype)initWithValidationFunction:(nullable GPBEnumValidationFunc)func | 344 - (instancetype)initWithValidationFunction:(nullable GPBEnumValidationFunc)func |
| 1328 rawValues:(const int32_t [])values | 345 rawValues:(const int32_t [])values |
| 1329 count:(NSUInteger)count; | 346 count:(NSUInteger)count; |
| 1330 | |
| 1331 /** | |
| 1332 * Initializes the array, copying the given values. | |
| 1333 * | |
| 1334 * @param array An array with the values to put inside this array. | |
| 1335 * | |
| 1336 * @return A newly initialized GPBEnumArray with a copy of the values. | |
| 1337 **/ | |
| 1338 - (instancetype)initWithValueArray:(GPBEnumArray *)array; | 347 - (instancetype)initWithValueArray:(GPBEnumArray *)array; |
| 1339 | |
| 1340 /** | |
| 1341 * Initializes the array with the given capacity. | |
| 1342 * | |
| 1343 * @param func The enum validation function for the array. | |
| 1344 * @param count The capacity needed for the array. | |
| 1345 * | |
| 1346 * @return A newly initialized GPBEnumArray with a capacity of count. | |
| 1347 **/ | |
| 1348 - (instancetype)initWithValidationFunction:(nullable GPBEnumValidationFunc)func | 348 - (instancetype)initWithValidationFunction:(nullable GPBEnumValidationFunc)func |
| 1349 capacity:(NSUInteger)count; | 349 capacity:(NSUInteger)count; |
| 1350 | 350 |
| 1351 // These will return kGPBUnrecognizedEnumeratorValue if the value at index is no
t a | 351 // These will return kGPBUnrecognizedEnumeratorValue if the value at index is no
t a |
| 1352 // valid enumerator as defined by validationFunc. If the actual value is | 352 // valid enumerator as defined by validationFunc. If the actual value is |
| 1353 // desired, use "raw" version of the method. | 353 // desired, use "raw" version of the method. |
| 1354 | 354 |
| 1355 /** | |
| 1356 * Gets the value at the given index. | |
| 1357 * | |
| 1358 * @param index The index of the value to get. | |
| 1359 * | |
| 1360 * @return The value at the given index. | |
| 1361 **/ | |
| 1362 - (int32_t)valueAtIndex:(NSUInteger)index; | 355 - (int32_t)valueAtIndex:(NSUInteger)index; |
| 1363 | 356 |
| 1364 /** | |
| 1365 * Enumerates the values on this array with the given block. | |
| 1366 * | |
| 1367 * @param block The block to enumerate with. | |
| 1368 * **value**: The current value being enumerated. | |
| 1369 * **idx**: The index of the current value. | |
| 1370 * **stop**: A pointer to a boolean that when set stops the enumeration. | |
| 1371 **/ | |
| 1372 - (void)enumerateValuesWithBlock:(void (^)(int32_t value, NSUInteger idx, BOOL *
stop))block; | 357 - (void)enumerateValuesWithBlock:(void (^)(int32_t value, NSUInteger idx, BOOL *
stop))block; |
| 1373 | |
| 1374 /** | |
| 1375 * Enumerates the values on this array with the given block. | |
| 1376 * | |
| 1377 * @param opts Options to control the enumeration. | |
| 1378 * @param block The block to enumerate with. | |
| 1379 * **value**: The current value being enumerated. | |
| 1380 * **idx**: The index of the current value. | |
| 1381 * **stop**: A pointer to a boolean that when set stops the enumeration. | |
| 1382 **/ | |
| 1383 - (void)enumerateValuesWithOptions:(NSEnumerationOptions)opts | 358 - (void)enumerateValuesWithOptions:(NSEnumerationOptions)opts |
| 1384 usingBlock:(void (^)(int32_t value, NSUInteger idx, BOOL
*stop))block; | 359 usingBlock:(void (^)(int32_t value, NSUInteger idx, BOOL
*stop))block; |
| 1385 | 360 |
| 1386 // These methods bypass the validationFunc to provide access to values that were
not | 361 // These methods bypass the validationFunc to provide access to values that were
not |
| 1387 // known at the time the binary was compiled. | 362 // known at the time the binary was compiled. |
| 1388 | 363 |
| 1389 /** | |
| 1390 * Gets the raw enum value at the given index. | |
| 1391 * | |
| 1392 * @param index The index of the raw enum value to get. | |
| 1393 * | |
| 1394 * @return The raw enum value at the given index. | |
| 1395 **/ | |
| 1396 - (int32_t)rawValueAtIndex:(NSUInteger)index; | 364 - (int32_t)rawValueAtIndex:(NSUInteger)index; |
| 1397 | 365 |
| 1398 /** | |
| 1399 * Enumerates the values on this array with the given block. | |
| 1400 * | |
| 1401 * @param block The block to enumerate with. | |
| 1402 * **value**: The current value being enumerated. | |
| 1403 * **idx**: The index of the current value. | |
| 1404 * **stop**: A pointer to a boolean that when set stops the enumeration. | |
| 1405 **/ | |
| 1406 - (void)enumerateRawValuesWithBlock:(void (^)(int32_t value, NSUInteger idx, BOO
L *stop))block; | 366 - (void)enumerateRawValuesWithBlock:(void (^)(int32_t value, NSUInteger idx, BOO
L *stop))block; |
| 1407 | |
| 1408 /** | |
| 1409 * Enumerates the values on this array with the given block. | |
| 1410 * | |
| 1411 * @param opts Options to control the enumeration. | |
| 1412 * @param block The block to enumerate with. | |
| 1413 * **value**: The current value being enumerated. | |
| 1414 * **idx**: The index of the current value. | |
| 1415 * **stop**: A pointer to a boolean that when set stops the enumeration. | |
| 1416 **/ | |
| 1417 - (void)enumerateRawValuesWithOptions:(NSEnumerationOptions)opts | 367 - (void)enumerateRawValuesWithOptions:(NSEnumerationOptions)opts |
| 1418 usingBlock:(void (^)(int32_t value, NSUInteger idx, B
OOL *stop))block; | 368 usingBlock:(void (^)(int32_t value, NSUInteger idx, B
OOL *stop))block; |
| 1419 | 369 |
| 1420 // If value is not a valid enumerator as defined by validationFunc, these | 370 // If value is not a valid enumerator as defined by validationFunc, these |
| 1421 // methods will assert in debug, and will log in release and assign the value | 371 // methods will assert in debug, and will log in release and assign the value |
| 1422 // to the default value. Use the rawValue methods below to assign non enumerator | 372 // to the default value. Use the rawValue methods below to assign non enumerator |
| 1423 // values. | 373 // values. |
| 1424 | 374 |
| 1425 /** | |
| 1426 * Adds a value to this array. | |
| 1427 * | |
| 1428 * @param value The value to add to this array. | |
| 1429 **/ | |
| 1430 - (void)addValue:(int32_t)value; | 375 - (void)addValue:(int32_t)value; |
| 1431 | |
| 1432 /** | |
| 1433 * Adds values to this array. | |
| 1434 * | |
| 1435 * @param values The values to add to this array. | |
| 1436 * @param count The number of elements to add. | |
| 1437 **/ | |
| 1438 - (void)addValues:(const int32_t [])values count:(NSUInteger)count; | 376 - (void)addValues:(const int32_t [])values count:(NSUInteger)count; |
| 1439 | 377 |
| 1440 | |
| 1441 /** | |
| 1442 * Inserts a value into the given position. | |
| 1443 * | |
| 1444 * @param value The value to add to this array. | |
| 1445 * @param index The index into which to insert the value. | |
| 1446 **/ | |
| 1447 - (void)insertValue:(int32_t)value atIndex:(NSUInteger)index; | 378 - (void)insertValue:(int32_t)value atIndex:(NSUInteger)index; |
| 1448 | 379 |
| 1449 /** | |
| 1450 * Replaces the value at the given index with the given value. | |
| 1451 * | |
| 1452 * @param index The index for which to replace the value. | |
| 1453 * @param value The value to replace with. | |
| 1454 **/ | |
| 1455 - (void)replaceValueAtIndex:(NSUInteger)index withValue:(int32_t)value; | 380 - (void)replaceValueAtIndex:(NSUInteger)index withValue:(int32_t)value; |
| 1456 | 381 |
| 1457 // These methods bypass the validationFunc to provide setting of values that wer
e not | 382 // These methods bypass the validationFunc to provide setting of values that wer
e not |
| 1458 // known at the time the binary was compiled. | 383 // known at the time the binary was compiled. |
| 1459 | 384 |
| 1460 /** | |
| 1461 * Adds a raw enum value to this array. | |
| 1462 * | |
| 1463 * @note This method bypass the validationFunc to enable the setting of values t
hat | |
| 1464 * were not known at the time the binary was compiled. | |
| 1465 * | |
| 1466 * @param value The raw enum value to add to the array. | |
| 1467 **/ | |
| 1468 - (void)addRawValue:(int32_t)value; | 385 - (void)addRawValue:(int32_t)value; |
| 1469 | |
| 1470 /** | |
| 1471 * Adds raw enum values to this array. | |
| 1472 * | |
| 1473 * @note This method bypass the validationFunc to enable the setting of values t
hat | |
| 1474 * were not known at the time the binary was compiled. | |
| 1475 * | |
| 1476 * @param array Array containing the raw enum values to add to this array. | |
| 1477 **/ | |
| 1478 - (void)addRawValuesFromArray:(GPBEnumArray *)array; | 386 - (void)addRawValuesFromArray:(GPBEnumArray *)array; |
| 1479 | |
| 1480 /** | |
| 1481 * Adds raw enum values to this array. | |
| 1482 * | |
| 1483 * @note This method bypass the validationFunc to enable the setting of values t
hat | |
| 1484 * were not known at the time the binary was compiled. | |
| 1485 * | |
| 1486 * @param values Array containing the raw enum values to add to this array. | |
| 1487 * @param count The number of raw values to add. | |
| 1488 **/ | |
| 1489 - (void)addRawValues:(const int32_t [])values count:(NSUInteger)count; | 387 - (void)addRawValues:(const int32_t [])values count:(NSUInteger)count; |
| 1490 | 388 |
| 1491 /** | |
| 1492 * Inserts a raw enum value at the given index. | |
| 1493 * | |
| 1494 * @note This method bypass the validationFunc to enable the setting of values t
hat | |
| 1495 * were not known at the time the binary was compiled. | |
| 1496 * | |
| 1497 * @param value Raw enum value to add. | |
| 1498 * @param index The index into which to insert the value. | |
| 1499 **/ | |
| 1500 - (void)insertRawValue:(int32_t)value atIndex:(NSUInteger)index; | 389 - (void)insertRawValue:(int32_t)value atIndex:(NSUInteger)index; |
| 1501 | 390 |
| 1502 /** | |
| 1503 * Replaces the raw enum value at the given index with the given value. | |
| 1504 * | |
| 1505 * @note This method bypass the validationFunc to enable the setting of values t
hat | |
| 1506 * were not known at the time the binary was compiled. | |
| 1507 * | |
| 1508 * @param index The index for which to replace the value. | |
| 1509 * @param value The raw enum value to replace with. | |
| 1510 **/ | |
| 1511 - (void)replaceValueAtIndex:(NSUInteger)index withRawValue:(int32_t)value; | 391 - (void)replaceValueAtIndex:(NSUInteger)index withRawValue:(int32_t)value; |
| 1512 | 392 |
| 1513 // No validation applies to these methods. | 393 // No validation applies to these methods. |
| 1514 | 394 |
| 1515 /** | |
| 1516 * Removes the value at the given index. | |
| 1517 * | |
| 1518 * @param index The index of the value to remove. | |
| 1519 **/ | |
| 1520 - (void)removeValueAtIndex:(NSUInteger)index; | 395 - (void)removeValueAtIndex:(NSUInteger)index; |
| 1521 | |
| 1522 /** | |
| 1523 * Removes all the values from this array. | |
| 1524 **/ | |
| 1525 - (void)removeAll; | 396 - (void)removeAll; |
| 1526 | 397 |
| 1527 /** | |
| 1528 * Exchanges the values between the given indexes. | |
| 1529 * | |
| 1530 * @param idx1 The index of the first element to exchange. | |
| 1531 * @param idx2 The index of the second element to exchange. | |
| 1532 **/ | |
| 1533 - (void)exchangeValueAtIndex:(NSUInteger)idx1 | 398 - (void)exchangeValueAtIndex:(NSUInteger)idx1 |
| 1534 withValueAtIndex:(NSUInteger)idx2; | 399 withValueAtIndex:(NSUInteger)idx2; |
| 1535 | 400 |
| 1536 @end | 401 @end |
| 1537 | 402 |
| 1538 //%PDDM-EXPAND-END DECLARE_ARRAYS() | 403 //%PDDM-EXPAND-END DECLARE_ARRAYS() |
| 1539 | 404 |
| 1540 NS_ASSUME_NONNULL_END | 405 NS_ASSUME_NONNULL_END |
| 1541 | 406 |
| 1542 //%PDDM-DEFINE DECLARE_ARRAYS() | 407 //%PDDM-DEFINE DECLARE_ARRAYS() |
| 1543 //%ARRAY_INTERFACE_SIMPLE(Int32, int32_t) | 408 //%ARRAY_INTERFACE_SIMPLE(Int32, int32_t) |
| 1544 //%ARRAY_INTERFACE_SIMPLE(UInt32, uint32_t) | 409 //%ARRAY_INTERFACE_SIMPLE(UInt32, uint32_t) |
| 1545 //%ARRAY_INTERFACE_SIMPLE(Int64, int64_t) | 410 //%ARRAY_INTERFACE_SIMPLE(Int64, int64_t) |
| 1546 //%ARRAY_INTERFACE_SIMPLE(UInt64, uint64_t) | 411 //%ARRAY_INTERFACE_SIMPLE(UInt64, uint64_t) |
| 1547 //%ARRAY_INTERFACE_SIMPLE(Float, float) | 412 //%ARRAY_INTERFACE_SIMPLE(Float, float) |
| 1548 //%ARRAY_INTERFACE_SIMPLE(Double, double) | 413 //%ARRAY_INTERFACE_SIMPLE(Double, double) |
| 1549 //%ARRAY_INTERFACE_SIMPLE(Bool, BOOL) | 414 //%ARRAY_INTERFACE_SIMPLE(Bool, BOOL) |
| 1550 //%ARRAY_INTERFACE_ENUM(Enum, int32_t) | 415 //%ARRAY_INTERFACE_ENUM(Enum, int32_t) |
| 1551 | 416 |
| 1552 // | 417 // |
| 1553 // The common case (everything but Enum) | 418 // The common case (everything but Enum) |
| 1554 // | 419 // |
| 1555 | 420 |
| 1556 //%PDDM-DEFINE ARRAY_INTERFACE_SIMPLE(NAME, TYPE) | 421 //%PDDM-DEFINE ARRAY_INTERFACE_SIMPLE(NAME, TYPE) |
| 1557 //%#pragma mark - NAME | 422 //%#pragma mark - NAME |
| 1558 //% | 423 //% |
| 1559 //%/** | |
| 1560 //% * Class used for repeated fields of ##TYPE## values. This performs better th
an | |
| 1561 //% * boxing into NSNumbers in NSArrays. | |
| 1562 //% * | |
| 1563 //% * @note This class is not meant to be subclassed. | |
| 1564 //% **/ | |
| 1565 //%@interface GPB##NAME##Array : NSObject <NSCopying> | 424 //%@interface GPB##NAME##Array : NSObject <NSCopying> |
| 1566 //% | 425 //% |
| 1567 //%/** The number of elements contained in the array. */ | |
| 1568 //%@property(nonatomic, readonly) NSUInteger count; | 426 //%@property(nonatomic, readonly) NSUInteger count; |
| 1569 //% | 427 //% |
| 1570 //%/** | |
| 1571 //% * @return A newly instanced and empty GPB##NAME##Array. | |
| 1572 //% **/ | |
| 1573 //%+ (instancetype)array; | 428 //%+ (instancetype)array; |
| 1574 //% | |
| 1575 //%/** | |
| 1576 //% * Creates and initializes a GPB##NAME##Array with the single element given. | |
| 1577 //% * | |
| 1578 //% * @param value The value to be placed in the array. | |
| 1579 //% * | |
| 1580 //% * @return A newly instanced GPB##NAME##Array with value in it. | |
| 1581 //% **/ | |
| 1582 //%+ (instancetype)arrayWithValue:(TYPE)value; | 429 //%+ (instancetype)arrayWithValue:(TYPE)value; |
| 1583 //% | |
| 1584 //%/** | |
| 1585 //% * Creates and initializes a GPB##NAME##Array with the contents of the given | |
| 1586 //% * array. | |
| 1587 //% * | |
| 1588 //% * @param array Array with the contents to be put into the new array. | |
| 1589 //% * | |
| 1590 //% * @return A newly instanced GPB##NAME##Array with the contents of array. | |
| 1591 //% **/ | |
| 1592 //%+ (instancetype)arrayWithValueArray:(GPB##NAME##Array *)array; | 430 //%+ (instancetype)arrayWithValueArray:(GPB##NAME##Array *)array; |
| 1593 //% | |
| 1594 //%/** | |
| 1595 //% * Creates and initializes a GPB##NAME##Array with the given capacity. | |
| 1596 //% * | |
| 1597 //% * @param count The capacity needed for the array. | |
| 1598 //% * | |
| 1599 //% * @return A newly instanced GPB##NAME##Array with a capacity of count. | |
| 1600 //% **/ | |
| 1601 //%+ (instancetype)arrayWithCapacity:(NSUInteger)count; | 431 //%+ (instancetype)arrayWithCapacity:(NSUInteger)count; |
| 1602 //% | 432 //% |
| 1603 //%/** | |
| 1604 //% * @return A newly initialized and empty GPB##NAME##Array. | |
| 1605 //% **/ | |
| 1606 //%- (instancetype)init NS_DESIGNATED_INITIALIZER; | 433 //%- (instancetype)init NS_DESIGNATED_INITIALIZER; |
| 1607 //% | 434 //%// Initializes the array, copying the values. |
| 1608 //%/** | |
| 1609 //% * Initializes the array, copying the given values. | |
| 1610 //% * | |
| 1611 //% * @param values An array with the values to put inside this array. | |
| 1612 //% * @param count The number of elements to copy into the array. | |
| 1613 //% * | |
| 1614 //% * @return A newly initialized GPB##NAME##Array with a copy of the values. | |
| 1615 //% **/ | |
| 1616 //%- (instancetype)initWithValues:(const TYPE [])values | 435 //%- (instancetype)initWithValues:(const TYPE [])values |
| 1617 //% count:(NSUInteger)count; | 436 //% count:(NSUInteger)count; |
| 1618 //% | |
| 1619 //%/** | |
| 1620 //% * Initializes the array, copying the given values. | |
| 1621 //% * | |
| 1622 //% * @param array An array with the values to put inside this array. | |
| 1623 //% * | |
| 1624 //% * @return A newly initialized GPB##NAME##Array with a copy of the values. | |
| 1625 //% **/ | |
| 1626 //%- (instancetype)initWithValueArray:(GPB##NAME##Array *)array; | 437 //%- (instancetype)initWithValueArray:(GPB##NAME##Array *)array; |
| 1627 //% | |
| 1628 //%/** | |
| 1629 //% * Initializes the array with the given capacity. | |
| 1630 //% * | |
| 1631 //% * @param count The capacity needed for the array. | |
| 1632 //% * | |
| 1633 //% * @return A newly initialized GPB##NAME##Array with a capacity of count. | |
| 1634 //% **/ | |
| 1635 //%- (instancetype)initWithCapacity:(NSUInteger)count; | 438 //%- (instancetype)initWithCapacity:(NSUInteger)count; |
| 1636 //% | 439 //% |
| 1637 //%ARRAY_IMMUTABLE_INTERFACE(NAME, TYPE, Basic) | 440 //%ARRAY_IMMUTABLE_INTERFACE(NAME, TYPE, Basic) |
| 1638 //% | 441 //% |
| 1639 //%ARRAY_MUTABLE_INTERFACE(NAME, TYPE, Basic) | 442 //%ARRAY_MUTABLE_INTERFACE(NAME, TYPE, Basic) |
| 1640 //% | 443 //% |
| 1641 //%@end | 444 //%@end |
| 1642 //% | 445 //% |
| 1643 | 446 |
| 1644 // | 447 // |
| 1645 // Macros specific to Enums (to tweak their interface). | 448 // Macros specific to Enums (to tweak their interface). |
| 1646 // | 449 // |
| 1647 | 450 |
| 1648 //%PDDM-DEFINE ARRAY_INTERFACE_ENUM(NAME, TYPE) | 451 //%PDDM-DEFINE ARRAY_INTERFACE_ENUM(NAME, TYPE) |
| 1649 //%#pragma mark - NAME | 452 //%#pragma mark - NAME |
| 1650 //% | 453 //% |
| 1651 //%/** | |
| 1652 //% * This class is used for repeated fields of ##TYPE## values. This performs | |
| 1653 //% * better than boxing into NSNumbers in NSArrays. | |
| 1654 //% * | |
| 1655 //% * @note This class is not meant to be subclassed. | |
| 1656 //% **/ | |
| 1657 //%@interface GPB##NAME##Array : NSObject <NSCopying> | 454 //%@interface GPB##NAME##Array : NSObject <NSCopying> |
| 1658 //% | 455 //% |
| 1659 //%/** The number of elements contained in the array. */ | |
| 1660 //%@property(nonatomic, readonly) NSUInteger count; | 456 //%@property(nonatomic, readonly) NSUInteger count; |
| 1661 //%/** The validation function to check if the enums are valid. */ | |
| 1662 //%@property(nonatomic, readonly) GPBEnumValidationFunc validationFunc; | 457 //%@property(nonatomic, readonly) GPBEnumValidationFunc validationFunc; |
| 1663 //% | 458 //% |
| 1664 //%/** | |
| 1665 //% * @return A newly instanced and empty GPB##NAME##Array. | |
| 1666 //% **/ | |
| 1667 //%+ (instancetype)array; | 459 //%+ (instancetype)array; |
| 1668 //% | |
| 1669 //%/** | |
| 1670 //% * Creates and initializes a GPB##NAME##Array with the enum validation functi
on | |
| 1671 //% * given. | |
| 1672 //% * | |
| 1673 //% * @param func The enum validation function for the array. | |
| 1674 //% * | |
| 1675 //% * @return A newly instanced GPB##NAME##Array. | |
| 1676 //% **/ | |
| 1677 //%+ (instancetype)arrayWithValidationFunction:(nullable GPBEnumValidationFunc)f
unc; | 460 //%+ (instancetype)arrayWithValidationFunction:(nullable GPBEnumValidationFunc)f
unc; |
| 1678 //% | |
| 1679 //%/** | |
| 1680 //% * Creates and initializes a GPB##NAME##Array with the enum validation functi
on | |
| 1681 //% * given and the single raw value given. | |
| 1682 //% * | |
| 1683 //% * @param func The enum validation function for the array. | |
| 1684 //% * @param value The raw value to add to this array. | |
| 1685 //% * | |
| 1686 //% * @return A newly instanced GPB##NAME##Array. | |
| 1687 //% **/ | |
| 1688 //%+ (instancetype)arrayWithValidationFunction:(nullable GPBEnumValidationFunc)f
unc | 461 //%+ (instancetype)arrayWithValidationFunction:(nullable GPBEnumValidationFunc)f
unc |
| 1689 //% rawValue:(TYPE)value; | 462 //% rawValue:(TYPE)value; |
| 1690 //% | |
| 1691 //%/** | |
| 1692 //% * Creates and initializes a GPB##NAME##Array that adds the elements from the | |
| 1693 //% * given array. | |
| 1694 //% * | |
| 1695 //% * @param array Array containing the values to add to the new array. | |
| 1696 //% * | |
| 1697 //% * @return A newly instanced GPB##NAME##Array. | |
| 1698 //% **/ | |
| 1699 //%+ (instancetype)arrayWithValueArray:(GPB##NAME##Array *)array; | 463 //%+ (instancetype)arrayWithValueArray:(GPB##NAME##Array *)array; |
| 1700 //% | |
| 1701 //%/** | |
| 1702 //% * Creates and initializes a GPB##NAME##Array with the given enum validation | |
| 1703 //% * function and with the givencapacity. | |
| 1704 //% * | |
| 1705 //% * @param func The enum validation function for the array. | |
| 1706 //% * @param count The capacity needed for the array. | |
| 1707 //% * | |
| 1708 //% * @return A newly instanced GPB##NAME##Array with a capacity of count. | |
| 1709 //% **/ | |
| 1710 //%+ (instancetype)arrayWithValidationFunction:(nullable GPBEnumValidationFunc)f
unc | 464 //%+ (instancetype)arrayWithValidationFunction:(nullable GPBEnumValidationFunc)f
unc |
| 1711 //% capacity:(NSUInteger)count; | 465 //% capacity:(NSUInteger)count; |
| 1712 //% | 466 //% |
| 1713 //%/** | |
| 1714 //% * Initializes the array with the given enum validation function. | |
| 1715 //% * | |
| 1716 //% * @param func The enum validation function for the array. | |
| 1717 //% * | |
| 1718 //% * @return A newly initialized GPB##NAME##Array with a copy of the values. | |
| 1719 //% **/ | |
| 1720 //%- (instancetype)initWithValidationFunction:(nullable GPBEnumValidationFunc)fu
nc | 467 //%- (instancetype)initWithValidationFunction:(nullable GPBEnumValidationFunc)fu
nc |
| 1721 //% NS_DESIGNATED_INITIALIZER; | 468 //% NS_DESIGNATED_INITIALIZER; |
| 1722 //% | 469 //% |
| 1723 //%/** | 470 //%// Initializes the array, copying the values. |
| 1724 //% * Initializes the array, copying the given values. | |
| 1725 //% * | |
| 1726 //% * @param func The enum validation function for the array. | |
| 1727 //% * @param values An array with the values to put inside this array. | |
| 1728 //% * @param count The number of elements to copy into the array. | |
| 1729 //% * | |
| 1730 //% * @return A newly initialized GPB##NAME##Array with a copy of the values. | |
| 1731 //% **/ | |
| 1732 //%- (instancetype)initWithValidationFunction:(nullable GPBEnumValidationFunc)fu
nc | 471 //%- (instancetype)initWithValidationFunction:(nullable GPBEnumValidationFunc)fu
nc |
| 1733 //% rawValues:(const TYPE [])values | 472 //% rawValues:(const TYPE [])values |
| 1734 //% count:(NSUInteger)count; | 473 //% count:(NSUInteger)count; |
| 1735 //% | |
| 1736 //%/** | |
| 1737 //% * Initializes the array, copying the given values. | |
| 1738 //% * | |
| 1739 //% * @param array An array with the values to put inside this array. | |
| 1740 //% * | |
| 1741 //% * @return A newly initialized GPB##NAME##Array with a copy of the values. | |
| 1742 //% **/ | |
| 1743 //%- (instancetype)initWithValueArray:(GPB##NAME##Array *)array; | 474 //%- (instancetype)initWithValueArray:(GPB##NAME##Array *)array; |
| 1744 //% | |
| 1745 //%/** | |
| 1746 //% * Initializes the array with the given capacity. | |
| 1747 //% * | |
| 1748 //% * @param func The enum validation function for the array. | |
| 1749 //% * @param count The capacity needed for the array. | |
| 1750 //% * | |
| 1751 //% * @return A newly initialized GPB##NAME##Array with a capacity of count. | |
| 1752 //% **/ | |
| 1753 //%- (instancetype)initWithValidationFunction:(nullable GPBEnumValidationFunc)fu
nc | 475 //%- (instancetype)initWithValidationFunction:(nullable GPBEnumValidationFunc)fu
nc |
| 1754 //% capacity:(NSUInteger)count; | 476 //% capacity:(NSUInteger)count; |
| 1755 //% | 477 //% |
| 1756 //%// These will return kGPBUnrecognizedEnumeratorValue if the value at index is
not a | 478 //%// These will return kGPBUnrecognizedEnumeratorValue if the value at index is
not a |
| 1757 //%// valid enumerator as defined by validationFunc. If the actual value is | 479 //%// valid enumerator as defined by validationFunc. If the actual value is |
| 1758 //%// desired, use "raw" version of the method. | 480 //%// desired, use "raw" version of the method. |
| 1759 //% | 481 //% |
| 1760 //%ARRAY_IMMUTABLE_INTERFACE(NAME, TYPE, NAME) | 482 //%ARRAY_IMMUTABLE_INTERFACE(NAME, TYPE, NAME) |
| 1761 //% | 483 //% |
| 1762 //%// These methods bypass the validationFunc to provide access to values that w
ere not | 484 //%// These methods bypass the validationFunc to provide access to values that w
ere not |
| 1763 //%// known at the time the binary was compiled. | 485 //%// known at the time the binary was compiled. |
| 1764 //% | 486 //% |
| 1765 //%/** | |
| 1766 //% * Gets the raw enum value at the given index. | |
| 1767 //% * | |
| 1768 //% * @param index The index of the raw enum value to get. | |
| 1769 //% * | |
| 1770 //% * @return The raw enum value at the given index. | |
| 1771 //% **/ | |
| 1772 //%- (TYPE)rawValueAtIndex:(NSUInteger)index; | 487 //%- (TYPE)rawValueAtIndex:(NSUInteger)index; |
| 1773 //% | 488 //% |
| 1774 //%/** | |
| 1775 //% * Enumerates the values on this array with the given block. | |
| 1776 //% * | |
| 1777 //% * @param block The block to enumerate with. | |
| 1778 //% * **value**: The current value being enumerated. | |
| 1779 //% * **idx**: The index of the current value. | |
| 1780 //% * **stop**: A pointer to a boolean that when set stops the enumeration. | |
| 1781 //% **/ | |
| 1782 //%- (void)enumerateRawValuesWithBlock:(void (^)(TYPE value, NSUInteger idx, BOO
L *stop))block; | 489 //%- (void)enumerateRawValuesWithBlock:(void (^)(TYPE value, NSUInteger idx, BOO
L *stop))block; |
| 1783 //% | |
| 1784 //%/** | |
| 1785 //% * Enumerates the values on this array with the given block. | |
| 1786 //% * | |
| 1787 //% * @param opts Options to control the enumeration. | |
| 1788 //% * @param block The block to enumerate with. | |
| 1789 //% * **value**: The current value being enumerated. | |
| 1790 //% * **idx**: The index of the current value. | |
| 1791 //% * **stop**: A pointer to a boolean that when set stops the enumeration. | |
| 1792 //% **/ | |
| 1793 //%- (void)enumerateRawValuesWithOptions:(NSEnumerationOptions)opts | 490 //%- (void)enumerateRawValuesWithOptions:(NSEnumerationOptions)opts |
| 1794 //% usingBlock:(void (^)(TYPE value, NSUInteger idx, B
OOL *stop))block; | 491 //% usingBlock:(void (^)(TYPE value, NSUInteger idx, B
OOL *stop))block; |
| 1795 //% | 492 //% |
| 1796 //%// If value is not a valid enumerator as defined by validationFunc, these | 493 //%// If value is not a valid enumerator as defined by validationFunc, these |
| 1797 //%// methods will assert in debug, and will log in release and assign the value | 494 //%// methods will assert in debug, and will log in release and assign the value |
| 1798 //%// to the default value. Use the rawValue methods below to assign non enumera
tor | 495 //%// to the default value. Use the rawValue methods below to assign non enumera
tor |
| 1799 //%// values. | 496 //%// values. |
| 1800 //% | 497 //% |
| 1801 //%ARRAY_MUTABLE_INTERFACE(NAME, TYPE, NAME) | 498 //%ARRAY_MUTABLE_INTERFACE(NAME, TYPE, NAME) |
| 1802 //% | 499 //% |
| 1803 //%@end | 500 //%@end |
| 1804 //% | 501 //% |
| 1805 | 502 |
| 1806 //%PDDM-DEFINE ARRAY_IMMUTABLE_INTERFACE(NAME, TYPE, HELPER_NAME) | 503 //%PDDM-DEFINE ARRAY_IMMUTABLE_INTERFACE(NAME, TYPE, HELPER_NAME) |
| 1807 //%/** | |
| 1808 //% * Gets the value at the given index. | |
| 1809 //% * | |
| 1810 //% * @param index The index of the value to get. | |
| 1811 //% * | |
| 1812 //% * @return The value at the given index. | |
| 1813 //% **/ | |
| 1814 //%- (TYPE)valueAtIndex:(NSUInteger)index; | 504 //%- (TYPE)valueAtIndex:(NSUInteger)index; |
| 1815 //% | 505 //% |
| 1816 //%/** | |
| 1817 //% * Enumerates the values on this array with the given block. | |
| 1818 //% * | |
| 1819 //% * @param block The block to enumerate with. | |
| 1820 //% * **value**: The current value being enumerated. | |
| 1821 //% * **idx**: The index of the current value. | |
| 1822 //% * **stop**: A pointer to a boolean that when set stops the enumeration. | |
| 1823 //% **/ | |
| 1824 //%- (void)enumerateValuesWithBlock:(void (^)(TYPE value, NSUInteger idx, BOOL *
stop))block; | 506 //%- (void)enumerateValuesWithBlock:(void (^)(TYPE value, NSUInteger idx, BOOL *
stop))block; |
| 1825 //% | |
| 1826 //%/** | |
| 1827 //% * Enumerates the values on this array with the given block. | |
| 1828 //% * | |
| 1829 //% * @param opts Options to control the enumeration. | |
| 1830 //% * @param block The block to enumerate with. | |
| 1831 //% * **value**: The current value being enumerated. | |
| 1832 //% * **idx**: The index of the current value. | |
| 1833 //% * **stop**: A pointer to a boolean that when set stops the enumeration. | |
| 1834 //% **/ | |
| 1835 //%- (void)enumerateValuesWithOptions:(NSEnumerationOptions)opts | 507 //%- (void)enumerateValuesWithOptions:(NSEnumerationOptions)opts |
| 1836 //% usingBlock:(void (^)(TYPE value, NSUInteger idx, BOOL
*stop))block; | 508 //% usingBlock:(void (^)(TYPE value, NSUInteger idx, BOOL
*stop))block; |
| 1837 | 509 |
| 1838 //%PDDM-DEFINE ARRAY_MUTABLE_INTERFACE(NAME, TYPE, HELPER_NAME) | 510 //%PDDM-DEFINE ARRAY_MUTABLE_INTERFACE(NAME, TYPE, HELPER_NAME) |
| 1839 //%/** | |
| 1840 //% * Adds a value to this array. | |
| 1841 //% * | |
| 1842 //% * @param value The value to add to this array. | |
| 1843 //% **/ | |
| 1844 //%- (void)addValue:(TYPE)value; | 511 //%- (void)addValue:(TYPE)value; |
| 1845 //% | |
| 1846 //%/** | |
| 1847 //% * Adds values to this array. | |
| 1848 //% * | |
| 1849 //% * @param values The values to add to this array. | |
| 1850 //% * @param count The number of elements to add. | |
| 1851 //% **/ | |
| 1852 //%- (void)addValues:(const TYPE [])values count:(NSUInteger)count; | 512 //%- (void)addValues:(const TYPE [])values count:(NSUInteger)count; |
| 1853 //% | |
| 1854 //%ARRAY_EXTRA_MUTABLE_METHODS1_##HELPER_NAME(NAME, TYPE) | 513 //%ARRAY_EXTRA_MUTABLE_METHODS1_##HELPER_NAME(NAME, TYPE) |
| 1855 //%/** | |
| 1856 //% * Inserts a value into the given position. | |
| 1857 //% * | |
| 1858 //% * @param value The value to add to this array. | |
| 1859 //% * @param index The index into which to insert the value. | |
| 1860 //% **/ | |
| 1861 //%- (void)insertValue:(TYPE)value atIndex:(NSUInteger)index; | 514 //%- (void)insertValue:(TYPE)value atIndex:(NSUInteger)index; |
| 1862 //% | 515 //% |
| 1863 //%/** | |
| 1864 //% * Replaces the value at the given index with the given value. | |
| 1865 //% * | |
| 1866 //% * @param index The index for which to replace the value. | |
| 1867 //% * @param value The value to replace with. | |
| 1868 //% **/ | |
| 1869 //%- (void)replaceValueAtIndex:(NSUInteger)index withValue:(TYPE)value; | 516 //%- (void)replaceValueAtIndex:(NSUInteger)index withValue:(TYPE)value; |
| 1870 //%ARRAY_EXTRA_MUTABLE_METHODS2_##HELPER_NAME(NAME, TYPE) | 517 //%ARRAY_EXTRA_MUTABLE_METHODS2_##HELPER_NAME(NAME, TYPE) |
| 1871 //%/** | |
| 1872 //% * Removes the value at the given index. | |
| 1873 //% * | |
| 1874 //% * @param index The index of the value to remove. | |
| 1875 //% **/ | |
| 1876 //%- (void)removeValueAtIndex:(NSUInteger)index; | 518 //%- (void)removeValueAtIndex:(NSUInteger)index; |
| 1877 //% | |
| 1878 //%/** | |
| 1879 //% * Removes all the values from this array. | |
| 1880 //% **/ | |
| 1881 //%- (void)removeAll; | 519 //%- (void)removeAll; |
| 1882 //% | 520 //% |
| 1883 //%/** | |
| 1884 //% * Exchanges the values between the given indexes. | |
| 1885 //% * | |
| 1886 //% * @param idx1 The index of the first element to exchange. | |
| 1887 //% * @param idx2 The index of the second element to exchange. | |
| 1888 //% **/ | |
| 1889 //%- (void)exchangeValueAtIndex:(NSUInteger)idx1 | 521 //%- (void)exchangeValueAtIndex:(NSUInteger)idx1 |
| 1890 //% withValueAtIndex:(NSUInteger)idx2; | 522 //% withValueAtIndex:(NSUInteger)idx2; |
| 1891 | 523 |
| 1892 // | 524 // |
| 1893 // These are hooks invoked by the above to do insert as needed. | 525 // These are hooks invoked by the above to do insert as needed. |
| 1894 // | 526 // |
| 1895 | 527 |
| 1896 //%PDDM-DEFINE ARRAY_EXTRA_MUTABLE_METHODS1_Basic(NAME, TYPE) | 528 //%PDDM-DEFINE ARRAY_EXTRA_MUTABLE_METHODS1_Basic(NAME, TYPE) |
| 1897 //%/** | |
| 1898 //% * Adds the values from the given array to this array. | |
| 1899 //% * | |
| 1900 //% * @param array The array containing the elements to add to this array. | |
| 1901 //% **/ | |
| 1902 //%- (void)addValuesFromArray:(GPB##NAME##Array *)array; | 529 //%- (void)addValuesFromArray:(GPB##NAME##Array *)array; |
| 1903 //% | 530 //% |
| 1904 //%PDDM-DEFINE ARRAY_EXTRA_MUTABLE_METHODS2_Basic(NAME, TYPE) | 531 //%PDDM-DEFINE ARRAY_EXTRA_MUTABLE_METHODS2_Basic(NAME, TYPE) |
| 1905 // Empty | 532 // Empty |
| 1906 //%PDDM-DEFINE ARRAY_EXTRA_MUTABLE_METHODS1_Enum(NAME, TYPE) | 533 //%PDDM-DEFINE ARRAY_EXTRA_MUTABLE_METHODS1_Enum(NAME, TYPE) |
| 1907 // Empty | 534 // Empty |
| 1908 //%PDDM-DEFINE ARRAY_EXTRA_MUTABLE_METHODS2_Enum(NAME, TYPE) | 535 //%PDDM-DEFINE ARRAY_EXTRA_MUTABLE_METHODS2_Enum(NAME, TYPE) |
| 1909 //% | 536 //% |
| 1910 //%// These methods bypass the validationFunc to provide setting of values that
were not | 537 //%// These methods bypass the validationFunc to provide setting of values that
were not |
| 1911 //%// known at the time the binary was compiled. | 538 //%// known at the time the binary was compiled. |
| 1912 //% | 539 //% |
| 1913 //%/** | |
| 1914 //% * Adds a raw enum value to this array. | |
| 1915 //% * | |
| 1916 //% * @note This method bypass the validationFunc to enable the setting of value
s that | |
| 1917 //% * were not known at the time the binary was compiled. | |
| 1918 //% * | |
| 1919 //% * @param value The raw enum value to add to the array. | |
| 1920 //% **/ | |
| 1921 //%- (void)addRawValue:(TYPE)value; | 540 //%- (void)addRawValue:(TYPE)value; |
| 1922 //% | |
| 1923 //%/** | |
| 1924 //% * Adds raw enum values to this array. | |
| 1925 //% * | |
| 1926 //% * @note This method bypass the validationFunc to enable the setting of value
s that | |
| 1927 //% * were not known at the time the binary was compiled. | |
| 1928 //% * | |
| 1929 //% * @param array Array containing the raw enum values to add to this array. | |
| 1930 //% **/ | |
| 1931 //%- (void)addRawValuesFromArray:(GPB##NAME##Array *)array; | 541 //%- (void)addRawValuesFromArray:(GPB##NAME##Array *)array; |
| 1932 //% | |
| 1933 //%/** | |
| 1934 //% * Adds raw enum values to this array. | |
| 1935 //% * | |
| 1936 //% * @note This method bypass the validationFunc to enable the setting of value
s that | |
| 1937 //% * were not known at the time the binary was compiled. | |
| 1938 //% * | |
| 1939 //% * @param values Array containing the raw enum values to add to this array. | |
| 1940 //% * @param count The number of raw values to add. | |
| 1941 //% **/ | |
| 1942 //%- (void)addRawValues:(const TYPE [])values count:(NSUInteger)count; | 542 //%- (void)addRawValues:(const TYPE [])values count:(NSUInteger)count; |
| 1943 //% | 543 //% |
| 1944 //%/** | |
| 1945 //% * Inserts a raw enum value at the given index. | |
| 1946 //% * | |
| 1947 //% * @note This method bypass the validationFunc to enable the setting of value
s that | |
| 1948 //% * were not known at the time the binary was compiled. | |
| 1949 //% * | |
| 1950 //% * @param value Raw enum value to add. | |
| 1951 //% * @param index The index into which to insert the value. | |
| 1952 //% **/ | |
| 1953 //%- (void)insertRawValue:(TYPE)value atIndex:(NSUInteger)index; | 544 //%- (void)insertRawValue:(TYPE)value atIndex:(NSUInteger)index; |
| 1954 //% | 545 //% |
| 1955 //%/** | |
| 1956 //% * Replaces the raw enum value at the given index with the given value. | |
| 1957 //% * | |
| 1958 //% * @note This method bypass the validationFunc to enable the setting of value
s that | |
| 1959 //% * were not known at the time the binary was compiled. | |
| 1960 //% * | |
| 1961 //% * @param index The index for which to replace the value. | |
| 1962 //% * @param value The raw enum value to replace with. | |
| 1963 //% **/ | |
| 1964 //%- (void)replaceValueAtIndex:(NSUInteger)index withRawValue:(TYPE)value; | 546 //%- (void)replaceValueAtIndex:(NSUInteger)index withRawValue:(TYPE)value; |
| 1965 //% | 547 //% |
| 1966 //%// No validation applies to these methods. | 548 //%// No validation applies to these methods. |
| 1967 //% | 549 //% |
| OLD | NEW |