Build with double vector support

Author: linev

build/jsroot.js

@@ -126542,7 +126542,7 @@ class TDrawSelector extends TSelector {
          this.leaf = args.leaf;
 
          // branch object remains, therefore we need to copy fields to see them all
-         this.copy_fields = ((args.branch.fLeaves?.arr.length > 1) || args.branch.fBranches?.arr.length) && !args.leaf;
+         this.copy_fields = args.copy_fields ?? (((args.branch.fLeaves?.arr.length > 1) || args.branch.fBranches?.arr.length) && !args.leaf);
 
          this.addBranch(branch, 'br0', args.direct_branch); // add branch
 
@@ -178256,9 +178256,20 @@ class RNTupleDescriptorBuilder {
       }
    }
 
+   /** @summary Return all childs of specified field */
+   findChildFields(field) {
+      const indx = this.fieldDescriptors.indexOf(field), res = [];
+      for (let n = 0; n < this.fieldDescriptors.length; ++n) {
+         const fld = this.fieldDescriptors[n];
+         if ((fld !== field) && (fld.parentFieldId === indx))
+            res.push(fld);
+      }
+      return res;
+   }
+
    /** @summary Return array of columns for specified field */
-   findColumns(name) {
-      const res = [], field = this.findField(name);
+   findColumns(field) {
+      const res = [];
       if (!field)
          return res;
       for (const colDesc of this.columnDescriptors) {
@@ -178268,6 +178279,7 @@ class RNTupleDescriptorBuilder {
       return res;
    }
 
+
 } // class RNTupleDescriptorBuilder
 
 
@@ -178359,11 +178371,13 @@ class ReaderItem {
       this.page = -1; // current page for the reading
       this.name = name;
       this.sz = 0;
+      this.simple = true;
 
       // special handling of split types
       if ((this.coltype >= ENTupleColumnType.kSplitInt16) && (this.coltype <= ENTupleColumnType.kSplitIndex64)) {
          this.splittype = this.coltype;
          this.coltype -= (ENTupleColumnType.kSplitInt16 - ENTupleColumnType.kInt16);
+         this.simple = false;
       }
    }
 
@@ -178403,8 +178417,13 @@ class ReaderItem {
       }
    }
 
-   /** @summary Simple column which fixed element size */
-   is_simple() { return this.sz > 0; }
+   /** @summary Simple column with fixed element size - no vectors, no strings */
+   is_simple() { return this.sz > 0 && this.simple; }
+
+   set_simple(flag) {
+      this.simple = flag;
+      this.item1?.set_simple(flag);
+   }
 
    assignReadFunc() {
       switch (this.coltype) {
@@ -178508,13 +178527,17 @@ class ReaderItem {
    }
 
    /** @summary identify if this item used as offset for std::string or similar */
-   is_offset_item() { return this.item1; }
+   is_offset_item() { return (this.func0 && this.shift0) || (this.shiftn && this.funcn); }
 
+   /** @summary implements reading of std::string where item1 provides offsets */
    assignStringReader(item1) {
       this.item1 = item1;
       this.off0 = 0;
       this.$tgt = {};
 
+      this.simple = false;
+      // for plain string one can read offsets
+
       item1.func0 = item1.func;
       item1.shift0 = item1.shift;
 
@@ -178535,14 +178558,55 @@ class ReaderItem {
 
       this.shift = function(entries) {
          if (entries > 0) {
-            this.item1.shift0(entries);
+            this.item1.shift0(entries - 1);
             this.item1.func0(this.$tgt);
             this.off0 = Number(this.$tgt[this.name]);
             this.shift_o(this.off0);
          }
       };
    }
 
+   /** @summary implement reading of std::vector where itemv provides element reading */
+   assignVectorReader(itemv) {
+      this.itemv = itemv;
+      this.offv0 = 0;
+
+      itemv.funcv = itemv.func;
+      itemv.shiftv = itemv.shift;
+      // assign noop
+      itemv.func = itemv.shift = () => {};
+
+      // item itself can remain simple
+      itemv.set_simple(false);
+
+      // remember own read function - they need to be used
+      this.funcn = this.func;
+      this.shiftn = this.shift;
+
+      this.func = function(tgtobj) {
+         const arr = [], tmp = {};
+         this.funcn(tmp);
+         const offv = Number(tmp[this.name]);
+         let len = offv - this.offv0;
+         while (len-- > 0) {
+            this.itemv.funcv(tmp);
+            arr.push(tmp[this.name]);
+         }
+         tgtobj[this.name] = arr;
+         this.offv0 = offv;
+      };
+
+      this.shift = function(entries) {
+         if (entries > 0) {
+            const tmp = {};
+            this.shiftn(entries - 1);
+            this.funcn(tmp);
+            this.offv0 = Number(tmp[this.name]);
+            this.itemv.shiftv(this.offv0);
+         }
+      };
+   }
+
    collectPages(cluster_locations, dataToRead, itemsToRead, pagesToRead, emin, emax, elist) {
       const pages = cluster_locations[this.id].pages;
 
@@ -178552,13 +178616,13 @@ class ReaderItem {
       for (let p = 0; p < pages.length; ++p) {
          const page = pages[p],
                e1 = e0 + Number(page.numElements),
-               margin = this.is_offset_item() ? 1 : 0; // offset for previous entry has to be read as well
-
+               margin = this.is_offset_item() ? 1 : 0, // offset for previous entry has to be read as well
+               is_inside = (e, beg, end) => (e >= beg) && (e < end + margin);
          let is_entries_inside = false;
          if (elist?.length)
-            elist.forEach(e => { is_entries_inside ||= (e >= e0) && (e - margin < e1); });
+            elist.forEach(e => { is_entries_inside ||= is_inside(e, e0, e1); });
          else
-            is_entries_inside = ((e0 >= emin - margin) && (e0 < emax)) || ((e1 > emin - margin) && (e1 <= emax));
+            is_entries_inside = is_inside(e0, emin, emax) || is_inside(e1, emin, emax) || is_inside(emin, e0, e1) || is_inside(emax, e0, e1);
 
          if (!this.is_simple() || is_entries_inside) {
             itemsToRead.push(this);
@@ -178707,29 +178771,46 @@ async function rntupleProcess(rntuple, selector, args = {}) {
       });
    }
 
+   function addFieldReading(field, tgtname) {
+      const columns = rntuple.builder.findColumns(field);
+      if (!columns?.length)
+         throw new Error(`No columns found for field '${field.fieldName}' in RNTuple`);
+
+      let item = new ReaderItem(columns[0], tgtname);
+      item.assignReadFunc();
+      handle.arr.push(item);
+
+      if ((columns.length === 2) && (field.typeName === 'std::string')) {
+         const items = new ReaderItem(columns[1], tgtname);
+         items.assignStringReader(item);
+         handle.arr.push(items);
+         item = items; // second item performs complete reading of the string
+      }
+
+      const childs = rntuple.builder.findChildFields(field);
+      if ((childs.length === 1) && (field.typeName.indexOf('std::vector') === 0)) {
+         const itemv = addFieldReading(childs[0], tgtname);
+         item.assignVectorReader(itemv);
+      }
+
+      return item;
+   }
+
    return readHeaderFooter(rntuple).then(res => {
       if (!res)
          throw new Error('Not able to read header for the RNtuple');
 
       for (let i = 0; i < selector.numBranches(); ++i) {
-         const name = getSelectorFieldName(selector, i);
+         const name = getSelectorFieldName(selector, i),
+               tgtname = selector.nameOfBranch(i);
          if (!name)
             throw new Error(`Not able to extract name for field ${i}`);
 
-         const columns = rntuple.builder.findColumns(name);
-         if (!columns?.length)
-            throw new Error(`No columns found for field '${name}' in RNTuple`);
-
-         const tgtname = selector.nameOfBranch(i),
-               item = new ReaderItem(columns[0], tgtname);
-         item.assignReadFunc();
-         handle.arr.push(item);
+         const field = rntuple.builder.findField(name);
+         if (!field)
+            throw new Error(`Field ${name} not found`);
 
-         if (columns.length === 2) {
-            const item2 = new ReaderItem(columns[1], tgtname);
-            item2.assignStringReader(item);
-            handle.arr.push(item2);
-         }
+         addFieldReading(field, tgtname);
       }
 
       // calculate number of entries
@@ -178877,13 +178958,15 @@ async function drawRNTuple(dom, obj, opt) {
    const args = {};
    let tuple;
 
-   if (obj?.$tuple) {
+   if (obj?.$tuple && obj.$field) {
       // case of fictional ROOT::RNTupleField
       tuple = obj.$tuple;
       args.expr = obj._name;
-      if (isStr(opt) && opt.indexOf('dump') === 0)
+      if (isStr(opt) && opt.indexOf('dump') === 0) {
          args.expr += '>>' + opt;
-      else if (opt)
+         args.branch = obj.$field;
+         args.copy_fields = false; // no need to copy fields, reading is simple
+      } else if (opt)
          args.expr += opt;
    } else {
       tuple = obj;