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 : http://dar.linux.free.fr/email.html
/*********************************************************************/


#ifndef ERREURS_HPP
#define ERREURS_HPP

#include "../my_config.h"

#include <string>
#include <list>
#include "integers.hpp"

namespace libdar
{


    extern const char *dar_gettext(const char *);


    class Egeneric
    {
    public :
        Egeneric(const std::string &source, const std::string &message);
        virtual ~Egeneric() {};

        virtual void stack(const std::string & passage, const std::string & message = "") { pile.push_back(niveau(passage, message)); };


        const std::string & get_message() const { return pile.front().objet; };

        const std::string & get_source() const { return pile.front().lieu; };


        const std::string & find_object(const std::string & location) const;

        void prepend_message(const std::string & context);

        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;

        static const std::string empty_string;
    };



    class Ememory : public Egeneric
    {
    public:
        Ememory(const std::string &source) : Egeneric(source, dar_gettext("Lack of Memory")) {};

    protected:
        Ememory(const std::string &source, const std::string & message) : Egeneric(source, message) {};
        std::string exceptionID() const { return "MEMORY"; };
    };


    class Esecu_memory : public Ememory
    {
    public:
        Esecu_memory(const std::string &source) : Ememory(source, dar_gettext("Lack of Secured Memory")) {};

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


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

    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"; };
    };


    class Einfinint : public Egeneric
    {
    public :
        Einfinint(const std::string & source, const std::string & message) : Egeneric(source, message) {};

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


    class Elimitint : public Egeneric
    {
    public :
        Elimitint() : Egeneric("", dar_gettext("Cannot handle such a too large integer. Use a full version of libdar (compiled to rely on the \"infinint\" integer type) to solve this problem")) {};

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


    class Erange : public Egeneric
    {
    public :
        Erange(const std::string & source, const std::string & message) : Egeneric(source, message) {};

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


    class Edeci : public Egeneric
    {
    public :
        Edeci(const std::string & source, const std::string & message) : Egeneric(source, message) {};

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


    class Efeature : public Egeneric
    {
    public :
        Efeature(const std::string & message) : Egeneric("", message) {};

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


    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"; };
    };


    class Euser_abort : public Egeneric
    {
    public :
        Euser_abort(const std::string & msg) : Egeneric("",msg) {};

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



    class Edata : public Egeneric
    {
    public :
        Edata(const std::string & msg) : Egeneric("", msg) {};

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


    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"; };
    };


    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"; };
    };


    class Ecompilation : public Egeneric
    {
    public :
        Ecompilation(const std::string & msg) : Egeneric("" ,msg) {};

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



    class Ethread_cancel : public Egeneric
    {
    public:
        Ethread_cancel(bool now, U_64 x_flag) : Egeneric("", now ? dar_gettext("Thread cancellation requested, aborting as soon as possible") : dar_gettext("Thread cancellation requested, aborting as properly as possible")) { immediate = now; flag = x_flag; };

        bool immediate_cancel() const { return immediate; };
        U_64 get_flag() const { return flag; };

    protected:
        std::string exceptionID() const { return "THREAD CANCELLATION REQUESTED, ABORTING"; };

    private:
        bool immediate;
        U_64 flag;
    };



} // end of namespace

#endif