Modified src/OFArray.m
from [38f8d86997]
to [2f6f04f166].
︙ | | |
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
|
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
|
-
-
-
-
-
-
-
+
-
-
-
-
-
-
-
-
+
-
-
-
-
-
-
-
-
+
-
-
-
-
-
-
-
-
+
-
|
return ret;
}
- initWithObject: (id)firstObject
arguments: (va_list)arguments
{
@try {
[self doesNotRecognizeSelector: _cmd];
} @catch (id e) {
[self release];
@throw e;
}
OF_INVALID_INIT_METHOD
abort();
}
- initWithArray: (OFArray*)array
{
@try {
[self doesNotRecognizeSelector: _cmd];
} @catch (id e) {
[self release];
@throw e;
}
OF_INVALID_INIT_METHOD
abort();
}
- initWithObjects: (id const*)objects
count: (size_t)count
{
@try {
[self doesNotRecognizeSelector: _cmd];
} @catch (id e) {
[self release];
@throw e;
}
OF_INVALID_INIT_METHOD
abort();
}
- initWithSerialization: (OFXMLElement*)element
{
@try {
[self doesNotRecognizeSelector: _cmd];
} @catch (id e) {
[self release];
@throw e;
}
OF_INVALID_INIT_METHOD
abort();
}
- (size_t)count
{
[self doesNotRecognizeSelector: _cmd];
abort();
}
|
︙ | | |
Modified src/OFBlock.m
from [84017da3fd]
to [c640f522f6].
︙ | | |
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
|
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
|
-
-
-
-
-
-
-
+
-
|
{
[self doesNotRecognizeSelector: _cmd];
abort();
}
- init
{
@try {
[self doesNotRecognizeSelector: _cmd];
} @catch (id e) {
[self release];
@throw e;
}
OF_INVALID_INIT_METHOD
abort();
}
- (void*)allocMemoryWithSize: (size_t)size
{
[self doesNotRecognizeSelector: _cmd];
abort();
}
|
︙ | | |
Modified src/OFDeflateStream.m
from [20af4c93d0]
to [926d013687].
︙ | | |
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
|
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
|
-
-
-
-
-
-
-
+
-
|
+ (instancetype)streamWithStream: (OFStream*)stream
{
return [[[self alloc] initWithStream: stream] autorelease];
}
- init
{
@try {
[self doesNotRecognizeSelector: _cmd];
} @catch (id e) {
[self release];
@throw e;
}
OF_INVALID_INIT_METHOD
abort();
}
- initWithStream: (OFStream*)stream
{
self = [super init];
_stream = [stream retain];
|
︙ | | |
Modified src/OFDictionary.m
from [65bfd85485]
to [03af4f840a].
︙ | | |
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
|
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
|
-
-
-
-
-
-
-
+
-
|
}
return [super init];
}
- initWithDictionary: (OFDictionary*)dictionary
{
@try {
[self doesNotRecognizeSelector: _cmd];
} @catch (id e) {
[self release];
@throw e;
}
OF_INVALID_INIT_METHOD
abort();
}
- initWithObject: (id)object
forKey: (id)key
{
if (key == nil || object == nil)
@throw [OFInvalidArgumentException exception];
|
︙ | | |
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
|
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
|
-
-
-
-
-
-
-
+
-
-
-
-
-
-
-
-
+
-
-
-
-
-
-
-
-
+
-
|
count: count];
}
- initWithObjects: (id const*)objects
forKeys: (id const*)keys
count: (size_t)count
{
@try {
[self doesNotRecognizeSelector: _cmd];
} @catch (id e) {
[self release];
@throw e;
}
OF_INVALID_INIT_METHOD
abort();
}
- initWithKeysAndObjects: (id)firstKey, ...
{
id ret;
va_list arguments;
va_start(arguments, firstKey);
ret = [self initWithKey: firstKey
arguments: arguments];
va_end(arguments);
return ret;
}
- initWithKey: (id)firstKey
arguments: (va_list)arguments
{
@try {
[self doesNotRecognizeSelector: _cmd];
} @catch (id e) {
[self release];
@throw e;
}
OF_INVALID_INIT_METHOD
abort();
}
- initWithSerialization: (OFXMLElement*)element
{
@try {
[self doesNotRecognizeSelector: _cmd];
} @catch (id e) {
[self release];
@throw e;
}
OF_INVALID_INIT_METHOD
abort();
}
- (id)objectForKey: (id)key
{
[self doesNotRecognizeSelector: _cmd];
abort();
}
|
︙ | | |
Modified src/OFFile.m
from [1f1aa20392]
to [65676b97b5].
︙ | | |
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
|
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
|
-
-
-
-
-
-
-
+
-
|
encoding: OF_STRING_ENCODING_NATIVE
length: length];
}
#endif
- init
{
@try {
[self doesNotRecognizeSelector: _cmd];
} @catch (id e) {
[self release];
@throw e;
}
OF_INVALID_INIT_METHOD
abort();
}
- initWithPath: (OFString*)path
mode: (OFString*)mode
{
self = [super init];
|
︙ | | |
Modified src/OFIntrospection.m
from [1405af45f9]
to [78aaa4b641].
︙ | | |
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
|
12
13
14
15
16
17
18
19
20
21
22
23
24
25
|
-
|
* 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>
#if defined(OF_APPLE_RUNTIME)
# import <objc/runtime.h>
#endif
#import "OFIntrospection.h"
|
︙ | | |
62
63
64
65
66
67
68
69
70
71
72
73
74
75
|
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
|
+
+
+
+
+
|
[self release];
@throw e;
}
return self;
}
#endif
- init
{
OF_INVALID_INIT_METHOD
}
- (void)dealloc
{
[_name release];
[super dealloc];
}
|
︙ | | |
174
175
176
177
178
179
180
181
182
183
184
185
186
187
|
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
|
+
+
+
+
+
|
[self release];
@throw e;
}
return self;
}
#endif
- init
{
OF_INVALID_INIT_METHOD
}
- (void)dealloc
{
[_name release];
[super dealloc];
}
|
︙ | | |
323
324
325
326
327
328
329
330
331
332
333
334
335
336
|
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
|
+
+
+
+
+
|
} @catch (id e) {
[self release];
@throw e;
}
return self;
}
- init
{
OF_INVALID_INIT_METHOD
}
- (void)dealloc
{
[_classMethods release];
[_instanceMethods release];
[_instanceVariables release];
|
︙ | | |
Modified src/OFMapTable.m
from [08236d7fb2]
to [3c5a2f693b].
︙ | | |
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
|
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
|
-
-
-
-
-
-
-
+
-
|
initWithKeyFunctions: keyFunctions
valueFunctions: valueFunctions
capacity: capacity] autorelease];
}
- init
{
@try {
[self doesNotRecognizeSelector: _cmd];
} @catch (id e) {
[self release];
@throw e;
}
OF_INVALID_INIT_METHOD
abort();
}
- initWithKeyFunctions: (of_map_table_functions_t)keyFunctions
valueFunctions: (of_map_table_functions_t)valueFunctions
{
return [self initWithKeyFunctions: keyFunctions
valueFunctions: valueFunctions
|
︙ | | |
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
|
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
|
-
-
-
-
-
-
-
+
-
|
return _valueFunctions;
}
@end
@implementation OFMapTableEnumerator
- init
{
@try {
[self doesNotRecognizeSelector: _cmd];
} @catch (id e) {
[self release];
@throw e;
}
OF_INVALID_INIT_METHOD
abort();
}
- (instancetype)OF_initWithMapTable: (OFMapTable*)mapTable
buckets: (struct of_map_table_bucket**)buckets
capacity: (uint32_t)capacity
mutationsPointer: (unsigned long*)mutationsPtr
{
|
︙ | | |
Modified src/OFMessagePackExtension.m
from [015dabf7d7]
to [2d88255d50].
︙ | | |
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
|
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>
#import "OFMessagePackExtension.h"
#import "OFDataArray.h"
#import "OFString.h"
#import "OFInvalidArgumentException.h"
#import "macros.h"
@implementation OFMessagePackExtension
+ (instancetype)extensionWithType: (int8_t)type
data: (OFDataArray*)data
{
return [[[self alloc] initWithType: type
data: data] autorelease];
}
- init
{
@try {
[self doesNotRecognizeSelector: _cmd];
} @catch (id e) {
[self release];
@throw e;
}
OF_INVALID_INIT_METHOD
abort();
}
- initWithType: (int8_t)type
data: (OFDataArray*)data
{
self = [super init];
|
︙ | | |
Modified src/OFMutableArray.m
from [fce85c3ce9]
to [f95015fcd1].
︙ | | |
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
|
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
|
-
-
-
-
-
-
-
+
-
|
}
return [super init];
}
- initWithCapacity: (size_t)capacity
{
@try {
[self doesNotRecognizeSelector: _cmd];
} @catch (id e) {
[self release];
@throw e;
}
OF_INVALID_INIT_METHOD
abort();
}
- copy
{
return [[OFArray alloc] initWithArray: self];
}
|
︙ | | |
Modified src/OFMutableDictionary.m
from [b32f46f782]
to [fcf875c4b5].
︙ | | |
18
19
20
21
22
23
24
25
26
27
28
29
30
31
|
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
|
+
|
#include <stdlib.h>
#import "OFMutableDictionary_hashtable.h"
#import "OFArray.h"
#import "autorelease.h"
#import "macros.h"
static struct {
Class isa;
} placeholder;
@interface OFMutableDictionary_placeholder: OFDictionary
@end
|
︙ | | |
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
|
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
|
-
-
-
-
-
-
-
+
-
|
}
return [super init];
}
- initWithCapacity: (size_t)capacity
{
@try {
[self doesNotRecognizeSelector: _cmd];
} @catch (id e) {
[self release];
@throw e;
}
OF_INVALID_INIT_METHOD
abort();
}
- (void)setObject: (id)object
forKey: (id)key
{
[self doesNotRecognizeSelector: _cmd];
abort();
|
︙ | | |
Modified src/OFNumber.m
from [ae2aab0b1f]
to [2dc38d355c].
︙ | | |
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
|
12
13
14
15
16
17
18
19
20
21
22
23
24
25
|
-
-
|
* 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 "OFDataArray.h"
|
︙ | | |
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
|
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
|
-
-
-
-
-
-
-
+
-
|
+ (instancetype)numberWithDouble: (double)double_
{
return [[[self alloc] initWithDouble: double_] autorelease];
}
- init
{
@try {
[self doesNotRecognizeSelector: _cmd];
} @catch (id e) {
[self release];
@throw e;
}
OF_INVALID_INIT_METHOD
abort();
}
- initWithBool: (bool)bool_
{
self = [super init];
_value.bool_ = bool_;
|
︙ | | |
Modified src/OFOptionsParser.m
from [aa4007b981]
to [b0427c629b].
︙ | | |
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
|
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
|
-
-
-
-
-
-
-
-
-
+
-
|
* 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 "OFOptionsParser.h"
#import "OFApplication.h"
#import "OFArray.h"
#import "autorelease.h"
#import "macros.h"
@implementation OFOptionsParser
+ (instancetype)parserWithOptions: (OFString*)options
{
return [[[self alloc] initWithOptions: options] autorelease];
}
- init
{
@try {
[self doesNotRecognizeSelector: _cmd];
} @catch (id e) {
[self release];
@throw e;
}
OF_INVALID_INIT_METHOD
abort();
}
- initWithOptions: (OFString*)options
{
self = [super init];
@try {
|
︙ | | |
Modified src/OFProcess.m
from [cf4262ee3c]
to [fbf3337ae3].
︙ | | |
40
41
42
43
44
45
46
47
48
49
50
51
52
53
|
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
|
+
|
#import "OFWriteFailedException.h"
#ifdef _WIN32
# include <windows.h>
#endif
#import "autorelease.h"
#import "macros.h"
#ifndef __MACH__
extern char **environ;
#endif
@interface OFProcess (OF_PRIVATE_CATEGORY)
#ifndef _WIN32
|
︙ | | |
85
86
87
88
89
90
91
92
93
94
95
96
97
98
|
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
|
+
+
+
+
+
|
environment: (OFDictionary*)environment
{
return [[[self alloc] initWithProgram: program
programName: programName
arguments: arguments
environment: environment] autorelease];
}
- init
{
OF_INVALID_INIT_METHOD
}
- initWithProgram: (OFString*)program
{
return [self initWithProgram: program
programName: program
arguments: nil
environment: nil];
|
︙ | | |
Modified src/OFSeekableStream.m
from [7c51ea7ed3]
to [075ee49105].
︙ | | |
18
19
20
21
22
23
24
25
26
27
28
29
30
31
|
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
|
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
|
#include <stdlib.h>
#include <stdio.h>
#import "OFSeekableStream.h"
@implementation OFSeekableStream
- init
{
if (object_getClass(self) == [OFSeekableStream class]) {
@try {
[self doesNotRecognizeSelector: _cmd];
abort();
} @catch (id e) {
[self release];
@throw e;
}
}
return [super init];
}
- (off_t)lowlevelSeekToOffset: (off_t)offset
whence: (int)whence
{
[self doesNotRecognizeSelector: _cmd];
abort();
}
|
︙ | | |
Modified src/OFSet.m
from [4ad4b1bea6]
to [6f0ac7c26a].
︙ | | |
21
22
23
24
25
26
27
28
29
30
31
32
33
34
|
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
|
+
|
#import "OFSet.h"
#import "OFSet_hashtable.h"
#import "OFString.h"
#import "OFArray.h"
#import "OFXMLElement.h"
#import "autorelease.h"
#import "macros.h"
static struct {
Class isa;
} placeholder;
@interface OFSet_placeholder: OFSet
@end
|
︙ | | |
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
|
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
|
-
-
-
-
-
-
-
+
-
-
-
-
-
-
-
-
+
-
-
-
-
-
-
-
-
+
-
-
-
-
-
-
-
-
+
-
-
-
-
-
-
-
-
+
-
|
}
return [super init];
}
- initWithSet: (OFSet*)set
{
@try {
[self doesNotRecognizeSelector: _cmd];
} @catch (id e) {
[self release];
@throw e;
}
OF_INVALID_INIT_METHOD
abort();
}
- initWithArray: (OFArray*)array
{
@try {
[self doesNotRecognizeSelector: _cmd];
} @catch (id e) {
[self release];
@throw e;
}
OF_INVALID_INIT_METHOD
abort();
}
- initWithObjects: (id const*)objects
count: (size_t)count
{
@try {
[self doesNotRecognizeSelector: _cmd];
} @catch (id e) {
[self release];
@throw e;
}
OF_INVALID_INIT_METHOD
abort();
}
- (id)initWithObjects: (id)firstObject, ...
{
id ret;
va_list arguments;
va_start(arguments, firstObject);
ret = [self initWithObject: firstObject
arguments: arguments];
va_end(arguments);
return ret;
}
- initWithObject: (id)firstObject
arguments: (va_list)arguments
{
@try {
[self doesNotRecognizeSelector: _cmd];
} @catch (id e) {
[self release];
@throw e;
}
OF_INVALID_INIT_METHOD
abort();
}
- initWithSerialization: (OFXMLElement*)element
{
@try {
[self doesNotRecognizeSelector: _cmd];
} @catch (id e) {
[self release];
@throw e;
}
OF_INVALID_INIT_METHOD
abort();
}
- (size_t)count
{
[self doesNotRecognizeSelector: _cmd];
abort();
}
|
︙ | | |
Modified src/OFStdIOStream.m
from [26b8ba6e3e]
to [953debbd4d].
︙ | | |
23
24
25
26
27
28
29
30
31
32
33
34
35
36
|
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
|
+
|
#import "OFDate.h"
#import "OFApplication.h"
#import "OFReadFailedException.h"
#import "OFWriteFailedException.h"
#import "autorelease.h"
#import "macros.h"
OFStdIOStream *of_stdin = nil;
OFStdIOStream *of_stdout = nil;
OFStdIOStream *of_stderr = nil;
@interface OFStdIOStream (OF_PRIVATE_CATEGORY)
- (instancetype)OF_initWithFileDescriptor: (int)fd;
|
︙ | | |
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
|
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
|
-
-
-
-
-
-
-
+
-
|
of_stdin = [[OFStdIOStream alloc] OF_initWithFileDescriptor: 0];
of_stdout = [[OFStdIOStream alloc] OF_initWithFileDescriptor: 1];
of_stderr = [[OFStdIOStream alloc] OF_initWithFileDescriptor: 2];
}
- init
{
@try {
[self doesNotRecognizeSelector: _cmd];
} @catch (id e) {
[self release];
@throw e;
}
OF_INVALID_INIT_METHOD
abort();
}
- (instancetype)OF_initWithFileDescriptor: (int)fd
{
self = [super init];
_fd = fd;
|
︙ | | |
Modified src/OFString.m
from [c9aea4c452]
to [5368d29b65].
︙ | | |
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732
733
734
735
736
|
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
|
-
-
-
-
-
-
-
+
-
-
-
-
-
-
-
-
+
-
-
-
-
-
-
-
-
+
-
|
length: strlen(cString)];
}
- initWithCString: (const char*)cString
encoding: (of_string_encoding_t)encoding
length: (size_t)cStringLength
{
@try {
[self doesNotRecognizeSelector: _cmd];
} @catch (id e) {
[self release];
@throw e;
}
OF_INVALID_INIT_METHOD
abort();
}
- initWithString: (OFString*)string
{
@try {
[self doesNotRecognizeSelector: _cmd];
} @catch (id e) {
[self release];
@throw e;
}
OF_INVALID_INIT_METHOD
abort();
}
- initWithCharacters: (const of_unichar_t*)string
length: (size_t)length
{
@try {
[self doesNotRecognizeSelector: _cmd];
} @catch (id e) {
[self release];
@throw e;
}
OF_INVALID_INIT_METHOD
abort();
}
- initWithUTF16String: (const of_char16_t*)string
{
return [self initWithUTF16String: string
length: of_string_utf16_length(string)
byteOrder: OF_BYTE_ORDER_NATIVE];
|
︙ | | |
752
753
754
755
756
757
758
759
760
761
762
763
764
765
766
767
768
769
770
771
772
773
|
731
732
733
734
735
736
737
738
739
740
741
742
743
744
745
|
-
-
-
-
-
-
-
+
-
|
byteOrder: byteOrder];
}
- initWithUTF16String: (const of_char16_t*)string
length: (size_t)length
byteOrder: (of_byte_order_t)byteOrder
{
@try {
[self doesNotRecognizeSelector: _cmd];
} @catch (id e) {
[self release];
@throw e;
}
OF_INVALID_INIT_METHOD
abort();
}
- initWithUTF32String: (const of_char32_t*)string
{
return [self initWithUTF32String: string
length: of_string_utf32_length(string)
byteOrder: OF_BYTE_ORDER_NATIVE];
|
︙ | | |
789
790
791
792
793
794
795
796
797
798
799
800
801
802
803
804
805
806
807
808
809
810
811
812
813
814
815
816
817
818
819
820
821
822
823
824
825
826
827
828
829
830
831
832
833
834
835
836
|
761
762
763
764
765
766
767
768
769
770
771
772
773
774
775
776
777
778
779
780
781
782
783
784
785
786
787
788
789
790
791
792
793
794
|
-
-
-
-
-
-
-
+
-
-
-
-
-
-
-
-
+
-
|
byteOrder: byteOrder];
}
- initWithUTF32String: (const of_char32_t*)string
length: (size_t)length
byteOrder: (of_byte_order_t)byteOrder
{
@try {
[self doesNotRecognizeSelector: _cmd];
} @catch (id e) {
[self release];
@throw e;
}
OF_INVALID_INIT_METHOD
abort();
}
- initWithFormat: (OFConstantString*)format, ...
{
id ret;
va_list arguments;
va_start(arguments, format);
ret = [self initWithFormat: format
arguments: arguments];
va_end(arguments);
return ret;
}
- initWithFormat: (OFConstantString*)format
arguments: (va_list)arguments
{
@try {
[self doesNotRecognizeSelector: _cmd];
} @catch (id e) {
[self release];
@throw e;
}
OF_INVALID_INIT_METHOD
abort();
}
- initWithContentsOfFile: (OFString*)path
{
return [self initWithContentsOfFile: path
encoding: OF_STRING_ENCODING_UTF_8];
}
|
︙ | | |
Modified src/OFThread.m
from [6544d29ad9]
to [b35e0e98a2].
︙ | | |
60
61
62
63
64
65
66
67
68
69
70
71
72
73
|
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
|
+
|
# import "OFThreadStillRunningException.h"
#endif
#ifdef OF_HAVE_ATOMIC_OPS
# import "atomic.h"
#endif
#import "autorelease.h"
#import "macros.h"
#ifdef OF_HAVE_THREADS
# import "threading.h"
static of_tlskey_t threadSelfKey;
static OFThread *mainThread;
|
︙ | | |
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
|
371
372
373
374
375
376
377
378
379
380
381
|
-
-
-
-
-
-
-
+
-
|
# endif
[super dealloc];
}
#else
- init
{
@try {
[self doesNotRecognizeSelector: _cmd];
} @catch (id e) {
[self release];
@throw e;
}
OF_INVALID_INIT_METHOD
abort();
}
#endif
@end
|
Modified src/OFTimer.m
from [cab4d43241]
to [18c068dfe1].
︙ | | |
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
|
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
|
-
-
-
-
-
-
-
+
-
|
return [timer autorelease];
}
#endif
- init
{
@try {
[self doesNotRecognizeSelector: _cmd];
} @catch (id e) {
[self release];
@throw e;
}
OF_INVALID_INIT_METHOD
abort();
}
- (instancetype)OF_initWithFireDate: (OFDate*)fireDate
interval: (double)interval
target: (id)target
selector: (SEL)selector
object: (id)object1
|
︙ | | |
Modified src/OFXMLElement.m
from [48732d84ce]
to [053784140f].
︙ | | |
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
|
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
|
-
-
-
-
-
-
-
+
-
|
+ (instancetype)elementWithFile: (OFString*)path
{
return [[[self alloc] initWithFile: path] autorelease];
}
- init
{
@try {
[self doesNotRecognizeSelector: _cmd];
} @catch (id e) {
[self release];
@throw e;
}
OF_INVALID_INIT_METHOD
abort();
}
- initWithName: (OFString*)name
{
return [self initWithName: name
namespace: nil
stringValue: nil];
|
︙ | | |
Modified src/OFXMLNode.m
from [4dde527cf4]
to [d0cf0df8f6].
︙ | | |
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
|
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
|
+
+
-
-
-
-
-
-
-
+
-
|
#include "config.h"
#include <stdlib.h>
#import "OFXMLNode.h"
#import "OFString.h"
#import "macros.h"
@implementation OFXMLNode
- initWithSerialization: (OFXMLElement*)element
{
@try {
[self doesNotRecognizeSelector: _cmd];
} @catch (id e) {
[self release];
@throw e;
}
OF_INVALID_INIT_METHOD
abort();
}
- (OFString*)stringValue
{
[self doesNotRecognizeSelector: _cmd];
abort();
}
|
︙ | | |
Modified src/OFZIPArchive.m
from [20c9faa50f]
to [6bc862255c].
︙ | | |
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
|
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
|
-
-
-
-
-
-
-
+
-
|
+ (instancetype)archiveWithPath: (OFString*)path
{
return [[[self alloc] initWithPath: path] autorelease];
}
- init
{
@try {
[self doesNotRecognizeSelector: _cmd];
} @catch (id e) {
[self release];
@throw e;
}
OF_INVALID_INIT_METHOD
abort();
}
- initWithPath: (OFString*)path
{
self = [super init];
@try {
|
︙ | | |
Modified src/exceptions/OFAcceptFailedException.m
from [a8b056d8fd]
to [c9df549033].
︙ | | |
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
|
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
|
-
-
+
-
-
-
-
-
-
-
+
-
|
* Public License, either version 2 or 3, which can be found in the file
* LICENSE.GPLv2 or LICENSE.GPLv3 respectively included in the packaging of this
* file.
*/
#include "config.h"
#include <stdlib.h>
#import "OFAcceptFailedException.h"
#import "OFString.h"
#import "OFTCPSocket.h"
#import "common.h"
#import "macros.h"
@implementation OFAcceptFailedException
+ (instancetype)exceptionWithSocket: (OFTCPSocket*)socket
{
return [[[self alloc] initWithSocket: socket] autorelease];
}
- init
{
@try {
[self doesNotRecognizeSelector: _cmd];
} @catch (id e) {
[self release];
@throw e;
}
OF_INVALID_INIT_METHOD
abort();
}
- initWithSocket: (OFTCPSocket*)socket
{
self = [super init];
_socket = [socket retain];
|
︙ | | |
Modified src/exceptions/OFAddressTranslationFailedException.m
from [e5b08ed3d1]
to [08cce05a27].
︙ | | |
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
|
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
|
+
+
+
+
+
+
|
#include "config.h"
#import "OFAddressTranslationFailedException.h"
#import "OFString.h"
#import "OFTCPSocket.h"
#import "common.h"
#import "macros.h"
@implementation OFAddressTranslationFailedException
+ (instancetype)exceptionWithSocket: (OFTCPSocket*)socket
{
return [[[self alloc] initWithSocket: socket] autorelease];
}
+ (instancetype)exceptionWithHost: (OFString*)host
{
return [[[self alloc] initWithHost: host] autorelease];
}
+ (instancetype)exceptionWithHost: (OFString*)host
socket: (OFTCPSocket*)socket
{
return [[[self alloc] initWithHost: host
socket: socket] autorelease];
}
- init
{
OF_INVALID_INIT_METHOD
}
- initWithSocket: (OFTCPSocket*)socket
{
return [self initWithHost: nil
socket: socket];
}
|
︙ | | |
Modified src/exceptions/OFAllocFailedException.m
from [35d67114ec]
to [92f1626a0e].
︙ | | |
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
|
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
|
+
+
-
-
-
-
-
-
-
+
-
|
#include "config.h"
#include <stdlib.h>
#import "OFAllocFailedException.h"
#import "OFString.h"
#import "macros.h"
@implementation OFAllocFailedException
+ alloc
{
[self doesNotRecognizeSelector: _cmd];
abort();
}
- init
{
@try {
[self doesNotRecognizeSelector: _cmd];
} @catch (id e) {
[self release];
@throw e;
}
OF_INVALID_INIT_METHOD
abort();
}
- (void*)allocMemoryWithSize: (size_t)size
{
[self doesNotRecognizeSelector: _cmd];
abort();
}
|
︙ | | |
Modified src/exceptions/OFAlreadyConnectedException.m
from [c94a781825]
to [2609dea2db].
︙ | | |
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
|
12
13
14
15
16
17
18
19
20
21
22
23
24
25
|
-
-
|
* Public License, either version 2 or 3, which can be found in the file
* LICENSE.GPLv2 or LICENSE.GPLv3 respectively included in the packaging of this
* file.
*/
#include "config.h"
#include <stdlib.h>
#import "OFAlreadyConnectedException.h"
#import "OFString.h"
#import "OFTCPSocket.h"
#import "common.h"
@implementation OFAlreadyConnectedException
|
︙ | | |
Modified src/exceptions/OFBindFailedException.m
from [8568a2e239]
to [c2dc859a2f].
︙ | | |
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
|
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
|
-
-
+
-
-
-
-
-
-
-
+
-
|
* Public License, either version 2 or 3, which can be found in the file
* LICENSE.GPLv2 or LICENSE.GPLv3 respectively included in the packaging of this
* file.
*/
#include "config.h"
#include <stdlib.h>
#import "OFBindFailedException.h"
#import "OFString.h"
#import "OFTCPSocket.h"
#import "common.h"
#import "macros.h"
@implementation OFBindFailedException
+ (instancetype)exceptionWithHost: (OFString*)host
port: (uint16_t)port
socket: (OFTCPSocket*)socket
{
return [[[self alloc] initWithHost: host
port: port
socket: socket] autorelease];
}
- init
{
@try {
[self doesNotRecognizeSelector: _cmd];
} @catch (id e) {
[self release];
@throw e;
}
OF_INVALID_INIT_METHOD
abort();
}
- initWithHost: (OFString*)host
port: (uint16_t)port
socket: (OFTCPSocket*)socket
{
self = [super init];
|
︙ | | |
Modified src/exceptions/OFChangeCurrentDirectoryPathFailedException.m
from [ec26a362b7]
to [f4a231c25b].
︙ | | |
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
|
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
|
-
-
+
-
-
-
-
-
-
-
+
-
|
* 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 "OFChangeCurrentDirectoryPathFailedException.h"
#import "OFString.h"
#import "common.h"
#import "macros.h"
@implementation OFChangeCurrentDirectoryPathFailedException
+ (instancetype)exceptionWithPath: (OFString*)path
{
return [[[self alloc] initWithPath: path] autorelease];
}
- init
{
@try {
[self doesNotRecognizeSelector: _cmd];
} @catch (id e) {
[self release];
@throw e;
}
OF_INVALID_INIT_METHOD
abort();
}
- initWithPath: (OFString*)path
{
self = [super init];
@try {
|
︙ | | |
Modified src/exceptions/OFChangeOwnerFailedException.m
from [da5fdc5878]
to [319c57bc6c].
︙ | | |
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
|
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
|
-
-
+
-
-
-
-
-
-
-
+
-
|
* 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 "OFChangeOwnerFailedException.h"
#import "OFString.h"
#import "common.h"
#import "macros.h"
#ifdef OF_HAVE_CHOWN
@implementation OFChangeOwnerFailedException
+ (instancetype)exceptionWithPath: (OFString*)path
owner: (OFString*)owner
group: (OFString*)group
{
return [[[self alloc] initWithPath: path
owner: owner
group: group] autorelease];
}
- init
{
@try {
[self doesNotRecognizeSelector: _cmd];
} @catch (id e) {
[self release];
@throw e;
}
OF_INVALID_INIT_METHOD
abort();
}
- initWithPath: (OFString*)path
owner: (OFString*)owner
group: (OFString*)group
{
self = [super init];
|
︙ | | |
Modified src/exceptions/OFChangePermissionsFailedException.m
from [95d5918ec4]
to [0fc029b850].
︙ | | |
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
|
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
|
-
-
+
-
-
-
-
-
-
-
+
-
|
* 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 "OFChangePermissionsFailedException.h"
#import "OFString.h"
#import "common.h"
#import "macros.h"
@implementation OFChangePermissionsFailedException
+ (instancetype)exceptionWithPath: (OFString*)path
permissions: (mode_t)permissions
{
return [[[self alloc] initWithPath: path
permissions: permissions] autorelease];
}
- init
{
@try {
[self doesNotRecognizeSelector: _cmd];
} @catch (id e) {
[self release];
@throw e;
}
OF_INVALID_INIT_METHOD
abort();
}
- initWithPath: (OFString*)path
permissions: (mode_t)permissions
{
self = [super init];
|
︙ | | |
Modified src/exceptions/OFConditionBroadcastFailedException.m
from [216f113c36]
to [5f30fac9ce].
︙ | | |
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
|
-
-
+
+
-
-
-
-
-
-
-
+
-
|
* 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 "macros.h"
@implementation OFConditionBroadcastFailedException
+ (instancetype)exceptionWithCondition: (OFCondition*)condition
{
return [[[self alloc] initWithCondition: condition] autorelease];
}
- init
{
@try {
[self doesNotRecognizeSelector: _cmd];
} @catch (id e) {
[self release];
@throw e;
}
OF_INVALID_INIT_METHOD
abort();
}
- initWithCondition: (OFCondition*)condition
{
self = [super init];
_condition = [condition retain];
|
︙ | | |
Modified src/exceptions/OFConditionSignalFailedException.m
from [e285820a8f]
to [5f302da8ef].
︙ | | |
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
|
-
-
+
+
-
-
-
-
-
-
-
+
-
|
* 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 "macros.h"
@implementation OFConditionSignalFailedException
+ (instancetype)exceptionWithCondition: (OFCondition*)condition
{
return [[[self alloc] initWithCondition: condition] autorelease];
}
- init
{
@try {
[self doesNotRecognizeSelector: _cmd];
} @catch (id e) {
[self release];
@throw e;
}
OF_INVALID_INIT_METHOD
abort();
}
- initWithCondition: (OFCondition*)condition
{
self = [super init];
_condition = [condition retain];
|
︙ | | |
Modified src/exceptions/OFConditionStillWaitingException.m
from [00e380e989]
to [20e45e136f].
︙ | | |
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
|
-
-
+
+
-
-
-
-
-
-
-
+
-
|
* 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 "macros.h"
@implementation OFConditionStillWaitingException
+ (instancetype)exceptionWithCondition: (OFCondition*)condition
{
return [[[self alloc] initWithCondition: condition] autorelease];
}
- init
{
@try {
[self doesNotRecognizeSelector: _cmd];
} @catch (id e) {
[self release];
@throw e;
}
OF_INVALID_INIT_METHOD
abort();
}
- initWithCondition: (OFCondition*)condition
{
self = [super init];
_condition = [condition retain];
|
︙ | | |
Modified src/exceptions/OFConditionWaitFailedException.m
from [eacb3cb5f7]
to [54badab712].
︙ | | |
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
|
-
-
+
+
-
-
-
-
-
-
-
+
-
|
* 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 "macros.h"
@implementation OFConditionWaitFailedException
+ (instancetype)exceptionWithCondition: (OFCondition*)condition
{
return [[[self alloc] initWithCondition: condition] autorelease];
}
- init
{
@try {
[self doesNotRecognizeSelector: _cmd];
} @catch (id e) {
[self release];
@throw e;
}
OF_INVALID_INIT_METHOD
abort();
}
- initWithCondition: (OFCondition*)condition
{
self = [super init];
_condition = [condition retain];
|
︙ | | |
Modified src/exceptions/OFConnectionFailedException.m
from [471928a109]
to [d2abef410f].
︙ | | |
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
|
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
|
-
-
+
-
-
-
-
-
-
-
+
-
|
* Public License, either version 2 or 3, which can be found in the file
* LICENSE.GPLv2 or LICENSE.GPLv3 respectively included in the packaging of this
* file.
*/
#include "config.h"
#include <stdlib.h>
#import "OFConnectionFailedException.h"
#import "OFString.h"
#import "OFTCPSocket.h"
#import "common.h"
#import "macros.h"
@implementation OFConnectionFailedException
+ (instancetype)exceptionWithHost: (OFString*)host
port: (uint16_t)port
socket: (OFTCPSocket*)socket
{
return [[[self alloc] initWithHost: host
port: port
socket: socket] autorelease];
}
- init
{
@try {
[self doesNotRecognizeSelector: _cmd];
} @catch (id e) {
[self release];
@throw e;
}
OF_INVALID_INIT_METHOD
abort();
}
- initWithHost: (OFString*)host
port: (uint16_t)port
socket: (OFTCPSocket*)socket
{
self = [super init];
|
︙ | | |
Modified src/exceptions/OFCopyFileFailedException.m
from [e2611a58a4]
to [72ed5cf0b0].
︙ | | |
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
|
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
|
-
-
+
-
-
-
-
-
-
-
+
-
|
* Public License, either version 2 or 3, which can be found in the file
* LICENSE.GPLv2 or LICENSE.GPLv3 respectively included in the packaging of this
* file.
*/
#include "config.h"
#include <stdlib.h>
#import "OFCopyFileFailedException.h"
#import "OFString.h"
#import "common.h"
#import "macros.h"
@implementation OFCopyFileFailedException
+ (instancetype)exceptionWithSourcePath: (OFString*)sourcePath
destinationPath: (OFString*)destinationPath
{
return [[[self alloc] initWithSourcePath: sourcePath
destinationPath: destinationPath] autorelease];
}
- init
{
@try {
[self doesNotRecognizeSelector: _cmd];
} @catch (id e) {
[self release];
@throw e;
}
OF_INVALID_INIT_METHOD
abort();
}
- initWithSourcePath: (OFString*)sourcePath
destinationPath: (OFString*)destinationPath
{
self = [super init];
|
︙ | | |
Modified src/exceptions/OFCreateDirectoryFailedException.m
from [50fb411f1e]
to [304107a2a5].
︙ | | |
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
|
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
|
-
-
+
-
-
-
-
-
-
-
+
-
|
* Public License, either version 2 or 3, which can be found in the file
* LICENSE.GPLv2 or LICENSE.GPLv3 respectively included in the packaging of this
* file.
*/
#include "config.h"
#include <stdlib.h>
#import "OFCreateDirectoryFailedException.h"
#import "OFString.h"
#import "common.h"
#import "macros.h"
@implementation OFCreateDirectoryFailedException
+ (instancetype)exceptionWithPath: (OFString*)path
{
return [[[self alloc] initWithPath: path] autorelease];
}
- init
{
@try {
[self doesNotRecognizeSelector: _cmd];
} @catch (id e) {
[self release];
@throw e;
}
OF_INVALID_INIT_METHOD
abort();
}
- initWithPath: (OFString*)path
{
self = [super init];
@try {
|
︙ | | |
Modified src/exceptions/OFCreateSymbolicLinkFailedException.m
from [a5e043dcde]
to [3cb2e0b69b].
︙ | | |
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
|
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
|
-
-
+
-
-
-
-
-
-
-
+
-
|
* Public License, either version 2 or 3, which can be found in the file
* LICENSE.GPLv2 or LICENSE.GPLv3 respectively included in the packaging of this
* file.
*/
#include "config.h"
#include <stdlib.h>
#import "OFCreateSymbolicLinkFailedException.h"
#import "OFString.h"
#import "common.h"
#import "macros.h"
#ifdef OF_HAVE_SYMLINK
@implementation OFCreateSymbolicLinkFailedException
+ (instancetype)exceptionWithSourcePath: (OFString*)sourcePath
destinationPath: (OFString*)destinationPath
{
return [[[self alloc] initWithSourcePath: sourcePath
destinationPath: destinationPath] autorelease];
}
- init
{
@try {
[self doesNotRecognizeSelector: _cmd];
} @catch (id e) {
[self release];
@throw e;
}
OF_INVALID_INIT_METHOD
abort();
}
- initWithSourcePath: (OFString*)sourcePath
destinationPath: (OFString*)destinationPath
{
self = [super init];
|
︙ | | |
Modified src/exceptions/OFEnumerationMutationException.m
from [3af9010d50]
to [73a1a3de63].
︙ | | |
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
|
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
|
-
-
+
-
-
-
-
-
-
-
+
-
|
* Public License, either version 2 or 3, which can be found in the file
* LICENSE.GPLv2 or LICENSE.GPLv3 respectively included in the packaging of this
* file.
*/
#include "config.h"
#include <stdlib.h>
#import "OFEnumerationMutationException.h"
#import "OFString.h"
#import "common.h"
#import "macros.h"
@implementation OFEnumerationMutationException
+ (instancetype)exceptionWithObject: (id)object
{
return [[[self alloc] initWithObject: object] autorelease];
}
- init
{
@try {
[self doesNotRecognizeSelector: _cmd];
} @catch (id e) {
[self release];
@throw e;
}
OF_INVALID_INIT_METHOD
abort();
}
- initWithObject: (id)object
{
self = [super init];
_object = [object retain];
|
︙ | | |
Modified src/exceptions/OFHTTPRequestFailedException.m
from [34b6f2f053]
to [d77c84404e].
︙ | | |
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
|
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>
#import "OFHTTPRequestFailedException.h"
#import "OFString.h"
#import "OFHTTPRequest.h"
#import "OFHTTPResponse.h"
#import "common.h"
#import "macros.h"
@implementation OFHTTPRequestFailedException
+ (instancetype)exceptionWithRequest: (OFHTTPRequest*)request
response: (OFHTTPResponse*)response
{
return [[[self alloc] initWithRequest: request
response: response] autorelease];
}
- init
{
@try {
[self doesNotRecognizeSelector: _cmd];
} @catch (id e) {
[self release];
@throw e;
}
OF_INVALID_INIT_METHOD
abort();
}
- initWithRequest: (OFHTTPRequest*)request
response: (OFHTTPResponse*)response
{
self = [super init];
|
︙ | | |
Modified src/exceptions/OFHashAlreadyCalculatedException.m
from [18369c4a51]
to [c0fd69c1da].
︙ | | |
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
|
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
|
-
-
+
-
-
-
-
-
-
-
+
-
|
* 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 "common.h"
#import "macros.h"
@implementation OFHashAlreadyCalculatedException
+ (instancetype)exceptionWithHash: (id <OFHash>)hash
{
return [[[self alloc] initWithHash: hash] autorelease];
}
- init
{
@try {
[self doesNotRecognizeSelector: _cmd];
} @catch (id e) {
[self release];
@throw e;
}
OF_INVALID_INIT_METHOD
abort();
}
- initWithHash: (id <OFHash>)hashObject
{
self = [super init];
_hashObject = [hashObject retain];
|
︙ | | |
Modified src/exceptions/OFInitializationFailedException.m
from [df3cddd866]
to [f8f3e3d8f3].
︙ | | |
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
|
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
|
-
-
+
-
-
-
-
-
-
-
+
-
|
* 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 "OFInitializationFailedException.h"
#import "OFString.h"
#import "common.h"
#import "macros.h"
@implementation OFInitializationFailedException
+ (instancetype)exceptionWithClass: (Class)class
{
return [[[self alloc] initWithClass: class] autorelease];
}
- init
{
@try {
[self doesNotRecognizeSelector: _cmd];
} @catch (id e) {
[self release];
@throw e;
}
OF_INVALID_INIT_METHOD
abort();
}
- initWithClass: (Class)class
{
self = [super init];
_inClass = class;
|
︙ | | |
Modified src/exceptions/OFInvalidJSONException.m
from [559483f21d]
to [4b6dcb9fa7].
︙ | | |
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
|
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
|
-
-
-
-
-
-
-
-
-
+
-
|
* 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 "macros.h"
@implementation OFInvalidJSONException
+ (instancetype)exceptionWithString: (OFString*)string
line: (size_t)line
{
return [[[self alloc] initWithString: string
line: line] autorelease];
}
- init
{
@try {
[self doesNotRecognizeSelector: _cmd];
} @catch (id e) {
[self release];
@throw e;
}
OF_INVALID_INIT_METHOD
abort();
}
- initWithString: (OFString*)string
line: (size_t)line
{
self = [super init];
|
︙ | | |
Modified src/exceptions/OFLinkFailedException.m
from [72257aafbd]
to [b1d794cdfc].
︙ | | |
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
|
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
|
-
-
+
-
-
-
-
-
-
-
+
-
|
* Public License, either version 2 or 3, which can be found in the file
* LICENSE.GPLv2 or LICENSE.GPLv3 respectively included in the packaging of this
* file.
*/
#include "config.h"
#include <stdlib.h>
#import "OFLinkFailedException.h"
#import "OFString.h"
#import "common.h"
#import "macros.h"
#ifdef OF_HAVE_LINK
@implementation OFLinkFailedException
+ (instancetype)exceptionWithSourcePath: (OFString*)sourcePath
destinationPath: (OFString*)destinationPath
{
return [[[self alloc] initWithSourcePath: sourcePath
destinationPath: destinationPath] autorelease];
}
- init
{
@try {
[self doesNotRecognizeSelector: _cmd];
} @catch (id e) {
[self release];
@throw e;
}
OF_INVALID_INIT_METHOD
abort();
}
- initWithSourcePath: (OFString*)sourcePath
destinationPath: (OFString*)destinationPath
{
self = [super init];
|
︙ | | |
Modified src/exceptions/OFListenFailedException.m
from [b821e4cd80]
to [a0961a5af9].
︙ | | |
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
|
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
|
-
-
+
-
-
-
-
-
-
-
+
-
|
* Public License, either version 2 or 3, which can be found in the file
* LICENSE.GPLv2 or LICENSE.GPLv3 respectively included in the packaging of this
* file.
*/
#include "config.h"
#include <stdlib.h>
#import "OFListenFailedException.h"
#import "OFString.h"
#import "OFTCPSocket.h"
#import "common.h"
#import "macros.h"
@implementation OFListenFailedException
+ (instancetype)exceptionWithSocket: (OFTCPSocket*)socket
backLog: (int)backLog
{
return [[[self alloc] initWithSocket: socket
backLog: backLog] autorelease];
}
- init
{
@try {
[self doesNotRecognizeSelector: _cmd];
} @catch (id e) {
[self release];
@throw e;
}
OF_INVALID_INIT_METHOD
abort();
}
- initWithSocket: (OFTCPSocket*)socket
backLog: (int)backLog
{
self = [super init];
|
︙ | | |
Modified src/exceptions/OFMemoryNotPartOfObjectException.m
from [ce4e415b85]
to [d3c1a7f281].
︙ | | |
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
|
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
|
-
-
-
-
-
-
-
-
-
+
-
|
* 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 "macros.h"
@implementation OFMemoryNotPartOfObjectException
+ (instancetype)exceptionWithPointer: (void*)pointer
object: (id)object
{
return [[[self alloc] initWithPointer: pointer
object: object] autorelease];
}
- init
{
@try {
[self doesNotRecognizeSelector: _cmd];
} @catch (id e) {
[self release];
@throw e;
}
OF_INVALID_INIT_METHOD
abort();
}
- initWithPointer: (void*)pointer
object: (id)object
{
self = [super init];
|
︙ | | |
Modified src/exceptions/OFNotConnectedException.m
from [395fdef6b4]
to [d144f51e1d].
︙ | | |
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
|
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
|
-
-
+
-
-
-
-
-
-
-
+
-
|
* Public License, either version 2 or 3, which can be found in the file
* LICENSE.GPLv2 or LICENSE.GPLv3 respectively included in the packaging of this
* file.
*/
#include "config.h"
#include <stdlib.h>
#import "OFNotConnectedException.h"
#import "OFString.h"
#import "OFTCPSocket.h"
#import "common.h"
#import "macros.h"
@implementation OFNotConnectedException
+ (instancetype)exceptionWithSocket: (OFStreamSocket*)socket
{
return [[[self alloc] initWithSocket: socket] autorelease];
}
- init
{
@try {
[self doesNotRecognizeSelector: _cmd];
} @catch (id e) {
[self release];
@throw e;
}
OF_INVALID_INIT_METHOD
abort();
}
- initWithSocket: (OFStreamSocket*)socket
{
self = [super init];
_socket = [socket retain];
|
︙ | | |
Modified src/exceptions/OFNotImplementedException.m
from [3675507b02]
to [570a9399b5].
︙ | | |
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
|
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
|
-
-
+
-
-
-
-
-
-
-
+
-
|
* 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"
#import "macros.h"
@implementation OFNotImplementedException
+ (instancetype)exceptionWithSelector: (SEL)selector
object: (id)object
{
return [[[self alloc] initWithSelector: selector
object: object] autorelease];
}
- init
{
@try {
[self doesNotRecognizeSelector: _cmd];
} @catch (id e) {
[self release];
@throw e;
}
OF_INVALID_INIT_METHOD
abort();
}
- initWithSelector: (SEL)selector
object: (id)object
{
self = [super init];
|
︙ | | |
Modified src/exceptions/OFOpenFileFailedException.m
from [c7d79c20a2]
to [44b6a7107c].
︙ | | |
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
|
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
|
-
-
+
-
-
-
-
-
-
-
+
-
|
* Public License, either version 2 or 3, which can be found in the file
* LICENSE.GPLv2 or LICENSE.GPLv3 respectively included in the packaging of this
* file.
*/
#include "config.h"
#include <stdlib.h>
#import "OFOpenFileFailedException.h"
#import "OFString.h"
#import "common.h"
#import "macros.h"
@implementation OFOpenFileFailedException
+ (instancetype)exceptionWithPath: (OFString*)path
mode: (OFString*)mode
{
return [[[self alloc] initWithPath: path
mode: mode] autorelease];
}
- init
{
@try {
[self doesNotRecognizeSelector: _cmd];
} @catch (id e) {
[self release];
@throw e;
}
OF_INVALID_INIT_METHOD
abort();
}
- initWithPath: (OFString*)path
mode: (OFString*)mode
{
self = [super init];
|
︙ | | |
Modified src/exceptions/OFReadOrWriteFailedException.m
from [1a0bc9c6ea]
to [097ec72f47].
︙ | | |
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
|
-
-
+
-
-
-
-
-
-
-
+
-
|
* 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 "OFStream.h"
#ifdef OF_HAVE_SOCKETS
# import "OFStreamSocket.h"
#endif
#import "common.h"
#import "macros.h"
@implementation OFReadOrWriteFailedException
+ (instancetype)exceptionWithStream: (OFStream*)stream
requestedLength: (size_t)requestedLength
{
return [[[self alloc] initWithStream: stream
requestedLength: requestedLength] autorelease];
}
- init
{
@try {
[self doesNotRecognizeSelector: _cmd];
} @catch (id e) {
[self release];
@throw e;
}
OF_INVALID_INIT_METHOD
abort();
}
- initWithStream: (OFStream*)stream
requestedLength: (size_t)requestedLength
{
self = [super init];
|
︙ | | |
Modified src/exceptions/OFRemoveItemFailedException.m
from [fc2e8c40c3]
to [8513c01866].
︙ | | |
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
|
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
|
-
-
+
-
-
-
-
-
-
-
+
-
|
* 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 "OFRemoveItemFailedException.h"
#import "OFString.h"
#import "common.h"
#import "macros.h"
@implementation OFRemoveItemFailedException
+ (instancetype)exceptionWithPath: (OFString*)path
{
return [[[self alloc] initWithPath: path] autorelease];
}
- init
{
@try {
[self doesNotRecognizeSelector: _cmd];
} @catch (id e) {
[self release];
@throw e;
}
OF_INVALID_INIT_METHOD
abort();
}
- initWithPath: (OFString*)path
{
self = [super init];
@try {
|
︙ | | |
Modified src/exceptions/OFRenameItemFailedException.m
from [c997242f11]
to [3a8ee84e77].
︙ | | |
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
|
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
|
-
-
+
-
-
-
-
-
-
-
+
-
|
* 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 "OFRenameItemFailedException.h"
#import "OFString.h"
#import "common.h"
#import "macros.h"
@implementation OFRenameItemFailedException
+ (instancetype)exceptionWithSourcePath: (OFString*)sourcePath
destinationPath: (OFString*)destinationPath
{
return [[[self alloc] initWithSourcePath: sourcePath
destinationPath: destinationPath] autorelease];
}
- init
{
@try {
[self doesNotRecognizeSelector: _cmd];
} @catch (id e) {
[self release];
@throw e;
}
OF_INVALID_INIT_METHOD
abort();
}
- initWithSourcePath: (OFString*)sourcePath
destinationPath: (OFString*)destinationPath
{
self = [super init];
|
︙ | | |
Modified src/exceptions/OFSeekFailedException.m
from [a61f6e2176]
to [4f43b74af7].
︙ | | |
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
|
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
|
-
-
+
-
-
-
-
-
-
-
+
-
|
* Public License, either version 2 or 3, which can be found in the file
* LICENSE.GPLv2 or LICENSE.GPLv3 respectively included in the packaging of this
* file.
*/
#include "config.h"
#include <stdlib.h>
#import "OFSeekFailedException.h"
#import "OFString.h"
#import "OFSeekableStream.h"
#import "common.h"
#import "macros.h"
@implementation OFSeekFailedException
+ (instancetype)exceptionWithStream: (OFSeekableStream*)stream
offset: (off_t)offset
whence: (int)whence
{
return [[[self alloc] initWithStream: stream
offset: offset
whence: whence] autorelease];
}
- init
{
@try {
[self doesNotRecognizeSelector: _cmd];
} @catch (id e) {
[self release];
@throw e;
}
OF_INVALID_INIT_METHOD
abort();
}
- initWithStream: (OFSeekableStream*)stream
offset: (off_t)offset
whence: (int)whence
{
self = [super init];
|
︙ | | |
Modified src/exceptions/OFSetOptionFailedException.m
from [f58b958525]
to [815b466283].
︙ | | |
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
|
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
|
-
-
+
-
-
-
-
-
-
-
+
-
|
* Public License, either version 2 or 3, which can be found in the file
* LICENSE.GPLv2 or LICENSE.GPLv3 respectively included in the packaging of this
* file.
*/
#include "config.h"
#include <stdlib.h>
#import "OFSetOptionFailedException.h"
#import "OFString.h"
#import "OFStream.h"
#import "common.h"
#import "macros.h"
@implementation OFSetOptionFailedException
+ (instancetype)exceptionWithStream: (OFStream*)stream
{
return [[[self alloc] initWithStream: stream] autorelease];
}
- init
{
@try {
[self doesNotRecognizeSelector: _cmd];
} @catch (id e) {
[self release];
@throw e;
}
OF_INVALID_INIT_METHOD
abort();
}
- initWithStream: (OFStream*)stream
{
self = [super init];
_stream = [stream retain];
|
︙ | | |
Modified src/exceptions/OFThreadJoinFailedException.m
from [6799ed802b]
to [f76e38b740].
︙ | | |
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
|
-
-
+
+
-
-
-
-
-
-
-
+
-
|
* 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 "macros.h"
@implementation OFThreadJoinFailedException
+ (instancetype)exceptionWithThread: (OFThread*)thread
{
return [[[self alloc] initWithThread: thread] autorelease];
}
- init
{
@try {
[self doesNotRecognizeSelector: _cmd];
} @catch (id e) {
[self release];
@throw e;
}
OF_INVALID_INIT_METHOD
abort();
}
- initWithThread: (OFThread*)thread
{
self = [super init];
_thread = [thread retain];
|
︙ | | |
Modified src/exceptions/OFThreadStartFailedException.m
from [54005830f8]
to [1d3efa4031].
︙ | | |
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
|
-
-
+
+
-
-
-
-
-
-
-
+
-
|
* 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 "macros.h"
@implementation OFThreadStartFailedException
+ (instancetype)exceptionWithThread: (OFThread*)thread
{
return [[[self alloc] initWithThread: thread] autorelease];
}
- init
{
@try {
[self doesNotRecognizeSelector: _cmd];
} @catch (id e) {
[self release];
@throw e;
}
OF_INVALID_INIT_METHOD
abort();
}
- initWithThread: (OFThread*)thread
{
self = [super init];
_thread = [thread retain];
|
︙ | | |
Modified src/exceptions/OFThreadStillRunningException.m
from [c77a91365a]
to [efe25e2243].
︙ | | |
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
|
-
-
+
+
-
-
-
-
-
-
-
+
-
|
* 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 "macros.h"
@implementation OFThreadStillRunningException
+ (instancetype)exceptionWithThread: (OFThread*)thread
{
return [[[self alloc] initWithThread: thread] autorelease];
}
- init
{
@try {
[self doesNotRecognizeSelector: _cmd];
} @catch (id e) {
[self release];
@throw e;
}
OF_INVALID_INIT_METHOD
abort();
}
- initWithThread: (OFThread*)thread
{
self = [super init];
_thread = [thread retain];
|
︙ | | |
Modified src/exceptions/OFUnboundNamespaceException.m
from [833fbe89dd]
to [619f0e9635].
︙ | | |
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
|
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
|
-
-
+
-
-
-
-
-
-
-
+
-
|
* Public License, either version 2 or 3, which can be found in the file
* LICENSE.GPLv2 or LICENSE.GPLv3 respectively included in the packaging of this
* file.
*/
#include "config.h"
#include <stdlib.h>
#import "OFUnboundNamespaceException.h"
#import "OFString.h"
#import "OFXMLElement.h"
#import "common.h"
#import "macros.h"
@implementation OFUnboundNamespaceException
+ (instancetype)exceptionWithNamespace: (OFString*)namespace
element: (OFXMLElement*)element
{
return [[[self alloc] initWithNamespace: namespace
element: element] autorelease];
}
- init
{
@try {
[self doesNotRecognizeSelector: _cmd];
} @catch (id e) {
[self release];
@throw e;
}
OF_INVALID_INIT_METHOD
abort();
}
- initWithNamespace: (OFString*)namespace
element: (OFXMLElement*)element
{
self = [super init];
|
︙ | | |
Modified src/exceptions/OFUnboundPrefixException.m
from [b76d254da0]
to [d2e7b8311f].
︙ | | |
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
|
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
|
-
-
+
-
-
-
-
-
-
-
+
-
|
* Public License, either version 2 or 3, which can be found in the file
* LICENSE.GPLv2 or LICENSE.GPLv3 respectively included in the packaging of this
* file.
*/
#include "config.h"
#include <stdlib.h>
#import "OFUnboundPrefixException.h"
#import "OFString.h"
#import "OFXMLParser.h"
#import "common.h"
#import "macros.h"
@implementation OFUnboundPrefixException
+ (instancetype)exceptionWithPrefix: (OFString*)prefix
parser: (OFXMLParser*)parser
{
return [[[self alloc] initWithPrefix: prefix
parser: parser] autorelease];
}
- init
{
@try {
[self doesNotRecognizeSelector: _cmd];
} @catch (id e) {
[self release];
@throw e;
}
OF_INVALID_INIT_METHOD
abort();
}
- initWithPrefix: (OFString*)prefix
parser: (OFXMLParser*)parser
{
self = [super init];
|
︙ | | |
Modified src/exceptions/OFUnsupportedProtocolException.m
from [d7d8e84a71]
to [0b9f3004d5].
︙ | | |
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
|
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
|
-
-
+
-
-
-
-
-
-
-
+
-
|
* Public License, either version 2 or 3, which can be found in the file
* LICENSE.GPLv2 or LICENSE.GPLv3 respectively included in the packaging of this
* file.
*/
#include "config.h"
#include <stdlib.h>
#import "OFUnsupportedProtocolException.h"
#import "OFString.h"
#import "OFURL.h"
#import "common.h"
#import "macros.h"
@implementation OFUnsupportedProtocolException
+ (instancetype)exceptionWithURL: (OFURL*)url
{
return [[[self alloc] initWithURL: url] autorelease];
}
- init
{
@try {
[self doesNotRecognizeSelector: _cmd];
} @catch (id e) {
[self release];
@throw e;
}
OF_INVALID_INIT_METHOD
abort();
}
- initWithURL: (OFURL*)URL
{
self = [super init];
@try {
|
︙ | | |
Modified src/exceptions/OFUnsupportedVersionException.m
from [efe3ce39e5]
to [510c431b8a].
︙ | | |
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
|
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
|
-
-
+
-
-
-
-
-
-
-
+
-
|
* Public License, either version 2 or 3, which can be found in the file
* LICENSE.GPLv2 or LICENSE.GPLv3 respectively included in the packaging of this
* file.
*/
#include "config.h"
#include <stdlib.h>
#import "OFUnsupportedVersionException.h"
#import "OFString.h"
#import "common.h"
#import "macros.h"
@implementation OFUnsupportedVersionException
+ (instancetype)exceptionWithVersion: (OFString*)version
{
return [[[self alloc] initWithVersion: version] autorelease];
}
- init
{
@try {
[self doesNotRecognizeSelector: _cmd];
} @catch (id e) {
[self release];
@throw e;
}
OF_INVALID_INIT_METHOD
abort();
}
- initWithVersion: (OFString*)version
{
self = [super init];
@try {
|
︙ | | |
Modified src/macros.h
from [086b67ded9]
to [0bb7e4c204].
︙ | | |
127
128
129
130
131
132
133
134
135
136
137
138
139
140
|
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
|
+
+
+
+
+
+
+
+
+
+
|
extern void objc_setProperty(id, SEL, ptrdiff_t, id, BOOL, signed char);
#define OF_IVAR_OFFSET(ivar) ((intptr_t)&ivar - (intptr_t)self)
#define OF_GETTER(ivar, atomic) \
return objc_getProperty(self, _cmd, OF_IVAR_OFFSET(ivar), atomic);
#define OF_SETTER(ivar, value, atomic, copy) \
objc_setProperty(self, _cmd, OF_IVAR_OFFSET(ivar), value, atomic, copy);
#define OF_INVALID_INIT_METHOD \
@try { \
[self doesNotRecognizeSelector: _cmd]; \
} @catch (id e) { \
[self release]; \
@throw e; \
} \
\
abort();
#ifdef OF_HAVE_CLASS_EXTENSIONS
# define OF_PRIVATE_CATEGORY
#else
# define OF_PRIVATE_CATEGORY Private
#endif
|
︙ | | |