private static void Subscribe(int domainId, int sampleCount)
        {
            // --- Create participant --- //
            DDS.DomainParticipant participant =
                DDS.DomainParticipantFactory.get_instance().create_participant(
                    domainId,
                    DDS.DomainParticipantFactory.PARTICIPANT_QOS_DEFAULT,
                    null /* listener */,
                    DDS.StatusMask.STATUS_MASK_NONE);
            if (participant == null) {
                Shutdown(participant);
                throw new Exception("create_participant error");
            }

            // --- Create subscriber --- //
            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.
            string typeName = FlightTypeSupport.get_type_name();
            try {
                FlightTypeSupport.register_type(participant, typeName);
            }
            catch(DDS.Exception e) {
                Console.WriteLine("register_type error {0}", e);
                Shutdown(participant);
                throw e;
            }

            DDS.Topic topic = participant.create_topic(
                "Example Flight",
                typeName,
                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 --- //
            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");
            }

            FlightDataReader flightReader = (FlightDataReader)reader;

            // Query for company named 'CompanyA' and for flights in cruise
            // (about 30,000ft). The company parameter will be changed in
            // run-time. NOTE: There must be single-quotes in the query
            // parameters around-any strings! The single-quote do NOT go in the
            // query condition itself.
            DDS.StringSeq queryParameters = new DDS.StringSeq();
            queryParameters.ensure_length(2, 2);
            queryParameters.set_at(0, "'CompanyA'");
            queryParameters.set_at(1, "30000");
            Console.WriteLine(
                "Setting parameters to company: {0} and altitude >= {1}\n",
                queryParameters.get_at(0), queryParameters.get_at(1));

            // Create the query condition with an expession to MATCH the id
            // field in the structure and a numeric comparison.
            DDS.QueryCondition queryCondition =
                reader.create_querycondition(
                    DDS.SampleStateKind.ANY_SAMPLE_STATE,
                    DDS.ViewStateKind.ANY_VIEW_STATE,
                    DDS.InstanceStateKind.ALIVE_INSTANCE_STATE,
                    "company MATCH %0 AND altitude >= %1",
                    queryParameters);

            // --- Wait for data --- //
            const int receivePeriod = 1000; // Milliseconds
            bool update = false;
            for (int count = 0;
                 (sampleCount == 0) || (count < sampleCount);
                 count++)
            {
                // Poll for new samples every second.
                System.Threading.Thread.Sleep(receivePeriod);

                // Change the filter parameter after 5 seconds.
                if ((count + 1) % 10 == 5) {
                    queryParameters.set_at(0, "'CompanyB'");
                    update = true;
                } else if ((count + 1) % 10 == 0) {
                    queryParameters.set_at(0, "'CompanyA'");
                    update = true;
                }

                // Set new parameters.
                if (update) {
                    Console.WriteLine("Changing parameter to {0}",
                        queryParameters.get_at(0));
                    queryCondition.set_query_parameters(queryParameters);
                    update = false;
                }

                // Iterate through the samples using read_w_condition.
                FlightSeq dataSeq = new FlightSeq();
                DDS.SampleInfoSeq infoSeq = new DDS.SampleInfoSeq();
                try {
                    flightReader.read_w_condition(
                        dataSeq,
                        infoSeq,
                        DDS.ResourceLimitsQosPolicy.LENGTH_UNLIMITED,
                        queryCondition);
                } catch (DDS.Retcode_NoData) {
                    continue;
                } catch (DDS.Exception e) {
                    Shutdown(participant);
                    throw e;
                }

                for (int i = 0; i < dataSeq.length; i++) {
                    DDS.SampleInfo info = (DDS.SampleInfo)infoSeq.get_at(i);
                    if (info.valid_data) {
                        Flight flight_info = (Flight)dataSeq.get_at(i);
                        Console.WriteLine(
                            "\t[trackId: {0}, company: {1}, altitude: {2}]\n",
                            flight_info.trackId,
                            flight_info.company,
                            flight_info.altitude);
                    }
                }

                try {
                    flightReader.return_loan(dataSeq, infoSeq);
                } catch (DDS.Exception e) {
                    Console.WriteLine("return loan error {0}", e);
                }
            }

            // Delete all entities
            Shutdown(participant);
        }
 public coherentListener()
 {
     data_seq = new coherentSeq();
     info_seq = new DDS.SampleInfoSeq();
 }
 public batch_dataListener()
 {
     data_seq = new batch_dataSeq();
     info_seq = new DDS.SampleInfoSeq();
 }
 public sequencesListener()
 {
     data_seq = new sequencesSeq();
     info_seq = new DDS.SampleInfoSeq();
 }
 public keysListener()
 {
     data_seq = new keysSeq();
     info_seq = new DDS.SampleInfoSeq();
 }
 public profilesListener(string name)
 {
     data_seq = new profilesSeq();
     info_seq = new DDS.SampleInfoSeq();
     _listener_name = name;
 }
 public cfcListener()
 {
     data_seq = new cfcSeq();
     info_seq = new DDS.SampleInfoSeq();
     timer.Elapsed += new ElapsedEventHandler(OnTimer);
     timer.Interval = 10; // every 10 ms
     timer.Enabled = true;
     timer.Start();
 }
    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 = pollTypeSupport.get_type_name();
        try {
            pollTypeSupport.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 poll",
            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");
        }

        /* If you want to change datareader_qos.history.kind 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. */

        /*DDS.DataReaderQos datareader_qos = new DDS.DataReaderQos();

        try
        {
            subscriber.get_default_datareader_qos(datareader_qos);
        }
        catch (DDS.Exception e)
        {
            Console.WriteLine("get_default_datareader_qos error {0}", e);
            shutdown(participant);
            throw e;
        }

        datareader_qos.history.kind =
            DDS.HistoryQosPolicyKind.KEEP_ALL_HISTORY_QOS;

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

        pollDataReader poll_reader =
            (pollDataReader)reader;

        // --- Wait for data --- //
        DDS.SampleInfoSeq info_seq = new DDS.SampleInfoSeq();
        pollSeq data_seq = new pollSeq();

        /* Main loop */
        const System.Int32 receive_period = 5000; // milliseconds
        for (int count=0;
             (sample_count == 0) || (count < sample_count);
             ++count) {
            Console.WriteLine(
                "poll subscriber sleeping for {0} sec...",
                receive_period / 1000);

            System.Threading.Thread.Sleep(receive_period);

            // --- Polling for data --- ///

            /* Check for new data calling the DataReader's take() method */
            try
            {
                poll_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)
            {
                // Not an error
                return;
            }
            catch (DDS.Exception e)
            {
                Console.WriteLine("take error {0}", e);
                return;
            }

            int len = 0;
            double sum = 0;

            /* Iterate through the samples read using the take() method, getting
             * the number of samples got and, adding the value of x on each of
             * them to calculate the average afterwards. */
            for (int i = 0; i < data_seq.length; ++i)
            {
                if (!info_seq.get_at(i).valid_data)
                    continue;
                len++;
                sum += data_seq.get_at(i).x;
            }

            if (len > 0)
            {
                Console.WriteLine("Got {0} samples.  Avg = {1}", len, sum / len);
            }

            try
            {
                poll_reader.return_loan(data_seq, info_seq);
            }
            catch (DDS.Exception e)
            {
                Console.WriteLine("return loan error {0}", e);
            }

        }

        // --- Shutdown --- //

        /* Delete all entities */
        shutdown(participant);
    }
 public numbersListener()
 {
     data_seq = new numbersSeq();
     info_seq = new DDS.SampleInfoSeq();
 }
 public cftListener()
 {
     data_seq = new cftSeq();
     info_seq = new DDS.SampleInfoSeq();
 }
 public partitionsListener()
 {
     data_seq = new partitionsSeq();
     info_seq = new DDS.SampleInfoSeq();
 }
 public profilesListener()
 {
     data_seq = new profilesSeq();
     info_seq = new DDS.SampleInfoSeq();
 }
 public BuiltinPublicationListener()
 {
     data_seq = new DDS.PublicationBuiltinTopicDataSeq();
     info_seq = new DDS.SampleInfoSeq();
 }
 public ReaderListener()
 {
     data_seq = new listenersSeq();
     info_seq = new DDS.SampleInfoSeq();
 }
    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);
    }
    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 = queryconditionTypeSupport.get_type_name();
        try {
            queryconditionTypeSupport.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 querycondition",
            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 datareader_qos.history 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. */

        /*DDS.DataReaderQos reader_qos = new DDS.DataReaderQos();
        subscriber.get_default_datareader_qos(reader_qos);

        reader_qos.history.kind = DDS.HistoryQosPolicyKind.KEEP_LAST_HISTORY_QOS;
        reader_qos.history.depth = 6;

        DDS.DataReader reader = subscriber.create_datareader(
            topic,
            reader_qos,
            reader_listener,
            DDS.StatusMask.STATUS_MASK_ALL);
        if (reader == null)
        {
            shutdown(participant);
            reader_listener = null;
            throw new ApplicationException("create_datareader error");
        } */

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

        /* NOTE: There must be single-quotes in the query parameters around
         * any strings!  The single-quotes do NOT go in the query condition
         * itself.
         */
        DDS.QueryCondition query_for_guid2;

        DDS.StringSeq query_parameters = new DDS.StringSeq();
        query_parameters.ensure_length(1, 1);
        query_parameters.set_at(0, "'GUID2'");

        queryconditionDataReader querycondition_reader =
                (queryconditionDataReader)reader;
        query_for_guid2 = querycondition_reader.create_querycondition(
            DDS.SampleStateKind.ANY_SAMPLE_STATE,
            DDS.ViewStateKind.ANY_VIEW_STATE,
            DDS.InstanceStateKind.ALIVE_INSTANCE_STATE,
            "id MATCH %0",
            query_parameters);

        /* Main loop */
        const System.Int32 receive_period = 4000; // milliseconds
        for (int count=0;
             (sample_count == 0) || (count < sample_count);
             ++count) {

            System.Threading.Thread.Sleep(receive_period);

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

            try
            {
                querycondition_reader.read_w_condition(
                    data_seq,
                    info_seq,
                    DDS.ResourceLimitsQosPolicy.LENGTH_UNLIMITED,
                    query_for_guid2);
            }
            catch (DDS.Retcode_NoData e)
            {
                continue;
            }
            catch (DDS.Exception e)
            {
                shutdown(participant);
                throw e;
            }

            int len = 0;
            double sum = 0;

            /* Iterate through the samples read using the read_w_condition() method,
             * accessing only the samples of GUID2.  Then, show the number of samples
             * received and, adding the value of x on each of them to calculate the
             * average afterwards. */
            for (int i = 0; i < data_seq.length; ++i)
            {
                if (!info_seq.get_at(i).valid_data)
                    continue;
                len++;
                sum += data_seq.get_at(i).value;
                Console.WriteLine("Guid = {0}\n", data_seq.get_at(i).id);
            }

            if (len > 0)
            {
                Console.WriteLine("Got {0} samples.  Avg = {1}\n", len, sum / len);

            }
            try
            {
                querycondition_reader.return_loan(data_seq, info_seq);
            }
            catch (DDS.Exception e)
            {
                Console.WriteLine("return loan error {0}", e);
            }

        }

        // --- Shutdown --- //

        /* Delete all entities */
        shutdown(participant);
    }
 public market_dataListener()
 {
     data_seq = new market_dataSeq();
     info_seq = new DDS.SampleInfoSeq();
 }
 public deadline_contentfilterListener()
 {
     data_seq = new deadline_contentfilterSeq();
     info_seq = new DDS.SampleInfoSeq();
 }
    /* Start changes for Ordered_Presentation*/
    /* No listener is needed; we poll readers in this function */
    private static void poll_data(DDS.DataReader[] reader, int numreaders)
    {
        DDS.SampleInfoSeq info_seq = new DDS.SampleInfoSeq();
        orderedSeq data_seq = new orderedSeq();

        for (int r = 0; r < numreaders; ++r) {
            try {
                ((orderedDataReader)(reader[r])).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) {
                // Not an error
                return;
            } catch (DDS.Exception e) {
                // Is an error
                Console.WriteLine("take error {0}", e);
                return;
            }

            System.Int32 data_length = data_seq.length;
            for (int i = 0; i < data_length; ++i) {
                if (!info_seq.get_at(i).valid_data) {
                    continue;
                }
                // Make things a bit easier to read.
                int ident = r;
                while (ident-- != 0) {
                    Console.Write("\t");
                }
                Console.WriteLine("Reader {0}: Instance{1}->value = {2}", r,
                    data_seq.get_at(i).id, data_seq.get_at(i).value);
            }

            try {
                ((orderedDataReader)(reader[r])).return_loan(data_seq,
                        info_seq);
            } catch (DDS.Exception e) {
                Console.WriteLine("return loan error {0}", e);
            }

            info_seq.ensure_length(0, 0);
            data_seq.ensure_length(0, 0);
        }
    }
        public keysListener()
        {
            data_seq = new keysSeq();
            info_seq = new DDS.SampleInfoSeq();

            /* Initialize instance states */
            states = new Instance_State[] {
                Instance_State.inactive,
                Instance_State.inactive,
                Instance_State.inactive};
        }
 public hello_worldListener()
 {
     data_seq = new hello_worldSeq();
     info_seq = new DDS.SampleInfoSeq();
 }
 public ShapeTypeListener()
 {
     data_seq = new DDS.DynamicDataSeq();
     info_seq = new DDS.SampleInfoSeq();
 }
 public msgListener()
 {
     data_seq = new msgSeq();
     info_seq = new DDS.SampleInfoSeq();
 }
 public tbfListener()
 {
     data_seq = new tbfSeq();
     info_seq = new DDS.SampleInfoSeq();
 }
    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);
    }