@openhps/core
Version:
Open Hybrid Positioning System - Core component
132 lines • 4.77 kB
JavaScript
;
Object.defineProperty(exports, "__esModule", { value: true });
exports.ProcessingNode = void 0;
const tslib_1 = require("tslib");
const Node_1 = require("../Node");
const service_1 = require("../service");
const decorators_1 = require("../data/decorators");
/**
* Node that processes a dataframe or the contained objects.
*
* ## Usage
*
* ### Creating a ProcessingNode
* Processing nodes hide the push and pull functionalities from a regular node. When a push is received, this
* data frame is provided to the ```process()``` method that has to be implemented. When a pull is received, this pull is
* forwarded to all incoming nodes.
* ```typescript
* import { DataFrame, DataObject, ProcessingNode } from '@openhps/core';
*
* export class CustomProcessingNode<In extends DataFrame, Out extends DataFrame> extends ProcessingNode<In, Out> {
* // ...
* public process(data: In, options?: GraphOptions): Promise<Out> {
* return new Promise<Out>((resolve, reject) => {
* // ... process/manipulate the data frame
* data.addObject(new DataObject("custom_process_object"));
* resolve(data);
* });
* }
* }
* ```
*
*
<script type="application/ld+json">
{
"@context": "http://purl.org/poso/",
"@type": "PositioningTechnique",
}
</script>
* @category Processing node
*/
let ProcessingNode = class ProcessingNode extends Node_1.Node {
constructor(options) {
super(options);
this.options.frameFilter = this.options.frameFilter || (() => true);
this.on('push', this._onPush.bind(this));
}
_onPush(frame, options) {
return new Promise((resolve, reject) => {
const processPromises = [];
if (Array.isArray(frame)) {
processPromises.push(this.processBulk(frame.filter((frame) => this.options.frameFilter(frame))));
frame
.filter((frame) => !this.options.frameFilter(frame))
.forEach((f) => {
processPromises.push(Promise.resolve(f));
});
}
else if (this.options.frameFilter(frame)) {
processPromises.push(this.process(frame, options));
}
else {
processPromises.push(Promise.resolve(frame));
}
Promise.all(processPromises)
.then((results) => {
const output = [];
results.forEach((res) => {
if (Array.isArray(res)) {
output.push(...res.filter((res) => res !== undefined));
}
else if (res !== undefined) {
output.push(res);
}
});
if (output.length > 0) {
this.outlets.forEach((outlet) => outlet.push(output.length === 1 ? output[0] : output, options));
}
resolve();
})
.catch((ex) => {
if (ex === undefined) {
this.logger('warn', `Exception thrown in processing node ${this.uid} but no exception given!`);
}
reject(ex);
});
});
}
findNodeDataService() {
return this.model.findDataService(service_1.NodeData);
}
/**
* Get node data
* @param {DataObject} dataObject Data object to get node data from
* @param {any} [defaultData] Default data
* @returns {Promise<any>} Promise with node data
*/
getNodeData(dataObject, defaultData = undefined) {
return new Promise((resolve, reject) => {
this.findNodeDataService()
.findData(this.uid, dataObject)
.then((data) => {
if (!data) {
resolve(defaultData);
}
else {
resolve(data);
}
})
.catch(reject);
});
}
/**
* Set node data
* @param {DataObject} dataObject Data object to store data for
* @param {any} data Data to store
* @returns {Promise<any>} Promise with stored node data
*/
setNodeData(dataObject, data) {
return new Promise((resolve, reject) => {
this.findNodeDataService().insertData(this.uid, dataObject, data).then(resolve).catch(reject);
});
}
processBulk(frames) {
return Promise.all(frames.map((frame) => this.process(frame)));
}
};
exports.ProcessingNode = ProcessingNode;
exports.ProcessingNode = ProcessingNode = tslib_1.__decorate([
(0, decorators_1.SerializableObject)(),
tslib_1.__metadata("design:paramtypes", [Object])
], ProcessingNode);
//# sourceMappingURL=ProcessingNode.js.map