FSize.h

/*
  Copyright (C) 2000-2012 Novell, Inc
  Copyright (C) 2018 SUSE LLC
  This library is free software; you can redistribute it and/or modify
  it under the terms of the GNU Lesser General Public License as
  published by the Free Software Foundation; either version 2.1 of the
  License, or (at your option) version 3.0 of the License. This library
  is distributed in the hope that it will be useful, but WITHOUT ANY
  WARRANTY; without even the implied warranty of MERCHANTABILITY or
  FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public
  License for more details. You should have received a copy of the GNU
  Lesser General Public License along with this library; if not, write
  to the Free Software Foundation, Inc., 51 Franklin Street, Fifth
  Floor, Boston, MA 02110-1301 USA
*/
 
 
/*-/
 
  File:       FSize.h
 
  Author:     Michael Andres <ma@suse.de>
  Maintainer: Michael Andres <ma@suse.de>
 
  Purpose: Store and operate on (file/package/partition) sizes.
 
/-*/
#ifndef _FSize_h_
#define _FSize_h_
 
#include <iosfwd>
#include <string>
 
// arbitrary precision integer
#include <boost/multiprecision/cpp_int.hpp>
// generate additional operators via the boost templates
#include <boost/operators.hpp>
 
//
//  CLASS NAME : FSize
//
class FSize :
    // generate > / * + - <= => !== operators
    boost::ordered_field_operators<FSize>,
    // generate postfix ++ --
    boost::unit_steppable<FSize>
  {
 
  public:

    enum class Unit { B, K, M, G, T, P, E, Z, Y };
 
  private:

    boost::multiprecision::cpp_int _size;
 
  public:
 
    static const boost::multiprecision::cpp_int KB;
    static const boost::multiprecision::cpp_int MB;
    static const boost::multiprecision::cpp_int GB;
    static const boost::multiprecision::cpp_int TB;
    static const boost::multiprecision::cpp_int PB;
    static const boost::multiprecision::cpp_int EB;
    // these do not fit long long anymore!
    static const boost::multiprecision::cpp_int ZB;
    static const boost::multiprecision::cpp_int YB;

    static boost::multiprecision::cpp_int factor( const Unit unit_r ) {
      switch ( unit_r ) {
      case Unit::Y: return YB;
      case Unit::Z: return ZB;
      case Unit::E: return EB;
      case Unit::P: return PB;
      case Unit::T: return TB;
      case Unit::G: return GB;
      case Unit::M: return MB;
      case Unit::K: return KB;
      case Unit::B: break;
      }
      return 1;
    }

    static const char * unit( const Unit unit_r ) {
      switch ( unit_r ) {
      case Unit::Y: return "YiB";
      case Unit::Z: return "ZiB";
      case Unit::E: return "EiB";
      case Unit::P: return "PiB";
      case Unit::T: return "TiB";
      case Unit::G: return "GiB";
      case Unit::M: return "MiB";
      case Unit::K: return "KiB";
      case Unit::B: break;
      }
      return "B";
    }
 
  public:

    FSize( const boost::multiprecision::cpp_int &size_r = 0, const Unit unit_r = Unit::B)
      : _size( boost::multiprecision::cpp_int(size_r) * factor( unit_r ) )
    {}

    FSize( double size_r )
      : _size( size_r )
    {}

    FSize( const std::string &sizeStr, const Unit unit_r = Unit::B );

    explicit operator long long() const { return static_cast<long long>(_size); }
    explicit operator int() const { return static_cast<int>(_size); }
    explicit operator double() const { return static_cast<double>(_size); }
 
    operator boost::multiprecision::cpp_int() const { return _size; }
    boost::multiprecision::cpp_int in_unit(const Unit unit_r) const { return _size / factor( unit_r ); }
 
    // unary minus
    FSize operator-() const { return FSize(-_size); }
    FSize & operator+=( const FSize &rhs ) { _size += boost::multiprecision::cpp_int(rhs); return *this; }
    FSize & operator-=( const FSize &rhs ) { _size -= boost::multiprecision::cpp_int(rhs); return *this; }
    FSize & operator*=( const FSize &rhs ) { _size *= boost::multiprecision::cpp_int(rhs); return *this; }
    FSize & operator/=( const FSize &rhs ) { _size /= boost::multiprecision::cpp_int(rhs); return *this; }
 
    bool operator<( const FSize &rhs ) const { return _size < boost::multiprecision::cpp_int(rhs); }
    bool operator==( const FSize &rhs ) const { return _size == boost::multiprecision::cpp_int(rhs); }
 
    // ++operator (the prefix variant)
    FSize & operator++() { _size += 1; return *this; }
    // --operator (the prefix variant)
    FSize & operator--() { _size -= 1; return *this; }

    FSize & fillBlock( FSize blocksize_r = boost::multiprecision::cpp_int(KB) );

    FSize fullBlock( FSize blocksize_r = boost::multiprecision::cpp_int(KB) ) const
    {
        FSize ret( _size );
        return ret.fillBlock(  blocksize_r );
    }

    Unit bestUnit() const;

    static const unsigned bestPrec = (unsigned)-1;

    std::string form( const Unit unit_r, unsigned fw = 0, unsigned prec = bestPrec, const bool showunit = true ) const;

    std::string form( unsigned fw = 0, unsigned prec = bestPrec, const bool showunit = true ) const {
      return form( bestUnit(), fw, prec, showunit );
    }

    std::string asString() const;
};
 
// stream operators
std::ostream& operator<<(std::ostream &ostr, const FSize&);
std::ostream& operator<<(std::ostream &ostr, const FSize::Unit);
 
#endif // _FSize_h_