package dagger;

import dagger.internal.Binding;
import dagger.internal.BindingsGroup;
import dagger.internal.FailoverLoader;
import dagger.internal.Keys;
import dagger.internal.Linker;
import dagger.internal.Loader;
import dagger.internal.ModuleAdapter;
import dagger.internal.Modules;
import dagger.internal.ProblemDetector;
import dagger.internal.SetBinding;
import dagger.internal.StaticInjection;
import dagger.internal.ThrowingErrorHandler;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Set;

public abstract class ObjectGraph
{
  public static ObjectGraph create(Object... paramVarArgs)
  {
    return DaggerObjectGraph.makeGraph(null, new FailoverLoader(), paramVarArgs);
  }
  
  static ObjectGraph createWith(Loader paramLoader, Object... paramVarArgs)
  {
    return DaggerObjectGraph.makeGraph(null, paramLoader, paramVarArgs);
  }
  
  public abstract <T> T get(Class<T> paramClass);
  
  public abstract <T> T inject(T paramT);
  
  public abstract void injectStatics();
  
  public abstract ObjectGraph plus(Object... paramVarArgs);
  
  public abstract void validate();
  
  static class DaggerObjectGraph
    extends ObjectGraph
  {
    private final DaggerObjectGraph base;
    private final Map<String, Class<?>> injectableTypes;
    private final Linker linker;
    private final Loader plugin;
    private final List<SetBinding<?>> setBindings;
    private final Map<Class<?>, StaticInjection> staticInjections;
    
    DaggerObjectGraph(DaggerObjectGraph paramDaggerObjectGraph, Linker paramLinker, Loader paramLoader, Map<Class<?>, StaticInjection> paramMap, Map<String, Class<?>> paramMap1, List<SetBinding<?>> paramList)
    {
      this.base = paramDaggerObjectGraph;
      this.linker = ((Linker)checkNotNull(paramLinker, "linker"));
      this.plugin = ((Loader)checkNotNull(paramLoader, "plugin"));
      this.staticInjections = ((Map)checkNotNull(paramMap, "staticInjections"));
      this.injectableTypes = ((Map)checkNotNull(paramMap1, "injectableTypes"));
      this.setBindings = ((List)checkNotNull(paramList, "setBindings"));
    }
    
    private static <T> T checkNotNull(T paramT, String paramString)
    {
      if (paramT == null) {
        throw new NullPointerException(paramString);
      }
      return paramT;
    }
    
    private Binding<?> getInjectableTypeBinding(ClassLoader paramClassLoader, String paramString1, String paramString2)
    {
      Class localClass = null;
      for (Object localObject = this; localObject != null; localObject = ((DaggerObjectGraph)localObject).base)
      {
        localClass = (Class)((DaggerObjectGraph)localObject).injectableTypes.get(paramString1);
        if (localClass != null) {
          break;
        }
      }
      if (localClass == null) {
        throw new IllegalArgumentException("No inject registered for " + paramString1 + ". You must explicitly add it to the 'injects' option in one of your modules.");
      }
      synchronized (this.linker)
      {
        localObject = this.linker.requestBinding(paramString2, localClass, paramClassLoader, false, true);
        if (localObject != null)
        {
          paramString1 = (String)localObject;
          if (((Binding)localObject).isLinked()) {}
        }
        else
        {
          this.linker.linkRequested();
          paramString1 = this.linker.requestBinding(paramString2, localClass, paramClassLoader, false, true);
        }
        return paramString1;
      }
    }
    
    private Map<String, Binding<?>> linkEverything()
    {
      ??? = this.linker.fullyLinkedBindings();
      if (??? != null) {
        return (Map<String, Binding<?>>)???;
      }
      synchronized (this.linker)
      {
        Map localMap1 = this.linker.fullyLinkedBindings();
        if (localMap1 != null) {
          return localMap1;
        }
      }
      linkStaticInjections();
      linkInjectableTypes();
      Map localMap2 = this.linker.linkAll();
      return localMap2;
    }
    
    private void linkInjectableTypes()
    {
      Iterator localIterator = this.injectableTypes.entrySet().iterator();
      while (localIterator.hasNext())
      {
        Map.Entry localEntry = (Map.Entry)localIterator.next();
        this.linker.requestBinding((String)localEntry.getKey(), localEntry.getValue(), ((Class)localEntry.getValue()).getClassLoader(), false, true);
      }
    }
    
    private void linkStaticInjections()
    {
      Iterator localIterator = this.staticInjections.entrySet().iterator();
      while (localIterator.hasNext())
      {
        Map.Entry localEntry = (Map.Entry)localIterator.next();
        StaticInjection localStaticInjection2 = (StaticInjection)localEntry.getValue();
        StaticInjection localStaticInjection1 = localStaticInjection2;
        if (localStaticInjection2 == null)
        {
          localStaticInjection1 = this.plugin.getStaticInjection((Class)localEntry.getKey());
          localEntry.setValue(localStaticInjection1);
        }
        localStaticInjection1.attach(this.linker);
      }
    }
    
    private static ObjectGraph makeGraph(DaggerObjectGraph paramDaggerObjectGraph, Loader paramLoader, Object... paramVarArgs)
    {
      LinkedHashMap localLinkedHashMap1 = new LinkedHashMap();
      LinkedHashMap localLinkedHashMap2 = new LinkedHashMap();
      if (paramDaggerObjectGraph == null) {}
      ObjectGraph.OverridesBindings localOverridesBindings;
      Map.Entry localEntry;
      ModuleAdapter localModuleAdapter;
      for (ObjectGraph.StandardBindings localStandardBindings = new ObjectGraph.StandardBindings();; localStandardBindings = new ObjectGraph.StandardBindings(paramDaggerObjectGraph.setBindings))
      {
        localOverridesBindings = new ObjectGraph.OverridesBindings();
        Iterator localIterator = Modules.loadModules(paramLoader, paramVarArgs).entrySet().iterator();
        if (!localIterator.hasNext()) {
          break label257;
        }
        localEntry = (Map.Entry)localIterator.next();
        localModuleAdapter = (ModuleAdapter)localEntry.getKey();
        i = 0;
        while (i < localModuleAdapter.injectableTypes.length)
        {
          localLinkedHashMap1.put(localModuleAdapter.injectableTypes[i], localModuleAdapter.moduleClass);
          i += 1;
        }
      }
      int i = 0;
      while (i < localModuleAdapter.staticInjections.length)
      {
        localLinkedHashMap2.put(localModuleAdapter.staticInjections[i], null);
        i += 1;
      }
      for (;;)
      {
        try
        {
          if (localModuleAdapter.overrides)
          {
            paramVarArgs = localOverridesBindings;
            localModuleAdapter.getBindings(paramVarArgs, localEntry.getValue());
          }
        }
        catch (IllegalArgumentException paramDaggerObjectGraph)
        {
          throw new IllegalArgumentException(localModuleAdapter.moduleClass.getSimpleName() + ": " + paramDaggerObjectGraph.getMessage(), paramDaggerObjectGraph);
        }
        paramVarArgs = localStandardBindings;
      }
      label257:
      if (paramDaggerObjectGraph != null) {}
      for (paramVarArgs = paramDaggerObjectGraph.linker;; paramVarArgs = null)
      {
        paramVarArgs = new Linker(paramVarArgs, paramLoader, new ThrowingErrorHandler());
        paramVarArgs.installBindings(localStandardBindings);
        paramVarArgs.installBindings(localOverridesBindings);
        return new DaggerObjectGraph(paramDaggerObjectGraph, paramVarArgs, paramLoader, localLinkedHashMap2, localLinkedHashMap1, ObjectGraph.StandardBindings.access$100(localStandardBindings));
      }
    }
    
    public <T> T get(Class<T> paramClass)
    {
      String str2 = Keys.get(paramClass);
      if (paramClass.isInterface()) {}
      for (String str1 = str2;; str1 = Keys.getMembersKey(paramClass)) {
        return (T)getInjectableTypeBinding(paramClass.getClassLoader(), str1, str2).get();
      }
    }
    
    public <T> T inject(T paramT)
    {
      String str = Keys.getMembersKey(paramT.getClass());
      getInjectableTypeBinding(paramT.getClass().getClassLoader(), str, str).injectMembers(paramT);
      return paramT;
    }
    
    public void injectStatics()
    {
      synchronized (this.linker)
      {
        linkStaticInjections();
        this.linker.linkRequested();
        linkStaticInjections();
        ??? = this.staticInjections.entrySet().iterator();
        if (((Iterator)???).hasNext()) {
          ((StaticInjection)((Map.Entry)((Iterator)???).next()).getValue()).inject();
        }
      }
    }
    
    public ObjectGraph plus(Object... paramVarArgs)
    {
      linkEverything();
      return makeGraph(this, this.plugin, paramVarArgs);
    }
    
    public void validate()
    {
      Map localMap = linkEverything();
      new ProblemDetector().detectProblems(localMap.values());
    }
  }
  
  static final class OverridesBindings
    extends BindingsGroup
  {
    public final Binding<?> contributeSetBinding(String paramString, SetBinding<?> paramSetBinding)
    {
      throw new IllegalArgumentException("Module overrides cannot contribute set bindings.");
    }
  }
  
  static final class StandardBindings
    extends BindingsGroup
  {
    private final List<SetBinding<?>> setBindings;
    
    public StandardBindings()
    {
      this.setBindings = new ArrayList();
    }
    
    public StandardBindings(List<SetBinding<?>> paramList)
    {
      this.setBindings = new ArrayList(paramList.size());
      paramList = paramList.iterator();
      while (paramList.hasNext())
      {
        SetBinding localSetBinding = new SetBinding((SetBinding)paramList.next());
        this.setBindings.add(localSetBinding);
        put(localSetBinding.provideKey, localSetBinding);
      }
    }
    
    public final Binding<?> contributeSetBinding(String paramString, SetBinding<?> paramSetBinding)
    {
      this.setBindings.add(paramSetBinding);
      return super.put(paramString, paramSetBinding);
    }
  }
}


/* Location:              /home/merong/decompile/hackery-dex2jar.jar!/dagger/ObjectGraph.class
 * Java compiler version: 6 (50.0)
 * JD-Core Version:       0.7.1
 */