home *** CD-ROM | disk | FTP | other *** search
/ OS/2 Shareware BBS: 10 Tools / 10-Tools.zip / ssvpar.zip / SSEXCEPT.HPP < prev    next >
Text File  |  1994-10-17  |  5KB  |  144 lines
  1. /*---------------------------------------------------------------------------
  2.  
  3.                Copyright (c) 1994 SandStone Software Inc.
  4.                           All rights reserved
  5.  
  6. ----------------------------------------------------------------------------*/
  7. #if !defined( SSEXCEPTION)
  8. #  define SSEXCEPTION
  9.  
  10. #  include<stdio.h>
  11. #  include<string.h>
  12. #  include<sssto.hpp>
  13. #  include<ssexcept.h>
  14. #  include<ssglobal.h>
  15.  
  16. #  define SSExceptionParmArray  8
  17. #  define SSExceptionTextLength 127
  18. #  define SSExceptionDefault    SSTrue
  19. #  define SSTHROW( class)       throw class
  20.  
  21.    class SSException;
  22.    class SSExceptionInfo;
  23.    class SSExceptionParm;
  24.    class SSExceptionPresent;
  25.  
  26.    class SSExceptionParm
  27.       {
  28.       public:
  29.  
  30.          enum SSExceptionParmType
  31.             {
  32.             constVoid,
  33.             constChar,
  34.             unsigned32
  35.             };
  36.  
  37.          SSConstr            SSExceptionParm( void);
  38.          SSConstr            SSExceptionParm( const char*);
  39.          SSConstr            SSExceptionParm( const void*);
  40.          SSConstr            SSExceptionParm( SSUnsigned32);
  41.          SSConstr            SSExceptionParm( const SSExceptionParm&);
  42.  
  43.          SSExceptionParm&    operator=( const char*);
  44.          SSExceptionParm&    operator=( const void*);
  45.          SSExceptionParm&    operator=( SSUnsigned32);
  46.          SSExceptionParm&    operator=( const SSExceptionParm&);
  47.  
  48.          SSExceptionParmType type( void) const;
  49.          SSBooleanValue      isConstChar( void) const;
  50.          SSBooleanValue      isConstVoid( void) const;
  51.          SSBooleanValue      isUnsigned32( void) const;
  52.  
  53.          const char*         asConstChar( void) const;
  54.          const void*         asConstVoid( void) const;
  55.          SSUnsigned32        asUnsigned32( void) const;
  56.  
  57.                              operator const char*( void);
  58.                              operator const void*( void);
  59.                              operator SSUnsigned32( void);
  60.  
  61.          SSDestr             SSExceptionParm( void);
  62.  
  63.       protected:
  64.          SSExceptionParmType oType;
  65.          union
  66.             {
  67.             const void*      opParm;
  68.             SSUnsigned32     oulParm;
  69.             char*            opchParm;
  70.             };
  71.       };
  72.  
  73.    class SSExceptionInfo
  74.       {
  75.       public:
  76.          SSConstr       SSExceptionInfo( void);
  77.  
  78.          SSBooleanValue hasException( void) const;
  79.          SSBooleanValue setException( SSBooleanValue = SSTrue);
  80.  
  81.       protected:
  82.          SSBooleanValue oException;
  83.       };
  84.  
  85.    class SSException
  86.       {
  87.       friend class SSExceptionInfo;
  88.  
  89.       public:
  90.          void*             operator new( size_t);
  91.          void              operator delete( void*);
  92.  
  93.          SSConstr          SSException( const SSException&);
  94.          SSConstr          SSException( const char*, unsigned long = 0);
  95.  
  96.          const char*       text( void) const;
  97.          SSExceptionParm*  parm( SSUnsigned32);
  98.          SSUnsigned32      errorId( void) const;
  99.          void              setText( const char*);
  100.  
  101.          SSDestr           SSException( void);
  102.  
  103.       protected:
  104.          SSUnsigned32      oulId;
  105.          SSExceptionParm   oaParm[ SSExceptionParmArray];
  106.          char              oachText[ SSExceptionTextLength + 1];
  107.       };
  108.  
  109.    class SSExceptionOutOfStorage : public SSException
  110.       {
  111.       public:
  112.          SSConstr          SSExceptionOutOfStorage( void);
  113.       };
  114.  
  115.    class SSExceptionPresent 
  116.       {
  117.       public:
  118.          SSConstr     SSExceptionPresent( void);
  119.  
  120.          void         throwException( SSUnsigned32, const char*);
  121.          void         throwException( SSUnsigned32, const char*,
  122.                          SSUnsigned32);
  123.          void         throwException( SSUnsigned32, const char*,
  124.                          const char*);
  125.          void         throwException( SSUnsigned32, const char*, 
  126.                          const char*, SSUnsigned32);
  127.          void         throwException( SSUnsigned32, const char*,
  128.                          SSUnsigned32, SSUnsigned32, const char*);
  129.  
  130.          SSException* getException( void);
  131.          SSException* hasException( void) const;
  132.          SSException* setException( SSException*);
  133.  
  134.       protected:
  135.          SSException* opException;
  136.       };
  137.  
  138.    SSExceptionInfo& getSSExceptionInfo( void);
  139.    void             setSSExceptionNewHandler( void);
  140.  
  141. #  include<ssexcept.inl>
  142.  
  143. #endif
  144.