FilebufIO.h

Classes

FilebufIO -- Class for buffered file IO. (full description)

class FilebufIO: public ByteIO

Interface

Public Members
FilebufIO()
explicit FilebufIO (int fd, uInt bufferSize=16384)
void attach (int fd, uInt bufferSize=16384)
~FilebufIO()
virtual void write (uInt size, const void* buf)
virtual Int read (uInt size, void* buf, Bool throwException=True)
void flush()
void resync()
virtual Int64 length()
virtual Bool isReadable() const
virtual Bool isWritable() const
virtual Bool isSeekable() const
virtual String fileName() const
uInt bufferSize() const
Protected Members
void detach (Bool closeFile=False)
void fillRWFlags (int fd)
void fillSeekable()
virtual Int64 doSeek (Int64 offset, ByteIO::ByteIO)
void setBuffer (uInt bufSize)
void writeBuffer (Int64 offset, const char* buf, Int size)
uInt readBuffer (Int64 offset, char* buf, uInt size, Bool throwException)
void writeBlock (uInt size, const char* buf)
uInt readBlock (uInt size, char* buf, Bool throwException)
Private Members
FilebufIO (const FilebufIO& that)
FilebufIO& operator= (const FilebufIO& that)

Description

Review Status

Reviewed By:
UNKNOWN
Date Reviewed:
before2004/08/25
Programs:
Tests:

Prerequisite

Synopsis

This class is a specialization of class ByteIO. This class is doing IO on a file in a buffered way to reduce the number of file accesses as much as possible. It is part of the entire IO framework. It can for instance be used to store data in canonical format in a file in an IO-efficient way
The buffer size is dynamic, so any time it can be set as needed.

It is also possible to construct a FilebufIO object from a file descriptor (e.g. for a pipe or socket). The constructor will determine automatically if the file is readable, writable and seekable.

Example

This example shows how FilebufIO can be used with an fd. It uses the fd for a regular file, which could be done in an easier way using class RegularFileIO. However, when using pipes or sockets, this would be the only way. 
    // Get a file descriptor for the file.
    int fd = open ("file.name");
    // Use that as the source of AipsIO (which will also use CanonicalIO).
    FilebufIO fio (fd);
    AipsIO stream (&fio);
    // Read the data.
    Int vali;
    Bool valb;
    stream >> vali >> valb;

Motivation

The stdio package was used, but it proved to be very slow on Solaris. After a seek the buffer was refreshed, which increased the number of file accesses enormously. Also the interaction between reads and writes in stdio required speial care.

Member Description

FilebufIO()

Default constructor. A stream can be attached using the attach function.

explicit FilebufIO (int fd, uInt bufferSize=16384)

Construct from the given file descriptor. Note that the detach function can be told to close the file descriptor.

void attach (int fd, uInt bufferSize=16384)

Attach to the given file descriptor. Note that the detach function can be told to close the file descriptor.

~FilebufIO()

The destructor closes the file when it was owned and opened and not closed yet.

virtual void write (uInt size, const void* buf)

Write the number of bytes.

virtual Int read (uInt size, void* buf, Bool throwException=True)

Read size bytes from the File. Returns the number of bytes actually read. Will throw an exception (AipsError) if the requested number of bytes could not be read unless throwException is set to False. Will always throw an exception if the file is not readable or the system call returns an undocumented value.

void flush()

Flush the current buffer.

void resync()

Resync the file (i.e. empty the current buffer).

virtual Int64 length()

Get the length of the byte stream.

virtual Bool isReadable() const

Is the IO stream readable?

virtual Bool isWritable() const

Is the IO stream writable?

virtual Bool isSeekable() const

Is the IO stream seekable?

virtual String fileName() const

Get the file name of the file attached.

uInt bufferSize() const

Get the buffer size.

void detach (Bool closeFile=False)

Detach the FILE. Close it when needed.

void fillRWFlags (int fd)

Determine if the file descriptor is readable and/or writable.

void fillSeekable()

Determine if the file is seekable.

virtual Int64 doSeek (Int64 offset, ByteIO::ByteIO)

Reset the position pointer to the given value. It returns the new position.

void setBuffer (uInt bufSize)

Set a new buffer size. If a buffer was already existing, flush and delete it.

void writeBuffer (Int64 offset, const char* buf, Int size)

Write a buffer of given length into the file at given offset.

uInt readBuffer (Int64 offset, char* buf, uInt size, Bool throwException)

Read a buffer of given length from the file at given offset.

void writeBlock (uInt size, const char* buf)

Write a block into the stream at the current offset. It is guaranteed that the block fits in a single buffer.

uInt readBlock (uInt size, char* buf, Bool throwException)

Read a block from the stream at the current offset. It is guaranteed that the block fits in a single buffer.

FilebufIO (const FilebufIO& that)

data written into current buffer?

Copy constructor, should not be used.

FilebufIO& operator= (const FilebufIO& that)

Assignment, should not be used.