EventLoop.h

Go to the documentation of this file.

  /* Copyright 2006-2008, 2016 Savarese Software Research Corporation
   *
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   *
   * http://www.savarese.com/software/ApacheLicense-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   */
  
  #ifndef __SSRC_WISP_SERVICE_EVENT_LOOP_H
  #define __SSRC_WISP_SERVICE_EVENT_LOOP_H
  
  #include <ssrc/wisp/service/EventHandler.h>
  
  #include <memory>
  
  __BEGIN_NS_SSRC_WISP_SERVICE
  
  struct EventLoopState;
  
  class EventLoop {
  public:
  
   static const bool Once = true;
   static const bool Persist = false;
  
   typedef int EventIO;
  
   static const EventIO None;
   static const EventIO Read;
   static const EventIO Write;
   static const EventIO Error;
   static const EventIO Hangup;
   /*
   static const EventIO Signal;
   static const EventIO Timeout;
   */
   explicit EventLoop() SSRC_DECL_THROW(std::runtime_error);
  
   // Note, we cannot use ~EventLoop() = default; here because then
   // the compiler must generate the destructor, which requires EventLoopState
   // to be a complete type at this stage so that the destructor of
   // std::unique_ptr<EventLoopState> may be properly invoked. All
   // implementation must be in EventLoop.cc for this to work.
   ~EventLoop();
  
   void add_handler(EventHandler & handler,
   const int events,
   const TimeValue & timeout = InfiniteTimeValue,
   const bool once = Persist)
   SSRC_DECL_THROW(std::runtime_error);
  
   void remove_handler(EventHandler & handler);
  
   unsigned int count_handlers();
  
   unsigned int count_io_handlers();
  
   bool running();
  
   void start();
  
   void stop();
  
  private:
   // Only allow EventLoop.cc to see EventLoopState implementation details.
   // This speeds up client compilation times and avoids potential
   // conflicts arising from our placing system headers in custom
   // namespaces (e.g., Linux:: for <sys/epoll.h>). This comes
   // at the expense of awkwardness, requiring client code to
   // specify events as int instead of the native type,
   // and inability to inline accessor functions.
   const std::unique_ptr<EventLoopState> _state;
  };
  
  class EventInfo {
   friend void EventLoop::start();
  
   //int _fd;
   bool _timeout;
   int _io_events;
   EventLoop & _loop;
   TimeValue _now;
  
  public:
  
   explicit EventInfo(EventLoop & loop,
   //const int fd = -1,
   const int io_events = EventLoop::None,
   const bool timeout = false) :
   /* _fd(fd),*/ _timeout(timeout), _io_events(io_events), _loop(loop), _now()
   { }
  
   int io_events() const {
   return _io_events;
   }
  
   /*
   int descriptor() const {
   return _fd;
   }
   */
   EventLoop & event_loop() const {
   return _loop;
   }
   /*
   bool signal_event() const {
   return (_event & 0);
   }
   */
  
   const TimeValue & now() const {
   return _now;
   }
  
   bool timeout_event() const {
   return _timeout;
   }
  
   bool error_event() const {
   return (_io_events & EventLoop::Error);
   }
  
   bool hangup_event() const {
   return (_io_events & EventLoop::Hangup);
   }
  
   bool read_event() const {
   return (_io_events & EventLoop::Read);
   }
  
   bool write_event() const {
   return (_io_events & EventLoop::Write);
   }
  };
  
  __END_NS_SSRC_WISP_SERVICE
  
  #endif