statistics.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 STATISTICS_HPP
#define STATISTICS_HPP
 
#include "../my_config.h"
 
#include "infinint.hpp"
#include "user_interaction.hpp"
#include "deci.hpp"
 
extern "C"
{
#if MUTEX_WORKS
#if HAVE_PTHREAD_H
#include <pthread.h>
#endif
#endif
}
 
 
#if MUTEX_WORKS
#define LOCK_IN pthread_mutex_lock(&lock_mutex)
#define LOCK_OUT pthread_mutex_unlock(&lock_mutex)
#define LOCK_IN_CONST pthread_mutex_lock(const_cast<pthread_mutex_t *>(&lock_mutex))
#define LOCK_OUT_CONST pthread_mutex_unlock(const_cast<pthread_mutex_t *>(&lock_mutex))
#else
#define LOCK_IN //
#define LOCK_OUT //
#define LOCK_IN_CONST //
#define LOCK_OUT_CONST //
#endif
 
namespace libdar
{
 
 
 
    class statistics
    {
    public:
 
    statistics(bool lock = true) { init(lock); clear(); };
 
    statistics(const statistics & ref) { copy_from(ref); };
 
    statistics(statistics && ref) { init(false); move_from(std::move(ref)); };
 
    statistics & operator = (const statistics & ref) { detruit(); copy_from(ref); return *this; };
 
    statistics & operator = (statistics && ref) noexcept { move_from(std::move(ref)); return *this; };
 
    ~statistics() { detruit(); };
 
        void clear();
 
        infinint total() const;
 
    void incr_treated() { (this->*increment)(&treated); };
 
    void incr_hard_links() { (this->*increment)(&hard_links); };
 
    void incr_skipped() { (this->*increment)(&skipped); };
 
    void incr_inode_only() { (this->*increment)(&inode_only); };
 
    void incr_ignored() { (this->*increment)(&ignored); };
 
    void incr_tooold() { (this->*increment)(&tooold); };
 
    void incr_errored() { (this->*increment)(&errored); };
 
    void incr_deleted() { (this->*increment)(&deleted); };
 
    void incr_ea_treated() { (this->*increment)(&ea_treated); };
 
    void incr_fsa_treated() { (this->*increment)(&fsa_treated); };
 
    void add_to_ignored(const infinint & val) { (this->*add_to)(&ignored, val); };
 
    void add_to_errored(const infinint & val) { (this->*add_to)(&errored, val); };
 
    void add_to_deleted(const infinint & val) { (this->*add_to)(&deleted, val); };
 
    void add_to_byte_amount(const infinint & val) { (this->*add_to)(&byte_amount, val); };
 
    void sub_from_treated(const infinint & val) { (this->*sub_from)(&treated, val); };
 
    void sub_from_ea_treated(const infinint & val) { (this->*sub_from)(&ea_treated, val); };
 
    void sub_from_hard_links(const infinint & val) { (this->*sub_from)(&hard_links, val); };
 
    void sub_from_fsa_treated(const infinint & val) { (this->*sub_from)(&fsa_treated, val); };
 
        // getting methods returning infinint
 
    infinint get_treated() const { return (this->*returned)(&treated); };
 
    infinint get_hard_links() const { return (this->*returned)(&hard_links); };
 
    infinint get_skipped() const { return (this->*returned)(&skipped); };
 
    infinint get_inode_only() const { return (this->*returned)(&inode_only); };
 
    infinint get_ignored() const { return (this->*returned)(&ignored); };
 
    infinint get_tooold() const { return (this->*returned)(&tooold); };
 
    infinint get_errored() const { return (this->*returned)(&errored); };
 
    infinint get_deleted() const { return (this->*returned)(&deleted); };
 
    infinint get_ea_treated() const { return (this->*returned)(&ea_treated); };
 
    infinint get_byte_amount() const { return (this->*returned)(&byte_amount); };
 
    infinint get_fsa_treated() const { return (this->*returned)(&fsa_treated); };
 
        // now the _str() variant returning std::string
 
    std::string get_treated_str() const { return deci(get_treated()).human(); };
 
    std::string get_hard_links_str() const { return deci(get_hard_links()).human(); };
 
    std::string get_skipped_str() const { return deci(get_skipped()).human(); };
 
    std::string get_inode_only_str() const { return deci(get_inode_only()).human(); };
 
    std::string get_ignored_str() const { return deci(get_ignored()).human();};
 
    std::string get_tooold_str() const { return deci(get_tooold()).human(); };
 
    std::string get_errored_str() const { return deci(get_errored()).human(); };
 
    std::string get_deleted_str() const { return deci(get_deleted()).human(); };
 
    std::string get_ea_treated_str() const { return deci(get_ea_treated()).human(); };
 
    std::string get_byte_amount_str() const { return deci(get_byte_amount()).human(); };
 
    std::string get_fsa_treated_str() const { return deci(get_fsa_treated()).human(); };
 
 
    void decr_treated() { (this->*decrement)(&treated); };
 
    void decr_hard_links() { (this->*decrement)(&hard_links); };
 
    void decr_skipped() { (this->*decrement)(&skipped); };
 
    void decr_inode_only() { (this->*decrement)(&inode_only); };
 
    void decr_ignored() { (this->*decrement)(&ignored); };
 
    void decr_tooold() { (this->*decrement)(&tooold); };
 
    void decr_errored() { (this->*decrement)(&errored); };
 
    void decr_deleted() { (this->*decrement)(&deleted); };
 
    void decr_ea_treated() { (this->*decrement)(&ea_treated); };
 
    void decr_fsa_treated() { (this->*decrement)(&fsa_treated); }
 
    void set_byte_amount(const infinint & val) { (this->*set_to)(&byte_amount, val); };
 
    void dump(user_interaction & dialog) const;
 
    private:
#if MUTEX_WORKS
    pthread_mutex_t lock_mutex;
#endif
    bool locking;
 
        infinint treated;
        infinint hard_links;
        infinint skipped;
    infinint inode_only;
        infinint ignored;
        infinint tooold;
        infinint errored;
        infinint deleted;
        infinint ea_treated;
    infinint byte_amount;
    infinint fsa_treated;
 
 
    void (statistics::*increment)(infinint * var);                    
    void (statistics::*add_to)(infinint * var, const infinint & val); 
    infinint (statistics::*returned)(const infinint * var) const;     
    void (statistics::*decrement)(infinint * var);                    
    void (statistics::*set_to)(infinint * var, const infinint & val); 
    void (statistics::*sub_from)(infinint *var, const infinint & val);
 
    void increment_locked(infinint * var)
    {
        LOCK_IN;
        (*var)++;
        LOCK_OUT;
    };
 
    void increment_unlocked(infinint * var)
    {
        (*var)++;
    }
 
    void add_to_locked(infinint * var, const infinint & val)
    {
        LOCK_IN;
        (*var) += val;
        LOCK_OUT;
    }
 
    void add_to_unlocked(infinint *var, const infinint & val)
    {
        (*var) += val;
    }
 
    infinint returned_locked(const infinint * var) const
    {
        infinint ret;
 
        LOCK_IN_CONST;
        ret = *var;
        LOCK_OUT_CONST;
 
        return ret;
    };
 
    infinint returned_unlocked(const infinint * var) const
    {
        return *var;
    };
 
    void decrement_locked(infinint * var)
    {
        LOCK_IN;
        (*var)--;
        LOCK_OUT;
    }
 
    void decrement_unlocked(infinint * var)
    {
        (*var)--;
    }
 
    void set_to_locked(infinint *var, const infinint & val)
    {
        LOCK_IN;
        (*var) = val;
        LOCK_OUT;
    }
 
    void set_to_unlocked(infinint *var, const infinint & val)
    {
        *var = val;
    }
 
    void sub_from_unlocked(infinint *var, const infinint & val)
    {
        *var -= val;
    }
 
    void sub_from_locked(infinint *var, const infinint & val)
    {
        LOCK_IN;
        *var -= val;
        LOCK_OUT;
    }
 
    void init(bool lock);
 
    void detruit();
 
    void copy_from(const statistics & ref);
 
    void move_from(statistics && ref) noexcept;
 
    };
 
 
 
} // end of namespace
 
#endif