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); }