const _: () = ::rustorb_core::idl::GENERATED_CODE_VERSION_1;
pub mod cos_naming {
pub type Istring = ::std::string::String;
#[derive(Debug, Clone, PartialEq, Eq, Hash, Default)]
pub struct NameComponent {
pub id: Istring,
pub kind: Istring,
}
impl NameComponent {
pub const REPOSITORY_ID: &'static str = "IDL:omg.org/CosNaming/NameComponent:1.0";
#[doc(hidden)]
pub fn _write_members(
&self,
out: &mut ::rustorb_core::OutStream<'_>,
) -> ::rustorb_core::idl::Sys<()> {
<alias::Istring as ::rustorb_core::idl::IdlType>::write(&self.id, out)?;
<alias::Istring as ::rustorb_core::idl::IdlType>::write(&self.kind, out)?;
Ok(())
}
#[doc(hidden)]
pub fn _read_members(
input: &mut ::rustorb_core::InStream<'_>,
) -> ::rustorb_core::idl::Sys<NameComponent> {
Ok(NameComponent {
id: <alias::Istring as ::rustorb_core::idl::IdlType>::read(input)?,
kind: <alias::Istring as ::rustorb_core::idl::IdlType>::read(input)?,
})
}
}
impl ::rustorb_core::idl::IdlType for NameComponent {
type Rust = NameComponent;
type Borrowed = NameComponent;
const MIN_SIZE: usize = <alias::Istring as ::rustorb_core::idl::IdlType>::MIN_SIZE
+ <alias::Istring as ::rustorb_core::idl::IdlType>::MIN_SIZE;
fn type_code() -> ::rustorb_core::TypeCode {
static TC: ::std::sync::OnceLock<::rustorb_core::TypeCode> =
::std::sync::OnceLock::new();
TC.get_or_init(|| {
::rustorb_core::idl::tc(::rustorb_core::TypeCode::struct_tc::<&str>(
"IDL:omg.org/CosNaming/NameComponent:1.0",
"NameComponent",
&[
(
"id",
<alias::Istring as ::rustorb_core::idl::IdlType>::type_code(),
),
(
"kind",
<alias::Istring as ::rustorb_core::idl::IdlType>::type_code(),
),
],
))
})
.clone()
}
fn write(
v: &NameComponent,
out: &mut ::rustorb_core::OutStream<'_>,
) -> ::rustorb_core::idl::Sys<()> {
v._write_members(out)
}
fn read(
input: &mut ::rustorb_core::InStream<'_>,
) -> ::rustorb_core::idl::Sys<NameComponent> {
Self::_read_members(input)
}
}
pub type Name = ::std::vec::Vec<NameComponent>;
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, PartialOrd, Ord, Default)]
pub enum BindingType {
#[default]
Nobject,
Ncontext,
}
impl BindingType {
pub const REPOSITORY_ID: &'static str = "IDL:omg.org/CosNaming/BindingType:1.0";
pub const VALUES: [BindingType; 2] = [BindingType::Nobject, BindingType::Ncontext];
pub fn from_u32(v: u32) -> Option<BindingType> {
Self::VALUES.get(v as usize).copied()
}
pub fn as_u32(self) -> u32 {
self as u32
}
}
impl ::rustorb_core::idl::IdlType for BindingType {
type Rust = BindingType;
type Borrowed = BindingType;
const MIN_SIZE: usize = 4;
fn type_code() -> ::rustorb_core::TypeCode {
static TC: ::std::sync::OnceLock<::rustorb_core::TypeCode> =
::std::sync::OnceLock::new();
TC.get_or_init(|| {
::rustorb_core::idl::tc(::rustorb_core::TypeCode::enum_tc(
"IDL:omg.org/CosNaming/BindingType:1.0",
"BindingType",
&["nobject", "ncontext"],
))
})
.clone()
}
fn write(
v: &BindingType,
out: &mut ::rustorb_core::OutStream<'_>,
) -> ::rustorb_core::idl::Sys<()> {
out.write_u32(v.as_u32());
Ok(())
}
fn read(input: &mut ::rustorb_core::InStream<'_>) -> ::rustorb_core::idl::Sys<BindingType> {
let v = input.read::<u32>()?;
BindingType::from_u32(v).ok_or_else(|| input.marshal_error())
}
}
#[derive(Debug, Clone, PartialEq, Eq, Hash, Default)]
pub struct Binding {
pub binding_name: Name,
pub binding_type: BindingType,
}
impl Binding {
pub const REPOSITORY_ID: &'static str = "IDL:omg.org/CosNaming/Binding:1.0";
#[doc(hidden)]
pub fn _write_members(
&self,
out: &mut ::rustorb_core::OutStream<'_>,
) -> ::rustorb_core::idl::Sys<()> {
<alias::Name as ::rustorb_core::idl::IdlType>::write(&self.binding_name, out)?;
<BindingType as ::rustorb_core::idl::IdlType>::write(&self.binding_type, out)?;
Ok(())
}
#[doc(hidden)]
pub fn _read_members(
input: &mut ::rustorb_core::InStream<'_>,
) -> ::rustorb_core::idl::Sys<Binding> {
Ok(Binding {
binding_name: <alias::Name as ::rustorb_core::idl::IdlType>::read(input)?,
binding_type: <BindingType as ::rustorb_core::idl::IdlType>::read(input)?,
})
}
}
impl ::rustorb_core::idl::IdlType for Binding {
type Rust = Binding;
type Borrowed = Binding;
const MIN_SIZE: usize = <alias::Name as ::rustorb_core::idl::IdlType>::MIN_SIZE
+ <BindingType as ::rustorb_core::idl::IdlType>::MIN_SIZE;
fn type_code() -> ::rustorb_core::TypeCode {
static TC: ::std::sync::OnceLock<::rustorb_core::TypeCode> =
::std::sync::OnceLock::new();
TC.get_or_init(|| {
::rustorb_core::idl::tc(::rustorb_core::TypeCode::struct_tc::<&str>(
"IDL:omg.org/CosNaming/Binding:1.0",
"Binding",
&[
(
"binding_name",
<alias::Name as ::rustorb_core::idl::IdlType>::type_code(),
),
(
"binding_type",
<BindingType as ::rustorb_core::idl::IdlType>::type_code(),
),
],
))
})
.clone()
}
fn write(
v: &Binding,
out: &mut ::rustorb_core::OutStream<'_>,
) -> ::rustorb_core::idl::Sys<()> {
v._write_members(out)
}
fn read(input: &mut ::rustorb_core::InStream<'_>) -> ::rustorb_core::idl::Sys<Binding> {
Self::_read_members(input)
}
}
pub type BindingList = ::std::vec::Vec<Binding>;
pub mod naming_context {
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, PartialOrd, Ord, Default)]
pub enum NotFoundReason {
#[default]
MissingNode,
NotContext,
NotObject,
}
impl NotFoundReason {
pub const REPOSITORY_ID: &'static str =
"IDL:omg.org/CosNaming/NamingContext/NotFoundReason:1.0";
pub const VALUES: [NotFoundReason; 3] = [
NotFoundReason::MissingNode,
NotFoundReason::NotContext,
NotFoundReason::NotObject,
];
pub fn from_u32(v: u32) -> Option<NotFoundReason> {
Self::VALUES.get(v as usize).copied()
}
pub fn as_u32(self) -> u32 {
self as u32
}
}
impl ::rustorb_core::idl::IdlType for NotFoundReason {
type Rust = NotFoundReason;
type Borrowed = NotFoundReason;
const MIN_SIZE: usize = 4;
fn type_code() -> ::rustorb_core::TypeCode {
static TC: ::std::sync::OnceLock<::rustorb_core::TypeCode> =
::std::sync::OnceLock::new();
TC.get_or_init(|| {
::rustorb_core::idl::tc(::rustorb_core::TypeCode::enum_tc(
"IDL:omg.org/CosNaming/NamingContext/NotFoundReason:1.0",
"NotFoundReason",
&["missing_node", "not_context", "not_object"],
))
})
.clone()
}
fn write(
v: &NotFoundReason,
out: &mut ::rustorb_core::OutStream<'_>,
) -> ::rustorb_core::idl::Sys<()> {
out.write_u32(v.as_u32());
Ok(())
}
fn read(
input: &mut ::rustorb_core::InStream<'_>,
) -> ::rustorb_core::idl::Sys<NotFoundReason> {
let v = input.read::<u32>()?;
NotFoundReason::from_u32(v).ok_or_else(|| input.marshal_error())
}
}
#[derive(Debug, Clone, PartialEq, Eq, Hash, Default)]
pub struct NotFound {
pub why: NotFoundReason,
pub rest_of_name: super::Name,
}
impl NotFound {
pub const REPOSITORY_ID: &'static str =
"IDL:omg.org/CosNaming/NamingContext/NotFound:1.0";
#[doc(hidden)]
pub fn _write_members(
&self,
out: &mut ::rustorb_core::OutStream<'_>,
) -> ::rustorb_core::idl::Sys<()> {
<NotFoundReason as ::rustorb_core::idl::IdlType>::write(&self.why, out)?;
<super::alias::Name as ::rustorb_core::idl::IdlType>::write(
&self.rest_of_name,
out,
)?;
Ok(())
}
#[doc(hidden)]
pub fn _read_members(
input: &mut ::rustorb_core::InStream<'_>,
) -> ::rustorb_core::idl::Sys<NotFound> {
Ok(NotFound {
why: <NotFoundReason as ::rustorb_core::idl::IdlType>::read(input)?,
rest_of_name: <super::alias::Name as ::rustorb_core::idl::IdlType>::read(
input,
)?,
})
}
}
impl ::std::fmt::Display for NotFound {
fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
f.write_str("user exception IDL:omg.org/CosNaming/NamingContext/NotFound:1.0")
}
}
impl ::std::error::Error for NotFound {}
impl ::rustorb_core::idl::IdlType for NotFound {
type Rust = NotFound;
type Borrowed = NotFound;
const MIN_SIZE: usize = 4
+ <NotFoundReason as ::rustorb_core::idl::IdlType>::MIN_SIZE
+ <super::alias::Name as ::rustorb_core::idl::IdlType>::MIN_SIZE;
fn type_code() -> ::rustorb_core::TypeCode {
static TC: ::std::sync::OnceLock<::rustorb_core::TypeCode> =
::std::sync::OnceLock::new();
TC.get_or_init(|| {
::rustorb_core::idl::tc(::rustorb_core::TypeCode::exception::<&str>(
"IDL:omg.org/CosNaming/NamingContext/NotFound:1.0",
"NotFound",
&[
(
"why",
<NotFoundReason as ::rustorb_core::idl::IdlType>::type_code(),
),
(
"rest_of_name",
<super::alias::Name as ::rustorb_core::idl::IdlType>::type_code(),
),
],
))
})
.clone()
}
fn write(
v: &NotFound,
out: &mut ::rustorb_core::OutStream<'_>,
) -> ::rustorb_core::idl::Sys<()> {
out.write_string(Self::REPOSITORY_ID)?;
v._write_members(out)
}
fn read(
input: &mut ::rustorb_core::InStream<'_>,
) -> ::rustorb_core::idl::Sys<NotFound> {
input.read_string()?;
Self::_read_members(input)
}
}
#[derive(Debug, Clone, PartialEq, Default)]
pub struct CannotProceed {
pub cxt: ::std::option::Option<super::NamingContext>,
pub rest_of_name: super::Name,
}
impl CannotProceed {
pub const REPOSITORY_ID: &'static str =
"IDL:omg.org/CosNaming/NamingContext/CannotProceed:1.0";
#[doc(hidden)]
pub fn _write_members(
&self,
out: &mut ::rustorb_core::OutStream<'_>,
) -> ::rustorb_core::idl::Sys<()> {
<super::NamingContext as ::rustorb_core::idl::IdlType>::write(&self.cxt, out)?;
<super::alias::Name as ::rustorb_core::idl::IdlType>::write(
&self.rest_of_name,
out,
)?;
Ok(())
}
#[doc(hidden)]
pub fn _read_members(
input: &mut ::rustorb_core::InStream<'_>,
) -> ::rustorb_core::idl::Sys<CannotProceed> {
Ok(CannotProceed {
cxt: <super::NamingContext as ::rustorb_core::idl::IdlType>::read(input)?,
rest_of_name: <super::alias::Name as ::rustorb_core::idl::IdlType>::read(
input,
)?,
})
}
}
impl ::std::fmt::Display for CannotProceed {
fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
f.write_str("user exception IDL:omg.org/CosNaming/NamingContext/CannotProceed:1.0")
}
}
impl ::std::error::Error for CannotProceed {}
impl ::rustorb_core::idl::IdlType for CannotProceed {
type Rust = CannotProceed;
type Borrowed = CannotProceed;
const MIN_SIZE: usize = 4
+ <super::NamingContext as ::rustorb_core::idl::IdlType>::MIN_SIZE
+ <super::alias::Name as ::rustorb_core::idl::IdlType>::MIN_SIZE;
fn type_code() -> ::rustorb_core::TypeCode {
static TC: ::std::sync::OnceLock<::rustorb_core::TypeCode> =
::std::sync::OnceLock::new();
TC.get_or_init(|| {
::rustorb_core::idl::tc(::rustorb_core::TypeCode::exception::<&str>(
"IDL:omg.org/CosNaming/NamingContext/CannotProceed:1.0",
"CannotProceed",
&[
(
"cxt",
<super::NamingContext as ::rustorb_core::idl::IdlType>::type_code(),
),
(
"rest_of_name",
<super::alias::Name as ::rustorb_core::idl::IdlType>::type_code(),
),
],
))
})
.clone()
}
fn write(
v: &CannotProceed,
out: &mut ::rustorb_core::OutStream<'_>,
) -> ::rustorb_core::idl::Sys<()> {
out.write_string(Self::REPOSITORY_ID)?;
v._write_members(out)
}
fn read(
input: &mut ::rustorb_core::InStream<'_>,
) -> ::rustorb_core::idl::Sys<CannotProceed> {
input.read_string()?;
Self::_read_members(input)
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Default)]
pub struct InvalidName {}
impl InvalidName {
pub const REPOSITORY_ID: &'static str =
"IDL:omg.org/CosNaming/NamingContext/InvalidName:1.0";
#[doc(hidden)]
pub fn _write_members(
&self,
_out: &mut ::rustorb_core::OutStream<'_>,
) -> ::rustorb_core::idl::Sys<()> {
Ok(())
}
#[doc(hidden)]
pub fn _read_members(
_input: &mut ::rustorb_core::InStream<'_>,
) -> ::rustorb_core::idl::Sys<InvalidName> {
Ok(InvalidName {})
}
}
impl ::std::fmt::Display for InvalidName {
fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
f.write_str("user exception IDL:omg.org/CosNaming/NamingContext/InvalidName:1.0")
}
}
impl ::std::error::Error for InvalidName {}
impl ::rustorb_core::idl::IdlType for InvalidName {
type Rust = InvalidName;
type Borrowed = InvalidName;
const MIN_SIZE: usize = 4;
fn type_code() -> ::rustorb_core::TypeCode {
static TC: ::std::sync::OnceLock<::rustorb_core::TypeCode> =
::std::sync::OnceLock::new();
TC.get_or_init(|| {
::rustorb_core::idl::tc(::rustorb_core::TypeCode::exception::<&str>(
"IDL:omg.org/CosNaming/NamingContext/InvalidName:1.0",
"InvalidName",
&[],
))
})
.clone()
}
fn write(
v: &InvalidName,
out: &mut ::rustorb_core::OutStream<'_>,
) -> ::rustorb_core::idl::Sys<()> {
out.write_string(Self::REPOSITORY_ID)?;
v._write_members(out)
}
fn read(
input: &mut ::rustorb_core::InStream<'_>,
) -> ::rustorb_core::idl::Sys<InvalidName> {
input.read_string()?;
Self::_read_members(input)
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Default)]
pub struct AlreadyBound {}
impl AlreadyBound {
pub const REPOSITORY_ID: &'static str =
"IDL:omg.org/CosNaming/NamingContext/AlreadyBound:1.0";
#[doc(hidden)]
pub fn _write_members(
&self,
_out: &mut ::rustorb_core::OutStream<'_>,
) -> ::rustorb_core::idl::Sys<()> {
Ok(())
}
#[doc(hidden)]
pub fn _read_members(
_input: &mut ::rustorb_core::InStream<'_>,
) -> ::rustorb_core::idl::Sys<AlreadyBound> {
Ok(AlreadyBound {})
}
}
impl ::std::fmt::Display for AlreadyBound {
fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
f.write_str("user exception IDL:omg.org/CosNaming/NamingContext/AlreadyBound:1.0")
}
}
impl ::std::error::Error for AlreadyBound {}
impl ::rustorb_core::idl::IdlType for AlreadyBound {
type Rust = AlreadyBound;
type Borrowed = AlreadyBound;
const MIN_SIZE: usize = 4;
fn type_code() -> ::rustorb_core::TypeCode {
static TC: ::std::sync::OnceLock<::rustorb_core::TypeCode> =
::std::sync::OnceLock::new();
TC.get_or_init(|| {
::rustorb_core::idl::tc(::rustorb_core::TypeCode::exception::<&str>(
"IDL:omg.org/CosNaming/NamingContext/AlreadyBound:1.0",
"AlreadyBound",
&[],
))
})
.clone()
}
fn write(
v: &AlreadyBound,
out: &mut ::rustorb_core::OutStream<'_>,
) -> ::rustorb_core::idl::Sys<()> {
out.write_string(Self::REPOSITORY_ID)?;
v._write_members(out)
}
fn read(
input: &mut ::rustorb_core::InStream<'_>,
) -> ::rustorb_core::idl::Sys<AlreadyBound> {
input.read_string()?;
Self::_read_members(input)
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Default)]
pub struct NotEmpty {}
impl NotEmpty {
pub const REPOSITORY_ID: &'static str =
"IDL:omg.org/CosNaming/NamingContext/NotEmpty:1.0";
#[doc(hidden)]
pub fn _write_members(
&self,
_out: &mut ::rustorb_core::OutStream<'_>,
) -> ::rustorb_core::idl::Sys<()> {
Ok(())
}
#[doc(hidden)]
pub fn _read_members(
_input: &mut ::rustorb_core::InStream<'_>,
) -> ::rustorb_core::idl::Sys<NotEmpty> {
Ok(NotEmpty {})
}
}
impl ::std::fmt::Display for NotEmpty {
fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
f.write_str("user exception IDL:omg.org/CosNaming/NamingContext/NotEmpty:1.0")
}
}
impl ::std::error::Error for NotEmpty {}
impl ::rustorb_core::idl::IdlType for NotEmpty {
type Rust = NotEmpty;
type Borrowed = NotEmpty;
const MIN_SIZE: usize = 4;
fn type_code() -> ::rustorb_core::TypeCode {
static TC: ::std::sync::OnceLock<::rustorb_core::TypeCode> =
::std::sync::OnceLock::new();
TC.get_or_init(|| {
::rustorb_core::idl::tc(::rustorb_core::TypeCode::exception::<&str>(
"IDL:omg.org/CosNaming/NamingContext/NotEmpty:1.0",
"NotEmpty",
&[],
))
})
.clone()
}
fn write(
v: &NotEmpty,
out: &mut ::rustorb_core::OutStream<'_>,
) -> ::rustorb_core::idl::Sys<()> {
out.write_string(Self::REPOSITORY_ID)?;
v._write_members(out)
}
fn read(
input: &mut ::rustorb_core::InStream<'_>,
) -> ::rustorb_core::idl::Sys<NotEmpty> {
input.read_string()?;
Self::_read_members(input)
}
}
#[derive(Debug, Clone)]
#[allow(clippy::enum_variant_names, clippy::large_enum_variant)]
pub enum BindError {
NotFound(NotFound),
CannotProceed(CannotProceed),
InvalidName(InvalidName),
AlreadyBound(AlreadyBound),
System(::rustorb_core::SystemException),
}
impl BindError {
pub fn repository_id(&self) -> &str {
match self {
BindError::NotFound(_) => NotFound::REPOSITORY_ID,
BindError::CannotProceed(_) => CannotProceed::REPOSITORY_ID,
BindError::InvalidName(_) => InvalidName::REPOSITORY_ID,
BindError::AlreadyBound(_) => AlreadyBound::REPOSITORY_ID,
BindError::System(e) => &e.repository_id,
}
}
pub fn from_exception(e: ::rustorb_core::Exception) -> BindError {
fn user(u: &::rustorb_core::UserException) -> ::rustorb_core::idl::Sys<BindError> {
let mut input = u.input()?;
Ok(match u.repository_id() {
NotFound::REPOSITORY_ID => {
BindError::NotFound(NotFound::_read_members(&mut input)?)
}
CannotProceed::REPOSITORY_ID => {
BindError::CannotProceed(CannotProceed::_read_members(&mut input)?)
}
InvalidName::REPOSITORY_ID => {
BindError::InvalidName(InvalidName::_read_members(&mut input)?)
}
AlreadyBound::REPOSITORY_ID => {
BindError::AlreadyBound(AlreadyBound::_read_members(&mut input)?)
}
_ => BindError::System(::rustorb_core::idl::unlisted_user_exception()),
})
}
match e {
::rustorb_core::Exception::System(e) => BindError::System(e),
::rustorb_core::Exception::User(u) => {
user(&u).unwrap_or_else(BindError::System)
}
}
}
#[doc(hidden)]
pub fn _write_reply(
self,
reply: &mut ::rustorb_core::ServerReply,
) -> ::rustorb_core::idl::Sys<()> {
match self {
BindError::NotFound(e) => {
e._write_members(&mut reply.user_exception(NotFound::REPOSITORY_ID)?)
}
BindError::CannotProceed(e) => {
e._write_members(&mut reply.user_exception(CannotProceed::REPOSITORY_ID)?)
}
BindError::InvalidName(e) => {
e._write_members(&mut reply.user_exception(InvalidName::REPOSITORY_ID)?)
}
BindError::AlreadyBound(e) => {
e._write_members(&mut reply.user_exception(AlreadyBound::REPOSITORY_ID)?)
}
BindError::System(e) => Err(e),
}
}
}
impl From<::rustorb_core::SystemException> for BindError {
fn from(e: ::rustorb_core::SystemException) -> BindError {
BindError::System(e)
}
}
impl From<NotFound> for BindError {
fn from(e: NotFound) -> BindError {
BindError::NotFound(e)
}
}
impl From<CannotProceed> for BindError {
fn from(e: CannotProceed) -> BindError {
BindError::CannotProceed(e)
}
}
impl From<InvalidName> for BindError {
fn from(e: InvalidName) -> BindError {
BindError::InvalidName(e)
}
}
impl From<AlreadyBound> for BindError {
fn from(e: AlreadyBound) -> BindError {
BindError::AlreadyBound(e)
}
}
impl ::std::fmt::Display for BindError {
fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
match self {
BindError::NotFound(e) => e.fmt(f),
BindError::CannotProceed(e) => e.fmt(f),
BindError::InvalidName(e) => e.fmt(f),
BindError::AlreadyBound(e) => e.fmt(f),
BindError::System(e) => e.fmt(f),
}
}
}
impl ::std::error::Error for BindError {}
#[derive(Debug, Clone)]
#[allow(clippy::enum_variant_names, clippy::large_enum_variant)]
pub enum RebindError {
NotFound(NotFound),
CannotProceed(CannotProceed),
InvalidName(InvalidName),
System(::rustorb_core::SystemException),
}
impl RebindError {
pub fn repository_id(&self) -> &str {
match self {
RebindError::NotFound(_) => NotFound::REPOSITORY_ID,
RebindError::CannotProceed(_) => CannotProceed::REPOSITORY_ID,
RebindError::InvalidName(_) => InvalidName::REPOSITORY_ID,
RebindError::System(e) => &e.repository_id,
}
}
pub fn from_exception(e: ::rustorb_core::Exception) -> RebindError {
fn user(
u: &::rustorb_core::UserException,
) -> ::rustorb_core::idl::Sys<RebindError> {
let mut input = u.input()?;
Ok(match u.repository_id() {
NotFound::REPOSITORY_ID => {
RebindError::NotFound(NotFound::_read_members(&mut input)?)
}
CannotProceed::REPOSITORY_ID => {
RebindError::CannotProceed(CannotProceed::_read_members(&mut input)?)
}
InvalidName::REPOSITORY_ID => {
RebindError::InvalidName(InvalidName::_read_members(&mut input)?)
}
_ => RebindError::System(::rustorb_core::idl::unlisted_user_exception()),
})
}
match e {
::rustorb_core::Exception::System(e) => RebindError::System(e),
::rustorb_core::Exception::User(u) => {
user(&u).unwrap_or_else(RebindError::System)
}
}
}
#[doc(hidden)]
pub fn _write_reply(
self,
reply: &mut ::rustorb_core::ServerReply,
) -> ::rustorb_core::idl::Sys<()> {
match self {
RebindError::NotFound(e) => {
e._write_members(&mut reply.user_exception(NotFound::REPOSITORY_ID)?)
}
RebindError::CannotProceed(e) => {
e._write_members(&mut reply.user_exception(CannotProceed::REPOSITORY_ID)?)
}
RebindError::InvalidName(e) => {
e._write_members(&mut reply.user_exception(InvalidName::REPOSITORY_ID)?)
}
RebindError::System(e) => Err(e),
}
}
}
impl From<::rustorb_core::SystemException> for RebindError {
fn from(e: ::rustorb_core::SystemException) -> RebindError {
RebindError::System(e)
}
}
impl From<NotFound> for RebindError {
fn from(e: NotFound) -> RebindError {
RebindError::NotFound(e)
}
}
impl From<CannotProceed> for RebindError {
fn from(e: CannotProceed) -> RebindError {
RebindError::CannotProceed(e)
}
}
impl From<InvalidName> for RebindError {
fn from(e: InvalidName) -> RebindError {
RebindError::InvalidName(e)
}
}
impl ::std::fmt::Display for RebindError {
fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
match self {
RebindError::NotFound(e) => e.fmt(f),
RebindError::CannotProceed(e) => e.fmt(f),
RebindError::InvalidName(e) => e.fmt(f),
RebindError::System(e) => e.fmt(f),
}
}
}
impl ::std::error::Error for RebindError {}
#[derive(Debug, Clone)]
#[allow(clippy::enum_variant_names, clippy::large_enum_variant)]
pub enum BindContextError {
NotFound(NotFound),
CannotProceed(CannotProceed),
InvalidName(InvalidName),
AlreadyBound(AlreadyBound),
System(::rustorb_core::SystemException),
}
impl BindContextError {
pub fn repository_id(&self) -> &str {
match self {
BindContextError::NotFound(_) => NotFound::REPOSITORY_ID,
BindContextError::CannotProceed(_) => CannotProceed::REPOSITORY_ID,
BindContextError::InvalidName(_) => InvalidName::REPOSITORY_ID,
BindContextError::AlreadyBound(_) => AlreadyBound::REPOSITORY_ID,
BindContextError::System(e) => &e.repository_id,
}
}
pub fn from_exception(e: ::rustorb_core::Exception) -> BindContextError {
fn user(
u: &::rustorb_core::UserException,
) -> ::rustorb_core::idl::Sys<BindContextError> {
let mut input = u.input()?;
Ok(match u.repository_id() {
NotFound::REPOSITORY_ID => {
BindContextError::NotFound(NotFound::_read_members(&mut input)?)
}
CannotProceed::REPOSITORY_ID => BindContextError::CannotProceed(
CannotProceed::_read_members(&mut input)?,
),
InvalidName::REPOSITORY_ID => {
BindContextError::InvalidName(InvalidName::_read_members(&mut input)?)
}
AlreadyBound::REPOSITORY_ID => {
BindContextError::AlreadyBound(AlreadyBound::_read_members(&mut input)?)
}
_ => {
BindContextError::System(::rustorb_core::idl::unlisted_user_exception())
}
})
}
match e {
::rustorb_core::Exception::System(e) => BindContextError::System(e),
::rustorb_core::Exception::User(u) => {
user(&u).unwrap_or_else(BindContextError::System)
}
}
}
#[doc(hidden)]
pub fn _write_reply(
self,
reply: &mut ::rustorb_core::ServerReply,
) -> ::rustorb_core::idl::Sys<()> {
match self {
BindContextError::NotFound(e) => {
e._write_members(&mut reply.user_exception(NotFound::REPOSITORY_ID)?)
}
BindContextError::CannotProceed(e) => {
e._write_members(&mut reply.user_exception(CannotProceed::REPOSITORY_ID)?)
}
BindContextError::InvalidName(e) => {
e._write_members(&mut reply.user_exception(InvalidName::REPOSITORY_ID)?)
}
BindContextError::AlreadyBound(e) => {
e._write_members(&mut reply.user_exception(AlreadyBound::REPOSITORY_ID)?)
}
BindContextError::System(e) => Err(e),
}
}
}
impl From<::rustorb_core::SystemException> for BindContextError {
fn from(e: ::rustorb_core::SystemException) -> BindContextError {
BindContextError::System(e)
}
}
impl From<NotFound> for BindContextError {
fn from(e: NotFound) -> BindContextError {
BindContextError::NotFound(e)
}
}
impl From<CannotProceed> for BindContextError {
fn from(e: CannotProceed) -> BindContextError {
BindContextError::CannotProceed(e)
}
}
impl From<InvalidName> for BindContextError {
fn from(e: InvalidName) -> BindContextError {
BindContextError::InvalidName(e)
}
}
impl From<AlreadyBound> for BindContextError {
fn from(e: AlreadyBound) -> BindContextError {
BindContextError::AlreadyBound(e)
}
}
impl ::std::fmt::Display for BindContextError {
fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
match self {
BindContextError::NotFound(e) => e.fmt(f),
BindContextError::CannotProceed(e) => e.fmt(f),
BindContextError::InvalidName(e) => e.fmt(f),
BindContextError::AlreadyBound(e) => e.fmt(f),
BindContextError::System(e) => e.fmt(f),
}
}
}
impl ::std::error::Error for BindContextError {}
#[derive(Debug, Clone)]
#[allow(clippy::enum_variant_names, clippy::large_enum_variant)]
pub enum RebindContextError {
NotFound(NotFound),
CannotProceed(CannotProceed),
InvalidName(InvalidName),
System(::rustorb_core::SystemException),
}
impl RebindContextError {
pub fn repository_id(&self) -> &str {
match self {
RebindContextError::NotFound(_) => NotFound::REPOSITORY_ID,
RebindContextError::CannotProceed(_) => CannotProceed::REPOSITORY_ID,
RebindContextError::InvalidName(_) => InvalidName::REPOSITORY_ID,
RebindContextError::System(e) => &e.repository_id,
}
}
pub fn from_exception(e: ::rustorb_core::Exception) -> RebindContextError {
fn user(
u: &::rustorb_core::UserException,
) -> ::rustorb_core::idl::Sys<RebindContextError> {
let mut input = u.input()?;
Ok(match u.repository_id() {
NotFound::REPOSITORY_ID => {
RebindContextError::NotFound(NotFound::_read_members(&mut input)?)
}
CannotProceed::REPOSITORY_ID => RebindContextError::CannotProceed(
CannotProceed::_read_members(&mut input)?,
),
InvalidName::REPOSITORY_ID => {
RebindContextError::InvalidName(InvalidName::_read_members(&mut input)?)
}
_ => RebindContextError::System(
::rustorb_core::idl::unlisted_user_exception(),
),
})
}
match e {
::rustorb_core::Exception::System(e) => RebindContextError::System(e),
::rustorb_core::Exception::User(u) => {
user(&u).unwrap_or_else(RebindContextError::System)
}
}
}
#[doc(hidden)]
pub fn _write_reply(
self,
reply: &mut ::rustorb_core::ServerReply,
) -> ::rustorb_core::idl::Sys<()> {
match self {
RebindContextError::NotFound(e) => {
e._write_members(&mut reply.user_exception(NotFound::REPOSITORY_ID)?)
}
RebindContextError::CannotProceed(e) => {
e._write_members(&mut reply.user_exception(CannotProceed::REPOSITORY_ID)?)
}
RebindContextError::InvalidName(e) => {
e._write_members(&mut reply.user_exception(InvalidName::REPOSITORY_ID)?)
}
RebindContextError::System(e) => Err(e),
}
}
}
impl From<::rustorb_core::SystemException> for RebindContextError {
fn from(e: ::rustorb_core::SystemException) -> RebindContextError {
RebindContextError::System(e)
}
}
impl From<NotFound> for RebindContextError {
fn from(e: NotFound) -> RebindContextError {
RebindContextError::NotFound(e)
}
}
impl From<CannotProceed> for RebindContextError {
fn from(e: CannotProceed) -> RebindContextError {
RebindContextError::CannotProceed(e)
}
}
impl From<InvalidName> for RebindContextError {
fn from(e: InvalidName) -> RebindContextError {
RebindContextError::InvalidName(e)
}
}
impl ::std::fmt::Display for RebindContextError {
fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
match self {
RebindContextError::NotFound(e) => e.fmt(f),
RebindContextError::CannotProceed(e) => e.fmt(f),
RebindContextError::InvalidName(e) => e.fmt(f),
RebindContextError::System(e) => e.fmt(f),
}
}
}
impl ::std::error::Error for RebindContextError {}
#[derive(Debug, Clone)]
#[allow(clippy::enum_variant_names, clippy::large_enum_variant)]
pub enum ResolveError {
NotFound(NotFound),
CannotProceed(CannotProceed),
InvalidName(InvalidName),
System(::rustorb_core::SystemException),
}
impl ResolveError {
pub fn repository_id(&self) -> &str {
match self {
ResolveError::NotFound(_) => NotFound::REPOSITORY_ID,
ResolveError::CannotProceed(_) => CannotProceed::REPOSITORY_ID,
ResolveError::InvalidName(_) => InvalidName::REPOSITORY_ID,
ResolveError::System(e) => &e.repository_id,
}
}
pub fn from_exception(e: ::rustorb_core::Exception) -> ResolveError {
fn user(
u: &::rustorb_core::UserException,
) -> ::rustorb_core::idl::Sys<ResolveError> {
let mut input = u.input()?;
Ok(match u.repository_id() {
NotFound::REPOSITORY_ID => {
ResolveError::NotFound(NotFound::_read_members(&mut input)?)
}
CannotProceed::REPOSITORY_ID => {
ResolveError::CannotProceed(CannotProceed::_read_members(&mut input)?)
}
InvalidName::REPOSITORY_ID => {
ResolveError::InvalidName(InvalidName::_read_members(&mut input)?)
}
_ => ResolveError::System(::rustorb_core::idl::unlisted_user_exception()),
})
}
match e {
::rustorb_core::Exception::System(e) => ResolveError::System(e),
::rustorb_core::Exception::User(u) => {
user(&u).unwrap_or_else(ResolveError::System)
}
}
}
#[doc(hidden)]
pub fn _write_reply(
self,
reply: &mut ::rustorb_core::ServerReply,
) -> ::rustorb_core::idl::Sys<()> {
match self {
ResolveError::NotFound(e) => {
e._write_members(&mut reply.user_exception(NotFound::REPOSITORY_ID)?)
}
ResolveError::CannotProceed(e) => {
e._write_members(&mut reply.user_exception(CannotProceed::REPOSITORY_ID)?)
}
ResolveError::InvalidName(e) => {
e._write_members(&mut reply.user_exception(InvalidName::REPOSITORY_ID)?)
}
ResolveError::System(e) => Err(e),
}
}
}
impl From<::rustorb_core::SystemException> for ResolveError {
fn from(e: ::rustorb_core::SystemException) -> ResolveError {
ResolveError::System(e)
}
}
impl From<NotFound> for ResolveError {
fn from(e: NotFound) -> ResolveError {
ResolveError::NotFound(e)
}
}
impl From<CannotProceed> for ResolveError {
fn from(e: CannotProceed) -> ResolveError {
ResolveError::CannotProceed(e)
}
}
impl From<InvalidName> for ResolveError {
fn from(e: InvalidName) -> ResolveError {
ResolveError::InvalidName(e)
}
}
impl ::std::fmt::Display for ResolveError {
fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
match self {
ResolveError::NotFound(e) => e.fmt(f),
ResolveError::CannotProceed(e) => e.fmt(f),
ResolveError::InvalidName(e) => e.fmt(f),
ResolveError::System(e) => e.fmt(f),
}
}
}
impl ::std::error::Error for ResolveError {}
#[derive(Debug, Clone)]
#[allow(clippy::enum_variant_names, clippy::large_enum_variant)]
pub enum UnbindError {
NotFound(NotFound),
CannotProceed(CannotProceed),
InvalidName(InvalidName),
System(::rustorb_core::SystemException),
}
impl UnbindError {
pub fn repository_id(&self) -> &str {
match self {
UnbindError::NotFound(_) => NotFound::REPOSITORY_ID,
UnbindError::CannotProceed(_) => CannotProceed::REPOSITORY_ID,
UnbindError::InvalidName(_) => InvalidName::REPOSITORY_ID,
UnbindError::System(e) => &e.repository_id,
}
}
pub fn from_exception(e: ::rustorb_core::Exception) -> UnbindError {
fn user(
u: &::rustorb_core::UserException,
) -> ::rustorb_core::idl::Sys<UnbindError> {
let mut input = u.input()?;
Ok(match u.repository_id() {
NotFound::REPOSITORY_ID => {
UnbindError::NotFound(NotFound::_read_members(&mut input)?)
}
CannotProceed::REPOSITORY_ID => {
UnbindError::CannotProceed(CannotProceed::_read_members(&mut input)?)
}
InvalidName::REPOSITORY_ID => {
UnbindError::InvalidName(InvalidName::_read_members(&mut input)?)
}
_ => UnbindError::System(::rustorb_core::idl::unlisted_user_exception()),
})
}
match e {
::rustorb_core::Exception::System(e) => UnbindError::System(e),
::rustorb_core::Exception::User(u) => {
user(&u).unwrap_or_else(UnbindError::System)
}
}
}
#[doc(hidden)]
pub fn _write_reply(
self,
reply: &mut ::rustorb_core::ServerReply,
) -> ::rustorb_core::idl::Sys<()> {
match self {
UnbindError::NotFound(e) => {
e._write_members(&mut reply.user_exception(NotFound::REPOSITORY_ID)?)
}
UnbindError::CannotProceed(e) => {
e._write_members(&mut reply.user_exception(CannotProceed::REPOSITORY_ID)?)
}
UnbindError::InvalidName(e) => {
e._write_members(&mut reply.user_exception(InvalidName::REPOSITORY_ID)?)
}
UnbindError::System(e) => Err(e),
}
}
}
impl From<::rustorb_core::SystemException> for UnbindError {
fn from(e: ::rustorb_core::SystemException) -> UnbindError {
UnbindError::System(e)
}
}
impl From<NotFound> for UnbindError {
fn from(e: NotFound) -> UnbindError {
UnbindError::NotFound(e)
}
}
impl From<CannotProceed> for UnbindError {
fn from(e: CannotProceed) -> UnbindError {
UnbindError::CannotProceed(e)
}
}
impl From<InvalidName> for UnbindError {
fn from(e: InvalidName) -> UnbindError {
UnbindError::InvalidName(e)
}
}
impl ::std::fmt::Display for UnbindError {
fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
match self {
UnbindError::NotFound(e) => e.fmt(f),
UnbindError::CannotProceed(e) => e.fmt(f),
UnbindError::InvalidName(e) => e.fmt(f),
UnbindError::System(e) => e.fmt(f),
}
}
}
impl ::std::error::Error for UnbindError {}
#[derive(Debug, Clone)]
#[allow(clippy::enum_variant_names, clippy::large_enum_variant)]
pub enum BindNewContextError {
NotFound(NotFound),
AlreadyBound(AlreadyBound),
CannotProceed(CannotProceed),
InvalidName(InvalidName),
System(::rustorb_core::SystemException),
}
impl BindNewContextError {
pub fn repository_id(&self) -> &str {
match self {
BindNewContextError::NotFound(_) => NotFound::REPOSITORY_ID,
BindNewContextError::AlreadyBound(_) => AlreadyBound::REPOSITORY_ID,
BindNewContextError::CannotProceed(_) => CannotProceed::REPOSITORY_ID,
BindNewContextError::InvalidName(_) => InvalidName::REPOSITORY_ID,
BindNewContextError::System(e) => &e.repository_id,
}
}
pub fn from_exception(e: ::rustorb_core::Exception) -> BindNewContextError {
fn user(
u: &::rustorb_core::UserException,
) -> ::rustorb_core::idl::Sys<BindNewContextError> {
let mut input = u.input()?;
Ok(match u.repository_id() {
NotFound::REPOSITORY_ID => {
BindNewContextError::NotFound(NotFound::_read_members(&mut input)?)
}
AlreadyBound::REPOSITORY_ID => BindNewContextError::AlreadyBound(
AlreadyBound::_read_members(&mut input)?,
),
CannotProceed::REPOSITORY_ID => BindNewContextError::CannotProceed(
CannotProceed::_read_members(&mut input)?,
),
InvalidName::REPOSITORY_ID => BindNewContextError::InvalidName(
InvalidName::_read_members(&mut input)?,
),
_ => BindNewContextError::System(
::rustorb_core::idl::unlisted_user_exception(),
),
})
}
match e {
::rustorb_core::Exception::System(e) => BindNewContextError::System(e),
::rustorb_core::Exception::User(u) => {
user(&u).unwrap_or_else(BindNewContextError::System)
}
}
}
#[doc(hidden)]
pub fn _write_reply(
self,
reply: &mut ::rustorb_core::ServerReply,
) -> ::rustorb_core::idl::Sys<()> {
match self {
BindNewContextError::NotFound(e) => {
e._write_members(&mut reply.user_exception(NotFound::REPOSITORY_ID)?)
}
BindNewContextError::AlreadyBound(e) => {
e._write_members(&mut reply.user_exception(AlreadyBound::REPOSITORY_ID)?)
}
BindNewContextError::CannotProceed(e) => {
e._write_members(&mut reply.user_exception(CannotProceed::REPOSITORY_ID)?)
}
BindNewContextError::InvalidName(e) => {
e._write_members(&mut reply.user_exception(InvalidName::REPOSITORY_ID)?)
}
BindNewContextError::System(e) => Err(e),
}
}
}
impl From<::rustorb_core::SystemException> for BindNewContextError {
fn from(e: ::rustorb_core::SystemException) -> BindNewContextError {
BindNewContextError::System(e)
}
}
impl From<NotFound> for BindNewContextError {
fn from(e: NotFound) -> BindNewContextError {
BindNewContextError::NotFound(e)
}
}
impl From<AlreadyBound> for BindNewContextError {
fn from(e: AlreadyBound) -> BindNewContextError {
BindNewContextError::AlreadyBound(e)
}
}
impl From<CannotProceed> for BindNewContextError {
fn from(e: CannotProceed) -> BindNewContextError {
BindNewContextError::CannotProceed(e)
}
}
impl From<InvalidName> for BindNewContextError {
fn from(e: InvalidName) -> BindNewContextError {
BindNewContextError::InvalidName(e)
}
}
impl ::std::fmt::Display for BindNewContextError {
fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
match self {
BindNewContextError::NotFound(e) => e.fmt(f),
BindNewContextError::AlreadyBound(e) => e.fmt(f),
BindNewContextError::CannotProceed(e) => e.fmt(f),
BindNewContextError::InvalidName(e) => e.fmt(f),
BindNewContextError::System(e) => e.fmt(f),
}
}
}
impl ::std::error::Error for BindNewContextError {}
#[derive(Debug, Clone)]
#[allow(clippy::enum_variant_names, clippy::large_enum_variant)]
pub enum DestroyError {
NotEmpty(NotEmpty),
System(::rustorb_core::SystemException),
}
impl DestroyError {
pub fn repository_id(&self) -> &str {
match self {
DestroyError::NotEmpty(_) => NotEmpty::REPOSITORY_ID,
DestroyError::System(e) => &e.repository_id,
}
}
pub fn from_exception(e: ::rustorb_core::Exception) -> DestroyError {
fn user(
u: &::rustorb_core::UserException,
) -> ::rustorb_core::idl::Sys<DestroyError> {
let mut input = u.input()?;
Ok(match u.repository_id() {
NotEmpty::REPOSITORY_ID => {
DestroyError::NotEmpty(NotEmpty::_read_members(&mut input)?)
}
_ => DestroyError::System(::rustorb_core::idl::unlisted_user_exception()),
})
}
match e {
::rustorb_core::Exception::System(e) => DestroyError::System(e),
::rustorb_core::Exception::User(u) => {
user(&u).unwrap_or_else(DestroyError::System)
}
}
}
#[doc(hidden)]
pub fn _write_reply(
self,
reply: &mut ::rustorb_core::ServerReply,
) -> ::rustorb_core::idl::Sys<()> {
match self {
DestroyError::NotEmpty(e) => {
e._write_members(&mut reply.user_exception(NotEmpty::REPOSITORY_ID)?)
}
DestroyError::System(e) => Err(e),
}
}
}
impl From<::rustorb_core::SystemException> for DestroyError {
fn from(e: ::rustorb_core::SystemException) -> DestroyError {
DestroyError::System(e)
}
}
impl From<NotEmpty> for DestroyError {
fn from(e: NotEmpty) -> DestroyError {
DestroyError::NotEmpty(e)
}
}
impl ::std::fmt::Display for DestroyError {
fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
match self {
DestroyError::NotEmpty(e) => e.fmt(f),
DestroyError::System(e) => e.fmt(f),
}
}
}
impl ::std::error::Error for DestroyError {}
}
#[derive(Debug, Clone, PartialEq)]
pub struct NamingContext(::rustorb_core::ObjectRef);
impl AsRef<::rustorb_core::ObjectRef> for NamingContext {
fn as_ref(&self) -> &::rustorb_core::ObjectRef {
&self.0
}
}
impl NamingContext {
pub const REPOSITORY_ID: &'static str = "IDL:omg.org/CosNaming/NamingContext:1.0";
pub fn narrow(
obj: &::rustorb_core::ObjectRef,
) -> ::rustorb_core::idl::Sys<Option<NamingContext>> {
Ok(if ::rustorb_core::idl::is_a(obj, Self::REPOSITORY_ID)? {
Some(NamingContext(obj.clone()))
} else {
None
})
}
pub fn unchecked_narrow(obj: ::rustorb_core::ObjectRef) -> NamingContext {
NamingContext(obj)
}
pub fn object(&self) -> &::rustorb_core::ObjectRef {
&self.0
}
pub fn into_object(self) -> ::rustorb_core::ObjectRef {
self.0
}
#[doc(hidden)]
pub fn _write(
v: Option<&NamingContext>,
out: &mut ::rustorb_core::OutStream<'_>,
) -> ::rustorb_core::idl::Sys<()> {
out.write_object(v.map(|v| &v.0))
}
#[allow(clippy::type_complexity)]
pub fn bind(
&self,
n: &[NameComponent],
obj: Option<&::rustorb_core::ObjectRef>,
) -> Result<(), naming_context::BindError> {
let request = self.0.request("bind").args(|out| {
<alias::Name as ::rustorb_core::idl::IdlType>::write(n, out)?;
out.write_object(obj)?;
Ok(())
});
request
.invoke()
.map_err(naming_context::BindError::from_exception)?;
Ok(())
}
#[allow(clippy::type_complexity)]
pub async fn bind_async(
&self,
n: &[NameComponent],
obj: Option<&::rustorb_core::ObjectRef>,
) -> Result<(), naming_context::BindError> {
let request = self.0.request_async("bind").args(|out| {
<alias::Name as ::rustorb_core::idl::IdlType>::write(n, out)?;
out.write_object(obj)?;
Ok(())
});
request
.invoke()
.await
.map_err(naming_context::BindError::from_exception)?;
Ok(())
}
#[allow(clippy::type_complexity)]
pub fn rebind(
&self,
n: &[NameComponent],
obj: Option<&::rustorb_core::ObjectRef>,
) -> Result<(), naming_context::RebindError> {
let request = self.0.request("rebind").args(|out| {
<alias::Name as ::rustorb_core::idl::IdlType>::write(n, out)?;
out.write_object(obj)?;
Ok(())
});
request
.invoke()
.map_err(naming_context::RebindError::from_exception)?;
Ok(())
}
#[allow(clippy::type_complexity)]
pub async fn rebind_async(
&self,
n: &[NameComponent],
obj: Option<&::rustorb_core::ObjectRef>,
) -> Result<(), naming_context::RebindError> {
let request = self.0.request_async("rebind").args(|out| {
<alias::Name as ::rustorb_core::idl::IdlType>::write(n, out)?;
out.write_object(obj)?;
Ok(())
});
request
.invoke()
.await
.map_err(naming_context::RebindError::from_exception)?;
Ok(())
}
#[allow(clippy::type_complexity)]
pub fn bind_context(
&self,
n: &[NameComponent],
nc: Option<&NamingContext>,
) -> Result<(), naming_context::BindContextError> {
let request = self.0.request("bind_context").args(|out| {
<alias::Name as ::rustorb_core::idl::IdlType>::write(n, out)?;
NamingContext::_write(nc, out)?;
Ok(())
});
request
.invoke()
.map_err(naming_context::BindContextError::from_exception)?;
Ok(())
}
#[allow(clippy::type_complexity)]
pub async fn bind_context_async(
&self,
n: &[NameComponent],
nc: Option<&NamingContext>,
) -> Result<(), naming_context::BindContextError> {
let request = self.0.request_async("bind_context").args(|out| {
<alias::Name as ::rustorb_core::idl::IdlType>::write(n, out)?;
NamingContext::_write(nc, out)?;
Ok(())
});
request
.invoke()
.await
.map_err(naming_context::BindContextError::from_exception)?;
Ok(())
}
#[allow(clippy::type_complexity)]
pub fn rebind_context(
&self,
n: &[NameComponent],
nc: Option<&NamingContext>,
) -> Result<(), naming_context::RebindContextError> {
let request = self.0.request("rebind_context").args(|out| {
<alias::Name as ::rustorb_core::idl::IdlType>::write(n, out)?;
NamingContext::_write(nc, out)?;
Ok(())
});
request
.invoke()
.map_err(naming_context::RebindContextError::from_exception)?;
Ok(())
}
#[allow(clippy::type_complexity)]
pub async fn rebind_context_async(
&self,
n: &[NameComponent],
nc: Option<&NamingContext>,
) -> Result<(), naming_context::RebindContextError> {
let request = self.0.request_async("rebind_context").args(|out| {
<alias::Name as ::rustorb_core::idl::IdlType>::write(n, out)?;
NamingContext::_write(nc, out)?;
Ok(())
});
request
.invoke()
.await
.map_err(naming_context::RebindContextError::from_exception)?;
Ok(())
}
#[allow(clippy::type_complexity)]
pub fn resolve(
&self,
n: &[NameComponent],
) -> Result<::std::option::Option<::rustorb_core::ObjectRef>, naming_context::ResolveError>
{
let request = self.0.request("resolve").args(|out| {
<alias::Name as ::rustorb_core::idl::IdlType>::write(n, out)?;
Ok(())
});
let reply = request
.invoke()
.map_err(naming_context::ResolveError::from_exception)?;
let mut input = reply.input();
let ret =
<::rustorb_core::idl::Object as ::rustorb_core::idl::IdlType>::read(&mut input)?;
Ok(ret)
}
#[allow(clippy::type_complexity)]
pub async fn resolve_async(
&self,
n: &[NameComponent],
) -> Result<::std::option::Option<::rustorb_core::ObjectRef>, naming_context::ResolveError>
{
let request = self.0.request_async("resolve").args(|out| {
<alias::Name as ::rustorb_core::idl::IdlType>::write(n, out)?;
Ok(())
});
let reply = request
.invoke()
.await
.map_err(naming_context::ResolveError::from_exception)?;
let mut input = reply.input();
let ret =
<::rustorb_core::idl::Object as ::rustorb_core::idl::IdlType>::read(&mut input)?;
Ok(ret)
}
#[allow(clippy::type_complexity)]
pub fn unbind(&self, n: &[NameComponent]) -> Result<(), naming_context::UnbindError> {
let request = self.0.request("unbind").args(|out| {
<alias::Name as ::rustorb_core::idl::IdlType>::write(n, out)?;
Ok(())
});
request
.invoke()
.map_err(naming_context::UnbindError::from_exception)?;
Ok(())
}
#[allow(clippy::type_complexity)]
pub async fn unbind_async(
&self,
n: &[NameComponent],
) -> Result<(), naming_context::UnbindError> {
let request = self.0.request_async("unbind").args(|out| {
<alias::Name as ::rustorb_core::idl::IdlType>::write(n, out)?;
Ok(())
});
request
.invoke()
.await
.map_err(naming_context::UnbindError::from_exception)?;
Ok(())
}
#[allow(clippy::type_complexity)]
pub fn new_context(
&self,
) -> Result<::std::option::Option<NamingContext>, ::rustorb_core::SystemException> {
let request = self.0.request("new_context");
let reply = request
.invoke()
.map_err(::rustorb_core::idl::system_exception)?;
let mut input = reply.input();
let ret = <NamingContext as ::rustorb_core::idl::IdlType>::read(&mut input)?;
Ok(ret)
}
#[allow(clippy::type_complexity)]
pub async fn new_context_async(
&self,
) -> Result<::std::option::Option<NamingContext>, ::rustorb_core::SystemException> {
let request = self.0.request_async("new_context");
let reply = request
.invoke()
.await
.map_err(::rustorb_core::idl::system_exception)?;
let mut input = reply.input();
let ret = <NamingContext as ::rustorb_core::idl::IdlType>::read(&mut input)?;
Ok(ret)
}
#[allow(clippy::type_complexity)]
pub fn bind_new_context(
&self,
n: &[NameComponent],
) -> Result<::std::option::Option<NamingContext>, naming_context::BindNewContextError>
{
let request = self.0.request("bind_new_context").args(|out| {
<alias::Name as ::rustorb_core::idl::IdlType>::write(n, out)?;
Ok(())
});
let reply = request
.invoke()
.map_err(naming_context::BindNewContextError::from_exception)?;
let mut input = reply.input();
let ret = <NamingContext as ::rustorb_core::idl::IdlType>::read(&mut input)?;
Ok(ret)
}
#[allow(clippy::type_complexity)]
pub async fn bind_new_context_async(
&self,
n: &[NameComponent],
) -> Result<::std::option::Option<NamingContext>, naming_context::BindNewContextError>
{
let request = self.0.request_async("bind_new_context").args(|out| {
<alias::Name as ::rustorb_core::idl::IdlType>::write(n, out)?;
Ok(())
});
let reply = request
.invoke()
.await
.map_err(naming_context::BindNewContextError::from_exception)?;
let mut input = reply.input();
let ret = <NamingContext as ::rustorb_core::idl::IdlType>::read(&mut input)?;
Ok(ret)
}
#[allow(clippy::type_complexity)]
pub fn destroy(&self) -> Result<(), naming_context::DestroyError> {
let request = self.0.request("destroy");
request
.invoke()
.map_err(naming_context::DestroyError::from_exception)?;
Ok(())
}
#[allow(clippy::type_complexity)]
pub async fn destroy_async(&self) -> Result<(), naming_context::DestroyError> {
let request = self.0.request_async("destroy");
request
.invoke()
.await
.map_err(naming_context::DestroyError::from_exception)?;
Ok(())
}
#[allow(clippy::type_complexity)]
pub fn list(
&self,
how_many: u32,
) -> Result<
(BindingList, ::std::option::Option<BindingIterator>),
::rustorb_core::SystemException,
> {
let request = self.0.request("list").args(|out| {
<::rustorb_core::idl::ULong as ::rustorb_core::idl::IdlType>::write(
&how_many, out,
)?;
Ok(())
});
let reply = request
.invoke()
.map_err(::rustorb_core::idl::system_exception)?;
let mut input = reply.input();
let bl = <alias::BindingList as ::rustorb_core::idl::IdlType>::read(&mut input)?;
let bi = <BindingIterator as ::rustorb_core::idl::IdlType>::read(&mut input)?;
Ok((bl, bi))
}
#[allow(clippy::type_complexity)]
pub async fn list_async(
&self,
how_many: u32,
) -> Result<
(BindingList, ::std::option::Option<BindingIterator>),
::rustorb_core::SystemException,
> {
let request = self.0.request_async("list").args(|out| {
<::rustorb_core::idl::ULong as ::rustorb_core::idl::IdlType>::write(
&how_many, out,
)?;
Ok(())
});
let reply = request
.invoke()
.await
.map_err(::rustorb_core::idl::system_exception)?;
let mut input = reply.input();
let bl = <alias::BindingList as ::rustorb_core::idl::IdlType>::read(&mut input)?;
let bi = <BindingIterator as ::rustorb_core::idl::IdlType>::read(&mut input)?;
Ok((bl, bi))
}
}
impl ::rustorb_core::idl::IdlType for NamingContext {
type Rust = Option<NamingContext>;
type Borrowed = Option<NamingContext>;
const MIN_SIZE: usize = 4;
fn type_code() -> ::rustorb_core::TypeCode {
static TC: ::std::sync::OnceLock<::rustorb_core::TypeCode> =
::std::sync::OnceLock::new();
TC.get_or_init(|| {
::rustorb_core::idl::tc(::rustorb_core::TypeCode::objref(
"IDL:omg.org/CosNaming/NamingContext:1.0",
"NamingContext",
))
})
.clone()
}
fn write(
v: &Option<NamingContext>,
out: &mut ::rustorb_core::OutStream<'_>,
) -> ::rustorb_core::idl::Sys<()> {
Self::_write(v.as_ref(), out)
}
fn read(
input: &mut ::rustorb_core::InStream<'_>,
) -> ::rustorb_core::idl::Sys<Option<NamingContext>> {
Ok(input.read_object()?.map(NamingContext))
}
}
pub trait NamingContextServant: Send + Sync {
#[allow(clippy::type_complexity)]
fn bind(
&self,
n: &[NameComponent],
obj: Option<&::rustorb_core::ObjectRef>,
) -> Result<(), naming_context::BindError>;
#[allow(clippy::type_complexity)]
fn rebind(
&self,
n: &[NameComponent],
obj: Option<&::rustorb_core::ObjectRef>,
) -> Result<(), naming_context::RebindError>;
#[allow(clippy::type_complexity)]
fn bind_context(
&self,
n: &[NameComponent],
nc: Option<&NamingContext>,
) -> Result<(), naming_context::BindContextError>;
#[allow(clippy::type_complexity)]
fn rebind_context(
&self,
n: &[NameComponent],
nc: Option<&NamingContext>,
) -> Result<(), naming_context::RebindContextError>;
#[allow(clippy::type_complexity)]
fn resolve(
&self,
n: &[NameComponent],
) -> Result<::std::option::Option<::rustorb_core::ObjectRef>, naming_context::ResolveError>;
#[allow(clippy::type_complexity)]
fn unbind(&self, n: &[NameComponent]) -> Result<(), naming_context::UnbindError>;
#[allow(clippy::type_complexity)]
fn new_context(
&self,
) -> Result<::std::option::Option<NamingContext>, ::rustorb_core::SystemException>;
#[allow(clippy::type_complexity)]
fn bind_new_context(
&self,
n: &[NameComponent],
) -> Result<::std::option::Option<NamingContext>, naming_context::BindNewContextError>;
#[allow(clippy::type_complexity)]
fn destroy(&self) -> Result<(), naming_context::DestroyError>;
#[allow(clippy::type_complexity)]
fn list(
&self,
how_many: u32,
) -> Result<
(BindingList, ::std::option::Option<BindingIterator>),
::rustorb_core::SystemException,
>;
}
pub struct NamingContextPoa<T>(pub T);
impl<T> ::std::fmt::Debug for NamingContextPoa<T> {
fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
f.write_str("NamingContextPoa")
}
}
impl<T: NamingContextServant + 'static> NamingContextPoa<T> {
pub fn activate(
self,
poa: &::rustorb_core::Poa,
) -> Result<(::rustorb_core::ObjectId, NamingContext), ::rustorb_core::PoaError> {
let servant: ::std::sync::Arc<dyn ::rustorb_core::Servant> =
::std::sync::Arc::new(self);
let id = poa.activate_object(servant)?;
let obj = poa.id_to_reference(&id)?;
Ok((id, NamingContext(obj)))
}
pub fn activate_with_id(
self,
poa: &::rustorb_core::Poa,
id: &[u8],
) -> Result<NamingContext, ::rustorb_core::PoaError> {
let servant: ::std::sync::Arc<dyn ::rustorb_core::Servant> =
::std::sync::Arc::new(self);
poa.activate_object_with_id(id, servant)?;
Ok(NamingContext(poa.id_to_reference(id)?))
}
}
impl<T: NamingContextServant> ::rustorb_core::Servant for NamingContextPoa<T> {
fn repository_id(&self) -> &str {
NamingContext::REPOSITORY_ID
}
fn is_a(&self, repository_id: &str) -> bool {
matches!(repository_id, "IDL:omg.org/CosNaming/NamingContext:1.0")
}
#[allow(unused_variables)]
fn dispatch(
&self,
operation: &str,
input: &mut ::rustorb_core::InStream<'_>,
reply: &mut ::rustorb_core::ServerReply,
) -> Result<(), ::rustorb_core::SystemException> {
match operation {
"bind" => {
let n = <alias::Name as ::rustorb_core::idl::IdlType>::read(input)?;
let obj =
<::rustorb_core::idl::Object as ::rustorb_core::idl::IdlType>::read(input)?;
let () = match self.0.bind(&n, obj.as_ref()) {
Ok(r) => r,
Err(e) => return e._write_reply(reply),
};
Ok(())
}
"rebind" => {
let n = <alias::Name as ::rustorb_core::idl::IdlType>::read(input)?;
let obj =
<::rustorb_core::idl::Object as ::rustorb_core::idl::IdlType>::read(input)?;
let () = match self.0.rebind(&n, obj.as_ref()) {
Ok(r) => r,
Err(e) => return e._write_reply(reply),
};
Ok(())
}
"bind_context" => {
let n = <alias::Name as ::rustorb_core::idl::IdlType>::read(input)?;
let nc = <NamingContext as ::rustorb_core::idl::IdlType>::read(input)?;
let () = match self.0.bind_context(&n, nc.as_ref()) {
Ok(r) => r,
Err(e) => return e._write_reply(reply),
};
Ok(())
}
"rebind_context" => {
let n = <alias::Name as ::rustorb_core::idl::IdlType>::read(input)?;
let nc = <NamingContext as ::rustorb_core::idl::IdlType>::read(input)?;
let () = match self.0.rebind_context(&n, nc.as_ref()) {
Ok(r) => r,
Err(e) => return e._write_reply(reply),
};
Ok(())
}
"resolve" => {
let n = <alias::Name as ::rustorb_core::idl::IdlType>::read(input)?;
let ret = match self.0.resolve(&n) {
Ok(r) => r,
Err(e) => return e._write_reply(reply),
};
let mut out = reply.output();
<::rustorb_core::idl::Object as ::rustorb_core::idl::IdlType>::write(
&ret, &mut out,
)?;
Ok(())
}
"unbind" => {
let n = <alias::Name as ::rustorb_core::idl::IdlType>::read(input)?;
let () = match self.0.unbind(&n) {
Ok(r) => r,
Err(e) => return e._write_reply(reply),
};
Ok(())
}
"new_context" => {
let ret = self.0.new_context()?;
let mut out = reply.output();
<NamingContext as ::rustorb_core::idl::IdlType>::write(&ret, &mut out)?;
Ok(())
}
"bind_new_context" => {
let n = <alias::Name as ::rustorb_core::idl::IdlType>::read(input)?;
let ret = match self.0.bind_new_context(&n) {
Ok(r) => r,
Err(e) => return e._write_reply(reply),
};
let mut out = reply.output();
<NamingContext as ::rustorb_core::idl::IdlType>::write(&ret, &mut out)?;
Ok(())
}
"destroy" => {
let () = match self.0.destroy() {
Ok(r) => r,
Err(e) => return e._write_reply(reply),
};
Ok(())
}
"list" => {
let how_many =
<::rustorb_core::idl::ULong as ::rustorb_core::idl::IdlType>::read(input)?;
let (bl, bi) = self.0.list(how_many)?;
let mut out = reply.output();
<alias::BindingList as ::rustorb_core::idl::IdlType>::write(&bl, &mut out)?;
<BindingIterator as ::rustorb_core::idl::IdlType>::write(&bi, &mut out)?;
Ok(())
}
_ => Err(::rustorb_core::idl::unknown_operation()),
}
}
}
#[derive(Debug, Clone, PartialEq)]
pub struct BindingIterator(::rustorb_core::ObjectRef);
impl AsRef<::rustorb_core::ObjectRef> for BindingIterator {
fn as_ref(&self) -> &::rustorb_core::ObjectRef {
&self.0
}
}
impl BindingIterator {
pub const REPOSITORY_ID: &'static str = "IDL:omg.org/CosNaming/BindingIterator:1.0";
pub fn narrow(
obj: &::rustorb_core::ObjectRef,
) -> ::rustorb_core::idl::Sys<Option<BindingIterator>> {
Ok(if ::rustorb_core::idl::is_a(obj, Self::REPOSITORY_ID)? {
Some(BindingIterator(obj.clone()))
} else {
None
})
}
pub fn unchecked_narrow(obj: ::rustorb_core::ObjectRef) -> BindingIterator {
BindingIterator(obj)
}
pub fn object(&self) -> &::rustorb_core::ObjectRef {
&self.0
}
pub fn into_object(self) -> ::rustorb_core::ObjectRef {
self.0
}
#[doc(hidden)]
pub fn _write(
v: Option<&BindingIterator>,
out: &mut ::rustorb_core::OutStream<'_>,
) -> ::rustorb_core::idl::Sys<()> {
out.write_object(v.map(|v| &v.0))
}
#[allow(clippy::type_complexity)]
pub fn next_one(&self) -> Result<(bool, Binding), ::rustorb_core::SystemException> {
let request = self.0.request("next_one");
let reply = request
.invoke()
.map_err(::rustorb_core::idl::system_exception)?;
let mut input = reply.input();
let ret =
<::rustorb_core::idl::Boolean as ::rustorb_core::idl::IdlType>::read(&mut input)?;
let b = <Binding as ::rustorb_core::idl::IdlType>::read(&mut input)?;
Ok((ret, b))
}
#[allow(clippy::type_complexity)]
pub async fn next_one_async(
&self,
) -> Result<(bool, Binding), ::rustorb_core::SystemException> {
let request = self.0.request_async("next_one");
let reply = request
.invoke()
.await
.map_err(::rustorb_core::idl::system_exception)?;
let mut input = reply.input();
let ret =
<::rustorb_core::idl::Boolean as ::rustorb_core::idl::IdlType>::read(&mut input)?;
let b = <Binding as ::rustorb_core::idl::IdlType>::read(&mut input)?;
Ok((ret, b))
}
#[allow(clippy::type_complexity)]
pub fn next_n(
&self,
how_many: u32,
) -> Result<(bool, BindingList), ::rustorb_core::SystemException> {
let request = self.0.request("next_n").args(|out| {
<::rustorb_core::idl::ULong as ::rustorb_core::idl::IdlType>::write(
&how_many, out,
)?;
Ok(())
});
let reply = request
.invoke()
.map_err(::rustorb_core::idl::system_exception)?;
let mut input = reply.input();
let ret =
<::rustorb_core::idl::Boolean as ::rustorb_core::idl::IdlType>::read(&mut input)?;
let bl = <alias::BindingList as ::rustorb_core::idl::IdlType>::read(&mut input)?;
Ok((ret, bl))
}
#[allow(clippy::type_complexity)]
pub async fn next_n_async(
&self,
how_many: u32,
) -> Result<(bool, BindingList), ::rustorb_core::SystemException> {
let request = self.0.request_async("next_n").args(|out| {
<::rustorb_core::idl::ULong as ::rustorb_core::idl::IdlType>::write(
&how_many, out,
)?;
Ok(())
});
let reply = request
.invoke()
.await
.map_err(::rustorb_core::idl::system_exception)?;
let mut input = reply.input();
let ret =
<::rustorb_core::idl::Boolean as ::rustorb_core::idl::IdlType>::read(&mut input)?;
let bl = <alias::BindingList as ::rustorb_core::idl::IdlType>::read(&mut input)?;
Ok((ret, bl))
}
#[allow(clippy::type_complexity)]
pub fn destroy(&self) -> Result<(), ::rustorb_core::SystemException> {
let request = self.0.request("destroy");
request
.invoke()
.map_err(::rustorb_core::idl::system_exception)?;
Ok(())
}
#[allow(clippy::type_complexity)]
pub async fn destroy_async(&self) -> Result<(), ::rustorb_core::SystemException> {
let request = self.0.request_async("destroy");
request
.invoke()
.await
.map_err(::rustorb_core::idl::system_exception)?;
Ok(())
}
}
impl ::rustorb_core::idl::IdlType for BindingIterator {
type Rust = Option<BindingIterator>;
type Borrowed = Option<BindingIterator>;
const MIN_SIZE: usize = 4;
fn type_code() -> ::rustorb_core::TypeCode {
static TC: ::std::sync::OnceLock<::rustorb_core::TypeCode> =
::std::sync::OnceLock::new();
TC.get_or_init(|| {
::rustorb_core::idl::tc(::rustorb_core::TypeCode::objref(
"IDL:omg.org/CosNaming/BindingIterator:1.0",
"BindingIterator",
))
})
.clone()
}
fn write(
v: &Option<BindingIterator>,
out: &mut ::rustorb_core::OutStream<'_>,
) -> ::rustorb_core::idl::Sys<()> {
Self::_write(v.as_ref(), out)
}
fn read(
input: &mut ::rustorb_core::InStream<'_>,
) -> ::rustorb_core::idl::Sys<Option<BindingIterator>> {
Ok(input.read_object()?.map(BindingIterator))
}
}
pub trait BindingIteratorServant: Send + Sync {
#[allow(clippy::type_complexity)]
fn next_one(&self) -> Result<(bool, Binding), ::rustorb_core::SystemException>;
#[allow(clippy::type_complexity)]
fn next_n(
&self,
how_many: u32,
) -> Result<(bool, BindingList), ::rustorb_core::SystemException>;
#[allow(clippy::type_complexity)]
fn destroy(&self) -> Result<(), ::rustorb_core::SystemException>;
}
pub struct BindingIteratorPoa<T>(pub T);
impl<T> ::std::fmt::Debug for BindingIteratorPoa<T> {
fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
f.write_str("BindingIteratorPoa")
}
}
impl<T: BindingIteratorServant + 'static> BindingIteratorPoa<T> {
pub fn activate(
self,
poa: &::rustorb_core::Poa,
) -> Result<(::rustorb_core::ObjectId, BindingIterator), ::rustorb_core::PoaError> {
let servant: ::std::sync::Arc<dyn ::rustorb_core::Servant> =
::std::sync::Arc::new(self);
let id = poa.activate_object(servant)?;
let obj = poa.id_to_reference(&id)?;
Ok((id, BindingIterator(obj)))
}
pub fn activate_with_id(
self,
poa: &::rustorb_core::Poa,
id: &[u8],
) -> Result<BindingIterator, ::rustorb_core::PoaError> {
let servant: ::std::sync::Arc<dyn ::rustorb_core::Servant> =
::std::sync::Arc::new(self);
poa.activate_object_with_id(id, servant)?;
Ok(BindingIterator(poa.id_to_reference(id)?))
}
}
impl<T: BindingIteratorServant> ::rustorb_core::Servant for BindingIteratorPoa<T> {
fn repository_id(&self) -> &str {
BindingIterator::REPOSITORY_ID
}
fn is_a(&self, repository_id: &str) -> bool {
matches!(repository_id, "IDL:omg.org/CosNaming/BindingIterator:1.0")
}
#[allow(unused_variables)]
fn dispatch(
&self,
operation: &str,
input: &mut ::rustorb_core::InStream<'_>,
reply: &mut ::rustorb_core::ServerReply,
) -> Result<(), ::rustorb_core::SystemException> {
match operation {
"next_one" => {
let (ret, b) = self.0.next_one()?;
let mut out = reply.output();
<::rustorb_core::idl::Boolean as ::rustorb_core::idl::IdlType>::write(
&ret, &mut out,
)?;
<Binding as ::rustorb_core::idl::IdlType>::write(&b, &mut out)?;
Ok(())
}
"next_n" => {
let how_many =
<::rustorb_core::idl::ULong as ::rustorb_core::idl::IdlType>::read(input)?;
let (ret, bl) = self.0.next_n(how_many)?;
let mut out = reply.output();
<::rustorb_core::idl::Boolean as ::rustorb_core::idl::IdlType>::write(
&ret, &mut out,
)?;
<alias::BindingList as ::rustorb_core::idl::IdlType>::write(&bl, &mut out)?;
Ok(())
}
"destroy" => {
self.0.destroy()?;
Ok(())
}
_ => Err(::rustorb_core::idl::unknown_operation()),
}
}
}
pub mod naming_context_ext {
pub type StringName = ::std::string::String;
pub type Address = ::std::string::String;
pub type UrlString = ::std::string::String;
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Default)]
pub struct InvalidAddress {}
impl InvalidAddress {
pub const REPOSITORY_ID: &'static str =
"IDL:omg.org/CosNaming/NamingContextExt/InvalidAddress:1.0";
#[doc(hidden)]
pub fn _write_members(
&self,
_out: &mut ::rustorb_core::OutStream<'_>,
) -> ::rustorb_core::idl::Sys<()> {
Ok(())
}
#[doc(hidden)]
pub fn _read_members(
_input: &mut ::rustorb_core::InStream<'_>,
) -> ::rustorb_core::idl::Sys<InvalidAddress> {
Ok(InvalidAddress {})
}
}
impl ::std::fmt::Display for InvalidAddress {
fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
f.write_str(
"user exception IDL:omg.org/CosNaming/NamingContextExt/InvalidAddress:1.0",
)
}
}
impl ::std::error::Error for InvalidAddress {}
impl ::rustorb_core::idl::IdlType for InvalidAddress {
type Rust = InvalidAddress;
type Borrowed = InvalidAddress;
const MIN_SIZE: usize = 4;
fn type_code() -> ::rustorb_core::TypeCode {
static TC: ::std::sync::OnceLock<::rustorb_core::TypeCode> =
::std::sync::OnceLock::new();
TC.get_or_init(|| {
::rustorb_core::idl::tc(::rustorb_core::TypeCode::exception::<&str>(
"IDL:omg.org/CosNaming/NamingContextExt/InvalidAddress:1.0",
"InvalidAddress",
&[],
))
})
.clone()
}
fn write(
v: &InvalidAddress,
out: &mut ::rustorb_core::OutStream<'_>,
) -> ::rustorb_core::idl::Sys<()> {
out.write_string(Self::REPOSITORY_ID)?;
v._write_members(out)
}
fn read(
input: &mut ::rustorb_core::InStream<'_>,
) -> ::rustorb_core::idl::Sys<InvalidAddress> {
input.read_string()?;
Self::_read_members(input)
}
}
#[derive(Debug, Clone)]
#[allow(clippy::enum_variant_names, clippy::large_enum_variant)]
pub enum ToStringError {
InvalidName(super::naming_context::InvalidName),
System(::rustorb_core::SystemException),
}
impl ToStringError {
pub fn repository_id(&self) -> &str {
match self {
ToStringError::InvalidName(_) => {
super::naming_context::InvalidName::REPOSITORY_ID
}
ToStringError::System(e) => &e.repository_id,
}
}
pub fn from_exception(e: ::rustorb_core::Exception) -> ToStringError {
fn user(
u: &::rustorb_core::UserException,
) -> ::rustorb_core::idl::Sys<ToStringError> {
let mut input = u.input()?;
Ok(match u.repository_id() {
super::naming_context::InvalidName::REPOSITORY_ID => {
ToStringError::InvalidName(
super::naming_context::InvalidName::_read_members(&mut input)?,
)
}
_ => ToStringError::System(::rustorb_core::idl::unlisted_user_exception()),
})
}
match e {
::rustorb_core::Exception::System(e) => ToStringError::System(e),
::rustorb_core::Exception::User(u) => {
user(&u).unwrap_or_else(ToStringError::System)
}
}
}
#[doc(hidden)]
pub fn _write_reply(
self,
reply: &mut ::rustorb_core::ServerReply,
) -> ::rustorb_core::idl::Sys<()> {
match self {
ToStringError::InvalidName(e) => e._write_members(
&mut reply
.user_exception(super::naming_context::InvalidName::REPOSITORY_ID)?,
),
ToStringError::System(e) => Err(e),
}
}
}
impl From<::rustorb_core::SystemException> for ToStringError {
fn from(e: ::rustorb_core::SystemException) -> ToStringError {
ToStringError::System(e)
}
}
impl From<super::naming_context::InvalidName> for ToStringError {
fn from(e: super::naming_context::InvalidName) -> ToStringError {
ToStringError::InvalidName(e)
}
}
impl ::std::fmt::Display for ToStringError {
fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
match self {
ToStringError::InvalidName(e) => e.fmt(f),
ToStringError::System(e) => e.fmt(f),
}
}
}
impl ::std::error::Error for ToStringError {}
#[derive(Debug, Clone)]
#[allow(clippy::enum_variant_names, clippy::large_enum_variant)]
pub enum ToNameError {
InvalidName(super::naming_context::InvalidName),
System(::rustorb_core::SystemException),
}
impl ToNameError {
pub fn repository_id(&self) -> &str {
match self {
ToNameError::InvalidName(_) => {
super::naming_context::InvalidName::REPOSITORY_ID
}
ToNameError::System(e) => &e.repository_id,
}
}
pub fn from_exception(e: ::rustorb_core::Exception) -> ToNameError {
fn user(
u: &::rustorb_core::UserException,
) -> ::rustorb_core::idl::Sys<ToNameError> {
let mut input = u.input()?;
Ok(match u.repository_id() {
super::naming_context::InvalidName::REPOSITORY_ID => {
ToNameError::InvalidName(
super::naming_context::InvalidName::_read_members(&mut input)?,
)
}
_ => ToNameError::System(::rustorb_core::idl::unlisted_user_exception()),
})
}
match e {
::rustorb_core::Exception::System(e) => ToNameError::System(e),
::rustorb_core::Exception::User(u) => {
user(&u).unwrap_or_else(ToNameError::System)
}
}
}
#[doc(hidden)]
pub fn _write_reply(
self,
reply: &mut ::rustorb_core::ServerReply,
) -> ::rustorb_core::idl::Sys<()> {
match self {
ToNameError::InvalidName(e) => e._write_members(
&mut reply
.user_exception(super::naming_context::InvalidName::REPOSITORY_ID)?,
),
ToNameError::System(e) => Err(e),
}
}
}
impl From<::rustorb_core::SystemException> for ToNameError {
fn from(e: ::rustorb_core::SystemException) -> ToNameError {
ToNameError::System(e)
}
}
impl From<super::naming_context::InvalidName> for ToNameError {
fn from(e: super::naming_context::InvalidName) -> ToNameError {
ToNameError::InvalidName(e)
}
}
impl ::std::fmt::Display for ToNameError {
fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
match self {
ToNameError::InvalidName(e) => e.fmt(f),
ToNameError::System(e) => e.fmt(f),
}
}
}
impl ::std::error::Error for ToNameError {}
#[derive(Debug, Clone)]
#[allow(clippy::enum_variant_names, clippy::large_enum_variant)]
pub enum ToUrlError {
InvalidAddress(InvalidAddress),
InvalidName(super::naming_context::InvalidName),
System(::rustorb_core::SystemException),
}
impl ToUrlError {
pub fn repository_id(&self) -> &str {
match self {
ToUrlError::InvalidAddress(_) => InvalidAddress::REPOSITORY_ID,
ToUrlError::InvalidName(_) => super::naming_context::InvalidName::REPOSITORY_ID,
ToUrlError::System(e) => &e.repository_id,
}
}
pub fn from_exception(e: ::rustorb_core::Exception) -> ToUrlError {
fn user(u: &::rustorb_core::UserException) -> ::rustorb_core::idl::Sys<ToUrlError> {
let mut input = u.input()?;
Ok(match u.repository_id() {
InvalidAddress::REPOSITORY_ID => {
ToUrlError::InvalidAddress(InvalidAddress::_read_members(&mut input)?)
}
super::naming_context::InvalidName::REPOSITORY_ID => {
ToUrlError::InvalidName(
super::naming_context::InvalidName::_read_members(&mut input)?,
)
}
_ => ToUrlError::System(::rustorb_core::idl::unlisted_user_exception()),
})
}
match e {
::rustorb_core::Exception::System(e) => ToUrlError::System(e),
::rustorb_core::Exception::User(u) => {
user(&u).unwrap_or_else(ToUrlError::System)
}
}
}
#[doc(hidden)]
pub fn _write_reply(
self,
reply: &mut ::rustorb_core::ServerReply,
) -> ::rustorb_core::idl::Sys<()> {
match self {
ToUrlError::InvalidAddress(e) => {
e._write_members(&mut reply.user_exception(InvalidAddress::REPOSITORY_ID)?)
}
ToUrlError::InvalidName(e) => e._write_members(
&mut reply
.user_exception(super::naming_context::InvalidName::REPOSITORY_ID)?,
),
ToUrlError::System(e) => Err(e),
}
}
}
impl From<::rustorb_core::SystemException> for ToUrlError {
fn from(e: ::rustorb_core::SystemException) -> ToUrlError {
ToUrlError::System(e)
}
}
impl From<InvalidAddress> for ToUrlError {
fn from(e: InvalidAddress) -> ToUrlError {
ToUrlError::InvalidAddress(e)
}
}
impl From<super::naming_context::InvalidName> for ToUrlError {
fn from(e: super::naming_context::InvalidName) -> ToUrlError {
ToUrlError::InvalidName(e)
}
}
impl ::std::fmt::Display for ToUrlError {
fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
match self {
ToUrlError::InvalidAddress(e) => e.fmt(f),
ToUrlError::InvalidName(e) => e.fmt(f),
ToUrlError::System(e) => e.fmt(f),
}
}
}
impl ::std::error::Error for ToUrlError {}
#[derive(Debug, Clone)]
#[allow(clippy::enum_variant_names, clippy::large_enum_variant)]
pub enum ResolveStrError {
NotFound(super::naming_context::NotFound),
CannotProceed(super::naming_context::CannotProceed),
InvalidName(super::naming_context::InvalidName),
System(::rustorb_core::SystemException),
}
impl ResolveStrError {
pub fn repository_id(&self) -> &str {
match self {
ResolveStrError::NotFound(_) => super::naming_context::NotFound::REPOSITORY_ID,
ResolveStrError::CannotProceed(_) => {
super::naming_context::CannotProceed::REPOSITORY_ID
}
ResolveStrError::InvalidName(_) => {
super::naming_context::InvalidName::REPOSITORY_ID
}
ResolveStrError::System(e) => &e.repository_id,
}
}
pub fn from_exception(e: ::rustorb_core::Exception) -> ResolveStrError {
fn user(
u: &::rustorb_core::UserException,
) -> ::rustorb_core::idl::Sys<ResolveStrError> {
let mut input = u.input()?;
Ok(match u.repository_id() {
super::naming_context::NotFound::REPOSITORY_ID => {
ResolveStrError::NotFound(
super::naming_context::NotFound::_read_members(&mut input)?,
)
}
super::naming_context::CannotProceed::REPOSITORY_ID => {
ResolveStrError::CannotProceed(
super::naming_context::CannotProceed::_read_members(&mut input)?,
)
}
super::naming_context::InvalidName::REPOSITORY_ID => {
ResolveStrError::InvalidName(
super::naming_context::InvalidName::_read_members(&mut input)?,
)
}
_ => {
ResolveStrError::System(::rustorb_core::idl::unlisted_user_exception())
}
})
}
match e {
::rustorb_core::Exception::System(e) => ResolveStrError::System(e),
::rustorb_core::Exception::User(u) => {
user(&u).unwrap_or_else(ResolveStrError::System)
}
}
}
#[doc(hidden)]
pub fn _write_reply(
self,
reply: &mut ::rustorb_core::ServerReply,
) -> ::rustorb_core::idl::Sys<()> {
match self {
ResolveStrError::NotFound(e) => e._write_members(
&mut reply
.user_exception(super::naming_context::NotFound::REPOSITORY_ID)?,
),
ResolveStrError::CannotProceed(e) => e._write_members(
&mut reply
.user_exception(super::naming_context::CannotProceed::REPOSITORY_ID)?,
),
ResolveStrError::InvalidName(e) => e._write_members(
&mut reply
.user_exception(super::naming_context::InvalidName::REPOSITORY_ID)?,
),
ResolveStrError::System(e) => Err(e),
}
}
}
impl From<::rustorb_core::SystemException> for ResolveStrError {
fn from(e: ::rustorb_core::SystemException) -> ResolveStrError {
ResolveStrError::System(e)
}
}
impl From<super::naming_context::NotFound> for ResolveStrError {
fn from(e: super::naming_context::NotFound) -> ResolveStrError {
ResolveStrError::NotFound(e)
}
}
impl From<super::naming_context::CannotProceed> for ResolveStrError {
fn from(e: super::naming_context::CannotProceed) -> ResolveStrError {
ResolveStrError::CannotProceed(e)
}
}
impl From<super::naming_context::InvalidName> for ResolveStrError {
fn from(e: super::naming_context::InvalidName) -> ResolveStrError {
ResolveStrError::InvalidName(e)
}
}
impl ::std::fmt::Display for ResolveStrError {
fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
match self {
ResolveStrError::NotFound(e) => e.fmt(f),
ResolveStrError::CannotProceed(e) => e.fmt(f),
ResolveStrError::InvalidName(e) => e.fmt(f),
ResolveStrError::System(e) => e.fmt(f),
}
}
}
impl ::std::error::Error for ResolveStrError {}
pub mod alias {
#[derive(Debug)]
pub struct StringName;
impl ::rustorb_core::idl::IdlType for StringName {
type Rust = <::rustorb_core::idl::String as ::rustorb_core::idl::IdlType>::Rust;
type Borrowed =
<::rustorb_core::idl::String as ::rustorb_core::idl::IdlType>::Borrowed;
const MIN_SIZE: usize =
<::rustorb_core::idl::String as ::rustorb_core::idl::IdlType>::MIN_SIZE;
fn type_code() -> ::rustorb_core::TypeCode {
static TC: ::std::sync::OnceLock<::rustorb_core::TypeCode> =
::std::sync::OnceLock::new();
TC.get_or_init(|| ::rustorb_core::idl::tc(::rustorb_core::TypeCode::alias("IDL:omg.org/CosNaming/NamingContextExt/StringName:1.0", "StringName", &<::rustorb_core::idl::String as ::rustorb_core::idl::IdlType>::type_code()))).clone()
}
fn write(
v: &Self::Borrowed,
out: &mut ::rustorb_core::OutStream<'_>,
) -> ::rustorb_core::idl::Sys<()> {
<::rustorb_core::idl::String as ::rustorb_core::idl::IdlType>::write(v, out)
}
fn read(
input: &mut ::rustorb_core::InStream<'_>,
) -> ::rustorb_core::idl::Sys<Self::Rust> {
<::rustorb_core::idl::String as ::rustorb_core::idl::IdlType>::read(input)
}
}
#[derive(Debug)]
pub struct Address;
impl ::rustorb_core::idl::IdlType for Address {
type Rust = <::rustorb_core::idl::String as ::rustorb_core::idl::IdlType>::Rust;
type Borrowed =
<::rustorb_core::idl::String as ::rustorb_core::idl::IdlType>::Borrowed;
const MIN_SIZE: usize =
<::rustorb_core::idl::String as ::rustorb_core::idl::IdlType>::MIN_SIZE;
fn type_code() -> ::rustorb_core::TypeCode {
static TC: ::std::sync::OnceLock<::rustorb_core::TypeCode> =
::std::sync::OnceLock::new();
TC.get_or_init(|| ::rustorb_core::idl::tc(::rustorb_core::TypeCode::alias("IDL:omg.org/CosNaming/NamingContextExt/Address:1.0", "Address", &<::rustorb_core::idl::String as ::rustorb_core::idl::IdlType>::type_code()))).clone()
}
fn write(
v: &Self::Borrowed,
out: &mut ::rustorb_core::OutStream<'_>,
) -> ::rustorb_core::idl::Sys<()> {
<::rustorb_core::idl::String as ::rustorb_core::idl::IdlType>::write(v, out)
}
fn read(
input: &mut ::rustorb_core::InStream<'_>,
) -> ::rustorb_core::idl::Sys<Self::Rust> {
<::rustorb_core::idl::String as ::rustorb_core::idl::IdlType>::read(input)
}
}
#[derive(Debug)]
pub struct UrlString;
impl ::rustorb_core::idl::IdlType for UrlString {
type Rust = <::rustorb_core::idl::String as ::rustorb_core::idl::IdlType>::Rust;
type Borrowed =
<::rustorb_core::idl::String as ::rustorb_core::idl::IdlType>::Borrowed;
const MIN_SIZE: usize =
<::rustorb_core::idl::String as ::rustorb_core::idl::IdlType>::MIN_SIZE;
fn type_code() -> ::rustorb_core::TypeCode {
static TC: ::std::sync::OnceLock<::rustorb_core::TypeCode> =
::std::sync::OnceLock::new();
TC.get_or_init(|| ::rustorb_core::idl::tc(::rustorb_core::TypeCode::alias("IDL:omg.org/CosNaming/NamingContextExt/URLString:1.0", "URLString", &<::rustorb_core::idl::String as ::rustorb_core::idl::IdlType>::type_code()))).clone()
}
fn write(
v: &Self::Borrowed,
out: &mut ::rustorb_core::OutStream<'_>,
) -> ::rustorb_core::idl::Sys<()> {
<::rustorb_core::idl::String as ::rustorb_core::idl::IdlType>::write(v, out)
}
fn read(
input: &mut ::rustorb_core::InStream<'_>,
) -> ::rustorb_core::idl::Sys<Self::Rust> {
<::rustorb_core::idl::String as ::rustorb_core::idl::IdlType>::read(input)
}
}
}
}
#[derive(Debug, Clone, PartialEq)]
pub struct NamingContextExt(::rustorb_core::ObjectRef);
impl AsRef<::rustorb_core::ObjectRef> for NamingContextExt {
fn as_ref(&self) -> &::rustorb_core::ObjectRef {
&self.0
}
}
impl From<NamingContextExt> for NamingContext {
fn from(v: NamingContextExt) -> NamingContext {
NamingContext::unchecked_narrow(v.0)
}
}
impl NamingContextExt {
pub const REPOSITORY_ID: &'static str = "IDL:omg.org/CosNaming/NamingContextExt:1.0";
pub fn narrow(
obj: &::rustorb_core::ObjectRef,
) -> ::rustorb_core::idl::Sys<Option<NamingContextExt>> {
Ok(if ::rustorb_core::idl::is_a(obj, Self::REPOSITORY_ID)? {
Some(NamingContextExt(obj.clone()))
} else {
None
})
}
pub fn unchecked_narrow(obj: ::rustorb_core::ObjectRef) -> NamingContextExt {
NamingContextExt(obj)
}
pub fn object(&self) -> &::rustorb_core::ObjectRef {
&self.0
}
pub fn into_object(self) -> ::rustorb_core::ObjectRef {
self.0
}
#[doc(hidden)]
pub fn _write(
v: Option<&NamingContextExt>,
out: &mut ::rustorb_core::OutStream<'_>,
) -> ::rustorb_core::idl::Sys<()> {
out.write_object(v.map(|v| &v.0))
}
#[allow(clippy::type_complexity)]
pub fn to_string(
&self,
n: &[NameComponent],
) -> Result<naming_context_ext::StringName, naming_context_ext::ToStringError> {
let request = self.0.request("to_string").args(|out| {
<alias::Name as ::rustorb_core::idl::IdlType>::write(n, out)?;
Ok(())
});
let reply = request
.invoke()
.map_err(naming_context_ext::ToStringError::from_exception)?;
let mut input = reply.input();
let ret =
<naming_context_ext::alias::StringName as ::rustorb_core::idl::IdlType>::read(
&mut input,
)?;
Ok(ret)
}
#[allow(clippy::type_complexity)]
pub async fn to_string_async(
&self,
n: &[NameComponent],
) -> Result<naming_context_ext::StringName, naming_context_ext::ToStringError> {
let request = self.0.request_async("to_string").args(|out| {
<alias::Name as ::rustorb_core::idl::IdlType>::write(n, out)?;
Ok(())
});
let reply = request
.invoke()
.await
.map_err(naming_context_ext::ToStringError::from_exception)?;
let mut input = reply.input();
let ret =
<naming_context_ext::alias::StringName as ::rustorb_core::idl::IdlType>::read(
&mut input,
)?;
Ok(ret)
}
#[allow(clippy::type_complexity)]
pub fn to_name(&self, sn: &str) -> Result<Name, naming_context_ext::ToNameError> {
let request = self.0.request("to_name").args(|out| {
<naming_context_ext::alias::StringName as ::rustorb_core::idl::IdlType>::write(
sn, out,
)?;
Ok(())
});
let reply = request
.invoke()
.map_err(naming_context_ext::ToNameError::from_exception)?;
let mut input = reply.input();
let ret = <alias::Name as ::rustorb_core::idl::IdlType>::read(&mut input)?;
Ok(ret)
}
#[allow(clippy::type_complexity)]
pub async fn to_name_async(
&self,
sn: &str,
) -> Result<Name, naming_context_ext::ToNameError> {
let request = self.0.request_async("to_name").args(|out| {
<naming_context_ext::alias::StringName as ::rustorb_core::idl::IdlType>::write(
sn, out,
)?;
Ok(())
});
let reply = request
.invoke()
.await
.map_err(naming_context_ext::ToNameError::from_exception)?;
let mut input = reply.input();
let ret = <alias::Name as ::rustorb_core::idl::IdlType>::read(&mut input)?;
Ok(ret)
}
#[allow(clippy::type_complexity)]
pub fn to_url(
&self,
addr: &str,
sn: &str,
) -> Result<naming_context_ext::UrlString, naming_context_ext::ToUrlError> {
let request = self.0.request("to_url").args(|out| {
<naming_context_ext::alias::Address as ::rustorb_core::idl::IdlType>::write(
addr, out,
)?;
<naming_context_ext::alias::StringName as ::rustorb_core::idl::IdlType>::write(
sn, out,
)?;
Ok(())
});
let reply = request
.invoke()
.map_err(naming_context_ext::ToUrlError::from_exception)?;
let mut input = reply.input();
let ret = <naming_context_ext::alias::UrlString as ::rustorb_core::idl::IdlType>::read(
&mut input,
)?;
Ok(ret)
}
#[allow(clippy::type_complexity)]
pub async fn to_url_async(
&self,
addr: &str,
sn: &str,
) -> Result<naming_context_ext::UrlString, naming_context_ext::ToUrlError> {
let request = self.0.request_async("to_url").args(|out| {
<naming_context_ext::alias::Address as ::rustorb_core::idl::IdlType>::write(
addr, out,
)?;
<naming_context_ext::alias::StringName as ::rustorb_core::idl::IdlType>::write(
sn, out,
)?;
Ok(())
});
let reply = request
.invoke()
.await
.map_err(naming_context_ext::ToUrlError::from_exception)?;
let mut input = reply.input();
let ret = <naming_context_ext::alias::UrlString as ::rustorb_core::idl::IdlType>::read(
&mut input,
)?;
Ok(ret)
}
#[allow(clippy::type_complexity)]
pub fn resolve_str(
&self,
n: &str,
) -> Result<
::std::option::Option<::rustorb_core::ObjectRef>,
naming_context_ext::ResolveStrError,
> {
let request = self.0.request("resolve_str").args(|out| {
<naming_context_ext::alias::StringName as ::rustorb_core::idl::IdlType>::write(
n, out,
)?;
Ok(())
});
let reply = request
.invoke()
.map_err(naming_context_ext::ResolveStrError::from_exception)?;
let mut input = reply.input();
let ret =
<::rustorb_core::idl::Object as ::rustorb_core::idl::IdlType>::read(&mut input)?;
Ok(ret)
}
#[allow(clippy::type_complexity)]
pub async fn resolve_str_async(
&self,
n: &str,
) -> Result<
::std::option::Option<::rustorb_core::ObjectRef>,
naming_context_ext::ResolveStrError,
> {
let request = self.0.request_async("resolve_str").args(|out| {
<naming_context_ext::alias::StringName as ::rustorb_core::idl::IdlType>::write(
n, out,
)?;
Ok(())
});
let reply = request
.invoke()
.await
.map_err(naming_context_ext::ResolveStrError::from_exception)?;
let mut input = reply.input();
let ret =
<::rustorb_core::idl::Object as ::rustorb_core::idl::IdlType>::read(&mut input)?;
Ok(ret)
}
#[allow(clippy::type_complexity)]
pub fn bind(
&self,
n: &[NameComponent],
obj: Option<&::rustorb_core::ObjectRef>,
) -> Result<(), naming_context::BindError> {
let request = self.0.request("bind").args(|out| {
<alias::Name as ::rustorb_core::idl::IdlType>::write(n, out)?;
out.write_object(obj)?;
Ok(())
});
request
.invoke()
.map_err(naming_context::BindError::from_exception)?;
Ok(())
}
#[allow(clippy::type_complexity)]
pub async fn bind_async(
&self,
n: &[NameComponent],
obj: Option<&::rustorb_core::ObjectRef>,
) -> Result<(), naming_context::BindError> {
let request = self.0.request_async("bind").args(|out| {
<alias::Name as ::rustorb_core::idl::IdlType>::write(n, out)?;
out.write_object(obj)?;
Ok(())
});
request
.invoke()
.await
.map_err(naming_context::BindError::from_exception)?;
Ok(())
}
#[allow(clippy::type_complexity)]
pub fn rebind(
&self,
n: &[NameComponent],
obj: Option<&::rustorb_core::ObjectRef>,
) -> Result<(), naming_context::RebindError> {
let request = self.0.request("rebind").args(|out| {
<alias::Name as ::rustorb_core::idl::IdlType>::write(n, out)?;
out.write_object(obj)?;
Ok(())
});
request
.invoke()
.map_err(naming_context::RebindError::from_exception)?;
Ok(())
}
#[allow(clippy::type_complexity)]
pub async fn rebind_async(
&self,
n: &[NameComponent],
obj: Option<&::rustorb_core::ObjectRef>,
) -> Result<(), naming_context::RebindError> {
let request = self.0.request_async("rebind").args(|out| {
<alias::Name as ::rustorb_core::idl::IdlType>::write(n, out)?;
out.write_object(obj)?;
Ok(())
});
request
.invoke()
.await
.map_err(naming_context::RebindError::from_exception)?;
Ok(())
}
#[allow(clippy::type_complexity)]
pub fn bind_context(
&self,
n: &[NameComponent],
nc: Option<&NamingContext>,
) -> Result<(), naming_context::BindContextError> {
let request = self.0.request("bind_context").args(|out| {
<alias::Name as ::rustorb_core::idl::IdlType>::write(n, out)?;
NamingContext::_write(nc, out)?;
Ok(())
});
request
.invoke()
.map_err(naming_context::BindContextError::from_exception)?;
Ok(())
}
#[allow(clippy::type_complexity)]
pub async fn bind_context_async(
&self,
n: &[NameComponent],
nc: Option<&NamingContext>,
) -> Result<(), naming_context::BindContextError> {
let request = self.0.request_async("bind_context").args(|out| {
<alias::Name as ::rustorb_core::idl::IdlType>::write(n, out)?;
NamingContext::_write(nc, out)?;
Ok(())
});
request
.invoke()
.await
.map_err(naming_context::BindContextError::from_exception)?;
Ok(())
}
#[allow(clippy::type_complexity)]
pub fn rebind_context(
&self,
n: &[NameComponent],
nc: Option<&NamingContext>,
) -> Result<(), naming_context::RebindContextError> {
let request = self.0.request("rebind_context").args(|out| {
<alias::Name as ::rustorb_core::idl::IdlType>::write(n, out)?;
NamingContext::_write(nc, out)?;
Ok(())
});
request
.invoke()
.map_err(naming_context::RebindContextError::from_exception)?;
Ok(())
}
#[allow(clippy::type_complexity)]
pub async fn rebind_context_async(
&self,
n: &[NameComponent],
nc: Option<&NamingContext>,
) -> Result<(), naming_context::RebindContextError> {
let request = self.0.request_async("rebind_context").args(|out| {
<alias::Name as ::rustorb_core::idl::IdlType>::write(n, out)?;
NamingContext::_write(nc, out)?;
Ok(())
});
request
.invoke()
.await
.map_err(naming_context::RebindContextError::from_exception)?;
Ok(())
}
#[allow(clippy::type_complexity)]
pub fn resolve(
&self,
n: &[NameComponent],
) -> Result<::std::option::Option<::rustorb_core::ObjectRef>, naming_context::ResolveError>
{
let request = self.0.request("resolve").args(|out| {
<alias::Name as ::rustorb_core::idl::IdlType>::write(n, out)?;
Ok(())
});
let reply = request
.invoke()
.map_err(naming_context::ResolveError::from_exception)?;
let mut input = reply.input();
let ret =
<::rustorb_core::idl::Object as ::rustorb_core::idl::IdlType>::read(&mut input)?;
Ok(ret)
}
#[allow(clippy::type_complexity)]
pub async fn resolve_async(
&self,
n: &[NameComponent],
) -> Result<::std::option::Option<::rustorb_core::ObjectRef>, naming_context::ResolveError>
{
let request = self.0.request_async("resolve").args(|out| {
<alias::Name as ::rustorb_core::idl::IdlType>::write(n, out)?;
Ok(())
});
let reply = request
.invoke()
.await
.map_err(naming_context::ResolveError::from_exception)?;
let mut input = reply.input();
let ret =
<::rustorb_core::idl::Object as ::rustorb_core::idl::IdlType>::read(&mut input)?;
Ok(ret)
}
#[allow(clippy::type_complexity)]
pub fn unbind(&self, n: &[NameComponent]) -> Result<(), naming_context::UnbindError> {
let request = self.0.request("unbind").args(|out| {
<alias::Name as ::rustorb_core::idl::IdlType>::write(n, out)?;
Ok(())
});
request
.invoke()
.map_err(naming_context::UnbindError::from_exception)?;
Ok(())
}
#[allow(clippy::type_complexity)]
pub async fn unbind_async(
&self,
n: &[NameComponent],
) -> Result<(), naming_context::UnbindError> {
let request = self.0.request_async("unbind").args(|out| {
<alias::Name as ::rustorb_core::idl::IdlType>::write(n, out)?;
Ok(())
});
request
.invoke()
.await
.map_err(naming_context::UnbindError::from_exception)?;
Ok(())
}
#[allow(clippy::type_complexity)]
pub fn new_context(
&self,
) -> Result<::std::option::Option<NamingContext>, ::rustorb_core::SystemException> {
let request = self.0.request("new_context");
let reply = request
.invoke()
.map_err(::rustorb_core::idl::system_exception)?;
let mut input = reply.input();
let ret = <NamingContext as ::rustorb_core::idl::IdlType>::read(&mut input)?;
Ok(ret)
}
#[allow(clippy::type_complexity)]
pub async fn new_context_async(
&self,
) -> Result<::std::option::Option<NamingContext>, ::rustorb_core::SystemException> {
let request = self.0.request_async("new_context");
let reply = request
.invoke()
.await
.map_err(::rustorb_core::idl::system_exception)?;
let mut input = reply.input();
let ret = <NamingContext as ::rustorb_core::idl::IdlType>::read(&mut input)?;
Ok(ret)
}
#[allow(clippy::type_complexity)]
pub fn bind_new_context(
&self,
n: &[NameComponent],
) -> Result<::std::option::Option<NamingContext>, naming_context::BindNewContextError>
{
let request = self.0.request("bind_new_context").args(|out| {
<alias::Name as ::rustorb_core::idl::IdlType>::write(n, out)?;
Ok(())
});
let reply = request
.invoke()
.map_err(naming_context::BindNewContextError::from_exception)?;
let mut input = reply.input();
let ret = <NamingContext as ::rustorb_core::idl::IdlType>::read(&mut input)?;
Ok(ret)
}
#[allow(clippy::type_complexity)]
pub async fn bind_new_context_async(
&self,
n: &[NameComponent],
) -> Result<::std::option::Option<NamingContext>, naming_context::BindNewContextError>
{
let request = self.0.request_async("bind_new_context").args(|out| {
<alias::Name as ::rustorb_core::idl::IdlType>::write(n, out)?;
Ok(())
});
let reply = request
.invoke()
.await
.map_err(naming_context::BindNewContextError::from_exception)?;
let mut input = reply.input();
let ret = <NamingContext as ::rustorb_core::idl::IdlType>::read(&mut input)?;
Ok(ret)
}
#[allow(clippy::type_complexity)]
pub fn destroy(&self) -> Result<(), naming_context::DestroyError> {
let request = self.0.request("destroy");
request
.invoke()
.map_err(naming_context::DestroyError::from_exception)?;
Ok(())
}
#[allow(clippy::type_complexity)]
pub async fn destroy_async(&self) -> Result<(), naming_context::DestroyError> {
let request = self.0.request_async("destroy");
request
.invoke()
.await
.map_err(naming_context::DestroyError::from_exception)?;
Ok(())
}
#[allow(clippy::type_complexity)]
pub fn list(
&self,
how_many: u32,
) -> Result<
(BindingList, ::std::option::Option<BindingIterator>),
::rustorb_core::SystemException,
> {
let request = self.0.request("list").args(|out| {
<::rustorb_core::idl::ULong as ::rustorb_core::idl::IdlType>::write(
&how_many, out,
)?;
Ok(())
});
let reply = request
.invoke()
.map_err(::rustorb_core::idl::system_exception)?;
let mut input = reply.input();
let bl = <alias::BindingList as ::rustorb_core::idl::IdlType>::read(&mut input)?;
let bi = <BindingIterator as ::rustorb_core::idl::IdlType>::read(&mut input)?;
Ok((bl, bi))
}
#[allow(clippy::type_complexity)]
pub async fn list_async(
&self,
how_many: u32,
) -> Result<
(BindingList, ::std::option::Option<BindingIterator>),
::rustorb_core::SystemException,
> {
let request = self.0.request_async("list").args(|out| {
<::rustorb_core::idl::ULong as ::rustorb_core::idl::IdlType>::write(
&how_many, out,
)?;
Ok(())
});
let reply = request
.invoke()
.await
.map_err(::rustorb_core::idl::system_exception)?;
let mut input = reply.input();
let bl = <alias::BindingList as ::rustorb_core::idl::IdlType>::read(&mut input)?;
let bi = <BindingIterator as ::rustorb_core::idl::IdlType>::read(&mut input)?;
Ok((bl, bi))
}
}
impl ::rustorb_core::idl::IdlType for NamingContextExt {
type Rust = Option<NamingContextExt>;
type Borrowed = Option<NamingContextExt>;
const MIN_SIZE: usize = 4;
fn type_code() -> ::rustorb_core::TypeCode {
static TC: ::std::sync::OnceLock<::rustorb_core::TypeCode> =
::std::sync::OnceLock::new();
TC.get_or_init(|| {
::rustorb_core::idl::tc(::rustorb_core::TypeCode::objref(
"IDL:omg.org/CosNaming/NamingContextExt:1.0",
"NamingContextExt",
))
})
.clone()
}
fn write(
v: &Option<NamingContextExt>,
out: &mut ::rustorb_core::OutStream<'_>,
) -> ::rustorb_core::idl::Sys<()> {
Self::_write(v.as_ref(), out)
}
fn read(
input: &mut ::rustorb_core::InStream<'_>,
) -> ::rustorb_core::idl::Sys<Option<NamingContextExt>> {
Ok(input.read_object()?.map(NamingContextExt))
}
}
pub trait NamingContextExtServant: Send + Sync + NamingContextServant {
#[allow(clippy::type_complexity)]
fn to_string(
&self,
n: &[NameComponent],
) -> Result<naming_context_ext::StringName, naming_context_ext::ToStringError>;
#[allow(clippy::type_complexity)]
fn to_name(&self, sn: &str) -> Result<Name, naming_context_ext::ToNameError>;
#[allow(clippy::type_complexity)]
fn to_url(
&self,
addr: &str,
sn: &str,
) -> Result<naming_context_ext::UrlString, naming_context_ext::ToUrlError>;
#[allow(clippy::type_complexity)]
fn resolve_str(
&self,
n: &str,
) -> Result<
::std::option::Option<::rustorb_core::ObjectRef>,
naming_context_ext::ResolveStrError,
>;
}
pub struct NamingContextExtPoa<T>(pub T);
impl<T> ::std::fmt::Debug for NamingContextExtPoa<T> {
fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
f.write_str("NamingContextExtPoa")
}
}
impl<T: NamingContextExtServant + 'static> NamingContextExtPoa<T> {
pub fn activate(
self,
poa: &::rustorb_core::Poa,
) -> Result<(::rustorb_core::ObjectId, NamingContextExt), ::rustorb_core::PoaError>
{
let servant: ::std::sync::Arc<dyn ::rustorb_core::Servant> =
::std::sync::Arc::new(self);
let id = poa.activate_object(servant)?;
let obj = poa.id_to_reference(&id)?;
Ok((id, NamingContextExt(obj)))
}
pub fn activate_with_id(
self,
poa: &::rustorb_core::Poa,
id: &[u8],
) -> Result<NamingContextExt, ::rustorb_core::PoaError> {
let servant: ::std::sync::Arc<dyn ::rustorb_core::Servant> =
::std::sync::Arc::new(self);
poa.activate_object_with_id(id, servant)?;
Ok(NamingContextExt(poa.id_to_reference(id)?))
}
}
impl<T: NamingContextExtServant> ::rustorb_core::Servant for NamingContextExtPoa<T> {
fn repository_id(&self) -> &str {
NamingContextExt::REPOSITORY_ID
}
fn is_a(&self, repository_id: &str) -> bool {
matches!(
repository_id,
"IDL:omg.org/CosNaming/NamingContextExt:1.0"
| "IDL:omg.org/CosNaming/NamingContext:1.0"
)
}
#[allow(unused_variables)]
fn dispatch(
&self,
operation: &str,
input: &mut ::rustorb_core::InStream<'_>,
reply: &mut ::rustorb_core::ServerReply,
) -> Result<(), ::rustorb_core::SystemException> {
match operation {
"to_string" => {
let n = <alias::Name as ::rustorb_core::idl::IdlType>::read(input)?;
let ret = match self.0.to_string(&n) {
Ok(r) => r,
Err(e) => return e._write_reply(reply),
};
let mut out = reply.output();
<naming_context_ext::alias::StringName as ::rustorb_core::idl::IdlType>::write(
&ret, &mut out,
)?;
Ok(())
}
"to_name" => {
let sn = <naming_context_ext::alias::StringName as ::rustorb_core::idl::IdlType>::read(input)?;
let ret = match self.0.to_name(&sn) {
Ok(r) => r,
Err(e) => return e._write_reply(reply),
};
let mut out = reply.output();
<alias::Name as ::rustorb_core::idl::IdlType>::write(&ret, &mut out)?;
Ok(())
}
"to_url" => {
let addr =
<naming_context_ext::alias::Address as ::rustorb_core::idl::IdlType>::read(
input,
)?;
let sn = <naming_context_ext::alias::StringName as ::rustorb_core::idl::IdlType>::read(input)?;
let ret = match self.0.to_url(&addr, &sn) {
Ok(r) => r,
Err(e) => return e._write_reply(reply),
};
let mut out = reply.output();
<naming_context_ext::alias::UrlString as ::rustorb_core::idl::IdlType>::write(
&ret, &mut out,
)?;
Ok(())
}
"resolve_str" => {
let n = <naming_context_ext::alias::StringName as ::rustorb_core::idl::IdlType>::read(input)?;
let ret = match self.0.resolve_str(&n) {
Ok(r) => r,
Err(e) => return e._write_reply(reply),
};
let mut out = reply.output();
<::rustorb_core::idl::Object as ::rustorb_core::idl::IdlType>::write(
&ret, &mut out,
)?;
Ok(())
}
"bind" => {
let n = <alias::Name as ::rustorb_core::idl::IdlType>::read(input)?;
let obj =
<::rustorb_core::idl::Object as ::rustorb_core::idl::IdlType>::read(input)?;
let () = match self.0.bind(&n, obj.as_ref()) {
Ok(r) => r,
Err(e) => return e._write_reply(reply),
};
Ok(())
}
"rebind" => {
let n = <alias::Name as ::rustorb_core::idl::IdlType>::read(input)?;
let obj =
<::rustorb_core::idl::Object as ::rustorb_core::idl::IdlType>::read(input)?;
let () = match self.0.rebind(&n, obj.as_ref()) {
Ok(r) => r,
Err(e) => return e._write_reply(reply),
};
Ok(())
}
"bind_context" => {
let n = <alias::Name as ::rustorb_core::idl::IdlType>::read(input)?;
let nc = <NamingContext as ::rustorb_core::idl::IdlType>::read(input)?;
let () = match self.0.bind_context(&n, nc.as_ref()) {
Ok(r) => r,
Err(e) => return e._write_reply(reply),
};
Ok(())
}
"rebind_context" => {
let n = <alias::Name as ::rustorb_core::idl::IdlType>::read(input)?;
let nc = <NamingContext as ::rustorb_core::idl::IdlType>::read(input)?;
let () = match self.0.rebind_context(&n, nc.as_ref()) {
Ok(r) => r,
Err(e) => return e._write_reply(reply),
};
Ok(())
}
"resolve" => {
let n = <alias::Name as ::rustorb_core::idl::IdlType>::read(input)?;
let ret = match self.0.resolve(&n) {
Ok(r) => r,
Err(e) => return e._write_reply(reply),
};
let mut out = reply.output();
<::rustorb_core::idl::Object as ::rustorb_core::idl::IdlType>::write(
&ret, &mut out,
)?;
Ok(())
}
"unbind" => {
let n = <alias::Name as ::rustorb_core::idl::IdlType>::read(input)?;
let () = match self.0.unbind(&n) {
Ok(r) => r,
Err(e) => return e._write_reply(reply),
};
Ok(())
}
"new_context" => {
let ret = self.0.new_context()?;
let mut out = reply.output();
<NamingContext as ::rustorb_core::idl::IdlType>::write(&ret, &mut out)?;
Ok(())
}
"bind_new_context" => {
let n = <alias::Name as ::rustorb_core::idl::IdlType>::read(input)?;
let ret = match self.0.bind_new_context(&n) {
Ok(r) => r,
Err(e) => return e._write_reply(reply),
};
let mut out = reply.output();
<NamingContext as ::rustorb_core::idl::IdlType>::write(&ret, &mut out)?;
Ok(())
}
"destroy" => {
let () = match self.0.destroy() {
Ok(r) => r,
Err(e) => return e._write_reply(reply),
};
Ok(())
}
"list" => {
let how_many =
<::rustorb_core::idl::ULong as ::rustorb_core::idl::IdlType>::read(input)?;
let (bl, bi) = self.0.list(how_many)?;
let mut out = reply.output();
<alias::BindingList as ::rustorb_core::idl::IdlType>::write(&bl, &mut out)?;
<BindingIterator as ::rustorb_core::idl::IdlType>::write(&bi, &mut out)?;
Ok(())
}
_ => Err(::rustorb_core::idl::unknown_operation()),
}
}
}
pub mod alias {
#[derive(Debug)]
pub struct Istring;
impl ::rustorb_core::idl::IdlType for Istring {
type Rust = <::rustorb_core::idl::String as ::rustorb_core::idl::IdlType>::Rust;
type Borrowed = <::rustorb_core::idl::String as ::rustorb_core::idl::IdlType>::Borrowed;
const MIN_SIZE: usize =
<::rustorb_core::idl::String as ::rustorb_core::idl::IdlType>::MIN_SIZE;
fn type_code() -> ::rustorb_core::TypeCode {
static TC: ::std::sync::OnceLock<::rustorb_core::TypeCode> =
::std::sync::OnceLock::new();
TC.get_or_init(|| {
::rustorb_core::idl::tc(::rustorb_core::TypeCode::alias(
"IDL:omg.org/CosNaming/Istring:1.0",
"Istring",
&<::rustorb_core::idl::String as ::rustorb_core::idl::IdlType>::type_code(),
))
})
.clone()
}
fn write(
v: &Self::Borrowed,
out: &mut ::rustorb_core::OutStream<'_>,
) -> ::rustorb_core::idl::Sys<()> {
<::rustorb_core::idl::String as ::rustorb_core::idl::IdlType>::write(v, out)
}
fn read(
input: &mut ::rustorb_core::InStream<'_>,
) -> ::rustorb_core::idl::Sys<Self::Rust> {
<::rustorb_core::idl::String as ::rustorb_core::idl::IdlType>::read(input)
}
}
#[derive(Debug)]
pub struct Name;
impl ::rustorb_core::idl::IdlType for Name {
type Rust = <::rustorb_core::idl::Sequence<super::NameComponent> as ::rustorb_core::idl::IdlType>::Rust;
type Borrowed = <::rustorb_core::idl::Sequence<super::NameComponent> as ::rustorb_core::idl::IdlType>::Borrowed;
const MIN_SIZE: usize = <::rustorb_core::idl::Sequence<super::NameComponent> as ::rustorb_core::idl::IdlType>::MIN_SIZE;
fn type_code() -> ::rustorb_core::TypeCode {
static TC: ::std::sync::OnceLock<::rustorb_core::TypeCode> =
::std::sync::OnceLock::new();
TC.get_or_init(|| {
::rustorb_core::idl::tc(::rustorb_core::TypeCode::alias(
"IDL:omg.org/CosNaming/Name:1.0",
"Name",
&::rustorb_core::idl::tc(::rustorb_core::TypeCode::sequence(
&<super::NameComponent as ::rustorb_core::idl::IdlType>::type_code(),
0,
)),
))
})
.clone()
}
fn write(
v: &Self::Borrowed,
out: &mut ::rustorb_core::OutStream<'_>,
) -> ::rustorb_core::idl::Sys<()> {
<::rustorb_core::idl::Sequence<super::NameComponent> as ::rustorb_core::idl::IdlType>::write(v, out)
}
fn read(
input: &mut ::rustorb_core::InStream<'_>,
) -> ::rustorb_core::idl::Sys<Self::Rust> {
<::rustorb_core::idl::Sequence<super::NameComponent> as ::rustorb_core::idl::IdlType>::read(input)
}
}
#[derive(Debug)]
pub struct BindingList;
impl ::rustorb_core::idl::IdlType for BindingList {
type Rust = <::rustorb_core::idl::Sequence<super::Binding> as ::rustorb_core::idl::IdlType>::Rust;
type Borrowed = <::rustorb_core::idl::Sequence<super::Binding> as ::rustorb_core::idl::IdlType>::Borrowed;
const MIN_SIZE: usize = <::rustorb_core::idl::Sequence<super::Binding> as ::rustorb_core::idl::IdlType>::MIN_SIZE;
fn type_code() -> ::rustorb_core::TypeCode {
static TC: ::std::sync::OnceLock<::rustorb_core::TypeCode> =
::std::sync::OnceLock::new();
TC.get_or_init(|| {
::rustorb_core::idl::tc(::rustorb_core::TypeCode::alias(
"IDL:omg.org/CosNaming/BindingList:1.0",
"BindingList",
&::rustorb_core::idl::tc(::rustorb_core::TypeCode::sequence(
&<super::Binding as ::rustorb_core::idl::IdlType>::type_code(),
0,
)),
))
})
.clone()
}
fn write(
v: &Self::Borrowed,
out: &mut ::rustorb_core::OutStream<'_>,
) -> ::rustorb_core::idl::Sys<()> {
<::rustorb_core::idl::Sequence<super::Binding> as ::rustorb_core::idl::IdlType>::write(v, out)
}
fn read(
input: &mut ::rustorb_core::InStream<'_>,
) -> ::rustorb_core::idl::Sys<Self::Rust> {
<::rustorb_core::idl::Sequence<super::Binding> as ::rustorb_core::idl::IdlType>::read(input)
}
}
}
}