@machinemetrics/io-adapter-lib 2.32.0

package/lib/transform/toBuffer.js

@@ -0,0 +1,159 @@
+'use strict';
+
+const _ = require('lodash');
+const Buffer = require('buffer/').Buffer;
+const TransformState = require('./transformState');
+
+const TYPE_PATTERN = /(type=)?(?<type>((u?int)(8|16|32|64))|(float(32|64)?)|double|string)/i;
+const ORDER_PATTERN = /((order=)|(8|16|32|64|float|double)|,\s*|\s+)(?<order>be|le)(,|,?\s+|$)/i;
+
+const INT_TYPES = ['INT8', 'UINT8', 'INT16', 'UINT16', 'INT32', 'UINT32', 'INT64', 'UINT64'];
+const FLOAT_TYPES = ['FLOAT', 'FLOAT32', 'DOUBLE', 'FLOAT64'];
+const STRING_TYPES = ['STRING'];
+
+/**
+ * Converts a value to a buffer
+ */
+class ToBufferFilter extends TransformState {
+  constructor(spec) {
+    super();
+
+    this.spec = spec;
+    this.type = (this.matchPattern(spec, TYPE_PATTERN, 'type') ?? 'uint8').toUpperCase();
+    this.order = (this.matchPattern(spec, ORDER_PATTERN, 'order') ?? 'be').toUpperCase();
+  }
+
+  static op = 'to-buffer';
+
+  static create(args) {
+    return new ToBufferFilter(args.args.spec);
+  }
+
+  static parseConfig(configUtil, defn) {
+    const spec = _.get(defn.args, 'spec', defn.args[defn.func]);
+
+    defn.args = { spec };
+  }
+
+  filter(context, value, time) {
+    try {
+      if (_.isArray(value)) {
+        const buf = Buffer.concat(value.map(v => this.writeValue(v)));
+        this.commitValue(context, buf, time);
+      } else {
+        this.commitValue(context, this.writeValue(value), time);
+      }
+    } catch (err) {
+      this.recordError(context, err, time);
+      this.setUnavailable(context, time);
+    }
+  }
+
+  matchPattern(spec, pattern, group) {
+    const match = spec.match(pattern) ?? { };
+    return match?.groups?.[group];
+  }
+
+  writeValue(value) {
+    if (Buffer.isBuffer(value)) {
+      return value;
+    }
+
+    if (_.isString(value)) {
+      if (INT_TYPES.includes(this.type)) {
+        value = parseInt(value, 10);
+      } else if (FLOAT_TYPES.includes(this.type)) {
+        value = parseFloat(value);
+      }
+    } else if (STRING_TYPES.includes(this.type)) {
+      value = value.toString();
+    }
+
+    let buf;
+    switch (this.type) {
+      case 'INT8':
+        buf = Buffer.alloc(1);
+        buf.writeInt8(value, 0);
+        break;
+      case 'UINT8':
+        buf = Buffer.alloc(1);
+        buf.writeUInt8(value, 0);
+        break;
+      case 'INT16':
+        buf = Buffer.alloc(2);
+        if (this.order === 'BE') {
+          buf.writeInt16BE(value, 0);
+        } else {
+          buf.writeInt16LE(value, 0);
+        }
+        break;
+      case 'UINT16':
+        buf = Buffer.alloc(2);
+        if (this.order === 'BE') {
+          buf.writeUInt16BE(value, 0);
+        } else {
+          buf.writeUInt16LE(value, 0);
+        }
+        break;
+      case 'INT32':
+        buf = Buffer.alloc(4);
+        if (this.order === 'BE') {
+          buf.writeInt32BE(value, 0);
+        } else {
+          buf.writeInt32LE(value, 0);
+        }
+        break;
+      case 'UINT32':
+        buf = Buffer.alloc(4);
+        if (this.order === 'BE') {
+          buf.writeUInt32BE(value, 0);
+        } else {
+          buf.writeUInt32LE(value, 0);
+        }
+        break;
+      case 'INT64':
+        buf = Buffer.alloc(8);
+        if (this.order === 'BE') {
+          buf.writeBigInt64BE(value, 0);
+        } else {
+          buf.writeBigInt64LE(value, 0);
+        }
+        break;
+      case 'UINT64':
+        buf = Buffer.alloc(8);
+        if (this.order === 'BE') {
+          buf.writeBigUInt64BE(value, 0);
+        } else {
+          buf.writeBigUInt64LE(value, 0);
+        }
+        break;
+      case 'FLOAT':
+      case 'FLOAT32':
+        buf = Buffer.alloc(4);
+        if (this.order === 'BE') {
+          buf.writeFloatBE(value, 0);
+        } else {
+          buf.writeFloatLE(value, 0);
+        }
+        break;
+      case 'DOUBLE':
+      case 'FLOAT64':
+        buf = Buffer.alloc(8);
+        if (this.order === 'BE') {
+          buf.writeDoubleBE(value, 0);
+        } else {
+          buf.writeDoubleLE(value, 0);
+        }
+        break;
+      case 'STRING':
+        buf = Buffer.alloc(value.length);
+        buf.write(value, 0, value.length, 'utf8');
+        break;
+      default:
+        throw new Error(`Unsupported type: ${this.type}`);
+    }
+    return buf;
+  }
+}
+
+module.exports = ToBufferFilter;

package/lib/transform/toggle.js

@@ -0,0 +1,118 @@
+'use strict';
+
+const _ = require('lodash');
+const TransformState = require('./transformState');
+
+/**
+ * Alternates between T and F on every rising edge (F->T) transition
+ *
+ * For every incoming sample, the current toggle state will be emitted.  When a rising edge is found,
+ * the toggle will flip before the output value is emitted.
+ */
+class ToggleFilter extends TransformState {
+  constructor({ engine, path, args: { init = false, reset = {} } }) {
+    super();
+
+    this.engine = engine;
+    this.resetExpression = reset.compiledExpression;
+    this.resetSources = engine.expressionService.expressionTriggers(`${path}.reset`);
+
+    this.defaultValue = init;
+    this.initReset();
+  }
+
+  static op = 'toggle';
+
+  static create(args) {
+    return new ToggleFilter(args);
+  }
+
+  static parseConfig(configUtil, defn) {
+    configUtil.requireObjectParams(defn.args, this.op, {
+      optional: true,
+      availableAttributes: ['default', 'reset'],
+    });
+
+    let init = defn.args.default;
+    if (!_.isUndefined(init)) {
+      init = configUtil.parseBool(init);
+    }
+
+    let reset = defn.args.reset;
+    if (!_.isUndefined(reset)) {
+      try {
+        const expression = reset.toString();
+        const compiledExpression = configUtil.compileExpression(expression, this.op);
+        reset = { expression, compiledExpression };
+      } catch (err) {
+        configUtil.throwConfigError(`Problem evaluating expression: ${err.message}`, this.op);
+      }
+    }
+
+    defn.args = { init, reset };
+  }
+
+  static getExpressions(configUtil, body, info) {
+    return configUtil.getExpressions(body, { ...info, field: 'reset' });
+  }
+
+  initReset() {
+    this.value = this.defaultValue;
+    this.previousValue = this.defaultValue;
+    this.previousInputValue = this.defaultValue;
+    this.toggle = this.defaultValue;
+  }
+
+  update(context, value, time) {
+    this.lastSampleTime = time;
+    if (!this.available) {
+      this.available = true;
+      this.previousInputValue = value;
+
+      // Don't change when becoming available already in a high state
+      this.emitUpdate(context);
+      return;
+    }
+
+    this.filter(context, value, time);
+    this.emitUpdate(context);
+  }
+
+  filter(context, value, time) {
+    if (value && value !== this.previousInputValue) {
+      this.commitValue(context, !this.value, time);
+    }
+    this.previousInputValue = value;
+  }
+
+  emitUpdate(context) {
+    // While resetExpression evals true, force count to 0
+    if (this.resetExpression) {
+      const localState = { this: this.value };
+      const unavailTerm = this.resetSources.reduce((res, name) => {
+        const state = this.engine.getState(name);
+        localState[name] = state?.value;
+        return res || !state || !state.available;
+      }, false);
+
+      try {
+        if (!unavailTerm && this.resetExpression.evaluate(localState)) {
+          this.value = this.defaultValue;
+          this.emit('update', this.value, this.lastSampleTime, context);
+          return;
+        }
+      } catch (err) {
+        this.recordError(context, err, this.lastSampleTime);
+      }
+    }
+
+    super.emitUpdate(context);
+  }
+
+  setUnavailable(context, time) {
+    super.setUnavailable(context, time);
+    this.initReset();
+  }
+}
+
+module.exports = ToggleFilter;

package/lib/transform/transformState.js

@@ -0,0 +1,193 @@
+'use strict';
+
+const _ = require('lodash');
+const EventEmitter = require('eventemitter3');
+
+class TransformState extends EventEmitter {
+  constructor() {
+    super();
+
+    this.available = false;
+    this.forceEmit = false;
+    this.defaultValue = 0;
+    this.value = 0;
+    this.valueTime = -1;
+    this.previousValue = 0;
+    this.previousValueTime = -1;
+    this.lastSampleTime = -1;
+    this.lastEmitValue = -1;
+    this.lastEmitTime = -1;
+    this.pendingChangeTime = null;
+    this.next = null;
+    this.lastSuppliedValue = undefined;
+    this.lastError = null;
+    this.lastErrorTime = 0;
+    this.errorCount = 0;
+  }
+
+  static op = 'no-op';
+
+  static opAliases = [];
+
+  static parseConfig(_configUtil, _defn) {
+    // Each class implements its own static ParseConfig
+  }
+
+  static getExpressions(_configUtil, _body, _info) {
+    return [];
+  }
+
+  static getStringExpressions(_configUtil, _body, _info) {
+    return [];
+  }
+
+  // A transform state that supports pending (future) state changes not necessarily tied to a specific input
+  // should override this to return true.  For example, a transform that reverts its state to another value
+  // after 3 seconds may have a pending change.
+  supportsPendingChanges() {
+    return false;
+  }
+
+  // The exact time in the future that the transform's state should change if it receives no further input.
+  // If there is no pending change, return null.
+  // Optional time argument lets a transform decide if a pending change should still be reported based on the
+  // amount of time that has elapsed since the last update.
+  nextPendingChange(_time) {
+    return this.pendingChangeTime;
+  }
+
+  update(context, value, time) {
+    if (!this.available) {
+      this.available = true;
+      this.forceEmit = true;
+    }
+
+    this.lastSuppliedValue = value;
+    this.lastSampleTime = time;
+    this.filter(context, value, time);
+    if (this.available) {
+      this.emitUpdate(context);
+    }
+  }
+
+  probe(context, time) {
+    if (!_.isUndefined(this.lastSuppliedValue)) {
+      this.forceEmit = true;
+      this.lastSampleTime = time;
+      this.filter(context, this.lastSuppliedValue, time);
+      this.emitUpdate(context);
+    } else {
+      this.setUnavailable(context, time);
+    }
+  }
+
+  probeOrForward(context, time) {
+    if (!this.next) {
+      this.probe(context, time);
+      return;
+    }
+
+    const thisChange = this.nextPendingChange(time);
+    const nextChange = this.next.chainNextPendingChange(time);
+    if (nextChange && (!thisChange || nextChange < thisChange)) {
+      this.next.probeOrForward(context, time);
+    } else {
+      this.probe(context, time);
+    }
+  }
+
+  filter(context, value, time) {
+    this.commitValue(context, value, time);
+  }
+
+  commitValue(context, value, time) {
+    if (value !== this.value) {
+      this.previousValue = this.value;
+      this.previousValueTime = this.valueTime;
+      this.value = value;
+      this.valueTime = time;
+    }
+  }
+
+  setUnavailable(context, time) {
+    this.available = false;
+    this.previousValue = this.value;
+    this.previousValueTime = this.valueTime;
+    this.value = this.defaultValue;
+    this.valueTime = time;
+    this.emit('unavailable', time, context);
+  }
+
+  emitUpdate(context) {
+    if (this.forceEmit || this.value !== this.lastEmitValue || this.lastSampleTime !== this.lastEmitTime) {
+      this.forceEmit = false;
+      this.lastEmitValue = this.value;
+      this.lastEmitTime = this.lastSampleTime;
+      this.emit('update', this.value, this.lastSampleTime, context);
+    }
+  }
+
+  emitCommittedUpdate(context) {
+    if (this.forceEmit || this.value !== this.lastEmitValue || this.valueTime !== this.lastEmitTime) {
+      this.forceEmit = false;
+      this.lastEmitValue = this.value;
+      this.lastEmitTime = this.valueTime;
+      this.emit('update', this.value, this.valueTime, context);
+    }
+  }
+
+  chain(nextFilter) {
+    if (this.next) {
+      this.next.chain(nextFilter);
+    } else {
+      this.next = nextFilter;
+      this.on('update', (value, time, context) => nextFilter.update(context, value, time));
+      this.on('unavailable', (time, context) => nextFilter.setUnavailable(context, time));
+    }
+
+    return this;
+  }
+
+  chainEnd() {
+    if (this.next === null) {
+      return this;
+    }
+    return this.next.chainEnd();
+  }
+
+  chainSupportsPendingChange() {
+    if (this.supportsPendingChanges()) {
+      return true;
+    } else if (this.next) {
+      return this.next.chainSupportsPendingChange();
+    }
+    return false;
+  }
+
+  // Find the soonest pending change for all transforms remaining in this chain, if any
+  chainNextPendingChange(time) {
+    if (!this.next) {
+      return this.nextPendingChange(time);
+    }
+
+    const nextChange = this.next.chainNextPendingChange(time);
+    const thisChange = this.nextPendingChange(time);
+    if (nextChange === null) {
+      return thisChange;
+    } else if (thisChange === null) {
+      return nextChange;
+    }
+
+    return Math.min(thisChange, nextChange);
+  }
+
+  recordError(context, err, time = 0) {
+    this.errorCount += 1;
+    this.lastError = err;
+    this.lastErrorContext = context;
+    this.lastEmitTime = time;
+    this.emit('error', err, time, context);
+  }
+}
+
+module.exports = TransformState;

package/lib/transform/trim.js

@@ -0,0 +1,27 @@
+'use strict';
+
+/* eslint-disable no-control-regex */
+
+const _ = require('lodash');
+const TransformState = require('./transformState');
+
+/**
+ * Trims any whitespace or nonprintable characters from ends of string samples.
+ */
+class TrimFilter extends TransformState {
+  static op = 'trim';
+
+  static create(_args) {
+    return new TrimFilter();
+  }
+
+  filter(context, value, time) {
+    if (_.isString(value)) {
+      value = value.replace(/^[\x00-\x20\x7F\xA0]*/, '');
+      value = value.replace(/[\x00-\x20\x7F\xA0]*$/, '');
+    }
+    this.commitValue(context, value, time);
+  }
+}
+
+module.exports = TrimFilter;

package/lib/transform/util/chainSource.js

@@ -0,0 +1,96 @@
+'use strict';
+
+const _ = require('lodash');
+
+class ChainSource {
+  constructor(transform, { engine, path, rootPath }, { onWatchSource, onWatchChainSource } = {}) {
+    this.transform = transform;
+    this.onWatchSource = onWatchSource;
+    this.onWatchChainSource = onWatchChainSource;
+    this.rootPath = rootPath;
+
+    if (!_.isArray(path)) {
+      path = [path];
+    }
+
+    this.selfSources = _(path).map(p => engine.expressionService.expressionTriggers(p)).flatten().union().value();
+    this.triggerSources = engine.expressionService.expressionTriggers(rootPath);
+    this.watchedSources = [];
+
+    const checkName = (name) => {
+      if (_.includes(this.selfSources, name)) {
+        this.watchSource(engine.getState(name));
+      } else if (_.includes(this.triggerSources, name)) {
+        this.watchChainSource(engine.getState(name));
+      }
+    };
+
+    _.each(this.triggerSources, checkName);
+
+    engine.on('add-item', state => checkName(state.name));
+  }
+
+  watchSource(state) {
+    if (!state || _.includes(this.watchedSources, state.name)) {
+      return;
+    }
+
+    state.on('update-unfiltered', (value, time, context) => {
+      const newContext = {
+        sourceType: 'chainRoot-update',
+        path: this.rootPath,
+        trigger: state.name,
+        prevContext: context,
+      };
+      this.transform.update(newContext, value, time);
+    });
+
+    state.on('unavailable', (time, context) => {
+      const newContext = {
+        sourceType: 'chainRoot-unavail',
+        path: this.rootPath,
+        trigger: state.name,
+        prevContext: context,
+      };
+      this.transform.setUnavailable(newContext, time);
+    });
+
+    this.watchedSources.push(state.name);
+    if (this.onWatchSource) {
+      this.onWatchSource(state.name);
+    }
+  }
+
+  watchChainSource(state) {
+    if (!state || _.includes(this.watchedSources, state.name)) {
+      return;
+    }
+
+    state.on('update-unfiltered', (value, time, context) => {
+      const newContext = {
+        sourceType: 'chain-update',
+        path: this.rootPath,
+        trigger: state.name,
+        prevContext: context,
+      };
+      this.transform.probe(newContext, time);
+    });
+
+    state.on('unavailable', (time, context) => {
+      const newContext = {
+        sourceType: 'chain-unavail',
+        path: this.rootPath,
+        trigger: state.name,
+        prevContext: context,
+      };
+      this.transform.probe(newContext, time);
+    });
+
+    this.watchedSources.push(state.name);
+    if (this.onWatchChainSource) {
+      this.onWatchChainSource(state.name);
+    }
+  }
+}
+
+module.exports = ChainSource;

package/lib/transform/util/ringBuffer.js

@@ -0,0 +1,34 @@
+'use strict';
+
+const _ = require('lodash');
+
+class RingBuffer {
+  constructor(size) {
+    this.size = size;
+    this.buffer = _.times(size, _.constant(0));
+    this.pointer = 0;
+  }
+
+  get(key) {
+    return this.buffer[key % this.size];
+  }
+
+  getHeadIndex() {
+    return (this.pointer + (this.size - 1)) % this.size;
+  }
+
+  getTailIndex() {
+    return this.pointer;
+  }
+
+  push(value) {
+    this.buffer[this.pointer] = value;
+    this.pointer = (this.size + this.pointer + 1) % this.size;
+  }
+
+  values() {
+    return this.buffer;
+  }
+}
+
+module.exports = RingBuffer;

package/lib/transform/valueChange.js

@@ -0,0 +1,34 @@
+'use strict';
+
+const TransformState = require('./transformState');
+
+/**
+ * Emits a T signal each time the value changes in a stream.
+ */
+class ValueChangeFilter extends TransformState {
+  constructor() {
+    super();
+
+    this.defaultValue = false;
+    this.value = false;
+    this.previousValue = false;
+  }
+
+  static op = 'value-change';
+
+  static create(_args) {
+    return new ValueChangeFilter();
+  }
+
+  emitUpdate(context) {
+    if (this.forceEmit || this.valueTime === this.lastSampleTime) {
+      this.forceEmit = false;
+      this.lastEmitValue = this.value;
+      this.lastEmitTime = this.lastSampleTime;
+      this.emit('update', true, this.lastSampleTime, context);
+    }
+    this.emit('update', false, this.lastSampleTime, context);
+  }
+}
+
+module.exports = ValueChangeFilter;

package/lib/transform/valueDecrease.js

@@ -0,0 +1,38 @@
+'use strict';
+
+const TransformState = require('./transformState');
+
+/**
+ * Emits a T signal each time the value decreases in a stream.
+ */
+class ValueDecreaseFilter extends TransformState {
+  constructor() {
+    super();
+
+    this.defaultValue = false;
+    this.value = false;
+    this.previousValue = false;
+  }
+
+  static op = 'value-decrease';
+
+  static create(_args) {
+    return new ValueDecreaseFilter();
+  }
+
+  filter(context, value, time) {
+    this.commitValue(context, +value, time);
+  }
+
+  emitUpdate(context) {
+    if (this.forceEmit || (this.value < this.previousValue && this.valueTime === this.lastSampleTime)) {
+      this.forceEmit = false;
+      this.lastEmitValue = this.value;
+      this.lastEmitTime = this.lastSampleTime;
+      this.emit('update', true, this.lastSampleTime, context);
+    }
+    this.emit('update', false, this.lastSampleTime, context);
+  }
+}
+
+module.exports = ValueDecreaseFilter;