DCPS_IR_Domain Class Reference

Representation of a Domain in the system. More...

#include <DCPS_IR_Domain.h>

Inheritance diagram for DCPS_IR_Domain:

[legend]

Collaboration diagram for DCPS_IR_Domain:

[legend]

List of all members.

Public Member Functions
	DCPS_IR_Domain (DDS::DomainId_t id, OpenDDS::DCPS::RepoIdGenerator &generator)
	~DCPS_IR_Domain ()
int	add_participant (DCPS_IR_Participant_rch participant)
int	remove_participant (const OpenDDS::DCPS::RepoId &particpantId, CORBA::Boolean notify_lost)
DCPS_IR_Participant *	participant (const OpenDDS::DCPS::RepoId &id) const
	Find the participant with the id.
OpenDDS::DCPS::TopicStatus	find_topic (const char *topicName, DCPS_IR_Topic *&topic)
DCPS_IR_Topic *	find_topic (const OpenDDS::DCPS::RepoId &id)
	Find a topic object reference using the topic Id value.
OpenDDS::DCPS::TopicStatus	remove_topic (DCPS_IR_Participant *part, DCPS_IR_Topic *&topic)
void	remove_topic_id_mapping (const OpenDDS::DCPS::RepoId &topicId)
void	add_dead_participant (DCPS_IR_Participant_rch participant)
void	remove_dead_participants ()
	Remove any participants currently marked as dead.
DDS::DomainId_t	get_id ()
OpenDDS::DCPS::RepoId	get_next_participant_id ()
	Next Entity Id value in sequence.
void	last_participant_key (long key)
	Ensure no conflicts with sequence values from persistent storage.
int	init_built_in_topics (bool federated, bool persistent)
int	cleanup_built_in_topics ()
	Cleans up the Built-In Topic structures.
int	reassociate_built_in_topic_pubs ()
void	publish_participant_bit (DCPS_IR_Participant *participant)
	Publish Participant in the Participant Built-In Topic.
void	publish_topic_bit (DCPS_IR_Topic *topic)
	Publish Topic in the Topic Built-In Topic.
void	publish_subscription_bit (DCPS_IR_Subscription *subscription)
	Publish Subscription in the Subscription Built-In Topic.
void	publish_publication_bit (DCPS_IR_Publication *publication)
	Publish Publication in the Publication Built-In Topic.
void	dispose_participant_bit (DCPS_IR_Participant *participant)
	Dispose Participant in the Participant Built-In Topic.
void	dispose_topic_bit (DCPS_IR_Topic *topic)
	Dispose Topic in the Topic Built-In Topic.
void	dispose_subscription_bit (DCPS_IR_Subscription *subscription)
	Dispose Subscription in the Subscription Built-In Topic.
void	dispose_publication_bit (DCPS_IR_Publication *publication)
	Dispose Publication in the Publication Built-In Topic.
const DCPS_IR_Participant_Map &	participants () const
	Expose a readable reference to the participant map.
std::string	dump_to_string (const std::string &prefix, int depth) const
bool	useBIT () const
Private Types
typedef std::map < OpenDDS::DCPS::RepoId, OpenDDS::DCPS::container_supported_unique_ptr < DCPS_IR_Topic > , OpenDDS::DCPS::GUID_tKeyLessThan >	IdToTopicMap
	Mapping from RepoId values to Topic object references.
Private Member Functions
OpenDDS::DCPS::TopicStatus	add_topic_i (OpenDDS::DCPS::RepoId &topicId, const char *topicName, const char *dataTypeName, const DDS::TopicQos &qos, DCPS_IR_Participant *participantPtr, bool isBIT)
int	add_topic_description (OpenDDS::DCPS::unique_ptr< DCPS_IR_Topic_Description > desc)
int	find_topic_description (const char *name, const char *dataTypeName, DCPS_IR_Topic_Description *&desc)
int	remove_topic_description (DCPS_IR_Topic_Description *desc)
	Returns 0 if successful.
	DCPS_IR_Domain (const DCPS_IR_Domain &)
Private Attributes
DDS::DomainId_t	id_
OpenDDS::DCPS::RepoIdGenerator &	participantIdGenerator_
DCPS_IR_Participant_Map	participants_
	all the participants
DCPS_IR_Participant_Set	deadParticipants_
DCPS_IR_Topic_Description_Set	topicDescriptions_
	all the topics
IdToTopicMap	idToTopicMap_
	Actual mapping of Id values to Topic object references.
bool	useBIT_
	indicates if the BuiltIn Topics are enabled
DDS::DomainParticipantFactory_var	bitParticipantFactory_
DDS::DomainParticipant_var	bitParticipant_
DDS::DomainParticipantListener_var	bitParticipantListener_
DDS::Publisher_var	bitPublisher_
OpenDDS::DCPS::TransportConfig_rch	transportConfig_
DDS::Topic_var	bitParticipantTopic_
DDS::ParticipantBuiltinTopicDataDataWriter_var	bitParticipantDataWriter_
DDS::Topic_var	bitTopicTopic_
DDS::TopicBuiltinTopicDataDataWriter_var	bitTopicDataWriter_
DDS::Topic_var	bitSubscriptionTopic_
DDS::SubscriptionBuiltinTopicDataDataWriter_var	bitSubscriptionDataWriter_
DDS::Topic_var	bitPublicationTopic_
DDS::PublicationBuiltinTopicDataDataWriter_var	bitPublicationDataWriter_
OpenDDS::DCPS::TopicStatus	add_topic (OpenDDS::DCPS::RepoId_out topicId, const char *topicName, const char *dataTypeName, const DDS::TopicQos &qos, DCPS_IR_Participant *participantPtr)
OpenDDS::DCPS::TopicStatus	force_add_topic (const OpenDDS::DCPS::RepoId &topicId, const char *topicName, const char *dataTypeName, const DDS::TopicQos &qos, DCPS_IR_Participant *participantPtr)
int	init_built_in_topics_topics ()
int	init_built_in_topics_datawriters (bool federated)
int	init_built_in_topics_transport (bool persistent)

---

Detailed Description

Representation of a Domain in the system.

This represents a Domain in the system. It contains the representatives of the entities that are in the corresponding system's domain.

Definition at line 64 of file DCPS_IR_Domain.h.

---

Member Typedef Documentation

typedef std::map<OpenDDS::DCPS::RepoId, OpenDDS::DCPS::container_supported_unique_ptr<DCPS_IR_Topic>, OpenDDS::DCPS::GUID_tKeyLessThan> DCPS_IR_Domain::IdToTopicMap [private]

Mapping from RepoId values to Topic object references.

Definition at line 234 of file DCPS_IR_Domain.h.

---

Constructor & Destructor Documentation

DCPS_IR_Domain h OPENDDS_BEGIN_VERSIONED_NAMESPACE_DECL DCPS_IR_Domain::DCPS_IR_Domain	(	DDS::DomainId_t	id,
		OpenDDS::DCPS::RepoIdGenerator &	generator
	)

Definition at line 38 of file DCPS_IR_Domain.cpp.

  : id_(id),
    participantIdGenerator_(generator),
    useBIT_(false)
{
}

DCPS_IR_Domain::~DCPS_IR_Domain

(

)

Definition at line 45 of file DCPS_IR_Domain.cpp.

{
}

DCPS_IR_Domain::DCPS_IR_Domain

(

const DCPS_IR_Domain &

)

[private]

---

Member Function Documentation

void DCPS_IR_Domain::add_dead_participant

(

DCPS_IR_Participant_rch

participant

)

Mark a participant as being unresponsive (dead) and schedule it to be removed next time remove_dead_participants is called.

Definition at line 946 of file DCPS_IR_Domain.cpp.

References deadParticipants_.

Referenced by DCPS_IR_Participant::mark_dead().

{
  deadParticipants_.insert(participant);
}

Here is the caller graph for this function:

int DCPS_IR_Domain::add_participant

(

DCPS_IR_Participant_rch

participant

)

Add the participant Returns 0 if added, 1 if already exists, -1 other failure

Definition at line 69 of file DCPS_IR_Domain.cpp.

References ACE_TEXT(), OpenDDS::DCPS::DCPS_debug_level, id_, OpenDDS::DCPS::RcHandle< T >::in(), LM_DEBUG, LM_NOTICE, participants_, and publish_participant_bit().

{
  OpenDDS::DCPS::RepoId participantId = participant->get_id();
  OpenDDS::DCPS::RepoIdConverter converter(participantId);

  DCPS_IR_Participant_Map::iterator where
  = this->participants_.find(participantId);

  if (where == this->participants_.end()) {
    this->participants_.insert(
      DCPS_IR_Participant_Map::value_type(participantId, participant));

    // Publish the BIT information
    publish_participant_bit(participant.in());

    if (OpenDDS::DCPS::DCPS_debug_level > 0) {
      ACE_DEBUG((LM_DEBUG,
                 ACE_TEXT("(%P|%t) DCPS_IR_Domain::add_participant: ")
                 ACE_TEXT("added participant %C in domain %d ")
                 ACE_TEXT("at 0x%x.\n"),
                 std::string(converter).c_str(),
                 id_,
                 participant.in()));
    }

  } else {
    if (OpenDDS::DCPS::DCPS_debug_level > 0) {
      ACE_DEBUG((LM_NOTICE,
                 ACE_TEXT("(%P|%t) NOTICE: DCPS_IR_Domain::add_participant: ")
                 ACE_TEXT("attempt to add already existing participant %C in domain %d.\n"),
                 std::string(converter).c_str(),
                 id_));
    }

    return 1;
  }

  return 0;
}

Here is the call graph for this function:

OpenDDS::DCPS::TopicStatus DCPS_IR_Domain::add_topic	(	OpenDDS::DCPS::RepoId_out	topicId,
		const char *	topicName,
		const char *	dataTypeName,
		const DDS::TopicQos &	qos,
		DCPS_IR_Participant *	participantPtr
	)

Add a topic to the domain Returns OpenDDS::DCPS::CREATED if successfull

Definition at line 150 of file DCPS_IR_Domain.cpp.

References add_topic_i(), OpenDDS::DCPS::CREATED, DCPS_IR_Participant::get_next_topic_id(), OpenDDS::DCPS::GUID_UNKNOWN, status, and OpenDDS::DCPS::topicIsBIT().

{
  topicId = OpenDDS::DCPS::GUID_UNKNOWN;

  bool isBIT = OpenDDS::DCPS::topicIsBIT(topicName, dataTypeName);
  OpenDDS::DCPS::RepoId new_topic_id = participantPtr->get_next_topic_id(isBIT);
  OpenDDS::DCPS::TopicStatus status = add_topic_i(new_topic_id, topicName
                                                  , dataTypeName
                                                  , qos, participantPtr, isBIT);

  if (status == OpenDDS::DCPS::CREATED) {
    topicId = new_topic_id;
  }

  return status;
}

Here is the call graph for this function:

int DCPS_IR_Domain::add_topic_description

(

OpenDDS::DCPS::unique_ptr< DCPS_IR_Topic_Description >

desc

)

[private]

Takes ownership of the memory pointed to by desc if successful returns 0 if successful, 1 if description already exists -1 unknown error 2 if confliciting dataTypeName

Definition at line 878 of file DCPS_IR_Domain.cpp.

References ACE_TEXT(), OpenDDS::DCPS::DCPS_debug_level, find_topic_description(), OpenDDS::DCPS::unique_ptr< T, Deleter >::get(), DCPS_IR_Topic_Description::get_name(), id_, LM_DEBUG, LM_ERROR, LM_NOTICE, OpenDDS::DCPS::EnableContainerSupportedUniquePtr< DCPS_IR_Domain >::move, OpenDDS::DCPS::move(), and topicDescriptions_.

Referenced by add_topic_i().

{
  using OpenDDS::DCPS::move;
  DCPS_IR_Topic_Description* discard = 0;
  DCPS_IR_Topic_Description* desc_ptr = desc.get();

  switch (this->find_topic_description(
            desc->get_name(),
            desc->get_dataTypeName(),
            discard)) {
  case -1:
    this->topicDescriptions_[desc_ptr->get_name()] = move(desc);

    if (OpenDDS::DCPS::DCPS_debug_level > 0) {
      ACE_DEBUG((LM_DEBUG,
                 ACE_TEXT("(%P|%t) DCPS_IR_Domain::add_topic_description: ")
                 ACE_TEXT("added Topic Description 0x%x in domain %d.\n"),
                 desc_ptr,
                 id_));
    }

    return 0;

  case 0:
    ACE_DEBUG((LM_NOTICE,
               ACE_TEXT("(%P|%t) NOTICE: DCPS_IR_Domain::add_topic_description: ")
               ACE_TEXT("attempt to add existing Topic Description 0x%x to domain %d.\n"),
               desc_ptr,
               id_));
    return 1;

  case 1:
    ACE_DEBUG((LM_NOTICE,
               ACE_TEXT("(%P|%t) NOTICE: DCPS_IR_Domain::add_topic_description: ")
               ACE_TEXT("attempt to add incompatible Topic Description 0x%x to domain %d.\n"),
               desc_ptr,
               id_));
    return 2;

  default:
    ACE_ERROR((LM_ERROR,
               ACE_TEXT("(%P|%t) ERROR: DCPS_IR_Domain::add_topic_description: ")
               ACE_TEXT("unknown error adding Topic Description 0x%x to domain %d.\n"),
               desc_ptr,
               id_));
    return 2;
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

OpenDDS::DCPS::TopicStatus DCPS_IR_Domain::add_topic_i	(	OpenDDS::DCPS::RepoId &	topicId,
		const char *	topicName,
		const char *	dataTypeName,
		const DDS::TopicQos &	qos,
		DCPS_IR_Participant *	participantPtr,
		bool	isBIT
	)			[private]

Definition at line 187 of file DCPS_IR_Domain.cpp.

References ACE_TEXT(), DCPS_IR_Topic_Description::add_topic(), add_topic_description(), DCPS_IR_Participant::add_topic_reference(), OpenDDS::DCPS::CONFLICTING_TYPENAME, OpenDDS::DCPS::CREATED, OpenDDS::DCPS::DCPS_debug_level, find_topic_description(), OpenDDS::DCPS::unique_ptr< T, Deleter >::get(), OpenDDS::DCPS::GUID_UNKNOWN, id_, idToTopicMap_, LM_DEBUG, LM_ERROR, LM_NOTICE, OpenDDS::DCPS::EnableContainerSupportedUniquePtr< DCPS_IR_Domain >::move, OpenDDS::DCPS::NOT_FOUND, publish_topic_bit(), and DCPS_IR_Topic_Description::remove_topic().

Referenced by add_topic(), and force_add_topic().

{
  DCPS_IR_Topic_Description* description;
  int descriptionLookup = find_topic_description(topicName, dataTypeName, description);

  if (1 == descriptionLookup) {
    topicId = OpenDDS::DCPS::GUID_UNKNOWN;
    return OpenDDS::DCPS::CONFLICTING_TYPENAME;

  } else if (-1 == descriptionLookup) {
    using namespace OpenDDS::DCPS;
    unique_ptr<DCPS_IR_Topic_Description> desc( new
                   DCPS_IR_Topic_Description(
                     this,
                     topicName,
                     dataTypeName));
    description = desc.get();
    int descriptionAddition = add_topic_description(move(desc));

    if (0 != descriptionAddition) {
      topicId = OpenDDS::DCPS::GUID_UNKNOWN;

      if (2 == descriptionAddition) {
        return OpenDDS::DCPS::CONFLICTING_TYPENAME;

      } else {
        return OpenDDS::DCPS::NOT_FOUND;
      }
    }
  }

  OpenDDS::DCPS::unique_ptr<DCPS_IR_Topic> topic( new
                 DCPS_IR_Topic(
                   topicId,
                   qos,
                   this,
                   participantPtr,
                   description,
                   isBIT));

  OpenDDS::DCPS::TopicStatus topicStatus = OpenDDS::DCPS::NOT_FOUND;

  switch (description->add_topic(topic.get())) {
  case 0: {
    switch (participantPtr->add_topic_reference(topic.get())) {
    case 0: {
      if (OpenDDS::DCPS::DCPS_debug_level > 0) {
        OpenDDS::DCPS::RepoIdConverter converter(topicId);
        ACE_DEBUG((LM_DEBUG,
                   ACE_TEXT("(%P|%t) DCPS_IR_Domain::add_topic_i: ")
                   ACE_TEXT("Domain %d successfully added topic %C ")
                   ACE_TEXT("at 0x%x.\n"),
                   this->id_,
                   std::string(converter).c_str(),
                   topic.get()));
      }

      topicStatus = OpenDDS::DCPS::CREATED;

      // Publish the BIT information
      publish_topic_bit(topic.get());

      // Keep a reference to easily locate the topic by id.
      this->idToTopicMap_[topicId] = move(topic);

    }
    break;

    case 1:

      if (OpenDDS::DCPS::DCPS_debug_level > 0) {
        OpenDDS::DCPS::RepoIdConverter converter(topicId);
        ACE_DEBUG((LM_NOTICE,
                   ACE_TEXT("(%P|%t) NOTICE: DCPS_IR_Domain::add_topic_i: ")
                   ACE_TEXT("Domain %d declined to add duplicate topic %C at 0x%x.\n"),
                   this->id_,
                   std::string(converter).c_str(),
                   topic.get()));
      }

      topicStatus = OpenDDS::DCPS::NOT_FOUND;
      topicId = OpenDDS::DCPS::GUID_UNKNOWN;
      description->remove_topic(topic.get());
      break;

    case -1: {
      OpenDDS::DCPS::RepoIdConverter converter(topicId);
      ACE_ERROR((LM_ERROR,
                 ACE_TEXT("(%P|%t) ERROR: DCPS_IR_Domain::add_topic_i: ")
                 ACE_TEXT("Domain %d failed to add topic %C at 0x%x.\n"),
                 this->id_,
                 std::string(converter).c_str(),
                 topic.get()));
      topicStatus = OpenDDS::DCPS::NOT_FOUND;
      topicId = OpenDDS::DCPS::GUID_UNKNOWN;
      description->remove_topic(topic.get());
    }
    break;
    }
  }
  break;

  case 1:

    if (OpenDDS::DCPS::DCPS_debug_level > 0) {
      OpenDDS::DCPS::RepoIdConverter converter(topicId);
      ACE_DEBUG((LM_DEBUG, ACE_TEXT("(%P|%t) WARNING: DCPS_IR_Domain::add_topic ")
                 ACE_TEXT("Unable to add topic 0x%x id %C to Topic Description\n"),
                 topic.get(),
                 std::string(converter).c_str()));
    }

    topicStatus = OpenDDS::DCPS::NOT_FOUND;
    topicId = OpenDDS::DCPS::GUID_UNKNOWN;
    break;

  case -1: {
    OpenDDS::DCPS::RepoIdConverter converter(topicId);
    ACE_ERROR((LM_ERROR, ACE_TEXT("(%P|%t) ERROR: DCPS_IR_Domain::add_topic ")
               ACE_TEXT("Unable to add topic 0x%x id %C to Topic Description\n"),
               topic.get(),
               std::string(converter).c_str()));
    topicStatus = OpenDDS::DCPS::NOT_FOUND;
    topicId = OpenDDS::DCPS::GUID_UNKNOWN;
  }
  break;
  }

  return topicStatus;
}

Here is the call graph for this function:

Here is the caller graph for this function:

int DCPS_IR_Domain::cleanup_built_in_topics

(

)

Cleans up the Built-In Topic structures.

Definition at line 851 of file DCPS_IR_Domain.cpp.

References bitParticipant_, bitParticipantDataWriter_, bitParticipantFactory_, bitParticipantTopic_, bitPublicationDataWriter_, bitPublicationTopic_, bitPublisher_, bitSubscriptionDataWriter_, bitSubscriptionTopic_, bitTopicDataWriter_, bitTopicTopic_, and useBIT_.

{
#if !defined (DDS_HAS_MINIMUM_BIT)

  if (useBIT_) {
    // clean up the Built-in Topic objects
    bitParticipant_->delete_contained_entities();
    bitPublisher_ = 0;
    bitParticipantDataWriter_ = 0;
    bitTopicDataWriter_ = 0;
    bitSubscriptionDataWriter_ = 0;
    bitPublicationDataWriter_ = 0;
    bitParticipantTopic_ = 0;
    bitTopicTopic_ = 0;
    bitSubscriptionTopic_ = 0;
    bitPublicationTopic_ = 0;

    bitParticipantFactory_->delete_participant(bitParticipant_); // deletes this
  }

  return 0;

#else
  return 1;
#endif // !defined (DDS_HAS_MINIMUM_BIT)
}

void DCPS_IR_Domain::dispose_participant_bit

(

DCPS_IR_Participant *

participant

)

Dispose Participant in the Participant Built-In Topic.

Definition at line 1255 of file DCPS_IR_Domain.cpp.

References CORBA::Exception::_tao_print_exception(), ACE_TEXT(), bitParticipantDataWriter_, DCPS_IR_Participant::get_handle(), DCPS_IR_Participant::get_id(), DCPS_IR_Participant::isBitPublisher(), LM_ERROR, DDS::RETCODE_OK, and useBIT_.

Referenced by remove_participant().

{
#if !defined (DDS_HAS_MINIMUM_BIT)

  if (useBIT_) {
    if (!participant->isBitPublisher()) {
      try {
        DDS::ParticipantBuiltinTopicData key_data;
        DDS::InstanceHandle_t handle = participant->get_handle();

        DDS::ReturnCode_t retGetKey
        = bitParticipantDataWriter_->get_key_value(key_data,
                                                   handle);

        if (DDS::RETCODE_OK != retGetKey) {
          OpenDDS::DCPS::RepoIdConverter converter(participant->get_id());
          ACE_ERROR((LM_ERROR,
                     ACE_TEXT("(%P|%t) ERROR: DCPS_IR_Domain::dispose_participant_bit ")
                     ACE_TEXT("Unable to get_key_value for participant %C handle %d.\n"),
                     std::string(converter).c_str(),
                     handle));
        }

        DDS::ReturnCode_t retDispose =
          bitParticipantDataWriter_->dispose(key_data,
                                             handle);

        if (DDS::RETCODE_OK != retDispose) {
          OpenDDS::DCPS::RepoIdConverter converter(participant->get_id());
          ACE_ERROR((LM_ERROR,
                     ACE_TEXT("(%P|%t) ERROR: DCPS_IR_Domain::dispose_participant_bit ")
                     ACE_TEXT("Unable to dispose for participant %C handle %d.\n"),
                     std::string(converter).c_str(),
                     handle));
        }

      } catch (const CORBA::Exception& ex) {
        ex._tao_print_exception(
          "ERROR: Exception caught in DCPS_IR_Domain::dispose_participant_bit:");
      }
    }
  }

#else
  ACE_UNUSED_ARG(participant);
#endif // !defined (DDS_HAS_MINIMUM_BIT)
}

Here is the call graph for this function:

Here is the caller graph for this function:

void DCPS_IR_Domain::dispose_publication_bit

(

DCPS_IR_Publication *

publication

)

Dispose Publication in the Publication Built-In Topic.

Definition at line 1403 of file DCPS_IR_Domain.cpp.

References CORBA::Exception::_tao_print_exception(), ACE_TEXT(), bitPublicationDataWriter_, DCPS_IR_Publication::get_handle(), DCPS_IR_Publication::is_bit(), LM_ERROR, DDS::RETCODE_OK, and useBIT_.

Referenced by DCPS_IR_Participant::remove_publication().

{
#if !defined (DDS_HAS_MINIMUM_BIT)

  if (useBIT_) {
    if (!publication->is_bit()) {
      try {
        DDS::PublicationBuiltinTopicData key_data;
        DDS::InstanceHandle_t handle = publication->get_handle();

        DDS::ReturnCode_t retGetKey
        = bitPublicationDataWriter_->get_key_value(key_data, handle);

        if (DDS::RETCODE_OK != retGetKey) {
          ACE_ERROR((LM_ERROR,
                     ACE_TEXT("(%P|%t) ERROR: DCPS_IR_Domain::dispose_publication_bit ")
                     ACE_TEXT("Unable to get_key_value for publication ptr 0x%x handle %d.  ")
                     ACE_TEXT("Call returned %d.\n"),
                     publication,
                     handle,
                     retGetKey));
        }

        DDS::ReturnCode_t retDispose =
          bitPublicationDataWriter_->dispose(key_data,
                                             handle);

        if (DDS::RETCODE_OK != retDispose) {
          ACE_ERROR((LM_ERROR,
                     ACE_TEXT("(%P|%t) ERROR: DCPS_IR_Domain::dispose_publication_bit ")
                     ACE_TEXT("Unable to dispose for publication ptr 0x%x handle %d.  ")
                     ACE_TEXT("Call returned %d.\n"),
                     publication,
                     handle,
                     retDispose));
        }

      } catch (const CORBA::Exception& ex) {
        ex._tao_print_exception(
          "(%P|%t) ERROR: Exception caught in DCPS_IR_Domain::dispose_publication_bit:");
      }
    }
  }

#else
  ACE_UNUSED_ARG(publication);
#endif // !defined (DDS_HAS_MINIMUM_BIT)
}

Here is the call graph for this function:

Here is the caller graph for this function:

void DCPS_IR_Domain::dispose_subscription_bit

(

DCPS_IR_Subscription *

subscription

)

Dispose Subscription in the Subscription Built-In Topic.

Definition at line 1353 of file DCPS_IR_Domain.cpp.

References CORBA::Exception::_tao_print_exception(), ACE_TEXT(), bitSubscriptionDataWriter_, DCPS_IR_Subscription::get_handle(), DCPS_IR_Subscription::is_bit(), LM_ERROR, DDS::RETCODE_OK, and useBIT_.

Referenced by DCPS_IR_Participant::remove_subscription().

{
#if !defined (DDS_HAS_MINIMUM_BIT)

  if (useBIT_) {
    if (!subscription->is_bit()) {
      try {
        DDS::SubscriptionBuiltinTopicData key_data;
        DDS::InstanceHandle_t handle = subscription->get_handle();

        DDS::ReturnCode_t retGetKey
        = bitSubscriptionDataWriter_->get_key_value(key_data,
                                                    handle);

        if (DDS::RETCODE_OK != retGetKey) {
          ACE_ERROR((LM_ERROR,
                     ACE_TEXT("(%P|%t) ERROR: DCPS_IR_Domain::dispose_subscription_bit ")
                     ACE_TEXT("Unable to get_key_value for subscription ptr 0x%x handle %d.  ")
                     ACE_TEXT("Call returned %d.\n"),
                     subscription,
                     handle,
                     retGetKey));
        }

        DDS::ReturnCode_t retDispose =
          bitSubscriptionDataWriter_->dispose(key_data,
                                              handle);

        if (DDS::RETCODE_OK != retDispose) {
          ACE_ERROR((LM_ERROR,
                     ACE_TEXT("(%P|%t) ERROR: DCPS_IR_Domain::dispose_subscription_bit ")
                     ACE_TEXT("Unable to dispose for subscription ptr 0x%x handle %d.  ")
                     ACE_TEXT("Call returned %d.\n"),
                     subscription,
                     handle,
                     retDispose));
        }

      } catch (const CORBA::Exception& ex) {
        ex._tao_print_exception(
          "(%P|%t) ERROR: Exception caught in DCPS_IR_Domain::dispose_subscription_bit:");
      }
    }
  }

#else
  ACE_UNUSED_ARG(subscription);
#endif // !defined (DDS_HAS_MINIMUM_BIT)
}

Here is the call graph for this function:

Here is the caller graph for this function:

void DCPS_IR_Domain::dispose_topic_bit

(

DCPS_IR_Topic *

topic

)

Dispose Topic in the Topic Built-In Topic.

Definition at line 1303 of file DCPS_IR_Domain.cpp.

References CORBA::Exception::_tao_print_exception(), ACE_TEXT(), bitTopicDataWriter_, DCPS_IR_Topic::get_handle(), DCPS_IR_Topic::is_bit(), LM_ERROR, DDS::RETCODE_OK, and useBIT_.

Referenced by remove_topic().

{
#if !defined (DDS_HAS_MINIMUM_BIT)

  if (useBIT_) {
    if (!topic->is_bit()) {
      try {
        DDS::TopicBuiltinTopicData key_data;
        DDS::InstanceHandle_t handle = topic->get_handle();

        DDS::ReturnCode_t retGetKey
        = bitTopicDataWriter_->get_key_value(key_data,
                                             handle);

        if (DDS::RETCODE_OK != retGetKey) {
          ACE_ERROR((LM_ERROR,
                     ACE_TEXT("(%P|%t) ERROR: DCPS_IR_Domain::dispose_topic_bit ")
                     ACE_TEXT("Unable to get_key_value for topic ptr 0x%x handle %d.  ")
                     ACE_TEXT("Call returned %d.\n"),
                     topic,
                     handle,
                     retGetKey));
        }

        DDS::ReturnCode_t retDispose =
          bitTopicDataWriter_->dispose(key_data,
                                       handle);

        if (DDS::RETCODE_OK != retDispose) {
          ACE_ERROR((LM_ERROR,
                     ACE_TEXT("(%P|%t) ERROR: DCPS_IR_Domain::dispose_topic_bit ")
                     ACE_TEXT("Unable to dispose for topic ptr 0x%x handle %d.  ")
                     ACE_TEXT("Call returned %d.\n"),
                     topic,
                     handle,
                     retDispose));
        }

      } catch (const CORBA::Exception& ex) {
        ex._tao_print_exception(
          "(%P|%t) ERROR: Exception caught in DCPS_IR_Domain::dispose_topic_bit:");
      }
    }
  }

#else
  ACE_UNUSED_ARG(topic);
#endif // !defined (DDS_HAS_MINIMUM_BIT)
}

Here is the call graph for this function:

Here is the caller graph for this function:

std::string DCPS_IR_Domain::dump_to_string	(	const std::string &	prefix,
		int	depth
	)			const

Definition at line 1459 of file DCPS_IR_Domain.cpp.

References deadParticipants_, id_, participants_, str, topicDescriptions_, and useBIT_.

{
  std::string str;
#if !defined (OPENDDS_INFOREPO_REDUCED_FOOTPRINT)
  for (int i=0; i < depth; i++)
    str += prefix;
  std::string indent = str + prefix;
  std::ostringstream os;
  os << "DCPS_IR_Domain[" << id_ << "]";
  str += os.str();
  if (useBIT_)
    str += " BITS";
  str += "\n";

  str += indent + "Participants:\n";
  for (DCPS_IR_Participant_Map::const_iterator pm = participants_.begin();
       pm != participants_.end();
       pm++)
  {
    str += pm->second->dump_to_string(prefix, depth+1);
  }

  str += indent + "Dead Participants:\n";
  for (DCPS_IR_Participant_Set::const_iterator dp = deadParticipants_.begin();
       dp != deadParticipants_.end();
       dp++)
  {
    OpenDDS::DCPS::RepoIdConverter sub_converter((*dp)->get_id());
    str += indent + std::string(sub_converter);
    str += "\n";
  }

  str += indent + "Topic Descriptions:\n";
  for (DCPS_IR_Topic_Description_Set::const_iterator tdi = topicDescriptions_.begin();
       tdi != topicDescriptions_.end();
       tdi++)
  {
    str += tdi->second->dump_to_string(prefix, depth+1);
  }
#endif // !defined (OPENDDS_INFOREPO_REDUCED_FOOTPRINT)
  return str;
}

DCPS_IR_Topic * DCPS_IR_Domain::find_topic

(

const OpenDDS::DCPS::RepoId &

id

)

Find a topic object reference using the topic Id value.

Definition at line 352 of file DCPS_IR_Domain.cpp.

References idToTopicMap_.

{
  IdToTopicMap::const_iterator location = this->idToTopicMap_.find(id);

  if (location == this->idToTopicMap_.end()) {
    return 0;
  }

  return location->second.get();
}

OpenDDS::DCPS::TopicStatus DCPS_IR_Domain::find_topic	(	const char *	topicName,
		DCPS_IR_Topic *&	topic
	)

Find the topic with the topic name Does NOT take ownership of any initial memory pointed to by topic Returns OpenDDS::DCPS::FOUND if exists and topic is changed, -1 otherwise

Definition at line 324 of file DCPS_IR_Domain.cpp.

References ACE_TEXT(), OpenDDS::DCPS::DCPS_debug_level, OpenDDS::DCPS::FOUND, DCPS_IR_Topic::get_id(), id_, LM_DEBUG, OpenDDS::DCPS::NOT_FOUND, and topicDescriptions_.

{
  DCPS_IR_Topic_Description_Set::iterator which
  = this->topicDescriptions_.find(topicName);

  if (which != this->topicDescriptions_.end()) {
    // Extract the topic from the description.
    topic = which->second->get_first_topic();

    if (OpenDDS::DCPS::DCPS_debug_level > 0) {
      OpenDDS::DCPS::RepoId topicId = topic->get_id();
      OpenDDS::DCPS::RepoIdConverter converter(topicId);
      ACE_DEBUG((LM_DEBUG,
                 ACE_TEXT("(%P|%t) DCPS_IR_Domain::find_topic: ")
                 ACE_TEXT("located topic %C in domain %d.\n"),
                 std::string(converter).c_str(),
                 id_));
    }

    return OpenDDS::DCPS::FOUND;

  } else {
    // topic = 0;
    return OpenDDS::DCPS::NOT_FOUND;
  }
}

Here is the call graph for this function:

int DCPS_IR_Domain::find_topic_description	(	const char *	name,
		const char *	dataTypeName,
		DCPS_IR_Topic_Description *&	desc
	)			[private]

Find the topic description with the name and data type name Does NOT take ownership of any initial memory pointed to by desc Returns 0 if found and desc is changed, -1 if not found and 1 if conflicting dataTypeName

Definition at line 412 of file DCPS_IR_Domain.cpp.

References ACE_TEXT(), OpenDDS::DCPS::DCPS_debug_level, id_, LM_DEBUG, LM_NOTICE, ACE_OS::strcmp(), and topicDescriptions_.

Referenced by add_topic_description(), and add_topic_i().

{
  DCPS_IR_Topic_Description_Set::iterator which
  = this->topicDescriptions_.find(name);

  if (which != this->topicDescriptions_.end()) {
    if (0 == ACE_OS::strcmp(dataTypeName, which->second->get_dataTypeName())) {
      if (OpenDDS::DCPS::DCPS_debug_level > 0) {
        ACE_DEBUG((LM_DEBUG,
                   ACE_TEXT("(%P|%t) DCPS_IR_Domain::find_topic_description: ")
                   ACE_TEXT("located topic description %C/%C in domain %d.\n"),
                   name,
                   dataTypeName,
                   id_));
      }

      desc = which->second.get();
      return 0;

    } else {
      if (OpenDDS::DCPS::DCPS_debug_level > 0) {
        ACE_DEBUG((LM_NOTICE,
                   ACE_TEXT("(%P|%t) NOTICE: DCPS_IR_Domain::find_topic_description: ")
                   ACE_TEXT("searching for topic description %C/%C, ")
                   ACE_TEXT("located topic description %C/%C instead in domain %d.\n"),
                   name,
                   dataTypeName,
                   which->second->get_name(),
                   which->second->get_dataTypeName(),
                   id_));
      }

      // desc = 0;
      return 1;
    }

  } else {
    // desc = 0;
    return -1;
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

OpenDDS::DCPS::TopicStatus DCPS_IR_Domain::force_add_topic	(	const OpenDDS::DCPS::RepoId &	topicId,
		const char *	topicName,
		const char *	dataTypeName,
		const DDS::TopicQos &	qos,
		DCPS_IR_Participant *	participantPtr
	)

Built-in Topic variables

Definition at line 172 of file DCPS_IR_Domain.cpp.

References add_topic_i(), status, and OpenDDS::DCPS::topicIsBIT().

{
  OpenDDS::DCPS::RepoId topic_id = topicId;
  bool isBIT = OpenDDS::DCPS::topicIsBIT(topicName, dataTypeName);
  OpenDDS::DCPS::TopicStatus status = add_topic_i(topic_id, topicName
                                                  , dataTypeName
                                                  , qos, participantPtr, isBIT);

  return status;
}

Here is the call graph for this function:

DDS::DomainId_t DCPS_IR_Domain::get_id

(

void

)

Definition at line 979 of file DCPS_IR_Domain.cpp.

References id_.

Referenced by DCPS_IR_Participant::remove_all_dependents(), and DCPS_IR_Participant::takeOwnership().

{
  return id_;
}

Here is the caller graph for this function:

OpenDDS::DCPS::RepoId DCPS_IR_Domain::get_next_participant_id

(

)

Next Entity Id value in sequence.

Definition at line 985 of file DCPS_IR_Domain.cpp.

References OpenDDS::DCPS::RepoIdGenerator::next(), and participantIdGenerator_.

Referenced by TAO_DDS_DCPSInfo_i::add_domain_participant().

{
  return this->participantIdGenerator_.next();
}

Here is the call graph for this function:

Here is the caller graph for this function:

int DCPS_IR_Domain::init_built_in_topics	(	bool	federated,
		bool	persistent
	)

Initialize the Built-In Topic structures This needs to be called before the run begins Returns 0 (zero) if successful

Definition at line 458 of file DCPS_IR_Domain.cpp.

Referenced by TAO_DDS_DCPSInfo_i::domain().

{
  return 1;
}

Here is the caller graph for this function:

int DCPS_IR_Domain::init_built_in_topics_datawriters

(

bool

federated

)

[private]

Built-in Topic variables

Definition at line 694 of file DCPS_IR_Domain.cpp.

{
  return 1;
}

int DCPS_IR_Domain::init_built_in_topics_topics

(

)

[private]

work of initializing the built in topics is done in these private methods. They were broken up for readability.

Definition at line 559 of file DCPS_IR_Domain.cpp.

References CORBA::Exception::_tao_print_exception(), ACE_TEXT(), bitParticipant_, bitParticipantTopic_, bitPublicationTopic_, bitSubscriptionTopic_, bitTopicTopic_, OpenDDS::DCPS::BUILT_IN_PARTICIPANT_TOPIC, OpenDDS::DCPS::BUILT_IN_PARTICIPANT_TOPIC_TYPE, OpenDDS::DCPS::BUILT_IN_PUBLICATION_TOPIC, OpenDDS::DCPS::BUILT_IN_PUBLICATION_TOPIC_TYPE, OpenDDS::DCPS::BUILT_IN_SUBSCRIPTION_TOPIC, OpenDDS::DCPS::BUILT_IN_SUBSCRIPTION_TOPIC_TYPE, OpenDDS::DCPS::BUILT_IN_TOPIC_TOPIC, OpenDDS::DCPS::BUILT_IN_TOPIC_TOPIC_TYPE, OpenDDS::DCPS::DEFAULT_STATUS_MASK, CORBA::is_nil(), LM_ERROR, and DDS::RETCODE_OK.

{
#if !defined (DDS_HAS_MINIMUM_BIT)

  try {
    DDS::TopicQos topic_qos;
    bitParticipant_->get_default_topic_qos(topic_qos);

    // Participant topic
    DDS::ParticipantBuiltinTopicDataTypeSupport_var
    participantTypeSupport(new DDS::ParticipantBuiltinTopicDataTypeSupportImpl());

    if (DDS::RETCODE_OK !=
        participantTypeSupport->register_type(bitParticipant_.in(),
                                              OpenDDS::DCPS::BUILT_IN_PARTICIPANT_TOPIC_TYPE)) {
      ACE_ERROR((LM_ERROR,
                 ACE_TEXT("(%P|%t) ERROR: Failed to register the ParticipantBuiltinTopicDataTypeSupport.")));
      return 1;
    }

    bitParticipantTopic_ =
      bitParticipant_->create_topic(OpenDDS::DCPS::BUILT_IN_PARTICIPANT_TOPIC,
                                    OpenDDS::DCPS::BUILT_IN_PARTICIPANT_TOPIC_TYPE,
                                    topic_qos,
                                    DDS::TopicListener::_nil(),
                                    OpenDDS::DCPS::DEFAULT_STATUS_MASK);

    if (CORBA::is_nil(bitParticipantTopic_.in())) {
      ACE_ERROR_RETURN((LM_ERROR,
                        ACE_TEXT("(%P|%t) ERROR: ")
                        ACE_TEXT("Nil %C Topic from ")
                        ACE_TEXT("DCPS_IR_Domain::init_built_in_topics.\n"),
                        OpenDDS::DCPS::BUILT_IN_PARTICIPANT_TOPIC),
                       1);
    }

    // Topic topic
    DDS::TopicBuiltinTopicDataTypeSupport_var
    topicTypeSupport(new DDS::TopicBuiltinTopicDataTypeSupportImpl());

    if (DDS::RETCODE_OK !=
        topicTypeSupport->register_type(bitParticipant_.in(),
                                        OpenDDS::DCPS::BUILT_IN_TOPIC_TOPIC_TYPE)) {
      ACE_ERROR((LM_ERROR,
                 ACE_TEXT("(%P|%t) ERROR: Failed to register the TopicBuiltinTopicDataTypeSupport.")));
      return 1;
    }

    bitTopicTopic_ =
      bitParticipant_->create_topic(OpenDDS::DCPS::BUILT_IN_TOPIC_TOPIC,
                                    OpenDDS::DCPS::BUILT_IN_TOPIC_TOPIC_TYPE,
                                    topic_qos,
                                    DDS::TopicListener::_nil(),
                                    OpenDDS::DCPS::DEFAULT_STATUS_MASK);

    if (CORBA::is_nil(bitTopicTopic_.in())) {
      ACE_ERROR_RETURN((LM_ERROR,
                        ACE_TEXT("(%P|%t) ERROR: ")
                        ACE_TEXT("Nil %C Topic from ")
                        ACE_TEXT("DCPS_IR_Domain::init_built_in_topics.\n"),
                        OpenDDS::DCPS::BUILT_IN_TOPIC_TOPIC),
                       1);
    }

    // Subscription topic
    DDS::SubscriptionBuiltinTopicDataTypeSupport_var
    subscriptionTypeSupport(new DDS::SubscriptionBuiltinTopicDataTypeSupportImpl());

    if (DDS::RETCODE_OK !=
        subscriptionTypeSupport->register_type(bitParticipant_.in(),
                                               OpenDDS::DCPS::BUILT_IN_SUBSCRIPTION_TOPIC_TYPE)) {
      ACE_ERROR((LM_ERROR,
                 ACE_TEXT("(%P|%t) ERROR: Failed to register the SubscriptionBuiltinTopicDataTypeSupport.")));
      return 1;
    }

    bitSubscriptionTopic_ =
      bitParticipant_->create_topic(OpenDDS::DCPS::BUILT_IN_SUBSCRIPTION_TOPIC,
                                    OpenDDS::DCPS::BUILT_IN_SUBSCRIPTION_TOPIC_TYPE,
                                    topic_qos,
                                    DDS::TopicListener::_nil(),
                                    OpenDDS::DCPS::DEFAULT_STATUS_MASK);

    if (CORBA::is_nil(bitSubscriptionTopic_.in())) {
      ACE_ERROR_RETURN((LM_ERROR,
                        ACE_TEXT("(%P|%t) ERROR: ")
                        ACE_TEXT("Nil %C Topic from ")
                        ACE_TEXT("DCPS_IR_Domain::init_built_in_topics.\n"),
                        OpenDDS::DCPS::BUILT_IN_SUBSCRIPTION_TOPIC),
                       1);
    }

    // Publication topic
    DDS::PublicationBuiltinTopicDataTypeSupport_var
    publicationTypeSupport(new DDS::PublicationBuiltinTopicDataTypeSupportImpl());

    if (DDS::RETCODE_OK !=
        publicationTypeSupport->register_type(bitParticipant_.in(),
                                              OpenDDS::DCPS::BUILT_IN_PUBLICATION_TOPIC_TYPE)) {
      ACE_ERROR((LM_ERROR,
                 ACE_TEXT("(%P|%t) ERROR: Failed to register the PublicationBuiltinTopicDataTypeSupport.")));
      return 1;
    }

    bitPublicationTopic_ =
      bitParticipant_->create_topic(OpenDDS::DCPS::BUILT_IN_PUBLICATION_TOPIC,
                                    OpenDDS::DCPS::BUILT_IN_PUBLICATION_TOPIC_TYPE,
                                    topic_qos,
                                    DDS::TopicListener::_nil(),
                                    OpenDDS::DCPS::DEFAULT_STATUS_MASK);

    if (CORBA::is_nil(bitPublicationTopic_.in())) {
      ACE_ERROR_RETURN((LM_ERROR,
                        ACE_TEXT("(%P|%t) ERROR: ")
                        ACE_TEXT("Nil %C Topic from ")
                        ACE_TEXT("DCPS_IR_Domain::init_built_in_topics.\n"),
                        OpenDDS::DCPS::BUILT_IN_PUBLICATION_TOPIC),
                       1);
    }

  } catch (const CORBA::Exception& ex) {
    ex._tao_print_exception(
      "ERROR: Exception caught in DCPS_IR_Domain::init_built_in_topics_topics:");
    return 1;
  }

  return 0;

#else

  return 1;
#endif // !defined (DDS_HAS_MINIMUM_BIT)
}

Here is the call graph for this function:

int DCPS_IR_Domain::init_built_in_topics_transport

(

bool

persistent

)

[private]

Built-in Topic variables

Definition at line 801 of file DCPS_IR_Domain.cpp.

References CORBA::Exception::_tao_print_exception(), ACE_TEXT(), bitParticipant_, bitPublisher_, OpenDDS::DCPS::TransportRegistry::DEFAULT_INST_PREFIX, OpenDDS::DCPS::DEFAULT_STATUS_MASK, OpenDDS::DCPS::TransportRegistry::instance(), CORBA::is_nil(), LM_ERROR, PUBLISHER_QOS_DEFAULT, transportConfig_, and DDS::DataWriterQos::writer_data_lifecycle.

{
#if !defined (DDS_HAS_MINIMUM_BIT)

  try {
    std::string config_name =
      OpenDDS::DCPS::TransportRegistry::DEFAULT_INST_PREFIX
      + std::string("InfoRepoBITTransportConfig");
    transportConfig_ =
      OpenDDS::DCPS::TransportRegistry::instance()->get_config(config_name);

    // Create the Publisher
    bitPublisher_ =
      bitParticipant_->create_publisher(PUBLISHER_QOS_DEFAULT,
                                        DDS::PublisherListener::_nil(),
                                        OpenDDS::DCPS::DEFAULT_STATUS_MASK);

    if (CORBA::is_nil(bitPublisher_.in())) {
      ACE_ERROR_RETURN((LM_ERROR,
                        ACE_TEXT("(%P|%t) ERROR: ")
                        ACE_TEXT("Nil Publisher from ")
                        ACE_TEXT("DCPS_IR_Domain::init_built_in_topics.\n")),
                       1);
    }

    // If persistence is active, do not have remote readers autodispose data
    if (persistent) {
      DDS::DataWriterQos qos;
      bitPublisher_->get_default_datawriter_qos(qos);
      qos.writer_data_lifecycle.autodispose_unregistered_instances = false;
      bitPublisher_->set_default_datawriter_qos(qos);
    }

    // Attach the Publisher with the TransportImpl.
    OpenDDS::DCPS::TransportRegistry::instance()->bind_config(transportConfig_,
                                                              bitPublisher_.in());

  } catch (const CORBA::Exception& ex) {
    ex._tao_print_exception(
      "ERROR: Exception caught in DCPS_IR_Domain::init_built_in_topics_transport:");
    return 1;
  }

  return 0;
#else

  return 1;
#endif // !defined (DDS_HAS_MINIMUM_BIT)
}

Here is the call graph for this function:

void DCPS_IR_Domain::last_participant_key

(

long

key

)

Ensure no conflicts with sequence values from persistent storage.

Definition at line 991 of file DCPS_IR_Domain.cpp.

References OpenDDS::DCPS::RepoIdGenerator::last(), and participantIdGenerator_.

{
  this->participantIdGenerator_.last(key);
}

Here is the call graph for this function:

DCPS_IR_Participant * DCPS_IR_Domain::participant

(

const OpenDDS::DCPS::RepoId &

id

)

const

Find the participant with the id.

Definition at line 56 of file DCPS_IR_Domain.cpp.

References participants_.

Referenced by TAO_DDS_DCPSInfo_i::add_domain_participant(), TAO_DDS_DCPSInfo_i::add_subscription(), and remove_participant().

{
  DCPS_IR_Participant_Map::const_iterator where
  = this->participants_.find(id);

  if (where != this->participants_.end()) {
    return where->second.in();

  } else {
    return 0;
  }
}

Here is the caller graph for this function:

const DCPS_IR_Participant_Map & DCPS_IR_Domain::participants

(

)

const

Expose a readable reference to the participant map.

Definition at line 50 of file DCPS_IR_Domain.cpp.

References participants_.

Referenced by TAO_DDS_DCPSInfo_i::add_domain_participant().

{
  return this->participants_;
}

Here is the caller graph for this function:

void DCPS_IR_Domain::publish_participant_bit

(

DCPS_IR_Participant *

participant

)

Publish Participant in the Participant Built-In Topic.

Definition at line 1009 of file DCPS_IR_Domain.cpp.

References CORBA::Exception::_tao_print_exception(), bitParticipantDataWriter_, OpenDDS::DCPS::DCPS_debug_level, DCPS_IR_Participant::get_id(), DCPS_IR_Participant::get_qos(), DCPS_IR_Participant::isBitPublisher(), DDS::ParticipantBuiltinTopicData::key, LM_DEBUG, DCPS_IR_Participant::set_handle(), useBIT_, DDS::DomainParticipantQos::user_data, and DDS::ParticipantBuiltinTopicData::user_data.

Referenced by add_participant(), and DCPS_IR_Participant::set_qos().

{
#if !defined (DDS_HAS_MINIMUM_BIT)

  if (useBIT_ && !participant->isBitPublisher()) {
    try {
      const DDS::DomainParticipantQos* participantQos = participant->get_qos();

      DDS::ParticipantBuiltinTopicData data;
      get_BuiltinTopicKey(data.key, participant->get_id());
      data.user_data = participantQos->user_data;

      DDS::InstanceHandle_t handle
      = bitParticipantDataWriter_->register_instance(data);

      participant->set_handle(handle);

      if (OpenDDS::DCPS::DCPS_debug_level > 0) {
        ACE_DEBUG((LM_DEBUG,
                   "(%P|%t) DCPS_IR_Domain::publish_participant_bit: [ %d, 0x%x, 0x%x], handle %d.\n",
                   data.key.value[0], data.key.value[1], data.key.value[2], handle));
      }

      bitParticipantDataWriter_->write(data, handle);

    } catch (const CORBA::Exception& ex) {
      ex._tao_print_exception(
        "(%P|%t) ERROR: Exception caught in DCPS_IR_Domain::publish_participant_bit:");
    }
  }

#else
  ACE_UNUSED_ARG(participant);
#endif // !defined (DDS_HAS_MINIMUM_BIT)
}

Here is the call graph for this function:

Here is the caller graph for this function:

void DCPS_IR_Domain::publish_publication_bit

(

DCPS_IR_Publication *

publication

)

Publish Publication in the Publication Built-In Topic.

Definition at line 1174 of file DCPS_IR_Domain.cpp.

References CORBA::Exception::_tao_print_exception(), bitPublicationDataWriter_, OpenDDS::DCPS::BUILT_IN_PARTICIPANT_TOPIC_TYPE, OpenDDS::DCPS::BUILT_IN_PUBLICATION_TOPIC_TYPE, OpenDDS::DCPS::BUILT_IN_SUBSCRIPTION_TOPIC_TYPE, OpenDDS::DCPS::BUILT_IN_TOPIC_TOPIC_TYPE, OpenDDS::DCPS::DCPS_debug_level, DDS::DataWriterQos::deadline, DDS::PublicationBuiltinTopicData::deadline, DDS::DataWriterQos::destination_order, DDS::PublicationBuiltinTopicData::destination_order, DDS::DataWriterQos::durability, DDS::PublicationBuiltinTopicData::durability, DDS::DataWriterQos::durability_service, DDS::PublicationBuiltinTopicData::durability_service, DCPS_IR_Topic_Description::get_dataTypeName(), DCPS_IR_Publication::get_datawriter_qos(), DCPS_IR_Publication::get_id(), DCPS_IR_Topic_Description::get_name(), DCPS_IR_Publication::get_participant_id(), DCPS_IR_Publication::get_publisher_qos(), DCPS_IR_Publication::get_topic(), DCPS_IR_Publication::get_topic_description(), DCPS_IR_Topic::get_topic_qos(), DDS::PublisherQos::group_data, DDS::PublicationBuiltinTopicData::group_data, DDS::PublicationBuiltinTopicData::key, DDS::DataWriterQos::latency_budget, DDS::PublicationBuiltinTopicData::latency_budget, DDS::DataWriterQos::lifespan, DDS::PublicationBuiltinTopicData::lifespan, DDS::DataWriterQos::liveliness, DDS::PublicationBuiltinTopicData::liveliness, LM_DEBUG, LM_ERROR, DDS::DataWriterQos::ownership, DDS::PublicationBuiltinTopicData::ownership, DDS::DataWriterQos::ownership_strength, DDS::PublicationBuiltinTopicData::ownership_strength, DDS::PublicationBuiltinTopicData::participant_key, DDS::PublisherQos::partition, DDS::PublicationBuiltinTopicData::partition, DDS::PublisherQos::presentation, DDS::PublicationBuiltinTopicData::presentation, DDS::DataWriterQos::reliability, DDS::PublicationBuiltinTopicData::reliability, DDS::RETCODE_OK, DCPS_IR_Publication::set_bit_status(), DCPS_IR_Publication::set_handle(), status, ACE_OS::strcmp(), DDS::TopicQos::topic_data, DDS::PublicationBuiltinTopicData::topic_data, DDS::PublicationBuiltinTopicData::topic_name, DDS::PublicationBuiltinTopicData::type_name, useBIT_, DDS::DataWriterQos::user_data, and DDS::PublicationBuiltinTopicData::user_data.

Referenced by DCPS_IR_Topic::add_publication_reference(), DCPS_IR_Publication::set_qos(), and DCPS_IR_Topic::set_topic_qos().

{
#if !defined (DDS_HAS_MINIMUM_BIT)

  if (useBIT_) {

    DCPS_IR_Topic_Description* desc =
      publication->get_topic_description();

    const char* dataTypeName = desc->get_dataTypeName();

    bool isNotBIT =
      ACE_OS::strcmp(dataTypeName, OpenDDS::DCPS::BUILT_IN_PARTICIPANT_TOPIC_TYPE) &&
      ACE_OS::strcmp(dataTypeName, OpenDDS::DCPS::BUILT_IN_TOPIC_TOPIC_TYPE) &&
      ACE_OS::strcmp(dataTypeName, OpenDDS::DCPS::BUILT_IN_SUBSCRIPTION_TOPIC_TYPE) &&
      ACE_OS::strcmp(dataTypeName, OpenDDS::DCPS::BUILT_IN_PUBLICATION_TOPIC_TYPE);

    if (isNotBIT) {
      try {
        const DDS::DataWriterQos* writerQos = publication->get_datawriter_qos();
        const DDS::PublisherQos* publisherQos = publication->get_publisher_qos();

        DCPS_IR_Topic* topic = publication->get_topic();
        const DDS::TopicQos* topicQos = topic->get_topic_qos();

        DDS::PublicationBuiltinTopicData data;
        get_BuiltinTopicKey(data.key, publication->get_id());
        get_BuiltinTopicKey(data.participant_key,
                            publication->get_participant_id());
        data.topic_name = desc->get_name();
        data.type_name = desc->get_dataTypeName();
        data.durability = writerQos->durability;
        data.durability_service = writerQos->durability_service;
        data.deadline = writerQos->deadline;
        data.latency_budget = writerQos->latency_budget;
        data.liveliness = writerQos->liveliness;
        data.reliability = writerQos->reliability;
        data.lifespan = writerQos->lifespan;
        data.user_data = writerQos->user_data;
        data.ownership = writerQos->ownership;
        data.ownership_strength = writerQos->ownership_strength;
        data.destination_order = writerQos->destination_order;
        data.presentation = publisherQos->presentation;
        data.partition = publisherQos->partition;
        data.topic_data = topicQos->topic_data;
        data.group_data = publisherQos->group_data;

        DDS::InstanceHandle_t handle
        = bitPublicationDataWriter_->register_instance(data);

        publication->set_handle(handle);

        if (OpenDDS::DCPS::DCPS_debug_level > 0) {
          ACE_DEBUG((LM_DEBUG,
                     "(%P|%t) DCPS_IR_Domain::publish_publication_bit: [ %d, 0x%x, 0x%x], handle %d.\n",
                     data.key.value[0], data.key.value[1], data.key.value[2], handle));
        }

        DDS::ReturnCode_t status = bitPublicationDataWriter_->write(data, handle);
        if (status != DDS::RETCODE_OK) {
          ACE_ERROR((LM_ERROR,
                       "(%P|%t) DCPS_IR_Domain::publish_publication_bit: write() status of %d\n",
                       status));
        }

      } catch (const CORBA::Exception& ex) {
        ex._tao_print_exception(
          "(%P|%t) ERROR: Exception caught in DCPS_IR_Domain::publish_publication_bit:");
      }

    } else {
      publication->set_bit_status(1);
    }
  }

#else
  ACE_UNUSED_ARG(publication);
#endif // !defined (DDS_HAS_MINIMUM_BIT)

}

Here is the call graph for this function:

Here is the caller graph for this function:

void DCPS_IR_Domain::publish_subscription_bit

(

DCPS_IR_Subscription *

subscription

)

Publish Subscription in the Subscription Built-In Topic.

Definition at line 1105 of file DCPS_IR_Domain.cpp.

References CORBA::Exception::_tao_print_exception(), bitSubscriptionDataWriter_, OpenDDS::DCPS::DCPS_debug_level, DDS::DataReaderQos::deadline, DDS::SubscriptionBuiltinTopicData::deadline, DDS::DataReaderQos::destination_order, DDS::SubscriptionBuiltinTopicData::destination_order, DDS::DataReaderQos::durability, DDS::SubscriptionBuiltinTopicData::durability, DCPS_IR_Subscription::get_datareader_qos(), DCPS_IR_Topic_Description::get_dataTypeName(), DCPS_IR_Subscription::get_id(), DCPS_IR_Topic_Description::get_name(), DCPS_IR_Subscription::get_participant_id(), DCPS_IR_Subscription::get_subscriber_qos(), DCPS_IR_Subscription::get_topic(), DCPS_IR_Subscription::get_topic_description(), DCPS_IR_Topic::get_topic_qos(), DDS::SubscriberQos::group_data, DDS::SubscriptionBuiltinTopicData::group_data, DDS::SubscriptionBuiltinTopicData::key, DDS::DataReaderQos::latency_budget, DDS::SubscriptionBuiltinTopicData::latency_budget, DDS::DataReaderQos::liveliness, DDS::SubscriptionBuiltinTopicData::liveliness, LM_DEBUG, DDS::DataReaderQos::ownership, DDS::SubscriptionBuiltinTopicData::ownership, DDS::SubscriptionBuiltinTopicData::participant_key, DDS::SubscriberQos::partition, DDS::SubscriptionBuiltinTopicData::partition, DDS::SubscriberQos::presentation, DDS::SubscriptionBuiltinTopicData::presentation, DDS::DataReaderQos::reliability, DDS::SubscriptionBuiltinTopicData::reliability, DCPS_IR_Subscription::set_bit_status(), DCPS_IR_Subscription::set_handle(), DDS::DataReaderQos::time_based_filter, DDS::SubscriptionBuiltinTopicData::time_based_filter, DDS::TopicQos::topic_data, DDS::SubscriptionBuiltinTopicData::topic_data, DDS::SubscriptionBuiltinTopicData::topic_name, OpenDDS::DCPS::topicIsBIT(), DDS::SubscriptionBuiltinTopicData::type_name, useBIT_, DDS::DataReaderQos::user_data, and DDS::SubscriptionBuiltinTopicData::user_data.

Referenced by DCPS_IR_Topic_Description::add_subscription_reference(), DCPS_IR_Subscription::set_qos(), and DCPS_IR_Topic::set_topic_qos().

{

#if !defined (DDS_HAS_MINIMUM_BIT)

  if (useBIT_) {
    DCPS_IR_Topic_Description* desc =
      subscription->get_topic_description();
    const char* name = desc->get_name();
    const char* type = desc->get_dataTypeName();

    if (!OpenDDS::DCPS::topicIsBIT(name, type)) {
      try {
        const DDS::DataReaderQos* readerQos = subscription->get_datareader_qos();
        const DDS::SubscriberQos* publisherQos = subscription->get_subscriber_qos();

        DCPS_IR_Topic* topic = subscription->get_topic();
        const DDS::TopicQos* topicQos = topic->get_topic_qos();

        DDS::SubscriptionBuiltinTopicData data;
        get_BuiltinTopicKey(data.key, subscription->get_id());
        get_BuiltinTopicKey(data.participant_key,
                            subscription->get_participant_id());
        data.topic_name = name;
        data.type_name = type;
        data.durability = readerQos->durability;
        data.deadline = readerQos->deadline;
        data.latency_budget = readerQos->latency_budget;
        data.liveliness = readerQos->liveliness;
        data.reliability = readerQos->reliability;
        data.ownership = readerQos->ownership;
        data.destination_order = readerQos->destination_order;
        data.user_data = readerQos->user_data;
        data.time_based_filter = readerQos->time_based_filter;
        data.presentation = publisherQos->presentation;
        data.partition = publisherQos->partition;
        data.topic_data = topicQos->topic_data;
        data.group_data = publisherQos->group_data;

        DDS::InstanceHandle_t handle
        = bitSubscriptionDataWriter_->register_instance(data);

        subscription->set_handle(handle);

        if (OpenDDS::DCPS::DCPS_debug_level > 0) {
          ACE_DEBUG((LM_DEBUG,
                     "(%P|%t) DCPS_IR_Domain::publish_subscription_bit: [ %d, 0x%x, 0x%x], handle %d.\n",
                     data.key.value[0], data.key.value[1], data.key.value[2], handle));
        }

        bitSubscriptionDataWriter_->write(data,
                                          handle);

      } catch (const CORBA::Exception& ex) {
        ex._tao_print_exception(
          "(%P|%t) ERROR: Exception caught in DCPS_IR_Domain::publish_subscription_bit:");
      }

    } else {
      subscription->set_bit_status(1);
    }
  }

#else
  ACE_UNUSED_ARG(subscription);
#endif // !defined (DDS_HAS_MINIMUM_BIT)

}

Here is the call graph for this function:

Here is the caller graph for this function:

void DCPS_IR_Domain::publish_topic_bit

(

DCPS_IR_Topic *

topic

)

Publish Topic in the Topic Built-In Topic.

Definition at line 1045 of file DCPS_IR_Domain.cpp.

References CORBA::Exception::_tao_print_exception(), bitTopicDataWriter_, OpenDDS::DCPS::DCPS_debug_level, DDS::TopicQos::deadline, DDS::TopicBuiltinTopicData::deadline, DDS::TopicQos::destination_order, DDS::TopicBuiltinTopicData::destination_order, DDS::TopicQos::durability, DDS::TopicBuiltinTopicData::durability, DDS::TopicQos::durability_service, DDS::TopicBuiltinTopicData::durability_service, DCPS_IR_Topic_Description::get_dataTypeName(), DCPS_IR_Topic::get_id(), DCPS_IR_Topic_Description::get_name(), DCPS_IR_Topic::get_topic_description(), DCPS_IR_Topic::get_topic_qos(), DDS::TopicQos::history, DDS::TopicBuiltinTopicData::history, DDS::TopicBuiltinTopicData::key, DDS::TopicQos::latency_budget, DDS::TopicBuiltinTopicData::latency_budget, DDS::TopicQos::lifespan, DDS::TopicBuiltinTopicData::lifespan, DDS::TopicQos::liveliness, DDS::TopicBuiltinTopicData::liveliness, LM_DEBUG, DDS::TopicBuiltinTopicData::name, DDS::TopicQos::ownership, DDS::TopicBuiltinTopicData::ownership, DDS::TopicQos::reliability, DDS::TopicBuiltinTopicData::reliability, DDS::TopicQos::resource_limits, DDS::TopicBuiltinTopicData::resource_limits, DCPS_IR_Topic::set_bit_status(), DCPS_IR_Topic::set_handle(), DDS::TopicQos::topic_data, DDS::TopicBuiltinTopicData::topic_data, OpenDDS::DCPS::topicIsBIT(), DDS::TopicQos::transport_priority, DDS::TopicBuiltinTopicData::transport_priority, DDS::TopicBuiltinTopicData::type_name, and useBIT_.

Referenced by add_topic_i(), and DCPS_IR_Topic::set_topic_qos().

{
#if !defined (DDS_HAS_MINIMUM_BIT)

  if (useBIT_) {
    DCPS_IR_Topic_Description* desc =
      topic->get_topic_description();
    const char* name = desc->get_name();
    const char* type = desc->get_dataTypeName();

    if (!OpenDDS::DCPS::topicIsBIT(name, type)) {
      try {
        const DDS::TopicQos* topicQos = topic->get_topic_qos();

        DDS::TopicBuiltinTopicData data;
        get_BuiltinTopicKey(data.key, topic->get_id());
        data.name = name;
        data.type_name = type;
        data.durability = topicQos->durability;
        data.durability_service = topicQos->durability_service;
        data.deadline = topicQos->deadline;
        data.latency_budget = topicQos->latency_budget;
        data.liveliness = topicQos->liveliness;
        data.reliability = topicQos->reliability;
        data.transport_priority = topicQos->transport_priority;
        data.lifespan = topicQos->lifespan;
        data.destination_order = topicQos->destination_order;
        data.history = topicQos->history;
        data.resource_limits = topicQos->resource_limits;
        data.ownership = topicQos->ownership;
        data.topic_data = topicQos->topic_data;

        DDS::InstanceHandle_t handle =
          bitTopicDataWriter_->register_instance(data);

        topic->set_handle(handle);

        if (OpenDDS::DCPS::DCPS_debug_level > 0) {
          ACE_DEBUG((LM_DEBUG,
                     "(%P|%t) DCPS_IR_Domain::publish_topic_bit: [ %d, 0x%x, 0x%x], handle %d.\n",
                     data.key.value[0], data.key.value[1], data.key.value[2], handle));
        }

        bitTopicDataWriter_->write(data, handle);

      } catch (const CORBA::Exception& ex) {
        ex._tao_print_exception(
          "(%P|%t) ERROR: Exception caught in DCPS_IR_Domain::publish_topic_bit:");
      }

    } else {
      topic->set_bit_status(1);
    }
  }

#else
  ACE_UNUSED_ARG(topic);
#endif // !defined (DDS_HAS_MINIMUM_BIT)
}

Here is the call graph for this function:

Here is the caller graph for this function:

int DCPS_IR_Domain::reassociate_built_in_topic_pubs

(

)

Reassociate the Built-In Topic datawriters This needs to be called after reincarnating from persistence and before the run begins Returns 0 (zero) if successful

Definition at line 525 of file DCPS_IR_Domain.cpp.

{
  return 1;
}

void DCPS_IR_Domain::remove_dead_participants

(

)

Remove any participants currently marked as dead.

Definition at line 951 of file DCPS_IR_Domain.cpp.

References ACE_TEXT(), dead, deadParticipants_, OpenDDS::DCPS::RcHandle< T >::in(), LM_ERROR, and remove_participant().

Referenced by TAO_DDS_DCPSInfo_i::add_subscription().

{
  if (0 < deadParticipants_.size()) {
    DCPS_IR_Participant_rch dead;
    DCPS_IR_Participant_Set::iterator iter = deadParticipants_.begin();

    // repeat end() due to the value possibly changing from additional dead
    // participants during notifications
    while (iter != deadParticipants_.end()) {
      dead = *iter;
      ++iter;

      OpenDDS::DCPS::RepoIdConverter converter(dead->get_id());
      ACE_ERROR((LM_ERROR,
                 ACE_TEXT("(%P|%t) ERROR: DCPS_IR_Domain::remove_dead_participants () ")
                 ACE_TEXT("Removing dead participant 0x%x id %C\n"),
                 dead.in(),
                 std::string(converter).c_str()));
      deadParticipants_.erase(dead);

      dead->set_alive(0);

      CORBA::Boolean notify_lost = 1;
      remove_participant(dead->get_id(), notify_lost);
    }
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

int DCPS_IR_Domain::remove_participant	(	const OpenDDS::DCPS::RepoId &	particpantId,
		CORBA::Boolean	notify_lost
	)

Remove the particpant The participant has been deleted if returns successful. Returns 0 if successful. The notify_lost parameter is passed to the remove_associations() See the comments of remove_associations() in DataWriterRemote.idl or DataReaderRemote.idl.

Definition at line 109 of file DCPS_IR_Domain.cpp.

References ACE_TEXT(), OpenDDS::DCPS::DCPS_debug_level, dispose_participant_bit(), OpenDDS::DCPS::RcHandle< T >::get(), id_, OpenDDS::DCPS::RcHandle< T >::in(), LM_DEBUG, LM_ERROR, participant(), and participants_.

Referenced by remove_dead_participants().

{
  DCPS_IR_Participant_Map::iterator where
  = this->participants_.find(participantId);

  if (where != this->participants_.end()) {
    // Extract the participant from the map.
    DCPS_IR_Participant_rch participant = where->second;

    // make sure the participant has cleaned up all publications,
    // subscriptions, and any topic references
    participant->remove_all_dependents(notify_lost);

    // Then remove it from the map.
    this->participants_.erase(where);

    if (OpenDDS::DCPS::DCPS_debug_level > 0) {
      OpenDDS::DCPS::RepoIdConverter converter(participantId);
      ACE_DEBUG((LM_DEBUG,
                 ACE_TEXT("(%P|%t) DCPS_IR_Domain::remove_participant: ")
                 ACE_TEXT("removed participant %C at 0x%x from domain %d.\n"),
                 std::string(converter).c_str(),
                 participant.in(),
                 id_));
    }

    dispose_participant_bit(participant.get());
    return 0;

  } else {
    OpenDDS::DCPS::RepoIdConverter converter(participantId);
    ACE_ERROR((LM_ERROR,
               ACE_TEXT("(%P|%t) ERROR: DCPS_IR_Domain::remove_participant: ")
               ACE_TEXT("unable to find participant %C in domain %d.\n"),
               std::string(converter).c_str(),
               id_));
    return 1;
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

OpenDDS::DCPS::TopicStatus DCPS_IR_Domain::remove_topic	(	DCPS_IR_Participant *	part,
		DCPS_IR_Topic *&	topic
	)

Remove the topic The topic has been deleted if returns successful Returns OpenDDS::DCPS::REMOVED if successful

Definition at line 363 of file DCPS_IR_Domain.cpp.

References ACE_TEXT(), dispose_topic_bit(), DCPS_IR_Topic_Description::get_dataTypeName(), DCPS_IR_Participant::get_id(), DCPS_IR_Topic::get_id(), DCPS_IR_Topic_Description::get_name(), DCPS_IR_Topic_Description::get_number_topics(), DCPS_IR_Topic::get_topic_description(), id_, LM_ERROR, DCPS_IR_Topic::release(), DCPS_IR_Topic_Description::remove_topic(), remove_topic_description(), DCPS_IR_Participant::remove_topic_reference(), and OpenDDS::DCPS::REMOVED.

Referenced by DCPS_IR_Participant::remove_all_dependents().

{
  DCPS_IR_Topic_Description* description = topic->get_topic_description();

  if (description->remove_topic(topic) != 0) {
    // An unknown error means that the description may still
    // have the topic in its topic set.  We can't remove it.
    // The system is an inconsistent state!
    throw OpenDDS::DCPS::Invalid_Topic();
  }

  if (description->get_number_topics() == 0) {
    // Remove the topic description
    if (remove_topic_description(description) != 0) {
      // An unknown error means that the description may still
      // have the topic in its topic set.
      ACE_ERROR((LM_ERROR,
                 ACE_TEXT("(%P|%t) ERROR: Topic Description %C %C  ")
                 ACE_TEXT("was not correctly removed from Domain %d"),
                 description->get_name(),
                 description->get_dataTypeName(),
                 id_));

    }
  }

  // description variable is invalid after this point

  if (part->remove_topic_reference(topic->get_id(), topic) != 0) {
    OpenDDS::DCPS::RepoIdConverter part_converter(part->get_id());
    OpenDDS::DCPS::RepoIdConverter topic_converter(topic->get_id());
    ACE_ERROR((LM_ERROR,
               ACE_TEXT("(%P|%t) ERROR: Domain %d Topic %C ")
               ACE_TEXT("was not correctly removed from Participant %C"),
               id_,
               std::string(topic_converter).c_str(),
               std::string(part_converter).c_str()));
  }

  // Dispose the BIT information
  dispose_topic_bit(topic);

  topic->release(true);
  topic = 0;
  return OpenDDS::DCPS::REMOVED;
}

Here is the call graph for this function:

Here is the caller graph for this function:

int DCPS_IR_Domain::remove_topic_description

(

DCPS_IR_Topic_Description *

desc

)

[private]

Returns 0 if successful.

Definition at line 927 of file DCPS_IR_Domain.cpp.

References ACE_TEXT(), DCPS_IR_Topic_Description::get_name(), id_, LM_ERROR, and topicDescriptions_.

Referenced by remove_topic().

{
  DCPS_IR_Topic_Description_Set::iterator where
  = this->topicDescriptions_.find(desc->get_name());

  if (where != this->topicDescriptions_.end()) {
    this->topicDescriptions_.erase(where);
    return 0;

  } else {
    ACE_ERROR((LM_ERROR,
               ACE_TEXT("(%P|%t) ERROR: DCPS_IR_Domain::remove_topic_description: ")
               ACE_TEXT("unable to remove Topic Description 0x%x from domain %d.\n"),
               desc,
               id_));
    return -1;
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

void DCPS_IR_Domain::remove_topic_id_mapping

(

const OpenDDS::DCPS::RepoId &

topicId

)

Remove the topic from the id to topic map. This method should only be called by the DCPS_IR_Topic when deleting the topic.

Definition at line 1452 of file DCPS_IR_Domain.cpp.

References idToTopicMap_.

Referenced by DCPS_IR_Topic::release().

{
  IdToTopicMap::iterator map_entry = this->idToTopicMap_.find(topicId);
  if (map_entry != this->idToTopicMap_.end())
    idToTopicMap_.erase(map_entry);
}

Here is the caller graph for this function:

bool DCPS_IR_Domain::useBIT

(

)

const [inline]

Definition at line 176 of file DCPS_IR_Domain.h.

Referenced by TAO_DDS_DCPSInfo_i::domain().

{ return useBIT_; }

Here is the caller graph for this function:

---

Member Data Documentation

DDS::DomainParticipant_var DCPS_IR_Domain::bitParticipant_ [private]

Built-in Topic variables

Definition at line 245 of file DCPS_IR_Domain.h.

Referenced by cleanup_built_in_topics(), init_built_in_topics_topics(), and init_built_in_topics_transport().

DDS::ParticipantBuiltinTopicDataDataWriter_var DCPS_IR_Domain::bitParticipantDataWriter_ [private]

Built-in Topic variables

Definition at line 253 of file DCPS_IR_Domain.h.

Referenced by cleanup_built_in_topics(), dispose_participant_bit(), and publish_participant_bit().

DDS::DomainParticipantFactory_var DCPS_IR_Domain::bitParticipantFactory_ [private]

Built-in Topic variables

Definition at line 244 of file DCPS_IR_Domain.h.

Referenced by cleanup_built_in_topics().

DDS::DomainParticipantListener_var DCPS_IR_Domain::bitParticipantListener_ [private]

Built-in Topic variables

Definition at line 246 of file DCPS_IR_Domain.h.

DDS::Topic_var DCPS_IR_Domain::bitParticipantTopic_ [private]

Built-in Topic variables

Definition at line 252 of file DCPS_IR_Domain.h.

Referenced by cleanup_built_in_topics(), and init_built_in_topics_topics().

DDS::PublicationBuiltinTopicDataDataWriter_var DCPS_IR_Domain::bitPublicationDataWriter_ [private]

Built-in Topic variables

Definition at line 262 of file DCPS_IR_Domain.h.

Referenced by cleanup_built_in_topics(), dispose_publication_bit(), and publish_publication_bit().

DDS::Topic_var DCPS_IR_Domain::bitPublicationTopic_ [private]

Built-in Topic variables

Definition at line 261 of file DCPS_IR_Domain.h.

Referenced by cleanup_built_in_topics(), and init_built_in_topics_topics().

DDS::Publisher_var DCPS_IR_Domain::bitPublisher_ [private]

Built-in Topic variables

Definition at line 247 of file DCPS_IR_Domain.h.

Referenced by cleanup_built_in_topics(), and init_built_in_topics_transport().

DDS::SubscriptionBuiltinTopicDataDataWriter_var DCPS_IR_Domain::bitSubscriptionDataWriter_ [private]

Built-in Topic variables

Definition at line 259 of file DCPS_IR_Domain.h.

Referenced by cleanup_built_in_topics(), dispose_subscription_bit(), and publish_subscription_bit().

DDS::Topic_var DCPS_IR_Domain::bitSubscriptionTopic_ [private]

Built-in Topic variables

Definition at line 258 of file DCPS_IR_Domain.h.

Referenced by cleanup_built_in_topics(), and init_built_in_topics_topics().

DDS::TopicBuiltinTopicDataDataWriter_var DCPS_IR_Domain::bitTopicDataWriter_ [private]

Built-in Topic variables

Definition at line 256 of file DCPS_IR_Domain.h.

Referenced by cleanup_built_in_topics(), dispose_topic_bit(), and publish_topic_bit().

DDS::Topic_var DCPS_IR_Domain::bitTopicTopic_ [private]

Built-in Topic variables

Definition at line 255 of file DCPS_IR_Domain.h.

Referenced by cleanup_built_in_topics(), and init_built_in_topics_topics().

DCPS_IR_Participant_Set DCPS_IR_Domain::deadParticipants_ [private]

the dead participants dead participants exist in both this and participants_

Definition at line 226 of file DCPS_IR_Domain.h.

Referenced by add_dead_participant(), dump_to_string(), and remove_dead_participants().

DDS::DomainId_t DCPS_IR_Domain::id_ [private]

Definition at line 215 of file DCPS_IR_Domain.h.

Referenced by add_participant(), add_topic_description(), add_topic_i(), dump_to_string(), find_topic(), find_topic_description(), get_id(), remove_participant(), remove_topic(), and remove_topic_description().

IdToTopicMap DCPS_IR_Domain::idToTopicMap_ [private]

Actual mapping of Id values to Topic object references.

Definition at line 237 of file DCPS_IR_Domain.h.

Referenced by add_topic_i(), find_topic(), and remove_topic_id_mapping().

OpenDDS::DCPS::RepoIdGenerator& DCPS_IR_Domain::participantIdGenerator_ [private]

Participant GUID Id generator. The remaining Entities have their values generated within the containing Participant.

Definition at line 219 of file DCPS_IR_Domain.h.

Referenced by get_next_participant_id(), and last_participant_key().

DCPS_IR_Participant_Map DCPS_IR_Domain::participants_ [private]

all the participants

Definition at line 222 of file DCPS_IR_Domain.h.

Referenced by add_participant(), dump_to_string(), participant(), participants(), and remove_participant().

DCPS_IR_Topic_Description_Set DCPS_IR_Domain::topicDescriptions_ [private]

all the topics

Definition at line 229 of file DCPS_IR_Domain.h.

Referenced by add_topic_description(), dump_to_string(), find_topic(), find_topic_description(), and remove_topic_description().

OpenDDS::DCPS::TransportConfig_rch DCPS_IR_Domain::transportConfig_ [private]

Built-in Topic variables

Definition at line 250 of file DCPS_IR_Domain.h.

Referenced by init_built_in_topics_transport().

bool DCPS_IR_Domain::useBIT_ [private]

indicates if the BuiltIn Topics are enabled

Definition at line 240 of file DCPS_IR_Domain.h.

Referenced by cleanup_built_in_topics(), dispose_participant_bit(), dispose_publication_bit(), dispose_subscription_bit(), dispose_topic_bit(), dump_to_string(), publish_participant_bit(), publish_publication_bit(), publish_subscription_bit(), and publish_topic_bit().

---

The documentation for this class was generated from the following files:

• DCPS_IR_Domain.h
• DCPS_IR_Domain.cpp