pub struct Encoder { /* private fields */ }Expand description
Writes CDR into a growable buffer.
Alignment is relative to the stream offset of the first byte, which is
0 unless the encoder was created with Encoder::with_offset.
An encoder that allows shared octets keeps
large octet sequences written with
write_octet_seq_shared apart from
its buffer: into_parts gives the buffer and
where each goes, for a vectored write, and
into_bytes puts them in place.
Implementations§
Source§impl Encoder
impl Encoder
Sourcepub fn new(order: ByteOrder, version: CdrVersion) -> Encoder
pub fn new(order: ByteOrder, version: CdrVersion) -> Encoder
Creates an encoder whose first byte is at stream offset 0.
Sourcepub fn with_offset(
order: ByteOrder,
version: CdrVersion,
base: usize,
) -> Encoder
pub fn with_offset( order: ByteOrder, version: CdrVersion, base: usize, ) -> Encoder
Creates an encoder whose first byte is at stream offset base.
Sourcepub fn encapsulation(order: ByteOrder, version: CdrVersion) -> Encoder
pub fn encapsulation(order: ByteOrder, version: CdrVersion) -> Encoder
Starts an encapsulation: offset 0, with the byte order octet written.
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 version(&self) -> CdrVersion
pub fn version(&self) -> CdrVersion
The GIOP version whose CDR rules apply.
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 into_bytes(self) -> Vec<u8> ⓘ
pub fn into_bytes(self) -> Vec<u8> ⓘ
Consumes the encoder and returns the bytes, shared octets copied in place.
Sourcepub fn into_parts(self) -> (Vec<u8>, Vec<(usize, Octets)>)
pub fn into_parts(self) -> (Vec<u8>, Vec<(usize, Octets)>)
Consumes the encoder and returns the buffer and the shared octets, each with the buffer length at which it goes.
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.
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.
Sourcepub fn write_octet_seq(&mut self, bytes: &[u8]) -> Result<()>
pub fn write_octet_seq(&mut self, bytes: &[u8]) -> Result<()>
Writes a sequence<octet>.
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). Otherwise
like write_octet_seq.
Sourcepub fn write_string_bytes(&mut self, bytes: &[u8]) -> Result<()>
pub fn write_string_bytes(&mut self, bytes: &[u8]) -> Result<()>
Writes a string from bytes already in the transmission code set.
The length includes the terminating NUL, which is appended here.
Sourcepub fn write_string(&mut self, value: &str) -> Result<()>
pub fn write_string(&mut self, value: &str) -> Result<()>
Writes a string as UTF-8.
Sourcepub fn write_wchar(&mut self, value: u16) -> Result<()>
pub fn write_wchar(&mut self, value: u16) -> Result<()>
Writes a wchar holding one UTF-16 code unit.
GIOP 1.1 writes 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<()>
pub fn write_wstring(&mut self, value: &str) -> Result<()>
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.
Sourcepub fn write_encapsulation<F>(&mut self, f: F) -> Result<()>
pub fn write_encapsulation<F>(&mut self, f: F) -> Result<()>
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.
Source§impl Encoder
impl Encoder
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>
pub fn begin_value( &mut self, key: u64, ids: &[&str], chunked: bool, ) -> Result<bool>
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<()>
pub fn end_value(&mut self) -> Result<()>
Ends the value started by the last Encoder::begin_value that
returned true.