OpenDDS::FaceTSS Namespace Reference

Namespaces
	config

Classes
class	Entities
class	Listener

Enumerations
enum	{ NSEC_PER_SEC = 1000000000 }

Functions
FACE::RETURN_CODE_TYPE	update_status (FACE::CONNECTION_ID_TYPE connection_id, DDS::ReturnCode_t retcode)
DDS::Duration_t	convertTimeout (FACE::TIMEOUT_TYPE timeout)
FACE::SYSTEM_TIME_TYPE	convertDuration (const DDS::Duration_t &duration)
FACE::SYSTEM_TIME_TYPE	convertTime (const DDS::Time_t &timestamp)
FACE::MESSAGE_INSTANCE_GUID	create_message_instance_guid (const OpenDDS::DCPS::GUID_t &pub, const CORBA::LongLong &orig_seq)
void	populate_header_received (const FACE::CONNECTION_ID_TYPE &connection_id, const DDS::DomainParticipant_var part, const DDS::SampleInfo &sinfo, FACE::RETURN_CODE_TYPE &return_code)
template<typename Msg >
void	receive_message (FACE::CONNECTION_ID_TYPE connection_id, FACE::TIMEOUT_TYPE timeout, FACE::TRANSACTION_ID_TYPE &transaction_id, Msg &message, FACE::MESSAGE_SIZE_TYPE message_size, FACE::RETURN_CODE_TYPE &return_code)
template<typename Msg >
void	send_message (FACE::CONNECTION_ID_TYPE connection_id, FACE::TIMEOUT_TYPE timeout, FACE::TRANSACTION_ID_TYPE &, const Msg &message, FACE::MESSAGE_SIZE_TYPE message_size, FACE::RETURN_CODE_TYPE &return_code)
template<typename Msg >
void	register_callback (FACE::CONNECTION_ID_TYPE connection_id, const FACE::WAITSET_TYPE, void(*callback)(FACE::TRANSACTION_ID_TYPE, Msg &, FACE::MESSAGE_TYPE_GUID, FACE::MESSAGE_SIZE_TYPE, const FACE::WAITSET_TYPE, FACE::RETURN_CODE_TYPE &), FACE::MESSAGE_SIZE_TYPE max_message_size, FACE::RETURN_CODE_TYPE &return_code)

Enumeration Type Documentation

anonymous enum

anonymous enum

Enumerator
NSEC_PER_SEC

Definition at line 777 of file FaceTSS.cpp.

{ NSEC_PER_SEC = 1000000000 };

Function Documentation

convertDuration()

OpenDDS_FACE_Export FACE::SYSTEM_TIME_TYPE OpenDDS::FaceTSS::convertDuration

(

const DDS::Duration_t &

duration

)

Definition at line 792 of file FaceTSS.cpp.

References DDS::DURATION_INFINITE_NSEC, DDS::DURATION_INFINITE_SEC, DDS::Duration_t::nanosec, NSEC_PER_SEC, and DDS::Duration_t::sec.

Referenced by FACE::TS::Create_Connection(), and send_message().

{
  if (duration.sec == DDS::DURATION_INFINITE_SEC
      && duration.nanosec == DDS::DURATION_INFINITE_NSEC) {
    return FACE::INF_TIME_VALUE;
  }
  return duration.nanosec +
    duration.sec * static_cast<FACE::SYSTEM_TIME_TYPE>(NSEC_PER_SEC);
}

convertTime()

OpenDDS_FACE_Export FACE::SYSTEM_TIME_TYPE OpenDDS::FaceTSS::convertTime

(

const DDS::Time_t &

timestamp

)

Definition at line 802 of file FaceTSS.cpp.

References DDS::Time_t::nanosec, NSEC_PER_SEC, and DDS::Time_t::sec.

Referenced by populate_header_received().

{
  return timestamp.nanosec +
      timestamp.sec * static_cast<FACE::SYSTEM_TIME_TYPE>(NSEC_PER_SEC);
}

convertTimeout()

OpenDDS_FACE_Export DDS::Duration_t OpenDDS::FaceTSS::convertTimeout

(

FACE::TIMEOUT_TYPE

timeout

)

Definition at line 779 of file FaceTSS.cpp.

References DDS::DURATION_INFINITE_NSEC, DDS::DURATION_INFINITE_SEC, and NSEC_PER_SEC.

Referenced by receive_message().

{
  if (timeout == FACE::INF_TIME_VALUE) {
    static const DDS::Duration_t dds_inf = {DDS::DURATION_INFINITE_SEC,
                                            DDS::DURATION_INFINITE_NSEC};
    return dds_inf;
  }

  DDS::Duration_t dur = {static_cast<int>(timeout / NSEC_PER_SEC),
                         static_cast<unsigned int>(timeout % NSEC_PER_SEC)};
  return dur;
}

create_message_instance_guid()

OpenDDS_FACE_Export FACE::MESSAGE_INSTANCE_GUID OpenDDS::FaceTSS::create_message_instance_guid	(	const OpenDDS::DCPS::GUID_t &	pub,
		const CORBA::LongLong &	orig_seq
	)

Definition at line 809 of file FaceTSS.cpp.

References ACE_DEBUG, ACE::crc32(), and LM_WARNING.

Referenced by populate_header_received().

{
  OpenDDS::DCPS::GuidConverter writer(pub);

  FACE::MESSAGE_INSTANCE_GUID message_instance_guid;
  FACE::LongLong mig_low;
  FACE::LongLong masked_seq;

  //Until MESSAGE_INSTANCE_GUID becomes 128 bit GUID, use checksum to represent Prefix
  FACE::Long prefix_representation = ACE::crc32(reinterpret_cast<const void*>(&pub), sizeof(pub));
  masked_seq = orig_seq >> 32;

  if (masked_seq) {
    ACE_DEBUG((LM_WARNING, "(%P|%t) WARNING: create_message_instance_guid - seq does not fit in FACE::Long, truncating high bits to fit\n"));
  }
  mig_low = orig_seq & 0xFFFFFFFF;
  message_instance_guid = (((FACE::LongLong) prefix_representation) << 32 ) | ((FACE::LongLong) mig_low);
/*
  //TODO: This is initial work toward defining how a 128 bit guid could be created
  //in the future for a Message Instance Guid when supported.
  // 13 byte prefix contains identifying pieces of guid
  // 3 byte seq - truncated sequence from the sample
  typedef CORBA::Octet MsgInstGuidPrefix_t[13];
  typedef CORBA::Octet MsgInstGuidSeq_t[3];
  MsgInstGuidPrefix_t migPrefix;
  MsgInstGuidSeq_t migSeq;
  ACE_OS::memcpy(&migPrefix[0], &pub.guidPrefix[2], 10);
  ACE_OS::memcpy(&migPrefix[10], &pub.entityId.entityKey[0], 3);
  masked_seq = orig_seq >> 24;

  if (masked_seq) {
    ACE_DEBUG((LM_WARNING, "(%P|%t) WARNING: create_message_instance_guid - seq does not fit in 3 bytes, truncating high bits to fit\n"));
  }
  FACE::LongLong masked = orig_seq & 0xFFFFFF;

#ifdef ACE_BIG_ENDIAN
  masked <<= 8 * (sizeof(FACE::LongLong)-3);
#endif
  ACE_OS::memcpy(&migSeq[0], &masked, 3);
*/
  return message_instance_guid;
}

populate_header_received()

OpenDDS_FACE_Export void OpenDDS::FaceTSS::populate_header_received	(	const FACE::CONNECTION_ID_TYPE &	connection_id,
		const DDS::DomainParticipant_var	part,
		const DDS::SampleInfo &	sinfo,
		FACE::RETURN_CODE_TYPE &	return_code
	)

Definition at line 852 of file FaceTSS.cpp.

References ACE_DEBUG, ACE_ERROR, ACE_TEXT(), DDS::ALIVE_INSTANCE_STATE, DDS::ANY_SAMPLE_STATE, DDS::ANY_VIEW_STATE, OpenDDS::DCPS::BUILT_IN_PUBLICATION_TOPIC, convertTime(), create_message_instance_guid(), OpenDDS::DCPS::DCPS_debug_level, DDS::LifespanQosPolicy::duration, DDS::DURATION_INFINITE_NSEC, DDS::DURATION_INFINITE_SEC, OpenDDS::DCPS::DomainParticipantImpl::get_id(), OpenDDS::DCPS::DomainParticipantImpl::get_repoid(), OpenDDS::DCPS::GUID_t::guidPrefix, header, OpenDDS::FaceTSS::Entities::instance(), CORBA::is_nil(), DDS::DataWriterQos::lifespan, LM_DEBUG, LM_ERROR, DDS::Duration_t::nanosec, DDS::Time_t::nanosec, OpenDDS::DCPS::TimePoint_T< SystemClock >::now(), OPENDDS_END_VERSIONED_NAMESPACE_DECL, DDS::SampleInfo::opendds_reserved_publication_seq, DDS::SampleInfo::publication_handle, OpenDDS::FaceTSS::Entities::receivers_, DDS::RETCODE_NO_DATA, DDS::RETCODE_OK, DDS::Duration_t::sec, DDS::Time_t::sec, OpenDDS::FaceTSS::Entities::senders_, DDS::SampleInfo::source_timestamp, OpenDDS::DCPS::TimePoint_T< AceClock >::to_dds_time(), DDS::DataWriterQos::user_data, and DDS::UserDataQosPolicy::value.

Referenced by OpenDDS::FaceTSS::Listener< Msg >::on_data_available(), and receive_message().

{
  Entities::ConnIdToReceiverMap& readers = Entities::instance()->receivers_;
  if (!readers.count(connection_id)) {
    return_code = FACE::INVALID_PARAM;
    return;
  }
  FACE::TS::MessageHeader& header = readers[connection_id]->last_msg_header;

  header.platform_view_guid = Entities::instance()->connections_[connection_id].platform_view_guid;

  DDS::Subscriber_var temp_sub = readers[connection_id]->dr->get_subscriber();
  DDS::DomainParticipant_var temp_dp = temp_sub->get_participant();
  OpenDDS::DCPS::DomainParticipantImpl* dpi = dynamic_cast<OpenDDS::DCPS::DomainParticipantImpl*>(temp_dp.in());
  if (!dpi) {
    ACE_ERROR((LM_ERROR, ACE_TEXT("(%P|%t) populate_header_received: ")
      ACE_TEXT("failed to get DomainParticipantImpl.\n")));
    return_code = FACE::NOT_AVAILABLE;
    return;
  }
  const OpenDDS::DCPS::GUID_t pub = dpi->get_repoid(sinfo.publication_handle);
  header.message_instance_guid = create_message_instance_guid(pub, sinfo.opendds_reserved_publication_seq);

  header.message_timestamp = convertTime(sinfo.source_timestamp);
  const OpenDDS::DCPS::SystemTimePoint now = OpenDDS::DCPS::SystemTimePoint::now();

  readers[connection_id]->sum_recvd_msgs_latency += (convertTime(now.to_dds_time()) - header.message_timestamp);
  ++readers[connection_id]->total_msgs_recvd;

  if (OpenDDS::DCPS::DCPS_debug_level > 8) {
    ACE_DEBUG((LM_DEBUG, "(%P|%t) populate_header_received: Latency is now (tot_latency %d / tot_msgs_recvd %d): %d\n",
        readers[connection_id]->sum_recvd_msgs_latency,
        readers[connection_id]->total_msgs_recvd,
        readers[connection_id]->sum_recvd_msgs_latency/readers[connection_id]->total_msgs_recvd));
  }

  DDS::UserDataQosPolicy qos_user_data;
  DDS::LifespanQosPolicy qos_lifespan;
  const OpenDDS::DCPS::GUID_t sub = dpi->get_id();

  // Test if the reader and writer share a participant
  if (std::memcmp(pub.guidPrefix, sub.guidPrefix, sizeof(sub.guidPrefix)) == 0) {

    Entities::ConnIdToSenderMap& writers = Entities::instance()->senders_;
    Entities::ConnIdToSenderMap::iterator wtrIter = writers.begin();

    // Search domain writers for the sending instance
    while (wtrIter != writers.end()) {
      if (wtrIter->second.dw->get_instance_handle() == sinfo.publication_handle) {
        break;
      }
      ++wtrIter;
    }

    if (wtrIter == writers.end()) {
      ACE_ERROR((LM_ERROR, "(%P|%t) populate_header_received: failed to find matching DataWriter instance.\n"));
      return_code = FACE::NOT_AVAILABLE;
      return;
    }

    DDS::DataWriterQos qos;
    wtrIter->second.dw->get_qos(qos);
    qos_lifespan = qos.lifespan;
    qos_user_data = qos.user_data;

  } else {
    ::DDS::Subscriber_var bit_subscriber
     = part->get_builtin_subscriber () ;

    ::DDS::DataReader_var reader
     = bit_subscriber->lookup_datareader (OpenDDS::DCPS::BUILT_IN_PUBLICATION_TOPIC) ;
    ::DDS::PublicationBuiltinTopicDataDataReader_var pub_reader
     = ::DDS::PublicationBuiltinTopicDataDataReader::_narrow (reader.in ());
    if (CORBA::is_nil (pub_reader.in ())) {
      ACE_ERROR((LM_ERROR, "(%P|%t) populate_header_received: failed to get BUILT_IN_PUBLICATION_TOPIC datareader.\n"));
      return_code = FACE::NOT_AVAILABLE;
      return;
    }

    ::DDS::ReturnCode_t ret;
    ::DDS::SampleInfoSeq pubinfos(1);
    ::DDS::PublicationBuiltinTopicDataSeq pubdata(1);

    ret = pub_reader->read_instance(pubdata,
                                    pubinfos,
                                    1,
                                    sinfo.publication_handle,
                                    ::DDS::ANY_SAMPLE_STATE,
                                    ::DDS::ANY_VIEW_STATE,
                                    ::DDS::ALIVE_INSTANCE_STATE);


    if (ret != ::DDS::RETCODE_OK && ret != ::DDS::RETCODE_NO_DATA) {
      ACE_ERROR((LM_ERROR,
          "(%P|%t) populate_header_received:  failed to read BIT publication data.\n"));
      return_code = FACE::NOT_AVAILABLE;
      return;
    }

    const CORBA::ULong i = 0;
    qos_lifespan = pubdata[i].lifespan;
    qos_user_data = pubdata[i].user_data;
  }

  header.message_source_guid =
    (qos_user_data.value[0] << 0) |
    (qos_user_data.value[1] << 8) |
    (qos_user_data.value[2] << 16);

//  ACE_DEBUG((LM_DEBUG, "(%P|%t) populate_header_received: DW lifespan qos value: sec: %d nanosec: %d\n",
//                         pubdata[i].lifespan.duration.sec, pubdata[i].lifespan.duration.nanosec));

  DDS::Duration_t lifespan = qos_lifespan.duration;
  if (lifespan.sec != DDS::DURATION_INFINITE_SEC &&
      lifespan.nanosec != DDS::DURATION_INFINITE_NSEC) {
    // Finite lifespan.  Check if data has expired.

    const DDS::Time_t tmp = {
      sinfo.source_timestamp.sec + lifespan.sec,
      sinfo.source_timestamp.nanosec + lifespan.nanosec
    };

    // We assume that the publisher host's clock and subscriber host's
    // clock are synchronized (allowed by the spec).
    const OpenDDS::DCPS::SystemTimePoint expiration_time(tmp);

    if (now >= expiration_time) {
//      ACE_DEBUG((LM_DEBUG, "(%P|%t) populate_header_received: Last message expired, setting message_validity to INVALID\n"));
      header.message_validity = FACE::INVALID;
      return_code = FACE::RC_NO_ERROR;
      return;
    }
  }
//  ACE_DEBUG((LM_DEBUG, "(%P|%t) populate_header_received: Setting message_validity to VALID\n"));
  header.message_validity = FACE::VALID;
  return_code = FACE::RC_NO_ERROR;
}

receive_message()

template<typename Msg >

void OpenDDS::FaceTSS::receive_message	(	FACE::CONNECTION_ID_TYPE	connection_id,
		FACE::TIMEOUT_TYPE	timeout,
		FACE::TRANSACTION_ID_TYPE &	transaction_id,
		Msg &	message,
		FACE::MESSAGE_SIZE_TYPE	message_size,
		FACE::RETURN_CODE_TYPE &	return_code
	)

Definition at line 144 of file FaceTSS.h.

References ACE_ERROR, DDS::ALIVE_INSTANCE_STATE, DDS::ANY_SAMPLE_STATE, DDS::ANY_VIEW_STATE, convertTimeout(), OpenDDS::DCPS::DCPS_debug_level, OpenDDS::FaceTSS::Entities::FaceReceiver::dr, OpenDDS::FaceTSS::Entities::instance(), LM_ERROR, populate_header_received(), OpenDDS::FaceTSS::Entities::receivers_, DDS::RETCODE_BAD_PARAMETER, DDS::RETCODE_NO_DATA, DDS::RETCODE_OK, DDS::RETCODE_TIMEOUT, OpenDDS::FaceTSS::Entities::DDSAdapter::status_valid, and update_status().

{
  try {
    Entities::ConnIdToReceiverMap& readers = Entities::instance()->receivers_;
    if (!readers.count(connection_id)) {
      return_code = FACE::INVALID_PARAM;
      return;
    }
    if (!Entities::instance()->connections_.count(connection_id)) {
      return_code = FACE::INVALID_PARAM;
      return;
    }
    FACE::TRANSPORT_CONNECTION_STATUS_TYPE status =
      Entities::instance()->connections_[connection_id].connection_status;
    if (message_size < status.MAX_MESSAGE_SIZE) {
      return_code = FACE::INVALID_PARAM;
      return;
    }
    typedef typename DCPS::DDSTraits<Msg>::DataReaderType DataReader;
    const typename DataReader::_var_type typedReader =
      DataReader::_narrow(readers[connection_id]->dr);
    if (!typedReader) {
      return_code = update_status(connection_id, DDS::RETCODE_BAD_PARAMETER);
      return;
    }
    if (readers[connection_id]->status_valid != FACE::VALID) {
      Entities::FaceReceiver* tmp = readers[connection_id];
      readers[connection_id] = new Entities::DDSTypedAdapter<Msg>(*readers[connection_id]);
      delete tmp;
    }
    readers[connection_id]->status_valid = FACE::VALID;

    const DDS::ReadCondition_var rc =
      typedReader->create_readcondition(DDS::ANY_SAMPLE_STATE,
        DDS::ANY_VIEW_STATE,
        DDS::ALIVE_INSTANCE_STATE);
    const DDS::WaitSet_var ws = new DDS::WaitSet;
    ws->attach_condition(rc);

    DDS::ConditionSeq active;
    const DDS::Duration_t ddsTimeout = convertTimeout(timeout);
    DDS::ReturnCode_t ret = ws->wait(active, ddsTimeout);
    ws->detach_condition(rc);

    if (ret == DDS::RETCODE_TIMEOUT) {
      typedReader->delete_readcondition(rc);
      return_code = update_status(connection_id, ret);
      return;
    }

    typename DCPS::DDSTraits<Msg>::MessageSequenceType seq;
    DDS::SampleInfoSeq sinfo;
    ret = typedReader->take_w_condition(seq, sinfo, 1 /*max*/, rc);
    typedReader->delete_readcondition(rc);
    if (ret == DDS::RETCODE_OK && sinfo[0].valid_data) {
      DDS::Subscriber_var subscriber = typedReader->get_subscriber();
      DDS::DomainParticipant_var participant = subscriber->get_participant();
      FACE::RETURN_CODE_TYPE ret_code;
      populate_header_received(connection_id, participant, sinfo[0], ret_code);
      if (ret_code != FACE::RC_NO_ERROR) {
        return_code = update_status(connection_id, ret_code);
        return;
      }

      transaction_id = ++readers[connection_id]->last_msg_tid;

      message = seq[0];
      return_code = update_status(connection_id, ret);
      return;
    }
    return_code = update_status(connection_id, DDS::RETCODE_NO_DATA);
  } catch (const CORBA::BAD_PARAM&) {
    if (OpenDDS::DCPS::DCPS_debug_level) {
      ACE_ERROR((LM_ERROR, "(%P|%t) ERROR: receive_message - INVALID_PARAM\n"));
    }
    return_code = FACE::INVALID_PARAM;
  }
}

register_callback()

template<typename Msg >

void OpenDDS::FaceTSS::register_callback	(	FACE::CONNECTION_ID_TYPE	connection_id,
		const FACE::WAITSET_TYPE	,
		void(*)(FACE::TRANSACTION_ID_TYPE, Msg &, FACE::MESSAGE_TYPE_GUID, FACE::MESSAGE_SIZE_TYPE, const FACE::WAITSET_TYPE, FACE::RETURN_CODE_TYPE &)	callback,
		FACE::MESSAGE_SIZE_TYPE	max_message_size,
		FACE::RETURN_CODE_TYPE &	return_code
	)

Definition at line 362 of file FaceTSS.h.

References ACE_ERROR, OpenDDS::FaceTSS::Listener< Msg >::add_callback(), DDS::DATA_AVAILABLE_STATUS, OpenDDS::FaceTSS::Entities::instance(), LM_ERROR, OPENDDS_END_VERSIONED_NAMESPACE_DECL, OpenDDS::FaceTSS::Entities::receivers_, and OpenDDS::FaceTSS::Entities::DDSAdapter::status_valid.

{
  Entities::ConnIdToReceiverMap& readers = Entities::instance()->receivers_;
  if (!readers.count(connection_id)) {
    return_code = FACE::INVALID_PARAM;
    return;
  }
  if(!Entities::instance()->connections_.count(connection_id)) {
    return_code = FACE::INVALID_PARAM;
    return;
  }
  FACE::TRANSPORT_CONNECTION_STATUS_TYPE status =
    Entities::instance()->connections_[connection_id].connection_status;
  if (max_message_size < status.MAX_MESSAGE_SIZE) {
    return_code = FACE::INVALID_PARAM;
    return;
  }
  DDS::DataReaderListener_var existing_listener = readers[connection_id]->dr->get_listener();
  if (existing_listener.in()) {
    Listener<Msg>* typedListener = dynamic_cast<Listener<Msg>*>(existing_listener.in());
    if (typedListener) {
      typedListener->add_callback(callback);
    } else {
      ACE_ERROR((LM_ERROR, "ERROR: register_callback - failed to obtain typed listener\n"));
      return_code = FACE::INVALID_PARAM;
      return;
    }
  } else {
    DDS::DataReaderListener_var listener = new Listener<Msg>(callback, connection_id);
    readers[connection_id]->dr->set_listener(listener, DDS::DATA_AVAILABLE_STATUS);
  }
  if (readers[connection_id]->status_valid != FACE::VALID) {
    Entities::FaceReceiver* tmp = readers[connection_id];
    readers[connection_id] = new Entities::DDSTypedAdapter<Msg>(*readers[connection_id]);
    delete tmp;
  }
  readers[connection_id]->status_valid = FACE::VALID;

  return_code = FACE::RC_NO_ERROR;
}

send_message()

template<typename Msg >

void OpenDDS::FaceTSS::send_message	(	FACE::CONNECTION_ID_TYPE	connection_id,
		FACE::TIMEOUT_TYPE	timeout,
		FACE::TRANSACTION_ID_TYPE &	,
		const Msg &	message,
		FACE::MESSAGE_SIZE_TYPE	message_size,
		FACE::RETURN_CODE_TYPE &	return_code
	)

Definition at line 229 of file FaceTSS.h.

References convertDuration(), DataWriter, DDS::HANDLE_NIL, OpenDDS::FaceTSS::Entities::instance(), DDS::ReliabilityQosPolicy::kind, DDS::ReliabilityQosPolicy::max_blocking_time, DDS::DataWriterQos::reliability, DDS::RELIABLE_RELIABILITY_QOS, DDS::RETCODE_BAD_PARAMETER, OpenDDS::FaceTSS::Entities::senders_, and update_status().

{
  if(!Entities::instance()->connections_.count(connection_id)) {
    return_code = FACE::INVALID_PARAM;
    return;
  }
  FACE::TRANSPORT_CONNECTION_STATUS_TYPE status =
    Entities::instance()->connections_[connection_id].connection_status;
  if (message_size < status.MAX_MESSAGE_SIZE) {
    return_code = FACE::INVALID_PARAM;
    return;
  }
  Entities::ConnIdToSenderMap& writers = Entities::instance()->senders_;
  if (!writers.count(connection_id)) {
    return_code = FACE::INVALID_PARAM;
    return;
  }

  typedef typename DCPS::DDSTraits<Msg>::DataWriterType DataWriter;
  const typename DataWriter::_var_type typedWriter =
    DataWriter::_narrow(writers[connection_id].dw);
  if (!typedWriter) {
    return_code = update_status(connection_id, DDS::RETCODE_BAD_PARAMETER);
    return;
  }
  writers[connection_id].status_valid = FACE::VALID;

  DDS::DataWriterQos dw_qos;
  typedWriter->get_qos(dw_qos);
  FACE::SYSTEM_TIME_TYPE max_blocking_time = convertDuration(dw_qos.reliability.max_blocking_time);
  if (dw_qos.reliability.kind == DDS::RELIABLE_RELIABILITY_QOS &&
      timeout != FACE::INF_TIME_VALUE &&
      ((max_blocking_time == FACE::INF_TIME_VALUE) || (timeout < max_blocking_time))) {
    return_code = update_status(connection_id, DDS::RETCODE_BAD_PARAMETER);
    return;
  }

  return_code = update_status(connection_id, typedWriter->write(message, DDS::HANDLE_NIL));
}

update_status()

OpenDDS_FACE_Export FACE::RETURN_CODE_TYPE OpenDDS::FaceTSS::update_status	(	FACE::CONNECTION_ID_TYPE	connection_id,
		DDS::ReturnCode_t	retcode
	)

Definition at line 730 of file FaceTSS.cpp.

References OpenDDS::FaceTSS::Entities::instance(), DDS::RETCODE_ALREADY_DELETED, DDS::RETCODE_BAD_PARAMETER, DDS::RETCODE_ERROR, DDS::RETCODE_ILLEGAL_OPERATION, DDS::RETCODE_IMMUTABLE_POLICY, DDS::RETCODE_INCONSISTENT_POLICY, DDS::RETCODE_NO_DATA, DDS::RETCODE_NOT_ENABLED, DDS::RETCODE_OK, DDS::RETCODE_OUT_OF_RESOURCES, DDS::RETCODE_PRECONDITION_NOT_MET, DDS::RETCODE_TIMEOUT, and DDS::RETCODE_UNSUPPORTED.

Referenced by OpenDDS::FaceTSS::Listener< Msg >::on_data_available(), FACE::TS::receive_header(), receive_message(), and send_message().

{
  FACE::TRANSPORT_CONNECTION_STATUS_TYPE& status =
    Entities::instance()->connections_[connection_id].connection_status;
  FACE::RETURN_CODE_TYPE rc = FACE::INVALID_PARAM;

  switch (retcode) {
  case DDS::RETCODE_OK:
    status.LAST_MSG_VALIDITY = FACE::VALID;
    return FACE::RC_NO_ERROR;

  case DDS::RETCODE_ERROR:
    rc = FACE::CONNECTION_CLOSED; break;

  case DDS::RETCODE_BAD_PARAMETER:
    rc = FACE::INVALID_PARAM; break;

  case DDS::RETCODE_OUT_OF_RESOURCES:
    rc = FACE::DATA_BUFFER_TOO_SMALL; break;

  case DDS::RETCODE_PRECONDITION_NOT_MET:
  case DDS::RETCODE_NOT_ENABLED:
    rc = FACE::INVALID_MODE; break;

  case DDS::RETCODE_IMMUTABLE_POLICY:
  case DDS::RETCODE_INCONSISTENT_POLICY:
    rc = FACE::INVALID_CONFIG; break;

  case DDS::RETCODE_ALREADY_DELETED:
    rc = FACE::CONNECTION_CLOSED; break;

  case DDS::RETCODE_TIMEOUT:
    rc = FACE::TIMED_OUT; break;

  case DDS::RETCODE_UNSUPPORTED:
  case DDS::RETCODE_NO_DATA:
    rc = FACE::NOT_AVAILABLE; break;

  case DDS::RETCODE_ILLEGAL_OPERATION:
    rc = FACE::PERMISSION_DENIED; break;
  }

  status.LAST_MSG_VALIDITY = FACE::INVALID;
  return rc;
}