@openhps/core
Version:
Open Hybrid Positioning System - Core component
197 lines • 6.44 kB
JavaScript
var DataFrame_1;
import { __decorate, __metadata } from "tslib";
import { v4 as uuidv4 } from 'uuid';
import { DataObject } from './object/DataObject';
import { SerializableObject, SerializableMember, SerializableMapMember, NumberType } from './decorators';
import { TimeService } from '../service/TimeService';
import { DataSerializer } from './DataSerializer';
/**
* A data frame is information that is passed through each node in a positioning model.
*
* 
*
* ## Usage
*
* ### Creation
* A data frame can be created with an optional source {@link DataObject} that represents
* the object responsible for generating the frame.
* ```typescript
* const dataFrame = new DataFrame(new DataObject("phone"));
* ```
*
* ### Creating a custom DataFrame
* Custom data frames can be created by extending the default {@link DataFrame} class. Important when handling
* data frames (and objects) is to add serializable decorators.
* ```typescript
* import { DataFrame, SerializableObject, SerializableArrayMember } from '@openhps/core';
*
* @SerializableObject()
* export class CustomDataFrame extends DataFrame {
* @SerialisableArrayMember(Number)
* public customFrameAttribute: number[];
* }
* ```
*
* ### Adding {@link DataObject}s
* Adding data object will clone the data objects to the data frame. Any changes made to the object after cloning will not
* be applied to the data frame.
*/
let DataFrame = DataFrame_1 = class DataFrame {
constructor(data) {
var _a;
/**
* Data frame unique identifier
*/
this.uid = uuidv4();
this._objects = new Map();
this.createdTimestamp = TimeService.now();
if (data instanceof DataFrame_1) {
// Copy data frame
this.createdTimestamp = data.createdTimestamp;
this.phenomenonTimestamp = data.phenomenonTimestamp;
this.uid = data.uid;
this._objects = data._objects;
this.source = data.source;
} else if (data instanceof DataObject) {
this.source = data;
}
this.phenomenonTimestamp = (_a = this.phenomenonTimestamp) !== null && _a !== void 0 ? _a : this.createdTimestamp;
}
/**
* Source object clone that captured the data frame
* @returns {DataObject} Source data object
*/
get source() {
return this.getObjectByUID(this._source);
}
/**
* Set the source object clone that captured the data frame
* @param {DataObject} object Source data object
*/
set source(object) {
if (object === undefined) return;
this.addObject(object.clone());
this._source = object.uid;
}
/**
* Get known sensor objects used in this data frame
* @param {typeof SensorObject} type Sensor type
* @param {string} [defaultUID] Default UID. When sensor is not added, it will be created
* @returns {SensorObject} Found data objects
*/
getSensor(type, defaultUID) {
let sensor = this.getObjects(type)[0];
if (!sensor && defaultUID !== undefined) {
sensor = new type(defaultUID);
this.addObject(sensor);
}
return sensor;
}
/**
* Get known objects used in this data frame
* @param {typeof DataObject} dataType Data object type
* @returns {DataObject[]} Array of found data objects
*/
getObjects(dataType) {
if (dataType === undefined) {
const filteredObjects = [];
this._objects.forEach(object => {
filteredObjects.push(object);
});
return filteredObjects;
} else {
const filteredObjects = [];
this._objects.forEach(object => {
if (object.constructor.name === dataType.name) filteredObjects.push(object);
});
return filteredObjects;
}
}
/**
* Get a specific object by its identifier
* @param {string} uid Object UID
* @returns {DataObject} Data object if found
*/
getObjectByUID(uid) {
return this._objects.get(uid);
}
/**
* Check if the data frame has an object
* @param {DataObject} object Data object to find
* @returns {boolean} Object exist
*/
hasObject(object) {
return this._objects.has(object.uid);
}
/**
* Add a new object relevant to this data frame
* @param {DataObject} object Relevant object
* @returns {DataFrame} instance
*/
addObject(object) {
if (object === undefined) return this;
this._objects.set(object.uid, object);
return this;
}
/**
* Add a new sensor relevant to this data frame
* @param {SensorObject} object Relevant sensor
* @returns {DataFrame} instance
*/
addSensor(object) {
return this.addObject(object);
}
/**
* Add a new reference space relevant to this data frame.
* @alias addObject Alias for addObject
* @param {ReferenceSpace} referenceSpace Relevant reference space
*/
addReferenceSpace(referenceSpace) {
this.addObject(referenceSpace);
}
/**
* Remove an object from the data frame
* @param {DataObject | string} object Object to remove
*/
removeObject(object) {
this._objects.delete(typeof object === 'string' ? object : object.uid);
}
/**
* Clear all objects
* @param {Function} objectFilter object filter
*/
clearObjects(objectFilter) {
const filter = objectFilter !== null && objectFilter !== void 0 ? objectFilter : object => true;
this._objects.forEach((obj, key) => {
if (filter(obj)) {
this._objects.delete(key);
}
});
}
/**
* Clone the data frame
* @returns {DataFrame} Cloned data frame
*/
clone() {
return DataSerializer.clone(this);
}
};
__decorate([SerializableMember({
primaryKey: true
}), __metadata("design:type", String)], DataFrame.prototype, "uid", void 0);
__decorate([SerializableMember({
index: true,
numberType: NumberType.LONG
}), __metadata("design:type", Number)], DataFrame.prototype, "createdTimestamp", void 0);
__decorate([SerializableMember({
index: true,
numberType: NumberType.LONG
}), __metadata("design:type", Number)], DataFrame.prototype, "phenomenonTimestamp", void 0);
__decorate([SerializableMember({
name: 'source'
}), __metadata("design:type", String)], DataFrame.prototype, "_source", void 0);
__decorate([SerializableMapMember(String, DataObject, {
name: 'objects'
}), __metadata("design:type", Map)], DataFrame.prototype, "_objects", void 0);
DataFrame = DataFrame_1 = __decorate([SerializableObject(), __metadata("design:paramtypes", [Object])], DataFrame);
export { DataFrame };