Main Page | Namespace List | Class Hierarchy | Alphabetical List | Class List | File List | Class Members | File Members

lXDR Class Reference

#include <lXDR.hh>

Inheritance diagram for lXDR:

Inheritance graph
[legend]
Collaboration diagram for lXDR:

Collaboration graph
[legend]
List of all members.

Public Member Functions

 lXDR (const char *filename=0, bool open_for_write=false)
virtual ~lXDR ()
void setFileName (const char *filename, bool open_for_write=false)
const char * getFileName (void) const
long getError (void) const
long readLong (void)
double readFloat (void)
double readDouble (void)
const char * readString (long &length)
long * readLongArray (long &length)
double * readFloatArray (long &length)
double * readDoubleArray (long &length)
long writeLong (long data)
long writeDouble (double data)
long writeString (const char *data)
long writeString (const char *data, long length)
long writeLongArray (const long *data, long length)
long writeDoubleArray (const double *data, long length)
void setError (long error)
long filePosition (long pos=-1)

Static Public Member Functions

int getMajor (void)
int getMinor (void)
const char * getText (void)

Private Types

enum  {
  MAJOR = 1, MINOR = 0, DAY = 23, MONTH = 10,
  YEAR = 2003
}

Private Member Functions

 lXDR (const lXDR &)
lXDR & operator= (const lXDR &)
double ntohd (double d) const
double htond (double d) const
long checkRead (long *)
long checkRead (float *)
long checkRead (double *)
long checkWrite (long *)
long checkWrite (double *)

Private Attributes

char * _fileName
FILE * _fp
long _error
bool _openForWrite
bool _hasNetworkOrder

Member Enumeration Documentation

anonymous enum [private]
 

Enumeration values:
MAJOR 
MINOR 
DAY 
MONTH 
YEAR 

Definition at line 31 of file lXDR.hh. 

00031 { MAJOR = 1, MINOR = 0, DAY = 23, MONTH = 10, YEAR = 2003 };

Constructor & Destructor Documentation

lXDR::lXDR (  const char *  filename = 0,
bool  open_for_write = false
) 
 

Definition at line 38 of file lXDR.cc.

References _hasNetworkOrder, and setFileName(). 

00038                                                     : _fileName(0), _fp(0) 
00039 {
00040    setFileName(filename, open_for_write);
00041    if (htonl(1L) == 1L) _hasNetworkOrder = true;
00042    else                 _hasNetworkOrder = false;
00043    return;
00044 }

lXDR::lXDR (  const lXDR &   )  [private]
 

lXDR::~lXDR (   )  [virtual]
 

Definition at line 25 of file lXDR.cc.

References _fileName, and _fp. 

00026 {
00027    if (_fp) {
00028       fclose(_fp);
00029       _fp = 0;
00030    }
00031    if (_fileName) {
00032       delete [] _fileName;
00033       _fileName = 0;
00034    }
00035    return;
00036 }

Member Function Documentation

long lXDR::checkRead (  double *   )  [private]
 

Definition at line 119 of file lXDR.cc.

References _error, _fp, _openForWrite, LXDR_NOFILE, LXDR_READERROR, LXDR_READONLY, LXDR_SUCCESS, and ntohd(). 

00120 {
00121    if (_openForWrite) return(_error = LXDR_READONLY);
00122    if (_fp == 0)      return(_error = LXDR_NOFILE);
00123    if (d) {
00124       if (fread(d, 8, 1, _fp) != 1) return(_error = LXDR_READERROR);
00125       *d = ntohd(*d);
00126    }
00127    return(LXDR_SUCCESS);
00128 }

long lXDR::checkRead (  float *   )  [private]
 

Definition at line 130 of file lXDR.cc.

References _error, _fp, _openForWrite, LXDR_NOFILE, LXDR_READERROR, LXDR_READONLY, and LXDR_SUCCESS. 

00131 {
00132    if (_openForWrite) return(_error = LXDR_READONLY);
00133    if (_fp == 0)      return(_error = LXDR_NOFILE);
00134    if (f) {
00135       if (fread(f, 4, 1, _fp) != 1) return(_error = LXDR_READERROR);
00136       *((long *) f) = ntohl(*((long *) f));
00137    }
00138    return(LXDR_SUCCESS);
00139 }

long lXDR::checkRead (  long *   )  [private]
 

Definition at line 107 of file lXDR.cc.

References _error, _fp, _openForWrite, LXDR_NOFILE, LXDR_READERROR, LXDR_READONLY, and LXDR_SUCCESS.

Referenced by readDouble(), readDoubleArray(), readFloat(), readFloatArray(), readLong(), readLongArray(), and readString(). 

00108 {
00109    if (_openForWrite) return(_error = LXDR_READONLY);
00110    if (_fp == 0)      return(_error = LXDR_NOFILE);
00111    if (l) {
00112       long nr;
00113       if ((nr = fread(l, 4, 1, _fp)) != 1) return(_error = LXDR_READERROR);
00114       *l = ntohl(*l);
00115    }
00116    return(LXDR_SUCCESS);
00117 }

long lXDR::checkWrite (  double *   )  [private]
 

Definition at line 236 of file lXDR.cc.

References _error, _fp, _openForWrite, htond(), LXDR_NOFILE, LXDR_SUCCESS, LXDR_WRITEERROR, and LXDR_WRITEONLY. 

00237 {
00238    if (_openForWrite == false) return(_error = LXDR_WRITEONLY);
00239    if (_fp == 0)               return(_error = LXDR_NOFILE);
00240    if (d) {
00241       double dd = htond(*d);
00242       if (fwrite(&dd, 8, 1, _fp) != 8) return(_error = LXDR_WRITEERROR);
00243    }
00244    return(LXDR_SUCCESS);
00245 }

long lXDR::checkWrite (  long *   )  [private]
 

Definition at line 225 of file lXDR.cc.

References _error, _fp, _openForWrite, LXDR_NOFILE, LXDR_SUCCESS, LXDR_WRITEERROR, and LXDR_WRITEONLY.

Referenced by writeDouble(), writeDoubleArray(), writeLong(), writeLongArray(), and writeString(). 

00226 {
00227    if (_openForWrite == false) return(_error = LXDR_WRITEONLY);
00228    if (_fp == 0)               return(_error = LXDR_NOFILE);
00229    if (l) {
00230       long ll = htonl(*l);
00231       if (fwrite(&ll, 4, 1, _fp) != 4) return(_error = LXDR_WRITEERROR);
00232    }
00233    return(LXDR_SUCCESS);
00234 }

long lXDR::filePosition (  long  pos = -1  ) 
 

Definition at line 300 of file lXDR.cc.

References _error, _fp, LXDR_NOFILE, and LXDR_SEEKERROR.

Referenced by lStdHep::readEvent(). 

00301 {
00302    if (_fp == 0) {
00303       _error = LXDR_NOFILE;
00304       return(-1);
00305    }
00306    if (pos == -1) return(ftell(_fp));
00307    if (fseek(_fp, pos, SEEK_SET)) {
00308       _error = LXDR_SEEKERROR;
00309       return(-1);
00310    }
00311    return(pos);
00312 }

long lXDR::getError (  void   )  const [inline]
 

Definition at line 70 of file lXDR.hh.

References _error.

Referenced by lStdHep::getEvent(), LCDG4readStdFile::LCDG4readStdFile(), lStdHep::more(), lStdHep::Event::read(), lStdHep::EventTable::read(), lStdHep::readEvent(), and lStdHep::readFileHeader(). 

00070 { return(_error); };

const char* lXDR::getFileName (  void   )  const [inline]
 

Definition at line 60 of file lXDR.hh.

References _fileName. 

00060 { return(_fileName); };

int lXDR::getMajor (  void   )  [inline, static]
 

Reimplemented in lStdHep.

Definition at line 34 of file lXDR.hh.

References MAJOR. 

00034 { return(MAJOR); };

int lXDR::getMinor (  void   )  [inline, static]
 

Reimplemented in lStdHep.

Definition at line 35 of file lXDR.hh.

References MINOR. 

00035 { return(MINOR); };

const char* lXDR::getText (  void   )  [inline, static]
 

Reimplemented in lStdHep.

Definition at line 36 of file lXDR.hh.

References DAY, MAJOR, MINOR, MONTH, and YEAR. 

00036                                      {
00037       static char buff[80];
00038       sprintf(buff, "lXDR version %d.%d (%02d.%02d.%d) by W.G.J. Langeveld, SLAC",
00039               MAJOR, MINOR, DAY, MONTH, YEAR);
00040       return(buff);
00041    };

double lXDR::htond (  double  d  )  const [inline, private]
 

Definition at line 122 of file lXDR.hh.

References ntohd().

Referenced by checkWrite(), and writeDoubleArray(). 

00122 { return(ntohd(d)); };

double lXDR::ntohd (  double  d  )  const [private]
 

Definition at line 84 of file lXDR.cc.

References _hasNetworkOrder.

Referenced by checkRead(), htond(), and readDoubleArray(). 

00085 {
00086 //
00087 // If we already have network order, we don't swap
00088 //
00089    if (_hasNetworkOrder == false) {
00090       union {
00091          double        d;
00092          unsigned char b[8];
00093       } dd;
00094       int i;
00095 
00096       dd.d = d;
00097       for (i = 0; i < 4; i++) {
00098          unsigned char c = dd.b[i];
00099          dd.b[i]         = dd.b[7 - i];
00100          dd.b[7 - i]     = c;
00101       }
00102       d = dd.d;
00103    }
00104    return(d);
00105 }

lXDR& lXDR::operator= (  const lXDR &   )  [private]
 

double lXDR::readDouble (  void   ) 
 

Definition at line 148 of file lXDR.cc.

References checkRead().

Referenced by lStdHep::Event::read(). 

00149 {
00150    double d = 0.0;
00151    checkRead(&d);
00152    return(d);
00153 }

double * lXDR::readDoubleArray (  long &  length  ) 
 

Definition at line 191 of file lXDR.cc.

References _error, _fp, _hasNetworkOrder, checkRead(), LXDR_READERROR, LXDR_SUCCESS, and ntohd().

Referenced by lStdHep::Event::read(). 

00192 {
00193    if (checkRead(&length)) return(0);
00194    double *s = new double[length];
00195    if (fread(s, 8, length, _fp) != (unsigned long) length) {
00196       _error = LXDR_READERROR;
00197       delete [] s;
00198       return(0);
00199    }
00200    if (_hasNetworkOrder == false) for (long i = 0; i < length; i++) s[i] = ntohd(s[i]);
00201    _error = LXDR_SUCCESS;
00202    return(s);
00203 }

double lXDR::readFloat (  void   ) 
 

Definition at line 155 of file lXDR.cc.

References checkRead().

Referenced by lStdHep::Event::read(). 

00156 {
00157    float f = 0.0;
00158    checkRead(&f);
00159    return((double) f);
00160 }

double * lXDR::readFloatArray (  long &  length  ) 
 

Definition at line 205 of file lXDR.cc.

References _error, _fp, _hasNetworkOrder, checkRead(), LXDR_READERROR, and LXDR_SUCCESS. 

00206 {
00207    if (checkRead(&length)) return(0);
00208    long *st = new long[length];
00209    if (fread(st, 4, length, _fp) != (unsigned long) length) {
00210       _error = LXDR_READERROR;
00211       delete [] st;
00212       return(0);
00213    }
00214    double *s = new double[length];
00215    if (_hasNetworkOrder == false) {
00216       for (long i = 0; i < length; i++) {
00217          long l = ntohl(st[i]);
00218          s[i] = (double) (*((float *) &l));
00219       }
00220    }
00221    _error = LXDR_SUCCESS;
00222    return(s);
00223 }

long lXDR::readLong (  void   ) 
 

Definition at line 141 of file lXDR.cc.

References checkRead().

Referenced by lStdHep::Event::read(), lStdHep::EventTable::read(), and lStdHep::readFileHeader(). 

00142 {
00143    long l = 0;
00144    checkRead(&l);
00145    return(l);
00146 }

long * lXDR::readLongArray (  long &  length  ) 
 

Definition at line 177 of file lXDR.cc.

References _error, _fp, _hasNetworkOrder, checkRead(), LXDR_READERROR, and LXDR_SUCCESS.

Referenced by lStdHep::Event::read(), lStdHep::EventTable::read(), and lStdHep::readFileHeader(). 

00178 {
00179    if (checkRead(&length)) return(0);
00180    long *s = new long[length];
00181    if (fread(s, 4, length, _fp) != (unsigned long) length) {
00182       _error = LXDR_READERROR;
00183       delete [] s;
00184       return(0);
00185    }
00186    if (_hasNetworkOrder == false) for (long i = 0; i < length; i++) s[i] = ntohl(s[i]);
00187    _error = LXDR_SUCCESS;
00188    return(s);
00189 }

const char * lXDR::readString (  long &  length  ) 
 

Definition at line 162 of file lXDR.cc.

References _error, _fp, checkRead(), LXDR_READERROR, and LXDR_SUCCESS.

Referenced by lStdHep::Event::read(), lStdHep::EventTable::read(), and lStdHep::readFileHeader(). 

00163 {
00164    if (checkRead(&length)) return(0);
00165    long rl = (length + 3) & 0xFFFFFFFC;
00166    char *s = new char[rl + 1];
00167    if (fread(s, 1, rl, _fp) != (unsigned long) rl) {
00168       _error = LXDR_READERROR;
00169       delete [] s;
00170       return(0);
00171    }
00172    s[rl] = '\0';
00173    _error = LXDR_SUCCESS;
00174    return(s);
00175 }

void lXDR::setError (  long  error  )  [inline]
 

Definition at line 108 of file lXDR.hh.

References _error.

Referenced by lStdHep::lStdHep(), lStdHep::Event::read(), lStdHep::EventTable::read(), lStdHep::readEvent(), and lStdHep::readFileHeader(). 

00108 { _error = error; return; };

void lXDR::setFileName (  const char *  filename,
bool  open_for_write = false
) 
 

Definition at line 46 of file lXDR.cc.

References _error, _fileName, _fp, _openForWrite, LXDR_OPENFAILURE, and LXDR_SUCCESS.

Referenced by lXDR(). 

00047 {
00048 //
00049 // First check if we can open this file
00050 //
00051    if (filename == 0) {
00052       _error = LXDR_OPENFAILURE;
00053       return;
00054    }
00055 #ifdef _MSC_VER
00056    FILE *fp = fopen(filename, open_for_write ? "wb" : "rb");
00057 #else
00058    FILE *fp = fopen(filename, open_for_write ? "w" : "r");
00059 #endif
00060    if (fp == 0) {
00061       _error = LXDR_OPENFAILURE;
00062       return;
00063    }
00064 
00065    if (_fp) fclose(_fp);
00066    _fp = fp;
00067 
00068    if (_fileName) {
00069       delete [] _fileName;
00070       _fileName = 0;
00071    }
00072 
00073    int n = strlen(filename);
00074    _fileName = new char [n + 1];
00075    strncpy(_fileName, filename, n);
00076    _fileName[n] = '\0';
00077 
00078    _openForWrite = open_for_write;
00079 
00080    _error = LXDR_SUCCESS;
00081    return;
00082 }

long lXDR::writeDouble (  double  data  ) 
 

Definition at line 252 of file lXDR.cc.

References checkWrite(). 

00253 {
00254    return(checkWrite(&data));
00255 }

long lXDR::writeDoubleArray (  const double *  data,
long  length
) 
 

Definition at line 285 of file lXDR.cc.

References _error, _fp, _hasNetworkOrder, checkWrite(), htond(), LXDR_SUCCESS, and LXDR_WRITEERROR. 

00286 {
00287    if (checkWrite(&length)) return(_error);
00288    double *s = (double *) data;
00289    if (_hasNetworkOrder == false) {
00290       s = new double[length];
00291       for (long i = 0; i < length; i++) s[i] = htond(data[i]);
00292    }
00293    long l = fwrite(s, 8, length, _fp);
00294    if (_hasNetworkOrder == false) delete [] s;
00295    if (l != length) return(_error = LXDR_WRITEERROR);
00296    return(_error = LXDR_SUCCESS);
00297 }

long lXDR::writeLong (  long  data  ) 
 

Definition at line 247 of file lXDR.cc.

References checkWrite(). 

00248 {
00249    return(checkWrite(&data));
00250 }

long lXDR::writeLongArray (  const long *  data,
long  length
) 
 

Definition at line 271 of file lXDR.cc.

References _error, _fp, _hasNetworkOrder, checkWrite(), LXDR_SUCCESS, and LXDR_WRITEERROR. 

00272 {
00273    if (checkWrite(&length)) return(_error);
00274    long *s = (long *) data;
00275    if (_hasNetworkOrder == false) {
00276       s = new long[length];
00277       for (long i = 0; i < length; i++) s[i] = htonl(data[i]);
00278    }
00279    long l = fwrite(s, 4, length, _fp);
00280    if (_hasNetworkOrder == false) delete [] s;
00281    if (l != length) return(_error = LXDR_WRITEERROR);
00282    return(_error = LXDR_SUCCESS);
00283 }

long lXDR::writeString (  const char *  data,
long  length
) 
 

Definition at line 262 of file lXDR.cc.

References _error, _fp, checkWrite(), LXDR_SUCCESS, and LXDR_WRITEERROR. 

00263 {
00264    if (checkWrite(&length)) return(_error);
00265    if (fwrite(data, 1, length, _fp) != (unsigned long) length) return(_error = LXDR_WRITEERROR);
00266    long l = ((length + 3) & 0xFFFFFFFC) - length;
00267    if (fwrite(&l, 1, l, _fp) != (unsigned long) l) return(_error = LXDR_WRITEERROR);
00268    return(_error = LXDR_SUCCESS);
00269 }

long lXDR::writeString (  const char *  data  ) 
 

Definition at line 257 of file lXDR.cc. 

00258 {
00259    return(writeString(data, strlen(data)));
00260 }

Member Data Documentation

long lXDR::_error [private]
 

Definition at line 117 of file lXDR.hh.

Referenced by checkRead(), checkWrite(), filePosition(), getError(), readDoubleArray(), readFloatArray(), readLongArray(), readString(), setError(), setFileName(), writeDoubleArray(), writeLongArray(), and writeString().

char* lXDR::_fileName [private]
 

Definition at line 115 of file lXDR.hh.

Referenced by getFileName(), setFileName(), and ~lXDR().

FILE* lXDR::_fp [private]
 

Definition at line 116 of file lXDR.hh.

Referenced by checkRead(), checkWrite(), filePosition(), readDoubleArray(), readFloatArray(), readLongArray(), readString(), setFileName(), writeDoubleArray(), writeLongArray(), writeString(), and ~lXDR().

bool lXDR::_hasNetworkOrder [private]
 

Definition at line 120 of file lXDR.hh.

Referenced by lXDR(), ntohd(), readDoubleArray(), readFloatArray(), readLongArray(), writeDoubleArray(), and writeLongArray().

bool lXDR::_openForWrite [private]
 

Definition at line 118 of file lXDR.hh.

Referenced by checkRead(), checkWrite(), and setFileName().

The documentation for this class was generated from the following files:
Generated on Thu Oct 7 18:45:09 2004 for LCDG4 by doxygen 1.3.4