quantity.hpp

#ifndef QUANTITY_H
#define QUANTITY_H
 
#include <cmath>
 
#include "json.hpp"
 
class Quantity
{
public:
    static constexpr double precision = 0.01;
 
    Quantity()
        : _value( 0.0 )
        , _max( 0.0 ) {}
 
    Quantity(double value, double max )
        : _value( value )
        , _max( max ) {}
 
    Quantity( const Quantity& other )
        : _value( other._value )
        , _max( other._max ) {}
 
    double operator += ( const Quantity &b) {
        _value += b._value;
        return _enforceCap();
    }
 
    double operator += ( double b ) {
        _value += b;
        return _enforceCap();
    }
 
    double operator -= ( const Quantity &b ) {
        _value -= b._value;
        return _enforceCap();
    }
 
    double operator -= ( double b ) {
        _value -= b;
        return _enforceCap();
    }
 
    const Quantity &operator =( const Quantity &b ) {
        _max = b._max;
        _value = b._value;
        return *this;
    }
 
    const Quantity &operator =( double b ) {
        _value = b;
        _enforceCap();
        return *this;
    }
 
    const Quantity & makeEqual( const Quantity& b ) {
        _max = b._max;
        _value = b._value;
        return *this;
    }
 
    double availability() const {
        return _max - _value;
    }
 
    void fill() {
        _value = _max;
    }
 
    void empty() {
        _value = 0.0;
    }
 
    double addValue( double b ) {
        _value += b;
        return _enforceCap();
    }
 
    double value() const { return _value; }
    double max() const { return _max; }
    double value( double value ) { _value = value; _enforceCap(); return _value; }
    double max( double max ) { _max = max; _enforceCap(); return _max; }
 
    bool isNaN() const {
        return (_value == NAN) || (_max == NAN);
    }
 
    friend void to_json(nlohmann::json& j, const Quantity& s) {
        j = nlohmann::json{
            {"value", s.value()},
            {"max", s.max()}
        };
    }
 
    friend void from_json(const nlohmann::json& j, Quantity& s) {
        s.max(j.at("max").get<double>());
        s.value(j.at("value").get<double>());
    }
 
    friend bool operator < (const Quantity &a, const Quantity &b) {
        if ( a.value() < b.value() )
            return true;
        return false;
    }
 
    friend bool operator == (const Quantity &a, const Quantity &b) {
        double delta = std::fabs( a.value() - b.value() );
        if ( delta <= Quantity::precision )
            return true;
        return false;
    }
 
    friend bool operator != (const Quantity &a, const Quantity &b) {
        double delta = std::fabs( a.value() - b.value() );
        if ( delta > Quantity::precision )
            return true;
        return false;
    }
 
private:
    inline double _enforceCap() {
        double spill = 0.0;
        if ( _value > _max ) {
            spill = _value - _max;
            _value = _max;
        }
        return spill;
    }
    double _value;
    double _max;
 
};
 
#endif // QUANTITY_H