FXReactor.h

/********************************************************************************
*                                                                               *
*                            R e a c t o r   C l a s s                          *
*                                                                               *
*********************************************************************************
* Copyright (C) 2006,2024 by Jeroen van der Zijp.   All Rights Reserved.        *
*********************************************************************************
* This library is free software; you can redistribute it and/or modify          *
* it under the terms of the GNU Lesser General Public License as published by   *
* the Free Software Foundation; either version 3 of the License, or             *
* (at your option) any later version.                                           *
*                                                                               *
* This library is distributed in the hope that it will be useful,               *
* but WITHOUT ANY WARRANTY; without even the implied warranty of                *
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the                 *
* GNU Lesser General Public License for more details.                           *
*                                                                               *
* You should have received a copy of the GNU Lesser General Public License      *
* along with this program.  If not, see <http://www.gnu.org/licenses/>          *
********************************************************************************/
#ifndef FXREACTOR_H
#define FXREACTOR_H

namespace FX {


class FXAPI FXReactor {
  friend class FXEventDispatcher;
private:
  struct Internals;
private:
  Internals      *internals;            // Internals
  FXint           sigreceived;          // Most recent received signal
  FXint           numhandles;           // Number of handles
  FXint           numwatched;           // Number of watched
  FXint           numraised;            // Number of raised handles
  FXint           current;              // Current handle
private:
  static FXReactor* volatile sigmanager[64];
private:
  FXReactor(const FXReactor&);
  FXReactor &operator=(const FXReactor&);
private:
  static void CDECL signalhandler(FXint sig);
  static void CDECL signalhandlerasync(FXint sig);
public:

  enum {
    InputNone   = 0,                    
    InputRead   = 1,                    
    InputWrite  = 2,                    
    InputExcept = 4                     
    };

  enum {
    DispatchAll     = 0xffffffff,       
    DispatchSignals = 0x00000001,       
    DispatchTimers  = 0x00000002,       
    DispatchIdle    = 0x00000004,       
    DispatchEvents  = 0x00000008,       
    DispatchOther   = 0x00000010        
    };

  static const FXTime maxwait;

public:

  FXReactor();

  virtual FXbool init();

  FXbool isInitialized() const { return (internals!=nullptr); }

  virtual FXbool dispatch(FXTime blocking=forever,FXuint flags=DispatchAll);

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

  virtual FXbool remHandle(FXInputHandle hnd);

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

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

  virtual FXbool remSignal(FXint sig);

  virtual FXbool hasSignal(FXint sig) const;

  virtual FXbool dispatchSignal(FXint sig);

  virtual FXTime nextTimeout();

  virtual FXbool dispatchTimeout(FXTime due);

  virtual FXbool dispatchIdle();

  virtual FXbool exit();

  virtual ~FXReactor();
  };

}

#endif