boost-ext / di Goto Github PK

View Code? Open in Web Editor NEW

1.1K 69.0 133.0 73.27 MB

C++14 Dependency Injection Library

Home Page: https://boost-ext.github.io/di

C++ 83.40% CMake 0.93% Makefile 0.68% Java 8.86% C# 3.95% Shell 0.73% Python 0.73% Meson 0.73%

dependency-injection metaprogramming design-patterns

di's Introduction

[Boost::ext].DI

Your C++14 one header only Dependency Injection library with no dependencies

https://www.youtube.com/watch?v=yVogS4NbL6U

Quick start

Download

[Boost::ext].DI requires only one file. Get the latest header here!

Include

#include <boost/di.hpp>
namespace di = boost::di;

Compile

GCC/Clang

$CXX -std=c++14 -O2 -fno-exceptions -fno-rtti -Wall -Werror -pedantic-errors file.cpp

MSVC
```
cl /std:c++14 /Ox /W3 file.cpp
```

Quick guide - Create object graph

class ctor {
public:
  explicit ctor(int i) : i(i) {}
  int i;
};

struct aggregate {
  double d;
};

class example {
 public:
  example(aggregate a, const ctor& c) {
    assert(87.0 == a.d);
    assert(42 == c.i);
  };
};

int main() {
  const auto injector = di::make_injector(
    di::bind<int>.to(42),
    di::bind<double>.to(87.0)
  );

  injector.create<example>();
}

Run this example on Wandbox.

	Clang-3.8	GCC-6	MSVC-2015
Compilation Time	0.102s	0.118s	0.296s
Binary size (stripped)	6.2kb	6.2kb	105kb
ASM x86-64	`xor eax, eax retq`

Quick guide - Bind interfaces

struct interface {
  virtual ~interface() noexcept = default;
  virtual int get() const = 0;
};

class implementation : public interface {
public:
  int get() const override { return 42; }
};

struct example {
  example(std::shared_ptr<interface> i) {
    assert(42 == i->get());
  }
};

int main() {
  const auto injector = di::make_injector(
    di::bind<interface>.to<implementation>()
  );

  injector.create<std::unique_ptr<example>>();
}

Run this example on Wandbox.

	Clang-3.8	GCC-6	MSVC-2015
Compilation Time	0.102s	0.118s	0.296s
Binary size (stripped)	6.2kb	6.2kb	105kb
ASM x86-64 (same as `make_unique`)	`push %rbx mov %rdi,%rbx mov $0x8,%edi callq 0x4008e0 <_Znwm@plt> movq $0x400c78,(%rax) mov %rax,(%rbx) mov %rbx,%rax pop %rbx retq`

Quick guide - Bind templates

template<class ErrorPolicy = class TErrorPolicy>
class simple_updater {
public:
  void update() const {
    ErrorPolicy::on("update");
  }
};

template<class Updater = class TUpdater>
class example {
public:
  explicit example(const Updater& updater)
    : updater(updater)
  { }

  void update() {
    updater.update();
  }

private:
  const Updater& updater;
};

int main() {
  struct throw_policy {
    static void on(const std::string& str) {
      throw std::runtime_error(str);
    }
  };

  const auto injector = di::make_injector(
    di::bind<class TErrorPolicy>.to<throw_policy>(),
    di::bind<class TUpdater>.to<simple_updater>()
  );

  injector.create<example>().update();
  // Terminates with an uncaught exception because of our bound error policy
}

Run this example on Wandbox.

	Clang-3.8	GCC-6	MSVC-2015
Compilation Time	0.102s	0.118s	0.296s
Binary size (stripped)	6.2kb	6.2kb	105kb
ASM x86-64	`xor eax, eax retq`

Quick guide - Bind concepts

struct Streamable {
 template<class T>
 auto requires(T&& t) -> decltype(
   int( t.read() ),
   t.write(int)
 );
};

template<class Exchange = Streamable(class ExchangeStream)
         class Engine   = Streamable(class EngineStream)>
class example {
public:
  example(Exchange exchange, Engine engine)
    : exchange(std::move(exchange)), engine(std::move(engine))
  { }
  
private:
  Exchange exchange;
  Engine engine;
};

int main() {
  const auto injector = di::make_injector(
    di::bind<Streamable(class ExchangeStream)>.to<exchange>(),
    di::bind<Streamable(class EngineStream)>.to<engine>()
  );

  injector.create<example>();
}

Run this example on Wandbox.

	Clang-3.8	GCC-6	MSVC-2015
Compilation Time	0.102s	0.118s	0.296s
Binary size (stripped)	6.2kb	6.2kb	105kb
ASM x86-64	`xor eax, eax retq`

Documentation

Disclaimer [Boost::ext].DI is not an official Boost library.

di's People

Contributors

Stargazers

Watchers

Forkers

retf antmd claudiouzelac arkadiuszsz valery-barysok zhongxingzhi d viboes ybainier johnh1989 digitalist mjkoo veterun zhaojiangbin ldm5180 kieranhay benmouh jhruby raymoritz 331527583 michalk-1 damonouyang kanstantsin-chernik krzysztof-jusiak fossabot nguyenhuutuanw maxmarkin gjasny techsmith cnsuhao testudoed marvelsoft delta1766 apokorny shoutanyoule serge-bekish badc0re netaudio flygsand mlimber dan-42 alexey-bogomolov donovan68 jamespharvey20 gauravalgo gauravvc mariansagat pck ebraph based-god-fucked-my-bitch-fuckzig cingoli e-schumann nvevg masterjedy yazici m-gaj xxxhycl2010 aikuimail ameeraldeen raphaelzulliger stevefan1999-personal rezahousseini apollo-go hetal-g zhouruiapple blockspacer linecode anb0s peterzs dwkimm01 szloveni subhamoys odant hypdeb angelo-abel snowwalkerj ppomaski cnliao ali-robot dcnick3 szigetics crackercat siliconvillager friendlyanon samvasko tralamazza itfenom bryanlihp wahello ldalek legalizeadulthood valkotova kingland mstaz clucheng clausklein externalrepositories elpako wg138940-zz zczhangcheng

di's Issues

convertible with scope

MT - modules combinations

Injector<M1, M2, M3>
modules tests

policy: external reference without ownership

OK:
External

C1(const D&)
C2(D&)
C3(shared_ptr)

example with QFsm in README.md

delegate creation to other di

session scope

//todo smart ptr instead of naked ptr

struct session
{
    template<typename T>
    struct scope
    {
         scope()
              : instance_(nullptr)
         { }

         ~scope() {
             delete instance_;
         }

         void call(const entry&)
         {
              in_scope_ = true;
         }

         void call(const exit&)
         {
              in_scope_ = false;

              delete instance_;
         }

          template<typename... Args>
          T* create(Args&& args)
          {
               if (in_scope_) {
                    return new T(args...);
               }
               return nullptr;
          }
    };
};

session<
    c1
>

injector.call<Session>(entry());
injector.create<c1>();
injector.call<Session>(exit());

Utility::Provider support

QDEPS_CTOR(Test, Provider i)
{
};

support of Bind<I, Provider >

binder.hpp cause sigsev on gcc 4.6.2 in debug mode

scope deduction support

class impl : i {};
class c1 {CTOR(shared_ptr);};
class c2 {CTOR(unique_ptr);};

generic_module.create();//singleton
generic_module.create();//per_request

Policy: references have to be externals

QDEPS_CTOR(Test, const I&); //lack of owner

msvc 10 support (windows)

default allocator policy

mingw support (windows)

constructor traits outside the constructor

template<>
ConstructorTraits<C1, int, doouble>
{ };

Pool per module

create < Type > - only shared_ptr, lvalue, ptr have sens

C c = create < shared_ptr >()
C c = create < C >()
const C& c = create < C >()
C* c = create < C* >()
const C* c = create <const C* >()

const C& c = create < const C& >() //error
const C& c = create < C& >() //error
const C& c = create < shared_ptr& >() //error

ghi test

Pool.get with Allocator::Smart -> extend convert about boost::variant

allow non const ref

QDEPS_CTOR(i&) -> non_const_ref

Method injector - ctor injector is enough

class C
{
public:
shared_ptr create()
{
return make_shared();
}
};

Module <
Bind ::InMethod<&C::create>

fusion module without externals but in ctor

Utility::Injector
<
     BOOST_TYPEOF(fusionModule)
>
injector;//ok

Utility::Injector
<
     BOOST_TYPEOF(fusionModule)
>
injector(fusionModule);//error

Policy: ModuleDependenciesRepetition

Module1<
PerRequest<int, int_<0> >

{ };

Module2<
PerRequest<int, int_<1>

{ };

Injector<Module1, Module2> injector; //error -> ambiguous int

Injector.visit -> dump to text

Injector injector;
Injector.visit(DotVisitor());

C1 --- C2
|
int

... in graphviz dot

factory support

class c
{
CTOR(i*) {
}
};

class c1
{
CTOR(i*) {
}
};

di<
bind::in_call::to(42)
Factory,
, bind::in_call

injector;

factory
{
CTOR(int i) {
}

i* create(di& di) {
    switch(i) {
        return di.create<Impl1>();
    }

    return nullptr;
}

};

typedef id2type::bind<
E1, Impl1
E2, Impl2

factory_type;

merge per_request and definite scopes

per_request<int, int_<32> >

policy: binding_correctness

Bind::in_calll

C1(double) { } //error C1 doesn't have int parameter
Compilation error requested

bidnes::correctness -> the same binding in different scopes
externals with scopes

Externals with base front end

Module <
Externals <
Annotate::With,
Annotate<Bind::InName::InCall >::With

Injector injector(Module(Set(42), Set(87)));

externals with fusion front end

BInd::To(32)

Default PerRequest scope with binding

Module <
C1, //works fine
Bind::InName //doesn't work

Policy: CircularDependencies

disallow circular dependencies

Base front end - Annotate support

Annotate< Bind::InCall >::With

Module(
Set(32)
)

Policy: Singleton can't be passed by value

Module <
Singleton

{ };

QDPES_CTOR(A1, S); //error -> passed by value
QDPES_CTOR(A2, shared_ptr);

Fix code coverage results due to templates generation

input/output object types via policy

Named with shared_ptr

QDEPS_CTOR(Test, Named< shared_ptr, Name >)
QDEPS_CTOR(Test, Named< const shared_ptr&, Name >)
QDEPS_CTOR(Test, Named< const shared_ptr&, Name >) -> Bind<int, int_<42> >::InName

Injector.install

Injector<> injector;

injector.install(m1, m2, ...); -> Injector<M1, M2, ...>

c++11 support

config.hpp

GraphvizDotVisitor - text visitor is enough

allow boost::function, pointers to functions, arrays, non const ref

class Test
{
QDEPS_CTOR(void (*f1)(int), boost::function f2, int a1[], int (&a2)[10])
{ }
};

setter injection support

class c
{
c()
: i_(0)
{ }

 void BOOST_DI_SETTER(int i) {
     i_ = i;
  }

private:
int i_;
};

di::injector<>.create();

Named with interface -> verify

QDEPS_CTOR(Named<If, Name>)

Bind::InName

C++11 fork

One line binding with InCall and InName -> Apply CallStack and Name

Singleton < C >::InCall < C1, C2 >
Singleton < C >::InName < Name >
Singleton < C >::InCall < C1, C2 >::InName < Name >
Singleton < C >::InName < Name >::InCall < C1, C2 >

PerRequest < C >::InCall < C1, C2 >
PerRequest < C >::InName < Name >
PerRequest < C >::InCall < C1, C2 >::InName < Name >
PerRequest < C >::InName < Name >::InCall < C1, C2 >