/**
* may be called by a callback to retrieve see <a
* href="doc-files/resyntax.html#rse">submatches</a>. Retrieving submatches must be done before
* the match is changed in any way. A typical call within an {@link FaAction} looks like
*
* <pre>
* public void invoke(StringBuilder out, int start, DfaRun r)
* throws CallbackException {
* {
* TextStore ts = r.submatches(out, start);
* ...
* }</pre>
*
* Parameter <code>txt</code> is not changed in any way.
*
* @param txt must contain the full match starting at position <code>start</code>. It may contain
* more characters.
* @param start is the position where the full match starts within <code>txt</code>
* @return a <code>TextStore</code> that contains the whole match as part 0 and submatches as
* subsequent parts. The return value is private to <code>this</code> and its contents may
* only be used locally in a callback. After returning from the callback, the contents of the
* result may soon change.
*/
public TextStore submatches(StringBuilder txt, int start) {
readTs.clear();
// System.out.println("-->"+txt+"<--, `"+txt.substring(start)
// +"' "+smd.size);
readTs.appendPart(txt, start, txt.length());
smd.analyze(readTs, action);
return readTs;
}
/**
* returns a <code>TextStore</code> which contains submatches, if any, pertaining to the most
* recent match. The object returned should be treated read-only. Its contents are only valid
* until the next match operation.
*
* @throws IllegalStateException if the most recent application of <code>this</code> did not yield
* a match.
*/
public TextStore submatches() {
if (a == null || a == DfaRun.EOF) {
throw new IllegalStateException("no recent match available");
}
if (!analyzed) {
analyzed = true;
ts.clear();
ts.appendPart(out, 0, out.length());
smd.analyze(ts, a);
}
return ts;
}
// depending on the object in 'client' the strings in 'tests' should
// probably be changed!! (Needs some thought if additional Splitters
// are implemented.
public void testGeneric1() {
for (int i = 0; i < tests.length; i++) {
store.clear();
client.split(store, new StringBuffer(tests[i][0]), 0);
assertEquals(tests[i].length, store.getNumParts());
StringBuffer sb = new StringBuffer();
store.getPart(sb, 0);
assertEquals(tests[i][0], sb.toString());
for (int j = 1; j < tests[i].length; j++) {
sb.setLength(0);
store.getPart(sb, j);
assertEquals("loop with j=" + j, tests[i][j], sb.toString());
}
}
}
public void testBeforeSplit3() {
StringBuffer sb = new StringBuffer();
Exception e = null;
store.getPart(sb, 0);
assertEquals("", sb.toString());
// try {
// store.getPart(sb, 0);
// } catch( ArrayIndexOutOfBoundsException _e ){
// e = _e;
// }
// assertTrue(e instanceof ArrayIndexOutOfBoundsException);
}
/**
* shoves back characters into the input of the <code>DfaRun</code>. This method simply applies
* {@link TextStore#drain TextStore.drain()} to the input of <code>this</code>. Consequently,
* <code>start</code> may be negative to indicate a suffix of <code>ts</code> to be pushed back.
*/
public void unskip(TextStore ts, int start) {
ts.drain(in, start);
}
public void testBeforeSplit1() {
assertEquals(0, store.getNumParts());
}
public void testSubstring() {
client.split(store, new StringBuffer(testAIn), 3);
StringBuffer sb = new StringBuffer();
for (int i = 0; i < 2; i++) {
int L = testAOut[i].length();
sb.setLength(0);
store.getPart(sb, i);
assertEquals("i=" + i, testAOut[i], sb.toString());
assertEquals("i=" + i, testAOut[i].length(), store.getPartLen(i));
sb.setLength(0);
store.getPart(sb, i, 1, -1);
assertEquals("i=" + i, testAOut[i].substring(1, L - 1), sb.toString());
sb.setLength(0);
store.getPart(sb, i, -3, 0);
assertEquals(testAOut[i].substring(L - 3, L), sb.toString());
sb.setLength(0);
store.getPart(sb, i, 2, 2);
assertEquals("", sb.toString());
sb.setLength(0);
store.getPart(sb, i, 2, 3);
assertEquals(testAOut[i].substring(2, 3), sb.toString());
// test left index too small
sb.setLength(0);
store.getPart(sb, i, -100, 0);
assertEquals(testAOut[i], sb.toString());
// Exception e = null;
// try {
// store.getPart(sb, i, -100, 0);
// System.out.println("*************"+sb);
// } catch( Exception _e) {
// e = _e;
// }
// assertTrue(e instanceof StringIndexOutOfBoundsException);
// test left index much too large
sb.setLength(0);
store.getPart(sb, i, 10000, 0);
assertEquals("", sb.toString());
// e = null;
// try {
// store.getPart(sb, i, 10000, 0);
// } catch( Exception _e) {
// e = _e;
// }
// assertTrue(e instanceof StringIndexOutOfBoundsException);
// test right index too small
sb.setLength(0);
store.getPart(sb, i, 0, -10000);
assertEquals("", sb.toString());
// e = null;
// try {
// store.getPart(sb, i, 0, -10000);
// } catch( Exception _e) {
// e = _e;
// }
// assertTrue(e instanceof StringIndexOutOfBoundsException);
// test right index far too large
sb.setLength(0);
store.getPart(sb, i, 0, 10000);
assertEquals(testAOut[i], sb.toString());
// e = null;
// try {
// store.getPart(sb, i, 0, 10000);
// } catch( Exception _e) {
// e = _e;
// }
// assertTrue(e instanceof StringIndexOutOfBoundsException);
// out of range part should return empty string
sb.setLength(0);
store.getPart(sb, 299, 0, 10000);
assertEquals("", sb.toString());
// e = null;
// try {
// store.getPart(sb, 1000, 0, 1);
// } catch( Exception _e) {
// e = _e;
// }
// assertTrue(e instanceof ArrayIndexOutOfBoundsException);
// yet another one, this time in getPartLen
assertEquals(0, store.getPartLen(1000));
// e = null;
// try {
// store.getPartLen(1000);
// } catch( Exception _e) {
// e = _e;
// }
// assertTrue(e instanceof ArrayIndexOutOfBoundsException);
}
}
