You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@qpid.apache.org by as...@apache.org on 2022/05/13 14:24:06 UTC
[qpid-proton] 02/09: PROTON-2542: Eliminate all code that uses pn_collector_put with PN_OBJECT
This is an automated email from the ASF dual-hosted git repository.
astitcher pushed a commit to branch main
in repository https://gitbox.apache.org/repos/asf/qpid-proton.git
commit 24976938f30bc82cb9dce8802e955035628f9b2e
Author: Andrew Stitcher <as...@apache.org>
AuthorDate: Mon May 2 18:20:04 2022 -0400
PROTON-2542: Eliminate all code that uses pn_collector_put with PN_OBJECT
This is to avoid the need to export the PN_OBJECT symbol from
libqpid_core - A step towards making most of object.h private and not
exported by the libqpid_core library.
---
c/include/proton/event.h | 23 ++++++++++++++++++++++-
c/src/core/engine.c | 24 ++++++++++++------------
c/src/core/event.c | 6 ++++++
c/src/core/transport.c | 36 ++++++++++++++++++------------------
c/src/proactor/epoll.c | 2 +-
c/src/proactor/libuv.c | 2 +-
c/src/proactor/win_iocp.cpp | 2 +-
c/src/reactor/reactor.c | 12 ++++++------
c/src/reactor/selectable.c | 8 ++++----
c/src/reactor/timer.c | 2 +-
c/src/sasl/sasl.c | 2 +-
c/tests/event_test.cpp | 6 +++---
cpp/src/receiver.cpp | 2 +-
13 files changed, 77 insertions(+), 50 deletions(-)
diff --git a/c/include/proton/event.h b/c/include/proton/event.h
index dba1b44f..048a60ee 100644
--- a/c/include/proton/event.h
+++ b/c/include/proton/event.h
@@ -526,7 +526,7 @@ PN_EXTERN void pn_collector_drain(pn_collector_t *collector);
* this happens, this operation will return a NULL pointer.
*
* @param[in] collector a collector object
- * @param[in] clazz class of the context
+ * @param[in] clazz memory management class of the context
* @param[in] context the event context
* @param[in] type the event type
*
@@ -538,6 +538,27 @@ PN_EXTERN pn_event_t *pn_collector_put(pn_collector_t *collector,
const pn_class_t *clazz, void *context,
pn_event_type_t type);
+/**
+ * Place a new event on a collector.
+ *
+ * This operation will create a new event of the given type with a
+ * context that is managed as a pn_object and return a pointer to the
+ * newly created event. In some cases an event of the given type and
+ * context can be elided. When this happens, this operation will return
+ * a NULL pointer.
+ *
+ * @param[in] collector a collector object
+ * @param[in] object the event context object
+ * @param[in] type the event type
+ *
+ * @return a pointer to the newly created event or NULL if the event
+ * was elided
+ */
+
+PN_EXTERN pn_event_t *pn_collector_put_object(pn_collector_t *collector,
+ void *object,
+ pn_event_type_t type);
+
/**
* Access the head event contained by a collector.
*
diff --git a/c/src/core/engine.c b/c/src/core/engine.c
index d16cf657..e5f64497 100644
--- a/c/src/core/engine.c
+++ b/c/src/core/engine.c
@@ -79,8 +79,8 @@ static void pn_endpoint_open(pn_endpoint_t *endpoint)
if (!(endpoint->state & PN_LOCAL_ACTIVE)) {
PN_SET_LOCAL(endpoint->state, PN_LOCAL_ACTIVE);
pn_connection_t *conn = pni_ep_get_connection(endpoint);
- pn_collector_put(conn->collector, PN_OBJECT, endpoint,
- endpoint_event((pn_endpoint_type_t) endpoint->type, true));
+ pn_collector_put_object(conn->collector, endpoint,
+ endpoint_event((pn_endpoint_type_t) endpoint->type, true));
pn_modified(conn, endpoint, true);
}
}
@@ -90,8 +90,8 @@ static void pn_endpoint_close(pn_endpoint_t *endpoint)
if (!(endpoint->state & PN_LOCAL_CLOSED)) {
PN_SET_LOCAL(endpoint->state, PN_LOCAL_CLOSED);
pn_connection_t *conn = pni_ep_get_connection(endpoint);
- pn_collector_put(conn->collector, PN_OBJECT, endpoint,
- endpoint_event((pn_endpoint_type_t) endpoint->type, false));
+ pn_collector_put_object(conn->collector, endpoint,
+ endpoint_event((pn_endpoint_type_t) endpoint->type, false));
pn_modified(conn, endpoint, true);
}
}
@@ -154,7 +154,7 @@ void pn_connection_free(pn_connection_t *connection) {
void pn_connection_bound(pn_connection_t *connection)
{
- pn_collector_put(connection->collector, PN_OBJECT, connection, PN_CONNECTION_BOUND);
+ pn_collector_put_object(connection->collector, connection, PN_CONNECTION_BOUND);
pn_ep_incref(&connection->endpoint);
size_t nsessions = pn_list_size(connection->sessions);
@@ -337,7 +337,7 @@ void pn_link_detach(pn_link_t *link)
if (link->detached) return;
link->detached = true;
- pn_collector_put(link->session->connection->collector, PN_OBJECT, link, PN_LINK_LOCAL_DETACH);
+ pn_collector_put_object(link->session->connection->collector, link, PN_LINK_LOCAL_DETACH);
pn_modified(link->session->connection, &link->endpoint, true);
}
@@ -449,7 +449,7 @@ void pn_ep_decref(pn_endpoint_t *endpoint)
endpoint->refcount--;
if (endpoint->refcount == 0) {
pn_connection_t *conn = pni_ep_get_connection(endpoint);
- pn_collector_put(conn->collector, PN_OBJECT, endpoint, pn_final_type((pn_endpoint_type_t) endpoint->type));
+ pn_collector_put_object(conn->collector, endpoint, pn_final_type((pn_endpoint_type_t) endpoint->type));
}
}
@@ -560,7 +560,7 @@ void pn_connection_collect(pn_connection_t *connection, pn_collector_t *collecto
pn_incref(connection->collector);
pn_endpoint_t *endpoint = connection->endpoint_head;
while (endpoint) {
- pn_collector_put(connection->collector, PN_OBJECT, endpoint, endpoint_init_event_map[endpoint->type]);
+ pn_collector_put_object(connection->collector, endpoint, endpoint_init_event_map[endpoint->type]);
endpoint = endpoint->endpoint_next;
}
}
@@ -781,8 +781,8 @@ void pn_modified(pn_connection_t *connection, pn_endpoint_t *endpoint, bool emit
}
if (emit && connection->transport) {
- pn_collector_put(connection->collector, PN_OBJECT, connection->transport,
- PN_TRANSPORT);
+ pn_collector_put_object(connection->collector, connection->transport,
+ PN_TRANSPORT);
}
}
@@ -1018,7 +1018,7 @@ pn_session_t *pn_session(pn_connection_t *conn)
ssn->state.remote_handles = pn_hash(PN_WEAKREF, 0, 0.75);
// end transport state
- pn_collector_put(conn->collector, PN_OBJECT, ssn, PN_SESSION_INIT);
+ pn_collector_put_object(conn->collector, ssn, PN_SESSION_INIT);
if (conn->transport) {
pni_session_bound(ssn);
}
@@ -1200,7 +1200,7 @@ pn_link_t *pn_link_new(int type, pn_session_t *session, const char *name)
link->state.link_credit = 0;
// end transport state
- pn_collector_put(session->connection->collector, PN_OBJECT, link, PN_LINK_INIT);
+ pn_collector_put_object(session->connection->collector, link, PN_LINK_INIT);
if (session->connection->transport) {
pni_link_bound(link);
}
diff --git a/c/src/core/event.c b/c/src/core/event.c
index 3562a00e..428fc10e 100644
--- a/c/src/core/event.c
+++ b/c/src/core/event.c
@@ -169,6 +169,12 @@ pn_event_t *pn_collector_put(pn_collector_t *collector,
return event;
}
+pn_event_t *pn_collector_put_object(pn_collector_t *collector, void *object, pn_event_type_t type)
+{
+ const pn_class_t *clazz = pn_class(object);
+ return pn_collector_put(collector, clazz, object, type);
+}
+
pn_event_t *pn_collector_peek(pn_collector_t *collector)
{
return collector->head;
diff --git a/c/src/core/transport.c b/c/src/core/transport.c
index b05f25ad..49d15d07 100644
--- a/c/src/core/transport.c
+++ b/c/src/core/transport.c
@@ -668,9 +668,9 @@ static void pn_transport_finalize(void *object)
}
static void pni_post_remote_open_events(pn_transport_t *transport, pn_connection_t *connection) {
- pn_collector_put(connection->collector, PN_OBJECT, connection, PN_CONNECTION_REMOTE_OPEN);
+ pn_collector_put_object(connection->collector, connection, PN_CONNECTION_REMOTE_OPEN);
if (transport->remote_idle_timeout) {
- pn_collector_put(connection->collector, PN_OBJECT, transport, PN_TRANSPORT);
+ pn_collector_put_object(connection->collector, transport, PN_TRANSPORT);
}
}
@@ -762,7 +762,7 @@ int pn_transport_unbind(pn_transport_t *transport)
transport->connection = NULL;
bool was_referenced = transport->referenced;
- pn_collector_put(conn->collector, PN_OBJECT, conn, PN_CONNECTION_UNBOUND);
+ pn_collector_put_object(conn->collector, conn, PN_CONNECTION_UNBOUND);
// XXX: what happens if the endpoints are freed before we get here?
pn_session_t *ssn = pn_session_head(conn, 0);
@@ -977,7 +977,7 @@ static void pni_maybe_post_closed(pn_transport_t *transport)
{
pn_collector_t *collector = pni_transport_collector(transport);
if (transport->head_closed && transport->tail_closed) {
- pn_collector_put(collector, PN_OBJECT, transport, PN_TRANSPORT_CLOSED);
+ pn_collector_put_object(collector, transport, PN_TRANSPORT_CLOSED);
}
}
@@ -986,7 +986,7 @@ static void pni_close_tail(pn_transport_t *transport)
if (!transport->tail_closed) {
transport->tail_closed = true;
pn_collector_t *collector = pni_transport_collector(transport);
- pn_collector_put(collector, PN_OBJECT, transport, PN_TRANSPORT_TAIL_CLOSED);
+ pn_collector_put_object(collector, transport, PN_TRANSPORT_TAIL_CLOSED);
pni_maybe_post_closed(transport);
}
}
@@ -1020,7 +1020,7 @@ int pn_do_error(pn_transport_t *transport, const char *condition, const char *fm
}
}
pn_collector_t *collector = pni_transport_collector(transport);
- pn_collector_put(collector, PN_OBJECT, transport, PN_TRANSPORT_ERROR);
+ pn_collector_put_object(collector, transport, PN_TRANSPORT_ERROR);
// Special case being called with no condition and no fmt to log the existing error condition
if (fmt && condition) {
PN_LOG(&transport->logger, PN_SUBSYSTEM_AMQP, PN_LEVEL_ERROR, "%s %s", condition, buf);
@@ -1140,7 +1140,7 @@ int pn_do_begin(pn_transport_t *transport, uint8_t frame_type, uint16_t channel,
}
pni_map_remote_channel(ssn, channel);
PN_SET_REMOTE(ssn->endpoint.state, PN_REMOTE_ACTIVE);
- pn_collector_put(transport->connection->collector, PN_OBJECT, ssn, PN_SESSION_REMOTE_OPEN);
+ pn_collector_put_object(transport->connection->collector, ssn, PN_SESSION_REMOTE_OPEN);
return 0;
}
@@ -1360,7 +1360,7 @@ int pn_do_attach(pn_transport_t *transport, uint8_t frame_type, uint16_t channel
link->remote_max_message_size = max_msgsz;
}
- pn_collector_put(transport->connection->collector, PN_OBJECT, link, PN_LINK_REMOTE_OPEN);
+ pn_collector_put_object(transport->connection->collector, link, PN_LINK_REMOTE_OPEN);
return 0;
}
@@ -1493,7 +1493,7 @@ int pn_do_transfer(pn_transport_t *transport, uint8_t frame_type, uint16_t chann
link->more_pending = false;
pn_work_update(transport->connection, delivery);
}
- pn_collector_put(transport->connection->collector, PN_OBJECT, delivery, PN_DELIVERY);
+ pn_collector_put_object(transport->connection->collector, delivery, PN_DELIVERY);
}
ssn->incoming_bytes += payload.size;
@@ -1559,7 +1559,7 @@ int pn_do_flow(pn_transport_t *transport, uint8_t frame_type, uint16_t channel,
}
}
- pn_collector_put(transport->connection->collector, PN_OBJECT, link, PN_LINK_FLOW);
+ pn_collector_put_object(transport->connection->collector, link, PN_LINK_FLOW);
}
return 0;
@@ -1649,7 +1649,7 @@ static int pni_do_delivery_disposition(pn_transport_t * transport, pn_delivery_t
delivery->updated = true;
pn_work_update(transport->connection, delivery);
- pn_collector_put(transport->connection->collector, PN_OBJECT, delivery, PN_DELIVERY);
+ pn_collector_put_object(transport->connection->collector, delivery, PN_DELIVERY);
return 0;
}
@@ -1740,9 +1740,9 @@ int pn_do_detach(pn_transport_t *transport, uint8_t frame_type, uint16_t channel
if (closed)
{
PN_SET_REMOTE(link->endpoint.state, PN_REMOTE_CLOSED);
- pn_collector_put(transport->connection->collector, PN_OBJECT, link, PN_LINK_REMOTE_CLOSE);
+ pn_collector_put_object(transport->connection->collector, link, PN_LINK_REMOTE_CLOSE);
} else {
- pn_collector_put(transport->connection->collector, PN_OBJECT, link, PN_LINK_REMOTE_DETACH);
+ pn_collector_put_object(transport->connection->collector, link, PN_LINK_REMOTE_DETACH);
}
pni_unmap_remote_handle(link);
@@ -1764,7 +1764,7 @@ int pn_do_end(pn_transport_t *transport, uint8_t frame_type, uint16_t channel, p
pn_condition_set(condition, cond, desc);
pn_data_rewind(pn_condition_info(condition));
PN_SET_REMOTE(ssn->endpoint.state, PN_REMOTE_CLOSED);
- pn_collector_put(transport->connection->collector, PN_OBJECT, ssn, PN_SESSION_REMOTE_CLOSE);
+ pn_collector_put_object(transport->connection->collector, ssn, PN_SESSION_REMOTE_CLOSE);
pni_unmap_remote_channel(ssn);
return 0;
}
@@ -1782,7 +1782,7 @@ int pn_do_close(pn_transport_t *transport, uint8_t frame_type, uint16_t channel,
pn_data_rewind(pn_condition_info(condition));
transport->close_rcvd = true;
PN_SET_REMOTE(conn->endpoint.state, PN_REMOTE_CLOSED);
- pn_collector_put(transport->connection->collector, PN_OBJECT, conn, PN_CONNECTION_REMOTE_CLOSE);
+ pn_collector_put_object(transport->connection->collector, conn, PN_CONNECTION_REMOTE_CLOSE);
return 0;
}
@@ -2205,7 +2205,7 @@ static int pni_process_tpwork_sender(pn_transport_t *transport, pn_delivery_t *d
// Aborted delivery with no data yet sent, drop it and issue a FLOW as we may have credit.
*settle = true;
state->sent = true;
- pn_collector_put(transport->connection->collector, PN_OBJECT, link, PN_LINK_FLOW);
+ pn_collector_put_object(transport->connection->collector, link, PN_LINK_FLOW);
return 0;
}
*settle = false;
@@ -2255,7 +2255,7 @@ static int pni_process_tpwork_sender(pn_transport_t *transport, pn_delivery_t *d
link->session->outgoing_deliveries--;
}
- pn_collector_put(transport->connection->collector, PN_OBJECT, link, PN_LINK_FLOW);
+ pn_collector_put_object(transport->connection->collector, link, PN_LINK_FLOW);
}
}
@@ -2708,7 +2708,7 @@ static void pni_close_head(pn_transport_t *transport)
if (!transport->head_closed) {
transport->head_closed = true;
pn_collector_t *collector = pni_transport_collector(transport);
- pn_collector_put(collector, PN_OBJECT, transport, PN_TRANSPORT_HEAD_CLOSED);
+ pn_collector_put_object(collector, transport, PN_TRANSPORT_HEAD_CLOSED);
pni_maybe_post_closed(transport);
}
}
diff --git a/c/src/proactor/epoll.c b/c/src/proactor/epoll.c
index 1ff68ef9..027ef2fe 100644
--- a/c/src/proactor/epoll.c
+++ b/c/src/proactor/epoll.c
@@ -1197,7 +1197,7 @@ static pn_event_batch_t *pconnection_process(pconnection_t *pc, uint32_t events,
if (waking) {
pn_connection_t *c = pc->driver.connection;
- pn_collector_put(pn_connection_collector(c), PN_OBJECT, c, PN_CONNECTION_WAKE);
+ pn_collector_put_object(pn_connection_collector(c), c, PN_CONNECTION_WAKE);
waking = false;
}
diff --git a/c/src/proactor/libuv.c b/c/src/proactor/libuv.c
index b450919e..9179823a 100644
--- a/c/src/proactor/libuv.c
+++ b/c/src/proactor/libuv.c
@@ -886,7 +886,7 @@ static void check_wake(pconnection_t *pc) {
uv_mutex_lock(&pc->lock);
if (pc->wake == W_PENDING) {
pn_connection_t *c = pc->driver.connection;
- pn_collector_put(pn_connection_collector(c), PN_OBJECT, c, PN_CONNECTION_WAKE);
+ pn_collector_put_object(pn_connection_collector(c), c, PN_CONNECTION_WAKE);
pc->wake = W_NONE;
}
uv_mutex_unlock(&pc->lock);
diff --git a/c/src/proactor/win_iocp.cpp b/c/src/proactor/win_iocp.cpp
index 51512bd7..4df6d7d8 100644
--- a/c/src/proactor/win_iocp.cpp
+++ b/c/src/proactor/win_iocp.cpp
@@ -2351,7 +2351,7 @@ static pn_event_batch_t *pconnection_process(pconnection_t *pc, iocp_result_t *r
bool ready = pconnection_has_event(pc);
if (waking) {
pn_connection_t *c = pc->driver.connection;
- pn_collector_put(pn_connection_collector(c), PN_OBJECT, c, PN_CONNECTION_WAKE);
+ pn_collector_put_object(pn_connection_collector(c), c, PN_CONNECTION_WAKE);
waking = false;
}
if (ready) {
diff --git a/c/src/reactor/reactor.c b/c/src/reactor/reactor.c
index 213b9f4e..27f2c717 100644
--- a/c/src/reactor/reactor.c
+++ b/c/src/reactor/reactor.c
@@ -199,7 +199,7 @@ pn_selectable_t *pn_reactor_selectable(pn_reactor_t *reactor) {
assert(reactor);
pn_selectable_t *sel = pn_selectable();
pn_selectable_collect(sel, reactor->collector);
- pn_collector_put(reactor->collector, PN_OBJECT, sel, PN_SELECTABLE_INIT);
+ pn_collector_put_object(reactor->collector, sel, PN_SELECTABLE_INIT);
pni_selectable_set_context(sel, reactor);
pn_list_add(reactor->children, sel);
pn_selectable_on_release(sel, pni_selectable_release);
@@ -216,9 +216,9 @@ void pn_reactor_update(pn_reactor_t *reactor, pn_selectable_t *selectable) {
if (!pn_record_has(record, PNI_TERMINATED)) {
if (pn_selectable_is_terminal(selectable)) {
pn_record_def(record, PNI_TERMINATED, PN_VOID);
- pn_collector_put(reactor->collector, PN_OBJECT, selectable, PN_SELECTABLE_FINAL);
+ pn_collector_put_object(reactor->collector, selectable, PN_SELECTABLE_FINAL);
} else {
- pn_collector_put(reactor->collector, PN_OBJECT, selectable, PN_SELECTABLE_UPDATED);
+ pn_collector_put_object(reactor->collector, selectable, PN_SELECTABLE_UPDATED);
}
}
}
@@ -427,7 +427,7 @@ bool pn_reactor_process(pn_reactor_t *reactor) {
pn_collector_pop(reactor->collector);
} else if (!reactor->stop && pni_reactor_more(reactor)) {
if (previous != PN_REACTOR_QUIESCED && reactor->previous != PN_REACTOR_FINAL) {
- pn_collector_put(reactor->collector, PN_OBJECT, reactor, PN_REACTOR_QUIESCED);
+ pn_collector_put_object(reactor->collector, reactor, PN_REACTOR_QUIESCED);
} else {
return true;
}
@@ -438,7 +438,7 @@ bool pn_reactor_process(pn_reactor_t *reactor) {
reactor->selectable = NULL;
} else {
if (reactor->previous != PN_REACTOR_FINAL)
- pn_collector_put(reactor->collector, PN_OBJECT, reactor, PN_REACTOR_FINAL);
+ pn_collector_put_object(reactor->collector, reactor, PN_REACTOR_FINAL);
return false;
}
}
@@ -483,7 +483,7 @@ int pn_reactor_wakeup(pn_reactor_t *reactor) {
void pn_reactor_start(pn_reactor_t *reactor) {
assert(reactor);
- pn_collector_put(reactor->collector, PN_OBJECT, reactor, PN_REACTOR_INIT);
+ pn_collector_put_object(reactor->collector, reactor, PN_REACTOR_INIT);
reactor->selectable = pni_timer_selectable(reactor);
}
diff --git a/c/src/reactor/selectable.c b/c/src/reactor/selectable.c
index 9ee5e9ef..e9bf55dd 100644
--- a/c/src/reactor/selectable.c
+++ b/c/src/reactor/selectable.c
@@ -276,19 +276,19 @@ void pn_selectable_free(pn_selectable_t *selectable)
}
static void pni_readable(pn_selectable_t *selectable) {
- pn_collector_put(selectable->collector, PN_OBJECT, selectable, PN_SELECTABLE_READABLE);
+ pn_collector_put_object(selectable->collector, selectable, PN_SELECTABLE_READABLE);
}
static void pni_writable(pn_selectable_t *selectable) {
- pn_collector_put(selectable->collector, PN_OBJECT, selectable, PN_SELECTABLE_WRITABLE);
+ pn_collector_put_object(selectable->collector, selectable, PN_SELECTABLE_WRITABLE);
}
static void pni_error(pn_selectable_t *selectable) {
- pn_collector_put(selectable->collector, PN_OBJECT, selectable, PN_SELECTABLE_ERROR);
+ pn_collector_put_object(selectable->collector, selectable, PN_SELECTABLE_ERROR);
}
static void pni_expired(pn_selectable_t *selectable) {
- pn_collector_put(selectable->collector, PN_OBJECT, selectable, PN_SELECTABLE_EXPIRED);
+ pn_collector_put_object(selectable->collector, selectable, PN_SELECTABLE_EXPIRED);
}
void pn_selectable_collect(pn_selectable_t *selectable, pn_collector_t *collector) {
diff --git a/c/src/reactor/timer.c b/c/src/reactor/timer.c
index 1e187223..316b08be 100644
--- a/c/src/reactor/timer.c
+++ b/c/src/reactor/timer.c
@@ -158,7 +158,7 @@ void pn_timer_tick(pn_timer_t *timer, pn_timestamp_t now) {
pn_task_t *min = (pn_task_t *) pn_list_minpop(timer->tasks);
assert(min == task);
if (!min->cancelled)
- pn_collector_put(timer->collector, PN_OBJECT, min, PN_TIMER_TASK);
+ pn_collector_put_object(timer->collector, min, PN_TIMER_TASK);
pn_decref(min);
} else {
break;
diff --git a/c/src/sasl/sasl.c b/c/src/sasl/sasl.c
index 1fc16a9d..3de63aa4 100644
--- a/c/src/sasl/sasl.c
+++ b/c/src/sasl/sasl.c
@@ -375,7 +375,7 @@ static void pni_emit(pn_transport_t *transport)
{
if (transport->connection && transport->connection->collector) {
pn_collector_t *collector = transport->connection->collector;
- pn_collector_put(collector, PN_OBJECT, transport, PN_TRANSPORT);
+ pn_collector_put_object(collector, transport, PN_TRANSPORT);
}
}
diff --git a/c/tests/event_test.cpp b/c/tests/event_test.cpp
index 0a93b5cd..03657f1b 100644
--- a/c/tests/event_test.cpp
+++ b/c/tests/event_test.cpp
@@ -35,7 +35,7 @@ TEST_CASE("event_collector") {
pn_collector_t *collector = pn_collector(); \
REQUIRE(collector); \
pn_event_t *event = \
- pn_collector_put(collector, PN_OBJECT, obj, (pn_event_type_t)0); \
+ pn_collector_put_object(collector, obj, (pn_event_type_t)0); \
pn_decref(obj);
TEST_CASE("event_collector_put") {
@@ -71,7 +71,7 @@ TEST_CASE("event_collector_pool") {
REQUIRE(!head);
void *obj2 = pn_class_new(PN_OBJECT, 0);
pn_event_t *event2 =
- pn_collector_put(collector, PN_OBJECT, obj2, (pn_event_type_t)0);
+ pn_collector_put_object(collector, obj2, (pn_event_type_t)0);
pn_decref(obj2);
REQUIRE(event == event2);
pn_free(collector);
@@ -87,7 +87,7 @@ void test_event_incref(bool eventfirst) {
REQUIRE(!pn_collector_peek(collector));
void *obj2 = pn_class_new(PN_OBJECT, 0);
pn_event_t *event2 =
- pn_collector_put(collector, PN_OBJECT, obj2, (pn_event_type_t)0);
+ pn_collector_put_object(collector, obj2, (pn_event_type_t)0);
pn_decref(obj2);
REQUIRE(head != event2);
if (eventfirst) {
diff --git a/cpp/src/receiver.cpp b/cpp/src/receiver.cpp
index 325036df..9f3c7706 100644
--- a/cpp/src/receiver.cpp
+++ b/cpp/src/receiver.cpp
@@ -78,7 +78,7 @@ void receiver::drain() {
// Drain is already complete. No state to communicate over the wire.
// Create dummy flow event where "drain finish" can be detected.
pn_connection_t *pnc = pn_session_connection(pn_link_session(pn_object()));
- pn_collector_put(pn_connection_collector(pnc), PN_OBJECT, pn_object(), PN_LINK_FLOW);
+ pn_collector_put_object(pn_connection_collector(pnc), pn_object(), PN_LINK_FLOW);
}
}
}
---------------------------------------------------------------------
To unsubscribe, e-mail: commits-unsubscribe@qpid.apache.org
For additional commands, e-mail: commits-help@qpid.apache.org