Loading...
Searching...
No Matches
erreurs.hpp
Go to the documentation of this file.
/*********************************************************************/
// dar - disk archive - a backup/restoration program
// Copyright (C) 2002-2025 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., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
//
// to contact the author, see the AUTHOR file
/*********************************************************************/
#ifndef ERREURS_HPP
#define ERREURS_HPP
#include "../my_config.h"
#include <string>
#include <deque>
#include "integers.hpp"
namespace libdar
{
extern const char *dar_gettext(const char *);
class Egeneric
{
public :
Egeneric(const std::string &source, const std::string &message);
Egeneric(const Egeneric & ref) = default;
Egeneric(Egeneric && ref) = default;
Egeneric & operator = (const Egeneric & ref) = default;
Egeneric & operator = (Egeneric && ref) noexcept = default;
virtual ~Egeneric() = default;
void stack(const std::string & passage, const std::string & message = "") { pile.push_back(niveau(passage, message)); };
void stack(const std::string && passage, const std::string && message = "") { pile.push_back(niveau(std::move(passage), std::move(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);
std::string dump_str() const;
protected :
virtual std::string exceptionID() const = 0;
private :
struct niveau
{
niveau(const std::string & ou, const std::string & quoi) { lieu = ou; objet = quoi; };
niveau(std::string && ou, std::string && quoi) { lieu = std::move(ou); objet = std::move(quoi); };
niveau(const niveau & ref) = default;
niveau(niveau && ref) noexcept = default;
niveau & operator = (const niveau & ref) = default;
niveau & operator = (niveau && ref) noexcept = default;
~niveau() = default;
std::string lieu, objet;
};
std::deque<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")) {};
Ememory(const Ememory & ref) = default;
Ememory(Ememory && ref) = default;
Ememory & operator = (const Ememory & ref) = default;
Ememory & operator = (Ememory && ref) = default;
~Ememory() = default;
protected:
Ememory(const std::string &source, const std::string & message) : Egeneric(source, message) {};
virtual std::string exceptionID() const override { return "MEMORY"; };
};
class Esecu_memory : public Ememory
{
public:
Esecu_memory(const std::string &source) : Ememory(source, dar_gettext("Lack of Secured Memory")) {};
Esecu_memory(const Esecu_memory & ref) = default;
Esecu_memory(Esecu_memory && ref) = default;
Esecu_memory & operator = (const Esecu_memory & ref) = default;
Esecu_memory & operator = (Esecu_memory && ref) = default;
~Esecu_memory() = default;
protected:
virtual std::string exceptionID() const override { 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);
Ebug(const Ebug & ref) = default;
Ebug(Ebug && ref) = default;
Ebug & operator = (const Ebug & ref) = default;
Ebug & operator = (Ebug && ref) = default;
~Ebug() = default;
using Egeneric::stack; // to avoid warning with clang
void stack(const std::string & passage, const std::string & file, const std::string & line);
protected :
virtual std::string exceptionID() const override { return "BUG"; };
};
class Einfinint : public Egeneric
{
public :
Einfinint(const std::string & source, const std::string & message) : Egeneric(source, message) {};
Einfinint(const Einfinint & ref) = default;
Einfinint(Einfinint && ref) = default;
Einfinint & operator = (const Einfinint & ref) = default;
Einfinint & operator = (Einfinint && ref) = default;
~Einfinint() = default;
protected :
virtual std::string exceptionID() const override { return "INFININT"; };
};
class Elimitint : public Egeneric
{
public :
Elimitint() : Egeneric("", dar_gettext("Cannot handle such a large integer. Use a full version of libdar (compiled to rely on the \"infinint\" integer type) to solve this problem")) {};
Elimitint(const Elimitint & ref) = default;
Elimitint(Elimitint && ref) = default;
Elimitint & operator = (const Elimitint & ref) = default;
Elimitint & operator = (Elimitint && ref) = default;
~Elimitint() = default;
protected :
virtual std::string exceptionID() const override { return "LIMITINT"; };
};
class Erange : public Egeneric
{
public :
Erange(const std::string & source, const std::string & message) : Egeneric(source, message) {};
Erange(const Erange & ref) = default;
Erange(Erange && ref) = default;
Erange & operator = (const Erange & ref) = default;
Erange & operator = (Erange && ref) = default;
~Erange() = default;
protected :
virtual std::string exceptionID() const override { return "RANGE"; };
};
class Edeci : public Egeneric
{
public :
Edeci(const std::string & source, const std::string & message) : Egeneric(source, message) {};
Edeci(const Edeci & ref) = default;
Edeci(Edeci && ref) = default;
Edeci & operator = (const Edeci & ref) = default;
Edeci & operator = (Edeci && ref) = default;
~Edeci() = default;
protected :
virtual std::string exceptionID() const override { return "DECI"; };
};
class Efeature : public Egeneric
{
public :
Efeature(const std::string & message) : Egeneric("", message) {};
Efeature(const Efeature & ref) = default;
Efeature(Efeature && ref) = default;
Efeature & operator = (const Efeature & ref) = default;
Efeature & operator = (Efeature && ref) = default;
~Efeature() = default;
protected :
virtual std::string exceptionID() const override { return "UNIMPLEMENTED FEATURE"; };
};
class Ehardware : public Egeneric
{
public :
Ehardware(const std::string & source, const std::string & message) : Egeneric(source, message) {};
Ehardware(const Ehardware & ref) = default;
Ehardware(Ehardware && ref) = default;
Ehardware & operator = (const Ehardware & ref) = default;
Ehardware & operator = (Ehardware && ref) = default;
~Ehardware() = default;
protected :
virtual std::string exceptionID() const override { return "HARDWARE ERROR"; };
};
class Euser_abort : public Egeneric
{
public :
Euser_abort(const std::string & msg) : Egeneric("",msg) {};
Euser_abort(const Euser_abort & ref) = default;
Euser_abort(Euser_abort && ref) = default;
Euser_abort & operator = (const Euser_abort & ref) = default;
Euser_abort & operator = (Euser_abort && ref) = default;
~Euser_abort() = default;
protected :
virtual std::string exceptionID() const override { return "USER ABORTED OPERATION"; };
};
class Edata : public Egeneric
{
public :
Edata(const std::string & msg) : Egeneric("", msg) {};
Edata(const Edata & ref) = default;
Edata(Edata && ref) = default;
Edata & operator = (const Edata & ref) = default;
Edata & operator = (Edata && ref) = default;
~Edata() = default;
protected :
virtual std::string exceptionID() const override { return "ERROR IN TREATED DATA"; };
};
class Escript : public Egeneric
{
public :
Escript(const std::string & source, const std::string & msg) : Egeneric(source ,msg) {};
Escript(const Escript & ref) = default;
Escript(Escript && ref) = default;
Escript & operator = (const Escript & ref) = default;
Escript & operator = (Escript && ref) = default;
~Escript() = default;
protected :
virtual std::string exceptionID() const override { return "USER ABORTED OPERATION"; };
};
class Elibcall : public Egeneric
{
public :
Elibcall(const std::string & source, const std::string & msg) : Egeneric(source ,msg) {};
Elibcall(const Elibcall & ref) = default;
Elibcall(Elibcall && ref) = default;
Elibcall & operator = (const Elibcall & ref) = default;
Elibcall & operator = (Elibcall && ref) = default;
~Elibcall() = default;
protected :
virtual std::string exceptionID() const override { return "USER ABORTED OPERATION"; };
};
class Ecompilation : public Egeneric
{
public :
Ecompilation(const std::string & msg) : Egeneric("" ,msg) {};
Ecompilation(const Ecompilation & ref) = default;
Ecompilation(Ecompilation && ref) = default;
Ecompilation & operator = (const Ecompilation & ref) = default;
Ecompilation & operator = (Ecompilation && ref) = default;
~Ecompilation() = default;
protected :
virtual std::string exceptionID() const override { 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; };
Ethread_cancel(const Ethread_cancel & ref) = default;
Ethread_cancel(Ethread_cancel && ref) = default;
Ethread_cancel & operator = (const Ethread_cancel & ref) = default;
Ethread_cancel & operator = (Ethread_cancel && ref) = default;
~Ethread_cancel() = default;
bool immediate_cancel() const { return immediate; };
U_64 get_flag() const { return flag; };
protected:
virtual std::string exceptionID() const override { return "THREAD CANCELLATION REQUESTED, ABORTING"; };
private:
bool immediate;
U_64 flag;
};
class Esystem : public Egeneric
{
public:
enum io_error
{
io_exist,
io_absent,
io_access,
io_ro_fs
};
Esystem(const std::string & source, const std::string & message, io_error code);
Esystem(const Esystem & ref) = default;
Esystem(Esystem && ref) = default;
Esystem & operator = (const Esystem & ref) = default;
Esystem & operator = (Esystem && ref) = default;
~Esystem() = default;
io_error get_code() const { return x_code; };
protected:
virtual std::string exceptionID() const override { return "SYSTEM ERROR MET"; };
private:
io_error x_code;
};
class Enet_auth : public Egeneric
{
public:
Enet_auth(const std::string & message): Egeneric("on the network", message) {};
Enet_auth(const Enet_auth & ref) = default;
Enet_auth(Enet_auth && ref) = default;
Enet_auth & operator = (const Enet_auth & ref) = default;
Enet_auth & operator = (Enet_auth && ref) = default;
~Enet_auth() = default;
protected:
virtual std::string exceptionID() const override { return "NETWORK AUTHENTICATION ERROR"; };
};
} // end of namespace
#endif
libdar::Egeneric::stack
void stack(const std::string &passage, const std::string &message="")
add more detailed couple of information to the exception
Definition erreurs.hpp:73
libdar::Egeneric::Egeneric
Egeneric(const std::string &source, const std::string &message)
the constructor
libdar::Egeneric::Egeneric
Egeneric(Egeneric &&ref)=default
move constructor
libdar::Egeneric::~Egeneric
virtual ~Egeneric()=default
the destructor
libdar::Egeneric::get_source
const std::string & get_source() const
get the call function which has thrown this exception
Definition erreurs.hpp:85
libdar::Egeneric::prepend_message
void prepend_message(const std::string &context)
prepend error message by the given string
libdar::Egeneric::dump_str
std::string dump_str() const
return a string result of the exception information dump
libdar::Egeneric::Egeneric
Egeneric(const Egeneric &ref)=default
copy constructor
libdar::Egeneric::get_message
const std::string & get_message() const
get the message explaing the nature of the exception
Definition erreurs.hpp:82
libdar::Egeneric::find_object
const std::string & find_object(const std::string &location) const
retrieve the objet (object) associated to a given "lieu" (location) from the stack
libdar::Egeneric::operator=
Egeneric & operator=(const Egeneric &ref)=default
assignment operator
libdar::Esystem
exception used to carry system error
Definition erreurs.hpp:406
libdar::Esystem::io_error
io_error
Definition erreurs.hpp:409
libdar::Esystem::io_access
@ io_access
permission denied (any mode)
Definition erreurs.hpp:412
libdar::Esystem::io_absent
@ io_absent
file does not exist (read mode)
Definition erreurs.hpp:411
libdar::Esystem::io_exist
@ io_exist
file already exists (write mode)
Definition erreurs.hpp:410
libdar::Esystem::io_ro_fs
@ io_ro_fs
read-only filesystem (write mode/read-write mode)
Definition erreurs.hpp:413
libdar::pile
stores a stack of generic_files writing/reading on each others
Definition pile.hpp:44
libdar::dar_gettext
const char * dar_gettext(const char *)
a routine to change NLS domaine forth and back for inline routines
integers.hpp
are defined here basic integer types that tend to be portable
my_config.h
include macro defined by the configure script and some specific additional ones
libdar
libdar namespace encapsulate all libdar symbols
Definition archive.hpp:47