widget.js

/**
 * This module representing a Context Widget.
 * 
 * @module Widget
 */
define(['MathUuid', 'callback', 'callbackList', 'attribute', 'attributeList', 'conditionList', 'subscriber', 'subscriberList'],
	function(MathUuid, Callback, CallbackList, Attribute, AttributeList, ConditionList, Subscriber, SubscriberList) {
		return (function() {

			/**
			 * Defines all outAttributes and constOutAttributes as an object.
			 * @type {object}
			 * @public
			 */
			Widget.inOut = {
				out: [
					{
						"name":"",
						"type":"",
						"value":""
					}
				],
				const: [
					{
						"name":"",
						"type":"",
						"value":""
					}
				]
			};

			/**
			 * Constructor: Generates the ID and initializes the
			 * Widget with attributes, callbacks and subscriber
			 * that are specified in the provided functions.
			 *
			 * @abstract
			 * @classdesc The Widget handles the access to sensors.
			 * @constructs Widget
			 */
			function Widget(discoverer, attributes) {
				var self = this;

				/**
				 * Name of the Widget.
				 *
				 * @public
				 * @type {string}
				 */
				this.name = 'Widget';

				/**
				 * ID of the Widget. Will be generated.
				 *
				 * @type {string}
				 */
				this.id = Math.uuid();

				/**
				 *
				 * @protected
				 * @type {AttributeList}
				 * @memberof Widget#
				 * @desc All available Attributes and their values.
				 */
				this._outAttributes = new AttributeList();

				/**
				 * @alias oldAttributes
				 * @protected
				 * @type {AttributeList}
				 * @memberof Widget#
				 * @desc This temporary variable is used for storing the old attribute values.
				 * 			So these can be used to check conditions.
				 */
				this._oldOutAttributes = new AttributeList();

				/**
				 * @alias constantAttributes
				 * @protected
				 * @type {AttributeList}
				 * @memberof Widget#
				 * @desc All available constant Attributes and their values.
				 */
				this._constantOutAttributes = new AttributeList();

				/**
				 * @alias callbacks
				 * @protected
				 * @type {CallbackList}
				 * @memberof Widget#
				 * @desc List of Callbacks.
				 */
				this._callbacks = new CallbackList();

				/**
				 * @alias subscribers
				 * @protected
				 * @type {SubscriberList}
				 * @memberof Widget#
				 * @desc List of Subscriber.
				 */
				this._subscribers = new SubscriberList();

				/**
				 * Associated discoverer.
				 *
				 * @type {Discoverer}
				 * @private
				 */
				this._discoverer = discoverer;

				this._register();
				this._init(attributes);

				return this;
			}

			/**
			 * Initializes the provided Attributes.
			 *
			 * @private
			 */
			Widget.prototype._initOutAttributes = function() {
				for(var outAttributeIndex in this.constructor.inOut.out) {
					var out = this.constructor.inOut.out[outAttributeIndex];
					this._outAttributes.put(this._discoverer.buildAttribute(
						out.name,
						out.type,
						out.parameterList,
						true
					));
				}
			};

			/**
			 * Initializes the provided ConstantAttributes.
			 *
			 * @private
			 */
			Widget.prototype._initConstantOutAttributes = function() {
				for(var constAttributeIndex in this.constructor.inOut.const) {
					var constants = this.constructor.inOut.const[constAttributeIndex];
					this._outAttributes.put(this._discoverer.buildAttribute(
						constants.name,
						constants.type,
						constants.parameterList,
						true
					));
				}
			};

			/**
			 * Initializes the provided Callbacks.
			 *
			 * @abstract
			 * @protected
			 */
			Widget.prototype._initCallbacks = function() {
				throw new Error("Abstract function!");
			};

			/**
			 * Function for initializing. Calls all initFunctions
			 * and will be called by the constructor.
			 *
			 * @protected
			 */
			Widget.prototype._init = function(attributes) {
				this._initOutAttributes();
				this._initConstantOutAttributes();
				this._initCallbacks();

				this.didFinishInitialization(attributes);
			};

			/**
			 * Method will be invoked after the initialization of the widget finished.
			 * Can be overridden by inheriting classes to take action after initialization.
			 *
			 * @public
			 * @virtual
			 * @param attributes
			 */
			Widget.prototype.didFinishInitialization = function(attributes) {

			};

			/**
			 * Returns the name of the widget.
			 *
			 * @public
			 * @alias getName
			 * @memberof Widget#
			 * @returns {string}
			 */
			Widget.prototype.getName = function() {
				return this.name;
			};

			/**
			 * Returns the id of the widget.
			 *
			 * @public
			 * @alias getId
			 * @memberof Widget#
			 * @returns {string}
			 */
			Widget.prototype.getId = function() {
				return this.id;
			};

			/**
			 * Returns the available AttributeTypes.
			 *
			 * @public
			 * @param {?AttributeList} [attributes]
			 * @returns {AttributeList}
			 */
			Widget.prototype.getOutAttributes = function(attributes) {
				// test if attributeList is a list
				if (attributes && attributes instanceof AttributeList) {
					return this._outAttributes.getSubset(attributes);
				} else {
					return this._outAttributes;
				}
			};

			/**
			 * Returns the available ConstantAttributeTypes
			 * (attributes that do not change).
			 *
			 * @public
			 * @param {?AttributeList} attributes
			 * @returns {AttributeList}
			 */
			Widget.prototype.getConstantOutAttributes = function(attributes) {
				if (attributes && attributes instanceof AttributeList) {
					return this._constantOutAttributes.getSubset(attributes);
				} else {
					return this._constantOutAttributes;
				}
			};

			/**
			 * Returns the last acquired attribute value with the given attribute type.
			 *
			 * @param {AttributeType} attributeType The attribute type to return the last value for.
			 * @returns {*}
			 */
			Widget.prototype.getValueForAttributeWithTypeOf = function(attributeType) {
				return this.getOutAttributes().getAttributeWithTypeOf(attributeType).getValue();
			};

			/**
			 * Returns the old Attributes.
			 *
			 * @private
			 * @alias getOldAttributes
			 * @memberof Widget#
			 * @returns {AttributeList}
			 */
			Widget.prototype.getOldAttributes = function() {
				return this._oldOutAttributes;
			};

			/**
			 * Returns a list of callbacks that can be
			 * subscribed to.
			 *
			 * @public
			 * @alias getCallbacks
			 * @memberof Widget#
			 * @returns {CallbackList}
			 */
			Widget.prototype.getCallbackList = function() {
				return this._callbacks;
			};

			/**
			 * Returns the specified callbacks that can be
			 * subscribed to.
			 *
			 * @public
			 * @alias getCallbacks
			 * @memberof Widget#
			 * @returns {Array}
			 */
			Widget.prototype.getCallbacks = function() {
				return this._callbacks.getItems();
			};

			Widget.prototype.queryServices = function() {
				return this.services;
			};

			/**
			 * Returns the Subscriber.
			 *
			 * @public
			 * @alias getSubscriber
			 * @memberof Widget#
			 * @returns {SubscriberList}
			 */
			Widget.prototype.getSubscriber = function() {
				return this._subscribers;
			};

			/**
			 * Sets the name of the Widget.
			 *
			 * @protected
			 * @alias setName
			 * @memberof Widget#
			 * @param {string} name Name of the Widget.
			 */
			Widget.prototype.setName = function(name) {
				if (typeof name === 'string') {
					this.name = name;
				}
			};

			/**
			 * Sets the id of the Widget.
			 *
			 * @protected
			 * @alias setId
			 * @memberof Widget#
			 * @param {string} id Id of the Widget.
			 */
			Widget._setId = function(id) {
				if (typeof id === 'string') {
					this.id = id;
				}
			};

			/**
			 * Sets the AttributeValueList and also the associated
			 * AttributeTypes.
			 *
			 * @protected
			 * @param {(AttributeList|Array)} attributesOrArray List or Array of AttributeValues
			 */
			Widget.prototype._setOutAttributes = function(attributesOrArray) {
				this._outAttributes = new AttributeList().withItems(attributesOrArray);
			};

			/**
			 * Adds a new AttributeValue. If the given value is
			 * not included in the list, the associated type will
			 * be also added. Otherwise, only the value will be
			 * updated.
			 *
			 * @public
			 * @param {Attribute} attribute
			 * @param {Boolean} multipleInstances
			 */
			Widget.prototype.addOutAttribute = function(attribute, multipleInstances) {
				multipleInstances = typeof multipleInstances == "undefined" ? false : multipleInstances;
				if (attribute instanceof Attribute) {
					if (!this._outAttributes.containsTypeOf(attribute)) {
						this._oldOutAttributes = this._outAttributes;
						attribute.setTimestamp(this.getCurrentTime());
						this._outAttributes.put(attribute, multipleInstances);
					}
				}
			};

			/**
			 * Sets the ConstantAttributeValueList and also the
			 * associated AttributeTypes.
			 *
			 * @protected
			 * @alias setConstantOutAttributes
			 * @memberof Widget#
			 * @param {(AttributeList|Array)} constantAttributes List or Array of AttributeValues
			 */
			Widget.prototype._setConstantOutAttributes = function(constantAttributes) {
				this._constantOutAttributes = new AttributeList().withItems(constantAttributes);
			};

			/**
			 * Adds a new constantAttributeValue. If the given value is
			 * not included in the list, the associated type will
			 * be also added. Otherwise, only the value will be
			 * updated.
			 *
			 * @protected
			 * @param {Attribute} constantAttribute AttributeValue
			 */
			Widget.prototype._addConstantOutAttribute = function(constantAttribute) {
				if (Class.isA(AttributeValue, constantAttribute)) {
					if (!this.constantAttributes
							.contains(constantAttribute)) {

						var type = new AttributeType().withName(constantAttribute.getName())
							.withType(constantAttribute.getType())
							.withParameters(constantAttribute.getParameters());
						this.constantAttributeTypes.put(type);
					}
					_attribute.setTimestamp(this.getCurrentTime());
					this.constantAttributes.put(constantAttribute);
				}
			};

			/**
			 * Sets Callbacks.
			 *
			 * @protected
			 * @alias setCallbacks
			 * @memberof Widget#
			 * @param {(CallbackList|Array)} callbacks List or Array of Callbacks.
			 */
			Widget.prototype._setCallbacks = function(callbacks) {
				var list = [];
				if (callbacks instanceof Array) {
					list = callbacks;
				} else if (callbacks instanceof CallbackList) {
					list = callbacks.getItems();
				}
				for ( var i in list) {
					var callback = list[i];
					if (callback instanceof Callback) {
						this.callbacks.put(callback);
					}
				}
			};

			/**
			 * Adds a new Callback.
			 *
			 * @protected
			 * @alias addCallback
			 * @memberof Widget#
			 * @param {Callback} callback List or Array of AttributeValues.
			 */
			Widget.prototype._addCallback = function(callback) {
				if (callback instanceof Callback) {
					this._callbacks.put(callback);
				}
			};

			Widget.prototype._setServices = function(services) {
				this.services = services;
			};

			/**
			 * Sets SubscriberList.
			 *
			 * @protected
			 * @alias setSubscriber
			 * @memberof Widget#
			 * @param {(SubscriberList|Array)}  subscribers List or Array of Subscriber.
			 */
			Widget.prototype._setSubscriber = function(subscribers) {
				var list = [];
				if (subscribers instanceof Array) {
					list = subscribers;
				} else if (subscribers instanceof SubscriberList) {
					list = subscribers.getItems();
				}
				for ( var i in list) {
					var singleSubscriber = list[i];
					if (singleSubscriber instanceof Subscriber) {
						this._subscribers.put(singleSubscriber);
					}
				}
			};

			/**
			 * Adds a new Subscriber.
			 *
			 * @public
			 * @param {?Subscriber} subscriber Subscriber
			 */
			Widget.prototype.addSubscriber = function(subscriber) {
				if (subscriber && subscriber instanceof Subscriber) {
					this._subscribers.put(subscriber);
				}
			};

			/**
			 * Removes the specified Subscriber.
			 *
			 * @public
			 * @param {Subscriber} subscriberId Subscriber
			 */
			Widget.prototype.removeSubscriber = function(subscriberId) {
				this._subscribers.removeSubscriberWithId(subscriberId);
			};

			/**
			 * Returns the current time.
			 *
			 * @private
			 * @returns {Date}
			 */
			Widget.prototype.getCurrentTime = function() {
				return new Date();
			};

			/**
			 * Verifies whether the specified attributes is a
			 * provided Attribute.
			 *
			 * @protected
			 * @alias isOutAttribute
			 * @memberof Widget#
			 * @param {Attribute} attribute
			 * @returns {boolean}
			 */
			Widget.prototype._isOutAttribute = function(attribute) {
				return !!this._outAttributes.containsTypeOf(attribute);
			};

			/**
			 * Notifies other components and sends the attributes.
			 *
			 * @virtual
			 * @public
			 */
			Widget.prototype.notify = function() {
				var callbacks = this.getCallbacks();
				for (var i in callbacks) {
					this.sendToSubscriber(callbacks[i]);
				}
			};

			/**
			 * Queries the associated sensor and updates the attributes with new values.
			 * Must be overridden by the subclasses. Overriding subclasses can call
			 * this.__super(_function) to invoke the provided callback function.
			 *
			 * @virtual
			 * @public
			 * @param {?function} callback For alternative actions, because an asynchronous function can be used.
			 */
			Widget.prototype.sendToSubscriber = function(callback) {
				if (callback && typeof(callback) == 'function') {
					callback();
				}
			};

			/**
			 *
			 * @abstract
			 * @param callback
			 */
			Widget.prototype.queryGenerator = function (callback) {
				throw "Call to abstract method 'queryGenerator'.";
			};

			/**
			 *
			 * @param response
			 * @param callback
			 * @protected
			 */
			Widget.prototype._sendResponse = function(response, callback) {
				this.putData(response);
				this.notify();

				if (callback && typeof(callback) == 'function') {
					callback();
				}
			};

			/**
			 * Updates the attributes by calling queryGenerator.
			 *
			 * @public
			 * @alias updateWidgetInformation
			 * @memberof Widget#
			 * @param {?function} callback For alternative  actions, because an asynchronous function can be used.
			 *
			 */
			Widget.prototype.updateWidgetInformation = function(callback) {
				this.queryGenerator(callback);
			};

			/**
			 * Updates the Attributes by external components.
			 *
			 * @param {(AttributeList|Array)} attributes Data that should be entered.
			 */
			Widget.prototype.putData = function(attributes) {
				var list = [];
				if (attributes instanceof Array) {
					list = attributes;
				} else if (attributes instanceof AttributeList) {
					list = attributes.getItems();
				}
				for ( var i in list) {
					var theAttribute = list[i];
					if (theAttribute.type === Attribute && this.isOutAttribute(theAttribute)) {
						this.addOutAttribute(theAttribute);
					}
				}
			};

			/**
			 * Returns all available AttributeValues, Attributes and ConstantAttributes.
			 *
			 * @public
			 * @returns {AttributeList}
			 */
			Widget.prototype.queryWidget = function() {
				var response = new AttributeList();
				response.putAll(this.getOutAttributes());
				response.putAll(this.getConstantOutAttributes());
				return response;
			};

			/**
			 * Updates and returns all available AttributeValues,
			 * Attributes and ConstantAtrributes.
			 *
			 * @public
			 * @alias updateAndQueryWidget
			 * @memberof Widget#
			 * @param {?function} callback For alternative  actions, because an asynchronous function can be used.
			 * @returns {?AttributeList}
			 */
			Widget.prototype.updateAndQueryWidget = function(callback) {
				if(callback && typeof(callback) === 'function'){
					this.queryGenerator(callback);
				} else {
					this.queryGenerator();
					return this.queryWidget();
				}
			};

			/**
			 * Sends all Attributes, specified in the given callback,
			 * to components which are subscribed to this Callback.
			 *
			 * @protected
			 * @param {string} callback Name of the searched Callback.
			 */
			Widget.prototype._sendToSubscriber = function(callback) {
				if (callback && callback instanceof Callback) {
					var subscriberList = this._subscribers.getItems();
					for (var i in subscriberList) {
						var subscriber = subscriberList[i];
						if (subscriber.getSubscriptionCallbacks().contains(callback)) {
							if(this.dataValid(subscriber.getConditions())){
								var subscriberInstance = this._discoverer.getComponent(subscriber.getSubscriberId());
								var callSubset =  callback.getAttributeTypes();
								var subscriberSubset = subscriber.getAttributesSubset();
								var data = this.outAttributes.getSubset(callSubset);
								if (subscriberSubset && subscriberSubset.size() > 0) {
									data = data.getSubset(subscriberSubset);
								}
							}
							if (data) {
								subscriberInstance.putData(data);
							}
						}
					}
				}
			};

			/**
			 * Verifies if the attributes match to the specified conditions in case any exists.
			 *
			 * @private
			 * @alias dataValid
			 * @memberof Widget#
			 * @param {string} conditions List of Conditions that will be verified.
			 * @returns {boolean}
			 */
			Widget.prototype._dataValid = function(conditions) {
				if (conditions instanceof ConditionList) {
					return true;
				}
				if (!conditions.isEmpty()) {
					var items = _condition.getItems();
					for (var i in items) {
						var condition = items[i];
						var conditionAttributeType = condition.getAttributeType();
						var conditionAttributeTypeList = new AttributeTypeList()
							.withItems(new Array(conditionAttributeType));
						var newValue = this.getAttributes().getSubset(conditionAttributeTypeList);
						var oldValue = this.getOldAttributes.getSubset(conditionAttributeTypeList);
						return condition.compare(newValue, oldValue);
					}
				}
				return false;
			};

			/**
			 * Runs the context acquisition constantly in an interval.
			 * Can be called by init.
			 *
			 * @virtual
			 * @protected
			 * @param {Number} interval Interval in ms
			 */
			Widget.prototype._intervalRunning = function(interval) {
				var self = this;
				if (interval === parseInt(interval)) {
					setInterval(function() {self.queryGenerator();}, interval);
				}
			};

			/**
			 * Sets the associated Discoverer and registers to that.
			 *
			 * @public
			 * @param {Discoverer} _discoverer Discoverer
			 */
			Widget.prototype.setDiscoverer = function(_discoverer) {
				if (!this._discoverer) {
					this._discoverer = _discoverer;
					this._register();
				}
			};

			/**
			 * Registers the component to the associated Discoverer.
			 *
			 * @protected
			 */
			Widget.prototype._register = function() {
				if (this._discoverer) {
					this._discoverer.registerNewComponent(this);
				}
			};

			/**
			 * Returns true if the widget can satisfy the requested attribute type.
			 *
			 * @public
			 * @param {AttributeType} attribute
			 * @returns {boolean}
			 */
			Widget.prototype.doesSatisfyTypeOf = function(attribute) {
				return this._outAttributes.containsTypeOf(attribute);
			};

			return Widget;
		})();
	}
);