Decimal.h

#pragma once


#include <libutl/Number.h>


UTL_NS_BEGIN;



class Decimal : public Object
{
    UTL_CLASS_DECL(Decimal, Object);

public:
    Decimal(int64_t n)
    {
        _n = n;
    }

    Decimal(const String& str)
    {
        set(str);
    }

    virtual void copy(const Object& rhs);

    virtual int compare(const Object& rhs) const;

    virtual void serialize(Stream& stream, uint_t io, uint_t mode = ser_default);

    virtual String toString() const;

    String toString(uint_t digits, bool round = true) const;

    Decimal& set(const String& str);

    Decimal&
    abs()
    {
        if (_n < 0) _n *= -1;
        return self;
    }

    Decimal&
    floor()
    {
        if (_n >= 0)
            _n -= (_n % 1000000);
        else
            _n += (_n % 1000000);
        return self;
    }


    Decimal operator+(const Decimal& rhs) const
    {
        return Decimal(_n + rhs._n);
    }

    Decimal& operator+=(const Decimal& rhs)
    {
        _n += rhs._n;
        return self;
    }

    Decimal operator-(const Decimal& rhs) const
    {
        return Decimal(_n - rhs._n);
    }

    Decimal& operator-=(const Decimal& rhs)
    {
        _n -= rhs._n;
        return self;
    }

    Decimal operator*(const Decimal& rhs) const
    {
        Decimal res(_n);
        res.multiply(rhs._n);
        return res;
    }

    Decimal& operator*=(const Decimal& rhs)
    {
        multiply(rhs._n);
        return self;
    }

    Decimal operator/(const Decimal& rhs) const
    {
        Decimal res(_n);
        res.divide(rhs._n);
        return res;
    }

    Decimal& operator/=(const Decimal& rhs)
    {
        divide(rhs._n);
        return self;
    }

    Decimal operator%(const Decimal& rhs) const
    {
        Decimal res(_n);
        res.mod(rhs._n);
        return res;
    }

    Decimal& operator++()
    {
        _n += 1000000;
        return self;
    }

    Decimal operator++(int)
    {
        Decimal res = self;
        _n += 1000000;
        return res;
    }

    Decimal& operator--()
    {
        _n -= 1000000;
        return self;
    }

    Decimal operator--(int)
    {
        Decimal res = self;
        _n -= 1000000;
        return res;
    }
private:
    void
    init()
    {
        _n = 0;
    }
    void
    deInit()
    {
    }

    Decimal& multiply(int64_t rhs);

    Decimal& divide(int64_t rhs);

    Decimal& mod(int64_t rhs);

private:
    int64_t _n;
};


UTL_NS_END;