1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
|
package bjc.utils.ioutils;
import bjc.utils.functypes.ID;
import java.util.function.UnaryOperator;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
/**
* Editor methods for strings based off the command language for the Sam editor.
*
* @author EVE
*
*/
public class RegexStringEditor {
/**
* Replace every occurrence of the pattern with the result of applying
* the action to the string matched by the pattern.
*
* @param input
* The input string to process.
*
* @param patt
* The pattern to match the string against.
*
* @param action
* The action to transform matches with.
*
* @return The string, with matches replaced with the action.
*/
public static String onOccurances(String input, Pattern patt, UnaryOperator<String> action) {
return occurances(input, patt, ID.id(), action);
}
/**
* Replace every occurrence between the patterns with the result of
* applying the action to the strings between the patterns.
*
* @param input
* The input string to process.
*
* @param patt
* The pattern to match the string against.
*
* @param action
* The action to transform matches with.
*
* @return The string, with strings between the matches replaced with
* the action.
*/
public static String betweenOccurances(String input, Pattern patt, UnaryOperator<String> action) {
return occurances(input, patt, action, ID.id());
}
/**
* Execute actions between and on matches of a regular expression.
*
* @param input
* The input string.
*
* @param patt
* The pattern to match against the string.
*
* @param betweenAction
* The function to execute between matches of the string.
*
* @param onAction
* The function to execute on matches of the string.
*
* @return The string, with both actions applied.
*/
public static String occurances(String input, Pattern patt, UnaryOperator<String> betweenAction,
UnaryOperator<String> onAction) {
Matcher matcher = patt.matcher(input);
StringBuffer res = new StringBuffer();
StringBuffer work = new StringBuffer();
while(matcher.find()) {
String match = matcher.group();
matcher.appendReplacement(work, "");
res.append(betweenAction.apply(matcher.toString()));
res.append(onAction.apply(match));
work = new StringBuffer();
}
matcher.appendTail(work);
res.append(betweenAction.apply(work.toString()));
return res.toString();
}
/**
* Apply an operation to a string if it matches a regular expression.
*
* @param input
* The input string.
*
* @param patt
* The pattern to match against it.
*
* @param action
* The action to execute if it matches.
*
* @return The string, modified by the action if the pattern matched.
*/
public static String ifMatches(String input, Pattern patt, UnaryOperator<String> action) {
Matcher matcher = patt.matcher(input);
if(matcher.matches()) {
return action.apply(input);
} else {
return input;
}
}
/**
* Apply an operation to a string if it matches a regular expression.
*
* @param input
* The input string.
*
* @param patt
* The pattern to match against it.
*
* @param action
* The action to execute if it doesn't match.
*
* @return The string, modified by the action if the pattern didn't
* match.
*/
public static String ifNotMatches(String input, Pattern patt, UnaryOperator<String> action) {
Matcher matcher = patt.matcher(input);
if(matcher.matches()) {
return input;
} else {
return action.apply(input);
}
}
}
|
