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.18 and 1.33

version 1.18, 2006/05/10 19:40:38

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

Line 1

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

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

// EMC Corporation; Symantec 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 43

Line 37

#include <Pegasus/Common/Exception.h>

#include <Pegasus/Common/PegasusAssert.h>

PEGASUS_NAMESPACE_BEGIN

/** Class AssertionFailureException

Line 60

Line 52

const char* file,

size_t line,

const String& message);

virtual ~AssertionFailureException();

};

Line 91

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 104

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 120

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 140

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 154

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 214

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 229

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 244

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 258

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 272

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 286

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 299

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 312

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 326

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 340

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

class PEGASUS_COMMON_LINKAGE NotImplemented : public Exception

class PEGASUS_COMMON_LINKAGE CannotChangeFilePerm : public Exception

{

public:

static const char MSG[];

static const char KEY[];

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

NotImplemented(const String& method)

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

};

class PEGASUS_COMMON_LINKAGE StackUnderflow : 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) { }

CannotChangeFilePerm(const String& path);

StackOverflow()

virtual ~CannotChangeFilePerm();

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

};

class PEGASUS_COMMON_LINKAGE QueueUnderflow : public Exception

// ATTN: P3 KS documentation Required

class PEGASUS_COMMON_LINKAGE NotImplemented : public Exception

{

public:

static const char MSG[];

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

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

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

StackOverflow();

BadlyFormedCGIQueryString()

virtual ~StackOverflow();

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

};

class PEGASUS_COMMON_LINKAGE DynamicLoadFailed : public Exception

Line 426

Line 315

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 440

Line 326

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 453

Line 337

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 465

Line 348

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 477

Line 359

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 491

Line 370

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 504

Line 381

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 516

Line 392

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 530

Line 403

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 542

Line 414

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 559

Line 431

static const char MSG[];

InternalSystemError()

InternalSystemError();

: Exception(MSG) { }

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 578

Line 460

const String& file,

Uint32 line);

//l10n

TraceableCIMException(

CIMStatusCode code,

MessageLoaderParms parms,

const MessageLoaderParms& parms,

const String& file,

Uint32 line);

// l10n

TraceableCIMException(

const ContentLanguageList& langs,

CIMStatusCode code,

Line 610

Line 490

#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__)

Line 631

Line 509

} \

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.18
changed lines
	Added in v.1.33

No CVS admin address has been configured