File indexing completed on 2024-04-14 14:10:46

 //#     Filename:   SpatialException.cpp
 //#
 //#     Author:     John Doug Reynolds, P. Kunszt
 //#
 //#     Date:       Mar 1997
 //#
 //#     SPDX-FileCopyrightText: 2000 Peter Z. Kunszt Alex S. Szalay, Aniruddha R. Thakar
 //#                     The Johns Hopkins University
 //#
 //#     Modification history:
 //#
 //#     Oct. 1998, P. Kunszt : remove Rogue Wave C-string dependency
 //#                almost all the interface had to be rewritten.
 //#                Also, use some of the inheritance to avoid
 //#                code duplication. Introduced defaultstr[].
 //#     Oct 18, 2001 : Dennis C. Dinge -- Replaced ValVec with std::vector
 //#
 
 #include <cstdio>
 #include <cstdlib>
 #include <string.h>
 #include <SpatialException.h>
 
 /* --- SpatialException methods ------------------------------------------------- */
 const char *SpatialException::defaultstr[] = { "SDSS Science Archive",
                                                "generic exception",           // These specialized exceptions are
                                                "unimplemented functionality", // currently implemented. If no string
                                                "failed operation",            // is given, this is the standard
                                                "array bounds violation",      // message.
                                                "interface violation" };
 
 #define CONTEXT       0 // indices of exceptions
 #define GENERIC       1
 #define UNIMPLEMENTED 2
 #define FAILURE       3
 #define BOUNDS        4
 #define INTERFACE     5
 
 SpatialException::~SpatialException() throw()
 {
     clear();
 }
 
 SpatialException::SpatialException(const char *cstr, int defIndex) throw()
 {
     try
     {
         if (cstr)
         {
             str_ = new char[slen(cstr) + 1];
             strcpy(str_, cstr);
         }
         else
         {
             str_ = new char[50];
             sprintf(str_, "%s : %s", defaultstr[CONTEXT], defaultstr[defIndex]);
         }
     }
     catch (...)
     {
         clear();
     }
 }
 
 SpatialException::SpatialException(const char *context, const char *because, int defIndex) throw()
 {
     try
     {
         const char *tmpc, *tmpb;
         tmpc = context ? context : defaultstr[CONTEXT];
         tmpb = because ? because : defaultstr[defIndex];
         str_ = new char[slen(tmpc) + slen(tmpb) + 50]; // allow extensions
         sprintf(str_, "%s : %s", tmpc, tmpb);
     }
     catch (...)
     {
         clear();
     }
 }
 
 SpatialException::SpatialException(const SpatialException &oldX) throw()
 {
     try
     {
         if (oldX.str_)
         {
             str_ = new char[slen(oldX.str_) + 1];
             strcpy(str_, oldX.str_);
         }
     }
     catch (...)
     {
         clear();
     }
 }
 
 SpatialException &SpatialException::operator=(const SpatialException &oldX) throw()
 {
     try
     {
         if (&oldX != this) // beware of self-assignment
         {
             if (oldX.str_)
             {
                 str_ = new char[slen(oldX.str_) + 1];
                 strcpy(str_, oldX.str_);
             }
         }
     }
     catch (...)
     {
         clear();
     }
     return *this;
 }
 
 const char *SpatialException::what() const throw()
 {
     try
     {
         return str_;
     }
     catch (...)
     {
         return "";
     }
 }
 
 int SpatialException::slen(const char *str) const
 {
     if (str)
         return strlen(str);
     return 0;
 }
 
 void SpatialException::clear()
 {
     delete[] str_;
     str_ = nullptr;
 }
 /* --- SpatialUnimplemented methods --------------------------------------------- */
 
 SpatialUnimplemented::SpatialUnimplemented(const char *cstr) throw() : SpatialException(cstr, UNIMPLEMENTED)
 {
 }
 
 SpatialUnimplemented::SpatialUnimplemented(const char *context, const char *because) throw()
     : SpatialException(context, because, UNIMPLEMENTED)
 {
 }
 
 SpatialUnimplemented::SpatialUnimplemented(const SpatialUnimplemented &oldX) throw() : SpatialException(oldX)
 {
 }
 
 /* --- SpatialFailure methods --------------------------------------------------- */
 
 SpatialFailure::SpatialFailure(const char *cstr) throw() : SpatialException(cstr, FAILURE)
 {
 }
 
 SpatialFailure::SpatialFailure(const char *context, const char *because) throw()
     : SpatialException(context, because, FAILURE)
 {
 }
 
 SpatialFailure::SpatialFailure(const char *context, const char *operation, const char *resource,
                                const char *because) throw()
 {
     try
     {
         clear();
         if (!operation && !resource && !because)
         {
             if (!context)
                 context = defaultstr[CONTEXT];
             because = "failed operation";
         }
         size_t const len = slen(context) + slen(operation) + slen(resource) + slen(because) + 50;
         str_  = new char[len];
         *str_ = '\0';
         char * ptr = str_;
         if (!context)
             context = defaultstr[CONTEXT];
         ptr += sprintf(ptr, "%s: ", context);
         if (operation)
         {
             ptr += sprintf(ptr, " %s failed ", operation);
         }
         if (resource)
         {
             if (operation)
                 ptr += sprintf(ptr, " on \"%s\"", resource);
             else
                 ptr += sprintf(ptr, " trouble with \"%s\"", resource);
         }
         if (because)
         {
             if (operation || resource)
                 ptr += sprintf(ptr, " because %s", because);
             else
                 ptr += sprintf(ptr, " %s", because);
         }
     }
     catch (...)
     {
         clear();
     }
 }
 
 SpatialFailure::SpatialFailure(const SpatialFailure &oldX) throw() : SpatialException(oldX)
 {
 }
 
 /* --- SpatialBoundsError methods ----------------------------------------------- */
 
 SpatialBoundsError::SpatialBoundsError(const char *cstr) throw() : SpatialException(cstr, BOUNDS)
 {
 }
 
 SpatialBoundsError::SpatialBoundsError(const char *context, const char *array, int32 limit, int32 index) throw()
     : SpatialException(context, array, BOUNDS)
 {
     try
     {
         if (limit != -1)
         {
             char * ptr = str_;
             if (array)
                 ptr += sprintf(ptr, "[%d]", index);
             else
                 ptr += sprintf(ptr, " array index %d ", index);
             if (index > limit)
             {
                 ptr += sprintf(ptr, " over upper bound by %d", index - limit);
             }
             else
             {
                 ptr += sprintf(ptr, " under lower bound by %d", limit - index);
             }
         }
     }
     catch (...)
     {
         clear();
     }
 }
 
 SpatialBoundsError::SpatialBoundsError(const SpatialBoundsError &oldX) throw() : SpatialException(oldX)
 {
 }
 
 /* --- SpatialInterfaceError methods -------------------------------------------- */
 
 SpatialInterfaceError::SpatialInterfaceError(const char *cstr) throw() : SpatialException(cstr, INTERFACE)
 {
 }
 
 SpatialInterfaceError::SpatialInterfaceError(const char *context, const char *because) throw()
     : SpatialException(context, because, INTERFACE)
 {
 }
 
 SpatialInterfaceError::SpatialInterfaceError(const char *context, const char *argument, const char *because) throw()
 {
     try
     {
         clear();
         str_  = new char[slen(context) + slen(argument) + slen(because) + 128];
         *str_ = '\0';
         char * ptr = str_;
         if (!context)
             context = defaultstr[CONTEXT];
         ptr += sprintf(ptr, "%s: ", context);
         if (argument && because)
         {
             ptr += sprintf(ptr, " argument \"%s\" is invalid because %s ", argument, because);
         }
         else if (argument && !because)
         {
             ptr += sprintf(ptr, " invalid argument \"%s\" ", argument);
         }
         else if (!argument)
         {
             if (because)
                 ptr += sprintf(str_, " %s", because);
             else
                 ptr += sprintf(str_, " interface violation");
         }
     }
     catch (...)
     {
         clear();
     }
 }
 
 SpatialInterfaceError::SpatialInterfaceError(const SpatialInterfaceError &oldX) throw() : SpatialException(oldX)
 {
 }