Struct EpochConfig 

pub struct EpochConfig {
    pub epoch_id: EpochId,
    pub version: String,
    pub tags: HashMap<String, EpochId>,
    pub list_existing_epochs: HashMap<EpochId, Option<EpochInfo>>,
}

The file written to .epochconfig that tells the CLI which epoch folder is the “current” one.

Only the minimal information needed for fast switches is stored:

• the numeric identifier of the selected epoch,
• a list of human-readable tags,
• the absolute path to the epoch’s directory.

No world or event data lives here - it is purely a lightweight pointer.

Fields

epoch_id: EpochId

The epoch ID that the binary should consider “current”.

version: String

The version of the file loaded, and hopefully of all the project

tags: HashMap<String, EpochId>

Optional human-friendly tags (e.g. "winter-B", "post-war").

list_existing_epochs: HashMap<EpochId, Option<EpochInfo>>

A hashmap containing the name of all existing epochs, only loaded in memory if used

Implementations

impl EpochConfig

pub fn new_from_path(_path: Option<&Path>) -> Result<Self, EpochError>

Create a new config from an existig path

pub fn version(&self) -> String

Output the current version vs the filesystem version

pub fn try_load(&mut self, epoch_id: &EpochId) -> Result<(), EpochError>

Loads the metadata for an epoch from disk into the in-memory cache.

The epoch identified by epoch_id must exist in list_existing_epochs. The JSON file on disk is read, deserialized into an EpochInfo, and stored in the map. Any existing value for that epoch is overwritten.

Returns

• Ok(()) when the epoch was successfully read and cached.
• Err(EpochError::EpochNotFound(..)) if the epoch is not present in the internal map.
• Err(EpochError::Serde { .. }) if the JSON file could not be parsed.
• Err(EpochError::Io { .. }) if the file could not be read.

pub fn try_load_current(&mut self) -> Result<&EpochInfo, EpochError>

Load the currently active epoch.

This helper first ensures that the current epoch’s metadata is cached by delegating to try_load, then returns a reference to it.

Returns

• Ok(&EpochInfo) - Reference to the cached epoch.
• Propagates any error from try_load.

pub unsafe fn try_load_id( &self, epoch_id: EpochId, ) -> Result<&EpochInfo, EpochError>

Load an epoch by its identifier.

The caller must guarantee that the epoch has already been loaded into the cache (e.g. by calling try_load). This function is marked unsafe because it performs a raw reference conversion without performing that check.

Safety

Calling this function when the requested epoch has not yet been loaded results in undefined behaviour.

Arguments

• epoch_id - Identifier of the epoch to load.

Returns

• Ok(&EpochInfo) - Reference to the cached epoch.
• Err(EpochError::EpochHashingImpossible(..)) - The identifier is unknown.
• Err(EpochError::LoadingEpochId(..)) - The epoch data is not yet present in the cache.

pub fn try_load_current_as_mut(&mut self) -> Result<&mut EpochInfo, EpochError>

Load the currently active epoch mutably.

This is a convenience wrapper that forwards to try_load_id_as_mut for the current epoch.

Returns

• Ok(&mut EpochInfo) - Mutable reference to the cached epoch.
• Propagates any error from the underlying load routine.

pub fn get_epoch_id(&self, id: &EpochIdentifier) -> Result<EpochId, EpochError>

Retrieves the internal epoch ID for a given identifier.

The identifier can be either a tag string (EpochIdentifier::Tag) or an explicit epoch ID (EpochIdentifier::Id).

• When a tag is supplied the function looks up the corresponding epoch ID in the tags map.
• When an ID is supplied it verifies that an epoch with that ID exists in list_existing_epochs and returns it.

Returns

• Ok(epoch_id) when the identifier is successfully resolved.
• Err(EpochError::AmbiguousTag(tag)) if a supplied tag does not exist.
• Err(EpochError::EpochFolderMissing(id, path)) if an ID does not have an associated epoch folder.

pub fn delete_id(&mut self, id: EpochId) -> Result<(), EpochError>

Delete an entire epoch folder by its ID.

The function removes the directory, deletes all references to the epoch from list_existing_epochs and tags, and then writes the updated configuration to disk.

pub fn compute_next(&mut self) -> Result<EpochInfo, EpochError>

Compute the next epoch.

Currently this function is a placeholder that creates a new epoch with the ID immediately following the current one. The actual logic is deferred to the EpochInfo -> World subsystem.

pub unsafe fn update_all_temporary_values(&mut self)

Update all temporary values of every entity in the current epoch.

Safety

• The caller must guarantee that the current epoch is loaded and its storage is still valid for the duration of the call.
• The function performs raw pointer arithmetic / unsafe reads/writes on the internal data structures. No other thread may be mutably borrowing the same data at the same time.

pub unsafe fn reset_temporary_stats(&mut self) -> Result<(), EpochError>

Reset all temporary values to the current live values.

Safety

• The caller must ensure that the current epoch is loaded and that no other mutable references to the same data exist.
• This method writes directly into the entity structs; any concurrent access will lead to undefined behaviour.

pub unsafe fn update_temps(&mut self)

Update temporary values for every entity assuming the current epoch is loaded.

Safety

• Same as update_all_temporary_values: the current epoch must be loaded and no other mutable references may exist.

pub fn insert_and_save( &mut self, new_epoch: EpochInfo, save_mode: &SaveMode, ) -> Result<(), EpochError>

Insert a new epoch into the configuration and persist it.

The function creates the epoch’s directory, writes its metadata, updates the internal maps, and finally writes the updated configuration to disk.

Returns

• Ok(()) - the epoch was added and the configuration was saved.
• Err(EpochError::EpochAlreadyExists(..)) if an epoch with the same ID already exists.

pub fn log_elements(&mut self, list_ids: &[EpochId]) -> Result<(), EpochError>

Load and display the metadata for a list of epoch IDs.

The function first ensures that each requested epoch’s metadata is loaded into memory, then displays a formatted log for each one.

Trait Implementations

impl Clone for EpochConfig

fn clone(&self) -> EpochConfig

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl ConfigWritable for EpochConfig

fn save_path(&self) -> String

The full path indicating where to save the config

fn save_folder(&self) -> String

The folder where to save the file to save the config

fn as_json(&self, action: String) -> Result<String, EpochError>

Serialises the config into a pretty JSON string.

fn save_with_context( &self, action_description: &str, do_not_erase: &SaveMode, ) -> Result<(), EpochError>

Saves the config into its nominal path.

impl Debug for EpochConfig

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

Formats the value using the given formatter.

impl Default for EpochConfig

fn default() -> Self

Create an empty config, mainly for initialisation

impl<'de> Deserialize<'de> for EpochConfig

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Serialize for EpochConfig

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.