Example #1
0
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;
}
Example #2
0
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;

}
Example #3
0
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;
}