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

Yummy-Yums

18 hours ago

3.76ms

88.19kb

pub trait Plugin {
    // 1. Finish the trait
    fn name(&self) -> &str;
    fn execute(&self);
}
pub struct MyPlugin {}
impl MyPlugin{
    pub fn new() -> MyPlugin {
        Self {  }
    }
}
impl Plugin for MyPlugin {
    fn name(&self) ->  &str {
        "MyPlugin"
    }
    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 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();
}

Ari Karim

arikarim

2 days ago

7.63ms

88.19kb

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

Vincent SAMY

vsamy

3 days ago

4.77ms

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 let Some(p) = self.plugins.iter().find(|&x| x.name() == plugin.name()) {
            panic!("Plugin with name '{}' already exists", p.name());
        }
        self.plugins.push(plugin);
    }
    pub fn remove_plugin(&mut self, name: &str) -> Option<Box<dyn Plugin>> {
        if let Some(p_index) = self.plugins.iter().position(|x| x.name() == name) {
            return Some(self.plugins.remove(p_index));
        }
        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!("Running!");
    }
}
// Example usage
pub fn main() {
    let mut manager = PluginManager::new();
    manager.add_plugin(Box::new(MyPlugin::new()));
    manager.execute_all();
}

Francisco Alejandro

francisco-alejandro

5 days ago

3.78ms

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() -> PluginManager {
        PluginManager{
            plugins: Vec::new()
        }
    }
    pub fn add_plugin(&mut self, item: Box<dyn Plugin> ) {
        if let Some(plugin) = self.plugins.iter().find(|&x| x.name() == item.name()) {
            panic!("Plugin with name '{}' already exists", plugin.name())
        }
        self.plugins.push(item);
    }
    pub fn remove_plugin(&mut self, item: &str) -> Option<Box<dyn Plugin>> {
        if let Some(idx) =  self.plugins.iter().position(|i|i.name() == item) {
            Some(self.plugins.remove(idx))
        } else {
            None
        }
    }
    pub fn execute_all(&self) {
        for plugin in &self.plugins {
            plugin.execute();
        }
    }
}
pub struct MyPlugin {}
impl MyPlugin {
    pub fn new() -> MyPlugin {
        MyPlugin{
        }
    }
}
impl Plugin for MyPlugin {
    fn name(&self) -> &str {
        return "Plugin"
    }
    fn execute(&self) {
    }
}
// Example usage
pub fn main() {
    let mut manager = PluginManager::new();
    manager.add_plugin(Box::new(MyPlugin::new()));
    manager.execute_all();
}

Abhishek Sharma

0xAbhiDev

11 days ago

3.39ms

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>>,
}
struct MyPlugin {
    pub name: String,
}
impl MyPlugin {
    fn new()-> Self {
        MyPlugin{name: "test".to_string()}
    }
}
impl Plugin for MyPlugin {
    fn name(&self) -> &str {
        &self.name
    }
    fn execute(&self) {
        print!("hello");
    }
}
// 3. Implement the PluginManager
impl PluginManager {
    pub fn new() -> Self {
        PluginManager {
            plugins: Vec::new(),
        }
    }
pub fn add_plugin(&mut self, item: Box<dyn Plugin>) {
   if self.plugins.iter().any(|p| p.name() == item.name()) {
            panic!("Plugin with name '{}' already exists", item.name());
        } else {
            self.plugins.push(item)
        }
    }
    pub fn remove_plugin(&mut self, item: &str) -> Option<Box<dyn Plugin>> {
            if let Some(idx) =  self.plugins.iter().position(|i|i.name() == item) {
               Some(self.plugins.remove(idx))
            } 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();
}

jfloresremar

14 days ago

3.56ms

88.19kb

use std::{thread, time::Duration};
pub trait Plugin {
    fn name(&self) -> &str;
    fn execute(&self);
}
pub struct MyPlugin {}
impl MyPlugin {
    pub fn new() -> Self {
        Self {}
    }
}
impl Plugin for MyPlugin {
    fn name(&self) -> &str {
        "my_plugin"
    }
    fn execute(&self) {
        thread::sleep(Duration::from_nanos(1));
    }
}
pub struct PluginManager {
    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(|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>> {
        if let Some(index) = self.plugins.iter().position(|x| x.name() == name) {
            let removed = self.plugins.swap_remove(index);
            Some(removed)
        } 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();
}

QuJohan

16 days ago

5.60ms

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>) {
        if let Some(_) = self.plugins.iter().position(|probe| probe.name() == plugin.name()) {
            panic!("Plugin with name {} already exists", plugin.name());
        } else {
            self.plugins.push(plugin)
        }
    }
    pub fn remove_plugin(&mut self, plugin: &str) -> Option<Box<dyn Plugin>>{
        match self.plugins.iter().position(|probe| probe.name() == plugin) {
            Some(key) => Some(self.plugins.remove(key)),
            None => 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();
}

Omar

OmniKobra

20 days ago

3.05ms

88.69kb

pub trait Plugin {
    // 1. Finish the trait
    fn name(&self) -> &str;
    fn execute(&self);
}
pub struct MyPlugin {
    name: String,
}
impl MyPlugin {
    fn new()->Self{
        Self{name: "foo".into()}
    }
}
impl Plugin for MyPlugin {
    fn name(&self) -> &str {
        &self.name
    }
    fn execute(&self) {
        println!("Executing.");
    }
}
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, item: Box<dyn Plugin>){
    
        let finder = self.plugins.iter().find(|i| i.name() == item.name());
        if let Some(i) = finder {
            panic!("Plugin with name {} already exists", item.name());
        } else {
            self.plugins.push(item);
        }
    }
    pub fn remove_plugin(&mut self, item: &str) -> Option<Box<dyn Plugin>> {
        //  let finder = self.plugins.iter().find(|i| i.name() == item);
            if let Some(idx) =  self.plugins.iter().position(|i|i.name() == item) {
               Some(self.plugins.remove(idx))
            } else {
                None
            }
    }
    pub fn execute_all(&self) {
        for item in self.plugins.iter() {
            item.execute();
        }
    }
}
// Example usage
pub fn main() {
    let mut manager = PluginManager::new();
    manager.add_plugin(Box::new(MyPlugin::new()));
    manager.execute_all();
}

Gurneet singh

GS-Jatt

24 days ago

3.38ms

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![] }
    }
    pub fn add_plugin(&mut self, plugin: Box<dyn Plugin>) {
        let plugins = self.plugins.iter().find(|item| item.name() == plugin.name());
        if let Some(item) = plugins {
            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(|item| item.name() == name)?;
        Some(self.plugins.remove(index))
    }
    pub fn execute_all(&self) {
        self.plugins.iter().for_each(|item| item.execute());
    }
}
struct MyPlugin {
    pub name: String,
}
impl Plugin for MyPlugin {
    fn name(&self) -> &str {
        &self.name
    }
    fn execute(&self) {
        print!("hello");
    }
}
impl MyPlugin {
    fn new() -> Self {
        MyPlugin {
            name: "test".to_string(),
        }
    }
}
// Example usage
pub fn main() {
    let mut manager = PluginManager::new();
    manager.add_plugin(Box::new(MyPlugin::new()));
    manager.execute_all();
}

Abdul

aisiyoup

25 days ago

3.50ms

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>>
}
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) {}
}
// 3. Implement the PluginManager
impl PluginManager {
    pub fn new() -> Self{
        PluginManager{plugins: Vec::new()}
    }
    pub fn add_plugin(&mut self, plugin: Box<dyn Plugin>){
        for p in &self.plugins{
            if p.name() == plugin.name(){
                panic!("Plugin with name {} already exists", plugin.name())
            }
        }
    self.plugins.push(plugin);
    }
    
    pub fn remove_plugin(&mut self, plugin: &str) -> Option<Box<dyn Plugin>>{
        if let Some(index) = self.plugins.iter().position(|p| p.name() == plugin) {
            Some(self.plugins.remove(index))
        } else {
            None
        }
    }
    pub fn execute_all(&self){
        self.plugins.iter().for_each(|p|p.execute());
    }
}
// Example usage
pub fn main() {
    let mut manager = PluginManager::new();
    manager.add_plugin(Box::new(MyPlugin::new()));
    manager.execute_all();
}

Abdul

aisiyoup

25 days ago

3.35ms

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>>
}
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) {}
}
// 3. Implement the PluginManager
impl PluginManager {
    pub fn new() -> Self{
        PluginManager{plugins: Vec::new()}
    }
    pub fn add_plugin(&mut self, plugin: Box<dyn Plugin>){
        for p in &self.plugins{
            if p.name() == plugin.name(){
                panic!("Plugin with name {} already exists", plugin.name())
            }
        }
    self.plugins.push(plugin);
    }
    
    pub fn remove_plugin(&mut self, plugin: &str) -> Option<Box<dyn Plugin>>{
        if let Some(index) = self.plugins.iter().position(|p| p.name() == plugin) {
            Some(self.plugins.remove(index))
        } else {
            None
        }
    }
    pub fn execute_all(&self){
        self.plugins.iter().for_each(|p|p.execute());
    }
}
// Example usage
pub fn main() {
    let mut manager = PluginManager::new();
    manager.add_plugin(Box::new(MyPlugin::new()));
    manager.execute_all();
}

msned

a month ago

3.63ms

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{
        Self { plugins: vec![] }
    }
    pub fn add_plugin(&mut self, p : Box<dyn Plugin>){
        if self.plugins.iter().any(|n| n.name() == p.name()){
            panic!("Plugin with name '{}' already exists",p.name());
        }
        else{
            self.plugins.push(p);
        }
    }
    pub fn remove_plugin(&mut self, name : &str)->Option<Box<dyn Plugin>>{
        if let Some(index) = self.plugins.iter().position(|n| n.name() == name){
            return Some(self.plugins.remove(index));
        }
        return None;
    }
    pub fn execute_all(&self){
        self.plugins.iter().for_each(|n| n.execute());
    }
}
// Example usage
pub fn main() {
    let mut manager = PluginManager::new();
    //manager.add_plugin(Box::new(MyPlugin::new()));
    manager.execute_all();
}

TheJanzap

a month ago

3.58ms

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, plugin_name: &str) -> Option<Box<dyn Plugin>> {
        // Unstable API in Rust 1.89
        //self.plugins.pop_if(|p| p.name() == plugin_name)
        if let Some(index) = self.plugins.iter().position(|p| p.name() == plugin_name) {
            Some(self.plugins.remove(index))
        } 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();
}

jh4vision

a month ago

3.50ms

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 let Some(_)= self.find(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(idx)= self.find(name){
            return Some(self.plugins.remove(idx));
        }
        None
    }
    pub fn execute_all(&self){
        for p in &self.plugins {
            p.execute();
        }
    }
    fn find(&self, name: &str)->Option<usize> {
        for (idx, p) in self.plugins.iter().enumerate() {
            if p.name() == name {
                return Some(idx);
            }
        }
        return None;
    }
}
// Example usage
pub fn main() {
    let mut manager = PluginManager::new();
    manager.execute_all();
}

Christophe Mohimont

mohic

a month ago

3.88ms

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>) {
        for p in &self.plugins {
            if p.name() == 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>> {
        for (i, p) in self.plugins.iter().enumerate() {
            if p.name() == plugin_name {
                return Some(self.plugins.remove(i));
            }
        }
        None
    }
    pub fn execute_all(&self) {
        for plugin in &self.plugins {
            plugin.execute();
        }
    }
}

muemart

a month ago

3.53ms

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 {
        PluginManager {
            plugins: HashMap::new()
        }
    }
    pub fn add_plugin(&mut self, plugin: Box<dyn Plugin>){
        let name = plugin.name();
        if(self.plugins.contains_key(name)){
            panic!("Plugin with name '{}' already exists", name);
        }
        self.plugins.insert(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.execute_all();
}

Smith, Taylor

a647965_fidelity

a month ago

3.70ms

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>) {
        let plugin_name = plugin.name();
        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, plugin_name: &str) -> Option<Box<dyn Plugin>> {
        let matching_index = self.plugins.iter().position(|plugin| plugin.name() == plugin_name);
        match matching_index {
            Some(idx) => Some(self.plugins.remove(idx)),
            None => None,
        }
    }
    pub fn execute_all(&self) {
        for plugin in self.plugins.iter() {
            plugin.execute();
        }
    }
}
struct MyPlugin {}
impl Plugin for MyPlugin {
    fn name(&self) -> &str {
        "MyPlugin"
    }
    fn execute(&self) {
        println!("Executing MyPlugin!");
    }
}
impl MyPlugin {
    pub fn new() -> Self {
        Self{}
    }
}
// Example usage
pub fn main() {
    let mut manager = PluginManager::new();
    manager.add_plugin(Box::new(MyPlugin::new()));
    manager.execute_all();
}

Jai

jsat97

a month 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

a month 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

a month 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

2 months 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

2 months 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

2 months 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

2 months 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

2 months 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

2 months 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

2 months 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

2 months 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

2 months 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

2 months 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

2 months 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

2 months 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

2 months 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

2 months 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

2 months 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

2 months 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

2 months 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

2 months 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

2 months 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

2 months 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

2 months 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

3 months 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

3 months 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

3 months 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

3 months 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

3 months 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

3 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

3 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

3 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

3 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();
}