if (isEmpty(name)) {
            return name;
        }
        final char[] chars = name.toCharArray();
        if (chars.length >= 2 && Character.isUpperCase(chars[0]) && Character.isUpperCase(chars[1])) {
            return name;
        }
        chars[0] = Character.toLowerCase(chars[0]);
        return new String(chars);
    }

    /**

        final byte b0 = DECODE_TABLE[inData.charAt(inIndex)];
        final byte b1 = DECODE_TABLE[inData.charAt(inIndex + 1)];
        final byte b2 = DECODE_TABLE[inData.charAt(inIndex + 2)];
        final byte b3 = DECODE_TABLE[inData.charAt(inIndex + 3)];
        outData[outIndex] = (byte) (b0 << 2 & 0xfc | b1 >> 4 & 0x3);

        }
        char[] chars = new char[0];
        assertThat(StringUtil.newStringUnsafe(chars), is(""));
        chars = new char[] { 'a', 'b', 'c' };
        assertThat(StringUtil.newStringUnsafe(chars), is("abc"));
        chars = new char[] { 'a', 'b', 'c', ' ' };
        assertThat(StringUtil.newStringUnsafe(chars), is("abc "));
    }

    public static String escape(final String value) {
        if (value == null) {
            return null;
        }

        char c;
        final int len = value.length();
        final StringBuilder buf = new StringBuilder(len * 2);

        for (int i = 0; i < len; i++) {
            c = value.charAt(i);
            switch (c) {
            case '\\':
            case '"':
                buf.append('\\');

                @Override
                public String toString() {
                    return name;
                }

                @Override
                public char charAt(final int index) {
                    return name.charAt(index);
                }

                @Override
                public int length() {
                    return name.length();
                }

     */
    public static String encodeAttrQuot(final String s) {
        if (s == null) {
            return null;
        }
        final char[] content = s.toCharArray();
        final StringBuilder buf = new StringBuilder(s.length() + 100);
        for (final char element : content) {
            switch (element) {
            case '<':
                buf.append("&lt;");
                break;
            case '>':

     * </table>
     *
     * @param beanDelimiter
     *            JavaBeansのデリミタ
     * @return JavaBeansのデリミタを設定した{@link CopyOptions}
     * @see CopyOptions#beanDelimiter(char)
     */
    public static CopyOptions beanDelimiter(final char beanDelimiter) {
        return new CopyOptions().beanDelimiter(beanDelimiter);
    }

    /**
     * {@literal Map}のデリミタを設定した{@link CopyOptions}を返します。
     * <p>

     */
    protected static String toPlainPattern(final String pattern) {
        final StringBuilder buf = new StringBuilder(pattern.length());
        for (int i = 0; i < pattern.length(); ++i) {
            final char ch = pattern.charAt(i);
            if (Character.isLetterOrDigit(ch) || Character.isWhitespace(ch)) {
                buf.append(ch);
            }
        }
        if (buf.indexOf("yy") == -1) {

    private final String str;

    private int colno = 0;

    private int ttype = TT_NOTHING;

    private String sval;

    private char[] buf = new char[20];

    private int peekc = NEED_CHAR;

    private byte peekct = 0;

    static {
        setup(defaultCtype);
    }

    /**
     * {@link Tokenizer}を作成します。
     *
     * @param str

     * @return フォーマットされたメッセージ文字列
     */
    public static LogMessage format(final String messageCode, final Object... args) {
        assertArgumentNotEmpty("messageCode", messageCode);

        final char messageType = messageCode.charAt(0);
        final String message = MessageFormatter.getSimpleMessage(messageCode, args);
        switch (messageType) {
        case 'D':
            return new LogMessage(LogLevel.DEBUG, message);