percent.hpp

浏览该文件的文档.

/*
 * @Description:  百分比 头文件及其实现
 * @Version:
 * @Autor: dreamy-xay
 * @date: 2024-1-27
 * @LastEditors: dreamy-xay
 * @LastEditTime: 2024-03-06
 */
 
#ifndef COMMON_PERCENT_HPP
#define COMMON_PERCENT_HPP
 
#include <string>
 
#include "common/enum.h"
#include "common/macro.h"
#include "common/type.h"
#include "common/utils/string.hpp"
 
namespace cm {
 
class Percent {
   private:
    double value;
    bool is_percent;  // 是否百分比
 
   public:
    Percent();
    Percent(double value, bool is_percent = true);
    Percent(int value, bool is_percent = false);
    Percent(const Percent& percent);
    ~Percent();
 
    friend std::ostream& operator<<(std::ostream& out, const Percent& percent);
 
    template <typename T>
    T operator+(const T& value) const;
    template <typename T>
    T operator-(const T& value) const;
    template <typename T>
    T operator*(const T& value) const;
    template <typename T>
    T operator/(const T& value) const;
 
    template <typename T>
    T& AddPercent(T& value) const;
    template <typename T>
    T& SubtractPercent(T& value) const;
    template <typename T>
    T& MultiplyPercent(T& value) const;
    template <typename T>
    T& DividePercent(T& value) const;
 
    template <typename T>
    friend T operator+(const T& value, const Percent& percent);
    template <typename T>
    friend T operator-(const T& value, const Percent& percent);
    template <typename T>
    friend T operator*(const T& value, const Percent& percent);
    template <typename T>
    friend T operator/(const T& value, const Percent& percent);
 
    template <typename T = double>
    T Value() const;
    Percent& Assign(double value, bool is_percent = true);
    Percent& Assign(int value, bool is_percent = false);
    std::string Percentage(uint precision = 2) const;
    bool IsPercent() const;
};
 
inline Percent::Percent() : value{}, is_percent(true) {}
 
inline Percent::Percent(double value, bool is_percent) : value(value), is_percent(is_percent) {}
 
inline Percent::Percent(int value, bool is_percent) : value(value), is_percent(is_percent) {}
 
inline Percent::Percent(const Percent& percent) : value(percent.value), is_percent(percent.is_percent) {}
 
inline Percent::~Percent() {}
 
inline std::ostream& operator<<(std::ostream& out, const Percent& percent) {
    out << percent.Percentage();
 
    return out;
}
 
template <typename T>
inline T Percent::operator+(const T& value) const {
    if (is_percent)
        return this->value + value;
    return this->value;
}
 
template <typename T>
inline T Percent::operator-(const T& value) const {
    if (is_percent)
        return this->value - value;
    return this->value;
}
 
template <typename T>
inline T Percent::operator*(const T& value) const {
    if (is_percent)
        return this->value * value;
    return this->value;
}
 
template <typename T>
inline T Percent::operator/(const T& value) const {
    if (is_percent)
        return this->value / value;
    return this->value;
}
 
template <typename T>
inline T& Percent::AddPercent(T& value) const {
    if (is_percent)
        value += this->value;
    return value;
}
 
template <typename T>
inline T& Percent::SubtractPercent(T& value) const {
    if (is_percent)
        value -= this->value;
    return value;
}
 
template <typename T>
inline T& Percent::MultiplyPercent(T& value) const {
    if (is_percent)
        value *= this->value;
    return value;
}
 
template <typename T>
inline T& Percent::DividePercent(T& value) const {
    if (is_percent)
        value /= this->value;
    return value;
}
 
template <typename T>
inline T operator+(const T& value, const Percent& percent) {
    if (percent.is_percent)
        return value + percent.value;
    return percent.value;
}
 
template <typename T>
inline T operator-(const T& value, const Percent& percent) {
    if (percent.is_percent)
        return value - percent.value;
    return percent.value;
}
 
template <typename T>
inline T operator*(const T& value, const Percent& percent) {
    if (percent.is_percent)
        return value * percent.value;
    return percent.value;
}
 
template <typename T>
inline T operator/(const T& value, const Percent& percent) {
    if (percent.is_percent)
        return value / percent.value;
    return percent.value;
}
 
template <typename T>
inline T Percent::Value() const {
    return value;
}
 
inline std::string Percent::Percentage(uint precision) const {
    if (is_percent)
        return std::move(Sprintf(Sprintf("%%.%df%%%%", precision).c_str(), value * 100));
    else
        return std::move(Sprintf(Sprintf("%%.%df", precision).c_str(), value));
}
 
inline Percent& Percent::Assign(double value, bool is_percent) {
    this->value = value;
    this->is_percent = is_percent;
 
    return *this;
}
 
inline Percent& Percent::Assign(int value, bool is_percent) {
    this->value = value;
    this->is_percent = is_percent;
 
    return *this;
}
 
inline bool Percent::IsPercent() const {
    return is_percent;
}
 
}  // namespace cm
 
#endif