rustorb 0.1.1__tar.gz → 0.3.0__tar.gz

{rustorb-0.1.1 → rustorb-0.3.0}/Cargo.lock

@@ -438,19 +438,11 @@ dependencies = [
 
 [[package]]
 name = "rustorb-cdr"
-version = "0.1.1"
-
-[[package]]
-name = "rustorb-codegen"
-version = "0.1.1"
-dependencies = [
- "rustorb-core",
- "tokio",
-]
+version = "0.3.0"
 
 [[package]]
 name = "rustorb-core"
-version = "0.1.1"
+version = "0.3.0"
 dependencies = [
  "criterion",
  "libc",
@@ -459,12 +451,13 @@ dependencies = [
  "rustorb-giop",
  "socket2",
  "tokio",
+ "tracing",
  "windows-sys 0.61.2",
 ]
 
 [[package]]
 name = "rustorb-ffi"
-version = "0.1.1"
+version = "0.3.0"
 dependencies = [
  "rustorb-cdr",
  "rustorb-core",
@@ -472,7 +465,7 @@ dependencies = [
 
 [[package]]
 name = "rustorb-giop"
-version = "0.1.1"
+version = "0.3.0"
 dependencies = [
  "rustorb-cdr",
  "serde_json",
@@ -480,26 +473,43 @@ dependencies = [
 
 [[package]]
 name = "rustorb-interop"
-version = "0.1.1"
+version = "0.3.0"
 dependencies = [
  "rustorb-core",
  "rustorb-naming",
 ]
 
+[[package]]
+name = "rustorb-mapping-tests"
+version = "0.0.0"
+dependencies = [
+ "rustorb-core",
+ "rustorb-typesupport",
+ "tokio",
+]
+
 [[package]]
 name = "rustorb-naming"
-version = "0.1.1"
+version = "0.3.0"
 dependencies = [
  "rustorb-core",
 ]
 
 [[package]]
 name = "rustorb-python"
-version = "0.1.1"
+version = "0.3.0"
 dependencies = [
  "pyo3",
  "pyo3-build-config",
  "rustorb-core",
+ "tracing",
+]
+
+[[package]]
+name = "rustorb-typesupport"
+version = "0.3.0"
+dependencies = [
+ "rustorb-cdr",
 ]
 
 [[package]]
@@ -628,6 +638,25 @@ dependencies = [
  "windows-sys 0.61.2",
 ]
 
+[[package]]
+name = "tracing"
+version = "0.1.44"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "63e71662fa4b2a2c3a26f570f037eb95bb1f85397f3cd8076caed2f026a6d100"
+dependencies = [
+ "pin-project-lite",
+ "tracing-core",
+]
+
+[[package]]
+name = "tracing-core"
+version = "0.1.36"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "db97caf9d906fbde555dd62fa95ddba9eecfd14cb388e4f491a66d74cd5fb79a"
+dependencies = [
+ "once_cell",
+]
+
 [[package]]
 name = "unicode-ident"
 version = "1.0.27"

{rustorb-0.1.1 → rustorb-0.3.0}/Cargo.toml

@@ -3,7 +3,7 @@ resolver = "3"
 members = ["crates/rustorb-cdr", "crates/rustorb-giop", "crates/rustorb-core", "crates/rustorb-python"]
 
 [workspace.package]
-version = "0.1.1"
+version = "0.3.0"
 edition = "2024"
 rust-version = "1.85"
 license = "MIT OR Apache-2.0"
@@ -13,10 +13,11 @@ keywords = ["corba", "giop", "iiop", "orb", "rpc"]
 categories = ["network-programming"]
 
 [workspace.dependencies]
-rustorb-cdr = { path = "crates/rustorb-cdr", version = "0.1.1" }
-rustorb-giop = { path = "crates/rustorb-giop", version = "0.1.1" }
-rustorb-core = { path = "crates/rustorb-core", version = "0.1.1" }
-rustorb-naming = { path = "crates/rustorb-naming", version = "0.1.1" }
+rustorb-cdr = { path = "crates/rustorb-cdr", version = "0.3.0" }
+rustorb-typesupport = { path = "crates/rustorb-typesupport", version = "0.3.0" }
+rustorb-giop = { path = "crates/rustorb-giop", version = "0.3.0" }
+rustorb-core = { path = "crates/rustorb-core", version = "0.3.0" }
+rustorb-naming = { path = "crates/rustorb-naming", version = "0.3.0" }
 tokio = { version = "1", default-features = false }
 
 [workspace.lints.rust]

{rustorb-0.1.1 → rustorb-0.3.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: rustorb
-Version: 0.1.1
+Version: 0.3.0
 Classifier: Programming Language :: Python :: 3
 Classifier: Topic :: System :: Networking
 Classifier: Topic :: Software Development :: Object Brokering
@@ -44,7 +44,7 @@ orb.destroy()
 
 The wheels are abi3, for CPython 3.9 or later, with the ORB core compiled
 in: GIOP 1.0–1.2, IIOP and SSLIOP, the POA, Any / TypeCode / DynAny,
-valuetypes, DII / DSI and call timeouts. See the
+valuetypes, DII / DSI, Portable Interceptors and call timeouts. See the
 [getting started guide](https://github.com/rustorb/rustorb/blob/main/docs/getting-started.md).
 
 Licensed under MIT OR Apache-2.0.

{rustorb-0.1.1 → rustorb-0.3.0}/README.md

@@ -29,7 +29,7 @@ orb.destroy()
 
 The wheels are abi3, for CPython 3.9 or later, with the ORB core compiled
 in: GIOP 1.0–1.2, IIOP and SSLIOP, the POA, Any / TypeCode / DynAny,
-valuetypes, DII / DSI and call timeouts. See the
+valuetypes, DII / DSI, Portable Interceptors and call timeouts. See the
 [getting started guide](https://github.com/rustorb/rustorb/blob/main/docs/getting-started.md).
 
 Licensed under MIT OR Apache-2.0.

{rustorb-0.1.1 → rustorb-0.3.0}/crates/rustorb-cdr/src/decoder.rs

@@ -1,6 +1,6 @@
 use std::sync::Arc;
 
-use crate::{ByteOrder, CdrVersion, Error, LongDouble, Octets, Result, SHARE_MIN};
+use crate::{ByteOrder, Encoding, Error, LongDouble, Octets, Result, SHARE_MIN};
 
 /// Reads CDR from a byte slice.
 ///
@@ -15,8 +15,10 @@ pub struct Decoder<'a> {
     shared: Option<&'a Arc<Vec<u8>>>,
     pub(crate) pos: usize,
     pub(crate) order: ByteOrder,
-    version: CdrVersion,
+    encoding: Encoding,
     base: usize,
+    /// The stream offset alignment counts from (`XCDR.origin`).
+    pub(crate) origin: usize,
     segments: &'a [Segment],
     wstring_default_order: ByteOrder,
     /// What the valuetypes read so far need (indirections, chunks);
@@ -56,15 +58,15 @@ macro_rules! read_number {
 
 impl<'a> Decoder<'a> {
     /// Creates a decoder whose first byte is at stream offset 0.
-    pub fn new(buf: &'a [u8], order: ByteOrder, version: CdrVersion) -> Decoder<'a> {
-        Decoder::with_offset(buf, order, version, 0)
+    pub fn new(buf: &'a [u8], order: ByteOrder, encoding: Encoding) -> Decoder<'a> {
+        Decoder::with_offset(buf, order, encoding, 0)
     }
 
     /// Creates a decoder whose first byte is at stream offset `base`.
     pub fn with_offset(
         buf: &'a [u8],
         order: ByteOrder,
-        version: CdrVersion,
+        encoding: Encoding,
         base: usize,
     ) -> Decoder<'a> {
         Decoder {
@@ -72,8 +74,9 @@ impl<'a> Decoder<'a> {
             shared: None,
             pos: 0,
             order,
-            version,
+            encoding,
             base,
+            origin: 0,
             segments: &[],
             wstring_default_order: ByteOrder::Big,
             values: None,
@@ -90,10 +93,10 @@ impl<'a> Decoder<'a> {
 
     /// Opens an encapsulation: reads the byte order octet and returns a
     /// decoder positioned after it, with alignment starting at that octet.
-    pub fn encapsulation(buf: &'a [u8], version: CdrVersion) -> Result<Decoder<'a>> {
+    pub fn encapsulation(buf: &'a [u8], encoding: Encoding) -> Result<Decoder<'a>> {
         let (&flag, _) = buf.split_first().ok_or(Error::EmptyEncapsulation)?;
         let order = ByteOrder::from_flag(flag)?;
-        let mut dec = Decoder::new(buf, order, version);
+        let mut dec = Decoder::new(buf, order, encoding);
         dec.pos = 1;
         Ok(dec)
     }
@@ -110,9 +113,9 @@ impl<'a> Decoder<'a> {
         self.order
     }
 
-    /// The GIOP version whose CDR rules apply.
-    pub fn version(&self) -> CdrVersion {
-        self.version
+    /// The encoding whose rules apply.
+    pub fn encoding(&self) -> Encoding {
+        self.encoding
     }
 
     /// The stream offset of the next byte.
@@ -142,14 +145,19 @@ impl<'a> Decoder<'a> {
         &self.buf[self.pos..]
     }
 
-    /// Skips padding until the stream offset is a multiple of `align`.
+    /// Skips padding until the stream offset is a multiple of `align`, or
+    /// of the encoding's [`max_align`](Encoding::max_align) when that is
+    /// smaller.
     ///
     /// Inside a chunked valuetype, a chunk that ends here is followed by
-    /// the next one: its length is read and the data aligned in it.
+    /// the next one: its length is read and the data aligned in it. In an
+    /// XCDR stream the offset counts from the alignment origin (see
+    /// [`set_origin`](Decoder::set_origin)).
     pub fn align(&mut self, align: usize) -> Result<()> {
+        let align = align.min(self.encoding.max_align());
         loop {
             self.chunk_boundary()?;
-            let rem = self.position() % align;
+            let rem = self.position().wrapping_sub(self.origin) % align;
             if rem == 0 {
                 return Ok(());
             }
@@ -163,6 +171,19 @@ impl<'a> Decoder<'a> {
         }
     }
 
+    /// The stream offset alignment counts from: 0 unless changed with
+    /// [`set_origin`](Decoder::set_origin).
+    pub fn origin(&self) -> usize {
+        self.origin
+    }
+
+    /// Makes alignment count from stream offset `origin`. This is the XCDR
+    /// `PUSH(ORIGIN)`; [`read_parameter`](Decoder::read_parameter) does it
+    /// itself.
+    pub fn set_origin(&mut self, origin: usize) {
+        self.origin = origin;
+    }
+
     /// Skips `n` bytes.
     pub fn skip(&mut self, n: usize) -> Result<()> {
         self.read_octets(n).map(|_| ())
@@ -341,10 +362,10 @@ impl<'a> Decoder<'a> {
 
     /// Reads a `wchar` holding one UTF-16 code unit.
     pub fn read_wchar(&mut self) -> Result<u16> {
-        match self.version {
-            CdrVersion::Giop1_0 => Err(Error::WcharNotSupported),
-            CdrVersion::Giop1_1 => self.read_u16(),
-            CdrVersion::Giop1_2 => {
+        match self.encoding {
+            Encoding::Giop1_0 => Err(Error::WcharNotSupported),
+            Encoding::Giop1_1 | Encoding::Xcdr1 | Encoding::Xcdr2 => self.read_u16(),
+            Encoding::Giop1_2 => {
                 let len = self.read_octet()?;
                 if len != 2 && len != 4 {
                     return Err(Error::InvalidWcharLength(len));
@@ -362,11 +383,23 @@ impl<'a> Decoder<'a> {
     /// Reads a `wstring` encoded as UTF-16.
     ///
     /// For GIOP 1.2 a leading BOM selects the byte order; without one the
-    /// order set by [`Decoder::set_wstring_default_order`] is used.
+    /// order set by [`Decoder::set_wstring_default_order`] is used. XCDR
+    /// has an octet length and code units in the stream byte order.
     pub fn read_wstring(&mut self) -> Result<String> {
-        match self.version {
-            CdrVersion::Giop1_0 => Err(Error::WcharNotSupported),
-            CdrVersion::Giop1_1 => {
+        match self.encoding {
+            Encoding::Giop1_0 => Err(Error::WcharNotSupported),
+            Encoding::Xcdr1 | Encoding::Xcdr2 => {
+                let len = self.read_len(1)?;
+                if len % 2 != 0 {
+                    return Err(Error::OddWstringLength(len as u32));
+                }
+                let mut units = Vec::with_capacity(len / 2);
+                for _ in 0..len / 2 {
+                    units.push(self.read_u16()?);
+                }
+                String::from_utf16(&units).map_err(|_| Error::InvalidUtf16)
+            }
+            Encoding::Giop1_1 => {
                 let len = self.read_len(2)?;
                 let mut units = Vec::with_capacity(len);
                 for _ in 0..len {
@@ -378,7 +411,7 @@ impl<'a> Decoder<'a> {
                 }
                 String::from_utf16(&units).map_err(|_| Error::InvalidUtf16)
             }
-            CdrVersion::Giop1_2 => {
+            Encoding::Giop1_2 => {
                 let bytes = self.read_octet_seq()?;
                 if bytes.len() % 2 != 0 {
                     return Err(Error::OddWstringLength(bytes.len() as u32));
@@ -407,7 +440,7 @@ impl<'a> Decoder<'a> {
     /// Reads an encapsulation and returns a decoder over its contents.
     pub fn read_encapsulation(&mut self) -> Result<Decoder<'a>> {
         let bytes = self.read_octet_seq()?;
-        let mut inner = Decoder::encapsulation(bytes, self.version)?;
+        let mut inner = Decoder::encapsulation(bytes, self.encoding)?;
         inner.wstring_default_order = self.wstring_default_order;
         Ok(inner)
     }

{rustorb-0.1.1 → rustorb-0.3.0}/crates/rustorb-cdr/src/encoder.rs

@@ -1,4 +1,4 @@
-use crate::{ByteOrder, CdrVersion, Error, LongDouble, Octets, Result, SHARE_MIN};
+use crate::{ByteOrder, Encoding, Error, LongDouble, Octets, Result, SHARE_MIN};
 
 /// Writes CDR into a growable buffer.
 ///
@@ -21,12 +21,21 @@ pub struct Encoder {
     shared_len: usize,
     allow_shared: bool,
     pub(crate) order: ByteOrder,
-    version: CdrVersion,
+    encoding: Encoding,
     base: usize,
+    /// The stream offset alignment counts from (`XCDR.origin`); 0 except
+    /// inside an XCDR stream.
+    pub(crate) origin: usize,
     wstring_bom: bool,
     /// The valuetypes written so far (for indirections) and the chunk
     /// being written; made with the first value.
     pub(crate) values: Option<Box<crate::value::WriteState>>,
+    /// The 8-byte alignment points written since
+    /// [`track_align8`](Encoder::track_align8), each as the buffer length
+    /// before its padding and the padding written; `None` when not
+    /// tracked, or when something was written whose bytes depend on
+    /// stream offsets (see [`take_align8`](Encoder::take_align8)).
+    align8: Option<Vec<(usize, usize)>>,
 }
 
 macro_rules! write_number {
@@ -46,28 +55,30 @@ macro_rules! write_number {
 
 impl Encoder {
     /// Creates an encoder whose first byte is at stream offset 0.
-    pub fn new(order: ByteOrder, version: CdrVersion) -> Encoder {
-        Encoder::with_offset(order, version, 0)
+    pub fn new(order: ByteOrder, encoding: Encoding) -> Encoder {
+        Encoder::with_offset(order, encoding, 0)
     }
 
     /// Creates an encoder whose first byte is at stream offset `base`.
-    pub fn with_offset(order: ByteOrder, version: CdrVersion, base: usize) -> Encoder {
+    pub fn with_offset(order: ByteOrder, encoding: Encoding, base: usize) -> Encoder {
         Encoder {
             buf: Vec::new(),
             shared: Vec::new(),
             shared_len: 0,
             allow_shared: false,
             order,
-            version,
+            encoding,
             base,
+            origin: 0,
             wstring_bom: true,
             values: None,
+            align8: None,
         }
     }
 
     /// Starts an encapsulation: offset 0, with the byte order octet written.
-    pub fn encapsulation(order: ByteOrder, version: CdrVersion) -> Encoder {
-        let mut enc = Encoder::new(order, version);
+    pub fn encapsulation(order: ByteOrder, encoding: Encoding) -> Encoder {
+        let mut enc = Encoder::new(order, encoding);
         enc.write_octet(order.flag());
         enc
     }
@@ -86,16 +97,54 @@ impl Encoder {
         self.order
     }
 
-    /// The GIOP version whose CDR rules apply.
-    pub fn version(&self) -> CdrVersion {
-        self.version
+    /// The encoding whose rules apply.
+    pub fn encoding(&self) -> Encoding {
+        self.encoding
     }
 
     /// The stream offset of the next byte.
+    ///
+    /// A caller that writes bytes depending on it (an offset or an
+    /// indirection) calls [`pin`](Encoder::pin) as well.
     pub fn position(&self) -> usize {
+        self.offset()
+    }
+
+    /// The stream offset of the next byte.
+    pub(crate) fn offset(&self) -> usize {
         self.base + self.len()
     }
 
+    /// 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`](Encoder::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`](Encoder::pin), [`set_origin`](Encoder::set_origin),
+    /// [`as_bytes_mut`](Encoder::as_bytes_mut) or
+    /// [`truncate`](Encoder::truncate).
+    pub fn track_align8(&mut self) {
+        self.align8 = self.encoding.is_giop().then(Vec::new);
+    }
+
+    /// Stops recording, and returns the 8-byte alignment points written
+    /// since [`track_align8`](Encoder::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.
+    pub fn take_align8(&mut self) -> Option<Vec<(usize, usize)>> {
+        self.align8.take()
+    }
+
+    /// Says that bytes written from here on depend on stream offsets, as
+    /// an indirection does, so the stream cannot be moved: stops
+    /// [`track_align8`](Encoder::track_align8) for good.
+    pub fn pin(&mut self) {
+        self.align8 = None;
+    }
+
     /// Bytes written so far, shared octets included.
     pub fn len(&self) -> usize {
         self.buf.len() + self.shared_len
@@ -116,12 +165,14 @@ impl Encoder {
     /// buffer indexes, which differ from stream offsets after shared
     /// octets.
     pub fn as_bytes_mut(&mut self) -> &mut [u8] {
+        self.align8 = None;
         &mut self.buf
     }
 
     /// Drops bytes past `len`, which must not be before shared octets.
     pub fn truncate(&mut self, len: usize) {
         debug_assert!(self.shared.last().is_none_or(|(at, _)| *at <= len));
+        self.align8 = None;
         self.buf.truncate(len);
     }
 
@@ -163,12 +214,40 @@ impl Encoder {
         self.allow_shared = allow;
     }
 
-    /// Pads with zero octets until the stream offset is a multiple of `align`.
+    /// Pads with zero octets until the stream offset is a multiple of
+    /// `align`, or of the encoding's [`max_align`](Encoding::max_align)
+    /// when that is smaller.
+    ///
+    /// In an XCDR stream the offset counts from the alignment origin (see
+    /// [`set_origin`](Encoder::set_origin)).
     pub fn align(&mut self, align: usize) {
-        let rem = self.position() % align;
-        if rem != 0 {
-            self.buf.resize(self.buf.len() + align - rem, 0);
+        let align = align.min(self.encoding.max_align());
+        let rem = (self.offset() - self.origin) % align;
+        let pad = if rem == 0 { 0 } else { align - rem };
+        if align == 8 {
+            if let Some(points) = self.align8.as_mut() {
+                points.push((self.buf.len(), pad));
+            }
         }
+        if pad != 0 {
+            self.buf.resize(self.buf.len() + pad, 0);
+        }
+    }
+
+    /// The stream offset alignment counts from: 0 unless changed with
+    /// [`set_origin`](Encoder::set_origin).
+    pub fn origin(&self) -> usize {
+        self.origin
+    }
+
+    /// Makes alignment count from stream offset `origin`, which must not
+    /// be past [`position`](Encoder::position). This is the XCDR
+    /// `PUSH(ORIGIN)`; the parameter headers of
+    /// [`begin_parameter`](Encoder::begin_parameter) do it themselves.
+    pub fn set_origin(&mut self, origin: usize) {
+        debug_assert!(origin <= self.offset());
+        self.align8 = None;
+        self.origin = origin;
     }
 
     /// Writes an `octet`.
@@ -236,10 +315,15 @@ impl Encoder {
 
     /// Writes a `sequence<octet>` without copying a large one, if the
     /// encoder [allows it](Encoder::allow_shared) and no valuetype is
-    /// being written (whose chunk lengths count the buffer). Otherwise
+    /// 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`](Encoder::write_octet_seq).
     pub fn write_octet_seq_shared(&mut self, octets: &Octets) -> Result<()> {
-        if !self.allow_shared || octets.len() < SHARE_MIN || self.values.is_some() {
+        if !self.allow_shared
+            || octets.len() < SHARE_MIN
+            || self.values.is_some()
+            || !self.encoding.is_giop()
+        {
             return self.write_octet_seq(octets);
         }
         self.write_len(octets.len())?;
@@ -265,14 +349,14 @@ impl Encoder {
 
     /// 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
+    /// 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.
     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 => {
+        match self.encoding {
+            Encoding::Giop1_0 => return Err(Error::WcharNotSupported),
+            Encoding::Giop1_1 | Encoding::Xcdr1 | Encoding::Xcdr2 => self.write_u16(value),
+            Encoding::Giop1_2 => {
                 self.write_octet(2);
                 self.write_octets(&value.to_be_bytes());
             }
@@ -287,11 +371,21 @@ impl Encoder {
     /// 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.
+    /// 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.
     pub fn write_wstring(&mut self, value: &str) -> Result<()> {
-        match self.version {
-            CdrVersion::Giop1_0 => Err(Error::WcharNotSupported),
-            CdrVersion::Giop1_1 => {
+        match self.encoding {
+            Encoding::Giop1_0 => Err(Error::WcharNotSupported),
+            Encoding::Xcdr1 | Encoding::Xcdr2 => {
+                let units: Vec<u16> = value.encode_utf16().collect();
+                self.write_len(units.len().saturating_mul(2))?;
+                for unit in units {
+                    self.write_u16(unit);
+                }
+                Ok(())
+            }
+            Encoding::Giop1_1 => {
                 let units: Vec<u16> = value.encode_utf16().collect();
                 self.write_len(units.len() + 1)?;
                 for unit in units {
@@ -300,7 +394,7 @@ impl Encoder {
                 self.write_u16(0);
                 Ok(())
             }
-            CdrVersion::Giop1_2 => {
+            Encoding::Giop1_2 => {
                 let order = if self.wstring_bom {
                     self.order
                 } else {
@@ -329,7 +423,7 @@ impl Encoder {
     where
         F: FnOnce(&mut Encoder) -> Result<()>,
     {
-        let mut inner = Encoder::encapsulation(self.order, self.version);
+        let mut inner = Encoder::encapsulation(self.order, self.encoding);
         inner.wstring_bom = self.wstring_bom;
         f(&mut inner)?;
         self.write_octet_seq(&inner.buf)

{rustorb-0.1.1 → rustorb-0.3.0}/crates/rustorb-cdr/src/error.rs

@@ -30,7 +30,7 @@ pub enum Error {
     InvalidWcharLength(u8),
     /// A GIOP 1.2 `wstring` had an odd octet length.
     OddWstringLength(u32),
-    /// `wchar` and `wstring` cannot be used with GIOP 1.0.
+    /// `wchar` and `wstring` cannot be used with this encoding (GIOP 1.0).
     WcharNotSupported,
     /// A sequence or string length is larger than the bytes left.
     LengthTooLarge {
@@ -54,6 +54,11 @@ pub enum Error {
     /// indirection that points nowhere. On the writing side, an
     /// `end_value` without its `begin_value`.
     InvalidValue(&'static str),
+    /// An XCDR header was malformed: an unknown encapsulation identifier,
+    /// a DHEADER, EMHEADER or parameter length past the end of the data
+    /// that holds it, or a length too large for its header. On the
+    /// writing side, a member ID too large for its header.
+    InvalidXcdr(&'static str),
 }
 
 impl fmt::Display for Error {
@@ -70,7 +75,7 @@ impl fmt::Display for Error {
             Error::InvalidUtf16 => f.write_str("wide string is not valid UTF-16"),
             Error::InvalidWcharLength(n) => write!(f, "invalid wchar octet length {n}"),
             Error::OddWstringLength(n) => write!(f, "odd wstring octet length {n}"),
-            Error::WcharNotSupported => f.write_str("wchar is not supported by GIOP 1.0"),
+            Error::WcharNotSupported => f.write_str("wchar is not supported by this encoding"),
             Error::LengthTooLarge { len, remaining } => write!(
                 f,
                 "length {len} is larger than the {remaining} bytes left in the stream"
@@ -82,6 +87,7 @@ impl fmt::Display for Error {
             Error::InvalidEnumValue(v) => write!(f, "invalid enum value {v}"),
             Error::InvalidTypeCode(why) => write!(f, "invalid TypeCode: {why}"),
             Error::InvalidValue(why) => write!(f, "invalid valuetype: {why}"),
+            Error::InvalidXcdr(why) => write!(f, "invalid XCDR: {why}"),
         }
     }
 }