Comment: | Make OFSet and OFCountedSet abstract classes. |
---|---|
Downloads: | Tarball | ZIP archive | SQL archive |
Timelines: | family | ancestors | descendants | both | trunk |
Files: | files | file ages | folders |
SHA3-256: |
66b12bb66f56b2e08482cc632910db14 |
User & Date: | js on 2011-08-31 16:01:16 |
Other Links: | manifest | tags |
2011-08-31
| ||
20:16 | Don't install headers for implementations in Xcode project. check-in: abad97e74c user: js tags: trunk | |
16:01 | Make OFSet and OFCountedSet abstract classes. check-in: 66b12bb66f user: js tags: trunk | |
2011-08-30
| ||
19:38 | Fix forgotten rename of OFMutableArrayPlaceholder. check-in: caa6878d38 user: js tags: trunk | |
Modified src/Makefile from [7a839ac93a] to [3905b7ae47].
︙ | ︙ | |||
69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 | asprintf.h \ ${ATOMIC_H} \ macros.h \ objfw-defs.h \ ${THREADING_H} SRCS += OFArray_adjacent.m \ OFDictionary_hashtable.m \ OFMutableArray_adjacent.m \ OFMutableDictionary_hashtable.m \ ${ASPRINTF_M} \ ${FOUNDATION_COMPAT_M} \ iso_8859_15.m \ windows_1252.m \ ${OBJC_PROPERTIES_M} \ ${OBJC_SYNC_M} | > > > | 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 | asprintf.h \ ${ATOMIC_H} \ macros.h \ objfw-defs.h \ ${THREADING_H} SRCS += OFArray_adjacent.m \ OFCountedSet_hashtable.m \ OFDictionary_hashtable.m \ OFMutableArray_adjacent.m \ OFMutableDictionary_hashtable.m \ OFMutableSet_hashtable.m \ OFSet_hashtable.m \ ${ASPRINTF_M} \ ${FOUNDATION_COMPAT_M} \ iso_8859_15.m \ windows_1252.m \ ${OBJC_PROPERTIES_M} \ ${OBJC_SYNC_M} |
︙ | ︙ |
Modified src/OFCountedSet.h from [953f39ec52] to [16777a9318].
︙ | ︙ | |||
38 39 40 41 42 43 44 | * * \param block The block to execute for each object in the set */ - (void)enumerateObjectsAndCountUsingBlock: (of_counted_set_enumeration_block_t)block; #endif @end | > > > | 38 39 40 41 42 43 44 45 46 47 | * * \param block The block to execute for each object in the set */ - (void)enumerateObjectsAndCountUsingBlock: (of_counted_set_enumeration_block_t)block; #endif @end @interface OFCountedSet_placeholder: OFCountedSet @end |
Modified src/OFCountedSet.m from [306e7a046d] to [564495dad9].
︙ | ︙ | |||
12 13 14 15 16 17 18 | * 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" | < < < | | > > > > > > | | | | < < < < < < < < < | > | | | | | < < > | < < < | < > | > > > > | > > > | > | > > | > > > > | > | > | > | > > > > > | > > > > > > | > > > > | > > > > > > > | > | > > > > > > | | | < | < | | | < | 12 13 14 15 16 17 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 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 | * Public License, either version 2 or 3, which can be found in the file * LICENSE.GPLv2 or LICENSE.GPLv3 respectively included in the packaging of this * file. */ #include "config.h" #import "OFCountedSet.h" #import "OFCountedSet_hashtable.h" #import "OFNumber.h" #import "OFString.h" #import "OFAutoreleasePool.h" #import "OFNotImplementedException.h" static struct { Class isa; } placeholder; @implementation OFCountedSet_placeholder - init { return (id)[[OFCountedSet_hashtable alloc] init]; } - initWithSet: (OFSet*)set { return (id)[[OFCountedSet_hashtable alloc] initWithSet: set]; } - initWithArray: (OFArray*)array { return (id)[[OFCountedSet_hashtable alloc] initWithArray: array]; } - initWithObjects: (id)firstObject, ... { id ret; va_list arguments; va_start(arguments, firstObject); ret = [[OFCountedSet_hashtable alloc] initWithObject: firstObject arguments: arguments]; va_end(arguments); return ret; } - initWithObject: (id)firstObject arguments: (va_list)arguments { return [[OFCountedSet_hashtable alloc] initWithObject: firstObject arguments: arguments]; } - retain { return self; } - autorelease { return self; } - (void)release { } - (void)dealloc { @throw [OFNotImplementedException newWithClass: isa selector: _cmd]; [super dealloc]; /* Get rid of a stupid warning */ } @end @implementation OFCountedSet + (void)initialize { if (self == [OFCountedSet class]) placeholder.isa = [OFCountedSet_placeholder class]; } + alloc { if (self == [OFCountedSet class]) return (id)&placeholder; return [super alloc]; } - init { if (isa == [OFCountedSet class]) { Class c = isa; [self release]; @throw [OFNotImplementedException newWithClass: c selector: _cmd]; } return [super init]; } - (size_t)countForObject: (id)object { @throw [OFNotImplementedException newWithClass: isa selector: _cmd]; } - (OFString*)description { OFMutableString *ret; OFAutoreleasePool *pool, *pool2; OFEnumerator *enumerator; size_t i, count = [self count]; id object; if (count == 0) return @"{()}"; ret = [OFMutableString stringWithString: @"{(\n"]; pool = [[OFAutoreleasePool alloc] init]; enumerator = [self objectEnumerator]; i = 0; pool2 = [[OFAutoreleasePool alloc] init]; while ((object = [enumerator nextObject]) != nil) { [ret appendString: object]; [ret appendFormat: @": %zu", [self countForObject: object]]; if (++i < count) [ret appendString: @",\n"]; [pool2 releaseObjects]; } [ret replaceOccurrencesOfString: @"\n" |
︙ | ︙ | |||
129 130 131 132 133 134 135 | } - mutableCopy { return [[OFCountedSet alloc] initWithSet: self]; } | < < < < < | < | | < < | | < | < | < < | < < | < | < < | < < | < < | < < < < | < < < < < < < < < < < | | < < < < < < < < < < | < < < < | < < | < < < < | < < | > | | | | | | < > > | > > | < | > | 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 | } - mutableCopy { return [[OFCountedSet alloc] initWithSet: self]; } #ifdef OF_HAVE_BLOCKS - (void)enumerateObjectsAndCountUsingBlock: (of_counted_set_enumeration_block_t)block { [self enumerateObjectsUsingBlock: ^ (id object, BOOL *stop) { block(object, [self countForObject: object], stop); }]; } #endif - (void)minusSet: (OFSet*)set { OFAutoreleasePool *pool = [[OFAutoreleasePool alloc] init]; if ([set isKindOfClass: [OFCountedSet class]]) { OFCountedSet *countedSet = (OFCountedSet*)set; OFEnumerator *enumerator = [countedSet objectEnumerator]; id object; while ((object = [enumerator nextObject]) != nil) { size_t i, count = [countedSet countForObject: object]; for (i = 0; i < count; i++) [self removeObject: object]; } } else { OFEnumerator *enumerator = [set objectEnumerator]; id object; while ((object = [enumerator nextObject]) != nil) [self removeObject: object]; } [pool release]; } - (void)unionSet: (OFSet*)set { OFAutoreleasePool *pool = [[OFAutoreleasePool alloc] init]; if ([set isKindOfClass: [OFCountedSet class]]) { OFCountedSet *countedSet = (OFCountedSet*)set; OFEnumerator *enumerator = [countedSet objectEnumerator]; id object; while ((object = [enumerator nextObject]) != nil) { size_t i, count = [countedSet countForObject: object]; for (i = 0; i < count; i++) [self addObject: object]; } } else { OFEnumerator *enumerator = [set objectEnumerator]; id object; while ((object = [enumerator nextObject]) != nil) [self addObject: object]; } [pool release]; } @end |
Added src/OFCountedSet_hashtable.h version [7a070c2ba9].
> > > > > > > > > > > > > > > > > > > > > > > > > > | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 | /* * Copyright (c) 2008, 2009, 2010, 2011 * Jonathan Schleifer <js@webkeks.org> * * All rights reserved. * * This file is part of ObjFW. It may be distributed under the terms of the * Q Public License 1.0, which can be found in the file LICENSE.QPL included in * the packaging of this file. * * Alternatively, it may be distributed under the terms of the GNU General * Public License, either version 2 or 3, which can be found in the file * LICENSE.GPLv2 or LICENSE.GPLv3 respectively included in the packaging of this * file. */ #import "OFCountedSet.h" @class OFDictionary_hashtable; @interface OFCountedSet_hashtable: OFCountedSet { OFDictionary_hashtable *dictionary; unsigned long mutations; } @end |
Added src/OFCountedSet_hashtable.m version [ecfe321ef8].
> > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 | /* * Copyright (c) 2008, 2009, 2010, 2011 * Jonathan Schleifer <js@webkeks.org> * * All rights reserved. * * This file is part of ObjFW. It may be distributed under the terms of the * Q Public License 1.0, which can be found in the file LICENSE.QPL included in * the packaging of this file. * * Alternatively, it may be distributed under the terms of the GNU General * Public License, either version 2 or 3, which can be found in the file * LICENSE.GPLv2 or LICENSE.GPLv3 respectively included in the packaging of this * file. */ #include "config.h" #define OF_COUNTED_SET_HASHTABLE_M #import "OFMutableSet_hashtable.h" #import "OFCountedSet_hashtable.h" #import "OFMutableDictionary_hashtable.h" #import "OFNumber.h" #import "OFArray.h" #import "OFAutoreleasePool.h" @implementation OFCountedSet_hashtable + (void)initialize { if (self == [OFCountedSet_hashtable class]) [self inheritMethodsFromClass: [OFMutableSet_hashtable class]]; } - initWithSet: (OFSet*)set { self = [self init]; @try { OFAutoreleasePool *pool = [[OFAutoreleasePool alloc] init]; if ([set isKindOfClass: [OFCountedSet class]]) { OFCountedSet *countedSet = (OFCountedSet*)countedSet; OFEnumerator *enumerator = [countedSet objectEnumerator]; id object; while ((object = [enumerator nextObject]) != nil) { size_t i, count; count = [countedSet countForObject: object]; for (i = 0; i < count; i++) [self addObject: object]; } } else { OFEnumerator *enumerator = [set objectEnumerator]; id object; while ((object = [enumerator nextObject]) != nil) [self addObject: object]; } [pool release]; } @catch (id e) { [self release]; @throw e; } return self; } - initWithArray: (OFArray*)array { self = [self init]; @try { id *cArray = [array cArray]; size_t i, count = [array count]; for (i = 0; i < count; i++) [self addObject: cArray[i]]; } @catch (id e) { [self release]; @throw e; } return self; } - initWithObject: (id)firstObject arguments: (va_list)arguments { self = [self init]; @try { id object; [self addObject: firstObject]; while ((object = va_arg(arguments, id)) != nil) [self addObject: object]; } @catch (id e) { [self release]; @throw e; } return self; } - (size_t)countForObject: (id)object { return [[dictionary objectForKey: object] sizeValue]; } #ifdef OF_HAVE_BLOCKS - (void)enumerateObjectsAndCountUsingBlock: (of_counted_set_enumeration_block_t)block { [dictionary enumerateKeysAndObjectsUsingBlock: ^ (id key, id object, BOOL *stop) { block(key, [object sizeValue], stop); }]; } #endif - (void)addObject: (id)object { OFAutoreleasePool *pool = [[OFAutoreleasePool alloc] init]; OFNumber *count; count = [[dictionary objectForKey: object] numberByIncreasing]; if (count == nil) count = [OFNumber numberWithSize: 1]; [dictionary _setObject: count forKey: object copyKey: NO]; mutations++; [pool release]; } - (void)removeObject: (id)object { OFNumber *count = [dictionary objectForKey: object]; OFAutoreleasePool *pool; if (count == nil) return; pool = [[OFAutoreleasePool alloc] init]; count = [count numberByDecreasing]; if ([count sizeValue] > 0) [dictionary _setObject: count forKey: object copyKey: NO]; else [dictionary removeObjectForKey: object]; mutations++; [pool release]; } - (void)makeImmutable { } @end |
Modified src/OFDictionary.m from [252a3f02aa] to [98b4c2fae3].
︙ | ︙ | |||
23 24 25 26 27 28 29 | #import "OFArray.h" #import "OFString.h" #import "OFXMLElement.h" #import "OFAutoreleasePool.h" #import "OFNotImplementedException.h" | < < | 23 24 25 26 27 28 29 30 31 32 33 34 35 36 | #import "OFArray.h" #import "OFString.h" #import "OFXMLElement.h" #import "OFAutoreleasePool.h" #import "OFNotImplementedException.h" static struct { Class isa; } placeholder; @implementation OFDictionary_placeholder - init { |
︙ | ︙ |
Modified src/OFDictionary_hashtable.h from [5e6091e296] to [e01393f440].
︙ | ︙ | |||
25 26 27 28 29 30 31 | @interface OFDictionary_hashtable: OFDictionary { struct of_dictionary_hashtable_bucket **data; uint32_t size; size_t count; } | | | 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 | @interface OFDictionary_hashtable: OFDictionary { struct of_dictionary_hashtable_bucket **data; uint32_t size; size_t count; } #if defined(OF_SET_HASHTABLE_M) || defined(OF_COUNTED_SET_HASHTABLE_M) - _initWithDictionary: (OFDictionary*)dictionary copyKeys: (BOOL)copyKeys; #endif @end @interface OFDictionaryEnumerator_hashtable: OFEnumerator { |
︙ | ︙ |
Modified src/OFMutableDictionary.m from [8805a4fb1a] to [b6a6426560].
︙ | ︙ | |||
17 18 19 20 21 22 23 | #include "config.h" #import "OFMutableDictionary_hashtable.h" #import "OFAutoreleasePool.h" #import "OFNotImplementedException.h" | < < | 17 18 19 20 21 22 23 24 25 26 27 28 29 30 | #include "config.h" #import "OFMutableDictionary_hashtable.h" #import "OFAutoreleasePool.h" #import "OFNotImplementedException.h" static struct { Class isa; } placeholder; @implementation OFMutableDictionary_placeholder - init { |
︙ | ︙ |
Modified src/OFMutableDictionary_hashtable.h from [459e55ec05] to [82dbdc2a0c].
︙ | ︙ | |||
20 21 22 23 24 25 26 | { struct of_dictionary_hashtable_bucket **data; uint32_t size; size_t count; unsigned long mutations; } | | > | | 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 | { struct of_dictionary_hashtable_bucket **data; uint32_t size; size_t count; unsigned long mutations; } #if defined(OF_SET_HASHTABLE_M) || defined(OF_COUNTED_SET_HASHTABLE_M) - _initWithDictionary: (OFDictionary*)dictionary copyKeys: (BOOL)copyKeys; #endif #if defined(OF_SET_HASHTABLE_M) || defined(OF_MUTABLE_SET_HASHTABLE_M) || \ defined(OF_COUNTED_SET_HASHTABLE_M) - (void)_setObject: (id)object forKey: (id)key copyKey: (BOOL)copyKey; #endif @end |
Modified src/OFMutableSet.h from [aa22f58832] to [74fb17cb05].
︙ | ︙ | |||
16 17 18 19 20 21 22 | #import "OFSet.h" /** * \brief An mutable unordered set of unique objects. */ @interface OFMutableSet: OFSet | < < < < | 16 17 18 19 20 21 22 23 24 25 26 27 28 29 | #import "OFSet.h" /** * \brief An mutable unordered set of unique objects. */ @interface OFMutableSet: OFSet /** * \brief Adds the specified object to the set. * * \param object The object to add to the set */ - (void)addObject: (id)object; |
︙ | ︙ | |||
61 62 63 64 65 66 67 | - (void)unionSet: (OFSet*)set; /** * \brief Converts the mutable set to an immutable set. */ - (void)makeImmutable; @end | > > > | 57 58 59 60 61 62 63 64 65 66 | - (void)unionSet: (OFSet*)set; /** * \brief Converts the mutable set to an immutable set. */ - (void)makeImmutable; @end @interface OFMutableSet_placeholder: OFMutableSet @end |
Modified src/OFMutableSet.m from [27d68fc0e7] to [781150565d].
︙ | ︙ | |||
12 13 14 15 16 17 18 | * 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" | | | | > | > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > | | > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > | < < | < | | < | | | > > > > > > | > > > > > | | | > > > < | 12 13 14 15 16 17 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 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 | * Public License, either version 2 or 3, which can be found in the file * LICENSE.GPLv2 or LICENSE.GPLv3 respectively included in the packaging of this * file. */ #include "config.h" #include <assert.h> #import "OFMutableSet.h" #import "OFMutableSet_hashtable.h" #import "OFAutoreleasePool.h" #import "OFNotImplementedException.h" static struct { Class isa; } placeholder; @implementation OFMutableSet_placeholder - init { return (id)[[OFMutableSet_hashtable alloc] init]; } - initWithSet: (OFSet*)set { return (id)[[OFMutableSet_hashtable alloc] initWithSet: set]; } - initWithArray: (OFArray*)array { return (id)[[OFMutableSet_hashtable alloc] initWithArray: array]; } - initWithObjects: (id)firstObject, ... { id ret; va_list arguments; va_start(arguments, firstObject); ret = [[OFMutableSet_hashtable alloc] initWithObject: firstObject arguments: arguments]; va_end(arguments); return ret; } - initWithObject: (id)firstObject arguments: (va_list)arguments { return [[OFMutableSet_hashtable alloc] initWithObject: firstObject arguments: arguments]; } - retain { return self; } - autorelease { return self; } - (void)release { } - (void)dealloc { @throw [OFNotImplementedException newWithClass: isa selector: _cmd]; [super dealloc]; /* Get rid of a stupid warning */ } @end @implementation OFMutableSet + (void)initialize { if (self == [OFMutableSet class]) placeholder.isa = [OFMutableSet_placeholder class]; } + alloc { if (self == [OFMutableSet class]) return (id)&placeholder; return [super alloc]; } - init { if (isa == [OFMutableSet class]) { Class c = isa; [self release]; @throw [OFNotImplementedException newWithClass: c selector: _cmd]; } return [super init]; } - (void)addObject: (id)object { @throw [OFNotImplementedException newWithClass: isa selector: _cmd]; } - (void)removeObject: (id)object { @throw [OFNotImplementedException newWithClass: isa selector: _cmd]; } - (void)minusSet: (OFSet*)set { OFAutoreleasePool *pool = [[OFAutoreleasePool alloc] init]; OFEnumerator *enumerator = [set objectEnumerator]; id object; while ((object = [enumerator nextObject]) != nil) [self removeObject: object]; [pool release]; } - (void)intersectSet: (OFSet*)set { OFAutoreleasePool *pool = [[OFAutoreleasePool alloc] init]; size_t count = [self count]; id *cArray; cArray = [self allocMemoryForNItems: count withSize: sizeof(id)]; @try { OFEnumerator *enumerator = [self objectEnumerator]; id object; size_t i = 0; while ((object = [enumerator nextObject]) != nil) { assert(i < count); cArray[i++] = object; } for (i = 0; i < count; i++) if (![set containsObject: cArray[i]]) [self removeObject: cArray[i]]; } @finally { [self freeMemory: cArray]; } [pool release]; } - (void)unionSet: (OFSet*)set { OFAutoreleasePool *pool = [[OFAutoreleasePool alloc] init]; OFEnumerator *enumerator = [set objectEnumerator]; id object; while ((object = [enumerator nextObject]) != nil) [self addObject: object]; [pool release]; } - (void)makeImmutable { } @end |
Added src/OFMutableSet_hashtable.h version [991b4e82f3].
> > > > > > > > > > > > > > > > > > > > > > > > > > | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 | /* * Copyright (c) 2008, 2009, 2010, 2011 * Jonathan Schleifer <js@webkeks.org> * * All rights reserved. * * This file is part of ObjFW. It may be distributed under the terms of the * Q Public License 1.0, which can be found in the file LICENSE.QPL included in * the packaging of this file. * * Alternatively, it may be distributed under the terms of the GNU General * Public License, either version 2 or 3, which can be found in the file * LICENSE.GPLv2 or LICENSE.GPLv3 respectively included in the packaging of this * file. */ #import "OFMutableSet.h" @class OFDictionary_hashtable; @interface OFMutableSet_hashtable: OFMutableSet { OFDictionary_hashtable *dictionary; unsigned long mutations; } @end |
Added src/OFMutableSet_hashtable.m version [f196c74e77].
> > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 | /* * Copyright (c) 2008, 2009, 2010, 2011 * Jonathan Schleifer <js@webkeks.org> * * All rights reserved. * * This file is part of ObjFW. It may be distributed under the terms of the * Q Public License 1.0, which can be found in the file LICENSE.QPL included in * the packaging of this file. * * Alternatively, it may be distributed under the terms of the GNU General * Public License, either version 2 or 3, which can be found in the file * LICENSE.GPLv2 or LICENSE.GPLv3 respectively included in the packaging of this * file. */ #include "config.h" #define OF_MUTABLE_SET_HASHTABLE_M #import "OFSet_hashtable.h" #import "OFMutableSet_hashtable.h" #import "OFMutableDictionary_hashtable.h" #import "OFNumber.h" #import "OFAutoreleasePool.h" @implementation OFMutableSet_hashtable + (void)initialize { if (self == [OFMutableSet_hashtable class]) [self inheritMethodsFromClass: [OFSet_hashtable class]]; } - (void)addObject: (id)object { [dictionary _setObject: [OFNumber numberWithSize: 1] forKey: object copyKey: NO]; mutations++; } - (void)removeObject: (id)object { [dictionary removeObjectForKey: object]; mutations++; } - (void)makeImmutable { isa = [OFSet_hashtable class]; } @end |
Modified src/OFSet.h from [ed184131ea] to [9364338508].
︙ | ︙ | |||
15 16 17 18 19 20 21 | */ #include <stdarg.h> #import "OFObject.h" #import "OFCollection.h" | < < < < < | 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 | */ #include <stdarg.h> #import "OFObject.h" #import "OFCollection.h" @class OFArray; #ifdef OF_HAVE_BLOCKS typedef void (^of_set_enumeration_block_t)(id object, BOOL *stop); typedef BOOL (^of_set_filter_block_t)(id object); #endif /** * \brief An unordered set of unique objects. */ @interface OFSet: OFObject <OFCollection, OFCopying, OFMutableCopying> /** * \brief Returns a new, autoreleased set. * * \return A new, autoreleased set */ + set; |
︙ | ︙ | |||
131 132 133 134 135 136 137 138 139 | * * \param block A block which determines if the object should be in the new set * \return A new, autoreleased OFSet */ - (OFSet*)filteredSetUsingBlock: (of_set_filter_block_t)block; #endif @end #import "OFMutableSet.h" | > > > | 126 127 128 129 130 131 132 133 134 135 136 137 | * * \param block A block which determines if the object should be in the new set * \return A new, autoreleased OFSet */ - (OFSet*)filteredSetUsingBlock: (of_set_filter_block_t)block; #endif @end @interface OFSet_placeholder: OFSet @end #import "OFMutableSet.h" |
Modified src/OFSet.m from [69cf3066e2] to [2a40664f4e].
︙ | ︙ | |||
12 13 14 15 16 17 18 | * 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" | < < | | | > | > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > | | > > > > > > > > > > > > > > > > > > > > > > > > > > > > > | 12 13 14 15 16 17 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 | * Public License, either version 2 or 3, which can be found in the file * LICENSE.GPLv2 or LICENSE.GPLv3 respectively included in the packaging of this * file. */ #include "config.h" #import "OFSet.h" #import "OFSet_hashtable.h" #import "OFString.h" #import "OFAutoreleasePool.h" #import "OFNotImplementedException.h" static struct { Class isa; } placeholder; @implementation OFSet_placeholder - init { return (id)[[OFSet_hashtable alloc] init]; } - initWithSet: (OFSet*)set { return (id)[[OFSet_hashtable alloc] initWithSet: set]; } - initWithArray: (OFArray*)array { return (id)[[OFSet_hashtable alloc] initWithArray: array]; } - initWithObjects: (id)firstObject, ... { id ret; va_list arguments; va_start(arguments, firstObject); ret = [[OFSet_hashtable alloc] initWithObject: firstObject arguments: arguments]; va_end(arguments); return ret; } - initWithObject: (id)firstObject arguments: (va_list)arguments { return [[OFSet_hashtable alloc] initWithObject: firstObject arguments: arguments]; } - retain { return self; } - autorelease { return self; } - (void)release { } - (void)dealloc { @throw [OFNotImplementedException newWithClass: isa selector: _cmd]; [super dealloc]; /* Get rid of a stupid warning */ } @end @implementation OFSet + (void)initialize { if (self == [OFSet class]) placeholder.isa = [OFSet_placeholder class]; } + alloc { if (self == [OFSet class]) return (id)&placeholder; return [super alloc]; } + set { return [[[self alloc] init] autorelease]; } + setWithSet: (OFSet*)set { |
︙ | ︙ | |||
52 53 54 55 56 57 58 | va_end(arguments); return ret; } - init { | < | | < < | > | < | < < < < < < < < < < < < < < < < < | | < | < < | < < < < < < < < < < < < < | | < | < > | > > | | < | < | | < | | | | < < | < < < | > | > > > | > > | | | < > > > | > > > > > > > > > > | | | | 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 | va_end(arguments); return ret; } - init { if (isa == [OFSet class]) { Class c = isa; [self release]; @throw [OFNotImplementedException newWithClass: c selector: _cmd]; } return [super init]; } - initWithSet: (OFSet*)set { Class c = isa; [self release]; @throw [OFNotImplementedException newWithClass: c selector: _cmd]; } - initWithArray: (OFArray*)array { Class c = isa; [self release]; @throw [OFNotImplementedException newWithClass: c selector: _cmd]; } - (id)initWithObjects:(id)firstObject, ... { id ret; va_list arguments; va_start(arguments, firstObject); ret = [self initWithObject: firstObject arguments: arguments]; va_end(arguments); return ret; } - initWithObject: (id)firstObject arguments: (va_list)arguments { Class c = isa; [self release]; @throw [OFNotImplementedException newWithClass: c selector: _cmd]; } - (size_t)count { @throw [OFNotImplementedException newWithClass: isa selector: _cmd]; } - (BOOL)containsObject: (id)object { @throw [OFNotImplementedException newWithClass: isa selector: _cmd]; } - (OFEnumerator*)objectEnumerator { @throw [OFNotImplementedException newWithClass: isa selector: _cmd]; } - (int)countByEnumeratingWithState: (of_fast_enumeration_state_t*)state objects: (id*)objects count: (int)count { @throw [OFNotImplementedException newWithClass: isa selector: _cmd]; } - (BOOL)isEqual: (id)object { OFSet *otherSet; if (![object isKindOfClass: [OFSet class]]) return NO; otherSet = object; if ([otherSet count] != [self count]) return NO; return [otherSet isSubsetOfSet: self]; } - (uint32_t)hash { OFAutoreleasePool *pool = [[OFAutoreleasePool alloc] init]; OFEnumerator *enumerator = [self objectEnumerator]; id object; uint32_t hash = 0; while ((object = [enumerator nextObject]) != nil) hash += [object hash]; [pool release]; return hash; } - (OFString*)description { OFMutableString *ret; OFAutoreleasePool *pool, *pool2; OFEnumerator *enumerator; size_t i, count = [self count]; id object; if (count == 0) return @"{()}"; ret = [OFMutableString stringWithString: @"{(\n"]; pool = [[OFAutoreleasePool alloc] init]; enumerator = [self objectEnumerator]; i = 0; pool2 = [[OFAutoreleasePool alloc] init]; while ((object = [enumerator nextObject]) != nil) { [ret appendString: [object description]]; |
︙ | ︙ | |||
220 221 222 223 224 225 226 | [pool release]; return ret; } - copy { | | < < < < < < < < < < | | > | < < | < | < < < | < > | | < | | < < < | | < | | | 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 304 305 306 307 308 309 310 311 312 313 314 315 316 317 318 319 320 321 322 323 324 325 326 327 328 329 330 331 332 333 334 335 336 337 338 339 340 341 342 343 344 345 346 347 348 | [pool release]; return ret; } - copy { return [self retain]; } - mutableCopy { return [[OFMutableSet alloc] initWithSet: self]; } - (BOOL)isSubsetOfSet: (OFSet*)set { OFAutoreleasePool *pool = [[OFAutoreleasePool alloc] init]; OFEnumerator *enumerator = [self objectEnumerator]; id object; while ((object = [enumerator nextObject]) != nil) { if (![set containsObject: object]) { [pool release]; return NO; } } [pool release]; return YES; } - (BOOL)intersectsSet: (OFSet*)set { OFAutoreleasePool *pool = [[OFAutoreleasePool alloc] init]; OFEnumerator *enumerator = [self objectEnumerator]; id object; while ((object = [enumerator nextObject]) != nil) { if ([set containsObject: object]) { [pool release]; return YES; } } [pool release]; return NO; } #ifdef OF_HAVE_BLOCKS - (void)enumerateObjectsUsingBlock: (of_set_enumeration_block_t)block { OFAutoreleasePool *pool = [[OFAutoreleasePool alloc] init]; OFEnumerator *enumerator = [self objectEnumerator]; id object; BOOL stop = NO; while (!stop && (object = [enumerator nextObject]) != nil) block(object, &stop); [pool release]; } - (OFSet*)filteredSetUsingBlock: (of_set_filter_block_t)block { OFMutableSet *ret = [OFMutableSet set]; [self enumerateObjectsUsingBlock: ^ (id object, BOOL *stop) { if (block(object)) [ret addObject: object]; }]; [ret makeImmutable]; return ret; } #endif @end |
Added src/OFSet_hashtable.h version [44a4a0ebed].
> > > > > > > > > > > > > > > > > > > > > > > > > | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 | /* * Copyright (c) 2008, 2009, 2010, 2011 * Jonathan Schleifer <js@webkeks.org> * * All rights reserved. * * This file is part of ObjFW. It may be distributed under the terms of the * Q Public License 1.0, which can be found in the file LICENSE.QPL included in * the packaging of this file. * * Alternatively, it may be distributed under the terms of the GNU General * Public License, either version 2 or 3, which can be found in the file * LICENSE.GPLv2 or LICENSE.GPLv3 respectively included in the packaging of this * file. */ #import "OFSet.h" @class OFMutableDictionary_hashtable; @interface OFSet_hashtable: OFSet { OFMutableDictionary_hashtable *dictionary; } @end |
Added src/OFSet_hashtable.m version [5a68e86a25].
> > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 | /* * Copyright (c) 2008, 2009, 2010, 2011 * Jonathan Schleifer <js@webkeks.org> * * All rights reserved. * * This file is part of ObjFW. It may be distributed under the terms of the * Q Public License 1.0, which can be found in the file LICENSE.QPL included in * the packaging of this file. * * Alternatively, it may be distributed under the terms of the GNU General * Public License, either version 2 or 3, which can be found in the file * LICENSE.GPLv2 or LICENSE.GPLv3 respectively included in the packaging of this * file. */ #include "config.h" #define OF_SET_HASHTABLE_M #import "OFSet_hashtable.h" #import "OFMutableDictionary_hashtable.h" #import "OFArray.h" #import "OFString.h" #import "OFNumber.h" #import "OFAutoreleasePool.h" @implementation OFSet_hashtable - init { self = [super init]; @try { dictionary = [[OFMutableDictionary_hashtable alloc] init]; } @catch (id e) { [self release]; @throw e; } return self; } - initWithSet: (OFSet*)set { self = [self init]; @try { OFAutoreleasePool *pool = [[OFAutoreleasePool alloc] init]; OFNumber *one = [OFNumber numberWithSize: 1]; OFEnumerator *enumerator = [set objectEnumerator]; id object; /* * We can't just copy the dictionary as the specified set might * be a counted set, but we're just a normal set. */ while ((object = [enumerator nextObject]) != nil) [dictionary _setObject: one forKey: object copyKey: NO]; [pool release]; } @catch (id e) { [self release]; @throw e; } return self; } - initWithArray: (OFArray*)array { self = [self init]; @try { OFAutoreleasePool *pool = [[OFAutoreleasePool alloc] init]; OFNumber *one = [OFNumber numberWithSize: 1]; id *cArray = [array cArray]; size_t i, count = [array count]; for (i = 0; i < count; i++) [dictionary _setObject: one forKey: cArray[i] copyKey: NO]; [pool release]; } @catch (id e) { [self release]; @throw e; } return self; } - initWithObject: (id)firstObject arguments: (va_list)arguments { self = [self init]; @try { OFAutoreleasePool *pool = [[OFAutoreleasePool alloc] init]; OFNumber *one = [OFNumber numberWithSize: 1]; id object; [dictionary _setObject: one forKey: firstObject copyKey: NO]; while ((object = va_arg(arguments, id)) != nil) [dictionary _setObject: one forKey: object copyKey: NO]; [pool release]; } @catch (id e) { [self release]; @throw e; } return self; } - (void)dealloc { [dictionary release]; [super dealloc]; } - (size_t)count { return [dictionary count]; } - (BOOL)containsObject: (id)object { return ([dictionary objectForKey: object] != nil); } - (BOOL)isEqual: (id)object { OFSet_hashtable *otherSet; if (![object isKindOfClass: [OFSet_hashtable class]] /*&& ![object isKindOfClass: [OFMutableSet_hashtable class]] && ![object isKindOfClass: [OFCountedSet_hashtable class]]*/) return [super isEqual: object]; otherSet = object; return [otherSet->dictionary isEqual: dictionary]; } - (OFEnumerator*)objectEnumerator { return [dictionary keyEnumerator]; } - (int)countByEnumeratingWithState: (of_fast_enumeration_state_t*)state objects: (id*)objects count: (int)count { return [dictionary countByEnumeratingWithState: state objects: objects count: count]; } #ifdef OF_HAVE_BLOCKS - (void)enumerateObjectsUsingBlock: (of_set_enumeration_block_t)block { [dictionary enumerateKeysAndObjectsUsingBlock: ^ (id key, id object, BOOL *stop) { block(key, stop); }]; } #endif @end |