event.h

Go to the documentation of this file.

#ifndef PROTON_EVENT_H
#define PROTON_EVENT_H 1

/*
 *
 * Licensed to the Apache Software Foundation (ASF) under one
 * or more contributor license agreements.  See the NOTICE file
 * distributed with this work for additional information
 * regarding copyright ownership.  The ASF licenses this file
 * to you 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.apache.org/licenses/LICENSE-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.
 *
 */

#include <proton/import_export.h>
#include <proton/type_compat.h>
#include <proton/object.h>
#include <stddef.h>

#ifdef __cplusplus
extern "C" {
#endif

typedef struct pn_event_t pn_event_t;

typedef enum {
  PN_EVENT_NONE = 0,

  PN_REACTOR_INIT,

  PN_REACTOR_QUIESCED,

  PN_REACTOR_FINAL,

  PN_TIMER_TASK,

  PN_CONNECTION_INIT,

  PN_CONNECTION_BOUND,

  PN_CONNECTION_UNBOUND,

  PN_CONNECTION_LOCAL_OPEN,

  PN_CONNECTION_REMOTE_OPEN,

  PN_CONNECTION_LOCAL_CLOSE,

  PN_CONNECTION_REMOTE_CLOSE,

  PN_CONNECTION_FINAL,

  PN_SESSION_INIT,

  PN_SESSION_LOCAL_OPEN,

  PN_SESSION_REMOTE_OPEN,

  PN_SESSION_LOCAL_CLOSE,

  PN_SESSION_REMOTE_CLOSE,

  PN_SESSION_FINAL,

  PN_LINK_INIT,

  PN_LINK_LOCAL_OPEN,

  PN_LINK_REMOTE_OPEN,

  PN_LINK_LOCAL_CLOSE,

  PN_LINK_REMOTE_CLOSE,

  PN_LINK_LOCAL_DETACH,

  PN_LINK_REMOTE_DETACH,

  PN_LINK_FLOW,

  PN_LINK_FINAL,

  PN_DELIVERY,

  PN_TRANSPORT,

  PN_TRANSPORT_AUTHENTICATED,

  PN_TRANSPORT_ERROR,

  PN_TRANSPORT_HEAD_CLOSED,

  PN_TRANSPORT_TAIL_CLOSED,

  PN_TRANSPORT_CLOSED,

  PN_SELECTABLE_INIT,
  PN_SELECTABLE_UPDATED,
  PN_SELECTABLE_READABLE,
  PN_SELECTABLE_WRITABLE,
  PN_SELECTABLE_ERROR,
  PN_SELECTABLE_EXPIRED,
  PN_SELECTABLE_FINAL,

  PN_CONNECTION_WAKE,

  PN_LISTENER_ACCEPT,

  PN_LISTENER_CLOSE,

  PN_PROACTOR_INTERRUPT,

  PN_PROACTOR_TIMEOUT,

  PN_PROACTOR_INACTIVE,

  PN_LISTENER_OPEN
} pn_event_type_t;


PN_EXTERN const char *pn_event_type_name(pn_event_type_t type);

PN_EXTERN pn_collector_t *pn_collector(void);

PN_EXTERN void pn_collector_free(pn_collector_t *collector);

PN_EXTERN void pn_collector_release(pn_collector_t *collector);

PN_EXTERN void pn_collector_drain(pn_collector_t *collector);

PN_EXTERN pn_event_t *pn_collector_put(pn_collector_t *collector,
                                       const pn_class_t *clazz, void *context,
                                       pn_event_type_t type);

PN_EXTERN pn_event_t *pn_collector_peek(pn_collector_t *collector);

PN_EXTERN bool pn_collector_pop(pn_collector_t *collector);

PN_EXTERN pn_event_t *pn_collector_next(pn_collector_t *collector);

PN_EXTERN pn_event_t *pn_collector_prev(pn_collector_t *collector);

PN_EXTERN  bool pn_collector_more(pn_collector_t *collector);

PN_EXTERN pn_event_type_t pn_event_type(pn_event_t *event);

PN_EXTERN const pn_class_t *pn_event_class(pn_event_t *event);

PN_EXTERN void *pn_event_context(pn_event_t *event);

PN_EXTERN pn_connection_t *pn_event_connection(pn_event_t *event);

PN_EXTERN pn_session_t *pn_event_session(pn_event_t *event);

PN_EXTERN pn_link_t *pn_event_link(pn_event_t *event);

PN_EXTERN pn_delivery_t *pn_event_delivery(pn_event_t *event);

PN_EXTERN pn_transport_t *pn_event_transport(pn_event_t *event);

PN_EXTERN pn_record_t *pn_event_attachments(pn_event_t *event);

PN_EXTERN struct pn_condition_t *pn_event_condition(pn_event_t *event);

typedef struct pn_event_batch_t pn_event_batch_t;

/* NOTE: there is deliberately no peek(), more() or other look-ahead on an event
 * batch. We want to know exactly which events have been handled, next() only
 * allows the user to get each event exactly once, in order.
 */

PN_EXTERN pn_event_t *pn_event_batch_next(pn_event_batch_t *batch);

struct pn_event_batch_t {
  pn_event_t *(*next_event)(pn_event_batch_t *batch);
};
#ifdef __cplusplus
}
#endif

#endif /* event.h */