libzypp: zypp-core/ByteCount.h Source File

libzypp 17.38.10

ByteCount.h
Go to the documentation of this file.
1/*---------------------------------------------------------------------\
2| ____ _ __ __ ___ |
3| |__ / \ / / . \ . \ |
4| / / \ V /| _/ _/ |
5| / /__ | | | | | | |
6| /_____||_| |_| |_| |
7| |
8\---------------------------------------------------------------------*/
12#ifndef ZYPP_BYTECOUNT_H
13#define ZYPP_BYTECOUNT_H
14
15#include <iosfwd>
16
17#include <zypp-core/Globals.h>
18#include <zypp-core/base/Unit.h>
19
21namespace zypp
22{
23
25 //
26 // CLASS NAME : ByteCount
27 //
31 class ZYPP_API ByteCount
32 {
33 friend std::ostream & operator<<( std::ostream & str, const ByteCount & obj );
34
35 public:
36
37 using Unit = base::Unit;
38 using SizeType = Unit::ValueType;
39
42
43 static const Unit B;
44
46 static const Unit K;
47 static const Unit KiB;
49 static const Unit M;
50 static const Unit MiB;
52 static const Unit G;
53 static const Unit GiB;
55 static const Unit T;
56 static const Unit TiB;
57
59 static const Unit kB;
61 static const Unit MB;
63 static const Unit GB;
65 static const Unit TB;
67
68 public:
69
71 ByteCount()
72 : _count( 0 )
73 {}
74
75 ByteCount( const Unit & unit_r )
76 : _count( unit_r.factor() )
77 {}
78
79 ByteCount( const SizeType count_r, const Unit & unit_r = B )
80 : _count( count_r * unit_r.factor() )
81 {}
82
83 public:
84
86 operator SizeType() const
87 { return _count; }
88
93 ByteCount & operator+=( const SizeType rhs ) { _count += rhs; return *this; }
94 ByteCount & operator-=( const SizeType rhs ) { _count -= rhs; return *this; }
95 ByteCount & operator*=( const SizeType rhs ) { _count *= rhs; return *this; }
96 ByteCount & operator/=( const SizeType rhs ) { _count /= rhs; return *this; }
97
98 ByteCount & operator++(/*prefix*/) { _count += 1; return *this; }
99 ByteCount & operator--(/*prefix*/) { _count -= 1; return *this; }
100
101 ByteCount operator++(int/*postfix*/) { return _count++; }
102 ByteCount operator--(int/*postfix*/) { return _count--; }
104
108 ByteCount & fillBlock( ByteCount blocksize_r = K );
109
111 ByteCount fullBlocks( ByteCount blocksize_r = K ) const
112 { return ByteCount(*this).fillBlock( blocksize_r ); }
113
115 SizeType blocks( ByteCount blocksize_r = K ) const
116 { return fullBlocks( blocksize_r ) / blocksize_r; }
117
118 public:
119
121 const Unit & bestUnit() const;
122
124 const Unit & bestUnit1000() const;
125
133
134 std::string asString( unsigned field_width_r = 0,
135 unsigned unit_width_r = 1 ) const
136 { return asString( bestUnit(), field_width_r, unit_width_r ); }
137
138 std::string asString( unsigned field_width_r,
139 unsigned unit_width_r,
140 unsigned prec_r ) const
141 { return asString( bestUnit(), field_width_r, unit_width_r, prec_r ); }
142
143 std::string asString( const Unit & unit_r,
144 unsigned field_width_r = 0,
145 unsigned unit_width_r = 1 ) const
146 { return asString( unit_r, field_width_r, unit_width_r, unit_r.prec() ); }
147
148 std::string asString( const Unit & unit_r,
149 unsigned field_width_r,
150 unsigned unit_width_r,
151 unsigned prec_r ) const
152 { return unit_r.form( _count, field_width_r, unit_width_r, prec_r ); }
153
154
155 private:
156 SizeType _count;
157 };
158
159
161 inline std::ostream & operator<<( std::ostream & str, const ByteCount & obj )
162 { return str << obj.asString(); }
163
165} // namespace zypp
167#endif // ZYPP_BYTECOUNT_H
Globals.h
Provides API related macros.
Unit.h
zypp::ByteCount
Store and operate with byte count.
Definition ByteCount.h:32
zypp::ByteCount::MiB
static const Unit MiB
Definition ByteCount.h:50
zypp::ByteCount::MB
static const Unit MB
1000^2 Byte
Definition ByteCount.h:61
zypp::ByteCount::TiB
static const Unit TiB
Definition ByteCount.h:56
zypp::ByteCount::asString
std::string asString(unsigned field_width_r, unsigned unit_width_r, unsigned prec_r) const
Auto selected Unit.
Definition ByteCount.h:138
zypp::ByteCount::G
static const Unit G
1024^3 Byte
Definition ByteCount.h:52
zypp::ByteCount::ByteCount
ByteCount()
Default ctor.
Definition ByteCount.h:71
zypp::ByteCount::asString
std::string asString(const Unit &unit_r, unsigned field_width_r, unsigned unit_width_r, unsigned prec_r) const
Nothing auto selected.
Definition ByteCount.h:148
zypp::ByteCount::Unit
base::Unit Unit
Definition ByteCount.h:37
zypp::ByteCount::asString
std::string asString(const Unit &unit_r, unsigned field_width_r=0, unsigned unit_width_r=1) const
Auto selected precision.
Definition ByteCount.h:143
zypp::ByteCount::kB
static const Unit kB
1000 Byte
Definition ByteCount.h:59
zypp::ByteCount::operator--
ByteCount operator--(int)
Definition ByteCount.h:102
zypp::ByteCount::ByteCount
ByteCount(const SizeType count_r, const Unit &unit_r=B)
Ctor taking a count and optinal Unit.
Definition ByteCount.h:79
zypp::ByteCount::blocks
SizeType blocks(ByteCount blocksize_r=K) const
Return number of blocks of size blocksize_r (default 1K).
Definition ByteCount.h:115
zypp::ByteCount::bestUnit
const Unit & bestUnit() const
Return the best Unit (B,K,M,G,T) for count.
Definition ByteCount.cc:70
zypp::ByteCount::operator+=
ByteCount & operator+=(const SizeType rhs)
Definition ByteCount.h:93
zypp::ByteCount::K
static const Unit K
1024 Byte
Definition ByteCount.h:46
zypp::ByteCount::ByteCount
ByteCount(const Unit &unit_r)
Ctor taking 1 Unit.
Definition ByteCount.h:75
zypp::ByteCount::operator*=
ByteCount & operator*=(const SizeType rhs)
Definition ByteCount.h:95
zypp::ByteCount::TB
static const Unit TB
1000^4 Byte
Definition ByteCount.h:65
zypp::ByteCount::operator/=
ByteCount & operator/=(const SizeType rhs)
Definition ByteCount.h:96
zypp::ByteCount::operator++
ByteCount & operator++()
Definition ByteCount.h:98
zypp::ByteCount::SizeType
Unit::ValueType SizeType
Definition ByteCount.h:38
zypp::ByteCount::B
static const Unit B
1 Byte
Definition ByteCount.h:43
zypp::ByteCount::operator-=
ByteCount & operator-=(const SizeType rhs)
Definition ByteCount.h:94
zypp::ByteCount::KiB
static const Unit KiB
Definition ByteCount.h:47
zypp::ByteCount::operator--
ByteCount & operator--()
Definition ByteCount.h:99
zypp::ByteCount::operator++
ByteCount operator++(int)
Definition ByteCount.h:101
zypp::ByteCount::fullBlocks
ByteCount fullBlocks(ByteCount blocksize_r=K) const
Return count adjusted to multiple of blocksize_r (default 1K).
Definition ByteCount.h:111
zypp::ByteCount::GiB
static const Unit GiB
Definition ByteCount.h:53
zypp::ByteCount::M
static const Unit M
1024^2 Byte
Definition ByteCount.h:49
zypp::ByteCount::GB
static const Unit GB
1000^3 Byte
Definition ByteCount.h:63
zypp::ByteCount::asString
std::string asString(unsigned field_width_r=0, unsigned unit_width_r=1) const
Auto selected Unit and precision.
Definition ByteCount.h:134
zypp::ByteCount::_count
SizeType _count
Definition ByteCount.h:156
zypp::ByteCount::T
static const Unit T
1024^4 Byte
Definition ByteCount.h:55
zypp::base::Unit
Simple handling of Units.
Definition Unit.h:46
zypp::base::Unit::form
std::string form(ValueType val_r, unsigned field_width_r=0, unsigned unit_width_r=1) const
Build string representation of val_r.
Definition Unit.h:73
zypp::base::Unit::ValueType
long long ValueType
Definition Unit.h:48
zypp::base::Unit::prec
unsigned prec() const
Definition Unit.h:69
str
String related utilities and Regular expression matching.
zypp
Easy-to use interface to the ZYPP dependency resolver.
Definition CodePitfalls.doc:2
zypp::ZYPP_API
const Arch Arch_empty ZYPP_API
relates: Arch This is an empty Arch represented by an empty string.
Definition Arch.h:173
zypp::asString
std::string asString(const Patch::Category &obj)
relates: Patch::Category string representation.
Definition Patch.cc:122
zypp::operator<<
std::ostream & operator<<(std::ostream &str, const Capabilities &obj)
relates: Capabilities Stream output
Definition Capabilities.cc:65