(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.4 and 1.9

version 1.4, 2002/09/11 21:20:24 version 1.9, 2003/10/22 14:26:03
Line 1 
Line 1 
 //%/////////////////////////////////////////////////////////////////////////////  //%2003////////////////////////////////////////////////////////////////////////
 // //
 // Copyright (c) 2000, 2001, 2002 BMC Software, Hewlett-Packard Company, IBM,  // Copyright (c) 2000, 2001, 2002  BMC Software, Hewlett-Packard Development
 // The Open Group, Tivoli Systems  // Company, L. P., IBM Corp., The Open Group, Tivoli Systems.
   // Copyright (c) 2003 BMC Software; Hewlett-Packard Development Company, L. P.;
   // IBM Corp.; EMC 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 copy
 // of this software and associated documentation files (the "Software"), to // of this software and associated documentation files (the "Software"), to
Line 99 
Line 101 
 public: public:
  
     static const char MSG[];     static const char MSG[];
       static const char KEY[];
   
       //NullPointer() : Exception(MSG) { }
  
     NullPointer() : Exception(MSG) { }      NullPointer() : Exception(MessageLoaderParms(KEY, MSG)) { }
 }; };
  
 // ATTN: P3  KS documentation Required // ATTN: P3  KS documentation Required
Line 109 
Line 114 
 public: public:
  
     static const char MSG[];     static const char MSG[];
       static const char KEY[];
  
       //UndeclaredQualifier(const String& qualifierName)
           //: Exception(MSG + qualifierName) { }
   
   // NOTE - MSG needs to have a $0 arg for all the substitution cases
     UndeclaredQualifier(const String& qualifierName)     UndeclaredQualifier(const String& qualifierName)
         : Exception(MSG + qualifierName) { }          : Exception(MessageLoaderParms(KEY, MSG, qualifierName)) { }
 }; };
  
 // ATTN: P3  KS documentation Required // ATTN: P3  KS documentation Required
Line 120 
Line 130 
 public: public:
  
     static const char MSG[];     static const char MSG[];
       static const char KEY[];
   
       //BadQualifierScope(const String& qualifierName, const String& scopeString)
           //: Exception(MSG + qualifierName + String(" scope=") + scopeString) { }
   
  
     BadQualifierScope(const String& qualifierName, const String& scopeString)     BadQualifierScope(const String& qualifierName, const String& scopeString)
         : Exception(MSG + qualifierName + String(" scope=") + scopeString) { }                                                   : Exception(MessageLoaderParms(KEY,
                                                                                                                   MSG,
                                                                                                                   qualifierName,
                                                                                                                   scopeString)) { }
   
 }; };
  
 // ATTN: P3  KS documentation Required // ATTN: P3  KS documentation Required
Line 131 
Line 150 
 public: public:
  
     static const char MSG[];     static const char MSG[];
       static const char KEY[];
   
       //BadQualifierOverride(const String& qualifierName)
           //: Exception(MSG + qualifierName) { }
  
     BadQualifierOverride(const String& qualifierName)     BadQualifierOverride(const String& qualifierName)
         : Exception(MSG + qualifierName) { }      : Exception(MessageLoaderParms(KEY, MSG, qualifierName)) { }
 }; };
  
 class PEGASUS_COMMON_LINKAGE BadQualifierType : public Exception class PEGASUS_COMMON_LINKAGE BadQualifierType : public Exception
Line 141 
Line 164 
 public: public:
  
     static const char MSG[];     static const char MSG[];
       static const char KEY[];
   
       //BadQualifierType(const String& qualifierName)
           //: Exception(MSG + qualifierName) { }
  
     BadQualifierType(const String& qualifierName)     BadQualifierType(const String& qualifierName)
         : Exception(MSG + qualifierName) { }          : Exception(MessageLoaderParms(KEY, MSG, qualifierName)) { }
 }; };
  
 // ATTN: P3  KS documentation Required // ATTN: P3  KS documentation Required
Line 152 
Line 179 
 public: public:
  
     static const char MSG[];     static const char MSG[];
       static const char KEY[];
   
       //ClassAlreadyResolved(const String& className)
           //: Exception(MSG + className) { }
  
     ClassAlreadyResolved(const String& className)     ClassAlreadyResolved(const String& className)
         : Exception(MSG + className) { }          : Exception(MessageLoaderParms(KEY, MSG, className)) { }
 }; };
  
 // ATTN: P3  KS documentation Required // ATTN: P3  KS documentation Required
Line 163 
Line 194 
 public: public:
  
     static const char MSG[];     static const char MSG[];
       static const char KEY[];
   
       //ClassNotResolved(const String& className)
           //: Exception(MSG + className) { }
  
     ClassNotResolved(const String& className)     ClassNotResolved(const String& className)
         : Exception(MSG + className) { }          : Exception(MessageLoaderParms(KEY, MSG, className)) { }
 }; };
  
 // ATTN: P3  KS documentation Required // ATTN: P3  KS documentation Required
Line 174 
Line 209 
 public: public:
  
     static const char MSG[];     static const char MSG[];
       static const char KEY[];
   
       //InstanceAlreadyResolved()
       // : Exception(MSG) { }
  
     InstanceAlreadyResolved()     InstanceAlreadyResolved()
      : Exception(MSG) { }          : Exception(MessageLoaderParms(KEY, MSG)) { }
 }; };
  
 // ATTN: P3  KS documentation Required // ATTN: P3  KS documentation Required
Line 185 
Line 224 
 public: public:
  
     static const char MSG[];     static const char MSG[];
       static const char KEY[];
   
       //InstantiatedAbstractClass(const String& className)
        //: Exception(MSG + className) { }
  
     InstantiatedAbstractClass(const String& className)     InstantiatedAbstractClass(const String& className)
      : Exception(MSG + className) { }          : Exception(MessageLoaderParms(KEY, MSG, className)) { }
 }; };
  
 // ATTN: P3  KS documentation Required // ATTN: P3  KS documentation Required
Line 196 
Line 239 
 public: public:
  
     static const char MSG[];     static const char MSG[];
       static const char KEY[];
   
       //NoSuchProperty(const String& propertyName)
           //: Exception(MSG + propertyName) { }
  
     NoSuchProperty(const String& propertyName)     NoSuchProperty(const String& propertyName)
         : Exception(MSG + propertyName) { }          : Exception(MessageLoaderParms(KEY, MSG, propertyName)) { }
 }; };
  
 // ATTN: P3  KS documentation Required // ATTN: P3  KS documentation Required
Line 207 
Line 254 
 public: public:
  
     static const char MSG[];     static const char MSG[];
       static const char KEY[];
   
      // NoSuchFile(const String& fileName) : Exception(MSG + fileName) { }
  
     NoSuchFile(const String& fileName) : Exception(MSG + fileName) { }      NoSuchFile(const String& fileName)
           : Exception(MessageLoaderParms(KEY, MSG, fileName)) { }
 }; };
  
 // ATTN: P3  KS documentation Required // ATTN: P3  KS documentation Required
Line 217 
Line 268 
 public: public:
  
     static const char MSG[];     static const char MSG[];
       static const char KEY[];
  
     FileNotReadable(const String& fileName) : Exception(MSG + fileName) { }      //FileNotReadable(const String& fileName) : Exception(MSG + fileName) { }
   
       FileNotReadable(const String& fileName)
           : Exception(MessageLoaderParms(KEY, MSG, fileName)) { }
 }; };
  
 // ATTN: P3  KS documentation Required // ATTN: P3  KS documentation Required
Line 227 
Line 282 
 public: public:
  
     static const char MSG[];     static const char MSG[];
       static const char KEY[];
   
       //CannotRemoveDirectory(const String& path) : Exception(MSG + path) { }
  
     CannotRemoveDirectory(const String& path) : Exception(MSG + path) { }      CannotRemoveDirectory(const String& path)
           : Exception(MessageLoaderParms(KEY, MSG, path)) { }
 }; };
  
 // ATTN: P3  KS documentation Required // ATTN: P3  KS documentation Required
Line 237 
Line 296 
 public: public:
  
     static const char MSG[];     static const char MSG[];
       static const char KEY[];
  
     CannotRemoveFile(const String& path) : Exception(MSG + path) { }      //CannotRemoveFile(const String& path) : Exception(MSG + path) { }
       CannotRemoveFile(const String& path)
           : Exception(MessageLoaderParms(KEY, MSG, path)) { }
 }; };
  
 // ATTN: P3  KS documentation Required // ATTN: P3  KS documentation Required
Line 247 
Line 309 
 public: public:
  
     static const char MSG[];     static const char MSG[];
       static const char KEY[];
  
     CannotRenameFile(const String& path) : Exception(MSG + path) { }      //CannotRenameFile(const String& path) : Exception(MSG + path) { }
       CannotRenameFile(const String& path)
           : Exception(MessageLoaderParms(KEY, MSG, path)) { }
 }; };
  
 // ATTN: P3  KS documentation Required // ATTN: P3  KS documentation Required
Line 257 
Line 322 
 public: public:
  
     static const char MSG[];     static const char MSG[];
       static const char KEY[];
  
       //NoSuchDirectory(const String& directoryName)
           //: Exception(MSG + directoryName) { }
     NoSuchDirectory(const String& directoryName)     NoSuchDirectory(const String& directoryName)
         : Exception(MSG + directoryName) { }          : Exception(MessageLoaderParms(KEY, MSG, directoryName)) { }
 }; };
  
 // ATTN: P3  KS documentation Required // ATTN: P3  KS documentation Required
Line 268 
Line 336 
 public: public:
  
     static const char MSG[];     static const char MSG[];
       static const char KEY[];
  
       //CannotCreateDirectory(const String& path)
           //: Exception(MSG + path) { }
     CannotCreateDirectory(const String& path)     CannotCreateDirectory(const String& path)
         : Exception(MSG + path) { }          : Exception(MessageLoaderParms(KEY, MSG, path)) { }
 }; };
  
 // ATTN: P3  KS documentation Required // ATTN: P3  KS documentation Required
Line 279 
Line 350 
 public: public:
  
     static const char MSG[];     static const char MSG[];
       static const char KEY[];
  
       //CannotOpenFile(const String& path)
           //: Exception(MSG + path) { }
     CannotOpenFile(const String& path)     CannotOpenFile(const String& path)
         : Exception(MSG + path) { }          : Exception(MessageLoaderParms(KEY, MSG, path)) { }
 }; };
  
 // ATTN: P3  KS documentation Required // ATTN: P3  KS documentation Required
Line 290 
Line 364 
 public: public:
  
     static const char MSG[];     static const char MSG[];
       static const char KEY[];
  
     NotImplemented(const String& method) : Exception(MSG + method) { }     // NotImplemented(const String& method) : Exception(MSG + method) { }
       NotImplemented(const String& method)
           : Exception(MessageLoaderParms(KEY, MSG, method)) { }
 }; };
  
 class PEGASUS_COMMON_LINKAGE StackUnderflow : public Exception class PEGASUS_COMMON_LINKAGE StackUnderflow : public Exception
Line 299 
Line 376 
 public: public:
  
     static const char MSG[];     static const char MSG[];
       static const char KEY[];
  
     StackUnderflow() : Exception(MSG) { }      //StackUnderflow() : Exception(MSG) { }
       StackUnderflow()
           : Exception(MessageLoaderParms(KEY, MSG)) { }
 }; };
  
 class PEGASUS_COMMON_LINKAGE StackOverflow : public Exception class PEGASUS_COMMON_LINKAGE StackOverflow : public Exception
Line 308 
Line 388 
 public: public:
  
     static const char MSG[];     static const char MSG[];
       static const char KEY[];
  
     StackOverflow() : Exception(MSG) { }      //StackOverflow() : Exception(MSG) { }
       StackOverflow()
           : Exception(MessageLoaderParms(KEY, MSG)) { }
 }; };
  
 class PEGASUS_COMMON_LINKAGE QueueUnderflow : public Exception class PEGASUS_COMMON_LINKAGE QueueUnderflow : public Exception
Line 317 
Line 400 
 public: public:
  
     static const char MSG[];     static const char MSG[];
       static const char KEY[];
  
     QueueUnderflow() : Exception(MSG) { }      //QueueUnderflow() : Exception(MSG) { }
       QueueUnderflow()
           : Exception(MessageLoaderParms(KEY, MSG)) { }
 }; };
  
 class PEGASUS_COMMON_LINKAGE BadFormat : public Exception class PEGASUS_COMMON_LINKAGE BadFormat : public Exception
Line 326 
Line 412 
 public: public:
  
     static const char MSG[];     static const char MSG[];
       static const char KEY[];
  
     BadFormat() : Exception(MSG) { }      //BadFormat() : Exception(MSG) { }
       BadFormat()
           : Exception(MessageLoaderParms(KEY, MSG)) { }
 }; };
  
 class PEGASUS_COMMON_LINKAGE BadlyFormedCGIQueryString : public Exception class PEGASUS_COMMON_LINKAGE BadlyFormedCGIQueryString : public Exception
Line 335 
Line 424 
 public: public:
  
     static const char MSG[];     static const char MSG[];
       static const char KEY[];
  
     BadlyFormedCGIQueryString() : Exception(MSG) { }      //BadlyFormedCGIQueryString() : Exception(MSG) { }
       BadlyFormedCGIQueryString()
           : Exception(MessageLoaderParms(KEY, MSG)) { }
 }; };
  
 class PEGASUS_COMMON_LINKAGE DynamicLoadFailed : public Exception class PEGASUS_COMMON_LINKAGE DynamicLoadFailed : public Exception
Line 344 
Line 436 
 public: public:
  
     static const char MSG[];     static const char MSG[];
       static const char KEY[];
   
       //DynamicLoadFailed(const String& libraryName)
           //: Exception(MSG + libraryName) { }
  
     DynamicLoadFailed(const String& libraryName)     DynamicLoadFailed(const String& libraryName)
         : Exception(MSG + libraryName) { }          : Exception(MessageLoaderParms(KEY, MSG, libraryName)) { }
 }; };
  
 class PEGASUS_COMMON_LINKAGE DynamicLookupFailed : public Exception class PEGASUS_COMMON_LINKAGE DynamicLookupFailed : public Exception
Line 354 
Line 450 
 public: public:
  
     static const char MSG[];     static const char MSG[];
       static const char KEY[];
  
       //DynamicLookupFailed(const String& symbolName)
           //: Exception(MSG + symbolName) { }
     DynamicLookupFailed(const String& symbolName)     DynamicLookupFailed(const String& symbolName)
         : Exception(MSG + symbolName) { }          : Exception(MessageLoaderParms(KEY, MSG, symbolName)) { }
 }; };
  
 class PEGASUS_COMMON_LINKAGE CannotOpenDirectory : public Exception class PEGASUS_COMMON_LINKAGE CannotOpenDirectory : public Exception
Line 364 
Line 463 
 public: public:
  
     static const char MSG[];     static const char MSG[];
       static const char KEY[];
  
     CannotOpenDirectory(const String& path) : Exception(MSG + path) { }      //CannotOpenDirectory(const String& path) : Exception(MSG + path) { }
       CannotOpenDirectory(const String& path)
           : Exception(MessageLoaderParms(KEY, MSG, path)) { }
 }; };
  
 class PEGASUS_COMMON_LINKAGE ParseError : public Exception class PEGASUS_COMMON_LINKAGE ParseError : public Exception
Line 373 
Line 475 
 public: public:
  
     static const char MSG[];     static const char MSG[];
       static const char KEY[];
  
     ParseError(const String& message) : Exception(MSG + message) { }      //ParseError(const String& message) : Exception(MSG + message) { }
       ParseError(const String& message)
           : Exception(MessageLoaderParms(KEY, MSG, message)) { }
 }; };
  
 class PEGASUS_COMMON_LINKAGE MissingNullTerminator : public Exception class PEGASUS_COMMON_LINKAGE MissingNullTerminator : public Exception
Line 382 
Line 487 
 public: public:
  
     static const char MSG[];     static const char MSG[];
       static const char KEY[];
  
     MissingNullTerminator() : Exception(MSG) { }      //MissingNullTerminator() : Exception(MSG) { }
       MissingNullTerminator()
           : Exception(MessageLoaderParms(KEY, MSG)) { }
 }; };
  
   //l10n start
   
   class PEGASUS_COMMON_LINKAGE MalformedLanguageHeader: public Exception
   {
   public:
   
       static const char MSG[];
       static const char KEY[];
   
       //MalformedLanguageHeader(const String& error) : Exception(MSG + error) { }
       MalformedLanguageHeader(const String& error)
           : Exception(MessageLoaderParms(KEY, MSG, error)) { }
   };
   
   
   class PEGASUS_COMMON_LINKAGE InvalidAcceptLanguageHeader: public Exception
   {
   public:
   
       static const char MSG[];
       static const char KEY[];
   
       //InvalidAcceptLanguageHeader(const String& error) : Exception(MSG + error) { }
       InvalidAcceptLanguageHeader(const String& error)
           : Exception(MessageLoaderParms(KEY, MSG, error)) { }
   };
   
   class PEGASUS_COMMON_LINKAGE InvalidContentLanguageHeader: public Exception
   {
   public:
   
       static const char MSG[];
       static const char KEY[];
   
       //InvalidContentLanguageHeader(const String& error) : Exception(MSG + error) { }
       InvalidContentLanguageHeader(const String& error)
           : Exception(MessageLoaderParms(KEY, MSG, error)) { }
   };
   
   //l10n end
   
 class PEGASUS_COMMON_LINKAGE InvalidAuthHeader: public Exception class PEGASUS_COMMON_LINKAGE InvalidAuthHeader: public Exception
 { {
 public: public:
  
     static const char MSG[];     static const char MSG[];
       static const char KEY[];
  
     InvalidAuthHeader() : Exception(MSG) { }      //InvalidAuthHeader() : Exception(MSG) { }
       InvalidAuthHeader()
           : Exception(MessageLoaderParms(KEY, MSG)) { }
 }; };
  
 class PEGASUS_COMMON_LINKAGE UnauthorizedAccess: public Exception class PEGASUS_COMMON_LINKAGE UnauthorizedAccess: public Exception
Line 400 
Line 552 
 public: public:
  
     static const char MSG[];     static const char MSG[];
       static const char KEY[];
  
     UnauthorizedAccess() : Exception(MSG) { }      //UnauthorizedAccess() : Exception(MSG) { }
       UnauthorizedAccess()
           : Exception(MessageLoaderParms(KEY, MSG)) { }
 }; };
  
 class PEGASUS_COMMON_LINKAGE IncompatibleTypesException : public Exception class PEGASUS_COMMON_LINKAGE IncompatibleTypesException : public Exception
Line 425 
Line 580 
         const char* file,         const char* file,
         Uint32 line);         Uint32 line);
  
           //l10n
           TraceableCIMException(
           CIMStatusCode code,
           MessageLoaderParms parms,
           const char* file,
           Uint32 line);
   
   // l10n
           TraceableCIMException(
           const ContentLanguages& langs,
       CIMStatusCode code,
       const String& message,
       const char* file,
       Uint32 line);
   
     TraceableCIMException(const CIMException & cimException);     TraceableCIMException(const CIMException & cimException);
  
     String getDescription() const;     String getDescription() const;
Line 435 
Line 605 
 #define PEGASUS_CIM_EXCEPTION(CODE, EXTRA_MESSAGE) \ #define PEGASUS_CIM_EXCEPTION(CODE, EXTRA_MESSAGE) \
     TraceableCIMException(CODE, EXTRA_MESSAGE, __FILE__, __LINE__)     TraceableCIMException(CODE, EXTRA_MESSAGE, __FILE__, __LINE__)
  
   // l10n
   #define PEGASUS_CIM_EXCEPTION_LANG(LANGS, CODE, EXTRA_MESSAGE) \
       TraceableCIMException(LANGS, CODE, EXTRA_MESSAGE, __FILE__, __LINE__)
   
   //l10n
   #define PEGASUS_CIM_EXCEPTION_L(CODE, MSG_PARMS) \
       TraceableCIMException(CODE, MSG_PARMS, __FILE__, __LINE__)
   
 PEGASUS_NAMESPACE_END PEGASUS_NAMESPACE_END
  
 #endif /* Pegasus_InternalException_h */ #endif /* Pegasus_InternalException_h */

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