libzypp 17.31.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
24namespace zypp
25{
26
32 {
33
34 public:
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 };
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
138
141 { return ByteCount( pkg_size, ByteCount::K ); }
142
146
150 };
152
153 typedef std::set<MountPoint> MountPointSet;
154
156 {}
157
160 : _mps( mps_r )
161 {}
162
164 void setMountPoints( const MountPointSet & mps_r )
165 { _mps = mps_r; }
166
169 { return _mps; }
170
176 static MountPointSet detectMountPoints( const std::string & rootdir = "/" );
177
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 ) ); }
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:
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
Store and operate with byte count.
Definition: ByteCount.h:31
static const Unit K
1024 Byte
Definition: ByteCount.h:45
static const Unit B
1 Byte
Definition: ByteCount.h:42
Compute disk space occupied by packages across partitions/directories.
const MountPointSet & getMountPoints() const
Get the current MountPointSet.
static MountPointSet justRootPartition()
Only one entry for "/" to collect total sizes.
MountPointSet disk_usage(Iterator begin_r, Iterator end_r) const
Compute disk usage of a collection (convertible by asSolvable).
MountPointSet disk_usage(const ResPool &pool) const
Compute disk usage if the current transaction woud be commited.
void setMountPoints(const MountPointSet &mps_r)
Set a MountPointSet to compute.
std::set< MountPoint > MountPointSet
static MountPointSet detectMountPoints(const std::string &rootdir="/")
Get mountpoints of system below rootdir If we happen to detect snapshotting btrfs partitions,...
MountPointSet disk_usage(const PoolItem &pi_r) const
MountPointSet disk_usage(const ResObject::constPtr &obj_r) const
std::ostream & operator<<(std::ostream &str, const DiskUsageCounter &obj)
Stream output.
DiskUsageCounter(const MountPointSet &mps_r)
Ctor taking the MountPointSet to compute.
Combining sat::Solvable and ResStatus.
Definition: PoolItem.h:51
TraitsType::constPtrType constPtr
Definition: ResObject.h:43
Global ResObject pool.
Definition: ResPool.h:61
Libsolv (bit)Map wrapper.
Definition: Map.h:34
static constexpr PoolSizeType poolSize
An object indicating the bitmap should match the current pools capacity.
Definition: Map.h:41
void set(size_type idx_r)
Set bit idx_r.
Definition: Map.cc:81
A Solvable object within the sat Pool.
Definition: Solvable.h:54
Definition: Arch.h:352
String related utilities and Regular expression matching.
Easy-to use interface to the ZYPP dependency resolver.
Definition: CodePitfalls.doc:2
std::ostream & operator<<(std::ostream &str, const SerialNumber &obj)
Definition: SerialNumber.cc:52
ZYPP_DECLARE_OPERATORS_FOR_FLAGS(DiskUsageCounter::MountPoint::HintFlags)
Mount point description If block_size is set DiskUsageCoutner will assume half a block_size is wasted...
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.
long long used_size
Used size of the filesystem in KiB (0 if you don't care)
MountPoint(const std::string &d, Hint hint)
ByteCount commitDiff() const
Size change due to installation as ByteCount for convenience.
MountPoint(const std::string &d, HintFlags hints)
Ctor just name and hints, all sizes 0.
ByteCount usedSize() const
Used size of the filesystem as ByteCount for convenience.
ByteCount freeSize() const
Free size of the filesystem as ByteCount for convenience.
@ Hint_growonly
growonly partitions (e.g. snapshotting btrfs)
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)
long long block_size
Block size of the filesystem in B (0 if you don't care)
MountPoint(const char *d, HintFlags hints)
ByteCount freeAfterCommit() const
Free size after installation as ByteCount for convenience.
long long total_size
Total size of the filesystem in KiB (0 if you don't care)
MountPoint(const char *d, long long bs, long long total=0LL, long long used=0LL, long long pkg=0LL, HintFlags hints=NoHint)
bool readonly
hint for readonly partitions
std::string dir
Directory name.
ByteCount blockSize() const
Block size of the filesystem as ByteCount for convenience.
MountPoint(const char *d, Hint hint)
long long pkg_size
Used size after installation in KiB (computed by DiskUsageCoutner)
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.
bool growonly
hint for growonly partitions (e.g. snapshotting btrfs)
bool operator<(const MountPoint &rhs) const
Sort by directory name.
ByteCount usedAfterCommit() const
Used size after installation as ByteCount for convenience.
friend std::ostream & operator<<(std::ostream &str, const MountPoint &obj)
std::string fstype
Filesystem type (provided by detectMountPoints)
ByteCount totalSize() const
Total size of the filesystem as ByteCount for convenience.
To Solvable transform functor.
Definition: Solvable.h:562
#define for_(IT, BEG, END)
Convenient for-loops using iterator.
Definition: Easy.h:28