DbiBinaryFile.cxx

Go to the documentation of this file.

// $Id: DbiBinaryFile.cxx,v 1.11 2008/06/02 13:36:21 nwest Exp $

#include <iostream>

#include "TClass.h"
#include "TObject.h"
#include "Api.h"
#include "TSystem.h"

#include "DatabaseInterface/DbiBinaryFile.h"
#include "DatabaseInterface/DbiTableRow.h"
#include "MessageService/MsgService.h"
#include "Validity/VldRange.h"
#include "Validity/VldTimeStamp.h"

enum Markers { StartMarker = 0xaabbccdd,
               EndMarker   = 0xddbbccaa};

//   Local utilities.
//   ***************

void* GetVTptr(const void* obj) {

//  Return an object's virtual table pointer.

  void* ptr;
  memcpy(&ptr,obj,4);
  return ptr;

}
void SetVTptr(void* obj, const void* vt) {

//  Set an object's virtual table pointer.

  memcpy(obj,&vt,4);

}
//   Definition of static data members
//   *********************************

string DbiBinaryFile::fgWorkDir;
Bool_t DbiBinaryFile::fgReadAccess  = kTRUE;
Bool_t DbiBinaryFile::fgWriteAccess = kTRUE;

CVSID("$Id: DbiBinaryFile.cxx,v 1.11 2008/06/02 13:36:21 nwest Exp $");


// Definition of member functions (is same order as DbiBinaryFile.h)
// *****************************************************************


//.....................................................................

DbiBinaryFile::DbiBinaryFile(const char* fileName, Bool_t input ) :
fFile(0),
fReading(input),
fHasErrors(kFALSE),
fArrayBuffer(0)
{
//
//
//  Purpose:  Default Constructor.
//
//  Arguments: 
//    fileName     in    File name (default: "" => file is a dummy)
//    input        in    true if reading (default = kTRUE)

//  Specification:-
//  =============
//  
//  If file name or fgWorkDir is dummy, or the appropriate access is not set
//  then name is set to dummy otherwise fgWorkDir is prepended to the name.

  // Complete the file name.
  fFileName = fileName;
  if ( fFileName != "" ) {
    Bool_t access = input ? fgReadAccess : fgWriteAccess;
    if ( fgWorkDir == "" || ! access ) fFileName = "";
    else                               fFileName = fgWorkDir +  fFileName;
  }

  // Open the file.
  ios_base::openmode mode = ios_base::in|ios_base::binary;
  if ( ! input ) mode = ios_base::out|ios_base::binary;

  if ( fFileName == "" ) fHasErrors = kTRUE;
  else {
    fFile = new fstream(fFileName.c_str(),mode);
    if ( ! fFile->is_open() || ! fFile->good() ) {
      MSG("Dbi",Msg::kDebug) << "Cannot open " << fFileName
                             << "; all I/O will fail." << endl;
      fHasErrors = kTRUE;
    }
  }

}
//.....................................................................

DbiBinaryFile::~DbiBinaryFile()
{
//
//
//  Purpose:  Default Destructor.

  delete[] fArrayBuffer;
  fArrayBuffer = 0;
  this->Close();
  delete fFile;
  fFile = 0;

}
//.....................................................................

void DbiBinaryFile::Close()
{
//
//
//  Purpose:  Close file.

  if ( fFile ) fFile->close();
}

//  Builtin data type I/O.
//  **********************

#define READ_BUILTIN(t)                                   \
                                                          \
DbiBinaryFile& DbiBinaryFile::operator >> (t& v) {        \
  UInt_t numBytes = sizeof(v);                            \
  char* bytes = reinterpret_cast<char*>(&v);              \
  this->Read(bytes,numBytes);                             \
  return *this;                                           \
}
#define WRITE_BUILTIN(t)                                  \
                                                          \
DbiBinaryFile& DbiBinaryFile::operator << (const t& v) {  \
  UInt_t numBytes = sizeof(v);                            \
  const char* bytes = reinterpret_cast<const char*>(&v);  \
  this->Write(bytes,numBytes);                            \
  return *this;                                           \
}

READ_BUILTIN(Bool_t)
WRITE_BUILTIN(Bool_t)  
READ_BUILTIN(Int_t)
WRITE_BUILTIN(Int_t)  
READ_BUILTIN(UInt_t)
WRITE_BUILTIN(UInt_t)  
READ_BUILTIN(Double_t)
WRITE_BUILTIN(Double_t)  


//  Simple Virtual object I/O 
//  *************************

#define READ_SIMPLE(t)                                    \
                                                          \
DbiBinaryFile& DbiBinaryFile::operator >> (t& v) {        \
  void* vt = GetVTptr(&v);                                \
  UInt_t numBytes = sizeof(v);                            \
  char* bytes = reinterpret_cast<char*>(&v);              \
  this->Read(bytes,numBytes);                             \
  SetVTptr(&v,vt);                                        \
  return *this;                                           \
}
#define WRITE_SIMPLE(t)                                   \
                                                          \
DbiBinaryFile& DbiBinaryFile::operator << (const t& v) {  \
  UInt_t numBytes = sizeof(v);                            \
  const char* bytes = reinterpret_cast<const char*>(&v);  \
  this->Write(bytes,numBytes);                            \
  return *this;                                           \
}

READ_SIMPLE(VldTimeStamp)
WRITE_BUILTIN(VldTimeStamp)  


//  String I/O.
//  ***********

//.....................................................................

DbiBinaryFile& DbiBinaryFile::operator >> (string& str) {

  if ( this->CanRead() ) {
    getline(*fFile,str,'\0');
    this->CheckFileStatus();
  }
  return *this; 
}
//.....................................................................

DbiBinaryFile& DbiBinaryFile::operator << (const string& str) {

  UInt_t numBytes = str.size()+1;
  this->Write(str.c_str(),numBytes);
  return *this;
}

//.....................................................................

DbiBinaryFile& DbiBinaryFile::operator >> (VldRange& vr) {

  if ( this->CanRead() ) {
    Int_t        detectorMask; 
    Int_t        simMask;
    VldTimeStamp timeStart;
    VldTimeStamp timeEnd;
    string str;
    (*this) >> detectorMask
            >> simMask
            >> timeStart
            >> timeEnd
            >> str;
    TString dataSource(str.c_str());
    VldRange tmp(detectorMask,simMask,timeStart,timeEnd,dataSource);
    vr = tmp;
  }
  return *this; 
}
//.....................................................................

DbiBinaryFile& DbiBinaryFile::operator << (const VldRange& vr) {

  if ( this->CanWrite() ) {
    string str(vr.GetDataSource().Data());
    (*this) << vr.GetDetectorMask()
            << vr.GetSimMask()
            << vr.GetTimeStart()
            << vr.GetTimeEnd()
            << str;
  }
  return *this;
}

//.....................................................................

// Vector I/O.
// ***********

DbiBinaryFile& DbiBinaryFile::operator >> (vector<DbiTableRow*>& arr) {
//
//
//  Purpose: Read a vector of objects inheriting from DbiTableRow.

//   NB:     On entry, array must be empty.
//
//           
//           The objects are written into a buffer that is a contiguous 
//           area of memory that is allocated to receive it. After a 
//           successful read the user must call ReleaseArrayBuffer to take 
//           control over this buffer as it will be automatically release
//           when the next array input occurs otherwise.

//  For the format of record see the operator <<.

  if ( ! this->CanRead() ) return *this;

  if ( arr.size() ) {
    MAXMSG("Dbi",Msg::kError,20) << "Attempting to read into non-empty array" << endl;
    return *this;
  }

// Check for start of array marker.

  UInt_t marker = 0;
  (*this) >> marker;
  if ( marker != StartMarker ) {
    MAXMSG("Dbi",Msg::kError,20) << "Cannot find start of array marker" << endl;
    this->Close();
    this->CheckFileStatus();
    return *this;
  }

//  Get array size and deal with non-empty arrays.

  Int_t arrSize = 0;
  (*this) >> arrSize;

  if ( arrSize ) {
    Int_t objSize  = 0;
    string objName;
    (*this) >> objName >> objSize;

//  Ensure that sizes look sensible and use ROOT to instatiate
//  an example object so that we can get the address of the 
//  virtual table.

    TClass objClass(objName.c_str());
    Int_t objSizefromRoot = objClass.Size();
    void* obj = objClass.New();
    void* vt  = GetVTptr(obj);
//  This only works if the address of the sub-class object is the same
//  as the underlying base class, which should be true in this simple case.
    DbiTableRow* tr = reinterpret_cast<DbiTableRow*>(obj);
    delete tr;

    MSG("Dbi",Msg::kVerbose) 
         << "Restoring array of " << arrSize << " " 
         << objName << " objects"
         << "  VTaddr " << hex << vt << dec 
         << " object size "  << objSize << "(from file) "
         << objSizefromRoot << "(from ROOT)"
         << endl;

    if ( arrSize < 0 || objSize != objSizefromRoot ) {
      MAXMSG("Dbi",Msg::kError,20) << "Illegal  array size ("<< arrSize 
                            << ") or object size(" << objSize 
                            << "," << objSizefromRoot << ")" << endl;
      this->Close();
      this->CheckFileStatus();
      return *this;
    }

//  Allocate buffer and load in array.
    delete[] fArrayBuffer;
    Int_t buffSize = arrSize*objSize;
    fArrayBuffer = new char[buffSize];
    this->Read(fArrayBuffer,buffSize);

//  Fix up VT pointers and populate the vector.

    char* elem = fArrayBuffer;
    arr.reserve(arrSize);
    for (int row = 0; row < arrSize; ++row ) {
      SetVTptr(elem,vt);
      arr.push_back(reinterpret_cast<DbiTableRow*>(elem));
      elem += objSize;
    }

  }

//  Check for end of array marker.

  (*this) >> marker;
  if ( marker != EndMarker ) {
    MAXMSG("Dbi",Msg::kError,20) << "Cannot find end of array marker" << endl;
    this->Close();
    this->CheckFileStatus();
  }

  return *this;

}

//.....................................................................

DbiBinaryFile& DbiBinaryFile::operator << (vector<DbiTableRow*>& arr) { 
//
//
//  Purpose: Write a vector of objects inheriting from DbiTableRow.

//  Format of record:-
//  
//  Int_t   StartMarker  Start of record marker = 0xaabbccdd
//  Int_t   arrSize      Size of vector
//  
//  If size of vector > 0 this is folowed by:-
//  
//  string  objName      Name of object
//  Int_t   objSize      Size of object
//  char*                The data arrSize*objSize bytes long
//  
//  The record concludes:-
//  
//  Int_t     EndMarker  End of record marker = 0xddbbccaa


  if ( ! this->CanWrite() ) return *this;

  UInt_t marker = StartMarker;
  (*this) << marker;
  Int_t arrSize = arr.size();
  (*this) << arrSize;

  if ( arrSize ) {
    DbiTableRow* obj = arr[0];
    Int_t objSize  = obj->IsA()->Size();
    string objName = obj->ClassName();
    (*this) << objName << objSize;
    for (int row = 0; row < arrSize; ++row ) {
      obj = arr[row];
      const char* p = reinterpret_cast<const char*>(arr[row]);
      this->Write(p,objSize);
    }

  }

  marker = EndMarker;
  (*this) << marker;

  return *this;

}

// The functions that do the low-level I/O.
// ****************************************

//.....................................................................

Bool_t DbiBinaryFile::CanRead() {

  if ( ! fReading ) {
    MAXMSG("Dbi",Msg::kError,20) << "Attempting to read from a write-only file" << endl;
    return kFALSE;
  }
  return this->IsOK();

}
//.....................................................................

Bool_t DbiBinaryFile::CanWrite() {

  if ( fReading ) {
    MAXMSG("Dbi",Msg::kError,20) << "Attempting to write to a read-only file" << endl;
    return kFALSE;
  }
  return this->IsOK();

}

//.....................................................................

void DbiBinaryFile::CheckFileStatus() {

//  If file was good but has just gone bad, report and close it.
//  Delete it if writing.

  if (    fFile 
       && ! fHasErrors  
       && ( ! fFile->is_open() || ! fFile->good() ) ) {
    MAXMSG("Dbi",Msg::kError,20) << "File not open or has gone bad,"
                           << " all further I/O will fail." << endl;
    fHasErrors = kTRUE;
    this->Close();

    //Delete file if writing.
    if ( ! fReading ) {
      MAXMSG("Dbi",Msg::kError,20) << "Erasing " << fFileName << endl;
      gSystem->Unlink(fFileName.c_str());
    }

  }

}

//.....................................................................

Bool_t DbiBinaryFile::Read(char* bytes, UInt_t numBytes) {
//
//
//  Purpose: Low-level I/O with error checking. 
//

  if ( ! this->CanRead() ) return kFALSE;

  fFile->read(bytes,numBytes);
  this->CheckFileStatus();
  return ! fHasErrors;
}

//.....................................................................

Bool_t DbiBinaryFile::Write(const char* bytes, UInt_t numBytes) {
//
//
//  Purpose: Low-level I/O with error checking. 
//

  if ( ! this->CanWrite() ) return kFALSE;

  fFile->write(bytes,numBytes);
  this->CheckFileStatus();
  return ! fHasErrors;
}

---