(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.79 and 1.80

version 1.79, 2006/10/31 18:29:36 version 1.80, 2006/11/08 22:24:00
Line 29 
Line 29 
 // //
 //============================================================================== //==============================================================================
 // //
 // Author: Mike Brasher (mbrasher@bmc.com)  
 //  
 // Modified By: Nag Boranna, Hewlett-Packard Company (nagaraja_boranna@hp.com)  
 //              Jenny Yu, Hewlett-Packard Company (jenny_yu@hp.com)  
 //              Carol Ann Krug Graves, Hewlett-Packard Company  
 //                (carolann_graves@hp.com)  
 //              Roger Kumpf, Hewlett-Packard Company (roger_kumpf@hp.com)  
 //              Sushma Fernandes , Hewlett-Packard Company  
 //                (sushma_fernandes@hp.com)  
 //              Amit K Arora, IBM (amita@in.ibm.com) for bug# 1593  
 //  
 //%///////////////////////////////////////////////////////////////////////////// //%/////////////////////////////////////////////////////////////////////////////
  
 #include <cstdio> #include <cstdio>
Line 61 
Line 50 
 { {
     _rep = new ExceptionRep();     _rep = new ExceptionRep();
     _rep->message = exception._rep->message;     _rep->message = exception._rep->message;
     _rep->contentLanguages = exception._rep->contentLanguages;    // l10n      _rep->contentLanguages = exception._rep->contentLanguages;
 } }
  
 // l10n  
 Exception::Exception(const MessageLoaderParms& msgParms) Exception::Exception(const MessageLoaderParms& msgParms)
 { {
     _rep = new ExceptionRep();     _rep = new ExceptionRep();
Line 89 
Line 77 
     return _rep->message;     return _rep->message;
 } }
  
 // l10n  
 const ContentLanguageList& Exception::getContentLanguages() const const ContentLanguageList& Exception::getContentLanguages() const
 { {
         return _rep->contentLanguages;         return _rep->contentLanguages;
 } }
  
 // l10n  
 void Exception::setContentLanguages(const ContentLanguageList& langs) void Exception::setContentLanguages(const ContentLanguageList& langs)
 { {
         _rep->contentLanguages = langs;         _rep->contentLanguages = langs;
 } }
  
 /*  
 IndexOutOfBoundsException::IndexOutOfBoundsException()  
     : Exception("index out of bounds")  
 {  
 }  
 */  
   
 IndexOutOfBoundsException::IndexOutOfBoundsException() IndexOutOfBoundsException::IndexOutOfBoundsException()
     : Exception(MessageLoaderParms("Common.Exception.INDEX_OUT_OF_BOUNDS_EXCEPTION","index out of bounds"))      : Exception(MessageLoaderParms(
             "Common.Exception.INDEX_OUT_OF_BOUNDS_EXCEPTION",
             "index out of bounds"))
 { {
 } }
  
 /*  
 AlreadyExistsException::AlreadyExistsException(const String& message) AlreadyExistsException::AlreadyExistsException(const String& message)
     : Exception("already exists: " + message)      : Exception(MessageLoaderParms(
 {            "Common.Exception.ALREADY_EXISTS_EXCEPTION",
 }  
 */  
   
 AlreadyExistsException::AlreadyExistsException(const String& message)  
     : Exception(MessageLoaderParms("Common.Exception.ALREADY_EXISTS_EXCEPTION",  
                                                 "already exists: $0",                                                 "already exists: $0",
                                                 message))                                                 message))
 { {
 } }
  
 AlreadyExistsException::AlreadyExistsException(MessageLoaderParms& msgParms) AlreadyExistsException::AlreadyExistsException(MessageLoaderParms& msgParms)
     : Exception(MessageLoaderParms("Common.Exception.ALREADY_EXISTS_EXCEPTION",      : Exception(MessageLoaderParms(
             "Common.Exception.ALREADY_EXISTS_EXCEPTION",
                                                         "already exists: "))                                                         "already exists: "))
 { {
         _rep->message.append(MessageLoader::getMessage(msgParms));         _rep->message.append(MessageLoader::getMessage(msgParms));
 } }
  
 /*  
 InvalidNameException::InvalidNameException(const String& name)  
     : Exception("invalid CIM name: " + name)  
 {  
 }  
 */  
   
 InvalidNameException::InvalidNameException(const String& message) InvalidNameException::InvalidNameException(const String& message)
     : Exception(MessageLoaderParms("Common.Exception.INVALID_NAME_EXCEPTION",      : Exception(MessageLoaderParms(
             "Common.Exception.INVALID_NAME_EXCEPTION",
                                                                 "invalid CIM name: $0",                                                                 "invalid CIM name: $0",
                                                                  message))                                                                  message))
 { {
 } }
  
 InvalidNameException::InvalidNameException(MessageLoaderParms& msgParms) InvalidNameException::InvalidNameException(MessageLoaderParms& msgParms)
     : Exception(MessageLoaderParms("Common.Exception.INVALID_NAME_EXCEPTION",      : Exception(MessageLoaderParms(
             "Common.Exception.INVALID_NAME_EXCEPTION",
                                                                 "invalid CIM name: "))                                                                 "invalid CIM name: "))
 { {
         _rep->message.append(MessageLoader::getMessage(msgParms));         _rep->message.append(MessageLoader::getMessage(msgParms));
 } }
  
 /*  
 InvalidNamespaceNameException::InvalidNamespaceNameException(const String& name)  
     : Exception("invalid CIM namespace name: " + name)  
 {  
 }  
 */  
   
   
 InvalidNamespaceNameException::InvalidNamespaceNameException(const String& name) InvalidNamespaceNameException::InvalidNamespaceNameException(const String& name)
     : Exception(MessageLoaderParms("Common.Exception.INVALID_NAMESACE_NAME_EXCEPTION",      : Exception(MessageLoaderParms(
             "Common.Exception.INVALID_NAMESACE_NAME_EXCEPTION",
                                                                 "invalid CIM namespace name: $0",                                                                 "invalid CIM namespace name: $0",
                                                                  name))                                                                  name))
 { {
 } }
  
 InvalidNamespaceNameException::InvalidNamespaceNameException(MessageLoaderParms& msgParms)  InvalidNamespaceNameException::InvalidNamespaceNameException(
     : Exception(MessageLoaderParms("Common.Exception.INVALID_NAMESPACE_NAME_EXCEPTION",      MessageLoaderParms& msgParms)
       : Exception(MessageLoaderParms(
             "Common.Exception.INVALID_NAMESPACE_NAME_EXCEPTION",
                                                                 "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(MessageLoaderParms(
 {            "Common.Exception.UNINITIALIZED_OBJECT_EXCEPTION",
 }  
 */  
   
 UninitializedObjectException::UninitializedObjectException()  
     : Exception(MessageLoaderParms("Common.Exception.UNINITIALIZED_OBJECT_EXCEPTION",  
                                                                 "uninitialized object"))                                                                 "uninitialized object"))
 { {
 } }
  
 /*  
 TypeMismatchException::TypeMismatchException()  
     : Exception("type mismatch")  
 {  
 }  
 */  
   
 TypeMismatchException::TypeMismatchException() TypeMismatchException::TypeMismatchException()
     : Exception(MessageLoaderParms("Common.Exception.TYPE_MISMATCH_EXCEPTION",      : Exception(MessageLoaderParms(
             "Common.Exception.TYPE_MISMATCH_EXCEPTION",
                                                                 "type mismatch"))                                                                 "type mismatch"))
 { {
 } }
  
 TypeMismatchException::TypeMismatchException(const String& message) TypeMismatchException::TypeMismatchException(const String& message)
     : Exception(MessageLoaderParms("Common.Exception.TYPE_MISMATCH_EXCEPTION",      : Exception(MessageLoaderParms(
             "Common.Exception.TYPE_MISMATCH_EXCEPTION",
                                                                 "type mismatch: $0",message))                                                                 "type mismatch: $0",message))
 { {
  
 } }
  
 TypeMismatchException::TypeMismatchException(MessageLoaderParms& msgParms) TypeMismatchException::TypeMismatchException(MessageLoaderParms& msgParms)
     : Exception(MessageLoaderParms("Common.Exception.TYPE_MISMATCH_EXCEPTION",      : Exception(MessageLoaderParms(
             "Common.Exception.TYPE_MISMATCH_EXCEPTION",
                                                                 "type mismatch: "))                                                                 "type mismatch: "))
 { {
     _rep->message.append(MessageLoader::getMessage(msgParms));     _rep->message.append(MessageLoader::getMessage(msgParms));
 } }
  
 /*  
 DynamicCastFailedException::DynamicCastFailedException() DynamicCastFailedException::DynamicCastFailedException()
     : Exception("dynamic cast failed")      : Exception(MessageLoaderParms(
 {            "Common.Exception.DYNAMIC_CAST_FAILED_EXCEPTION",
 }  
 */  
   
 DynamicCastFailedException::DynamicCastFailedException()  
     : Exception(MessageLoaderParms("Common.Exception.DYNAMIC_CAST_FAILED_EXCEPTION",  
                                                                 "dynamic cast failed"))                                                                 "dynamic cast failed"))
 { {
 } }
  
 /*  
 InvalidDateTimeFormatException::InvalidDateTimeFormatException()  
     : Exception("invalid datetime format")  
 {  
 }  
 */  
   
 InvalidDateTimeFormatException::InvalidDateTimeFormatException() InvalidDateTimeFormatException::InvalidDateTimeFormatException()
     : Exception(MessageLoaderParms("Common.Exception.INVALID_DATETIME_FORMAT_EXCEPTION",      : Exception(MessageLoaderParms(
             "Common.Exception.INVALID_DATETIME_FORMAT_EXCEPTION",
                                                                 "invalid datetime format"))                                                                 "invalid datetime format"))
 { {
 } }
  
 /*  
 MalformedObjectNameException::MalformedObjectNameException( MalformedObjectNameException::MalformedObjectNameException(
     const String& objectName)      const String& message)
     : Exception("malformed object name: " + objectName)      : Exception(MessageLoaderParms(
 {            "Common.Exception.MALFORMED_OBJECT_NAME_EXCEPTION",
 }  
 */  
   
 MalformedObjectNameException::MalformedObjectNameException(const String& message)  
     : Exception(MessageLoaderParms("Common.Exception.MALFORMED_OBJECT_NAME_EXCEPTION",  
                                                                 "malformed object name: $0",                                                                 "malformed object name: $0",
                                                                  message))                                                                  message))
 { {
 } }
  
 MalformedObjectNameException::MalformedObjectNameException(MessageLoaderParms& msgParms)  MalformedObjectNameException::MalformedObjectNameException(
     : Exception(MessageLoaderParms("Common.Exception.MALFORMED_OBJECT_NAME_EXCEPTION",      MessageLoaderParms& msgParms)
       : Exception(MessageLoaderParms(
             "Common.Exception.MALFORMED_OBJECT_NAME_EXCEPTION",
                                                                 "malformed object name: "))                                                                 "malformed object name: "))
 { {
         _rep->message.append(MessageLoader::getMessage(msgParms));         _rep->message.append(MessageLoader::getMessage(msgParms));
 } }
  
 /*  
 BindFailedException::BindFailedException(const String& message)  
     : Exception("Bind failed: " + message)  
 {  
 }  
 */  
   
 BindFailedException::BindFailedException(const String& message) BindFailedException::BindFailedException(const String& message)
     : Exception(MessageLoaderParms("Common.Exception.BIND_FAILED_EXCEPTION",      : Exception(MessageLoaderParms(
             "Common.Exception.BIND_FAILED_EXCEPTION",
                                                                 "Bind failed: $0",                                                                 "Bind failed: $0",
                                                                  message))                                                                  message))
 { {
 } }
  
 BindFailedException::BindFailedException(MessageLoaderParms& msgParms) BindFailedException::BindFailedException(MessageLoaderParms& msgParms)
     : Exception(MessageLoaderParms("Common.Exception.BIND_FAILED_EXCEPTION",      : Exception(MessageLoaderParms(
             "Common.Exception.BIND_FAILED_EXCEPTION",
                                                                 "Bind failed: "))                                                                 "Bind failed: "))
 { {
         _rep->message.append(MessageLoader::getMessage(msgParms));         _rep->message.append(MessageLoader::getMessage(msgParms));
 } }
  
 /*  
 InvalidLocatorException::InvalidLocatorException(const String& locator)  
     : Exception("Invalid locator: " + locator)  
 {  
 }  
 */  
   
 InvalidLocatorException::InvalidLocatorException(const String& message) InvalidLocatorException::InvalidLocatorException(const String& message)
     : Exception(MessageLoaderParms("Common.Exception.INVALID_LOCATOR_EXCEPTION",      : Exception(MessageLoaderParms(
             "Common.Exception.INVALID_LOCATOR_EXCEPTION",
                                                                 "Invalid locator: $0",                                                                 "Invalid locator: $0",
                                                                  message))                                                                  message))
 { {
 } }
  
 InvalidLocatorException::InvalidLocatorException(MessageLoaderParms& msgParms) InvalidLocatorException::InvalidLocatorException(MessageLoaderParms& msgParms)
     : Exception(MessageLoaderParms("Common.Exception.INVALID_LOCATOR_EXCEPTION",      : Exception(MessageLoaderParms(
             "Common.Exception.INVALID_LOCATOR_EXCEPTION",
                                                                 "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(MessageLoaderParms(
 {            "Common.Exception.CANNOT_CREATE_SOCKET_EXCEPTION",
 }  
 */  
   
 CannotCreateSocketException::CannotCreateSocketException()  
     : Exception(MessageLoaderParms("Common.Exception.CANNOT_CREATE_SOCKET_EXCEPTION",  
                                                                 "Cannot create socket"))                                                                 "Cannot create socket"))
 { {
 } }
Line 332 
Line 256 
 { {
 } }
  
 /*  
 AlreadyConnectedException::AlreadyConnectedException()  
     : Exception("already connected")  
 {  
 }  
 */  
   
 AlreadyConnectedException::AlreadyConnectedException() AlreadyConnectedException::AlreadyConnectedException()
     : Exception(MessageLoaderParms("Common.Exception.ALREADY_CONNECTED_EXCEPTION",      : Exception(MessageLoaderParms(
             "Common.Exception.ALREADY_CONNECTED_EXCEPTION",
                                                                 "already connected"))                                                                 "already connected"))
 { {
 } }
  
 /*  
 NotConnectedException::NotConnectedException()  
     : Exception("not connected")  
 {  
 }  
 */  
  
 NotConnectedException::NotConnectedException() NotConnectedException::NotConnectedException()
     : Exception(MessageLoaderParms("Common.Exception.NOT_CONNECTED_EXCEPTION",      : Exception(MessageLoaderParms(
             "Common.Exception.NOT_CONNECTED_EXCEPTION",
                                                                 "not connected"))                                                                 "not connected"))
 { {
 } }
  
 /*  
 ConnectionTimeoutException::ConnectionTimeoutException()  
     : Exception("connection timed out")  
 {  
 }  
 */  
   
 ConnectionTimeoutException::ConnectionTimeoutException() ConnectionTimeoutException::ConnectionTimeoutException()
     : Exception(MessageLoaderParms("Common.Exception.CONNECTION_TIMEOUT_EXCEPTION",      : Exception(MessageLoaderParms(
             "Common.Exception.CONNECTION_TIMEOUT_EXCEPTION",
                                                                 "connection timed out"))                                                                 "connection timed out"))
 { {
 } }
  
 /*  
 SSLException::SSLException(const String& message)  
     : Exception("SSL Exception: " + message)  
 {  
 }  
 */  
   
 SSLException::SSLException(const String& message) SSLException::SSLException(const String& message)
     : Exception(MessageLoaderParms("Common.Exception.SSL_EXCEPTION",      : Exception(MessageLoaderParms(
             "Common.Exception.SSL_EXCEPTION",
                                                                 "SSL Exception: $0" ,                                                                 "SSL Exception: $0" ,
                                                                  message))                                                                  message))
 { {
 } }
  
 SSLException::SSLException(MessageLoaderParms& msgParms) SSLException::SSLException(MessageLoaderParms& msgParms)
     : Exception(MessageLoaderParms("Common.Exception.SSL_EXCEPTION",      : Exception(MessageLoaderParms(
             "Common.Exception.SSL_EXCEPTION",
                                                                 "SSL Exception: " ))                                                                 "SSL Exception: " ))
 { {
         _rep->message.append(MessageLoader::getMessage(msgParms));         _rep->message.append(MessageLoader::getMessage(msgParms));
 } }
  
 /*  
 DateTimeOutOfRangeException::DateTimeOutOfRangeException(const String& message)  
     : Exception("DateTime is out of range : " + message)  
 {  
 }  
 */  
   
 DateTimeOutOfRangeException::DateTimeOutOfRangeException(const String& message) DateTimeOutOfRangeException::DateTimeOutOfRangeException(const String& message)
     : Exception(MessageLoaderParms("Common.Exception.DATETIME_OUT_OF_RANGE_EXCEPTION",      : Exception(MessageLoaderParms(
             "Common.Exception.DATETIME_OUT_OF_RANGE_EXCEPTION",
                                                                 "DateTime is out of range : $0" ,                                                                 "DateTime is out of range : $0" ,
                                                                  message))                                                                  message))
 { {
 } }
  
 DateTimeOutOfRangeException::DateTimeOutOfRangeException(MessageLoaderParms& msgParms)  DateTimeOutOfRangeException::DateTimeOutOfRangeException(
     : Exception(MessageLoaderParms("Common.Exception.DATETIME_OUT_OF_RANGE_EXCEPTION",      MessageLoaderParms& msgParms)
       : Exception(MessageLoaderParms(
             "Common.Exception.DATETIME_OUT_OF_RANGE_EXCEPTION",
                                                                 "DateTime is out of range : " ))                                                                 "DateTime is out of range : " ))
 { {
         _rep->message.append(MessageLoader::getMessage(msgParms));         _rep->message.append(MessageLoader::getMessage(msgParms));
Line 542 
Line 440 
     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->contentLanguages = rep->contentLanguages;
     tmp->cimMessage = rep->cimMessage;  // l10n      tmp->cimMessage = rep->cimMessage;
     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 560 
Line 458 
         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->contentLanguages = right->contentLanguages;
         left->cimMessage = right->cimMessage;  // l10n          left->cimMessage = right->cimMessage;
         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.79  
changed lines
  Added in v.1.80
No CVS admin address has been configured
 Powered by
ViewCVS 0.9.2