void
dds::topic::detail::Topic<T>::discover_topics(
const dds::domain::DomainParticipant& dp,
std::vector<dds::topic::Topic<T, dds::topic::detail::Topic> >& topics,
uint32_t max_size)
{
std::vector<u_topic> uTopics;
dp.delegate()->lookup_topics(topic_type_name<T>::value(), uTopics, max_size);
topics.clear();
topics.reserve(uTopics.size());
for (std::vector<u_topic>::const_iterator it = uTopics.begin(); it != uTopics.end(); ++it) {
u_topic uTopic = *it;
os_char *topic_name = u_topicName(uTopic);
os_char *type_name = u_topicTypeName(uTopic);
u_topicQos uQos;
u_result uResult = u_topicGetQos(uTopic, &uQos);
ISOCPP_U_RESULT_CHECK_AND_THROW(uResult, "Failed to get user layer topic qos");
dds::topic::qos::TopicQos qos;
qos.delegate().u_qos(uQos);
u_topicQosFree(uQos);
typename dds::topic::Topic<T, dds::topic::detail::Topic>::DELEGATE_REF_T ref(new Topic<T>(dp, topic_name, type_name, qos, uTopic));
ref->init(ref);
os_free(topic_name);
os_free(type_name);
topics.push_back(dds::topic::Topic<T>(ref));
}
}
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::topic::Topic<T, dds::topic::detail::Topic>
dds::topic::detail::Topic<T>::discover_topic(
const dds::domain::DomainParticipant& dp,
const std::string& name,
const dds::core::Duration& timeout)
{
u_topic uTopic = dp.delegate()->lookup_topic(name, timeout);
if (uTopic == NULL) {
return dds::core::null;
}
os_char *uTypename = u_topicTypeName(uTopic);
std::string type_name = uTypename;
os_free(uTypename);
u_topicQos uQos;
u_result uResult = u_topicGetQos(uTopic, &uQos);
ISOCPP_U_RESULT_CHECK_AND_THROW(uResult, "Failed to get user layer topic qos");
qos::TopicQos qos;
qos.delegate().u_qos(uQos);
u_topicQosFree(uQos);
typename dds::topic::Topic<T, dds::topic::detail::Topic>::DELEGATE_REF_T ref(new Topic<T>(dp, name, type_name, qos, uTopic));
ref->init(ref);
return dds::topic::Topic<T>(ref);
}
void
PublisherDelegate::end_coherent_changes()
{
this->check();
u_result uResult = u_publisherCoherentEnd(u_publisher(this->userHandle));
ISOCPP_U_RESULT_CHECK_AND_THROW(uResult, "Could not end coherent changes.");
}
void
PublisherDelegate::resume_publications()
{
this->check();
u_result uResult = u_publisherResume(u_publisher(this->userHandle));
ISOCPP_U_RESULT_CHECK_AND_THROW(uResult, "Could not resume publications.");
}
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
org::opensplice::core::UserObjectDelegate::close()
{
if (this->userHandle != NULL) {
u_result result = u_objectClose(this->userHandle);
if (result != U_RESULT_ALREADY_DELETED) {
ISOCPP_U_RESULT_CHECK_AND_THROW(result, "Unable to successfully close object");
}
}
org::opensplice::core::ObjectDelegate::close();
}
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;
}
