/**
   * Remove all entries from <code>self</code>. This will result in a re-initialization of the table
   * upon the first insertion into <code>self</code>.
   */
  public void clear() {
    {
      StellaHashTable self = this;

      self.theTable = null;
      self.size = Stella.NULL_INTEGER;
      self.freeElements = Stella.NULL_INTEGER;
    }
  }
  public static StellaHashTable newStellaHashTable() {
    {
      StellaHashTable self = null;

      self = new StellaHashTable();
      self.theStellaHashTable = null;
      self.theHashTable = null;
      self.equalTestP = false;
      self.freeElements = Stella.NULL_INTEGER;
      self.initialSize = 50;
      self.size = Stella.NULL_INTEGER;
      self.initializeHashTable();
      return (self);
    }
  }
  /**
   * Return a copy of the hash table <code>self</code>. The bucket table and buckets are freshly
   * allocated, however, the keys and values of entries are not copied themselves (similar to what
   * we do for lists, etc.).
   *
   * @return StellaHashTable
   */
  public StellaHashTable copy() {
    {
      StellaHashTable self = this;

      {
        int size = self.size;

        {
          StellaHashTable self000 = StellaHashTable.newStellaHashTable();

          self000.size = size;
          self000.initialSize = self.initialSize;
          self000.freeElements = self.freeElements;
          self000.equalTestP = self.equalTestP;
          {
            StellaHashTable copy = self000;
            KvCons[] table = self.theTable;
            KvCons[] tablecopy = table;
            KvCons bucket = null;

            if (table != null) {
              tablecopy = new KvCons[size];
              copy.theTable = tablecopy;
              {
                int i = Stella.NULL_INTEGER;
                int iter000 = 0;
                int upperBound000 = size - 1;

                for (; iter000 <= upperBound000; iter000 = iter000 + 1) {
                  i = iter000;
                  bucket = table[i];
                  if (bucket != null) {
                    tablecopy[i] = KvCons.copyKvConsList(bucket);
                  } else {
                    tablecopy[i] = null;
                  }
                }
              }
            }
            return (copy);
          }
        }
      }
    }
  }
  public static void initializeStellaHashTable(StellaHashTable self) {
    {
      int size =
          Stella.pickHashTableSizePrime(
              Native.floor(self.initialSize / Stella.$STELLA_HASH_TABLE_AVG_BUCKET_LENGTH$));
      KvCons[] table = new KvCons[size];

      {
        int i = Stella.NULL_INTEGER;
        int iter000 = 0;
        int upperBound000 = size - 1;

        for (; iter000 <= upperBound000; iter000 = iter000 + 1) {
          i = iter000;
          table[i] = null;
        }
      }
      self.theTable = table;
      self.size = size;
      self.freeElements = Native.floor(size * Stella.$STELLA_HASH_TABLE_AVG_BUCKET_LENGTH$);
    }
  }
  public static Stella_Object accessStellaHashTableSlotValue(
      StellaHashTable self, Symbol slotname, Stella_Object value, boolean setvalueP) {
    if (slotname == Stella.SYM_STELLA_SIZE) {
      if (setvalueP) {
        self.size = ((IntegerWrapper) (value)).wrapperValue;
      } else {
        value = IntegerWrapper.wrapInteger(self.size);
      }
    } else if (slotname == Stella.SYM_STELLA_INITIAL_SIZE) {
      if (setvalueP) {
        self.initialSize = ((IntegerWrapper) (value)).wrapperValue;
      } else {
        value = IntegerWrapper.wrapInteger(self.initialSize);
      }
    } else if (slotname == Stella.SYM_STELLA_FREE_ELEMENTS) {
      if (setvalueP) {
        self.freeElements = ((IntegerWrapper) (value)).wrapperValue;
      } else {
        value = IntegerWrapper.wrapInteger(self.freeElements);
      }
    } else if (slotname == Stella.SYM_STELLA_EQUAL_TESTp) {
      if (setvalueP) {
        self.equalTestP = BooleanWrapper.coerceWrappedBooleanToBoolean(((BooleanWrapper) (value)));
      } else {
        value = (self.equalTestP ? Stella.TRUE_WRAPPER : Stella.FALSE_WRAPPER);
      }
    } else {
      {
        OutputStringStream stream000 = OutputStringStream.newOutputStringStream();

        stream000.nativeStream.print("`" + slotname + "' is not a valid case option");
        throw ((StellaException)
            (StellaException.newStellaException(stream000.theStringReader()).fillInStackTrace()));
      }
    }
    return (value);
  }
  public static void rehashStellaHashTable(StellaHashTable self, int newsize) {
    if (self.theTable == null) {
      StellaHashTable.initializeStellaHashTable(self);
      return;
    }
    {
      int size = self.size;
      KvCons[] table = self.theTable;
      KvCons[] newtable = new KvCons[newsize];
      int newbucketindex = 0;
      KvCons newbucket = null;
      KvCons cursor = null;
      KvCons current = null;
      boolean equaltestP = self.equalTestP;

      {
        int i = Stella.NULL_INTEGER;
        int iter000 = 0;
        int upperBound000 = newsize - 1;

        for (; iter000 <= upperBound000; iter000 = iter000 + 1) {
          i = iter000;
          newtable[i] = null;
        }
      }
      {
        int i = Stella.NULL_INTEGER;
        int iter001 = 0;
        int upperBound001 = size - 1;

        for (; iter001 <= upperBound001; iter001 = iter001 + 1) {
          i = iter001;
          cursor = table[i];
          while (cursor != null) {
            if (equaltestP) {
              newbucketindex = (((cursor.key.equalHashCode()) & 0x7FFFFFFF) % newsize);
            } else {
              newbucketindex = (((cursor.key.hashCode_()) & 0x7FFFFFFF) % newsize);
            }
            newbucket = newtable[newbucketindex];
            current = cursor;
            cursor = cursor.rest;
            if (newbucket != null) {
              current.rest = newbucket.rest;
              newbucket.rest = current;
            } else {
              newtable[newbucketindex] = current;
              current.rest = null;
            }
          }
        }
      }
      self.theTable = newtable;
      self.size = newsize;
      self.freeElements =
          Stella.max(
              self.freeElements
                  + Native.floor((newsize - size) * Stella.$STELLA_HASH_TABLE_AVG_BUCKET_LENGTH$),
              0);
    }
  }