Exception.hpp

Go to the documentation of this file.

//==============================================================================
//
//  This file is part of GNSSTk, the ARL:UT GNSS Toolkit.
//
//  The GNSSTk is free software; you can redistribute it and/or modify
//  it under the terms of the GNU Lesser General Public License as published
//  by the Free Software Foundation; either version 3.0 of the License, or
//  any later version.
//
//  The GNSSTk is distributed in the hope that it will be useful,
//  but WITHOUT ANY WARRANTY; without even the implied warranty of
//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
//  GNU Lesser General Public License for more details.
//
//  You should have received a copy of the GNU Lesser General Public
//  License along with GNSSTk; if not, write to the Free Software Foundation,
//  Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110, USA
//
//  This software was developed by Applied Research Laboratories at the
//  University of Texas at Austin.
//  Copyright 2004-2022, The Board of Regents of The University of Texas System
//
//==============================================================================
 
//==============================================================================
//
//  This software was developed by Applied Research Laboratories at the
//  University of Texas at Austin, under contract to an agency or agencies
//  within the U.S. Department of Defense. The U.S. Government retains all
//  rights to use, duplicate, distribute, disclose, or release this software.
//
//  Pursuant to DoD Directive 523024
//
//  DISTRIBUTION STATEMENT A: This software has been approved for public
//                            release, distribution is unlimited.
//
//==============================================================================
 
// The unusual include macro below is done this way because xerces
// #defines EXCEPTION_HPP in their own exception class header file.
#ifndef GNSSTK_EXCEPTION_HPP
#define GNSSTK_EXCEPTION_HPP
 
#include <cstdlib>
#include <iostream>
#include <vector>
#include <string>
 
namespace gnsstk
{
   class ExceptionLocation
   {
   public:
      ExceptionLocation(const std::string& filename = std::string(),
                        const std::string& funcName = std::string(),
                        const unsigned long& lineNum = 0)
            : fileName(filename), functionName(funcName),
              lineNumber(lineNum)
      { }
 
      ~ExceptionLocation() {}
 
      std::string getFileName() const
      { return fileName; }
      std::string getFunctionName() const
      { return functionName; }
      unsigned long getLineNumber() const
      { return lineNumber; }
 
      void dump(std::ostream& s) const;
 
      std::string what() const;
 
      friend std::ostream& operator<<( std::ostream& s,
                                       const ExceptionLocation& e );
 
   private:
      std::string fileName;
      std::string functionName;
      unsigned long lineNumber;
   }; // class ExceptionLocation
 
   class Exception
   {
   public:
      enum Severity
      {
         unrecoverable, 
         recoverable    
      };
 
      Exception();
 
      Exception(const std::string& errorText,
                const unsigned long& errorId = 0,
                const Severity& severity = unrecoverable);
 
 
      Exception(const char* errorText,
                const unsigned long& errorId = 0,
                const Severity& severity = unrecoverable);
 
 
      Exception(const Exception& exception);
 
      ~Exception()
      {};
 
      Exception& operator=(const Exception& e);
 
      void terminate()
      { exit(1); };
 
      unsigned long getErrorId() const
      { return errorId; };
 
      Exception& setErrorId(const unsigned long& errId)
      { errorId = errId; return *this; };
 
      Exception& addLocation(const ExceptionLocation& location);
 
      const ExceptionLocation getLocation(const size_t& index=0) const;
 
      size_t getLocationCount() const;
 
      bool isRecoverable() const
      { return (severity == recoverable); }
 
      Exception& setSeverity(const Severity& sever)
      { severity = sever; return *this; };
 
      Exception& addText(const std::string& errorText);
 
      std::string getText(const size_t& index=0) const;
 
      size_t getTextCount() const;
 
      std::string getName() const
      { return "Exception"; };
 
      void dump(std::ostream& s) const;
 
      std::string what() const;
 
      friend std::ostream& operator<<( std::ostream& s,
                                       const Exception& e );
 
   protected:
      unsigned long errorId;
      std::vector<ExceptionLocation> locations;
      Severity severity;
      std::vector<std::string> text;
 
      int overflow(int c);
 
   private:
      std::string streamBuffer;
   }; // class Exception
 
 
}  // namespace gnsstk
 
 
#if defined ( __FUNCTION__ )
#define FILE_LOCATION gnsstk::ExceptionLocation(__FILE__, __FUNCTION__, __LINE__)
#else
#define FILE_LOCATION gnsstk::ExceptionLocation(__FILE__, "", __LINE__)
#endif
 
// For compilers without exceptions, die if you get an exception.
#if defined (NO_EXCEPTIONS_SUPPORT)
#define GNSSTK_THROW(exc) { exc.addLocation(FILE_LOCATION); exc.terminate(); }
#define GNSSTK_RETHROW(exc) { exc.addLocation(FILE_LOCATION); exc.terminate(); }
#else
#define GNSSTK_THROW(exc)   { exc.addLocation(FILE_LOCATION); throw exc; }
#define GNSSTK_RETHROW(exc) { exc.addLocation(FILE_LOCATION); throw; }
#endif
 
#define GNSSTK_ASSERT(CONDITION) if (!(CONDITION)) {                     \
      gnsstk::AssertionFailure exc("Assertion failed: " #CONDITION);     \
      GNSSTK_THROW(exc);                                                 \
   }
 
 
#define NEW_EXCEPTION_CLASS(child, parent) \
class child : public parent  \
{ \
public: \
 \
   child() : parent() {} \
 \
   child(const child& a): parent(a) {} \
 \
   child(const gnsstk::Exception& a) : parent(a) {}; \
 \
   child(const std::string& a, unsigned long b = 0,\
         gnsstk::Exception::Severity c = gnsstk::Exception::unrecoverable) \
         : parent(a, b, c) \
   {};\
 \
   child(const char* a, unsigned long b = 0,\
   gnsstk::Exception::Severity c = gnsstk::Exception::unrecoverable) \
   : parent(a, b, c) \
   {};\
 \
   ~child() {} \
 \
   std::string getName() const {return ( # child);} \
 \
   child& operator=(const child& kid) \
      { parent::operator=(kid); return *this; } \
 \
   friend std::ostream& operator<<(std::ostream& s, const child& c) \
      { c.dump(s); return s; } \
}
 
namespace gnsstk
{
   NEW_EXCEPTION_CLASS(InvalidParameter, Exception);
 
   NEW_EXCEPTION_CLASS(InvalidRequest, Exception);
 
   NEW_EXCEPTION_CLASS(AssertionFailure, Exception);
 
   NEW_EXCEPTION_CLASS(AccessError, Exception);
 
   NEW_EXCEPTION_CLASS(IndexOutOfBoundsException, Exception);
 
   NEW_EXCEPTION_CLASS(InvalidArgumentException, Exception);
 
   NEW_EXCEPTION_CLASS(ConfigurationException, Exception);
 
   NEW_EXCEPTION_CLASS(FileMissingException, Exception);
 
   NEW_EXCEPTION_CLASS(SystemSemaphoreException, Exception);
 
   NEW_EXCEPTION_CLASS(SystemPipeException, Exception);
 
   NEW_EXCEPTION_CLASS(SystemQueueException, Exception);
 
   NEW_EXCEPTION_CLASS(OutOfMemory, Exception);
 
   NEW_EXCEPTION_CLASS(ObjectNotFound, AccessError);
 
   NEW_EXCEPTION_CLASS(NullPointerException, Exception);
 
   NEW_EXCEPTION_CLASS(UnimplementedException, Exception);
 
   NEW_EXCEPTION_CLASS(FFStreamError, gnsstk::Exception);
 
   NEW_EXCEPTION_CLASS(EndOfFile, gnsstk::FFStreamError);
 
   class StopIterator {};
 
} // namespace gnsstk
#endif