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 | |
40 NS_ASSUME_NONNULL_BEGIN | 35 NS_ASSUME_NONNULL_BEGIN |
41 | 36 |
42 //%PDDM-EXPAND DECLARE_ARRAYS() | 37 //%PDDM-EXPAND DECLARE_ARRAYS() |
43 // This block of code is generated, do not edit it directly. | 38 // This block of code is generated, do not edit it directly. |
44 | 39 |
45 #pragma mark - Int32 | 40 #pragma mark - Int32 |
46 | 41 |
| 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 **/ |
47 @interface GPBInt32Array : NSObject <NSCopying> | 48 @interface GPBInt32Array : NSObject <NSCopying> |
48 | 49 |
| 50 /** The number of elements contained in the array. */ |
49 @property(nonatomic, readonly) NSUInteger count; | 51 @property(nonatomic, readonly) NSUInteger count; |
50 | 52 |
| 53 /** |
| 54 * @return A newly instanced and empty GPBInt32Array. |
| 55 **/ |
51 + (instancetype)array; | 56 + (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 **/ |
52 + (instancetype)arrayWithValue:(int32_t)value; | 65 + (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 **/ |
53 + (instancetype)arrayWithValueArray:(GPBInt32Array *)array; | 75 + (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 **/ |
54 + (instancetype)arrayWithCapacity:(NSUInteger)count; | 84 + (instancetype)arrayWithCapacity:(NSUInteger)count; |
55 | 85 |
| 86 /** |
| 87 * @return A newly initialized and empty GPBInt32Array. |
| 88 **/ |
56 - (instancetype)init NS_DESIGNATED_INITIALIZER; | 89 - (instancetype)init NS_DESIGNATED_INITIALIZER; |
57 // Initializes the array, copying the values. | 90 |
| 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 **/ |
58 - (instancetype)initWithValues:(const int32_t [])values | 99 - (instancetype)initWithValues:(const int32_t [])values |
59 count:(NSUInteger)count; | 100 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 **/ |
60 - (instancetype)initWithValueArray:(GPBInt32Array *)array; | 109 - (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 **/ |
61 - (instancetype)initWithCapacity:(NSUInteger)count; | 118 - (instancetype)initWithCapacity:(NSUInteger)count; |
62 | 119 |
| 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 **/ |
63 - (int32_t)valueAtIndex:(NSUInteger)index; | 127 - (int32_t)valueAtIndex:(NSUInteger)index; |
64 | 128 |
| 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 **/ |
65 - (void)enumerateValuesWithBlock:(void (^)(int32_t value, NSUInteger idx, BOOL *
stop))block; | 137 - (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 **/ |
66 - (void)enumerateValuesWithOptions:(NSEnumerationOptions)opts | 148 - (void)enumerateValuesWithOptions:(NSEnumerationOptions)opts |
67 usingBlock:(void (^)(int32_t value, NSUInteger idx, BOOL
*stop))block; | 149 usingBlock:(void (^)(int32_t value, NSUInteger idx, BOOL
*stop))block; |
68 | 150 |
| 151 /** |
| 152 * Adds a value to this array. |
| 153 * |
| 154 * @param value The value to add to this array. |
| 155 **/ |
69 - (void)addValue:(int32_t)value; | 156 - (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 **/ |
70 - (void)addValues:(const int32_t [])values count:(NSUInteger)count; | 164 - (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 **/ |
71 - (void)addValuesFromArray:(GPBInt32Array *)array; | 171 - (void)addValuesFromArray:(GPBInt32Array *)array; |
72 | 172 |
| 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 **/ |
73 - (void)insertValue:(int32_t)value atIndex:(NSUInteger)index; | 179 - (void)insertValue:(int32_t)value atIndex:(NSUInteger)index; |
74 | 180 |
| 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 **/ |
75 - (void)replaceValueAtIndex:(NSUInteger)index withValue:(int32_t)value; | 187 - (void)replaceValueAtIndex:(NSUInteger)index withValue:(int32_t)value; |
76 | 188 |
| 189 /** |
| 190 * Removes the value at the given index. |
| 191 * |
| 192 * @param index The index of the value to remove. |
| 193 **/ |
77 - (void)removeValueAtIndex:(NSUInteger)index; | 194 - (void)removeValueAtIndex:(NSUInteger)index; |
| 195 |
| 196 /** |
| 197 * Removes all the values from this array. |
| 198 **/ |
78 - (void)removeAll; | 199 - (void)removeAll; |
79 | 200 |
| 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 **/ |
80 - (void)exchangeValueAtIndex:(NSUInteger)idx1 | 207 - (void)exchangeValueAtIndex:(NSUInteger)idx1 |
81 withValueAtIndex:(NSUInteger)idx2; | 208 withValueAtIndex:(NSUInteger)idx2; |
82 | 209 |
83 @end | 210 @end |
84 | 211 |
85 #pragma mark - UInt32 | 212 #pragma mark - UInt32 |
86 | 213 |
| 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 **/ |
87 @interface GPBUInt32Array : NSObject <NSCopying> | 220 @interface GPBUInt32Array : NSObject <NSCopying> |
88 | 221 |
| 222 /** The number of elements contained in the array. */ |
89 @property(nonatomic, readonly) NSUInteger count; | 223 @property(nonatomic, readonly) NSUInteger count; |
90 | 224 |
| 225 /** |
| 226 * @return A newly instanced and empty GPBUInt32Array. |
| 227 **/ |
91 + (instancetype)array; | 228 + (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 **/ |
92 + (instancetype)arrayWithValue:(uint32_t)value; | 237 + (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 **/ |
93 + (instancetype)arrayWithValueArray:(GPBUInt32Array *)array; | 247 + (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 **/ |
94 + (instancetype)arrayWithCapacity:(NSUInteger)count; | 256 + (instancetype)arrayWithCapacity:(NSUInteger)count; |
95 | 257 |
| 258 /** |
| 259 * @return A newly initialized and empty GPBUInt32Array. |
| 260 **/ |
96 - (instancetype)init NS_DESIGNATED_INITIALIZER; | 261 - (instancetype)init NS_DESIGNATED_INITIALIZER; |
97 // Initializes the array, copying the values. | 262 |
| 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 **/ |
98 - (instancetype)initWithValues:(const uint32_t [])values | 271 - (instancetype)initWithValues:(const uint32_t [])values |
99 count:(NSUInteger)count; | 272 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 **/ |
100 - (instancetype)initWithValueArray:(GPBUInt32Array *)array; | 281 - (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 **/ |
101 - (instancetype)initWithCapacity:(NSUInteger)count; | 290 - (instancetype)initWithCapacity:(NSUInteger)count; |
102 | 291 |
| 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 **/ |
103 - (uint32_t)valueAtIndex:(NSUInteger)index; | 299 - (uint32_t)valueAtIndex:(NSUInteger)index; |
104 | 300 |
| 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 **/ |
105 - (void)enumerateValuesWithBlock:(void (^)(uint32_t value, NSUInteger idx, BOOL
*stop))block; | 309 - (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 **/ |
106 - (void)enumerateValuesWithOptions:(NSEnumerationOptions)opts | 320 - (void)enumerateValuesWithOptions:(NSEnumerationOptions)opts |
107 usingBlock:(void (^)(uint32_t value, NSUInteger idx, BOO
L *stop))block; | 321 usingBlock:(void (^)(uint32_t value, NSUInteger idx, BOO
L *stop))block; |
108 | 322 |
| 323 /** |
| 324 * Adds a value to this array. |
| 325 * |
| 326 * @param value The value to add to this array. |
| 327 **/ |
109 - (void)addValue:(uint32_t)value; | 328 - (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 **/ |
110 - (void)addValues:(const uint32_t [])values count:(NSUInteger)count; | 336 - (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 **/ |
111 - (void)addValuesFromArray:(GPBUInt32Array *)array; | 343 - (void)addValuesFromArray:(GPBUInt32Array *)array; |
112 | 344 |
| 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 **/ |
113 - (void)insertValue:(uint32_t)value atIndex:(NSUInteger)index; | 351 - (void)insertValue:(uint32_t)value atIndex:(NSUInteger)index; |
114 | 352 |
| 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 **/ |
115 - (void)replaceValueAtIndex:(NSUInteger)index withValue:(uint32_t)value; | 359 - (void)replaceValueAtIndex:(NSUInteger)index withValue:(uint32_t)value; |
116 | 360 |
| 361 /** |
| 362 * Removes the value at the given index. |
| 363 * |
| 364 * @param index The index of the value to remove. |
| 365 **/ |
117 - (void)removeValueAtIndex:(NSUInteger)index; | 366 - (void)removeValueAtIndex:(NSUInteger)index; |
| 367 |
| 368 /** |
| 369 * Removes all the values from this array. |
| 370 **/ |
118 - (void)removeAll; | 371 - (void)removeAll; |
119 | 372 |
| 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 **/ |
120 - (void)exchangeValueAtIndex:(NSUInteger)idx1 | 379 - (void)exchangeValueAtIndex:(NSUInteger)idx1 |
121 withValueAtIndex:(NSUInteger)idx2; | 380 withValueAtIndex:(NSUInteger)idx2; |
122 | 381 |
123 @end | 382 @end |
124 | 383 |
125 #pragma mark - Int64 | 384 #pragma mark - Int64 |
126 | 385 |
| 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 **/ |
127 @interface GPBInt64Array : NSObject <NSCopying> | 392 @interface GPBInt64Array : NSObject <NSCopying> |
128 | 393 |
| 394 /** The number of elements contained in the array. */ |
129 @property(nonatomic, readonly) NSUInteger count; | 395 @property(nonatomic, readonly) NSUInteger count; |
130 | 396 |
| 397 /** |
| 398 * @return A newly instanced and empty GPBInt64Array. |
| 399 **/ |
131 + (instancetype)array; | 400 + (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 **/ |
132 + (instancetype)arrayWithValue:(int64_t)value; | 409 + (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 **/ |
133 + (instancetype)arrayWithValueArray:(GPBInt64Array *)array; | 419 + (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 **/ |
134 + (instancetype)arrayWithCapacity:(NSUInteger)count; | 428 + (instancetype)arrayWithCapacity:(NSUInteger)count; |
135 | 429 |
| 430 /** |
| 431 * @return A newly initialized and empty GPBInt64Array. |
| 432 **/ |
136 - (instancetype)init NS_DESIGNATED_INITIALIZER; | 433 - (instancetype)init NS_DESIGNATED_INITIALIZER; |
137 // Initializes the array, copying the values. | 434 |
| 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 **/ |
138 - (instancetype)initWithValues:(const int64_t [])values | 443 - (instancetype)initWithValues:(const int64_t [])values |
139 count:(NSUInteger)count; | 444 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 **/ |
140 - (instancetype)initWithValueArray:(GPBInt64Array *)array; | 453 - (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 **/ |
141 - (instancetype)initWithCapacity:(NSUInteger)count; | 462 - (instancetype)initWithCapacity:(NSUInteger)count; |
142 | 463 |
| 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 **/ |
143 - (int64_t)valueAtIndex:(NSUInteger)index; | 471 - (int64_t)valueAtIndex:(NSUInteger)index; |
144 | 472 |
| 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 **/ |
145 - (void)enumerateValuesWithBlock:(void (^)(int64_t value, NSUInteger idx, BOOL *
stop))block; | 481 - (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 **/ |
146 - (void)enumerateValuesWithOptions:(NSEnumerationOptions)opts | 492 - (void)enumerateValuesWithOptions:(NSEnumerationOptions)opts |
147 usingBlock:(void (^)(int64_t value, NSUInteger idx, BOOL
*stop))block; | 493 usingBlock:(void (^)(int64_t value, NSUInteger idx, BOOL
*stop))block; |
148 | 494 |
| 495 /** |
| 496 * Adds a value to this array. |
| 497 * |
| 498 * @param value The value to add to this array. |
| 499 **/ |
149 - (void)addValue:(int64_t)value; | 500 - (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 **/ |
150 - (void)addValues:(const int64_t [])values count:(NSUInteger)count; | 508 - (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 **/ |
151 - (void)addValuesFromArray:(GPBInt64Array *)array; | 515 - (void)addValuesFromArray:(GPBInt64Array *)array; |
152 | 516 |
| 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 **/ |
153 - (void)insertValue:(int64_t)value atIndex:(NSUInteger)index; | 523 - (void)insertValue:(int64_t)value atIndex:(NSUInteger)index; |
154 | 524 |
| 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 **/ |
155 - (void)replaceValueAtIndex:(NSUInteger)index withValue:(int64_t)value; | 531 - (void)replaceValueAtIndex:(NSUInteger)index withValue:(int64_t)value; |
156 | 532 |
| 533 /** |
| 534 * Removes the value at the given index. |
| 535 * |
| 536 * @param index The index of the value to remove. |
| 537 **/ |
157 - (void)removeValueAtIndex:(NSUInteger)index; | 538 - (void)removeValueAtIndex:(NSUInteger)index; |
| 539 |
| 540 /** |
| 541 * Removes all the values from this array. |
| 542 **/ |
158 - (void)removeAll; | 543 - (void)removeAll; |
159 | 544 |
| 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 **/ |
160 - (void)exchangeValueAtIndex:(NSUInteger)idx1 | 551 - (void)exchangeValueAtIndex:(NSUInteger)idx1 |
161 withValueAtIndex:(NSUInteger)idx2; | 552 withValueAtIndex:(NSUInteger)idx2; |
162 | 553 |
163 @end | 554 @end |
164 | 555 |
165 #pragma mark - UInt64 | 556 #pragma mark - UInt64 |
166 | 557 |
| 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 **/ |
167 @interface GPBUInt64Array : NSObject <NSCopying> | 564 @interface GPBUInt64Array : NSObject <NSCopying> |
168 | 565 |
| 566 /** The number of elements contained in the array. */ |
169 @property(nonatomic, readonly) NSUInteger count; | 567 @property(nonatomic, readonly) NSUInteger count; |
170 | 568 |
| 569 /** |
| 570 * @return A newly instanced and empty GPBUInt64Array. |
| 571 **/ |
171 + (instancetype)array; | 572 + (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 **/ |
172 + (instancetype)arrayWithValue:(uint64_t)value; | 581 + (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 **/ |
173 + (instancetype)arrayWithValueArray:(GPBUInt64Array *)array; | 591 + (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 **/ |
174 + (instancetype)arrayWithCapacity:(NSUInteger)count; | 600 + (instancetype)arrayWithCapacity:(NSUInteger)count; |
175 | 601 |
| 602 /** |
| 603 * @return A newly initialized and empty GPBUInt64Array. |
| 604 **/ |
176 - (instancetype)init NS_DESIGNATED_INITIALIZER; | 605 - (instancetype)init NS_DESIGNATED_INITIALIZER; |
177 // Initializes the array, copying the values. | 606 |
| 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 **/ |
178 - (instancetype)initWithValues:(const uint64_t [])values | 615 - (instancetype)initWithValues:(const uint64_t [])values |
179 count:(NSUInteger)count; | 616 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 **/ |
180 - (instancetype)initWithValueArray:(GPBUInt64Array *)array; | 625 - (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 **/ |
181 - (instancetype)initWithCapacity:(NSUInteger)count; | 634 - (instancetype)initWithCapacity:(NSUInteger)count; |
182 | 635 |
| 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 **/ |
183 - (uint64_t)valueAtIndex:(NSUInteger)index; | 643 - (uint64_t)valueAtIndex:(NSUInteger)index; |
184 | 644 |
| 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 **/ |
185 - (void)enumerateValuesWithBlock:(void (^)(uint64_t value, NSUInteger idx, BOOL
*stop))block; | 653 - (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 **/ |
186 - (void)enumerateValuesWithOptions:(NSEnumerationOptions)opts | 664 - (void)enumerateValuesWithOptions:(NSEnumerationOptions)opts |
187 usingBlock:(void (^)(uint64_t value, NSUInteger idx, BOO
L *stop))block; | 665 usingBlock:(void (^)(uint64_t value, NSUInteger idx, BOO
L *stop))block; |
188 | 666 |
| 667 /** |
| 668 * Adds a value to this array. |
| 669 * |
| 670 * @param value The value to add to this array. |
| 671 **/ |
189 - (void)addValue:(uint64_t)value; | 672 - (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 **/ |
190 - (void)addValues:(const uint64_t [])values count:(NSUInteger)count; | 680 - (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 **/ |
191 - (void)addValuesFromArray:(GPBUInt64Array *)array; | 687 - (void)addValuesFromArray:(GPBUInt64Array *)array; |
192 | 688 |
| 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 **/ |
193 - (void)insertValue:(uint64_t)value atIndex:(NSUInteger)index; | 695 - (void)insertValue:(uint64_t)value atIndex:(NSUInteger)index; |
194 | 696 |
| 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 **/ |
195 - (void)replaceValueAtIndex:(NSUInteger)index withValue:(uint64_t)value; | 703 - (void)replaceValueAtIndex:(NSUInteger)index withValue:(uint64_t)value; |
196 | 704 |
| 705 /** |
| 706 * Removes the value at the given index. |
| 707 * |
| 708 * @param index The index of the value to remove. |
| 709 **/ |
197 - (void)removeValueAtIndex:(NSUInteger)index; | 710 - (void)removeValueAtIndex:(NSUInteger)index; |
| 711 |
| 712 /** |
| 713 * Removes all the values from this array. |
| 714 **/ |
198 - (void)removeAll; | 715 - (void)removeAll; |
199 | 716 |
| 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 **/ |
200 - (void)exchangeValueAtIndex:(NSUInteger)idx1 | 723 - (void)exchangeValueAtIndex:(NSUInteger)idx1 |
201 withValueAtIndex:(NSUInteger)idx2; | 724 withValueAtIndex:(NSUInteger)idx2; |
202 | 725 |
203 @end | 726 @end |
204 | 727 |
205 #pragma mark - Float | 728 #pragma mark - Float |
206 | 729 |
| 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 **/ |
207 @interface GPBFloatArray : NSObject <NSCopying> | 736 @interface GPBFloatArray : NSObject <NSCopying> |
208 | 737 |
| 738 /** The number of elements contained in the array. */ |
209 @property(nonatomic, readonly) NSUInteger count; | 739 @property(nonatomic, readonly) NSUInteger count; |
210 | 740 |
| 741 /** |
| 742 * @return A newly instanced and empty GPBFloatArray. |
| 743 **/ |
211 + (instancetype)array; | 744 + (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 **/ |
212 + (instancetype)arrayWithValue:(float)value; | 753 + (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 **/ |
213 + (instancetype)arrayWithValueArray:(GPBFloatArray *)array; | 763 + (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 **/ |
214 + (instancetype)arrayWithCapacity:(NSUInteger)count; | 772 + (instancetype)arrayWithCapacity:(NSUInteger)count; |
215 | 773 |
| 774 /** |
| 775 * @return A newly initialized and empty GPBFloatArray. |
| 776 **/ |
216 - (instancetype)init NS_DESIGNATED_INITIALIZER; | 777 - (instancetype)init NS_DESIGNATED_INITIALIZER; |
217 // Initializes the array, copying the values. | 778 |
| 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 **/ |
218 - (instancetype)initWithValues:(const float [])values | 787 - (instancetype)initWithValues:(const float [])values |
219 count:(NSUInteger)count; | 788 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 **/ |
220 - (instancetype)initWithValueArray:(GPBFloatArray *)array; | 797 - (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 **/ |
221 - (instancetype)initWithCapacity:(NSUInteger)count; | 806 - (instancetype)initWithCapacity:(NSUInteger)count; |
222 | 807 |
| 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 **/ |
223 - (float)valueAtIndex:(NSUInteger)index; | 815 - (float)valueAtIndex:(NSUInteger)index; |
224 | 816 |
| 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 **/ |
225 - (void)enumerateValuesWithBlock:(void (^)(float value, NSUInteger idx, BOOL *st
op))block; | 825 - (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 **/ |
226 - (void)enumerateValuesWithOptions:(NSEnumerationOptions)opts | 836 - (void)enumerateValuesWithOptions:(NSEnumerationOptions)opts |
227 usingBlock:(void (^)(float value, NSUInteger idx, BOOL *
stop))block; | 837 usingBlock:(void (^)(float value, NSUInteger idx, BOOL *
stop))block; |
228 | 838 |
| 839 /** |
| 840 * Adds a value to this array. |
| 841 * |
| 842 * @param value The value to add to this array. |
| 843 **/ |
229 - (void)addValue:(float)value; | 844 - (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 **/ |
230 - (void)addValues:(const float [])values count:(NSUInteger)count; | 852 - (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 **/ |
231 - (void)addValuesFromArray:(GPBFloatArray *)array; | 859 - (void)addValuesFromArray:(GPBFloatArray *)array; |
232 | 860 |
| 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 **/ |
233 - (void)insertValue:(float)value atIndex:(NSUInteger)index; | 867 - (void)insertValue:(float)value atIndex:(NSUInteger)index; |
234 | 868 |
| 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 **/ |
235 - (void)replaceValueAtIndex:(NSUInteger)index withValue:(float)value; | 875 - (void)replaceValueAtIndex:(NSUInteger)index withValue:(float)value; |
236 | 876 |
| 877 /** |
| 878 * Removes the value at the given index. |
| 879 * |
| 880 * @param index The index of the value to remove. |
| 881 **/ |
237 - (void)removeValueAtIndex:(NSUInteger)index; | 882 - (void)removeValueAtIndex:(NSUInteger)index; |
| 883 |
| 884 /** |
| 885 * Removes all the values from this array. |
| 886 **/ |
238 - (void)removeAll; | 887 - (void)removeAll; |
239 | 888 |
| 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 **/ |
240 - (void)exchangeValueAtIndex:(NSUInteger)idx1 | 895 - (void)exchangeValueAtIndex:(NSUInteger)idx1 |
241 withValueAtIndex:(NSUInteger)idx2; | 896 withValueAtIndex:(NSUInteger)idx2; |
242 | 897 |
243 @end | 898 @end |
244 | 899 |
245 #pragma mark - Double | 900 #pragma mark - Double |
246 | 901 |
| 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 **/ |
247 @interface GPBDoubleArray : NSObject <NSCopying> | 908 @interface GPBDoubleArray : NSObject <NSCopying> |
248 | 909 |
| 910 /** The number of elements contained in the array. */ |
249 @property(nonatomic, readonly) NSUInteger count; | 911 @property(nonatomic, readonly) NSUInteger count; |
250 | 912 |
| 913 /** |
| 914 * @return A newly instanced and empty GPBDoubleArray. |
| 915 **/ |
251 + (instancetype)array; | 916 + (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 **/ |
252 + (instancetype)arrayWithValue:(double)value; | 925 + (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 **/ |
253 + (instancetype)arrayWithValueArray:(GPBDoubleArray *)array; | 935 + (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 **/ |
254 + (instancetype)arrayWithCapacity:(NSUInteger)count; | 944 + (instancetype)arrayWithCapacity:(NSUInteger)count; |
255 | 945 |
| 946 /** |
| 947 * @return A newly initialized and empty GPBDoubleArray. |
| 948 **/ |
256 - (instancetype)init NS_DESIGNATED_INITIALIZER; | 949 - (instancetype)init NS_DESIGNATED_INITIALIZER; |
257 // Initializes the array, copying the values. | 950 |
| 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 **/ |
258 - (instancetype)initWithValues:(const double [])values | 959 - (instancetype)initWithValues:(const double [])values |
259 count:(NSUInteger)count; | 960 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 **/ |
260 - (instancetype)initWithValueArray:(GPBDoubleArray *)array; | 969 - (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 **/ |
261 - (instancetype)initWithCapacity:(NSUInteger)count; | 978 - (instancetype)initWithCapacity:(NSUInteger)count; |
262 | 979 |
| 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 **/ |
263 - (double)valueAtIndex:(NSUInteger)index; | 987 - (double)valueAtIndex:(NSUInteger)index; |
264 | 988 |
| 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 **/ |
265 - (void)enumerateValuesWithBlock:(void (^)(double value, NSUInteger idx, BOOL *s
top))block; | 997 - (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 **/ |
266 - (void)enumerateValuesWithOptions:(NSEnumerationOptions)opts | 1008 - (void)enumerateValuesWithOptions:(NSEnumerationOptions)opts |
267 usingBlock:(void (^)(double value, NSUInteger idx, BOOL
*stop))block; | 1009 usingBlock:(void (^)(double value, NSUInteger idx, BOOL
*stop))block; |
268 | 1010 |
| 1011 /** |
| 1012 * Adds a value to this array. |
| 1013 * |
| 1014 * @param value The value to add to this array. |
| 1015 **/ |
269 - (void)addValue:(double)value; | 1016 - (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 **/ |
270 - (void)addValues:(const double [])values count:(NSUInteger)count; | 1024 - (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 **/ |
271 - (void)addValuesFromArray:(GPBDoubleArray *)array; | 1031 - (void)addValuesFromArray:(GPBDoubleArray *)array; |
272 | 1032 |
| 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 **/ |
273 - (void)insertValue:(double)value atIndex:(NSUInteger)index; | 1039 - (void)insertValue:(double)value atIndex:(NSUInteger)index; |
274 | 1040 |
| 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 **/ |
275 - (void)replaceValueAtIndex:(NSUInteger)index withValue:(double)value; | 1047 - (void)replaceValueAtIndex:(NSUInteger)index withValue:(double)value; |
276 | 1048 |
| 1049 /** |
| 1050 * Removes the value at the given index. |
| 1051 * |
| 1052 * @param index The index of the value to remove. |
| 1053 **/ |
277 - (void)removeValueAtIndex:(NSUInteger)index; | 1054 - (void)removeValueAtIndex:(NSUInteger)index; |
| 1055 |
| 1056 /** |
| 1057 * Removes all the values from this array. |
| 1058 **/ |
278 - (void)removeAll; | 1059 - (void)removeAll; |
279 | 1060 |
| 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 **/ |
280 - (void)exchangeValueAtIndex:(NSUInteger)idx1 | 1067 - (void)exchangeValueAtIndex:(NSUInteger)idx1 |
281 withValueAtIndex:(NSUInteger)idx2; | 1068 withValueAtIndex:(NSUInteger)idx2; |
282 | 1069 |
283 @end | 1070 @end |
284 | 1071 |
285 #pragma mark - Bool | 1072 #pragma mark - Bool |
286 | 1073 |
| 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 **/ |
287 @interface GPBBoolArray : NSObject <NSCopying> | 1080 @interface GPBBoolArray : NSObject <NSCopying> |
288 | 1081 |
| 1082 /** The number of elements contained in the array. */ |
289 @property(nonatomic, readonly) NSUInteger count; | 1083 @property(nonatomic, readonly) NSUInteger count; |
290 | 1084 |
| 1085 /** |
| 1086 * @return A newly instanced and empty GPBBoolArray. |
| 1087 **/ |
291 + (instancetype)array; | 1088 + (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 **/ |
292 + (instancetype)arrayWithValue:(BOOL)value; | 1097 + (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 **/ |
293 + (instancetype)arrayWithValueArray:(GPBBoolArray *)array; | 1107 + (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 **/ |
294 + (instancetype)arrayWithCapacity:(NSUInteger)count; | 1116 + (instancetype)arrayWithCapacity:(NSUInteger)count; |
295 | 1117 |
| 1118 /** |
| 1119 * @return A newly initialized and empty GPBBoolArray. |
| 1120 **/ |
296 - (instancetype)init NS_DESIGNATED_INITIALIZER; | 1121 - (instancetype)init NS_DESIGNATED_INITIALIZER; |
297 // Initializes the array, copying the values. | 1122 |
| 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 **/ |
298 - (instancetype)initWithValues:(const BOOL [])values | 1131 - (instancetype)initWithValues:(const BOOL [])values |
299 count:(NSUInteger)count; | 1132 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 **/ |
300 - (instancetype)initWithValueArray:(GPBBoolArray *)array; | 1141 - (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 **/ |
301 - (instancetype)initWithCapacity:(NSUInteger)count; | 1150 - (instancetype)initWithCapacity:(NSUInteger)count; |
302 | 1151 |
| 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 **/ |
303 - (BOOL)valueAtIndex:(NSUInteger)index; | 1159 - (BOOL)valueAtIndex:(NSUInteger)index; |
304 | 1160 |
| 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 **/ |
305 - (void)enumerateValuesWithBlock:(void (^)(BOOL value, NSUInteger idx, BOOL *sto
p))block; | 1169 - (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 **/ |
306 - (void)enumerateValuesWithOptions:(NSEnumerationOptions)opts | 1180 - (void)enumerateValuesWithOptions:(NSEnumerationOptions)opts |
307 usingBlock:(void (^)(BOOL value, NSUInteger idx, BOOL *s
top))block; | 1181 usingBlock:(void (^)(BOOL value, NSUInteger idx, BOOL *s
top))block; |
308 | 1182 |
| 1183 /** |
| 1184 * Adds a value to this array. |
| 1185 * |
| 1186 * @param value The value to add to this array. |
| 1187 **/ |
309 - (void)addValue:(BOOL)value; | 1188 - (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 **/ |
310 - (void)addValues:(const BOOL [])values count:(NSUInteger)count; | 1196 - (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 **/ |
311 - (void)addValuesFromArray:(GPBBoolArray *)array; | 1203 - (void)addValuesFromArray:(GPBBoolArray *)array; |
312 | 1204 |
| 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 **/ |
313 - (void)insertValue:(BOOL)value atIndex:(NSUInteger)index; | 1211 - (void)insertValue:(BOOL)value atIndex:(NSUInteger)index; |
314 | 1212 |
| 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 **/ |
315 - (void)replaceValueAtIndex:(NSUInteger)index withValue:(BOOL)value; | 1219 - (void)replaceValueAtIndex:(NSUInteger)index withValue:(BOOL)value; |
316 | 1220 |
| 1221 /** |
| 1222 * Removes the value at the given index. |
| 1223 * |
| 1224 * @param index The index of the value to remove. |
| 1225 **/ |
317 - (void)removeValueAtIndex:(NSUInteger)index; | 1226 - (void)removeValueAtIndex:(NSUInteger)index; |
| 1227 |
| 1228 /** |
| 1229 * Removes all the values from this array. |
| 1230 **/ |
318 - (void)removeAll; | 1231 - (void)removeAll; |
319 | 1232 |
| 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 **/ |
320 - (void)exchangeValueAtIndex:(NSUInteger)idx1 | 1239 - (void)exchangeValueAtIndex:(NSUInteger)idx1 |
321 withValueAtIndex:(NSUInteger)idx2; | 1240 withValueAtIndex:(NSUInteger)idx2; |
322 | 1241 |
323 @end | 1242 @end |
324 | 1243 |
325 #pragma mark - Enum | 1244 #pragma mark - Enum |
326 | 1245 |
| 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 **/ |
327 @interface GPBEnumArray : NSObject <NSCopying> | 1252 @interface GPBEnumArray : NSObject <NSCopying> |
328 | 1253 |
| 1254 /** The number of elements contained in the array. */ |
329 @property(nonatomic, readonly) NSUInteger count; | 1255 @property(nonatomic, readonly) NSUInteger count; |
| 1256 /** The validation function to check if the enums are valid. */ |
330 @property(nonatomic, readonly) GPBEnumValidationFunc validationFunc; | 1257 @property(nonatomic, readonly) GPBEnumValidationFunc validationFunc; |
331 | 1258 |
| 1259 /** |
| 1260 * @return A newly instanced and empty GPBEnumArray. |
| 1261 **/ |
332 + (instancetype)array; | 1262 + (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 **/ |
333 + (instancetype)arrayWithValidationFunction:(nullable GPBEnumValidationFunc)func
; | 1272 + (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 **/ |
334 + (instancetype)arrayWithValidationFunction:(nullable GPBEnumValidationFunc)func | 1283 + (instancetype)arrayWithValidationFunction:(nullable GPBEnumValidationFunc)func |
335 rawValue:(int32_t)value; | 1284 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 **/ |
336 + (instancetype)arrayWithValueArray:(GPBEnumArray *)array; | 1294 + (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 **/ |
337 + (instancetype)arrayWithValidationFunction:(nullable GPBEnumValidationFunc)func | 1305 + (instancetype)arrayWithValidationFunction:(nullable GPBEnumValidationFunc)func |
338 capacity:(NSUInteger)count; | 1306 capacity:(NSUInteger)count; |
339 | 1307 |
| 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 **/ |
340 - (instancetype)initWithValidationFunction:(nullable GPBEnumValidationFunc)func | 1315 - (instancetype)initWithValidationFunction:(nullable GPBEnumValidationFunc)func |
341 NS_DESIGNATED_INITIALIZER; | 1316 NS_DESIGNATED_INITIALIZER; |
342 | 1317 |
343 // Initializes the array, copying the values. | 1318 /** |
| 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 **/ |
344 - (instancetype)initWithValidationFunction:(nullable GPBEnumValidationFunc)func | 1327 - (instancetype)initWithValidationFunction:(nullable GPBEnumValidationFunc)func |
345 rawValues:(const int32_t [])values | 1328 rawValues:(const int32_t [])values |
346 count:(NSUInteger)count; | 1329 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 **/ |
347 - (instancetype)initWithValueArray:(GPBEnumArray *)array; | 1338 - (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 **/ |
348 - (instancetype)initWithValidationFunction:(nullable GPBEnumValidationFunc)func | 1348 - (instancetype)initWithValidationFunction:(nullable GPBEnumValidationFunc)func |
349 capacity:(NSUInteger)count; | 1349 capacity:(NSUInteger)count; |
350 | 1350 |
351 // These will return kGPBUnrecognizedEnumeratorValue if the value at index is no
t a | 1351 // These will return kGPBUnrecognizedEnumeratorValue if the value at index is no
t a |
352 // valid enumerator as defined by validationFunc. If the actual value is | 1352 // valid enumerator as defined by validationFunc. If the actual value is |
353 // desired, use "raw" version of the method. | 1353 // desired, use "raw" version of the method. |
354 | 1354 |
| 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 **/ |
355 - (int32_t)valueAtIndex:(NSUInteger)index; | 1362 - (int32_t)valueAtIndex:(NSUInteger)index; |
356 | 1363 |
| 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 **/ |
357 - (void)enumerateValuesWithBlock:(void (^)(int32_t value, NSUInteger idx, BOOL *
stop))block; | 1372 - (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 **/ |
358 - (void)enumerateValuesWithOptions:(NSEnumerationOptions)opts | 1383 - (void)enumerateValuesWithOptions:(NSEnumerationOptions)opts |
359 usingBlock:(void (^)(int32_t value, NSUInteger idx, BOOL
*stop))block; | 1384 usingBlock:(void (^)(int32_t value, NSUInteger idx, BOOL
*stop))block; |
360 | 1385 |
361 // These methods bypass the validationFunc to provide access to values that were
not | 1386 // These methods bypass the validationFunc to provide access to values that were
not |
362 // known at the time the binary was compiled. | 1387 // known at the time the binary was compiled. |
363 | 1388 |
| 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 **/ |
364 - (int32_t)rawValueAtIndex:(NSUInteger)index; | 1396 - (int32_t)rawValueAtIndex:(NSUInteger)index; |
365 | 1397 |
| 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 **/ |
366 - (void)enumerateRawValuesWithBlock:(void (^)(int32_t value, NSUInteger idx, BOO
L *stop))block; | 1406 - (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 **/ |
367 - (void)enumerateRawValuesWithOptions:(NSEnumerationOptions)opts | 1417 - (void)enumerateRawValuesWithOptions:(NSEnumerationOptions)opts |
368 usingBlock:(void (^)(int32_t value, NSUInteger idx, B
OOL *stop))block; | 1418 usingBlock:(void (^)(int32_t value, NSUInteger idx, B
OOL *stop))block; |
369 | 1419 |
370 // If value is not a valid enumerator as defined by validationFunc, these | 1420 // If value is not a valid enumerator as defined by validationFunc, these |
371 // methods will assert in debug, and will log in release and assign the value | 1421 // methods will assert in debug, and will log in release and assign the value |
372 // to the default value. Use the rawValue methods below to assign non enumerator | 1422 // to the default value. Use the rawValue methods below to assign non enumerator |
373 // values. | 1423 // values. |
374 | 1424 |
| 1425 /** |
| 1426 * Adds a value to this array. |
| 1427 * |
| 1428 * @param value The value to add to this array. |
| 1429 **/ |
375 - (void)addValue:(int32_t)value; | 1430 - (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 **/ |
376 - (void)addValues:(const int32_t [])values count:(NSUInteger)count; | 1438 - (void)addValues:(const int32_t [])values count:(NSUInteger)count; |
377 | 1439 |
| 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 **/ |
378 - (void)insertValue:(int32_t)value atIndex:(NSUInteger)index; | 1447 - (void)insertValue:(int32_t)value atIndex:(NSUInteger)index; |
379 | 1448 |
| 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 **/ |
380 - (void)replaceValueAtIndex:(NSUInteger)index withValue:(int32_t)value; | 1455 - (void)replaceValueAtIndex:(NSUInteger)index withValue:(int32_t)value; |
381 | 1456 |
382 // These methods bypass the validationFunc to provide setting of values that wer
e not | 1457 // These methods bypass the validationFunc to provide setting of values that wer
e not |
383 // known at the time the binary was compiled. | 1458 // known at the time the binary was compiled. |
384 | 1459 |
| 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 **/ |
385 - (void)addRawValue:(int32_t)value; | 1468 - (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 **/ |
386 - (void)addRawValuesFromArray:(GPBEnumArray *)array; | 1478 - (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 **/ |
387 - (void)addRawValues:(const int32_t [])values count:(NSUInteger)count; | 1489 - (void)addRawValues:(const int32_t [])values count:(NSUInteger)count; |
388 | 1490 |
| 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 **/ |
389 - (void)insertRawValue:(int32_t)value atIndex:(NSUInteger)index; | 1500 - (void)insertRawValue:(int32_t)value atIndex:(NSUInteger)index; |
390 | 1501 |
| 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 **/ |
391 - (void)replaceValueAtIndex:(NSUInteger)index withRawValue:(int32_t)value; | 1511 - (void)replaceValueAtIndex:(NSUInteger)index withRawValue:(int32_t)value; |
392 | 1512 |
393 // No validation applies to these methods. | 1513 // No validation applies to these methods. |
394 | 1514 |
| 1515 /** |
| 1516 * Removes the value at the given index. |
| 1517 * |
| 1518 * @param index The index of the value to remove. |
| 1519 **/ |
395 - (void)removeValueAtIndex:(NSUInteger)index; | 1520 - (void)removeValueAtIndex:(NSUInteger)index; |
| 1521 |
| 1522 /** |
| 1523 * Removes all the values from this array. |
| 1524 **/ |
396 - (void)removeAll; | 1525 - (void)removeAll; |
397 | 1526 |
| 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 **/ |
398 - (void)exchangeValueAtIndex:(NSUInteger)idx1 | 1533 - (void)exchangeValueAtIndex:(NSUInteger)idx1 |
399 withValueAtIndex:(NSUInteger)idx2; | 1534 withValueAtIndex:(NSUInteger)idx2; |
400 | 1535 |
401 @end | 1536 @end |
402 | 1537 |
403 //%PDDM-EXPAND-END DECLARE_ARRAYS() | 1538 //%PDDM-EXPAND-END DECLARE_ARRAYS() |
404 | 1539 |
405 NS_ASSUME_NONNULL_END | 1540 NS_ASSUME_NONNULL_END |
406 | 1541 |
407 //%PDDM-DEFINE DECLARE_ARRAYS() | 1542 //%PDDM-DEFINE DECLARE_ARRAYS() |
408 //%ARRAY_INTERFACE_SIMPLE(Int32, int32_t) | 1543 //%ARRAY_INTERFACE_SIMPLE(Int32, int32_t) |
409 //%ARRAY_INTERFACE_SIMPLE(UInt32, uint32_t) | 1544 //%ARRAY_INTERFACE_SIMPLE(UInt32, uint32_t) |
410 //%ARRAY_INTERFACE_SIMPLE(Int64, int64_t) | 1545 //%ARRAY_INTERFACE_SIMPLE(Int64, int64_t) |
411 //%ARRAY_INTERFACE_SIMPLE(UInt64, uint64_t) | 1546 //%ARRAY_INTERFACE_SIMPLE(UInt64, uint64_t) |
412 //%ARRAY_INTERFACE_SIMPLE(Float, float) | 1547 //%ARRAY_INTERFACE_SIMPLE(Float, float) |
413 //%ARRAY_INTERFACE_SIMPLE(Double, double) | 1548 //%ARRAY_INTERFACE_SIMPLE(Double, double) |
414 //%ARRAY_INTERFACE_SIMPLE(Bool, BOOL) | 1549 //%ARRAY_INTERFACE_SIMPLE(Bool, BOOL) |
415 //%ARRAY_INTERFACE_ENUM(Enum, int32_t) | 1550 //%ARRAY_INTERFACE_ENUM(Enum, int32_t) |
416 | 1551 |
417 // | 1552 // |
418 // The common case (everything but Enum) | 1553 // The common case (everything but Enum) |
419 // | 1554 // |
420 | 1555 |
421 //%PDDM-DEFINE ARRAY_INTERFACE_SIMPLE(NAME, TYPE) | 1556 //%PDDM-DEFINE ARRAY_INTERFACE_SIMPLE(NAME, TYPE) |
422 //%#pragma mark - NAME | 1557 //%#pragma mark - NAME |
423 //% | 1558 //% |
| 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 //% **/ |
424 //%@interface GPB##NAME##Array : NSObject <NSCopying> | 1565 //%@interface GPB##NAME##Array : NSObject <NSCopying> |
425 //% | 1566 //% |
| 1567 //%/** The number of elements contained in the array. */ |
426 //%@property(nonatomic, readonly) NSUInteger count; | 1568 //%@property(nonatomic, readonly) NSUInteger count; |
427 //% | 1569 //% |
| 1570 //%/** |
| 1571 //% * @return A newly instanced and empty GPB##NAME##Array. |
| 1572 //% **/ |
428 //%+ (instancetype)array; | 1573 //%+ (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 //% **/ |
429 //%+ (instancetype)arrayWithValue:(TYPE)value; | 1582 //%+ (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 //% **/ |
430 //%+ (instancetype)arrayWithValueArray:(GPB##NAME##Array *)array; | 1592 //%+ (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 //% **/ |
431 //%+ (instancetype)arrayWithCapacity:(NSUInteger)count; | 1601 //%+ (instancetype)arrayWithCapacity:(NSUInteger)count; |
432 //% | 1602 //% |
| 1603 //%/** |
| 1604 //% * @return A newly initialized and empty GPB##NAME##Array. |
| 1605 //% **/ |
433 //%- (instancetype)init NS_DESIGNATED_INITIALIZER; | 1606 //%- (instancetype)init NS_DESIGNATED_INITIALIZER; |
434 //%// Initializes the array, copying the values. | 1607 //% |
| 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 //% **/ |
435 //%- (instancetype)initWithValues:(const TYPE [])values | 1616 //%- (instancetype)initWithValues:(const TYPE [])values |
436 //% count:(NSUInteger)count; | 1617 //% 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 //% **/ |
437 //%- (instancetype)initWithValueArray:(GPB##NAME##Array *)array; | 1626 //%- (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 //% **/ |
438 //%- (instancetype)initWithCapacity:(NSUInteger)count; | 1635 //%- (instancetype)initWithCapacity:(NSUInteger)count; |
439 //% | 1636 //% |
440 //%ARRAY_IMMUTABLE_INTERFACE(NAME, TYPE, Basic) | 1637 //%ARRAY_IMMUTABLE_INTERFACE(NAME, TYPE, Basic) |
441 //% | 1638 //% |
442 //%ARRAY_MUTABLE_INTERFACE(NAME, TYPE, Basic) | 1639 //%ARRAY_MUTABLE_INTERFACE(NAME, TYPE, Basic) |
443 //% | 1640 //% |
444 //%@end | 1641 //%@end |
445 //% | 1642 //% |
446 | 1643 |
447 // | 1644 // |
448 // Macros specific to Enums (to tweak their interface). | 1645 // Macros specific to Enums (to tweak their interface). |
449 // | 1646 // |
450 | 1647 |
451 //%PDDM-DEFINE ARRAY_INTERFACE_ENUM(NAME, TYPE) | 1648 //%PDDM-DEFINE ARRAY_INTERFACE_ENUM(NAME, TYPE) |
452 //%#pragma mark - NAME | 1649 //%#pragma mark - NAME |
453 //% | 1650 //% |
| 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 //% **/ |
454 //%@interface GPB##NAME##Array : NSObject <NSCopying> | 1657 //%@interface GPB##NAME##Array : NSObject <NSCopying> |
455 //% | 1658 //% |
| 1659 //%/** The number of elements contained in the array. */ |
456 //%@property(nonatomic, readonly) NSUInteger count; | 1660 //%@property(nonatomic, readonly) NSUInteger count; |
| 1661 //%/** The validation function to check if the enums are valid. */ |
457 //%@property(nonatomic, readonly) GPBEnumValidationFunc validationFunc; | 1662 //%@property(nonatomic, readonly) GPBEnumValidationFunc validationFunc; |
458 //% | 1663 //% |
| 1664 //%/** |
| 1665 //% * @return A newly instanced and empty GPB##NAME##Array. |
| 1666 //% **/ |
459 //%+ (instancetype)array; | 1667 //%+ (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 //% **/ |
460 //%+ (instancetype)arrayWithValidationFunction:(nullable GPBEnumValidationFunc)f
unc; | 1677 //%+ (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 //% **/ |
461 //%+ (instancetype)arrayWithValidationFunction:(nullable GPBEnumValidationFunc)f
unc | 1688 //%+ (instancetype)arrayWithValidationFunction:(nullable GPBEnumValidationFunc)f
unc |
462 //% rawValue:(TYPE)value; | 1689 //% 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 //% **/ |
463 //%+ (instancetype)arrayWithValueArray:(GPB##NAME##Array *)array; | 1699 //%+ (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 //% **/ |
464 //%+ (instancetype)arrayWithValidationFunction:(nullable GPBEnumValidationFunc)f
unc | 1710 //%+ (instancetype)arrayWithValidationFunction:(nullable GPBEnumValidationFunc)f
unc |
465 //% capacity:(NSUInteger)count; | 1711 //% capacity:(NSUInteger)count; |
466 //% | 1712 //% |
| 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 //% **/ |
467 //%- (instancetype)initWithValidationFunction:(nullable GPBEnumValidationFunc)fu
nc | 1720 //%- (instancetype)initWithValidationFunction:(nullable GPBEnumValidationFunc)fu
nc |
468 //% NS_DESIGNATED_INITIALIZER; | 1721 //% NS_DESIGNATED_INITIALIZER; |
469 //% | 1722 //% |
470 //%// Initializes the array, copying the values. | 1723 //%/** |
| 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 //% **/ |
471 //%- (instancetype)initWithValidationFunction:(nullable GPBEnumValidationFunc)fu
nc | 1732 //%- (instancetype)initWithValidationFunction:(nullable GPBEnumValidationFunc)fu
nc |
472 //% rawValues:(const TYPE [])values | 1733 //% rawValues:(const TYPE [])values |
473 //% count:(NSUInteger)count; | 1734 //% 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 //% **/ |
474 //%- (instancetype)initWithValueArray:(GPB##NAME##Array *)array; | 1743 //%- (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 //% **/ |
475 //%- (instancetype)initWithValidationFunction:(nullable GPBEnumValidationFunc)fu
nc | 1753 //%- (instancetype)initWithValidationFunction:(nullable GPBEnumValidationFunc)fu
nc |
476 //% capacity:(NSUInteger)count; | 1754 //% capacity:(NSUInteger)count; |
477 //% | 1755 //% |
478 //%// These will return kGPBUnrecognizedEnumeratorValue if the value at index is
not a | 1756 //%// These will return kGPBUnrecognizedEnumeratorValue if the value at index is
not a |
479 //%// valid enumerator as defined by validationFunc. If the actual value is | 1757 //%// valid enumerator as defined by validationFunc. If the actual value is |
480 //%// desired, use "raw" version of the method. | 1758 //%// desired, use "raw" version of the method. |
481 //% | 1759 //% |
482 //%ARRAY_IMMUTABLE_INTERFACE(NAME, TYPE, NAME) | 1760 //%ARRAY_IMMUTABLE_INTERFACE(NAME, TYPE, NAME) |
483 //% | 1761 //% |
484 //%// These methods bypass the validationFunc to provide access to values that w
ere not | 1762 //%// These methods bypass the validationFunc to provide access to values that w
ere not |
485 //%// known at the time the binary was compiled. | 1763 //%// known at the time the binary was compiled. |
486 //% | 1764 //% |
| 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 //% **/ |
487 //%- (TYPE)rawValueAtIndex:(NSUInteger)index; | 1772 //%- (TYPE)rawValueAtIndex:(NSUInteger)index; |
488 //% | 1773 //% |
| 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 //% **/ |
489 //%- (void)enumerateRawValuesWithBlock:(void (^)(TYPE value, NSUInteger idx, BOO
L *stop))block; | 1782 //%- (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 //% **/ |
490 //%- (void)enumerateRawValuesWithOptions:(NSEnumerationOptions)opts | 1793 //%- (void)enumerateRawValuesWithOptions:(NSEnumerationOptions)opts |
491 //% usingBlock:(void (^)(TYPE value, NSUInteger idx, B
OOL *stop))block; | 1794 //% usingBlock:(void (^)(TYPE value, NSUInteger idx, B
OOL *stop))block; |
492 //% | 1795 //% |
493 //%// If value is not a valid enumerator as defined by validationFunc, these | 1796 //%// If value is not a valid enumerator as defined by validationFunc, these |
494 //%// methods will assert in debug, and will log in release and assign the value | 1797 //%// methods will assert in debug, and will log in release and assign the value |
495 //%// to the default value. Use the rawValue methods below to assign non enumera
tor | 1798 //%// to the default value. Use the rawValue methods below to assign non enumera
tor |
496 //%// values. | 1799 //%// values. |
497 //% | 1800 //% |
498 //%ARRAY_MUTABLE_INTERFACE(NAME, TYPE, NAME) | 1801 //%ARRAY_MUTABLE_INTERFACE(NAME, TYPE, NAME) |
499 //% | 1802 //% |
500 //%@end | 1803 //%@end |
501 //% | 1804 //% |
502 | 1805 |
503 //%PDDM-DEFINE ARRAY_IMMUTABLE_INTERFACE(NAME, TYPE, HELPER_NAME) | 1806 //%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 //% **/ |
504 //%- (TYPE)valueAtIndex:(NSUInteger)index; | 1814 //%- (TYPE)valueAtIndex:(NSUInteger)index; |
505 //% | 1815 //% |
| 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 //% **/ |
506 //%- (void)enumerateValuesWithBlock:(void (^)(TYPE value, NSUInteger idx, BOOL *
stop))block; | 1824 //%- (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 //% **/ |
507 //%- (void)enumerateValuesWithOptions:(NSEnumerationOptions)opts | 1835 //%- (void)enumerateValuesWithOptions:(NSEnumerationOptions)opts |
508 //% usingBlock:(void (^)(TYPE value, NSUInteger idx, BOOL
*stop))block; | 1836 //% usingBlock:(void (^)(TYPE value, NSUInteger idx, BOOL
*stop))block; |
509 | 1837 |
510 //%PDDM-DEFINE ARRAY_MUTABLE_INTERFACE(NAME, TYPE, HELPER_NAME) | 1838 //%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 //% **/ |
511 //%- (void)addValue:(TYPE)value; | 1844 //%- (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 //% **/ |
512 //%- (void)addValues:(const TYPE [])values count:(NSUInteger)count; | 1852 //%- (void)addValues:(const TYPE [])values count:(NSUInteger)count; |
| 1853 //% |
513 //%ARRAY_EXTRA_MUTABLE_METHODS1_##HELPER_NAME(NAME, TYPE) | 1854 //%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 //% **/ |
514 //%- (void)insertValue:(TYPE)value atIndex:(NSUInteger)index; | 1861 //%- (void)insertValue:(TYPE)value atIndex:(NSUInteger)index; |
515 //% | 1862 //% |
| 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 //% **/ |
516 //%- (void)replaceValueAtIndex:(NSUInteger)index withValue:(TYPE)value; | 1869 //%- (void)replaceValueAtIndex:(NSUInteger)index withValue:(TYPE)value; |
517 //%ARRAY_EXTRA_MUTABLE_METHODS2_##HELPER_NAME(NAME, TYPE) | 1870 //%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 //% **/ |
518 //%- (void)removeValueAtIndex:(NSUInteger)index; | 1876 //%- (void)removeValueAtIndex:(NSUInteger)index; |
| 1877 //% |
| 1878 //%/** |
| 1879 //% * Removes all the values from this array. |
| 1880 //% **/ |
519 //%- (void)removeAll; | 1881 //%- (void)removeAll; |
520 //% | 1882 //% |
| 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 //% **/ |
521 //%- (void)exchangeValueAtIndex:(NSUInteger)idx1 | 1889 //%- (void)exchangeValueAtIndex:(NSUInteger)idx1 |
522 //% withValueAtIndex:(NSUInteger)idx2; | 1890 //% withValueAtIndex:(NSUInteger)idx2; |
523 | 1891 |
524 // | 1892 // |
525 // These are hooks invoked by the above to do insert as needed. | 1893 // These are hooks invoked by the above to do insert as needed. |
526 // | 1894 // |
527 | 1895 |
528 //%PDDM-DEFINE ARRAY_EXTRA_MUTABLE_METHODS1_Basic(NAME, TYPE) | 1896 //%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 //% **/ |
529 //%- (void)addValuesFromArray:(GPB##NAME##Array *)array; | 1902 //%- (void)addValuesFromArray:(GPB##NAME##Array *)array; |
530 //% | 1903 //% |
531 //%PDDM-DEFINE ARRAY_EXTRA_MUTABLE_METHODS2_Basic(NAME, TYPE) | 1904 //%PDDM-DEFINE ARRAY_EXTRA_MUTABLE_METHODS2_Basic(NAME, TYPE) |
532 // Empty | 1905 // Empty |
533 //%PDDM-DEFINE ARRAY_EXTRA_MUTABLE_METHODS1_Enum(NAME, TYPE) | 1906 //%PDDM-DEFINE ARRAY_EXTRA_MUTABLE_METHODS1_Enum(NAME, TYPE) |
534 // Empty | 1907 // Empty |
535 //%PDDM-DEFINE ARRAY_EXTRA_MUTABLE_METHODS2_Enum(NAME, TYPE) | 1908 //%PDDM-DEFINE ARRAY_EXTRA_MUTABLE_METHODS2_Enum(NAME, TYPE) |
536 //% | 1909 //% |
537 //%// These methods bypass the validationFunc to provide setting of values that
were not | 1910 //%// These methods bypass the validationFunc to provide setting of values that
were not |
538 //%// known at the time the binary was compiled. | 1911 //%// known at the time the binary was compiled. |
539 //% | 1912 //% |
| 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 //% **/ |
540 //%- (void)addRawValue:(TYPE)value; | 1921 //%- (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 //% **/ |
541 //%- (void)addRawValuesFromArray:(GPB##NAME##Array *)array; | 1931 //%- (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 //% **/ |
542 //%- (void)addRawValues:(const TYPE [])values count:(NSUInteger)count; | 1942 //%- (void)addRawValues:(const TYPE [])values count:(NSUInteger)count; |
543 //% | 1943 //% |
| 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 //% **/ |
544 //%- (void)insertRawValue:(TYPE)value atIndex:(NSUInteger)index; | 1953 //%- (void)insertRawValue:(TYPE)value atIndex:(NSUInteger)index; |
545 //% | 1954 //% |
| 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 //% **/ |
546 //%- (void)replaceValueAtIndex:(NSUInteger)index withRawValue:(TYPE)value; | 1964 //%- (void)replaceValueAtIndex:(NSUInteger)index withRawValue:(TYPE)value; |
547 //% | 1965 //% |
548 //%// No validation applies to these methods. | 1966 //%// No validation applies to these methods. |
549 //% | 1967 //% |
OLD | NEW |