use crate::{ByteOrder, CdrVersion, Error, LongDouble, Octets, Result, SHARE_MIN};
#[derive(Debug, Clone)]
pub struct Encoder {
pub(crate) buf: Vec<u8>,
shared: Vec<(usize, Octets)>,
shared_len: usize,
allow_shared: bool,
pub(crate) order: ByteOrder,
version: CdrVersion,
base: usize,
wstring_bom: bool,
pub(crate) values: Option<Box<crate::value::WriteState>>,
}
macro_rules! write_number {
($(#[$doc:meta] $name:ident: $ty:ty;)*) => {
$(
#[$doc]
pub fn $name(&mut self, value: $ty) {
self.align(size_of::<$ty>());
match self.order {
ByteOrder::Big => self.buf.extend_from_slice(&value.to_be_bytes()),
ByteOrder::Little => self.buf.extend_from_slice(&value.to_le_bytes()),
}
}
)*
};
}
impl Encoder {
pub fn new(order: ByteOrder, version: CdrVersion) -> Encoder {
Encoder::with_offset(order, version, 0)
}
pub fn with_offset(order: ByteOrder, version: CdrVersion, base: usize) -> Encoder {
Encoder {
buf: Vec::new(),
shared: Vec::new(),
shared_len: 0,
allow_shared: false,
order,
version,
base,
wstring_bom: true,
values: None,
}
}
pub fn encapsulation(order: ByteOrder, version: CdrVersion) -> Encoder {
let mut enc = Encoder::new(order, version);
enc.write_octet(order.flag());
enc
}
pub fn set_wstring_bom(&mut self, bom: bool) {
self.wstring_bom = bom;
}
pub fn byte_order(&self) -> ByteOrder {
self.order
}
pub fn version(&self) -> CdrVersion {
self.version
}
pub fn position(&self) -> usize {
self.base + self.len()
}
pub fn len(&self) -> usize {
self.buf.len() + self.shared_len
}
pub fn is_empty(&self) -> bool {
self.len() == 0
}
pub fn as_bytes(&self) -> &[u8] {
&self.buf
}
pub fn as_bytes_mut(&mut self) -> &mut [u8] {
&mut self.buf
}
pub fn truncate(&mut self, len: usize) {
debug_assert!(self.shared.last().is_none_or(|(at, _)| *at <= len));
self.buf.truncate(len);
}
pub fn into_bytes(self) -> Vec<u8> {
if self.shared.is_empty() {
return self.buf;
}
let mut out = Vec::with_capacity(self.len());
let mut from = 0;
for (at, octets) in &self.shared {
out.extend_from_slice(&self.buf[from..*at]);
out.extend_from_slice(octets);
from = *at;
}
out.extend_from_slice(&self.buf[from..]);
out
}
pub fn into_parts(self) -> (Vec<u8>, Vec<(usize, Octets)>) {
(self.buf, self.shared)
}
pub fn reserve(&mut self, additional: usize) {
self.buf.reserve(additional);
}
pub fn allow_shared(&mut self, allow: bool) {
self.allow_shared = allow;
}
pub fn align(&mut self, align: usize) {
let rem = self.position() % align;
if rem != 0 {
self.buf.resize(self.buf.len() + align - rem, 0);
}
}
pub fn write_octet(&mut self, value: u8) {
self.buf.push(value);
}
pub fn write_bool(&mut self, value: bool) {
self.buf.push(u8::from(value));
}
pub fn write_char(&mut self, value: u8) {
self.buf.push(value);
}
write_number! {
write_i16: i16;
write_u16: u16;
write_i32: i32;
write_u32: u32;
write_i64: i64;
write_u64: u64;
write_f32: f32;
write_f64: f64;
}
pub fn write_long_double(&mut self, value: LongDouble) {
self.align(8);
let bits = value.to_bits();
self.buf.extend_from_slice(&match self.order {
ByteOrder::Big => bits.to_be_bytes(),
ByteOrder::Little => bits.to_le_bytes(),
});
}
pub fn write_octets(&mut self, bytes: &[u8]) {
self.buf.extend_from_slice(bytes);
}
pub fn write_len(&mut self, len: usize) -> Result<()> {
let len = u32::try_from(len).map_err(|_| Error::LengthOverflow(len))?;
self.write_u32(len);
Ok(())
}
pub fn write_octet_seq(&mut self, bytes: &[u8]) -> Result<()> {
self.write_len(bytes.len())?;
self.write_octets(bytes);
Ok(())
}
pub fn write_octet_seq_shared(&mut self, octets: &Octets) -> Result<()> {
if !self.allow_shared || octets.len() < SHARE_MIN || self.values.is_some() {
return self.write_octet_seq(octets);
}
self.write_len(octets.len())?;
self.shared.push((self.buf.len(), octets.clone()));
self.shared_len += octets.len();
Ok(())
}
pub fn write_string_bytes(&mut self, bytes: &[u8]) -> Result<()> {
self.write_len(bytes.len() + 1)?;
self.write_octets(bytes);
self.write_octet(0);
Ok(())
}
pub fn write_string(&mut self, value: &str) -> Result<()> {
self.write_string_bytes(value.as_bytes())
}
pub fn write_wchar(&mut self, value: u16) -> Result<()> {
match self.version {
CdrVersion::Giop1_0 => return Err(Error::WcharNotSupported),
CdrVersion::Giop1_1 => self.write_u16(value),
CdrVersion::Giop1_2 => {
self.write_octet(2);
self.write_octets(&value.to_be_bytes());
}
}
Ok(())
}
pub fn write_wstring(&mut self, value: &str) -> Result<()> {
match self.version {
CdrVersion::Giop1_0 => Err(Error::WcharNotSupported),
CdrVersion::Giop1_1 => {
let units: Vec<u16> = value.encode_utf16().collect();
self.write_len(units.len() + 1)?;
for unit in units {
self.write_u16(unit);
}
self.write_u16(0);
Ok(())
}
CdrVersion::Giop1_2 => {
let order = if self.wstring_bom {
self.order
} else {
ByteOrder::Big
};
let bom = (self.wstring_bom && !value.is_empty()).then_some(0xFEFF);
let bytes: Vec<u8> = bom
.into_iter()
.chain(value.encode_utf16())
.flat_map(|unit| match order {
ByteOrder::Big => unit.to_be_bytes(),
ByteOrder::Little => unit.to_le_bytes(),
})
.collect();
self.write_octet_seq(&bytes)
}
}
}
pub fn write_encapsulation<F>(&mut self, f: F) -> Result<()>
where
F: FnOnce(&mut Encoder) -> Result<()>,
{
let mut inner = Encoder::encapsulation(self.order, self.version);
inner.wstring_bom = self.wstring_bom;
f(&mut inner)?;
self.write_octet_seq(&inner.buf)
}
}