std::vector<org::opensplice::sub::AnyDataReaderDelegate::ref_type>
SubscriberDelegate::get_datareaders(
const dds::sub::status::DataState& mask)
{
org::opensplice::core::ScopedObjectLock scopedLock(*this);
std::vector<org::opensplice::sub::AnyDataReaderDelegate::ref_type> readers;
u_dataReader uReader;
u_sampleMask uMask;
u_result uResult;
c_iter uList;
/* Get list from user layer. */
uMask = org::opensplice::sub::AnyDataReaderDelegate::getUserMask(mask);
uResult = u_subscriberGetDataReaders(u_subscriber(this->userHandle), uMask, &uList);
ISOCPP_U_RESULT_CHECK_AND_THROW(uResult, "Could not get datareaders.");
/* Translate user layer list. */
readers.reserve(c_iterLength(uList));
while ((uReader = u_dataReader(c_iterTakeFirst(uList))) != NULL) {
org::opensplice::core::ObjectDelegate::ref_type reader =
org::opensplice::core::EntityDelegate::extract_strong_ref(u_entity(uReader));
if (reader) {
readers.push_back(OSPL_CXX11_STD_MODULE::dynamic_pointer_cast<AnyDataReaderDelegate>(reader));
}
}
c_iterFree(uList);
return readers;
}
void
SubscriberDelegate::end_coherent_access()
{
ISOCPP_REPORT_STACK_DELEGATE_BEGIN(this);
this->check();
u_result uResult = u_subscriberEndAccess(u_subscriber(this->userHandle));
ISOCPP_U_RESULT_CHECK_AND_THROW(uResult, "Could not end coherent access.");
ISOCPP_REPORT_STACK_END();
}
void
SubscriberDelegate::qos(const dds::sub::qos::SubscriberQos& sqos)
{
org::opensplice::core::ScopedObjectLock scopedLock(*this);
u_subscriberQos uQos;
u_result uResult;
sqos.delegate().check();
uQos = sqos.delegate().u_qos();
if (!uQos) {
ISOCPP_THROW_EXCEPTION(ISOCPP_ERROR, "Could not convert subscriber qos.");
}
uResult = u_subscriberSetQos(u_subscriber(this->userHandle), uQos);
u_subscriberQosFree(uQos);
ISOCPP_U_RESULT_CHECK_AND_THROW(uResult, "Could not set subscriber qos.");
this->qos_ = sqos;
}
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;
}
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;
}
