EventLoop.h

Go to the documentation of this file.

/*
 * Copyright 2006-2008 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>

__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);

  ~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 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.
  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