FXDispatcher.h

/********************************************************************************
*                                                                               *
*                      C a l l b a c k   D i s p a t c h e r                    *
*                                                                               *
*********************************************************************************
* Copyright (C) 2006,2022 by Jeroen van der Zijp.   All Rights Reserved.        *
********************************************************************************/
#ifndef FXDISPATCHER_H
#define FXDISPATCHER_H

#ifndef FXREACTOR_H
#include "FXReactor.h"
#endif

namespace FX {


class FXAPI FXDispatcher : public FXReactor {
private:
  struct Handle;
  struct Signal;
  struct Idle;
  struct Timer;
private:
  FXHash        handles;                // Handle callbacks
  Signal      **signals;                // Signal callbacks
  Timer        *timers;                 // Timeout callbacks
  Idle         *idles;                  // Idle callbacks
  Timer        *timerrecs;              // Timer records
  Idle         *idlerecs;               // Idle records
private:
  FXDispatcher(const FXDispatcher&);
  FXDispatcher &operator=(const FXDispatcher&);
public:

  typedef FXCallback<FXbool(FXDispatcher*,FXInputHandle,FXuint,void*)> HandleCallback;

  typedef FXCallback<FXbool(FXDispatcher*,FXint,void*)> SignalCallback;

  typedef FXCallback<FXbool(FXDispatcher*,FXTime,void*)> TimeoutCallback;

  typedef FXCallback<FXbool(FXDispatcher*,void*)> IdleCallback;

public:

  FXDispatcher();

  virtual FXbool init();

  virtual FXbool addHandle(HandleCallback cb,FXInputHandle hnd,FXuint mode=InputRead,void* ptr=nullptr);

  virtual FXbool addHandle(FXInputHandle hnd,FXuint mode=InputRead);

  virtual FXbool remHandle(FXInputHandle hnd);

  virtual FXbool hasHandle(FXInputHandle hnd) const;

  virtual FXbool dispatchHandle(FXInputHandle hnd,FXuint mode,FXuint flags);

  virtual FXbool addSignal(SignalCallback cb,FXint sig,void* ptr=nullptr,FXbool async=false);

  virtual FXbool addSignal(FXint sig,FXbool async=false);

  virtual FXbool remSignal(FXint sig);

  virtual FXbool dispatchSignal(FXint sig);

  virtual void* addTimeout(TimeoutCallback cb,FXTime due,void* ptr=nullptr);

  virtual void* addInterval(TimeoutCallback cb,FXTime interval,void* ptr=nullptr);

  virtual void* remTimeout(TimeoutCallback cb);

  virtual FXTime getTimeout(TimeoutCallback cb) const;

  virtual FXbool hasTimeout(TimeoutCallback cb) const;

  virtual FXTime nextTimeout();

  virtual FXbool dispatchTimeout(FXTime due);

  virtual void* addIdle(IdleCallback cb,void* ptr=nullptr);

  virtual void* remIdle(IdleCallback cb);

  virtual FXbool hasIdle(IdleCallback cb) const;

  virtual FXbool dispatchIdle();

  virtual FXbool exit();

  virtual ~FXDispatcher();
  };


}

#endif