def subscriber_main(domain_id, sample_count):
participant = dds.DomainParticipant(domain_id)
wsqc_type = dds.QosProvider("waitset_cond.xml").type("wssc_lib", "Foo")
topic = dds.DynamicData.Topic(participant, "Example Foo", wsqc_type)
reader_qos = dds.QosProvider.default.datareader_qos
reader = dds.DynamicData.DataReader(dds.Subscriber(participant), topic, reader_qos)
# Get the StatusCondition associated with the reader and set the mask to get liveliness updates
status_condition = dds.StatusCondition(reader)
status_condition.enabled_statuses = dds.StatusMask.LIVELINESS_CHANGED
# Create a ReadCondition to get any data
read_condition = dds.ReadCondition(reader, dds.DataState.any_data)
# Create WaitSet and attach conditions
waitset = dds.WaitSet()
waitset += status_condition
waitset += read_condition
count = Counter()
while (sample_count == 0) or (count.value < sample_count):
active = waitset.wait(4.0)
# Check conditions after wait to see if anything triggered
if status_condition in active:
status_handler(reader)
if read_condition in active:
rc_handler(reader, count)
def run_example(domain_id, sample_count):
# A DomainParticipant allows an application to begin communicating in
# a DDS domain. Typically there is one DomainParticipant per application.
# Create a DomainParticipant with default Qos
with dds.DomainParticipant(domain_id) as participant:
# A QosProvider is used here to get the type from the file
# HelloWorld.xml
provider = dds.QosProvider(FILE)
provider_type = provider.type("HelloWorld")
# A Topic has a name and a datatype. Create a Topic named
# "HelloWorld Topic" with type HelloWorld
topic = dds.DynamicData.Topic(
participant, "Example HelloWorld", provider_type
)
# A Subscriber allows an application to create one or more DataReaders
# Subscriber QoS is configured in USER_QOS_PROFILES.xml
subscriber = dds.Subscriber(participant)
# This DataReader will read data of type HelloWorld on Topic
# "HelloWorld Topic". DataReader QoS is configured in
# USER_QOS_PROFILES.xml
reader = dds.DynamicData.DataReader(subscriber, topic)
# Obtain the DataReader's Status Condition
status_condition = dds.StatusCondition(reader)
# Enable the 'data available' status.
status_condition.enabled_statuses = dds.StatusMask.data_available()
# Initialize samples_read to zero
samples_read = 0
# Associate a handler with the status condition. This will run when the
# condition is triggered, in the context of the dispatch call (see below)
def handler(_): # condition argument is not used
nonlocal samples_read
nonlocal reader
samples_read += process_data(reader)
status_condition.set_handler(handler)
# Create a WaitSet and attach the StatusCondition
waitset = dds.WaitSet()
waitset += status_condition
# Catch control c interrupt
try:
while samples_read < sample_count:
# Dispatch will call the handlers associated to the WaitSet conditions
# when they activate
print(f"Hello World subscriber sleeping for 4 seconds...")
waitset.dispatch(dds.Duration(4)) # Wait up to 4s each time
except KeyboardInterrupt:
pass
def subscriber_main(domain_id, sample_count):
participant = dds.DomainParticipant(domain_id)
ccf_type = dds.QosProvider("ccf.xml").type("ccf_lib", "Foo")
topic = dds.DynamicData.Topic(participant, "Example ccf", ccf_type)
# Register the custom filter with the Participant
participant.register_contentfilter(ccf.CustomFilterType(), "CustomFilter")
# Set a filter expression and the filter name, then create the CFT
custom_filter = dds.Filter("%0 %1 x", ["2", "divides"])
custom_filter.name = "CustomFilter"
topic = dds.DynamicData.ContentFilteredTopic(
topic, "ContentFilteredTopic", custom_filter
)
print("Filter: 2 divides x")
reader = dds.DynamicData.DataReader(dds.Subscriber(participant), topic)
reader.bind_listener(CcfListener(), dds.StatusMask.DATA_AVAILABLE)
count = 0
while (sample_count == 0) or (count < sample_count):
time.sleep(1)
if count == 10:
# Update the filter parameters after 10 seconds
print(
textwrap.dedent(
"""
==========================
Changing Filter Parameters
Filter: 15 greater-than x
=========================="""
)
)
topic.filter_parameters = ["15", "greater-than"]
elif count == 20:
# Update the filter again after 20 seconds
print(
textwrap.dedent(
"""
==========================
Changing Filter Parameters
Filter: 3 divides x
=========================="""
)
)
topic.filter_parameters = ["3", "divides"]
count += 1
def run_example(domain_id, sample_count, sensor_id):
# A DomainParticipant allows an application to begin communicating in
# a DDS domain. Typically there is one DomainParticipant per application.
# Create a DomainParticipant with default Qos
participant = dds.DomainParticipant(domain_id)
# A Topic has a name and a datatype. Create a Topic named
# "ChocolateTemperature" with type Temperature
temperature_type = dds.QosProvider(FILE).type("Temperature")
topic = dds.DynamicData.Topic(participant, "ChocolateTemperature",
temperature_type)
# A Subscriber allows an application to create one or more DataReaders
# Subscriber QoS is configured in USER_QOS_PROFILES.xml
subscriber = dds.Subscriber(participant)
# This DataReader reads data of type Temperature on Topic
# "ChocolateTemperature". DataReader QoS is configured in
# USER_QOS_PROFILES.xml
reader = dds.DynamicData.DataReader(subscriber, topic)
# Obtain the DataReader's Status Condition
status_condition = dds.StatusCondition(reader)
# Enable the 'data available' status.
status_condition.enabled_statuses = dds.StatusMask.data_available()
# Associate a handler with the status condition. This will run when the
# condition is triggered, in the context of the dispatch call (see below)
samples_read = 0
def handler(_):
nonlocal samples_read
nonlocal reader
samples_read += process_data(reader)
status_condition.set_handler(handler)
# Create a WaitSet and attach the StatusCondition
waitset = dds.WaitSet()
waitset += status_condition
try:
# Dispatch will call the handlers associated to the WaitSet conditions
# when they activate
while sample_count is None or samples_read < sample_count:
print("ChocolateTemperature subcriber sleeping for 4 sec...")
waitset.dispatch(dds.Duration(4)) # Wait up to 4s each time
except KeyboardInterrupt:
pass
def subscriber_main(domain_id, sample_count):
participant = dds.DomainParticipant(domain_id)
subscriber_qos = dds.QosProvider.default.subscriber_qos
subscriber = dds.Subscriber(participant, subscriber_qos)
coherent_type = dds.QosProvider("coherent.xml").type("coherent_lib", "coherent")
topic = dds.DynamicData.Topic(participant, "Example coherent", coherent_type)
datareader_qos = dds.QosProvider.default.datareader_qos
reader = dds.DynamicData.DataReader(subscriber, topic, datareader_qos)
reader.bind_listener(CoherentListener(), dds.StatusMask.data_available())
count = 0
while (sample_count == 0) or (count < sample_count):
time.sleep(1)
def test_close_datareader_contained_entity(retain):
p = utils.create_participant()
topic = dds.StringTopicType.Topic(p, "test_topic")
sub = dds.Subscriber(p)
reader = dds.StringTopicType.DataReader(sub, topic)
topic_query = dds.TopicQuery(
dds.AnyDataReader(reader),
dds.TopicQuerySelection(dds.Filter("foo = 1 or foo = 3")),
)
if retain:
topic_query.retain()
reader.close()
assert topic_query.closed
assert reader.closed
def test_close_subscriber_contained_entities(implicit_sub):
p = utils.create_participant()
topic1 = dds.StringTopicType.Topic(p, "test topic1")
topic2 = dds.StringTopicType.Topic(p, "test topic2")
topic3 = dds.StringTopicType.Topic(p, "test topic3")
sub1 = None
sub2 = dds.Subscriber(p)
if not implicit_sub:
sub1 = dds.Subscriber(p)
else:
sub1 = p.implicit_subscriber
reader10 = dds.StringTopicType.DataReader(sub1, topic1)
reader11 = dds.StringTopicType.DataReader(sub1, topic1)
reader20 = dds.StringTopicType.DataReader(sub1, topic2)
reader30 = dds.StringTopicType.DataReader(sub1, topic3)
reader31 = dds.StringTopicType.DataReader(sub2, topic3)
topic_query1 = dds.TopicQuery(
dds.AnyDataReader(reader10),
dds.TopicQuerySelection(dds.Filter("foo = 1 or foo = 3")),
)
topic_query2 = dds.TopicQuery(
dds.AnyDataReader(reader31),
dds.TopicQuerySelection(dds.Filter("foo = 4 or foo = 6")),
)
sub1.close()
assert reader10.closed
assert reader11.closed
assert reader20.closed
assert reader30.closed
assert topic_query1.closed
assert not reader31.closed
assert not topic_query2.closed
def __init__(self, domain_id, sample_type):
self.participant = create_participant(domain_id)
reader_qos = self.participant.implicit_subscriber.default_datareader_qos
reader_qos << dds.Durability.transient_local
reader_qos << dds.Reliability.reliable()
reader_qos << dds.History.keep_all
writer_qos = self.participant.implicit_publisher.default_datawriter_qos
writer_qos << dds.Durability.transient_local
writer_qos << dds.Reliability.reliable()
writer_qos << dds.History.keep_all
if sample_type == "StringTopicType":
self.topic = dds.StringTopicType.Topic(self.participant,
"StringTopicType")
self.reader = dds.StringTopicType.DataReader(
self.participant, self.topic, reader_qos)
self.writer = dds.StringTopicType.DataWriter(
self.participant, self.topic, writer_qos)
elif sample_type == "KeyedStringTopicType":
self.topic = dds.KeyedStringTopicType.Topic(
self.participant, "KeyedStringTopicType")
self.reader = dds.KeyedStringTopicType.DataReader(
self.participant, self.topic, reader_qos)
self.writer = dds.KeyedStringTopicType.DataWriter(
self.participant, self.topic, writer_qos)
elif sample_type == "PerformanceTest":
provider = dds.QosProvider(
str(pathlib.Path(__file__).parent.absolute()) +
"/../xml/PerfTest.xml")
provider_type = provider.type("PerformanceTest")
self.topic = dds.DynamicData.Topic(self.participant,
"PerformanceTest",
provider_type)
self.reader = dds.DynamicData.DataReader(
dds.Subscriber(self.participant), self.topic, reader_qos)
self.writer = dds.DynamicData.DataWriter(
dds.Publisher(self.participant), self.topic, writer_qos)
else:
raise Exception(sample_type + " not supported in test system")
def subscriber_main(domain_id, sample_count, participant_auth):
participant_qos = dds.QosProvider.default.participant_qos
resource_limits_qos = participant_qos.resource_limits
max_participant_user_data = resource_limits_qos.participant_user_data_max_length
# Set the participant auth string as user data bytes
if len(participant_auth) > max_participant_user_data:
raise ValueError("participant user data exceeds resource limits")
else:
participant_qos.user_data.value = bytearray(participant_auth.encode())
participant = dds.DomainParticipant(domain_id, participant_qos)
participant.enable()
msg_type = dds.QosProvider("msg.xml").type("builtin_topics_lib", "msg")
topic = dds.DynamicData.Topic(participant, "Example msg", msg_type)
reader = dds.DynamicData.DataReader(dds.Subscriber(participant), topic)
reader.bind_listener(MsgListener(), dds.StatusMask.data_available())
count = 0
while (sample_count == 0) or (count < sample_count):
time.sleep(1)
count += 1
def __init__(self, domain_id, use_dynamic_data, use_qos_object,
use_custom_topic, use_replier_cft, use_pub_sub_args,
use_callback_funcs, use_simple_replier):
qos = dds.DomainParticipantQos()
qos.database.shutdown_cleanup_period = dds.Duration.from_milliseconds(
100)
self._participant = dds.DomainParticipant(domain_id, qos)
if use_dynamic_data:
self._type = get_keyed_string_dynamic_type()
self.create_data_fnc = create_dynamic_rr_data
self.parse_data_fnc = parse_dynamic_rr_data
self.copy_sample_fnc = copy_dynamic_sample
create_topic_func = create_dynamic_topic
else:
self._type = type_cls = dds.KeyedStringTopicType
self.create_data_fnc = create_rr_data
self.parse_data_fnc = parse_rr_data
self.copy_sample_fnc = copy_sample
create_topic_func = create_topic
service_name = 'Test'
if use_qos_object:
request_writer_qos = request.Requester.default_writer_qos
request_reader_qos = request.Replier.default_reader_qos
reply_writer_qos = request.Replier.default_writer_qos
reply_reader_qos = request.Requester.default_reader_qos
else:
request_writer_qos = request_reader_qos = reply_writer_qos = reply_reader_qos = None
if use_custom_topic:
# Test with custom Topic object
request_topic = create_topic_func(self._participant, 'TestRequest')
# Test with custom string Topic name
reply_topic = 'TestReply'
else:
request_topic = reply_topic = None
if use_replier_cft:
replier_filter = dds.Filter("NOT (key MATCH 'filtered')")
request_reader_topic = create_topic_func(
self._participant,
'TestRequest') if request_topic is None else request_topic
if isinstance(self._type, dds.DynamicType):
request_reader_topic = dds.DynamicData.ContentFilteredTopic(
request_reader_topic, 'request_cft', replier_filter)
else:
request_reader_topic = dds.KeyedStringTopicType.ContentFilteredTopic(
request_reader_topic, 'request_cft', replier_filter)
else:
request_reader_topic = request_topic
if use_pub_sub_args:
publisher = dds.Publisher(self._participant)
subscriber = dds.Subscriber(self._participant)
else:
publisher = subscriber = None
self._cb = use_callback_funcs
self._request_queue = queue.Queue()
self._reply_queue = queue.Queue()
if use_callback_funcs:
def replier_callback(replier):
for sample in (s for s in replier.take_requests()
if s.info.valid):
self._request_queue.put(self.copy_sample_fnc(sample))
def requester_callback(requester):
for sample in (s for s in requester.take_replies()
if s.info.valid):
self._reply_queue.put(self.copy_sample_fnc(sample))
else:
replier_callback = requester_callback = None
self._requester = request.Requester(self._type, self._type,
self._participant, service_name,
request_topic, reply_topic,
request_writer_qos,
reply_reader_qos, publisher,
subscriber, requester_callback)
self._simple = use_simple_replier
if use_simple_replier:
def simple_replier_callback(request):
key, value = self.parse_data_fnc(request)
reply = self.create_data_fnc(key, value + ' reply')
return reply
self._replier = request.SimpleReplier(
self._type, self._type, self._participant,
simple_replier_callback, service_name, request_reader_topic,
reply_topic, reply_writer_qos, request_reader_qos, publisher,
subscriber)
else:
self._replier = request.Replier(self._type, self._type,
self._participant, service_name,
request_reader_topic, reply_topic,
reply_writer_qos,
request_reader_qos, publisher,
subscriber, replier_callback)
def subscriber_main(domain_id, sample_count, is_cft):
participant = dds.DomainParticipant(domain_id)
cft_type = dds.QosProvider("cft.xml").type("cft_lib", "cft")
topic = dds.DynamicData.Topic(participant, "Example cft", cft_type)
if is_cft:
# Create a CFT that filters for incoming data within a range
topic = dds.DynamicData.ContentFilteredTopic(
topic, "ContentFilteredTopic", dds.Filter("x >= %0 AND x <= %1", ["1", "4"])
)
print(
textwrap.dedent(
"""
==========================
Using CFT
Filter: 1 <= x <= 4
=========================="""
)
)
else:
# Filtering disabled by default
print(
textwrap.dedent(
"""
==========================
Using Normal Topic
=========================="""
)
)
reader_qos = dds.QosProvider.default.datareader_qos
reader = dds.DynamicData.DataReader(dds.Subscriber(participant), topic, reader_qos)
reader.bind_listener(CftListener(), dds.StatusMask.DATA_AVAILABLE)
count = 0
while (sample_count == 0) or (count < sample_count):
time.sleep(1)
if is_cft:
if count == 10:
# After 10 seconds, udpdate the filter range
print(
textwrap.dedent(
"""
==========================
Changing Filter Parameters
Filter: 5 <= x <= 9
=========================="""
)
)
topic.filter_parameters = ["5", "9"]
if count == 20:
# After 20 seconds, update the filter again
print(
textwrap.dedent(
"""
==========================
Changing Filter Parameters
Filter: 3 <= x <= 9
=========================="""
)
)
topic.filter_parameters = ["3", "9"]
count += 1
def run_example(domain_id, sensor_id):
# A DomainParticipant allows an application to begin communicating in
# a DDS domain. Typically there is one DomainParticipant per application.
# DomainParticipant QoS is configured in USER_QOS_PROFILES.xml
participant = dds.DomainParticipant(domain_id)
# A Topic has a name and a datatype. Create Topics.
# Topic names are constants defined in the XML file.
temperature_topic = dds.DynamicData.Topic(participant,
CHOCOLATE_TEMPERATURE_TOPIC,
TEMPERATURE_TYPE)
lot_state_topic = dds.DynamicData.Topic(participant,
CHOCOLATE_LOT_STATE_TOPIC,
CHOCOLATE_LOT_TYPE)
# A Publisher allows an application to create one or more DataWriters
# Publisher QoS is configured in USER_QOS_PROFILES.xml
publisher = dds.Publisher(participant)
# Create DataWriters of Topics "ChocolateTemperature" & "ChocolateLotState"
# DataWriter QoS is configured in USER_QOS_PROFILES.xml
temperature_writer = dds.DynamicData.DataWriter(publisher,
temperature_topic)
lot_state_writer = dds.DynamicData.DataWriter(publisher, lot_state_topic)
# A Subscriber allows an application to create one or more DataReaders
# Subscriber QoS is configured in USER_QOS_PROFILES.xml
subscriber = dds.Subscriber(participant)
# Create DataReader of Topic "ChocolateLotState".
# DataReader QoS is configured in USER_QOS_PROFILES.xml
lot_state_reader = dds.DynamicData.DataReader(subscriber, lot_state_topic)
# Obtain the DataReader's Status Condition
status_condition = dds.StatusCondition(lot_state_reader)
# Enable the 'data available' status.
status_condition.enabled_statuses = dds.StatusMask.data_available()
# Associate a handler with the status condition. This will run when the
# condition is triggered, in the context of the dispatch call (see below)
def handler(_):
nonlocal lot_state_reader
nonlocal lot_state_writer
process_lot(lot_state_reader, lot_state_writer)
# Create a WaitSet and attach the StatusCondition
status_condition.set_handler(handler)
waitset = dds.WaitSet()
waitset += status_condition
# Create a thread to periodically publish the temperature
print(f"ChocolateTemperature Sensor with ID: {sensor_id} starting")
temperature_thread = threading.Thread(target=publish_temperature,
args=(temperature_writer, sensor_id))
temperature_thread.start()
try:
while True:
# Wait for ChocolateLotState
print("Waiting for lot")
waitset.dispatch(dds.Duration(10)) # Wait up to 10s for update
except KeyboardInterrupt:
pass
temperature_thread.join()
def run_example(domain_id, lots_to_process, sensor_id):
# A DomainParticipant allows an application to begin communicating in
# a DDS domain. Typically there is one DomainParticipant per application.
# DomainParticipant QoS is configured in USER_QOS_PROFILES.xml
participant = dds.DomainParticipant(domain_id)
# A Topic has a name and a datatype. Create a Topic with type
# ChocolateLotState. Topic name is a constant defined in the XML file.
topic = dds.DynamicData.Topic(participant, CHOCOLATE_LOT_STATE_TOPIC,
CHOCOLATE_LOT_TYPE)
# Exercise #4.1: Add a Topic for Temperature to this application
temperature_topic = dds.DynamicData.Topic(participant,
CHOCOLATE_TEMPERATURE_TOPIC,
provider.type("Temperature"))
# A Publisher allows an application to create one or more DataWriters
# Publisher QoS is configured in USER_QOS_PROFILES.xml
publisher = dds.Publisher(participant)
# This DataWriter writes data on Topic "ChocolateLotState"
# DataWriter QoS is configured in USER_QOS_PROFILES.xml
writer = dds.DynamicData.DataWriter(publisher, topic)
# A Subscriber allows an application to create one or more DataReaders
# Subscriber QoS is configured in USER_QOS_PROFILES.xml
subscriber = dds.Subscriber(participant)
# Create DataReader of Topic "ChocolateLotState".
# DataReader QoS is configured in USER_QOS_PROFILES.xml
reader = dds.DynamicData.DataReader(subscriber, topic)
# Exercise #4.2: Add a DataReader for Temperature to this application
temperature_reader = dds.DynamicData.DataReader(subscriber,
temperature_topic)
# Obtain the DataReader's Status Condition
status_condition = dds.StatusCondition(reader)
# Enable the 'data available' status.
status_condition.enabled_statuses = dds.StatusMask.data_available()
# Associate a handler with the status condition. This will run when the
# condition is triggered, in the context of the dispatch call (see below)
lots_processed = 0
def handler(_):
nonlocal lots_processed
nonlocal reader
lots_processed += monitor_lot_state(reader)
status_condition.set_handler(handler)
temperature_status_condition = dds.StatusCondition(reader)
temperature_status_condition.enabled_statuses = (
dds.StatusMask.data_available())
def temperature_handler(_):
nonlocal temperature_reader
monitor_lot_state(temperature_reader)
temperature_status_condition.set_handler(temperature_handler)
# Create a WaitSet and attach the StatusCondition
waitset = dds.WaitSet()
waitset += status_condition
# Exercise #4.3: Add the new DataReader's StatusCondition to the Waitset
waitset += temperature_status_condition
# Create a thread to periodically publish the temperature
start_lot_thread = threading.Thread(target=publish_start_lot,
args=(writer, lots_to_process))
start_lot_thread.start()
try:
while lots_to_process is None or lots_processed < lots_to_process:
# Dispatch will call the handlers associated to the WaitSet conditions
# when they activate
waitset.dispatch(dds.Duration(4)) # Wait for up to 4s each time
except KeyboardInterrupt:
pass
start_lot_thread.join()
def subscriber_main(domain_id, sample_count, is_cft):
participant = dds.DomainParticipant(domain_id)
cft_type = dds.QosProvider("cft.xml").type("cft_lib", "cft")
topic = dds.DynamicData.Topic(participant, "Example cft", cft_type)
if is_cft:
# Use a stringmatch CFT
str_filter = dds.Filter("name MATCH %0", ["SOME_STRING"])
str_filter.name = dds.Filter.stringmatch_filter_name
topic = dds.DynamicData.ContentFilteredTopic(topic,
"ContentFilteredTopic",
str_filter)
# Initial filter is a simple name match
print(
textwrap.dedent("""
==========================
Using ContentFilteredTopic
name MATCH %0
=========================="""))
else:
# Default topic does not use a CFT
print(
textwrap.dedent("""
==========================
Using Normal Topic
=========================="""))
reader_qos = dds.QosProvider.default.datareader_qos
reader = dds.DynamicData.DataReader(dds.Subscriber(participant), topic,
reader_qos)
reader.bind_listener(CftListener(), dds.StatusMask.DATA_AVAILABLE)
# Change the filter
if is_cft:
print('Now setting a new filter: name MATCH "EVEN"')
topic.append_to_expression_parameter(0, "EVEN")
count = 0
while (sample_count == 0) or (count < sample_count):
time.sleep(1)
if is_cft:
if count == 10:
# Change the filter again after 10 seconds
print(
textwrap.dedent("""
==========================
Changing Filter Parameters
Append 'ODD' filter
=========================="""))
topic.append_to_expression_parameter(0, "ODD")
if count == 20:
# Change the filter one more time after 20 seconds
print(
textwrap.dedent("""
==========================
Changing Filter Parameters
Remove 'EVEN' filter
=========================="""))
topic.remove_from_expression_parameter(0, "EVEN")
count += 1
def subscriber_main(domain_id, sample_count):
participant = dds.DomainParticipant(domain_id)
wsqc_type = dds.QosProvider("waitset_query_cond.xml").type(
"wsqc_lib", "waitset_query_cond"
)
topic = dds.DynamicData.Topic(participant, "Example waitset_query_cond", wsqc_type)
reader_qos = dds.QosProvider.default.datareader_qos
reader = dds.DynamicData.DataReader(dds.Subscriber(participant), topic, reader_qos)
# Query against even samples at the start
query_parameters = ["'EVEN'"]
query = dds.Query(reader, "name MATCH %0", query_parameters)
query_condition = dds.QueryCondition(query, dds.DataState.any_data)
# Create a WaitSet and attach the QueryCondition
waitset = dds.WaitSet()
waitset += query_condition
print(
textwrap.dedent(
"""\
>>> Timeout: {} sec
>>> Query conditions: {}
\t %0 = {}
----------------------------------
""".format(
1, query_condition.expression, query_parameters[0]
)
)
)
count = 0
while (sample_count == 0) or (count < sample_count):
time.sleep(1)
if count == 7:
# Update the query after 7 seconds
query_parameters[0] = "'ODD'"
query_condition.parameters = query_parameters
print(
textwrap.dedent(
"""
CHANGING THE QUERY CONDITION
>>> Query conditions:
{}
\t %%0 = {}
>>> We keep one sample in the history
-------------------------------------
""".format(
query_condition.expression, query_parameters[0]
)
)
)
active = waitset.wait((1, 0))
# Check to see if the query was triggered
if query_condition in active:
query_handler(reader, query_condition)
count += 1
def test_close_participant_contained_entities(implicit_pub, test_retain):
p1 = utils.create_participant()
p2 = utils.create_participant()
topic1 = dds.StringTopicType.Topic(p1, "test_topic1")
topic2 = dds.StringTopicType.Topic(p1, "test topic2")
topic30 = dds.StringTopicType.Topic(p1, "test topic3")
topic31 = dds.StringTopicType.Topic(p2, "test topic3")
cft10 = dds.StringTopicType.ContentFilteredTopic(topic1, "cft10",
dds.Filter("value = '1'"))
cft11 = dds.StringTopicType.ContentFilteredTopic(topic1, "cft11",
dds.Filter("value = '1'"))
cft20 = dds.StringTopicType.ContentFilteredTopic(topic31, "cft20",
dds.Filter("value = '1'"))
pub1 = None
pub2 = None
sub1 = None
sub2 = None
if not implicit_pub:
pub1 = dds.Publisher(p1)
pub2 = dds.Publisher(p2)
sub1 = dds.Subscriber(p1)
sub2 = dds.Subscriber(p2)
else:
pub1 = p1.implicit_publisher
pub2 = p2.implicit_publisher
sub1 = p1.implicit_subscriber
sub2 = p2.implicit_subscriber
writer10 = dds.StringTopicType.DataWriter(pub1, topic1)
writer11 = dds.StringTopicType.DataWriter(pub1, topic1)
writer20 = dds.StringTopicType.DataWriter(pub1, topic2)
writer30 = dds.StringTopicType.DataWriter(pub1, topic30)
writer31 = dds.StringTopicType.DataWriter(pub2, topic31)
reader10 = dds.StringTopicType.DataReader(sub1, topic1)
reader11 = dds.StringTopicType.DataReader(sub1, topic2)
reader20 = dds.StringTopicType.DataReader(sub1, cft10)
reader30 = dds.StringTopicType.DataReader(sub1, topic30)
reader31 = dds.StringTopicType.DataReader(sub2, topic31)
reader32 = dds.StringTopicType.DataReader(sub2, cft20)
flow_controller10 = dds.FlowController(p1, "fc10")
flow_controller11 = dds.FlowController(p1, "fc11")
flow_controller12 = dds.FlowController(p1, "fc12")
flow_controller20 = dds.FlowController(p2, "fc20")
tq1 = dds.TopicQuery(
reader10,
dds.TopicQuerySelection(dds.Filter("value = '1' or value = '3'")))
tq2 = dds.TopicQuery(
reader31,
dds.TopicQuerySelection(dds.Filter("value = '4' or value = '6'")))
if test_retain:
pub1.retain()
reader11.retain()
writer11.retain()
topic2.retain()
cft11.retain()
flow_controller12.retain()
tq1.retain()
flow_controller12.close()
p1.close()
assert p1.closed
assert pub1.closed
assert sub1.closed
assert not pub2.closed
assert not sub2.closed
assert topic1.closed
assert topic2.closed
assert topic30.closed
assert not topic31.closed
assert cft10.closed
assert cft11.closed
assert not cft20.closed
assert writer10.closed
assert writer11.closed
assert writer20.closed
assert writer30.closed
assert not writer31.closed
assert reader10.closed
assert reader11.closed
assert reader20.closed
assert reader30.closed
assert not reader31.closed
assert flow_controller10.closed
assert flow_controller11.closed
assert flow_controller12.closed
assert not flow_controller20.closed
assert tq1.closed
assert not tq2.closed