Struct TypeSpec

pub struct TypeSpec<F: Form = MetaForm> { /* private fields */ }

A type specification.

This contains the actual type as well as an optional compile-time known displayed representation of the type. This is useful for cases where the type is used through a type alias in order to provide information about the alias name.

Examples

Consider the following Rust function:

fn is_sorted(input: &[i32], pred: Predicate) -> bool;

In this above example input would have no displayable name, preds display name is Predicate and the display name of the return type is simply bool. Note that Predicate could simply be a type alias to fn(i32, i32) -> Ordering.

Implementations

impl TypeSpec

pub fn with_name_str<T>(display_name: &'static str) -> Self

where T: TypeInfo + 'static,

Creates a new type specification with a display name.

The name is any valid Rust identifier or path.

Examples

Valid display names are foo, foo::bar, foo::bar::Baz, etc.

Panics

Panics if the given display name is invalid.

pub fn with_name_segs<T, S>(segments: S) -> Self

where T: TypeInfo + 'static, S: IntoIterator<Item = &'static str>,

Creates a new type specification with a display name represented by the given path segments.

The display name segments all must be valid Rust identifiers.

Examples

Valid display names are foo, foo::bar, foo::bar::Baz, etc.

Panics

Panics if the given display name is invalid.

pub fn of_type<T>() -> Self

where T: TypeInfo + 'static,

Creates a new type specification without a display name.

Example:

ReturnTypeSpec::new(TypeSpec::of_type::<i32>()); // return type of `i32`

impl<F> TypeSpec<F>

where F: Form,

pub fn ty(&self) -> &F::Type

Returns the actual type.

pub fn display_name(&self) -> &DisplayName<F>

Returns the compile-time known displayed representation of the type.

pub fn new(ty: <F as Form>::Type, display_name: DisplayName<F>) -> Self

Creates a new type specification for a given type and display name.

Trait Implementations

impl<F: Debug + Form> Debug for TypeSpec<F>

where F::Type: Debug,

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

Formats the value using the given formatter.

impl Default for TypeSpec<MetaForm>

fn default() -> Self

Returns the “default value” for a type.

impl Default for TypeSpec<PortableForm>

fn default() -> Self

Returns the “default value” for a type.

impl<'de, F: Form> Deserialize<'de> for TypeSpec<F>

where F::Type: DeserializeOwned, F::String: DeserializeOwned,

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl IntoPortable for TypeSpec

type Output = TypeSpec<PortableForm>

The portable version of Self.

fn into_portable(self, registry: &mut Registry) -> Self::Output

Convert self to the portable form by using the registry for caching.

impl<F: Form + JsonSchema> JsonSchema for TypeSpec<F>

fn schema_name() -> String

The name of the generated JSON Schema.

fn schema_id() -> Cow<'static, str>

Returns a string that uniquely identifies the schema produced by this type.

fn json_schema(generator: &mut SchemaGenerator) -> Schema

Generates a JSON Schema for this type.

fn is_referenceable() -> bool

Whether JSON Schemas generated for this type should be re-used where possible using the $ref keyword.

impl<F: PartialEq + Form> PartialEq for TypeSpec<F>

where F::Type: PartialEq,

fn eq(&self, other: &TypeSpec<F>) -> 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.

impl<F: Form> Serialize for TypeSpec<F>

where F::Type: Serialize, F::String: Serialize,

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl<F: Eq + Form> Eq for TypeSpec<F>

where F::Type: Eq,

impl<F: Form> StructuralPartialEq for TypeSpec<F>