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.37 and 1.81.4.2

version 1.37, 2002/04/24 17:34:29

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

Line 1

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

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

Line 20

Line 29

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

// Author: Mike Brasher (mbrasher@bmc.com)

// Modified By: Nag Boranna (nagaraja_boranna@hp.com)

// Modified By: Jenny Yu (jenny_yu@am.exch.hp.com)

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

#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, "%u", line);

{

*this->_rep = *exception._rep;

_message = file;

}

_message.append("(");

return *this;

_message.append(lineStr);

_message.append("): ");

_message.append(message);

// ATTN-RK-P3-20020408: Should define a "test" trace component

PEG_TRACE_STRING(TRC_SERVER, Tracer::LEVEL2, _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 handle";

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

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[] =

"attempted to instantiate an abstract class ";

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

const char TruncatedCharacter::MSG[] =

"truncated character during conversion from Char16 to char";

const char ExpectedReferenceValue::MSG[] =

"Expected CIMValue object to be CIMType::REFERENCE or CIMType::REFERENCE_ARRAY "

"in this context";

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

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

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

const char CIMValueIsNull::MSG[] = "null CIMValue accessed";

const char CIMValueInvalidType::MSG[] = "invalid CIMValue type";

const char DynamicCastFailed::MSG[] = "dynamic cast failed";

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

const char FileNotReadable::MSG[] = "file not readable: ";

const char CannotBindToAddress::MSG[] = "cannot bind to address: ";

const ContentLanguageList& Exception::getContentLanguages() const

{

return _rep->contentLanguages;

}

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

void Exception::setContentLanguages(const ContentLanguageList& langs)

{

_rep->contentLanguages = langs;

}

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

IndexOutOfBoundsException::IndexOutOfBoundsException()

: Exception(MessageLoaderParms(

"Common.Exception.INDEX_OUT_OF_BOUNDS_EXCEPTION",

"index out of bounds"))

{

}

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

AlreadyExistsException::AlreadyExistsException(const String& message)

: Exception(MessageLoaderParms(

"Common.Exception.ALREADY_EXISTS_EXCEPTION",

"already exists: $0",

message))

{

}

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

AlreadyExistsException::AlreadyExistsException(MessageLoaderParms& msgParms)

: Exception(MessageLoaderParms(

"Common.Exception.ALREADY_EXISTS_EXCEPTION",

"already exists: $0",

MessageLoader::getMessage(msgParms)))

{

}

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

InvalidNameException::InvalidNameException(const String& message)

: Exception(MessageLoaderParms(

"Common.Exception.INVALID_NAME_EXCEPTION",

"invalid CIM name: $0",

message))

{

}

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

InvalidNameException::InvalidNameException(MessageLoaderParms& msgParms)

: Exception(MessageLoaderParms(

"Common.Exception.INVALID_NAME_EXCEPTION",

"invalid CIM name: $0",

MessageLoader::getMessage(msgParms)))

{

}

const char CannotRemoveDirectory::MSG[] = "cannot remove directory: ";

InvalidNamespaceNameException::InvalidNamespaceNameException(const String& name)

: Exception(MessageLoaderParms(

"Common.Exception.INVALID_NAMESACE_NAME_EXCEPTION",

"invalid CIM namespace name: $0",

name))

{

}

const char CannotRemoveFile::MSG[] = "cannot remove file: ";

InvalidNamespaceNameException::InvalidNamespaceNameException(

MessageLoaderParms& msgParms)

: Exception(MessageLoaderParms(

"Common.Exception.INVALID_NAMESPACE_NAME_EXCEPTION",

"invalid CIM namespace name: $0",

MessageLoader::getMessage(msgParms)))

{

}

const char CannotRenameFile::MSG[] = "cannot rename file: ";

UninitializedObjectException::UninitializedObjectException()

: Exception(MessageLoaderParms(

"Common.Exception.UNINITIALIZED_OBJECT_EXCEPTION",

"uninitialized object"))

{

}

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

TypeMismatchException::TypeMismatchException()

: Exception(MessageLoaderParms(

"Common.Exception.TYPE_MISMATCH_EXCEPTION",

"type mismatch"))

{

}

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

TypeMismatchException::TypeMismatchException(const String& message)

: Exception(MessageLoaderParms(

"Common.Exception.TYPE_MISMATCH_EXCEPTION",

"type mismatch: $0",message))

{

const char QueueUnderflow::MSG[] = "queue Underflow";

}

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

TypeMismatchException::TypeMismatchException(MessageLoaderParms& msgParms)

: Exception(MessageLoaderParms(

"Common.Exception.TYPE_MISMATCH_EXCEPTION",

"type mismatch: $0",

MessageLoader::getMessage(msgParms)))

{

}

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

DynamicCastFailedException::DynamicCastFailedException()

: Exception(MessageLoaderParms(

"Common.Exception.DYNAMIC_CAST_FAILED_EXCEPTION",

"dynamic cast failed"))

{

}

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

InvalidDateTimeFormatException::InvalidDateTimeFormatException()

: Exception(MessageLoaderParms(

"Common.Exception.INVALID_DATETIME_FORMAT_EXCEPTION",

"invalid datetime format"))

{

}

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

MalformedObjectNameException::MalformedObjectNameException(

const String& message)

: Exception(MessageLoaderParms(

"Common.Exception.MALFORMED_OBJECT_NAME_EXCEPTION",

"malformed object name: $0",

message))

{

}

const char IllformedObjectName::MSG[] = "illformed object name: ";

MalformedObjectNameException::MalformedObjectNameException(

MessageLoaderParms& msgParms)

: Exception(MessageLoaderParms(

"Common.Exception.MALFORMED_OBJECT_NAME_EXCEPTION",

"malformed object name: $0",

MessageLoader::getMessage(msgParms)))

{

}

const char DynamicLoadFailed::MSG[] = "load of dynamic library failed: ";

BindFailedException::BindFailedException(const String& message)

: Exception(MessageLoaderParms(

"Common.Exception.BIND_FAILED_EXCEPTION",

"Bind failed: $0",

message))

{

}

const char DynamicLookupFailed::MSG[] =

BindFailedException::BindFailedException(MessageLoaderParms& msgParms)

"lookup of symbol in dynamic library failed: ";

: Exception(MessageLoaderParms(

"Common.Exception.BIND_FAILED_EXCEPTION",

"Bind failed: $0",

MessageLoader::getMessage(msgParms)))

{

}

const char CannotOpenDirectory::MSG[] = "cannot open directory: ";

InvalidLocatorException::InvalidLocatorException(const String& message)

: Exception(MessageLoaderParms(

"Common.Exception.INVALID_LOCATOR_EXCEPTION",

"Invalid locator: $0",

message))

{

}

const char CorruptFile::MSG[] = "corrupt file: ";

InvalidLocatorException::InvalidLocatorException(MessageLoaderParms& msgParms)

: Exception(MessageLoaderParms(

"Common.Exception.INVALID_LOCATOR_EXCEPTION",

"Invalid locator: $0",

MessageLoader::getMessage(msgParms)))

{

}

const char BindFailed::MSG[] = "Bind failed: ";

CannotCreateSocketException::CannotCreateSocketException()

: Exception(MessageLoaderParms(

"Common.Exception.CANNOT_CREATE_SOCKET_EXCEPTION",

"Cannot create socket"))

{

}

const char InvalidLocator::MSG[] = "Invalid locator: ";

const char CannotCreateSocket::MSG[] = "Cannot create socket";

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

: Exception(message)

{

}

const char CannotConnect::MSG[] = "Cannot connect to: ";

const char UnexpectedFailure::MSG[] = "Unexpected failure";

CannotConnectException::CannotConnectException(MessageLoaderParms& msgParms)

: Exception(msgParms)

{

}

const char AlreadyConnected::MSG[] = "already connected";

AlreadyConnectedException::AlreadyConnectedException()

: Exception(MessageLoaderParms(

"Common.Exception.ALREADY_CONNECTED_EXCEPTION",

"already connected"))

{

}

const char NotConnected::MSG[] = "not connected";

const char TimedOut::MSG[] = "timed out";

NotConnectedException::NotConnectedException()

: Exception(MessageLoaderParms(

"Common.Exception.NOT_CONNECTED_EXCEPTION",

"not connected"))

{

}

const char ParseError::MSG[] = "parse error: ";

ConnectionTimeoutException::ConnectionTimeoutException()

: Exception(MessageLoaderParms(

"Common.Exception.CONNECTION_TIMEOUT_EXCEPTION",

"connection timed out"))

{

}

const char MissingNullTerminator::MSG[] = "missing null terminator: ";

SSLException::SSLException(const String& message)

: Exception(MessageLoaderParms(

"Common.Exception.SSL_EXCEPTION",

"SSL Exception: $0" ,

message))

{

}

const char SSL_Exception::MSG[] = "SSL Exception ";

SSLException::SSLException(MessageLoaderParms& msgParms)

: Exception(MessageLoaderParms(

"Common.Exception.SSL_EXCEPTION",

"SSL Exception: $0",

MessageLoader::getMessage(msgParms)))

{

}

const char InvalidAuthHeader::MSG[] = "Invalid Authorization header";

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 208

Line 326

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

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

// Creates a description without source file name and line number.

// detail message, or one with an untranslated detail message

// The pegasus message associated with code will be translated.

static String _makeCIMExceptionDescription(

CIMException::CIMException(

CIMStatusCode code,

const String& message)

: Exception()

{

String tmp;

CIMExceptionRep * tmp = new CIMExceptionRep ();

tmp.append(CIMStatusCodeToString(code));

tmp->message = message;

tmp.append(": \"");

tmp->code = code;

tmp.append(message);

tmp->file = "";

tmp.append("\"");

tmp->line = 0;

return tmp;

tmp->contentLanguages.clear();

tmp->cimMessage = String::EMPTY;

_rep = tmp;

}

// Creates a description with source file name and line number.

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

// an untranslated detail message and an attached CIM_Error

static String _makeCIMExceptionDescription(

// The pegasus message associated with code will be translated.

CIMException::CIMException(

CIMStatusCode code,

const String& message,

const char* file,

const CIMInstance& instance)

Uint32 line)

: Exception()

{

String tmp = file;

CIMExceptionRep * tmp = new CIMExceptionRep ();

tmp.append("(");

tmp->message = message;

char buffer[32];

tmp->code = code;

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

tmp->file = "";

tmp.append(buffer);

tmp->errors.append(instance);

tmp.append("): ");

tmp->line = 0;

tmp->contentLanguages.clear();

tmp.append(CIMStatusCodeToString(code));

tmp->cimMessage = String::EMPTY;

tmp.append(": \"");

_rep = tmp;

tmp.append(message);

}

tmp.append("\"");

return 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 char* file,

const Array<CIMInstance>& instances)

Uint32 line)

: Exception()

{

Exception(message),

CIMExceptionRep * tmp = new CIMExceptionRep ();

_code(code),

tmp->message = message;

_file(file),

tmp->code = code;

_line(line)

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)

: Exception(cimException.getMessage()),

: Exception()

_code(cimException._code),

_file(cimException._file),

_line(cimException._line)

{

_rep = new CIMExceptionRep(

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

}

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

// Returns a description string fit for human consumption

String CIMException::getDescription() const

{

#ifdef DEBUG_CIMEXCEPTION

if (&cimException != this)

return getTraceDescription();

{

#else

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

return _makeCIMExceptionDescription(_code, getMessage());

CIMExceptionRep* right =

#endif

reinterpret_cast<CIMExceptionRep*>(cimException._rep);

*left = *right;

}

return *this;

}

CIMException::~CIMException()

// Returns a description string with filename and line number information

// specifically for tracing.

String CIMException::getTraceDescription() const

{

String traceDescription =

}

_makeCIMExceptionDescription(_code, getMessage(), _file, _line);

return traceDescription;

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

}

void ThrowUnitializedHandle()

CIMStatusCode CIMException::getCode() const

{

throw UnitializedHandle();

CIMExceptionRep* rep;

rep = reinterpret_cast<CIMExceptionRep*>(_rep);

return rep->code;

}

PEGASUS_NAMESPACE_END

Legend:

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

No CVS admin address has been configured