@agoric/swingset-liveslots 0.10.3-dev-dd19d79.0 → 0.10.3-dev-d589873.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@agoric/swingset-liveslots",
-  "version": "0.10.3-dev-dd19d79.0+dd19d79",
+  "version": "0.10.3-dev-d589873.0+d589873",
   "description": "SwingSet ocap support layer",
   "type": "module",
   "main": "src/index.js",
@@ -17,10 +17,10 @@
     "lint:eslint": "eslint ."
   },
   "dependencies": {
-    "@agoric/assert": "0.6.1-dev-dd19d79.0+dd19d79",
-    "@agoric/internal": "0.3.3-dev-dd19d79.0+dd19d79",
-    "@agoric/store": "0.9.3-dev-dd19d79.0+dd19d79",
-    "@agoric/vat-data": "0.5.3-dev-dd19d79.0+dd19d79",
+    "@agoric/assert": "0.6.1-dev-d589873.0+d589873",
+    "@agoric/internal": "0.3.3-dev-d589873.0+d589873",
+    "@agoric/store": "0.9.3-dev-d589873.0+d589873",
+    "@agoric/vat-data": "0.5.3-dev-d589873.0+d589873",
     "@endo/eventual-send": "^0.17.2",
     "@endo/exo": "^0.2.2",
     "@endo/far": "^0.2.18",
@@ -61,5 +61,5 @@
   "publishConfig": {
     "access": "public"
   },
-  "gitHead": "dd19d7941c60a98470fc75cc8ac648ab7e39fde1"
+  "gitHead": "d5898733a61b253fae863e4ad5531d9005cdacb0"
 }

package/src/collectionManager.js

@@ -15,7 +15,10 @@ import {
   makeCopySet,
   makeCopyMap,
   getRankCover,
+  getCopyMapEntries,
+  getCopySetKeys,
 } from '@endo/patterns';
+import { isCopyMap, isCopySet } from '@agoric/store';
 import { makeBaseRef, parseVatSlot } from './parseVatSlots.js';
 import {
   enumerateKeysStartEnd,
@@ -624,6 +627,36 @@ export function makeCollectionManager(
     const snapshotMap = (keyPatt, valuePatt) =>
       makeCopyMap(entries(keyPatt, valuePatt));
 
+    const addAllToSet = elems => {
+      if (typeof elems[Symbol.iterator] !== 'function') {
+        if (Object.isFrozen(elems) && isCopySet(elems)) {
+          elems = getCopySetKeys(elems);
+        } else {
+          Fail`provided data source is not iterable: ${elems}`;
+        }
+      }
+      for (const elem of elems) {
+        addToSet(elem);
+      }
+    };
+
+    const addAllToMap = mapEntries => {
+      if (typeof mapEntries[Symbol.iterator] !== 'function') {
+        if (Object.isFrozen(mapEntries) && isCopyMap(mapEntries)) {
+          mapEntries = getCopyMapEntries(mapEntries);
+        } else {
+          Fail`provided data source is not iterable: ${mapEntries}`;
+        }
+      }
+      for (const [key, value] of mapEntries) {
+        if (has(key)) {
+          set(key, value);
+        } else {
+          doInit(key, value, true);
+        }
+      }
+    };
+
     return {
       has,
       get,
@@ -635,6 +668,8 @@ export function makeCollectionManager(
       keys,
       values,
       entries,
+      addAllToSet,
+      addAllToMap,
       snapshotSet,
       snapshotMap,
       sizeInternal,
@@ -647,12 +682,23 @@ export function makeCollectionManager(
     const hasWeakKeys = storeKindInfo[kindName].hasWeakKeys;
     const raw = summonCollectionInternal(initial, collectionID, kindName);
 
-    const { has, get, init, addToSet, set, delete: del } = raw;
+    const {
+      has,
+      get,
+      init,
+      addToSet,
+      addAllToMap,
+      addAllToSet,
+      set,
+      delete: del,
+    } = raw;
     const weakMethods = {
       has,
       get,
       init,
       addToSet,
+      addAllToSet,
+      addAllToMap,
       set,
       delete: del,
     };
@@ -764,12 +810,48 @@ export function makeCollectionManager(
   }
 
   function collectionToMapStore(collection) {
-    const { snapshotSet: _, snapshotMap, ...rest } = collection;
-    return Far('mapStore', { snapshot: snapshotMap, ...rest });
+    const {
+      has,
+      get,
+      init,
+      set,
+      delete: del,
+      addAllToMap,
+      keys,
+      values,
+      entries,
+      snapshotMap,
+      getSize,
+      clear,
+    } = collection;
+    const mapStore = {
+      has,
+      get,
+      init,
+      set,
+      delete: del,
+      addAll: addAllToMap,
+      keys,
+      values,
+      entries,
+      snapshot: snapshotMap,
+      getSize,
+      clear,
+    };
+    return Far('mapStore', mapStore);
   }
 
   function collectionToWeakMapStore(collection) {
-    return Far('weakMapStore', collection);
+    const { has, get, init, set, delete: del, addAllToMap } = collection;
+    const weakMapStore = {
+      has,
+      get,
+      init,
+      set,
+      delete: del,
+      addAll: addAllToMap,
+    };
+    return Far('weakMapStore', weakMapStore);
   }
 
   function collectionToSetStore(collection) {
@@ -777,50 +859,35 @@ export function makeCollectionManager(
       has,
       addToSet,
       delete: del,
+      addAllToSet,
       keys,
-      getSize,
       snapshotSet,
+      getSize,
       clear,
     } = collection;
-    function* entries(patt) {
-      for (const k of keys(patt)) {
-        yield [k, k];
-      }
-    }
-    function addAll(elems) {
-      for (const elem of elems) {
-        addToSet(elem, null);
-      }
-    }
 
     const setStore = {
       has,
       add: addToSet,
-      addAll,
       delete: del,
+      addAll: addAllToSet,
       keys: patt => keys(patt),
       values: patt => keys(patt),
-      entries,
-      getSize: patt => getSize(patt),
       snapshot: snapshotSet,
+      getSize: patt => getSize(patt),
       clear,
     };
     return Far('setStore', setStore);
   }
 
   function collectionToWeakSetStore(collection) {
-    const { has, addToSet, delete: del } = collection;
-    function addAll(elems) {
-      for (const elem of elems) {
-        addToSet(elem);
-      }
-    }
+    const { has, addToSet, delete: del, addAllToSet } = collection;
 
     const weakSetStore = {
       has,
       add: addToSet,
-      addAll,
       delete: del,
+      addAll: addAllToSet,
     };
     return Far('weakSetStore', weakSetStore);
   }

package/test/test-collections.js

@@ -3,6 +3,7 @@ import '@endo/init/debug.js';
 
 import { Far } from '@endo/marshal';
 import { M } from '@agoric/store';
+import { makeCopyMap, makeCopySet } from '@endo/patterns';
 import { makeFakeCollectionManager } from '../tools/fakeVirtualSupport.js';
 
 const {
@@ -191,6 +192,89 @@ test('basic weak set operations', t => {
   );
 });
 
+function exerciseSetAddAll(t, weak, testStore) {
+  const allThatStuff = stuff.map(entry => entry[0]);
+
+  testStore.addAll(allThatStuff);
+  for (const elem of allThatStuff) {
+    t.truthy(testStore.has(elem));
+    testStore.delete(elem);
+  }
+  if (!weak) {
+    t.is(testStore.getSize(), 0);
+  }
+
+  testStore.addAll(makeCopySet(allThatStuff));
+  for (const elem of allThatStuff) {
+    t.truthy(testStore.has(elem));
+    testStore.delete(elem);
+  }
+  if (!weak) {
+    t.is(testStore.getSize(), 0);
+  }
+
+  t.throws(
+    () => testStore.addAll({ bogus: 47 }),
+    m(/provided data source is not iterable/),
+  );
+}
+
+test('set addAll', t => {
+  exerciseSetAddAll(t, false, makeScalarBigSetStore('test set'));
+});
+
+test('weak set addAll', t => {
+  exerciseSetAddAll(t, true, makeScalarBigWeakSetStore('test weak set'));
+});
+
+test('set snapshot', t => {
+  const testStore = makeScalarBigSetStore('test set');
+  const allThatStuff = stuff.map(entry => entry[0]);
+  testStore.addAll(allThatStuff);
+  t.deepEqual(testStore.snapshot(), makeCopySet(allThatStuff));
+});
+
+function exerciseMapAddAll(t, weak, testStore) {
+  testStore.addAll(stuff);
+  for (const [k, v] of stuff) {
+    t.truthy(testStore.has(k));
+    t.is(testStore.get(k), v);
+    testStore.delete(k);
+  }
+  if (!weak) {
+    t.is(testStore.getSize(), 0);
+  }
+
+  testStore.addAll(makeCopyMap(stuff));
+  for (const [k, v] of stuff) {
+    t.truthy(testStore.has(k));
+    t.is(testStore.get(k), v);
+    testStore.delete(k);
+  }
+  if (!weak) {
+    t.is(testStore.getSize(), 0);
+  }
+
+  t.throws(
+    () => testStore.addAll({ bogus: 47 }),
+    m(/provided data source is not iterable/),
+  );
+}
+
+test('map addAll', t => {
+  exerciseMapAddAll(t, false, makeScalarBigMapStore('test map'));
+});
+
+test('weak map addAll', t => {
+  exerciseMapAddAll(t, true, makeScalarBigWeakMapStore('test weak map'));
+});
+
+test('map snapshot', t => {
+  const testStore = makeScalarBigMapStore('test map');
+  testStore.addAll(stuff);
+  t.deepEqual(testStore.snapshot(), makeCopyMap(stuff));
+});
+
 test('constrain map key shape', t => {
   const stringsOnly = makeScalarBigMapStore('map key strings only', {
     keyShape: M.string(),
@@ -766,13 +850,6 @@ test('set queries', t => {
     symbolKrusty,
     undefined,
   ]);
-
-  // @ts-expect-error our BigSetStore has .entries, but not the SetStore type
-  t.deepEqual(Array.from(testStore.entries(M.number())), [
-    [-29, -29],
-    [3, 3],
-    [47, 47],
-  ]);
 });
 
 test('remotable sort order', t => {