Modified src/OFApplication.m
from [c32b0e2937]
to [35ca9806a3].
︙ | | |
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
|
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 "OFNotImplementedException.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
|
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 "OFNotImplementedException.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
|
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
|
-
-
-
+
+
+
+
+
|
- (void)release
{
}
- (void)dealloc
{
@throw [OFNotImplementedException exceptionWithClass: [self class]
selector: _cmd];
[super dealloc]; /* Get rid of a stupid warning */
[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
|
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 {
Class c = [self class];
[self doesNotRecognizeSelector: _cmd];
abort();
} @catch (id e) {
[self release];
@throw [OFNotImplementedException exceptionWithClass: c
@throw e;
selector: _cmd];
}
}
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
|
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 {
Class c = [self class];
[self doesNotRecognizeSelector: _cmd];
abort();
} @catch (id e) {
[self release];
@throw [OFNotImplementedException exceptionWithClass: c
@throw e;
selector: _cmd];
}
}
- initWithArray: (OFArray*)array
{
@try {
Class c = [self class];
[self doesNotRecognizeSelector: _cmd];
abort();
} @catch (id e) {
[self release];
@throw [OFNotImplementedException exceptionWithClass: c
@throw e;
selector: _cmd];
}
}
- initWithObjects: (id const*)objects
count: (size_t)count
{
@try {
Class c = [self class];
[self doesNotRecognizeSelector: _cmd];
abort();
} @catch (id e) {
[self release];
@throw [OFNotImplementedException exceptionWithClass: c
@throw e;
selector: _cmd];
}
}
- initWithSerialization: (OFXMLElement*)element
{
@try {
Class c = [self class];
[self doesNotRecognizeSelector: _cmd];
abort();
} @catch (id e) {
[self release];
@throw [OFNotImplementedException exceptionWithClass: c
@throw e;
selector: _cmd];
}
}
- (size_t)count
{
@throw [OFNotImplementedException exceptionWithClass: [self class]
selector: _cmd];
[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
|
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
{
@throw [OFNotImplementedException exceptionWithClass: [self class]
selector: _cmd];
[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
|
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 "OFNotImplementedException.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
|
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
|
-
-
+
+
-
-
+
+
|
}
[super dealloc];
}
- retain
{
@throw [OFNotImplementedException exceptionWithClass: [self class]
selector: _cmd];
[self doesNotRecognizeSelector: _cmd];
abort();
}
- autorelease
{
@throw [OFNotImplementedException exceptionWithClass: [self class]
selector: _cmd];
[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
|
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 "OFNotImplementedException.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
|
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
{
@throw [OFNotImplementedException exceptionWithClass: self
selector: _cmd];
[self doesNotRecognizeSelector: _cmd];
abort();
}
- init
{
@throw [OFNotImplementedException exceptionWithClass: [self class]
selector: _cmd];
@try {
[self doesNotRecognizeSelector: _cmd];
abort();
} @catch (id e) {
[self release];
@throw e;
}
}
- (void*)allocMemoryWithSize: (size_t)size
{
@throw [OFNotImplementedException exceptionWithClass: [self class]
selector: _cmd];
[self doesNotRecognizeSelector: _cmd];
abort();
}
- (void*)allocMemoryWithSize: (size_t)size
count: (size_t)count
{
@throw [OFNotImplementedException exceptionWithClass: [self class]
selector: _cmd];
[self doesNotRecognizeSelector: _cmd];
abort();
}
- (void*)resizeMemory: (void*)ptr
size: (size_t)size
{
@throw [OFNotImplementedException exceptionWithClass: [self class]
selector: _cmd];
[self doesNotRecognizeSelector: _cmd];
abort();
}
- (void*)resizeMemory: (void*)ptr
size: (size_t)size
count: (size_t)count
{
@throw [OFNotImplementedException exceptionWithClass: [self class]
selector: _cmd];
[self doesNotRecognizeSelector: _cmd];
abort();
}
- (void)freeMemory: (void*)ptr
{
@throw [OFNotImplementedException exceptionWithClass: [self class]
selector: _cmd];
[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
|
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
{
@throw [OFNotImplementedException exceptionWithClass: [self class]
selector: _cmd];
[super dealloc]; /* Get rid of a stupid warning */
[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
|
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 "OFNotImplementedException.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
|
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
{
@throw [OFNotImplementedException exceptionWithClass: self
selector: _cmd];
[self doesNotRecognizeSelector: _cmd];
abort();
}
- (void*)allocMemoryWithSize: (size_t)size
{
@throw [OFNotImplementedException exceptionWithClass: [self class]
selector: _cmd];
[self doesNotRecognizeSelector: _cmd];
abort();
}
- (void*)allocMemoryWithSize: (size_t)itemSize
count: (size_t)count
{
@throw [OFNotImplementedException exceptionWithClass: [self class]
selector: _cmd];
[self doesNotRecognizeSelector: _cmd];
abort();
}
- (void*)resizeMemory: (void*)ptr
size: (size_t)size
{
@throw [OFNotImplementedException exceptionWithClass: [self class]
selector: _cmd];
[self doesNotRecognizeSelector: _cmd];
abort();
}
- (void*)resizeMemory: (void*)ptr
toNItems: (size_t)nitems
withSize: (size_t)size
{
@throw [OFNotImplementedException exceptionWithClass: [self class]
selector: _cmd];
[self doesNotRecognizeSelector: _cmd];
abort();
}
- (void)freeMemory: (void*)ptr
{
@throw [OFNotImplementedException exceptionWithClass: [self class]
selector: _cmd];
[self doesNotRecognizeSelector: _cmd];
abort();
}
- retain
{
return self;
}
|
︙ | | |
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
|
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
|
-
-
-
+
+
+
+
+
|
- (void)release
{
}
- (void)dealloc
{
@throw [OFNotImplementedException exceptionWithClass: [self class]
selector: _cmd];
[super dealloc]; /* Get rid of a stupid warning */
[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
|
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
{
@throw [OFNotImplementedException exceptionWithClass: self
selector: _cmd];
[self doesNotRecognizeSelector: _cmd];
abort();
}
- (void*)allocMemoryWithSize: (size_t)size
{
@throw [OFNotImplementedException exceptionWithClass: [self class]
selector: _cmd];
[self doesNotRecognizeSelector: _cmd];
abort();
}
- (void*)allocMemoryWithSize: (size_t)size
count: (size_t)count
{
@throw [OFNotImplementedException exceptionWithClass: [self class]
selector: _cmd];
[self doesNotRecognizeSelector: _cmd];
abort();
}
- (void*)resizeMemory: (void*)ptr
size: (size_t)size
{
@throw [OFNotImplementedException exceptionWithClass: [self class]
selector: _cmd];
[self doesNotRecognizeSelector: _cmd];
abort();
}
- (void*)resizeMemory: (void*)ptr
size: (size_t)size
count: (size_t)count
{
@throw [OFNotImplementedException exceptionWithClass: [self class]
selector: _cmd];
[self doesNotRecognizeSelector: _cmd];
abort();
}
- (void)freeMemory: (void*)ptr
{
@throw [OFNotImplementedException exceptionWithClass: [self class]
selector: _cmd];
[self doesNotRecognizeSelector: _cmd];
abort();
}
- retain
{
return self;
}
|
︙ | | |
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
|
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
|
-
-
-
+
+
+
+
+
|
- (void)release
{
}
- (void)dealloc
{
@throw [OFNotImplementedException exceptionWithClass: [self class]
selector: _cmd];
[super dealloc]; /* Get rid of a stupid warning */
[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
|
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 "OFNotImplementedException.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
|
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
|
-
-
-
+
+
+
+
+
|
- (void)release
{
}
- (void)dealloc
{
@throw [OFNotImplementedException exceptionWithClass: [self class]
selector: _cmd];
[super dealloc]; /* Get rid of a stupid warning */
[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
|
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 {
Class c = [self class];
[self doesNotRecognizeSelector: _cmd];
abort();
} @catch (id e) {
[self release];
@throw [OFNotImplementedException exceptionWithClass: c
@throw e;
selector: _cmd];
}
}
return [super init];
}
- (size_t)countForObject: (id)object
{
@throw [OFNotImplementedException exceptionWithClass: [self class]
selector: _cmd];
[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
|
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 "OFNotImplementedException.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
|
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 [OFNotImplementedException
exceptionWithClass: [self class]
@throw [OFInvalidArgumentException
exceptionWithClass: [self class]];
selector: _cmd];
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
|
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 "OFNotImplementedException.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
|
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
|
-
-
-
+
+
+
+
+
|
- (void)release
{
}
- (void)dealloc
{
@throw [OFNotImplementedException exceptionWithClass: [self class]
selector: _cmd];
[super dealloc]; /* Get rid of a stupid warning */
[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
|
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 {
Class c = [self class];
[self doesNotRecognizeSelector: _cmd];
abort();
} @catch (id e) {
[self release];
@throw [OFNotImplementedException exceptionWithClass: c
@throw e;
selector: _cmd];
}
}
return [super init];
}
- initWithDictionary: (OFDictionary*)dictionary
{
@try {
Class c = [self class];
[self doesNotRecognizeSelector: _cmd];
abort();
} @catch (id e) {
[self release];
@throw [OFNotImplementedException exceptionWithClass: c
@throw e;
selector: _cmd];
}
}
- 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
|
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 {
Class c = [self class];
[self doesNotRecognizeSelector: _cmd];
abort();
} @catch (id e) {
[self release];
@throw [OFNotImplementedException exceptionWithClass: c
@throw e;
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
{
@try {
Class c = [self class];
[self doesNotRecognizeSelector: _cmd];
abort();
} @catch (id e) {
[self release];
@throw [OFNotImplementedException exceptionWithClass: c
@throw e;
selector: _cmd];
}
}
- initWithSerialization: (OFXMLElement*)element
{
@try {
Class c = [self class];
[self doesNotRecognizeSelector: _cmd];
abort();
} @catch (id e) {
[self release];
@throw [OFNotImplementedException exceptionWithClass: c
@throw e;
selector: _cmd];
}
}
- (id)objectForKey: (id)key
{
@throw [OFNotImplementedException exceptionWithClass: [self class]
selector: _cmd];
[self doesNotRecognizeSelector: _cmd];
abort();
}
- (id)objectForKeyedSubscript: (id)key
{
return [self objectForKey: key];
}
- (size_t)count
{
@throw [OFNotImplementedException exceptionWithClass: [self class]
selector: _cmd];
[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
|
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
{
@throw [OFNotImplementedException exceptionWithClass: [self class]
selector: _cmd];
[self doesNotRecognizeSelector: _cmd];
abort();
}
- (OFEnumerator*)keyEnumerator
{
@throw [OFNotImplementedException exceptionWithClass: [self class]
selector: _cmd];
[self doesNotRecognizeSelector: _cmd];
abort();
}
- (int)countByEnumeratingWithState: (of_fast_enumeration_state_t*)state
objects: (id*)objects
count: (int)count_
{
@throw [OFNotImplementedException exceptionWithClass: [self class]
selector: _cmd];
[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
|
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 "OFNotImplementedException.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
|
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"
#import "OFEnumerator.h"
#include <stdlib.h>
#import "OFNotImplementedException.h"
#import "OFEnumerator.h"
@implementation OFEnumerator
- init
{
if (object_getClass(self) == [OFEnumerator class]) {
@try {
Class c = [self class];
[self doesNotRecognizeSelector: _cmd];
abort();
} @catch (id e) {
[self release];
@throw [OFNotImplementedException exceptionWithClass: c
@throw e;
selector: _cmd];
}
}
return [super init];
}
- (id)nextObject
{
@throw [OFNotImplementedException exceptionWithClass: [self class]
selector: _cmd];
[self doesNotRecognizeSelector: _cmd];
abort();
}
- (void)reset
{
@throw [OFNotImplementedException exceptionWithClass: [self class]
selector: _cmd];
[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
|
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 "OFNotImplementedException.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
|
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 {
Class c = [self class];
[self doesNotRecognizeSelector: _cmd];
abort();
} @catch (id e) {
[self release];
@throw [OFNotImplementedException exceptionWithClass: c
@throw e;
selector: _cmd];
}
}
- 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
|
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 {
Class c = [self class];
[self doesNotRecognizeSelector: _cmd];
abort();
} @catch (id e) {
[self release];
@throw [OFNotImplementedException exceptionWithClass: c
@throw e;
selector: _cmd];
}
}
- autorelease
{
return self;
}
|
︙ | | |
787
788
789
790
791
792
793
794
795
796
797
798
799
800
801
802
803
804
805
|
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
{
@throw [OFNotImplementedException exceptionWithClass: [self class]
selector: _cmd];
[super dealloc]; /* Get rid of stupid warning */
[self doesNotRecognizeSelector: _cmd];
abort();
/* Get rid of stupid warning */
[super dealloc];
}
- (void)lowlevelSeekToOffset: (off_t)offset
whence: (int)whence
{
@throw [OFNotImplementedException exceptionWithClass: [self class]
selector: _cmd];
[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
|
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 "OFNotImplementedException.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
|
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"
#include <stdlib.h>
#import "OFNotImplementedException.h"
#import "OFHash.h"
@implementation OFHash
+ (instancetype)hash
{
return [[[self alloc] init] autorelease];
}
+ (size_t)digestSize
{
@throw [OFNotImplementedException exceptionWithClass: self
selector: _cmd];
[self doesNotRecognizeSelector: _cmd];
abort();
}
+ (size_t)blockSize
{
@throw [OFNotImplementedException exceptionWithClass: self
selector: _cmd];
[self doesNotRecognizeSelector: _cmd];
abort();
}
- (void)updateWithBuffer: (const void*)buffer
length: (size_t)length
{
@throw [OFNotImplementedException exceptionWithClass: [self class]
selector: _cmd];
[self doesNotRecognizeSelector: _cmd];
abort();
}
- (uint8_t*)digest
{
@throw [OFNotImplementedException exceptionWithClass: [self class]
selector: _cmd];
[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
|
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 "OFNotImplementedException.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
|
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 {
Class c = [self class];
[self doesNotRecognizeSelector: _cmd];
abort();
} @catch (id e) {
[self release];
@throw [OFNotImplementedException exceptionWithClass: c
@throw e;
selector: _cmd];
}
}
- 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
|
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 {
Class c = [self class];
[self doesNotRecognizeSelector: _cmd];
abort();
} @catch (id e) {
[self release];
@throw [OFNotImplementedException exceptionWithClass: c
@throw e;
selector: _cmd];
}
}
- 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
|
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
|
-
-
+
+
|
[mapTable release];
[super dealloc];
}
- (void*)nextValue
{
@throw [OFNotImplementedException exceptionWithClass: [self class]
selector: _cmd];
[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
|
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 "OFNotImplementedException.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
|
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
|
-
-
-
+
+
+
+
+
|
- (void)release
{
}
- (void)dealloc
{
@throw [OFNotImplementedException exceptionWithClass: [self class]
selector: _cmd];
[super dealloc]; /* Get rid of a stupid warning */
[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
|
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 {
Class c = [self class];
[self doesNotRecognizeSelector: _cmd];
abort();
} @catch (id e) {
[self release];
@throw [OFNotImplementedException exceptionWithClass: c
@throw e;
selector: _cmd];
}
}
return [super init];
}
- copy
{
|
︙ | | |
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
|
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
{
@throw [OFNotImplementedException exceptionWithClass: [self class]
selector: _cmd];
[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
|
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
{
@throw [OFNotImplementedException exceptionWithClass: [self class]
selector: _cmd];
[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
|
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
|
-
-
+
+
|
return;
}
}
}
- (void)removeObjectAtIndex: (size_t)index
{
@throw [OFNotImplementedException exceptionWithClass: [self class]
selector: _cmd];
[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
|
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"
#include <stdlib.h>
#import "OFNotImplementedException.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
|
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
|
-
-
-
+
+
+
+
+
|
- (void)release
{
}
- (void)dealloc
{
@throw [OFNotImplementedException exceptionWithClass: [self class]
selector: _cmd];
[super dealloc]; /* Get rid of a stupid warning */
[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
|
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 {
Class c = [self class];
[self doesNotRecognizeSelector: _cmd];
abort();
} @catch (id e) {
[self release];
@throw [OFNotImplementedException exceptionWithClass: c
@throw e;
selector: _cmd];
}
}
return [super init];
}
- (void)setObject: (id)object
forKey: (id)key
{
@throw [OFNotImplementedException exceptionWithClass: [self class]
selector: _cmd];
[self doesNotRecognizeSelector: _cmd];
abort();
}
- (void)setObject: (id)object
forKeyedSubscript: (id)key
{
[self setObject: object
forKey: key];
}
- (void)removeObjectForKey: (id)key
{
@throw [OFNotImplementedException exceptionWithClass: [self class]
selector: _cmd];
[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
|
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 "OFNotImplementedException.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
|
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
|
-
-
-
+
+
+
+
+
|
- (void)release
{
}
- (void)dealloc
{
@throw [OFNotImplementedException exceptionWithClass: [self class]
selector: _cmd];
[super dealloc]; /* Get rid of a stupid warning */
[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
|
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 {
Class c = [self class];
[self doesNotRecognizeSelector: _cmd];
abort();
} @catch (id e) {
[self release];
@throw [OFNotImplementedException exceptionWithClass: c
@throw e;
selector: _cmd];
}
}
return [super init];
}
- (void)addObject: (id)object
{
@throw [OFNotImplementedException exceptionWithClass: [self class]
selector: _cmd];
[self doesNotRecognizeSelector: _cmd];
abort();
}
- (void)removeObject: (id)object
{
@throw [OFNotImplementedException exceptionWithClass: [self class]
selector: _cmd];
[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
|
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 "OFNotImplementedException.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
|
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
|
-
-
-
+
+
+
+
+
|
- (void)release
{
}
- (void)dealloc
{
@throw [OFNotImplementedException exceptionWithClass: [self class]
selector: _cmd];
[super dealloc]; /* Get rid of a stupid warning */
[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
|
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
{
@throw [OFNotImplementedException exceptionWithClass: [self class]
selector: _cmd];
[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
|
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
{
@throw [OFNotImplementedException exceptionWithClass: [self class]
selector: _cmd];
[self doesNotRecognizeSelector: _cmd];
abort();
}
- (void)deleteCharactersInRange: (of_range_t)range
{
@throw [OFNotImplementedException exceptionWithClass: [self class]
selector: _cmd];
[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
|
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 "OFNotImplementedException.h"
#import "autorelease.h"
static OFNull *null = nil;
@implementation OFNull
+ (void)initialize
|
︙ | | |
104
105
106
107
108
109
110
111
112
113
114
115
|
105
106
107
108
109
110
111
112
113
114
115
116
117
118
|
-
-
-
+
+
+
+
+
|
- (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 */
[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
|
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 "OFNotImplementedException.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
|
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 [OFNotImplementedException \
@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
|
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
{
@throw [OFNotImplementedException exceptionWithClass: [self class]
selector: _cmd];
@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
|
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 "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)])
if (![self conformsToProtocol: @protocol(OFSerialization)]) {
@throw [OFNotImplementedException
exceptionWithClass: [self class]
[self doesNotRecognizeSelector: _cmd];
selector: @selector(stringBySerializing)];
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
|
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
|
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)
{
fprintf(stderr, "Runtime error: Selector %s is not implemented in "
"class %s!\n", sel_getName(sel),
[obj doesNotRecognizeSelector: sel];
class_getName(object_getClass(obj)));
/*
* 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
|
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
|
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)
if OF_UNLIKELY (zone != NULL) {
@throw [OFNotImplementedException
exceptionWithClass: [self class]
selector: _cmd];
[self doesNotRecognizeSelector: _cmd];
abort();
}
return [(id)self copy];
}
- mutableCopyWithZone: (void*)zone
{
if OF_UNLIKELY (zone != NULL)
if OF_UNLIKELY (zone != NULL) {
@throw [OFNotImplementedException
exceptionWithClass: [self class]
selector: _cmd];
[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
{
@throw [OFNotImplementedException exceptionWithClass: self
selector: _cmd];
[self doesNotRecognizeSelector: _cmd];
abort();
}
+ (void*)allocMemoryWithSize: (size_t)size
count: (size_t)count
{
@throw [OFNotImplementedException exceptionWithClass: self
selector: _cmd];
[self doesNotRecognizeSelector: _cmd];
abort();
}
+ (void*)resizeMemory: (void*)pointer
size: (size_t)size
{
@throw [OFNotImplementedException exceptionWithClass: self
selector: _cmd];
[self doesNotRecognizeSelector: _cmd];
abort();
}
+ (void*)resizeMemory: (void*)pointer
size: (size_t)size
count: (size_t)count
{
@throw [OFNotImplementedException exceptionWithClass: self
selector: _cmd];
[self doesNotRecognizeSelector: _cmd];
abort();
}
+ (void)freeMemory: (void*)pointer
{
@throw [OFNotImplementedException exceptionWithClass: self
selector: _cmd];
[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
|
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
{
@throw [OFNotImplementedException exceptionWithClass: self
selector: _cmd];
[self doesNotRecognizeSelector: _cmd];
abort();
}
+ copyWithZone: (void*)zone
{
@throw [OFNotImplementedException exceptionWithClass: self
selector: _cmd];
[self doesNotRecognizeSelector: _cmd];
abort();
}
+ mutableCopyWithZone: (void*)zone
{
@throw [OFNotImplementedException exceptionWithClass: self
selector: _cmd];
[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
|
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 "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)
|
︙ | | |
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
|
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 {
Class c = [self class];
[self doesNotRecognizeSelector: _cmd];
abort();
} @catch (id e) {
[self release];
@throw [OFNotImplementedException exceptionWithClass: c
@throw e;
selector: _cmd];
}
}
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
|
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 "OFNotImplementedException.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
|
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
@throw [OFNotImplementedException exceptionWithClass: [self class]
selector: _cmd];
[self doesNotRecognizeSelector: _cmd];
abort();
#endif
}
- (int)fileDescriptorForWriting
{
#ifndef _WIN32
return writePipe[1];
#else
@throw [OFNotImplementedException exceptionWithClass: [self class]
selector: _cmd];
[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
|
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"
#import "OFSeekableStream.h"
#include <stdlib.h>
#import "OFNotImplementedException.h"
#import "OFSeekableStream.h"
@implementation OFSeekableStream
- (void)lowlevelSeekToOffset: (off_t)offset
whence: (int)whence
{
@throw [OFNotImplementedException exceptionWithClass: [self class]
selector: _cmd];
[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
|
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 "OFNotImplementedException.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
|
92
93
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 */
[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
|
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 {
Class c = [self class];
[self doesNotRecognizeSelector: _cmd];
abort();
} @catch (id e) {
[self release];
@throw [OFNotImplementedException exceptionWithClass: c
@throw e;
selector: _cmd];
}
}
return [super init];
}
- initWithSet: (OFSet*)set
{
@try {
Class c = [self class];
[self doesNotRecognizeSelector: _cmd];
abort();
} @catch (id e) {
[self release];
@throw [OFNotImplementedException exceptionWithClass: c
@throw e;
selector: _cmd];
}
}
- initWithArray: (OFArray*)array
{
@try {
Class c = [self class];
[self doesNotRecognizeSelector: _cmd];
abort();
} @catch (id e) {
[self release];
@throw e;
}
}
@throw [OFNotImplementedException exceptionWithClass: c
selector: _cmd];
- 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;
}
- 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
{
@try {
Class c = [self class];
[self doesNotRecognizeSelector: _cmd];
abort();
} @catch (id e) {
[self release];
@throw [OFNotImplementedException exceptionWithClass: c
@throw e;
selector: _cmd];
}
}
- initWithSerialization: (OFXMLElement*)element
{
@try {
Class c = [self class];
[self doesNotRecognizeSelector: _cmd];
abort();
} @catch (id e) {
[self release];
@throw [OFNotImplementedException exceptionWithClass: c
@throw e;
selector: _cmd];
}
}
- (size_t)count
{
@throw [OFNotImplementedException exceptionWithClass: [self class]
selector: _cmd];
[self doesNotRecognizeSelector: _cmd];
abort();
}
- (BOOL)containsObject: (id)object
{
@throw [OFNotImplementedException exceptionWithClass: [self class]
selector: _cmd];
[self doesNotRecognizeSelector: _cmd];
abort();
}
- (OFEnumerator*)objectEnumerator
{
@throw [OFNotImplementedException exceptionWithClass: [self class]
selector: _cmd];
[self doesNotRecognizeSelector: _cmd];
abort();
}
- (int)countByEnumeratingWithState: (of_fast_enumeration_state_t*)state
objects: (id*)objects
count: (int)count
{
@throw [OFNotImplementedException exceptionWithClass: [self class]
selector: _cmd];
[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
|
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"
#include <stdlib.h>
#import "OFNotImplementedException.h"
#import "OFSortedList.h"
@implementation OFSortedList
- (of_list_object_t*)appendObject: (id)object
{
@throw [OFNotImplementedException exceptionWithClass: [self class]
selector: _cmd];
[self doesNotRecognizeSelector: _cmd];
abort();
}
- (of_list_object_t*)prependObject: (id)object
{
@throw [OFNotImplementedException exceptionWithClass: [self class]
selector: _cmd];
[self doesNotRecognizeSelector: _cmd];
abort();
}
- (of_list_object_t*)insertObject: (id)object
beforeListObject: (of_list_object_t*)listObject
{
@throw [OFNotImplementedException exceptionWithClass: [self class]
selector: _cmd];
[self doesNotRecognizeSelector: _cmd];
abort();
}
- (of_list_object_t*)insertObject: (id)object
afterListObject: (of_list_object_t*)listObject
{
@throw [OFNotImplementedException exceptionWithClass: [self class]
selector: _cmd];
[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
|
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 "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]) {
@try {
Class c = [self class];
[self doesNotRecognizeSelector: _cmd];
abort();
} @catch (id e) {
[self release];
@throw [OFNotImplementedException exceptionWithClass: c
@throw e;
selector: _cmd];
}
}
self = [super init];
cache = NULL;
writeBuffer = NULL;
blocking = YES;
return self;
}
- (BOOL)lowlevelIsAtEndOfStream
{
@throw [OFNotImplementedException exceptionWithClass: [self class]
selector: _cmd];
[self doesNotRecognizeSelector: _cmd];
abort();
}
- (size_t)lowlevelReadIntoBuffer: (void*)buffer
length: (size_t)length
{
@throw [OFNotImplementedException exceptionWithClass: [self class]
selector: _cmd];
[self doesNotRecognizeSelector: _cmd];
abort();
}
- (void)lowlevelWriteBuffer: (const void*)buffer
length: (size_t)length
{
@throw [OFNotImplementedException exceptionWithClass: [self class]
selector: _cmd];
[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
|
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
@throw [OFNotImplementedException exceptionWithClass: [self class]
selector: _cmd];
[self doesNotRecognizeSelector: _cmd];
abort();
#endif
}
- (int)fileDescriptorForReading
{
@throw [OFNotImplementedException exceptionWithClass: [self class]
selector: _cmd];
[self doesNotRecognizeSelector: _cmd];
abort();
}
- (int)fileDescriptorForWriting
{
@throw [OFNotImplementedException exceptionWithClass: [self class]
selector: _cmd];
[self doesNotRecognizeSelector: _cmd];
abort();
}
- (void)cancelAsyncRequests
{
[OFRunLoop OF_cancelAsyncRequestsForStream: self];
}
- (void)close
{
@throw [OFNotImplementedException exceptionWithClass: [self class]
selector: _cmd];
[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
|
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
|
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 "OFNotImplementedException.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
|
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
{
@throw [OFNotImplementedException exceptionWithClass: [self class]
selector: _cmd];
[self doesNotRecognizeSelector: _cmd];
abort();
}
- (void)OF_addFileDescriptorForWriting: (int)fd
{
@throw [OFNotImplementedException exceptionWithClass: [self class]
selector: _cmd];
[self doesNotRecognizeSelector: _cmd];
abort();
}
- (void)OF_removeFileDescriptorForReading: (int)fd
{
@throw [OFNotImplementedException exceptionWithClass: [self class]
selector: _cmd];
[self doesNotRecognizeSelector: _cmd];
abort();
}
- (void)OF_removeFileDescriptorForWriting: (int)fd
{
@throw [OFNotImplementedException exceptionWithClass: [self class]
selector: _cmd];
[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
|
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
{
@throw [OFNotImplementedException exceptionWithClass: [self class]
selector: _cmd];
[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
|
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
|
-
-
-
+
+
+
+
+
|
- (void)release
{
}
- (void)dealloc
{
@throw [OFNotImplementedException exceptionWithClass: [self class]
selector: _cmd];
[super dealloc]; /* Get rid of a stupid warning */
[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
|
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 {
Class c = [self class];
[self doesNotRecognizeSelector: _cmd];
abort();
} @catch (id e) {
[self release];
@throw [OFNotImplementedException exceptionWithClass: c
@throw e;
selector: _cmd];
}
}
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
|
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 {
Class c = [self class];
[self doesNotRecognizeSelector: _cmd];
abort();
} @catch (id e) {
[self release];
@throw [OFNotImplementedException exceptionWithClass: c
@throw e;
selector: _cmd];
}
}
- initWithString: (OFString*)string
{
@try {
Class c = [self class];
[self doesNotRecognizeSelector: _cmd];
abort();
} @catch (id e) {
[self release];
@throw [OFNotImplementedException exceptionWithClass: c
@throw e;
selector: _cmd];
}
}
- 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
|
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 {
Class c = [self class];
[self doesNotRecognizeSelector: _cmd];
abort();
} @catch (id e) {
[self release];
@throw [OFNotImplementedException exceptionWithClass: c
@throw e;
selector: _cmd];
}
}
- 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
|
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 {
Class c = [self class];
[self doesNotRecognizeSelector: _cmd];
abort();
} @catch (id e) {
[self release];
@throw [OFNotImplementedException exceptionWithClass: c
@throw e;
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
{
@try {
Class c = [self class];
[self doesNotRecognizeSelector: _cmd];
abort();
} @catch (id e) {
[self release];
@throw [OFNotImplementedException exceptionWithClass: c
@throw e;
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
{
@try {
Class c = [self class];
[self doesNotRecognizeSelector: _cmd];
abort();
} @catch (id e) {
[self release];
@throw [OFNotImplementedException exceptionWithClass: c
@throw e;
selector: _cmd];
}
}
- 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
|
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
{
@throw [OFNotImplementedException exceptionWithClass: [self class]
selector: _cmd];
[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
|
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
{
@throw [OFNotImplementedException exceptionWithClass: [self class]
selector: _cmd];
[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
|
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 "OFNotImplementedException.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
|
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 "OFNotImplementedException.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
|
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 "OFNotImplementedException.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
|
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 {
Class c = [self class];
[self doesNotRecognizeSelector: _cmd];
abort();
} @catch (id e) {
[self release];
@throw [OFNotImplementedException exceptionWithClass: c
@throw e;
selector: _cmd];
}
}
- 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
|
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 "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 [OFInvalidArgumentException
@throw [OFNotImplementedException exceptionWithClass: Nil];
exceptionWithClass: [self class]];
if (![class conformsToProtocol: @protocol(OFSerialization)])
@throw [OFNotImplementedException
exceptionWithClass: class
@throw [OFInvalidArgumentException
exceptionWithClass: [self class]];
selector: @selector(initWithSerialization:)];
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
|
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 "OFNotImplementedException.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
|
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 {
Class c = [self class];
[self doesNotRecognizeSelector: _cmd];
abort();
} @catch (id e) {
[self release];
@throw [OFNotImplementedException exceptionWithClass: c
@throw e;
selector: _cmd];
}
}
- 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
|
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"
#import "OFNotImplementedException.h"
@implementation OFXMLNode
- initWithSerialization: (OFXMLElement*)element
{
@try {
Class c = [self class];
[self doesNotRecognizeSelector: _cmd];
abort();
} @catch (id e) {
[self release];
@throw [OFNotImplementedException exceptionWithClass: c
@throw e;
selector: _cmd];
}
}
- (OFString*)stringValue
{
@throw [OFNotImplementedException exceptionWithClass: [self class]
selector: _cmd];
[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
|
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
{
@throw [OFNotImplementedException exceptionWithClass: [self class]
selector: _cmd];
[self doesNotRecognizeSelector: _cmd];
abort();
}
- (OFString*)description
{
return [self XMLStringWithIndentation: 2];
}
- (OFXMLElement*)XMLElementBySerializing
{
@throw [OFNotImplementedException exceptionWithClass: [self class]
selector: _cmd];
[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
|
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 "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_
{
@try {
Class c = [self class];
[self doesNotRecognizeSelector: _cmd];
abort();
} @catch (id e) {
[self release];
@throw [OFNotImplementedException exceptionWithClass: c
@throw e;
selector: _cmd];
}
}
- 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
|
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"
#import "OFNotImplementedException.h"
@implementation OFAllocFailedException
+ alloc
{
@throw [OFNotImplementedException exceptionWithClass: self
selector: _cmd];
[self doesNotRecognizeSelector: _cmd];
abort();
}
- init
{
@throw [OFNotImplementedException exceptionWithClass: [self class]
selector: _cmd];
@try {
[self doesNotRecognizeSelector: _cmd];
abort();
} @catch (id e) {
[self release];
@throw e;
}
}
- (void*)allocMemoryWithSize: (size_t)size
{
@throw [OFNotImplementedException exceptionWithClass: [self class]
selector: _cmd];
[self doesNotRecognizeSelector: _cmd];
abort();
}
- (void*)allocMemoryForNItems: (size_t)nitems
withSize: (size_t)size
{
@throw [OFNotImplementedException exceptionWithClass: [self class]
selector: _cmd];
[self doesNotRecognizeSelector: _cmd];
abort();
}
- (void*)resizeMemory: (void*)ptr
toSize: (size_t)size
{
@throw [OFNotImplementedException exceptionWithClass: [self class]
selector: _cmd];
[self doesNotRecognizeSelector: _cmd];
abort();
}
- (void*)resizeMemory: (void*)ptr
toNItems: (size_t)nitems
withSize: (size_t)size
{
@throw [OFNotImplementedException exceptionWithClass: [self class]
selector: _cmd];
[self doesNotRecognizeSelector: _cmd];
abort();
}
- (void)freeMemory: (void*)ptr
{
@throw [OFNotImplementedException exceptionWithClass: [self class]
selector: _cmd];
[self doesNotRecognizeSelector: _cmd];
abort();
}
- retain
{
return self;
}
|
︙ | | |
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
|
90
91
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 */
[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
|
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 "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_
{
@try {
Class c = [self class];
[self doesNotRecognizeSelector: _cmd];
abort();
} @catch (id e) {
[self release];
@throw [OFNotImplementedException exceptionWithClass: c
@throw e;
selector: _cmd];
}
}
- 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
|
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 "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_
{
@try {
Class c = [self class];
[self doesNotRecognizeSelector: _cmd];
abort();
} @catch (id e) {
[self release];
@throw [OFNotImplementedException exceptionWithClass: c
@throw e;
selector: _cmd];
}
}
- 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
|
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 "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_
{
@try {
Class c = [self class];
[self doesNotRecognizeSelector: _cmd];
abort();
} @catch (id e) {
[self release];
@throw [OFNotImplementedException exceptionWithClass: c
@throw e;
selector: _cmd];
}
}
- 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
|
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 "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_
{
@try {
Class c = [self class];
[self doesNotRecognizeSelector: _cmd];
abort();
} @catch (id e) {
[self release];
@throw [OFNotImplementedException exceptionWithClass: c
@throw e;
selector: _cmd];
}
}
- 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
|
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 "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_
{
@try {
Class c = [self class];
[self doesNotRecognizeSelector: _cmd];
abort();
} @catch (id e) {
[self release];
@throw [OFNotImplementedException exceptionWithClass: c
@throw e;
selector: _cmd];
}
}
- 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
|
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"
#import "OFNotImplementedException.h"
@implementation OFConditionBroadcastFailedException
+ (instancetype)exceptionWithClass: (Class)class_
condition: (OFCondition*)condition
{
return [[[self alloc] initWithClass: class_
condition: condition] autorelease];
}
- initWithClass: (Class)class_
{
@try {
Class c = [self class];
[self doesNotRecognizeSelector: _cmd];
abort();
} @catch (id e) {
[self release];
@throw [OFNotImplementedException exceptionWithClass: c
@throw e;
selector: _cmd];
}
}
- 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
|
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"
#import "OFNotImplementedException.h"
@implementation OFConditionSignalFailedException
+ (instancetype)exceptionWithClass: (Class)class_
condition: (OFCondition*)condition
{
return [[[self alloc] initWithClass: class_
condition: condition] autorelease];
}
- initWithClass: (Class)class_
{
@try {
Class c = [self class];
[self doesNotRecognizeSelector: _cmd];
abort();
} @catch (id e) {
[self release];
@throw [OFNotImplementedException exceptionWithClass: c
@throw e;
selector: _cmd];
}
}
- 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
|
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"
#import "OFNotImplementedException.h"
@implementation OFConditionStillWaitingException
+ (instancetype)exceptionWithClass: (Class)class_
condition: (OFCondition*)condition
{
return [[[self alloc] initWithClass: class_
condition: condition] autorelease];
}
- initWithClass: (Class)class_
{
@try {
Class c = [self class];
[self doesNotRecognizeSelector: _cmd];
abort();
} @catch (id e) {
[self release];
@throw [OFNotImplementedException exceptionWithClass: c
@throw e;
selector: _cmd];
}
}
- 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
|
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"
#import "OFNotImplementedException.h"
@implementation OFConditionWaitFailedException
+ (instancetype)exceptionWithClass: (Class)class_
condition: (OFCondition*)condition
{
return [[[self alloc] initWithClass: class_
condition: condition] autorelease];
}
- initWithClass: (Class)class_
{
@try {
Class c = [self class];
[self doesNotRecognizeSelector: _cmd];
abort();
} @catch (id e) {
[self release];
@throw [OFNotImplementedException exceptionWithClass: c
@throw e;
selector: _cmd];
}
}
- 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
|
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 "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_
{
@try {
Class c = [self class];
[self doesNotRecognizeSelector: _cmd];
abort();
} @catch (id e) {
[self release];
@throw [OFNotImplementedException exceptionWithClass: c
@throw e;
selector: _cmd];
}
}
- 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
|
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 "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_
{
@try {
Class c = [self class];
[self doesNotRecognizeSelector: _cmd];
abort();
} @catch (id e) {
[self release];
@throw [OFNotImplementedException exceptionWithClass: c
@throw e;
selector: _cmd];
}
}
- 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
|
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 "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_
{
@try {
Class c = [self class];
[self doesNotRecognizeSelector: _cmd];
abort();
} @catch (id e) {
[self release];
@throw [OFNotImplementedException exceptionWithClass: c
@throw e;
selector: _cmd];
}
}
- 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
|
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 "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_
{
@try {
Class c = [self class];
[self doesNotRecognizeSelector: _cmd];
abort();
} @catch (id e) {
[self release];
@throw [OFNotImplementedException exceptionWithClass: c
@throw e;
selector: _cmd];
}
}
- 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
|
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 "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_
{
@try {
Class c = [self class];
[self doesNotRecognizeSelector: _cmd];
abort();
} @catch (id e) {
[self release];
@throw [OFNotImplementedException exceptionWithClass: c
@throw e;
selector: _cmd];
}
}
- 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
|
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 "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_
{
@try {
Class c = [self class];
[self doesNotRecognizeSelector: _cmd];
abort();
} @catch (id e) {
[self release];
@throw [OFNotImplementedException exceptionWithClass: c
@throw e;
selector: _cmd];
}
}
- 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
|
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"
#import "OFNotImplementedException.h"
@implementation OFException
+ (instancetype)exceptionWithClass: (Class)class_
{
return [[[self alloc] initWithClass: class_] autorelease];
}
- init
{
@try {
Class c = [self class];
[self doesNotRecognizeSelector: _cmd];
abort();
} @catch (id e) {
[self release];
@throw [OFNotImplementedException exceptionWithClass: c
@throw e;
selector: _cmd];
}
}
- 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
|
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 "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_
{
@try {
Class c = [self class];
[self doesNotRecognizeSelector: _cmd];
abort();
} @catch (id e) {
[self release];
@throw [OFNotImplementedException exceptionWithClass: c
@throw e;
selector: _cmd];
}
}
- 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
|
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 "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_
{
@try {
Class c = [self class];
[self doesNotRecognizeSelector: _cmd];
abort();
} @catch (id e) {
[self release];
@throw [OFNotImplementedException exceptionWithClass: c
@throw e;
selector: _cmd];
}
}
- 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
|
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 "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_
{
@try {
Class c = [self class];
[self doesNotRecognizeSelector: _cmd];
abort();
} @catch (id e) {
[self release];
@throw [OFNotImplementedException exceptionWithClass: c
@throw e;
selector: _cmd];
}
}
- 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
|
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"
#import "OFNotImplementedException.h"
@implementation OFInvalidJSONException
+ (instancetype)exceptionWithClass: (Class)class_
line: (size_t)line
{
return [[[self alloc] initWithClass: class_
line: line] autorelease];
}
- init
{
@try {
Class c = [self class];
[self doesNotRecognizeSelector: _cmd];
abort();
} @catch (id e) {
[self release];
@throw [OFNotImplementedException exceptionWithClass: c
@throw e;
selector: _cmd];
}
}
- 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
|
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 "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_
{
@try {
Class c = [self class];
[self doesNotRecognizeSelector: _cmd];
abort();
} @catch (id e) {
[self release];
@throw [OFNotImplementedException exceptionWithClass: c
@throw e;
selector: _cmd];
}
}
- 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
|
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 "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_
{
@try {
Class c = [self class];
[self doesNotRecognizeSelector: _cmd];
abort();
} @catch (id e) {
[self release];
@throw [OFNotImplementedException exceptionWithClass: c
@throw e;
selector: _cmd];
}
}
- 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
|
15
16
17
18
19
20
21
22
23
24
25
26
27
28
|
-
-
|
*/
#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_
|
︙ | | |
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
|
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 "OFNotImplementedException.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
|
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"
#import "OFNotImplementedException.h"
@implementation OFMemoryNotPartOfObjectException
+ (instancetype)exceptionWithClass: (Class)class_
pointer: (void*)ptr
{
return [[[self alloc] initWithClass: class_
pointer: ptr] autorelease];
}
- initWithClass: (Class)class_
{
@try {
Class c = [self class];
[self doesNotRecognizeSelector: _cmd];
abort();
} @catch (id e) {
[self release];
@throw [OFNotImplementedException exceptionWithClass: c
@throw e;
selector: _cmd];
}
}
- 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
|
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 "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_
{
@try {
Class c = [self class];
[self doesNotRecognizeSelector: _cmd];
abort();
} @catch (id e) {
[self release];
@throw [OFNotImplementedException exceptionWithClass: c
@throw e;
selector: _cmd];
}
}
- 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
|
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 {
Class c = [self class];
[self doesNotRecognizeSelector: _cmd];
abort();
} @catch (id e) {
[self release];
@throw [OFNotImplementedException exceptionWithClass: c
@throw e;
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];
@"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
|
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 "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_
{
@try {
Class c = [self class];
[self doesNotRecognizeSelector: _cmd];
abort();
} @catch (id e) {
[self release];
@throw [OFNotImplementedException exceptionWithClass: c
@throw e;
selector: _cmd];
}
}
- 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
|
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 "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_
{
@try {
Class c = [self class];
[self doesNotRecognizeSelector: _cmd];
abort();
} @catch (id e) {
[self release];
@throw [OFNotImplementedException exceptionWithClass: c
@throw e;
selector: _cmd];
}
}
- 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
|
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 "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_
{
@try {
Class c = [self class];
[self doesNotRecognizeSelector: _cmd];
abort();
} @catch (id e) {
[self release];
@throw [OFNotImplementedException exceptionWithClass: c
@throw e;
selector: _cmd];
}
}
- 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
|
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 "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_
{
@try {
Class c = [self class];
[self doesNotRecognizeSelector: _cmd];
abort();
} @catch (id e) {
[self release];
@throw [OFNotImplementedException exceptionWithClass: c
@throw e;
selector: _cmd];
}
}
- 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
|
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 "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_
{
@try {
Class c = [self class];
[self doesNotRecognizeSelector: _cmd];
abort();
} @catch (id e) {
[self release];
@throw [OFNotImplementedException exceptionWithClass: c
@throw e;
selector: _cmd];
}
}
- 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
|
15
16
17
18
19
20
21
22
23
24
25
26
27
28
|
-
-
|
*/
#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_
|
︙ | | |
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
|
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 "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_
{
@try {
Class c = [self class];
[self doesNotRecognizeSelector: _cmd];
abort();
} @catch (id e) {
[self release];
@throw [OFNotImplementedException exceptionWithClass: c
@throw e;
selector: _cmd];
}
}
- 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
|
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"
#import "OFNotImplementedException.h"
@implementation OFThreadJoinFailedException
+ (instancetype)exceptionWithClass: (Class)class_
thread: (OFThread*)thread
{
return [[[self alloc] initWithClass: class_
thread: thread] autorelease];
}
- initWithClass: (Class)class_
{
@try {
Class c = [self class];
[self doesNotRecognizeSelector: _cmd];
abort();
} @catch (id e) {
[self release];
@throw [OFNotImplementedException exceptionWithClass: c
@throw e;
selector: _cmd];
}
}
- 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
|
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"
#import "OFNotImplementedException.h"
@implementation OFThreadStartFailedException
+ (instancetype)exceptionWithClass: (Class)class_
thread: (OFThread*)thread
{
return [[[self alloc] initWithClass: class_
thread: thread] autorelease];
}
- initWithClass: (Class)class_
{
@try {
Class c = [self class];
[self doesNotRecognizeSelector: _cmd];
abort();
} @catch (id e) {
[self release];
@throw [OFNotImplementedException exceptionWithClass: c
@throw e;
selector: _cmd];
}
}
- 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
|
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"
#import "OFNotImplementedException.h"
@implementation OFThreadStillRunningException
+ (instancetype)exceptionWithClass: (Class)class_
thread: (OFThread*)thread
{
return [[[self alloc] initWithClass: class_
thread: thread] autorelease];
}
- initWithClass: (Class)class_
{
@try {
Class c = [self class];
[self doesNotRecognizeSelector: _cmd];
abort();
} @catch (id e) {
[self release];
@throw [OFNotImplementedException exceptionWithClass: c
@throw e;
selector: _cmd];
}
}
- 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
|
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 "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_
{
@try {
Class c = [self class];
[self doesNotRecognizeSelector: _cmd];
abort();
} @catch (id e) {
[self release];
@throw [OFNotImplementedException exceptionWithClass: c
@throw e;
selector: _cmd];
}
}
- 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
|
15
16
17
18
19
20
21
22
23
24
25
26
27
28
|
-
-
|
*/
#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_
|
︙ | | |
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
|
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 "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_
{
@try {
Class c = [self class];
[self doesNotRecognizeSelector: _cmd];
abort();
} @catch (id e) {
[self release];
@throw [OFNotImplementedException exceptionWithClass: c
@throw e;
selector: _cmd];
}
}
- 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
|
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 "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_
{
@try {
Class c = [self class];
[self doesNotRecognizeSelector: _cmd];
abort();
} @catch (id e) {
[self release];
@throw [OFNotImplementedException exceptionWithClass: c
@throw e;
selector: _cmd];
}
}
- initWithClass: (Class)class_
version: (OFString*)version_
{
self = [super initWithClass: class_];
|
︙ | | |