import com.google.code.regexp.Matcher; //导入依赖的package包/类
/**
 * Counts valid emojis passed string
 * 
 * @param text String to count emoji characters in.
 * @return returns count of emojis
 */
public static int countEmojis(String text) {

	String htmlifiedText = htmlify(text);
	// regex to identify html entitities in htmlified text
	Matcher matcher = htmlEntityPattern.matcher(htmlifiedText);

	int counter = 0;
	while (matcher.find()) {
		String emojiCode = matcher.group();
		if (isEmoji(emojiCode)) {
			counter++;
		}
	}
	return counter;
}
 

import com.google.code.regexp.Matcher; //导入依赖的package包/类
public static String compileRegex(Route route, List<String> variables) {
    HashMap<String, String> requirements = route.getRequirements();
    Iterator<String> variablesIterator = variables.iterator();
    String patternString = quote(route.getPath());
    while (variablesIterator.hasNext()) {
        String varName = variablesIterator.next();
        String regex = "[^/]+";
        if (requirements.containsKey(varName)) {
            regex = requirements.get(varName);
        }
        patternString = patternString.replaceFirst(
                String.format("\\\\\\{%s\\\\\\}", varName),
                java.util.regex.Matcher.quoteReplacement(String.format("(?<%s>%s)", varName, regex))
        );
    }

    return patternString;
}
 

import com.google.code.regexp.Matcher; //导入依赖的package包/类
/**
 * Parses string with regex, and emits a Map corresponding to named capturing group names and their captured values.
 *
 * @param line tuple to parse
 * @throws RuntimeException
 */
public void processTuple(String line) throws RuntimeException
{
  if (pattern == null) {
    throw new RuntimeException("regex has not been set");
  }

  Matcher matcher = pattern.matcher(line);
  if (matcher.matches()) {
    Map<String, Object> outputMap = new HashMap<String, Object>();

    for (String key : pattern.groupNames()) {
      outputMap.put(key, matcher.group(key));
    }
    output.emit(outputMap);
  }
}
 

import com.google.code.regexp.Matcher; //导入依赖的package包/类
public void testMatchFiles_several_Regexp() {
    System.out.println("matchFiles_several_Regexp");

    Path file = Paths.get("src/test/resources/file.log");

    Map<String, String> regexpMap = new HashMap<>();
    Map<String, String> matchesMap = new HashMap<>();

    regexpMap.put("1", "(?<date>\\d{4}-\\d{2}-\\d{2}+)\\s");
    regexpMap.put("2", "(?<time>\\d{2}:\\d{2}:\\d{2}+)\\s");

    try {
        List<String> linesfile = Files.readAllLines(file, Charset.defaultCharset());
        for (String line : linesfile) {
            for (String regexp : regexpMap.values()) {
                Matcher m = Pattern.compile(regexp).matcher(line);
                matchesMap.putAll(m.namedGroups());
            }
        }
    } catch (IOException e) {
        e.printStackTrace();
    }

    System.out.println(matchesMap);

}
 

import com.google.code.regexp.Matcher; //导入依赖的package包/类
private void capturePathParms(Properties parms, String path, Route route) {
  Matcher m = route._url_pattern.matcher(path);
  if (! m.matches()) {
    throw H2O.fail("Routing regex error: Pattern matched once but not again for pattern: " + route._url_pattern.pattern() + " and path: " + path);
  }

  // Java doesn't allow _ in group names but we want them in field names, so remove all _ from the path params before we look up the group capture value
  for (String key : route._path_params) {
    String key_no_underscore = key.replace("_","");
    String val;
    try {
      val = m.group(key_no_underscore);
    }
    catch (IllegalArgumentException e) {
      throw H2O.fail("Missing request parameter in the URL: did not find " + key + " in the URL as expected; URL pattern: " + route._url_pattern.pattern() + " with expected parameters: " + Arrays.toString(route._path_params) + " for URL: " + path);
    }
    if (null != val)
      parms.put(key, val);
  }
}
 

import com.google.code.regexp.Matcher; //导入依赖的package包/类
public void setHexHtml(String hexHtml) {
	this.hexHtml = hexHtml;
	Matcher matcher = htmlSurrogateEntityPattern.matcher(hexHtml);
	if(matcher.find()) {
		String signifiantHtmlEntity = matcher.group("H");
		this.setHexHtmlShort(signifiantHtmlEntity);
	} else {
		this.setHexHtmlShort(hexHtml);
	}
}
 

import com.google.code.regexp.Matcher; //导入依赖的package包/类
public void setDecimalHtml(String decimalHtml) {
	
	this.decimalHtml = decimalHtml;
	Matcher matcher = htmlSurrogateEntityPattern.matcher(decimalHtml);
	if(matcher.find()) {
		String signifiantHtmlEntity = matcher.group("H");
		this.setDecimalHtmlShort(signifiantHtmlEntity);
	} else {
		this.setDecimalHtmlShort(decimalHtml);
	}
}
 

import com.google.code.regexp.Matcher; //导入依赖的package包/类
protected Map<String, String> parsePathVariables(CompiledRoute compiledRoute, Matcher matchedMatcher) {
    Map<String, String> pathVariables = null;
    if (compiledRoute.getVariables() != null) {
        pathVariables = new HashMap<>();
        for (String var : compiledRoute.getVariables()) {
            pathVariables.put(var, matchedMatcher.group(var));
        }
    }

    return pathVariables;
}
 

import com.google.code.regexp.Matcher; //导入依赖的package包/类
public static List<String> detectVariables(Route route) {
    Pattern pattern = Pattern.compile("\\{(\\w+)\\}");
    Matcher matcher = pattern.matcher(route.getPath());
    List<String> variables = new ArrayList<>();
    while (matcher.find()) {
        variables.add(matcher.group(1));
    }

    return variables;
}
 

import com.google.code.regexp.Matcher; //导入依赖的package包/类
/**
 * Aplicar regexps al mensaje, de todas las regexps enriquequecemos usando
 * la primera regexp que nos devuelva algun resultado.
 *
 * @param message
 * @return map
 */
public Map<String, String> applyRegexps(String message) {
    logger.debug("Message: " + message);


    for (Map.Entry<String, Pattern> entry : regexpMap.entrySet()) {
        logger.debug("Regexp: " + entry.getKey() + " |||| " + entry.getValue());
        Matcher m = entry.getValue().matcher(message);

        if (m.namedGroups().size() > 0) {
            logger.debug("WITH NAMED GROUPS");
            matchesMap.putAll(m.namedGroups());
            break;
        } else {
            logger.debug("WITHOUT NAMED GROUPS");
            // First match is already catched by previous namedGroups() call, so we reset it
            m.reset();
            // Useful for regexps with <key, value> pairs
            while (m.find() && m.groupCount() > 0){
                logger.debug("Group 0: " + m.group(0));
                logger.debug("Group 1: " + m.group(this.regexpKey));
                logger.debug("Group 2: " + m.group(this.regexpValue));
                matchesMap.put(m.group(this.regexpKey), m.group(this.regexpValue));
            }
        }
    }
    return matchesMap;
}
 

import com.google.code.regexp.Matcher; //导入依赖的package包/类
/**
 * Test of matchFilesRegexp(), of class RegexpData
 */
public void testMatchFiles_SINGLE_Regexp() {
    System.out.println("matchFiles_single_Regexp");

    Path file = Paths.get("src/test/resources/file.log");

    Map<String, String> regexpMap = new HashMap<>();
    Map<String, String> matchesMap = new HashMap<>();

    regexpMap.put("1", "(?<date>\\d{4}-\\d{2}-\\d{2}+)\\s"
            + "(?<time>\\d{2}:\\d{2}:\\d{2}+)\\s"
            + "(?<time-taken>\\d{1}+)\\s");

    try {
        List<String> linesfile = Files.readAllLines(file, Charset.defaultCharset());
        for (String line : linesfile) {
            for (String regexp : regexpMap.values()) {
                Matcher m = Pattern.compile(regexp).matcher(line);
                matchesMap.putAll(m.namedGroups());
            }
        }
    } catch (IOException e) {
        e.printStackTrace();
    }

    System.out.println(matchesMap);

}
 

import com.google.code.regexp.Matcher; //导入依赖的package包/类
public void testMatchFiles_SINGLE_Regexp_SEVERAL_lines() {
    System.out.println("MatchFiles_SINGLE_Regexp_SEVERAL_lines_Single_file");

    Path file = Paths.get("src/test/resources/file3.log");

    Map<String, String> regexpMap = new HashMap<>();
    Map<String, String> matchesMap = new HashMap<>();

    regexpMap.put("1", "(?<date>\\d{4}-\\d{2}-\\d{2}+)\\s"
            + "(?<time>\\d{2}:\\d{2}:\\d{2}+)\\s"
            + "(?<time-taken>\\d{1}+)\\s");

    try {
        List<String> linesfile = Files.readAllLines(file, Charset.defaultCharset());
        for (String line : linesfile) {
            for (String regexp : regexpMap.values()) {
                Matcher m = Pattern.compile(regexp).matcher(line);
                matchesMap.putAll(m.namedGroups());
            }
        }
    } catch (IOException e) {
        e.printStackTrace();
    }

    System.out.println(matchesMap);

}
 

import com.google.code.regexp.Matcher; //导入依赖的package包/类
public List<InlineDirectiveMatcher> getInlineDirectiveMatchers(String text) {
	List<InlineDirectiveMatcher> matchers = new ArrayList<InlineDirectiveMatcher>();
	for( InlineDirectiveItem directive : inlineDirectives ){
		Matcher m = directive.pattern.matcher(text);
		matchers.add(new InlineDirectiveMatcher(m, directive.directiveClass));
	}
	return matchers;
}
 

import com.google.code.regexp.Matcher; //导入依赖的package包/类
/**
 * Get emoji by unicode, short code, decimal html entity or hexadecimal html
 * entity
 * 
 * @param code unicode, short code, decimal html entity or hexadecimal html
 * @return Emoji
 */
public static Emoji getEmoji(String code) {

	Matcher m = shortCodePattern.matcher(code);
	

	// test for shortcode with colons
	if (m.find()) {
		code = m.group(1);
	}

	Emoji emoji = null;
	// If you're running java 8 you could do this:
       /*selectFirst(EmojiManager.data(),having(on(Emoji.class).getEmoji(), Matchers.equalTo(code))
                       .or(having(on(Emoji.class).getEmoji(), Matchers.equalTo(code)))
					.or(having(on(Emoji.class).getHexHtml(), Matchers.equalToIgnoringCase(code)))
					.or(having(on(Emoji.class).getDecimalHtml(), Matchers.equalToIgnoringCase(code)))
					.or(having(on(Emoji.class).getDecimalSurrogateHtml(), Matchers.equalToIgnoringCase(code)))
					.or(having(on(Emoji.class).getHexHtmlShort(), Matchers.equalToIgnoringCase(code)))
					.or(having(on(Emoji.class).getDecimalHtmlShort(), Matchers.equalToIgnoringCase(code)))
					.or(having(on(Emoji.class).getAliases(), Matchers.hasItem(code)))
					.or(having(on(Emoji.class).getEmoticons(), Matchers.hasItem(code))));*/

       // since i'm using Java 7 if not you can just do as follows:
       /*
       * I'll be excluding Aliases e.g. "smiley" and Emoticons e.g. :/ because they interfere with links such as http[":/"]/
	* Matchers.hasItem(code).matches(emo.getEmoticons())
       **/
	for (Emoji emo: EmojiManager.data()) {
		if (Matchers.equalTo(code).matches(emo.getEmoji()) ||
				Matchers.equalToIgnoringCase(code).matches(emo.getEmoji()) ||
				Matchers.equalToIgnoringCase(code).matches(emo.getHexHtml()) ||
				Matchers.equalToIgnoringCase(code).matches(emo.getDecimalHtml()) ||
				Matchers.equalToIgnoringCase(code).matches(emo.getDecimalSurrogateHtml()) ||
				Matchers.equalToIgnoringCase(code).matches(emo.getHexHtmlShort()) ||
				Matchers.equalToIgnoringCase(code).matches(emo.getDecimalHtmlShort()) ||
                   Matchers.hasItem(code).matches(emo.getAliases())) {
			emoji = emo;
			break;
		}
	}

	return emoji;
}
 

import com.google.code.regexp.Matcher; //导入依赖的package包/类
/**
 * Common method used for processing the string to replace with emojis
 * 
 * @param text
 * @param pattern
 * @return
 */
private static String processStringWithRegex(String text, Pattern pattern, int startIndex, boolean recurseEmojify) {
	//System.out.println(text);
	Matcher matcher = pattern.matcher(text);
	StringBuffer sb = new StringBuffer();
	int resetIndex = 0;
	
	if(startIndex > 0) {
		matcher.region(startIndex, text.length());
	} 
	
	while (matcher.find()) {
		
		String emojiCode = matcher.group();
		
		Emoji emoji = getEmoji(emojiCode);
		// replace matched tokens with emojis
		
		if(emoji!=null) {
			matcher.appendReplacement(sb, emoji.getEmoji());
		} else {
			if(htmlSurrogateEntityPattern2.matcher(emojiCode).matches()) {
				String highSurrogate1 = matcher.group("H1");
				String highSurrogate2 = matcher.group("H2");
				String lowSurrogate1 = matcher.group("L1");
				String lowSurrogate2 = matcher.group("L2");
				matcher.appendReplacement(sb, processStringWithRegex(highSurrogate1+highSurrogate2, shortCodeOrHtmlEntityPattern, 0, false));
				
				//basically this handles &#junk1;❤️&#junk2; scenario
				//verifies if &#junk1;❤ or &#junk1; are valid emojis via recursion
				//if not move past &#junk1; and reset the cursor to ❤
				if(sb.toString().endsWith(highSurrogate2)) {
					resetIndex = sb.length() - highSurrogate2.length();
				} else {
					resetIndex = sb.length();
				}
				sb.append(lowSurrogate1);
				sb.append(lowSurrogate2);
				break;
			} else if(htmlSurrogateEntityPattern.matcher(emojiCode).matches()) {
				//could be individual html entities assumed as surrogate pair
				String highSurrogate = matcher.group("H");
				String lowSurrogate = matcher.group("L");
				matcher.appendReplacement(sb, processStringWithRegex(highSurrogate, htmlEntityPattern, 0, true));
				resetIndex = sb.length();
				sb.append(lowSurrogate);
				break;
			} else {
				matcher.appendReplacement(sb, emojiCode);
			}
		}

	}
	matcher.appendTail(sb);
	
	//do not recurse emojify when coming here through htmlSurrogateEntityPattern2..so we get a chance to check if the tail
	//is part of a surrogate entity
	if(recurseEmojify && resetIndex > 0) {
		return emojify(sb.toString(), resetIndex);
	}
	return sb.toString();
}
 

import com.google.code.regexp.Matcher; //导入依赖的package包/类
public InlineDirectiveMatcher(Matcher matcher, Class<? extends AbstractDirective<?>> directiveClass) {
	this.matcher = matcher;
	this.directiveClass = directiveClass;
}
 

import com.google.code.regexp.Matcher; //导入依赖的package包/类
/**
 * Compile the {@code Grok} pattern to named regex pattern.
 *
 * @param pattern : Grok pattern (ex: %{IP})
 * @throws Exception
 */
public void compile(String pattern) throws Exception {

  if (StringUtils.isBlank(pattern)) {
    throw new Exception("{pattern} should not be empty or null");
  }

  namedRegex = pattern;
  originalGrokPattern = pattern;
  int index = 0;
  /** flag for infinite recurtion */
  int iterationLeft = 1000;
  Boolean continueIteration = true;

  // Replace %{foo} with the regex (mostly groupname regex)
  // and then compile the regex
  while (continueIteration) {
    continueIteration = false;
    if (iterationLeft <= 0) {
      throw new Exception("Deep recursion pattern compilation of " + originalGrokPattern);
    }
    iterationLeft--;

    Matcher m = GrokUtils.GROK_PATTERN.matcher(namedRegex);
    // Match %{Foo:bar} -> pattern name and subname
    // Match %{Foo=regex} -> add new regex definition
    if (m.find()) {
      continueIteration = true;
      Map<String, String> group = m.namedGroups();
      if (group.get("definition") != null) {
        try {
          addPattern(group.get("pattern"), group.get("definition"));
          group.put("name", group.get("name") + "=" + group.get("definition"));
        } catch (Exception e) {
          // Log the exeception
        }
      }
      namedRegexCollection.put("name" + index,
          (group.get("subname") != null ? group.get("subname") : group.get("name")));
      namedRegex =
          StringUtils.replace(namedRegex, "%{" + group.get("name") + "}", "(?<name" + index + ">"
              + grokPatternDefinition.get(group.get("pattern")) + ")");
      // System.out.println(_expanded_pattern);
      index++;
    }
  }

  if (namedRegex.isEmpty()) {
    throw new Exception("Pattern not fount");
  }
  // Compile the regex
  compiledNamedRegex = Pattern.compile(namedRegex);
}
 

import com.google.code.regexp.Matcher; //导入依赖的package包/类
public Matcher getMatch() {
  return match;
}
 

import com.google.code.regexp.Matcher; //导入依赖的package包/类
public void setMatch(Matcher match) {
  this.match = match;
}
 

import com.google.code.regexp.Matcher; //导入依赖的package包/类
/**
 * Extracts named groups from the raw data
 *
 * @param rawData
 * @return A map of group names mapped to their extracted values or null if there are no matches
 */
public Map<String, String> extractNamedGroups(final CharSequence rawData) {

  Matcher matcher = compiledPattern.matcher(rawData);

  if (matcher.find()) {

    MatchResult r = matcher.toMatchResult();

    if (r != null && r.namedGroups() != null) {
      return r.namedGroups();
    }
  }

  return null;
}