Struct Block 

pub struct Block {
    pub identifier: Identifier,
    pub labels: Vec<BlockLabel>,
    pub body: Body,
}

Represents an HCL block which consists of a block identifier, zero or more block labels and a block body.

In HCL syntax this is represented as:

block_identifier "block_label1" "block_label2" {
  body
}

Fields

identifier: Identifier

The block identifier.

labels: Vec<BlockLabel>

Zero or more block labels.

body: Body

Represents the Block’s body.

Implementations

impl Block

pub fn new<I>(ident: I) -> Block

where I: Into<Identifier>,

Creates a new empty Block.

pub fn builder<I>(identifier: I) -> BlockBuilder

where I: Into<Identifier>,

Creates a new BlockBuilder to start building a new Block with the provided identifier.

pub fn identifier(&self) -> &str

Returns a reference to the block’s identifier.

pub fn labels(&self) -> &[BlockLabel]

Returns a reference to the block’s labels.

pub fn body(&self) -> &Body

Returns a reference to the block’s body.

Trait Implementations

impl Clone for Block

fn clone(&self) -> Block

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Block

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for Block

fn deserialize<__D>( __deserializer: __D, ) -> Result<Block, <__D as Deserializer<'de>>::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Eq for Block

impl Evaluate for Block

type Output = Block

The type that is returned by evaluate on success.

fn evaluate( &self, ctx: &Context<'_>, ) -> Result<<Block as Evaluate>::Output, Error>

Recursively evaluates all HCL templates and expressions in the implementing type using the variables and functions declared in the Context.

fn evaluate_in_place(&mut self, ctx: &Context<'_>) -> Result<(), Errors>

Recursively tries to evaluate all nested expressions in place.

impl Format for Block

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

where W: Write,

Formats a HCL structure using a formatter and writes the result to the provided writer.

fn format_vec<W>(&self, fmt: &mut Formatter<'_, W>) -> Result<Vec<u8>, Error>

where W: Write + AsMut<Vec<u8>>,

Formats a HCL structure using a formatter and returns the result as a Vec<u8>.

fn format_string<W>(&self, fmt: &mut Formatter<'_, W>) -> Result<String, Error>

where W: Write + AsMut<Vec<u8>>,

Formats a HCL structure using a formatter and returns the result as a String.

impl<I, B> From<(I, B)> for Block

where I: Into<Identifier>, B: IntoIterator, <B as IntoIterator>::Item: Into<Structure>,

fn from(_: (I, B)) -> Block

Converts to this type from the input type.

impl<I, L, B> From<(I, L, B)> for Block

where I: Into<Identifier>, L: IntoIterator, <L as IntoIterator>::Item: Into<BlockLabel>, B: IntoIterator, <B as IntoIterator>::Item: Into<Structure>,

fn from(_: (I, L, B)) -> Block

Converts to this type from the input type.

impl From<Block> for Block

fn from(value: Block) -> Block

Converts to this type from the input type.

impl From<Block> for Structure

fn from(block: Block) -> Structure

Converts to this type from the input type.

impl<'de> IntoDeserializer<'de, Error> for Block

type Deserializer = MapAccessDeserializer<BlockAccess>

The type of the deserializer being converted into.

fn into_deserializer( self, ) -> <Block as IntoDeserializer<'de, Error>>::Deserializer

Convert this value into a deserializer.

impl PartialEq for Block

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

Equality operator ==.

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

Inequality operator !=.

impl Serialize for Block

fn serialize<S>( &self, serializer: S, ) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>

where S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for Block