Comment: | Add support for and use the new nullability |
---|---|
Downloads: | Tarball | ZIP archive | SQL archive |
Timelines: | family | ancestors | descendants | both | trunk |
Files: | files | file ages | folders |
SHA3-256: |
9e76144ef8bd60cee8f2745faab1678d |
User & Date: | js on 2015-06-13 22:26:05 |
Other Links: | manifest | tags |
2015-06-14
| ||
10:45 | Add OF_NONNULL / OF_NULLABLE and use that instead check-in: b7097a67b6 user: js tags: trunk | |
2015-06-13
| ||
22:26 | Add support for and use the new nullability check-in: 9e76144ef8 user: js tags: trunk | |
11:11 | Update ObjFW.xcodeproj to Xcode 7 check-in: f25b2c9e91 user: js tags: trunk | |
Modified src/OFApplication.h from [b8b3df6515] to [efd0ac2883].
︙ | |||
12 13 14 15 16 17 18 19 20 21 22 23 24 25 | 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 | + + | * 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 "OFObject.h" OF_ASSUME_NONNULL_BEGIN @class OFString; #ifndef DOXYGEN @class OFArray OF_GENERIC(ObjectType); @class OFDictionary OF_GENERIC(KeyType, ObjectType); @class OFMutableArray OF_GENERIC(ObjectType); @class OFMutableDictionary OF_GENERIC(KeyType, ObjectType); #endif |
︙ | |||
129 130 131 132 133 134 135 | 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 | - + | } #ifdef OF_HAVE_PROPERTIES @property (readonly, copy, nonatomic) OFString *programName; @property (readonly, copy, nonatomic) OFArray OF_GENERIC(OFString*) *arguments; @property (readonly, copy, nonatomic) OFDictionary OF_GENERIC(OFString*, OFString*) *environment; |
︙ | |||
178 179 180 181 182 183 184 | 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 | - - + + | /*! * @brief Gets args and argv. * * @param argc A pointer where a pointer to argc should be stored * @param argv A pointer where a pointer to argv should be stored */ |
︙ | |||
207 208 209 210 211 212 213 | 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 | - + - + - + + + + | - (OFDictionary OF_GENERIC(OFString*, OFString*)*)environment; /*! * @brief Returns the delegate of the application. * * @return The delegate of the application */ |
Modified src/OFArray.h from [3b343ee011] to [f02c7b62f7].
︙ | |||
26 27 28 29 30 31 32 33 34 35 36 37 38 39 | 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 | + + | #import "OFObject.h" #import "OFCollection.h" #import "OFEnumerator.h" #import "OFSerialization.h" #import "OFJSONRepresentation.h" #import "OFMessagePackRepresentation.h" OF_ASSUME_NONNULL_BEGIN /*! @file */ @class OFString; enum { OF_ARRAY_SKIP_EMPTY = 1, OF_ARRAY_SORT_DESCENDING = 2, |
︙ | |||
63 64 65 66 67 68 69 | 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 | - + - + | /*! * @brief A block for mapping objects to objects in an OFArray. * * @param object The object to map * @param index The index of the object to map * @return The object to map to */ |
︙ | |||
133 134 135 136 137 138 139 | 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 | - + | * @brief Creates a new OFArray with the objects from the specified C array of * the specified length. * * @param objects A C array of objects * @param count The length of the C array * @return A new autoreleased OFArray */ |
︙ | |||
178 179 180 181 182 183 184 | 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 | - + - + - + | * @brief Initializes an OFArray with the objects from the specified C array of * the specified length. * * @param objects A C array of objects * @param count The length of the C array * @return An initialized OFArray */ |
︙ | |||
236 237 238 239 240 241 242 | 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 | - + - + - + - + | /*! * @brief Checks whether the array contains an object equal to the specified * object. * * @param object The object which is checked for being in the array * @return A boolean whether the array contains the specified object */ |
︙ | |||
342 343 344 345 346 347 348 | 344 345 346 347 348 349 350 351 352 353 354 355 356 357 358 | - + | * specified object. * * @param selector The selector to perform on all objects in the array * @param object The object to perform the selector with on all objects in the * array */ - (void)makeObjectsPerformSelector: (SEL)selector |
︙ | |||
446 447 448 449 450 451 452 | 448 449 450 451 452 453 454 455 456 457 458 459 460 461 462 463 464 465 466 467 468 469 470 471 472 473 474 475 476 477 478 479 480 481 482 | - + - + + + | * except the first, where left is always to what the array has already been * folded and right what should be added to left. * * @param block A block which folds two objects into one, which is called for * all objects except the first * @return The array folded to a single object */ |
Modified src/OFArray_adjacent.h from [777201fd2e] to [8b070c069d].
︙ | |||
12 13 14 15 16 17 18 19 20 21 22 23 24 25 | 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. */ #import "OFArray.h" OF_ASSUME_NONNULL_BEGIN @class OFDataArray; @interface OFArray_adjacent: OFArray { OFDataArray *_array; } @end OF_ASSUME_NONNULL_END |
Modified src/OFArray_adjacentSubarray.h from [8326d185e5] to [35a14732b3].
︙ | |||
11 12 13 14 15 16 17 18 19 20 | 11 12 13 14 15 16 17 18 19 20 21 22 23 24 | + + + + | * 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 "OFArray_subarray.h" OF_ASSUME_NONNULL_BEGIN @interface OFArray_adjacentSubarray: OFArray_subarray @end OF_ASSUME_NONNULL_END |
Modified src/OFArray_subarray.h from [bdc7298609] to [5c479443ba].
︙ | |||
11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 | 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 | + + + + | * Alternatively, it may be distributed under the terms of the GNU General * Public License, either version 2 or 3, which can be found in the file * LICENSE.GPLv2 or LICENSE.GPLv3 respectively included in the packaging of this * file. */ #import "OFArray.h" OF_ASSUME_NONNULL_BEGIN @interface OFArray_subarray: OFArray { OFArray *_array; of_range_t _range; } + (instancetype)arrayWithArray: (OFArray*)array range: (of_range_t)range; - initWithArray: (OFArray*)array range: (of_range_t)range; @end OF_ASSUME_NONNULL_END |
Modified src/OFAutoreleasePool+Private.h from [572e63f6a3] to [15b3ef0a51].
︙ | |||
11 12 13 14 15 16 17 18 19 20 21 22 | 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 | + + + + | * 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 "OFAutoreleasePool.h" OF_ASSUME_NONNULL_BEGIN @interface OFAutoreleasePool (OF_PRIVATE_CATEGORY) + (void)OF_handleThreadTermination; - (void)OF_super_dealloc; @end OF_ASSUME_NONNULL_END |
Modified src/OFAutoreleasePool.h from [d9cfb7f06a] to [c4fa3ea10e].
︙ | |||
12 13 14 15 16 17 18 19 20 21 22 23 24 25 | 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 | + + | * 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 "OFObject.h" OF_ASSUME_NONNULL_BEGIN /*! * @class OFAutoreleasePool OFAutoreleasePool.h ObjFW/OFAutoreleasePool.h * * @brief A pool that keeps track of objects to release. * * The OFAutoreleasePool class is a class that keeps track of objects that will * be released when the autorelease pool is released. |
︙ | |||
72 73 74 75 76 77 78 | 74 75 76 77 78 79 80 81 82 | + + | #ifdef __cplusplus extern "C" { #endif extern id of_autorelease(id); #ifdef __cplusplus } #endif OF_ASSUME_NONNULL_END |
Modified src/OFBigDataArray.h from [c97b3ec377] to [3e034e5ab6].
︙ | |||
12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 | 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 | + + + + | * Public License, either version 2 or 3, which can be found in the file * LICENSE.GPLv2 or LICENSE.GPLv3 respectively included in the packaging of this * file. */ #import "OFDataArray.h" OF_ASSUME_NONNULL_BEGIN /*! * @class OFBigDataArray OFBigDataArray.h ObjFW/OFBigDataArray.h * * @brief A class for storing arbitrary big data in an array. * * The OFBigDataArray class is a class for storing arbitrary data in an array * and is designed to store large hunks of data. Therefore, it allocates * memory in pages rather than a chunk of memory for each item. */ @interface OFBigDataArray: OFDataArray { size_t _size; } @end OF_ASSUME_NONNULL_END |
Modified src/OFBlock.h from [5b982e6c1a] to [01e4fda855].
︙ | |||
14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 | 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 | + + + + | * file. */ #import "OFObject.h" #import "block.h" OF_ASSUME_NONNULL_BEGIN /*! * @class OFBlock OFBlock.h ObjFW/OFBlock.h * * @brief The class for all blocks, since all blocks are also objects. */ @interface OFBlock: OFObject @end @interface OFStackBlock: OFBlock @end @interface OFGlobalBlock: OFBlock @end @interface OFMallocBlock: OFBlock @end OF_ASSUME_NONNULL_END |
Modified src/OFCollection.h from [57a89b6a29] to [ca64037e5a].
︙ | |||
12 13 14 15 16 17 18 19 20 21 22 23 24 25 | 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 | + + | * 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 "OFEnumerator.h" OF_ASSUME_NONNULL_BEGIN /*! * @protocol OFCollection OFCollection.h ObjFW/OFCollection.h * * @brief A protocol with methods common for all collections. */ @protocol OFCollection <OFEnumerating, OFFastEnumeration> #ifdef OF_HAVE_PROPERTIES |
︙ | |||
36 37 38 39 40 41 42 | 38 39 40 41 42 43 44 45 46 47 48 | - + + + | /*! * @brief Checks whether the collection contains an object equal to the * specified object. * * @param object The object which is checked for being in the collection * @return A boolean whether the collection contains the specified object */ |
Modified src/OFCondition.h from [745b1cab73] to [c33a65126c].
︙ | |||
12 13 14 15 16 17 18 19 20 21 22 23 24 25 | 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 | + + | * 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 "OFMutex.h" OF_ASSUME_NONNULL_BEGIN @class OFDate; /*! * @class OFCondition OFCondition.h ObjFW/OFCondition.h * * @brief A class implementing a condition variable for thread synchronization. */ |
︙ | |||
66 67 68 69 70 71 72 | 68 69 70 71 72 73 74 75 76 | + + | - (void)signal; /*! * @brief Signals all threads to continue. */ - (void)broadcast; @end OF_ASSUME_NONNULL_END |
Modified src/OFConstantString.h from [b952a6d48c] to [ab4546c924].
︙ | |||
11 12 13 14 15 16 17 18 19 20 21 22 23 24 | 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 | + + | * 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 "OFString.h" OF_ASSUME_NONNULL_BEGIN #if !defined(OF_CONSTANT_STRING_M) && \ defined(OF_APPLE_RUNTIME) && !defined(__OBJC2__) # ifdef __cplusplus extern "C" { # endif extern void *_OFConstantStringClassReference; |
︙ | |||
34 35 36 37 38 39 40 | 36 37 38 39 40 41 42 43 44 | + + | */ @interface OFConstantString: OFString { char *_cString; unsigned int _cStringLength; } @end OF_ASSUME_NONNULL_END |
Modified src/OFCountedSet.h from [0b0a8e2d9d] to [5313d3ec39].
︙ | |||
12 13 14 15 16 17 18 19 20 21 22 23 24 25 | 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 | + + | * 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" OF_ASSUME_NONNULL_BEGIN /*! @file */ #ifdef OF_HAVE_BLOCKS /*! * @brief A block for enumerating an OFCountedSet. * * @param object The current object |
︙ | |||
61 62 63 64 65 66 67 | 63 64 65 66 67 68 69 70 71 | + + | - (void)enumerateObjectsAndCountUsingBlock: (of_counted_set_enumeration_block_t)block; #endif @end #if !defined(OF_HAVE_GENERICS) && !defined(DOXYGEN) # undef ObjectType #endif OF_ASSUME_NONNULL_END |
Modified src/OFCountedSet_hashtable.h from [7b0360b3f8] to [c4031acd18].
︙ | |||
12 13 14 15 16 17 18 19 20 21 22 23 24 25 | 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. */ #import "OFCountedSet.h" OF_ASSUME_NONNULL_BEGIN @class OFMapTable; @interface OFCountedSet_hashtable: OFCountedSet { OFMapTable *_mapTable; } @end OF_ASSUME_NONNULL_END |
Modified src/OFDataArray+Hashing.h from [395a3e3df7] to [9fd7a3ae5d].
︙ | |||
12 13 14 15 16 17 18 19 20 21 22 23 24 25 | 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 | + + | * 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 "OFDataArray.h" OF_ASSUME_NONNULL_BEGIN @class OFString; #ifdef __cplusplus extern "C" { #endif extern int _OFDataArray_Hashing_reference; #ifdef __cplusplus |
︙ | |||
77 78 79 80 81 82 83 | 79 80 81 82 83 84 85 86 87 | + + | * @brief Returns the SHA-512 hash of the data array as an autoreleased * OFString. * * @return The SHA-512 hash of the data array as an autoreleased OFString */ - (OFString*)SHA512Hash; @end OF_ASSUME_NONNULL_END |
Modified src/OFDataArray+MessagePackValue.h from [fd122e8b07] to [63099f0f3d].
︙ | |||
12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 | 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 | + + + + | * 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 "OFDataArray.h" OF_ASSUME_NONNULL_BEGIN #ifdef __cplusplus extern "C" { #endif extern int _OFDataArray_MessagePackValue_reference; #ifdef __cplusplus } #endif @interface OFDataArray (MessagePackValue) /*! * @brief Parses the MessagePack representation and returns it as an object. * * @return The MessagePack representation as an object */ - (id)messagePackValue; @end OF_ASSUME_NONNULL_END |
Modified src/OFDataArray.h from [5959e95840] to [dbaf155683].
︙ | |||
14 15 16 17 18 19 20 21 22 23 24 25 26 27 | 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 | + + | * file. */ #import "OFObject.h" #import "OFSerialization.h" #import "OFMessagePackRepresentation.h" OF_ASSUME_NONNULL_BEGIN @class OFString; @class OFURL; /*! * @class OFDataArray OFDataArray.h ObjFW/OFDataArray.h * * @brief A class for storing arbitrary data in an array. |
︙ | |||
226 227 228 229 230 231 232 | 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 | - + - + | - (void*)itemAtIndex: (size_t)index OF_RETURNS_INNER_POINTER; /*! * @brief Returns the first item of the OFDataArray. * * @return The first item of the OFDataArray or NULL */ |
︙ | |||
321 322 323 324 325 326 327 328 329 330 | 323 324 325 326 327 328 329 330 331 332 333 334 | + + | * @brief Writes the OFDataArray into the specified file. * * @param path The path of the file to write to */ - (void)writeToFile: (OFString*)path; #endif @end OF_ASSUME_NONNULL_END #import "OFDataArray+Hashing.h" #import "OFDataArray+MessagePackValue.h" |
Modified src/OFDate.h from [a91a3bb659] to [5fea3d4d33].
︙ | |||
13 14 15 16 17 18 19 20 21 22 23 24 25 26 | 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 | + + | * LICENSE.GPLv2 or LICENSE.GPLv3 respectively included in the packaging of this * file. */ #import "OFObject.h" #import "OFSerialization.h" OF_ASSUME_NONNULL_BEGIN @class OFString; @class OFConstantString; /*! * @class OFDate OFDate.h ObjFW/OFDate.h * * @brief A class for storing, accessing and comparing dates. |
︙ | |||
334 335 336 337 338 339 340 | 336 337 338 339 340 341 342 343 344 | + + | * @brief Creates a new date with the specified time interval added. * * @param seconds The seconds after the date * @return A new, autoreleased OFDate */ - (OFDate*)dateByAddingTimeInterval: (of_time_interval_t)seconds; @end OF_ASSUME_NONNULL_END |
Modified src/OFDictionary.h from [357ef085a2] to [85eedadac8].
︙ | |||
25 26 27 28 29 30 31 32 33 34 35 36 37 38 | 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 | + + - + | #import "OFObject.h" #import "OFCollection.h" #import "OFEnumerator.h" #import "OFSerialization.h" #import "OFJSONRepresentation.h" #import "OFMessagePackRepresentation.h" OF_ASSUME_NONNULL_BEGIN @class OFArray OF_GENERIC(ObjectType); #ifdef OF_HAVE_BLOCKS typedef void (^of_dictionary_enumeration_block_t)(id key, id object, bool *stop); typedef bool (^of_dictionary_filter_block_t)(id key, id object); |
︙ | |||
101 102 103 104 105 106 107 | 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 | - - - + + + + | * @brief Creates a new OFDictionary with the specified keys and objects. * * @param keys An array of keys * @param objects An array of objects * @param count The number of objects in the arrays * @return A new autoreleased OFDictionary */ |
︙ | |||
154 155 156 157 158 159 160 | 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 | - - + + | * and objects. * * @param keys An array of keys * @param objects An array of objects * @param count The number of objects in the arrays * @return An initialized OFDictionary */ |
︙ | |||
187 188 189 190 191 192 193 | 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 | - - + + - + - + | * * @warning The returned object is *not* retained and autoreleased for * performance reasons! * * @param key The key whose object should be returned * @return The object for the given key or nil if the key was not found */ |
︙ | |||
272 273 274 275 276 277 278 279 280 281 282 283 284 285 | 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 | + + | (of_dictionary_filter_block_t)block; #endif @end #if !defined(OF_HAVE_GENERICS) && !defined(DOXYGEN) # undef KeyType # undef ObjectType #endif OF_ASSUME_NONNULL_END #import "OFMutableDictionary.h" #ifndef NSINTEGER_DEFINED /* Required for dictionary literals to work */ @compatibility_alias NSDictionary OFDictionary; #endif |
Modified src/OFDictionary_hashtable.h from [2e15481966] to [d0f64480f3].
︙ | |||
12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 | 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 | + + + + | * Public License, either version 2 or 3, which can be found in the file * LICENSE.GPLv2 or LICENSE.GPLv3 respectively included in the packaging of this * file. */ #import "OFDictionary.h" OF_ASSUME_NONNULL_BEGIN @class OFMapTable; @class OFMapTableEnumerator; @interface OFDictionary_hashtable: OFDictionary { OFMapTable *_mapTable; } - initWithCapacity: (size_t)capacity; @end OF_ASSUME_NONNULL_END |
Modified src/OFEnumerator.h from [289c822ada] to [00a9d26e5f].
︙ | |||
12 13 14 15 16 17 18 19 20 21 22 23 24 25 | 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 | + + | * 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 "OFObject.h" OF_ASSUME_NONNULL_BEGIN #ifndef DOXYGEN @class OFEnumerator OF_GENERIC(ObjectType); @class OFArray OF_GENERIC(ObjectType); #endif /*! * @protocol OFEnumerating OFEnumerator.h ObjFW/OFEnumerator.h |
︙ | |||
46 47 48 49 50 51 52 | 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 | - + - + - + | #else # ifndef DOXYGEN # define ObjectType id # endif @interface OFEnumerator: OFObject #endif /*! |
︙ | |||
86 87 88 89 90 91 92 | 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 | - + - + | */ #define of_fast_enumeration_state_t NSFastEnumerationState #ifndef NSINTEGER_DEFINED typedef struct { /// Arbitrary state information for the enumeration unsigned long state; /// Pointer to a C array of objects to return |
︙ | |||
114 115 116 117 118 119 120 | 116 117 118 119 120 121 122 123 124 125 126 127 128 | - + + + + | * @param state Context information for the enumeration * @param objects A pointer to an array where to put the objects * @param count The number of objects that can be stored at objects * @return The number of objects returned in objects or 0 when the enumeration * finished. */ - (int)countByEnumeratingWithState: (of_fast_enumeration_state_t*)state |
Modified src/OFFile.h from [ebd8f096a0] to [03d8a7c1d4].
︙ | |||
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 36 | + + | # define __STDC_CONSTANT_MACROS #endif #include <sys/types.h> #include <sys/stat.h> #import "OFSeekableStream.h" OF_ASSUME_NONNULL_BEGIN @class OFArray OF_GENERIC(ObjectType); @class OFDate; #if defined(_WIN32) typedef struct __stat64 of_stat_t; #elif defined(OF_HAVE_OFF64_T) |
︙ | |||
325 326 327 328 329 330 331 | 327 328 329 330 331 332 333 334 335 | + + | extern "C" { #endif extern int of_stat(OFString *path, of_stat_t *buffer); extern int of_lstat(OFString *path, of_stat_t *buffer); #ifdef __cplusplus } #endif OF_ASSUME_NONNULL_END |
Modified src/OFHTTPClient.h from [65cccf1fb8] to [74c3496cfd].
︙ | |||
16 17 18 19 20 21 22 23 24 25 26 27 28 29 | 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 | + + | #import "OFObject.h" #ifndef OF_HAVE_SOCKETS # error No sockets available! #endif OF_ASSUME_NONNULL_BEGIN @class OFHTTPClient; @class OFHTTPRequest; @class OFHTTPResponse; @class OFURL; @class OFTCPSocket; @class OFDictionary OF_GENERIC(KeyType, ObjectType); @class OFDataArray; |
︙ | |||
104 105 106 107 108 109 110 | 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 | - + - + - + | OFTCPSocket *_socket; OFURL *_lastURL; bool _lastWasHEAD; OFHTTPResponse *_lastResponse; } #ifdef OF_HAVE_PROPERTIES |
︙ | |||
170 171 172 173 174 175 176 | 172 173 174 175 176 177 178 179 180 | + + | * @brief Closes connections that are still open due to keep-alive. */ - (void)close; @end @interface OFObject (OFHTTPClientDelegate) <OFHTTPClientDelegate> @end OF_ASSUME_NONNULL_END |
Modified src/OFHTTPRequest.h from [22005b677b] to [523bcf67ad].
︙ | |||
17 18 19 20 21 22 23 24 25 26 27 28 29 30 | 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 | + + | #import "OFObject.h" #import "OFString.h" #ifndef OF_HAVE_SOCKETS # error No sockets available! #endif OF_ASSUME_NONNULL_BEGIN @class OFURL; @class OFDictionary OF_GENERIC(KeyType, ObjectType); @class OFDataArray; @class OFString; /*! @file */ |
︙ | |||
78 79 80 81 82 83 84 | 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 | - - - + + + + | OFString *_remoteAddress; } #ifdef OF_HAVE_PROPERTIES @property (copy) OFURL *URL; @property of_http_request_method_t method; @property of_http_request_protocol_version_t protocolVersion; |
︙ | |||
168 169 170 171 172 173 174 | 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 | + - + - + - + - + - + - + - + - + - + + + | - (OFString*)protocolVersionString; /*! * @brief Sets a dictionary with headers for the HTTP request. * * @param headers A dictionary with headers for the HTTP request */ - (void)setHeaders: |
Modified src/OFHTTPResponse.h from [988402eb89] to [043802ccf0].
︙ | |||
12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 | 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 | + + - + + | * Public License, either version 2 or 3, which can be found in the file * LICENSE.GPLv2 or LICENSE.GPLv3 respectively included in the packaging of this * file. */ #import "OFStream.h" #import "OFHTTPRequest.h" OF_ASSUME_NONNULL_BEGIN @class OFDictionary OF_GENERIC(KeyType, ObjectType); /*! * @class OFHTTPResponse OFHTTPResponse.h ObjFW/OFHTTPResponse.h * * @brief A class for representing an HTTP request reply as a stream. */ @interface OFHTTPResponse: OFStream { of_http_request_protocol_version_t _protocolVersion; short _statusCode; OFDictionary OF_GENERIC(OFString*, OFString*) *_headers; } #ifdef OF_HAVE_PROPERTIES @property of_http_request_protocol_version_t protocolVersion; @property short statusCode; |
︙ | |||
81 82 83 84 85 86 87 | 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 | - + + - + + + | - (void)setStatusCode: (short)statusCode; /*! * @brief Returns the headers of the reply to the HTTP request. * * @return The headers of the reply to the HTTP request */ |
Modified src/OFHTTPServer.h from [a748f86500] to [1d47d66b5b].
︙ | |||
16 17 18 19 20 21 22 23 24 25 26 27 28 29 | 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 | + + | #import "OFObject.h" #ifndef OF_HAVE_SOCKETS # error No sockets available! #endif OF_ASSUME_NONNULL_BEGIN @class OFHTTPServer; @class OFHTTPRequest; @class OFHTTPResponse; @class OFTCPSocket; @class OFException; /*! |
︙ | |||
73 74 75 76 77 78 79 | 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 | - + - - + + - + - + - + - + - + - + + + | uint16_t _port; id <OFHTTPServerDelegate> _delegate; OFString *_name; OFTCPSocket *_listeningSocket; } #ifdef OF_HAVE_PROPERTIES |
Modified src/OFHash.h from [3407d4c3db] to [3d6ceb79ea].
︙ | |||
12 13 14 15 16 17 18 19 20 21 22 23 24 25 | 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 | + + | * 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 "OFObject.h" OF_ASSUME_NONNULL_BEGIN /*! * @protocol OFHash OFHash.h ObjFW/OFHash.h * * @brief A protocol for classes providing hash functions. */ @protocol OFHash <OFObject> #ifdef OF_HAVE_PROPERTIES |
︙ | |||
78 79 80 81 82 83 84 | 80 81 82 83 84 85 86 87 88 | + + | * * @warning This invalidates any pointer previously returned by @ref digest. If * you are still interested in the previous digest, you need to memcpy * it yourself before calling @ref reset! */ - (void)reset; @end OF_ASSUME_NONNULL_END |
Modified src/OFINICategory+Private.h from [f3dd9db12f] to [57eb45a3d8].
︙ | |||
13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 | 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 | + + + + | * LICENSE.GPLv2 or LICENSE.GPLv3 respectively included in the packaging of this * file. */ #import "OFINICategory.h" #import "OFString.h" OF_ASSUME_NONNULL_BEGIN @class OFStream; @interface OFINICategory (OF_PRIVATE_CATEGORY) - (instancetype)OF_init; - (void)OF_parseLine: (OFString*)line; - (bool)OF_writeToStream: (OFStream*)stream encoding: (of_string_encoding_t)encoding first: (bool)first; @end OF_ASSUME_NONNULL_END |
Modified src/OFINICategory.h from [96f0151dae] to [e2014b9e81].
︙ | |||
12 13 14 15 16 17 18 19 20 21 22 23 24 25 | 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 | + + | * 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 "OFObject.h" OF_ASSUME_NONNULL_BEGIN @class OFString; #ifndef DOXYGEN @class OFArray OF_GENERIC(ObjectType); @class OFMutableArray OF_GENERIC(ObjectType); #endif /*! |
︙ | |||
57 58 59 60 61 62 63 | 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 | - + - - + + | * * If the specified key is a multi-key (see @ref arrayForKey:), the value of * the first key/value pair found is returned. * * @param key The key for which the string value should be returned * @return The string value for the specified key, or nil if it does not exist */ |
︙ | |||
232 233 234 235 236 237 238 | 234 235 236 237 238 239 240 241 242 | + + | * If the specified key is a multi-key (see @ref arrayForKey:), all key/value * pairs matching the specified key are removed. * * @param key The key of the value to remove */ - (void)removeValueForKey: (OFString*)key; @end OF_ASSUME_NONNULL_END |
Modified src/OFINIFile.h from [2b02002d00] to [0ded227d84].
︙ | |||
13 14 15 16 17 18 19 20 21 22 23 24 25 26 | 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 | + + | * LICENSE.GPLv2 or LICENSE.GPLv3 respectively included in the packaging of this * file. */ #import "OFObject.h" #import "OFString.h" #import "OFINICategory.h" OF_ASSUME_NONNULL_BEGIN @class OFMutableArray OF_GENERIC(ObjectType); /*! * @class OFINIFile OFINIFile.h ObjFW/OFINIFile.h * * @brief A class for reading, creating and modifying INI files. |
︙ | |||
97 98 99 100 101 102 103 | 99 100 101 102 103 104 105 106 107 | + + | * * @param path The path of the file to write to * @param encoding The encoding to use */ - (void)writeToFile: (OFString*)path encoding: (of_string_encoding_t)encoding; @end OF_ASSUME_NONNULL_END |
Modified src/OFInflate64Stream.h from [351ad5a7b7] to [90b8b21020].
︙ | |||
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 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. */ #import "OFInflateStream.h" OF_ASSUME_NONNULL_BEGIN /*! * @class OFInflate64Stream OFInflate64Stream.h ObjFW/OFInflate64Stream.h * * @brief A class that handles Deflate64 decompression transparently for an * underlying stream. */ @interface OFInflate64Stream: OFInflateStream @end OF_ASSUME_NONNULL_END |
Modified src/OFInflateStream.h from [9d59f54685] to [b2d90d3bc7].
︙ | |||
11 12 13 14 15 16 17 18 19 20 21 22 23 24 | 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 | + + | * 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 "OFStream.h" OF_ASSUME_NONNULL_BEGIN #define OF_INFLATE_STREAM_BUFFER_SIZE 4096 /*! * @class OFInflateStream OFInflateStream.h ObjFW/OFInflateStream.h * * @brief A class that handles Deflate decompression transparently for an |
︙ | |||
93 94 95 96 97 98 99 | 95 96 97 98 99 100 101 102 103 | + + | * * @param stream The underlying stream to which compressed data is written or * from which compressed data is read * @return A initialized OFInflateStream */ - initWithStream: (OFStream*)stream; @end OF_ASSUME_NONNULL_END |
Modified src/OFIntrospection.h from [757a211040] to [0bd232c6bc].
︙ | |||
12 13 14 15 16 17 18 19 20 21 22 23 24 25 | 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 | + + | * 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 "OFObject.h" OF_ASSUME_NONNULL_BEGIN @class OFString; #ifndef DOXYGEN @class OFArray OF_GENERIC(ObjectType); @class OFMutableArray OF_GENERIC(ObjectType); #endif enum { |
︙ | |||
46 47 48 49 50 51 52 | 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 | - + | OFString *_name; const char *_typeEncoding; } #ifdef OF_HAVE_PROPERTIES @property (readonly) SEL selector; @property (readonly, copy) OFString *name; |
︙ | |||
68 69 70 71 72 73 74 | 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 | - + - + | - (OFString*)name; /*! * @brief Returns the type encoding for the method. * * @return The type encoding for the method */ |
︙ | |||
122 123 124 125 126 127 128 | 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 | - + - + - + | - (unsigned)attributes; /*! * @brief Returns the name of the getter. * * @return The name of the getter */ |
︙ | |||
169 170 171 172 173 174 175 | 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 | - + | - (ptrdiff_t)offset; /*! * @brief Returns the type encoding for the instance variable. * * @return The type encoding for the instance variable */ |
︙ | |||
255 256 257 258 259 260 261 | 257 258 259 260 261 262 263 264 265 | + + | * * @return An array of objects of class @ref OFInstanceVariable */ - (OFArray OF_GENERIC(OFInstanceVariable*)*)instanceVariables; /* TODO: protocols */ @end OF_ASSUME_NONNULL_END |
Modified src/OFJSONRepresentation.h from [4abe1573f2] to [8dc534c0fd].
︙ | |||
12 13 14 15 16 17 18 19 20 21 22 23 24 25 | 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 | + + | * 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. */ @class OFString; OF_ASSUME_NONNULL_BEGIN enum { OF_JSON_REPRESENTATION_PRETTY = 0x01, OF_JSON_REPRESENTATION_JSON5 = 0x02, OF_JSON_REPRESENTATION_IDENTIFIER = 0x10 }; /*! |
︙ | |||
51 52 53 54 55 56 57 | 53 54 55 56 57 58 59 60 61 | + + | * `OF_JSON_REPRESENTATION_PRETTY` | Optimize for readability * `OF_JSON_REPRESENTATION_JSON5` | Generate JSON5 * * @return The JSON representation of the object as a string */ - (OFString*)JSONRepresentationWithOptions: (int)options; @end OF_ASSUME_NONNULL_END |
Modified src/OFKernelEventObserver+Private.h from [dfd89ec8e7] to [e624333841].
︙ | |||
11 12 13 14 15 16 17 18 19 20 21 22 23 | 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 | + + - + + + | * 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 "OFKernelEventObserver.h" OF_ASSUME_NONNULL_BEGIN @interface OFKernelEventObserver (OF_PRIVATE_CATEGORY) - (void)OF_addObjectForReading: (id)object; - (void)OF_addObjectForWriting: (id)object; - (void)OF_removeObjectForReading: (id)object; - (void)OF_removeObjectForWriting: (id)object; |
Modified src/OFKernelEventObserver.h from [5f1691d0b1] to [134a6fc2ce].
︙ | |||
13 14 15 16 17 18 19 20 21 22 23 24 25 26 | 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 | + + | * LICENSE.GPLv2 or LICENSE.GPLv3 respectively included in the packaging of this * file. */ #import "OFObject.h" #import "socket.h" OF_ASSUME_NONNULL_BEGIN @class OFMutableArray OF_GENERIC(ObjectType); @class OFMutableDictionary OF_GENERIC(KeyType, ObjectType); @class OFDataArray; #ifdef OF_HAVE_THREADS @class OFMutex; #endif |
︙ | |||
123 124 125 126 127 128 129 | 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 | - + - + - + | #endif #ifdef OF_HAVE_THREADS OFMutex *_mutex; #endif } #ifdef OF_HAVE_PROPERTIES |
︙ | |||
224 225 226 227 228 229 230 | 226 227 228 229 230 231 232 233 234 | + + | */ - (void)cancel; @end @interface OFObject (OFKernelEventObserverDelegate) <OFKernelEventObserverDelegate> @end OF_ASSUME_NONNULL_END |
Modified src/OFKernelEventObserver_epoll.h from [a1c28950dc] to [6c5bfc2bcc].
︙ | |||
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 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. */ #import "OFKernelEventObserver.h" OF_ASSUME_NONNULL_BEGIN @class OFMapTable; @interface OFKernelEventObserver_epoll: OFKernelEventObserver { int _epfd; OFMapTable *_FDToEvents; } @end OF_ASSUME_NONNULL_END |
Modified src/OFKernelEventObserver_kqueue.h from [59ced1df2f] to [59a7d7f5c7].
︙ | |||
12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 | 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 | + + + + | * Public License, either version 2 or 3, which can be found in the file * LICENSE.GPLv2 or LICENSE.GPLv3 respectively included in the packaging of this * file. */ #import "OFKernelEventObserver.h" OF_ASSUME_NONNULL_BEGIN @class OFDataArray; @class OFMutableArray OF_GENERIC(ObjectType); @interface OFKernelEventObserver_kqueue: OFKernelEventObserver { int _kernelQueue; OFDataArray *_changeList; OFMutableArray *_removedArray; } @end OF_ASSUME_NONNULL_END |
Modified src/OFKernelEventObserver_poll.h from [f1ee0351df] to [8cd049f795].
︙ | |||
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 26 27 28 29 30 31 | + + + + | * Public License, either version 2 or 3, which can be found in the file * LICENSE.GPLv2 or LICENSE.GPLv3 respectively included in the packaging of this * file. */ #import "OFKernelEventObserver.h" OF_ASSUME_NONNULL_BEGIN @class OFDataArray; @interface OFKernelEventObserver_poll: OFKernelEventObserver { OFDataArray *_FDs; size_t _maxFD; __unsafe_unretained id *_FDToObject; } @end OF_ASSUME_NONNULL_END |
Modified src/OFKernelEventObserver_select.h from [ba6ed69d4a] to [ff27d287c3].
︙ | |||
22 23 24 25 26 27 28 29 30 31 32 33 34 35 | 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 | + + + + | #endif #ifdef HAVE_SYS_SELECT_H # include <sys/select.h> #endif #import "OFKernelEventObserver.h" OF_ASSUME_NONNULL_BEGIN @interface OFKernelEventObserver_select: OFKernelEventObserver { fd_set _readFDs, _writeFDs; int _maxFD; } @end OF_ASSUME_NONNULL_END |
Modified src/OFList.h from [41ad30e5c0] to [badebf99e1].
︙ | |||
14 15 16 17 18 19 20 21 22 23 24 25 26 27 | 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 | + + | * file. */ #import "OFObject.h" #import "OFCollection.h" #import "OFEnumerator.h" #import "OFSerialization.h" OF_ASSUME_NONNULL_BEGIN typedef struct of_list_object_t of_list_object_t; /*! * @struct of_list_object_t OFList.h ObjFW/OFList.h * * @brief A list object. * |
︙ | |||
55 56 57 58 59 60 61 | 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 | - - + + - + - + | of_list_object_t *_firstListObject; of_list_object_t *_lastListObject; size_t _count; unsigned long _mutations; } #ifdef OF_HAVE_PROPERTIES |
︙ | |||
140 141 142 143 144 145 146 | 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 | - + - + - + - + | /*! * @brief Checks whether the list contains an object equal to the specified * object. * * @param object The object which is checked for being in the list * @return A boolean whether the list contains the specified object */ |
︙ | |||
198 199 200 201 202 203 204 | 200 201 202 203 204 205 206 207 208 | + + | unsigned long _mutations; unsigned long *_mutationsPtr; } - initWithList: (OFList*)list mutationsPointer: (unsigned long*)mutationsPtr; @end OF_ASSUME_NONNULL_END |
Modified src/OFLocking.h from [ff0b514bb3] to [aabddd2a24].
︙ | |||
12 13 14 15 16 17 18 19 20 21 22 23 24 25 | 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 | + + - + | * Public License, either version 2 or 3, which can be found in the file * LICENSE.GPLv2 or LICENSE.GPLv3 respectively included in the packaging of this * file. */ #import "OFObject.h" OF_ASSUME_NONNULL_BEGIN /*! * @protocol OFLocking OFLocking.h ObjFW/OFLocking.h * * @brief A protocol for locks. */ @protocol OFLocking <OFObject> #ifdef OF_HAVE_PROPERTIES |
︙ | |||
44 45 46 47 48 49 50 | 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 | - + - + + + | - (void)unlock; /*! * @brief Sets a name for the lock. * * @param name The name for the lock */ |
Modified src/OFMD5Hash.h from [f6743c94bf] to [802d16ca17].
︙ | |||
12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 | 12 13 14 15 16 17 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. */ #import "OFHash.h" OF_ASSUME_NONNULL_BEGIN /*! * @class OFMD5Hash OFMD5Hash.h ObjFW/OFMD5Hash.h * * @brief A class which provides functions to create an MD5 hash. */ @interface OFMD5Hash: OFObject <OFHash> { uint32_t _state[4]; uint64_t _bits; union { uint8_t bytes[64]; uint32_t words[16]; } _buffer; size_t _bufferLength; bool _calculated; } - (void)OF_resetState; @end OF_ASSUME_NONNULL_END |
Modified src/OFMapTable+Private.h from [6d5ea1749d] to [3115c68700].
︙ | |||
11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 | 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 | + + + + | * 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 "OFMapTable.h" OF_ASSUME_NONNULL_BEGIN @interface OFMapTable_EnumeratorWrapper: OFEnumerator { OFMapTableEnumerator *_enumerator; id _object; } - initWithEnumerator: (OFMapTableEnumerator*)enumerator object: (id)object; @end OF_ASSUME_NONNULL_END |
Modified src/OFMapTable.h from [d4d456e6cd] to [03ba48a726].
︙ | |||
13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 | 13 14 15 16 17 18 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 | + + - + - + - + + - + | * LICENSE.GPLv2 or LICENSE.GPLv3 respectively included in the packaging of this * file. */ #import "OFObject.h" #import "OFEnumerator.h" OF_ASSUME_NONNULL_BEGIN /*! @file */ /*! * @struct of_map_table_functions_t OFMapTable.h ObjFW/OFMapTable.h * * @brief A struct describing the functions to be used by the map table. */ typedef struct { /// The function to retain keys / values |
︙ | |||
50 51 52 53 54 55 56 | 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 | - + | /*! * @brief A block for replacing values in an OFMapTable. * * @param key The key of the value to replace * @param value The value to replace * @return The value to replace the value with */ |
︙ | |||
129 130 131 132 133 134 135 | 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 | - + - + - + | * @brief Returns the number of objects in the map table. * * @return The number of objects in the map table */ - (size_t)count; /*! |
︙ | |||
164 165 166 167 168 169 170 | 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 | - + - + | /*! * @brief Checks whether the map table contains a value equal to the specified * value. * * @param value The value which is checked for being in the map table * @return A boolean whether the map table contains the specified value */ |
︙ | |||
253 254 255 256 257 258 259 | 256 257 258 259 260 261 262 263 264 | + + | /*! * @brief Resets the enumerator, so the next call to nextKey returns the first * key again. */ - (void)reset; @end OF_ASSUME_NONNULL_END |
Modified src/OFMessagePackExtension.h from [059cbd7345] to [62dc4c8908].
︙ | |||
13 14 15 16 17 18 19 20 21 22 23 24 25 26 | 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 | + + | * LICENSE.GPLv2 or LICENSE.GPLv3 respectively included in the packaging of this * file. */ #import "OFObject.h" #import "OFMessagePackRepresentation.h" OF_ASSUME_NONNULL_BEGIN @class OFDataArray; /*! * @class OFMessagePackExtension \ * OFMessagePackExtension.h ObjFW/OFMessagePackExtension.h * * @brief A class for representing the MessagePack extension type. |
︙ | |||
69 70 71 72 73 74 75 | 71 72 73 74 75 76 77 78 79 | + + | /*! * @brief Returns the data of the extension. * * @return The data of the extension */ - (OFDataArray*)data; @end OF_ASSUME_NONNULL_END |
Modified src/OFMessagePackRepresentation.h from [6498c39786] to [02cc4d0e2e].
︙ | |||
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 | 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 | + + + + + + | * * 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 "OFObject.h" OF_ASSUME_NONNULL_BEGIN @class OFDataArray; /*! * @protocol OFMessagePackRepresentation * OFMessagePackRepresentation.h ObjFW/OFMessagePackRepresentation.h * * @brief A protocol implemented by classes that support encoding to a * MessagePack representation. */ @protocol OFMessagePackRepresentation /*! * @brief Returns the MessagePack representation of the object as an * OFDataArray. * * @return The MessagePack representation of the object as an OFDataArray. */ - (OFDataArray*)messagePackRepresentation; @end OF_ASSUME_NONNULL_END |
Modified src/OFMutableArray.h from [d606689457] to [73428ea9d3].
︙ | |||
12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 | 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 | + + - + | * 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 "OFArray.h" OF_ASSUME_NONNULL_BEGIN /*! @file */ #ifdef OF_HAVE_BLOCKS /*! * @brief A block for replacing values in an OFMutableArray. * * @param object The object to replace * @param index The index of the object to replace * @return The object to replace the object with */ |
︙ | |||
206 207 208 209 210 211 212 | 208 209 210 211 212 213 214 215 216 | + + | * @brief Converts the mutable array to an immutable array. */ - (void)makeImmutable; @end #if !defined(OF_HAVE_GENERICS) && !defined(DOXYGEN) # undef ObjectType #endif OF_ASSUME_NONNULL_END |
Modified src/OFMutableArray_adjacent.h from [a5f8845a3f] to [fd4cebc98d].
︙ | |||
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 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. */ #import "OFArray.h" OF_ASSUME_NONNULL_BEGIN @class OFDataArray; @interface OFMutableArray_adjacent: OFMutableArray { OFDataArray *_array; unsigned long _mutations; } @end OF_ASSUME_NONNULL_END |
Modified src/OFMutableDictionary.h from [1bc847e58e] to [d3e27d1158].
︙ | |||
12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 | 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 | + + - + | * 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 "OFDictionary.h" OF_ASSUME_NONNULL_BEGIN /*! @file */ #ifdef OF_HAVE_BLOCKS /*! * @brief A block for replacing objects in an OFMutableDictionary. * * @param key The key of the object to replace * @param object The object to replace * @return The object to replace the object with */ |
︙ | |||
101 102 103 104 105 106 107 | 103 104 105 106 107 108 109 110 111 | + + | */ - (void)makeImmutable; @end #if !defined(OF_HAVE_GENERICS) && !defined(DOXYGEN) # undef KeyType # undef ObjectType #endif OF_ASSUME_NONNULL_END |
Modified src/OFMutableDictionary_hashtable.h from [c9686e59b7] to [0634fd79ce].
︙ | |||
12 13 14 15 16 17 18 19 20 21 22 23 24 25 | 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. */ #import "OFDictionary.h" OF_ASSUME_NONNULL_BEGIN @class OFMapTable; @interface OFMutableDictionary_hashtable: OFMutableDictionary { OFMapTable *_mapTable; } @end OF_ASSUME_NONNULL_END |
Modified src/OFMutableSet.h from [4371ecc2d9] to [eae3dd1556].
︙ | |||
12 13 14 15 16 17 18 19 20 21 22 23 24 25 | 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 | + + | * 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" OF_ASSUME_NONNULL_BEGIN /*! * @class OFMutableSet OFSet.h ObjFW/OFSet.h * * @brief An abstract class for a mutable unordered set of unique objects. */ #ifdef OF_HAVE_GENERICS @interface OFMutableSet <ObjectType>: OFSet <ObjectType> |
︙ | |||
69 70 71 72 73 74 75 | 71 72 73 74 75 76 77 78 79 | + + | * @brief Converts the mutable set to an immutable set. */ - (void)makeImmutable; @end #if !defined(OF_HAVE_GENERICS) && !defined(DOXYGEN) # undef ObjectType #endif OF_ASSUME_NONNULL_END |
Modified src/OFMutableSet_hashtable.h from [7505a928c5] to [a91b953b51].
︙ | |||
12 13 14 15 16 17 18 19 20 21 22 23 24 25 | 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. */ #import "OFMutableSet.h" OF_ASSUME_NONNULL_BEGIN @class OFMapTable; @interface OFMutableSet_hashtable: OFMutableSet { OFMapTable *_mapTable; } @end OF_ASSUME_NONNULL_END |
Modified src/OFMutableString.h from [d844db881d] to [0629306105].
︙ | |||
12 13 14 15 16 17 18 19 20 21 22 23 24 25 | 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 | + + | * 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 "OFString.h" OF_ASSUME_NONNULL_BEGIN /*! * @class OFMutableString OFString.h ObjFW/OFString.h * * @brief A class for storing and modifying strings. */ @interface OFMutableString: OFString /*! |
︙ | |||
203 204 205 206 207 208 209 | 205 206 207 208 209 210 211 212 213 | + + | - (void)deleteEnclosingWhitespaces; /*! * @brief Converts the mutable string to an immutable string. */ - (void)makeImmutable; @end OF_ASSUME_NONNULL_END |
Modified src/OFMutableString_UTF8.h from [e65e37ad7f] to [1e46c927ce].
︙ | |||
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 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. */ #import "OFMutableString.h" #import "OFString_UTF8.h" OF_ASSUME_NONNULL_BEGIN @interface OFMutableString_UTF8: OFMutableString { @public struct of_string_utf8_ivars *restrict _s; struct of_string_utf8_ivars _storage; } @end OF_ASSUME_NONNULL_END |
Modified src/OFMutex.h from [1f9a5c477b] to [3c700dc33f].
︙ | |||
15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 | 15 16 17 18 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 | + + + + | */ #import "OFObject.h" #import "OFLocking.h" #import "threading.h" OF_ASSUME_NONNULL_BEGIN /*! * @class OFMutex OFMutex.h ObjFW/OFMutex.h * * @brief A class for creating mutual exclusions. */ @interface OFMutex: OFObject <OFLocking> { of_mutex_t _mutex; bool _initialized; OFString *_name; } /*! * @brief Creates a new mutex. * * @return A new autoreleased mutex. */ + (instancetype)mutex; @end OF_ASSUME_NONNULL_END |
Modified src/OFNull.h from [8996415aaa] to [69a8b20533].
︙ | |||
15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 | 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 | + + + + | */ #import "OFObject.h" #import "OFSerialization.h" #import "OFJSONRepresentation.h" #import "OFMessagePackRepresentation.h" OF_ASSUME_NONNULL_BEGIN /*! * @class OFNull OFNull.h ObjFW/OFNull.h * * @brief A class for representing null values in collections. */ @interface OFNull: OFObject <OFCopying, OFSerialization, OFJSONRepresentation, OFMessagePackRepresentation> /*! * @brief Returns an OFNull singleton. * * @return An OFNull singleton */ + (OFNull*)null; @end OF_ASSUME_NONNULL_END |
Modified src/OFNumber.h from [51f3647292] to [d6e03f82de].
︙ | |||
24 25 26 27 28 29 30 31 32 33 34 35 36 37 | 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 | + + | #include <sys/types.h> #import "OFObject.h" #import "OFSerialization.h" #import "OFJSONRepresentation.h" #import "OFMessagePackRepresentation.h" OF_ASSUME_NONNULL_BEGIN /*! @file */ /*! * @brief The C type of a number stored in an OFNumber. */ typedef enum { /*! bool */ |
︙ | |||
809 810 811 812 813 814 815 816 817 818 819 820 | 811 812 813 814 815 816 817 818 819 820 821 822 823 824 | + + | /*! * @brief Returns the OFNumber as a double. * * @return The OFNumber as a double */ - (double)doubleValue; @end OF_ASSUME_NONNULL_END #ifndef NSINTEGER_DEFINED /* Required for number literals to work */ @compatibility_alias NSNumber OFNumber; #endif |
Modified src/OFObject+Serialization.h from [cb97c55d5b] to [5916ad3770].
︙ | |||
12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 | 12 13 14 15 16 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. */ #import "OFObject.h" OF_ASSUME_NONNULL_BEGIN @class OFString; #ifdef __cplusplus extern "C" { #endif extern int _OFObject_Serialization_reference; #ifdef __cplusplus } #endif @interface OFObject (OFSerialization) /*! * @brief Creates a string by serializing the receiver. * * @return The object serialized as a string */ - (OFString*)stringBySerializing; @end OF_ASSUME_NONNULL_END |
Modified src/OFObject.h from [1907dcf7b8] to [c9ef03c38f].
︙ | |||
27 28 29 30 31 32 33 34 35 36 37 38 39 40 | 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 | + + | #include <stdint.h> #include <stdbool.h> #include <limits.h> #import "macros.h" #import "autorelease.h" OF_ASSUME_NONNULL_BEGIN /*! @file */ /*! * @brief A result of a comparison. */ typedef enum { /*! The left object is smaller than the right */ |
︙ | |||
232 233 234 235 236 237 238 | 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 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 | - + - + - + - - + + - - - + + + - + | /*! * @brief Returns the implementation for the specified selector. * * @param selector The selector for which the method should be returned * @return The implementation for the specified selector */ |
︙ | |||
467 468 469 470 471 472 473 | 469 470 471 472 473 474 475 476 477 478 479 480 481 482 483 484 485 486 487 488 489 490 491 492 493 494 495 496 497 498 499 500 501 502 503 504 505 506 507 508 509 510 511 512 513 514 515 516 517 518 519 520 521 522 523 524 525 526 527 528 529 530 531 532 533 534 535 536 537 538 539 540 541 542 543 544 545 546 547 548 549 550 551 552 553 554 | - + - + - - + + - - + + - - - + + + - - - + + + | * @brief Returns the implementation of the instance method for the specified * selector. * * @param selector The selector for which the method should be returned * @return The implementation of the instance method for the specified selector * or nil if it isn't implemented */ |
︙ | |||
654 655 656 657 658 659 660 | 656 657 658 659 660 661 662 663 664 665 666 667 668 669 670 671 672 673 674 675 676 677 678 679 680 681 682 683 684 685 686 687 688 689 690 691 692 693 694 695 696 | - - + + - - - + + + - + | * If the pointer is NULL, this is equivalent to allocating memory. * If the size is 0, this is equivalent to freeing memory. * * @param pointer A pointer to the already allocated memory * @param size The new size for the memory chunk * @return A pointer to the resized memory chunk */ |
︙ | |||
710 711 712 713 714 715 716 | 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 737 738 739 740 741 742 | - + - - + + | * * @param selector The selector to perform * @param object The object that is passed to the method specified by the * selector * @param delay The delay after which the selector will be performed */ - (void)performSelector: (SEL)selector |
︙ | |||
753 754 755 756 757 758 759 | 755 756 757 758 759 760 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 | - + - - + + | * @param thread The thread on which to perform the selector * @param object The object that is passed to the method specified by the * selector * @param waitUntilDone Whether to wait until the perform finished */ - (void)performSelector: (SEL)selector onThread: (OFThread*)thread |
︙ | |||
793 794 795 796 797 798 799 | 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 | - + - - + + | * * @param selector The selector to perform * @param object The object that is passed to the method specified by the * selector * @param waitUntilDone Whether to wait until the perform finished */ - (void)performSelectorOnMainThread: (SEL)selector |
︙ | |||
836 837 838 839 840 841 842 | 838 839 840 841 842 843 844 845 846 847 848 849 850 851 852 853 854 855 856 857 858 859 860 861 862 863 864 865 866 867 868 869 870 871 872 873 874 875 876 877 878 879 880 881 882 883 884 | - + - - + + - + | * @param thread The thread on which to perform the selector * @param object The object that is passed to the method specified by the * selector * @param delay The delay after which the selector will be performed */ - (void)performSelector: (SEL)selector onThread: (OFThread*)thread |
︙ | |||
933 934 935 936 937 938 939 | 935 936 937 938 939 940 941 942 943 944 945 946 947 948 949 950 951 952 953 954 955 | - - - - + + + + + + | * * @param object An object to compare the object to * @return The result of the comparison */ - (of_comparison_result_t)compare: (id <OFComparing>)object; @end |
Modified src/OFOptionsParser.h from [e68f8554d3] to [bff8d10a51].
︙ | |||
13 14 15 16 17 18 19 20 21 22 23 24 25 26 | 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 | + + | * LICENSE.GPLv2 or LICENSE.GPLv3 respectively included in the packaging of this * file. */ #import "OFObject.h" #import "OFConstantString.h" OF_ASSUME_NONNULL_BEGIN /*! * @class OFOptionsParser OFOptionsParser.h ObjFW/OFOptionsParser.h * * @brief A class for parsing the program options specified on the command line. */ @interface OFOptionsParser: OFObject { |
︙ | |||
78 79 80 81 82 83 84 | 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 | - + + + | /*! * @brief Returns the argument for the last parsed option, or nil if the last * parsed option takes no argument. * * @return The argument for the last parsed option */ |
Modified src/OFPlugin.h from [5e026f9965] to [d9a4de6e06].
︙ | |||
12 13 14 15 16 17 18 19 20 21 22 23 24 25 | 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 | + + | * 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 "OFObject.h" OF_ASSUME_NONNULL_BEGIN @class OFString; #ifndef _WIN32 typedef void* of_plugin_handle_t; #else # include <windows.h> typedef HMODULE of_plugin_handle_t; |
︙ | |||
37 38 39 40 41 42 43 | 39 40 41 42 43 44 45 46 47 48 49 | - + + + | /*! * @brief Loads a plugin from a file. * * @param path Path to the plugin file. The suffix is appended automatically. * @return The loaded plugin */ |
Modified src/OFProcess.h from [d9cfbadee0] to [c6a99c7fe3].
︙ | |||
25 26 27 28 29 30 31 32 33 34 35 36 37 38 | 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 | + + | #import "OFStream.h" #import "OFString.h" #ifdef _WIN32 # include <windows.h> #endif OF_ASSUME_NONNULL_BEGIN @class OFArray OF_GENERIC(ObjectType); @class OFDictionary OF_GENERIC(KeyType, ObjectType); /*! * @class OFProcess OFProcess.h ObjFW/OFProcess.h * |
︙ | |||
65 66 67 68 69 70 71 | 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 | + - - + + + - - - + + + + - - - - - + + + + + | * invokes the program. * * @param program The program to execute. If it does not start with a slash, the * search path specified in PATH is used. * @param arguments The arguments to pass to the program, or nil * @return A new, autoreleased OFProcess. */ + (instancetype) |
︙ | |||
125 126 127 128 129 130 131 | 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 | - + - + - - + + + + + | * * @param program The program to execute. If it does not start with a slash, the * search path specified in PATH is used. * @param arguments The arguments to pass to the program, or nil * @return An initialized OFProcess. */ - initWithProgram: (OFString*)program |
Modified src/OFRIPEMD160Hash.h from [59577d187f] to [1a15dbdf74].
︙ | |||
12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 | 12 13 14 15 16 17 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. */ #import "OFHash.h" OF_ASSUME_NONNULL_BEGIN /*! * @class OFRIPEMD160Hash OFRIPEMD160Hash.h ObjFW/OFRIPEMD160Hash.h * * @brief A class which provides functions to create a RIPEMD-160 hash. */ @interface OFRIPEMD160Hash: OFObject <OFHash> { uint32_t _state[5]; uint64_t _bits; union { uint8_t bytes[64]; uint32_t words[16]; } _buffer; size_t _bufferLength; bool _calculated; } - (void)OF_resetState; @end OF_ASSUME_NONNULL_END |
Modified src/OFRecursiveMutex.h from [159cca8cc8] to [1999595e1e].
︙ | |||
15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 | 15 16 17 18 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 | + + + + | */ #import "OFObject.h" #import "OFLocking.h" #import "threading.h" OF_ASSUME_NONNULL_BEGIN /*! * @class OFRecursiveMutex OFRecursiveMutex.h ObjFW/OFRecursiveMutex.h * * @brief A class for creating mutual exclusions which can be entered * recursively. */ @interface OFRecursiveMutex: OFObject <OFLocking> { of_rmutex_t _rmutex; bool _initialized; OFString *_name; } /*! * @brief Creates a new recursive mutex. * * @return A new autoreleased recursive mutex. */ + (instancetype)mutex; @end OF_ASSUME_NONNULL_END |
Modified src/OFRunLoop+Private.h from [e6e1e76645] to [c9ae02043f].
︙ | |||
15 16 17 18 19 20 21 22 23 24 25 26 27 28 | 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 | + + | */ #import "OFRunLoop.h" #import "OFStream.h" #ifdef OF_HAVE_SOCKETS # import "OFUDPSocket.h" #endif OF_ASSUME_NONNULL_BEGIN @interface OFRunLoop (OF_PRIVATE_CATEGORY) + (void)OF_setMainRunLoop: (OFRunLoop*)runLoop; #ifdef OF_HAVE_SOCKETS + (void)OF_addAsyncReadForStream: (OFStream*)stream buffer: (void*)buffer length: (size_t)length |
︙ | |||
66 67 68 69 70 71 72 | 68 69 70 71 72 73 74 75 76 | + + | block: (of_udp_socket_async_receive_block_t) block; # endif + (void)OF_cancelAsyncRequestsForObject: (id)object; #endif - (void)OF_removeTimer: (OFTimer*)timer; @end OF_ASSUME_NONNULL_END |
Modified src/OFRunLoop.h from [e260344414] to [0b6d167631].
︙ | |||
14 15 16 17 18 19 20 21 22 23 24 25 26 27 | 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 | + + | * file. */ #import "OFObject.h" #ifdef OF_HAVE_SOCKETS # import "OFTCPSocket.h" #endif OF_ASSUME_NONNULL_BEGIN @class OFSortedList OF_GENERIC(ObjectType); #ifdef OF_HAVE_THREADS @class OFMutex; @class OFCondition; #endif #ifdef OF_HAVE_SOCKETS |
︙ | |||
78 79 80 81 82 83 84 | 80 81 82 83 84 85 86 87 88 | + + | /*! * @brief Stops the run loop. If there is still an operation being executed, it * is finished before the run loop stops. */ - (void)stop; @end OF_ASSUME_NONNULL_END |
Modified src/OFSHA1Hash.h from [f7d1ee4112] to [73f9b0884e].
︙ | |||
12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 | 12 13 14 15 16 17 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. */ #import "OFHash.h" OF_ASSUME_NONNULL_BEGIN /*! * @class OFSHA1Hash OFSHA1Hash.h ObjFW/OFSHA1Hash.h * * @brief A class which provides functions to create an SHA-1 hash. */ @interface OFSHA1Hash: OFObject <OFHash> { uint32_t _state[5]; uint64_t _bits; union { uint8_t bytes[64]; uint32_t words[80]; } _buffer; size_t _bufferLength; bool _calculated; } - (void)OF_resetState; @end OF_ASSUME_NONNULL_END |
Modified src/OFSHA224Hash.h from [d0fda4a283] to [5ac11423ff].
︙ | |||
12 13 14 15 16 17 18 19 20 21 22 23 24 25 | 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. */ #import "OFSHA224Or256Hash.h" OF_ASSUME_NONNULL_BEGIN /*! * @class OFSHA224Hash OFSHA224Hash.h ObjFW/OFSHA224Hash.h * * @brief A class which provides functions to create an SHA-224 hash. */ @interface OFSHA224Hash: OFSHA224Or256Hash @end OF_ASSUME_NONNULL_END |
Modified src/OFSHA224Or256Hash.h from [257314d339] to [b9a0ba0397].
︙ | |||
12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 | 12 13 14 15 16 17 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. */ #import "OFHash.h" OF_ASSUME_NONNULL_BEGIN /*! * @class OFSHA224Or256Hash OFSHA224Or256Hash.h ObjFW/OFSHA224Or256Hash.h * * @brief A base class for SHA-224 and SHA-256. */ @interface OFSHA224Or256Hash: OFObject <OFHash> { uint32_t _state[8]; uint64_t _bits; union { uint8_t bytes[64]; uint32_t words[64]; } _buffer; size_t _bufferLength; bool _calculated; } - (void)OF_resetState; @end OF_ASSUME_NONNULL_END |
Modified src/OFSHA256Hash.h from [70e713a5ba] to [7708f93289].
︙ | |||
12 13 14 15 16 17 18 19 20 21 22 23 24 25 | 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. */ #import "OFSHA224Or256Hash.h" OF_ASSUME_NONNULL_BEGIN /*! * @class OFSHA256Hash OFSHA256Hash.h ObjFW/OFSHA256Hash.h * * @brief A class which provides functions to create an SHA-256 hash. */ @interface OFSHA256Hash: OFSHA224Or256Hash @end OF_ASSUME_NONNULL_END |
Modified src/OFSHA384Hash.h from [23b8e9e316] to [fc29a4656a].
︙ | |||
12 13 14 15 16 17 18 19 20 21 22 23 24 25 | 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. */ #import "OFSHA384Or512Hash.h" OF_ASSUME_NONNULL_BEGIN /*! * @class OFSHA384Hash OFSHA384Hash.h ObjFW/OFSHA384Hash.h * * @brief A class which provides functions to create an SHA-384 hash. */ @interface OFSHA384Hash: OFSHA384Or512Hash @end OF_ASSUME_NONNULL_END |
Modified src/OFSHA384Or512Hash.h from [468a3cb6e2] to [5aec9e9b8a].
︙ | |||
12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 | 12 13 14 15 16 17 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. */ #import "OFHash.h" OF_ASSUME_NONNULL_BEGIN /*! * @class OFSHA384Or512Hash OFSHA384Or512Hash.h ObjFW/OFSHA384Or512Hash.h * * @brief A base class for SHA-384 and SHA-512. */ @interface OFSHA384Or512Hash: OFObject <OFHash> { uint64_t _state[8]; uint64_t _bits[2]; union { uint8_t bytes[128]; uint64_t words[80]; } _buffer; size_t _bufferLength; bool _calculated; } - (void)OF_resetState; @end OF_ASSUME_NONNULL_END |
Modified src/OFSHA512Hash.h from [e271607c35] to [b69f965a65].
︙ | |||
12 13 14 15 16 17 18 19 20 21 22 23 24 25 | 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. */ #import "OFSHA384Or512Hash.h" OF_ASSUME_NONNULL_BEGIN /*! * @class OFSHA512Hash OFSHA512Hash.h ObjFW/OFSHA512Hash.h * * @brief A class which provides functions to create an SHA-512 hash. */ @interface OFSHA512Hash: OFSHA384Or512Hash @end OF_ASSUME_NONNULL_END |
Modified src/OFSeekableStream.h from [2c45e50707] to [f5b4d92235].
︙ | |||
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 36 | + + | # define __STDC_CONSTANT_MACROS #endif #include <sys/types.h> #import "OFStream.h" OF_ASSUME_NONNULL_BEGIN #if defined(_WIN32) typedef __int64 of_offset_t; #elif defined(__ANDROID__) typedef long long of_offset_t; #elif defined(OF_HAVE_OFF64_T) typedef off64_t of_offset_t; #else |
︙ | |||
80 81 82 83 84 85 86 | 82 83 84 85 86 87 88 89 90 | + + | * `SEEK_CUR` | Seek to the current location + offset * `SEEK_END` | Seek to the end of the stream + offset * @return The new offset from the start of the file */ - (of_offset_t)lowlevelSeekToOffset: (of_offset_t)offset whence: (int)whence; @end OF_ASSUME_NONNULL_END |
Modified src/OFSerialization.h from [03c0d6da44] to [5d272a4583].
︙ | |||
11 12 13 14 15 16 17 18 19 20 21 22 23 24 | 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 | + + | * 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 "OFObject.h" OF_ASSUME_NONNULL_BEGIN #define OF_SERIALIZATION_NS @"https://webkeks.org/objfw/serialization" @class OFXMLElement; /*! * @protocol OFSerialization OFSerialization.h ObjFW/OFSerialization.h |
︙ | |||
37 38 39 40 41 42 43 | 39 40 41 42 43 44 45 46 47 | + + | /*! * @brief Serializes the object into an XML element. * * @return The object serialized into an XML element */ - (OFXMLElement*)XMLElementBySerializing; @end OF_ASSUME_NONNULL_END |
Modified src/OFSet.h from [da75a58c99] to [4f3cbb67f1].
︙ | |||
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 38 | + + | #include <stdarg.h> #import "OFObject.h" #import "OFCollection.h" #import "OFSerialization.h" OF_ASSUME_NONNULL_BEGIN /*! @file */ @class OFArray OF_GENERIC(ObjectType); #ifdef OF_HAVE_BLOCKS /*! * @brief A block for enumerating an OFSet. |
︙ | |||
101 102 103 104 105 106 107 | 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 | - + | /*! * @brief Creates a new set with the specified objects. * * @param objects An array of objects for the set * @param count The number of objects in the specified array * @return A new, autoreleased set with the specified objects */ |
︙ | |||
135 136 137 138 139 140 141 | 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 | - + | /*! * @brief Initializes an already allocated set with the specified objects. * * @param objects An array of objects for the set * @param count The number of objects in the specified array * @return An initialized set with the specified objects */ |
︙ | |||
213 214 215 216 217 218 219 | 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 | - + | /*! * @brief Checks whether the set contains an object equal to the specified * object. * * @param object The object which is checked for being in the set * @return A boolean whether the set contains the specified object */ |
︙ | |||
244 245 246 247 248 249 250 251 252 | 246 247 248 249 250 251 252 253 254 255 256 | + + | - (OFSet OF_GENERIC(ObjectType)*)filteredSetUsingBlock: (of_set_filter_block_t)block; #endif @end #if !defined(OF_HAVE_GENERICS) && !defined(DOXYGEN) # undef ObjectType #endif OF_ASSUME_NONNULL_END #import "OFMutableSet.h" |
Modified src/OFSet_hashtable.h from [987ad060d9] to [a2bc103db5].
︙ | |||
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 26 27 28 29 30 31 | + + + + | * Public License, either version 2 or 3, which can be found in the file * LICENSE.GPLv2 or LICENSE.GPLv3 respectively included in the packaging of this * file. */ #import "OFSet.h" OF_ASSUME_NONNULL_BEGIN @class OFMapTable; @interface OFSet_hashtable: OFSet { OFMapTable *_mapTable; } - initWithCapacity: (size_t)capacity; @end OF_ASSUME_NONNULL_END |
Modified src/OFSettings.h from [0d8a20bfc8] to [2f4b4ac28d].
︙ | |||
12 13 14 15 16 17 18 19 20 21 22 23 24 25 | 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 | + + | * 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 "OFObject.h" OF_ASSUME_NONNULL_BEGIN @class OFString; @class OFArray OF_GENERIC(ObjectType); /*! * @class OFSettings OFSettings.h ObjFW/OFSettings.h * * Paths are delimited by dots, for example `category.subcategory.key`. |
︙ | |||
125 126 127 128 129 130 131 | 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 | - + - - + + | /*! * @brief Returns the string for the specified path, or nil if the path does * not exist. * * @param path The path for which the string value should be returned * @return The string value of the specified path */ |
︙ | |||
208 209 210 211 212 213 214 | 210 211 212 213 214 215 216 217 218 | + + | * @warning Some backends might save the settings instantly, others might not * save them before calling this method for performance reasons. You * should always call this method after doing a bunch of changes, no * matter which backend is used! */ - (void)save; @end OF_ASSUME_NONNULL_END |
Modified src/OFSettings_INIFile.h from [81324b1018] to [7b87ff8285].
︙ | |||
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 26 27 28 29 30 31 | + + + + | * Public License, either version 2 or 3, which can be found in the file * LICENSE.GPLv2 or LICENSE.GPLv3 respectively included in the packaging of this * file. */ #import "OFSettings.h" OF_ASSUME_NONNULL_BEGIN @class OFString; @class OFINIFile; @interface OFSettings_INIFile: OFSettings { OFString *_filePath; OFINIFile *_INIFile; } @end OF_ASSUME_NONNULL_END |
Modified src/OFSortedList.h from [df204b4c51] to [fb7f02bccb].
︙ | |||
12 13 14 15 16 17 18 19 20 21 22 23 24 25 | 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 | + + | * 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 "OFList.h" OF_ASSUME_NONNULL_BEGIN /*! * @class OFSortedList OFSortedList.h ObjFW/OFSortedList.h * * @brief A class which provides easy to use sorted double-linked lists. * * @warning Because the list is sorted, all methods inserting an object at a * specific place are unavailable, even though they exist in OFList! |
︙ | |||
39 40 41 42 43 44 45 | 41 42 43 44 45 46 47 48 49 | + + | * @return The list object for the object just added */ - (of_list_object_t*)insertObject: (ObjectType <OFComparing>)object; @end #if !defined(OF_HAVE_GENERICS) && !defined(DOXYGEN) # undef ObjectType #endif OF_ASSUME_NONNULL_END |
Modified src/OFStdIOStream.h from [004622bc57] to [1b4f95e1e9].
︙ | |||
12 13 14 15 16 17 18 19 20 21 22 23 24 25 | 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 | + + | * 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 "OFStream.h" OF_ASSUME_NONNULL_BEGIN /*! * @class OFStdIOStream OFStdIOStream.h ObjFW/OFStdIOStream.h * * @brief A class for providing standard input, output and error as OFStream. * * The global variables @ref of_stdin, @ref of_stdout and @ref of_stderr are * instances of this class and need no initialization. |
︙ | |||
35 36 37 38 39 40 41 | 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 | - + - + - + + + | extern "C" { #endif /*! @file */ /*! * @brief The standard input as an OFStream. */ |
Modified src/OFStream+Private.h from [4081796c91] to [374d14d5bd].
︙ | |||
11 12 13 14 15 16 17 18 19 20 21 | 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 | + + + + | * 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 "OFStream.h" OF_ASSUME_NONNULL_BEGIN @interface OFStream (OF_PRIVATE_CATEGORY) - (bool)OF_isWaitingForDelimiter; @end OF_ASSUME_NONNULL_END |
Modified src/OFStream.h from [4c3277f2ac] to [af476e35d4].
︙ | |||
25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 | 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 | + + - + - + + - + | #import "OFObject.h" #import "OFString.h" #ifdef OF_HAVE_SOCKETS # import "OFKernelEventObserver.h" #endif OF_ASSUME_NONNULL_BEGIN /*! @file */ @class OFStream; @class OFDataArray; @class OFException; #if defined(OF_HAVE_SOCKETS) && defined(OF_HAVE_BLOCKS) /*! * @brief A block which is called when data was read from the stream. * * @param stream The stream on which data was read * @param buffer A buffer with the data that has been read * @param length The length of the data that has been read * @param exception An exception which occurred while reading or nil on success * @return A bool whether the same block should be used for the next read */ typedef bool (^of_stream_async_read_block_t)(OFStream *stream, void *buffer, |
︙ | |||
198 199 200 201 202 203 204 | 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 | - - - - + + + + | * data has been received. If you want the next method in the * queue to handle the data received next, you need to return * false from the method. * @param selector The selector to call on the target. The signature must be * `bool (OFStream *stream, void *buffer, size_t size, * OFException *exception)`. */ |
︙ | |||
592 593 594 595 596 597 598 | 595 596 597 598 599 600 601 602 603 604 605 606 607 608 609 610 611 612 613 614 615 616 617 618 619 | - + - + | /*! * @brief Reads until a newline, \\0 or end of stream occurs. * * @return The line that was read, autoreleased, or nil if the end of the * stream has been reached. */ |
︙ | |||
687 688 689 690 691 692 693 | 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 737 738 739 740 741 742 743 744 745 746 747 748 749 750 751 752 753 754 755 756 757 758 759 760 761 | - + - + - + - - + + - + - - + + | /*! * @brief Tries to read a line from the stream (see readLine) and returns nil if * no complete line has been received yet. * * @return The line that was read, autoreleased, or nil if the line is not * complete yet */ |
︙ | |||
1160 1161 1162 1163 1164 1165 1166 | 1163 1164 1165 1166 1167 1168 1169 1170 1171 | + + | * Override this method with your actual end of stream checking implementation * when subclassing! * * @return Whether the lowlevel is at the end of the stream */ - (bool)lowlevelIsAtEndOfStream; @end OF_ASSUME_NONNULL_END |
Modified src/OFStreamSocket.h from [6843e4c621] to [2e737acb53].
︙ | |||
14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 | 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 | + + + + | * file. */ #import "OFStream.h" #import "socket.h" OF_ASSUME_NONNULL_BEGIN /*! * @class OFStreamSocket OFStreamSocket.h ObjFW/OFStreamSocket.h * * @brief A class which provides functions to create and use stream sockets. */ @interface OFStreamSocket: OFStream { of_socket_t _socket; bool _atEndOfStream; } /*! * @brief Returns a new, autoreleased OFTCPSocket. * * @return A new, autoreleased OFTCPSocket */ + (instancetype)socket; @end OF_ASSUME_NONNULL_END |
Modified src/OFString+Hashing.h from [c1ea3b2a9a] to [057e394b3d].
︙ | |||
12 13 14 15 16 17 18 19 20 21 22 23 24 25 | 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 | + + | * 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 "OFString.h" OF_ASSUME_NONNULL_BEGIN #ifdef __cplusplus extern "C" { #endif extern int _OFString_Hashing_reference; #ifdef __cplusplus } #endif |
︙ | |||
70 71 72 73 74 75 76 | 72 73 74 75 76 77 78 79 80 | + + | /*! * @brief Returns the SHA-512 hash of the string as an autoreleased OFString. * * @return The SHA-512 hash of the string as an autoreleased OFString */ - (OFString*)SHA512Hash; @end OF_ASSUME_NONNULL_END |
Modified src/OFString+JSONValue.h from [5331e43cf6] to [3904afc721].
︙ | |||
12 13 14 15 16 17 18 19 20 21 22 23 24 25 | 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 | + + | * 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 "OFString.h" OF_ASSUME_NONNULL_BEGIN #ifdef __cplusplus extern "C" { #endif extern int _OFString_JSONValue_reference; #ifdef __cplusplus } #endif |
︙ | |||
62 63 64 65 66 67 68 | 64 65 66 67 68 69 70 71 72 | + + | * @param depthLimit The maximum depth the parser should accept (defaults to 32 * if not specified, 0 means no limit (insecure!)) * * @return An object */ - (id)JSONValueWithDepthLimit: (size_t)depthLimit; @end OF_ASSUME_NONNULL_END |
Modified src/OFString+Serialization.h from [b2442150b8] to [d42f2bddcf].
︙ | |||
12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 | 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 | + + + + | * 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 "OFString.h" OF_ASSUME_NONNULL_BEGIN #ifdef __cplusplus extern "C" { #endif extern int _OFString_Serialization_reference; #ifdef __cplusplus } #endif @interface OFString (Serialization) /*! * @brief Deserializes the receiver into an object. * * @return The deserialized object */ - (id)objectByDeserializing; @end OF_ASSUME_NONNULL_END |
Modified src/OFString+URLEncoding.h from [b68e3b83bd] to [7aab8630a9].
︙ | |||
12 13 14 15 16 17 18 19 20 21 22 23 24 25 | 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 | + + | * 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 "OFString.h" OF_ASSUME_NONNULL_BEGIN #ifdef __cplusplus extern "C" { #endif extern int _OFString_URLEncoding_reference; #ifdef __cplusplus } #endif |
︙ | |||
35 36 37 38 39 40 41 | 37 38 39 40 41 42 43 44 45 | + + | /*! * @brief Decodes a string used in a URL. * * @return A new autoreleased string */ - (OFString*)stringByURLDecoding; @end OF_ASSUME_NONNULL_END |
Modified src/OFString+XMLEscaping.h from [db78a5e48c] to [5146f4aa80].
︙ | |||
12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 | 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 | + + + + | * 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 "OFString.h" OF_ASSUME_NONNULL_BEGIN #ifdef __cplusplus extern "C" { #endif extern int _OFString_XMLEscaping_reference; #ifdef __cplusplus } #endif @interface OFString (XMLEscaping) /*! * @brief Escapes a string for use in an XML document. * * @return A new autoreleased string */ - (OFString*)stringByXMLEscaping; @end OF_ASSUME_NONNULL_END |
Modified src/OFString+XMLUnescaping.h from [ca089314de] to [faa405a093].
︙ | |||
12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 | 12 13 14 15 16 17 18 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. */ #import "OFString.h" OF_ASSUME_NONNULL_BEGIN /*! @file */ #ifdef __cplusplus extern "C" { #endif extern int _OFString_XMLUnescaping_reference; #ifdef __cplusplus } #endif #ifdef OF_HAVE_BLOCKS /*! * @brief A block which is called to replace unknown XML entities in an XML * string. * * @param string The XML string which contains an unknown entity * @param entity The XML entity which is unknown * @return A replacement string for the unknown entity */ |
︙ | |||
71 72 73 74 75 76 77 | 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 | - + + + | /*! * @brief Unescapes XML in the string and uses the specified delegate for * unknown entities. * * @param delegate An OFXMLUnescapingDelegate as a handler for unknown entities */ - (OFString*)stringByXMLUnescapingWithDelegate: |
Modified src/OFString.h from [727e3bcb81] to [a26c914c0c].
︙ | |||
25 26 27 28 29 30 31 32 33 34 35 36 37 38 | 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 | + + | #include <inttypes.h> #import "OFObject.h" #import "OFSerialization.h" #import "OFJSONRepresentation.h" #import "OFMessagePackRepresentation.h" OF_ASSUME_NONNULL_BEGIN /*! @file */ @class OFConstantString; #if defined(__cplusplus) && __cplusplus >= 201103L typedef char16_t of_char16_t; typedef char32_t of_char32_t; |
︙ | |||
1094 1095 1096 1097 1098 1099 1100 1101 1102 1103 1104 1105 1106 1107 | 1096 1097 1098 1099 1100 1101 1102 1103 1104 1105 1106 1107 1108 1109 1110 1111 1112 1113 1114 1115 1116 1117 1118 1119 1120 1121 1122 | + + + + + + + + + + + + + | * * @brief block The block to call for each line */ - (void)enumerateLinesUsingBlock: (of_string_line_enumeration_block_t)block; #endif @end #ifdef __cplusplus extern "C" { #endif extern size_t of_string_utf8_encode(of_unichar_t, char*); extern size_t of_string_utf8_decode(const char*, size_t, of_unichar_t*); extern size_t of_string_utf16_length(const of_char16_t*); extern size_t of_string_utf32_length(const of_char32_t*); #ifdef __cplusplus } #endif OF_ASSUME_NONNULL_END #import "OFConstantString.h" #import "OFMutableString.h" #import "OFString+Hashing.h" #import "OFString+JSONValue.h" #import "OFString+Serialization.h" #import "OFString+URLEncoding.h" #import "OFString+XMLEscaping.h" |
︙ | |||
1118 1119 1120 1121 1122 1123 1124 1125 | 1133 1134 1135 1136 1137 1138 1139 1140 | - - - - - - - - - - - | * and not to NSString (which would result in a linker error, but would be the * correct behavior). * * TODO: Submit a patch for Clang that makes the boxing classes configurable! */ @interface NSString: OFString @end #endif |
Modified src/OFString_UTF8+Private.h from [5fd3c45bf4] to [ce04431695].
︙ | |||
11 12 13 14 15 16 17 18 19 20 21 22 23 | 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 | + + + + | * 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 "OFString_UTF8.h" OF_ASSUME_NONNULL_BEGIN @interface OFString_UTF8 (OF_PRIVATE_CATEGORY) - (instancetype)OF_initWithUTF8String: (const char*)UTF8String length: (size_t)UTF8StringLength storage: (char*)storage; @end OF_ASSUME_NONNULL_END |
Modified src/OFString_UTF8.h from [fa7aabff72] to [6a733beb72].
︙ | |||
11 12 13 14 15 16 17 18 19 20 21 22 23 24 | 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 | + + | * 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 "OFString.h" OF_ASSUME_NONNULL_BEGIN @interface OFString_UTF8: OFString { @public /* * A pointer to the actual data. * |
︙ | |||
44 45 46 47 48 49 50 | 46 47 48 49 50 51 52 53 54 | + + | #endif extern int of_string_utf8_check(const char*, size_t, size_t*); extern size_t of_string_utf8_get_index(const char*, size_t); extern size_t of_string_utf8_get_position(const char*, size_t, size_t); #ifdef __cplusplus } #endif OF_ASSUME_NONNULL_END |
Modified src/OFSystemInfo.h from [83510ab411] to [579d6e7617].
︙ | |||
13 14 15 16 17 18 19 20 21 22 23 24 25 26 | 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 | + + | * LICENSE.GPLv2 or LICENSE.GPLv3 respectively included in the packaging of this * file. */ #import "OFObject.h" #import "OFString.h" OF_ASSUME_NONNULL_BEGIN /*! * @class OFSystemInfo OFSystemInfo.h ObjFW/OFSystemInfo.h * * @brief A class for querying information about the system. */ @interface OFSystemInfo: OFObject /*! |
︙ | |||
78 79 80 81 82 83 84 | 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 | - + | /*! * @brief Returns the vendor of the CPU. * * If the vendor could not be determined, nil is returned instead. * * @return The vendor of the CPU */ |
︙ | |||
143 144 145 146 147 148 149 | 145 146 147 148 149 150 151 152 153 | + + | /*! * @brief Returns whether the CPU supports AVX2. * * @return Whether the CPU supports AVX2 */ + (bool)supportsAVX2; @end OF_ASSUME_NONNULL_END |
Modified src/OFTCPSocket+SOCKS5.h from [0f865cda54] to [694b2a7d0b].
︙ | |||
12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 | 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 | + + + + | * Public License, either version 2 or 3, which can be found in the file * LICENSE.GPLv2 or LICENSE.GPLv3 respectively included in the packaging of this * file. */ #import "OFTCPSocket.h" OF_ASSUME_NONNULL_BEGIN #ifdef __cplusplus extern "C" { #endif extern int _OFTCPSocket_SOCKS5_reference; #ifdef __cplusplus } #endif @interface OFTCPSocket (SOCKS5) - (void)OF_SOCKS5ConnectToHost: (OFString*)host port: (uint16_t)port; @end OF_ASSUME_NONNULL_END |
Modified src/OFTCPSocket.h from [0e29d56685] to [433e48e1ac].
︙ | |||
14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 | 14 15 16 17 18 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 | + + - + - + | * file. */ #import "OFStreamSocket.h" #import "socket.h" OF_ASSUME_NONNULL_BEGIN /*! @file */ @class OFTCPSocket; @class OFString; #ifdef OF_HAVE_BLOCKS /*! * @brief A block which is called when the socket connected. * * @param socket The socket which connected * @param exception An exception which occurred while connecting the socket or * nil on success */ typedef void (^of_tcp_socket_async_connect_block_t)(OFTCPSocket *socket, |
︙ | |||
63 64 65 66 67 68 69 | 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 | - + - + - + - + - + | socklen_t _addressLength; OFString *_SOCKS5Host; uint16_t _SOCKS5Port; } #ifdef OF_HAVE_PROPERTIES @property (readonly, getter=isListening) bool listening; |
︙ | |||
230 231 232 233 234 235 236 | 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 | - + | /*! * @brief Returns the remote address of the socket. * * Only works with accepted sockets! * * @return The remote address as a string */ |
︙ | |||
271 272 273 274 275 276 277 | 273 274 275 276 277 278 279 280 281 282 283 284 285 | - + + + | */ - (bool)isTCPNoDelayEnabled; @end #ifdef __cplusplus extern "C" { #endif |
Modified src/OFTLSSocket.h from [a7cdac098b] to [968eca3d6d].
︙ | |||
10 11 12 13 14 15 16 | 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 | - + + + | * * 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. */ |
︙ | |||
51 52 53 54 55 56 57 | 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 | - - - + + + | * @protocol OFTLSSocket OFTLSSocket.h ObjFW/OFTLSSocket.h * * @brief A protocol that should be implemented by 3rd-party libraries * implementing TLS. */ @protocol OFTLSSocket #ifdef OF_HAVE_PROPERTIES |
︙ | |||
82 83 84 85 86 87 88 | 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 185 186 187 188 189 190 191 192 | - + - + - + - + - + - + - + - + - + | - (void)startTLSWithExpectedHost: (OFString*)host; /*! * @brief Sets a delegate for the TLS socket. * * @param delegate The delegate to use */ |
︙ | |||
200 201 202 203 204 205 206 | 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 | - + - + + + | /*! * @brief Returns the passphrase to decrypt the PKCS#8 private key file. * * @warning You should not copy this to insecure memory which is swappable! * * @return The passphrase to decrypt the PKCS#8 private key file */ |
Modified src/OFThread+Private.h from [7aa9919aa4] to [0c17908055].
︙ | |||
12 13 14 15 16 17 18 19 20 21 22 23 | 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 | + + + + | * 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 "OFThread.h" OF_ASSUME_NONNULL_BEGIN #ifdef OF_HAVE_THREADS @interface OFThread (OF_PRIVATE_CATEGORY) + (void)OF_createMainThread; @end #endif OF_ASSUME_NONNULL_END |
Modified src/OFThread.h from [2d3c3b4342] to [5030168140].
︙ | |||
16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 | 16 17 18 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 | + + - + | #import "OFObject.h" #ifdef OF_HAVE_THREADS # import "threading.h" #endif OF_ASSUME_NONNULL_BEGIN /*! @file */ @class OFDate; @class OFRunLoop; @class OFMutableDictionary OF_GENERIC(KeyType, ObjectType); #if defined(OF_HAVE_THREADS) && defined(OF_HAVE_BLOCKS) /*! * @brief A block to be executed in a new thread. * * @return The object which should be returned when the thread is joined */ |
︙ | |||
152 153 154 155 156 157 158 | 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 | - + - + | + (void)terminate OF_NO_RETURN; /*! * @brief Terminates the current thread, letting it return the specified object. * * @param object The object which the terminated thread will return */ |
︙ | |||
206 207 208 209 210 211 212 | 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 | - + - + | - (OFRunLoop*)runLoop; /*! * @brief Returns the name of the thread or nil if none has been set. * * @return The name of the thread or nik if none has been set */ |
︙ | |||
249 250 251 252 253 254 255 | 251 252 253 254 255 256 257 258 259 | + + | * @note This has to be set before the thread is started! * * @param stackSize The stack size for the thread */ - (void)setStackSize: (size_t)stackSize; #endif @end OF_ASSUME_NONNULL_END |
Modified src/OFThreadPool.h from [e4268d9aa1] to [3d5d69ac3c].
︙ | |||
12 13 14 15 16 17 18 19 20 21 22 23 24 25 | 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 | + + | * 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 "OFObject.h" OF_ASSUME_NONNULL_BEGIN /*! @file */ #ifdef OF_HAVE_BLOCKS /*! * @brief A block for a job which should be executed in a thread pool. */ typedef void (^of_thread_pool_block_t)(void); |
︙ | |||
91 92 93 94 95 96 97 | 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 | - + | * * @param target The target on which to perform the selector * @param selector The selector to perform on the target * @param object THe object with which the selector is performed on the target */ - (void)dispatchWithTarget: (id)target selector: (SEL)selector |
︙ | |||
114 115 116 117 118 119 120 | 116 117 118 119 120 121 122 123 124 | + + | /*! * @brief Returns the size of the thread pool. * * @return The size of the thread pool */ - (size_t)size; @end OF_ASSUME_NONNULL_END |
Modified src/OFTimer+Private.h from [f003cb3fb5] to [27d3b82c84].
︙ | |||
11 12 13 14 15 16 17 18 19 | 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 | + + - + + + | * 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 "OFTimer.h" OF_ASSUME_NONNULL_BEGIN @interface OFTimer (OF_PRIVATE_CATEGORY) |
Modified src/OFTimer.h from [9a0d092c72] to [46ec059844].
︙ | |||
12 13 14 15 16 17 18 19 20 21 22 23 24 25 | 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 | + + | * 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 "OFObject.h" OF_ASSUME_NONNULL_BEGIN /*! @file */ @class OFTimer; @class OFDate; @class OFRunLoop; #ifdef OF_HAVE_THREADS @class OFCondition; |
︙ | |||
85 86 87 88 89 90 91 | 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 | - + - - + + | * @param object An object to pass when calling the selector on the target * @param repeats Whether the timer repeats after it has been executed * @return A new, autoreleased timer */ + (instancetype)scheduledTimerWithTimeInterval: (of_time_interval_t)timeInterval target: (id)target selector: (SEL)selector |
︙ | |||
149 150 151 152 153 154 155 | 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 | - + - - + + | * @param object An object to pass when calling the selector on the target * @param repeats Whether the timer repeats after it has been executed * @return A new, autoreleased timer */ + (instancetype)timerWithTimeInterval: (of_time_interval_t)timeInterval target: (id)target selector: (SEL)selector |
︙ | |||
221 222 223 224 225 226 227 | 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 | - + | * @param repeats Whether the timer repeats after it has been executed * @return An initialized timer */ - initWithFireDate: (OFDate*)fireDate interval: (of_time_interval_t)interval target: (id)target selector: (SEL)selector |
︙ | |||
244 245 246 247 248 249 250 | 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 | - - + + | * @param repeats Whether the timer repeats after it has been executed * @return An initialized timer */ - initWithFireDate: (OFDate*)fireDate interval: (of_time_interval_t)interval target: (id)target selector: (SEL)selector |
︙ | |||
319 320 321 322 323 324 325 | 321 322 323 324 325 326 327 328 329 | + + | #ifdef OF_HAVE_THREADS /*! * @brief Waits until the timer fired. */ - (void)waitUntilDone; #endif @end OF_ASSUME_NONNULL_END |
Modified src/OFUDPSocket.h from [40843cdaf1] to [47b461dbfd].
︙ | |||
15 16 17 18 19 20 21 22 23 24 25 26 27 28 | 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 | + + | */ #import "OFObject.h" #import "OFKernelEventObserver.h" #import "socket.h" OF_ASSUME_NONNULL_BEGIN /*! @file */ @class OFUDPSocket; @class OFException; /*! * @struct of_udp_socket_address_t OFUDPSocket.h ObjFW/OFUDPSocket.h |
︙ | |||
42 43 44 45 46 47 48 | 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 | - + + - + - + - | * @param host The host that has been resolved * @param port The port of the host / port pair * @param address The address of the resolved host / port pair * @param exception An exception which occurred while resolving or nil on * success */ typedef void (^of_udp_socket_async_resolve_block_t)(OFString *host, |
︙ | |||
148 149 150 151 152 153 154 | 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 | - - + + | * * @param host A pointer to an OFString*. If it is not NULL, it will be set to * the host of the host / port pair. * @param port A pointer to an uint16_t. If it is not NULL, the port of the * host / port pair will be written to it. * @param address The address for which the host and port should be retrieved */ |
︙ | |||
276 277 278 279 280 281 282 | 278 279 280 281 282 283 284 285 286 | + + | * @param address The address to hash * @return The hash for the specified of_udp_socket_address_t */ extern uint32_t of_udp_socket_address_hash(of_udp_socket_address_t *address); #ifdef __cplusplus } #endif OF_ASSUME_NONNULL_END |
Modified src/OFURL.h from [5d05ef422c] to [a3a984e369].
︙ | |||
13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 | 13 14 15 16 17 18 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 | + + - - + + - - - + + + | * LICENSE.GPLv2 or LICENSE.GPLv3 respectively included in the packaging of this * file. */ #import "OFObject.h" #import "OFSerialization.h" OF_ASSUME_NONNULL_BEGIN @class OFString; /*! * @class OFURL OFURL.h ObjFW/OFURL.h * * @brief A class for parsing URLs and accessing parts of it. */ @interface OFURL: OFObject <OFCopying, OFSerialization> { OFString *_scheme, *_host; uint16_t _port; OFString *_user, *_password, *_path, *_parameters, *_query, *_fragment; } #ifdef OF_HAVE_PROPERTIES @property (copy) OFString *scheme; @property (copy) OFString *host; @property uint16_t port; |
︙ | |||
130 131 132 133 134 135 136 | 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 | - + - + - + - + - + - + - + - + - + - + + + | - (void)setPort: (uint16_t)port; /*! * @brief Returns the user part of the URL. * * @return The user part of the URL */ |
Modified src/OFXMLAttribute.h from [f649c0cd04] to [06dd68e3e3].
︙ | |||
12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 | 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 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. */ #import "OFXMLNode.h" OF_ASSUME_NONNULL_BEGIN @class OFString; /*! * @class OFXMLAttribute OFXMLAttribute.h ObjFW/OFXMLAttribute.h * * @brief A representation of an attribute of an XML element as an object. */ @interface OFXMLAttribute: OFXMLNode { @public OFString *_name, *_namespace, *_stringValue; } #ifdef OF_HAVE_PROPERTIES @property (readonly, copy) OFString *name; # ifdef __cplusplus |
︙ | |||
53 54 55 56 57 58 59 | 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 | - + | * * @param name The name of the attribute * @param namespace_ The namespace of the attribute * @param stringValue The string value of the attribute * @return A new autoreleased OFXMLAttribute with the specified parameters */ + (instancetype)attributeWithName: (OFString*)name |
︙ | |||
75 76 77 78 79 80 81 | 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 | - + - + + + | * * @param name The name of the attribute * @param namespace_ The namespace of the attribute * @param stringValue The string value of the attribute * @return An initialized OFXMLAttribute with the specified parameters */ - initWithName: (OFString*)name |
Modified src/OFXMLCDATA.h from [adae2369d2] to [1ebcd2d0d8].
︙ | |||
12 13 14 15 16 17 18 19 20 21 22 23 24 25 | 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 | + + | * 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 "OFXMLNode.h" OF_ASSUME_NONNULL_BEGIN /*! * @class OFXMLCDATA OFXMLCDATA.h ObjFW/OFXMLCDATA.h * * @brief A class representing XML CDATA. */ @interface OFXMLCDATA: OFXMLNode { |
︙ | |||
38 39 40 41 42 43 44 | 40 41 42 43 44 45 46 47 48 | + + | * @brief Initializes an alredy allocated OFXMLCDATA with the specified string. * * @param string The string value for the CDATA * @return An initialized OFXMLCDATA */ - initWithString: (OFString*)string; @end OF_ASSUME_NONNULL_END |
Modified src/OFXMLCharacters.h from [e1225e013b] to [178ec3fb9d].
︙ | |||
12 13 14 15 16 17 18 19 20 21 22 23 24 25 | 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 | + + | * 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 "OFXMLNode.h" OF_ASSUME_NONNULL_BEGIN /*! * @class OFXMLCharacters OFXMLCharacters.h ObjFW/OFXMLCharacters.h * * @brief A class representing XML characters. */ @interface OFXMLCharacters: OFXMLNode { |
︙ | |||
39 40 41 42 43 44 45 | 41 42 43 44 45 46 47 48 49 | + + | * string. * * @param string The string value for the characters * @return An initialized OFXMLCharacters */ - initWithString: (OFString*)string; @end OF_ASSUME_NONNULL_END |
Modified src/OFXMLComment.h from [607f77da02] to [d8d36ce46e].
︙ | |||
12 13 14 15 16 17 18 19 20 21 22 23 24 25 | 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 | + + | * 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 "OFXMLNode.h" OF_ASSUME_NONNULL_BEGIN /*! * @class OFXMLComment OFXMLComment.h ObjFW/OFXMLComment.h * * @brief A class for representing XML comments. */ @interface OFXMLComment: OFXMLNode { |
︙ | |||
39 40 41 42 43 44 45 | 41 42 43 44 45 46 47 48 49 | + + | * string. * * @param string The string for the comment * @return An initialized OFXMLComment */ - initWithString: (OFString*)string; @end OF_ASSUME_NONNULL_END |
Modified src/OFXMLElement+Serialization.h from [075c05aef9] to [dda7e9f3d6].
︙ | |||
12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 | 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 | + + + + | * 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 "OFXMLElement.h" OF_ASSUME_NONNULL_BEGIN #ifdef __cplusplus extern "C" { #endif extern int _OFXMLElement_Serialization_reference; #ifdef __cplusplus } #endif @interface OFXMLElement (OFSerialization) /*! * @brief Deserializes the receiver into an object. * * @return The deserialized object */ - (id)objectByDeserializing; @end OF_ASSUME_NONNULL_END |
Modified src/OFXMLElement.h from [3275f15b38] to [1cbedf75d5].
︙ | |||
12 13 14 15 16 17 18 19 20 21 22 23 24 25 | 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 | + + | * 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 "OFXMLNode.h" OF_ASSUME_NONNULL_BEGIN @class OFString; @class OFMutableString; #ifndef DOXYGEN @class OFArray OF_GENERIC(ObjectType); @class OFMutableArray OF_GENERIC(ObjectType); @class OFMutableDictionary OF_GENERIC(KeyType, ObjectType); #endif |
︙ | |||
37 38 39 40 41 42 43 | 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 | - + + - + - - - + + + + - + - + - - + + | OFMutableDictionary OF_GENERIC(OFString*, OFString*) *_namespaces; OFMutableArray OF_GENERIC(OFXMLNode*) *_children; } #ifdef OF_HAVE_PROPERTIES @property (copy) OFString *name; # ifdef __cplusplus |
︙ | |||
136 137 138 139 140 141 142 | 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 | - + - + - - + + | * * @param name The name for the element * @param stringValue The value for the element * @return An initialized OFXMLElement with the specified element name and * value */ - initWithName: (OFString*)name |
︙ | |||
213 214 215 216 217 218 219 | 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 | - + - + + + + + + + + + + + + + + + + + + + + + + + + + + + - + - - - - - - - - - - - - - - | - (OFString*)name; /*! * @brief Sets the namespace of the element. * * @param namespace_ The new namespace */ |
︙ | |||
277 278 279 280 281 282 283 | 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 349 350 351 352 353 354 355 356 | - + - + - + - + - + - - + - - + - - - - - - + - - - - - - + | * added. * * @param name The name of the attribute * @param namespace_ The namespace of the attribute * @param stringValue The value of the attribute */ - (void)addAttributeWithName: (OFString*)name |
︙ | |||
411 412 413 414 415 416 417 | 415 416 417 418 419 420 421 422 423 424 425 426 427 428 429 | - + | /*! * @brief Returns all children that have the specified namespace. * * @return All children that have the specified namespace */ - (OFArray OF_GENERIC(OFXMLElement*)*)elementsForNamespace: |
︙ | |||
437 438 439 440 441 442 443 | 441 442 443 444 445 446 447 448 449 450 451 452 453 454 455 456 457 458 459 460 461 462 463 464 | - + - - + + + + + | * @brief Returns the first child element with the specified name and namespace. * * @param elementName The name of the element * @param elementNS The namespace of the element * @return The first child element with the specified name and namespace */ - (OFXMLElement*)elementForName: (OFString*)elementName |
Modified src/OFXMLElementBuilder.h from [bc1c1fb01a] to [0cd8345c79].
︙ | |||
12 13 14 15 16 17 18 19 20 21 22 23 24 25 | 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 | + + | * 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 "OFObject.h" #import "OFXMLParser.h" OF_ASSUME_NONNULL_BEGIN @class OFMutableArray OF_GENERIC(ObjectType); @class OFXMLElement; @class OFXMLElementBuilder; /*! * @protocol OFXMLElementBuilderDelegate |
︙ | |||
75 76 77 78 79 80 81 | 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 | - - + + | * @param builder The builder which did not expect the close tag * @param name The name of the close tag * @param prefix The prefix of the close tag * @param namespace_ The namespace of the close tag */ - (void)elementBuilder: (OFXMLElementBuilder*)builder didNotExpectCloseTag: (OFString*)name |
︙ | |||
107 108 109 110 111 112 113 | 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 | - + - - - - - - - + + + + + + + - + + + | @interface OFXMLElementBuilder: OFObject <OFXMLParserDelegate> { OFMutableArray OF_GENERIC(OFXMLElement*) *_stack; id <OFXMLElementBuilderDelegate> _delegate; } #ifdef OF_HAVE_PROPERTIES |
Modified src/OFXMLNode.h from [92923cf6b5] to [ec948ed45d].
︙ | |||
13 14 15 16 17 18 19 20 21 22 23 24 25 26 | 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 | + + | * LICENSE.GPLv2 or LICENSE.GPLv3 respectively included in the packaging of this * file. */ #import "OFObject.h" #import "OFSerialization.h" OF_ASSUME_NONNULL_BEGIN /*! * @class OFXMLNode OFXMLNode.h ObjFW/OFXMLNode.h * * @brief A class which stores an XML element. */ @interface OFXMLNode: OFObject <OFCopying, OFSerialization> /*! |
︙ | |||
93 94 95 96 97 98 99 | 95 96 97 98 99 100 101 102 103 | + + | * @param level The level of indentation * @return An OFString representing the OFXMLNode as an XML string with * indentation */ - (OFString*)XMLStringWithIndentation: (unsigned int)indentation level: (unsigned int)level; @end OF_ASSUME_NONNULL_END |
Modified src/OFXMLParser.h from [fa3cd926f4] to [67de382a36].
︙ | |||
14 15 16 17 18 19 20 21 22 23 24 25 26 27 | 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 | + + | * file. */ #import "OFObject.h" #import "OFString.h" #import "OFXMLAttribute.h" OF_ASSUME_NONNULL_BEGIN @class OFXMLParser; #ifndef DOXYGEN @class OFArray OF_GENERIC(ObjectType); @class OFMutableArray OF_GENERIC(ObjectType); @class OFMutableDictionary OF_GENERIC(KeyType, ObjectType); #endif @class OFDataArray; |
︙ | |||
55 56 57 58 59 60 61 | 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 | - - - + + + - - + + | * @param prefix The prefix of the tag which just started or nil * @param ns The namespace of the tag which just started or nil * @param attributes The attributes included in the tag which just started or * nil */ - (void)parser: (OFXMLParser*)parser didStartElement: (OFString*)name |
︙ | |||
172 173 174 175 176 177 178 | 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 | - + - - - - - - - + + + + + + + - + | size_t _lineNumber; bool _lastCarriageReturn, _finishedParsing; of_string_encoding_t _encoding; size_t _depthLimit; } #ifdef OF_HAVE_PROPERTIES |
︙ | |||
264 265 266 267 268 269 270 | 266 267 268 269 270 271 272 273 274 | + + | * @return Whether the XML parser has finished parsing */ - (bool)finishedParsing; @end @interface OFObject (OFXMLParserDelegate) <OFXMLParserDelegate> @end OF_ASSUME_NONNULL_END |
Modified src/OFXMLProcessingInstructions.h from [b8543db99d] to [cd910d0b0a].
︙ | |||
12 13 14 15 16 17 18 19 20 21 22 23 24 25 | 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 | + + | * 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 "OFXMLNode.h" OF_ASSUME_NONNULL_BEGIN /*! * @class OFXMLProcessingInstructions \ * OFXMLProcessingInstructions.h ObjFW/OFXMLProcessingInstructions.h * * @brief A class for representing XML processing instructions. */ @interface OFXMLProcessingInstructions: OFXMLNode |
︙ | |||
40 41 42 43 44 45 46 | 42 43 44 45 46 47 48 49 50 | + + | * specified string. * * @param string The string for the processing instructions * @return An initialized OFXMLProcessingInstructions */ - initWithString: (OFString*)string; @end OF_ASSUME_NONNULL_END |
Modified src/OFZIPArchive.h from [3ce281f546] to [d2c0dfdef8].
︙ | |||
14 15 16 17 18 19 20 21 22 23 24 25 26 27 | 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 | + + | * file. */ #import "OFObject.h" #import "OFString.h" #import "OFZIPArchiveEntry.h" OF_ASSUME_NONNULL_BEGIN #ifndef DOXYGEN @class OFArray OF_GENERIC(ObjectType); @class OFMutableArray OF_GENERIC(ObjectType); @class OFMutableDictionary OF_GENERIC(KeyType, ObjectType); #endif @class OFSeekableStream; @class OFStream; |
︙ | |||
110 111 112 113 114 115 116 | 112 113 114 115 116 117 118 119 120 | + + | * invalidated stream will throw an @ref OFReadFailedException! * * @param path The path to the file inside the archive * @return A stream for reading the specified file form the archive */ - (OFStream*)streamForReadingFile: (OFString*)path; @end OF_ASSUME_NONNULL_END |
Modified src/OFZIPArchiveEntry+Private.h from [d8d4d53628] to [ae322a52c9].
︙ | |||
11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 | 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 | + + + + | * 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 "OFZIPArchive.h" OF_ASSUME_NONNULL_BEGIN @interface OFZIPArchiveEntry (OF_PRIVATE_CATEGORY) - (instancetype)OF_initWithStream: (OFStream*)stream; - (uint16_t)OF_generalPurposeBitFlag; - (uint16_t)OF_lastModifiedFileTime; - (uint16_t)OF_lastModifiedFileDate; - (uint64_t)OF_localFileHeaderOffset; @end OF_ASSUME_NONNULL_END |
Modified src/OFZIPArchiveEntry.h from [7421f93176] to [247677c877].
︙ | |||
12 13 14 15 16 17 18 19 20 21 22 23 24 25 | 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 | + + | * 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 "OFObject.h" OF_ASSUME_NONNULL_BEGIN /*! @file */ enum { OF_ZIP_ARCHIVE_ENTRY_COMPRESSION_METHOD_NONE = 0, OF_ZIP_ARCHIVE_ENTRY_COMPRESSION_METHOD_DEFLATE = 8, OF_ZIP_ARCHIVE_ENTRY_COMPRESSION_METHOD_DEFLATE64 = 9 }; |
︙ | |||
229 230 231 232 233 234 235 | 231 232 233 234 235 236 237 238 239 240 241 242 243 | - + + + | * the specified tag * @param tag The tag to look for * @param data A pointer to a pointer that should be set to the start of the * extra field with the specified tag * @param size A pointer to an uint16_t that should be set to the size */ extern void of_zip_archive_entry_extra_field_find(OFDataArray *extraField, |
Modified src/atomic.h from [4c89aaf0ff] to [907e2f3914].
︙ | |||
24 25 26 27 28 29 30 31 | 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 | + + - + | #import "macros.h" #ifdef OF_HAVE_OSATOMIC # include <libkern/OSAtomic.h> #endif OF_ASSUME_NONNULL_BEGIN static OF_INLINE int |
︙ | |||
74 75 76 77 78 79 80 | 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 | - + | return OSAtomicAdd32Barrier(i, p); #else # error of_atomic_int_add not implemented! #endif } static OF_INLINE int32_t |
︙ | |||
110 111 112 113 114 115 116 | 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 | - + | return OSAtomicAdd32Barrier(i, p); #else # error of_atomic_int32_add not implemented! #endif } static OF_INLINE void* |
︙ | |||
160 161 162 163 164 165 166 | 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 | - + | # endif #else # error of_atomic_ptr_add not implemented! #endif } static OF_INLINE int |
︙ | |||
211 212 213 214 215 216 217 | 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 | - + | return OSAtomicAdd32Barrier(-i, p); #else # error of_atomic_int_sub not implemented! #endif } static OF_INLINE int32_t |
︙ | |||
248 249 250 251 252 253 254 | 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 | - + | return OSAtomicAdd32Barrier(-i, p); #else # error of_atomic_int32_sub not implemented! #endif } static OF_INLINE void* |
︙ | |||
300 301 302 303 304 305 306 | 302 303 304 305 306 307 308 309 310 311 312 313 314 315 316 | - + | # endif #else # error of_atomic_ptr_sub not implemented! #endif } static OF_INLINE int |
︙ | |||
357 358 359 360 361 362 363 | 359 360 361 362 363 364 365 366 367 368 369 370 371 372 373 | - + | return OSAtomicIncrement32Barrier(p); #else # error of_atomic_int_inc not implemented! #endif } static OF_INLINE int32_t |
︙ | |||
399 400 401 402 403 404 405 | 401 402 403 404 405 406 407 408 409 410 411 412 413 414 415 | - + | return OSAtomicIncrement32Barrier(p); #else # error of_atomic_int32_inc not implemented! #endif } static OF_INLINE int |
︙ | |||
456 457 458 459 460 461 462 | 458 459 460 461 462 463 464 465 466 467 468 469 470 471 472 | - + | return OSAtomicDecrement32Barrier(p); #else # error of_atomic_int_dec not implemented! #endif } static OF_INLINE int32_t |
︙ | |||
498 499 500 501 502 503 504 | 500 501 502 503 504 505 506 507 508 509 510 511 512 513 514 | - + | return OSAtomicDecrement32Barrier(p); #else # error of_atomic_int32_dec not implemented! #endif } static OF_INLINE unsigned int |
︙ | |||
557 558 559 560 561 562 563 | 559 560 561 562 563 564 565 566 567 568 569 570 571 572 573 | - + | return OSAtomicOr32Barrier(i, p); #else # error of_atomic_int_or not implemented! #endif } static OF_INLINE uint32_t |
︙ | |||
598 599 600 601 602 603 604 | 600 601 602 603 604 605 606 607 608 609 610 611 612 613 614 | - + | return OSAtomicOr32Barrier(i, p); #else # error of_atomic_int32_or not implemented! #endif } static OF_INLINE unsigned int |
︙ | |||
657 658 659 660 661 662 663 | 659 660 661 662 663 664 665 666 667 668 669 670 671 672 673 | - + | return OSAtomicAnd32Barrier(i, p); #else # error of_atomic_int_and not implemented! #endif } static OF_INLINE uint32_t |
︙ | |||
698 699 700 701 702 703 704 | 700 701 702 703 704 705 706 707 708 709 710 711 712 713 714 | - + | return OSAtomicAnd32Barrier(i, p); #else # error of_atomic_int32_and not implemented! #endif } static OF_INLINE unsigned int |
︙ | |||
757 758 759 760 761 762 763 | 759 760 761 762 763 764 765 766 767 768 769 770 771 772 773 | - + | return OSAtomicXor32Barrier(i, p); #else # error of_atomic_int_xor not implemented! #endif } static OF_INLINE uint32_t |
︙ | |||
798 799 800 801 802 803 804 | 800 801 802 803 804 805 806 807 808 809 810 811 812 813 814 | - + | return OSAtomicXor32Barrier(i, p); #else # error of_atomic_int32_xor not implemented! #endif } static OF_INLINE bool |
︙ | |||
853 854 855 856 857 858 859 | 855 856 857 858 859 860 861 862 863 864 865 866 867 868 869 | - + | return OSAtomicCompareAndSwapIntBarrier(o, n, p); #else # error of_atomic_int_cmpswap not implemented! #endif } static OF_INLINE bool |
︙ | |||
908 909 910 911 912 913 914 | 910 911 912 913 914 915 916 917 918 919 920 921 922 923 924 925 | - + + | return OSAtomicCompareAndSwap32Barrier(o, n, p); #else # error of_atomic_int32_cmpswap not implemented! #endif } static OF_INLINE bool |
︙ | |||
1008 1009 1010 1011 1012 1013 1014 | 1011 1012 1013 1014 1015 1016 1017 1018 1019 | + + | __asm__ __volatile__ ( "sfence" ); #else of_memory_barrier(); #endif } OF_ASSUME_NONNULL_END |
Modified src/autorelease.h from [cc1becd34f] to [bf550554f1].
︙ | |||
10 11 12 13 14 15 16 17 18 19 20 21 22 23 | 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 | + + + + | * * 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 "macros.h" OF_ASSUME_NONNULL_BEGIN /*! @file */ #ifdef __cplusplus extern "C" { #endif /*! * @brief Creates a new autorelease pool. |
︙ | |||
39 40 41 42 43 44 45 | 43 44 45 46 47 48 49 50 51 | + + | * @param object The object to autorelease * @return The autoreleased object */ extern id _objc_rootAutorelease(id object); #ifdef __cplusplus } #endif OF_ASSUME_NONNULL_END |
Modified src/base64.h from [83adc61f26] to [3f2eb41d3c].
︙ | |||
19 20 21 22 23 24 25 | 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 | - - - + + - - + + + | #ifndef __STDC_LIMIT_MACROS # define __STDC_LIMIT_MACROS #endif #ifndef __STDC_CONSTANT_MACROS # define __STDC_CONSTANT_MACROS #endif |
Modified src/block.h from [74698753c6] to [30540ac853].
︙ | |||
10 11 12 13 14 15 16 17 18 19 20 21 22 23 | 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 | + + + + | * * 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 "macros.h" OF_ASSUME_NONNULL_BEGIN typedef struct of_block_literal_t { #ifdef __OBJC__ Class isa; #else void *isa; #endif int flags; |
︙ | |||
44 45 46 47 48 49 50 | 48 49 50 51 52 53 54 55 56 | + + | #ifndef Block_copy # define Block_copy(...) \ ((__typeof__(__VA_ARGS__))_Block_copy((const void*)(__VA_ARGS__))) #endif #ifndef Block_release # define Block_release(...) _Block_release((const void*)(__VA_ARGS__)) #endif OF_ASSUME_NONNULL_END |
Modified src/instance.h from [e149a9f613] to [a5b3481f06].
︙ | |||
10 11 12 13 14 15 16 17 18 19 | 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 | + + + + - + + + | * * 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 "macros.h" OF_ASSUME_NONNULL_BEGIN #ifdef __cplusplus extern "C" { #endif |
Modified src/macros.h from [73c4a25692] to [6ce9a1b05b].
︙ | |||
169 170 171 172 173 174 175 176 177 178 179 180 181 182 | 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 | + + + + + + + + + + + + | #if __has_feature(objc_generics) # define OF_HAVE_GENERICS # define OF_GENERIC(...) <__VA_ARGS__> #else # define OF_GENERIC(...) #endif #if __has_feature(nullability) # define OF_ASSUME_NONNULL_BEGIN _Pragma("clang assume_nonnull begin") # define OF_ASSUME_NONNULL_END _Pragma("clang assume_nonnull end") #else # define OF_ASSUME_NONNULL_BEGIN # define OF_ASSUME_NONNULL_END # define __nonnull # define __nullable # define nonnull # define nullable #endif #if __has_feature(objc_kindof) # define OF_KINDOF(cls) __kindof cls #else # define OF_KINDOF(cls) id #endif |
︙ |
Modified src/of_asprintf.h from [b3e6d9aacb] to [f79cba2d8d].
︙ | |||
19 20 21 22 23 24 25 26 27 28 | 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 | + + + + - - + + + + + | #endif #ifndef __STDC_CONSTANT_MACROS # define __STDC_CONSTANT_MACROS #endif #include <stdarg.h> #import "macros.h" OF_ASSUME_NONNULL_BEGIN #ifdef __cplusplus extern "C" { #endif |
Modified src/of_strptime.h from [0474419529] to [3d18d54500].
︙ | |||
19 20 21 22 23 24 25 26 27 28 29 30 31 32 | 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 | + + + + + + | #endif #ifndef __STDC_CONSTANT_MACROS # define __STDC_CONSTANT_MACROS #endif #include <time.h> #import "macros.h" OF_ASSUME_NONNULL_BEGIN #ifdef __cplusplus extern "C" { #endif extern const char* of_strptime(const char*, const char*, struct tm *tm); #ifdef __cplusplus } #endif OF_ASSUME_NONNULL_END |
Modified src/resolver.h from [f71e91f385] to [453d9528f7].
︙ | |||
14 15 16 17 18 19 20 21 22 23 24 25 26 27 | 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 | + + | * file. */ #import "OFString.h" #import "socket.h" OF_ASSUME_NONNULL_BEGIN /*! @file */ /*! * @struct of_resolver_result_t resolver.h ObjFW/resolver.h * * @brief A struct representing one result from the resolver. */ |
︙ | |||
43 44 45 46 47 48 49 | 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 | - - + + - + + + - + + + + | * struct * @param protocol The protocol that should be inserted into the resulting * address struct * * @return An array of results. The list is terminated by NULL and should be * free'd after use. */ |
Modified src/socket.h from [dbedacc6ee] to [c74fa51c3e].
︙ | |||
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 | 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 | + + + + + + | sa_family_t ss_family; in_port_t ss_data1; struct in_addr ss_data2; int8_t ss_data3[8]; }; #endif #import "macros.h" OF_ASSUME_NONNULL_BEGIN #ifndef _WIN32 typedef int of_socket_t; #else typedef SOCKET of_socket_t; #endif #ifdef __cplusplus extern "C" { #endif extern bool of_socket_init(void); extern int of_socket_errno(void); # ifndef __wii__ extern int of_getsockname(of_socket_t socket, struct sockaddr *restrict address, socklen_t *restrict address_len); # endif #ifdef __cplusplus } #endif OF_ASSUME_NONNULL_END |
Modified tests/OFDataArrayTests.m from [7ed24ced8e] to [06e9072275].
︙ | |||
131 132 133 134 135 136 137 | 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 | - + | count: 6]) && R([array[0] addItem: ""]) && !strcmp([array[0] items], str)) EXPECT_EXCEPTION(@"Detect out of range in -[itemAtIndex:]", OFOutOfRangeException, [array[0] itemAtIndex: [array[0] count]]) EXPECT_EXCEPTION(@"Detect out of range in -[addItems:count:]", |
︙ |