protected Reader makeReader(String pInput) { // Split String[] input = StringUtil.toStringArray(pInput, " "); // Reappend spaces... for (int i = 0; i < input.length; i++) { if (i != 0) { input[i] = " " + input[i]; } } return new StringArrayReader(input); }
public void reset() throws IOException { synchronized (finalLock) { ensureOpen(); if (currentSting != markedString) { currentSting = markedString - 1; nextReader(); current.skip(mark); } else { current.reset(); } next = mark; } }
public int read() throws IOException { synchronized (finalLock) { int read = current.read(); if (read < 0 && currentSting < strings.length) { nextReader(); return read(); // In case of empty strings } next++; return read; } }
public long skip(long pChars) throws IOException { synchronized (finalLock) { long skipped = current.skip(pChars); if (skipped == 0 && currentSting < strings.length) { nextReader(); return skip(pChars); } next += skipped; return skipped; } }
public void mark(int pReadLimit) throws IOException { if (pReadLimit < 0){ throw new IllegalArgumentException("Read limit < 0"); } synchronized (finalLock) { ensureOpen(); mark = next; markedString = currentSting; current.mark(pReadLimit); } }
/** * Create a new string array reader. * * @param pStrings {@code String}s providing the character stream. */ public StringArrayReader(final String[] pStrings) { super(""); Validate.notNull(pStrings, "strings"); finalLock = lock = pStrings; // NOTE: It's ok to sync on pStrings, as the // reference can't change, only it's elements strings = pStrings.clone(); // Defensive copy for content nextReader(); }
public long skip(long pChars) throws IOException { synchronized (finalLock) { long skipped = current.skip(pChars); if (skipped == 0 && currentSting < strings.length) { nextReader(); return skip(pChars); } next += skipped; return skipped; } }
public void mark(int pReadLimit) throws IOException { if (pReadLimit < 0){ throw new IllegalArgumentException("Read limit < 0"); } synchronized (finalLock) { ensureOpen(); mark = next; markedString = currentSting; current.mark(pReadLimit); } }
/** * Create a new string array reader. * * @param pStrings {@code String}s providing the character stream. */ public StringArrayReader(final String[] pStrings) { super(""); if (pStrings == null) { throw new NullPointerException("strings == null"); } mLock = lock = pStrings; // NOTE: It's ok to sync on pStrings, as the // reference can't change, only it's elements mStrings = pStrings.clone(); // Defensive copy for content nextReader(); }
public int read(char pBuffer[], int pOffset, int pLength) throws IOException { synchronized (finalLock) { int read = current.read(pBuffer, pOffset, pLength); if (read < 0 && currentSting < strings.length) { nextReader(); return read(pBuffer, pOffset, pLength); // In case of empty strings } next += read; return read; } }
public long skip(long pChars) throws IOException { synchronized (mLock) { long skipped = mCurrent.skip(pChars); if (skipped == 0 && mCurrentSting < mStrings.length) { nextReader(); return skip(pChars); } mNext += skipped; return skipped; } }
@Test public void testEmptyStringConstructor() throws IOException { Reader reader = new StringArrayReader(new String[] {""}); assertEquals(-1, reader.read()); } }
public void reset() throws IOException { synchronized (finalLock) { ensureOpen(); if (currentSting != markedString) { currentSting = markedString - 1; nextReader(); current.skip(mark); } else { current.reset(); } next = mark; } }
public void mark(int pReadLimit) throws IOException { if (pReadLimit < 0){ throw new IllegalArgumentException("Read limit < 0"); } synchronized (mLock) { ensureOpen(); mMark = mNext; mMarkedString = mCurrentSting; mCurrent.mark(pReadLimit); } }
/** * Create a new string array reader. * * @param pStrings {@code String}s providing the character stream. */ public StringArrayReader(final String[] pStrings) { super(""); Validate.notNull(pStrings, "strings"); finalLock = lock = pStrings; // NOTE: It's ok to sync on pStrings, as the // reference can't change, only it's elements strings = pStrings.clone(); // Defensive copy for content nextReader(); }
public int read() throws IOException { synchronized (finalLock) { int read = current.read(); if (read < 0 && currentSting < strings.length) { nextReader(); return read(); // In case of empty strings } next++; return read; } }
@Test public void testEmptyArrayConstructor() throws IOException { Reader reader = new StringArrayReader(new String[0]); assertEquals(-1, reader.read()); }
public void reset() throws IOException { synchronized (mLock) { ensureOpen(); if (mCurrentSting != mMarkedString) { mCurrentSting = mMarkedString - 1; nextReader(); mCurrent.skip(mMark); } else { mCurrent.reset(); } mNext = mMark; } }
public int read(char pBuffer[], int pOffset, int pLength) throws IOException { synchronized (finalLock) { int read = current.read(pBuffer, pOffset, pLength); if (read < 0 && currentSting < strings.length) { nextReader(); return read(pBuffer, pOffset, pLength); // In case of empty strings } next += read; return read; } }
@Test public void testNullConstructor() { try { new StringArrayReader(null); fail("Should not allow null argument"); } catch (RuntimeException e) { assertNotNull(e.getMessage()); } }