ByteCount.h

Go to the documentation of this file.

/*---------------------------------------------------------------------\
|                          ____ _   __ __ ___                          |
|                         |__  / \ / / . \ . \                         |
|                           / / \ V /|  _/  _/                         |
|                          / /__ | | | | | |                           |
|                         /_____||_| |_| |_|                           |
|                                                                      |
\---------------------------------------------------------------------*/
#ifndef ZYPP_BYTECOUNT_H
#define ZYPP_BYTECOUNT_H
 
#include <iosfwd>
 
#include <zypp/Globals.h>
#include <zypp-core/base/Unit.h>

namespace zypp
{ 

  //
  //    CLASS NAME : ByteCount
  //
  class ZYPP_API ByteCount
  {
    friend std::ostream & operator<<( std::ostream & str, const ByteCount & obj );
 
  public:
 
    using Unit = base::Unit;
    using SizeType = Unit::ValueType;


    static const Unit B;

    static const Unit K;
    static const Unit KiB;
    static const Unit M;
    static const Unit MiB;
    static const Unit G;
    static const Unit GiB;
    static const Unit T;
    static const Unit TiB;

    static const Unit kB;
    static const Unit MB;
    static const Unit GB;
    static const Unit TB;
 
  public:

    ByteCount()
    : _count( 0 )
    {}

    ByteCount( const Unit & unit_r )
    : _count( unit_r.factor() )
    {}

    ByteCount( const SizeType count_r, const Unit & unit_r = B )
    : _count( count_r * unit_r.factor() )
    {}
 
 public:

    operator SizeType() const
    { return _count; }

    ByteCount & operator+=( const SizeType rhs ) { _count += rhs; return *this; }
    ByteCount & operator-=( const SizeType rhs ) { _count -= rhs; return *this; }
    ByteCount & operator*=( const SizeType rhs ) { _count *= rhs; return *this; }
    ByteCount & operator/=( const SizeType rhs ) { _count /= rhs; return *this; }
 
    ByteCount & operator++(/*prefix*/) { _count += 1; return *this; }
    ByteCount & operator--(/*prefix*/) { _count -= 1; return *this; }
 
    ByteCount operator++(int/*postfix*/) { return _count++; }
    ByteCount operator--(int/*postfix*/) { return _count--; }

    ByteCount & fillBlock( ByteCount blocksize_r = K );

    ByteCount fullBlocks( ByteCount blocksize_r = K ) const
    { return ByteCount(*this).fillBlock( blocksize_r ); }

    SizeType blocks( ByteCount blocksize_r = K ) const
    { return fullBlocks( blocksize_r ) / blocksize_r; }
 
  public:

    const Unit & bestUnit() const;

    const Unit & bestUnit1000() const;


    std::string asString( unsigned field_width_r = 0,
                          unsigned unit_width_r  = 1 ) const
    { return asString( bestUnit(), field_width_r, unit_width_r ); }

    std::string asString( unsigned field_width_r,
                          unsigned unit_width_r,
                          unsigned prec_r ) const
    { return asString( bestUnit(), field_width_r, unit_width_r, prec_r ); }

    std::string asString( const Unit & unit_r,
                          unsigned field_width_r = 0,
                          unsigned unit_width_r  = 1 ) const
    { return asString( unit_r, field_width_r, unit_width_r, unit_r.prec() ); }

    std::string asString( const Unit & unit_r,
                          unsigned field_width_r,
                          unsigned unit_width_r,
                          unsigned prec_r ) const
    { return unit_r.form( _count, field_width_r, unit_width_r, prec_r ); }

 
  private:
    SizeType _count;
  };


  inline std::ostream & operator<<( std::ostream & str, const ByteCount & obj )
  { return str << obj.asString(); }

} // namespace zypp
#endif // ZYPP_BYTECOUNT_H