AProperty.h

/*
 * AUI Framework - Declarative UI toolkit for modern C++20
 * Copyright (C) 2020-2025 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/Common/ASignal.h>
#include <AUI/Common/APropertyPrecomputed.h>
#include <AUI/Common/PropertyModifier.h>
#include <AUI/Common/detail/property.h>

template <typename T>
struct AProperty: AObjectBase {
   static_assert(!std::is_reference_v<T>, "====================> AProperty: attempt to wrap a reference.");
 
   using Underlying = T;

   T raw{};

   emits<T> changed;
 
   AProperty()
       requires aui::default_initializable<T>
   = default;
 
   template <aui::convertible_to<T> U>
   AProperty(U&& value) noexcept(noexcept(T(std::forward<U>(value)))): raw(std::forward<U>(value)) {}
 
   AObjectBase* boundObject() {
       return this;
   }
 
   const AObjectBase* boundObject() const {
       return this;
   }
 
   AProperty(const AProperty& value): raw(value.raw) {
   }
 
   AProperty(AProperty&& value) noexcept: raw(std::move(value.raw)) {
       value.notify();
   }
 
   AProperty& operator=(const AProperty& value) {
       if (this == &value) {
           return *this;
       }
       operator=(value.raw);
       return *this;
   }
 
   AProperty& operator=(AProperty&& value) noexcept {
       if (this == &value) {
           return *this;
       }
       operator=(std::move(value.raw));
       value.notify();
       return *this;
   }
 
   template <aui::convertible_to<T> U>
   AProperty& operator=(U&& value) noexcept {
       static constexpr auto IS_COMPARABLE = requires { this->raw == value; };
       if constexpr (IS_COMPARABLE) {
           if (this->raw == value) [[unlikely]] {
               return *this;
           }
       }
       this->raw = std::forward<U>(value);
       notify();
       return *this;
   }
 
   template <ASignalInvokable SignalInvokable>
   void operator^(SignalInvokable&& t) {
       t.invokeSignal(nullptr);
   }

   void notify() {
       emit changed(this->raw);
   }
 
   [[nodiscard]]
   const T& value() const noexcept {
       aui::react::DependencyObserverRegistrar::addDependency(changed);
       return raw;
   }
 
   [[nodiscard]] operator const T&() const noexcept { return value(); }
 
   [[nodiscard]]
   const T* operator->() const noexcept {
       return &value();
   }
 
   [[nodiscard]]
   const T& operator*() const noexcept {
       return value();
   }

   aui::PropertyModifier<AProperty> writeScope() noexcept {
       return { *this };
   }

   template<aui::invocable<const T&> Projection>
   [[nodiscard]]
   auto readProjected(Projection&& projection) const noexcept {
       return aui::detail::property::makeReadonlyProjection(*this, std::forward<Projection>(projection));
   }

   template<aui::invocable<const T&> ProjectionRead,
            aui::invocable<const std::invoke_result_t<ProjectionRead, T>&> ProjectionWrite>
   [[nodiscard]]
   auto biProjected(ProjectionRead&& projectionRead, ProjectionWrite&& projectionWrite) noexcept {
       return aui::detail::property::makeBidirectionalProjection(*this,
                                                                 std::forward<ProjectionRead>(projectionRead),
                                                                 std::forward<ProjectionWrite>(projectionWrite));
   }

   template<aui::detail::property::ProjectionBidirectional<T> Projection>
   [[nodiscard]]
   auto biProjected(Projection&& projectionBidirectional) noexcept {
       return aui::detail::property::makeBidirectionalProjection(*this, projectionBidirectional);
   }
 
private:
   friend class AObject;
   [[nodiscard]]
   auto assignment() noexcept {
       return aui::detail::property::makeAssignment(*this);
   }
};
static_assert(AAnyProperty<AProperty<int>>, "AProperty does not conform AAnyProperty concept");
static_assert(AAnyProperty<AProperty<int>&>, "AProperty does not conform AAnyProperty concept");
static_assert(APropertyReadable<const AProperty<int>>, "const AProperty does not conform AAnyProperty concept");
 
template<typename T>
class aui::PropertyModifier<AProperty<T>> {
public:
   using Underlying = T;
   PropertyModifier(AProperty<T>& owner): mOwner(&owner) {}
   ~PropertyModifier() {
       if (mOwner == nullptr) {
           return;
       }
       mOwner->notify();
   }
 
   [[nodiscard]]
   Underlying& value() const noexcept {
       return mOwner->raw;
   }
 
   [[nodiscard]]
   Underlying* operator->() const noexcept {
       return &value();
   }
 
private:
   AProperty<T>* mOwner;
};
 

template <
   typename M, aui::invocable<M&> Getter, aui::invocable<M&, std::invoke_result_t<Getter, M&>> Setter,
   typename SignalArg>
struct APropertyDef {
   const M* base;
   using Model = M;

   Getter get;

   Setter set;
   using GetterReturnT = decltype(std::invoke(get, base));
   using Underlying = std::decay_t<GetterReturnT>;

   const emits<SignalArg>& changed;
   static_assert(aui::same_as<Underlying , std::decay_t<SignalArg>>, "different getter result and signal arg?");
 
   // this ctor effectively prohibits designated initialization, i.e., this one is not possible:
   //
   // auto size() const {
   //     return APropertyDef {
   //         .base = this,
   //         .get = &AView::mSize,
   //         .set = &AView::setSize,
   //         .changed = mSizeChanged,
   //     };
   // }
   //
   // deduction in designated initializers is relatively recent feature.
   APropertyDef(const M* base, Getter get, Setter set, const emits<SignalArg>& changed)
     : base(base), get(std::move(get)), set(std::move(set)), changed(changed) {}
 
   template <aui::convertible_to<Underlying> U>
   APropertyDef& operator=(U&& u) {
       std::invoke(set, *const_cast<Model*>(base), std::forward<U>(u));
       return *this;
   }
 
   [[nodiscard]]
   GetterReturnT value() const noexcept {
       return std::invoke(get, base);
   }
 
   [[nodiscard]]
   GetterReturnT operator*() const noexcept {
       return std::invoke(get, base);
   }
 
   [[nodiscard]]
   const Underlying* operator->() const noexcept {
       return &std::invoke(get, base);
   }
 
   [[nodiscard]] operator GetterReturnT() const noexcept { return std::invoke(get, base); }
 
   [[nodiscard]]
   M* boundObject() const {
       return const_cast<M*>(base);
   }

   template <aui::invocable<const Underlying&> Projection>
   [[nodiscard]]
   auto readProjected(Projection&& projection) noexcept {
       return aui::detail::property::makeReadonlyProjection(std::move(*this), std::forward<Projection>(projection));
   }

   template <
       aui::invocable<const Underlying&> ProjectionRead,
       aui::invocable<const std::invoke_result_t<ProjectionRead, Underlying>&> ProjectionWrite>
   [[nodiscard]]
   auto biProjected(ProjectionRead&& projectionRead, ProjectionWrite&& projectionWrite) noexcept {
       return aui::detail::property::makeBidirectionalProjection(
           std::move(*this), std::forward<ProjectionRead>(projectionRead),
           std::forward<ProjectionWrite>(projectionWrite));
   }

   template <aui::detail::property::ProjectionBidirectional<Underlying> Projection>
   [[nodiscard]]
   auto biProjected(Projection&& projectionBidirectional) noexcept {
       return aui::detail::property::makeBidirectionalProjection(std::move(*this), projectionBidirectional);
   };

   void notify() {
       if (changed.hasOutgoingConnections()) {
           emit changed(this->value());
       }
   }
 
private:
   friend class AObject;
   [[nodiscard]]
   auto assignment() noexcept {
       return aui::detail::property::makeAssignment(std::move(*this));
   }
};
 
// binary operations for properties.
// note: sync this PropertyModifier.h
template<AAnyProperty Lhs, typename Rhs>
[[nodiscard]]
inline auto operator==(const Lhs& lhs, Rhs&& rhs) {
   return *lhs == std::forward<Rhs>(rhs);
}
 
template<AAnyProperty Lhs, typename Rhs>
[[nodiscard]]
inline auto operator!=(const Lhs& lhs, Rhs&& rhs) {
   return *lhs != std::forward<Rhs>(rhs);
}
 
template<AAnyProperty Lhs, typename Rhs>
[[nodiscard]]
inline auto operator<<(const Lhs& lhs, Rhs&& rhs) {
   return *lhs << std::forward<Rhs>(rhs);
}
 
template<AAnyProperty Lhs, typename Rhs>
[[nodiscard]]
inline auto operator>>(const Lhs& lhs, Rhs&& rhs) {
   return *lhs >> std::forward<Rhs>(rhs);
}
 
template<AAnyProperty Lhs, typename Rhs>
[[nodiscard]]
inline auto operator<(const Lhs& lhs, Rhs&& rhs) {
   return *lhs < std::forward<Rhs>(rhs);
}
 
template<AAnyProperty Lhs, typename Rhs>
[[nodiscard]]
inline auto operator>(const Lhs& lhs, Rhs&& rhs) {
   return *lhs > std::forward<Rhs>(rhs);
}
 
template<AAnyProperty Lhs, typename Rhs>
[[nodiscard]]
inline auto operator<=(const Lhs& lhs, Rhs&& rhs) {
   return *lhs <= std::forward<Rhs>(rhs);
}
 
template<AAnyProperty Lhs, typename Rhs>
[[nodiscard]]
inline auto operator>=(const Lhs& lhs, Rhs&& rhs) {
   return *lhs >= std::forward<Rhs>(rhs);
}
 
template<AAnyProperty Lhs, typename Rhs>
[[nodiscard]]
inline auto operator+(const Lhs& lhs, Rhs&& rhs) {
   return *lhs + std::forward<Rhs>(rhs);
}
 
template<AAnyProperty Lhs, typename Rhs>
[[nodiscard]]
inline auto operator-(const Lhs& lhs, Rhs&& rhs) {
   return *lhs - std::forward<Rhs>(rhs);
}
 
template<AAnyProperty Lhs, typename Rhs>
inline decltype(auto) operator+=(Lhs& lhs, Rhs&& rhs)  {
   if constexpr (requires { *lhs += std::forward<Rhs>(rhs); }) {
       // const operator?
       return *lhs += std::forward<Rhs>(rhs);
   } else {
       return *lhs.writeScope() += std::forward<Rhs>(rhs);
   }
}
 
template<AAnyProperty Lhs, typename Rhs>
inline decltype(auto) operator+=(Lhs&& lhs, Rhs&& rhs) {
   return lhs = *lhs + std::forward<Rhs>(rhs);
}
 
// simple check above operators work.
static_assert(requires { AProperty<int>() + 1; });
 
 
/*
// UNCOMMENT THIS to test biProjected
static_assert(requires (AProperty<int>& intProperty) {
   { intProperty.biProjected(aui::lambda_overloaded {
     [](int) -> AString { return ""; },
     [](const AString&) -> int { return 0; },
   }).value() } -> aui::convertible_to<AString>;
 
   { intProperty.biProjected(aui::lambda_overloaded {
       [](int) -> AString { return ""; },
       [](const AString&) -> int { return 0; },
   }) = "AString" };
 
 
   { intProperty.biProjected(aui::lambda_overloaded {
       [](int) -> AString { return ""; },
       [](const AString&) -> int { return 0; },
   }) };
 
   { intProperty.biProjected(aui::lambda_overloaded {
       [](int) -> AString { return ""; },
       [](const AString&) -> int { return 0; },
   }).assignment() } -> aui::invocable<AString>;
});
*/
 
template <APropertyReadable T> struct fmt::formatter<T> {
   template<typename ParseContext>
   constexpr auto parse(ParseContext& ctx)
   {
       return ctx.begin();
   }
 
   auto format(T& c, format_context& ctx) const {
       return fmt::format_to(ctx.out(), "{}", *c);
   }
};

© 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.