Java EnumSet.addAll方法代码示例

import java.util.EnumSet; //导入方法依赖的package包/类
@Override
public Condition generateCondition() {
    Condition subcondition = subfulfillment.getCondition();

    EnumSet<FeatureSuite> features = subcondition.getFeatures();
    features.addAll(BASE_FEATURES);

    byte[] fingerprint = Crypto.getSha256Hash(
            calculateFingerPrintContent(
                    prefix,
                    subcondition
            )
    );

    int maxFulfillmentLength = calculateMaxFulfillmentLength(
            prefix,
            subcondition
    );

    return new ConditionImpl(
            ConditionType.PREFIX_SHA256,
            features,
            fingerprint,
            maxFulfillmentLength);
}
 

import java.util.EnumSet; //导入方法依赖的package包/类
/**
 * Determines the set of condition rsa that are ultimately held via the sub condition.
 *
 * @param subconditions The sub conditions that this condition depends on.
 *
 * @return The set of condition rsa related to the sub condition.
 */
private static final EnumSet<CryptoConditionType> calculateSubtypes(
    final List<Condition> subconditions
) {
  Objects.requireNonNull(subconditions);

  final EnumSet<CryptoConditionType> subtypes = EnumSet.noneOf(CryptoConditionType.class);
  for (int i = 0; i < subconditions.size(); i++) {
    subtypes.add(subconditions.get(i).getType());
    if (subconditions.get(i) instanceof CompoundCondition) {
      subtypes.addAll(((CompoundCondition) subconditions.get(i)).getSubtypes());
    }
  }

  // Remove our own type
  if (subtypes.contains(THRESHOLD_SHA256)) {
    subtypes.remove(THRESHOLD_SHA256);
  }

  return subtypes;
}
 

import java.util.EnumSet; //导入方法依赖的package包/类
/**
 */
public Scheme(
    ImmutableSet<String> lcaseNames,
    boolean isHierarchical, int defaultPortOrNegOne,
    SchemePart... parts) {
  Preconditions.checkArgument(
      defaultPortOrNegOne == -1
      || (1 <= defaultPortOrNegOne && defaultPortOrNegOne <= 65535),
      "Port is out of range");
  EnumSet<SchemePart> partSet = EnumSet.noneOf(SchemePart.class);
  partSet.addAll(Arrays.asList(parts));
  this.lcaseNames = lcaseNames;
  this.isHierarchical = isHierarchical;
  this.defaultPortOrNegOne = defaultPortOrNegOne;
  this.naturallyEmbedsContent = partSet.contains(SchemePart.CONTENT);
  this.naturallyHasAuthority = partSet.contains(SchemePart.AUTHORITY);
  this.mayHaveUserName = partSet.contains(SchemePart.USERINFO);
  this.naturallyHasPath = partSet.contains(SchemePart.PATH);
  this.naturallyHasQuery = partSet.contains(SchemePart.QUERY);
}
 

import java.util.EnumSet; //导入方法依赖的package包/类
private static void assertCornerCases(
    String refUrl, String baseUrl,
    String wantUrl, UrlValue.CornerCase... wantCases) {
  Absolutizer abs = new Absolutizer(
      UrlContext.DEFAULT.absolutizer.schemes, baseUrl);
  Absolutizer.Result got = abs.absolutize(refUrl);
  EnumSet<UrlValue.CornerCase> wantCaseSet = EnumSet.noneOf(
      UrlValue.CornerCase.class);
  wantCaseSet.addAll(Arrays.asList(wantCases));
  assertEquals(
      "base=" + baseUrl + ", ref=" + refUrl,
      wantCaseSet, got.cornerCases);
  assertEquals(
      "base=" + baseUrl + ", ref=" + refUrl,
      wantUrl, got.absUrlText);
}
 

import java.util.EnumSet; //导入方法依赖的package包/类
@Override
protected EnumSet<OperandFlag> getFlags(Field field) {
    EnumSet<OperandFlag> result = EnumSet.noneOf(OperandFlag.class);
    // Unfortunately, annotations cannot have class hierarchies or implement interfaces, so
    // we have to duplicate the code for every operand mode.
    // Unfortunately, annotations cannot have an EnumSet property, so we have to convert
    // from arrays to EnumSet manually.
    if (field.isAnnotationPresent(LIRInstruction.Use.class)) {
        result.addAll(Arrays.asList(field.getAnnotation(LIRInstruction.Use.class).value()));
    } else if (field.isAnnotationPresent(LIRInstruction.Alive.class)) {
        result.addAll(Arrays.asList(field.getAnnotation(LIRInstruction.Alive.class).value()));
    } else if (field.isAnnotationPresent(LIRInstruction.Temp.class)) {
        result.addAll(Arrays.asList(field.getAnnotation(LIRInstruction.Temp.class).value()));
    } else if (field.isAnnotationPresent(LIRInstruction.Def.class)) {
        result.addAll(Arrays.asList(field.getAnnotation(LIRInstruction.Def.class).value()));
    } else {
        GraalError.shouldNotReachHere();
    }
    return result;
}
 

import java.util.EnumSet; //导入方法依赖的package包/类
/**
 * Creates a new configuration by adding the new options to the options used in this configuration.
 * @param options options to add
 * @return a new configuration
 */
public Configuration addOptions(Option... options) {
    EnumSet<Option> opts = EnumSet.noneOf(Option.class);
    opts.addAll(this.options);
    opts.addAll(asList(options));
    return Configuration.builder().jsonProvider(jsonProvider).mappingProvider(mappingProvider).options(opts).evaluationListener(evaluationListeners).build();
}
 

import java.util.EnumSet; //导入方法依赖的package包/类
public static EnumSet<SatelliteImageType> typeFromDescription(String description) throws BuenOjoCSVParserException  {
	
	String types[] = description.split(",");
	EnumSet<SatelliteImageType> typeSet = EnumSet.noneOf(SatelliteImageType.class);
	for (String type : types) {
		EnumSet<SatelliteImageType> subSet = enumSetFromTypeString(type.trim());
		 typeSet.addAll(subSet);
	}
	return typeSet;
}
 

import java.util.EnumSet; //导入方法依赖的package包/类
/**
 * Determines the set of condition rsa that are ultimately held via the sub condition.
 *
 * @param subcondition The sub condition that this condition depends on.
 *
 * @return The set of condition rsa related to the sub condition.
 */
private static EnumSet<CryptoConditionType> calculateSubtypes(Condition subcondition) {
  EnumSet<CryptoConditionType> subtypes = EnumSet.of(subcondition.getType());
  if (subcondition instanceof CompoundCondition) {
    subtypes.addAll(((CompoundCondition) subcondition).getSubtypes());
  }

  // Remove our own type
  if (subtypes.contains(PREFIX_SHA256)) {
    subtypes.remove(PREFIX_SHA256);
  }

  return subtypes;
}
 

import java.util.EnumSet; //导入方法依赖的package包/类
/**
 * Copy a compilation state from an original function to this function. Used when creating synthetic
 * function nodes by the splitter.
 *
 * @param lc lexical context
 * @param original the original function node to copy compilation state from
 * @return function node or a new one if state was changed
 */
public FunctionNode copyCompilationState(final LexicalContext lc, final FunctionNode original) {
    final EnumSet<CompilationState> origState = original.compilationState;
    if (!AssertsEnabled.assertsEnabled() || this.compilationState.containsAll(origState)) {
        return this;
    }
    final EnumSet<CompilationState> newState = EnumSet.copyOf(this.compilationState);
    newState.addAll(origState);
    return setCompilationState(lc, newState);
}
 

import java.util.EnumSet; //导入方法依赖的package包/类
@Override
protected EnumSet<OperandFlag> getFlags(Field field) {
    EnumSet<OperandFlag> result = EnumSet.noneOf(OperandFlag.class);
    if (field.isAnnotationPresent(CompositeValue.Component.class)) {
        result.addAll(Arrays.asList(field.getAnnotation(CompositeValue.Component.class).value()));
    } else {
        GraalError.shouldNotReachHere();
    }
    return result;
}
 

import java.util.EnumSet; //导入方法依赖的package包/类
private static String getCascadeStrategy(
		javax.persistence.CascadeType[] ejbCascades,
		Cascade hibernateCascadeAnnotation,
		boolean orphanRemoval,
		boolean forcePersist) {
	EnumSet<CascadeType> hibernateCascadeSet = convertToHibernateCascadeType( ejbCascades );
	CascadeType[] hibernateCascades = hibernateCascadeAnnotation == null ?
			null :
			hibernateCascadeAnnotation.value();

	if ( hibernateCascades != null && hibernateCascades.length > 0 ) {
		hibernateCascadeSet.addAll( Arrays.asList( hibernateCascades ) );
	}

	if ( orphanRemoval ) {
		hibernateCascadeSet.add( CascadeType.DELETE_ORPHAN );
		hibernateCascadeSet.add( CascadeType.REMOVE );
	}
	if ( forcePersist ) {
		hibernateCascadeSet.add( CascadeType.PERSIST );
	}

	StringBuilder cascade = new StringBuilder();
	for ( CascadeType aHibernateCascadeSet : hibernateCascadeSet ) {
		switch ( aHibernateCascadeSet ) {
			case ALL:
				cascade.append( "," ).append( "all" );
				break;
			case SAVE_UPDATE:
				cascade.append( "," ).append( "save-update" );
				break;
			case PERSIST:
				cascade.append( "," ).append( "persist" );
				break;
			case MERGE:
				cascade.append( "," ).append( "merge" );
				break;
			case LOCK:
				cascade.append( "," ).append( "lock" );
				break;
			case REFRESH:
				cascade.append( "," ).append( "refresh" );
				break;
			case REPLICATE:
				cascade.append( "," ).append( "replicate" );
				break;
			case EVICT:
			case DETACH:
				cascade.append( "," ).append( "evict" );
				break;
			case DELETE:
				cascade.append( "," ).append( "delete" );
				break;
			case DELETE_ORPHAN:
				cascade.append( "," ).append( "delete-orphan" );
				break;
			case REMOVE:
				cascade.append( "," ).append( "delete" );
				break;
		}
	}
	return cascade.length() > 0 ?
			cascade.substring( 1 ) :
			"none";
}
 

import java.util.EnumSet; //导入方法依赖的package包/类
public boolean[] parseFaces(String p_parseFaces_1_, boolean[] p_parseFaces_2_)
{
    if (p_parseFaces_1_ == null)
    {
        return p_parseFaces_2_;
    }
    else
    {
        EnumSet enumset = EnumSet.allOf(EnumFacing.class);
        String[] astring = Config.tokenize(p_parseFaces_1_, " ,");

        for (int i = 0; i < astring.length; ++i)
        {
            String s = astring[i];

            if (s.equals("sides"))
            {
                enumset.add(EnumFacing.NORTH);
                enumset.add(EnumFacing.SOUTH);
                enumset.add(EnumFacing.WEST);
                enumset.add(EnumFacing.EAST);
            }
            else if (s.equals("all"))
            {
                enumset.addAll(Arrays.asList(EnumFacing.VALUES));
            }
            else
            {
                EnumFacing enumfacing = this.parseFace(s);

                if (enumfacing != null)
                {
                    enumset.add(enumfacing);
                }
            }
        }

        boolean[] aboolean = new boolean[EnumFacing.VALUES.length];

        for (int j = 0; j < aboolean.length; ++j)
        {
            aboolean[j] = enumset.contains(EnumFacing.VALUES[j]);
        }

        return aboolean;
    }
}
 

import java.util.EnumSet; //导入方法依赖的package包/类
/** replace types in all bounds - this might trigger listener notification */
public void substBounds(List<Type> from, List<Type> to, Types types) {
    List<Type> instVars = from.diff(to);
    //if set of instantiated ivars is empty, there's nothing to do!
    if (instVars.isEmpty()) return;
    final EnumSet<InferenceBound> boundsChanged = EnumSet.noneOf(InferenceBound.class);
    UndetVarListener prevListener = listener;
    try {
        //setup new listener for keeping track of changed bounds
        listener = new UndetVarListener() {
            public void varChanged(UndetVar uv, Set<InferenceBound> ibs) {
                boundsChanged.addAll(ibs);
            }
        };
        for (Map.Entry<InferenceBound, List<Type>> _entry : bounds.entrySet()) {
            InferenceBound ib = _entry.getKey();
            List<Type> prevBounds = _entry.getValue();
            ListBuffer<Type> newBounds = new ListBuffer<>();
            ListBuffer<Type> deps = new ListBuffer<>();
            //step 1 - re-add bounds that are not dependent on ivars
            for (Type t : prevBounds) {
                if (!t.containsAny(instVars)) {
                    newBounds.append(t);
                } else {
                    deps.append(t);
                }
            }
            //step 2 - replace bounds
            bounds.put(ib, newBounds.toList());
            //step 3 - for each dependency, add new replaced bound
            for (Type dep : deps) {
                addBound(ib, types.subst(dep, from, to), types, true);
            }
        }
    } finally {
        listener = prevListener;
        if (!boundsChanged.isEmpty()) {
            notifyChange(boundsChanged);
        }
    }
}
 

import java.util.EnumSet; //导入方法依赖的package包/类
private UrlValue(UrlContext context, String originalUrlText) {
  this.context = context;
  this.originalUrlText = originalUrlText;

  EnumSet<CornerCase> extraCornerCases = EnumSet.noneOf(
      CornerCase.class);

  String refUrlText = originalUrlText;
  switch (context.microsoftPathStrategy) {
    case BACK_TO_FORWARD:
      int eos = Absolutizer.endOfScheme(refUrlText);
      @SuppressWarnings("hiding")
      Scheme scheme = null;
      if (eos >= 0) {
        scheme = context.absolutizer.schemes.schemeForName(
            refUrlText.substring(0, eos - 1 /* ':' */));
      }
      if (scheme == null || scheme.isHierarchical) {
        refUrlText = refUrlText.replace('\\', '/');
        if (!refUrlText.equals(originalUrlText)) {
          extraCornerCases.add(CornerCase.FLIPPED_SLASHES);
        }
      }
      break;
    case STANDARDS_COMPLIANT:
      break;
  }

  Absolutizer.Result abs = context.absolutizer.absolutize(refUrlText);
  this.scheme  = abs.scheme;
  this.urlText = abs.absUrlText;
  this.ranges = abs.absUrlRanges;
  if (ranges == null || ranges.authorityLeft == ranges.authorityRight) {
    this.rawAuthority = null;
    this.authority = null;
    this.inheritsPlaceholderAuthority = false;
  } else {
    this.rawAuthority = this.urlText.substring(
        this.ranges.authorityLeft, this.ranges.authorityRight);
    this.inheritsPlaceholderAuthority = this.ranges != null
        && abs.originalUrlRanges.authorityLeft < 0
        && UrlContext.PLACEHOLDER_AUTHORITY.equals(rawAuthority);
    this.authority = Authority.decode(this, Diagnostic.Receiver.NULL);
    if (this.authority != null) {
      if (!this.authority.hasValidHost()) {
        extraCornerCases.add(CornerCase.IDNA_INVALID_HOST);
      } else if (this.authority.hasTransitionalDifference()) {
        extraCornerCases.add(CornerCase.IDNA_TRANSITIONAL_DIFFERENCE);
      }
    }
  }

  ImmutableSet<CornerCase> allCornerCases = abs.cornerCases;
  if (!extraCornerCases.isEmpty()) {
    extraCornerCases.addAll(allCornerCases);
    allCornerCases = Sets.immutableEnumSet(extraCornerCases);
  }
  this.cornerCases = allCornerCases;
}
 

import java.util.EnumSet; //导入方法依赖的package包/类
static <E extends Enum<E>> EnumSet<E> toEnumSet(final Class<E> clazz,
    final E... values) {
  final EnumSet<E> set = EnumSet.noneOf(clazz);
  set.addAll(Arrays.asList(values));
  return set;
}