statistics.hpp

Go to the documentation of this file.
00001 //*********************************************************************/
00002 // dar - disk archive - a backup/restoration program
00003 // Copyright (C) 2002-2052 Denis Corbin
00004 //
00005 // This program is free software; you can redistribute it and/or
00006 // modify it under the terms of the GNU General Public License
00007 // as published by the Free Software Foundation; either version 2
00008 // of the License, or (at your option) any later version.
00009 //
00010 // This program is distributed in the hope that it will be useful,
00011 // but WITHOUT ANY WARRANTY; without even the implied warranty of
00012 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
00013 // GNU General Public License for more details.
00014 //
00015 // You should have received a copy of the GNU General Public License
00016 // along with this program; if not, write to the Free Software
00017 // Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
00018 //
00019 // to contact the author : dar.linux@free.fr
00020 /*********************************************************************/
00021 // $Id: statistics.hpp,v 1.11 2005/12/01 17:47:30 edrusb Rel $
00022 //
00023 /*********************************************************************/
00024 //
00025 
00028 
00029 #ifndef STATISTICS_HPP
00030 #define STATISTICS_HPP
00031 
00032 #include "../my_config.h"
00033 
00034 #include "infinint.hpp"
00035 
00036 extern "C"
00037 {
00038 #if MUTEX_WORKS
00039 #if HAVE_PTHREAD_H
00040 #include <pthread.h>
00041 #endif
00042 #endif
00043 }
00044 
00045 #if MUTEX_WORKS
00046 #define LOCK_IN pthread_mutex_lock(&lock_mutex)
00047 #define LOCK_OUT pthread_mutex_unlock(&lock_mutex)
00048 #define LOCK_IN_CONST pthread_mutex_lock(const_cast<pthread_mutex_t *>(&lock_mutex))
00049 #define LOCK_OUT_CONST pthread_mutex_unlock(const_cast<pthread_mutex_t *>(&lock_mutex))
00050 #else
00051 #define LOCK_IN //
00052 #define LOCK_OUT //
00053 #define LOCK_IN_CONST //
00054 #define LOCK_OUT_CONST //
00055 #endif
00056 
00057 namespace libdar
00058 {
00059 
00061 
00065         // are their meaning see the archive class constructor and methods documentation
00067     class statistics
00068     {
00069     public:
00071 
00077         statistics(bool lock = true) { init(lock); clear(); };
00078         statistics(const statistics & ref) { copy_from(ref); };
00079         statistics & operator = (const statistics & ref) { detruit(); copy_from(ref); return *this; };
00080 
00082         ~statistics() { detruit(); };
00083 
00085         void clear();
00086 
00088         infinint total() const;
00089 
00090         void incr_treated() { (this->*increment)(&treated); };       
00091         void incr_hard_links() { (this->*increment)(&hard_links); }; 
00092         void incr_skipped() { (this->*increment)(&skipped); };       
00093         void incr_ignored() { (this->*increment)(&ignored); };       
00094         void incr_tooold() { (this->*increment)(&tooold); };         
00095         void incr_errored() { (this->*increment)(&errored); };       
00096         void incr_deleted() { (this->*increment)(&deleted); };       
00097         void incr_ea_treated() { (this->*increment)(&ea_treated); }; 
00098 
00099         void add_to_ignored(const infinint & val) { (this->*add_to)(&ignored, val); };  
00100         void add_to_errored(const infinint & val) { (this->*add_to)(&errored, val); };  
00101         void add_to_deleted(const infinint & val) { (this->*add_to)(&deleted, val); };  
00102 
00103         infinint get_treated() const { return (this->*returned)(&treated); };     
00104         infinint get_hard_links() const { return (this->*returned)(&hard_links); }; 
00105         infinint get_skipped() const { return (this->*returned)(&skipped); };     
00106         infinint get_ignored() const { return (this->*returned)(&ignored); };     
00107         infinint get_tooold() const { return (this->*returned)(&tooold); };       
00108         infinint get_errored() const { return (this->*returned)(&errored); };     
00109         infinint get_deleted() const { return (this->*returned)(&deleted); };     
00110         infinint get_ea_treated() const { return (this->*returned)(&ea_treated); };  
00111 
00112     private:
00113 #if MUTEX_WORKS
00114         pthread_mutex_t lock_mutex;   
00115 #endif
00116         bool locking;           
00117 
00118         infinint treated;       
00119         infinint hard_links;    
00120         infinint skipped;       
00121         infinint ignored;       
00122         infinint tooold;        
00123         infinint errored;       
00124         infinint deleted;       
00125         infinint ea_treated;    
00126 
00127 
00128         void (statistics::*increment)(infinint * var);                    
00129         void (statistics::*add_to)(infinint * var, const infinint & val); 
00130         infinint (statistics::*returned)(const infinint * var) const;     
00131 
00132         void increment_locked(infinint * var)
00133         {
00134             LOCK_IN;
00135             (*var)++;
00136             LOCK_OUT;
00137         };
00138 
00139         void increment_unlocked(infinint * var)
00140         {
00141             (*var)++;
00142         }
00143 
00144         void add_to_locked(infinint * var, const infinint & val)
00145         {
00146             LOCK_IN;
00147             (*var) += val;
00148             LOCK_OUT;
00149         }
00150 
00151         void add_to_unlocked(infinint *var, const infinint & val)
00152         {
00153             (*var) += val;
00154         }
00155 
00156         infinint returned_locked(const infinint * var) const
00157         {
00158             infinint ret;
00159 
00160             LOCK_IN_CONST;
00161             ret = *var;
00162             LOCK_OUT_CONST;
00163 
00164             return ret;
00165         };
00166 
00167         infinint returned_unlocked(const infinint * var) const
00168         {
00169             return *var;
00170         };
00171 
00172         void init(bool lock); // set locking & mutex
00173         void detruit();       // release and free the mutex
00174         void copy_from(const statistics & ref); // reset mutex and copy data from the object of reference
00175 
00176     };
00177 
00178 } // end of namespace
00179 
00180 #endif

Generated on Tue Dec 7 18:54:30 2010 for Disk ARchive by  doxygen 1.5.9