OFStream.h

Go to the documentation of this file.

/*
 * Copyright (c) 2008, 2009, 2010, 2011, 2012, 2013, 2014, 2015, 2016, 2017
 *   Jonathan Schleifer <js@heap.zone>
 *
 * All rights reserved.
 *
 * This file is part of ObjFW. It may be distributed under the terms of the
 * Q Public License 1.0, which can be found in the file LICENSE.QPL included in
 * the packaging of this file.
 *
 * Alternatively, it may be distributed under the terms of the GNU General
 * Public License, either version 2 or 3, which can be found in the file
 * LICENSE.GPLv2 or LICENSE.GPLv3 respectively included in the packaging of this
 * file.
 */

#ifndef __STDC_LIMIT_MACROS
# define __STDC_LIMIT_MACROS
#endif
#ifndef __STDC_CONSTANT_MACROS
# define __STDC_CONSTANT_MACROS
#endif

#include <stdarg.h>

#import "OFObject.h"
#import "OFString.h"
#ifdef OF_HAVE_SOCKETS
# import "OFKernelEventObserver.h"
#endif

OF_ASSUME_NONNULL_BEGIN

@class OFStream;
@class OFData;
@class OFException;

#if defined(OF_HAVE_SOCKETS) && defined(OF_HAVE_BLOCKS)

typedef bool (^of_stream_async_read_block_t)(OFStream *stream, void *buffer,
    size_t length, OFException *_Nullable exception);

typedef bool (^of_stream_async_read_line_block_t)(OFStream *stream,
    OFString *_Nullable line, OFException *_Nullable exception);
#endif

@interface OFStream: OFObject <
#ifdef OF_HAVE_SOCKETS
    OFReadyForReadingObserving, OFReadyForWritingObserving,
#endif
    OFCopying>
{
#if !defined(OF_SEEKABLE_STREAM_M) && !defined(OF_TCP_SOCKET_M)
@private
#endif
    char *_Nullable _readBuffer, *_Nullable _readBufferMemory;
    char *_Nullable _writeBuffer;
    size_t _readBufferLength, _writeBufferLength;
    bool _writeBuffered, _waitingForDelimiter;
@protected
    bool _blocking;
}

- (bool)isAtEndOfStream;

- (size_t)readIntoBuffer: (void *)buffer
          length: (size_t)length;

 - (void)readIntoBuffer: (void *)buffer
        exactLength: (size_t)length;

#ifdef OF_HAVE_SOCKETS

- (void)asyncReadIntoBuffer: (void *)buffer
             length: (size_t)length
             target: (id)target
           selector: (SEL)selector;

- (void)asyncReadIntoBuffer: (void *)buffer
        exactLength: (size_t)length
             target: (id)target
           selector: (SEL)selector;

# ifdef OF_HAVE_BLOCKS

- (void)asyncReadIntoBuffer: (void *)buffer
             length: (size_t)length
              block: (of_stream_async_read_block_t)block;

 - (void)asyncReadIntoBuffer: (void *)buffer
         exactLength: (size_t)length
               block: (of_stream_async_read_block_t)block;
# endif
#endif

- (uint8_t)readInt8;

- (uint16_t)readBigEndianInt16;

- (uint32_t)readBigEndianInt32;

- (uint64_t)readBigEndianInt64;

- (float)readBigEndianFloat;

- (double)readBigEndianDouble;

- (size_t)readBigEndianInt16sIntoBuffer: (uint16_t *)buffer
                  count: (size_t)count;

- (size_t)readBigEndianInt32sIntoBuffer: (uint32_t *)buffer
                  count: (size_t)count;

- (size_t)readBigEndianInt64sIntoBuffer: (uint64_t *)buffer
                  count: (size_t)count;

- (size_t)readBigEndianFloatsIntoBuffer: (float *)buffer
                  count: (size_t)count;

- (size_t)readBigEndianDoublesIntoBuffer: (double *)buffer
                   count: (size_t)count;

- (uint16_t)readLittleEndianInt16;

- (uint32_t)readLittleEndianInt32;

- (uint64_t)readLittleEndianInt64;

- (float)readLittleEndianFloat;

- (double)readLittleEndianDouble;

- (size_t)readLittleEndianInt16sIntoBuffer: (uint16_t *)buffer
                     count: (size_t)count;

- (size_t)readLittleEndianInt32sIntoBuffer: (uint32_t *)buffer
                     count: (size_t)count;

- (size_t)readLittleEndianInt64sIntoBuffer: (uint64_t *)buffer
                     count: (size_t)count;

- (size_t)readLittleEndianFloatsIntoBuffer: (float *)buffer
                     count: (size_t)count;

- (size_t)readLittleEndianDoublesIntoBuffer: (double *)buffer
                      count: (size_t)count;

- (OFData *)readDataWithCount: (size_t)count;

- (OFData *)readDataWithItemSize: (size_t)itemSize
               count: (size_t)count;

- (OFData *)readDataUntilEndOfStream;

- (OFString *)readStringWithLength: (size_t)length;

- (OFString *)readStringWithLength: (size_t)length
              encoding: (of_string_encoding_t)encoding;

- (nullable OFString *)readLine;

- (nullable OFString *)readLineWithEncoding: (of_string_encoding_t)encoding;

#ifdef OF_HAVE_SOCKETS

- (void)asyncReadLineWithTarget: (id)target
               selector: (SEL)selector;

- (void)asyncReadLineWithEncoding: (of_string_encoding_t)encoding
               target: (id)target
             selector: (SEL)selector;

# ifdef OF_HAVE_BLOCKS

- (void)asyncReadLineWithBlock: (of_stream_async_read_line_block_t)block;

- (void)asyncReadLineWithEncoding: (of_string_encoding_t)encoding
                block: (of_stream_async_read_line_block_t)block;
# endif
#endif

- (nullable OFString *)tryReadLine;

- (nullable OFString *)tryReadLineWithEncoding: (of_string_encoding_t)encoding;

- (nullable OFString *)readTillDelimiter: (OFString *)delimiter;

- (nullable OFString *)readTillDelimiter: (OFString *)delimiter
                encoding: (of_string_encoding_t)encoding;

- (nullable OFString *)tryReadTillDelimiter: (OFString *)delimiter;

- (nullable OFString *)tryReadTillDelimiter: (OFString *)delimiter
                   encoding: (of_string_encoding_t)encoding;

- (bool)isWriteBuffered;

- (void)setWriteBuffered: (bool)enable;

- (void)flushWriteBuffer;

- (void)writeBuffer: (const void *)buffer
         length: (size_t)length;

- (void)writeInt8: (uint8_t)int8;

- (void)writeBigEndianInt16: (uint16_t)int16;

- (void)writeBigEndianInt32: (uint32_t)int32;

- (void)writeBigEndianInt64: (uint64_t)int64;

- (void)writeBigEndianFloat: (float)float_;

- (void)writeBigEndianDouble: (double)double_;

- (size_t)writeBigEndianInt16s: (const uint16_t *)buffer
             count: (size_t)count;

- (size_t)writeBigEndianInt32s: (const uint32_t *)buffer
             count: (size_t)count;

- (size_t)writeBigEndianInt64s: (const uint64_t *)buffer
             count: (size_t)count;

- (size_t)writeBigEndianFloats: (const float *)buffer
             count: (size_t)count;

- (size_t)writeBigEndianDoubles: (const double *)buffer
              count: (size_t)count;

- (void)writeLittleEndianInt16: (uint16_t)int16;

- (void)writeLittleEndianInt32: (uint32_t)int32;

- (void)writeLittleEndianInt64: (uint64_t)int64;

- (void)writeLittleEndianFloat: (float)float_;

- (void)writeLittleEndianDouble: (double)double_;

- (size_t)writeLittleEndianInt16s: (const uint16_t *)buffer
                count: (size_t)count;

- (size_t)writeLittleEndianInt32s: (const uint32_t *)buffer
                count: (size_t)count;

- (size_t)writeLittleEndianInt64s: (const uint64_t *)buffer
                count: (size_t)count;

- (size_t)writeLittleEndianFloats: (const float *)buffer
                count: (size_t)count;

- (size_t)writeLittleEndianDoubles: (const double *)buffer
                 count: (size_t)count;

- (size_t)writeData: (OFData *)data;

- (size_t)writeString: (OFString *)string;

- (size_t)writeString: (OFString *)string
         encoding: (of_string_encoding_t)encoding;

- (size_t)writeLine: (OFString *)string;

- (size_t)writeLine: (OFString *)string
       encoding: (of_string_encoding_t)encoding;

- (size_t)writeFormat: (OFConstantString *)format, ...;

- (size_t)writeFormat: (OFConstantString *)format
        arguments: (va_list)arguments;

- (bool)hasDataInReadBuffer;

- (bool)isBlocking;

- (void)setBlocking: (bool)enable;

- (int)fileDescriptorForReading;

- (int)fileDescriptorForWriting;

#ifdef OF_HAVE_SOCKETS

- (void)cancelAsyncRequests;
#endif

- (void)unreadFromBuffer: (const void *)buffer
          length: (size_t)length;

- (void)close;

- (size_t)lowlevelReadIntoBuffer: (void *)buffer
              length: (size_t)length;

- (void)lowlevelWriteBuffer: (const void *)buffer
             length: (size_t)length;

- (bool)lowlevelIsAtEndOfStream;
@end

OF_ASSUME_NONNULL_END