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; }