Class for IO on a tape device. More...

#include <TapeIO.h>

Inheritance diagram for casa::TapeIO:

Public Member Functions
	TapeIO ()
	Default constructor.
	TapeIO (int fd)
	Construct from the given file descriptor.
	TapeIO (const Path &device, Bool writable=False)
	Construct from the given device.
virtual	~TapeIO ()
	The destructor will only close the file if the appropriate constructor, or attach function, was used.
void	attach (int fd)
	Attach to the given file descriptor.
void	attach (const Path &device, Bool writable=False)
	Attach to the given tape device.
virtual void	write (uInt size, const void *buf)
	Write the specified number of bytes.
virtual Int	read (uInt size, void *buf, Bool throwException=True)
	Read `size` bytes from the tape.
virtual void	rewind ()
	Rewind the tape device to the beginning.
virtual void	skip (uInt howMany=1)
	skip the specified number of files (ie tape marks) on the tape.
virtual void	mark (uInt howMany=1)
	write the specified number of filemarks.
Bool	fixedBlocks () const
	returns True if the tape device is configured to use a fixed block size
uInt	fixedBlockSize () const
	returns the block size in bytes.
void	setFixedBlockSize (uInt sizeInBytes)
	Configure the tape device to use fixed length blocks of the specified size.
void	setVariableBlockSize ()
	Configure the tape device to use variable length blocks.
virtual Int64	length ()
	Get the length of the tape device.
virtual Bool	isReadable () const
	Is the tape device readable?
virtual Bool	isWritable () const
	Is the tape device writable?
virtual Bool	isSeekable () const
	Is the tape device seekable?
virtual String	fileName () const
	Get the name of the attached device or return a zero length string if it cannot be determined.
Static Public Member Functions
static int	open (const Path &device, Bool writable=False)
	Some static convenience functions for file descriptor opening & closing.
static void	close (int fd)
Protected Member Functions
void	detach ()

void	fillRWFlags ()
	Determine if the file is readable and/or writable.
void	fillSeekable ()
	Determine if the file is seekable.
virtual Int64	doSeek (Int64 offset, ByteIO::SeekOption)
	Reset the position pointer to the given value.
Private Member Functions
	TapeIO (const TapeIO &that)
	The following functions are made private so that the compiler does not generate default ones.
TapeIO &	operator= (const TapeIO &that)
void	setBlockSize (uInt sizeInBytes)
uInt	getBlockSize () const
Private Attributes
int	itsDevice
Bool	itsOwner
Bool	itsReadable
Bool	itsWritable
Bool	itsSeekable
String	itsDeviceName

Detailed Description

Class for IO on a tape device.

Intended use:

Public interface

 <h3>Review Status</h3><dl><dt>Date Reviewed:<dd>yyyy/mm/dd</dl>

Prerequisite

ByteIO class
Tape descriptors

Synopsis

This class is a specialization of class ByteIO . It uses a file descriptor to read/write data.

The file associated with the file descriptor has to be opened before hand. The constructor will determine automatically if the file is readable, writable and seekable. Note that on destruction the file descriptor is NOT closed.

Example

This example shows how FiledesIO 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).
       FiledesIO fio (fd);
       AipsIO stream (&fio);
       // Read the data.
       Int vali;
       Bool valb;
       stream >> vali >> valb;

Motivation

Make it possible to use the AIPS++ IO functionality on any file. In this way any device can be hooked to the IO framework.

Definition at line 87 of file TapeIO.h.

Constructor & Destructor Documentation

casa::TapeIO::TapeIO ( )

Default constructor.

A stream can be attached using the attach function.

casa::TapeIO::TapeIO ( int fd ) [explicit]

Construct from the given file descriptor.

The file descriptor must have been obtained using the TapeIO::open static function. When constructed this way the class will not take over the file descriptor and hence not close the Tape device when this class is destroyed.

casa::TapeIO::TapeIO	(	const Path &	device,
		Bool	writable = `False`
	)

Construct from the given device.

The device must point to a tape device and if requested it is checked if the device is writeable. Throws an exception if the device could not be opened correctly. When constructed this way the class will close the Tape device when this class is destroyed or the TapeIO object is attached to a new file descriptor.

virtual casa::TapeIO::~TapeIO ( ) [virtual]

The destructor will only close the file if the appropriate constructor, or attach function, was used.

casa::TapeIO::TapeIO ( const TapeIO & that ) [private]

The following functions are made private so that the compiler does not generate default ones.

They cannot be used and are not defined.

Member Function Documentation

void casa::TapeIO::attach ( int fd )

Attach to the given file descriptor.

The file descriptor will not be closed when this class is destroyed.

void casa::TapeIO::attach	(	const Path &	device,
		Bool	writable = `False`
	)

Attach to the given tape device.

The tape will be closed when this class is destroyed or the TapeIO object is attached to a new descriptor.

static void casa::TapeIO::close ( int fd ) [static]

void casa::TapeIO::detach ( ) [protected]

Detach the FILE. Close it when it is owned.

virtual Int64 casa::TapeIO::doSeek	(	Int64	offset,
		ByteIO::SeekOption
	)		`[protected, virtual]`

Reset the position pointer to the given value.

It returns the new position. May not work on all Tape devices use the isSeekable(0 member function to see if this function is usuable. Otherwise an Exception (AipsError) is thrown.

Implements casa::ByteIO.

virtual String casa::TapeIO::fileName ( ) const [virtual]

Get the name of the attached device or return a zero length string if it cannot be determined.

void casa::TapeIO::fillRWFlags ( ) [protected]

Determine if the file is readable and/or writable.

void casa::TapeIO::fillSeekable ( ) [protected]

Determine if the file is seekable.

Bool casa::TapeIO::fixedBlocks ( ) const

returns True if the tape device is configured to use a fixed block size

uInt casa::TapeIO::fixedBlockSize ( ) const

returns the block size in bytes.

Returns zero if the device is configured to use variable length blocks.

uInt casa::TapeIO::getBlockSize ( ) const [private]

virtual Bool casa::TapeIO::isReadable ( ) const [virtual]

Is the tape device readable?

Implements casa::ByteIO.

virtual Bool casa::TapeIO::isSeekable ( ) const [virtual]

Is the tape device seekable?

Implements casa::ByteIO.

virtual Bool casa::TapeIO::isWritable ( ) const [virtual]

Is the tape device writable?

Implements casa::ByteIO.

virtual Int64 casa::TapeIO::length ( ) [virtual]

Get the length of the tape device.

Not a meaningful function for this class and this function always returns -1.

Implements casa::ByteIO.

virtual void casa::TapeIO::mark ( uInt howMany = 1 ) [virtual]

write the specified number of filemarks.

static int casa::TapeIO::open	(	const Path &	device,
		Bool	writable = `False`
	)		`[static]`

Some static convenience functions for file descriptor opening & closing.

The open function returns a file descriptor and the close function requires a file descriptor as an argument.

TapeIO& casa::TapeIO::operator= ( const TapeIO & that ) [private]

virtual Int casa::TapeIO::read	(	uInt	size,
		void *	buf,
		Bool	throwException = `True`
	)		`[virtual]`

Read size bytes from the tape.

Returns the number of bytes actually read or a negative number if an error occured. Will throw an exception (AipsError) if the requested number of bytes could not be read, or an error occured, unless throwException is set to False. Will always throw an exception if the tape is not readable or the system call returns an undocumented value. Returns zero if the tape is at the end of the current file (and size is non-zero and throwException is False).

Implements casa::ByteIO.

virtual void casa::TapeIO::rewind ( ) [virtual]

Rewind the tape device to the beginning.

void casa::TapeIO::setBlockSize ( uInt sizeInBytes ) [private]

void casa::TapeIO::setFixedBlockSize ( uInt sizeInBytes )

Configure the tape device to use fixed length blocks of the specified size.

The size must be bigger than zero (dugh!). Values bigger than 64k may cause problems on some systems. Currently this function only does anything under Solaris and Linux systems.

void casa::TapeIO::setVariableBlockSize ( )

Configure the tape device to use variable length blocks.

Currently this function only does anything under Solaris and Linux systems.

virtual void casa::TapeIO::skip ( uInt howMany = 1 ) [virtual]