Build with rntuple new features

Author: linev

build/jsroot.js

@@ -164607,7 +164607,11 @@ function objectHierarchy(top, obj, args = undefined) {
                }
             }
          }
-      } else if ((typeof fld === 'number') || (typeof fld === 'boolean') || (typeof fld === 'bigint')) {
+      } else if (typeof fld === 'bigint') {
+         simple = true;
+         item._value = fld.toString() + 'n';
+         item._vclass = cssValueNum;
+      } else if ((typeof fld === 'number') || (typeof fld === 'boolean')) {
          simple = true;
          if (key === 'fBits')
             item._value = '0x' + fld.toString(16);
@@ -177778,7 +177782,6 @@ class RNTupleDescriptorBuilder {
          throw new Error('RNTuple corrupted: header checksum does not match footer checksum.');
 
       const schemaExtensionSize = reader.readS64();
-
       if (schemaExtensionSize < 0)
          throw new Error('Schema extension frame is not a record frame, which is unexpected.');
 
@@ -177835,14 +177838,12 @@ class RNTupleDescriptorBuilder {
             fieldListSize = reader.readS64(), // signed 64-bit
             fieldListIsList = fieldListSize < 0;
 
-
       if (!fieldListIsList)
          throw new Error('Field list frame is not a list frame, which is required.');
 
       const fieldListCount = reader.readU32(), // number of field entries
-         // List frame: list of field record frames
+            fieldDescriptors = []; // List frame: list of field record frames
 
-            fieldDescriptors = [];
       for (let i = 0; i < fieldListCount; ++i) {
          const recordStart = BigInt(reader.offset),
                fieldRecordSize = reader.readS64(),
@@ -178344,18 +178345,18 @@ class ReaderItem {
             this.buf = new DataView(new ArrayBuffer(4), 0);
             break;
          case kReal32Trunc:
+            this.buf = new DataView(new ArrayBuffer(4), 0);
+            // eslint-disable-next-line  no-fallthrough
          case kReal32Quant:
             this.nbits = this.column.bitsOnStorage;
-            if (this.coltype === kReal32Trunc)
-               this.buf = new DataView(new ArrayBuffer(4), 0);
-            else {
+            if (!this.buf) {
                this.factor = (this.column.maxValue - this.column.minValue) / ((1 << this.nbits) - 1);
                this.min = this.column.minValue;
             }
 
             this.func = function(obj) {
                let res = 0, len = this.nbits;
-               // extract nbits from the
+               // extract nbits from the stream
                while (len > 0) {
                   if (this.o2 === 0) {
                      this.byte = this.view.getUint8(this.o);
@@ -178610,6 +178611,42 @@ class ArrayReaderItem extends ReaderItem {
 }
 
 
+/** @class reading of std::bitset<N>
+ * @desc large numbers with more than 48 bits converted to BigInt
+ * @private */
+
+class BitsetReaderItem extends ReaderItem {
+
+   constructor(items, tgtname, size) {
+      super(items, tgtname);
+      this.size = size;
+      items[0].set_not_simple();
+      this.bigint = size > 48;
+   }
+
+   func(tgtobj) {
+      const tmp = {};
+      let len = 0, res = this.bigint ? 0n : 0;
+      while (len < this.size) {
+         this.items[0].func(tmp);
+         if (tmp.bit) {
+            if (this.bigint)
+               res |= (1n << BigInt(len));
+            else
+               res |= 1 << len;
+         }
+         len++;
+      }
+      tgtobj[this.name] = res;
+   }
+
+   shift(entries) {
+      this.items[0].shift(entries * this.size);
+   }
+
+}
+
+
 /** @class reading std::vector and other kinds of collections
  * @private */
 
@@ -178657,7 +178694,6 @@ class VariantReaderItem extends ReaderItem {
 
    constructor(items, tgtname) {
       super(items, tgtname);
-      this.items = items;
       this.set_not_simple();
    }
 
@@ -178691,6 +178727,29 @@ class TupleReaderItem extends ReaderItem {
 
 }
 
+/** @class reading custom class field
+  * @private */
+
+class CustomClassReaderItem extends ReaderItem {
+
+   constructor(items, tgtname, classname) {
+      super(items, tgtname);
+      this.classname = classname;
+      this.set_not_simple();
+   }
+
+   func(tgtobj) {
+      const obj = { _typename: this.classname };
+      this.items.forEach(item => item.func(obj));
+      tgtobj[this.name] = obj;
+   }
+
+   shift(entries) {
+      this.items.forEach(item => item.shift(entries));
+   }
+
+}
+
 
 /** @class reading std::pair field
  * @private */
@@ -178726,7 +178785,7 @@ async function rntupleProcess(rntuple, selector, args = {}) {
       lastentry: 0    // last entry in the rntuple
    };
 
-   function readNextPortion(inc_cluster) {
+   function readNextPortion(builder, inc_cluster) {
       let do_again = true, numClusterEntries, locations;
 
       while (do_again) {
@@ -178735,13 +178794,13 @@ async function rntupleProcess(rntuple, selector, args = {}) {
             handle.current_cluster_first_entry = handle.current_cluster_last_entry;
          }
 
-         locations = rntuple.builder.pageLocations[handle.current_cluster];
+         locations = builder.pageLocations[handle.current_cluster];
          if (!locations) {
             selector.Terminate(true);
             return selector;
          }
 
-         numClusterEntries = rntuple.builder.clusterSummaries[handle.current_cluster].numEntries;
+         numClusterEntries = builder.clusterSummaries[handle.current_cluster].numEntries;
 
          handle.current_cluster_last_entry = handle.current_cluster_first_entry + numClusterEntries;
 
@@ -178804,7 +178863,7 @@ async function rntupleProcess(rntuple, selector, args = {}) {
             }
          }
 
-         return readNextPortion(true);
+         return readNextPortion(builder, true);
       });
    }
 
@@ -178815,28 +178874,39 @@ async function rntupleProcess(rntuple, selector, args = {}) {
       return item;
    }
 
-   function addFieldReading(field, tgtname) {
-      const columns = rntuple.builder.findColumns(field),
-            childs = rntuple.builder.findChildFields(field);
+   function addFieldReading(builder, field, tgtname) {
+      const columns = builder.findColumns(field),
+            childs = builder.findChildFields(field);
       if (!columns?.length) {
          if ((childs.length === 2) && (field.typeName.indexOf('std::pair') === 0)) {
-            const item1 = addFieldReading(childs[0], 'first'),
-                  item2 = addFieldReading(childs[1], 'second');
+            const item1 = addFieldReading(builder, childs[0], 'first'),
+                  item2 = addFieldReading(builder, childs[1], 'second');
             return new PairReaderItem([item1, item2], tgtname);
          }
 
          if ((childs.length === 1) && (field.typeName.indexOf('std::array') === 0)) {
-            const item1 = addFieldReading(childs[0], 'value');
+            const item1 = addFieldReading(builder, childs[0], 'value');
             return new ArrayReaderItem([item1], tgtname, Number(field.arraySize));
          }
 
+         if ((childs.length === 1) && (field.typeName.indexOf('std::atomic') === 0))
+            return addFieldReading(builder, childs[0], tgtname);
+
+
          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}`));
+               items.push(addFieldReading(builder, childs[i], `_${i}`));
             return new TupleReaderItem(items, tgtname);
          }
 
+         if ((childs.length > 0) && field.checksum && field.typeName) {
+            const items = [];
+            for (let i = 0; i < childs.length; ++i)
+               items.push(addFieldReading(builder, childs[i], childs[i].fieldName));
+            return new CustomClassReaderItem(items, tgtname, field.typeName);
+         }
+
          throw new Error(`No columns found for field '${field.fieldName}' in RNTuple`);
       }
 
@@ -178846,6 +178916,12 @@ async function rntupleProcess(rntuple, selector, args = {}) {
          return new StringReaderItem([itemlen, itemstr], tgtname);
       }
 
+      if ((columns.length === 1) && (field.typeName.indexOf('std::bitset') === 0)) {
+         const itembit = addColumnReadout(columns[0], 'bit');
+         return new BitsetReaderItem([itembit], tgtname, Number(field.arraySize));
+      }
+
+
       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)
@@ -178854,22 +178930,22 @@ async function rntupleProcess(rntuple, selector, args = {}) {
 
       if ((childs.length === 1) && is_stl) {
          const itemlen = addColumnReadout(columns[0], 'len'),
-               itemval = addFieldReading(childs[0], 'val');
+               itemval = addFieldReading(builder, childs[0], 'val');
          return new CollectionReaderItem([itemlen, itemval], tgtname);
       }
 
       if ((childs.length > 0) && (field.typeName.indexOf('std::variant') === 0)) {
          const items = [addColumnReadout(columns[0], 'switch')];
          for (let i = 0; i < childs.length; ++i)
-            items.push(addFieldReading(childs[i], tgtname));
+            items.push(addFieldReading(builder, childs[i], tgtname));
          return new VariantReaderItem(items, tgtname);
       }
 
       return addColumnReadout(columns[0], tgtname);
    }
 
-   return readHeaderFooter(rntuple).then(res => {
-      if (!res)
+   return readHeaderFooter(rntuple).then(builder => {
+      if (!builder)
          throw new Error('Not able to read header for the RNtuple');
 
       for (let i = 0; i < selector.numBranches(); ++i) {
@@ -178879,16 +178955,16 @@ async function rntupleProcess(rntuple, selector, args = {}) {
          if (!name)
             throw new Error(`Not able to extract name for field ${i}`);
 
-         const field = rntuple.builder.findField(name);
+         const field = builder.findField(name);
          if (!field)
             throw new Error(`Field ${name} not found`);
 
-         const item = addFieldReading(field, tgtname);
+         const item = addFieldReading(builder, field, tgtname);
          handle.arr.push(item);
       }
 
       // calculate number of entries
-      rntuple.builder.clusterSummaries.forEach(summary => { handle.lastentry += summary.numEntries; });
+      builder.clusterSummaries.forEach(summary => { handle.lastentry += summary.numEntries; });
 
       if (handle.firstentry >= handle.lastentry)
          throw new Error('Not able to find entries in the RNtuple');
@@ -178912,8 +178988,8 @@ async function rntupleProcess(rntuple, selector, args = {}) {
          handle.process_max = Math.min(handle.process_max, handle.process_min + args.numentries);
 
       // first check from which cluster one should start
-      for (let indx = 0, emin = 0; indx < rntuple.builder.clusterSummaries.length; ++indx) {
-         const summary = rntuple.builder.clusterSummaries[indx],
+      for (let indx = 0, emin = 0; indx < builder.clusterSummaries.length; ++indx) {
+         const summary = builder.clusterSummaries[indx],
                emax = emin + summary.numEntries;
          if ((handle.process_min >= emin) && (handle.process_min < emax)) {
             handle.current_cluster = indx;
@@ -178930,7 +179006,7 @@ async function rntupleProcess(rntuple, selector, args = {}) {
 
       selector.Begin(rntuple);
 
-      return readNextPortion();
+      return readNextPortion(builder);
    }).then(() => selector);
 }
 
@@ -178977,8 +179053,8 @@ async function rntupleDraw(rntuple, args) {
    args.SelectorClass = TDrawSelectorTuple;
    args.processFunction = rntupleProcess;
 
-   return readHeaderFooter(rntuple).then(res_header_footer => {
-      return res_header_footer ? treeDraw(rntuple, args) : null;
+   return readHeaderFooter(rntuple).then(builder => {
+      return builder ? treeDraw(rntuple, args) : null;
    });
 }
 
@@ -178989,12 +179065,8 @@ async function rntupleDraw(rntuple, args) {
 async function tupleHierarchy(tuple_node, tuple) {
    tuple_node._childs = [];
    // tuple_node._tuple = tuple;  // set reference, will be used later by RNTuple::Draw
-
-   return readHeaderFooter(tuple).then(res => {
-      if (!res)
-         return res;
-
-      tuple.builder?.fieldDescriptors.forEach((field, indx) => {
+   return readHeaderFooter(tuple).then(builder => {
+      builder?.fieldDescriptors.forEach((field, indx) => {
          if (field.parentFieldId !== indx)
             return;
          const item = {
@@ -179005,13 +179077,10 @@ async function tupleHierarchy(tuple_node, tuple) {
             $tuple: tuple, // reference on tuple, need for drawing
             $field: field
          };
-
          item._obj = item;
-
          tuple_node._childs.push(item);
       });
-
-      return true;
+      return Boolean(builder);
    });
 }