Struct ConstParamInfo

pub struct ConstParamInfo { /* private fields */ }

Type information for a const generic parameter.

An example of a const parameter would be N in struct Foo<const N: usize>.

Implementations

impl ConstParamInfo

pub fn new<T: TypePath + ?Sized>(name: impl Into<Cow<'static, str>>) -> Self

Creates a new const parameter with the given name.

pub fn with_default<T: Reflect + 'static>(self, default: T) -> Self

Sets the default value for the parameter.

pub fn name(&self) -> &Cow<'static, str>

The name of the const parameter.

pub fn default(&self) -> Option<&dyn Reflect>

The default value for the parameter, if any.

Example

#[derive(Reflect)]
struct Foo<const N: usize = 10>([u8; N]);

let generics = Foo::<5>::type_info().generics();
let GenericInfo::Const(info) = generics.get_named("N").unwrap() else {
   panic!("expected a const parameter");
};

let default = info.default().unwrap();

assert_eq!(default.downcast_ref::<usize>().unwrap(), &10);

pub fn ty(&self) -> &Type

The underlying Rust type.

pub fn type_id(&self) -> TypeId

The TypeId of this type.

pub fn type_path(&self) -> &'static str

The stable, full type path of this type.

Use type_path_table if you need access to the other methods on TypePath.

pub fn type_path_table(&self) -> &TypePathTable

A representation of the type path of this type.

Provides dynamic access to all methods on TypePath.

pub fn is<T: Any>(&self) -> bool

Check if the given type matches this one.

This only compares the TypeId of the types and does not verify they share the same TypePath (though it implies they do).

Trait Implementations

impl Clone for ConstParamInfo

fn clone(&self) -> ConstParamInfo

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for ConstParamInfo

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

Formats the value using the given formatter.

impl From<ConstParamInfo> for GenericInfo

fn from(value: ConstParamInfo) -> Self

Converts to this type from the input type.