Logo Search packages:      
Sourcecode: dar version File versions

erreurs.hpp

Go to the documentation of this file.
/*********************************************************************/
// dar - disk archive - a backup/restoration program
// Copyright (C) 2002-2052 Denis Corbin
//
// This program 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.
//
// This program 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 this program; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
//
// to contact the author : dar.linux@free.fr
/*********************************************************************/
// $Id: erreurs.hpp,v 1.14 2004/11/07 18:21:38 edrusb Rel $
//
/*********************************************************************/

    /// \file erreurs.hpp
    /// \brief contains all the excetion class thrown by libdar


#ifndef ERREURS_HPP
#define ERREURS_HPP

#include "../my_config.h"
#include <string>
#include <list>
#include "integers.hpp"

namespace libdar
{

#define E_BEGIN try {
#define E_END(passage, message)  } catch(Egeneric & e) { e.stack(passage, message); throw; }

      /// \addtogroup API
      /// @{

      /// this is the parent class of all exception classes.

      /// this is a pure virtual class that provide some simple
      /// mechanisme to carry the information about the cause of the exception,
      /// as well as some a complex mechanim which not used often in libdar
      /// that keep trace, for each exception throwing process, of the different
      /// calls by which the current exception has been exiting.
00053     class Egeneric
    {
    public :
          /// the constructor
        Egeneric(const std::string &source, const std::string &message);
          /// copy constructor
00059         Egeneric(const Egeneric & ref) { pile = ref.pile; };
          /// the destructor
00061         virtual ~Egeneric() {};

          /// rarely used mechanism to keep trace of calls the exception has been exiting from
00064         virtual void stack(const std::string & passage, const std::string & message = "") { pile.push_back(niveau(passage, message)); };

          /// get the message explaing the nature of the exception

          /// This is probably the only method you will use for all the
          /// the exception, as you will not have to create such objects
          /// and will only need to get the error message thanks to this
          /// method
00072         std::string get_message() const { return pile.front().objet; };

          /// get the call function which has thrown this exception
00075       std::string get_source() const { return pile.front().lieu; };

          /// dump all information of the exception to the standard error
        void dump() const;

    protected :
        virtual std::string exceptionID() const = 0;

    private :
        struct niveau
        {
            niveau(const std::string &ou, const std::string &quoi) { lieu = ou; objet = quoi; };
            std::string lieu, objet;
        };

        std::list<niveau> pile;
    };


      /// exception used when memory has been exhausted

      /// the inherited get_message() method is probably
      /// the only one you will need to use
00098     class Ememory : public Egeneric
    {
    public:
        Ememory(const std::string &source) : Egeneric(source, gettext("Lack of Memory")) {};

    protected :
        std::string exceptionID() const { return "MEMORY"; };
    };

#define SRC_BUG Ebug(__FILE__, __LINE__)
#define XMT_BUG(exception, call) exception.stack(call, __FILE__, __LINE__)

      /// exception used to signal a bug. A bug is triggered when reaching some code that should never be reached
00111     class Ebug : public Egeneric
    {
    public :
        Ebug(const std::string & file, S_I line);

        void stack(const std::string & passage, const std::string & file, const std::string & line);

    protected :
        std::string exceptionID() const { return "BUG"; };
    };

      /// exception used when arithmetic error is detected when operating on infinint

      /// the inherited get_message() method is probably
      /// the only one you will need to use
00126     class Einfinint : public Egeneric
    {
    public :
        Einfinint(const std::string & source, const std::string & message) : Egeneric(source, message) {};

    protected :
        std::string exceptionID() const { return "INFININT"; };
    };

      /// exception used when a limitint overflow is detected, the maximum value of the limitint has been exceeded

      /// the inherited get_message() method is probably
      /// the only one you will need to use
00139     class Elimitint : public Egeneric
    {
    public :
        Elimitint() : Egeneric("", gettext("cannot handle a too large integer. Use full version of dar_suite programs (compilation option set for using infinint) to solve this problem")) {};

    protected :
        std::string exceptionID() const { return "LIMITINT"; };
    };

      /// exception used to signal range error

      /// the inherited get_message() method is probably
      /// the only one you will need to use
00152     class Erange : public Egeneric
    {
    public :
        Erange(const std::string & source, const std::string & message) : Egeneric(source, message) {};

    protected :
        std::string exceptionID() const { return "RANGE"; };
    };

      /// exception used to signal convertion problem between infinint and string (decimal representation)

      /// the inherited get_message() method is probably
      /// the only one you will need to use
      /// see also the class deci
00166     class Edeci : public Egeneric
    {
    public :
        Edeci(const std::string & source, const std::string & message) : Egeneric(source, message) {};

    protected :
        std::string exceptionID() const { return "DECI"; };
    };

      /// exception used when a requested feature is not (yet) implemented

      /// the inherited get_message() method is probably
      /// the only one you will need to use
00179     class Efeature : public Egeneric
    {
    public :
        Efeature(const std::string & message) : Egeneric("", message) {};

    protected :
        std::string exceptionID() const { return "UNIMPLEMENTED FEATURE"; };
    };

      /// exception used when hardware problem is found

      /// the inherited get_message() method is probably
      /// the only one you will need to use
00192     class Ehardware : public Egeneric
    {
    public :
        Ehardware(const std::string & source, const std::string & message) : Egeneric(source, message) {};

    protected :
        std::string exceptionID() const { return "HARDWARE ERROR"; };
    };

      /// exception used to signal that the user has aborted the operation

      /// the inherited get_message() method is probably
      /// the only one you will need to use
00205     class Euser_abort : public Egeneric
    {
    public :
        Euser_abort(const std::string & msg) : Egeneric("",msg) {};

    protected :
        std::string exceptionID() const { return "USER ABORTED OPERATION"; };
    };

      /// exception used when an error concerning the treated data has been met

      /// the inherited get_message() method is probably
      /// the only one you will need to use
00218     class Edata : public Egeneric
    {
    public :
        Edata(const std::string & msg) : Egeneric("", msg) {};

    protected :
        std::string exceptionID() const { return "ERROR IN TREATED DATA"; };
    };

      /// exception used when error the inter-slice user command returned an error code

      /// the inherited get_message() method is probably
      /// the only one you will need to use
00231     class Escript : public Egeneric
    {
    public :
        Escript(const std::string & source, const std::string & msg) : Egeneric(source ,msg) {};

    protected :
        std::string exceptionID() const { return "USER ABORTED OPERATION"; };
    };

      /// exception used to signal an error in the argument given to libdar call of the API

      /// the inherited get_message() method is probably
      /// the only one you will need to use
00244     class Elibcall : public Egeneric
    {
    public :
        Elibcall(const std::string & source, const std::string & msg) : Egeneric(source ,msg) {};

    protected :
        std::string exceptionID() const { return "USER ABORTED OPERATION"; };
    };

      /// exception used when a requested fearture has not beed activated at compilation time

      /// the inherited get_message() method is probably
      /// the only one you will need to use
00257     class Ecompilation : public Egeneric
    {
    public :
        Ecompilation(const std::string & msg) : Egeneric("" ,msg) {};

    protected :
        std::string exceptionID() const { return "FEATURE DISABLED AT COMPILATION TIME"; };
    };

      /// @}

} // end of namespace

#endif

Generated by  Doxygen 1.6.0   Back to index