odx_pdu_hexarray/HexArray.js

Used to Handle Hex Arrays

const translator = require("./translator");

function HexArray(arr) {
  this.hexarray = arr;

  this.insertData = (data, translation) => {
    switch (translation.type) {
      case "hexdump":
        if (
          translation.bitPosition !== 0 &&
          translation.bitPosition !== undefined
        )
          throw new Error("bitPosition in getHexDump not supported");
        if (translation.bitLength !== data.length * 8)
          throw new Error("bitLength does not match Data Length");
        this.hexarray.splice(
          translation.bytePosition,
          parseInt(translation.bitLength / 8),
          ...data
        );
        break;
      case "physical":
      default:
        // console.log(translation);
        const internalData = translator.toInternal(data, translation);
        // console.log(internalData);
        this.insert(
          translation.bytePosition,
          translation.bitPosition || 0,
          translation.bitLength,
          internalData
        );
        break;
    }
    console.log("pdu", this.hexarray);
    return this;
  };

  this.insert = (bytePosition, bitPosition, length, data) => {
    const bytecount = Math.ceil((bitPosition + length) / 8);
    const mask = ((1 << length) - 1) << bitPosition;
    const shiftedData = data << bitPosition;
    let maskedShiftedData = shiftedData & mask;
    for (
      let index = bytePosition + bytecount - 1;
      index >= bytePosition;
      index--
    ) {
      this.hexarray[index] = this.hexarray[index] | (maskedShiftedData & 0xff);
      maskedShiftedData = maskedShiftedData >> 8;
    }
    return this;
  };
  this.getRaw = (bytePosition, bitPosition, length) => {
    const bytecount = Math.ceil((bitPosition + length) / 8);
    const mask = ((1 << length) - 1) << bitPosition;
    let raw = BigInt(0);
    for (let index = bytePosition; index < bytePosition + bytecount; index++) {
      raw = (raw << BigInt(8)) | BigInt(this.hexarray[index] & 0xff);
    }
    raw &= BigInt(mask);
    raw = raw >> BigInt(bitPosition);
    return raw;
  };

  this.getTranslated = dictionary => {
    let res = {};
    dictionary.forEach(({ name, translation }) => {
      switch (translation.type) {
        case "hexdump":
          res[name] = this.getHexDump(translation);
          break;
        case "physical":
        default:
          res[name] = this.getPhysical(translation);
      }
    });
    return res;
  };

  this.getPhysical = translation => {
    const internal = this.getRaw(
      translation.bytePosition,
      translation.bitPosition || 0,
      translation.bitLength
    );
    return translator.toPhysical(internal, translation);
  };

  this.getHexDump = ({ bytePosition, bitPosition, bitLength }) => {
    if (bitPosition !== 0 && bitPosition !== undefined)
      throw new Error("bitPosition in getHexDump not supported");
    if (bitLength % 8)
      throw new Error(
        "length in getHexDump not supported (not a complete Byte)"
      );
    const bytes = parseInt(bitLength / 8);
    return this.hexarray.slice(bytePosition, bytePosition + bytes);
  };
  this.get = () => {
    return this.hexarray;
  };
}
module.exports = HexArray;