com.google.common.collect.ClassToInstanceMap Java Examples

@Test
public void classToINstanceMap_example () {
	
	Person person = new Person("Jackson");
	Jobs jobs = new Jobs("IT person");
	Address address = new  Address("505 Williams Street");
	
	ClassToInstanceMap<Object> classToInstanceMap = MutableClassToInstanceMap.create();
	classToInstanceMap.put(Person.class, person);
	classToInstanceMap.put(Jobs.class, jobs);
	classToInstanceMap.put(Address.class, address);
	
	logger.info(classToInstanceMap);
	
	assertEquals("IT person", classToInstanceMap.getInstance(Jobs.class).getJobName());
}
 

@Override
public List<Parameter> extractParameters(List<Annotation> annotations, Type type, Set<Type> typesToSkip, Iterator<SwaggerExtension> chain) {
    if (this.shouldIgnoreType(type, typesToSkip)) {
        return new ArrayList<Parameter>();
    }

    ClassToInstanceMap<Annotation> annotationMap = toMap(annotations);

    List<Parameter> parameters = new ArrayList<Parameter>();
    parameters.addAll(extractParametersFromAnnotation(type, annotationMap));

    if (!parameters.isEmpty()) {
        return parameters;
    }
    return super.extractParameters(annotations, type, typesToSkip, chain);
}
 

/**
 * Returns a copy of this configuration only including the given fragments (which the current
 * configuration is assumed to have).
 */
public BuildConfiguration clone(
    FragmentClassSet fragmentClasses,
    RuleClassProvider ruleClassProvider,
    BuildOptions defaultBuildOptions) {

  ClassToInstanceMap<Fragment> fragmentsMap = MutableClassToInstanceMap.create();
  for (Fragment fragment : fragments.values()) {
    if (fragmentClasses.fragmentClasses().contains(fragment.getClass())) {
      fragmentsMap.put(fragment.getClass(), fragment);
    }
  }
  BuildOptions options =
      buildOptions.trim(getOptionsClasses(fragmentsMap.keySet(), ruleClassProvider));
  BuildConfiguration newConfig =
      new BuildConfiguration(
          getDirectories(),
          fragmentsMap,
          options,
          BuildOptions.diffForReconstruction(defaultBuildOptions, options),
          reservedActionMnemonics,
          actionEnv,
          mainRepositoryName.strippedName());
  return newConfig;
}
 

private static ClassToInstanceMap<Context> getContextMap(UUID actionUUID, Player player, VirtualChestHandheldItem itemTemplate)
{
    ImmutableClassToInstanceMap.Builder<Context> contextBuilder = ImmutableClassToInstanceMap.builder();

    contextBuilder.put(Context.HANDHELD_ITEM, new HandheldItemContext(itemTemplate::matchItem));
    contextBuilder.put(Context.ACTION_UUID, new ActionUUIDContext(actionUUID));
    contextBuilder.put(Context.PLAYER, new PlayerContext(player));

    return contextBuilder.build();
}
 

static <T extends Completable> T getInstance(Class<T> type, Supplier<T> supplier) {
  ClassToInstanceMap<Completable> components = state().components;
  @Nullable T instance = components.getInstance(type);
  if (instance == null) {
    instance = supplier.get();
    components.putInstance(type, instance);
  }
  return instance;
}
 

private ClassToInstanceMap<Annotation> toMap(Collection<? extends Annotation> annotations) {
    ClassToInstanceMap<Annotation> annotationMap = MutableClassToInstanceMap.create();
    for (Annotation annotation : annotations) {
        if (annotation == null) {
            continue;
        }
        annotationMap.put(annotation.annotationType(), annotation);
    }

    return annotationMap;
}
 

@Test
public void givenClassToInstanceMap_whenPutCalled_returnPreviousElementUpperBound() {
    ClassToInstanceMap<Action> map = MutableClassToInstanceMap.create();
    map.put(Save.class, new Save());
    // Put again to get previous value returned
    Action action = map.put(Save.class, new Save());
    assertTrue(action instanceof Save);

    // Use putInstance to avoid casting
    Save save = map.putInstance(Save.class, new Save());
}
 

@Test
public void givenClassToInstanceMap_whenGetCalled_returnUpperBoundElement() {
    ClassToInstanceMap<Action> map = ImmutableClassToInstanceMap.of(Save.class, new Save());
    Action action = map.get(Save.class);
    assertTrue(action instanceof Save);

    // Use getInstance to avoid casting
    Save save = map.getInstance(Save.class);
}
 

@Test
public void whenBuilderUser_thenCreateMap() {
    ClassToInstanceMap<Action> map = ImmutableClassToInstanceMap.<Action>builder()
            .put(Save.class, new Save())
            .put(Open.class, new Open())
            .build();
    assertEquals(2, map.size());
}
 

public FakeSpawnExecutionContext(
    Spawn spawn,
    MetadataProvider metadataProvider,
    Path execRoot,
    FileOutErr outErr,
    ClassToInstanceMap<ActionContext> actionContextRegistry) {
  this.spawn = spawn;
  this.metadataProvider = metadataProvider;
  this.execRoot = execRoot;
  this.outErr = outErr;
  this.actionContextRegistry = actionContextRegistry;
}
 

private FakeSpawnExecutionContext getSpawnContext(Spawn spawn) {
  AbstractSpawnStrategy fakeLocalStrategy = new AbstractSpawnStrategy(execRoot, localRunner) {};
  ClassToInstanceMap<ActionContext> actionContextRegistry =
      ImmutableClassToInstanceMap.of(RemoteLocalFallbackRegistry.class, () -> fakeLocalStrategy);
  return new FakeSpawnExecutionContext(
      spawn, fakeFileCache, execRoot, outErr, actionContextRegistry);
}
 

@NotNull
public <T extends BuildModelNotification> T getNotificationForType(@NotNull GradleDslFile file,
                                                                   @NotNull NotificationTypeReference<T> type) {
  ClassToInstanceMap<BuildModelNotification> notificationMap =
    myNotifications.computeIfAbsent(file, (f) -> MutableClassToInstanceMap.create());
  if (notificationMap.containsKey(type.getClazz())) {
    return notificationMap.getInstance(type.getClazz());
  }
  else {
    T notification = type.getConstructor().produce();
    notificationMap.putInstance(type.getClazz(), notification);
    return notification;
  }
}
 

@Override
public final ClassToInstanceMap<NormalizedNodeStreamWriterExtension> getExtensions() {
    return ImmutableClassToInstanceMap.of(StreamWriterMetadataExtension.class, this);
}
 

@Override
public final ClassToInstanceMap<NormalizedNodeStreamWriterExtension> getExtensions() {
    return ImmutableClassToInstanceMap.of(StreamWriterMountPointExtension.class, this);
}
 

private HandlerMapBuilder(Builder<HandlerId, ResourceHandler> builder, ClassToInstanceMap<ResourceHandler> handlers) {
	this.builder = builder;
	this.handlers = handlers;
}
 

@Test
public void whenOfCalled_thenCreateEmptyImmutableMap() {
    ClassToInstanceMap<Action> map = ImmutableClassToInstanceMap.of();
    assertTrue(map.isEmpty());
}
 

@Test
public void whenCreateCalled_thenCreateEmptyMutableMap() {
    ClassToInstanceMap<Action> map = MutableClassToInstanceMap.create();
    assertTrue(map.isEmpty());
}
 

@Test
public void whenOfWithParameterCalled_thenCreateSingleEntryMap() {
    ClassToInstanceMap<Action> map = ImmutableClassToInstanceMap.of(Save.class, new Save());
    assertEquals(1, map.size());
}
 

@Override
public final ClassToInstanceMap<NormalizedNodeStreamWriterExtension> getExtensions() {
    return ImmutableClassToInstanceMap.of(StreamWriterMetadataExtension.class, this);
}
 

@Override
public ClassToInstanceMap<NormalizedNodeStreamWriterExtension> getExtensions() {
    return delegate().getExtensions();
}
 

@Override
public ClassToInstanceMap<NormalizedNodeStreamWriterExtension> getExtensions() {
    return ImmutableClassToInstanceMap.of(StreamWriterMountPointExtension.class, this);
}
 

protected FallbackInstanceStorage(ClassToInstanceMap<B> instances, InstanceStorage<B> defaults) {
    super(instances);
    this.defaults = Preconditions.checkNotNull(defaults, "defaults");
}
 

protected ClassToInstanceStorage(ClassToInstanceMap<B> instances) {
    this.instances = Preconditions.checkNotNull(instances, "instances");
}
 

public static <T> ClassToInstanceStorage<T> create(ClassToInstanceMap<T> instances) {
    return new ClassToInstanceStorage<>(instances);
}
 

public @NonNull ClassToInstanceMap<E> newInstance(final T object) {
    return new ObjectExtensions<>(extensions, object);
}
 

/**
 * Return a map of currently-supported extensions, along with accessor objects which provide access to the specific
 * functionality bound to this object.
 *
 * @return A map of supported functionality.
 */
default @NonNull ClassToInstanceMap<E> getExtensions() {
    return ImmutableClassToInstanceMap.of();
}
 

/**
 * Execute the submitted action and return a result. Asynchronous execution is allowed.
 *
 * @param parent  parent result
 * @param command command suffix
 * @param context immutable context map
 * @return a completable future which will provide a {@link CommandResult}
 */
CompletableFuture<CommandResult> execute(CommandResult parent, String command, ClassToInstanceMap<Context> context);