Method wait

dds/DCPS/WaitSet.cpp:112–169

}

ReturnCode_t WaitSet::wait(ConditionSeq& active_conditions,
                           const Duration_t& timeout)
{
  using namespace OpenDDS::DCPS;

  if (!non_negative_duration(timeout)) {
    return DDS::RETCODE_BAD_PARAMETER;
  }

  MonotonicTimePoint deadline;
  const bool use_deadline = !is_infinite(timeout);
  if (use_deadline) {
    deadline = MonotonicTimePoint::now() + TimeDuration(timeout);
  }

  ACE_GUARD_RETURN(ACE_Recursive_Thread_Mutex, g, lock_,
                   RETCODE_OUT_OF_RESOURCES);

  if (waiting_) {
    return RETCODE_PRECONDITION_NOT_MET;
  }

  waiting_ = true;
  signaled_conditions_.clear();

  for (ConditionSet::const_iterator iter = attached_conditions_.begin(),
       end = attached_conditions_.end(); iter != end; ++iter) {
    if ((*iter)->get_trigger_value()) {
      signaled_conditions_.insert(*iter);
    }
  }

  CvStatus status = CvStatus_NoTimeout;
  ThreadStatusManager& thread_status_manager = TheServiceParticipant->get_thread_status_manager();
  while ((attached_conditions_.empty() || signaled_conditions_.empty()) &&
      status == CvStatus_NoTimeout) {
    status = use_deadline ? cond_.wait_until(deadline, thread_status_manager) : cond_.wait(thread_status_manager);
  }

  copyInto(active_conditions, signaled_conditions_);
  signaled_conditions_.clear();
  waiting_ = false;

  switch (status) {
  case CvStatus_NoTimeout:
    return RETCODE_OK;

  case CvStatus_Timeout:
    return RETCODE_TIMEOUT;

  case CvStatus_Error:
  default:
    if (DCPS_debug_level) {
      ACE_ERROR((LM_ERROR, "(%P|%t) ERROR: WaitSet::wait: wait_until failed\n"));
    }
    return RETCODE_ERROR;
  }
}