static void subscribe(int domain_id, int sample_count)
    {
        // --- Create participant --- //

        /* To customize the participant QoS, use
         * the configuration file USER_QOS_PROFILES.xml */
        DDS.DomainParticipant participant =
            DDS.DomainParticipantFactory.get_instance().create_participant(
                domain_id,
                DDS.DomainParticipantFactory.PARTICIPANT_QOS_DEFAULT,
                null /* listener */,
                DDS.StatusMask.STATUS_MASK_NONE);
        if (participant == null)
        {
            shutdown(participant);
            throw new ApplicationException("create_participant error");
        }

        // --- Create subscriber --- //

        /* To customize the subscriber QoS, use
         * the configuration file USER_QOS_PROFILES.xml */
        DDS.Subscriber subscriber = participant.create_subscriber(
            DDS.DomainParticipant.SUBSCRIBER_QOS_DEFAULT,
            null /* listener */,
            DDS.StatusMask.STATUS_MASK_NONE);
        if (subscriber == null)
        {
            shutdown(participant);
            throw new ApplicationException("create_subscriber error");
        }

        // --- Create topic --- //

        /* Register the type before creating the topic */
        System.String type_name = waitsetsTypeSupport.get_type_name();
        try {
            waitsetsTypeSupport.register_type(
                participant, type_name);
        } catch (DDS.Exception e) {
            Console.WriteLine("register_type error {0}", e);
            shutdown(participant);
            throw e;
        }

        /* To customize the topic QoS, use
         * the configuration file USER_QOS_PROFILES.xml */
        DDS.Topic topic = participant.create_topic(
            "Example waitsets",
            type_name,
            DDS.DomainParticipant.TOPIC_QOS_DEFAULT,
            null /* listener */,
            DDS.StatusMask.STATUS_MASK_NONE);
        if (topic == null)
        {
            shutdown(participant);
            throw new ApplicationException("create_topic error");
        }

        // --- Create reader --- //

        /* To customize the data reader QoS, use
         * the configuration file USER_QOS_PROFILES.xml */
        DDS.DataReader reader = subscriber.create_datareader(
            topic,
            DDS.Subscriber.DATAREADER_QOS_DEFAULT,
            null,
            DDS.StatusMask.STATUS_MASK_ALL);
        if (reader == null)
        {
            shutdown(participant);
            throw new ApplicationException("create_datareader error");
        }

        /* If you want to change the DataReader's QoS programmatically rather
         * than using the XML file, you will need to add the following lines to
         * your code and comment out the create_datareader call above.
         *
         * In this case, we reduce the liveliness timeout period to trigger the
         * StatusCondition DDS.StatusKind.LIVELINESS_CHANGED_STATUS
         */
        /*
         * DDS.DataReaderQos datawriter_qos = new DDS.DataReaderQos();
         * try {
         *  subscriber.get_default_datareader_qos(datawriter_qos);
         * } catch (DDS.Exception e) {
         *  Console.WriteLine("get_default_datareader_qos error {0}", e);
         *  shutdown(participant);
         *  throw e;
         * }
         * datawriter_qos.liveliness.lease_duration.sec = 2;
         * datawriter_qos.liveliness.lease_duration.nanosec = 0;
         *
         * reader = subscriber.create_datareader(topic, datawriter_qos,
         *  null, DDS.StatusMask.STATUS_MASK_NONE);
         * if (reader == null) {
         *  shutdown(participant);
         *  throw new ApplicationException("create_datawriter_qos error");
         * }
         */

        /* Create read condition
         * ---------------------
         * Note that the Read Conditions are dependent on both incoming
         * data as well as sample state. Thus, this method has more
         * overhead than adding a DDS.StatusKind.DATA_AVAILABLE_STATUS
         * StatusCondition. We show it here purely for reference
         */
        DDS.ReadCondition read_condition = reader.create_readcondition(
            DDS.SampleStateKind.NOT_READ_SAMPLE_STATE,
            DDS.ViewStateKind.ANY_VIEW_STATE,
            DDS.InstanceStateKind.ANY_INSTANCE_STATE);
        if (read_condition == null)
        {
            shutdown(participant);
            throw new ApplicationException("create_readcondition error");
        }

        /* Get status conditions
         * ---------------------
         * Each entity may have an attached Status Condition. To modify the
         * statuses we need to get the reader's Status Conditions first.
         */

        DDS.StatusCondition status_condition = reader.get_statuscondition();
        if (status_condition.get_entity() == null)
        {
            shutdown(participant);
            throw new ApplicationException("get_statuscondition error");
        }

        /* Set enabled statuses
         * --------------------
         * Now that we have the Status Condition, we are going to enable the
         * statuses we are interested in:
         * DDS.StatusKind.SUBSCRIPTION_MATCHED_STATUS
         * and DDS.StatusKind.LIVELINESS_CHANGED_STATUS.
         */
        try {
            status_condition.set_enabled_statuses(
                DDS.StatusMask.STATUS_MASK_NONE |
                (DDS.StatusMask)DDS.StatusKind.SUBSCRIPTION_MATCHED_STATUS |
                (DDS.StatusMask)DDS.StatusKind.LIVELINESS_CHANGED_STATUS);
        } catch (DDS.Exception e) {
            Console.WriteLine("set_enabled_statuses error {0}", e);
            shutdown(participant);
            throw e;
        }

        /* Create and attach conditions to the WaitSet
         * -------------------------------------------
         * Finally, we create the WaitSet and attach both the Read Conditions
         * and the Status Condition to it.
         */
        DDS.WaitSet waitset = new DDS.WaitSet();

        /* Attach Read Conditions */
        try {
            waitset.attach_condition(read_condition);
        } catch (DDS.Exception e) {
            Console.WriteLine("attach_read_condition error {0}", e);
            shutdown(participant);
            throw e;
        }

        /* Attach Status Conditions */
        try {
            waitset.attach_condition(status_condition);
        } catch (DDS.Exception e) {
            Console.WriteLine("attach_status_condition error {0}", e);
            shutdown(participant);
            throw e;
        }

        /* Narrow the reader into your specific data type */
        waitsetsDataReader waitsets_reader =
            (waitsetsDataReader)reader;


        /* Main loop */
        for (int count = 0; (sample_count == 0) || (count < sample_count);
             ++count)
        {
            DDS.ConditionSeq active_conditions_seq = new DDS.ConditionSeq();
            DDS.Duration_t   timeout;
            timeout.nanosec = (uint)500000000;
            timeout.sec     = 1;

            /* wait() blocks execution of the thread until one or more attached
             * Conditions become true, or until a user-specified timeout expires
             */
            try {
                waitset.wait(active_conditions_seq, timeout);
            } catch (DDS.Retcode_Timeout) {
                Console.WriteLine("Wait timed out!! No conditions were " +
                                  "triggered.");
                continue;
            } catch (DDS.Exception e) {
                Console.WriteLine("wait error {0}", e);
                break;
            }

            /* Get the number of active conditions */
            int active_conditions = active_conditions_seq.length;
            Console.WriteLine("Got {0} active conditions", active_conditions);

            for (int i = 0; i < active_conditions; i++)
            {
                /* Now we compare the current condition with the Status
                 * Conditions and the Read Conditions previously defined. If
                 * they match, we print the condition that was triggered.*/

                /* Compare with Status Conditions */
                if (active_conditions_seq.get_at(i) == status_condition)
                {
                    /* Get the status changes so we can check which status
                     * condition triggered. */
                    DDS.StatusMask triggeredmask =
                        waitsets_reader.get_status_changes();

                    /* Liveliness changed */
                    DDS.StatusMask test = triggeredmask &
                                          (DDS.StatusMask)DDS.StatusKind.
                                          LIVELINESS_CHANGED_STATUS;
                    if (test != DDS.StatusMask.STATUS_MASK_NONE)
                    {
                        DDS.LivelinessChangedStatus st =
                            new DDS.LivelinessChangedStatus();
                        waitsets_reader.get_liveliness_changed_status(ref st);
                        Console.WriteLine("Liveliness changed => " +
                                          "Active writers = {0}", st.alive_count);
                    }

                    /* Subscription matched */
                    test = triggeredmask &
                           (DDS.StatusMask)DDS.StatusKind.
                           SUBSCRIPTION_MATCHED_STATUS;
                    if (test != DDS.StatusMask.STATUS_MASK_NONE)
                    {
                        DDS.SubscriptionMatchedStatus st =
                            new DDS.SubscriptionMatchedStatus();
                        waitsets_reader.get_subscription_matched_status(ref st);
                        Console.WriteLine("Subscription matched => " +
                                          "Cumulative matches = {0}", st.total_count);
                    }
                }

                /* Compare with Read Conditions */
                else if (active_conditions_seq.get_at(i) == read_condition)
                {
                    /* Current conditions match our conditions to read data, so
                     * we can read data just like we would do in any other
                     * example. */
                    waitsetsSeq       data_seq = new waitsetsSeq();
                    DDS.SampleInfoSeq info_seq = new DDS.SampleInfoSeq();

                    /* You may want to call take_w_condition() or
                     * read_w_condition() on the Data Reader. This way you will
                     * use the same status masks that were set on the Read
                     * Condition.
                     * This is just a suggestion, you can always use
                     * read() or take() like in any other example.
                     */
                    bool follow = true;
                    while (follow)
                    {
                        try {
                            waitsets_reader.take_w_condition(
                                data_seq, info_seq,
                                DDS.ResourceLimitsQosPolicy.LENGTH_UNLIMITED,
                                read_condition);

                            for (int j = 0; j < data_seq.length; ++j)
                            {
                                if (!info_seq.get_at(j).valid_data)
                                {
                                    Console.WriteLine("Got metadata");
                                    continue;
                                }
                                waitsetsTypeSupport.print_data(
                                    data_seq.get_at(j));
                            }
                        } catch (DDS.Retcode_NoData) {
                            /* When there isn't data, the subscriber stop to
                             * take samples
                             */
                            follow = false;
                        } finally {
                            waitsets_reader.return_loan(data_seq, info_seq);
                        }
                    }
                }
            }
        }

        // --- Shutdown --- //

        /* Delete all entities */
        shutdown(participant);
    }
    static void subscribe(int domain_id, int sample_count)
    {
        // --- Create participant --- //

        /* To customize the participant QoS, use
         * the configuration file USER_QOS_PROFILES.xml */
        DDS.DomainParticipant participant =
            DDS.DomainParticipantFactory.get_instance().create_participant(
                domain_id,
                DDS.DomainParticipantFactory.PARTICIPANT_QOS_DEFAULT,
                null /* listener */,
                DDS.StatusMask.STATUS_MASK_NONE);
        if (participant == null)
        {
            shutdown(participant);
            throw new ApplicationException("create_participant error");
        }

        // --- Create subscriber --- //

        /* To customize the subscriber QoS, use
         * the configuration file USER_QOS_PROFILES.xml */
        DDS.Subscriber subscriber = participant.create_subscriber(
            DDS.DomainParticipant.SUBSCRIBER_QOS_DEFAULT,
            null /* listener */,
            DDS.StatusMask.STATUS_MASK_NONE);
        if (subscriber == null)
        {
            shutdown(participant);
            throw new ApplicationException("create_subscriber error");
        }

        // --- Create topic --- //

        /* Register the type before creating the topic */
        System.String type_name =
            waitset_statuscondTypeSupport.get_type_name();
        try {
            waitset_statuscondTypeSupport.register_type(
                participant, type_name);
        }
        catch (DDS.Exception e) {
            Console.WriteLine("register_type error {0}", e);
            shutdown(participant);
            throw e;
        }

        /* To customize the topic QoS, use
         * the configuration file USER_QOS_PROFILES.xml */
        DDS.Topic topic = participant.create_topic(
            "Example waitset_statuscond",
            type_name,
            DDS.DomainParticipant.TOPIC_QOS_DEFAULT,
            null /* listener */,
            DDS.StatusMask.STATUS_MASK_NONE);
        if (topic == null)
        {
            shutdown(participant);
            throw new ApplicationException("create_topic error");
        }

        // --- Create reader --- //



        /* To customize the data reader QoS, use
         * the configuration file USER_QOS_PROFILES.xml */
        DDS.DataReader reader = subscriber.create_datareader(
            topic,
            DDS.Subscriber.DATAREADER_QOS_DEFAULT,
            null,
            DDS.StatusMask.STATUS_MASK_ALL);
        if (reader == null)
        {
            shutdown(participant);
            throw new ApplicationException("create_datareader error");
        }

        // Get narrowed datareader
        waitset_statuscondDataReader waitset_reader =
            (waitset_statuscondDataReader)reader;

        /* Get status conditions
         * ---------------------
         * Each entity may have an attached Status Condition. To modify the
         * statuses we need to get the reader's Status Conditions first.
         */
        DDS.StatusCondition status_condition = reader.get_statuscondition();

        /* Set enabled statuses
         * --------------------
         * Now that we have the Status Condition, we are going to enable the
         * status we are interested in: knowing that data is available
         */
        try
        {
            status_condition.set_enabled_statuses(
                (DDS.StatusMask)DDS.StatusKind.DATA_AVAILABLE_STATUS);
        }
        catch (DDS.Exception e)
        {
            shutdown(participant);
            throw new ApplicationException("set_enabled_statuses error {0}",
                                           e);
        }

        /* Create and attach conditions to the WaitSet
         * -------------------------------------------
         * Finally, we create the WaitSet and attach both the Read Conditions
         * and the Status Condition to it.
         */
        DDS.WaitSet waitset = new DDS.WaitSet();


        /* Attach Status Conditions */
        try
        {
            waitset.attach_condition(status_condition);
        }
        catch (DDS.Exception e)
        {
            shutdown(participant);
            throw new ApplicationException("set_enabled_statuses error {0}",
                                           e);
        }
        // --- Wait for data --- //
        int count = 0;

        DDS.Duration_t timeout;
        timeout.nanosec = (uint)500000000;
        timeout.sec     = 1;

        /* Main loop */
        while (sample_count == 0 || count < sample_count)
        {
            DDS.ConditionSeq active_conditions = new DDS.ConditionSeq();

            // The triggered condition(s) will be placed in active_conditions
            try
            {
                waitset.wait(active_conditions, timeout);
                Console.WriteLine("got {0} active conditions", active_conditions.length);

                for (int i = 0; i < active_conditions.length; ++i)
                {
                    /* In this case, we have only a single condition, but
                     *          if we had multiple, we would need to iterate over
                     *          them and check which one is true.  Leaving the logic
                     *          for the more complex case. */
                    if (active_conditions.get_at(i) == status_condition)
                    {
                        DDS.StatusMask triggeredmask =
                            waitset_reader.get_status_changes();

                        if ((triggeredmask &
                             (DDS.StatusMask)
                             DDS.StatusKind.DATA_AVAILABLE_STATUS) != 0)
                        {
                            /* Current conditions match our conditions to read data, so
                             * we can read data just like we would do in any other
                             * example. */
                            waitset_statuscondSeq data_seq
                                = new waitset_statuscondSeq();
                            DDS.SampleInfoSeq info_seq
                                = new DDS.SampleInfoSeq();

                            try
                            {
                                /* Access data using read(), take(), etc.  If
                                 * you fail to do this the condition will
                                 * remain true, and the WaitSet will wake up
                                 * immediately - causing high CPU usage when it
                                 * does not sleep in the loop */
                                waitset_reader.take(
                                    data_seq,
                                    info_seq,
                                    DDS.ResourceLimitsQosPolicy.LENGTH_UNLIMITED,
                                    DDS.SampleStateKind.ANY_SAMPLE_STATE,
                                    DDS.ViewStateKind.ANY_VIEW_STATE,
                                    DDS.InstanceStateKind.ANY_INSTANCE_STATE);
                            }
                            catch (DDS.Retcode_NoData e)
                            {
                                shutdown(participant);
                                throw e;
                            }
                            catch (DDS.Exception e)
                            {
                                shutdown(participant);
                                throw e;
                            }

                            /* Iterate over returned data.  Print the data
                             * values if it is not metadata.
                             */
                            System.Int32 data_length = data_seq.length;
                            for (int j = 0; i < data_length; ++i)
                            {
                                if (!info_seq.get_at(j).valid_data)
                                {
                                    Console.WriteLine("Got metadata");
                                    continue;
                                }
                                waitset_statuscondTypeSupport.print_data(data_seq.get_at(j));
                            }

                            try
                            {
                                /* Return the loaned data */
                                waitset_reader.return_loan(data_seq, info_seq);
                            }
                            catch (DDS.Exception e)
                            {
                                Console.WriteLine("return loan error {0}", e);
                            }
                        }
                    }
                }
            }
            catch (DDS.Retcode_Timeout)
            {
                Console.WriteLine("wait timed out");
                count += 2;
                continue;
            }
        }
        // --- Shutdown --- //

        /* Delete all entities */
        shutdown(participant);
    }
    static void subscribe( int domain_id, int sample_count )
    {
        // --- Create participant --- //

        /* To customize the participant QoS, use
           the configuration file USER_QOS_PROFILES.xml */
        DDS.DomainParticipant participant =
            DDS.DomainParticipantFactory.get_instance().create_participant(
                domain_id,
                DDS.DomainParticipantFactory.PARTICIPANT_QOS_DEFAULT,
                null /* listener */,
                DDS.StatusMask.STATUS_MASK_NONE);
        if (participant == null) {
            shutdown(participant);
            throw new ApplicationException("create_participant error");
        }

        // --- Create subscriber --- //

        /* To customize the subscriber QoS, use
           the configuration file USER_QOS_PROFILES.xml */
        DDS.Subscriber subscriber = participant.create_subscriber(
            DDS.DomainParticipant.SUBSCRIBER_QOS_DEFAULT,
            null /* listener */,
            DDS.StatusMask.STATUS_MASK_NONE);
        if (subscriber == null) {
            shutdown(participant);
            throw new ApplicationException("create_subscriber error");
        }

        // --- Create topic --- //

        /* Register the type before creating the topic */
        System.String type_name = waitsetsTypeSupport.get_type_name();
        try {
            waitsetsTypeSupport.register_type(
                participant, type_name);
        } catch (DDS.Exception e) {
            Console.WriteLine("register_type error {0}", e);
            shutdown(participant);
            throw e;
        }

        /* To customize the topic QoS, use
           the configuration file USER_QOS_PROFILES.xml */
        DDS.Topic topic = participant.create_topic(
            "Example waitsets",
            type_name,
            DDS.DomainParticipant.TOPIC_QOS_DEFAULT,
            null /* listener */,
            DDS.StatusMask.STATUS_MASK_NONE);
        if (topic == null) {
            shutdown(participant);
            throw new ApplicationException("create_topic error");
        }

        // --- Create reader --- //

        /* To customize the data reader QoS, use
           the configuration file USER_QOS_PROFILES.xml */
        DDS.DataReader reader = subscriber.create_datareader(
            topic,
            DDS.Subscriber.DATAREADER_QOS_DEFAULT,
            null,
            DDS.StatusMask.STATUS_MASK_ALL);
        if (reader == null) {
            shutdown(participant);
            throw new ApplicationException("create_datareader error");
        }

        /* If you want to change the DataReader's QoS programmatically rather
         * than using the XML file, you will need to add the following lines to
         * your code and comment out the create_datareader call above.
         *
         * In this case, we reduce the liveliness timeout period to trigger the
         * StatusCondition DDS.StatusKind.LIVELINESS_CHANGED_STATUS
         */
        /*
        DDS.DataReaderQos datawriter_qos = new DDS.DataReaderQos();
        try {
            subscriber.get_default_datareader_qos(datawriter_qos);
        } catch (DDS.Exception e) {
            Console.WriteLine("get_default_datareader_qos error {0}", e);
            shutdown(participant);
            throw e;
        }
        datawriter_qos.liveliness.lease_duration.sec = 2;
        datawriter_qos.liveliness.lease_duration.nanosec = 0;

        reader = subscriber.create_datareader(topic, datawriter_qos,
            null, DDS.StatusMask.STATUS_MASK_NONE);
        if (reader == null) {
            shutdown(participant);
            throw new ApplicationException("create_datawriter_qos error");
        }
        */

        /* Create read condition
         * ---------------------
         * Note that the Read Conditions are dependent on both incoming
         * data as well as sample state. Thus, this method has more
         * overhead than adding a DDS.StatusKind.DATA_AVAILABLE_STATUS
         * StatusCondition. We show it here purely for reference
         */
        DDS.ReadCondition read_condition = reader.create_readcondition(
            DDS.SampleStateKind.NOT_READ_SAMPLE_STATE,
            DDS.ViewStateKind.ANY_VIEW_STATE,
            DDS.InstanceStateKind.ANY_INSTANCE_STATE);
        if (read_condition == null) {
            shutdown(participant);
            throw new ApplicationException("create_readcondition error");
        }

        /* Get status conditions
         * ---------------------
         * Each entity may have an attached Status Condition. To modify the
         * statuses we need to get the reader's Status Conditions first.
         */

        DDS.StatusCondition status_condition = reader.get_statuscondition();
        if (status_condition.get_entity() == null) {
            shutdown(participant);
            throw new ApplicationException("get_statuscondition error");
        }

        /* Set enabled statuses
         * --------------------
         * Now that we have the Status Condition, we are going to enable the
         * statuses we are interested in:
         * DDS.StatusKind.SUBSCRIPTION_MATCHED_STATUS
         * and DDS.StatusKind.LIVELINESS_CHANGED_STATUS.
         */
        try {
            status_condition.set_enabled_statuses(
                DDS.StatusMask.STATUS_MASK_NONE |
                (DDS.StatusMask)DDS.StatusKind.SUBSCRIPTION_MATCHED_STATUS |
                (DDS.StatusMask)DDS.StatusKind.LIVELINESS_CHANGED_STATUS);
        } catch (DDS.Exception e) {
            Console.WriteLine("set_enabled_statuses error {0}", e);
            shutdown(participant);
            throw e;
        }

        /* Create and attach conditions to the WaitSet
         * -------------------------------------------
         * Finally, we create the WaitSet and attach both the Read Conditions
         * and the Status Condition to it.
         */
        DDS.WaitSet waitset = new DDS.WaitSet();

        /* Attach Read Conditions */
        try {
            waitset.attach_condition(read_condition);
        } catch (DDS.Exception e) {
            Console.WriteLine("attach_read_condition error {0}", e);
            shutdown(participant);
            throw e;
        }

        /* Attach Status Conditions */
        try {
            waitset.attach_condition(status_condition);
        } catch (DDS.Exception e) {
            Console.WriteLine("attach_status_condition error {0}", e);
            shutdown(participant);
            throw e;
        }

        /* Narrow the reader into your specific data type */
        waitsetsDataReader waitsets_reader =
            (waitsetsDataReader)reader;

        /* Main loop */
        for (int count = 0; (sample_count == 0) || (count < sample_count);
                ++count) {
            DDS.ConditionSeq active_conditions_seq = new DDS.ConditionSeq();
            DDS.Duration_t timeout;
            timeout.nanosec = (uint)500000000;
            timeout.sec = 1;

            /* wait() blocks execution of the thread until one or more attached
             * Conditions become true, or until a user-specified timeout expires
             */
            try {
                waitset.wait(active_conditions_seq, timeout);
            } catch (DDS.Retcode_Timeout) {
                Console.WriteLine("Wait timed out!! No conditions were " +
                    "triggered.");
                continue;
            } catch (DDS.Exception e) {
                Console.WriteLine("wait error {0}", e);
                break;
            }

            /* Get the number of active conditions */
            int active_conditions = active_conditions_seq.length;
            Console.WriteLine("Got {0} active conditions", active_conditions);

            for (int i = 0; i < active_conditions; i++) {
                /* Now we compare the current condition with the Status
                 * Conditions and the Read Conditions previously defined. If
                 * they match, we print the condition that was triggered.*/

                /* Compare with Status Conditions */
                if (active_conditions_seq.get_at(i) == status_condition) {
                    /* Get the status changes so we can check which status
                     * condition triggered. */
                    DDS.StatusMask triggeredmask =
                        waitsets_reader.get_status_changes();

                    /* Liveliness changed */
                    DDS.StatusMask test = triggeredmask &
                        (DDS.StatusMask)DDS.StatusKind.
                            LIVELINESS_CHANGED_STATUS;
                    if (test != DDS.StatusMask.STATUS_MASK_NONE) {
                        DDS.LivelinessChangedStatus st =
                            new DDS.LivelinessChangedStatus();
                        waitsets_reader.get_liveliness_changed_status(ref st);
                        Console.WriteLine("Liveliness changed => " +
                            "Active writers = {0}", st.alive_count);
                    }

                    /* Subscription matched */
                    test = triggeredmask &
                        (DDS.StatusMask)DDS.StatusKind.
                            SUBSCRIPTION_MATCHED_STATUS;
                    if (test != DDS.StatusMask.STATUS_MASK_NONE) {
                        DDS.SubscriptionMatchedStatus st =
                            new DDS.SubscriptionMatchedStatus();
                        waitsets_reader.get_subscription_matched_status(ref st);
                        Console.WriteLine("Subscription matched => " +
                            "Cumulative matches = {0}", st.total_count);
                    }
                }

                /* Compare with Read Conditions */
                else if (active_conditions_seq.get_at(i) == read_condition) {
                    /* Current conditions match our conditions to read data, so
                     * we can read data just like we would do in any other
                     * example. */
                    waitsetsSeq data_seq = new waitsetsSeq();
                    DDS.SampleInfoSeq info_seq = new DDS.SampleInfoSeq();

                    /* You may want to call take_w_condition() or
                     * read_w_condition() on the Data Reader. This way you will
                     * use the same status masks that were set on the Read
                     * Condition.
                     * This is just a suggestion, you can always use
                     * read() or take() like in any other example.
                     */
                    try {
                        waitsets_reader.take_w_condition(
                            data_seq, info_seq,
                            DDS.ResourceLimitsQosPolicy.LENGTH_UNLIMITED,
                            read_condition);
                    } catch (DDS.Exception e) {
                        Console.WriteLine("take error {0}", e);
                        break;
                    }

                    for (int j = 0; j < data_seq.length; ++j) {
                        if (!info_seq.get_at(j).valid_data) {
                            Console.WriteLine("Got metadata");
                            continue;
                        }
                        waitsetsTypeSupport.print_data(data_seq.get_at(i));
                    }
                    waitsets_reader.return_loan(data_seq, info_seq);
                }

            }

        }

        // --- Shutdown --- //

        /* Delete all entities */
        shutdown(participant);
    }
    static void subscribe(int domain_id, int sample_count)
    {
        // --- Create participant --- //

        /* To customize the participant QoS, use
           the configuration file USER_QOS_PROFILES.xml */
        DDS.DomainParticipant participant =
            DDS.DomainParticipantFactory.get_instance().create_participant(
                domain_id,
                DDS.DomainParticipantFactory.PARTICIPANT_QOS_DEFAULT,
                null /* listener */,
                DDS.StatusMask.STATUS_MASK_NONE);
        if (participant == null) {
            shutdown(participant);
            throw new ApplicationException("create_participant error");
        }

        // --- Create subscriber --- //

        /* To customize the subscriber QoS, use
           the configuration file USER_QOS_PROFILES.xml */
        DDS.Subscriber subscriber = participant.create_subscriber(
            DDS.DomainParticipant.SUBSCRIBER_QOS_DEFAULT,
            null /* listener */,
            DDS.StatusMask.STATUS_MASK_NONE);
        if (subscriber == null) {
            shutdown(participant);
            throw new ApplicationException("create_subscriber error");
        }

        // --- Create topic --- //

        /* Register the type before creating the topic */
        System.String type_name =
            waitset_statuscondTypeSupport.get_type_name();
        try {
            waitset_statuscondTypeSupport.register_type(
                participant, type_name);
        }
        catch(DDS.Exception e) {
            Console.WriteLine("register_type error {0}", e);
            shutdown(participant);
            throw e;
        }

        /* To customize the topic QoS, use
           the configuration file USER_QOS_PROFILES.xml */
        DDS.Topic topic = participant.create_topic(
            "Example waitset_statuscond",
            type_name,
            DDS.DomainParticipant.TOPIC_QOS_DEFAULT,
            null /* listener */,
            DDS.StatusMask.STATUS_MASK_NONE);
        if (topic == null) {
            shutdown(participant);
            throw new ApplicationException("create_topic error");
        }

        // --- Create reader --- //

        /* To customize the data reader QoS, use
           the configuration file USER_QOS_PROFILES.xml */
        DDS.DataReader reader = subscriber.create_datareader(
            topic,
            DDS.Subscriber.DATAREADER_QOS_DEFAULT,
            null,
            DDS.StatusMask.STATUS_MASK_ALL);
        if (reader == null) {
            shutdown(participant);
            throw new ApplicationException("create_datareader error");
        }

        // Get narrowed datareader
        waitset_statuscondDataReader waitset_reader =
            (waitset_statuscondDataReader)reader;

        /* Get status conditions
         * ---------------------
         * Each entity may have an attached Status Condition. To modify the
         * statuses we need to get the reader's Status Conditions first.
         */
        DDS.StatusCondition status_condition = reader.get_statuscondition();

        /* Set enabled statuses
         * --------------------
         * Now that we have the Status Condition, we are going to enable the
         * status we are interested in: knowing that data is available
         */
        try
        {
            status_condition.set_enabled_statuses(
                (DDS.StatusMask)DDS.StatusKind.DATA_AVAILABLE_STATUS);
        }
        catch (DDS.Exception e)
        {
            shutdown(participant);
            throw new ApplicationException("set_enabled_statuses error {0}",
                e);
        }

        /* Create and attach conditions to the WaitSet
         * -------------------------------------------
         * Finally, we create the WaitSet and attach both the Read Conditions
         * and the Status Condition to it.
         */
        DDS.WaitSet waitset = new DDS.WaitSet();

        /* Attach Status Conditions */
        try
        {
            waitset.attach_condition(status_condition);
        }
        catch (DDS.Exception e)
        {
            shutdown(participant);
            throw new ApplicationException("set_enabled_statuses error {0}",
                e);

        }
        // --- Wait for data --- //
        int count = 0;
        DDS.Duration_t timeout;
        timeout.nanosec = (uint)500000000;
        timeout.sec = 1;

        /* Main loop */
        while (sample_count == 0 || count < sample_count)
        {
            DDS.ConditionSeq active_conditions = new DDS.ConditionSeq();

            // The triggered condition(s) will be placed in active_conditions
            try
            {
                waitset.wait(active_conditions, timeout);
                Console.WriteLine("got {0} active conditions", active_conditions.length);

                for (int i = 0; i < active_conditions.length; ++i)
                {
                    /* In this case, we have only a single condition, but
                    if we had multiple, we would need to iterate over
                    them and check which one is true.  Leaving the logic
                    for the more complex case. */
                    if (active_conditions.get_at(i) == status_condition)
                    {
                        DDS.StatusMask triggeredmask =
                            waitset_reader.get_status_changes();

                        if ((triggeredmask &
                            (DDS.StatusMask)
                            DDS.StatusKind.DATA_AVAILABLE_STATUS) != 0)
                        {
                            /* Current conditions match our conditions to read data, so
                             * we can read data just like we would do in any other
                             * example. */
                            waitset_statuscondSeq data_seq
                                = new waitset_statuscondSeq();
                            DDS.SampleInfoSeq info_seq
                                = new DDS.SampleInfoSeq();

                            try
                            {
                                /* Access data using read(), take(), etc.  If
                                 * you fail to do this the condition will
                                 * remain true, and the WaitSet will wake up
                                 * immediately - causing high CPU usage when it
                                 * does not sleep in the loop */
                                waitset_reader.take(
                                    data_seq,
                                    info_seq,
                                    DDS.ResourceLimitsQosPolicy.LENGTH_UNLIMITED,
                                    DDS.SampleStateKind.ANY_SAMPLE_STATE,
                                    DDS.ViewStateKind.ANY_VIEW_STATE,
                                    DDS.InstanceStateKind.ANY_INSTANCE_STATE);

                            }
                            catch (DDS.Retcode_NoData e)
                            {
                                shutdown(participant);
                                throw e;
                            }
                            catch (DDS.Exception e)
                            {
                                shutdown(participant);
                                throw e;
                            }

                            /* Iterate over returned data.  Print the data
                             * values if it is not metadata.
                             */
                            System.Int32 data_length = data_seq.length;
                            for (int j = 0; i < data_length; ++i)
                            {
                                if (!info_seq.get_at(j).valid_data)
                                {
                                    Console.WriteLine("Got metadata");
                                    continue;
                                }
                                waitset_statuscondTypeSupport.print_data(data_seq.get_at(j));
                            }

                            try
                            {
                                /* Return the loaned data */
                                waitset_reader.return_loan(data_seq, info_seq);
                            }
                            catch (DDS.Exception e)
                            {
                                Console.WriteLine("return loan error {0}", e);
                            }

                        }
                    }
                }
            }
            catch (DDS.Retcode_Timeout)
            {
                Console.WriteLine("wait timed out");
                count += 2;
                continue;
            }
        }
        // --- Shutdown --- //

        /* Delete all entities */
        shutdown(participant);
    }
Exemplo n.º 5
0
    static void subscribe(int domain_id, int sample_count)
    {
        /* Auxiliary variables */
        String odd_string  = "'ODD'";
        String even_string = "'EVEN'";

        // --- Create participant --- //

        /* To customize the participant QoS, use
         * the configuration file USER_QOS_PROFILES.xml */
        DDS.DomainParticipant participant =
            DDS.DomainParticipantFactory.get_instance().create_participant(
                domain_id,
                DDS.DomainParticipantFactory.PARTICIPANT_QOS_DEFAULT,
                null /* listener */,
                DDS.StatusMask.STATUS_MASK_NONE);
        if (participant == null)
        {
            shutdown(participant);
            throw new ApplicationException("create_participant error");
        }

        // --- Create subscriber --- //

        /* To customize the subscriber QoS, use
         * the configuration file USER_QOS_PROFILES.xml */
        DDS.Subscriber subscriber = participant.create_subscriber(
            DDS.DomainParticipant.SUBSCRIBER_QOS_DEFAULT,
            null /* listener */,
            DDS.StatusMask.STATUS_MASK_NONE);
        if (subscriber == null)
        {
            shutdown(participant);
            throw new ApplicationException("create_subscriber error");
        }

        // --- Create topic --- //

        /* Register the type before creating the topic */
        System.String type_name = waitset_query_condTypeSupport.get_type_name();
        try {
            waitset_query_condTypeSupport.register_type(
                participant, type_name);
        }
        catch (DDS.Exception e) {
            Console.WriteLine("register_type error {0}", e);
            shutdown(participant);
            throw e;
        }

        /* To customize the topic QoS, use
         * the configuration file USER_QOS_PROFILES.xml */
        DDS.Topic topic = participant.create_topic(
            "Example waitset_query_cond",
            type_name,
            DDS.DomainParticipant.TOPIC_QOS_DEFAULT,
            null /* listener */,
            DDS.StatusMask.STATUS_MASK_NONE);
        if (topic == null)
        {
            shutdown(participant);
            throw new ApplicationException("create_topic error");
        }

        // --- Create reader --- //

        /* To customize the data reader QoS, use
         * the configuration file USER_QOS_PROFILES.xml */
        DDS.DataReader reader = subscriber.create_datareader(
            topic,
            DDS.Subscriber.DATAREADER_QOS_DEFAULT,
            null,
            DDS.StatusMask.STATUS_MASK_NONE);
        if (reader == null)
        {
            shutdown(participant);
            throw new ApplicationException("create_datareader error");
        }
        waitset_query_condDataReader waitset_query_cond_reader =
            (waitset_query_condDataReader)reader;

        /* Create query condition */
        DDS.StringSeq query_parameters = new DDS.StringSeq(1);
        query_parameters.ensure_length(1, 1);

        /* The initial value of the parameters is EVEN string */
        query_parameters.set_at(0, even_string);

        String query_expression = "name MATCH %0";

        DDS.QueryCondition query_condition =
            waitset_query_cond_reader.create_querycondition(
                DDS.SampleStateKind.NOT_READ_SAMPLE_STATE,
                DDS.ViewStateKind.ANY_VIEW_STATE,
                DDS.InstanceStateKind.ANY_INSTANCE_STATE,
                query_expression,
                query_parameters);
        if (query_condition == null)
        {
            shutdown(participant);
            throw new ApplicationException("create_querycondition error");
        }

        DDS.WaitSet waitset = new DDS.WaitSet();
        if (waitset == null)
        {
            shutdown(participant);
            throw new ApplicationException("create waitset error");
        }

        /* Attach Query Conditions */
        try {
            waitset.attach_condition((DDS.Condition)query_condition);
        } catch (DDS.Exception e) {
            Console.WriteLine("attach_condition error {0}", e);
            shutdown(participant);
            throw e;
        }

        DDS.Duration_t wait_timeout;
        wait_timeout.nanosec = (uint)500000000;
        wait_timeout.sec     = 1;

        Console.WriteLine("\n>>>Timeout: {0} sec",
                          wait_timeout.sec, wait_timeout.nanosec);
        Console.WriteLine(">>> Query conditions: name MATCH %0");
        Console.WriteLine("\t%0 = {0}", query_parameters.get_at(0));
        Console.WriteLine("---------------------------------\n");


        // --- Wait for data --- //

        /* Main loop */

        for (int count = 0;
             (sample_count == 0) || (count < sample_count);
             ++count)
        {
            DDS.ConditionSeq active_conditions_seq = new DDS.ConditionSeq();

            /* We set a new parameter in the Query Condition after 7 secs */
            if (count == 7)
            {
                query_parameters.set_at(0, odd_string);
                Console.WriteLine("CHANGING THE QUERY CONDITION");
                Console.WriteLine("\n>>> Query conditions: name MATCH %0");
                Console.WriteLine("\t%0 = {0}", query_parameters.get_at(0));
                Console.WriteLine(">>> We keep one sample in the history");
                Console.WriteLine("-------------------------------------\n");
                query_condition.set_query_parameters(query_parameters);
            }

            /* wait() blocks execution of the thread until one or more attached
             * Conditions become true, or until a user-specified timeout
             * expires.
             */
            try {
                waitset.wait(active_conditions_seq, wait_timeout);
            } catch (DDS.Retcode_Timeout) {
                Console.WriteLine("Wait timed out!! No conditions were " +
                                  "triggered.");
                continue;
            } catch (DDS.Exception e) {
                Console.WriteLine("wait error {0}", e);
                break;
            }

            waitset_query_condSeq data_seq = new waitset_query_condSeq();
            DDS.SampleInfoSeq     info_seq = new DDS.SampleInfoSeq();

            bool follow = true;
            while (follow)
            {
                try {
                    waitset_query_cond_reader.take_w_condition(
                        data_seq, info_seq,
                        DDS.ResourceLimitsQosPolicy.LENGTH_UNLIMITED,
                        query_condition);

                    for (int i = 0; i < data_seq.length; ++i)
                    {
                        if (!info_seq.get_at(i).valid_data)
                        {
                            Console.WriteLine("Got metadata");
                            continue;
                        }
                        waitset_query_condTypeSupport.print_data(
                            data_seq.get_at(i));
                    }
                } catch (DDS.Retcode_NoData) {
                    /* When there isn't data, the subscriber stop to
                     * take samples
                     */
                    follow = false;
                } finally {
                    waitset_query_cond_reader.return_loan(data_seq, info_seq);
                }
            }
        }

        // --- Shutdown --- //

        /* Delete all entities */
        shutdown(participant);
    }
    static void subscribe(int domain_id, int sample_count)
    {
        /* Auxiliary variables */
        String odd_string = "'ODD'";
        String even_string = "'EVEN'";

        // --- Create participant --- //

        /* To customize the participant QoS, use
           the configuration file USER_QOS_PROFILES.xml */
        DDS.DomainParticipant participant =
            DDS.DomainParticipantFactory.get_instance().create_participant(
                domain_id,
                DDS.DomainParticipantFactory.PARTICIPANT_QOS_DEFAULT,
                null /* listener */,
                DDS.StatusMask.STATUS_MASK_NONE);
        if (participant == null) {
            shutdown(participant);
            throw new ApplicationException("create_participant error");
        }

        // --- Create subscriber --- //

        /* To customize the subscriber QoS, use
           the configuration file USER_QOS_PROFILES.xml */
        DDS.Subscriber subscriber = participant.create_subscriber(
            DDS.DomainParticipant.SUBSCRIBER_QOS_DEFAULT,
            null /* listener */,
            DDS.StatusMask.STATUS_MASK_NONE);
        if (subscriber == null) {
            shutdown(participant);
            throw new ApplicationException("create_subscriber error");
        }

        // --- Create topic --- //

        /* Register the type before creating the topic */
        System.String type_name = waitset_query_condTypeSupport.get_type_name();
        try {
            waitset_query_condTypeSupport.register_type(
                participant, type_name);
        }
        catch(DDS.Exception e) {
            Console.WriteLine("register_type error {0}", e);
            shutdown(participant);
            throw e;
        }

        /* To customize the topic QoS, use
           the configuration file USER_QOS_PROFILES.xml */
        DDS.Topic topic = participant.create_topic(
            "Example waitset_query_cond",
            type_name,
            DDS.DomainParticipant.TOPIC_QOS_DEFAULT,
            null /* listener */,
            DDS.StatusMask.STATUS_MASK_NONE);
        if (topic == null) {
            shutdown(participant);
            throw new ApplicationException("create_topic error");
        }

        // --- Create reader --- //

        /* To customize the data reader QoS, use
           the configuration file USER_QOS_PROFILES.xml */
        DDS.DataReader reader = subscriber.create_datareader(
            topic,
            DDS.Subscriber.DATAREADER_QOS_DEFAULT,
            null,
            DDS.StatusMask.STATUS_MASK_NONE);
        if (reader == null) {
            shutdown(participant);
            throw new ApplicationException("create_datareader error");
        }
        waitset_query_condDataReader waitset_query_cond_reader =
            (waitset_query_condDataReader)reader;

        /* Create query condition */
        DDS.StringSeq query_parameters = new DDS.StringSeq(1);
        query_parameters.ensure_length(1, 1);

        /* The initial value of the parameters is EVEN string */
        query_parameters.set_at(0, even_string);

        String query_expression = "name MATCH %0";

        DDS.QueryCondition query_condition =
            waitset_query_cond_reader.create_querycondition(
                DDS.SampleStateKind.NOT_READ_SAMPLE_STATE,
                DDS.ViewStateKind.ANY_VIEW_STATE,
                DDS.InstanceStateKind.ANY_INSTANCE_STATE,
                query_expression,
                query_parameters);
        if (query_condition == null) {
            shutdown(participant);
            throw new ApplicationException("create_querycondition error");
        }

        DDS.WaitSet waitset = new DDS.WaitSet();
        if (waitset == null) {
            shutdown(participant);
            throw new ApplicationException("create waitset error");
        }

        /* Attach Query Conditions */
        try {
            waitset.attach_condition((DDS.Condition)query_condition);
        } catch (DDS.Exception e) {
            Console.WriteLine("attach_condition error {0}", e);
            shutdown(participant);
            throw e;
        }

        DDS.Duration_t wait_timeout;
        wait_timeout.nanosec = (uint)500000000;
        wait_timeout.sec = 1;

        Console.WriteLine("\n>>>Timeout: {0} sec",
            wait_timeout.sec, wait_timeout.nanosec);
        Console.WriteLine(">>> Query conditions: name MATCH %0");
        Console.WriteLine("\t%0 = {0}", query_parameters.get_at(0));
        Console.WriteLine("---------------------------------\n");

        // --- Wait for data --- //

        /* Main loop */

        for (int count=0;
             (sample_count == 0) || (count < sample_count);
             ++count) {

            DDS.ConditionSeq active_conditions_seq = new DDS.ConditionSeq();

            /* We set a new parameter in the Query Condition after 7 secs */
            if (count == 7) {
                query_parameters.set_at(0,odd_string);
                Console.WriteLine("CHANGING THE QUERY CONDITION");
                Console.WriteLine("\n>>> Query conditions: name MATCH %0");
                Console.WriteLine("\t%0 = {0}", query_parameters.get_at(0));
                Console.WriteLine(">>> We keep one sample in the history");
                Console.WriteLine("-------------------------------------\n");
                query_condition.set_query_parameters(query_parameters);
            }

            /* wait() blocks execution of the thread until one or more attached
             * Conditions become true, or until a user-specified timeout
             * expires.
             */
            try {
                waitset.wait(active_conditions_seq, wait_timeout);
            } catch (DDS.Retcode_Timeout) {
                Console.WriteLine("Wait timed out!! No conditions were " +
                    "triggered.");
                continue;
            } catch (DDS.Exception e) {
                Console.WriteLine("wait error {0}", e);
                break;
            }

            waitset_query_condSeq data_seq = new waitset_query_condSeq();
            DDS.SampleInfoSeq info_seq = new DDS.SampleInfoSeq();

            bool follow = true;
            while (follow) {
                try {
                    waitset_query_cond_reader.take_w_condition(
                        data_seq, info_seq,
                        DDS.ResourceLimitsQosPolicy.LENGTH_UNLIMITED,
                        query_condition);

                    for (int i = 0; i < data_seq.length; ++i) {
                        if (!info_seq.get_at(i).valid_data) {
                            Console.WriteLine("Got metadata");
                            continue;
                        }
                        waitset_query_condTypeSupport.print_data(
                            data_seq.get_at(i));
                    }
                } catch (DDS.Retcode_NoData) {
                    /* When there isn't data, the subscriber stop to
                     * take samples
                     */
                    follow = false;
                } finally {
                    waitset_query_cond_reader.return_loan(data_seq, info_seq);
                }
            }
        }

        // --- Shutdown --- //

        /* Delete all entities */
        shutdown(participant);
    }