exceptions.hpp

Go to the documentation of this file.

/*********************************************************************/
// libthreadar - is a library providing several C++ classes to work with threads
// Copyright (C) 2014-2025 Denis Corbin
//
// This file is part of libthreadar
//
//  libthreadar is free software: you can redistribute it and/or modify
//  it under the terms of the GNU Lesser General Public License as published by
//  the Free Software Foundation, either version 3 of the License, or
//  (at your option) any later version.
//
//  libhtreadar 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 Lesser General Public License for more details.
//
//  You should have received a copy of the GNU Lesser General Public License
//  along with libthreadar.  If not, see <http://www.gnu.org/licenses/>
//
//----
//  to contact the author: dar.linux@free.fr
/*********************************************************************/
 
#ifndef LIBTHREADAR_EXCEPTIONS_HPP
#define LIBTHREADAR_EXCEPTIONS_HPP
 
#include "config.h"
 
    // C system headers
extern "C"
{
#if HAVE_STRING_H
#include <string.h>
#endif
}
    // C++ standard headers
#include <string>
#include <vector>
#include <new>
#include <iostream>
#include <sstream>
 
    // libthreadar headers
 
namespace libthreadar
{
 
 
 
 
    class exception_base
    {
    public:
 
        exception_base(const std::string & x_msg) { msg_table.push_back(x_msg); };
 
        exception_base(const exception_base & ref) = default;
 
        exception_base(exception_base && ref) noexcept = default;
 
        exception_base & operator = (const exception_base & ref) = default;
 
        exception_base & operator = (exception_base && ref) noexcept = default;
 
        virtual ~exception_base() = default;
 
        void push_message(const std::string & x_msg) { msg_table.push_back(x_msg); };
 
 
        unsigned int size() const { return msg_table.size(); };
 
 
        const std::string & operator [](unsigned int i) const { return msg_table[i]; };
 
 
        std::string get_message(const std::string & sep) const;
 
 
        virtual exception_base *clone() const = 0;
 
    protected:
        void reset_first_message(const std::string & msg) { msg_table[0] = msg; };
 
    private:
        std::vector<std::string> msg_table;
    };
 
 
    template<class T> exception_base *cloner(void * const ptr);
 
 
    class exception_memory : public exception_base
    {
    public:
        exception_memory() : exception_base("lack of memory") {};
 
    protected:
        virtual exception_base *clone() const { return cloner<exception_memory>((void *)this); };
    };
 
    template<class T> exception_base *cloner(void * const ptr) { exception_base *ret = new (std::nothrow) T(*(reinterpret_cast<T const *>(ptr))); if(ret == nullptr) throw exception_memory(); return ret; }
 
 
#define THREADAR_BUG exception_bug(__FILE__, __LINE__)
 
 
    class exception_bug : public exception_base
    {
    public:
        exception_bug(const std::string & file, int line) : exception_base("LIBTHREADAR BUG MET IN File " + file + " line " + std::to_string(line)) {};
 
    protected:
        virtual exception_base *clone() const { return cloner<exception_bug>((void *)this); };
    };
 
 
 
    class exception_thread : public exception_base
    {
    public:
        exception_thread(const std::string & x_msg) : exception_base(x_msg) {};
 
    protected:
        virtual exception_base *clone() const { return cloner<exception_thread>((void *)this); };
    };
 
 
    class exception_system : public exception_base
    {
    public:
        exception_system(const std::string & context, int error_code);
 
    protected:
        virtual exception_base *clone() const { return cloner<exception_system>((void *)this); };
    };
 
 
    class exception_range : public exception_base
    {
    public:
        exception_range(const std::string & msg): exception_base(msg) {};
 
    protected:
        virtual exception_base *clone() const { return cloner<exception_range>((void *)this); };
    };
 
 
 
    class exception_feature : public exception_base
    {
    public:
        exception_feature(const std::string & feature_name): exception_base(std::string("Unimplemented feature: ") + feature_name) {};
 
    protected:
        virtual exception_base *clone() const { return cloner<exception_feature>((void *)this); };
    };
 
 
} // end of namespace
 
#endif