ContainerImpl(Map<?> factories) 
{
    this.factories = factories;
    Map< Class< ? >,Set< String > > map = new HashMap< Class< ? >,Set< String > >();
    for (Key< ? > key : factories.keySet()) {
      Set< String > names = map.get(key.getType());
      if (names == null) {
        names = new HashSet< String >();
        map.put(key.getType(), names);
      }
      names.add(key.getName());
    }
    for (Entry< Class< ? >,Set< String > > entry : map.entrySet()) {
      entry.setValue(Collections.unmodifiableSet(entry.getValue()));
    }
    this.factoryNamesByType = Collections.unmodifiableMap(map);
}

  void addInjectors(Class clazz,
    List<Injector> injectors) 
{
    if (clazz == Object.class) {
      return;
    }
    // Add injectors for superclass first.
    addInjectors(clazz.getSuperclass(), injectors);
    // TODO (crazybob): Filter out overridden members.
    addInjectorsForFields(clazz.getDeclaredFields(), false, injectors);
    addInjectorsForMethods(clazz.getDeclaredMethods(), false, injectors);
}

Recursively adds injectors for fields and methods from the given class to the given list. Injects parent classes before sub classes.

  void addInjectorsForFields(Field[] fields,
    boolean statics,
    List<Injector> injectors) 
{
    addInjectorsForMembers(Arrays.asList(fields), statics, injectors,
        new InjectorFactory< Field >() {
          public Injector create(ContainerImpl container, Field field,
              String name) throws MissingDependencyException {
            return new FieldInjector(container, field, name);
          }
        });
}

  void addInjectorsForMembers(List<M> members,
    boolean statics,
    List<Injector> injectors,
    InjectorFactory<M> injectorFactory) 
{
    for (M member : members) {
      if (isStatic(member) == statics) {
        Inject inject = member.getAnnotation(Inject.class);
        if (inject != null) {
          try {
            injectors.add(injectorFactory.create(this, member, inject.value()));
          } catch (MissingDependencyException e) {
            if (inject.required()) {
              throw new DependencyException(e);
            }
          }
        }
      }
    }
}

  void addInjectorsForMethods(Method[] methods,
    boolean statics,
    List<Injector> injectors) 
{
    addInjectorsForMembers(Arrays.asList(methods), statics, injectors,
        new InjectorFactory< Method >() {
          public Injector create(ContainerImpl container, Method method,
              String name) throws MissingDependencyException {
            return new MethodInjector(container, method, name);
          }
        });
}

 T callInContext(ContextualCallable<T> callable) 
{
    Object[] reference = localContext.get();
    if (reference[0] == null) {
      reference[0] = new InternalContext(this);
      try {
        return callable.call((InternalContext)reference[0]);
      } finally {
        // Only remove the context if this call created it.
        reference[0] = null;
      }
    } else {
      // Someone else will clean up this context.
      return callable.call((InternalContext)reference[0]);
    }
}

Looks up thread local context. Creates (and removes) a new context if necessary.

 ParameterInjector<T> createParameterInjector(Key<T> key,
    Member member) throws MissingDependencyException 
{
    InternalFactory< ? extends T > factory = getFactory(key);
    if (factory == null) {
      throw new MissingDependencyException(
          "No mapping found for dependency " + key + " in " + member + ".");
    }
    ExternalContext< T > externalContext =
        ExternalContext.newInstance(member, key, this);
    return new ParameterInjector< T >(externalContext, factory);
}

 Inject findInject(Annotation[] annotations) 
{
    for (Annotation annotation : annotations) {
      if (annotation.annotationType() == Inject.class) {
        return Inject.class.cast(annotation);
      }
    }
    return null;
}

Finds the Inject annotation in an array of annotations.

 ConstructorInjector<T> getConstructor(Class<T> implementation) 
{
    return constructors.get(implementation);
}

Gets a constructor function for a given implementation class.

 InternalFactory<? extends T> getFactory(Key<T> key) 
{
    return (InternalFactory< T >) factories.get(key);
}

 public T getInstance(Class<T> type) 
{
    return callInContext(new ContextualCallable< T >() {
      public T call(InternalContext context) {
        return getInstance(type, context);
      }
    });
}

 T getInstance(Class<T> type,
    InternalContext context) 
{
    return getInstance(type, DEFAULT_NAME, context);
}

 public T getInstance(Class<T> type,
    String name) 
{
    return callInContext(new ContextualCallable< T >() {
      public T call(InternalContext context) {
        return getInstance(type, name, context);
      }
    });
}

 T getInstance(Class<T> type,
    String name,
    InternalContext context) 
{
    ExternalContext< ? > previous = context.getExternalContext();
    Key< T > key = Key.newInstance(type, name);
    context.setExternalContext(ExternalContext.newInstance(null, key, this));
    try {
      InternalFactory o = getFactory(key);
      if (o != null) {
          return getFactory(key).create(context);
      } else {
          return null;
      }
    } finally {
      context.setExternalContext(previous);
    }
}

 public Set<String> getInstanceNames(Class<?> type) 
{
    return factoryNamesByType.get(type);
}

 ParameterInjector<?>[] getParametersInjectors(M member,
    Annotation[][] annotations,
    Class[] parameterTypes,
    String defaultName) throws MissingDependencyException 
{
    List< ParameterInjector< ? > > parameterInjectors =
        new ArrayList< ParameterInjector< ? > >();
    Iterator< Annotation[] > annotationsIterator =
        Arrays.asList(annotations).iterator();
    for (Class< ? > parameterType : parameterTypes) {
      Inject annotation = findInject(annotationsIterator.next());
      String name = annotation == null ? defaultName : annotation.value();
      Key< ? > key = Key.newInstance(parameterType, name);
      parameterInjectors.add(createParameterInjector(key, member));
    }
    return toArray(parameterInjectors);
}

Gets parameter injectors.

 public  void inject(Object o) 
{
    callInContext(new ContextualCallable< Void >() {
      public Void call(InternalContext context) {
        inject(o, context);
        return null;
      }
    });
}

 public T inject(Class<T> implementation) 
{
    return callInContext(new ContextualCallable< T >() {
      public T call(InternalContext context) {
        return inject(implementation, context);
      }
    });
}

  void inject(Object o,
    InternalContext context) 
{
    List< Injector > injectors = this.injectors.get(o.getClass());
    for (Injector injector : injectors) {
      injector.inject(context, o);
    }
}

 T inject(Class<T> implementation,
    InternalContext context) 
{
    try {
      ConstructorInjector< T > constructor = getConstructor(implementation);
      return implementation.cast(
          constructor.construct(context, implementation));
    } catch (Exception e) {
      throw new RuntimeException(e);
    }
}

  void injectStatics(List<?> staticInjections) 
{
    final List< Injector > injectors = new ArrayList< Injector >();
    for (Class< ? > clazz : staticInjections) {
      addInjectorsForFields(clazz.getDeclaredFields(), true, injectors);
      addInjectorsForMethods(clazz.getDeclaredMethods(), true, injectors);
    }
    callInContext(new ContextualCallable< Void >() {
      public Void call(InternalContext context) {
        for (Injector injector : injectors) {
          injector.inject(context, null);
        }
        return null;
      }
    });
}

 public  void removeScopeStrategy() 
{
    this.localScopeStrategy.remove();
}

 public  void setScopeStrategy(Strategy scopeStrategy) 
{
    this.localScopeStrategy.set(scopeStrategy);
}