1 files changed, 257 insertions, 0 deletions
diff --git a/target_explorer/plugins/org.eclipse.tcf.te.core/src/org/eclipse/tcf/te/core/connection/managers/ConnectionTypeBindingsManager.java b/target_explorer/plugins/org.eclipse.tcf.te.core/src/org/eclipse/tcf/te/core/connection/managers/ConnectionTypeBindingsManager.java
new file mode 100644
index 000000000..92870e2ac
--- /dev/null
+++ b/target_explorer/plugins/org.eclipse.tcf.te.core/src/org/eclipse/tcf/te/core/connection/managers/ConnectionTypeBindingsManager.java
@@ -0,0 +1,257 @@
+/*******************************************************************************
+ * Copyright (c) 2011 Wind River Systems, Inc. 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:
+ * Wind River Systems - initial API and implementation
+ *******************************************************************************/
+package org.eclipse.tcf.te.core.connection.managers;
+
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.Comparator;
+import java.util.LinkedHashMap;
+import java.util.List;
+import java.util.Map;
+
+import org.eclipse.core.runtime.Assert;
+import org.eclipse.core.runtime.IConfigurationElement;
+import org.eclipse.core.runtime.IExtension;
+import org.eclipse.core.runtime.IExtensionPoint;
+import org.eclipse.core.runtime.IExtensionRegistry;
+import org.eclipse.core.runtime.Platform;
+import org.eclipse.tcf.te.core.connection.interfaces.IConnectStrategy;
+import org.eclipse.tcf.te.core.connection.interfaces.IConnectionType;
+
+/**
+ * Connection type bindings extension point manager implementation.
+ */
+public class ConnectionTypeBindingsManager {
+
+	/**
+	 * Immutable class describing a connect strategy binding.
+	 */
+	private final static class ConnectStrategyBinding {
+		public final String id;
+		public final String overwrite;
+
+		public ConnectStrategyBinding(String id, String overwrite) {
+			this.id = id;
+			this.overwrite = overwrite;
+		}
+	}
+
+	// Flag to remember if the extension point got already read and processed.
+	private boolean initialized;
+
+	// The map between connection type id's and their associated connect strategies.
+	private final Map<String, List<ConnectStrategyBinding>> typeIdToStrategyId = new LinkedHashMap<String, List<ConnectStrategyBinding>>();
+
+	// The sub extension point manager instances
+	private final ConnectionTypeExtensionPointManager connectionTypeManger = new ConnectionTypeExtensionPointManager();
+
+	/*
+	 * Thread save singleton instance creation.
+	 */
+	private static class LazyConnectionTypeBindingsManager {
+		public static ConnectionTypeBindingsManager instance = new ConnectionTypeBindingsManager();
+	}
+
+	/**
+	 * Returns the singleton instance for the connection type bindings manager.
+	 */
+	public static ConnectionTypeBindingsManager getInstance() {
+		return LazyConnectionTypeBindingsManager.instance;
+	}
+
+	/**
+	 * Constructor.
+	 */
+	ConnectionTypeBindingsManager() {
+		initialized = false;
+		initialize();
+	}
+
+	/**
+	 * Initialize the connection type bindings manager and triggers to load and read the managed
+	 * extension points.
+	 */
+	public void initialize() {
+		if (initialized) {
+			return;
+		}
+		// load and register the connection type bindings
+		loadConnectionTypeBindings();
+		initialized = true;
+	}
+
+	// ***** BEGIN: Section extension point management *****
+
+	/**
+	 * Load and register all connection type id shortcuts.
+	 */
+	private void loadConnectionTypeBindings() {
+		// load all target connection type bindings and register them
+		IExtensionRegistry registry = Platform.getExtensionRegistry();
+		IExtensionPoint point = registry.getExtensionPoint("org.eclipse.tcf.te.core.connectionTypeBindings"); //$NON-NLS-1$
+		if (point != null) {
+			// load target connection type bindings
+			IExtension[] typeBindings = point.getExtensions();
+			for (IExtension typeBinding : typeBindings) {
+				// load configuration elements
+				IConfigurationElement[] configElements = typeBinding.getConfigurationElements();
+				for (IConfigurationElement configElement : configElements) {
+					// handle connection type binding
+					if ("connectionTypeBinding".equals(configElement.getName())) { //$NON-NLS-1$
+						String connectionTypeId = configElement.getAttribute("connectionTypeId"); //$NON-NLS-1$
+						// load connect strategy binding
+						IConfigurationElement[] connectStrategy = configElement.getChildren("connectStrategy"); //$NON-NLS-1$
+						for (IConfigurationElement element : connectStrategy) {
+							String connectStrategyId = element.getAttribute("id"); //$NON-NLS-1$
+							String connectStrategyOverwrite = element.getAttribute("overwrite"); //$NON-NLS-1$
+							if (connectStrategyId != null && connectStrategyId.length() > 0) {
+								registerConnectStrategyBinding(connectionTypeId.trim(), connectStrategyId.trim(), connectStrategyOverwrite != null ? connectStrategyOverwrite.trim() : null);
+							}
+						}
+					}
+				}
+			}
+		}
+	}
+
+	// ***** END: Section extension point management *****
+
+	// ***** BEGIN: Section connect strategy management *****
+
+	/**
+	 * Register a binding between a connection type id and a connect strategy id. Bindings
+	 * registered for the same connection type will be overwritten using the overwrite attribute. If
+	 * the connect strategy id is <code>null</code>, possibly registered bindings are removed.
+	 *
+	 * @param typeId The connection type id. Must not be <code>null</code> and not empty.
+	 * @param strategyId The connect strategy id or <code>null</code>.
+	 * @param overwrite The connect strategy id that should be overwritten by this id.
+	 */
+	public void registerConnectStrategyBinding(String typeId, String strategyId, String overwrite) {
+		Assert.isNotNull(typeId);
+		Assert.isTrue(typeId.trim().length() > 0);
+
+		if (strategyId != null && strategyId.trim().length() > 0) {
+			List<ConnectStrategyBinding> bindings = typeIdToStrategyId.get(typeId.trim());
+			if (bindings == null) {
+				bindings = new ArrayList<ConnectStrategyBinding>();
+				typeIdToStrategyId.put(typeId.trim(), bindings);
+			}
+			ConnectStrategyBinding binding = new ConnectStrategyBinding(strategyId.trim(), overwrite != null ? overwrite.trim() : null);
+			bindings.add(binding);
+			Collections.sort(bindings, new Comparator<ConnectStrategyBinding>() {
+				@Override
+                public int compare(ConnectStrategyBinding o1, ConnectStrategyBinding o2) {
+					// handle  multiple id's without overwrite (alphabetical order)
+					if (o1.overwrite == null && o2.overwrite == null) {
+						return o1.id.compareTo(o2.id);
+					}
+					// handle overwrite the same id twice (alphabetical order)
+					if (o1.overwrite != null && o2.overwrite != null && o1.overwrite.equals(o2.overwrite)) {
+						return o1.id.compareTo(o2.id);
+					}
+					// handle recursive overwrite (alphabetical order)
+					if (o1.overwrite != null && o1.overwrite.equals(o2.id) && o2.overwrite != null && o2.overwrite.equals(o1.id)) {
+						return o1.id.compareTo(o2.id);
+					}
+					// o1 overwrites o2
+					if (o1.overwrite != null && o1.overwrite.equals(o2.id)) {
+						return -1;
+					}
+					// o2 overwrites o1
+					if (o2.overwrite != null && o2.overwrite.equals(o1.id)) {
+						return 1;
+					}
+					// fallback alphabetical order
+					return o1.id.compareTo(o2.id);
+				}
+			});
+
+		} else if (strategyId == null) {
+			typeIdToStrategyId.remove(typeId.trim());
+		}
+	}
+
+	/**
+	 * Returns the corresponding connect strategy id for the given connection type id.
+	 *
+	 * @param typeId The connection type id. Must not be <code>null</code> and not empty!
+	 * @return The connect strategy id if registered or <code>null</code>.
+	 */
+	public String getConnectStrategyId(String typeId) {
+		if (typeId != null && typeId.trim().length() > 0) {
+			List<ConnectStrategyBinding> bindings = typeIdToStrategyId.get(typeId.trim());
+			return bindings != null && !bindings.isEmpty() ? bindings.get(0).id : null;
+		}
+		return null;
+	}
+
+	/**
+	 * Returns the corresponding <code>IConnectStrategy</code> for the given connection type id.
+	 *
+	 * @param typeId The connection type id. Must not be <code>null</code>.
+	 * @return The corresponding connect strategy object or <code>null</code>.
+	 */
+	public IConnectStrategy getConnectStrategy(String typeId) {
+		Assert.isNotNull(typeId);
+		String connectStrategyId = getConnectStrategyId(typeId);
+		return ConnectStrategyExtensionPointManager.getInstance().getConnectStrategy(connectStrategyId);
+	}
+
+	// ***** END: Section connect strategy management *****
+
+	// ***** BEGIN: Section connection type management *****
+
+	/**
+	 * Returns the list of all contributed connection types.
+	 *
+	 * @return The list of contributed connection types, or an empty array.
+	 */
+	public IConnectionType[] getConnectionTypes() {
+		return connectionTypeManger.getConnectionTypes();
+	}
+
+	/**
+	 * Returns the corresponding <code>IConnectionType</code> for the given connection type id.
+	 *
+	 * @param typeId The connection type id. Must not be <code>null</code>.
+	 * @return The corresponding connection type object or <code>null</code>.
+	 */
+	public IConnectionType getConnectionType(String typeId) {
+		Assert.isNotNull(typeId);
+		return connectionTypeManger.getConnectionType(typeId);
+	}
+
+	/**
+	 * Returns the corresponding <code>IConnectionType</code> for the given connectable context object.
+	 *
+	 * @param context The connectable context object. Must not be <code>null</code>
+	 * @return The corresponding target connection type object or <code>null</code>.
+	 */
+	public IConnectionType getConnectionType(Object context) {
+		Assert.isNotNull(context);
+		return null;
+	}
+
+	/**
+	 * Checks if the connection type, specified by the given type id, is enabled.
+	 * <p>
+	 * A connection type is enabled when at least one enablement evaluates to <code>true</code>.
+	 *
+	 * @param typeId The connection type id. Must not be <code>null</code>.
+	 * @return <code>True</code> if the connection type is enabled, <code>false</code> otherwise.
+	 */
+	public boolean isConnectionTypeEnabled(String typeId) {
+		Assert.isNotNull(typeId);
+		return true;
+	}
+
+	// ***** END: Section connection type management *****
+}