---------------------------------------------------------------------------- More...

#include <blockio.h>

Inheritance diagram for casa::BlockIO:

Public Types
enum	IOErrs { OK, NOSUCHFILE, NOMEM, OPENERR, CLOSEERR, READERR, WRITEERR }
	error return code More...
Public Member Functions
int	err () const
int	blockno () const
	number of physical blocks read/written
void	reset_iosize ()
	reset the m_iosize data member
int	iosize () const
	get the total bytes of data in m_buffer
int	current () const
	get the current read position within m_buffer
char *	buffer () const
	get m_buffer
int	recno () const
	number of logical records read/written
const char *	fname () const
	name of file associated with I/O stream, if applicable
int	close_file (fitsfile fptr, int status)
	fits_close_file() does not work for reasons that the file pointer does not have the knowledge of chdu which were written with write_hdr() not write_***_hdr().
int	fdes () const
	file descriptor associated with I/O stream, if applicable
fitsfile *	getfptr () const
	get the fitsfile pointer
void	setfptr (fitsfile *ffp)
Protected Member Functions
	BlockIO (const char *, int, int, int=1, FITSErrorHandler errhandler=FITSError::defaultHandler)
	Construction can be done either from a filename with open options or from a file descriptor.
	BlockIO (int, int, int=1, FITSErrorHandler errhandler=FITSError::defaultHandler)
virtual	~BlockIO ()
void	errmsg (IOErrs, const char *)
	set the error message and error number for later recovery
Protected Attributes
char *	m_filename
int	m_options
const int	m_recsize
const int	m_nrec
const int	m_blocksize
FITSErrorHandler	m_errfn
IOErrs	m_err_status
int	m_fd
char *	m_buffer
int	m_block_no
int	m_rec_no
int	m_current
int	m_iosize
	size of record in buffer
fitsfile *	m_fptr
	using fitsfile structure from cfitsio of NASA

Detailed Description

----------------------------------------------------------------------------

fixed-length blocked sequentual I/O base class

Synopsis

BlockIO is a low level base class that implements fixed-length blocked sequential I/O. Its derived classes, BlockInput and BlockOutput are used by the FitsInput and FitsOutput classes. Users will hardly ever need to use this class directly.

To Do

ifdef kludges until OS dependent flags are developed for the compilation system.

Definition at line 61 of file blockio.h.

Member Enumeration Documentation

enum casa::BlockIO::IOErrs

error return code

Enumerator:

OK
NOSUCHFILE
NOMEM
OPENERR
CLOSEERR
READERR
WRITEERR

Definition at line 64 of file blockio.h.

Constructor & Destructor Documentation

casa::BlockIO::BlockIO	(	const char *	,
		int	,
		int	,
		int	= `1`,
		FITSErrorHandler	errhandler = `FITSError::defaultHandler`
	)			`[protected]`

Construction can be done either from a filename with open options or from a file descriptor.

The remaining arguments are the the logical record size and number of records that make up a physical record followed by the output stream that is used to write error messages to.

casa::BlockIO::BlockIO	(	int	,
		int	,
		int	= `1`,
		FITSErrorHandler	errhandler = `FITSError::defaultHandler`
	)			`[protected]`

virtual casa::BlockIO::~BlockIO ( ) [protected, virtual]

Member Function Documentation

int casa::BlockIO::blockno ( ) const [inline]

number of physical blocks read/written

Definition at line 69 of file blockio.h.

References m_block_no.

Referenced by casa::FitsInput::blockno().

char* casa::BlockIO::buffer ( ) const [inline]

get m_buffer

Definition at line 81 of file blockio.h.

References m_buffer.

int casa::BlockIO::close_file	(	fitsfile *	fptr,
		int *	status
	)

fits_close_file() does not work for reasons that the file pointer does not have the knowledge of chdu which were written with write_hdr() not write_***_hdr().

So create our own close_file() method.

int casa::BlockIO::current ( ) const [inline]

get the current read position within m_buffer

Definition at line 78 of file blockio.h.

References m_current.

int casa::BlockIO::err ( ) const [inline]

Definition at line 66 of file blockio.h.

References m_err_status.