OFStream.h

Go to the documentation of this file.

/*
 * Copyright (c) 2008, 2009, 2010, 2011, 2012, 2013, 2014, 2015
 *   Jonathan Schleifer <js@webkeks.org>
 *
 * 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 OFDataArray;
@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 *OF_NULLABLE exception);

typedef bool (^of_stream_async_read_line_block_t)(OFStream *stream,
    OFString *OF_NULLABLE line, OFException *OF_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 *_readBuffer, *_writeBuffer;
    size_t _readBufferLength, _writeBufferLength;
    bool _writeBuffered, _waitingForDelimiter;
@protected
    bool _blocking;
}

#ifdef OF_HAVE_PROPERTIES
@property (getter=isWriteBuffered) bool writeBuffered;
@property (getter=isBlocking) bool blocking;
@property (readonly, getter=isAtEndOfStream) bool atEndOfStream;
#endif

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

- (OFDataArray*)readDataArrayWithCount: (size_t)count;

- (OFDataArray*)readDataArrayWithItemSize: (size_t)itemSize
                    count: (size_t)count;

- (OFDataArray*)readDataArrayTillEndOfStream;

- (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)writeDataArray: (OFDataArray*)dataArray;

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