eventdispatcher.h

Go to the documentation of this file.

/*---------------------------------------------------------------------\
|                          ____ _   __ __ ___                          |
|                         |__  / \ / / . \ . \                         |
|                           / / \ V /|  _/  _/                         |
|                          / /__ | | | | | |                           |
|                         /_____||_| |_| |_|                           |
|                                                                      |
\----------------------------------------------------------------------/
*
* This file contains private API, this might break at any time between releases.
* You have been warned!
*
*/
#ifndef ZYPP_BASE_EVENTDISPATCHER_DEFINED
#define ZYPP_BASE_EVENTDISPATCHER_DEFINED
 
#include <zypp-core/ng/base/zyppglobal.h>
#include <zypp-core/ng/base/Signals>
#include <zypp-core/ng/base/Base>
#include <zypp-core/ng/base/AbstractEventSource>
#include <memory>
#include <functional>
 
namespace zyppng {
 
class SocketNotifier;
class Timer;
 
ZYPP_FWD_DECL_TYPE_WITH_REFS( EventDispatcher );
ZYPP_FWD_DECL_TYPE_WITH_REFS( UnixSignalSource );
class EventDispatcherPrivate;

class LIBZYPP_NG_EXPORT EventDispatcher : public Base
{
  ZYPP_DECLARE_PRIVATE(EventDispatcher)
  friend class AbstractEventSource;
  friend class Timer;
 
public:
 
  using Ptr = std::shared_ptr<EventDispatcher>;
  using WeakPtr = std::shared_ptr<EventDispatcher>;
  using IdleFunction = std::function<bool ()>;
  using TimeoutFunction = std::function<bool ()>;
 
 
  ~EventDispatcher() override;

  virtual bool run_once();

  template< typename T = IdleFunction >
  static void invokeOnIdle ( T &&callback )
  {
    auto ev = instance();
    if ( ev )
      ev->invokeOnIdleImpl( std::forward<T>(callback) );
  }

  template< typename T = TimeoutFunction >
  static void invokeAfter ( T &&callback, uint32_t timeout )
  {
    auto ev = instance();
    if ( ev )
      ev->invokeAfterImpl( std::forward<T>(callback), timeout );
  }
 

  template< typename T >
  static void unrefLater ( T &&ptr ) {
    auto ev = instance();
    if ( ev )
      ev->unrefLaterImpl( std::static_pointer_cast<void>( std::forward<T>(ptr) ) );
  }

  void clearUnrefLaterList ();

  ulong runningTimers() const;

  static std::shared_ptr<EventDispatcher> instance();

  static void setThreadDispatcher ( const std::shared_ptr<EventDispatcher> &disp );

  void *nativeDispatcherHandle () const;

  static bool waitForFdEvent ( const int fd, int events, int &revents, int &timeout );
 
  using WaitPidCallback = std::function<void(int, int)>;

  void trackChildProcess ( int pid, std::function<void(int, int)> callback  );

  bool untrackChildProcess ( int pid );

  UnixSignalSourceRef unixSignalSource ();
 
protected:

  EventDispatcher( void *ctx = nullptr );

  void unrefLaterImpl ( std::shared_ptr<void> &&ptr );

  void invokeOnIdleImpl ( IdleFunction &&callback );
 

  void invokeAfterImpl (TimeoutFunction &&callback, uint32_t timeout );

  virtual void updateEventSource ( AbstractEventSource &notifier, int fd, int mode );

  virtual void removeEventSource   ( AbstractEventSource &notifier, int fd = -1 );

  virtual void registerTimer ( Timer &timer );

  virtual void removeTimer ( Timer &timer );
 
};
 
}
 
#endif