com.google.gwt.emul.java.lang.AbstractStringBuilder Maven / Gradle / Ivy

Go to download

Show more of this group Show more artifacts with this name
Show all versions of vaadin-client Show documentation

Vaadin is a web application framework for Rich Internet Applications (RIA). Vaadin enables easy development and maintenance of fast and secure rich web applications with a stunning look and feel and a wide browser support. It features a server-side architecture with the majority of the logic running on the server. Ajax technology is used at the browser-side to ensure a rich and interactive user experience.

There is a newer version: 8.27.1

Show newest version

/*
 * Copyright 2008 Google Inc.
 * 
 * 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 java.lang;

/**
 * A base class to share implementation between {@link StringBuffer} and {@link StringBuilder}.
 * 
 * Most methods will give expected performance results. Exception is {@link #setCharAt(int, char)},
 * which is O(n), and thus should not be used many times on the same StringBuffer.
 */
abstract class AbstractStringBuilder {

  String string;

  public AbstractStringBuilder(String string) {
    this.string = string;
  }

  public int length() {
    return string.length();
  }

  public void setLength(int newLength) {
    int oldLength = length();
    if (newLength < oldLength) {
      string = string.substring(0, newLength);
    } else if (newLength > oldLength) {
      string += String.valueOf(new char[newLength - oldLength]);
    }
  }

  public int capacity() {
    // This implementation does not track capacity.
    return Integer.MAX_VALUE;
  }

  @SuppressWarnings("unused")
  public void ensureCapacity(int ignoredCapacity) {
    // This implementation does not track capacity
  }

  public void trimToSize() {
    // This implementation does not track capacity
  }

  public char charAt(int index) {
    return string.charAt(index);
  }

  public void getChars(int srcStart, int srcEnd, char[] dst, int dstStart) {
    String.__checkBounds(length(), srcStart, srcEnd);
    String.__checkBounds(dst.length, dstStart, dstStart + (srcEnd - srcStart));
    while (srcStart < srcEnd) {
      dst[dstStart++] = string.charAt(srcStart++);
    }
  }

  /**
   * Warning! This method is much slower than the JRE implementation. If you need to do
   * character level manipulation, you are strongly advised to use a char[] directly.
   */
  public void setCharAt(int index, char x) {
    replace0(index, index + 1, String.valueOf(x));
  }

  public CharSequence subSequence(int start, int end) {
    return string.substring(start, end);
  }

  public String substring(int begin) {
    return string.substring(begin);
  }

  public String substring(int begin, int end) {
    return string.substring(begin, end);
  }

  public int indexOf(String x) {
    return string.indexOf(x);
  }

  public int indexOf(String x, int start) {
    return string.indexOf(x, start);
  }

  public int lastIndexOf(String s) {
    return string.lastIndexOf(s);
  }

  public int lastIndexOf(String s, int start) {
    return string.lastIndexOf(s, start);
  }

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

  void append0(CharSequence x, int start, int end) {
    if (x == null) {
      x = "null";
    }
    string += x.subSequence(start, end);
  }

  void appendCodePoint0(int x) {
    string += String.valueOf(Character.toChars(x));
  }

  void replace0(int start, int end, String toInsert) {
    string = string.substring(0, start) + toInsert + string.substring(end);
  }

  void reverse0() {
    int length = string.length();

    if (length <= 1) {
      return;
    }

    char[] buffer = new char[length];

    buffer[0] = string.charAt(length - 1);

    for (int i = 1; i < length; i++) {
      buffer[i] = string.charAt(length - 1 - i);
      if (Character.isSurrogatePair(buffer[i], buffer[i - 1])) {
        swap(buffer, i - 1, i);
      }
    }

    string = new String(buffer);
  }

  private static void swap(char[] buffer, int f, int s) {
    char tmp = buffer[f];
    buffer[f] = buffer[s];
    buffer[s] = tmp;
  }
}