import com.google.inject.spi.LinkedKeyBinding; //导入依赖的package包/类
private static String instantiation(Binding<?> binding) {
  if (binding instanceof InstanceBinding<?>) {
    return instanceLiteral((InstanceBinding<?>) binding);
  } else if (binding instanceof ProviderKeyBinding<?>) {
    return providerCall(((ProviderKeyBinding<?>) binding).getProviderKey()) + ".get()";
  } else if (binding instanceof LinkedKeyBinding<?>) {
    return providerCall(((LinkedKeyBinding<?>) binding).getLinkedKey());
  } else if (binding instanceof ConstructorBinding<?>) {
    return constructorCall((ConstructorBinding<?>) binding);
  } else if (binding instanceof ProviderBinding<?>) {
    return provider((ProviderBinding<?>) binding);
  } else if (binding instanceof ProviderInstanceBinding<?>) {
    return instantiation((ProviderInstanceBinding<?>) binding);
  } else {
    throw new DeguicifierException();
  }
}
 

import com.google.inject.spi.LinkedKeyBinding; //导入依赖的package包/类
public static <T> Optional<TypeLiteral<? extends T>> targetType(Injector injector, Binding<T> binding) {
    if(binding instanceof UntargettedBinding) {
        return Optional.of(binding.getKey().getTypeLiteral());
    } else if(binding instanceof ConstructorBinding) {
        return Optional.of((TypeLiteral<? extends T>) ((ConstructorBinding) binding).getConstructor().getDeclaringType());
    } else if(binding instanceof InstanceBinding) {
        return Optional.of(TypeLiteral.get((Class<T>) ((InstanceBinding) binding).getInstance().getClass()));
    } else if(binding instanceof LinkedKeyBinding) {
        return targetType(injector, injector.getBinding(((LinkedKeyBinding) binding).getLinkedKey()));
    } else if(binding instanceof ExposedBinding) {
        return targetType(((ExposedBinding) binding).getPrivateElements().getInjector(), binding.getKey());
    }
    return Optional.empty();
}
 

import com.google.inject.spi.LinkedKeyBinding; //导入依赖的package包/类
@Override
public <T> Collection<T> getBeansOfType(Class<T> clazz)
{
	Injector injector = ensureInjector();
	List<T> beans = new ArrayList<T>();
	Map<Key<?>, Binding<?>> bindings = injector.getBindings();
	for( Binding<?> binding : bindings.values() )
	{
		Key<?> actualKey = null;
		if( binding instanceof UntargettedBinding || binding instanceof ConstructorBinding )
		{
			actualKey = binding.getKey();
		}
		else if( binding instanceof LinkedKeyBinding )
		{
			actualKey = ((LinkedKeyBinding<?>) binding).getLinkedKey();
		}
		else if( binding instanceof ProviderBinding )
		{
			actualKey = ((ProviderBinding<?>) binding).getProvidedKey();
		}
		if( actualKey != null && clazz.isAssignableFrom(actualKey.getTypeLiteral().getRawType()) )
		{
			beans.add(clazz.cast(binding.getProvider().get()));
		}
	}
	return beans;
}
 

import com.google.inject.spi.LinkedKeyBinding; //导入依赖的package包/类
@Test
public void binds_linked_key() {
  given(module = new AbstractModule() {
    @Override
    protected void configure() {
      bind(Interface.class).to(Implementation.class);
    }
  });
  given(injector = Guice.createInjector(module));
  when(injector.getBinding(Interface.class));
  thenReturned(instanceOf(LinkedKeyBinding.class));
}
 

import com.google.inject.spi.LinkedKeyBinding; //导入依赖的package包/类
/**
 * Visitor for {@link LinkedKeyBinding}. This is the standard {@link Binding} you get from
 * binding an interface class to an implementation class. We draw a {@link BindingEdge} from the
 * interface node to the node of the implementing class.
 */
@Override
public Collection<Edge> visit(LinkedKeyBinding<?> binding) {
  return ImmutableList.<Edge>of(
      new BindingEdge(
          NodeId.newTypeId(binding.getKey()),
          NodeId.newTypeId(binding.getLinkedKey()),
          BindingEdge.Type.NORMAL));
}
 

import com.google.inject.spi.LinkedKeyBinding; //导入依赖的package包/类
public void testVisitLinkedKey() {
  Binding<?> binding = getBinding(Key.get(Interface.class), new LinkedKeyModule());
  Collection<Key<?>> dependencies = visitor.visit((LinkedKeyBinding<?>) binding);

  // Dependency should be to the class this interface is bound to.
  assertDependencies(dependencies, Key.get(ConstructedClass.class));
}
 

import com.google.inject.spi.LinkedKeyBinding; //导入依赖的package包/类
@Override
public String toString() {
  return MoreObjects.toStringHelper(LinkedKeyBinding.class)
      .add("key", getKey())
      .add("source", getSource())
      .add("scope", getScoping())
      .add("target", targetKey)
      .toString();
}
 

import com.google.inject.spi.LinkedKeyBinding; //导入依赖的package包/类
private static boolean matches(Binding<?> item, BindResult<?> result) {
  switch (result.type) {
    case INSTANCE:
      if (item instanceof InstanceBinding
          && ((InstanceBinding) item).getInstance().equals(result.instance)) {
        return true;
      }
      break;
    case LINKED:
      if (item instanceof LinkedKeyBinding
          && ((LinkedKeyBinding) item).getLinkedKey().equals(result.key)) {
        return true;
      }
      break;
    case PROVIDER_INSTANCE:
      if (item instanceof ProviderInstanceBinding
          && Objects.equal(
              ((ProviderInstanceBinding) item).getUserSuppliedProvider().get(),
              result.instance)) {
        return true;
      }
      break;
    case PROVIDER_KEY:
      if (item instanceof ProviderKeyBinding
          && ((ProviderKeyBinding) item).getProviderKey().equals(result.key)) {
        return true;
      }
      break;
  }
  return false;
}
 

import com.google.inject.spi.LinkedKeyBinding; //导入依赖的package包/类
private static boolean matches(Binding<?> item, BindResult<?> result) {
  switch (result.type) {
  case INSTANCE:
    if (item instanceof InstanceBinding
        && ((InstanceBinding) item).getInstance().equals(result.instance)) {
      return true;
    }
    break;
  case LINKED:
    if (item instanceof LinkedKeyBinding
        && ((LinkedKeyBinding) item).getLinkedKey().equals(result.key)) {
      return true;
    }
    break;
  case PROVIDER_INSTANCE:
    if (item instanceof ProviderInstanceBinding
        && Objects.equal(((ProviderInstanceBinding) item).getUserSuppliedProvider().get(),
                         result.instance)) {
      return true;
    }
    break;
  case PROVIDER_KEY:
    if (item instanceof ProviderKeyBinding
        && ((ProviderKeyBinding) item).getProviderKey().equals(result.key)) {
      return true;
    }
    break;
  }
  return false;
}
 

import com.google.inject.spi.LinkedKeyBinding; //导入依赖的package包/类
@Override public String toString() {
  return Objects.toStringHelper(LinkedKeyBinding.class)
      .add("key", getKey())
      .add("source", getSource())
      .add("scope", getScoping())
      .add("target", targetKey)
      .toString();
}
 

import com.google.inject.spi.LinkedKeyBinding; //导入依赖的package包/类
@Override
public Optional<TypeLiteral<?>> visit(LinkedKeyBinding<?> binding) {
    // Delegate to the binding for the target type
    return injector.getBinding(binding.getLinkedKey()).acceptTargetVisitor(this);
}
 

import com.google.inject.spi.LinkedKeyBinding; //导入依赖的package包/类
@Override
public Object visit(LinkedKeyBinding<? extends T> linkedKeyBinding) {
    requireKey(linkedKeyBinding.getLinkedKey());
    return super.visit(linkedKeyBinding);
}
 

import com.google.inject.spi.LinkedKeyBinding; //导入依赖的package包/类
@Override
public Void visit(LinkedKeyBinding<? extends T> binding) {
    scope(binding, rebind(binding).to(binding.getLinkedKey()));
    return null;
}
 

import com.google.inject.spi.LinkedKeyBinding; //导入依赖的package包/类
@Override
public Void visit(LinkedKeyBinding<? extends Object> linkedKeyBinding)
{
	analyzeImplementation(linkedKeyBinding.getLinkedKey().getTypeLiteral(), false);
	return null;
}
 

import com.google.inject.spi.LinkedKeyBinding; //导入依赖的package包/类
public Void visit(LinkedKeyBinding<? extends T> linkedKeyBinding) {
  Context context = Context.forElement(linkedKeyBinding);
  bindingsCollection.addBinding(targetKey,
      bindingFactory.getBindClassBinding(linkedKeyBinding.getLinkedKey(), targetKey, context));
  return null;
}
 

import com.google.inject.spi.LinkedKeyBinding; //导入依赖的package包/类
@Override
public Collection<Key<?>> visit(LinkedKeyBinding<?> binding) {
  return ImmutableSet.<Key<?>>of(binding.getLinkedKey());
}
 

import com.google.inject.spi.LinkedKeyBinding; //导入依赖的package包/类
@Override
public Indexer.IndexedBinding visit(LinkedKeyBinding<? extends Object> binding) {
  return new Indexer.IndexedBinding(
      binding, BindingType.LINKED_KEY, scope(binding), binding.getLinkedKey());
}
 

import com.google.inject.spi.LinkedKeyBinding; //导入依赖的package包/类
@Override
public ResolvedBinding<T> visit(LinkedKeyBinding<? extends T> linkedKeyBinding) {
  return traverse(linkedKeyBinding.getLinkedKey());
}
 

import com.google.inject.spi.LinkedKeyBinding; //导入依赖的package包/类
@Override public Collection<Key<?>> visit(LinkedKeyBinding<?> binding) {
  return ImmutableSet.<Key<?>>of(binding.getLinkedKey());
}
 

import com.google.inject.spi.LinkedKeyBinding; //导入依赖的package包/类
/**
 * Visitor for {@link LinkedKeyBinding}. This is the standard {@link Binding} you get from
 * binding an interface class to an implementation class. We  draw a {@link BindingEdge} from
 * the interface node to the node of the implementing class.
 */
@Override public Collection<Edge> visit(LinkedKeyBinding<?> binding) {
  return ImmutableList.<Edge>of(new BindingEdge(NodeId.newTypeId(binding.getKey()),
      NodeId.newTypeId(binding.getLinkedKey()),
      BindingEdge.Type.NORMAL));
}