Home /Modules/java/BitSet.sleela

BitSet.sleela

lib/java/jdk-28/java.base/java/util/BitSet.sleela · 402 line(s) · sleela

<< lib/java/jdk-28/java.base/java/util/BitSet.sleela
   SLeeLa file for the Java type java.util.BitSet (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/util/BitSet.html
   Java kind: class; extends java.lang.Object; implements java.lang.Cloneable, java.io.Serializable
   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 BitSet {
  < ---- 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 = 1850;
  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.util.BitSet";
  String javaModule = "java.base";
  String javaSource = "https://download.java.net/java/early_access/jdk28/docs/api/java.base/java/util/BitSet.html";
  String javaKind = "class";
  String javaSuper = "java.lang.Object";

  < ---- BEGIN java implementation (ported from the jdk-25 tier by lib/java/jdk-25/tools/jdk28_connect.py) ---- >
  < ---- java.util.BitSet members (procedural implementation in SLeeLa) ---- >
  << A growable vector of bits. Storage is one boolean per bit; the Java
     long-word view is reproduced where it is observable (size() is a
     multiple of 64, toLongArray / valueOf / hashCode use the 64-bit word
     layout). The constructor takes the initial size in bits. Java overloads
     carry suffixes: set(i, value) is setTo, set(from, to) is setRange,
     set(from, to, value) is setRangeTo, clear(from, to) is clearRange,
     clear() is clearAll, get(from, to) is getRange, flip(from, to) is
     flipRange. >>
  boolean[] bits;
  int wordsInUse;
  BitSet(int nbits) {
    if (nbits < 0) { throw new NegativeArraySizeException("nbits < 0: " + nbits); }
    int words = (nbits + 63) / 64;
    this.bits = newBits(words * 64);
    this.wordsInUse = 0;
  }
  boolean[] newBits(int n) {
    boolean[] b = new boolean[n];
    int i = 0;
    while (i < n) { b[i] = false; i = i + 1; }
    return b;
  }
  void ensure(int bitIndex) {
    int cap = arrayLength(this.bits);
    if (bitIndex < cap) { return; }
    int need = (bitIndex / 64 + 1) * 64;
    int nc = cap * 2;
    if (nc < need) { nc = need; }
    boolean[] nb = newBits(nc);
    int i = 0;
    while (i < cap) { nb[i] = this.bits[i]; i = i + 1; }
    this.bits = nb;
  }
  void checkIndex(int bitIndex) {
    if (bitIndex < 0) { throw new IndexOutOfBoundsException("bitIndex < 0: " + bitIndex); }
  }
  void checkRange(int fromIndex, int toIndex) {
    if (fromIndex < 0) { throw new IndexOutOfBoundsException("fromIndex < 0: " + fromIndex); }
    if (toIndex < 0) { throw new IndexOutOfBoundsException("toIndex < 0: " + toIndex); }
    if (fromIndex > toIndex) { throw new IndexOutOfBoundsException("fromIndex: " + fromIndex + " > toIndex: " + toIndex); }
  }
  void set(int bitIndex) { setTo(bitIndex, true); }
  void setTo(int bitIndex, boolean value) {
    checkIndex(bitIndex);
    if (value) { ensure(bitIndex); this.bits[bitIndex] = true; }
    else { if (bitIndex < arrayLength(this.bits)) { this.bits[bitIndex] = false; } }
  }
  void setRange(int fromIndex, int toIndex) { setRangeTo(fromIndex, toIndex, true); }
  void setRangeTo(int fromIndex, int toIndex, boolean value) {
    checkRange(fromIndex, toIndex);
    int i = fromIndex;
    while (i < toIndex) { setTo(i, value); i = i + 1; }
  }
  void clear(int bitIndex) { setTo(bitIndex, false); }
  void clearRange(int fromIndex, int toIndex) { setRangeTo(fromIndex, toIndex, false); }
  void clearAll() {
    int i = 0;
    while (i < arrayLength(this.bits)) { this.bits[i] = false; i = i + 1; }
  }
  boolean get(int bitIndex) {
    checkIndex(bitIndex);
    if (bitIndex >= arrayLength(this.bits)) { return false; }
    return this.bits[bitIndex];
  }
  BitSet getRange(int fromIndex, int toIndex) {
    checkRange(fromIndex, toIndex);
    BitSet r = new BitSet(0);
    int i = fromIndex;
    while (i < toIndex) { if (get(i)) { r.set(i - fromIndex); } i = i + 1; }
    return r;
  }
  void flip(int bitIndex) { setTo(bitIndex, !get(bitIndex)); }
  void flipRange(int fromIndex, int toIndex) {
    checkRange(fromIndex, toIndex);
    int i = fromIndex;
    while (i < toIndex) { flip(i); i = i + 1; }
  }
  << Index of the highest set bit plus one. >>
  int length() {
    int i = arrayLength(this.bits) - 1;
    while (i >= 0) { if (this.bits[i]) { return i + 1; } i = i - 1; }
    return 0;
  }
  int size() { return arrayLength(this.bits); }
  boolean isEmpty() { return length() == 0; }
  int cardinality() {
    int n = 0;
    int i = 0;
    while (i < arrayLength(this.bits)) { if (this.bits[i]) { n = n + 1; } i = i + 1; }
    return n;
  }
  int nextSetBit(int fromIndex) {
    if (fromIndex < 0) { throw new IndexOutOfBoundsException("fromIndex < 0: " + fromIndex); }
    int i = fromIndex;
    while (i < arrayLength(this.bits)) { if (this.bits[i]) { return i; } i = i + 1; }
    return -1;
  }
  int nextClearBit(int fromIndex) {
    if (fromIndex < 0) { throw new IndexOutOfBoundsException("fromIndex < 0: " + fromIndex); }
    int i = fromIndex;
    while (i < arrayLength(this.bits)) { if (!this.bits[i]) { return i; } i = i + 1; }
    return i;
  }
  int previousSetBit(int fromIndex) {
    if (fromIndex < -1) { throw new IndexOutOfBoundsException("fromIndex < -1: " + fromIndex); }
    int i = fromIndex;
    while (i >= 0) { if (get(i)) { return i; } i = i - 1; }
    return -1;
  }
  int previousClearBit(int fromIndex) {
    if (fromIndex < -1) { throw new IndexOutOfBoundsException("fromIndex < -1: " + fromIndex); }
    int i = fromIndex;
    while (i >= 0) { if (!get(i)) { return i; } i = i - 1; }
    return -1;
  }
  void and(BitSet set) {
    int i = 0;
    while (i < arrayLength(this.bits)) { if (this.bits[i] && !set.get(i)) { this.bits[i] = false; } i = i + 1; }
  }
  void or(BitSet set) {
    int n = set.length();
    int i = 0;
    while (i < n) { if (set.get(i)) { setTo(i, true); } i = i + 1; }
  }
  void xor(BitSet set) {
    int n = set.length();
    int i = 0;
    while (i < n) { if (set.get(i)) { flip(i); } i = i + 1; }
  }
  void andNot(BitSet set) {
    int i = 0;
    while (i < arrayLength(this.bits)) { if (this.bits[i] && set.get(i)) { this.bits[i] = false; } i = i + 1; }
  }
  boolean intersects(BitSet set) {
    int i = 0;
    while (i < arrayLength(this.bits)) { if (this.bits[i] && set.get(i)) { return true; } i = i + 1; }
    return false;
  }
  << The 64-bit word w of the Java long[] layout (bit i of word w is bit 64w+i). >>
  long word(int w) {
    long v = 0;
    long p = 1;
    int i = 0;
    while (i < 63) {
      if (get(w * 64 + i)) { v = v + p; }
      p = p * 2;
      i = i + 1;
    }
    if (get(w * 64 + 63)) { v = v + (-9223372036854775807 - 1); }
    return v;
  }
  long[] toLongArray() {
    int n = (length() + 63) / 64;
    long[] out = new long[n];
    int w = 0;
    while (w < n) { out[w] = word(w); w = w + 1; }
    return out;
  }
  BitSet valueOf(long[] longs) {
    BitSet r = new BitSet(arrayLength(longs) * 64);
    int w = 0;
    while (w < arrayLength(longs)) {
      long v = longs[w];
      boolean top = v < 0;
      if (top) { v = v - (-9223372036854775807 - 1); }
      int i = 0;
      while (i < 63) {
        if (v % 2 == 1) { r.set(w * 64 + i); }
        v = v / 2;
        i = i + 1;
      }
      if (top) { r.set(w * 64 + 63); }
      w = w + 1;
    }
    return r;
  }
  int[] toByteArray() {
    int n = (length() + 7) / 8;
    int[] out = new int[n];
    int k = 0;
    while (k < n) {
      int v = 0;
      int p = 1;
      int i = 0;
      while (i < 8) { if (get(k * 8 + i)) { v = v + p; } p = p * 2; i = i + 1; }
      if (v > 127) { v = v - 256; }
      out[k] = v;
      k = k + 1;
    }
    return out;
  }
  << Java hashCode: h = 1234 xor-accumulated with word[i] * (i + 1), folded
     to 32 bits; computed on 32-bit halves. >>
  int hashCode() {
    initNibbles();
    long hHi = 0;
    long hLo = 1234;
    int n = (length() + 63) / 64;
    int i = n - 1;
    while (i >= 0) {
      long prodHi = 0;
      long prodLo = 0;
      mul64(word(i), i + 1);
      hHi = xor32(hHi, this.mulHi);
      hLo = xor32(hLo, this.mulLo);
      i = i - 1;
    }
    long r = xor32(hHi, hLo);
    if (r > 2147483647) { r = r - 4294967296; }
    return (int) r;
  }
  long mulHi;
  long mulLo;
  << The low 64 bits of v * k (k small, positive) as unsigned 32-bit halves. >>
  void mul64(long v, int k) {
    long lo = v % 4294967296;
    long hi = v / 4294967296;
    if (lo < 0) { lo = lo + 4294967296; hi = hi - 1; }
    if (hi < 0) { hi = hi + 4294967296; }
    long pl = lo * k;
    long carry = pl / 4294967296;
    this.mulLo = pl % 4294967296;
    this.mulHi = (hi * k + carry) % 4294967296;
  }
  boolean equals(Any obj) {
    if (obj instanceof BitSet) {
      BitSet o = (BitSet) obj;
      int n = length();
      if (o.length() != n) { return false; }
      int i = 0;
      while (i < n) { if (get(i) != o.get(i)) { return false; } i = i + 1; }
      return true;
    }
    return false;
  }
  BitSet clone() {
    BitSet r = new BitSet(arrayLength(this.bits));
    r.or(this);
    return r;
  }
  String toString() {
    String sb = "{";
    boolean first = true;
    int i = 0;
    while (i < arrayLength(this.bits)) {
      if (this.bits[i]) {
        if (!first) { sb = sb + ", "; }
        sb = sb + i;
        first = false;
      }
      i = i + 1;
    }
    return sb + "}";
  }
  << Bitwise operations on unsigned 32-bit values through a 4-bit table
     (the VM has no bitwise operators). >>
  int[] nib;
  void initNibbles() {
    this.nib = new int[256];
    int a = 0;
    while (a < 16) {
      int b = 0;
      while (b < 16) {
        int r = 0;
        int bit = 1;
        int x = a;
        int y = b;
        int k = 0;
        while (k < 4) {
          if ((x % 2) != (y % 2)) { r = r + bit; }
          x = x / 2; y = y / 2; bit = bit * 2; k = k + 1;
        }
        this.nib[a * 16 + b] = r;
        b = b + 1;
      }
      a = a + 1;
    }
  }
  long xor32(long a, long b) {
    long r = 0;
    long mul = 1;
    long x = a;
    long y = b;
    int k = 0;
    while (k < 8) {
      r = r + this.nib[(int) ((x % 16) * 16 + (y % 16))] * mul;
      x = x / 16; y = y / 16; mul = mul * 16; k = k + 1;
    }
    return r;
  }
  < ---- 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 BitSet 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) ---- >
  @throwable("java.lang.UnsupportedOperationException")
  public BitSet() { }
  < ---- 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 Any get(int fromIndex, int toIndex) { return null; }
  @throwable("java.lang.UnsupportedOperationException")
  public void clear(int fromIndex, int toIndex) { }
  @throwable("java.lang.UnsupportedOperationException")
  public void clear() { }
  @throwable("java.lang.UnsupportedOperationException")
  public Any stream() { return null; }
  @throwable("java.lang.UnsupportedOperationException")
  public void set(int fromIndex, int toIndex) { }
  @throwable("java.lang.UnsupportedOperationException")
  public void set(int bitIndex, boolean value) { }
  @throwable("java.lang.UnsupportedOperationException")
  public void set(int fromIndex, int toIndex, boolean value) { }
  @throwable("java.lang.UnsupportedOperationException")
  public void flip(int fromIndex, int toIndex) { }
  < ---- END java signatures ---- >
}