package dagger.internal;

import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Queue;
import java.util.Set;

public final class Linker
{
  private static final Object UNINITIALIZED = new Object();
  private boolean attachSuccess = true;
  private final Linker base;
  private final Map<String, Binding<?>> bindings = new HashMap();
  private final ErrorHandler errorHandler;
  private final List<String> errors = new ArrayList();
  private volatile Map<String, Binding<?>> linkedBindings = null;
  private final Loader plugin;
  private final Queue<Binding<?>> toLink = new ArrayQueue();
  
  public Linker(Linker paramLinker, Loader paramLoader, ErrorHandler paramErrorHandler)
  {
    if (paramLoader == null) {
      throw new NullPointerException("plugin");
    }
    if (paramErrorHandler == null) {
      throw new NullPointerException("errorHandler");
    }
    this.base = paramLinker;
    this.plugin = paramLoader;
    this.errorHandler = paramErrorHandler;
  }
  
  private void addError(String paramString)
  {
    this.errors.add(paramString);
  }
  
  private void assertLockHeld()
  {
    if (!Thread.holdsLock(this)) {
      throw new AssertionError();
    }
  }
  
  private Binding<?> createBinding(String paramString, Object paramObject, ClassLoader paramClassLoader, boolean paramBoolean)
  {
    String str = Keys.getBuiltInBindingsKey(paramString);
    if (str != null) {
      paramObject = new BuiltInBinding(paramString, paramObject, paramClassLoader, str);
    }
    do
    {
      return (Binding<?>)paramObject;
      str = Keys.getLazyKey(paramString);
      if (str != null) {
        return new LazyBinding(paramString, paramObject, paramClassLoader, str);
      }
      str = Keys.getClassName(paramString);
      if ((str == null) || (Keys.isAnnotated(paramString))) {
        throw new IllegalArgumentException(paramString);
      }
      paramClassLoader = this.plugin.getAtInjectBinding(paramString, str, paramClassLoader, paramBoolean);
      paramObject = paramClassLoader;
    } while (paramClassLoader != null);
    throw new Binding.InvalidBindingException(str, "could not be bound with key " + paramString);
  }
  
  private <T> void putBinding(Binding<T> paramBinding)
  {
    if (paramBinding.provideKey != null) {
      putIfAbsent(this.bindings, paramBinding.provideKey, paramBinding);
    }
    if (paramBinding.membersKey != null) {
      putIfAbsent(this.bindings, paramBinding.membersKey, paramBinding);
    }
  }
  
  private <K, V> void putIfAbsent(Map<K, V> paramMap, K paramK, V paramV)
  {
    paramV = paramMap.put(paramK, paramV);
    if (paramV != null) {
      paramMap.put(paramK, paramV);
    }
  }
  
  static <T> Binding<T> scope(Binding<T> paramBinding)
  {
    if ((!paramBinding.isSingleton()) || ((paramBinding instanceof SingletonBinding))) {
      return paramBinding;
    }
    return new SingletonBinding(paramBinding, null);
  }
  
  public final Map<String, Binding<?>> fullyLinkedBindings()
  {
    return this.linkedBindings;
  }
  
  public final void installBindings(BindingsGroup paramBindingsGroup)
  {
    if (this.linkedBindings != null) {
      throw new IllegalStateException("Cannot install further bindings after calling linkAll().");
    }
    paramBindingsGroup = paramBindingsGroup.entrySet().iterator();
    while (paramBindingsGroup.hasNext())
    {
      Map.Entry localEntry = (Map.Entry)paramBindingsGroup.next();
      this.bindings.put(localEntry.getKey(), scope((Binding)localEntry.getValue()));
    }
  }
  
  public final Map<String, Binding<?>> linkAll()
  {
    assertLockHeld();
    if (this.linkedBindings != null) {
      return this.linkedBindings;
    }
    Iterator localIterator = this.bindings.values().iterator();
    while (localIterator.hasNext())
    {
      Binding localBinding = (Binding)localIterator.next();
      if (!localBinding.isLinked()) {
        this.toLink.add(localBinding);
      }
    }
    linkRequested();
    this.linkedBindings = Collections.unmodifiableMap(this.bindings);
    return this.linkedBindings;
  }
  
  public final void linkRequested()
  {
    assertLockHeld();
    for (;;)
    {
      Binding localBinding1 = (Binding)this.toLink.poll();
      if (localBinding1 == null) {
        break;
      }
      if ((localBinding1 instanceof DeferredBinding))
      {
        Object localObject2 = (DeferredBinding)localBinding1;
        String str = ((DeferredBinding)localObject2).deferredKey;
        boolean bool = ((DeferredBinding)localObject2).mustHaveInjections;
        if (!this.bindings.containsKey(str)) {
          try
          {
            localObject2 = createBinding(str, localBinding1.requiredBy, ((DeferredBinding)localObject2).classLoader, bool);
            ((Binding)localObject2).setLibrary(localBinding1.library());
            ((Binding)localObject2).setDependedOn(localBinding1.dependedOn());
            if ((!str.equals(((Binding)localObject2).provideKey)) && (!str.equals(((Binding)localObject2).membersKey))) {
              throw new IllegalStateException("Unable to create binding for " + str);
            }
          }
          catch (Binding.InvalidBindingException localInvalidBindingException)
          {
            addError(localInvalidBindingException.type + " " + localInvalidBindingException.getMessage() + " required by " + localBinding1.requiredBy);
            this.bindings.put(str, Binding.UNRESOLVED);
            continue;
            Binding localBinding2 = scope(localInvalidBindingException);
            this.toLink.add(localBinding2);
            putBinding(localBinding2);
          }
          catch (UnsupportedOperationException localUnsupportedOperationException)
          {
            addError("Unsupported: " + localUnsupportedOperationException.getMessage() + " required by " + localBinding1.requiredBy);
            this.bindings.put(str, Binding.UNRESOLVED);
          }
          catch (IllegalArgumentException localIllegalArgumentException)
          {
            addError(localIllegalArgumentException.getMessage() + " required by " + localBinding1.requiredBy);
            this.bindings.put(str, Binding.UNRESOLVED);
          }
          catch (RuntimeException localRuntimeException)
          {
            throw localRuntimeException;
          }
          catch (Exception localException)
          {
            throw new RuntimeException(localException);
          }
        }
      }
      else
      {
        this.attachSuccess = true;
        localException.attach(this);
        if (this.attachSuccess) {
          localException.setLinked();
        } else {
          this.toLink.add(localException);
        }
      }
    }
    try
    {
      this.errorHandler.handleErrors(this.errors);
      return;
    }
    finally
    {
      this.errors.clear();
    }
  }
  
  @Deprecated
  public final Binding<?> requestBinding(String paramString, Object paramObject)
  {
    return requestBinding(paramString, paramObject, getClass().getClassLoader(), true, true);
  }
  
  public final Binding<?> requestBinding(String paramString, Object paramObject, ClassLoader paramClassLoader)
  {
    return requestBinding(paramString, paramObject, paramClassLoader, true, true);
  }
  
  public final Binding<?> requestBinding(String paramString, Object paramObject, ClassLoader paramClassLoader, boolean paramBoolean1, boolean paramBoolean2)
  {
    assertLockHeld();
    Linker localLinker = this;
    Binding localBinding1 = null;
    Binding localBinding2;
    for (;;)
    {
      localBinding2 = localBinding1;
      if (localLinker == null) {
        break;
      }
      localBinding1 = (Binding)localLinker.bindings.get(paramString);
      if (localBinding1 != null)
      {
        localBinding2 = localBinding1;
        if (localLinker == this) {
          break;
        }
        localBinding2 = localBinding1;
        if (localBinding1.isLinked()) {
          break;
        }
        throw new AssertionError();
      }
      localLinker = localLinker.base;
    }
    if (localBinding2 == null)
    {
      paramString = new DeferredBinding(paramString, paramClassLoader, paramObject, paramBoolean1, null);
      paramString.setLibrary(paramBoolean2);
      paramString.setDependedOn(true);
      this.toLink.add(paramString);
      this.attachSuccess = false;
      return null;
    }
    if (!localBinding2.isLinked()) {
      this.toLink.add(localBinding2);
    }
    localBinding2.setLibrary(paramBoolean2);
    localBinding2.setDependedOn(true);
    return localBinding2;
  }
  
  @Deprecated
  public final Binding<?> requestBinding(String paramString, Object paramObject, boolean paramBoolean1, boolean paramBoolean2)
  {
    return requestBinding(paramString, paramObject, getClass().getClassLoader(), paramBoolean1, paramBoolean2);
  }
  
  static class DeferredBinding
    extends Binding<Object>
  {
    final ClassLoader classLoader;
    final String deferredKey;
    final boolean mustHaveInjections;
    
    private DeferredBinding(String paramString, ClassLoader paramClassLoader, Object paramObject, boolean paramBoolean)
    {
      super(null, false, paramObject);
      this.deferredKey = paramString;
      this.classLoader = paramClassLoader;
      this.mustHaveInjections = paramBoolean;
    }
    
    public void getDependencies(Set<Binding<?>> paramSet1, Set<Binding<?>> paramSet2)
    {
      throw new UnsupportedOperationException("Deferred bindings must resolve first.");
    }
    
    public void injectMembers(Object paramObject)
    {
      throw new UnsupportedOperationException("Deferred bindings must resolve first.");
    }
    
    public String toString()
    {
      return "DeferredBinding[deferredKey=" + this.deferredKey + "]";
    }
  }
  
  public static abstract interface ErrorHandler
  {
    public static final ErrorHandler NULL = new ErrorHandler()
    {
      public final void handleErrors(List<String> paramAnonymousList) {}
    };
    
    public abstract void handleErrors(List<String> paramList);
  }
  
  static class SingletonBinding<T>
    extends Binding<T>
  {
    private final Binding<T> binding;
    private volatile Object onlyInstance = Linker.UNINITIALIZED;
    
    private SingletonBinding(Binding<T> paramBinding)
    {
      super(paramBinding.membersKey, true, paramBinding.requiredBy);
      this.binding = paramBinding;
    }
    
    public void attach(Linker paramLinker)
    {
      this.binding.attach(paramLinker);
    }
    
    public boolean dependedOn()
    {
      return this.binding.dependedOn();
    }
    
    public T get()
    {
      if (this.onlyInstance == Linker.UNINITIALIZED) {}
      try
      {
        if (this.onlyInstance == Linker.UNINITIALIZED) {
          this.onlyInstance = this.binding.get();
        }
        return (T)this.onlyInstance;
      }
      finally {}
    }
    
    public void getDependencies(Set<Binding<?>> paramSet1, Set<Binding<?>> paramSet2)
    {
      this.binding.getDependencies(paramSet1, paramSet2);
    }
    
    public void injectMembers(T paramT)
    {
      this.binding.injectMembers(paramT);
    }
    
    public boolean isCycleFree()
    {
      return this.binding.isCycleFree();
    }
    
    public boolean isLinked()
    {
      return this.binding.isLinked();
    }
    
    protected boolean isSingleton()
    {
      return true;
    }
    
    public boolean isVisiting()
    {
      return this.binding.isVisiting();
    }
    
    public boolean library()
    {
      return this.binding.library();
    }
    
    public void setCycleFree(boolean paramBoolean)
    {
      this.binding.setCycleFree(paramBoolean);
    }
    
    public void setDependedOn(boolean paramBoolean)
    {
      this.binding.setDependedOn(paramBoolean);
    }
    
    public void setLibrary(boolean paramBoolean)
    {
      this.binding.setLibrary(true);
    }
    
    protected void setLinked()
    {
      this.binding.setLinked();
    }
    
    public void setVisiting(boolean paramBoolean)
    {
      this.binding.setVisiting(paramBoolean);
    }
    
    public String toString()
    {
      return "@Singleton/" + this.binding.toString();
    }
  }
}


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