Example #1
0
_Subscriber
_BuiltinSubscriberNew (
    u_participant uParticipant,
    _DomainParticipantFactory factory,
    _DomainParticipant participant)
{
    u_subscriber s;
    _Status status;
    _Subscriber newSubscriber = _SubscriberAlloc();
    gapi_handle handle;
    _TypeSupport typeSupport;
    gapi_dataReaderQos rQos;
    long i;

    s = u_participantGetBuiltinSubscriber(uParticipant);

    if (s) {
        newSubscriber = _SubscriberAlloc();

        if (newSubscriber != NULL) {

            _EntityInit(_Entity(newSubscriber), _Entity(participant));

            U_SUBSCRIBER_SET(newSubscriber, s);

            status = _StatusNew(_Entity(newSubscriber),
                                STATUS_KIND_SUBSCRIBER,
                                NULL, 0);
            if (status) {
                for ( i = 0; i < MAX_BUILTIN_TOPIC; i++ ) {
                    _DataReader reader = NULL;
                    _Topic topic = NULL;

                    typeSupport = _DomainParticipantFindTypeSupport(participant,
                                                                    _BuiltinTopicTypeName(i));
                    if (typeSupport) {
                        c_iter uTopicList;
                        u_topic uTopic;

                        uTopicList = u_participantFindTopic(uParticipant,
                                                            _BuiltinTopicName(i),
                                                            C_TIME_ZERO);
                        uTopic = c_iterTakeFirst(uTopicList);
                        if (uTopic) {
                            topic = _TopicFromKernelTopic(uTopic,
                                                          _BuiltinTopicName(i),
                                                          _BuiltinTopicTypeName(i),
                                                          typeSupport,
                                                          participant,
                                                          NULL);
                            while (uTopic) {
                                uTopic = c_iterTakeFirst(uTopicList);
                                /* multiple instances should not occure but
                                 * just in case this loop frees all references.
                                 */
                                assert(uTopic == NULL);
                                u_entityFree(u_entity(uTopic));
                            }
                        } else {
                            OS_REPORT_2(OS_WARNING,"_BuiltinSubscriberNew",0,
                                        "failed to resolve User layer Topic "
                                        "'%s' for Participant 0x%x",
                                        _BuiltinTopicName(i), participant);
                        }
                    } else {
                        OS_REPORT_2(OS_WARNING,"_BuiltinSubscriberNew",0,
                                    "Builtin TypeSupport for type '%s' is not "
                                    "yet registered for Participant 0x%x",
                                    _BuiltinTopicTypeName(i), participant);
                    }

                    if (topic) {
                        initBuiltinDataReaderQos(&rQos);
                        reader = _DataReaderNew(_TopicDescription(topic),
                                                typeSupport,
                                                &rQos,
                                                NULL, 0,
                                                newSubscriber);

                        _EntityRelease(topic);
                    } else {
                        OS_REPORT_2(OS_WARNING,"_BuiltinSubscriberNew",0,
                                    "failed to create Builtin Topic '%s' "
                                    "for Participant 0x%x",
                                    _BuiltinTopicName(i), participant);
                    }

                    if ( reader ) {
                        _ENTITY_REGISTER_OBJECT(_Entity(newSubscriber),
                                                (_Object)reader);
                        handle = _EntityRelease(reader);
                        gapi_entity_enable(handle);
                    }
                }
                newSubscriber->builtin = TRUE;
                _EntityStatus(newSubscriber) = status;
            } else {
                _EntityDispose(_Entity(newSubscriber));
                newSubscriber = NULL;
            }
        }
    }
    return newSubscriber;
}
Example #2
0
_Subscriber
_SubscriberNew (
    u_participant uParticipant,
    const gapi_subscriberQos  *qos,
    const struct gapi_subscriberListener *a_listener,
    const gapi_statusMask mask,
    const _DomainParticipant participant)
{
    _Subscriber newSubscriber;
    v_subscriberQos subscriberQos;
    gapi_long len;

    assert(uParticipant);
    assert(qos);
    assert(participant);

    newSubscriber = _SubscriberAlloc();

    if ( newSubscriber != NULL ) {
        _EntityInit(_Entity(newSubscriber),
                          _Entity(participant));
        gapi_dataReaderQosCopy (&gapi_dataReaderQosDefault,
                                &newSubscriber->_defDataReaderQos);
        if ( a_listener ) {
            newSubscriber->_Listener = *a_listener;
        }
    }

    if  (newSubscriber != NULL ) {
        subscriberQos = u_subscriberQosNew(NULL);
        if ( subscriberQos != NULL ) {
            if ( !copySubscriberQosIn(qos, subscriberQos) ) {
                _EntityDispose(_Entity(newSubscriber));
                newSubscriber = NULL;
            }
        } else {
            _EntityDispose(_Entity(newSubscriber));
            newSubscriber = NULL;
        }
    }

    if ( newSubscriber != NULL) {
        u_subscriber uSubscriber;
        uSubscriber = u_subscriberNew(uParticipant, "subscriber", subscriberQos, FALSE);
        u_subscriberQosFree(subscriberQos);
        if ( uSubscriber != NULL ) {
            U_SUBSCRIBER_SET(newSubscriber, uSubscriber);
        } else {
            _EntityDispose(_Entity(newSubscriber));
            newSubscriber = NULL;
        }
    }

    if ( newSubscriber != NULL) {
        _Status status;

        status = _StatusNew(_Entity(newSubscriber),
                            STATUS_KIND_SUBSCRIBER,
                            (struct gapi_listener *)a_listener, mask);
        if (status) {
            _EntityStatus(newSubscriber) = status;
            len = (gapi_long)qos->partition.name._length;
            if ( qos->partition.name._length == 0UL ) {
                /*
                 * behaviour of the kernel in case of an empty sequence
                 * is that it is related to none of the partitions,
                 * while DCPS expects it to be conected to all partitions.
                 * Therefore this has to be done seperately.
                 */
                u_subscriberSubscribe (U_SUBSCRIBER_GET(newSubscriber), "");
            }
            newSubscriber->builtin = FALSE;
        } else {
            u_subscriberFree(U_SUBSCRIBER_GET(newSubscriber));
            _EntityDispose(_Entity(newSubscriber));
            newSubscriber = NULL;
        }
    }

    return newSubscriber;
}