casacore::TapeIO Class Reference

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

#include <TapeIO.h>

Inheritance diagram for casacore::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 (Int64 size, const void *buf)
	Write the specified number of bytes.
virtual Int64	read (Int64 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 ()
	Detach the FILE.
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

Review Status

Date Reviewed:: yyyy/mm/dd

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

casacore::TapeIO::TapeIO ( )

Default constructor.

A stream can be attached using the attach function.

casacore::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.

casacore::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 casacore::TapeIO::~TapeIO ( ) [virtual]

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

casacore::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 casacore::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.

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

Attach to the given file descriptor.

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

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

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

Detach the FILE.

Close it when it is owned.

virtual Int64 casacore::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 casacore::ByteIO.

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

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

Reimplemented from casacore::ByteIO.

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

Determine if the file is readable and/or writable.

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

Determine if the file is seekable.

Bool casacore::TapeIO::fixedBlocks ( ) const

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

uInt casacore::TapeIO::fixedBlockSize ( ) const

returns the block size in bytes.

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

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

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

Is the tape device readable?

Implements casacore::ByteIO.

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

Is the tape device seekable?

Implements casacore::ByteIO.

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

Is the tape device writable?

Implements casacore::ByteIO.

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

Get the length of the tape device.

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

Implements casacore::ByteIO.

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

write the specified number of filemarks.

static int casacore::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& casacore::TapeIO::operator= ( const TapeIO & that ) [private]

Reimplemented from casacore::ByteIO.

virtual Int64 casacore::TapeIO::read	(	Int64	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 casacore::ByteIO.

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

Rewind the tape device to the beginning.

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

void casacore::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 casacore::TapeIO::setVariableBlockSize ( )

Configure the tape device to use variable length blocks.

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

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