Java 类javax.inject.Provider 实例源码

String[] renderedTags() {
    final StringBuilder sb = new StringBuilder();
    boolean some = false;
    for(Provider<Tagger> provider : taggers.get()) {
        final Tagger tagger;
        try {
            tagger = Injection.unwrappingExceptions(OutOfScopeException.class, provider);
        } catch(OutOfScopeException e) {
            // If the tagger is out of scope, just omit its tags,
            // but log a warning in case this hides an unexpected exception.
            logger.warning("Ignoring out-of-scope tagger (" + e.toString() + ")");
            continue;
        }

        final ImmutableSet<Tag> tags = tagger.tags();
        if(!tags.isEmpty()) {
            if(some) sb.append(',');
            some = true;
            sb.append(tagSetCache.getUnchecked(tags));
        }
    }
    return some ? new String[] {sb.toString()} : EMPTY;
}

@Test
public void testSingleton() {
    final Provider<MySingleton> provider = injector.getProvider(MySingleton.class);
    assertNotNull(provider);

    final MySingleton instance = provider.get();
    assertNotNull(instance);

    final Provider<MySingleton> provider2 = injector.getProvider(MySingleton.class);
    assertNotNull(provider2);
    assertEquals(provider, provider2);

    final MySingleton instance2 = provider2.get();
    assertNotNull(instance2);
    assertEquals(instance, instance2);
    assertTrue(instance == instance2);
}

@NonNull
@SuppressWarnings("unchecked")
@Override
public <T extends ViewModel> T create(@NonNull Class<T> modelClass) {
    Provider<? extends ViewModel> creator = creators.get(modelClass);
    if (creator == null) {
        for (Map.Entry<Class<? extends ViewModel>, Provider<ViewModel>> entry : creators.entrySet()) {
            if (modelClass.isAssignableFrom(entry.getKey())) {
                creator = entry.getValue();
                break;
            }
        }
    }
    if (creator == null) {
        throw new IllegalArgumentException("unknown model class " + modelClass);
    }
    try {
        return (T) creator.get();
    } catch (Exception e) {
        throw new RuntimeException(e);
    }
}

/**
 * Constructs a new {@code TArchiveDetector} by filtering the given driver
 * provider for all canonicalized extensions in the {@code extensions} list.
 *
 * @param  provider the file system driver provider to filter.
 * @param  extensions A list of file name extensions which shall identify
 *         prospective archive files.
 *         If this is {@code null}, no filtering is applied and all drivers
 *         known by the given provider are available for use with this
 *         archive detector.
 * @throws IllegalArgumentException If any of the extensions in the list
 *         names a extension for which no file system driver is known by the
 *         provider.
 * @see    ExtensionSet Syntax constraints for extension lists.
 */
public TArchiveDetector(final Provider<Map<FsScheme, FsDriver>> provider,
                        final @CheckForNull String extensions) {
    final ExtensionSet available = extensions(provider);
    ExtensionSet accepted;
    if (null == extensions) {
        accepted = available;
    } else {
        accepted = new ExtensionSet(extensions);
        if (accepted.retainAll(available)) {
            accepted = new ExtensionSet(extensions);
            accepted.removeAll(available);
            assert !accepted.isEmpty();
            throw new IllegalArgumentException(
                    "\"" + accepted + "\" (no archive driver installed for these extensions)");
        }
    }
    this.extensions = accepted;
    this.drivers = provider.get();
}

@Inject
public Commander(
    Ignite ignite,
    RPCManager manager,
    @Named(DataCapturerBusConfiguration.CLUSTER_ID) UUID clusterId,
    @Named(DataCapturerBusConfiguration.RPC_ADDRESS) String address,
    @Named(DataCapturerBusConfiguration.SUPER_CLUSTER_ADDRESS) String superClusterAddress,
    DataRecoveryConfig dataRecoveryConfig,
    Provider<ActiveCacheStoreService> mainInterfaceProvider,
    PublisherReplicaService replicaService
) {
    this.ignite = ignite;
    this.manager = manager;
    this.clusterId = clusterId;
    this.address = address;
    this.superClusterAddress = superClusterAddress;
    this.dataRecoveryConfig = dataRecoveryConfig;
    this.mainInterfaceProvider = mainInterfaceProvider;
    this.replicaService = replicaService;
}

@BeforeClass
public static void startServices() throws Exception {
  provider = new LocalKVStoreProvider(DremioTest.CLASSPATH_SCAN_RESULT, null, true, false);
  provider.start();
  manager = new TokenManagerImpl(
      new Provider<KVStoreProvider>() {
        @Override
        public KVStoreProvider get() {
          return provider;
        }
      },
      new Provider<SchedulerService>() {
        @Override
        public SchedulerService get() {
          return mock(SchedulerService.class);
        }
      },
      false, 10, 10);
  manager.start();
}

@SuppressWarnings("unchecked")
@Override
public <T extends ViewModel> T create(Class<T> modelClass) {
    Provider<? extends ViewModel> creator = mCreators.get(modelClass);
    if (creator == null) {
        for (Map.Entry<Class<? extends ViewModel>, Provider<ViewModel>> entry : mCreators
                .entrySet()) {
            if (modelClass.isAssignableFrom(entry.getKey())) {
                creator = entry.getValue();
                break;
            }
        }
    }
    if (creator == null) {
        throw new IllegalArgumentException("unknown model class " + modelClass);
    }
    try {
        return (T) creator.get();
    } catch (Exception e) {
        throw new RuntimeException(e);
    }
}

@Test
public void testProviderFieldInjection() {
    final Provider<ProviderFieldInjection> providerInjectionProvider = injector.getProvider(ProviderFieldInjection.class);
    assertNotNull(providerInjectionProvider);

    final ProviderFieldInjection providerInjection = providerInjectionProvider.get();
    assertNotNull(providerInjection);
    assertNotNull(providerInjection.provider);

    final C instance1 = providerInjection.provider.get();
    assertNotNull(instance1);

    final C instance2 = providerInjection.provider.get();
    assertNotNull(instance2);
    assertNotEquals(instance1, instance2);
}

@Test
public void testSimple() {
    final Provider<C> provider = injector.getProvider(C.class);
    assertNotNull(provider);

    final C instance = provider.get();
    assertNotNull(instance);

    final Provider<C> provider2 = injector.getProvider(C.class);
    assertNotNull(provider2);
    assertEquals(provider, provider2);

    final C instance2 = provider2.get();
    assertNotNull(instance2);
    assertNotEquals(instance, instance2);
}

public ModuleHolder(
  String name,
  boolean canOverrideExistingModule,
  boolean supportsWebWorkers,
  boolean needsEagerInit,
  boolean hasConstants,
  Provider<? extends NativeModule> provider) {
  mName = name;
  mCanOverrideExistingModule = canOverrideExistingModule;
  mSupportsWebWorkers = supportsWebWorkers;
  mHasConstants = hasConstants;
  mProvider = provider;
  if (needsEagerInit) {
    mModule = create();
  }
}

public PDFSService(
    final Provider<SabotContext> contextProvider,
    Provider<FabricService> fabricService,
    SabotConfig config,
    BufferAllocator allocator,
    PDFSMode mode) {
  final Provider<Iterable<NodeEndpoint>> nodeProvider = new Provider<Iterable<NodeEndpoint>>(){
    @Override
    public Iterable<NodeEndpoint> get() {
      return contextProvider.get().getExecutors();
    }};

  Provider<NodeEndpoint> identityProvider = new Provider<NodeEndpoint>(){
    @Override
    public NodeEndpoint get() {
      return contextProvider.get().getEndpoint();
    }};
  this.fabricService = fabricService;

  this.identityProvider = identityProvider;
  this.nodeProvider = nodeProvider;
  this.config = config;
  this.allocator = allocator.newChildAllocator("pdfs-allocator", 0, Long.MAX_VALUE);
  this.allowLocalAccess = mode == PDFSMode.DATA;
}

public static UpgradeStats upgrade(final SabotConfig sabotConfig, final ScanResult classpathScan,
    final KVStoreProvider storeProvider) throws Exception {
  final KVStore<String, ClusterIdentity> supportStore = storeProvider.getStore(SupportStoreCreator.class);
  final ClusterIdentity identity = Preconditions.checkNotNull(supportStore.get(SupportService.CLUSTER_ID), "No Cluster Identity found");

  final Version kvStoreVersion = retrieveStoreVersion(identity);
  System.out.println("KVStore version is " + kvStoreVersion.getVersion());
  ensureUpgradeSupported(kvStoreVersion);


  final LogicalPlanPersistence lpPersistence = new LogicalPlanPersistence(sabotConfig, classpathScan);
  final UpgradeContext context = new UpgradeContext(new Provider<KVStoreProvider>() {
    @Override
    public KVStoreProvider get() {
      return storeProvider;
    }
  }, lpPersistence);
  for (UpgradeTask task : TASKS) {
    if (kvStoreVersion.compareTo(task.getMaxVersion()) < 0) {
      System.out.println(task);
      task.upgrade(context);
    } else {
      System.out.println("Skipping " + task);
    }
    // let exceptions propagate to main()
  }

  updateStoreVersion(supportStore, identity);

  return context.getUpgradeStats();
}

public SingletonHolder(
        final Class<T> beanClass,
        final Provider<Pair<T, Collection<ResourceReference<?>>>> factory,
        final InterceptorChain chain
) {
    this.beanClass = beanClass;
    this.factory = factory;
    proxyInstance = createProxy(beanClass, chain);
}

@Inject
public Car(Provider<Seat> seatProvider) {
    Seat driver = seatProvider.get();
    logger.info(driver + "");
    Seat passenger = seatProvider.get();
    logger.info(passenger + "");
}

public void prepareMapperClass(Class<? extends BaseMapper> mapperClass, Class<?> modelClass) {
    Object o = Proxy.newProxyInstance(mapperClass.getClassLoader(),
            new Class<?>[]{mapperClass},
            new MapperJavaProxy(new DefaultMapperBuilder(beetlSql), beetlSql, mapperClass));
    final BaseMapper mapper = $.cast(o);
    mapperMap.put(mapperClass, mapper);
    mapperMap.put(modelClass, mapper);
    Genie genie = Act.getInstance(Genie.class);
    genie.registerProvider(mapperClass, new Provider() {
        @Override
        public Object get() {
            return mapper;
        }
    });
}

@Override
protected Module bindInfinispan(Provider<InfinispanCacheManager> ignored) {
    return new AbstractModule() {
        @Override
        protected void configure() {
            bind(InfinispanCacheManager.class).toProvider((javax.inject.Provider<InfinispanCacheManager>) () -> new InfinispanCacheManager(mock(MetricRegistry.class, RETURNS_MOCKS), TestCacheManagerFactory.createCacheManager()));
        }
    };
}

public PDFSService(
    Provider<FabricService> fabricService,
    Provider<NodeEndpoint> identityProvider,
    Provider<Iterable<NodeEndpoint>> nodeProvider,
    SabotConfig config,
    BufferAllocator allocator,
    PDFSMode mode) {
  this.fabricService = fabricService;
  this.identityProvider = identityProvider;
  this.nodeProvider = nodeProvider;
  this.config = config;
  this.allocator = allocator.newChildAllocator("pdfs-allocator", 0, Long.MAX_VALUE);
  this.allowLocalAccess = mode == PDFSMode.DATA;
}

public <T> T provide(Key<T> key, Provider<T> provider) {
    T t = (T) map.get(key);
    if(t != null) return t;

    t = provider.get();
    if(!Scopes.isCircularProxy(t)) {
        store(key, t);
    }

    return t;
}

protected T circularGet(final Provider<? extends T> provider, final Errors errors,
    InternalContext context, final Dependency<?> dependency,
    ProvisionListenerStackCallback<T> provisionCallback)
    throws ErrorsException {    
  final ConstructionContext<T> constructionContext = context.getConstructionContext(this);

  // We have a circular reference between constructors. Return a proxy.
  if (constructionContext.isConstructing()) {
      Class<?> expectedType = dependency.getKey().getTypeLiteral().getRawType();
      // TODO: if we can't proxy this object, can we proxy the other object?
      @SuppressWarnings("unchecked")
      T proxyType = (T) constructionContext.createProxy(
          errors, context.getInjectorOptions(), expectedType);
      return proxyType;
  }

  // Optimization: Don't go through the callback stack if no one's listening.
  constructionContext.startConstruction();
  try {
    if (!provisionCallback.hasListeners()) {
      return provision(provider, errors, dependency, constructionContext);
    } else {
      return provisionCallback.provision(errors, context, new ProvisionCallback<T>() {
        public T call() throws ErrorsException {
          return provision(provider, errors, dependency, constructionContext);
        }
      });
    }
  } finally {
    constructionContext.removeCurrentReference();
    constructionContext.finishConstruction();
  }
}

@SuppressWarnings({ "squid:S3824", "unchecked" })
<T> Provider<T> getProvider(final Key<T> key, final Set<Key<?>> chain) {
    Provider<T> result = (Provider<T>) providers.get(key);

    if (result == null) {
        result = buildProvider(key, chain);
        providers.put(key, result);
    }

    return result;
}

public static Module queriesModule(Function<QueriesSources, Queries> queriesSupplier) {
    return new AbstractModule() {
        @Override
        protected void configure() {

            com.google.inject.Provider<SourcesCollector> provider = binder().getProvider(SourcesCollector.class);

            bind(Queries.class).toProvider(() -> queriesSupplier.apply(provider.get().getSources()))
                    .in(Singleton.class);
        }
    };
}

/**
 * Return the type that is depended on by injecting the given type.
 * These types are the same, unless the injected type is a {@link Provider},
 * in which case the dependency is on the provided type.
 */
public static TypeLiteral<?> dependencyType(TypeLiteral<?> injectedType) {
    if(isImplicitProvider(injectedType)) {
        return providedType((TypeLiteral<? extends Provider<Object>>) injectedType);
    } else {
        return injectedType;
    }
}

private <T> Provider<T> buildProvider(final Key<T> key, final Set<Key<?>> chain) {
    final Provider<T> p;

    switch (key.getStrategy()) {
    case CONTEXT:
        p = new ContextProvider<>(key);
        break;
    case COOKIE:
        p = new CookieParamProvider<>(key);
        break;
    case FORM:
        p = new FormParamProvider<>(key);
        break;
    case HEADER:
        p = new HeaderParamProvider<>(key);
        break;
    case PATH:
        p = new PathParamProvider<>(key);
        break;
    case QUERY:
        p = new QueryParamProvider<>(key);
        break;
    default:
        p = new ConstructorProviderBuilder<>(this, key, chain).buildConstructorProvider();
        break;
    }

    if (key.getType().getAnnotation(Singleton.class) != null) {
        return new SingletonProvider<>(p);
    } else if (key.getType().getAnnotation(RequestScoped.class) != null) {
        return new RequestScopedProvider<>(key, p);
    } else {
        return p;
    }
}

@Override
public void start() throws Exception {
  accelerationStore.start();
  materializationStore.start();

  this.namespaceService = new Provider<NamespaceService>() {
    @Override
    public NamespaceService get() {
      return contextProvider.get().getNamespaceService(SYSTEM_USERNAME);
    }
  };
}

public ConstructorProvider(
        final Constructor<T> ctor,
        final Provider<?>[] paramProviders,
        final List<InjectionSet<? super T>> injectionSets) {

    this.ctor = ctor;
    this.paramProviders = paramProviders;
    this.injectionSets = injectionSets;
}

@Inject
EggworldService(
    Provider<CheckIngredientsGraph.Component.Builder> checkIngredientsGraph,
    Provider<FindRecipeGraph.Component.Builder> findRecipeGraph) {
  this.checkIngredientsGraph = checkIngredientsGraph;
  this.findRecipeGraph = findRecipeGraph;
}

public MasterStatusListener(Provider<ClusterCoordinator> clusterCoordinator,
                            String masterNode, int masterPort, boolean isMaster) {
  this.clusterCoordinator = clusterCoordinator;
  this.masterNode = masterNode;
  this.masterUp = isMaster;
  this.masterPort = masterPort;
}

@Override
public void prepare(@NonNull final Primitive.Header model,
                    final List<Provider<GraywaterAdapter.Binder<
                            ? super Primitive.Header, PrimitiveViewHolder, ? extends PrimitiveViewHolder>>> binderList,
                    final int binderIndex) {

}

public LocalKVStoreProvider(ScanResult scan, Provider<FabricService> fabricService, BufferAllocator allocator, String hostName,
                            String baseDirectory, boolean inMemory, boolean timed, boolean validateOCC, boolean disableOCC) {
  coreStoreProvider = new CoreStoreProviderImpl(baseDirectory, inMemory, timed, validateOCC, disableOCC);
  this.fabricService = fabricService;
  this.allocator = allocator;
  this.hostName = hostName;
  this.scan = scan;
}

@Override
public void prepare(@NonNull final ColorNamePrimitive model,
                    final List<Provider<GraywaterAdapter.Binder<
                            ? super ColorNamePrimitive, PrimitiveViewHolder, ? extends PrimitiveViewHolder>>> binderList,
                    final int binderIndex) {

}

public PDFSConfig(ExecutorService executor, FabricRunnerFactory runnerFactory, BufferAllocator allocator,
    Provider<Iterable<NodeEndpoint>> endpointProvider, NodeEndpoint localIdentity, boolean localAccessAllowed) {
  super();
  this.executor = executor;
  this.runnerFactory = runnerFactory;
  this.allocator = allocator;
  this.endpointProvider = endpointProvider;
  this.localIdentity = localIdentity;
  this.localAccessAllowed = localAccessAllowed;
}

@Override
public void act(@NonNull final Palette model,
                @NonNull final PrimitiveViewHolder holder,
                @NonNull final View v,
                @NonNull final List<Provider<GraywaterAdapter.Binder<
                        ? super Palette, PrimitiveViewHolder, ? extends PrimitiveViewHolder>>> binderList,
                final int binderIndex,
                @Nullable final Object obj) {

}

@NonNull
@Override
public List<Provider<
        ? extends GraywaterAdapter.Binder<Primitive.Header, PrimitiveViewHolder, ? extends PrimitiveViewHolder>>>
getBinderList(@NonNull final Primitive.Header model, final int position) {
    return new ArrayList<Provider<
            ? extends GraywaterAdapter.Binder<Primitive.Header, PrimitiveViewHolder, ? extends PrimitiveViewHolder>>>() {{
        add(mHeaderBinder);
    }};
}

@Test
public void shouldFailToGetConfIfNotInitialized() throws FileNotFoundException {
    final Provider<AppConfiguration> provider = new JoalConfigProvider(new ObjectMapper(), resourcePath.toString(), Mockito.mock(ApplicationEventPublisher.class));

    assertThatThrownBy(provider::get)
            .isInstanceOf(IllegalStateException.class)
            .hasMessage("Attempted to get configuration before init.");
}

@Override
public void act(@NonNull final ColorNamePrimitive model,
                @NonNull final PrimitiveViewHolder holder,
                @NonNull final View v,
                @NonNull final List<Provider<GraywaterAdapter.Binder<
                        ? super ColorNamePrimitive, PrimitiveViewHolder, ? extends PrimitiveViewHolder>>> binderList,
                final int binderIndex,
                @Nullable final Object obj) {
    Toast.makeText(v.getContext(), model.getString(), Toast.LENGTH_SHORT).show();

    final PrimitiveAdapter adapter = mAdapter.get();

    adapter.add(adapter.getItemPosition(holder.getAdapterPosition()) + 1,
            new ColorNamePrimitive(model.getColor(), model.getString() + "+"), true);
}

@Inject DataDogClient(Loggers loggers, DataDogConfig config, Provider<StatsDClient> clientProvider, Provider<Collection<Provider<Tagger>>> taggers) {
    this.logger = loggers.get(getClass());
    this.config = config;
    this.clientProvider = clientProvider;
    this.taggers = taggers;

    this.client = clientProvider.get();
}

/**
 * @param model
 *      the model to get parts for.
 * @param position
 *      the position of the model.
 * @return the list of binders to use.
 */
@Nullable
protected List<Provider<Binder<? super T, VH, ? extends VH>>> getParts(final T model, final int position) {
    final List<Provider<Binder<? super T, VH, ? extends VH>>> list;

    final ItemBinder itemBinder = getItemBinder(model);

    if (itemBinder != null) {
        list = itemBinder.getBinderList(model, position);
    } else {
        list = null;
    }

    return list;
}

/**
 * Computes the position of the item and the position of the binder within the item's binder list.
 * Note that this is an <i>O(n)</i> operation.
 *
 * @param viewHolderPosition
 *      the position of the view holder in the adapter.
 * @return the item position and the position of the binder in the item's binder list.
 */
@VisibleForTesting
BinderResult computeItemAndBinderIndex(final int viewHolderPosition) {
    // subtract off the length of each list until we get to the desired item

    final int itemIndex = mViewHolderToItemPositionCache.get(viewHolderPosition);
    final T item = mItems.get(itemIndex);
    final List<Provider<Binder<? super T, VH, ? extends VH>>> binders = mBinderListCache.get(itemIndex);
    // index of the first item in the set of viewholders for the current item.
    final int firstVHPosForItem = mItemPositionToFirstViewHolderPositionCache.get(itemIndex);

    return new BinderResult(item, itemIndex, binders, viewHolderPosition - firstVHPosForItem);
}

public RemoteKVStoreProvider(ScanResult scan, Provider<FabricService> fabricService, BufferAllocator allocator, String hostName, String masterHostName, int masterPort) {
  this.fabricService = fabricService;
  this.allocator = allocator;
  this.hostName = hostName;
  this.masterHostName = masterHostName;
  this.masterPort = masterPort;
  this.scan = scan;
}

/**
 * Note that this is an <i>O(n)</i> operation, since the cache needs to be updated.
 *
 * @param position
 *      the position to insert into the list.
 * @param item
 *      the item to add. Note that if it is <code>null</code>, there is no way to determine which binder to use.
 * @param notify
 *      whether or not to notify the adapter.
 */
public void add(final int position, @NonNull final T item, final boolean notify) {
    final int numViewHolders = getViewHolderCount(position);

    final List<Provider<Binder<? super T, VH, ? extends VH>>> binders = getParts(item, position);

    mItems.add(position, item);
    mBinderListCache.add(position, binders);

    if (binders != null) {
        if (notify) {
            notifyItemRangeInserted(numViewHolders, binders.size());
        }

        final List<Integer> itemPositions = new ArrayList<>();
        for (int i = 0; i < binders.size(); i++) {
            itemPositions.add(position);
        }

        mViewHolderToItemPositionCache.addAll(numViewHolders, itemPositions);
        for (int viewHolderIndex = numViewHolders + binders.size(); viewHolderIndex < mViewHolderToItemPositionCache.size();
             viewHolderIndex++) {
            mViewHolderToItemPositionCache.set(viewHolderIndex, mViewHolderToItemPositionCache.get(viewHolderIndex) + 1);
            mViewHolderPreparedCache.remove(viewHolderIndex);
        }

        mItemPositionToFirstViewHolderPositionCache.add(position, numViewHolders);
        for (int itemIndex = position + 1; itemIndex < mItemPositionToFirstViewHolderPositionCache.size(); itemIndex++) {
            mItemPositionToFirstViewHolderPositionCache.set(itemIndex,
                    mItemPositionToFirstViewHolderPositionCache.get(itemIndex) + binders.size());
        }
    }
}