pegasus/src/Pegasus/Common/Exception.cpp - diff

Return to Exception.cpp CVS log

Up to [Pegasus] / pegasus / src / Pegasus / Common

Diff for /pegasus/src/Pegasus/Common/Exception.cpp between version 1.3 and 1.81.4.2

version 1.3, 2001/01/23 01:25:35

version 1.81.4.2, 2008/02/13 20:45:48

Line 1

//BEGIN_LICENSE

//%2006////////////////////////////////////////////////////////////////////////

// Company, L.P.; IBM Corp.; The Open Group; Tivoli Systems.

// IBM Corp.; EMC Corporation, The Open Group.

// IBM Corp.; EMC Corporation; VERITAS Software Corporation; The Open Group.

// EMC Corporation; VERITAS Software Corporation; The Open Group.

// EMC Corporation; Symantec Corporation; The Open Group.

// Permission is hereby granted, free of charge, to any person obtaining a copy

// of this software and associated documentation files (the "Software"), to

// deal in the Software without restriction, including without limitation the

// rights to use, copy, modify, merge, publish, distribute, sublicense, and/or

// sell copies of the Software, and to permit persons to whom the Software is

// furnished to do so, subject to the following conditions:

// THE ABOVE COPYRIGHT NOTICE AND THIS PERMISSION NOTICE SHALL BE INCLUDED IN

// ALL COPIES OR SUBSTANTIAL PORTIONS OF THE SOFTWARE. THE SOFTWARE IS PROVIDED

// "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT

// LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR

// PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT

// HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN

// 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.

// Permission is hereby granted, free of charge, to any person obtaining a

//==============================================================================

// copy of this software and associated documentation files (the "Software"),

// to deal in the Software without restriction, including without limitation

// the rights to use, copy, modify, merge, publish, distribute, sublicense,

// and/or sell copies of the Software, and to permit persons to whom the

// Software is furnished to do so, subject to the following conditions:

// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR

//%/////////////////////////////////////////////////////////////////////////////

// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,

// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL

// THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER

// LIABILITY, WHETHER IN AN 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.

//END_LICENSE

//BEGIN_HISTORY

// Author:

// $Log$

// Revision 1.3 2001/01/23 01:25:35 mike

// Reworked resolve scheme.

// Revision 1.2 2001/01/22 00:45:47 mike

// more work on resolve scheme

// Revision 1.1.1.1 2001/01/14 19:51:33 mike

// Pegasus import

//END_HISTORY

#include <cstdio>

#include "Exception.h"

#include <Pegasus/Common/ExceptionRep.h>

#include <Pegasus/Common/CIMExceptionRep.h>

#include "Tracer.h"

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 char* message) : _message(message)

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()

{

delete _rep;

}

AssertionFailureException::AssertionFailureException(

Exception& Exception::operator=(const Exception& exception)

const char* file,

size_t line,

const String& message) : Exception(String())

{

char lineStr[32];

if (&exception != this)

sprintf(lineStr, "%d", line);

{

*this->_rep = *exception._rep;

_message = file;

}

_message.append("(");

return *this;

_message.append(lineStr);

_message.append("): ");

_message.append(message);

}

const char OutOfBounds::MSG[] = "out of bounds";

const String& Exception::getMessage() const

{

const char AlreadyExists::MSG[] = "already exists: ";

return _rep->message;

}

const char NullPointer::MSG[] = "null pointer";

const char UnitializedHandle::MSG[] = "unitialized reference";

const ContentLanguageList& Exception::getContentLanguages() const

{

return _rep->contentLanguages;

}

const char IllegalName::MSG[] = "illegal CIM name";

void Exception::setContentLanguages(const ContentLanguageList& langs)

{

_rep->contentLanguages = langs;

}

const char NoSuchSuperClass::MSG[] = "no such super class: ";

IndexOutOfBoundsException::IndexOutOfBoundsException()

: Exception(MessageLoaderParms(

"Common.Exception.INDEX_OUT_OF_BOUNDS_EXCEPTION",

"index out of bounds"))

{

}

const char NoSuchClass::MSG[] = "no such class: ";

AlreadyExistsException::AlreadyExistsException(const String& message)

: Exception(MessageLoaderParms(

"Common.Exception.ALREADY_EXISTS_EXCEPTION",

"already exists: $0",

message))

{

}

const char InvalidPropertyOverride::MSG[] = "invalid property override: ";

AlreadyExistsException::AlreadyExistsException(MessageLoaderParms& msgParms)

: Exception(MessageLoaderParms(

"Common.Exception.ALREADY_EXISTS_EXCEPTION",

"already exists: $0",

MessageLoader::getMessage(msgParms)))

{

}

const char InvalidMethodOverride::MSG[] = "invalid method override: ";

InvalidNameException::InvalidNameException(const String& message)

: Exception(MessageLoaderParms(

"Common.Exception.INVALID_NAME_EXCEPTION",

"invalid CIM name: $0",

message))

{

}

const char UndeclaredQualifier::MSG[] = "undeclared qualifier: ";

InvalidNameException::InvalidNameException(MessageLoaderParms& msgParms)

: Exception(MessageLoaderParms(

"Common.Exception.INVALID_NAME_EXCEPTION",

"invalid CIM name: $0",

MessageLoader::getMessage(msgParms)))

{

}

const char BadQualifierScope::MSG[] = "qualifier invalid in this scope: ";

InvalidNamespaceNameException::InvalidNamespaceNameException(const String& name)

: Exception(MessageLoaderParms(

"Common.Exception.INVALID_NAMESACE_NAME_EXCEPTION",

"invalid CIM namespace name: $0",

name))

{

}

const char BadQualifierOverride::MSG[] = "qualifier not overridable: ";

InvalidNamespaceNameException::InvalidNamespaceNameException(

MessageLoaderParms& msgParms)

: Exception(MessageLoaderParms(

"Common.Exception.INVALID_NAMESPACE_NAME_EXCEPTION",

"invalid CIM namespace name: $0",

MessageLoader::getMessage(msgParms)))

{

}

const char NullType::MSG[] = "type is null";

UninitializedObjectException::UninitializedObjectException()

: Exception(MessageLoaderParms(

"Common.Exception.UNINITIALIZED_OBJECT_EXCEPTION",

"uninitialized object"))

{

}

const char AddedReferenceToClass::MSG[] =

TypeMismatchException::TypeMismatchException()

"attempted to add reference to a non-association class: ";

: Exception(MessageLoaderParms(

"Common.Exception.TYPE_MISMATCH_EXCEPTION",

"type mismatch"))

{

}

const char ClassAlreadyResolved::MSG[] =

TypeMismatchException::TypeMismatchException(const String& message)

"attempt to resolve a class that is already resolved: ";

: Exception(MessageLoaderParms(

"Common.Exception.TYPE_MISMATCH_EXCEPTION",

"type mismatch: $0",message))

{

const char ClassNotResolved::MSG[] =

}

"class is not yet resolved: ";

const char InstanceAlreadyResolved::MSG[] =

TypeMismatchException::TypeMismatchException(MessageLoaderParms& msgParms)

"attempted to resolve a instance that is already resolved";

: Exception(MessageLoaderParms(

"Common.Exception.TYPE_MISMATCH_EXCEPTION",

"type mismatch: $0",

MessageLoader::getMessage(msgParms)))

{

}

const char InstantiatedAbstractClass::MSG[] =

DynamicCastFailedException::DynamicCastFailedException()

"attempted to instantiated an abstract class";

: Exception(MessageLoaderParms(

"Common.Exception.DYNAMIC_CAST_FAILED_EXCEPTION",

"dynamic cast failed"))

{

}

const char NoSuchProperty::MSG[] = "no such property: ";

InvalidDateTimeFormatException::InvalidDateTimeFormatException()

: Exception(MessageLoaderParms(

"Common.Exception.INVALID_DATETIME_FORMAT_EXCEPTION",

"invalid datetime format"))

{

}

const char TruncatedCharacter::MSG[] =

MalformedObjectNameException::MalformedObjectNameException(

"truncated character during conversion from Char16 to char";

const String& message)

: Exception(MessageLoaderParms(

"Common.Exception.MALFORMED_OBJECT_NAME_EXCEPTION",

"malformed object name: $0",

message))

{

}

const char ExpectedReferenceValue::MSG[] =

MalformedObjectNameException::MalformedObjectNameException(

"Expected Value object to be Type::REFERENCE or Type::REFERENCE_ARRAY "

MessageLoaderParms& msgParms)

"in this context";

: Exception(MessageLoaderParms(

"Common.Exception.MALFORMED_OBJECT_NAME_EXCEPTION",

"malformed object name: $0",

MessageLoader::getMessage(msgParms)))

{

}

const char MissingReferenceClassName::MSG[] = "missing reference class name";

BindFailedException::BindFailedException(const String& message)

: Exception(MessageLoaderParms(

"Common.Exception.BIND_FAILED_EXCEPTION",

"Bind failed: $0",

message))

{

}

const char IllegalTypeTag::MSG[] = "illegal type tag";

BindFailedException::BindFailedException(MessageLoaderParms& msgParms)

: Exception(MessageLoaderParms(

"Common.Exception.BIND_FAILED_EXCEPTION",

"Bind failed: $0",

MessageLoader::getMessage(msgParms)))

{

}

const char TypeMismatch::MSG[] = "type mismatch";

InvalidLocatorException::InvalidLocatorException(const String& message)

: Exception(MessageLoaderParms(

"Common.Exception.INVALID_LOCATOR_EXCEPTION",

"Invalid locator: $0",

message))

{

}

const char NoSuchFile::MSG[] = "no such file: ";

InvalidLocatorException::InvalidLocatorException(MessageLoaderParms& msgParms)

: Exception(MessageLoaderParms(

"Common.Exception.INVALID_LOCATOR_EXCEPTION",

"Invalid locator: $0",

MessageLoader::getMessage(msgParms)))

{

}

const char NoSuchDirectory::MSG[] = "no such directory: ";

CannotCreateSocketException::CannotCreateSocketException()

: Exception(MessageLoaderParms(

"Common.Exception.CANNOT_CREATE_SOCKET_EXCEPTION",

"Cannot create socket"))

{

}

const char ChangeDirectoryFailed::MSG[] = "failed to change directory: ";

const char CannotCreateDirectory::MSG[] = "cannot create directory: ";

CannotConnectException::CannotConnectException(const String& message)//???

: Exception(message)

{

}

const char NoSuchNameSpace::MSG[] = "no such namespace: ";

const char CannotOpenFile::MSG[] = "cannot open file: ";

CannotConnectException::CannotConnectException(MessageLoaderParms& msgParms)

: Exception(msgParms)

{

}

const char NotImplemented::MSG[] = "not implemented: ";

AlreadyConnectedException::AlreadyConnectedException()

: Exception(MessageLoaderParms(

"Common.Exception.ALREADY_CONNECTED_EXCEPTION",

"already connected"))

{

}

const char FailedToRemoveDirectory::MSG[] = "failed to remove directory: ";

const char FailedToRemoveFile::MSG[] = "failed to remove file: ";

NotConnectedException::NotConnectedException()

: Exception(MessageLoaderParms(

"Common.Exception.NOT_CONNECTED_EXCEPTION",

"not connected"))

{

}

const char StackUnderflow::MSG[] = "stack overflow";

ConnectionTimeoutException::ConnectionTimeoutException()

: Exception(MessageLoaderParms(

"Common.Exception.CONNECTION_TIMEOUT_EXCEPTION",

"connection timed out"))

{

}

const char BadFormat::MSG[] = "bad format passed to Formatter::format()";

SSLException::SSLException(const String& message)

: Exception(MessageLoaderParms(

"Common.Exception.SSL_EXCEPTION",

"SSL Exception: $0" ,

message))

{

}

const char BadDateTimeFormat::MSG[] = "bad datetime format";

SSLException::SSLException(MessageLoaderParms& msgParms)

: Exception(MessageLoaderParms(

"Common.Exception.SSL_EXCEPTION",

"SSL Exception: $0",

MessageLoader::getMessage(msgParms)))

{

}

const char IncompatibleTypes::MSG[] = "incompatible types";

DateTimeOutOfRangeException::DateTimeOutOfRangeException(const String& message)

: Exception(MessageLoaderParms(

"Common.Exception.DATETIME_OUT_OF_RANGE_EXCEPTION",

"DateTime is out of range : $0" ,

message))

{

}

const char BadlyFormedCGIQueryString::MSG[] = "badly formed CGI query string";

DateTimeOutOfRangeException::DateTimeOutOfRangeException(

MessageLoaderParms& msgParms)

: Exception(MessageLoaderParms(

"Common.Exception.DATETIME_OUT_OF_RANGE_EXCEPTION",

"DateTime is out of range : $0",

MessageLoader::getMessage(msgParms)))

{

}

////////////////////////////////////////////////////////////////////////////////

// CimException

// CIMException

////////////////////////////////////////////////////////////////////////////////

static char* _cimMessages[] =

// 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(

CIMStatusCode code,

const String& message)

: Exception()

{

"successful",

CIMExceptionRep * tmp = new CIMExceptionRep ();

tmp->message = message;

"A general error occurred that is not covered by a more specific "

tmp->code = code;

"error code.",

tmp->file = "";

tmp->line = 0;

"Access to a CIM resource was not available to the client.",

tmp->contentLanguages.clear();

tmp->cimMessage = String::EMPTY;

"The target namespace does not exist.",

_rep = tmp;

}

"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 "

// l10n - note - use this when you have an exception

"superClass does not exist.",

// 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;

}

"Operation cannot be carried out because an object already exists.",

// 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;

}

"The specified property does not exist.",

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;

}

"The value supplied is incompatible with the type.",

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;

}

"The query language is not recognized or supported.",

CIMException::CIMException(const CIMException & cimException)

: Exception()

{

_rep = new CIMExceptionRep(

*reinterpret_cast<CIMExceptionRep*>(cimException._rep));

}

"The query is not valid for the specified query language.",

CIMException& CIMException::operator=(const CIMException & cimException)

{

if (&cimException != this)

{

CIMExceptionRep* left = reinterpret_cast<CIMExceptionRep*>(this->_rep);

CIMExceptionRep* right =

reinterpret_cast<CIMExceptionRep*>(cimException._rep);

*left = *right;

}

return *this;

}

"The extrinsic method could not be executed.",

CIMException::~CIMException()

{

}

"The specified extrinsic method does not exist."

Uint32 CIMException::getErrorCount() const

};

{

return reinterpret_cast<CIMExceptionRep*>(_rep)->errors.size();

}

/**************

CIMInstance CIMException::getError(Uint32 index)

{

return reinterpret_cast<CIMExceptionRep*>(_rep)->errors[index];

}

***************/

CimException::CimException(CimException::Code code)

CIMConstInstance CIMException::getError(Uint32 index) const

: Exception(_cimMessages[Uint32(code)]), _code(code)

{

return reinterpret_cast<CIMExceptionRep*>(_rep)->errors[index];

}

void CIMException::addError(const CIMInstance& instance)

{

reinterpret_cast<CIMExceptionRep*>(_rep)->errors.append(instance);

}

const char* CimException::codeToString(CimException::Code code)

CIMStatusCode CIMException::getCode() const

{

return _cimMessages[Uint32(code)];

CIMExceptionRep* rep;

rep = reinterpret_cast<CIMExceptionRep*>(_rep);

return rep->code;

}

PEGASUS_NAMESPACE_END

Legend:

Removed from v.1.3
changed lines
	Added in v.1.81.4.2

No CVS admin address has been configured