Inheritance diagram for OpenDDS::RTPS::Sedp::TypeLookupReplyReader:

[legend]

Collaboration diagram for OpenDDS::RTPS::Sedp::TypeLookupReplyReader:

[legend]

Public Member Functions
	TypeLookupReplyReader (const DCPS::GUID_t &sub_id, Sedp &sedp)

virtual	~TypeLookupReplyReader ()

void	get_continuation_point (const GUID_t &guid, const XTypes::TypeIdentifier &remote_ti, XTypes::OctetSeq32 &cont_point) const

void	cleanup (const DCPS::GUID_t &guid, const XTypes::TypeIdentifier &ti)

Public Member Functions inherited from OpenDDS::RTPS::Sedp::Reader
	Reader (const DCPS::GUID_t &sub_id, Sedp &sedp)

virtual	~Reader ()

bool	assoc (const DCPS::AssociationData &publication)

void	data_received (const DCPS::ReceivedDataSample &sample)

void	notify_subscription_disconnected (const DCPS::WriterIdSeq &)

void	notify_subscription_reconnected (const DCPS::WriterIdSeq &)

void	notify_subscription_lost (const DCPS::WriterIdSeq &)

void	remove_associations (const DCPS::WriterIdSeq &, bool)

Public Member Functions inherited from OpenDDS::DCPS::TransportReceiveListener
virtual	~TransportReceiveListener ()

virtual void	transport_discovery_change ()

Public Member Functions inherited from OpenDDS::DCPS::RcObject
virtual	~RcObject ()

virtual void	_add_ref ()

virtual void	_remove_ref ()

long	ref_count () const

WeakObject *	_get_weak_object () const

Public Member Functions inherited from OpenDDS::RTPS::Sedp::Endpoint
	Endpoint (const DCPS::GUID_t &repo_id, Sedp &sedp)

virtual	~Endpoint ()

bool	check_transport_qos (const DCPS::TransportInst &)

DCPS::GUID_t	get_guid () const

DDS::DomainId_t	domain_id () const

CORBA::Long	get_priority_value (const DCPS::AssociationData &) const

void	set_crypto_handles (DDS::Security::ParticipantCryptoHandle p, DDS::Security::NativeCryptoHandle e=DDS::HANDLE_NIL)

DDS::Security::ParticipantCryptoHandle	get_crypto_handle () const

DDS::Security::NativeCryptoHandle	get_endpoint_crypto_handle () const

void	shutting_down ()

OPENDDS_STRING	get_instance_name (const DCPS::GUID_t &id) const

EntityId_t	counterpart_entity_id () const

GUID_t	make_counterpart_guid (const DCPS::GUID_t &remote_part) const

bool	associated_with_counterpart (const DCPS::GUID_t &remote_part) const

bool	pending_association_with_counterpart (const DCPS::GUID_t &remote_part) const

bool	associated_with_counterpart_if_not_pending (const DCPS::GUID_t &remote_part) const

RcHandle< DCPS::BitSubscriber >	get_builtin_subscriber_proxy () const

Public Member Functions inherited from OpenDDS::DCPS::TransportClient
void	use_datalink (const GUID_t &remote_id, const DataLink_rch &link)

	TransportClient ()

virtual	~TransportClient ()

void	enable_transport (bool reliable, bool durable)

void	enable_transport_using_config (bool reliable, bool durable, const TransportConfig_rch &tc)

bool	swap_bytes () const

bool	cdr_encapsulation () const

const TransportLocatorSeq &	connection_info () const

void	populate_connection_info ()

bool	is_reliable () const

bool	associate (const AssociationData &peer, bool active)

void	disassociate (const GUID_t &peerId)

void	stop_associating ()

void	stop_associating (const GUID_t *repos, CORBA::ULong length)

void	send_final_acks ()

void	transport_stop ()

void	register_for_reader (const GUID_t &participant, const GUID_t &writerid, const GUID_t &readerid, const TransportLocatorSeq &locators, OpenDDS::DCPS::DiscoveryListener *listener)

void	unregister_for_reader (const GUID_t &participant, const GUID_t &writerid, const GUID_t &readerid)

void	register_for_writer (const GUID_t &participant, const GUID_t &readerid, const GUID_t &writerid, const TransportLocatorSeq &locators, DiscoveryListener *listener)

void	unregister_for_writer (const GUID_t &participant, const GUID_t &readerid, const GUID_t &writerid)

void	update_locators (const GUID_t &remote, const TransportLocatorSeq &locators)

WeakRcHandle< ICE::Endpoint >	get_ice_endpoint ()

bool	send_response (const GUID_t &peer, const DataSampleHeader &header, Message_Block_Ptr payload)

void	send (SendStateDataSampleList send_list, ACE_UINT64 transaction_id=0)

SendControlStatus	send_w_control (SendStateDataSampleList send_list, const DataSampleHeader &header, Message_Block_Ptr msg, const GUID_t &destination)

SendControlStatus	send_control (const DataSampleHeader &header, Message_Block_Ptr msg)

SendControlStatus	send_control_to (const DataSampleHeader &header, Message_Block_Ptr msg, const GUID_t &destination)

bool	remove_sample (const DataSampleElement *sample)

bool	remove_all_msgs ()

virtual void	add_link (const DataLink_rch &link, const GUID_t &peer)

void	terminate_send_if_suspended ()

bool	associated_with (const GUID_t &remote) const

bool	pending_association_with (const GUID_t &remote) const

GUID_t	repo_id () const

void	data_acked (const GUID_t &remote)

bool	is_leading (const GUID_t &reader_id) const

Private Types
typedef std::pair< XTypes::OctetSeq32, XTypes::TypeIdentifierSeq >	ContinuationPair

Private Member Functions
virtual void	data_received_i (const DCPS::ReceivedDataSample &sample, const DCPS::EntityId_t &entity_id, DCPS::Serializer &ser, DCPS::Extensibility extensibility)

bool	process_type_lookup_reply (const DCPS::ReceivedDataSample &, DCPS::Serializer &ser, bool is_discovery_protected)

bool	process_get_types_reply (const XTypes::TypeLookup_Reply &reply)

bool	process_get_dependencies_reply (const DCPS::ReceivedDataSample &sample, const XTypes::TypeLookup_Reply &reply, const DCPS::SequenceNumber &seq_num, bool is_discovery_protected)

typedef	OPENDDS_MAP (XTypes::TypeIdentifier, ContinuationPair) RemoteDependencies

typedef	OPENDDS_MAP_CMP (GUID_t, RemoteDependencies, GUID_tKeyLessThan) DependenciesMap

Private Attributes
DependenciesMap	dependencies_

Additional Inherited Members
Public Types inherited from OpenDDS::DCPS::TransportClient
enum	{ ASSOC_OK = 1, ASSOC_ACTIVE = 2 }

Protected Member Functions inherited from OpenDDS::DCPS::TransportReceiveListener
	TransportReceiveListener ()

Protected Member Functions inherited from OpenDDS::DCPS::RcObject
	RcObject ()

Protected Member Functions inherited from OpenDDS::DCPS::TransportClient
void	cdr_encapsulation (bool encap)

Protected Attributes inherited from OpenDDS::RTPS::Sedp::Endpoint
DCPS::GUID_t	repo_id_

Sedp &	sedp_

AtomicBool	shutting_down_

DDS::Security::ParticipantCryptoHandle	participant_crypto_handle_

DDS::Security::NativeCryptoHandle	endpoint_crypto_handle_

Detailed Description

Definition at line 725 of file Sedp.h.

Member Typedef Documentation

◆ ContinuationPair

typedef std::pair<XTypes::OctetSeq32, XTypes::TypeIdentifierSeq> OpenDDS::RTPS::Sedp::TypeLookupReplyReader::ContinuationPair

private

Definition at line 752 of file Sedp.h.

Constructor & Destructor Documentation

◆ TypeLookupReplyReader()

OpenDDS::RTPS::Sedp::TypeLookupReplyReader::TypeLookupReplyReader	(	const DCPS::GUID_t &	sub_id,
		Sedp &	sedp
	)

inline

Definition at line 727 of file Sedp.h.

References OpenDDS::XTypes::extensibility().

728 : Reader(sub_id, sedp)

729 {}

OpenDDS::RTPS::Sedp::Reader::Reader

Reader(const DCPS::GUID_t &sub_id, Sedp &sedp)

Definition: Sedp.h:612

◆ ~TypeLookupReplyReader()

OpenDDS::RTPS::Sedp::TypeLookupReplyReader::~TypeLookupReplyReader ( )

virtual

Definition at line 3623 of file Sedp.cpp.

3624 {

3625 }

Member Function Documentation

◆ cleanup()

void OpenDDS::RTPS::Sedp::TypeLookupReplyReader::cleanup	(	const DCPS::GUID_t &	guid,
		const XTypes::TypeIdentifier &	ti
	)

Definition at line 3834 of file Sedp.cpp.

References OpenDDS::DCPS::make_part_guid().

 {
   const GUID_t part_guid = DCPS::make_part_guid(guid);
   const DependenciesMap::iterator it = dependencies_.find(part_guid);
   if (it != dependencies_.end() && it->second.find(type_id) != it->second.end()) {
     it->second.erase(type_id);
   }
 
   if (it != dependencies_.end() && it->second.empty()) {
     dependencies_.erase(it);
   }
 }

◆ data_received_i()

void OpenDDS::RTPS::Sedp::TypeLookupReplyReader::data_received_i	(	const DCPS::ReceivedDataSample &	sample,
		const DCPS::EntityId_t &	entity_id,
		DCPS::Serializer &	ser,
		DCPS::Extensibility	extensibility
	)

privatevirtual

Implements OpenDDS::RTPS::Sedp::Reader.

Definition at line 4514 of file Sedp.cpp.

References ACE_DEBUG, ACE_ERROR, ACE_TEXT(), OpenDDS::DCPS::LogGuid::c_str(), OpenDDS::DCPS::DCPS_debug_level, OpenDDS::DCPS::ENTITYID_TL_SVC_REPLY_WRITER, OpenDDS::RTPS::ENTITYID_TL_SVC_REPLY_WRITER_SECURE, OpenDDS::DCPS::ReceivedDataSample::header_, LM_DEBUG, LM_ERROR, and OpenDDS::DCPS::DataSampleHeader::publication_id_.

 {
   if (DCPS::DCPS_debug_level > 8) {
     ACE_DEBUG((LM_DEBUG, "(%P|%t) Sedp::TypeLookupReplyReader::data_received_i: from %C\n",
       DCPS::LogGuid(sample.header_.publication_id_).c_str()));
   }
 
 #ifdef OPENDDS_SECURITY
   if (remote_id == ENTITYID_TL_SVC_REPLY_WRITER_SECURE) {
     if (!process_type_lookup_reply(sample, ser, true)) {
       if (DCPS::DCPS_debug_level) {
         ACE_ERROR((LM_ERROR, ACE_TEXT("(%P|%t) ERROR: Sedp::TypeLookupReplyReader::data_received_i - ")
           ACE_TEXT("failed to process secure type lookup reply\n")));
       }
       return;
     }
   } else if (remote_id == ENTITYID_TL_SVC_REPLY_WRITER) {
 #endif
     if (!process_type_lookup_reply(sample, ser, false)) {
       if (DCPS::DCPS_debug_level) {
         ACE_ERROR((LM_ERROR, ACE_TEXT("(%P|%t) ERROR: Sedp::TypeLookupReplyReader::data_received_i - ")
           ACE_TEXT("failed to process type lookup reply\n")));
       }
       return;
     }
 #ifdef OPENDDS_SECURITY
   }
 #else
   ACE_UNUSED_ARG(remote_id);
 #endif
 }

◆ get_continuation_point()

void OpenDDS::RTPS::Sedp::TypeLookupReplyReader::get_continuation_point	(	const GUID_t &	guid,
		const XTypes::TypeIdentifier &	remote_ti,
		XTypes::OctetSeq32 &	cont_point
	)		const

Definition at line 3821 of file Sedp.cpp.

References OpenDDS::DCPS::make_part_guid().

 {
   const GUID_t part_guid = DCPS::make_part_guid(guid);
   const DependenciesMap::const_iterator it = dependencies_.find(part_guid);
   if (it == dependencies_.end() || it->second.find(remote_ti) == it->second.end()) {
     cont_point.length(0);
   } else {
     cont_point = it->second.find(remote_ti)->second.first;
   }
 }

◆ OPENDDS_MAP()

typedef OpenDDS::RTPS::Sedp::TypeLookupReplyReader::OPENDDS_MAP	(	XTypes::TypeIdentifier	,
		ContinuationPair
	)

private

◆ OPENDDS_MAP_CMP()

typedef OpenDDS::RTPS::Sedp::TypeLookupReplyReader::OPENDDS_MAP_CMP	(	GUID_t	,
		RemoteDependencies	,
		GUID_tKeyLessThan
	)

private

◆ process_get_dependencies_reply()

bool OpenDDS::RTPS::Sedp::TypeLookupReplyReader::process_get_dependencies_reply	(	const DCPS::ReceivedDataSample &	sample,
		const XTypes::TypeLookup_Reply &	reply,
		const DCPS::SequenceNumber &	seq_num,
		bool	is_discovery_protected
	)

private

Definition at line 3990 of file Sedp.cpp.

References ACE_DEBUG, ACE_ERROR, ACE_TEXT(), OpenDDS::XTypes::Sequence< T >::append(), OpenDDS::DCPS::DCPS_debug_level, OpenDDS::DCPS::SequenceNumber::getValue(), OpenDDS::DCPS::GUID_t::guidPrefix, OpenDDS::DCPS::ReceivedDataSample::header_, LM_DEBUG, LM_ERROR, OpenDDS::DCPS::make_part_guid(), OpenDDS::RTPS::Sedp::orig_seq_numbers_, OpenDDS::DCPS::DataSampleHeader::publication_id_, OpenDDS::RTPS::Sedp::Endpoint::sedp_, OpenDDS::RTPS::Sedp::send_type_lookup_request(), OpenDDS::RTPS::Sedp::type_lookup_service_, and OpenDDS::RTPS::Sedp::type_lookup_service_sequence_number_.

 {
   if (DCPS::DCPS_debug_level > 8) {
     ACE_DEBUG((LM_DEBUG, "(%P|%t) Sedp::TypeLookupReplyReader::process_get_dependencies_reply - "
       "seq %q\n", seq_num.getValue()));
   }
 
   if (reply._cxx_return.getTypeDependencies().result().continuation_point.length() != 0 &&
       reply._cxx_return.getTypeDependencies().result().dependent_typeids.length() == 0) {
     if (DCPS::DCPS_debug_level) {
       ACE_ERROR((LM_ERROR, "(%P|%t) ERROR: "
         "Sedp::TypeLookupReplyReader::process_get_dependencies_reply - "
         "received reply with no data\n"));
     }
     return false;
   }
 
   const XTypes::TypeLookup_getTypeDependencies_Out& data = reply._cxx_return.getTypeDependencies().result();
   const DCPS::GUID_t remote_id = sample.header_.publication_id_;
 
   const XTypes::TypeIdentifier remote_ti = sedp_.orig_seq_numbers_[seq_num].type_id;
   const GUID_t part_guid = DCPS::make_part_guid(remote_id.guidPrefix);
   XTypes::TypeIdentifierSeq& deps = dependencies_[part_guid][remote_ti].second;
   for (unsigned i = 0; i < data.dependent_typeids.length(); ++i) {
     const XTypes::TypeIdentifier& ti = data.dependent_typeids[i].type_id;
     // Optimization - only store TypeIdentifiers for which TypeObjects haven't
     // already been in the type objects cache yet
     if (!sedp_.type_lookup_service_->type_object_in_cache(ti)) {
       deps.append(ti);
     }
   }
   dependencies_[part_guid][remote_ti].first = data.continuation_point;
 
   // Update internal data
   sedp_.orig_seq_numbers_.insert(std::make_pair(++sedp_.type_lookup_service_sequence_number_,
                                                 sedp_.orig_seq_numbers_[seq_num]));
   sedp_.orig_seq_numbers_.erase(seq_num);
 
   if (data.continuation_point.length() == 0) { // Get all type objects
     deps.append(remote_ti);
     if (!sedp_.send_type_lookup_request(deps, remote_id, is_discovery_protected, true, sedp_.type_lookup_service_sequence_number_)) {
       ACE_ERROR((LM_ERROR, ACE_TEXT("(%P|%t) ERROR: Sedp::TypeLookupReplyReader::process_get_dependencies_reply - ")
         ACE_TEXT("failed to send getTypes request\n")));
       return false;
     }
   } else { // Get more dependencies
     XTypes::TypeIdentifierSeq type_ids;
     type_ids.append(remote_ti);
     if (!sedp_.send_type_lookup_request(type_ids, remote_id, is_discovery_protected, false, sedp_.type_lookup_service_sequence_number_)) {
       ACE_ERROR((LM_ERROR, ACE_TEXT("(%P|%t) ERROR: Sedp::TypeLookupReplyReader::process_get_dependencies_reply - ")
         ACE_TEXT("failed to send getTypeDependencies request\n")));
       return false;
     }
   }
 
   return true;
 }

◆ process_get_types_reply()

bool OpenDDS::RTPS::Sedp::TypeLookupReplyReader::process_get_types_reply ( const XTypes::TypeLookup_Reply & reply )

private

Definition at line 3954 of file Sedp.cpp.

References ACE_DEBUG, ACE_ERROR, OpenDDS::DCPS::DCPS_debug_level, LM_DEBUG, LM_ERROR, DDS::RETCODE_OK, OpenDDS::DCPS::retcode_to_string(), OpenDDS::RTPS::Sedp::Endpoint::sedp_, and OpenDDS::RTPS::Sedp::type_lookup_service_.

 {
   if (DCPS::DCPS_debug_level > 8) {
     ACE_DEBUG((LM_DEBUG, "(%P|%t) Sedp::TypeLookupReplyReader::process_get_types_reply\n"));
   }
 
   if (reply._cxx_return.getType()._d() != DDS::RETCODE_OK) {
     if (DCPS::DCPS_debug_level) {
       ACE_DEBUG((LM_DEBUG, "(%P|%t) Sedp::TypeLookupReplyReader::process_get_types_reply - "
                  "received reply with return code %C\n",
                  DCPS::retcode_to_string(reply._cxx_return.getType()._d())));
     }
     return false;
   }
 
   if (reply._cxx_return.getType().result().types.length() == 0) {
     if (DCPS::DCPS_debug_level) {
       ACE_ERROR((LM_ERROR, "(%P|%t) ERROR: Sedp::TypeLookupReplyReader::process_get_types_reply - "
                  "received reply with no data\n"));
     }
     return false;
   }
 
   sedp_.type_lookup_service_->add_type_objects_to_cache(reply._cxx_return.getType().result().types);
 
   if (reply._cxx_return.getType().result().complete_to_minimal.length() != 0) {
     if (DCPS::DCPS_debug_level >= 4) {
       ACE_DEBUG((LM_DEBUG, "(%P|%t) Sedp::TypeLookupReplyReader::process_get_types_reply - "
                  "received reply with non-empty complete to minimal map\n"));
     }
     sedp_.type_lookup_service_->update_type_identifier_map(reply._cxx_return.getType().result().complete_to_minimal);
   }
 
   return true;
 }

◆ process_type_lookup_reply()

bool OpenDDS::RTPS::Sedp::TypeLookupReplyReader::process_type_lookup_reply	(	const DCPS::ReceivedDataSample &	sample,
		DCPS::Serializer &	ser,
		bool	is_discovery_protected
	)

private

Definition at line 3848 of file Sedp.cpp.

References ACE_DEBUG, ACE_ERROR, ACE_GUARD_RETURN, ACE_TEXT(), OpenDDS::DCPS::LogGuid::c_str(), OpenDDS::DCPS::DCPS_debug_level, OpenDDS::RTPS::Sedp::Endpoint::get_guid(), OpenDDS::RTPS::Spdp::get_participant_discovered_at(), OpenDDS::DCPS::SequenceNumber::getValue(), OpenDDS::XTypes::TypeLookup_Reply::header, OpenDDS::DCPS::ReceivedDataSample::header_, LM_DEBUG, LM_ERROR, LM_WARNING, OpenDDS::RTPS::Sedp::lock_, OpenDDS::DCPS::log_level, OpenDDS::DCPS::log_progress(), OpenDDS::RTPS::Sedp::match_continue(), OpenDDS::RTPS::Sedp::matching_data_buffer_, OpenDDS::RTPS::Sedp::orig_seq_numbers_, OpenDDS::DCPS::DataSampleHeader::publication_id_, DDS::RPC::ReplyHeader::relatedRequestId, DDS::RETCODE_OK, OpenDDS::RTPS::Sedp::Endpoint::sedp_, DDS::SampleIdentity::sequence_number, OpenDDS::RTPS::Sedp::spdp_, OpenDDS::RTPS::to_opendds_seqnum(), OpenDDS::DCPS::transport_debug, OpenDDS::XTypes::TypeLookup_getDependencies_HashId, OpenDDS::XTypes::TypeLookup_getTypes_HashId, OpenDDS::DCPS::LogLevel::Warning, and DDS::SampleIdentity::writer_guid.

 {
   XTypes::TypeLookup_Reply type_lookup_reply;
   if (!(ser >> type_lookup_reply)) {
     if (DCPS::DCPS_debug_level) {
       ACE_ERROR((LM_ERROR,
         ACE_TEXT("(%P|%t) ERROR: Sedp::TypeLookupReplyReader::process_type_lookup_reply - ")
         ACE_TEXT("failed to deserialize type lookup reply\n")));
     }
     return false;
   }
 
   const DDS::SampleIdentity& request_id = type_lookup_reply.header.relatedRequestId;
   const DCPS::SequenceNumber seq_num = to_opendds_seqnum(request_id.sequence_number);
   if (DCPS::DCPS_debug_level >= 8) {
     ACE_DEBUG((LM_DEBUG, "(%P|%t) Sedp::TypeLookupReplyReader::process_type_lookup_reply - "
       "from %C seq %q\n",
       DCPS::LogGuid(request_id.writer_guid).c_str(),
       seq_num.getValue()));
   }
 
   ACE_GUARD_RETURN(ACE_Thread_Mutex, g, sedp_.lock_, false);
   if (DCPS::transport_debug.log_progress) {
     log_progress("receive type lookup reply", get_guid(), sample.header_.publication_id_, sedp_.spdp_.get_participant_discovered_at(sample.header_.publication_id_));
   }
   const OrigSeqNumberMap::const_iterator seq_num_it = sedp_.orig_seq_numbers_.find(seq_num);
   if (seq_num_it == sedp_.orig_seq_numbers_.end()) {
     ACE_DEBUG((LM_WARNING,
       ACE_TEXT("(%P|%t) WARNING: Sedp::TypeLookupReplyReader::process_type_lookup_reply - ")
       ACE_TEXT("could not find request corresponding to the reply from %C seq %q\n"),
       DCPS::LogGuid(request_id.writer_guid).c_str(), seq_num.getValue()));
     return false;
   }
 
   bool success;
   const ACE_CDR::Long kind = type_lookup_reply._cxx_return._d();
   switch (kind) {
   case XTypes::TypeLookup_getTypes_HashId:
     success = process_get_types_reply(type_lookup_reply);
     break;
   case XTypes::TypeLookup_getDependencies_HashId:
     success = process_get_dependencies_reply(sample, type_lookup_reply, seq_num, is_discovery_protected);
     break;
   default:
     if (DCPS::DCPS_debug_level) {
       ACE_ERROR((LM_ERROR, "(%P|%t) ERROR: "
         "Sedp::TypeLookupReplyReader::process_type_lookup_reply - "
         "reply kind is %d\n", kind));
     }
     return false;
   }
 
   if (kind == XTypes::TypeLookup_getTypes_HashId) {
     if (DCPS::DCPS_debug_level > 8) {
       ACE_DEBUG((LM_DEBUG,
                  "(%P|%t) Sedp::TypeLookupReplyReader::process_type_lookup_reply - "
                  "got the reply for the final request in the sequence\n"));
     }
     const DCPS::SequenceNumber key_seq_num = seq_num_it->second.seq_number;
 
     // Cleanup data
     cleanup(sample.header_.publication_id_, seq_num_it->second.type_id);
     sedp_.orig_seq_numbers_.erase(seq_num);
 
     if (success) {
       MatchingDataIter it;
       for (it = sedp_.matching_data_buffer_.begin(); it != sedp_.matching_data_buffer_.end(); ++it) {
         const DCPS::SequenceNumber& seqnum_minimal = it->second.rpc_seqnum_minimal;
         const DCPS::SequenceNumber& seqnum_complete = it->second.rpc_seqnum_complete;
         if (seqnum_minimal == key_seq_num || seqnum_complete == key_seq_num) {
           if (seqnum_minimal == key_seq_num) {
             it->second.got_minimal = true;
           } else {
             it->second.got_complete = true;
           }
 
           if (it->first.type_obj_req_cond) {
             it->first.type_obj_req_cond->done(DDS::RETCODE_OK);
             sedp_.matching_data_buffer_.erase(it);
             return true;
           } else if (it->second.got_minimal && it->second.got_complete) {
             // All remote type objects are obtained, continue the matching process
             const GUID_t writer = it->first.writer();
             const GUID_t reader = it->first.reader();
             sedp_.matching_data_buffer_.erase(it);
             sedp_.match_continue(writer, reader);
             return true;
           }
           break;
         }
       }
 
       if (it == sedp_.matching_data_buffer_.end()) {
         if (DCPS::log_level >= DCPS::LogLevel::Warning) {
           ACE_ERROR((LM_WARNING, "(%P|%t) WARNING: Sedp::TypeLookupReplyReader::process_type_lookup_reply: "
                      "RPC sequence number %q: No data found in matching data buffer\n",
                      key_seq_num.getValue()));
         }
       }
     }
   }
 
   return success;
 }

Member Data Documentation

◆ dependencies_

DependenciesMap OpenDDS::RTPS::Sedp::TypeLookupReplyReader::dependencies_

private

Definition at line 760 of file Sedp.h.

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

Public Member Functions

Private Types

Private Member Functions

Private Attributes

Additional Inherited Members

Detailed Description

Member Typedef Documentation

◆ ContinuationPair

Constructor & Destructor Documentation

◆ TypeLookupReplyReader()

◆ ~TypeLookupReplyReader()

Member Function Documentation

◆ cleanup()

◆ data_received_i()

◆ get_continuation_point()

◆ OPENDDS_MAP()

◆ OPENDDS_MAP_CMP()

◆ process_get_dependencies_reply()

◆ process_get_types_reply()

◆ process_type_lookup_reply()

Member Data Documentation

◆ dependencies_