statistics.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 STATISTICS_HPP
#define STATISTICS_HPP

#include "../my_config.h"

#include "infinint.hpp"
#include "user_interaction.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
{


        // are their meaning see the archive class constructor and methods documentation
    class statistics
    {
    public:

        statistics(bool lock = true) { init(lock); clear(); };
        statistics(const statistics & ref) { copy_from(ref); };
        const statistics & operator = (const statistics & ref) { detruit(); copy_from(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_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 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); };

        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_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); };  

        void decr_treated() { (this->*decrement)(&treated); };        
        void decr_hard_links() { (this->*decrement)(&hard_links); };  
        void decr_skipped() { (this->*decrement)(&skipped); };        
        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 set_byte_amount(const infinint & val) { (this->*set_to)(&byte_amount, val); }; 

            // debuging method
        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 ignored;       
        infinint tooold;        
        infinint errored;       
        infinint deleted;       
        infinint ea_treated;    
        infinint byte_amount;   


        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); // set locking & mutex
        void detruit();       // release and free the mutex
        void copy_from(const statistics & ref); // reset mutex and copy data from the object of reference

    };

} // end of namespace


#endif