egroupware/api/js/etemplate/et2_core_inheritance.js

/**
 * EGroupware eTemplate2 - JS code for implementing inheritance with attributes
 *
 * @license http://opensource.org/licenses/gpl-license.php GPL - GNU General Public License
 * @package etemplate
 * @subpackage api
 * @link: https://www.egroupware.org
 * @author Andreas Stöckel
 */
/*egw:uses
    et2_core_common;
*/
import { egw } from "../jsapi/egw_global";
import { et2_checkType, et2_no_init, et2_validateAttrib } from "./et2_core_common";
import { et2_implements_registry } from "./et2_core_interfaces";
export class ClassWithAttributes {
    /**
     * Returns the value of the given attribute. If the property does not
     * exist, an error message is issued.
     *
     * @param {string} _name
     * @return {*}
     */
    getAttribute(_name) {
        if (typeof this.attributes[_name] != "undefined" &&
            !this.attributes[_name].ignore) {
            if (typeof this["get_" + _name] == "function") {
                return this["get_" + _name]();
            }
            else {
                return this[_name];
            }
        }
        else {
            egw.debug("error", this, "Attribute '" + _name + "' does not exist!");
        }
    }
    /**
     * The setAttribute function sets the attribute with the given name to
     * the given value. _override defines, whether this[_name] will be set,
     * if this key already exists. _override defaults to true. A warning
     * is issued if the attribute does not exist.
     *
     * @param {string} _name
     * @param {*} _value
     * @param {boolean} _override
     */
    setAttribute(_name, _value, _override) {
        if (typeof this.attributes[_name] != "undefined") {
            if (!this.attributes[_name].ignore) {
                if (typeof _override == "undefined") {
                    _override = true;
                }
                var val = et2_checkType(_value, this.attributes[_name].type, _name, this);
                if (typeof this["set_" + _name] == "function") {
                    this["set_" + _name](val);
                }
                else if (_override || typeof this[_name] == "undefined") {
                    this[_name] = val;
                }
            }
        }
        else {
            egw.debug("warn", this, "Attribute '" + _name + "' does not exist!");
        }
    }
    /**
     * generateAttributeSet sanitizes the given associative array of attributes
     * (by passing each entry to "et2_checkType" and checking for existance of
     * the attribute) and adds the default values to the associative array.
     *
     * @param {object} _attrs is the associative array containing the attributes.
     */
    static generateAttributeSet(widget, _attrs) {
        // Sanity check and validation
        for (var key in _attrs) {
            if (typeof widget[key] != "undefined") {
                if (!widget[key].ignore) {
                    _attrs[key] = et2_checkType(_attrs[key], widget[key].type, key, this);
                }
            }
            else {
                // Key does not exist - delete it and issue a warning
                delete (_attrs[key]);
                egw.debug("warn", this, "Attribute '" + key +
                    "' does not exist in " + _attrs.type + "!");
            }
        }
        // Include default values or already set values for this attribute
        for (var key in widget) {
            if (typeof _attrs[key] == "undefined") {
                var _default = widget[key]["default"];
                if (_default == et2_no_init) {
                    _default = undefined;
                }
                _attrs[key] = _default;
            }
        }
        return _attrs;
    }
    /**
     * The initAttributes function sets the attributes to their default
     * values. The attributes are not overwritten, which means, that the
     * default is only set, if either a setter exists or this[propName] does
     * not exist yet.
     *
     * @param {object} _attrs is the associative array containing the attributes.
     */
    initAttributes(_attrs) {
        for (var key in _attrs) {
            if (typeof this.attributes[key] != "undefined" && !this.attributes[key].ignore && !(_attrs[key] == undefined)) {
                this.setAttribute(key, _attrs[key], false);
            }
        }
    }
    static buildAttributes(class_prototype) {
        let class_tree = [];
        let attributes = {};
        let n = 0;
        do {
            n++;
            class_tree.push(class_prototype);
            class_prototype = Object.getPrototypeOf(class_prototype);
        } while (class_prototype !== ClassWithAttributes && n < 50);
        for (let i = class_tree.length - 1; i >= 0; i--) {
            attributes = ClassWithAttributes.extendAttributes(attributes, class_tree[i]._attributes);
        }
        return attributes;
    }
    /**
     * Extend current _attributes with the one from the parent class
     *
     * This gives inheritance from the parent plus the ability to override in the current class.
     *
     * @param _attributes
     * @param _parent
     */
    static extendAttributes(_parent, _attributes) {
        function _copyMerge(_new, _old) {
            var result = {};
            // Copy the new object
            if (typeof _new != "undefined") {
                for (var key in _new) {
                    result[key] = _new[key];
                }
            }
            // Merge the old object
            for (var key in _old) {
                if (typeof result[key] == "undefined") {
                    result[key] = _old[key];
                }
            }
            return result;
        }
        var attributes = {};
        // Copy the old attributes
        for (var key in _attributes) {
            attributes[key] = _copyMerge({}, _attributes[key]);
        }
        // Add the old attributes to the new ones. If the attributes already
        // exist, they are merged.
        for (var key in _parent) {
            var _old = _parent[key];
            attributes[key] = _copyMerge(attributes[key], _old);
        }
        // Validate the attributes
        for (var key in attributes) {
            et2_validateAttrib(key, attributes[key]);
        }
        return attributes;
    }
    /**
     * The implements function can be used to check whether the object
     * implements the given interface.
     *
     * As TypeScript can not (yet) check if an objects implements an interface on runtime,
     * we currently implements with each interface a function called 'implements_'+interfacename
     * to be able to check here.
     *
     * @param _iface name of interface to check
     */
    implements(_iface_name) {
        if (typeof et2_implements_registry[_iface_name] === 'function' &&
            et2_implements_registry[_iface_name](this)) {
            return true;
        }
        return false;
    }
    /**
     * Check if object is an instance of a class or implements an interface (specified by the interfaces name)
     *
     * @param _class_or_interfacename class(-name) or string with name of interface
     */
    instanceOf(_class_or_interfacename) {
        if (typeof _class_or_interfacename === 'string') {
            return this.implements(_class_or_interfacename);
        }
        return this instanceof _class_or_interfacename;
    }
}
//# sourceMappingURL=et2_core_inheritance.js.map