Exception.hpp

Go to the documentation of this file.

#pragma ident "$Id: Exception.hpp 2937 2011-10-23 19:23:33Z yanweignss $"

//============================================================================
//
//  This file is part of GPSTk, the GPS Toolkit.
//
//  The GPSTk 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 2.1 of the License, or
//  any later version.
//
//  The GPSTk 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 GPSTk; if not, write to the Free Software Foundation,
//  Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
//  
//  Copyright 2004, The University of Texas at Austin
//
//============================================================================

//============================================================================
//
//This software 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 GPSTK_EXCEPTION_HPP
#define GPSTK_EXCEPTION_HPP

#include <cstdlib>
#include <iostream>
#include <vector>
#include <string>

namespace gpstk
{


   class ExceptionLocation
   {
   public:
      ExceptionLocation(const std::string& filename = std::string(),
                        const std::string& funcName = std::string(),
                        const unsigned long& lineNum = 0)
         throw()
            : fileName(filename), functionName(funcName),
              lineNumber(lineNum)
      { }

      ~ExceptionLocation() throw() {}

      std::string getFileName() const 
         throw() 
      { return fileName; }
      std::string getFunctionName() const 
         throw() 
      { return functionName; }
      unsigned long getLineNumber() const 
         throw()
      { return lineNumber; }

      void dump(std::ostream& s) const throw();

      std::string what() const throw();

      friend std::ostream& operator<<( std::ostream& s,
                                       const ExceptionLocation& e )
         throw();

   private:
      std::string fileName;
      std::string functionName;
      unsigned long lineNumber;
   }; // class ExceptionLocation
   
   class Exception : public std::exception
   {
   public:
      enum Severity
      {
         unrecoverable, 
         recoverable    
      };

      Exception() throw();

      Exception(const std::string& errorText, 
                const unsigned long& errorId = 0,
                const Severity& severity = unrecoverable)
         throw();
      Exception(const Exception& exception) 
         throw();
      ~Exception() 
         throw() 
      {};

      Exception& operator=(const Exception& e)
         throw();

      void terminate()
         throw()
      { ::exit(1); };

      unsigned long getErrorId() const 
         throw()
      { return errorId; };

      Exception& setErrorId(const unsigned long& errId)
         throw()
      { errorId = errId; return *this; };

      Exception& addLocation(const ExceptionLocation& location) 
         throw();

      const ExceptionLocation getLocation(const size_t& index=0) const
         throw();

      size_t getLocationCount() const
         throw();

      bool isRecoverable() const
         throw()
      { return (severity == recoverable); }

      Exception& setSeverity(const Severity& sever) 
         throw()
      { severity = sever; return *this; };

      Exception& addText(const std::string& errorText) 
         throw();

      std::string getText(const size_t& index=0) const 
         throw();

      size_t getTextCount() const
         throw();

      std::string getName() const
         throw()
      { return "Exception"; };

      void dump(std::ostream& s) const 
         throw();

      virtual const char* what() const throw();

      friend std::ostream& operator<<( std::ostream& s,
                                       const Exception& e )
         throw();

   protected:
      unsigned long errorId;
      std::vector<ExceptionLocation> locations;
      Severity severity;
      std::vector<std::string> text;

      int overflow(int c);

   private:
      std::string streamBuffer;
      mutable std::string whatBuffer;
   }; // class Exception


}  // namespace gpstk


#if defined ( __FUNCTION__ )
#define FILE_LOCATION gpstk::ExceptionLocation(__FILE__, __FUNCTION__, __LINE__)
#else
#define FILE_LOCATION gpstk::ExceptionLocation(__FILE__, "", __LINE__)
#endif

// For compilers without exceptions, die if you get an exception.
#if defined (NO_EXCEPTIONS_SUPPORT)
#define GPSTK_THROW(exc) { exc.addLocation(FILE_LOCATION); exc.terminate(); }
#define GPSTK_RETHROW(exc) { exc.addLocation(FILE_LOCATION); exc.terminate(); }
#else
#define GPSTK_THROW(exc)   { exc.addLocation(FILE_LOCATION); throw exc; }
#define GPSTK_RETHROW(exc) { exc.addLocation(FILE_LOCATION); throw; }
#endif



#define NEW_EXCEPTION_CLASS(child, parent) \
class child : public parent  \
{ \
public: \
 \
   child() throw()                  : parent() {} \
 \
   child(const child& a) throw()   : parent(a) {} \
 \
   child(const gpstk::Exception& a) throw() : parent(a) {}; \
 \
   child(std::string a, unsigned long b = 0,\
         gpstk::Exception::Severity c = gpstk::Exception::unrecoverable) \
         throw() \
         : parent(a, b, c) \
   {};\
 \
   ~child() throw() {} \
 \
   std::string getName() const throw() {return ( # child);} \
 \
   child& operator=(const child& kid) \
      { parent::operator=(kid); return *this; } \
 \
   friend std::ostream& operator<<(std::ostream& s, const child& c) throw() \
      { c.dump(s); return s; } \
}

namespace gpstk
{
   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);


} // namespace gpstk
#endif

---