EventHandler.h

Go to the documentation of this file.

/*
 * Copyright 2006-2009 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_HANDLER_H
#define __SSRC_WISP_SERVICE_EVENT_HANDLER_H

#include <ssrc/wisp/utility/TimeValue.h>

__BEGIN_NS_SSRC_WISP_SERVICE

using NS_SSRC_WISP_UTILITY::TimeValue;
using NS_SSRC_WISP_UTILITY::InfiniteTimeValue;

// Forward declaration of EventInfo.
class EventInfo;

// Currently implemented so you need one EventHandler instance per
// descriptor.  It is possible to implement this so that you can use
// the same EventHandler instance for multiple descriptors (passing
// the file descriptor to the handler via EventInfo), but it's only
// a benefit for EventHandlers that need to share state between
// descriptors or that consume a lot of memory.  Right now it's
// not a win because we still have to allocate structures that store
// timeout info and point to handlers, so why not just use the handler?
class EventHandler {
  friend class EventLoop;
  friend class EventLoopState;

  bool _handled_timeout; // scratch variable;
  bool _once;
#if defined(WISP_HAVE_NONPERSISTENT_EVENTS) || defined(WISP_HAVE_KQUEUE)
  int _events; // store original events of interest
#endif
  TimeValue _timeout;
  TimeValue _expiration;

protected:

  const TimeValue & timeout() const {
    return _timeout;
  }

  const TimeValue & expiration() const {
    return _expiration;
  }

  bool has_timeout() const {
    return (_timeout < InfiniteTimeValue);
  }

public:

  static const int NoDescriptor = -1;

  virtual ~EventHandler() { }

  virtual int event_descriptor() const {
    return NoDescriptor;
  }

#if defined(WISP_HAVE_NONPERSISTENT_EVENTS) || defined(WISP_HAVE_KQUEUE)
  int events() { return _events; }
#endif

  virtual void handle_read(const EventInfo & info) { }

  virtual void handle_write(const EventInfo & info) { }

  virtual void handle_timeout(const EventInfo & info) { }

  //virtual void handle_signal(const EventInfo & info) { }

  virtual void handle_error(const EventInfo & info) { }

  virtual void handle_hangup(const EventInfo & info) { }
};

__END_NS_SSRC_WISP_SERVICE

#endif