Appends a char array to the string builder.
Appending null will call {@link #appendNull()}.

@param chars  the char array to append
@return this, to enable chaining
432503
public StrBuilder append(final char[] chars) {
        if (chars == null) {
            return appendNull();
        }
        final int strLen = chars.length;
        if (strLen > 0) {
            final int len = length();
            ensureCapacity(len + strLen);
            System.arraycopy(chars, 0, buffer, len, strLen);
            size += strLen;
        }
        return this;
    }
1338085
public void append(final CharBuffer cb) {
        if (cb == null) {
            return;
        }
        provideCapacity(length + cb.length);
        System.arraycopy(cb.c, 0, c, length, cb.length);
        length += cb.length;
    }
1200921
@SafeVarargs
    public final WordBuilder<I> append(I... symbols) {
        if (symbols.length == 0) {
            return this;
        }
        ensureAdditionalCapacity(symbols.length);
        System.arraycopy(symbols, 0, array, length, symbols.length);
        length += symbols.length;
        return this;
    }
1189541
@Override
    public void characters(char ch[], int start, int length) {
	content.append(new String(ch, start, length));
    }
1119158
public void append(final char ch) {
        final int newlen = this.len + 1;
        if (newlen > this.array.length) {
            expand(newlen);
        }
        this.array[this.len] = ch;
        this.len = newlen;
    }
538766
public ISynchronizationPoint<IOException> write(char[] chars, int offset, int length) {
		ISynchronizationPoint<IOException> last = lastWrite;
		if (length == 0) return last;
		if (last.isUnblocked()) {
			lastWrite = stream.writeAsync(chars, offset, length);
			return lastWrite;
		}
		SynchronizationPoint<IOException> ours = new SynchronizationPoint<>();
		lastWrite = ours;
		last.listenInline(() -> { stream.writeAsync(chars, offset, length).listenInline(ours); }, ours);
		return ours;
	}
914276
public void append(final StringBuffer sb) {
        if (sb == null) {
            return;
        }
        provideCapacity(length + sb.length());
        sb.getChars(0, sb.length(), c, length);
        length += sb.length();
    }
320604
private void append(final StringBuilder builder, final String string,
            final String separator) {
        if (string != null) {
            builder.append(string);
        }
        builder.append(separator);
    }
1314521
public static String escapeChars(String str, String chars) {
        StringBuilder sb = new StringBuilder();

        for (int i = 0; i < str.length(); i++) {
            char c = str.charAt(i);

            if (chars.indexOf(c) >= 0) {
                sb.append('\\');
            }

            sb.append(c);
        }

        return sb.toString();
    }
1353045
public void append(final CharArrayBuffer b) {
        if (b == null) {
            return;
        }
        append(b.array,0, b.len);
    }
326981
public static String[] charArrayToStringArray(char[][] charArrays)
	{
		if (charArrays == null)
		{
			return null;
		}
		int length = charArrays.length;
		if (length == 0)
		{
			return NO_STRINGS;
		}
		String[] strings = new String[length];
		for (int i = 0; i < length; i++)
		{
			strings[i] = new String(charArrays[i]);
		}
		return strings;
	}
330216
public void append(final char[] data) {
        if (data == null) {
            return;
        }
        provideCapacity(length + data.length);
        System.arraycopy(data, 0, c, length, data.length);
        length += data.length;
    }
1104990
public StrBuilder append(char[] src, int srcPos, int length) {
		return insert(this.position, src, srcPos, length);
	}
1174659
public Object parse(char [] chars) {
        if (chars == null) {
            throw new IllegalArgumentException("chars must not be null");
        }

        Object content;
        content = createParser().parse(chars);
        return content;
    }
703816
public boolean append(char c) {
        return set(get() == null ? String.valueOf(c) : get() + c);
    }
1370331
public StrBuilder append(final StrBuilder str) {
        if (str == null) {
            return appendNull();
        }
        final int strLen = str.length();
        if (strLen > 0) {
            final int len = length();
            ensureCapacity(len + strLen);
            System.arraycopy(str.buffer, 0, buffer, len, strLen);
            size += strLen;
        }
        return this;
    }
436655
public static StringBuilder encode(StringBuilder buffer, CharSequence chars) {
		chars.chars().forEach(c -> {
			if (c == '\\') {
				buffer.append("\\\\");
			} else if (c == '"') {
				buffer.append("\\\"");
			} else if (32 <= c && c <= 126) {
				buffer.append((char) c);
			} else {
				switch (c) {
				case 0:
					buffer.append("\\0");
					break;
				case 8:
					buffer.append("\\b");
					break;
				case 9:
					buffer.append("\\t");
					break;
				case 10:
					buffer.append("\\n");
					break;
				case 12:
					buffer.append("\\f");
					break;
				case 13:
					buffer.append("\\r");
					break;
				default:
					buffer.append("\\u").append(hexCharsUpper[(c >> 12) & 0xf]).append(hexCharsUpper[(c >> 8) & 0xf])
							.append(hexCharsUpper[(c >> 4) & 0xf]).append(hexCharsUpper[c & 0xf]);
				}
			}
		});
		return buffer;
	}