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