14#ifndef ZYPP_NG_BASE_SIGNALS_H_INCLUDED
15#define ZYPP_NG_BASE_SIGNALS_H_INCLUDED
18#include <sywu/signal.hpp>
20#include <sigc++/trackable.h>
21#include <sigc++/signal.h>
22#include <sigc++/connection.h>
23#include <sigc++/visit_each.h>
24#include <sigc++/adaptors/adaptors.h>
150 template <
class R,
class... T>
168 template <
class R,
class... T>
171 template <
class R,
class... T>
172 class Signal<R(T...)> :
public sywu::Signal<R(T...)>
182 using sigc::track_obj;
184 template <
class R,
class... T>
188 template <
class R,
class... T>
189 class Signal<R(T...)> :
public sigc::signal<R(T...)>
195 WAR <<
"Deleting Signal during emission, this is usually a BUG, Slots will be blocked to prevent SIGSEGV." << std::endl;
196#ifdef LIBZYPP_USE_SIGC_BLOCK_WORKAROUND
210 template <
class SignalHost,
typename ReturnType,
typename... Arguments>
220 WAR <<
"Deleting MemSignal during emission, this is definitely a BUG, Slots will be blocked to prevent SIGSEGV." << std::endl;
221#ifdef LIBZYPP_USE_SIGC_BLOCK_WORKAROUND
233 template<
typename...
Args>
235 auto ref = _host.shared_from_this();
236 return sigc::signal<
ReturnType(Arguments...)>::emit( std::forward<Args>(
arg)...);
239 template<
typename...
Args>
242 return sigc::signal<
ReturnType(Arguments...)>::operator()( std::forward<Args>(
arg)...);
255 template <
typename T>
258 if constexpr ( std::is_base_of_v<BasePrivate, T> ) {
259 return locker.z_func()->shared_from_this();
261 return locker.shared_from_this();
263 }
catch (
const std::bad_weak_ptr &
e ) {
273 template <
typename T_functor,
typename ...Lockers>
276 template <
typename...
Args>
277 decltype(
auto)
operator()(
Args&&... args )
const {
287 if constexpr (
sizeof... (
Args) == 0 ) {
290 return this->
functor_.template operator()<
decltype ( std::forward<Args>(args) )...> ( std::forward<Args>(args)... );
292 }
catch (
const std::bad_weak_ptr &
e ) {
294 ERR <<
"Ignoring signal emit due to a bad_weak_ptr exception during object locking. Maybe the signal was sent to a object that is currently destructing?" << std::endl;
298 if constexpr ( !std::is_same_v<void, typename sigc::adapts<T_functor>::result_type> )
299 return typename sigc::adapts<T_functor>::result_type{};
312 std::tuple<sigc::const_limit_reference<Lockers>...>
_lcks;
315 template<
typename Functor,
typename ...Obj >
324 template <
class R,
class... T>
332 template <
class R,
class... T>
343 template <
typename...
Args>
346 return _sig.connect( std::forward<Args>(
slot)... );
360 template <
typename T_functor,
typename ...Lockers>
361 struct visitor<
zyppng::internal::lock_shared<T_functor, Lockers...> >
363 template <
typename T_action>
367 sigc::visit_each(action, target.functor_);
368 std::apply( [&](
auto&...
a) {
369 ((void)sigc::visit_each(action,
a),...);
Reference counted access to a Tp object calling a custom Dispose function when the last AutoDispose h...
auto emit(Args &&...arg) const
MemSignal(SignalHost &host)
auto operator()(Args &&...arg) const
SignalProxy(SignalType &sig)
connection connect(Args &&... slot)
Forwards the arguments to the internal connect function of the signal type.
SignalProxyBase< R, T... > SignalType
decltype(auto) locking_fun(const Functor &f, const Obj &... o)
auto lock_shared_makeLock(const T &locker)
sigc::trackable trackable
sigc::connection connection
sigc::signal< R(T...)> SignalProxyBase
static void do_visit_each(const T_action &action, const zyppng::internal::lock_shared< T_functor, Lockers... > &target)
std::tuple< sigc::const_limit_reference< Lockers >... > _lcks
lock_shared(const T_functor &functor, const Lockers &... lcks)
#define ZYPP_CAUGHT(EXCPT)
Drops a logline telling the Exception was caught (in order to handle it).
#define ZYPP_THROW(EXCPT)
Drops a logline and throws the Exception.