implement import and export tables

runtime/src/main/java/org/capnproto/ExportTable.java

@@ -0,0 +1,56 @@
+package org.capnproto;
+
+import java.util.HashMap;
+import java.util.Iterator;
+import java.util.PriorityQueue;
+import java.util.Queue;
+import java.util.function.Consumer;
+
+abstract class ExportTable<T> implements Iterable<T> {
+
+    final HashMap<Integer, T> slots = new HashMap<>();
+    final Queue<Integer> freeIds = new PriorityQueue<>();
+    int max = 0;
+
+    protected abstract T newExportable();
+
+    public T find(int id) {
+        return slots.get(id);
+    }
+
+    public T erase(int id, T entry) {
+        var value = slots.get(id);
+        if (value == entry) {
+            freeIds.add(id);
+            return slots.remove(id);
+        } else {
+            return null;
+        }
+    }
+
+    public T next() {
+        if (freeIds.isEmpty()) {
+            var id = max;
+            max++;
+            var value = newExportable();
+            slots.put(id, value);
+            return value;
+        } else {
+            var id = freeIds.remove();
+            var value = newExportable();
+            slots.put(id, value);
+            return value;
+        }
+    }
+
+    @Override
+    public Iterator<T> iterator() {
+        return slots.values().iterator();
+    }
+
+    @Override
+    public void forEach(Consumer<? super T> action) {
+        slots.values().forEach(action);
+    }
+}
+

runtime/src/main/java/org/capnproto/ImportTable.java

@@ -0,0 +1,40 @@
+package org.capnproto;
+
+import java.util.HashMap;
+import java.util.Iterator;
+import java.util.function.Consumer;
+
+abstract class ImportTable<T> implements Iterable<T> {
+
+    private final HashMap<Integer, T> slots = new HashMap<>();
+
+    protected abstract T newImportable();
+
+    public T put(int id) {
+        return slots.computeIfAbsent(id, key -> newImportable());
+    }
+
+    public T find(int id) {
+        return slots.get(id);
+    }
+
+    public T erase(int id, T entry) {
+        var removed = slots.remove(id, entry);
+        assert removed;
+        return entry;
+    }
+
+    public T erase(int id) {
+        return slots.remove(id);
+    }
+
+    @Override
+    public Iterator<T> iterator() {
+        return slots.values().iterator();
+    }
+
+    @Override
+    public void forEach(Consumer<? super T> action) {
+        slots.values().forEach(action);
+    }
+}

runtime/src/main/java/org/capnproto/RpcState.java

@@ -1,7 +1,8 @@
 package org.capnproto;
 
-import java.util.List;
+import java.util.*;
 import java.util.concurrent.CompletableFuture;
+import java.util.function.Consumer;
 
 final class RpcState {
 
@@ -46,6 +47,43 @@ final class RpcState {
         CompletableFuture<java.lang.Void> fulfiller;
     }
 
+    private final ExportTable<Export> exports = new ExportTable<Export>() {
+        @Override
+        protected Export newExportable() {
+            return new Export();
+        }
+    };
+
+    private final ExportTable<Question> questions = new ExportTable<Question>() {
+        @Override
+        protected Question newExportable() {
+            return new Question();
+        }
+    };
+
+    private final ImportTable<Answer> answers = new ImportTable<Answer>() {
+        @Override
+        protected Answer newImportable() {
+            return new Answer();
+        }
+    };
+
+    private final ImportTable<Import> imports = new ImportTable<Import>() {
+        @Override
+        protected Import newImportable() {
+            return new Import();
+        }
+    };
+
+    private final ExportTable<Embargo> embargos = new ExportTable<Embargo>() {
+        @Override
+        protected Embargo newExportable() {
+            return new Embargo();
+        }
+    };
+
+    private final HashMap<ClientHook, Integer> exportsByCap = new HashMap<>();
+
     interface RpcResponse extends ResponseHook {
         AnyPointer.Reader getResults();
     }