/**
 * TextPrimitive.java
 * 
 * Copyright (c) 2004-2012, Nicole C. Tedesco. All rights reserved.
 * 
 * Licensed under the Apache License, Version 2.0 (the "License"); you may not
 * use this file except in compliance with the License. You may obtain a copy of
 * the License at:
 * 
 * http://www.apache.org/licenses/LICENSE-2.0
 * 
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
 * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
 * License for the specific language governing permissions and limitations under
 * the License.
 */

package net.sf.jaccumulator.texts;

import java.util.NoSuchElementException;

import net.sf.jaccumulator.ConcurrencyStrategy;
import net.sf.jaccumulator.lex.PrimitiveAction;
import net.sf.jaccumulator.primitives.Primitive;

/**
 * A {@link String text} {@link Primitive primitive} implementation
 * 
 * @since JAccumulator 4.0
 * @author Nicole Tedesco (<a
 *         href="mailto:Nicole@NicoleTedesco.com">Nicole@NicoleTedesco.com</a>)
 */
public final class TextPrimitive
    extends
        AbstractTextPrimitive<TextPrimitive>
{
    private static final long serialVersionUID = 5620031426456524721L;

    private final StringBuilder _theBuilder;

    public TextPrimitive()
    {
        super();
        this._theBuilder = new StringBuilder();
    }

    public TextPrimitive( final boolean aValue )
    {
        this();
        this._theBuilder.append(aValue);
    }

    public TextPrimitive(
        final boolean aValue,
        final PrimitiveAction<Primitive<?>> aPrimitiveTranslator )
    {
        this(aPrimitiveTranslator);
        this._theBuilder.append(aValue);
    }

    public TextPrimitive(
        final boolean aValue,
        final PrimitiveAction<Primitive<?>> aPrimitiveTranslator,
        final PrimitiveAction<Primitive<?>> aRealTranslator )
    {
        this(aPrimitiveTranslator, aRealTranslator);
        this._theBuilder.append(aValue);
    }

    public TextPrimitive(
        final boolean aValue,
        final PrimitiveAction<Primitive<?>> aPrimitiveTranslator,
        final PrimitiveAction<Primitive<?>> aRealTranslator,
        final PrimitiveAction<Primitive<?>> aScalarTranslator )
    {
        this(aPrimitiveTranslator, aRealTranslator, aScalarTranslator);
        this._theBuilder.append(aValue);
    }

    public TextPrimitive( final byte aValue )
    {
        this();
        this._theBuilder.append(aValue);
    }

    public TextPrimitive(
        final byte aValue,
        final PrimitiveAction<Primitive<?>> aPrimitiveTranslator )
    {
        this(aPrimitiveTranslator);
        this._theBuilder.append(aValue);
    }

    public TextPrimitive(
        final byte aValue,
        final PrimitiveAction<Primitive<?>> aPrimitiveTranslator,
        final PrimitiveAction<Primitive<?>> aRealTranslator )
    {
        this(aPrimitiveTranslator, aRealTranslator);
        this._theBuilder.append(aValue);
    }

    public TextPrimitive(
        final byte aValue,
        final PrimitiveAction<Primitive<?>> aPrimitiveTranslator,
        final PrimitiveAction<Primitive<?>> aRealTranslator,
        final PrimitiveAction<Primitive<?>> aScalarTranslator )
    {
        this(aPrimitiveTranslator, aRealTranslator, aScalarTranslator);
        this._theBuilder.append(aValue);
    }

    public TextPrimitive( final char aValue )
    {
        this();
        this._theBuilder.append(aValue);
    }

    public TextPrimitive(
        final char aValue,
        final PrimitiveAction<Primitive<?>> aPrimitiveTranslator )
    {
        this(aPrimitiveTranslator);
        this._theBuilder.append(aValue);
    }

    public TextPrimitive(
        final char aValue,
        final PrimitiveAction<Primitive<?>> aPrimitiveTranslator,
        final PrimitiveAction<Primitive<?>> aRealTranslator )
    {
        this(aPrimitiveTranslator, aRealTranslator);
        this._theBuilder.append(aValue);
    }

    public TextPrimitive(
        final char aValue,
        final PrimitiveAction<Primitive<?>> aPrimitiveTranslator,
        final PrimitiveAction<Primitive<?>> aRealTranslator,
        final PrimitiveAction<Primitive<?>> aScalarTranslator )
    {
        this(aPrimitiveTranslator, aRealTranslator, aScalarTranslator);
        this._theBuilder.append(aValue);
    }

    public TextPrimitive( final CharSequence aValue )
    {
        super();
        this._theBuilder = new StringBuilder(aValue);
    }

    public TextPrimitive( final double aValue )
    {
        this();
        this._theBuilder.append(aValue);
    }

    public TextPrimitive(
        final double aValue,
        final PrimitiveAction<Primitive<?>> aPrimitiveTranslator )
    {
        this(aPrimitiveTranslator);
        this._theBuilder.append(aValue);
    }

    public TextPrimitive(
        final double aValue,
        final PrimitiveAction<Primitive<?>> aPrimitiveTranslator,
        final PrimitiveAction<Primitive<?>> aRealTranslator )
    {
        this(aPrimitiveTranslator, aRealTranslator);
        this._theBuilder.append(aValue);
    }

    public TextPrimitive(
        final double aValue,
        final PrimitiveAction<Primitive<?>> aPrimitiveTranslator,
        final PrimitiveAction<Primitive<?>> aRealTranslator,
        final PrimitiveAction<Primitive<?>> aScalarTranslator )
    {
        this(aPrimitiveTranslator, aRealTranslator, aScalarTranslator);
        this._theBuilder.append(aValue);
    }

    public TextPrimitive( final float aValue )
    {
        this();
        this._theBuilder.append(aValue);
    }

    public TextPrimitive(
        final float aValue,
        final PrimitiveAction<Primitive<?>> aPrimitiveTranslator )
    {
        this(aPrimitiveTranslator);
        this._theBuilder.append(aValue);
    }

    public TextPrimitive(
        final float aValue,
        final PrimitiveAction<Primitive<?>> aPrimitiveTranslator,
        final PrimitiveAction<Primitive<?>> aRealTranslator )
    {
        this(aPrimitiveTranslator, aRealTranslator);
        this._theBuilder.append(aValue);
    }

    public TextPrimitive(
        final float aValue,
        final PrimitiveAction<Primitive<?>> aPrimitiveTranslator,
        final PrimitiveAction<Primitive<?>> aRealTranslator,
        final PrimitiveAction<Primitive<?>> aScalarTranslator )
    {
        this(aPrimitiveTranslator, aRealTranslator, aScalarTranslator);
        this._theBuilder.append(aValue);
    }

    public TextPrimitive( final int aValue )
    {
        this();
        this._theBuilder.append(aValue);
    }

    public TextPrimitive(
        final int aValue,
        final PrimitiveAction<Primitive<?>> aPrimitiveTranslator )
    {
        this(aPrimitiveTranslator);
        this._theBuilder.append(aValue);
    }

    public TextPrimitive(
        final int aValue,
        final PrimitiveAction<Primitive<?>> aPrimitiveTranslator,
        final PrimitiveAction<Primitive<?>> aRealTranslator )
    {
        this(aPrimitiveTranslator, aRealTranslator);
        this._theBuilder.append(aValue);
    }

    public TextPrimitive(
        final int aValue,
        final PrimitiveAction<Primitive<?>> aPrimitiveTranslator,
        final PrimitiveAction<Primitive<?>> aRealTranslator,
        final PrimitiveAction<Primitive<?>> aScalarTranslator )
    {
        this(aPrimitiveTranslator, aRealTranslator, aScalarTranslator);
        this._theBuilder.append(aValue);
    }

    public TextPrimitive( final long aValue )
    {
        this();
        this._theBuilder.append(aValue);
    }

    public TextPrimitive(
        final long aValue,
        final PrimitiveAction<Primitive<?>> aPrimitiveTranslator )
    {
        this(aPrimitiveTranslator);
        this._theBuilder.append(aValue);
    }

    public TextPrimitive(
        final long aValue,
        final PrimitiveAction<Primitive<?>> aPrimitiveTranslator,
        final PrimitiveAction<Primitive<?>> aRealTranslator )
    {
        this(aPrimitiveTranslator, aRealTranslator);
        this._theBuilder.append(aValue);
    }

    public TextPrimitive(
        final long aValue,
        final PrimitiveAction<Primitive<?>> aPrimitiveTranslator,
        final PrimitiveAction<Primitive<?>> aRealTranslator,
        final PrimitiveAction<Primitive<?>> aScalarTranslator )
    {
        this(aPrimitiveTranslator, aRealTranslator, aScalarTranslator);
        this._theBuilder.append(aValue);
    }

    public TextPrimitive( final Object aValue )
    {
        this();
        this._theBuilder.append(aValue);
    }

    public TextPrimitive(
        final Object aValue,
        final PrimitiveAction<Primitive<?>> aPrimitiveTranslator )
    {
        this(aPrimitiveTranslator);
        this._theBuilder.append(aValue);
    }

    public TextPrimitive(
        final Object aValue,
        final PrimitiveAction<Primitive<?>> aPrimitiveTranslator,
        final PrimitiveAction<Primitive<?>> aRealTranslator )
    {
        this(aPrimitiveTranslator, aRealTranslator);
        this._theBuilder.append(aValue);
    }

    public TextPrimitive(
        final Object aValue,
        final PrimitiveAction<Primitive<?>> aPrimitiveTranslator,
        final PrimitiveAction<Primitive<?>> aRealTranslator,
        final PrimitiveAction<Primitive<?>> aScalarTranslator )
    {
        this(aPrimitiveTranslator, aRealTranslator, aScalarTranslator);
        this._theBuilder.append(aValue);
    }

    public TextPrimitive(
        final PrimitiveAction<Primitive<?>> aPrimitiveTranslator )
    {
        super(aPrimitiveTranslator);
        this._theBuilder = new StringBuilder();
    }

    public TextPrimitive(
        final PrimitiveAction<Primitive<?>> aPrimitiveTranslator,
        final PrimitiveAction<Primitive<?>> aRealTranslator )
    {
        super(aPrimitiveTranslator, aRealTranslator);
        this._theBuilder = new StringBuilder();
    }

    public TextPrimitive(
        final PrimitiveAction<Primitive<?>> aPrimitiveTranslator,
        final PrimitiveAction<Primitive<?>> aRealTranslator,
        final PrimitiveAction<Primitive<?>> aScalarTranslator )
    {
        super(aPrimitiveTranslator, aRealTranslator, aScalarTranslator);
        this._theBuilder = new StringBuilder();
    }

    public TextPrimitive( final short aValue )
    {
        this();
        this._theBuilder.append(aValue);
    }

    public TextPrimitive(
        final short aValue,
        final PrimitiveAction<Primitive<?>> aPrimitiveTranslator )
    {
        this(aPrimitiveTranslator);
        this._theBuilder.append(aValue);
    }

    public TextPrimitive(
        final short aValue,
        final PrimitiveAction<Primitive<?>> aPrimitiveTranslator,
        final PrimitiveAction<Primitive<?>> aRealTranslator )
    {
        this(aPrimitiveTranslator, aRealTranslator);
        this._theBuilder.append(aValue);
    }

    public TextPrimitive(
        final short aValue,
        final PrimitiveAction<Primitive<?>> aPrimitiveTranslator,
        final PrimitiveAction<Primitive<?>> aRealTranslator,
        final PrimitiveAction<Primitive<?>> aScalarTranslator )
    {
        this(aPrimitiveTranslator, aRealTranslator, aScalarTranslator);
        this._theBuilder.append(aValue);
    }

    @Override
    public final TextPrimitive append( final boolean aValue )
    {
        this._theBuilder.append(aValue);
        return this;
    }

    @Override
    public final TextPrimitive append( final char aValue )
    {
        this._theBuilder.append(aValue);
        return this;
    }

    @Override
    public final TextPrimitive append( final char[] content )
    {
        this._theBuilder.append(content);
        return this;
    }

    @Override
    public final TextPrimitive append(
        final char[] content,
        final int contentIndex )
    {
        this._theBuilder.append(content, contentIndex, content.length
                - contentIndex);
        return this;
    }

    @Override
    public final TextPrimitive append(
        final char[] content,
        final int contentIndex,
        final int contentLength )
    {
        this._theBuilder.append(content, contentIndex, contentLength);
        return this;
    }

    @Override
    public final TextPrimitive append( final CharSequence content )
    {
        this._theBuilder.append(content);
        return this;
    }

    @Override
    public final TextPrimitive append(
        final CharSequence content,
        final int contentStartIndex )
    {
        return this.append(content, contentStartIndex, content.length());
    }

    @Override
    public final TextPrimitive append(
        final CharSequence content,
        final int contentStartIndex,
        final int contentEndIndexPlusOne )
    {
        this._theBuilder.append(content, contentStartIndex,
            contentEndIndexPlusOne);
        return this;
    }

    @Override
    public final TextPrimitive append( final double aValue )
    {
        this._theBuilder.append(aValue);
        return this;
    }

    @Override
    public final TextPrimitive append( final float aValue )
    {
        this._theBuilder.append(aValue);
        return this;
    }

    @Override
    public final TextPrimitive append( final int aValue )
    {
        this._theBuilder.append(aValue);
        return this;
    }

    @Override
    public final TextPrimitive append( final long aValue )
    {
        this._theBuilder.append(aValue);
        return this;
    }

    @Override
    public final TextPrimitive append( final Object aValue )
    {
        this._theBuilder.append(aValue);
        return this;
    }

    @Override
    public final TextPrimitive append( final StringBuffer sb )
    {
        this._theBuilder.append(sb);
        return this;
    }

    @Override
    public final TextPrimitive appendCodePoint( final int codePoint )
    {
        this._theBuilder.appendCodePoint(codePoint);
        return this;
    }

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

    @Override
    public final void clear()
    {
        this._theBuilder.setLength(0);
    }

    @Override
    public final int codePointAt( final int index )
    {
        return this._theBuilder.codePointAt(index);
    }

    @Override
    public final int codePointBefore( final int index )
    {
        return this._theBuilder.codePointBefore(index);
    }

    @Override
    public final int codePointCount( final int beginIndex, final int endIndex )
    {
        return this._theBuilder.codePointCount(beginIndex, endIndex);
    }

    @Override
    public final TextPrimitive copy()
    {
        return new TextPrimitive(this._theBuilder);
    }

    @Override
    public final TextPrimitive copyUsingText( final CharSequence aValue )
    {
        return new TextPrimitive(aValue);
    }

    @Override
    public final TextPrimitive delete( final int start, final int end )
    {
        this._theBuilder.delete(start, end);
        return this;
    }

    @Override
    public final TextPrimitive deleteCharAt( final int anIndex )
    {
        this._theBuilder.deleteCharAt(anIndex);
        return this;
    }

    @Override
    public final ConcurrencyStrategy getConcurrency()
    {
        return ConcurrencyStrategy.SEQUENTIAL;
    }

    @Override
    public int indexOfText( final CharSequence str )
    {
        return this._theBuilder.indexOf(str.toString());
    }

    @Override
    public final int indexOfText( final CharSequence str, final int beginIndex )
    {
        return this._theBuilder.indexOf(str.toString(), beginIndex);
    }

    @Override
    @SuppressWarnings( "unchecked" )
    public final <TEXT extends Text<?>> TEXT induceTextValue( final TEXT aTarget )
        throws NullPointerException,
            NoSuchElementException,
            UnsupportedOperationException,
            IllegalStateException
    {
        return (TEXT)aTarget.setText(this._theBuilder);
    }

    @Override
    public final TextPrimitive insert( final int anIndex, final boolean aValue )
    {
        this._theBuilder.insert(anIndex, aValue);
        return this;
    }

    @Override
    public final TextPrimitive insert( final int anIndex, final char aValue )
    {
        this._theBuilder.insert(anIndex, aValue);
        return this;
    }

    @Override
    public final TextPrimitive insert( final int anIndex, final char[] content )
    {
        this._theBuilder.insert(anIndex, content);
        return this;
    }

    @Override
    public final TextPrimitive insert(
        final int targetIndex,
        final char[] content,
        final int contentIndex,
        final int contentLength )
    {
        this._theBuilder.insert(targetIndex, content, contentIndex,
            contentLength);
        return this;
    }

    @Override
    public final TextPrimitive insert(
        final int anIndex,
        final CharSequence content )
    {
        this._theBuilder.insert(anIndex, content);
        return this;
    }

    @Override
    public final TextPrimitive insert(
        final int targetIndex,
        final CharSequence content,
        final int contentIndex ) throws UnsupportedOperationException
    {
        return this.insert(targetIndex, content, contentIndex, content.length());
    }

    @Override
    public final TextPrimitive insert(
        final int targetIndex,
        final CharSequence content,
        final int contentStartIndex,
        final int contentEndIndexPlusOne )
    {
        this._theBuilder.insert(targetIndex, content, contentStartIndex,
            contentEndIndexPlusOne);
        return this;
    }

    @Override
    public final TextPrimitive insert( final int anIndex, final double aValue )
    {
        this._theBuilder.insert(anIndex, aValue);
        return this;
    }

    @Override
    public final TextPrimitive insert( final int anIndex, final float aValue )
    {
        this._theBuilder.insert(anIndex, aValue);
        return this;
    }

    @Override
    public final TextPrimitive insert( final int anIndex, final int aValue )
    {
        this._theBuilder.insert(anIndex, aValue);
        return this;
    }

    @Override
    public final TextPrimitive insert( final int anIndex, final long aValue )
    {
        this._theBuilder.insert(anIndex, aValue);
        return this;
    }

    @Override
    public final TextPrimitive insert( final int anIndex, final Object aValue )
    {
        this._theBuilder.insert(anIndex, aValue);
        return this;
    }

    @Override
    public final boolean isElastic()
    {
        return true;
    }

    @Override
    public final boolean isEmpty()
    {
        return this._theBuilder.length() == 0;
    }

    @Override
    public final boolean isExpandable()
    {
        return true;
    }

    @Override
    public final int length()
    {
        return this._theBuilder.length();
    }

    @Override
    public TextPrimitive lowerCase()
    {
        final int myLength = this.length();
        for (int i = 0; i < myLength; i++) {
            final char lowSurrogate = this._theBuilder.charAt(i);
            if (Character.isHighSurrogate(lowSurrogate)) {
                final int iNext = i + 1;
                if (iNext < myLength) {
                    final char highSurrogate = this._theBuilder.charAt(iNext);
                    if (Character.isLowSurrogate(highSurrogate)) {
                        final int cp = Character.toCodePoint(lowSurrogate,
                            highSurrogate);
                        final int lcp = Character.toLowerCase(cp);
                        final char lowerLowSurrogate = Character.lowSurrogate(lcp);
                        final char lowerHighSurrogate = Character.highSurrogate(lcp);
                        this._theBuilder.setCharAt(iNext, lowerLowSurrogate);
                        this._theBuilder.setCharAt(i++, lowerHighSurrogate);
                        continue;
                    }
                }
            }
            final char lc = Character.toLowerCase(lowSurrogate);
            this._theBuilder.setCharAt(i, lc);
        }
        return this;
    }

    @Override
    public final TextPrimitive prepend( final boolean aValue )
    {
        this._theBuilder.insert(0, aValue);
        return this;
    }

    @Override
    public final TextPrimitive prepend( final char aValue )
    {
        this._theBuilder.insert(0, aValue);
        return this;
    }

    @Override
    public final TextPrimitive prepend( final char[] content )
    {
        this._theBuilder.insert(0, content);
        return this;
    }

    @Override
    public final TextPrimitive prepend(
        final char[] content,
        final int contentIndex )
    {
        this._theBuilder.insert(0, content, contentIndex, content.length
                - contentIndex);
        return this;
    }

    @Override
    public final TextPrimitive prepend(
        final char[] content,
        final int contentIndex,
        final int contentLength )
    {
        this._theBuilder.insert(0, content, contentIndex, contentLength);
        return this;
    }

    @Override
    public final TextPrimitive prepend( final CharSequence content )
    {
        this._theBuilder.insert(0, content);
        return this;
    }

    @Override
    public final TextPrimitive prepend(
        final CharSequence content,
        final int contentStartIndex )
    {
        return this.prepend(content, contentStartIndex, content.length());
    }

    @Override
    public final TextPrimitive prepend(
        final CharSequence content,
        final int contentStartIndex,
        final int contentEndIndexPlusOne )
    {
        this._theBuilder.insert(0, content, contentStartIndex,
            contentEndIndexPlusOne);
        return this;
    }

    @Override
    public final TextPrimitive prepend( final double aValue )
    {
        this._theBuilder.insert(0, aValue);
        return this;
    }

    @Override
    public final TextPrimitive prepend( final float aValue )
    {
        this._theBuilder.insert(0, aValue);
        return this;
    }

    @Override
    public final TextPrimitive prepend( final int aValue )
    {
        this._theBuilder.insert(0, aValue);
        return this;
    }

    @Override
    public final TextPrimitive prepend( final long aValue )
    {
        this._theBuilder.insert(0, aValue);
        return this;
    }

    @Override
    public final TextPrimitive prepend( final Object aValue )
    {
        this._theBuilder.insert(0, aValue);
        return this;
    }

    @Override
    public final TextPrimitive replace(
        final CharSequence target,
        final CharSequence replacement )
    {
        final String myString = this.toString();
        return this.setText(myString.replace(target, replacement));
    }

    @Override
    public final TextPrimitive replace(
        final int start,
        final int end,
        final String str )
    {
        this._theBuilder.replace(start, end, str);
        return this;
    }

    @Override
    public final TextPrimitive replaceAll(
        final String regex,
        final String replacement )
    {
        final String myString = this.toString();
        return this.setText(myString.replaceAll(regex, replacement));
    }

    @Override
    public final TextPrimitive replaceCharacter(
        final char oldChar,
        final char newChar )
    {
        final int myLength = this._theBuilder.length();
        for (int i = 0; i < myLength; i++) {
            final char aCharacter = this._theBuilder.charAt(i);
            if (aCharacter == oldChar) {
                this._theBuilder.setCharAt(i, newChar);
            }
        }
        return this;
    }

    @Override
    public final TextPrimitive replaceFirst(
        final String regex,
        final String replacement )
    {
        final String myString = this.toString();
        return this.setText(myString.replaceFirst(regex, replacement));
    }

    @Override
    public final TextPrimitive reverse()
    {
        this._theBuilder.reverse();
        return this;
    }

    @Override
    public final TextPrimitive setCharAt( final int index, final char ch )
    {
        this._theBuilder.setCharAt(index, ch);
        return this;
    }

    @Override
    public final TextPrimitive setLength( final int newLength )
    {
        this._theBuilder.setLength(newLength);
        return this;
    }

    @Override
    public final TextPrimitive setText( final CharSequence content )
        throws UnsupportedOperationException,
            IllegalArgumentException,
            ArithmeticException,
            NullPointerException
    {
        this._theBuilder.setLength(0);
        this._theBuilder.append(content);
        return this;
    }

    @Override
    public final CharSequence subSequence( final int start, final int end )
    {
        return this._theBuilder.subSequence(start, end);
    }

    @Override
    public final String substring( final int start )
    {
        return this._theBuilder.substring(start);
    }

    @Override
    public final String substring( final int start, final int end )
    {
        return this._theBuilder.substring(start, end);
    }

    @Override
    public TextPrimitive titleCase()
    {
        final int myLength = this.length();
        for (int i = 0; i < myLength; i++) {
            final char lowSurrogate = this._theBuilder.charAt(i);
            if (Character.isHighSurrogate(lowSurrogate)) {
                final int iNext = i + 1;
                if (iNext < myLength) {
                    final char highSurrogate = this._theBuilder.charAt(iNext);
                    if (Character.isLowSurrogate(highSurrogate)) {
                        final int cp = Character.toCodePoint(lowSurrogate,
                            highSurrogate);
                        final int tcp = Character.toTitleCase(cp);
                        final char titleLowSurrogate = Character.lowSurrogate(tcp);
                        final char titleHighSurrogate = Character.highSurrogate(tcp);
                        this._theBuilder.setCharAt(iNext, titleLowSurrogate);
                        this._theBuilder.setCharAt(i++, titleHighSurrogate);
                        continue;
                    }
                }
            }
            final char tc = Character.toTitleCase(lowSurrogate);
            this._theBuilder.setCharAt(i, tc);
        }
        return this;
    }

    @Override
    public final String toString()
    {
        return this._theBuilder.toString();
    }

    @Override
    public TextPrimitive upperCase()
    {
        final int myLength = this.length();
        for (int i = 0; i < myLength; i++) {
            final char lowSurrogate = this._theBuilder.charAt(i);
            if (Character.isHighSurrogate(lowSurrogate)) {
                final int iNext = i + 1;
                if (iNext < myLength) {
                    final char highSurrogate = this._theBuilder.charAt(iNext);
                    if (Character.isLowSurrogate(highSurrogate)) {
                        final int cp = Character.toCodePoint(lowSurrogate,
                            highSurrogate);
                        final int ucp = Character.toUpperCase(cp);
                        final char upperLowSurrogate = Character.lowSurrogate(ucp);
                        final char upperHighSurrogate = Character.highSurrogate(ucp);
                        this._theBuilder.setCharAt(iNext, upperLowSurrogate);
                        this._theBuilder.setCharAt(i++, upperHighSurrogate);
                        continue;
                    }
                }
            }
            final char uc = Character.toUpperCase(lowSurrogate);
            this._theBuilder.setCharAt(i, uc);
        }
        return this;
    }
}