(file) Return to ClientPerfDataStore.cpp CVS log (file) (dir) Up to [Pegasus] / pegasus / src / Pegasus / Client

Diff for /pegasus/src/Pegasus/Client/ClientPerfDataStore.cpp between version 1.2 and 1.3

version 1.2, 2005/02/05 22:59:19 version 1.3, 2005/02/25 04:18:02
Line 27 
Line 27 
 // //
 //============================================================================== //==============================================================================
 // //
 // Author: Willis White (whiwill@us.ibm.com  // Author: Willis White (whiwill@us.ibm.com)
 // //
 // Modified By: // Modified By:
 // //
 //%/////////////////////////////////////////////////////////////////////////////  //%/////////////////////////////////////////////////////////////b////////////////
  
  
 #include "ClientPerfDataStore.h" #include "ClientPerfDataStore.h"
Line 39 
Line 39 
  
 PEGASUS_USING_STD; PEGASUS_USING_STD;
  
   PEGASUS_USING_STD;
 PEGASUS_NAMESPACE_BEGIN PEGASUS_NAMESPACE_BEGIN
  
 ClientPerfDataStore* ClientPerfDataStore::current_Store = NULL; ClientPerfDataStore* ClientPerfDataStore::current_Store = NULL;
  
 ClientPerfDataStore* ClientPerfDataStore::current(){  ClientPerfDataStore* ClientPerfDataStore::Instance(){
    if (current_Store == NULL){     static ClientPerfDataStore current_Store;
       current_Store = new ClientPerfDataStore();     return &current_Store;
    }  
    return current_Store;  
 } }
  
   
 ClientPerfDataStore::ClientPerfDataStore() ClientPerfDataStore::ClientPerfDataStore()
 {   current_Store = this;  {
  /*   serverTimeValid = false;  
     serverTime = 0;  
     networkStartTime = CIMDateTime("00000000000000.000000+000");  
     networkEndTime = CIMDateTime("00000000000000.000000+000");  
     requestSize = 0;  
     responseSize = 0;  
     messID = "";   */  
   
 } }
  
 void ClientPerfDataStore::reset() void ClientPerfDataStore::reset()
 { {
     operationType = CIMOPTYPE_INVOKE_METHOD;      _operationType = CIMOPTYPE_INVOKE_METHOD;
     serverTimeValid = false;      _serverTimeKnown = false;
     serverTime = 0;      _errorCondition = false;
     networkStartTime = CIMDateTime(); //CIMDateTime("00000000000000.000000-000");      _serverTime = 0;
     networkEndTime = CIMDateTime(); //CIMDateTime("00000000000000.000000-000");      _networkStartTime = CIMDateTime();
     requestSize = 0;      _networkEndTime = CIMDateTime();
     responseSize = 0;      _requestSize = 0;
     messID = "";      _responseSize = 0;
       _messID = "";
  
 } }
  
  
 ClientOpPerformanceData ClientPerfDataStore::createPerfDataSrtuct()  bClientOpPerformanceData ClientPerfDataStore::createPerfDataStruct()
 { {
     ClientOpPerformanceData * cOPD;      ClientOpPerformanceData _ClientOpPerfData_obj;
     cOPD = new ClientOpPerformanceData;      _ClientOpPerfData_obj.roundTripTime = (_networkEndTime-_networkStartTime).toMicroSeconds();
     return *cOPD;      _ClientOpPerfData_obj.operationType = _operationType;
       _ClientOpPerfData_obj.requestSize = _requestSize;
       _ClientOpPerfData_obj.responseSize = _responseSize;
       _ClientOpPerfData_obj.serverTimeKnown = _serverTimeKnown;
       if (_serverTimeKnown) {
           _ClientOpPerfData_obj.serverTime = _serverTime;
       }
       return _ClientOpPerfData_obj;
 } }
  
  
  
 void ClientPerfDataStore::setServerTime(Uint32 time)  void ClientPerfDataStore::setServerTime(Uint64 time)
 {   serverTime = time;  {   _serverTime = time;
     serverTimeValid = true;      _serverTimeKnown = true;
 } }
  
  
 void ClientPerfDataStore::setResponseSize(Uint32 size)  void ClientPerfDataStore::setResponseSize(Uint64 size)
 { responseSize = size; }  { _responseSize = size; }
  
  
 void ClientPerfDataStore::setRequestSize(Uint32 size)  void ClientPerfDataStore::setRequestSize(Uint64 size)
 {  requestSize = size; }  {  _requestSize = size; }
  
  
 void ClientPerfDataStore::setStartNetworkTime(void) void ClientPerfDataStore::setStartNetworkTime(void)
 { networkStartTime = CIMDateTime::getCurrentDateTime();  }  { _networkStartTime = CIMDateTime::getCurrentDateTime();  }
   
  
 void ClientPerfDataStore::setEndNetworkTime(CIMDateTime time) void ClientPerfDataStore::setEndNetworkTime(CIMDateTime time)
 { networkEndTime = time; }  { _networkEndTime = time; }
  
  
 void ClientPerfDataStore::setValidServerTime(Boolean bol)  void ClientPerfDataStore::setServerTimeKnown(Boolean bol)
 {   serverTimeValid = bol; }  {   _serverTimeKnown = bol; }
   
  
 void ClientPerfDataStore::setMessageID(String messageID) void ClientPerfDataStore::setMessageID(String messageID)
 { messID = messageID; }  { _messID = messageID; }
  
  
 CIMOperationType ClientPerfDataStore::setOperationType(Uint32 type)  void ClientPerfDataStore::setOperationType(Uint32 type)
 {   //this function needs to translate message type (type) to CIMOperationType  {
    //CIMOperationType oT = CIMOPTYPE_EMPTY;    _operationType = Message::convertMessageTypetoCIMOpType(type);
    //return oT;  }
  
     Uint32 in_type, enum_type;  
     CIMOperationType cT;  
  
   Boolean ClientPerfDataStore::checkMessageIDandType(String messageID, Uint32 type)
   { if(_messID != messageID)
     {
       _errorCondition = true;
       cerr << " error being set in check method for messageID" << endl;
       return false;
     }
   
     if (_operationType != Message::convertMessageTypetoCIMOpType(type))
     {
       _errorCondition = true;
       cerr << " error being set in check method for type" << endl;
       return false;
     }
  
     in_type = type%40;      /* groups request/response message by type ie. getClassRequestMessage    return true;
                                 (type = 1) gives the same result as getClassResponseMessage (type = 41)*/  }
  
     if (in_type < 3) {  String ClientPerfDataStore::toString()
         enum_type = in_type;  {
       Array<char> out;
       /*XMLWriter::append(out, String(" serverTime = ");
       XMLWriter::append(out, _serverTime);
        << "\r\n";  */
       out << " operation type  = " << (Uint32)_operationType << "\r\n";
       out << " network start time is = " << _networkStartTime.toString() << "\r\n";
       out << " network end time = " << _networkEndTime.toString() << "\r\n";
       out << " numberofRequestBytes = " << (Uint32)_requestSize << "\r\n";
       out << " number foRespoonse Bytes = " << (Uint32)_responseSize << "\r\n";
       out << "the message ID is " << _messID << "\r\n";
       if (_errorCondition) {
           out << "the error condition is true " << "\r\n";
     }     }
     else if((3 < in_type) && (in_type < 25)){      else{
         enum_type = in_type -1;          out << " he error condition is false" << "\r\n";
     }     }
     else if (in_type == 25) {      if (_classRegistered) {
         enum_type = 0;          out << "there is a class registered" << "\r\n";
     }     }
     else{     else{
         //set error          out << "no class is registered" << "\r\n";
         cout << "error getting type" << endl;      }
       if (_serverTimeKnown) {
           out << "_serverTimeKnown is true" << "\r\n";
       }
       else{
           out << "_serverTimeKnown is false" << "\r\n";
     }     }
  
       //return a Pegasus String constructed form the array "out"
     cT = (CIMOperationType)enum_type;      return (String(out.getData(), out.size()));
     operationType = cT;  
     return cT;  
   
 } }
  
 //void ClientPerfDataStore::setErrorCondition(Boolean bol)  
 //{  errorCondition = bol; }  
  
 Boolean ClientPerfDataStore::checkMessageIDandType(String & messageID, CIMOperationType type)  
 { if(messID == messageID)  
     { return true; }  
   else  
     { return false;}  
 }  
  
 void ClientPerfDataStore::print()  Boolean ClientPerfDataStore::getStatError()
 { {
     cout << " serverTime = " << serverTime << endl;      return _errorCondition;
     cout << " operation type  = " << (Uint32) operationType << endl;  
     cout << " network start time is = " << networkStartTime.toString() << endl;  
     cout << " network end time = " << networkEndTime.toString() << endl;  
     cout << " numberofRequestBytes = " << requestSize << endl;  
     cout << " number foRespoonse Bytes = " << responseSize << endl;  
     cout << "the message ID is " << messID << endl;  
 } }
  
   void ClientPerfDataStore::setClassRegistered(Boolean bol)
   {
       _classRegistered = bol;
   }
  
   Boolean ClientPerfDataStore::isClassRegistered()
   {
       return _classRegistered;
   }
  
 PEGASUS_NAMESPACE_END PEGASUS_NAMESPACE_END
  

Legend:
Removed from v.1.2  
changed lines
  Added in v.1.3
No CVS admin address has been configured
 Powered by
ViewCVS 0.9.2