/*******************************************************************************
* Copyright (c) 2001, 2005 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.core.internal.provisional;
/**
* An abstract implementation of IAdapterFactory. All implementers of
* IAdapterFactory should subclass this class. The default constructor uses
* itself (this) as the key. Subclasses need to provide a way to create the
* adapter, and can override or call other methods.
*/
abstract public class AbstractAdapterFactory implements INodeAdapterFactory {
private Object fAdapterKey;
private boolean fShouldRegisterAdapter;
/**
* If this default constructor used, setAdapterKey and setShouldRegister
* should be used to properly initialize.
*/
protected AbstractAdapterFactory() {
super();
}
public AbstractAdapterFactory(Object adapterKey) {
this(adapterKey, true);
}
/**
* Suclasses may extended this constructor, if needed.
*/
public AbstractAdapterFactory(Object adapterKey, boolean registerAdapters) {
super();
fAdapterKey = adapterKey;
fShouldRegisterAdapter = registerAdapters;
}
/**
* ISSUE: should be final. See those that implement it
* for complicating details and "unknowns".
*/
public INodeAdapter adapt(INodeNotifier target) {
INodeAdapter adapter = null;
if (target != null) {
adapter = target.getExistingAdapter(fAdapterKey);
if (adapter == null) {
adapter = adaptNew(target);
}
}
return adapter;
}
/**
* Subclasses should normally implement their own 'copy' method. By
* default, we'll return the same instance, for convenience of those using
* singleton factories (which have no state, and so need to do anything on
* 'release').
*
*/
public INodeAdapterFactory copy() {
return this;
}
/**
* This method needs to return true of this factory is for adapters of
* type 'type'. It is required that it return true if 'equals' and this
* default behavior is provided by this super class. Clients may extend
* this behavior if more complex logic is required.
*/
public boolean isFactoryForType(Object type) {
return type.equals(fAdapterKey);
}
/**
* Subclasses may need to "cleanup" their adapter factory, release
* adapters, resources, etc. Subclasses may extend this method if such
* clean up is required. Note: while current behavior is to do nothing,
* subclasses should not assume this would always be true, so should
* always call super.release at the end of their method.
*/
public void release() {
// default for superclass is to do nothing
}
/**
* Only for special cases there the adapter key can be set in the
* constructor. It can be set here. If it is set more than, and
*/
final protected void setAdapterKey(Object key) {
if (fAdapterKey != null && !(fAdapterKey.equals(key)))
throw new IllegalStateException("INodeAdapter Key cannot be changed."); //$NON-NLS-1$
fAdapterKey = key;
}
/**
* Can be called by subclasses during 'adapt' process, but must not be
* overridden or reimplemented by subclasses.
*
* @param target
* @return
*/
protected final INodeAdapter adaptNew(INodeNotifier target) {
INodeAdapter adapter = createAdapter(target);
if (adapter != null) {
if (fShouldRegisterAdapter) {
target.addAdapter(adapter);
}
}
return adapter;
}
/**
* Subclasses must implement this method. It is called by infrastructure
* when an instance is needed. It is provided the node notifier, which may
* or may not be relevent when creating the adapter. Note: the adapter
* does not have to literally be a new intance and is actually recommended
* to typically be a singleton for performance reasons.
*
* @param target
* @return
*/
abstract protected INodeAdapter createAdapter(INodeNotifier target);
protected final boolean isShouldRegisterAdapter() {
return fShouldRegisterAdapter;
}
protected final void setShouldRegisterAdapter(boolean shouldRegisterAdapter) {
// ISSUE: technically we probably should not allow this value to
// change, after initialization, but is not so easy to do,
// and I'm not sure its "worth" the protection.
fShouldRegisterAdapter = shouldRegisterAdapter;
}
protected final Object getAdapterKey() {
return fAdapterKey;
}
}