DiskUsageCounter.h

Go to the documentation of this file.

/*---------------------------------------------------------------------\
|                          ____ _   __ __ ___                          |
|                         |__  / \ / / . \ . \                         |
|                           / / \ V /|  _/  _/                         |
|                          / /__ | | | | | |                           |
|                         /_____||_| |_| |_|                           |
|                                                                      |
\---------------------------------------------------------------------*/
#ifndef ZYPP_DISKUSAGE_COUNTER_H
#define ZYPP_DISKUSAGE_COUNTER_H
 
#include <set>
#include <string>
#include <iosfwd>
 
#include <zypp/ResPool.h>
#include <zypp/Bitmap.h>
#include <zypp/base/Flags.h>
 
namespace zypp
{ 
 
  class DiskUsageCounter
  {
 
  public:
    struct MountPoint
    {
      friend std::ostream & operator<<( std::ostream & str, const MountPoint & obj );
      std::string dir;                  
      std::string fstype;               
      long long block_size;             
      long long total_size;             
      long long used_size;              
      mutable long long pkg_size;       
      // hint bits:
      bool readonly:1;                  
      bool growonly:1;                  
 
 
      enum Hint
      {
        NoHint          = 0,
        Hint_readonly   = (1<<0),       
        Hint_growonly   = (1<<1),       
      };
      ZYPP_DECLARE_FLAGS(HintFlags,Hint);
 
      MountPoint( const std::string & d = "/",
                  const std::string & f = std::string(),
                  long long bs = 0LL, long long total = 0LL, long long used = 0LL, long long pkg = 0LL,
                  HintFlags hints = NoHint )
        : dir(d), fstype(f)
        , block_size(bs), total_size(total), used_size(used), pkg_size(pkg)
        , readonly(hints.testFlag(Hint_readonly))
        , growonly(hints.testFlag(Hint_growonly))
      {}
      MountPoint( const char * d,
                  const std::string & f = std::string(),
                  long long bs = 0LL, long long total = 0LL, long long used = 0LL, long long pkg = 0LL,
                  HintFlags hints = NoHint )
        : MountPoint( std::string(d?d:""), f, bs, total, used, pkg, hints )
      {}
 
 
      MountPoint( const std::string & d,
                  long long bs, long long total = 0LL, long long used = 0LL, long long pkg = 0LL,
                  HintFlags hints = NoHint )
        : MountPoint( d, std::string(), bs, total, used, pkg, hints )
      {}
      MountPoint( const char * d,
                  long long bs, long long total = 0LL, long long used = 0LL, long long pkg = 0LL,
                  HintFlags hints = NoHint )
        : MountPoint( std::string(d?d:""), bs, total, used, pkg, hints )
      {}
 
 
      MountPoint( const std::string & d, HintFlags hints )
        : MountPoint( d, std::string(), 0LL, 0LL, 0LL, 0LL, hints )
      {}
      MountPoint( const char * d, HintFlags hints )
        : MountPoint( std::string(d?d:""), hints )
      {}
      MountPoint( const std::string & d, Hint hint )
        : MountPoint( d, HintFlags(hint) )
      {}
      MountPoint( const char * d, Hint hint )
        : MountPoint( std::string(d?d:""), HintFlags(hint) )
      {}
 
      bool operator<( const MountPoint & rhs ) const
      { return dir < rhs.dir; }
 
      ByteCount blockSize() const
      { return ByteCount( block_size, ByteCount::B ); }
 
      ByteCount totalSize() const
      { return ByteCount( total_size, ByteCount::K ); }
 
      ByteCount usedSize() const
      { return ByteCount( used_size, ByteCount::K ); }
 
      ByteCount freeSize() const
      { return ByteCount( total_size-used_size, ByteCount::K ); }
 
      ByteCount usedAfterCommit() const
      { return ByteCount( pkg_size, ByteCount::K ); }
 
      ByteCount freeAfterCommit() const
      { return ByteCount( total_size-pkg_size, ByteCount::K ); }
 
      ByteCount commitDiff() const
      { return ByteCount( pkg_size-used_size, ByteCount::K ); }
    };
 
    typedef std::set<MountPoint> MountPointSet;
 
    DiskUsageCounter()
    {}
 
    DiskUsageCounter( const MountPointSet & mps_r )
    : _mps( mps_r )
    {}
 
    void setMountPoints( const MountPointSet & mps_r )
    { _mps = mps_r; }
 
    const MountPointSet & getMountPoints() const
    { return _mps; }
 
    static MountPointSet detectMountPoints( const std::string & rootdir = "/" );
 
    static MountPointSet justRootPartition();
 
 
    MountPointSet disk_usage( const ResPool & pool ) const;
 
    MountPointSet disk_usage( sat::Solvable solv_r ) const;
    MountPointSet disk_usage( const PoolItem & pi_r  ) const
    { return disk_usage( sat::asSolvable()( pi_r ) ); }
    MountPointSet disk_usage( const ResObject::constPtr & obj_r ) const
    { return disk_usage( sat::asSolvable()( obj_r ) ); }
 
    MountPointSet disk_usage( const Bitmap & bitmap_r ) const;
 
    template<class Iterator>
    MountPointSet disk_usage( Iterator begin_r, Iterator end_r ) const
    {
      Bitmap bitmap( Bitmap::poolSize );
      for_( it, begin_r, end_r )
        bitmap.set( sat::asSolvable()( *it ).id() );
      return disk_usage( bitmap );
    }
 
  private:
    MountPointSet _mps;
  };
 
  ZYPP_DECLARE_OPERATORS_FOR_FLAGS(DiskUsageCounter::MountPoint::HintFlags);
 
  std::ostream & operator<<( std::ostream & str, const DiskUsageCounter::MountPoint & obj );
 
  std::ostream & operator<<( std::ostream & str, const DiskUsageCounter::MountPointSet & obj );
 
  inline std::ostream & operator<<( std::ostream & str, const DiskUsageCounter & obj )
  { return str << obj.getMountPoints(); }
 
} // namespace zypp
#endif // ZYPP_DISKUSAGE_COUNTER_H