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.4.14.4 and 1.34.2.1

version 1.4.14.4, 2003/08/14 11:55:42

version 1.34.2.1, 2013/06/03 22:35:12

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

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 93

Line 77

} while (0)

// l10n TODO - finish the commented out constructors

// ATTN: P3 KS documentation Required

class PEGASUS_COMMON_LINKAGE NullPointer : public Exception

{

Line 103

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 116

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 132

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 152

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 165

Line 137

static const char MSG[];

static const char KEY[];

BadQualifierType(const String& qualifierName,

const String& className = String());

virtual ~BadQualifierType();

const String _qualifierName;

const String _className;

const String& getQualifierName() const;

const String& getClassName() const;

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

class PEGASUS_COMMON_LINKAGE InstantiatedAbstractClass : public Exception

{

public:

static const char MSG[];

static const char KEY[];

//ClassAlreadyResolved(const String& className)

InstantiatedAbstractClass(const String& className);

//: Exception(MSG + className) { }

virtual ~InstantiatedAbstractClass();

ClassAlreadyResolved(const String& className)

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

};

// ATTN: P3 KS documentation Required

class PEGASUS_COMMON_LINKAGE ClassNotResolved : public Exception

class PEGASUS_COMMON_LINKAGE NoSuchProperty : public Exception

{

public:

static const char MSG[];

static const char KEY[];

//ClassNotResolved(const String& className)

NoSuchProperty(const String& propertyName);

//: Exception(MSG + className) { }

virtual ~NoSuchProperty();

ClassNotResolved(const String& className)

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

};

// ATTN: P3 KS documentation Required

class PEGASUS_COMMON_LINKAGE InstanceAlreadyResolved : public Exception

class PEGASUS_COMMON_LINKAGE NoSuchFile : public Exception

{

public:

static const char MSG[];

static const char KEY[];

//InstanceAlreadyResolved()

NoSuchFile(const String& fileName);

// : Exception(MSG) { }

virtual ~NoSuchFile();

InstanceAlreadyResolved()

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

};

// ATTN: P3 KS documentation Required

class PEGASUS_COMMON_LINKAGE InstantiatedAbstractClass : public Exception

class PEGASUS_COMMON_LINKAGE FileNotReadable : public Exception

{

public:

static const char MSG[];

static const char KEY[];

//InstantiatedAbstractClass(const String& className)

FileNotReadable(const String& fileName);

//: Exception(MSG + className) { }

virtual ~FileNotReadable();

InstantiatedAbstractClass(const String& className)

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

};

// ATTN: P3 KS documentation Required

class PEGASUS_COMMON_LINKAGE NoSuchProperty : public Exception

class PEGASUS_COMMON_LINKAGE CannotRemoveDirectory : public Exception

{

public:

static const char MSG[];

static const char KEY[];

//NoSuchProperty(const String& propertyName)

CannotRemoveDirectory(const String& path);

//: Exception(MSG + propertyName) { }

virtual ~CannotRemoveDirectory();

NoSuchProperty(const String& propertyName)

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

};

// ATTN: P3 KS documentation Required

class PEGASUS_COMMON_LINKAGE NoSuchFile : public Exception

class PEGASUS_COMMON_LINKAGE CannotRemoveFile : public Exception

{

public:

static const char MSG[];

static const char KEY[];

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

CannotRemoveFile(const String& path);

virtual ~CannotRemoveFile();

NoSuchFile(const String& fileName)

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

};

// ATTN: P3 KS documentation Required

class PEGASUS_COMMON_LINKAGE FileNotReadable : public Exception

class PEGASUS_COMMON_LINKAGE CannotRenameFile : public Exception

{

public:

static const char MSG[];

static const char KEY[];

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

CannotRenameFile(const String& path);

virtual ~CannotRenameFile();

FileNotReadable(const String& fileName)

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

};

// ATTN: P3 KS documentation Required

class PEGASUS_COMMON_LINKAGE CannotRemoveDirectory : public Exception

class PEGASUS_COMMON_LINKAGE NoSuchDirectory : public Exception

{

public:

static const char MSG[];

static const char KEY[];

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

NoSuchDirectory(const String& directoryName);

virtual ~NoSuchDirectory();

CannotRemoveDirectory(const String& path)

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

};

// ATTN: P3 KS documentation Required

class PEGASUS_COMMON_LINKAGE CannotRemoveFile : public Exception

class PEGASUS_COMMON_LINKAGE CannotCreateDirectory : public Exception

{

public:

static const char MSG[];

static const char KEY[];

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

CannotCreateDirectory(const String& path);

CannotRemoveFile(const String& path)

virtual ~CannotCreateDirectory();

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

};

// ATTN: P3 KS documentation Required

class PEGASUS_COMMON_LINKAGE CannotRenameFile : public Exception

class PEGASUS_COMMON_LINKAGE CannotOpenFile : public Exception

{

public:

static const char MSG[];

static const char KEY[];

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

CannotOpenFile(const String& path);

CannotRenameFile(const String& path)

virtual ~CannotOpenFile();

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

};

// ATTN: P3 KS documentation Required

class PEGASUS_COMMON_LINKAGE NoSuchDirectory : public Exception

class PEGASUS_COMMON_LINKAGE CannotChangeFilePerm : public Exception

{

public:

static const char MSG[];

static const char KEY[];

//NoSuchDirectory(const String& directoryName)

CannotChangeFilePerm(const String& path);

//: Exception(MSG + directoryName) { }

virtual ~CannotChangeFilePerm();

NoSuchDirectory(const String& directoryName)

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

};

// ATTN: P3 KS documentation Required

class PEGASUS_COMMON_LINKAGE CannotCreateDirectory : public Exception

class PEGASUS_COMMON_LINKAGE NotImplemented : public Exception

{

public:

static const char MSG[];

static const char KEY[];

//CannotCreateDirectory(const String& path)

NotImplemented(const String& method);

//: Exception(MSG + path) { }

virtual ~NotImplemented();

CannotCreateDirectory(const String& path)

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

};

// ATTN: P3 KS documentation Required

class PEGASUS_COMMON_LINKAGE StackUnderflow : public Exception

class PEGASUS_COMMON_LINKAGE CannotOpenFile : public Exception

{

public:

static const char MSG[];

static const char KEY[];

//CannotOpenFile(const String& path)

StackUnderflow();

//: Exception(MSG + path) { }

virtual ~StackUnderflow();

CannotOpenFile(const String& path)

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

};

// ATTN: P3 KS documentation Required

class PEGASUS_COMMON_LINKAGE StackOverflow : public Exception

class PEGASUS_COMMON_LINKAGE NotImplemented : public Exception

{

public:

static const char MSG[];

static const char KEY[];

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

StackOverflow();

NotImplemented(const String& method)

virtual ~StackOverflow();

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

};

class PEGASUS_COMMON_LINKAGE StackUnderflow : public Exception

class PEGASUS_COMMON_LINKAGE DynamicLoadFailed : public Exception

{

public:

static const char MSG[];

static const char KEY[];

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

DynamicLoadFailed(const String& libraryName);

StackUnderflow()

virtual ~DynamicLoadFailed();

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

};

class PEGASUS_COMMON_LINKAGE StackOverflow : public Exception

class PEGASUS_COMMON_LINKAGE DynamicLookupFailed : public Exception

{

public:

static const char MSG[];

static const char KEY[];

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

DynamicLookupFailed(const String& symbolName);

StackOverflow()

virtual ~DynamicLookupFailed();

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

};

class PEGASUS_COMMON_LINKAGE QueueUnderflow : public Exception

class PEGASUS_COMMON_LINKAGE CannotOpenDirectory : public Exception

{

public:

static const char MSG[];

static const char KEY[];

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

CannotOpenDirectory(const String& path);

QueueUnderflow()

virtual ~CannotOpenDirectory();

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

};

class PEGASUS_COMMON_LINKAGE BadFormat : public Exception

class PEGASUS_COMMON_LINKAGE ParseError : public Exception

{

public:

static const char MSG[];

static const char KEY[];

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

ParseError(const String& message);

BadFormat()

virtual ~ParseError();

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

};

class PEGASUS_COMMON_LINKAGE BadlyFormedCGIQueryString : public Exception

class PEGASUS_COMMON_LINKAGE MissingNullTerminator : public Exception

{

public:

static const char MSG[];

static const char KEY[];

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

MissingNullTerminator();

BadlyFormedCGIQueryString()

virtual ~MissingNullTerminator();

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

};

class PEGASUS_COMMON_LINKAGE DynamicLoadFailed : public Exception

class PEGASUS_COMMON_LINKAGE MalformedLanguageHeader: public Exception

{

public:

static const char MSG[];

static const char KEY[];

//DynamicLoadFailed(const String& libraryName)

MalformedLanguageHeader(const String& error);

//: Exception(MSG + libraryName) { }

virtual ~MalformedLanguageHeader();

DynamicLoadFailed(const String& libraryName)

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

};

class PEGASUS_COMMON_LINKAGE DynamicLookupFailed : public Exception

class PEGASUS_COMMON_LINKAGE InvalidAcceptLanguageHeader: public Exception

{

public:

static const char MSG[];

static const char KEY[];

//DynamicLookupFailed(const String& symbolName)

InvalidAcceptLanguageHeader(const String& error);

//: Exception(MSG + symbolName) { }

virtual ~InvalidAcceptLanguageHeader();

DynamicLookupFailed(const String& symbolName)

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

};

class PEGASUS_COMMON_LINKAGE CannotOpenDirectory : public Exception

class PEGASUS_COMMON_LINKAGE InvalidContentLanguageHeader: public Exception

{

public:

static const char MSG[];

static const char KEY[];

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

InvalidContentLanguageHeader(const String& error);

CannotOpenDirectory(const String& path)

virtual ~InvalidContentLanguageHeader();

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

};

class PEGASUS_COMMON_LINKAGE ParseError : public Exception

class PEGASUS_COMMON_LINKAGE InvalidAuthHeader: public Exception

{

public:

static const char MSG[];

static const char KEY[];

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

InvalidAuthHeader();

ParseError(const String& message)

virtual ~InvalidAuthHeader();

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

};

class PEGASUS_COMMON_LINKAGE MissingNullTerminator : public Exception

class PEGASUS_COMMON_LINKAGE UnauthorizedAccess: public Exception

{

public:

static const char MSG[];

static const char KEY[];

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

UnauthorizedAccess();

MissingNullTerminator()

virtual ~UnauthorizedAccess();

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

};

//l10n start

class PEGASUS_COMMON_LINKAGE IncompatibleTypesException : public Exception

class PEGASUS_COMMON_LINKAGE MalformedLanguageHeader: public Exception

{

public:

IncompatibleTypesException();

static const char MSG[];

virtual ~IncompatibleTypesException();

static const char KEY[];

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

MalformedLanguageHeader(const String& error)

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

};

class PEGASUS_COMMON_LINKAGE InternalSystemError : public Exception

class PEGASUS_COMMON_LINKAGE InvalidAcceptLanguageHeader: public Exception

{

public:

static const char MSG[];

static const char KEY[];

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

InternalSystemError();

InvalidAcceptLanguageHeader(const String& error)

virtual ~InternalSystemError();

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

};

class PEGASUS_COMMON_LINKAGE InvalidContentLanguageHeader: public Exception

class PEGASUS_COMMON_LINKAGE SocketWriteError : public Exception

{

public:

static const char MSG[];

static const char KEY[];

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

SocketWriteError(const String& error);

InvalidContentLanguageHeader(const String& error)

virtual ~SocketWriteError();

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

};

//l10n end

class PEGASUS_COMMON_LINKAGE TooManyHTTPHeadersException : public Exception

class PEGASUS_COMMON_LINKAGE InvalidAuthHeader: public Exception

{

public:

TooManyHTTPHeadersException();

static const char MSG[];

virtual ~TooManyHTTPHeadersException();

static const char KEY[];

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

InvalidAuthHeader()

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

};

class PEGASUS_COMMON_LINKAGE UnauthorizedAccess: public Exception

class PEGASUS_COMMON_LINKAGE TooManyElementsException : public Exception

{

public:

static const char MSG[];

static const char KEY[];

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

TooManyElementsException();

UnauthorizedAccess()

virtual ~TooManyElementsException();

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

};

// function used to throw TooManyElementsException for use in inlined functions

// to reduce static code size

PEGASUS_COMMON_LINKAGE extern void ThrowTooManyElementsException();

class PEGASUS_COMMON_LINKAGE IncompatibleTypesException : public Exception

// function used to throw IndexOutOfBoundsException for use in inlined functions

{

// to reduce static code size

public:

PEGASUS_COMMON_LINKAGE extern void ThrowIndexOutOfBoundsException();

IncompatibleTypesException();

};

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

Line 577

Line 487

TraceableCIMException(

CIMStatusCode code,

const String& message,

const char* file,

const String& file,

Uint32 line);

//l10n

TraceableCIMException(

CIMStatusCode code,

MessageLoaderParms parms,

const MessageLoaderParms& parms,

const char* file,

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 600

Line 508

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

//l10n

#define PEGASUS_CIM_EXCEPTION_L(CODE, MSG_PARMS) \

TraceableCIMException(CODE, MSG_PARMS, __FILE__, __LINE__)

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

PEGASUS_COMMON_LINKAGE extern void ThrowCannotOpenFileException(

const char* path);

inline void CheckRep(void * rep)

{

if (!rep)

ThrowUninitializedObjectException();

}

PEGASUS_NAMESPACE_END

Legend:

Removed from v.1.4.14.4
changed lines
	Added in v.1.34.2.1

No CVS admin address has been configured