Quota.hpp

// -*- C++ -*-
/*
 *    Copyright (C) 2021 Joshua Boudreau <jboudreau@45drives.com>
 *    
 *    This file is part of lib45d.
 * 
 *    lib45d is free software: you can redistribute it and/or modify
 *    it under the terms of the GNU General Public License as published by
 *    the Free Software Foundation, either version 3 of the License, or
 *    (at your option) any later version.
 * 
 *    lib45d 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 General Public License for more details.
 * 
 *    You should have received a copy of the GNU General Public License
 *    along with lib45d.  If not, see <https://www.gnu.org/licenses/>.
 */
 
#pragma once
 
#include <45d/Bytes.hpp>
 
namespace ffd {
    class Quota : public Bytes {
    public:
        enum RoundingMethod {
            NEAREST, 
            DOWN, 
            UP 
        }; 
        Quota(const Bytes &max, const std::string &str, RoundingMethod method = NEAREST);
        Quota(const Bytes &max, double fraction = 1.0, RoundingMethod method = NEAREST)
            : Bytes(max), fraction_(fraction), rounding_method_(method) {}
        Quota(const Bytes &max, const Bytes &allotted, RoundingMethod method = NEAREST)
            : Bytes(max), fraction_(allotted / max)
            , rounding_method_(method) {}
        Quota(void) : Bytes(), fraction_(0), rounding_method_(NEAREST) {}
        Quota(const Quota &other)
            : Bytes(other.bytes_), fraction_(other.fraction_)
            , rounding_method_(other.rounding_method_) {}
        Quota(Quota &&other)
            : Bytes(std::move(other)), fraction_(std::move(other.fraction_))
            , rounding_method_(std::move(other.rounding_method_)) {}
        Quota &operator=(const Quota &other) {
            bytes_ = other.bytes_;
            fraction_ = other.fraction_;
            rounding_method_ = other.rounding_method_;
            return *this;
        }
        Quota &operator=(Quota &&other) {
            bytes_ = std::move(other.bytes_);
            fraction_ = std::move(other.fraction_);
            rounding_method_ = std::move(other.rounding_method_);
            return *this;
        }
        ~Quota() = default;
        void set_rounding_method(RoundingMethod method) {
            rounding_method_ = method;
        }
        bytes_type get(void) const {
            return round(double(bytes_) * fraction_);
        }
        bytes_type get_max(void) const {
            return bytes_;
        }
        double get_fraction(void) const {
            return fraction_;
        }
        void set_fraction(double fraction) {
            fraction_ = fraction;
        }
        void set_fraction(const std::string &str){
            fraction_ = parse_fraction(str);
        }
        double parse_fraction(const std::string &str);
    private:
        double fraction_; 
        RoundingMethod rounding_method_; 
 
        bytes_type round(double x) const {
            switch (rounding_method_) {
                case RoundingMethod::NEAREST:
                    return bytes_type(::round(x));
                case RoundingMethod::DOWN:
                    return bytes_type(x);
                case RoundingMethod::UP:
                    return bytes_type(ceil(x));
                default:
                    return bytes_type(::round(x));
            }
        }
    };
}