Enum rustdoc::clean::cfg::Cfg

pub(crate) enum Cfg {
    True,
    False,
    Cfg(Symbol, Option<Symbol>),
    Not(Box<Cfg>),
    Any(Vec<Cfg>),
    All(Vec<Cfg>),
}

Variants

True

Accepts all configurations.

False

Denies all configurations.

Cfg(Symbol, Option<Symbol>)

A generic configuration option, e.g., test or target_os = "linux".

Not(Box<Cfg>)

Negates a configuration requirement, i.e., not(x).

Any(Vec<Cfg>)

Union of a list of configuration requirements, i.e., any(...).

All(Vec<Cfg>)

Intersection of a list of configuration requirements, i.e., all(...).

Implementations

impl Cfg

fn parse_nested( nested_cfg: &NestedMetaItem, exclude: &FxHashSet<Cfg> ) -> Result<Option<Cfg>, InvalidCfgError>

Parses a NestedMetaItem into a Cfg.

pub(crate) fn parse_without( cfg: &MetaItem, exclude: &FxHashSet<Cfg> ) -> Result<Option<Cfg>, InvalidCfgError>

pub(crate) fn parse(cfg: &MetaItem) -> Result<Cfg, InvalidCfgError>

Parses a MetaItem into a Cfg.

The MetaItem should be the content of the #[cfg(...)], e.g., unix or target_os = "redox".

If the content is not properly formatted, it will return an error indicating what and where the error is.

pub(crate) fn matches( &self, parse_sess: &ParseSess, features: Option<&Features> ) -> bool

Checks whether the given configuration can be matched in the current session.

Equivalent to attr::cfg_matches.

fn is_simple(&self) -> bool

Whether the configuration consists of just Cfg or Not.

fn is_all(&self) -> bool

Whether the configuration consists of just Cfg, Not or All.

pub(crate) fn render_short_html(&self) -> String

Renders the configuration for human display, as a short HTML description.

pub(crate) fn render_long_html(&self) -> String

Renders the configuration for long display, as a long HTML description.

pub(crate) fn render_long_plain(&self) -> String

Renders the configuration for long display, as a long plain text description.

fn should_capitalize_first_letter(&self) -> bool

fn should_append_only_to_description(&self) -> bool

fn should_use_with_in_description(&self) -> bool

pub(crate) fn simplify_with(&self, assume: &Cfg) -> Option<Cfg>

Attempt to simplify this cfg by assuming that assume is already known to be true, will return None if simplification managed to completely eliminate any requirements from this Cfg.

See tests::test_simplify_with for examples.

Trait Implementations

impl BitAnd<Cfg> for Cfg

type Output = Cfg

The resulting type after applying the & operator.

fn bitand(self, other: Cfg) -> Cfg

Performs the & operation.

impl BitAndAssign<Cfg> for Cfg

fn bitand_assign(&mut self, other: Cfg)

Performs the &= operation.

impl BitOr<Cfg> for Cfg

type Output = Cfg

The resulting type after applying the | operator.

fn bitor(self, other: Cfg) -> Cfg

Performs the | operation.

impl BitOrAssign<Cfg> for Cfg

fn bitor_assign(&mut self, other: Cfg)

Performs the |= operation.

impl Clone for Cfg

fn clone(&self) -> Cfg

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for Cfg

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

Formats the value using the given formatter.

impl Hash for Cfg

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl Not for Cfg

type Output = Cfg

The resulting type after applying the ! operator.

fn not(self) -> Cfg

Performs the unary ! operation.

impl PartialEq<Cfg> for Cfg

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

This method tests for self and other values to be equal, and is used by ==.

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

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

impl Eq for Cfg

impl StructuralEq for Cfg

impl StructuralPartialEq for Cfg

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: 32 bytes

Size for each variant:

• True: 0 bytes
• False: 0 bytes
• Cfg: 8 bytes
• Not: 12 bytes
• Any: 28 bytes
• All: 28 bytes