Struct dygpi::config::PluginManagerConfiguration

pub struct PluginManagerConfiguration { /* fields omitted */ }

The plugin manager configuration itself. This is logically a map from a plugin type identifier and a list of library paths. The type identifier allows the configuration to partition the list of libraries so that multiple plugin managers may be created, for different plugin types, from the same configuration value or serialized file.

Note, that if the feature “config_serde” is included this type implements the Serde Deserialize and Serialize traits and so may be included in configuration files.

use dygpi::config::PluginManagerConfiguration;
use serde::{Deserialize, Serialize};

#[derive(Deserialize, Serialize)]
pub struct MyAppConfiguration {
    pub save_path: String,
    pub template_path: String,
    pub plugins: Option<PluginManagerConfiguration>,
}

Implementations

impl PluginManagerConfiguration

pub fn is_empty(&self) -> bool

Returns true if the configuration contains no plugin types, else false.

pub fn len(&self) -> usize

Returns the number of plugin types in the configuration, also referred to as its ‘length’.

pub fn plugin_types(&self) -> impl Iterator<Item = &String>

Return an iterator over the plugin type identifiers in the configuration.

pub fn contains_plugin_type(&self, plugin_type: &str) -> bool

Returns true if the configuration has values for the provided plugin type identifier, else false.

pub fn plugin_libraries_for_type(
    &self,
    plugin_type: &str
) -> Option<impl Iterator<Item = &PathBuf>>

Returns an iterator over all the library paths specified for the provided plugin type identifier. This method returns None if the configuration has no entry for the plugin type.

pub fn insert(
    &mut self,
    plugin_type: &str,
    library_list: &[&Path]
) -> Option<HashSet<PathBuf>>

Insert a list of libraries for the named plugin type; if there exists an entry for this type already it will be replaced. Note that this method will panic if the library list is empty.

pub fn merge(&mut self, plugin_type: &str, library_list: &[&Path])

Merge a list of libraries into the configuration for the plugin type. if there exists an entry for this type already the values provided will be added to the list, if not then this acts exactly as insert. Note that this method will panic if the library list is empty.

pub fn remove(&mut self, plugin_type: &str) -> Option<HashSet<PathBuf>>

Removes and returns the plugin libraries for the plugin type.

pub fn make_manager_for_type<T>(
    &self,
    plugin_type: &str
) -> Result<PluginManager<T>> where
    T: Plugin, 

Construct and return a new PluginManager for plugins of type T using the list of libraries specified for the plugin type identifier provided. Note that this method will return an error if there is no configured library list for the provided plugin type.

Example

use dygpi::config::PluginManagerConfiguration;
use dygpi::manager::PluginManager;

let config_as_string = read_config_file();
let config: PluginManagerConfiguration = toml::from_str(&config_as_string).unwrap();
let manager: PluginManager<SoundEffectPlugin> =
    config.make_manager_for_type("sound_effects")
        .unwrap();

Trait Implementations

impl Debug for PluginManagerConfiguration

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

Formats the value using the given formatter.

impl Default for PluginManagerConfiguration

fn default() -> Self

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for PluginManagerConfiguration

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

Deserialize this value from the given Serde deserializer.

impl Serialize for PluginManagerConfiguration

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

Serialize this value into the given Serde serializer.