AMetric.h

/*
 * AUI Framework - Declarative UI toolkit for modern C++20
 * Copyright (C) 2020-2024 Alex2772 and Contributors
 *
 * SPDX-License-Identifier: MPL-2.0
 *
 * This Source Code Form is subject to the terms of the Mozilla Public
 * License, v. 2.0. If a copy of the MPL was not distributed with this
 * file, You can obtain one at http://mozilla.org/MPL/2.0/.
 */
 
#pragma once
 
#include <AUI/Core.h>
#include <type_traits>
#include <ostream>
#include <tuple>
#include "AUI/Util/Assert.h"
 
class AString;
 
class API_AUI_VIEWS AMetric
{
public:
    enum Unit
    {
        T_UNKNOWN,
        T_PX,
        T_DP,
        T_PT,
    };
 
private:
    float mValue;
    Unit mUnit;
 
    float convertValueToMyUnit(const AMetric& anotherMetric) {
        return fromPxToMetric(anotherMetric.getValuePx(), mUnit);
    }
 
public:
    constexpr AMetric():
        AMetric(0, T_PX) {}
 
    template<typename T, typename std::enable_if_t<std::is_integral_v<T>, bool> = 0>
    constexpr AMetric(T value):
        AMetric(value, T_PX)
    {
        AUI_ASSERTX(value == 0,
                    "please use _px, _dp or _pt literal for AMetric initialisation. only zero allowed to "
                    "initialise AMetric without literal");
    }
 
    constexpr AMetric(float value, Unit unit): mValue(value), mUnit(unit) {
 
    }
 
    AMetric(const AString& text);
 
    [[nodiscard]] float getRawValue() const
    {
        return mValue;
    }
 
    [[nodiscard]] Unit getUnit() const
    {
        return mUnit;
    }
 
    [[nodiscard]] float getValuePx() const;
    [[nodiscard]] float getValueDp() const;
 
    static float fromPxToMetric(float value, Unit unit);
 
    operator float() const {
        return getValuePx();
    }
    
    AMetric operator-() const {
        return {-mValue, mUnit};
    }
 
    AMetric& operator+=(AMetric rhs) noexcept {
        AUI_ASSERT(mUnit == rhs.mUnit);
        mValue += rhs.mValue;
        return *this;
    }
 
    AMetric& operator-=(AMetric rhs) noexcept {
        AUI_ASSERT(mUnit == rhs.mUnit);
        mValue -= rhs.mValue;
        return *this;
    }
 
    AMetric& operator*=(AMetric rhs) noexcept {
        AUI_ASSERT(mUnit == rhs.mUnit);
        mValue *= rhs.mValue;
        return *this;
    }
 
    AMetric& operator/=(AMetric rhs) noexcept {
        AUI_ASSERT(mUnit == rhs.mUnit);
        mValue /= rhs.mValue;
        return *this;
    }
 
    AMetric operator+(AMetric rhs) const noexcept {
        AUI_ASSERT(mUnit == rhs.mUnit);
        auto copy = *this;
        copy += rhs;
        return copy;
    }
 
    AMetric operator-(AMetric rhs) const noexcept {
        AUI_ASSERT(mUnit == rhs.mUnit);
        auto copy = *this;
        copy -= rhs;
        return copy;
    }
 
    AMetric operator*(AMetric rhs) const noexcept {
        AUI_ASSERT(mUnit == rhs.mUnit);
        auto copy = *this;
        copy *= rhs;
        return copy;
    }
 
    AMetric operator/(AMetric rhs) const noexcept {
        AUI_ASSERT(mUnit == rhs.mUnit);
        auto copy = *this;
        copy /= rhs;
        return copy;
    }
 
    AMetric& operator*=(float rhs) noexcept {
        mValue *= rhs;
        return *this;
    }
 
    AMetric& operator/=(float rhs) noexcept {
        mValue /= rhs;
        return *this;
    }
 
    AMetric operator*(float rhs) const noexcept {
        auto copy = *this;
        copy *= rhs;
        return copy;
    }
 
    AMetric operator/(float rhs) const noexcept {
        auto copy = *this;
        copy /= rhs;
        return copy;
    }
 
    bool operator==(const AMetric& rhs) const {
        return std::tie(mValue, mUnit) == std::tie(rhs.mValue, rhs.mUnit);
    }
 
    bool operator!=(const AMetric& rhs) const {
        return !(rhs == *this);
    }
};
 
 
constexpr inline AMetric operator""_px(unsigned long long v)
{
    return AMetric(static_cast<float>(static_cast<long long>(v)), AMetric::T_PX);
}
constexpr inline AMetric operator""_dp(unsigned long long v)
{
    return AMetric(static_cast<float>(static_cast<long long>(v)), AMetric::T_DP);
}
constexpr inline AMetric operator""_pt(unsigned long long v)
{
    return AMetric(static_cast<float>(static_cast<long long>(v)), AMetric::T_PT);
}
 
inline std::ostream& operator<<(std::ostream& o, const AMetric& value) {
    o << value.getRawValue();
    switch (value.getUnit()) {
        case AMetric::T_PX:
            o << "_px";
            break;
        case AMetric::T_DP:
            o << "_dp";
            break;
        case AMetric::T_PT:
            o << "_pt";
            break;
 
        default:
            break;
    }
    return o;
}