exception.H

/*
 * This file is part of the "Archon" framework.
 * (http://files3d.sourceforge.net)
 *
 * Copyright © 2002 by Kristian Spangsege and Brian Kristiansen.
 *
 * Permission to use, copy, modify, and distribute this software and
 * its documentation under the terms of the GNU General Public License is
 * hereby granted. No representations are made about the suitability of
 * this software for any purpose. It is provided "as is" without express
 * or implied warranty. See the GNU General Public License
 * (http://www.gnu.org/copyleft/gpl.html) for more details.
 *
 * The characters in this file are ISO8859-1 encoded.
 *
 * The documentation in this file is in "Doxygen" style
 * (http://www.doxygen.org).
 */

#ifndef ARCHON_UTILITIES_EXCEPTION_H
#define ARCHON_UTILITIES_EXCEPTION_H

#include <typeinfo>
#include <exception>
#include <string>
#include <iostream>

#define ARCHON_THROW(e) \
throw e(string(__FILE__)+":"+Archon::Utilities::Exception::line(__LINE__))

#define ARCHON_THROW1(e, v) \
throw e(string(__FILE__)+":"+Archon::Utilities::Exception::line(__LINE__), (v))

#define ARCHON_THROW2(e, v, w) \
throw e(string(__FILE__)+":"+Archon::Utilities::Exception::line(__LINE__), (v), (w))

#define ARCHON_THROW3(e, v, w, x) \
throw e(string(__FILE__)+":"+Archon::Utilities::Exception::line(__LINE__), (v), (w), (x))

#define ARCHON_THROW4(e, v, w, x, y) \
throw e(string(__FILE__)+":"+Archon::Utilities::Exception::line(__LINE__), (v), (w), (x), (y))

#define ARCHON_THROW5(e, v, w, x, y, z) \
throw e(string(__FILE__)+":"+Archon::Utilities::Exception::line(__LINE__), (v), (w), (x), (y), (z))

namespace Archon
{
  namespace Utilities
  {
    using namespace std;

    struct Exception: exception
    {
      virtual ~Exception() throw() {}

      string getLocation() { return location; }

      virtual string getMessage() const throw()
      {
        return message;
      }

      typedef string (*Formatter)
        (const type_info &type, string location, string message);

      typedef bool (*InfoCatcher)(Formatter, string &);

      template<InfoCatcher C> static void terminal()
      {
        string message;
        if(!(*C)(&Exception::explainLong, message))
          message = Exception::explainLongUnknown();
        cerr << message;
        abort();
      }

      static string explainLong(const type_info &,
                                string location, string message);

      static string explainLongUnknown();

      static string explainShort(const type_info &,
                                 string location, string message);

      static string explainShortUnknown();


      static string line(long);

    protected:
      Exception() {}
      Exception(string location): location(location) {}
      Exception(string location, string message):
        location(location), message(message) {}

    private:
      string location;
      string message;
      string w;

      const char *what() const throw()
      {
        const_cast<Exception *>(this)->w = getMessage();
        return w.c_str();
      }
    };

    bool exceptionCatchInfo(Exception::Formatter format, string &result);

    struct UnexpectedException: Exception
    {
      UnexpectedException(string location, string message):
        Exception(location, message) {}

    protected:
      UnexpectedException() {}
      UnexpectedException(string location): Exception(location) {}
    };

    struct InternalException: UnexpectedException
    {
      InternalException(string location, string message):
        UnexpectedException(location, message) {}
    };

    struct ArgumentException: UnexpectedException
    {
      ArgumentException(string location, string message):
        UnexpectedException(location, message) {}
    };

    struct StateException: UnexpectedException
    {
      StateException(string location, string message):
        UnexpectedException(location, message) {}
    };

    struct ResourceException: UnexpectedException
    {
      ResourceException(string location, string message):
        UnexpectedException(location, message) {}
    };


    struct IOException: Exception
    {
      IOException(string location, string message):
        Exception(location, message) {}

    protected:
      IOException() {}
    };

    struct ParseException: virtual Exception
    {
      ParseException(string location, string message):
        Exception(location, message) {}

    protected:
      ParseException() {}
    };
  }
}

#endif // ARCHON_UTILITIES_EXCEPTION_H

---