bool coalescing_message_handler::flush(
boost::unique_lock<mutex_type>& l,
bool stop_buffering)
{
HPX_ASSERT(l.owns_lock());
if (!stopped_ && stop_buffering) {
stopped_ = true;
util::unlock_guard<boost::unique_lock<mutex_type> > ul(l);
timer_.stop(); // interrupt timer
}
if (buffer_.empty())
return false;
detail::message_buffer buff (buffer_.capacity());
std::swap(buff, buffer_);
l.unlock();
HPX_ASSERT(NULL != pp_);
buff(pp_); // 'invoke' the buffer
return true;
}
future_status result::wait_until(time_point const& wait_timeout_time,
boost::unique_lock<boost::mutex>& lock) const
{
if(ready(lock))
return future_status::ready;
while(!expired() && !(clock_type::now() > wait_timeout_time))
{
// note: don't set to wait for 0 ms, it might not timeout
if(m_condition.wait_for(lock, boost::chrono::milliseconds(1),
boost::bind(&result::ready, this, boost::ref(lock))))
{
return future_status::ready;
}
if(expired() || (clock_type::now() > wait_timeout_time))
break;
lock.unlock();
io_runner::poll_one(*m_io_service);
lock.lock();
}
if(clock_type::now() > wait_timeout_time)
return future_status::timeout;
BOOST_ASSERT(expired());
m_exception = boost::make_shared<remote_error>
(remote_error::timeout, "remote call timeout");
m_ready = true;
return future_status::ready;
}
connection_ptr accept_locked(boost::unique_lock<mutex_type> & header_lock)
{
connection_ptr res;
util::mpi_environment::scoped_try_lock l;
if(l.locked)
{
MPI_Status status;
if(request_done_locked(hdr_request_, &status))
{
header h = new_header();
l.unlock();
header_lock.unlock();
res.reset(
new connection_type(
status.MPI_SOURCE
, h
, pp_
)
);
return res;
}
}
return res;
}
void Bank::setPlanet(boost::unique_lock<boost::mutex>& lock, int8_t planet) {
planet_ = planet;
auto dispatcher = GetEventDispatcher();
lock.unlock();
dispatcher->DispatchMainThread(std::make_shared<CreatureObjectEvent>("CreatureObject::PersistHomeBank", owner_->GetCreature()));
}
void Bank::setCredits(boost::unique_lock<boost::mutex>& lock, uint32 credits) {
credits_ = credits;
auto dispatcher = GetEventDispatcher();
lock.unlock();
dispatcher->Dispatch(std::make_shared<CreatureObjectEvent>("CreatureObject::BankCredits", owner_->GetCreature()));
dispatcher->DispatchMainThread(std::make_shared<CreatureObjectEvent>("CreatureObject::PersistBankCredits", owner_->GetCreature()));
}
bool StatelessReader::change_received(CacheChange_t* change, boost::unique_lock<boost::recursive_mutex> &lock)
{
// Only make visible the change if there is not other with bigger sequence number.
// TODO Revisar si no hay que incluirlo.
if(!mp_history->thereIsUpperRecordOf(change->writerGUID, change->sequenceNumber))
{
if(mp_history->received_change(change, 0))
{
if(getListener() != nullptr)
{
lock.unlock();
getListener()->onNewCacheChangeAdded((RTPSReader*)this,change);
lock.lock();
}
mp_history->postSemaphore();
return true;
}
}
return false;
}