ObjFW  Check-in [c5c17fdd30]

{
	@throw [OFNotImplementedException newWithClass: isa
					      selector: _cmd];
}

- seekToOffset: (off_t)offset
{
	[self flushWriteCache];
	[self flushWriteBuffer];
	[self _seekToOffset: offset];

	[self freeMemory: cache];
	cache = NULL;
	cache_len = 0;

	return self;
}

- (off_t)seekForwardWithOffset: (off_t)offset
{
	off_t ret;

	[self flushWriteCache];
	[self flushWriteBuffer];
	ret = [self _seekForwardWithOffset: offset - cache_len];

	[self freeMemory: cache];
	cache = NULL;
	cache_len = 0;

	return ret;
}

- (off_t)seekToOffsetRelativeToEnd: (off_t)offset
{
	off_t ret;

	[self flushWriteCache];
	[self flushWriteBuffer];
	ret = [self _seekToOffsetRelativeToEnd: offset];

	[self freeMemory: cache];
	cache = NULL;
	cache_len = 0;

	return ret;
}
@end

 * _writeNBytes:fromBuffer: and _atEndOfStream, but nothing else. Those are not
 * defined in the headers, but do the actual work. OFStream uses those and does
 * all the caching and other stuff. If you override these methods without the
 * _ prefix, you *WILL* break caching and get broken results!
 */
@interface OFStream: OFObject
{
	char   *cache, *wcache;
	size_t cache_len, wcache_len;
	BOOL   use_wcache;
	char   *cache, *wbuffer;
	size_t cache_len, wbuffer_len;
	BOOL   use_wbuffer;
}

/**
 * Returns a boolean whether the end of the stream has been reached.
 *
 * \return A boolean whether the end of the stream has been reached
 */

 * \return The line that was read, autoreleased, or nil if the end of the
 *	   stream has been reached.
 */
- (OFString*)readTillDelimiter: (OFString*)delimiter
		  withEncoding: (enum of_string_encoding)encoding;

/**
 * Caches all writes until flushWriteCache is called.
 * Buffer all writes until flushWriteBuffer is called.
 */
- cacheWrites;
- bufferWrites;

/**
 * Writes everything in the write cache to the stream.
 */
- flushWriteCache;
- flushWriteBuffer;

/**
 * Writes from a buffer into the stream.
 *
 * \param buf The buffer from which the data is written to the stream
 * \param size The size of the data that should be written
 * \return The number of bytes written

	self = [super init];

	if (isa == [OFStream class])
		@throw [OFNotImplementedException newWithClass: isa
						      selector: _cmd];

	cache = NULL;
	wcache = NULL;
	wbuffer = NULL;

	return self;
}

- (BOOL)_atEndOfStream
{
	@throw [OFNotImplementedException newWithClass: isa

		[self freeMemory: tmp];
	}

	/* Get rid of a warning, never reached anyway */
	assert(0);
}

- cacheWrites
- bufferWrites
{
	use_wcache = YES;
	use_wbuffer = YES;

	return self;
}

- flushWriteCache
- flushWriteBuffer
{
	if (wcache == NULL)
	if (wbuffer == NULL)
		return self;

	[self _writeNBytes: wcache_len
		fromBuffer: wcache];
	[self _writeNBytes: wbuffer_len
		fromBuffer: wbuffer];

	[self freeMemory: wcache];
	wcache = NULL;
	wcache_len = 0;
	use_wcache = NO;
	[self freeMemory: wbuffer];
	wbuffer = NULL;
	wbuffer_len = 0;
	use_wbuffer = NO;

	return self;
}

- (size_t)writeNBytes: (size_t)size
	   fromBuffer: (const char*)buf
{
	if (!use_wcache)
	if (!use_wbuffer)
		return [self _writeNBytes: size
			       fromBuffer: buf];
	else {
		wcache = [self resizeMemory: wcache
				     toSize: wcache_len + size];
		memcpy(wcache + wcache_len, buf, size);
		wcache_len += size;
		wbuffer = [self resizeMemory: wbuffer
				      toSize: wbuffer_len + size];
		memcpy(wbuffer + wbuffer_len, buf, size);
		wbuffer_len += size;

		return size;
	}
}

- (void)writeInt8: (uint8_t)int8
{