DDS.cxx

Go to the documentation of this file.

//                                                                         // 
// DDS                                                                     //
//                                                                         //
// Package: DDS (Data Dispatcher System).                                  //
//                                                                         //
// S. Kasahara 05/2001                                                     //
//                                                                         //
// Purpose: Define data types and provide general purpose utility methods  // 
//          to the data dispatcher system package.                         //
//                                                                         //

#include "TString.h"  // for use of ToLower method

#include "MessageService/MsgService.h"
#include "Dispatcher/DDS.h"

CVSID("$Id: DDS.cxx,v 1.19 2006/11/05 20:31:13 schubert Exp $");

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

const char* DDS::AsString(EDataSource datasource) {
  //  Purpose:  Convert enumerated data source to a data source string.
  //
  //  Argument: datasource   enumerated EDataSource described in DDS.h.
  //
  //  Return:  data source string of type const char*. If data source is
  //           unknown, returns "Unknown".
  //
  //  Contact:   S. Kasahara
  //

  switch ( datasource ) {
    case kDaq: 
      return "DAQ";
    case kDcs: 
      return "DCS";
    default:
      MSG("DDS",Msg::kWarning) 
      << "DDS::AsString called with unknown message type" 
      << (int)datasource << endl;
      return "Unknown";
  }//end of switch

}

const char* DDS::AsString(EKeepUpMode keepupmode) {
  //  Purpose:  Convert enumerated keepup mode to a keepup mode string.
  //
  //  Argument: keepupmode   enumerated EKeepUpMode described in DDS.h.
  //
  //  Return:  keepup mode string of type const char*. If keepup mode is
  //           unknown, returns "Unknown".
  //
  //  Contact:   S. Kasahara
  //

  switch ( keepupmode ) {
    case kAll: 
      return "All";
    case kFileKeepUp: 
      return "FileKeepUp";
    case kRecordKeepUp: 
      return "RecordKeepUp";
    default:
      MSG("DDS",Msg::kWarning) 
      << "DDS::AsString called with unknown keepup mode" 
      << (int)keepupmode << endl;
      return "Unknown";
  }//end of switch

}

const char* DDS::AsString(EMessageType messagetype) {
  //  Purpose:  Convert enumerated message type to a message string.
  //
  //  Argument: messagetype: enumerated EMessageType described in DDS.h.
  //
  //  Return:  message string of type const char*. If message type is
  //           unknown, returns "Unknown".
  //
  //  Contact:   S. Kasahara
  //

  switch ( messagetype ) {
    case kData: 
      return "Data";
    case kStatus: 
      return "Status";
    case kGoToFile:
      return "GoToFile";
    case kNext: 
      return "Next";
    case kSubscribe:  
      return "Subscribe";
    case kShutdown:
      return "Shutdown";
    case kPermissionDenied:
      return "PermissionDenied";
    case kSaturated:
      return "Saturated";
    case kFileError:
      return "FileError";
    case kTimeoutNewFile:
      return "TimeoutNewFile";
    case kTimeoutNewRecord:
      return "TimeoutNewRecord";
    case kInvalidSelection:
      return "InvalidSelection";
    case kMessageUnknown:
      return "MessageUnknown";
    case kOk:
      return "Ok";
    case kSocketError:
      return "SocketError";
    case kSystemError:
      return "SystemError";
    case kError:
      return "Error";
    case kInactive:
      return "Inactive";
    default:
      MSG("DDS",Msg::kWarning) 
      << "DDS::AsString called with unknown message type" 
      << (int)messagetype << endl;
      return "Unknown";
  }//end of switch

}

const char* DDS::AsString(EClientType clienttype) {
  //  Purpose:  Convert enumerated client type to a client string.
  //
  //  Argument: clienttype: enumerated EClientType described in DDS.h.
  //
  //  Return:  client type as string.  If unknown, returns "Unknown".
  //
  //  Contact:   S. Kasahara
  //

  switch ( clienttype ) {
    case kOnlineMonitor:
      return "OnlineMonitor";
    case kDatabaseUpdater:
      return "DatabaseUpdater";
    case kEventDisplay:
      return "EventDisplay";
    case kOther:
      return "Other";
    case kUnknownClientType:
      return "Unknown";
    default:
      MSG("DDS",Msg::kWarning)
      << "DDS::AsString called with unknown client type"
      << (int)clienttype << endl;
      return "Unknown";
  }//end of switch

}

int DDS::GetKeepUpCode(const char* keepupmode) {
  //  Purpose:  Convert text string keepup mode to an enumerated code.
  //
  //  Argument: keepupmode  string  
  //
  //  Return:  returns -1 if no match
  //
  //  Contact:   S. Kasahara
  //

  TString tmpstr(keepupmode);
  tmpstr.ToLower();
  if      ( strcmp(tmpstr.Data(),"all") == 0 ) return DDS::kAll;
  else if ( strcmp(tmpstr.Data(),"filekeepup") == 0 ) return DDS::kFileKeepUp;
  else if (strcmp(tmpstr.Data(),"recordkeepup")==0) return DDS::kRecordKeepUp;
  return -1;

}

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

  TString tmpstr(datasource);
  tmpstr.ToLower();
  if      ( strcmp(tmpstr.Data(),"daq") == 0 ) return DDS::kDaq;
  else if ( strcmp(tmpstr.Data(),"dcs") == 0 ) return DDS::kDcs;
  return -1;

}

DDS::EClientType DDS::GetClientType(const char* clienttype) {
  //  Purpose:  Convert text string clienttype to an enumerated code.
  //
  //  Argument: clienttype  string  
  //
  //  Return:  returns -1 if no match
  //
  //  Contact:   S. Kasahara
  //

  TString tmpstr(clienttype);
  tmpstr.ToLower();
  if (strcmp(tmpstr.Data(),"onlinemonitor")  ==0) return DDS::kOnlineMonitor;
  if (strcmp(tmpstr.Data(),"databaseupdater")==0) return DDS::kDatabaseUpdater;
  if (strcmp(tmpstr.Data(),"eventdisplay")   ==0) return DDS::kEventDisplay;
  if (strcmp(tmpstr.Data(),"other")          ==0) return DDS::kOther;
  if (strcmp(tmpstr.Data(),"unknown")      ==0) return DDS::kUnknownClientType;
  MSG("DDS",Msg::kWarning) << "DDS::GetClientType called with unknown"
                           << "\nclienttype " << clienttype 
                           << " Return DDS::kUnknownClientType." << endl;
  return DDS::kUnknownClientType;

}

---