static void destroy_builtin_readers (struct builtin_datareader_set *drset)
{
if (drset->publication_dr)
u_dataReaderFree (drset->publication_dr);
if (drset->subscription_dr)
u_dataReaderFree (drset->subscription_dr);
if (drset->participant_dr)
u_dataReaderFree (drset->participant_dr);
if (drset->subscriber)
u_subscriberFree (drset->subscriber);
}
u_result
u_subscriberDeleteContainedEntities (
u_subscriber _this)
{
u_result result;
u_reader reader;
c_iter list;
if (_this != NULL) {
result = u_entityLock(u_entity(_this));
if (result == U_RESULT_OK) {
list = _this->readers;
_this->readers = NULL;
/* Unlock here because following code will take this lock. */
u_entityUnlock(u_entity(_this));
reader = c_iterTakeFirst(list);
while (reader) {
switch (u_entityKind(u_entity(reader))) {
case U_READER:
result = u_dataReaderDeleteContainedEntities(u_dataReader(reader));
result = u_dataReaderFree(u_dataReader(reader));
break;
case U_GROUPQUEUE:
result = u_groupQueueFree(u_groupQueue(reader));
break;
case U_DATAVIEW:
result = u_dataViewFree(u_dataView(reader));
break;
case U_NETWORKREADER:
result = u_networkReaderFree(u_networkReader(reader));
break;
default:
OS_REPORT_2(OS_WARNING,
"u_subscriberDeleteContainedEntities",0,
"invalid object type: "
"For Subscriber = 0x%x, found Reader type = %s.",
_this, u_kindImage(u_entityKind(u_entity(reader))));
assert(0);
break;
}
u_entityDereference(u_entity(_this));
reader = c_iterTakeFirst(list);
}
c_iterFree(list);
} else {
OS_REPORT_2(OS_WARNING,
"u_subscriberDeleteContainedEntities",0,
"Operation u_entityLock failed: "
"Subscriber = 0x%x, result = %s.",
_this, u_resultImage(result));
}
} else {
OS_REPORT(OS_WARNING,
"u_subscriberDeleteContainedEntities",0,
"Invalid Subscriber <NULL>.");
result = U_RESULT_ILL_PARAM;
}
return result;
}
gapi_returnCode_t
_DataReaderFree (
_DataReader _this)
{
gapi_returnCode_t result = GAPI_RETCODE_OK;
_Status status;
u_dataReader r;
assert(_this);
/* The following refCount checking and destruction mechanism is not
* bullet proof and may cause leakage.
* This is a temporary situation during GAPI redesign and should be
* resolved when the GAPI redesign is finished.
*/
r = U_DATAREADER_GET(_this);
_TopicDescriptionDecUse(_this->topicDescription);
status = _EntityStatus(_this);
_StatusSetListener(status, NULL, 0);
_EntityClaim(status);
_StatusDeinit(status);
gapi_loanRegistry_free(_this->loanRegistry);
/* Following the user layer reader object is deleted after the entity
* dispose because it will otherwise lead to a double free of the user
* layer reader.
* This is caused by the status condition which is attached to an exiting
* waitset and the fact that a status condition's user object is the user
* layer reader.
* This is a hack but besides of that the destruction of the user entity
* should be part of the entity dispose method.
* For now this works.
*/
_EntityDispose(_Entity(_this));
u_dataReaderFree(r);
return result;
}
void
d_readerListenerDeinit(
d_object object)
{
d_readerListener listener;
assert(d_objectIsValid(object, D_LISTENER));
if(object){
listener = d_readerListener(object);
d_readerListenerStop(listener);
if(listener->deinit){
listener->deinit(object);
}
d_listenerLock(d_listener(listener));
u_dataReaderFree(listener->dataReader);
os_free(listener->name);
d_listenerUnlock(d_listener(listener));
}
}
u_result
u_subscriberDeinit(
u_subscriber _this)
{
u_result result;
u_dataReader reader;
c_iter list;
if (_this != NULL) {
result = u_participantRemoveSubscriber(_this->participant,_this);
if (result == U_RESULT_OK) {
_this->participant = NULL;
if (_this->readers) {
list = _this->readers;
_this->readers = NULL;
u_entityUnlock(u_entity(_this));
reader = c_iterTakeFirst(list);
while (reader) {
/* Readers should not exist at this point!
* This loop corrects this erronous state.
*/
result = u_dataReaderFree(reader);
u_entityDereference(u_entity(_this));
reader = c_iterTakeFirst(list);
}
c_iterFree(list);
result = u_entityLock(u_entity(_this));
}
result = u_dispatcherDeinit(u_dispatcher(_this));
}
} else {
OS_REPORT_1(OS_ERROR,
"u_subscriberDeinit",0,
"Illegal parameter: _this = 0x%x.",
_this);
result = U_RESULT_ILL_PARAM;
}
return result;
}
_DataReader
_DataReaderNew (
const _TopicDescription topicDescription,
const _TypeSupport typesupport,
const gapi_dataReaderQos *qos,
const struct gapi_dataReaderListener *a_listener,
const gapi_statusMask mask,
const _Subscriber subscriber)
{
_DataReader _this;
v_readerQos readerQos;
u_dataReader uReader;
gapi_string topicName;
char dataReaderId[256];
c_bool noError = TRUE;
readerQos = u_readerQosNew(NULL);
if ( readerQos != NULL ) {
if ( gapi_kernelReaderQosCopyIn(qos, readerQos) ) {
q_expr expr;
c_value *params;
topicName = _TopicDescriptionGetName (topicDescription);
if (topicName) {
snprintf (dataReaderId,
sizeof(dataReaderId),
"%sReader", topicName);
gapi_free (topicName);
} else {
snprintf (dataReaderId,
sizeof(dataReaderId),
"dataReader");
}
expr = _TopicDescriptionGetExpr(topicDescription);
if (_ObjectGetKind(_Object(topicDescription)) ==
OBJECT_KIND_CONTENTFILTEREDTOPIC) {
params = _ContentFilteredTopicParameters(
(_ContentFilteredTopic)topicDescription);
} else {
params = NULL;
}
uReader = u_dataReaderNew(_SubscriberUsubscriber(subscriber),
dataReaderId,
expr,
params,
readerQos,
FALSE);
q_dispose(expr);
os_free(params);
noError = (uReader != NULL);
if (noError) {
_this = _DataReaderAlloc();
if ( _this != NULL ) {
noError = _DataReaderInit(_this,
subscriber,
topicDescription,
typesupport,
a_listener,
mask,
uReader);
if (!noError) {
_EntityDispose(_Entity(_this));
}
}
if (!noError) {
u_dataReaderFree(uReader);
}
}
} else {
noError = FALSE;
}
u_readerQosFree(readerQos);
} else {
noError = FALSE;
}
if (!noError) {
_this = NULL;
}
return _this;
}
