Struct Statics 

pub struct Statics { /* private fields */ }

A collection of statics to declare when building a unit.

A static item usually comes from the source being compiled, but a host which wants to hand a script a piece of state does not necessarily want that state to be declared by the script. Statics declared here are added to the unit as if the source had declared them, so a script can read and write them by name without declaring them itself.

Such a static has no initializer, since there is no source to evaluate. This means it starts out uninitialized and reading it before anything has assigned it is a runtime error, exactly like a static N; in a script. The caller is expected to populate it through Globals::set before running anything which reads it.

Declaring a name which the source also declares is an error, since it is ambiguous which of the two declarations a use refers to.

Examples

use rune::{Context, Source, Sources, Statics, Vm};
use rune::runtime::Globals;
use rune::sync::Arc;

let context = Context::with_default_modules()?;
let runtime = Arc::try_new(context.runtime()?)?;

let mut sources = Sources::new();
sources.insert(Source::memory(r#"
pub fn main() {
    LIMIT += 1;
    LIMIT
}
"#)?)?;

let mut statics = Statics::new();
statics.insert(["LIMIT"])?;

let unit = rune::prepare(&mut sources)
    .with_context(&context)
    .with_statics(&statics)
    .build()?;

let unit = Arc::try_new(unit)?;
let globals = Globals::new(unit.clone())?;
globals.set(["LIMIT"], rune::to_value(41i64)?)?;

let mut vm = Vm::new(runtime, unit).with_globals(globals);
let output = vm.call(["main"], ())?;
assert_eq!(rune::from_value::<i64>(output)?, 42);

Implementations

impl Statics

pub const fn new() -> Self

Construct an empty collection of statics.

pub fn insert( &mut self, name: impl IntoIterator<Item: IntoComponent>, ) -> Result<()>

Declare a static with the given name.

The name is the item the static is declared as, so ["LIMIT"] declares it at the root of the unit and ["config", "LIMIT"] declares it inside of the config module. Every component has to be a valid identifier.

Declaring the same name twice does nothing the second time.

Examples

use rune::Statics;

let mut statics = Statics::new();
statics.insert(["LIMIT"])?;
statics.insert(["config", "LIMIT"])?;
assert_eq!(statics.len(), 2);

statics.insert(["LIMIT"])?;
assert_eq!(statics.len(), 2);

pub fn len(&self) -> usize

The number of statics being declared.

pub fn is_empty(&self) -> bool

Test if the collection is empty.

Trait Implementations

impl Debug for Statics

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

Formats the value using the given formatter.

impl Default for Statics

fn default() -> Statics

Returns the “default value” for a type.