RubyTypeHierarchyEngine.java

/*******************************************************************************
 * Copyright (c) 2005, 2016 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
 *
 *******************************************************************************/
package org.eclipse.dltk.ruby.internal.typehierarchy;

import java.util.ArrayList;
import java.util.List;

import org.eclipse.core.runtime.CoreException;
import org.eclipse.core.runtime.IProgressMonitor;
import org.eclipse.dltk.core.DLTKLanguageManager;
import org.eclipse.dltk.core.IType;
import org.eclipse.dltk.core.ModelException;
import org.eclipse.dltk.core.WorkingCopyOwner;
import org.eclipse.dltk.core.search.IDLTKSearchConstants;
import org.eclipse.dltk.core.search.IDLTKSearchScope;
import org.eclipse.dltk.core.search.SearchEngine;
import org.eclipse.dltk.core.search.SearchPattern;
import org.eclipse.dltk.core.search.TypeNameMatch;
import org.eclipse.dltk.core.search.TypeNameMatchRequestor;

public class RubyTypeHierarchyEngine {
	private static final boolean DEBUG = false;
	public static IType[] locateSuperTypes( IType type, IProgressMonitor monitor ) {
		try {
			String[] superTypes = type.getSuperClasses();
			List<IType> types = new ArrayList<IType>();
			if (superTypes != null) {
				monitor.beginTask(Messages.RubyTypeHierarchyEngine_collectingTypes, superTypes.length);
				IDLTKSearchScope scope = SearchEngine.createWorkspaceScope(DLTKLanguageManager.getLanguageToolkit(type));
				for( int i = 0; i < superTypes.length; ++i ) {
					if( DEBUG ) {
						System.out.println("Type:" + type.getElementName() + " has supertype:" + superTypes[i]); //$NON-NLS-1$ //$NON-NLS-2$
					}
					TypeNameMatch[] possibleTypes = searchTypesForName(superTypes[i], monitor, scope);
					for( int j = 0; j < possibleTypes.length; ++i ) {
						IType sType = possibleTypes[j].getType();
						if( sType.exists() && filterTypeFromSelection(sType, type)) {
							types.add(sType);
						}
					}
				}
			}
			return types.toArray(new IType[types.size()]);
		} catch (ModelException e) {
			e.printStackTrace();
		} catch (CoreException e) {
			e.printStackTrace();
		}
		finally {
			monitor.done();
		}
		return null;
	}
	private static boolean filterTypeFromSelection(IType superType, IType type ) {
		return true;
	}
	private static TypeNameMatch[] searchTypesForName(String name, IProgressMonitor monitor, IDLTKSearchScope scope ) {
		SearchRequestor reqestor = new SearchRequestor();
		SearchEngine engine= new SearchEngine((WorkingCopyOwner)null);
		monitor.setTaskName(Messages.RubyTypeHierarchyEngine_searchingTypes);
		try {
			engine.searchAllTypeNames(
				null, 
				0,
				name.toCharArray(), 
				SearchPattern.R_EXACT_MATCH | SearchPattern.R_CASE_SENSITIVE, 
				IDLTKSearchConstants.TYPE, 
				scope, 
				reqestor, 
				IDLTKSearchConstants.WAIT_UNTIL_READY_TO_SEARCH, 
				monitor);
			return reqestor.getResult();
		} catch (ModelException e) {
			e.printStackTrace();
		}
		return null;
	}
	private static class SearchRequestor extends TypeNameMatchRequestor {
		private volatile boolean fStop;

		private List<TypeNameMatch> fResult;
		
		public SearchRequestor() {
			super();
			fResult= new ArrayList<TypeNameMatch>(5);
		}
		public TypeNameMatch[] getResult() {
			return fResult.toArray(new TypeNameMatch[fResult.size()]);
		}
		public void cancel() {
			fStop= true;
		}

		@Override
		public void acceptTypeNameMatch(TypeNameMatch match) {
			if (fStop)
				return;
			fResult.add(match);
		}
	}
}