File

libs/sensorml/src/lib/services/xml/XPathDocument.ts

Index

Properties
Methods

Constructor

constructor(document: Document)
Parameters :
Name Type Optional
document Document No

Properties

Public document
Type : Document

Methods

Private _eval
_eval(expression: string, context?: Node)
Parameters :
Name Type Optional
expression string No
context Node Yes
Returns : any
Public eval
eval(expr: string, context?: Node)
Parameters :
Name Type Optional
expr string No
context Node Yes
Returns : boolean | string | number | Node | []
Static parse
parse(xml: string)
Parameters :
Name Type Optional
xml string No
Returns : XPathDocument
Private parseIterator
parseIterator(result: XPathResult)
Parameters :
Name Type Optional
result XPathResult No
Returns : Node[]
Private parseSnapshot
parseSnapshot(result: XPathResult)
Parameters :
Name Type Optional
result XPathResult No
Returns : Node[]
import { SensorMLNamespaceResolver } from './SensorMLNamespaceResolver';

export class XPathDocument {

    public static parse(xml: string): XPathDocument {
        const parser = new DOMParser();
        const document = parser.parseFromString(xml, 'application/xml');
        return new XPathDocument(document);
    }

    constructor(public document: Document) { }

    public eval(expr: string, context?: Node): boolean | string | number | Node | Node[] {
        const result = this._eval(expr, context);

        switch (result.resultType) {
            case XPathResult.FIRST_ORDERED_NODE_TYPE:
                return result.singleNodeValue;
            case XPathResult.ANY_UNORDERED_NODE_TYPE:
                return result.singleNodeValue;
            case XPathResult.BOOLEAN_TYPE:
                return result.booleanValue;
            case XPathResult.NUMBER_TYPE:
                return result.numberValue;
            case XPathResult.STRING_TYPE:
                return result.stringValue;
            case XPathResult.ORDERED_NODE_ITERATOR_TYPE:
                return this.parseIterator(result);
            case XPathResult.UNORDERED_NODE_ITERATOR_TYPE:
                return this.parseIterator(result);
            case XPathResult.ORDERED_NODE_SNAPSHOT_TYPE:
                return this.parseSnapshot(result);
            case XPathResult.UNORDERED_NODE_SNAPSHOT_TYPE:
                return this.parseSnapshot(result);
            default:
                throw new Error('Unsupported result type: ' + result.resultType);
        }
    }

    private parseSnapshot(result: XPathResult): Node[] {
        const array: Node[] = new Array<Node>(result.snapshotLength);
        for (let i = 0; i < result.snapshotLength; ++i) {
            array[i] = result.snapshotItem(i);
        }
        return array;
    }

    private parseIterator(result: XPathResult): Node[] {
        const array: Node[] = [];
        let node: Node = result.iterateNext();
        while (node != null) {
            array.push(node);
            node = result.iterateNext();
        }
        return array;
    }

    private _eval(expression: string, context?: Node) {
        context = context || this.document.documentElement;
        const resolver: XPathNSResolver = {
            lookupNamespaceURI(prefix: string): string {
                return new SensorMLNamespaceResolver().getNamespace(prefix);
            }
        };
        return this.document.evaluate(
            expression, context, resolver, XPathResult.ANY_TYPE, null);
    }

}

result-matching ""

    No results matching ""