ComponentImpl.java

/**
 * Copyright 2011-2012 Universite Joseph Fourier, LIG, ADELE team
 *   Licensed under the Apache License, Version 2.0 (the "License");
 *   you may not use this file except in compliance with the License.
 *   You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 *   Unless required by applicable law or agreed to in writing, software
 *   distributed under the License is distributed on an "AS IS" BASIS,
 *   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 *   See the License for the specific language governing permissions and
 *   limitations under the License.
 */
package fr.imag.adele.apam.impl;

import java.util.Collection;
import java.util.Collections;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Map;
import java.util.Set;
import java.util.concurrent.ConcurrentHashMap;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import fr.imag.adele.apam.ApamManagers;
import fr.imag.adele.apam.AttrType;
import fr.imag.adele.apam.CST;
import fr.imag.adele.apam.Component;
import fr.imag.adele.apam.Composite;
import fr.imag.adele.apam.CompositeType;
import fr.imag.adele.apam.DynamicManager;
import fr.imag.adele.apam.Implementation;
import fr.imag.adele.apam.Instance;
import fr.imag.adele.apam.Link;
import fr.imag.adele.apam.RelToResolve;
import fr.imag.adele.apam.RelationDefinition;
import fr.imag.adele.apam.Specification;
import fr.imag.adele.apam.apform.ApformComponent;
import fr.imag.adele.apam.declarations.ComponentDeclaration;
import fr.imag.adele.apam.declarations.InjectedPropertyPolicy;
import fr.imag.adele.apam.declarations.PropertyDefinition;
import fr.imag.adele.apam.declarations.RelationDeclaration;
import fr.imag.adele.apam.declarations.references.resources.ResourceReference;
import fr.imag.adele.apam.util.ApamFilter;
import fr.imag.adele.apam.util.Attribute;
import fr.imag.adele.apam.util.Substitute;
import fr.imag.adele.apam.util.Util;
import fr.imag.adele.apam.util.Visible;

public abstract class ComponentImpl extends ConcurrentHashMap<String, Object> implements Component, Comparable<Component> {

	/**
	 * An exception that can be thrown in the case of problems while creating a
	 * component
	 */
	public static class InvalidConfiguration extends Exception {

		private static final long serialVersionUID = 1L;

		public InvalidConfiguration(String message) {
			super(message);
		}

		public InvalidConfiguration(String message, Throwable cause) {
			super(message, cause);
		}

		public InvalidConfiguration(Throwable cause) {
			super(cause);
		}

	}

	private final Object componentId = new Object(); // only for hashCode

	private static final long serialVersionUID = 1L;

	protected static Logger logger = LoggerFactory.getLogger(ComponentImpl.class);
	
	private final ApformComponent apform;

	private final ComponentDeclaration declaration;
	
	/*
	 * set to true if an instantiation failed.
	 * True means : do not try to instantiate again
	 */
	private boolean instantiateFails = false ;

	// Contains the composite type that was the first to physically deploy that
	// component.
	private CompositeType firstDeployed;

	// Set of Dependencies
	private Map<String, RelationDefinition> relDef = new HashMap<String, RelationDefinition>();
	
	protected final Set<Link> links 	= Collections.newSetFromMap(new ConcurrentHashMap<Link, Boolean>());

	protected final Set<Link> invlinks 	= Collections.newSetFromMap(new ConcurrentHashMap<Link, Boolean>());

	public ComponentImpl(ApformComponent apform) throws InvalidConfiguration {
		if (apform == null) {
			throw new InvalidConfiguration("Null apform instance while creating component");
		}

		this.apform = apform;
		this.declaration = apform.getDeclaration();
	}

	/**
	 * Whether the component is instantiable
	 */
	@Override
	public boolean canSee(Component target) {
		return Visible.isVisible(this, target);
	}

	/**
	 * TODO Assumes that all components are in the same name space, including
	 * instance !!
	 */
	@Override
	public int compareTo(Component that) {
		return this.getName().compareTo(that.getName());
	}

	@Override
	public boolean createLink(Component to, RelToResolve dep, boolean hasConstraints, boolean promotion) {
		// Not a relation : a find
		if (!dep.isRelation()) {
			return true;
		}

		if (CST.isFinalRelation(dep.getName())) {
			logger.error("CreateLink: cannot create predefined relation "
					+ dep.getName());
			return false;
		}

		if ((to == null) || (dep == null)) {
			logger.error("CreateLink: Source or target are null ");
			return false;
		}
		
		if (!promotion && !canSee(to)) {
			logger.error("CreateLink: Source  " + this + " does not see its target " + to);
			return false;
		}
		
		if (this.getKind() != dep.getSourceKind()) {
			logger.error("CreateLink: Source kind " + getKind()
					+ " is not compatible with relation sourceType "
					+ dep.getSourceKind());
			return false;
		}
		
		if (to.getKind() != dep.getTargetKind()) {
			logger.error("CreateLink: Target kind " + to.getKind()
					+ " is not compatible with relation targetType "
					+ dep.getTargetKind());
			return false;
		}
		
		if (hasConstraints && !dep.matchRelationConstraints(to)) {
			logger.error("CreateLink: Target does not satisfies the constraints" );
			return false ;
		}

		String depName = dep.getName();

		for (Link link : links) { // check if it already exists
			if ((link.getDestination() == to) && link.getName().equals(depName)) {
				// It exists, do nothing.
				return true;
			}
		}

		// creation
		if (!getApformComponent().checkLink(to, depName)) {
			logger.error("CreateLink: INTERNAL ERROR: link from " + this
					+ " to " + to
					+ " could not be created in the real instance.");
			return false;
		}

		Link link = new LinkImpl(this, to, dep, hasConstraints, promotion);
		links.add(link);
		((ComponentImpl) to).invlinks.add(link);
		getApformComponent().setLink(to, depName);

		// Notify Dynamic managers that a new link has been created
		for (DynamicManager manager : ApamManagers.getDynamicManagers()) {
			manager.addedLink(link);
		}

		return true;
	}

	/**
	 * Components are uniquely represented in the Apam state model, so we use
	 * reference equality in all comparisons.
	 */
	@Override
	public final boolean equals(Object o) {
		return (this == o);
	}

	/**
	 * To be called when the object is fully loaded and chained. Terminate the
	 * generic initialization : computing the dependencies, and the properties
	 * 
	 * @param initialProperties
	 */
	public void finishInitialize(Map<String, String> initialProperties) {
		initializeRelations();
		initializeProperties(initialProperties);
	}

	/**
	 * Get the value of all the properties in the component.
	 * 
	 */
	@Override
	public Map<String, Object> getAllProperties() {
		return Collections.unmodifiableMap(this);
	}

	@Override
	public Map<String, String> getAllPropertiesString() {
		Map<String, String> ret = new HashMap<String, String>();
		for (Entry<String, Object> e : this.entrySet()) {
			if (!Attribute.isFinalAttribute(e.getKey())) {
				ret.put(e.getKey(), Util.toStringAttrValue(e.getValue()));
			}
		}
		return ret;
	}

	@Override
	public final ApformComponent getApformComponent() {
		return apform;
	}
	
	/**
	 * Tries to find the definition of a property, the property can be valued in this component
	 * or in its defining group
	 * 
	 * @param attribute
	 * @return
	 */	
	@Override
	public PropertyDefinition getPropertyDefinition(String attribute) {
		return getAttrDefinition(attribute);
	}
	

	/**
	 * Tries to find the definition of attribute "attr" associated with
	 * component "component". Returns null if the attribute is not explicitly
	 * defined
	 * 
	 * @param component
	 * @param attr
	 * @return
	 */
	public PropertyDefinition getAttrDefinition(String attr) {

		// PropertyDefinition definition =
		// getDeclaration().getPropertyDefinition(attr);
		// if (definition != null) {
		// return definition;
		// }

		PropertyDefinition definition = null;
		Component group = this; // .getGroup();
		while (group != null) {
			definition = group.getDeclaration().getPropertyDefinition(attr);
			if (definition != null) {
				return definition;
			}
			group = group.getGroup();
		}
		return null;
	}

	@Override
	public AttrType getAttrType(String attr) {
		PropertyDefinition attrDef = getAttrDefinition(attr);
		if (attrDef == null) {
			if (Attribute.isFinalAttribute(attr)) {
				return Attribute.splitType("string");
			}
			return null;
		}
		return Attribute.splitType(attrDef.getType());
	}

	@Override
	public final ComponentDeclaration getDeclaration() {
		return declaration;
	}

	/**
	 * Return the first link having this name, on any ancestor, but do not try
	 * to resolve is none are found
	 * 
	 * @param relName
	 * @return
	 */
	public Link getExistingLink(String relName) {
		Component group = this;
		while (group != null) {
			for (Link link : ((ComponentImpl) group).getLocalLinks()) {
				if (link.getName().equals(relName)) {
					return link;
				}
			}
			group = group.getGroup();
		}
		return null;
	}

	/**
	 * Return all the link of that names, but do not resolve if nore are found
	 * 
	 * @param relName
	 * @return
	 */
	public Set<Link> getExistingLinks(String relName) {
		Set<Link> dests = new HashSet<Link>();
		Component group = this;
		while (group != null) {
			for (Link link : ((ComponentImpl) group).getLocalLinks()) {
				if (link.getName().equals(relName)) {
					dests.add(link);
				}
			}
			group = group.getGroup();
		}
		return dests;
	}

	private Set<Component> getFInalLinkDests(String depName) {

		Set<Component> dests = new HashSet<Component>();
		// if (depName.equals(CST.REL_GROUP)) {
		// dests.add(getGroup()) ;
		// return dests ;
		// }
		// if (depName.equals(CST.REL_MEMBERS)) {
		// dests.addAll(getMembers()) ;
		// return dests ;
		// }
		if (depName.equals(CST.REL_COMPOSITE)) {
			if (this instanceof Instance) {
				dests.add(((Instance) this).getComposite());
			}
			return dests;
		}
		if (depName.equals(CST.REL_COMPOTYPE)) {
			if (this instanceof Instance) {
				dests.add(((Instance) this).getComposite().getCompType());
			} else if (this instanceof Implementation) {
				dests.addAll(((Implementation) this).getInCompositeType());
			}
			return dests;
		}
		if (depName.equals(CST.REL_CONTAINS)) {
			if (this instanceof Composite) {
				dests.addAll(((Composite) this).getContainInsts());
			} else if (this instanceof CompositeType) {
				dests.addAll(((CompositeType) this).getImpls());
			}
			return dests;
		}

		if (depName.equals(CST.REL_SPEC)) {
			if (this instanceof Specification) {
				dests.add(this);
			} else if (this instanceof Implementation) {
				dests.add(((Implementation) this).getSpec());
			} else if (this instanceof Instance) {
				dests.add(((Instance) this).getSpec());
			}
			return dests;
		}
		if (depName.equals(CST.REL_IMPL)) {
			if (this instanceof Implementation) {
				dests.add(this);
			} else if (this instanceof Instance) {
				dests.add(((Instance) this).getImpl());
			}
			return dests;
		}
		if (depName.equals(CST.REL_INST)) {
			if (this instanceof Instance) {
				dests.add(this);
			}
			return dests;
		}

		if (depName.equals(CST.REL_IMPLS)) {
			if (this instanceof Specification) {
				dests.addAll(this.getMembers());
			} else if (this instanceof Implementation) {
				dests.addAll(((Implementation) this).getSpec().getMembers());
			} else {
				dests.addAll(((Instance) this).getSpec().getMembers());
			}
			return dests;
		}
		if (depName.equals(CST.REL_INSTS)) {
			if (this instanceof Implementation) {
				dests.addAll(this.getMembers());
			} else if (this instanceof Instance) {
				dests.addAll(((Instance) this).getImpl().getMembers());
			}
			return dests;
		}
		if (depName.equals(CST.REL_INST)) {
			if (this instanceof Instance) {
				dests.add(this);
			}
			return dests;
		}
		return dests;
	}

	@Override
	public CompositeType getFirstDeployed() {
		return firstDeployed == null ? CompositeTypeImpl.getRootCompositeType()
				: firstDeployed;
	}

	@Override
	public Link getInvLink(Component destInst) {
		if (destInst == null) {
			return null;
		}
		for (Link link : invlinks) {
			if (link.getDestination() == destInst) {
				return link;
			}
		}
		return null;
	}

	@Override
	public Link getInvLink(Component destInst, String depName) {
		if (destInst == null) {
			return null;
		}
		for (Link link : invlinks) {
			if ((link.getDestination() == destInst)
					&& (link.getName().equals(depName))) {
				return link;
			}
		}
		return null;
	}

	@Override
	public Set<Link> getInvLinks() {
		return Collections.unmodifiableSet(invlinks);
	}

	@Override
	public Set<Link> getInvLinks(Component destInst) {
		if (destInst == null) {
			return null;
		}
		Set<Link> w = new HashSet<Link>();
		for (Link link : invlinks) {
			if (link.getDestination() == destInst) {
				w.add(link);
			}
		}
		return w;
	}

	@Override
	public Set<Link> getInvLinks(String depName) {
		Set<Link> w = new HashSet<Link>();
		for (Link link : invlinks) {
			if ((link.getDestination() == this)
					&& (link.getName().equals(depName))) {
				w.add(link);
			}
		}
		return w;
	}

	@Override
	public Link getLink(String relName) {
		Component group = this;
		while (group != null) {
			for (Link link : ((ComponentImpl) group).getLocalLinks()) {
				if (link.getName().equals(relName)) {
					return link;
				}
			}
			group = group.getGroup();
		}

		// None are present. Try to resolve
		RelationDefinition rel = getRelation(relName);
		if (rel == null) {
			logger.error("relation " + relName + " undefined for " + this);
			return null;
		}
		Component source = rel.getRelSource(this);
		CST.apamResolver.resolveLink(source, rel);
		return getExistingLink(relName);
	}

	/**
	 * resolve
	 */
	@Override
	public Component getLinkDest(String depName) {
		Link link = getLink(depName);
		return (link == null) ? null : link.getDestination();
	}

	// =================================== Links =========
	/**
	 * returns the connections towards the service instances actually used.
	 * return only APAM links.
	 */
	@Override
	public Set<Component> getLinkDests(String depName) {
		if (depName == null || depName.isEmpty()) {
			return null;
		}

		if (CST.isFinalRelation(depName)) {
			return getFInalLinkDests(depName);
		}

		Set<Component> dests = new HashSet<Component>();
		for (Link link : getLinks(depName)) {
			if (link.getName().equals(depName)) {
				dests.add(link.getDestination());
			}
		}
		return dests;
	}

	/**
	 * Inherits and resolve
	 */
	@Override
	public Set<Link> getLinks(String relName) {
		Set<Link> dests = getExistingLinks(relName);
		if (!dests.isEmpty()) {
			return dests;
		}

		// None are present. Try to resolve
		RelationDefinition rel = getRelation(relName);
		if (rel == null) {
			logger.error("relation " + relName + " undefined for " + this);
			return null;
		}

		// if (!rel.isLazy())
		// return dests ;

		Component source = rel.getRelSource(this);
		CST.apamResolver.resolveLink(source, rel);
		return getExistingLinks(relName);
	}

	/**
	 * Only return the links instantiated on that source component (no
	 * inheritance, no resolution)
	 */
	public Set<Link> getLocalLinks() {
		return Collections.unmodifiableSet(links);
	}

	protected RelationDefinition getLocalRelation(String id) {
		return relDef.get(id);
	}

	@Override
	public Collection<RelationDefinition> getLocalRelations() {
		return Collections.unmodifiableCollection(relDef.values());
	}

	@Override
	public final String getName() {
		return declaration.getName();
	}

	/**
	 * Get the value of the property.
	 * 
	 * Attributes are supposed to be correct and inherited statically
	 * 
	 */
	@Override
	public String getProperty(String attr) {
		return Util.toStringAttrValue(getPropertyObject(attr));
	}

	/**
	 * Get the value of a property, the property can be valued in this component
	 * or in its defining group Return will be an object of type int, String,
	 * boolean for attributes declared int, String, boolean String for an
	 * enumeration.
	 * 
	 * For sets, the return will be an array of the corresponding types. i.e;
	 * int[], String[] and so on. Returns null if attribute is not defined or
	 * not set.
	 */
	@Override
	public Object getPropertyObject(String attribute) {
		Object value = get(attribute);
		if (value == null) {
			return null;
			// all attributes, including default values are already there
			// if(value==null && getDeclaration()!=null)
			// value=getDeclaration().getProperty(attribute);
		}

		return Substitute.substitute(attribute, value, this);
	}

	@Override
	public Set<ResourceReference> getProvidedResources() {
		Set<ResourceReference> provided = new HashSet<ResourceReference>();
		
		/*
		 * add all provided resources declared at all levels of abstraction
		 */
		Component ancestor = this;
		while (ancestor != null) {
			provided.addAll(ancestor.getDeclaration().getProvidedResources());
			ancestor = ancestor.getGroup();
		}
		
		return Collections.unmodifiableSet(provided);
	}

	// Set<ResourceReference> allResources = new HashSet<ResourceReference> () ;
	// Component current = this ;
	// while (current != null) {
	// if (current.getDeclaration().getProvidedResources() != null)
	// allResources.addAll (current.getDeclaration().getProvidedResources()) ;
	// current = current.getGroup() ;
	// }
	// return allResources ;
	// }

	/**
	 * WARNING : no resolution
	 */
	@Override
	public Set<Component> getRawLinkDests() {
		Set<Component> dests = new HashSet<Component>();

		for (Link link : getRawLinks()) {
			dests.add(link.getDestination());
		}
		return dests;
	}

	/**
	 * No resolution
	 * 
	 * @param depName
	 * @return
	 */
	public Set<Component> getRawLinkDests(String depName) {
		if (depName == null || depName.isEmpty()) {
			return null;
		}

		if (CST.isFinalRelation(depName)) {
			return getFInalLinkDests(depName);
		}

		Set<Component> dests = new HashSet<Component>();
		for (Link link : getRawLinks()) {
			if (link.getName().equals(depName)) {
				dests.add(link.getDestination());
			}
		}
		return dests;
	}

	/**
	 * Warning : do not resolve !
	 */
	@Override
	public Set<Link> getRawLinks() {
		Set<Link> allLinks = new HashSet<Link>();
		Component group = this;
		while (group != null) {
			allLinks.addAll(((ComponentImpl) group).getLocalLinks());
			group = group.getGroup();
		}
		return allLinks;
	}

	/**
	 * Return the relation with name "id" if it can be applied to this
	 * component.
	 * 
	 * A relation D can be applied on a component source if D.Id == id D.source
	 * must be the name of source or of an ancestor of source, and D.SourceKind
	 * == source.getKind.
	 * 
	 * Looks in the group, and then in the composite type, if source in an
	 * instance in all composite types if source is an implem.
	 * 
	 * @param source
	 * @param id
	 * @return
	 */
	@Override
	public RelationDefinition getRelation(String id) {
		RelationDefinition dep = null;
		Component group = this;
		while (group != null) {
			dep = ((ComponentImpl) group).getLocalRelation(id);
			if (dep != null) {
				return dep;
			}
			group = group.getGroup();
		}

		// Looking for composite definitions.
		if (this instanceof Instance) {
			CompositeType comptype = ((Instance) this).getComposite()
					.getCompType();
			dep = comptype.getCtxtRelation(this, id);
			if (dep != null) {
				return dep;
			}
		}
		if (this instanceof Implementation) {
			for (CompositeType comptype : ((Implementation) this)
					.getInCompositeType()) {
				dep = comptype.getCtxtRelation(this, id);
				if (dep != null) {
					return dep;
				}
			}
		}
		return null;
	}

	@Override
	public Set<RelationDefinition> getRelations() {
		Set<RelationDefinition> relDefs = new HashSet<RelationDefinition>();
		Set<String> processed = new HashSet<String>();

		Component group = this;
		while (group != null) {

			for (RelationDefinition relDef : group.getLocalRelations()) {
				if (!processed.contains(relDef.getName())) {
					relDefs.add(relDef);
					processed.add(relDef.getName());
				}
			}

			group = group.getGroup();
		}

		// Looking for composite definitions.
		if (this instanceof Instance) {
			CompositeType comptype = ((Instance) this).getComposite()
					.getCompType();

			for (RelationDefinition relDef : comptype.getCtxtRelations(this)) {
				if (!processed.contains(relDef.getName())) {
					relDefs.add(relDef);
					processed.add(relDef.getName());
				}
			}

		}
		if (this instanceof Implementation) {
			for (CompositeType comptype : ((Implementation) this)
					.getInCompositeType()) {
				for (RelationDefinition relDef : comptype
						.getCtxtRelations(this)) {
					if (!processed.contains(relDef.getName())) {
						relDefs.add(relDef);
						processed.add(relDef.getName());
					}
				}
			}
		}

		return relDefs;
	}

	@Override
	public Map<String, String> getValidAttributes() {
		Map<String, String> ret = new HashMap<String, String>();
		for (PropertyDefinition def : declaration.getPropertyDefinitions()) {
			ret.put(def.getName(), def.getType());
		}
		if (getGroup() != null) {
			ret.putAll(getGroup().getValidAttributes());
		}
		return ret;
	}

	/**
	 * Override to make hash code conform to the equality definition
	 */
	@Override
	public final int hashCode() {
		return componentId.hashCode();
	}

	/**
	 * Provided a component, compute its effective relations definition, adding group
	 * constraint and flags. It is supposed to be correct !! No failure expected
	 * 
	 * Does not add those dependencies defined "above".
	 * For relations refined locally, merge the local definition with the group definition.
	 * 
	 * For instances only, add the relation definition overridden by the composite. 
	 * 
	 * Remove those links that are not valid with the computed relation definition (for changeOwner)
	 * 
	 */
	private void initializeRelations() {

		/*
		 * First we need to compute the list of relations that must be locally
		 * defined in this component. We consider locally defined relation
		 * declarations and overridden inherited relations.
		 */
		Set<RelationDeclaration> overrides = null;
		if (this instanceof Instance) {
			overrides = ((Instance) this).getComposite().getCompType().getCompoDeclaration().getOverridenDependencies();
		} else overrides = Collections.emptySet() ;

		Set<RelationDeclaration> localRelations = new HashSet<RelationDeclaration>();
		Set<String> processed = new HashSet<String>();

		Component group = this;
		while (group != null) {

			for (RelationDeclaration relationDeclaration : group.getDeclaration().getRelations()) {

				/*
				 * Ignore relations already processed at a lower level
				 */
				if (processed.contains(relationDeclaration.getIdentifier())) {
					continue;
				}

				/*
				 * Check overridden relations
				 */
				boolean matchOverride = false;
				for (RelationDeclaration override : overrides) {
					//					for (RelationDeclaration override : overrides != null ? overrides
					//							: Collections.<RelationDeclaration> emptySet()) {
					if (matchOverride(relationDeclaration, override)) {
						relationDeclaration = relationDeclaration.overriddenBy(override);
						matchOverride = true;
					}
				}

				/*
				 * Process locally declared and inherited overridden relations
				 */
				if (group == this || matchOverride) {
					localRelations.add(relationDeclaration);
					processed.add(relationDeclaration.getIdentifier());
				}
			}
			group = group.getGroup();
		}

		/*
		 * Define all the local relations definition of this component
		 */
		for (RelationDeclaration relationDeclaration : localRelations) {
			/*
			 * Local declarations may be partial definitions, we need to compute
			 * the complete declaration by refining the ancestor definition.
			 */
			RelationDefinition base = this.getRelation(relationDeclaration.getIdentifier());
			relationDeclaration = (base == null) ? relationDeclaration
					: ((RelationDefinitionImpl) base).refinedBy(relationDeclaration);

			relDef.put(relationDeclaration.getIdentifier(),
					new RelationDefinitionImpl(relationDeclaration));
		}
		
		/*
		 * If the component has links, remove those that are invalid (for changeOwner)
		 * Also remove the link if it is a promotion, since we are no longer in the same composite
		 */
		for (Link localLink : getLocalLinks()) {
			if (localLink.isPromotion() || !localLink.isValid())
				localLink.remove();
		}

		for (Link incoming : getInvLinks()) {
			if (incoming.isPromotion() || !incoming.isValid())
				incoming.remove();
		}

	}

	/**
	 * Given a relation declared in this component, checks if the provided
	 * override relation matches the relation declaration.
	 * 
	 * To be applied on a component C, the override must be such that : id
	 * matches the override id source must be the name of C or of an ancestor of
	 * C. target must be the same type (resource of component, and its name must
	 * match).
	 * 
	 */
	public boolean matchOverride(RelationDeclaration relation,	RelationDeclaration override) {

		// Overrides are currently only valid for instance
		boolean match = (this instanceof Instance);
		if (!match) {
			return false;
		}


		// Check if override source matches this component or one of its
		// ancestors

		match 			= false;
		Component group = this;
		while (group != null && !match) {
			match = override.refines(group.getDeclaration().getReference(), relation);
			group = group.getGroup();
		}

		return match;
	}
	
	/**
	 * To be called once the Apam entity is fully initialized.
	 * 
	 * Computes all its attributes, including inheritance. Checks if initial properties are consistent with the
	 * declarations.
	 * 
	 * NOTE this method is also called when the owner changes, to force recalculation of substitutions that depend
	 * on the current owner.
	 */
	private void initializeProperties(Map<String, String> initialProperties) {


		Component group = getGroup();

		/*
		 * Currently the instance declaration may include invalid properties. 
		 * 
		 * For declared instances this should not happen as the declaration is validated at build-time. For dynamically
		 * created instances (using the APAM API or the apform API directly) this should be validated by this method.
		 * 
		 * However, there are many properties added by the iPOJO apform layer that need to be ignored, so we simply 
		 * silently ignore all invalid properties.
		 * 
		 * TODO We should be able to distinguish properties specified by the user that must be validated, from properties
		 * used internally by the iPOJO apform.
		 */
		Set<String> invalidDeclaredProperties = new HashSet<String>();
		for (String property : getDeclaration().getProperties().keySet()) {

			boolean isDefined =	getDeclaration().isDefined(property) ||
								(group != null && group.getPropertyDefinition(property) != null);
			
			if (!isDefined) {
				invalidDeclaredProperties.add(property);
			}
			
			if (group != null && group.getProperty(property) != null) {
				invalidDeclaredProperties.add(property);
			}
		}
			
		getDeclaration().getProperties().keySet().removeAll(invalidDeclaredProperties);
		
		/*
		 * Merge initial and declared properties.
		 *  
		 */
		Map<String, String> fullInitialProperties = new HashMap<String, String>(getDeclaration().getProperties());
		if (initialProperties != null) {
			fullInitialProperties.putAll(initialProperties);
			fullInitialProperties.remove("instance.name");
		}

		/*
		 * NOTE  In the case of change owner, the initial properties include inherited values from the group,
		 * we ignore them to avoid false error messages, they will be added later by the normal inheritance
		 * mechanism
		 * 
		 * TODO Distinguish the case of change owner from a real initialization 
		 */
		if (initialProperties != null && group !=null) {
			for (Map.Entry<String, String> initialProperty : initialProperties.entrySet()) {
				if (group.getProperty(initialProperty.getKey()) != null && group.getProperty(initialProperty.getKey()).equals(initialProperty.getValue())) {
					fullInitialProperties.remove(initialProperty.getKey());
				}
			}
		}

		// start cleaning the properties (normally empty)
		clear ();

		/*
		 *  First add the valid attributes.
		 */
		for (Map.Entry<String, String> initialProperty : fullInitialProperties.entrySet()) {
			
			PropertyDefinition def = validDef(initialProperty.getKey(), true);
			if (def != null) {
				Object val = Attribute.checkAttrType(initialProperty.getKey(), initialProperty.getValue(), def.getType());
				if (val != null) {
					put(initialProperty.getKey(), val);
				}
			}
		}

		/*
		 *  then add those coming from its group, avoiding overloads.
		 */
		if (group != null) {
			for (String attr : group.getAllProperties().keySet()) {
				if (get(attr) == null) {
					put(attr, ((ComponentImpl)group).get(attr));
				}
			}
		}

		/*
		 * Add the default values specified in the group for properties not explicitly specified
		 */
		if (group != null) {
			for (PropertyDefinition definition : group.getDeclaration().getPropertyDefinitions()) {
				if (definition.hasDefaultValue() && get(definition.getName()) == null && definition.getInjected() != InjectedPropertyPolicy.INTERNAL) {
					Object val = Attribute.checkAttrType(definition.getName(),definition.getDefaultValue(), definition.getType());
					if (val != null) {
						put(definition.getName(), val);
					}
				}
			}
		}

		/*
		 * Set the attribute for the final attributes
		 */
		put(CST.SHARED, Boolean.toString(isShared()));
		put(CST.SINGLETON, Boolean.toString(isSingleton()));
		put(CST.INSTANTIABLE, Boolean.toString(isInstantiable()));

		/*
		 * Finally add the specific attributes. 
		 * Should be the only place where instanceof is used.
		 */
		put(CST.NAME, apform.getDeclaration().getName());
		if (this instanceof Specification) {
			put(CST.SPECNAME, apform.getDeclaration().getName());
		} else if (this instanceof Implementation) {
			put(CST.IMPLNAME, apform.getDeclaration().getName());
			if (this instanceof CompositeType) {
				put(CST.APAM_COMPOSITETYPE, CST.V_TRUE);
			}
		} else if (this instanceof Instance) {
			put(CST.INSTNAME, apform.getDeclaration().getName());
			if (this instanceof Composite) {

				Composite composite = (Composite) this;
				put(CST.APAM_COMPOSITE, CST.V_TRUE);
				if (composite.getMainInst() != null) {
					put(CST.APAM_MAIN_INSTANCE, composite.getMainInst()
							.getName());
				}
			}
		}

		/*
		 *  and propagate, to the platform and to members, in case the spec has been created after the implem
		 */
		for (Map.Entry<String, Object> entry : this.entrySet()) {
			for (Component member : getMembers()) {
				((ComponentImpl) member).propagate(entry.getKey(), entry.getValue());
			}
		}
	}

	/**
	 * Whether this component is an ancestor of the specified component
	 */
	@Override
	public boolean isAncestorOf(Component member) {

		assert member != null;

		Component ancestor = member.getGroup();
		while (ancestor != null && !ancestor.equals(this)) {
			ancestor = ancestor.getGroup();
		}

		return ancestor != null;
	}

	/**
	 * Whether this component is a descendant of the specified component
	 */
	@Override
	public boolean isDescendantOf(Component group) {
		assert group != null;
		return group.isAncestorOf(this);
	}

	public boolean isInternalInstantiable () {
		if (declaration.isDefinedInstantiable() || getGroup() == null) {
			return (declaration.isInstantiable())  ;
		}
		return ((ComponentImpl)getGroup()).isInternalInstantiable();
	}
	
	/**
	 * Whether the component can be instantiated
	 */
	@Override
	public boolean isInstantiable() {
		if (instantiateFails) return false ;
		if (!isInternalInstantiable()) return false ;
		
		if (this instanceof Implementation) {
			if (isSingleton() && !getMembers().isEmpty() ) return false;			
		}
		return true ;
	}

	/**
	 * Set the flag InstantiateFails which when true means : do not try to instantiate.
	 * Should be used only by the resolver when createinstance fails
	 * @param doNotTry
	 */
	public void setInstantiateFails (boolean doNotTryToInstantiate) {
		instantiateFails = doNotTryToInstantiate ;
	}
	
	/**
	 * Whether the component is shared
	 */
	@Override
	public boolean isShared() {
		if (declaration.isDefinedShared() || getGroup() == null) {
			return declaration.isShared();
		}
		return getGroup().isShared();
	}

	/**
	 * Whether the component is singleton
	 */
	@Override
	public boolean isSingleton() {
		if (declaration.isDefinedSingleton() || getGroup() == null) {
			return declaration.isSingleton();
		}
		return getGroup().isSingleton();
	}

	public boolean isSubstitute(String attr) {
		PropertyDefinition def = getDeclaration().getPropertyDefinition(attr);
		return (def != null && def.hasDefaultValue() && (def.getDefaultValue().charAt(0) == '$' || def.getDefaultValue().charAt(0) == '@'));
	}

	/**
	 * The link keeps the relToResolve used for its resolution.
	 * We make the hypothesis that the definition did not change, 
	 * and the source and destination did not change of composite.
	 * 
	 * @param link
	 * @return
	 */
//	public boolean isValidLink(Link link) {
//		return link.isValid() ;
//		RelToResolve relToResolve = link.getRelToResolve();
//		if (relToResolve == null) return false ;
//		
//
//		return relToResolve.matchRelationConstraints(link.getDestination());
//	}

	@Override
	public boolean match(ApamFilter goal) {
		if (goal == null) {
			return true;
		}
		return goal.match(this);
	}

	@Override
	public boolean match(String goal) {
		if (goal == null) {
			return true;
		}
		ApamFilter f = ApamFilter.newInstance(goal);
		if (f == null) {
			return false;
		}
		return goal == null || f.match(this.getAllProperties());
	}

	@Override
	public boolean matchRelation(RelToResolve dep) {
		return dep.matchRelation(this);
	}

	@Override
	public boolean matchRelationConstraints(RelToResolve dep) {
		return dep.matchRelationConstraints(dep.getTargetKind(),
				this.getAllProperties());
	}

	@Override
	public boolean matchRelationTarget(RelToResolve dep) {
		return dep.matchRelationTarget(this);
	}

	/**
	 * set the value, update apform and the platform, notify managers and
	 * propagates to the members, recursively
	 * 
	 * @param com
	 *            the component on which ot set the attribute
	 * @param attr
	 *            attribute name
	 * @param value
	 *            attribute value
	 */

	private void propagate(String attr, Object value) {
		if (value == null) {
			return;
		}
		Object oldValue = get(attr);
		if (oldValue != null && oldValue.equals(value.toString())) {
			return;
		}

		// Change value
		put(attr, value);

		// Notify the execution platform
		if (get(attr) == value) {
			getApformComponent().setProperty(attr, value.toString());
		}

		/*
		 * notify property managers
		 */
		if (oldValue == null) {
			ApamManagers.notifyAttributeAdded(this, attr, value.toString());
		} else {
			ApamManagers.notifyAttributeChanged(this, attr, value.toString(),
					oldValue.toString());
		}

		// Propagate to members recursively
		for (Component member : getMembers()) {
			((ComponentImpl) member).propagate(attr, value);
		}
	}

	/*
	 * Filter evaluation on the properties of this component
	 */

	/**
	 * TODO. Should we notify at all levels ?
	 * 
	 * @param ent
	 * @param attr
	 */
	private void propagateRemove(String attr) {

		remove(attr);
		for (Component member : getMembers()) {
			((ComponentImpl) member).propagateRemove(attr);
		}
	}

	/**
	 * This methods adds a newly created component to the Apam state model, so
	 * that it is visible to the external API
	 */
	public abstract void register(Map<String, String> initialProperties)
			throws InvalidConfiguration;

	public void removeInvLink(Link link) {
		invlinks.remove(link);
		// if (invLinks.isEmpty()) {
		/*
		 * This instance is no longer used. We do not set it unused
		 * setUsed(false); setOwner(CompositeImpl.getRootAllComposites());
		 * 
		 * Because it must stay in the same composite since it may be the target
		 * of an "OWN" clause, and must not be changed. In case it will be
		 * re-used (local).
		 */
		// }
	}

	// @Override
	public void removeLink(Link link) {
		if (getApformComponent().remLink(link.getDestination(), link.getName())) {
			links.remove(link);
			// TODO distriman: check if we have the destination implementation,
			// is this the right way to do it?

			// if(link.getDestination().getImpl()!=null)
			// ((ImplementationImpl)
			// getImpl()).removeUses(link.getDestination().getImpl());

		} else {
			logger.error("INTERNAL ERROR: link from " + this + " to "
					+ link.getDestination()
					+ " could not be removed in the real instance.");
		}
	}

	/**
	 * Removes the specifed property
	 * 
	 */
	@Override
	public boolean removeProperty(String attr) {
		return removeProperty(attr, false);
	}

	/**
	 * Warning: to be used only by Apform for removing internal attributes. Only
	 * Inhibits the message "Attribute " + attr +
	 * " is an program field attribute and cannot be removed.");
	 */
	public boolean removeProperty(String attr, boolean forced) {

		String oldValue = getProperty(attr);

		if (oldValue == null) {
			logger.error("ERROR: \"" + attr + "\" not instanciated");
			return false;
		}

		if (Attribute.isFinalAttribute(attr)) {
			logger.error("ERROR: \"" + attr + "\" is a final attribute");
			return false;
		}

		if (Attribute.isReservedAttributePrefix(attr)) {
			logger.error("ERROR: \"" + attr + "\" is a reserved attribute");
			return false;
		}

		PropertyDefinition propDef = getAttrDefinition(attr);
		if (propDef != null && propDef.getField() != null && !forced) {
			logger.error("In " + this + " attribute " + attr
					+ " is a program field and cannot be removed.");
			return false;
		}

		if (getGroup() != null && getGroup().getProperty(attr) != null) {
			logger.error("In " + this + " attribute " + attr
					+ " inherited and cannot be removed.");
			return false;
		}

		// it is ok, remove it and propagate to members, recursively
		propagateRemove(attr);

		// TODO. Should we notify at all levels ?
		ApamManagers.notifyAttributeRemoved(this, attr, oldValue);

		return true;
	}

	/**
	 * Sets all the values of the specified properties
	 * 
	 * We validate all attributes before actually modifying the value to avoid
	 * partial modifications ?
	 */
	@Override
	public boolean setAllProperties(Map<String, String> properties) {
		for (Map.Entry<String, String> entry : properties.entrySet()) {

			if (!setProperty(entry.getKey(), entry.getValue())) {
				return false;
			}
		}
		return true;
	}

	public void setFirstDeployed(CompositeType father) {
		firstDeployed = father;
	}

	/**
	 * Set the value of the property in the Apam state model. Changing an
	 * attribute notifies the property manager, the underlying execution
	 * platform (apform), and propagates to members
	 */
	@Override
	public boolean setProperty(String attr, Object value) {
		return setProperty(attr, value, false);
	}

	/**
	 * Warning: to be used only by Apform for setting internal attributes. Only
	 * Inhibits the message "Attribute " + attr +
	 * " is an internal field attribute and cannot be set.");
	 * 
	 * @param attr
	 * @param value
	 * @param forced
	 * @return
	 */
	public boolean setProperty(String attr, Object value, boolean forced) {
		/*
		 * Validate that the property is defined and the value is valid Forced
		 * means that we can set field attribute
		 */
		PropertyDefinition def = validDef(attr, forced);
		if (def == null) {
			return false;
		}
		// At initialization, all valid attributes are ok for specs
		Object val = Attribute.checkAttrType(attr, value, def.getType());
		if (val == null) {
			return false;
		}

		/*
		 * Force recalculation of dependencies that may have been invalidated by
		 * the property change. This must be done before notification and
		 * propagation, otherwise we risk to remove links updated by managers.
		 * 
		 * We remove only those links that are now invalid problematic for those
		 * that are not lazy links : assychronous messages, .. and avoiding
		 * unnecessary work TODO Check if this must be done for all links or
		 * only dynamic links
		 */
		Object oldValue = get(attr);
		put(attr, val);

		for (Link incoming : getInvLinks()) {
			// If still valid, do nothing
			if (incoming.hasConstraints() && !incoming.isValid()) {
				incoming.remove();
			}
		}

		// If outgoing constraints have substitution, the link may be now invalid
		for (Link outgoing : getLocalLinks()) {
//			if (!!!((RelationDefinitionImpl) outgoing.getRelDefinition()).isStaticImplemConstraints()
//					&& !outgoing.isValid()) {
			outgoing.getRelToResolve().reComputeSubstFilters();
			if (!outgoing.isValid()) {
				outgoing.remove();
			}
		}

		// WARNING : undo the change because propagate needs the initial state
		if (oldValue == null) {
			remove(attr);
		} else {
			put(attr, oldValue);
		}

		// does the change, notifies managers, changes the platform and
		// propagate to members
		this.propagate(attr, val);

		return true;
	}

	// ==============================================
	@Override
	public String toString() {
		return getKind() + " " + getName();
	}

	/**
	 * This method removes a component from the Apam state model, it must ensure
	 * that the component is no longer referenced by any other component or
	 * visible by the external API. Should be called ONLY from the Broker.
	 */
	abstract void unregister();

	/**
	 * An attribute is valid if declared in an ancestor, and not set in an
	 * ancestor. Check if the value is conforming to its type (string, int,
	 * boolean). Internal attribute (associated with a field) cannot be set.
	 * Must be called on the level above.
	 * 
	 * Checks if attr is correctly defined for component ent it must be
	 * explicitly defined in its upper groups, for the top group, it must be
	 * already existing.
	 * 
	 * boolean Forced = true can be set only by Apform. Needed when an internal
	 * attribute is set in the program, Apform propagates the value to the
	 * attribute.
	 * 
	 * @param attr
	 * @param value
	 * @return
	 */
	public PropertyDefinition validDef(String attr, boolean forced) {
		if (Attribute.isFinalAttribute(attr) ) {
			logger.error("In " + this + ", cannot redefine final attribute \""
					+ attr + "\"");
			return null;
		}

		if (Attribute.isReservedAttributePrefix(attr)) {
			logger.error("In " + this + ", attribute\"" + attr
					+ "\" is reserved");
			return null;
		}

		PropertyDefinition definition = this.getAttrDefinition(attr);
		if (definition == null ) {
			logger.error("In " + this + ", attribute \"" + attr
					+ "\" is undefined.");
			return null;
		}

		/*
		 * Internal field attributes cannot be set
		 */
		if (definition.getInjected() == InjectedPropertyPolicy.INTERNAL	&& !forced) {
			logger.error("In " + this + ", attribute \"" + attr
					+ "\" is an internal field attribute and cannot be set.");
			return null;
		}

		/*
		 * if the same attribute exists above, it is a redefinition.
		 */
		ComponentImpl group = (ComponentImpl) this.getGroup();
		if (group != null && group.get(attr) != null) {
			
			Object groupValue 	= group.get(attr);
			String defaultValue	= definition.getDefaultValue();
			
			boolean isDefault 	= 	defaultValue != null &&
									groupValue.equals(Attribute.checkAttrType(attr,defaultValue,definition.getType()));
			
			// If the attribute above is the default value, it is allowed to change it
			if (!isDefault && !Attribute.isBuiltAttribute(attr)) {
				logger.error("In " + this + ", cannot redefine attribute \"" + attr + "\"");
				return null;
			}
		}

		return definition;
	}

}