pegasus/src/Pegasus/Common/InternalException.h - diff

Return to InternalException.h CVS log

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

Diff for /pegasus/src/Pegasus/Common/InternalException.h between version 1.5 and 1.33

version 1.5, 2003/07/15 16:53:03

version 1.33, 2010/02/01 11:40:17

Line 1

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

//%LICENSE////////////////////////////////////////////////////////////////

// The Open Group, Tivoli Systems

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

// Licensed to The Open Group (TOG) under one or more contributor license

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

// agreements. Refer to the OpenPegasusNOTICE.txt file distributed with

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

// this work for additional information regarding copyright ownership.

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

// Each contributor licenses this file to you under the OpenPegasus Open

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

// Source License; you may not use this file except in compliance with the

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

// License.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

// The above copyright notice and this permission notice shall be included

// in all copies or substantial portions of the Software.

// Author: Roger Kumpf, Hewlett-Packard Company (roger_kumpf@hp.com)

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

// Modified By:

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

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

Line 33

Line 35

#include <Pegasus/Common/Config.h>

#include <Pegasus/Common/Linkage.h>

#include <Pegasus/Common/Exception.h>

#include <Pegasus/Common/PegasusAssert.h>

PEGASUS_NAMESPACE_BEGIN

Line 49

Line 52

const char* file,

size_t line,

const String& message);

};

/** define PEGASUS_ASSERT assertion statement. This statement tests the

virtual ~AssertionFailureException();

condition defined by the parameters and if not True executes an

};

<pre>

throw AssertionFailureException

</pre>

defining the file, line and condition that was tested.

#ifdef NDEBUG

#define PEGASUS_ASSERT(COND)

#else

#define PEGASUS_ASSERT(COND) \

do \

{ \

if (!(COND)) \

{ \

throw AssertionFailureException(__FILE__, __LINE__, #COND); \

} \

} while (0)

#endif

/* Macro to Create the equivalent of an assert but without the

termination. This can be used as a temporary marker for asserts

Line 93

Line 77

} while (0)

// l10n TODO - finish the commented out constructors

// ATTN: P3 KS documentation Required

class PEGASUS_COMMON_LINKAGE NullPointer : public Exception

{

public:

static const char MSG[];

// static const char KEY[];

static const char KEY[];

NullPointer() : Exception(MSG) { }

NullPointer();

// NullPointer() : Exception(MessageLoaderParms(KEY, MSG)) { }

virtual ~NullPointer();

};

// ATTN: P3 KS documentation Required

Line 114

Line 96

public:

static const char MSG[];

// static const char KEY[];

static const char KEY[];

UndeclaredQualifier(const String& qualifierName)

UndeclaredQualifier(const String& qualifierName) ;

: Exception(MSG + qualifierName) { }

// NOTE - MSG needs to have a $0 arg for all the substitution cases

virtual ~UndeclaredQualifier();

// UndeclaredQualifier(const String& qualifierName)

// : Exception(MessageLoaderParms(KEY, MSG, qualifierName)) { }

};

// ATTN: P3 KS documentation Required

Line 130

Line 109

public:

static const char MSG[];

// static const char KEY[];

static const char KEY[];

BadQualifierScope(const String& qualifierName, const String& scopeString)

BadQualifierScope(

: Exception(MSG + qualifierName + String(" scope=") + scopeString) { }

const String& qualifierName,

const String& scopeString);

virtual ~BadQualifierScope();

BadQualifierScope(const String& qualifierName, const String& scopeString)

: Exception(MessageLoaderParms(KEY,

MSG,

qualifierName,

scopeString)) { }

};

// ATTN: P3 KS documentation Required

Line 150

Line 124

public:

static const char MSG[];

// static const char KEY[];

static const char KEY[];

BadQualifierOverride(const String& qualifierName)

BadQualifierOverride(const String& qualifierName);

: Exception(MSG + qualifierName) { }

// BadQualifierOverride(const String& qualifierName)

virtual ~BadQualifierOverride();

// : Exception(MessageLoaderParms(KEY, MSG, qualifierName)) { }

};

class PEGASUS_COMMON_LINKAGE BadQualifierType : public Exception

Line 164

Line 136

public:

static const char MSG[];

// static const char KEY[];

static const char KEY[];

BadQualifierType(const String& qualifierName)

: Exception(MSG + qualifierName) { }

// BadQualifierType(const String& qualifierName)

// : Exception(MessageLoaderParms(KEY, MSG, qualifierName)) { }

};

// ATTN: P3 KS documentation Required

class PEGASUS_COMMON_LINKAGE ClassAlreadyResolved : public Exception

{

public:

static const char MSG[];

// static const char KEY[];

ClassAlreadyResolved(const String& className)

: Exception(MSG + className) { }

// ClassAlreadyResolved(const String& className)

// : Exception(MessageLoaderParms(KEY, MSG, className)) { }

};

// ATTN: P3 KS documentation Required

class PEGASUS_COMMON_LINKAGE ClassNotResolved : public Exception

{

public:

static const char MSG[];

// static const char KEY[];

ClassNotResolved(const String& className)

: Exception(MSG + className) { }

// ClassNotResolved(const String& className)

// : Exception(MessageLoaderParms(KEY, MSG, className)) { }

};

// ATTN: P3 KS documentation Required

class PEGASUS_COMMON_LINKAGE InstanceAlreadyResolved : public Exception

{

public:

static const char MSG[];

// static const char KEY[];

InstanceAlreadyResolved()

BadQualifierType(const String& qualifierName);

: Exception(MSG) { }

virtual ~BadQualifierType();

// InstanceAlreadyResolved()

// : Exception(MessageLoaderParms(KEY, MSG)) { }

};

// ATTN: P3 KS documentation Required

Line 224

Line 148

public:

static const char MSG[];

// static const char KEY[];

static const char KEY[];

InstantiatedAbstractClass(const String& className)

: Exception(MSG + className) { }

// InstantiatedAbstractClass(const String& className)

InstantiatedAbstractClass(const String& className);

// : Exception(MessageLoaderParms(KEY, MSG, className)) { }

virtual ~InstantiatedAbstractClass();

};

// ATTN: P3 KS documentation Required

Line 239

Line 160

public:

static const char MSG[];

// static const char KEY[];

static const char KEY[];

NoSuchProperty(const String& propertyName)

NoSuchProperty(const String& propertyName);

: Exception(MSG + propertyName) { }

virtual ~NoSuchProperty();

// NoSuchProperty(const String& propertyName)

// : Exception(MessageLoaderParms(KEY, MSG, propertyName)) { }

};

// ATTN: P3 KS documentation Required

Line 254

Line 172

public:

static const char MSG[];

// static const char KEY[];

static const char KEY[];

NoSuchFile(const String& fileName) : Exception(MSG + fileName) { }

// NoSuchFile(const String& fileName)

NoSuchFile(const String& fileName);

// : Exception(MessageLoaderParms(KEY, MSG, fileName)) { }

virtual ~NoSuchFile();

};

// ATTN: P3 KS documentation Required

Line 268

Line 184

public:

static const char MSG[];

// static const char KEY[];

static const char KEY[];

FileNotReadable(const String& fileName) : Exception(MSG + fileName) { }

// FileNotReadable(const String& fileName)

FileNotReadable(const String& fileName);

// : Exception(MessageLoaderParms(KEY, MSG, fileName)) { }

virtual ~FileNotReadable();

};

// ATTN: P3 KS documentation Required

Line 282

Line 196

public:

static const char MSG[];

// static const char KEY[];

static const char KEY[];

CannotRemoveDirectory(const String& path) : Exception(MSG + path) { }

CannotRemoveDirectory(const String& path);

virtual ~CannotRemoveDirectory();

// CannotRemoveDirectory(const String& path)

// : Exception(MessageLoaderParms(KEY, MSG, path)) { }

};

// ATTN: P3 KS documentation Required

Line 296

Line 208

public:

static const char MSG[];

// static const char KEY[];

static const char KEY[];

CannotRemoveFile(const String& path) : Exception(MSG + path) { }

CannotRemoveFile(const String& path);

// CannotRemoveFile(const String& path)

virtual ~CannotRemoveFile();

// : Exception(MessageLoaderParms(KEY, MSG, path)) { }

};

// ATTN: P3 KS documentation Required

Line 309

Line 220

public:

static const char MSG[];

// static const char KEY[];

static const char KEY[];

CannotRenameFile(const String& path) : Exception(MSG + path) { }

CannotRenameFile(const String& path);

// CannotRenameFile(const String& path)

virtual ~CannotRenameFile();

// : Exception(MessageLoaderParms(KEY, MSG, path)) { }

};

// ATTN: P3 KS documentation Required

Line 322

Line 232

public:

static const char MSG[];

// static const char KEY[];

static const char KEY[];

NoSuchDirectory(const String& directoryName)

NoSuchDirectory(const String& directoryName);

: Exception(MSG + directoryName) { }

virtual ~NoSuchDirectory();

// NoSuchDirectory(const String& directoryName)

// : Exception(MessageLoaderParms(KEY, MSG, directoryName)) { }

};

// ATTN: P3 KS documentation Required

Line 336

Line 244

public:

static const char MSG[];

// static const char KEY[];

static const char KEY[];

CannotCreateDirectory(const String& path)

CannotCreateDirectory(const String& path);

: Exception(MSG + path) { }

virtual ~CannotCreateDirectory();

// CannotCreateDirectory(const String& path)

// : Exception(MessageLoaderParms(KEY, MSG, path)) { }

};

// ATTN: P3 KS documentation Required

Line 350

Line 256

public:

static const char MSG[];

// static const char KEY[];

static const char KEY[];

CannotOpenFile(const String& path)

CannotOpenFile(const String& path);

: Exception(MSG + path) { }

virtual ~CannotOpenFile();

// CannotOpenFile(const String& path)

// : Exception(MessageLoaderParms(KEY, MSG, path)) { }

};

// ATTN: P3 KS documentation Required

class PEGASUS_COMMON_LINKAGE NotImplemented : public Exception

class PEGASUS_COMMON_LINKAGE CannotChangeFilePerm : public Exception

{

public:

static const char MSG[];

// static const char KEY[];

static const char KEY[];

NotImplemented(const String& method) : Exception(MSG + method) { }

CannotChangeFilePerm(const String& path);

// NotImplemented(const String& method)

virtual ~CannotChangeFilePerm();

// : Exception(MessageLoaderParms(KEY, MSG, method)) { }

};

class PEGASUS_COMMON_LINKAGE StackUnderflow : public Exception

// ATTN: P3 KS documentation Required

{

class PEGASUS_COMMON_LINKAGE NotImplemented : public Exception

public:

static const char MSG[];

// static const char KEY[];

StackUnderflow() : Exception(MSG) { }

// StackUnderflow()

// : Exception(MessageLoaderParms(KEY, MSG)) { }

};

class PEGASUS_COMMON_LINKAGE StackOverflow : public Exception

{

public:

static const char MSG[];

// static const char KEY[];

StackOverflow() : Exception(MSG) { }

// StackOverflow()

// : Exception(MessageLoaderParms(KEY, MSG)) { }

};

class PEGASUS_COMMON_LINKAGE QueueUnderflow : public Exception

{

public:

static const char MSG[];

// static const char KEY[];

static const char KEY[];

QueueUnderflow() : Exception(MSG) { }

NotImplemented(const String& method);

// QueueUnderflow()

virtual ~NotImplemented();

// : Exception(MessageLoaderParms(KEY, MSG)) { }

};

class PEGASUS_COMMON_LINKAGE BadFormat : public Exception

class PEGASUS_COMMON_LINKAGE StackUnderflow : public Exception

{

public:

static const char MSG[];

// static const char KEY[];

static const char KEY[];

BadFormat() : Exception(MSG) { }

StackUnderflow();

// BadFormat()

virtual ~StackUnderflow();

// : Exception(MessageLoaderParms(KEY, MSG)) { }

};

class PEGASUS_COMMON_LINKAGE BadlyFormedCGIQueryString : public Exception

class PEGASUS_COMMON_LINKAGE StackOverflow : public Exception

{

public:

static const char MSG[];

// static const char KEY[];

static const char KEY[];

BadlyFormedCGIQueryString() : Exception(MSG) { }

StackOverflow();

// BadlyFormedCGIQueryString()

virtual ~StackOverflow();

// : Exception(MessageLoaderParms(KEY, MSG)) { }

};

class PEGASUS_COMMON_LINKAGE DynamicLoadFailed : public Exception

Line 436

Line 313

public:

static const char MSG[];

// static const char KEY[];

static const char KEY[];

DynamicLoadFailed(const String& libraryName)

: Exception(MSG + libraryName) { }

// DynamicLoadFailed(const String& libraryName)

DynamicLoadFailed(const String& libraryName);

// : Exception(MessageLoaderParms(KEY, MSG, libraryName)) { }

virtual ~DynamicLoadFailed();

};

class PEGASUS_COMMON_LINKAGE DynamicLookupFailed : public Exception

Line 450

Line 324

public:

static const char MSG[];

// static const char KEY[];

static const char KEY[];

DynamicLookupFailed(const String& symbolName)

DynamicLookupFailed(const String& symbolName);

: Exception(MSG + symbolName) { }

virtual ~DynamicLookupFailed();

// DynamicLookupFailed(const String& symbolName)

// : Exception(MessageLoaderParms(KEY, MSG, symbolName)) { }

};

class PEGASUS_COMMON_LINKAGE CannotOpenDirectory : public Exception

Line 463

Line 335

public:

static const char MSG[];

// static const char KEY[];

static const char KEY[];

CannotOpenDirectory(const String& path) : Exception(MSG + path) { }

CannotOpenDirectory(const String& path);

// CannotOpenDirectory(const String& path)

virtual ~CannotOpenDirectory();

// : Exception(MessageLoaderParms(KEY, MSG, path)) { }

};

class PEGASUS_COMMON_LINKAGE ParseError : public Exception

Line 475

Line 346

public:

static const char MSG[];

// static const char KEY[];

static const char KEY[];

ParseError(const String& message) : Exception(MSG + message) { }

ParseError(const String& message);

// ParseError(const String& message)

virtual ~ParseError();

// : Exception(MessageLoaderParms(KEY, MSG, message)) { }

};

class PEGASUS_COMMON_LINKAGE MissingNullTerminator : public Exception

Line 487

Line 357

public:

static const char MSG[];

// static const char KEY[];

static const char KEY[];

MissingNullTerminator() : Exception(MSG) { }

MissingNullTerminator();

// MissingNullTerminator()

virtual ~MissingNullTerminator();

// : Exception(MessageLoaderParms(KEY, MSG)) { }

};

//l10n start

class PEGASUS_COMMON_LINKAGE MalformedLanguageHeader: public Exception

{

public:

static const char MSG[];

// static const char KEY[];

static const char KEY[];

MalformedLanguageHeader(const String& error) : Exception(MSG + error) { }

MalformedLanguageHeader(const String& error);

// MalformedLanguageHeader(const String& error)

virtual ~MalformedLanguageHeader();

// : Exception(MessageLoaderParms(KEY, MSG, error)) { }

};

class PEGASUS_COMMON_LINKAGE InvalidAcceptLanguageHeader: public Exception

{

public:

static const char MSG[];

// static const char KEY[];

static const char KEY[];

InvalidAcceptLanguageHeader(const String& error) : Exception(MSG + error) { }

InvalidAcceptLanguageHeader(const String& error);

// InvalidAcceptLanguageHeader(const String& error)

virtual ~InvalidAcceptLanguageHeader();

// : Exception(MessageLoaderParms(KEY, MSG, error)) { }

};

class PEGASUS_COMMON_LINKAGE InvalidContentLanguageHeader: public Exception

Line 526

Line 390

public:

static const char MSG[];

// static const char KEY[];

static const char KEY[];

InvalidContentLanguageHeader(const String& error) : Exception(MSG + error) { }

InvalidContentLanguageHeader(const String& error);

// InvalidContentLanguageHeader(const String& error)

virtual ~InvalidContentLanguageHeader();

// : Exception(MessageLoaderParms(KEY, MSG, error)) { }

};

//l10n end

class PEGASUS_COMMON_LINKAGE InvalidAuthHeader: public Exception

{

public:

static const char MSG[];

// static const char KEY[];

static const char KEY[];

InvalidAuthHeader() : Exception(MSG) { }

InvalidAuthHeader();

// InvalidAuthHeader()

virtual ~InvalidAuthHeader();

// : Exception(MessageLoaderParms(KEY, MSG)) { }

};

class PEGASUS_COMMON_LINKAGE UnauthorizedAccess: public Exception

Line 552

Line 412

public:

static const char MSG[];

// static const char KEY[];

static const char KEY[];

UnauthorizedAccess() : Exception(MSG) { }

UnauthorizedAccess();

// UnauthorizedAccess()

virtual ~UnauthorizedAccess();

// : Exception(MessageLoaderParms(KEY, MSG)) { }

};

class PEGASUS_COMMON_LINKAGE IncompatibleTypesException : public Exception

{

public:

IncompatibleTypesException();

virtual ~IncompatibleTypesException();

};

class PEGASUS_COMMON_LINKAGE InternalSystemError : public Exception

{

public:

static const char MSG[];

InternalSystemError();

virtual ~InternalSystemError();

};

class PEGASUS_COMMON_LINKAGE SocketWriteError : public Exception

{

public:

static const char MSG[];

static const char KEY[];

SocketWriteError(const String& error);

virtual ~SocketWriteError();

};

/** The CIMException defines the CIM exceptions that are formally defined in

the CIM Operations over HTTP specification. TraceableCIMException allows

Line 577

Line 457

TraceableCIMException(

CIMStatusCode code,

const String& message,

const char* file,

const String& file,

Uint32 line);

TraceableCIMException(

CIMStatusCode code,

const MessageLoaderParms& parms,

const String& file,

Uint32 line);

// l10n

TraceableCIMException(

const ContentLanguages& langs,

const ContentLanguageList& langs,

CIMStatusCode code,

const String& message,

const char* file,

const String& file,

Uint32 line);

TraceableCIMException(const CIMException & cimException);

Line 593

Line 478

String getDescription() const;

String getTraceDescription() const;

String getCIMMessage() const;

void setCIMMessage(const String& cimMessage);

String getFile() const;

Uint32 getLine() const;

const ContentLanguageList& getContentLanguages() const;

};

#define PEGASUS_CIM_EXCEPTION(CODE, EXTRA_MESSAGE) \

TraceableCIMException(CODE, EXTRA_MESSAGE, __FILE__, __LINE__)

TraceableCIMException(CODE, EXTRA_MESSAGE, String(__FILE__), __LINE__)

// l10n

#define PEGASUS_CIM_EXCEPTION_LANG(LANGS, CODE, EXTRA_MESSAGE) \

TraceableCIMException(LANGS, CODE, EXTRA_MESSAGE, __FILE__, __LINE__)

TraceableCIMException( \

LANGS, CODE, EXTRA_MESSAGE, String(__FILE__), __LINE__)

#define PEGASUS_CIM_EXCEPTION_L(CODE, MSG_PARMS) \

TraceableCIMException(CODE, MSG_PARMS, String(__FILE__), __LINE__)

/** Macro to prevent overflow of a signed int value when said value is

* doubled. If String/Array/Buffer size is greater than 0x3FFFFFFF, then

* something is suspect, throw bad_alloc exception.

#define PEGASUS_CHECK_CAPACITY_OVERFLOW(capacity) \

do \

{ \

if (capacity > 0x3FFFFFFF) \

throw PEGASUS_STD(bad_alloc)(); \

} \

while (0)

/** The following function CheckRep serves to reduce the function call

* overhead caused by calling a non-inlined function that only checks

* if a pointer is not NULL.

* The function ThrowUnitializedObjectException throws

* an UninitialisedObjectException.

* A function to throw the exception is used to reduce object size of

* function CheckRep which is inlined in many places across

* the common library.

PEGASUS_COMMON_LINKAGE extern void ThrowUninitializedObjectException();

inline void CheckRep(void * rep)

{

if (!rep)

ThrowUninitializedObjectException();

}

PEGASUS_NAMESPACE_END

Legend:

Removed from v.1.5
changed lines
	Added in v.1.33

No CVS admin address has been configured