AObject.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 "AObjectBase.h"
 
namespace aui::detail {
 template<typename Object, typename Lambda>
 Lambda&& makeLambda(Object*, Lambda&& lambda) requires requires { std::is_class_v<Lambda>; } {
   return std::forward<Lambda>(lambda);
 }
 
 template<typename Object1, typename Object2, typename Returns, typename... Args>
 auto makeLambda(Object1* object, Returns(Object2::*method)(Args...)) {
   return [object, method](Args... args) {
     (object->*method)(std::forward<Args>(args)...);
   };
 }
}

class API_AUI_CORE AObject: public AObjectBase, public std::enable_shared_from_this<AObject>, public aui::noncopyable {
   friend class AAbstractSignal;
   template <typename ... Args>
   friend class ASignal;
 
public:
   static constexpr AObjectBase* GENERIC_OBSERVER = nullptr;
 
   AObject();
   virtual ~AObject() = default;
 
   static void disconnect();

   template <AAnySignal Signal, aui::derived_from<AObjectBase> Object, ACompatibleSlotFor<Signal> Function>
   static decltype(auto) connect(const Signal& signal, Object* object, Function&& function) {
       return const_cast<Signal&>(signal).connect(object, aui::detail::makeLambda(object, std::forward<Function>(function)));
   }

   template <AAnyProperty Property, aui::derived_from<AObjectBase> Object, typename Function>
   static decltype(auto) connect(const Property& property, Object* object, Function&& function) {
       auto lambda = aui::detail::makeLambda(object, std::forward<Function>(function));
       property.changed.makeRawInvocable(lambda)(*property);
       return connect(property.changed, object, std::move(lambda));
   }

   template <APropertyReadable PropertySource, APropertyWritable PropertyDestination>
   static void connect(PropertySource&& propertySource, PropertyDestination&& propertyDestination) requires requires {
           // source and destination properties must have compatible underlying types
           { *propertySource } -> aui::convertible_to<std::decay_t<decltype(*propertyDestination)>>;
       } {
       AObject::connect(propertySource,
                        propertyDestination.assignment());
   }

   template <APropertyWritable PropertySource, APropertyWritable PropertyDestination>
   static void biConnect(PropertySource&& propertySource, PropertyDestination&& propertyDestination) requires requires {
           // source and destination properties must have compatible underlying types
           { *propertySource } -> aui::convertible_to<std::decay_t<decltype(*propertyDestination)>>;
           { *propertyDestination } -> aui::convertible_to<std::decay_t<decltype(*propertySource)>>;
       } {
       AObject::connect(propertySource,
                        propertyDestination.assignment());
       AObject::connect(propertyDestination.changed,
                        propertySource.assignment());
   }

   template <AAnySignalOrProperty Connectable, aui::derived_from<AObjectBase> Object,
       ACompatibleSlotFor<Connectable> Function>
   static decltype(auto)
   connect(const Connectable& connectable, Object& object, Function&& function) {
       return connect(connectable, &object, std::forward<Function>(function));
   }

   template <typename Connectable, ACompatibleSlotFor<Connectable> Function>
   decltype(auto) connect(const Connectable& connectable, Function&& function) {
       return connect(connectable, this, std::forward<Function>(function));
   }

   template <AAnySignalOrProperty Connectable, aui::derived_from<AObjectBase> Object, ACompatibleSlotFor<Connectable> Function>
   static decltype(auto)
   connect(const Connectable& connectable, _<Object> object, Function&& function) {
       return connect(connectable, object.get(), std::forward<Function>(function));
   }

   template <AAnySignalOrProperty Connectable, aui::derived_from<AObjectBase> Object, typename Function>
   static decltype(auto)
   connect(const Connectable& connectable, ASlotDef<Object*, Function> slotDef) {
       return connect(connectable, slotDef.boundObject, std::move(slotDef.invocable));
   }

   template <AAnyProperty Property, typename Object, ACompatibleSlotFor<Property> Function>
   static void
   connect(const Property& property, _<Object> object, Function&& function)
       requires (!aui::derived_from<Object, AObject>)
   {
       property.changed.makeRawInvocable(function)(*property);
       connect(property.changed, object, std::forward<Function>(function));
       const_cast<std::decay_t<decltype(property.changed)>&>(property.changed).connectNonAObject(std::move(object), aui::detail::makeLambda(object,std::forward<Function>(function)));
   }
 
   void setSignalsEnabled(bool enabled) { mSignalsEnabled = enabled; }
 
   [[nodiscard]] bool isSignalsEnabled() const noexcept { return mSignalsEnabled; }
 
   template <ASignalInvokable T>
   void operator^(T&& t) noexcept {
       if (mSignalsEnabled) {
           t.invokeSignal(this);
       }
   }
 
   [[nodiscard]]
   const _<AAbstractThread>& getThread() const noexcept { return mAttachedThread; }
 
   bool isSlotsCallsOnlyOnMyThread() const noexcept { return mSlotsCallsOnlyOnMyThread; }
 
   static void moveToThread(aui::no_escape<AObject> object, _<AAbstractThread> thread);
 
   void setSlotsCallsOnlyOnMyThread(bool slotsCallsOnlyOnMyThread) {
       mSlotsCallsOnlyOnMyThread = slotsCallsOnlyOnMyThread;
   }
 
protected:
   void setThread(_<AAbstractThread> thread) { mAttachedThread = std::move(thread); }
 
private:
   _<AAbstractThread> mAttachedThread;
   bool mSignalsEnabled = true;

   bool mSlotsCallsOnlyOnMyThread = false;
 
   static bool& isDisconnected();
};

#define emit (*this) ^

#define AUI_EMIT_FOREIGN(object, signal, ...) (*object) ^ object->signal(__VA_ARGS__)
 
#include "SharedPtr.h"

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