public boolean isChanged(String s) { for (Pair<String, Expr> pair : this._changedVariables) { if (pair.getFirst().equals(s)) { return true; } } return false; }
@JsonIgnore public Ip getLocalIp() { return _key.getFirst(); }
@Override protected T1 featureValueOf(Pair<T1, T2> actual) { return actual.getFirst(); } }
@Nullable private Expr find(PList<Pair<String, Expr>> vals, String s) { for (Pair<String, Expr> pair : vals) { if (pair.getFirst().equals(s)) { return pair.getSecond(); } } return null; }
private NodeRoleDimension toNodeRoleDimension( Pair<Integer, Double> bestRegexAndScore, List<List<String>> candidates, String dimName) { List<String> bestRegexTokens = candidates.get(bestRegexAndScore.getFirst()); String bestRegex = regexTokensToRegex(bestRegexTokens); return regexToNodeRoleDimension(bestRegex, dimName); }
private boolean inferCommonRegex(Collection<String> nodes) { for (int attempts = 0; attempts < 10; attempts++) { // pick a random node name, in order to find one with a common pattern // the node name that is used to infer a regex String chosenNode = Iterables.get(nodes, new Random().nextInt(nodes.size())); _tokens = tokenizeName(chosenNode); _regex = _tokens.stream() .map((p) -> p.getSecond().tokenToRegex(p.getFirst())) .collect(Collectors.toList()); Pattern p = Pattern.compile(String.join("", _regex), _patternFlags); _matchingNodes = nodes.stream().filter((node) -> p.matcher(node).matches()).collect(Collectors.toList()); // keep this regex if it matches a sufficient fraction of node names; otherwise try again if ((double) _matchingNodes.size() / nodes.size() >= REGEX_THRESHOLD) { return true; } } return false; }
public InterfacePolicy restrictStatic(List<Prefix> prefixes) { if (_staticRoutes == null) { return this; } SortedSet<Pair<Prefix, Integer>> newStatic = new TreeSet<>(); for (Pair<Prefix, Integer> tup : _staticRoutes) { if (prefixes == null || PrefixUtils.overlap(tup.getFirst(), prefixes)) { newStatic.add(tup); } } if (newStatic.size() == _staticRoutes.size()) { return this; } InterfacePolicy pol = new InterfacePolicy(this); pol._staticRoutes = newStatic; return pol; }
private static List<Pair<String, Token>> preTokensToUndelimitedTokens( List<Pair<String, PreToken>> pretokens) { List<Pair<String, Token>> tokens = new ArrayList<>(); int size = pretokens.size(); for (int i = 0; i < size; i++) { String chars = pretokens.get(i).getFirst(); PreToken pt = pretokens.get(i).getSecond(); switch (pt) { case ALPHA_PLUS: int next = i + 1; if (next >= size) { tokens.add(new Pair<>(chars, Token.ALPHA_PLUS)); } else { // the next token must be DIGIT_PLUS since we know there are no delimiters String bothChars = chars + pretokens.get(next).getFirst(); tokens.add(new Pair<>(bothChars, Token.ALPHA_PLUS_DIGIT_PLUS)); i++; } break; case DIGIT_PLUS: tokens.add(new Pair<>(chars, Token.DIGIT_PLUS)); break; default: throw new BatfishException("Unexpected pretoken " + pt); } } return tokens; }
private boolean getWorkStatus( @Nullable FileWriter outWriter, List<String> options, List<String> parameters) { if (!isValidArgument(options, parameters, 0, 1, 1, Command.GET_WORK_STATUS)) { return false; } UUID workId = UUID.fromString(parameters.get(0)); Pair<WorkStatusCode, String> response = _workHelper.getWorkStatus(workId); if (response == null) { return false; } printWorkStatusResponse(response, true); logOutput(outWriter, "status: " + response.getFirst()); return true; }
@Override public void complete(LineReader lineReader, ParsedLine parsedLine, List<Candidate> candidates) { String buffer = parsedLine.word().trim(); if (Strings.isNullOrEmpty(buffer)) { candidates.addAll(_commandStrs.stream().map(Candidate::new).collect(Collectors.toList())); } else { for (String match : _commandStrs.tailSet(buffer)) { if (!match.startsWith(buffer)) { break; } candidates.add(new Candidate(match)); } } // if the match was unique and the complete command was specified, print the command usage if (candidates.size() == 1 && candidates.get(0).displ().equals(buffer)) { candidates.clear(); candidates.add( new Candidate( " " + Command.getUsageMap().get(Command.getNameMap().get(buffer)).getFirst())); } } }
private void printUsage(Command command) { Pair<String, String> usage = Command.getUsageMap().get(command); _logger.outputf("%s %s\n\t%s\n\n", command.commandName(), usage.getFirst(), usage.getSecond()); }
public RipNeighborSummary(RipNeighbor ripNeighbor) { super(ripNeighbor.getOwner().getHostname() + ":" + ripNeighbor._key); _localIp = ripNeighbor._key.getFirst(); _remoteIp = ripNeighbor._key.getSecond(); _vrf = ripNeighbor._vrf; }
public PList<Pair<String, Pair<Expr, Expr>>> mergeChangedVariables(TransferResult<U, T> other) { Set<String> seen = new HashSet<>(); PList<Pair<String, Pair<Expr, Expr>>> vars = PList.empty(); for (Pair<String, Expr> cv1 : this._changedVariables) { String s = cv1.getFirst(); Expr x = cv1.getSecond(); if (!seen.contains(s)) { seen.add(s); Expr e = find(other._changedVariables, s); Pair<Expr, Expr> pair = new Pair<>(x, e); vars = vars.plus(new Pair<>(s, pair)); } } for (Pair<String, Expr> cv1 : other._changedVariables) { String s = cv1.getFirst(); Expr x = cv1.getSecond(); if (!seen.contains(s)) { seen.add(s); Expr e = find(this._changedVariables, s); Pair<Expr, Expr> pair = new Pair<>(e, x); // preserve order vars = vars.plus(new Pair<>(s, pair)); } } return vars; }
private void testInvalidInput(Command command, String[] options, String[] parameters) throws Exception { Pair<String, String> usage = Command.getUsageMap().get(command); String expected = String.format( "Invalid arguments: %s %s\n%s %s\n\t%s\n\n", Arrays.toString(options), Arrays.toString(parameters), command.commandName(), usage.getFirst(), usage.getSecond()); checkProcessCommandErrorMessage(command, ArrayUtils.addAll(options, parameters), expected); }
WorkStatusCode status = response.getFirst(); _logger.outputf("status: %s\n", status);
@Test public void testHelpInvalidParas() throws Exception { Command command = HELP; String[] parameters = new String[] {"-option1"}; Pair<String, String> usage = Command.getUsageMap().get(command); String expected = String.format( "Invalid arguments: %s []\n%s %s\n\t%s\n\n", Arrays.toString(parameters), command.commandName(), usage.getFirst(), usage.getSecond()); checkProcessCommandErrorMessage(command, parameters, expected); }
@Test public void testCatInvalidParas() throws Exception { Command command = CAT; String[] args = new String[] {command.commandName()}; Pair<String, String> usage = Command.getUsageMap().get(command); String expected = String.format( "Invalid arguments: %s\n%s %s\n\t%s\n\n", Arrays.toString(args), command.commandName(), usage.getFirst(), usage.getSecond()); checkProcessCommandErrorMessage(command, new String[] {}, expected); }
@Test public void testInitNetworkEmptyParasWithOption() throws Exception { Command command = INIT_NETWORK; String[] args = new String[] {"-setname"}; Pair<String, String> usage = Command.getUsageMap().get(command); String expected = String.format( "Invalid arguments: %s []\n%s %s\n\t%s\n\n", "[-setname]", command.commandName(), usage.getFirst(), usage.getSecond()); checkProcessCommandErrorMessage(command, args, expected); }
@Test public void testHelpValidParas() throws Exception { String[] parameters = new String[] {"get"}; Pair<String, String> usage = Command.getUsageMap().get(GET); String expected = String.format("%s %s\n\t%s\n\n", GET.commandName(), usage.getFirst(), usage.getSecond()); testProcessCommandWithValidInput(HELP, parameters, expected); }
@Test public void testInitNetworkInvalidOptions() throws Exception { Command command = INIT_NETWORK; String invalidOption = "-setnetwork"; String[] args = new String[] {invalidOption, "parameter1"}; Pair<String, String> usage = Command.getUsageMap().get(command); String expected = String.format( "Invalid arguments: %s %s\n%s %s\n\t%s\n\n", "[-setnetwork]", "[parameter1]", command.commandName(), usage.getFirst(), usage.getSecond()); checkProcessCommandErrorMessage(command, args, expected); }