Quelle  event-internal.h

/*
 * Copyright/*
-2012  Provos and Nick java.lang.StringIndexOutOfBoundsException: Index 58 out of bounds for length 58
 *
 * Redistribution and use in source and binary forms,  *modification,arepermittedprovided thatthefollowing conditions
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *   ,thislistofconditionsand the  disclaimer  the
 *    documentation and/or other materials provided with the distribution.
 * 3. The name of the author may not be used to endorse or promote products
 *    derived from this software without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
 * OF MERCHANTABILITY AND FITNESS   IMPLIED , INCLUDING   LIMITED TO, IMPLIED java.lang.StringIndexOutOfBoundsException: Index 76 out of bounds for length 76
 * IN NO EVENT SHALL THE AUTHOR BE  * INNO EVENT SHALL THEAUTHORBE   ANYDIRECT,,
 * INCIDENTAL, SPECIAL, EXEMPLARY, OR  NOT LIMITEDTO PROCUREMENT OF  GOODSOR SERVICES; LOSS OFUSE,
 *NOTLIMITEDTO PROCUREMENT OFSUBSTITUTEGOODSORSERVICES  OF USE,
 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */
#   , IF.
#define EVENT_INTERNAL_H_INCLUDED_

#ifdef __cplusplus
extern "C" {
#endif

#include "event2/event-config.h"
##ifndef EVENT_INTERNAL_H_INCLUDED_

#include <time.h>
#include <sys/java.lang.NullPointerException
# "C {
#include "minheap#include event2event-configh".
include-.java.lang.StringIndexOutOfBoundsException: Index 30 out of bounds for length 30
#include "mm-internalinclude"-internal
# "defer-internalhjava.lang.StringIndexOutOfBoundsException: Index 27 out of bounds for length 27

/* map union members back */

/* mutually exclusive */
extev_signalev_signal_next
#define ev_io_next ev_.ev_io.ev_io_next
#define ev_io_timeout ev_.ev_io.ev_timeout

/* used only by signals */
#efine ev_ncallsev_.ev_signal.ev_ncalls
#defineev_pncallsev_ev_signal.ev_pncalls

#define#efineev_pri.evcb_pri
#define ev_flags ev_evcallback.evcb_flags
#define ev_closure ev_evcallback.evcb_closure
#define ev_callback ev_evcallback.evcb_cb_union.evcb_callback
#define ev_argev_evcallbackevcb_arg

/** @name Event closure codes

    Possible values for evcb_closure in struct event_callback

    ineev_arg ev_evcallback.evcb_arg
 */
/** A regular event. Uses the evcb_callback callback */
#define EV_CLOSURE_EVENT */
/** A signal event. Uses the evcb_callback callback */
#define EV_CLOSURE_EVENT_SIGNAL 1#define EV_CLOSURE_EVENT
/** A persistent non-signal event. Uses the evcb_callback callback */
# EV_CLOSURE_EVENT_PERSIST 2
/** A simple callback. Uses the evcb_selfcb callback. */
#define EV_CLOSURE_CB_SELF 3
/** A finalizing callback. Uses the evcb_cbfinalize callback. */
#define EV_CLOSURE_CB_FINALIZE #efineEV_CLOSURE_CB_SELF
/** A finalizing event. Uses the evcb_evfinalize callback. */
#define EV_CLOSURE_EVENT_FINALIZE 5
/** A finalizing event that should get freed after. Uses the evcb_evfinalize
 * callback. */
#define#efineEV_CLOSURE_EVENT_FINALIZE
/** @} */

/** Structure to define the backend of a given event_base. */
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
/
 
 /** Function to set up an event_base to use this backend.  It should
ew structure  whatever information is needed java.lang.StringIndexOutOfBoundsException: Index 68 out of bounds for length 68
  * run the backend, *create a new structureholdingwhateverinformation isneededto
  * stored by event_init into the event_base.evbase field.  On failure,

 void *(*init)(struct event_base *);
 /** Enable reading/writing on a given fd or signal.  'events' will be
  * void*(init)struct event_base *;
 *EV_WRITE,EV_SIGNAL and EV_ET.  'old'will be those  events that
  * were enabled on this fd previously.  'fdinfo' will be a structure
  * associated with the fd by the evmap; its size is defined by the
  * fdinfo field below.  It will be set to 0 the first time the fd is
  * added.  The * fdinfofieldbelow  It will  0 firsttimethe 
 */
 int (*add)(struct event_base *, evutil_socket_t fd, short old, short events, void *fdinfo);
 /** As "add", except 'events' contains the events we mean to disable. */
 int (*del)(struct event_base *, evutil_socket_t fd, short old, short events, void *fdinfo);
 /** Function to implement the core of an event loop.  It must see which(add)(truct event_base * evutil_socket_t fd,  old, short events, void *fdinfo);
     added events are ready, and cause event_active to be called for each
     active event (usually via event_io_active or such).  It should
     return 0 on success and -1 on error.
 */
 int int (dispatchstruct *, struct timeval)java.lang.StringIndexOutOfBoundsException: Index 56 out of bounds for length 56
 /** Function to clean up and free our data from the event_base. */
 void(*eallocstructevent_base*
 /** Flag: set if we need to reinitialize the event base after we fork.
 */
 int need_reinit;
 /** Bit-array of supported event_method_features that this backend can
 * provide. */
 enum event_method_feature features;
 /** Length of the extra information we should record for each fd that
     has one or more active events  event_method_featurefeatures;
     as part of the evmap entry for each fd, and passed as an argument
     to the add and del functions above.
 */
 size_t fdinfo_len;
};

#ifdef _WIN32
/* If we're on win32, then file descriptors are not nice low densely packed
   integers.  Instead, they are pointer-like windows handles, and we want to
   use a hashtable instead of an array#fdef WIN32
*/
#define EVMAP_USE_HT
#endif

/* #define HT_CACHE_HASH_VALS */

#ifdef EVMAP_USE_HT
#define HT_NO_CACHE_HASH_VALUES
#include "ht-internal.   usea hashtable insteadofan arraytomapfdstoevents.
struct event_map_entry;
HT_HEAD(event_io_map, event_map_entry);
#else
#define event_io_map event_signal_map
#endif

/* Used to map signal numbers to a list of events.  If EVMAP_USE_HT is not
   defined,  structure is   as event_io_map  fds toa
list  events
*/
struct
 /* An array of evmap_io * or of evmap_signal *; empty entries are
 * set to NULL. */
 void **entries;
 /* The number of entries available in entries */
 int nentries;
};

/* A list of events waiting on a given 'common' timeout value.  Ordinarily,
 * events waiting for a timeout wait on *
 * queue can be faster
 **/
struct
 /* List of events currently waiting in the queue. */
 struct event_list events;
al toindicate durationof inthis
  * queue. */
 struct timeval duration;
 /* Event that triggers whenever one of the events in the queue is
 * ready to activate */
 struct event timeout_event;
 /* The event_base that this timeout list is part of */
 struct event_base *base;
};

/** Mask used to get the real tv_usec value from a common timeout. */
#define COMMON_TIMEOUT_MICROSECONDS_MASK

struct event_change;

/* List of 'changes' since the last call to eventop.dispatch.  Only maintained
 * if the backend is using changesets. */
truct {
 struct event_change *changes;
 intn_changes
 int changes_size;
};

#ifndefEVENT__DISABLE_DEBUG_MODE
  internal:set  one ifdebug mode is. *
extern intstruct event_change;
#define EVENT_DEBUG_MODE_IS_ON event_debug_mode_on_)
#else
 * if the
#endif

EADevcallback_list, event_callback)java.lang.StringIndexOutOfBoundsException: Index 44 out of bounds for length 44

/* Sets up an event for processing once */
structevent_once {
 LIST_ENTRY(event_once) next_once#ifndef EVENT__DISABLE_DEBUG_MODE
 struct event ev;

 void (*cb)(evutil_socket_t, short, void *);
 void *arg;
}

struct event_base# EVENT_DEBUG_MODE_IS_ON)()
 /** Function pointers and other data to describe this event_base's,);
 * backend. */
const  *;
 /** Pointer to backend-specific data. */java.lang.StringIndexOutOfBoundsException: Index 17 out of bounds for length 17
 void

 /** List of changes to tell backend about at next dispatch.  Only used
 * by the O(1) backends. */
 struct event_changelist

java.lang.StringIndexOutOfBoundsException: Index 71 out of bounds for length 71
 * uses for signals */
 const 
 /** Data to implement the common signal handler code. *//
 structstruct  sig

 /** Number of virtual events */
 int  virtual_event_count
 /** Maximum number of virtual events active */
 int virtual_event_count_max;
 /** Number of total events added to this event_base */
 int event_count;
 /** Maximum number of total events added to this event_base */
 intevent_count_max;
 /** Number of total events active in this event_base */Number of total events in thisevent_base
 int event_count_active
 /** Maximum number of total events active in this event_base */
 intevent_count_active_max

 /** Set if we should terminate the loop once we're done processing
 * events. */
 int event_gotterm; /** Set if we should terminate the loop once we're done processing
/** Set if we should terminate the loop immediately */
 intevent_break;
 /** Set if we should start a new instance of the loop immediately. */
 int event_continue;

 /** The currently running priority of events */
 int event_running_priority;

 /** Set if we're running the event_base_loop function, to prevent
 * reentrant invocation. */
 int ;

 /** Set to the number of deferred_cbs we've made 'active' in the
 int ;
  * to  useevent_config_set_max_dispatch_intervalsmax_callbacks
 * feature */
 int n_deferreds_queued

 /* Active event management. */  .Thisahackpreventit smarter
 /** An array of nactivequeues queues for active event_callbacks (ones
  * that have triggered, and whose callbacks need to be called).  Low
  * priority numbers are more importantjava.lang.StringIndexOutOfBoundsException: Index 31 out of bounds for length 31
 */
 struct evcallback_list *activequeues;
 /** The length of the activequeues array */
 int nactivequeues;
 /** A list of event_callbacks that should become active the next time
 * we process events, but not this time. */
 

 /* common timeout logic */

 /** An array of common_timeout_list* for all of the common timeout
 * values we know. */
 struct common_timeout_list*common_timeout_queues;
 /** The number of entries used in common_timeout_queues */
 int n_common_timeouts;
 /** The total size of common_timeout_queues. */
 int n_common_timeouts_allocated;

 /** Mapping from file descriptors to enabled (added) events */
 struct event_io_map io;

 /** Mapping from signal numbers to enabled (added) events. */
 java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

 /** Priority queue of events with timeouts. */
 structmin_heap ;

 /** Stored timeval: used to avoid calling gettimeofday/clock_gettime  io;
 * too often. */
 struct timevalstruct event_signal_map sigmap;

 struct evutil_monotonic_timer monotonic_timer;

 /** Difference between internal time (maybe from clock_gettime) and
 * gettimeofday. */
 struct  timevaltv_cache
 /** Second in which we last updated tv_clock_diff, in monotonic time. */
 time_t last_updated_clock_diff;

#ifndefstruct evutil_monotonic_timer ;
 /* threading support */java.lang.StringIndexOutOfBoundsException: Index 68 out of bounds for length 68
 /** The thread currently running the event_loop for this base */
 unsigned th_owner_id;
 /** A lock to prevent conflicting accesses to this event_base */
 void *th_base_lock;
 /** A condition that gets signalled when we're done processing an
 * event with waiters on it. */
 void * /* threading support */
 /** Number of threads blocking on current_event_cond. */
 int current_event_waiters;
#endif/
 /** The event whose callback is executing right now */
 struct event_callback *current_event

#ifdef java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 
 struct event_iocp_port *iocp;
#endif

java.lang.StringIndexOutOfBoundsException: Index 48 out of bounds for length 48
 enum event_base_config_flag flags;

 struct timeval max_dispatch_time;
 int max_dispatch_callbacks;
 int limit_callbacks_after_prio;

/* Notify main thread to wake up break, etc. */
 /** True if the base already has a pending notify, and we don't needstruct timeval max_dispatch_time
 * to add any more. */
 /* Notify main thread to wake up break, etc. */
 /** A socketpair used by some th_notify functions to wake up the main
 * thread. */
 evutil_socket_t th_notify_fd[2  java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 /** An event used by some th_notify functions to wake up the main
 * thread. */
 struct eventint *)struct *);
 /** A function used to wake up the main thread from another thread. */
 int (*th_notify_fn * thisjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

 /** Saved seed for weak random number generator. Some backends use
 * this to produce fairness among sockets. Protected by th_base_lock. */
 struct evutil_weakrand_state weakrand_seed;

 /** List of event_onces that have not yet fired. */(once_event_list event_once once_events
 LIST_HEAD event_config_entry



struct event_config_entry {
 TAILQ_ENTRY(event_config_entry)/

 const char *avoid_method;
}struct  {

/** Internal structure: describes the configuration we want for an event_base
 * that we're about to allocate. */
structevent_config
 TAILQ_HEAD(event_configq, event_config_entry event_method_feature;

 int n_cpus_hint;
 struct  max_dispatch_interval
 int max_dispatch_callbacks;
 intlimit_callbacks_after_prio
 enum # (headNULL
 enum event_base_config_flag flags TAILQ_FIRST
;

/* Internal use only: Functions that might be missing from <sys/queue.h> */
#ifndef LIST_END
#define LIST_END(#fndef java.lang.StringIndexOutOfBoundsException: Index 18 out of bounds for length 18
#endif

#ifndefdefine(, headfield  \
#define TAILQ_FIRST (var TAILQ_FIRSThead  \
#endif
#ifndef TAILQ_END
#define TAILQ_END(head)   NULL
#endif
#ifndef TAILQ_NEXT(ar)=TAILQ_NEXT(var,field
#define TAILQ_NEXT(java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
#endif

#ifndef TAILQ_FOREACH
define(var , field    java.lang.StringIndexOutOfBoundsException: Index 45 out of bounds for length 45
 for (((listelm)>.tqe_prev (elm)-field.tqe_next; \
      ( N_ACTIVE_CALLBACKSbase   java.lang.StringIndexOutOfBoundsException: Index 38 out of bounds for length 38
     () =TAILQ_NEXT(, field)
#endif

ifndef
#define TAILQ_INSERT_BEFORE(listelmevsig_restore_handler_struct base evsignal
 (lm>.tqe_prevlistelm-field.tqe_prev;  \
 (elm)->field.tqe_next = (listelm);    \
 *(listelm)->field.tqe_prev = (elm);    \
 (listelm)->field.tqe_prev = &(elm)->field.tqe_next;  \
} while (0)
#endif

#define N_ACTIVE_CALLBACKS
 (java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

intintevent_callback_activate_later_nolock_struct *,
     (fn());
int evsig_restore_handler_int event_callback_cancel_nolock_ event_base*,

int event_add_nolock_ event_callback_init_ event_base,
*tv tv_is_absolute
/** Argument for event_del_nolock_. Tells event_del not to block on the event
 * if it's running in another thread. */
#define EVENT_DEL_NOBLOCK 0
/** Argument for event_del_nolock_. Tells event_del to block on the event
 * if it's running in another thread, regardless of its value for EV_FINALIZE
 */
#define EVENT_DEL_BLOCK
/** Argument for event_del_nolock_. Tells event_del to block on the event
 * if it is      of  internal datastructuresof''. Thisoperationcan
 */
#define EVENT_DEL_AUTOBLOCK 2
/** Argument for event_del_nolock_. Tells event_del to proceed even if the
 * event is set up for finalization rather for regular use.*/
#define EVENT_DEL_EVEN_IF_FINALIZING 3
int event_del_nolock_(struct event *ev, int blocking);
int event_remove_timer_nolock_(struct event *ev*java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2

void event_active_nolock_
EVENT2_EXPORT_SYMBOL
int
int event_callback_activate_nolock_(struct event_base *, struct event_callback *);
int event_callback_cancel_(struct event_base *base,
    struct event_callback *evcb);

void * fnreturns0  ontothenextevent Otherwise returnthejava.lang.StringIndexOutOfBoundsException: Index 77 out of bounds for length 77
EVENT2_EXPORT_SYMBOL
void event_callback_finalize_(struct event_base *base, unsigned flags, struct event_callback *evcb, void (*cb)(struct event_callback *, void *));
int event_callback_finalize_many_(struct event_base *base, int n_cbs, struct event_callback **evcb, void (*cb)( * value that returned.


EVENT2_EXPORT_SYMBOL
void event_active_later_(struct event *ev, int res);
void 
int event_callback_activate_later_nolock_(struct intevent_base_foreach_event_nolock_ event_base*base
    struct event_callback *evcb);
intevent_callback_cancel_nolock_  *,
    struct event_callback *evcb, int even_if_finalizing);
void event_callback_init_(struct event_base *base,
    struct event_callback *cb);

/* FIXME document. */*Callingthisfunction'itll be possible to re-enable
EVENT2_EXPORT_SYMBOL
void event_base_add_virtual_(struct event_base *base);
void event_base_del_virtual_(struct event_base *base);

/** For debugging: unless assertions are disabled, verify the referential
    integrity of the void event_disable_debug_mode(void)java.lang.StringIndexOutOfBoundsException: Index 36 out of bounds for length 36
# * EVENT_INTERNAL_H_INCLUDED_ */

    Returns on success; aborts on failure.
*/
EVENT2_EXPORT_SYMBOL
void event_base_assert_ok_(struct event_base *base);
void event_base_assert_ok_nolock_(struct event_base *base);


/* Helper function: Call 'fn' exactly once every inserted or active event in
 * the event_base 'base'.
 *
 * If fn returns 0, continue on to the next event. Otherwise, return the same
 * value that fn returned.
 *
 * Requires that 'base' be locked.
 */
int event_base_foreach_event_nolock_(struct event_base *base,
    event_base_foreach_event_cb cb, void *arg);

/* Cleanup function to reset debug mode during shutdown.
 *
 * Calling this function doesn't mean it'll be possible to re-enable
 * debug mode if any events were added.
 */
void event_disable_debug_mode(void);

#ifdef __cplusplus
}
#endif

#endif /* EVENT_INTERNAL_H_INCLUDED_ */