Topic Use Cases

The following #includes are needed for the examples on this page

#include <dds/domain/ddsdomain.hpp>
#include <dds/core/ddscore.hpp>
#include <dds/topic/ddstopic.hpp>
 
#include "Foo.hpp"

Registering a user data type

• Types are implicitly registered during Topic construction, see Setting up a Topic

Setting up a Topic

• Set up a DomainParticipant
• Create a Topic with each of the available constructors

      // Create the participant
      dds::domain::DomainParticipant participant(0);
   
      // Creating a topic with user-defined type Foo and topic name MyTopic1,
      // with default Qos and no listener
      dds::topic::Topic<Foo> topic1(participant, "MyTopic1");
   
      // Creating a topic with user-defined type Foo, topic name MyTopic2, 
      // type name MyTypeName2
      dds::topic::Topic<Foo> topic2(participant, "MyTopic2", "MyTypeName2");
   
      // Creating a topic with user-defined type Foo, topic name MyTopic3, and
      // modified QoS
      dds::topic::qos::TopicQos qos;
      qos << dds::core::policy::Durability::TransientLocal();
      dds::topic::Topic<Foo> topic3(participant, "MyTopic3", qos);
   
      // Creating a topic with user-defined type Foo, topic name MyTopic4, type 
      // name MyTypeName4 and modified QoS
      dds::topic::Topic<Foo> topic4(participant, "MyTopic4", "MyTypeName4", qos);
   
      // Creating a topic with user-defined type Foo, topic name MyTopic5, 
      // modified QoS, and a listener
      auto listener = std::make_shared<ExampleTopicListener>();
      dds::topic::Topic<Foo> topic5(participant, "MyTopic5", qos, listener);
   
      // Creating a topic with user-defined type Foo, topic name MyTopic6, type
      // name MyTypeName6, modified QoS, and a listener
      dds::topic::Topic<Foo> topic6(
         participant, "MyTopic6", "MyTypeName6", qos, listener);
   
      // Creating a topic with user-defined type Foo, topic name MyTopic7, 
      // modified QoS, a non-NULL listener, and a inconsistent_topic status mask
      dds::topic::Topic<Foo> topic7(
         participant, "MyTopic7", qos, listener, 
         dds::core::status::StatusMask::inconsistent_topic());
   
      // Creating a topic with user-defined type Foo, topic name MyTopic8, type
      // name MyTypeName8, modified QoS, a listener, and
      // a inconsistent_topic status mask
      dds::topic::Topic<Foo> topic8(
         participant, "MyTopic8", "MyTypeName8", qos, listener, 
         dds::core::status::StatusMask::inconsistent_topic());
   

Discovering Topics

• Lookup local Topics by their topic name

  void howto_lookup_topics()
  {
      dds::domain::DomainParticipant participant(0);
   
      // Create two Topics and retain them
      create_and_retain_topic(participant, "Topic1");
      create_and_retain_topic(participant, "Topic2");
   
      // We don't have any references to the created Topics but we can look 
      // them up using topic name that they were created with
      dds::topic::Topic<Foo> topic1 = 
          dds::topic::find<dds::topic::Topic<Foo> >(participant, "Topic1");
   
      dds::topic::Topic<Foo> topic2 = 
          dds::topic::find<dds::topic::Topic<Foo> >(participant, "Topic2");
   
      // We retained the topics so we must close them now
      topic1.close();
      topic2.close();
  }
   
  void create_and_retain_topic(
     dds::domain::DomainParticipant &participant, const std::string& topic_name)
  {
      dds::topic::Topic<Foo> topic(participant, topic_name);
      topic.retain();
  }

  
  
• The next two examples assume the following setup

      // Create two DomainParticipants on the same domain
      dds::domain::DomainParticipant participant1(1);
      dds::domain::DomainParticipant participant2(1);
      
      // Create some Topics for both of the Participants
      dds::topic::Topic<Foo> topic1(participant1, "Topic1");
      dds::topic::Topic<Foo> topic2(participant1, "Topic2");
   
      dds::topic::Topic<Foo> topic3(participant2, "Topic3");

  
  
• Discover all Topics in a domain

      // Get a list of the InstanceHandles of all of the topics in the 
      // domain. topic_count will = 3
      dds::core::InstanceHandleSeq handles1;
      int topic_count = dds::topic::discover_any_topic(
         participant1, std::back_inserter(handles1));
   
      // discover_any_topic also takes a forward iterator and a max number of 
      // topics to discover. topic_count will = 2. There is no guarantee
      // as to which two topics' handles will be retrieved
      dds::core::InstanceHandleSeq handles2(10, dds::core::InstanceHandle::nil());
      topic_count = dds::topic::discover_any_topic(participant2, handles2.begin(), 2);

  
  
• Retrieve the TopicBuiltinTopicData for a Topic

      std::vector<dds::topic::TopicBuiltinTopicData> topic_data1;
   
      // Get the TopicBuiltinTopicData for all of the participant's local topics
      // topic_count will = 2 because participant1 has 2 associated Topics
      topic_count = dds::topic::discover_topic_data(participant1, std::back_inserter(topic_data1));
   
      std::vector<dds::topic::TopicBuiltinTopicData> topic_data2(10);
   
      // discover_any_topic also takes a forward iterator and a max number of 
      // topics to get the data for. Because we're using participant2, 
      // topic_count will = 1
      topic_count = dds::topic::discover_topic_data(participant2, topic_data2.begin());
   
      // You can also retrieve data about a specific Topic or Topics with their 
      // InstanceHandles. Because discover_topic_data will only retrieve data
      // about local topics, using an InstanceHandle that refers to a remote 
      // Topic will cause an UnsupportedError to be thrown in either of the 
      // following cases
   
      // Retrieve the TopicBuiltinTopicData for topic3
      dds::topic::TopicBuiltinTopicData topic_data = 
          dds::topic::discover_topic_data(participant2, topic3.instance_handle());
   
      // Pass in a container with multiple handles and retrieve the 
      // TopicBuiltinTopicData for each of the Topics associated with each of the 
      // InstanceHandles 
      std::vector<dds::topic::TopicBuiltinTopicData> topic_data3(10);
   
      dds::core::InstanceHandleSeq local_handles;
      local_handles.push_back(topic1.instance_handle());
      local_handles.push_back(topic2.instance_handle());
   
      // topic_count will equal 2
      topic_count = dds::topic::discover_topic_data(
         participant1, topic_data3.begin(), local_handles);
   

Tearing down a topic

• See Tearing Down An Entity for eamples of the various ways to teardown a Topic