Source: BinaryArray.js

  1. /** Class for returning array members from {@link Binary} objects */
  2. class BinaryArrayBase {
  3.   // @member
  4.   type
  5.   // @member
  6.   dv
  7.   // @member
  8.   offset
  9.   // @member
  10.   length
  11.   // @member
  12.   bytes
  14.   /**
  15.    * Creates a new customized array
  16.    * @param {DataView} dv - The DataView handling the buffer where the data lives
  17.    * @param {object} type - The type of the array members from {@link Types}
  18.    * @param {number} offset - The offset of the first member of the array into the buffer
  19.    * @param {number} length - The length of the array
  20.    */
  21.   constructor (dv, type, offset, length) {
  22.     this.type = type
  23.     this.dv = dv
  24.     this.offset = offset
  25.     this.length = length
  26.     this.bytes = length * type.bytes
  27.   }
  29.   /**
  30.    * Proxy array methods using this iterator
  31.    * @param {function} fn - The function to apply on the array elements
  32.    * @return {array} - The new generated array (not bound to original values)
  33.    * @method
  34.    */
  35.   map = (fn) => Array.from(this, fn)
  36.   // reduce = (...args) => Array.prototype.reduce.call([...this], ...args);
  38.   /**
  39.    * Transform this array into a JSON string
  40.    * @return {string} - The JSON string representing this array
  41.    * @method
  42.    */
  43.   toJSON = () => JSON.parse(JSON.stringify(this.map()));
  45.   /**
  46.    * Make a generator iterator
  47.    * @method
  48.    * @generator
  49.    * @function iterator
  50.    * @yield {any} - Each of this array elements of type {@link Types}
  51.    * @name iterator
  52.    */
  53.   * [Symbol.iterator] () {
  54.     // Deconstruct to optimize and ease reading
  55.     const {
  56.       length,
  57.       dv,
  58.       offset,
  59.       type: { get, bytes }
  60.     } = this
  62.     // Use a new index for each iterator. This makes multiple
  63.     // iterations over the iterable safe for non-trivial cases,
  64.     // such as use of break or nested looping over the same iterable.
  65.     for (let index = 0; index < length; index++) {
  66.       yield get(dv, offset + bytes * index)
  67.     }
  68.   }
  69. }
  71. /**
  72.  * A Proxy handler for the {@link BinaryArray} class to allow accessing its elements
  73.  * @enum
  74.  */
  75. const BinaryArrayHandler = {
  76.   /**
  77.    * Getter for the elements of the handled {@link BinaryArray}
  78.    * @param {BinaryArray} target - The handled {@link BinaryArray} instance
  79.    * @param {string} prop - The property to return (only handled when prop is a string representing a number)
  80.    * @return {any} - The element at {@link prop} position, or a reflected value from {@link target}
  81.    */
  82.   get (target, prop) {
  83.     // Very inefficient way
  84.     // Need to:
  85.     //  - Override Array internals, but are private
  86.     //  - Override `[]` operator, but it's not possible
  87.     if (prop === '0' || (typeof prop === 'string' && Number(prop) > 0)) {
  88.       // Destructure to optimize
  89.       const {
  90.         dv,
  91.         offset,
  92.         type: { get, bytes }
  93.       } = target
  94.       return get(dv, offset + bytes * Number(prop))
  95.     }
  97.     // Return original value
  98.     return Reflect.get(target, prop)
  99.   },
  101.   /**
  102.    * Setter for the elements of the handled {@link BinaryArray}
  103.    * @param {BinaryArray} target - The handled {@link BinaryArray} instance
  104.    * @param {string} prop - The property to set (only handled when prop is a string representing a number)
  105.    * @param {any} value - The value to assign to the {@link prop}'th element
  106.    * @return {boolean} - If {@link prop} is numericalish, true (as needed for JS setters), else the return value from the {@link target} reflected setter
  107.    */
  108.   set (target, prop, value) {
  109.     if (prop === '0' || (typeof prop === 'string' && Number(prop) > 0)) {
  110.       // Destructure to optimize
  111.       const {
  112.         dv,
  113.         offset,
  114.         type: { set, bytes }
  115.       } = target
  116.       set(dv, offset + bytes * Number(prop), value)
  117.       return true
  118.     }
  119.     return Reflect.set(target, prop, value)
  120.   }
  121. }
  123. // #TODO: BUG: Argument Spread Operator not working
  124. //             well when packing with webpack
  125. /**
  126.  * Proxy creator for {@link BinaryArrayBase}
  127.  * @param {DataView} dv - The DataView handling the buffer where the data lives
  128.  * @param {object} type - The type of the array members from {@link Types}
  129.  * @param {number} offset - The offset before the first member of the array
  130.  * @param {number} length - The length of the array
  131.  * @return {Proxy} - The proxy to {@link BinaryArrayBase} with {@link BinaryArrayHandler} as proxy handler
  132.  */
  133. const BinaryArray = (dv, type, offset, length) => {
  134.   return new Proxy(
  135.     new BinaryArrayBase(dv, type, offset, length),
  136.     BinaryArrayHandler
  137.   )
  138. }
  140. export default BinaryArray