BigNumber.h

#ifndef _KNOW_CORE_BIGNUMBER_H_
#define _KNOW_CORE_BIGNUMBER_H_
 
#include <QList>
#include "ReturnValue.h"
 
#include <Cyqlops/Crypto/Hash.h>
 
class QVariant;
 
namespace std
{
  template<>
  struct is_floating_point<knowCore::BigNumber> : public true_type
  {
  };
  template<>
  struct is_signed<knowCore::BigNumber> : public true_type
  {
  };
  template<>
  struct is_unsigned<knowCore::BigNumber> : public false_type
  {
  };
  template<>
  struct is_integral<knowCore::BigNumber> : public false_type
  {
  };
}
 
namespace knowCore
{
  class BigNumber
  {
  public:
    enum class Sign
    {
      Positive,
      Negative,
      NaN,
      PositiveInfinite,
      NegativeInfinite
    };
  public:
    BigNumber();
    BigNumber(qint16 weight, Sign sign, qint16 dscale, const QList<quint16>& digits);
    ~BigNumber();
 
    BigNumber(std::intmax_t _value);
    BigNumber(std::uintmax_t _value);
    template<typename _T_, std::enable_if_t<std::is_integral_v<_T_> and std::is_unsigned_v<_T_>, int> = 0>
    BigNumber(_T_ _value) : BigNumber(std::uintmax_t(_value)) {}
    template<typename _T_, std::enable_if_t<std::is_integral_v<_T_> and std::is_signed_v<_T_>, int> = 0>
    BigNumber(_T_ _value) : BigNumber(std::intmax_t(_value)) {}
    BigNumber(double _value);
    static ReturnValue<BigNumber> fromString(const QString& _value);
    static ReturnValue<BigNumber> fromString(const char* _value) { return fromString(QString(_value)); }
    static ReturnValue<BigNumber> fromVariant(const QVariant& _value);
    static ReturnValue<BigNumber> fromValue(const knowCore::Value& _value);
    static BigNumber zero();
    static BigNumber nan();
    static BigNumber positiveInfinite();
    static BigNumber negativeInfinite();
    bool isNaN() const;
    bool isFinite() const;
    bool isInfinite() const;
    bool isFloating() const;
    QString toString() const;
    QVariant toVariant() const;
    knowCore::Value toValue() const;
    double toDouble() const;
    ReturnValue<qint64> toInt64(bool _truncate = false) const;
    ReturnValue<quint64> toUInt64(bool _truncate = false) const;
    bool operator==(const BigNumber& _rhs) const;
    bool operator!=(const BigNumber& _rhs) const { return not (*this == _rhs); }
    QByteArray md5() const;
    void hash(QCryptographicHash* _hash) const;
    
    BigNumber operator+(const BigNumber& _rhs) const;
    BigNumber operator-(const BigNumber& _rhs) const;
    BigNumber operator*(const BigNumber& _rhs) const;
    BigNumber operator/(const BigNumber& _rhs) const;
    BigNumber operator-() const;
    bool operator<(const BigNumber& _rhs) const;
    bool operator<=(const BigNumber& _rhs) const;
    bool operator>(const BigNumber& _rhs) const;
    bool operator>=(const BigNumber& _rhs) const;
    
    template<typename _T_, std::enable_if_t<std::is_arithmetic_v<_T_>, bool> = true>
    BigNumber operator+(const _T_& _rhs) const { return operator+(BigNumber(_rhs)); }
    template<typename _T_, std::enable_if_t<std::is_arithmetic_v<_T_>, bool> = true>
    BigNumber operator-(const _T_& _rhs) const { return operator-(BigNumber(_rhs)); }
    template<typename _T_, std::enable_if_t<std::is_arithmetic_v<_T_>, bool> = true>
    BigNumber operator*(const _T_& _rhs) const { return operator*(BigNumber(_rhs)); }
    template<typename _T_, std::enable_if_t<std::is_arithmetic_v<_T_>, bool> = true>
    BigNumber operator/(const _T_& _rhs) const { return operator/(BigNumber(_rhs)); }
    template<typename _T_, std::enable_if_t<std::is_arithmetic_v<_T_>, bool> = true>
    bool operator<(const _T_& _rhs) const { return operator<(BigNumber(_rhs)); }
    template<typename _T_, std::enable_if_t<std::is_arithmetic_v<_T_>, bool> = true>
    bool operator<=(const _T_& _rhs) const { return operator<=(BigNumber(_rhs)); }
    template<typename _T_, std::enable_if_t<std::is_arithmetic_v<_T_>, bool> = true>
    bool operator>(const _T_& _rhs) const { return operator>(BigNumber(_rhs)); }
    template<typename _T_, std::enable_if_t<std::is_arithmetic_v<_T_>, bool> = true>
    bool operator>=(const _T_& _rhs) const { return operator>=(BigNumber(_rhs)); }
    
  public:
    quint16 weight() const { return m_weight; }
    Sign sign() const { return m_sign; }
    quint16 dscale() const { return m_dscale; }
    QList<quint16> digits() const { return m_digits; }
  private:
    void simplify();
    void roundVar();
    void exponenfy(int exp);
    BigNumber add_abs(const BigNumber& _rhs) const;
    BigNumber sub_abs(const BigNumber& _rhs) const;
    enum class ComparisonResult { Bigger /* this < _rhs */, Smaller /* this > _rhs */, Equal };
    ComparisonResult compare_abs(const BigNumber& _rhs) const;
    ComparisonResult compare(const BigNumber& _rhs) const;
    std::tuple<bool, quint64> toUInt64_ignore_sign() const;
    template<typename _T_>
    _T_ toVariantValue() const;
  private:
    qint16 m_weight, m_dscale;
    Sign m_sign;
    QList<quint16> m_digits;
  };
  template<typename _T_, std::enable_if_t<std::is_arithmetic_v<_T_>, bool> = true>
  static inline BigNumber operator+(const _T_& _lhs, const BigNumber& _rhs) { return BigNumber(_lhs) + _rhs; }
  template<typename _T_, std::enable_if_t<std::is_arithmetic_v<_T_>, bool> = true>
  static inline BigNumber operator-(const _T_& _lhs, const BigNumber& _rhs) { return BigNumber(_lhs) - _rhs; }
  template<typename _T_, std::enable_if_t<std::is_arithmetic_v<_T_>, bool> = true>
  static inline BigNumber operator*(const _T_& _lhs, const BigNumber& _rhs) { return BigNumber(_lhs) * _rhs; }
  template<typename _T_, std::enable_if_t<std::is_arithmetic_v<_T_>, bool> = true>
  static inline BigNumber operator/(const _T_& _lhs, const BigNumber& _rhs) { return BigNumber(_lhs) / _rhs; }
  template<typename _T_, std::enable_if_t<std::is_arithmetic_v<_T_>, bool> = true>
  static inline bool operator<(const _T_& _lhs, const BigNumber& _rhs) { return BigNumber(_lhs) < _rhs; }
  template<typename _T_, std::enable_if_t<std::is_arithmetic_v<_T_>, bool> = true>
  static inline bool operator<=(const _T_& _lhs, const BigNumber& _rhs) { return BigNumber(_lhs) <= _rhs; }
  template<typename _T_, std::enable_if_t<std::is_arithmetic_v<_T_>, bool> = true>
  static inline bool operator>(const _T_& _lhs, const BigNumber& _rhs) { return BigNumber(_lhs) > _rhs; }
  template<typename _T_, std::enable_if_t<std::is_arithmetic_v<_T_>, bool> = true>
  static inline bool operator>=(const _T_& _lhs, const BigNumber& _rhs) { return BigNumber(_lhs) >= _rhs; }
  template<typename _T_, std::enable_if_t<std::is_arithmetic_v<_T_>, bool> = true>
  static inline bool operator==(const _T_& _lhs, const BigNumber& _rhs) { return BigNumber(_lhs) == _rhs; }
}
 
#include "MetaType.h"
KNOWCORE_DECLARE_FULL_METATYPE(knowCore, BigNumber)
 
#include "Formatter.h"
 
KNOWCORE_CORE_DECLARE_FORMATTER(knowCore::BigNumber)
{
  return forward(p.toString(), ctx);
}
 
namespace Cyqlops::Crypto::Hash
{
  template<>
  struct Compute<knowCore::BigNumber>
  {
    Compute(QCryptographicHash& _algorithm, const knowCore::BigNumber& _v)
    {
      _v.hash(&_algorithm);
    }
  };
}
 
#endif