package com.google.code.regexp;
import java.util.ArrayList;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
import java.util.regex.MatchResult;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
public class NamedMatcher implements NamedMatchResult {
private Matcher matcher;
private NamedPattern parentPattern;
NamedMatcher() {
}
NamedMatcher(NamedPattern parentPattern, MatchResult matcher) {
this.parentPattern = parentPattern;
this.matcher = (Matcher) matcher;
}
NamedMatcher(NamedPattern parentPattern, CharSequence input) {
this.parentPattern = parentPattern;
this.matcher = parentPattern.pattern().matcher(input);
}
public Pattern standardPattern() {
return matcher.pattern();
}
public NamedPattern namedPattern() {
return parentPattern;
}
public NamedMatcher usePattern(NamedPattern newPattern) {
this.parentPattern = newPattern;
matcher.usePattern(newPattern.pattern());
return this;
}
public NamedMatcher reset() {
matcher.reset();
return this;
}
public NamedMatcher reset(CharSequence input) {
matcher.reset(input);
return this;
}
public boolean matches() {
return matcher.matches();
}
public NamedMatchResult toMatchResult() {
return new NamedMatcher(this.parentPattern, matcher.toMatchResult());
}
public boolean find() {
return matcher.find();
}
public boolean find(int start) {
return matcher.find(start);
}
public boolean lookingAt() {
return matcher.lookingAt();
}
public NamedMatcher appendReplacement(StringBuffer sb, String replacement) {
matcher.appendReplacement(sb, replacement);
return this;
}
public StringBuffer appendTail(StringBuffer sb) {
return matcher.appendTail(sb);
}
public String group() {
return matcher.group();
}
public String group(int group) {
return matcher.group(group);
}
public int groupCount() {
return matcher.groupCount();
}
public List<String> orderedGroups() {
ArrayList<String> groups = new ArrayList<String>();
for (int i = 1; i <= groupCount(); i++) {
groups.add(group(i));
}
return groups;
}
public String group(String groupName) {
return group(groupIndex(groupName));
}
public Map<String, String> namedGroups() {
Map<String, String> result = new LinkedHashMap<String, String>();
for (int i = 1; i <= groupCount(); i++) {
String groupName = parentPattern.groupNames().get(i-1);
String groupValue = matcher.group(i);
result.put(groupName, groupValue);
}
return result;
}
private int groupIndex(String groupName) {
return parentPattern.groupNames().indexOf(groupName) + 1;
}
public int start() {
return matcher.start();
}
public int start(int group) {
return matcher.start(group);
}
public int start(String groupName) {
return start(groupIndex(groupName));
}
public int end() {
return matcher.end();
}
public int end(int group) {
return matcher.end(group);
}
public int end(String groupName) {
return end(groupIndex(groupName));
}
public NamedMatcher region(int start, int end) {
matcher.region(start, end);
return this;
}
public int regionEnd() {
return matcher.regionEnd();
}
public int regionStart() {
return matcher.regionStart();
}
public boolean hitEnd() {
return matcher.hitEnd();
}
public boolean requireEnd() {
return matcher.requireEnd();
}
public boolean hasAnchoringBounds() {
return matcher.hasAnchoringBounds();
}
public boolean hasTransparentBounds() {
return matcher.hasTransparentBounds();
}
public String replaceAll(String replacement) {
return matcher.replaceAll(replacement);
}
public String replaceFirst(String replacement) {
return matcher.replaceFirst(replacement);
}
public NamedMatcher useAnchoringBounds(boolean b) {
matcher.useAnchoringBounds(b);
return this;
}
public NamedMatcher useTransparentBounds(boolean b) {
matcher.useTransparentBounds(b);
return this;
}
public boolean equals(Object obj) {
return matcher.equals(obj);
}
public int hashCode() {
return matcher.hashCode();
}
public String toString() {
return matcher.toString();
}
}