Singleton Manager

Is a management service for Singleton Services. If there is a need for a service to keep its state across multiple threads, this singleton service can pull the services from a singleton storage.

Note: Singleton Manager itself is not thread-safe, so you need to make your service threadsafe.

Usage

Say we want to use a custom struct as our singleton: ```rust pub struct MyService { message: String, guard: Mutex<()>, }

impl MyService { pub fn set(&mut self, msg: &str) { let mut guard = self.guard.lock().expect("Failed to get guard"); self.message = msg.tostring(); }

pub fn get(&self) -> String {
    let _guard = self.guard.lock();
    self.message.clone()
}

} ```

Using object instance

if this is our service and we would now want to store it as a singleton, we can do this simply by:

rust SingletonManager::instance().set( "my_service", "MyService", None, Some(MyService { message: "".to_string(), guard: Mutex::new(()), }), ) .ok();

this will set the service and is now retrivable by using:

```rust let service = SingletonManager::instance() .get::("my_service") .expect("Failed to get service"); service.set("My Message");

let different_service = SingletonManager::instance()
    .get::<MyService>("my_service")
    .expect("Failed to get service");
assert_eq!("My Message".to_string(), different_service.get());

```

Full example

```rust pub struct MyService { message: String, guard: Mutex<()>, }

impl MyService { pub fn set(&mut self, msg: &str) { let mut guard = self.guard.lock().expect("Failed to get guard"); self.message = msg.tostring(); }

pub fn get(&self) -> String {
    let _guard = self.guard.lock();
    self.message.clone()
}

}

fn main() { SingletonManager::instance().set( "myservice", "MyService", None, Some(MyService { message: "".tostring(), guard: Mutex::new(()), }), ) .ok(); let service = SingletonManager::instance() .get::("my_service") .expect("Failed to get service"); service.set("My Message");

let different_service = SingletonManager::instance()
    .get::<MyService>("my_service")
    .expect("Failed to get service");
assert_eq!("My Message".to_string(), different_service.get());

} ```

Using factory instance

It's possible to instantiate only on request by using a factory to create the service

rust SingletonManager::instance() .set_factory( "my_service_factory", Box::new(|| { Box::new(MyService { message: "".to_string(), guard: Mutex::new(()), }) }), ) .ok();

this will set the service and is now retrivable by using:

```rust fn main() { setservice(); let service = SingletonManager::instance() .get::("myservice_factory") .expect("Failed to get service"); service.set("My Message");

let different_service = SingletonManager::instance()
    .get::<MyService>("my_service_factory")
    .expect("Failed to get service");
assert_eq!("My Message".to_string(), different_service.get());

} ```

Full Example

```rust pub struct MyService { message: String, guard: Mutex<()>, }

impl MyService { pub fn set(&mut self, msg: &str) { let mut guard = self.guard.lock().expect("Failed to get guard"); self.message = msg.tostring(); }

pub fn get(&self) -> String {
    let _guard = self.guard.lock();
    self.message.clone()
}

}

fn main() { SingletonManager::instance() .setfactory( "myservicefactory", Box::new(|| { Box::new(MyService { message: "".tostring(), guard: Mutex::new(()), }) }), ) .ok();

let service = SingletonManager::instance()
    .get::<MyService>("my_service_factory")
    .unwrap();
service.set("My Message");

let different_service = SingletonManager::instance()
    .get::<MyService>("my_service_factory")
    .unwrap();
assert_eq!("My Message".to_string(), different_service.get());

} ```