exception.hpp

Go to the documentation of this file.

// FEAT3: Finite Element Analysis Toolbox, Version 3
// Copyright (C) 2010 by Stefan Turek & the FEAT group
// FEAT3 is released under the GNU General Public License version 3,
// see the file 'copyright.txt' in the top level directory for details.
 
#pragma once
 
// The following line is necessary - otherwise doxygen won't document the #define's in this file.
// includes, FEAT
#include <kernel/base_header.hpp>
#include <kernel/util/string.hpp>
 
// includes, system
#include <iostream>
 
namespace FEAT
{
  class Exception :
    public std::exception
  {
  private:
    const String _message;
 
  protected:
    explicit Exception(const String & message_in) :
      _message(message_in)
    {
    }
 
    Exception(
        const char* const function,
        const char* const file,
        const long line,
        const String & message_in) :
      _message(stringify(file) + ":" + stringify(line) + ": in " + stringify(function) + ": " + message_in)
    {
    }
 
    Exception(const Exception &)
    {
    }
 
  public:
    virtual ~Exception() noexcept
    {
    }
 
    const String message() const
    {
      return _message;
    }
 
    virtual const char * what() const noexcept override
    {
      return _message.empty() ? std::exception::what() : _message.c_str();
    }
  }; // class Exception
 
 
  class InternalError :
    public Exception
  {
  public:
    explicit InternalError(const String & message_in) :
      Exception("Internal error: " + message_in)
    {
    }
 
    InternalError(
        const char* const function,
        const char* const file,
        const long line,
        const String & message_in) :
      Exception(function, file, line, "Internal error: " + message_in)
    {
    }
  }; // class InternalError
 
  class ParseError :
    public Exception
  {
  public:
    explicit ParseError(const String& message_in) :
      Exception("ParseError: " + message_in)
    {
    }
 
    explicit ParseError(const String& name, const String& got, const String& expect) :
      Exception("ParseError: " + name + ": expected " + expect + " but got '" + got + "'")
    {
    }
 
    virtual ~ParseError() noexcept
    {
    }
  }; // class ParseError
 
  class FileError :
    public Exception
  {
  public:
    explicit FileError(const String& message_in) :
      Exception(message_in)
    {
    }
    virtual ~FileError() noexcept
    {
    }
  }; // class FileError
 
  class FileNotFound :
    public FileError
  {
  public:
    explicit FileNotFound(const String& filename) :
      FileError("File not found: '" + filename + "'")
    {
    }
    virtual ~FileNotFound() noexcept
    {
    }
  }; // class FileNotFound
 
  class FileNotCreated :
    public FileError
  {
  public:
    explicit FileNotCreated(const String& filename) :
      FileError("Could not create file: '" + filename + "'")
    {
    }
    virtual ~FileNotCreated() noexcept
    {
    }
  }; // class FileNotCreated
 
  class SyntaxError :
    public Exception
  {
  protected:
    String _filename;
 
  public:
     explicit SyntaxError(
     String message_in,
      String filename = ""):
      Exception(message_in + (filename.empty() ? "": " in file " + filename)),
      _filename(filename)
    {
    }
 
    virtual ~SyntaxError() noexcept
    {
    }
 
    String get_filename() const
    {
      return _filename;
    }
  }; // class SyntaxError
} // namespace FEAT