bundles/org.eclipse.jst.ws.consumption.ui/src/org/eclipse/jst/ws/internal/consumption/ui/wsrt/FacetMatchCache.java - webservices/webtools.webservices - Git at Google

 /*******************************************************************************
  * Copyright (c) 2006, 2010 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
  *
  * Contributors:
  * IBM Corporation - initial API and implementation
  * yyyymmdd bug      Email and other contact information
  * -------- -------- -----------------------------------------------------------
  * 20060131   121071 rsinha@ca.ibm.com - Rupam Kuehner (initial creation)
  * 20060426   138051 kathy@ca.ibm.com - Kathy Chan
  * 20060427   126780 rsinha@ca.ibm.com - Rupam Kuehner
  * 20080923   247525 mahutch@ca.ibm.com - Mark Hutchinson, cache not updated properly when project facet versions changed
  * 20100811   322429 mahutch@ca.ibm.com - Mark Hutchinson, Improve performance of launching the Web Services Wizard
  *******************************************************************************/
 package org.eclipse.jst.ws.internal.consumption.ui.wsrt;

 import java.util.ArrayList;
 import java.util.HashSet;
 import java.util.Hashtable;
 import java.util.Iterator;
 import java.util.List;
 import java.util.Set;

 import org.eclipse.core.resources.IProject;
 import org.eclipse.core.resources.IResource;
 import org.eclipse.core.resources.IResourceChangeEvent;
 import org.eclipse.core.resources.IResourceChangeListener;
 import org.eclipse.core.resources.ResourcesPlugin;
 import org.eclipse.jem.util.emf.workbench.ProjectUtilities;
 import org.eclipse.jst.ws.internal.consumption.common.FacetMatcher;
 import org.eclipse.jst.ws.internal.consumption.common.FacetSetsByTemplateCache;
 import org.eclipse.jst.ws.internal.consumption.common.FacetUtils;
 import org.eclipse.jst.ws.internal.consumption.common.RequiredFacetVersion;
 import org.eclipse.wst.common.project.facet.core.IFacetedProjectTemplate;
 import org.eclipse.wst.common.project.facet.core.ProjectFacetsManager;
 import org.eclipse.wst.common.project.facet.core.runtime.IRuntime;

 /**
  * FacetMatchCache caches results of calculations made respecting
  * the suitability of projects and project types for serviceRuntimes
  * and clientRuntimes.
  *
  * <br/><br/>
  * Terminology used in the javadoc in this class:
  * <ul>
  * <li><b>serviceRuntime</b>: extension to org.eclipse.jst.ws.consumption.ui.serviceRuntimes.
  * The Java representation of this is org.eclipse.jst.ws.internal.consumption.ui.wsrt.ServiceRuntimeDescriptor</li>
  * <li><b>clientRuntime</b>: extension to org.eclipse.jst.ws.consumption.ui.clientRuntimes.
  * The Java representation of this is org.eclipse.jst.ws.internal.consumption.ui.wsrt.ClientRuntimeDescriptor</li>
  * </ul>
  *
  */
 public class FacetMatchCache implements IResourceChangeListener
 {
   //single instance per workbench
   private static FacetMatchCache instance_;


   //Tables related to existing projects in the workspace

   //serviceFacetMatchTable_:
   //key: Object of type String.
   //     Forward slash separated concatenation of a serviceRuntimeId and a projectName
   //     (e.g. org.eclipse.jst.ws.axis.creation.java/wp).
   //value: Object of type org.eclipse.jst.ws.internal.consumption.common.FacetMatcher.
   //       The FacetMatcher contains the matching characteristics calculated for the
   //       serviceRuntime and project in the key.
   private Hashtable serviceFacetMatchTable_;

   //serviceTableKeysByProjectName_:
   //key: Object of type String.
   //     project name (e.g. wp)
   //value: Set of elements of type String. The Strings in the Set are keys from the serviceFacetMatchTable_
   //       that contain the project name (e.g. org.eclipse.jst.ws.axis.creation.java/wp). Used to rapidly
   //       delete entries from serviceFacetMatchTable_ after a project is deleted from the workspace.
   private Hashtable serviceTableKeysByProjectName_;

   //clientFacetMatchTable_;
   //key: Object of type String.
   //     forward slash separated concatenation of a clientRuntimeId and a projectName
   //     (e.g. org.eclipse.jst.ws.axis.consumption.java/wp)
   //value: Object of type org.eclipse.jst.ws.internal.consumption.common.FacetMatcher
   //       The FacetMatcher contains the matching characteristics calculated for the
   //       clientRuntime and project in the key.
   private Hashtable clientFacetMatchTable_;

   //clientTableKeysByProjectName_
   //key: Object of type String.
   //     project name (e.g. wp)
   //value: Set of elements of type String. The Strings in the Set are keys from the clientFacetMatchTable_
   //       that contain the project name (e.g. org.eclipse.jst.ws.axis.consumption.java/wp). Used to rapidly
   //       delete entries from clientFacetMatchTable_ after a project is deleted from the workspace.
   private Hashtable clientTableKeysByProjectName_;

   //projectEntriesToDelete_: elements of type String containing the names of projects that have
   //been deleted from the workspace but their corresponding entries from serviceFacetMatchTable_
   //and clientFacetMatchTable_ have yet to be deleted.
   private List projectEntriesToDelete_;


   //Tables related to templates

   //templatesByServiceRuntimeId_:
   //key: Object of type String.
   //     serviceRuntime id
   //value: Set of elements of type org.eclipse.wst.common.project.facet.core.IFacetedProjectTemplate
   //       This the set of templates that support the serviceRuntime identified by the key.
   private Hashtable templatesByServiceRuntimeId_;

   //templatesByClientRuntimeId_
   //key: Object of type String.
   //     clientRuntime id
   //value: Set of elements of type org.eclipse.wst.common.project.facet.core.IFacetedProjectTemplate
   //       This the set of templates that support the clientRuntime identified by the key.
   private Hashtable templatesByClientRuntimeId_;


   /**
    * Returns a singleton instance of this class.
    *
    * @return A singleton FacetMatchCache object.
    */
   public static synchronized FacetMatchCache getInstance()
   {
     if (instance_ == null)
     {
       instance_ = new FacetMatchCache();
       instance_.load();
     }
     return instance_;
   }

   private void load()
   {
     serviceFacetMatchTable_ = new Hashtable();
     serviceTableKeysByProjectName_ = new Hashtable();
     clientFacetMatchTable_ = new Hashtable();
     clientTableKeysByProjectName_ = new Hashtable();
     projectEntriesToDelete_ = new ArrayList();
     templatesByClientRuntimeId_ = new Hashtable();
     templatesByServiceRuntimeId_ = new Hashtable();

     //Listen for deletions of projects in order to delete all entries in
     //Hashtables for the deleted project.
     ResourcesPlugin.getWorkspace().addResourceChangeListener(this, IResourceChangeEvent.PRE_DELETE);
   }


   /*
    * Returns the FacetMatcher resulting from matching a serviceRuntime or clientRuntime with an existing project.
    * @param isClient true if runtimeId is a clientRuntimeId. false if runtimeId is a serviceRuntimeId.
    * @param runtimeId the id of a clientRuntime if isClient is true or the id of a serviceRuntime if
    * isClient is false.
    * @param projectName the name of an existing project.
    *
    * @returns FacetMatcher resulting from calling FacetUtils.match(..) using the serviceRuntime or clientRuntime id
    * and the project name. Returns null if the project doesn't exist. Non-faceted existing projects will always result
    * in a FacetMatcher with isMatch() equal to false (with the exception of Java projects which are a special case
    * - see FacetUtils.getFacetsForProject()).
    */
   public synchronized FacetMatcher getMatchForProject(boolean isClient, String runtimeId, String projectName)
   {
     //Delete entries from tables if there are deletions pending.
     if (projectEntriesToDelete_.size() > 0)
     {
       Iterator projectItr = projectEntriesToDelete_.iterator();
       while(projectItr.hasNext())
       {
         String projectNameToDelete = (String)projectItr.next();

         //Delete entries from client table
         removeTableEntriesForProject(true, projectNameToDelete);

         //Delete entries from service table
         removeTableEntriesForProject(false, projectNameToDelete);
       }

       //Clear the projectEntriesToDelete list
       projectEntriesToDelete_.clear();
     }

     IProject project = ProjectUtilities.getProject(projectName);
     FacetMatcher fm = null;
     if (project != null && project.exists())
     {
       String key = getKey(runtimeId, projectName);
       if (isClient)
       {
         fm = (FacetMatcher) clientFacetMatchTable_.get(key);
       }
       else
       {
         fm = (FacetMatcher) serviceFacetMatchTable_.get(key);
       }

       if (fm == null)
       {
         // This combination has not yet been calculated and cached so calculate it and cache it.
         fm = calculateFacetMatcher(isClient, runtimeId, projectName);
         if (isClient)
         {
           clientFacetMatchTable_.put(key,fm);
         }
         else
         {
           serviceFacetMatchTable_.put(key, fm);
         }
         updateTableOfKeys(isClient, key, projectName);

       } else
       {
         // If the project's facets have changed since the last time the
         // facets were calculated, refresh the facetMatcher.
         Set currentFacetVersions = FacetUtils.getFacetsForProject(projectName);
         Set previousFacetVersions = fm.getFacetsTested();
         if (!currentFacetVersions.equals(previousFacetVersions))
         {
           //recalculate and cache the FacetMatcher
           fm = calculateFacetMatcher(isClient, runtimeId, projectName);
           if (isClient)
           {
             clientFacetMatchTable_.put(key,fm);
           }
           else
           {
             serviceFacetMatchTable_.put(key, fm);
           }
         }
       }
     }

     return fm;
   }

   /**
    * Updates serviceTableKeysByProjectName_ or clientTableKeysByProjectName_ with
    * the provided project name and key. This is called whenever a new entry is
    * added to serviceFacetMatchTable_ or clientFacetMatchTable_.
    * @param isClient true if runtimeId is a clientRuntimeId. false if runtimeId is a serviceRuntimeId.
    * @param key
    * @param projectName
    */
   private void updateTableOfKeys(boolean isClient, String key, String projectName)
   {
     Set setOfKeysForProjectName = null;
     if (isClient)
     {
       setOfKeysForProjectName = (Set)clientTableKeysByProjectName_.get(projectName);
     }
     else
     {
       setOfKeysForProjectName = (Set)serviceTableKeysByProjectName_.get(projectName);
     }

     if (setOfKeysForProjectName == null)
     {
       //Add an entry in the table for this project.
       Set keys = new HashSet();
       keys.add(key);
       if (isClient)
       {
         clientTableKeysByProjectName_.put(projectName, keys);
       }
       else
       {
         serviceTableKeysByProjectName_.put(projectName, keys);
       }
     }
     else
     {
       //Update the entry in the table for this project.
       setOfKeysForProjectName.add(key);
     }
   }

   /**
    * Returns the {@link FacetMatcher} calculated for the given serviceRuntime or clientRuntime and project
    * @param isClient true if runtimeId is a clientRuntimeId. false if runtimeId is a serviceRuntimeId.
    * @param runtimeId the id of a clientRuntime if isClient is true or the id of a serviceRuntime if
    * isClient is false.
    * @param projectName the name of an existing project.
    * @return FacetMatcher resulting from calling FacetUtils.match(..) using the serviceRuntime or clientRuntime id
    * and the project name. Returns null if the project doesn't exist. Non-faceted existing projects will always result
    * in a FacetMatcher with isMatch() equal to false (with the exception of Java projects which are a special case
    * - see FacetUtils.getFacetsForProject()).
    */
   private FacetMatcher calculateFacetMatcher(boolean isClient, String runtimeId, String projectName)
   {
     FacetMatcher fm = null;
     RequiredFacetVersion[] rfvs = null;
     if (isClient)
     {
       ClientRuntimeDescriptor desc = WebServiceRuntimeExtensionUtils2.getClientRuntimeDescriptorById(runtimeId);
       rfvs = desc.getRequiredFacetVersions();
     }
     else
     {
       ServiceRuntimeDescriptor desc = WebServiceRuntimeExtensionUtils2.getServiceRuntimeDescriptorById(runtimeId);
       rfvs = desc.getRequiredFacetVersions();
     }

     Set facetVersions = new HashSet(FacetUtils.getFacetsForProject(projectName));
     if (facetVersions == null)
     {
       fm = new FacetMatcher();
       fm.setMatch(false);
       return fm;
     }

     fm = FacetUtils.match(rfvs, facetVersions);

     // Check if the facet runtime required by the required facet is supported
     // by the project without chaning it's current facet runtime

     IRuntime fProjectRuntime = FacetUtils.getFacetRuntimeForProject(projectName);
     if (fProjectRuntime != null) {
     	String fProjectRuntimeName = fProjectRuntime.getName();
     	boolean projectSupportRequiredFacetRuntime = false;
     	Set rts = FacetUtils.getRuntimes(rfvs);
     	for (Iterator iterator = rts.iterator(); iterator.hasNext() && !projectSupportRequiredFacetRuntime;) {
     		IRuntime fRequiredRuntime = (IRuntime) iterator.next();
     		if (fRequiredRuntime != null) {
     			if (fRequiredRuntime.getName().equals(fProjectRuntimeName)) {
     				projectSupportRequiredFacetRuntime = true;
     			}
     		}
     	}

     	// if project does not support the required facet runtime, set FacetMatch match to false
     	if (!projectSupportRequiredFacetRuntime) {
     		fm.setMatch(false);
     	}
     }
     return fm;
   }

   private String getKey(String a, String b)
   {
     StringBuffer keysb = new StringBuffer();
     keysb.append(a);
     keysb.append("/");
     keysb.append(b);
     return keysb.toString();
   }

   /**
    * Removes all table entries in this cache for the given project
    * @param isClient true to remove entries from client side tables. false to remove entries from service side tables
    * @param projectName
    */
   private void removeTableEntriesForProject(boolean isClient, String projectName)
   {
     //First remove the entries from clientFacetMatchTable_ or serviceFacetMatchTable_
     //that have keys containing this project name.
     Set setOfKeysForProjectName = null;
     if (isClient)
     {
       setOfKeysForProjectName = (Set)clientTableKeysByProjectName_.get(projectName);
     }
     else
     {
       setOfKeysForProjectName = (Set)serviceTableKeysByProjectName_.get(projectName);
     }

     if (setOfKeysForProjectName != null)
     {
       Iterator keysItr = setOfKeysForProjectName.iterator();
       while (keysItr.hasNext())
       {
         String key = (String)keysItr.next();
         if (isClient)
         {
           clientFacetMatchTable_.remove(key);
         }
         else
         {
           serviceFacetMatchTable_.remove(key);
         }
       }

       //Second, remove the entry in clientTableKeysByProjectName_ or serviceTableKeysByProjectName_
       //with this projectName as the key.
       if (isClient)
       {
         clientTableKeysByProjectName_.remove(projectName);
       }
       else
       {
         serviceTableKeysByProjectName_.remove(projectName);
       }

     }

   }

   /**
    * Returns a set of templates supported by the given clientRuntime
    * @param clientRuntimeId id of a clientRuntime
    * @returns Set (elementtype: IFacetedProjectTemplate)
    */
   public synchronized Set getTemplatesForClientRuntime(String clientRuntimeId)
   {
     Set templates = (Set)templatesByClientRuntimeId_.get(clientRuntimeId);
     if (templates != null)
     {
       //Return the cached set of templates.
       return templates;
     }
     else
     {
       //Calculate the templates, cache them for later use, and return them.
       ClientRuntimeDescriptor desc = WebServiceRuntimeExtensionUtils2.getClientRuntimeDescriptorById(clientRuntimeId);

       Set validTemplates = null;
       Set<String> suitableIds = desc.getSuitableProjectTemplates();
       if (!suitableIds.isEmpty()) {
     	  //If a list of suitable project templates is specified in the metadata, then use those project templates and do not search
     	  validTemplates = new HashSet(1);
     	  for (String s : suitableIds) {
     		  IFacetedProjectTemplate t = ProjectFacetsManager.getTemplate(s);
     		  if (t != null)
     			  validTemplates.add(t);
     	  }
       }

       //if the set of valid templates is still empty, then search for valid templates based on required facet versions
       if (validTemplates == null || validTemplates.isEmpty()) {
     	  validTemplates = getTemplates(desc.getRequiredFacetVersions(), desc.getUnsuitableProjectTemplates());
       }

       templatesByClientRuntimeId_.put(clientRuntimeId, validTemplates);
       return validTemplates;
     }
   }

   /**
    * Returns a set of templates supported by the given serviceRuntime
    * @param serviceRuntimeId id of a serviceRuntime
    * @returns Set (elementtype: IFacetedProjectTemplate)
    */
   public synchronized Set getTemplatesForServiceRuntime(String serviceRuntimeId)
   {
     Set templates = (Set)templatesByServiceRuntimeId_.get(serviceRuntimeId);
     if (templates != null)
     {
       //Return the cached set of templates.
       return templates;
     }
     else
     {
       //Calculate the templates, cache them for later use, and return them.
       ServiceRuntimeDescriptor desc = WebServiceRuntimeExtensionUtils2.getServiceRuntimeDescriptorById(serviceRuntimeId);
       Set validTemplates = null;
       Set<String> suitableIds = desc.getSuitableProjectTemplates();
       if (!suitableIds.isEmpty()) {
     	  //If a list of suitable project templates is specified in the metadata, then use those project templates and do not search
     	  validTemplates = new HashSet(1);
     	  for (String s : suitableIds) {
     		  IFacetedProjectTemplate t = ProjectFacetsManager.getTemplate(s);
     		  if (t != null)
     			  validTemplates.add(t);
     	  }
       }

       //if the set of valid templates is still empty, then search for valid templates based on required facet versions
       if (validTemplates == null || validTemplates.isEmpty()) {
     	  validTemplates = getTemplates(desc.getRequiredFacetVersions(), desc.getUnsuitableProjectTemplates());
       }

       templatesByServiceRuntimeId_.put(serviceRuntimeId, validTemplates);
       return validTemplates;
     }
   }

    /**
    * Returns the set of templates that supported the given required facet versions.
    * @param requiredFacetVersions
    * @param unSuitableTemplates set of unsuitable template ids to exclude from the search for increased performance
    * @return Set containing elemets of type {@link IFacetedProjectTemplate}.
    */
   private Set getTemplates(RequiredFacetVersion[] requiredFacetVersions, Set<String> unSuitableTemplates)  {
     Set templates = new HashSet();
     for( Iterator itr = ProjectFacetsManager.getTemplates().iterator(); itr.hasNext(); ) {
         final IFacetedProjectTemplate template = (IFacetedProjectTemplate) itr.next();
         String templateId = template.getId();
         if (unSuitableTemplates == null || !unSuitableTemplates.contains(templateId)) { //if we know the template is unsuitable, then exclude it
 	        if (templateId.indexOf("ear") == -1 && templateId.indexOf("wst.web") == -1) { //Don't include the EARs!!
 	          Set[] combinations = FacetSetsByTemplateCache.getInstance().getFacetVersionCombinationsFromTemplate(templateId);

 	          for (int i=0; i<combinations.length; i++) {
 	            FacetMatcher fm = FacetUtils.match(requiredFacetVersions, combinations[i]);
 	            if (fm.isMatch()) {
 	              //Found a combination that worked. Add the template to the list and move on.
 	              templates.add(template);
 	              break;
 	            }
 	          }
 	        }
         }
     }
     return templates;
   }

   public synchronized void resourceChanged(IResourceChangeEvent event)
   {
     if (event.getType() == IResourceChangeEvent.PRE_DELETE)
     {
       IResource projectResource = event.getResource();
       if (projectResource!=null)
       {
         String projectName = projectResource.getName();

         //Add this project name to the list of project entries
         //to delete. Next time getMatchForProject is called all
         //entries for this project from all tables in this cache
         //will be deleted.
         projectEntriesToDelete_.add(projectName);
       }
     }
   }
 }
	/*******************************************************************************
	* Copyright (c) 2006, 2010 IBM Corporation and others.
	* All rights reserved. This program and the accompanying materials
	* are made available under the terms of the Eclipse Public License v1.0
	* which accompanies this distribution, and is available at
	* http://www.eclipse.org/legal/epl-v10.html
	*
	* Contributors:
	* IBM Corporation - initial API and implementation
	* yyyymmdd bug Email and other contact information
	* -------- -------- -----------------------------------------------------------
	* 20060131 121071 rsinha@ca.ibm.com - Rupam Kuehner (initial creation)
	* 20060426 138051 kathy@ca.ibm.com - Kathy Chan
	* 20060427 126780 rsinha@ca.ibm.com - Rupam Kuehner
	* 20080923 247525 mahutch@ca.ibm.com - Mark Hutchinson, cache not updated properly when project facet versions changed
	* 20100811 322429 mahutch@ca.ibm.com - Mark Hutchinson, Improve performance of launching the Web Services Wizard
	*******************************************************************************/
	package org.eclipse.jst.ws.internal.consumption.ui.wsrt;

	import java.util.ArrayList;
	import java.util.HashSet;
	import java.util.Hashtable;
	import java.util.Iterator;
	import java.util.List;
	import java.util.Set;

	import org.eclipse.core.resources.IProject;
	import org.eclipse.core.resources.IResource;
	import org.eclipse.core.resources.IResourceChangeEvent;
	import org.eclipse.core.resources.IResourceChangeListener;
	import org.eclipse.core.resources.ResourcesPlugin;
	import org.eclipse.jem.util.emf.workbench.ProjectUtilities;
	import org.eclipse.jst.ws.internal.consumption.common.FacetMatcher;
	import org.eclipse.jst.ws.internal.consumption.common.FacetSetsByTemplateCache;
	import org.eclipse.jst.ws.internal.consumption.common.FacetUtils;
	import org.eclipse.jst.ws.internal.consumption.common.RequiredFacetVersion;
	import org.eclipse.wst.common.project.facet.core.IFacetedProjectTemplate;
	import org.eclipse.wst.common.project.facet.core.ProjectFacetsManager;
	import org.eclipse.wst.common.project.facet.core.runtime.IRuntime;

	/**
	* FacetMatchCache caches results of calculations made respecting
	* the suitability of projects and project types for serviceRuntimes
	* and clientRuntimes.
	*
	* <br/><br/>
	* Terminology used in the javadoc in this class:
	* <ul>
	* <li><b>serviceRuntime</b>: extension to org.eclipse.jst.ws.consumption.ui.serviceRuntimes.
	* The Java representation of this is org.eclipse.jst.ws.internal.consumption.ui.wsrt.ServiceRuntimeDescriptor</li>
	* <li><b>clientRuntime</b>: extension to org.eclipse.jst.ws.consumption.ui.clientRuntimes.
	* The Java representation of this is org.eclipse.jst.ws.internal.consumption.ui.wsrt.ClientRuntimeDescriptor</li>
	* </ul>
	*
	*/
	public class FacetMatchCache implements IResourceChangeListener
	{
	//single instance per workbench
	private static FacetMatchCache instance_;


	//Tables related to existing projects in the workspace

	//serviceFacetMatchTable_:
	//key: Object of type String.
	// Forward slash separated concatenation of a serviceRuntimeId and a projectName
	// (e.g. org.eclipse.jst.ws.axis.creation.java/wp).
	//value: Object of type org.eclipse.jst.ws.internal.consumption.common.FacetMatcher.
	// The FacetMatcher contains the matching characteristics calculated for the
	// serviceRuntime and project in the key.
	private Hashtable serviceFacetMatchTable_;

	//serviceTableKeysByProjectName_:
	//key: Object of type String.
	// project name (e.g. wp)
	//value: Set of elements of type String. The Strings in the Set are keys from the serviceFacetMatchTable_
	// that contain the project name (e.g. org.eclipse.jst.ws.axis.creation.java/wp). Used to rapidly
	// delete entries from serviceFacetMatchTable_ after a project is deleted from the workspace.
	private Hashtable serviceTableKeysByProjectName_;

	//clientFacetMatchTable_;
	//key: Object of type String.
	// forward slash separated concatenation of a clientRuntimeId and a projectName
	// (e.g. org.eclipse.jst.ws.axis.consumption.java/wp)
	//value: Object of type org.eclipse.jst.ws.internal.consumption.common.FacetMatcher
	// The FacetMatcher contains the matching characteristics calculated for the
	// clientRuntime and project in the key.
	private Hashtable clientFacetMatchTable_;

	//clientTableKeysByProjectName_
	//key: Object of type String.
	// project name (e.g. wp)
	//value: Set of elements of type String. The Strings in the Set are keys from the clientFacetMatchTable_
	// that contain the project name (e.g. org.eclipse.jst.ws.axis.consumption.java/wp). Used to rapidly
	// delete entries from clientFacetMatchTable_ after a project is deleted from the workspace.
	private Hashtable clientTableKeysByProjectName_;

	//projectEntriesToDelete_: elements of type String containing the names of projects that have
	//been deleted from the workspace but their corresponding entries from serviceFacetMatchTable_
	//and clientFacetMatchTable_ have yet to be deleted.
	private List projectEntriesToDelete_;



	//Tables related to templates

	//templatesByServiceRuntimeId_:
	//key: Object of type String.
	// serviceRuntime id
	//value: Set of elements of type org.eclipse.wst.common.project.facet.core.IFacetedProjectTemplate
	// This the set of templates that support the serviceRuntime identified by the key.
	private Hashtable templatesByServiceRuntimeId_;

	//templatesByClientRuntimeId_
	//key: Object of type String.
	// clientRuntime id
	//value: Set of elements of type org.eclipse.wst.common.project.facet.core.IFacetedProjectTemplate
	// This the set of templates that support the clientRuntime identified by the key.
	private Hashtable templatesByClientRuntimeId_;


	/**
	* Returns a singleton instance of this class.
	*
	* @return A singleton FacetMatchCache object.
	*/
	public static synchronized FacetMatchCache getInstance()
	{
	if (instance_ == null)
	{
	instance_ = new FacetMatchCache();
	instance_.load();
	}
	return instance_;
	}

	private void load()
	{
	serviceFacetMatchTable_ = new Hashtable();
	serviceTableKeysByProjectName_ = new Hashtable();
	clientFacetMatchTable_ = new Hashtable();
	clientTableKeysByProjectName_ = new Hashtable();
	projectEntriesToDelete_ = new ArrayList();
	templatesByClientRuntimeId_ = new Hashtable();
	templatesByServiceRuntimeId_ = new Hashtable();

	//Listen for deletions of projects in order to delete all entries in
	//Hashtables for the deleted project.
	ResourcesPlugin.getWorkspace().addResourceChangeListener(this, IResourceChangeEvent.PRE_DELETE);
	}


	/*
	* Returns the FacetMatcher resulting from matching a serviceRuntime or clientRuntime with an existing project.
	* @param isClient true if runtimeId is a clientRuntimeId. false if runtimeId is a serviceRuntimeId.
	* @param runtimeId the id of a clientRuntime if isClient is true or the id of a serviceRuntime if
	* isClient is false.
	* @param projectName the name of an existing project.
	*
	* @returns FacetMatcher resulting from calling FacetUtils.match(..) using the serviceRuntime or clientRuntime id
	* and the project name. Returns null if the project doesn't exist. Non-faceted existing projects will always result
	* in a FacetMatcher with isMatch() equal to false (with the exception of Java projects which are a special case
	* - see FacetUtils.getFacetsForProject()).
	*/
	public synchronized FacetMatcher getMatchForProject(boolean isClient, String runtimeId, String projectName)
	{
	//Delete entries from tables if there are deletions pending.
	if (projectEntriesToDelete_.size() > 0)
	{
	Iterator projectItr = projectEntriesToDelete_.iterator();
	while(projectItr.hasNext())
	{
	String projectNameToDelete = (String)projectItr.next();

	//Delete entries from client table
	removeTableEntriesForProject(true, projectNameToDelete);

	//Delete entries from service table
	removeTableEntriesForProject(false, projectNameToDelete);
	}

	//Clear the projectEntriesToDelete list
	projectEntriesToDelete_.clear();
	}

	IProject project = ProjectUtilities.getProject(projectName);
	FacetMatcher fm = null;
	if (project != null && project.exists())
	{
	String key = getKey(runtimeId, projectName);
	if (isClient)
	{
	fm = (FacetMatcher) clientFacetMatchTable_.get(key);
	}
	else
	{
	fm = (FacetMatcher) serviceFacetMatchTable_.get(key);
	}

	if (fm == null)
	{
	// This combination has not yet been calculated and cached so calculate it and cache it.
	fm = calculateFacetMatcher(isClient, runtimeId, projectName);
	if (isClient)
	{
	clientFacetMatchTable_.put(key,fm);
	}
	else
	{
	serviceFacetMatchTable_.put(key, fm);
	}
	updateTableOfKeys(isClient, key, projectName);

	} else
	{
	// If the project's facets have changed since the last time the
	// facets were calculated, refresh the facetMatcher.
	Set currentFacetVersions = FacetUtils.getFacetsForProject(projectName);
	Set previousFacetVersions = fm.getFacetsTested();
	if (!currentFacetVersions.equals(previousFacetVersions))
	{
	//recalculate and cache the FacetMatcher
	fm = calculateFacetMatcher(isClient, runtimeId, projectName);
	if (isClient)
	{
	clientFacetMatchTable_.put(key,fm);
	}
	else
	{
	serviceFacetMatchTable_.put(key, fm);
	}
	}
	}
	}

	return fm;
	}

	/**
	* Updates serviceTableKeysByProjectName_ or clientTableKeysByProjectName_ with
	* the provided project name and key. This is called whenever a new entry is
	* added to serviceFacetMatchTable_ or clientFacetMatchTable_.
	* @param isClient true if runtimeId is a clientRuntimeId. false if runtimeId is a serviceRuntimeId.
	* @param key
	* @param projectName
	*/
	private void updateTableOfKeys(boolean isClient, String key, String projectName)
	{
	Set setOfKeysForProjectName = null;
	if (isClient)
	{
	setOfKeysForProjectName = (Set)clientTableKeysByProjectName_.get(projectName);
	}
	else
	{
	setOfKeysForProjectName = (Set)serviceTableKeysByProjectName_.get(projectName);
	}

	if (setOfKeysForProjectName == null)
	{
	//Add an entry in the table for this project.
	Set keys = new HashSet();
	keys.add(key);
	if (isClient)
	{
	clientTableKeysByProjectName_.put(projectName, keys);
	}
	else
	{
	serviceTableKeysByProjectName_.put(projectName, keys);
	}
	}
	else
	{
	//Update the entry in the table for this project.
	setOfKeysForProjectName.add(key);
	}
	}

	/**
	* Returns the {@link FacetMatcher} calculated for the given serviceRuntime or clientRuntime and project
	* @param isClient true if runtimeId is a clientRuntimeId. false if runtimeId is a serviceRuntimeId.
	* @param runtimeId the id of a clientRuntime if isClient is true or the id of a serviceRuntime if
	* isClient is false.
	* @param projectName the name of an existing project.
	* @return FacetMatcher resulting from calling FacetUtils.match(..) using the serviceRuntime or clientRuntime id
	* and the project name. Returns null if the project doesn't exist. Non-faceted existing projects will always result
	* in a FacetMatcher with isMatch() equal to false (with the exception of Java projects which are a special case
	* - see FacetUtils.getFacetsForProject()).
	*/
	private FacetMatcher calculateFacetMatcher(boolean isClient, String runtimeId, String projectName)
	{
	FacetMatcher fm = null;
	RequiredFacetVersion[] rfvs = null;
	if (isClient)
	{
	ClientRuntimeDescriptor desc = WebServiceRuntimeExtensionUtils2.getClientRuntimeDescriptorById(runtimeId);
	rfvs = desc.getRequiredFacetVersions();
	}
	else
	{
	ServiceRuntimeDescriptor desc = WebServiceRuntimeExtensionUtils2.getServiceRuntimeDescriptorById(runtimeId);
	rfvs = desc.getRequiredFacetVersions();
	}

	Set facetVersions = new HashSet(FacetUtils.getFacetsForProject(projectName));
	if (facetVersions == null)
	{
	fm = new FacetMatcher();
	fm.setMatch(false);
	return fm;
	}

	fm = FacetUtils.match(rfvs, facetVersions);

	// Check if the facet runtime required by the required facet is supported
	// by the project without chaning it's current facet runtime

	IRuntime fProjectRuntime = FacetUtils.getFacetRuntimeForProject(projectName);
	if (fProjectRuntime != null) {
	String fProjectRuntimeName = fProjectRuntime.getName();
	boolean projectSupportRequiredFacetRuntime = false;
	Set rts = FacetUtils.getRuntimes(rfvs);
	for (Iterator iterator = rts.iterator(); iterator.hasNext() && !projectSupportRequiredFacetRuntime;) {
	IRuntime fRequiredRuntime = (IRuntime) iterator.next();
	if (fRequiredRuntime != null) {
	if (fRequiredRuntime.getName().equals(fProjectRuntimeName)) {
	projectSupportRequiredFacetRuntime = true;
	}
	}
	}

	// if project does not support the required facet runtime, set FacetMatch match to false
	if (!projectSupportRequiredFacetRuntime) {
	fm.setMatch(false);
	}
	}
	return fm;
	}

	private String getKey(String a, String b)
	{
	StringBuffer keysb = new StringBuffer();
	keysb.append(a);
	keysb.append("/");
	keysb.append(b);
	return keysb.toString();
	}

	/**
	* Removes all table entries in this cache for the given project
	* @param isClient true to remove entries from client side tables. false to remove entries from service side tables
	* @param projectName
	*/
	private void removeTableEntriesForProject(boolean isClient, String projectName)
	{
	//First remove the entries from clientFacetMatchTable_ or serviceFacetMatchTable_
	//that have keys containing this project name.
	Set setOfKeysForProjectName = null;
	if (isClient)
	{
	setOfKeysForProjectName = (Set)clientTableKeysByProjectName_.get(projectName);
	}
	else
	{
	setOfKeysForProjectName = (Set)serviceTableKeysByProjectName_.get(projectName);
	}

	if (setOfKeysForProjectName != null)
	{
	Iterator keysItr = setOfKeysForProjectName.iterator();
	while (keysItr.hasNext())
	{
	String key = (String)keysItr.next();
	if (isClient)
	{
	clientFacetMatchTable_.remove(key);
	}
	else
	{
	serviceFacetMatchTable_.remove(key);
	}
	}

	//Second, remove the entry in clientTableKeysByProjectName_ or serviceTableKeysByProjectName_
	//with this projectName as the key.
	if (isClient)
	{
	clientTableKeysByProjectName_.remove(projectName);
	}
	else
	{
	serviceTableKeysByProjectName_.remove(projectName);
	}

	}

	}

	/**
	* Returns a set of templates supported by the given clientRuntime
	* @param clientRuntimeId id of a clientRuntime
	* @returns Set (elementtype: IFacetedProjectTemplate)
	*/
	public synchronized Set getTemplatesForClientRuntime(String clientRuntimeId)
	{
	Set templates = (Set)templatesByClientRuntimeId_.get(clientRuntimeId);
	if (templates != null)
	{
	//Return the cached set of templates.
	return templates;
	}
	else
	{
	//Calculate the templates, cache them for later use, and return them.
	ClientRuntimeDescriptor desc = WebServiceRuntimeExtensionUtils2.getClientRuntimeDescriptorById(clientRuntimeId);

	Set validTemplates = null;
	Set<String> suitableIds = desc.getSuitableProjectTemplates();
	if (!suitableIds.isEmpty()) {
	//If a list of suitable project templates is specified in the metadata, then use those project templates and do not search
	validTemplates = new HashSet(1);
	for (String s : suitableIds) {
	IFacetedProjectTemplate t = ProjectFacetsManager.getTemplate(s);
	if (t != null)
	validTemplates.add(t);
	}
	}

	//if the set of valid templates is still empty, then search for valid templates based on required facet versions
	if (validTemplates == null \|\| validTemplates.isEmpty()) {
	validTemplates = getTemplates(desc.getRequiredFacetVersions(), desc.getUnsuitableProjectTemplates());
	}

	templatesByClientRuntimeId_.put(clientRuntimeId, validTemplates);
	return validTemplates;
	}
	}

	/**
	* Returns a set of templates supported by the given serviceRuntime
	* @param serviceRuntimeId id of a serviceRuntime
	* @returns Set (elementtype: IFacetedProjectTemplate)
	*/
	public synchronized Set getTemplatesForServiceRuntime(String serviceRuntimeId)
	{
	Set templates = (Set)templatesByServiceRuntimeId_.get(serviceRuntimeId);
	if (templates != null)
	{
	//Return the cached set of templates.
	return templates;
	}
	else
	{
	//Calculate the templates, cache them for later use, and return them.
	ServiceRuntimeDescriptor desc = WebServiceRuntimeExtensionUtils2.getServiceRuntimeDescriptorById(serviceRuntimeId);
	Set validTemplates = null;
	Set<String> suitableIds = desc.getSuitableProjectTemplates();
	if (!suitableIds.isEmpty()) {
	//If a list of suitable project templates is specified in the metadata, then use those project templates and do not search
	validTemplates = new HashSet(1);
	for (String s : suitableIds) {
	IFacetedProjectTemplate t = ProjectFacetsManager.getTemplate(s);
	if (t != null)
	validTemplates.add(t);
	}
	}

	//if the set of valid templates is still empty, then search for valid templates based on required facet versions
	if (validTemplates == null \|\| validTemplates.isEmpty()) {
	validTemplates = getTemplates(desc.getRequiredFacetVersions(), desc.getUnsuitableProjectTemplates());
	}

	templatesByServiceRuntimeId_.put(serviceRuntimeId, validTemplates);
	return validTemplates;
	}
	}

	/**
	* Returns the set of templates that supported the given required facet versions.
	* @param requiredFacetVersions
	* @param unSuitableTemplates set of unsuitable template ids to exclude from the search for increased performance
	* @return Set containing elemets of type {@link IFacetedProjectTemplate}.
	*/
	private Set getTemplates(RequiredFacetVersion[] requiredFacetVersions, Set<String> unSuitableTemplates) {
	Set templates = new HashSet();
	for( Iterator itr = ProjectFacetsManager.getTemplates().iterator(); itr.hasNext(); ) {
	final IFacetedProjectTemplate template = (IFacetedProjectTemplate) itr.next();
	String templateId = template.getId();
	if (unSuitableTemplates == null \|\| !unSuitableTemplates.contains(templateId)) { //if we know the template is unsuitable, then exclude it
	if (templateId.indexOf("ear") == -1 && templateId.indexOf("wst.web") == -1) { //Don't include the EARs!!
	Set[] combinations = FacetSetsByTemplateCache.getInstance().getFacetVersionCombinationsFromTemplate(templateId);

	for (int i=0; i<combinations.length; i++) {
	FacetMatcher fm = FacetUtils.match(requiredFacetVersions, combinations[i]);
	if (fm.isMatch()) {
	//Found a combination that worked. Add the template to the list and move on.
	templates.add(template);
	break;
	}
	}
	}
	}
	}
	return templates;
	}

	public synchronized void resourceChanged(IResourceChangeEvent event)
	{
	if (event.getType() == IResourceChangeEvent.PRE_DELETE)
	{
	IResource projectResource = event.getResource();
	if (projectResource!=null)
	{
	String projectName = projectResource.getName();

	//Add this project name to the list of project entries
	//to delete. Next time getMatchForProject is called all
	//entries for this project from all tables in this cache
	//will be deleted.
	projectEntriesToDelete_.add(projectName);
	}
	}
	}
	}