home *** CD-ROM | disk | FTP | other *** search
/ Power GUI Programming with VisualAge C++ / powergui.iso / trialva / ibmcppw / include / iexc.h < prev    next >
Encoding:
C/C++ Source or Header  |  1996-02-22  |  11.5 KB  |  484 lines
  1. /**********************************************************************
  2. *                                                                     *
  3. *  IBM(R) VisualAge(TM) for C++ for Windows(R), Version 3.5           *
  4. *                                                                     *
  5. *  PID: 5622-880                                                      *
  6. *  - Licensed Material - Program-Property of IBM                      *
  7. *  (C) Copyright IBM Corp. 1991, 1995 - All Right Reserved.           *
  8. *                                                                     *
  9. *  US Government Users Restricted Rights - Use, duplication or        *
  10. *  disclosure restricted by GSA ADP Schedule Contract with IBM Corp.  *
  11. *                                                                     *
  12. *  VisualAge, and IBM are trademarks or registered trademarks of      *
  13. *  International Business Machines Corporation.                       *
  14. *  Windows is a registered trademark of Microsoft Corporation.        *
  15. *                                                                     *
  16. **********************************************************************/
  17.  
  18. #ifndef _IEXC_H
  19. #define _IEXC_H
  20.  
  21. #include <iiglobal.h>
  22. #include <iexcbase.hpp>
  23. #include <iexctxt.h>
  24.  
  25. #pragma info (nocls, nocnd, nocns, nocnv, noext, nognr, novft)
  26. #pragma pack (4)
  27.  
  28.  
  29. #pragma SOMAsDefault (off)
  30.  
  31. class IPreconditionViolation : public IException {
  32. public:
  33.  
  34.            IPreconditionViolation
  35.                             (char const*, unsigned long = 0,
  36.                              Severity = IException::unrecoverable);
  37.  
  38.            IPreconditionViolation
  39.                             (IPreconditionViolation const&);
  40.  
  41.   virtual ~IPreconditionViolation
  42.                             ();
  43.  
  44.   virtual
  45.   char const*
  46.            name             () const;
  47.  
  48.   static
  49.   void     throwIt          (unsigned long,
  50.                              char const*, unsigned long);
  51.  
  52. protected:
  53.  
  54. private:
  55.  
  56.   void     operator=        (IPreconditionViolation const&);
  57.  
  58.  
  59. };
  60.  
  61. class IFullException : public IPreconditionViolation {
  62. public:
  63.  
  64.            IFullException   (char const*, unsigned long = 0,
  65.                              Severity = IException::unrecoverable);
  66.  
  67.            IFullException   (IFullException const&);
  68.  
  69.   virtual ~IFullException   ();
  70.  
  71.   virtual
  72.   char const*
  73.            name             () const;
  74.  
  75.   static
  76.   void     throwIt          (unsigned long,
  77.                              char const*, unsigned long);
  78.  
  79. protected:
  80.  
  81. private:
  82.  
  83.   void     operator=        (IFullException const&);
  84.  
  85.  
  86. };
  87.  
  88. class IEmptyException : public IPreconditionViolation {
  89. public:
  90.  
  91.            IEmptyException  (char const*, unsigned long = 0,
  92.                              Severity = IException::unrecoverable);
  93.  
  94.            IEmptyException  (IEmptyException const&);
  95.  
  96.   virtual ~IEmptyException  ();
  97.  
  98.   virtual
  99.   char const*
  100.            name             () const;
  101.  
  102.   static
  103.   void     throwIt          (unsigned long,
  104.                              char const*, unsigned long);
  105.  
  106. protected:
  107.  
  108. private:
  109.  
  110.   void     operator=        (IEmptyException const&);
  111.  
  112.  
  113. };
  114.  
  115. class INotEmptyException : public IPreconditionViolation {
  116. public:
  117.  
  118.            INotEmptyException
  119.                             (char const*, unsigned long = 0,
  120.                              Severity = IException::unrecoverable);
  121.  
  122.            INotEmptyException
  123.                             (INotEmptyException const&);
  124.  
  125.   virtual ~INotEmptyException
  126.                             ();
  127.  
  128.   virtual
  129.   char const*
  130.            name             () const;
  131.  
  132.   static
  133.   void     throwIt          (unsigned long,
  134.                              char const*, unsigned long);
  135.  
  136. protected:
  137.  
  138. private:
  139.  
  140.   void     operator=        (INotEmptyException const&);
  141.  
  142.  
  143. };
  144.  
  145. class INotBoundedException : public IPreconditionViolation {
  146. public:
  147.  
  148.            INotBoundedException
  149.                             (char const*, unsigned long = 0,
  150.                              Severity = IException::unrecoverable);
  151.  
  152.            INotBoundedException
  153.                             (INotBoundedException const&);
  154.  
  155.   virtual ~INotBoundedException
  156.                             ();
  157.  
  158.   virtual
  159.   char const*
  160.            name             () const;
  161.  
  162.   static
  163.   void     throwIt          (unsigned long,
  164.                              char const*, unsigned long);
  165.  
  166. protected:
  167.  
  168. private:
  169.  
  170.   void     operator=        (INotBoundedException const&);
  171.  
  172.  
  173. };
  174.  
  175. class ICursorInvalidException : public IPreconditionViolation {
  176. public:
  177.  
  178.            ICursorInvalidException
  179.                             (char const*, unsigned long = 0,
  180.                              Severity = IException::unrecoverable);
  181.  
  182.            ICursorInvalidException
  183.                             (ICursorInvalidException const&);
  184.  
  185.   virtual ~ICursorInvalidException
  186.                             ();
  187.  
  188.   virtual
  189.   char const*
  190.            name             () const;
  191.  
  192.   static
  193.   void     throwIt          (unsigned long,
  194.                              char const*, unsigned long);
  195.  
  196. protected:
  197.  
  198. private:
  199.  
  200.   void     operator=        (ICursorInvalidException const&);
  201.  
  202.  
  203. };
  204.  
  205. class IPositionInvalidException : public IPreconditionViolation {
  206. public:
  207.  
  208.            IPositionInvalidException
  209.                             (char const*, unsigned long = 0,
  210.                              Severity = IException::unrecoverable);
  211.  
  212.            IPositionInvalidException
  213.                             (IPositionInvalidException const&);
  214.  
  215.   virtual ~IPositionInvalidException
  216.                             ();
  217.  
  218.   virtual
  219.   char const*
  220.            name             () const;
  221.  
  222.   static
  223.   void     throwIt          (unsigned long,
  224.                              char const*, unsigned long);
  225.  
  226. protected:
  227.  
  228. private:
  229.  
  230.   void     operator=        (IPositionInvalidException const&);
  231.  
  232.  
  233. };
  234.  
  235. class INotContainsKeyException : public IPreconditionViolation {
  236. public:
  237.  
  238.            INotContainsKeyException
  239.                             (char const*, unsigned long = 0,
  240.                              Severity = IException::unrecoverable);
  241.  
  242.            INotContainsKeyException
  243.                             (INotContainsKeyException const&);
  244.  
  245.   virtual ~INotContainsKeyException
  246.                             ();
  247.  
  248.   virtual
  249.   char const*
  250.            name             () const;
  251.  
  252.   static
  253.   void     throwIt          (unsigned long,
  254.                              char const*, unsigned long);
  255.  
  256. protected:
  257.  
  258. private:
  259.  
  260.   void     operator=        (INotContainsKeyException const&);
  261.  
  262.  
  263. };
  264.  
  265. class IKeyAlreadyExistsException : public IPreconditionViolation {
  266. public:
  267.  
  268.            IKeyAlreadyExistsException
  269.                             (char const*, unsigned long = 0,
  270.                              Severity = IException::unrecoverable);
  271.  
  272.            IKeyAlreadyExistsException
  273.                             (IKeyAlreadyExistsException const&);
  274.  
  275.   virtual ~IKeyAlreadyExistsException
  276.                             ();
  277.  
  278.   virtual
  279.   char const*
  280.            name             () const;
  281.  
  282.   static
  283.   void     throwIt          (unsigned long,
  284.                              char const*, unsigned long);
  285.  
  286. protected:
  287.  
  288. private:
  289.  
  290.   void     operator=        (IKeyAlreadyExistsException const&);
  291.  
  292.  
  293. };
  294.  
  295. class IRootAlreadyExistsException : public IPreconditionViolation {
  296. public:
  297.  
  298.            IRootAlreadyExistsException
  299.                             (char const*, unsigned long = 0,
  300.                              Severity = IException::unrecoverable);
  301.  
  302.            IRootAlreadyExistsException
  303.                             (IRootAlreadyExistsException const&);
  304.  
  305.   virtual ~IRootAlreadyExistsException
  306.                             ();
  307.  
  308.   virtual
  309.   char const*
  310.            name             () const;
  311.  
  312.   static
  313.   void     throwIt          (unsigned long,
  314.                              char const*, unsigned long);
  315.  
  316. protected:
  317.  
  318. private:
  319.  
  320.   void     operator=        (IRootAlreadyExistsException const&);
  321.  
  322.  
  323. };
  324.  
  325. class IChildAlreadyExistsException : public IPreconditionViolation {
  326. public:
  327.  
  328.            IChildAlreadyExistsException
  329.                             (char const*, unsigned long = 0,
  330.                              Severity = IException::unrecoverable);
  331.  
  332.            IChildAlreadyExistsException
  333.                             (IChildAlreadyExistsException const&);
  334.  
  335.   virtual ~IChildAlreadyExistsException
  336.                             ();
  337.  
  338.   virtual
  339.   char const*
  340.            name             () const;
  341.  
  342.   static
  343.   void     throwIt          (unsigned long,
  344.                              char const*, unsigned long);
  345.  
  346. protected:
  347.  
  348. private:
  349.  
  350.   void     operator=        (IChildAlreadyExistsException const&);
  351.  
  352.  
  353. };
  354.  
  355. class IIdenticalCollectionException : public IPreconditionViolation {
  356. public:
  357.  
  358.            IIdenticalCollectionException
  359.                             (char const*, unsigned long = 0,
  360.                              Severity = IException::unrecoverable);
  361.  
  362.            IIdenticalCollectionException
  363.                             (IIdenticalCollectionException const&);
  364.  
  365.   virtual ~IIdenticalCollectionException
  366.                             ();
  367.  
  368.   virtual
  369.   char const*
  370.            name             () const;
  371.  
  372.   static
  373.   void     throwIt          (unsigned long,
  374.                              char const*, unsigned long);
  375.  
  376. protected:
  377.  
  378. private:
  379.  
  380.   void     operator=        (IIdenticalCollectionException const&);
  381.  
  382.  
  383. };
  384.  
  385. class IInvalidReplacementException : public IPreconditionViolation {
  386. public:
  387.  
  388.            IInvalidReplacementException
  389.                             (char const*, unsigned long = 0,
  390.                              Severity = IException::unrecoverable);
  391.  
  392.            IInvalidReplacementException
  393.                             (IInvalidReplacementException const&);
  394.  
  395.   virtual ~IInvalidReplacementException
  396.                             ();
  397.  
  398.   virtual
  399.   char const*
  400.            name             () const;
  401.  
  402.   static
  403.   void     throwIt          (unsigned long,
  404.                              char const*, unsigned long);
  405.  
  406. protected:
  407.  
  408. private:
  409.  
  410.   void     operator=        (IInvalidReplacementException const&);
  411.  
  412.  
  413. };
  414.  
  415. class ICyclicAttachException : public IPreconditionViolation {
  416. public:
  417.  
  418.            ICyclicAttachException
  419.                             (char const*, unsigned long = 0,
  420.                              Severity = IException::unrecoverable);
  421.  
  422.            ICyclicAttachException
  423.                             (ICyclicAttachException const&);
  424.  
  425.   virtual ~ICyclicAttachException
  426.                             ();
  427.  
  428.   virtual
  429.   char const*
  430.            name             () const;
  431.  
  432.   static
  433.   void     throwIt          (unsigned long,
  434.                              char const*, unsigned long);
  435.  
  436. protected:
  437.  
  438. private:
  439.  
  440.   void     operator=        (ICyclicAttachException const&);
  441.  
  442.  
  443. };
  444.  
  445. class IOutOfCollectionMemory : public IOutOfMemory {
  446. public:
  447.  
  448.            IOutOfCollectionMemory
  449.                             (char const*, unsigned long = 0,
  450.                              Severity = IException::unrecoverable);
  451.  
  452.            IOutOfCollectionMemory
  453.                             (IOutOfCollectionMemory const&);
  454.  
  455.   virtual ~IOutOfCollectionMemory
  456.                             ();
  457.  
  458.   virtual
  459.   char const*
  460.            name             () const;
  461.  
  462.   static
  463.   void     throwIt          (unsigned long,
  464.                              char const*, unsigned long);
  465.  
  466. protected:
  467.  
  468. private:
  469.  
  470.   void     operator=        (IOutOfCollectionMemory const&);
  471.  
  472.  
  473. };
  474.  
  475.  
  476.  
  477. #pragma SOMAsDefault (pop)
  478.  
  479.  
  480. #pragma info (restore)
  481. #pragma pack ()
  482.  
  483. #endif
  484.