Enum Item 

pub enum Item<'de> {
    Fn(ItemFn<'de>),
    Struct(ItemStruct<'de>),
    Class(ItemClass<'de>),
    Enum(ItemEnum<'de>),
    Union(ItemUnion<'de>),
    Namespace(ItemNamespace<'de>),
    Use(ItemUse<'de>),
    Type(ItemType<'de>),
    Typedef(ItemTypedef<'de>),
    Const(ItemConst<'de>),
    Static(ItemStatic<'de>),
    ForeignMod(ItemForeignMod<'de>),
    Template(ItemTemplate<'de>),
    StaticAssert(ItemStaticAssert<'de>),
    Include(ItemInclude<'de>),
    Macro(ItemMacro<'de>),
    Verbatim(ItemVerbatim<'de>),
}

A top-level item (declaration) in a C++ translation unit.

Analogous to syn::Item. Each variant corresponds to a kind of declaration that can appear at file scope or namespace scope.

Variants

Fn(ItemFn<'de>)

Function declaration or definition: int foo() { ... }

Struct(ItemStruct<'de>)

Struct definition: struct Foo { ... };

Class(ItemClass<'de>)

Class definition: class Foo { ... };

Enum(ItemEnum<'de>)

Enum definition: enum Color { Red, Green, Blue };

Union(ItemUnion<'de>)

Union definition: union Data { int i; float f; };

Namespace(ItemNamespace<'de>)

Namespace: namespace foo { ... }

Use(ItemUse<'de>)

Using declaration/directive/alias: using std::cout;

Type(ItemType<'de>)

Type alias: using size_t = unsigned long;

Typedef(ItemTypedef<'de>)

Typedef: typedef unsigned long size_t;

Const(ItemConst<'de>)

Const/constexpr variable: constexpr int MAX = 100;

Static(ItemStatic<'de>)

Static variable: static int count;

ForeignMod(ItemForeignMod<'de>)

Extern block: extern "C" { ... }

Template(ItemTemplate<'de>)

Template declaration: template<typename T> ...

StaticAssert(ItemStaticAssert<'de>)

Static assertion: static_assert(sizeof(int) == 4);

Include(ItemInclude<'de>)

Include directive: #include <iostream> or #include "myfile.h"

Macro(ItemMacro<'de>)

Preprocessor directive: #include <iostream>

Verbatim(ItemVerbatim<'de>)

Tokens not interpreted by the parser

Trait Implementations

impl<'de> Clone for Item<'de>

fn clone(&self) -> Item<'de>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<'de> Debug for Item<'de>

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

Formats the value using the given formatter.

impl<'de> PartialEq for Item<'de>

fn eq(&self, other: &Item<'de>) -> 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<'de> StructuralPartialEq for Item<'de>