Enum glsl::syntax::SimpleStatement

pub enum SimpleStatement {
    Declaration(Declaration),
    Expression(ExprStatement),
    Selection(SelectionStatement),
    Switch(SwitchStatement),
    CaseLabel(CaseLabel),
    Iteration(IterationStatement),
    Jump(JumpStatement),
}

Simple statement.

Variants

Declaration(Declaration)

Expression(ExprStatement)

Selection(SelectionStatement)

Switch(SwitchStatement)

CaseLabel(CaseLabel)

Iteration(IterationStatement)

Jump(JumpStatement)

Implementations

impl SimpleStatement

pub fn new_expr<E>(expr: E) -> Self

where E: Into<Expr>,

Create a new expression statement.

pub fn new_if_else<If, True, False>(ife: If, truee: True, falsee: False) -> Self

where If: Into<Expr>, True: Into<Statement>, False: Into<Statement>,

Create a new selection statement (if / else).

pub fn new_switch<H, B>(head: H, body: B) -> Self

where H: Into<Expr>, B: IntoIterator<Item = Statement>,

Create a new switch statement.

A switch statement is always composed of a SimpleStatement::Switch block, that contains it all, and has as body a compound list of case statements.

pub fn new_while<C, S>(cond: C, body: S) -> Self

where C: Into<Condition>, S: Into<Statement>,

Create a new while statement.

pub fn new_do_while<C, S>(body: S, cond: C) -> Self

where S: Into<Statement>, C: Into<Expr>,

Create a new do-while statement.

Trait Implementations

impl Clone for SimpleStatement

fn clone(&self) -> SimpleStatement

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for SimpleStatement

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

Formats the value using the given formatter.

impl Host for SimpleStatement

fn visit<V>(&self, visitor: &mut V)

where V: Visitor,

Visit an AST node.

impl HostMut for SimpleStatement

fn visit_mut<V>(&mut self, visitor: &mut V)

where V: VisitorMut,

Visit an AST node.

impl Parse for SimpleStatement

fn parse<B>(source: B) -> Result<Self, ParseError>

where B: AsRef<str>,

Parse from a string slice.

impl PartialEq for SimpleStatement

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