public static <E extends Enum<E>> ImmutableEnumSet<?> instantiate( SerializationStreamReader reader) throws SerializationException { List<E> deserialized = Lists.newArrayList(); Collection_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 (ImmutableEnumSet<?>) Sets.immutableEnumSet(deserialized); }
/** * Sets the given features to be supported by the file system. Any features not provided here * will not be supported. */ public Builder setSupportedFeatures(Feature... features) { supportedFeatures = Sets.immutableEnumSet(Arrays.asList(features)); return this; }
@Override protected Set<AnEnum> create(AnEnum[] elements) { AnEnum[] otherElements = new AnEnum[elements.length - 1]; System.arraycopy(elements, 1, otherElements, 0, otherElements.length); return Sets.immutableEnumSet(elements[0], otherElements); } })
@SuppressWarnings("unchecked") // only cast after checking each element's type private static ImmutableSet<PosixFilePermission> toPermissions(Set<?> set) { ImmutableSet<?> copy = ImmutableSet.copyOf(set); for (Object obj : copy) { if (!(obj instanceof PosixFilePermission)) { throw new IllegalArgumentException( "invalid element for attribute 'posix:permissions': " + "should be Set<PosixFilePermission>, found element of type " + obj.getClass()); } } return Sets.immutableEnumSet((ImmutableSet<PosixFilePermission>) copy); }
private static ImmutableSet<Compiler> detectCompilers() { EnumSet<Compiler> compilers = EnumSet.noneOf(Compiler.class); try { // Specific method is not essential, we just // forcing to load class here ClassSymbol.class.getCanonicalName(); compilers.add(Compiler.JAVAC); } catch (Throwable ex) { } try { // just forcing the loading of class ElementImpl.class.getCanonicalName(); compilers.add(Compiler.ECJ); } catch (Throwable ex) { } return Sets.immutableEnumSet(compilers); } }
/** * Creates a new {@link ServerPort} that listens to the specified {@code localAddress} using the specified * {@link SessionProtocol}s. */ public ServerPort(InetSocketAddress localAddress, Iterable<SessionProtocol> protocols) { // Try to resolve the localAddress if not resolved yet. if (requireNonNull(localAddress, "localAddress").isUnresolved()) { try { localAddress = new InetSocketAddress( InetAddress.getByName(localAddress.getHostString()), localAddress.getPort()); } catch (UnknownHostException e) { throw new IllegalArgumentException("unresolved localAddress: " + localAddress, e); } } requireNonNull(protocols, "protocols"); this.localAddress = localAddress; this.protocols = Sets.immutableEnumSet(protocols); checkArgument(!this.protocols.isEmpty(), "protocols: %s (must not be empty)", this.protocols); checkArgument(this.protocols.contains(HTTP) || this.protocols.contains(HTTPS), "protocols: %s (must contain HTTP or HTTPS)", this.protocols); checkArgument(this.protocols.stream().allMatch(p -> p == HTTP || p == HTTPS || p == PROXY), "protocols: %s (must not contain other than %s, %s or %s)", this.protocols, HTTP, HTTPS, PROXY); comparisonStr = localAddress.getAddress().getHostAddress() + '/' + localAddress.getPort() + '/' + protocols; }
@GwtIncompatible // java serialization not supported in GWT. public void testImmutableEnumSet_deserializationMakesDefensiveCopy() throws Exception { ImmutableSet<SomeEnum> original = Sets.immutableEnumSet(SomeEnum.A, SomeEnum.B); int handleOffset = 6; byte[] serializedForm = serializeWithBackReference(original, handleOffset); ObjectInputStream in = new ObjectInputStream(new ByteArrayInputStream(serializedForm)); ImmutableSet<?> deserialized = (ImmutableSet<?>) in.readObject(); EnumSet<?> delegate = (EnumSet<?>) in.readObject(); assertEquals(original, deserialized); assertTrue(delegate.remove(SomeEnum.A)); assertTrue(deserialized.contains(SomeEnum.A)); }
public void testImmutableEnumSet_fromIterable() { ImmutableSet<SomeEnum> none = Sets.immutableEnumSet(MinimalIterable.<SomeEnum>of()); assertThat(none).isEmpty(); ImmutableSet<SomeEnum> one = Sets.immutableEnumSet(MinimalIterable.of(SomeEnum.B)); assertThat(one).contains(SomeEnum.B); ImmutableSet<SomeEnum> two = Sets.immutableEnumSet(MinimalIterable.of(SomeEnum.D, SomeEnum.B)); assertThat(two).containsExactly(SomeEnum.B, SomeEnum.D).inOrder(); }
static Tuple<BlobInfo, Storage.BlobWriteOption[]> toWriteOptions( BlobInfo info, BlobWriteOption... options) { Set<Storage.BlobWriteOption.Option> optionSet = Sets.immutableEnumSet(Lists.transform(Arrays.asList(options), TO_ENUM)); checkArgument( !(optionSet.contains(Storage.BlobWriteOption.Option.IF_METAGENERATION_NOT_MATCH) && optionSet.contains(Storage.BlobWriteOption.Option.IF_METAGENERATION_MATCH)), "metagenerationMatch and metagenerationNotMatch options can not be both provided"); checkArgument( !(optionSet.contains(Storage.BlobWriteOption.Option.IF_GENERATION_NOT_MATCH) && optionSet.contains(Storage.BlobWriteOption.Option.IF_GENERATION_MATCH)), "Only one option of generationMatch, doesNotExist or generationNotMatch can be provided"); Storage.BlobWriteOption[] convertedOptions = new Storage.BlobWriteOption[options.length]; BlobInfo writeInfo = info; int index = 0; for (BlobWriteOption option : options) { Tuple<BlobInfo, Storage.BlobWriteOption> write = option.toWriteOption(writeInfo); writeInfo = write.x(); convertedOptions[index++] = write.y(); } return Tuple.of(writeInfo, convertedOptions); } }
if (userProvidedPermissions instanceof String) { permissions = Sets.immutableEnumSet( PosixFilePermissions.fromString((String) userProvidedPermissions)); } else if (userProvidedPermissions instanceof Set) {
static Tuple<BlobInfo, Storage.BlobTargetOption[]> toTargetOptions( BlobInfo info, BlobTargetOption... options) { Set<StorageRpc.Option> optionSet = Sets.immutableEnumSet(Lists.transform(Arrays.asList(options), TO_ENUM)); checkArgument( !(optionSet.contains(StorageRpc.Option.IF_METAGENERATION_NOT_MATCH) && optionSet.contains(StorageRpc.Option.IF_METAGENERATION_MATCH)), "metagenerationMatch and metagenerationNotMatch options can not be both provided"); checkArgument( !(optionSet.contains(StorageRpc.Option.IF_GENERATION_NOT_MATCH) && optionSet.contains(StorageRpc.Option.IF_GENERATION_MATCH)), "Only one option of generationMatch, doesNotExist or generationNotMatch can be provided"); Storage.BlobTargetOption[] convertedOptions = new Storage.BlobTargetOption[options.length]; BlobInfo targetInfo = info; int index = 0; for (BlobTargetOption option : options) { Tuple<BlobInfo, Storage.BlobTargetOption> target = option.toTargetOption(targetInfo); targetInfo = target.x(); convertedOptions[index++] = target.y(); } return Tuple.of(targetInfo, convertedOptions); } }
public void testImmutableEnumSet() { Set<SomeEnum> units = Sets.immutableEnumSet(SomeEnum.D, SomeEnum.B); assertThat(units).containsExactly(SomeEnum.B, SomeEnum.D).inOrder(); try { units.remove(SomeEnum.B); fail("ImmutableEnumSet should throw an exception on remove()"); } catch (UnsupportedOperationException expected) { } try { units.add(SomeEnum.C); fail("ImmutableEnumSet should throw an exception on add()"); } catch (UnsupportedOperationException expected) { } }
return ImmutableSet.of(); return Sets.immutableEnumSet(normalizations);
@GwtIncompatible // SerializableTester public void testImmutableEnumSet_serialized() { Set<SomeEnum> units = Sets.immutableEnumSet(SomeEnum.D, SomeEnum.B); assertThat(units).containsExactly(SomeEnum.B, SomeEnum.D).inOrder(); Set<SomeEnum> copy = SerializableTester.reserializeAndAssert(units); assertTrue(copy instanceof ImmutableEnumSet); }
public MovedIssueValidator(final Set<Operator> operatorsSupportingMovedIssues, final MovedIssueKeyStore movedIssueKeyStore, final I18nHelper.BeanFactory i18nFactory) { this.movedIssueKeyStore = movedIssueKeyStore; this.i18nFactory = i18nFactory; this.supportedOperators = Sets.immutableEnumSet(operatorsSupportingMovedIssues); }
/** Creates an empty Builder. */ Builder() { this.map = new HashMap<>(); this.sets = CacheBuilder.newBuilder() .build(CacheLoader.from(set -> Sets.immutableEnumSet(set))); }
public static <E extends Enum<E>> ImmutableEnumSet<?> instantiate( SerializationStreamReader reader) throws SerializationException { List<E> deserialized = Lists.newArrayList(); Collection_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 (ImmutableEnumSet<?>) Sets.immutableEnumSet(deserialized); }
ImmutableList<Diagnostic<? extends JavaFileObject>> diagnosticsOfKind(Kind kind, Kind... more) { ImmutableSet<Kind> kinds = Sets.immutableEnumSet(kind, more); return diagnostics() .stream() .filter(diagnostic -> kinds.contains(diagnostic.getKind())) .collect(toImmutableList()); }
public static void register(final Kryo kryo) { final ImmutableSetSerializer setSerializer = new ImmutableSetSerializer(); kryo.register(ImmutableSet.class, setSerializer); kryo.register(ImmutableSet.of().getClass(), setSerializer); kryo.register(ImmutableSet.of(Integer.valueOf(1)).getClass(), setSerializer); kryo.register(ImmutableSet.of(Integer.valueOf(1), Integer.valueOf(2), Integer.valueOf(3)).getClass(), setSerializer); kryo.register(Sets.immutableEnumSet(SomeEnum.A, new SomeEnum[]{SomeEnum.B, SomeEnum.C}).getClass(), setSerializer); }
protected Set<org.dmg.pmml.ResultFeature> collectResultFeatures(){ M model = getModel(); Output output = model.getOutput(); Set<org.dmg.pmml.ResultFeature> resultFeatures = EnumSet.noneOf(org.dmg.pmml.ResultFeature.class); if(output != null && output.hasOutputFields()){ List<org.dmg.pmml.OutputField> outputFields = output.getOutputFields(); for(org.dmg.pmml.OutputField outputField : outputFields){ resultFeatures.add(outputField.getResultFeature()); } } return Sets.immutableEnumSet(resultFeatures); }