blob: fb7d278dd8902f072344b5e667439a61ebe83c1a [file] [log] [blame]
/****************************************************************************
* Copyright (c) 2004 Composent, Inc. and others.
*
* This program and the accompanying materials are made
* available under the terms of the Eclipse Public License 2.0
* which is available at https://www.eclipse.org/legal/epl-2.0/
*
* Contributors: Composent, Inc. - initial API and implementation
*
* SPDX-License-Identifier: EPL-2.0
*****************************************************************************/
package org.eclipse.ecf.core;
import java.lang.reflect.InvocationTargetException;
import java.util.*;
import org.eclipse.core.runtime.*;
import org.eclipse.ecf.core.provider.IContainerInstantiator;
import org.eclipse.ecf.core.provider.IRemoteServiceContainerInstantiator;
import org.eclipse.ecf.core.util.Trace;
import org.eclipse.ecf.internal.core.ECFDebugOptions;
import org.eclipse.ecf.internal.core.ECFPlugin;
/**
* Description of an {@link IContainer} type. Instances of this class are used to represent {@link IContainerInstantiator}s
* in the {@link ContainerFactory}
*
* @see ContainerFactory IContainerInstantiator
*/
public class ContainerTypeDescription {
protected String name = null;
protected String instantiatorClass = null;
protected IContainerInstantiator instantiator = null;
protected String description = null;
protected int hashCode = 0;
protected boolean server;
protected boolean hidden;
public ContainerTypeDescription(String name, String instantiatorClass, String description) {
this(name, instantiatorClass, description, false, false);
}
public ContainerTypeDescription(String name, String instantiatorClass, String description, boolean server, boolean hidden) {
Assert.isNotNull(name, "ContainerTypeDescription<init> name cannot be null"); //$NON-NLS-1$
this.name = name;
this.hashCode = name.hashCode();
Assert.isNotNull(instantiatorClass, "ContainerTypeDescription<init> instantiatorClass cannot be null"); //$NON-NLS-1$
this.instantiatorClass = instantiatorClass;
this.description = description;
this.server = server;
this.hidden = hidden;
}
/**
* @param name name
* @param instantiator instantiator
* @since 3.4
*/
public ContainerTypeDescription(String name, IContainerInstantiator instantiator) {
this(name, instantiator, null);
}
public ContainerTypeDescription(String name, IContainerInstantiator instantiator, String description) {
this(name, instantiator, description, false, false);
}
public ContainerTypeDescription(String name, IContainerInstantiator inst, String desc, boolean server, boolean hidden) {
Assert.isNotNull(name, "ContainerTypeDescription<init> name cannot be null"); //$NON-NLS-1$
this.name = name;
this.hashCode = name.hashCode();
Assert.isNotNull(inst, "ContainerTypeDescription<init> instantiator instance cannot be null"); //$NON-NLS-1$
this.instantiator = inst;
this.description = desc;
this.server = server;
this.hidden = hidden;
}
/**
* Get ContainerTypeDescription name
*
* @return String name for the ContainerTypeDescription. Will not be null.
*/
public String getName() {
return name;
}
public boolean equals(Object other) {
if (!(other instanceof ContainerTypeDescription))
return false;
ContainerTypeDescription scd = (ContainerTypeDescription) other;
return scd.name.equals(name);
}
public int hashCode() {
return hashCode;
}
public String toString() {
StringBuffer b = new StringBuffer("ContainerTypeDescription["); //$NON-NLS-1$
b.append("name=").append(name).append(";"); //$NON-NLS-1$ //$NON-NLS-2$
if (instantiator == null)
b.append("instantiatorClass=").append(instantiatorClass) //$NON-NLS-1$
.append(";"); //$NON-NLS-1$
else
b.append("instantiator=").append(instantiator).append(";"); //$NON-NLS-1$ //$NON-NLS-2$
b.append("desc=").append(description).append(";"); //$NON-NLS-1$ //$NON-NLS-2$
return b.toString();
}
protected IContainerInstantiator getInstantiator() throws ClassNotFoundException, InstantiationException, IllegalAccessException {
synchronized (this) {
if (instantiator == null)
initializeInstantiator();
return instantiator;
}
}
private void initializeInstantiator() throws ClassNotFoundException, InstantiationException, IllegalAccessException {
// Load instantiator class
Class clazz = Class.forName(instantiatorClass);
// Make new instance
try {
instantiator = (IContainerInstantiator) clazz.getDeclaredConstructor().newInstance();
} catch (InvocationTargetException e) {
throw new ClassNotFoundException("Invocation target exception accessing null constructor for class=" + clazz, e); //$NON-NLS-1$
} catch (NoSuchMethodException e) {
throw new ClassNotFoundException("No null constructor found on class=" + clazz, e); //$NON-NLS-1$
} catch (SecurityException e) {
throw new ClassNotFoundException("Security exception accessing null constructor for class=" + clazz, e); //$NON-NLS-1$
}
}
/**
* Get the String description associated with this ContainerTypeDescription
* instance
*
* @return String description. May be null.
*/
public String getDescription() {
return description;
}
public boolean isServer() {
return server;
}
public boolean isHidden() {
return hidden;
}
/**
* Get array of supported adapters for this container type description. The
* returned array entries will be the fully qualified names of the adapter
* classes.
*
* Note that the returned types do not guarantee that a subsequent call to
* {@link IContainer#getAdapter(Class)} with the same type name as a
* returned value will return a non-<code>null</code> result. In other words, even if the
* class name is in the returned array, subsequent calls to
* {@link IContainer#getAdapter(Class)} may still return <code>null</code>.
*
* @return String[] of supported adapters. The entries in the returned array
* will be the fully qualified class names of adapters supported by
* the given description. An empty string array (String[0]) will be
* returned if no adapters are supported.
*/
public String[] getSupportedAdapterTypes() {
String[] result = new String[0];
try {
String[] r = getInstantiator().getSupportedAdapterTypes(this);
if (r != null)
result = r;
} catch (Exception e) {
traceAndLogException(IStatus.ERROR, "getSupportedAdapterTypes", e); //$NON-NLS-1$
}
List resultList = new ArrayList();
resultList.addAll(Arrays.asList(result));
if (!resultList.contains(IContainer.class.getName()))
resultList.add(IContainer.class.getName());
return (String[]) resultList.toArray(new String[] {});
}
protected void traceAndLogException(int code, String method, Throwable e) {
Trace.catching(ECFPlugin.PLUGIN_ID, ECFDebugOptions.EXCEPTIONS_CATCHING, this.getClass(), method, e);
ECFPlugin.getDefault().log(new Status(IStatus.ERROR, ECFPlugin.PLUGIN_ID, code, method, e));
}
/**
* Get array of parameter types for this ContainerTypeDescription. Each of
* the rows of the returned array specifies a Class[] of parameter types.
* These parameter types correspond to the types of Objects that can be
* passed into the second parameter of
* {@link IContainerInstantiator#createInstance(ContainerTypeDescription, Object[])}.
* For example, if this method returns a Class [] = {{ String.class,
* String.class }, { String.class }} this indicates that a call to
* createInstance(description,new String[] { "hello", "there" }) and a call
* to createInstance(description,new String[] { "hello" }) will be
* understood by the underlying provider implementation.
*
* @return Class[][] array of Class arrays. Each row corresponds to a
* Class[] that describes the types of Objects for second parameter
* to
* {@link IContainerInstantiator#createInstance(ContainerTypeDescription, Object[])}.
* If no parameter types are understood as arguments, a Class[0][0]
* array will be returned
*/
public Class[][] getSupportedParameterTypes() {
Class[][] result = {{}};
try {
Class[][] r = getInstantiator().getSupportedParameterTypes(this);
if (r != null)
result = r;
} catch (Exception e) {
traceAndLogException(IStatus.ERROR, "getSupportedParameterTypes", e); //$NON-NLS-1$
}
return result;
}
/**
* @return String[] of container's intents.
*
* @since 3.0
*/
public String[] getSupportedIntents() {
try {
IContainerInstantiator ci = getInstantiator();
return (ci instanceof IRemoteServiceContainerInstantiator) ? ((IRemoteServiceContainerInstantiator) ci).getSupportedIntents(this) : null;
} catch (Exception e) {
traceAndLogException(IStatus.ERROR, "getSupportedIntents", e); //$NON-NLS-1$
return null;
}
}
/**
* @return String[] supported configs
* @since 3.1
*/
public String[] getSupportedConfigs() {
try {
IContainerInstantiator ci = getInstantiator();
return (ci instanceof IRemoteServiceContainerInstantiator) ? ((IRemoteServiceContainerInstantiator) ci).getSupportedConfigs(this) : null;
} catch (Exception e) {
traceAndLogException(IStatus.ERROR, "getSupportedConfigs", e); //$NON-NLS-1$
return null;
}
}
/**
* @param exporterSupportedConfigs exporter supported configs
* @return String[] imported configs
* @since 3.1
*/
public String[] getImportedConfigs(String[] exporterSupportedConfigs) {
if (exporterSupportedConfigs == null)
return null;
try {
IContainerInstantiator ci = getInstantiator();
return (ci instanceof IRemoteServiceContainerInstantiator) ? ((IRemoteServiceContainerInstantiator) ci).getImportedConfigs(this, exporterSupportedConfigs) : null;
} catch (Exception e) {
traceAndLogException(IStatus.ERROR, "getImportedConfigs", e); //$NON-NLS-1$
return null;
}
}
/**
* @param importedConfigs imported configs
* @param exportedProperties exported properties
* @return Dictionary dictionary of properties for imported configs
* @since 3.1
*/
public Dictionary getPropertiesForImportedConfigs(String[] importedConfigs, Dictionary exportedProperties) {
if (importedConfigs == null)
return null;
try {
IContainerInstantiator ci = getInstantiator();
return (ci instanceof IRemoteServiceContainerInstantiator) ? ((IRemoteServiceContainerInstantiator) ci).getPropertiesForImportedConfigs(this, importedConfigs, exportedProperties) : null;
} catch (Exception e) {
traceAndLogException(IStatus.ERROR, "getPropertiesForImportedConfigs", e); //$NON-NLS-1$
return null;
}
}
}