(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.5 and 1.21

version 1.5, 2003/07/15 16:53:03 version 1.21, 2006/11/08 22:24:00
Line 1 
Line 1 
 //%/////////////////////////////////////////////////////////////////////////////  //%2006////////////////////////////////////////////////////////////////////////
 // //
 // 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.
   // Copyright (c) 2004 BMC Software; Hewlett-Packard Development Company, L.P.;
   // IBM Corp.; EMC Corporation; VERITAS Software Corporation; The Open Group.
   // Copyright (c) 2005 Hewlett-Packard Development Company, L.P.; IBM Corp.;
   // EMC Corporation; VERITAS Software Corporation; The Open Group.
   // Copyright (c) 2006 Hewlett-Packard Development Company, L.P.; IBM Corp.;
   // 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 copy
 // of this software and associated documentation files (the "Software"), to // of this software and associated documentation files (the "Software"), to
Line 21 
Line 29 
 // //
 //============================================================================== //==============================================================================
 // //
 // Author: Roger Kumpf, Hewlett-Packard Company (roger_kumpf@hp.com)  
 //  
 // Modified By:  
 //  
 //%///////////////////////////////////////////////////////////////////////////// //%/////////////////////////////////////////////////////////////////////////////
  
 #ifndef Pegasus_InternalException_h #ifndef Pegasus_InternalException_h
Line 33 
Line 37 
 #include <Pegasus/Common/Config.h> #include <Pegasus/Common/Config.h>
 #include <Pegasus/Common/Linkage.h> #include <Pegasus/Common/Linkage.h>
 #include <Pegasus/Common/Exception.h> #include <Pegasus/Common/Exception.h>
   #include <Pegasus/Common/PegasusAssert.h>
  
 PEGASUS_NAMESPACE_BEGIN PEGASUS_NAMESPACE_BEGIN
  
Line 49 
Line 54 
         const char* file,         const char* file,
         size_t line,         size_t line,
         const String& message);         const String& message);
 };  
  
 /** define PEGASUS_ASSERT assertion statement.  This statement tests the      virtual ~AssertionFailureException();
     condition defined by the parameters and if not True executes an  };
   
     <pre>  
     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 /* Macro to Create the equivalent of an assert but without the
    termination.  This can be used as a temporary marker for asserts    termination.  This can be used as a temporary marker for asserts
Line 93 
Line 79 
     } while (0)     } while (0)
  
  
 // l10n TODO - finish the commented out constructors  
   
 // ATTN: P3  KS documentation Required // ATTN: P3  KS documentation Required
 class PEGASUS_COMMON_LINKAGE NullPointer : public Exception class PEGASUS_COMMON_LINKAGE NullPointer : public Exception
 { {
 public: public:
  
     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 114 
Line 98 
 public: public:
  
     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 130 
Line 111 
 public: public:
  
     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);
  
 /*      virtual ~BadQualifierScope();
         BadQualifierScope(const String& qualifierName, const String& scopeString)  
                                                  : Exception(MessageLoaderParms(KEY,  
                                                                                                                 MSG,  
                                                                                                                 qualifierName,  
                                                                                                                 scopeString)) { }  
 */  
 }; };
  
 // ATTN: P3  KS documentation Required // ATTN: P3  KS documentation Required
Line 150 
Line 126 
 public: public:
  
     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 164 
Line 138 
 public: public:
  
     static const char MSG[];     static const char MSG[];
 //  static const char KEY[];      static const char KEY[];
   
     BadQualifierType(const String& qualifierName)  
         : Exception(MSG + qualifierName) { }  
  
 //  BadQualifierType(const String& qualifierName)      BadQualifierType(const String& qualifierName);
 //      : Exception(MessageLoaderParms(KEY, MSG, qualifierName)) { }      virtual ~BadQualifierType();
 }; };
  
 // ATTN: P3  KS documentation Required // ATTN: P3  KS documentation Required
Line 179 
Line 150 
 public: public:
  
     static const char MSG[];     static const char MSG[];
 //  static const char KEY[];      static const char KEY[];
  
     ClassAlreadyResolved(const String& className)      ClassAlreadyResolved(const String& className);
         : Exception(MSG + className) { }  
  
 //  ClassAlreadyResolved(const String& className)      virtual ~ClassAlreadyResolved();
 //      : Exception(MessageLoaderParms(KEY, MSG, className)) { }  
 }; };
  
 // ATTN: P3  KS documentation Required // ATTN: P3  KS documentation Required
Line 194 
Line 163 
 public: public:
  
     static const char MSG[];     static const char MSG[];
 //  static const char KEY[];      static const char KEY[];
  
     ClassNotResolved(const String& className)      ClassNotResolved(const String& className);
         : Exception(MSG + className) { }      virtual ~ClassNotResolved();
   
 //  ClassNotResolved(const String& className)  
 //      : Exception(MessageLoaderParms(KEY, MSG, className)) { }  
 }; };
  
 // ATTN: P3  KS documentation Required // ATTN: P3  KS documentation Required
Line 209 
Line 175 
 public: public:
  
     static const char MSG[];     static const char MSG[];
 //  static const char KEY[];      static const char KEY[];
   
     InstanceAlreadyResolved()  
      : Exception(MSG) { }  
  
 //  InstanceAlreadyResolved()      InstanceAlreadyResolved();
 //      : Exception(MessageLoaderParms(KEY, MSG)) { }      virtual ~InstanceAlreadyResolved();
 }; };
  
 // ATTN: P3  KS documentation Required // ATTN: P3  KS documentation Required
Line 224 
Line 187 
 public: public:
  
     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 239 
Line 199 
 public: public:
  
     static const char MSG[];     static const char MSG[];
 //  static const char KEY[];      static const char KEY[];
   
     NoSuchProperty(const String& propertyName)  
         : Exception(MSG + propertyName) { }  
  
 //  NoSuchProperty(const String& propertyName)      NoSuchProperty(const String& propertyName);
 //      : Exception(MessageLoaderParms(KEY, MSG, propertyName)) { }      virtual ~NoSuchProperty();
 }; };
  
 // ATTN: P3  KS documentation Required // ATTN: P3  KS documentation Required
Line 254 
Line 211 
 public: public:
  
     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)      NoSuchFile(const String& fileName);
 //      : Exception(MessageLoaderParms(KEY, MSG, fileName)) { }      virtual ~NoSuchFile();
 }; };
  
 // ATTN: P3  KS documentation Required // ATTN: P3  KS documentation Required
Line 268 
Line 223 
 public: public:
  
     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 282 
Line 235 
 public: public:
  
     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)      CannotRemoveDirectory(const String& path);
 //      : Exception(MessageLoaderParms(KEY, MSG, path)) { }      virtual ~CannotRemoveDirectory();
 }; };
  
 // ATTN: P3  KS documentation Required // ATTN: P3  KS documentation Required
Line 296 
Line 247 
 public: public:
  
     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 309 
Line 259 
 public: public:
  
     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 322 
Line 271 
 public: public:
  
     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 336 
Line 283 
 public: public:
  
     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 350 
Line 295 
 public: public:
  
     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 364 
Line 307 
 public: public:
  
     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 376 
Line 318 
 public: public:
  
     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 388 
Line 329 
 public: public:
  
     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 class PEGASUS_COMMON_LINKAGE BadFormat : public Exception
Line 412 
Line 340 
 public: public:
  
     static const char MSG[];     static const char MSG[];
 //  static const char KEY[];      static const char KEY[];
  
     BadFormat() : Exception(MSG) { }      BadFormat();
 //  BadFormat()      virtual ~BadFormat();
 //      : Exception(MessageLoaderParms(KEY, MSG)) { }  
 }; };
  
 class PEGASUS_COMMON_LINKAGE BadlyFormedCGIQueryString : public Exception class PEGASUS_COMMON_LINKAGE BadlyFormedCGIQueryString : public Exception
Line 424 
Line 351 
 public: public:
  
     static const char MSG[];     static const char MSG[];
 //  static const char KEY[];      static const char KEY[];
  
     BadlyFormedCGIQueryString() : Exception(MSG) { }      BadlyFormedCGIQueryString();
 //  BadlyFormedCGIQueryString()      virtual ~BadlyFormedCGIQueryString();
 //      : Exception(MessageLoaderParms(KEY, MSG)) { }  
 }; };
  
 class PEGASUS_COMMON_LINKAGE DynamicLoadFailed : public Exception class PEGASUS_COMMON_LINKAGE DynamicLoadFailed : public Exception
Line 436 
Line 362 
 public: public:
  
     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 450 
Line 373 
 public: public:
  
     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 463 
Line 384 
 public: public:
  
     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 475 
Line 395 
 public: public:
  
     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 487 
Line 406 
 public: public:
  
     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 //l10n start
Line 501 
Line 419 
 public: public:
  
     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:
  
     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 526 
Line 441 
 public: public:
  
     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 //l10n end
Line 540 
Line 454 
 public: public:
  
     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 552 
Line 465 
 public: public:
  
     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
   {
   public:
   
       static const char MSG[];
   
       InternalSystemError();
       virtual ~InternalSystemError();
 }; };
  
  
Line 577 
Line 500 
     TraceableCIMException(     TraceableCIMException(
         CIMStatusCode code,         CIMStatusCode code,
         const String& message,         const String& message,
         const char* file,          const String& file,
         Uint32 line);         Uint32 line);
  
 // l10n  
         TraceableCIMException(         TraceableCIMException(
         const ContentLanguages& langs,          CIMStatusCode code,
           MessageLoaderParms parms,
           const String& file,
           Uint32 line);
   
       TraceableCIMException(
           const ContentLanguageList& langs,
     CIMStatusCode code,     CIMStatusCode code,
     const String& message,     const String& message,
     const char* file,          const String& file,
     Uint32 line);     Uint32 line);
  
     TraceableCIMException(const CIMException & cimException);     TraceableCIMException(const CIMException & cimException);
Line 593 
Line 521 
     String getDescription() const;     String getDescription() const;
  
     String getTraceDescription() 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) \ #define PEGASUS_CIM_EXCEPTION(CODE, EXTRA_MESSAGE) \
     TraceableCIMException(CODE, EXTRA_MESSAGE, __FILE__, __LINE__)      TraceableCIMException(CODE, EXTRA_MESSAGE, String(__FILE__), __LINE__)
  
 // l10n // l10n
 #define PEGASUS_CIM_EXCEPTION_LANG(LANGS, CODE, EXTRA_MESSAGE) \ #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, 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)
  
 PEGASUS_NAMESPACE_END PEGASUS_NAMESPACE_END
  

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