/* layout:

-physicalSize

-actual size

-one string pointer per entry

*/

sclass ManagedStringList extends AbstractRandomAccessList<S> implements IManagedObject {

  replace Addr with int.

  !include #1031662 // IManagedObject mix-in

  new L<Entry> list;

  int physicalLength;

  class Entry {

    int ptr;

    S value;

    bool changed;

    *(int *ptr) {}

    *(S *value) { changed = true; }

    S value() {

      if (value == null && ptr != 0) {

        //printVars("Reading " + this);

        value = mem.readString(ptr);

      }

      ret value;

    }

    void setValue(S s) {

      value = s;

      changed = true;

    }

    toString { ret "Entry(" + renderVars(+ptr, +value, +changed) + ")"; }

  }

  public int size() { ret l(list); }

  int arrayStart() { ret addr+2; }

  int elementAddr(int i) { ret arrayStart()+i; }

  // read from memory

  *(ManagedIntObjects_v1 *mem, Addr *addr) {

    physicalLength = mem.get(addr);

    int size = mem.get(addr+1);

    list = emptyList(size);

    for i to size:

      list.add(new Entry(mem.get(elementAddr(i))));

  }

  *(ManagedIntObjects_v1 *mem) {

    flush();

  }

  *(ManagedIntObjects_v1 *mem, LS initialData) {

    fOr (S s : initialData)

      add(s);

    flush();

  }

  public S set(int i, S s) {

    Entry e = list.get(i);

    S old = e.value();

    e.setValue(s);

    ret old;

  }

  public S get(int i) {

    ret list.get(i).value();

  }

  @Override

  public void add(int i, S s) {

    list.add(i, new Entry(s));

  }

  public bool add(S s) {

    ret list.add(new Entry(s));

  }

  public S remove(int i) {

    ret list.remove(i).value();

  }

  void flush {

    ensureCapacityInternal(2+size());

    mem.set(addr+1, size());

    int n = size();

    for i to n: {

      Entry e = list.get(i);

      if (e.changed) {

        // release strings here if they are owned

        e.ptr = mem.newString(e.value);

        e.changed = false;

        deb()?.printVars("flushed entry", +e);

      }

      mem.set(elementAddr(i), e.ptr);

    }

    deb()?.printVars(ptrs := map(list, e -> e.ptr));

  }

  void ensureCapacityInternal(int minCapacity) {

    if (physicalLength < minCapacity) grow(minCapacity);

  }

  private void grow(int minCapacity) {

    int oldCapacity = physicalLength;

    int newCapacity = oldCapacity + (oldCapacity >> 1);

    if (newCapacity - minCapacity < 0)

      newCapacity = minCapacity;

    int oldAddr = addr, oldSize = objectSize();

    physicalLength = newCapacity;

    setAddr(mem.realloc(oldAddr, oldSize, objectSize()));

    mem.set(addr, physicalLength);

  }

  // GC handling

  public void scanForCollection(IManagedObjectCollector gc) {

    deb()?.printVars("scanForCollection", +this, +addr);

    gc.noteObject(addr, objectSize());

    /*int n = size();

    for i to n:

      gc.noteString(mem.get(elementAddr(i)));*/

    int i = 0;

    for (Entry e : list) {

      int elAddr = elementAddr(i++);

      int actualPtr = mem.read(elAddr);

      deb()?.printVars("noteEntry", +e, +i, +elAddr, +actualPtr);

      gc.noteString(actualPtr, null);

      gc.notePointer(elAddr, addr -> {

        deb()?.print("Moving entry " + e + " to " + addr);

        e.ptr = addr;

      });

    }

  } 

  int objectSize() { ret 2+physicalLength; }

  static IF2<ManagedIntObjects_v1, Int, ManagedStringList> factory() {

    ret (mem, addr) -> new ManagedStringList(mem, addr);

  }

  protected void removeRange(int fromIndex, int toIndex) {

    if (fromIndex == toIndex) ret;

    list.subList(fromIndex, toIndex).clear();

  }

}