sclass HCRUD_Data {

  new Map<S, Renderer> renderers;

  new SS fieldHelp;

  O currentValue; // current field value held temporarily

  bool humanizeFieldNames = true;

  SS rawFormValues; // temporary map with raw form values

  abstract sclass Renderer {

    S metaInfo;

    swappable O preprocessValue(O value) { ret value; }

  }

  sclass NotEditable extends Renderer {}

  srecord TextArea(int cols, int rows) extends Renderer {

    // star constructor syntax not working here (transpiler bug)

    TextArea(int cols, int rows, IF1 preprocessValue) {

      this.cols = cols;

      this.rows = rows;

      this.preprocessValue = preprocessValue;

    }

  }

  sclass AceEditor extends TextArea {

    *() {}

    *(int *cols, int *rows) {}

  }

  srecord TextField(int cols) extends Renderer {}

  srecord AbstractComboBox extends Renderer {

    bool editable;

    // help find item to select

    swappable S valueToEntry(O value) { ret strOrNull(value); }

  }

  srecord ComboBox(LS entries) extends AbstractComboBox {

    ComboBox(S... entries) { this(asList(entries)); }

    ComboBox(bool editable, S... entries) { this(entries); this.editable = editable; }

    ComboBox(bool editable, LS entries) { this(entries); this.editable = editable; }

    // star constructor syntax not working here (transpiler bug)

    ComboBox(LS entries, IF1<O, S> valueToEntry) {

      this.entries = entries;

      this.valueToEntry = valueToEntry;

    }

  }

  srecord DynamicComboBox(S info) extends AbstractComboBox {

    S url;

  }

  srecord CheckBox() extends Renderer {

    { metaInfo = "Bool"; }

  }

  srecord FlexibleLengthList(Renderer itemRenderer) extends Renderer {}

  S itemName() { ret "object"; }

  S itemNamePlural() { ret plural(itemName()); }

  //LS fields() { null; }

  L<MapSO> list() { null; }

  L<MapSO> list(IntRange range) { ret subListOrFull(list(), range); }

  S idField() { ret "id"; }

  MapSO emptyObject() { null; }

  MapSO getObject(O id) { null; }

  MapSO getObjectForEdit(O id) { ret getObject(id); }

  swappable MapSO getObjectForDuplication(O id) { ret getObject(id); }

  // return ID

  O createObject(SS fullMap, S fieldPrefix) { throw unimplemented(); }

  // return text msg

  S deleteObject(O id) { throw unimplemented(); }

  bool objectCanBeDeleted(O id) { true; }

  swappable bool objectCanBeEdited(O id) { true; }

  // return text msg

  S updateObject(O id, SS fullMap, S fieldPrefix) { throw unimplemented(); }

  // return null for standard input field

  Renderer getRenderer(S field) { ret renderers.get(field); }

  final Renderer getRenderer(S field, O value) {

    this.currentValue = value;

    try {

      ret getRenderer(field);

    } finally {

      this.currentValue = null;

    }

  }

  // returns HTML

  S fieldHelp(S field) { ret fieldHelp.get(field); }

  returnSelf addRenderer(S field, Renderer renderer) { renderers.put(field, renderer); }

  returnSelf fieldHelp(S field, S help, S... more) {

    fieldHelp.put(field, help);

    for (int i = 0; i+1 < l(more); i += 2)

      fieldHelp.put(more[i], more[i+1]);

  }

  S fieldNameToHTML(S name) {

    S help = fieldHelp.get(name);

    ret spanTitle(help, htmlencode2(

      humanizeFieldNames ? humanizeLabel(name) : name));

  }

  Set<S> filteredFields() { null; }

  LS comboBoxSearch(S info, S query) { null; }

  // optional page title when showing a single object

  S titleForObjectID(O id) { null; }

  // second parameter indicates descending

  Pair<S, Bool> defaultSortField() { null; }

  abstract class Item extends AbstractMap<S, O> {

    O id;

    MapSO fullMap;

    *(O *id) {}

    abstract MapSO calcFullMap();

    MapSO fullMap() { if (fullMap == null) fullMap = calcFullMap(); ret fullMap; }

    replace A with S.

    replace B with O.

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

    public Set<Map.Entry<A, B>> entrySet() { ret fullMap().entrySet(); }

    public bool containsKey(O o) { ret fullMap().containsKey(o); }

    public B get(O o) {

      if (fullMap == null && eq(o, idField())) ret id;

      ret fullMap().get(o);

    }

    public B put(A key, B value) {

      ret fullMap().put(key, value);

    }

  }

}