(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.32

version 1.4, 2002/09/11 21:20:24 version 1.32, 2009/01/22 09:02:15
Line 1 
Line 1 
 //%/////////////////////////////////////////////////////////////////////////////  //%LICENSE////////////////////////////////////////////////////////////////
 //  
 // Copyright (c) 2000, 2001, 2002 BMC Software, Hewlett-Packard Company, IBM,  
 // 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/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 52 
         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 99 
Line 83 
 public: public:
  
     static const char MSG[];     static const char MSG[];
       static const char KEY[];
   
       NullPointer();
  
     NullPointer() : Exception(MSG) { }      virtual ~NullPointer();
 }; };
  
 // ATTN: P3  KS documentation Required // ATTN: P3  KS documentation Required
Line 109 
Line 96 
 public: public:
  
     static const char MSG[];     static const char MSG[];
       static const char KEY[];
  
     UndeclaredQualifier(const String& qualifierName)      UndeclaredQualifier(const String& qualifierName) ;
         : Exception(MSG + qualifierName) { }  
 };  
  
 // ATTN: P3  KS documentation Required      virtual ~UndeclaredQualifier();
 class PEGASUS_COMMON_LINKAGE BadQualifierScope : public Exception  
 {  
 public:  
   
     static const char MSG[];  
   
     BadQualifierScope(const String& qualifierName, const String& scopeString)  
         : Exception(MSG + qualifierName + String(" scope=") + scopeString) { }  
 }; };
  
 // ATTN: P3  KS documentation Required // ATTN: P3  KS documentation Required
 class PEGASUS_COMMON_LINKAGE BadQualifierOverride : public Exception  class PEGASUS_COMMON_LINKAGE BadQualifierScope : public Exception
 { {
 public: public:
  
     static const char MSG[];     static const char MSG[];
       static const char KEY[];
  
     BadQualifierOverride(const String& qualifierName)      BadQualifierScope(
         : Exception(MSG + qualifierName) { }          const String& qualifierName,
 };          const String& scopeString);
   
 class PEGASUS_COMMON_LINKAGE BadQualifierType : public Exception  
 {  
 public:  
  
     static const char MSG[];      virtual ~BadQualifierScope();
   
     BadQualifierType(const String& qualifierName)  
         : Exception(MSG + qualifierName) { }  
 }; };
  
 // ATTN: P3  KS documentation Required // ATTN: P3  KS documentation Required
 class PEGASUS_COMMON_LINKAGE ClassAlreadyResolved : public Exception  class PEGASUS_COMMON_LINKAGE BadQualifierOverride : public Exception
 { {
 public: public:
  
     static const char MSG[];     static const char MSG[];
       static const char KEY[];
  
     ClassAlreadyResolved(const String& className)      BadQualifierOverride(const String& qualifierName);
         : Exception(MSG + className) { }  
 };  
  
 // ATTN: P3  KS documentation Required      virtual ~BadQualifierOverride();
 class PEGASUS_COMMON_LINKAGE ClassNotResolved : public Exception  
 {  
 public:  
   
     static const char MSG[];  
   
     ClassNotResolved(const String& className)  
         : Exception(MSG + className) { }  
 }; };
  
 // ATTN: P3  KS documentation Required  class PEGASUS_COMMON_LINKAGE BadQualifierType : public Exception
 class PEGASUS_COMMON_LINKAGE InstanceAlreadyResolved : public Exception  
 { {
 public: public:
  
     static const char MSG[];     static const char MSG[];
       static const char KEY[];
  
     InstanceAlreadyResolved()      BadQualifierType(const String& qualifierName);
      : Exception(MSG) { }      virtual ~BadQualifierType();
 }; };
  
 // ATTN: P3  KS documentation Required // ATTN: P3  KS documentation Required
Line 185 
Line 148 
 public: public:
  
     static const char MSG[];     static const char MSG[];
       static const char KEY[];
  
     InstantiatedAbstractClass(const String& className)      InstantiatedAbstractClass(const String& className);
      : Exception(MSG + className) { }      virtual ~InstantiatedAbstractClass();
 }; };
  
 // ATTN: P3  KS documentation Required // ATTN: P3  KS documentation Required
Line 196 
Line 160 
 public: public:
  
     static const char MSG[];     static const char MSG[];
       static const char KEY[];
  
     NoSuchProperty(const String& propertyName)      NoSuchProperty(const String& propertyName);
         : Exception(MSG + propertyName) { }      virtual ~NoSuchProperty();
 }; };
  
 // ATTN: P3  KS documentation Required // ATTN: P3  KS documentation Required
Line 207 
Line 172 
 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);
       virtual ~NoSuchFile();
 }; };
  
 // ATTN: P3  KS documentation Required // ATTN: P3  KS documentation Required
Line 217 
Line 184 
 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);
       virtual ~FileNotReadable();
 }; };
  
 // ATTN: P3  KS documentation Required // ATTN: P3  KS documentation Required
Line 227 
Line 196 
 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);
       virtual ~CannotRemoveDirectory();
 }; };
  
 // ATTN: P3  KS documentation Required // ATTN: P3  KS documentation Required
Line 237 
Line 208 
 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);
       virtual ~CannotRemoveFile();
 }; };
  
 // ATTN: P3  KS documentation Required // ATTN: P3  KS documentation Required
Line 247 
Line 220 
 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);
       virtual ~CannotRenameFile();
 }; };
  
 // ATTN: P3  KS documentation Required // ATTN: P3  KS documentation Required
Line 257 
Line 232 
 public: public:
  
     static const char MSG[];     static const char MSG[];
       static const char KEY[];
  
     NoSuchDirectory(const String& directoryName)      NoSuchDirectory(const String& directoryName);
         : Exception(MSG + directoryName) { }      virtual ~NoSuchDirectory();
 }; };
  
 // ATTN: P3  KS documentation Required // ATTN: P3  KS documentation Required
Line 268 
Line 244 
 public: public:
  
     static const char MSG[];     static const char MSG[];
       static const char KEY[];
  
     CannotCreateDirectory(const String& path)      CannotCreateDirectory(const String& path);
         : Exception(MSG + path) { }      virtual ~CannotCreateDirectory();
 }; };
  
 // ATTN: P3  KS documentation Required // ATTN: P3  KS documentation Required
Line 279 
Line 256 
 public: public:
  
     static const char MSG[];     static const char MSG[];
       static const char KEY[];
   
       CannotOpenFile(const String& path);
       virtual ~CannotOpenFile();
   };
   
   // ATTN: P3  KS documentation Required
   class PEGASUS_COMMON_LINKAGE CannotChangeFilePerm : public Exception
   {
   public:
   
       static const char MSG[];
       static const char KEY[];
  
     CannotOpenFile(const String& path)      CannotChangeFilePerm(const String& path);
         : Exception(MSG + path) { }      virtual ~CannotChangeFilePerm();
 }; };
  
 // ATTN: P3  KS documentation Required // ATTN: P3  KS documentation Required
Line 290 
Line 280 
 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);
       virtual ~NotImplemented();
 }; };
  
 class PEGASUS_COMMON_LINKAGE StackUnderflow : public Exception class PEGASUS_COMMON_LINKAGE StackUnderflow : public Exception
Line 299 
Line 291 
 public: public:
  
     static const char MSG[];     static const char MSG[];
       static const char KEY[];
  
     StackUnderflow() : Exception(MSG) { }      StackUnderflow();
       virtual ~StackUnderflow();
 }; };
  
 class PEGASUS_COMMON_LINKAGE StackOverflow : public Exception class PEGASUS_COMMON_LINKAGE StackOverflow : public Exception
Line 308 
Line 302 
 public: public:
  
     static const char MSG[];     static const char MSG[];
       static const char KEY[];
  
     StackOverflow() : Exception(MSG) { }      StackOverflow();
       virtual ~StackOverflow();
 }; };
  
 class PEGASUS_COMMON_LINKAGE QueueUnderflow : public Exception  class PEGASUS_COMMON_LINKAGE DynamicLoadFailed : public Exception
 { {
 public: public:
  
     static const char MSG[];     static const char MSG[];
       static const char KEY[];
  
     QueueUnderflow() : Exception(MSG) { }      DynamicLoadFailed(const String& libraryName);
       virtual ~DynamicLoadFailed();
 }; };
  
 class PEGASUS_COMMON_LINKAGE BadFormat : public Exception  class PEGASUS_COMMON_LINKAGE DynamicLookupFailed : public Exception
 { {
 public: public:
  
     static const char MSG[];     static const char MSG[];
       static const char KEY[];
  
     BadFormat() : Exception(MSG) { }      DynamicLookupFailed(const String& symbolName);
       virtual ~DynamicLookupFailed();
 }; };
  
 class PEGASUS_COMMON_LINKAGE BadlyFormedCGIQueryString : public Exception  class PEGASUS_COMMON_LINKAGE CannotOpenDirectory : public Exception
 { {
 public: public:
  
     static const char MSG[];     static const char MSG[];
       static const char KEY[];
  
     BadlyFormedCGIQueryString() : Exception(MSG) { }      CannotOpenDirectory(const String& path);
       virtual ~CannotOpenDirectory();
 }; };
  
 class PEGASUS_COMMON_LINKAGE DynamicLoadFailed : public Exception  class PEGASUS_COMMON_LINKAGE ParseError : public Exception
 { {
 public: public:
  
     static const char MSG[];     static const char MSG[];
       static const char KEY[];
  
     DynamicLoadFailed(const String& libraryName)      ParseError(const String& message);
         : Exception(MSG + libraryName) { }      virtual ~ParseError();
 }; };
  
 class PEGASUS_COMMON_LINKAGE DynamicLookupFailed : public Exception  class PEGASUS_COMMON_LINKAGE MissingNullTerminator : public Exception
 { {
 public: public:
  
     static const char MSG[];     static const char MSG[];
       static const char KEY[];
  
     DynamicLookupFailed(const String& symbolName)      MissingNullTerminator();
         : Exception(MSG + symbolName) { }      virtual ~MissingNullTerminator();
 }; };
  
 class PEGASUS_COMMON_LINKAGE CannotOpenDirectory : public Exception  class PEGASUS_COMMON_LINKAGE MalformedLanguageHeader: public Exception
 { {
 public: public:
  
     static const char MSG[];     static const char MSG[];
       static const char KEY[];
  
     CannotOpenDirectory(const String& path) : Exception(MSG + path) { }      MalformedLanguageHeader(const String& error);
       virtual ~MalformedLanguageHeader();
 }; };
  
 class PEGASUS_COMMON_LINKAGE ParseError : public Exception  class PEGASUS_COMMON_LINKAGE InvalidAcceptLanguageHeader: public Exception
 { {
 public: public:
  
     static const char MSG[];     static const char MSG[];
       static const char KEY[];
  
     ParseError(const String& message) : Exception(MSG + message) { }      InvalidAcceptLanguageHeader(const String& error);
       virtual ~InvalidAcceptLanguageHeader();
 }; };
  
 class PEGASUS_COMMON_LINKAGE MissingNullTerminator : public Exception  class PEGASUS_COMMON_LINKAGE InvalidContentLanguageHeader: public Exception
 { {
 public: public:
  
     static const char MSG[];     static const char MSG[];
       static const char KEY[];
  
     MissingNullTerminator() : Exception(MSG) { }      InvalidContentLanguageHeader(const String& error);
       virtual ~InvalidContentLanguageHeader();
 }; };
  
 class PEGASUS_COMMON_LINKAGE InvalidAuthHeader: public Exception class PEGASUS_COMMON_LINKAGE InvalidAuthHeader: public Exception
Line 391 
Line 401 
 public: public:
  
     static const char MSG[];     static const char MSG[];
       static const char KEY[];
  
     InvalidAuthHeader() : Exception(MSG) { }      InvalidAuthHeader();
       virtual ~InvalidAuthHeader();
 }; };
  
 class PEGASUS_COMMON_LINKAGE UnauthorizedAccess: public Exception class PEGASUS_COMMON_LINKAGE UnauthorizedAccess: public Exception
Line 400 
Line 412 
 public: public:
  
     static const char MSG[];     static const char MSG[];
       static const char KEY[];
  
     UnauthorizedAccess() : Exception(MSG) { }      UnauthorizedAccess();
       virtual ~UnauthorizedAccess();
 }; };
  
 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 422 
Line 447 
     TraceableCIMException(     TraceableCIMException(
         CIMStatusCode code,         CIMStatusCode code,
         const String& message,         const String& message,
         const char* file,          const String& file,
           Uint32 line);
   
       TraceableCIMException(
           CIMStatusCode code,
           const MessageLoaderParms& parms,
           const String& file,
           Uint32 line);
   
       TraceableCIMException(
           const ContentLanguageList& langs,
           CIMStatusCode code,
           const String& message,
           const String& file,
         Uint32 line);         Uint32 line);
  
     TraceableCIMException(const CIMException & cimException);     TraceableCIMException(const CIMException & cimException);
Line 430 
Line 468 
     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__)
   
   #define PEGASUS_CIM_EXCEPTION_LANG(LANGS, CODE, EXTRA_MESSAGE) \
       TraceableCIMException( \
           LANGS, CODE, EXTRA_MESSAGE, String(__FILE__), __LINE__)
   
   #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)
   
   /** 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
  

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