com.google.common.collect.ImmutableRangeSet#copyOf ( )源码实例Demo

private @Nonnull Optional<TransformationStep> computeOutgoingSnatPoolTransformation(
    SnatPool snatPool) {
  RangeSet<Ip> pool =
      ImmutableRangeSet.copyOf(
          snatPool.getMembers().stream()
              .map(_snatTranslations::get)
              .filter(Objects::nonNull)
              .map(SnatTranslation::getAddress)
              .filter(Objects::nonNull)
              .map(Range::singleton)
              .collect(ImmutableList.toImmutableList()));
  return pool.isEmpty()
      ? Optional.empty()
      : Optional.of(
          new ApplyAll(
              ASSIGN_EPHEMERAL_SOURCE_PORT,
              new AssignIpAddressFromPool(TransformationType.SOURCE_NAT, IpField.SOURCE, pool)));
}
 

private CrontabEntry(
    RangeSet<Integer> minute,
    RangeSet<Integer> hour,
    RangeSet<Integer> dayOfMonth,
    RangeSet<Integer> month,
    RangeSet<Integer> dayOfWeek) {

  checkEnclosed("minute", MINUTE, minute);
  checkEnclosed("hour", HOUR, hour);
  checkEnclosed("dayOfMonth", DAY_OF_MONTH, dayOfMonth);
  checkEnclosed("month", MONTH, month);
  checkEnclosed("dayOfWeek", DAY_OF_WEEK, dayOfWeek);

  this.minute = ImmutableRangeSet.copyOf(minute);
  this.hour = ImmutableRangeSet.copyOf(hour);
  this.dayOfMonth = ImmutableRangeSet.copyOf(dayOfMonth);
  this.month = ImmutableRangeSet.copyOf(month);
  this.dayOfWeek = ImmutableRangeSet.copyOf(dayOfWeek);

  checkArgument(hasWildcardDayOfMonth() || hasWildcardDayOfWeek(),
      "Specifying both dayOfWeek and dayOfMonth is not supported.");
}
 

@JsonCreator
private static AssignIpAddressFromPool jsonCreator(
    @JsonProperty(PROP_TRANSFORMATION_TYPE) TransformationType type,
    @JsonProperty(PROP_IP_FIELD) IpField ipField,
    @JsonProperty(PROP_IP_RANGES) RangeSet<Ip> ipRanges) {
  checkNotNull(type, PROP_TRANSFORMATION_TYPE + " cannot be null");
  checkNotNull(ipField, PROP_IP_FIELD + " cannot be null");
  checkNotNull(ipRanges, PROP_IP_RANGES + " cannot be null");
  return new AssignIpAddressFromPool(type, ipField, ImmutableRangeSet.copyOf(ipRanges));
}
 

@Nonnull
private RangeSet<Ip> ipRangeSetFromRuleEndpoints(
    Collection<RuleEndpoint> endpoints, Vsys vsys, Warnings w) {
  RangeSet<Ip> rangeSet = TreeRangeSet.create();
  endpoints.stream()
      .map(endpoint -> ruleEndpointToIpRangeSet(endpoint, vsys, w))
      .forEach(rangeSet::addAll);
  return ImmutableRangeSet.copyOf(rangeSet);
}
 

/**
 * Returns a {@link com.google.common.collect.RangeSet} containing the union of all addresses
 * owned by members. Returns empty RangeSet if there are no members.
 */
public RangeSet<Ip> getIpRangeSet(
    Map<String, AddressObject> addressObjects, Map<String, AddressGroup> addressGroups) {
  RangeSet<Ip> rangeSet = TreeRangeSet.create();
  getDescendantObjects(addressObjects, addressGroups, new HashSet<>()).stream()
      .map(addrObjName -> addressObjects.get(addrObjName).getAddressAsRangeSet())
      .forEach(rangeSet::addAll);
  return ImmutableRangeSet.copyOf(rangeSet);
}
 

private RangeSet<Integer> parseMinute() {
  RangeSet<Integer> minutes = TreeRangeSet.create();
  for (String component : getComponents(rawMinute)) {
    minutes.addAll(parseComponent(MINUTE, component));
  }
  return ImmutableRangeSet.copyOf(minutes);
}
 

private RangeSet<Integer> parseHour() {
  RangeSet<Integer> hours = TreeRangeSet.create();
  for (String component : getComponents(rawHour)) {
    hours.addAll(parseComponent(HOUR, component));
  }
  return ImmutableRangeSet.copyOf(hours);
}
 

private RangeSet<Integer> parseDayOfWeek() {
  RangeSet<Integer> daysOfWeek = TreeRangeSet.create();
  for (String component : getComponents(rawDayOfWeek)) {
    daysOfWeek.addAll(parseComponent(DAY_OF_WEEK, replaceNameAliases(component, DAY_NAMES)));
  }
  return ImmutableRangeSet.copyOf(daysOfWeek);
}
 

private RangeSet<Integer> parseMonth() {
  RangeSet<Integer> months = TreeRangeSet.create();
  for (String component : getComponents(rawMonth)) {
    months.addAll(parseComponent(MONTH, replaceNameAliases(component, MONTH_NAMES)));
  }
  return ImmutableRangeSet.copyOf(months);
}
 

private RangeSet<Integer> parseDayOfMonth() {
  RangeSet<Integer> daysOfMonth = TreeRangeSet.create();
  for (String component : getComponents(rawDayOfMonth)) {
    daysOfMonth.addAll(parseComponent(DAY_OF_MONTH, component));
  }
  return ImmutableRangeSet.copyOf(daysOfMonth);
}
 

protected NumberSpace(RangeSet<T> rangeset) {
  _rangeset = ImmutableRangeSet.copyOf(rangeset);
}
 

public AssignIpAddressFromPool(TransformationType type, IpField ipField, RangeSet<Ip> ranges) {
  checkArgument(!ranges.isEmpty(), "Pool ranges cannot be empty");
  _type = type;
  _ipField = ipField;
  _ipRanges = ImmutableRangeSet.copyOf(ranges);
}
 

ResolvedRangeConstraint(final ConstraintMetaDefinition meta, final RangeSet<T> ranges) {
    this.meta = requireNonNull(meta);
    this.ranges = ImmutableRangeSet.copyOf(ranges);
}
 

ResolvedLengthConstraint(final ConstraintMetaDefinition meta, final RangeSet<Integer> ranges) {
    this.meta = requireNonNull(meta);
    this.ranges = ImmutableRangeSet.copyOf(ranges);
}
 

@Override
public RangeSet<Double> load(Field<?> field){
	return ImmutableRangeSet.<Double>copyOf(parseValidRanges((Field & HasContinuousDomain)field));
}