bundles/org.eclipse.wst.sse.ui/src/org/eclipse/wst/sse/ui/internal/openon/OpenOnBuilder.java - sourceediting/webtools.sourceediting - Git at Google

 /*******************************************************************************
  * Copyright (c) 2001, 2004 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
  *     Jens Lukowski/Innoopract - initial renaming/restructuring
  *
  *******************************************************************************/
 package org.eclipse.wst.sse.ui.internal.openon;

 import java.util.ArrayList;
 import java.util.List;

 import org.eclipse.core.runtime.IConfigurationElement;
 import org.eclipse.core.runtime.IExtensionRegistry;
 import org.eclipse.core.runtime.Platform;
 import org.eclipse.wst.sse.ui.internal.extension.RegistryReader;


 /**
  * Reads extensions for open on extension point,
  * org.eclipse.wst.sse.ui.extensions.openon
  *
  * @deprecated Use base support for hyperlink navigation
  */
 public class OpenOnBuilder extends RegistryReader {
 	public static final String ATT_CLASS = "class"; //$NON-NLS-1$

 	public static final String ATT_ID = "id"; //$NON-NLS-1$

 	private static OpenOnBuilder fInstance;
 	// extension point ID
 	public static final String PL_OPENON = "openon"; //$NON-NLS-1$

 	public static final String PLUGIN_ID = "org.eclipse.wst.sse.ui"; //$NON-NLS-1$
 	public static final String TAG_CONTENT_TYPE_IDENTIFIER = "contenttypeidentifier"; //$NON-NLS-1$

 	public static final String TAG_OPENON = "openon"; //$NON-NLS-1$
 	public static final String TAG_PARTITION_TYPE = "partitiontype"; //$NON-NLS-1$

 	/**
 	 * returns singleton instance of OpenOnBuilder
 	 *
 	 * @return OpenOnBuilder
 	 */
 	public synchronized static OpenOnBuilder getInstance() {
 		if (fInstance == null) {
 			fInstance = new OpenOnBuilder();
 		}
 		return fInstance;
 	}

 	private String fCurrentContentType;
 	private OpenOnDefinition fCurrentOpenOnDefinition = null;

 	private List fOpenOnDefs = null;

 	protected String targetContributionTag;

 	/**
 	 * Returns the name of the part ID attribute that is expected in the
 	 * target extension.
 	 *
 	 * @param element
 	 * @return String
 	 */
 	protected String getId(IConfigurationElement element) {
 		String value = element.getAttribute(ATT_ID);
 		return value;
 	}

 	protected String getOpenOnClass(IConfigurationElement element) {
 		String value = element.getAttribute(ATT_CLASS);
 		return value;
 	}

 	/**
 	 * Returns all the open on definition objects
 	 *
 	 * @return
 	 */
 	public OpenOnDefinition[] getOpenOnDefinitions() {
 		initCache();
 		return (OpenOnDefinition[]) fOpenOnDefs.toArray(new OpenOnDefinition[fOpenOnDefs.size()]);
 	}

 	/**
 	 * Returns all the open on definition objects valid for
 	 * contentType/partitionType
 	 *
 	 * @param contentType
 	 * @param partitionType
 	 * @return if either contentType or partitionType is null, null is
 	 *         returned
 	 */
 	public OpenOnDefinition[] getOpenOnDefinitions(String contentType, String partitionType) {
 		if (contentType == null || partitionType == null) {
 			// should not be able to define an openon without a content type
 			// but if it were possible then would need to search all openon
 			// definitions for
 			// definitions with empty contentType list
 			return null;
 		}

 		// entire list of openon definition objects
 		OpenOnDefinition[] allDefs = getOpenOnDefinitions();
 		// current list of open on definitions valid for
 		// contentType/partitionType
 		List defs = new ArrayList();
 		// default definitions that should be added to end of list of open on
 		// definitions
 		List lastDefs = new ArrayList();

 		for (int i = 0; i < allDefs.length; ++i) {
 			// for each one check if it contains contentType
 			List partitions = (List) allDefs[i].getContentTypes().get(contentType);
 			if (partitions != null) {
 				// this openon definition is valid for all partition types for
 				// this content type
 				if (partitions.isEmpty()) {
 					// this will be added to end of list because this is
 					// considered a default openon
 					lastDefs.add(allDefs[i]);
 				} else {
 					// examine the partition types of this openon
 					int j = 0; // current index in list of partitions
 					boolean added = false; // openon has been added to list
 					while (j < partitions.size() && !added) {
 						// this openon definition applies to partitionType so
 						// add to list of valid openons
 						if (partitionType.equals(partitions.get(j))) {
 							defs.add(allDefs[i]);
 							added = true;
 						} else {
 							// continue checking to see if this openon
 							// definition is valid for current partitionType
 							++j;
 						}
 					}
 				}
 			}
 		}
 		// append the default openon definitions
 		defs.addAll(lastDefs);

 		// return the list
 		return (OpenOnDefinition[]) defs.toArray(new OpenOnDefinition[defs.size()]);
 	}

 	private void initCache() {
 		if (fOpenOnDefs == null) {
 			fOpenOnDefs = new ArrayList(0);
 			readContributions(TAG_OPENON, PL_OPENON);
 		}
 	}

 	/**
 	 * Processes element which should be a configuration element specifying a
 	 * content type for the current open on tag. Assumes that there is a valid
 	 * current open on definition object.
 	 *
 	 * @param element
 	 *            contenttypeidentifier configuration element
 	 */
 	private void processContentTypeTag(IConfigurationElement element) {
 		// add to current openOnDefinition
 		String theId = getId(element);

 		if (theId != null) {
 			fCurrentContentType = theId;
 			fCurrentOpenOnDefinition.addContentTypeId(fCurrentContentType);
 		} else {
 			fCurrentContentType = null;
 		}
 	}

 	/**
 	 * Processes element which should be a configuration element specifying an
 	 * open on object. Creates a new open on definition object and adds it to
 	 * the list of open on definition objects
 	 *
 	 * @param element
 	 *            openon configuration element
 	 */
 	private void processOpenOnTag(IConfigurationElement element) {
 		String theId = getId(element);
 		String theClass = getOpenOnClass(element);

 		if (theId != null && theClass != null) {
 			// start building new OpenOnDefinition
 			fCurrentOpenOnDefinition = new OpenOnDefinition(theId, theClass, element);
 			fOpenOnDefs.add(fCurrentOpenOnDefinition);
 		} else {
 			fCurrentOpenOnDefinition = null;
 		}
 	}

 	/**
 	 * Processes element which should be a configuration element specifying a
 	 * partition type for the current open on/content type tag. Assumes that
 	 * there is a valid current open on/content type tag.
 	 *
 	 * @param element
 	 *            partitiontype configuration element
 	 */
 	private void processPartitionTypeTag(IConfigurationElement element) {
 		// add to current openOnDefinition/contentType
 		String theId = getId(element);

 		if (theId != null) {
 			fCurrentOpenOnDefinition.addPartitionType(fCurrentContentType, theId);
 		}
 	}

 	/**
 	 * Reads the contributions from the registry for the provided workbench
 	 * part and the provided extension point ID.
 	 *
 	 * @param tag
 	 * @param extensionPoint
 	 */
 	protected void readContributions(String tag, String extensionPoint) {
 		targetContributionTag = tag;
 		IExtensionRegistry registry = Platform.getExtensionRegistry();
 		readRegistry(registry, PLUGIN_ID, extensionPoint);
 	}

 	/*
 	 * (non-Javadoc)
 	 *
 	 * @see org.eclipse.wst.sse.ui.internal.extension.RegistryReader#readElement(org.eclipse.core.runtime.IConfigurationElement)
 	 */
 	protected boolean readElement(IConfigurationElement element) {
 		String tag = element.getName();

 		if (tag.equals(targetContributionTag)) {
 			processOpenOnTag(element);

 			// make sure processing of current open on tag resulted in a
 			// current open on definition
 			// before continue reading the children
 			if (fCurrentOpenOnDefinition != null) {
 				readElementChildren(element);
 			}
 			return true;
 		} else if (tag.equals(TAG_CONTENT_TYPE_IDENTIFIER)) {
 			processContentTypeTag(element);

 			// make sure processing of current content type resulted in a
 			// valid content type
 			// before reading the children
 			if (fCurrentContentType != null) {
 				readElementChildren(element);
 			}
 			return true;
 		} else if (tag.equals(TAG_PARTITION_TYPE)) {
 			processPartitionTypeTag(element);
 			return true;
 		}

 		return false;
 	}
 }
	/*******************************************************************************
	* Copyright (c) 2001, 2004 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
	* Jens Lukowski/Innoopract - initial renaming/restructuring
	*
	*******************************************************************************/
	package org.eclipse.wst.sse.ui.internal.openon;

	import java.util.ArrayList;
	import java.util.List;

	import org.eclipse.core.runtime.IConfigurationElement;
	import org.eclipse.core.runtime.IExtensionRegistry;
	import org.eclipse.core.runtime.Platform;
	import org.eclipse.wst.sse.ui.internal.extension.RegistryReader;


	/**
	* Reads extensions for open on extension point,
	* org.eclipse.wst.sse.ui.extensions.openon
	*
	* @deprecated Use base support for hyperlink navigation
	*/
	public class OpenOnBuilder extends RegistryReader {
	public static final String ATT_CLASS = "class"; //$NON-NLS-1$

	public static final String ATT_ID = "id"; //$NON-NLS-1$

	private static OpenOnBuilder fInstance;
	// extension point ID
	public static final String PL_OPENON = "openon"; //$NON-NLS-1$

	public static final String PLUGIN_ID = "org.eclipse.wst.sse.ui"; //$NON-NLS-1$
	public static final String TAG_CONTENT_TYPE_IDENTIFIER = "contenttypeidentifier"; //$NON-NLS-1$

	public static final String TAG_OPENON = "openon"; //$NON-NLS-1$
	public static final String TAG_PARTITION_TYPE = "partitiontype"; //$NON-NLS-1$

	/**
	* returns singleton instance of OpenOnBuilder
	*
	* @return OpenOnBuilder
	*/
	public synchronized static OpenOnBuilder getInstance() {
	if (fInstance == null) {
	fInstance = new OpenOnBuilder();
	}
	return fInstance;
	}

	private String fCurrentContentType;
	private OpenOnDefinition fCurrentOpenOnDefinition = null;

	private List fOpenOnDefs = null;

	protected String targetContributionTag;

	/**
	* Returns the name of the part ID attribute that is expected in the
	* target extension.
	*
	* @param element
	* @return String
	*/
	protected String getId(IConfigurationElement element) {
	String value = element.getAttribute(ATT_ID);
	return value;
	}

	protected String getOpenOnClass(IConfigurationElement element) {
	String value = element.getAttribute(ATT_CLASS);
	return value;
	}

	/**
	* Returns all the open on definition objects
	*
	* @return
	*/
	public OpenOnDefinition[] getOpenOnDefinitions() {
	initCache();
	return (OpenOnDefinition[]) fOpenOnDefs.toArray(new OpenOnDefinition[fOpenOnDefs.size()]);
	}

	/**
	* Returns all the open on definition objects valid for
	* contentType/partitionType
	*
	* @param contentType
	* @param partitionType
	* @return if either contentType or partitionType is null, null is
	* returned
	*/
	public OpenOnDefinition[] getOpenOnDefinitions(String contentType, String partitionType) {
	if (contentType == null \|\| partitionType == null) {
	// should not be able to define an openon without a content type
	// but if it were possible then would need to search all openon
	// definitions for
	// definitions with empty contentType list
	return null;
	}

	// entire list of openon definition objects
	OpenOnDefinition[] allDefs = getOpenOnDefinitions();
	// current list of open on definitions valid for
	// contentType/partitionType
	List defs = new ArrayList();
	// default definitions that should be added to end of list of open on
	// definitions
	List lastDefs = new ArrayList();

	for (int i = 0; i < allDefs.length; ++i) {
	// for each one check if it contains contentType
	List partitions = (List) allDefs[i].getContentTypes().get(contentType);
	if (partitions != null) {
	// this openon definition is valid for all partition types for
	// this content type
	if (partitions.isEmpty()) {
	// this will be added to end of list because this is
	// considered a default openon
	lastDefs.add(allDefs[i]);
	} else {
	// examine the partition types of this openon
	int j = 0; // current index in list of partitions
	boolean added = false; // openon has been added to list
	while (j < partitions.size() && !added) {
	// this openon definition applies to partitionType so
	// add to list of valid openons
	if (partitionType.equals(partitions.get(j))) {
	defs.add(allDefs[i]);
	added = true;
	} else {
	// continue checking to see if this openon
	// definition is valid for current partitionType
	++j;
	}
	}
	}
	}
	}
	// append the default openon definitions
	defs.addAll(lastDefs);

	// return the list
	return (OpenOnDefinition[]) defs.toArray(new OpenOnDefinition[defs.size()]);
	}

	private void initCache() {
	if (fOpenOnDefs == null) {
	fOpenOnDefs = new ArrayList(0);
	readContributions(TAG_OPENON, PL_OPENON);
	}
	}

	/**
	* Processes element which should be a configuration element specifying a
	* content type for the current open on tag. Assumes that there is a valid
	* current open on definition object.
	*
	* @param element
	* contenttypeidentifier configuration element
	*/
	private void processContentTypeTag(IConfigurationElement element) {
	// add to current openOnDefinition
	String theId = getId(element);

	if (theId != null) {
	fCurrentContentType = theId;
	fCurrentOpenOnDefinition.addContentTypeId(fCurrentContentType);
	} else {
	fCurrentContentType = null;
	}
	}

	/**
	* Processes element which should be a configuration element specifying an
	* open on object. Creates a new open on definition object and adds it to
	* the list of open on definition objects
	*
	* @param element
	* openon configuration element
	*/
	private void processOpenOnTag(IConfigurationElement element) {
	String theId = getId(element);
	String theClass = getOpenOnClass(element);

	if (theId != null && theClass != null) {
	// start building new OpenOnDefinition
	fCurrentOpenOnDefinition = new OpenOnDefinition(theId, theClass, element);
	fOpenOnDefs.add(fCurrentOpenOnDefinition);
	} else {
	fCurrentOpenOnDefinition = null;
	}
	}

	/**
	* Processes element which should be a configuration element specifying a
	* partition type for the current open on/content type tag. Assumes that
	* there is a valid current open on/content type tag.
	*
	* @param element
	* partitiontype configuration element
	*/
	private void processPartitionTypeTag(IConfigurationElement element) {
	// add to current openOnDefinition/contentType
	String theId = getId(element);

	if (theId != null) {
	fCurrentOpenOnDefinition.addPartitionType(fCurrentContentType, theId);
	}
	}

	/**
	* Reads the contributions from the registry for the provided workbench
	* part and the provided extension point ID.
	*
	* @param tag
	* @param extensionPoint
	*/
	protected void readContributions(String tag, String extensionPoint) {
	targetContributionTag = tag;
	IExtensionRegistry registry = Platform.getExtensionRegistry();
	readRegistry(registry, PLUGIN_ID, extensionPoint);
	}

	/*
	* (non-Javadoc)
	*
	* @see org.eclipse.wst.sse.ui.internal.extension.RegistryReader#readElement(org.eclipse.core.runtime.IConfigurationElement)
	*/
	protected boolean readElement(IConfigurationElement element) {
	String tag = element.getName();

	if (tag.equals(targetContributionTag)) {
	processOpenOnTag(element);

	// make sure processing of current open on tag resulted in a
	// current open on definition
	// before continue reading the children
	if (fCurrentOpenOnDefinition != null) {
	readElementChildren(element);
	}
	return true;
	} else if (tag.equals(TAG_CONTENT_TYPE_IDENTIFIER)) {
	processContentTypeTag(element);

	// make sure processing of current content type resulted in a
	// valid content type
	// before reading the children
	if (fCurrentContentType != null) {
	readElementChildren(element);
	}
	return true;
	} else if (tag.equals(TAG_PARTITION_TYPE)) {
	processPartitionTypeTag(element);
	return true;
	}

	return false;
	}
	}