ArrayList<PhraseMatcher> babbleTmp = new ArrayList<>();
ArrayList<AXKeyValuePair> kvs = new ArrayList<>(Arrays.asList(
new AXKeyValuePair("what is {0}", "{0} is {1}"),
new AXKeyValuePair("explain {0}", "{0} is {1}")
));
babbleTmp.add(new PhraseMatcher("(.*) is (.*)", kvs));import java.util.ArrayList;
import java.util.Collections;
public class ElizaDeducerInitializer {
private ArrayList<PhraseMatcher> babbleTmp;
public ElizaDeducerInitializer() {
babbleTmp = new ArrayList<>();
initializeBabble2();
}
private void initializeBabble2() {
addPhraseMatcher(
new PhraseMatcher("(.*) is (.*)", new ArrayList<>(Arrays.asList(
new AXKeyValuePair("what is {0}", "{0} is {1}"),
new AXKeyValuePair("explain {0}", "{0} is {1}")
)))
);
addPhraseMatcher(
new PhraseMatcher("if (.*) or (.*) than (.*)", new ArrayList<>(Arrays.asList(
new AXKeyValuePair("{0}", "{2}"),
new AXKeyValuePair("{1}", "{2}")
)))
);
addPhraseMatcher(
new PhraseMatcher("if (.*) and (.*) than (.*)", new ArrayList<>(Collections.singletonList(
new AXKeyValuePair("{0}", "{1}")
)))
);
addPhraseMatcher(
new PhraseMatcher("(.*) because (.*)", new ArrayList<>(Collections.singletonList(
new AXKeyValuePair("{1}", "i guess {0}")
)))
);
babble2 = Collections.unmodifiableList(babbleTmp);
}
private void addPhraseMatcher(PhraseMatcher matcher) {
babbleTmp.add(matcher);
}
}import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
public class ElizaDeducerInitializer {
private ArrayList<PhraseMatcher> babbleTmp;
public ElizaDeducerInitializer() {
babbleTmp = new ArrayList<>();
initializeBabble2();
}
private void initializeBabble2() {
addPhraseMatcher(
"(.*) is (.*)",
"what is {0}", "{0} is {1}",
"explain {0}", "{0} is {1}"
);
addPhraseMatcher(
"if (.*) or (.*) than (.*)",
"{0}", "{2}",
"{1}", "{2}"
);
addPhraseMatcher(
"if (.*) and (.*) than (.*)",
"{0}", "{1}"
);
addPhraseMatcher(
"(.*) because (.*)",
"{1}", "i guess {0}"
);
babble2 = Collections.unmodifiableList(babbleTmp);
}
private void addPhraseMatcher(String pattern, String... kvPairs) {
ArrayList<AXKeyValuePair> kvs = new ArrayList<>();
for (int i = 0; i < kvPairs.length; i += 2) {
kvs.add(new AXKeyValuePair(kvPairs[i], kvPairs[i + 1]));
}
babbleTmp.add(new PhraseMatcher(pattern, kvs));
}
}import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
public class ElizaDeducerInitializer extends ElizaDeducer {
public ElizaDeducerInitializer() {
initializeBabble2();
babble2 = Collections.unmodifiableList(babble2);
}
private void initializeBabble2() {
addPhraseMatcher(
"(.*) is (.*)",
"what is {0}", "{0} is {1}",
"explain {0}", "{0} is {1}"
);
addPhraseMatcher(
"if (.*) or (.*) than (.*)",
"{0}", "{2}",
"{1}", "{2}"
);
addPhraseMatcher(
"if (.*) and (.*) than (.*)",
"{0}", "{1}"
);
addPhraseMatcher(
"(.*) because (.*)",
"{1}", "i guess {0}"
);
}
private void addPhraseMatcher(String pattern, String... kvPairs) {
ArrayList<AXKeyValuePair> kvs = new ArrayList<>();
for (int i = 0; i < kvPairs.length; i += 2) {
kvs.add(new AXKeyValuePair(kvPairs[i], kvPairs[i + 1]));
}
babble2.add(new PhraseMatcher(pattern, kvs));
}
}import java.util.ArrayList;
import java.util.Arrays;
public class ElizaDeducerInitializer extends ElizaDeducer {
public ElizaDeducerInitializer() {
initializeBabble2();
}
private void initializeBabble2() {
addPhraseMatcher(
"(.*) is (.*)",
"what is {0}", "{0} is {1}",
"explain {0}", "{0} is {1}"
);
addPhraseMatcher(
"if (.*) or (.*) than (.*)",
"{0}", "{2}",
"{1}", "{2}"
);
addPhraseMatcher(
"if (.*) and (.*) than (.*)",
"{0}", "{1}"
);
addPhraseMatcher(
"(.*) because (.*)",
"{1}", "i guess {0}"
);
}
private void addPhraseMatcher(String pattern, String... kvPairs) {
ArrayList<AXKeyValuePair> kvs = new ArrayList<>();
for (int i = 0; i < kvPairs.length; i += 2) {
kvs.add(new AXKeyValuePair(kvPairs[i], kvPairs[i + 1]));
}
babble2.add(new PhraseMatcher(pattern, kvs));
}
}import java.util.ArrayList;
import java.util.List;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
public class ElizaDeducer {
public List<PhraseMatcher> babble2;
public ElizaDeducer() {
// init values in subclass
// see ElizaDeducerInitializer for example
// example input-output based on ElizaDeducerInitializer values:
// elizaDeducer.respond("a is a b")
// [what is a a;a is a b, explain a;a is a b]
}
public ArrayList<AXKeyValuePair> respond(String msg) {
for (PhraseMatcher pm : babble2) {
if (pm.matches(msg)) {
return pm.respond(msg);
}
}
return new ArrayList<AXKeyValuePair>();
}
public void addPhraseMatcher(String pattern, String... kvPairs) {
ArrayList<AXKeyValuePair> kvs = new ArrayList<>();
for (int i = 0; i < kvPairs.length; i += 2) {
kvs.add(new AXKeyValuePair(kvPairs[i], kvPairs[i + 1]));
}
babble2.add(new PhraseMatcher(pattern, kvs));
}
public class PhraseMatcher {
public final Pattern matcher;
public final List<AXKeyValuePair> responses;
public PhraseMatcher(String matcher, List<AXKeyValuePair> responses) {
this.matcher = Pattern.compile(matcher);
this.responses = responses;
}
public boolean matches(String str) {
Matcher m = matcher.matcher(str);
return m.matches();
}
public ArrayList<AXKeyValuePair> respond(String str) {
Matcher m = matcher.matcher(str);
ArrayList<AXKeyValuePair> result = new ArrayList<>();
if (m.find()) {
int tmp = m.groupCount();
for (AXKeyValuePair kv : this.responses) {
AXKeyValuePair tempKV = new AXKeyValuePair(kv.getKey(), kv.getValue());
for (int i = 0; i < tmp; i++) {
String s = m.group(i + 1);
tempKV.setKey(tempKV.getKey().replace("{" + i + "}", s).toLowerCase());
tempKV.setValue(tempKV.getValue().replace("{" + i + "}", s).toLowerCase());
}
result.add(tempKV);
}
}
return result;
}
}
}import java.util.Arrays;
public class ElizaDeducerInitializer extends ElizaDeducer {
public ElizaDeducerInitializer() {
babble2 = new ArrayList<>();
initializeBabble2();
}
private void initializeBabble2() {
addPhraseMatcher(
"(.*) is (.*)",
"what is {0}", "{0} is {1}",
"explain {0}", "{0} is {1}"
);
addPhraseMatcher(
"if (.*) or (.*) than (.*)",
"{0}", "{2}",
"{1}", "{2}"
);
addPhraseMatcher(
"if (.*) and (.*) than (.*)",
"{0}", "{1}"
);
addPhraseMatcher(
"(.*) because (.*)",
"{1}", "i guess {0}"
);
}
}import java.util.*;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
public class ElizaDeducer {
public List<PhraseMatcher> babble2;
private Map<String, List<PhraseMatcher>> patternIndex;
private Map<String, List<AXKeyValuePair>> responseCache;
public ElizaDeducer() {
babble2 = new ArrayList<>();
patternIndex = new HashMap<>();
responseCache = new HashMap<>();
}
public ArrayList<AXKeyValuePair> respond(String msg) {
// Check cache first
if (responseCache.containsKey(msg)) {
return new ArrayList<>(responseCache.get(msg));
}
// Search for matching patterns
List<PhraseMatcher> potentialMatchers = getPotentialMatchers(msg);
for (PhraseMatcher pm : potentialMatchers) {
if (pm.matches(msg)) {
ArrayList<AXKeyValuePair> response = pm.respond(msg);
responseCache.put(msg, response);
return response;
}
}
return new ArrayList<>();
}
private List<PhraseMatcher> getPotentialMatchers(String msg) {
List<PhraseMatcher> potentialMatchers = new ArrayList<>();
for (String key : patternIndex.keySet()) {
if (msg.contains(key)) {
potentialMatchers.addAll(patternIndex.get(key));
}
}
return potentialMatchers;
}
public void addPhraseMatcher(String pattern, String... kvPairs) {
ArrayList<AXKeyValuePair> kvs = new ArrayList<>();
for (int i = 0; i < kvPairs.length; i += 2) {
kvs.add(new AXKeyValuePair(kvPairs[i], kvPairs[i + 1]));
}
PhraseMatcher matcher = new PhraseMatcher(pattern, kvs);
babble2.add(matcher);
indexPattern(pattern, matcher);
}
private void indexPattern(String pattern, PhraseMatcher matcher) {
for (String word : pattern.split("\\s+")) {
patternIndex.computeIfAbsent(word, k -> new ArrayList<>()).add(matcher);
}
}
public class PhraseMatcher {
public final Pattern matcher;
public final List<AXKeyValuePair> responses;
public PhraseMatcher(String matcher, List<AXKeyValuePair> responses) {
this.matcher = Pattern.compile(matcher);
this.responses = responses;
}
public boolean matches(String str) {
Matcher m = matcher.matcher(str);
return m.matches();
}
public ArrayList<AXKeyValuePair> respond(String str) {
Matcher m = matcher.matcher(str);
ArrayList<AXKeyValuePair> result = new ArrayList<>();
if (m.find()) {
int tmp = m.groupCount();
for (AXKeyValuePair kv : this.responses) {
AXKeyValuePair tempKV = new AXKeyValuePair(kv.getKey(), kv.getValue());
for (int i = 0; i < tmp; i++) {
String s = m.group(i + 1);
tempKV.setKey(tempKV.getKey().replace("{" + i + "}", s).toLowerCase());
tempKV.setValue(tempKV.getValue().replace("{" + i + "}", s).toLowerCase());
}
result.add(tempKV);
}
}
return result;
}
}
}