zypp/DiskUsage.h

   1 /*---------------------------------------------------------------------\
   2 |                          ____ _   __ __ ___                          |
   3 |                         |__  / \ / / . \ . \                         |
   4 |                           / / \ V /|  _/  _/                         |
   5 |                          / /__ | | | | | |                           |
   6 |                         /_____||_| |_| |_|                           |
   7 |                                                                      |
   8 \---------------------------------------------------------------------*/
   9 /** \file       zypp/DiskUsage.h
  10  *
  11 */
  12 #ifndef ZYPP_DISKUSAGE_H
  13 #define ZYPP_DISKUSAGE_H
  14
  15 #include <set>
  16 #include <string>
  17
  18 ///////////////////////////////////////////////////////////////////
  19 namespace zypp
  20 { /////////////////////////////////////////////////////////////////
  21
  22   class DiskUsage {
  23   public:
  24     /**
  25     * @short Holds data about how much space will be needed per directory.
  26     **/
  27     struct Entry {
  28       Entry() : _size(0), _files(0) {};
  29       Entry(const std::string& path_r,
  30               const unsigned size_r = 0,
  31               const unsigned files_r = 0)
  32       : path(path_r), _size(size_r), _files(files_r)
  33       {
  34         // assert leading and trailing '/'
  35         if ( ! path.empty() )
  36         {
  37           if ( *path.begin() != '/' ) path.insert( path.begin(), '/' );
  38           if ( *path.rbegin() != '/' ) path.insert( path.end(), '/' );
  39         }
  40       }
  41       std::string path;
  42       mutable unsigned _size;
  43       mutable unsigned _files;
  44       friend std::ostream & operator<<( std::ostream & str, const Entry & obj );
  45       /**
  46        * Test for equality based on directory name.
  47        **/
  48       bool operator==( const Entry & rhs ) const {
  49         return  path == rhs.path;
  50       }
  51       /**
  52        * Order based on directory name.
  53        **/
  54       bool operator<( const Entry & rhs ) const {
  55         return  path < rhs.path;
  56       }
  57       /**
  58        * Return true if this entry denotes a directory equal to or below rhs._dirname.
  59        **/
  60       bool isBelow( const Entry & rhs ) const {
  61         // whether _dirname has prefix rhs._dirname
  62         return( path.compare( 0, rhs.path.size(), rhs.path ) == 0 );
  63       }
  64       /**
  65        * Return true if this entry denotes a directory equal to or below dirname_r.
  66        **/
  67       bool isBelow( const std::string & dirname_r ) const {
  68         return  isBelow( Entry( dirname_r ) );
  69       }
  70
  71       /**
  72        * Numerical operation based on size and files values.
  73        **/
  74       const Entry & operator+=( const Entry & rhs ) const {
  75         _size  += rhs._size;
  76         _files += rhs._files;
  77         return *this;
  78       }
  79       /**
  80        * Numerical operation based on size and files values.
  81        **/
  82       const Entry & operator-=( const Entry & rhs ) const {
  83         _size  -= rhs._size;
  84         _files -= rhs._files;
  85         return *this;
  86       }
  87     };
  88   private:
  89     typedef std::set<Entry> EntrySet;
  90     EntrySet _dirs;
  91   public:
  92
  93     DiskUsage() {};
  94    /**
  95      * Add an entry. If already present, sum up the new entries size and files value.
  96      **/
  97     void add( const Entry & newent_r ) {
  98       std::pair<EntrySet::iterator,bool> res = _dirs.insert( newent_r );
  99       if ( !res.second ) {
 100         *res.first += newent_r;
 101       }
 102     }
 103    /**
 104      * Add an entry. If already present, sum up the new entries size and files value.
 105      **/
 106     void add( const std::string & dirname_r, const unsigned & size_r = 0, const unsigned & files_r = 0 ) {
 107       add( Entry( dirname_r, size_r, files_r ) );
 108     }
 109     /**
 110      * Whether there is no entry available.
 111      */
 112     bool empty() const { return _dirs.empty(); }
 113     /**
 114      * Number of entries
 115      **/
 116     unsigned size() const { return _dirs.size(); }
 117     /**
 118      * Clear EntrySet
 119      **/
 120     void clear() { _dirs.clear(); }
 121     /**
 122      * Sum up any entries for dirname_r and its descendants and remove them
 123      * on the fly. Return the result.
 124      **/
 125     Entry extract( const std::string & dirname_r );
 126
 127   public:
 128
 129     typedef EntrySet::iterator               iterator;
 130     typedef EntrySet::reverse_iterator       reverse_iterator;
 131
 132     /**
 133      * Forward iterator pointing to the first entry (if any)
 134      **/
 135     iterator begin() { return _dirs.begin(); }
 136     /**
 137      * Forward iterator pointing behind the last entry.
 138      **/
 139     iterator end() { return _dirs.end(); }
 140     /**
 141      * Reverse iterator pointing to the last entry (if any)
 142      **/
 143     reverse_iterator rbegin() { return _dirs.rbegin(); }
 144     /**
 145      * Reverse iterator pointing before the first entry.
 146      **/
 147     reverse_iterator rend() { return _dirs.rend(); }
 148
 149     typedef EntrySet::const_iterator         const_iterator;
 150     typedef EntrySet::const_reverse_iterator const_reverse_iterator;
 151
 152     /**
 153      * Forward const iterator pointing to the first entry (if any)
 154      **/
 155     const_iterator begin() const { return _dirs.begin(); }
 156     /**
 157      * Forward const iterator pointing behind the last entry.
 158      **/
 159     const_iterator end() const { return _dirs.end(); }
 160     /**
 161      * Reverse const iterator pointing to the last entry (if any)
 162      **/
 163     const_reverse_iterator rbegin() const { return _dirs.rbegin(); }
 164     /**
 165      * Reverse const iterator pointing before the first entry.
 166      **/
 167     const_reverse_iterator rend()const { return _dirs.rend(); }
 168
 169   public:
 170
 171     friend std::ostream & operator<<( std::ostream & str, const DiskUsage & obj );
 172
 173   };
 174   ///////////////////////////////////////////////////////////////////
 175   /////////////////////////////////////////////////////////////////
 176 } // namespace zypp
 177 ///////////////////////////////////////////////////////////////////
 178 #endif // ZYPP_DISKUSAGE_H