(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.64 and 1.65

version 1.64, 2003/07/15 16:53:03 version 1.65, 2003/07/18 13:25:25
Line 92 
Line 92 
 } }
  
 // l10n TODO - finish the commented out constructors below // l10n TODO - finish the commented out constructors below
   /*
 IndexOutOfBoundsException::IndexOutOfBoundsException() IndexOutOfBoundsException::IndexOutOfBoundsException()
     : Exception("index out of bounds")     : Exception("index out of bounds")
 { {
 } }
   */
  
 /*  
 IndexOutOfBoundsException::IndexOutOfBoundsException() IndexOutOfBoundsException::IndexOutOfBoundsException()
     : Exception(MessageLoaderParms("key","index out of bounds"))      : Exception(MessageLoaderParms("Common.Exception.IndexOutOfBoundsException","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) AlreadyExistsException::AlreadyExistsException(const String& message)
     : Exception(MessageLoaderParms("key1",      : Exception(MessageLoaderParms("Common.Exception.AlreadyExistsException",
                                                                 "already exists: $0",                                                                 "already exists: $0",
 DON'T FORGET THE $0 for the rest of these!  
                                                                  message))                                                                  message))
 { {
 } }
  
 AlreadyExistsException::AlreadyExistsException(const MessageLoaderParms& msgParms)  AlreadyExistsException::AlreadyExistsException(MessageLoaderParms& msgParms)
     : Exception(MessageLoaderParms("key2",      : Exception(MessageLoaderParms("Common.Exception.AlreadyExistsException",
                                                                 "already exists: "))                                                                 "already exists: "))
 { {
         _rep->message.append(MessageLoader.getMessage(msgParms));          _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) InvalidNameException::InvalidNameException(const String& message)
     : Exception(MessageLoaderParms("key1",      : Exception(MessageLoaderParms("Common.Exception.InvalidNameException",
                                                                 "invalid CIM name: ",                                                                  "invalid CIM name: $0",
                                                                  message))                                                                  message))
 { {
 } }
  
 InvalidNameException::InvalidNameException(const MessageLoaderParms& msgParms)  InvalidNameException::InvalidNameException(MessageLoaderParms& msgParms)
     : Exception(MessageLoaderParms("key2",      : Exception(MessageLoaderParms("Common.Exception.InvalidNameException",
                                                                 "invalid CIM name: "))                                                                 "invalid CIM name: "))
 { {
         _rep->message.append(MessageLoader.getMessage(msgParms));          _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) InvalidNamespaceNameException::InvalidNamespaceNameException(const String& name)
     : Exception(MessageLoaderParms("key1",      : Exception(MessageLoaderParms("Common.Exception.InvalidNamespaceNameException",
                                                                 "invalid CIM namespace name: ",                                                                  "invalid CIM namespace name: $0",
                                                                  name))                                                                  name))
 { {
 } }
  
 InvalidNamespaceNameException::InvalidNamespaceNameException(const MessageLoaderParms& msgParms)  InvalidNamespaceNameException::InvalidNamespaceNameException(MessageLoaderParms& msgParms)
     : Exception(MessageLoaderParms("key2",      : Exception(MessageLoaderParms("Common.Exception.InvalidNamespaceNameException",
                                                                 "invalid CIM namespace name: "))                                                                 "invalid CIM namespace name: "))
 { {
         _rep->message.append(MessageLoader.getMessage(msgParms));          _rep->message.append(MessageLoader::getMessage(msgParms));
 } }
 */  
  
   /*
 UninitializedObjectException::UninitializedObjectException() UninitializedObjectException::UninitializedObjectException()
     : Exception("uninitialized object")     : Exception("uninitialized object")
 { {
 } }
   */
  
 /*  
 UninitializedObjectException::UninitializedObjectException() UninitializedObjectException::UninitializedObjectException()
     : Exception(MessageLoaderParms("key1",      : Exception(MessageLoaderParms("Common.Exception.UninitializedObjectException",
                                                                 "uninitialized object"))                                                                 "uninitialized object"))
 { {
 } }
 */  
  
   /*
 TypeMismatchException::TypeMismatchException() TypeMismatchException::TypeMismatchException()
     : Exception("type mismatch")     : Exception("type mismatch")
 { {
 } }
   */
  
 /*  
 TypeMismatchException::TypeMismatchException() TypeMismatchException::TypeMismatchException()
     : Exception(MessageLoaderParms("key1",      : Exception(MessageLoaderParms("Common.Exception.TypeMismatchException",
                                                                 "type mismatch"))                                                                 "type mismatch"))
 { {
 } }
 */  
  
   /*
 DynamicCastFailedException::DynamicCastFailedException() DynamicCastFailedException::DynamicCastFailedException()
     : Exception("dynamic cast failed")     : Exception("dynamic cast failed")
 { {
 } }
   */
  
 /*  
 DynamicCastFailedException::DynamicCastFailedException() DynamicCastFailedException::DynamicCastFailedException()
     : Exception(MessageLoaderParms("key1",      : Exception(MessageLoaderParms("Common.Exception.DynamicCastFailedException",
                                                                 "dynamic cast failed"))                                                                 "dynamic cast failed"))
 { {
 } }
 */  
  
   /*
 InvalidDateTimeFormatException::InvalidDateTimeFormatException() InvalidDateTimeFormatException::InvalidDateTimeFormatException()
     : Exception("invalid datetime format")     : Exception("invalid datetime format")
 { {
 } }
   */
  
 /*  
 InvalidDateTimeFormatException::InvalidDateTimeFormatException() InvalidDateTimeFormatException::InvalidDateTimeFormatException()
     : Exception(MessageLoaderParms("key1",      : Exception(MessageLoaderParms("Common.Exception.InvalidDateTimeFormatException",
                                                                 "invalid datetime format"))                                                                 "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) MalformedObjectNameException::MalformedObjectNameException(const String& message)
     : Exception(MessageLoaderParms("key1",      : Exception(MessageLoaderParms("Common.Exception.MalformedObjectNameException",
                                                                 "malformed object name: ",                                                                  "malformed object name: $0",
                                                                  message))                                                                  message))
 { {
 } }
  
 MalformedObjectNameException::MalformedObjectNameException(const MessageLoaderParms& msgParms)  MalformedObjectNameException::MalformedObjectNameException(MessageLoaderParms& msgParms)
     : Exception(MessageLoaderParms("key2",      : Exception(MessageLoaderParms("Common.Exception.MalformedObjectNameException",
                                                                 "malformed object name: "))                                                                 "malformed object name: "))
 { {
         _rep->message.append(MessageLoader.getMessage(msgParms));          _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) BindFailedException::BindFailedException(const String& message)
     : Exception(MessageLoaderParms("key1",      : Exception(MessageLoaderParms("Common.Exception.BindFailedException",
                                                                 "Bind failed: ",                                                                  "Bind failed: $0",
                                                                  message))                                                                  message))
 { {
 } }
  
 BindFailedException::BindFailedException(const MessageLoaderParms& msgParms)  BindFailedException::BindFailedException(MessageLoaderParms& msgParms)
     : Exception(MessageLoaderParms("key2",      : Exception(MessageLoaderParms("Common.Exception.BindFailedException",
                                                                 "Bind failed: "))                                                                 "Bind failed: "))
 { {
         _rep->message.append(MessageLoader.getMessage(msgParms));          _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) InvalidLocatorException::InvalidLocatorException(const String& message)
     : Exception(MessageLoaderParms("key1",      : Exception(MessageLoaderParms("Common.Exception.InvalidLocatorException",
                                                                 "Invalid locator: ",                                                                  "Invalid locator: $0",
                                                                  message))                                                                  message))
 { {
 } }
  
 InvalidLocatorException::InvalidLocatorException(const MessageLoaderParms& msgParms)  InvalidLocatorException::InvalidLocatorException(MessageLoaderParms& msgParms)
     : Exception(MessageLoaderParms("key2",      : Exception(MessageLoaderParms("Common.Exception.InvalidLocatorException",
                                                                 "Invalid locator: "))                                                                 "Invalid locator: "))
 { {
         _rep->message.append(MessageLoader.getMessage(msgParms));          _rep->message.append(MessageLoader::getMessage(msgParms));
 } }
 */  
  
   /*
 CannotCreateSocketException::CannotCreateSocketException() CannotCreateSocketException::CannotCreateSocketException()
     : Exception("Cannot create socket")     : Exception("Cannot create socket")
 { {
 } }
   */
  
 /*  
 CannotCreateSocketException::CannotCreateSocketException() CannotCreateSocketException::CannotCreateSocketException()
     : Exception(MessageLoaderParms("key1",      : Exception(MessageLoaderParms("Common.Exception.CannotCreateSocketException",
                                                                 "Cannot create socket"))                                                                 "Cannot create socket"))
 { {
 } }
 */  
  
 CannotConnectException::CannotConnectException(const String& message)  
   CannotConnectException::CannotConnectException(const String& message)//???
     : Exception(message)     : Exception(message)
 { {
 } }
 /*  
 CannotConnectException::CannotConnectException(const MessageLoaderParms& msgParms)  
   CannotConnectException::CannotConnectException(MessageLoaderParms& msgParms)
     : Exception(msgParms)     : Exception(msgParms)
 { {
 } }
 */  
  
   /*
 AlreadyConnectedException::AlreadyConnectedException() AlreadyConnectedException::AlreadyConnectedException()
     : Exception("already connected")     : Exception("already connected")
 { {
 } }
   */
  
 /*  
 AlreadyConnectedException::AlreadyConnectedException() AlreadyConnectedException::AlreadyConnectedException()
     : Exception(MessageLoaderParms("key1",      : Exception(MessageLoaderParms("Common.Exception.AlreadyConnectedException",
                                                                 "already connected"))                                                                 "already connected"))
 { {
 } }
 */  
  
   /*
 NotConnectedException::NotConnectedException() NotConnectedException::NotConnectedException()
     : Exception("not connected")     : Exception("not connected")
 { {
 } }
   */
  
 /*  
 NotConnectedException::NotConnectedException() NotConnectedException::NotConnectedException()
     : Exception(MessageLoaderParms("key1",      : Exception(MessageLoaderParms("Common.Exception.NotConnectedException",
                                                                 "not connected"))                                                                 "not connected"))
 { {
 } }
 */  
  
   /*
 ConnectionTimeoutException::ConnectionTimeoutException() ConnectionTimeoutException::ConnectionTimeoutException()
     : Exception("connection timed out")     : Exception("connection timed out")
 { {
 } }
   */
  
 /*  
 ConnectionTimeoutException::ConnectionTimeoutException() ConnectionTimeoutException::ConnectionTimeoutException()
     : Exception(MessageLoaderParms("key1",      : Exception(MessageLoaderParms("Common.Exception.ConnectionTimeoutException",
                                                                 "connection timed out"))                                                                 "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) SSLException::SSLException(const String& message)
     : Exception(MessageLoaderParms("key1",      : Exception(MessageLoaderParms("Common.Exception.SSLException",
                                                                 "SSL Exception: " ,                                                                  "SSL Exception: $0" ,
                                                                  message))                                                                  message))
 { {
 } }
  
 SSLException::SSLException(const MessageLoaderParms& msgParms)  SSLException::SSLException(MessageLoaderParms& msgParms)
     : Exception(MessageLoaderParms("key2",      : Exception(MessageLoaderParms("Common.Exception.SSLException",
                                                                 "SSL Exception: " ))                                                                 "SSL Exception: " ))
 { {
         _rep->message.append(MessageLoader.getMessage(msgParms));          _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) DateTimeOutOfRangeException::DateTimeOutOfRangeException(const String& message)
     : Exception(MessageLoaderParms("key1",      : Exception(MessageLoaderParms("Common.Exception.DateTimeOutOfRangeException",
                                                                 "DateTime is out of range : " ,                                                                  "DateTime is out of range : $0" ,
                                                                  message))                                                                  message))
 { {
 } }
  
 DateTimeOutOfRangeException::DateTimeOutOfRangeException(const MessageLoaderParms& msgParms)  DateTimeOutOfRangeException::DateTimeOutOfRangeException(MessageLoaderParms& msgParms)
     : Exception(MessageLoaderParms("key2",      : Exception(MessageLoaderParms("Common.Exception.DateTimeOutOfRangeException",
                                                                 "DateTime is out of range : " ))                                                                 "DateTime is out of range : " ))
 { {
         _rep->message.append(MessageLoader.getMessage(msgParms));          _rep->message.append(MessageLoader::getMessage(msgParms));
 } }
 */  
  
 //////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////
 // //

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