static void
collect_readers(
c_voidp object,
c_voidp arg)
{
struct collect_readers_arg *a = (struct collect_readers_arg *)arg;
u_reader r = (u_reader)object;
c_char *name;
if (a->topic_name == NULL) {
a->readers = c_iterInsert(a->readers, r);
} else {
name = NULL;
u_dataReaderTopicName(u_dataReader(r),&name);
if (name) {
if (strcmp(name, a->topic_name) == 0)
{
/* Expect to have a u_entityKeep(r); at this point as
* soon as GAPI redesign is finished.
*/
a->readers = c_iterInsert(a->readers, r);
}
os_free(name);
}
}
}
const c_char*
cmx_dataReaderWaitForHistoricalData(
const c_char* dataReader,
const c_time timeout)
{
u_result ur;
const c_char* result;
u_dataReader entity;
entity = u_dataReader(cmx_entityUserEntity(dataReader));
if(entity != NULL){
ur = u_dataReaderWaitForHistoricalData(entity, timeout);
if(ur == U_RESULT_OK){
result = CMX_RESULT_OK;
} else if(ur == U_RESULT_TIMEOUT){
result = CMX_RESULT_TIMEOUT;
} else {
result = CMX_RESULT_FAILED;
}
} else {
result = CMX_RESULT_ENTITY_NOT_AVAILABLE;
}
return result;
}
_DataReaderView
_DataReaderViewNew (
const gapi_dataReaderViewQos * qos,
const _DataReader datareader)
{
_DataReaderView _this;
v_dataViewQos ViewQos;
u_dataView uReaderView;
_TypeSupport typeSupport;
_this = _DataReaderViewAlloc();
if ( _this != NULL ) {
_EntityInit(_Entity(_this),
_Entity(datareader));
typeSupport = _TopicDescriptionGetTypeSupport(datareader->topicDescription);
assert(typeSupport);
_this->datareader = datareader;
ViewQos = u_dataViewQosNew(NULL);
if ( ViewQos != NULL ) {
if ( !copyReaderViewQosIn(qos, ViewQos) ) {
u_dataViewQosFree(ViewQos);
_EntityDispose(_Entity(_this));
_this = NULL;
}
} else {
_EntityDispose(_Entity(_this));
_this = NULL;
}
}
if ( _this != NULL ) {
uReaderView = u_dataViewNew(u_dataReader(_EntityUEntity (datareader)),
"dataReaderView",
ViewQos);
if ( uReaderView ) {
U_DATAREADERVIEW_SET(_this, uReaderView);
} else {
_EntityDispose(_Entity(_this));
_this = NULL;
}
u_dataViewQosFree(ViewQos);
}
if ( _this != NULL ) {
if ( !initViewQuery(_this) ) {
u_dataViewFree(uReaderView);
_EntityDispose(_Entity(_this));
_this = NULL;
}
}
if ( _this != NULL ) {
_EntityStatus(_this) = _Entity(datareader)->status;
}
return _this;
}
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;
}
DDS::ReturnCode_t
DDS::OpenSplice::DataReaderView::nlReq_init (
DDS::OpenSplice::DataReader *reader,
const char *name,
const DDS::DataReaderViewQos &qos)
{
DDS::ReturnCode_t result;
u_dataViewQos uQos = NULL;
u_dataView uView = NULL;
assert (reader != NULL);
assert (name != NULL);
/* qos consistency already checked in create_view */
assert (DDS::OpenSplice::Utils::qosIsConsistent(qos) == DDS::RETCODE_OK);
uQos = u_dataViewQosNew(NULL);
if (uQos) {
result = DDS::OpenSplice::Utils::copyQosIn(qos, uQos);
if (result == DDS::RETCODE_OK) {
uView = u_dataViewNew(
u_dataReader(reader->rlReq_get_user_entity()),
name,
uQos);
if (uView) {
result = DDS::OpenSplice::Entity::nlReq_init (u_entity (uView));
if (result == DDS::RETCODE_OK) {
(void) DDS::DataReader::_duplicate(reader);
this->pimpl->reader = reader;
setDomainId(reader->getDomainId());
}
if (result == DDS::RETCODE_OK) {
result = this->pimpl->conditions->init();
}
} else {
result = DDS::RETCODE_OUT_OF_RESOURCES;
CPP_REPORT(result, "Could not create DataReaderView.");
}
}
u_dataViewQosFree(uQos);
} else {
result = DDS::RETCODE_OUT_OF_RESOURCES;
CPP_REPORT(result, "Could not copy DataReaderViewQos.");
}
return result;
}
u_result
u_readerRead(
u_reader r,
u_readerAction action,
c_voidp actionArg)
{
u_result result;
switch (u_entity(r)->kind) {
case U_READER:
result = u_dataReaderRead(u_dataReader(r), action, actionArg);
break;
case U_DATAVIEW:
result = u_dataViewRead(u_dataView(r), action, actionArg);
break;
case U_QUERY:
result = u_queryRead(u_query(r), action, actionArg);
break;
default:
result = U_RESULT_ILL_PARAM;
break;
}
return result;
}
c_ulong
d_readerListenerAction(
u_dispatcher o,
u_waitsetEvent event,
c_voidp usrData)
{
u_result result;
d_readerListener listener;
c_bool proceed;
listener = d_readerListener(usrData);
d_listenerLock(d_listener(listener));
do {
proceed = FALSE;
listener->message = NULL;
listener->processMessage = FALSE;
result = u_dataReaderTake(u_dataReader(o), d_readerListenerCopy, usrData);
if(result != U_RESULT_OK){
OS_REPORT_1(OS_ERROR, D_CONTEXT_DURABILITY, 0,
"Could not take data from reader (result: %d)", result);
} else if(listener->message != NULL){
if(listener->processMessage == TRUE) {
d_readerListenerProcessAction(listener->message, usrData);
}
c_free(listener->value);
listener->value = NULL;
proceed = TRUE;
}
} while((result == U_RESULT_OK) && (proceed == TRUE));
d_listenerUnlock(d_listener(listener));
return (event->events & V_EVENT_DATA_AVAILABLE);
}
