Modified src/OFConstantString.m
from [8b793fe13a]
to [c17936e454].
︙ | | | ︙ | |
594
595
596
597
598
599
600
601
602
603
604
605
606
607
|
- (void)writeToURL: (OFURL *)URL encoding: (OFStringEncoding)encoding
{
[self finishInitialization];
[self writeToURL: URL encoding: encoding];
}
#ifdef OF_HAVE_BLOCKS
- (void)enumerateLinesUsingBlock: (of_string_line_enumeration_block_t)block
{
[self finishInitialization];
[self enumerateLinesUsingBlock: block];
}
#endif
@end
|
|
|
594
595
596
597
598
599
600
601
602
603
604
605
606
607
|
- (void)writeToURL: (OFURL *)URL encoding: (OFStringEncoding)encoding
{
[self finishInitialization];
[self writeToURL: URL encoding: encoding];
}
#ifdef OF_HAVE_BLOCKS
- (void)enumerateLinesUsingBlock: (OFStringLineEnumerationBlock)block
{
[self finishInitialization];
[self enumerateLinesUsingBlock: block];
}
#endif
@end
|
Modified src/OFCountedMapTableSet.m
from [1688e99723]
to [00546e8e62].
︙ | | | ︙ | |
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
|
- (size_t)countForObject: (id)object
{
return (size_t)(uintptr_t)[_mapTable objectForKey: object];
}
#ifdef OF_HAVE_BLOCKS
- (void)enumerateObjectsAndCountUsingBlock:
(of_counted_set_enumeration_block_t)block
{
@try {
[_mapTable enumerateKeysAndObjectsUsingBlock:
^ (void *key, void *object, bool *stop) {
block(key, (size_t)(uintptr_t)object, stop);
}];
} @catch (OFEnumerationMutationException *e) {
|
|
<
|
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
|
- (size_t)countForObject: (id)object
{
return (size_t)(uintptr_t)[_mapTable objectForKey: object];
}
#ifdef OF_HAVE_BLOCKS
- (void)enumerateObjectsAndCountUsingBlock: (OFCountedSetEnumerationBlock)block
{
@try {
[_mapTable enumerateKeysAndObjectsUsingBlock:
^ (void *key, void *object, bool *stop) {
block(key, (size_t)(uintptr_t)object, stop);
}];
} @catch (OFEnumerationMutationException *e) {
|
︙ | | | ︙ | |
Modified src/OFCountedSet.h
from [d5fbc7df8a]
to [aa07eb172d].
︙ | | | ︙ | |
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
|
* @brief A block for enumerating an OFCountedSet.
*
* @param object The current object
* @param count The count of the object
* @param stop A pointer to a variable that can be set to true to stop the
* enumeration
*/
typedef void (^of_counted_set_enumeration_block_t)(id object, size_t count,
bool *stop);
#endif
/**
* @class OFCountedSet OFCountedSet.h ObjFW/OFCountedSet.h
*
* @brief An abstract class for a mutable unordered set of objects, counting how
|
|
|
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
|
* @brief A block for enumerating an OFCountedSet.
*
* @param object The current object
* @param count The count of the object
* @param stop A pointer to a variable that can be set to true to stop the
* enumeration
*/
typedef void (^OFCountedSetEnumerationBlock)(id object, size_t count,
bool *stop);
#endif
/**
* @class OFCountedSet OFCountedSet.h ObjFW/OFCountedSet.h
*
* @brief An abstract class for a mutable unordered set of objects, counting how
|
︙ | | | ︙ | |
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
|
#ifdef OF_HAVE_BLOCKS
/**
* @brief Executes a block for each object in the set.
*
* @param block The block to execute for each object in the set
*/
- (void)enumerateObjectsAndCountUsingBlock:
(of_counted_set_enumeration_block_t)block;
#endif
#if !defined(OF_HAVE_GENERICS) && !defined(DOXYGEN)
# undef ObjectType
#endif
@end
OF_ASSUME_NONNULL_END
|
|
<
|
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
|
#ifdef OF_HAVE_BLOCKS
/**
* @brief Executes a block for each object in the set.
*
* @param block The block to execute for each object in the set
*/
- (void)enumerateObjectsAndCountUsingBlock: (OFCountedSetEnumerationBlock)block;
#endif
#if !defined(OF_HAVE_GENERICS) && !defined(DOXYGEN)
# undef ObjectType
#endif
@end
OF_ASSUME_NONNULL_END
|
Modified src/OFCountedSet.m
from [d6c7218230]
to [fe3c7716dc].
︙ | | | ︙ | |
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
|
objc_autoreleasePoolPop(pool);
return [element autorelease];
}
#ifdef OF_HAVE_BLOCKS
- (void)enumerateObjectsAndCountUsingBlock:
(of_counted_set_enumeration_block_t)block
{
[self enumerateObjectsUsingBlock: ^ (id object, bool *stop) {
block(object, [self countForObject: object], stop);
}];
}
#endif
|
|
<
|
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
|
objc_autoreleasePoolPop(pool);
return [element autorelease];
}
#ifdef OF_HAVE_BLOCKS
- (void)enumerateObjectsAndCountUsingBlock: (OFCountedSetEnumerationBlock)block
{
[self enumerateObjectsUsingBlock: ^ (id object, bool *stop) {
block(object, [self countForObject: object], stop);
}];
}
#endif
|
︙ | | | ︙ | |
Modified src/OFDatagramSocket.h
from [3462a90bc3]
to [9ea42e6506].
︙ | | | ︙ | |
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
|
*
* @param length The length of the packet
* @param sender The address of the sender of the packet
* @param exception An exception which occurred while receiving or `nil` on
* success
* @return A bool whether the same block should be used for the next receive
*/
typedef bool (^of_datagram_socket_async_receive_block_t)(
size_t length, const of_socket_address_t *_Nonnull sender,
id _Nullable exception);
/**
* @brief A block which is called when a packet has been sent.
*
* @param data The data which was sent
* @param receiver The receiver for the packet
* @param exception An exception which occurred while reading or `nil` on
* success
* @return The data to repeat the send with or nil if it should not repeat
*/
typedef OFData *_Nullable (^of_datagram_socket_async_send_data_block_t)(
OFData *_Nonnull data, const of_socket_address_t *_Nonnull receiver,
id _Nullable exception);
#endif
/**
* @protocol OFDatagramSocketDelegate OFDatagramSocket.h \
* ObjFW/OFDatagramSocket.h
|
|
|
<
|
|
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
|
*
* @param length The length of the packet
* @param sender The address of the sender of the packet
* @param exception An exception which occurred while receiving or `nil` on
* success
* @return A bool whether the same block should be used for the next receive
*/
typedef bool (^OFDatagramSocketAsyncReceiveBlock)(size_t length,
const of_socket_address_t *_Nonnull sender, id _Nullable exception);
/**
* @brief A block which is called when a packet has been sent.
*
* @param data The data which was sent
* @param receiver The receiver for the packet
* @param exception An exception which occurred while reading or `nil` on
* success
* @return The data to repeat the send with or nil if it should not repeat
*/
typedef OFData *_Nullable (^OFDatagramSocketAsyncSendDataBlock)(
OFData *_Nonnull data, const of_socket_address_t *_Nonnull receiver,
id _Nullable exception);
#endif
/**
* @protocol OFDatagramSocketDelegate OFDatagramSocket.h \
* ObjFW/OFDatagramSocket.h
|
︙ | | | ︙ | |
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
|
* buffer and maximum length when more datagrams have been
* received. If you want the next method in the queue to handle
* the datagram received next, you need to return false from the
* method.
*/
- (void)asyncReceiveIntoBuffer: (void *)buffer
length: (size_t)length
block: (of_datagram_socket_async_receive_block_t)block;
/**
* @brief Asynchronously receives a datagram and stores it into the specified
* buffer.
*
* If the buffer is too small, the datagram is truncated.
*
* @param buffer The buffer to write the datagram to
* @param length The length of the buffer
* @param runLoopMode The run loop mode in which to perform the async receive
* @param block The block to call when the datagram has been received. If the
* block returns true, it will be called again with the same
* buffer and maximum length when more datagrams have been
* received. If you want the next method in the queue to handle
* the datagram received next, you need to return false from the
* method.
*/
- (void)asyncReceiveIntoBuffer: (void *)buffer
length: (size_t)length
runLoopMode: (of_run_loop_mode_t)runLoopMode
block: (of_datagram_socket_async_receive_block_t)block;
#endif
/**
* @brief Sends the specified datagram to the specified address.
*
* @param buffer The buffer to send as a datagram
* @param length The length of the buffer
|
|
|
|
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
|
* buffer and maximum length when more datagrams have been
* received. If you want the next method in the queue to handle
* the datagram received next, you need to return false from the
* method.
*/
- (void)asyncReceiveIntoBuffer: (void *)buffer
length: (size_t)length
block: (OFDatagramSocketAsyncReceiveBlock)block;
/**
* @brief Asynchronously receives a datagram and stores it into the specified
* buffer.
*
* If the buffer is too small, the datagram is truncated.
*
* @param buffer The buffer to write the datagram to
* @param length The length of the buffer
* @param runLoopMode The run loop mode in which to perform the async receive
* @param block The block to call when the datagram has been received. If the
* block returns true, it will be called again with the same
* buffer and maximum length when more datagrams have been
* received. If you want the next method in the queue to handle
* the datagram received next, you need to return false from the
* method.
*/
- (void)asyncReceiveIntoBuffer: (void *)buffer
length: (size_t)length
runLoopMode: (of_run_loop_mode_t)runLoopMode
block: (OFDatagramSocketAsyncReceiveBlock)block;
#endif
/**
* @brief Sends the specified datagram to the specified address.
*
* @param buffer The buffer to send as a datagram
* @param length The length of the buffer
|
︙ | | | ︙ | |
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
|
* datagram should be sent. The receiver is copied.
* @param block The block to call when the packet has been sent. It should
* return the data for the next send with the same callback or nil
* if it should not repeat.
*/
- (void)asyncSendData: (OFData *)data
receiver: (const of_socket_address_t *)receiver
block: (of_datagram_socket_async_send_data_block_t)block;
/**
* @brief Asynchronously sends the specified datagram to the specified address.
*
* @param data The data to send as a datagram
* @param receiver A pointer to an @ref of_socket_address_t to which the
* datagram should be sent. The receiver is copied.
* @param runLoopMode The run loop mode in which to perform the async send
* @param block The block to call when the packet has been sent. It should
* return the data for the next send with the same callback or nil
* if it should not repeat.
*/
- (void)asyncSendData: (OFData *)data
receiver: (const of_socket_address_t *)receiver
runLoopMode: (of_run_loop_mode_t)runLoopMode
block: (of_datagram_socket_async_send_data_block_t)block;
#endif
/**
* @brief Cancels all pending asynchronous requests on the socket.
*/
- (void)cancelAsyncRequests;
|
|
|
|
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
|
* datagram should be sent. The receiver is copied.
* @param block The block to call when the packet has been sent. It should
* return the data for the next send with the same callback or nil
* if it should not repeat.
*/
- (void)asyncSendData: (OFData *)data
receiver: (const of_socket_address_t *)receiver
block: (OFDatagramSocketAsyncSendDataBlock)block;
/**
* @brief Asynchronously sends the specified datagram to the specified address.
*
* @param data The data to send as a datagram
* @param receiver A pointer to an @ref of_socket_address_t to which the
* datagram should be sent. The receiver is copied.
* @param runLoopMode The run loop mode in which to perform the async send
* @param block The block to call when the packet has been sent. It should
* return the data for the next send with the same callback or nil
* if it should not repeat.
*/
- (void)asyncSendData: (OFData *)data
receiver: (const of_socket_address_t *)receiver
runLoopMode: (of_run_loop_mode_t)runLoopMode
block: (OFDatagramSocketAsyncSendDataBlock)block;
#endif
/**
* @brief Cancels all pending asynchronous requests on the socket.
*/
- (void)cancelAsyncRequests;
|
︙ | | | ︙ | |
Modified src/OFDatagramSocket.m
from [ed638b6427]
to [dd3b60a4d6].
︙ | | | ︙ | |
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
|
# endif
delegate: _delegate];
}
#ifdef OF_HAVE_BLOCKS
- (void)asyncReceiveIntoBuffer: (void *)buffer
length: (size_t)length
block: (of_datagram_socket_async_receive_block_t)block
{
[self asyncReceiveIntoBuffer: buffer
length: length
runLoopMode: of_run_loop_mode_default
block: block];
}
- (void)asyncReceiveIntoBuffer: (void *)buffer
length: (size_t)length
runLoopMode: (of_run_loop_mode_t)runLoopMode
block: (of_datagram_socket_async_receive_block_t)block
{
[OFRunLoop of_addAsyncReceiveForDatagramSocket: self
buffer: buffer
length: length
mode: runLoopMode
block: block
delegate: nil];
|
|
|
|
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
|
# endif
delegate: _delegate];
}
#ifdef OF_HAVE_BLOCKS
- (void)asyncReceiveIntoBuffer: (void *)buffer
length: (size_t)length
block: (OFDatagramSocketAsyncReceiveBlock)block
{
[self asyncReceiveIntoBuffer: buffer
length: length
runLoopMode: of_run_loop_mode_default
block: block];
}
- (void)asyncReceiveIntoBuffer: (void *)buffer
length: (size_t)length
runLoopMode: (of_run_loop_mode_t)runLoopMode
block: (OFDatagramSocketAsyncReceiveBlock)block
{
[OFRunLoop of_addAsyncReceiveForDatagramSocket: self
buffer: buffer
length: length
mode: runLoopMode
block: block
delegate: nil];
|
︙ | | | ︙ | |
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
|
# endif
delegate: _delegate];
}
#ifdef OF_HAVE_BLOCKS
- (void)asyncSendData: (OFData *)data
receiver: (const of_socket_address_t *)receiver
block: (of_datagram_socket_async_send_data_block_t)block
{
[self asyncSendData: data
receiver: receiver
runLoopMode: of_run_loop_mode_default
block: block];
}
- (void)asyncSendData: (OFData *)data
receiver: (const of_socket_address_t *)receiver
runLoopMode: (of_run_loop_mode_t)runLoopMode
block: (of_datagram_socket_async_send_data_block_t)block
{
[OFRunLoop of_addAsyncSendForDatagramSocket: self
data: data
receiver: receiver
mode: runLoopMode
block: block
delegate: nil];
|
|
|
|
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
|
# endif
delegate: _delegate];
}
#ifdef OF_HAVE_BLOCKS
- (void)asyncSendData: (OFData *)data
receiver: (const of_socket_address_t *)receiver
block: (OFDatagramSocketAsyncSendDataBlock)block
{
[self asyncSendData: data
receiver: receiver
runLoopMode: of_run_loop_mode_default
block: block];
}
- (void)asyncSendData: (OFData *)data
receiver: (const of_socket_address_t *)receiver
runLoopMode: (of_run_loop_mode_t)runLoopMode
block: (OFDatagramSocketAsyncSendDataBlock)block
{
[OFRunLoop of_addAsyncSendForDatagramSocket: self
data: data
receiver: receiver
mode: runLoopMode
block: block
delegate: nil];
|
︙ | | | ︙ | |
Modified src/OFDictionary.h
from [72e24e9365]
to [a266eaef28].
︙ | | | ︙ | |
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
|
#import "OFMessagePackRepresentation.h"
OF_ASSUME_NONNULL_BEGIN
@class OFArray OF_GENERIC(ObjectType);
#ifdef OF_HAVE_BLOCKS
typedef void (^of_dictionary_enumeration_block_t)(id key, id object,
bool *stop);
typedef bool (^of_dictionary_filter_block_t)(id key, id object);
typedef id _Nonnull (^of_dictionary_map_block_t)(id key, id object);
#endif
/**
* @class OFDictionary OFDictionary.h ObjFW/OFDictionary.h
*
* @brief An abstract class for storing objects in a dictionary.
*
|
|
<
|
|
|
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
|
#import "OFMessagePackRepresentation.h"
OF_ASSUME_NONNULL_BEGIN
@class OFArray OF_GENERIC(ObjectType);
#ifdef OF_HAVE_BLOCKS
typedef void (^OFDictionaryEnumerationBlock)(id key, id object, bool *stop);
typedef bool (^OFDictionaryFilterBlock)(id key, id object);
typedef id _Nonnull (^OFDictionaryMapBlock)(id key, id object);
#endif
/**
* @class OFDictionary OFDictionary.h ObjFW/OFDictionary.h
*
* @brief An abstract class for storing objects in a dictionary.
*
|
︙ | | | ︙ | |
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
|
#ifdef OF_HAVE_BLOCKS
/**
* @brief Executes a block for each key / object pair.
*
* @param block The block to execute for each key / object pair.
*/
- (void)enumerateKeysAndObjectsUsingBlock:
(of_dictionary_enumeration_block_t)block;
/**
* @brief Creates a new dictionary, mapping each object using the specified
* block.
*
* @param block A block which maps an object for each object
* @return A new autoreleased OFDictionary
*/
- (OFDictionary OF_GENERIC(KeyType, id) *)mappedDictionaryUsingBlock:
(of_dictionary_map_block_t)block;
/**
* @brief Creates a new dictionary, only containing the objects for which the
* block returns true.
*
* @param block A block which determines if the object should be in the new
* dictionary
* @return A new autoreleased OFDictionary
*/
- (OFDictionary OF_GENERIC(KeyType, ObjectType) *)filteredDictionaryUsingBlock:
(of_dictionary_filter_block_t)block;
#endif
#if !defined(OF_HAVE_GENERICS) && !defined(DOXYGEN)
# undef KeyType
# undef ObjectType
#endif
@end
|
|
<
|
|
|
|
|
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
|
#ifdef OF_HAVE_BLOCKS
/**
* @brief Executes a block for each key / object pair.
*
* @param block The block to execute for each key / object pair.
*/
- (void)enumerateKeysAndObjectsUsingBlock: (OFDictionaryEnumerationBlock)block;
/**
* @brief Creates a new dictionary, mapping each object using the specified
* block.
*
* @param block A block which maps an object for each object
* @return A new autoreleased OFDictionary
*/
- (OFDictionary OF_GENERIC(KeyType, id) *)
mappedDictionaryUsingBlock: (OFDictionaryMapBlock)block;
/**
* @brief Creates a new dictionary, only containing the objects for which the
* block returns true.
*
* @param block A block which determines if the object should be in the new
* dictionary
* @return A new autoreleased OFDictionary
*/
- (OFDictionary OF_GENERIC(KeyType, ObjectType) *)
filteredDictionaryUsingBlock: (OFDictionaryFilterBlock)block;
#endif
#if !defined(OF_HAVE_GENERICS) && !defined(DOXYGEN)
# undef KeyType
# undef ObjectType
#endif
@end
|
︙ | | | ︙ | |
Modified src/OFDictionary.m
from [4dbb63643c]
to [18419a43d0].
︙ | | | ︙ | |
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
|
objects[i] = object;
}
return i;
}
#ifdef OF_HAVE_BLOCKS
- (void)enumerateKeysAndObjectsUsingBlock:
(of_dictionary_enumeration_block_t)block
{
bool stop = false;
for (id key in self) {
block(key, [self objectForKey: key], &stop);
if (stop)
break;
}
}
- (OFDictionary *)mappedDictionaryUsingBlock: (of_dictionary_map_block_t)block
{
OFMutableDictionary *new = [OFMutableDictionary dictionary];
[self enumerateKeysAndObjectsUsingBlock: ^ (id key, id object,
bool *stop) {
[new setObject: block(key, object) forKey: key];
}];
[new makeImmutable];
return new;
}
- (OFDictionary *)filteredDictionaryUsingBlock:
(of_dictionary_filter_block_t)block
{
OFMutableDictionary *new = [OFMutableDictionary dictionary];
[self enumerateKeysAndObjectsUsingBlock: ^ (id key, id object,
bool *stop) {
if (block(key, object))
[new setObject: object forKey: key];
|
|
<
|
|
<
|
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
|
objects[i] = object;
}
return i;
}
#ifdef OF_HAVE_BLOCKS
- (void)enumerateKeysAndObjectsUsingBlock: (OFDictionaryEnumerationBlock)block
{
bool stop = false;
for (id key in self) {
block(key, [self objectForKey: key], &stop);
if (stop)
break;
}
}
- (OFDictionary *)mappedDictionaryUsingBlock: (OFDictionaryMapBlock)block
{
OFMutableDictionary *new = [OFMutableDictionary dictionary];
[self enumerateKeysAndObjectsUsingBlock: ^ (id key, id object,
bool *stop) {
[new setObject: block(key, object) forKey: key];
}];
[new makeImmutable];
return new;
}
- (OFDictionary *)filteredDictionaryUsingBlock: (OFDictionaryFilterBlock)block
{
OFMutableDictionary *new = [OFMutableDictionary dictionary];
[self enumerateKeysAndObjectsUsingBlock: ^ (id key, id object,
bool *stop) {
if (block(key, object))
[new setObject: object forKey: key];
|
︙ | | | ︙ | |
Modified src/OFIPSocketAsyncConnector.m
from [09c7bbbcdf]
to [3510e69ffe].
︙ | | | ︙ | |
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
|
{
if (_exception == nil)
[_socket setCanBlock: true];
#ifdef OF_HAVE_BLOCKS
if (_block != NULL) {
if ([_socket isKindOfClass: [OFTCPSocket class]])
((of_tcp_socket_async_connect_block_t)_block)(
_exception);
else
OF_ENSURE(0);
} else {
#endif
if ([_delegate respondsToSelector:
@selector(socket:didConnectToHost:port:exception:)])
[_delegate socket: _socket
|
<
|
|
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
|
{
if (_exception == nil)
[_socket setCanBlock: true];
#ifdef OF_HAVE_BLOCKS
if (_block != NULL) {
if ([_socket isKindOfClass: [OFTCPSocket class]])
((OFTCPSocketAsyncConnectBlock)_block)(_exception);
else
OF_ENSURE(0);
} else {
#endif
if ([_delegate respondsToSelector:
@selector(socket:didConnectToHost:port:exception:)])
[_delegate socket: _socket
|
︙ | | | ︙ | |
Modified src/OFMapTable.h
from [428b0aea8c]
to [843bd062c2].
︙ | | | ︙ | |
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
|
* @brief A block for enumerating an OFMapTable.
*
* @param key The current key
* @param object The current object
* @param stop A pointer to a variable that can be set to true to stop the
* enumeration
*/
typedef void (^of_map_table_enumeration_block_t)(void *_Nullable key,
void *_Nullable object, bool *stop);
/**
* @brief A block for replacing objects in an OFMapTable.
*
* @param key The key of the object to replace
* @param object The object to replace
* @return The object to replace the object with
*/
typedef void *_Nullable (^of_map_table_replace_block_t)(void *_Nullable key,
void *_Nullable object);
#endif
@class OFMapTableEnumerator;
/**
* @class OFMapTable OFMapTable.h ObjFW/OFMapTable.h
|
|
|
|
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
|
* @brief A block for enumerating an OFMapTable.
*
* @param key The current key
* @param object The current object
* @param stop A pointer to a variable that can be set to true to stop the
* enumeration
*/
typedef void (^OFMapTableEnumerationBlock)(void *_Nullable key,
void *_Nullable object, bool *stop);
/**
* @brief A block for replacing objects in an OFMapTable.
*
* @param key The key of the object to replace
* @param object The object to replace
* @return The object to replace the object with
*/
typedef void *_Nullable (^OFMapTableReplaceBlock)(void *_Nullable key,
void *_Nullable object);
#endif
@class OFMapTableEnumerator;
/**
* @class OFMapTable OFMapTable.h ObjFW/OFMapTable.h
|
︙ | | | ︙ | |
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
|
#ifdef OF_HAVE_BLOCKS
/**
* @brief Executes a block for each key / object pair.
*
* @param block The block to execute for each key / object pair.
*/
- (void)enumerateKeysAndObjectsUsingBlock:
(of_map_table_enumeration_block_t)block;
/**
* @brief Replaces each object with the object returned by the block.
*
* @param block The block which returns a new object for each object
*/
- (void)replaceObjectsUsingBlock: (of_map_table_replace_block_t)block;
#endif
@end
/**
* @class OFMapTableEnumerator OFMapTable.h ObjFW/OFMapTable.h
*
* @brief A class which provides methods to enumerate through an OFMapTable's
|
|
<
|
|
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
|
#ifdef OF_HAVE_BLOCKS
/**
* @brief Executes a block for each key / object pair.
*
* @param block The block to execute for each key / object pair.
*/
- (void)enumerateKeysAndObjectsUsingBlock: (OFMapTableEnumerationBlock)block;
/**
* @brief Replaces each object with the object returned by the block.
*
* @param block The block which returns a new object for each object
*/
- (void)replaceObjectsUsingBlock: (OFMapTableReplaceBlock)block;
#endif
@end
/**
* @class OFMapTableEnumerator OFMapTable.h ObjFW/OFMapTable.h
*
* @brief A class which provides methods to enumerate through an OFMapTable's
|
︙ | | | ︙ | |
Modified src/OFMapTable.m
from [f62fe0ab1f]
to [69ee51ce08].
︙ | | | ︙ | |
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
|
state->itemsPtr = objects;
state->mutationsPtr = &_mutations;
return i;
}
#ifdef OF_HAVE_BLOCKS
- (void)enumerateKeysAndObjectsUsingBlock:
(of_map_table_enumeration_block_t)block
{
bool stop = false;
unsigned long mutations = _mutations;
for (size_t i = 0; i < _capacity && !stop; i++) {
if (_mutations != mutations)
@throw [OFEnumerationMutationException
exceptionWithObject: self];
if (_buckets[i] != NULL && _buckets[i] != &deleted)
block(_buckets[i]->key, _buckets[i]->object, &stop);
}
}
- (void)replaceObjectsUsingBlock: (of_map_table_replace_block_t)block
{
unsigned long mutations = _mutations;
for (size_t i = 0; i < _capacity; i++) {
if (_mutations != mutations)
@throw [OFEnumerationMutationException
exceptionWithObject: self];
|
|
<
|
|
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
|
state->itemsPtr = objects;
state->mutationsPtr = &_mutations;
return i;
}
#ifdef OF_HAVE_BLOCKS
- (void)enumerateKeysAndObjectsUsingBlock: (OFMapTableEnumerationBlock)block
{
bool stop = false;
unsigned long mutations = _mutations;
for (size_t i = 0; i < _capacity && !stop; i++) {
if (_mutations != mutations)
@throw [OFEnumerationMutationException
exceptionWithObject: self];
if (_buckets[i] != NULL && _buckets[i] != &deleted)
block(_buckets[i]->key, _buckets[i]->object, &stop);
}
}
- (void)replaceObjectsUsingBlock: (OFMapTableReplaceBlock)block
{
unsigned long mutations = _mutations;
for (size_t i = 0; i < _capacity; i++) {
if (_mutations != mutations)
@throw [OFEnumerationMutationException
exceptionWithObject: self];
|
︙ | | | ︙ | |
Modified src/OFMapTableDictionary.m
from [8abac033d7]
to [b911edeffb].
︙ | | | ︙ | |
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
|
{
return [_mapTable countByEnumeratingWithState: state
objects: objects
count: count];
}
#ifdef OF_HAVE_BLOCKS
- (void)enumerateKeysAndObjectsUsingBlock:
(of_dictionary_enumeration_block_t)block
{
@try {
[_mapTable enumerateKeysAndObjectsUsingBlock:
^ (void *key, void *object, bool *stop) {
block(key, object, stop);
}];
} @catch (OFEnumerationMutationException *e) {
|
|
<
|
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
|
{
return [_mapTable countByEnumeratingWithState: state
objects: objects
count: count];
}
#ifdef OF_HAVE_BLOCKS
- (void)enumerateKeysAndObjectsUsingBlock: (OFDictionaryEnumerationBlock)block
{
@try {
[_mapTable enumerateKeysAndObjectsUsingBlock:
^ (void *key, void *object, bool *stop) {
block(key, object, stop);
}];
} @catch (OFEnumerationMutationException *e) {
|
︙ | | | ︙ | |
Modified src/OFMapTableSet.m
from [906bf79f74]
to [8d95facb2a].
︙ | | | ︙ | |
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
|
{
return [_mapTable countByEnumeratingWithState: state
objects: objects
count: count];
}
#ifdef OF_HAVE_BLOCKS
- (void)enumerateObjectsUsingBlock: (of_set_enumeration_block_t)block
{
@try {
[_mapTable enumerateKeysAndObjectsUsingBlock:
^ (void *key, void *object, bool *stop) {
block(key, stop);
}];
} @catch (OFEnumerationMutationException *e) {
|
|
|
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
|
{
return [_mapTable countByEnumeratingWithState: state
objects: objects
count: count];
}
#ifdef OF_HAVE_BLOCKS
- (void)enumerateObjectsUsingBlock: (OFSetEnumerationBlock)block
{
@try {
[_mapTable enumerateKeysAndObjectsUsingBlock:
^ (void *key, void *object, bool *stop) {
block(key, stop);
}];
} @catch (OFEnumerationMutationException *e) {
|
︙ | | | ︙ | |
Modified src/OFMutableDictionary.h
from [d0bf1761a1]
to [d2bbc1da30].
︙ | | | ︙ | |
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
|
/**
* @brief A block for replacing objects in an OFMutableDictionary.
*
* @param key The key of the object to replace
* @param object The object to replace
* @return The object to replace the object with
*/
typedef id _Nonnull (^of_dictionary_replace_block_t)(id key, id object);
#endif
/**
* @class OFMutableDictionary OFDictionary.h ObjFW/OFDictionary.h
*
* @brief An abstract class for storing and changing objects in a dictionary.
*
|
|
|
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
|
/**
* @brief A block for replacing objects in an OFMutableDictionary.
*
* @param key The key of the object to replace
* @param object The object to replace
* @return The object to replace the object with
*/
typedef id _Nonnull (^OFDictionaryReplaceBlock)(id key, id object);
#endif
/**
* @class OFMutableDictionary OFDictionary.h ObjFW/OFDictionary.h
*
* @brief An abstract class for storing and changing objects in a dictionary.
*
|
︙ | | | ︙ | |
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
|
#ifdef OF_HAVE_BLOCKS
/**
* @brief Replaces each object with the object returned by the block.
*
* @param block The block which returns a new object for each object
*/
- (void)replaceObjectsUsingBlock: (of_dictionary_replace_block_t)block;
#endif
/**
* @brief Converts the mutable dictionary to an immutable dictionary.
*/
- (void)makeImmutable;
#if !defined(OF_HAVE_GENERICS) && !defined(DOXYGEN)
# undef KeyType
# undef ObjectType
#endif
@end
OF_ASSUME_NONNULL_END
|
|
|
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
|
#ifdef OF_HAVE_BLOCKS
/**
* @brief Replaces each object with the object returned by the block.
*
* @param block The block which returns a new object for each object
*/
- (void)replaceObjectsUsingBlock: (OFDictionaryReplaceBlock)block;
#endif
/**
* @brief Converts the mutable dictionary to an immutable dictionary.
*/
- (void)makeImmutable;
#if !defined(OF_HAVE_GENERICS) && !defined(DOXYGEN)
# undef KeyType
# undef ObjectType
#endif
@end
OF_ASSUME_NONNULL_END
|
Modified src/OFMutableDictionary.m
from [76370e25f8]
to [e5de8c4c10].
︙ | | | ︙ | |
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
|
(object = [objectEnumerator nextObject]) != nil)
[self setObject: object forKey: key];
objc_autoreleasePoolPop(pool);
}
#ifdef OF_HAVE_BLOCKS
- (void)replaceObjectsUsingBlock: (of_dictionary_replace_block_t)block
{
[self enumerateKeysAndObjectsUsingBlock: ^ (id key, id object,
bool *stop) {
id new = block(key, object);
if (new != object) {
[self setObject: block(key, object) forKey: key];
|
|
|
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
|
(object = [objectEnumerator nextObject]) != nil)
[self setObject: object forKey: key];
objc_autoreleasePoolPop(pool);
}
#ifdef OF_HAVE_BLOCKS
- (void)replaceObjectsUsingBlock: (OFDictionaryReplaceBlock)block
{
[self enumerateKeysAndObjectsUsingBlock: ^ (id key, id object,
bool *stop) {
id new = block(key, object);
if (new != object) {
[self setObject: block(key, object) forKey: key];
|
︙ | | | ︙ | |
Modified src/OFMutableMapTableDictionary.m
from [b27a83ce2f]
to [1009eb93ce].
︙ | | | ︙ | |
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
|
- (void)removeAllObjects
{
[_mapTable removeAllObjects];
}
#ifdef OF_HAVE_BLOCKS
- (void)replaceObjectsUsingBlock: (of_dictionary_replace_block_t)block
{
@try {
[_mapTable replaceObjectsUsingBlock:
^ void *(void *key, void *object) {
return block(key, object);
}];
} @catch (OFEnumerationMutationException *e) {
|
|
|
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
|
- (void)removeAllObjects
{
[_mapTable removeAllObjects];
}
#ifdef OF_HAVE_BLOCKS
- (void)replaceObjectsUsingBlock: (OFDictionaryReplaceBlock)block
{
@try {
[_mapTable replaceObjectsUsingBlock:
^ void *(void *key, void *object) {
return block(key, object);
}];
} @catch (OFEnumerationMutationException *e) {
|
︙ | | | ︙ | |
Modified src/OFRunLoop+Private.h
from [d23b407299]
to [89b1324cc5].
︙ | | | ︙ | |
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
|
#ifdef OF_HAVE_SOCKETS
+ (void)of_addAsyncReadForStream: (OFStream <OFReadyForReadingObserving> *)
stream
buffer: (void *)buffer
length: (size_t)length
mode: (of_run_loop_mode_t)mode
# ifdef OF_HAVE_BLOCKS
block: (nullable of_stream_async_read_block_t)block
# endif
delegate: (nullable id <OFStreamDelegate>)delegate;
+ (void)of_addAsyncReadForStream: (OFStream <OFReadyForReadingObserving> *)
stream
buffer: (void *)buffer
exactLength: (size_t)length
mode: (of_run_loop_mode_t)mode
# ifdef OF_HAVE_BLOCKS
block: (nullable of_stream_async_read_block_t)block
# endif
delegate: (nullable id <OFStreamDelegate>)delegate;
+ (void)of_addAsyncReadLineForStream: (OFStream <OFReadyForReadingObserving> *)
stream
encoding: (OFStringEncoding)encoding
mode: (of_run_loop_mode_t)mode
# ifdef OF_HAVE_BLOCKS
block: (nullable
of_stream_async_read_line_block_t)
block
# endif
delegate: (nullable id <OFStreamDelegate>)delegate;
+ (void)of_addAsyncWriteForStream: (OFStream <OFReadyForWritingObserving> *)
stream
data: (OFData *)data
mode: (of_run_loop_mode_t)mode
# ifdef OF_HAVE_BLOCKS
block: (nullable of_stream_async_write_data_block_t)
block
# endif
delegate: (nullable id <OFStreamDelegate>)delegate;
+ (void)of_addAsyncWriteForStream: (OFStream <OFReadyForWritingObserving> *)
stream
string: (OFString *)string
encoding: (OFStringEncoding)encoding
mode: (of_run_loop_mode_t)mode
# ifdef OF_HAVE_BLOCKS
block: (nullable
of_stream_async_write_string_block_t)
block
# endif
delegate: (nullable id <OFStreamDelegate>)delegate;
# if !defined(OF_WII) && !defined(OF_NINTENDO_3DS)
+ (void)of_addAsyncConnectForSocket: (id)socket
mode: (of_run_loop_mode_t)mode
delegate: (id <OFRunLoopConnectDelegate>)delegate;
# endif
+ (void)of_addAsyncAcceptForSocket: (id)socket
mode: (of_run_loop_mode_t)mode
block: (nullable id)block
delegate: (nullable id)delegate;
+ (void)of_addAsyncReceiveForDatagramSocket: (OFDatagramSocket *)socket
buffer: (void *)buffer
length: (size_t)length
mode: (of_run_loop_mode_t)mode
# ifdef OF_HAVE_BLOCKS
block: (nullable of_datagram_socket_async_receive_block_t)block
# endif
delegate: (nullable id <OFDatagramSocketDelegate>) delegate;
+ (void)of_addAsyncSendForDatagramSocket: (OFDatagramSocket *)socket
data: (OFData *)data
receiver: (const of_socket_address_t *)receiver
mode: (of_run_loop_mode_t)mode
# ifdef OF_HAVE_BLOCKS
block: (nullable of_datagram_socket_async_send_data_block_t)block
# endif
delegate: (nullable id <OFDatagramSocketDelegate>)delegate;
+ (void)of_addAsyncReceiveForSequencedPacketSocket:
(OFSequencedPacketSocket *)socket
buffer: (void *)buffer
length: (size_t)length
mode: (of_run_loop_mode_t)mode
# ifdef OF_HAVE_BLOCKS
block: (nullable of_sequenced_packet_socket_async_receive_block_t)block
# endif
delegate: (nullable id <OFSequencedPacketSocketDelegate>) delegate;
+ (void)of_addAsyncSendForSequencedPacketSocket:
(OFSequencedPacketSocket *)socket
data: (OFData *)data
mode: (of_run_loop_mode_t)mode
# ifdef OF_HAVE_BLOCKS
block: (nullable of_sequenced_packet_socket_async_send_data_block_t)block
# endif
delegate: (nullable id <OFSequencedPacketSocketDelegate>)delegate;
+ (void)of_cancelAsyncRequestsForObject: (id)object
mode: (of_run_loop_mode_t)mode;
#endif
- (void)of_removeTimer: (OFTimer *)timer forMode: (of_run_loop_mode_t)mode;
@end
OF_ASSUME_NONNULL_END
|
|
|
|
<
<
|
<
|
<
<
|
|
|
|
|
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
|
#ifdef OF_HAVE_SOCKETS
+ (void)of_addAsyncReadForStream: (OFStream <OFReadyForReadingObserving> *)
stream
buffer: (void *)buffer
length: (size_t)length
mode: (of_run_loop_mode_t)mode
# ifdef OF_HAVE_BLOCKS
block: (nullable OFStreamAsyncReadBlock)block
# endif
delegate: (nullable id <OFStreamDelegate>)delegate;
+ (void)of_addAsyncReadForStream: (OFStream <OFReadyForReadingObserving> *)
stream
buffer: (void *)buffer
exactLength: (size_t)length
mode: (of_run_loop_mode_t)mode
# ifdef OF_HAVE_BLOCKS
block: (nullable OFStreamAsyncReadBlock)block
# endif
delegate: (nullable id <OFStreamDelegate>)delegate;
+ (void)of_addAsyncReadLineForStream: (OFStream <OFReadyForReadingObserving> *)
stream
encoding: (OFStringEncoding)encoding
mode: (of_run_loop_mode_t)mode
# ifdef OF_HAVE_BLOCKS
block: (nullable OFStreamAsyncReadLineBlock)block
# endif
delegate: (nullable id <OFStreamDelegate>)delegate;
+ (void)of_addAsyncWriteForStream: (OFStream <OFReadyForWritingObserving> *)
stream
data: (OFData *)data
mode: (of_run_loop_mode_t)mode
# ifdef OF_HAVE_BLOCKS
block: (nullable OFStreamAsyncWriteDataBlock)block
# endif
delegate: (nullable id <OFStreamDelegate>)delegate;
+ (void)of_addAsyncWriteForStream: (OFStream <OFReadyForWritingObserving> *)
stream
string: (OFString *)string
encoding: (OFStringEncoding)encoding
mode: (of_run_loop_mode_t)mode
# ifdef OF_HAVE_BLOCKS
block: (nullable OFStreamAsyncWriteStringBlock)block
# endif
delegate: (nullable id <OFStreamDelegate>)delegate;
# if !defined(OF_WII) && !defined(OF_NINTENDO_3DS)
+ (void)of_addAsyncConnectForSocket: (id)socket
mode: (of_run_loop_mode_t)mode
delegate: (id <OFRunLoopConnectDelegate>)delegate;
# endif
+ (void)of_addAsyncAcceptForSocket: (id)socket
mode: (of_run_loop_mode_t)mode
block: (nullable id)block
delegate: (nullable id)delegate;
+ (void)of_addAsyncReceiveForDatagramSocket: (OFDatagramSocket *)socket
buffer: (void *)buffer
length: (size_t)length
mode: (of_run_loop_mode_t)mode
# ifdef OF_HAVE_BLOCKS
block: (nullable OFDatagramSocketAsyncReceiveBlock)block
# endif
delegate: (nullable id <OFDatagramSocketDelegate>) delegate;
+ (void)of_addAsyncSendForDatagramSocket: (OFDatagramSocket *)socket
data: (OFData *)data
receiver: (const of_socket_address_t *)receiver
mode: (of_run_loop_mode_t)mode
# ifdef OF_HAVE_BLOCKS
block: (nullable OFDatagramSocketAsyncSendDataBlock)block
# endif
delegate: (nullable id <OFDatagramSocketDelegate>)delegate;
+ (void)of_addAsyncReceiveForSequencedPacketSocket:
(OFSequencedPacketSocket *)socket
buffer: (void *)buffer
length: (size_t)length
mode: (of_run_loop_mode_t)mode
# ifdef OF_HAVE_BLOCKS
block: (nullable OFSequencedPacketSocketAsyncReceiveBlock)block
# endif
delegate: (nullable id <OFSequencedPacketSocketDelegate>) delegate;
+ (void)of_addAsyncSendForSequencedPacketSocket:
(OFSequencedPacketSocket *)socket
data: (OFData *)data
mode: (of_run_loop_mode_t)mode
# ifdef OF_HAVE_BLOCKS
block: (nullable OFSequencedPacketSocketAsyncSendDataBlock)block
# endif
delegate: (nullable id <OFSequencedPacketSocketDelegate>)delegate;
+ (void)of_cancelAsyncRequestsForObject: (id)object
mode: (of_run_loop_mode_t)mode;
#endif
- (void)of_removeTimer: (OFTimer *)timer forMode: (of_run_loop_mode_t)mode;
@end
OF_ASSUME_NONNULL_END
|
Modified src/OFRunLoop.m
from [01753453f7]
to [2f8a16c7ba].
︙ | | | ︙ | |
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
|
- (bool)handleObject: (id)object;
@end
@interface OFRunLoopReadQueueItem: OFRunLoopQueueItem
{
@public
# ifdef OF_HAVE_BLOCKS
of_stream_async_read_block_t _block;
# endif
void *_buffer;
size_t _length;
}
@end
@interface OFRunLoopExactReadQueueItem: OFRunLoopQueueItem
{
@public
# ifdef OF_HAVE_BLOCKS
of_stream_async_read_block_t _block;
# endif
void *_buffer;
size_t _exactLength, _readLength;
}
@end
@interface OFRunLoopReadLineQueueItem: OFRunLoopQueueItem
{
@public
# ifdef OF_HAVE_BLOCKS
of_stream_async_read_line_block_t _block;
# endif
OFStringEncoding _encoding;
}
@end
@interface OFRunLoopWriteDataQueueItem: OFRunLoopQueueItem
{
@public
# ifdef OF_HAVE_BLOCKS
of_stream_async_write_data_block_t _block;
# endif
OFData *_data;
size_t _writtenLength;
}
@end
@interface OFRunLoopWriteStringQueueItem: OFRunLoopQueueItem
{
@public
# ifdef OF_HAVE_BLOCKS
of_stream_async_write_string_block_t _block;
# endif
OFString *_string;
OFStringEncoding _encoding;
size_t _writtenLength;
}
@end
|
|
|
|
|
|
|
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
|
- (bool)handleObject: (id)object;
@end
@interface OFRunLoopReadQueueItem: OFRunLoopQueueItem
{
@public
# ifdef OF_HAVE_BLOCKS
OFStreamAsyncReadBlock _block;
# endif
void *_buffer;
size_t _length;
}
@end
@interface OFRunLoopExactReadQueueItem: OFRunLoopQueueItem
{
@public
# ifdef OF_HAVE_BLOCKS
OFStreamAsyncReadBlock _block;
# endif
void *_buffer;
size_t _exactLength, _readLength;
}
@end
@interface OFRunLoopReadLineQueueItem: OFRunLoopQueueItem
{
@public
# ifdef OF_HAVE_BLOCKS
OFStreamAsyncReadLineBlock _block;
# endif
OFStringEncoding _encoding;
}
@end
@interface OFRunLoopWriteDataQueueItem: OFRunLoopQueueItem
{
@public
# ifdef OF_HAVE_BLOCKS
OFStreamAsyncWriteDataBlock _block;
# endif
OFData *_data;
size_t _writtenLength;
}
@end
@interface OFRunLoopWriteStringQueueItem: OFRunLoopQueueItem
{
@public
# ifdef OF_HAVE_BLOCKS
OFStreamAsyncWriteStringBlock _block;
# endif
OFString *_string;
OFStringEncoding _encoding;
size_t _writtenLength;
}
@end
|
︙ | | | ︙ | |
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
|
}
@end
@interface OFRunLoopDatagramReceiveQueueItem: OFRunLoopQueueItem
{
@public
# ifdef OF_HAVE_BLOCKS
of_datagram_socket_async_receive_block_t _block;
# endif
void *_buffer;
size_t _length;
}
@end
@interface OFRunLoopDatagramSendQueueItem: OFRunLoopQueueItem
{
@public
# ifdef OF_HAVE_BLOCKS
of_datagram_socket_async_send_data_block_t _block;
# endif
OFData *_data;
of_socket_address_t _receiver;
}
@end
@interface OFRunLoopPacketReceiveQueueItem: OFRunLoopQueueItem
{
@public
# ifdef OF_HAVE_BLOCKS
of_sequenced_packet_socket_async_receive_block_t _block;
# endif
void *_buffer;
size_t _length;
}
@end
@interface OFRunLoopPacketSendQueueItem: OFRunLoopQueueItem
{
@public
# ifdef OF_HAVE_BLOCKS
of_sequenced_packet_socket_async_send_data_block_t _block;
# endif
OFData *_data;
}
@end
#endif
@implementation OFRunLoopState
|
|
|
|
|
|
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
|
}
@end
@interface OFRunLoopDatagramReceiveQueueItem: OFRunLoopQueueItem
{
@public
# ifdef OF_HAVE_BLOCKS
OFDatagramSocketAsyncReceiveBlock _block;
# endif
void *_buffer;
size_t _length;
}
@end
@interface OFRunLoopDatagramSendQueueItem: OFRunLoopQueueItem
{
@public
# ifdef OF_HAVE_BLOCKS
OFDatagramSocketAsyncSendDataBlock _block;
# endif
OFData *_data;
of_socket_address_t _receiver;
}
@end
@interface OFRunLoopPacketReceiveQueueItem: OFRunLoopQueueItem
{
@public
# ifdef OF_HAVE_BLOCKS
OFSequencedPacketSocketAsyncReceiveBlock _block;
# endif
void *_buffer;
size_t _length;
}
@end
@interface OFRunLoopPacketSendQueueItem: OFRunLoopQueueItem
{
@public
# ifdef OF_HAVE_BLOCKS
OFSequencedPacketSocketAsyncSendDataBlock _block;
# endif
OFData *_data;
}
@end
#endif
@implementation OFRunLoopState
|
︙ | | | ︙ | |
750
751
752
753
754
755
756
757
758
759
760
761
762
763
764
765
766
767
768
769
|
acceptedSocket = nil;
exception = e;
}
# ifdef OF_HAVE_BLOCKS
if (_block != NULL) {
if ([object isKindOfClass: [OFStreamSocket class]])
return ((of_stream_socket_async_accept_block_t)
_block)(acceptedSocket, exception);
else if ([object isKindOfClass:
[OFSequencedPacketSocket class]])
return
((of_sequenced_packet_socket_async_accept_block_t)
_block)(acceptedSocket, exception);
else
OF_ENSURE(0);
} else {
# endif
if (![_delegate respondsToSelector:
@selector(socket:didAcceptSocket:exception:)])
|
|
|
|
<
|
750
751
752
753
754
755
756
757
758
759
760
761
762
763
764
765
766
767
768
|
acceptedSocket = nil;
exception = e;
}
# ifdef OF_HAVE_BLOCKS
if (_block != NULL) {
if ([object isKindOfClass: [OFStreamSocket class]])
return ((OFStreamSocketAsyncAcceptBlock)_block)(
acceptedSocket, exception);
else if ([object isKindOfClass:
[OFSequencedPacketSocket class]])
return ((OFSequencedPacketSocketAsyncAcceptBlock)
_block)(acceptedSocket, exception);
else
OF_ENSURE(0);
} else {
# endif
if (![_delegate respondsToSelector:
@selector(socket:didAcceptSocket:exception:)])
|
︙ | | | ︙ | |
1086
1087
1088
1089
1090
1091
1092
1093
1094
1095
1096
1097
1098
1099
1100
|
+ (void)of_addAsyncReadForStream: (OFStream <OFReadyForReadingObserving> *)
stream
buffer: (void *)buffer
length: (size_t)length
mode: (of_run_loop_mode_t)mode
# ifdef OF_HAVE_BLOCKS
block: (of_stream_async_read_block_t)block
# endif
delegate: (id <OFStreamDelegate>)delegate
{
NEW_READ(OFRunLoopReadQueueItem, stream, mode)
queueItem->_delegate = [delegate retain];
# ifdef OF_HAVE_BLOCKS
|
|
|
1085
1086
1087
1088
1089
1090
1091
1092
1093
1094
1095
1096
1097
1098
1099
|
+ (void)of_addAsyncReadForStream: (OFStream <OFReadyForReadingObserving> *)
stream
buffer: (void *)buffer
length: (size_t)length
mode: (of_run_loop_mode_t)mode
# ifdef OF_HAVE_BLOCKS
block: (OFStreamAsyncReadBlock)block
# endif
delegate: (id <OFStreamDelegate>)delegate
{
NEW_READ(OFRunLoopReadQueueItem, stream, mode)
queueItem->_delegate = [delegate retain];
# ifdef OF_HAVE_BLOCKS
|
︙ | | | ︙ | |
1108
1109
1110
1111
1112
1113
1114
1115
1116
1117
1118
1119
1120
1121
1122
1123
1124
1125
1126
1127
1128
1129
1130
1131
1132
1133
1134
1135
1136
1137
1138
1139
1140
1141
1142
1143
1144
1145
1146
1147
1148
1149
1150
1151
1152
1153
1154
1155
1156
1157
1158
1159
1160
1161
1162
1163
1164
1165
1166
1167
1168
1169
1170
1171
1172
1173
1174
1175
1176
1177
1178
1179
1180
1181
1182
1183
1184
|
+ (void)of_addAsyncReadForStream: (OFStream <OFReadyForReadingObserving> *)
stream
buffer: (void *)buffer
exactLength: (size_t)exactLength
mode: (of_run_loop_mode_t)mode
# ifdef OF_HAVE_BLOCKS
block: (of_stream_async_read_block_t)block
# endif
delegate: (id <OFStreamDelegate>)delegate
{
NEW_READ(OFRunLoopExactReadQueueItem, stream, mode)
queueItem->_delegate = [delegate retain];
# ifdef OF_HAVE_BLOCKS
queueItem->_block = [block copy];
# endif
queueItem->_buffer = buffer;
queueItem->_exactLength = exactLength;
QUEUE_ITEM
}
+ (void)of_addAsyncReadLineForStream: (OFStream <OFReadyForReadingObserving> *)
stream
encoding: (OFStringEncoding)encoding
mode: (of_run_loop_mode_t)mode
# ifdef OF_HAVE_BLOCKS
block: (of_stream_async_read_line_block_t)block
# endif
delegate: (id <OFStreamDelegate>)delegate
{
NEW_READ(OFRunLoopReadLineQueueItem, stream, mode)
queueItem->_delegate = [delegate retain];
# ifdef OF_HAVE_BLOCKS
queueItem->_block = [block copy];
# endif
queueItem->_encoding = encoding;
QUEUE_ITEM
}
+ (void)of_addAsyncWriteForStream: (OFStream <OFReadyForWritingObserving> *)
stream
data: (OFData *)data
mode: (of_run_loop_mode_t)mode
# ifdef OF_HAVE_BLOCKS
block: (of_stream_async_write_data_block_t)block
# endif
delegate: (id <OFStreamDelegate>)delegate
{
NEW_WRITE(OFRunLoopWriteDataQueueItem, stream, mode)
queueItem->_delegate = [delegate retain];
# ifdef OF_HAVE_BLOCKS
queueItem->_block = [block copy];
# endif
queueItem->_data = [data copy];
QUEUE_ITEM
}
+ (void)of_addAsyncWriteForStream: (OFStream <OFReadyForWritingObserving> *)
stream
string: (OFString *)string
encoding: (OFStringEncoding)encoding
mode: (of_run_loop_mode_t)mode
# ifdef OF_HAVE_BLOCKS
block: (of_stream_async_write_string_block_t)block
# endif
delegate: (id <OFStreamDelegate>)delegate
{
NEW_WRITE(OFRunLoopWriteStringQueueItem, stream, mode)
queueItem->_delegate = [delegate retain];
# ifdef OF_HAVE_BLOCKS
|
|
|
|
|
|
1107
1108
1109
1110
1111
1112
1113
1114
1115
1116
1117
1118
1119
1120
1121
1122
1123
1124
1125
1126
1127
1128
1129
1130
1131
1132
1133
1134
1135
1136
1137
1138
1139
1140
1141
1142
1143
1144
1145
1146
1147
1148
1149
1150
1151
1152
1153
1154
1155
1156
1157
1158
1159
1160
1161
1162
1163
1164
1165
1166
1167
1168
1169
1170
1171
1172
1173
1174
1175
1176
1177
1178
1179
1180
1181
1182
1183
|
+ (void)of_addAsyncReadForStream: (OFStream <OFReadyForReadingObserving> *)
stream
buffer: (void *)buffer
exactLength: (size_t)exactLength
mode: (of_run_loop_mode_t)mode
# ifdef OF_HAVE_BLOCKS
block: (OFStreamAsyncReadBlock)block
# endif
delegate: (id <OFStreamDelegate>)delegate
{
NEW_READ(OFRunLoopExactReadQueueItem, stream, mode)
queueItem->_delegate = [delegate retain];
# ifdef OF_HAVE_BLOCKS
queueItem->_block = [block copy];
# endif
queueItem->_buffer = buffer;
queueItem->_exactLength = exactLength;
QUEUE_ITEM
}
+ (void)of_addAsyncReadLineForStream: (OFStream <OFReadyForReadingObserving> *)
stream
encoding: (OFStringEncoding)encoding
mode: (of_run_loop_mode_t)mode
# ifdef OF_HAVE_BLOCKS
block: (OFStreamAsyncReadLineBlock)block
# endif
delegate: (id <OFStreamDelegate>)delegate
{
NEW_READ(OFRunLoopReadLineQueueItem, stream, mode)
queueItem->_delegate = [delegate retain];
# ifdef OF_HAVE_BLOCKS
queueItem->_block = [block copy];
# endif
queueItem->_encoding = encoding;
QUEUE_ITEM
}
+ (void)of_addAsyncWriteForStream: (OFStream <OFReadyForWritingObserving> *)
stream
data: (OFData *)data
mode: (of_run_loop_mode_t)mode
# ifdef OF_HAVE_BLOCKS
block: (OFStreamAsyncWriteDataBlock)block
# endif
delegate: (id <OFStreamDelegate>)delegate
{
NEW_WRITE(OFRunLoopWriteDataQueueItem, stream, mode)
queueItem->_delegate = [delegate retain];
# ifdef OF_HAVE_BLOCKS
queueItem->_block = [block copy];
# endif
queueItem->_data = [data copy];
QUEUE_ITEM
}
+ (void)of_addAsyncWriteForStream: (OFStream <OFReadyForWritingObserving> *)
stream
string: (OFString *)string
encoding: (OFStringEncoding)encoding
mode: (of_run_loop_mode_t)mode
# ifdef OF_HAVE_BLOCKS
block: (OFStreamAsyncWriteStringBlock)block
# endif
delegate: (id <OFStreamDelegate>)delegate
{
NEW_WRITE(OFRunLoopWriteStringQueueItem, stream, mode)
queueItem->_delegate = [delegate retain];
# ifdef OF_HAVE_BLOCKS
|
︙ | | | ︙ | |
1219
1220
1221
1222
1223
1224
1225
1226
1227
1228
1229
1230
1231
1232
1233
1234
1235
1236
1237
1238
1239
1240
1241
1242
1243
1244
1245
1246
1247
1248
1249
1250
1251
1252
1253
1254
|
}
+ (void)of_addAsyncReceiveForDatagramSocket: (OFDatagramSocket *)sock
buffer: (void *)buffer
length: (size_t)length
mode: (of_run_loop_mode_t)mode
# ifdef OF_HAVE_BLOCKS
block: (of_datagram_socket_async_receive_block_t)block
# endif
delegate: (id <OFDatagramSocketDelegate>)delegate
{
NEW_READ(OFRunLoopDatagramReceiveQueueItem, sock, mode)
queueItem->_delegate = [delegate retain];
# ifdef OF_HAVE_BLOCKS
queueItem->_block = [block copy];
# endif
queueItem->_buffer = buffer;
queueItem->_length = length;
QUEUE_ITEM
}
+ (void)of_addAsyncSendForDatagramSocket: (OFDatagramSocket *)sock
data: (OFData *)data
receiver: (const of_socket_address_t *)receiver
mode: (of_run_loop_mode_t)mode
# ifdef OF_HAVE_BLOCKS
block: (of_datagram_socket_async_send_data_block_t)block
# endif
delegate: (id <OFDatagramSocketDelegate>)delegate
{
NEW_WRITE(OFRunLoopDatagramSendQueueItem, sock, mode)
queueItem->_delegate = [delegate retain];
# ifdef OF_HAVE_BLOCKS
|
|
|
|
1218
1219
1220
1221
1222
1223
1224
1225
1226
1227
1228
1229
1230
1231
1232
1233
1234
1235
1236
1237
1238
1239
1240
1241
1242
1243
1244
1245
1246
1247
1248
1249
1250
1251
1252
1253
|
}
+ (void)of_addAsyncReceiveForDatagramSocket: (OFDatagramSocket *)sock
buffer: (void *)buffer
length: (size_t)length
mode: (of_run_loop_mode_t)mode
# ifdef OF_HAVE_BLOCKS
block: (OFDatagramSocketAsyncReceiveBlock)block
# endif
delegate: (id <OFDatagramSocketDelegate>)delegate
{
NEW_READ(OFRunLoopDatagramReceiveQueueItem, sock, mode)
queueItem->_delegate = [delegate retain];
# ifdef OF_HAVE_BLOCKS
queueItem->_block = [block copy];
# endif
queueItem->_buffer = buffer;
queueItem->_length = length;
QUEUE_ITEM
}
+ (void)of_addAsyncSendForDatagramSocket: (OFDatagramSocket *)sock
data: (OFData *)data
receiver: (const of_socket_address_t *)receiver
mode: (of_run_loop_mode_t)mode
# ifdef OF_HAVE_BLOCKS
block: (OFDatagramSocketAsyncSendDataBlock)block
# endif
delegate: (id <OFDatagramSocketDelegate>)delegate
{
NEW_WRITE(OFRunLoopDatagramSendQueueItem, sock, mode)
queueItem->_delegate = [delegate retain];
# ifdef OF_HAVE_BLOCKS
|
︙ | | | ︙ | |
1262
1263
1264
1265
1266
1267
1268
1269
1270
1271
1272
1273
1274
1275
1276
1277
1278
1279
1280
1281
1282
1283
1284
1285
1286
1287
1288
1289
1290
1291
1292
1293
1294
1295
1296
|
+ (void)of_addAsyncReceiveForSequencedPacketSocket: (OFSequencedPacketSocket *)
sock
buffer: (void *)buffer
length: (size_t)length
mode: (of_run_loop_mode_t)mode
# ifdef OF_HAVE_BLOCKS
block: (of_sequenced_packet_socket_async_receive_block_t)block
# endif
delegate: (id <OFSequencedPacketSocketDelegate>)delegate
{
NEW_READ(OFRunLoopPacketReceiveQueueItem, sock, mode)
queueItem->_delegate = [delegate retain];
# ifdef OF_HAVE_BLOCKS
queueItem->_block = [block copy];
# endif
queueItem->_buffer = buffer;
queueItem->_length = length;
QUEUE_ITEM
}
+ (void)of_addAsyncSendForSequencedPacketSocket: (OFSequencedPacketSocket *)sock
data: (OFData *)data
mode: (of_run_loop_mode_t)mode
# ifdef OF_HAVE_BLOCKS
block: (of_sequenced_packet_socket_async_send_data_block_t)block
# endif
delegate: (id <OFSequencedPacketSocketDelegate>)delegate
{
NEW_WRITE(OFRunLoopPacketSendQueueItem, sock, mode)
queueItem->_delegate = [delegate retain];
# ifdef OF_HAVE_BLOCKS
|
|
|
|
1261
1262
1263
1264
1265
1266
1267
1268
1269
1270
1271
1272
1273
1274
1275
1276
1277
1278
1279
1280
1281
1282
1283
1284
1285
1286
1287
1288
1289
1290
1291
1292
1293
1294
1295
|
+ (void)of_addAsyncReceiveForSequencedPacketSocket: (OFSequencedPacketSocket *)
sock
buffer: (void *)buffer
length: (size_t)length
mode: (of_run_loop_mode_t)mode
# ifdef OF_HAVE_BLOCKS
block: (OFSequencedPacketSocketAsyncReceiveBlock)block
# endif
delegate: (id <OFSequencedPacketSocketDelegate>)delegate
{
NEW_READ(OFRunLoopPacketReceiveQueueItem, sock, mode)
queueItem->_delegate = [delegate retain];
# ifdef OF_HAVE_BLOCKS
queueItem->_block = [block copy];
# endif
queueItem->_buffer = buffer;
queueItem->_length = length;
QUEUE_ITEM
}
+ (void)of_addAsyncSendForSequencedPacketSocket: (OFSequencedPacketSocket *)sock
data: (OFData *)data
mode: (of_run_loop_mode_t)mode
# ifdef OF_HAVE_BLOCKS
block: (OFSequencedPacketSocketAsyncSendDataBlock)block
# endif
delegate: (id <OFSequencedPacketSocketDelegate>)delegate
{
NEW_WRITE(OFRunLoopPacketSendQueueItem, sock, mode)
queueItem->_delegate = [delegate retain];
# ifdef OF_HAVE_BLOCKS
|
︙ | | | ︙ | |
Modified src/OFSPXSocket.h
from [20d64f5e49]
to [d205a758d4].
︙ | | | ︙ | |
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
|
#ifdef OF_HAVE_BLOCKS
/**
* @brief A block which is called when the socket connected.
*
* @param exception An exception which occurred while connecting the socket or
* `nil` on success
*/
typedef void (^of_spx_socket_async_connect_block_t)(id _Nullable exception);
#endif
/**
* @protocol OFSPXSocketDelegate OFSPXSocket.h ObjFW/OFSPXSocket.h
*
* A delegate for OFSPXSocket.
*/
|
|
|
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
|
#ifdef OF_HAVE_BLOCKS
/**
* @brief A block which is called when the socket connected.
*
* @param exception An exception which occurred while connecting the socket or
* `nil` on success
*/
typedef void (^OFSPXSocketAsyncConnectBlock)(id _Nullable exception);
#endif
/**
* @protocol OFSPXSocketDelegate OFSPXSocket.h ObjFW/OFSPXSocket.h
*
* A delegate for OFSPXSocket.
*/
|
︙ | | | ︙ | |
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
|
* @param port The port (sometimes also called socket number) on the node to
* connect to
* @param block The block to execute once the connection has been established
*/
- (void)asyncConnectToNode: (unsigned char [_Nonnull IPX_NODE_LEN])node
network: (uint32_t)network
port: (uint16_t)port
block: (of_spx_socket_async_connect_block_t)block;
/**
* @brief Asynchronously connect the OFSPXSocket to the specified destination.
*
* @param node The node to connect to
* @param network The network on which the node to connect to is
* @param port The port (sometimes also called socket number) on the node to
* connect to
* @param runLoopMode The run loop mode in which to perform the async connect
* @param block The block to execute once the connection has been established
*/
- (void)asyncConnectToNode: (unsigned char [_Nonnull IPX_NODE_LEN])node
network: (uint32_t)network
port: (uint16_t)port
runLoopMode: (of_run_loop_mode_t)runLoopMode
block: (of_spx_socket_async_connect_block_t)block;
#endif
/**
* @brief Bind the socket to the specified network, node and port.
*
* @param port The port (sometimes called socket number) to bind to. 0 means to
* pick one and return it.
* @return The address on which this socket can be reached
*/
- (of_socket_address_t)bindToPort: (uint16_t)port;
@end
OF_ASSUME_NONNULL_END
|
|
|
|
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
|
* @param port The port (sometimes also called socket number) on the node to
* connect to
* @param block The block to execute once the connection has been established
*/
- (void)asyncConnectToNode: (unsigned char [_Nonnull IPX_NODE_LEN])node
network: (uint32_t)network
port: (uint16_t)port
block: (OFSPXSocketAsyncConnectBlock)block;
/**
* @brief Asynchronously connect the OFSPXSocket to the specified destination.
*
* @param node The node to connect to
* @param network The network on which the node to connect to is
* @param port The port (sometimes also called socket number) on the node to
* connect to
* @param runLoopMode The run loop mode in which to perform the async connect
* @param block The block to execute once the connection has been established
*/
- (void)asyncConnectToNode: (unsigned char [_Nonnull IPX_NODE_LEN])node
network: (uint32_t)network
port: (uint16_t)port
runLoopMode: (of_run_loop_mode_t)runLoopMode
block: (OFSPXSocketAsyncConnectBlock)block;
#endif
/**
* @brief Bind the socket to the specified network, node and port.
*
* @param port The port (sometimes called socket number) to bind to. 0 means to
* pick one and return it.
* @return The address on which this socket can be reached
*/
- (of_socket_address_t)bindToPort: (uint16_t)port;
@end
OF_ASSUME_NONNULL_END
|
Modified src/OFSPXSocket.m
from [852f3cc78c]
to [d8020c8aee].
︙ | | | ︙ | |
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
|
@interface OFSPXSocketAsyncConnectDelegate: OFObject <OFRunLoopConnectDelegate>
{
OFSPXSocket *_socket;
unsigned char _node[IPX_NODE_LEN];
uint32_t _network;
uint16_t _port;
#ifdef OF_HAVE_BLOCKS
of_spx_socket_async_connect_block_t _block;
#endif
}
- (instancetype)initWithSocket: (OFSPXSocket *)socket
node: (unsigned char [IPX_NODE_LEN])node
network: (uint32_t)network
port: (uint16_t)port
#ifdef OF_HAVE_BLOCKS
block: (of_spx_socket_async_connect_block_t)block
#endif
;
- (void)startWithRunLoopMode: (of_run_loop_mode_t)runLoopMode;
@end
@implementation OFSPXSocketAsyncConnectDelegate
- (instancetype)initWithSocket: (OFSPXSocket *)sock
node: (unsigned char [IPX_NODE_LEN])node
network: (uint32_t)network
port: (uint16_t)port
#ifdef OF_HAVE_BLOCKS
block: (of_spx_socket_async_connect_block_t)block
#endif
{
self = [super init];
@try {
_socket = [sock retain];
memcpy(_node, node, IPX_NODE_LEN);
|
|
|
|
|
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
|
@interface OFSPXSocketAsyncConnectDelegate: OFObject <OFRunLoopConnectDelegate>
{
OFSPXSocket *_socket;
unsigned char _node[IPX_NODE_LEN];
uint32_t _network;
uint16_t _port;
#ifdef OF_HAVE_BLOCKS
OFSPXSocketAsyncConnectBlock _block;
#endif
}
- (instancetype)initWithSocket: (OFSPXSocket *)socket
node: (unsigned char [IPX_NODE_LEN])node
network: (uint32_t)network
port: (uint16_t)port
#ifdef OF_HAVE_BLOCKS
block: (OFSPXSocketAsyncConnectBlock)block
#endif
;
- (void)startWithRunLoopMode: (of_run_loop_mode_t)runLoopMode;
@end
@implementation OFSPXSocketAsyncConnectDelegate
- (instancetype)initWithSocket: (OFSPXSocket *)sock
node: (unsigned char [IPX_NODE_LEN])node
network: (uint32_t)network
port: (uint16_t)port
#ifdef OF_HAVE_BLOCKS
block: (OFSPXSocketAsyncConnectBlock)block
#endif
{
self = [super init];
@try {
_socket = [sock retain];
memcpy(_node, node, IPX_NODE_LEN);
|
︙ | | | ︙ | |
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
|
objc_autoreleasePoolPop(pool);
}
#ifdef OF_HAVE_BLOCKS
- (void)asyncConnectToNode: (unsigned char [_Nonnull IPX_NODE_LEN])node
network: (uint32_t)network
port: (uint16_t)port
block: (of_spx_socket_async_connect_block_t)block
{
[self asyncConnectToNode: node
network: network
port: port
runLoopMode: of_run_loop_mode_default
block: block];
}
- (void)asyncConnectToNode: (unsigned char [_Nonnull IPX_NODE_LEN])node
network: (uint32_t)network
port: (uint16_t)port
runLoopMode: (of_run_loop_mode_t)runLoopMode
block: (of_spx_socket_async_connect_block_t)block
{
void *pool = objc_autoreleasePoolPush();
[[[[OFSPXSocketAsyncConnectDelegate alloc]
initWithSocket: self
node: node
network: network
|
|
|
|
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
|
objc_autoreleasePoolPop(pool);
}
#ifdef OF_HAVE_BLOCKS
- (void)asyncConnectToNode: (unsigned char [_Nonnull IPX_NODE_LEN])node
network: (uint32_t)network
port: (uint16_t)port
block: (OFSPXSocketAsyncConnectBlock)block
{
[self asyncConnectToNode: node
network: network
port: port
runLoopMode: of_run_loop_mode_default
block: block];
}
- (void)asyncConnectToNode: (unsigned char [_Nonnull IPX_NODE_LEN])node
network: (uint32_t)network
port: (uint16_t)port
runLoopMode: (of_run_loop_mode_t)runLoopMode
block: (OFSPXSocketAsyncConnectBlock)block
{
void *pool = objc_autoreleasePoolPush();
[[[[OFSPXSocketAsyncConnectDelegate alloc]
initWithSocket: self
node: node
network: network
|
︙ | | | ︙ | |
Modified src/OFSPXStreamSocket.h
from [9b835a4c0b]
to [c485257223].
︙ | | | ︙ | |
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
|
#ifdef OF_HAVE_BLOCKS
/**
* @brief A block which is called when the socket connected.
*
* @param exception An exception which occurred while connecting the socket or
* `nil` on success
*/
typedef void (^of_spx_stream_socket_async_connect_block_t)(
id _Nullable exception);
#endif
/**
* @protocol OFSPXStreamSocketDelegate OFSPXStreamSocket.h \
* ObjFW/OFSPXStreamSocket.h
*
* A delegate for OFSPXStreamSocket.
|
<
|
|
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
|
#ifdef OF_HAVE_BLOCKS
/**
* @brief A block which is called when the socket connected.
*
* @param exception An exception which occurred while connecting the socket or
* `nil` on success
*/
typedef void (^OFSPXStreamSocketAsyncConnectBlock)(id _Nullable exception);
#endif
/**
* @protocol OFSPXStreamSocketDelegate OFSPXStreamSocket.h \
* ObjFW/OFSPXStreamSocket.h
*
* A delegate for OFSPXStreamSocket.
|
︙ | | | ︙ | |
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
|
* @param port The port (sometimes also called socket number) on the node to
* connect to
* @param block The block to execute once the connection has been established
*/
- (void)asyncConnectToNode: (unsigned char [_Nonnull IPX_NODE_LEN])node
network: (uint32_t)network
port: (uint16_t)port
block: (of_spx_stream_socket_async_connect_block_t)block;
/**
* @brief Asynchronously connect the OFSPXStreamSocket to the specified
* destination.
*
* @param node The node to connect to
* @param network The network on which the node to connect to is
* @param port The port (sometimes also called socket number) on the node to
* connect to
* @param runLoopMode The run loop mode in which to perform the async connect
* @param block The block to execute once the connection has been established
*/
- (void)asyncConnectToNode: (unsigned char [_Nonnull IPX_NODE_LEN])node
network: (uint32_t)network
port: (uint16_t)port
runLoopMode: (of_run_loop_mode_t)runLoopMode
block: (of_spx_stream_socket_async_connect_block_t)block;
#endif
/**
* @brief Bind the socket to the specified network, node and port.
*
* @param port The port (sometimes called socket number) to bind to. 0 means to
* pick one and return it.
* @return The address on which this socket can be reached
*/
- (of_socket_address_t)bindToPort: (uint16_t)port;
@end
OF_ASSUME_NONNULL_END
|
|
|
|
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
|
* @param port The port (sometimes also called socket number) on the node to
* connect to
* @param block The block to execute once the connection has been established
*/
- (void)asyncConnectToNode: (unsigned char [_Nonnull IPX_NODE_LEN])node
network: (uint32_t)network
port: (uint16_t)port
block: (OFSPXStreamSocketAsyncConnectBlock)block;
/**
* @brief Asynchronously connect the OFSPXStreamSocket to the specified
* destination.
*
* @param node The node to connect to
* @param network The network on which the node to connect to is
* @param port The port (sometimes also called socket number) on the node to
* connect to
* @param runLoopMode The run loop mode in which to perform the async connect
* @param block The block to execute once the connection has been established
*/
- (void)asyncConnectToNode: (unsigned char [_Nonnull IPX_NODE_LEN])node
network: (uint32_t)network
port: (uint16_t)port
runLoopMode: (of_run_loop_mode_t)runLoopMode
block: (OFSPXStreamSocketAsyncConnectBlock)block;
#endif
/**
* @brief Bind the socket to the specified network, node and port.
*
* @param port The port (sometimes called socket number) to bind to. 0 means to
* pick one and return it.
* @return The address on which this socket can be reached
*/
- (of_socket_address_t)bindToPort: (uint16_t)port;
@end
OF_ASSUME_NONNULL_END
|
Modified src/OFSPXStreamSocket.m
from [759cabd824]
to [4ad7503fd3].
︙ | | | ︙ | |
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
|
<OFRunLoopConnectDelegate>
{
OFSPXStreamSocket *_socket;
unsigned char _node[IPX_NODE_LEN];
uint32_t _network;
uint16_t _port;
#ifdef OF_HAVE_BLOCKS
of_spx_stream_socket_async_connect_block_t _block;
#endif
}
- (instancetype)initWithSocket: (OFSPXStreamSocket *)socket
node: (unsigned char [IPX_NODE_LEN])node
network: (uint32_t)network
port: (uint16_t)port
#ifdef OF_HAVE_BLOCKS
block: (of_spx_stream_socket_async_connect_block_t)
block
#endif
;
- (void)startWithRunLoopMode: (of_run_loop_mode_t)runLoopMode;
@end
@implementation OFSPXStreamSocketAsyncConnectDelegate
- (instancetype)initWithSocket: (OFSPXStreamSocket *)sock
node: (unsigned char [IPX_NODE_LEN])node
network: (uint32_t)network
port: (uint16_t)port
#ifdef OF_HAVE_BLOCKS
block: (of_spx_stream_socket_async_connect_block_t)
block
#endif
{
self = [super init];
@try {
_socket = [sock retain];
memcpy(_node, node, IPX_NODE_LEN);
|
|
<
|
<
|
|
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
|
<OFRunLoopConnectDelegate>
{
OFSPXStreamSocket *_socket;
unsigned char _node[IPX_NODE_LEN];
uint32_t _network;
uint16_t _port;
#ifdef OF_HAVE_BLOCKS
OFSPXStreamSocketAsyncConnectBlock _block;
#endif
}
- (instancetype)initWithSocket: (OFSPXStreamSocket *)socket
node: (unsigned char [IPX_NODE_LEN])node
network: (uint32_t)network
port: (uint16_t)port
#ifdef OF_HAVE_BLOCKS
block: (OFSPXStreamSocketAsyncConnectBlock)block
#endif
;
- (void)startWithRunLoopMode: (of_run_loop_mode_t)runLoopMode;
@end
@implementation OFSPXStreamSocketAsyncConnectDelegate
- (instancetype)initWithSocket: (OFSPXStreamSocket *)sock
node: (unsigned char [IPX_NODE_LEN])node
network: (uint32_t)network
port: (uint16_t)port
#ifdef OF_HAVE_BLOCKS
block: (OFSPXStreamSocketAsyncConnectBlock)block
#endif
{
self = [super init];
@try {
_socket = [sock retain];
memcpy(_node, node, IPX_NODE_LEN);
|
︙ | | | ︙ | |
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
|
objc_autoreleasePoolPop(pool);
}
#ifdef OF_HAVE_BLOCKS
- (void)asyncConnectToNode: (unsigned char [_Nonnull IPX_NODE_LEN])node
network: (uint32_t)network
port: (uint16_t)port
block: (of_spx_stream_socket_async_connect_block_t)block
{
[self asyncConnectToNode: node
network: network
port: port
runLoopMode: of_run_loop_mode_default
block: block];
}
- (void)asyncConnectToNode: (unsigned char [_Nonnull IPX_NODE_LEN])node
network: (uint32_t)network
port: (uint16_t)port
runLoopMode: (of_run_loop_mode_t)runLoopMode
block: (of_spx_stream_socket_async_connect_block_t)block
{
void *pool = objc_autoreleasePoolPush();
[[[[OFSPXStreamSocketAsyncConnectDelegate alloc]
initWithSocket: self
node: node
network: network
|
|
|
|
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
|
objc_autoreleasePoolPop(pool);
}
#ifdef OF_HAVE_BLOCKS
- (void)asyncConnectToNode: (unsigned char [_Nonnull IPX_NODE_LEN])node
network: (uint32_t)network
port: (uint16_t)port
block: (OFSPXStreamSocketAsyncConnectBlock)block
{
[self asyncConnectToNode: node
network: network
port: port
runLoopMode: of_run_loop_mode_default
block: block];
}
- (void)asyncConnectToNode: (unsigned char [_Nonnull IPX_NODE_LEN])node
network: (uint32_t)network
port: (uint16_t)port
runLoopMode: (of_run_loop_mode_t)runLoopMode
block: (OFSPXStreamSocketAsyncConnectBlock)block
{
void *pool = objc_autoreleasePoolPush();
[[[[OFSPXStreamSocketAsyncConnectDelegate alloc]
initWithSocket: self
node: node
network: network
|
︙ | | | ︙ | |
Modified src/OFSequencedPacketSocket.h
from [441de8fe25]
to [8979a0a6ff].
︙ | | | ︙ | |
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
|
* @brief A block which is called when a packet has been received.
*
* @param length The length of the packet
* @param exception An exception which occurred while receiving or `nil` on
* success
* @return A bool whether the same block should be used for the next receive
*/
typedef bool (^of_sequenced_packet_socket_async_receive_block_t)(size_t length,
id _Nullable exception);
/**
* @brief A block which is called when a packet has been sent.
*
* @param data The data which was sent
* @param exception An exception which occurred while reading or `nil` on
* success
* @return The data to repeat the send with or nil if it should not repeat
*/
typedef OFData *_Nullable (^of_sequenced_packet_socket_async_send_data_block_t)(
OFData *_Nonnull data, id _Nullable exception);
/**
* @brief A block which is called when the socket accepted a connection.
*
* @param acceptedSocket The socket which has been accepted
* @param exception An exception which occurred while accepting the socket or
* `nil` on success
* @return A bool whether the same block should be used for the next incoming
* connection
*/
typedef bool (^of_sequenced_packet_socket_async_accept_block_t)(
OFSequencedPacketSocket *acceptedSocket, id _Nullable exception);
#endif
/**
* @protocol OFSequencedPacketSocketDelegate OFSequencedPacketSocket.h \
* ObjFW/OFSequencedPacketSocket.h
*
|
|
|
|
|
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
|
* @brief A block which is called when a packet has been received.
*
* @param length The length of the packet
* @param exception An exception which occurred while receiving or `nil` on
* success
* @return A bool whether the same block should be used for the next receive
*/
typedef bool (^OFSequencedPacketSocketAsyncReceiveBlock)(size_t length,
id _Nullable exception);
/**
* @brief A block which is called when a packet has been sent.
*
* @param data The data which was sent
* @param exception An exception which occurred while reading or `nil` on
* success
* @return The data to repeat the send with or nil if it should not repeat
*/
typedef OFData *_Nullable (^OFSequencedPacketSocketAsyncSendDataBlock)(
OFData *_Nonnull data, id _Nullable exception);
/**
* @brief A block which is called when the socket accepted a connection.
*
* @param acceptedSocket The socket which has been accepted
* @param exception An exception which occurred while accepting the socket or
* `nil` on success
* @return A bool whether the same block should be used for the next incoming
* connection
*/
typedef bool (^OFSequencedPacketSocketAsyncAcceptBlock)(
OFSequencedPacketSocket *acceptedSocket, id _Nullable exception);
#endif
/**
* @protocol OFSequencedPacketSocketDelegate OFSequencedPacketSocket.h \
* ObjFW/OFSequencedPacketSocket.h
*
|
︙ | | | ︙ | |
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
|
* @param length The length of the buffer
* @param block The block to call when the packet has been received. If the
* block returns true, it will be called again with the same
* buffer and maximum length when more packets have been received.
* If you want the next method in the queue to handle the packet
* received next, you need to return false from the method.
*/
- (void)
asyncReceiveIntoBuffer: (void *)buffer
length: (size_t)length
block: (of_sequenced_packet_socket_async_receive_block_t)
block;
/**
* @brief Asynchronously receives a packet and stores it into the specified
* buffer.
*
* If the buffer is too small, the receive operation fails.
*
* @param buffer The buffer to write the packet to
* @param length The length of the buffer
* @param runLoopMode The run loop mode in which to perform the async receive
* @param block The block to call when the packet has been received. If the
* block returns true, it will be called again with the same
* buffer and maximum length when more packets have been received.
* If you want the next method in the queue to handle the packet
* received next, you need to return false from the method.
*/
- (void)
asyncReceiveIntoBuffer: (void *)buffer
length: (size_t)length
runLoopMode: (of_run_loop_mode_t)runLoopMode
block: (of_sequenced_packet_socket_async_receive_block_t)
block;
#endif
/**
* @brief Sends the specified packet.
*
* @param buffer The buffer to send as a packet
* @param length The length of the buffer
|
<
|
|
<
|
<
|
|
|
<
|
|
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
|
* @param length The length of the buffer
* @param block The block to call when the packet has been received. If the
* block returns true, it will be called again with the same
* buffer and maximum length when more packets have been received.
* If you want the next method in the queue to handle the packet
* received next, you need to return false from the method.
*/
- (void)asyncReceiveIntoBuffer: (void *)buffer
length: (size_t)length
block: (OFSequencedPacketSocketAsyncReceiveBlock)block;
/**
* @brief Asynchronously receives a packet and stores it into the specified
* buffer.
*
* If the buffer is too small, the receive operation fails.
*
* @param buffer The buffer to write the packet to
* @param length The length of the buffer
* @param runLoopMode The run loop mode in which to perform the async receive
* @param block The block to call when the packet has been received. If the
* block returns true, it will be called again with the same
* buffer and maximum length when more packets have been received.
* If you want the next method in the queue to handle the packet
* received next, you need to return false from the method.
*/
- (void)asyncReceiveIntoBuffer: (void *)buffer
length: (size_t)length
runLoopMode: (of_run_loop_mode_t)runLoopMode
block: (OFSequencedPacketSocketAsyncReceiveBlock)block;
#endif
/**
* @brief Sends the specified packet.
*
* @param buffer The buffer to send as a packet
* @param length The length of the buffer
|
︙ | | | ︙ | |
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
|
*
* @param data The data to send as a packet
* @param block The block to call when the packet has been sent. It should
* return the data for the next send with the same callback or nil
* if it should not repeat.
*/
- (void)asyncSendData: (OFData *)data
block: (of_sequenced_packet_socket_async_send_data_block_t)
block;
/**
* @brief Asynchronously sends the specified packet.
*
* @param data The data to send as a packet
* @param runLoopMode The run loop mode in which to perform the async send
* @param block The block to call when the packet has been sent. It should
* return the data for the next send with the same callback or nil
* if it should not repeat.
*/
- (void)asyncSendData: (OFData *)data
runLoopMode: (of_run_loop_mode_t)runLoopMode
block: (of_sequenced_packet_socket_async_send_data_block_t)
block;
#endif
/**
* @brief Listen on the socket.
*
* @param backlog Maximum length for the queue of pending connections.
*/
|
<
|
<
|
|
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
|
*
* @param data The data to send as a packet
* @param block The block to call when the packet has been sent. It should
* return the data for the next send with the same callback or nil
* if it should not repeat.
*/
- (void)asyncSendData: (OFData *)data
block: (OFSequencedPacketSocketAsyncSendDataBlock)block;
/**
* @brief Asynchronously sends the specified packet.
*
* @param data The data to send as a packet
* @param runLoopMode The run loop mode in which to perform the async send
* @param block The block to call when the packet has been sent. It should
* return the data for the next send with the same callback or nil
* if it should not repeat.
*/
- (void)asyncSendData: (OFData *)data
runLoopMode: (of_run_loop_mode_t)runLoopMode
block: (OFSequencedPacketSocketAsyncSendDataBlock)block;
#endif
/**
* @brief Listen on the socket.
*
* @param backlog Maximum length for the queue of pending connections.
*/
|
︙ | | | ︙ | |
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
|
/**
* @brief Asynchronously accept an incoming connection.
*
* @param block The block to execute when a new connection has been accepted.
* Returns whether the next incoming connection should be accepted
* by the specified block as well.
*/
- (void)asyncAcceptWithBlock:
(of_sequenced_packet_socket_async_accept_block_t)block;
/**
* @brief Asynchronously accept an incoming connection.
*
* @param runLoopMode The run loop mode in which to perform the async accept
* @param block The block to execute when a new connection has been accepted.
* Returns whether the next incoming connection should be accepted
* by the specified block as well.
*/
- (void)asyncAcceptWithRunLoopMode: (of_run_loop_mode_t)runLoopMode
block: (of_sequenced_packet_socket_async_accept_block_t)block;
#endif
/**
* @brief Cancels all pending asynchronous requests on the socket.
*/
- (void)cancelAsyncRequests;
|
|
<
>
|
|
|
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
|
/**
* @brief Asynchronously accept an incoming connection.
*
* @param block The block to execute when a new connection has been accepted.
* Returns whether the next incoming connection should be accepted
* by the specified block as well.
*/
- (void)asyncAcceptWithBlock: (OFSequencedPacketSocketAsyncAcceptBlock)block;
/**
* @brief Asynchronously accept an incoming connection.
*
* @param runLoopMode The run loop mode in which to perform the async accept
* @param block The block to execute when a new connection has been accepted.
* Returns whether the next incoming connection should be accepted
* by the specified block as well.
*/
- (void)
asyncAcceptWithRunLoopMode: (of_run_loop_mode_t)runLoopMode
block: (OFSequencedPacketSocketAsyncAcceptBlock)block;
#endif
/**
* @brief Cancels all pending asynchronous requests on the socket.
*/
- (void)cancelAsyncRequests;
|
︙ | | | ︙ | |
Modified src/OFSequencedPacketSocket.m
from [7bba0bbd14]
to [340b6ad1b0].
︙ | | | ︙ | |
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
|
# ifdef OF_HAVE_BLOCKS
block: NULL
# endif
delegate: _delegate];
}
#ifdef OF_HAVE_BLOCKS
- (void)
asyncReceiveIntoBuffer: (void *)buffer
length: (size_t)length
block: (of_sequenced_packet_socket_async_receive_block_t)
block
{
[self asyncReceiveIntoBuffer: buffer
length: length
runLoopMode: of_run_loop_mode_default
block: block];
}
- (void)
asyncReceiveIntoBuffer: (void *)buffer
length: (size_t)length
runLoopMode: (of_run_loop_mode_t)runLoopMode
block: (of_sequenced_packet_socket_async_receive_block_t)
block
{
[OFRunLoop of_addAsyncReceiveForSequencedPacketSocket: self
buffer: buffer
length: length
mode: runLoopMode
block: block
delegate: nil];
|
<
|
|
<
|
<
|
|
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
|
# ifdef OF_HAVE_BLOCKS
block: NULL
# endif
delegate: _delegate];
}
#ifdef OF_HAVE_BLOCKS
- (void)asyncReceiveIntoBuffer: (void *)buffer
length: (size_t)length
block: (OFSequencedPacketSocketAsyncReceiveBlock)block
{
[self asyncReceiveIntoBuffer: buffer
length: length
runLoopMode: of_run_loop_mode_default
block: block];
}
- (void)
asyncReceiveIntoBuffer: (void *)buffer
length: (size_t)length
runLoopMode: (of_run_loop_mode_t)runLoopMode
block: (OFSequencedPacketSocketAsyncReceiveBlock)block
{
[OFRunLoop of_addAsyncReceiveForSequencedPacketSocket: self
buffer: buffer
length: length
mode: runLoopMode
block: block
delegate: nil];
|
︙ | | | ︙ | |
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
|
block: NULL
# endif
delegate: _delegate];
}
#ifdef OF_HAVE_BLOCKS
- (void)asyncSendData: (OFData *)data
block: (of_sequenced_packet_socket_async_send_data_block_t)block
{
[self asyncSendData: data
runLoopMode: of_run_loop_mode_default
block: block];
}
- (void)asyncSendData: (OFData *)data
runLoopMode: (of_run_loop_mode_t)runLoopMode
block: (of_sequenced_packet_socket_async_send_data_block_t)block
{
[OFRunLoop of_addAsyncSendForSequencedPacketSocket: self
data: data
mode: runLoopMode
block: block
delegate: nil];
}
|
|
|
|
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
|
block: NULL
# endif
delegate: _delegate];
}
#ifdef OF_HAVE_BLOCKS
- (void)asyncSendData: (OFData *)data
block: (OFSequencedPacketSocketAsyncSendDataBlock)block
{
[self asyncSendData: data
runLoopMode: of_run_loop_mode_default
block: block];
}
- (void)asyncSendData: (OFData *)data
runLoopMode: (of_run_loop_mode_t)runLoopMode
block: (OFSequencedPacketSocketAsyncSendDataBlock)block
{
[OFRunLoop of_addAsyncSendForSequencedPacketSocket: self
data: data
mode: runLoopMode
block: block
delegate: nil];
}
|
︙ | | | ︙ | |
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
|
[OFRunLoop of_addAsyncAcceptForSocket: self
mode: runLoopMode
block: NULL
delegate: _delegate];
}
#ifdef OF_HAVE_BLOCKS
- (void)asyncAcceptWithBlock: (of_sequenced_packet_socket_async_accept_block_t)
block
{
[self asyncAcceptWithRunLoopMode: of_run_loop_mode_default
block: block];
}
- (void)asyncAcceptWithRunLoopMode: (of_run_loop_mode_t)runLoopMode
block: (of_sequenced_packet_socket_async_accept_block_t)block
{
[OFRunLoop of_addAsyncAcceptForSocket: self
mode: runLoopMode
block: block
delegate: nil];
}
#endif
|
|
<
>
|
|
|
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
|
[OFRunLoop of_addAsyncAcceptForSocket: self
mode: runLoopMode
block: NULL
delegate: _delegate];
}
#ifdef OF_HAVE_BLOCKS
- (void)asyncAcceptWithBlock: (OFSequencedPacketSocketAsyncAcceptBlock)block
{
[self asyncAcceptWithRunLoopMode: of_run_loop_mode_default
block: block];
}
- (void)
asyncAcceptWithRunLoopMode: (of_run_loop_mode_t)runLoopMode
block: (OFSequencedPacketSocketAsyncAcceptBlock)block
{
[OFRunLoop of_addAsyncAcceptForSocket: self
mode: runLoopMode
block: block
delegate: nil];
}
#endif
|
︙ | | | ︙ | |
Modified src/OFSet.h
from [14327ba57e]
to [b05430c060].
︙ | | | ︙ | |
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
|
/**
* @brief A block for enumerating an OFSet.
*
* @param object The current object
* @param stop A pointer to a variable that can be set to true to stop the
* enumeration
*/
typedef void (^of_set_enumeration_block_t)(id object, bool *stop);
/**
* @brief A block for filtering an OFSet.
*
* @param object The object to inspect
* @return Whether the object should be in the filtered set
*/
typedef bool (^of_set_filter_block_t)(id object);
#endif
/**
* @class OFSet OFSet.h ObjFW/OFSet.h
*
* @brief An abstract class for an unordered set of unique objects.
*
|
|
|
|
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
|
/**
* @brief A block for enumerating an OFSet.
*
* @param object The current object
* @param stop A pointer to a variable that can be set to true to stop the
* enumeration
*/
typedef void (^OFSetEnumerationBlock)(id object, bool *stop);
/**
* @brief A block for filtering an OFSet.
*
* @param object The object to inspect
* @return Whether the object should be in the filtered set
*/
typedef bool (^OFSetFilterBlock)(id object);
#endif
/**
* @class OFSet OFSet.h ObjFW/OFSet.h
*
* @brief An abstract class for an unordered set of unique objects.
*
|
︙ | | | ︙ | |
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
|
#ifdef OF_HAVE_BLOCKS
/**
* @brief Executes a block for each object in the set.
*
* @param block The block to execute for each object in the set
*/
- (void)enumerateObjectsUsingBlock: (of_set_enumeration_block_t)block;
/**
* @brief Creates a new set, only containing the objects for which the block
* returns true.
*
* @param block A block which determines if the object should be in the new set
* @return A new, autoreleased OFSet
*/
- (OFSet OF_GENERIC(ObjectType) *)filteredSetUsingBlock:
(of_set_filter_block_t)block;
#endif
#if !defined(OF_HAVE_GENERICS) && !defined(DOXYGEN)
# undef ObjectType
#endif
@end
OF_ASSUME_NONNULL_END
#import "OFMutableSet.h"
|
|
|
|
|
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
|
#ifdef OF_HAVE_BLOCKS
/**
* @brief Executes a block for each object in the set.
*
* @param block The block to execute for each object in the set
*/
- (void)enumerateObjectsUsingBlock: (OFSetEnumerationBlock)block;
/**
* @brief Creates a new set, only containing the objects for which the block
* returns true.
*
* @param block A block which determines if the object should be in the new set
* @return A new, autoreleased OFSet
*/
- (OFSet OF_GENERIC(ObjectType) *)
filteredSetUsingBlock: (OFSetFilterBlock)block;
#endif
#if !defined(OF_HAVE_GENERICS) && !defined(DOXYGEN)
# undef ObjectType
#endif
@end
OF_ASSUME_NONNULL_END
#import "OFMutableSet.h"
|
Modified src/OFSet.m
from [a8859ecef5]
to [b7d60ea604].
︙ | | | ︙ | |
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
|
void *pool = objc_autoreleasePoolPush();
id ret = [[[self objectEnumerator] nextObject] retain];
objc_autoreleasePoolPop(pool);
return [ret autorelease];
}
#ifdef OF_HAVE_BLOCKS
- (void)enumerateObjectsUsingBlock: (of_set_enumeration_block_t)block
{
bool stop = false;
for (id object in self) {
block(object, &stop);
if (stop)
break;
}
}
- (OFSet *)filteredSetUsingBlock: (of_set_filter_block_t)block
{
OFMutableSet *ret = [OFMutableSet set];
[self enumerateObjectsUsingBlock: ^ (id object, bool *stop) {
if (block(object))
[ret addObject: object];
}];
|
|
|
|
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
|
void *pool = objc_autoreleasePoolPush();
id ret = [[[self objectEnumerator] nextObject] retain];
objc_autoreleasePoolPop(pool);
return [ret autorelease];
}
#ifdef OF_HAVE_BLOCKS
- (void)enumerateObjectsUsingBlock: (OFSetEnumerationBlock)block
{
bool stop = false;
for (id object in self) {
block(object, &stop);
if (stop)
break;
}
}
- (OFSet *)filteredSetUsingBlock: (OFSetFilterBlock)block
{
OFMutableSet *ret = [OFMutableSet set];
[self enumerateObjectsUsingBlock: ^ (id object, bool *stop) {
if (block(object))
[ret addObject: object];
}];
|
︙ | | | ︙ | |
Modified src/OFStream.h
from [68d6326585]
to [478b508e50].
︙ | | | ︙ | |
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
|
* stream.
*
* @param length The length of the data that has been read
* @param exception An exception which occurred while reading or `nil` on
* success
* @return A bool whether the same block should be used for the next read
*/
typedef bool (^of_stream_async_read_block_t)(size_t length,
id _Nullable exception);
/**
* @brief A block which is called when a line was read asynchronously from a
* stream.
*
* @param line The line which has been read or `nil` when the end of stream
* occurred
* @param exception An exception which occurred while reading or `nil` on
* success
* @return A bool whether the same block should be used for the next read
*/
typedef bool (^of_stream_async_read_line_block_t)(OFString *_Nullable line,
id _Nullable exception);
/**
* @brief A block which is called when data was written asynchronously to a
* stream.
*
* @param data The data which was written to the stream
* @param bytesWritten The number of bytes which have been written. This
* matches the length of the specified data on the
* asynchronous write if no exception was encountered.
* @param exception An exception which occurred while writing or `nil` on
* success
* @return The data to repeat the write with or nil if it should not repeat
*/
typedef OFData *_Nullable (^of_stream_async_write_data_block_t)(
OFData *_Nonnull data, size_t bytesWritten, id _Nullable exception);
/**
* @brief A block which is called when a string was written asynchronously to a
* stream.
*
* @param string The string which was written to the stream
* @param bytesWritten The number of bytes which have been written. This
* matches the length of the specified data on the
* asynchronous write if no exception was encountered.
* @param exception An exception which occurred while writing or `nil` on
* success
* @return The string to repeat the write with or nil if it should not repeat
*/
typedef OFString *_Nullable (^of_stream_async_write_string_block_t)(
OFString *_Nonnull string, size_t bytesWritten, id _Nullable exception);
#endif
/**
* @protocol OFStreamDelegate OFStream.h ObjFW/OFStream.h
*
* A delegate for OFStream.
|
<
|
|
|
|
|
|
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
|
* stream.
*
* @param length The length of the data that has been read
* @param exception An exception which occurred while reading or `nil` on
* success
* @return A bool whether the same block should be used for the next read
*/
typedef bool (^OFStreamAsyncReadBlock)(size_t length, id _Nullable exception);
/**
* @brief A block which is called when a line was read asynchronously from a
* stream.
*
* @param line The line which has been read or `nil` when the end of stream
* occurred
* @param exception An exception which occurred while reading or `nil` on
* success
* @return A bool whether the same block should be used for the next read
*/
typedef bool (^OFStreamAsyncReadLineBlock)(OFString *_Nullable line,
id _Nullable exception);
/**
* @brief A block which is called when data was written asynchronously to a
* stream.
*
* @param data The data which was written to the stream
* @param bytesWritten The number of bytes which have been written. This
* matches the length of the specified data on the
* asynchronous write if no exception was encountered.
* @param exception An exception which occurred while writing or `nil` on
* success
* @return The data to repeat the write with or nil if it should not repeat
*/
typedef OFData *_Nullable (^OFStreamAsyncWriteDataBlock)(OFData *_Nonnull data,
size_t bytesWritten, id _Nullable exception);
/**
* @brief A block which is called when a string was written asynchronously to a
* stream.
*
* @param string The string which was written to the stream
* @param bytesWritten The number of bytes which have been written. This
* matches the length of the specified data on the
* asynchronous write if no exception was encountered.
* @param exception An exception which occurred while writing or `nil` on
* success
* @return The string to repeat the write with or nil if it should not repeat
*/
typedef OFString *_Nullable (^OFStreamAsyncWriteStringBlock)(
OFString *_Nonnull string, size_t bytesWritten, id _Nullable exception);
#endif
/**
* @protocol OFStreamDelegate OFStream.h ObjFW/OFStream.h
*
* A delegate for OFStream.
|
︙ | | | ︙ | |
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
|
* If the block returns true, it will be called again with the same
* buffer and maximum length when more data has been received. If
* you want the next block in the queue to handle the data
* received next, you need to return false from the block.
*/
- (void)asyncReadIntoBuffer: (void *)buffer
length: (size_t)length
block: (of_stream_async_read_block_t)block;
/**
* @brief Asynchronously reads *at most* ref size bytes from the stream into a
* buffer.
*
* On network streams, this might read less than the specified number of bytes.
* If you want to read exactly the specified number of bytes, use
|
|
|
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
|
* If the block returns true, it will be called again with the same
* buffer and maximum length when more data has been received. If
* you want the next block in the queue to handle the data
* received next, you need to return false from the block.
*/
- (void)asyncReadIntoBuffer: (void *)buffer
length: (size_t)length
block: (OFStreamAsyncReadBlock)block;
/**
* @brief Asynchronously reads *at most* ref size bytes from the stream into a
* buffer.
*
* On network streams, this might read less than the specified number of bytes.
* If you want to read exactly the specified number of bytes, use
|
︙ | | | ︙ | |
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
|
* buffer and maximum length when more data has been received. If
* you want the next block in the queue to handle the data
* received next, you need to return false from the block.
*/
- (void)asyncReadIntoBuffer: (void *)buffer
length: (size_t)length
runLoopMode: (of_run_loop_mode_t)runLoopMode
block: (of_stream_async_read_block_t)block;
/**
* @brief Asynchronously reads exactly the specified length bytes from the
* stream into a buffer.
*
* Unlike @ref asyncReadIntoBuffer:length:block:, this method does not invoke
* the block when less than the specified length has been read - instead, it
|
|
|
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
|
* buffer and maximum length when more data has been received. If
* you want the next block in the queue to handle the data
* received next, you need to return false from the block.
*/
- (void)asyncReadIntoBuffer: (void *)buffer
length: (size_t)length
runLoopMode: (of_run_loop_mode_t)runLoopMode
block: (OFStreamAsyncReadBlock)block;
/**
* @brief Asynchronously reads exactly the specified length bytes from the
* stream into a buffer.
*
* Unlike @ref asyncReadIntoBuffer:length:block:, this method does not invoke
* the block when less than the specified length has been read - instead, it
|
︙ | | | ︙ | |
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
|
* If the block returns true, it will be called again with the same
* buffer and exact length when more data has been received. If
* you want the next block in the queue to handle the data
* received next, you need to return false from the block.
*/
- (void)asyncReadIntoBuffer: (void *)buffer
exactLength: (size_t)length
block: (of_stream_async_read_block_t)block;
/**
* @brief Asynchronously reads exactly the specified length bytes from the
* stream into a buffer.
*
* Unlike @ref asyncReadIntoBuffer:length:block:, this method does not invoke
* the block when less than the specified length has been read - instead, it
|
|
|
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
|
* If the block returns true, it will be called again with the same
* buffer and exact length when more data has been received. If
* you want the next block in the queue to handle the data
* received next, you need to return false from the block.
*/
- (void)asyncReadIntoBuffer: (void *)buffer
exactLength: (size_t)length
block: (OFStreamAsyncReadBlock)block;
/**
* @brief Asynchronously reads exactly the specified length bytes from the
* stream into a buffer.
*
* Unlike @ref asyncReadIntoBuffer:length:block:, this method does not invoke
* the block when less than the specified length has been read - instead, it
|
︙ | | | ︙ | |
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
|
* buffer and exact length when more data has been received. If
* you want the next block in the queue to handle the data
* received next, you need to return false from the block.
*/
- (void)asyncReadIntoBuffer: (void *)buffer
exactLength: (size_t)length
runLoopMode: (of_run_loop_mode_t)runLoopMode
block: (of_stream_async_read_block_t)block;
# endif
#endif
/**
* @brief Reads a uint8_t from the stream.
*
* @warning Only call this when you know that enough data is available!
|
|
|
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
|
* buffer and exact length when more data has been received. If
* you want the next block in the queue to handle the data
* received next, you need to return false from the block.
*/
- (void)asyncReadIntoBuffer: (void *)buffer
exactLength: (size_t)length
runLoopMode: (of_run_loop_mode_t)runLoopMode
block: (OFStreamAsyncReadBlock)block;
# endif
#endif
/**
* @brief Reads a uint8_t from the stream.
*
* @warning Only call this when you know that enough data is available!
|
︙ | | | ︙ | |
856
857
858
859
860
861
862
863
864
865
866
867
868
869
870
871
872
873
874
875
876
877
878
879
880
881
882
883
884
885
886
887
888
889
890
891
892
893
894
895
896
897
898
899
900
901
902
903
904
905
906
|
*
* @param block The block to call when the data has been received.
* If the block returns true, it will be called again when the next
* line has been received. If you want the next block in the queue
* to handle the next line, you need to return false from the
* block.
*/
- (void)asyncReadLineWithBlock: (of_stream_async_read_line_block_t)block;
/**
* @brief Asynchronously reads with the specified encoding until a newline,
* `\0`, end of stream or an exception occurs.
*
* @note The stream must conform to @ref OFReadyForReadingObserving in order
* for this to work!
*
* @param encoding The encoding used by the stream
* @param block The block to call when the data has been received.
* If the block returns true, it will be called again when the next
* line has been received. If you want the next block in the queue
* to handle the next line, you need to return false from the
* block.
*/
- (void)asyncReadLineWithEncoding: (OFStringEncoding)encoding
block: (of_stream_async_read_line_block_t)block;
/**
* @brief Asynchronously reads with the specified encoding until a newline,
* `\0`, end of stream or an exception occurs.
*
* @note The stream must conform to @ref OFReadyForReadingObserving in order
* for this to work!
*
* @param encoding The encoding used by the stream
* @param runLoopMode The run loop mode in which to perform the async read
* @param block The block to call when the data has been received.
* If the block returns true, it will be called again when the next
* line has been received. If you want the next block in the queue
* to handle the next line, you need to return false from the
* block.
*/
- (void)asyncReadLineWithEncoding: (OFStringEncoding)encoding
runLoopMode: (of_run_loop_mode_t)runLoopMode
block: (of_stream_async_read_line_block_t)block;
# endif
#endif
/**
* @brief Tries to read a line from the stream (see @ref readLine) and returns
* `nil` if no complete line has been received yet.
*
|
|
|
|
|
855
856
857
858
859
860
861
862
863
864
865
866
867
868
869
870
871
872
873
874
875
876
877
878
879
880
881
882
883
884
885
886
887
888
889
890
891
892
893
894
895
896
897
898
899
900
901
902
903
904
905
|
*
* @param block The block to call when the data has been received.
* If the block returns true, it will be called again when the next
* line has been received. If you want the next block in the queue
* to handle the next line, you need to return false from the
* block.
*/
- (void)asyncReadLineWithBlock: (OFStreamAsyncReadLineBlock)block;
/**
* @brief Asynchronously reads with the specified encoding until a newline,
* `\0`, end of stream or an exception occurs.
*
* @note The stream must conform to @ref OFReadyForReadingObserving in order
* for this to work!
*
* @param encoding The encoding used by the stream
* @param block The block to call when the data has been received.
* If the block returns true, it will be called again when the next
* line has been received. If you want the next block in the queue
* to handle the next line, you need to return false from the
* block.
*/
- (void)asyncReadLineWithEncoding: (OFStringEncoding)encoding
block: (OFStreamAsyncReadLineBlock)block;
/**
* @brief Asynchronously reads with the specified encoding until a newline,
* `\0`, end of stream or an exception occurs.
*
* @note The stream must conform to @ref OFReadyForReadingObserving in order
* for this to work!
*
* @param encoding The encoding used by the stream
* @param runLoopMode The run loop mode in which to perform the async read
* @param block The block to call when the data has been received.
* If the block returns true, it will be called again when the next
* line has been received. If you want the next block in the queue
* to handle the next line, you need to return false from the
* block.
*/
- (void)asyncReadLineWithEncoding: (OFStringEncoding)encoding
runLoopMode: (of_run_loop_mode_t)runLoopMode
block: (OFStreamAsyncReadLineBlock)block;
# endif
#endif
/**
* @brief Tries to read a line from the stream (see @ref readLine) and returns
* `nil` if no complete line has been received yet.
*
|
︙ | | | ︙ | |
1053
1054
1055
1056
1057
1058
1059
1060
1061
1062
1063
1064
1065
1066
1067
1068
1069
1070
1071
1072
1073
1074
1075
1076
1077
1078
1079
1080
1081
1082
1083
1084
1085
1086
1087
1088
1089
1090
1091
1092
1093
1094
1095
1096
1097
1098
1099
1100
1101
1102
1103
1104
1105
1106
1107
1108
1109
1110
1111
1112
1113
1114
1115
1116
1117
1118
1119
1120
1121
1122
1123
1124
1125
1126
1127
1128
1129
1130
1131
1132
1133
1134
1135
|
*
* @param data The data which is written into the stream
* @param block The block to call when the data has been written. It should
* return the data for the next write with the same callback or
* nil if it should not repeat.
*/
- (void)asyncWriteData: (OFData *)data
block: (of_stream_async_write_data_block_t)block;
/**
* @brief Asynchronously writes data into the stream.
*
* @note The stream must conform to @ref OFReadyForWritingObserving in order
* for this to work!
*
* @param data The data which is written into the stream
* @param runLoopMode The run loop mode in which to perform the async write
* @param block The block to call when the data has been written. It should
* return the data for the next write with the same callback or
* nil if it should not repeat.
*/
- (void)asyncWriteData: (OFData *)data
runLoopMode: (of_run_loop_mode_t)runLoopMode
block: (of_stream_async_write_data_block_t)block;
/**
* @brief Asynchronously writes a string into the stream.
*
* @note The stream must conform to @ref OFReadyForWritingObserving in order
* for this to work!
*
* @param string The string which is written into the stream
* @param block The block to call when the string has been written. It should
* return the string for the next write with the same callback or
* nil if it should not repeat.
*/
- (void)asyncWriteString: (OFString *)string
block: (of_stream_async_write_string_block_t)block;
/**
* @brief Asynchronously writes a string in the specified encoding into the
* stream.
*
* @note The stream must conform to @ref OFReadyForWritingObserving in order
* for this to work!
*
* @param string The string which is written into the stream
* @param encoding The encoding in which the string should be written to the
* stream
* @param block The block to call when the string has been written. It should
* return the string for the next write with the same callback or
* nil if it should not repeat.
*/
- (void)asyncWriteString: (OFString *)string
encoding: (OFStringEncoding)encoding
block: (of_stream_async_write_string_block_t)block;
/**
* @brief Asynchronously writes a string in the specified encoding into the
* stream.
*
* @note The stream must conform to @ref OFReadyForWritingObserving in order
* for this to work!
*
* @param string The string which is written into the stream
* @param encoding The encoding in which the string should be written to the
* stream
* @param runLoopMode The run loop mode in which to perform the async write
* @param block The block to call when the string has been written. It should
* return the string for the next write with the same callback or
* nil if it should not repeat.
*/
- (void)asyncWriteString: (OFString *)string
encoding: (OFStringEncoding)encoding
runLoopMode: (of_run_loop_mode_t)runLoopMode
block: (of_stream_async_write_string_block_t)block;
# endif
#endif
/**
* @brief Writes a uint8_t into the stream.
*
* @param int8 A uint8_t
|
|
|
|
|
|
|
1052
1053
1054
1055
1056
1057
1058
1059
1060
1061
1062
1063
1064
1065
1066
1067
1068
1069
1070
1071
1072
1073
1074
1075
1076
1077
1078
1079
1080
1081
1082
1083
1084
1085
1086
1087
1088
1089
1090
1091
1092
1093
1094
1095
1096
1097
1098
1099
1100
1101
1102
1103
1104
1105
1106
1107
1108
1109
1110
1111
1112
1113
1114
1115
1116
1117
1118
1119
1120
1121
1122
1123
1124
1125
1126
1127
1128
1129
1130
1131
1132
1133
1134
|
*
* @param data The data which is written into the stream
* @param block The block to call when the data has been written. It should
* return the data for the next write with the same callback or
* nil if it should not repeat.
*/
- (void)asyncWriteData: (OFData *)data
block: (OFStreamAsyncWriteDataBlock)block;
/**
* @brief Asynchronously writes data into the stream.
*
* @note The stream must conform to @ref OFReadyForWritingObserving in order
* for this to work!
*
* @param data The data which is written into the stream
* @param runLoopMode The run loop mode in which to perform the async write
* @param block The block to call when the data has been written. It should
* return the data for the next write with the same callback or
* nil if it should not repeat.
*/
- (void)asyncWriteData: (OFData *)data
runLoopMode: (of_run_loop_mode_t)runLoopMode
block: (OFStreamAsyncWriteDataBlock)block;
/**
* @brief Asynchronously writes a string into the stream.
*
* @note The stream must conform to @ref OFReadyForWritingObserving in order
* for this to work!
*
* @param string The string which is written into the stream
* @param block The block to call when the string has been written. It should
* return the string for the next write with the same callback or
* nil if it should not repeat.
*/
- (void)asyncWriteString: (OFString *)string
block: (OFStreamAsyncWriteStringBlock)block;
/**
* @brief Asynchronously writes a string in the specified encoding into the
* stream.
*
* @note The stream must conform to @ref OFReadyForWritingObserving in order
* for this to work!
*
* @param string The string which is written into the stream
* @param encoding The encoding in which the string should be written to the
* stream
* @param block The block to call when the string has been written. It should
* return the string for the next write with the same callback or
* nil if it should not repeat.
*/
- (void)asyncWriteString: (OFString *)string
encoding: (OFStringEncoding)encoding
block: (OFStreamAsyncWriteStringBlock)block;
/**
* @brief Asynchronously writes a string in the specified encoding into the
* stream.
*
* @note The stream must conform to @ref OFReadyForWritingObserving in order
* for this to work!
*
* @param string The string which is written into the stream
* @param encoding The encoding in which the string should be written to the
* stream
* @param runLoopMode The run loop mode in which to perform the async write
* @param block The block to call when the string has been written. It should
* return the string for the next write with the same callback or
* nil if it should not repeat.
*/
- (void)asyncWriteString: (OFString *)string
encoding: (OFStringEncoding)encoding
runLoopMode: (of_run_loop_mode_t)runLoopMode
block: (OFStreamAsyncWriteStringBlock)block;
# endif
#endif
/**
* @brief Writes a uint8_t into the stream.
*
* @param int8 A uint8_t
|
︙ | | | ︙ | |
Modified src/OFStream.m
from [7e08799ba0]
to [82b41b1ac9].
︙ | | | ︙ | |
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
|
# endif
delegate: _delegate];
}
# ifdef OF_HAVE_BLOCKS
- (void)asyncReadIntoBuffer: (void *)buffer
length: (size_t)length
block: (of_stream_async_read_block_t)block
{
[self asyncReadIntoBuffer: buffer
length: length
runLoopMode: of_run_loop_mode_default
block: block];
}
- (void)asyncReadIntoBuffer: (void *)buffer
length: (size_t)length
runLoopMode: (of_run_loop_mode_t)runLoopMode
block: (of_stream_async_read_block_t)block
{
OFStream <OFReadyForReadingObserving> *stream =
(OFStream <OFReadyForReadingObserving> *)self;
[OFRunLoop of_addAsyncReadForStream: stream
buffer: buffer
length: length
mode: runLoopMode
block: block
delegate: nil];
}
- (void)asyncReadIntoBuffer: (void *)buffer
exactLength: (size_t)length
block: (of_stream_async_read_block_t)block
{
[self asyncReadIntoBuffer: buffer
exactLength: length
runLoopMode: of_run_loop_mode_default
block: block];
}
- (void)asyncReadIntoBuffer: (void *)buffer
exactLength: (size_t)length
runLoopMode: (of_run_loop_mode_t)runLoopMode
block: (of_stream_async_read_block_t)block
{
OFStream <OFReadyForReadingObserving> *stream =
(OFStream <OFReadyForReadingObserving> *)self;
[OFRunLoop of_addAsyncReadForStream: stream
buffer: buffer
exactLength: length
|
|
|
|
|
|
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
|
# endif
delegate: _delegate];
}
# ifdef OF_HAVE_BLOCKS
- (void)asyncReadIntoBuffer: (void *)buffer
length: (size_t)length
block: (OFStreamAsyncReadBlock)block
{
[self asyncReadIntoBuffer: buffer
length: length
runLoopMode: of_run_loop_mode_default
block: block];
}
- (void)asyncReadIntoBuffer: (void *)buffer
length: (size_t)length
runLoopMode: (of_run_loop_mode_t)runLoopMode
block: (OFStreamAsyncReadBlock)block
{
OFStream <OFReadyForReadingObserving> *stream =
(OFStream <OFReadyForReadingObserving> *)self;
[OFRunLoop of_addAsyncReadForStream: stream
buffer: buffer
length: length
mode: runLoopMode
block: block
delegate: nil];
}
- (void)asyncReadIntoBuffer: (void *)buffer
exactLength: (size_t)length
block: (OFStreamAsyncReadBlock)block
{
[self asyncReadIntoBuffer: buffer
exactLength: length
runLoopMode: of_run_loop_mode_default
block: block];
}
- (void)asyncReadIntoBuffer: (void *)buffer
exactLength: (size_t)length
runLoopMode: (of_run_loop_mode_t)runLoopMode
block: (OFStreamAsyncReadBlock)block
{
OFStream <OFReadyForReadingObserving> *stream =
(OFStream <OFReadyForReadingObserving> *)self;
[OFRunLoop of_addAsyncReadForStream: stream
buffer: buffer
exactLength: length
|
︙ | | | ︙ | |
830
831
832
833
834
835
836
837
838
839
840
841
842
843
844
845
846
847
848
849
850
851
852
853
854
855
856
857
858
859
860
861
|
# ifdef OF_HAVE_BLOCKS
block: NULL
# endif
delegate: _delegate];
}
# ifdef OF_HAVE_BLOCKS
- (void)asyncReadLineWithBlock: (of_stream_async_read_line_block_t)block
{
[self asyncReadLineWithEncoding: OFStringEncodingUTF8
runLoopMode: of_run_loop_mode_default
block: block];
}
- (void)asyncReadLineWithEncoding: (OFStringEncoding)encoding
block: (of_stream_async_read_line_block_t)block
{
[self asyncReadLineWithEncoding: encoding
runLoopMode: of_run_loop_mode_default
block: block];
}
- (void)asyncReadLineWithEncoding: (OFStringEncoding)encoding
runLoopMode: (of_run_loop_mode_t)runLoopMode
block: (of_stream_async_read_line_block_t)block
{
OFStream <OFReadyForReadingObserving> *stream =
(OFStream <OFReadyForReadingObserving> *)self;
[OFRunLoop of_addAsyncReadLineForStream: stream
encoding: encoding
mode: runLoopMode
|
|
|
|
|
830
831
832
833
834
835
836
837
838
839
840
841
842
843
844
845
846
847
848
849
850
851
852
853
854
855
856
857
858
859
860
861
|
# ifdef OF_HAVE_BLOCKS
block: NULL
# endif
delegate: _delegate];
}
# ifdef OF_HAVE_BLOCKS
- (void)asyncReadLineWithBlock: (OFStreamAsyncReadLineBlock)block
{
[self asyncReadLineWithEncoding: OFStringEncodingUTF8
runLoopMode: of_run_loop_mode_default
block: block];
}
- (void)asyncReadLineWithEncoding: (OFStringEncoding)encoding
block: (OFStreamAsyncReadLineBlock)block
{
[self asyncReadLineWithEncoding: encoding
runLoopMode: of_run_loop_mode_default
block: block];
}
- (void)asyncReadLineWithEncoding: (OFStringEncoding)encoding
runLoopMode: (of_run_loop_mode_t)runLoopMode
block: (OFStreamAsyncReadLineBlock)block
{
OFStream <OFReadyForReadingObserving> *stream =
(OFStream <OFReadyForReadingObserving> *)self;
[OFRunLoop of_addAsyncReadLineForStream: stream
encoding: encoding
mode: runLoopMode
|
︙ | | | ︙ | |
1143
1144
1145
1146
1147
1148
1149
1150
1151
1152
1153
1154
1155
1156
1157
1158
1159
1160
1161
1162
1163
1164
1165
1166
1167
1168
1169
1170
1171
1172
1173
1174
1175
1176
1177
1178
1179
1180
1181
1182
1183
1184
1185
1186
1187
1188
1189
1190
1191
1192
1193
1194
1195
1196
1197
1198
1199
1200
1201
|
# ifdef OF_HAVE_BLOCKS
block: NULL
# endif
delegate: _delegate];
}
# ifdef OF_HAVE_BLOCKS
- (void)asyncWriteData: (OFData *)data
block: (of_stream_async_write_data_block_t)block
{
[self asyncWriteData: data
runLoopMode: of_run_loop_mode_default
block: block];
}
- (void)asyncWriteData: (OFData *)data
runLoopMode: (of_run_loop_mode_t)runLoopMode
block: (of_stream_async_write_data_block_t)block
{
OFStream <OFReadyForWritingObserving> *stream =
(OFStream <OFReadyForWritingObserving> *)self;
[OFRunLoop of_addAsyncWriteForStream: stream
data: data
mode: runLoopMode
block: block
delegate: nil];
}
- (void)asyncWriteString: (OFString *)string
block: (of_stream_async_write_string_block_t)block
{
[self asyncWriteString: string
encoding: OFStringEncodingUTF8
runLoopMode: of_run_loop_mode_default
block: block];
}
- (void)asyncWriteString: (OFString *)string
encoding: (OFStringEncoding)encoding
block: (of_stream_async_write_string_block_t)block
{
[self asyncWriteString: string
encoding: encoding
runLoopMode: of_run_loop_mode_default
block: block];
}
- (void)asyncWriteString: (OFString *)string
encoding: (OFStringEncoding)encoding
runLoopMode: (of_run_loop_mode_t)runLoopMode
block: (of_stream_async_write_string_block_t)block
{
OFStream <OFReadyForWritingObserving> *stream =
(OFStream <OFReadyForWritingObserving> *)self;
[OFRunLoop of_addAsyncWriteForStream: stream
string: string
encoding: encoding
|
|
<
|
|
|
|
|
1143
1144
1145
1146
1147
1148
1149
1150
1151
1152
1153
1154
1155
1156
1157
1158
1159
1160
1161
1162
1163
1164
1165
1166
1167
1168
1169
1170
1171
1172
1173
1174
1175
1176
1177
1178
1179
1180
1181
1182
1183
1184
1185
1186
1187
1188
1189
1190
1191
1192
1193
1194
1195
1196
1197
1198
1199
1200
|
# ifdef OF_HAVE_BLOCKS
block: NULL
# endif
delegate: _delegate];
}
# ifdef OF_HAVE_BLOCKS
- (void)asyncWriteData: (OFData *)data block: (OFStreamAsyncWriteDataBlock)block
{
[self asyncWriteData: data
runLoopMode: of_run_loop_mode_default
block: block];
}
- (void)asyncWriteData: (OFData *)data
runLoopMode: (of_run_loop_mode_t)runLoopMode
block: (OFStreamAsyncWriteDataBlock)block
{
OFStream <OFReadyForWritingObserving> *stream =
(OFStream <OFReadyForWritingObserving> *)self;
[OFRunLoop of_addAsyncWriteForStream: stream
data: data
mode: runLoopMode
block: block
delegate: nil];
}
- (void)asyncWriteString: (OFString *)string
block: (OFStreamAsyncWriteStringBlock)block
{
[self asyncWriteString: string
encoding: OFStringEncodingUTF8
runLoopMode: of_run_loop_mode_default
block: block];
}
- (void)asyncWriteString: (OFString *)string
encoding: (OFStringEncoding)encoding
block: (OFStreamAsyncWriteStringBlock)block
{
[self asyncWriteString: string
encoding: encoding
runLoopMode: of_run_loop_mode_default
block: block];
}
- (void)asyncWriteString: (OFString *)string
encoding: (OFStringEncoding)encoding
runLoopMode: (of_run_loop_mode_t)runLoopMode
block: (OFStreamAsyncWriteStringBlock)block
{
OFStream <OFReadyForWritingObserving> *stream =
(OFStream <OFReadyForWritingObserving> *)self;
[OFRunLoop of_addAsyncWriteForStream: stream
string: string
encoding: encoding
|
︙ | | | ︙ | |
Modified src/OFStreamSocket.h
from [27f4a02196]
to [53fd37ea6a].
︙ | | | ︙ | |
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
|
*
* @param acceptedSocket The socket which has been accepted
* @param exception An exception which occurred while accepting the socket or
* `nil` on success
* @return A bool whether the same block should be used for the next incoming
* connection
*/
typedef bool (^of_stream_socket_async_accept_block_t)(
OFStreamSocket *acceptedSocket, id _Nullable exception);
#endif
/**
* @protocol OFStreamSocketDelegate OFStreamSocket.h ObjFW/OFStreamSocket.h
*
* A delegate for OFStreamSocket.
*/
|
|
|
|
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
|
*
* @param acceptedSocket The socket which has been accepted
* @param exception An exception which occurred while accepting the socket or
* `nil` on success
* @return A bool whether the same block should be used for the next incoming
* connection
*/
typedef bool (^OFStreamSocketAsyncAcceptBlock)(OFStreamSocket *acceptedSocket,
id _Nullable exception);
#endif
/**
* @protocol OFStreamSocketDelegate OFStreamSocket.h ObjFW/OFStreamSocket.h
*
* A delegate for OFStreamSocket.
*/
|
︙ | | | ︙ | |
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
|
/**
* @brief Asynchronously accept an incoming connection.
*
* @param block The block to execute when a new connection has been accepted.
* Returns whether the next incoming connection should be accepted
* by the specified block as well.
*/
- (void)asyncAcceptWithBlock: (of_stream_socket_async_accept_block_t)block;
/**
* @brief Asynchronously accept an incoming connection.
*
* @param runLoopMode The run loop mode in which to perform the async accept
* @param block The block to execute when a new connection has been accepted.
* Returns whether the next incoming connection should be accepted
* by the specified block as well.
*/
- (void)asyncAcceptWithRunLoopMode: (of_run_loop_mode_t)runLoopMode
block: (of_stream_socket_async_accept_block_t)
block;
#endif
@end
OF_ASSUME_NONNULL_END
|
|
<
|
|
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
|
/**
* @brief Asynchronously accept an incoming connection.
*
* @param block The block to execute when a new connection has been accepted.
* Returns whether the next incoming connection should be accepted
* by the specified block as well.
*/
- (void)asyncAcceptWithBlock: (OFStreamSocketAsyncAcceptBlock)block;
/**
* @brief Asynchronously accept an incoming connection.
*
* @param runLoopMode The run loop mode in which to perform the async accept
* @param block The block to execute when a new connection has been accepted.
* Returns whether the next incoming connection should be accepted
* by the specified block as well.
*/
- (void)asyncAcceptWithRunLoopMode: (of_run_loop_mode_t)runLoopMode
block: (OFStreamSocketAsyncAcceptBlock)block;
#endif
@end
OF_ASSUME_NONNULL_END
|
Modified src/OFStreamSocket.m
from [7f5d88caa9]
to [ac4dcd7238].
︙ | | | ︙ | |
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
|
[OFRunLoop of_addAsyncAcceptForSocket: self
mode: runLoopMode
block: NULL
delegate: _delegate];
}
#ifdef OF_HAVE_BLOCKS
- (void)asyncAcceptWithBlock: (of_stream_socket_async_accept_block_t)block
{
[self asyncAcceptWithRunLoopMode: of_run_loop_mode_default
block: block];
}
- (void)asyncAcceptWithRunLoopMode: (of_run_loop_mode_t)runLoopMode
block: (of_stream_socket_async_accept_block_t)block
{
[OFRunLoop of_addAsyncAcceptForSocket: self
mode: runLoopMode
block: block
delegate: nil];
}
#endif
|
|
|
|
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
|
[OFRunLoop of_addAsyncAcceptForSocket: self
mode: runLoopMode
block: NULL
delegate: _delegate];
}
#ifdef OF_HAVE_BLOCKS
- (void)asyncAcceptWithBlock: (OFStreamSocketAsyncAcceptBlock)block
{
[self asyncAcceptWithRunLoopMode: of_run_loop_mode_default
block: block];
}
- (void)asyncAcceptWithRunLoopMode: (of_run_loop_mode_t)runLoopMode
block: (OFStreamSocketAsyncAcceptBlock)block
{
[OFRunLoop of_addAsyncAcceptForSocket: self
mode: runLoopMode
block: block
delegate: nil];
}
#endif
|
︙ | | | ︙ | |
Modified src/OFString+XMLUnescaping.h
from [d4c2a5d60a]
to [cbe997ff43].
︙ | | | ︙ | |
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
|
* @brief A block which is called to replace unknown XML entities in an XML
* string.
*
* @param string The XML string which contains an unknown entity
* @param entity The XML entity which is unknown
* @return A replacement string for the unknown entity
*/
typedef OFString *_Nullable (^of_string_xml_unescaping_block_t)(
OFString *string, OFString *entity);
#endif
/**
* @protocol OFStringXMLUnescapingDelegate OFString.h ObjFW/OFString.h
*
* @brief A protocol that needs to be implemented by delegates for
* stringByXMLUnescapingWithHandler:.
|
|
|
|
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
|
* @brief A block which is called to replace unknown XML entities in an XML
* string.
*
* @param string The XML string which contains an unknown entity
* @param entity The XML entity which is unknown
* @return A replacement string for the unknown entity
*/
typedef OFString *_Nullable (^OFStringXMLUnescapingBlock)(OFString *string,
OFString *entity);
#endif
/**
* @protocol OFStringXMLUnescapingDelegate OFString.h ObjFW/OFString.h
*
* @brief A protocol that needs to be implemented by delegates for
* stringByXMLUnescapingWithHandler:.
|
︙ | | | ︙ | |
81
82
83
84
85
86
87
88
89
90
91
92
93
|
#ifdef OF_HAVE_BLOCKS
/**
* @brief Unescapes XML in the string and uses the specified block for unknown
* entities.
*
* @param block A block which handles unknown entities
*/
- (OFString *)stringByXMLUnescapingWithBlock:
(of_string_xml_unescaping_block_t)block;
#endif
@end
OF_ASSUME_NONNULL_END
|
|
<
|
81
82
83
84
85
86
87
88
89
90
91
92
|
#ifdef OF_HAVE_BLOCKS
/**
* @brief Unescapes XML in the string and uses the specified block for unknown
* entities.
*
* @param block A block which handles unknown entities
*/
- (OFString *)stringByXMLUnescapingWithBlock: (OFStringXMLUnescapingBlock)block;
#endif
@end
OF_ASSUME_NONNULL_END
|
Modified src/OFString+XMLUnescaping.m
from [4b3564a7f2]
to [0a903f9009].
︙ | | | ︙ | |
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
|
return [delegate string: self containsUnknownEntityNamed: entity];
}
#ifdef OF_HAVE_BLOCKS
static id
lookupUsingBlock(void *context, OFString *self, OFString *entity)
{
of_string_xml_unescaping_block_t block = context;
if (block == NULL)
return nil;
return block(self, entity);
}
#endif
|
|
|
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
|
return [delegate string: self containsUnknownEntityNamed: entity];
}
#ifdef OF_HAVE_BLOCKS
static id
lookupUsingBlock(void *context, OFString *self, OFString *entity)
{
OFStringXMLUnescapingBlock block = context;
if (block == NULL)
return nil;
return block(self, entity);
}
#endif
|
︙ | | | ︙ | |
208
209
210
211
212
213
214
215
216
217
218
219
220
221
|
- (OFString *)stringByXMLUnescapingWithDelegate:
(id <OFStringXMLUnescapingDelegate>)delegate
{
return parseEntities(self, lookupUsingDelegate, delegate);
}
#ifdef OF_HAVE_BLOCKS
- (OFString *)stringByXMLUnescapingWithBlock:
(of_string_xml_unescaping_block_t)block
{
return parseEntities(self, lookupUsingBlock, block);
}
#endif
@end
|
|
<
|
208
209
210
211
212
213
214
215
216
217
218
219
220
|
- (OFString *)stringByXMLUnescapingWithDelegate:
(id <OFStringXMLUnescapingDelegate>)delegate
{
return parseEntities(self, lookupUsingDelegate, delegate);
}
#ifdef OF_HAVE_BLOCKS
- (OFString *)stringByXMLUnescapingWithBlock: (OFStringXMLUnescapingBlock)block
{
return parseEntities(self, lookupUsingBlock, block);
}
#endif
@end
|
Modified src/OFString.h
from [686eedcec8]
to [c20eafef33].
︙ | | | ︙ | |
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
|
/**
* @brief A block for enumerating the lines of a string.
*
* @param line The current line
* @param stop A pointer to a variable that can be set to true to stop the
* enumeration
*/
typedef void (^of_string_line_enumeration_block_t)(OFString *line, bool *stop);
#endif
#ifdef __OBJC__
@class OFArray OF_GENERIC(ObjectType);
@class OFCharacterSet;
@class OFURL;
|
|
|
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
|
/**
* @brief A block for enumerating the lines of a string.
*
* @param line The current line
* @param stop A pointer to a variable that can be set to true to stop the
* enumeration
*/
typedef void (^OFStringLineEnumerationBlock)(OFString *line, bool *stop);
#endif
#ifdef __OBJC__
@class OFArray OF_GENERIC(ObjectType);
@class OFCharacterSet;
@class OFURL;
|
︙ | | | ︙ | |
1259
1260
1261
1262
1263
1264
1265
1266
1267
1268
1269
1270
1271
1272
1273
|
# ifdef OF_HAVE_BLOCKS
/**
* Enumerates all lines in the receiver using the specified block.
*
* @brief block The block to call for each line
*/
- (void)enumerateLinesUsingBlock: (of_string_line_enumeration_block_t)block;
# endif
@end
#endif
#ifdef __cplusplus
extern "C" {
#endif
|
|
|
1259
1260
1261
1262
1263
1264
1265
1266
1267
1268
1269
1270
1271
1272
1273
|
# ifdef OF_HAVE_BLOCKS
/**
* Enumerates all lines in the receiver using the specified block.
*
* @brief block The block to call for each line
*/
- (void)enumerateLinesUsingBlock: (OFStringLineEnumerationBlock)block;
# endif
@end
#endif
#ifdef __cplusplus
extern "C" {
#endif
|
︙ | | | ︙ | |
Modified src/OFString.m
from [173940368f]
to [8bdf1a14a9].
︙ | | | ︙ | |
2739
2740
2741
2742
2743
2744
2745
2746
2747
2748
2749
2750
2751
2752
2753
|
stream = [URLHandler openItemAtURL: URL mode: @"w"];
[stream writeString: self encoding: encoding];
objc_autoreleasePoolPop(pool);
}
#ifdef OF_HAVE_BLOCKS
- (void)enumerateLinesUsingBlock: (of_string_line_enumeration_block_t)block
{
void *pool = objc_autoreleasePoolPush();
const OFUnichar *characters = self.characters;
size_t i, last = 0, length = self.length;
bool stop = false, lastCarriageReturn = false;
for (i = 0; i < length && !stop; i++) {
|
|
|
2739
2740
2741
2742
2743
2744
2745
2746
2747
2748
2749
2750
2751
2752
2753
|
stream = [URLHandler openItemAtURL: URL mode: @"w"];
[stream writeString: self encoding: encoding];
objc_autoreleasePoolPop(pool);
}
#ifdef OF_HAVE_BLOCKS
- (void)enumerateLinesUsingBlock: (OFStringLineEnumerationBlock)block
{
void *pool = objc_autoreleasePoolPush();
const OFUnichar *characters = self.characters;
size_t i, last = 0, length = self.length;
bool stop = false, lastCarriageReturn = false;
for (i = 0; i < length && !stop; i++) {
|
︙ | | | ︙ | |
Modified src/OFTCPSocket.h
from [b81cee61b1]
to [1696dc957f].
︙ | | | ︙ | |
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
|
#ifdef OF_HAVE_BLOCKS
/**
* @brief A block which is called when the socket connected.
*
* @param exception An exception which occurred while connecting the socket or
* `nil` on success
*/
typedef void (^of_tcp_socket_async_connect_block_t)(id _Nullable exception);
#endif
/**
* @protocol OFTCPSocketDelegate OFTCPSocket.h ObjFW/OFTCPSocket.h
*
* A delegate for OFTCPSocket.
*/
|
|
|
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
|
#ifdef OF_HAVE_BLOCKS
/**
* @brief A block which is called when the socket connected.
*
* @param exception An exception which occurred while connecting the socket or
* `nil` on success
*/
typedef void (^OFTCPSocketAsyncConnectBlock)(id _Nullable exception);
#endif
/**
* @protocol OFTCPSocketDelegate OFTCPSocket.h ObjFW/OFTCPSocket.h
*
* A delegate for OFTCPSocket.
*/
|
︙ | | | ︙ | |
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
|
*
* @param host The host to connect to
* @param port The port on the host to connect to
* @param block The block to execute once the connection has been established
*/
- (void)asyncConnectToHost: (OFString *)host
port: (uint16_t)port
block: (of_tcp_socket_async_connect_block_t)block;
/**
* @brief Asynchronously connect the OFTCPSocket to the specified destination.
*
* @param host The host to connect to
* @param port The port on the host to connect to
* @param runLoopMode The run loop mode in which to perform the async connect
* @param block The block to execute once the connection has been established
*/
- (void)asyncConnectToHost: (OFString *)host
port: (uint16_t)port
runLoopMode: (of_run_loop_mode_t)runLoopMode
block: (of_tcp_socket_async_connect_block_t)block;
#endif
/**
* @brief Bind the socket to the specified host and port.
*
* @param host The host to bind to. Use `@"0.0.0.0"` for IPv4 or `@"::"` for
* IPv6 to bind to all.
|
|
|
|
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
|
*
* @param host The host to connect to
* @param port The port on the host to connect to
* @param block The block to execute once the connection has been established
*/
- (void)asyncConnectToHost: (OFString *)host
port: (uint16_t)port
block: (OFTCPSocketAsyncConnectBlock)block;
/**
* @brief Asynchronously connect the OFTCPSocket to the specified destination.
*
* @param host The host to connect to
* @param port The port on the host to connect to
* @param runLoopMode The run loop mode in which to perform the async connect
* @param block The block to execute once the connection has been established
*/
- (void)asyncConnectToHost: (OFString *)host
port: (uint16_t)port
runLoopMode: (of_run_loop_mode_t)runLoopMode
block: (OFTCPSocketAsyncConnectBlock)block;
#endif
/**
* @brief Bind the socket to the specified host and port.
*
* @param host The host to bind to. Use `@"0.0.0.0"` for IPv4 or `@"::"` for
* IPv6 to bind to all.
|
︙ | | | ︙ | |
Modified src/OFTCPSocket.m
from [5cdf6dd0d8]
to [95d1a09274].
︙ | | | ︙ | |
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
|
objc_autoreleasePoolPop(pool);
}
#ifdef OF_HAVE_BLOCKS
- (void)asyncConnectToHost: (OFString *)host
port: (uint16_t)port
block: (of_tcp_socket_async_connect_block_t)block
{
[self asyncConnectToHost: host
port: port
runLoopMode: of_run_loop_mode_default
block: block];
}
- (void)asyncConnectToHost: (OFString *)host
port: (uint16_t)port
runLoopMode: (of_run_loop_mode_t)runLoopMode
block: (of_tcp_socket_async_connect_block_t)block
{
void *pool = objc_autoreleasePoolPush();
id <OFTCPSocketDelegate> delegate = nil;
if (_socket != INVALID_SOCKET)
@throw [OFAlreadyConnectedException exceptionWithSocket: self];
|
|
|
|
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
|
objc_autoreleasePoolPop(pool);
}
#ifdef OF_HAVE_BLOCKS
- (void)asyncConnectToHost: (OFString *)host
port: (uint16_t)port
block: (OFTCPSocketAsyncConnectBlock)block
{
[self asyncConnectToHost: host
port: port
runLoopMode: of_run_loop_mode_default
block: block];
}
- (void)asyncConnectToHost: (OFString *)host
port: (uint16_t)port
runLoopMode: (of_run_loop_mode_t)runLoopMode
block: (OFTCPSocketAsyncConnectBlock)block
{
void *pool = objc_autoreleasePoolPush();
id <OFTCPSocketDelegate> delegate = nil;
if (_socket != INVALID_SOCKET)
@throw [OFAlreadyConnectedException exceptionWithSocket: self];
|
︙ | | | ︙ | |
Modified src/OFTCPSocketSOCKS5Connector.h
from [edab2535a4]
to [2e0767356b].
︙ | | | ︙ | |
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
|
@interface OFTCPSocketSOCKS5Connector: OFObject <OFTCPSocketDelegate>
{
OFTCPSocket *_socket;
OFString *_host;
uint16_t _port;
id <OFTCPSocketDelegate> _Nullable _delegate;
#ifdef OF_HAVE_BLOCKS
of_tcp_socket_async_connect_block_t _Nullable _block;
#endif
id _Nullable _exception;
enum {
OF_SOCKS5_STATE_SEND_AUTHENTICATION = 1,
OF_SOCKS5_STATE_READ_VERSION,
OF_SOCKS5_STATE_SEND_REQUEST,
OF_SOCKS5_STATE_READ_RESPONSE,
OF_SOCKS5_STATE_READ_ADDRESS,
OF_SOCKS5_STATE_READ_ADDRESS_LENGTH,
} _SOCKS5State;
/* Longest read is domain name (max 255 bytes) + port */
unsigned char _buffer[257];
OFMutableData *_Nullable _request;
}
- (instancetype)initWithSocket: (OFTCPSocket *)sock
host: (OFString *)host
port: (uint16_t)port
delegate: (nullable id <OFTCPSocketDelegate>)delegate
#ifdef OF_HAVE_BLOCKS
block: (nullable of_tcp_socket_async_connect_block_t)
block
#endif
;
- (void)didConnect;
@end
OF_ASSUME_NONNULL_END
|
|
|
<
|
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
|
@interface OFTCPSocketSOCKS5Connector: OFObject <OFTCPSocketDelegate>
{
OFTCPSocket *_socket;
OFString *_host;
uint16_t _port;
id <OFTCPSocketDelegate> _Nullable _delegate;
#ifdef OF_HAVE_BLOCKS
OFTCPSocketAsyncConnectBlock _Nullable _block;
#endif
id _Nullable _exception;
enum {
OF_SOCKS5_STATE_SEND_AUTHENTICATION = 1,
OF_SOCKS5_STATE_READ_VERSION,
OF_SOCKS5_STATE_SEND_REQUEST,
OF_SOCKS5_STATE_READ_RESPONSE,
OF_SOCKS5_STATE_READ_ADDRESS,
OF_SOCKS5_STATE_READ_ADDRESS_LENGTH,
} _SOCKS5State;
/* Longest read is domain name (max 255 bytes) + port */
unsigned char _buffer[257];
OFMutableData *_Nullable _request;
}
- (instancetype)initWithSocket: (OFTCPSocket *)sock
host: (OFString *)host
port: (uint16_t)port
delegate: (nullable id <OFTCPSocketDelegate>)delegate
#ifdef OF_HAVE_BLOCKS
block: (nullable OFTCPSocketAsyncConnectBlock)block
#endif
;
- (void)didConnect;
@end
OF_ASSUME_NONNULL_END
|
Modified src/OFTCPSocketSOCKS5Connector.m
from [777126a470]
to [1ba6ee5625].
︙ | | | ︙ | |
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
|
@implementation OFTCPSocketSOCKS5Connector
- (instancetype)initWithSocket: (OFTCPSocket *)sock
host: (OFString *)host
port: (uint16_t)port
delegate: (id <OFTCPSocketDelegate>)delegate
#ifdef OF_HAVE_BLOCKS
block: (of_tcp_socket_async_connect_block_t)block
#endif
{
self = [super init];
@try {
_socket = [sock retain];
_host = [host copy];
|
|
|
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
|
@implementation OFTCPSocketSOCKS5Connector
- (instancetype)initWithSocket: (OFTCPSocket *)sock
host: (OFString *)host
port: (uint16_t)port
delegate: (id <OFTCPSocketDelegate>)delegate
#ifdef OF_HAVE_BLOCKS
block: (OFTCPSocketAsyncConnectBlock)block
#endif
{
self = [super init];
@try {
_socket = [sock retain];
_host = [host copy];
|
︙ | | | ︙ | |
Modified src/OFThread.h
from [ac920e666c]
to [4486e81af4].
︙ | | | ︙ | |
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
|
#if defined(OF_HAVE_THREADS) && defined(OF_HAVE_BLOCKS)
/**
* @brief A block to be executed in a new thread.
*
* @return The object which should be returned when the thread is joined
*/
typedef id _Nullable (^of_thread_block_t)(void);
#endif
/**
* @class OFThread OFThread.h ObjFW/OFThread.h
*
* @brief A class which provides portable threads.
*
|
|
|
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
|
#if defined(OF_HAVE_THREADS) && defined(OF_HAVE_BLOCKS)
/**
* @brief A block to be executed in a new thread.
*
* @return The object which should be returned when the thread is joined
*/
typedef id _Nullable (^OFThreadBlock)(void);
#endif
/**
* @class OFThread OFThread.h ObjFW/OFThread.h
*
* @brief A class which provides portable threads.
*
|
︙ | | | ︙ | |
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
|
OF_THREAD_RUNNING,
OF_THREAD_WAITING_FOR_JOIN
} _running;
# ifndef OF_OBJFW_RUNTIME
void *_pool;
# endif
# ifdef OF_HAVE_BLOCKS
of_thread_block_t _Nullable _threadBlock;
# endif
jmp_buf _exitEnv;
id _returnValue;
bool _supportsSockets;
OFRunLoop *_Nullable _runLoop;
OFMutableDictionary *_threadDictionary;
OFString *_Nullable _name;
|
|
|
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
|
OF_THREAD_RUNNING,
OF_THREAD_WAITING_FOR_JOIN
} _running;
# ifndef OF_OBJFW_RUNTIME
void *_pool;
# endif
# ifdef OF_HAVE_BLOCKS
OFThreadBlock _Nullable _threadBlock;
# endif
jmp_buf _exitEnv;
id _returnValue;
bool _supportsSockets;
OFRunLoop *_Nullable _runLoop;
OFMutableDictionary *_threadDictionary;
OFString *_Nullable _name;
|
︙ | | | ︙ | |
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
|
*/
@property OF_NULLABLE_PROPERTY (copy) OFString *name;
# ifdef OF_HAVE_BLOCKS
/**
* @brief The block to execute in the thread.
*/
@property OF_NULLABLE_PROPERTY (readonly, nonatomic)
of_thread_block_t threadBlock;
# endif
/**
* @brief The run loop for the thread.
*/
@property (readonly, nonatomic) OFRunLoop *runLoop;
|
|
<
|
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
|
*/
@property OF_NULLABLE_PROPERTY (copy) OFString *name;
# ifdef OF_HAVE_BLOCKS
/**
* @brief The block to execute in the thread.
*/
@property OF_NULLABLE_PROPERTY (readonly, nonatomic) OFThreadBlock threadBlock;
# endif
/**
* @brief The run loop for the thread.
*/
@property (readonly, nonatomic) OFRunLoop *runLoop;
|
︙ | | | ︙ | |
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
|
# ifdef OF_HAVE_BLOCKS
/**
* @brief Creates a new thread with the specified block.
*
* @param threadBlock A block which is executed by the thread
* @return A new, autoreleased thread
*/
+ (instancetype)threadWithThreadBlock: (of_thread_block_t)threadBlock;
# endif
/**
* @brief Returns the current thread.
*
* @return The current thread
*/
|
|
|
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
|
# ifdef OF_HAVE_BLOCKS
/**
* @brief Creates a new thread with the specified block.
*
* @param threadBlock A block which is executed by the thread
* @return A new, autoreleased thread
*/
+ (instancetype)threadWithThreadBlock: (OFThreadBlock)threadBlock;
# endif
/**
* @brief Returns the current thread.
*
* @return The current thread
*/
|
︙ | | | ︙ | |
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
|
# ifdef OF_HAVE_BLOCKS
/**
* @brief Initializes an already allocated thread with the specified block.
*
* @param threadBlock A block which is executed by the thread
* @return An initialized OFThread.
*/
- (instancetype)initWithThreadBlock: (of_thread_block_t)threadBlock;
# endif
/**
* @brief The main routine of the thread. You need to reimplement this!
*
* @return The object the join method should return when called for this thread
*/
|
|
|
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
|
# ifdef OF_HAVE_BLOCKS
/**
* @brief Initializes an already allocated thread with the specified block.
*
* @param threadBlock A block which is executed by the thread
* @return An initialized OFThread.
*/
- (instancetype)initWithThreadBlock: (OFThreadBlock)threadBlock;
# endif
/**
* @brief The main routine of the thread. You need to reimplement this!
*
* @return The object the join method should return when called for this thread
*/
|
︙ | | | ︙ | |
Modified src/OFThread.m
from [304aef013f]
to [edb1078c84].
︙ | | | ︙ | |
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
|
+ (instancetype)thread
{
return [[[self alloc] init] autorelease];
}
# ifdef OF_HAVE_BLOCKS
+ (instancetype)threadWithThreadBlock: (of_thread_block_t)threadBlock
{
return [[[self alloc] initWithThreadBlock: threadBlock] autorelease];
}
# endif
+ (OFThread *)currentThread
{
|
|
|
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
|
+ (instancetype)thread
{
return [[[self alloc] init] autorelease];
}
# ifdef OF_HAVE_BLOCKS
+ (instancetype)threadWithThreadBlock: (OFThreadBlock)threadBlock
{
return [[[self alloc] initWithThreadBlock: threadBlock] autorelease];
}
# endif
+ (OFThread *)currentThread
{
|
︙ | | | ︙ | |
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
|
@throw e;
}
return self;
}
# ifdef OF_HAVE_BLOCKS
- (instancetype)initWithThreadBlock: (of_thread_block_t)threadBlock
{
self = [self init];
@try {
_threadBlock = [threadBlock copy];
} @catch (id e) {
[self release];
|
|
|
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
|
@throw e;
}
return self;
}
# ifdef OF_HAVE_BLOCKS
- (instancetype)initWithThreadBlock: (OFThreadBlock)threadBlock
{
self = [self init];
@try {
_threadBlock = [threadBlock copy];
} @catch (id e) {
[self release];
|
︙ | | | ︙ | |
Modified src/OFThreadPool.h
from [7948e1d39c]
to [4da774feaf].
︙ | | | ︙ | |
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
|
/** @file */
#ifdef OF_HAVE_BLOCKS
/**
* @brief A block for a job which should be executed in a thread pool.
*/
typedef void (^of_thread_pool_block_t)(void);
#endif
@class OFCondition;
@class OFList OF_GENERIC(ObjectType);
@class OFMutableArray OF_GENERIC(ObjectType);
@class OFThreadPoolJob;
|
|
|
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
|
/** @file */
#ifdef OF_HAVE_BLOCKS
/**
* @brief A block for a job which should be executed in a thread pool.
*/
typedef void (^OFThreadPoolBlock)(void);
#endif
@class OFCondition;
@class OFList OF_GENERIC(ObjectType);
@class OFMutableArray OF_GENERIC(ObjectType);
@class OFThreadPoolJob;
|
︙ | | | ︙ | |
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
|
#ifdef OF_HAVE_BLOCKS
/**
* @brief Executes the specified block as soon as a thread is ready.
*
* @param block The block to execute
*/
- (void)dispatchWithBlock: (of_thread_pool_block_t)block;
#endif
/**
* @brief Waits until all jobs are done.
*/
- (void)waitUntilDone;
@end
OF_ASSUME_NONNULL_END
|
|
|
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
|
#ifdef OF_HAVE_BLOCKS
/**
* @brief Executes the specified block as soon as a thread is ready.
*
* @param block The block to execute
*/
- (void)dispatchWithBlock: (OFThreadPoolBlock)block;
#endif
/**
* @brief Waits until all jobs are done.
*/
- (void)waitUntilDone;
@end
OF_ASSUME_NONNULL_END
|
Modified src/OFThreadPool.m
from [1d33cef32f]
to [ae8a5813e0].
︙ | | | ︙ | |
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
|
OF_DIRECT_MEMBERS
@interface OFThreadPoolJob: OFObject
{
id _target;
SEL _selector;
id _object;
#ifdef OF_HAVE_BLOCKS
of_thread_pool_block_t _block;
#endif
}
- (instancetype)initWithTarget: (id)target
selector: (SEL)selector
object: (id)object;
#ifdef OF_HAVE_BLOCKS
- (instancetype)initWithBlock: (of_thread_pool_block_t)block;
#endif
- (void)perform;
@end
@implementation OFThreadPoolJob
- (instancetype)initWithTarget: (id)target
selector: (SEL)selector
|
|
|
|
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
|
OF_DIRECT_MEMBERS
@interface OFThreadPoolJob: OFObject
{
id _target;
SEL _selector;
id _object;
#ifdef OF_HAVE_BLOCKS
OFThreadPoolBlock _block;
#endif
}
- (instancetype)initWithTarget: (id)target
selector: (SEL)selector
object: (id)object;
#ifdef OF_HAVE_BLOCKS
- (instancetype)initWithBlock: (OFThreadPoolBlock)block;
#endif
- (void)perform;
@end
@implementation OFThreadPoolJob
- (instancetype)initWithTarget: (id)target
selector: (SEL)selector
|
︙ | | | ︙ | |
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
|
@throw e;
}
return self;
}
#ifdef OF_HAVE_BLOCKS
- (instancetype)initWithBlock: (of_thread_pool_block_t)block
{
self = [super init];
@try {
_block = [block copy];
} @catch (id e) {
[self release];
|
|
|
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
|
@throw e;
}
return self;
}
#ifdef OF_HAVE_BLOCKS
- (instancetype)initWithBlock: (OFThreadPoolBlock)block
{
self = [super init];
@try {
_block = [block copy];
} @catch (id e) {
[self release];
|
︙ | | | ︙ | |
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
|
[self of_dispatchJob: job];
} @finally {
[job release];
}
}
#ifdef OF_HAVE_BLOCKS
- (void)dispatchWithBlock: (of_thread_pool_block_t)block
{
OFThreadPoolJob *job = [[OFThreadPoolJob alloc] initWithBlock: block];
@try {
[self of_dispatchJob: job];
} @finally {
[job release];
}
|
|
|
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
|
[self of_dispatchJob: job];
} @finally {
[job release];
}
}
#ifdef OF_HAVE_BLOCKS
- (void)dispatchWithBlock: (OFThreadPoolBlock)block
{
OFThreadPoolJob *job = [[OFThreadPoolJob alloc] initWithBlock: block];
@try {
[self of_dispatchJob: job];
} @finally {
[job release];
}
|
︙ | | | ︙ | |
Modified src/OFTimer.h
from [b4310df08c]
to [e6818096dc].
︙ | | | ︙ | |
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
|
#ifdef OF_HAVE_BLOCKS
/**
* @brief A block to execute when a timer fires.
*
* @param timer The timer which fired
*/
typedef void (^of_timer_block_t)(OFTimer *timer);
#endif
/**
* @class OFTimer OFTimer.h ObjFW/OFTimer.h
*
* @brief A class for creating and firing timers.
*/
OF_SUBCLASSING_RESTRICTED
@interface OFTimer: OFObject <OFComparing>
{
OFDate *_fireDate;
OFTimeInterval _interval;
id _target;
id _Nullable _object1, _object2, _object3, _object4;
SEL _selector;
unsigned char _arguments;
bool _repeats;
#ifdef OF_HAVE_BLOCKS
of_timer_block_t _block;
#endif
bool _valid;
#ifdef OF_HAVE_THREADS
OFCondition *_condition;
bool _done;
#endif
OFRunLoop *_Nullable _inRunLoop;
|
|
|
|
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
|
#ifdef OF_HAVE_BLOCKS
/**
* @brief A block to execute when a timer fires.
*
* @param timer The timer which fired
*/
typedef void (^OFTimerBlock)(OFTimer *timer);
#endif
/**
* @class OFTimer OFTimer.h ObjFW/OFTimer.h
*
* @brief A class for creating and firing timers.
*/
OF_SUBCLASSING_RESTRICTED
@interface OFTimer: OFObject <OFComparing>
{
OFDate *_fireDate;
OFTimeInterval _interval;
id _target;
id _Nullable _object1, _object2, _object3, _object4;
SEL _selector;
unsigned char _arguments;
bool _repeats;
#ifdef OF_HAVE_BLOCKS
OFTimerBlock _block;
#endif
bool _valid;
#ifdef OF_HAVE_THREADS
OFCondition *_condition;
bool _done;
#endif
OFRunLoop *_Nullable _inRunLoop;
|
︙ | | | ︙ | |
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
|
* @param timeInterval The time interval after which the timer should be fired
* @param repeats Whether the timer repeats after it has been executed
* @param block The block to invoke when the timer fires
* @return A new, autoreleased timer
*/
+ (instancetype)scheduledTimerWithTimeInterval: (OFTimeInterval)timeInterval
repeats: (bool)repeats
block: (of_timer_block_t)block;
#endif
/**
* @brief Creates a new timer with the specified time interval.
*
* @param timeInterval The time interval after which the timer should be fired
* @param target The target on which to call the selector
|
|
|
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
|
* @param timeInterval The time interval after which the timer should be fired
* @param repeats Whether the timer repeats after it has been executed
* @param block The block to invoke when the timer fires
* @return A new, autoreleased timer
*/
+ (instancetype)scheduledTimerWithTimeInterval: (OFTimeInterval)timeInterval
repeats: (bool)repeats
block: (OFTimerBlock)block;
#endif
/**
* @brief Creates a new timer with the specified time interval.
*
* @param timeInterval The time interval after which the timer should be fired
* @param target The target on which to call the selector
|
︙ | | | ︙ | |
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
|
* @param timeInterval The time interval after which the timer should be fired
* @param repeats Whether the timer repeats after it has been executed
* @param block The block to invoke when the timer fires
* @return A new, autoreleased timer
*/
+ (instancetype)timerWithTimeInterval: (OFTimeInterval)timeInterval
repeats: (bool)repeats
block: (of_timer_block_t)block;
#endif
- (instancetype)init OF_UNAVAILABLE;
/**
* @brief Initializes an already allocated timer with the specified time
* interval.
|
|
|
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
|
* @param timeInterval The time interval after which the timer should be fired
* @param repeats Whether the timer repeats after it has been executed
* @param block The block to invoke when the timer fires
* @return A new, autoreleased timer
*/
+ (instancetype)timerWithTimeInterval: (OFTimeInterval)timeInterval
repeats: (bool)repeats
block: (OFTimerBlock)block;
#endif
- (instancetype)init OF_UNAVAILABLE;
/**
* @brief Initializes an already allocated timer with the specified time
* interval.
|
︙ | | | ︙ | |
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
|
* @param repeats Whether the timer repeats after it has been executed
* @param block The block to invoke when the timer fires
* @return An initialized timer
*/
- (instancetype)initWithFireDate: (OFDate *)fireDate
interval: (OFTimeInterval)interval
repeats: (bool)repeats
block: (of_timer_block_t)block;
#endif
/**
* @brief Compares the timer to another timer.
*
* @param timer The timer to compare the string to
* @return The result of the comparison
|
|
|
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
|
* @param repeats Whether the timer repeats after it has been executed
* @param block The block to invoke when the timer fires
* @return An initialized timer
*/
- (instancetype)initWithFireDate: (OFDate *)fireDate
interval: (OFTimeInterval)interval
repeats: (bool)repeats
block: (OFTimerBlock)block;
#endif
/**
* @brief Compares the timer to another timer.
*
* @param timer The timer to compare the string to
* @return The result of the comparison
|
︙ | | | ︙ | |
Modified src/OFTimer.m
from [fc8cefbc96]
to [f12435550c].
︙ | | | ︙ | |
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
|
return [timer autorelease];
}
#ifdef OF_HAVE_BLOCKS
+ (instancetype)scheduledTimerWithTimeInterval: (OFTimeInterval)timeInterval
repeats: (bool)repeats
block: (of_timer_block_t)block
{
void *pool = objc_autoreleasePoolPush();
OFDate *fireDate = [OFDate dateWithTimeIntervalSinceNow: timeInterval];
id timer = [[[self alloc] initWithFireDate: fireDate
interval: timeInterval
repeats: repeats
block: block] autorelease];
|
|
|
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
|
return [timer autorelease];
}
#ifdef OF_HAVE_BLOCKS
+ (instancetype)scheduledTimerWithTimeInterval: (OFTimeInterval)timeInterval
repeats: (bool)repeats
block: (OFTimerBlock)block
{
void *pool = objc_autoreleasePoolPush();
OFDate *fireDate = [OFDate dateWithTimeIntervalSinceNow: timeInterval];
id timer = [[[self alloc] initWithFireDate: fireDate
interval: timeInterval
repeats: repeats
block: block] autorelease];
|
︙ | | | ︙ | |
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
|
return [timer autorelease];
}
#ifdef OF_HAVE_BLOCKS
+ (instancetype)timerWithTimeInterval: (OFTimeInterval)timeInterval
repeats: (bool)repeats
block: (of_timer_block_t)block
{
void *pool = objc_autoreleasePoolPush();
OFDate *fireDate = [OFDate dateWithTimeIntervalSinceNow: timeInterval];
id timer = [[[self alloc] initWithFireDate: fireDate
interval: timeInterval
repeats: repeats
block: block] autorelease];
|
|
|
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
|
return [timer autorelease];
}
#ifdef OF_HAVE_BLOCKS
+ (instancetype)timerWithTimeInterval: (OFTimeInterval)timeInterval
repeats: (bool)repeats
block: (OFTimerBlock)block
{
void *pool = objc_autoreleasePoolPush();
OFDate *fireDate = [OFDate dateWithTimeIntervalSinceNow: timeInterval];
id timer = [[[self alloc] initWithFireDate: fireDate
interval: timeInterval
repeats: repeats
block: block] autorelease];
|
︙ | | | ︙ | |
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
|
repeats: repeats];
}
#ifdef OF_HAVE_BLOCKS
- (instancetype)initWithFireDate: (OFDate *)fireDate
interval: (OFTimeInterval)interval
repeats: (bool)repeats
block: (of_timer_block_t)block
{
self = [super init];
@try {
_fireDate = [fireDate retain];
_interval = interval;
_repeats = repeats;
|
|
|
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
|
repeats: repeats];
}
#ifdef OF_HAVE_BLOCKS
- (instancetype)initWithFireDate: (OFDate *)fireDate
interval: (OFTimeInterval)interval
repeats: (bool)repeats
block: (OFTimerBlock)block
{
self = [super init];
@try {
_fireDate = [fireDate retain];
_interval = interval;
_repeats = repeats;
|
︙ | | | ︙ | |
Modified src/OFUTF8String.m
from [765c0c09a1]
to [325d0971b0].
︙ | | | ︙ | |
1208
1209
1210
1211
1212
1213
1214
1215
1216
1217
1218
1219
1220
1221
1222
|
return [[OFData dataWithItemsNoCopy: buffer
count: _s->length + 1
itemSize: sizeof(OFChar32)
freeWhenDone: true] items];
}
#ifdef OF_HAVE_BLOCKS
- (void)enumerateLinesUsingBlock: (of_string_line_enumeration_block_t)block
{
void *pool;
const char *cString = _s->cString;
const char *last = cString;
bool stop = false, lastCarriageReturn = false;
while (!stop && *cString != 0) {
|
|
|
1208
1209
1210
1211
1212
1213
1214
1215
1216
1217
1218
1219
1220
1221
1222
|
return [[OFData dataWithItemsNoCopy: buffer
count: _s->length + 1
itemSize: sizeof(OFChar32)
freeWhenDone: true] items];
}
#ifdef OF_HAVE_BLOCKS
- (void)enumerateLinesUsingBlock: (OFStringLineEnumerationBlock)block
{
void *pool;
const char *cString = _s->cString;
const char *last = cString;
bool stop = false, lastCarriageReturn = false;
while (!stop && *cString != 0) {
|
︙ | | | ︙ | |