OpenDDS::DCPS::PublisherImpl Class Reference

Implements the OpenDDS::DCPS::Publisher interfaces. More...

#include <PublisherImpl.h>

Inheritance diagram for OpenDDS::DCPS::PublisherImpl:

[legend]Collaboration diagram for OpenDDS::DCPS::PublisherImpl:

[legend]List of all members.

Public Member Functions
	PublisherImpl (DDS::InstanceHandle_t handle, RepoId id, const DDS::PublisherQos &qos, DDS::PublisherListener_ptr a_listener, const DDS::StatusMask &mask, DomainParticipantImpl *participant)
virtual	~PublisherImpl ()
virtual DDS::InstanceHandle_t	get_instance_handle ()
bool	contains_writer (DDS::InstanceHandle_t a_handle)
virtual DDS::DataWriter_ptr	create_datawriter (DDS::Topic_ptr a_topic, const DDS::DataWriterQos &qos, DDS::DataWriterListener_ptr a_listener, DDS::StatusMask mask)
virtual DDS::ReturnCode_t	delete_datawriter (DDS::DataWriter_ptr a_datawriter)
virtual DDS::DataWriter_ptr	lookup_datawriter (const char *topic_name)
virtual DDS::ReturnCode_t	delete_contained_entities ()
virtual DDS::ReturnCode_t	set_qos (const DDS::PublisherQos &qos)
virtual DDS::ReturnCode_t	get_qos (DDS::PublisherQos &qos)
virtual DDS::ReturnCode_t	set_listener (DDS::PublisherListener_ptr a_listener, DDS::StatusMask mask)
virtual DDS::PublisherListener_ptr	get_listener ()
virtual DDS::ReturnCode_t	suspend_publications ()
virtual DDS::ReturnCode_t	resume_publications ()
virtual DDS::ReturnCode_t	begin_coherent_changes ()
virtual DDS::ReturnCode_t	end_coherent_changes ()
virtual DDS::ReturnCode_t	wait_for_acknowledgments (const DDS::Duration_t &max_wait)
virtual DDS::DomainParticipant_ptr	get_participant ()
virtual DDS::ReturnCode_t	set_default_datawriter_qos (const DDS::DataWriterQos &qos)
virtual DDS::ReturnCode_t	get_default_datawriter_qos (DDS::DataWriterQos &qos)
virtual DDS::ReturnCode_t	copy_from_topic_qos (DDS::DataWriterQos &a_datawriter_qos, const DDS::TopicQos &a_topic_qos)
virtual DDS::ReturnCode_t	enable ()
ACE_Recursive_Thread_Mutex &	get_pi_lock ()
bool	is_clean () const
DDS::ReturnCode_t	writer_enabled (const char *topic_name, DataWriterImpl *impl)
DDS::PublisherListener_ptr	listener_for (::DDS::StatusKind kind)
DDS::ReturnCode_t	assert_liveliness_by_participant ()
ACE_Time_Value	liveliness_check_interval (DDS::LivelinessQosPolicyKind kind)
bool	participant_liveliness_activity_after (const ACE_Time_Value &tv)
typedef	OPENDDS_VECTOR (PublicationId) PublicationIdVec
void	get_publication_ids (PublicationIdVec &pubs)
bool	is_suspended () const
virtual EntityImpl *	parent () const
Static Public Member Functions
static bool	validate_datawriter_qos (const DDS::DataWriterQos &qos, const DDS::DataWriterQos &default_qos, DDS::Topic_ptr a_topic, DDS::DataWriterQos &dw_qos)
Private Types
typedef ACE_Recursive_Thread_Mutex	lock_type
typedef ACE_Reverse_Lock< lock_type >	reverse_lock_type
Private Member Functions
typedef	OPENDDS_MULTIMAP (OPENDDS_STRING, DataWriterImpl *) DataWriterMap
typedef	OPENDDS_MAP_CMP (PublicationId, DataWriterImpl *, GUID_tKeyLessThan) PublicationMap
typedef	OPENDDS_MAP_CMP (RepoId, DDS::DataWriterQos, GUID_tKeyLessThan) DwIdToQosMap
Private Attributes
DDS::InstanceHandle_t	handle_
DDS::PublisherQos	qos_
	Publisher QoS policy list.
DDS::DataWriterQos	default_datawriter_qos_
	Default datawriter Qos policy list.
DDS::StatusMask	listener_mask_
DDS::PublisherListener_var	listener_
	Used to notify the entity for relevant events.
DataWriterMap	datawriter_map_
	This map is used to support datawriter lookup by topic name.
PublicationMap	publication_map_
std::size_t	change_depth_
	The number of times begin_coherent_changes as been called.
DDS::DomainId_t	domain_id_
	Domain in which we are contained.
DomainParticipantImpl *	participant_
	The DomainParticipant servant that owns this Publisher.
CORBA::Short	suspend_depth_count_
	The suspend depth count.
SequenceNumber	sequence_number_
ACE_Time_Value	aggregation_period_start_
	Start of current aggregation period. - NOT USED IN FIRST IMPL.
lock_type	pi_lock_
	The recursive lock to protect datawriter map and suspend count.
reverse_lock_type	reverse_pi_lock_
Monitor *	monitor_
	Monitor object for this entity.
RepoId	publisher_id_
Friends
class	DataWriterImpl

---

Detailed Description

Implements the OpenDDS::DCPS::Publisher interfaces.

This class acts as a factory and container of the datawriter.

See the DDS specification, OMG formal/04-12-02, for a description of the interface this class is implementing.

Definition at line 37 of file PublisherImpl.h.

---

Member Typedef Documentation

typedef ACE_Recursive_Thread_Mutex OpenDDS::DCPS::PublisherImpl::lock_type [private]

Definition at line 193 of file PublisherImpl.h.

typedef ACE_Reverse_Lock<lock_type> OpenDDS::DCPS::PublisherImpl::reverse_lock_type [private]

Definition at line 194 of file PublisherImpl.h.

---

Constructor & Destructor Documentation

OpenDDS::DCPS::PublisherImpl::PublisherImpl	(	DDS::InstanceHandle_t	handle,
		RepoId	id,
		const DDS::PublisherQos &	qos,
		DDS::PublisherListener_ptr	a_listener,
		const DDS::StatusMask &	mask,
		DomainParticipantImpl *	participant
	)

Definition at line 29 of file PublisherImpl.cpp.

References monitor_, and TheServiceParticipant.

: handle_(handle),
  qos_(qos),
  default_datawriter_qos_(TheServiceParticipant->initial_DataWriterQos()),
  listener_mask_(mask),
  listener_(DDS::PublisherListener::_duplicate(a_listener)),
#ifndef OPENDDS_NO_OBJECT_MODEL_PROFILE
  change_depth_(0),
#endif
  domain_id_(participant->get_domain_id()),
  participant_(participant),
  suspend_depth_count_(0),
  sequence_number_(),
  aggregation_period_start_(ACE_Time_Value::zero),
  reverse_pi_lock_(pi_lock_),
  monitor_(0),
  publisher_id_(id)
{
  monitor_ = TheServiceParticipant->monitor_factory_->create_publisher_monitor(this);
}

OpenDDS::DCPS::PublisherImpl::~PublisherImpl

(

)

[virtual]

Definition at line 56 of file PublisherImpl.cpp.

References is_clean().

{
  //The datawriters should be deleted already before calling delete
  //publisher.
  if (!is_clean()) {
    ACE_ERROR((LM_ERROR,
        ACE_TEXT("(%P|%t) ERROR: ")
        ACE_TEXT("PublisherImpl::~PublisherImpl, ")
        ACE_TEXT("some datawriters still exist.\n")));
  }
}

---

Member Function Documentation

DDS::ReturnCode_t OpenDDS::DCPS::PublisherImpl::assert_liveliness_by_participant

(

)

Definition at line 818 of file PublisherImpl.cpp.

References datawriter_map_, and DDS::RETCODE_OK.

{
  DDS::ReturnCode_t ret = DDS::RETCODE_OK;

  for (DataWriterMap::iterator it(datawriter_map_.begin());
      it != datawriter_map_.end(); ++it) {
    DDS::ReturnCode_t dw_ret = it->second->assert_liveliness_by_participant();

    if (dw_ret != DDS::RETCODE_OK) {
      ret = dw_ret;
    }
  }

  return ret;
}

DDS::ReturnCode_t OpenDDS::DCPS::PublisherImpl::begin_coherent_changes

(

)

[virtual]

Implements DDS::Publisher.

Definition at line 519 of file PublisherImpl.cpp.

References change_depth_, OpenDDS::DCPS::EntityImpl::enabled_, DDS::INSTANCE_PRESENTATION_QOS, DDS::PublisherQos::presentation, publication_map_, qos_, DDS::RETCODE_ERROR, DDS::RETCODE_NOT_ENABLED, and DDS::RETCODE_OK.

{
  if (enabled_ == false) {
    ACE_ERROR_RETURN((LM_ERROR,
        ACE_TEXT("(%P|%t) ERROR: PublisherImpl::begin_coherent_changes:")
        ACE_TEXT(" Publisher is not enabled!\n")),
        DDS::RETCODE_NOT_ENABLED);
  }

  if (!qos_.presentation.coherent_access) {
    ACE_ERROR_RETURN((LM_ERROR,
        ACE_TEXT("(%P|%t) ERROR: PublisherImpl::begin_coherent_changes:")
        ACE_TEXT(" QoS policy does not support coherent access!\n")),
        DDS::RETCODE_ERROR);
  }

  ACE_GUARD_RETURN(ACE_Recursive_Thread_Mutex,
      guard,
      this->pi_lock_,
      DDS::RETCODE_ERROR);

  ++this->change_depth_;

  if (qos_.presentation.access_scope == DDS::INSTANCE_PRESENTATION_QOS) {
    // INSTANCE access scope essentially behaves
    // as a no-op. (see: 7.1.3.6)
    return DDS::RETCODE_OK;
  }

  // We should only notify publications on the first
  // and last change to the current change set:
  if (this->change_depth_ == 1) {
    for (PublicationMap::iterator it = this->publication_map_.begin();
        it != this->publication_map_.end(); ++it) {
      it->second->begin_coherent_changes();
    }
  }

  return DDS::RETCODE_OK;
}

bool OpenDDS::DCPS::PublisherImpl::contains_writer

(

DDS::InstanceHandle_t

a_handle

)

Definition at line 75 of file PublisherImpl.cpp.

References datawriter_map_, and DDS::RETCODE_ERROR.

{
  ACE_GUARD_RETURN(ACE_Recursive_Thread_Mutex,
      guard,
      this->pi_lock_,
      DDS::RETCODE_ERROR);

  for (DataWriterMap::iterator it(datawriter_map_.begin());
      it != datawriter_map_.end(); ++it) {
    if (a_handle == it->second->get_instance_handle()) {
      return true;
    }
  }

  return false;
}

DDS::ReturnCode_t OpenDDS::DCPS::PublisherImpl::copy_from_topic_qos	(	DDS::DataWriterQos &	a_datawriter_qos,
		const DDS::TopicQos &	a_topic_qos
	)			[virtual]

Definition at line 725 of file PublisherImpl.cpp.

References OpenDDS::DCPS::Qos_Helper::copy_from_topic_qos(), DDS::RETCODE_INCONSISTENT_POLICY, and DDS::RETCODE_OK.

{
  if (Qos_Helper::copy_from_topic_qos(a_datawriter_qos, a_topic_qos)) {
    return DDS::RETCODE_OK;
  } else {
    return DDS::RETCODE_INCONSISTENT_POLICY;
  }
}

DDS::DataWriter_ptr OpenDDS::DCPS::PublisherImpl::create_datawriter	(	DDS::Topic_ptr	a_topic,
		const DDS::DataWriterQos &	qos,
		DDS::DataWriterListener_ptr	a_listener,
		DDS::StatusMask	mask
	)			[virtual]

Definition at line 93 of file PublisherImpl.cpp.

References default_datawriter_qos_, OpenDDS::DCPS::DataWriterImpl::enable(), DDS::PublisherQos::entity_factory, OpenDDS::DCPS::TopicDescriptionImpl::get_name(), OpenDDS::DCPS::TopicDescriptionImpl::get_type_support(), OpenDDS::DCPS::DataWriterImpl::init(), participant_, qos_, DDS::RETCODE_OK, and validate_datawriter_qos().

{
  DDS::DataWriterQos dw_qos;

  if (!validate_datawriter_qos(qos, default_datawriter_qos_, a_topic, dw_qos)) {
    return DDS::DataWriter::_nil();
  }

  TopicImpl* topic_servant = dynamic_cast<TopicImpl*>(a_topic);

  OpenDDS::DCPS::TypeSupport_ptr typesupport =
      topic_servant->get_type_support();

  if (typesupport == 0) {
    CORBA::String_var name = topic_servant->get_name();
    ACE_ERROR((LM_ERROR,
        ACE_TEXT("(%P|%t) ERROR: ")
        ACE_TEXT("PublisherImpl::create_datawriter, ")
        ACE_TEXT("typesupport(topic_name=%C) is nil.\n"),
        name.in()));
    return DDS::DataWriter::_nil();
  }

  DDS::DataWriter_var dw_obj = typesupport->create_datawriter();

  DataWriterImpl* dw_servant =
      dynamic_cast <DataWriterImpl*>(dw_obj.in());

  dw_servant->init(a_topic,
      topic_servant,
      dw_qos,
      a_listener,
      mask,
      participant_,
      this,
      dw_obj.in());

  if (this->enabled_ == true
      && qos_.entity_factory.autoenable_created_entities == 1) {

    DDS::ReturnCode_t ret = dw_servant->enable();

    if (ret != DDS::RETCODE_OK) {
      ACE_ERROR((LM_ERROR,
          ACE_TEXT("(%P|%t) ERROR: ")
          ACE_TEXT("PublisherImpl::create_datawriter, ")
          ACE_TEXT("enable failed.\n")));
      return DDS::DataWriter::_nil();
    }
  }

  return DDS::DataWriter::_duplicate(dw_obj.in());
}

DDS::ReturnCode_t OpenDDS::DCPS::PublisherImpl::delete_contained_entities

(

)

[virtual]

Implements DDS::Publisher.

Definition at line 312 of file PublisherImpl.cpp.

References datawriter_map_, delete_datawriter(), OpenDDS::DCPS::DataWriterImpl::get_publication_id(), OpenDDS::DCPS::GUID_UNKNOWN, OPENDDS_STRING, DDS::RETCODE_ERROR, DDS::RETCODE_OK, and OpenDDS::DCPS::EntityImpl::set_deleted().

{
  // mark that the entity is being deleted
  set_deleted(true);

  while (true) {
    PublicationId pub_id = GUID_UNKNOWN;
    DataWriterImpl* a_datawriter;

    {
      ACE_GUARD_RETURN(ACE_Recursive_Thread_Mutex,
          guard,
          this->pi_lock_,
          DDS::RETCODE_ERROR);

      if (datawriter_map_.empty()) {
        break;
      } else {
        a_datawriter = datawriter_map_.begin()->second;
        pub_id = a_datawriter->get_publication_id();
      }
    }

    DDS::ReturnCode_t ret = delete_datawriter(a_datawriter);

    if (ret != DDS::RETCODE_OK) {
      GuidConverter converter(pub_id);
      ACE_ERROR_RETURN((LM_ERROR,
          ACE_TEXT("(%P|%t) ERROR: ")
          ACE_TEXT("PublisherImpl::")
          ACE_TEXT("delete_contained_entities: ")
          ACE_TEXT("failed to delete ")
          ACE_TEXT("datawriter %C.\n"),
          OPENDDS_STRING(converter).c_str()),ret);
    }
  }

  // the publisher can now start creating new publications
  set_deleted(false);

  return DDS::RETCODE_OK;
}

DDS::ReturnCode_t OpenDDS::DCPS::PublisherImpl::delete_datawriter

(

DDS::DataWriter_ptr

a_datawriter

)

[virtual]

Definition at line 152 of file PublisherImpl.cpp.

References OpenDDS::DCPS::DataWriterImpl::cleanup(), datawriter_map_, OpenDDS::DCPS::DCPS_debug_level, OpenDDS::DCPS::DataWriterImpl::get_publication_id(), OpenDDS::DCPS::DataWriterImpl::get_publisher(), OpenDDS::DCPS::DataWriterImpl::get_topic_name(), OpenDDS::DCPS::GUID_UNKNOWN, OPENDDS_STRING, participant_, OpenDDS::DCPS::DataWriterImpl::persist_data(), OpenDDS::DCPS::DataWriterImpl::prepare_to_delete(), publication_map_, OpenDDS::DCPS::DomainParticipantImpl::remove_adjust_liveliness_timers(), OpenDDS::DCPS::DataWriterImpl::remove_all_associations(), DDS::RETCODE_ERROR, DDS::RETCODE_OK, DDS::RETCODE_PRECONDITION_NOT_MET, TheServiceParticipant, OpenDDS::DCPS::time_value_to_time(), OpenDDS::DCPS::DataWriterImpl::unregister_all(), OpenDDS::DCPS::DataWriterImpl::unregister_instances(), OpenDDS::DCPS::DataWriterImpl::wait_control_pending(), and OpenDDS::DCPS::DataWriterImpl::wait_pending().

Referenced by delete_contained_entities().

{
  DataWriterImpl* dw_servant = dynamic_cast<DataWriterImpl*>(a_datawriter);
  if (dw_servant) {
    // marks entity as deleted and stops future associating
    dw_servant->prepare_to_delete();
  }

  if (!dw_servant) {
    ACE_ERROR((LM_ERROR,
              "(%P|%t) PublisherImpl::delete_datawriter - dynamic cast to DataWriterImpl failed\n"
    ));
    return DDS::RETCODE_ERROR;
  }

  {
    DDS::Publisher_var dw_publisher(dw_servant->get_publisher());

    if (dw_publisher.in() != this) {
      RepoId id = dw_servant->get_publication_id();
      GuidConverter converter(id);
      ACE_ERROR((LM_ERROR,
          ACE_TEXT("(%P|%t) PublisherImpl::delete_datawriter: ")
          ACE_TEXT("the data writer %C doesn't ")
          ACE_TEXT("belong to this subscriber \n"),
          OPENDDS_STRING(converter).c_str()));
      return DDS::RETCODE_PRECONDITION_NOT_MET;
    }
  }

#ifndef OPENDDS_NO_PERSISTENCE_PROFILE
  // Trigger data to be persisted, i.e. made durable, if so
  // configured. This needs be called before unregister_instances
  // because unregister_instances may cause instance dispose.
  if (!dw_servant->persist_data() && DCPS_debug_level >= 2) {
    ACE_ERROR((LM_ERROR,
        ACE_TEXT("(%P|%t) ERROR: ")
        ACE_TEXT("PublisherImpl::delete_datawriter, ")
        ACE_TEXT("failed to make data durable.\n")));
  }
#endif

  // Unregister all registered instances prior to deletion.
  DDS::Time_t source_timestamp = time_value_to_time(ACE_OS::gettimeofday());
  dw_servant->unregister_instances(source_timestamp);

  // Wait for any control messages to be transported during
  // unregistering of instances.
  dw_servant->wait_pending();
  dw_servant->wait_control_pending();

  CORBA::String_var topic_name = dw_servant->get_topic_name();
  RepoId publication_id  = GUID_UNKNOWN;
  {
    ACE_GUARD_RETURN(ACE_Recursive_Thread_Mutex,
        guard,
        this->pi_lock_,
        DDS::RETCODE_ERROR);

    publication_id = dw_servant->get_publication_id();

    PublicationMap::iterator it = publication_map_.find(publication_id);

    if (it == publication_map_.end()) {
      GuidConverter converter(publication_id);
      ACE_ERROR_RETURN((LM_ERROR,
          ACE_TEXT("(%P|%t) ERROR: ")
          ACE_TEXT("PublisherImpl::delete_datawriter, ")
          ACE_TEXT("datawriter %C not found.\n"),
          OPENDDS_STRING(converter).c_str()), DDS::RETCODE_ERROR);
    }

    // We can not erase the datawriter from datawriter map by the topic name
    // because the map might have multiple datawriters with the same topic
    // name.
    // Find the iterator to the datawriter in the datawriter map and erase
    // by the iterator.
    DataWriterMap::iterator writ;
    DataWriterMap::iterator the_writ = datawriter_map_.end();

    for (writ = datawriter_map_.begin();
        writ != datawriter_map_.end();
        ++writ) {
      if (writ->second == it->second) {
        the_writ = writ;
        break;
      }
    }

    if (the_writ != datawriter_map_.end()) {
      datawriter_map_.erase(the_writ);
    }

    publication_map_.erase(it);

    // Release pi_lock_ before making call to transport layer to avoid
    // some deadlock situations that threads acquire locks(PublisherImpl
    // pi_lock_, TransportClient reservation_lock and TransportImpl
    // lock_) in reverse order.
    ACE_GUARD_RETURN(reverse_lock_type, reverse_monitor, this->reverse_pi_lock_,
        DDS::RETCODE_ERROR);
    // Wait for pending samples to drain prior to removing associations
    // and unregistering the publication.
    dw_servant->wait_pending();
    // Call remove association before unregistering the datawriter
    // with the transport, otherwise some callbacks resulted from
    // remove_association may lost.
    dw_servant->remove_all_associations();
    dw_servant->cleanup();
  }
  // not just unregister but remove any pending writes/sends.
  dw_servant->unregister_all();
  Discovery_rch disco = TheServiceParticipant->get_discovery(this->domain_id_);
  if (!disco->remove_publication(
      this->domain_id_,
      this->participant_->get_id(),
      publication_id)) {
    ACE_ERROR_RETURN((LM_ERROR,
        ACE_TEXT("(%P|%t) ERROR: ")
        ACE_TEXT("PublisherImpl::delete_datawriter, ")
        ACE_TEXT("publication not removed from discovery.\n")),
        DDS::RETCODE_ERROR);
  }
  // Decrease ref count after the servant is removed from the maps.
  dw_servant->_remove_ref();

  participant_->remove_adjust_liveliness_timers();

  return DDS::RETCODE_OK;
}

DDS::ReturnCode_t OpenDDS::DCPS::PublisherImpl::enable

(

)

[virtual]

Implements DDS::Entity.

Definition at line 736 of file PublisherImpl.cpp.

References monitor_, OpenDDS::DCPS::Monitor::report(), DDS::RETCODE_OK, DDS::RETCODE_PRECONDITION_NOT_MET, and OpenDDS::DCPS::EntityImpl::set_enabled().

Referenced by OpenDDS::DCPS::DomainParticipantImpl::create_publisher().

{
  //According spec:
  // - Calling enable on an already enabled Entity returns OK and has no
  // effect.
  // - Calling enable on an Entity whose factory is not enabled will fail
  // and return PRECONDITION_NOT_MET.

  if (this->is_enabled()) {
    return DDS::RETCODE_OK;
  }

  if (this->participant_->is_enabled() == false) {
    return DDS::RETCODE_PRECONDITION_NOT_MET;
  }

  if (this->monitor_) {
    this->monitor_->report();
  }

  this->set_enabled();
  return DDS::RETCODE_OK;
}

DDS::ReturnCode_t OpenDDS::DCPS::PublisherImpl::end_coherent_changes

(

)

[virtual]

Implements DDS::Publisher.

Definition at line 561 of file PublisherImpl.cpp.

References change_depth_, OpenDDS::DCPS::EntityImpl::enabled_, DDS::INSTANCE_PRESENTATION_QOS, DDS::PublisherQos::presentation, publication_map_, qos_, DDS::RETCODE_ERROR, DDS::RETCODE_NOT_ENABLED, DDS::RETCODE_OK, and DDS::RETCODE_PRECONDITION_NOT_MET.

{
  if (enabled_ == false) {
    ACE_ERROR_RETURN((LM_ERROR,
        ACE_TEXT("(%P|%t) ERROR: PublisherImpl::end_coherent_changes:")
        ACE_TEXT(" Publisher is not enabled!\n")),
        DDS::RETCODE_NOT_ENABLED);
  }

  if (!qos_.presentation.coherent_access) {
    ACE_ERROR_RETURN((LM_ERROR,
        ACE_TEXT("(%P|%t) ERROR: PublisherImpl::end_coherent_changes:")
        ACE_TEXT(" QoS policy does not support coherent access!\n")),
        DDS::RETCODE_ERROR);
  }

  ACE_GUARD_RETURN(ACE_Recursive_Thread_Mutex,
      guard,
      this->pi_lock_,
      DDS::RETCODE_ERROR);

  if (this->change_depth_ == 0) {
    ACE_ERROR_RETURN((LM_ERROR,
        ACE_TEXT("(%P|%t) ERROR: PublisherImpl::end_coherent_changes:")
        ACE_TEXT(" No matching call to begin_coherent_changes!\n")),
        DDS::RETCODE_PRECONDITION_NOT_MET);
  }

  --this->change_depth_;

  if (qos_.presentation.access_scope == DDS::INSTANCE_PRESENTATION_QOS) {
    // INSTANCE access scope essentially behaves
    // as a no-op. (see: 7.1.3.6)
    return DDS::RETCODE_OK;
  }

  // We should only notify publications on the first
  // and last change to the current change set:
  if (this->change_depth_ == 0) {
    GroupCoherentSamples group_samples;
    for (PublicationMap::iterator it = this->publication_map_.begin();
        it != this->publication_map_.end(); ++it) {

      if (it->second->coherent_samples_ == 0) {
        continue;
      }

      std::pair<GroupCoherentSamples::iterator, bool> pair =
          group_samples.insert(GroupCoherentSamples::value_type(
              it->second->get_publication_id(),
              WriterCoherentSample(it->second->coherent_samples_,
                  it->second->sequence_number_)));

      if (pair.second == false) {
        ACE_ERROR_RETURN((LM_ERROR,
            ACE_TEXT("(%P|%t) ERROR: PublisherImpl::end_coherent_changes: ")
            ACE_TEXT("failed to insert to GroupCoherentSamples.\n")),
            DDS::RETCODE_ERROR);
      }
    }

    for (PublicationMap::iterator it = this->publication_map_.begin();
        it != this->publication_map_.end(); ++it) {
      if (it->second->coherent_samples_ == 0) {
        continue;
      }

      it->second->end_coherent_changes(group_samples);
    }
  }

  return DDS::RETCODE_OK;
}

DDS::ReturnCode_t OpenDDS::DCPS::PublisherImpl::get_default_datawriter_qos

(

DDS::DataWriterQos &

qos

)

[virtual]

Definition at line 718 of file PublisherImpl.cpp.

References default_datawriter_qos_, and DDS::RETCODE_OK.

{
  qos = default_datawriter_qos_;
  return DDS::RETCODE_OK;
}

DDS::InstanceHandle_t OpenDDS::DCPS::PublisherImpl::get_instance_handle

(

)

[virtual]

Implements OpenDDS::DCPS::EntityImpl.

Definition at line 69 of file PublisherImpl.cpp.

References handle_.

Referenced by OpenDDS::DCPS::PublisherMonitorImpl::report().

{
  return handle_;
}

DDS::PublisherListener_ptr OpenDDS::DCPS::PublisherImpl::get_listener

(

)

[virtual]

Implements DDS::Publisher.

Definition at line 448 of file PublisherImpl.cpp.

References listener_.

{
  return DDS::PublisherListener::_duplicate(listener_.in());
}

DDS::DomainParticipant_ptr OpenDDS::DCPS::PublisherImpl::get_participant

(

)

[virtual]

Implements DDS::Publisher.

Definition at line 700 of file PublisherImpl.cpp.

References participant_.

Referenced by OpenDDS::DCPS::PublisherMonitorImpl::report().

{
  return DDS::DomainParticipant::_duplicate(participant_);
}

ACE_Recursive_Thread_Mutex& OpenDDS::DCPS::PublisherImpl::get_pi_lock

(

)

[inline]

Definition at line 112 of file PublisherImpl.h.

{ return pi_lock_; }

void OpenDDS::DCPS::PublisherImpl::get_publication_ids

(

PublicationIdVec &

pubs

)

Populates a std::vector with the PublicationIds (GUIDs) of this Publisher's Data Writers

Definition at line 858 of file PublisherImpl.cpp.

References publication_map_.

Referenced by OpenDDS::DCPS::PublisherMonitorImpl::report().

{
  ACE_GUARD_RETURN(ACE_Recursive_Thread_Mutex,
      guard,
      this->pi_lock_,
  );

  pubs.reserve(publication_map_.size());
  for (PublicationMap::iterator iter = publication_map_.begin();
      iter != publication_map_.end();
      ++iter) {
    pubs.push_back(iter->first);
  }
}

DDS::ReturnCode_t OpenDDS::DCPS::PublisherImpl::get_qos

(

DDS::PublisherQos &

qos

)

[virtual]

Definition at line 431 of file PublisherImpl.cpp.

References qos_, and DDS::RETCODE_OK.

Referenced by OpenDDS::DCPS::DataWriterImpl::enable(), OpenDDS::DCPS::DataWriterImpl::retrieve_inline_qos_data(), and OpenDDS::DCPS::DataWriterImpl::set_qos().

{
  qos = qos_;
  return DDS::RETCODE_OK;
}

bool OpenDDS::DCPS::PublisherImpl::is_clean

(

)

const

This method is not defined in the IDL and is defined for internal use. Check if there is any datawriter associated with this publisher.

Definition at line 761 of file PublisherImpl.cpp.

References datawriter_map_, and publication_map_.

Referenced by OpenDDS::DCPS::DomainParticipantImpl::delete_publisher(), and ~PublisherImpl().

{
  ACE_GUARD_RETURN(ACE_Recursive_Thread_Mutex,
      guard,
      this->pi_lock_,
      false);
  return datawriter_map_.empty() && publication_map_.empty();
}

bool OpenDDS::DCPS::PublisherImpl::is_suspended

(

)

const

Definition at line 473 of file PublisherImpl.cpp.

References suspend_depth_count_.

{
  ACE_GUARD_RETURN(ACE_Recursive_Thread_Mutex,
      guard,
      this->pi_lock_,
      false);
  return suspend_depth_count_;
}

DDS::PublisherListener_ptr OpenDDS::DCPS::PublisherImpl::listener_for

(

::DDS::StatusKind

kind

)

This is used to retrieve the listener for a certain status change. If this publisher has a registered listener and the status kind is in the listener mask then the listener is returned. Otherwise, the query for listener is propagated up to the factory/DomainParticipant.

Referenced by OpenDDS::DCPS::DataWriterImpl::listener_for().

ACE_Time_Value OpenDDS::DCPS::PublisherImpl::liveliness_check_interval

(

DDS::LivelinessQosPolicyKind

kind

)

Definition at line 835 of file PublisherImpl.cpp.

References datawriter_map_.

{
  ACE_Time_Value tv = ACE_Time_Value::max_time;
  for (DataWriterMap::iterator it(datawriter_map_.begin());
      it != datawriter_map_.end(); ++it) {
    tv = std::min (tv, it->second->liveliness_check_interval(kind));
  }
  return tv;
}

DDS::DataWriter_ptr OpenDDS::DCPS::PublisherImpl::lookup_datawriter

(

const char *

topic_name

)

[virtual]

Definition at line 284 of file PublisherImpl.cpp.

References datawriter_map_, and OpenDDS::DCPS::DCPS_debug_level.

{
  ACE_GUARD_RETURN(ACE_Recursive_Thread_Mutex,
      guard,
      this->pi_lock_,
      DDS::DataWriter::_nil());

  // If multiple entries whose key is "topic_name" then which one is
  // returned ? Spec does not limit which one should give.
  DataWriterMap::iterator it = datawriter_map_.find(topic_name);

  if (it == datawriter_map_.end()) {
    if (DCPS_debug_level >= 2) {
      ACE_DEBUG((LM_DEBUG,
          ACE_TEXT("(%P|%t) ")
          ACE_TEXT("PublisherImpl::lookup_datawriter, ")
          ACE_TEXT("The datawriter(topic_name=%C) is not found\n"),
          topic_name));
    }

    return DDS::DataWriter::_nil();

  } else {
    return DDS::DataWriter::_duplicate(it->second);
  }
}

typedef OpenDDS::DCPS::PublisherImpl::OPENDDS_MAP_CMP	(	RepoId	,
		DDS::DataWriterQos	,
		GUID_tKeyLessThan
	)			[private]

typedef OpenDDS::DCPS::PublisherImpl::OPENDDS_MAP_CMP	(	PublicationId	,
		DataWriterImpl *	,
		GUID_tKeyLessThan
	)			[private]

typedef OpenDDS::DCPS::PublisherImpl::OPENDDS_MULTIMAP	(	OPENDDS_STRING	,
		DataWriterImpl *
	)			[private]

typedef OpenDDS::DCPS::PublisherImpl::OPENDDS_VECTOR

(

PublicationId

)

EntityImpl * OpenDDS::DCPS::PublisherImpl::parent

(

)

const [virtual]

Reimplemented from OpenDDS::DCPS::EntityImpl.

Definition at line 874 of file PublisherImpl.cpp.

References participant_.

{
  return this->participant_;
}

bool OpenDDS::DCPS::PublisherImpl::participant_liveliness_activity_after

(

const ACE_Time_Value &

tv

)

Definition at line 846 of file PublisherImpl.cpp.

References datawriter_map_.

{
  for (DataWriterMap::iterator it(datawriter_map_.begin());
      it != datawriter_map_.end(); ++it) {
    if (it->second->participant_liveliness_activity_after(tv)) {
      return true;
    }
  }
  return false;
}

DDS::ReturnCode_t OpenDDS::DCPS::PublisherImpl::resume_publications

(

)

[virtual]

Implements DDS::Publisher.

Definition at line 483 of file PublisherImpl.cpp.

References OpenDDS::DCPS::EntityImpl::enabled_, publication_map_, DDS::RETCODE_ERROR, DDS::RETCODE_NOT_ENABLED, DDS::RETCODE_OK, DDS::RETCODE_PRECONDITION_NOT_MET, and suspend_depth_count_.

{
  if (enabled_ == false) {
    ACE_ERROR_RETURN((LM_ERROR,
        ACE_TEXT("(%P|%t) ERROR: ")
        ACE_TEXT("PublisherImpl::resume_publications, ")
        ACE_TEXT(" Entity is not enabled. \n")),
        DDS::RETCODE_NOT_ENABLED);
  }

  ACE_GUARD_RETURN(ACE_Recursive_Thread_Mutex,
      guard,
      this->pi_lock_,
      DDS::RETCODE_ERROR);

  --suspend_depth_count_;

  if (suspend_depth_count_ < 0) {
    suspend_depth_count_ = 0;
    return DDS::RETCODE_PRECONDITION_NOT_MET;
  }

  if (suspend_depth_count_ == 0) {

    for (PublicationMap::iterator it = this->publication_map_.begin();
        it != this->publication_map_.end(); ++it) {
      it->second->send_suspended_data();
    }
  }

  return DDS::RETCODE_OK;
}

DDS::ReturnCode_t OpenDDS::DCPS::PublisherImpl::set_default_datawriter_qos

(

const DDS::DataWriterQos &

qos

)

[virtual]

Definition at line 706 of file PublisherImpl.cpp.

References OpenDDS::DCPS::Qos_Helper::consistent(), default_datawriter_qos_, DDS::RETCODE_INCONSISTENT_POLICY, DDS::RETCODE_OK, and OpenDDS::DCPS::Qos_Helper::valid().

{
  if (Qos_Helper::valid(qos) && Qos_Helper::consistent(qos)) {
    default_datawriter_qos_ = qos;
    return DDS::RETCODE_OK;

  } else {
    return DDS::RETCODE_INCONSISTENT_POLICY;
  }
}

DDS::ReturnCode_t OpenDDS::DCPS::PublisherImpl::set_listener	(	DDS::PublisherListener_ptr	a_listener,
		DDS::StatusMask	mask
	)			[virtual]

Definition at line 438 of file PublisherImpl.cpp.

References listener_, listener_mask_, and DDS::RETCODE_OK.

{
  listener_mask_ = mask;
  //note: OK to duplicate  a nil object ref
  listener_ = DDS::PublisherListener::_duplicate(a_listener);
  return DDS::RETCODE_OK;
}

DDS::ReturnCode_t OpenDDS::DCPS::PublisherImpl::set_qos

(

const DDS::PublisherQos &

qos

)

[virtual]

Definition at line 356 of file PublisherImpl.cpp.

References OpenDDS::DCPS::Qos_Helper::changeable(), OpenDDS::DCPS::Qos_Helper::consistent(), OpenDDS::DCPS::EntityImpl::enabled_, OpenDDS::DCPS::DomainParticipantImpl::get_domain_id(), OpenDDS::DCPS::DomainParticipantImpl::get_id(), OPENDDS_NO_OBJECT_MODEL_PROFILE_COMPATIBILITY_CHECK, OPENDDS_STRING, participant_, publication_map_, qos_, DDS::RETCODE_ERROR, DDS::RETCODE_IMMUTABLE_POLICY, DDS::RETCODE_INCONSISTENT_POLICY, DDS::RETCODE_OK, DDS::RETCODE_UNSUPPORTED, TheServiceParticipant, and OpenDDS::DCPS::Qos_Helper::valid().

{

  OPENDDS_NO_OBJECT_MODEL_PROFILE_COMPATIBILITY_CHECK(qos, DDS::RETCODE_UNSUPPORTED);

  if (Qos_Helper::valid(qos) && Qos_Helper::consistent(qos)) {
    if (qos_ == qos)
      return DDS::RETCODE_OK;

    // for the not changeable qos, it can be changed before enable
    if (!Qos_Helper::changeable(qos_, qos) && enabled_ == true) {
      return DDS::RETCODE_IMMUTABLE_POLICY;

    } else {
      qos_ = qos;

      DwIdToQosMap idToQosMap;
      {
        ACE_GUARD_RETURN(ACE_Recursive_Thread_Mutex,
            guard,
            this->pi_lock_,
            DDS::RETCODE_ERROR);

        for (PublicationMap::iterator iter = publication_map_.begin();
            iter != publication_map_.end();
            ++iter) {
          DDS::DataWriterQos qos;
          iter->second->get_qos(qos);
          RepoId id = iter->second->get_publication_id();
          std::pair<DwIdToQosMap::iterator, bool> pair =
              idToQosMap.insert(DwIdToQosMap::value_type(id, qos));

          if (pair.second == false) {
            GuidConverter converter(id);
            ACE_ERROR_RETURN((LM_ERROR,
                ACE_TEXT("(%P|%t) ")
                ACE_TEXT("PublisherImpl::set_qos: ")
                ACE_TEXT("insert id %d to DwIdToQosMap ")
                ACE_TEXT("failed.\n"),
                OPENDDS_STRING(converter).c_str()), DDS::RETCODE_ERROR);
          }
        }
      }

      DwIdToQosMap::iterator iter = idToQosMap.begin();

      while (iter != idToQosMap.end()) {
        Discovery_rch disco = TheServiceParticipant->get_discovery(this->domain_id_);
        const bool status
        = disco->update_publication_qos(
            participant_->get_domain_id(),
            participant_->get_id(),
            iter->first,
            iter->second,
            this->qos_);

        if (!status) {
          ACE_ERROR_RETURN((LM_ERROR,
              ACE_TEXT("(%P|%t) PublisherImpl::set_qos, ")
              ACE_TEXT("failed. \n")),
              DDS::RETCODE_ERROR);
        }

        ++iter;
      }
    }

    return DDS::RETCODE_OK;

  } else {
    return DDS::RETCODE_INCONSISTENT_POLICY;
  }
}

DDS::ReturnCode_t OpenDDS::DCPS::PublisherImpl::suspend_publications

(

)

[virtual]

Implements DDS::Publisher.

Definition at line 454 of file PublisherImpl.cpp.

References OpenDDS::DCPS::EntityImpl::enabled_, DDS::RETCODE_ERROR, DDS::RETCODE_NOT_ENABLED, DDS::RETCODE_OK, and suspend_depth_count_.

{
  if (enabled_ == false) {
    ACE_ERROR_RETURN((LM_ERROR,
        ACE_TEXT("(%P|%t) ERROR: ")
        ACE_TEXT("PublisherImpl::suspend_publications, ")
        ACE_TEXT(" Entity is not enabled. \n")),
        DDS::RETCODE_NOT_ENABLED);
  }

  ACE_GUARD_RETURN(ACE_Recursive_Thread_Mutex,
      guard,
      this->pi_lock_,
      DDS::RETCODE_ERROR);
  ++suspend_depth_count_;
  return DDS::RETCODE_OK;
}

bool OpenDDS::DCPS::PublisherImpl::validate_datawriter_qos	(	const DDS::DataWriterQos &	qos,
		const DDS::DataWriterQos &	default_qos,
		DDS::Topic_ptr	a_topic,
		DDS::DataWriterQos &	dw_qos
	)			[static]

Definition at line 880 of file PublisherImpl.cpp.

References OpenDDS::DCPS::Qos_Helper::consistent(), OpenDDS::DCPS::Qos_Helper::copy_from_topic_qos(), DATAWRITER_QOS_DEFAULT, DATAWRITER_QOS_USE_TOPIC_QOS, OPENDDS_NO_DURABILITY_KIND_TRANSIENT_PERSISTENT_COMPATIBILITY_CHECK, OPENDDS_NO_DURABILITY_SERVICE_COMPATIBILITY_CHECK, OPENDDS_NO_OWNERSHIP_KIND_EXCLUSIVE_COMPATIBILITY_CHECK, OPENDDS_NO_OWNERSHIP_PROFILE_COMPATIBILITY_CHECK, OPENDDS_NO_OWNERSHIP_STRENGTH_COMPATIBILITY_CHECK, and OpenDDS::DCPS::Qos_Helper::valid().

Referenced by create_datawriter(), and OpenDDS::DCPS::DomainParticipantImpl::create_replayer().

{
  if (CORBA::is_nil(a_topic)) {
    ACE_ERROR((LM_ERROR,
        ACE_TEXT("(%P|%t) ERROR: ")
        ACE_TEXT("PublisherImpl::create_datawriter, ")
        ACE_TEXT("topic is nil.\n")));
    return DDS::DataWriter::_nil();
  }

  if (qos == DATAWRITER_QOS_DEFAULT) {
    dw_qos = default_qos;

  } else if (qos == DATAWRITER_QOS_USE_TOPIC_QOS) {
    DDS::TopicQos topic_qos;
    a_topic->get_qos(topic_qos);
    dw_qos = default_qos;

    Qos_Helper::copy_from_topic_qos(dw_qos, topic_qos);

  } else {
    dw_qos = qos;
  }

  OPENDDS_NO_OWNERSHIP_KIND_EXCLUSIVE_COMPATIBILITY_CHECK(dw_qos, DDS::DataWriter::_nil());
  OPENDDS_NO_OWNERSHIP_STRENGTH_COMPATIBILITY_CHECK(dw_qos, DDS::DataWriter::_nil());
  OPENDDS_NO_OWNERSHIP_PROFILE_COMPATIBILITY_CHECK(dw_qos, DDS::DataWriter::_nil());
  OPENDDS_NO_DURABILITY_SERVICE_COMPATIBILITY_CHECK(dw_qos, DDS::DataWriter::_nil());
  OPENDDS_NO_DURABILITY_KIND_TRANSIENT_PERSISTENT_COMPATIBILITY_CHECK(dw_qos, DDS::DataWriter::_nil());

  if (!Qos_Helper::valid(dw_qos)) {
    ACE_ERROR((LM_ERROR,
        ACE_TEXT("(%P|%t) ERROR: ")
        ACE_TEXT("PublisherImpl::create_datawriter, ")
        ACE_TEXT("invalid qos.\n")));
    return DDS::DataWriter::_nil();
  }

  if (!Qos_Helper::consistent(dw_qos)) {
    ACE_ERROR((LM_ERROR,
        ACE_TEXT("(%P|%t) ERROR: ")
        ACE_TEXT("PublisherImpl::create_datawriter, ")
        ACE_TEXT("inconsistent qos.\n")));
    return DDS::DataWriter::_nil();
  }
  return true;
}

DDS::ReturnCode_t OpenDDS::DCPS::PublisherImpl::wait_for_acknowledgments

(

const DDS::Duration_t &

max_wait

)

[virtual]

Definition at line 638 of file PublisherImpl.cpp.

References datawriter_map_, OpenDDS::DCPS::DCPS_debug_level, OpenDDS::DCPS::EntityImpl::enabled_, OpenDDS::DCPS::OPENDDS_MAP(), DDS::RELIABLE_RELIABILITY_QOS, DDS::RETCODE_ERROR, DDS::RETCODE_NOT_ENABLED, and DDS::RETCODE_OK.

{
  if (enabled_ == false) {
    ACE_ERROR_RETURN((LM_ERROR,
        ACE_TEXT("(%P|%t) ERROR: PublisherImpl::wait_for_acknowledgments, ")
        ACE_TEXT("Entity is not enabled.\n")),
        DDS::RETCODE_NOT_ENABLED);
  }

  typedef OPENDDS_MAP(DataWriterImpl*, DataWriterImpl::AckToken) DataWriterAckMap;
  DataWriterAckMap ack_writers;
  {
    ACE_GUARD_RETURN(ACE_Recursive_Thread_Mutex,
        guard,
        this->pi_lock_,
        DDS::RETCODE_ERROR);

    // Collect writers to request acks
    for (DataWriterMap::iterator it(this->datawriter_map_.begin());
        it != this->datawriter_map_.end(); ++it) {
      DataWriterImpl* writer = it->second;
      if (writer->qos_.reliability.kind != DDS::RELIABLE_RELIABILITY_QOS)
        continue;
      if (writer->should_ack()) {
        DataWriterImpl::AckToken token = writer->create_ack_token(max_wait);

        std::pair<DataWriterAckMap::iterator, bool> pair =
            ack_writers.insert(DataWriterAckMap::value_type(writer, token));

        if (!pair.second) {
          ACE_ERROR_RETURN((LM_ERROR,
              ACE_TEXT("(%P|%t) ERROR: PublisherImpl::wait_for_acknowledgments, ")
              ACE_TEXT("Unable to insert AckToken into DataWriterAckMap!\n")),
              DDS::RETCODE_ERROR);
        }
      }
    }
  }

  if (ack_writers.empty()) {
    if (DCPS_debug_level > 0) {
      ACE_DEBUG((LM_DEBUG,
          ACE_TEXT("(%P|%t) PublisherImpl::wait_for_acknowledgments() - ")
          ACE_TEXT("not blocking due to no writers requiring acks.\n")));
    }

    return DDS::RETCODE_OK;
  }

  // Wait for ack responses from all associated readers
  for (DataWriterAckMap::iterator it(ack_writers.begin());
      it != ack_writers.end(); ++it) {
    DataWriterImpl::AckToken token = it->second;

    it->first->wait_for_specific_ack(token);
  }

  return DDS::RETCODE_OK;
}

DDS::ReturnCode_t OpenDDS::DCPS::PublisherImpl::writer_enabled	(	const char *	topic_name,
		DataWriterImpl *	impl
	)

This method is called when the datawriter created by this publisher was enabled.

Definition at line 771 of file PublisherImpl.cpp.

References datawriter_map_, OpenDDS::DCPS::DataWriterImpl::get_publication_id(), OPENDDS_STRING, publication_map_, DDS::RETCODE_ERROR, and DDS::RETCODE_OK.

Referenced by OpenDDS::DCPS::DataWriterImpl::enable().

{
  ACE_GUARD_RETURN(ACE_Recursive_Thread_Mutex,
      guard,
      this->pi_lock_,
      DDS::RETCODE_ERROR);

  datawriter_map_.insert(DataWriterMap::value_type(topic_name, writer));

  const RepoId publication_id = writer->get_publication_id();

  std::pair<PublicationMap::iterator, bool> pair =
      publication_map_.insert(PublicationMap::value_type(publication_id, writer));

  if (pair.second == false) {
    GuidConverter converter(publication_id);
    ACE_ERROR_RETURN((LM_ERROR,
        ACE_TEXT("(%P|%t) ERROR: ")
        ACE_TEXT("PublisherImpl::writer_enabled: ")
        ACE_TEXT("insert publication %C failed.\n"),
        OPENDDS_STRING(converter).c_str()), DDS::RETCODE_ERROR);
  }

  // Increase ref count when the servant is added to the
  // datawriter/publication map.
  writer->_add_ref();

  return DDS::RETCODE_OK;
}

---

Friends And Related Function Documentation

friend class DataWriterImpl [friend]

Definition at line 42 of file PublisherImpl.h.

---

Member Data Documentation

ACE_Time_Value OpenDDS::DCPS::PublisherImpl::aggregation_period_start_ [private]

Start of current aggregation period. - NOT USED IN FIRST IMPL.

Definition at line 191 of file PublisherImpl.h.

std::size_t OpenDDS::DCPS::PublisherImpl::change_depth_ [private]

The number of times begin_coherent_changes as been called.

Definition at line 179 of file PublisherImpl.h.

Referenced by begin_coherent_changes(), and end_coherent_changes().

DataWriterMap OpenDDS::DCPS::PublisherImpl::datawriter_map_ [private]

This map is used to support datawriter lookup by topic name.

Definition at line 173 of file PublisherImpl.h.

Referenced by assert_liveliness_by_participant(), contains_writer(), delete_contained_entities(), delete_datawriter(), is_clean(), liveliness_check_interval(), lookup_datawriter(), participant_liveliness_activity_after(), wait_for_acknowledgments(), and writer_enabled().

DDS::DataWriterQos OpenDDS::DCPS::PublisherImpl::default_datawriter_qos_ [private]

Default datawriter Qos policy list.

Definition at line 165 of file PublisherImpl.h.

Referenced by create_datawriter(), get_default_datawriter_qos(), and set_default_datawriter_qos().

DDS::DomainId_t OpenDDS::DCPS::PublisherImpl::domain_id_ [private]

Domain in which we are contained.

Definition at line 182 of file PublisherImpl.h.

DDS::InstanceHandle_t OpenDDS::DCPS::PublisherImpl::handle_ [private]

Definition at line 160 of file PublisherImpl.h.

Referenced by get_instance_handle().

DDS::PublisherListener_var OpenDDS::DCPS::PublisherImpl::listener_ [private]

Used to notify the entity for relevant events.

Definition at line 171 of file PublisherImpl.h.

Referenced by get_listener(), and set_listener().

DDS::StatusMask OpenDDS::DCPS::PublisherImpl::listener_mask_ [private]

The StatusKind bit mask indicates which status condition change can be notified by the listener of this entity.

Definition at line 169 of file PublisherImpl.h.

Referenced by set_listener().

Monitor* OpenDDS::DCPS::PublisherImpl::monitor_ [private]

Monitor object for this entity.

Definition at line 200 of file PublisherImpl.h.

Referenced by enable(), and PublisherImpl().

DomainParticipantImpl* OpenDDS::DCPS::PublisherImpl::participant_ [private]

The DomainParticipant servant that owns this Publisher.

Definition at line 184 of file PublisherImpl.h.

Referenced by create_datawriter(), delete_datawriter(), get_participant(), parent(), and set_qos().

lock_type OpenDDS::DCPS::PublisherImpl::pi_lock_ [mutable, private]

The recursive lock to protect datawriter map and suspend count.

Definition at line 196 of file PublisherImpl.h.

PublicationMap OpenDDS::DCPS::PublisherImpl::publication_map_ [private]

This map is used to support datawriter lookup by datawriter repository id.

Definition at line 176 of file PublisherImpl.h.

Referenced by begin_coherent_changes(), delete_datawriter(), end_coherent_changes(), get_publication_ids(), is_clean(), resume_publications(), set_qos(), and writer_enabled().

RepoId OpenDDS::DCPS::PublisherImpl::publisher_id_ [private]

NOTE: The publisher_id_ is not generated by repository, it's uniqueue in DomainParticipant scope.

Definition at line 204 of file PublisherImpl.h.

Referenced by OpenDDS::DCPS::DataWriterImpl::create_control_message(), OpenDDS::DCPS::DataWriterImpl::create_sample_data_message(), and OpenDDS::DCPS::DataWriterImpl::end_coherent_changes().

DDS::PublisherQos OpenDDS::DCPS::PublisherImpl::qos_ [private]

Publisher QoS policy list.

Definition at line 163 of file PublisherImpl.h.

Referenced by begin_coherent_changes(), create_datawriter(), OpenDDS::DCPS::DataWriterImpl::create_sample_data_message(), end_coherent_changes(), OpenDDS::DCPS::DataWriterImpl::end_coherent_changes(), get_qos(), and set_qos().

reverse_lock_type OpenDDS::DCPS::PublisherImpl::reverse_pi_lock_ [private]

Definition at line 197 of file PublisherImpl.h.

SequenceNumber OpenDDS::DCPS::PublisherImpl::sequence_number_ [private]

Unique sequence number used when the scope_access = GROUP.

• NOT USED IN FIRST IMPL - not supporting GROUP scope

Definition at line 189 of file PublisherImpl.h.

CORBA::Short OpenDDS::DCPS::PublisherImpl::suspend_depth_count_ [private]

The suspend depth count.

Definition at line 186 of file PublisherImpl.h.

Referenced by is_suspended(), resume_publications(), and suspend_publications().

---

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

• PublisherImpl.h
• PublisherImpl.cpp

---