Modified src/Makefile
from [c748eda942]
to [29dc8f24f3].
︙ | | | ︙ | |
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
|
OFBase64.m \
OFBitSetCharacterSet.m \
OFBytesValue.m \
OFCRC16.m \
OFCRC32.m \
OFConcreteArray.m \
OFConcreteColor.m \
OFConcreteData.m \
OFConcreteMutableArray.m \
OFConcreteMutableData.m \
OFConcreteSubarray.m \
OFCountedMapTableSet.m \
OFEmbeddedIRIHandler.m \
OFHuffmanTree.m \
OFINIFileSettings.m \
OFInvertedCharacterSet.m \
OFLHADecompressingStream.m \
OFMapTableDictionary.m \
OFMapTableSet.m \
OFMutableMapTableDictionary.m \
OFMutableMapTableSet.m \
OFMutableUTF8String.m \
OFNonretainedObjectValue.m \
OFPointValue.m \
OFPointerValue.m \
OFRangeCharacterSet.m \
OFRangeValue.m \
OFRectValue.m \
|
>
>
>
>
>
<
<
<
<
<
|
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
|
OFBase64.m \
OFBitSetCharacterSet.m \
OFBytesValue.m \
OFCRC16.m \
OFCRC32.m \
OFConcreteArray.m \
OFConcreteColor.m \
OFConcreteCountedSet.m \
OFConcreteData.m \
OFConcreteDictionary.m \
OFConcreteMutableArray.m \
OFConcreteMutableData.m \
OFConcreteMutableDictionary.m \
OFConcreteMutableSet.m \
OFConcreteSet.m \
OFConcreteSubarray.m \
OFEmbeddedIRIHandler.m \
OFHuffmanTree.m \
OFINIFileSettings.m \
OFInvertedCharacterSet.m \
OFLHADecompressingStream.m \
OFMutableUTF8String.m \
OFNonretainedObjectValue.m \
OFPointValue.m \
OFPointerValue.m \
OFRangeCharacterSet.m \
OFRangeValue.m \
OFRectValue.m \
|
︙ | | | ︙ | |
Modified src/OFColor.m
from [f189109e30]
to [a2a90d4c7a].
︙ | | | ︙ | |
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
|
#import "OFOnce.h"
#import "OFString.h"
#import "OFTaggedPointerColor.h"
@interface OFColorSingleton: OFConcreteColor
@end
@interface OFColorPlaceholder: OFColor
@end
static struct {
Class isa;
} placeholder;
#ifdef OF_OBJFW_RUNTIME
static const float allowedImprecision = 0.0000001;
#endif
@implementation OFColorPlaceholder
- (instancetype)initWithRed: (float)red
green: (float)green
blue: (float)blue
alpha: (float)alpha
{
#ifdef OF_OBJFW_RUNTIME
uint8_t redInt = nearbyintf(red * 255);
|
|
|
|
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
|
#import "OFOnce.h"
#import "OFString.h"
#import "OFTaggedPointerColor.h"
@interface OFColorSingleton: OFConcreteColor
@end
@interface OFPlaceholderColor: OFColor
@end
static struct {
Class isa;
} placeholder;
#ifdef OF_OBJFW_RUNTIME
static const float allowedImprecision = 0.0000001;
#endif
@implementation OFPlaceholderColor
- (instancetype)initWithRed: (float)red
green: (float)green
blue: (float)blue
alpha: (float)alpha
{
#ifdef OF_OBJFW_RUNTIME
uint8_t redInt = nearbyintf(red * 255);
|
︙ | | | ︙ | |
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
|
OF_SINGLETON_METHODS
@end
@implementation OFColor
+ (void)initialize
{
if (self == [OFColor class])
object_setClass((id)&placeholder, [OFColorPlaceholder class]);
}
+ (instancetype)alloc
{
if (self == [OFColor class])
return (id)&placeholder;
|
|
|
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
|
OF_SINGLETON_METHODS
@end
@implementation OFColor
+ (void)initialize
{
if (self == [OFColor class])
object_setClass((id)&placeholder, [OFPlaceholderColor class]);
}
+ (instancetype)alloc
{
if (self == [OFColor class])
return (id)&placeholder;
|
︙ | | | ︙ | |
Renamed and modified
src/OFCountedMapTableSet.h
[05ce680e3e]
to src/OFConcreteCountedSet.h
[df72e24841].
︙ | | | ︙ | |
15
16
17
18
19
20
21
22
23
24
25
26
27
28
|
#import "OFCountedSet.h"
OF_ASSUME_NONNULL_BEGIN
@class OFMapTable;
@interface OFCountedMapTableSet: OFCountedSet
{
OFMapTable *_mapTable;
}
@end
OF_ASSUME_NONNULL_END
|
|
|
15
16
17
18
19
20
21
22
23
24
25
26
27
28
|
#import "OFCountedSet.h"
OF_ASSUME_NONNULL_BEGIN
@class OFMapTable;
@interface OFConcreteCountedSet: OFCountedSet
{
OFMapTable *_mapTable;
}
@end
OF_ASSUME_NONNULL_END
|
Renamed and modified
src/OFCountedMapTableSet.m
[7a63d8437b]
to src/OFConcreteCountedSet.m
[b73b47c42b].
︙ | | | ︙ | |
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
|
* 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 "OFCountedMapTableSet.h"
#import "OFArray.h"
#import "OFMapTable.h"
#import "OFMutableMapTableSet.h"
#import "OFString.h"
#import "OFXMLAttribute.h"
#import "OFInvalidArgumentException.h"
#import "OFInvalidFormatException.h"
#import "OFEnumerationMutationException.h"
#import "OFOutOfRangeException.h"
@implementation OFCountedMapTableSet
+ (void)initialize
{
if (self == [OFCountedMapTableSet class])
[self inheritMethodsFromClass: [OFMutableMapTableSet class]];
}
- (instancetype)initWithSet: (OFSet *)set
{
self = [self init];
@try {
|
|
|
|
|
|
|
|
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
|
* 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 "OFConcreteCountedSet.h"
#import "OFArray.h"
#import "OFConcreteMutableSet.h"
#import "OFMapTable.h"
#import "OFString.h"
#import "OFXMLAttribute.h"
#import "OFInvalidArgumentException.h"
#import "OFInvalidFormatException.h"
#import "OFEnumerationMutationException.h"
#import "OFOutOfRangeException.h"
@implementation OFConcreteCountedSet
+ (void)initialize
{
if (self == [OFConcreteCountedSet class])
[self inheritMethodsFromClass: [OFConcreteMutableSet class]];
}
- (instancetype)initWithSet: (OFSet *)set
{
self = [self init];
@try {
|
︙ | | | ︙ | |
Renamed and modified
src/OFMapTableDictionary.h
[f2de5e0f29]
to src/OFConcreteDictionary.h
[983e5c5cf8].
︙ | | | ︙ | |
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
|
#import "OFDictionary.h"
OF_ASSUME_NONNULL_BEGIN
@class OFMapTable;
@class OFMapTableEnumerator;
@interface OFMapTableDictionary: OFDictionary
{
OFMapTable *_mapTable;
}
- (instancetype)initWithCapacity: (size_t)capacity;
@end
OF_ASSUME_NONNULL_END
|
|
|
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
|
#import "OFDictionary.h"
OF_ASSUME_NONNULL_BEGIN
@class OFMapTable;
@class OFMapTableEnumerator;
@interface OFConcreteDictionary: OFDictionary
{
OFMapTable *_mapTable;
}
- (instancetype)initWithCapacity: (size_t)capacity;
@end
OF_ASSUME_NONNULL_END
|
Renamed and modified
src/OFMapTableDictionary.m
[7d4c6241d2]
to src/OFConcreteDictionary.m
[8171774da2].
︙ | | | ︙ | |
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
|
* 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 "OFMapTableDictionary.h"
#import "OFArray.h"
#import "OFMapTable+Private.h"
#import "OFMapTable.h"
#import "OFMutableMapTableDictionary.h"
#import "OFString.h"
#import "OFEnumerationMutationException.h"
#import "OFInvalidArgumentException.h"
#import "OFInvalidFormatException.h"
static void *
|
|
>
<
|
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
|
* 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 "OFConcreteDictionary.h"
#import "OFArray.h"
#import "OFConcreteMutableDictionary.h"
#import "OFMapTable+Private.h"
#import "OFMapTable.h"
#import "OFString.h"
#import "OFEnumerationMutationException.h"
#import "OFInvalidArgumentException.h"
#import "OFInvalidFormatException.h"
static void *
|
︙ | | | ︙ | |
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
|
static const OFMapTableFunctions objectFunctions = {
.retain = retain,
.release = release,
.hash = hash,
.equal = equal
};
@implementation OFMapTableDictionary
- (instancetype)init
{
return [self initWithCapacity: 0];
}
- (instancetype)initWithCapacity: (size_t)capacity
{
|
|
|
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
|
static const OFMapTableFunctions objectFunctions = {
.retain = retain,
.release = release,
.hash = hash,
.equal = equal
};
@implementation OFConcreteDictionary
- (instancetype)init
{
return [self initWithCapacity: 0];
}
- (instancetype)initWithCapacity: (size_t)capacity
{
|
︙ | | | ︙ | |
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
|
- (instancetype)initWithDictionary: (OFDictionary *)dictionary
{
size_t count;
if (dictionary == nil)
return [self init];
if ([dictionary isKindOfClass: [OFMapTableDictionary class]] ||
[dictionary isKindOfClass: [OFMutableMapTableDictionary class]]) {
self = [super init];
@try {
OFMapTableDictionary *dictionary_ =
(OFMapTableDictionary *)dictionary;
_mapTable = [dictionary_->_mapTable copy];
} @catch (id e) {
[self release];
@throw e;
}
|
|
|
|
|
|
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
|
- (instancetype)initWithDictionary: (OFDictionary *)dictionary
{
size_t count;
if (dictionary == nil)
return [self init];
if ([dictionary isKindOfClass: [OFConcreteDictionary class]] ||
[dictionary isKindOfClass: [OFConcreteMutableDictionary class]]) {
self = [super init];
@try {
OFConcreteDictionary *dictionary_ =
(OFConcreteDictionary *)dictionary;
_mapTable = [dictionary_->_mapTable copy];
} @catch (id e) {
[self release];
@throw e;
}
|
︙ | | | ︙ | |
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
|
- (size_t)count
{
return _mapTable.count;
}
- (bool)isEqual: (id)object
{
OFMapTableDictionary *dictionary;
if (object == self)
return true;
if (![object isKindOfClass: [OFMapTableDictionary class]] &&
![object isKindOfClass: [OFMutableMapTableDictionary class]])
return [super isEqual: object];
dictionary = (OFMapTableDictionary *)object;
return [dictionary->_mapTable isEqual: _mapTable];
}
- (bool)containsObject: (id)object
{
return [_mapTable containsObject: object];
|
|
|
|
|
|
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
|
- (size_t)count
{
return _mapTable.count;
}
- (bool)isEqual: (id)object
{
OFConcreteDictionary *dictionary;
if (object == self)
return true;
if (![object isKindOfClass: [OFConcreteDictionary class]] &&
![object isKindOfClass: [OFConcreteMutableDictionary class]])
return [super isEqual: object];
dictionary = (OFConcreteDictionary *)object;
return [dictionary->_mapTable isEqual: _mapTable];
}
- (bool)containsObject: (id)object
{
return [_mapTable containsObject: object];
|
︙ | | | ︙ | |
Renamed and modified
src/OFMutableMapTableDictionary.h
[56771d5148]
to src/OFConcreteMutableDictionary.h
[20db8412b1].
︙ | | | ︙ | |
15
16
17
18
19
20
21
22
23
24
25
26
27
28
|
#import "OFDictionary.h"
OF_ASSUME_NONNULL_BEGIN
@class OFMapTable;
@interface OFMutableMapTableDictionary: OFMutableDictionary
{
OFMapTable *_mapTable;
}
@end
OF_ASSUME_NONNULL_END
|
|
|
15
16
17
18
19
20
21
22
23
24
25
26
27
28
|
#import "OFDictionary.h"
OF_ASSUME_NONNULL_BEGIN
@class OFMapTable;
@interface OFConcreteMutableDictionary: OFMutableDictionary
{
OFMapTable *_mapTable;
}
@end
OF_ASSUME_NONNULL_END
|
Renamed and modified
src/OFMutableMapTableDictionary.m
[0658abc2dc]
to src/OFConcreteMutableDictionary.m
[728a3cf89d].
︙ | | | ︙ | |
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
|
* file.
*/
#include "config.h"
#include <string.h>
#import "OFMutableMapTableDictionary.h"
#import "OFMapTable.h"
#import "OFMapTableDictionary.h"
#import "OFEnumerationMutationException.h"
#import "OFOutOfRangeException.h"
@implementation OFMutableMapTableDictionary
+ (void)initialize
{
if (self == [OFMutableMapTableDictionary class])
[self inheritMethodsFromClass: [OFMapTableDictionary class]];
}
- (void)setObject: (id)object forKey: (id)key
{
[_mapTable setObject: object forKey: key];
}
|
|
|
|
|
|
|
|
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
|
* file.
*/
#include "config.h"
#include <string.h>
#import "OFConcreteMutableDictionary.h"
#import "OFConcreteDictionary.h"
#import "OFMapTable.h"
#import "OFEnumerationMutationException.h"
#import "OFOutOfRangeException.h"
@implementation OFConcreteMutableDictionary
+ (void)initialize
{
if (self == [OFConcreteMutableDictionary class])
[self inheritMethodsFromClass: [OFConcreteDictionary class]];
}
- (void)setObject: (id)object forKey: (id)key
{
[_mapTable setObject: object forKey: key];
}
|
︙ | | | ︙ | |
59
60
61
62
63
64
65
66
67
68
|
exceptionWithObject: self];
}
}
#endif
- (void)makeImmutable
{
object_setClass(self, [OFMapTableDictionary class]);
}
@end
|
|
|
59
60
61
62
63
64
65
66
67
68
|
exceptionWithObject: self];
}
}
#endif
- (void)makeImmutable
{
object_setClass(self, [OFConcreteDictionary class]);
}
@end
|
Renamed and modified
src/OFMutableMapTableSet.h
[4eae6d1c54]
to src/OFConcreteMutableSet.h
[e35eb70f3b].
︙ | | | ︙ | |
15
16
17
18
19
20
21
22
23
24
25
26
27
28
|
#import "OFMutableSet.h"
OF_ASSUME_NONNULL_BEGIN
@class OFMapTable;
@interface OFMutableMapTableSet: OFMutableSet
{
OFMapTable *_mapTable;
}
@end
OF_ASSUME_NONNULL_END
|
|
|
15
16
17
18
19
20
21
22
23
24
25
26
27
28
|
#import "OFMutableSet.h"
OF_ASSUME_NONNULL_BEGIN
@class OFMapTable;
@interface OFConcreteMutableSet: OFMutableSet
{
OFMapTable *_mapTable;
}
@end
OF_ASSUME_NONNULL_END
|
Renamed and modified
src/OFMutableMapTableSet.m
[3dd4e2c006]
to src/OFConcreteMutableSet.m
[da1e112dc4].
︙ | | | ︙ | |
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
|
* 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 "OFMutableMapTableSet.h"
#import "OFMapTableSet.h"
#import "OFMapTable.h"
@implementation OFMutableMapTableSet
+ (void)initialize
{
if (self == [OFMutableMapTableSet class])
[self inheritMethodsFromClass: [OFMapTableSet class]];
}
- (void)addObject: (id)object
{
[_mapTable setObject: (void *)1 forKey: object];
}
- (void)removeObject: (id)object
{
[_mapTable removeObjectForKey: object];
}
- (void)removeAllObjects
{
[_mapTable removeAllObjects];
}
- (void)makeImmutable
{
object_setClass(self, [OFMapTableSet class]);
}
@end
|
|
|
|
|
|
|
|
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
|
* 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 "OFConcreteMutableSet.h"
#import "OFConcreteSet.h"
#import "OFMapTable.h"
@implementation OFConcreteMutableSet
+ (void)initialize
{
if (self == [OFConcreteMutableSet class])
[self inheritMethodsFromClass: [OFConcreteSet class]];
}
- (void)addObject: (id)object
{
[_mapTable setObject: (void *)1 forKey: object];
}
- (void)removeObject: (id)object
{
[_mapTable removeObjectForKey: object];
}
- (void)removeAllObjects
{
[_mapTable removeAllObjects];
}
- (void)makeImmutable
{
object_setClass(self, [OFConcreteSet class]);
}
@end
|
Renamed and modified
src/OFMapTableSet.h
[98f1d6ac4b]
to src/OFConcreteSet.h
[87d40dbfde].
︙ | | | ︙ | |
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
|
#import "OFSet.h"
OF_ASSUME_NONNULL_BEGIN
@class OFMapTable;
@interface OFMapTableSet: OFSet
{
OFMapTable *_mapTable;
}
- (instancetype)initWithCapacity: (size_t)capacity;
@end
OF_ASSUME_NONNULL_END
|
|
|
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
|
#import "OFSet.h"
OF_ASSUME_NONNULL_BEGIN
@class OFMapTable;
@interface OFConcreteSet: OFSet
{
OFMapTable *_mapTable;
}
- (instancetype)initWithCapacity: (size_t)capacity;
@end
OF_ASSUME_NONNULL_END
|
Renamed and modified
src/OFMapTableSet.m
[c087e53711]
to src/OFConcreteSet.m
[86fb079ff7].
︙ | | | ︙ | |
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
|
* 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 "OFMapTableSet.h"
#import "OFArray.h"
#import "OFCountedMapTableSet.h"
#import "OFMapTable.h"
#import "OFMapTable+Private.h"
#import "OFMutableMapTableSet.h"
#import "OFString.h"
#import "OFInvalidArgumentException.h"
#import "OFEnumerationMutationException.h"
static void *
retain(void *object)
|
|
|
|
|
|
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
|
* 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 "OFConcreteSet.h"
#import "OFArray.h"
#import "OFConcreteCountedSet.h"
#import "OFConcreteMutableSet.h"
#import "OFMapTable+Private.h"
#import "OFMapTable.h"
#import "OFString.h"
#import "OFInvalidArgumentException.h"
#import "OFEnumerationMutationException.h"
static void *
retain(void *object)
|
︙ | | | ︙ | |
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
|
.retain = retain,
.release = release,
.hash = hash,
.equal = equal
};
static const OFMapTableFunctions objectFunctions = { NULL };
@implementation OFMapTableSet
- (instancetype)init
{
return [self initWithCapacity: 0];
}
- (instancetype)initWithCapacity: (size_t)capacity
{
|
|
|
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
|
.retain = retain,
.release = release,
.hash = hash,
.equal = equal
};
static const OFMapTableFunctions objectFunctions = { NULL };
@implementation OFConcreteSet
- (instancetype)init
{
return [self initWithCapacity: 0];
}
- (instancetype)initWithCapacity: (size_t)capacity
{
|
︙ | | | ︙ | |
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
|
return false;
return ([_mapTable objectForKey: object] != nil);
}
- (bool)isEqual: (id)object
{
OFMapTableSet *set;
if (object == self)
return true;
if (![object isKindOfClass: [OFMapTableSet class]] &&
![object isKindOfClass: [OFMutableMapTableSet class]] &&
![object isKindOfClass: [OFCountedMapTableSet class]])
return [super isEqual: object];
set = object;
return [set->_mapTable isEqual: _mapTable];
}
|
|
|
|
|
|
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
|
return false;
return ([_mapTable objectForKey: object] != nil);
}
- (bool)isEqual: (id)object
{
OFConcreteSet *set;
if (object == self)
return true;
if (![object isKindOfClass: [OFConcreteSet class]] &&
![object isKindOfClass: [OFConcreteMutableSet class]] &&
![object isKindOfClass: [OFConcreteCountedSet class]])
return [super isEqual: object];
set = object;
return [set->_mapTable isEqual: _mapTable];
}
|
︙ | | | ︙ | |
Modified src/OFCountedSet.m
from [8d16a5d34a]
to [3de39a28c5].
︙ | | | ︙ | |
14
15
16
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
81
82
83
84
85
86
87
88
|
*/
#include "config.h"
#include <stdlib.h>
#import "OFCountedSet.h"
#import "OFCountedMapTableSet.h"
#import "OFNumber.h"
#import "OFString.h"
static struct {
Class isa;
} placeholder;
@interface OFCountedSetPlaceholder: OFCountedSet
@end
@implementation OFCountedSetPlaceholder
- (instancetype)init
{
return (id)[[OFCountedMapTableSet alloc] init];
}
- (instancetype)initWithSet: (OFSet *)set
{
return (id)[[OFCountedMapTableSet alloc] initWithSet: set];
}
- (instancetype)initWithArray: (OFArray *)array
{
return (id)[[OFCountedMapTableSet alloc] initWithArray: array];
}
- (instancetype)initWithObjects: (id)firstObject, ...
{
id ret;
va_list arguments;
va_start(arguments, firstObject);
ret = [[OFCountedMapTableSet alloc] initWithObject: firstObject
arguments: arguments];
va_end(arguments);
return ret;
}
- (instancetype)initWithObjects: (id const *)objects count: (size_t)count
{
return (id)[[OFCountedMapTableSet alloc] initWithObjects: objects
count: count];
}
- (instancetype)initWithObject: (id)firstObject arguments: (va_list)arguments
{
return (id)[[OFCountedMapTableSet alloc] initWithObject: firstObject
arguments: arguments];
}
OF_SINGLETON_METHODS
@end
@implementation OFCountedSet
+ (void)initialize
{
if (self == [OFCountedSet class])
object_setClass((id)&placeholder,
[OFCountedSetPlaceholder class]);
}
+ (instancetype)alloc
{
if (self == [OFCountedSet class])
return (id)&placeholder;
|
|
|
|
|
|
|
|
|
|
|
|
14
15
16
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
81
82
83
84
85
86
87
88
|
*/
#include "config.h"
#include <stdlib.h>
#import "OFCountedSet.h"
#import "OFConcreteCountedSet.h"
#import "OFNumber.h"
#import "OFString.h"
static struct {
Class isa;
} placeholder;
@interface OFPlaceholderCountedSet: OFCountedSet
@end
@implementation OFPlaceholderCountedSet
- (instancetype)init
{
return (id)[[OFConcreteCountedSet alloc] init];
}
- (instancetype)initWithSet: (OFSet *)set
{
return (id)[[OFConcreteCountedSet alloc] initWithSet: set];
}
- (instancetype)initWithArray: (OFArray *)array
{
return (id)[[OFConcreteCountedSet alloc] initWithArray: array];
}
- (instancetype)initWithObjects: (id)firstObject, ...
{
id ret;
va_list arguments;
va_start(arguments, firstObject);
ret = [[OFConcreteCountedSet alloc] initWithObject: firstObject
arguments: arguments];
va_end(arguments);
return ret;
}
- (instancetype)initWithObjects: (id const *)objects count: (size_t)count
{
return (id)[[OFConcreteCountedSet alloc] initWithObjects: objects
count: count];
}
- (instancetype)initWithObject: (id)firstObject arguments: (va_list)arguments
{
return (id)[[OFConcreteCountedSet alloc] initWithObject: firstObject
arguments: arguments];
}
OF_SINGLETON_METHODS
@end
@implementation OFCountedSet
+ (void)initialize
{
if (self == [OFCountedSet class])
object_setClass((id)&placeholder,
[OFPlaceholderCountedSet class]);
}
+ (instancetype)alloc
{
if (self == [OFCountedSet class])
return (id)&placeholder;
|
︙ | | | ︙ | |
Modified src/OFData.m
from [f7d95004e7]
to [4738b91ed8].
︙ | | | ︙ | |
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
|
#import "OFTruncatedDataException.h"
#import "OFUnsupportedProtocolException.h"
static struct {
Class isa;
} placeholder;
@interface OFDataPlaceholder: OFString
@end
/* References for static linking */
void
_references_to_categories_of_OFData(void)
{
_OFData_CryptographicHashing_reference = 1;
_OFData_MessagePackParsing_reference = 1;
}
@implementation OFDataPlaceholder
- (instancetype)init
{
return (id)[[OFConcreteData alloc] init];
}
- (instancetype)initWithItemSize: (size_t)itemSize
{
|
|
|
|
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
|
#import "OFTruncatedDataException.h"
#import "OFUnsupportedProtocolException.h"
static struct {
Class isa;
} placeholder;
@interface OFPlaceholderData: OFString
@end
/* References for static linking */
void
_references_to_categories_of_OFData(void)
{
_OFData_CryptographicHashing_reference = 1;
_OFData_MessagePackParsing_reference = 1;
}
@implementation OFPlaceholderData
- (instancetype)init
{
return (id)[[OFConcreteData alloc] init];
}
- (instancetype)initWithItemSize: (size_t)itemSize
{
|
︙ | | | ︙ | |
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
|
OF_SINGLETON_METHODS
@end
@implementation OFData
+ (void)initialize
{
if (self == [OFData class])
object_setClass((id)&placeholder, [OFDataPlaceholder class]);
}
+ (instancetype)alloc
{
if (self == [OFData class])
return (id)&placeholder;
|
|
|
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
|
OF_SINGLETON_METHODS
@end
@implementation OFData
+ (void)initialize
{
if (self == [OFData class])
object_setClass((id)&placeholder, [OFPlaceholderData class]);
}
+ (instancetype)alloc
{
if (self == [OFData class])
return (id)&placeholder;
|
︙ | | | ︙ | |
Modified src/OFDate.m
from [e2edddf9dc]
to [468bf23684].
︙ | | | ︙ | |
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
|
#import "OFOutOfRangeException.h"
#if defined(OF_AMIGAOS_M68K) || defined(OF_MINT)
/* amiga-gcc and freemint-gcc do not have trunc() */
# define trunc(x) ((int64_t)(x))
#endif
@interface OFDatePlaceholder: OFDate
@end
@interface OFConcreteDate: OFDate
{
OFTimeInterval _seconds;
}
@end
|
|
|
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
|
#import "OFOutOfRangeException.h"
#if defined(OF_AMIGAOS_M68K) || defined(OF_MINT)
/* amiga-gcc and freemint-gcc do not have trunc() */
# define trunc(x) ((int64_t)(x))
#endif
@interface OFPlaceholderDate: OFDate
@end
@interface OFConcreteDate: OFDate
{
OFTimeInterval _seconds;
}
@end
|
︙ | | | ︙ | |
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
|
return seconds;
}
@implementation OFDateSingleton
OF_SINGLETON_METHODS
@end
@implementation OFDatePlaceholder
#ifdef __clang__
/* We intentionally don't call into super, so silence the warning. */
# pragma clang diagnostic push
# pragma clang diagnostic ignored "-Wunknown-pragmas"
# pragma clang diagnostic ignored "-Wobjc-designated-initializers"
#endif
- (instancetype)initWithTimeIntervalSince1970: (OFTimeInterval)seconds
|
|
|
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
|
return seconds;
}
@implementation OFDateSingleton
OF_SINGLETON_METHODS
@end
@implementation OFPlaceholderDate
#ifdef __clang__
/* We intentionally don't call into super, so silence the warning. */
# pragma clang diagnostic push
# pragma clang diagnostic ignored "-Wunknown-pragmas"
# pragma clang diagnostic ignored "-Wobjc-designated-initializers"
#endif
- (instancetype)initWithTimeIntervalSince1970: (OFTimeInterval)seconds
|
︙ | | | ︙ | |
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
|
#ifdef OF_WINDOWS
HMODULE module;
#endif
if (self != [OFDate class])
return;
object_setClass((id)&placeholder, [OFDatePlaceholder class]);
#if (!defined(HAVE_GMTIME_R) || !defined(HAVE_LOCALTIME_R)) && \
defined(OF_HAVE_THREADS)
mutex = [[OFMutex alloc] init];
atexit(releaseMutex);
#endif
|
|
|
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
|
#ifdef OF_WINDOWS
HMODULE module;
#endif
if (self != [OFDate class])
return;
object_setClass((id)&placeholder, [OFPlaceholderDate class]);
#if (!defined(HAVE_GMTIME_R) || !defined(HAVE_LOCALTIME_R)) && \
defined(OF_HAVE_THREADS)
mutex = [[OFMutex alloc] init];
atexit(releaseMutex);
#endif
|
︙ | | | ︙ | |
Modified src/OFDictionary.m
from [32e0526264]
to [8b606ffec2].
︙ | | | ︙ | |
16
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
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
|
#include "config.h"
#include <stdlib.h>
#import "OFDictionary.h"
#import "OFArray.h"
#import "OFCharacterSet.h"
#import "OFData.h"
#import "OFEnumerator.h"
#import "OFMapTableDictionary.h"
#import "OFString.h"
#import "OFInvalidArgumentException.h"
#import "OFOutOfRangeException.h"
#import "OFUndefinedKeyException.h"
static struct {
Class isa;
} placeholder;
@interface OFDictionary ()
- (OFString *)
of_JSONRepresentationWithOptions: (OFJSONRepresentationOptions)options
depth: (size_t)depth;
@end
@interface OFDictionaryPlaceholder: OFDictionary
@end
OF_DIRECT_MEMBERS
@interface OFDictionaryObjectEnumerator: OFEnumerator
{
OFDictionary *_dictionary;
OFEnumerator *_keyEnumerator;
}
- (instancetype)initWithDictionary: (OFDictionary *)dictionary;
@end
@implementation OFDictionaryPlaceholder
- (instancetype)init
{
return (id)[[OFMapTableDictionary alloc] init];
}
- (instancetype)initWithDictionary: (OFDictionary *)dictionary
{
return (id)[[OFMapTableDictionary alloc]
initWithDictionary: dictionary];
}
- (instancetype)initWithObject: (id)object forKey: (id)key
{
return (id)[[OFMapTableDictionary alloc] initWithObject: object
forKey: key];
}
- (instancetype)initWithObjects: (OFArray *)objects forKeys: (OFArray *)keys
{
return (id)[[OFMapTableDictionary alloc] initWithObjects: objects
forKeys: keys];
}
- (instancetype)initWithObjects: (id const *)objects
forKeys: (id const *)keys
count: (size_t)count
{
return (id)[[OFMapTableDictionary alloc] initWithObjects: objects
forKeys: keys
count: count];
}
- (instancetype)initWithKeysAndObjects: (id <OFCopying>)firstKey, ...
{
id ret;
va_list arguments;
va_start(arguments, firstKey);
ret = [[OFMapTableDictionary alloc] initWithKey: firstKey
arguments: arguments];
va_end(arguments);
return ret;
}
- (instancetype)initWithKey: (id <OFCopying>)firstKey
arguments: (va_list)arguments
{
return (id)[[OFMapTableDictionary alloc] initWithKey: firstKey
arguments: arguments];
}
OF_SINGLETON_METHODS
@end
@implementation OFDictionary
+ (void)initialize
{
if (self == [OFDictionary class])
object_setClass((id)&placeholder,
[OFDictionaryPlaceholder class]);
}
+ (instancetype)alloc
{
if (self == [OFDictionary class])
return (id)&placeholder;
|
>
<
|
|
|
|
|
|
|
|
|
|
|
16
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
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
|
#include "config.h"
#include <stdlib.h>
#import "OFDictionary.h"
#import "OFArray.h"
#import "OFCharacterSet.h"
#import "OFConcreteDictionary.h"
#import "OFData.h"
#import "OFEnumerator.h"
#import "OFString.h"
#import "OFInvalidArgumentException.h"
#import "OFOutOfRangeException.h"
#import "OFUndefinedKeyException.h"
static struct {
Class isa;
} placeholder;
@interface OFDictionary ()
- (OFString *)
of_JSONRepresentationWithOptions: (OFJSONRepresentationOptions)options
depth: (size_t)depth;
@end
@interface OFPlaceholderDictionary: OFDictionary
@end
OF_DIRECT_MEMBERS
@interface OFDictionaryObjectEnumerator: OFEnumerator
{
OFDictionary *_dictionary;
OFEnumerator *_keyEnumerator;
}
- (instancetype)initWithDictionary: (OFDictionary *)dictionary;
@end
@implementation OFPlaceholderDictionary
- (instancetype)init
{
return (id)[[OFConcreteDictionary alloc] init];
}
- (instancetype)initWithDictionary: (OFDictionary *)dictionary
{
return (id)[[OFConcreteDictionary alloc]
initWithDictionary: dictionary];
}
- (instancetype)initWithObject: (id)object forKey: (id)key
{
return (id)[[OFConcreteDictionary alloc] initWithObject: object
forKey: key];
}
- (instancetype)initWithObjects: (OFArray *)objects forKeys: (OFArray *)keys
{
return (id)[[OFConcreteDictionary alloc] initWithObjects: objects
forKeys: keys];
}
- (instancetype)initWithObjects: (id const *)objects
forKeys: (id const *)keys
count: (size_t)count
{
return (id)[[OFConcreteDictionary alloc] initWithObjects: objects
forKeys: keys
count: count];
}
- (instancetype)initWithKeysAndObjects: (id <OFCopying>)firstKey, ...
{
id ret;
va_list arguments;
va_start(arguments, firstKey);
ret = [[OFConcreteDictionary alloc] initWithKey: firstKey
arguments: arguments];
va_end(arguments);
return ret;
}
- (instancetype)initWithKey: (id <OFCopying>)firstKey
arguments: (va_list)arguments
{
return (id)[[OFConcreteDictionary alloc] initWithKey: firstKey
arguments: arguments];
}
OF_SINGLETON_METHODS
@end
@implementation OFDictionary
+ (void)initialize
{
if (self == [OFDictionary class])
object_setClass((id)&placeholder,
[OFPlaceholderDictionary class]);
}
+ (instancetype)alloc
{
if (self == [OFDictionary class])
return (id)&placeholder;
|
︙ | | | ︙ | |
Modified src/OFMutableArray.m
from [5bbb4e13e7]
to [6a1691417f].
︙ | | | ︙ | |
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
|
#import "OFInvalidArgumentException.h"
#import "OFOutOfRangeException.h"
static struct {
Class isa;
} placeholder;
@interface OFMutableArrayPlaceholder: OFMutableArray
@end
static void
quicksort(OFMutableArray *array, size_t left, size_t right,
OFCompareFunction compare, void *context, OFArraySortOptions options)
{
OFComparisonResult ascending, descending;
|
|
|
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
|
#import "OFInvalidArgumentException.h"
#import "OFOutOfRangeException.h"
static struct {
Class isa;
} placeholder;
@interface OFPlaceholderMutableArray: OFMutableArray
@end
static void
quicksort(OFMutableArray *array, size_t left, size_t right,
OFCompareFunction compare, void *context, OFArraySortOptions options)
{
OFComparisonResult ascending, descending;
|
︙ | | | ︙ | |
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
|
quicksort(array, left, i - 1, compare, context,
options);
left = i + 1;
}
}
@implementation OFMutableArrayPlaceholder
- (instancetype)init
{
return (id)[[OFConcreteMutableArray alloc] init];
}
- (instancetype)initWithCapacity: (size_t)capacity
{
|
|
|
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
|
quicksort(array, left, i - 1, compare, context,
options);
left = i + 1;
}
}
@implementation OFPlaceholderMutableArray
- (instancetype)init
{
return (id)[[OFConcreteMutableArray alloc] init];
}
- (instancetype)initWithCapacity: (size_t)capacity
{
|
︙ | | | ︙ | |
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
|
@end
@implementation OFMutableArray
+ (void)initialize
{
if (self == [OFMutableArray class])
object_setClass((id)&placeholder,
[OFMutableArrayPlaceholder class]);
}
+ (instancetype)alloc
{
if (self == [OFMutableArray class])
return (id)&placeholder;
|
|
|
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
|
@end
@implementation OFMutableArray
+ (void)initialize
{
if (self == [OFMutableArray class])
object_setClass((id)&placeholder,
[OFPlaceholderMutableArray class]);
}
+ (instancetype)alloc
{
if (self == [OFMutableArray class])
return (id)&placeholder;
|
︙ | | | ︙ | |
Modified src/OFMutableData.m
from [bd4ea52fa8]
to [eabfe1061f].
︙ | | | ︙ | |
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
|
#import "OFOutOfRangeException.h"
static struct {
Class isa;
} placeholder;
@interface OFMutableDataPlaceholder: OFMutableData
@end
@implementation OFMutableDataPlaceholder
- (instancetype)init
{
return (id)[[OFConcreteMutableData alloc] init];
}
- (instancetype)initWithItemSize: (size_t)itemSize
{
|
|
|
|
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
|
#import "OFOutOfRangeException.h"
static struct {
Class isa;
} placeholder;
@interface OFPlaceholderMutableData: OFMutableData
@end
@implementation OFPlaceholderMutableData
- (instancetype)init
{
return (id)[[OFConcreteMutableData alloc] init];
}
- (instancetype)initWithItemSize: (size_t)itemSize
{
|
︙ | | | ︙ | |
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
|
@end
@implementation OFMutableData
+ (void)initialize
{
if (self == [OFMutableData class])
object_setClass((id)&placeholder,
[OFMutableDataPlaceholder class]);
}
+ (instancetype)alloc
{
if (self == [OFMutableData class])
return (id)&placeholder;
|
|
|
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
|
@end
@implementation OFMutableData
+ (void)initialize
{
if (self == [OFMutableData class])
object_setClass((id)&placeholder,
[OFPlaceholderMutableData class]);
}
+ (instancetype)alloc
{
if (self == [OFMutableData class])
return (id)&placeholder;
|
︙ | | | ︙ | |
Modified src/OFMutableDictionary.m
from [6b2bb24001]
to [c24bbf1afd].
︙ | | | ︙ | |
13
14
15
16
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
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
|
* file.
*/
#include "config.h"
#include <stdlib.h>
#import "OFMutableMapTableDictionary.h"
#import "OFArray.h"
#import "OFString.h"
static struct {
Class isa;
} placeholder;
@interface OFMutableDictionaryPlaceholder: OFDictionary
@end
@implementation OFMutableDictionaryPlaceholder
- (instancetype)init
{
return (id)[[OFMutableMapTableDictionary alloc] init];
}
- (instancetype)initWithDictionary: (OFDictionary *)dictionary
{
return (id)[[OFMutableMapTableDictionary alloc]
initWithDictionary: dictionary];
}
- (instancetype)initWithObject: (id)object forKey: (id)key
{
return (id)[[OFMutableMapTableDictionary alloc] initWithObject: object
forKey: key];
}
- (instancetype)initWithObjects: (OFArray *)objects forKeys: (OFArray *)keys
{
return (id)[[OFMutableMapTableDictionary alloc] initWithObjects: objects
forKeys: keys];
}
- (instancetype)initWithObjects: (id const *)objects
forKeys: (id const *)keys
count: (size_t)count
{
return (id)[[OFMutableMapTableDictionary alloc] initWithObjects: objects
forKeys: keys
count: count];
}
- (instancetype)initWithKeysAndObjects: (id)firstKey, ...
{
id ret;
va_list arguments;
va_start(arguments, firstKey);
ret = (id)[[OFMutableMapTableDictionary alloc] initWithKey: firstKey
arguments: arguments];
va_end(arguments);
return ret;
}
- (instancetype)initWithKey: (id)firstKey arguments: (va_list)arguments
{
return (id)[[OFMutableMapTableDictionary alloc] initWithKey: firstKey
arguments: arguments];
}
- (instancetype)initWithCapacity: (size_t)capacity
{
return (id)[[OFMutableMapTableDictionary alloc]
initWithCapacity: capacity];
}
OF_SINGLETON_METHODS
@end
@implementation OFMutableDictionary
+ (void)initialize
{
if (self == [OFMutableDictionary class])
object_setClass((id)&placeholder,
[OFMutableDictionaryPlaceholder class]);
}
+ (instancetype)alloc
{
if (self == [OFMutableDictionary class])
return (id)&placeholder;
|
|
|
|
|
|
|
|
|
|
|
|
|
|
13
14
15
16
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
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
|
* file.
*/
#include "config.h"
#include <stdlib.h>
#import "OFConcreteMutableDictionary.h"
#import "OFArray.h"
#import "OFString.h"
static struct {
Class isa;
} placeholder;
@interface OFPlaceholderMutableDictionary: OFDictionary
@end
@implementation OFPlaceholderMutableDictionary
- (instancetype)init
{
return (id)[[OFConcreteMutableDictionary alloc] init];
}
- (instancetype)initWithDictionary: (OFDictionary *)dictionary
{
return (id)[[OFConcreteMutableDictionary alloc]
initWithDictionary: dictionary];
}
- (instancetype)initWithObject: (id)object forKey: (id)key
{
return (id)[[OFConcreteMutableDictionary alloc] initWithObject: object
forKey: key];
}
- (instancetype)initWithObjects: (OFArray *)objects forKeys: (OFArray *)keys
{
return (id)[[OFConcreteMutableDictionary alloc] initWithObjects: objects
forKeys: keys];
}
- (instancetype)initWithObjects: (id const *)objects
forKeys: (id const *)keys
count: (size_t)count
{
return (id)[[OFConcreteMutableDictionary alloc] initWithObjects: objects
forKeys: keys
count: count];
}
- (instancetype)initWithKeysAndObjects: (id)firstKey, ...
{
id ret;
va_list arguments;
va_start(arguments, firstKey);
ret = (id)[[OFConcreteMutableDictionary alloc] initWithKey: firstKey
arguments: arguments];
va_end(arguments);
return ret;
}
- (instancetype)initWithKey: (id)firstKey arguments: (va_list)arguments
{
return (id)[[OFConcreteMutableDictionary alloc] initWithKey: firstKey
arguments: arguments];
}
- (instancetype)initWithCapacity: (size_t)capacity
{
return (id)[[OFConcreteMutableDictionary alloc]
initWithCapacity: capacity];
}
OF_SINGLETON_METHODS
@end
@implementation OFMutableDictionary
+ (void)initialize
{
if (self == [OFMutableDictionary class])
object_setClass((id)&placeholder,
[OFPlaceholderMutableDictionary class]);
}
+ (instancetype)alloc
{
if (self == [OFMutableDictionary class])
return (id)&placeholder;
|
︙ | | | ︙ | |
Modified src/OFMutableSet.m
from [52a6d0078f]
to [c4dda1aa5f].
︙ | | | ︙ | |
14
15
16
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
81
82
83
84
85
86
87
88
89
90
91
92
|
*/
#include "config.h"
#include <stdlib.h>
#import "OFMutableSet.h"
#import "OFMutableMapTableSet.h"
#import "OFString.h"
static struct {
Class isa;
} placeholder;
@interface OFMutableSetPlaceholder: OFMutableSet
@end
@implementation OFMutableSetPlaceholder
- (instancetype)init
{
return (id)[[OFMutableMapTableSet alloc] init];
}
- (instancetype)initWithSet: (OFSet *)set
{
return (id)[[OFMutableMapTableSet alloc] initWithSet: set];
}
- (instancetype)initWithArray: (OFArray *)array
{
return (id)[[OFMutableMapTableSet alloc] initWithArray: array];
}
- (instancetype)initWithObjects: (id)firstObject, ...
{
id ret;
va_list arguments;
va_start(arguments, firstObject);
ret = [[OFMutableMapTableSet alloc] initWithObject: firstObject
arguments: arguments];
va_end(arguments);
return ret;
}
- (instancetype)initWithObjects: (id const *)objects count: (size_t)count
{
return (id)[[OFMutableMapTableSet alloc] initWithObjects: objects
count: count];
}
- (instancetype)initWithObject: (id)firstObject arguments: (va_list)arguments
{
return (id)[[OFMutableMapTableSet alloc] initWithObject: firstObject
arguments: arguments];
}
- (instancetype)initWithCapacity: (size_t)capacity
{
return (id)[[OFMutableMapTableSet alloc] initWithCapacity: capacity];
}
OF_SINGLETON_METHODS
@end
@implementation OFMutableSet
+ (void)initialize
{
if (self == [OFMutableSet class])
object_setClass((id)&placeholder,
[OFMutableSetPlaceholder class]);
}
+ (instancetype)alloc
{
if (self == [OFMutableSet class])
return (id)&placeholder;
|
|
|
|
|
|
|
|
|
|
|
|
|
14
15
16
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
81
82
83
84
85
86
87
88
89
90
91
92
|
*/
#include "config.h"
#include <stdlib.h>
#import "OFMutableSet.h"
#import "OFConcreteMutableSet.h"
#import "OFString.h"
static struct {
Class isa;
} placeholder;
@interface OFPlaceholderMutableSet: OFMutableSet
@end
@implementation OFPlaceholderMutableSet
- (instancetype)init
{
return (id)[[OFConcreteMutableSet alloc] init];
}
- (instancetype)initWithSet: (OFSet *)set
{
return (id)[[OFConcreteMutableSet alloc] initWithSet: set];
}
- (instancetype)initWithArray: (OFArray *)array
{
return (id)[[OFConcreteMutableSet alloc] initWithArray: array];
}
- (instancetype)initWithObjects: (id)firstObject, ...
{
id ret;
va_list arguments;
va_start(arguments, firstObject);
ret = [[OFConcreteMutableSet alloc] initWithObject: firstObject
arguments: arguments];
va_end(arguments);
return ret;
}
- (instancetype)initWithObjects: (id const *)objects count: (size_t)count
{
return (id)[[OFConcreteMutableSet alloc] initWithObjects: objects
count: count];
}
- (instancetype)initWithObject: (id)firstObject arguments: (va_list)arguments
{
return (id)[[OFConcreteMutableSet alloc] initWithObject: firstObject
arguments: arguments];
}
- (instancetype)initWithCapacity: (size_t)capacity
{
return (id)[[OFConcreteMutableSet alloc] initWithCapacity: capacity];
}
OF_SINGLETON_METHODS
@end
@implementation OFMutableSet
+ (void)initialize
{
if (self == [OFMutableSet class])
object_setClass((id)&placeholder,
[OFPlaceholderMutableSet class]);
}
+ (instancetype)alloc
{
if (self == [OFMutableSet class])
return (id)&placeholder;
|
︙ | | | ︙ | |
Modified src/OFMutableString.m
from [b405469c4d]
to [19236c79ee].
︙ | | | ︙ | |
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
|
#import "unicode.h"
static struct {
Class isa;
} placeholder;
@interface OFMutableStringPlaceholder: OFMutableString
@end
@implementation OFMutableStringPlaceholder
- (instancetype)init
{
return (id)[[OFMutableUTF8String alloc] init];
}
- (instancetype)initWithUTF8String: (const char *)UTF8String
{
|
|
|
|
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
|
#import "unicode.h"
static struct {
Class isa;
} placeholder;
@interface OFPlaceholderMutableString: OFMutableString
@end
@implementation OFPlaceholderMutableString
- (instancetype)init
{
return (id)[[OFMutableUTF8String alloc] init];
}
- (instancetype)initWithUTF8String: (const char *)UTF8String
{
|
︙ | | | ︙ | |
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
|
@end
@implementation OFMutableString
+ (void)initialize
{
if (self == [OFMutableString class])
object_setClass((id)&placeholder,
[OFMutableStringPlaceholder class]);
}
+ (instancetype)alloc
{
if (self == [OFMutableString class])
return (id)&placeholder;
|
|
|
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
|
@end
@implementation OFMutableString
+ (void)initialize
{
if (self == [OFMutableString class])
object_setClass((id)&placeholder,
[OFPlaceholderMutableString class]);
}
+ (instancetype)alloc
{
if (self == [OFMutableString class])
return (id)&placeholder;
|
︙ | | | ︙ | |
Modified src/OFNumber.m
from [af557968cc]
to [8fe1f42701].
︙ | | | ︙ | |
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
|
@interface OFNumber ()
+ (instancetype)of_alloc;
- (OFString *)
of_JSONRepresentationWithOptions: (OFJSONRepresentationOptions)options
depth: (size_t)depth;
@end
@interface OFNumberPlaceholder: OFNumber
@end
@interface OFNumberSingleton: OFNumber
@end
#ifdef OF_OBJFW_RUNTIME
enum Tag {
|
|
|
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
|
@interface OFNumber ()
+ (instancetype)of_alloc;
- (OFString *)
of_JSONRepresentationWithOptions: (OFJSONRepresentationOptions)options
depth: (size_t)depth;
@end
@interface OFPlaceholderNumber: OFNumber
@end
@interface OFNumberSingleton: OFNumber
@end
#ifdef OF_OBJFW_RUNTIME
enum Tag {
|
︙ | | | ︙ | |
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
|
case 'd':
return true;
default:
return false;
}
}
@implementation OFNumberPlaceholder
- (instancetype)initWithBool: (bool)value
{
if (value) {
static OFOnceControl onceControl = OFOnceControlInitValue;
OFOnce(&onceControl, trueNumberInit);
return (id)trueNumber;
} else {
|
|
|
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
|
case 'd':
return true;
default:
return false;
}
}
@implementation OFPlaceholderNumber
- (instancetype)initWithBool: (bool)value
{
if (value) {
static OFOnceControl onceControl = OFOnceControlInitValue;
OFOnce(&onceControl, trueNumberInit);
return (id)trueNumber;
} else {
|
︙ | | | ︙ | |
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
|
@implementation OFNumber
+ (void)initialize
{
if (self != [OFNumber class])
return;
object_setClass((id)&placeholder, [OFNumberPlaceholder class]);
#ifdef OF_OBJFW_RUNTIME
numberTag =
objc_registerTaggedPointerClass([OFTaggedPointerNumber class]);
#endif
}
|
|
|
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
|
@implementation OFNumber
+ (void)initialize
{
if (self != [OFNumber class])
return;
object_setClass((id)&placeholder, [OFPlaceholderNumber class]);
#ifdef OF_OBJFW_RUNTIME
numberTag =
objc_registerTaggedPointerClass([OFTaggedPointerNumber class]);
#endif
}
|
︙ | | | ︙ | |
Modified src/OFSet.m
from [3d86fbe75e]
to [cf7d351eda].
︙ | | | ︙ | |
15
16
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
81
82
83
84
85
86
87
88
89
|
#include "config.h"
#include <stdlib.h>
#import "OFSet.h"
#import "OFArray.h"
#import "OFCountedSet.h"
#import "OFMapTableSet.h"
#import "OFNull.h"
#import "OFString.h"
static struct {
Class isa;
} placeholder;
@interface OFSetPlaceholder: OFSet
@end
@implementation OFSetPlaceholder
- (instancetype)init
{
return (id)[[OFMapTableSet alloc] init];
}
- (instancetype)initWithSet: (OFSet *)set
{
return (id)[[OFMapTableSet alloc] initWithSet: set];
}
- (instancetype)initWithArray: (OFArray *)array
{
return (id)[[OFMapTableSet alloc] initWithArray: array];
}
- (instancetype)initWithObjects: (id)firstObject, ...
{
id ret;
va_list arguments;
va_start(arguments, firstObject);
ret = [[OFMapTableSet alloc] initWithObject: firstObject
arguments: arguments];
va_end(arguments);
return ret;
}
- (instancetype)initWithObjects: (id const *)objects count: (size_t)count
{
return (id)[[OFMapTableSet alloc] initWithObjects: objects
count: count];
}
- (instancetype)initWithObject: (id)firstObject arguments: (va_list)arguments
{
return (id)[[OFMapTableSet alloc] initWithObject: firstObject
arguments: arguments];
}
OF_SINGLETON_METHODS
@end
@implementation OFSet
+ (void)initialize
{
if (self == [OFSet class])
object_setClass((id)&placeholder, [OFSetPlaceholder class]);
}
+ (instancetype)alloc
{
if (self == [OFSet class])
return (id)&placeholder;
|
|
|
|
|
|
|
|
|
|
|
|
|
15
16
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
81
82
83
84
85
86
87
88
89
|
#include "config.h"
#include <stdlib.h>
#import "OFSet.h"
#import "OFArray.h"
#import "OFConcreteSet.h"
#import "OFCountedSet.h"
#import "OFNull.h"
#import "OFString.h"
static struct {
Class isa;
} placeholder;
@interface OFPlaceholderSet: OFSet
@end
@implementation OFPlaceholderSet
- (instancetype)init
{
return (id)[[OFConcreteSet alloc] init];
}
- (instancetype)initWithSet: (OFSet *)set
{
return (id)[[OFConcreteSet alloc] initWithSet: set];
}
- (instancetype)initWithArray: (OFArray *)array
{
return (id)[[OFConcreteSet alloc] initWithArray: array];
}
- (instancetype)initWithObjects: (id)firstObject, ...
{
id ret;
va_list arguments;
va_start(arguments, firstObject);
ret = [[OFConcreteSet alloc] initWithObject: firstObject
arguments: arguments];
va_end(arguments);
return ret;
}
- (instancetype)initWithObjects: (id const *)objects count: (size_t)count
{
return (id)[[OFConcreteSet alloc] initWithObjects: objects
count: count];
}
- (instancetype)initWithObject: (id)firstObject arguments: (va_list)arguments
{
return (id)[[OFConcreteSet alloc] initWithObject: firstObject
arguments: arguments];
}
OF_SINGLETON_METHODS
@end
@implementation OFSet
+ (void)initialize
{
if (self == [OFSet class])
object_setClass((id)&placeholder, [OFPlaceholderSet class]);
}
+ (instancetype)alloc
{
if (self == [OFSet class])
return (id)&placeholder;
|
︙ | | | ︙ | |
Modified src/OFString.m
from [c23004791c]
to [e84d292643].
︙ | | | ︙ | |
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
|
- (const char *)of_cStringWithEncoding: (OFStringEncoding)encoding
lossy: (bool)lossy OF_DIRECT;
- (OFString *)
of_JSONRepresentationWithOptions: (OFJSONRepresentationOptions)options
depth: (size_t)depth;
@end
@interface OFStringPlaceholder: OFString
@end
extern bool OFUnicodeToISO8859_2(const OFUnichar *, unsigned char *,
size_t, bool);
extern bool OFUnicodeToISO8859_3(const OFUnichar *, unsigned char *,
size_t, bool);
extern bool OFUnicodeToISO8859_15(const OFUnichar *, unsigned char *,
|
|
|
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
|
- (const char *)of_cStringWithEncoding: (OFStringEncoding)encoding
lossy: (bool)lossy OF_DIRECT;
- (OFString *)
of_JSONRepresentationWithOptions: (OFJSONRepresentationOptions)options
depth: (size_t)depth;
@end
@interface OFPlaceholderString: OFString
@end
extern bool OFUnicodeToISO8859_2(const OFUnichar *, unsigned char *,
size_t, bool);
extern bool OFUnicodeToISO8859_3(const OFUnichar *, unsigned char *,
size_t, bool);
extern bool OFUnicodeToISO8859_15(const OFUnichar *, unsigned char *,
|
︙ | | | ︙ | |
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
|
objc_autoreleasePoolPop(pool);
return ret;
}
#endif
@implementation OFStringPlaceholder
- (instancetype)init
{
return (id)[[OFUTF8String alloc] init];
}
- (instancetype)initWithUTF8String: (const char *)UTF8String
{
|
|
|
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
|
objc_autoreleasePoolPop(pool);
return ret;
}
#endif
@implementation OFPlaceholderString
- (instancetype)init
{
return (id)[[OFUTF8String alloc] init];
}
- (instancetype)initWithUTF8String: (const char *)UTF8String
{
|
︙ | | | ︙ | |
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
|
@implementation OFString
+ (void)initialize
{
if (self != [OFString class])
return;
object_setClass((id)&placeholder, [OFStringPlaceholder class]);
#if defined(HAVE_STRTOF_L) || defined(HAVE_STRTOD_L) || defined(HAVE_USELOCALE)
if ((cLocale = newlocale(LC_ALL_MASK, "C", NULL)) == NULL)
@throw [OFInitializationFailedException
exceptionWithClass: self];
#endif
}
|
|
|
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
|
@implementation OFString
+ (void)initialize
{
if (self != [OFString class])
return;
object_setClass((id)&placeholder, [OFPlaceholderString class]);
#if defined(HAVE_STRTOF_L) || defined(HAVE_STRTOD_L) || defined(HAVE_USELOCALE)
if ((cLocale = newlocale(LC_ALL_MASK, "C", NULL)) == NULL)
@throw [OFInitializationFailedException
exceptionWithClass: self];
#endif
}
|
︙ | | | ︙ | |
Modified tests/OFSetTests.m
from [bc79bd72ed]
to [c815f9bb11].
︙ | | | ︙ | |
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
|
*/
#include "config.h"
#import "TestsAppDelegate.h"
#import "OFSet.h"
#import "OFMapTableSet.h"
#import "OFMutableMapTableSet.h"
static OFString *module;
@interface SimpleSet: OFSet
{
OFMutableSet *_set;
}
|
|
|
|
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
|
*/
#include "config.h"
#import "TestsAppDelegate.h"
#import "OFSet.h"
#import "OFConcreteSet.h"
#import "OFConcreteMutableSet.h"
static OFString *module;
@interface SimpleSet: OFSet
{
OFMutableSet *_set;
}
|
︙ | | | ︙ | |
284
285
286
287
288
289
290
291
292
293
294
295
|
- (void)setTests
{
module = @"OFSet";
[self setTestsWithClass: [SimpleSet class]
mutableClass: [SimpleMutableSet class]];
module = @"OFMapTableSet";
[self setTestsWithClass: [OFMapTableSet class]
mutableClass: [OFMutableMapTableSet class]];
}
@end
|
|
|
|
|
284
285
286
287
288
289
290
291
292
293
294
295
|
- (void)setTests
{
module = @"OFSet";
[self setTestsWithClass: [SimpleSet class]
mutableClass: [SimpleMutableSet class]];
module = @"OFConcreteSet";
[self setTestsWithClass: [OFConcreteSet class]
mutableClass: [OFConcreteMutableSet class]];
}
@end
|