MNSelector.h

Go to the documentation of this file.

/* Copyright (C) 2000 KOM/Darmstadt University of Technology
 *
 * You are allowed to use all other parts of the code under the following terms:
 *
 * For non-commercial use, code may be used in unmodified form provided
 * that this copyright notice and this permission notice appear in
 * supporting documentation.
 *
 * This software is provided "as is" and without any express or implied
 * warranties, including, without limitation, the implied warranty of
 * fitness for a particular purpose.
 *
 * The code may be subjected to the GNU General Public License, Version 2,
 * and re-distributed under the terms of this license.
 * As a special exception, permission is granted to link this code
 * with the Qt library and distribute executables, as long as you
 * follow the requirements of the GNU GPL in regard to all of the
 * software in the executable aside from Qt.
 *
 * Commercial use other than under the terms of the GNU General Public
 * License is allowed only after express negotiation of conditions
 * with the authors.
 */
#ifndef MN_SELECTOR_H
#define MN_SELECTOR_H

#define max_fd_find(i,j)        (((i)>(j)) ? (i) : (j))

/*************************************************************
 * Name: MNSelector
 * Short: takes up to all socket objects to wait for
 */

#include <assert.h>
#include <sys/time.h>

#include "dictionary.h"
#include "MNSocketBase.h"
#include "MNMutex.h"
#include "MNTimerEntry.h"
#include "MNTimerCall.h"
#include "MNValid.h"

/* An bugfix for an annoying define in net/net_globals.h on AIX */
#ifdef wakeup
#undef wakeup
#endif

class MNTimer;
class TimerCallBase;
class AutonomousTimer;

class MNSelector
{
    DECLARE_VALID

private:
    friend class MNTimer;
    friend class AutonomousTimer;

    typedef MNSocketBase* MNSocketBasePtr;
    typedef dictionary<int,MNSocketBasePtr> FdMap;

    FdMap   _fd_read_entries;
    FdMap   _fd_write_entries;
    MNMutex _fd_mutex;

    TimerMap _timer_entries;

    int private_init( fd_set& read_set, fd_set& write_set, fd_set& except_set );

public:
    MNSelector( bool notifiable );
    virtual ~MNSelector( );
  
    void select( );

    void insert( MNSocketBase* socketptr,
                 bool          threaded,
                 const char*   caller,
                 u_int32_t     set = MNSelector::READSET);

    void remove_fd ( int fd, u_int32_t set = MNSelector::BOTHSETS );
    void remove_fd ( MNSocketBase* socketptr );

    bool insert_abs_timer( void*                 data,
                           TimerCallBase*        timerptr,
                           const struct timeval& timeout,
                           const char*           owner );
    bool insert_rel_timer( void*                 data,
                           TimerCallBase*        timerptr,
                           const struct timeval& timeout,
                           const char*           owner );
    bool insert_periodic_timer( void*                 data,
                                TimerCallBase*        timerptr,
                                const struct timeval& timeout,
                                const char*           owner );
    bool cancel_timer( TimerCallBase* timerptr );
    void cancel_all_timers( );

public:
    static const bool DontWakeup = false;

    static const bool Wakeup     = true;

    static const u_int32_t READSET      = 0;
    static const u_int32_t WRITESET     = 1;
    static const u_int32_t BOTHSETS     = 2;

private:
    enum RW
    {
      Read  = 0,
      Write = 1,
      Both  = 2
    };

    int  _notepipe[Both];
    bool _notifiable;

public:
    void wakeup( );

    bool notifiable( ) const;

private:
    void private_debug_find_bad_fd( );
};

#endif /* MN_SELECTOR_H */

---