/* 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();
  }
}

Began life as a copy of #1031661