use std::fmt;
use std::sync::Weak;
use rustorb_cdr::{ByteOrder, Decoder, Encoder, Encoding as CdrEncoding};
pub use rustorb_giop::{ServiceContext, TaggedComponent, TaggedProfile, component_tag, service_id};
use crate::orb::OrbInner;
use crate::stream::{InStream, OutStream};
use crate::{Any, Orb, TypeCode};
pub const ENCODING_CDR_ENCAPS: i16 = 0;
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
pub struct Encoding {
pub format: i16,
pub major_version: u8,
pub minor_version: u8,
}
impl Encoding {
pub fn cdr(major_version: u8, minor_version: u8) -> Encoding {
Encoding {
format: ENCODING_CDR_ENCAPS,
major_version,
minor_version,
}
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum CodecError {
InvalidTypeForEncoding,
FormatMismatch,
TypeMismatch,
}
impl fmt::Display for CodecError {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
f.write_str(match self {
CodecError::InvalidTypeForEncoding => "IOP::Codec::InvalidTypeForEncoding",
CodecError::FormatMismatch => "IOP::Codec::FormatMismatch",
CodecError::TypeMismatch => "IOP::Codec::TypeMismatch",
})
}
}
impl std::error::Error for CodecError {}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub struct UnknownEncoding;
impl fmt::Display for UnknownEncoding {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
f.write_str("IOP::CodecFactory::UnknownEncoding")
}
}
impl std::error::Error for UnknownEncoding {}
#[derive(Clone)]
pub struct CodecFactory {
orb: Weak<OrbInner>,
order: ByteOrder,
}
impl fmt::Debug for CodecFactory {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
f.debug_struct("CodecFactory").finish_non_exhaustive()
}
}
impl CodecFactory {
pub(crate) fn new(orb: &Orb) -> CodecFactory {
CodecFactory {
orb: std::sync::Arc::downgrade(&orb.inner),
order: orb.inner.options.byte_order,
}
}
pub fn create_codec(&self, encoding: Encoding) -> Result<Codec, UnknownEncoding> {
let version = match (
encoding.format,
encoding.major_version,
encoding.minor_version,
) {
(ENCODING_CDR_ENCAPS, 1, 0) => CdrEncoding::Giop1_0,
(ENCODING_CDR_ENCAPS, 1, 1) => CdrEncoding::Giop1_1,
(ENCODING_CDR_ENCAPS, 1, 2) => CdrEncoding::Giop1_2,
_ => return Err(UnknownEncoding),
};
Ok(Codec {
orb: self.orb.clone(),
order: self.order,
version,
})
}
}
#[derive(Clone)]
pub struct Codec {
orb: Weak<OrbInner>,
order: ByteOrder,
version: CdrEncoding,
}
impl fmt::Debug for Codec {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
f.debug_struct("Codec")
.field("version", &self.version)
.finish_non_exhaustive()
}
}
impl Codec {
pub fn encode(&self, data: &Any) -> Result<Vec<u8>, CodecError> {
self.write(|out| out.write_any(data))
}
pub fn decode(&self, data: &[u8]) -> Result<Any, CodecError> {
self.read(data, |input| input.read_any())
.map_err(|_| CodecError::FormatMismatch)
}
pub fn encode_value(&self, data: &Any) -> Result<Vec<u8>, CodecError> {
self.write(|out| out.write_value(data.typecode(), data.value()))
}
pub fn decode_value(&self, data: &[u8], tc: &TypeCode) -> Result<Any, CodecError> {
let value = self
.read(data, |input| input.read_value(tc))
.map_err(|e| match e {
ReadError::Format => CodecError::FormatMismatch,
ReadError::Value => CodecError::TypeMismatch,
})?;
Ok(Any::new(tc.clone(), value))
}
fn write(
&self,
f: impl FnOnce(&mut OutStream<'_>) -> Result<(), crate::SystemException>,
) -> Result<Vec<u8>, CodecError> {
let mut enc = Encoder::encapsulation(self.order, self.version);
{
let mut out = OutStream::standalone(&mut enc);
if self.version == CdrEncoding::Giop1_0 {
out.set_code_sets(crate::CodeSets::NATIVE_NO_WCHAR);
}
f(&mut out).map_err(|_| CodecError::InvalidTypeForEncoding)?;
}
Ok(enc.into_parts().0)
}
fn read<T>(
&self,
data: &[u8],
f: impl FnOnce(&mut InStream<'_>) -> Result<T, crate::SystemException>,
) -> Result<T, ReadError> {
let dec = Decoder::encapsulation(data, self.version).map_err(|_| ReadError::Format)?;
let orb = self.orb.upgrade().map(|inner| Orb { inner });
let mut input = InStream::standalone(dec, orb.as_ref());
if self.version == CdrEncoding::Giop1_0 {
input.set_code_sets(crate::CodeSets::NATIVE_NO_WCHAR);
}
f(&mut input).map_err(|_| ReadError::Value)
}
}
enum ReadError {
Format,
Value,
}