exceptions.h

Go to the documentation of this file.

// This file is part of HermesCommon
//
// Copyright (c) 2009 hp-FEM group at the University of Nevada, Reno (UNR).
// Email: hpfem-group@unr.edu, home page: http://www.hpfem.org/.
//
// Hermes2D is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published
// by the Free Software Foundation; either version 2 of the License,
// or (at your option) any later version.
//
// Hermes2D 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 General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with Hermes2D; if not, write to the Free Software
// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
#ifndef __HERMES_COMMON_EXCEPTIONS_H_
#define __HERMES_COMMON_EXCEPTIONS_H_

#include "common.h"
#include "util/compat.h"

#ifndef _DEBUG
#undef assert
#define assert(x)
#endif

namespace Hermes
{
  namespace Exceptions
  {
    class HERMES_API Exception : public std::exception
    {
    public:
      Exception();
      Exception(const Exception& e);
      Exception(const char * msg, ...);
      void print_msg() const;
      virtual const char * what() const throw();
      std::string info() const;
      const char * get_func_name() const;
      virtual ~Exception() throw() {};

    protected:
      std::stringstream message;
      char message_char[10000];
    };

    class HERMES_API IOException : public Exception
    {
    public:
      enum ReadWrite
      {
        Read,
        Write
      };
      IOException(ReadWrite readWrite, const char* filename);
      IOException(ReadWrite readWrite, std::string filename);

      virtual ~IOException() throw() {};
      IOException(const IOException & e);
    private:
      ReadWrite readWrite;
      std::string filename;
    };

    class HERMES_API NullException : public Exception
    {
    public:
      NullException();
      NullException(unsigned int param_idx);
      NullException(unsigned int param_idx, unsigned int item_idx);
      unsigned int get_param_idx() const;
      unsigned int get_item_idx() const;
      virtual ~NullException() throw() {};
      NullException(const NullException & e);
    private:
      unsigned int param_idx, item_idx;
    };

    class HERMES_API LengthException : public Exception
    {
    public:
      LengthException();
      LengthException(unsigned int wrong, unsigned int right);
      LengthException(unsigned int param_idx, unsigned int wrong, unsigned int right);
      LengthException(unsigned int fst_param_idx, unsigned int snd_param_idx, unsigned int first, unsigned int second);
      unsigned int get_first_param_idx() const;
      unsigned int get_second_param_idx() const;
      unsigned int get_first_length() const;
      unsigned int get_expected_length() const;
      virtual ~LengthException() throw() {};
      LengthException(const LengthException & e);
    private:
      unsigned int fst_param_idx, snd_param_idx, wrong, right;
    };

    class HERMES_API LinearMatrixSolverException : public Exception
    {
    public:
      LinearMatrixSolverException();
      LinearMatrixSolverException(const char * reason, ...);
      virtual ~LinearMatrixSolverException() throw() {};
      LinearMatrixSolverException(const LinearMatrixSolverException & e);
    };

    class HERMES_API ValueException : public Exception
    {
    public:
      ValueException(const char * name, double value, double allowed);
      ValueException(const char * name, double value, double min, double max);
      ValueException(const char * name, std::string passed);
      double get_value() const;
      double get_allowed() const;
      virtual ~ValueException() throw() {};
      ValueException(const ValueException & e);
    private:
      double value, allowed;
    };

    class HERMES_API MethodNotOverridenException : public Exception
    {
    public:
      MethodNotOverridenException(const char * msg, ...);
      virtual  ~MethodNotOverridenException() throw() {};
      MethodNotOverridenException(const MethodNotOverridenException & e);
    };

    class HERMES_API MethodNotImplementedException : public Exception
    {
    public:
      MethodNotImplementedException(const char * msg, ...);
      virtual ~MethodNotImplementedException() throw() {};
      MethodNotImplementedException(const MethodNotImplementedException & e);
    };

    class HERMES_API MeshLoadFailureException : public Exception
    {
    public:
      MeshLoadFailureException(const char * msg, ...);
      ~MeshLoadFailureException() throw() {};
      MeshLoadFailureException(const MeshLoadFailureException & e);
    };

    class HERMES_API SpaceLoadFailureException : public Exception
    {
    public:
      SpaceLoadFailureException(const char * msg, ...);
      virtual ~SpaceLoadFailureException() throw() {};
      SpaceLoadFailureException(const SpaceLoadFailureException & e);
    };

    class HERMES_API SolutionSaveFailureException : public Exception
    {
    public:
      SolutionSaveFailureException(const char * msg, ...);
      virtual ~SolutionSaveFailureException() throw() {};
      SolutionSaveFailureException(const SolutionSaveFailureException & e);
    };

    class HERMES_API SolutionLoadFailureException : public Exception
    {
    public:
      SolutionLoadFailureException(const char * msg, ...);
      virtual ~SolutionLoadFailureException() throw() {};
      SolutionLoadFailureException(const SolutionLoadFailureException & e);
    };
  }
}
#endif