Per.cxx

Go to the documentation of this file.

//
// Per
//
// Package: Per (Persistency).
//
// S. Kasahara 11/00
//
// Purpose: Define data types and provide general purpose utility routines 
//          to the persistency package.
//

#include "TString.h"
#include "Persistency/Per.h"
#include "MessageService/MsgService.h"

// Static (file-level) constant not directly visible to the outside
// ****************************************************************

// kVldBegin has negative time stamp because I've seen erroneous negative
// time stamps in the data.  kVldEnd will need to be updated should the
// experiment last much longer than expected.
static const VldContext kVldBegin = 
  VldContext(Detector::kUnknown,SimFlag::kUnknown,
             VldTimeStamp::GetNBOT());
static const VldContext kVldEnd = 
  VldContext(Detector::kUnknown,SimFlag::kUnknown,
             VldTimeStamp::GetEOT());

CVSID("$Id: Per.cxx,v 1.21 2006/06/28 04:29:16 rhatcher Exp $");

// Definition of methods (alphabetical order)
// ******************************************

const char* Per::AsString(EAccessMode accessmode) {
  //  Purpose:  Convert enumerated accessmode to an access string.
  //
  //  Argument: accessmode: enumerated EAccessMode described in Per.h.
  //
  //  Return:  access string. If accessmode is unknown, returns "UNKNOWN".
  //
  //  Contact:   S. Kasahara
  //

  switch ( accessmode ) {
    case kRead:
      return "READ";
    case kNew:
      return "NEW";
    case kRecreate:
      return "RECREATE";
    case kUpdate:
      return "UPDATE";
    default:
      MSG("Per",Msg::kWarning) 
      << "Per::AsString called with unknown accessmode" 
      << (int)accessmode << endl;
      return "UNKNOWN";
  }//end of switch

}

const char* Per::AsString(EErrorCode errorcode) {
  //  Purpose:  Convert enumerated error code to an error string.
  //
  //  Argument: errorcode   enumerated EErrorCode described in Per.h.
  //
  //  Return:  error string. If error is unknown, returns "Unknown".
  //
  //  Contact:   S. Kasahara
  //

  switch ( errorcode ) {
    case kErrSuccess:
      return "Success";
    case kErrFileExists:
      return "FileExists";
    case kErrFileNotFound:
      return "FileNotFound";
    case kErrFileNoSpace:
      return "FileNoSpace";
    case kErrFileConflict:
      return "FileConflict";
    case kErrFileError:
      return "FileError";
    case kErrTreeExists:
      return "TreeExists";
    case kErrTreeReadError:
      return "TreeReadError"; 
    case kErrInvalidAccessMode:
      return "InvalidAccessMode";
    default:
      MSG("Per",Msg::kWarning) 
      << "Per::AsString called with unknown error code" 
      << (int)errorcode << endl;
      return "Unknown";
  }//end of switch

}

const char* Per::AsString(EStreamType streamtype) {
  //  Purpose:  Convert enumerated stream type to a stream string.
  //
  //  Argument: streamtype   enumerated EStreamType described in Per.h.
  //
  //  Return:  stream string. If stream is unknown, returns "Unknown".
  //
  //  Contact:   S. Kasahara
  //

  switch ( streamtype ) {
    case kDaqSnarl:
      return "DaqSnarl";
    case kDaqMonitor:
      return "DaqMonitor";
    case kLightInjection:
      return "LightInjection";
    case kDcsAlarm:
      return "DcsAlarm";
    case kDcsMonitor:
      return "DcsMonitor";
    case kBeamMon:
      return "BeamMon";
    case kCand:
      return "Cand";
    case kConfig:
      return "Config";
    default:
      MSG("Per",Msg::kWarning) 
      << "Per::AsString called with unknown stream type" 
      << (int)streamtype << endl;
      return "Unknown";
  }//end of switch

}

const char* Per::AsString(ESequenceMode sequencemode) {
  //  Purpose:  Convert enumerated sequencemode to a sequencemode string.
  //
  //  Argument: sequencemode: enumerated ESequenceMode described in Per.h.
  //
  //  Return:  sequencemode string. If unknown, returns "Unknown".
  //
  //  Contact:   S. Kasahara
  //

  switch ( sequencemode ) {
  case kKey:
    return "Key";
  case kLowerBound:
    return "LowerBound";
  case kWindow:
    return "Window";
  case kSequential:
    return "Sequential";
  case kRandom:
    return "Random";
  default:
    MSG("Per",Msg::kWarning) 
      << "Per::AsString called with unknown sequencemode" 
      << (int)sequencemode << endl;
    return "Unknown";
  }//end of switch

}

int Per::GetAccessMode(const char* accessmode) {
  // Purpose: Convert text string accessmode to an enumerated code.
  // 
  // Argument: accessmode string
  //
  // Return: returns -1 if no match
  //
  // Contact: S. Kasahara
  //

  TString tmpstr(accessmode);
  tmpstr.ToLower();
  if ( strcmp(tmpstr.Data(),"read") == 0 ) return Per::kRead;
  else if ( strcmp(tmpstr.Data(),"new") == 0 ) return Per::kNew;
  else if ( strcmp(tmpstr.Data(),"recreate") == 0 ) return Per::kRecreate;
  else if ( strcmp(tmpstr.Data(),"update") == 0 ) return Per::kUpdate;

  return -1;

}

int Per::GetSequenceMode(const char* sequencemode) {
  // Purpose: Convert text string sequencemode to an enumerated code.
  // 
  // Argument: sequencemode string
  //
  // Return: returns -1 if no match
  //
  // Contact: S. Kasahara
  //

  TString tmpstr(sequencemode);
  tmpstr.ToLower();
  if ( strcmp(tmpstr.Data(),"key") == 0 ) return Per::kKey;
  else if ( strcmp(tmpstr.Data(),"lowerbound") == 0 ) return Per::kLowerBound;

  return -1;

}

int Per::GetStreamType(const char* streamname) {
  // Purpose: Convert text string streamname to an enumerated code.
  // 
  // Argument: streamname string
  //
  // Return: returns -1 if no match
  //
  // Contact: S. Kasahara
  //

  TString tmpstr(streamname);
  tmpstr.ToLower();
  if ( strcmp(tmpstr.Data(),"daqsnarl") == 0 ) return Per::kDaqSnarl;
  else if ( strcmp(tmpstr.Data(),"daqmonitor") == 0 ) return Per::kDaqMonitor;
  else if ( strcmp(tmpstr.Data(),"lightinjection") == 0 ) 
                                                return Per::kLightInjection;
  else if ( strcmp(tmpstr.Data(),"dcsalarm") == 0 ) return Per::kDcsAlarm;
  else if ( strcmp(tmpstr.Data(),"dcsmonitor") == 0 ) return Per::kDcsMonitor;
  else if ( strcmp(tmpstr.Data(),"beammon") == 0 ) 
                                                return Per::kBeamMon;
  else if ( strcmp(tmpstr.Data(),"cand") == 0 ) return Per::kCand;
  else if ( strcmp(tmpstr.Data(),"config") == 0 ) return Per::kConfig;

  return -1;

}

Per::ESequenceMode Per::GetDefSequenceMode(const char* streamname) {
  //  Purpose:  Return default sequencemode for specified stream.
  //
  //  Argument: streamname (e.g. "Cand")
  //
  //  Return:  default sequence mode for this stream.  If stream
  //           is unknown, default of Per::kKey is returned.
  //
  //  Contact:   S. Kasahara
  //

  int streamtype = Per::GetStreamType(streamname);
  switch ( streamtype ) {
    case kConfig:
      return Per::kLowerBound;
    default:
      return Per::kKey;
  } // end of switch
  
}

const char* Per::GetAssociatedStreamList(const char* streamname) {
  //  Purpose:  Return streams associated (coupled) with specified stream.
  //
  //  Argument: streamname (e.g. "DaqSnarl")
  //
  //  Return:  default associated streamlist for this stream.  If stream
  //           is unknown, default of "" is returned.
  //
  //  Contact:   S. Kasahara
  //

  int streamtype = Per::GetStreamType(streamname);
  switch ( streamtype ) {
    case kCand:
      return "Config";
    default:
      return "";
  } // end of switch
  
}

const VldContext& Per::GetVldBegin() { return kVldBegin; }
const VldContext& Per::GetVldEnd()   { return kVldEnd;   }
bool Per::IsBegin(const VldContext& vldc) { return (vldc == kVldBegin); }
bool Per::IsEnd(const VldContext& vldc)   { return (vldc == kVldEnd); }

---