blockio.h

Go to the documentation of this file.

// # blockio.h:
// # Copyright (C) 1993,1994,1995,1996,1999
// # Associated Universities, Inc. Washington DC, USA.
// #
// # This library is free software; you can redistribute it and/or modify it
// # under the terms of the GNU Library General Public License as published by
// # the Free Software Foundation; either version 2 of the License, or (at your
// # option) any later version.
// #
// # This library is distributed in the hope that it will be useful, but WITHOUT
// # ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
// # FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Library General Public
// # License for more details.
// #
// # You should have received a copy of the GNU Library General Public License
// # along with this library; if not, write to the Free Software Foundation,
// # Inc., 675 Massachusetts Ave, Cambridge, MA 02139, USA.
// #
// # Correspondence concerning AIPS++ should be addressed as follows:
// #        Internet email: casa-feedback@nrao.edu.
// #        Postal address: AIPS++ Project Office
// #                        National Radio Astronomy Observatory
// #                        520 Edgemont Road
// #                        Charlottesville, VA 22903-2475 USA
#ifndef FITS_BLOCKIO_H
#define FITS_BLOCKIO_H
 
// # Include this file first, because it may set LFS variables used by cfitsio.
#include <casacore/casa/aips.h>
 
// # Make sure that cfitsio does not declare the wcs headers.
extern "C" {
#include <fitsio.h>   //# header file from cfitsio
#include <fitsio2.h>  //# using core functions of cfitsio
}
 
#include <stdlib.h>
#include <unistd.h>
#include <fcntl.h>
 
#include <casacore/fits/FITS/FITSError.h>
 
namespace casacore {  // # NAMESPACE CASACORE - BEGIN
 
//----------------------------------------------------------------------------
//<category lib=aips module=FITS sect="Blocked I/O">
//<summary> fixed-length blocked sequentual I/O base class </summary>
//<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.
//</synopsis>
//<todo>
// <li> ifdef kludges until OS dependent flags are developed
//       for the compilation system.
//</todo>
 
class BlockIO {
 public:
  // error return code
  enum IOErrs { OK, NOSUCHFILE, NOMEM, OPENERR, CLOSEERR, READERR, WRITEERR };
  int err() const { return (int)m_err_status; }
 
  //  number of physical blocks read/written
  int blockno() const { return m_block_no; }
 
  // reset the m_iosize data member
  void reset_iosize() { m_iosize = 0; }
 
  // get the total bytes of data in m_buffer
  int iosize() const { return m_iosize; }
 
  // get the current read position within m_buffer
  int current() const { return m_current; }
 
  // get m_buffer
  char *buffer() const { return m_buffer; }
 
  //  number of logical records read/written
  int recno() const { return m_rec_no; }
 
  // name of file associated with I/O stream, if applicable
  const char *fname() const { return m_filename; }
 
  // 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 close_file(fitsfile *fptr, int *status);
  // file descriptor associated with I/O stream, if applicable
  int fdes() const { return m_fd; }
  // get the fitsfile pointer
  fitsfile *getfptr() const { return m_fptr; }
  void setfptr(fitsfile *ffp);
 
 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.
  //<group>
  BlockIO(const char *, int, int, int = 1, FITSErrorHandler errhandler = FITSError::defaultHandler);
  BlockIO(int, int, int = 1, FITSErrorHandler errhandler = FITSError::defaultHandler);
  virtual ~BlockIO();
  //</group>
 
  char *m_filename;          // name of file
  int m_options;             // options on open statement
  const int m_recsize;       // size in bytes of a logical record
  const int m_nrec;          // maximum number of logical records
  const int m_blocksize;     // size in bytes of physical records
  FITSErrorHandler m_errfn;  // FITS error handler function
  IOErrs m_err_status;       // error number
  int m_fd;                  // file descriptor
  char *m_buffer;            // the actual data buffer itself
  int m_block_no;            // number of physical blocks read/written
  int m_rec_no;              // number of logical records read/written
  int m_current;             // offset to current logical record
  // size of record in buffer
  int m_iosize;
  // using fitsfile structure from cfitsio of NASA
  fitsfile *m_fptr;
 
  // set the error message and error number for later recovery
  void errmsg(IOErrs, const char *);
};
 
//<summary> fixed-length blocked sequential input base class</summary>
//<prerequisite>
//   <li> BlockIO
//</prerequisite>
 
class BlockInput : public BlockIO {
 public:
  // Construction can be done either from a filename 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.
  //<group>
  BlockInput(const char *, int, int = 1, FITSErrorHandler errhandler = FITSError::defaultHandler);
  BlockInput(int, int, int = 1, FITSErrorHandler errhandler = FITSError::defaultHandler);
  virtual ~BlockInput();
  //</group>
 
  // read the next logical record or first
  // skip N logical records and then read the next one.
  // (note it is not possible to skip a record without
  // reading a record).
  //<note role=caution> these functions return a pointer to an
  // internal record. The user must make sure that
  // after destruction of this class no dangling pointers
  // are left.
  //</note>
  //<group>
  virtual char *read();  // read a physical block.
  virtual char *skip(int);
  //</group>
};
 
//<summary> fixed-length blocked sequential output base class</summary>
//<prerequisite>
//   <li> BlockIO
//</prerequisite>
 
class BlockOutput : public BlockIO {
 public:
  // Construction can be done either from a filename 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.
  //<group>
  BlockOutput(const char *, int, int = 1, FITSErrorHandler errhandler = FITSError::defaultHandler);
  BlockOutput(int, int, int = 1, FITSErrorHandler errhandler = FITSError::defaultHandler);
  virtual ~BlockOutput();
  void flush_buffer();
  //</group>
 
  // write the next logical record. The input must point
  // to a logical record
  virtual int write(char *);
};
 
}  // namespace casacore
 
#endif