@Override protected Map<AnEnum, String> create(Entry<AnEnum, String>[] entries) { Map<AnEnum, String> map = Maps.newHashMap(); for (Entry<AnEnum, String> entry : entries) { // checkArgument(!map.containsKey(entry.getKey())); map.put(entry.getKey(), entry.getValue()); } return Maps.immutableEnumMap(map); } }
public static <K extends Enum<K>, V> ImmutableEnumMap<?, ?> instantiate( SerializationStreamReader reader) throws SerializationException { Map<K, V> deserialized = Maps.newHashMap(); Map_CustomFieldSerializerBase.deserialize(reader, deserialized); /* * It is safe to cast to ImmutableEnumSet because in order for it to be * serialized as an ImmutableEnumSet, it must be non-empty to start * with. */ return (ImmutableEnumMap<?, ?>) Maps.immutableEnumMap(deserialized); }
@Override protected Map<AnEnum, String> create(Entry<AnEnum, String>[] entries) { Map<AnEnum, String> map = Maps.newHashMap(); for (Entry<AnEnum, String> entry : entries) { map.put(entry.getKey(), entry.getValue()); } return Maps.immutableEnumMap(map); } }
public void testEmptyImmutableEnumMap() { ImmutableMap<AnEnum, String> map = Maps.immutableEnumMap(ImmutableMap.<AnEnum, String>of()); assertEquals(ImmutableMap.of(), map); }
public void testIteratesOnce() { Map<AnEnum, AnEnum> map = Maps.asMap( ImmutableSet.of(AnEnum.A), new Function<AnEnum, AnEnum>() { boolean used = false; @Override public AnEnum apply(AnEnum ae) { checkState(!used, "should not be applied more than once"); used = true; return ae; } }); ImmutableMap<AnEnum, AnEnum> copy = Maps.immutableEnumMap(map); assertThat(copy.entrySet()).containsExactly(Helpers.mapEntry(AnEnum.A, AnEnum.A)); }
public void testImmutableEnumMapOrdering() { ImmutableMap<AnEnum, String> map = Maps.immutableEnumMap(ImmutableMap.of(AnEnum.C, "c", AnEnum.A, "a", AnEnum.E, "e")); assertThat(map.entrySet()) .containsExactly( Helpers.mapEntry(AnEnum.A, "a"), Helpers.mapEntry(AnEnum.C, "c"), Helpers.mapEntry(AnEnum.E, "e")) .inOrder(); }
public ModelProperty(ModelType<T> type, String name, Set<ModelType<?>> declaredBy, Map<PropertyAccessorType, WeaklyTypeReferencingMethod<?, ?>> accessors) { this.name = name; this.type = type; this.declaredBy = ImmutableSet.copyOf(declaredBy); this.accessors = Maps.immutableEnumMap(accessors); }
protected ImmutableMap<Counter, AtomicLong> createCounterMap() { EnumMap<Counter, AtomicLong> countersMap = new EnumMap<>(Counter.class); for (Counter counter : ALL_COUNTERS) { countersMap.put(counter, new AtomicLong()); } return Maps.immutableEnumMap(countersMap); }
@Override protected Map<AnEnum, String> create(Entry<AnEnum, String>[] entries) { Map<AnEnum, String> map = Maps.newHashMap(); for (Entry<AnEnum, String> entry : entries) { // checkArgument(!map.containsKey(entry.getKey())); map.put(entry.getKey(), entry.getValue()); } return Maps.immutableEnumMap(map); } }
@Override protected Map<AnEnum, String> create(Entry<AnEnum, String>[] entries) { Map<AnEnum, String> map = Maps.newHashMap(); for (Entry<AnEnum, String> entry : entries) { // checkArgument(!map.containsKey(entry.getKey())); map.put(entry.getKey(), entry.getValue()); } return Maps.immutableEnumMap(map); } }
public static <K extends Enum<K>, V> ImmutableEnumMap<?, ?> instantiate( SerializationStreamReader reader) throws SerializationException { Map<K, V> deserialized = Maps.newHashMap(); Map_CustomFieldSerializerBase.deserialize(reader, deserialized); /* * It is safe to cast to ImmutableEnumSet because in order for it to be * serialized as an ImmutableEnumSet, it must be non-empty to start * with. */ return (ImmutableEnumMap<?, ?>) Maps.immutableEnumMap(deserialized); }
/** * Copy the current immutable object by replacing the {@link ProcessAnsibleResource.AnsibleStatsEntry#stats() stats} map with the specified map. * Nulls are not permitted as keys or values. * A shallow reference equality check is used to prevent copying of the same value by returning {@code this}. * @param entries The entries to be added to the stats map * @return A modified copy of {@code this} object */ public final ImmutableAnsibleStatsEntry withStats(Map<ProcessAnsibleResource.AnsibleHostStatus, ? extends Integer> entries) { if (this.stats == entries) return this; ImmutableMap<ProcessAnsibleResource.AnsibleHostStatus, Integer> newValue = Maps.immutableEnumMap(entries); return new ImmutableAnsibleStatsEntry(this.uniqueHosts, newValue, this.hostGroups); }
private InheritanceModeOptions(Map<SubModeOfInheritance, Float> values) { this.subMoiMaxFreqs = Maps.immutableEnumMap(values); this.subMoiMaxFreqs.forEach(InheritanceModeOptions::checkBounds); this.moiMaxFreqs = createInheritanceModeMaxFreqs(subMoiMaxFreqs); this.maxFreq = moiMaxFreqs.values().stream().max(Comparator.naturalOrder()).orElse(Float.MAX_VALUE); }
@Override public IBakedModel bake(IModelState state, VertexFormat format, Function<ResourceLocation, TextureAtlasSprite> bakedTextureGetter) { ImmutableMap<ItemCameraTransforms.TransformType, TRSRTransformation> transformMap = PerspectiveMapWrapper.getTransforms(state); ImmutableList.Builder<BakedQuad> builder = ImmutableList.builder(); IBakedModel coreModel = new ItemLayerModel(ImmutableList.copyOf(locations)).bake(state, format, bakedTextureGetter); builder.addAll(coreModel.getQuads(null, null, 0)); TextureAtlasSprite someTexture = bakedTextureGetter.apply(locations.get(0)); return new SteamExosuitItemBakedModel(this, builder.build(), someTexture, format, Maps.immutableEnumMap(transformMap), Maps.newHashMap()); } }
@Override public IBakedModel bake(IModelState state, VertexFormat format, Function<ResourceLocation, TextureAtlasSprite> bakedTextureGetter) { ImmutableMap<ItemCameraTransforms.TransformType, TRSRTransformation> transformMap = PerspectiveMapWrapper.getTransforms(state); ImmutableList.Builder<BakedQuad> builder = ImmutableList.builder(); IBakedModel coreModel = new ItemLayerModel(ImmutableList.copyOf(locations)).bake(state, format, bakedTextureGetter); builder.addAll(coreModel.getQuads(null, null, 0)); TextureAtlasSprite someTexture = bakedTextureGetter.apply(locations.get(0)); return new LeatherExosuitItemBakedModel(this, builder.build(), someTexture, format, Maps.immutableEnumMap(transformMap), Maps.newHashMap()); } }
@Override public IBakedModel bake(IModelState state, VertexFormat format, Function<ResourceLocation, TextureAtlasSprite> bakedTextureGetter) { ImmutableMap<ItemCameraTransforms.TransformType, TRSRTransformation> transformMap = PerspectiveMapWrapper.getTransforms(state); ImmutableList.Builder<BakedQuad> builder = ImmutableList.builder(); IBakedModel coreModel = new ItemLayerModel(ImmutableList.of(core, head)).bake(state, format, bakedTextureGetter); builder.addAll(coreModel.getQuads(null, null, 0)); TextureAtlasSprite headTexture = bakedTextureGetter.apply(head); return new SteamToolBakedModel(this, builder.build(), headTexture, format, Maps.immutableEnumMap(transformMap), Maps.newHashMap()); }
@Override protected Map<AnEnum, String> create(Entry<AnEnum, String>[] entries) { Map<AnEnum, String> map = Maps.newHashMap(); for (Entry<AnEnum, String> entry : entries) { map.put(entry.getKey(), entry.getValue()); } return Maps.immutableEnumMap(map); } }
@Override public IBakedModel bake(IModelState state, VertexFormat format, Function<ResourceLocation, TextureAtlasSprite> bakedTextureGetter) { ImmutableMap<ItemCameraTransforms.TransformType, TRSRTransformation> transformMap = PerspectiveMapWrapper.getTransforms(state); ImmutableList.Builder<BakedQuad> builder = ImmutableList.builder(); IBakedModel model = (new ItemLayerModel(ImmutableList.of(EMPTY))).bake(state, format, bakedTextureGetter); builder.addAll(model.getQuads(null, null, 0)); TextureAtlasSprite particleSprite = model.getParticleTexture(); return new BakedItemModel(builder.build(), particleSprite, Maps.immutableEnumMap(transformMap), new FluidContainerItemOverrideList(state, format, transformMap, bakedTextureGetter)); }
public void testIteratesOnce() { Map<AnEnum, AnEnum> map = Maps.asMap(ImmutableSet.of(AnEnum.A), new Function<AnEnum, AnEnum>() { boolean used = false; @Override public AnEnum apply(AnEnum ae) { checkState(!used, "should not be applied more than once"); used = true; return ae; } }); ImmutableMap<AnEnum, AnEnum> copy = Maps.immutableEnumMap(map); assertThat(copy.entrySet()).containsExactly(Helpers.mapEntry(AnEnum.A, AnEnum.A)); }
public void testImmutableEnumMapOrdering() { ImmutableMap<AnEnum, String> map = Maps.immutableEnumMap( ImmutableMap.of(AnEnum.C, "c", AnEnum.A, "a", AnEnum.E, "e")); assertThat(map.entrySet()).containsExactly( Helpers.mapEntry(AnEnum.A, "a"), Helpers.mapEntry(AnEnum.C, "c"), Helpers.mapEntry(AnEnum.E, "e")).inOrder(); }