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.14 and 1.30

version 1.14, 2005/11/22 02:59:06

version 1.30, 2008/12/02 09:00:47

Line 1

//%2005////////////////////////////////////////////////////////////////////////

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

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

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

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

// this work for additional information regarding copyright ownership.

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

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

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

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

// License.

// EMC Corporation; VERITAS Software 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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

// Modified By:

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

Line 41

Line 37

#include <Pegasus/Common/Exception.h>

#include <Pegasus/Common/PegasusAssert.h>

PEGASUS_NAMESPACE_BEGIN

/** Class AssertionFailureException

Line 58

Line 52

const char* file,

size_t line,

const String& message);

};

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

condition defined by the parameters and if not True executes an

<pre>

virtual ~AssertionFailureException();

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 110

Line 85

static const char MSG[];

static const char KEY[];

//NullPointer() : Exception(MSG) { }

NullPointer();

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

virtual ~NullPointer();

};

// ATTN: P3 KS documentation Required

Line 123

Line 98

static const char MSG[];

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 139

Line 111

static const char MSG[];

static const char KEY[];

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

BadQualifierScope(

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

const String& qualifierName,

const String& scopeString);

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

: Exception(MessageLoaderParms(KEY,

MSG,

qualifierName,

scopeString)) { }

virtual ~BadQualifierScope();

};

// ATTN: P3 KS documentation Required

Line 159

Line 126

static const char MSG[];

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 173

Line 138

static const char MSG[];

static const char KEY[];

//BadQualifierType(const String& qualifierName)

BadQualifierType(const String& qualifierName);

//: Exception(MSG + qualifierName) { }

virtual ~BadQualifierType();

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

// : Exception(MSG) { }

InstanceAlreadyResolved()

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

};

// ATTN: P3 KS documentation Required

Line 233

Line 150

static const char MSG[];

static const char KEY[];

//InstantiatedAbstractClass(const String& className)

InstantiatedAbstractClass(const String& className);

//: Exception(MSG + className) { }

virtual ~InstantiatedAbstractClass();

InstantiatedAbstractClass(const String& className)

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

};

// ATTN: P3 KS documentation Required

Line 248

Line 162

static const char MSG[];

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 263

Line 174

static const char MSG[];

static const char KEY[];

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

NoSuchFile(const String& fileName);

virtual ~NoSuchFile();

NoSuchFile(const String& fileName)

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

};

// ATTN: P3 KS documentation Required

Line 277

Line 186

static const char MSG[];

static const char KEY[];

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

FileNotReadable(const String& fileName);

virtual ~FileNotReadable();

FileNotReadable(const String& fileName)

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

};

// ATTN: P3 KS documentation Required

Line 291

Line 198

static const char MSG[];

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 305

Line 210

static const char MSG[];

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 318

Line 222

static const char MSG[];

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 331

Line 234

static const char MSG[];

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 345

Line 246

static const char MSG[];

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 359

Line 258

static const char MSG[];

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

Line 373

Line 270

static const char MSG[];

static const char KEY[];

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

NotImplemented(const String& method);

NotImplemented(const String& method)

virtual ~NotImplemented();

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

};

class PEGASUS_COMMON_LINKAGE StackUnderflow : public Exception

Line 385

Line 281

static const char MSG[];

static const char KEY[];

//StackUnderflow() : Exception(MSG) { }

StackUnderflow();

StackUnderflow()

virtual ~StackUnderflow();

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

};

class PEGASUS_COMMON_LINKAGE StackOverflow : public Exception

Line 397

Line 292

static const char MSG[];

static const char KEY[];

//StackOverflow() : Exception(MSG) { }

StackOverflow();

StackOverflow()

virtual ~StackOverflow();

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

};

class PEGASUS_COMMON_LINKAGE QueueUnderflow : public Exception

{

public:

static const char MSG[];

static const char KEY[];

//QueueUnderflow() : Exception(MSG) { }

QueueUnderflow()

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

};

class PEGASUS_COMMON_LINKAGE BadFormat : public Exception

{

public:

static const char MSG[];

static const char KEY[];

//BadFormat() : Exception(MSG) { }

BadFormat()

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

};

class PEGASUS_COMMON_LINKAGE BadlyFormedCGIQueryString : public Exception

{

public:

static const char MSG[];

static const char KEY[];

//BadlyFormedCGIQueryString() : Exception(MSG) { }

BadlyFormedCGIQueryString()

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

};

class PEGASUS_COMMON_LINKAGE DynamicLoadFailed : public Exception

Line 445

Line 303

static const char MSG[];

static const char KEY[];

//DynamicLoadFailed(const String& libraryName)

DynamicLoadFailed(const String& libraryName);

//: Exception(MSG + libraryName) { }

virtual ~DynamicLoadFailed();

DynamicLoadFailed(const String& libraryName)

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

};

class PEGASUS_COMMON_LINKAGE DynamicLookupFailed : public Exception

Line 459

Line 314

static const char MSG[];

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 472

Line 325

static const char MSG[];

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 484

Line 336

static const char MSG[];

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 496

Line 347

static const char MSG[];

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:

Line 510

Line 358

static const char MSG[];

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:

Line 523

Line 369

static const char MSG[];

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 535

Line 380

static const char MSG[];

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:

Line 549

Line 391

static const char MSG[];

static const char KEY[];

//InvalidAuthHeader() : Exception(MSG) { }

InvalidAuthHeader();

InvalidAuthHeader()

virtual ~InvalidAuthHeader();

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

};

class PEGASUS_COMMON_LINKAGE UnauthorizedAccess: public Exception

Line 561

Line 402

static const char MSG[];

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

Line 578

Line 419

static const char MSG[];

InternalSystemError()

InternalSystemError();

: Exception(MSG) { }

virtual ~InternalSystemError();

};

Line 597

Line 438

const String& file,

Uint32 line);

//l10n

TraceableCIMException(

CIMStatusCode code,

MessageLoaderParms parms,

const MessageLoaderParms& parms,

const String& file,

Uint32 line);

// l10n

TraceableCIMException(

const ContentLanguages& langs,

const ContentLanguageList& langs,

CIMStatusCode code,

const String& message,

const String& file,

Line 623

Line 462

String getFile() const;

Uint32 getLine() const;

const ContentLanguages& getContentLanguages() const;

const ContentLanguageList& getContentLanguages() const;

};

#define PEGASUS_CIM_EXCEPTION(CODE, EXTRA_MESSAGE) \

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

// l10n

#define PEGASUS_CIM_EXCEPTION_LANG(LANGS, CODE, EXTRA_MESSAGE) \

TraceableCIMException( \

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

//l10n

#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

#endif /* Pegasus_InternalException_h */

Legend:

Removed from v.1.14
changed lines
	Added in v.1.30

No CVS admin address has been configured