ObjFW  Changes On Branch 99766b222c6b6d11

Changes In Branch 0.7 Through [99766b222c] Excluding Merge-Ins

This is equivalent to a diff from 24b7e7894e to 99766b222c

2012-12-01
18:29
Increase library version minor. check-in: e1996effd2 user: js tags: 0.7
2012-11-30
15:41
Remove inline that lead to a missing symbol. check-in: 99766b222c user: js tags: 0.7
15:41
Remove functions from runtime.h that don't exist. check-in: e661bf4171 user: js tags: 0.7
2012-10-27
16:32
Update ChangeLog for 0.7. check-in: 49f84877bf user: js tags: trunk
16:16
Branch for 0.7. check-in: fef1ca67e1 user: js tags: 0.7
16:16
make tarball: Generate documentation tarball. check-in: 24b7e7894e user: js tags: trunk
16:09
TableGenerator: Terminate when done. check-in: 8aba444b87 user: js tags: trunk

Modified ChangeLog from [92fa197ba9] to [3f68d32878].

1
2
3
4

































5
6
7
8
9
10
11
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44




+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+







Legend:
 * Changes of existing features or bugfixes.
 + New features.

ObjFW 0.7 -> ObjFW 0.7.1, 12.11.2012
 + Support for Haiku.
 * Autorelease pools now work properly without __thread.
 * Incorrect framework version in Xcode project fixed.
 * Documentation fixes and improvements.
 * Blocks now only use 16 bits for the reference count in order to avoid
   problems with newer Clang versions.
 * More use of OF_SENTINEL.

ObjFW 0.6 -> ObjFW 0.7, 27.10.2012
 Again, the differences are more than in any release before, thus listing them
 all would be too much. The major differences are:
 + ObjFW now comes with its own runtime, which greatly increases performance
   compared to the GNU runtime and is even faster than the Apple runtime
   (using Clang >= 3.2 is recommended, but not necessary).
 * Support for the GNU runtime has been dropped.
 + New, much faster autorelease pool implementation (now inside the runtime).
 + Support for Automatic Reference Counting (requires Clang >= 3.2).
 + Forwarding has been implemented.
 + Asynchronous stream handling.
 + New classes: OFThreadPool, OFRecursiveMutex, OFSortedList, OFTimer, OFRunLoop
 + New protocols: OFLocking, OFTLSSocket
 * Lots of API changes to make APIs more future-proof.
 + Support for the new Objective-C literals.
 * OFHTTPRequest now implements HTTP/1.1.
 * OFObject's memory handling has been improved, leading to better performance.
 * Strings are allocated faster now.
 + Support for JSON5.
 * All private methods use the prefix OF_ now instead of _, making it possible
   to use the _ prefix in applications.
 * Most ObjC compiler feature checks are not part of configure anymore, making
   it possible to use the same installation with different compilers.

ObjFW 0.5.4 -> ObjFW 0.6, 27.02.2012
 The differences between 0.5.4 and 0.6 are too big to list them all. However,
 the major new features are:
 * OFString, OFArray, OFDictionary, OFSet and OFCountedSet are now class
   clusters.
 + Serialization and deserialization of objects into/from XML and JSON.
 + New class OFIntrospection for introspecting classes.

Modified ObjFW.xcodeproj/project.pbxproj from [1d3afb7b15] to [91cbd2f31d].

1773
1774
1775
1776
1777
1778
1779
1780
1781


1782
1783
1784
1785
1786
1787
1788
1789
1790
1791
1792
1793
1794
1795
1796
1797
1798
1799
1800


1801
1802
1803
1804
1805
1806
1807
1773
1774
1775
1776
1777
1778
1779


1780
1781
1782
1783
1784
1785
1786
1787
1788
1789
1790
1791
1792
1793
1794
1795
1796
1797
1798


1799
1800
1801
1802
1803
1804
1805
1806
1807







-
-
+
+

















-
-
+
+







				PRODUCT_NAME = "$(TARGET_NAME)";
			};
			name = Release;
		};
		4B3D23871337FBC800DD29B8 /* Debug */ = {
			isa = XCBuildConfiguration;
			buildSettings = {
				DYLIB_COMPATIBILITY_VERSION = 5;
				DYLIB_CURRENT_VERSION = 5;
				DYLIB_COMPATIBILITY_VERSION = 6;
				DYLIB_CURRENT_VERSION = 6;
				FRAMEWORK_VERSION = A;
				INFOPLIST_FILE = Info.plist;
				OTHER_LDFLAGS = (
					"-Wl,-reexport-lobjc",
					"-lobjc",
					"-lm",
					"-Xarch_x86_64",
					"-Wl,-alias_list,${SOURCE_ROOT}/src/mach_alias_list",
				);
				PRODUCT_NAME = "$(TARGET_NAME)";
				WRAPPER_EXTENSION = framework;
			};
			name = Debug;
		};
		4B3D23881337FBC800DD29B8 /* Release */ = {
			isa = XCBuildConfiguration;
			buildSettings = {
				DYLIB_COMPATIBILITY_VERSION = 5;
				DYLIB_CURRENT_VERSION = 5;
				DYLIB_COMPATIBILITY_VERSION = 6;
				DYLIB_CURRENT_VERSION = 6;
				FRAMEWORK_VERSION = A;
				INFOPLIST_FILE = Info.plist;
				OTHER_LDFLAGS = (
					"-Wl,-reexport-lobjc",
					"-lobjc",
					"-lm",
					"-Xarch_x86_64",

Modified PLATFORMS.md from [491300294a] to [6dc1d88aa1].

9
10
11
12
13
14
15









16
17
18
19
20
21
22
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31







+
+
+
+
+
+
+
+
+







------------

  * OS versions: 3.0, 3.3-DEVELOPMENT
  * Architectures: x86, x86_64
  * Compilers: GCC 4.4.7
  * Runtimes: ObjFW


Haiku
-----

  * OS version: r1-alpha4
  * Architectures: x86
  * Compilers: Clang 3.2, GCC 4.6.3
  * Runtimes: ObjFW


iOS
---

  * Architectures: ARM
  * Compilers: GCC 4.2.1
  * Runtimes: Apple

Modified buildsys.mk.in from [8ce39250fe] to [b65e728a78].

56
57
58
59
60
61
62




63
64
65
66
67
68
69
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73







+
+
+
+







LIB_SUFFIX = @LIB_SUFFIX@
PLUGIN_CFLAGS = @PLUGIN_CFLAGS@
PLUGIN_LDFLAGS = @PLUGIN_LDFLAGS@
PLUGIN_SUFFIX = @PLUGIN_SUFFIX@
INSTALL_LIB = @INSTALL_LIB@
UNINSTALL_LIB = @UNINSTALL_LIB@
CLEAN_LIB = @CLEAN_LIB@
CC_DEPENDS = @CC_DEPENDS@
CXX_DEPENDS = @CXX_DEPENDS@
OBJC_DEPENDS = @OBJC_DEPENDS@
OBJCXX_DEPENDS = @OBJCXX_DEPENDS@
LN_S = @LN_S@
MKDIR_P = mkdir -p
INSTALL = @INSTALL@
SHELL = @SHELL@
MSGFMT = @MSGFMT@
JAVAC = @JAVAC@
JAVACFLAGS = @JAVACFLAGS@
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
126
127
128
129
130
131
132
133
134
135
136
137
138



139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181


182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205







+
+
+
+
+
+
-
-
-
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+















+
+
+
+
+
-
-
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+








depend: pre-depend ${SRCS}
	regen=0; \
	deps=""; \
	test -f .deps || regen=1; \
	for i in ${SRCS}; do \
		case $$i in \
			*.c) \
				if test x"${CC_DEPENDS}" = x"yes"; then \
					test $$i -nt .deps && regen=1; \
					deps="$$deps $$i.dep"; \
				fi; \
				;; \
			*.c | *.cc | *.cxx | *.m | *.mm | *.S) \
				test $$i -nt .deps && regen=1; \
				deps="$$deps $$i.dep"; \
			*.cc | *.cxx) \
				if test x"${CXX_DEPENDS}" = x"yes"; then \
					test $$i -nt .deps && regen=1; \
					deps="$$deps $$i.dep"; \
				fi; \
				;; \
			*.m) \
				if test x"${OBJC_DEPENDS}" = x"yes"; then \
					test $$i -nt .deps && regen=1; \
					deps="$$deps $$i.dep"; \
				fi; \
				;; \
			*.mm) \
				if test x"${OBJCXX_DEPENDS}" = x"yes"; then \
					test $$i -nt .deps && regen=1; \
					deps="$$deps $$i.dep"; \
				fi; \
				;; \
			*.S) \
				if test x"${AS_DEPENDS}" = x"yes"; then \
					test $$i -nt .deps && regen=1; \
					deps="$$deps $$i.dep"; \
				fi; \
				;; \
		esac; \
	done; \
	if test x"$$regen" = x"1" -a x"$$deps" != x""; then \
		${DEPEND_STATUS}; \
		if ${MAKE} ${MFLAGS} $$deps && cat $$deps >.deps; then \
			rm -f $$deps; \
			${DEPEND_OK}; \
		else \
			:> .deps; \
			touch -t 0001010000 .deps; \
			${DEPEND_FAILED}; \
		fi; \
	fi

.c.c.dep:
	${CPP} ${CPPFLAGS} ${CFLAGS} -M $< | \
	sed 's/^\([^\.]*\)\.o:/\1.o \1.lib.o \1.plugin.o:/' >$@ || \
	{ rm -f $@; false; }

.c.c.dep .cc.cc.dep .cxx.cxx.dep .m.m.dep .mm.mm.dep .S.S.dep:
	${CPP} ${CPPFLAGS} -M $< | \
.cc.cc.dep .cxx.cxx.dep:
	${CPP} ${CPPFLAGS} ${CXXFLAGS} -M $< | \
	sed 's/^\([^\.]*\)\.o:/\1.o \1.lib.o \1.plugin.o:/' >$@ || \
	{ rm -f $@; false; }

.m.m.dep:
	${CPP} ${CPPFLAGS} ${OBJCFLAGS} -M $< | \
	sed 's/^\([^\.]*\)\.o:/\1.o \1.lib.o \1.plugin.o:/' >$@ || \
	{ rm -f $@; false; }

.mm.mm.dep:
	${CPP} ${CPPFLAGS} ${OBJCPPFLAGS} -M $< | \
	sed 's/^\([^\.]*\)\.o:/\1.o \1.lib.o \1.plugin.o:/' >$@ || \
	{ rm -f $@; false; }

.S.S.dep:
	${CPP} ${CPPFLAGS} ${ASFLAGS} -M $< | \
	sed 's/^\([^\.]*\)\.o:/\1.o \1.lib.o \1.plugin.o:/' >$@ || \
	{ rm -f $@; false; }

pre-depend:

${PROG} ${PROG_NOINST}: ${EXT_DEPS} ${OBJS} ${OBJS_EXTRA}
	${LINK_STATUS}

Modified configure.ac from [b6a1472c42] to [55d15e10d9].

1

2
3
4
5
6
7
8

1
2
3
4
5
6
7
8
-
+







AC_INIT(ObjFW, 0.7-dev, js@webkeks.org)
AC_INIT(ObjFW, 0.7.1, js@webkeks.org)
AC_CONFIG_SRCDIR(src)

AS_IF([test x"$host" = x"psp"], [
	OBJCFLAGS="-G0 $OBJCFLAGS"
	LIBS="$LIBS -lpspdebug -lpspdisplay -lpspge -lpspctrl -lpspsdk -lc"
	LIBS="$LIBS -lpspnet -lpspnet_inet -lpspnet_apctl -lpspnet_resolver"
	LIBS="$LIBS -lpsputility -lpspuser -lpspkernel"

Modified m4/buildsys.m4 from [7661b473e8] to [80a1df42db].

18
19
20
21
22
23
24





25
26
27
28
29
30
31
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36







+
+
+
+
+







dnl INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
dnl CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
dnl ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
dnl POSSIBILITY OF SUCH DAMAGE.
dnl

AC_DEFUN([BUILDSYS_INIT], [
	AC_SUBST(CC_DEPENDS, $GCC)
	AC_SUBST(CXX_DEPENDS, $GXX)
	AC_SUBST(OBJC_DEPENDS, $GOBJC)
	AC_SUBST(OBJCXX_DEPENDS, $GOBJCXX)

	AC_PATH_PROG(TPUT, tput)

	AS_IF([test x"$TPUT" != x""], [
		if x=$($TPUT el 2>/dev/null); then
			AC_SUBST(TERM_EL, "$x")
		else
			AC_SUBST(TERM_EL, "$($TPUT ce 2>/dev/null)")

Modified src/OFArray.h from [d93b4c3a6a] to [55dd8b5416].

80
81
82
83
84
85
86
87

88
89
90
91
92
93
94
80
81
82
83
84
85
86

87
88
89
90
91
92
93
94







-
+







+ (instancetype)arrayWithArray: (OFArray*)array;

/**
 * \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 length The length of the C array
 * \param count The length of the C array
 * \return A new autoreleased OFArray
 */
+ (instancetype)arrayWithObjects: (id const*)objects
			   count: (size_t)count;

/**
 * \brief Initializes an OFArray with the specified object.
125
126
127
128
129
130
131
132

133
134
135
136
137
138
139
125
126
127
128
129
130
131

132
133
134
135
136
137
138
139







-
+







- initWithArray: (OFArray*)array;

/**
 * \brief Initializes an OFArray with the objects from the specified C array of
 *	  the specified length.
 *
 * \param objects A C array of objects
 * \param length The length of the C array
 * \param count The length of the C array
 * \return An initialized OFArray
 */
- initWithObjects: (id const*)objects
	    count: (size_t)count;

/**
 * \brief Returns a specified object of the array.

Modified src/OFBlock.m from [6ab3d02d2d] to [79c29da2a3].

53
54
55
56
57
58
59
60

61
62
63
64
65
66
67
68
69
53
54
55
56
57
58
59

60


61
62
63
64
65
66
67







-
+
-
-







enum {
	OF_BLOCK_HAS_COPY_DISPOSE = (1 << 25),
	OF_BLOCK_HAS_CTOR	  = (1 << 26),
	OF_BLOCK_IS_GLOBAL	  = (1 << 28),
	OF_BLOCK_HAS_STRET	  = (1 << 29),
	OF_BLOCK_HAS_SIGNATURE	  = (1 << 30),
};
#define OF_BLOCK_REFCOUNT_MASK \
#define OF_BLOCK_REFCOUNT_MASK 0xFFFF
	~(OF_BLOCK_HAS_COPY_DISPOSE | OF_BLOCK_HAS_CTOR | OF_BLOCK_IS_GLOBAL | \
	OF_BLOCK_HAS_STRET | OF_BLOCK_HAS_SIGNATURE)

enum {
	OF_BLOCK_FIELD_IS_OBJECT =   3,
	OF_BLOCK_FIELD_IS_BLOCK	 =   7,
	OF_BLOCK_FIELD_IS_BYREF	 =   8,
	OF_BLOCK_FIELD_IS_WEAK	 =  16,
	OF_BLOCK_BYREF_CALLER	 = 128,

Modified src/OFCondition.h from [1e8d6909b1] to [639ca19fe8].

29
30
31
32
33
34
35
36
37


38
39
40
41
42
43
44
29
30
31
32
33
34
35


36
37
38
39
40
41
42
43
44







-
-
+
+







 * \brief Creates a new condition.
 *
 * \return A new, autoreleased OFCondition
 */
+ (instancetype)condition;

/**
 * \brief Blocks the current thread until another thread calls -[signal] or
 *	  -[broadcast].
 * \brief Blocks the current thread until another thread calls \ref signal or
 *	  \ref broadcast.
 */
- (void)wait;

/**
 * \brief Signals the next waiting thread to continue.
 */
- (void)signal;

Modified src/OFDataArray.h from [fe192fcada] to [32b74edf73].

89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
89
90
91
92
93
94
95







96
97
98
99
100
101
102







-
-
-
-
-
-
-







 *	  of the Base64-encoded string.
 *
 * \param string The string with the Base64-encoded data
 * \return A new autoreleased OFDataArray
 */
+ (instancetype)dataArrayWithBase64EncodedString: (OFString*)string;

/**
 * \brief Initializes an already allocated OFDataArray with an item size of 1.
 *
 * \return A initialized OFDataArray
 */
- init;

/**
 * \brief Initializes an already allocated OFDataArray whose items all have the
 *	  same size.
 *
 * \param itemSize The size of each element in the OFDataArray
 * \return An initialized OFDataArray
 */
137
138
139
140
141
142
143
144

145
146
147
148
149
150
151
130
131
132
133
134
135
136

137
138
139
140
141
142
143
144







-
+







- initWithStringRepresentation: (OFString*)string;

/**
 * \brief Initializes an already allocated OFDataArray with an item size of 1,
 *	  containing the data of the Base64-encoded string.
 *
 * \param string The string with the Base64-encoded data
 * \return A initialized OFDataArray
 * \return An initialized OFDataArray
 */
- initWithBase64EncodedString: (OFString*)string;

/**
 * \brief Returns the number of items in the OFDataArray.
 *
 * \return The number of items in the OFDataArray

Modified src/OFDataArray.m from [238d0749d1] to [dfe3b68b31].

393
394
395
396
397
398
399
400
401


402
403
404
405
406
407
408
393
394
395
396
397
398
399


400
401
402
403
404
405
406
407
408







-
-
+
+







	} @catch (OFOutOfMemoryException *e) {
		/* We don't really care, as we only made it smaller */
	}
}

- (void)removeLastItem
{
	if (count < 1)
		@throw [OFOutOfRangeException exceptionWithClass: [self class]];
	if (count == 0)
		return;

	count--;
	@try {
		data = [self resizeMemory: data
				     size: itemSize
				    count: count];
	} @catch (OFOutOfMemoryException *e) {
659
660
661
662
663
664
665
666
667


668
669
670
671
672
673
674
659
660
661
662
663
664
665


666
667
668
669
670
671
672
673
674







-
-
+
+







	size = newSize;
}

- (void)removeLastItem
{
	size_t newSize, lastPageByte;

	if (count < 1)
		@throw [OFOutOfRangeException exceptionWithClass: [self class]];
	if (count == 0)
		return;

	count--;
	lastPageByte = of_pagesize - 1;
	newSize = (count * itemSize + lastPageByte) & ~lastPageByte;

	if (size != newSize) {
		@try {

Modified src/OFDate.h from [09915d0305] to [c62550e787].

52
53
54
55
56
57
58
59

60
61
62
63
64
65
66
52
53
54
55
56
57
58

59
60
61
62
63
64
65
66







-
+







 */
+ (instancetype)dateWithTimeIntervalSinceNow: (double)seconds;

/**
 * \brief Creates a new OFDate with the specified string in the specified
 *	  format.
 *
 * The time zone used is UTC. See +[dateWithLocalDateString:format:] if you
 * The time zone used is UTC. See \ref dateWithLocalDateString:format: if you
 * want local time.
 *
 * See the manpage for strftime for information on the format.
 *
 * \warning The format is currently limited to the following format specifiers:
 *	    %%d, %%e, %%H, %%m, %%M, %%S, %%y, %%Y, %%, %%n and %%t.
 *
124
125
126
127
128
129
130
131

132
133
134
135
136
137
138
124
125
126
127
128
129
130

131
132
133
134
135
136
137
138







-
+







- initWithTimeIntervalSinceNow: (double)seconds;

/**
 * \brief Initializes an already allocated OFDate with the specified string in
 *	  the specified format.
 *
 * The time zone used is UTC. If a time zone is specified anyway, an
 * OFInvalidFormatException is thrown. See -[initWithLocalDateString:format:]
 * OFInvalidFormatException is thrown. See \ref initWithLocalDateString:format:
 * if you want to specify a time zone.
 *
 * See the manpage for strftime for information on the format.
 *
 * \warning The format is currently limited to the following format specifiers:
 *	    %%d, %%e, %%H, %%m, %%M, %%S, %%y, %%Y, %%, %%n and %%t.
 *
285
286
287
288
289
290
291
292

293
294
295
296
297
298
299
300

301
302
303
304
305
306
307
308
309
310
311
312
313
314
315

316
317
318
319
320
321
322
285
286
287
288
289
290
291

292
293
294
295
296
297
298
299

300
301
302
303
304
305
306
307
308
309
310
311
312
313
314

315
316
317
318
319
320
321
322







-
+







-
+














-
+







 * \return A new, autoreleased OFString
 */
- (OFString*)localDateStringWithFormat: (OFConstantString*)format;

/**
 * \brief Returns the earlier of the two dates.
 *
 * \param date Another date
 * \param otherDate Another date
 * \return The earlier date of the two dates
 */
- (OFDate*)earlierDate: (OFDate*)otherDate;

/**
 * \brief Returns the later of the two dates.
 *
 * \param date Another date
 * \param otherDate Another date
 * \return The later date of the two dates
 */
- (OFDate*)laterDate: (OFDate*)otherDate;

/**
 * \brief Returns the seconds since 1970-01-01T00:00:00Z.
 *
 * \return The seconds since 1970-01-01T00:00:00Z
 */
- (double)timeIntervalSince1970;

/**
 * \brief Returns the seconds the receiver is after the date.
 *
 * \param date Date date to generate the difference with receiver
 * \param otherDate Date date to generate the difference with receiver
 * \return The seconds the receiver is after the date.
 */
- (double)timeIntervalSinceDate: (OFDate*)otherDate;

/**
 * \brief Returns the seconds the receiver is in the future.
 *

Modified src/OFDate.m from [66b4bbf344] to [da5cc3c73a].

26
27
28
29
30
31
32
33

34
35
36
37
38
39
40
26
27
28
29
30
31
32

33
34
35
36
37
38
39
40







-
+







#include <sys/time.h>

#import "OFDate.h"
#import "OFString.h"
#import "OFDictionary.h"
#import "OFXMLElement.h"
#ifdef OF_THREADS
# import "OFThread.h"
# import "OFMutex.h"
#endif

#import "OFInitializationFailedException.h"
#import "OFInvalidArgumentException.h"
#import "OFInvalidFormatException.h"
#import "OFOutOfRangeException.h"

Modified src/OFDictionary.h from [180610d08f] to [067b5149b1].

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
89
90
91
92
93
94
95

96
97
98
99
100
101
102
103
104
105







106
107
108
109
110
111
112







-
+









-
-
-
-
-
-
-







 * \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
 */
+ (instancetype)dictionaryWithObjects: (id const*)objects
			      forKeys: (id const*)keys
		  count: (size_t)count;
				count: (size_t)count;

/**
 * \brief Creates a new OFDictionary with the specified keys objects.
 *
 * \param firstKey The first key
 * \return A new autoreleased OFDictionary
 */
+ (instancetype)dictionaryWithKeysAndObjects: (id)firstKey, ... OF_SENTINEL;

/**
 * \brief Initializes an already allocated OFDictionary.
 *
 * \return An initialized OFDictionary
 */
- init;

/**
 * \brief Initializes an already allocated OFDictionary with the specified
 *	  OFDictionary.
 *
 * \param dictionary An OFDictionary
 * \return An initialized OFDictionary
 */

Modified src/OFMutableArray.m from [93a257326c] to [880c8c3997].

298
299
300
301
302
303
304
305
306




307
308
309
310
311
312
313
298
299
300
301
302
303
304


305
306
307
308
309
310
311
312
313
314
315







-
-
+
+
+
+







		[self removeObjectAtIndex: range.location];
}

- (void)removeLastObject
{
	size_t count = [self count];

	if (count > 0)
		[self removeObjectAtIndex: count - 1];
	if (count == 0)
		return;

	[self removeObjectAtIndex: count - 1];
}

- (void)removeAllObjects
{
	[self removeObjectsInRange: of_range(0, [self count])];
}

Modified src/OFMutableArray_adjacent.m from [83612a9b9c] to [d741de4264].

193
194
195
196
197
198
199






200

201
202
203
204
205
206
207
193
194
195
196
197
198
199
200
201
202
203
204
205

206
207
208
209
210
211
212
213







+
+
+
+
+
+
-
+







	} @finally {
		[self freeMemory: copy];
	}
}

- (void)removeLastObject
{
	size_t count = [array count];
	id object;

	if (count == 0)
		return;

	id object = [self objectAtIndex: [array count] - 1];
	object = [self objectAtIndex: count - 1];
	[array removeLastItem];
	[object release];

	mutations++;
}

- (void)exchangeObjectAtIndex: (size_t)index1

Modified src/OFObject.h from [de75aa3e70] to [cf116e78a7].

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
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







+

+

















+

+







+

+








+

+







	OF_ORDERED_DESCENDING = 1
} of_comparison_result_t;

/**
 * \brief An enum for storing endianess.
 */
typedef enum of_byte_order_t {
	/// Most significant byte first (big endian)
	OF_BYTE_ORDER_BIG_ENDIAN,
	/// Least significant byte first (little endian)
	OF_BYTE_ORDER_LITTLE_ENDIAN
} of_byte_order_t;

/**
 * \brief A range.
 */
typedef struct of_range_t {
	/// The start of the range
	size_t location;
	/// The length of the range
	size_t length;
} of_range_t;

/**
 * \brief A point.
 */
typedef struct of_point_t {
	/// The x coordinate of the point
	float x;
	/// The y coordinate of the point
	float y;
} of_point_t;

/**
 * \brief A dimension.
 */
typedef struct of_dimension_t {
	/// The width of the dimension
	float width;
	/// The height of the dimension
	float height;
} of_dimension_t;

/**
 * \brief A rectangle.
 */
typedef struct of_rectangle_t
{
	/// The point from where the rectangle originates
	of_point_t origin;
	/// The size of the rectangle
	of_dimension_t size;
} of_rectangle_t;

@class OFString;
@class OFThread;

/**
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
333
334
335
336
337
338
339

340
341
342
343
344
345
346







-








/**
 * \brief The root class for all other classes inside ObjFW.
 */
@interface OFObject <OFObject>
{
@public
	/// The class of the object
	Class isa;
}

/**
 * \brief A method which is called once when the class is loaded into the
 *	  runtime.
 *
361
362
363
364
365
366
367
368

369
370
371
372
373
374
375
368
369
370
371
372
373
374

375
376
377
378
379
380
381
382







-
+







 * OFAllocFailedException.
 *
 * \return The allocated object
 */
+ alloc;

/**
 * \brief Allocates memory for a new instance and calls -[init] on it.
 * \brief Allocates memory for a new instance and calls \ref init on it.
 * \return An allocated and initialized object
 */
+ new;

/**
 * \brief Returns the class.
 *
510
511
512
513
514
515
516
517

518
519
520
521
522
523
524
517
518
519
520
521
522
523

524
525
526
527
528
529
530
531







-
+







 *
 * If the specified class is a superclass of the receiving class, nothing is
 * done.
 *
 * The methods which will be added from the specified class are not allowed to
 * use super or access instance variables, instead they have to use accessors.
 *
 * \param class The class from which the instance methods should be inherited
 * \param class_ The class from which the instance methods should be inherited
 */
+ (void)inheritMethodsFromClass: (Class)class_;

/**
 * \brief Try to resolve the specified class method.
 *
 * This method is called if a class method was not found, so that an
537
538
539
540
541
542
543
544
545
546







547
548
549
550
551
552
553
544
545
546
547
548
549
550



551
552
553
554
555
556
557
558
559
560
561
562
563
564







-
-
-
+
+
+
+
+
+
+







 * \return Whether the method has been added to the class
 */
+ (BOOL)resolveInstanceMethod: (SEL)selector;

/**
 * \brief Initializes an already allocated object.
 *
 * Derived classes may override this, but need to do self = [super init] before
 * they do any initialization themselves. init may never return nil, instead
 * an exception (for example OFInitializationFailed) should be thrown.
 * Derived classes may override this, but need to do
 * \code
 *   self = [super init]
 * \endcode
 * before they do any initialization themselves. \ref init may never return nil,
 * instead an exception (for example OFInitializationFailedException) should be
 * thrown.
 *
 * \return An initialized object
 */
- init;

/**
 * \brief Returns the name of the object's class.

Modified src/OFSeekableStream.h from [38bd04ae73] to [44bcd8de89].

24
25
26
27
28
29
30
31
32
33
34
35
36
37







38
39
40
41
42
43
44
24
25
26
27
28
29
30







31
32
33
34
35
36
37
38
39
40
41
42
43
44







-
-
-
-
-
-
-
+
+
+
+
+
+
+







#include <sys/types.h>

#import "OFStream.h"

/**
 * \brief A stream that supports seeking.
 *
 * \note If you want to subclass this, override lowlevelSeekToOffset:,
 *	 lowlevelSeekForwardWithOffset: and lowlevelSeekToOffsetRelativeToEnd:,
 *	 but nothing else. Those are not defined in the headers, but do the
 *	 actual work. OFSeekableStream uses those and makes them work together
 *	 with the caching of OFStream. If you override these methods without
 *	 the lowlevel prefix, you <i>will</i> break caching, get broken results
 *	 and seek to the wrong position!
 * \note If you want to subclass this, override \ref lowlevelSeekToOffset:,
 *	 \ref lowlevelSeekForwardWithOffset: and
 *	 \ref lowlevelSeekToOffsetRelativeToEnd:, but nothing else, as they do
 *	 the actual work. OFSeekableStream uses those and makes them work
 *	 together with the caching of OFStream. If you override these methods
 *	 without the lowlevel prefix, you <i>will</i> break caching, get broken
 *	 results and seek to the wrong position!
 */
@interface OFSeekableStream: OFStream
/**
 * \brief Seeks to the specified absolute offset.
 *
 * \param offset The offset in bytes
 */

Modified src/OFStream.h from [6c1eafc699] to [47ab0fd36d].

43
44
45
46
47
48
49
50
51
52
53
54
55







56
57
58
59
60
61
62
43
44
45
46
47
48
49






50
51
52
53
54
55
56
57
58
59
60
61
62
63







-
-
-
-
-
-
+
+
+
+
+
+
+







 * \warning Even though the OFCopying protocol is implemented, it does
 *	    <i>not</i> return an independent copy of the stream, but instead
 *	    retains it. This is so that the stream can be used as a key for a
 *	    dictionary, so context can be associated with a stream. Using a
 *	    stream in more than one thread at the same time is not thread-safe,
 *	    even if copy was called to create one "instance" for every thread!
 *
 * \note If you want to subclass this, override lowlevelReadIntoBuffer:length:,
 *	 lowlevelWriteBuffer:length: and lowlevelIsAtEndOfStream, but nothing
 *	 else, as those are are the methods that do the actual work. OFStream
 *	 uses those for all other methods and does all the caching and other
 *	 stuff for you. If you override these methods without the lowlevel
 *	 prefix, you <i>will</i> break caching and get broken results!
 * \note If you want to subclass this, override
 *	 \ref lowlevelReadIntoBuffer:length:, \ref lowlevelWriteBuffer:length:
 *	 and \ref lowlevelIsAtEndOfStream, but nothing else, as those are are
 *	 the methods that do the actual work. OFStream uses those for all other
 *	 methods and does all the caching and other stuff for you. If you
 *	 override these methods without the lowlevel prefix, you <i>will</i>
 *	 break caching and get broken results!
 */
@interface OFStream: OFObject <OFCopying>
{
	char   *cache;
	char   *writeBuffer;
	size_t cacheLength, writeBufferLength;
	BOOL   writeBufferEnabled;
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
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







-
+

-
+







-
+





-
-
-
+
+
+

















-
-
-
+
+
+







- (BOOL)isAtEndOfStream;

/**
 * \brief Reads <i>at most</i> size bytes from the stream into a buffer.
 *
 * On network streams, this might read less than the specified number of bytes.
 * If you want to read exactly the specified number of bytes, use
 * -readIntoBuffer:exactLength:. Note that a read can even return 0 bytes -
 * \ref readIntoBuffer:exactLength:. Note that a read can even return 0 bytes -
 * this does not necessarily mean that the stream ended, so you still need to
 * check isAtEndOfStream.
 * check \ref isAtEndOfStream.
 *
 * \param buffer The buffer into which the data is read
 * \param length The length of the data that should be read at most.
 *		 The buffer <i>must</i> be at least this big!
 * \return The number of bytes read
 */
- (size_t)readIntoBuffer: (void*)buffer
		  length: (size_t)size;
		  length: (size_t)length;

/**
 * \brief Reads exactly the specified length bytes from the stream into a
 *	  buffer.
 *
 * Unlike readIntoBuffer:length:, this method does not return when less than the
 * specified length has been read - instead, it waits until it got exactly the
 * specified length.
 * Unlike \ref readIntoBuffer:length:, this method does not return when less
 * than the specified length has been read - instead, it waits until it got
 * exactly the specified length.
 *
 * \warning Only call this when you know that specified amount of data is
 *	    available! Otherwise you will get an exception!
 *
 * \param buffer The buffer into which the data is read
 * \param length The length of the data that should be read.
 *		 The buffer <i>must</i> be <i>exactly</i> this big!
 */
 - (void)readIntoBuffer: (void*)buffer
	    exactLength: (size_t)length;

/**
 * \brief Asyncronously reads <i>at most</i> size bytes from the stream into a
 *	  buffer.
 *
 * On network streams, this might read less than the specified number of bytes.
 * If you want to read exactly the specified number of bytes, use
 * asyncReadIntoBuffer:exactLength:block:. Note that a read can even return 0
 * bytes - this does not necessarily mean that the stream ended, so you still
 * need to check isAtEndOfStream.
 * \ref asyncReadIntoBuffer:exactLength:block:. Note that a read can even
 * return 0 bytes - this does not necessarily mean that the stream ended, so
 * you still need to check \ref isAtEndOfStream.
 *
 * \param buffer The buffer into which the data is read.
 *		 The buffer must not be free'd before the async read completed!
 * \param length The length of the data that should be read at most.
 *		 The buffer <i>must</i> be at least this big!
 * \param target The target on which the selector should be called when the
 *		 data has been received. If the method returns YES, it will be
140
141
142
143
144
145
146
147

148
149
150
151
152
153
154
141
142
143
144
145
146
147

148
149
150
151
152
153
154
155







-
+







		     target: (id)target
		   selector: (SEL)selector;

/**
 * \brief Asyncronously reads exactly the specified length bytes from the
 *	  stream into a buffer.
 *
 * Unlike asyncReadIntoBuffer:length:block, this method does not call the
 * Unlike \ref asyncReadIntoBuffer:length:block, this method does not call the
 * method when less than the specified length has been read - instead, it waits
 * until it got exactly the specified length, the stream has ended or an
 * exception occurred.
 *
 * \param buffer The buffer into which the data is read
 * \param length The length of the data that should be read.
 *		 The buffer <i>must</i> be <i>exactly</i> this big!
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
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







-
-
-
+
+
+



















-
+







#ifdef OF_HAVE_BLOCKS
/**
 * \brief Asyncronously reads <i>at most</i> size bytes from the stream into a
 *	  buffer.
 *
 * On network streams, this might read less than the specified number of bytes.
 * If you want to read exactly the specified number of bytes, use
 * asyncReadIntoBuffer:exactLength:block:. Note that a read can even return 0
 * bytes - this does not necessarily mean that the stream ended, so you still
 * need to check isAtEndOfStream.
 * \ref asyncReadIntoBuffer:exactLength:block:. Note that a read can even
 * return 0 bytes - this does not necessarily mean that the stream ended, so
 * you still need to check \ref isAtEndOfStream.
 *
 * \param buffer The buffer into which the data is read.
 *		 The buffer must not be free'd before the async read completed!
 * \param length The length of the data that should be read at most.
 *		 The buffer <i>must</i> be at least this big!
 * \param block The block to call when the data has been received.
 *		If the block returns YES, it will be called again with the same
 *		buffer and maximum length when more data has been received. If
 *		you want the next block in the queue to handle the data
 *		received next, you need to return NO from the block.
 */
- (void)asyncReadIntoBuffer: (void*)buffer
		     length: (size_t)length
		      block: (of_stream_async_read_block_t)block;

/**
 * \brief Asyncronously reads exactly the specified length bytes from the
 *	  stream into a buffer.
 *
 * Unlike asyncReadIntoBuffer:length:block, this method does not invoke the
 * Unlike \ref asyncReadIntoBuffer:length:block, this method does not invoke the
 * block when less than the specified length has been read - instead, it waits
 * until it got exactly the specified length, the stream has ended or an
 * exception occurred.
 *
 * \param buffer The buffer into which the data is read
 * \param length The length of the data that should be read.
 *		 The buffer <i>must</i> be <i>exactly</i> this big!
278
279
280
281
282
283
284
285
286
287

288
289
290
291

292
293
294
295
296
297
298
299
300
301
302

303
304
305
306

307
308
309
310
311
312
313
314
315
316
317

318
319
320
321

322
323
324
325
326
327
328
329
330
331
332

333
334
335
336

337
338
339
340
341
342
343
344
345
346
347

348
349
350
351

352
353
354
355
356
357
358
279
280
281
282
283
284
285

286
287
288
289
290
291

292
293
294
295
296
297
298
299
300

301
302
303
304
305
306

307
308
309
310
311
312
313
314
315

316
317
318
319
320
321

322
323
324
325
326
327
328
329
330

331
332
333
334
335
336

337
338
339
340
341
342
343
344
345

346
347
348
349
350
351

352
353
354
355
356
357
358
359







-


+



-
+








-


+



-
+








-


+



-
+








-


+



-
+








-


+



-
+







/**
 * \brief Reads the specified number of uint16_ts from the stream which are
 *	  encoded in big endian.
 *
 * \warning Only call this when you know that enough data is available!
 *	    Otherwise you will get an exception!
 *
 * \param nInt16s The number of uint16_ts to read
 * \param buffer A buffer of sufficient size to store the specified number of
 *		 uint16_ts
 * \param count The number of uint16_ts to read
 * \return The number of bytes read
 */
- (size_t)readBigEndianInt16sIntoBuffer: (uint16_t*)buffer
				  count: (size_t)nInt16s;
				  count: (size_t)count;

/**
 * \brief Reads the specified number of uint32_ts from the stream which are
 *	  encoded in big endian.
 *
 * \warning Only call this when you know that enough data is available!
 *	    Otherwise you will get an exception!
 *
 * \param nInt32s The number of uint32_ts to read
 * \param buffer A buffer of sufficient size to store the specified number of
 *		 uint32_ts
 * \param count The number of uint32_ts to read
 * \return The number of bytes read
 */
- (size_t)readBigEndianInt32sIntoBuffer: (uint32_t*)buffer
				  count: (size_t)nInt32s;
				  count: (size_t)count;

/**
 * \brief Reads the specified number of uint64_ts from the stream which are
 *	  encoded in big endian.
 *
 * \warning Only call this when you know that enough data is available!
 *	    Otherwise you will get an exception!
 *
 * \param nInt64s The number of uint64_ts to read
 * \param buffer A buffer of sufficient size to store the specified number of
 *		 uint64_ts
 * \param count The number of uint64_ts to read
 * \return The number of bytes read
 */
- (size_t)readBigEndianInt64sIntoBuffer: (uint64_t*)buffer
				  count: (size_t)nInt64s;
				  count: (size_t)count;

/**
 * \brief Reads the specified number of floats from the stream which are encoded
 *	  in big endian.
 *
 * \warning Only call this when you know that enough data is available!
 *	    Otherwise you will get an exception!
 *
 * \param nFloatss The number of floats to read
 * \param buffer A buffer of sufficient size to store the specified number of
 *		 floats
 * \param count The number of floats to read
 * \return The number of bytes read
 */
- (size_t)readBigEndianFloatsIntoBuffer: (float*)buffer
				  count: (size_t)nFloats;
				  count: (size_t)count;

/**
 * \brief Reads the specified number of doubles from the stream which are
 *	  encoded in big endian.
 *
 * \warning Only call this when you know that enough data is available!
 *	    Otherwise you will get an exception!
 *
 * \param nDoubles The number of doubles to read
 * \param buffer A buffer of sufficient size to store the specified number of
 *		 doubles
 * \param count The number of doubles to read
 * \return The number of bytes read
 */
- (size_t)readBigEndianDoublesIntoBuffer: (double*)buffer
				   count: (size_t)nDoubles;
				   count: (size_t)count;

/**
 * \brief Reads a uint16_t from the stream which is encoded in little endian.
 *
 * \warning Only call this when you know that enough data is available!
 *	    Otherwise you will get an exception!
 *
403
404
405
406
407
408
409
410
411
412

413
414
415
416

417
418
419
420
421
422
423
424
425
426
427

428
429
430
431

432
433
434
435
436
437
438
439
440
441
442

443
444
445
446

447
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
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
404
405
406
407
408
409
410

411
412
413
414
415
416

417
418
419
420
421
422
423
424
425

426
427
428
429
430
431

432
433
434
435
436
437
438
439
440

441
442
443
444
445
446

447
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
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







-


+



-
+








-


+



-
+








-


+



-
+








-


+



-
+








-


+



-
+








-
-
+
+











-
-
+
+


-
+







/**
 * \brief Reads the specified number of uint16_ts from the stream which are
 *	  encoded in little endian.
 *
 * \warning Only call this when you know that enough data is available!
 *	    Otherwise you will get an exception!
 *
 * \param nInt16s The number of uint16_ts to read
 * \param buffer A buffer of sufficient size to store the specified number of
 *		 uint16_ts
 * \param count The number of uint16_ts to read
 * \return The number of bytes read
 */
- (size_t)readLittleEndianInt16sIntoBuffer: (uint16_t*)buffer
				     count: (size_t)nInt16s;
				     count: (size_t)count;

/**
 * \brief Reads the specified number of uint32_ts from the stream which are
 *	  encoded in little endian.
 *
 * \warning Only call this when you know that enough data is available!
 *	    Otherwise you will get an exception!
 *
 * \param nInt32s The number of uint32_ts to read
 * \param buffer A buffer of sufficient size to store the specified number of
 *		 uint32_ts
 * \param count The number of uint32_ts to read
 * \return The number of bytes read
 */
- (size_t)readLittleEndianInt32sIntoBuffer: (uint32_t*)buffer
				     count: (size_t)nInt32s;
				     count: (size_t)count;

/**
 * \brief Reads the specified number of uint64_ts from the stream which are
 *	  encoded in little endian.
 *
 * \warning Only call this when you know that enough data is available!
 *	    Otherwise you will get an exception!
 *
 * \param nInt64s The number of uint64_ts to read
 * \param buffer A buffer of sufficient size to store the specified number of
 *		 uint64_ts
 * \param count The number of uint64_ts to read
 * \return The number of bytes read
 */
- (size_t)readLittleEndianInt64sIntoBuffer: (uint64_t*)buffer
				     count: (size_t)nInt64s;
				     count: (size_t)count;

/**
 * \brief Reads the specified number of floats from the stream which are
 *	  encoded in little endian.
 *
 * \warning Only call this when you know that enough data is available!
 *	    Otherwise you will get an exception!
 *
 * \param nFloats The number of floats to read
 * \param buffer A buffer of sufficient size to store the specified number of
 *		 floats
 * \param count The number of floats to read
 * \return The number of bytes read
 */
- (size_t)readLittleEndianFloatsIntoBuffer: (float*)buffer
				     count: (size_t)nFloats;
				     count: (size_t)count;

/**
 * \brief Reads the specified number of doubles from the stream which are
 *	  encoded in little endian.
 *
 * \warning Only call this when you know that enough data is available!
 *	    Otherwise you will get an exception!
 *
 * \param nDoubles The number of doubles to read
 * \param buffer A buffer of sufficient size to store the specified number of
 *		 doubles
 * \param count The number of doubles to read
 * \return The number of bytes read
 */
- (size_t)readLittleEndianDoublesIntoBuffer: (double*)buffer
				      count: (size_t)nDoubles;
				      count: (size_t)count;

/**
 * \brief Reads the specified number of items with an item size of 1 from the
 *	  stream and returns them in an OFDataArray.
 *
 * \warning Only call this when you know that enough data is available!
 *	    Otherwise you will get an exception!
 *
 * \param nItems The number of items to read
 * \return An OFDataArray with at nItems items.
 * \param size The number of items to read
 * \return An OFDataArray with count items.
 */
- (OFDataArray*)readDataArrayWithSize: (size_t)size;

/**
 * \brief Reads the specified number of items with the specified item size from
 *	  the stream and returns them in an OFDataArray.
 *
 * \warning Only call this when you know that enough data is available!
 *	    Otherwise you will get an exception!
 *
 * \param itemSize The size of each item
 * \param nItems The number of items to read
 * \return An OFDataArray with at nItems items.
 * \param count The number of items to read
 * \return An OFDataArray with count items.
 */
- (OFDataArray*)readDataArrayWithItemSize: (size_t)itemSize
				    count: (size_t)nItems;
				    count: (size_t)count;

/**
 * \brief Returns an OFDataArray with all the remaining data of the stream.
 *
 * \return An OFDataArray with an item size of 1 with all the data of the
 *	   stream until the end of the stream is reached.
 */
628
629
630
631
632
633
634
635
636


637
638
639
640
641
642
643
629
630
631
632
633
634
635


636
637
638
639
640
641
642
643
644







-
-
+
+







 * \return The line that was read, autoreleased, or nil if the line is not
 *	   complete yet
 */
- (OFString*)tryReadLine;

/**
 * \brief Tries to read a line from the stream with the specified encoding (see
 *	  readLineWithEncoding:) and returns nil if no complete line has been
 *	  received yet.
 *	  \ref readLineWithEncoding:) and returns nil if no complete line has
 *	  been received yet.
 *
 * \param encoding The encoding used by the stream
 * \return The line that was read, autoreleased, or nil if the line is not
 *	   complete yet
 */
- (OFString*)tryReadLineWithEncoding: (of_string_encoding_t)encoding;

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
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







-
-
+
+









-
-
+
+







 *	   stream has been reached.
 */
- (OFString*)readTillDelimiter: (OFString*)delimiter
		      encoding: (of_string_encoding_t)encoding;

/**
 * \brief Tries to reads until the specified string or \\0 is found or the end
 *	  of stream (see readTillDelimiter:) and returns nil if not enough data
 *	  has been received yet.
 *	  of stream (see \ref readTillDelimiter:) and returns nil if not enough
 *	  data has been received yet.
 *
 * \param delimiter The delimiter
 * \return The line that was read, autoreleased, or nil if the end of the
 *	   stream has been reached.
 */
- (OFString*)tryReadTillDelimiter: (OFString*)delimiter;

/**
 * \brief Tries to read until the specified string or \\0 is found or the end
 *	  of stream occurs (see readTIllDelimiterWithEncoding:) and returns nil
 *	  if not enough data has been received yet.
 *	  of stream occurs (see \ref readTillDelimiterWithEncoding:) and
 *	  returns nil if not enough data has been received yet.
 *
 * \param delimiter The delimiter
 * \param encoding The encoding used by the stream
 * \return The line that was read, autoreleased, or nil if the end of the
 *	   stream has been reached.
 */
- (OFString*)tryReadTillDelimiter: (OFString*)delimiter
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
788
789
790

791
792
793
794

795
796
797
798
799
800
801
802

803
804
805
806

807
808
809
810
811
812
813
814

815
816
817
818

819
820
821
822
823
824
825
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
788

789
790
791
792
793
794

795
796
797
798
799
800

801
802
803
804
805
806

807
808
809
810
811
812

813
814
815
816
817
818

819
820
821
822
823
824
825
826







-


+



-
+





-


+



-
+





-


+



-
+





-


+



-
+





-


+



-
+







 */
- (void)writeBigEndianDouble: (double)double_;

/**
 * \brief Writes the specified number of uint16_ts into the stream, encoded in
 *	  big endian.
 *
 * \param nInt16 The number of uint16_ts to write
 * \param buffer The buffer from which the data is written to the stream after
 *		 it has been byte swapped if necessary
 * \param count The number of uint16_ts to write
 * \return The number of bytes written to the stream
 */
- (size_t)writeBigEndianInt16s: (const uint16_t*)buffer
			 count: (size_t)nInt16s;
			 count: (size_t)count;

/**
 * \brief Writes the specified number of uint32_ts into the stream, encoded in
 *	  big endian.
 *
 * \param nInt32 The number of uint32_ts to write
 * \param buffer The buffer from which the data is written to the stream after
 *		 it has been byte swapped if necessary
 * \param count The number of uint32_ts to write
 * \return The number of bytes written to the stream
 */
- (size_t)writeBigEndianInt32s: (const uint32_t*)buffer
			 count: (size_t)nInt32s;
			 count: (size_t)count;

/**
 * \brief Writes the specified number of uint64_ts into the stream, encoded in
 *	  big endian.
 *
 * \param nInt64 The number of uint64_ts to write
 * \param buffer The buffer from which the data is written to the stream after
 *		 it has been byte swapped if necessary
 * \param count The number of uint64_ts to write
 * \return The number of bytes written to the stream
 */
- (size_t)writeBigEndianInt64s: (const uint64_t*)buffer
			 count: (size_t)nInt64s;
			 count: (size_t)count;

/**
 * \brief Writes the specified number of floats into the stream, encoded in big
 *	  endian.
 *
 * \param nFloats The number of floats to write
 * \param buffer The buffer from which the data is written to the stream after
 *		 it has been byte swapped if necessary
 * \param count The number of floats to write
 * \return The number of bytes written to the stream
 */
- (size_t)writeBigEndianFloats: (const float*)buffer
			 count: (size_t)nFloats;
			 count: (size_t)count;

/**
 * \brief Writes the specified number of doubles into the stream, encoded in
 *	  big endian.
 *
 * \param nDoubles The number of doubles to write
 * \param buffer The buffer from which the data is written to the stream after
 *		 it has been byte swapped if necessary
 * \param count The number of doubles to write
 * \return The number of bytes written to the stream
 */
- (size_t)writeBigEndianDoubles: (const double*)buffer
			  count: (size_t)nDoubles;
			  count: (size_t)count;

/**
 * \brief Writes a uint16_t into the stream, encoded in little endian.
 *
 * \param int16 A uint16_t
 */
- (void)writeLittleEndianInt16: (uint16_t)int16;
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
885

886
887
888
889

890
891
892
893
894
895
896
897

898
899
900
901

902
903
904
905
906
907
908
909

910
911
912
913

914
915
916
917
918
919
920
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
885
886
887
888
889

890
891
892
893
894
895

896
897
898
899
900
901

902
903
904
905
906
907

908
909
910
911
912
913

914
915
916
917
918
919
920
921







-


+



-
+





-
+





-
+





-


+



-
+





-


+



-
+





-


+



-
+







 */
- (void)writeLittleEndianDouble: (double)double_;

/**
 * \brief Writes the specified number of uint16_ts into the stream, encoded in
 *	  little endian.
 *
 * \param nInt16 The number of uint16_ts to write
 * \param buffer The buffer from which the data is written to the stream after
 *		 it has been byte swapped if necessary
 * \param count The number of uint16_ts to write
 * \return The number of bytes written to the stream
 */
- (size_t)writeLittleEndianInt16s: (const uint16_t*)buffer
			    count: (size_t)nInt16s;
			    count: (size_t)count;

/**
 * \brief Writes the specified number of uint32_ts into the stream, encoded in
 *	  little endian.
 *
 * \param nInt32 The number of uint32_ts to write
 * \param count The number of uint32_ts to write
 * \param buffer The buffer from which the data is written to the stream after
 *		 it has been byte swapped if necessary
 * \return The number of bytes written to the stream
 */
- (size_t)writeLittleEndianInt32s: (const uint32_t*)buffer
			    count: (size_t)nInt32s;
			    count: (size_t)count;

/**
 * \brief Writes the specified number of uint64_ts into the stream, encoded in
 *	  little endian.
 *
 * \param nInt64 The number of uint64_ts to write
 * \param buffer The buffer from which the data is written to the stream after
 *		 it has been byte swapped if necessary
 * \param count The number of uint64_ts to write
 * \return The number of bytes written to the stream
 */
- (size_t)writeLittleEndianInt64s: (const uint64_t*)buffer
			    count: (size_t)nInt64s;
			    count: (size_t)count;

/**
 * \brief Writes the specified number of floats into the stream, encoded in
 *	  little endian.
 *
 * \param nFloats The number of floats to write
 * \param buffer The buffer from which the data is written to the stream after
 *		 it has been byte swapped if necessary
 * \param count The number of floats to write
 * \return The number of bytes written to the stream
 */
- (size_t)writeLittleEndianFloats: (const float*)buffer
			    count: (size_t)nFloats;
			    count: (size_t)count;

/**
 * \brief Writes the specified number of doubles into the stream, encoded in
 *	  little endian.
 *
 * \param nDoubles The number of doubles to write
 * \param buffer The buffer from which the data is written to the stream after
 *		 it has been byte swapped if necessary
 * \param count The number of doubles to write
 * \return The number of bytes written to the stream
 */
- (size_t)writeLittleEndianDoubles: (const double*)buffer
			     count: (size_t)nDoubles;
			     count: (size_t)count;

/**
 * \brief Writes from an OFDataArray into the stream.
 *
 * \param dataArray The OFDataArray to write into the stream
 * \return The number of bytes written
 */

Modified src/OFStream.m from [1ba71f5d61] to [cea01024de].

247
248
249
250
251
252
253
254

255
256

257
258
259
260
261
262
263
264

265
266
267
268
269
270
271
272

273
274

275
276
277
278
279
280
281
282

283
284
285
286
287
288
289
290

291
292

293
294
295
296
297
298
299
300

301
302
303
304
305
306
307
308

309
310

311
312
313
314
315
316
317
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
247
248
249
250
251
252
253

254
255

256
257
258
259
260
261
262
263

264
265
266
267
268
269
270
271

272
273

274
275
276
277
278
279
280
281

282
283
284
285
286
287
288
289

290
291

292
293
294
295
296
297
298
299

300
301
302
303
304
305
306
307

308
309

310
311
312
313
314
315
316
317

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







-
+

-
+







-
+







-
+

-
+







-
+







-
+

-
+







-
+







-
+

-
+







-
+







-
+

-
+







-
+







	[self readIntoBuffer: (char*)&ret
		 exactLength: 8];

	return OF_BSWAP_DOUBLE_IF_LE(ret);
}

- (size_t)readBigEndianInt16sIntoBuffer: (uint16_t*)buffer
				  count: (size_t)nInt16s
				  count: (size_t)count
{
	size_t size = nInt16s * sizeof(uint16_t);
	size_t size = count * sizeof(uint16_t);

	[self readIntoBuffer: buffer
		 exactLength: size];

#ifndef OF_BIG_ENDIAN
	size_t i;

	for (i = 0; i < nInt16s; i++)
	for (i = 0; i < count; i++)
		buffer[i] = OF_BSWAP16(buffer[i]);
#endif

	return size;
}

- (size_t)readBigEndianInt32sIntoBuffer: (uint32_t*)buffer
				  count: (size_t)nInt32s
				  count: (size_t)count
{
	size_t size = nInt32s * sizeof(uint32_t);
	size_t size = count * sizeof(uint32_t);

	[self readIntoBuffer: buffer
		 exactLength: size];

#ifndef OF_BIG_ENDIAN
	size_t i;

	for (i = 0; i < nInt32s; i++)
	for (i = 0; i < count; i++)
		buffer[i] = OF_BSWAP32(buffer[i]);
#endif

	return size;
}

- (size_t)readBigEndianInt64sIntoBuffer: (uint64_t*)buffer
				  count: (size_t)nInt64s
				  count: (size_t)count
{
	size_t size = nInt64s * sizeof(uint64_t);
	size_t size = count * sizeof(uint64_t);

	[self readIntoBuffer: buffer
		 exactLength: size];

#ifndef OF_BIG_ENDIAN
	size_t i;

	for (i = 0; i < nInt64s; i++)
	for (i = 0; i < count; i++)
		buffer[i] = OF_BSWAP64(buffer[i]);
#endif

	return size;
}

- (size_t)readBigEndianFloatsIntoBuffer: (float*)buffer
				  count: (size_t)nFloats
				  count: (size_t)count
{
	size_t size = nFloats * sizeof(float);
	size_t size = count * sizeof(float);

	[self readIntoBuffer: buffer
		 exactLength: size];

#ifndef OF_FLOAT_BIG_ENDIAN
	size_t i;

	for (i = 0; i < nFloats; i++)
	for (i = 0; i < count; i++)
		buffer[i] = OF_BSWAP_FLOAT(buffer[i]);
#endif

	return size;
}

- (size_t)readBigEndianDoublesIntoBuffer: (double*)buffer
				   count: (size_t)nDoubles
				   count: (size_t)count
{
	size_t size = nDoubles * sizeof(double);
	size_t size = count * sizeof(double);

	[self readIntoBuffer: buffer
		 exactLength: size];

#ifndef OF_FLOAT_BIG_ENDIAN
	size_t i;

	for (i = 0; i < nDoubles; i++)
	for (i = 0; i < count; i++)
		buffer[i] = OF_BSWAP_DOUBLE(buffer[i]);
#endif

	return size;
}

- (uint16_t)readLittleEndianInt16
387
388
389
390
391
392
393
394

395
396

397
398
399
400
401
402
403
404

405
406
407
408
409
410
411
412

413
414

415
416
417
418
419
420
421
422

423
424
425
426
427
428
429
430

431
432

433
434
435
436
437
438
439
440

441
442
443
444
445
446
447
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
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
387
388
389
390
391
392
393

394
395

396
397
398
399
400
401
402
403

404
405
406
407
408
409
410
411

412
413

414
415
416
417
418
419
420
421

422
423
424
425
426
427
428
429

430
431

432
433
434
435
436
437
438
439

440
441
442
443
444
445
446
447

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

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







-
+

-
+







-
+







-
+

-
+







-
+







-
+

-
+







-
+







-
+

-
+







-
+







-
+

-
+







-
+






-
+


-
+



-
+






-
+



-
+


-
+







	[self readIntoBuffer: (char*)&ret
		 exactLength: 8];

	return OF_BSWAP_DOUBLE_IF_BE(ret);
}

- (size_t)readLittleEndianInt16sIntoBuffer: (uint16_t*)buffer
				     count: (size_t)nInt16s
				     count: (size_t)count
{
	size_t size = nInt16s * sizeof(uint16_t);
	size_t size = count * sizeof(uint16_t);

	[self readIntoBuffer: buffer
		 exactLength: size];

#ifdef OF_BIG_ENDIAN
	size_t i;

	for (i = 0; i < nInt16s; i++)
	for (i = 0; i < count; i++)
		buffer[i] = OF_BSWAP16(buffer[i]);
#endif

	return size;
}

- (size_t)readLittleEndianInt32sIntoBuffer: (uint32_t*)buffer
				     count: (size_t)nInt32s
				     count: (size_t)count
{
	size_t size = nInt32s * sizeof(uint32_t);
	size_t size = count * sizeof(uint32_t);

	[self readIntoBuffer: buffer
		 exactLength: size];

#ifdef OF_BIG_ENDIAN
	size_t i;

	for (i = 0; i < nInt32s; i++)
	for (i = 0; i < count; i++)
		buffer[i] = OF_BSWAP32(buffer[i]);
#endif

	return size;
}

- (size_t)readLittleEndianInt64sIntoBuffer: (uint64_t*)buffer
				     count: (size_t)nInt64s
				     count: (size_t)count
{
	size_t size = nInt64s * sizeof(uint64_t);
	size_t size = count * sizeof(uint64_t);

	[self readIntoBuffer: buffer
		 exactLength: size];

#ifdef OF_BIG_ENDIAN
	size_t i;

	for (i = 0; i < nInt64s; i++)
	for (i = 0; i < count; i++)
		buffer[i] = OF_BSWAP64(buffer[i]);
#endif

	return size;
}

- (size_t)readLittleEndianFloatsIntoBuffer: (float*)buffer
				     count: (size_t)nFloats
				     count: (size_t)count
{
	size_t size = nFloats * sizeof(float);
	size_t size = count * sizeof(float);

	[self readIntoBuffer: buffer
		 exactLength: size];

#ifdef OF_FLOAT_BIG_ENDIAN
	size_t i;

	for (i = 0; i < nFloats; i++)
	for (i = 0; i < count; i++)
		buffer[i] = OF_BSWAP_FLOAT(buffer[i]);
#endif

	return size;
}

- (size_t)readLittleEndianDoublesIntoBuffer: (double*)buffer
				      count: (size_t)nDoubles
				      count: (size_t)count
{
	size_t size = nDoubles * sizeof(double);
	size_t size = count * sizeof(double);

	[self readIntoBuffer: buffer
		 exactLength: size];

#ifdef OF_FLOAT_BIG_ENDIAN
	size_t i;

	for (i = 0; i < nDoubles; i++)
	for (i = 0; i < count; i++)
		buffer[i] = OF_BSWAP_DOUBLE(buffer[i]);
#endif

	return size;
}

- (OFDataArray*)readDataArrayWithSize: (size_t)nItems
- (OFDataArray*)readDataArrayWithSize: (size_t)size
{
	return [self readDataArrayWithItemSize: 1
					 count: nItems];
					 count: size];
}

- (OFDataArray*)readDataArrayWithItemSize: (size_t)itemSize
				    count: (size_t)nItems
				    count: (size_t)count
{
	OFDataArray *dataArray;
	char *tmp;

	dataArray = [OFDataArray dataArrayWithItemSize: itemSize];
	tmp = [self allocMemoryWithSize: itemSize
				  count: nItems];
				  count: count];

	@try {
		[self readIntoBuffer: tmp
			 exactLength: nItems * itemSize];
			 exactLength: count * itemSize];

		[dataArray addItemsFromCArray: tmp
					count: nItems];
					count: count];
	} @finally {
		[self freeMemory: tmp];
	}

	return dataArray;
}

1010
1011
1012
1013
1014
1015
1016
1017

1018
1019

1020
1021
1022
1023
1024
1025
1026
1027
1028

1029
1030
1031
1032
1033

1034
1035
1036
1037
1038
1039
1040
1041
1042
1043
1044
1045
1046
1047

1048
1049

1050
1051
1052
1053
1054
1055
1056
1057
1058

1059
1060
1061
1062
1063

1064
1065
1066
1067
1068
1069
1070
1071
1072
1073
1074
1075
1076
1077

1078
1079

1080
1081
1082
1083
1084
1085
1086
1087
1088

1089
1090
1091
1092
1093

1094
1095
1096
1097
1098
1099
1100
1101
1102
1103
1104
1105
1106
1107

1108
1109

1110
1111
1112
1113
1114
1115
1116
1117
1118

1119
1120
1121
1122
1123

1124
1125
1126
1127
1128
1129
1130
1131
1132
1133
1134
1135
1136
1137

1138
1139

1140
1141
1142
1143
1144
1145
1146
1147
1148

1149
1150
1151
1152
1153

1154
1155
1156
1157
1158
1159
1160
1010
1011
1012
1013
1014
1015
1016

1017
1018

1019
1020
1021
1022
1023
1024
1025
1026
1027

1028
1029
1030
1031
1032

1033
1034
1035
1036
1037
1038
1039
1040
1041
1042
1043
1044
1045
1046

1047
1048

1049
1050
1051
1052
1053
1054
1055
1056
1057

1058
1059
1060
1061
1062

1063
1064
1065
1066
1067
1068
1069
1070
1071
1072
1073
1074
1075
1076

1077
1078

1079
1080
1081
1082
1083
1084
1085
1086
1087

1088
1089
1090
1091
1092

1093
1094
1095
1096
1097
1098
1099
1100
1101
1102
1103
1104
1105
1106

1107
1108

1109
1110
1111
1112
1113
1114
1115
1116
1117

1118
1119
1120
1121
1122

1123
1124
1125
1126
1127
1128
1129
1130
1131
1132
1133
1134
1135
1136

1137
1138

1139
1140
1141
1142
1143
1144
1145
1146
1147

1148
1149
1150
1151
1152

1153
1154
1155
1156
1157
1158
1159
1160







-
+

-
+








-
+




-
+













-
+

-
+








-
+




-
+













-
+

-
+








-
+




-
+













-
+

-
+








-
+




-
+













-
+

-
+








-
+




-
+







	double_ = OF_BSWAP_DOUBLE_IF_LE(double_);

	[self writeBuffer: (char*)&double_
		   length: 8];
}

- (size_t)writeBigEndianInt16s: (const uint16_t*)buffer
			 count: (size_t)nInt16s
			 count: (size_t)count
{
	size_t size = nInt16s * sizeof(uint16_t);
	size_t size = count * sizeof(uint16_t);

#ifdef OF_BIG_ENDIAN
	[self writeBuffer: buffer
		   length: size];
#else
	uint16_t *tmp;

	tmp = [self allocMemoryWithSize: sizeof(uint16_t)
				  count: nInt16s];
				  count: count];

	@try {
		size_t i;

		for (i = 0; i < nInt16s; i++)
		for (i = 0; i < count; i++)
			tmp[i] = OF_BSWAP16(buffer[i]);

		[self writeBuffer: tmp
			   length: size];
	} @finally {
		[self freeMemory: tmp];
	}
#endif

	return size;
}

- (size_t)writeBigEndianInt32s: (const uint32_t*)buffer
			 count: (size_t)nInt32s
			 count: (size_t)count
{
	size_t size = nInt32s * sizeof(uint32_t);
	size_t size = count * sizeof(uint32_t);

#ifdef OF_BIG_ENDIAN
	[self writeBuffer: buffer
		   length: size];
#else
	uint32_t *tmp;

	tmp = [self allocMemoryWithSize: sizeof(uint32_t)
				  count: nInt32s];
				  count: count];

	@try {
		size_t i;

		for (i = 0; i < nInt32s; i++)
		for (i = 0; i < count; i++)
			tmp[i] = OF_BSWAP32(buffer[i]);

		[self writeBuffer: tmp
			   length: size];
	} @finally {
		[self freeMemory: tmp];
	}
#endif

	return size;
}

- (size_t)writeBigEndianInt64s: (const uint64_t*)buffer
			 count: (size_t)nInt64s
			 count: (size_t)count
{
	size_t size = nInt64s * sizeof(uint64_t);
	size_t size = count * sizeof(uint64_t);

#ifdef OF_BIG_ENDIAN
	[self writeBuffer: buffer
		   length: size];
#else
	uint64_t *tmp;

	tmp = [self allocMemoryWithSize: sizeof(uint64_t)
				  count: nInt64s];
				  count: count];

	@try {
		size_t i;

		for (i = 0; i < nInt64s; i++)
		for (i = 0; i < count; i++)
			tmp[i] = OF_BSWAP64(buffer[i]);

		[self writeBuffer: tmp
			   length: size];
	} @finally {
		[self freeMemory: tmp];
	}
#endif

	return size;
}

- (size_t)writeBigEndianFloats: (const float*)buffer
			 count: (size_t)nFloats
			 count: (size_t)count
{
	size_t size = nFloats * sizeof(float);
	size_t size = count * sizeof(float);

#ifdef OF_FLOAT_BIG_ENDIAN
	[self writeBuffer: buffer
		   length: size];
#else
	float *tmp;

	tmp = [self allocMemoryWithSize: sizeof(float)
				  count: nFloats];
				  count: count];

	@try {
		size_t i;

		for (i = 0; i < nFloats; i++)
		for (i = 0; i < count; i++)
			tmp[i] = OF_BSWAP_FLOAT(buffer[i]);

		[self writeBuffer: tmp
			   length: size];
	} @finally {
		[self freeMemory: tmp];
	}
#endif

	return size;
}

- (size_t)writeBigEndianDoubles: (const double*)buffer
			  count: (size_t)nDoubles
			  count: (size_t)count
{
	size_t size = nDoubles * sizeof(double);
	size_t size = count * sizeof(double);

#ifdef OF_FLOAT_BIG_ENDIAN
	[self writeBuffer: buffer
		   length: size];
#else
	double *tmp;

	tmp = [self allocMemoryWithSize: sizeof(double)
				  count: nDoubles];
				  count: count];

	@try {
		size_t i;

		for (i = 0; i < nDoubles; i++)
		for (i = 0; i < count; i++)
			tmp[i] = OF_BSWAP_DOUBLE(buffer[i]);

		[self writeBuffer: tmp
			   length: size];
	} @finally {
		[self freeMemory: tmp];
	}
1200
1201
1202
1203
1204
1205
1206
1207

1208
1209

1210
1211
1212
1213
1214
1215
1216
1217
1218

1219
1220
1221
1222
1223

1224
1225
1226
1227
1228
1229
1230
1231
1232
1233
1234
1235
1236
1237

1238
1239

1240
1241
1242
1243
1244
1245
1246
1247
1248

1249
1250
1251
1252
1253

1254
1255
1256
1257
1258
1259
1260
1261
1262
1263
1264
1265
1266
1267

1268
1269

1270
1271
1272
1273
1274
1275
1276
1277
1278

1279
1280
1281
1282
1283

1284
1285
1286
1287
1288
1289
1290
1291
1292
1293
1294
1295
1296
1297

1298
1299

1300
1301
1302
1303
1304
1305
1306
1307
1308

1309
1310
1311
1312
1313

1314
1315
1316
1317
1318
1319
1320
1321
1322
1323
1324
1325
1326
1327

1328
1329

1330
1331
1332
1333
1334
1335
1336
1337
1338

1339
1340
1341
1342
1343

1344
1345
1346
1347
1348
1349
1350
1200
1201
1202
1203
1204
1205
1206

1207
1208

1209
1210
1211
1212
1213
1214
1215
1216
1217

1218
1219
1220
1221
1222

1223
1224
1225
1226
1227
1228
1229
1230
1231
1232
1233
1234
1235
1236

1237
1238

1239
1240
1241
1242
1243
1244
1245
1246
1247

1248
1249
1250
1251
1252

1253
1254
1255
1256
1257
1258
1259
1260
1261
1262
1263
1264
1265
1266

1267
1268

1269
1270
1271
1272
1273
1274
1275
1276
1277

1278
1279
1280
1281
1282

1283
1284
1285
1286
1287
1288
1289
1290
1291
1292
1293
1294
1295
1296

1297
1298

1299
1300
1301
1302
1303
1304
1305
1306
1307

1308
1309
1310
1311
1312

1313
1314
1315
1316
1317
1318
1319
1320
1321
1322
1323
1324
1325
1326

1327
1328

1329
1330
1331
1332
1333
1334
1335
1336
1337

1338
1339
1340
1341
1342

1343
1344
1345
1346
1347
1348
1349
1350







-
+

-
+








-
+




-
+













-
+

-
+








-
+




-
+













-
+

-
+








-
+




-
+













-
+

-
+








-
+




-
+













-
+

-
+








-
+




-
+







	double_ = OF_BSWAP_DOUBLE_IF_BE(double_);

	[self writeBuffer: (char*)&double_
		   length: 8];
}

- (size_t)writeLittleEndianInt16s: (const uint16_t*)buffer
			    count: (size_t)nInt16s
			    count: (size_t)count
{
	size_t size = nInt16s * sizeof(uint16_t);
	size_t size = count * sizeof(uint16_t);

#ifndef OF_BIG_ENDIAN
	[self writeBuffer: buffer
		   length: size];
#else
	uint16_t *tmp;

	tmp = [self allocMemoryWithSize: sizeof(uint16_t)
				  count: nInt16s];
				  count: count];

	@try {
		size_t i;

		for (i = 0; i < nInt16s; i++)
		for (i = 0; i < count; i++)
			tmp[i] = OF_BSWAP16(buffer[i]);

		[self writeBuffer: tmp
			   length: size];
	} @finally {
		[self freeMemory: tmp];
	}
#endif

	return size;
}

- (size_t)writeLittleEndianInt32s: (const uint32_t*)buffer
			    count: (size_t)nInt32s
			    count: (size_t)count
{
	size_t size = nInt32s * sizeof(uint32_t);
	size_t size = count * sizeof(uint32_t);

#ifndef OF_BIG_ENDIAN
	[self writeBuffer: buffer
		   length: size];
#else
	uint32_t *tmp;

	tmp = [self allocMemoryWithSize: sizeof(uint32_t)
				  count: nInt32s];
				  count: count];

	@try {
		size_t i;

		for (i = 0; i < nInt32s; i++)
		for (i = 0; i < count; i++)
			tmp[i] = OF_BSWAP32(buffer[i]);

		[self writeBuffer: tmp
			   length: size];
	} @finally {
		[self freeMemory: tmp];
	}
#endif

	return size;
}

- (size_t)writeLittleEndianInt64s: (const uint64_t*)buffer
			    count: (size_t)nInt64s
			    count: (size_t)count
{
	size_t size = nInt64s * sizeof(uint64_t);
	size_t size = count * sizeof(uint64_t);

#ifndef OF_BIG_ENDIAN
	[self writeBuffer: buffer
		   length: size];
#else
	uint64_t *tmp;

	tmp = [self allocMemoryWithSize: sizeof(uint64_t)
				  count: nInt64s];
				  count: count];

	@try {
		size_t i;

		for (i = 0; i < nInt64s; i++)
		for (i = 0; i < count; i++)
			tmp[i] = OF_BSWAP64(buffer[i]);

		[self writeBuffer: tmp
			   length: size];
	} @finally {
		[self freeMemory: tmp];
	}
#endif

	return size;
}

- (size_t)writeLittleEndianFloats: (const float*)buffer
			    count: (size_t)nFloats
			    count: (size_t)count
{
	size_t size = nFloats * sizeof(float);
	size_t size = count * sizeof(float);

#ifndef OF_FLOAT_BIG_ENDIAN
	[self writeBuffer: buffer
		   length: size];
#else
	float *tmp;

	tmp = [self allocMemoryWithSize: sizeof(float)
				  count: nFloats];
				  count: count];

	@try {
		size_t i;

		for (i = 0; i < nFloats; i++)
		for (i = 0; i < count; i++)
			tmp[i] = OF_BSWAP_FLOAT(buffer[i]);

		[self writeBuffer: tmp
			   length: size];
	} @finally {
		[self freeMemory: tmp];
	}
#endif

	return size;
}

- (size_t)writeLittleEndianDoubles: (const double*)buffer
			     count: (size_t)nDoubles
			     count: (size_t)count
{
	size_t size = nDoubles * sizeof(double);
	size_t size = count * sizeof(double);

#ifndef OF_FLOAT_BIG_ENDIAN
	[self writeBuffer: buffer
		   length: size];
#else
	double *tmp;

	tmp = [self allocMemoryWithSize: sizeof(double)
				  count: nDoubles];
				  count: count];

	@try {
		size_t i;

		for (i = 0; i < nDoubles; i++)
		for (i = 0; i < count; i++)
			tmp[i] = OF_BSWAP_DOUBLE(buffer[i]);

		[self writeBuffer: tmp
			   length: size];
	} @finally {
		[self freeMemory: tmp];
	}

Modified src/OFStreamObserver.h from [85b360a246] to [7f3a6cb32d].

41
42
43
44
45
46
47
48

49
50
51
52
53
54
55
41
42
43
44
45
46
47

48
49
50
51
52
53
54
55







-
+







#endif
#ifdef OF_HAVE_OPTIONAL_PROTOCOLS
@optional
#endif
/**
 * \brief This callback is called when a stream did get ready for reading.
 *
 * NOTE: When -[tryReadLine] or -[tryReadTillDelimiter:] has been called on the
 * \note When \ref tryReadLine or \ref tryReadTillDelimiter: has been called on
 *	 the stream, this callback will not be called again until new data has
 *	 been received, even though there is still data in the cache. The reason
 *	 for this is to prevent spinning in a loop when there is an incomplete
 *	 string in the cache. Once the string is complete, the callback will be
 *	 called again if there is data in the cache.
 *
 * \param stream The stream which did become ready for reading
70
71
72
73
74
75
76
77

78
79
80
81
82
83
84
70
71
72
73
74
75
76

77
78
79
80
81
82
83
84







-
+







 */
- (void)streamDidReceiveException: (OFStream*)stream;
@end

/**
 * \brief A class that can observe multiple streams at once.
 *
 * Note: Currently, Win32 can only observe sockets and not files!
 * \note Currently, Win32 can only observe sockets and not files!
 */
@interface OFStreamObserver: OFObject
{
	OFMutableArray *readStreams;
	OFMutableArray *writeStreams;
	__unsafe_unretained OFStream **FDToStream;
	size_t maxFD;
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
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







-
-
+
+










-
-
+
+








-
-
+
+








-
-
+
+







 * \brief Adds a stream to observe for reading.
 *
 * This is also used to observe a listening socket for incoming connections,
 * which then triggers a read event for the observed stream.
 *
 * It is recommended that the stream you add is set to non-blocking mode.
 *
 * If there is an -[observe] call blocking, it will be canceled. The reason for
 * this is to prevent blocking even though the new added stream is ready.
 * If there is an \ref observe call blocking, it will be canceled. The reason
 * for this is to prevent blocking even though the new added stream is ready.
 *
 * \param stream The stream to observe for reading
 */
- (void)addStreamForReading: (OFStream*)stream;

/**
 * \brief Adds a stream to observe for writing.
 *
 * It is recommended that the stream you add is set to non-blocking mode.
 *
 * If there is an -[observe] call blocking, it will be canceled. The reason for
 * this is to prevent blocking even though the new added stream is ready.
 * If there is an \ref observe call blocking, it will be canceled. The reason
 * for this is to prevent blocking even though the new added stream is ready.
 *
 * \param stream The stream to observe for writing
 */
- (void)addStreamForWriting: (OFStream*)stream;

/**
 * \brief Removes a stream to observe for reading.
 *
 * If there is an -[observe] call blocking, it will be canceled. The reason for
 * this is to prevent the removed stream from still being observed.
 * If there is an \ref observe call blocking, it will be canceled. The reason
 * for this is to prevent the removed stream from still being observed.
 *
 * \param stream The stream to remove from observing for reading
 */
- (void)removeStreamForReading: (OFStream*)stream;

/**
 * \brief Removes a stream to observe for writing.
 *
 * If there is an -[observe] call blocking, it will be canceled. The reason for
 * this is to prevent the removed stream from still being observed.
 * If there is an \ref observe call blocking, it will be canceled. The reason
 * for this is to prevent the removed stream from still being observed.
 *
 * \param stream The stream to remove from observing for writing
 */
- (void)removeStreamForWriting: (OFStream*)stream;

/**
 * \brief Observes all streams and blocks until an event happens on a stream.

Modified src/OFString+JSONValue.h from [9180243d68] to [178e602423].

34
35
36
37
38
39
40
41

42
43
44
45
46
34
35
36
37
38
39
40

41
42
43
44
45
46







-
+





 * \warning Although not specified by the JSON specification, this can also
 *          return primitives like strings and numbers. The rationale behind
 *          this is that most JSON parsers allow JSON data just consisting of a
 *          single primitive, leading to realworld JSON files sometimes only
 *          consisting of a single primitive. Therefore, you should not make any
 *          assumptions about the object returned by this method if you don't
 *          want your program to terminate due to a message not understood, but
 *          instead check the returned object using -[isKindOfClass:].
 *          instead check the returned object using \ref isKindOfClass:.
 *
 * \return An object
 */
- (id)JSONValue;
@end

Modified src/OFString+XMLUnescaping.h from [3d118891eb] to [fec8efb31f].

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
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







-
+





-
+










-
+



-
+







#endif
extern int _OFString_XMLUnescaping_reference;
#ifdef __cplusplus
}
#endif

#ifdef OF_HAVE_BLOCKS
typedef OFString* (^of_string_xml_unescaping_block_t)(OFString *str,
typedef OFString* (^of_string_xml_unescaping_block_t)(OFString *string,
    OFString *entity);
#endif

/**
 * \brief A protocol that needs to be implemented by delegates for
 *	  -[stringByXMLUnescapingWithHandler:].
 *	  stringByXMLUnescapingWithHandler:.
 */
@protocol OFStringXMLUnescapingDelegate <OFObject>
/**
 * \brief This callback is called when an unknown entity was found while trying
 *	  to unescape XML.
 *
 * The callback is supposed to return a substitution for the entity or nil if
 * it is unknown to the callback as well, in which case an exception will be
 * thrown.
 *
 * \param str The string which contains the unknown entity
 * \param string The string which contains the unknown entity
 * \param entity The name of the entity that is unknown
 * \return A substitution for the entity or nil
 */
-	   (OFString*)string: (OFString*)str
-	   (OFString*)string: (OFString*)string
  containsUnknownEntityNamed: (OFString*)entity;
@end

/**
 * \brief A category for unescaping XML in strings.
 */
@interface OFString (XMLUnescaping)

Modified src/OFString.h from [1cf435b925] to [25f3180e0b].

71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
71
72
73
74
75
76
77






78
79
80
81
82
83
84







-
-
-
-
-
-







#endif

@class OFArray;
@class OFURL;

/**
 * \brief A class for handling strings.
 *
 * <b>Warning:</b> If you add methods to OFString using a category, you are not
 * allowed to access the ivars directly, as these might be still uninitialized
 * for a constant string and get initialized on the first message! Therefore,
 * you should use the corresponding methods to get the ivars, which ensures the
 * constant string is initialized.
 */
@interface OFString: OFObject <OFCopying, OFMutableCopying, OFComparing,
    OFSerialization, OFJSONRepresentation>
#ifdef OF_HAVE_PROPERTIES
@property (readonly) size_t length;
#endif

113
114
115
116
117
118
119
120

121
122
123
124
125
126
127
107
108
109
110
111
112
113

114
115
116
117
118
119
120
121







-
+







 */
+ (instancetype)stringWithUTF8String: (const char*)UTF8String
			      length: (size_t)UTF8StringLength;

/**
 * \brief Creates a new OFString from a C string with the specified encoding.
 *
 * \param string A C string to initialize the OFString with
 * \param cString A C string to initialize the OFString with
 * \param encoding The encoding of the C string
 * \return A new autoreleased OFString
 */
+ (instancetype)stringWithCString: (const char*)cString
			 encoding: (of_string_encoding_t)encoding;

/**
245
246
247
248
249
250
251
252

253
254
255
256
257
258
259
239
240
241
242
243
244
245

246
247
248
249
250
251
252
253







-
+








/**
 * \brief Creates a new OFString containing the constructed specified path.
 *
 * \param firstComponent The first component of the path
 * \return A new autoreleased OFString
 */
+ (instancetype)stringWithPath: (OFString*)firstComponent, ...;
+ (instancetype)stringWithPath: (OFString*)firstComponent, ... OF_SENTINEL;

/**
 * \brief Creates a new OFString with the contents of the specified UTF-8
 *	  encoded file.
 *
 * \param path The path to the file
 * \return A new autoreleased OFString
477
478
479
480
481
482
483
484

485
486
487
488
489
490
491
471
472
473
474
475
476
477

478
479
480
481
482
483
484
485







-
+







/**
 * \brief Initializes an already allocated OFString with the constructed
 *	  specified path.
 *
 * \param firstComponent The first component of the path
 * \return A new autoreleased OFString
 */
- initWithPath: (OFString*)firstComponent, ...;
- initWithPath: (OFString*)firstComponent, ... OF_SENTINEL;

/**
 * \brief Initializes an already allocated OFString with the constructed
 *	  specified path.
 *
 * \param firstComponent The first component of the path
 * \param arguments A va_list with the other components of the path
624
625
626
627
628
629
630
631


632
633
634
635
636
637
638
639
640
641
642
643


644
645
646
647
648
649
650
618
619
620
621
622
623
624

625
626
627
628
629
630
631
632
633
634
635
636
637

638
639
640
641
642
643
644
645
646







-
+
+











-
+
+







- (of_range_t)rangeOfString: (OFString*)string;

/**
 * \brief Returns the range of the string.
 *
 * \param string The string to search
 * \param options Options modifying search behaviour.
 *		  Possible values: OF_STRING_SEARCH_BACKWARDS
 *		  Possible values:
 *		    * OF_STRING_SEARCH_BACKWARDS
 * \return The range of the first occurrence of the string or a range with
 *	   OF_NOT_FOUND as start position if it was not found
 */
- (of_range_t)rangeOfString: (OFString*)string
		    options: (int)options;

/**
 * \brief Returns the range of the string in the specified range.
 *
 * \param string The string to search
 * \param options Options modifying search behaviour.
 *		  Possible values: OF_STRING_SEARCH_BACKWARDS
 *		  Possible values:
 *		    * OF_STRING_SEARCH_BACKWARDS
 * \param range The range in which to search
 * \return The range of the first occurrence of the string or a range with
 *	   OF_NOT_FOUND as start position if it was not found
 */
- (of_range_t)rangeOfString: (OFString*)string
		    options: (int)options
		      range: (of_range_t)range;
703
704
705
706
707
708
709
710


711
712
713
714
715
716
717
699
700
701
702
703
704
705

706
707
708
709
710
711
712
713
714







-
+
+







/**
 * \brief Creates a new string by replacing the occurrences of the specified
 *	  string in the specified range with the specified replacement.
 *
 * \param string The string to replace
 * \param replacement The string with which it should be replaced
 * \param options Options modifying search behaviour.
 *		  Possible values: None yet
 *		  Possible values:
 *		    * None yet
 * \param range The range in which to replace the string
 * \return A new string with the occurrences of the specified string replaced
 */
- (OFString*)stringByReplacingOccurrencesOfString: (OFString*)string
				       withString: (OFString*)replacement
					  options: (int)options
					    range: (of_range_t)range;
729
730
731
732
733
734
735
736

737
738
739
740
741
742
743
726
727
728
729
730
731
732

733
734
735
736
737
738
739
740







-
+







 * \return The string in lowercase
 */
- (OFString*)lowercaseString;

/**
 * \brief Returns the string capitalized.
 *
 * \note This only considers spaces, tab and newlines to be word delimiters!
 * \note This only considers spaces, tabs and newlines to be word delimiters!
 *	 Also note that this might change in the future to all word delimiters
 *	 specified by Unicode!
 *
 * \return The capitalized string
 */
- (OFString*)capitalizedString;

787
788
789
790
791
792
793
794
795



796
797
798
799
800
801
802
784
785
786
787
788
789
790


791
792
793
794
795
796
797
798
799
800







-
-
+
+
+







 */
- (OFArray*)componentsSeparatedByString: (OFString*)delimiter;

/**
 * \brief Separates an OFString into an OFArray of OFStrings.
 *
 * \param delimiter The delimiter for separating
 * \param options Options according to which the string should be separated
 * 		  Possible values: OF_STRING_SKIP_EMPTY
 * \param options Options according to which the string should be separated.
 * 		  Possible values:
 * 		    * OF_STRING_SKIP_EMPTY
 * \return An autoreleased OFArray with the separated string
 */
- (OFArray*)componentsSeparatedByString: (OFString*)delimiter
				options: (int)options;

/**
 * \brief Returns the components of the path.

Modified src/OFString.m from [5ea7b40c2a] to [38b0945b74].

375
376
377
378
379
380
381
382

383
384
385
386
387
388
389
375
376
377
378
379
380
381

382
383
384
385
386
387
388
389







-
+







{
	return [[[self alloc] initWithCString: cString
				     encoding: encoding] autorelease];
}

+ (instancetype)stringWithCString: (const char*)cString
			 encoding: (of_string_encoding_t)encoding
	     length: (size_t)cStringLength
			   length: (size_t)cStringLength
{
	return [[[self alloc] initWithCString: cString
				     encoding: encoding
				       length: cStringLength] autorelease];
}

+ (instancetype)stringWithString: (OFString*)string

Modified src/OFTCPSocket.h from [facc710023] to [3d65177451].

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
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







-
+
















-
+














-
+







 */
- (uint16_t)bindToHost: (OFString*)host
		  port: (uint16_t)port;

/**
 * \brief Listen on the socket.
 *
 * \param backlog Maximum length for the queue of pending connections.
 * \param backLog Maximum length for the queue of pending connections.
 */
- (void)listenWithBackLog: (int)backLog;

/**
 * \brief Listen on the socket.
 */
- (void)listen;

/**
 * \brief Accept an incoming connection.
 *
 * \return An autoreleased OFTCPSocket for the accepted connection.
 */
- (OFTCPSocket*)accept;

/**
 * \brief Asyncronously ccept an incoming connection.
 * \brief Asyncronously accept an incoming connection.
 *
 * \param target The target on which to execute the selector when a new
 *		 connection has been accepted. The method returns whether the
 *		 next incoming connection should be accepted by the specified
 *		 block as well.
 * \param selector The selector to call on the target. The signature must be
 *		   BOOL (OFTCPSocket *socket, OFTCPSocket *acceptedSocket,
 *		   OFException *exception).
 */
- (void)asyncAcceptWithTarget: (id)target
		     selector: (SEL)selector;

#ifdef OF_HAVE_BLOCKS
/**
 * \brief Asyncronously ccept an incoming connection.
 * \brief Asyncronously accept an incoming connection.
 *
 * \param block The block to execute when a new connection has been accepted.
 *		Returns whether the next incoming connection should be accepted
 *		by the specified block as well.
 */
- (void)asyncAcceptWithBlock: (of_tcpsocket_async_accept_block_t)block;
#endif

Modified src/OFTCPSocket.m from [da12c47fdd] to [c453a27f56].

54
55
56
57
58
59
60
61

62
63
64
65
66
67
68
54
55
56
57
58
59
60

61
62
63
64
65
66
67
68







-
+







#import "macros.h"

#ifndef INVALID_SOCKET
# define INVALID_SOCKET -1
#endif

#if defined(OF_THREADS) && !defined(HAVE_THREADSAFE_GETADDRINFO)
# import "OFThread.h"
# import "OFMutex.h"
# import "OFDataArray.h"

static OFMutex *mutex = nil;
#endif

#ifdef _WIN32
# define close(sock) closesocket(sock)

Modified src/OFTLSKey.h from [3990e8ca34] to [b19c7d885e].

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
30
31
32







+
+
+
+
+







 * file.
 */

#import "OFObject.h"
#import "OFList.h"

#import "threading.h"

/* Haiku used to define this for some unknown reason which causes trouble */
#ifdef protected
# undef protected
#endif

/**
 * \brief A class for Thread Local Storage keys.
 */
@interface OFTLSKey: OFObject
{
@public

Modified src/OFTLSSocket.h from [882cb079a6] to [975f02bdfb].

24
25
26
27
28
29
30


31
32


33
34
35
36
37
38
39
24
25
26
27
28
29
30
31
32


33
34
35
36
37
38
39
40
41







+
+
-
-
+
+







 * \brief A delegate for classes implementing the OFTLSSocket protocol.
 */
@protocol OFTLSSocketDelegate
/**
 * \brief This callback is called when the TLS socket wants to know if it
 *	  should accept the received keychain.
 *
 * \param socket The socket which wants to know if it should accept the received
 *		 keychain
 * \param certificate An array of objects implementing the OFX509Certificate
 *		      protocol
 * \param keychain An array of objects implementing the OFX509Certificate
 *		   protocol
 * \return Whether the TLS socket should accept the received keychain
 */
-	  (BOOL)socket: (id <OFTLSSocket>)socket
  shouldAcceptKeychain: (OFArray*)keychain;
@end

/**

Modified src/OFThread.h from [384da59e46] to [86aa6ed7ff].

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
30
31
32







+
+
+
+
+







 * file.
 */

#import "OFObject.h"
#import "OFTLSKey.h"

#import "threading.h"

/* Haiku used to define this for some unknown reason which causes trouble */
#ifdef protected
# undef protected
#endif

@class OFDate;
@class OFSortedList;
@class OFRunLoop;

#ifdef OF_HAVE_BLOCKS
typedef id (^of_thread_block_t)(id object);

Modified src/OFThreadPool.h from [9c891bd73d] to [10a91b11db].

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
60
61
62
63
64
65
66












67
68
69
70
71
72
73







-
-
-
-
-
-
-
-
-
-
-
-







 *	    determined, the pool will only have one thread!
 *
 * \param size The number of threads for the pool
 * \return A new thread pool with the specified number of threads
 */
+ (instancetype)threadPoolWithSize: (size_t)size;

/**
 * \brief Initializes an already allocated OFThreadPool with one thread for
 *	  each core in the system.
 *
 * \warning If for some reason the number of cores in the system could not be
 *	    determined, the pool will only have one thread!
 *
 * \return An initialized OFThreadPool with one thread for each core in the
 *	   system
 */
- init;

/**
 * \brief Initializes an already allocated OFThreadPool with the specified
 *	  number of threads.
 *
 * \warning If for some reason the number of cores in the system could not be
 *	    determined, the pool will only have one thread!
 *

Modified src/OFTimer.h from [72b838b1fd] to [111602135a].

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
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







-
+











+
+
+
+







 * \param repeats Whether the timer repeats after it has been executed
 * \return An initialized timer
 */
- initWithFireDate: (OFDate*)fireDate
	  interval: (double)interval
	    target: (id)target
	  selector: (SEL)selector
	    object: (id)object1
	    object: (id)object
	   repeats: (BOOL)repeats;

/**
 * \brief Initializes an already allocated timer with the specified time
 *	  interval.
 *
 * \param fireDate The date at which the timer should fire
 * \param interval The time interval after which to repeat the timer, if it is
 *		   a repeating timer
 * \param target The target on which to call the selector
 * \param selector The selector to call on the target
 * \param object1 The first object to pass when calling the selector on the
 *		  target
 * \param object2 The second object to pass when calling the selector on the
 *		  target
 * \param repeats Whether the timer repeats after it has been executed
 * \return An initialized timer
 */
- initWithFireDate: (OFDate*)fireDate
	  interval: (double)interval
	    target: (id)target
	  selector: (SEL)selector

Modified src/OFURL.h from [23c8849a02] to [33f810be9b].

78
79
80
81
82
83
84
85

86
87
88
89
90
91
92
78
79
80
81
82
83
84

85
86
87
88
89
90
91
92







-
+







 *	  relative URL.
 *
 * \param string A string describing a URL
 * \param URL A URL to which the string is relative
 * \return An initialized OFURL
 */
- initWithString: (OFString*)string
   relativeToURL: (OFURL*)url;
   relativeToURL: (OFURL*)URL;

/**
 * \brief Returns the scheme part of the URL.
 *
 * \return The scheme part of the URL
 */
- (OFString*)scheme;

Modified src/OFXMLElement.h from [15d1784604] to [f0dd668642].

299
300
301
302
303
304
305
306

307
308
309
310
311
312
313
299
300
301
302
303
304
305

306
307
308
309
310
311
312
313







-
+







 */
- (OFXMLAttribute*)attributeForName: (OFString*)attributeName
			  namespace: (OFString*)attributeNS;

/**
 * \brief Removes the attribute with the specified name.
 *
 * \param attribteName The name of the attribute
 * \param attributeName The name of the attribute
 */
- (void)removeAttributeForName: (OFString*)attributeName;

/**
 * \brief Removes the attribute with the specified name and namespace.
 *
 * \param attributeName The name of the attribute

Modified src/OFXMLElementBuilder.h from [a3fee8ab7a] to [1452f384ab].

34
35
36
37
38
39
40
41

42
43
44
45
46
47
48
34
35
36
37
38
39
40

41
42
43
44
45
46
47
48







-
+







 * \brief This callback is called when the OFXMLElementBuilder built an element.
 *
 * If the OFXMLElementBuilder was used as a delegate for the OFXMLParser since
 * parsing started, this will return the complete document as an OFXMLElement
 * with all children.
 *
 * \param builder The builder which built an OFXMLElement
 * \param elem The OFXMLElement the OFXMLElementBuilder built
 * \param element The OFXMLElement the OFXMLElementBuilder built
 */
- (void)elementBuilder: (OFXMLElementBuilder*)builder
       didBuildElement: (OFXMLElement*)element;

#ifdef OF_HAVE_OPTIONAL_PROTOCOLS
@optional
#endif
83
84
85
86
87
88
89

90
91
92
93
94
95
96
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97







+







	    withPrefix: (OFString*)prefix
	     namespace: (OFString*)ns;

/**
 * \brief This callback is called when the XML parser for the element builder
 *	  found an unknown entity.
 *
 * \param builder The element builder which found an unknown entity
 * \param entity The name of the entity
 * \return The substitution for the entity
 */
- (OFString*)elementBuilder: (OFXMLElementBuilder*)builder
    foundUnknownEntityNamed: (OFString*)entity;
@end

Modified src/OFXMLElementBuilder.m from [2a5d5697ce] to [5fb1759a2a].

185
186
187
188
189
190
191
192

193
194
195
196
197
198
199
185
186
187
188
189
190
191

192
193
194
195
196
197
198
199







-
+







	return [delegate elementBuilder: self
		foundUnknownEntityNamed: entity];
}
@end

@implementation OFObject (OFXMLElementBuilderDelegate)
- (void)elementBuilder: (OFXMLElementBuilder*)builder
       didBuildElement: (OFXMLElement*)elem
       didBuildElement: (OFXMLElement*)element
{
}

-   (void)elementBuilder: (OFXMLElementBuilder*)builder
  didBuildParentlessNode: (OFXMLNode*)node
{
}

Modified src/autorelease.m from [bf4537c728] to [54e2ae018c].

35
36
37
38
39
40
41
42
43


44
45
46
47
48
49
50
35
36
37
38
39
40
41


42
43
44
45
46
47
48
49
50







-
-
+
+







#else
static of_tlskey_t objectsKey, topKey, sizeKey;

static void __attribute__((constructor))
init(void)
{
	OF_ENSURE(of_tlskey_new(&objectsKey));
	OF_ENSURE(of_tlskey_new(&sizeKey));
	OF_ENSURE(of_tlskey_new(&topKey));
	OF_ENSURE(of_tlskey_new(&topKey));
	OF_ENSURE(of_tlskey_new(&sizeKey));
}
#endif

void*
objc_autoreleasePoolPush()
{
#ifndef OF_COMPILER_TLS
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
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







-
-
+
+















+
+
+


-
+
-

-
-
-




















-
+




		free(objects);

		objects = NULL;
		top = NULL;
	}

#ifndef OF_COMPILER_TLS
	OF_ENSURE(of_tlskey_set(objectsKey, objects));
	OF_ENSURE(of_tlskey_set(topKey, top));
	OF_ENSURE(of_tlskey_set(topKey, top));
	OF_ENSURE(of_tlskey_set(objectsKey, objects));
#endif
}

id
_objc_rootAutorelease(id object)
{
#ifndef OF_COMPILER_TLS
	id *top = of_tlskey_get(topKey);
	id *objects = of_tlskey_get(objectsKey);
	size_t size = (size_t)(uintptr_t)of_tlskey_get(sizeKey);
#endif

	if (objects == NULL) {
		OF_ENSURE((objects = malloc(of_pagesize)) != NULL);

		top = objects;
		size = of_pagesize;

#ifndef OF_COMPILER_TLS
		OF_ENSURE(of_tlskey_set(objectsKey, objects));
		OF_ENSURE(of_tlskey_set(sizeKey,
		OF_ENSURE(of_tlskey_set(sizeKey, (void*)(uintptr_t)size));
			(void*)(uintptr_t)of_pagesize));
#endif

		top = objects;
		size = of_pagesize;
	}

	if ((uintptr_t)top >= (uintptr_t)objects + size) {
		ptrdiff_t diff = top - objects;

		size += of_pagesize;
		OF_ENSURE((objects = realloc(objects, size)) != NULL);

#ifndef OF_COMPILER_TLS
		OF_ENSURE(of_tlskey_set(objectsKey, objects));
		OF_ENSURE(of_tlskey_set(sizeKey, (void*)(uintptr_t)size));
#endif

		top = objects + diff;
	}

	*top = object;
	top++;

#ifndef OF_COMPILER_TLS
	OF_ENSURE(of_tlskey_set(topKey, objects));
	OF_ENSURE(of_tlskey_set(topKey, top));
#endif

	return object;
}

Modified src/exceptions/OFAcceptFailedException.h from [ce6bf67244] to [f0b09b1354].

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
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







+
+


-
+





-
+









+
+





+
+





#ifdef OF_HAVE_PROPERTIES
@property (readonly, retain, nonatomic) OFTCPSocket *socket;
@property (readonly) int errNo;
#endif

/**
 * \brief Creates a new, autoreleased accept failed exception.
 *
 * \param class_ The class of the object which caused the exception
 * \param socket The socket which could not accept a connection
 * \return A new accept failed exception
 * \return A new, autoreleased accept failed exception
 */
+ (instancetype)exceptionWithClass: (Class)class_
			    socket: (OFTCPSocket*)socket;

/**
 * Initializes an already allocated accept failed exception.
 * \brief Initializes an already allocated accept failed exception.
 *
 * \param class_ The class of the object which caused the exception
 * \param socket The socket which could not accept a connection
 * \return An initialized accept failed exception
 */
- initWithClass: (Class)class_
	 socket: (OFTCPSocket*)socket;

/**
 * \brief Returns the socket which could not accept a connection.
 *
 * \return The socket which could not accept a connection
 */
- (OFTCPSocket*)socket;

/**
 * \brief Returns the errno from when the exception was created.
 *
 * \return The errno from when the exception was created
 */
- (int)errNo;
@end

Modified src/exceptions/OFAddressTranslationFailedException.h from [51fe7c2bc9] to [d753968c79].

31
32
33
34
35
36
37


38
39
40
41

42
43
44
45
46
47
48

49
50
51
52
53
54
55
56
57
58
59


60
61
62
63
64


65

66
67
68
69


70
71
72
73
31
32
33
34
35
36
37
38
39
40
41
42

43
44
45
46
47
48
49

50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70

71
72
73
74
75
76
77
78
79
80
81







+
+



-
+






-
+











+
+





+
+
-
+




+
+




#ifdef OF_HAVE_PROPERTIES
@property (readonly, retain, nonatomic) OFTCPSocket *socket;
@property (readonly, copy, nonatomic) OFString *host;
@property (readonly) int errNo;
#endif

/**
 * \brief Creates a new, autoreleased address translation failed exception.
 *
 * \param class_ The class of the object which caused the exception
 * \param socket The socket which could not translate the address
 * \param host The host for which translation was requested
 * \return A new address translation failed exception
 * \return A new, autoreleased address translation failed exception
 */
+ (instancetype)exceptionWithClass: (Class)class_
			    socket: (OFTCPSocket*)socket
			      host: (OFString*)host;

/**
 * Initializes an already allocated address translation failed exception.
 * \brief Initializes an already allocated address translation failed exception.
 *
 * \param class_ The class of the object which caused the exception
 * \param socket The socket which could not translate the address
 * \param host The host for which translation was requested
 * \return An initialized address translation failed exception
 */
- initWithClass: (Class)class_
	 socket: (OFTCPSocket*)socket
	   host: (OFString*)host;

/**
 * \brief Returns the socket which could not translate the address.
 *
 * \return The socket which could not translate the address
 */
- (OFTCPSocket*)socket;

/**
 * \brief Returns the host for which the address translation was requested.
 *
 * /return The host for which translation was requested
 * \return The host for which the address translation was requested
 */
- (OFString*)host;

/**
 * \brief Returns the errno from when the exception was created.
 *
 * \return The errno from when the exception was created
 */
- (int)errNo;
@end

Modified src/exceptions/OFAllocFailedException.h from [c7f0fcd19a] to [52825cc2ea].

17
18
19
20
21
22
23
24

25
26
27
28
29
30
31

32
33
34


35
36
37
38
17
18
19
20
21
22
23

24
25
26
27
28
29
30

31
32
33
34
35
36
37
38
39
40







-
+






-
+



+
+




#import "OFObject.h"

@class OFString;

/**
 * \brief An exception indicating an object could not be allocated.
 *
 * This exception is preallocated, as if there's no memory, no exception can
 * This exception is preallocated, as when there's no memory, no exception can
 * be allocated of course. That's why you shouldn't and even can't deallocate
 * it.
 *
 * This is the only exception that is not an OFException as it's special.
 * It does not know for which class allocation failed and it should not be
 * handled like other exceptions, as the exception handling code is not
 * allowed to allocate ANY memory.
 * allowed to allocate <i>any</i> memory.
 */
@interface OFAllocFailedException: OFObject
/**
 * \brief Returns a description of the exception.
 *
 * \return A description of the exception
 */
- (OFString*)description;
@end

Modified src/exceptions/OFAlreadyConnectedException.h from [f0f3a732ca] to [d77fb10305].

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
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







+
+


-
+





-
+









+
+




}

#ifdef OF_HAVE_PROPERTIES
@property (readonly, retain, nonatomic) OFTCPSocket *socket;
#endif

/**
 * \brief Creates a new, autoreleased already connected exception.
 *
 * \param class_ The class of the object which caused the exception
 * \param socket The socket which is already connected
 * \return A new already connected exception
 * \return A new, autoreleased already connected exception
 */
+ (instancetype)exceptionWithClass: (Class)class_
			    socket: (OFTCPSocket*)socket;

/**
 * Initializes an already allocated already connected exception.
 * \brief Initializes an already allocated already connected exception.
 *
 * \param class_ The class of the object which caused the exception
 * \param socket The socket which is already connected
 * \return An initialized already connected exception
 */
- initWithClass: (Class)class_
	 socket: (OFTCPSocket*)socket;

/**
 * \brief Returns the socket which is already connected.
 *
 * \return The socket which is already connected
 */
- (OFTCPSocket*)socket;
@end

Modified src/exceptions/OFBindFailedException.h from [de9573017a] to [320926608f].

33
34
35
36
37
38
39


40
41
42
43
44

45
46
47
48
49
50
51
52

53
54
55
56
57
58
59
60
61
62
63
64
65


66
67
68
69
70


71
72
73
74
75


76
77
78
79
80


81
82
83
84
33
34
35
36
37
38
39
40
41
42
43
44
45

46
47
48
49
50
51
52
53

54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94







+
+




-
+







-
+













+
+





+
+





+
+





+
+




@property (readonly, retain, nonatomic) OFTCPSocket *socket;
@property (readonly, copy, nonatomic) OFString *host;
@property (readonly) uint16_t port;
@property (readonly) int errNo;
#endif

/**
 * \brief Creates a new, autoreleased bind failed exception.
 *
 * \param class_ The class of the object which caused the exception
 * \param socket The socket which could not be bound
 * \param host The host on which binding failed
 * \param port The port on which binding failed
 * \return A new bind failed exception
 * \return A new, autoreleased bind failed exception
 */
+ (instancetype)exceptionWithClass: (Class)class_
			    socket: (OFTCPSocket*)socket
			      host: (OFString*)host
			      port: (uint16_t)port;

/**
 * Initializes an already allocated bind failed exception.
 * \brief Initializes an already allocated bind failed exception.
 *
 * \param class_ The class of the object which caused the exception
 * \param socket The socket which could not be bound
 * \param host The host on which binding failed
 * \param port The port on which binding failed
 * \return An initialized bind failed exception
 */
- initWithClass: (Class)class_
	 socket: (OFTCPSocket*)socket
	   host: (OFString*)host
	   port: (uint16_t)port;

/**
 * \brief Returns the socket which could not be bound.
 *
 * \return The socket which could not be bound
 */
- (OFTCPSocket*)socket;

/**
 * \brief Returns the host on which binding failed.
 *
 * \return The host on which binding failed
 */
- (OFString*)host;

/**
 * \brief Return the port on which binding failed.
 *
 * \return The port on which binding failed
 */
- (uint16_t)port;

/**
 * \brief Returns the errno from when the exception was created.
 *
 * \return The errno from when the exception was created
 */
- (int)errNo;
@end

Modified src/exceptions/OFChangeDirectoryFailedException.h from [3beb130497] to [e685ba550b].

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
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







+
+



-
+





-
+










+
+





+
+
-
+




#ifdef OF_HAVE_PROPERTIES
@property (readonly, copy, nonatomic) OFString *path;
@property (readonly) int errNo;
#endif

/**
 * \brief Creates a new, autoreleased change directory failed exception.
 *
 * \param class_ The class of the object which caused the exception
 * \param path A string with the path of the directory to which couldn't be
 *	       changed
 * \return A new change directory failed exception
 * \return A new, autoreleased change directory failed exception
 */
+ (instancetype)exceptionWithClass: (Class)class_
			      path: (OFString*)path;

/**
 * Initializes an already allocated change directory failed exception.
 * \brief Initializes an already allocated change directory failed exception.
 *
 * \param class_ The class of the object which caused the exception
 * \param path A string with the path of the directory to which couldn't be
 *	       changed
 * \return An initialized change directory failed exception
 */
- initWithClass: (Class)class_
	   path: (OFString*)path;

/**
 * \brief Returns the errno from when the exception was created.
 *
 * \return The errno from when the exception was created
 */
- (int)errNo;

/**
 * \brief Returns the path to which changing failed.
 *
 * \return A string with the path of the directory to which couldn't changed
 * \return The path to which changing failed
 */
- (OFString*)path;
@end

Modified src/exceptions/OFChangeFileModeFailedException.h from [affc9d01dd] to [9f27f66777].

31
32
33
34
35
36
37


38
39
40
41

42
43
44
45
46
47
48

49
50
51
52
53
54
55
56
57
58
59


60
61
62
63
64


65
66
67
68
69


70
71
72
73
31
32
33
34
35
36
37
38
39
40
41
42

43
44
45
46
47
48
49

50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81







+
+



-
+






-
+











+
+





+
+





+
+




#ifdef OF_HAVE_PROPERTIES
@property (readonly, copy, nonatomic) OFString *path;
@property (readonly) mode_t mode;
@property (readonly) int errNo;
#endif

/**
 * \brief Creates a new, autoreleased change file mode failed exception.
 *
 * \param class_ The class of the object which caused the exception
 * \param path The path of the file
 * \param mode The new mode for the file
 * \return An initialized change file mode failed exception
 * \return A new, autoreleased change file mode failed exception
 */
+ (instancetype)exceptionWithClass: (Class)class_
			      path: (OFString*)path
			      mode: (mode_t)mode;

/**
 * Initializes an already allocated change file mode failed exception.
 * \brief Initializes an already allocated change file mode failed exception.
 *
 * \param class_ The class of the object which caused the exception
 * \param path The path of the file
 * \param mode The new mode for the file
 * \return An initialized change file mode failed exception
 */
- initWithClass: (Class)class_
	   path: (OFString*)path
	   mode: (mode_t)mode;

/**
 * \brief Returns the errno from when the exception was created.
 *
 * \return The errno from when the exception was created
 */
- (int)errNo;

/**
 * \brief Returns the path of the file.
 *
 * \return The path of the file
 */
- (OFString*)path;

/**
 * \brief Returns the new mode for the file.
 *
 * \return The new mode for the file
 */
- (mode_t)mode;
@end

Modified src/exceptions/OFChangeFileOwnerFailedException.h from [9421a3246c] to [de30ddbf1a].

32
33
34
35
36
37
38


39
40
41
42
43

44
45
46
47
48
49
50
51

52
53
54
55
56
57
58
59
60
61
62
63
64


65
66
67
68
69


70
71
72
73
74


75
76
77
78
79


80
81
82
83
84
32
33
34
35
36
37
38
39
40
41
42
43
44

45
46
47
48
49
50
51
52

53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94







+
+




-
+







-
+













+
+





+
+





+
+





+
+





@property (readonly, copy, nonatomic) OFString *path;
@property (readonly, copy, nonatomic) OFString *owner;
@property (readonly, copy, nonatomic) OFString *group;
@property (readonly) int errNo;
#endif

/**
 * \brief Creates a new, autoreleased change file owner failed exception.
 *
 * \param class_ The class of the object which caused the exception
 * \param path The path of the file
 * \param owner The new owner for the file
 * \param group The new group for the file
 * \return An initialized change file owner failed exception
 * \return A new, autoreleased change file owner failed exception
 */
+ (instancetype)exceptionWithClass: (Class)class_
			      path: (OFString*)path
			     owner: (OFString*)owner
			     group: (OFString*)group;

/**
 * Initializes an already allocated change file owner failed exception.
 * \brief Initializes an already allocated change file owner failed exception.
 *
 * \param class_ The class of the object which caused the exception
 * \param path The path of the file
 * \param owner The new owner for the file
 * \param group The new group for the file
 * \return An initialized change file owner failed exception
 */
- initWithClass: (Class)class_
	   path: (OFString*)path
	  owner: (OFString*)owner
	  group: (OFString*)group;

/**
 * \brief Returns the errno from when the exception was created.
 *
 * \return The errno from when the exception was created
 */
- (int)errNo;

/**
 * \brief Returns the path of the file.
 *
 * \return The path of the file
 */
- (OFString*)path;

/**
 * \brief Returns the new owner for the file.
 *
 * \return The new owner for the file
 */
- (OFString*)owner;

/**
 * \brief Returns the new group for the file.
 *
 * \return The new group for the file
 */
- (OFString*)group;
@end
#endif

Modified src/exceptions/OFConditionBroadcastFailedException.h from [12a3b4f9af] to [f7da45bb6a].

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
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







+
+


-
+





-
+









+
+




}

#ifdef OF_HAVE_PROPERTIES
@property (readonly, retain, nonatomic) OFCondition *condition;
#endif

/**
 * \brief Returns a new, autoreleased condition broadcast failed exception.
 *
 * \param class_ The class of the object which caused the exception
 * \param condition The condition which could not be broadcasted
 * \return A new condition broadcast failed exception
 * \return A new, autoreleased condition broadcast failed exception
 */
+ (instancetype)exceptionWithClass: (Class)class_
			 condition: (OFCondition*)condition;

/**
 * Initializes an already allocated condition broadcast failed exception.
 * \brief Initializes an already allocated condition broadcast failed exception.
 *
 * \param class_ The class of the object which caused the exception
 * \param condition The condition which could not be broadcasted
 * \return An initialized condition broadcast failed exception
 */
- initWithClass: (Class)class_
      condition: (OFCondition*)condition;

/**
 * \brief Returns the condition which could not be broadcasted.
 *
 * \return The condition which could not be broadcasted
 */
- (OFCondition*)condition;
@end

Modified src/exceptions/OFConditionSignalFailedException.h from [ccc6986d00] to [0da50535a2].

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
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







+
+


-
+





-
+









+
+




}

#ifdef OF_HAVE_PROPERTIES
@property (readonly, retain, nonatomic) OFCondition *condition;
#endif

/**
 * \brief Creates a new, autoreleased condition signal failed exception.
 *
 * \param class_ The class of the object which caused the exception
 * \param condition The condition which could not be signaled
 * \return A new condition signal failed exception
 * \return A new, autoreleased condition signal failed exception
 */
+ (instancetype)exceptionWithClass: (Class)class_
			 condition: (OFCondition*)condition;

/**
 * Initializes an already allocated condition signal failed exception.
 * \brief Initializes an already allocated condition signal failed exception.
 *
 * \param class_ The class of the object which caused the exception
 * \param condition The condition which could not be signaled
 * \return An initialized condition signal failed exception
 */
- initWithClass: (Class)class_
      condition: (OFCondition*)condition;

/**
 * \brief Return the condition which could not be signaled.
 *
 * \return The condition which could not be signaled
 */
- (OFCondition*)condition;
@end

Modified src/exceptions/OFConditionStillWaitingException.h from [fca0f6e639] to [7bed89b86a].

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
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







+
+


-
+





-
+









+
+




}

#ifdef OF_HAVE_PROPERTIES
@property (readonly, retain, nonatomic) OFCondition *condition;
#endif

/**
 * \brief Creates a new, autoreleased condition still waiting exception.
 *
 * \param class_ The class of the object which caused the exception
 * \param condition The condition for which is still being waited
 * \return A new condition still waiting exception
 * \return A new, autoreleased condition still waiting exception
 */
+ (instancetype)exceptionWithClass: (Class)class_
			 condition: (OFCondition*)condition;

/**
 * Initializes an already allocated condition still waiting exception.
 * \brief Initializes an already allocated condition still waiting exception.
 *
 * \param class_ The class of the object which caused the exception
 * \param condition The condition for which is still being waited
 * \return An initialized condition still waiting exception
 */
- initWithClass: (Class)class_
      condition: (OFCondition*)condition;

/**
 * \brief Return the condition for which is still being waited.
 *
 * \return The condition for which is still being waited
 */
- (OFCondition*)condition;
@end

Modified src/exceptions/OFConditionWaitFailedException.h from [a05792c7b8] to [3cbd408248].

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
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







+
+


-
+





-
+









+
+




}

#ifdef OF_HAVE_PROPERTIES
@property (readonly, retain, nonatomic) OFCondition *condition;
#endif

/**
 * \brief Creates a new, autoreleased condition wait failed exception.
 *
 * \param class_ The class of the object which caused the exception
 * \param condition The condition for which could not be waited
 * \return A new condition wait failed exception
 * \return A new, autoreleased condition wait failed exception
 */
+ (instancetype)exceptionWithClass: (Class)class_
			 condition: (OFCondition*)condition;

/**
 * Initializes an already allocated condition wait failed exception.
 * \brief Initializes an already allocated condition wait failed exception.
 *
 * \param class_ The class of the object which caused the exception
 * \param condition The condition for which could not be waited
 * \return An initialized condition wait failed exception
 */
- initWithClass: (Class)class_
      condition: (OFCondition*)condition;

/**
 * \brief Return the condition for which could not be waited.
 *
 * \return The condition for which could not be waited
 */
- (OFCondition*)condition;
@end

Modified src/exceptions/OFConnectionFailedException.h from [cf16965ef3] to [ee671036b6].

33
34
35
36
37
38
39


40
41
42
43
44

45
46
47
48
49
50
51
52

53
54
55
56
57
58
59
60
61
62
63
64
65


66
67
68
69
70


71
72
73
74
75


76
77
78
79
80


81
82
83
84
33
34
35
36
37
38
39
40
41
42
43
44
45

46
47
48
49
50
51
52
53

54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94







+
+




-
+







-
+













+
+





+
+





+
+





+
+




@property (readonly, retain, nonatomic) OFTCPSocket *socket;
@property (readonly, copy, nonatomic) OFString *host;
@property (readonly) uint16_t port;
@property (readonly) int errNo;
#endif

/**
 * \brief Creates a new, autoreleased connection failed exception.
 *
 * \param class_ The class of the object which caused the exception
 * \param socket The socket which could not connect
 * \param host The host to which the connection failed
 * \param port The port on the host to which the connection failed
 * \return A new connection failed exception
 * \return A new, autoreleased connection failed exception
 */
+ (instancetype)exceptionWithClass: (Class)class_
			    socket: (OFTCPSocket*)socket
			      host: (OFString*)host
			      port: (uint16_t)port;

/**
 * Initializes an already allocated connection failed exception.
 * \brief Initializes an already allocated connection failed exception.
 *
 * \param class_ The class of the object which caused the exception
 * \param socket The socket which could not connect
 * \param host The host to which the connection failed
 * \param port The port on the host to which the connection failed
 * \return An initialized connection failed exception
 */
- initWithClass: (Class)class_
	 socket: (OFTCPSocket*)socket
	   host: (OFString*)host
	   port: (uint16_t)port;

/**
 * \brief Returns the socket which could not connect.
 *
 * \return The socket which could not connect
 */
- (OFTCPSocket*)socket;

/**
 * \brief Returns the host to which the connection failed.
 *
 * \return The host to which the connection failed
 */
- (OFString*)host;

/**
 * \brief Returns the port on the host to which the connection failed.
 *
 * \return The port on the host to which the connection failed
 */
- (uint16_t)port;

/**
 * \brief Returns the errno from when the exception was created.
 *
 * \return The errno from when the exception was created
 */
- (int)errNo;
@end

Modified src/exceptions/OFCopyFileFailedException.h from [2ecd97f65f] to [3168d8b98e].

29
30
31
32
33
34
35


36
37
38
39

40
41
42
43
44
45
46

47
48
49
50
51
52
53
54
55
56
57


58
59
60
61
62


63
64
65
66
67


68
69
70
71
29
30
31
32
33
34
35
36
37
38
39
40

41
42
43
44
45
46
47

48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79







+
+



-
+






-
+











+
+





+
+





+
+




#ifdef OF_HAVE_PROPERTIES
@property (readonly, copy, nonatomic) OFString *sourcePath;
@property (readonly, copy, nonatomic) OFString *destinationPath;
@property (readonly) int errNo;
#endif

/**
 * \brief Creates a new, autoreleased copy file failed exception.
 *
 * \param class_ The class of the object which caused the exception
 * \param source The original path
 * \param destination The new path
 * \return A new copy file failed exception
 * \return A new, autoreleased copy file failed exception
 */
+ (instancetype)exceptionWithClass: (Class)class_
			sourcePath: (OFString*)source
		   destinationPath: (OFString*)destination;

/**
 * Initializes an already allocated copy file failed exception.
 * \brief Initializes an already allocated copy file failed exception.
 *
 * \param class_ The class of the object which caused the exception
 * \param source The original path
 * \param destination The new path
 * \return An initialized copy file failed exception
 */
-   initWithClass: (Class)class_
       sourcePath: (OFString*)source
  destinationPath: (OFString*)destination;

/**
 * \brief Returns the errno from when the exception was created.
 *
 * \return The errno from when the exception was created
 */
- (int)errNo;

/**
 * \brief Returns the path of the source file.
 *
 * \return The path of the source file
 */
- (OFString*)sourcePath;

/**
 * \brief Returns the destination path.
 *
 * \return The destination path
 */
- (OFString*)destinationPath;
@end

Modified src/exceptions/OFCreateDirectoryFailedException.h from [04b508ef4d] to [a166105f90].

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
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







+
+


-
+





-
+









+
+





+
+
+





#ifdef OF_HAVE_PROPERTIES
@property (readonly, copy, nonatomic) OFString *path;
@property (readonly) int errNo;
#endif

/**
 * \brief Creates a new, autoreleased create directory failed exception.
 *
 * \param class_ The class of the object which caused the exception
 * \param path A string with the path of the directory which couldn't be created
 * \return A new create directory failed exception
 * \return A new, autoreleased create directory failed exception
 */
+ (instancetype)exceptionWithClass: (Class)class_
			      path: (OFString*)path;

/**
 * Initializes an already allocated create directory failed exception.
 * \brief Initializes an already allocated create directory failed exception.
 *
 * \param class_ The class of the object which caused the exception
 * \param path A string with the path of the directory which couldn't be created
 * \return An initialized create directory failed exception
 */
- initWithClass: (Class)class_
	   path: (OFString*)path;

/**
 * \brief Returns the errno from when the exception was created.
 *
 * \return The errno from when the exception was created
 */
- (int)errNo;

/**
 * \brief Returns a string with the path of the directory which couldn't be
 *	  created.
 *
 * \return A string with the path of the directory which couldn't be created
 */
- (OFString*)path;
@end

Modified src/exceptions/OFDeleteDirectoryFailedException.h from [d3f645608a] to [b2ada4ca66].

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
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







+
+


-
+





-
+









+
+





+
+





#ifdef OF_HAVE_PROPERTIES
@property (readonly, copy, nonatomic) OFString *path;
@property (readonly) int errNo;
#endif

/**
 * \brief Creates a new, autoreleased delete directory failed exception.
 *
 * \param class_ The class of the object which caused the exception
 * \param path The path of the directory
 * \return A new delete directory failed exception
 * \return A new, autoreleased delete directory failed exception
 */
+ (instancetype)exceptionWithClass: (Class)class_
			      path: (OFString*)path;

/**
 * Initializes an already allocated delete directory failed exception.
 * \brief Initializes an already allocated delete directory failed exception.
 *
 * \param class_ The class of the object which caused the exception
 * \param path The path of the directory
 * \return An initialized delete directory failed exception
 */
- initWithClass: (Class)class_
	   path: (OFString*)path;

/**
 * \brief Returns the errno from when the exception was created.
 *
 * \return The errno from when the exception was created
 */
- (int)errNo;

/**
 * \brief Returns the path of the directory.
 *
 * \return The path of the directory
 */
- (OFString*)path;
@end

Modified src/exceptions/OFDeleteFileFailedException.h from [0bc79ded9a] to [0a397ad844].

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
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







+
+


-
+





-
+









+
+





+
+





#ifdef OF_HAVE_PROPERTIES
@property (readonly, copy, nonatomic) OFString *path;
@property (readonly) int errNo;
#endif

/**
 * \brief Creates a new, autoreleased delete file failed exception.
 *
 * \param class_ The class of the object which caused the exception
 * \param path The path of the file
 * \return A new delete file failed exception
 * \return A new, autoreleased delete file failed exception
 */
+ (instancetype)exceptionWithClass: (Class)class_
			      path: (OFString*)path;

/**
 * Initializes an already allocated delete file failed exception.
 * \brief Initializes an already allocated delete file failed exception.
 *
 * \param class_ The class of the object which caused the exception
 * \param path The path of the file
 * \return An initialized delete file failed exception
 */
- initWithClass: (Class)class_
	   path: (OFString*)path;

/**
 * \brief Returns the errno from when the exception was created.
 *
 * \return The errno from when the exception was created
 */
- (int)errNo;

/**
 * \brief Returns the path of the file.
 *
 * \return The path of the file
 */
- (OFString*)path;
@end

Modified src/exceptions/OFEnumerationMutationException.h from [df642fbe51] to [29ed3c81fa].

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
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







+
+


-
+





-
+









+
+




}

#ifdef OF_HAVE_PROPERTIES
@property (readonly, retain, nonatomic) id object;
#endif

/**
 * \brief Creates a new, autoreleased enumeration mutation exception.
 *
 * \param class_ The class of the object which caused the exception
 * \param object The object which was mutated during enumeration
 * \return A new enumeration mutation exception
 * \return A new, autoreleased enumeration mutation exception
 */
+ (instancetype)exceptionWithClass: (Class)class_
			    object: (id)object;

/**
 * Initializes an already allocated enumeration mutation exception.
 * \brief Initializes an already allocated enumeration mutation exception.
 *
 * \param class_ The class of the object which caused the exception
 * \param object The object which was mutated during enumeration
 * \return An initialized enumeration mutation exception
 */
- initWithClass: (Class)class_
	 object: (id)object;

/**
 * \brief Returns the object which was mutated during enumeration.
 *
 * \return The object which was mutated during enumeration
 */
- (id)object;
@end

Modified src/exceptions/OFException.h from [1070cfb5a4] to [3da93c69a8].

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
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







-
+


-
+




-
+







+
+





+
+




}

#ifdef OF_HAVE_PROPERTIES
@property (readonly) Class inClass;
#endif

/**
 * Creates a new exception.
 * \brief Creates a new, autoreleased exception.
 *
 * \param class_ The class of the object which caused the exception
 * \return A new exception
 * \return A new, autoreleased exception
 */
+ (instancetype)exceptionWithClass: (Class)class_;

/**
 * Initializes an already allocated OFException.
 * \brief Initializes an already allocated OFException.
 *
 * \param class_ The class of the object which caused the exception
 * \return An initialized OFException
 */
- initWithClass: (Class)class_;

/**
 * \brief Returns the class of the object in which the exception happened.
 *
 * \return The class of the object in which the exception happened
 */
- (Class)inClass;

/**
 * \brief Returns a description of the exception.
 *
 * \return A description of the exception
 */
- (OFString*)description;
@end

Modified src/exceptions/OFHTTPRequestFailedException.h from [cfa7c8cc6b] to [d34a3e64ab].

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
30
31
32
33
34
35
36
37
38
39
40
41

42
43
44
45
46
47
48

49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73







+
+



-
+






-
+











+
+





+
+





#ifdef OF_HAVE_PROPERTIES
@property (readonly, retain, nonatomic) OFHTTPRequest *request;
@property (readonly, retain, nonatomic) OFHTTPRequestResult *result;
#endif

/**
 * \brief Creates a new, autoreleased HTTP request failed exception.
 *
 * \param class_ The class of the object which caused the exception
 * \param request The HTTP request which failed
 * \param result The result of the failed HTTP request
 * \return A new HTTP request failed exception
 * \return A new, autoreleased HTTP request failed exception
 */
+ (instancetype)exceptionWithClass: (Class)class_
			   request: (OFHTTPRequest*)request
			    result: (OFHTTPRequestResult*)result;

/**
 * Initializes an already allocated HTTP request failed exception
 * \brief Initializes an already allocated HTTP request failed exception.
 *
 * \param class_ The class of the object which caused the exception
 * \param request The HTTP request which failed
 * \param result The result of the failed HTTP request
 * \return A new HTTP request failed exception
 */
- initWithClass: (Class)class_
	request: (OFHTTPRequest*)request
	 result: (OFHTTPRequestResult*)result;

/**
 * \brief Returns the HTTP request which failed.
 *
 * \return The HTTP request which failed
 */
- (OFHTTPRequest*)request;

/**
 * \brief Returns the result of the failed HTTP request.
 *
 * \return The result of the failed HTTP request
 */
- (OFHTTPRequestResult*)result;
@end

Modified src/exceptions/OFHashAlreadyCalculatedException.h from [bffa480758] to [b8336f017c].

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
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







+
+


-
+





-
+









+
+




}

#ifdef OF_HAVE_PROPERTIES
@property (readonly, retain, nonatomic) OFHash *hashObject;
#endif

/**
 * \brief Creates a new, autoreleased hash already calculated exception.
 *
 * \param class_ The class of the object which caused the exception
 * \param hash The hash which has already been calculated
 * \return A new hash already calculated exception
 * \return A new, autoreleased hash already calculated exception
 */
+ (instancetype)exceptionWithClass: (Class)class_
			      hash: (OFHash*)hash;

/**
 * Initializes an already allocated hash already calculated exception.
 * \brief Initializes an already allocated hash already calculated exception.
 *
 * \param class_ The class of the object which caused the exception
 * \param hash The hash which has already been calculated
 * \return An initialized hash already calculated exception
 */
- initWithClass: (Class)class_
	   hash: (OFHash*)hash;

/**
 * \brief Returns the hash which has already been calculated.
 *
 * \return The hash which has already been calculated
 */
- (OFHash*)hashObject;
@end

Modified src/exceptions/OFInvalidArgumentException.h from [9262afb54a] to [99df6b70e6].

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
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







+
+


-
+





-
+









+
+




}

#ifdef OF_HAVE_PROPERTIES
@property (readonly) SEL selector;
#endif

/**
 * \brief Creates a new, autoreleased invalid argument exception.
 *
 * \param class_ The class of the object which caused the exception
 * \param selector The selector which doesn't accept the argument
 * \return A new invalid argument exception
 * \return A new, autoreleased invalid argument exception
 */
+ (instancetype)exceptionWithClass: (Class)class_
			  selector: (SEL)selector;

/**
 * Initializes an already allocated invalid argument exception
 * \brief Initializes an already allocated invalid argument exception.
 *
 * \param class_ The class of the object which caused the exception
 * \param selector The selector which doesn't accept the argument
 * \return An initialized invalid argument exception
 */
- initWithClass: (Class)class_
       selector: (SEL)selector;

/**
 * \brief Returns the selector to which an invalid argument was passed.
 *
 * \return The selector to which an invalid argument was passed
 */
- (SEL)selector;
@end

Modified src/exceptions/OFInvalidJSONException.h from [dd69569b81] to [1896fbbfc5].

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
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







+
+


-
+





-
+









+
+




}

#ifdef OF_HAVE_PROPERTIES
@property (readonly) size_t line;
#endif

/**
 * \brief Creates a new, autoreleased invalid JSON exception.
 *
 * \param class_ The class of the object which caused the exception
 * \param line The line in which the parsing error encountered
 * \return A new invalid JSON exception
 * \return A new, autoreleased invalid JSON exception
 */
+ (instancetype)exceptionWithClass: (Class)class_
			      line: (size_t)line;

/**
 * Initializes an already allocated invalid JSON exception.
 * \brief Initializes an already allocated invalid JSON exception.
 *
 * \param class_ The class of the object which caused the exception
 * \param line The line in which the parsing error encountered
 * \return An initialized invalid JSON exception
 */
- initWithClass: (Class)class_
	   line: (size_t)line;

/**
 * \brief Returns the line in which parsing the JSON representation failed.
 *
 * \return The line in which parsing the JSON representation failed
 */
- (size_t)line;
@end

Modified src/exceptions/OFLinkFailedException.h from [f106ab4027] to [e9e9edf9b6].

30
31
32
33
34
35
36


37
38
39
40

41
42
43
44
45
46
47

48
49
50
51
52
53
54
55
56
57
58


59
60
61
62
63


64
65
66
67
68


69
70
71
72
73
30
31
32
33
34
35
36
37
38
39
40
41

42
43
44
45
46
47
48

49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81







+
+



-
+






-
+











+
+





+
+





+
+





# ifdef OF_HAVE_PROPERTIES
@property (readonly, copy, nonatomic) OFString *sourcePath;
@property (readonly, copy, nonatomic) OFString *destinationPath;
@property (readonly) int errNo;
# endif

/**
 * \brief Creates a new, autoreleased link failed exception.
 *
 * \param class_ The class of the object which caused the exception
 * \param source The source for the link
 * \param destination The destination for the link
 * \return A new link failed exception
 * \return A new, autoreleased link failed exception
 */
+ (instancetype)exceptionWithClass: (Class)class_
			sourcePath: (OFString*)source
		   destinationPath: (OFString*)destination;

/**
 * Initializes an already allocated link failed exception.
 * \brief Initializes an already allocated link failed exception.
 *
 * \param class_ The class of the object which caused the exception
 * \param source The source for the link
 * \param destination The destination for the link
 * \return An initialized link failed exception
 */
-   initWithClass: (Class)class_
       sourcePath: (OFString*)source
  destinationPath: (OFString*)destination;

/**
 * \brief Returns the errno from when the exception was created.
 *
 * \return The errno from when the exception was created
 */
- (int)errNo;

/**
 * \brief Returns a string with the source for the link.
 *
 * \return A string with the source for the link
 */
- (OFString*)sourcePath;

/**
 * \brief Returns a string with the destination for the link.
 *
 * \return A string with the destination for the link
 */
- (OFString*)destinationPath;
@end
#endif

Modified src/exceptions/OFListenFailedException.h from [0ed7c6fb04] to [319d8e8c77].

31
32
33
34
35
36
37


38
39
40
41

42
43
44
45
46
47
48

49
50
51
52
53
54
55
56
57
58
59


60
61
62
63
64


65

66
67
68
69


70
71
72
73
31
32
33
34
35
36
37
38
39
40
41
42

43
44
45
46
47
48
49

50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70

71
72
73
74
75
76
77
78
79
80
81







+
+



-
+






-
+











+
+





+
+
-
+




+
+




#ifdef OF_HAVE_PROPERTIES
@property (readonly, retain, nonatomic) OFTCPSocket *socket;
@property (readonly) int backLog;
@property (readonly) int errNo;
#endif

/**
 * \brief Creates a new, autoreleased listen failed exception.
 *
 * \param class_ The class of the object which caused the exception
 * \param socket The socket which failed to listen
 * \param backlog The requested size of the back log
 * \return A new listen failed exception
 * \return A new, autoreleased listen failed exception
 */
+ (instancetype)exceptionWithClass: (Class)class_
			    socket: (OFTCPSocket*)socket
			   backLog: (int)backlog;

/**
 * Initializes an already allocated listen failed exception
 * \brief Initializes an already allocated listen failed exception
 *
 * \param class_ The class of the object which caused the exception
 * \param socket The socket which failed to listen
 * \param backlog The requested size of the back log
 * \return An initialized listen failed exception
 */
- initWithClass: (Class)class_
	 socket: (OFTCPSocket*)socket
	backLog: (int)backlog;

/**
 * \brief Returns the socket which failed to listen.
 *
 * \return The socket which failed to listen
 */
- (OFTCPSocket*)socket;

/**
 * \brief Returns the requested back log.
 *
 * \return The requested back log.
 * \return The requested back log
 */
- (int)backLog;

/**
 * \brief Returns the errno from when the exception was created.
 *
 * \return The errno from when the exception was created
 */
- (int)errNo;
@end

Modified src/exceptions/OFLockFailedException.h from [34551c1887] to [209deaacef].

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
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







+
+


-
+





-
+









+
+
-
+



}

#ifdef OF_HAVE_PROPERTIES
@property (readonly, retain, nonatomic) id <OFLocking> lock;
#endif

/**
 * \brief Creates a new, autoreleased lock failed exception.
 *
 * \param class_ The class of the object which caused the exception
 * \param lock The lock which could not be locked
 * \return A new lock failed exception
 * \return A new, autoreleased lock failed exception
 */
+ (instancetype)exceptionWithClass: (Class)class_
			      lock: (id <OFLocking>)lock;

/**
 * Initializes an already allocated lock failed exception.
 * \brief Initializes an already allocated lock failed exception.
 *
 * \param class_ The class of the object which caused the exception
 * \param lock The lock which could not be locked
 * \return An initialized lock failed exception
 */
- initWithClass: (Class)class_
	   lock: (id <OFLocking>)lock;

/**
 * \brief Returns the lock which could not be locked.
 *
 * \param The lock which could not be locked
 * \return The lock which could not be locked
 */
- (id <OFLocking>)lock;
@end

Modified src/exceptions/OFMalformedXMLException.h from [afc4e720c1] to [1d08e6da53].

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
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







+
+
+

-
+





-
+

+







+
+




}

#ifdef OF_HAVE_PROPERTIES
@property (readonly, retain, nonatomic) OFXMLParser *parser;
#endif

/**
 * \brief Creates a new, autoreleased malformed XML exception.
 *
 * \param class_ The class of the object which caused the exception
 * \param parser The parser which encountered malformed XML
 * \return A new malformed XML exception
 * \return A new, autoreleased malformed XML exception
 */
+ (instancetype)exceptionWithClass: (Class)class_
			    parser: (OFXMLParser*)parser;

/**
 * Initializes an already allocated malformed XML exception.
 * \brief Initializes an already allocated malformed XML exception.
 *
 * \param class_ The class of the object which caused the exception
 * \param parser The parser which encountered malformed XML
 * \return An initialized malformed XML exception
 */
- initWithClass: (Class)class_
	 parser: (OFXMLParser*)parser;

/**
 * \brief Returns the parser which encountered malformed XML.
 *
 * \return The parser which encountered malformed XML
 */
- (OFXMLParser*)parser;
@end

Modified src/exceptions/OFMemoryNotPartOfObjectException.h from [da2c12c442] to [2c57679bbf].

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
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







+
+


-
+





-
+









+
+




}

#ifdef OF_HAVE_PROPERTIES
@property (readonly) void *pointer;
#endif

/**
 * \brief Creates a new, autoreleased memory not part of object exception.
 *
 * \param class_ The class of the object which caused the exception
 * \param ptr A pointer to the memory that is not part of the object
 * \return A new memory not part of object exception
 * \return A new, autoreleased memory not part of object exception
 */
+ (instancetype)exceptionWithClass: (Class)class_
			   pointer: (void*)ptr;

/**
 * Initializes an already allocated memory not part of object exception.
 * \brief Initializes an already allocated memory not part of object exception.
 *
 * \param class_ The class of the object which caused the exception
 * \param ptr A pointer to the memory that is not part of the object
 * \return An initialized memory not part of object exception
 */
- initWithClass: (Class)class_
	pointer: (void*)ptr;

/**
 * \brief Returns a pointer to the memory which is not part of the object.
 *
 * \return A pointer to the memory which is not part of the object
 */
- (void*)pointer;
@end

Modified src/exceptions/OFNotConnectedException.h from [b592f8f4ca] to [59613be5ec].

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
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







+
+


-
+





-
+









+
+




}

#ifdef OF_HAVE_PROPERTIES
@property (readonly, retain, nonatomic) OFStreamSocket *socket;
#endif

/**
 * \brief Creates a new, autoreleased not connected exception.
 *
 * \param class_ The class of the object which caused the exception
 * \param socket The socket which is not connected
 * \return A new not connected exception
 * \return A new, autoreleased not connected exception
 */
+ (instancetype)exceptionWithClass: (Class)class_
			    socket: (OFStreamSocket*)socket;

/**
 * Initializes an already allocated not connected exception.
 * \brief Initializes an already allocated not connected exception.
 *
 * \param class_ The class of the object which caused the exception
 * \param socket The socket which is not connected
 * \return An initialized not connected exception
 */
- initWithClass: (Class)class_
	 socket: (OFStreamSocket*)socket;

/**
 * \brief Returns the socket which is not connected.
 *
 * \return The socket which is not connected
 */
- (OFStreamSocket*)socket;
@end

Modified src/exceptions/OFNotImplementedException.h from [8dd8831751] to [5a2811c535].

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
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







+
+


-
+





-
+









+
+




}

#ifdef OF_HAVE_PROPERTIES
@property (readonly) SEL selector;
#endif

/**
 * \brief Creates a new, autoreleased not implemented exception.
 *
 * \param class_ The class of the object which caused the exception
 * \param selector The selector which is not or not fully implemented
 * \return A new not implemented exception
 * \return A new, autoreleased not implemented exception
 */
+ (instancetype)exceptionWithClass: (Class)class_
			  selector: (SEL)selector;

/**
 * Initializes an already allocated not implemented exception.
 * \brief Initializes an already allocated not implemented exception.
 *
 * \param class_ The class of the object which caused the exception
 * \param selector The selector which is not or not fully implemented
 * \return An initialized not implemented exception
 */
- initWithClass: (Class)class_
       selector: (SEL)selector;

/**
 * \brief Returns the selector which is not or not fully implemented.
 *
 * \return The selector which is not or not fully implemented
 */
- (SEL)selector;
@end

Modified src/exceptions/OFOpenFileFailedException.h from [bbb3cac915] to [e8f32aea07].

29
30
31
32
33
34
35


36
37
38
39

40
41
42
43
44
45
46

47
48
49
50
51
52
53
54
55
56
57


58
59
60
61
62


63
64
65
66
67



68
69
70
71
29
30
31
32
33
34
35
36
37
38
39
40

41
42
43
44
45
46
47

48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80







+
+



-
+






-
+











+
+





+
+





+
+
+




#ifdef OF_HAVE_PROPERTIES
@property (readonly, copy, nonatomic) OFString *path;
@property (readonly, copy, nonatomic) OFString *mode;
@property (readonly) int errNo;
#endif

/**
 * \brief Creates a new, autoreleased open file failed exception.
 *
 * \param class_ The class of the object which caused the exception
 * \param path A string with the path of the file tried to open
 * \param mode A string with the mode in which the file should have been opened
 * \return A new open file failed exception
 * \return A new, autoreleased open file failed exception
 */
+ (instancetype)exceptionWithClass: (Class)class_
			      path: (OFString*)path
			      mode: (OFString*)mode;

/**
 * Initializes an already allocated open file failed exception.
 * \brief Initializes an already allocated open file failed exception.
 *
 * \param class_ The class of the object which caused the exception
 * \param path A string with the path of the file which couldn't be opened
 * \param mode A string with the mode in which the file should have been opened
 * \return An initialized open file failed exception
 */
- initWithClass: (Class)class_
	   path: (OFString*)path
	   mode: (OFString*)mode;

/**
 * \brief Returns the errno from when the exception was created.
 *
 * \return The errno from when the exception was created
 */
- (int)errNo;

/**
 * \brief Returns a string with the path of the file which couldn't be opened.
 *
 * \return A string with the path of the file which couldn't be opened
 */
- (OFString*)path;

/**
 * \brief Returns a string with the mode in which the file should have been
 *	  opened.
 *
 * \return A string with the mode in which the file should have been opened
 */
- (OFString*)mode;
@end

Modified src/exceptions/OFOutOfMemoryException.h from [3b65a6153f] to [0fd4b3d4d5].

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
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







+
+


-
+





-
+









+
+




}

#ifdef OF_HAVE_PROPERTIES
@property (readonly) size_t requestedSize;
#endif

/**
 * \brief Creates a new, autoreleased no memory exception.
 *
 * \param class_ The class of the object which caused the exception
 * \param size The size of the memory that couldn't be allocated
 * \return A new no memory exception
 * \return A new, autoreleased no memory exception
 */
+ (instancetype)exceptionWithClass: (Class)class_
		     requestedSize: (size_t)size;

/**
 * Initializes an already allocated no memory exception.
 * \brief Initializes an already allocated no memory exception.
 *
 * \param class_ The class of the object which caused the exception
 * \param size The size of the memory that couldn't be allocated
 * \return An initialized no memory exception
 */
- initWithClass: (Class)class_
  requestedSize: (size_t)size;

/**
 * \brief Returns the size of the memoory that couldn't be allocated.
 *
 * \return The size of the memoory that couldn't be allocated
 */
- (size_t)requestedSize;
@end

Modified src/exceptions/OFReadOrWriteFailedException.h from [f9eb7c2c4f] to [f7f6b96b66].

32
33
34
35
36
37
38


39
40
41
42
43

44
45
46
47
48
49
50

51
52
53
54
55
56
57
58
59
60
61
62


63
64
65
66
67



68
69
70
71
72


73
74
75
76
32
33
34
35
36
37
38
39
40
41
42
43
44

45
46
47
48
49
50
51

52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85







+
+




-
+






-
+












+
+





+
+
+





+
+




#ifdef OF_HAVE_PROPERTIES
@property (readonly, retain, nonatomic) OFStream *stream;
@property (readonly) size_t requestedLength;
@property (readonly) int errNo;
#endif

/**
 * \brief Creates a new, autoreleased read or write failed exception.
 *
 * \param class_ The class of the object which caused the exception
 * \param stream The stream which caused the read or write failed exception
 * \param length The requested length of the data that couldn't be read /
 *		 written
 * \return A new open file failed exception
 * \return A new, autoreleased read or write failed exception
 */
+ (instancetype)exceptionWithClass: (Class)class_
			    stream: (OFStream*)stream
		   requestedLength: (size_t)length;

/**
 * Initializes an already allocated read or write failed exception.
 * \brief Initializes an already allocated read or write failed exception.
 *
 * \param class_ The class of the object which caused the exception
 * \param stream The stream which caused the read or write failed exception
 * \param length The requested length of the data that couldn't be read /
 *		 written
 * \return A new open file failed exception
 */
-   initWithClass: (Class)class_
	   stream: (OFStream*)stream
  requestedLength: (size_t)length;

/**
 * \brief Returns the stream which caused the read or write failed exception.
 *
 * \return The stream which caused the read or write failed exception
 */
- (OFStream*)stream;

/**
 * \brief Returns the requested length of the data that couldn't be read /
 *	  written.
 *
 * \return The requested length of the data that couldn't be read / written
 */
- (size_t)requestedLength;

/**
 * \brief Returns the errno from when the exception was created.
 *
 * \return The errno from when the exception was created
 */
- (int)errNo;
@end

Modified src/exceptions/OFRenameFileFailedException.h from [d9ec20488f] to [3abdac8037].

29
30
31
32
33
34
35


36
37
38
39

40
41
42
43
44
45
46

47
48
49
50
51
52
53
54
55
56
57


58
59
60
61
62


63
64
65
66
67


68
69
70
71
29
30
31
32
33
34
35
36
37
38
39
40

41
42
43
44
45
46
47

48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79







+
+



-
+






-
+











+
+





+
+





+
+




#ifdef OF_HAVE_PROPERTIES
@property (readonly, copy, nonatomic) OFString *sourcePath;
@property (readonly, copy, nonatomic) OFString *destinationPath;
@property (readonly) int errNo;
#endif

/**
 * \brief Creates a new, autoreleased rename file failed exception.
 *
 * \param class_ The class of the object which caused the exception
 * \param source The original path
 * \param destination The new path
 * \return A new rename file failed exception
 * \return A new, autoreleased rename file failed exception
 */
+ (instancetype)exceptionWithClass: (Class)class_
			sourcePath: (OFString*)source
		   destinationPath: (OFString*)destination;

/**
 * Initializes an already allocated rename failed exception.
 * \brief Initializes an already allocated rename failed exception.
 *
 * \param class_ The class of the object which caused the exception
 * \param source The original path
 * \param destination The new path
 * \return An initialized rename file failed exception
 */
-   initWithClass: (Class)class_
       sourcePath: (OFString*)source
  destinationPath: (OFString*)destination;

/**
 * \brief Returns the errno from when the exception was created.
 *
 * \return The errno from when the exception was created
 */
- (int)errNo;

/**
 * \brief Returns the original path.
 *
 * \return The original path
 */
- (OFString*)sourcePath;

/**
 * \brief Returns the new path.
 *
 * \return The new path
 */
- (OFString*)destinationPath;
@end

Modified src/exceptions/OFSeekFailedException.h from [a7860b2a1b] to [fff3fa205d].

35
36
37
38
39
40
41



42
43
44
45

46
47
48
49
50
51
52
53

54

55
56
57
58
59
60
61
62
63
64
65


66
67
68
69
70


71
72
73
74
75


76
77
78
79
80


81
82
83
84
35
36
37
38
39
40
41
42
43
44
45
46
47

48
49
50
51
52
53
54
55

56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96







+
+
+



-
+







-
+

+











+
+





+
+





+
+





+
+




@property (readonly, retain, nonatomic) OFSeekableStream *stream;
@property (readonly) off_t offset;
@property (readonly) int whence;
@property (readonly) int errNo;
#endif

/**
 * \brief Creates a new, autoreleased seek failed exception.
 *
 * \param class_ The class of the object which caused the exception
 * \param stream The stream for which seeking failed
 * \param offset The offset to which seeking failed
 * \param whence To what the offset is relative
 * \return A new seek failed exception
 * \return A new, autoreleased seek failed exception
 */
+ (instancetype)exceptionWithClass: (Class)class_
			    stream: (OFSeekableStream*)stream
			    offset: (off_t)offset
			    whence: (int)whence;

/**
 * Initializes an already allocated seek failed exception.
 * \brief Initializes an already allocated seek failed exception.
 *
 * \param class_ The class of the object which caused the exception
 * \param stream The stream for which seeking failed
 * \param offset The offset to which seeking failed
 * \param whence To what the offset is relative
 * \return An initialized seek failed exception
 */
- initWithClass: (Class)class_
	 stream: (OFSeekableStream*)stream
	 offset: (off_t)offset
	 whence: (int)whence;

/**
 * \brief Returns the stream for which seeking failed.
 *
 * \return The stream for which seeking failed
 */
- (OFSeekableStream*)stream;

/**
 * \brief Returns the offset to which seeking failed.
 *
 * \return The offset to which seeking failed
 */
- (off_t)offset;

/**
 * \brief Returns to what the offset is relative.
 *
 * \return To what the offset is relative
 */
- (int)whence;

/**
 * \brief Returns the errno from when the exception was created.
 *
 * \return The errno from when the exception was created
 */
- (int)errNo;
@end

Modified src/exceptions/OFSetOptionFailedException.h from [3b6762b0cd] to [f353dc8cb7].

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
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







+
+
+

-
+





-
+

+







+
+




}

#ifdef OF_HAVE_PROPERTIES
@property (readonly, retain, nonatomic) OFStream *stream;
#endif

/**
 * \brief Creates a new, autoreleased set option failed exception.
 *
 * \param class_ The class of the object which caused the exception
 * \param stream The stream for which the option could not be set
 * \return A new set option failed exception
 * \return A new, autoreleased set option failed exception
 */
+ (instancetype)exceptionWithClass: (Class)class_
			    stream: (OFStream*)stream;

/**
 * Initializes an already allocated set option failed exception.
 * \brief Initializes an already allocated set option failed exception.
 *
 * \param class_ The class of the object which caused the exception
 * \param stream The stream for which the option could not be set
 * \return An initialized set option failed exception
 */
- initWithClass: (Class)class_
	 stream: (OFStream*)stream;

/**
 * \brief Returns the stream for which the option could not be set.
 *
 * \return The stream for which the option could not be set
 */
- (OFStream*)stream;
@end

Modified src/exceptions/OFStillLockedException.h from [da3d6698c1] to [4bd731ca9c].

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
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







+
+


-
+





-
+









+
+




}

#ifdef OF_HAVE_PROPERTIES
@property (readonly, retain, nonatomic) id <OFLocking> lock;
#endif

/**
 * \brief Creates a new, autoreleased still locked exception.
 *
 * \param class_ The class of the object which caused the exception
 * \param lock The lock which is still locked
 * \return A new still locked exception
 * \return A new, autoreleased still locked exception
 */
+ (instancetype)exceptionWithClass: (Class)class_
			      lock: (id <OFLocking>)lock;

/**
 * Initializes an already allocated still locked exception.
 * \brief Initializes an already allocated still locked exception.
 *
 * \param class_ The class of the object which caused the exception
 * \param lock The lock which is still locked
 * \return An initialized still locked exception
 */
- initWithClass: (Class)class_
	   lock: (id <OFLocking>)lock;

/**
 * \brief Returns the lock which is still locked.
 *
 * \return The lock which is still locked
 */
- (id <OFLocking>)lock;
@end

Modified src/exceptions/OFSymlinkFailedException.h from [2ddabcad84] to [fec9b21169].

30
31
32
33
34
35
36


37
38
39
40

41
42
43
44
45
46
47

48
49
50
51
52
53
54
55
56
57
58


59
60
61
62
63


64
65
66
67
68


69
70
71
72
73
30
31
32
33
34
35
36
37
38
39
40
41

42
43
44
45
46
47
48

49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81







+
+



-
+






-
+











+
+





+
+





+
+





#ifdef OF_HAVE_PROPERTIES
@property (readonly, copy, nonatomic) OFString *sourcePath;
@property (readonly, copy, nonatomic) OFString *destinationPath;
@property (readonly) int errNo;
#endif

/**
 * \brief Creates a new, autoreleased symlink failed exception.
 *
 * \param class_ The class of the object which caused the exception
 * \param source The source for the symlink
 * \param destination The destination for the symlink
 * \return A new symlink failed exception
 * \return A new, autoreleased symlink failed exception
 */
+ (instancetype)exceptionWithClass: (Class)class_
			sourcePath: (OFString*)source
		   destinationPath: (OFString*)destination;

/**
 * Initializes an already allocated symlink failed exception.
 * \brief Initializes an already allocated symlink failed exception.
 *
 * \param class_ The class of the object which caused the exception
 * \param source The source for the symlink
 * \param destination The destination for the symlink
 * \return An initialized symlink failed exception
 */
-   initWithClass: (Class)class_
       sourcePath: (OFString*)source
  destinationPath: (OFString*)destination;

/**
 * \brief Returns the errno from when the exception was created.
 *
 * \return The errno from when the exception was created
 */
- (int)errNo;

/**
 * \brief Returns a string with the source for the symlink.
 *
 * \return A string with the source for the symlink
 */
- (OFString*)sourcePath;

/**
 * \brief Returns a string with the destination for the symlink.
 *
 * \return A string with the destination for the symlink
 */
- (OFString*)destinationPath;
@end
#endif

Modified src/exceptions/OFThreadJoinFailedException.h from [cf2dc40e40] to [1b90b4ec97].

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
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







+
+


-
+





-
+









+
+




}

#ifdef OF_HAVE_PROPERTIES
@property (readonly, retain, nonatomic) OFThread *thread;
#endif

/**
 * \brief Creates a new, autoreleased thread join failed exception.
 *
 * \param class_ The class of the object which caused the exception
 * \param thread The thread which could not be joined
 * \return A new thread join failed exception
 * \return A new, autoreleased thread join failed exception
 */
+ (instancetype)exceptionWithClass: (Class)class_
			    thread: (OFThread*)thread;

/**
 * Initializes an already allocated thread join failed exception.
 * \brief Initializes an already allocated thread join failed exception.
 *
 * \param class_ The class of the object which caused the exception
 * \param thread The thread which could not be joined
 * \return An initialized thread join failed exception
 */
- initWithClass: (Class)class_
	 thread: (OFThread*)thread;

/**
 * \brief Returns the thread which could not be joined.
 *
 * \return The thread which could not be joined
 */
- (OFThread*)thread;
@end

Modified src/exceptions/OFThreadStartFailedException.h from [fdad7cfed9] to [96beeca7a8].

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
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







+
+


-
+





-
+









+
+




}

#ifdef OF_HAVE_PROPERTIES
@property (readonly, retain, nonatomic) OFThread *thread;
#endif

/**
 * \brief Creates a new, autoreleased thread start failed exception.
 *
 * \param class_ The class of the object which caused the exception
 * \param thread The thread which could not be started
 * \return An initialized thread start failed exception
 * \return A new, autoreleased thread start failed exception
 */
+ (instancetype)exceptionWithClass: (Class)class_
			    thread: (OFThread*)thread;

/**
 * Initializes an already allocated thread start failed exception.
 * \brief Initializes an already allocated thread start failed exception.
 *
 * \param class_ The class of the object which caused the exception
 * \param thread The thread which could not be started
 * \return An initialized thread start failed exception
 */
- initWithClass: (Class)class_
	 thread: (OFThread*)thread;

/**
 * \brief Returns the thread which could not be started.
 *
 * \return The thread which could not be started
 */
- (OFThread*)thread;
@end

Modified src/exceptions/OFThreadStillRunningException.h from [306bedb437] to [d6ab0f1cee].

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
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







+
+


-
+





-
+









+
+




}

#ifdef OF_HAVE_PROPERTIES
@property (readonly, retain, nonatomic) OFThread *thread;
#endif

/**
 * \brief Creates a new, autoreleased thread still running exception.
 *
 * \param class_ The class of the object which caused the exception
 * \param thread The thread which is still running
 * \return A new thread still running exception
 * \return A new, autoreleased thread still running exception
 */
+ (instancetype)exceptionWithClass: (Class)class_
			    thread: (OFThread*)thread;

/**
 * Initializes an already allocated thread still running exception.
 * \brief Initializes an already allocated thread still running exception.
 *
 * \param class_ The class of the object which caused the exception
 * \param thread The thread which is still running
 * \return An initialized thread still running exception
 */
- initWithClass: (Class)class_
	 thread: (OFThread*)thread;

/**
 * \brief Returns the thread which is still running.
 *
 * \return The thread which is still running
 */
- (OFThread*)thread;
@end

Modified src/exceptions/OFUnboundNamespaceException.h from [d127c108c6] to [f9012f2216].

27
28
29
30
31
32
33


34
35
36

37
38
39
40
41


42
43
44

45
46
47
48
49
50

51
52
53
54
55
56
57
58
59
60

61
62
63
64
65
66
67
68
69


70
71
72
73
74


75
76
77
78
27
28
29
30
31
32
33
34
35
36
37

38
39
40
41
42
43
44
45
46
47

48
49
50
51
52
53

54
55
56
57
58
59
60
61
62
63

64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86







+
+


-
+





+
+


-
+





-
+









-
+









+
+





+
+





#ifdef OF_HAVE_PROPERTIES
@property (readonly, copy, nonatomic, getter=namespace) OFString *ns;
@property (readonly, copy, nonatomic) OFString *prefix;
#endif

/**
 * \brief Creates a new, autoreleased unbound namespace exception.
 *
 * \param class_ The class of the object which caused the exception
 * \param ns The namespace which is unbound
 * \return A new unbound namespace exception
 * \return A new, autoreleased unbound namespace exception
 */
+ (instancetype)exceptionWithClass: (Class)class_
			 namespace: (OFString*)ns;

/**
 * \brief Creates a new, autoreleased unbound namespace exception.
 *
 * \param class_ The class of the object which caused the exception
 * \param prefix The prefix which is unbound
 * \return A new unbound namespace exception
 * \return A new, autoreleased unbound namespace exception
 */
+ (instancetype)exceptionWithClass: (Class)class_
			    prefix: (OFString*)prefix;

/**
 * Initializes an already allocated unbound namespace exception
 * \brief Initializes an already allocated unbound namespace exception.
 *
 * \param class_ The class of the object which caused the exception
 * \param ns The namespace which is unbound
 * \return An initialized unbound namespace exception
 */
- initWithClass: (Class)class_
      namespace: (OFString*)ns;

/**
 * Initializes an already allocated unbound namespace exception
 * \brief Initializes an already allocated unbound namespace exception.
 *
 * \param class_ The class of the object which caused the exception
 * \param prefix The prefix which is unbound
 * \return An initialized unbound namespace exception
 */
- initWithClass: (Class)class_
	 prefix: (OFString*)prefix;

/**
 * \brief Returns the unbound namespace.
 *
 * \return The unbound namespace
 */
- (OFString*)namespace;

/**
 * \brief Returns the unbound prefix.
 *
 * \return The unbound prefix
 */
- (OFString*)prefix;
@end

Modified src/exceptions/OFUnlockFailedException.h from [7d2a66af7c] to [01fd3111fd].

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
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







+
+


-
+





-
+









+
+




}

#ifdef OF_HAVE_PROPERTIES
@property (readonly, retain, nonatomic) id <OFLocking> lock;
#endif

/**
 * \brief Creates a new, autoreleased unlock failed exception.
 *
 * \param class_ The class of the object which caused the exception
 * \param lock The lock which could not be unlocked
 * \return A new unlock failed exception
 * \return A new, autoreleased unlock failed exception
 */
+ (instancetype)exceptionWithClass: (Class)class_
			      lock: (id <OFLocking>)lock;

/**
 * Initializes an already allocated unlock failed exception.
 * \brief Initializes an already allocated unlock failed exception.
 *
 * \param class_ The class of the object which caused the exception
 * \param lock The lock which could not be unlocked
 * \return An initialized unlock failed exception
 */
- initWithClass: (Class)class_
	   lock: (id <OFLocking>)lock;

/**
 * \brief Returns the lock which could not be unlocked.
 *
 * \return The lock which could not be unlocked
 */
- (id <OFLocking>)lock;
@end

Modified src/exceptions/OFUnsupportedProtocolException.h from [6c4ace59cb] to [d768ed8ee1].

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
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







+
+


-
+





-
+









+
+




}

#ifdef OF_HAVE_PROPERTIES
@property (readonly, retain, nonatomic) OFURL *URL;
#endif

/**
 * \brief Creates a new, autoreleased unsupported protocol exception.
 *
 * \param class_ The class of the object which caused the exception
 * \param url The URL whose protocol is unsupported
 * \return A new unsupported protocol exception
 * \return A new, autoreleased unsupported protocol exception
 */
+ (instancetype)exceptionWithClass: (Class)class_
			       URL: (OFURL*)url;

/**
 * Initializes an already allocated unsupported protocol exception
 * \brief Initializes an already allocated unsupported protocol exception
 *
 * \param class_ The class of the object which caused the exception
 * \param url The URL whose protocol is unsupported
 * \return An initialized unsupported protocol exception
 */
- initWithClass: (Class)class_
	    URL: (OFURL*)url;

/**
 * \brief Returns the URL whose protocol is unsupported.
 *
 * \return The URL whose protocol is unsupported
 */
- (OFURL*)URL;
@end

Modified src/exceptions/OFUnsupportedVersionException.h from [1c4d087ca0] to [538dcc03da].

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
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







+
+


-
+





-
+









+
+




}

#ifdef OF_HAVE_PROPERTIES
@property (readonly, copy, nonatomic) OFString *version;
#endif

/**
 * \brief Creates a new, autoreleased unsupported version exception.
 *
 * \param class_ The class of the object which caused the exception
 * \param version The version which is unsupported
 * \return A new unsupported version exception
 * \return A new, autoreleased unsupported version exception
 */
+ (instancetype)exceptionWithClass: (Class)class_
			   version: (OFString*)version;

/**
 * Initializes an already allocated unsupported protocol exception
 * \brief Initializes an already allocated unsupported protocol exception.
 *
 * \param class_ The class of the object which caused the exception
 * \param version The version which is unsupported
 * \return An initialized unsupported version exception
 */
- initWithClass: (Class)class_
	version: (OFString*)version;

/**
 * \brief Returns the version which is unsupported.
 *
 * \return The version which is unsupported
 */
- (OFString*)version;
@end

Modified src/runtime/class.m from [cde4d41e21] to [2c7fbf6833].

350
351
352
353
354
355
356
357

358
359
360
361
362
363
364
350
351
352
353
354
355
356

357
358
359
360
361
362
363
364







-
+








			if (load_queue == NULL)
				OBJC_ERROR("Not enough memory for load queue!");
		}
	}
}

inline Class
Class
objc_lookup_class(const char *name)
{
	Class cls = objc_classname_to_class(name);

	if (cls == NULL)
		return Nil;

Modified src/runtime/runtime.h from [995079990b] to [865d6eebac].

181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
181
182
183
184
185
186
187


188
189
190
191
192
193
194







-
-







extern IMP class_replaceMethod(Class, SEL, IMP, const char*);
extern const char* objc_get_type_encoding(Class, SEL);
extern IMP objc_msg_lookup(id, SEL);
extern IMP objc_msg_lookup_super(struct objc_super*, SEL);
extern const char* protocol_getName(Protocol*);
extern BOOL protocol_isEqual(Protocol*, Protocol*);
extern BOOL protocol_conformsToProtocol(Protocol*, Protocol*);
extern void objc_thread_add(void);
extern void objc_thread_remove(void);
extern void objc_exit(void);
extern objc_uncaught_exception_handler objc_setUncaughtExceptionHandler(
    objc_uncaught_exception_handler);
extern IMP (*objc_forward_handler)(id, SEL);
extern id objc_constructInstance(Class, void*);
extern void* objc_destructInstance(id);
extern id objc_autorelease(id);