Java Context类代码示例

import com.google.gwt.inject.rebind.binding.Context; //导入依赖的package包/类
private BindClassBinding createImplementedByBinding(Key<?> key, ImplementedBy implementedBy)
    throws BindingCreationException {
  Class<?> rawType = key.getTypeLiteral().getRawType();
  Class<?> implementationType = implementedBy.value();

  if (implementationType == rawType) {
    throw new BindingCreationException(
        "@ImplementedBy points to the same class it annotates: %s", rawType);
  }

  if (!rawType.isAssignableFrom(implementationType)) {
    throw new BindingCreationException("%s doesn't extend %s (while resolving @ImplementedBy)",
        implementationType, rawType);
  }

  return bindingFactory.getBindClassBinding(Key.get(implementationType), key,
      Context.forText("@ImplementedBy annotation"));
}
 

import com.google.gwt.inject.rebind.binding.Context; //导入依赖的package包/类
public Void visit(ProviderInstanceBinding<? extends T> providerInstanceBinding) {
  // Detect provider methods and handle them
  // TODO(bstoler): Update this when the SPI explicitly has a case for
  // provider methods
  Provider<? extends T> provider = providerInstanceBinding.getProviderInstance();
  if (provider instanceof ProviderMethod) {
    Context context = Context.forElement(providerInstanceBinding);
    bindingsCollection.addBinding(targetKey,
        bindingFactory.getProviderMethodBinding((ProviderMethod<?>) provider, context));
    return null;
  }

  if (provider instanceof GwtDotCreateProvider) {
    addImplicitBinding(providerInstanceBinding);
    return null;
  }

  // OTt, use the normal default handler (and error)
  return super.visit(providerInstanceBinding);
}
 

import com.google.gwt.inject.rebind.binding.Context; //导入依赖的package包/类
private void createBindingsForFactories(GinjectorBindings bindings) {
  for (final FactoryModule<?> factoryModule : bindings.getFactoryModules()) {
    FactoryBinding binding;
    try {
      binding = bindingFactory.getFactoryBinding(
          factoryModule.getBindings(),
          factoryModule.getFactoryType(),
          Context.forText(factoryModule.getSource()));
    } catch (ConfigurationException e) {
      errorManager.logError("Factory %s could not be created", e, factoryModule.getFactoryType());
      continue;
    }

    bindings.addBinding(factoryModule.getFactoryType(), binding);
  }
}
 

import com.google.gwt.inject.rebind.binding.Context; //导入依赖的package包/类
/**
 * Writes out a binding context, followed by a newline.
 *
 * <p>Binding contexts may contain newlines; this routine translates those for
 * the SourceWriter to ensure that indents, Javadoc comments, etc are handled
 * properly.
 */
public void writeBindingContext(SourceWriter writer, Context context) {
  // Avoid a trailing \n -- the GWT class source file composer will output an
  // ugly extra newline if we do that.
  String text = context.toString();
  boolean first = true;
  for (String line : text.split("\n")) {
    if (first) {
      first = false;
    } else {
      writer.println();
    }
    // Indent the line relative to its current location.  writer.indent()
    // won't work, since it does the wrong thing in Javadoc.
    writer.print("  ");
    writer.print(line);
  }
}
 

import com.google.gwt.inject.rebind.binding.Context; //导入依赖的package包/类
/**
 * For each binding exposed from a child, expect it to be represented
 * in the parent by an {@link ExposedChildBinding}.
 */
private void expectExposedBindingsExist() {
  for (Map.Entry<GinjectorBindings, Map<Key<?>, GinjectorBindings>> entry :
      exposedTo.entrySet()) {
    GinjectorBindings parent = entry.getKey();
    Map<Key<?>, GinjectorBindings> keyToChildMap = entry.getValue();

    for (Map.Entry<Key<?>, GinjectorBindings> keyAndChild : keyToChildMap.entrySet()) {
      Key<?> key = keyAndChild.getKey();
      GinjectorBindings child = keyAndChild.getValue();

      expect(parent.getBinding(key))
          .andReturn(new ExposedChildBinding(errorManager, Key.get(Long.class), child,
              Context.forText("")))
          .anyTimes();
    }
  }
}
 

import com.google.gwt.inject.rebind.binding.Context; //导入依赖的package包/类
/**
 * Ensure that the binding for key which exists in the parent Ginjector is also available to the
 * child Ginjector.
 */
private void ensureAccessible(Key<?> key, GinjectorBindings parent, GinjectorBindings child) {
  // Parent will be null if it is was an optional dependency and it couldn't be created.
  if (parent != null && !child.equals(parent) && !child.isBound(key)) {
    PrettyPrinter.log(logger, TreeLogger.DEBUG,
        "In %s: inheriting binding for %s from the parent %s", child, key, parent);
    Context context = Context.format("Inheriting %s from parent", key);

    // We don't strictly need all the extra checks in addBinding, but it can't hurt.  We know, for
    // example, that there will not be any unresolved bindings for this key.
    child.addBinding(key, bindingFactory.getParentBinding(key, parent, context));
  }
}
 

import com.google.gwt.inject.rebind.binding.Context; //导入依赖的package包/类
private BindProviderBinding createProvidedByBinding(Key<?> key, ProvidedBy providedBy)
    throws BindingCreationException {
  Class<?> rawType = key.getTypeLiteral().getRawType();
  Class<? extends Provider<?>> providerType = providedBy.value();

  if (providerType == rawType) {
    throw new BindingCreationException(
        "@ProvidedBy points to the same class it annotates: %s", rawType);
  }

  return bindingFactory.getBindProviderBinding(Key.get(providerType), key,
      Context.forText("@ProvidedBy annotation"));
}
 

import com.google.gwt.inject.rebind.binding.Context; //导入依赖的package包/类
public void testInstallImplicitBindings() throws Exception {
  // Tests that implicit bindings that are not already available in the origin are made accessible
  // foo and bar both had implicit bindings created (with no dependencies).  Foo is installed in
  // the child, and bar is installed in root.  We should add a binding to make bar accessible in
  // the child.
  expect(positions.getInstallPosition(foo())).andStubReturn(child);
  expect(positions.getInstallPosition(bar())).andStubReturn(root);
  
  Map<Key<?>, Binding> implicitBindingMap = new HashMap<Key<?>, Binding>();
  
  // Parent Binding to make bar available to child
  ParentBinding barBinding = control.createMock("barBinding", ParentBinding.class);
  expect(child.isBound(bar())).andReturn(false);
  expect(bindingFactory.getParentBinding(eq(bar()), eq(root), isA(Context.class)))
      .andReturn(barBinding);
  
  // Implicit binding for Foo
  Binding fooBinding = control.createMock("fooBinding", Binding.class);
  expect(graph.getDependenciesOf(foo())).andReturn(TestUtils.dependencyList());
  implicitBindingMap.put(foo(), fooBinding);
  
  expect(output.getImplicitBindings()).andReturn(implicitBindingMap.entrySet());
  expect(child.getDependencies()).andReturn(TestUtils.dependencyList(
      new Dependency(Dependency.GINJECTOR, foo(), SOURCE),
      new Dependency(Dependency.GINJECTOR, bar(), SOURCE)));
  
  child.addBinding(bar(), barBinding);
  child.addBinding(foo(), fooBinding);
  control.replay();
  installer.installBindings(output);
  control.verify();
}
 

import com.google.gwt.inject.rebind.binding.Context; //导入依赖的package包/类
public void testInheritDependencies() throws Exception {
  // Tests that when we install an implicit binding (for foo), we install bindings to "inherit"
  // the dependencies (bar and baz) from the appropriate injectors.  In this case, bar must be
  // inherited from the root, but we don't need to do anything with baz, since it is already
  // available.
  expect(positions.getInstallPosition(foo())).andStubReturn(child);
  expect(positions.getInstallPosition(bar())).andStubReturn(root);
  expect(positions.getInstallPosition(baz())).andStubReturn(child);
  
  Map<Key<?>, Binding> implicitBindingMap = new HashMap<Key<?>, Binding>();
  
  // Parent Binding to make bar available to child
  ParentBinding barBinding = control.createMock("barBinding", ParentBinding.class);
  expect(child.isBound(bar())).andReturn(false);
  expect(bindingFactory.getParentBinding(eq(bar()), eq(root), isA(Context.class)))
      .andReturn(barBinding);

  // Implicit binding for Bar
  Binding bazBinding = control.createMock("bazBinding", Binding.class);
  expect(graph.getDependenciesOf(baz())).andReturn(TestUtils.dependencyList());
  implicitBindingMap.put(baz(), bazBinding);
  
  // Implicit binding for Foo
  Binding fooBinding = control.createMock("fooBinding", Binding.class);
  expect(graph.getDependenciesOf(foo())).andReturn(TestUtils.dependencyList(
      new Dependency(foo(), bar(), SOURCE),
      new Dependency(foo(), baz(), SOURCE)));
  implicitBindingMap.put(foo(), fooBinding);
  
  expect(output.getImplicitBindings()).andReturn(implicitBindingMap.entrySet());
  expect(child.getDependencies()).andReturn(TestUtils.dependencyList(
      new Dependency(Dependency.GINJECTOR, foo(), SOURCE)));
  
  child.addBinding(baz(), bazBinding);
  child.addBinding(bar(), barBinding);
  child.addBinding(foo(), fooBinding);
  control.replay();
  installer.installBindings(output);
  control.verify();
}
 

import com.google.gwt.inject.rebind.binding.Context; //导入依赖的package包/类
private void bind(Key<?> key, GinjectorBindings in) {
  Binding binding = control.createMock(Binding.class);
  expect(binding.getContext()).andReturn(Context.forText("")).anyTimes();
  expect(in.isBound(key)).andReturn(true).anyTimes();
  expect(in.getBinding(key)).andReturn(binding).anyTimes();
  bindings.add(binding);
}
 

import com.google.gwt.inject.rebind.binding.Context; //导入依赖的package包/类
private void bindChild(Key<?> key, GinjectorBindings parent, GinjectorBindings child) {
  ExposedChildBinding binding = control.createMock(ExposedChildBinding.class);
  expect(binding.getContext()).andReturn(Context.forText("")).anyTimes();
  expect(parent.isBound(key)).andReturn(true).anyTimes();
  expect(parent.getBinding(key)).andReturn(binding).anyTimes();
  expect(child.isPinned(key)).andReturn(true).anyTimes();
  expect(binding.getChildBindings()).andReturn(child).anyTimes();
  bindings.add(binding);
}
 

import com.google.gwt.inject.rebind.binding.Context; //导入依赖的package包/类
private void bindParent(Key<?> key, GinjectorBindings parent, GinjectorBindings child) {
  ParentBinding binding = control.createMock(ParentBinding.class);
  expect(binding.getContext()).andReturn(Context.forText("")).anyTimes();
  expect(binding.getParentBindings()).andReturn(parent).anyTimes();
  expect(child.isBound(key)).andReturn(true).anyTimes();
  expect(child.getBinding(key)).andReturn(binding).anyTimes();
  bindings.add(binding);
}
 

import com.google.gwt.inject.rebind.binding.Context; //导入依赖的package包/类
/**
 * Writes a method describing the getter for the given key, along with any other code necessary to support it. Produces a list of helper methods that still
 * need to be written.
 */
void writeBindingGetter(Key<?> key, Binding binding, GinScope scope, List<InjectorMethod> helperMethodsOutput) {
    Context bindingContext = binding.getContext();

    SourceSnippetBuilder getterBuilder = new SourceSnippetBuilder();
    SourceSnippet creationStatements;
    String getter = nameGenerator.getGetterMethodName(key);

    String typeName;
    try {
        typeName = ReflectUtil.getSourceName(key.getTypeLiteral());

        creationStatements = binding.getCreationStatements(nameGenerator, helperMethodsOutput);
    } catch (NoSourceNameException e) {
        errorManager.logError("Error trying to write getter for [%s] -> [%s];" + " binding declaration: %s", e, key, binding, bindingContext);
        return;
    }
    // Name of the field that we might need.
    String field = nameGenerator.getSingletonFieldName(key);

    switch (scope) {
        case EAGER_SINGLETON:
            initializeEagerSingletonsBody.append("// Eager singleton bound at:\n");
            appendBindingContextCommentToMethod(bindingContext, initializeEagerSingletonsBody);
            initializeEagerSingletonsBody.append(getter).append("();\n");
            // $FALL-THROUGH$
        case SINGLETON:
            writer.println("private " + typeName + " " + field + " = null;");
            writer.println();
            getterBuilder.append(String.format("\nif (%s == null) {\n", field)).append(creationStatements).append("\n")
                    .append(String.format("    %s = result;\n", field)).append(postConstruct(key)).append("}\n").append(String.format("return %s;\n", field));
            break;

        case NO_SCOPE:
            sourceWriteUtil.writeBindingContextJavadoc(writer, bindingContext, key);

            getterBuilder.append(creationStatements).append("\n").append(postConstruct(key)).append("return result;\n");
            break;

        default:
            throw new IllegalStateException();
    }

    outputMethod(SourceSnippets.asMethod(false, String.format("public %s %s()", typeName, getter), fragmentPackageName.toString(), getterBuilder.build()));
}
 

import com.google.gwt.inject.rebind.binding.Context; //导入依赖的package包/类
private void appendBindingContextCommentToMethod(Context bindingContext, StringBuilder methodBody) {
    for (String line : bindingContext.toString().split("\n")) {
        methodBody.append("//   ").append(line).append("\n");
    }
}
 

import com.google.gwt.inject.rebind.binding.Context; //导入依赖的package包/类
private void addImplicitBinding(Element sourceElement) {
  bindingsCollection.addDependency(new Dependency(Dependency.GINJECTOR, targetKey,
      Context.forElement(sourceElement).toString()));
}