File indexing completed on 2024-04-14 03:42:33

 //#     Filename:   SpatialException.h
 //#
 //#     Author:     Peter Z Kunszt based on John Doug Reynolds'code
 //#
 //#     Date:       March 1998
 //#
 //#     SPDX-FileCopyrightText: 2000 Peter Z. Kunszt Alex S. Szalay, Aniruddha R. Thakar
 //#                     The Johns Hopkins University
 //#
 //#     Modification History:
 //#
 //#     Oct 18, 2001 : Dennis C. Dinge -- Replaced ValVec with std::vector
 //#
 
 #ifndef _SpatialException_h
 #define _SpatialException_h
 
 #include "SpatialGeneral.h"
 
 /** HTM SpatialIndex Exception base class
     This is the base class for all Science Archive exceptions.  It may
     be used as a generic exception, but programmers are encouraged to
     use the more specific derived classes.  Note that all Spatial
     exceptions are also Standard Library exceptions by
     inheritance.
 */
 
 class LINKAGE SpatialException
 {
   public:
     /** Default and explicit constructor.
             The default constructor
             supplies a generic message indicating the exception type.  The
             explicit constructor sets the message to a copy of the provided
             string.  This behavior is shared by all derived classes.
         */
 
     SpatialException(const char *what = nullptr, int defIndex = 1) throw();
 
     /** Standard constructor.
             The message is assembled from copies of
             the two component strings.  The first indicates where in the
             program the exception was thrown, and the second indicates why.
             The null pointer is used to select standard components according
             to the type of the exception.  This behavior is shared by all
             derived classes.
         */
     SpatialException(const char *context, const char *because, int defIndex = 1) throw();
 
     /// Copy constructor.
     SpatialException(const SpatialException &) throw();
 
     /// Assignment operator.
     SpatialException &operator=(const SpatialException &) throw();
 
     /// Destructor.
     virtual ~SpatialException() throw();
 
     /// Returns the message as set during construction.
     virtual const char *what() const throw();
 
     /// return string length also for null strings
     int slen(const char *) const;
 
     /// deallocate string
     void clear();
 
     /// default error string
     static const char *defaultstr[];
 
   protected:
     /// error string to assemble
     char *str_;
 };
 
 /** SpatialException thrown by unimplemented functions.
     This Exception should be thrown wherever
     important functionality has been left temporarily unimplemented.
     Typically this exception will apply to an entire function.
 */
 
 class LINKAGE SpatialUnimplemented : public SpatialException
 {
   public:
     /// Default and explicit constructors.
     SpatialUnimplemented(const char *what = nullptr) throw();
 
     /// Standard constructor.
     SpatialUnimplemented(const char *context, const char *because) throw();
 
     /// Copy constructor.
     SpatialUnimplemented(const SpatialUnimplemented &) throw();
 };
 
 /** SpatialException thrown on operational failure.
     This Exception should be thrown when an operation
     fails unexpectedly.  A special constructor is provided for
     assembling the message from the typical components: program
     context, operation name, resource name, and explanation.  As usual,
     any component may be left out by specifying the null pointer.
 */
 
 class LINKAGE SpatialFailure : public SpatialException
 {
   public:
     /// Default and explicit constructors.
     SpatialFailure(const char *what = nullptr) throw();
 
     /// Standard constructor.
     SpatialFailure(const char *context, const char *because) throw();
 
     /// Special constructor.
     SpatialFailure(const char *context, const char *operation, const char *resource, const char *because = nullptr) throw();
 
     /// Copy constructor.
     SpatialFailure(const SpatialFailure &) throw();
 };
 
 /** SpatialException thrown on violation of array bounds.
     This Exception should be thrown on detection of an
     attempt to access elements beyond the boundaries of an array.  A
     special constructor is provided for assembling the message from the
     typical components: program context, array name, violated boundary,
     and violating index.
 */
 
 class LINKAGE SpatialBoundsError : public SpatialException
 {
   public:
     /// Default and explicit constructors.
     SpatialBoundsError(const char *what = nullptr) throw();
 
     /** Standard constructor.
             If limit and index are -1, both are
             considered unknown.  Note that the upper limit of a zero-offset
             array is not the same as the number of elements.
         */
     SpatialBoundsError(const char *context, const char *array, int32 limit = -1, int32 index = -1) throw();
 
     /// Copy constructor.
     SpatialBoundsError(const SpatialBoundsError &) throw();
 };
 
 /** SpatialException thrown on violation of interface protocols.
     This Exception should be thrown when a program,
     class, or function interface requirement is breached.
     Specifically, this includes improper usage and invalid arguments.
     For the latter, a special constructor is provided for assembling
     the message from the typical components: program context, argument
     name, and explanation.
 */
 
 class LINKAGE SpatialInterfaceError : public SpatialException
 {
   public:
     /// Default and explicit constructors.
     SpatialInterfaceError(const char *what = nullptr) throw();
 
     /// Standard constructor.
     SpatialInterfaceError(const char *context, const char *because) throw();
 
     /// Special constructor.
     SpatialInterfaceError(const char *context, const char *argument, const char *because) throw();
 
     /// Copy constructor.
     SpatialInterfaceError(const SpatialInterfaceError &) throw();
 };
 
 #endif /* _SpatialException_h */