quickcpplib::_xxx::signal_guard::signal_guard_watchdog< T > Class Template Reference

Call an optional specified routine after a period of time, possibly on another thread. Async signal safe. More...

#include "signal_guard.hpp"

Inheritance diagram for quickcpplib::_xxx::signal_guard::signal_guard_watchdog< T >:

Public Member Functions
template<class U , typename std::enable_if<(std::is_constructible< T, U >::value), bool >::type = true, typename = decltype( std::declval<U>()() )>
	signal_guard_watchdog (U &&f, unsigned ms)
	Constructs an instance.
	~signal_guard_watchdog ()=default
	signal_guard_watchdog (const signal_guard_watchdog &)=delete
	signal_guard_watchdog (signal_guard_watchdog &&o) noexcept=default
signal_guard_watchdog &	operator= (const signal_guard_watchdog &)=delete
signal_guard_watchdog &	operator= (signal_guard_watchdog &&o) noexcept

Detailed Description

template<class T>
class quickcpplib::_xxx::signal_guard::signal_guard_watchdog< T >

Call an optional specified routine after a period of time, possibly on another thread. Async signal safe.

In your signal handler, you may have no choice but to execute async signal unsafe code e.g. you absolutely must call malloc() because third party code does so and there is no way to not call that third party code. This can very often lead to hangs, whether due to infinite loops or getting deadlocked by locking an already locked mutex.

This facility provides the ability to set a watchdog timer which will either call your specified routine or the default routine after a period of time after construction, unless it is released or destructed first. Your routine will be called via an async signal (SIGALRM) if on POSIX, or from a separate thread if on Windows. Therefore, if on Windows, a kernel thread will be launched on construction, and killed on destruction. On POSIX, a global signal continuation decider is ALWAYS installed at process init for signalc::timer_expire (SIGALRM) in order to implement signal_guard_watchdog, this is a filtering decider which only matches signal_guard_watchdog whose timers have expired, otherwise it passes on the signal to other handlers.

If you don't specify a routine, the default routine is terminate_process_immediately() which performs a fast fail process termination.

Constructor & Destructor Documentation

signal_guard_watchdog() [1/3]

template<class T >

template<class U , typename std::enable_if<(std::is_constructible< T, U >::value), bool >::type = true, typename = decltype( std::declval<U>()() )>

quickcpplib::_xxx::signal_guard::signal_guard_watchdog< T >::signal_guard_watchdog ( U &&  f, unsigned  ms  )

inline

Constructs an instance.

Parameters

f	A callable with prototype bool(raised_signal_info *), which must return true if execution is to resume, false if the next decider function should be called. Note that on Windows only, signalc::interrupt and signalc::process_terminate call f from some other kernel thread, and the return value is always treated as false.
callfirst	True if this decider should be called before any other. Otherwise call order is in the order of addition.

        : detail::signal_guard_watchdog_impl(ms)
        , _f(static_cast<U &&>(f))
    {
    }

~signal_guard_watchdog()

template<class T >

quickcpplib::_xxx::signal_guard::signal_guard_watchdog< T >::~signal_guard_watchdog ( )

default

signal_guard_watchdog() [2/3]

template<class T >

quickcpplib::_xxx::signal_guard::signal_guard_watchdog< T >::signal_guard_watchdog ( const signal_guard_watchdog< T > &  )

delete

signal_guard_watchdog() [3/3]

template<class T >

quickcpplib::_xxx::signal_guard::signal_guard_watchdog< T >::signal_guard_watchdog ( signal_guard_watchdog< T > &&  o )

defaultnoexcept

Member Function Documentation

operator=() [1/2]

template<class T >

signal_guard_watchdog & quickcpplib::_xxx::signal_guard::signal_guard_watchdog< T >::operator= ( const signal_guard_watchdog< T > &  )

delete

operator=() [2/2]

template<class T >

signal_guard_watchdog & quickcpplib::_xxx::signal_guard::signal_guard_watchdog< T >::operator= ( signal_guard_watchdog< T > &&  o )

inlinenoexcept

    {
      this->~signal_guard_watchdog();
      new(this) signal_guard_watchdog(static_cast<signal_guard_watchdog &&>(o));
      return *this;
    }

---

The documentation for this class was generated from the following file:

• include/quickcpplib/signal_guard.hpp