plugins/org.eclipse.bpel.ui.noEmbeddedEditors/src/org/eclipse/bpel/ui/details/providers/AbstractResourceContentProvider.java

/*******************************************************************************
 * Copyright (c) 2005, 2012 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:
 *     Oracle Corporation
 *******************************************************************************/
package org.eclipse.bpel.ui.details.providers;

import java.util.Iterator;
import java.util.LinkedList;
import java.util.List;

import org.eclipse.bpel.ui.BPELUIPlugin;
import org.eclipse.core.resources.IContainer;
import org.eclipse.core.resources.IResource;
import org.eclipse.core.resources.IWorkspaceRoot;
import org.eclipse.core.runtime.CoreException;
import org.eclipse.emf.common.util.URI;
import org.eclipse.emf.ecore.resource.Resource;
import org.eclipse.emf.ecore.resource.ResourceSet;


/**
 * Content provider for EMF objects that can be read from the Workspace 
 * 
 * @author Michal Chmielewski (michal.chmielewski@oracle.com)
 */

public abstract class AbstractResourceContentProvider extends AbstractContentProvider  {	
	
	static private final String SLASH = "/"; //$NON-NLS-1$
	
	/**
	 * Append the schemas that are present in the object passed to the list
	 * indicated.   
	 * 
	 * @param input an object that has or is schema definitions.
	 * @param list the list where the schemas are put.
	 */
	
	
	ResourceSet fResourceSet;
	 
	public AbstractResourceContentProvider ( ResourceSet set ) {

		fResourceSet = set;
	}
	
	
	protected void doCollectElements ( Object input, List list) throws CoreException {
		
		if (input == null) {
			return ;
		}
		
		if (input instanceof IContainer) {			
			findCandidates((IContainer) input,list, getKindClass() );
			return;
		}
		
 
		if (isAcceptableKind(input)) {
			list.add(input);			
			return;
		}

		Object[] arr = null;
		
		if (input.getClass().isArray()) {			
			arr = (Object[]) input;
		} else if (input instanceof List) {
			arr = ((List)input).toArray();
		}
		
		if (arr == null) {
			return;
		}
		
		for(int i=0; i < arr.length; i++) {
			doCollectElements ( arr[i], list );
		}					
	}
		
	

	@Override
	public void collectElements (Object input, List list) {
		try {
			doCollectElements ( input, list );
		} catch (CoreException e) {
			BPELUIPlugin.log(e);
		}	
	}				
	
	
	
	/**
	 * Check of the object passed is of the acceptable kind. This simply
	 * checks to see if the the result returned by {@link #getKindClass()}
	 * matches the object passed.
	 *  
	 * @param obj the object to test.
	 * @return true/false, depending on outcomee.
	 */
	
	protected boolean isAcceptableKind ( Object obj ) {
		
		Class [] kind = getKindClass();
		
		if (kind == null) {
			return true;
		}
		
		for(int i=0; i < kind.length; i++) {
			if (kind[i].isInstance(obj)) {
				return true;
			}
		}
		
		return false;
	}
	
	
	
	/**
	 * Find the candidate objects to load.
	 * 
	 * @param container
	 * @param list
	 * @param the kind of EMF objects that we want back
	 * @return
	 * @throws CoreException
	 */
	
	protected List findCandidates ( IContainer container, List list, Class [] kind ) throws CoreException {
		
		if (list == null) {
			list = new LinkedList();
		}		
		
		Iterator i = findCandidates( container ).iterator();
		while (i.hasNext()) {
			IResource r = (IResource) i.next();
			try {
				Object obj = load(r);
				if ( isAcceptableKind (obj) ) {
					list.add(obj);
				} 
			} catch (Exception ex) {
				BPELUIPlugin.log(ex);
			}
		}
		return list;
	}	

	
	/**
	 * Load the EMF model from the resource indicated. Return the top EMF object for the model. 
	 *  
	 * @param r
	 * @return
	 */
	
	protected Object load ( IResource r ) 
    {
    	// Format: /Project/path    	
    	String uri = SLASH + r.getProject().getName() + SLASH + r.getProjectRelativePath();
        URI locationURI = URI.createPlatformResourceURI( uri );       
            
        Resource resource = fResourceSet.getResource(locationURI, true);        
        return resource.getContents().get(0);               
    }

	
	
	protected abstract String[] getKind () ;
	
	
	/**
	 * Return the kind of objects that we as a provider are interested in
	 * 
	 * @return an array of kind of objects that we are interested in
	 */
	
	protected Class[] getKindClass () {
		return null;
	}
	
	
	/**
	 * Return the depth at which discover for new resources will abort if none is found
	 * at the current level and the level below.
	 * 
	 * @return the max depth to search, including current level
	 */
	
	protected int getDepth ( ) {
		return 2;
	}
	
	
	/**
	 * Find candidate resourcesin the container passed. The container is searched
	 * up to a certain depth. If resources are found in that container then the next
	 * level is searched. Otherwise the search at that level stops. So not exactly a full
	 * workspace scan.
	 * 
	 * @param container the container to search (project, folder, workspace root)
	 * @return the list of schemas found
	 * @throws CoreException
	 */
	
	protected List findCandidates ( IContainer container ) throws CoreException {
		
		LinkedList list = new LinkedList();
		
		// Workspace root contains Projects ...
		if (container instanceof IWorkspaceRoot) {
			return findCandidates( container, list, getKind(), getDepth() + 1 );
		}		
		return findCandidates( container, list, getKind(), getDepth() );		
	}
	
	
	
	
	protected List findCandidates ( IContainer container, List list, String [] kind , int depth ) throws CoreException {
		
		if (depth <= 0 || container.isAccessible() == false) {
			return list;
		}
		
		depth -= 1;
		
		boolean bFound = false;
		
		IResource [] rlist = container.members();
			
		for(int i=0; i< rlist.length; i++) {
			
			IResource r = rlist[i];
			if ( r.getType() != IResource.FILE) {
				continue;
			}			
			String name = r.getFileExtension();
			for(int j=0; j < kind.length; j++) {
				if (name != null && name.equalsIgnoreCase(kind[j])) {
					bFound = true;
					list.add( r );
					break;
				}
			}				
		}
		
		// if found some candidates at this level, look only in the next level (and
		// so on). Eventually, not all levels are searched, just the ones that contain
		// xsd resources and their descendant folders
		
		if (bFound) {
			depth = 1;
		}
			
		for(int i=0; i < rlist.length; i++) {
			IResource r = rlist[i];
			if (r instanceof IContainer) {
				findCandidates((IContainer) r, list, kind, depth);
			}
		}
		
		return list;
	}
	
	
}