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://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 "compat.h"

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

        virtual Exception* clone();
      protected:
        char * message;
    };

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

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

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

    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;
        ~ValueException() throw() {};
        ValueException(const ValueException & e);
        virtual Exception* clone();
      private:
        double value, allowed;
    };

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

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

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

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

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