Build with more supported cases in tuple

Author: linev

build/jsroot.js

@@ -177541,6 +177541,7 @@ const ENTupleColumnType = {
    kReal64: 0x0D,
    kIndex32: 0x0E,
    kIndex64: 0x0F,
+   kSwitch: 0x10,
    kSplitInt16: 0x11,
    kSplitUInt16: 0x12,
    kSplitInt32: 0x13,
@@ -177683,6 +177684,17 @@ function DecodeDeltaIndex(blob, coltype) {
    return { blob: result, coltype };
 }
 
+function DecodeSwitchIndex(src) {
+   let o = 0, prev = BigInt(0);
+   while (o < src.byteLength) {
+      const v = prev + src.getBigInt64(o, LITTLE_ENDIAN);
+      src.setBigInt64(o, prev, LITTLE_ENDIAN);
+      prev = v;
+      o += 12;
+   }
+   return src;
+}
+
 /**
  * @summary Decode a reconstructed signed integer buffer using ZigZag encoding
   */
@@ -178414,7 +178426,7 @@ class ReaderItem {
    }
 
    shift(entries) {
-      if (this.sz)
+      if (this.sz && this.simple)
          this.shift_o(this.sz * entries);
       else {
          while (entries-- > 0)
@@ -178475,6 +178487,16 @@ class ReaderItem {
             };
             this.sz = 8;
             break;
+         case ENTupleColumnType.kSwitch:
+            this.func = function(obj) {
+               // index not used in std::variant, may be in some other usecases
+               // obj[this.name] = Number(this.view.getBigInt64(this.o, LITTLE_ENDIAN));
+               this.shift_o(8); // skip value, not used yet
+               obj[this.name] = this.view.getInt32(this.o, LITTLE_ENDIAN);
+               this.shift_o(4);
+            };
+            this.sz = 12;
+            break;
          case ENTupleColumnType.kInt32:
          case ENTupleColumnType.kIndex32:
             this.func = function(obj) {
@@ -178612,6 +178634,74 @@ class ReaderItem {
       };
    }
 
+   /** @summary implement reading of std::array<T,N> where item1 reads value element */
+   assignArrayReader(itemv, arrsize) {
+      this.itemv = itemv;
+      this.arrsize = arrsize;
+
+      itemv.funcv = itemv.func;
+      itemv.shiftv = itemv.shift;
+      // assign noop
+      itemv.func = itemv.shift = () => {};
+
+      // item itself can remain simple
+      itemv.set_simple(false);
+
+      this.func = function(tgtobj) {
+         const arr = [], tmp = {};
+         let len = this.arrsize;
+         while (len-- > 0) {
+            this.itemv.funcv(tmp);
+            arr.push(tmp[this.name]);
+         }
+         tgtobj[this.name] = arr;
+      };
+
+      this.shift = function(entries) {
+         if (entries > 0)
+            this.itemv.shiftv(entries * this.arrsize);
+      };
+   }
+
+   /** @summary assign all childs fields for std::variant reader */
+   assignVariantReader(items) {
+      this.items = items;
+      items.forEach(item => {
+         item.funcV = item.func;
+         item.func = item.shift = () => {};
+         item.set_simple(false);
+      });
+      this.set_simple(false);
+
+      this.funcV = this.func;
+      this.func = function(tgtobj) {
+         const tmp = {};
+         this.funcV(tmp);
+         const id = tmp[this.name];
+         if (id === 0)
+            tgtobj[this.name] = null; // set null
+         else if (Number.isInteger(id) && (id > 0) && (id <= this.items.length))
+            this.items[id - 1].funcV(tgtobj);
+      };
+   }
+
+   /** @summary assign all childs fields for std::variant reader */
+   assignTupleReader(items) {
+      this.items = items;
+      items.forEach(item => {
+         item.funcV = item.func;
+         item.func = item.shift = () => {};
+         item.set_simple(false);
+      });
+      this.set_simple(false);
+
+      this.func = function(tgtobj) {
+         const tuple = {};
+         this.items.forEach(item => item.funcV(tuple));
+         tgtobj[this.name] = tuple;
+      };
+   }
+
    /** @summary implement reading of std::pair where item1 reads first (key) element */
    assignPairReader(item_p1, item_p2) {
       this.item_p1 = item_p1;
@@ -178708,6 +178798,8 @@ class ReaderItem {
       // Handle split index types
       if (originalColtype === ENTupleColumnType.kSplitIndex32 || originalColtype === ENTupleColumnType.kSplitIndex64)
          view = new DataView(DecodeDeltaIndex(data.blob, data.coltype).blob.buffer);
+      else if (originalColtype === ENTupleColumnType.kSwitch)
+         view = DecodeSwitchIndex(data.blob);
       // Handle Split Signed Int types
       else if (originalColtype === ENTupleColumnType.kSplitInt16 || originalColtype === ENTupleColumnType.kSplitInt32 || originalColtype === ENTupleColumnType.kSplitInt64)
          view = new DataView(decodeZigzag(data.blob, data.coltype).blob.buffer);
@@ -178822,6 +178914,24 @@ async function rntupleProcess(rntuple, selector, args = {}) {
             return item;
          }
 
+         if ((childs.length === 1) && (field.typeName.indexOf('std::array') === 0)) {
+            const item1 = addFieldReading(childs[0], tgtname),
+                  item = new ReaderItem(null, tgtname);
+            handle.arr.push(item);
+            item.assignArrayReader(item1, Number(field.arraySize));
+            return item;
+         }
+
+         if ((childs.length > 0) && (field.typeName.indexOf('std::tuple') === 0)) {
+            const items = [];
+            for (let i = 0; i < childs.length; ++i)
+               items.push(addFieldReading(childs[i], `_${i}`));
+            const item = new ReaderItem(null, tgtname);
+            handle.arr.push(item);
+            item.assignTupleReader(items);
+            return item;
+         }
+
          throw new Error(`No columns found for field '${field.fieldName}' in RNTuple`);
       }
 
@@ -178836,9 +178946,20 @@ async function rntupleProcess(rntuple, selector, args = {}) {
          return items; // second item performs complete reading of the string
       }
 
-      if ((childs.length === 1) && (field.typeName.indexOf('std::vector') === 0 || field.typeName.indexOf('std::map') === 0)) {
+      let is_stl = false;
+      ['vector', 'map', 'unordered_map', 'multimap', 'unordered_multimap', 'set', 'unordered_set', 'multiset', 'unordered_multiset'].forEach(name => {
+         if (field.typeName.indexOf('std::' + name) === 0)
+            is_stl = true;
+      });
+
+      if ((childs.length === 1) && is_stl) {
          const itemv = addFieldReading(childs[0], tgtname);
          item.assignCollectionReader(itemv);
+      } else if ((childs.length > 0) && (field.typeName.indexOf('std::variant') === 0)) {
+         const items = [];
+         for (let i = 0; i < childs.length; ++i)
+            items.push(addFieldReading(childs[i], tgtname));
+         item.assignVariantReader(items);
       }
 
       return item;

changes.md

@@ -2,7 +2,13 @@
 
 
 ## Changes in dev
-1. Support std collections like `std::vector` and `std::map` in `RNtuple`
+1. Implement new data types in `RNtuple`
+   - `std::vector`
+   - `std::map`, `std::unordered_map`, `std::multimap`, `std::unordered_multimap` with `std::pair`
+   - `std::set`, `std::unordered_set`, `std::multiset`, `std::unordered_multiset`
+   - `std::array`
+   - `std::variant`
+   - `std::tuple`
 1. Resort order of ranges in http request, fixing several long-standing problems #374
 1. Implement for `TPie` 3d, text, title drawing including interactivity
 1. Implement `TCanvas` support in `build3d` function #373