void d_readerListenerInitDataReader( d_readerListener listener, d_subscriber subscriber, const c_char* name, v_reliabilityKind reliability, v_historyQosKind historyKind, c_long historyDepth) { v_readerQos readerQos; u_subscriber s; d_networkAddress unaddressed, myAddr; d_admin admin; c_char *query; q_expr expr; assert(d_objectIsValid(d_object(listener), D_LISTENER)); if(listener && subscriber){ readerQos = d_readerQosNew(V_DURABILITY_VOLATILE, reliability); readerQos->history.kind = historyKind; readerQos->history.depth = historyDepth; readerQos->lifecycle.autopurge_nowriter_samples_delay.seconds = 60; readerQos->lifecycle.autopurge_nowriter_samples_delay.nanoseconds = 0; readerQos->lifecycle.autopurge_disposed_samples_delay.seconds = 10; readerQos->lifecycle.autopurge_disposed_samples_delay.nanoseconds = 0; s = d_subscriberGetSubscriber(subscriber); admin = d_subscriberGetAdmin(subscriber); myAddr = d_adminGetMyAddress(admin); unaddressed = d_networkAddressUnaddressed(); /* * Message is: * - meant for me or * - meant for all and not sent by me */ #define FILTER_EXPRESSION "select * from %s where " \ "parentMsg.addressee.systemId=%u OR " \ "parentMsg.addressee.systemId=%u AND " \ "parentMsg.senderAddress.systemId!=%u" query = (c_char*)(os_malloc(strlen(listener->name) + strlen(FILTER_EXPRESSION) + 32)); os_sprintf(query, FILTER_EXPRESSION, listener->name, myAddr->systemId, unaddressed->systemId, myAddr->systemId); expr = q_parse(query); listener->dataReader = u_dataReaderNew (s, name, expr, NULL, readerQos, TRUE); q_dispose(expr); os_free(query); #undef FILTER_EXPRESSION d_networkAddressFree(myAddr); d_networkAddressFree(unaddressed); d_readerQosFree(readerQos); } }
u_dataReader u_subscriberCreateDataReader ( u_subscriber _this, const c_char *name, const c_char *expression, c_value params[], v_readerQos qos, c_bool enable) { u_dataReader reader; q_expr expr; if (_this) { if (expression) { expr = q_parse(expression); if (!expr) { OS_REPORT_1(OS_WARNING, "u_subscriberCreateDataReader",0, "Invalid filter expression: '%s'.", expression); } } else { expr = NULL; } reader = u_dataReaderNew(_this, name, expr, params, qos, enable); if (expr) { q_dispose(expr); } } else { reader = NULL; OS_REPORT(OS_WARNING, "u_subscriberCreateDataReader",0, "Bad parameter: Subscriber = NULL."); } return reader; }
c_char* cmx_dataReaderNew( const c_char* subscriber, const c_char* name, const c_char* view, const c_char* qos) { u_subscriber sub; u_dataReader rea; c_char* result; cmx_entityArg arg; u_result ur; cmx_entityKernelArg kernelArg; v_readerQos rqos; q_expr qexpr; result = NULL; sub = u_subscriber(cmx_entityUserEntity(subscriber)); if(sub != NULL){ kernelArg = cmx_entityKernelArg(os_malloc(C_SIZEOF(cmx_entityKernelArg))); u_entityAction(u_entity(sub), cmx_entityKernelAction, (c_voidp)kernelArg); if(qos != NULL){ rqos = v_readerQos(cmx_qosKernelQosFromKind(qos, K_DATAREADER, c_getBase(c_object(kernelArg->kernel)))); if(rqos == NULL){ rqos = v_readerQosNew(kernelArg->kernel, NULL); } } else { rqos = v_readerQosNew(kernelArg->kernel, NULL); } if(view != NULL){ qexpr = q_parse(view); if(qexpr != NULL){ rea = u_dataReaderNew(sub, name, qexpr, NULL, rqos, TRUE); q_dispose(qexpr); } else { rea = NULL; OS_REPORT(OS_ERROR, CM_XML_CONTEXT, 0, "cmx_dataReaderNew: invalid view expression."); } } else { rea = u_dataReaderNew(sub, name, NULL, NULL, rqos, TRUE); } c_free(rqos); os_free(kernelArg); if(rea != NULL){ cmx_registerEntity(u_entity(rea)); arg = cmx_entityArg(os_malloc((os_uint32)(C_SIZEOF(cmx_entityArg)))); arg->entity = u_entity(rea); arg->create = FALSE; arg->participant = NULL; arg->result = NULL; ur = u_entityAction(u_entity(rea), cmx_entityNewFromAction, (c_voidp)(arg)); if(ur == U_RESULT_OK){ result = arg->result; os_free(arg); } } } 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; }
DDS::ReturnCode_t DDS::OpenSplice::DataReader::nlReq_init ( DDS::OpenSplice::Subscriber *subscriber, const DDS::DataReaderQos &qos, DDS::OpenSplice::TopicDescription *a_topic, const char *name) { DDS::OpenSplice::ContentFilteredTopic *contentFilteredTopic; DDS::ULong i = 0; DDS::ULong length = 0; DDS::ULong bytes = 0; DDS::ReturnCode_t result = DDS::RETCODE_OK; u_readerQos uReaderQos = NULL; u_dataReader uReader = NULL; const char *expression = NULL; c_value *uParameters = NULL; assert (subscriber != NULL); /* Only check for QoS consistency here in debug builds. It's unnecessary to to verify it twice in release builds. */ assert (DDS::OpenSplice::Utils::qosIsConsistent (qos) == DDS::RETCODE_OK); assert (a_topic != NULL); assert (name != NULL); uReaderQos = u_readerQosNew (NULL); if (uReaderQos != NULL) { result = DDS::OpenSplice::Utils::copyQosIn (qos, uReaderQos); } else { result = DDS::RETCODE_OUT_OF_RESOURCES; CPP_REPORT(result, "Could not copy DataReaderQos."); } if (result == DDS::RETCODE_OK) { result = this->pimpl->views->init(); } if (result == DDS::RETCODE_OK) { result = this->pimpl->conditions->init(); } if (result == DDS::RETCODE_OK) { result = a_topic->write_lock(); if (result == DDS::RETCODE_OK) { expression = a_topic->rlReq_get_topic_expression (); assert(expression); switch (a_topic->rlReq_get_kind()) { case DDS::OpenSplice::CONTENTFILTEREDTOPIC: contentFilteredTopic = dynamic_cast<DDS::OpenSplice::ContentFilteredTopic *>(a_topic); if (contentFilteredTopic != NULL) { length = contentFilteredTopic->filterParameters.length (); if(length > 0) { bytes = length * sizeof (struct c_value); uParameters = (c_value *)os_malloc (bytes); for (i = 0; i < length; i++) { const c_string param = (const c_string) contentFilteredTopic->filterParameters[i].in(); uParameters[i] = c_stringValue(param); } } } else { result = DDS::RETCODE_BAD_PARAMETER; CPP_REPORT(result, "a_topic invalid, not of type '%s'", "DDS::OpenSplice::ContentFilteredTopic"); } break; case DDS::OpenSplice::TOPIC: default: uParameters = NULL; break; } } if (result == DDS::RETCODE_OK) { uReader = u_dataReaderNew ( u_subscriber (subscriber->rlReq_get_user_entity ()), name, expression, uParameters, length, uReaderQos); if (uReader == NULL) { result = DDS::RETCODE_OUT_OF_RESOURCES; CPP_REPORT(result, "Could not create DataReader."); } } if (result == DDS::RETCODE_OK) { result = DDS::OpenSplice::Entity::nlReq_init (u_entity (uReader)); if (result == DDS::RETCODE_OK) { (void) DDS::Subscriber::_duplicate(subscriber); this->pimpl->subscriber = subscriber; (void) DDS::TopicDescription::_duplicate(a_topic); this->pimpl->topic = a_topic; a_topic->wlReq_incrNrUsers(); setDomainId(subscriber->getDomainId()); } } a_topic->unlock(); } if (uReaderQos) { u_readerQosFree (uReaderQos); } if (uParameters) { os_free (uParameters); } return result; }