discoverer.js

define(['attributeList', 'attribute', 'translation', 'parameter', 'parameterList', 'widget', 'interpreter', 'aggregator',  'interpretation' ],
	function(AttributeList, Attribute, Translation, Parameter, ParameterList, Widget, Interpreter, Aggregator, Interpretation) {
		return (function() {
			/**
			 * Constructor: All known components given in the associated functions will be registered as startup.
			 *
			 * @classdesc The Discoverer handles requests for components and attributes.
			 * @constructs Discoverer
			 */
			function Discoverer(widgets, interpreters, translations) {
				/**
				 * List of available Widgets.
				 *
				 * @type {Array}
				 * @private
				 */
				this._widgets = [];

				/**
				 * List of unregistered Widgets
				 *
				 * @type (Array)
				 * @private
				 */
				this._unregisteredWidgets = widgets;


				/**
				 * List of available Aggregators.
				 *
				 * @type {Array}
				 * @private
				 */
				this._aggregators = [];

				/**
				 * List of available Interpreter.
				 *
				 * @type {Object}
				 * @private
				 */
				this._interpreters = [];

				/**
				 * List of unregistered Interpreters
				 *
				 * @type (Array)
				 * @private
				 */
				this._unregisteredInterpreters = interpreters;

				/**
				 * List of translations or synonymous attributes, respectively.
				 *
				 * @type {Array}
				 * @private
				 */
				this._translations = [];

				// build translations from input array
                for (var i in translations) {
					// get translation (an array) from array of translations
                    var translationArray = translations[i];
					// check for correct cardinality
                    if (translationArray.length != 2)
                        throw new Error("Translations must consist of exactly 2 attributes!");
					// check for correct number of attribute building blocks
					for (var j in translationArray) {
                        if (translationArray[j].length > 3 || translationArray[j].length < 2)
                            throw new Error("Please provide a name, type and (optional) list of parameters!");
                    }
					// build attributes from arrays containing name, type (and parameters)
                    var firstAttribute = this.buildAttribute(
                        translationArray[0][0],
                        translationArray[0][1],
                        translationArray[0][2],
                        false
                    );
                    var secondAttribute = this.buildAttribute(
                        translationArray[1][0],
                        translationArray[1][1],
                        translationArray[1][2],
                        false
                    );
					// add built attributes to translations
                    this._translations.push(new Translation(firstAttribute,secondAttribute));
                }

				return this;
			}

			/**
			 * Registers the specified component.
			 *
			 * @param {Widget|Aggregator|Interpreter} component the component that should be registered
			 */
			Discoverer.prototype.registerNewComponent = function(component) {
				if (component instanceof Aggregator && this.getAggregator(component.getId()) == null) this._aggregators.push(component);
				if (component instanceof Widget && !(component instanceof Aggregator) && this.getWidget(component.getId()) == null) this._widgets.push(component);
				if (component instanceof Interpreter && this.getInterpreter(component.getId()) == null) this._interpreters.push(component);
			};

			/**
			 * Deletes a component from the Discoverer.
			 *
			 * @param {string} componentId id of the component that should be registered
			 */
			Discoverer.prototype.unregisterComponent = function(componentId) {
				for (var wi in this._widgets) {
					var theWidget = this._widgets[wi];
					if (componentId == theWidget.getId()) this._widgets.splice(wi, 1);
				}
				for (var ii in this._interpreters) {
					var theInterpreter = this._interpreters[ii];
					if (componentId == theInterpreter.getId()) this._interpreters.splice(ii, 1);
				}
				for (var ai in this._aggregators) {
					var theAggregator= this._aggregators[ai];
					if (componentId == theAggregator.getId()) this._aggregators.splice(ai, 1);
				}
			};

			/**
			 * Returns the widget for the specified id.
			 *
			 * @param {string} widgetId id of the component that should be returned
			 * @returns {?Widget}
			 */
			Discoverer.prototype.getWidget = function(widgetId) {
				for (var index in this._widgets) {
					var theWidget = this._widgets[index];
					if (theWidget.getId() == widgetId) return theWidget;
				}
				return null;
			};

			/**
			 * Returns the aggregator for the specified id.
			 *
			 * @param {string} aggregatorId id of the component that should be returned
			 * @returns {?Aggregator}
			 */
			Discoverer.prototype.getAggregator = function(aggregatorId) {
				for (var index in this._aggregators) {
					var theAggregator = this._aggregators[index];
					if (theAggregator.getId() == aggregatorId) return theAggregator;
				}
				return null;
			};

			/**
			 * Returns the interpreter for the specified id.
			 *
			 * @param {string} interpreterId id of the component that should be returned
			 * @returns {Interpreter}
			 */
			Discoverer.prototype.getInterpreter = function(interpreterId) {
				for (var index in this._interpreters) {
					var theInterpreter = this._interpreters[index];
					if (theInterpreter.getId() == interpreterId) return theInterpreter;
				}
				return null;
			};

			/**
			 * Returns all registered components (widget, aggregator and interpreter).
			 *
			 * @param {Array} componentTypes Component types to get descriptions for. Defaults to Widget, Interpreter and Aggregator.
			 * @returns {Array}
			 */
			Discoverer.prototype.getComponents = function(componentTypes) {
				if (typeof componentTypes == "undefined") componentTypes = [Widget, Interpreter, Aggregator];
				var response = [];
				if (jQuery.inArray(Widget, componentTypes) != -1) response = response.concat(this._widgets);
				if (jQuery.inArray(Aggregator, componentTypes) != -1) response = response.concat(this._aggregators);
				if (jQuery.inArray(Interpreter, componentTypes) != -1) response = response.concat(this._interpreters);
				return response;
			};

			/**
			 * Returns the instance (widget, aggregator or interpreter) for the specified id.
			 *
			 * @param {string} componentId id of the component that should be returned
			 * @returns {?(Widget|Aggregator|Interpreter)}
			 */
			Discoverer.prototype.getComponent = function(componentId) {
				var theWidget = this.getWidget(componentId);
				if (theWidget) {
					return theWidget;
				}
				var theAggregator = this.getAggregator(componentId);
				if (theAggregator) {
					return theAggregator;
				}
				var theInterpreter = this.getInterpreter(componentId);
				if (theInterpreter) {
					return theInterpreter;
				}
				return null;
			};

			/**
			 * Returns all components that have the specified attribute as
			 * outAttribute. It can be chosen between the verification of
			 * all attributes or at least one attribute.
			 *
			 * @param {AttributeList|Array} attributeListOrArray list of searched attributes
			 * @param {Boolean} all choise of the verification mode
			 * @param {Array} componentTypes Components types to search for
			 * @returns {Array}
			 */
			Discoverer.prototype.getComponentsByAttributes = function(attributeListOrArray, all, componentTypes) {
				var componentList = [];
				var list = [];
				if (typeof componentTypes == "undefined") componentTypes = [Widget, Interpreter, Aggregator];
				if (attributeListOrArray instanceof Array) {
					list = attributeListOrArray;
				} else if (attributeListOrArray.constructor === AttributeList) {
					list = attributeListOrArray.getItems();
				}
				if (typeof list != "undefined") {
					var components = this.getComponents(componentTypes);
					for (var i in components) {
						var theComponent = components[i];
						if(all && this._containsAllAttributes(theComponent, list)) {
							componentList.push(theComponent);
						} else if(!all && this._containsAtLeastOneAttribute(theComponent, list)) {
							componentList.push(theComponent);
						}
					}
				}
				return componentList;
			};

			/**
			 * Returns an array of all translations known to the discoverer.
			 *
			 * @returns {Array}
			 */
			Discoverer.prototype.getTranslations = function() {
				return this._translations;
			};

			/**
			 * Builds a new attribute from given name, type and parameters,
			 * adding known translations to its synonyms.
			 *
			 * @param name
			 * @param type
			 * @param {Array} [parameterList=[]]
             * @param {Boolean} [withSynonyms=true]
			 * @returns {Attribute}
			 */
			Discoverer.prototype.buildAttribute = function(name, type, parameterList, withSynonyms) {
				if (typeof withSynonyms == 'undefined') withSynonyms = true;
				if (typeof parameterList == 'undefined') parameterList = [];

                if (typeof name != 'string' || typeof type != 'string')
                    throw new Error("Parameters name and type must be of type String!");

                var newAttribute = new Attribute(true).withName(name).withType(type);

				for (var i = 0; i < parameterList.length; i++) {
					var param = parameterList[i];
					var value = param[1];
					var key = param[0];
					if (typeof key != 'undefined' && typeof value != 'undefined') newAttribute = newAttribute.withParameter(new Parameter().withKey(key).withValue(value));
				}

                if (withSynonyms) {
                    for (var index in this._translations) {
                        var translation = this._translations[index];
						newAttribute = translation.translate(newAttribute);
                    }
                }

				return newAttribute;
			};


			/***********************************************************************
			 * Helper *
			 **********************************************************************/
			/**
			 * Helper: Verifies whether a component description contains all searched attributes.
			 *
			 * @private
			 * @param {Widget|Interpreter|Aggregator} component description of a component
			 * @param {Array} list searched attributes
			 * @returns {boolean}
			 */
			Discoverer.prototype._containsAllAttributes = function(component, list) {
				for (var j in list) {
					var attribute = list[j];
					if (!component.doesSatisfyTypeOf(attribute)) {
						return false;
					}
				}
				return true;
			};

			/**
			 * Helper: Verifies whether a component description contains at least on searched attributes.
			 *
			 * @private
			 * @param {Widget|Interpreter|Aggregator} component description of a component
			 * @param {Array} list searched attributes
			 * @returns {boolean}
			 */
			Discoverer.prototype._containsAtLeastOneAttribute = function(component, list) {
				for (var j in list) {
					var attribute = list[j];
					if (component.doesSatisfyTypeOf(attribute)) {
						return true;
					}
				}
				return false;
			};

			/**
			 * Searches for components that can satisfy the requested attributes. Searches recursively through all
			 * registered and unregistered components and initiates them.
			 *
			 * @param {String} aggregatorId The aggregator's ID
			 * @param {AttributeList} unsatisfiedAttributes A list of attributes that components should be searched for.
			 * @param {Boolean} all If true all attributes must be satisfied by a single component.
			 * @param {Array} componentTypes An array of components classes that should be searched for (e.g. Widget, Interpreter and Aggregator).
			 * @private
			 */
			Discoverer.prototype.getComponentsForUnsatisfiedAttributes = function(aggregatorId, unsatisfiedAttributes, all, componentTypes){
				// the discoverer gets a list of attributes to satisfy
				console.log('Discoverer: I will look for components that satisfy the following Attributes: '+unsatisfiedAttributes.getItems()+'.' );
				// look at all the already registered components
				this._getRegisteredComponentsForUnsatisfiedAttributes(aggregatorId, unsatisfiedAttributes, all, componentTypes);
				// look at all unregistered components
				this._getUnregisteredComponentsForUnsatisfiedAttributes(aggregatorId, unsatisfiedAttributes);
			};

			/**
			 * Searches for registered components that satisfy the requested attributes.
			 *
			 * @param {String} aggregatorId The aggregator's ID
			 * @param {AttributeList} unsatisfiedAttributes A list of attributes that components should be searched for.
			 * @param {Boolean} all If true all attributes must be satisfied by a single component.
			 * @param {Array} componentTypes An array of components classes that should be searched for (e.g. Widget, Interpreter and Aggregator).
			 * @private
			 */
			Discoverer.prototype._getRegisteredComponentsForUnsatisfiedAttributes = function(aggregatorId, unsatisfiedAttributes, all, componentTypes) {
				var theAggregator = this.getAggregator(aggregatorId);
				console.log("Discoverer: Let's look at my registered components.");

				var relevantComponents = this.getComponentsByAttributes(unsatisfiedAttributes, all, componentTypes);
				console.log("Discoverer: I found " + relevantComponents.length + " registered component(s) that might satisfy the requested attributes.");

				//iterate over the found components
				for(var index in relevantComponents) {
					var theComponent = relevantComponents[index];
					console.log("Discoverer: Let's look at component "+theComponent.getName()+".");

					// if the component was added before, ignore it
					if (!theAggregator._hasComponent(theComponent.getId())) {
						// if component is a widget and it wasn't added before, subscribe to its callbacks
						if (theComponent instanceof Widget) {
							theAggregator.addWidgetSubscription(theComponent);
							console.log("Discoverer: I found "+theComponent.name+" and the Aggregator did subscribe to it.");
							this._removeAttributesSatisfiedByWidget(aggregatorId, theComponent, unsatisfiedAttributes);
						} else if (theComponent instanceof Interpreter) { // if the component is an interpreter and all its in attributes can be satisfied, add the interpreter
							console.log("Discoverer: It's an Interpreter.");

							if (this._checkInterpreterInAttributes(aggregatorId, theComponent)) {
								// remove satisfied attributes
								this._removeAttributesSatisfiedByInterpreter(aggregatorId, theComponent, unsatisfiedAttributes);
							} else {
								console.log("Discoverer: I found a registered Interpreter but I couldn't satisfy the required attributes.");
								for (var j in theComponent.getInAttributes().getItems()) {
									console.log("Discoverer: It is missing " + theComponent.getInAttributes().getItems()[j] + ".");
								}
							}
						} else {
							console.log("Discoverer: It seems that the component was added before.");
						}
					}
				}
			};

			/**
			 * Searches for unregistered components that satisfy the requested attributes.
			 *
			 * @param {String} aggregatorId The aggregator's ID
			 * @param {AttributeList} unsatisfiedAttributes A list of attributes that components should be searched for.
			 * @private
			 */
			Discoverer.prototype._getUnregisteredComponentsForUnsatisfiedAttributes = function(aggregatorId, unsatisfiedAttributes) {
				var theAggregator = this.getAggregator(aggregatorId);
				console.log("Discoverer: Let's look at the unregistered components.");

				//check all Widget's outAttributes
				var foundWidget = false;
				for(var widgetIndex in this._unregisteredWidgets){
					var theWidget = this._unregisteredWidgets[widgetIndex];
					for(var unsatisfiedAttributeIndex in unsatisfiedAttributes.getItems()){
						var theUnsatisfiedAttribute = unsatisfiedAttributes.getItems()[unsatisfiedAttributeIndex];
						//if a Widget can satisfy the Attribute, register it and subscribe the Aggregator

						//create temporary OutAttributeList
						var tempWidgetOutList = AttributeList.fromAttributeDescription(this, theWidget.inOut.out);

						for(var tempWidgetOutListIndex in tempWidgetOutList.getItems()) {
							if (theUnsatisfiedAttribute.equalsTypeOf(tempWidgetOutList.getItems[tempWidgetOutListIndex])) {
								console.log("Discoverer: I have found an unregistered "+theWidget.name+".");
								var newWidget = new theWidget(this, tempWidgetOutList);
								theAggregator.addWidgetSubscription(newWidget);
								console.log("Discoverer: I registered "+theWidget.name+" and the Aggregator subscribed to it.");
								// remove satisfied attributes
								this._removeAttributesSatisfiedByWidget(aggregatorId, newWidget, unsatisfiedAttributes);
								foundWidget = true;
							}
						}
					}
				}

				if (!foundWidget) {
					//check all interpreters' outAttributes
					for (var index in this._unregisteredInterpreters) {
						var theInterpreter = this._unregisteredInterpreters[index];
						for (var unsatisfiedAttributeIndex in unsatisfiedAttributes.getItems()) {
							var theUnsatisfiedAttribute = unsatisfiedAttributes.getItems()[unsatisfiedAttributeIndex];
							//create temporary outAttributeList
							var tempOutList = AttributeList.fromAttributeDescription(this, theInterpreter.inOut.out);
							//create temporary inAttributeList
							var tempInList = AttributeList.fromAttributeDescription(this, theInterpreter.inOut.in);

							for (var tempOutAttributeIndex in tempOutList.getItems()) {
								if (theUnsatisfiedAttribute.equalsTypeOf(tempOutList.getItems()[tempOutAttributeIndex])) {
									console.log("Discoverer: I have found an unregistered "+theInterpreter.name+" that might satisfy the requested Attribute.");

									//if an interpreter can satisfy the Attribute, check if the inAttributes are satisfied
									if (this._checkInterpreterInAttributes(aggregatorId, theInterpreter)) {
										var newInterpreter = new theInterpreter(this, tempInList, tempOutList);
										//theAggregator.addWidgetSubscription(newInterpreter);
										console.log("Discoverer: I registered the Interpreter \"" + theInterpreter.name + "\" .");
										// remove satisfied attributes
										this._removeAttributesSatisfiedByInterpreter(aggregatorId, newInterpreter, unsatisfiedAttributes);
									} else {
										console.log("Discoverer: I found an unregistered Interpreter but I couldn't satisfy the required Attributes.");
									}
								}
							}
						}
					}
				}
			};

			/**
			 *
			 * @param aggregatorId
			 * @param theInterpreter
			 * @returns {boolean}
			 * @private
			 */
			Discoverer.prototype._checkInterpreterInAttributes = function(aggregatorId, theInterpreter) {
				var theAggregator = this.getComponent(aggregatorId);
				var canSatisfyInAttributes = true;
				var attributes;
				if (theInterpreter instanceof Interpreter) {
					attributes = theInterpreter.getInAttributes().getItems();
				} else {
					attributes = AttributeList.fromAttributeDescription(this, theInterpreter.inOut.in).getItems();
				}

				for (var attributeIdentifier in attributes) {
					// get the attribute
					var theAttribute = attributes[attributeIdentifier];
					console.log("Discoverer: The Interpreter needs the Attribute: "+theAttribute.toString(true)+".");
					// if required attribute is not already satisfied by the aggregator search for components that do
					if (!theAggregator.doesSatisfyTypeOf(theAttribute)) {
						console.log("Discoverer: The Aggregator doesn't satisfy "+theAttribute.toString(true)+", but I will search for components that do.");
						var newAttributeList = new AttributeList();
						newAttributeList.put(theAttribute);
						this.getComponentsForUnsatisfiedAttributes(aggregatorId, newAttributeList, false, [Widget, Interpreter]);
						// if the attribute still can't be satisfied drop the interpreter
						if (!theAggregator.doesSatisfyTypeOf(theAttribute)) {
							console.log("Discoverer: I couldn't find a component to satisfy "+theAttribute.toString(true)+". Dropping interpreter.");
							canSatisfyInAttributes = false;
							break;
						}
					} else {
						console.log("Discoverer: It seems that the Aggregator already satisfies the Attribute "+theAttribute.toString(true)+". Will move on.");
					}
				}

				return canSatisfyInAttributes;
			};

			/**
			 *
			 * @param aggregatorId
			 * @param theWidget
			 * @param unsatisfiedAttributes
			 * @private
			 */
			Discoverer.prototype._removeAttributesSatisfiedByWidget = function(aggregatorId, theWidget, unsatisfiedAttributes) {
				var theAggregator = this.getAggregator(aggregatorId);

				var attributes = theWidget.getOutAttributes().getItems();
				for (var attributeIndex in attributes) {
					var theAttribute = attributes[attributeIndex];
					// add the attribute type to the aggregator's list of handled attribute types
					if (!theAggregator.getOutAttributes().containsTypeOf(theAttribute)) theAggregator.addOutAttribute(theAttribute);
					console.log("Discoverer: The Aggregator can now satisfy attribute "+theAttribute.toString(true)+" with the help of "+theWidget.getName()+".");
					unsatisfiedAttributes.removeAttributeWithTypeOf(theAttribute);
				}
			};

			/**
			 *
			 * @param aggregatorId
			 * @param theInterpreter
			 * @param unsatisfiedAttributes
			 * @private
			 */
			Discoverer.prototype._removeAttributesSatisfiedByInterpreter = function(aggregatorId, theInterpreter, unsatisfiedAttributes) {
				var theAggregator = this.getAggregator(aggregatorId);

				var attributes = theInterpreter.getOutAttributes().getItems();
				for (var attributeIndex in attributes) {
					var theAttribute = attributes[attributeIndex];
					// add the attribute type to the aggregator's list of handled attribute types
					for (var unsatisfiedAttributeIndex in unsatisfiedAttributes.getItems()) {
						var theUnsatisfiedAttribute = unsatisfiedAttributes.getItems()[unsatisfiedAttributeIndex];
						if (theUnsatisfiedAttribute.equalsTypeOf(theAttribute)) {
							if (!theAggregator.getOutAttributes().containsTypeOf(theAttribute)) theAggregator.addOutAttribute(theAttribute);
							console.log("Aggregator: The Aggregator can now satisfy Attribute "+theAttribute.toString(true)+" with the help of "+theInterpreter.getName()+".");
							theAggregator._interpretations.push(new Interpretation(theInterpreter.getId(), theInterpreter.getInAttributes(), new AttributeList().withItems([theUnsatisfiedAttribute])));
						}
					}
					unsatisfiedAttributes.removeAttributeWithTypeOf(theAttribute, true);
				}
			};

			return Discoverer;
		})();
	}
);