zypp/ByteCount.h

   1 /*---------------------------------------------------------------------\
   2 |                          ____ _   __ __ ___                          |
   3 |                         |__  / \ / / . \ . \                         |
   4 |                           / / \ V /|  _/  _/                         |
   5 |                          / /__ | | | | | |                           |
   6 |                         /_____||_| |_| |_|                           |
   7 |                                                                      |
   8 \---------------------------------------------------------------------*/
   9 /** \file       zypp/ByteCount.h
  10  *
  11 */
  12 #ifndef ZYPP_BYTECOUNT_H
  13 #define ZYPP_BYTECOUNT_H
  14
  15 #include <iosfwd>
  16
  17 #include "zypp/base/Unit.h"
  18
  19 ///////////////////////////////////////////////////////////////////
  20 namespace zypp
  21 { /////////////////////////////////////////////////////////////////
  22
  23   ///////////////////////////////////////////////////////////////////
  24   //
  25   //    CLASS NAME : ByteCount
  26   //
  27   /** Store and operate with byte count.
  28    *
  29   */
  30   class ByteCount
  31   {
  32     friend std::ostream & operator<<( std::ostream & str, const ByteCount & obj );
  33
  34   public:
  35
  36     typedef base::Unit      Unit;
  37     typedef Unit::ValueType SizeType;
  38
  39     /** \name Byte unit constants. */
  40     //@{
  41     /** 1 Byte */
  42     static const Unit B;
  43
  44     /** 1024 Byte */
  45     static const Unit K;
  46     static const Unit KiB;
  47     /** 1024^2 Byte */
  48     static const Unit M;
  49     static const Unit MiB;
  50     /** 1024^3 Byte */
  51     static const Unit G;
  52     static const Unit GiB;
  53     /** 1024^4 Byte */
  54     static const Unit T;
  55     static const Unit TiB;
  56
  57     /** 1000 Byte */
  58     static const Unit kB;
  59     /** 1000^2 Byte */
  60     static const Unit MB;
  61     /** 1000^3 Byte */
  62     static const Unit GB;
  63     /** 1000^4 Byte */
  64     static const Unit TB;
  65     //@}
  66
  67   public:
  68
  69     /** Default ctor */
  70     ByteCount()
  71     : _count( 0 )
  72     {}
  73     /** Ctor taking 1 Unit. */
  74     ByteCount( const Unit & unit_r )
  75     : _count( unit_r.factor() )
  76     {}
  77     /** Ctor taking a count and optinal Unit. */
  78     ByteCount( const SizeType count_r, const Unit & unit_r = B )
  79     : _count( count_r * unit_r.factor() )
  80     {}
  81
  82  public:
  83
  84     /** Conversion to SizeType. */
  85     operator SizeType() const
  86     { return _count; }
  87
  88     /** \name Arithmetic operations.
  89      * \c + \c - \c * \c / are provided via conversion to SizeType.
  90     */
  91     //@{
  92     ByteCount & operator+=( const SizeType rhs ) { _count += rhs; return *this; }
  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
  97     ByteCount & operator++(/*prefix*/) { _count += 1; return *this; }
  98     ByteCount & operator--(/*prefix*/) { _count -= 1; return *this; }
  99
 100     ByteCount operator++(int/*postfix*/) { return _count++; }
 101     ByteCount operator--(int/*postfix*/) { return _count--; }
 102     //@}
 103
 104     /** Adjust count to multiple of \a blocksize_r (default 1K).
 105      * Zero blocksize_r is treated as 1B.
 106     */
 107     ByteCount & fillBlock( ByteCount blocksize_r = K );
 108
 109     /** Return count adjusted to multiple of \a blocksize_r (default 1K). */
 110     ByteCount fullBlocks( ByteCount blocksize_r = K ) const
 111     { return ByteCount(*this).fillBlock( blocksize_r ); }
 112
 113     /** Return number of blocks of size \a blocksize_r (default 1K). */
 114     SizeType blocks( ByteCount blocksize_r = K ) const
 115     { return fullBlocks( blocksize_r ) / blocksize_r; }
 116
 117   public:
 118
 119     /** Return the best Unit (B,K,M,G,T) for count. */
 120     const Unit & bestUnit() const;
 121
 122     /** Return the best Unit (B,kB,MB,GB,TB) for count. */
 123     const Unit & bestUnit1000() const;
 124
 125     /** \name Conversion to string.
 126      * \li \a field_width_r Width for the number part (incl. precision)
 127      * \li \a unit_width_r With for the unit symbol (without symbol if zero)
 128      * \li \a prec_r Precision to use.
 129      * \see zypp::base::Unit
 130     */
 131     //@{
 132     /** Auto selected Unit and precision. */
 133     std::string asString( unsigned field_width_r = 0,
 134                           unsigned unit_width_r  = 1 ) const
 135     { return asString( bestUnit(), field_width_r, unit_width_r ); }
 136     /** Auto selected Unit. */
 137     std::string asString( unsigned field_width_r,
 138                           unsigned unit_width_r,
 139                           unsigned prec_r ) const
 140     { return asString( bestUnit(), field_width_r, unit_width_r, prec_r ); }
 141     /** Auto selected precision. */
 142     std::string asString( const Unit & unit_r,
 143                           unsigned field_width_r = 0,
 144                           unsigned unit_width_r  = 1 ) const
 145     { return asString( unit_r, field_width_r, unit_width_r, unit_r.prec() ); }
 146     /** Nothing auto selected. */
 147     std::string asString( const Unit & unit_r,
 148                           unsigned field_width_r,
 149                           unsigned unit_width_r,
 150                           unsigned prec_r ) const
 151     { return unit_r.form( _count, field_width_r, unit_width_r, prec_r ); }
 152     //@}
 153
 154   private:
 155     SizeType _count;
 156   };
 157   ///////////////////////////////////////////////////////////////////
 158
 159   /** \relates ByteCount Stream output */
 160   inline std::ostream & operator<<( std::ostream & str, const ByteCount & obj )
 161   { return str << obj.asString(); }
 162
 163   /////////////////////////////////////////////////////////////////
 164 } // namespace zypp
 165 ///////////////////////////////////////////////////////////////////
 166 #endif // ZYPP_BYTECOUNT_H