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

Diff for /pegasus/src/Pegasus/Common/Exception.cpp between version 1.63 and 1.64

version 1.63, 2003/03/13 23:09:55 version 1.64, 2003/07/15 16:53:03
Line 45 
Line 45 
 { {
     _rep = new ExceptionRep();     _rep = new ExceptionRep();
     _rep->message = message;     _rep->message = message;
       _rep->contentLanguages = ContentLanguages::EMPTY;  // l10n
 } }
  
 Exception::Exception(const Exception& exception) Exception::Exception(const Exception& exception)
 { {
     _rep = new ExceptionRep();     _rep = new ExceptionRep();
     _rep->message = exception._rep->message;     _rep->message = exception._rep->message;
       _rep->contentLanguages = exception._rep->contentLanguages;    // l10n
   }
   
   // l10n
   Exception::Exception(const MessageLoaderParms& msgParms)
   {
       _rep = new ExceptionRep();
       _rep->message = MessageLoader::getMessage(
           const_cast<MessageLoaderParms &>(msgParms));
       // Must be after MessageLoader::getMessage call
       _rep->contentLanguages = msgParms.contentlanguages;
 } }
  
 Exception::Exception() Exception::Exception()
Line 67 
Line 79 
     return _rep->message;     return _rep->message;
 } }
  
   // l10n
   const ContentLanguages& Exception::getContentLanguages() const
   {
           return _rep->contentLanguages;
   }
   
   // l10n
   void Exception::setContentLanguages(const ContentLanguages& langs)
   {
           _rep->contentLanguages = langs;
   }
   
   // l10n TODO - finish the commented out constructors below
  
 IndexOutOfBoundsException::IndexOutOfBoundsException() IndexOutOfBoundsException::IndexOutOfBoundsException()
     : Exception("index out of bounds")     : Exception("index out of bounds")
 { {
 } }
  
   /*
   IndexOutOfBoundsException::IndexOutOfBoundsException()
       : Exception(MessageLoaderParms("key","index out of bounds"))
   {
   }
   */
   
 AlreadyExistsException::AlreadyExistsException(const String& message) AlreadyExistsException::AlreadyExistsException(const String& message)
     : Exception("already exists: " + message)     : Exception("already exists: " + message)
 { {
 } }
  
   /*
   AlreadyExistsException::AlreadyExistsException(const String& message)
       : Exception(MessageLoaderParms("key1",
                                                                   "already exists: $0",
   DON'T FORGET THE $0 for the rest of these!
                                                                    message))
   {
   }
   
   AlreadyExistsException::AlreadyExistsException(const MessageLoaderParms& msgParms)
       : Exception(MessageLoaderParms("key2",
                                                                   "already exists: "))
   {
           _rep->message.append(MessageLoader.getMessage(msgParms));
   }
   */
   
 InvalidNameException::InvalidNameException(const String& name) InvalidNameException::InvalidNameException(const String& name)
     : Exception("invalid CIM name: " + name)     : Exception("invalid CIM name: " + name)
 { {
 } }
  
   /*
   InvalidNameException::InvalidNameException(const String& message)
       : Exception(MessageLoaderParms("key1",
                                                                   "invalid CIM name: ",
                                                                    message))
   {
   }
   
   InvalidNameException::InvalidNameException(const MessageLoaderParms& msgParms)
       : Exception(MessageLoaderParms("key2",
                                                                   "invalid CIM name: "))
   {
           _rep->message.append(MessageLoader.getMessage(msgParms));
   }
   */
   
 InvalidNamespaceNameException::InvalidNamespaceNameException(const String& name) InvalidNamespaceNameException::InvalidNamespaceNameException(const String& name)
     : Exception("invalid CIM namespace name: " + name)     : Exception("invalid CIM namespace name: " + name)
 { {
 } }
  
   /*
   InvalidNamespaceNameException::InvalidNamespaceNameException(const String& name)
       : Exception(MessageLoaderParms("key1",
                                                                   "invalid CIM namespace name: ",
                                                                    name))
   {
   }
   
   InvalidNamespaceNameException::InvalidNamespaceNameException(const MessageLoaderParms& msgParms)
       : Exception(MessageLoaderParms("key2",
                                                                   "invalid CIM namespace name: "))
   {
           _rep->message.append(MessageLoader.getMessage(msgParms));
   }
   */
   
 UninitializedObjectException::UninitializedObjectException() UninitializedObjectException::UninitializedObjectException()
     : Exception("uninitialized object")     : Exception("uninitialized object")
 { {
 } }
  
   /*
   UninitializedObjectException::UninitializedObjectException()
       : Exception(MessageLoaderParms("key1",
                                                                   "uninitialized object"))
   {
   }
   */
   
 TypeMismatchException::TypeMismatchException() TypeMismatchException::TypeMismatchException()
     : Exception("type mismatch")     : Exception("type mismatch")
 { {
 } }
  
   /*
   TypeMismatchException::TypeMismatchException()
       : Exception(MessageLoaderParms("key1",
                                                                   "type mismatch"))
   {
   }
   */
   
 DynamicCastFailedException::DynamicCastFailedException() DynamicCastFailedException::DynamicCastFailedException()
     : Exception("dynamic cast failed")     : Exception("dynamic cast failed")
 { {
 } }
  
   /*
   DynamicCastFailedException::DynamicCastFailedException()
       : Exception(MessageLoaderParms("key1",
                                                                   "dynamic cast failed"))
   {
   }
   */
   
 InvalidDateTimeFormatException::InvalidDateTimeFormatException() InvalidDateTimeFormatException::InvalidDateTimeFormatException()
     : Exception("invalid datetime format")     : Exception("invalid datetime format")
 { {
 } }
  
   /*
   InvalidDateTimeFormatException::InvalidDateTimeFormatException()
       : Exception(MessageLoaderParms("key1",
                                                                   "invalid datetime format"))
   {
   }
   */
   
 MalformedObjectNameException::MalformedObjectNameException( MalformedObjectNameException::MalformedObjectNameException(
     const String& objectName)     const String& objectName)
     : Exception("malformed object name: " + objectName)     : Exception("malformed object name: " + objectName)
 { {
 } }
  
   /*
   MalformedObjectNameException::MalformedObjectNameException(const String& message)
       : Exception(MessageLoaderParms("key1",
                                                                   "malformed object name: ",
                                                                    message))
   {
   }
   
   MalformedObjectNameException::MalformedObjectNameException(const MessageLoaderParms& msgParms)
       : Exception(MessageLoaderParms("key2",
                                                                   "malformed object name: "))
   {
           _rep->message.append(MessageLoader.getMessage(msgParms));
   }
   */
   
 BindFailedException::BindFailedException(const String& message) BindFailedException::BindFailedException(const String& message)
     : Exception("Bind failed: " + message)     : Exception("Bind failed: " + message)
 { {
 } }
  
   /*
   BindFailedException::BindFailedException(const String& message)
       : Exception(MessageLoaderParms("key1",
                                                                   "Bind failed: ",
                                                                    message))
   {
   }
   
   BindFailedException::BindFailedException(const MessageLoaderParms& msgParms)
       : Exception(MessageLoaderParms("key2",
                                                                   "Bind failed: "))
   {
           _rep->message.append(MessageLoader.getMessage(msgParms));
   }
   */
   
 InvalidLocatorException::InvalidLocatorException(const String& locator) InvalidLocatorException::InvalidLocatorException(const String& locator)
     : Exception("Invalid locator: " + locator)     : Exception("Invalid locator: " + locator)
 { {
 } }
  
   /*
   InvalidLocatorException::InvalidLocatorException(const String& message)
       : Exception(MessageLoaderParms("key1",
                                                                   "Invalid locator: ",
                                                                    message))
   {
   }
   
   InvalidLocatorException::InvalidLocatorException(const MessageLoaderParms& msgParms)
       : Exception(MessageLoaderParms("key2",
                                                                   "Invalid locator: "))
   {
           _rep->message.append(MessageLoader.getMessage(msgParms));
   }
   */
   
 CannotCreateSocketException::CannotCreateSocketException() CannotCreateSocketException::CannotCreateSocketException()
     : Exception("Cannot create socket")     : Exception("Cannot create socket")
 { {
 } }
  
   /*
   CannotCreateSocketException::CannotCreateSocketException()
       : Exception(MessageLoaderParms("key1",
                                                                   "Cannot create socket"))
   {
   }
   */
   
 CannotConnectException::CannotConnectException(const String& message) CannotConnectException::CannotConnectException(const String& message)
     : Exception(message)     : Exception(message)
 { {
 } }
   /*
   CannotConnectException::CannotConnectException(const MessageLoaderParms& msgParms)
       : Exception(msgParms)
   {
   }
   */
  
 AlreadyConnectedException::AlreadyConnectedException() AlreadyConnectedException::AlreadyConnectedException()
     : Exception("already connected")     : Exception("already connected")
 { {
 } }
  
   /*
   AlreadyConnectedException::AlreadyConnectedException()
       : Exception(MessageLoaderParms("key1",
                                                                   "already connected"))
   {
   }
   */
   
 NotConnectedException::NotConnectedException() NotConnectedException::NotConnectedException()
     : Exception("not connected")     : Exception("not connected")
 { {
 } }
  
   /*
   NotConnectedException::NotConnectedException()
       : Exception(MessageLoaderParms("key1",
                                                                   "not connected"))
   {
   }
   */
   
 ConnectionTimeoutException::ConnectionTimeoutException() ConnectionTimeoutException::ConnectionTimeoutException()
     : Exception("connection timed out")     : Exception("connection timed out")
 { {
 } }
  
   /*
   ConnectionTimeoutException::ConnectionTimeoutException()
       : Exception(MessageLoaderParms("key1",
                                                                   "connection timed out"))
   {
   }
   */
   
 SSLException::SSLException(const String& message) SSLException::SSLException(const String& message)
     : Exception("SSL Exception: " + message)     : Exception("SSL Exception: " + message)
 { {
 } }
  
   /*
   SSLException::SSLException(const String& message)
       : Exception(MessageLoaderParms("key1",
                                                                   "SSL Exception: " ,
                                                                    message))
   {
   }
   
   SSLException::SSLException(const MessageLoaderParms& msgParms)
       : Exception(MessageLoaderParms("key2",
                                                                   "SSL Exception: " ))
   {
           _rep->message.append(MessageLoader.getMessage(msgParms));
   }
   */
   
 DateTimeOutOfRangeException::DateTimeOutOfRangeException(const String& message) DateTimeOutOfRangeException::DateTimeOutOfRangeException(const String& message)
     : Exception("DateTime is out of range : " + message)     : Exception("DateTime is out of range : " + message)
 { {
 } }
  
   /*
   DateTimeOutOfRangeException::DateTimeOutOfRangeException(const String& message)
       : Exception(MessageLoaderParms("key1",
                                                                   "DateTime is out of range : " ,
                                                                    message))
   {
   }
   
   DateTimeOutOfRangeException::DateTimeOutOfRangeException(const MessageLoaderParms& msgParms)
       : Exception(MessageLoaderParms("key2",
                                                                   "DateTime is out of range : " ))
   {
           _rep->message.append(MessageLoader.getMessage(msgParms));
   }
   */
   
 //////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////
 // //
 // CIMException // CIMException
 // //
 //////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////
  
   // l10n - note - use this when you have an exception with no
   // detail message, or one with an untranslated detail message
   // The pegasus message associated with code will be translated.
 CIMException::CIMException( CIMException::CIMException(
     CIMStatusCode code,     CIMStatusCode code,
     const String& message)     const String& message)
Line 175 
Line 409 
     tmp->code = code;     tmp->code = code;
     tmp->file = "";     tmp->file = "";
     tmp->line = 0;     tmp->line = 0;
       tmp->contentLanguages = ContentLanguages::EMPTY;
       tmp->cimMessage = String::EMPTY;
       _rep = tmp;
   }
   
   // l10n - note use this when you have an exception with a translated
   // detail message
   // l10n
   CIMException::CIMException(
       CIMStatusCode code,
       const MessageLoaderParms& msgParms)
       : Exception()
   {
       CIMExceptionRep * tmp = new CIMExceptionRep ();
       tmp->message = MessageLoader::getMessage(
           const_cast<MessageLoaderParms &>(msgParms));
       // Must be after MessageLoader::getMessage call
       tmp->contentLanguages = msgParms.contentlanguages;
       tmp->cimMessage = String::EMPTY;
       tmp->code = code;
       tmp->file = "";
       tmp->line = 0;
     _rep = tmp;     _rep = tmp;
 } }
  
Line 185 
Line 441 
     CIMExceptionRep * rep;     CIMExceptionRep * rep;
     rep = reinterpret_cast<CIMExceptionRep*>(cimException._rep);     rep = reinterpret_cast<CIMExceptionRep*>(cimException._rep);
     tmp->message = rep->message;     tmp->message = rep->message;
       tmp->contentLanguages = rep->contentLanguages;  // l10n
       tmp->cimMessage = rep->cimMessage;  // l10n
     tmp->code = rep->code;     tmp->code = rep->code;
     tmp->file = rep->file;     tmp->file = rep->file;
     tmp->line = rep->line;     tmp->line = rep->line;
Line 198 
Line 456 
     left = reinterpret_cast<CIMExceptionRep*>(this->_rep);     left = reinterpret_cast<CIMExceptionRep*>(this->_rep);
     right = reinterpret_cast<CIMExceptionRep*>(cimException._rep);     right = reinterpret_cast<CIMExceptionRep*>(cimException._rep);
     left->message = right->message;     left->message = right->message;
       left->contentLanguages = right->contentLanguages;  // l10n
       left->cimMessage = right->cimMessage;  // l10n
     left->code = right->code;     left->code = right->code;
     left->file = right->file;     left->file = right->file;
     left->line = right->line;     left->line = right->line;

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