(file) Return to InternalException.h CVS log (file) (dir) Up to [Pegasus] / pegasus / src / Pegasus / Common

Diff for /pegasus/src/Pegasus/Common/InternalException.h between version 1.18 and 1.27

version 1.18, 2006/05/10 19:40:38 version 1.27, 2008/06/10 17:59:15
Line 29 
Line 29 
 // //
 //============================================================================== //==============================================================================
 // //
 // Author: Roger Kumpf, Hewlett-Packard Company (roger_kumpf@hp.com)  
 //  
 // Modified By:  
 //  
 //%///////////////////////////////////////////////////////////////////////////// //%/////////////////////////////////////////////////////////////////////////////
  
 #ifndef Pegasus_InternalException_h #ifndef Pegasus_InternalException_h
Line 43 
Line 39 
 #include <Pegasus/Common/Exception.h> #include <Pegasus/Common/Exception.h>
 #include <Pegasus/Common/PegasusAssert.h> #include <Pegasus/Common/PegasusAssert.h>
  
   
   
 PEGASUS_NAMESPACE_BEGIN PEGASUS_NAMESPACE_BEGIN
  
 /** Class AssertionFailureException /** Class AssertionFailureException
Line 60 
Line 54 
         const char* file,         const char* file,
         size_t line,         size_t line,
         const String& message);         const String& message);
   
       virtual ~AssertionFailureException();
 }; };
  
  
Line 91 
Line 87 
     static const char MSG[];     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 // ATTN: P3  KS documentation Required
Line 104 
Line 100 
     static const char MSG[];     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 // ATTN: P3  KS documentation Required
Line 120 
Line 113 
     static const char MSG[];     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);
   
         BadQualifierScope(const String& qualifierName, const String& scopeString)  
                                                  : Exception(MessageLoaderParms(KEY,  
                                                                                                                 MSG,  
                                                                                                                 qualifierName,  
                                                                                                                 scopeString)) { }  
  
       virtual ~BadQualifierScope();
 }; };
  
 // ATTN: P3  KS documentation Required // ATTN: P3  KS documentation Required
Line 140 
Line 128 
     static const char MSG[];     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 class PEGASUS_COMMON_LINKAGE BadQualifierType : public Exception
Line 154 
Line 140 
     static const char MSG[];     static const char MSG[];
     static const char KEY[];     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 // ATTN: P3  KS documentation Required
Line 214 
Line 152 
     static const char MSG[];     static const char MSG[];
     static const char KEY[];     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 // ATTN: P3  KS documentation Required
Line 229 
Line 164 
     static const char MSG[];     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 // ATTN: P3  KS documentation Required
Line 244 
Line 176 
     static const char MSG[];     static const char MSG[];
     static const char KEY[];     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 // ATTN: P3  KS documentation Required
Line 258 
Line 188 
     static const char MSG[];     static const char MSG[];
     static const char KEY[];     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 // ATTN: P3  KS documentation Required
Line 272 
Line 200 
     static const char MSG[];     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 // ATTN: P3  KS documentation Required
Line 286 
Line 212 
     static const char MSG[];     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 // ATTN: P3  KS documentation Required
Line 299 
Line 224 
     static const char MSG[];     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 // ATTN: P3  KS documentation Required
Line 312 
Line 236 
     static const char MSG[];     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 // ATTN: P3  KS documentation Required
Line 326 
Line 248 
     static const char MSG[];     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 // ATTN: P3  KS documentation Required
Line 340 
Line 260 
     static const char MSG[];     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 // ATTN: P3  KS documentation Required
Line 354 
Line 272 
     static const char MSG[];     static const char MSG[];
     static const char KEY[];     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 class PEGASUS_COMMON_LINKAGE StackUnderflow : public Exception
Line 366 
Line 283 
     static const char MSG[];     static const char MSG[];
     static const char KEY[];     static const char KEY[];
  
     //StackUnderflow() : Exception(MSG) { }      StackUnderflow();
     StackUnderflow()      virtual ~StackUnderflow();
         : Exception(MessageLoaderParms(KEY, MSG)) { }  
 }; };
  
 class PEGASUS_COMMON_LINKAGE StackOverflow : public Exception class PEGASUS_COMMON_LINKAGE StackOverflow : public Exception
Line 378 
Line 294 
     static const char MSG[];     static const char MSG[];
     static const char KEY[];     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 class PEGASUS_COMMON_LINKAGE DynamicLoadFailed : public Exception
Line 426 
Line 305 
     static const char MSG[];     static const char MSG[];
     static const char KEY[];     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 class PEGASUS_COMMON_LINKAGE DynamicLookupFailed : public Exception
Line 440 
Line 316 
     static const char MSG[];     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 class PEGASUS_COMMON_LINKAGE CannotOpenDirectory : public Exception
Line 453 
Line 327 
     static const char MSG[];     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 class PEGASUS_COMMON_LINKAGE ParseError : public Exception
Line 465 
Line 338 
     static const char MSG[];     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 class PEGASUS_COMMON_LINKAGE MissingNullTerminator : public Exception
Line 477 
Line 349 
     static const char MSG[];     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 class PEGASUS_COMMON_LINKAGE MalformedLanguageHeader: public Exception
 { {
 public: public:
Line 491 
Line 360 
     static const char MSG[];     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 class PEGASUS_COMMON_LINKAGE InvalidAcceptLanguageHeader: public Exception
 { {
 public: public:
Line 504 
Line 371 
     static const char MSG[];     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 class PEGASUS_COMMON_LINKAGE InvalidContentLanguageHeader: public Exception
Line 516 
Line 382 
     static const char MSG[];     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 class PEGASUS_COMMON_LINKAGE InvalidAuthHeader: public Exception
 { {
 public: public:
Line 530 
Line 393 
     static const char MSG[];     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 class PEGASUS_COMMON_LINKAGE UnauthorizedAccess: public Exception
Line 542 
Line 404 
     static const char MSG[];     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 class PEGASUS_COMMON_LINKAGE IncompatibleTypesException : public Exception
 { {
 public: public:
     IncompatibleTypesException();     IncompatibleTypesException();
       virtual ~IncompatibleTypesException();
 }; };
  
 class PEGASUS_COMMON_LINKAGE InternalSystemError : public Exception class PEGASUS_COMMON_LINKAGE InternalSystemError : public Exception
Line 559 
Line 421 
  
     static const char MSG[];     static const char MSG[];
  
     InternalSystemError()      InternalSystemError();
         : Exception(MSG) { }      virtual ~InternalSystemError();
 }; };
  
  
Line 578 
Line 440 
         const String& file,         const String& file,
         Uint32 line);         Uint32 line);
  
         //l10n  
         TraceableCIMException(         TraceableCIMException(
         CIMStatusCode code,         CIMStatusCode code,
         MessageLoaderParms parms,          const MessageLoaderParms& parms,
         const String& file,         const String& file,
         Uint32 line);         Uint32 line);
  
 // l10n  
         TraceableCIMException(         TraceableCIMException(
         const ContentLanguageList& langs,         const ContentLanguageList& langs,
     CIMStatusCode code,     CIMStatusCode code,
Line 610 
Line 470 
 #define PEGASUS_CIM_EXCEPTION(CODE, EXTRA_MESSAGE) \ #define PEGASUS_CIM_EXCEPTION(CODE, EXTRA_MESSAGE) \
     TraceableCIMException(CODE, EXTRA_MESSAGE, String(__FILE__), __LINE__)     TraceableCIMException(CODE, EXTRA_MESSAGE, String(__FILE__), __LINE__)
  
 // l10n  
 #define PEGASUS_CIM_EXCEPTION_LANG(LANGS, CODE, EXTRA_MESSAGE) \ #define PEGASUS_CIM_EXCEPTION_LANG(LANGS, CODE, EXTRA_MESSAGE) \
     TraceableCIMException( \     TraceableCIMException( \
         LANGS, CODE, EXTRA_MESSAGE, String(__FILE__), __LINE__)         LANGS, CODE, EXTRA_MESSAGE, String(__FILE__), __LINE__)
  
 //l10n  
 #define PEGASUS_CIM_EXCEPTION_L(CODE, MSG_PARMS) \ #define PEGASUS_CIM_EXCEPTION_L(CODE, MSG_PARMS) \
     TraceableCIMException(CODE, MSG_PARMS, String(__FILE__), __LINE__)     TraceableCIMException(CODE, MSG_PARMS, String(__FILE__), __LINE__)
  
Line 631 
Line 489 
     } \     } \
     while (0)     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 PEGASUS_NAMESPACE_END
  
 #endif /* Pegasus_InternalException_h */ #endif /* Pegasus_InternalException_h */

Legend:
Removed from v.1.18  
changed lines
  Added in v.1.27
No CVS admin address has been configured
 Powered by
ViewCVS 0.9.2