values.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 <type_traits>
#include <cassert>
#include <utility>
#include <functional>
#include <optional>
#include <glm/glm.hpp>
#include <AUI/Common/SharedPtrTypes.h>
#include <AUI/Common/AOptional.h>
#include <AUI/Thread/AMutex.h>
#include <AUI/Traits/concepts.h>
 
namespace aui {
    struct noncopyable {
        noncopyable() = default;
        noncopyable(const noncopyable&) = delete;
        noncopyable& operator=(const noncopyable&) = delete;
    };
 

    template<typename T>
    class assert_not_used_when_null {
    private:
        T mValue;
 
    public:
        assert_not_used_when_null(T value) noexcept: mValue(std::move(value)) {}
 
        template<typename AnyType>
        operator AnyType() noexcept {
            if constexpr(!std::is_same_v<AnyType, bool>) {
                AUI_ASSERTX(mValue != nullptr, "value is used when null");
            }
            return AnyType(mValue);
        }
 
        [[nodiscard]]
        T value() const noexcept {
            return mValue;
        }
 
        template<typename AnyType>
        bool operator==(const AnyType& v) const noexcept {
            return mValue == v;
        }
 
        template<typename AnyType>
        bool operator!=(const AnyType& v) const noexcept {
            return mValue != v;
        }
    };
 
 
    template<typename T>
    struct non_null_lateinit {
    private:
        void checkForNull() const { AUI_ASSERTX(value != nullptr, "this value couldn't be null"); }
    public:
        T value;
        non_null_lateinit() {
 
        }
 
        non_null_lateinit(T value): value(std::move(value)) {
            checkForNull();
        }
 
        operator T() const noexcept {
            checkForNull();
            return value;
        }
        auto operator->() const {
            checkForNull();
            return &*value;
        }
    };
 
    template<typename T>
    struct non_null: non_null_lateinit<T> {
        non_null(T value): non_null_lateinit<T>(std::move(value)) {}
    };

    template<typename T>
    struct no_escape {
    static_assert(!std::is_reference<T>::value, "use undecorated type (without reference)");
    static_assert(!std::is_pointer_v<T>, "use undecorated type (without pointer)");
    private:
        T* value;
 
    public:
        no_escape(T& value): value(&value) {
            AUI_ASSERTX(no_escape::value != nullptr, "the argument could not be null");
        }
        // referring to a temporary value; no_escape should never be used anything else than as argument
        // NOLINTNEXTLINE(cppcoreguidelines-rvalue-reference-param-not-moved)
        no_escape(T&& value): value(&value) {
            AUI_ASSERTX(no_escape::value != nullptr, "the argument could not be null");
        }
        no_escape(T* value): value(value) {
            AUI_ASSERTX(no_escape::value != nullptr, "the argument could not be null");
        }
 
        no_escape(const _<T>& value): value(&*value) {
            AUI_ASSERTX(no_escape::value != nullptr, "the argument could not be null");
        }
        no_escape(const _unique<T>& value): value(&*value) {
            AUI_ASSERTX(no_escape::value != nullptr, "the argument could not be null");
        }
 
        template<typename DerivedFromT, std::enable_if_t<std::is_base_of_v<T, DerivedFromT> && !std::is_same_v<DerivedFromT, T>, bool> = true>
        no_escape(const _<DerivedFromT>& value): value(&*value) {
            AUI_ASSERTX(no_escape::value != nullptr, "the argument could not be null");
        }
 
        template<typename DerivedFromT, std::enable_if_t<std::is_base_of_v<T, DerivedFromT> && !std::is_same_v<DerivedFromT, T>, bool> = true>
        no_escape(const _unique<DerivedFromT>& value): value(&*value) {
            AUI_ASSERTX(no_escape::value != nullptr, "the argument could not be null");
        }
 
        [[nodiscard]]
        T* ptr() const noexcept {
            return value;
        }
 
        T* operator->() const noexcept {
            return value;
        }
 
        T& operator*() const noexcept {
            return *value;
        }
    };

    template<typename T = void>
    struct lazy {
    private:
        mutable AOptional<T> value;
        std::function<T()> initializer;
    public:
        template<typename Factory, std::enable_if_t<std::is_invocable_r_v<T, Factory>, bool> = true>
        lazy(Factory&& initializer) noexcept : initializer(std::forward<Factory>(initializer)) {}
 
        lazy(const lazy<T>& other) noexcept: value(other.value), initializer(other.initializer) {}
        lazy(lazy<T>&& other) noexcept: value(std::move(other.value)), initializer(std::move(other.initializer)) {}
 
        T& get() {
            if (!value) {
                value = initializer();
            }
            return *value;
        }
        const T& get() const {
            return const_cast<lazy<T>*>(this)->get();
        }
 
        operator T&() {
            return get();
        }
        operator const T&() const {
            return get();
        }
 
        T& operator*() {
            return get();
        }
        const T& operator*() const {
            return get();
        }
 
        T* operator->() {
            return &get();
        }
        T const * operator->() const {
            return &get();
        }
 
        lazy<T>& operator=(T&& t) {
            value = std::move(t);
            return *this;
        }
        lazy<T>& operator=(const T& t) {
            value = t;
            return *this;
        }
 
        void reset() {
            value.reset();
        }
 
        explicit operator bool() const noexcept requires requires { !aui::same_as<T, bool>; } {
            return hasValue();
        }
 
        [[nodiscard]]
        bool hasValue() const noexcept {
            return value.hasValue();
        }
    };

    template<>
    struct lazy<void> {
    private:
        mutable bool value = false;
        std::function<void()> initializer;
    public:
        template<typename Factory, std::enable_if_t<std::is_invocable_r_v<void, Factory>, bool> = true>
        lazy(Factory&& initializer) noexcept : initializer(std::forward<Factory>(initializer)) {}
 
        lazy(const lazy<void>& other) noexcept: value(other.value), initializer(other.initializer) {}
        lazy(lazy<void>&& other) noexcept: value(other.value), initializer(std::move(other.initializer)) {}
 
        void get() {
            if (!value) {
                value = true;
                initializer();
            }
        }
        void get() const {
            return const_cast<lazy<void>*>(this)->get();
        }
 
        void operator*() {
            return get();
        }
        const void operator*() const {
            return get();
        }
 
 
        void reset() {
            value = false;
        }
 
        [[nodiscard]]
        bool hasValue() const noexcept {
            return value;
        }
    };

    template<typename T>
    struct atomic_lazy {
    private:
        mutable AMutex sync;
        mutable AOptional<T> value;
        std::function<T()> initializer;
    public:
        template<typename Factory, std::enable_if_t<std::is_invocable_r_v<T, Factory>, bool> = true>
        atomic_lazy(Factory&& initializer) : initializer(std::forward<Factory>(initializer)) {}
 
        atomic_lazy(const atomic_lazy<T>& other) {
            std::unique_lock lock(other.sync);
            value = other.value;
            initializer = other.initializer;
        }
        atomic_lazy(atomic_lazy<T>&& other) noexcept {
            std::unique_lock lock(other.sync);
            value = std::move(other.value);
            initializer = std::move(other.initializer);
        }
 
        T& get() {
            if (!value) {
                std::unique_lock lock(sync);
                if (!value) {
                    value = initializer();
                }
            }
            return *value;
        }
        const T& get() const {
            return const_cast<atomic_lazy<T>*>(this)->get();
        }
 
        operator T&() {
            return get();
        }
        operator const T&() const {
            return get();
        }
 
        T& operator*() {
            return get();
        }
        const T& operator*() const {
            return get();
        }
 
        T* operator->() {
            return &get();
        }
        T const * operator->() const {
            return &get();
        }
 
        atomic_lazy<T>& operator=(T&& t) {
            std::unique_lock lock(sync);
            value = std::move(t);
            return *this;
        }
 
        atomic_lazy<T>& operator=(const T& t) {
            std::unique_lock lock(sync);
            value = t;
            return *this;
        }
 
        void reset() {
            std::unique_lock lock(sync);
            value.reset();
        }
 
        [[nodiscard]]
        bool hasValue() const noexcept {
            std::unique_lock lock(sync);
            return value.hasValue();
        }
    };
 
    namespace constraint {
        template<typename T>
        class avoid_copy {
        private:
            T* value;
 
        public:
            avoid_copy(T& value): value(&value) {          // implicit initializer
 
            }
            operator T&() const {                      // implicit conversion
                return *value;
            }
 
            T& operator*() const {                     // std dereference
                return *value;
            }
            T* operator->() const {                    // allow pointer-style calls
                return value;
            }
        };

        template<typename T>
        class move_only {
        private:
            T value;
 
        public:
            move_only(T&& rhs): value(std::move(rhs)) {
 
            }
            move_only(move_only&& rhs) noexcept: value(std::move(rhs.value)) {
 
            }
            move_only(const move_only&) = delete;
 
            operator const T&() const {
                return value;
            }
            operator T&() {
                return value;
            }
 
            const T& operator*() const {
                return value;
            }
            const T* operator->() const {
                return &value;
            }
            T* operator->() {
                return &value;
            }
        };
    }
 
 

    template<aui::arithmetic UnderlyingType,
             auto /* UnderlyingType*/ min,
             auto /* UnderlyingType*/ max> // min and max are defined auto because some static analyzers won't work with
                                           // float value template arguments
    requires aui::convertible_to<decltype(min), UnderlyingType> && aui::convertible_to<decltype(max), UnderlyingType>
    struct ranged_number {
    public:
         static constexpr auto MIN = min;
         static constexpr auto MAX = max;
 
        ranged_number(UnderlyingType value): value(glm::clamp(value, static_cast<UnderlyingType>(min), static_cast<UnderlyingType>(max))) {}
        ranged_number(): value(min) {}
 
        operator UnderlyingType() const { // make it possible to work with ranged_number like with the underlying type
            return value;
        }
 
    private:
        UnderlyingType value;
    };
 
    using float_within_0_1 = ranged_number<float, 0, 1>;
}

© 2025 AUI Framework Contributors. Documentation contributions included herein are the copyrights of their respective owners. The documentation provided herein is licensed under the terms of the GNU Free Documentation License version 1.3 as published by the Free Software Foundation. All trademarks are property of their respective owners.