// Create your own injector
GIInjector *injector = [[GIInjector alloc] init];

// or use the shared injector
GIInjector *injector = [GIInjector sharedInjector];

// Child Injector
GIInjector *childInjector = [injector createChildInjector];

// Map classes
[injector map:[MyImplementation class] to:@protocol(MyProtocol)];

// You don't have to do this. Gummi Injection will figure it out itself.
[injector map:[MyImplementation class] to:[MyImplementation class]];

// But you could do this
[injector map:[MyImplementation1 class] to:[MyImplementation2 class]];

// Map instances
[injector map:car to:[Car class]]
[injector map:car to:@protocol(Vehicle)]

// Map singletons and eager singletons.
// Eager singletons will be instantiated immediately
[injector mapEagerSingleton:[Service class] to:@protocol(RemoteService)];
[injector mapSingleton:[Model class] to:[Model class]];

// Map blocks
id (^factoryBlock)(GIInjector *) = ^(GIInjector *injector) {
    id stuff = [injector getObject:[SomeStuff class]];
    Car *car = [[Car alloc] initWithStuff:stuff];
    return car;
};
[injector map:factoryBlock to:@protocol(Vehicle)];

// You can remove mappings at any time
[injector unMap:[Service class] from:@protocol(RemoteService)];

@class Wheel;

@interface Car : NSObject <Vehicle>
@property(nonatomic, strong) Wheel *wheel1;
@property(nonatomic, strong) Wheel *wheel2;
@property(nonatomic, strong) Wheel *wheel3;
@property(nonatomic, strong) Wheel *wheel4;
@property(nonatomic) id <Engine> engine;
@end

@implementation Car

inject(@"wheel1", @"wheel2", @"wheel3", @"wheel4", @"engine");

// Optional selector gets performed, when injection is complete
injection_complete(@selector(startEngine))

- (void)startEngine {
    if (self.engine)
        NSLog(@"[%@] Brrrmmmmm....", NSStringFromClass([self class]));
}

...
@end

// No need to set up rules for simple injections like Wheel
// that can be created with alloc init.
// For protocols there's no way to know which implementation to return -
// we need to set up a rule for it.
[injector map:[HybridEngine class] to:@protocol(Engine)];

Car *car = [injector getObject:[Car class]];

// or use protocols
[injector map:[Car class] to:@protocol(Vehicle)];
Car *car = [injector getObject:@protocol(Vehicle)];

// or inject into existing objects
Car *car = [[Car alloc] init];
[injector injectIntoObject:car];

// This will happen:
// - getObject looks up type Car -> no rule set -> Instantiate Car and inject into object
//     - Each Car wants Wheels
//         - Look up type Wheel -> no rule set -> Instantiate Wheel and inject into object
//     - Car wants <Engine>
//         - Look up type <Engine> -> rule found: [HybridEngine class]
//         - Instantiate HybridEngine and inject into object
// Done

GIModule *module = [[GameModule alloc] init];
[injector addModule:module];

// After the game, remove the Module by class
[injector removeModuleClass:[GameModule class]];
// or by instance
[injector removeModule:gameModule];

@interface GameModule : GIModule
@end

@implementation GameModule

- (void)configure:(GIInjector *)injector {
    [super configure:injector];

    [self mapSingleton:[MyGameModel class]
                    to:@protocol(GameModel)];
    
    // Example Service starts automatically on init
    [self mapEagerSingleton:[MyRemoteService class]
                         to:@protocol(RemoteService)];
}

- (void)unload {
    // For convenience, close all connections to stop service
    Service *service = [_injector getObject:@protocol(RemoteService)];
    [service close];

    [super unload];
}

- (void)dealloc {
    NSLog(@"Service and Model get dealloced with me.");
}

@end