goatnative-inject

C++11 Dependency Injection (IoC - inversion of control) class using variadic templates and shared pointers. This ought to give a good example of variadic templates usage and other C++11 features such as auto and shared_ptr.

The implementation behind the goatnative::Inject is taken from www.codeproject.com/Articles/567981/AnplusIOCplusContainerplususingplusVariadicplusTem I've extended that implementation by:

Adding a registerInterface method that lets you map interfaces to previously registered instance classes.

Features

Register types to their dependencies.
Register as singleton.
Register interfaces to to concrete types.
Thread safe.

Limits

Currently injection is done only via constructor.
Injectee constructors are expected to have shared_ptr to each injected types

Examples

Example - Hello world

#include "Injector/goatnative/Injector.h"
#include <iostream>

using goatnative::Injector;

class IHello
{
public:
    virtual void hello() const = 0;
    virtual ~IHello() = default;
};


class Hello : public IHello
{
public:
    virtual void hello() const
    {
        std::cout << "hello world!" << std::endl;
    }
};


int main(int argc, const char** argv)
{
    Injector injector;
    
    // Let's register the concrete class
    injector.registerClass<Hello>();
    
    // Now register IHello with Hello so that each time we ask for IHello 
    // We get Hello -
    injector.registerInterface<IHello, Hello>();
    
    auto helloInstance = injector.getInstance<IHello>();
    
    helloInstance->hello();
}

Example - Singleton Class

#include <cassert>
#include <functional>

#include "Injector/goatnative/Injector.h"

using goatnative::Injector;

class IExecutor
{
public:
    virtual void execute(std::function<void()> func) = 0;
    virtual ~IExecutor() = default;
};

class SyncExecutor : public IExecutor
{
public:
    void execute(std::function<void()> func) override
    {
        func();
    }
};

int main(int argc, const char * argv[]) {
    Injector injector;
    
    // Here we're registering IExecutor with SyncExecutor as singleton
    injector.registerSingleton<SyncExecutor>();
    injector.registerInterface<IExecutor, SyncExecutor>();
    
    // Whenever we'll ask for IExecutor we'll get the same instance of SyncExecutor
    auto executor1 = injector.getInstance<IExecutor>();
    auto executor2 = injector.getInstance<IExecutor>();
    
    // Compare returned pointer which are expected to be the same
    assert(executor1.get() == executor2.get());
    return 0;
}

Example - map to an existing instance

#include <cassert>
#include <memory>

#include "Injector/goatnative/Injector.h"

using goatnative::Injector;

class NullObject
{
};

int main(int argc, const char * argv[]) {
    Injector injector;

    // Here's an example of how to register a manually created instance of an object
    auto nullInstance = std::make_shared<NullObject>();
    
    injector.registerInstance(nullInstance);
    
    auto null1 = injector.getInstance<NullObject>();
    auto null2 = injector.getInstance<NullObject>();
    
    assert(null1.get() == null2.get());
    assert(null1.get() == nullInstance.get());
    return 0;
}

Example - class with dependencies

#include <iostream>
#include <memory>
#include <string>

#include "Injector/goatnative/Injector.h"

using std::cout;
using std::endl;
using std::shared_ptr;
using std::string;

using goatnative::Injector;

class ICar
{
public:
    virtual void startIgnition() = 0;
    virtual ~ICar() = default;
};

class IEngine
{
public:
    virtual double getVolume() const = 0;
    virtual ~IEngine() = default;
};

class IWheels
{
public:
    virtual bool inflated() const = 0;
    virtual ~IWheels() = default;
};

class Engine : public IEngine
{
public:
    virtual double getVolume() const override
    {
        return 10.5;
    }
};

class Wheels : public IWheels
{
public:
    virtual bool inflated() const override
    {
        return false;
    }
};

class Car : public ICar
{
public:
    Car(shared_ptr<IEngine> engine, shared_ptr<IWheels> wheels) : _engine(engine), _wheels(wheels)
    {
        
    }
    
    virtual void startIgnition()
    {
        std::cout << "starting ignition, engine volume: " << _engine->getVolume()
                  << ", wheels inflated? " << _wheels->inflated() << std::endl;
    }

private:
    shared_ptr<IEngine> _engine;
    shared_ptr<IWheels> _wheels;
};


int main(int argc, const char * argv[]) {
    Injector injector;
    
    // Here's an example of a more complex graph of objects tied together
    // using Injector -
    
    // Engine
    injector.registerClass<Engine>();
    injector.registerInterface<IEngine, Engine>();
    
    // Wheels
    injector.registerClass<Wheels>();
    injector.registerInterface<IWheels, Wheels>();
    
    // Register car with its dependencies - IEngine and IWheels (required by its ctor)
    injector.registerClass<Car, IEngine, IWheels>();
    injector.registerInterface<ICar, Car>();
    
    // Car is instansiated with instances of Engine, Wheels and Car automatically!
    auto car = injector.getInstance<Car>();
    car->startIgnition();
    
    return 0;
}

See more examples in main.cpp

TODO

Move tests from main.cpp to Google Test.

Cheap and reliable Node.js hosting starts at $3/month, and $1/month static HTML hosting

Autodesk / goatnative-inject

Programming Languages