anchor.diff:  ----
   <1> retrieving the `BeanManager`
   <2> requesting an `InjectionTargetFactory` from the `BeanManager`
  -<3> using the new `AnnotatedTypeConfigurator` SPI in CDI 2.0 to configure the underlying `AnnotatedType`
  -<4> looking for the `MyField` field and adding `@Inject` to it (we use the new InjectLiteral in CDI 2.0)
  +<3> using the new `AnnotatedTypeConfigurator` SPI in CDI 2.0 to configure the underlying `AnnotatedType`. Before CDI 2.0 you'd have to implement `AnnotatedType` to add your annotation and use it in previous step (2)
  +<4> looking for the `MyField` field and adding `@Inject` to it (we use the new `InjectLiteral` introduced in CDI 2.0)
   <5> creating the `InjectionTarget`. As it's for a non-contextual instance, we create it by passing null (no bean) to the method
   <6> creating the `CreationalContext`. As it's for a non-contextual instance, we create it by passing null (no bean) to the method
  -<7> creating the instance and performing `@PostConstruct` lifecycle call back and injection
  +<7> creating the instance, performing `@PostConstruct` lifecycle call back and injection
   <8> call the `@Predestroy` lifecycle callback
   <9> release the `CreationalContext` and all the dependents bean instances
   
  -Note, that, we could also have added an interceptor binding with the `configure()` method.
  -
  -Before CDI 2.0 it would have been necessary to implement a specific AnnotatedType and provide it in step 2 to achieve the same.
  -
  -=== User Instantiated non-contextual instance
  -
  -If the instance shouldn't be created by the container, code is roughly the same
  +Note, that, we could also have added interceptor bindings to the `AnnotatedTypeConfigurator` during step (3).
  +In this case, `MyClass` shouldn't be unproxyable as detailed in the http://docs.jboss.org/cdi/spec/2.0/cdi-spec.html#unproxyable[spec^].
  +
  +
  +=== Use case 3: User Instantiated non-contextual instance
  +
  +If the instance is provided by the user, code is roughly the same
   
   [source,java]
   ----
  
positive.code: <6> perform destruction of the instance context (i.e. release all `@Dependent` instances injected in the instance)
  
  Keep in mind that letting the container producing the instance (`produce()` method) activate optional interceptors and decorators on the instance.
  In this case, the class shouldn't be unproxyable as detailed in the http://docs.jboss.org/cdi/spec/2.0/cdi-spec.html#unproxyable[spec^].
  
  `Unmanaged.UnmanagedInstance` is an important handler that gives you access to all CDI services for the instance you want to obtain, but it should also be kept to perform the `dispose()` tasks, which mainly release all dependent beans instances that were created with your instance.
   Without this call you may face memory leaks in your application
  
  === Non-contextual instance whose class doesn't have the required annotation
  
  Unfortunately, `Unmanaged` doesn't provide access to the underlying `AnnotatedType` for the instance class.
  
   So if you need to add annotation to the metadata model because they are missing on the original class, you'll have to use an `InjectionTargetFactory` provided by the container.
   Note that Unmanaged does the same under the hood.
  
  To request an `InjectionTargetFactory` from the container, you'll need first to access the `BeanManager`.
  
  If you are in CDI programming model (i.e in a bean) simply inject the BeanManager to access it
  
  [source,java]
  ----
  
negative.code: BeanManager bm;
  ----
  
  If are not CDI programming model, the easiest way to access the `BeanManager` is ot use the `CDI` class available since CDI 1.1 (note that it also works in CDI programming model even if direct injection is still preferred to static call done with `CDI.current()`).
  
  [source,java]
  ----
  BeanManager bm = CDI.current().getBeanManager();
  ----
  
  In certain circumstance, you may want to retrieve the `BeanManager` from a JNDI lookup through the `java:comp/BeanManager`, JNDI name.
  
  The following example show how to create a non-contextual instance from `MyClass` in which you need to create an injection point (add `@Inject`) on the field `MyField`
  
  [source,java]
  ----
  public void doSomethingWithContextualMyClass() {
          BeanManager bm = CDI.current().getBeanManager();  //<1>
          InjectionTargetFactory<MyClass> itf = bm
                  .getInjectionTargetFactory(bm.createAnnotatedType(MyClass.class)); //<2>
          itf.configure() //<3>
                  .filterFields(f -> "MyField".equals(f.getJavaMember().getName()))
                  .findFirst()
  