ObjFW  History of src/OFStream.h of 9808f35fb3869d28

This allows for a much cleaner solution to avoid the internal read
buffer of e.g. a TLS connection never being processed while waiting for
a delimiter. file: [bdf949a291] check-in: [a61e0594b4] user: js, branch: trunk, size: 51698 [annotate] [blame] [check-ins using] [diff]

Those are never used in practice. file: [d8c22a2ea2] check-in: [808601a0cc] user: js, branch: trunk, size: 43637 [annotate] [blame] [check-ins using] [diff]

The old write API made it too easy to lose bytes when a stream is set to
non-blocking mode. The new API always throws when not all bytes were
written, which forces handling the number of bytes being written being
smaller than the number of bytes requested to be written. file: [0bf8c49ae4] check-in: [d1d36ae522] user: js, branch: trunk, size: 52835 [annotate] [blame] [check-ins using] [diff]

This is only migrating some places, others will be migrated as they are
touched. file: [7fe1e202cf] check-in: [a0fd103a0b] user: js, branch: trunk, size: 51472 [annotate] [blame] [check-ins using] [diff]

__COUNTER__ does not exist in GCC 4.2, and Apple GCC 4.2 is still the
newest compiler available for macOS 10.5. file: [8fe05ff320] check-in: [ef614a225d] user: js, branch: trunk, size: 51665 [annotate] [blame] [check-ins using] [diff]

Arguments that can just be captured by the block don't need to be
repeated as an argument. A lot of arguments passed to a delegate are
therefore not needed for a block. file: [854f995c5b] check-in: [d7ddb3dbc7] user: js, branch: trunk, size: 51753 [annotate] [blame] [check-ins using] [diff]

This is intended for SCTP and SPX. file: [190450d179] check-in: [e5b2ee56ff] user: js, branch: trunk, size: 52150 [annotate] [blame] [check-ins using] [diff]

This allows ABI stability with the fragile ABI. file: [a643169c96] check-in: [496695d778] user: js, branch: trunk, size: 51523 [annotate] [blame] [check-ins using] [diff]

This avoids the entire problem of keeping the buffer alive until the
send finished. file: [123c708db9] check-in: [0f3ae90eef] user: js, branch: trunk, size: 51598 [annotate] [blame] [check-ins using] [diff]

This avoids the entire problem of keeping the buffer alive until the
write finished. file: [a9818d561e] check-in: [f218986f51] user: js, branch: trunk, size: 46548 [annotate] [blame] [check-ins using] [diff]

Otherwise, there would be two methods for every operation: One for
success and one for failure. It also makes it easy to forget about
handling failure, so it's better to always pass an optional exception. file: [ba57cd6e80] check-in: [064dbe5127] user: js, branch: trunk, size: 47916 [annotate] [blame] [check-ins using] [diff]

The target / selector approach had several drawbacks:

* It was inconvenient to use, as for every read or write, a target,
selector and context would need to be specified.
* It lacked any kind of type-safety and would not even warn about using
a callback method with the wrong number of parameters.
* It encouraged using a different callback method for each read or
write call, which results in code that is hard to follow and also
slower (as it needs to recreate the async operation with a new
callback every time). file: [aea2292c00] check-in: [d16ad96cbd] user: js, branch: trunk, size: 47919 [annotate] [blame] [check-ins using] [diff]

This is in preparation for removing the body from OFHTTPRequest.
Having it as OFData that is part of the OFHTTPRequest was a bad idea, as
it does not allow streaming. file: [99b8fab82d] check-in: [8681bba25e] user: js, branch: trunk, size: 41706 [annotate] [blame] [check-ins using] [diff]

Instead of letting OFStream conform to it, which itself does not really
conform to it, let all the subclasses that actually do conform to it. file: [cfa0bd1248] check-in: [69749b6a5b] user: js, branch: trunk, size: 41569 [annotate] [blame] [check-ins using] [diff]

This improves Swift compatibility. file: [7eb7553262] check-in: [f3ccf14461] user: js, branch: trunk, size: 42215 [annotate] [blame] [check-ins using] [diff]

This allows performing another write with the same buffer, length and
callback, which is useful for asynchronously writing in chunks. file: [7472119df2] check-in: [47db5636d7] user: js, branch: trunk, size: 41700 [annotate] [blame] [check-ins using] [diff]

Casts are now written like types in variable declarations. file: [dce22ba2cb] check-in: [4af49a13c3] user: js, branch: trunk, size: 39288 [annotate] [blame] [check-ins using] [diff]

Forgot to add 2017, even though I already did quite some changes in
2017. file: [2a211758fc] check-in: [44f45c2e35] user: js, branch: trunk, size: 39564 [annotate] [blame] [check-ins using] [diff]

Right now, this is only useful for OFTCPSocket, as this is the only
class so far not establishing the stream in the init method. However,
this adds the general infrastructure to allow reuse to all subclasses of
OFStream. file: [c3708c076a] check-in: [1de551cb5f] user: js, branch: trunk, size: 39558 [annotate] [blame] [check-ins using] [diff]

In some situations, this is 50x faster. file: [f5d7e92017] check-in: [a7d66e7ab2] user: js, branch: trunk, size: 39462 [annotate] [blame] [check-ins using] [diff]

While at it, also update the mail address. file: [01d31991cc] check-in: [cec0f072f8] user: js, branch: 0.8, size: 39587 [annotate] [blame] [check-ins using] [diff]

While at it, also update the mail address. file: [87f1020ea1] check-in: [2a27cf3000] user: js, branch: trunk, size: 39442 [annotate] [blame] [check-ins using] [diff]

This increases the required GCC version from 4.0 to 4.6 (exception:
Apple GCC, which already supports this with >= 4.0 starting with OS X
10.5). Since even GCC 4.6 is really old by now, there is no point in
still supporting something even older and making the code ugly because
of that. While some hardware and OS support was dropped from GCC 4.6
compared to GCC 4.0, there is nothing in there that would be an
interesting target with the exception of BeOS maybe - but a port to BeOS
can also be achieved using the Haiku support. The other dropped OSes are
mostly old versions of OSes while newer ones are still being supported
(and those newer versions of those OSes still support the same
hardware). file: [ceee33b1c7] check-in: [48980f2297] user: js, branch: trunk, size: 39438 [annotate] [blame] [check-ins using] [diff]

Now that Clang switched to use _Nullable and _Nonnull instead of
__nullable / __nonnull, there is no longer a conflict with glibc, which
means we can just define _Nullable / _Nonnull to nothing if they are not
understood by the compiler (which did not work with __nullable /
__nonnull due to this conflict).

This also defines _Null_unspecified to nothing if unavailable. file: [4dfb1471ce] check-in: [d526d938d7] user: js, branch: trunk, size: 39577 [annotate] [blame] [check-ins using] [diff]

Using __nonnull directly doesn't work on systems using glibc, as glibc
defines __nonnull as a parameterized define. While this does not fix the
problem of Clang introducing __nonnull even though it conflicts with
glibc, this at least means it's possible again to compile things with
versions of Clang that don't support __nonnull on systems with glibc. file: [66ebb7f50c] check-in: [b7097a67b6] user: js, branch: trunk, size: 39583 [annotate] [blame] [check-ins using] [diff]

This prevents reading old data when closing and reconnecting the socket. file: [58a6fa04a7] check-in: [c6a4b0a95f] user: js, branch: trunk, size: 39395 [annotate] [blame] [check-ins using] [diff]

This replaces -[numberOfBytesInReadBuffer], as it's not always known how
many bytes there are exactly and thus the number would often be wrong
(e.g. because data is compressed). file: [10f43f7343] check-in: [acc999a75e] user: js, branch: trunk, size: 39343 [annotate] [blame] [check-ins using] [diff]

It is no longer limited to streams now. file: [f656291875] check-in: [c694569d86] user: js, branch: trunk, size: 38832 [annotate] [blame] [check-ins using] [diff]

This reverts 2943b43. It turned out that using %C and %S is possible,
even when mixing code with Cocoa code, as it is possible to introduce
__attribute__((format(__OFString__, ...))) to Clang which just handles
%C and %S as being of_unichar_t instead of unichar like they are handled
for __attribute__((format(__NSString__, ...))).

The Clang patch for __attribute__((format(__OFString__, ...))) has been
submitted, but is not upstream yet, thus the changes for that are not
being committed yet. file: [af49de697f] check-in: [4b56450a24] user: js, branch: trunk, size: 37660 [annotate] [blame] [check-ins using] [diff]

%K is for const of_unichar_t*. file: [a037efd8d4] check-in: [945ff1043d] user: js, branch: trunk, size: 37660 [annotate] [blame] [check-ins using] [diff]

In Cocoa, %C means unichar, which is unsigned short and thus compilers
expect %C to be unichar when the language is set to ObjC. It would be
hard to let compilers detect whether %C should be unichar or
of_unichar_t, especially when mixing ObjFW and Cocoa code, thus the
change to %k. file: [72c5abcbb8] check-in: [5eada9f7b0] user: js, branch: trunk, size: 37604 [annotate] [blame] [check-ins using] [diff]

No compression support yet, only decompression.

Decompression speed is acceptable for productive use, but there is still
a lot of room for optimization as this is a very straightforward
implementation without much optimization. file: [e0f5011968] check-in: [d83d3aa719] user: js, branch: trunk, size: 37556 [annotate] [blame] [check-ins using] [diff]

It is now called -[readDataArrayWithCount:]. file: [27c14268e9] check-in: [eceebefeab] user: js, branch: trunk, size: 36549 [annotate] [blame] [check-ins using] [diff]

This also removes "bool *stop" from some blocks where it does not make
sense. file: [05795f4687] check-in: [e8473b9db8] user: js, branch: trunk, size: 36418 [annotate] [blame] [check-ins using] [diff]

The only places where BOOL is left are those where they are required by
the ABI. file: [d1cbeea7d2] check-in: [c5ef582958] user: js, branch: trunk, size: 35612 [annotate] [blame] [check-ins using] [diff]

It is now called -[numberOfBytesInReadBuffer].

Additionally, this commit renames OFStream's _cache to _readBuffer. file: [74effa40b4] check-in: [efe7be259d] user: js, branch: trunk, size: 35572 [annotate] [blame] [check-ins using] [diff]

-[setBlocking:] correctly works for unidirectional streams now. file: [6b4f15f3b1] check-in: [436f274d65] user: js, branch: trunk, size: 35560 [annotate] [blame] [check-ins using] [diff]

This also renames the getter to -[isWriteBufferEnabled]. file: [79e322d7a8] check-in: [b96b150ce3] user: js, branch: trunk, size: 35568 [annotate] [blame] [check-ins using] [diff]

It is now -[write*:encoding:]. file: [7c8c68988a] check-in: [5405bd5c5f] user: js, branch: trunk, size: 35501 [annotate] [blame] [check-ins using] [diff]

This makes it possible to handle exceptions that occurred during async
I/O in the specified handler. file: [6c1eafc699] check-in: [6343e04dcd] user: js, branch: trunk, size: 34683 [annotate] [blame] [check-ins using] [diff]

Async connecting is still missing. file: [8627416ee2] check-in: [4d9a641d87] user: js, branch: trunk, size: 34418 [annotate] [blame] [check-ins using] [diff]

It is now -[fileDescriptorForReading] and -[fileDescriptorForWriting].
The split was necessary as some stream types (e.g. OFProcess) don't have
a single file descriptor, but two. This allows to use those stream types
with OFStreamObserver as well. file: [fb448f8379] check-in: [440e95fd4a] user: js, branch: trunk, size: 26216 [annotate] [blame] [check-ins using] [diff]

This makes it impossible for the developer to accidentally create a DoS.
When data has been received after calling -[tryReadLine] and the string
is still incomplete, -[streamIsReadyForReading:] will not be called
anymore until new data has been received, thus preventing spinning in a
loop. file: [3697389637] check-in: [535c2d5d9b] user: js, branch: trunk, size: 25173 [annotate] [blame] [check-ins using] [diff]

This way, the method to determine whether OFStreamSocket should
call the delegate can be overriden by subclasses, for example
for SSL sockets. file: [30f45428be] check-in: [f4151a36e3] user: js, branch: trunk, size: 9698 [annotate] [blame] [check-ins using] [diff]

It also looks at the cache of each stream now and does not block if
there is still data in the cache. file: [dd21d0d02a] check-in: [b554732eae] user: js, branch: trunk, size: 8577 [annotate] [blame] [check-ins using] [diff]

ivars are now named like this: thisIsAnIVar. If an accessor exists for
the ivar, the ivar is named like the accessor. This is required for
@property to work. file: [a95808e9fd] check-in: [37db8f0fb3] user: js, branch: trunk, size: 7415 [annotate] [blame] [check-ins using] [diff]

Endianess, size etc. may differ from system to system. While this might
be ok when writing files that are only read local again, this is
definitely not ok with sockets. So it's better to remove it from the
OFStream protocol. file: [1921fa4c55] check-in: [70874cf3c5] user: js, branch: trunk, size: 1464 [annotate] [blame] [check-ins using] [diff]