import {
AbstractTime
} from '../../model/gml';
import {
AbstractAlgorithm,
AbstractMetadataList,
AbstractModes,
AbstractNamedMetadataList,
AbstractPhysicalProcess,
AbstractProcess,
AggregateProcess,
AggregatingProcess,
ArrayValueSetting,
Axis,
CapabilityList,
CharacteristicList,
ClassifierList,
Component,
ComponentList,
Connection,
ConnectionList,
ConstraintSetting,
ContactList,
DataInterface,
DescribedObject,
DocumentList,
Event,
EventList,
FeatureList,
FeatureProperty,
IdentifierList,
InputList,
InputOrOutputOrParameter,
KeywordList,
Mode,
ModeChoice,
ModeSetting,
NamedSweDataComponent,
ObservableProperty,
OutputList,
ParameterList,
PhysicalComponent,
PhysicalSystem,
Position,
ProcessMethod,
ProcessMethodProcess,
Settings,
SimpleProcess,
SpatialFrame,
StatusSetting,
TemporalFrame,
Term,
ValueSetting
} from '../../model/sml';
import {
AbstractDataComponent,
AllowedTimes,
AllowedTokens,
AllowedValues,
SweDataRecord,
SweDataStream,
SweEncoding
} from '../../model/swe';
import { BidiMap } from '../dynamicGUI/BidiMap';
import { DecoderUtils } from './DecoderUtils';
import { GmlDecoder } from './GmlDecoder';
import { IsoDecoder } from './IsoDecoder';
import { NAMESPACES } from './Namespaces';
import { ReturnObject } from './ReturnObject';
import { SweDecoder } from './SweDecoder';
export class SensorMLDecoder {
private gmlDecoder = new GmlDecoder();
private sweDecoder = new SweDecoder();
private isoDecoder = new IsoDecoder();
private utils = new DecoderUtils();
private _profileIDMap: BidiMap;
public get profileIDMap() {
return this._profileIDMap;
}
public set profileIDMap(profileIDMap: BidiMap) {
this._profileIDMap = profileIDMap;
this.gmlDecoder.profileIDMap = profileIDMap;
this.isoDecoder.profileIDMap = profileIDMap;
this.sweDecoder.profileIDMap = profileIDMap;
}
public decodeElement(element: Element): AbstractProcess {
const process = this.createProcessOfElement(element);
if (process instanceof SimpleProcess) {
this.decodeSimpleProcess(element, process);
} else if (process instanceof AggregateProcess) {
this.decodeAggregateProcess(element, process);
} else if (process instanceof PhysicalSystem) {
this.decodePhysicalSystem(element, process);
} else if (process instanceof PhysicalComponent) {
this.decodePhysicalComponent(element, process);
} else {
throw new Error('Unsupported process type');
}
return process;
}
private createProcessOfElement(element: Element): AbstractProcess {
if (this.utils.getElement(element, SimpleProcess.NAME(), NAMESPACES.SML)) {
return new SimpleProcess();
}
if (this.utils.getElement(element, AggregateProcess.NAME(), NAMESPACES.SML)) {
return new AggregateProcess();
}
if (this.utils.getElement(element, PhysicalComponent.NAME(), NAMESPACES.SML)) {
return new PhysicalComponent();
}
if (this.utils.getElement(element, PhysicalSystem.NAME(), NAMESPACES.SML)) {
return new PhysicalSystem();
}
throw new Error('Unsupported process type');
}
public getMapWithProfileIDs() {
return this._profileIDMap;
}
public decodeSimpleProcess(elem: Element, object: SimpleProcess): void {
this.decodeAbstractProcess(elem, object);
this.decodeProcessMethodProcess(elem, object);
}
public decodeAggregateProcess(elem: Element, object: AggregateProcess): void {
this.decodeAbstractProcess(elem, object);
this.decodeAggregatingProcess(elem, object);
}
public decodePhysicalSystem(elem: Element, object: PhysicalSystem): void {
this.decodeAbstractPhysicalProcess(elem, object);
this.decodeAggregatingProcess(elem, object);
}
public decodePhysicalComponent(elem: Element, object: PhysicalComponent): void {
this.decodeAbstractPhysicalProcess(elem, object);
this.decodeProcessMethodProcess(elem, object);
}
public decodeAbstractPhysicalProcess(elem: Element, object: AbstractPhysicalProcess): void {
this.decodeAbstractProcess(elem, object);
const returnObject: ReturnObject<string> = this.utils.getAttributeOfElement(
elem, 'attachedTo', NAMESPACES.SML, 'href', NAMESPACES.XLINK
);
if (returnObject) {
object.attachedTo = returnObject.value;
this._profileIDMap = this.utils.processProfileID(
returnObject.docElement, object, 'attachedTo', this._profileIDMap
);
}
object.localReferenceFrame = this.utils.getDecodedList(
elem,
'localReferenceFrame',
NAMESPACES.SML, this._profileIDMap,
(lrf) => this.decodeSpatialFrame(lrf));
object.localTimeFrame = this.utils.getDecodedList(
elem,
'localTimeFrame',
NAMESPACES.SML, this._profileIDMap,
(ltf) => this.decodeTemporalFrame(ltf));
object.position = this.utils.getDecodedList(
elem, 'position', NAMESPACES.SML, this._profileIDMap, (pos) => this.decodePosition(pos)
);
object.timePosition = this.utils.getDecodedList(
elem,
'timePosition',
NAMESPACES.SML, this._profileIDMap,
(timePos) => this.sweDecoder.decodeTime(timePos));
}
public decodeSpatialFrame(elem: Element): ReturnObject<SpatialFrame> {
const spatialFrame = new SpatialFrame();
const spatialFrameElem = this.utils.getElement(elem, 'SpatialFrame', NAMESPACES.SML);
this._profileIDMap = this.utils.processProfileID(spatialFrameElem, spatialFrame, '', this._profileIDMap);
if (spatialFrameElem != null) {
this.sweDecoder.decodeAbstractSweIdentifiable(spatialFrameElem, spatialFrame);
const originElem = this.utils.getElement(spatialFrameElem, 'origin', NAMESPACES.SML);
if (originElem != null) {
spatialFrame.origin = originElem.textContent.trim();
this._profileIDMap = this.utils.processProfileID(
originElem, spatialFrame, 'origin', this._profileIDMap
);
}
spatialFrame.axis = this.utils.getDecodedList<Axis>(
spatialFrameElem,
'axis',
NAMESPACES.SML, this._profileIDMap,
(axisNode) => this.decodeAxis(axisNode));
}
return new ReturnObject(spatialFrame, spatialFrameElem);
}
public decodeTemporalFrame(elem: Element): ReturnObject<TemporalFrame> {
const temporalFrame = new TemporalFrame();
const temporalFrameElem = this.utils.getElement(elem, 'TemporalFrame', NAMESPACES.SML);
if (temporalFrameElem != null) {
this.sweDecoder.decodeAbstractSweIdentifiable(temporalFrameElem, temporalFrame);
const originElem = this.utils.getElement(temporalFrameElem, 'origin', NAMESPACES.SML);
if (originElem != null) {
temporalFrame.origin = originElem.textContent.trim();
this._profileIDMap = this.utils.processProfileID(
originElem, temporalFrame, 'origin', this._profileIDMap
);
}
}
return new ReturnObject(temporalFrame, elem);
}
public decodeAxis(elem: Element): ReturnObject<Axis> {
const axis = new Axis();
const name = elem.getAttribute('name');
if (name != null) {
axis.name = name;
this._profileIDMap = this.utils.processProfileID(elem, axis, 'name', this._profileIDMap);
}
const description = elem.textContent.trim();
if (description != null) {
axis.description = description;
this._profileIDMap = this.utils.processProfileID(elem, axis, 'description', this._profileIDMap);
}
return new ReturnObject(axis, elem);
}
public decodePosition(elem: Element): ReturnObject<Position> {
const point = this.gmlDecoder.decodePoint(elem);
if (point != null) { return point; }
const text = this.sweDecoder.decodeText(elem);
if (text != null) { return text; }
const vector = this.sweDecoder.decodeVector(elem);
if (vector != null) { return vector; }
const dataRecord = this.sweDecoder.decodeDataRecord(elem);
if (dataRecord != null) { return dataRecord; }
const matrix = this.sweDecoder.decodeMatrix(elem);
if (matrix != null) { return matrix; }
const dataArray = this.sweDecoder.decodeDataArray(elem);
if (dataArray != null) { return dataArray; }
// TODO decode if process
}
public decodeAggregatingProcess(elem: Element, object: AggregatingProcess): void {
const componentsElem = this.utils.getElement(elem, 'components', NAMESPACES.SML);
if (componentsElem != null) {
const returnObject: ReturnObject<ComponentList> = this.decodeComponentList(componentsElem);
if (returnObject) {
object.components = returnObject.value;
this._profileIDMap = this.utils.processProfileID(
returnObject.docElement, object, 'components', this._profileIDMap
);
}
}
const connectionsElem = this.utils.getElement(elem, 'connections', NAMESPACES.SML);
if (connectionsElem != null) {
const returnObject: ReturnObject<ConnectionList> = this.decodeConnectionList(connectionsElem);
if (returnObject) {
object.connections = returnObject.value;
this._profileIDMap = this.utils.processProfileID(
returnObject.docElement, object, 'connections', this._profileIDMap
);
}
}
}
public decodeAbstractProcess(elem: Element, object: AbstractProcess): void {
this.decodeDescribedObject(elem, object);
const returnObject: ReturnObject<string> = this.utils.getAttributeOfElement(
elem, 'typeOf', NAMESPACES.SML, 'href', NAMESPACES.XLINK
);
if (returnObject) {
object.typeOf = returnObject.value;
this._profileIDMap = this.utils.processProfileID(
returnObject.docElement, object, 'typeOf', this._profileIDMap
);
}
const settings = this.utils.getElement(elem, 'configuration', NAMESPACES.SML);
if (settings != null) {
const settingsRo: ReturnObject<Settings> = this.decodeSettings(settings);
if (settingsRo) {
object.configuration = settingsRo.value;
this._profileIDMap = this.utils.processProfileID(
settingsRo.docElement, object, 'configuration', this._profileIDMap
);
}
}
const features = this.utils.getElement(elem, 'featuresOfInterest', NAMESPACES.SML);
if (features != null) {
const featureListRo: ReturnObject<FeatureList> = this.decodeFeatureList(features);
if (featureListRo) {
object.featureOfInterest = featureListRo.value;
this._profileIDMap = this.utils.processProfileID(
featureListRo.docElement, object, 'featureOfInterest', this._profileIDMap
);
}
}
const inputsElem = this.utils.getElement(elem, 'inputs', NAMESPACES.SML);
if (inputsElem != null) {
const inputListRo: ReturnObject<InputList> = this.decodeInputList(inputsElem);
if (inputListRo) {
object.inputs = inputListRo.value;
this._profileIDMap = this.utils.processProfileID(
inputListRo.docElement, object, 'inputs', this._profileIDMap
);
}
}
const outputsElem = this.utils.getElement(elem, 'outputs', NAMESPACES.SML);
if (outputsElem != null) {
const outputListRo: ReturnObject<OutputList> = this.decodeOutputList(outputsElem);
if (outputListRo) {
object.outputs = outputListRo.value;
this._profileIDMap = this.utils.processProfileID(
outputListRo.docElement, object, 'outputs', this._profileIDMap
);
}
}
const parameters = this.utils.getElement(elem, 'parameters', NAMESPACES.SML);
if (parameters != null) {
const parameterListRo: ReturnObject<ParameterList> = this.decodeParameterList(parameters);
if (parameterListRo) {
object.parameters = parameterListRo.value;
this._profileIDMap = this.utils.processProfileID(
parameterListRo.docElement, object, 'parameters', this._profileIDMap
);
}
}
object.modes = this.utils.getDecodedList(
elem, 'modes', NAMESPACES.SML, this._profileIDMap, (mode) => this.decodeModes(mode)
);
if (elem.hasAttribute('definition')) {
object.definition = elem.getAttribute('definition');
this._profileIDMap = this.utils.processProfileID(elem, object, 'definition', this._profileIDMap);
}
}
public decodeFeatureList(elem: Element): ReturnObject<FeatureList> {
const featureListElem = this.utils.getElement(elem, 'FeatureList', NAMESPACES.SML);
if (featureListElem != null) {
const featureList = new FeatureList();
this._profileIDMap = this.utils.processProfileID(featureListElem, featureList, '', this._profileIDMap);
this.decodeAbstractMetadataList(featureListElem, featureList);
featureList.feature =
this.utils.getDecodedList<FeatureProperty>(
featureListElem,
'feature',
NAMESPACES.SML,
this._profileIDMap,
(feature) => {
const featureProperty = new FeatureProperty();
this.gmlDecoder.decodeAssociationAttributeGroup(feature, featureProperty);
return new ReturnObject(featureProperty, feature);
});
return new ReturnObject(featureList, featureListElem);
}
}
public decodeModes(elem: Element): ReturnObject<AbstractModes> {
const modeChoice = this.decodeModeChoice(elem);
if (modeChoice != null) { return new ReturnObject(modeChoice, elem); }
}
public decodeModeChoice(elem: Element): ModeChoice {
const modeChoiceElem = this.utils.getElement(elem, 'ModeChoice', NAMESPACES.SML);
if (modeChoiceElem != null) {
const modeChoice = new ModeChoice();
this._profileIDMap = this.utils.processProfileID(modeChoiceElem, modeChoice, '', this._profileIDMap);
this.sweDecoder.decodeAbstractSwe(modeChoiceElem, modeChoice);
modeChoice.modes = this.utils.getDecodedList(
modeChoiceElem,
'mode',
NAMESPACES.SML, this._profileIDMap,
(mode) => this.decodeMode(mode));
return modeChoice;
}
}
public decodeMode(elem: Element): ReturnObject<Mode> {
const modeElem = this.utils.getElement(elem, 'Mode', NAMESPACES.SML);
if (modeElem != null) {
const mode = new Mode();
this._profileIDMap = this.utils.processProfileID(modeElem, mode, '', this._profileIDMap);
this.decodeDescribedObject(modeElem, mode);
const settingsElem = this.utils.getElement(modeElem, 'configuration', NAMESPACES.SML);
if (settingsElem != null) {
const returnObject: ReturnObject<Settings> = this.decodeSettings(settingsElem);
if (returnObject) {
mode.configuration = returnObject.value;
this._profileIDMap = this.utils.processProfileID(
returnObject.docElement, mode, 'configuration', this._profileIDMap
);
}
}
return new ReturnObject(mode, modeElem);
}
}
public decodeDescribedObject(elem: Element, describedObject: DescribedObject): void {
this.gmlDecoder.decodeAbstractFeature(elem, describedObject);
describedObject.keywords = this.utils.getDecodedList(
elem,
'keywords',
NAMESPACES.SML, this._profileIDMap,
(keywords) => this.decodeKeywordList(keywords));
describedObject.identification = this.utils.getDecodedList(
elem,
'identification',
NAMESPACES.SML, this._profileIDMap,
(identifications) => this.decodeIdentifierList(identifications));
describedObject.classification = this.utils.getDecodedList(
elem,
'classification',
NAMESPACES.SML, this._profileIDMap,
(classifier) => this.decodeClassifierList(classifier));
describedObject.validTime = this.utils.getDecodedList(
elem,
'validTime',
NAMESPACES.SML, this._profileIDMap,
(validTime) => this.gmlDecoder.decodeTime(validTime));
const secConstElem = this.utils.getElement(elem, 'securityConstraints', NAMESPACES.SML);
if (secConstElem != null) {
throw new Error('Security Constraints currently not supported');
}
describedObject.legalConstraints = this.utils.getDecodedList(
elem,
'legalConstraints',
NAMESPACES.SML, this._profileIDMap,
(legalConst) => this.isoDecoder.decodeLegalConstraints(legalConst));
describedObject.characteristics = this.utils.getDecodedList(
elem,
'characteristics',
NAMESPACES.SML, this._profileIDMap,
(characteristic) => this.decodeCharacteristicList(characteristic));
describedObject.capabilities = this.utils.getDecodedList(
elem,
'capabilities',
NAMESPACES.SML, this._profileIDMap,
(capa) => this.decodeCapabilitiesList(capa));
describedObject.contacts = this.utils.getDecodedList(
elem,
'contacts',
NAMESPACES.SML, this._profileIDMap,
(contactList) => this.decodeContactList(contactList));
describedObject.documentation = this.utils.getDecodedList(
elem,
'documentation',
NAMESPACES.SML, this._profileIDMap,
(documentation) => this.decodeDocumentList(documentation));
describedObject.history = this.utils.getDecodedList(
elem,
'history',
NAMESPACES.SML, this._profileIDMap,
(history) => this.decodeEventList(history));
}
public decodeComponentList(elem: Element): ReturnObject<ComponentList> {
const componentListElem = this.utils.getElement(elem, 'ComponentList', NAMESPACES.SML);
if (componentListElem != null) {
const compList = new ComponentList();
this._profileIDMap = this.utils.processProfileID(componentListElem, compList, '', this._profileIDMap);
this.sweDecoder.decodeAbstractSwe(componentListElem, compList);
compList.components = this.utils.getDecodedList(
componentListElem,
'component',
NAMESPACES.SML, this._profileIDMap,
(component) => this.decodeComponent(component));
return new ReturnObject(compList, componentListElem);
}
}
public decodeComponent(elem: Element): ReturnObject<Component> {
const component = new Component();
if (elem.hasAttribute('name')) {
component.name = elem.getAttribute('name');
this._profileIDMap = this.utils.processProfileID(elem, component, 'name', this._profileIDMap);
}
if (elem.children.length === 1) {
component.abstractProcess = this.decodeElement(elem.children[0]);
}
return new ReturnObject(component, elem);
}
public decodeConnectionList(elem: Element): ReturnObject<ConnectionList> {
const connectionListElem = this.utils.getElement(elem, 'ConnectionList', NAMESPACES.SML);
if (connectionListElem != null) {
const connList = new ConnectionList();
this._profileIDMap = this.utils.processProfileID(connectionListElem, connList, '', this._profileIDMap);
this.sweDecoder.decodeAbstractSwe(connectionListElem, connList);
connList.connections = this.utils.getDecodedList(
connectionListElem,
'connection',
NAMESPACES.SML, this._profileIDMap,
(connection) => this.decodeConnection(connection));
return new ReturnObject(connList, connectionListElem);
}
}
public decodeConnection(elem: Element): ReturnObject<Connection> {
const connectionElem = this.utils.getElement(elem, 'Link', NAMESPACES.SML);
if (connectionElem != null) {
const conn = new Connection();
let returnObject: ReturnObject<string> = this.utils.getAttributeOfElement(
connectionElem, 'source', NAMESPACES.SML, 'ref', ''
);
if (returnObject) {
conn.source = returnObject.value;
this._profileIDMap = this.utils.processProfileID(
returnObject.docElement, conn, 'source', this._profileIDMap
);
}
returnObject = this.utils.getAttributeOfElement(connectionElem, 'destination', NAMESPACES.SML, 'ref', '');
if (returnObject) {
conn.destination = returnObject.value;
this._profileIDMap = this.utils.processProfileID(
returnObject.docElement, conn, 'destination', this._profileIDMap
);
}
return new ReturnObject(conn, connectionElem);
}
}
public decodeContactList(elem: Element): ReturnObject<ContactList> {
const contactListElem = this.utils.getElement(elem, 'ContactList', NAMESPACES.SML);
if (contactListElem != null) {
const contactList = new ContactList();
this._profileIDMap = this.utils.processProfileID(contactListElem, contactList, '', this._profileIDMap);
this.decodeAbstractMetadataList(contactListElem, contactList);
contactList.contacts = this.utils.getDecodedList(
contactListElem,
'contact',
NAMESPACES.SML, this._profileIDMap,
(contact) => this.isoDecoder.decodeResponsibleParty(contact));
return new ReturnObject(contactList, contactListElem);
}
}
public decodeInputList(elem: Element): ReturnObject<InputList> {
const inputListElem = this.utils.getElement(elem, 'InputList', NAMESPACES.SML);
if (inputListElem != null) {
const inputList = new InputList();
this._profileIDMap = this.utils.processProfileID(inputListElem, inputList, '', this._profileIDMap);
this.sweDecoder.decodeAbstractSwe(inputListElem, inputList);
inputList.inputs = this.utils.getDecodedList(
inputListElem,
'input',
NAMESPACES.SML, this._profileIDMap,
(input) => this.decodeInputOrOutputOrParameter(input));
return new ReturnObject(inputList, inputListElem);
}
}
public decodeOutputList(elem: Element): ReturnObject<OutputList> {
const outputListElem = this.utils.getElement(elem, 'OutputList', NAMESPACES.SML);
if (outputListElem != null) {
const outputList = new OutputList();
this.sweDecoder.decodeAbstractSwe(outputListElem, outputList);
outputList.outputs = this.utils.getDecodedList(
outputListElem,
'output',
NAMESPACES.SML, this._profileIDMap,
(output) => this.decodeInputOrOutputOrParameter(output));
return new ReturnObject(outputList, outputListElem);
}
}
public decodeParameterList(elem: Element): ReturnObject<ParameterList> {
const parameterListElem = this.utils.getElement(elem, 'ParameterList', NAMESPACES.SML);
if (parameterListElem != null) {
const parameterList = new ParameterList();
this._profileIDMap = this.utils.processProfileID(parameterListElem, parameterList, '', this._profileIDMap);
this.sweDecoder.decodeAbstractSwe(parameterListElem, parameterList);
parameterList.parameters = this.utils.getDecodedList(
parameterListElem,
'parameter',
NAMESPACES.SML, this._profileIDMap,
(param) => this.decodeInputOrOutputOrParameter(param));
return new ReturnObject(parameterList, parameterListElem);
}
}
public decodeInputOrOutputOrParameter(elem: Element): ReturnObject<InputOrOutputOrParameter> {
const param = new InputOrOutputOrParameter();
this._profileIDMap = this.utils.processProfileID(elem, param, '', this._profileIDMap);
if (elem.hasAttribute('name')) {
param.name = elem.getAttribute('name');
this._profileIDMap = this.utils.processProfileID(elem, param, 'name', this._profileIDMap);
}
if (elem.firstElementChild != null) {
const returnObject: ReturnObject<ObservableProperty> = this.decodeObservableProperty(elem);
if (returnObject && returnObject.value != null) {
param.value = returnObject.value;
this._profileIDMap = this.utils.processProfileID(
returnObject.docElement, param, 'value', this._profileIDMap
);
}
const returnObject1: ReturnObject<DataInterface> = this.decodeDataInterface(elem);
if (returnObject1) {
const dataInterface = returnObject1.value;
if (dataInterface != null) {
param.value = dataInterface;
this._profileIDMap = this.utils.processProfileID(
returnObject1.docElement, param, 'value', this._profileIDMap
);
}
}
const returnObject2: ReturnObject<AbstractDataComponent> = this.sweDecoder.decodeDataComponent(elem);
if (returnObject2) {
const dataComponent = returnObject2.value;
if (dataComponent != null) {
param.value = dataComponent;
this._profileIDMap = this.utils.processProfileID(
returnObject2.docElement, param, 'value', this._profileIDMap
);
}
}
}
return new ReturnObject(param, elem);
}
public decodeObservableProperty(elem: Element): ReturnObject<ObservableProperty> {
const obsPropElem = this.utils.getElement(elem, 'ObservableProperty', NAMESPACES.SML);
if (obsPropElem != null) {
const obsProp = new ObservableProperty();
this._profileIDMap = this.utils.processProfileID(obsPropElem, obsProp, '', this._profileIDMap);
this.sweDecoder.decodeAbstractSweIdentifiable(obsPropElem, obsProp);
if (obsPropElem.hasAttribute('definition')) {
obsProp.definition = obsPropElem.getAttribute('definition');
this._profileIDMap = this.utils.processProfileID(
obsPropElem, obsProp, 'definition', this._profileIDMap
);
}
return new ReturnObject(obsProp, obsPropElem);
}
}
public decodeDataInterface(elem: Element): ReturnObject<DataInterface> {
const dataInterfaceElem = this.utils.getElement(elem, 'DataInterface', NAMESPACES.SML);
if (dataInterfaceElem != null) {
const dataInterface = new DataInterface();
this._profileIDMap = this.utils.processProfileID(dataInterfaceElem, dataInterface, '', this._profileIDMap);
this.sweDecoder.decodeAbstractSweIdentifiable(dataInterfaceElem, dataInterface);
const dataElem = this.utils.getElement(dataInterfaceElem, 'data', NAMESPACES.SML);
if (dataElem != null) {
const returnObject: ReturnObject<SweDataStream> = this.sweDecoder.decodeDataStream(dataElem);
if (returnObject) {
dataInterface.data = returnObject.value;
this._profileIDMap = this.utils.processProfileID(
returnObject.docElement, dataInterface, 'data', this._profileIDMap
);
}
}
const interfaceParams = this.utils.getElement(dataInterfaceElem, 'interfaceParameters', NAMESPACES.SML);
if (interfaceParams != null) {
const returnObject: ReturnObject<SweDataRecord> = this.sweDecoder.decodeDataRecord(interfaceParams);
if (returnObject) {
dataInterface.interfaceParameters = returnObject.value;
this._profileIDMap = this.utils.processProfileID(
interfaceParams, dataInterface, 'interfaceParameters', this._profileIDMap
);
}
}
return new ReturnObject(dataInterface, dataInterfaceElem);
}
}
public decodeCharacteristicList(elem: Element): ReturnObject<CharacteristicList> {
const characteristicListElem = this.utils.getElement(elem, 'CharacteristicList', NAMESPACES.SML);
if (characteristicListElem != null) {
const characteristicList = new CharacteristicList();
this._profileIDMap = this.utils.processProfileID(
characteristicListElem, characteristicList, '', this._profileIDMap
);
this.decodeAbstractNamedMetadataList(elem, characteristicList);
characteristicList.characteristics = this.utils.getDecodedList(
characteristicListElem,
'characteristic',
NAMESPACES.SML, this._profileIDMap,
(char) => this.decodeNamedSweDataComponent(char));
return new ReturnObject(characteristicList, characteristicListElem);
}
}
public decodeCapabilitiesList(elem: Element): ReturnObject<CapabilityList> {
const capabilitiesListElem = this.utils.getElement(elem, 'CapabilityList', NAMESPACES.SML);
if (capabilitiesListElem != null) {
const capabilitiesList = new CapabilityList();
this._profileIDMap = this.utils.processProfileID(
capabilitiesListElem, capabilitiesList, '', this._profileIDMap
);
this.decodeAbstractNamedMetadataList(elem, capabilitiesList);
capabilitiesList.capabilities = this.utils.getDecodedList(
capabilitiesListElem,
'capability',
NAMESPACES.SML, this._profileIDMap,
(char) => this.decodeNamedSweDataComponent(char));
return new ReturnObject(capabilitiesList, capabilitiesListElem);
}
}
public decodeNamedSweDataComponent(elem: Element): ReturnObject<NamedSweDataComponent> {
if (elem != null) {
const comp = new NamedSweDataComponent();
if (elem.hasAttribute('name')) {
comp.name = elem.getAttribute('name');
this._profileIDMap = this.utils.processProfileID(elem, comp, 'name', this._profileIDMap);
}
if (elem.firstElementChild != null) {
const returnObject: ReturnObject<AbstractDataComponent> =
this.sweDecoder.decodeDataComponent(elem.firstElementChild);
if (returnObject) {
comp.component = returnObject.value;
this._profileIDMap = this.utils.processProfileID(
returnObject.docElement, comp, 'component', this._profileIDMap
);
}
}
return new ReturnObject(comp, elem);
}
}
public decodeKeywordList(elem: Element): ReturnObject<KeywordList> {
const keywordListElem = this.utils.getElement(elem, 'KeywordList', NAMESPACES.SML);
if (keywordListElem != null) {
const keywordList = new KeywordList();
this._profileIDMap = this.utils.processProfileID(keywordListElem, keywordList, '', this._profileIDMap);
this.decodeAbstractMetadataList(keywordListElem, keywordList);
const returnObject: ReturnObject<string> = this.utils.getAttributeOfElement(
keywordListElem, 'codeSpace', NAMESPACES.SML, 'href', NAMESPACES.XLINK
);
if (returnObject) {
keywordList.codeSpace = returnObject.value;
this._profileIDMap = this.utils.processProfileID(
returnObject.docElement, keywordList, 'codeSpace', this._profileIDMap
);
}
this.utils.getDecodedList(
keywordListElem,
'keyword',
NAMESPACES.SML, this._profileIDMap,
(keywords) => new ReturnObject(keywordList.keywords.push(keywords.textContent), null));
return new ReturnObject(keywordList, keywordListElem);
}
}
public decodeIdentifierList(elem: Element): ReturnObject<IdentifierList> {
const identifierListElem = this.utils.getElement(elem, 'IdentifierList', NAMESPACES.SML);
if (identifierListElem != null) {
const identifierList = new IdentifierList();
this._profileIDMap = this.utils.processProfileID(
identifierListElem, identifierList, '', this._profileIDMap
);
this.decodeAbstractMetadataList(identifierListElem, identifierList);
identifierList.identifiers = this.utils.getDecodedList(
identifierListElem,
'identifier',
NAMESPACES.SML, this._profileIDMap,
(identifier) => this.decodeTerm(identifier));
return new ReturnObject(identifierList, identifierListElem);
}
}
public decodeClassifierList(elem: Element): ReturnObject<ClassifierList> {
const classifierListElem = this.utils.getElement(elem, 'ClassifierList', NAMESPACES.SML);
if (classifierListElem != null) {
const classifierList = new ClassifierList();
this.decodeAbstractMetadataList(classifierListElem, classifierList);
classifierList.classifiers = this.utils.getDecodedList(
classifierListElem,
'classifier',
NAMESPACES.SML, this._profileIDMap,
(classifier) => this.decodeTerm(classifier));
return new ReturnObject(classifierList, classifierListElem);
}
}
public decodeEventList(elem: Element): ReturnObject<EventList> {
const eventListElem = this.utils.getElement(elem, 'EventList', NAMESPACES.SML);
if (eventListElem != null) {
const eventList = new EventList();
this.decodeAbstractMetadataList(eventListElem, eventList);
eventList.events = this.utils.getDecodedList(
eventListElem,
'event',
NAMESPACES.SML, this._profileIDMap,
(event) => this.decodeEvent(event));
return new ReturnObject(eventList, eventListElem);
}
}
public decodeDocumentList(elem: Element): ReturnObject<DocumentList> {
const documentListElem = this.utils.getElement(elem, 'DocumentList', NAMESPACES.SML);
if (documentListElem != null) {
const documentList = new DocumentList();
this._profileIDMap = this.utils.processProfileID(documentListElem, documentList, '', this._profileIDMap);
this.decodeAbstractMetadataList(documentListElem, documentList);
documentList.documents = this.utils.getDecodedList(
documentListElem,
'document',
NAMESPACES.SML, this._profileIDMap,
(doc) => this.isoDecoder.decodeOnlineResource(doc));
return new ReturnObject(documentList, documentListElem);
}
}
public decodeProcessMethodProcess(elem: Element, object: ProcessMethodProcess): void {
const methodElem = this.utils.getElement(elem, 'method', NAMESPACES.SML);
if (methodElem != null) {
const returnObject: ReturnObject<ProcessMethod> = this.decodeProcessMethod(methodElem);
if (returnObject) {
object.method = returnObject.value;
this._profileIDMap = this.utils.processProfileID(
returnObject.docElement, object, 'method', this._profileIDMap
);
}
}
}
public decodeProcessMethod(elem: Element): ReturnObject<ProcessMethod> {
const processMethodElem = this.utils.getElement(elem, 'ProcessMethod', NAMESPACES.SML);
if (processMethodElem != null) {
const processMethod = new ProcessMethod();
this._profileIDMap = this.utils.processProfileID(processMethodElem, processMethod, '', this._profileIDMap);
this.sweDecoder.decodeAbstractSweIdentifiable(processMethodElem, processMethod);
processMethod.algorithm = this.utils.getDecodedList(
processMethodElem,
'algorithm',
NAMESPACES.SML, this._profileIDMap,
(algorithm) => this.decodeAlgorithm(algorithm));
return new ReturnObject(processMethod, processMethodElem);
}
}
public decodeAlgorithm(elem: Element): ReturnObject<AbstractAlgorithm> {
// TODO implement algorithm
throw new Error('not yet implemented');
}
public decodeAbstractMetadataList(elem: Element, object: AbstractMetadataList): void {
this.sweDecoder.decodeAbstractSweIdentifiable(elem, object);
if (elem.hasAttribute('definition')) {
object.definition = elem.getAttribute('definition');
this._profileIDMap = this.utils.processProfileID(elem, object, 'definition', this._profileIDMap);
}
}
public decodeAbstractNamedMetadataList(elem: Element, object: AbstractNamedMetadataList): void {
if (elem.hasAttribute('name')) {
object.name = elem.getAttribute('name');
this._profileIDMap = this.utils.processProfileID(elem, object, 'name', this._profileIDMap);
}
}
public decodeEvent(elem: Element): ReturnObject<Event> {
const eventElem = this.utils.getElement(elem, 'Event', NAMESPACES.SML);
if (eventElem != null) {
const event = new Event();
this._profileIDMap = this.utils.processProfileID(eventElem, event, '', this._profileIDMap);
this.sweDecoder.decodeAbstractSweIdentifiable(eventElem, event);
event.identification = this.utils.getDecodedList(
eventElem,
'identification',
NAMESPACES.SML, this._profileIDMap,
(identifier) => this.decodeIdentifierList(identifier));
event.classification = this.utils.getDecodedList(eventElem,
'classification',
NAMESPACES.SML, this._profileIDMap,
(classification) => this.decodeClassifierList(classification));
event.contacts = this.utils.getDecodedList(
eventElem,
'contacts',
NAMESPACES.SML, this._profileIDMap,
(contacts) => this.decodeContactList(contacts));
event.documentation = this.utils.getDecodedList(
eventElem,
'documentation',
NAMESPACES.SML, this._profileIDMap,
(documentation) => this.decodeDocumentList(documentation));
event.keywords = this.utils.getDecodedList(
eventElem,
'keywords',
NAMESPACES.SML, this._profileIDMap,
(keyword) => this.decodeKeywordList(keyword));
const timeElem = this.utils.getElement(eventElem, 'time', NAMESPACES.SML);
if (timeElem != null) {
const returnObject: ReturnObject<AbstractTime> = this.gmlDecoder.decodeTime(timeElem);
if (returnObject) {
event.time = returnObject.value;
this._profileIDMap = this.utils.processProfileID(
returnObject.docElement, event, 'time', this._profileIDMap
);
}
}
const propertiesElem = this.utils.getElement(eventElem, 'property', NAMESPACES.SML);
if (propertiesElem != null) {
throw new Error('not implemented');
// event.properties = this.sweDecoder.decodeDataComponent(propertiesElem);
}
const configurationElem = this.utils.getElement(eventElem, 'configuration', NAMESPACES.SML);
if (configurationElem != null) {
const returnObject: ReturnObject<Settings> = this.decodeSettings(configurationElem);
if (returnObject) {
event.configuration = returnObject.value;
this._profileIDMap = this.utils.processProfileID(
returnObject.docElement, event, 'configuration', this._profileIDMap
);
}
}
return new ReturnObject(event, eventElem);
}
}
public decodeSettings(elem: Element): ReturnObject<Settings> {
const settingsElem = this.utils.getElement(elem, 'Settings', NAMESPACES.SML);
if (settingsElem != null) {
const settings = new Settings();
this.sweDecoder.decodeAbstractSwe(settingsElem, settings);
settings.setValue = this.utils.getDecodedList(
settingsElem,
'setValue',
NAMESPACES.SML, this._profileIDMap,
(val) => this.decodeSetValue(val));
settings.setArrayValue = this.utils.getDecodedList(
settingsElem,
'setArrayValue',
NAMESPACES.SML, this._profileIDMap,
(arr) => this.decodeSetArrayValue(arr));
settings.setConstraint = this.utils.getDecodedList(
settingsElem,
'setConstraint',
NAMESPACES.SML, this._profileIDMap,
(constraint) => this.decodeSetConstraint(constraint));
settings.setMode = this.utils.getDecodedList(
settingsElem,
'setMode',
NAMESPACES.SML, this._profileIDMap,
(mode) => this.decodeSetMode(mode));
settings.setStatus = this.utils.getDecodedList(
settingsElem,
'setStatus',
NAMESPACES.SML, this._profileIDMap,
(status) => this.decodeSetStatus(status));
return new ReturnObject(settings, settingsElem);
}
}
public decodeSetStatus(elem: Element): ReturnObject<StatusSetting> {
const statusSett = new StatusSetting();
if (elem.hasAttribute('ref')) {
statusSett.ref = elem.getAttribute('ref');
this._profileIDMap = this.utils.processProfileID(elem, statusSett, 'ref', this._profileIDMap);
}
if (elem.textContent === 'enabled') {
statusSett.value = 'enabled';
this._profileIDMap = this.utils.processProfileID(elem, statusSett, 'value', this._profileIDMap);
}
if (elem.textContent === 'disabled') {
statusSett.value = 'disabled';
this._profileIDMap = this.utils.processProfileID(elem, statusSett, 'disabled', this._profileIDMap);
}
return new ReturnObject(statusSett, elem);
}
public decodeSetMode(elem: Element): ReturnObject<ModeSetting> {
const modeSett = new ModeSetting();
if (elem.hasAttribute('ref')) {
modeSett.ref = elem.getAttribute('ref');
this._profileIDMap = this.utils.processProfileID(elem, modeSett, 'ref', this._profileIDMap);
}
modeSett.value = elem.textContent;
return new ReturnObject(modeSett, elem);
}
public decodeSetValue(elem: Element): ReturnObject<ValueSetting> {
const valueSett = new ValueSetting();
if (elem.hasAttribute('ref')) {
valueSett.ref = elem.getAttribute('ref');
this._profileIDMap = this.utils.processProfileID(elem, valueSett, 'ref', this._profileIDMap);
}
if (elem.textContent === 'true' || elem.textContent === 'false') {
valueSett.value = (elem.textContent === 'true');
} else if (!isNaN(+elem.textContent)) {
valueSett.value = +elem.textContent;
} else if (!isNaN(Date.parse(elem.textContent))) {
// parses everything with number in the string to a date... (maybe use momentjs)
valueSett.value = new Date(Date.parse(elem.textContent));
} else {
valueSett.value = elem.textContent;
}
return new ReturnObject(valueSett, elem);
}
public decodeSetArrayValue(elem: Element): ReturnObject<ArrayValueSetting> {
const arrayValueSett = new ArrayValueSetting();
if (elem.hasAttribute('ref')) {
arrayValueSett.ref = elem.getAttribute('ref');
this._profileIDMap = this.utils.processProfileID(elem, arrayValueSett, 'ref', this._profileIDMap);
}
const encodingElem = this.utils.getElement(elem, 'encoding', NAMESPACES.SML);
if (encodingElem != null) {
const returnObject: ReturnObject<SweEncoding> = this.sweDecoder.decodeAbstractEncoding(encodingElem);
if (returnObject) {
arrayValueSett.encoding = returnObject.value;
this._profileIDMap = this.utils.processProfileID(
returnObject.docElement, arrayValueSett, 'encoding', this._profileIDMap
);
}
}
const valueElem = this.utils.getElement(elem, 'value', NAMESPACES.SML);
if (valueElem != null) {
arrayValueSett.value = valueElem.textContent;
this._profileIDMap = this.utils.processProfileID(valueElem, arrayValueSett, 'value', this._profileIDMap);
}
return new ReturnObject(arrayValueSett, elem);
}
public decodeSetConstraint(elem: Element): ReturnObject<ConstraintSetting> {
const constraintSett = new ConstraintSetting();
if (elem.hasAttribute('ref')) {
constraintSett.ref = elem.getAttribute('ref');
this._profileIDMap = this.utils.processProfileID(elem, constraintSett, 'ref', this._profileIDMap);
}
if (elem.firstElementChild != null) {
const returnObject: ReturnObject<AllowedTimes | AllowedTokens | AllowedValues> =
this.sweDecoder.decodeConstraint(elem.firstElementChild);
if (returnObject) {
constraintSett.value = returnObject.value;
this._profileIDMap = this.utils.processProfileID(
returnObject.docElement, constraintSett, 'value', this._profileIDMap
);
}
}
return new ReturnObject(constraintSett, elem);
}
public decodeTerm(elem: Element): ReturnObject<Term> {
const termElem = this.utils.getElement(elem, 'Term', NAMESPACES.SML);
if (termElem != null) {
const term = new Term();
this._profileIDMap = this.utils.processProfileID(termElem, term, 'Term', this._profileIDMap);
if (termElem.hasAttribute('definition')) {
term.definition = termElem.getAttribute('definition');
}
const label = this.utils.getElement(termElem, 'label', NAMESPACES.SML);
if (label != null) {
term.label = label.textContent;
this._profileIDMap = this.utils.processProfileID(label, term, 'label', this._profileIDMap);
}
const value = this.utils.getElement(termElem, 'value', NAMESPACES.SML);
if (value != null) {
term.value = value.textContent;
this._profileIDMap = this.utils.processProfileID(value, term, 'value', this._profileIDMap);
}
const returnObject: ReturnObject<string> = this.utils.getAttributeOfElement(
termElem, 'codeSpace', NAMESPACES.SML, 'href', NAMESPACES.XLINK
);
if (returnObject) {
term.codeSpace = returnObject.value;
}
return new ReturnObject(term, termElem);
}
}
}