gapi_dataReader
gapi_subscriber_lookup_datareader (
gapi_subscriber _this,
const gapi_char *topic_name)
{
_Subscriber subscriber;
gapi_dataReader handle = NULL;
u_dataReader found;
c_iter iter;
subscriber = gapi_subscriberClaim(_this, NULL);
if (subscriber) {
iter = u_subscriberLookupReaders(U_SUBSCRIBER_GET(subscriber),
topic_name);
if (iter) {
found = c_iterTakeFirst(iter);
if (found) {
handle = u_entityGetUserData(u_entity(found));
}
c_iterFree(iter);
}
_EntityRelease(subscriber);
}
return handle;
}
u_subscriber
_SubscriberUsubscriber (
_Subscriber subscriber)
{
assert(subscriber);
return U_SUBSCRIBER_GET(subscriber);
}
gapi_returnCode_t
_SubscriberFree (
_Subscriber subscriber)
{
gapi_returnCode_t result = GAPI_RETCODE_OK;
_Status status;
u_subscriber s;
assert(subscriber);
status = _EntityStatus(subscriber);
_StatusSetListener(status, NULL, 0);
_EntityClaim(status);
_StatusDeinit(status);
gapi_dataReaderQos_free(&subscriber->_defDataReaderQos);
s = U_SUBSCRIBER_GET(subscriber);
_EntityDispose(_Entity(subscriber));
if (u_subscriberFree(s) != U_RESULT_OK) {
result = GAPI_RETCODE_ERROR;
}
return result;
}
gapi_returnCode_t
gapi_subscriber_notify_datareaders (
gapi_subscriber _this)
{
gapi_returnCode_t result = GAPI_RETCODE_OK;
_Subscriber subscriber;
subscriber = gapi_subscriberClaim(_this, &result);
if ( subscriber ) {
u_subscriberWalkReaders(U_SUBSCRIBER_GET(subscriber),
(u_readerAction)trigger_reader,NULL);
_EntityRelease(subscriber);
}
return result;
}
void
_BuiltinSubscriberFree (
_Subscriber subscriber)
{
_Status status;
assert(subscriber != NULL);
status = _EntityStatus(subscriber);
_StatusSetListener(status, NULL, 0);
_EntityClaim(status);
_StatusDeinit(status);
u_subscriberFree(U_SUBSCRIBER_GET(subscriber));
_EntityDispose(_Entity(subscriber));
}
gapi_subscriberQos *
_SubscriberGetQos (
_Subscriber subscriber,
gapi_subscriberQos *qos)
{
v_subscriberQos subscriberQos;
u_subscriber uSubscriber;
assert(subscriber);
uSubscriber = U_SUBSCRIBER_GET(subscriber);
if ( u_entityQoS(u_entity(uSubscriber), (v_qos*)&subscriberQos) == U_RESULT_OK ) {
copySubscriberQosOut(subscriberQos, qos);
u_subscriberQosFree(subscriberQos);
}
return qos;
}
gapi_returnCode_t
gapi_subscriber_delete_datareader (
gapi_subscriber _this,
const gapi_dataReader a_datareader)
{
gapi_returnCode_t result = GAPI_RETCODE_OK;
_Subscriber subscriber;
_DataReader datareader = NULL;
gapi_context context;
c_bool contains;
GAPI_CONTEXT_SET(context, _this, GAPI_METHOD_DELETE_DATAREADER);
subscriber = gapi_subscriberClaimNB(_this, &result);
if ( subscriber ) {
if ( !subscriber->builtin ) {
datareader = gapi_dataReaderClaimNB(a_datareader, NULL);
if ( datareader ) {
contains = u_subscriberContainsReader(U_SUBSCRIBER_GET(subscriber),
U_READER_GET(datareader));
if (contains) {
if ( _DataReaderPrepareDelete (datareader, &context) ) {
_DataReaderFree(datareader);
datareader = NULL;
} else {
result = GAPI_RETCODE_PRECONDITION_NOT_MET;
}
} else {
result = GAPI_RETCODE_PRECONDITION_NOT_MET;
}
_EntityRelease(datareader);
} else {
result = GAPI_RETCODE_BAD_PARAMETER;
}
}
_EntityRelease(subscriber);
}
return result;
}
gapi_boolean
_SubscriberContainsEntity (
_Subscriber _this,
gapi_instanceHandle_t handle)
{
struct check_handle_arg arg;
assert(_this);
_EntityClaim(_this);
arg.handle = handle;
arg.result = FALSE;
u_subscriberWalkReaders(U_SUBSCRIBER_GET(_this),
(u_readerAction)check_handle,
(c_voidp)&arg);
_EntityRelease(_this);
return arg.result;
}
gapi_returnCode_t
_SubscriberDeleteContainedEntities (
_Subscriber _this)
{
gapi_dataReader handle;
gapi_returnCode_t result = GAPI_RETCODE_OK;
_DataReader dataReader;
c_iter readers;
u_dataReader r;
gapi_context context;
GAPI_CONTEXT_SET(context, _EntityHandle(_this), GAPI_METHOD_DELETE_CONTAINED_ENTITIES);
if ( _this ) {
readers = u_subscriberLookupReaders(U_SUBSCRIBER_GET(_this),NULL);
r = c_iterTakeFirst(readers);
while (r) {
handle = u_entityGetUserData(u_entity(r));
result = gapi_dataReader_delete_contained_entities(handle);
if (result == GAPI_RETCODE_OK) {
dataReader = gapi_dataReaderClaimNB(handle,&result);
if (dataReader) {
if ( _DataReaderPrepareDelete(dataReader, &context) ) {
_DataReaderFree(dataReader);
} else if (result == GAPI_RETCODE_OK) {
result = GAPI_RETCODE_PRECONDITION_NOT_MET;
}
}
} else if (result == GAPI_RETCODE_ALREADY_DELETED) {
result = GAPI_RETCODE_OK;
}
r = c_iterTakeFirst(readers);
}
c_iterFree(readers);
}
return result;
}
c_long
_SubscriberReaderCount (
_Subscriber _this)
{
return u_subscriberReaderCount(U_SUBSCRIBER_GET(_this));
}
_Subscriber
_SubscriberNew (
u_participant uParticipant,
const gapi_subscriberQos *qos,
const struct gapi_subscriberListener *a_listener,
const gapi_statusMask mask,
const _DomainParticipant participant)
{
_Subscriber newSubscriber;
v_subscriberQos subscriberQos;
gapi_long len;
assert(uParticipant);
assert(qos);
assert(participant);
newSubscriber = _SubscriberAlloc();
if ( newSubscriber != NULL ) {
_EntityInit(_Entity(newSubscriber),
_Entity(participant));
gapi_dataReaderQosCopy (&gapi_dataReaderQosDefault,
&newSubscriber->_defDataReaderQos);
if ( a_listener ) {
newSubscriber->_Listener = *a_listener;
}
}
if (newSubscriber != NULL ) {
subscriberQos = u_subscriberQosNew(NULL);
if ( subscriberQos != NULL ) {
if ( !copySubscriberQosIn(qos, subscriberQos) ) {
_EntityDispose(_Entity(newSubscriber));
newSubscriber = NULL;
}
} else {
_EntityDispose(_Entity(newSubscriber));
newSubscriber = NULL;
}
}
if ( newSubscriber != NULL) {
u_subscriber uSubscriber;
uSubscriber = u_subscriberNew(uParticipant, "subscriber", subscriberQos, FALSE);
u_subscriberQosFree(subscriberQos);
if ( uSubscriber != NULL ) {
U_SUBSCRIBER_SET(newSubscriber, uSubscriber);
} else {
_EntityDispose(_Entity(newSubscriber));
newSubscriber = NULL;
}
}
if ( newSubscriber != NULL) {
_Status status;
status = _StatusNew(_Entity(newSubscriber),
STATUS_KIND_SUBSCRIBER,
(struct gapi_listener *)a_listener, mask);
if (status) {
_EntityStatus(newSubscriber) = status;
len = (gapi_long)qos->partition.name._length;
if ( qos->partition.name._length == 0UL ) {
/*
* behaviour of the kernel in case of an empty sequence
* is that it is related to none of the partitions,
* while DCPS expects it to be conected to all partitions.
* Therefore this has to be done seperately.
*/
u_subscriberSubscribe (U_SUBSCRIBER_GET(newSubscriber), "");
}
newSubscriber->builtin = FALSE;
} else {
u_subscriberFree(U_SUBSCRIBER_GET(newSubscriber));
_EntityDispose(_Entity(newSubscriber));
newSubscriber = NULL;
}
}
return newSubscriber;
}
