pub struct OutStream<'a> { /* private fields */ }Expand description
The stream request arguments are written to.
It dereferences to the CDR Encoder of the message body, and adds
the operations that depend on the connection: string in the
negotiated code set, wchar and wstring only when a wide code set was
negotiated, and object references.
Implementations§
Source§impl<'a> OutStream<'a>
impl<'a> OutStream<'a>
Sourcepub fn standalone(enc: &'a mut Encoder) -> OutStream<'a>
pub fn standalone(enc: &'a mut Encoder) -> OutStream<'a>
A stream over enc outside any message, with the native code
sets (UTF-8 and UTF-16). Bindings use it to marshal the value of an
any on its own, to read it back with InStream::standalone.
Sourcepub fn set_code_sets(&mut self, code_sets: CodeSets)
pub fn set_code_sets(&mut self, code_sets: CodeSets)
Uses code_sets for the char and wchar data that follows, as
on a standalone stream that must match another ORB’s native code
sets.
Sourcepub fn write_string(&mut self, s: &str) -> Result<(), SystemException>
pub fn write_string(&mut self, s: &str) -> Result<(), SystemException>
Writes a string in the negotiated char code set.
Sourcepub fn write_wchar(&mut self, c: u16) -> Result<(), SystemException>
pub fn write_wchar(&mut self, c: u16) -> Result<(), SystemException>
Writes a wchar (one UTF-16 code unit).
Sourcepub fn write_wstring(&mut self, s: &str) -> Result<(), SystemException>
pub fn write_wstring(&mut self, s: &str) -> Result<(), SystemException>
Writes a wstring.
Sourcepub fn write_object(
&mut self,
obj: Option<&ObjectRef>,
) -> Result<(), SystemException>
pub fn write_object( &mut self, obj: Option<&ObjectRef>, ) -> Result<(), SystemException>
Writes an object reference; None is a nil reference.
Sourcepub fn write_typecode(&mut self, tc: &TypeCode) -> Result<(), SystemException>
pub fn write_typecode(&mut self, tc: &TypeCode) -> Result<(), SystemException>
Writes a TypeCode. An unresolved recursive placeholder is
BAD_TYPECODE.
Sourcepub fn write_value(
&mut self,
tc: &TypeCode,
v: &Value,
) -> Result<(), SystemException>
pub fn write_value( &mut self, tc: &TypeCode, v: &Value, ) -> Result<(), SystemException>
Writes a value of type tc. A value that does not fit the type is
BAD_PARAM.
Sourcepub fn write_fixed(
&mut self,
digits: &[u8],
negative: bool,
) -> Result<(), SystemException>
pub fn write_fixed( &mut self, digits: &[u8], negative: bool, ) -> Result<(), SystemException>
Writes a fixed of digits.len() digits (each 0 to 9, most
significant first) as packed decimal. A digit over 9 or more than
31 digits is BAD_PARAM.
Methods from Deref<Target = Encoder>§
Sourcepub fn set_wstring_bom(&mut self, bom: bool)
pub fn set_wstring_bom(&mut self, bom: bool)
Chooses how a GIOP 1.2 wstring is written: with a BOM followed by
code units in the stream byte order (the default, as omniORB does),
or, when false, big endian without a BOM (the form the
specification defines for a missing BOM). Readers that follow
CORBA 2.4 or later accept both.
Sourcepub fn byte_order(&self) -> ByteOrder
pub fn byte_order(&self) -> ByteOrder
The byte order of the stream.
Sourcepub fn position(&self) -> usize
pub fn position(&self) -> usize
The stream offset of the next byte.
A caller that writes bytes depending on it (an offset or an
indirection) calls pin as well.
Sourcepub fn track_align8(&mut self)
pub fn track_align8(&mut self)
Starts recording where the stream is aligned to 8 bytes, so that
the bytes written from here on can be moved by 4 bytes with
take_align8. Only for GIOP encodings;
recording stops for good when something is written whose bytes
depend on stream offsets: a valuetype, a call to
pin, set_origin,
as_bytes_mut or
truncate.
Sourcepub fn take_align8(&mut self) -> Option<Vec<(usize, usize)>>
pub fn take_align8(&mut self) -> Option<Vec<(usize, usize)>>
Stops recording, and returns the 8-byte alignment points written
since track_align8: each is the buffer
length before its padding and the length of that padding. Data
whose alignment is at most 4 does not depend on the stream offset
modulo 8, so the bytes written since can be moved by 4 bytes by
recomputing the padding at these points alone. None if not
recording, or if recording stopped.
Sourcepub fn pin(&mut self)
pub fn pin(&mut self)
Says that bytes written from here on depend on stream offsets, as
an indirection does, so the stream cannot be moved: stops
track_align8 for good.
Sourcepub fn as_bytes(&self) -> &[u8] ⓘ
pub fn as_bytes(&self) -> &[u8] ⓘ
The bytes written into the buffer so far: all of them, unless shared octets were kept apart.
Sourcepub fn as_bytes_mut(&mut self) -> &mut [u8] ⓘ
pub fn as_bytes_mut(&mut self) -> &mut [u8] ⓘ
Mutable access to the buffer, for patching lengths. Indexes are buffer indexes, which differ from stream offsets after shared octets.
Sourcepub fn truncate(&mut self, len: usize)
pub fn truncate(&mut self, len: usize)
Drops bytes past len, which must not be before shared octets.
Sourcepub fn reserve(&mut self, additional: usize)
pub fn reserve(&mut self, additional: usize)
Makes room for at least additional more bytes in the buffer.
Lets write_octet_seq_shared
keep large octet sequences apart from the buffer. Only for an
encoder whose result goes out through
into_parts or
into_bytes, not one read through
as_bytes.
Sourcepub fn align(&mut self, align: usize)
pub fn align(&mut self, align: usize)
Pads with zero octets until the stream offset is a multiple of
align, or of the encoding’s max_align
when that is smaller.
In an XCDR stream the offset counts from the alignment origin (see
set_origin).
Sourcepub fn origin(&self) -> usize
pub fn origin(&self) -> usize
The stream offset alignment counts from: 0 unless changed with
set_origin.
Sourcepub fn set_origin(&mut self, origin: usize)
pub fn set_origin(&mut self, origin: usize)
Makes alignment count from stream offset origin, which must not
be past position. This is the XCDR
PUSH(ORIGIN); the parameter headers of
begin_parameter do it themselves.
Sourcepub fn write_octet(&mut self, value: u8)
pub fn write_octet(&mut self, value: u8)
Writes an octet.
Sourcepub fn write_bool(&mut self, value: bool)
pub fn write_bool(&mut self, value: bool)
Writes a boolean.
Sourcepub fn write_char(&mut self, value: u8)
pub fn write_char(&mut self, value: u8)
Writes a char as a single octet in the transmission code set.
Sourcepub fn write_long_double(&mut self, value: LongDouble)
pub fn write_long_double(&mut self, value: LongDouble)
Writes a long double: 16 octets on an 8 octet boundary.
Sourcepub fn write_octets(&mut self, bytes: &[u8])
pub fn write_octets(&mut self, bytes: &[u8])
Writes raw octets without alignment or a length.
Writes a sequence<octet> without copying a large one, if the
encoder allows it and no valuetype is
being written (whose chunk lengths count the buffer), and the
encoding is a GIOP one (XCDR headers are patched in the buffer). Otherwise
like write_octet_seq.
Sourcepub fn write_string_bytes(&mut self, bytes: &[u8]) -> Result<(), Error>
pub fn write_string_bytes(&mut self, bytes: &[u8]) -> Result<(), Error>
Writes a string from bytes already in the transmission code set.
The length includes the terminating NUL, which is appended here.
Sourcepub fn write_wchar(&mut self, value: u16) -> Result<(), Error>
pub fn write_wchar(&mut self, value: u16) -> Result<(), Error>
Writes a wchar holding one UTF-16 code unit.
GIOP 1.1 and XCDR (Char16, DDS-XTypes 7.4.1.1.1) write an aligned
unsigned short in the stream byte order. GIOP 1.2 writes an octet length of 2 followed by the code unit in big
endian without a BOM, as omniORB does.
Sourcepub fn write_wstring(&mut self, value: &str) -> Result<(), Error>
pub fn write_wstring(&mut self, value: &str) -> Result<(), Error>
Writes a wstring encoded as UTF-16.
GIOP 1.1 writes the number of code units including a terminating
NUL, then aligned code units in the stream byte order. GIOP 1.2
writes the octet length, then the code units without a terminator:
by default a BOM followed by the stream byte order, or big endian
without a BOM (see Encoder::set_wstring_bom). An empty string is
just a zero length. XCDR (DDS-XTypes 7.4.1.1.2) writes the length in
octets, then the code units in the stream byte order, without a BOM
or a terminator.
Sourcepub fn write_encapsulation<F>(&mut self, f: F) -> Result<(), Error>
pub fn write_encapsulation<F>(&mut self, f: F) -> Result<(), Error>
Writes an encapsulation as a sequence<octet>.
f writes the contents into a fresh encoder whose alignment starts
at the byte order octet. The encapsulation uses this stream’s byte
order and version.
Sourcepub fn write_null_value(&mut self)
pub fn write_null_value(&mut self)
Writes a null value.
Sourcepub fn begin_value(
&mut self,
key: u64,
ids: &[&str],
chunked: bool,
) -> Result<bool, Error>
pub fn begin_value( &mut self, key: u64, ids: &[&str], chunked: bool, ) -> Result<bool, Error>
Starts writing a value.
key identifies the value: if a value with the same key was
written before in this stream, an indirection to it is written and
false is returned. Otherwise the value tag and ids (repository
ids, most derived first; none leaves the type to the receiver) are
written and true is returned: the caller writes the state and
then calls Encoder::end_value.
A value nested in a chunked value is chunked as well.
Sourcepub fn end_value(&mut self) -> Result<(), Error>
pub fn end_value(&mut self) -> Result<(), Error>
Ends the value started by the last Encoder::begin_value that
returned true.
Sourcepub fn begin_dheader(&mut self) -> DHeaderMark
pub fn begin_dheader(&mut self) -> DHeaderMark
Writes a DHEADER to be filled in by
end_dheader with the length of what is
written in between (DDS-XTypes 7.4.3.4.1).
Marks of begin_dheader,
begin_member and
begin_parameter must be ended
innermost first.
Sourcepub fn end_dheader(&mut self, mark: DHeaderMark) -> Result<(), Error>
pub fn end_dheader(&mut self, mark: DHeaderMark) -> Result<(), Error>
Fills in the DHEADER of mark.
Sourcepub fn begin_member(
&mut self,
id: u32,
must_understand: bool,
) -> Result<MemberMark, Error>
pub fn begin_member( &mut self, id: u32, must_understand: bool, ) -> Result<MemberMark, Error>
Starts a member of an XCDR2 mutable type: an EMHEADER for member
id, filled in by end_member with the
length of what is written in between (DDS-XTypes 7.4.3.4.2, rule
22). Only for Encoding::Xcdr2.
Sourcepub fn end_member(&mut self, mark: MemberMark) -> Result<(), Error>
pub fn end_member(&mut self, mark: MemberMark) -> Result<(), Error>
Fills in the EMHEADER of mark. A member of 1, 2, 4 or 8 octets
gets a length code of 0 to 3 and no NEXTINT; any other gets length
code 4 and its length in NEXTINT. (Length codes 5 to 7, which share
NEXTINT with the member, are read but not written.)
Sourcepub fn begin_parameter(
&mut self,
id: u32,
must_understand: bool,
) -> Result<ParameterMark, Error>
pub fn begin_parameter( &mut self, id: u32, must_understand: bool, ) -> Result<ParameterMark, Error>
Starts a parameter of an XCDR1 parameter list, or the header of an
XCDR1 optional member: a parameter header for member id, filled
in by end_parameter with the length of
what is written in between (DDS-XTypes 7.4.1.2, rules 24 and 25).
The header is a short one (16-bit ID and length) when id is at
most MAX_SHORT_PID, and an extended one (PID_EXTENDED)
otherwise or when the member turns out longer than 65535 octets.
Alignment counts from the byte after the header until
end_parameter. An absent optional member is a parameter with
nothing written in it.
Sourcepub fn end_parameter(&mut self, mark: ParameterMark) -> Result<(), Error>
pub fn end_parameter(&mut self, mark: ParameterMark) -> Result<(), Error>
Fills in the parameter header of mark and restores the alignment
origin. The length is that of the member, without padding
(DDS-XTypes 7.4.1.2).
Sourcepub fn end_parameter_list(&mut self, end: ListEnd)
pub fn end_parameter_list(&mut self, end: ListEnd)
Ends an XCDR1 parameter list with end and a zero length (rule
23).