private void writeLineKeepWhiteSpace(final int end, final int depth) throws IOException {
// Writes the first line from the source text starting from index, ending at the specified end
// position.
// The line break characters are not written.
// Sets index to the position following the first line break character(s), or end if the text
// contains no line breaks. index is guaranteed <= end.
// Any tags encountered are written using the writeTag method, whose output may include line
// breaks.
// assert index < end
updateNextTag();
while (true) {
while (nextTag != null && index == nextTag.begin) {
writeTag(nextTag, depth, end);
if (index == end) return;
}
final char ch = sourceText.charAt(index);
if (ch == '\r') {
final int nextindex = index + 1;
if (nextindex < end && sourceText.charAt(nextindex) == '\n') {
index += 2;
return;
}
}
if (ch == '\n') {
index++;
return;
}
writer.write(ch);
if (++index == end) return;
}
}
private void writeSpecifiedTextInline(final CharSequence text, int depth) throws IOException {
final int textLength = text.length();
int i = writeSpecifiedLine(text, 0);
if (i < textLength) {
final int subsequentLineDepth = depth + 1;
do {
while (Segment.isWhiteSpace(text.charAt(i)))
if (++i >= textLength) return; // trim whitespace.
writeEssentialNewLine();
writeIndent(subsequentLineDepth);
i = writeSpecifiedLine(text, i);
} while (i < textLength);
}
}
private void writeTextCollapseWhiteSpace(final int end, final int depth) throws IOException {
// sets index to end
// assert index < end
boolean lastWasWhiteSpace = false;
updateNextTag();
while (index < end) {
while (nextTag != null && index == nextTag.begin) {
if (lastWasWhiteSpace) {
writer.write(' ');
lastWasWhiteSpace = false;
}
writeTag(nextTag, depth, end);
if (index == end) return;
}
final char ch = sourceText.charAt(index++);
if (Segment.isWhiteSpace(ch)) {
lastWasWhiteSpace = true;
} else {
if (lastWasWhiteSpace) {
writer.write(' ');
lastWasWhiteSpace = false;
}
writer.write(ch);
}
}
if (lastWasWhiteSpace) writer.write(' ');
}
/**
* @param queryString a query string of the form n1=v1&n2=v2&... to decode. May be null.
* @param acceptAmp -> "&" if true, "&" if false
* @return a Map of String[] indexed by name, an empty Map if the query string was null
*/
public static Map<String, String[]> decodeQueryString(
final CharSequence queryString, final boolean acceptAmp) {
final Map<String, String[]> result = new TreeMap<String, String[]>();
if (queryString != null) {
final Matcher matcher =
acceptAmp ? PATTERN_AMP.matcher(queryString) : PATTERN_NO_AMP.matcher(queryString);
int matcherEnd = 0;
while (matcher.find()) {
matcherEnd = matcher.end();
try {
// Group 0 is the whole match, e.g. a=b, while group 1 is the first group
// denoted ( with parens ) in the expression. Hence we start with group 1.
final String name =
URLDecoder.decode(matcher.group(1), NetUtils.STANDARD_PARAMETER_ENCODING);
final String value =
URLDecoder.decode(matcher.group(2), NetUtils.STANDARD_PARAMETER_ENCODING);
StringUtils.addValueToStringArrayMap(result, name, value);
} catch (UnsupportedEncodingException e) {
// Should not happen as we are using a required encoding
throw new OXFException(e);
}
}
if (queryString.length() != matcherEnd) {
// There was garbage at the end of the query.
throw new OXFException("Malformed URL: " + queryString);
}
}
return result;
}
private int writeSpecifiedLine(final CharSequence text, int i) throws IOException {
// Writes the first line from the specified text starting from the specified position.
// The line break characters are not written.
// Returns the position following the first line break character(s), or text.length() if the
// text contains no line breaks.
final int textLength = text.length();
while (true) {
final char ch = text.charAt(i);
if (ch == '\r') {
final int nexti = i + 1;
if (nexti < textLength && text.charAt(nexti) == '\n') return i + 2;
}
if (ch == '\n') return i + 1;
writer.write(ch);
if (++i >= textLength) return i;
}
}
private void writeContentPreformatted(final int end, final int depth) throws IOException {
// sets index to end
// assert index < end
updateNextTag();
do {
while (nextTag != null && index == nextTag.begin) {
writeTag(nextTag, depth, end);
if (index == end) return;
}
writer.write(sourceText.charAt(index));
} while (++index < end);
}
private void writeText(final int end, int depth) throws IOException {
// sets index to end
if (index == end) return;
while (Segment.isWhiteSpace(sourceText.charAt(index)))
if (++index == end) return; // trim whitespace.
writeIndent(depth);
if (collapseWhiteSpace) {
writeTextCollapseWhiteSpace(end, depth);
} else {
writeTextInline(end, depth, false);
}
writeFormattingNewLine();
}
private int getStartOfLinePos(final int end, final boolean atStartOfLine) {
// returns the starting position of the next complete line containing text, or -1 if texts
// starts on the current line (hence not a complete line).
// sets index to the start of the text following the returned position, or end, whichever
// comes first.
int startOfLinePos = atStartOfLine ? index : -1;
while (true) {
final char ch = sourceText.charAt(index);
if (ch == '\n' || ch == '\r') {
startOfLinePos = index + 1;
} else if (!(ch == ' ' || ch == '\t')) break;
if (++index == end) break;
}
return startOfLinePos;
}
private boolean writeTextRemoveIndentation(final int end) throws IOException {
// assert index < end
// sets index to end
writeLineKeepWhiteSpace(end, 0);
if (index == end) return true;
while (index != end) {
// Skip over the original indent:
while (true) {
final char ch = sourceText.charAt(index);
if (!(ch == ' ' || ch == '\t')) break;
if (++index == end) return false;
}
writeEssentialNewLine();
// Write the rest of the line including any indent greater than the first line's indent:
writeLineKeepWhiteSpace(end, 0);
}
return false;
}
private boolean writeTextInline(
final int end, int depth, final boolean increaseIndentAfterFirstLineBreak)
throws IOException {
// returns true if all text was on one line, otherwise false
// sets index to end
// assert index < end
writeLineKeepWhiteSpace(end, depth);
if (index == end) return true;
final int subsequentLineDepth = increaseIndentAfterFirstLineBreak ? depth + 1 : depth;
do {
while (Segment.isWhiteSpace(sourceText.charAt(index)))
if (++index == end) return false; // trim whitespace.
writeEssentialNewLine(); // essential because we might be inside a tag attribute value. If
// new lines in normal text aren't required this method wouldn't
// have been called.
writeIndent(subsequentLineDepth);
writeLineKeepWhiteSpace(end, subsequentLineDepth);
} while (index < end);
return false;
}
private void writeTextPreserveIndentation(
final int end, final int depth, final int originalIndentLength) throws IOException {
// assert index < end
// sets index to end
writeIndent(depth);
writeLineKeepWhiteSpace(end, depth);
while (index != end) {
// Skip over the original indent:
for (int x = 0; x < originalIndentLength; x++) {
final char ch = sourceText.charAt(index);
if (!(ch == ' ' || ch == '\t')) break;
if (++index == end) return;
}
writeEssentialNewLine();
// Insert our indent:
writeIndent(depth);
// Write the rest of the line including any indent greater than the first line's indent:
writeLineKeepWhiteSpace(end, depth);
}
}
/** Test for [JACKSON-483], allow handling of CharSequence */
public void testCharSequence() throws IOException {
CharSequence cs = MAPPER.readValue("\"abc\"", CharSequence.class);
assertEquals(String.class, cs.getClass());
assertEquals("abc", cs.toString());
}
