Enum rustdoc_json_types::ItemEnum
source · pub enum ItemEnum {
Show 21 variants
Module(Module),
ExternCrate {
name: String,
rename: Option<String>,
},
Import(Import),
Union(Union),
Struct(Struct),
StructField(Type),
Enum(Enum),
Variant(Variant),
Function(Function),
Trait(Trait),
TraitAlias(TraitAlias),
Impl(Impl),
TypeAlias(TypeAlias),
Constant {
type_: Type,
const_: Constant,
},
Static(Static),
ForeignType,
Macro(String),
ProcMacro(ProcMacro),
Primitive(Primitive),
AssocConst {
type_: Type,
default: Option<String>,
},
AssocType {
generics: Generics,
bounds: Vec<GenericBound>,
default: Option<Type>,
},
}
Expand description
Specific fields of an item.
Part of Item
.
Variants§
Module(Module)
A module declaration, e.g. mod foo;
or mod foo {}
ExternCrate
A crate imported via the extern crate
syntax.
Fields
Import(Import)
An import of 1 or more items into scope, using the use
keyword.
Union(Union)
A union
declaration.
Struct(Struct)
A struct
declaration.
StructField(Type)
A field of a struct.
Enum(Enum)
An enum
declaration.
Variant(Variant)
A variant of a enum.
Function(Function)
A function declaration (including methods and other associated functions)
Trait(Trait)
A trait
declaration.
TraitAlias(TraitAlias)
A trait alias declaration, e.g. trait Int = Add + Sub + Mul + Div;
Impl(Impl)
An impl
block.
TypeAlias(TypeAlias)
A type alias declaration, e.g. type Pig = std::borrow::Cow<'static, str>;
Constant
The declaration of a constant, e.g. const GREETING: &str = "Hi :3";
Static(Static)
A declaration of a static
.
ForeignType
type
s from an extern
block.
Macro(String)
A macro_rules! declarative macro. Contains a single string with the source representation of the macro with the patterns stripped.
ProcMacro(ProcMacro)
A procedural macro.
Primitive(Primitive)
A primitive type, e.g. u32
.
Item
s of this kind only come from the core library.
AssocConst
An associated constant of a trait or a type.
Fields
AssocType
An associated type of a trait or a type.
Fields
bounds: Vec<GenericBound>
The bounds for this associated type. e.g.
trait IntoIterator {
type Item;
type IntoIter: Iterator<Item = Self::Item>;
// ^^^^^^^^^^^^^^^^^^^^^^^^^^^
}
Trait Implementations§
source§impl<'de> Deserialize<'de> for ItemEnum
impl<'de> Deserialize<'de> for ItemEnum
source§fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>where
__D: Deserializer<'de>,
fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>where
__D: Deserializer<'de>,
impl Eq for ItemEnum
impl StructuralPartialEq for ItemEnum
Auto Trait Implementations§
impl Freeze for ItemEnum
impl RefUnwindSafe for ItemEnum
impl Send for ItemEnum
impl Sync for ItemEnum
impl Unpin for ItemEnum
impl UnwindSafe for ItemEnum
Blanket Implementations§
source§impl<T> BorrowMut<T> for Twhere
T: ?Sized,
impl<T> BorrowMut<T> for Twhere
T: ?Sized,
source§fn borrow_mut(&mut self) -> &mut T
fn borrow_mut(&mut self) -> &mut T
source§impl<T> CloneToUninit for Twhere
T: Clone,
impl<T> CloneToUninit for Twhere
T: Clone,
source§unsafe fn clone_to_uninit(&self, dst: *mut T)
unsafe fn clone_to_uninit(&self, dst: *mut T)
clone_to_uninit
)impl<T> DeserializeOwned for Twhere
T: for<'de> Deserialize<'de>,
Layout§
Note: Most layout information is completely unstable and may even differ between compilations. The only exception is types with certain repr(...)
attributes. Please see the Rust Reference's “Type Layout” chapter for details on type layout guarantees.
Size: 352 bytes
Size for each variant:
Module
: 40 bytesExternCrate
: 56 bytesImport
: 88 bytesUnion
: 112 bytesStruct
: 112 bytesStructField
: 104 bytesEnum
: 112 bytesVariant
: 88 bytesFunction
: 224 bytesTrait
: 136 bytesTraitAlias
: 80 bytesImpl
: 352 bytesTypeAlias
: 152 bytesConstant
: 160 bytesStatic
: 136 bytesForeignType
: 0 bytesMacro
: 32 bytesProcMacro
: 40 bytesPrimitive
: 56 bytesAssocConst
: 128 bytesAssocType
: 176 bytes