How to use

including

method

in

org.batfish.datamodel.IpWildcardSetIpSpace$Builder

private IpSpace computeOwnedIps() {
 try (ActiveSpan span =
   GlobalTracer.get().buildSpan("ForwardingAnalysisImpl.computeOwnedIps").startActive()) {
  assert span != null; // avoid unused warning
  return IpWildcardSetIpSpace.builder()
    .including(
      _interfaceOwnedIps.values().stream()
        .flatMap(ifaceMap -> ifaceMap.values().stream())
        .flatMap(Collection::stream)
        .map(IpWildcard::new)
        .collect(Collectors.toList()))
    .build();
 }
}

public Builder including(IpWildcard... wildcards) {
 return including(Arrays.asList(wildcards));
}

@VisibleForTesting
IpSpace computeIpsAssignedToThisInterface(Interface iface) {
 Set<Ip> ips = _interfaceOwnedIps.get(iface.getOwner().getHostname()).get(iface.getName());
 if (ips == null || ips.isEmpty()) {
  return EmptyIpSpace.INSTANCE;
 }
 IpWildcardSetIpSpace.Builder ipsAssignedToThisInterfaceBuilder = IpWildcardSetIpSpace.builder();
 ips.forEach(ip -> ipsAssignedToThisInterfaceBuilder.including(new IpWildcard(ip)));
 IpWildcardSetIpSpace ipsAssignedToThisInterface = ipsAssignedToThisInterfaceBuilder.build();
 return ipsAssignedToThisInterface;
}

@Test
public void testParseIpSpace_whitelist() {
 assertThat(
   parseIpSpace("1.0.0.0,2.0.0.0/8"),
   equalTo(
     IpWildcardSetIpSpace.builder()
       .including(ImmutableList.of(new IpWildcard("1.0.0.0"), new IpWildcard("2.0.0.0/8")))
       .build()));
}

void addRoutableIps(IpWildcardSetIpSpace.Builder builder) {
 if (hasForwardingRoute()) {
  builder.including(new IpWildcard(_prefix));
 } else {
  if (_left != null) {
   _left.addRoutableIps(builder);
  }
  if (_right != null) {
   _right.addRoutableIps(builder);
  }
 }
}

public void setNotSrcIps(Iterable<IpWildcard> notSrcIps) {
 _notSrcIps = IpWildcardSetIpSpace.builder().including(notSrcIps).build();
}

public void setDstIps(Iterable<IpWildcard> dstIps) {
 _dstIps = IpWildcardSetIpSpace.builder().including(dstIps).build();
}

public Builder setNotSrcIps(Iterable<IpWildcard> notSrcIps) {
 _notSrcIps = IpWildcardSetIpSpace.builder().including(notSrcIps).build();
 return this;
}

@Test
public void testConstantIpSpace() {
 assertThat(
   new FlexibleInferFromLocationIpSpaceSpecifierFactory().buildIpSpaceSpecifier("1.1.1.1"),
   equalTo(
     new ConstantIpSpaceSpecifier(
       IpWildcardSetIpSpace.builder().including(new IpWildcard("1.1.1.1")).build())));
}

public Builder setDstIps(Iterable<IpWildcard> dstIps) {
 _dstIps = IpWildcardSetIpSpace.builder().including(dstIps).build();
 return this;
}

public Builder setNotDstIps(Iterable<IpWildcard> notDstIps) {
 _notDstIps = IpWildcardSetIpSpace.builder().including(notDstIps).build();
 return this;
}

public Builder setSrcOrDstIps(Iterable<IpWildcard> srcOrDstIps) {
 _srcOrDstIps = IpWildcardSetIpSpace.builder().including(srcOrDstIps).build();
 return this;
}

public void setSrcIps(Iterable<IpWildcard> srcIps) {
 _srcIps = IpWildcardSetIpSpace.builder().including(srcIps).build();
}

public void setNotDstIps(Iterable<IpWildcard> notDstIps) {
 _notDstIps = IpWildcardSetIpSpace.builder().including(notDstIps).build();
}

@Test
public void testParseIpSpace_blacklist() {
 assertThat(
   parseIpSpace("1.0.0.0,2.0.0.0/8 - 3.0.0.0,4.0.0.0/32"),
   equalTo(
     IpWildcardSetIpSpace.builder()
       .including(ImmutableList.of(new IpWildcard("1.0.0.0"), new IpWildcard("2.0.0.0/8")))
       .excluding(
         ImmutableList.of(new IpWildcard("3.0.0.0"), new IpWildcard("4.0.0.0/32")))
       .build()));
}

public void setSrcOrDstIps(Iterable<IpWildcard> srcOrDstIps) {
 _srcOrDstIps = IpWildcardSetIpSpace.builder().including(srcOrDstIps).build();
}

@Test
public void testVisitIpWildcardSetIpSpace_whitelistOne() {
 IpWildcard ipWildcard = new IpWildcard("1.2.3.4");
 assertThat(
   SIMPLIFIER.simplify(IpWildcardSetIpSpace.builder().including(ipWildcard).build()),
   equalTo(ipWildcard.toIpSpace()));
}

@Test
public void testParseIpSpace_blacklist_backslash() {
 assertThat(
   parseIpSpace("1.0.0.0,2.0.0.0/8 \\ 3.0.0.0,4.0.0.0/32"),
   equalTo(
     IpWildcardSetIpSpace.builder()
       .including(ImmutableList.of(new IpWildcard("1.0.0.0"), new IpWildcard("2.0.0.0/8")))
       .excluding(
         ImmutableList.of(new IpWildcard("3.0.0.0"), new IpWildcard("4.0.0.0/32")))
       .build()));
}

@VisibleForTesting
static IpWildcardSetIpSpace parseIpSpace(@Nonnull String input) {
 String[] strs = input.split("-|\\\\");
 if (strs.length == 1) {
  return IpWildcardSetIpSpace.builder().including(parseWildcards(strs[0])).build();
 }
 if (strs.length == 2) {
  return IpWildcardSetIpSpace.builder()
    .including(parseWildcards(strs[0]))
    .excluding(parseWildcards(strs[1]))
    .build();
 }
 throw new IllegalArgumentException(
   "Error parsing IpWildcards: only 1 subtraction operator ('-' or '\\') allowed");
}

public Builder setSrcIps(Iterable<IpWildcard> srcIps) {
 _srcIps = IpWildcardSetIpSpace.builder().including(srcIps).build();
 return this;
}