Initial work on Nucleus parity merge

Packages/ohif-viewerbase/client/lib/classes/metadata/InstanceMetadata.js

@@ -0,0 +1,173 @@
+import { Metadata } from './Metadata';
+
+const UNDEFINED = 'undefined';
+const NUMBER = 'number';
+const STRING = 'string';
+const REGEX_TAG = /^x[0-9a-f]{8}$/;
+
+export class InstanceMetadata extends Metadata {
+
+    constructor(data) {
+        super(data);
+        this._sopInstanceUID = null;
+    }
+
+    /**
+     * Returns the SOPInstanceUID of the current instance.
+     */
+    getSOPInstanceUID() {
+        return this._sopInstanceUID;
+    }
+
+    // @TODO: Improve this... (E.g.: blob data)
+    getStringValue(tagOrProperty, index, defaultValue) {
+        let value = this.getRawValue(tagOrProperty, defaultValue);
+
+        if (typeof value !== STRING && typeof value !== UNDEFINED) {
+            value = value.toString(); 
+        }
+
+        return InstanceMetadata.getIndexedValue(value, index, defaultValue);
+    }
+
+    // @TODO: Improve this... (E.g.: blob data)
+    getFloatValue(tagOrProperty, index, defaultValue) {
+        let value = this.getRawValue(tagOrProperty, defaultValue);
+        value = InstanceMetadata.getIndexedValue(value, index, defaultValue);
+
+        if(value instanceof Array) {
+            value.forEach( (val, idx) => {
+                value[idx] = parseFloat(val);
+            });
+            
+            return value;
+        }
+
+        return typeof value === STRING ? parseFloat(value) : value;
+    }
+
+    // @TODO: Improve this... (E.g.: blob data)
+    getIntValue(tagOrProperty, index, defaultValue) {
+        let value = this.getRawValue(tagOrProperty, defaultValue);
+        value = InstanceMetadata.getIndexedValue(value, index, defaultValue);
+
+        if(value instanceof Array) {
+            value.forEach( (val, idx) => {
+                value[idx] = parseFloat(val);
+            });
+
+            return value;
+        }
+
+        return typeof value === STRING ? parseInt(value) : value;
+    }
+
+    /**
+     * 
+     */
+    getRawValue(tagOrProperty, defaultValue) {
+        /**
+         * Please override this method on a specialized class.
+         */
+    }
+
+    /**
+     * Compares the current instance with another one.
+     * @param {InstanceMetadata} instance An instance of the InstanceMetadata class.
+     * @returns {boolean} Returns true if both instances refer to the same instance.
+     */
+    equals(instance) {
+        const self = this;
+        return (
+            instance === self ||
+            (
+                instance instanceof InstanceMetadata &&
+                instance.getSOPInstanceUID() === self.getSOPInstanceUID()
+            )
+        );
+    }
+
+    /**
+     * Check if the tagOrProperty exists
+     * @param  {String} tagOrProperty tag or property be checked
+     * @return {Boolean}   True if the tag or property exists or false if doesn't
+     */
+    tagExists(tagOrProperty) {
+        /**
+         * Please override this method
+         */
+    }
+
+    /**
+    * Returns a URI for the specified resource related to this instance (if an instance).
+    * @param {string} resource The name of the resource. This name cannot have any leading or
+    * trailing slashes
+    * @param {string|number} [optParameter] An optional parameter. This cannot have any leading or
+    * trailing slashes
+    * @returns {string|undefined} The constructed URI for the specified resource related to this
+    * instance or undefined if this sequence is a sub-sequence (i.e.: it has no related resources of
+    * its own).
+    */
+    getResourceUri(resource, optParameter) {
+        /**
+         * Please override this method
+         */
+    }
+
+    /**
+     * Static Methods
+     */
+
+    static getTagInfo(tagOrProperty) {
+        let tagName = null,
+            propertyName = null;
+
+        if (typeof tagOrProperty === NUMBER) {
+            // if it's a number, build an hexadecimal representation...
+            tagName = 'x' + ('00000000' + tagOrProperty.toString(16)).substr(-8);
+        } else if (typeof tagOrProperty === STRING && REGEX_TAG.test(tagOrProperty)) {
+            tagName = tagOrProperty;
+        } else {
+            // use it as a property name otherwise...
+            propertyName = tagOrProperty;
+        }
+
+        // @TODO: map tagName to propertyName and vice versa
+
+        return { tagName, propertyName };
+    }
+
+    /**
+     * Get an value based that can be index based. This function is called by all getters. See above functions.
+     *     - If value is a String and has indexes:
+     *         - If undefined index: returns an array of the split values.
+     *         - If defined index: 
+     *             - If invalid: returns defaultValue
+     *             - If valid: returns the indexed value
+     *      - If value is not a String, returns default value.
+     */
+    static getIndexedValue(value, index, defaultValue) {
+        let result = defaultValue;
+
+        if (typeof value === STRING) {
+            const hasIndexValues = value.indexOf('\\') !== -1;
+
+            result = value;
+
+            if(hasIndexValues) {
+                const splitValues = value.split('\\');
+                if (Metadata.isValidIndex(index)) {
+                    const indexedValue = splitValues[index];
+
+                    result = typeof indexedValue !== STRING ? defaultValue : indexedValue;
+                }
+                else {
+                    result = splitValues;
+                }
+            }
+        }
+
+        return result;
+    }
+
+}