Modified src/OFApplication.m
from [c32b0e2937]
to [35ca9806a3].
︙ | | | ︙ | |
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
|
#import "OFApplication.h"
#import "OFString.h"
#import "OFArray.h"
#import "OFDictionary.h"
#import "OFThread.h"
#import "OFRunLoop.h"
#import "OFNotImplementedException.h"
#import "autorelease.h"
#if defined(__MACH__) && !defined(OF_IOS)
# include <crt_externs.h>
#elif !defined(OF_IOS)
extern char **environ;
#endif
|
<
<
|
25
26
27
28
29
30
31
32
33
34
35
36
37
38
|
#import "OFApplication.h"
#import "OFString.h"
#import "OFArray.h"
#import "OFDictionary.h"
#import "OFThread.h"
#import "OFRunLoop.h"
#import "autorelease.h"
#if defined(__MACH__) && !defined(OF_IOS)
# include <crt_externs.h>
#elif !defined(OF_IOS)
extern char **environ;
#endif
|
︙ | | | ︙ | |
Modified src/OFArray.m
from [a77077bbb2]
to [0bbcdb4b0f].
︙ | | | ︙ | |
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
|
* LICENSE.GPLv2 or LICENSE.GPLv3 respectively included in the packaging of this
* file.
*/
#include "config.h"
#include <stdarg.h>
#import "OFArray.h"
#import "OFArray_subarray.h"
#import "OFArray_adjacent.h"
#import "OFString.h"
#import "OFXMLElement.h"
#import "OFEnumerationMutationException.h"
#import "OFInvalidArgumentException.h"
#import "OFNotImplementedException.h"
#import "OFOutOfRangeException.h"
#import "autorelease.h"
#import "macros.h"
static struct {
Class isa;
|
>
<
|
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
|
* LICENSE.GPLv2 or LICENSE.GPLv3 respectively included in the packaging of this
* file.
*/
#include "config.h"
#include <stdarg.h>
#include <stdlib.h>
#import "OFArray.h"
#import "OFArray_subarray.h"
#import "OFArray_adjacent.h"
#import "OFString.h"
#import "OFXMLElement.h"
#import "OFEnumerationMutationException.h"
#import "OFInvalidArgumentException.h"
#import "OFOutOfRangeException.h"
#import "autorelease.h"
#import "macros.h"
static struct {
Class isa;
|
︙ | | | ︙ | |
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
|
- (void)release
{
}
- (void)dealloc
{
@throw [OFNotImplementedException exceptionWithClass: [self class]
selector: _cmd];
[super dealloc]; /* Get rid of a stupid warning */
}
@end
@implementation OFArray
+ (void)initialize
{
if (self == [OFArray class])
|
|
>
|
|
>
|
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
|
- (void)release
{
}
- (void)dealloc
{
[self doesNotRecognizeSelector: _cmd];
abort();
/* Get rid of a stupid warning */
[super dealloc];
}
@end
@implementation OFArray
+ (void)initialize
{
if (self == [OFArray class])
|
︙ | | | ︙ | |
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
|
return [[[self alloc] initWithObjects: objects
count: count] autorelease];
}
- init
{
if (object_getClass(self) == [OFArray class]) {
Class c = [self class];
[self release];
@throw [OFNotImplementedException exceptionWithClass: c
selector: _cmd];
}
return [super init];
}
- initWithObject: (id)object
{
|
>
|
>
>
|
|
<
>
|
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
|
return [[[self alloc] initWithObjects: objects
count: count] autorelease];
}
- init
{
if (object_getClass(self) == [OFArray class]) {
@try {
[self doesNotRecognizeSelector: _cmd];
abort();
} @catch (id e) {
[self release];
@throw e;
}
}
return [super init];
}
- initWithObject: (id)object
{
|
︙ | | | ︙ | |
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
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
|
return ret;
}
- initWithObject: (id)firstObject
arguments: (va_list)arguments
{
Class c = [self class];
[self release];
@throw [OFNotImplementedException exceptionWithClass: c
selector: _cmd];
}
- initWithArray: (OFArray*)array
{
Class c = [self class];
[self release];
@throw [OFNotImplementedException exceptionWithClass: c
selector: _cmd];
}
- initWithObjects: (id const*)objects
count: (size_t)count
{
Class c = [self class];
[self release];
@throw [OFNotImplementedException exceptionWithClass: c
selector: _cmd];
}
- initWithSerialization: (OFXMLElement*)element
{
Class c = [self class];
[self release];
@throw [OFNotImplementedException exceptionWithClass: c
selector: _cmd];
}
- (size_t)count
{
@throw [OFNotImplementedException exceptionWithClass: [self class]
selector: _cmd];
}
- (void)getObjects: (id*)buffer
inRange: (of_range_t)range
{
size_t i;
|
>
|
>
>
|
|
<
>
>
|
>
>
|
|
<
>
>
|
>
>
|
|
<
>
>
|
>
>
|
|
<
>
<
|
>
|
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
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
|
return ret;
}
- initWithObject: (id)firstObject
arguments: (va_list)arguments
{
@try {
[self doesNotRecognizeSelector: _cmd];
abort();
} @catch (id e) {
[self release];
@throw e;
}
}
- initWithArray: (OFArray*)array
{
@try {
[self doesNotRecognizeSelector: _cmd];
abort();
} @catch (id e) {
[self release];
@throw e;
}
}
- initWithObjects: (id const*)objects
count: (size_t)count
{
@try {
[self doesNotRecognizeSelector: _cmd];
abort();
} @catch (id e) {
[self release];
@throw e;
}
}
- initWithSerialization: (OFXMLElement*)element
{
@try {
[self doesNotRecognizeSelector: _cmd];
abort();
} @catch (id e) {
[self release];
@throw e;
}
}
- (size_t)count
{
[self doesNotRecognizeSelector: _cmd];
abort();
}
- (void)getObjects: (id*)buffer
inRange: (of_range_t)range
{
size_t i;
|
︙ | | | ︙ | |
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
|
- mutableCopy
{
return [[OFMutableArray alloc] initWithArray: self];
}
- (id)objectAtIndex: (size_t)index
{
@throw [OFNotImplementedException exceptionWithClass: [self class]
selector: _cmd];
}
- (id)objectAtIndexedSubscript: (size_t)index
{
return [self objectAtIndex: index];
}
|
<
|
>
|
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
|
- mutableCopy
{
return [[OFMutableArray alloc] initWithArray: self];
}
- (id)objectAtIndex: (size_t)index
{
[self doesNotRecognizeSelector: _cmd];
abort();
}
- (id)objectAtIndexedSubscript: (size_t)index
{
return [self objectAtIndex: index];
}
|
︙ | | | ︙ | |
Modified src/OFAutoreleasePool.m
from [b7dda03eca]
to [b1114f3a89].
︙ | | | ︙ | |
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
|
#include "config.h"
#include <stdlib.h>
#import "OFAutoreleasePool.h"
#import "OFArray.h"
#import "OFNotImplementedException.h"
#import "macros.h"
#ifndef OF_COMPILER_TLS
# import "threading.h"
# import "OFInitializationFailedException.h"
#endif
|
<
<
|
17
18
19
20
21
22
23
24
25
26
27
28
29
30
|
#include "config.h"
#include <stdlib.h>
#import "OFAutoreleasePool.h"
#import "OFArray.h"
#import "macros.h"
#ifndef OF_COMPILER_TLS
# import "threading.h"
# import "OFInitializationFailedException.h"
#endif
|
︙ | | | ︙ | |
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
|
}
[super dealloc];
}
- retain
{
@throw [OFNotImplementedException exceptionWithClass: [self class]
selector: _cmd];
}
- autorelease
{
@throw [OFNotImplementedException exceptionWithClass: [self class]
selector: _cmd];
}
@end
|
<
|
>
<
|
>
|
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
|
}
[super dealloc];
}
- retain
{
[self doesNotRecognizeSelector: _cmd];
abort();
}
- autorelease
{
[self doesNotRecognizeSelector: _cmd];
abort();
}
@end
|
Modified src/OFBlock.m
from [90b4a8e14a]
to [68b4ea5979].
︙ | | | ︙ | |
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
|
# import <objc/runtime.h>
#endif
#import "OFBlock.h"
#import "OFAllocFailedException.h"
#import "OFInitializationFailedException.h"
#import "OFNotImplementedException.h"
#import "macros.h"
#ifdef OF_ATOMIC_OPS
# import "atomic.h"
#endif
#ifdef OF_THREADS
# import "threading.h"
|
<
|
26
27
28
29
30
31
32
33
34
35
36
37
38
39
|
# import <objc/runtime.h>
#endif
#import "OFBlock.h"
#import "OFAllocFailedException.h"
#import "OFInitializationFailedException.h"
#import "macros.h"
#ifdef OF_ATOMIC_OPS
# import "atomic.h"
#endif
#ifdef OF_THREADS
# import "threading.h"
|
︙ | | | ︙ | |
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
|
@throw [OFInitializationFailedException
exceptionWithClass: self];
}
#endif
+ alloc
{
@throw [OFNotImplementedException exceptionWithClass: self
selector: _cmd];
}
- init
{
@throw [OFNotImplementedException exceptionWithClass: [self class]
selector: _cmd];
}
- (void*)allocMemoryWithSize: (size_t)size
{
@throw [OFNotImplementedException exceptionWithClass: [self class]
selector: _cmd];
}
- (void*)allocMemoryWithSize: (size_t)size
count: (size_t)count
{
@throw [OFNotImplementedException exceptionWithClass: [self class]
selector: _cmd];
}
- (void*)resizeMemory: (void*)ptr
size: (size_t)size
{
@throw [OFNotImplementedException exceptionWithClass: [self class]
selector: _cmd];
}
- (void*)resizeMemory: (void*)ptr
size: (size_t)size
count: (size_t)count
{
@throw [OFNotImplementedException exceptionWithClass: [self class]
selector: _cmd];
}
- (void)freeMemory: (void*)ptr
{
@throw [OFNotImplementedException exceptionWithClass: [self class]
selector: _cmd];
}
- retain
{
if (object_getClass(self) == (Class)&_NSConcreteMallocBlock)
return Block_copy(self);
|
<
|
>
|
|
>
>
>
>
>
<
|
>
<
|
>
<
|
>
<
|
>
<
|
>
|
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
|
@throw [OFInitializationFailedException
exceptionWithClass: self];
}
#endif
+ alloc
{
[self doesNotRecognizeSelector: _cmd];
abort();
}
- init
{
@try {
[self doesNotRecognizeSelector: _cmd];
abort();
} @catch (id e) {
[self release];
@throw e;
}
}
- (void*)allocMemoryWithSize: (size_t)size
{
[self doesNotRecognizeSelector: _cmd];
abort();
}
- (void*)allocMemoryWithSize: (size_t)size
count: (size_t)count
{
[self doesNotRecognizeSelector: _cmd];
abort();
}
- (void*)resizeMemory: (void*)ptr
size: (size_t)size
{
[self doesNotRecognizeSelector: _cmd];
abort();
}
- (void*)resizeMemory: (void*)ptr
size: (size_t)size
count: (size_t)count
{
[self doesNotRecognizeSelector: _cmd];
abort();
}
- (void)freeMemory: (void*)ptr
{
[self doesNotRecognizeSelector: _cmd];
abort();
}
- retain
{
if (object_getClass(self) == (Class)&_NSConcreteMallocBlock)
return Block_copy(self);
|
︙ | | | ︙ | |
467
468
469
470
471
472
473
474
475
476
477
478
|
{
if (object_getClass(self) == (Class)&_NSConcreteMallocBlock)
Block_release(self);
}
- (void)dealloc
{
@throw [OFNotImplementedException exceptionWithClass: [self class]
selector: _cmd];
[super dealloc]; /* Get rid of a stupid warning */
}
@end
|
|
>
|
|
>
|
471
472
473
474
475
476
477
478
479
480
481
482
483
484
|
{
if (object_getClass(self) == (Class)&_NSConcreteMallocBlock)
Block_release(self);
}
- (void)dealloc
{
[self doesNotRecognizeSelector: _cmd];
abort();
/* Get rid of a stupid warning */
[super dealloc];
}
@end
|
Modified src/OFConstantString.m
from [b86bf57c57]
to [4e1d37633d].
︙ | | | ︙ | |
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
|
#include <string.h>
#import "OFConstantString.h"
#import "OFString_UTF8.h"
#import "OFInitializationFailedException.h"
#import "OFInvalidEncodingException.h"
#import "OFNotImplementedException.h"
#import "OFOutOfMemoryException.h"
#if defined(OF_APPLE_RUNTIME) && !defined(__OBJC2__)
# import <objc/runtime.h>
struct {
struct class *isa, *super_class;
|
<
|
22
23
24
25
26
27
28
29
30
31
32
33
34
35
|
#include <string.h>
#import "OFConstantString.h"
#import "OFString_UTF8.h"
#import "OFInitializationFailedException.h"
#import "OFInvalidEncodingException.h"
#import "OFOutOfMemoryException.h"
#if defined(OF_APPLE_RUNTIME) && !defined(__OBJC2__)
# import <objc/runtime.h>
struct {
struct class *isa, *super_class;
|
︙ | | | ︙ | |
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
|
@interface OFString_const: OFString_UTF8
@end
@implementation OFString_const
+ alloc
{
@throw [OFNotImplementedException exceptionWithClass: self
selector: _cmd];
}
- (void*)allocMemoryWithSize: (size_t)size
{
@throw [OFNotImplementedException exceptionWithClass: [self class]
selector: _cmd];
}
- (void*)allocMemoryWithSize: (size_t)itemSize
count: (size_t)count
{
@throw [OFNotImplementedException exceptionWithClass: [self class]
selector: _cmd];
}
- (void*)resizeMemory: (void*)ptr
size: (size_t)size
{
@throw [OFNotImplementedException exceptionWithClass: [self class]
selector: _cmd];
}
- (void*)resizeMemory: (void*)ptr
toNItems: (size_t)nitems
withSize: (size_t)size
{
@throw [OFNotImplementedException exceptionWithClass: [self class]
selector: _cmd];
}
- (void)freeMemory: (void*)ptr
{
@throw [OFNotImplementedException exceptionWithClass: [self class]
selector: _cmd];
}
- retain
{
return self;
}
|
<
|
>
<
|
>
<
|
>
<
|
>
<
|
>
<
|
>
|
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
|
@interface OFString_const: OFString_UTF8
@end
@implementation OFString_const
+ alloc
{
[self doesNotRecognizeSelector: _cmd];
abort();
}
- (void*)allocMemoryWithSize: (size_t)size
{
[self doesNotRecognizeSelector: _cmd];
abort();
}
- (void*)allocMemoryWithSize: (size_t)itemSize
count: (size_t)count
{
[self doesNotRecognizeSelector: _cmd];
abort();
}
- (void*)resizeMemory: (void*)ptr
size: (size_t)size
{
[self doesNotRecognizeSelector: _cmd];
abort();
}
- (void*)resizeMemory: (void*)ptr
toNItems: (size_t)nitems
withSize: (size_t)size
{
[self doesNotRecognizeSelector: _cmd];
abort();
}
- (void)freeMemory: (void*)ptr
{
[self doesNotRecognizeSelector: _cmd];
abort();
}
- retain
{
return self;
}
|
︙ | | | ︙ | |
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
|
- (void)release
{
}
- (void)dealloc
{
@throw [OFNotImplementedException exceptionWithClass: [self class]
selector: _cmd];
[super dealloc]; /* Get rid of a stupid warning */
}
@end
@implementation OFConstantString
+ (void)load
{
#if defined(OF_APPLE_RUNTIME) && !defined(__OBJC2__)
|
|
>
|
|
>
|
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
|
- (void)release
{
}
- (void)dealloc
{
[self doesNotRecognizeSelector: _cmd];
abort();
/* Get rid of a stupid warning */
[super dealloc];
}
@end
@implementation OFConstantString
+ (void)load
{
#if defined(OF_APPLE_RUNTIME) && !defined(__OBJC2__)
|
︙ | | | ︙ | |
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
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
|
cString = (char*)ivars;
object_setClass(self, [OFString_const class]);
}
+ alloc
{
@throw [OFNotImplementedException exceptionWithClass: self
selector: _cmd];
}
- (void*)allocMemoryWithSize: (size_t)size
{
@throw [OFNotImplementedException exceptionWithClass: [self class]
selector: _cmd];
}
- (void*)allocMemoryWithSize: (size_t)size
count: (size_t)count
{
@throw [OFNotImplementedException exceptionWithClass: [self class]
selector: _cmd];
}
- (void*)resizeMemory: (void*)ptr
size: (size_t)size
{
@throw [OFNotImplementedException exceptionWithClass: [self class]
selector: _cmd];
}
- (void*)resizeMemory: (void*)ptr
size: (size_t)size
count: (size_t)count
{
@throw [OFNotImplementedException exceptionWithClass: [self class]
selector: _cmd];
}
- (void)freeMemory: (void*)ptr
{
@throw [OFNotImplementedException exceptionWithClass: [self class]
selector: _cmd];
}
- retain
{
return self;
}
|
<
|
>
<
|
>
<
|
>
<
|
>
<
|
>
<
|
>
|
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
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
|
cString = (char*)ivars;
object_setClass(self, [OFString_const class]);
}
+ alloc
{
[self doesNotRecognizeSelector: _cmd];
abort();
}
- (void*)allocMemoryWithSize: (size_t)size
{
[self doesNotRecognizeSelector: _cmd];
abort();
}
- (void*)allocMemoryWithSize: (size_t)size
count: (size_t)count
{
[self doesNotRecognizeSelector: _cmd];
abort();
}
- (void*)resizeMemory: (void*)ptr
size: (size_t)size
{
[self doesNotRecognizeSelector: _cmd];
abort();
}
- (void*)resizeMemory: (void*)ptr
size: (size_t)size
count: (size_t)count
{
[self doesNotRecognizeSelector: _cmd];
abort();
}
- (void)freeMemory: (void*)ptr
{
[self doesNotRecognizeSelector: _cmd];
abort();
}
- retain
{
return self;
}
|
︙ | | | ︙ | |
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
|
- (void)release
{
}
- (void)dealloc
{
@throw [OFNotImplementedException exceptionWithClass: [self class]
selector: _cmd];
[super dealloc]; /* Get rid of a stupid warning */
}
/*
* In all following methods, the constant string is converted to an
* OFString_UTF8 and the message sent again.
*/
|
|
>
|
|
>
|
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
|
- (void)release
{
}
- (void)dealloc
{
[self doesNotRecognizeSelector: _cmd];
abort();
/* Get rid of a stupid warning */
[super dealloc];
}
/*
* In all following methods, the constant string is converted to an
* OFString_UTF8 and the message sent again.
*/
|
︙ | | | ︙ | |
Modified src/OFCountedSet.m
from [dd9c0e4002]
to [85c3dcd865].
︙ | | | ︙ | |
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
|
* Alternatively, it may be distributed under the terms of the GNU General
* Public License, either version 2 or 3, which can be found in the file
* LICENSE.GPLv2 or LICENSE.GPLv3 respectively included in the packaging of this
* file.
*/
#include "config.h"
#import "OFCountedSet.h"
#import "OFCountedSet_hashtable.h"
#import "OFNumber.h"
#import "OFString.h"
#import "OFXMLElement.h"
#import "OFNotImplementedException.h"
#import "autorelease.h"
static struct {
Class isa;
} placeholder;
@interface OFCountedSet_placeholder: OFCountedSet
|
>
>
<
<
|
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
|
* Alternatively, it may be distributed under the terms of the GNU General
* Public License, either version 2 or 3, which can be found in the file
* LICENSE.GPLv2 or LICENSE.GPLv3 respectively included in the packaging of this
* file.
*/
#include "config.h"
#include <stdlib.h>
#import "OFCountedSet.h"
#import "OFCountedSet_hashtable.h"
#import "OFNumber.h"
#import "OFString.h"
#import "OFXMLElement.h"
#import "autorelease.h"
static struct {
Class isa;
} placeholder;
@interface OFCountedSet_placeholder: OFCountedSet
|
︙ | | | ︙ | |
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
|
- (void)release
{
}
- (void)dealloc
{
@throw [OFNotImplementedException exceptionWithClass: [self class]
selector: _cmd];
[super dealloc]; /* Get rid of a stupid warning */
}
@end
@implementation OFCountedSet
+ (void)initialize
{
if (self == [OFCountedSet class])
|
|
>
|
|
>
|
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
|
- (void)release
{
}
- (void)dealloc
{
[self doesNotRecognizeSelector: _cmd];
abort();
/* Get rid of a stupid warning */
[super dealloc];
}
@end
@implementation OFCountedSet
+ (void)initialize
{
if (self == [OFCountedSet class])
|
︙ | | | ︙ | |
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
144
|
return [super alloc];
}
- init
{
if (object_getClass(self) == [OFCountedSet class]) {
Class c = [self class];
[self release];
@throw [OFNotImplementedException exceptionWithClass: c
selector: _cmd];
}
return [super init];
}
- (size_t)countForObject: (id)object
{
@throw [OFNotImplementedException exceptionWithClass: [self class]
selector: _cmd];
}
- (OFString*)description
{
OFMutableString *ret;
void *pool;
OFEnumerator *enumerator;
|
>
|
>
>
|
|
<
>
<
|
>
|
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
|
return [super alloc];
}
- init
{
if (object_getClass(self) == [OFCountedSet class]) {
@try {
[self doesNotRecognizeSelector: _cmd];
abort();
} @catch (id e) {
[self release];
@throw e;
}
}
return [super init];
}
- (size_t)countForObject: (id)object
{
[self doesNotRecognizeSelector: _cmd];
abort();
}
- (OFString*)description
{
OFMutableString *ret;
void *pool;
OFEnumerator *enumerator;
|
︙ | | | ︙ | |
Modified src/OFDataArray.m
from [84f1c9eaa1]
to [b9544608cd].
︙ | | | ︙ | |
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
|
#import "OFHTTPClient.h"
#import "OFHTTPRequest.h"
#import "OFXMLElement.h"
#import "OFHTTPRequestFailedException.h"
#import "OFInvalidArgumentException.h"
#import "OFInvalidFormatException.h"
#import "OFNotImplementedException.h"
#import "OFOutOfMemoryException.h"
#import "OFOutOfRangeException.h"
#import "autorelease.h"
#import "base64.h"
#import "macros.h"
|
<
|
27
28
29
30
31
32
33
34
35
36
37
38
39
40
|
#import "OFHTTPClient.h"
#import "OFHTTPRequest.h"
#import "OFXMLElement.h"
#import "OFHTTPRequestFailedException.h"
#import "OFInvalidArgumentException.h"
#import "OFInvalidFormatException.h"
#import "OFOutOfMemoryException.h"
#import "OFOutOfRangeException.h"
#import "autorelease.h"
#import "base64.h"
#import "macros.h"
|
︙ | | | ︙ | |
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
|
- (OFXMLElement*)XMLElementBySerializing
{
void *pool;
OFXMLElement *element;
if (itemSize != 1)
@throw [OFNotImplementedException
exceptionWithClass: [self class]
selector: _cmd];
pool = objc_autoreleasePoolPush();
element = [OFXMLElement
elementWithName: [self className]
namespace: OF_SERIALIZATION_NS
stringValue: of_base64_encode(items, count * itemSize)];
|
|
|
<
|
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
|
- (OFXMLElement*)XMLElementBySerializing
{
void *pool;
OFXMLElement *element;
if (itemSize != 1)
@throw [OFInvalidArgumentException
exceptionWithClass: [self class]];
pool = objc_autoreleasePoolPush();
element = [OFXMLElement
elementWithName: [self className]
namespace: OF_SERIALIZATION_NS
stringValue: of_base64_encode(items, count * itemSize)];
|
︙ | | | ︙ | |
Modified src/OFDictionary.m
from [8f52b3e64a]
to [2f5f515df2].
︙ | | | ︙ | |
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
|
* Public License, either version 2 or 3, which can be found in the file
* LICENSE.GPLv2 or LICENSE.GPLv3 respectively included in the packaging of this
* file.
*/
#include "config.h"
#include <assert.h>
#import "OFDictionary.h"
#import "OFDictionary_hashtable.h"
#import "OFArray.h"
#import "OFString.h"
#import "OFXMLElement.h"
#import "OFInvalidArgumentException.h"
#import "OFNotImplementedException.h"
#import "autorelease.h"
static struct {
Class isa;
} placeholder;
|
>
>
<
|
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
|
* Public License, either version 2 or 3, which can be found in the file
* LICENSE.GPLv2 or LICENSE.GPLv3 respectively included in the packaging of this
* file.
*/
#include "config.h"
#include <stdlib.h>
#include <assert.h>
#import "OFDictionary.h"
#import "OFDictionary_hashtable.h"
#import "OFArray.h"
#import "OFString.h"
#import "OFXMLElement.h"
#import "OFInvalidArgumentException.h"
#import "autorelease.h"
static struct {
Class isa;
} placeholder;
|
︙ | | | ︙ | |
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
|
- (void)release
{
}
- (void)dealloc
{
@throw [OFNotImplementedException exceptionWithClass: [self class]
selector: _cmd];
[super dealloc]; /* Get rid of a stupid warning */
}
@end
@implementation OFDictionary
+ (void)initialize
{
if (self == [OFDictionary class])
|
|
>
|
|
>
|
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
|
- (void)release
{
}
- (void)dealloc
{
[self doesNotRecognizeSelector: _cmd];
abort();
/* Get rid of a stupid warning */
[super dealloc];
}
@end
@implementation OFDictionary
+ (void)initialize
{
if (self == [OFDictionary class])
|
︙ | | | ︙ | |
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
206
207
|
return ret;
}
- init
{
if (object_getClass(self) == [OFDictionary class]) {
Class c = [self class];
[self release];
@throw [OFNotImplementedException exceptionWithClass: c
selector: _cmd];
}
return [super init];
}
- initWithDictionary: (OFDictionary*)dictionary
{
Class c = [self class];
[self release];
@throw [OFNotImplementedException exceptionWithClass: c
selector: _cmd];
}
- initWithObject: (id)object
forKey: (id)key
{
if (key == nil || object == nil)
@throw [OFInvalidArgumentException
|
>
|
>
>
|
|
<
>
>
|
>
>
|
|
<
>
|
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
|
return ret;
}
- init
{
if (object_getClass(self) == [OFDictionary class]) {
@try {
[self doesNotRecognizeSelector: _cmd];
abort();
} @catch (id e) {
[self release];
@throw e;
}
}
return [super init];
}
- initWithDictionary: (OFDictionary*)dictionary
{
@try {
[self doesNotRecognizeSelector: _cmd];
abort();
} @catch (id e) {
[self release];
@throw e;
}
}
- initWithObject: (id)object
forKey: (id)key
{
if (key == nil || object == nil)
@throw [OFInvalidArgumentException
|
︙ | | | ︙ | |
235
236
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
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
295
296
297
298
299
|
count: count];
}
- initWithObjects: (id const*)objects
forKeys: (id const*)keys
count: (size_t)count
{
Class c = [self class];
[self release];
@throw [OFNotImplementedException exceptionWithClass: c
selector: _cmd];
}
- initWithKeysAndObjects: (id)firstKey, ...
{
id ret;
va_list arguments;
va_start(arguments, firstKey);
ret = [self initWithKey: firstKey
arguments: arguments];
va_end(arguments);
return ret;
}
- initWithKey: (id)firstKey
arguments: (va_list)arguments
{
Class c = [self class];
[self release];
@throw [OFNotImplementedException exceptionWithClass: c
selector: _cmd];
}
- initWithSerialization: (OFXMLElement*)element
{
Class c = [self class];
[self release];
@throw [OFNotImplementedException exceptionWithClass: c
selector: _cmd];
}
- (id)objectForKey: (id)key
{
@throw [OFNotImplementedException exceptionWithClass: [self class]
selector: _cmd];
}
- (id)objectForKeyedSubscript: (id)key
{
return [self objectForKey: key];
}
- (size_t)count
{
@throw [OFNotImplementedException exceptionWithClass: [self class]
selector: _cmd];
}
- copy
{
return [self retain];
}
|
>
|
>
>
|
|
<
>
>
|
>
>
|
|
<
>
>
|
>
>
|
|
<
>
<
|
>
<
|
>
|
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
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
|
count: count];
}
- initWithObjects: (id const*)objects
forKeys: (id const*)keys
count: (size_t)count
{
@try {
[self doesNotRecognizeSelector: _cmd];
abort();
} @catch (id e) {
[self release];
@throw e;
}
}
- initWithKeysAndObjects: (id)firstKey, ...
{
id ret;
va_list arguments;
va_start(arguments, firstKey);
ret = [self initWithKey: firstKey
arguments: arguments];
va_end(arguments);
return ret;
}
- initWithKey: (id)firstKey
arguments: (va_list)arguments
{
@try {
[self doesNotRecognizeSelector: _cmd];
abort();
} @catch (id e) {
[self release];
@throw e;
}
}
- initWithSerialization: (OFXMLElement*)element
{
@try {
[self doesNotRecognizeSelector: _cmd];
abort();
} @catch (id e) {
[self release];
@throw e;
}
}
- (id)objectForKey: (id)key
{
[self doesNotRecognizeSelector: _cmd];
abort();
}
- (id)objectForKeyedSubscript: (id)key
{
return [self objectForKey: key];
}
- (size_t)count
{
[self doesNotRecognizeSelector: _cmd];
abort();
}
- copy
{
return [self retain];
}
|
︙ | | | ︙ | |
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
|
}
return ret;
}
- (OFEnumerator*)objectEnumerator
{
@throw [OFNotImplementedException exceptionWithClass: [self class]
selector: _cmd];
}
- (OFEnumerator*)keyEnumerator
{
@throw [OFNotImplementedException exceptionWithClass: [self class]
selector: _cmd];
}
- (int)countByEnumeratingWithState: (of_fast_enumeration_state_t*)state
objects: (id*)objects
count: (int)count_
{
@throw [OFNotImplementedException exceptionWithClass: [self class]
selector: _cmd];
}
#if defined(OF_HAVE_BLOCKS) && defined(OF_HAVE_FAST_ENUMERATION)
- (void)enumerateKeysAndObjectsUsingBlock:
(of_dictionary_enumeration_block_t)block
{
BOOL stop = NO;
|
<
|
>
<
|
>
<
|
>
|
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
|
}
return ret;
}
- (OFEnumerator*)objectEnumerator
{
[self doesNotRecognizeSelector: _cmd];
abort();
}
- (OFEnumerator*)keyEnumerator
{
[self doesNotRecognizeSelector: _cmd];
abort();
}
- (int)countByEnumeratingWithState: (of_fast_enumeration_state_t*)state
objects: (id*)objects
count: (int)count_
{
[self doesNotRecognizeSelector: _cmd];
abort();
}
#if defined(OF_HAVE_BLOCKS) && defined(OF_HAVE_FAST_ENUMERATION)
- (void)enumerateKeysAndObjectsUsingBlock:
(of_dictionary_enumeration_block_t)block
{
BOOL stop = NO;
|
︙ | | | ︙ | |
Modified src/OFDictionary_hashtable.m
from [368527d2d0]
to [2aa9021130].
︙ | | | ︙ | |
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
|
#import "OFArray.h"
#import "OFString.h"
#import "OFXMLElement.h"
#import "OFEnumerationMutationException.h"
#import "OFInvalidArgumentException.h"
#import "OFInvalidFormatException.h"
#import "OFNotImplementedException.h"
#import "autorelease.h"
static void*
copy(void *value)
{
return [(id)value copy];
|
<
|
24
25
26
27
28
29
30
31
32
33
34
35
36
37
|
#import "OFArray.h"
#import "OFString.h"
#import "OFXMLElement.h"
#import "OFEnumerationMutationException.h"
#import "OFInvalidArgumentException.h"
#import "OFInvalidFormatException.h"
#import "autorelease.h"
static void*
copy(void *value)
{
return [(id)value copy];
|
︙ | | | ︙ | |
Modified src/OFEnumerator.m
from [a52bed56fc]
to [6da733cb79].
︙ | | | ︙ | |
12
13
14
15
16
17
18
19
20
21
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
|
* Public License, either version 2 or 3, which can be found in the file
* LICENSE.GPLv2 or LICENSE.GPLv3 respectively included in the packaging of this
* file.
*/
#include "config.h"
#import "OFEnumerator.h"
#import "OFNotImplementedException.h"
@implementation OFEnumerator
- init
{
if (object_getClass(self) == [OFEnumerator class]) {
Class c = [self class];
[self release];
@throw [OFNotImplementedException exceptionWithClass: c
selector: _cmd];
}
return [super init];
}
- (id)nextObject
{
@throw [OFNotImplementedException exceptionWithClass: [self class]
selector: _cmd];
}
- (void)reset
{
@throw [OFNotImplementedException exceptionWithClass: [self class]
selector: _cmd];
}
@end
|
|
|
>
|
>
>
|
|
<
>
<
|
>
<
|
>
|
12
13
14
15
16
17
18
19
20
21
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
|
* Public License, either version 2 or 3, which can be found in the file
* LICENSE.GPLv2 or LICENSE.GPLv3 respectively included in the packaging of this
* file.
*/
#include "config.h"
#include <stdlib.h>
#import "OFEnumerator.h"
@implementation OFEnumerator
- init
{
if (object_getClass(self) == [OFEnumerator class]) {
@try {
[self doesNotRecognizeSelector: _cmd];
abort();
} @catch (id e) {
[self release];
@throw e;
}
}
return [super init];
}
- (id)nextObject
{
[self doesNotRecognizeSelector: _cmd];
abort();
}
- (void)reset
{
[self doesNotRecognizeSelector: _cmd];
abort();
}
@end
|
Modified src/OFFile.m
from [136919bb87]
to [b3c8f30967].
︙ | | | ︙ | |
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
|
#import "OFCreateDirectoryFailedException.h"
#import "OFDeleteDirectoryFailedException.h"
#import "OFDeleteFileFailedException.h"
#import "OFInitializationFailedException.h"
#import "OFInvalidArgumentException.h"
#import "OFLinkFailedException.h"
#import "OFLockFailedException.h"
#import "OFNotImplementedException.h"
#import "OFOpenFileFailedException.h"
#import "OFOutOfMemoryException.h"
#import "OFReadFailedException.h"
#import "OFRenameFileFailedException.h"
#import "OFSeekFailedException.h"
#import "OFSymlinkFailedException.h"
#import "OFUnlockFailedException.h"
|
<
|
55
56
57
58
59
60
61
62
63
64
65
66
67
68
|
#import "OFCreateDirectoryFailedException.h"
#import "OFDeleteDirectoryFailedException.h"
#import "OFDeleteFileFailedException.h"
#import "OFInitializationFailedException.h"
#import "OFInvalidArgumentException.h"
#import "OFLinkFailedException.h"
#import "OFLockFailedException.h"
#import "OFOpenFileFailedException.h"
#import "OFOutOfMemoryException.h"
#import "OFReadFailedException.h"
#import "OFRenameFileFailedException.h"
#import "OFSeekFailedException.h"
#import "OFSymlinkFailedException.h"
#import "OFUnlockFailedException.h"
|
︙ | | | ︙ | |
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
|
objc_autoreleasePoolPop(pool);
}
#endif
- init
{
Class c = [self class];
[self release];
@throw [OFNotImplementedException exceptionWithClass: c
selector: _cmd];
}
- initWithPath: (OFString*)path
mode: (OFString*)mode
{
self = [super init];
|
>
|
>
>
|
|
<
>
|
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
|
objc_autoreleasePoolPop(pool);
}
#endif
- init
{
@try {
[self doesNotRecognizeSelector: _cmd];
abort();
} @catch (id e) {
[self release];
@throw e;
}
}
- initWithPath: (OFString*)path
mode: (OFString*)mode
{
self = [super init];
|
︙ | | | ︙ | |
760
761
762
763
764
765
766
767
768
769
770
771
772
773
774
775
776
777
|
of_stdout = [[OFFileSingleton alloc] initWithFileDescriptor: 1];
of_stderr = [[OFFileSingleton alloc] initWithFileDescriptor: 2];
}
- initWithPath: (OFString*)path
mode: (OFString*)mode
{
Class c = [self class];
[self release];
@throw [OFNotImplementedException exceptionWithClass: c
selector: _cmd];
}
- autorelease
{
return self;
}
|
>
|
>
>
|
|
<
>
|
762
763
764
765
766
767
768
769
770
771
772
773
774
775
776
777
778
779
780
781
782
|
of_stdout = [[OFFileSingleton alloc] initWithFileDescriptor: 1];
of_stderr = [[OFFileSingleton alloc] initWithFileDescriptor: 2];
}
- initWithPath: (OFString*)path
mode: (OFString*)mode
{
@try {
[self doesNotRecognizeSelector: _cmd];
abort();
} @catch (id e) {
[self release];
@throw e;
}
}
- autorelease
{
return self;
}
|
︙ | | | ︙ | |
787
788
789
790
791
792
793
794
795
796
797
798
799
800
801
802
803
804
805
|
- (unsigned int)retainCount
{
return OF_RETAIN_COUNT_MAX;
}
- (void)dealloc
{
@throw [OFNotImplementedException exceptionWithClass: [self class]
selector: _cmd];
[super dealloc]; /* Get rid of stupid warning */
}
- (void)lowlevelSeekToOffset: (off_t)offset
whence: (int)whence
{
@throw [OFNotImplementedException exceptionWithClass: [self class]
selector: _cmd];
}
@end
|
|
>
|
|
>
<
|
>
|
792
793
794
795
796
797
798
799
800
801
802
803
804
805
806
807
808
809
810
811
812
|
- (unsigned int)retainCount
{
return OF_RETAIN_COUNT_MAX;
}
- (void)dealloc
{
[self doesNotRecognizeSelector: _cmd];
abort();
/* Get rid of stupid warning */
[super dealloc];
}
- (void)lowlevelSeekToOffset: (off_t)offset
whence: (int)whence
{
[self doesNotRecognizeSelector: _cmd];
abort();
}
@end
|
Modified src/OFHTTPServer.m
from [0d0597589f]
to [3793430199].
︙ | | | ︙ | |
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
|
#import "OFHTTPRequest.h"
#import "OFTCPSocket.h"
#import "OFTimer.h"
#import "OFAlreadyConnectedException.h"
#import "OFInvalidArgumentException.h"
#import "OFInvalidFormatException.h"
#import "OFNotImplementedException.h"
#import "OFOutOfMemoryException.h"
#import "OFOutOfRangeException.h"
#import "OFWriteFailedException.h"
#import "macros.h"
#define BUFFER_SIZE 1024
|
<
|
27
28
29
30
31
32
33
34
35
36
37
38
39
40
|
#import "OFHTTPRequest.h"
#import "OFTCPSocket.h"
#import "OFTimer.h"
#import "OFAlreadyConnectedException.h"
#import "OFInvalidArgumentException.h"
#import "OFInvalidFormatException.h"
#import "OFOutOfMemoryException.h"
#import "OFOutOfRangeException.h"
#import "OFWriteFailedException.h"
#import "macros.h"
#define BUFFER_SIZE 1024
|
︙ | | | ︙ | |
Modified src/OFHash.m
from [a3d9e07296]
to [e20cbc12c6].
︙ | | | ︙ | |
12
13
14
15
16
17
18
19
20
21
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
58
|
* Public License, either version 2 or 3, which can be found in the file
* LICENSE.GPLv2 or LICENSE.GPLv3 respectively included in the packaging of this
* file.
*/
#include "config.h"
#import "OFHash.h"
#import "OFNotImplementedException.h"
@implementation OFHash
+ (instancetype)hash
{
return [[[self alloc] init] autorelease];
}
+ (size_t)digestSize
{
@throw [OFNotImplementedException exceptionWithClass: self
selector: _cmd];
}
+ (size_t)blockSize
{
@throw [OFNotImplementedException exceptionWithClass: self
selector: _cmd];
}
- (void)updateWithBuffer: (const void*)buffer
length: (size_t)length
{
@throw [OFNotImplementedException exceptionWithClass: [self class]
selector: _cmd];
}
- (uint8_t*)digest
{
@throw [OFNotImplementedException exceptionWithClass: [self class]
selector: _cmd];
}
- (BOOL)isCalculated
{
return calculated;
}
@end
|
|
|
<
|
>
<
|
>
<
|
>
<
|
>
|
12
13
14
15
16
17
18
19
20
21
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
58
|
* Public License, either version 2 or 3, which can be found in the file
* LICENSE.GPLv2 or LICENSE.GPLv3 respectively included in the packaging of this
* file.
*/
#include "config.h"
#include <stdlib.h>
#import "OFHash.h"
@implementation OFHash
+ (instancetype)hash
{
return [[[self alloc] init] autorelease];
}
+ (size_t)digestSize
{
[self doesNotRecognizeSelector: _cmd];
abort();
}
+ (size_t)blockSize
{
[self doesNotRecognizeSelector: _cmd];
abort();
}
- (void)updateWithBuffer: (const void*)buffer
length: (size_t)length
{
[self doesNotRecognizeSelector: _cmd];
abort();
}
- (uint8_t*)digest
{
[self doesNotRecognizeSelector: _cmd];
abort();
}
- (BOOL)isCalculated
{
return calculated;
}
@end
|
Modified src/OFMapTable.m
from [458807374d]
to [1a1f8d234d].
︙ | | | ︙ | |
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
|
* Public License, either version 2 or 3, which can be found in the file
* LICENSE.GPLv2 or LICENSE.GPLv3 respectively included in the packaging of this
* file.
*/
#include "config.h"
#include <string.h>
#include <assert.h>
#import "OFMapTable.h"
#import "OFEnumerator.h"
#import "OFEnumerationMutationException.h"
#import "OFInvalidArgumentException.h"
#import "OFNotImplementedException.h"
#import "OFOutOfRangeException.h"
#import "macros.h"
#define MIN_CAPACITY 16
struct of_map_table_bucket {
|
>
<
|
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
|
* Public License, either version 2 or 3, which can be found in the file
* LICENSE.GPLv2 or LICENSE.GPLv3 respectively included in the packaging of this
* file.
*/
#include "config.h"
#include <stdlib.h>
#include <string.h>
#include <assert.h>
#import "OFMapTable.h"
#import "OFEnumerator.h"
#import "OFEnumerationMutationException.h"
#import "OFInvalidArgumentException.h"
#import "OFOutOfRangeException.h"
#import "macros.h"
#define MIN_CAPACITY 16
struct of_map_table_bucket {
|
︙ | | | ︙ | |
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
|
initWithKeyFunctions: keyFunctions
valueFunctions: valueFunctions
capacity: capacity] autorelease];
}
- init
{
Class c = [self class];
[self release];
@throw [OFNotImplementedException exceptionWithClass: c
selector: _cmd];
}
- initWithKeyFunctions: (of_map_table_functions_t)keyFunctions_
valueFunctions: (of_map_table_functions_t)valueFunctions_
{
return [self initWithKeyFunctions: keyFunctions_
valueFunctions: valueFunctions_
|
>
|
>
>
|
|
<
>
|
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
|
initWithKeyFunctions: keyFunctions
valueFunctions: valueFunctions
capacity: capacity] autorelease];
}
- init
{
@try {
[self doesNotRecognizeSelector: _cmd];
abort();
} @catch (id e) {
[self release];
@throw e;
}
}
- initWithKeyFunctions: (of_map_table_functions_t)keyFunctions_
valueFunctions: (of_map_table_functions_t)valueFunctions_
{
return [self initWithKeyFunctions: keyFunctions_
valueFunctions: valueFunctions_
|
︙ | | | ︙ | |
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
|
return valueFunctions;
}
@end
@implementation OFMapTableEnumerator
- init
{
Class c = [self class];
[self release];
@throw [OFNotImplementedException exceptionWithClass: c
selector: _cmd];
}
- OF_initWithMapTable: (OFMapTable*)mapTable_
buckets: (struct of_map_table_bucket**)buckets_
capacity: (uint32_t)capacity_
mutationsPointer: (unsigned long*)mutationsPtr_
{
|
>
|
>
>
|
|
<
>
|
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
|
return valueFunctions;
}
@end
@implementation OFMapTableEnumerator
- init
{
@try {
[self doesNotRecognizeSelector: _cmd];
abort();
} @catch (id e) {
[self release];
@throw e;
}
}
- OF_initWithMapTable: (OFMapTable*)mapTable_
buckets: (struct of_map_table_bucket**)buckets_
capacity: (uint32_t)capacity_
mutationsPointer: (unsigned long*)mutationsPtr_
{
|
︙ | | | ︙ | |
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
|
[mapTable release];
[super dealloc];
}
- (void*)nextValue
{
@throw [OFNotImplementedException exceptionWithClass: [self class]
selector: _cmd];
}
- (void)reset
{
if (*mutationsPtr != mutations)
@throw [OFEnumerationMutationException
exceptionWithClass: [mapTable class]
|
<
|
>
|
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
|
[mapTable release];
[super dealloc];
}
- (void*)nextValue
{
[self doesNotRecognizeSelector: _cmd];
abort();
}
- (void)reset
{
if (*mutationsPtr != mutations)
@throw [OFEnumerationMutationException
exceptionWithClass: [mapTable class]
|
︙ | | | ︙ | |
Modified src/OFMutableArray.m
from [7a6a7331fd]
to [6e205df884].
︙ | | | ︙ | |
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
|
* Public License, either version 2 or 3, which can be found in the file
* LICENSE.GPLv2 or LICENSE.GPLv3 respectively included in the packaging of this
* file.
*/
#include "config.h"
#include <string.h>
#include <assert.h>
#import "OFMutableArray.h"
#import "OFMutableArray_adjacent.h"
#import "OFEnumerationMutationException.h"
#import "OFInvalidArgumentException.h"
#import "OFNotImplementedException.h"
#import "OFOutOfRangeException.h"
#import "autorelease.h"
#import "macros.h"
static struct {
Class isa;
|
>
<
|
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
|
* Public License, either version 2 or 3, which can be found in the file
* LICENSE.GPLv2 or LICENSE.GPLv3 respectively included in the packaging of this
* file.
*/
#include "config.h"
#include <stdlib.h>
#include <string.h>
#include <assert.h>
#import "OFMutableArray.h"
#import "OFMutableArray_adjacent.h"
#import "OFEnumerationMutationException.h"
#import "OFInvalidArgumentException.h"
#import "OFOutOfRangeException.h"
#import "autorelease.h"
#import "macros.h"
static struct {
Class isa;
|
︙ | | | ︙ | |
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
|
- (void)release
{
}
- (void)dealloc
{
@throw [OFNotImplementedException exceptionWithClass: [self class]
selector: _cmd];
[super dealloc]; /* Get rid of a stupid warning */
}
@end
@implementation OFMutableArray
+ (void)initialize
{
if (self == [OFMutableArray class])
|
|
>
|
|
>
|
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
|
- (void)release
{
}
- (void)dealloc
{
[self doesNotRecognizeSelector: _cmd];
abort();
/* Get rid of a stupid warning */
[super dealloc];
}
@end
@implementation OFMutableArray
+ (void)initialize
{
if (self == [OFMutableArray class])
|
︙ | | | ︙ | |
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
|
return [super alloc];
}
- init
{
if (object_getClass(self) == [OFMutableArray class]) {
Class c = [self class];
[self release];
@throw [OFNotImplementedException exceptionWithClass: c
selector: _cmd];
}
return [super init];
}
- copy
{
|
>
|
>
>
|
|
<
>
|
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
|
return [super alloc];
}
- init
{
if (object_getClass(self) == [OFMutableArray class]) {
@try {
[self doesNotRecognizeSelector: _cmd];
abort();
} @catch (id e) {
[self release];
@throw e;
}
}
return [super init];
}
- copy
{
|
︙ | | | ︙ | |
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
|
[self insertObjectsFromArray: array
atIndex: [self count]];
}
- (void)insertObject: (id)object
atIndex: (size_t)index
{
@throw [OFNotImplementedException exceptionWithClass: [self class]
selector: _cmd];
}
- (void)insertObjectsFromArray: (OFArray*)array
atIndex: (size_t)index
{
void *pool = objc_autoreleasePoolPush();
OFEnumerator *enumerator = [array objectEnumerator];
|
<
|
>
|
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
|
[self insertObjectsFromArray: array
atIndex: [self count]];
}
- (void)insertObject: (id)object
atIndex: (size_t)index
{
[self doesNotRecognizeSelector: _cmd];
abort();
}
- (void)insertObjectsFromArray: (OFArray*)array
atIndex: (size_t)index
{
void *pool = objc_autoreleasePoolPush();
OFEnumerator *enumerator = [array objectEnumerator];
|
︙ | | | ︙ | |
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
|
objc_autoreleasePoolPop(pool);
}
- (void)replaceObjectAtIndex: (size_t)index
withObject: (id)object
{
@throw [OFNotImplementedException exceptionWithClass: [self class]
selector: _cmd];
}
- (void)setObject: (id)object
atIndexedSubscript: (size_t)index
{
[self replaceObjectAtIndex: index
withObject: object];
|
<
|
>
|
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
|
objc_autoreleasePoolPop(pool);
}
- (void)replaceObjectAtIndex: (size_t)index
withObject: (id)object
{
[self doesNotRecognizeSelector: _cmd];
abort();
}
- (void)setObject: (id)object
atIndexedSubscript: (size_t)index
{
[self replaceObjectAtIndex: index
withObject: object];
|
︙ | | | ︙ | |
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
|
return;
}
}
}
- (void)removeObjectAtIndex: (size_t)index
{
@throw [OFNotImplementedException exceptionWithClass: [self class]
selector: _cmd];
}
- (void)removeObject: (id)object
{
size_t i, count;
if (object == nil)
|
<
|
>
|
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
|
return;
}
}
}
- (void)removeObjectAtIndex: (size_t)index
{
[self doesNotRecognizeSelector: _cmd];
abort();
}
- (void)removeObject: (id)object
{
size_t i, count;
if (object == nil)
|
︙ | | | ︙ | |
Modified src/OFMutableDictionary.m
from [366d9b52dc]
to [89524405ee].
︙ | | | ︙ | |
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
|
* Public License, either version 2 or 3, which can be found in the file
* LICENSE.GPLv2 or LICENSE.GPLv3 respectively included in the packaging of this
* file.
*/
#include "config.h"
#import "OFMutableDictionary_hashtable.h"
#import "OFNotImplementedException.h"
static struct {
Class isa;
} placeholder;
@interface OFMutableDictionary_placeholder: OFDictionary
@end
|
|
|
|
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
|
* Public License, either version 2 or 3, which can be found in the file
* LICENSE.GPLv2 or LICENSE.GPLv3 respectively included in the packaging of this
* file.
*/
#include "config.h"
#include <stdlib.h>
#import "OFMutableDictionary_hashtable.h"
static struct {
Class isa;
} placeholder;
@interface OFMutableDictionary_placeholder: OFDictionary
@end
|
︙ | | | ︙ | |
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
|
- (void)release
{
}
- (void)dealloc
{
@throw [OFNotImplementedException exceptionWithClass: [self class]
selector: _cmd];
[super dealloc]; /* Get rid of a stupid warning */
}
@end
@implementation OFMutableDictionary
+ (void)initialize
{
if (self == [OFMutableDictionary class])
|
|
>
|
|
>
|
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
|
- (void)release
{
}
- (void)dealloc
{
[self doesNotRecognizeSelector: _cmd];
abort();
/* Get rid of a stupid warning */
[super dealloc];
}
@end
@implementation OFMutableDictionary
+ (void)initialize
{
if (self == [OFMutableDictionary class])
|
︙ | | | ︙ | |
128
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
166
167
168
|
return [super alloc];
}
- init
{
if (object_getClass(self) == [OFMutableDictionary class]) {
Class c = [self class];
[self release];
@throw [OFNotImplementedException exceptionWithClass: c
selector: _cmd];
}
return [super init];
}
- (void)setObject: (id)object
forKey: (id)key
{
@throw [OFNotImplementedException exceptionWithClass: [self class]
selector: _cmd];
}
- (void)setObject: (id)object
forKeyedSubscript: (id)key
{
[self setObject: object
forKey: key];
}
- (void)removeObjectForKey: (id)key
{
@throw [OFNotImplementedException exceptionWithClass: [self class]
selector: _cmd];
}
- copy
{
return [[OFDictionary alloc] initWithDictionary: self];
}
|
>
|
>
>
|
|
<
>
<
|
>
<
|
>
|
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
166
167
168
169
170
171
172
173
|
return [super alloc];
}
- init
{
if (object_getClass(self) == [OFMutableDictionary class]) {
@try {
[self doesNotRecognizeSelector: _cmd];
abort();
} @catch (id e) {
[self release];
@throw e;
}
}
return [super init];
}
- (void)setObject: (id)object
forKey: (id)key
{
[self doesNotRecognizeSelector: _cmd];
abort();
}
- (void)setObject: (id)object
forKeyedSubscript: (id)key
{
[self setObject: object
forKey: key];
}
- (void)removeObjectForKey: (id)key
{
[self doesNotRecognizeSelector: _cmd];
abort();
}
- copy
{
return [[OFDictionary alloc] initWithDictionary: self];
}
|
︙ | | | ︙ | |
Modified src/OFMutableSet.m
from [0f6765c635]
to [ebca6379f5].
︙ | | | ︙ | |
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
|
* Public License, either version 2 or 3, which can be found in the file
* LICENSE.GPLv2 or LICENSE.GPLv3 respectively included in the packaging of this
* file.
*/
#include "config.h"
#include <assert.h>
#import "OFMutableSet.h"
#import "OFMutableSet_hashtable.h"
#import "OFNotImplementedException.h"
#import "autorelease.h"
static struct {
Class isa;
} placeholder;
@interface OFMutableSet_placeholder: OFMutableSet
|
>
>
<
<
|
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
|
* Public License, either version 2 or 3, which can be found in the file
* LICENSE.GPLv2 or LICENSE.GPLv3 respectively included in the packaging of this
* file.
*/
#include "config.h"
#include <stdlib.h>
#include <assert.h>
#import "OFMutableSet.h"
#import "OFMutableSet_hashtable.h"
#import "autorelease.h"
static struct {
Class isa;
} placeholder;
@interface OFMutableSet_placeholder: OFMutableSet
|
︙ | | | ︙ | |
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
|
- (void)release
{
}
- (void)dealloc
{
@throw [OFNotImplementedException exceptionWithClass: [self class]
selector: _cmd];
[super dealloc]; /* Get rid of a stupid warning */
}
@end
@implementation OFMutableSet
+ (void)initialize
{
if (self == [OFMutableSet class])
|
|
>
|
|
>
|
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
|
- (void)release
{
}
- (void)dealloc
{
[self doesNotRecognizeSelector: _cmd];
abort();
/* Get rid of a stupid warning */
[super dealloc];
}
@end
@implementation OFMutableSet
+ (void)initialize
{
if (self == [OFMutableSet class])
|
︙ | | | ︙ | |
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
144
145
146
147
148
149
|
return [super alloc];
}
- init
{
if (object_getClass(self) == [OFMutableSet class]) {
Class c = [self class];
[self release];
@throw [OFNotImplementedException exceptionWithClass: c
selector: _cmd];
}
return [super init];
}
- (void)addObject: (id)object
{
@throw [OFNotImplementedException exceptionWithClass: [self class]
selector: _cmd];
}
- (void)removeObject: (id)object
{
@throw [OFNotImplementedException exceptionWithClass: [self class]
selector: _cmd];
}
- (void)minusSet: (OFSet*)set
{
void *pool = objc_autoreleasePoolPush();
OFEnumerator *enumerator = [set objectEnumerator];
id object;
|
>
|
>
>
|
|
<
>
<
|
>
<
|
>
|
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
144
145
146
147
148
149
150
151
152
153
154
|
return [super alloc];
}
- init
{
if (object_getClass(self) == [OFMutableSet class]) {
@try {
[self doesNotRecognizeSelector: _cmd];
abort();
} @catch (id e) {
[self release];
@throw e;
}
}
return [super init];
}
- (void)addObject: (id)object
{
[self doesNotRecognizeSelector: _cmd];
abort();
}
- (void)removeObject: (id)object
{
[self doesNotRecognizeSelector: _cmd];
abort();
}
- (void)minusSet: (OFSet*)set
{
void *pool = objc_autoreleasePoolPush();
OFEnumerator *enumerator = [set objectEnumerator];
id object;
|
︙ | | | ︙ | |
Modified src/OFMutableString.m
from [5fcf1bb841]
to [e77a1233fc].
︙ | | | ︙ | |
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
|
#include <sys/types.h>
#import "OFString.h"
#import "OFMutableString_UTF8.h"
#import "OFInvalidArgumentException.h"
#import "OFInvalidFormatException.h"
#import "OFNotImplementedException.h"
#import "OFOutOfRangeException.h"
#import "autorelease.h"
#import "macros.h"
#import "of_asprintf.h"
#import "unicode.h"
|
<
|
23
24
25
26
27
28
29
30
31
32
33
34
35
36
|
#include <sys/types.h>
#import "OFString.h"
#import "OFMutableString_UTF8.h"
#import "OFInvalidArgumentException.h"
#import "OFInvalidFormatException.h"
#import "OFOutOfRangeException.h"
#import "autorelease.h"
#import "macros.h"
#import "of_asprintf.h"
#import "unicode.h"
|
︙ | | | ︙ | |
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
|
- (void)release
{
}
- (void)dealloc
{
@throw [OFNotImplementedException exceptionWithClass: [self class]
selector: _cmd];
[super dealloc]; /* Get rid of a stupid warning */
}
@end
@implementation OFMutableString
+ (void)initialize
{
if (self == [OFMutableString class])
|
|
>
|
|
>
|
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
|
- (void)release
{
}
- (void)dealloc
{
[self doesNotRecognizeSelector: _cmd];
abort();
/* Get rid of a stupid warning */
[super dealloc];
}
@end
@implementation OFMutableString
+ (void)initialize
{
if (self == [OFMutableString class])
|
︙ | | | ︙ | |
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
|
objc_autoreleasePoolPop(pool);
}
- (void)setCharacter: (of_unichar_t)character
atIndex: (size_t)index
{
@throw [OFNotImplementedException exceptionWithClass: [self class]
selector: _cmd];
}
- (void)appendUTF8String: (const char*)UTF8String
{
void *pool = objc_autoreleasePoolPush();
[self appendString: [OFString stringWithUTF8String: UTF8String]];
|
<
|
>
|
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
|
objc_autoreleasePoolPop(pool);
}
- (void)setCharacter: (of_unichar_t)character
atIndex: (size_t)index
{
[self doesNotRecognizeSelector: _cmd];
abort();
}
- (void)appendUTF8String: (const char*)UTF8String
{
void *pool = objc_autoreleasePoolPush();
[self appendString: [OFString stringWithUTF8String: UTF8String]];
|
︙ | | | ︙ | |
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
|
wordStartTableSize: OF_UNICODE_TITLECASE_TABLE_SIZE
wordMiddleTableSize: OF_UNICODE_LOWERCASE_TABLE_SIZE];
}
- (void)insertString: (OFString*)string
atIndex: (size_t)index
{
@throw [OFNotImplementedException exceptionWithClass: [self class]
selector: _cmd];
}
- (void)deleteCharactersInRange: (of_range_t)range
{
@throw [OFNotImplementedException exceptionWithClass: [self class]
selector: _cmd];
}
- (void)replaceCharactersInRange: (of_range_t)range
withString: (OFString*)replacement
{
[self deleteCharactersInRange: range];
[self insertString: replacement
|
<
|
>
<
|
>
|
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
|
wordStartTableSize: OF_UNICODE_TITLECASE_TABLE_SIZE
wordMiddleTableSize: OF_UNICODE_LOWERCASE_TABLE_SIZE];
}
- (void)insertString: (OFString*)string
atIndex: (size_t)index
{
[self doesNotRecognizeSelector: _cmd];
abort();
}
- (void)deleteCharactersInRange: (of_range_t)range
{
[self doesNotRecognizeSelector: _cmd];
abort();
}
- (void)replaceCharactersInRange: (of_range_t)range
withString: (OFString*)replacement
{
[self deleteCharactersInRange: range];
[self insertString: replacement
|
︙ | | | ︙ | |
Modified src/OFNull.m
from [469bfd7104]
to [fdbe044d7b].
︙ | | | ︙ | |
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
|
* Public License, either version 2 or 3, which can be found in the file
* LICENSE.GPLv2 or LICENSE.GPLv3 respectively included in the packaging of this
* file.
*/
#include "config.h"
#import "OFNull.h"
#import "OFString.h"
#import "OFXMLElement.h"
#import "OFInvalidArgumentException.h"
#import "OFNotImplementedException.h"
#import "autorelease.h"
static OFNull *null = nil;
@implementation OFNull
+ (void)initialize
|
>
>
<
|
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
|
* Public License, either version 2 or 3, which can be found in the file
* LICENSE.GPLv2 or LICENSE.GPLv3 respectively included in the packaging of this
* file.
*/
#include "config.h"
#include <stdlib.h>
#import "OFNull.h"
#import "OFString.h"
#import "OFXMLElement.h"
#import "OFInvalidArgumentException.h"
#import "autorelease.h"
static OFNull *null = nil;
@implementation OFNull
+ (void)initialize
|
︙ | | | ︙ | |
104
105
106
107
108
109
110
111
112
113
114
115
|
- (unsigned int)retainCount
{
return OF_RETAIN_COUNT_MAX;
}
- (void)dealloc
{
@throw [OFNotImplementedException exceptionWithClass: [self class]
selector: _cmd];
[super dealloc]; /* Get rid of a stupid warning */
}
@end
|
|
>
|
|
>
|
105
106
107
108
109
110
111
112
113
114
115
116
117
118
|
- (unsigned int)retainCount
{
return OF_RETAIN_COUNT_MAX;
}
- (void)dealloc
{
[self doesNotRecognizeSelector: _cmd];
abort();
/* Get rid of a stupid warning */
[super dealloc];
}
@end
|
Modified src/OFNumber.m
from [a189f6857c]
to [ba1adda867].
︙ | | | ︙ | |
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
|
* Public License, either version 2 or 3, which can be found in the file
* LICENSE.GPLv2 or LICENSE.GPLv3 respectively included in the packaging of this
* file.
*/
#include "config.h"
#include <math.h>
#import "OFNumber.h"
#import "OFString.h"
#import "OFXMLElement.h"
#import "OFXMLAttribute.h"
#import "OFInvalidArgumentException.h"
#import "OFInvalidFormatException.h"
#import "OFNotImplementedException.h"
#import "autorelease.h"
#import "macros.h"
#define RETURN_AS(t) \
switch (type) { \
case OF_NUMBER_BOOL: \
|
>
>
<
|
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
|
* Public License, either version 2 or 3, which can be found in the file
* LICENSE.GPLv2 or LICENSE.GPLv3 respectively included in the packaging of this
* file.
*/
#include "config.h"
#include <stdlib.h>
#include <math.h>
#import "OFNumber.h"
#import "OFString.h"
#import "OFXMLElement.h"
#import "OFXMLAttribute.h"
#import "OFInvalidArgumentException.h"
#import "OFInvalidFormatException.h"
#import "autorelease.h"
#import "macros.h"
#define RETURN_AS(t) \
switch (type) { \
case OF_NUMBER_BOOL: \
|
︙ | | | ︙ | |
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
|
return [OFNumber numberWithIntPtr: \
value.intptr o [n intPtrValue]]; \
case OF_NUMBER_UINTPTR: \
return [OFNumber numberWithUIntPtr: \
value.uintptr o [n uIntPtrValue]]; \
case OF_NUMBER_FLOAT: \
case OF_NUMBER_DOUBLE: \
@throw [OFNotImplementedException \
exceptionWithClass: [self class] \
selector: _cmd]; \
default: \
@throw [OFInvalidFormatException \
exceptionWithClass: [self class]]; \
}
#define CALCULATE3(o) \
|
|
|
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
|
return [OFNumber numberWithIntPtr: \
value.intptr o [n intPtrValue]]; \
case OF_NUMBER_UINTPTR: \
return [OFNumber numberWithUIntPtr: \
value.uintptr o [n uIntPtrValue]]; \
case OF_NUMBER_FLOAT: \
case OF_NUMBER_DOUBLE: \
@throw [OFInvalidArgumentException \
exceptionWithClass: [self class] \
selector: _cmd]; \
default: \
@throw [OFInvalidFormatException \
exceptionWithClass: [self class]]; \
}
#define CALCULATE3(o) \
|
︙ | | | ︙ | |
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
|
+ (instancetype)numberWithDouble: (double)double_
{
return [[[self alloc] initWithDouble: double_] autorelease];
}
- init
{
@throw [OFNotImplementedException exceptionWithClass: [self class]
selector: _cmd];
}
- initWithBool: (BOOL)bool_
{
self = [super init];
value.bool_ = (bool_ ? YES : NO);
|
|
|
>
>
>
>
>
|
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
|
+ (instancetype)numberWithDouble: (double)double_
{
return [[[self alloc] initWithDouble: double_] autorelease];
}
- init
{
@try {
[self doesNotRecognizeSelector: _cmd];
abort();
} @catch (id e) {
[self release];
@throw e;
}
}
- initWithBool: (BOOL)bool_
{
self = [super init];
value.bool_ = (bool_ ? YES : NO);
|
︙ | | | ︙ | |
Modified src/OFObject+Serialization.m
from [c7f6b6d6fd]
to [15c867dc7d].
︙ | | | ︙ | |
11
12
13
14
15
16
17
18
19
20
21
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
|
* Alternatively, it may be distributed under the terms of the GNU General
* Public License, either version 2 or 3, which can be found in the file
* LICENSE.GPLv2 or LICENSE.GPLv3 respectively included in the packaging of this
* file.
*/
#include "config.h"
#import "OFObject.h"
#import "OFObject+Serialization.h"
#import "OFSerialization.h"
#import "OFString.h"
#import "OFXMLElement.h"
#import "OFNotImplementedException.h"
#import "autorelease.h"
int _OFObject_Serialization_reference;
@implementation OFObject (Serialization)
- (OFString*)stringBySerializing
{
void *pool;
OFXMLElement *element;
OFXMLElement *root;
OFString *ret;
if (![self conformsToProtocol: @protocol(OFSerialization)])
@throw [OFNotImplementedException
exceptionWithClass: [self class]
selector: @selector(stringBySerializing)];
pool = objc_autoreleasePoolPush();
element = [(id)self XMLElementBySerializing];
root = [OFXMLElement elementWithName: @"serialization"
namespace: OF_SERIALIZATION_NS];
[root addAttributeWithName: @"version"
|
>
>
<
<
|
<
|
<
>
>
|
11
12
13
14
15
16
17
18
19
20
21
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
|
* Alternatively, it may be distributed under the terms of the GNU General
* Public License, either version 2 or 3, which can be found in the file
* LICENSE.GPLv2 or LICENSE.GPLv3 respectively included in the packaging of this
* file.
*/
#include "config.h"
#include <stdlib.h>
#import "OFObject.h"
#import "OFObject+Serialization.h"
#import "OFSerialization.h"
#import "OFString.h"
#import "OFXMLElement.h"
#import "autorelease.h"
int _OFObject_Serialization_reference;
@implementation OFObject (Serialization)
- (OFString*)stringBySerializing
{
void *pool;
OFXMLElement *element;
OFXMLElement *root;
OFString *ret;
if (![self conformsToProtocol: @protocol(OFSerialization)]) {
[self doesNotRecognizeSelector: _cmd];
abort();
}
pool = objc_autoreleasePoolPush();
element = [(id)self XMLElementBySerializing];
root = [OFXMLElement elementWithName: @"serialization"
namespace: OF_SERIALIZATION_NS];
[root addAttributeWithName: @"version"
|
︙ | | | ︙ | |
Modified src/OFObject.h
from [c663f1ca8f]
to [fdedfa544a].
︙ | | | ︙ | |
818
819
820
821
822
823
824
825
826
827
828
829
830
831
|
*
* @note When the message should not be forwarded, you should not return nil,
* but instead return the result of the superclass!
*
* @return The target to forward the message to
*/
- (id)forwardingTargetForSelector: (SEL)selector;
@end
/*!
* @brief A protocol for the creation of copies.
*/
@protocol OFCopying
/*!
|
>
>
>
>
>
>
>
>
>
>
|
818
819
820
821
822
823
824
825
826
827
828
829
830
831
832
833
834
835
836
837
838
839
840
841
|
*
* @note When the message should not be forwarded, you should not return nil,
* but instead return the result of the superclass!
*
* @return The target to forward the message to
*/
- (id)forwardingTargetForSelector: (SEL)selector;
/*!
* @brief Handles messages which are not understood by the receiver.
*
* @warning If you override this method, you must make sure that it never
* returns.
*
* @param selector The selector not understood by the receiver
*/
- (void)doesNotRecognizeSelector: (SEL)selector;
@end
/*!
* @brief A protocol for the creation of copies.
*/
@protocol OFCopying
/*!
|
︙ | | | ︙ | |
Modified src/OFObject.m
from [9c302a662d]
to [23e21a638e].
︙ | | | ︙ | |
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
|
exceptionWithClass: [object class]
object: object];
}
void
of_method_not_found(id obj, SEL sel)
{
fprintf(stderr, "Runtime error: Selector %s is not implemented in "
"class %s!\n", sel_getName(sel),
class_getName(object_getClass(obj)));
abort();
}
#ifdef OF_OBJFW_RUNTIME
static IMP
forward_handler(id obj, SEL sel)
{
|
|
|
<
>
>
>
>
|
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
|
exceptionWithClass: [object class]
object: object];
}
void
of_method_not_found(id obj, SEL sel)
{
[obj doesNotRecognizeSelector: sel];
/*
* Just in case doesNotRecognizeSelector: returned, even though it must
* never return.
*/
abort();
}
#ifdef OF_OBJFW_RUNTIME
static IMP
forward_handler(id obj, SEL sel)
{
|
︙ | | | ︙ | |
972
973
974
975
976
977
978
979
980
981
982
983
984
985
|
free(PRE_MEM(pointer));
}
- (id)forwardingTargetForSelector: (SEL)selector
{
return nil;
}
- retain
{
#if defined(OF_ATOMIC_OPS)
of_atomic_inc_32(&PRE_IVARS->retainCount);
#elif defined(OF_THREADS)
OF_ENSURE(of_spinlock_lock(&PRE_IVARS->retainCountSpinlock));
|
>
>
>
>
>
>
|
975
976
977
978
979
980
981
982
983
984
985
986
987
988
989
990
991
992
993
994
|
free(PRE_MEM(pointer));
}
- (id)forwardingTargetForSelector: (SEL)selector
{
return nil;
}
- (void)doesNotRecognizeSelector: (SEL)selector
{
@throw [OFNotImplementedException exceptionWithClass: [self class]
selector: selector];
}
- retain
{
#if defined(OF_ATOMIC_OPS)
of_atomic_inc_32(&PRE_IVARS->retainCount);
#elif defined(OF_THREADS)
OF_ENSURE(of_spinlock_lock(&PRE_IVARS->retainCountSpinlock));
|
︙ | | | ︙ | |
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
|
free((char*)self - PRE_IVARS_ALIGN);
}
/* Required to use properties with the Apple runtime */
- copyWithZone: (void*)zone
{
if OF_UNLIKELY (zone != NULL)
@throw [OFNotImplementedException
exceptionWithClass: [self class]
selector: _cmd];
return [(id)self copy];
}
- mutableCopyWithZone: (void*)zone
{
if OF_UNLIKELY (zone != NULL)
@throw [OFNotImplementedException
exceptionWithClass: [self class]
selector: _cmd];
return [(id)self mutableCopy];
}
/*
* Those are needed as the root class is the superclass of the root class's
* metaclass and thus instance methods can be sent to class objects as well.
*/
+ (void*)allocMemoryWithSize: (size_t)size
{
@throw [OFNotImplementedException exceptionWithClass: self
selector: _cmd];
}
+ (void*)allocMemoryWithSize: (size_t)size
count: (size_t)count
{
@throw [OFNotImplementedException exceptionWithClass: self
selector: _cmd];
}
+ (void*)resizeMemory: (void*)pointer
size: (size_t)size
{
@throw [OFNotImplementedException exceptionWithClass: self
selector: _cmd];
}
+ (void*)resizeMemory: (void*)pointer
size: (size_t)size
count: (size_t)count
{
@throw [OFNotImplementedException exceptionWithClass: self
selector: _cmd];
}
+ (void)freeMemory: (void*)pointer
{
@throw [OFNotImplementedException exceptionWithClass: self
selector: _cmd];
}
+ retain
{
return self;
}
|
|
<
|
|
>
|
<
|
|
>
<
|
>
<
|
>
<
|
>
<
|
>
<
|
>
|
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
|
free((char*)self - PRE_IVARS_ALIGN);
}
/* Required to use properties with the Apple runtime */
- copyWithZone: (void*)zone
{
if OF_UNLIKELY (zone != NULL) {
[self doesNotRecognizeSelector: _cmd];
abort();
}
return [(id)self copy];
}
- mutableCopyWithZone: (void*)zone
{
if OF_UNLIKELY (zone != NULL) {
[self doesNotRecognizeSelector: _cmd];
abort();
}
return [(id)self mutableCopy];
}
/*
* Those are needed as the root class is the superclass of the root class's
* metaclass and thus instance methods can be sent to class objects as well.
*/
+ (void*)allocMemoryWithSize: (size_t)size
{
[self doesNotRecognizeSelector: _cmd];
abort();
}
+ (void*)allocMemoryWithSize: (size_t)size
count: (size_t)count
{
[self doesNotRecognizeSelector: _cmd];
abort();
}
+ (void*)resizeMemory: (void*)pointer
size: (size_t)size
{
[self doesNotRecognizeSelector: _cmd];
abort();
}
+ (void*)resizeMemory: (void*)pointer
size: (size_t)size
count: (size_t)count
{
[self doesNotRecognizeSelector: _cmd];
abort();
}
+ (void)freeMemory: (void*)pointer
{
[self doesNotRecognizeSelector: _cmd];
abort();
}
+ retain
{
return self;
}
|
︙ | | | ︙ | |
1134
1135
1136
1137
1138
1139
1140
1141
1142
1143
1144
1145
1146
1147
1148
1149
1150
1151
1152
1153
1154
1155
1156
|
+ (void)release
{
}
+ (void)dealloc
{
@throw [OFNotImplementedException exceptionWithClass: self
selector: _cmd];
}
+ copyWithZone: (void*)zone
{
@throw [OFNotImplementedException exceptionWithClass: self
selector: _cmd];
}
+ mutableCopyWithZone: (void*)zone
{
@throw [OFNotImplementedException exceptionWithClass: self
selector: _cmd];
}
@end
|
<
|
>
<
|
>
<
|
>
|
1143
1144
1145
1146
1147
1148
1149
1150
1151
1152
1153
1154
1155
1156
1157
1158
1159
1160
1161
1162
1163
1164
1165
|
+ (void)release
{
}
+ (void)dealloc
{
[self doesNotRecognizeSelector: _cmd];
abort();
}
+ copyWithZone: (void*)zone
{
[self doesNotRecognizeSelector: _cmd];
abort();
}
+ mutableCopyWithZone: (void*)zone
{
[self doesNotRecognizeSelector: _cmd];
abort();
}
@end
|
Modified src/OFPlugin.m
from [26711ccaf1]
to [260b8dfd9b].
︙ | | | ︙ | |
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
|
#include <dlfcn.h>
#endif
#import "OFPlugin.h"
#import "OFString.h"
#import "OFInitializationFailedException.h"
#import "OFNotImplementedException.h"
#import "autorelease.h"
#ifdef _WIN32
# define dlopen(file, mode) LoadLibrary(file)
# define dlsym(handle, symbol) GetProcAddress(handle, symbol)
# define dlclose(handle) FreeLibrary(handle)
|
<
|
23
24
25
26
27
28
29
30
31
32
33
34
35
36
|
#include <dlfcn.h>
#endif
#import "OFPlugin.h"
#import "OFString.h"
#import "OFInitializationFailedException.h"
#import "autorelease.h"
#ifdef _WIN32
# define dlopen(file, mode) LoadLibrary(file)
# define dlsym(handle, symbol) GetProcAddress(handle, symbol)
# define dlclose(handle) FreeLibrary(handle)
|
︙ | | | ︙ | |
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
|
plugin->handle = handle;
return plugin;
}
- init
{
if (object_getClass(self) == [OFPlugin class]) {
Class c = [self class];
[self release];
@throw [OFNotImplementedException exceptionWithClass: c
selector: _cmd];
}
return [super init];
}
- (void)dealloc
{
|
>
|
>
>
|
|
<
>
|
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
|
plugin->handle = handle;
return plugin;
}
- init
{
if (object_getClass(self) == [OFPlugin class]) {
@try {
[self doesNotRecognizeSelector: _cmd];
abort();
} @catch (id e) {
[self release];
@throw e;
}
}
return [super init];
}
- (void)dealloc
{
|
︙ | | | ︙ | |
Modified src/OFProcess.m
from [ed7607de4d]
to [77862565be].
︙ | | | ︙ | |
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
|
#endif
#import "OFProcess.h"
#import "OFString.h"
#import "OFArray.h"
#import "OFInitializationFailedException.h"
#import "OFNotImplementedException.h"
#import "OFReadFailedException.h"
#import "OFWriteFailedException.h"
#ifdef _WIN32
# include <windows.h>
#endif
|
<
|
24
25
26
27
28
29
30
31
32
33
34
35
36
37
|
#endif
#import "OFProcess.h"
#import "OFString.h"
#import "OFArray.h"
#import "OFInitializationFailedException.h"
#import "OFReadFailedException.h"
#import "OFWriteFailedException.h"
#ifdef _WIN32
# include <windows.h>
#endif
|
︙ | | | ︙ | |
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
|
}
- (int)fileDescriptorForReading
{
#ifndef _WIN32
return readPipe[0];
#else
@throw [OFNotImplementedException exceptionWithClass: [self class]
selector: _cmd];
#endif
}
- (int)fileDescriptorForWriting
{
#ifndef _WIN32
return writePipe[1];
#else
@throw [OFNotImplementedException exceptionWithClass: [self class]
selector: _cmd];
#endif
}
- (void)closeForWriting
{
#ifndef _WIN32
if (writePipe[1] != -1)
|
<
|
>
<
|
>
|
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
|
}
- (int)fileDescriptorForReading
{
#ifndef _WIN32
return readPipe[0];
#else
[self doesNotRecognizeSelector: _cmd];
abort();
#endif
}
- (int)fileDescriptorForWriting
{
#ifndef _WIN32
return writePipe[1];
#else
[self doesNotRecognizeSelector: _cmd];
abort();
#endif
}
- (void)closeForWriting
{
#ifndef _WIN32
if (writePipe[1] != -1)
|
︙ | | | ︙ | |
Modified src/OFSeekableStream.m
from [ff18537f89]
to [432d090484].
︙ | | | ︙ | |
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
|
*
* Alternatively, it may be distributed under the terms of the GNU General
* Public License, either version 2 or 3, which can be found in the file
* LICENSE.GPLv2 or LICENSE.GPLv3 respectively included in the packaging of this
* file.
*/
#import "OFSeekableStream.h"
#import "OFNotImplementedException.h"
@implementation OFSeekableStream
- (void)lowlevelSeekToOffset: (off_t)offset
whence: (int)whence
{
@throw [OFNotImplementedException exceptionWithClass: [self class]
selector: _cmd];
}
- (void)seekToOffset: (off_t)offset
whence: (int)whence
{
[self lowlevelSeekToOffset: offset
whence: whence];
[self freeMemory: cache];
cache = NULL;
cacheLength = 0;
}
@end
|
>
|
>
|
<
|
>
|
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
|
*
* Alternatively, it may be distributed under the terms of the GNU General
* Public License, either version 2 or 3, which can be found in the file
* LICENSE.GPLv2 or LICENSE.GPLv3 respectively included in the packaging of this
* file.
*/
#include "config.h"
#include <stdlib.h>
#import "OFSeekableStream.h"
@implementation OFSeekableStream
- (void)lowlevelSeekToOffset: (off_t)offset
whence: (int)whence
{
[self doesNotRecognizeSelector: _cmd];
abort();
}
- (void)seekToOffset: (off_t)offset
whence: (int)whence
{
[self lowlevelSeekToOffset: offset
whence: whence];
[self freeMemory: cache];
cache = NULL;
cacheLength = 0;
}
@end
|
Modified src/OFSet.m
from [f4c7729752]
to [fdc84a25fe].
︙ | | | ︙ | |
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
|
* Public License, either version 2 or 3, which can be found in the file
* LICENSE.GPLv2 or LICENSE.GPLv3 respectively included in the packaging of this
* file.
*/
#include "config.h"
#import "OFSet.h"
#import "OFSet_hashtable.h"
#import "OFString.h"
#import "OFXMLElement.h"
#import "OFNotImplementedException.h"
#import "autorelease.h"
static struct {
Class isa;
} placeholder;
@interface OFSet_placeholder: OFSet
|
>
>
<
<
|
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
|
* Public License, either version 2 or 3, which can be found in the file
* LICENSE.GPLv2 or LICENSE.GPLv3 respectively included in the packaging of this
* file.
*/
#include "config.h"
#include <stdlib.h>
#import "OFSet.h"
#import "OFSet_hashtable.h"
#import "OFString.h"
#import "OFXMLElement.h"
#import "autorelease.h"
static struct {
Class isa;
} placeholder;
@interface OFSet_placeholder: OFSet
|
︙ | | | ︙ | |
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
|
- (void)release
{
}
- (void)dealloc
{
@throw [OFNotImplementedException exceptionWithClass: [self class]
selector: _cmd];
[super dealloc]; /* Get rid of a stupid warning */
}
@end
@implementation OFSet
+ (void)initialize
{
if (self == [OFSet class])
|
|
>
|
|
>
|
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
|
- (void)release
{
}
- (void)dealloc
{
[self doesNotRecognizeSelector: _cmd];
abort();
/* Get rid of a stupid warning */
[super dealloc];
}
@end
@implementation OFSet
+ (void)initialize
{
if (self == [OFSet class])
|
︙ | | | ︙ | |
151
152
153
154
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
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
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
|
return [[[self alloc] initWithObjects: objects
count: count] autorelease];
}
- init
{
if (object_getClass(self) == [OFSet class]) {
Class c = [self class];
[self release];
@throw [OFNotImplementedException exceptionWithClass: c
selector: _cmd];
}
return [super init];
}
- initWithSet: (OFSet*)set
{
Class c = [self class];
[self release];
@throw [OFNotImplementedException exceptionWithClass: c
selector: _cmd];
}
- initWithArray: (OFArray*)array
{
Class c = [self class];
[self release];
@throw [OFNotImplementedException exceptionWithClass: c
selector: _cmd];
}
- (id)initWithObjects: (id)firstObject, ...
{
id ret;
va_list arguments;
va_start(arguments, firstObject);
ret = [self initWithObject: firstObject
arguments: arguments];
va_end(arguments);
return ret;
}
- initWithObjects: (id const*)objects
count: (size_t)count
{
Class c = [self class];
[self release];
@throw [OFNotImplementedException exceptionWithClass: c
selector: _cmd];
}
- initWithObject: (id)firstObject
arguments: (va_list)arguments
{
Class c = [self class];
[self release];
@throw [OFNotImplementedException exceptionWithClass: c
selector: _cmd];
}
- initWithSerialization: (OFXMLElement*)element
{
Class c = [self class];
[self release];
@throw [OFNotImplementedException exceptionWithClass: c
selector: _cmd];
}
- (size_t)count
{
@throw [OFNotImplementedException exceptionWithClass: [self class]
selector: _cmd];
}
- (BOOL)containsObject: (id)object
{
@throw [OFNotImplementedException exceptionWithClass: [self class]
selector: _cmd];
}
- (OFEnumerator*)objectEnumerator
{
@throw [OFNotImplementedException exceptionWithClass: [self class]
selector: _cmd];
}
- (int)countByEnumeratingWithState: (of_fast_enumeration_state_t*)state
objects: (id*)objects
count: (int)count
{
@throw [OFNotImplementedException exceptionWithClass: [self class]
selector: _cmd];
}
- (BOOL)isEqual: (id)object
{
OFSet *otherSet;
if (![object isKindOfClass: [OFSet class]])
|
>
|
>
>
|
|
<
>
>
|
>
>
|
|
<
|
|
>
>
|
>
>
|
>
>
>
|
>
>
>
>
|
>
>
>
>
>
<
<
<
<
<
<
<
<
<
>
|
>
>
|
|
<
>
>
|
>
>
|
|
<
>
<
|
>
<
|
>
<
|
>
<
|
>
|
153
154
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
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
236
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
263
264
265
266
267
268
269
270
271
272
|
return [[[self alloc] initWithObjects: objects
count: count] autorelease];
}
- init
{
if (object_getClass(self) == [OFSet class]) {
@try {
[self doesNotRecognizeSelector: _cmd];
abort();
} @catch (id e) {
[self release];
@throw e;
}
}
return [super init];
}
- initWithSet: (OFSet*)set
{
@try {
[self doesNotRecognizeSelector: _cmd];
abort();
} @catch (id e) {
[self release];
@throw e;
}
}
- initWithArray: (OFArray*)array
{
@try {
[self doesNotRecognizeSelector: _cmd];
abort();
} @catch (id e) {
[self release];
@throw e;
}
}
- initWithObjects: (id const*)objects
count: (size_t)count
{
@try {
[self doesNotRecognizeSelector: _cmd];
abort();
} @catch (id e) {
[self release];
@throw e;
}
}
- (id)initWithObjects: (id)firstObject, ...
{
id ret;
va_list arguments;
va_start(arguments, firstObject);
ret = [self initWithObject: firstObject
arguments: arguments];
va_end(arguments);
return ret;
}
- initWithObject: (id)firstObject
arguments: (va_list)arguments
{
@try {
[self doesNotRecognizeSelector: _cmd];
abort();
} @catch (id e) {
[self release];
@throw e;
}
}
- initWithSerialization: (OFXMLElement*)element
{
@try {
[self doesNotRecognizeSelector: _cmd];
abort();
} @catch (id e) {
[self release];
@throw e;
}
}
- (size_t)count
{
[self doesNotRecognizeSelector: _cmd];
abort();
}
- (BOOL)containsObject: (id)object
{
[self doesNotRecognizeSelector: _cmd];
abort();
}
- (OFEnumerator*)objectEnumerator
{
[self doesNotRecognizeSelector: _cmd];
abort();
}
- (int)countByEnumeratingWithState: (of_fast_enumeration_state_t*)state
objects: (id*)objects
count: (int)count
{
[self doesNotRecognizeSelector: _cmd];
abort();
}
- (BOOL)isEqual: (id)object
{
OFSet *otherSet;
if (![object isKindOfClass: [OFSet class]])
|
︙ | | | ︙ | |
Modified src/OFSortedList.m
from [679b0761d3]
to [85917055a7].
︙ | | | ︙ | |
12
13
14
15
16
17
18
19
20
21
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
|
* Public License, either version 2 or 3, which can be found in the file
* LICENSE.GPLv2 or LICENSE.GPLv3 respectively included in the packaging of this
* file.
*/
#include "config.h"
#import "OFSortedList.h"
#import "OFNotImplementedException.h"
@implementation OFSortedList
- (of_list_object_t*)appendObject: (id)object
{
@throw [OFNotImplementedException exceptionWithClass: [self class]
selector: _cmd];
}
- (of_list_object_t*)prependObject: (id)object
{
@throw [OFNotImplementedException exceptionWithClass: [self class]
selector: _cmd];
}
- (of_list_object_t*)insertObject: (id)object
beforeListObject: (of_list_object_t*)listObject
{
@throw [OFNotImplementedException exceptionWithClass: [self class]
selector: _cmd];
}
- (of_list_object_t*)insertObject: (id)object
afterListObject: (of_list_object_t*)listObject
{
@throw [OFNotImplementedException exceptionWithClass: [self class]
selector: _cmd];
}
- (of_list_object_t*)insertObject: (id <OFComparing>)object
{
of_list_object_t *iter;
for (iter = lastListObject; iter != NULL; iter = iter->previous) {
|
|
|
<
|
>
<
|
>
<
|
>
<
|
>
|
12
13
14
15
16
17
18
19
20
21
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
|
* Public License, either version 2 or 3, which can be found in the file
* LICENSE.GPLv2 or LICENSE.GPLv3 respectively included in the packaging of this
* file.
*/
#include "config.h"
#include <stdlib.h>
#import "OFSortedList.h"
@implementation OFSortedList
- (of_list_object_t*)appendObject: (id)object
{
[self doesNotRecognizeSelector: _cmd];
abort();
}
- (of_list_object_t*)prependObject: (id)object
{
[self doesNotRecognizeSelector: _cmd];
abort();
}
- (of_list_object_t*)insertObject: (id)object
beforeListObject: (of_list_object_t*)listObject
{
[self doesNotRecognizeSelector: _cmd];
abort();
}
- (of_list_object_t*)insertObject: (id)object
afterListObject: (of_list_object_t*)listObject
{
[self doesNotRecognizeSelector: _cmd];
abort();
}
- (of_list_object_t*)insertObject: (id <OFComparing>)object
{
of_list_object_t *iter;
for (iter = lastListObject; iter != NULL; iter = iter->previous) {
|
︙ | | | ︙ | |
Modified src/OFStream.m
from [4d480da639]
to [31e482b9ed].
︙ | | | ︙ | |
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
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
|
#import "OFStream.h"
#import "OFString.h"
#import "OFDataArray.h"
#import "OFRunLoop.h"
#import "OFInvalidArgumentException.h"
#import "OFInvalidFormatException.h"
#import "OFNotImplementedException.h"
#import "OFSetOptionFailedException.h"
#import "macros.h"
#import "of_asprintf.h"
@implementation OFStream
#ifndef _WIN32
+ (void)initialize
{
if (self == [OFStream class])
signal(SIGPIPE, SIG_IGN);
}
#endif
- init
{
if (object_getClass(self) == [OFStream class]) {
Class c = [self class];
[self release];
@throw [OFNotImplementedException exceptionWithClass: c
selector: _cmd];
}
self = [super init];
cache = NULL;
writeBuffer = NULL;
blocking = YES;
return self;
}
- (BOOL)lowlevelIsAtEndOfStream
{
@throw [OFNotImplementedException exceptionWithClass: [self class]
selector: _cmd];
}
- (size_t)lowlevelReadIntoBuffer: (void*)buffer
length: (size_t)length
{
@throw [OFNotImplementedException exceptionWithClass: [self class]
selector: _cmd];
}
- (void)lowlevelWriteBuffer: (const void*)buffer
length: (size_t)length
{
@throw [OFNotImplementedException exceptionWithClass: [self class]
selector: _cmd];
}
- copy
{
return [self retain];
}
|
<
>
|
>
>
|
|
<
>
<
|
>
<
|
>
<
|
>
|
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
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
|
#import "OFStream.h"
#import "OFString.h"
#import "OFDataArray.h"
#import "OFRunLoop.h"
#import "OFInvalidArgumentException.h"
#import "OFInvalidFormatException.h"
#import "OFSetOptionFailedException.h"
#import "macros.h"
#import "of_asprintf.h"
@implementation OFStream
#ifndef _WIN32
+ (void)initialize
{
if (self == [OFStream class])
signal(SIGPIPE, SIG_IGN);
}
#endif
- init
{
if (object_getClass(self) == [OFStream class]) {
@try {
[self doesNotRecognizeSelector: _cmd];
abort();
} @catch (id e) {
[self release];
@throw e;
}
}
self = [super init];
cache = NULL;
writeBuffer = NULL;
blocking = YES;
return self;
}
- (BOOL)lowlevelIsAtEndOfStream
{
[self doesNotRecognizeSelector: _cmd];
abort();
}
- (size_t)lowlevelReadIntoBuffer: (void*)buffer
length: (size_t)length
{
[self doesNotRecognizeSelector: _cmd];
abort();
}
- (void)lowlevelWriteBuffer: (const void*)buffer
length: (size_t)length
{
[self doesNotRecognizeSelector: _cmd];
abort();
}
- copy
{
return [self retain];
}
|
︙ | | | ︙ | |
1479
1480
1481
1482
1483
1484
1485
1486
1487
1488
1489
1490
1491
1492
1493
1494
1495
1496
1497
1498
1499
1500
1501
1502
1503
1504
1505
1506
1507
1508
1509
1510
1511
1512
1513
1514
1515
1516
1517
1518
|
if (fcntl([self fileDescriptorForReading], F_SETFL, readFlags) == -1 ||
fcntl([self fileDescriptorForWriting], F_SETFL, writeFlags) == -1)
@throw [OFSetOptionFailedException
exceptionWithClass: [self class]
stream: self];
#else
@throw [OFNotImplementedException exceptionWithClass: [self class]
selector: _cmd];
#endif
}
- (int)fileDescriptorForReading
{
@throw [OFNotImplementedException exceptionWithClass: [self class]
selector: _cmd];
}
- (int)fileDescriptorForWriting
{
@throw [OFNotImplementedException exceptionWithClass: [self class]
selector: _cmd];
}
- (void)cancelAsyncRequests
{
[OFRunLoop OF_cancelAsyncRequestsForStream: self];
}
- (void)close
{
@throw [OFNotImplementedException exceptionWithClass: [self class]
selector: _cmd];
}
- (BOOL)OF_isWaitingForDelimiter
{
return waitingForDelimiter;
}
@end
|
<
|
>
<
|
>
<
|
>
<
|
>
|
1481
1482
1483
1484
1485
1486
1487
1488
1489
1490
1491
1492
1493
1494
1495
1496
1497
1498
1499
1500
1501
1502
1503
1504
1505
1506
1507
1508
1509
1510
1511
1512
1513
1514
1515
1516
1517
1518
1519
1520
|
if (fcntl([self fileDescriptorForReading], F_SETFL, readFlags) == -1 ||
fcntl([self fileDescriptorForWriting], F_SETFL, writeFlags) == -1)
@throw [OFSetOptionFailedException
exceptionWithClass: [self class]
stream: self];
#else
[self doesNotRecognizeSelector: _cmd];
abort();
#endif
}
- (int)fileDescriptorForReading
{
[self doesNotRecognizeSelector: _cmd];
abort();
}
- (int)fileDescriptorForWriting
{
[self doesNotRecognizeSelector: _cmd];
abort();
}
- (void)cancelAsyncRequests
{
[OFRunLoop OF_cancelAsyncRequestsForStream: self];
}
- (void)close
{
[self doesNotRecognizeSelector: _cmd];
abort();
}
- (BOOL)OF_isWaitingForDelimiter
{
return waitingForDelimiter;
}
@end
|
Modified src/OFStreamObserver.m
from [df859b9099]
to [77de7642b5].
︙ | | | ︙ | |
14
15
16
17
18
19
20
21
22
23
24
25
26
27
|
* file.
*/
#include "config.h"
#define __NO_EXT_QNX
#include <unistd.h>
#include <assert.h>
#import "OFStreamObserver.h"
#import "OFArray.h"
#import "OFDictionary.h"
|
>
>
|
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
|
* file.
*/
#include "config.h"
#define __NO_EXT_QNX
#include <stdlib.h>
#include <unistd.h>
#include <assert.h>
#import "OFStreamObserver.h"
#import "OFArray.h"
#import "OFDictionary.h"
|
︙ | | | ︙ | |
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
|
# import "OFStreamObserver_poll.h"
#endif
#if defined(HAVE_SYS_SELECT_H) || defined(_WIN32)
# import "OFStreamObserver_select.h"
#endif
#import "OFInitializationFailedException.h"
#import "OFNotImplementedException.h"
#import "OFOutOfRangeException.h"
#import "autorelease.h"
#import "macros.h"
enum {
QUEUE_ADD = 0,
|
<
|
43
44
45
46
47
48
49
50
51
52
53
54
55
56
|
# import "OFStreamObserver_poll.h"
#endif
#if defined(HAVE_SYS_SELECT_H) || defined(_WIN32)
# import "OFStreamObserver_select.h"
#endif
#import "OFInitializationFailedException.h"
#import "OFOutOfRangeException.h"
#import "autorelease.h"
#import "macros.h"
enum {
QUEUE_ADD = 0,
|
︙ | | | ︙ | |
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
|
OF_ENSURE(sendto(cancelFD[1], "", 1, 0, (struct sockaddr*)&cancelAddr,
sizeof(cancelAddr)) > 0);
#endif
}
- (void)OF_addFileDescriptorForReading: (int)fd
{
@throw [OFNotImplementedException exceptionWithClass: [self class]
selector: _cmd];
}
- (void)OF_addFileDescriptorForWriting: (int)fd
{
@throw [OFNotImplementedException exceptionWithClass: [self class]
selector: _cmd];
}
- (void)OF_removeFileDescriptorForReading: (int)fd
{
@throw [OFNotImplementedException exceptionWithClass: [self class]
selector: _cmd];
}
- (void)OF_removeFileDescriptorForWriting: (int)fd
{
@throw [OFNotImplementedException exceptionWithClass: [self class]
selector: _cmd];
}
- (void)OF_processQueue
{
[mutex lock];
@try {
OFStream **queueObjects = [queue objects];
|
<
|
>
<
|
>
<
|
>
<
|
>
|
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
295
|
OF_ENSURE(sendto(cancelFD[1], "", 1, 0, (struct sockaddr*)&cancelAddr,
sizeof(cancelAddr)) > 0);
#endif
}
- (void)OF_addFileDescriptorForReading: (int)fd
{
[self doesNotRecognizeSelector: _cmd];
abort();
}
- (void)OF_addFileDescriptorForWriting: (int)fd
{
[self doesNotRecognizeSelector: _cmd];
abort();
}
- (void)OF_removeFileDescriptorForReading: (int)fd
{
[self doesNotRecognizeSelector: _cmd];
abort();
}
- (void)OF_removeFileDescriptorForWriting: (int)fd
{
[self doesNotRecognizeSelector: _cmd];
abort();
}
- (void)OF_processQueue
{
[mutex lock];
@try {
OFStream **queueObjects = [queue objects];
|
︙ | | | ︙ | |
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
|
- (void)observe
{
[self observeWithTimeout: -1];
}
- (BOOL)observeWithTimeout: (double)timeout
{
@throw [OFNotImplementedException exceptionWithClass: [self class]
selector: _cmd];
}
- (void)cancel
{
#ifndef _WIN32
OF_ENSURE(write(cancelFD[1], "", 1) > 0);
#else
|
<
|
>
|
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
|
- (void)observe
{
[self observeWithTimeout: -1];
}
- (BOOL)observeWithTimeout: (double)timeout
{
[self doesNotRecognizeSelector: _cmd];
abort();
}
- (void)cancel
{
#ifndef _WIN32
OF_ENSURE(write(cancelFD[1], "", 1) > 0);
#else
|
︙ | | | ︙ | |
Modified src/OFString.m
from [9b74d0387e]
to [5f30990c6d].
︙ | | | ︙ | |
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
|
- (void)release
{
}
- (void)dealloc
{
@throw [OFNotImplementedException exceptionWithClass: [self class]
selector: _cmd];
[super dealloc]; /* Get rid of a stupid warning */
}
@end
@implementation OFString
+ (void)initialize
{
if (self == [OFString class])
|
|
>
|
|
>
|
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
|
- (void)release
{
}
- (void)dealloc
{
[self doesNotRecognizeSelector: _cmd];
abort();
/* Get rid of a stupid warning */
[super dealloc];
}
@end
@implementation OFString
+ (void)initialize
{
if (self == [OFString class])
|
︙ | | | ︙ | |
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
|
return [[[self alloc] initWithContentsOfURL: URL
encoding: encoding] autorelease];
}
- init
{
if (object_getClass(self) == [OFString class]) {
Class c = [self class];
[self release];
@throw [OFNotImplementedException exceptionWithClass: c
selector: _cmd];
}
return [super init];
}
- initWithUTF8String: (const char*)UTF8String
{
|
>
|
>
>
|
|
<
>
|
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
|
return [[[self alloc] initWithContentsOfURL: URL
encoding: encoding] autorelease];
}
- init
{
if (object_getClass(self) == [OFString class]) {
@try {
[self doesNotRecognizeSelector: _cmd];
abort();
} @catch (id e) {
[self release];
@throw e;
}
}
return [super init];
}
- initWithUTF8String: (const char*)UTF8String
{
|
︙ | | | ︙ | |
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
|
length: strlen(cString)];
}
- initWithCString: (const char*)cString
encoding: (of_string_encoding_t)encoding
length: (size_t)cStringLength
{
Class c = [self class];
[self release];
@throw [OFNotImplementedException exceptionWithClass: c
selector: _cmd];
}
- initWithString: (OFString*)string
{
Class c = [self class];
[self release];
@throw [OFNotImplementedException exceptionWithClass: c
selector: _cmd];
}
- initWithUnicodeString: (const of_unichar_t*)string
{
return [self initWithUnicodeString: string
byteOrder: OF_BYTE_ORDER_NATIVE
length: of_unicode_string_length(string)];
|
>
|
>
>
|
|
<
>
>
|
>
>
|
|
<
>
|
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
|
length: strlen(cString)];
}
- initWithCString: (const char*)cString
encoding: (of_string_encoding_t)encoding
length: (size_t)cStringLength
{
@try {
[self doesNotRecognizeSelector: _cmd];
abort();
} @catch (id e) {
[self release];
@throw e;
}
}
- initWithString: (OFString*)string
{
@try {
[self doesNotRecognizeSelector: _cmd];
abort();
} @catch (id e) {
[self release];
@throw e;
}
}
- initWithUnicodeString: (const of_unichar_t*)string
{
return [self initWithUnicodeString: string
byteOrder: OF_BYTE_ORDER_NATIVE
length: of_unicode_string_length(string)];
|
︙ | | | ︙ | |
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
|
length: length];
}
- initWithUnicodeString: (const of_unichar_t*)string
byteOrder: (of_byte_order_t)byteOrder
length: (size_t)length
{
Class c = [self class];
[self release];
@throw [OFNotImplementedException exceptionWithClass: c
selector: _cmd];
}
- initWithUTF16String: (const uint16_t*)string
{
return [self initWithUTF16String: string
byteOrder: OF_BYTE_ORDER_BIG_ENDIAN
length: of_utf16_string_length(string)];
|
>
|
>
>
|
|
<
>
|
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
|
length: length];
}
- initWithUnicodeString: (const of_unichar_t*)string
byteOrder: (of_byte_order_t)byteOrder
length: (size_t)length
{
@try {
[self doesNotRecognizeSelector: _cmd];
abort();
} @catch (id e) {
[self release];
@throw e;
}
}
- initWithUTF16String: (const uint16_t*)string
{
return [self initWithUTF16String: string
byteOrder: OF_BYTE_ORDER_BIG_ENDIAN
length: of_utf16_string_length(string)];
|
︙ | | | ︙ | |
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
|
length: length];
}
- initWithUTF16String: (const uint16_t*)string
byteOrder: (of_byte_order_t)byteOrder
length: (size_t)length
{
Class c = [self class];
[self release];
@throw [OFNotImplementedException exceptionWithClass: c
selector: _cmd];
}
- initWithFormat: (OFConstantString*)format, ...
{
id ret;
va_list arguments;
va_start(arguments, format);
ret = [self initWithFormat: format
arguments: arguments];
va_end(arguments);
return ret;
}
- initWithFormat: (OFConstantString*)format
arguments: (va_list)arguments
{
Class c = [self class];
[self release];
@throw [OFNotImplementedException exceptionWithClass: c
selector: _cmd];
}
- initWithPath: (OFString*)firstComponent, ...
{
id ret;
va_list arguments;
va_start(arguments, firstComponent);
ret = [self initWithPath: firstComponent
arguments: arguments];
va_end(arguments);
return ret;
}
- initWithPath: (OFString*)firstComponent
arguments: (va_list)arguments
{
Class c = [self class];
[self release];
@throw [OFNotImplementedException exceptionWithClass: c
selector: _cmd];
}
- initWithContentsOfFile: (OFString*)path
{
return [self initWithContentsOfFile: path
encoding: OF_STRING_ENCODING_UTF_8];
}
|
>
|
>
>
|
|
<
>
>
|
>
>
|
|
<
>
>
|
>
>
|
|
<
>
|
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
|
length: length];
}
- initWithUTF16String: (const uint16_t*)string
byteOrder: (of_byte_order_t)byteOrder
length: (size_t)length
{
@try {
[self doesNotRecognizeSelector: _cmd];
abort();
} @catch (id e) {
[self release];
@throw e;
}
}
- initWithFormat: (OFConstantString*)format, ...
{
id ret;
va_list arguments;
va_start(arguments, format);
ret = [self initWithFormat: format
arguments: arguments];
va_end(arguments);
return ret;
}
- initWithFormat: (OFConstantString*)format
arguments: (va_list)arguments
{
@try {
[self doesNotRecognizeSelector: _cmd];
abort();
} @catch (id e) {
[self release];
@throw e;
}
}
- initWithPath: (OFString*)firstComponent, ...
{
id ret;
va_list arguments;
va_start(arguments, firstComponent);
ret = [self initWithPath: firstComponent
arguments: arguments];
va_end(arguments);
return ret;
}
- initWithPath: (OFString*)firstComponent
arguments: (va_list)arguments
{
@try {
[self doesNotRecognizeSelector: _cmd];
abort();
} @catch (id e) {
[self release];
@throw e;
}
}
- initWithContentsOfFile: (OFString*)path
{
return [self initWithContentsOfFile: path
encoding: OF_STRING_ENCODING_UTF_8];
}
|
︙ | | | ︙ | |
924
925
926
927
928
929
930
931
932
933
934
935
936
937
938
939
|
- (const char*)UTF8String
{
return [self cStringUsingEncoding: OF_STRING_ENCODING_UTF_8];
}
- (size_t)length
{
@throw [OFNotImplementedException exceptionWithClass: [self class]
selector: _cmd];
}
- (size_t)lengthOfBytesUsingEncoding: (of_string_encoding_t)encoding
{
switch (encoding) {
case OF_STRING_ENCODING_UTF_8:;
const of_unichar_t *unicodeString;
|
<
|
>
|
947
948
949
950
951
952
953
954
955
956
957
958
959
960
961
962
|
- (const char*)UTF8String
{
return [self cStringUsingEncoding: OF_STRING_ENCODING_UTF_8];
}
- (size_t)length
{
[self doesNotRecognizeSelector: _cmd];
abort();
}
- (size_t)lengthOfBytesUsingEncoding: (of_string_encoding_t)encoding
{
switch (encoding) {
case OF_STRING_ENCODING_UTF_8:;
const of_unichar_t *unicodeString;
|
︙ | | | ︙ | |
968
969
970
971
972
973
974
975
976
977
978
979
980
981
982
983
|
- (size_t)UTF8StringLength
{
return [self lengthOfBytesUsingEncoding: OF_STRING_ENCODING_UTF_8];
}
- (of_unichar_t)characterAtIndex: (size_t)index
{
@throw [OFNotImplementedException exceptionWithClass: [self class]
selector: _cmd];
}
- (void)getCharacters: (of_unichar_t*)buffer
inRange: (of_range_t)range
{
size_t i;
|
<
|
>
|
991
992
993
994
995
996
997
998
999
1000
1001
1002
1003
1004
1005
1006
|
- (size_t)UTF8StringLength
{
return [self lengthOfBytesUsingEncoding: OF_STRING_ENCODING_UTF_8];
}
- (of_unichar_t)characterAtIndex: (size_t)index
{
[self doesNotRecognizeSelector: _cmd];
abort();
}
- (void)getCharacters: (of_unichar_t*)buffer
inRange: (of_range_t)range
{
size_t i;
|
︙ | | | ︙ | |
Modified src/OFString_UTF8.m
from [75ce5faed6]
to [dfd9d65700].
︙ | | | ︙ | |
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
|
#import "OFMutableString_UTF8.h"
#import "OFArray.h"
#import "OFInitializationFailedException.h"
#import "OFInvalidArgumentException.h"
#import "OFInvalidEncodingException.h"
#import "OFInvalidFormatException.h"
#import "OFNotImplementedException.h"
#import "OFOutOfMemoryException.h"
#import "OFOutOfRangeException.h"
#import "autorelease.h"
#import "macros.h"
#import "of_asprintf.h"
#import "unicode.h"
|
<
|
27
28
29
30
31
32
33
34
35
36
37
38
39
40
|
#import "OFMutableString_UTF8.h"
#import "OFArray.h"
#import "OFInitializationFailedException.h"
#import "OFInvalidArgumentException.h"
#import "OFInvalidEncodingException.h"
#import "OFInvalidFormatException.h"
#import "OFOutOfMemoryException.h"
#import "OFOutOfRangeException.h"
#import "autorelease.h"
#import "macros.h"
#import "of_asprintf.h"
#import "unicode.h"
|
︙ | | | ︙ | |
Modified src/OFThread.m
from [bdce062fba]
to [ba81cccfd2].
︙ | | | ︙ | |
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
|
#ifdef _WIN32
# include <windows.h>
#endif
#import "OFInitializationFailedException.h"
#import "OFInvalidArgumentException.h"
#import "OFNotImplementedException.h"
#import "OFOutOfRangeException.h"
#import "OFThreadJoinFailedException.h"
#import "OFThreadStartFailedException.h"
#import "OFThreadStillRunningException.h"
#import "atomic.h"
#import "autorelease.h"
|
<
|
40
41
42
43
44
45
46
47
48
49
50
51
52
53
|
#ifdef _WIN32
# include <windows.h>
#endif
#import "OFInitializationFailedException.h"
#import "OFInvalidArgumentException.h"
#import "OFOutOfRangeException.h"
#import "OFThreadJoinFailedException.h"
#import "OFThreadStartFailedException.h"
#import "OFThreadStillRunningException.h"
#import "atomic.h"
#import "autorelease.h"
|
︙ | | | ︙ | |
Modified src/OFTimer.m
from [0447782afb]
to [7245211e76].
︙ | | | ︙ | |
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
|
* Public License, either version 2 or 3, which can be found in the file
* LICENSE.GPLv2 or LICENSE.GPLv3 respectively included in the packaging of this
* file.
*/
#include "config.h"
#include <assert.h>
#import "OFTimer.h"
#import "OFDate.h"
#import "OFRunLoop.h"
#import "OFCondition.h"
#import "OFInvalidArgumentException.h"
#import "OFNotImplementedException.h"
#import "autorelease.h"
#import "macros.h"
@implementation OFTimer
+ (instancetype)scheduledTimerWithTimeInterval: (double)interval
target: (id)target
|
>
>
<
|
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
|
* Public License, either version 2 or 3, which can be found in the file
* LICENSE.GPLv2 or LICENSE.GPLv3 respectively included in the packaging of this
* file.
*/
#include "config.h"
#include <stdlib.h>
#include <assert.h>
#import "OFTimer.h"
#import "OFDate.h"
#import "OFRunLoop.h"
#import "OFCondition.h"
#import "OFInvalidArgumentException.h"
#import "autorelease.h"
#import "macros.h"
@implementation OFTimer
+ (instancetype)scheduledTimerWithTimeInterval: (double)interval
target: (id)target
|
︙ | | | ︙ | |
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
|
return [timer autorelease];
}
#endif
- init
{
Class c = [self class];
[self release];
@throw [OFNotImplementedException exceptionWithClass: c
selector: _cmd];
}
- OF_initWithFireDate: (OFDate*)fireDate_
interval: (double)interval_
target: (id)target_
selector: (SEL)selector_
object: (id)object1_
|
>
|
>
>
|
|
<
>
|
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
|
return [timer autorelease];
}
#endif
- init
{
@try {
[self doesNotRecognizeSelector: _cmd];
abort();
} @catch (id e) {
[self release];
@throw e;
}
}
- OF_initWithFireDate: (OFDate*)fireDate_
interval: (double)interval_
target: (id)target_
selector: (SEL)selector_
object: (id)object1_
|
︙ | | | ︙ | |
Modified src/OFXMLElement+Serialization.m
from [9ca8fe4ac9]
to [0a3d66ab61].
︙ | | | ︙ | |
18
19
20
21
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
|
#import "OFXMLElement.h"
#import "OFXMLElement+Serialization.h"
#import "OFSerialization.h"
#import "OFString.h"
#import "OFInvalidArgumentException.h"
#import "OFNotImplementedException.h"
#import "autorelease.h"
#import "macros.h"
int _OFXMLElement_Serialization_reference;
@implementation OFXMLElement (Serialization)
- (id)objectByDeserializing
{
void *pool = objc_autoreleasePoolPush();
Class class;
id object;
if ((class = objc_getClass([name cStringUsingEncoding:
OF_STRING_ENCODING_ASCII])) == Nil)
@throw [OFNotImplementedException exceptionWithClass: Nil];
if (![class conformsToProtocol: @protocol(OFSerialization)])
@throw [OFNotImplementedException
exceptionWithClass: class
selector: @selector(initWithSerialization:)];
object = [[class alloc] initWithSerialization: self];
objc_autoreleasePoolPop(pool);
return [object autorelease];
}
@end
|
<
>
|
|
|
<
|
18
19
20
21
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
|
#import "OFXMLElement.h"
#import "OFXMLElement+Serialization.h"
#import "OFSerialization.h"
#import "OFString.h"
#import "OFInvalidArgumentException.h"
#import "autorelease.h"
#import "macros.h"
int _OFXMLElement_Serialization_reference;
@implementation OFXMLElement (Serialization)
- (id)objectByDeserializing
{
void *pool = objc_autoreleasePoolPush();
Class class;
id object;
if ((class = objc_getClass([name cStringUsingEncoding:
OF_STRING_ENCODING_ASCII])) == Nil)
@throw [OFInvalidArgumentException
exceptionWithClass: [self class]];
if (![class conformsToProtocol: @protocol(OFSerialization)])
@throw [OFInvalidArgumentException
exceptionWithClass: [self class]];
object = [[class alloc] initWithSerialization: self];
objc_autoreleasePoolPop(pool);
return [object autorelease];
}
@end
|
Modified src/OFXMLElement.m
from [16ca049b3f]
to [5487d3f056].
︙ | | | ︙ | |
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
|
* Public License, either version 2 or 3, which can be found in the file
* LICENSE.GPLv2 or LICENSE.GPLv3 respectively included in the packaging of this
* file.
*/
#include "config.h"
#include <string.h>
#include <assert.h>
#import "OFXMLElement.h"
#import "OFString.h"
#import "OFArray.h"
#import "OFDictionary.h"
#import "OFDataArray.h"
#import "OFXMLAttribute.h"
#import "OFXMLCharacters.h"
#import "OFXMLCDATA.h"
#import "OFXMLParser.h"
#import "OFXMLElementBuilder.h"
#import "OFInvalidArgumentException.h"
#import "OFInvalidFormatException.h"
#import "OFMalformedXMLException.h"
#import "OFNotImplementedException.h"
#import "OFUnboundNamespaceException.h"
#import "autorelease.h"
#import "macros.h"
/* References for static linking */
void _references_to_categories_of_OFXMLElement(void)
|
>
>
<
|
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
|
* Public License, either version 2 or 3, which can be found in the file
* LICENSE.GPLv2 or LICENSE.GPLv3 respectively included in the packaging of this
* file.
*/
#include "config.h"
#include <stdlib.h>
#include <string.h>
#include <assert.h>
#import "OFXMLElement.h"
#import "OFString.h"
#import "OFArray.h"
#import "OFDictionary.h"
#import "OFDataArray.h"
#import "OFXMLAttribute.h"
#import "OFXMLCharacters.h"
#import "OFXMLCDATA.h"
#import "OFXMLParser.h"
#import "OFXMLElementBuilder.h"
#import "OFInvalidArgumentException.h"
#import "OFInvalidFormatException.h"
#import "OFMalformedXMLException.h"
#import "OFUnboundNamespaceException.h"
#import "autorelease.h"
#import "macros.h"
/* References for static linking */
void _references_to_categories_of_OFXMLElement(void)
|
︙ | | | ︙ | |
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
|
+ (instancetype)elementWithFile: (OFString*)path
{
return [[[self alloc] initWithFile: path] autorelease];
}
- init
{
Class c = [self class];
[self release];
@throw [OFNotImplementedException exceptionWithClass: c
selector: _cmd];
}
- initWithName: (OFString*)name_
{
return [self initWithName: name_
namespace: nil
stringValue: nil];
|
>
|
>
>
|
|
<
>
|
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
|
+ (instancetype)elementWithFile: (OFString*)path
{
return [[[self alloc] initWithFile: path] autorelease];
}
- init
{
@try {
[self doesNotRecognizeSelector: _cmd];
abort();
} @catch (id e) {
[self release];
@throw e;
}
}
- initWithName: (OFString*)name_
{
return [self initWithName: name_
namespace: nil
stringValue: nil];
|
︙ | | | ︙ | |
Modified src/OFXMLNode.m
from [cb63feb9eb]
to [6055c48f8a].
︙ | | | ︙ | |
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
|
* Alternatively, it may be distributed under the terms of the GNU General
* Public License, either version 2 or 3, which can be found in the file
* LICENSE.GPLv2 or LICENSE.GPLv3 respectively included in the packaging of this
* file.
*/
#include "config.h"
#import "OFXMLNode.h"
#import "OFString.h"
#import "OFNotImplementedException.h"
@implementation OFXMLNode
- initWithSerialization: (OFXMLElement*)element
{
Class c = [self class];
[self release];
@throw [OFNotImplementedException exceptionWithClass: c
selector: _cmd];
}
- (OFString*)stringValue
{
@throw [OFNotImplementedException exceptionWithClass: [self class]
selector: _cmd];
}
- (intmax_t)decimalValue
{
return [[self stringValue] decimalValue];
}
|
>
>
<
<
>
|
>
>
|
|
<
>
<
|
>
|
11
12
13
14
15
16
17
18
19
20
21
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
|
* Alternatively, it may be distributed under the terms of the GNU General
* Public License, either version 2 or 3, which can be found in the file
* LICENSE.GPLv2 or LICENSE.GPLv3 respectively included in the packaging of this
* file.
*/
#include "config.h"
#include <stdlib.h>
#import "OFXMLNode.h"
#import "OFString.h"
@implementation OFXMLNode
- initWithSerialization: (OFXMLElement*)element
{
@try {
[self doesNotRecognizeSelector: _cmd];
abort();
} @catch (id e) {
[self release];
@throw e;
}
}
- (OFString*)stringValue
{
[self doesNotRecognizeSelector: _cmd];
abort();
}
- (intmax_t)decimalValue
{
return [[self stringValue] decimalValue];
}
|
︙ | | | ︙ | |
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
|
return [self XMLStringWithIndentation: 0
level: 0];
}
- (OFString*)XMLStringWithIndentation: (unsigned int)indentation
level: (unsigned int)level
{
@throw [OFNotImplementedException exceptionWithClass: [self class]
selector: _cmd];
}
- (OFString*)description
{
return [self XMLStringWithIndentation: 2];
}
- (OFXMLElement*)XMLElementBySerializing
{
@throw [OFNotImplementedException exceptionWithClass: [self class]
selector: _cmd];
}
- copy
{
return [self retain];
}
@end
|
<
|
>
<
|
>
|
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
|
return [self XMLStringWithIndentation: 0
level: 0];
}
- (OFString*)XMLStringWithIndentation: (unsigned int)indentation
level: (unsigned int)level
{
[self doesNotRecognizeSelector: _cmd];
abort();
}
- (OFString*)description
{
return [self XMLStringWithIndentation: 2];
}
- (OFXMLElement*)XMLElementBySerializing
{
[self doesNotRecognizeSelector: _cmd];
abort();
}
- copy
{
return [self retain];
}
@end
|
Modified src/exceptions/OFAcceptFailedException.m
from [c457c058f0]
to [6c1a76fdbf].
︙ | | | ︙ | |
11
12
13
14
15
16
17
18
19
20
21
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
|
* Alternatively, it may be distributed under the terms of the GNU General
* Public License, either version 2 or 3, which can be found in the file
* LICENSE.GPLv2 or LICENSE.GPLv3 respectively included in the packaging of this
* file.
*/
#include "config.h"
#import "OFAcceptFailedException.h"
#import "OFString.h"
#import "OFTCPSocket.h"
#import "OFNotImplementedException.h"
#import "common.h"
@implementation OFAcceptFailedException
+ (instancetype)exceptionWithClass: (Class)class_
socket: (OFTCPSocket*)socket
{
return [[[self alloc] initWithClass: class_
socket: socket] autorelease];
}
- initWithClass: (Class)class_
{
Class c = [self class];
[self release];
@throw [OFNotImplementedException exceptionWithClass: c
selector: _cmd];
}
- initWithClass: (Class)class_
socket: (OFTCPSocket*)socket_
{
self = [super initWithClass: class_];
|
>
>
<
<
>
|
>
>
|
|
<
>
|
11
12
13
14
15
16
17
18
19
20
21
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
|
* Alternatively, it may be distributed under the terms of the GNU General
* Public License, either version 2 or 3, which can be found in the file
* LICENSE.GPLv2 or LICENSE.GPLv3 respectively included in the packaging of this
* file.
*/
#include "config.h"
#include <stdlib.h>
#import "OFAcceptFailedException.h"
#import "OFString.h"
#import "OFTCPSocket.h"
#import "common.h"
@implementation OFAcceptFailedException
+ (instancetype)exceptionWithClass: (Class)class_
socket: (OFTCPSocket*)socket
{
return [[[self alloc] initWithClass: class_
socket: socket] autorelease];
}
- initWithClass: (Class)class_
{
@try {
[self doesNotRecognizeSelector: _cmd];
abort();
} @catch (id e) {
[self release];
@throw e;
}
}
- initWithClass: (Class)class_
socket: (OFTCPSocket*)socket_
{
self = [super initWithClass: class_];
|
︙ | | | ︙ | |
Modified src/exceptions/OFAllocFailedException.m
from [f91f71fe9f]
to [353b58a3aa].
︙ | | | ︙ | |
11
12
13
14
15
16
17
18
19
20
21
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
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
|
* Alternatively, it may be distributed under the terms of the GNU General
* Public License, either version 2 or 3, which can be found in the file
* LICENSE.GPLv2 or LICENSE.GPLv3 respectively included in the packaging of this
* file.
*/
#include "config.h"
#import "OFAllocFailedException.h"
#import "OFString.h"
#import "OFNotImplementedException.h"
@implementation OFAllocFailedException
+ alloc
{
@throw [OFNotImplementedException exceptionWithClass: self
selector: _cmd];
}
- init
{
@throw [OFNotImplementedException exceptionWithClass: [self class]
selector: _cmd];
}
- (void*)allocMemoryWithSize: (size_t)size
{
@throw [OFNotImplementedException exceptionWithClass: [self class]
selector: _cmd];
}
- (void*)allocMemoryForNItems: (size_t)nitems
withSize: (size_t)size
{
@throw [OFNotImplementedException exceptionWithClass: [self class]
selector: _cmd];
}
- (void*)resizeMemory: (void*)ptr
toSize: (size_t)size
{
@throw [OFNotImplementedException exceptionWithClass: [self class]
selector: _cmd];
}
- (void*)resizeMemory: (void*)ptr
toNItems: (size_t)nitems
withSize: (size_t)size
{
@throw [OFNotImplementedException exceptionWithClass: [self class]
selector: _cmd];
}
- (void)freeMemory: (void*)ptr
{
@throw [OFNotImplementedException exceptionWithClass: [self class]
selector: _cmd];
}
- retain
{
return self;
}
|
>
>
<
<
<
|
>
|
|
>
>
>
>
>
<
|
>
<
|
>
<
|
>
<
|
>
<
|
>
|
11
12
13
14
15
16
17
18
19
20
21
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
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
|
* Alternatively, it may be distributed under the terms of the GNU General
* Public License, either version 2 or 3, which can be found in the file
* LICENSE.GPLv2 or LICENSE.GPLv3 respectively included in the packaging of this
* file.
*/
#include "config.h"
#include <stdlib.h>
#import "OFAllocFailedException.h"
#import "OFString.h"
@implementation OFAllocFailedException
+ alloc
{
[self doesNotRecognizeSelector: _cmd];
abort();
}
- init
{
@try {
[self doesNotRecognizeSelector: _cmd];
abort();
} @catch (id e) {
[self release];
@throw e;
}
}
- (void*)allocMemoryWithSize: (size_t)size
{
[self doesNotRecognizeSelector: _cmd];
abort();
}
- (void*)allocMemoryForNItems: (size_t)nitems
withSize: (size_t)size
{
[self doesNotRecognizeSelector: _cmd];
abort();
}
- (void*)resizeMemory: (void*)ptr
toSize: (size_t)size
{
[self doesNotRecognizeSelector: _cmd];
abort();
}
- (void*)resizeMemory: (void*)ptr
toNItems: (size_t)nitems
withSize: (size_t)size
{
[self doesNotRecognizeSelector: _cmd];
abort();
}
- (void)freeMemory: (void*)ptr
{
[self doesNotRecognizeSelector: _cmd];
abort();
}
- retain
{
return self;
}
|
︙ | | | ︙ | |
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
|
- (void)release
{
}
- (void)dealloc
{
@throw [OFNotImplementedException exceptionWithClass: [self class]
selector: _cmd];
[super dealloc]; /* Get rid of a stupid warning */
}
- (OFString*)description
{
return @"Allocating an object failed!";
}
@end
|
|
>
|
|
>
|
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
|
- (void)release
{
}
- (void)dealloc
{
[self doesNotRecognizeSelector: _cmd];
abort();
/* Get rid of a stupid warning */
[super dealloc];
}
- (OFString*)description
{
return @"Allocating an object failed!";
}
@end
|
Modified src/exceptions/OFAlreadyConnectedException.m
from [5e1a345877]
to [ab4527fab8].
︙ | | | ︙ | |
11
12
13
14
15
16
17
18
19
20
21
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
|
* Alternatively, it may be distributed under the terms of the GNU General
* Public License, either version 2 or 3, which can be found in the file
* LICENSE.GPLv2 or LICENSE.GPLv3 respectively included in the packaging of this
* file.
*/
#include "config.h"
#import "OFAlreadyConnectedException.h"
#import "OFString.h"
#import "OFTCPSocket.h"
#import "OFNotImplementedException.h"
#import "common.h"
@implementation OFAlreadyConnectedException
+ (instancetype)exceptionWithClass: (Class)class_
socket: (OFTCPSocket*)socket
{
return [[[self alloc] initWithClass: class_
socket: socket] autorelease];
}
- initWithClass: (Class)class_
{
Class c = [self class];
[self release];
@throw [OFNotImplementedException exceptionWithClass: c
selector: _cmd];
}
- initWithClass: (Class)class_
socket: (OFTCPSocket*)socket_
{
self = [super initWithClass: class_];
|
>
>
<
<
>
|
>
>
|
|
<
>
|
11
12
13
14
15
16
17
18
19
20
21
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
|
* Alternatively, it may be distributed under the terms of the GNU General
* Public License, either version 2 or 3, which can be found in the file
* LICENSE.GPLv2 or LICENSE.GPLv3 respectively included in the packaging of this
* file.
*/
#include "config.h"
#include <stdlib.h>
#import "OFAlreadyConnectedException.h"
#import "OFString.h"
#import "OFTCPSocket.h"
#import "common.h"
@implementation OFAlreadyConnectedException
+ (instancetype)exceptionWithClass: (Class)class_
socket: (OFTCPSocket*)socket
{
return [[[self alloc] initWithClass: class_
socket: socket] autorelease];
}
- initWithClass: (Class)class_
{
@try {
[self doesNotRecognizeSelector: _cmd];
abort();
} @catch (id e) {
[self release];
@throw e;
}
}
- initWithClass: (Class)class_
socket: (OFTCPSocket*)socket_
{
self = [super initWithClass: class_];
|
︙ | | | ︙ | |
Modified src/exceptions/OFBindFailedException.m
from [e975d14a09]
to [dc36806f5b].
︙ | | | ︙ | |
11
12
13
14
15
16
17
18
19
20
21
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
|
* Alternatively, it may be distributed under the terms of the GNU General
* Public License, either version 2 or 3, which can be found in the file
* LICENSE.GPLv2 or LICENSE.GPLv3 respectively included in the packaging of this
* file.
*/
#include "config.h"
#import "OFBindFailedException.h"
#import "OFString.h"
#import "OFTCPSocket.h"
#import "OFNotImplementedException.h"
#import "common.h"
@implementation OFBindFailedException
+ (instancetype)exceptionWithClass: (Class)class_
socket: (OFTCPSocket*)socket
host: (OFString*)host
port: (uint16_t)port
{
return [[[self alloc] initWithClass: class_
socket: socket
host: host
port: port] autorelease];
}
- initWithClass: (Class)class_
{
Class c = [self class];
[self release];
@throw [OFNotImplementedException exceptionWithClass: c
selector: _cmd];
}
- initWithClass: (Class)class_
socket: (OFTCPSocket*)socket_
host: (OFString*)host_
port: (uint16_t)port_
{
|
>
>
<
<
>
|
>
>
|
|
<
>
|
11
12
13
14
15
16
17
18
19
20
21
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
|
* Alternatively, it may be distributed under the terms of the GNU General
* Public License, either version 2 or 3, which can be found in the file
* LICENSE.GPLv2 or LICENSE.GPLv3 respectively included in the packaging of this
* file.
*/
#include "config.h"
#include <stdlib.h>
#import "OFBindFailedException.h"
#import "OFString.h"
#import "OFTCPSocket.h"
#import "common.h"
@implementation OFBindFailedException
+ (instancetype)exceptionWithClass: (Class)class_
socket: (OFTCPSocket*)socket
host: (OFString*)host
port: (uint16_t)port
{
return [[[self alloc] initWithClass: class_
socket: socket
host: host
port: port] autorelease];
}
- initWithClass: (Class)class_
{
@try {
[self doesNotRecognizeSelector: _cmd];
abort();
} @catch (id e) {
[self release];
@throw e;
}
}
- initWithClass: (Class)class_
socket: (OFTCPSocket*)socket_
host: (OFString*)host_
port: (uint16_t)port_
{
|
︙ | | | ︙ | |
Modified src/exceptions/OFChangeDirectoryFailedException.m
from [061077ad6c]
to [7743d847c5].
︙ | | | ︙ | |
11
12
13
14
15
16
17
18
19
20
21
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
|
* Alternatively, it may be distributed under the terms of the GNU General
* Public License, either version 2 or 3, which can be found in the file
* LICENSE.GPLv2 or LICENSE.GPLv3 respectively included in the packaging of this
* file.
*/
#include "config.h"
#import "OFChangeDirectoryFailedException.h"
#import "OFString.h"
#import "OFNotImplementedException.h"
#import "common.h"
@implementation OFChangeDirectoryFailedException
+ (instancetype)exceptionWithClass: (Class)class_
path: (OFString*)path_
{
return [[[self alloc] initWithClass: class_
path: path_] autorelease];
}
- initWithClass: (Class)class_
{
Class c = [self class];
[self release];
@throw [OFNotImplementedException exceptionWithClass: c
selector: _cmd];
}
- initWithClass: (Class)class_
path: (OFString*)path_
{
self = [super initWithClass: class_];
|
>
>
<
<
>
|
>
>
|
|
<
>
|
11
12
13
14
15
16
17
18
19
20
21
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
|
* Alternatively, it may be distributed under the terms of the GNU General
* Public License, either version 2 or 3, which can be found in the file
* LICENSE.GPLv2 or LICENSE.GPLv3 respectively included in the packaging of this
* file.
*/
#include "config.h"
#include <stdlib.h>
#import "OFChangeDirectoryFailedException.h"
#import "OFString.h"
#import "common.h"
@implementation OFChangeDirectoryFailedException
+ (instancetype)exceptionWithClass: (Class)class_
path: (OFString*)path_
{
return [[[self alloc] initWithClass: class_
path: path_] autorelease];
}
- initWithClass: (Class)class_
{
@try {
[self doesNotRecognizeSelector: _cmd];
abort();
} @catch (id e) {
[self release];
@throw e;
}
}
- initWithClass: (Class)class_
path: (OFString*)path_
{
self = [super initWithClass: class_];
|
︙ | | | ︙ | |
Modified src/exceptions/OFChangeFileModeFailedException.m
from [84e028f2f5]
to [c910398387].
︙ | | | ︙ | |
11
12
13
14
15
16
17
18
19
20
21
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
|
* Alternatively, it may be distributed under the terms of the GNU General
* Public License, either version 2 or 3, which can be found in the file
* LICENSE.GPLv2 or LICENSE.GPLv3 respectively included in the packaging of this
* file.
*/
#include "config.h"
#import "OFChangeFileModeFailedException.h"
#import "OFString.h"
#import "OFNotImplementedException.h"
#import "common.h"
@implementation OFChangeFileModeFailedException
+ (instancetype)exceptionWithClass: (Class)class_
path: (OFString*)path
mode: (mode_t)mode
{
return [[[self alloc] initWithClass: class_
path: path
mode: mode] autorelease];
}
- initWithClass: (Class)class_
{
Class c = [self class];
[self release];
@throw [OFNotImplementedException exceptionWithClass: c
selector: _cmd];
}
- initWithClass: (Class)class_
path: (OFString*)path_
mode: (mode_t)mode_
{
self = [super initWithClass: class_];
|
>
>
<
<
>
|
>
>
|
|
<
>
|
11
12
13
14
15
16
17
18
19
20
21
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
|
* Alternatively, it may be distributed under the terms of the GNU General
* Public License, either version 2 or 3, which can be found in the file
* LICENSE.GPLv2 or LICENSE.GPLv3 respectively included in the packaging of this
* file.
*/
#include "config.h"
#include <stdlib.h>
#import "OFChangeFileModeFailedException.h"
#import "OFString.h"
#import "common.h"
@implementation OFChangeFileModeFailedException
+ (instancetype)exceptionWithClass: (Class)class_
path: (OFString*)path
mode: (mode_t)mode
{
return [[[self alloc] initWithClass: class_
path: path
mode: mode] autorelease];
}
- initWithClass: (Class)class_
{
@try {
[self doesNotRecognizeSelector: _cmd];
abort();
} @catch (id e) {
[self release];
@throw e;
}
}
- initWithClass: (Class)class_
path: (OFString*)path_
mode: (mode_t)mode_
{
self = [super initWithClass: class_];
|
︙ | | | ︙ | |
Modified src/exceptions/OFChangeFileOwnerFailedException.m
from [e07fdc2eff]
to [5a1ab8f6f5].
︙ | | | ︙ | |
11
12
13
14
15
16
17
18
19
20
21
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
|
* Alternatively, it may be distributed under the terms of the GNU General
* Public License, either version 2 or 3, which can be found in the file
* LICENSE.GPLv2 or LICENSE.GPLv3 respectively included in the packaging of this
* file.
*/
#include "config.h"
#import "OFChangeFileOwnerFailedException.h"
#import "OFString.h"
#import "OFNotImplementedException.h"
#import "common.h"
#ifndef _WIN32
@implementation OFChangeFileOwnerFailedException
+ (instancetype)exceptionWithClass: (Class)class_
path: (OFString*)path
owner: (OFString*)owner
group: (OFString*)group
{
return [[[self alloc] initWithClass: class_
path: path
owner: owner
group: group] autorelease];
}
- initWithClass: (Class)class_
{
Class c = [self class];
[self release];
@throw [OFNotImplementedException exceptionWithClass: c
selector: _cmd];
}
- initWithClass: (Class)class_
path: (OFString*)path_
owner: (OFString*)owner_
group: (OFString*)group_
{
|
>
>
<
<
>
|
>
>
|
|
<
>
|
11
12
13
14
15
16
17
18
19
20
21
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
|
* Alternatively, it may be distributed under the terms of the GNU General
* Public License, either version 2 or 3, which can be found in the file
* LICENSE.GPLv2 or LICENSE.GPLv3 respectively included in the packaging of this
* file.
*/
#include "config.h"
#include <stdlib.h>
#import "OFChangeFileOwnerFailedException.h"
#import "OFString.h"
#import "common.h"
#ifndef _WIN32
@implementation OFChangeFileOwnerFailedException
+ (instancetype)exceptionWithClass: (Class)class_
path: (OFString*)path
owner: (OFString*)owner
group: (OFString*)group
{
return [[[self alloc] initWithClass: class_
path: path
owner: owner
group: group] autorelease];
}
- initWithClass: (Class)class_
{
@try {
[self doesNotRecognizeSelector: _cmd];
abort();
} @catch (id e) {
[self release];
@throw e;
}
}
- initWithClass: (Class)class_
path: (OFString*)path_
owner: (OFString*)owner_
group: (OFString*)group_
{
|
︙ | | | ︙ | |
Modified src/exceptions/OFConditionBroadcastFailedException.m
from [3559216b34]
to [8cedc9960a].
︙ | | | ︙ | |
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
|
* Alternatively, it may be distributed under the terms of the GNU General
* Public License, either version 2 or 3, which can be found in the file
* LICENSE.GPLv2 or LICENSE.GPLv3 respectively included in the packaging of this
* file.
*/
#include "config.h"
#import "OFConditionBroadcastFailedException.h"
#import "OFString.h"
#import "OFCondition.h"
#import "OFNotImplementedException.h"
@implementation OFConditionBroadcastFailedException
+ (instancetype)exceptionWithClass: (Class)class_
condition: (OFCondition*)condition
{
return [[[self alloc] initWithClass: class_
condition: condition] autorelease];
}
- initWithClass: (Class)class_
{
Class c = [self class];
[self release];
@throw [OFNotImplementedException exceptionWithClass: c
selector: _cmd];
}
- initWithClass: (Class)class_
condition: (OFCondition*)condition_
{
self = [super initWithClass: class_];
|
>
>
<
<
>
|
>
>
|
|
<
>
|
11
12
13
14
15
16
17
18
19
20
21
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
|
* Alternatively, it may be distributed under the terms of the GNU General
* Public License, either version 2 or 3, which can be found in the file
* LICENSE.GPLv2 or LICENSE.GPLv3 respectively included in the packaging of this
* file.
*/
#include "config.h"
#include <stdlib.h>
#import "OFConditionBroadcastFailedException.h"
#import "OFString.h"
#import "OFCondition.h"
@implementation OFConditionBroadcastFailedException
+ (instancetype)exceptionWithClass: (Class)class_
condition: (OFCondition*)condition
{
return [[[self alloc] initWithClass: class_
condition: condition] autorelease];
}
- initWithClass: (Class)class_
{
@try {
[self doesNotRecognizeSelector: _cmd];
abort();
} @catch (id e) {
[self release];
@throw e;
}
}
- initWithClass: (Class)class_
condition: (OFCondition*)condition_
{
self = [super initWithClass: class_];
|
︙ | | | ︙ | |
Modified src/exceptions/OFConditionSignalFailedException.m
from [d23e0ba837]
to [496e150dc1].
︙ | | | ︙ | |
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
|
* Alternatively, it may be distributed under the terms of the GNU General
* Public License, either version 2 or 3, which can be found in the file
* LICENSE.GPLv2 or LICENSE.GPLv3 respectively included in the packaging of this
* file.
*/
#include "config.h"
#import "OFConditionSignalFailedException.h"
#import "OFString.h"
#import "OFCondition.h"
#import "OFNotImplementedException.h"
@implementation OFConditionSignalFailedException
+ (instancetype)exceptionWithClass: (Class)class_
condition: (OFCondition*)condition
{
return [[[self alloc] initWithClass: class_
condition: condition] autorelease];
}
- initWithClass: (Class)class_
{
Class c = [self class];
[self release];
@throw [OFNotImplementedException exceptionWithClass: c
selector: _cmd];
}
- initWithClass: (Class)class_
condition: (OFCondition*)condition_
{
self = [super initWithClass: class_];
|
>
>
<
<
>
|
>
>
|
|
<
>
|
11
12
13
14
15
16
17
18
19
20
21
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
|
* Alternatively, it may be distributed under the terms of the GNU General
* Public License, either version 2 or 3, which can be found in the file
* LICENSE.GPLv2 or LICENSE.GPLv3 respectively included in the packaging of this
* file.
*/
#include "config.h"
#include <stdlib.h>
#import "OFConditionSignalFailedException.h"
#import "OFString.h"
#import "OFCondition.h"
@implementation OFConditionSignalFailedException
+ (instancetype)exceptionWithClass: (Class)class_
condition: (OFCondition*)condition
{
return [[[self alloc] initWithClass: class_
condition: condition] autorelease];
}
- initWithClass: (Class)class_
{
@try {
[self doesNotRecognizeSelector: _cmd];
abort();
} @catch (id e) {
[self release];
@throw e;
}
}
- initWithClass: (Class)class_
condition: (OFCondition*)condition_
{
self = [super initWithClass: class_];
|
︙ | | | ︙ | |
Modified src/exceptions/OFConditionStillWaitingException.m
from [bdcb857f81]
to [69975815b7].
︙ | | | ︙ | |
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
|
* Alternatively, it may be distributed under the terms of the GNU General
* Public License, either version 2 or 3, which can be found in the file
* LICENSE.GPLv2 or LICENSE.GPLv3 respectively included in the packaging of this
* file.
*/
#include "config.h"
#import "OFConditionStillWaitingException.h"
#import "OFString.h"
#import "OFCondition.h"
#import "OFNotImplementedException.h"
@implementation OFConditionStillWaitingException
+ (instancetype)exceptionWithClass: (Class)class_
condition: (OFCondition*)condition
{
return [[[self alloc] initWithClass: class_
condition: condition] autorelease];
}
- initWithClass: (Class)class_
{
Class c = [self class];
[self release];
@throw [OFNotImplementedException exceptionWithClass: c
selector: _cmd];
}
- initWithClass: (Class)class_
condition: (OFCondition*)condition_
{
self = [super initWithClass: class_];
|
>
>
<
<
>
|
>
>
|
|
<
>
|
11
12
13
14
15
16
17
18
19
20
21
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
|
* Alternatively, it may be distributed under the terms of the GNU General
* Public License, either version 2 or 3, which can be found in the file
* LICENSE.GPLv2 or LICENSE.GPLv3 respectively included in the packaging of this
* file.
*/
#include "config.h"
#include <stdlib.h>
#import "OFConditionStillWaitingException.h"
#import "OFString.h"
#import "OFCondition.h"
@implementation OFConditionStillWaitingException
+ (instancetype)exceptionWithClass: (Class)class_
condition: (OFCondition*)condition
{
return [[[self alloc] initWithClass: class_
condition: condition] autorelease];
}
- initWithClass: (Class)class_
{
@try {
[self doesNotRecognizeSelector: _cmd];
abort();
} @catch (id e) {
[self release];
@throw e;
}
}
- initWithClass: (Class)class_
condition: (OFCondition*)condition_
{
self = [super initWithClass: class_];
|
︙ | | | ︙ | |
Modified src/exceptions/OFConditionWaitFailedException.m
from [f57be4081a]
to [46242fbae6].
︙ | | | ︙ | |
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
|
* Alternatively, it may be distributed under the terms of the GNU General
* Public License, either version 2 or 3, which can be found in the file
* LICENSE.GPLv2 or LICENSE.GPLv3 respectively included in the packaging of this
* file.
*/
#include "config.h"
#import "OFConditionWaitFailedException.h"
#import "OFString.h"
#import "OFCondition.h"
#import "OFNotImplementedException.h"
@implementation OFConditionWaitFailedException
+ (instancetype)exceptionWithClass: (Class)class_
condition: (OFCondition*)condition
{
return [[[self alloc] initWithClass: class_
condition: condition] autorelease];
}
- initWithClass: (Class)class_
{
Class c = [self class];
[self release];
@throw [OFNotImplementedException exceptionWithClass: c
selector: _cmd];
}
- initWithClass: (Class)class_
condition: (OFCondition*)condition_
{
self = [super initWithClass: class_];
|
>
>
<
<
>
|
>
>
|
|
<
>
|
11
12
13
14
15
16
17
18
19
20
21
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
|
* Alternatively, it may be distributed under the terms of the GNU General
* Public License, either version 2 or 3, which can be found in the file
* LICENSE.GPLv2 or LICENSE.GPLv3 respectively included in the packaging of this
* file.
*/
#include "config.h"
#include <stdlib.h>
#import "OFConditionWaitFailedException.h"
#import "OFString.h"
#import "OFCondition.h"
@implementation OFConditionWaitFailedException
+ (instancetype)exceptionWithClass: (Class)class_
condition: (OFCondition*)condition
{
return [[[self alloc] initWithClass: class_
condition: condition] autorelease];
}
- initWithClass: (Class)class_
{
@try {
[self doesNotRecognizeSelector: _cmd];
abort();
} @catch (id e) {
[self release];
@throw e;
}
}
- initWithClass: (Class)class_
condition: (OFCondition*)condition_
{
self = [super initWithClass: class_];
|
︙ | | | ︙ | |
Modified src/exceptions/OFConnectionFailedException.m
from [c39e733948]
to [489e5ee9c3].
︙ | | | ︙ | |
11
12
13
14
15
16
17
18
19
20
21
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
|
* Alternatively, it may be distributed under the terms of the GNU General
* Public License, either version 2 or 3, which can be found in the file
* LICENSE.GPLv2 or LICENSE.GPLv3 respectively included in the packaging of this
* file.
*/
#include "config.h"
#import "OFConnectionFailedException.h"
#import "OFString.h"
#import "OFTCPSocket.h"
#import "OFNotImplementedException.h"
#import "common.h"
@implementation OFConnectionFailedException
+ (instancetype)exceptionWithClass: (Class)class_
socket: (OFTCPSocket*)socket
host: (OFString*)host
port: (uint16_t)port
{
return [[[self alloc] initWithClass: class_
socket: socket
host: host
port: port] autorelease];
}
- initWithClass: (Class)class_
{
Class c = [self class];
[self release];
@throw [OFNotImplementedException exceptionWithClass: c
selector: _cmd];
}
- initWithClass: (Class)class_
socket: (OFTCPSocket*)socket_
host: (OFString*)host_
port: (uint16_t)port_
{
|
>
>
<
<
>
|
>
>
|
|
<
>
|
11
12
13
14
15
16
17
18
19
20
21
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
|
* Alternatively, it may be distributed under the terms of the GNU General
* Public License, either version 2 or 3, which can be found in the file
* LICENSE.GPLv2 or LICENSE.GPLv3 respectively included in the packaging of this
* file.
*/
#include "config.h"
#include <stdlib.h>
#import "OFConnectionFailedException.h"
#import "OFString.h"
#import "OFTCPSocket.h"
#import "common.h"
@implementation OFConnectionFailedException
+ (instancetype)exceptionWithClass: (Class)class_
socket: (OFTCPSocket*)socket
host: (OFString*)host
port: (uint16_t)port
{
return [[[self alloc] initWithClass: class_
socket: socket
host: host
port: port] autorelease];
}
- initWithClass: (Class)class_
{
@try {
[self doesNotRecognizeSelector: _cmd];
abort();
} @catch (id e) {
[self release];
@throw e;
}
}
- initWithClass: (Class)class_
socket: (OFTCPSocket*)socket_
host: (OFString*)host_
port: (uint16_t)port_
{
|
︙ | | | ︙ | |
Modified src/exceptions/OFCopyFileFailedException.m
from [0092226d0a]
to [2df64adc88].
︙ | | | ︙ | |
11
12
13
14
15
16
17
18
19
20
21
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
|
* Alternatively, it may be distributed under the terms of the GNU General
* Public License, either version 2 or 3, which can be found in the file
* LICENSE.GPLv2 or LICENSE.GPLv3 respectively included in the packaging of this
* file.
*/
#include "config.h"
#import "OFCopyFileFailedException.h"
#import "OFString.h"
#import "OFNotImplementedException.h"
#import "common.h"
@implementation OFCopyFileFailedException
+ (instancetype)exceptionWithClass: (Class)class_
sourcePath: (OFString*)source
destinationPath: (OFString*)destination
{
return [[[self alloc] initWithClass: class_
sourcePath: source
destinationPath: destination] autorelease];
}
- initWithClass: (Class)class_
{
Class c = [self class];
[self release];
@throw [OFNotImplementedException exceptionWithClass: c
selector: _cmd];
}
- initWithClass: (Class)class_
sourcePath: (OFString*)source
destinationPath: (OFString*)destination
{
self = [super initWithClass: class_];
|
>
>
<
<
>
|
>
>
|
|
<
>
|
11
12
13
14
15
16
17
18
19
20
21
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
|
* Alternatively, it may be distributed under the terms of the GNU General
* Public License, either version 2 or 3, which can be found in the file
* LICENSE.GPLv2 or LICENSE.GPLv3 respectively included in the packaging of this
* file.
*/
#include "config.h"
#include <stdlib.h>
#import "OFCopyFileFailedException.h"
#import "OFString.h"
#import "common.h"
@implementation OFCopyFileFailedException
+ (instancetype)exceptionWithClass: (Class)class_
sourcePath: (OFString*)source
destinationPath: (OFString*)destination
{
return [[[self alloc] initWithClass: class_
sourcePath: source
destinationPath: destination] autorelease];
}
- initWithClass: (Class)class_
{
@try {
[self doesNotRecognizeSelector: _cmd];
abort();
} @catch (id e) {
[self release];
@throw e;
}
}
- initWithClass: (Class)class_
sourcePath: (OFString*)source
destinationPath: (OFString*)destination
{
self = [super initWithClass: class_];
|
︙ | | | ︙ | |
Modified src/exceptions/OFCreateDirectoryFailedException.m
from [49460e3e5d]
to [5178d57406].
︙ | | | ︙ | |
11
12
13
14
15
16
17
18
19
20
21
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
|
* Alternatively, it may be distributed under the terms of the GNU General
* Public License, either version 2 or 3, which can be found in the file
* LICENSE.GPLv2 or LICENSE.GPLv3 respectively included in the packaging of this
* file.
*/
#include "config.h"
#import "OFCreateDirectoryFailedException.h"
#import "OFString.h"
#import "OFNotImplementedException.h"
#import "common.h"
@implementation OFCreateDirectoryFailedException
+ (instancetype)exceptionWithClass: (Class)class_
path: (OFString*)path_
{
return [[[self alloc] initWithClass: class_
path: path_] autorelease];
}
- initWithClass: (Class)class_
{
Class c = [self class];
[self release];
@throw [OFNotImplementedException exceptionWithClass: c
selector: _cmd];
}
- initWithClass: (Class)class_
path: (OFString*)path_
{
self = [super initWithClass: class_];
|
>
>
<
<
>
|
>
>
|
|
<
>
|
11
12
13
14
15
16
17
18
19
20
21
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
|
* Alternatively, it may be distributed under the terms of the GNU General
* Public License, either version 2 or 3, which can be found in the file
* LICENSE.GPLv2 or LICENSE.GPLv3 respectively included in the packaging of this
* file.
*/
#include "config.h"
#include <stdlib.h>
#import "OFCreateDirectoryFailedException.h"
#import "OFString.h"
#import "common.h"
@implementation OFCreateDirectoryFailedException
+ (instancetype)exceptionWithClass: (Class)class_
path: (OFString*)path_
{
return [[[self alloc] initWithClass: class_
path: path_] autorelease];
}
- initWithClass: (Class)class_
{
@try {
[self doesNotRecognizeSelector: _cmd];
abort();
} @catch (id e) {
[self release];
@throw e;
}
}
- initWithClass: (Class)class_
path: (OFString*)path_
{
self = [super initWithClass: class_];
|
︙ | | | ︙ | |
Modified src/exceptions/OFDeleteDirectoryFailedException.m
from [d0a7435971]
to [ca94e78ea5].
︙ | | | ︙ | |
11
12
13
14
15
16
17
18
19
20
21
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
|
* Alternatively, it may be distributed under the terms of the GNU General
* Public License, either version 2 or 3, which can be found in the file
* LICENSE.GPLv2 or LICENSE.GPLv3 respectively included in the packaging of this
* file.
*/
#include "config.h"
#import "OFDeleteDirectoryFailedException.h"
#import "OFString.h"
#import "OFNotImplementedException.h"
#import "common.h"
@implementation OFDeleteDirectoryFailedException
+ (instancetype)exceptionWithClass: (Class)class_
path: (OFString*)path_
{
return [[[self alloc] initWithClass: class_
path: path_] autorelease];
}
- initWithClass: (Class)class_
{
Class c = [self class];
[self release];
@throw [OFNotImplementedException exceptionWithClass: c
selector: _cmd];
}
- initWithClass: (Class)class_
path: (OFString*)path_
{
self = [super initWithClass: class_];
|
>
>
<
<
>
|
>
>
|
|
<
>
|
11
12
13
14
15
16
17
18
19
20
21
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
|
* Alternatively, it may be distributed under the terms of the GNU General
* Public License, either version 2 or 3, which can be found in the file
* LICENSE.GPLv2 or LICENSE.GPLv3 respectively included in the packaging of this
* file.
*/
#include "config.h"
#include <stdlib.h>
#import "OFDeleteDirectoryFailedException.h"
#import "OFString.h"
#import "common.h"
@implementation OFDeleteDirectoryFailedException
+ (instancetype)exceptionWithClass: (Class)class_
path: (OFString*)path_
{
return [[[self alloc] initWithClass: class_
path: path_] autorelease];
}
- initWithClass: (Class)class_
{
@try {
[self doesNotRecognizeSelector: _cmd];
abort();
} @catch (id e) {
[self release];
@throw e;
}
}
- initWithClass: (Class)class_
path: (OFString*)path_
{
self = [super initWithClass: class_];
|
︙ | | | ︙ | |
Modified src/exceptions/OFDeleteFileFailedException.m
from [b0c2776292]
to [f17b08ef53].
︙ | | | ︙ | |
11
12
13
14
15
16
17
18
19
20
21
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
|
* Alternatively, it may be distributed under the terms of the GNU General
* Public License, either version 2 or 3, which can be found in the file
* LICENSE.GPLv2 or LICENSE.GPLv3 respectively included in the packaging of this
* file.
*/
#include "config.h"
#import "OFDeleteFileFailedException.h"
#import "OFString.h"
#import "OFNotImplementedException.h"
#import "common.h"
@implementation OFDeleteFileFailedException
+ (instancetype)exceptionWithClass: (Class)class_
path: (OFString*)path_
{
return [[[self alloc] initWithClass: class_
path: path_] autorelease];
}
- initWithClass: (Class)class_
{
Class c = [self class];
[self release];
@throw [OFNotImplementedException exceptionWithClass: c
selector: _cmd];
}
- initWithClass: (Class)class_
path: (OFString*)path_
{
self = [super initWithClass: class_];
|
>
>
<
<
>
|
>
>
|
|
<
>
|
11
12
13
14
15
16
17
18
19
20
21
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
|
* Alternatively, it may be distributed under the terms of the GNU General
* Public License, either version 2 or 3, which can be found in the file
* LICENSE.GPLv2 or LICENSE.GPLv3 respectively included in the packaging of this
* file.
*/
#include "config.h"
#include <stdlib.h>
#import "OFDeleteFileFailedException.h"
#import "OFString.h"
#import "common.h"
@implementation OFDeleteFileFailedException
+ (instancetype)exceptionWithClass: (Class)class_
path: (OFString*)path_
{
return [[[self alloc] initWithClass: class_
path: path_] autorelease];
}
- initWithClass: (Class)class_
{
@try {
[self doesNotRecognizeSelector: _cmd];
abort();
} @catch (id e) {
[self release];
@throw e;
}
}
- initWithClass: (Class)class_
path: (OFString*)path_
{
self = [super initWithClass: class_];
|
︙ | | | ︙ | |
Modified src/exceptions/OFEnumerationMutationException.m
from [15571f572b]
to [a29a4c4c7c].
︙ | | | ︙ | |
11
12
13
14
15
16
17
18
19
20
21
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
|
* Alternatively, it may be distributed under the terms of the GNU General
* Public License, either version 2 or 3, which can be found in the file
* LICENSE.GPLv2 or LICENSE.GPLv3 respectively included in the packaging of this
* file.
*/
#include "config.h"
#import "OFEnumerationMutationException.h"
#import "OFString.h"
#import "OFNotImplementedException.h"
#import "common.h"
@implementation OFEnumerationMutationException
+ (instancetype)exceptionWithClass: (Class)class_
object: (id)object
{
return [[[self alloc] initWithClass: class_
object: object] autorelease];
}
- initWithClass: (Class)class_
{
Class c = [self class];
[self release];
@throw [OFNotImplementedException exceptionWithClass: c
selector: _cmd];
}
- initWithClass: (Class)class_
object: (id)object_
{
self = [super initWithClass: class_];
|
>
>
<
<
>
|
>
>
|
|
<
>
|
11
12
13
14
15
16
17
18
19
20
21
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
|
* Alternatively, it may be distributed under the terms of the GNU General
* Public License, either version 2 or 3, which can be found in the file
* LICENSE.GPLv2 or LICENSE.GPLv3 respectively included in the packaging of this
* file.
*/
#include "config.h"
#include <stdlib.h>
#import "OFEnumerationMutationException.h"
#import "OFString.h"
#import "common.h"
@implementation OFEnumerationMutationException
+ (instancetype)exceptionWithClass: (Class)class_
object: (id)object
{
return [[[self alloc] initWithClass: class_
object: object] autorelease];
}
- initWithClass: (Class)class_
{
@try {
[self doesNotRecognizeSelector: _cmd];
abort();
} @catch (id e) {
[self release];
@throw e;
}
}
- initWithClass: (Class)class_
object: (id)object_
{
self = [super initWithClass: class_];
|
︙ | | | ︙ | |
Modified src/exceptions/OFException.m
from [2112dc5f17]
to [e32d14537c].
︙ | | | ︙ | |
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
|
* Alternatively, it may be distributed under the terms of the GNU General
* Public License, either version 2 or 3, which can be found in the file
* LICENSE.GPLv2 or LICENSE.GPLv3 respectively included in the packaging of this
* file.
*/
#include "config.h"
#import "OFException.h"
#import "OFString.h"
#import "OFNotImplementedException.h"
@implementation OFException
+ (instancetype)exceptionWithClass: (Class)class_
{
return [[[self alloc] initWithClass: class_] autorelease];
}
- init
{
Class c = [self class];
[self release];
@throw [OFNotImplementedException exceptionWithClass: c
selector: _cmd];
}
- initWithClass: (Class)class_
{
self = [super init];
inClass = class_;
|
>
>
<
<
>
|
>
>
|
|
<
>
|
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
|
* Alternatively, it may be distributed under the terms of the GNU General
* Public License, either version 2 or 3, which can be found in the file
* LICENSE.GPLv2 or LICENSE.GPLv3 respectively included in the packaging of this
* file.
*/
#include "config.h"
#include <stdlib.h>
#import "OFException.h"
#import "OFString.h"
@implementation OFException
+ (instancetype)exceptionWithClass: (Class)class_
{
return [[[self alloc] initWithClass: class_] autorelease];
}
- init
{
@try {
[self doesNotRecognizeSelector: _cmd];
abort();
} @catch (id e) {
[self release];
@throw e;
}
}
- initWithClass: (Class)class_
{
self = [super init];
inClass = class_;
|
︙ | | | ︙ | |
Modified src/exceptions/OFHTTPRequestFailedException.m
from [f3f841e094]
to [89529e8143].
︙ | | | ︙ | |
11
12
13
14
15
16
17
18
19
20
21
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
|
* Alternatively, it may be distributed under the terms of the GNU General
* Public License, either version 2 or 3, which can be found in the file
* LICENSE.GPLv2 or LICENSE.GPLv3 respectively included in the packaging of this
* file.
*/
#include "config.h"
#import "OFHTTPRequestFailedException.h"
#import "OFString.h"
#import "OFHTTPRequest.h"
#import "OFNotImplementedException.h"
#import "autorelease.h"
#import "common.h"
@implementation OFHTTPRequestFailedException
+ (instancetype)exceptionWithClass: (Class)class_
request: (OFHTTPRequest*)request
result: (OFHTTPRequestResult*)result
{
return [[[self alloc] initWithClass: class_
request: request
result: result] autorelease];
}
- initWithClass: (Class)class_
{
Class c = [self class];
[self release];
@throw [OFNotImplementedException exceptionWithClass: c
selector: _cmd];
}
- initWithClass: (Class)class_
request: (OFHTTPRequest*)request_
result: (OFHTTPRequestResult*)result_
{
self = [super initWithClass: class_];
|
>
>
<
<
>
|
>
>
|
|
<
>
|
11
12
13
14
15
16
17
18
19
20
21
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
|
* Alternatively, it may be distributed under the terms of the GNU General
* Public License, either version 2 or 3, which can be found in the file
* LICENSE.GPLv2 or LICENSE.GPLv3 respectively included in the packaging of this
* file.
*/
#include "config.h"
#include <stdlib.h>
#import "OFHTTPRequestFailedException.h"
#import "OFString.h"
#import "OFHTTPRequest.h"
#import "autorelease.h"
#import "common.h"
@implementation OFHTTPRequestFailedException
+ (instancetype)exceptionWithClass: (Class)class_
request: (OFHTTPRequest*)request
result: (OFHTTPRequestResult*)result
{
return [[[self alloc] initWithClass: class_
request: request
result: result] autorelease];
}
- initWithClass: (Class)class_
{
@try {
[self doesNotRecognizeSelector: _cmd];
abort();
} @catch (id e) {
[self release];
@throw e;
}
}
- initWithClass: (Class)class_
request: (OFHTTPRequest*)request_
result: (OFHTTPRequestResult*)result_
{
self = [super initWithClass: class_];
|
︙ | | | ︙ | |
Modified src/exceptions/OFHashAlreadyCalculatedException.m
from [483aecd301]
to [1162c03304].
︙ | | | ︙ | |
11
12
13
14
15
16
17
18
19
20
21
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
|
* Alternatively, it may be distributed under the terms of the GNU General
* Public License, either version 2 or 3, which can be found in the file
* LICENSE.GPLv2 or LICENSE.GPLv3 respectively included in the packaging of this
* file.
*/
#include "config.h"
#import "OFHashAlreadyCalculatedException.h"
#import "OFString.h"
#import "OFHash.h"
#import "OFNotImplementedException.h"
#import "common.h"
@implementation OFHashAlreadyCalculatedException
+ (instancetype)exceptionWithClass: (Class)class_
hash: (OFHash*)hash
{
return [[[self alloc] initWithClass: class_
hash: hash] autorelease];
}
- initWithClass: (Class)class_
{
Class c = [self class];
[self release];
@throw [OFNotImplementedException exceptionWithClass: c
selector: _cmd];
}
- initWithClass: (Class)class_
hash: (OFHash*)hash
{
self = [super initWithClass: class_];
|
>
>
<
<
>
|
>
>
|
|
<
>
|
11
12
13
14
15
16
17
18
19
20
21
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
|
* Alternatively, it may be distributed under the terms of the GNU General
* Public License, either version 2 or 3, which can be found in the file
* LICENSE.GPLv2 or LICENSE.GPLv3 respectively included in the packaging of this
* file.
*/
#include "config.h"
#include <stdlib.h>
#import "OFHashAlreadyCalculatedException.h"
#import "OFString.h"
#import "OFHash.h"
#import "common.h"
@implementation OFHashAlreadyCalculatedException
+ (instancetype)exceptionWithClass: (Class)class_
hash: (OFHash*)hash
{
return [[[self alloc] initWithClass: class_
hash: hash] autorelease];
}
- initWithClass: (Class)class_
{
@try {
[self doesNotRecognizeSelector: _cmd];
abort();
} @catch (id e) {
[self release];
@throw e;
}
}
- initWithClass: (Class)class_
hash: (OFHash*)hash
{
self = [super initWithClass: class_];
|
︙ | | | ︙ | |
Modified src/exceptions/OFInvalidArgumentException.m
from [18afe7f030]
to [d573c7d088].
︙ | | | ︙ | |
11
12
13
14
15
16
17
18
19
20
21
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
|
* Alternatively, it may be distributed under the terms of the GNU General
* Public License, either version 2 or 3, which can be found in the file
* LICENSE.GPLv2 or LICENSE.GPLv3 respectively included in the packaging of this
* file.
*/
#include "config.h"
#import "OFInvalidArgumentException.h"
#import "OFString.h"
#import "OFNotImplementedException.h"
#import "common.h"
@implementation OFInvalidArgumentException
+ (instancetype)exceptionWithClass: (Class)class_
selector: (SEL)selector_
{
return [[[self alloc] initWithClass: class_
selector: selector_] autorelease];
}
- initWithClass: (Class)class_
{
Class c = [self class];
[self release];
@throw [OFNotImplementedException exceptionWithClass: c
selector: _cmd];
}
- initWithClass: (Class)class_
selector: (SEL)selector_
{
self = [super initWithClass: class_];
|
>
>
<
<
>
|
>
>
|
|
<
>
|
11
12
13
14
15
16
17
18
19
20
21
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
|
* Alternatively, it may be distributed under the terms of the GNU General
* Public License, either version 2 or 3, which can be found in the file
* LICENSE.GPLv2 or LICENSE.GPLv3 respectively included in the packaging of this
* file.
*/
#include "config.h"
#include <stdlib.h>
#import "OFInvalidArgumentException.h"
#import "OFString.h"
#import "common.h"
@implementation OFInvalidArgumentException
+ (instancetype)exceptionWithClass: (Class)class_
selector: (SEL)selector_
{
return [[[self alloc] initWithClass: class_
selector: selector_] autorelease];
}
- initWithClass: (Class)class_
{
@try {
[self doesNotRecognizeSelector: _cmd];
abort();
} @catch (id e) {
[self release];
@throw e;
}
}
- initWithClass: (Class)class_
selector: (SEL)selector_
{
self = [super initWithClass: class_];
|
︙ | | | ︙ | |
Modified src/exceptions/OFInvalidJSONException.m
from [b02bc86218]
to [7ebc35808d].
︙ | | | ︙ | |
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
|
* Alternatively, it may be distributed under the terms of the GNU General
* Public License, either version 2 or 3, which can be found in the file
* LICENSE.GPLv2 or LICENSE.GPLv3 respectively included in the packaging of this
* file.
*/
#include "config.h"
#import "OFInvalidJSONException.h"
#import "OFString.h"
#import "OFNotImplementedException.h"
@implementation OFInvalidJSONException
+ (instancetype)exceptionWithClass: (Class)class_
line: (size_t)line
{
return [[[self alloc] initWithClass: class_
line: line] autorelease];
}
- init
{
Class c = [self class];
[self release];
@throw [OFNotImplementedException exceptionWithClass: c
selector: _cmd];
}
- initWithClass: (Class)class_
line: (size_t)line_
{
self = [super initWithClass: class_];
|
>
>
<
<
>
|
>
>
|
|
<
>
|
11
12
13
14
15
16
17
18
19
20
21
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
|
* Alternatively, it may be distributed under the terms of the GNU General
* Public License, either version 2 or 3, which can be found in the file
* LICENSE.GPLv2 or LICENSE.GPLv3 respectively included in the packaging of this
* file.
*/
#include "config.h"
#include <stdlib.h>
#import "OFInvalidJSONException.h"
#import "OFString.h"
@implementation OFInvalidJSONException
+ (instancetype)exceptionWithClass: (Class)class_
line: (size_t)line
{
return [[[self alloc] initWithClass: class_
line: line] autorelease];
}
- init
{
@try {
[self doesNotRecognizeSelector: _cmd];
abort();
} @catch (id e) {
[self release];
@throw e;
}
}
- initWithClass: (Class)class_
line: (size_t)line_
{
self = [super initWithClass: class_];
|
︙ | | | ︙ | |
Modified src/exceptions/OFLinkFailedException.m
from [9f6ed4a020]
to [56b55d35a2].
︙ | | | ︙ | |
11
12
13
14
15
16
17
18
19
20
21
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
|
* Alternatively, it may be distributed under the terms of the GNU General
* Public License, either version 2 or 3, which can be found in the file
* LICENSE.GPLv2 or LICENSE.GPLv3 respectively included in the packaging of this
* file.
*/
#include "config.h"
#import "OFLinkFailedException.h"
#import "OFString.h"
#import "OFNotImplementedException.h"
#import "common.h"
#ifndef _WIN32
@implementation OFLinkFailedException
+ (instancetype)exceptionWithClass: (Class)class_
sourcePath: (OFString*)source
destinationPath: (OFString*)destination
{
return [[[self alloc] initWithClass: class_
sourcePath: source
destinationPath: destination] autorelease];
}
- initWithClass: (Class)class_
{
Class c = [self class];
[self release];
@throw [OFNotImplementedException exceptionWithClass: c
selector: _cmd];
}
- initWithClass: (Class)class_
sourcePath: (OFString*)source
destinationPath: (OFString*)destination
{
self = [super initWithClass: class_];
|
>
>
<
<
>
|
>
>
|
|
<
>
|
11
12
13
14
15
16
17
18
19
20
21
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
|
* Alternatively, it may be distributed under the terms of the GNU General
* Public License, either version 2 or 3, which can be found in the file
* LICENSE.GPLv2 or LICENSE.GPLv3 respectively included in the packaging of this
* file.
*/
#include "config.h"
#include <stdlib.h>
#import "OFLinkFailedException.h"
#import "OFString.h"
#import "common.h"
#ifndef _WIN32
@implementation OFLinkFailedException
+ (instancetype)exceptionWithClass: (Class)class_
sourcePath: (OFString*)source
destinationPath: (OFString*)destination
{
return [[[self alloc] initWithClass: class_
sourcePath: source
destinationPath: destination] autorelease];
}
- initWithClass: (Class)class_
{
@try {
[self doesNotRecognizeSelector: _cmd];
abort();
} @catch (id e) {
[self release];
@throw e;
}
}
- initWithClass: (Class)class_
sourcePath: (OFString*)source
destinationPath: (OFString*)destination
{
self = [super initWithClass: class_];
|
︙ | | | ︙ | |
Modified src/exceptions/OFListenFailedException.m
from [038815ba73]
to [acfa6cf611].
︙ | | | ︙ | |
11
12
13
14
15
16
17
18
19
20
21
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
|
* Alternatively, it may be distributed under the terms of the GNU General
* Public License, either version 2 or 3, which can be found in the file
* LICENSE.GPLv2 or LICENSE.GPLv3 respectively included in the packaging of this
* file.
*/
#include "config.h"
#import "OFListenFailedException.h"
#import "OFString.h"
#import "OFTCPSocket.h"
#import "OFNotImplementedException.h"
#import "common.h"
@implementation OFListenFailedException
+ (instancetype)exceptionWithClass: (Class)class_
socket: (OFTCPSocket*)socket
backLog: (int)backlog
{
return [[[self alloc] initWithClass: class_
socket: socket
backLog: backlog] autorelease];
}
- initWithClass: (Class)class_
{
Class c = [self class];
[self release];
@throw [OFNotImplementedException exceptionWithClass: c
selector: _cmd];
}
- initWithClass: (Class)class_
socket: (OFTCPSocket*)socket_
backLog: (int)backlog
{
self = [super initWithClass: class_];
|
>
>
<
<
>
|
>
>
|
|
<
>
|
11
12
13
14
15
16
17
18
19
20
21
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
|
* Alternatively, it may be distributed under the terms of the GNU General
* Public License, either version 2 or 3, which can be found in the file
* LICENSE.GPLv2 or LICENSE.GPLv3 respectively included in the packaging of this
* file.
*/
#include "config.h"
#include <stdlib.h>
#import "OFListenFailedException.h"
#import "OFString.h"
#import "OFTCPSocket.h"
#import "common.h"
@implementation OFListenFailedException
+ (instancetype)exceptionWithClass: (Class)class_
socket: (OFTCPSocket*)socket
backLog: (int)backlog
{
return [[[self alloc] initWithClass: class_
socket: socket
backLog: backlog] autorelease];
}
- initWithClass: (Class)class_
{
@try {
[self doesNotRecognizeSelector: _cmd];
abort();
} @catch (id e) {
[self release];
@throw e;
}
}
- initWithClass: (Class)class_
socket: (OFTCPSocket*)socket_
backLog: (int)backlog
{
self = [super initWithClass: class_];
|
︙ | | | ︙ | |
Modified src/exceptions/OFLockFailedException.m
from [573e15c5b2]
to [216c033d30].
︙ | | | ︙ | |
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
|
*/
#include "config.h"
#import "OFLockFailedException.h"
#import "OFString.h"
#import "OFNotImplementedException.h"
#import "macros.h"
@implementation OFLockFailedException
+ (instancetype)exceptionWithClass: (Class)class_
lock: (id <OFLocking>)lock
{
return [[[self alloc] initWithClass: class_
|
<
<
|
15
16
17
18
19
20
21
22
23
24
25
26
27
28
|
*/
#include "config.h"
#import "OFLockFailedException.h"
#import "OFString.h"
#import "macros.h"
@implementation OFLockFailedException
+ (instancetype)exceptionWithClass: (Class)class_
lock: (id <OFLocking>)lock
{
return [[[self alloc] initWithClass: class_
|
︙ | | | ︙ | |
Modified src/exceptions/OFMalformedXMLException.m
from [b3e0941446]
to [006a4e8017].
︙ | | | ︙ | |
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
|
#include "config.h"
#import "OFMalformedXMLException.h"
#import "OFString.h"
#import "OFXMLParser.h"
#import "OFNotImplementedException.h"
#import "common.h"
@implementation OFMalformedXMLException
+ (instancetype)exceptionWithClass: (Class)class_
parser: (OFXMLParser*)parser
{
return [[[self alloc] initWithClass: class_
|
<
<
|
16
17
18
19
20
21
22
23
24
25
26
27
28
29
|
#include "config.h"
#import "OFMalformedXMLException.h"
#import "OFString.h"
#import "OFXMLParser.h"
#import "common.h"
@implementation OFMalformedXMLException
+ (instancetype)exceptionWithClass: (Class)class_
parser: (OFXMLParser*)parser
{
return [[[self alloc] initWithClass: class_
|
︙ | | | ︙ | |
Modified src/exceptions/OFMemoryNotPartOfObjectException.m
from [cbc504825f]
to [2f129f6a0a].
︙ | | | ︙ | |
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
|
* Alternatively, it may be distributed under the terms of the GNU General
* Public License, either version 2 or 3, which can be found in the file
* LICENSE.GPLv2 or LICENSE.GPLv3 respectively included in the packaging of this
* file.
*/
#include "config.h"
#import "OFMemoryNotPartOfObjectException.h"
#import "OFString.h"
#import "OFNotImplementedException.h"
@implementation OFMemoryNotPartOfObjectException
+ (instancetype)exceptionWithClass: (Class)class_
pointer: (void*)ptr
{
return [[[self alloc] initWithClass: class_
pointer: ptr] autorelease];
}
- initWithClass: (Class)class_
{
Class c = [self class];
[self release];
@throw [OFNotImplementedException exceptionWithClass: c
selector: _cmd];
}
- initWithClass: (Class)class_
pointer: (void*)ptr
{
self = [super initWithClass: class_];
|
>
>
<
<
>
|
>
>
|
|
<
>
|
11
12
13
14
15
16
17
18
19
20
21
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
|
* Alternatively, it may be distributed under the terms of the GNU General
* Public License, either version 2 or 3, which can be found in the file
* LICENSE.GPLv2 or LICENSE.GPLv3 respectively included in the packaging of this
* file.
*/
#include "config.h"
#include <stdlib.h>
#import "OFMemoryNotPartOfObjectException.h"
#import "OFString.h"
@implementation OFMemoryNotPartOfObjectException
+ (instancetype)exceptionWithClass: (Class)class_
pointer: (void*)ptr
{
return [[[self alloc] initWithClass: class_
pointer: ptr] autorelease];
}
- initWithClass: (Class)class_
{
@try {
[self doesNotRecognizeSelector: _cmd];
abort();
} @catch (id e) {
[self release];
@throw e;
}
}
- initWithClass: (Class)class_
pointer: (void*)ptr
{
self = [super initWithClass: class_];
|
︙ | | | ︙ | |
Modified src/exceptions/OFNotConnectedException.m
from [24094739a0]
to [0d876782a7].
︙ | | | ︙ | |
11
12
13
14
15
16
17
18
19
20
21
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
|
* Alternatively, it may be distributed under the terms of the GNU General
* Public License, either version 2 or 3, which can be found in the file
* LICENSE.GPLv2 or LICENSE.GPLv3 respectively included in the packaging of this
* file.
*/
#include "config.h"
#import "OFNotConnectedException.h"
#import "OFString.h"
#import "OFTCPSocket.h"
#import "OFNotImplementedException.h"
#import "common.h"
@implementation OFNotConnectedException
+ (instancetype)exceptionWithClass: (Class)class_
socket: (OFStreamSocket*)socket
{
return [[[self alloc] initWithClass: class_
socket: socket] autorelease];
}
- initWithClass: (Class)class_
{
Class c = [self class];
[self release];
@throw [OFNotImplementedException exceptionWithClass: c
selector: _cmd];
}
- initWithClass: (Class)class_
socket: (OFStreamSocket*)socket_
{
self = [super initWithClass: class_];
|
>
>
<
<
>
|
>
>
|
|
<
>
|
11
12
13
14
15
16
17
18
19
20
21
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
|
* Alternatively, it may be distributed under the terms of the GNU General
* Public License, either version 2 or 3, which can be found in the file
* LICENSE.GPLv2 or LICENSE.GPLv3 respectively included in the packaging of this
* file.
*/
#include "config.h"
#include <stdlib.h>
#import "OFNotConnectedException.h"
#import "OFString.h"
#import "OFTCPSocket.h"
#import "common.h"
@implementation OFNotConnectedException
+ (instancetype)exceptionWithClass: (Class)class_
socket: (OFStreamSocket*)socket
{
return [[[self alloc] initWithClass: class_
socket: socket] autorelease];
}
- initWithClass: (Class)class_
{
@try {
[self doesNotRecognizeSelector: _cmd];
abort();
} @catch (id e) {
[self release];
@throw e;
}
}
- initWithClass: (Class)class_
socket: (OFStreamSocket*)socket_
{
self = [super initWithClass: class_];
|
︙ | | | ︙ | |
Modified src/exceptions/OFNotImplementedException.m
from [5283a9e0e5]
to [31161653fa].
︙ | | | ︙ | |
11
12
13
14
15
16
17
18
19
20
21
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
58
59
60
61
62
63
64
65
66
|
* Alternatively, it may be distributed under the terms of the GNU General
* Public License, either version 2 or 3, which can be found in the file
* LICENSE.GPLv2 or LICENSE.GPLv3 respectively included in the packaging of this
* file.
*/
#include "config.h"
#import "OFNotImplementedException.h"
#import "OFString.h"
#import "common.h"
@implementation OFNotImplementedException
+ (instancetype)exceptionWithClass: (Class)class_
selector: (SEL)selector
{
return [[[self alloc] initWithClass: class_
selector: selector] autorelease];
}
- initWithClass: (Class)class_
{
Class c = [self class];
[self release];
@throw [OFNotImplementedException exceptionWithClass: c
selector: _cmd];
}
- initWithClass: (Class)class_
selector: (SEL)selector_
{
self = [super initWithClass: class_];
selector = selector_;
return self;
}
- (OFString*)description
{
if (description != nil)
return description;
description = [[OFString alloc] initWithFormat:
@"The method %s of class %@ is not or not fully implemented!",
sel_getName(selector), inClass];
return description;
}
- (SEL)selector
{
return selector;
}
@end
|
>
>
>
|
>
>
|
|
<
>
|
|
|
11
12
13
14
15
16
17
18
19
20
21
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
58
59
60
61
62
63
64
65
66
67
68
69
70
71
|
* Alternatively, it may be distributed under the terms of the GNU General
* Public License, either version 2 or 3, which can be found in the file
* LICENSE.GPLv2 or LICENSE.GPLv3 respectively included in the packaging of this
* file.
*/
#include "config.h"
#include <stdlib.h>
#import "OFNotImplementedException.h"
#import "OFString.h"
#import "common.h"
@implementation OFNotImplementedException
+ (instancetype)exceptionWithClass: (Class)class_
selector: (SEL)selector
{
return [[[self alloc] initWithClass: class_
selector: selector] autorelease];
}
- initWithClass: (Class)class_
{
@try {
[self doesNotRecognizeSelector: _cmd];
abort();
} @catch (id e) {
[self release];
@throw e;
}
}
- initWithClass: (Class)class_
selector: (SEL)selector_
{
self = [super initWithClass: class_];
selector = selector_;
return self;
}
- (OFString*)description
{
if (description != nil)
return description;
description = [[OFString alloc] initWithFormat:
@"The selector %s is not understood by class %@ or not (fully) "
@"implemented!", sel_getName(selector), inClass];
return description;
}
- (SEL)selector
{
return selector;
}
@end
|
Modified src/exceptions/OFOpenFileFailedException.m
from [a32dab7ab4]
to [94930c081e].
︙ | | | ︙ | |
11
12
13
14
15
16
17
18
19
20
21
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
|
* Alternatively, it may be distributed under the terms of the GNU General
* Public License, either version 2 or 3, which can be found in the file
* LICENSE.GPLv2 or LICENSE.GPLv3 respectively included in the packaging of this
* file.
*/
#include "config.h"
#import "OFOpenFileFailedException.h"
#import "OFString.h"
#import "OFNotImplementedException.h"
#import "common.h"
@implementation OFOpenFileFailedException
+ (instancetype)exceptionWithClass: (Class)class_
path: (OFString*)path
mode: (OFString*)mode
{
return [[[self alloc] initWithClass: class_
path: path
mode: mode] autorelease];
}
- initWithClass: (Class)class_
{
Class c = [self class];
[self release];
@throw [OFNotImplementedException exceptionWithClass: c
selector: _cmd];
}
- initWithClass: (Class)class_
path: (OFString*)path_
mode: (OFString*)mode_
{
self = [super initWithClass: class_];
|
>
>
<
<
>
|
>
>
|
|
<
>
|
11
12
13
14
15
16
17
18
19
20
21
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
|
* Alternatively, it may be distributed under the terms of the GNU General
* Public License, either version 2 or 3, which can be found in the file
* LICENSE.GPLv2 or LICENSE.GPLv3 respectively included in the packaging of this
* file.
*/
#include "config.h"
#include <stdlib.h>
#import "OFOpenFileFailedException.h"
#import "OFString.h"
#import "common.h"
@implementation OFOpenFileFailedException
+ (instancetype)exceptionWithClass: (Class)class_
path: (OFString*)path
mode: (OFString*)mode
{
return [[[self alloc] initWithClass: class_
path: path
mode: mode] autorelease];
}
- initWithClass: (Class)class_
{
@try {
[self doesNotRecognizeSelector: _cmd];
abort();
} @catch (id e) {
[self release];
@throw e;
}
}
- initWithClass: (Class)class_
path: (OFString*)path_
mode: (OFString*)mode_
{
self = [super initWithClass: class_];
|
︙ | | | ︙ | |
Modified src/exceptions/OFReadOrWriteFailedException.m
from [af417a70ea]
to [e1a4cb7250].
︙ | | | ︙ | |
11
12
13
14
15
16
17
18
19
20
21
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
|
* Alternatively, it may be distributed under the terms of the GNU General
* Public License, either version 2 or 3, which can be found in the file
* LICENSE.GPLv2 or LICENSE.GPLv3 respectively included in the packaging of this
* file.
*/
#include "config.h"
#import "OFReadOrWriteFailedException.h"
#import "OFString.h"
#import "OFStreamSocket.h"
#import "OFNotImplementedException.h"
#import "common.h"
@implementation OFReadOrWriteFailedException
+ (instancetype)exceptionWithClass: (Class)class_
stream: (OFStream*)stream
requestedLength: (size_t)length
{
return [[[self alloc] initWithClass: class_
stream: stream
requestedLength: length] autorelease];
}
- initWithClass: (Class)class_
{
Class c = [self class];
[self release];
@throw [OFNotImplementedException exceptionWithClass: c
selector: _cmd];
}
- initWithClass: (Class)class_
stream: (OFStream*)stream_
requestedLength: (size_t)length
{
self = [super initWithClass: class_];
|
>
>
<
<
>
|
>
>
|
|
<
>
|
11
12
13
14
15
16
17
18
19
20
21
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
|
* Alternatively, it may be distributed under the terms of the GNU General
* Public License, either version 2 or 3, which can be found in the file
* LICENSE.GPLv2 or LICENSE.GPLv3 respectively included in the packaging of this
* file.
*/
#include "config.h"
#include <stdlib.h>
#import "OFReadOrWriteFailedException.h"
#import "OFString.h"
#import "OFStreamSocket.h"
#import "common.h"
@implementation OFReadOrWriteFailedException
+ (instancetype)exceptionWithClass: (Class)class_
stream: (OFStream*)stream
requestedLength: (size_t)length
{
return [[[self alloc] initWithClass: class_
stream: stream
requestedLength: length] autorelease];
}
- initWithClass: (Class)class_
{
@try {
[self doesNotRecognizeSelector: _cmd];
abort();
} @catch (id e) {
[self release];
@throw e;
}
}
- initWithClass: (Class)class_
stream: (OFStream*)stream_
requestedLength: (size_t)length
{
self = [super initWithClass: class_];
|
︙ | | | ︙ | |
Modified src/exceptions/OFRenameFileFailedException.m
from [2f687e8aec]
to [bd163b2b08].
︙ | | | ︙ | |
11
12
13
14
15
16
17
18
19
20
21
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
|
* Alternatively, it may be distributed under the terms of the GNU General
* Public License, either version 2 or 3, which can be found in the file
* LICENSE.GPLv2 or LICENSE.GPLv3 respectively included in the packaging of this
* file.
*/
#include "config.h"
#import "OFRenameFileFailedException.h"
#import "OFString.h"
#import "OFNotImplementedException.h"
#import "common.h"
@implementation OFRenameFileFailedException
+ (instancetype)exceptionWithClass: (Class)class_
sourcePath: (OFString*)source
destinationPath: (OFString*)destination
{
return [[[self alloc] initWithClass: class_
sourcePath: source
destinationPath: destination] autorelease];
}
- initWithClass: (Class)class_
{
Class c = [self class];
[self release];
@throw [OFNotImplementedException exceptionWithClass: c
selector: _cmd];
}
- initWithClass: (Class)class_
sourcePath: (OFString*)source
destinationPath: (OFString*)destination
{
self = [super initWithClass: class_];
|
>
>
<
<
>
|
>
>
|
|
<
>
|
11
12
13
14
15
16
17
18
19
20
21
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
|
* Alternatively, it may be distributed under the terms of the GNU General
* Public License, either version 2 or 3, which can be found in the file
* LICENSE.GPLv2 or LICENSE.GPLv3 respectively included in the packaging of this
* file.
*/
#include "config.h"
#include <stdlib.h>
#import "OFRenameFileFailedException.h"
#import "OFString.h"
#import "common.h"
@implementation OFRenameFileFailedException
+ (instancetype)exceptionWithClass: (Class)class_
sourcePath: (OFString*)source
destinationPath: (OFString*)destination
{
return [[[self alloc] initWithClass: class_
sourcePath: source
destinationPath: destination] autorelease];
}
- initWithClass: (Class)class_
{
@try {
[self doesNotRecognizeSelector: _cmd];
abort();
} @catch (id e) {
[self release];
@throw e;
}
}
- initWithClass: (Class)class_
sourcePath: (OFString*)source
destinationPath: (OFString*)destination
{
self = [super initWithClass: class_];
|
︙ | | | ︙ | |
Modified src/exceptions/OFSeekFailedException.m
from [d1cecd4b8a]
to [f5ed617a11].
︙ | | | ︙ | |
11
12
13
14
15
16
17
18
19
20
21
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
|
* Alternatively, it may be distributed under the terms of the GNU General
* Public License, either version 2 or 3, which can be found in the file
* LICENSE.GPLv2 or LICENSE.GPLv3 respectively included in the packaging of this
* file.
*/
#include "config.h"
#import "OFSeekFailedException.h"
#import "OFString.h"
#import "OFSeekableStream.h"
#import "OFNotImplementedException.h"
#import "common.h"
@implementation OFSeekFailedException
+ (instancetype)exceptionWithClass: (Class)class_
stream: (OFSeekableStream*)stream
offset: (off_t)offset
whence: (int)whence
{
return [[[self alloc] initWithClass: class_
stream: stream
offset: offset
whence: whence] autorelease];
}
- initWithClass: (Class)class_
{
Class c = [self class];
[self release];
@throw [OFNotImplementedException exceptionWithClass: c
selector: _cmd];
}
- initWithClass: (Class)class_
stream: (OFSeekableStream*)stream_
offset: (off_t)offset_
whence: (int)whence_
{
|
>
>
<
<
>
|
>
>
|
|
<
>
|
11
12
13
14
15
16
17
18
19
20
21
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
|
* Alternatively, it may be distributed under the terms of the GNU General
* Public License, either version 2 or 3, which can be found in the file
* LICENSE.GPLv2 or LICENSE.GPLv3 respectively included in the packaging of this
* file.
*/
#include "config.h"
#include <stdlib.h>
#import "OFSeekFailedException.h"
#import "OFString.h"
#import "OFSeekableStream.h"
#import "common.h"
@implementation OFSeekFailedException
+ (instancetype)exceptionWithClass: (Class)class_
stream: (OFSeekableStream*)stream
offset: (off_t)offset
whence: (int)whence
{
return [[[self alloc] initWithClass: class_
stream: stream
offset: offset
whence: whence] autorelease];
}
- initWithClass: (Class)class_
{
@try {
[self doesNotRecognizeSelector: _cmd];
abort();
} @catch (id e) {
[self release];
@throw e;
}
}
- initWithClass: (Class)class_
stream: (OFSeekableStream*)stream_
offset: (off_t)offset_
whence: (int)whence_
{
|
︙ | | | ︙ | |
Modified src/exceptions/OFSetOptionFailedException.m
from [df261401f3]
to [58cd1e1798].
︙ | | | ︙ | |
11
12
13
14
15
16
17
18
19
20
21
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
|
* Alternatively, it may be distributed under the terms of the GNU General
* Public License, either version 2 or 3, which can be found in the file
* LICENSE.GPLv2 or LICENSE.GPLv3 respectively included in the packaging of this
* file.
*/
#include "config.h"
#import "OFSetOptionFailedException.h"
#import "OFString.h"
#import "OFStream.h"
#import "OFNotImplementedException.h"
#import "common.h"
@implementation OFSetOptionFailedException
+ (instancetype)exceptionWithClass: (Class)class_
stream: (OFStream*)stream
{
return [[[self alloc] initWithClass: class_
stream: stream] autorelease];
}
- initWithClass: (Class)class_
{
Class c = [self class];
[self release];
@throw [OFNotImplementedException exceptionWithClass: c
selector: _cmd];
}
- initWithClass: (Class)class_
stream: (OFStream*)stream_
{
self = [super initWithClass: class_];
|
>
>
<
<
>
|
>
>
|
|
<
>
|
11
12
13
14
15
16
17
18
19
20
21
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
|
* Alternatively, it may be distributed under the terms of the GNU General
* Public License, either version 2 or 3, which can be found in the file
* LICENSE.GPLv2 or LICENSE.GPLv3 respectively included in the packaging of this
* file.
*/
#include "config.h"
#include <stdlib.h>
#import "OFSetOptionFailedException.h"
#import "OFString.h"
#import "OFStream.h"
#import "common.h"
@implementation OFSetOptionFailedException
+ (instancetype)exceptionWithClass: (Class)class_
stream: (OFStream*)stream
{
return [[[self alloc] initWithClass: class_
stream: stream] autorelease];
}
- initWithClass: (Class)class_
{
@try {
[self doesNotRecognizeSelector: _cmd];
abort();
} @catch (id e) {
[self release];
@throw e;
}
}
- initWithClass: (Class)class_
stream: (OFStream*)stream_
{
self = [super initWithClass: class_];
|
︙ | | | ︙ | |
Modified src/exceptions/OFStillLockedException.m
from [89bf01b698]
to [36d00b82d6].
︙ | | | ︙ | |
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
|
*/
#include "config.h"
#import "OFStillLockedException.h"
#import "OFString.h"
#import "OFNotImplementedException.h"
#import "macros.h"
@implementation OFStillLockedException
+ (instancetype)exceptionWithClass: (Class)class_
lock: (id <OFLocking>)lock
{
return [[[self alloc] initWithClass: class_
|
<
<
|
15
16
17
18
19
20
21
22
23
24
25
26
27
28
|
*/
#include "config.h"
#import "OFStillLockedException.h"
#import "OFString.h"
#import "macros.h"
@implementation OFStillLockedException
+ (instancetype)exceptionWithClass: (Class)class_
lock: (id <OFLocking>)lock
{
return [[[self alloc] initWithClass: class_
|
︙ | | | ︙ | |
Modified src/exceptions/OFSymlinkFailedException.m
from [9c1b009edc]
to [b64d2c9b32].
︙ | | | ︙ | |
11
12
13
14
15
16
17
18
19
20
21
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
|
* Alternatively, it may be distributed under the terms of the GNU General
* Public License, either version 2 or 3, which can be found in the file
* LICENSE.GPLv2 or LICENSE.GPLv3 respectively included in the packaging of this
* file.
*/
#include "config.h"
#import "OFSymlinkFailedException.h"
#import "OFString.h"
#import "OFNotImplementedException.h"
#import "common.h"
#ifndef _WIN32
@implementation OFSymlinkFailedException
+ (instancetype)exceptionWithClass: (Class)class_
sourcePath: (OFString*)source
destinationPath: (OFString*)destination
{
return [[[self alloc] initWithClass: class_
sourcePath: source
destinationPath: destination] autorelease];
}
- initWithClass: (Class)class_
{
Class c = [self class];
[self release];
@throw [OFNotImplementedException exceptionWithClass: c
selector: _cmd];
}
- initWithClass: (Class)class_
sourcePath: (OFString*)source
destinationPath: (OFString*)destination
{
self = [super initWithClass: class_];
|
>
>
<
<
>
|
>
>
|
|
<
>
|
11
12
13
14
15
16
17
18
19
20
21
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
|
* Alternatively, it may be distributed under the terms of the GNU General
* Public License, either version 2 or 3, which can be found in the file
* LICENSE.GPLv2 or LICENSE.GPLv3 respectively included in the packaging of this
* file.
*/
#include "config.h"
#include <stdlib.h>
#import "OFSymlinkFailedException.h"
#import "OFString.h"
#import "common.h"
#ifndef _WIN32
@implementation OFSymlinkFailedException
+ (instancetype)exceptionWithClass: (Class)class_
sourcePath: (OFString*)source
destinationPath: (OFString*)destination
{
return [[[self alloc] initWithClass: class_
sourcePath: source
destinationPath: destination] autorelease];
}
- initWithClass: (Class)class_
{
@try {
[self doesNotRecognizeSelector: _cmd];
abort();
} @catch (id e) {
[self release];
@throw e;
}
}
- initWithClass: (Class)class_
sourcePath: (OFString*)source
destinationPath: (OFString*)destination
{
self = [super initWithClass: class_];
|
︙ | | | ︙ | |
Modified src/exceptions/OFThreadJoinFailedException.m
from [dcbbd27d07]
to [fc1aa36d36].
︙ | | | ︙ | |
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
|
* Alternatively, it may be distributed under the terms of the GNU General
* Public License, either version 2 or 3, which can be found in the file
* LICENSE.GPLv2 or LICENSE.GPLv3 respectively included in the packaging of this
* file.
*/
#include "config.h"
#import "OFThreadJoinFailedException.h"
#import "OFString.h"
#import "OFThread.h"
#import "OFNotImplementedException.h"
@implementation OFThreadJoinFailedException
+ (instancetype)exceptionWithClass: (Class)class_
thread: (OFThread*)thread
{
return [[[self alloc] initWithClass: class_
thread: thread] autorelease];
}
- initWithClass: (Class)class_
{
Class c = [self class];
[self release];
@throw [OFNotImplementedException exceptionWithClass: c
selector: _cmd];
}
- initWithClass: (Class)class_
thread: (OFThread*)thread_
{
self = [super initWithClass: class_];
|
>
>
<
<
>
|
>
>
|
|
<
>
|
11
12
13
14
15
16
17
18
19
20
21
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
|
* Alternatively, it may be distributed under the terms of the GNU General
* Public License, either version 2 or 3, which can be found in the file
* LICENSE.GPLv2 or LICENSE.GPLv3 respectively included in the packaging of this
* file.
*/
#include "config.h"
#include <stdlib.h>
#import "OFThreadJoinFailedException.h"
#import "OFString.h"
#import "OFThread.h"
@implementation OFThreadJoinFailedException
+ (instancetype)exceptionWithClass: (Class)class_
thread: (OFThread*)thread
{
return [[[self alloc] initWithClass: class_
thread: thread] autorelease];
}
- initWithClass: (Class)class_
{
@try {
[self doesNotRecognizeSelector: _cmd];
abort();
} @catch (id e) {
[self release];
@throw e;
}
}
- initWithClass: (Class)class_
thread: (OFThread*)thread_
{
self = [super initWithClass: class_];
|
︙ | | | ︙ | |
Modified src/exceptions/OFThreadStartFailedException.m
from [b64a1ff539]
to [354bccc4cc].
︙ | | | ︙ | |
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
|
* Alternatively, it may be distributed under the terms of the GNU General
* Public License, either version 2 or 3, which can be found in the file
* LICENSE.GPLv2 or LICENSE.GPLv3 respectively included in the packaging of this
* file.
*/
#include "config.h"
#import "OFThreadStartFailedException.h"
#import "OFString.h"
#import "OFThread.h"
#import "OFNotImplementedException.h"
@implementation OFThreadStartFailedException
+ (instancetype)exceptionWithClass: (Class)class_
thread: (OFThread*)thread
{
return [[[self alloc] initWithClass: class_
thread: thread] autorelease];
}
- initWithClass: (Class)class_
{
Class c = [self class];
[self release];
@throw [OFNotImplementedException exceptionWithClass: c
selector: _cmd];
}
- initWithClass: (Class)class_
thread: (OFThread*)thread_
{
self = [super initWithClass: class_];
|
>
>
<
<
>
|
>
>
|
|
<
>
|
11
12
13
14
15
16
17
18
19
20
21
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
|
* Alternatively, it may be distributed under the terms of the GNU General
* Public License, either version 2 or 3, which can be found in the file
* LICENSE.GPLv2 or LICENSE.GPLv3 respectively included in the packaging of this
* file.
*/
#include "config.h"
#include <stdlib.h>
#import "OFThreadStartFailedException.h"
#import "OFString.h"
#import "OFThread.h"
@implementation OFThreadStartFailedException
+ (instancetype)exceptionWithClass: (Class)class_
thread: (OFThread*)thread
{
return [[[self alloc] initWithClass: class_
thread: thread] autorelease];
}
- initWithClass: (Class)class_
{
@try {
[self doesNotRecognizeSelector: _cmd];
abort();
} @catch (id e) {
[self release];
@throw e;
}
}
- initWithClass: (Class)class_
thread: (OFThread*)thread_
{
self = [super initWithClass: class_];
|
︙ | | | ︙ | |
Modified src/exceptions/OFThreadStillRunningException.m
from [f3a233791c]
to [c62f2a8214].
︙ | | | ︙ | |
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
|
* Alternatively, it may be distributed under the terms of the GNU General
* Public License, either version 2 or 3, which can be found in the file
* LICENSE.GPLv2 or LICENSE.GPLv3 respectively included in the packaging of this
* file.
*/
#include "config.h"
#import "OFThreadStillRunningException.h"
#import "OFString.h"
#import "OFThread.h"
#import "OFNotImplementedException.h"
@implementation OFThreadStillRunningException
+ (instancetype)exceptionWithClass: (Class)class_
thread: (OFThread*)thread
{
return [[[self alloc] initWithClass: class_
thread: thread] autorelease];
}
- initWithClass: (Class)class_
{
Class c = [self class];
[self release];
@throw [OFNotImplementedException exceptionWithClass: c
selector: _cmd];
}
- initWithClass: (Class)class_
thread: (OFThread*)thread_
{
self = [super initWithClass: class_];
|
>
>
<
<
>
|
>
>
|
|
<
>
|
11
12
13
14
15
16
17
18
19
20
21
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
|
* Alternatively, it may be distributed under the terms of the GNU General
* Public License, either version 2 or 3, which can be found in the file
* LICENSE.GPLv2 or LICENSE.GPLv3 respectively included in the packaging of this
* file.
*/
#include "config.h"
#include <stdlib.h>
#import "OFThreadStillRunningException.h"
#import "OFString.h"
#import "OFThread.h"
@implementation OFThreadStillRunningException
+ (instancetype)exceptionWithClass: (Class)class_
thread: (OFThread*)thread
{
return [[[self alloc] initWithClass: class_
thread: thread] autorelease];
}
- initWithClass: (Class)class_
{
@try {
[self doesNotRecognizeSelector: _cmd];
abort();
} @catch (id e) {
[self release];
@throw e;
}
}
- initWithClass: (Class)class_
thread: (OFThread*)thread_
{
self = [super initWithClass: class_];
|
︙ | | | ︙ | |
Modified src/exceptions/OFUnboundNamespaceException.m
from [611f4c170e]
to [d1c53e726d].
︙ | | | ︙ | |
11
12
13
14
15
16
17
18
19
20
21
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
|
* Alternatively, it may be distributed under the terms of the GNU General
* Public License, either version 2 or 3, which can be found in the file
* LICENSE.GPLv2 or LICENSE.GPLv3 respectively included in the packaging of this
* file.
*/
#include "config.h"
#import "OFUnboundNamespaceException.h"
#import "OFString.h"
#import "OFNotImplementedException.h"
#import "common.h"
@implementation OFUnboundNamespaceException
+ (instancetype)exceptionWithClass: (Class)class_
namespace: (OFString*)ns
{
return [[[self alloc] initWithClass: class_
namespace: ns] autorelease];
}
+ (instancetype)exceptionWithClass: (Class)class_
prefix: (OFString*)prefix
{
return [[[self alloc] initWithClass: class_
prefix: prefix] autorelease];
}
- initWithClass: (Class)class_
{
Class c = [self class];
[self release];
@throw [OFNotImplementedException exceptionWithClass: c
selector: _cmd];
}
- initWithClass: (Class)class_
namespace: (OFString*)ns_
{
self = [super initWithClass: class_];
|
>
>
<
<
>
|
>
>
|
|
<
>
|
11
12
13
14
15
16
17
18
19
20
21
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
|
* Alternatively, it may be distributed under the terms of the GNU General
* Public License, either version 2 or 3, which can be found in the file
* LICENSE.GPLv2 or LICENSE.GPLv3 respectively included in the packaging of this
* file.
*/
#include "config.h"
#include <stdlib.h>
#import "OFUnboundNamespaceException.h"
#import "OFString.h"
#import "common.h"
@implementation OFUnboundNamespaceException
+ (instancetype)exceptionWithClass: (Class)class_
namespace: (OFString*)ns
{
return [[[self alloc] initWithClass: class_
namespace: ns] autorelease];
}
+ (instancetype)exceptionWithClass: (Class)class_
prefix: (OFString*)prefix
{
return [[[self alloc] initWithClass: class_
prefix: prefix] autorelease];
}
- initWithClass: (Class)class_
{
@try {
[self doesNotRecognizeSelector: _cmd];
abort();
} @catch (id e) {
[self release];
@throw e;
}
}
- initWithClass: (Class)class_
namespace: (OFString*)ns_
{
self = [super initWithClass: class_];
|
︙ | | | ︙ | |
Modified src/exceptions/OFUnlockFailedException.m
from [ef011d99a3]
to [287873875d].
︙ | | | ︙ | |
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
|
*/
#include "config.h"
#import "OFUnlockFailedException.h"
#import "OFString.h"
#import "OFNotImplementedException.h"
#import "macros.h"
@implementation OFUnlockFailedException
+ (instancetype)exceptionWithClass: (Class)class_
lock: (id <OFLocking>)lock
{
return [[[self alloc] initWithClass: class_
|
<
<
|
15
16
17
18
19
20
21
22
23
24
25
26
27
28
|
*/
#include "config.h"
#import "OFUnlockFailedException.h"
#import "OFString.h"
#import "macros.h"
@implementation OFUnlockFailedException
+ (instancetype)exceptionWithClass: (Class)class_
lock: (id <OFLocking>)lock
{
return [[[self alloc] initWithClass: class_
|
︙ | | | ︙ | |
Modified src/exceptions/OFUnsupportedProtocolException.m
from [be041cf8f8]
to [f034f4fd41].
︙ | | | ︙ | |
11
12
13
14
15
16
17
18
19
20
21
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
|
* Alternatively, it may be distributed under the terms of the GNU General
* Public License, either version 2 or 3, which can be found in the file
* LICENSE.GPLv2 or LICENSE.GPLv3 respectively included in the packaging of this
* file.
*/
#include "config.h"
#import "OFUnsupportedProtocolException.h"
#import "OFString.h"
#import "OFURL.h"
#import "OFNotImplementedException.h"
#import "common.h"
@implementation OFUnsupportedProtocolException
+ (instancetype)exceptionWithClass: (Class)class_
URL: (OFURL*)url
{
return [[[self alloc] initWithClass: class_
URL: url] autorelease];
}
- initWithClass: (Class)class_
{
Class c = [self class];
[self release];
@throw [OFNotImplementedException exceptionWithClass: c
selector: _cmd];
}
- initWithClass: (Class)class_
URL: (OFURL*)url
{
self = [super initWithClass: class_];
|
>
>
<
<
>
|
>
>
|
|
<
>
|
11
12
13
14
15
16
17
18
19
20
21
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
|
* Alternatively, it may be distributed under the terms of the GNU General
* Public License, either version 2 or 3, which can be found in the file
* LICENSE.GPLv2 or LICENSE.GPLv3 respectively included in the packaging of this
* file.
*/
#include "config.h"
#include <stdlib.h>
#import "OFUnsupportedProtocolException.h"
#import "OFString.h"
#import "OFURL.h"
#import "common.h"
@implementation OFUnsupportedProtocolException
+ (instancetype)exceptionWithClass: (Class)class_
URL: (OFURL*)url
{
return [[[self alloc] initWithClass: class_
URL: url] autorelease];
}
- initWithClass: (Class)class_
{
@try {
[self doesNotRecognizeSelector: _cmd];
abort();
} @catch (id e) {
[self release];
@throw e;
}
}
- initWithClass: (Class)class_
URL: (OFURL*)url
{
self = [super initWithClass: class_];
|
︙ | | | ︙ | |
Modified src/exceptions/OFUnsupportedVersionException.m
from [b93e7d43cd]
to [406a681988].
︙ | | | ︙ | |
11
12
13
14
15
16
17
18
19
20
21
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
|
* Alternatively, it may be distributed under the terms of the GNU General
* Public License, either version 2 or 3, which can be found in the file
* LICENSE.GPLv2 or LICENSE.GPLv3 respectively included in the packaging of this
* file.
*/
#include "config.h"
#import "OFUnsupportedVersionException.h"
#import "OFString.h"
#import "OFNotImplementedException.h"
#import "common.h"
@implementation OFUnsupportedVersionException
+ (instancetype)exceptionWithClass: (Class)class_
version: (OFString*)version
{
return [[[self alloc] initWithClass: class_
version: version] autorelease];
}
- initWithClass: (Class)class_
{
Class c = [self class];
[self release];
@throw [OFNotImplementedException exceptionWithClass: c
selector: _cmd];
}
- initWithClass: (Class)class_
version: (OFString*)version_
{
self = [super initWithClass: class_];
|
>
>
<
<
>
|
>
>
|
|
<
>
|
11
12
13
14
15
16
17
18
19
20
21
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
|
* Alternatively, it may be distributed under the terms of the GNU General
* Public License, either version 2 or 3, which can be found in the file
* LICENSE.GPLv2 or LICENSE.GPLv3 respectively included in the packaging of this
* file.
*/
#include "config.h"
#include <stdlib.h>
#import "OFUnsupportedVersionException.h"
#import "OFString.h"
#import "common.h"
@implementation OFUnsupportedVersionException
+ (instancetype)exceptionWithClass: (Class)class_
version: (OFString*)version
{
return [[[self alloc] initWithClass: class_
version: version] autorelease];
}
- initWithClass: (Class)class_
{
@try {
[self doesNotRecognizeSelector: _cmd];
abort();
} @catch (id e) {
[self release];
@throw e;
}
}
- initWithClass: (Class)class_
version: (OFString*)version_
{
self = [super initWithClass: class_];
|
︙ | | | ︙ | |