/*******************************************************************************
* Copyright (c) 2004, 2013 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
*******************************************************************************/
package org.eclipse.wst.server.core.model;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import org.eclipse.core.resources.IProject;
import org.eclipse.core.runtime.IProgressMonitor;
import org.eclipse.wst.server.core.IModule;
import org.eclipse.wst.server.core.IServer;
import org.eclipse.wst.server.core.ServerCore;
import org.eclipse.wst.server.core.internal.Module;
import org.eclipse.wst.server.core.internal.ModuleFactory;
import org.eclipse.wst.server.core.internal.Server;
/**
* A module factory delegate provides a mechanism for discovering
* modules. A module factory delegate is specified by the
* <code>class</code> attribute of a <code>moduleFactories</code> extension.
* <p>
* When the module factory needs to be given a delegate, the delegate class
* specified for the module factory is instantiated with a 0-argument
* constructor.
* </p>
* <p>
* Module factory delegates may keep state in instance fields, but that state is
* transient and will not be persisted across workbench sessions.
* </p>
* <p>
* This abstract class is intended to be extended only by clients
* to extend the <code>moduleFactories</code> extension point.
* </p>
*
* @see org.eclipse.wst.server.core.IModule
* @see ModuleDelegate
* @since 1.0
*/
public abstract class ModuleFactoryDelegate {
private ModuleFactory factory;
/**
* Delegates must have a public 0-arg constructor.
*/
public ModuleFactoryDelegate() {
// do nothing
}
/**
* Initializes this module factory delegate with its life-long module
* factory instance.
* <p>
* This method is called by the server core framework.
* Clients should never call this method.
* </p>
*
* @param newFactory the module factory instance
* @param monitor a progress monitor, or <code>null</code> if progress
* reporting and cancellation are not desired
*/
final void initialize(ModuleFactory newFactory, IProgressMonitor monitor) {
factory = newFactory;
initialize();
}
/**
* Initializes this module factory delegate. This method gives delegates a chance
* to do their own initialization.
* <p>
* This method is called by the server core framework.
* Clients should never call this method.
* </p>
*/
public void initialize() {
// do nothing
}
/**
* Returns the id of this factory.
* Each factory has a distinct id, fixed for its lifetime. Ids are intended to
* be used internally as keys; they are not intended to be shown to end users.
*
* @return the factory id
*/
protected final String getId() {
return factory.getId();
}
/**
* Clears the cache of modules returned by getModules(). Delegates can call this
* method if they know that the results of getModules() is invalid and should be
* refreshed.
*
* @deprecated This method is implementation specific and never called by the
* framework. It shouldn't be part of the public API, but subclasses are still
* welcome to provide their own method to clear the cache.
* @see #getModules()
*/
public void clearModuleCache() {
// ignore
}
/**
* Creates a module instance with the given static information. This method is used
* by module factory delegates to create module instances.
*
* @param id the module id
* @param name the module name
* @param type the module type id
* @param version the module version id
* @param project the project that the module is contained in
* @return a module instance
*/
protected final IModule createModule(String id, String name, String type, String version, IProject project) {
return new Module(factory, id, name, type, version, project);
}
/**
* Creates a module instance with the given static information,
* including a map of properties.
*
* This method is used by module factory delegates to create module instances.
*
* @param id the module id
* @param name the module name
* @param type the module type id
* @param version the module version id
* @param project the project that the module is contained in
* @param properties a map of key/value pairs for additional information
* @return a module instance
* @since 1.5
*/
protected final IModule createModule(String id, String name, String type, String version, IProject project, Map<String, String> properties) {
return new Module(factory, id, name, type, version, project, properties);
}
/**
* Creates the module delegate for a module with the given information.
* This method is called when a client needs to access the module delegate
* associated with the given module.
*
* @param module a module
* @return the module delegate
*/
public abstract ModuleDelegate getModuleDelegate(IModule module);
/**
* Return all modules created by this factory.
* <p>
* This method is normally called by the web server core framework.
* Clients (other than the delegate) should never call this method.
* </p>
* <p>
* A new array is returned on each call, so clients may store or modify the result.
* </p>
*
* @return a possibly-empty array of modules {@link IModule}
*/
public abstract IModule[] getModules();
/**
* Return all modules created by this factory that are contained within the
* given project. Subclasses should override this method if they do not need
* to filter through the entire project list.
* <p>
* This method is normally called by the web server core framework.
* Clients (other than the delegate) should never call this method.
* </p>
* <p>
* A new array is returned on each call, so clients may store or modify the result.
* </p>
*
* @param project a project
* @return a possibly-empty array of modules {@link IModule}
* @since 2.0
*/
public IModule[] getModules(IProject project) {
IModule[] modules = getModules();
if (project != null && modules != null) {
List<IModule> list = new ArrayList<IModule>(modules.length);
int size = modules.length;
for (int i = 0; i < size; i++) {
if (project.equals(modules[i].getProject()))
list.add(modules[i]);
}
IModule[] m = new IModule[list.size()];
list.toArray(m);
return m;
}
return new IModule[0];
}
/**
* Returns the module created by this factory that has the given id, or
* <code>null</code> if there is no module with the given id. The id must
* not be null.
* <p>
* Subclasses should override this method if they do not need to search
* through the entire project list.
* </p>
* <p>
* This method is normally called by the web server core framework.
* Clients (other than the delegate) should never call this method.
* </p>
*
* @param id a module id
* @return the module with the given id, or <code>null</code> if no module
* could be found {@link IModule}
* @since 2.0
*/
public IModule findModule(String id) {
if (id == null)
return null;
IModule[] modules = getModules();
if (modules != null) {
int size = modules.length;
for (int i = 0; i < size; i++) {
String id2 = modules[i].getId();
int index = id2.indexOf(":");
if (index >= 0)
id2 = id2.substring(index+1);
if (id.equals(id2))
return modules[i];
}
}
return null;
}
/**
* Alerts the server tools framework that this factory's list of modules
* has changed, and caches may no longer be accurate
*/
protected void modulesChanged() {
IServer[] allServers = ServerCore.getServers();
for( int i = 0; i < allServers.length; i++ ) {
((Server)allServers[i]).clearModuleCache();
}
}
}