mirror of https://gitee.com/bigwinds/arangodb
302 lines
8.9 KiB
Plaintext
302 lines
8.9 KiB
Plaintext
[/
|
|
/ Copyright (c) 2003-2016 Christopher M. Kohlhoff (chris at kohlhoff dot com)
|
|
/
|
|
/ Distributed under the Boost Software License, Version 1.0. (See accompanying
|
|
/ file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
|
|
/]
|
|
|
|
[section:SerialPortService Serial port service requirements]
|
|
|
|
A serial port service must meet the requirements for an [link
|
|
boost_asio.reference.IoObjectService I/O object service] with support for movability,
|
|
as well as the additional requirements listed below.
|
|
|
|
In the table below, `X` denotes a serial port service class, `a` and `ao` denote
|
|
values of type `X`, `d` denotes a serial port device name of type `std::string`,
|
|
`b` and `c` denote values of type `X::implementation_type`, `n` denotes a value
|
|
of type `X::native_handle_type`, `ec` denotes a value of type `error_code`, `s`
|
|
denotes a value meeting [link boost_asio.reference.SettableSerialPortOption
|
|
`SettableSerialPortOption`] requirements, `g` denotes a value meeting [link
|
|
boost_asio.reference.GettableSerialPortOption `GettableSerialPortOption`]
|
|
requirements, `mb` denotes a value satisfying [link
|
|
boost_asio.reference.MutableBufferSequence mutable buffer sequence] requirements,
|
|
`rh` denotes a value meeting [link boost_asio.reference.ReadHandler `ReadHandler`]
|
|
requirements, `cb` denotes a value satisfying [link
|
|
boost_asio.reference.ConstBufferSequence constant buffer sequence] requirements, and
|
|
`wh` denotes a value meeting [link boost_asio.reference.WriteHandler `WriteHandler`]
|
|
requirements. and `u` and `v` denote identifiers.
|
|
|
|
[table SerialPortService requirements
|
|
[[expression] [return type] [assertion/note\npre/post-condition]]
|
|
[
|
|
[`X::native_handle_type`]
|
|
[]
|
|
[
|
|
The implementation-defined native representation of a serial port. Must
|
|
satisfy the requirements of `CopyConstructible` types (C++ Std, 20.1.3),
|
|
and the requirements of `Assignable` types (C++ Std, 23.1).
|
|
]
|
|
]
|
|
[
|
|
[`a.construct(b);`]
|
|
[]
|
|
[
|
|
From [link boost_asio.reference.IoObjectService IoObjectService]
|
|
requirements.\n
|
|
post: `!a.is_open(b)`.
|
|
]
|
|
]
|
|
[
|
|
[`a.destroy(b);`]
|
|
[]
|
|
[
|
|
From [link boost_asio.reference.IoObjectService IoObjectService]
|
|
requirements. Implicitly cancels asynchronous operations, as if by calling
|
|
`a.close(b, ec)`.
|
|
]
|
|
]
|
|
[
|
|
[``
|
|
a.move_construct(b, c);
|
|
``]
|
|
[]
|
|
[
|
|
From [link boost_asio.reference.IoObjectService IoObjectService] requirements.
|
|
The underlying native representation is moved from `c` to `b`.
|
|
]
|
|
]
|
|
[
|
|
[``
|
|
a.move_assign(b, ao, c);
|
|
``]
|
|
[]
|
|
[
|
|
From [link boost_asio.reference.IoObjectService IoObjectService] requirements.
|
|
Implicitly cancels asynchronous operations associated with `b`, as if by
|
|
calling `a.close(b, ec)`. Then the underlying native representation is
|
|
moved from `c` to `b`.
|
|
]
|
|
]
|
|
[
|
|
[``
|
|
const std::string& u = d;
|
|
a.open(b, u, ec);
|
|
``]
|
|
[`error_code`]
|
|
[
|
|
pre: `!a.is_open(b)`.\n
|
|
post: `!!ec || a.is_open(b)`.
|
|
]
|
|
]
|
|
[
|
|
[``
|
|
a.assign(b, n, ec);
|
|
``]
|
|
[`error_code`]
|
|
[
|
|
pre: `!a.is_open(b)`.\n
|
|
post: `!!ec || a.is_open(b)`.
|
|
]
|
|
]
|
|
[
|
|
[``
|
|
a.is_open(b);
|
|
``]
|
|
[`bool`]
|
|
[
|
|
]
|
|
]
|
|
[
|
|
[``
|
|
const X& u = a;
|
|
const X::implementation_type& v = b;
|
|
u.is_open(v);
|
|
``]
|
|
[`bool`]
|
|
[
|
|
]
|
|
]
|
|
[
|
|
[``
|
|
a.close(b, ec);
|
|
``]
|
|
[`error_code`]
|
|
[
|
|
If `a.is_open()` is true, causes any outstanding asynchronous operations
|
|
to complete as soon as possible. Handlers for cancelled operations shall
|
|
be passed the error code `error::operation_aborted`.\n
|
|
post: `!a.is_open(b)`.
|
|
]
|
|
]
|
|
[
|
|
[``
|
|
a.native_handle(b);
|
|
``]
|
|
[`X::native_handle_type`]
|
|
[
|
|
]
|
|
]
|
|
[
|
|
[``
|
|
a.cancel(b, ec);
|
|
``]
|
|
[`error_code`]
|
|
[
|
|
pre: `a.is_open(b)`.\n
|
|
Causes any outstanding asynchronous operations to complete as soon as
|
|
possible. Handlers for cancelled operations shall be passed the error
|
|
code `error::operation_aborted`.
|
|
]
|
|
]
|
|
[
|
|
[``
|
|
a.set_option(b, s, ec);
|
|
``]
|
|
[`error_code`]
|
|
[
|
|
pre: `a.is_open(b)`.
|
|
]
|
|
]
|
|
[
|
|
[``
|
|
a.get_option(b, g, ec);
|
|
``]
|
|
[`error_code`]
|
|
[
|
|
pre: `a.is_open(b)`.
|
|
]
|
|
]
|
|
[
|
|
[``
|
|
const X& u = a;
|
|
const X::implementation_type& v = b;
|
|
u.get_option(v, g, ec);
|
|
``]
|
|
[`error_code`]
|
|
[
|
|
pre: `a.is_open(b)`.
|
|
]
|
|
]
|
|
[
|
|
[``
|
|
a.send_break(b, ec);
|
|
``]
|
|
[`error_code`]
|
|
[
|
|
pre: `a.is_open(b)`.
|
|
]
|
|
]
|
|
[
|
|
[`a.read_some(b, mb, ec);`]
|
|
[`size_t`]
|
|
[
|
|
pre: `a.is_open(b)`.\n
|
|
\n
|
|
Reads one or more bytes of data from a serial port `b`.\n
|
|
\n
|
|
The mutable buffer sequence `mb` specifies memory where the data should
|
|
be placed. The operation shall always fill a buffer in the sequence
|
|
completely before proceeding to the next.\n
|
|
\n
|
|
If successful, returns the number of bytes read. Otherwise returns `0`.
|
|
If the total size of all buffers in the sequence `mb` is `0`, the
|
|
function shall return `0` immediately.\n
|
|
\n
|
|
If the operation completes due to graceful connection closure by the
|
|
peer, the operation shall fail with `error::eof`.
|
|
]
|
|
]
|
|
[
|
|
[`a.async_read_some(b, mb, rh);`]
|
|
[`void`]
|
|
[
|
|
pre: `a.is_open(b)`.\n
|
|
\n
|
|
Initiates an asynchronous operation to read one or more bytes of data
|
|
from a serial port `b`. The operation is performed via the
|
|
`io_service` object `a.get_io_service()` and behaves according to [link
|
|
boost_asio.reference.asynchronous_operations asynchronous operation]
|
|
requirements.\n
|
|
\n
|
|
The mutable buffer sequence `mb` specifies memory where the data should
|
|
be placed. The operation shall always fill a buffer in the sequence
|
|
completely before proceeding to the next.\n
|
|
\n
|
|
The implementation shall maintain one or more copies of `mb` until such
|
|
time as the read operation no longer requires access to the memory
|
|
specified by the buffers in the sequence. The program must ensure the
|
|
memory is valid until:\n
|
|
\n
|
|
[mdash] the last copy of `mb` is destroyed, or\n
|
|
\n
|
|
[mdash] the handler for the asynchronous operation is invoked,\n
|
|
\n
|
|
whichever comes first. If the total size of all buffers in the sequence
|
|
`mb` is `0`, the asynchronous read operation shall complete immediately
|
|
and pass `0` as the argument to the handler that specifies the number of
|
|
bytes read.\n
|
|
\n
|
|
If the operation completes due to graceful connection closure by the
|
|
peer, the operation shall fail with `error::eof`.\n
|
|
\n
|
|
If the operation completes successfully, the `ReadHandler` object
|
|
`rh` is invoked with the number of bytes transferred. Otherwise it is
|
|
invoked with `0`.
|
|
]
|
|
]
|
|
[
|
|
[`a.write_some(b, cb, ec);`]
|
|
[`size_t`]
|
|
[
|
|
pre: `a.is_open(b)`.\n
|
|
\n
|
|
Writes one or more bytes of data to a serial port `b`.\n
|
|
\n
|
|
The constant buffer sequence `cb` specifies memory where the data to be
|
|
written is located. The operation shall always write a buffer in the
|
|
sequence completely before proceeding to the next.\n
|
|
\n
|
|
If successful, returns the number of bytes written. Otherwise returns `0`.
|
|
If the total size of all buffers in the sequence `cb` is `0`, the
|
|
function shall return `0` immediately.
|
|
]
|
|
]
|
|
[
|
|
[`a.async_write_some(b, cb, wh);`]
|
|
[`void`]
|
|
[
|
|
pre: `a.is_open(b)`.\n
|
|
\n
|
|
Initiates an asynchronous operation to write one or more bytes of data to
|
|
a serial port `b`. The operation is performed via the `io_service`
|
|
object `a.get_io_service()` and behaves according to [link
|
|
boost_asio.reference.asynchronous_operations asynchronous operation]
|
|
requirements.\n
|
|
\n
|
|
The constant buffer sequence `cb` specifies memory where the data to be
|
|
written is located. The operation shall always write a buffer in the
|
|
sequence completely before proceeding to the next.\n
|
|
\n
|
|
The implementation shall maintain one or more copies of `cb` until such
|
|
time as the write operation no longer requires access to the memory
|
|
specified by the buffers in the sequence. The program must ensure the
|
|
memory is valid until:\n
|
|
\n
|
|
[mdash] the last copy of `cb` is destroyed, or\n
|
|
\n
|
|
[mdash] the handler for the asynchronous operation is invoked,\n
|
|
\n
|
|
whichever comes first. If the total size of all buffers in the sequence
|
|
`cb` is `0`, the asynchronous operation shall complete immediately and
|
|
pass `0` as the argument to the handler that specifies the number of
|
|
bytes read.\n
|
|
\n
|
|
If the operation completes successfully, the `WriteHandler` object `wh`
|
|
is invoked with the number of bytes transferred. Otherwise it is invoked
|
|
with `0`.
|
|
]
|
|
]
|
|
]
|
|
|
|
[endsect]
|