(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.10 and 1.55

version 1.10, 2001/04/25 22:20:55 version 1.55, 2002/08/20 17:39:37
Line 1 
Line 1 
 //%///////////////////////////////////////////////////////////////////////////// //%/////////////////////////////////////////////////////////////////////////////
 // //
 // Copyright (c) 2000 The Open Group, BMC Software, Tivoli Systems, IBM  // Copyright (c) 2000, 2001, 2002 BMC Software, Hewlett-Packard Company, IBM,
   // The Open Group, Tivoli Systems
 // //
 // Permission is hereby granted, free of charge, to any person obtaining a  // Permission is hereby granted, free of charge, to any person obtaining a copy
 // copy of this software and associated documentation files (the "Software"),  // of this software and associated documentation files (the "Software"), to
 // to deal in the Software without restriction, including without limitation  // deal in the Software without restriction, including without limitation the
 // the rights to use, copy, modify, merge, publish, distribute, sublicense,  // rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
 // and/or sell copies of the Software, and to permit persons to whom the  // sell copies of the Software, and to permit persons to whom the Software is
 // Software is furnished to do so, subject to the following conditions:  // furnished to do so, subject to the following conditions:
 //  //
 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR  // THE ABOVE COPYRIGHT NOTICE AND THIS PERMISSION NOTICE SHALL BE INCLUDED IN
 // IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,  // ALL COPIES OR SUBSTANTIAL PORTIONS OF THE SOFTWARE. THE SOFTWARE IS PROVIDED
 // FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL  // "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT
 // THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER  // LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR
 // LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING  // PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
 // FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER  // HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
 // DEALINGS IN THE SOFTWARE.  // ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
   // WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 // //
 //============================================================================== //==============================================================================
 // //
 // Author: Mike Brasher (mbrasher@bmc.com) // Author: Mike Brasher (mbrasher@bmc.com)
 // //
 // Modified By:  // 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/CIMExceptionRep.h>
   #include "Tracer.h"
  
 PEGASUS_NAMESPACE_BEGIN PEGASUS_NAMESPACE_BEGIN
  
 Exception::Exception(const String& message) : _message(message) Exception::Exception(const String& message) : _message(message)
 { {
   
 }  
   
 Exception::Exception(const char* message) : _message(message)  
 {  
   
 } }
  
 Exception::~Exception() Exception::~Exception()
 { {
   
 } }
  
 AssertionFailureException::AssertionFailureException(  const String& Exception::getMessage() const
     const char* file,  
     size_t line,  
     const String& message) : Exception(String())  
 { {
     char lineStr[32];      return _message;
     sprintf(lineStr, "%d", line);  
   
     _message = file;  
     _message.append("(");  
     _message.append(lineStr);  
     _message.append("): ");  
     _message.append(message);  
 } }
  
 const char OutOfBounds::MSG[] = "out of bounds";  
   
 const char AlreadyExists::MSG[] = "already exists: ";  
   
 const char NullPointer::MSG[] = "null pointer";  
   
 const char UnitializedHandle::MSG[] = "unitialized reference";  
   
 const char IllegalName::MSG[] = "illegal CIM name";  
   
 const char NoSuchSuperClass::MSG[] = "no such super class: ";  
   
 const char NoSuchClass::MSG[] = "no such class: ";  
   
 const char InvalidPropertyOverride::MSG[] = "invalid property override: ";  
   
 const char InvalidMethodOverride::MSG[] = "invalid method override: ";  
   
 const char UndeclaredQualifier::MSG[] = "undeclared qualifier: ";  
   
 const char BadQualifierScope::MSG[] = "qualifier invalid in this scope: ";  
   
 const char BadQualifierOverride::MSG[] = "qualifier not overridable: ";  
   
 const char BadQualifierType::MSG[] =  
     "CIMType of qualifier different than its declaration: ";  
   
 const char NullType::MSG[] = "type is null";  
   
 const char AddedReferenceToClass::MSG[] =  
     "attempted to add reference to a non-association class: ";  
   
 const char ClassAlreadyResolved::MSG[] =  
     "attempt to resolve a class that is already resolved: ";  
   
 const char ClassNotResolved::MSG[] =  
     "class is not yet resolved: ";  
   
 const char InstanceAlreadyResolved::MSG[] =  
     "attempted to resolve a instance that is already resolved";  
  
 const char InstantiatedAbstractClass::MSG[] =  IndexOutOfBoundsException::IndexOutOfBoundsException()
     "attempted to instantiated an abstract class";      : Exception("index out of bounds")
   {
 const char NoSuchProperty::MSG[] = "no such property: ";  }
  
 const char TruncatedCharacter::MSG[] =  AlreadyExistsException::AlreadyExistsException(const String& message)
     "truncated character during conversion from Char16 to char";      : Exception("already exists: " + message)
   {
   }
  
 const char ExpectedReferenceValue::MSG[] =  InvalidNameException::InvalidNameException(const String& name)
     "Expected CIMValue object to be CIMType::REFERENCE or CIMType::REFERENCE_ARRAY "      : Exception("invalid CIM name: " + name)
     "in this context";  {
   }
  
 const char MissingReferenceClassName::MSG[] = "missing reference class name";  InvalidNamespaceNameException::InvalidNamespaceNameException(const String& name)
       : Exception("invalid CIM namespace name: " + name)
   {
   }
  
 const char IllegalTypeTag::MSG[] = "illegal type tag";  UninitializedHandleException::UninitializedHandleException()
       : Exception("uninitialized handle")
   {
   }
  
 const char TypeMismatch::MSG[] = "type mismatch";  UninitializedObjectException::UninitializedObjectException()
       : Exception("uninitialized object")
   {
   }
  
 const char NoSuchFile::MSG[] = "no such file: ";  ExpectedReferenceValueException::ExpectedReferenceValueException()
       : Exception("Expected CIMValue object to be of type reference "
                       "in this context")
   {
   }
  
 const char NoSuchDirectory::MSG[] = "no such directory: ";  MissingReferenceClassNameException::MissingReferenceClassNameException()
       : Exception("missing reference class name")
   {
   }
  
 const char ChangeDirectoryFailed::MSG[] = "failed to change directory: ";  TypeMismatchException::TypeMismatchException()
       : Exception("type mismatch")
   {
   }
  
 const char CannotCreateDirectory::MSG[] = "cannot create directory: ";  CIMValueInvalidTypeException::CIMValueInvalidTypeException()
       : Exception("invalid CIMValue type")
   {
   }
  
 const char NoSuchNameSpace::MSG[] = "no such namespace: ";  DynamicCastFailedException::DynamicCastFailedException()
       : Exception("dynamic cast failed")
   {
   }
  
 const char CannotOpenFile::MSG[] = "cannot open file: ";  InvalidDateTimeFormatException::InvalidDateTimeFormatException()
       : Exception("invalid datetime format")
   {
   }
  
 const char NotImplemented::MSG[] = "not implemented: ";  IncompatibleTypesException::IncompatibleTypesException()
       : Exception("incompatible types")
   {
   }
  
 const char FailedToRemoveDirectory::MSG[] = "failed to remove directory: ";  MalformedObjectNameException::MalformedObjectNameException(
       const String& objectName)
       : Exception("malformed object name: " + objectName)
   {
   }
  
 const char FailedToRemoveFile::MSG[] = "failed to remove file: ";  BindFailedException::BindFailedException(const String& message)
       : Exception("Bind failed: " + message)
   {
   }
  
 const char StackUnderflow::MSG[] = "stack overflow";  InvalidLocatorException::InvalidLocatorException(const String& locator)
       : Exception("Invalid locator: " + locator)
   {
   }
  
 const char BadFormat::MSG[] = "bad format passed to Formatter::format()";  CannotCreateSocketException::CannotCreateSocketException()
       : Exception("Cannot create socket")
   {
   }
  
 const char BadDateTimeFormat::MSG[] = "bad datetime format";  CannotConnectException::CannotConnectException(const String& locator)
       : Exception("Cannot connect to: " + locator)
   {
   }
  
 const char IncompatibleTypes::MSG[] = "incompatible types";  UnexpectedFailureException::UnexpectedFailureException()
       : Exception("Unexpected failure")
   {
   }
  
 const char BadlyFormedCGIQueryString::MSG[] = "badly formed CGI query string";  AlreadyConnectedException::AlreadyConnectedException()
       : Exception("already connected")
   {
   }
  
 const char IllformedObjectPath::MSG[] = "illformed object path: ";  NotConnectedException::NotConnectedException()
       : Exception("not connected")
   {
   }
  
 const char DynamicLoadFailed::MSG[] = "load of dynamic library failed: ";  ConnectionTimeoutException::ConnectionTimeoutException()
       : Exception("connection timed out")
   {
   }
  
 const char DynamicLookupFailed::MSG[] =  SSLException::SSLException(const String& message)
     "lookup of symbol in dynamic library failed: ";      : Exception("SSL Exception: " + message)
   {
   }
  
 const char CannotOpenDirectory::MSG[] = "cannot open directory: ";  
  
 //////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////
 // //
Line 162 
Line 176 
 // //
 //////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////
  
 static char* _cimMessages[] =  CIMException::CIMException(
       CIMStatusCode code,
       const String& message)
       :
       Exception(message)
 { {
     "successful",      _rep = new CIMExceptionRep();
       _rep->code = code;
     "A general error occurred that is not covered by a more specific "      _rep->file = "";
     "error code.",      _rep->line = 0;
   }
     "Access to a CIM resource was not available to the client.",  
   
     "The target namespace does not exist.",  
   
     "One or more parameter values passed to the method were invalid.",  
   
     "The specified class does not exist.",  
   
     "The requested object could not be found.",  
   
     "The requested operation is not supported.",  
   
     "Operation cannot be carried out on this class since it has subclasses.",  
   
     "Operation cannot be carried out on this class since it has instances.",  
   
     "Operation cannot be carried out since the specified "  
     "superClass does not exist.",  
   
     "Operation cannot be carried out because an object already exists.",  
   
     "The specified property does not exist.",  
   
     "The value supplied is incompatible with the type.",  
   
     "The query language is not recognized or supported.",  
   
     "The query is not valid for the specified query language.",  
   
     "The extrinsic method could not be executed.",  
   
     "The specified extrinsic method does not exist."  
 };  
  
 static String _makeCIMExceptionMessage(  CIMException::CIMException(const CIMException & cimException)
     CIMException::Code code,      : Exception(cimException.getMessage())
     const String& extraMessage)  
 { {
     String tmp = _cimMessages[Uint32(code)];      _rep = new CIMExceptionRep();
     tmp.append(": ");      _rep->code = cimException._rep->code;
     tmp.append(extraMessage);      _rep->file = cimException._rep->file;
     return tmp;      _rep->line = cimException._rep->line;
 } }
  
 CIMException::CIMException(  CIMException& CIMException::operator=(const CIMException & cimException)
     CIMException::Code code,  
     const String& extraMessage)  
     : Exception(_makeCIMExceptionMessage(code, extraMessage)), _code(code)  
 { {
       _message = cimException._message;
       _rep->code = cimException._rep->code;
       _rep->file = cimException._rep->file;
       _rep->line = cimException._rep->line;
       return *this;
   }
  
   CIMException::~CIMException()
   {
       delete _rep;
 } }
  
 const char* CIMException::codeToString(CIMException::Code code)  CIMStatusCode CIMException::getCode() const
 { {
     return _cimMessages[Uint32(code)];      return _rep->code;
 } }
  
 PEGASUS_NAMESPACE_END PEGASUS_NAMESPACE_END

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