Struct Variable

pub struct Variable {
    pub array_sections: Vec<ArraySection>,
    /* private fields */
}

A variable reference, possibly with array sections

Variables in OpenMP clauses can be:

• Simple: x, my_var
• Array elements: arr[i]
• Array sections: arr[0:N]
• Multidimensional: matrix[i][0:N]

Learning: Composition

Notice how Variable is built from other IR types:

• Uses &'a str for the name (borrowed from source)
• Uses Vec<ArraySection> for subscripts
• ArraySection uses Expression

This shows how complex structures are built from simple parts.

Example

use roup::ir::{Variable, ArraySection, Expression, ParserConfig};

let config = ParserConfig::default();

// Simple variable: x
let simple = Variable::new("x");
assert_eq!(simple.name(), "x");
assert!(simple.is_scalar());

// Array section: arr[0:N]
let array = Variable::with_sections(
    "arr",
    vec![ArraySection::new(
        Some(Expression::new("0", &config)),
        Some(Expression::new("N", &config)),
        None,
    )]
);
assert!(!array.is_scalar());

Fields

array_sections: Vec<ArraySection>

Array sections (empty for scalar variables)

Each element represents one dimension:

• arr[i] → 1 section
• matrix[i][j] → 2 sections
• tensor[i][j][k] → 3 sections

Implementations

impl Variable

pub fn new(name: impl Into<String>) -> Self

Create a new variable without array sections (scalar)

Example

use roup::ir::Variable;

let var = Variable::new("x");
assert_eq!(var.name(), "x");
assert!(var.is_scalar());

pub fn with_sections( name: impl Into<String>, sections: Vec<ArraySection>, ) -> Self

Create a variable with array sections

Example

use roup::ir::{Variable, ArraySection};

let var = Variable::with_sections(
    "arr",
    vec![ArraySection::all()]
);
assert_eq!(var.name(), "arr");
assert!(!var.is_scalar());

pub fn name(&self) -> &str

Get the variable name

pub fn is_scalar(&self) -> bool

Check if this is a scalar (no array sections)

pub fn is_array(&self) -> bool

Check if this is an array (has sections)

pub fn dimensions(&self) -> usize

Get the number of dimensions

Returns 0 for scalars, 1+ for arrays.

Trait Implementations

impl Clone for Variable

fn clone(&self) -> Variable

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Variable

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

Formats the value using the given formatter.

impl Display for Variable

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

Format as OpenMP variable syntax

Example

use roup::ir::{Variable, ArraySection, Expression, ParserConfig};

let config = ParserConfig::default();

// Scalar
let scalar = Variable::new("x");
assert_eq!(format!("{}", scalar), "x");

// Array section
let array = Variable::with_sections(
    "arr",
    vec![ArraySection::new(
        Some(Expression::new("0", &config)),
        Some(Expression::new("N", &config)),
        None,
    )]
);
assert_eq!(format!("{}", array), "arr[0:N]");

impl From<&str> for Variable

fn from(name: &str) -> Self

Converts to this type from the input type.

impl From<Identifier> for Variable

fn from(id: Identifier) -> Self

Converts to this type from the input type.

impl From<String> for Variable

fn from(name: String) -> Self

Converts to this type from the input type.

impl From<Variable> for ClauseItem

fn from(var: Variable) -> Self

Converts to this type from the input type.

impl PartialEq for Variable

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