APropertyDef.h

#pragma once
 
#include <AUI/Common/detail/property.h>

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);
   };

   aui::PropertyModifier<APropertyDef> writeScope() noexcept {
       return { std::move(*this) };
   }

   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));
   }
};
 
// implementation of property modifier for APropertyDef (in comparison to AProperty) has to call getter, store a copy
// within PropertyModifier and call setter upon destruction.
// this behaviour described here - https://aui-framework.github.io/develop/structAPropertyDef.html#declaration
template <
   typename M, aui::invocable<M&> Getter, aui::invocable<M&, std::invoke_result_t<Getter, M&>> Setter,
   typename SignalArg>
class aui::PropertyModifier<APropertyDef<M, Getter, Setter, SignalArg>> {
public:
   using Property = APropertyDef<M, Getter, Setter, SignalArg>;
   using Underlying = std::decay_t<typename Property::Underlying>;
   PropertyModifier(Property owner): mOwner(std::move(owner)), mCopyOfValue(*mOwner) {}
   ~PropertyModifier() {
       mOwner = std::move(mCopyOfValue); // calls setter
   }
 
   [[nodiscard]]
   Underlying& value() const noexcept {
       return mCopyOfValue;
   }
 
   [[nodiscard]]
   Underlying* operator->() const noexcept {
       return &value();
   }
 
private:
   Property mOwner;
   mutable Underlying mCopyOfValue;
};

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