boost-ext/di

C++14 Dependency Injection Library

di's Issues

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

Policy mechanism to Injector

Injector< Moudle1, Policy< AllowA, AllowB > > inj1;
Injector<Policy< AllowC >, Module1 > inj2;

mingw support (windows)

merge per_request and definite scopes

per_request<int, int_<32> >

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])
{ }
};

default allocator policy

Injector.install

Injector<> injector;

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

Policy: ModuleDependenciesRepetition

Module1<
PerRequest<int, int_<0> >

{ };

Module2<
PerRequest<int, int_<1>

{ };

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

example with QFsm in README.md

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

Thread safe scope singleton - verify

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 >

c++11 support

config.hpp

Pool per module

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

scope externals shound't compile

Sngletons<
Externals //compile error

ghi test

allow non const ref

QDEPS_CTOR(i&) -> non_const_ref

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;
}

};

or

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

factory_type;

Utility::Provider support

QDEPS_CTOR(Test, Provider i)
{
};

support of Bind<I, Provider >

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

input/output object types via policy

Examples

Wiki documentation

Default PerRequest scope with binding

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

clang 3.0 with c++11 - error: call to deleted constructor of '...'

Policy: CircularDependencies

disallow circular dependencies

Injector.visit -> dump to text

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

C1 --- C2
|
int

... in graphviz dot

delegate creation to other di

?

Policy: Singleton can't be passed by value

Module <
Singleton

{ };

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

policy: external reference without ownership

OK:
External

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

Externals with base front end

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

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

Fix code coverage results due to templates generation

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

GraphvizDotVisitor - text visitor is enough

convertible with scope

Policy: references have to be externals

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

fusion module without externals but in ctor

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

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

constructor traits outside the constructor

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

Named with interface -> verify

QDEPS_CTOR(Named<If, Name>)

Bind::InName

externals with fusion front end

BInd::To(32)

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

MT - modules combinations

Injector<M1, M2, M3>
modules tests

externals_mix

setter injection support

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

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

private:
int i_;
};

di::injector<>.create();

Base front end - Annotate support

Annotate< Bind::InCall >::With

Module(
Set(32)
)

Method injector - ctor injector is enough

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

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

C++11 fork

msvc 10 support (windows)