DiskUsage.h

Go to the documentation of this file.

/*---------------------------------------------------------------------\
|                          ____ _   __ __ ___                          |
|                         |__  / \ / / . \ . \                         |
|                           / / \ V /|  _/  _/                         |
|                          / /__ | | | | | |                           |
|                         /_____||_| |_| |_|                           |
|                                                                      |
\---------------------------------------------------------------------*/
#ifndef ZYPP_DISKUSAGE_H
#define ZYPP_DISKUSAGE_H

#include <set>
#include <string>

namespace zypp
{ 

  class DiskUsage {
  public:
    struct Entry {
      Entry() : _size(0), _files(0) {};
      Entry(const std::string& path_r,
              const unsigned size_r = 0,
              const unsigned files_r = 0)
      : path(path_r), _size(size_r), _files(files_r)
      {
        // assert leading and trailing '/'
        if ( ! path.empty() )
        {
          if ( *path.begin() != '/' ) path.insert( path.begin(), '/' );
          if ( *path.rbegin() != '/' ) path.insert( path.end(), '/' );
        }
      }
      std::string path;
      mutable unsigned _size;
      mutable unsigned _files;
      friend std::ostream & operator<<( std::ostream & str, const Entry & obj );
      bool operator==( const Entry & rhs ) const {
        return  path == rhs.path;
      }
      bool operator<( const Entry & rhs ) const {
        return  path < rhs.path;
      }
      bool isBelow( const Entry & rhs ) const {
        // whether _dirname has prefix rhs._dirname
        return( path.compare( 0, rhs.path.size(), rhs.path ) == 0 );
      }
      bool isBelow( const std::string & dirname_r ) const {
        return  isBelow( Entry( dirname_r ) );
      }

      const Entry & operator+=( const Entry & rhs ) const {
        _size  += rhs._size;
        _files += rhs._files;
        return *this;
      }
      const Entry & operator-=( const Entry & rhs ) const {
        _size  -= rhs._size;
        _files -= rhs._files;
        return *this;
      }
    };
  private:
    typedef std::set<Entry> EntrySet;
    EntrySet _dirs;
  public:

    DiskUsage() {};
    void add( const Entry & newent_r ) {
      std::pair<EntrySet::iterator,bool> res = _dirs.insert( newent_r );
      if ( !res.second ) {
        *res.first += newent_r;
      }
    }
    void add( const std::string & dirname_r, const unsigned & size_r = 0, const unsigned & files_r = 0 ) {
      add( Entry( dirname_r, size_r, files_r ) );
    }
    bool empty() const { return _dirs.empty(); }
    unsigned size() const { return _dirs.size(); }
    void clear() { _dirs.clear(); }
    Entry extract( const std::string & dirname_r );

  public:

    typedef EntrySet::iterator               iterator;
    typedef EntrySet::reverse_iterator       reverse_iterator;

    iterator begin() { return _dirs.begin(); }
    iterator end() { return _dirs.end(); }
    reverse_iterator rbegin() { return _dirs.rbegin(); }
    reverse_iterator rend() { return _dirs.rend(); }

    typedef EntrySet::const_iterator         const_iterator;
    typedef EntrySet::const_reverse_iterator const_reverse_iterator;

    const_iterator begin() const { return _dirs.begin(); }
    const_iterator end() const { return _dirs.end(); }
    const_reverse_iterator rbegin() const { return _dirs.rbegin(); }
    const_reverse_iterator rend()const { return _dirs.rend(); }

  public:

    friend std::ostream & operator<<( std::ostream & str, const DiskUsage & obj );

  };
} // namespace zypp
#endif // ZYPP_DISKUSAGE_H