void async_receive_from(implementation_type& impl,
const null_buffers&, endpoint_type& sender_endpoint,
socket_base::message_flags flags, Handler& handler)
{
bool is_continuation =
asio_handler_cont_helpers::is_continuation(handler);
// Allocate and construct an operation to wrap the handler.
typedef reactive_null_buffers_op<Handler> op;
typename op::ptr p = { asio::detail::addressof(handler),
asio_handler_alloc_helpers::allocate(
sizeof(op), handler), 0 };
p.p = new (p.v) op(handler);
ASIO_HANDLER_CREATION((p.p, "socket",
&impl, "async_receive_from(null_buffers)"));
// Reset endpoint since it can be given no sensible value at this time.
sender_endpoint = endpoint_type();
start_op(impl,
(flags & socket_base::message_out_of_band)
? reactor::except_op : reactor::read_op,
p.p, is_continuation, false, false);
p.v = p.p = 0;
}
void async_receive_from(implementation_type& impl,
const MutableBufferSequence& buffers, endpoint_type& sender_endpoint,
socket_base::message_flags flags, Handler& handler)
{
bool is_continuation =
asio_handler_cont_helpers::is_continuation(handler);
// Allocate and construct an operation to wrap the handler.
typedef reactive_socket_recvfrom_op<MutableBufferSequence,
endpoint_type, Handler> op;
typename op::ptr p = { asio::detail::addressof(handler),
asio_handler_alloc_helpers::allocate(
sizeof(op), handler), 0 };
int protocol = impl.protocol_.type();
p.p = new (p.v) op(impl.socket_, protocol,
buffers, sender_endpoint, flags, handler);
ASIO_HANDLER_CREATION((p.p, "socket",
&impl, "async_receive_from"));
start_op(impl,
(flags & socket_base::message_out_of_band)
? reactor::except_op : reactor::read_op,
p.p, is_continuation, true, false);
p.v = p.p = 0;
}
void async_send(base_implementation_type& impl, const null_buffers&,
socket_base::message_flags, Handler handler)
{
// Allocate and construct an operation to wrap the handler.
typedef reactive_null_buffers_op<Handler> op;
typename op::ptr p = { boost::addressof(handler),
asio_handler_alloc_helpers::allocate(
sizeof(op), handler), 0 };
p.p = new (p.v) op(handler);
start_op(impl, reactor::write_op, p.p, false, false);
p.v = p.p = 0;
}
void async_read_some(implementation_type& impl,
const null_buffers&, Handler handler)
{
// Allocate and construct an operation to wrap the handler.
typedef reactive_null_buffers_op<Handler> op;
typename op::ptr p = { boost::addressof(handler),
boost_asio_handler_alloc_helpers::allocate(
sizeof(op), handler), 0 };
p.p = new (p.v) op(handler);
start_op(impl, reactor::read_op, p.p, false, false);
p.v = p.p = 0;
}
void async_read_some(implementation_type& impl,
const MutableBufferSequence& buffers, Handler handler)
{
// Allocate and construct an operation to wrap the handler.
typedef descriptor_read_op<MutableBufferSequence, Handler> op;
typename op::ptr p = { boost::addressof(handler),
asio_handler_alloc_helpers::allocate(
sizeof(op), handler), 0 };
p.p = new (p.v) op(impl.descriptor_, buffers, handler);
start_op(impl, reactor::read_op, p.p, true,
buffer_sequence_adapter<asio::mutable_buffer,
MutableBufferSequence>::all_empty(buffers));
p.v = p.p = 0;
}
void async_write_some(implementation_type& impl,
const null_buffers&, Handler& handler)
{
// Allocate and construct an operation to wrap the handler.
typedef reactive_null_buffers_op<Handler> op;
typename op::ptr p = { boost::addressof(handler),
asio_handler_alloc_helpers::allocate(
sizeof(op), handler), 0 };
p.p = new (p.v) op(handler);
ASIO_HANDLER_CREATION((p.p, "descriptor",
&impl, "async_write_some(null_buffers)"));
start_op(impl, reactor::write_op, p.p, false, false);
p.v = p.p = 0;
}
void async_write_some(implementation_type& impl,
const ConstBufferSequence& buffers, Handler& handler)
{
// Allocate and construct an operation to wrap the handler.
typedef descriptor_write_op<ConstBufferSequence, Handler> op;
typename op::ptr p = { boost::addressof(handler),
asio_handler_alloc_helpers::allocate(
sizeof(op), handler), 0 };
p.p = new (p.v) op(impl.descriptor_, buffers, handler);
ASIO_HANDLER_CREATION((p.p, "descriptor", &impl, "async_write_some"));
start_op(impl, reactor::write_op, p.p, true,
buffer_sequence_adapter<asio::const_buffer,
ConstBufferSequence>::all_empty(buffers));
p.v = p.p = 0;
}
void async_send(base_implementation_type& impl,
const ConstBufferSequence& buffers,
socket_base::message_flags flags, Handler handler)
{
// Allocate and construct an operation to wrap the handler.
typedef reactive_socket_send_op<ConstBufferSequence, Handler> op;
typename op::ptr p = { boost::addressof(handler),
asio_handler_alloc_helpers::allocate(
sizeof(op), handler), 0 };
p.p = new (p.v) op(impl.socket_, buffers, flags, handler);
start_op(impl, reactor::write_op, p.p, true,
((impl.state_ & socket_ops::stream_oriented)
&& buffer_sequence_adapter<asio::const_buffer,
ConstBufferSequence>::all_empty(buffers)));
p.v = p.p = 0;
}
void async_send_to(implementation_type& impl, const null_buffers&,
const endpoint_type&, socket_base::message_flags, Handler& handler)
{
bool is_continuation =
asio_handler_cont_helpers::is_continuation(handler);
// Allocate and construct an operation to wrap the handler.
typedef reactive_null_buffers_op<Handler> op;
typename op::ptr p = { asio::detail::addressof(handler),
op::ptr::allocate(handler), 0 };
p.p = new (p.v) op(handler);
ASIO_HANDLER_CREATION((p.p, "socket",
&impl, "async_send_to(null_buffers)"));
start_op(impl, reactor::write_op, p.p, is_continuation, false, false);
p.v = p.p = 0;
}
void async_read_some(implementation_type& impl,
const null_buffers&, Handler& handler)
{
bool is_continuation =
pdalboost_asio_handler_cont_helpers::is_continuation(handler);
// Allocate and construct an operation to wrap the handler.
typedef reactive_null_buffers_op<Handler> op;
typename op::ptr p = { pdalboost::asio::detail::addressof(handler),
pdalboost_asio_handler_alloc_helpers::allocate(
sizeof(op), handler), 0 };
p.p = new (p.v) op(handler);
BOOST_ASIO_HANDLER_CREATION((p.p, "descriptor",
&impl, "async_read_some(null_buffers)"));
start_op(impl, reactor::read_op, p.p, is_continuation, false, false);
p.v = p.p = 0;
}
void async_read_some(implementation_type& impl,
const MutableBufferSequence& buffers, Handler& handler)
{
bool is_continuation =
pdalboost_asio_handler_cont_helpers::is_continuation(handler);
// Allocate and construct an operation to wrap the handler.
typedef descriptor_read_op<MutableBufferSequence, Handler> op;
typename op::ptr p = { pdalboost::asio::detail::addressof(handler),
pdalboost_asio_handler_alloc_helpers::allocate(
sizeof(op), handler), 0 };
p.p = new (p.v) op(impl.descriptor_, buffers, handler);
BOOST_ASIO_HANDLER_CREATION((p.p, "descriptor", &impl, "async_read_some"));
start_op(impl, reactor::read_op, p.p, is_continuation, true,
buffer_sequence_adapter<pdalboost::asio::mutable_buffer,
MutableBufferSequence>::all_empty(buffers));
p.v = p.p = 0;
}
bool i2cman_execute(const i2c_op_t * _begin, const i2c_op_t * _end, void (* succ)(void), void (* err)(uint32_t))
{
if(!current_op)
{
begin = _begin;
end = _end;
current_op = begin;
success_func = succ;
error_func = err;
// activates the interrupt handler
//
// also activates my trap card
start_op(current_op);
return true;
}
return false;
}
void async_receive(base_implementation_type& impl,
const MutableBufferSequence& buffers,
socket_base::message_flags flags, Handler handler)
{
// Allocate and construct an operation to wrap the handler.
typedef reactive_socket_recv_op<MutableBufferSequence, Handler> op;
typename op::ptr p = { boost::addressof(handler),
asio_handler_alloc_helpers::allocate(
sizeof(op), handler), 0 };
p.p = new (p.v) op(impl.socket_, impl.state_, buffers, flags, handler);
start_op(impl,
(flags & socket_base::message_out_of_band)
? reactor::except_op : reactor::read_op,
p.p, (flags & socket_base::message_out_of_band) == 0,
((impl.state_ & socket_ops::stream_oriented)
&& buffer_sequence_adapter<asio::mutable_buffer,
MutableBufferSequence>::all_empty(buffers)));
p.v = p.p = 0;
}
void async_send_to(implementation_type& impl,
const ConstBufferSequence& buffers,
const endpoint_type& destination, socket_base::message_flags flags,
Handler& handler)
{
bool is_continuation =
asio_handler_cont_helpers::is_continuation(handler);
// Allocate and construct an operation to wrap the handler.
typedef reactive_socket_sendto_op<ConstBufferSequence,
endpoint_type, Handler> op;
typename op::ptr p = { asio::detail::addressof(handler),
op::ptr::allocate(handler), 0 };
p.p = new (p.v) op(impl.socket_, buffers, destination, flags, handler);
ASIO_HANDLER_CREATION((p.p, "socket", &impl, "async_send_to"));
start_op(impl, reactor::write_op, p.p, is_continuation, true, false);
p.v = p.p = 0;
}
void i2cman_handler()
{
ROM_I2CMasterIntClear(I2C_PORT);
if(current_op == end || current_op == 0)
return; // do absolutely nothing (irq may be called after aborting)
uint32_t error = finish_op(current_op);
if(error != I2C_MASTER_ERR_NONE)
{
stop();
if(error & I2C_MASTER_ERR_ARB_LOST)
{
if(error_func)
error_func(I2C_ARBLOST);
}
else
{
// error, abort completely
//kill_op(current_op);
// bad bad bad!
if(error_func)
error_func(I2C_NOACK);
}
return;
}
current_op ++;
if(current_op == end)
{
stop(); // all done
if(success_func)
success_func();
return;
}
// otherwise, process the next op
start_op(current_op);
}
