libzypp  17.3.0
DiskUsageCounter.h
Go to the documentation of this file.
1 /*---------------------------------------------------------------------\
2 | ____ _ __ __ ___ |
3 | |__ / \ / / . \ . \ |
4 | / / \ V /| _/ _/ |
5 | / /__ | | | | | | |
6 | /_____||_| |_| |_| |
7 | |
8 \---------------------------------------------------------------------*/
12 #ifndef ZYPP_DISKUSAGE_COUNTER_H
13 #define ZYPP_DISKUSAGE_COUNTER_H
14 
15 #include <set>
16 #include <string>
17 #include <iosfwd>
18 
19 #include "zypp/ResPool.h"
20 #include "zypp/Bitmap.h"
21 #include "zypp/base/Flags.h"
22 
24 namespace zypp
25 {
26 
32  {
33 
34  public:
42  struct MountPoint
43  {
44  friend std::ostream & operator<<( std::ostream & str, const MountPoint & obj );
45  std::string dir;
46  std::string fstype;
47  long long block_size;
48  long long total_size;
49  long long used_size;
50  mutable long long pkg_size;
51  // hint bits:
52  bool readonly:1;
53  bool growonly:1;
54 
55 
57  enum Hint
58  {
59  NoHint = 0,
60  Hint_readonly = (1<<0),
61  Hint_growonly = (1<<1),
62  };
63  ZYPP_DECLARE_FLAGS(HintFlags,Hint);
64 
66  MountPoint( const std::string & d = "/",
67  const std::string & f = std::string(),
68  long long bs = 0LL, long long total = 0LL, long long used = 0LL, long long pkg = 0LL,
69  HintFlags hints = NoHint )
70  : dir(d), fstype(f)
71  , block_size(bs), total_size(total), used_size(used), pkg_size(pkg)
72  , readonly(hints.testFlag(Hint_readonly))
73  , growonly(hints.testFlag(Hint_growonly))
74  {}
80  MountPoint( const char * d,
81  const std::string & f = std::string(),
82  long long bs = 0LL, long long total = 0LL, long long used = 0LL, long long pkg = 0LL,
83  HintFlags hints = NoHint )
84  : MountPoint( std::string(d?d:""), f, bs, total, used, pkg, hints )
85  {}
86 
87 
89  MountPoint( const std::string & d,
90  long long bs, long long total = 0LL, long long used = 0LL, long long pkg = 0LL,
91  HintFlags hints = NoHint )
92  : MountPoint( d, std::string(), bs, total, used, pkg, hints )
93  {}
95  MountPoint( const char * d,
96  long long bs, long long total = 0LL, long long used = 0LL, long long pkg = 0LL,
97  HintFlags hints = NoHint )
98  : MountPoint( std::string(d?d:""), bs, total, used, pkg, hints )
99  {}
100 
101 
103  MountPoint( const std::string & d, HintFlags hints )
104  : MountPoint( d, std::string(), 0LL, 0LL, 0LL, 0LL, hints )
105  {}
107  MountPoint( const char * d, HintFlags hints )
108  : MountPoint( std::string(d?d:""), hints )
109  {}
111  MountPoint( const std::string & d, Hint hint )
112  : MountPoint( d, HintFlags(hint) )
113  {}
115  MountPoint( const char * d, Hint hint )
116  : MountPoint( std::string(d?d:""), HintFlags(hint) )
117  {}
118 
120  bool operator<( const MountPoint & rhs ) const
121  { return dir < rhs.dir; }
122 
125  { return ByteCount( block_size, ByteCount::B ); }
126 
129  { return ByteCount( total_size, ByteCount::K ); }
130 
133  { return ByteCount( used_size, ByteCount::K ); }
134 
137  { return ByteCount( total_size-used_size, ByteCount::K ); }
138 
141  { return ByteCount( pkg_size, ByteCount::K ); }
142 
145  { return ByteCount( total_size-pkg_size, ByteCount::K ); }
146 
149  { return ByteCount( pkg_size-used_size, ByteCount::K ); }
150  };
152 
153  typedef std::set<MountPoint> MountPointSet;
154 
156  {}
157 
159  DiskUsageCounter( const MountPointSet & mps_r )
160  : _mps( mps_r )
161  {}
162 
164  void setMountPoints( const MountPointSet & mps_r )
165  { _mps = mps_r; }
166 
168  const MountPointSet & getMountPoints() const
169  { return _mps; }
170 
176  static MountPointSet detectMountPoints( const std::string & rootdir = "/" );
177 
179  static MountPointSet justRootPartition();
180 
181 
183  MountPointSet disk_usage( const ResPool & pool ) const;
184 
186  MountPointSet disk_usage( sat::Solvable solv_r ) const;
188  MountPointSet disk_usage( const PoolItem & pi_r ) const
189  { return disk_usage( sat::asSolvable()( pi_r ) ); }
191  MountPointSet disk_usage( const ResObject::constPtr & obj_r ) const
192  { return disk_usage( sat::asSolvable()( obj_r ) ); }
193 
195  MountPointSet disk_usage( const Bitmap & bitmap_r ) const;
196 
198  template<class Iterator>
199  MountPointSet disk_usage( Iterator begin_r, Iterator end_r ) const
200  {
201  Bitmap bitmap( Bitmap::poolSize );
202  for_( it, begin_r, end_r )
203  bitmap.set( sat::asSolvable()( *it ).id() );
204  return disk_usage( bitmap );
205  }
206 
207  private:
208  MountPointSet _mps;
209  };
211 
212  ZYPP_DECLARE_OPERATORS_FOR_FLAGS(DiskUsageCounter::MountPoint::HintFlags);
213 
215  std::ostream & operator<<( std::ostream & str, const DiskUsageCounter::MountPoint & obj );
216 
218  std::ostream & operator<<( std::ostream & str, const DiskUsageCounter::MountPointSet & obj );
219 
221  inline std::ostream & operator<<( std::ostream & str, const DiskUsageCounter & obj )
222  { return str << obj.getMountPoints(); }
223 
225 } // namespace zypp
227 #endif // ZYPP_DISKUSAGE_COUNTER_H
A Solvable object within the sat Pool.
Definition: Solvable.h:53
ByteCount freeAfterCommit() const
Free size after installation as ByteCount for convenience.
MountPoint(const std::string &d, Hint hint)
ByteCount blockSize() const
Block size of the filesystem as ByteCount for convenience.
growonly partitions (e.g. snapshotting btrfs)
Store and operate with byte count.
Definition: ByteCount.h:30
static MountPointSet justRootPartition()
Only one entry for "/" to collect total sizes.
bool readonly
hint for readonly partitions
ByteCount usedSize() const
Used size of the filesystem as ByteCount for convenience.
ZYPP_DECLARE_OPERATORS_FOR_FLAGS(DiskUsageCounter::MountPoint::HintFlags)
void set(size_type idx_r)
Set bit idx_r.
Definition: Map.cc:79
String related utilities and Regular expression matching.
Definition: Arch.h:344
MountPoint(const std::string &d, long long bs, long long total=0LL, long long used=0LL, long long pkg=0LL, HintFlags hints=NoHint)
Ctor initialize directory and sizes.
#define for_(IT, BEG, END)
Convenient for-loops using iterator.
Definition: Easy.h:27
friend std::ostream & operator<<(std::ostream &str, const MountPoint &obj)
TraitsType::constPtrType constPtr
Definition: ResObject.h:44
long long total_size
Total size of the filesystem in KiB (0 if you don&#39;t care)
bool operator<(const MountPoint &rhs) const
Sort by directory name.
std::ostream & operator<<(std::ostream &str, const DiskUsageCounter &obj)
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)
DiskUsageCounter(const MountPointSet &mps_r)
Ctor taking the MountPointSet to compute.
std::string fstype
Filesystem type (provided by detectMountPoints)
long long used_size
Used size of the filesystem in KiB (0 if you don&#39;t care)
std::set< MountPoint > MountPointSet
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)
Ctor initialize directory, fstype and sizes.
ByteCount totalSize() const
Total size of the filesystem as ByteCount for convenience.
Mount point description If block_size is set DiskUsageCoutner will assume half a block_size is wasted...
std::string dir
Directory name.
MountPoint(const char *d, Hint hint)
MountPointSet disk_usage(Iterator begin_r, Iterator end_r) const
Compute disk usage of a collection (convertible by asSolvable).
MountPointSet disk_usage(const ResObject::constPtr &obj_r) const
long long pkg_size
Used size after installation in KiB (computed by DiskUsageCoutner)
static constexpr PoolSizeType poolSize
An object indicating the bitmap should match the current pools capacity.
Definition: Map.h:41
const MountPointSet & getMountPoints() const
Get the current MountPointSet.
Global ResObject pool.
Definition: ResPool.h:60
MountPointSet disk_usage(const ResPool &pool) const
Compute disk usage if the current transaction woud be commited.
static const Unit B
1 Byte
Definition: ByteCount.h:42
MountPointSet disk_usage(const PoolItem &pi_r) const
Compute disk space occupied by packages across partitions/directories.
MountPoint(const char *d, HintFlags hints)
static const Unit K
1024 Byte
Definition: ByteCount.h:45
ByteCount freeSize() const
Free size of the filesystem as ByteCount for convenience.
Combining sat::Solvable and ResStatus.
Definition: PoolItem.h:50
MountPoint(const char *d, long long bs, long long total=0LL, long long used=0LL, long long pkg=0LL, HintFlags hints=NoHint)
bool growonly
hint for growonly partitions (e.g. snapshotting btrfs)
Libsolv (bit)Map wrapper.
Definition: Map.h:33
To Solvable transform functor.
Definition: Solvable.h:514
ByteCount usedAfterCommit() const
Used size after installation as ByteCount for convenience.
Easy-to use interface to the ZYPP dependency resolver.
Definition: CodePitfalls.doc:1
long long block_size
Block size of the filesystem in B (0 if you don&#39;t care)
void setMountPoints(const MountPointSet &mps_r)
Set a MountPointSet to compute.
ByteCount commitDiff() const
Size change due to installation as ByteCount for convenience.
static MountPointSet detectMountPoints(const std::string &rootdir="/")
Get mountpoints of system below rootdir If we happen to detect snapshotting btrfs partitions...
MountPoint(const std::string &d, HintFlags hints)
Ctor just name and hints, all sizes 0.