Plugin System

We now have an overview of traits, how to define them and how they work, now it's time to put that knowledge to use and build a plugin system using traits.

A plugin in this system is any type that implements a specific trait. Each plugin will perform a specific task, and the system should manage a collection of these plugins, executing them in sequence. You’ll also address advanced issues like object safety and resolving potential conflicts between overlapping trait implementations.

Your Task

Design and implement a plugin system using trait objects. You will:

Define a Plugin trait that includes methods for initialization and execution.
Create a PluginManager struct to manage plugins. It should:
- Dynamically load plugins implementing the Plugin trait.
- Allow adding and removing plugins.
- Execute all registered plugins in sequence.

Requirements

The Plugin trait should include the following methods:
- fn name(&self) -> &str; - Returns the name of the plugin.
- fn execute(&self); - Executes the plugin's functionality.
The PluginManager should:
- Have the following methods and associated functions:
  - new() -> Self - Creates a new PluginManager instance.
  - add_plugin - Adds a plugin to the list.
  - remove_plugin - Removes a plugin from the list and returns the removed plugin if found.
  - execute_all - Executes all registered plugins.
If a duplicate plugin is added (with the same name), it should panic with the message "Plugin with name [name] already exists".

Make sure you make all relevant items public.

Hints

Click here to reveal hints

Dynamic Dispatch: Store plugins in a Vec<Box<dyn Plugin>> for dynamic dispatch.
Plugin Uniqueness: Use the name method to identify and ensure uniqueness among plugins.

Editor not available on Mobile!

In order to solve the challenge, please visit this page on a desktop computer.

Solutions

Jai

jsat97

2 days ago

3.40ms

88.19kb

pub trait Plugin {
    // 1. Finish the trait
    fn name(&self) -> &str;
    fn execute(&self);
}
struct MyPlugin {
    pub name: String,
}
impl MyPlugin {
    fn new()-> Self {
        MyPlugin{name: "Jay Doe".to_string()}
    }
}
impl Plugin for MyPlugin {
    fn name (&self) -> &str {&self.name}
    fn execute(&self) {}
}
pub struct PluginManager {
    // 2. Finish the struct
    // Make fields public
    pub plugins: Vec<Box<dyn Plugin>>,
}
// 3. Implement the PluginManager
impl PluginManager {
   pub fn new() -> Self {
        PluginManager{plugins: vec!{}}
   }
   pub fn add_plugin(&mut self, plugin:Box<dyn Plugin>) {
        let name = plugin.name();
        for p in &self.plugins {
            if p.name() == name {
                panic!("Plugin with name '{}' already exists", name);
            }
        }
        self.plugins.push(plugin);
   }
   //pub fn remove_plugin(&mut self, plugin:Box<dyn Plugin>) -> Option< Box<dyn Plugin>> {
   pub fn remove_plugin(&mut self, name: &str) -> Option< Box<dyn Plugin>> {
    let idx = self.plugins.iter().position(|x| x.name() == name);
    if idx.is_none() {
        return None;
    }
    let idx = idx.unwrap();
    //let plugin = &self.plugins[idx];
    Some(self.plugins.remove(idx))
   }
   pub fn execute_all(&self) {
    for p in &self.plugins {
        p.execute();
    }
   }
}
// Example usage
pub fn main() {
    let mut manager = PluginManager::new();
    manager.add_plugin(Box::new(MyPlugin::new()));
    manager.execute_all();
}

amdfxlucas

5 days ago

4.40ms

88.42kb

use std::collections::HashMap;
struct MyPlugin{
    pub name: String
    
}
impl MyPlugin {
    pub fn new() -> Self{
        Self{name: "Jane Doe".to_string() }
    }
}
impl Plugin for MyPlugin {
    fn name(&self)-> &str {
        return self.name.as_str()
    }
    
    fn execute(&self)
    {}
}
pub trait Plugin {
   fn name(&self) -> &str;
   fn execute(&self); 
}
pub struct PluginManager {
    pub plugins: HashMap<String, Box<dyn Plugin>>
}
// 3. Implement the PluginManager
impl PluginManager {
    pub fn new() -> Self{
        Self{plugins: HashMap::new()}
    }
   pub fn add_plugin(&mut self, b: Box<dyn Plugin>)
    {
        if self.plugins.contains_key( &b.name().to_string() )//get( &b.name().to_string() ).is_some()
        {panic!("Plugin with name '{}' already exists.", b.name() );
        }
        self.plugins.insert(b.name().to_string(), b);
    }
    pub fn remove_plugin(&mut self, name: &str) -> Option<Box<dyn Plugin>>    
    {
        self.plugins.remove(&name.to_string())
    }
    pub fn execute_all(&self)
    {
        self.plugins.iter().for_each(|(x,v)|v.execute());
    }
}
// Example usage
pub fn main() {
    let mut manager = PluginManager::new();
    manager.add_plugin(Box::new(MyPlugin::new()));
    manager.execute_all();
}

StevenCanDrink

5 days ago

3.33ms

88.27kb

use std::collections::HashMap;
pub trait Plugin {
    // 1. Finish the trait
    fn name(&self) -> &str;
    fn execute(&self);
}
struct MyPlugin {
    pub name: String,
}
impl Plugin for MyPlugin {
    fn execute(&self) {
        print!("{}", self.name)
    }
    fn name(&self) -> &str {
        &self.name
    }
}
impl MyPlugin {
    fn new() -> Self {
        Self { name: "default".to_string() }
    }
}
pub trait PM {
    fn new() -> Self;
    fn add_plugin(&mut self, pl: Box<dyn Plugin>) -> Option<Box<dyn Plugin>>;
    fn remove_plugin(&mut self, name: &str) -> Option<Box<dyn Plugin>>;
    fn execute_all(&self) -> ();
}
pub struct PluginManager {
    // 2. Finish the struct
    // Make fields public
    pub plugins: HashMap<String, Box<dyn Plugin>>,
}
// 3. Implement the PluginManager
impl PM for PluginManager {
    fn new() -> Self {
        Self { plugins: HashMap::new() }
    }
    fn add_plugin(&mut self, pl: Box<dyn Plugin>) -> Option<Box<dyn Plugin>> {
        if self.plugins.contains_key(pl.name()) {
            panic!("Plugin with name '{}' already exists", pl.name());
        }
        self.plugins.insert(pl.name().to_string(), pl)
    }
    fn execute_all(&self) -> () {
        for plugin in self.plugins.values() {
            plugin.execute();
        }
    }
    fn remove_plugin(&mut self, name: &str) -> Option<Box<dyn Plugin>> {
        self.plugins.remove(name)
    }
}
// Example usage
pub fn main() {
    let mut manager = PluginManager::new();
    manager.add_plugin(Box::new(MyPlugin::new()));
    manager.execute_all();
}

Chih Ying Yen

xavierforge

8 days ago

4.12ms

88.27kb

use std::collections::HashMap;
pub trait Plugin {
    // 1. Finish the trait
    fn name(&self) -> &str;
    fn execute(&self);
}
pub struct PluginManager {
    // 2. Finish the struct
    // Make fields public
    pub plugins: HashMap<String, Box<dyn Plugin>>
}
// 3. Implement the PluginManager
impl PluginManager {
    pub fn new() -> Self {
        Self { plugins: HashMap::new() }
    }
    pub fn add_plugin(&mut self, plugin: Box<dyn Plugin>) {
        let name = plugin.name().to_string();
        if self.plugins.contains_key(&name) {
            panic!("Plugin with name '{name}' already exists")
        }
        self.plugins.insert(name, plugin);
    }
    pub fn remove_plugin(&mut self, name: &str) -> Option<Box<dyn Plugin>> {
        self.plugins.remove(name)
    }
    pub fn  execute_all(&self) {
        for plugin in self.plugins.values() {
            plugin.execute()
        }
    }
}
pub struct MyPlugin;
impl MyPlugin {
    pub fn new() -> Self {
        Self
    }
}
impl Plugin for MyPlugin {
    fn name(&self) -> &str {
        "MyPlugin"
    }
    fn execute(&self) {
        println!("MyPlugin is executing its task.");
    }
}
// Example usage
pub fn main() {
    let mut manager = PluginManager::new();
    manager.add_plugin(Box::new(MyPlugin::new()));
    manager.execute_all();
}

undefeated_

boyboi86

9 days ago

4.14ms

87.96kb

pub trait Plugin {
    // 1. Finish the trait
    fn name(&self) -> &str;
    fn execute(&self);
}
pub struct PluginManager {
    // 2. Finish the struct
    // Make fields public
    pub plugins: Vec<Box<dyn Plugin>>,
    
}
// 3. Implement the PluginManager
impl PluginManager {
    pub fn new() -> Self {
        Self {
            plugins: Vec::new()
        }
    }
    pub fn add_plugin(&mut self, plugin: Box<dyn Plugin>) {
        if self.plugins.iter().any(|n| n.name() == plugin.name()) {
            panic!("Plugin with name '{}' already exists", plugin.name());
        }
        self.plugins.push(plugin);
    }
    pub fn remove_plugin(&mut self, name: &str) -> Option<Box<dyn Plugin>>{
    // Find the position of the plugin with matching name
    if let Some(pos) = self.plugins.iter().position(|n| n.name() == name) {
        // Remove the plugin at the found position
        Some(self.plugins.remove(pos))
    } else {
        None
    }
}
    pub fn execute_all(&self) {
        for p in &self.plugins {
            println!("Name {}",  p.name());
            p.execute();
        }
    }
}
// Add in this portion bc the test case didn't implement it
pub struct MyPlugin;
impl MyPlugin {
    pub fn new() -> Self {
        MyPlugin
    }
}
impl Plugin for MyPlugin {
    fn name(&self) -> &str {
        "MyPlugin"
    }
    fn execute(&self) {
        println!("MyPlugin is executing its task.");
    }
}
// Example usage
pub fn main() {
    let mut manager = PluginManager::new();
    manager.add_plugin(Box::new(MyPlugin::new()));
    manager.execute_all();
}

shahab-tplus

12 days ago

3.31ms

87.96kb

pub trait Plugin {
    // 1. Finish the trait
    fn name(&self) -> &str;
    fn execute(&self);
}
pub struct PluginManager {
    // 2. Finish the struct
    // Make fields public
    pub plugins: Vec<Box<dyn Plugin>>,
}
// 3. Implement the PluginManager
impl PluginManager {
    pub fn new() -> Self {
        Self {
            plugins: Vec::new()
        }
    }
    pub fn add_plugin(&mut self, plugin: Box<dyn Plugin>) {
        
        if self.plugins.iter().any(|p| p.name() == plugin.name()) {
            panic!("Plugin with name '{}' already exists", plugin.name());
        }
        self.plugins.push(plugin);
    }
    pub fn remove_plugin(&mut self, name: &str) -> Option<Box<dyn Plugin>> {
        if let Some(pos) = self.plugins.iter().position(|p| p.name() == name) {
            Some(self.plugins.remove(pos))
        } else {
            None
        }
    }
    pub fn execute_all(&self) {
        for p in &self.plugins {
            println!("Name {}",  p.name());
            p.execute();
        }
    }
}
pub struct MyPlugin;
impl MyPlugin {
    pub fn new() -> Self {
        MyPlugin
    }
}
impl Plugin for MyPlugin {
    fn name(&self) -> &str {
        "MyPlugin"
    }
    fn execute(&self) {
        println!("MyPlugin is executing its task.");
    }
}
// Example usage
pub fn main() {
    let mut manager = PluginManager::new();
    manager.add_plugin(Box::new(MyPlugin::new()));
    manager.execute_all();
}

toto

12 days ago

3.91ms

88.27kb

use std::collections::HashMap;
pub trait Plugin {
    // 1. Finish the trait
    fn name(&self) -> &str;
    fn execute(&self);
}
#[derive(Default)]
pub struct PluginManager {
    // 2. Finish the struct
    // Make fields public
    pub plugins: HashMap<String, Box<dyn Plugin>>,
}
// 3. Implement the PluginManager
impl PluginManager {
    pub fn new() -> Self {
        Self::default()
    }
    pub fn add_plugin(&mut self, plugin: Box<dyn Plugin>) {
        let name = plugin.name();
        if self.plugins.contains_key(name) {
            panic!("Plugin with name '{name}' already exists")
        }
        self.plugins.insert(plugin.name().to_string(), plugin);
    }
    pub fn remove_plugin(&mut self, name: &str) -> Option<Box<dyn Plugin>> {
        self.plugins.remove(name)
    }
    pub fn execute_all(&self) {
        self.plugins.values().for_each(|plugin| plugin.execute());
    }
}
#[derive(Default)]
struct MyPlugin {}
impl MyPlugin {
    fn new() -> Self {
        Self::default()
    }
}
impl Plugin for MyPlugin {
    fn name(&self) -> &str {
        "test"
    }
    fn execute(&self) {}
}
// Example usage
pub fn main() {
    let mut manager = PluginManager::new();
    manager.add_plugin(Box::new(MyPlugin::new()));
    manager.execute_all();
}

GunGraveCpp

13 days ago

4.70ms

88.27kb

use core::{option::Option};
use std::collections::HashMap;
pub trait Plugin {
  
    fn name(&self) -> &str;
    fn execute(&self);
}
struct MyPlugin{
}
impl MyPlugin {
    pub fn new() -> MyPlugin{
        MyPlugin { }
    }
}
impl Plugin for MyPlugin  {
    fn name(&self) -> &str {
        "MyPlugin" 
    }
    fn execute(&self) {
        println!("MyPlugin")
    }
}
pub struct PluginManager {
    pub plugins: HashMap<String, Box<dyn Plugin>>
}
impl PluginManager {
    pub fn new() -> PluginManager{
        PluginManager { plugins: HashMap::new() }
    }
    pub fn add_plugin(&mut self, plugin: Box<dyn Plugin>){
        let plug_name = plugin.name().to_string();
        if !self.plugins.contains_key(&plug_name){
            self.plugins.insert(plug_name, plugin);
        }else {
            panic!("Plugin with name '{}' already exists", plug_name)
        }         
    }
    pub fn execute_all(&self){
        for (_, plug) in self.plugins.iter(){
            plug.execute()
        }
    }
    pub fn remove_plugin(&mut self, name: &str) -> Option<Box<dyn Plugin>>{
        self.plugins.remove(name)
    }
}
// Example usage
pub fn main() {
    let mut manager = PluginManager::new();
    manager.add_plugin(Box::new(MyPlugin::new()));
    manager.execute_all();
}

manu3618

14 days ago

30.50ms

87.93kb

pub trait Plugin {
    // 1. Finish the trait
    fn name(&self) -> &str;
    fn execute(&self);
}
pub struct PluginManager {
    // 2. Finish the struct
    // Make fields public
    pub plugins: Vec<Box<dyn Plugin>>,
}
// 3. Implement the PluginManager
impl PluginManager {
    pub fn new() -> Self{
        Self {
            plugins: Vec::new()
        }
    }
    pub fn add_plugin(&mut self, plugin: Box<dyn Plugin>) {
        if self.plugins.iter().map(|p| p.name()).collect::<Vec<_>>().contains(&plugin.name()) {
            panic!("Plugin with name '{}' already exists.", plugin.name())
        }
        self.plugins.push(plugin)
    }
    pub fn remove_plugin(&mut self, plugin_name: &str) -> Option<Box<dyn Plugin>> {
        if let Some(idx) = self.plugins.iter().position(|p| p.name() == plugin_name){
            Some(self.plugins.remove(idx))
        } else {
            None
        }
    }
    pub fn execute_all(&self) {
        for p in &self.plugins {
            p.execute();
        }
    }
}
// Example usage
pub fn main() {
    let mut manager = PluginManager::new();
    // manager.add_plugin(Box::new(MyPlugin::new()));
    manager.execute_all();
}

Lvfalue

15 days ago

4.19ms

88.69kb

pub trait Plugin {
    // 1. Finish the trait
    fn name(&self) -> &str;
    fn execute(&self);
}
pub struct PluginManager {
    // 2. Finish the struct
    // Make fields public
    pub plugins: Vec<Box<dyn Plugin>>
}
// 3. Implement the PluginManager
impl PluginManager {
    pub fn new() -> Self {
        PluginManager { plugins: Vec::new() }
    }
    pub fn add_plugin(&mut self, plugin: Box<dyn Plugin>) {
        let name = plugin.name();
        if let Some(_) = self.plugins.iter().position(|p| p.name() == name) {
            panic!("Plugin with name [{name}] already exists");
        } else {
            self.plugins.push(plugin);
        }
    }
    pub fn remove_plugin(&mut self, plugin_name: &str) -> Option<Box<dyn Plugin>> {
        if let Some(pos) = self.plugins.iter().position(|plugin| plugin.name() == plugin_name) {
            Some(self.plugins.remove(pos))
        } else {
            None
        }
    }
    pub fn execute_all(&self) {
        self.plugins.iter().for_each(|plugin| plugin.execute());
    }
}
pub struct MyPlugin {
    pub name: String
}
impl MyPlugin {
    pub fn new() -> Self {
        MyPlugin { name: "MyPlugin".to_string() }
    }
}
impl Plugin for MyPlugin {
    fn name(&self) -> &str {
        &self.name
    }
    fn execute(&self) {
        println!("this is {} running.", self.name);
    }
}
// Example usage
pub fn main() {
    let mut manager = PluginManager::new();
    manager.add_plugin(Box::new(MyPlugin::new()));
    manager.execute_all();
}

Lvfalue

15 days ago

3.44ms

88.69kb

pub trait Plugin {
    // 1. Finish the trait
    fn name(&self) -> &str;
    fn execute(&self);
}
pub struct PluginManager {
    // 2. Finish the struct
    // Make fields public
    pub plugins: Vec<Box<dyn Plugin>>
}
// 3. Implement the PluginManager
impl PluginManager {
    pub fn new() -> Self {
        PluginManager { plugins: Vec::new() }
    }
    pub fn add_plugin(&mut self, plugin: Box<dyn Plugin>) {
        let name = plugin.name();
        if let Some(_) = self.plugins.iter().position(|p| p.name() == name) {
            panic!("Plugin with name [{name}] already exists");
        } else {
            self.plugins.push(plugin);
        }
    }
    pub fn remove_plugin(&mut self, plugin_name: &str) -> Option<Box<dyn Plugin>> {
        if let Some(pos) = self.plugins.iter().position(|plugin| plugin.name() == plugin_name) {
            Some(self.plugins.remove(pos))
        } else {
            None
        }
    }
    pub fn execute_all(&self) {
        self.plugins.iter().for_each(|plugin| plugin.execute());
    }
}
pub struct MyPlugin {
    pub name: String
}
impl MyPlugin {
    pub fn new() -> Self {
        MyPlugin { name: "MyPlugin".to_string() }
    }
}
impl Plugin for MyPlugin {
    fn name(&self) -> &str {
        &self.name
    }
    fn execute(&self) {
        println!("this is {} running.", self.name);
    }
}
// Example usage
pub fn main() {
    let mut manager = PluginManager::new();
    manager.add_plugin(Box::new(MyPlugin::new()));
    manager.execute_all();
}

Jean-baptiste JOFFRE

Indy79

16 days ago

4.28ms

88.19kb

pub trait Plugin {
    fn name(&self) -> &str;
    fn execute(&self);
}
#[derive(Default)]
pub struct MyPlugin {
    name: String
}
impl MyPlugin {
    pub fn new() -> Self {
        Self::default()
    }
}
impl Plugin for MyPlugin {
    fn name(&self) -> &str {
        &self.name
    }
    fn execute(&self) {
        println!("Executing plugin with name {}", self.name);
    }
}
pub struct PluginManager {
    pub plugins: Vec<Box<dyn Plugin>>,
}
// 3. Implement the PluginManager
impl PluginManager {
    pub fn new() -> PluginManager {
        PluginManager {
            plugins: vec![],
        }
    }
    pub fn add_plugin(&mut self, plugin: Box<dyn Plugin>) -> () {
        if self.plugins.iter().any(|pl| pl.name() == plugin.name()) {
            let name = plugin.name();
            panic!("Plugin with name '{name}' already exists")
        }
        self.plugins.push(plugin);
    }
    pub fn remove_plugin(&mut self, plugin_name: &str) -> Option<Box<dyn Plugin>> {
        match self.plugins.iter_mut().position(|plugin| plugin.name() == plugin_name) {
            Some(index) => Some(self.plugins.remove(index)),
            None => None,
        }
    }
    pub fn execute_all(&self) {
        for plugin in self.plugins.iter() {
            plugin.execute();
        }
    }
}
// Example usage
pub fn main() {
    let mut manager = PluginManager::new();
    manager.add_plugin(Box::new(MyPlugin::new()));
    manager.execute_all();
}

visanr

17 days ago

3.11ms

89.08kb

pub trait Plugin {
    fn name(&self) -> &str;
    fn execute(&self);
    // 1. Finish the trait
}
#[derive(Default)]
pub struct MyPlugin {
    name: String
}
impl MyPlugin {
    pub fn new() -> Self {
        Self::default()
    }
}
impl Plugin for MyPlugin {
    fn name(&self) -> &str {
        &self.name
    }
    fn execute(&self) {
        println!("Executing plugin with name {}", self.name);
    }
}
use std::collections::HashMap;
pub struct PluginManager {
    pub plugins: HashMap<String, Box<dyn Plugin>>
    // 2. Finish the struct
    // Make fields public
}
// 3. Implement the PluginManager
impl PluginManager {
    pub fn new() -> Self {
        Self { plugins: HashMap::new() }
    }
    pub fn add_plugin(&mut self, plugin: Box<dyn Plugin>) {
        if self.plugins.contains_key(plugin.name()) {
            panic!("Plugin with name {} already exists", plugin.name());
        } else {
            self.plugins.insert(plugin.name().to_string(), plugin);
        }
    }
    pub fn remove_plugin(&mut self, name: &str) -> Option<Box<dyn Plugin>>{
        self.plugins.remove(name)
    }
    pub fn execute_all(&self) {
        for plugin in self.plugins.values() {
            plugin.execute();
        }
    }
}
// Example usage
pub fn main() {
    let mut manager = PluginManager::new();
    manager.add_plugin(Box::new(MyPlugin::new()));
    manager.execute_all();
}

aghia98

20 days ago

3.77ms

88.27kb

use std::collections::HashMap;
pub trait Plugin {
    // 1. Finish the trait
    fn name(&self) -> &str;
    fn execute(&self);
}
pub struct MyPlugin {
    name: String
}
impl MyPlugin {
    pub fn new()-> Self {
        Self {
            name: "defaultName".to_string()
        }
    }
}
impl Plugin for MyPlugin{
    fn name(&self) -> &str {
        self.name.as_str()
    }
    fn execute(&self) {
        println!("{} executed", self.name);
    }
}
pub struct PluginManager {
    pub plugins: HashMap<String,Box<dyn Plugin>>
}
    
// 3. Implement the PluginManager
impl PluginManager {
    pub fn new()-> Self {
        Self {
            plugins: HashMap::new()
        }
    }
    pub fn add_plugin(&mut self, plugin: Box<dyn Plugin>) {
        if !self.plugins.contains_key(plugin.name()) {
            self.plugins.insert(plugin.name().into(), plugin);
        }else{
            panic!("Plugin with name '{}' already exists", plugin.name());
        }
        
    }
    pub fn remove_plugin(&mut self, name: impl AsRef<str>)-> Option<Box<dyn Plugin>>{
        self.plugins.remove(name.as_ref())
    }
    pub fn execute_all(&self) {
        for plugin in self.plugins.values() {
            plugin.execute();
        } 
    }
}
// Example usage
pub fn main() {
    let mut manager = PluginManager::new();
    manager.add_plugin(Box::new(MyPlugin::new()));
    manager.execute_all();
}

Luka Bračun

lbracun

23 days ago

4.14ms

88.27kb

use std::{collections::HashMap};
pub trait Plugin {
    fn name(&self) -> &str;
    fn execute(&self);
}
pub struct PluginManager {
    pub plugins: HashMap<String, Box<dyn Plugin>>,
}
impl PluginManager {
    pub fn new() -> Self {
        PluginManager {
            plugins: HashMap::new(),
        }
    }
    pub fn add_plugin(&mut self, plugin: Box<dyn Plugin>) {
        if self.plugins.contains_key(plugin.name()) {
            panic!("Plugin with name '{}' already exists", plugin.name());
        }
        self.plugins.insert(plugin.name().to_string(), plugin);
    }
    pub fn remove_plugin(&mut self, name: &str) -> Option<Box<dyn Plugin>> {
        self.plugins.remove(name)
    }
    pub fn execute_all(&self) {
      self.plugins.values().for_each(|plugin| plugin.execute());
    }
}
struct MyPlugin {
    name: String,
}
impl MyPlugin {
    fn new() -> Self {
        MyPlugin {
            name: "MyPlugin".to_string(),
        }
    }
}
impl Plugin for MyPlugin {
    fn name(&self) -> &str {
        &self.name
    }
    fn execute(&self) {
        println!("Hello from {}!", self.name);
    }
}
// Example usage
pub fn main() {
    let mut manager = PluginManager::new();
    manager.add_plugin(Box::new(MyPlugin::new()));
    manager.execute_all();
}

bzdula

23 days ago

4.20ms

88.19kb

pub trait Plugin {
    fn name(&self) -> &str;
    fn execute(&self);
    // 1. Finish the trait
}
pub struct PluginManager {
    pub plugins: Vec<Box<dyn Plugin>>, // 2. Finish the struct
                                       // Make fields public
}
// 3. Implement the PluginManager
impl PluginManager {
    pub fn new() -> Self {
        Self { plugins: vec![] }
    }
    pub fn add_plugin(&mut self, item: Box<dyn Plugin>) {
        if self
            .plugins
            .iter()
            .any(|plugin| plugin.name() == item.name())
        {
            panic!("Plugin with name '{}' already exists", item.name());
        }
        self.plugins.push(item);
    }
    pub fn remove_plugin(&mut self, name: &str) -> Option<Box<dyn Plugin>> {
        if let Some(pos) = self.plugins.iter().position(|p| p.name() == name) {
            Some(self.plugins.remove(pos))
        } else {
            None
        }
    }
    pub fn execute_all(&self) {
        self.plugins.iter().for_each(|plugin| plugin.execute());
    }
}

Wouter

WouterMartens

a month ago

3.55ms

88.19kb

pub trait Plugin {
    fn name(&self) -> &str;
    fn execute(&self);
}
pub struct PluginManager {
    pub plugins: Vec<Box<dyn Plugin>>,
}
pub struct MyPlugin {
    name: String,
}
impl MyPlugin {
    pub fn new() -> Self {
        Self {
            name: "MyPlugin".to_string(),
        }
    }
}
impl Plugin for MyPlugin {
    fn name(&self) -> &str {
        &self.name
    }
    fn execute(&self) {
        println!("{}: Executing...", self.name())
    }
}
impl PluginManager {
    pub fn new() -> Self {
        Self { plugins: Vec::new() }
    }
    pub fn add_plugin(&mut self, plugin: Box<dyn Plugin>) {
        if self.plugins.iter().any(|p| p.name() == plugin.name()) {
            panic!("Plugin with name '{}' already exists", plugin.name()); 
        }
        self.plugins.push(plugin);
    }
    
    pub fn remove_plugin(&mut self, name: &str) -> Option<Box<dyn Plugin>> {
        if let Some(position) = self.plugins.iter().position(|p| p.name() == name) {
            Some(self.plugins.remove(position))
        } else {
            None
        }
    }
    pub fn execute_all(&self) {
        for plugin in &self.plugins {
            plugin.execute();
        }
    }
}
pub fn main() {
    let mut manager = PluginManager::new();
    manager.add_plugin(Box::new(MyPlugin::new()));
    manager.execute_all();
}

Andy Randrianirina

andyslash

a month ago

3.89ms

88.19kb

pub trait Plugin {
    // 1. Finish the trait
    fn name(&self) -> &str;
    fn execute(&self);
}
pub struct PluginManager {
    pub plugins: Vec<Box<dyn Plugin>>,
    // 2. Finish the struct
    // Make fields public
}
pub struct MyPlugin;
impl MyPlugin {
    pub fn new() -> Self {
        Self {}
    }
}
impl Plugin for MyPlugin {
    fn name(&self) -> &str {
        "MyPlugin"
    }
    fn execute(&self) {
        println!("MyPlugin executed.");
    }
}
// 3. Implement the PluginManager
impl PluginManager {
    pub fn new() -> Self {
        PluginManager {
            plugins: vec![],
        }
    }
    pub fn add_plugin(&mut self, plugin: Box<dyn Plugin>){
        if self.plugins.iter().any(|plg| plg.name() == plugin.name()) {
            panic!("Plugin with name '{}' already exists", plugin.name())
        }
        self.plugins.push(plugin)
    }
    pub fn remove_plugin(&mut self, name: &str) -> Option<Box<dyn Plugin>> {
        if let Some(index) = self.plugins.iter().position(|p| p.name() == name) {
            Some(self.plugins.remove(index))
        } else {
            None
        }
    }
    pub fn execute_all(&self) {
        self.plugins.iter().for_each(|x| x.execute());
    }
}
// Example usage
pub fn main() {
    let mut manager = PluginManager::new();
    manager.add_plugin(Box::new(MyPlugin::new()));
    manager.execute_all();
}

Daniel Mestas

miel-codeai

a month ago

3.43ms

88.19kb

pub trait Plugin {
    fn name(&self) -> &str;
    fn execute(&self);
}
pub struct PluginManager {
    pub plugins: Vec<Box<dyn Plugin>>,
}
impl PluginManager {
    pub fn new() -> Self {
        Self {
            plugins: Vec::new(),
        }
    }
    pub fn add_plugin(&mut self, plugin: Box<dyn Plugin>) {
        if self.plugins.iter().any(|plg| plg.name() == plugin.name()) {
            panic!("Plugin with name '{}' already exists", plugin.name())
        }
        self.plugins.push(plugin);
    }
    pub fn remove_plugin(&mut self, name: &str) -> Option<Box<dyn Plugin>> {
        let index = self.plugins.iter().position(|plg| plg.name() == name)?;
        Some(self.plugins.remove(index))
    }
    pub fn execute_all(&self) {
        self.plugins.iter().for_each(|plugin| plugin.execute());
    }
}
// Example usage
// pub fn main() {
//     let mut manager = PluginManager::new();
//     manager.add_plugin(Box::new(MyPlugin::new()));
//     manager.execute_all();
// }

Rocky.C

cloki0610

a month ago

4.81ms

88.19kb

pub trait Plugin {
    // 1. Finish the trait
    fn name(&self) -> &str;
    fn execute(&self);
}
pub struct PluginManager {
    // 2. Finish the struct
    // Make fields public
    pub plugins: Vec<Box<dyn Plugin>>,
}
// 3. Implement the PluginManager
impl PluginManager {
    pub fn new() -> Self {
        Self {
            plugins: vec![]
        }
    }
    pub fn add_plugin(&mut self, plugin: Box<dyn Plugin>) {
        if self.plugins.iter().any(|p| p.name() == plugin.name()) {
            panic!("Plugin with name '{}' already exists", plugin.name());
        }
        self.plugins.push(plugin);
    }
    pub fn remove_plugin(&mut self, name: &str) -> Option<Box<dyn Plugin>> {
        if let Some(index) = self.plugins.iter().position(|p| p.name() == name) {
            Some(self.plugins.remove(index))
        } else {
            None
        }
    }
    pub fn execute_all(&self) {
        for plugin in &self.plugins {
            plugin.execute();
        }
    }
}
pub struct MyPlugin;
impl MyPlugin {
    pub fn new() -> Self {
        Self {}
    }
}
impl Plugin for MyPlugin {
    fn name(&self) -> &str {
        "MyPlugin"
    }
    fn execute(&self) {
        println!("MyPlugin executed.");
    }
}
// Example usage
pub fn main() {
    let mut manager = PluginManager::new();
    manager.add_plugin(Box::new(MyPlugin::new()));
    manager.execute_all();
}

m1031

monorail103

a month ago

4.49ms

88.19kb

pub trait Plugin {
    // 1. Finish the trait
    fn name(&self) -> &str;
    fn execute(&self);
}
pub struct PluginManager {
    // 2. Finish the struct
    // Make fields public
    pub plugins: Vec<Box<dyn Plugin>>,
}
// 3. Implement the PluginManager
impl PluginManager {
    pub fn new() -> Self {
        Self {
            plugins: vec![]
        }
    }
    pub fn add_plugin(&mut self, plugin: Box<dyn Plugin>) {
        if self.plugins.iter().any(|p| p.name() == plugin.name()) {
            panic!("Plugin with name '{}' already exists", plugin.name());
        }
        self.plugins.push(plugin);
    }
    pub fn remove_plugin(&mut self, name: &str) -> Option<Box<dyn Plugin>> {
        if let Some(index) = self.plugins.iter().position(|p| p.name() == name) {
            Some(self.plugins.remove(index))
        } else {
            None
        }
    }
    pub fn execute_all(&self) {
        for plugin in &self.plugins {
            plugin.execute();
        }
    }
}
pub struct MyPlugin{}
impl MyPlugin {
    pub fn new() -> Self {
        Self {}
    }
}
impl Plugin for MyPlugin {
    fn name(&self) -> &str {
        "MyPlugin"
    }
    fn execute(&self) {
        println!("aaa");
    }
}
// Example usage
pub fn main() {
    let mut manager = PluginManager::new();
    manager.add_plugin(Box::new(MyPlugin::new()));
    manager.execute_all();
}

Fatih

0fatih

a month ago

3.61ms

88.19kb

pub trait Plugin {
    // 1. Finish the trait
    fn name(&self) -> &str;
    fn execute(&self);
}
pub struct PluginManager {
    // 2. Finish the struct
    // Make fields public
    pub plugins: Vec<Box<dyn Plugin>>
    
}
// 3. Implement the PluginManager
impl PluginManager {
    pub fn new() -> Self {
        Self {
            plugins: vec![]
        }
    }
    pub fn add_plugin(&mut self, plugin: Box<dyn Plugin>) {
        for p in &self.plugins {
            if p.name() == plugin.name() {
                panic!("{}",format!("Plugin with name '{}' already exists", plugin.name()))
            }
        }
        self.plugins.push(plugin);
    }
    pub fn remove_plugin(&mut self, name: &str) -> Option<Box<dyn Plugin>> {
        // Find the index of the plugin to remove
        let index = self.plugins.iter().position(|plugin| plugin.name() == name);
        // If an index is found, remove and return the plugin
        if let Some(i) = index {
            Some(self.plugins.remove(i))
        } else {
            None // Plugin not found
        }    
    }
    pub fn execute_all(&self) {
        for p in &self.plugins {
            p.execute()
        }
    }
}
pub struct MyPlugin {}
impl MyPlugin {
    pub fn new() -> Self {
        Self {}
    }
}
impl Plugin for MyPlugin {
            fn name(&self) -> &str {
            "yo"
        }
    fn execute(&self) {
        println!("ye")
    }
}
// Example usage
pub fn main() {
    let mut manager = PluginManager::new();
    manager.add_plugin(Box::new(MyPlugin::new()));
    manager.execute_all();
}

slaws

a month ago

3.12ms

87.93kb


pub trait Plugin {
    // 1. Finish the trait
    fn name(&self) -> &str;
    fn execute(&self);
}
pub struct PluginManager {
    // 2. Finish the struct
    // Make fields public
    pub plugins: Vec<Box<dyn Plugin>>
}
pub struct MyPlugin {
    name: String,
}
impl MyPlugin {
    pub fn new() -> Self {
        Self {
            name: "MyPlugin".into(),
        }
    }
}
impl Plugin for MyPlugin {
    fn name(&self) -> &str {
        &self.name
    }
    fn execute(&self) {
        println!("{}: Executing...", self.name)
    }
}
// 3. Implement the PluginManager
impl PluginManager {
    pub fn new() -> Self {
        PluginManager { plugins: Vec::new() }
    }
    pub fn add_plugin(&mut self, plugin: Box<dyn Plugin>) {
        let name = plugin.name();
        if self.plugins.iter().any(|x| x.name() == name.to_string() ){
            panic!("Plugin with name '{name}' already exists");
        }
        self.plugins.push(plugin);
    }
    pub fn remove_plugin(&mut self,name: &str) -> Option<Box<dyn Plugin>>{
        if let Some(idx) = self.plugins.iter().position(|x| x.name() == name.to_string() ) {
            return Some(self.plugins.remove(idx))
        }
        None
    }
    pub fn execute_all(&self) {
        for v in &self.plugins {
            v.execute();
        }
    }
}
// Example usage
pub fn main() {
    let mut manager = PluginManager::new();
    manager.add_plugin(Box::new(MyPlugin::new()));
    manager.execute_all();
}

Evrins Hu

evrins

a month ago

3.78ms

88.27kb

use std::collections::HashMap;
pub trait Plugin {
    // 1. Finish the trait
    fn name(&self) -> &str;
    fn execute(&self);
}
pub struct PluginManager {
    // 2. Finish the struct
    // Make fields public
    pub plugins: HashMap<String, Box<dyn Plugin>>,
}
// 3. Implement the PluginManager
impl PluginManager {
    pub fn new() -> Self {
        Self {
            plugins: HashMap::new(),
        }
    }
    pub fn add_plugin(&mut self, plugin: Box<dyn Plugin>) {
        if self.plugins.contains_key(plugin.name()) {
            panic!("Plugin with name '{}' already exists!", plugin.name());
        }
        self.plugins.insert(plugin.name().into(), plugin);
    }
    pub fn remove_plugin(&mut self, name: &str) -> Option<Box<dyn Plugin>> {
        self.plugins.remove(name)
    }
    pub fn execute_all(&self) {
        for plugin in self.plugins.values() {
            plugin.execute()
        }
    }
}
pub struct MyPlugin {
    pub name: String,
}
impl MyPlugin {
    pub fn new() -> Self {
        Self {
            name: "MyPlugin".into(),
        }
    }
}
impl Plugin for MyPlugin {
    fn name(&self) -> &str {
        self.name.as_str()
    }
    fn execute(&self) {
        println!("Execute plugin {}", self.name);
    }
}
// Example usage
pub fn main() {
    let mut manager = PluginManager::new();
    manager.add_plugin(Box::new(MyPlugin::new()));
    manager.execute_all();
}

johndoe30bc

a month ago

3.52ms

88.19kb

pub trait Plugin {
    fn name(&self) -> &str;
    fn execute(&self);
}
pub struct PluginManager {
    pub plugins: Vec<Box<dyn Plugin>>,
}
impl PluginManager {
    pub fn new() -> Self {
        Self {
            plugins: Vec::new(),
        }
    }
    pub fn add_plugin(&mut self, plugin: Box<dyn Plugin>) {
        let name = plugin.name();
        if self.plugins.iter().any(|x| x.name() == name) {
            panic!("Plugin with name '{name}' already exists");
        }
        self.plugins.push(plugin);
    }
    pub fn remove_plugin(&mut self, name: &str) -> Option<Box<dyn Plugin>> {
        if let Some(idx) = self.plugins.iter().position(|x| x.name() == name) {
            Some(self.plugins.remove(idx))
        } else {
            None
        }
    }
    pub fn execute_all(&self) {
        self.plugins.iter().for_each(|x| x.execute());
    }
}
pub struct MyPlugin {
    pub name: String,
}
impl MyPlugin {
    pub fn new() -> Self {
        Self {
            name: "MyPlugin".to_string(),
        }
    }
}
impl Plugin for MyPlugin {
    fn name(&self) -> &str {
        &self.name
    }
    fn execute(&self) {
        println!("Executing plugin: {}", self.name)
    }
}
// Example usage
pub fn main() {
    let mut manager = PluginManager::new();
    manager.add_plugin(Box::new(MyPlugin::new()));
    manager.execute_all();
}

Baron Curtin

baroncurtin2

a month ago

3.49ms

88.14kb

use std::collections::HashSet;
pub trait Plugin {
    fn name(&self) -> &str;
    fn execute(&self);
}
pub struct PluginManager {
    pub plugins: Vec<Box<dyn Plugin>>,
    plugin_names: HashSet<String>,
}
// 3. Implement the PluginManager
impl PluginManager {
    pub fn new() -> Self {
        Self {
            plugins: vec![],
            plugin_names: HashSet::new(),
        }
    }
    pub fn add_plugin(&mut self, plugin: Box<dyn Plugin>) {
        if self.plugin_names.contains(plugin.name()) {
            panic!("Plugin with name '{}' already exists", plugin.name());
        }
        self.plugin_names.insert(plugin.name().to_string());
        self.plugins.push(plugin);
    }
    pub fn remove_plugin(&mut self, name: &str) -> Option<Box<dyn Plugin>> {
        if let Some(index) = self.plugins.iter().position(|p| p.name() == name) {
            self.plugin_names.remove(name);
            return Some(self.plugins.swap_remove(index))
        } else {
            None
        }
    }
    pub fn execute_all(&self) {
        self.plugins.iter().for_each(|p| p.execute());
    }
}
pub struct MyPlugin {
    name: String,
}
impl MyPlugin {
    pub fn new() -> Self {
        Self {
            name: "MyPlugin".into(),
        }
    }
}
impl Plugin for MyPlugin {
    fn name(&self) -> &str {
        &self.name
    }
    fn execute(&self) {
        println!("{}: Executing...", self.name)
    }
}
// Example usage
pub fn main() {
    let mut manager = PluginManager::new();
    manager.add_plugin(Box::new(MyPlugin::new()));
    manager.execute_all();
}

AtlasVakyrie

a month ago

3.37ms

88.19kb

pub trait Plugin {
    // 1. Finish the trait
    fn name(&self) -> &str;
    fn execute(&self);
}
pub struct PluginManager {
    // 2. Finish the struct
    // Make fields public
    pub plugins: Vec<Box<dyn Plugin>>,
}
// 3. Implement the PluginManager
impl PluginManager {
    pub fn new() -> Self {
        PluginManager {
            plugins: Vec::new(),
        }
    }
    pub fn add_plugin(&mut self, plugin: Box<dyn Plugin>) {
        if self.plugins.iter().any(|p| p.name() == plugin.name()) {
            panic!("Plugin with name '{}' already exists", plugin.name());
        }
        self.plugins.push(plugin);
    }
    pub fn remove_plugin(&mut self, name: &str) -> Option<Box<dyn Plugin>> {
        // self.plugins.retain(|plugin| plugin.name() != name);
        if let Some(index) = self.plugins.iter().position(|p| p.name() == name) {
            Some(self.plugins.remove(index))
        } else {
            None
        }
    }
    pub fn execute_all(&self) {
        self.plugins.iter().for_each(|plugin| plugin.execute());
        }
}
pub struct MyPlugin {
    name: String,
}
// 4. Implement the MyPlugin
impl MyPlugin {
    pub fn new() -> Self {
        MyPlugin {
            name: String::from("MyPlugin"),
        }
    }
}
impl Plugin for MyPlugin {
    fn name(&self) -> &str {
        &self.name
    }
    fn execute(&self) {
        println!("Executing {}", self.name);
    }
}
// Example usage
pub fn main() {
    let mut manager = PluginManager::new();
    manager.add_plugin(Box::new(MyPlugin::new()));
    manager.execute_all();
}

xxxxsk

a month ago

3.85ms

88.19kb

pub trait Plugin {
    // 1. Finish the trait
    fn name(&self) -> &str;
    fn execute(&self);
}
pub struct PluginManager {
    // 2. Finish the struct
    // Make fields public
    pub plugins: Vec<Box<dyn Plugin>>,
}
// 3. Implement the PluginManager
impl PluginManager {
    pub fn new() -> Self {
        PluginManager {
            plugins: Vec::new(),
        }
    }
    pub fn add_plugin(&mut self, plugin: Box<dyn Plugin>) {
        if self.plugins.iter().any(|p| p.name() == plugin.name()) {
            panic!("Plugin with name '{}' already exists", plugin.name());
        }
        self.plugins.push(plugin);
    }
    pub fn remove_plugin(&mut self, name: &str) -> Option<Box<dyn Plugin>> {
        // self.plugins.retain(|plugin| plugin.name() != name);
        if let Some(index) = self.plugins.iter().position(|p| p.name() == name) {
            Some(self.plugins.remove(index))
        } else {
            None
        }
    }
    pub fn execute_all(&self) {
        self.plugins.iter().for_each(|plugin| plugin.execute());
        }
}
pub struct MyPlugin {
    name: String,
}
// 4. Implement the MyPlugin
impl MyPlugin {
    pub fn new() -> Self {
        MyPlugin {
            name: String::from("MyPlugin"),
        }
    }
}
impl Plugin for MyPlugin {
    fn name(&self) -> &str {
        &self.name
    }
    fn execute(&self) {
        println!("Executing {}", self.name);
    }
}
// Example usage
pub fn main() {
    let mut manager = PluginManager::new();
    manager.add_plugin(Box::new(MyPlugin::new()));
    manager.execute_all();
}

Evgenii Grigorenko

grevgeny

a month ago

3.57ms

88.27kb

use std::collections::HashMap;
pub trait Plugin {
    fn name(&self) -> &str;
    fn execute(&self);
}
pub struct MyPlugin {
    pub name: String
}
impl MyPlugin {
    pub fn new() -> Self {
        Self {
            name: String::from("MyPlugin")
        }
    }
}
impl Plugin for MyPlugin {
    fn name(&self) -> &str {
        &self.name
    }
    fn execute(&self) {}
}
pub struct PluginManager {
    pub plugins: HashMap<String, Box<dyn Plugin>>
}
// 3. Implement the PluginManager
impl PluginManager {
    pub fn new() -> Self {
        Self {
            plugins: HashMap::new()
        }
    }
    pub fn add_plugin(&mut self, plugin: Box<dyn Plugin>) {
        if self.plugins.contains_key(plugin.name()) {
            panic!("Plugin with name '{}' already exists", plugin.name());
        }
        self.plugins.insert(plugin.name().to_owned(), plugin);
    }
    pub fn remove_plugin(&mut self, plugin_name: impl AsRef<str>) -> Option<Box<dyn Plugin>> {
        self.plugins.remove(plugin_name.as_ref())
    }
    pub fn execute_all(&self) {
        for plugin in self.plugins.values() {
            plugin.execute();
        }
    }
}
// Example usage
pub fn main() {
    let mut manager = PluginManager::new();
    manager.add_plugin(Box::new(MyPlugin::new()));
    manager.execute_all();
}

FredoPo

2 months ago

3.52ms

88.19kb

pub trait Plugin {
    // 1. Finish the trait
    fn name(&self) -> &str;
    fn execute(&self);
}
pub struct PluginManager {
    // 2. Finish the struct
    // Make fields public
    pub plugins: Vec<Box<dyn Plugin>>
}
pub struct MyPlugin {
    pub name: String
}
impl MyPlugin {
    pub fn new() -> Self {
        Self {
            name: "Test".to_string()
        }
    }
}
impl Plugin for MyPlugin {
    fn name(&self) -> &str {
        &self.name
    }
    fn execute(&self) {
    }
}
// 3. Implement the PluginManager
impl PluginManager {
    pub fn new() -> Self {
        PluginManager{
            plugins: Vec::new()
        }
    }
    pub fn add_plugin(&mut self, plugin: Box<dyn Plugin>) {
        let existing = self.plugins.iter().filter(|val| val.name() == plugin.name());
        if existing.count() > 0 {
            panic!("Plugin with name '{}' already exists", plugin.name())
        }
        self.plugins.push(plugin);
    }
    pub fn remove_plugin(&mut self, name: &str) -> Option<Box<dyn Plugin>> {
        let mut index = 0;
        for plugin_tmp in &self.plugins {
            if plugin_tmp.name() == name {
                return Some(self.plugins.remove(index));
            }
            index +=1;
        }
        None
    }
    pub fn execute_all(&self) {
        self.plugins.iter().for_each(|plugin| plugin.execute());
    }
}
// Example usage
pub fn main() {
    let mut manager = PluginManager::new();
    manager.add_plugin(Box::new(MyPlugin::new()));
    manager.execute_all();
}

Procybit

2 months ago

3.82ms

88.27kb

use std::collections::HashMap;
pub trait Plugin {
    fn name(&self) -> &str;
    fn execute(&self);
}
pub struct PluginManager {
    pub plugins: HashMap<String, Box<dyn Plugin>>,
}
// 3. Implement the PluginManager
impl PluginManager {
    pub fn new() -> Self {
        Self {
            plugins: HashMap::new(),
        }
    }
    pub fn add_plugin(&mut self, plugin: Box<dyn Plugin>) {
        if self.plugins.contains_key(plugin.name()) {
            panic!("Plugin with name '{}' already exists", plugin.name())
        }
        self.plugins.insert(plugin.name().to_string(), plugin);
    }
    pub fn remove_plugin(&mut self, name: &str) -> Option<Box<dyn Plugin>> {
        self.plugins.remove(name)
    }
    pub fn execute_all(&self) {
        for (_, p) in &self.plugins {
            p.execute();
        }
    }
}
// // Example usage
// pub fn main() {
//     let mut manager = PluginManager::new();
//     manager.add_plugin(Box::new(MyPlugin::new()));
//     manager.execute_all();
// }

brucecox01

2 months ago

3.57ms

88.20kb

pub trait Plugin {
    // 1. Finish the trait
    fn name(&self) -> &str;
    fn execute(&self);
}
pub struct MyPlugin {
    pub name: String,
}
impl MyPlugin {
    pub fn new() -> Self {
        MyPlugin { name: "test".to_string(), }
    }
    pub fn new_with_name(name: String) -> Self {
        MyPlugin { name, }
    }
}
impl Plugin for MyPlugin {
    fn name(&self) -> &str {
        &self.name
    }
    fn execute(&self) {
        println!("Executing {}", self.name);
    }
}
pub struct PluginManager {
    // 2. Finish the struct
    // Make fields public
    pub plugins: Vec<Box<dyn Plugin>>,
}
// 3. Implement the PluginManager
impl PluginManager {
    pub fn new() -> Self {
        PluginManager {
            plugins: vec![]
        }
    }
    pub fn add_plugin(&mut self, plugin: Box<dyn Plugin>) {
        let name = plugin.name();
        for p in self.plugins.iter() {
            if *p.name() == *name {
                panic!("Plugin with name '{}' already exists.", name);
            }
        }
        self.plugins.push(plugin);
    }
    pub fn remove_plugin(&mut self, name: &str) -> Option<Box<dyn Plugin>> {
        for (i, p) in self.plugins.iter().enumerate() {
            if *p.name() == *name {
                return Some(self.plugins.remove(i));
            }
        }
        None
    }
    pub fn execute_all(&self) {
        for p in self.plugins.iter() {
            p.execute();
        }
    }
}
// Example usage
pub fn main() {
    let mut manager = PluginManager::new();
    manager.add_plugin(Box::new(MyPlugin::new()));
    manager.execute_all();
}

Miguel Ángel Allende

maallende

2 months ago

3.82ms

88.19kb

pub trait Plugin {
    // 1. Finish the trait
    fn name(&self) -> &str;
    fn execute(&self);
}
pub struct PluginManager {
    // 2. Finish the struct
    // Make fields public
   pub plugins: Vec<Box<dyn Plugin>>,
}
#[derive(Clone, Debug)]
pub struct MyPlugin {
    pub name: String,
}
impl MyPlugin {
    pub fn new() -> Self {
        MyPlugin {
            name: Default::default()
        }
    }
}
impl Plugin for MyPlugin {
    // 1. Implement the Plugin trait
    fn name(&self) -> &str {
        &self.name
    }
    fn execute(&self) {
        println!("Executing plugin: {}", self.name);
    }
}
// 3. Implement the PluginManager
impl PluginManager {
     pub fn new() -> Self {
        PluginManager {
            plugins: Vec::new(),
        }
    }
    pub fn add_plugin(&mut self, plugin: Box<dyn Plugin>) {
        if self.plugins.iter().any(|p| p.name() == plugin.name()) {
            panic!("Plugin with name '{}' already exists", plugin.name());
        }
        self.plugins.push(plugin);
    }   
    pub fn remove_plugin(&mut self, name: &str) -> Option<Box<dyn Plugin>> {
        if let Some(pos) = self.plugins.iter().position(|p| p.name() == name) {
            Some(self.plugins.remove(pos))
        } else {
            None
        }
    }
    pub fn execute_all(&self) {
        for plugin in &self.plugins {
            plugin.execute();
        }
    }       
}
// Example usage
pub fn main() {
    let mut manager = PluginManager::new();
    manager.add_plugin(Box::new(MyPlugin::new()));
    manager.execute_all();
}

Krzysztof Atłasik

katlasik

2 months ago

3.47ms

88.19kb

pub trait Plugin {
  fn name(&self) -> &str;
  fn execute(&self);
}
pub struct PluginManager {
  pub plugins: Vec<Box<dyn Plugin>>
}
// 3. Implement the PluginManager
impl PluginManager {
  pub fn new() -> Self {
    PluginManager {
      plugins: Vec::new(),
    }
  }
  fn validate_no_plugin_with_name(&self, name: &str) {
    if self.plugins.iter().any(|plugin| plugin.name() == name) {
      panic!("Plugin with name '{name}' already exists");
    }
  }
  pub fn add_plugin(&mut self, plugin: Box<dyn Plugin>) {
    self.validate_no_plugin_with_name(plugin.name());
    self.plugins.push(plugin);
  }
  pub fn remove_plugin(&mut self, name: &str)  -> Option<Box<dyn Plugin>> {
    self.plugins.iter()
      .position(|plugin| plugin.name() == name)
      .map(|index| self.plugins.remove(index))
  }
  pub fn execute_all(&self) {
    self.plugins.iter().for_each(|plugin| plugin.execute())
  }
}

coreyralph

2 months ago

3.65ms

88.24kb

pub trait Plugin {
    fn name(&self) -> &str;
    fn execute(&self);
}
pub struct PluginManager {
    pub plugins: Vec<Box<dyn Plugin>>
}
impl PluginManager {
    pub fn new() -> Self {
        Self { plugins: vec![] }
    }
    pub fn add_plugin<T: Plugin + 'static>(&mut self, plugin: Box<T>) {
        if self.plugins.iter().any(|e| e.name() == plugin.name()) {
            panic!("Plugin with name '{}' already exists", plugin.name())
        }
        self.plugins.push(plugin);
    }
    pub fn remove_plugin(&mut self, name: &str) -> Option<Box<(dyn Plugin + 'static)>> {
        if let Some(index) = self.plugins.iter().position(|e| e.name() == name ) {
            return Some(self.plugins.remove(index));
        }
        return None
    }
    pub fn execute_all(&self) {
    }
}
pub struct MyPlugin {}
impl MyPlugin {
    pub fn new() -> Self {
        Self{}
    }
}
impl Plugin for MyPlugin {
    fn name(&self) -> &str {
        "MyPlugin"
    }
    fn execute(&self) {
        
    }
}
// Example usage
pub fn main() {
    let mut manager = PluginManager::new();
    manager.add_plugin(Box::new(MyPlugin::new()));
    manager.execute_all();
}

medzernik

2 months ago

3.46ms

88.19kb

pub trait Plugin {
    // 1. Finish the trait
    fn name(&self) -> &str;
    fn execute(&self); 
}
pub struct MyPlugin {name: String}
pub struct PluginManager {
    // 2. Finish the struct
    // Make fields public
    pub plugins: Vec<Box<dyn Plugin>>
}
impl Plugin for MyPlugin {
    fn name(&self) -> &str {
        &self.name
    }
    fn execute(&self){}
}
impl MyPlugin {
    pub fn new() -> Self {
        Self {name: "testing name".to_string()}
    } 
}
// 3. Implement the PluginManager
impl PluginManager {
    pub fn new() -> Self {
        Self {
            plugins: Vec::new()
        }
    }
    pub fn add_plugin(&mut self, plugin: Box<dyn Plugin>) {
        if self.plugins.iter().any(|x| x.name() == plugin.name()) {
            panic!("Plugin with name '{}' already exists", plugin.name())
        }
        self.plugins.push(plugin);
    }
    pub fn remove_plugin(&mut self, name: &str) -> Option<Box<dyn Plugin>> {
        self.plugins
            .iter()
            .position(|x| x.name() == name)
            .map(|x| self.plugins.remove(x))
            
    }
    pub fn execute_all(&self) {
        self.plugins.iter().for_each(|x| x.execute());
    }
}
// Example usage
pub fn main() {
    let mut manager = PluginManager::new();
    manager.add_plugin(Box::new(MyPlugin::new()));
    manager.execute_all();
}

Philippe Massicotte

PMassicotte

2 months ago

4.17ms

88.19kb

pub trait Plugin {
    fn name(&self) -> &str;
    fn execute(&self);
}
pub struct PluginManager {
    // 2. Finish the struct
    pub plugins: Vec<Box<dyn Plugin>>,
}
// 3. Implement the PluginManager
impl PluginManager {
    pub fn new() -> Self {
        PluginManager {
            plugins: Vec::new(),
        }
    }
    pub fn add_plugin(&mut self, plugin: Box<dyn Plugin>) {
        if self.plugins.iter().any(|p| p.name() == plugin.name()) {
            panic!("Plugin with name '{}' already exists", plugin.name());
        }
        self.plugins.push(plugin);
    }
    pub fn remove_plugin(&mut self, name: &str) -> Option<Box<dyn Plugin>> {
        self.plugins
            .iter()
            .position(|p| p.name() == name)
            .map(|i| self.plugins.remove(i))
    }
    pub fn execute_all(&self) {
        self.plugins.iter().for_each(|p| p.execute());
    }
}
pub struct MyPlugin;
impl MyPlugin {
    fn new() -> MyPlugin {
        MyPlugin {}
    }
}
impl Plugin for MyPlugin {
    fn name(&self) -> &str {
        "MyPlugin"
    }
    fn execute(&self) {
        println!("Executing {}", self.name());
    }
}
// Example usage
pub fn main() {
    let mut manager = PluginManager::new();
    manager.add_plugin(Box::new(MyPlugin::new()));
    manager.execute_all();
}

gsspdev

2 months ago

3.25ms

88.20kb

pub trait Plugin {
    // 1. Finish the trait
    fn name(&self) -> &str;
    fn execute(&self);
}
pub struct PluginManager {
    // 2. Finish the struct
    // Make fields public
    pub plugins: Vec<Box<dyn Plugin>>,
}
// 3. Implement the PluginManager
impl PluginManager {
    pub fn new() -> Self {
        PluginManager {
            plugins: Vec::new(),
        }
    }
    pub fn add_plugin(&mut self, plugin: Box<dyn Plugin>) {
        if self.plugins.iter().any(|plg| plg.name() == plugin.name()) {
            panic!("Plugin with name '{}' already exists!", plugin.name())
        }
        self.plugins.push(plugin);
    }
    pub fn remove_plugin(&mut self, name: &str) -> Option<Box<dyn Plugin>> {
        if let Some(index) = self.plugins.iter().position(|p| p.name() == name) {
            return Some(self.plugins.remove(index))
        } 
        None
    }
    pub fn execute_all(&self) {
        for plugin in &self.plugins {
            plugin.execute()
        }
    }
}
// Example usage
// pub fn main() {
//     let mut manager = PluginManager::new();
//     manager.add_plugin(Box::new(MyPlugin::new()));
    // manager.execute_all();
// }

Herman effendi

hrmneffdii

2 months ago

3.40ms

88.19kb

pub trait Plugin {
    fn name(&self) -> &str;
    fn execute(&self);
}
pub struct PluginManager {
    // 2. Finish the struct
    // Make fields public
    pub plugins: Vec<Box<dyn Plugin>>,
}
// 3. Implement the PluginManager
impl PluginManager {
    pub fn new() -> Self {
        PluginManager {
            plugins: Vec::new(),
        }
    }
    pub fn add_plugin(&mut self, plugin: Box<dyn Plugin>) {
        if self.plugins.iter().any(|plg| plg.name() == plugin.name()) {
            panic!("Plugin with name '{}' already exists", plugin.name())
        }
        self.plugins.push(plugin);
    }
    pub fn execute_all(&self) {
        self.plugins.iter().for_each(|plg| plg.execute());
    }
    pub fn remove_plugin(&mut self, name: &str) -> Option<Box<dyn Plugin>> {
        let i = self.plugins.iter().position(|plg| plg.name() == name)?;
        Some(self.plugins.remove(i))
    }
}
// Example usage
// pub fn main() {
//     let mut manager = PluginManager::new();
//     manager.add_plugin(Box::new(MyPlugin::new()));
//     manager.execute_all();
// }

Ushakov Andrey

stdstring

2 months ago

3.85ms

88.66kb

pub trait Plugin {
    // 1. Finish the trait
    fn name(&self) -> &str;
    fn execute(&self);
}
pub struct PluginManager {
    // 2. Finish the struct
    // Make fields public
    pub plugins: Vec<Box<dyn Plugin>>
}
impl PluginManager {
    pub fn new() -> Self {
        PluginManager{plugins: Vec::new()}
    }
    pub fn add_plugin(&mut self, plugin: Box<dyn Plugin>) {
        if self.plugins.iter().any(|x| x.name() == plugin.name()) {
            panic!("dublicate plugin by name")
        }
        self.plugins.push(plugin);
    }
    pub fn remove_plugin(&mut self, name: &str) -> Option<Box<dyn Plugin>> {
        let index = self.plugins.iter().position(|x| x.name() == name)?;
        Some(self.plugins.remove(index))
    }
    pub fn execute_all(&self) {
        for plugin in self.plugins.iter() {
            plugin.execute();
        }
    }
}
pub struct MyPlugin {}
impl MyPlugin {
    pub fn new() -> Self {
        MyPlugin{}
    }
}
impl Plugin for MyPlugin {
    fn name(&self) -> &str {
        "IDDQD"
    }
    fn execute(&self) {}
}
// 3. Implement the PluginManager
// Example usage
pub fn main() {
    let mut manager = PluginManager::new();
    manager.add_plugin(Box::new(MyPlugin::new()));
    manager.execute_all();
}

esl

esl07

2 months ago

3.40ms

88.19kb

pub trait Plugin {
    fn name(&self) -> &str;
    fn execute(&self);
}
pub struct PluginManager {
    // 2. Finish the struct
    // Make fields public
    pub plugins: Vec<Box<dyn Plugin>>,
}
// 3. Implement the PluginManager
impl PluginManager {
    pub fn new() -> Self {
        PluginManager {
            plugins: Vec::new(),
        }
    }
    pub fn add_plugin(&mut self, plugin: Box<dyn Plugin>) {
        if self.plugins.iter().any(|plg| plg.name() == plugin.name()) {
            panic!("Plugin with name '{}' already exists", plugin.name())
        }
        self.plugins.push(plugin);
    }
    pub fn execute_all(&self) {
        self.plugins.iter().for_each(|plg| plg.execute());
    }
    pub fn remove_plugin(&mut self, name: &str) -> Option<Box<dyn Plugin>> {
        let i = self.plugins.iter().position(|plg| plg.name() == name)?;
        Some(self.plugins.remove(i))
    }
}
// Example usage
// pub fn main() {
//     let mut manager = PluginManager::new();
//     manager.add_plugin(Box::new(MyPlugin::new()));
//     manager.execute_all();
// }

alexsavio

2 months ago

3.75ms

88.33kb

use std::collections::BTreeMap;
pub trait Plugin {
    // 1. Finish the trait
    fn name(&self) -> &str;
    fn execute(&self);
}
type PluginContainer = BTreeMap<String, Box<dyn Plugin>>;
pub struct PluginManager {
    // 2. Finish the struct
    pub plugins: PluginContainer,
}
// 3. Implement the PluginManager
impl PluginManager {
    pub fn new() -> Self {
        PluginManager { 
            plugins: PluginContainer::new(),
        }
    }
    pub fn add_plugin(&mut self, plugin: Box<dyn Plugin>) {
        let plugin_name = plugin.name().to_string();
        if let Some(_) = self.plugins.insert(plugin_name.clone(), plugin) {
            panic!("Plugin with name '{}' already exists", plugin_name)
        }
    }
    pub fn remove_plugin(&mut self, name: &str) -> Option<Box<dyn Plugin>> {
        self.plugins.remove(name)
    }
    pub fn execute_all(&self) {
        self.plugins.iter().for_each(|(_, p)| p.execute());
    }    
}
pub struct MyPlugin;
impl Plugin for MyPlugin {
    fn name(&self) -> &str {
        "MyPlugin"
    }
    
    fn execute(&self) {
        println!("{} executed.", self.name());
    }
}
impl MyPlugin {
    pub fn new() -> Self {
        MyPlugin {}
    }
}
// Example usage
pub fn main() {
    let mut manager = PluginManager::new();
    manager.add_plugin(Box::new(MyPlugin::new()));
    manager.execute_all();
}

alexsavio

2 months ago

4.64ms

88.33kb

use std::collections::BTreeMap;
pub trait Plugin {
    // 1. Finish the trait
    fn name(&self) -> &str;
    fn execute(&self);
}
type PluginContainer = BTreeMap<String, Box<dyn Plugin>>;
pub struct PluginManager {
    // 2. Finish the struct
    pub plugins: PluginContainer,
}
// 3. Implement the PluginManager
impl PluginManager {
    pub fn new() -> Self {
        PluginManager { 
            plugins: PluginContainer::new(),
        }
    }
    pub fn add_plugin(&mut self, plugin: Box<dyn Plugin>) {
        let plugin_name = plugin.name().to_string();
        if let Some(_) = self.plugins.insert(plugin_name.clone(), plugin) {
            panic!("Plugin with name '{}' already exists", plugin_name)
        }
    }
    pub fn remove_plugin(&mut self, name: &str) -> Option<Box<dyn Plugin>> {
        self.plugins.remove(name)
    }
    pub fn execute_all(&self) {
        self.plugins.iter().for_each(|(_, p)| p.execute());
    }    
}
pub struct MyPlugin;
impl Plugin for MyPlugin {
    fn name(&self) -> &str {
        "MyPlugin"
    }
    
    fn execute(&self) {
        println!("{} executed.", self.name());
    }
}
impl MyPlugin {
    pub fn new() -> Self {
        MyPlugin {}
    }
}
// Example usage
pub fn main() {
    let mut manager = PluginManager::new();
    manager.add_plugin(Box::new(MyPlugin::new()));
    manager.execute_all();
}

alexsavio

2 months ago

3.57ms

88.31kb

use std::collections::HashMap;
pub trait Plugin {
    // 1. Finish the trait
    fn name(&self) -> &str;
    fn execute(&self);
}
type PluginContainer = HashMap<String, Box<dyn Plugin>>;
pub struct PluginManager {
    // 2. Finish the struct
    pub plugins: PluginContainer,
}
// 3. Implement the PluginManager
impl PluginManager {
    pub fn new() -> Self {
        PluginManager { 
            plugins: PluginContainer::new(),
        }
    }
    pub fn add_plugin(&mut self, plugin: Box<dyn Plugin>) {
        if self.plugins.contains_key(plugin.name()) {
            panic!("Plugin with name '{}' already exists", plugin.name());
        }
        else {
            self.plugins.insert(plugin.name().to_string(), plugin);
        }
    }
    pub fn remove_plugin(&mut self, name: &str) -> Option<Box<dyn Plugin>> {
        self.plugins.remove(name)
    }
    pub fn execute_all(&self) {
        for (name, plugin) in self.plugins.iter() {
            println!("Executing {}.", name);
            plugin.execute();
        }
    }    
}
pub struct MyPlugin;
impl Plugin for MyPlugin {
    fn name(&self) -> &str {
        "MyPlugin"
    }
    
    fn execute(&self) {
        println!("{} executed.", self.name());
    }
}
impl MyPlugin {
    pub fn new() -> Self {
        MyPlugin {}
    }
}
// Example usage
pub fn main() {
    let mut manager = PluginManager::new();
    manager.add_plugin(Box::new(MyPlugin::new()));
    manager.execute_all();
}

vanos001

2 months ago

3.35ms

88.33kb

use std::collections::BTreeMap;
pub trait Plugin {
    fn name(&self) -> &str;
    fn execute(&self);
    // 1. Finish the trait
}
pub struct PluginManager {
    // 2. Finish the struct
    // Make fields public
    pub plugins : BTreeMap<String,Box<dyn Plugin>>,
}
// 3. Implement the PluginManager
impl PluginManager {
    pub fn new() -> Self{
        return Self{
            plugins : BTreeMap::new(),
        };
    }
    pub fn add_plugin(&mut self,el : Box<dyn Plugin>){
        let namex = (*el).name().to_string();
        if let Some(_) = self.plugins.insert(namex.clone(),el){
            panic!("Plugin with name '{namex}' already exists");
        }
    }
    pub fn remove_plugin(&mut self,name : &str) -> Option<Box<dyn Plugin>>{
        self.plugins.remove(&name.to_string())
    }
    pub fn execute_all(&self){
        self.plugins.iter().for_each(|(_,e)| e.execute());
    }
}
// Example usage
pub fn main() {
    let mut manager = PluginManager::new();
    // manager.add_plugin(Box::new(MyPlugin::new()));
    manager.execute_all();
}

0x0f1

Paul4673

2 months ago

3.64ms

88.19kb

pub trait Plugin {
    fn name(&self) -> &str;
    fn execute(&self);
}
impl Plugin for MyPlugin {
    fn name(&self) -> &str {
        &self.name
    }
    fn execute(&self) {
        println!("Execute Plugin");
    }
}
pub struct MyPlugin {
    pub name : String,
}
impl MyPlugin {
    fn new() -> Self {
        Self {
            name : "MyPlugin".to_string()
        }
    }
}
pub struct PluginManager {
    // 2. Finish the struct
    // Make fields public
    pub plugins : Vec<Box<dyn Plugin>>,
}
// 3. Implement the PluginManager
impl PluginManager {
    pub fn new() -> Self {
        Self {
            plugins : Vec::new(),
        }
    }
    pub fn add_plugin(&mut self, plugin : Box<dyn Plugin>) {
        if self.plugins.iter().find(|p| p.name() == plugin.name()).is_none() {
            self.plugins.push(plugin);
        } else {
            panic!("Plugin with name '{}' already exists", plugin.name());
        }
    }
    pub fn remove_plugin(&mut self, name : &str) -> Option<Box<dyn Plugin>>{
        if let Some(index) = self.plugins.iter().position(|p| p.name() == name) {
            return Some(self.plugins.remove(index))
        } 
        None
    }
    pub fn execute_all(&self) {
        for plugin in &self.plugins {
            plugin.execute();
        }
    }
}
// Example usage
pub fn main() {
    let mut manager = PluginManager::new();
    manager.add_plugin(Box::new(MyPlugin::new()));
    manager.execute_all();
}

Enes

enesscevik

2 months ago

4.99ms

88.17kb

pub trait Plugin {
    // 1. Finish the trait
    fn name(&self) -> &str;
    fn execute(&self);
}
pub struct PluginManager {
    // 2. Finish the struct
    // Make fields public
    pub plugins: Vec<Box<dyn Plugin>>,
}
// 3. Implement the PluginManager
impl PluginManager {
    pub fn new() -> Self {
        PluginManager {
            plugins: Vec::new(),
        }
    }
    pub fn add_plugin(&mut self, plugin: Box<dyn Plugin>) {
        if self.plugins.iter().find(|x| x.name() == plugin.name()).is_none() {
            self.plugins.push(plugin);    
        } else {
            panic!("Plugin with name '{}' already exists", plugin.name());
        }
        
    }
    
    pub fn execute_all(&self) {
        for plugin in &self.plugins {
            println!("Executing plugin {}", plugin.name());
            plugin.execute();
        }
    }
    
    pub fn remove_plugin(&mut self, name: &str) -> Option<Box<dyn Plugin>> {
        if let Some(index) = self.plugins.iter().position(|plg| plg.name() == name) {
            Some(self.plugins.remove(index))
        } else {
            None
        }
    }
}
struct MyPlugin { name: String }
impl Plugin for MyPlugin {
    fn name(&self) -> &str {
        &self.name
    }
    fn execute(&self) {
        println!("Executing MyPlugin!");
    }
}
impl MyPlugin {
    fn new() -> MyPlugin {
        MyPlugin {
            name: "myPlug".to_owned(),
        }
    }
}
// Example usage
pub fn main() {
    let mut manager = PluginManager::new();
    manager.add_plugin(Box::new(MyPlugin::new()));
    manager.execute_all();
}

Luigi Terrone

LuigiTer

2 months ago

3.72ms

88.17kb

pub trait Plugin {
    fn name(&self) -> &str;
    fn execute(&self);
}
pub struct PluginManager {
    // 2. Finish the struct
    // Make fields public
    pub plugins: Vec<Box <dyn Plugin>>,
}
// 3. Implement the PluginManager
impl PluginManager {
    pub fn new() -> Self {
        PluginManager {
            plugins: Vec::new(),
        }
    }
    pub fn add_plugin(&mut self, plugin: Box<dyn Plugin>) {
        
        if self.plugins.iter().find(|x| x.name() == plugin.name()).is_none() {
            self.plugins.push(plugin);    
        } else {
            panic!("Plugin with name '{}' already exists", plugin.name());
        }
        
    }
    pub fn execute_all(&self) {
        for plugin in &self.plugins {
            println!("Executing plugin {}", plugin.name());
            plugin.execute();
        }
    }
    
    pub fn remove_plugin(&mut self, name: &str) -> Option<Box<dyn Plugin>> {
        if let Some(index) = self.plugins.iter().position(|plg| plg.name() == name) {
            Some(self.plugins.remove(index))
        } else {
            None
        }
    }
}
struct MyPlugin {
    name: String,
}
impl Plugin for MyPlugin {
    fn name(&self) -> &str {
        &self.name
    }
    fn execute(&self) {
        println!("Executing MyPlugin!");
    }
    
}
impl MyPlugin {
    fn new() -> MyPlugin {
        MyPlugin {
            name: "myPlug".to_string(),
        }
    }
}
// Example usage
pub fn main() {
    let mut manager = PluginManager::new();
    manager.add_plugin(Box::new(MyPlugin::new()));
    manager.execute_all();
}

Tengz Mao

MaoX-Yu

2 months ago

3.45ms

88.19kb

pub trait Plugin {
    // 1. Finish the trait
    fn name(&self) -> &str;
    fn execute(&self);
}
pub struct PluginManager {
    // 2. Finish the struct
    // Make fields public
    pub plugins: Vec<Box<dyn Plugin>>,
}
// 3. Implement the PluginManager
impl PluginManager {
    pub fn new() -> Self {
        Self { plugins: Vec::new() }
    }
    pub fn add_plugin(&mut self, plugin: Box<dyn Plugin>) {
        if self.plugins.iter().find(|p| p.name() == plugin.name()).is_some() {
            panic!("Plugin with name '{}' already exists", plugin.name())
        }
        self.plugins.push(plugin);
    }
    pub fn remove_plugin(&mut self, name: &str) -> Option<Box<dyn Plugin>> {
        if let Some(idx) = self.plugins.iter().position(|p| p.name() == name) {
            Some(self.plugins.remove(idx))
        } else {
            None
        }
    }
    pub fn execute_all(&self) {
        for p in &self.plugins {
            p.execute();
        }
    }
}
pub struct MyPlugin {
    pub name: String,
}
impl MyPlugin {
    pub fn new() -> Self {
        Self { name: "MyPlugin".to_string() }
    }
}
impl Plugin for MyPlugin {
    fn name(&self) -> &str {
        &self.name
    }
    fn execute(&self) {}
}
// Example usage
pub fn main() {
    let mut manager = PluginManager::new();
    manager.add_plugin(Box::new(MyPlugin::new()));
    manager.execute_all();
}

Heino Mortensen

hmortensen83

2 months ago

3.21ms

88.24kb

pub trait Plugin {
    fn name(&self) -> &str;
    fn execute(&self);
}
pub struct PluginManager {
    pub plugins: Vec<Box<dyn Plugin>>,
}
impl PluginManager {
    pub fn new() -> Self {
        Self { plugins: vec![] }
    }
    pub fn add_plugin(&mut self, new_plugin: Box<dyn Plugin>) {
        if self
            .plugins
            .iter()
            .find(|p| p.name() == new_plugin.name())
            .is_none()
        {
            self.plugins.push(new_plugin);
        } else {
            panic!("Plugin with name '{}' already exists", new_plugin.name())
        }
    }
    pub fn remove_plugin(&mut self, name: &str) -> Option<Box<dyn Plugin>> {
        if let Some(index) = self.plugins.iter().position(|plg| plg.name() == name) {
            Some(self.plugins.remove(index))
        } else {
            None
        }
    }
    pub fn execute_all(&self) {}
}
struct MyPlugin {
    name: String,
}
impl MyPlugin {
    fn new() -> Self {
        Self {
            name: "MyPlugin".to_string(),
        }
    }
}
impl Plugin for MyPlugin {
    fn name(&self) -> &str {
        &self.name
    }
    fn execute(&self) {
        println!("Executing MyPlugin!");
    }
}
// Example usage
pub fn main() {
    let mut manager = PluginManager::new();
    manager.add_plugin(Box::new(MyPlugin::new()));
    manager.execute_all();
}