(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.55 and 1.83

version 1.55, 2002/08/20 17:39:37 version 1.83, 2008/01/08 20:15:09
Line 1 
Line 1 
 //%/////////////////////////////////////////////////////////////////////////////  //%2006////////////////////////////////////////////////////////////////////////
 // //
 // Copyright (c) 2000, 2001, 2002 BMC Software, Hewlett-Packard Company, IBM,  // Copyright (c) 2000, 2001, 2002 BMC Software; Hewlett-Packard Development
 // The Open Group, Tivoli Systems  // Company, L.P.; IBM Corp.; The Open Group; Tivoli Systems.
   // Copyright (c) 2003 BMC Software; Hewlett-Packard Development Company, L.P.;
   // IBM Corp.; EMC Corporation, The Open Group.
   // Copyright (c) 2004 BMC Software; Hewlett-Packard Development Company, L.P.;
   // IBM Corp.; EMC Corporation; VERITAS Software Corporation; The Open Group.
   // Copyright (c) 2005 Hewlett-Packard Development Company, L.P.; IBM Corp.;
   // EMC Corporation; VERITAS Software Corporation; The Open Group.
   // Copyright (c) 2006 Hewlett-Packard Development Company, L.P.; IBM Corp.;
   // EMC Corporation; Symantec Corporation; The Open Group.
 // //
 // Permission is hereby granted, free of charge, to any person obtaining a copy // Permission is hereby granted, free of charge, to any person obtaining a copy
 // of this software and associated documentation files (the "Software"), to // of this software and associated documentation files (the "Software"), to
Line 21 
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)  
 //  
 //%///////////////////////////////////////////////////////////////////////////// //%/////////////////////////////////////////////////////////////////////////////
  
 #include <cstdio> #include <cstdio>
 #include "Exception.h" #include "Exception.h"
   #include <Pegasus/Common/ExceptionRep.h>
 #include <Pegasus/Common/CIMExceptionRep.h> #include <Pegasus/Common/CIMExceptionRep.h>
 #include "Tracer.h" #include "Tracer.h"
  
 PEGASUS_NAMESPACE_BEGIN PEGASUS_NAMESPACE_BEGIN
  
 Exception::Exception(const String& message) : _message(message)  Exception::Exception(const String& message)
   {
       _rep = new ExceptionRep();
       _rep->message = message;
       _rep->contentLanguages.clear();
   }
   
   Exception::Exception(const Exception& exception)
   {
       _rep = new ExceptionRep();
       _rep->message = exception._rep->message;
       _rep->contentLanguages = exception._rep->contentLanguages;
   }
   
   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()
 { {
       _rep = NULL;
 } }
  
 Exception::~Exception() Exception::~Exception()
 { {
       delete _rep;
 } }
  
 const String& Exception::getMessage() const const String& Exception::getMessage() const
 { {
     return _message;      return _rep->message;
   }
   
   const ContentLanguageList& Exception::getContentLanguages() const
   {
       return _rep->contentLanguages;
 } }
  
   void Exception::setContentLanguages(const ContentLanguageList& langs)
   {
       _rep->contentLanguages = langs;
   }
  
 IndexOutOfBoundsException::IndexOutOfBoundsException() IndexOutOfBoundsException::IndexOutOfBoundsException()
     : 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",
             "already exists: $0",
             message))
 { {
 } }
  
 InvalidNameException::InvalidNameException(const String& name)  AlreadyExistsException::AlreadyExistsException(MessageLoaderParms& msgParms)
     : Exception("invalid CIM name: " + name)      : Exception(MessageLoaderParms(
             "Common.Exception.ALREADY_EXISTS_EXCEPTION",
             "already exists: $0",
             MessageLoader::getMessage(msgParms)))
 { {
 } }
  
 InvalidNamespaceNameException::InvalidNamespaceNameException(const String& name)  InvalidNameException::InvalidNameException(const String& message)
     : Exception("invalid CIM namespace name: " + name)      : Exception(MessageLoaderParms(
             "Common.Exception.INVALID_NAME_EXCEPTION",
             "The CIM name is not valid: $0",
             message))
 { {
 } }
  
 UninitializedHandleException::UninitializedHandleException()  InvalidNameException::InvalidNameException(MessageLoaderParms& msgParms)
     : Exception("uninitialized handle")      : Exception(MessageLoaderParms(
             "Common.Exception.INVALID_NAME_EXCEPTION",
             "invalid CIM name: $0",
             MessageLoader::getMessage(msgParms)))
 { {
 } }
  
 UninitializedObjectException::UninitializedObjectException()  InvalidNamespaceNameException::InvalidNamespaceNameException(const String& name)
     : Exception("uninitialized object")      : Exception(MessageLoaderParms(
             "Common.Exception.INVALID_NAMESACE_NAME_EXCEPTION",
             "invalid CIM namespace name: $0",
             name))
 { {
 } }
  
 ExpectedReferenceValueException::ExpectedReferenceValueException()  InvalidNamespaceNameException::InvalidNamespaceNameException(
     : Exception("Expected CIMValue object to be of type reference "      MessageLoaderParms& msgParms)
                     "in this context")      : Exception(MessageLoaderParms(
             "Common.Exception.INVALID_NAMESPACE_NAME_EXCEPTION",
             "invalid CIM namespace name: $0",
             MessageLoader::getMessage(msgParms)))
 { {
 } }
  
 MissingReferenceClassNameException::MissingReferenceClassNameException()  UninitializedObjectException::UninitializedObjectException()
     : Exception("missing reference class name")      : Exception(MessageLoaderParms(
             "Common.Exception.UNINITIALIZED_OBJECT_EXCEPTION",
             "uninitialized object"))
 { {
 } }
  
 TypeMismatchException::TypeMismatchException() TypeMismatchException::TypeMismatchException()
     : Exception("type mismatch")      : Exception(MessageLoaderParms(
             "Common.Exception.TYPE_MISMATCH_EXCEPTION",
             "type mismatch"))
   {
   }
   
   TypeMismatchException::TypeMismatchException(const String& message)
       : Exception(MessageLoaderParms(
             "Common.Exception.TYPE_MISMATCH_EXCEPTION",
             "type mismatch: $0",message))
 { {
   
 } }
  
 CIMValueInvalidTypeException::CIMValueInvalidTypeException()  TypeMismatchException::TypeMismatchException(MessageLoaderParms& msgParms)
     : Exception("invalid CIMValue type")      : Exception(MessageLoaderParms(
             "Common.Exception.TYPE_MISMATCH_EXCEPTION",
             "type mismatch: $0",
             MessageLoader::getMessage(msgParms)))
 { {
 } }
  
 DynamicCastFailedException::DynamicCastFailedException() DynamicCastFailedException::DynamicCastFailedException()
     : Exception("dynamic cast failed")      : Exception(MessageLoaderParms(
             "Common.Exception.DYNAMIC_CAST_FAILED_EXCEPTION",
             "dynamic cast failed"))
 { {
 } }
  
 InvalidDateTimeFormatException::InvalidDateTimeFormatException() InvalidDateTimeFormatException::InvalidDateTimeFormatException()
     : Exception("invalid datetime format")      : Exception(MessageLoaderParms(
             "Common.Exception.INVALID_DATETIME_FORMAT_EXCEPTION",
             "invalid datetime format"))
 { {
 } }
  
 IncompatibleTypesException::IncompatibleTypesException()  MalformedObjectNameException::MalformedObjectNameException(
     : Exception("incompatible types")      const String& message)
       : Exception(MessageLoaderParms(
             "Common.Exception.MALFORMED_OBJECT_NAME_EXCEPTION",
             "malformed object name: $0",
             message))
 { {
 } }
  
 MalformedObjectNameException::MalformedObjectNameException( MalformedObjectNameException::MalformedObjectNameException(
     const String& objectName)      MessageLoaderParms& msgParms)
     : Exception("malformed object name: " + objectName)      : Exception(MessageLoaderParms(
             "Common.Exception.MALFORMED_OBJECT_NAME_EXCEPTION",
             "malformed object name: $0",
             MessageLoader::getMessage(msgParms)))
 { {
 } }
  
 BindFailedException::BindFailedException(const String& message) BindFailedException::BindFailedException(const String& message)
     : Exception("Bind failed: " + message)      : Exception(MessageLoaderParms(
             "Common.Exception.BIND_FAILED_EXCEPTION",
             "Bind failed: $0",
             message))
 { {
 } }
  
 InvalidLocatorException::InvalidLocatorException(const String& locator)  BindFailedException::BindFailedException(MessageLoaderParms& msgParms)
     : Exception("Invalid locator: " + locator)      : Exception(MessageLoaderParms(
             "Common.Exception.BIND_FAILED_EXCEPTION",
             "Bind failed: $0",
             MessageLoader::getMessage(msgParms)))
   {
   }
   
   InvalidLocatorException::InvalidLocatorException(const String& message)
       : Exception(MessageLoaderParms(
             "Common.Exception.INVALID_LOCATOR_EXCEPTION",
             "Invalid locator: $0",
             message))
   {
   }
   
   InvalidLocatorException::InvalidLocatorException(MessageLoaderParms& msgParms)
       : Exception(MessageLoaderParms(
             "Common.Exception.INVALID_LOCATOR_EXCEPTION",
             "Invalid locator: $0",
             MessageLoader::getMessage(msgParms)))
 { {
 } }
  
 CannotCreateSocketException::CannotCreateSocketException() CannotCreateSocketException::CannotCreateSocketException()
     : Exception("Cannot create socket")      : Exception(MessageLoaderParms(
             "Common.Exception.CANNOT_CREATE_SOCKET_EXCEPTION",
             "Cannot create socket"))
 { {
 } }
  
 CannotConnectException::CannotConnectException(const String& locator)  
     : Exception("Cannot connect to: " + locator)  CannotConnectException::CannotConnectException(const String& message)//???
       : Exception(message)
 { {
 } }
  
 UnexpectedFailureException::UnexpectedFailureException()  
     : Exception("Unexpected failure")  CannotConnectException::CannotConnectException(MessageLoaderParms& msgParms)
       : Exception(msgParms)
 { {
 } }
  
 AlreadyConnectedException::AlreadyConnectedException() AlreadyConnectedException::AlreadyConnectedException()
     : Exception("already connected")      : Exception(MessageLoaderParms(
             "Common.Exception.ALREADY_CONNECTED_EXCEPTION",
             "already connected"))
 { {
 } }
  
   
 NotConnectedException::NotConnectedException() NotConnectedException::NotConnectedException()
     : Exception("not connected")      : Exception(MessageLoaderParms(
             "Common.Exception.NOT_CONNECTED_EXCEPTION",
             "not connected"))
 { {
 } }
  
 ConnectionTimeoutException::ConnectionTimeoutException() ConnectionTimeoutException::ConnectionTimeoutException()
     : Exception("connection timed out")      : Exception(MessageLoaderParms(
             "Common.Exception.CONNECTION_TIMEOUT_EXCEPTION",
             "connection timed out"))
 { {
 } }
  
 SSLException::SSLException(const String& message) SSLException::SSLException(const String& message)
     : Exception("SSL Exception: " + message)      : Exception(MessageLoaderParms(
             "Common.Exception.SSL_EXCEPTION",
             "SSL Exception: $0" ,
             message))
 { {
 } }
  
   SSLException::SSLException(MessageLoaderParms& msgParms)
       : Exception(MessageLoaderParms(
             "Common.Exception.SSL_EXCEPTION",
             "SSL Exception: $0",
             MessageLoader::getMessage(msgParms)))
   {
   }
   
   DateTimeOutOfRangeException::DateTimeOutOfRangeException(const String& message)
       : Exception(MessageLoaderParms(
             "Common.Exception.DATETIME_OUT_OF_RANGE_EXCEPTION",
             "DateTime is out of range : $0" ,
             message))
   {
   }
   
   DateTimeOutOfRangeException::DateTimeOutOfRangeException(
       MessageLoaderParms& msgParms)
       : Exception(MessageLoaderParms(
             "Common.Exception.DATETIME_OUT_OF_RANGE_EXCEPTION",
             "DateTime is out of range : $0",
             MessageLoader::getMessage(msgParms)))
   {
   }
  
 //////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////
 // //
Line 176 
Line 317 
 // //
 //////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////
  
   // 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)
     :      : Exception()
     Exception(message)  
 { {
     _rep = new CIMExceptionRep();      CIMExceptionRep * tmp = new CIMExceptionRep ();
     _rep->code = code;      tmp->message = message;
     _rep->file = "";      tmp->code = code;
     _rep->line = 0;      tmp->file = "";
       tmp->line = 0;
       tmp->contentLanguages.clear();
       tmp->cimMessage = String::EMPTY;
       _rep = tmp;
   }
   
   
   // l10n - note - use this when you have an exception
   // an untranslated detail message and an attached CIM_Error
   // The pegasus message associated with code will be translated.
   CIMException::CIMException(
       CIMStatusCode code,
       const String& message,
       const CIMInstance& instance)
       : Exception()
   {
       CIMExceptionRep * tmp = new CIMExceptionRep ();
       tmp->message = message;
       tmp->code = code;
       tmp->file = "";
       tmp->errors.append(instance);
       tmp->line = 0;
       tmp->contentLanguages.clear();
       tmp->cimMessage = String::EMPTY;
       _rep = tmp;
   }
   
   // l10n - note - use this when you have an exception
   // an untranslated detail message and an attached CIM_Error
   // array
   // The pegasus message associated with code will be translated.
   CIMException::CIMException(
       CIMStatusCode code,
       const String& message,
       const Array<CIMInstance>& instances)
       : Exception()
   {
       CIMExceptionRep * tmp = new CIMExceptionRep ();
       tmp->message = message;
       tmp->code = code;
       tmp->file = "";
       tmp->errors.appendArray(instances);
       tmp->line = 0;
       tmp->contentLanguages.clear();
       tmp->cimMessage = String::EMPTY;
       _rep = tmp;
   }
   // l10n - note use this when you have an exception with a translated
   // detail message
   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;
   }
   
   CIMException::CIMException(
       CIMStatusCode code,
       const MessageLoaderParms& msgParms,
       const CIMInstance& instance)
       : 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->errors.append(instance);
       tmp->code = code;
       tmp->file = "";
       tmp->line = 0;
       _rep = tmp;
 } }
  
   CIMException::CIMException(
       CIMStatusCode code,
       const MessageLoaderParms& msgParms,
       const Array<CIMInstance>& instances)
       : 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->errors.appendArray(instances);
       tmp->code = code;
       tmp->file = "";
       tmp->line = 0;
       _rep = tmp;
   }
 CIMException::CIMException(const CIMException & cimException) CIMException::CIMException(const CIMException & cimException)
     : Exception(cimException.getMessage())      : Exception()
 { {
     _rep = new CIMExceptionRep();      CIMExceptionRep* tmp = new CIMExceptionRep();
     _rep->code = cimException._rep->code;      CIMExceptionRep* rep;
     _rep->file = cimException._rep->file;      rep = reinterpret_cast<CIMExceptionRep*>(cimException._rep);
     _rep->line = cimException._rep->line;      tmp->message = rep->message;
       tmp->contentLanguages = rep->contentLanguages;
       tmp->cimMessage = rep->cimMessage;
       tmp->code = rep->code;
       tmp->file = rep->file;
       tmp->line = rep->line;
       tmp->errors = rep->errors;
       _rep = tmp;
 } }
  
 CIMException& CIMException::operator=(const CIMException & cimException) CIMException& CIMException::operator=(const CIMException & cimException)
 { {
     _message = cimException._message;      if (&cimException != this)
     _rep->code = cimException._rep->code;      {
     _rep->file = cimException._rep->file;          CIMExceptionRep* left;
     _rep->line = cimException._rep->line;          CIMExceptionRep* right;
           left = reinterpret_cast<CIMExceptionRep*>(this->_rep);
           right = reinterpret_cast<CIMExceptionRep*>(cimException._rep);
           left->message = right->message;
           left->contentLanguages = right->contentLanguages;
           left->cimMessage = right->cimMessage;
           left->code = right->code;
           left->file = right->file;
           left->line = right->line;
           left->errors = right->errors;
       }
     return *this;     return *this;
 } }
  
 CIMException::~CIMException() CIMException::~CIMException()
 { {
     delete _rep;  }
   
   Uint32 CIMException::getErrorCount() const
   {
       return reinterpret_cast<CIMExceptionRep*>(_rep)->errors.size();
   }
   /**************
   CIMInstance CIMException::getError(Uint32 index)
   {
       return reinterpret_cast<CIMExceptionRep*>(_rep)->errors[index];
   }
   ***************/
   
   CIMConstInstance CIMException::getError(Uint32 index) const
   {
       return reinterpret_cast<CIMExceptionRep*>(_rep)->errors[index];
   }
   
   void CIMException::addError(const CIMInstance& instance)
   {
       reinterpret_cast<CIMExceptionRep*>(_rep)->errors.append(instance);
 } }
  
 CIMStatusCode CIMException::getCode() const CIMStatusCode CIMException::getCode() const
 { {
     return _rep->code;      CIMExceptionRep* rep;
       rep = reinterpret_cast<CIMExceptionRep*>(_rep);
       return rep->code;
 } }
  
 PEGASUS_NAMESPACE_END PEGASUS_NAMESPACE_END

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