DDS::ReturnCode_t
DDS::OpenSplice::Utils::timeIsValid(
const DDS::Time_t &time,
os_int64 maxSupportedSeconds)
{
DDS::ReturnCode_t result = DDS::RETCODE_BAD_PARAMETER;
os_int64 sec = time.sec;
if ((time.sec >= 0) && (C_TIME_NANOS(time.nanosec) < 1000000000ULL)) {
result = DDS::RETCODE_OK;
} else if ((time.sec == TIMESTAMP_INVALID_SEC) && (time.nanosec == TIMESTAMP_INVALID_NSEC)) {
CPP_REPORT(result, "Time_t is invalid");
} else if (sec > maxSupportedSeconds) {
result = DDS::RETCODE_BAD_PARAMETER;
if (sec <= OS_TIME_MAX_VALID_SECONDS) {
CPP_REPORT(result, "Time value [%" PA_PRId64".%u] is not supported, support for time beyond year 2038 is not enabled",
sec, time.nanosec);
} else {
CPP_REPORT(result, "Time value [%" PA_PRId64".%u] is not supported the time is too large", sec, time.nanosec);
}
} else {
os_int64 sec = time.sec;
CPP_REPORT(result, "Time_t is invalid, seconds '%" PA_PRId64"', nanoseconds '%u'", sec, time.nanosec);
}
return result;
}
DDS::ReturnCode_t
DDS::OpenSplice::ReadCondition::attachToWaitset (
DDS::WaitSet *waitset
)
{
DDS::ReturnCode_t result;
result = this->write_lock ();
if (result == DDS::RETCODE_OK) {
if (!this->deinitializing) {
if (!waitsets->containsElement(waitset)) {
/* Don't _duplicate the waitset to avoid cyclic references messing up the garbage collection;
* it will detach itself when it is destructed. */
result = waitset->wlReq_attachGeneralCondition(this, u_observable(uQuery));
if (result == DDS::RETCODE_OK) {
DDS::Boolean insertOK;
insertOK = waitsets->insertElement(waitset);
if (!insertOK) {
result = DDS::RETCODE_OUT_OF_RESOURCES;
CPP_REPORT(result, "Could not attach to Waitset.");
}
assert(insertOK);
}
} else {
result = DDS::RETCODE_OK;
}
} else {
/* Do not allow a Condition that is already deinitializing to be attached to a WaitSet. */
result = DDS::RETCODE_ALREADY_DELETED;
CPP_REPORT(result, "This ReadCondition is being deleted.");
}
this->unlock ();
}
return result;
}
DDS::ReturnCode_t
DDS::OpenSplice::Utils::copyTimeIn(
const DDS::Time_t &from,
os_timeW &to,
os_int64 maxSupportedSeconds)
{
DDS::ReturnCode_t result = DDS::RETCODE_OK;
os_int64 sec = from.sec;
if ((from.sec == TIMESTAMP_INVALID_SEC) && (from.nanosec == TIMESTAMP_INVALID_NSEC)) {
to = OS_TIMEW_INVALID;
} else if (sec > maxSupportedSeconds) {
result = DDS::RETCODE_BAD_PARAMETER;
if (sec <= OS_TIME_MAX_VALID_SECONDS) {
CPP_REPORT(result, "Time value [%" PA_PRId64".%u] is not supported, support for time beyond year 2038 is not enabled",
sec, from.nanosec);
} else {
CPP_REPORT(result, "Time value [%" PA_PRId64".%u] is not supported the time is too large", sec, from.nanosec);
}
} else if ((from.sec >= 0 && from.nanosec < 1000000000)) {
to = OS_TIMEW_INIT(from.sec, from.nanosec);
} else {
result = DDS::RETCODE_BAD_PARAMETER;
}
return result;
}
DDS::ReturnCode_t
DDS::OpenSplice::DataReader::wlReq_deinit ()
{
DDS::ReturnCode_t result;
if (this->pimpl->views->getNrElements() != 0) {
result = DDS::RETCODE_PRECONDITION_NOT_MET;
CPP_REPORT(result, "DataReader still contains %d DataReaderView entities.",
this->pimpl->views->getNrElements());
} else if (this->pimpl->conditions->getNrElements() != 0) {
result = DDS::RETCODE_PRECONDITION_NOT_MET;
CPP_REPORT(result, "DataReader still contains %d Condition entities.",
this->pimpl->conditions->getNrElements());
} else {
this->disable_callbacks();
if (this->pimpl->topic != NULL) {
result = this->pimpl->topic->write_lock();
if (result == DDS::RETCODE_OK) {
this->pimpl->topic->wlReq_decrNrUsers();
this->pimpl->topic->unlock();
}
DDS::release (this->pimpl->topic);
this->pimpl->topic = NULL;
}
if (this->pimpl->subscriber != NULL) {
DDS::release (this->pimpl->subscriber);
this->pimpl->subscriber = NULL;
}
result = DDS::OpenSplice::Entity::wlReq_deinit();
}
return result;
}
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;
}
DDS::ReturnCode_t
DDS::OpenSplice::ReadCondition::take_next_instance (
DDS::OpenSplice::Entity *source,
void *data_seq,
DDS::SampleInfoSeq &info_seq,
const long max_samples,
DDS::InstanceHandle_t a_handle,
void*)
{
DDS::ReturnCode_t result = DDS::RETCODE_BAD_PARAMETER;
CPP_REPORT_STACK();
if (source->rlReq_get_kind() == DATAREADER) {
result = (dynamic_cast<FooDataReader_impl*>(source))->take_next_instance_internal(data_seq, info_seq, max_samples, a_handle, this->get_sample_state_mask(), this->get_view_state_mask(), this->get_instance_state_mask());
} else if (source->rlReq_get_kind() == DATAREADERVIEW) {
result = (dynamic_cast<FooDataReaderView_impl*>(source))->take_next_instance_internal(data_seq, info_seq, max_samples, a_handle, this->get_sample_state_mask(), this->get_view_state_mask(), this->get_instance_state_mask());
} else {
CPP_REPORT(result, "Invalid source Entity kind");
}
CPP_REPORT_FLUSH(this, (result != DDS::RETCODE_OK) && (result != DDS::RETCODE_NO_DATA) && (result != DDS::RETCODE_HANDLE_EXPIRED));
return result;
}
DDS::ReturnCode_t
DDS::OpenSplice::ReadCondition::nlReq_init (
DDS::OpenSplice::Entity *reader,
DDS::SampleStateMask sample_states,
DDS::ViewStateMask view_states,
DDS::InstanceStateMask instance_states)
{
DDS::ReturnCode_t result = DDS::RETCODE_OK;
u_reader uReader = NULL;
u_sampleMask mask = statesMask(sample_states, view_states, instance_states);
const os_char *kind;
this->reader = reader;
this->sample_states = sample_states;
this->view_states = view_states;
this->instance_states = instance_states;
result = DDS::OpenSplice::Condition::nlReq_init();
if (result == DDS::RETCODE_OK) {
setDomainId(reader->getDomainId());
if (reader->rlReq_get_kind() == DATAREADERVIEW) {
uReader = u_reader(dynamic_cast<DataReaderView*>(reader)->rlReq_get_user_entity ());
kind = "DataReaderView";
} else {
assert (reader->rlReq_get_kind() == DATAREADER);
uReader = u_reader(dynamic_cast<DataReader*>(reader)->rlReq_get_user_entity ());
kind = "DataReader";
}
if (uReader) {
if (this->uQuery == NULL) { // Query condition can initialize uQuery before ReadCondition::nlReq_init is called
// from QueryCondition::nlReq_init. In that case, do not create a query here
this->uQuery = u_queryNew(uReader, NULL, "1=1", NULL, 0, mask);
if (this->uQuery == NULL) {
result = DDS::RETCODE_ERROR;
CPP_REPORT(result, "Could not create ReadCondition.");
}
}
} else {
result = DDS::RETCODE_BAD_PARAMETER;
CPP_REPORT(result, "%s is not initialized.", kind);
}
}
return result;
}
DDS::ReturnCode_t
DDS::OpenSplice::Utils::booleanIsValid(
const DDS::Boolean value)
{
DDS::ReturnCode_t result = DDS::RETCODE_BAD_PARAMETER;
if (value == (DDS::Boolean)TRUE || value == (DDS::Boolean)FALSE) {
result = DDS::RETCODE_OK;
} else {
CPP_REPORT(result, "Boolean invalid");
}
return result;
}
DDS::ReturnCode_t
DDS::OpenSplice::ReadCondition::wlReq_detachFromWaitset (
DDS::WaitSet *waitset
)
{
DDS::ReturnCode_t result = DDS::RETCODE_OK;
if (waitsets->removeElement(waitset)) {
result = waitset->wlReq_detachGeneralCondition(this, u_observable(uQuery));
} else {
/* Unable to take the given waitset is not a problem when de-initializing. */
if (!this->deinitializing) {
result = DDS::RETCODE_PRECONDITION_NOT_MET;
CPP_REPORT(result, "This ReadCondition is being deleted.");
}
}
return result;
}
DDS::ReturnCode_t
DDS::OpenSplice::DataReaderView::wlReq_deinit ()
{
DDS::ReturnCode_t result;
if (this->pimpl->conditions->getNrElements() != 0) {
result = DDS::RETCODE_PRECONDITION_NOT_MET;
CPP_REPORT(result, "DataReaderView still contains '%d' Condition entities.",
this->pimpl->conditions->getNrElements());
} else {
if (this->pimpl->reader != NULL) {
DDS::release (this->pimpl->reader);
this->pimpl->reader = NULL;
}
result = DDS::OpenSplice::Entity::wlReq_deinit();
}
return result;
}
DDS::ReturnCode_t
DDS::OpenSplice::Utils::durationIsValid(
const DDS::Duration_t &duration)
{
DDS::ReturnCode_t result = DDS::RETCODE_BAD_PARAMETER;
/* Duration is valid, only when range below 1 billion,
* or when both fields are equal to DURATION_INFINITE.
*/
if ((duration.sec == DDS::DURATION_INFINITE_SEC &&
duration.nanosec == DDS::DURATION_INFINITE_NSEC) ||
(duration.nanosec < 1000000000ULL) )
{
result = DDS::RETCODE_OK;
} else {
CPP_REPORT(result, "Duration_t is invalid, seconds '%d', nanoseconds '%d'.",
duration.sec, duration.nanosec);
}
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;
}
