Home /Modules/java/StringBuffer.sleela

StringBuffer.sleela

lib/java/jdk-28/java.base/java/lang/StringBuffer.sleela · 381 line(s) · sleela

<< lib/java/jdk-28/java.base/java/lang/StringBuffer.sleela
   SLeeLa file for the Java type java.lang.StringBuffer (module java.base). One Java type, one SLeeLa file.
   Java Source (JDK 28 API): https://download.java.net/java/early_access/jdk28/docs/api/java.base/java/lang/StringBuffer.html
   Java kind: class; extends java.lang.AbstractStringBuilder; implements java.lang.Appendable, java.io.Serializable, java.lang.Comparable, java.lang.CharSequence
   Status: members from the JDK 28 API (exact signatures).
   The SLeeLa functions here are produced from that Java Source. No Java source text is copied. >>
#sleela 3.0
material;
import java.jdk-28;

class StringBuffer {
  < ---- Descriptive metadata (version 1.11 nested-friendly accessors) ---- >
  << Eleven catalogued attributes with getter/setter pairs. Values are faithful
     to the real origin of the Java type: the Java SE / JDK 28 API by Oracle
     and the OpenJDK community. >>
  String metaVersion = "1.1.0";
  int metaId = 8648;
  String metaAuthor = "Oracle / OpenJDK";
  String metaDate = "2026-11-12";
  String metaCopyright = "GPLv2 with Classpath Exception (OpenJDK)";
  String metaTrademark = "Java";
  String metaCorporation = "Oracle Corporation";
  < metaOrigin: National | <nation> | International | Galactic >
  String metaOrigin = "International";
  String metaBirthDate = "2026-11-12";
  < metaScienceRating: maturity/robustness on a 1..10 scale >
  int metaScienceRating = 9;
  < metaNationalSchedule: a real, citable instrument or "none" >
  String metaNationalSchedule = "Java SE 28 API Specification (JDK 28 early access)";

  String getMetaVersion() { return metaVersion; }
  void setMetaVersion(String v) { metaVersion = v; }
  int getMetaId() { return metaId; }
  void setMetaId(int v) { metaId = v; }
  String getAuthor() { return metaAuthor; }
  void setAuthor(String v) { metaAuthor = v; }
  String getDate() { return metaDate; }
  void setDate(String v) { metaDate = v; }
  String getCopyright() { return metaCopyright; }
  void setCopyright(String v) { metaCopyright = v; }
  String getTrademark() { return metaTrademark; }
  void setTrademark(String v) { metaTrademark = v; }
  String getCorporation() { return metaCorporation; }
  void setCorporation(String v) { metaCorporation = v; }
  String getOrigin() { return metaOrigin; }
  void setOrigin(String v) { metaOrigin = v; }
  String getBirthDate() { return metaBirthDate; }
  void setBirthDate(String v) { metaBirthDate = v; }
  int getScienceRating() { return metaScienceRating; }
  void setScienceRating(int v) { metaScienceRating = v; }
  String getNationalSchedule() { return metaNationalSchedule; }
  void setNationalSchedule(String v) { metaNationalSchedule = v; }

  String javaType = "java.lang.StringBuffer";
  String javaModule = "java.base";
  String javaSource = "https://download.java.net/java/early_access/jdk28/docs/api/java.base/java/lang/StringBuffer.html";
  String javaKind = "class";
  String javaSuper = "java.lang.AbstractStringBuilder";

  < ---- BEGIN java implementation (ported from the jdk-25 tier by lib/java/jdk-25/tools/jdk28_connect.py) ---- >
  < ---- StringBuffer members (procedural implementation in SLeeLa) ---- >
  << StringBuffer over a Java UTF-16 String value (buf). Text goes in
     through javaStringFromUtf8 and is spliced with javaStringSubstring and
     javaStringConcat, so every index counts UTF-16 code units, as in Java.
     Exceptions carry the JDK 25 messages. String arguments may be plain SLeeLa
     Strings or Java UTF-16 Strings. toString() returns a plain String whenever
     the text has one (any Unicode text without NUL or an unpaired surrogate,
     see JavaText.plainOf), so the result concatenates and compares like any
     SLeeLa String, and the UTF-16 String otherwise. CharSequence arguments may
     be plain Strings, StringBuilder or StringBuffer. The VM has no char
     primitive, so a char is an int code unit, built at run time with
     javaStringFromCodeUnit; code points above U+FFFF become surrogate pairs and
     reverse() keeps each pair in order, as Java does. append(char) cannot be
     told apart from append(int); the float and double forms keep their stubs. >>
  String buf = javaStringFromCodeUnits();

  public StringBuffer() { this.buf = javaStringFromCodeUnits(); }
  public StringBuffer(int capacity) {
    if (capacity < 0) { throw new NegativeArraySizeException("" + capacity); }
    this.buf = javaStringFromCodeUnits();
  }
  public StringBuffer(java.lang.String str) {
    if (str == null) { throw new NullPointerException(); }
    this.buf = toU(str);
  }

  public synchronized int length() { return javaStringLength(this.buf); }
  public synchronized int capacity() { return javaStringLength(this.buf) + 16; }
  public synchronized boolean isEmpty() { return javaStringLength(this.buf) == 0; }
  public synchronized java.lang.String toString() { return JavaText.plainIfRepresentable(this.buf); }
  public synchronized char charAt(int index) {
    checkIndex(index, length());
    return javaStringCharAt(this.buf, index);
  }
  public synchronized int codePointAt(int index) {
    checkIndex(index, length());
    return javaStringCodePointAt(this.buf, index);
  }
  public synchronized int compareTo(StringBuffer another) {
    return javaStringCompareTo(this.buf, another.buf);
  }
  public synchronized int hashCode() { return javaStringHashCode(this.buf); }

  public synchronized java.lang.String substring(int start) { return substring(start, length()); }
  public synchronized java.lang.String substring(int start, int end) {
    checkRange(start, end, length());
    return javaStringSubstring(this.buf, start, end);
  }

  public synchronized StringBuffer append(java.lang.String str) {
    if (str == null) { return appendText("null"); }
    return appendText(str);
  }
  public synchronized StringBuffer append(int i) { return appendText("" + i); }
  public synchronized StringBuffer append(long lng) { return appendText("" + lng); }
  public synchronized StringBuffer append(boolean b) {
    if (b) { return appendText("true"); }
    return appendText("false");
  }
  public synchronized StringBuffer appendCodePoint(int codePoint) {
    this.buf = javaStringConcat(this.buf, JavaText.codePointU(codePoint));
    return this;
  }

  public synchronized StringBuffer insert(int offset, java.lang.String str) {
    checkOffset(offset, length());
    String t = "null";
    if (str != null) { t = str; }
    return spliceIn(offset, toU(t));
  }
  public StringBuffer insert(int offset, int i) { return insert(offset, "" + i); }
  public StringBuffer insert(int offset, long l) { return insert(offset, "" + l); }
  public StringBuffer insert(int offset, boolean b) {
    if (b) { return insert(offset, "true"); }
    return insert(offset, "false");
  }

  public synchronized StringBuffer delete(int start, int end) {
    int n = length();
    int e = end;
    if (e > n) { e = n; }
    checkRange(start, e, n);
    this.buf = javaStringConcat(javaStringSubstring(this.buf, 0, start), javaStringSubstring(this.buf, e, n));
    return this;
  }
  public synchronized StringBuffer deleteCharAt(int index) {
    checkIndex(index, length());
    return delete(index, index + 1);
  }
  public synchronized StringBuffer replace(int start, int end, java.lang.String str) {
    int n = length();
    int e = end;
    if (e > n) { e = n; }
    checkRange(start, e, n);
    String mid = toU(str);
    this.buf = javaStringConcat(javaStringConcat(javaStringSubstring(this.buf, 0, start), mid), javaStringSubstring(this.buf, e, n));
    return this;
  }
  public synchronized void setLength(int newLength) {
    if (newLength < 0) { throw new StringIndexOutOfBoundsException("String index out of range: " + newLength); }
    int n = length();
    if (newLength <= n) {
      this.buf = javaStringSubstring(this.buf, 0, newLength);
      return;
    }
    int k = newLength - n;
    while (k > 0) { this.buf = javaStringConcat(this.buf, codeUnitString(0)); k = k - 1; }
  }
  public synchronized void setCharAt(int index, char ch) {
    checkIndex(index, length());
    int n = length();
    this.buf = javaStringConcat(javaStringConcat(javaStringSubstring(this.buf, 0, index), codeUnitString(ch)), javaStringSubstring(this.buf, index + 1, n));
  }
  public synchronized StringBuffer reverse() {
    int n = length();
    String out = javaStringFromCodeUnits();
    int i = n - 1;
    while (i >= 0) {
      int c = javaStringCharAt(this.buf, i);
      if (c >= 56320 && c <= 57343 && i > 0) {
        int hi = javaStringCharAt(this.buf, i - 1);
        if (hi >= 55296 && hi <= 56319) {
          out = javaStringConcat(out, javaStringSubstring(this.buf, i - 1, i + 1));
          i = i - 2;
          continue;
        }
      }
      out = javaStringConcat(out, javaStringSubstring(this.buf, i, i + 1));
      i = i - 1;
    }
    this.buf = out;
    return this;
  }
  public synchronized StringBuffer repeat(int codePoint, int count) {
    if (count < 0) { throw new IllegalArgumentException("count is negative: " + count); }
    String u = JavaText.codePointU(codePoint);
    int k = count;
    while (k > 0) { this.buf = javaStringConcat(this.buf, u); k = k - 1; }
    return this;
  }

  public int indexOf(java.lang.String str) { return indexOf(str, 0); }
  public synchronized int indexOf(java.lang.String str, int fromIndex) {
    String t = toU(str);
    int n = length();
    int m = javaStringLength(t);
    int i = fromIndex;
    if (i < 0) { i = 0; }
    if (m == 0) {
      if (i > n) { return n; }
      return i;
    }
    while (i + m <= n) {
      if (javaStringSubstring(this.buf, i, i + m) == t) { return i; }
      i = i + 1;
    }
    return 0 - 1;
  }
  public int lastIndexOf(java.lang.String str) { return lastIndexOf(str, length()); }
  public synchronized int lastIndexOf(java.lang.String str, int fromIndex) {
    String t = toU(str);
    int n = length();
    int m = javaStringLength(t);
    int i = fromIndex;
    if (i > n - m) { i = n - m; }
    if (i < 0) { return 0 - 1; }
    while (i >= 0) {
      if (javaStringSubstring(this.buf, i, i + m) == t) { return i; }
      i = i - 1;
    }
    return 0 - 1;
  }

  public synchronized StringBuffer append(java.lang.CharSequence s) {
    if (s == null) { return appendText("null"); }
    this.buf = javaStringConcat(this.buf, seqU(s));
    return this;
  }
  public synchronized StringBuffer append(java.lang.CharSequence s, int start, int end) {
    String u = javaStringFromUtf8("null");
    if (s != null) { u = seqU(s); }
    int n = javaStringLength(u);
    if (start < 0 || start > end || end > n) { throw new IndexOutOfBoundsException("Range [" + start + ", " + end + ") out of bounds for length " + n); }
    this.buf = javaStringConcat(this.buf, javaStringSubstring(u, start, end));
    return this;
  }
  public synchronized StringBuffer append(char[] str) { return append(str, 0, arrayLength(str)); }
  public synchronized StringBuffer append(char[] str, int offset, int len) {
    int n = arrayLength(str);
    if (offset < 0 || len < 0 || offset > n - len) { throw new IndexOutOfBoundsException("Range [" + offset + ", " + (offset + len) + ") out of bounds for length " + n); }
    this.buf = javaStringConcat(this.buf, unitsU(str, offset, len));
    return this;
  }
  public synchronized StringBuffer insert(int offset, char[] str) {
    checkOffset(offset, length());
    return spliceIn(offset, unitsU(str, 0, arrayLength(str)));
  }
  public synchronized StringBuffer insert(int index, char[] str, int offset, int len) {
    checkOffset(index, length());
    int n = arrayLength(str);
    if (offset < 0 || len < 0 || offset > n - len) { throw new StringIndexOutOfBoundsException("Range [" + offset + ", " + (offset + len) + ") out of bounds for length " + n); }
    return spliceIn(index, unitsU(str, offset, len));
  }
  public synchronized StringBuffer insert(int dstOffset, java.lang.CharSequence s) {
    checkOffset(dstOffset, length());
    if (s == null) { return spliceIn(dstOffset, javaStringFromUtf8("null")); }
    return spliceIn(dstOffset, seqU(s));
  }
  public synchronized StringBuffer insert(int dstOffset, java.lang.CharSequence s, int start, int end) {
    checkOffset(dstOffset, length());
    String u = javaStringFromUtf8("null");
    if (s != null) { u = seqU(s); }
    int n = javaStringLength(u);
    if (start < 0 || start > end || end > n) { throw new IndexOutOfBoundsException("Range [" + start + ", " + end + ") out of bounds for length " + n); }
    return spliceIn(dstOffset, javaStringSubstring(u, start, end));
  }
  public synchronized StringBuffer repeat(java.lang.CharSequence cs, int count) {
    if (count < 0) { throw new IllegalArgumentException("count is negative: " + count); }
    String u = javaStringFromUtf8("null");
    if (cs != null) { u = seqU(cs); }
    int k = count;
    while (k > 0) { this.buf = javaStringConcat(this.buf, u); k = k - 1; }
    return this;
  }

  < text of either String kind as UTF-16 >
  java.lang.String toU(java.lang.String s) {
    if (s instanceof string) { return javaStringFromUtf8(s); }
    return s;
  }
  < a CharSequence argument as UTF-16: a plain String, a StringBuffer or a StringBuffer >
  java.lang.String seqU(Any s) {
    if (s instanceof string) { return javaStringFromUtf8("" + s); }
    if (s instanceof StringBuilder) { StringBuilder b = (StringBuilder) s; return b.buf; }
    if (s instanceof StringBuffer) { StringBuffer f = (StringBuffer) s; return f.buf; }
    throw new UnsupportedOperationException("java.lang.StringBuffer: this CharSequence kind is not supported yet; pass a String, StringBuffer or StringBuffer");
  }
  < a run of char code units as UTF-16 >
  java.lang.String unitsU(char[] str, int offset, int len) {
    String out = javaStringFromCodeUnits();
    int i = 0;
    while (i < len) { out = javaStringConcat(out, codeUnitString(str[offset + i])); i = i + 1; }
    return out;
  }

  public synchronized StringBuffer append(StringBuffer sb) {
    if (sb == null) { return appendText("null"); }
    this.buf = javaStringConcat(this.buf, sb.buf);
    return this;
  }
  public synchronized void ensureCapacity(int minimumCapacity) { }
  public synchronized void trimToSize() { }

  < internal helpers >
  StringBuffer appendText(java.lang.String text) {
    this.buf = javaStringConcat(this.buf, toU(text));
    return this;
  }
  StringBuffer spliceIn(int offset, java.lang.String utf16) {
    int n = length();
    this.buf = javaStringConcat(javaStringConcat(javaStringSubstring(this.buf, 0, offset), utf16), javaStringSubstring(this.buf, offset, n));
    return this;
  }
  < one UTF-16 code unit as a String (a char argument is already 0..65535; wider ints keep their low 16 bits, as a cast to char does) >
  java.lang.String codeUnitString(int c) {
    int v = c % 65536;
    if (v < 0) { v = v + 65536; }
    return javaStringFromCodeUnit(v);
  }
  void checkIndex(int index, int n) {
    if (index < 0 || index >= n) { throw new StringIndexOutOfBoundsException("Index " + index + " out of bounds for length " + n); }
  }
  void checkOffset(int offset, int n) {
    if (offset < 0 || offset > n) { throw new StringIndexOutOfBoundsException("Range [" + offset + ", " + n + ") out of bounds for length " + n); }
  }
  void checkRange(int start, int end, int n) {
    if (start < 0 || start > end || end > n) { throw new StringIndexOutOfBoundsException("Range [" + start + ", " + end + ") out of bounds for length " + n); }
  }
  < ---- END java implementation ---- >

  < ---- generics (SLeeLa erasure, SLEELA.syntax 16.3 and 38.1) ---- >
  << The class is written without Java type parameters: every type variable and
     every parameterized or package-qualified reference type erases to Any, and
     java.lang.String erases to String. A value of a type parameter travels as
     Any; test it with instanceof and cast it where it is used. The Java type
     parameters are kept as data in JAVA_TYPE_PARAMETERS. An instance may record
     the type arguments its caller means with bindGenericTypeArguments (for an
     ArrayList of String, bind the single name java.lang.String). Nothing is
     checked against them at run time. >>
  static final String JAVA_TYPE_PARAMETERS = "";
  String[] genericTypeArguments = new String[0];
  public static String genericTypeParameters() { return JAVA_TYPE_PARAMETERS; }
  public static int genericTypeParameterCount() { return 0; }
  public static String genericTypeParameterName(int index) { return null; }
  public StringBuffer bindGenericTypeArguments(String[] arguments) { if (arguments == null) { this.genericTypeArguments = new String[0]; } else { this.genericTypeArguments = arguments; } return this; }
  public String genericTypeArgument(int index) { if (index < 0 || index >= arrayLength(genericTypeArguments)) { return null; } return genericTypeArguments[index]; }
  public int genericTypeArgumentCount() { return arrayLength(genericTypeArguments); }


  < ---- BEGIN java constructors (exact JDK 28 API signatures) ---- >
  < ---- END java constructors ---- >

  < ---- BEGIN java signatures (exact JDK 28 API signatures) ---- >
  << Not yet SLeeLa logic: each method returns the default value of its
     Java return type. @throwable names what Java throws for it (abstract:
     AbstractMethodError, else UnsupportedOperationException, plus the
     declared throws). Write the logic from the Java Source above into the
     java implementation block; the generator then drops the stub. >>
  @throwable("java.lang.UnsupportedOperationException")
  public synchronized void getChars(int srcBegin, int srcEnd, char[] dst, int dstBegin) { }
  @throwable("java.lang.UnsupportedOperationException")
  public synchronized int codePointBefore(int index) { return 0; }
  @throwable("java.lang.UnsupportedOperationException")
  public synchronized int codePointCount(int beginIndex, int endIndex) { return 0; }
  @throwable("java.lang.UnsupportedOperationException")
  public synchronized int offsetByCodePoints(int index, int codePointOffset) { return 0; }
  @throwable("java.lang.UnsupportedOperationException")
  public synchronized Any subSequence(int start, int end) { return null; }
  < ---- END java signatures ---- >
}