Java Code Examples for java.util.regex.Matcher#find()

private static String removeByRegex(String inputString, String regex) {
    Pattern pattern = Pattern.compile(regex);
    Matcher matcher = pattern.matcher(inputString);
    StringBuilder sb = new StringBuilder(inputString);

    Set<String> wrapped = new LinkedHashSet<>();

    while (matcher.find()) {
        wrapped.add(matcher.group());
    }

    for (String str : wrapped) {
        int from = -1;
        int to = -1;
        while ((from = sb.indexOf(str)) != -1) {
            to = from + str.length();
            sb.replace(from, to, "");

        }
    }

    return sb.toString();
}
 

public static SQLQuery replaceNamedParameters( String query, Map<String, Object> namedParameters )
{  // replace #{namedVar} in query with ? and appends corresponding parameter from map namedParameters
 Pattern p = Pattern.compile("#\\{\\s*([^\\s\\}]+)\\s*\\}");
 SQLQuery qry = new SQLQuery();
 Matcher m = p.matcher( query );

 while( m.find() )
 { String nParam = m.group(1);
   if( !namedParameters.containsKey(nParam) )
    throw new IllegalArgumentException("sql: named Parameter ["+ nParam +"] missing");
   qry.addParameter( namedParameters.get(nParam) );
 }

 qry.append( m.replaceAll("?") );

 return qry;
}
 

public static List<EnumMetaDada> string2EnumMetaData(String data) {
    if (data == null || data.trim().length() == 0)
        return new ArrayList();
    //enumAlias(enumKey,enumDesc),enumAlias(enumDesc)

    List<EnumMetaDada> list = new ArrayList();
    Pattern p = Pattern.compile("\\w+\\(.*?\\)");
    Matcher m = p.matcher(data);
    while (m.find()) {
        String str = m.group();
        Matcher three_m = three.matcher(str);
        if (three_m.find()) {
            list.add(new EnumMetaDada(three_m.group(1), three_m.group(2), three_m.group(3)));
            continue;
        }
        Matcher two_m = two.matcher(str);
        if (two_m.find()) {
            list.add(new EnumMetaDada(two_m.group(1), two_m.group(1), two_m.group(2)));
            continue;
        }
        throw new IllegalArgumentException("error enumString format:" + data + " expected format:F(1,Female);M(0,Male) or F(Female);M(Male)");
    }
    return list;
}
 

private static String getAaptResult(String sdkPath, String apkPath, final Pattern pattern) {
	try {
		final File apkFile = new File(apkPath);
		final ByteArrayOutputStream aaptOutput = new ByteArrayOutputStream();
		final String command = getAaptDumpBadgingCommand(sdkPath, apkFile.getName());

		Process process = Runtime.getRuntime().exec(command, null, apkFile.getParentFile());

		InputStream inputStream = process.getInputStream();
		for (int last = inputStream.read(); last != -1; last = inputStream.read()) {
			aaptOutput.write(last);
		}

		String packageId = "";
		final String aaptResult = aaptOutput.toString();
		if (aaptResult.length() > 0) {
			final Matcher matcher = pattern.matcher(aaptResult);
			if (matcher.find()) {
				packageId = matcher.group(1);
			}
		}
		return packageId;
	} catch(IOException e) {
		throw new RuntimeException(e);
	}
}
 

public static void addEventLogEntry(Event event, Location<World> location, Object source, Object target, Subject permissionSubject, String permission, String trust, Tristate result) {
    if (GriefPreventionPlugin.debugActive) {
        String sourceId = getPermissionIdentifier(source, true);
        String targetPermission = permission;
        String targetId = getPermissionIdentifier(target);
        if (!targetId.isEmpty()) {
            // move target meta to end of permission
            Matcher m = PATTERN_META.matcher(targetId);
            String targetMeta = "";
            if (!permission.contains("command-execute")) {
                if (m.find()) {
                    targetMeta = m.group(0);
                    targetId = StringUtils.replace(targetId, targetMeta, "");
                }
            }
            targetPermission += "." + targetId + targetMeta;
        }
        if (permissionSubject == null) {
            permissionSubject = GriefPreventionPlugin.GLOBAL_SUBJECT;
        }
        GriefPreventionPlugin.addEventLogEntry(event, location, sourceId, targetId, permissionSubject, targetPermission, trust, result);
    }
}
 

public static String stripUIRefsFromInspectionDescription(String description) {
  final int descriptionEnd = description.indexOf("<!-- tooltip end -->");
  if (descriptionEnd < 0) {
    final Pattern pattern = Pattern.compile(".*Use.*(the (panel|checkbox|checkboxes|field|button|controls).*below).*", Pattern.DOTALL);
    final Matcher matcher = pattern.matcher(description);
    int startFindIdx = 0;
    while (matcher.find(startFindIdx)) {
      final int end = matcher.end(1);
      startFindIdx = end;
      description = description.substring(0, matcher.start(1)) + " inspection settings " + description.substring(end);
    }
  } else {
    description = description.substring(0, descriptionEnd);
  }
  return description;
}
 

/**
 * 匹配 str 中符合表达式 p的第一个
 * 
 * @param p
 * @param str
 * @return
 */
public static String match(String p, String str) {

    Pattern pattern = Pattern.compile(p);
    Matcher m = pattern.matcher(str);
    if (m.find()) {
        return m.group(1);
    }
    return null;
}
 

public String encodeUrlsAsHtml(String text) {
    // MOVED FROM Web
    Pattern p = Pattern.compile("(?<!href=['\"]{1})(((https?|s?ftp|ftps|file|smb|afp|nfs|(x-)?man|gopher|txmt)://|mailto:)[-:;@a-zA-Z0-9_.,~%+/?=&#]+(?<![.,?:]))");
    Matcher m = p.matcher(text);
    StringBuffer buf = new StringBuffer();
    while(m.find()) {
        String matchedUrl = m.group();
        m.appendReplacement(buf, "<a href=\"" + unEscapeHtml(matchedUrl) + "\">$1</a>");
    }
    m.appendTail(buf);
    return buf.toString();
}
 

public static String[] splitCommandWithoutRemovingQuotes(String command) {
    List<String> list = new ArrayList<>();
    Matcher m = Pattern.compile("(\\\\\"\\\\\"|[^\\\\\"]\\S*|\\\\\".+?\\\\\")\\s*").matcher(command);
    while (m.find()) {
        list.add(m.group(1).replaceAll("\\\\\"", "\""));
    }
    return list.toArray(new String[list.size()]);
}
 

private void replaceParameterBindings(List<AbstractAggregateQueryProvider.ParameterBinding> bindings, Matcher valueMatcher, String prefix,
                                      boolean quoted) {
  while (valueMatcher.find()) {

    int paramIndex = Integer.parseInt(valueMatcher.group(PARAMETER_INDEX_GROUP));

    bindings.add(new AbstractAggregateQueryProvider.ParameterBinding(paramIndex, quoted, prefix));
  }
}
 

/**
 * Returns the default JTReg arguments for a jvm running a test without
 * options that matches regular expressions in {@code filters}.
 * This is the combination of JTReg arguments test.vm.opts and test.java.opts.
 * @param filters Regular expressions used to filter out options.
 * @return An array of options, or an empty array if no options.
 */
public static String[] getFilteredTestJavaOpts(String... filters) {
    String options[] = getTestJavaOpts();

    if (filters.length == 0) {
        return options;
    }

    List<String> filteredOptions = new ArrayList<String>(options.length);
    Pattern patterns[] = new Pattern[filters.length];
    for (int i = 0; i < filters.length; i++) {
        patterns[i] = Pattern.compile(filters[i]);
    }

    for (String option : options) {
        boolean matched = false;
        for (int i = 0; i < patterns.length && !matched; i++) {
            Matcher matcher = patterns[i].matcher(option);
            matched = matcher.find();
        }
        if (!matched) {
            filteredOptions.add(option);
        }
    }

    return filteredOptions.toArray(new String[filteredOptions.size()]);
}
 

private static String generateMessage(String message, Object... args) {
    int index = 0;
    Matcher matcher = REPLACE_PATTERN.matcher(message);
    StringBuffer sb = new StringBuffer();
    while (matcher.find()) {
        matcher.appendReplacement(sb, Matcher.quoteReplacement(String.valueOf(args[index++])));
    }
    matcher.appendTail(sb);
    return sb.toString();
}
 

protected boolean processLike(Object column_value, Object v) {
    if (!(v == null || v instanceof String)) {// TODO shenxun
        // 丢异常才对，但老实现丢异常会出现无法关闭cursor的问题。所以返回false.
        return false;
    }
    String colValString = "";
    if (column_value != null) {
        colValString = String.valueOf(column_value);
    }

    String tar = (String) v;
    if (tarCache == null || !tarCache.equals(tar)) {
        if (pattern != null) {
            throw new IllegalArgumentException("should not be here");
        }

        tarCache = tar;
        // trim and remove %%
        tar = TStringUtil.trim(tar);
        tar = TStringUtil.replace(tar, "\\_", "[uANDOR]");
        tar = TStringUtil.replace(tar, "\\%", "[pANDOR]");
        tar = TStringUtil.replace(tar, "%", ".*");
        tar = TStringUtil.replace(tar, "_", ".");
        tar = TStringUtil.replace(tar, "[uANDOR]", "\\_");
        tar = TStringUtil.replace(tar, "[pANDOR]", "\\%");

        // case insensitive
        tar = "(?i)" + tar;

        tar = "^" + tar;
        tar = tar + "$";

        pattern = Pattern.compile(tar);

    }
    Matcher matcher = pattern.matcher(colValString);
    return matcher.find();
}
 

public static Match extract(Matcher matcher, String matchee, IndexType type, int index) {
  matcher.reset(matchee);
  switch (type) {
    case INDEX:
    case INDEX_BACKWARDS:
      List<Match> matches = new ArrayList<Match>();
      while (matcher.find()) {
        matches.add(PatternMatchUtils.match(matcher));
      }
      int length = matches.size();
      int i = (type == INDEX_BACKWARDS) ? length - 1 - index : index;
      if (i < matches.size() && i >= 0) {
        return matches.get(i);
      }
      break;
    case CAPTURE_GROUP:
      if (matcher.matches()) {
        if (index >= 0 && index < matcher.groupCount()) {
          return PatternMatchUtils.groupMatch(matcher, index);
        }
      }
      break;
    default:
      throw new UnsupportedOperationException(type.name());
  }
  return null;
}
 

public boolean parseLine(String line){
	Matcher m=pattern.matcher(line);
	if(!m.find()) return false;
	
	//get dictionary data and fix them up
	String[] targets=m.group(2).split("/");
	for(int i=0;i<targets.length;i++){
		dict.add(m.group(1).trim().toLowerCase()
				,targets[i].trim().toLowerCase());
	}			
	return true;
}
 

/**
 * Encode a string for use in the path of a URL; uses URLEncoder.encode,
 * (which encodes a string for use in the query portion of a URL), then
 * applies some postfilters to fix things up per the RFC. Can optionally
 * handle strings which are meant to encode a path (ie include '/'es
 * which should NOT be escaped).
 *
 * @param value the value to encode
 * @param path  true if the value is intended to represent a path
 * @return the encoded value
 */
public static String urlEncode(final String value, final boolean path) {
    if (value == null) {
        return "";
    }

    try {
        String encoded = URLEncoder.encode(value, DEFAULT_ENCODING);

        Matcher matcher = ENCODED_CHARACTERS_PATTERN.matcher(encoded);
        StringBuffer buffer = new StringBuffer(encoded.length());

        while (matcher.find()) {
            String replacement = matcher.group(0);

            if ("+".equals(replacement)) {
                replacement = "%20";
            } else if ("*".equals(replacement)) {
                replacement = "%2A";
            } else if ("%7E".equals(replacement)) {
                replacement = "~";
            } else if (path && "%2F".equals(replacement)) {
                replacement = "/";
            }

            matcher.appendReplacement(buffer, replacement);
        }

        matcher.appendTail(buffer);
        return buffer.toString();

    } catch (UnsupportedEncodingException ex) {
        throw new RuntimeException(ex);
    }
}
 

/**
 * Searches for a jvm pid in the output from "jcmd -l".
 *
 * Example output from jcmd is:
 * 12498 sun.tools.jcmd.JCmd -l
 * 12254 /tmp/jdk8/tl/jdk/JTwork/classes/com/sun/tools/attach/Application.jar
 *
 * @param key A regular expression to search for.
 * @return The found pid, or -1 if Enot found.
 * @throws Exception If multiple matching jvms are found.
 */
public static int tryFindJvmPid(String key) throws Throwable {
    OutputAnalyzer output = null;
    try {
        JDKToolLauncher jcmdLauncher = JDKToolLauncher.create("jcmd");
        jcmdLauncher.addToolArg("-l");
        output = ProcessTools.executeProcess(jcmdLauncher.getCommand());
        output.shouldHaveExitValue(0);

        // Search for a line starting with numbers (pid), follwed by the key.
        Pattern pattern = Pattern.compile("([0-9]+)\\s.*(" + key + ").*\\r?\\n");
        Matcher matcher = pattern.matcher(output.getStdout());

        int pid = -1;
        if (matcher.find()) {
            pid = Integer.parseInt(matcher.group(1));
            System.out.println("findJvmPid.pid: " + pid);
            if (matcher.find()) {
                throw new Exception("Found multiple JVM pids for key: " + key);
            }
        }
        return pid;
    } catch (Throwable t) {
        System.out.println(String.format("Utils.findJvmPid(%s) failed: %s", key, t));
        throw t;
    }
}
 

private String getAlternativeType(String alternativeString) {
	String type = "";
	// Content between Braces; Braces are escaped using double \\
	Pattern patternType = Pattern.compile("\\(([^)]+)\\)$");
	Matcher matcherType = patternType.matcher(alternativeString);
	if (matcherType.find()) {
		type = matcherType.group(1);
	}
	return type;
}
 

public static List<Node> getNodesInfo(String src) throws UnsupportedEncodingException {
    List<Node> result = new ArrayList<Node>();
    if (src != null)
    {
        Pattern pattern = Pattern.compile("5:nodes(.*)", Pattern.DOTALL);
        Matcher matcher = pattern.matcher(src);
        String nodesInfoStr = null;
        if (matcher.find())
        {
            nodesInfoStr = matcher.group(1);
        }
        if (nodesInfoStr != null)
        {
            int start = nodesInfoStr.indexOf(":");
            int nodesInfoLength = Integer.parseInt(nodesInfoStr.substring(0, start));
            byte[] nodesInfo = new byte[nodesInfoLength];
            nodesInfoStr = nodesInfoStr.substring(start + 1);
            try {
                byte[] nodesInfoSrc = nodesInfoStr.getBytes("utf-8");
                for (int i = 0; i < nodesInfoLength; i++)
                {
                    nodesInfo[i] = nodesInfoSrc[i];
                }
            } catch (Exception e) {
                e.printStackTrace();
            }
            for (int i = 0; i < nodesInfoLength / SpiderConstant.NODE_INFO_LENGTH_ON_DHT; i++)
            {
                Node node;
                byte[] nodeId = new byte[20];
                String nodeIp;
                byte[] nodeIpBytes = new byte[4];
                int nodePort;
                byte[] nodePortBytes = new byte[2];
                for (int j = i * SpiderConstant.NODE_INFO_LENGTH_ON_DHT; j < (i + 1) * SpiderConstant.NODE_INFO_LENGTH_ON_DHT; j++)
                {
                    if (j % SpiderConstant.NODE_INFO_LENGTH_ON_DHT <= SpiderConstant.NODE_INFO_ID_LAST_INDEX)
                    {
                        nodeId[j % SpiderConstant.NODE_INFO_LENGTH_ON_DHT] = nodesInfo[j];
                    }
                    if (SpiderConstant.NODE_INFO_ID_LAST_INDEX < j % SpiderConstant.NODE_INFO_LENGTH_ON_DHT &&
                            j % SpiderConstant.NODE_INFO_LENGTH_ON_DHT <= SpiderConstant.NODE_INFO_IP_LAST_INDEX)
                    {
                        nodeIpBytes[j % SpiderConstant.NODE_INFO_LENGTH_ON_DHT - SpiderConstant.NODE_INFO_ID_LAST_INDEX - 1] = nodesInfo[j];
                    }
                    if (SpiderConstant.NODE_INFO_IP_LAST_INDEX < j % SpiderConstant.NODE_INFO_LENGTH_ON_DHT &&
                            j % SpiderConstant.NODE_INFO_LENGTH_ON_DHT <= SpiderConstant.NODE_INFO_PORT_LAST_INDEX)
                    {
                        nodePortBytes[j % SpiderConstant.NODE_INFO_LENGTH_ON_DHT - SpiderConstant.NODE_INFO_IP_LAST_INDEX - 1] = nodesInfo[j];
                    }
                }
                long ip_temp = Long.parseLong(bytesToHexString(nodeIpBytes), 16);
                nodeIp = long2IpAdress(ip_temp);
                nodePort = Integer.parseInt(bytesToHexString(nodePortBytes), 16);
                node = new Node(nodeId, nodeIp, nodePort);
                result.add(node);
            }
        }
    }
    return result;
}
 

/**
 * Checks that a file in the default downloaded files folder matches the given regexp.
 *
 * @param file
 *            The name of the file
 * @param encoding
 *            The file encoding
 * @param regexp
 *            The pattern to match
 * @param conditions
 *            List of 'expected' values condition and 'actual' values ({@link com.github.noraui.gherkin.GherkinStepCondition}).
 * @throws FailureException
 *             if the scenario encounters a functional error
 * @throws TechnicalException
 *             is thrown if you have a technical error (format, configuration, datas, ...) in NoraUi.
 *             Exception with {@value com.github.noraui.utils.Messages#FAIL_MESSAGE_FILE_NOT_MATCHES} message (with screenshot, no exception)
 */
@Conditioned
@Alors("Le fichier {string} encodé en {string} vérifie {string}(\\?)")
@Then("The file {string} encoded in {string} matches {string}(\\?)")
public void checkFile(String file, String encoding, String regexp, List<GherkinStepCondition> conditions) throws TechnicalException, FailureException {
    try {
        final Matcher m = Pattern.compile(regexp)
                .matcher(FileUtils.readFileToString(new File(System.getProperty(USER_DIR) + File.separator + DOWNLOADED_FILES_FOLDER + File.separator + file), encoding));
        if (!m.find()) {
            new Result.Failure<>(file, Messages.format(Messages.getMessage(Messages.FAIL_MESSAGE_FILE_NOT_MATCHES), file, regexp), false, Context.getCallBack(Callbacks.RESTART_WEB_DRIVER));
        }
    } catch (final IOException e) {
        new Result.Failure<>(file, Messages.format(Messages.getMessage(Messages.FAIL_MESSAGE_FILE_NOT_FOUND), file), false, Context.getCallBack(Callbacks.RESTART_WEB_DRIVER));
    }
}