How to use

matches

method

in

org.batfish.role.NodeRole

/** Does this nodeName match any of roles that match our _regex? */
private boolean nodeNameInMatchingRole(String nodeName, Set<NodeRole> roles) {
 for (NodeRole role : roles) {
  if (_regex.matcher(role.getName()).matches() && role.matches(nodeName)) {
   return true;
  }
 }
 return false;
}

/**
 * Create a map from each role name to the set of nodes that play that role
 *
 * @param nodeNames The universe of nodes that we need to classify
 * @return The created map
 */
public SortedMap<String, SortedSet<String>> createRoleNodesMap(Set<String> nodeNames) {
 SortedMap<String, SortedSet<String>> roleNodesMap = new TreeMap<>();
 for (NodeRole role : _roles) {
  for (String node : nodeNames) {
   if (role.matches(node)) {
    SortedSet<String> roleNodes =
      roleNodesMap.computeIfAbsent(role.getName(), k -> new TreeSet<>());
    roleNodes.add(node);
   }
  }
 }
 return roleNodesMap;
}

/**
 * Create a map from each node name to its set of roles
 *
 * @param nodeNames The universe of nodes that we need to classify
 * @return The created map
 */
public SortedMap<String, SortedSet<String>> createNodeRolesMap(Set<String> nodeNames) {
 SortedMap<String, SortedSet<String>> nodeRolesMap = new TreeMap<>();
 for (String node : nodeNames) {
  for (NodeRole role : _roles) {
   if (role.matches(node)) {
    SortedSet<String> nodeRoles = nodeRolesMap.computeIfAbsent(node, k -> new TreeSet<>());
    nodeRoles.add(role.getName());
   }
  }
 }
 return nodeRolesMap;
}

 @Override
 public Set<String> resolve(SpecifierContext ctxt) {
  Optional<NodeRoleDimension> dimension = ctxt.getNodeRoleDimension(_roleDimension);
  Set<NodeRole> roles =
    dimension.isPresent()
      ? dimension.get().getRoles().stream()
        .filter(role -> _rolePattern.matcher(role.getName()).matches())
        .collect(ImmutableSet.toImmutableSet())
      : ImmutableSet.of();

  return ctxt.getConfigs().keySet().stream()
    .filter(node -> roles.stream().anyMatch(role -> role.matches(node)))
    .collect(ImmutableSet.toImmutableSet());
 }
}

 @Override
 public Set<Location> resolve(SpecifierContext ctxt) {
  Optional<NodeRoleDimension> dimension = ctxt.getNodeRoleDimension(_roleDimension);
  Set<NodeRole> matchingRoles =
    dimension.isPresent()
      ? dimension.get().getRoles().stream()
        .filter(role -> _rolePattern.matcher(role.getName()).matches())
        .collect(ImmutableSet.toImmutableSet())
      : ImmutableSet.of();

  return ctxt.getConfigs().values().stream()
    .filter(node -> matchingRoles.stream().anyMatch(role -> role.matches(node.getHostname())))
    .flatMap(this::getNodeLocations)
    .collect(ImmutableSet.toImmutableSet());
 }
}

 @Test
 public void matches() {
  NodeRole role = new NodeRole("hello", "a.*");

  assertThat(role.matches("a1"), equalTo(true));
  assertThat(role.matches("b1"), equalTo(false));
 }
}