mutable_buffer connection_engine::read_buffer() {
ssize_t cap = pn_transport_capacity(unwrap(transport_));
if (cap > 0)
return mutable_buffer(pn_transport_tail(unwrap(transport_)), cap);
else
return mutable_buffer(0, 0);
}
/**
* @relates mutable_buffer
*/
inline mutable_buffer operator+(std::size_t start, const mutable_buffer& b)
{
if (start > buffer_size(b))
return mutable_buffer();
char* new_data = buffer_cast<char*>(b) + start;
std::size_t new_size = buffer_size(b) - start;
return mutable_buffer(new_data, new_size);
}
/// Create a new modifiable buffer from an existing buffer.
inline mutable_buffer_container_1 buffer(const mutable_buffer& b,
std::size_t max_size_in_bytes)
{
return mutable_buffer_container_1(
mutable_buffer(buffer_cast<void*>(b),
buffer_size(b) < max_size_in_bytes
? buffer_size(b) : max_size_in_bytes));
}
inline mutable_buffer_container_1 buffer(std::vector<Pod_Type, Allocator>& data,
std::size_t max_size_in_bytes)
{
return mutable_buffer_container_1(
mutable_buffer(&data[0],
data.size() * sizeof(Pod_Type) < max_size_in_bytes
? data.size() * sizeof(Pod_Type) : max_size_in_bytes));
}
void mfd::EventSender::send_buffer(frontend::BufferStreamId id, graphics::Buffer& buffer, mg::BufferIpcMsgType type)
{
mp::EventSequence seq;
auto request = seq.mutable_buffer_request();
request->mutable_id()->set_value(id.as_value());
request->mutable_buffer()->set_buffer_id(buffer.id().as_value());
mfd::ProtobufBufferPacker request_msg{const_cast<mir::protobuf::Buffer*>(request->mutable_buffer())};
buffer_packer->pack_buffer(request_msg, buffer, type);
std::vector<mir::Fd> set;
for(auto& fd : request->buffer().fd())
set.emplace_back(mir::Fd(IntOwnedFd{fd}));
request->mutable_buffer()->set_fds_on_side_channel(set.size());
send_event_sequence(seq, {set});
}
void uninitialize()
{
++ globalCounter;
LEMON_CHECK(counter == maxCounter);
send(LEMON_SET_JOBID_REMOTE(1,1),mutable_buffer());
}
inline mutable_buffer_container_1 buffer(boost::array<Pod_Type, N>& data,
std::size_t max_size_in_bytes)
{
return mutable_buffer_container_1(
mutable_buffer(data.c_array(),
data.size() * sizeof(Pod_Type) < max_size_in_bytes
? data.size() * sizeof(Pod_Type) : max_size_in_bytes));
}
inline mutable_buffer_container_1 buffer(Pod_Type (&data)[N],
std::size_t max_size_in_bytes)
{
return mutable_buffer_container_1(
mutable_buffer(data,
N * sizeof(Pod_Type) < max_size_in_bytes
? N * sizeof(Pod_Type) : max_size_in_bytes));
}
void multicast(lemon_job_id source, const_buffer buff)
{
maxCounter = buffer_cast<size_t>(buff);
send(source, mutable_buffer());
++ counter;
_timer.reset();
}
LEMON_UNITTEST_CASE(RunQUnittest,ResetJobTest)
{
runQ_service Q;
for(size_t i = 0; i < 10000; ++ i)
{
job_id id = ResetJob::create(Q);
runQ::send(Q,LEMON_INVALID_JOBID,id,mutable_buffer());
Q.run();
Q.reset();
LEMON_CHECK(Q.jobs() == 0);
}
}
void timeout()
{
lemon::timer_t timer;
send(_group,mutable_buffer());
time_duration duration = timer.duration();
std::cout << "multicast send(" << counter << ") -- success("
<< duration / 10000000 << "."
<< std::setw(6) << std::setfill('0') <<(duration % 10000000) / 10
<< " s)" << std::endl;
std::cout << "group job counter(" << jobs(runQ()) << ")" << std::endl;
if(jobs(runQ()) == 1) exit();
}
void timeout()
{
std::cout << "taxi counter :" << jobs(runQ()) << std::endl;
if(jobs(runQ()) == 1) {
exit();
return;
}
std::vector<job_id>::const_iterator iter,end = _taxis.end();
for(iter = _taxis.begin(); iter != end; ++ iter)
{
try
{
send(*iter,mutable_buffer());
}
catch(const error_info & e)
{
if(!LEMON_ERRORINOF_EQ(e.Error,LEMON_RUNQ_INVALID_JOB_ID)) throw e;
}
}
}
BasicConnection::Buffer::operator boost::asio::mutable_buffer( void ){
return mutable_buffer( (void*)m_data.data(), m_data.size() );
}
inline mutable_buffer buf(char (&source) [N])
{
return mutable_buffer((byte_t*)source,N);
}
inline mutable_buffer buf(byte_t (&source) [N])
{
return mutable_buffer(source,N);
}
inline mutable_buffer buf(T & t)
{
return mutable_buffer((lemon_byte_t*)&t,sizeof(T));
}
/// Create a new modifiable buffer that represents the given memory range.
inline mutable_buffer_container_1 buffer(void* data, std::size_t size_in_bytes)
{
return mutable_buffer_container_1(mutable_buffer(data, size_in_bytes));
}
inline mutable_buffer_container_1 buffer(std::vector<Pod_Type, Allocator>& data)
{
return mutable_buffer_container_1(
mutable_buffer(&data[0], data.size() * sizeof(Pod_Type)));
}
inline mutable_buffer_container_1 buffer(boost::array<Pod_Type, N>& data)
{
return mutable_buffer_container_1(
mutable_buffer(data.c_array(), data.size() * sizeof(Pod_Type)));
}
inline mutable_buffer_container_1 buffer(Pod_Type (&data)[N])
{
return mutable_buffer_container_1(mutable_buffer(data, N * sizeof(Pod_Type)));
}
inline mutable_buffer buf(byte_t * source,size_t length)
{
return mutable_buffer(source,length);
}
inline mutable_buffer mutable_buffer_cast(Buffer buffer)
{
return mutable_buffer((byte_t*)buffer.Data,buffer.Length);
}
