Struct ComMethodInfo

pub struct ComMethodInfo {
    pub name: Ident,
    pub is_const: bool,
    pub rust_self_arg: Receiver,
    pub rust_return_ty: Type,
    pub retval_type: Option<Type>,
    pub return_type: Option<Type>,
    pub signature_span: Span,
    pub returnhandler: Rc<dyn ReturnHandler>,
    pub args: Vec<RustArg>,
    pub is_unsafe: bool,
    pub type_system: ModelTypeSystem,
    pub infallible: bool,
}

Fields

name: Ident

The display name used in public places that do not require an unique name.

is_const: bool

True if the self parameter is not mutable.

rust_self_arg: Receiver

Rust self argument.

rust_return_ty: Type

Rust return type.

retval_type: Option<Type>

COM retval out parameter type, such as the value of Result<…>.

return_type: Option<Type>

COM return type, such as the error value of Result<…>.

signature_span: Span

Span for the method signature.

returnhandler: Rc<dyn ReturnHandler>

Return value handler.

args: Vec<RustArg>

Method arguments.

is_unsafe: bool

True if the Rust method is unsafe.

type_system: ModelTypeSystem

Type system.

infallible: bool

Is the method infallible.

Implementations

impl ComMethodInfo

pub fn new( decl: &Signature, type_system: ModelTypeSystem, ) -> Result<ComMethodInfo, ComMethodInfoError>

Constructs new COM method info from a Rust method signature.

pub fn raw_com_args(&self) -> Vec<ComArg>

pub fn get_parameters_tokenstream(&self) -> TokenStream

Trait Implementations

impl Clone for ComMethodInfo

fn clone(&self) -> ComMethodInfo

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for ComMethodInfo

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl PartialEq for ComMethodInfo

fn eq(&self, other: &ComMethodInfo) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.