Struct nu_protocol::engine::EngineState

pub struct EngineState {

    pub scope: ScopeFrame,
    pub ctrlc: Option<Arc<AtomicBool>>,
    pub env_vars: Arc<EnvVars>,
    pub previous_env_vars: Arc<HashMap<String, Value>>,
    pub config: Arc<Config>,
    pub pipeline_externals_state: Arc<(AtomicU32, AtomicU32)>,
    pub repl_state: Arc<Mutex<ReplState>>,
    pub table_decl_id: Option<usize>,
    pub plugin_path: Option<PathBuf>,
    pub history_enabled: bool,
    pub history_session_id: i64,
    pub file: Option<PathBuf>,
    pub regex_cache: Arc<Mutex<LruCache<String, Regex>>>,
    pub is_interactive: bool,
    pub is_login: bool,
    pub debugger: Arc<Mutex<Box<dyn Debugger>>>,
    /* private fields */
}

The core global engine state. This includes all global definitions as well as any global state that will persist for the whole session.

Declarations, variables, blocks, and other forms of data are held in the global state and referenced elsewhere using their IDs. These IDs are simply their index into the global state. This allows us to more easily handle creating blocks, binding variables and callsites, and more, because each of these will refer to the corresponding IDs rather than their definitions directly. At runtime, this means less copying and smaller structures.

Many of the larger objects in this structure are stored within Arc to decrease the cost of cloning EngineState. While Arcs are generally immutable, they can be modified using Arc::make_mut, which automatically clones to a new allocation if there are other copies of the Arc already in use, but will let us modify the Arc directly if we have the only reference to it.

Note that the runtime stack is not part of this global state. Runtime stacks are handled differently, but they also rely on using IDs rather than full definitions.

Fields

scope: ScopeFrame

ctrlc: Option<Arc<AtomicBool>>

env_vars: Arc<EnvVars>

previous_env_vars: Arc<HashMap<String, Value>>

config: Arc<Config>

pipeline_externals_state: Arc<(AtomicU32, AtomicU32)>

repl_state: Arc<Mutex<ReplState>>

table_decl_id: Option<usize>

plugin_path: Option<PathBuf>

history_enabled: bool

history_session_id: i64

file: Option<PathBuf>

regex_cache: Arc<Mutex<LruCache<String, Regex>>>

is_interactive: bool

is_login: bool

debugger: Arc<Mutex<Box<dyn Debugger>>>

Implementations

impl EngineState

pub fn new() -> Self

pub fn merge_delta(&mut self, delta: StateDelta) -> Result<(), ShellError>

Merges a StateDelta onto the current state. These deltas come from a system, like the parser, that creates a new set of definitions and visible symbols in the current scope. We make this transactional as there are times when we want to run the parser and immediately throw away the results (namely: syntax highlighting and completions).

When we want to preserve what the parser has created, we can take its output (the StateDelta) and use this function to merge it into the global state.

pub fn merge_env( &mut self, stack: &mut Stack, cwd: impl AsRef<Path> ) -> Result<(), ShellError>

Merge the environment from the runtime Stack into the engine state

pub fn has_overlay(&self, name: &[u8]) -> bool

pub fn active_overlay_ids<'a, 'b>( &'b self, removed_overlays: &'a [Vec<u8>] ) -> impl DoubleEndedIterator<Item = &OverlayId> + 'a

where 'b: 'a,

pub fn active_overlays<'a, 'b>( &'b self, removed_overlays: &'a [Vec<u8>] ) -> impl DoubleEndedIterator<Item = &OverlayFrame> + 'a

where 'b: 'a,

pub fn active_overlay_names<'a, 'b>( &'b self, removed_overlays: &'a [Vec<u8>] ) -> impl DoubleEndedIterator<Item = &[u8]> + 'a

where 'b: 'a,

pub fn translate_overlay_ids(&self, other: &ScopeFrame) -> Vec<OverlayId>

Translate overlay IDs from other to IDs in self

pub fn last_overlay_name(&self, removed_overlays: &[Vec<u8>]) -> &[u8]

pub fn last_overlay(&self, removed_overlays: &[Vec<u8>]) -> &OverlayFrame

pub fn get_overlay_name(&self, overlay_id: OverlayId) -> &[u8]

pub fn get_overlay(&self, overlay_id: OverlayId) -> &OverlayFrame

pub fn render_env_vars(&self) -> HashMap<&String, &Value>

pub fn add_env_var(&mut self, name: String, val: Value)

pub fn get_env_var(&self, name: &str) -> Option<&Value>

pub fn get_path_env_var(&self) -> Option<&Value>

pub fn plugins(&self) -> &[Arc<dyn RegisteredPlugin>]

pub fn update_plugin_file( &self, updated_items: Vec<PluginRegistryItem> ) -> Result<(), ShellError>

pub fn num_files(&self) -> usize

pub fn num_virtual_paths(&self) -> usize

pub fn num_vars(&self) -> usize

pub fn num_decls(&self) -> usize

pub fn num_blocks(&self) -> usize

pub fn num_modules(&self) -> usize

pub fn print_vars(&self)

pub fn print_decls(&self)

pub fn print_blocks(&self)

pub fn print_contents(&self)

pub fn find_decl( &self, name: &[u8], removed_overlays: &[Vec<u8>] ) -> Option<DeclId>

pub fn find_decl_name( &self, decl_id: DeclId, removed_overlays: &[Vec<u8>] ) -> Option<&[u8]>

pub fn get_module_comments(&self, module_id: ModuleId) -> Option<&[Span]>

pub fn plugin_decls(&self) -> impl Iterator<Item = &Box<dyn Command + 'static>>

pub fn find_module( &self, name: &[u8], removed_overlays: &[Vec<u8>] ) -> Option<ModuleId>

pub fn which_module_has_decl( &self, decl_name: &[u8], removed_overlays: &[Vec<u8>] ) -> Option<&[u8]>

pub fn find_overlay(&self, name: &[u8]) -> Option<OverlayId>

pub fn find_active_overlay(&self, name: &[u8]) -> Option<OverlayId>

pub fn find_commands_by_predicate( &self, predicate: impl Fn(&[u8]) -> bool, ignore_deprecated: bool ) -> Vec<(Vec<u8>, Option<String>, CommandType)>

pub fn get_span_contents(&self, span: Span) -> &[u8]

pub fn get_config(&self) -> &Config

pub fn set_config(&mut self, conf: Config)

pub fn get_plugin_config(&self, plugin: &str) -> Option<&Value>

Fetch the configuration for a plugin

The plugin must match the registered name of a plugin. For register nu_plugin_example the plugin name to use will be "example"

pub fn history_config(&self) -> Option<HistoryConfig>

Returns the configuration settings for command history or None if history is disabled

pub fn get_var(&self, var_id: VarId) -> &Variable

pub fn get_constant(&self, var_id: VarId) -> Option<&Value>

pub fn generate_nu_constant(&mut self)

pub fn get_decl(&self, decl_id: DeclId) -> &dyn Command

pub fn get_decls_sorted(&self, include_hidden: bool) -> Vec<(Vec<u8>, DeclId)>

Get all commands within scope, sorted by the commands’ names

pub fn get_signature(&self, decl: &dyn Command) -> Signature

pub fn get_signatures(&self, include_hidden: bool) -> Vec<Signature>

Get signatures of all commands within scope.

pub fn get_block(&self, block_id: BlockId) -> &Arc<Block>

pub fn try_get_block(&self, block_id: BlockId) -> Option<&Arc<Block>>

Optionally get a block by id, if it exists

Prefer to use [.get_block()] in most cases - BlockIds that don’t exist are normally a compiler error. This only exists to stop plugins from crashing the engine if they send us something invalid.

pub fn get_module(&self, module_id: ModuleId) -> &Module

pub fn get_virtual_path( &self, virtual_path_id: VirtualPathId ) -> &(String, VirtualPath)

pub fn next_span_start(&self) -> usize

pub fn files(&self) -> impl Iterator<Item = &CachedFile>

pub fn add_file(&mut self, filename: Arc<str>, content: Arc<[u8]>) -> FileId

pub fn set_config_path(&mut self, key: &str, val: PathBuf)

pub fn get_config_path(&self, key: &str) -> Option<&PathBuf>

pub fn build_usage(&self, spans: &[Span]) -> (String, String)

pub fn build_module_usage( &self, module_id: ModuleId ) -> Option<(String, String)>

pub fn current_work_dir(&self) -> String

👎Deprecated since 0.92.3: please use EngineState::cwd() instead

Returns the current working directory, which is guaranteed to be canonicalized.

Returns an empty String if $env.PWD doesn’t exist.

pub fn cwd(&self, stack: Option<&Stack>) -> Result<PathBuf, ShellError>

Returns the current working directory, which is guaranteed to be an absolute path without trailing slashes (unless it’s the root path), but might contain symlink components.

If stack is supplied, also considers modifications to the working directory on the stack that have yet to be merged into the engine state.

pub fn cwd_as_string(&self, stack: Option<&Stack>) -> Result<String, ShellError>

Like EngineState::cwd(), but returns a String instead of a PathBuf for convenience.

pub fn get_file_contents(&self) -> &[CachedFile]

pub fn get_startup_time(&self) -> i64

pub fn set_startup_time(&mut self, startup_time: i64)

pub fn activate_debugger( &self, debugger: Box<dyn Debugger> ) -> Result<(), PoisonError<MutexGuard<'_, Box<dyn Debugger>>>>

pub fn deactivate_debugger( &self ) -> Result<Box<dyn Debugger>, PoisonError<MutexGuard<'_, Box<dyn Debugger>>>>

pub fn is_debugging(&self) -> bool

pub fn recover_from_panic(&mut self)

Trait Implementations

impl Clone for EngineState

fn clone(&self) -> EngineState

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Default for EngineState

fn default() -> Self

Returns the “default value” for a type.