rustorb 0.1.0__tar.gz → 0.2.0__tar.gz

{rustorb-0.1.0 → rustorb-0.2.0}/Cargo.lock

@@ -438,19 +438,20 @@ dependencies = [
 
 [[package]]
 name = "rustorb-cdr"
-version = "0.1.0"
+version = "0.2.0"
 
 [[package]]
 name = "rustorb-codegen"
-version = "0.1.0"
+version = "0.2.0"
 dependencies = [
  "rustorb-core",
+ "rustorb-typesupport",
  "tokio",
 ]
 
 [[package]]
 name = "rustorb-core"
-version = "0.1.0"
+version = "0.2.0"
 dependencies = [
  "criterion",
  "libc",
@@ -459,12 +460,13 @@ dependencies = [
  "rustorb-giop",
  "socket2",
  "tokio",
+ "tracing",
  "windows-sys 0.61.2",
 ]
 
 [[package]]
 name = "rustorb-ffi"
-version = "0.1.0"
+version = "0.2.0"
 dependencies = [
  "rustorb-cdr",
  "rustorb-core",
@@ -472,7 +474,7 @@ dependencies = [
 
 [[package]]
 name = "rustorb-giop"
-version = "0.1.0"
+version = "0.2.0"
 dependencies = [
  "rustorb-cdr",
  "serde_json",
@@ -480,7 +482,7 @@ dependencies = [
 
 [[package]]
 name = "rustorb-interop"
-version = "0.1.0"
+version = "0.2.0"
 dependencies = [
  "rustorb-core",
  "rustorb-naming",
@@ -488,18 +490,26 @@ dependencies = [
 
 [[package]]
 name = "rustorb-naming"
-version = "0.1.0"
+version = "0.2.0"
 dependencies = [
  "rustorb-core",
 ]
 
 [[package]]
 name = "rustorb-python"
-version = "0.1.0"
+version = "0.2.0"
 dependencies = [
  "pyo3",
  "pyo3-build-config",
  "rustorb-core",
+ "tracing",
+]
+
+[[package]]
+name = "rustorb-typesupport"
+version = "0.2.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.0 → rustorb-0.2.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.0"
+version = "0.2.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.0" }
-rustorb-giop = { path = "crates/rustorb-giop", version = "0.1.0" }
-rustorb-core = { path = "crates/rustorb-core", version = "0.1.0" }
-rustorb-naming = { path = "crates/rustorb-naming", version = "0.1.0" }
+rustorb-cdr = { path = "crates/rustorb-cdr", version = "0.2.0" }
+rustorb-typesupport = { path = "crates/rustorb-typesupport", version = "0.2.0" }
+rustorb-giop = { path = "crates/rustorb-giop", version = "0.2.0" }
+rustorb-core = { path = "crates/rustorb-core", version = "0.2.0" }
+rustorb-naming = { path = "crates/rustorb-naming", version = "0.2.0" }
 tokio = { version = "1", default-features = false }
 
 [workspace.lints.rust]

{rustorb-0.1.0 → rustorb-0.2.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: rustorb
-Version: 0.1.0
+Version: 0.2.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.0 → rustorb-0.2.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.0 → rustorb-0.2.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.0 → rustorb-0.2.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,8 +21,11 @@ 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.
@@ -46,28 +49,29 @@ 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,
         }
     }
 
     /// 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,9 +90,9 @@ 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.
@@ -163,14 +167,35 @@ 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;
+        let align = align.min(self.encoding.max_align());
+        let rem = (self.position() - self.origin) % align;
         if rem != 0 {
             self.buf.resize(self.buf.len() + align - rem, 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.position());
+        self.origin = origin;
+    }
+
     /// Writes an `octet`.
     pub fn write_octet(&mut self, value: u8) {
         self.buf.push(value);
@@ -236,10 +261,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 +295,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 +317,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 +340,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 +369,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.0 → rustorb-0.2.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}"),
         }
     }
 }

{rustorb-0.1.0 → rustorb-0.2.0}/crates/rustorb-cdr/src/lib.rs

@@ -41,6 +41,7 @@ mod long_double;
 mod octets;
 mod traits;
 mod value;
+pub mod xcdr;
 
 pub use decoder::{Decoder, Segment};
 pub use encoder::Encoder;
@@ -85,17 +86,48 @@ impl ByteOrder {
     }
 }
 
-/// The GIOP version whose CDR rules a stream follows.
+/// The encoding rules a stream follows.
 ///
-/// The versions differ only in how `wchar` and `wstring` are encoded:
+/// The GIOP versions differ only in how `wchar` and `wstring` are encoded:
 /// GIOP 1.0 has no wide characters, GIOP 1.1 encodes them as aligned
 /// fixed-width code units, and GIOP 1.2 encodes them as octet sequences.
+///
+/// [`Xcdr1`](Encoding::Xcdr1) and [`Xcdr2`](Encoding::Xcdr2) are the
+/// Extended CDR encodings of DDS-XTypes, versions 1 and 2. XCDR2 aligns
+/// no primitive to more than 4 octets ([`max_align`](Encoding::max_align)).
+/// The headers they add (the payload header, DHEADER, EMHEADER, parameter
+/// headers) are in [`xcdr`]; which of them a type needs is up to the code
+/// that knows the type.
 #[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
-pub enum CdrVersion {
+pub enum Encoding {
     /// GIOP 1.0.
     Giop1_0,
     /// GIOP 1.1.
     Giop1_1,
     /// GIOP 1.2 and later.
     Giop1_2,
+    /// DDS-XTypes Extended CDR, encoding version 1.
+    Xcdr1,
+    /// DDS-XTypes Extended CDR, encoding version 2.
+    Xcdr2,
+}
+
+impl Encoding {
+    /// Whether this is one of the GIOP encodings.
+    pub fn is_giop(self) -> bool {
+        matches!(
+            self,
+            Encoding::Giop1_0 | Encoding::Giop1_1 | Encoding::Giop1_2
+        )
+    }
+
+    /// The largest alignment a value gets: 8 octets, or 4 for XCDR2.
+    ///
+    /// [`Encoder::align`] and [`Decoder::align`] use no more than this.
+    pub fn max_align(self) -> usize {
+        match self {
+            Encoding::Xcdr2 => 4,
+            _ => 8,
+        }
+    }
 }

{rustorb-0.1.0 → rustorb-0.2.0}/crates/rustorb-cdr/src/value.rs

@@ -465,14 +465,14 @@ impl Decoder<'_> {
 #[cfg(test)]
 mod tests {
     use super::*;
-    use crate::{ByteOrder, CdrVersion};
+    use crate::{ByteOrder, Encoding};
 
     fn encoder(order: ByteOrder) -> Encoder {
-        Encoder::new(order, CdrVersion::Giop1_2)
+        Encoder::new(order, Encoding::Giop1_2)
     }
 
     fn decoder(bytes: &[u8], order: ByteOrder) -> Decoder<'_> {
-        Decoder::new(bytes, order, CdrVersion::Giop1_2)
+        Decoder::new(bytes, order, Encoding::Giop1_2)
     }
 
     #[test]