Attachment #59683 for bug #175151

Some Eclipse Foundation services are deprecated, or will be soon. Please ensure you've read this important communication.




/*******************************************************************************
 * Copyright (c) 2006 QNX Software Systems 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:
 * 		QNX - Initial API and implementation
 * 		IBM Corporation
 *******************************************************************************/

package org.eclipse.cdt.core.browser;

import org.eclipse.cdt.core.CCorePlugin;
import org.eclipse.cdt.core.dom.IName;
import org.eclipse.cdt.core.dom.ast.DOMException;
import org.eclipse.cdt.core.dom.ast.IBinding;
import org.eclipse.cdt.core.dom.ast.cpp.ICPPBinding;
import org.eclipse.cdt.core.index.IIndex;
import org.eclipse.cdt.core.model.ICProject;
import org.eclipse.cdt.core.parser.ast.ASTAccessVisibility;
import org.eclipse.cdt.internal.core.CCoreInternals;
import org.eclipse.cdt.internal.core.dom.parser.cpp.CPPVisitor;
import org.eclipse.cdt.internal.core.pdom.PDOM;
import org.eclipse.cdt.internal.core.pdom.dom.PDOMNotImplementedError;
import org.eclipse.core.runtime.CoreException;

/**
 * @author Doug Schaefer
 *
 */
public class PDOMTypeInfo implements ITypeInfo {

	private final IBinding binding;
	private final int elementType;
	private final ICProject project;

	public PDOMTypeInfo(IBinding binding, int elementType, ICProject project) {
		this.binding = binding;
		this.elementType = elementType;
		this.project = project;
	}
	
	public void addDerivedReference(ITypeReference location) {
		throw new PDOMNotImplementedError();
	}

	public void addReference(ITypeReference location) {
		throw new PDOMNotImplementedError();
	}

	public boolean canSubstituteFor(ITypeInfo info) {
		throw new PDOMNotImplementedError();
	}

	public boolean encloses(ITypeInfo info) {
		throw new PDOMNotImplementedError();
	}

	public boolean exists() {
		throw new PDOMNotImplementedError();
	}

	public int getCElementType() {
		return elementType;
	}

	public ITypeReference[] getDerivedReferences() {
		throw new PDOMNotImplementedError();
	}

	public ITypeInfo[] getEnclosedTypes() {
		throw new PDOMNotImplementedError();
	}

	public ITypeInfo[] getEnclosedTypes(int[] kinds) {
		throw new PDOMNotImplementedError();
	}

	public ITypeInfo getEnclosingNamespace(boolean includeGlobalNamespace) {
		throw new PDOMNotImplementedError();
	}

	public ICProject getEnclosingProject() {
		return project;
	}

	public ITypeInfo getEnclosingType() {
		// TODO not sure
		return null;
	}

	public ITypeInfo getEnclosingType(int[] kinds) {
		throw new PDOMNotImplementedError();
	}

	public String getName() {
		return binding.getName();
	}

	public IQualifiedTypeName getQualifiedTypeName() {
		String qn;
		if(binding instanceof ICPPBinding) {
			try {
				qn = CPPVisitor.renderQualifiedName(((ICPPBinding)binding).getQualifiedName());
			} catch(DOMException de) {
				CCorePlugin.log(de); // can't happen when (binding instanceof PDOMBinding)
				return null;
			}
		} else {
			qn = binding.getName();
		}
		
		return new QualifiedTypeName(qn);
	}

	public ITypeReference[] getReferences() {
		throw new PDOMNotImplementedError();
	}

	public ITypeReference getResolvedReference() {
		try {
			PDOM pdom = (PDOM) CCoreInternals.getPDOMManager().getPDOM(project);
			IName[] names= pdom.findNames(binding, IIndex.FIND_DEFINITIONS);
			return names != null && names.length > 0 ? new PDOMTypeReference(names[0], project) : null;
		} catch (CoreException e) {
			CCorePlugin.log(e);
			return null;
		}
	}

	public ITypeInfo getRootNamespace(boolean includeGlobalNamespace) {
		throw new PDOMNotImplementedError();
	}

	public ITypeInfo[] getSubTypes() {
		throw new PDOMNotImplementedError();
	}

	public ASTAccessVisibility getSuperTypeAccess(ITypeInfo subType) {
		throw new PDOMNotImplementedError();
	}

	public ITypeInfo[] getSuperTypes() {
		throw new PDOMNotImplementedError();
	}

	public boolean hasEnclosedTypes() {
		throw new PDOMNotImplementedError();
	}

	public boolean hasSubTypes() {
		throw new PDOMNotImplementedError();
	}

	public boolean hasSuperTypes() {
		throw new PDOMNotImplementedError();
	}

	public boolean isClass() {
		throw new PDOMNotImplementedError();
	}

	public boolean isEnclosed(ITypeInfo info) {
		throw new PDOMNotImplementedError();
	}

	public boolean isEnclosed(ITypeSearchScope scope) {
		throw new PDOMNotImplementedError();
	}

	public boolean isEnclosedType() {
		throw new PDOMNotImplementedError();
	}

	public boolean isEnclosingType() {
		throw new PDOMNotImplementedError();
	}

	public boolean isReferenced(ITypeSearchScope scope) {
		throw new PDOMNotImplementedError();
	}

	public boolean isUndefinedType() {
		throw new PDOMNotImplementedError();
	}

	public void setCElementType(int type) {
		throw new PDOMNotImplementedError();
	}

	public int compareTo(Object arg0) {
		throw new PDOMNotImplementedError();
	}

}




/*******************************************************************************
 * Copyright (c) 2006 QNX Software Systems 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:
 * QNX - Initial API and implementation
 *******************************************************************************/

package org.eclipse.cdt.core.browser;

import org.eclipse.cdt.core.dom.IName;
import org.eclipse.cdt.core.model.CoreModel;
import org.eclipse.cdt.core.model.ICElement;
import org.eclipse.cdt.core.model.ICProject;
import org.eclipse.cdt.core.model.ITranslationUnit;
import org.eclipse.cdt.core.model.IWorkingCopy;
import org.eclipse.cdt.internal.core.pdom.dom.PDOMNotImplementedError;
import org.eclipse.core.resources.IProject;
import org.eclipse.core.resources.IResource;
import org.eclipse.core.runtime.IPath;
import org.eclipse.core.runtime.Path;

/**
 * @author Doug Schaefer
 *
 */
public class PDOMTypeReference implements ITypeReference {
	
	private final IName name;
	private final ICProject project;
	private final IPath path; 
	
	public PDOMTypeReference(IName name, ICProject project) {
		this.name = name;
		this.project = project;
		this.path = new Path(name.getFileLocation().getFileName());
	}

	public ICElement[] getCElements() {
		throw new PDOMNotImplementedError();
	}

	public int getLength() {
		return name.getFileLocation().getNodeLength();
	}

	public IPath getLocation() {
		return path;
	}

	public int getOffset() {
		return name.getFileLocation().getNodeOffset();
	}

	public IPath getPath() {
		return path;
	}

	public IProject getProject() {
		throw new PDOMNotImplementedError();
	}

	public IPath getRelativeIncludePath(IProject project) {
		throw new PDOMNotImplementedError();
	}

	public IPath getRelativePath(IPath relativeToPath) {
		throw new PDOMNotImplementedError();
	}

	public IResource getResource() {
		throw new PDOMNotImplementedError();
	}

	public ITranslationUnit getTranslationUnit() {
		ICElement element = CoreModel.getDefault().create(path);
		if (element != null && element instanceof ITranslationUnit)
			return (ITranslationUnit)element;
		else
			return CoreModel.getDefault().createTranslationUnitFrom(project, path);
	}

	public IWorkingCopy getWorkingCopy() {
		throw new PDOMNotImplementedError();
	}

	public boolean isLineNumber() {
		return name.getFileLocation().getNodeLength() == -1;
	}

}




 *
 * Contributors:
 *     QNX Software Systems - initial API and implementation
 *     Andrew Ferguson (Symbian)
 *******************************************************************************/
package org.eclipse.cdt.core.browser;

import java.util.regex.Pattern;
import java.util.List;

import org.eclipse.cdt.core.CCorePlugin;
import org.eclipse.cdt.core.dom.ILinkage;
import org.eclipse.cdt.core.dom.IPDOMNode;
import org.eclipse.cdt.core.dom.IPDOMVisitor;
import org.eclipse.cdt.core.dom.ast.DOMException;
import org.eclipse.cdt.core.dom.ast.IBinding;
import org.eclipse.cdt.core.index.IIndex;
import org.eclipse.cdt.core.index.IIndexBinding;
import org.eclipse.cdt.core.index.IndexFilter;
import org.eclipse.cdt.core.dom.ast.cpp.ICPPNamespace;
import org.eclipse.cdt.core.dom.ast.cpp.ICPPNamespaceAlias;
import org.eclipse.cdt.core.model.CoreModel;
import org.eclipse.cdt.core.model.ICElement;
import org.eclipse.cdt.core.model.ICProject;
import org.eclipse.cdt.internal.core.browser.util.IndexModelUtil;
import org.eclipse.cdt.internal.core.pdom.PDOM;
import org.eclipse.cdt.internal.core.pdom.PDOMManager;
import org.eclipse.cdt.internal.core.pdom.dom.PDOMBinding;
import org.eclipse.cdt.internal.core.pdom.dom.PDOMLinkage;
import org.eclipse.cdt.internal.core.pdom.dom.c.PDOMCStructure;
import org.eclipse.core.runtime.CoreException;
import org.eclipse.core.runtime.IProgressMonitor;
import org.eclipse.core.runtime.NullProgressMonitor;

/**
 * Manages a search cache for types in the workspace. Instead of returning

 * waits for the completion of the background job.
 */
public class AllTypesCache {
	private static final boolean DEBUG = false;
	private abstract static class TypesCollector implements IPDOMVisitor {
		private final int[] kinds;
		protected final List types;
		protected final ICProject project;
		
		protected TypesCollector(int[] kinds, List types, ICProject project) {
			this.kinds = kinds;
			this.types = types;
			this.project = project;
		}
		
		protected abstract void visitKind(IPDOMNode node, int kind);
		
		public boolean visit(IPDOMNode node) throws CoreException {
			for (int i = 0; i < kinds.length; ++i)
				visitKind(node, kinds[i]);
			return true;
		}
		
		public void leave(IPDOMNode node) throws CoreException {
		}
		
		public List getTypes() {
			return types;
		}
	}
	
	private static ITypeInfo[] getTypes(ICProject[] projects, final int[] kinds, IProgressMonitor monitor) throws CoreException {
		IIndex index = CCorePlugin.getIndexManager().getIndex(projects);
			super(kinds, types, project);
		}
		
		try {
			index.acquireReadLock();
			
			long start = System.currentTimeMillis();
			
			IIndexBinding[] all =
				index.findBindings(Pattern.compile(".*"), false, new IndexFilter() { //$NON-NLS-1$
					public boolean acceptBinding(IBinding binding) {
						return IndexModelUtil.bindingHasCElementType(binding, kinds);
					}},
					monitor
				);
			
			if(DEBUG) {
				System.out.println("Index search took "+(System.currentTimeMillis() - start)); //$NON-NLS-1$
				start = System.currentTimeMillis();
			}
			
			ITypeInfo[] result = new ITypeInfo[all.length];
			for(int i=0; i<all.length; i++) {
				IIndexBinding ib = (IIndexBinding) all[i];				
				result[i] = new IndexTypeInfo(ib.getQualifiedName(), IndexModelUtil.getElementType(ib), index);
			super(kinds, types, project);
		}
		
		protected void visitKind(IPDOMNode node, int kind) {
			try {
				switch (kind) {
				case ICElement.C_NAMESPACE:
					if (node instanceof ICPPNamespace || node instanceof ICPPNamespaceAlias)
						types.add(new PDOMTypeInfo((PDOMBinding)node, kind, project));
					return;
				case ICElement.C_CLASS:
					if (node instanceof ICPPClassType
							&& ((ICPPClassType)node).getKey() == ICPPClassType.k_class)
						types.add(new PDOMTypeInfo((PDOMBinding)node, kind, project));
					return;
				case ICElement.C_STRUCT:
					if (node instanceof ICPPClassType
							&& ((ICPPClassType)node).getKey() == ICompositeType.k_struct)
						types.add(new PDOMTypeInfo((PDOMBinding)node, kind, project));
					return;
				case ICElement.C_UNION:
					if (node instanceof ICPPClassType
							&& ((ICPPClassType)node).getKey() == ICompositeType.k_union)
						types.add(new PDOMTypeInfo((PDOMBinding)node, kind, project));
					return;
				case ICElement.C_ENUMERATION:
					if (node instanceof IEnumeration
							/*&& node instanceof ICPPBinding*/)
							types.add(new PDOMTypeInfo((IEnumeration)node, kind, project));
					return;
				case ICElement.C_TYPEDEF:
					return;
				}
			} catch (DOMException e) {
				CCorePlugin.log(e);
			}

			if(DEBUG) {
				System.out.println("Wrapping as ITypeInfo took "+(System.currentTimeMillis() - start)); //$NON-NLS-1$
				start = System.currentTimeMillis();
		List types = new ArrayList();
		PDOMManager pdomManager = CCoreInternals.getPDOMManager();
		
		for (int i = 0; i < projects.length; ++i) {
			ICProject project = projects[i];
			CTypesCollector cCollector = new CTypesCollector(kinds, types, project);
			CPPTypesCollector cppCollector = new CPPTypesCollector(kinds, types, project);
				
			PDOM pdom = (PDOM)pdomManager.getPDOM(project);
			PDOMLinkage linkage= pdom.getLinkage(ILinkage.C_LINKAGE_ID);
			if (linkage != null) {
				linkage.accept(cCollector);
			}
			
			return result;
		} catch(InterruptedException ie) {
			ie.printStackTrace();
		} finally {
			index.releaseReadLock();
		}
		return new ITypeInfo[0];
		return (ITypeInfo[])types.toArray(new ITypeInfo[types.size()]);
	}

	/**
	 * Returns all types in the workspace.
	 */
	public static ITypeInfo[] getAllTypes() {
		return getAllTypes(new NullProgressMonitor());
	}
	
	/**
	 * Returns all types in the workspace.
	 */
	public static ITypeInfo[] getAllTypes(IProgressMonitor monitor) {
		try {
			ICProject[] projects = CoreModel.getDefault().getCModel().getCProjects();
			return getTypes(projects, ITypeInfo.KNOWN_TYPES, monitor);
		} catch (CoreException e) {
			CCorePlugin.log(e);
			return new ITypeInfo[0];
		}
	}

	/**
	 * Returns all types in the given scope.
	 * 

	 */
	public static ITypeInfo[] getTypes(ITypeSearchScope scope, int[] kinds) {
		try {
			return getTypes(scope.getEnclosingProjects(), kinds, new NullProgressMonitor());
		} catch (CoreException e) {
			CCorePlugin.log(e);
			return new ITypeInfo[0];
		}
	}

	/**
	 * Returns all namespaces in the given scope.
	 * 

	 */
	public static ITypeInfo[] getNamespaces(ITypeSearchScope scope, boolean includeGlobalNamespace) {
		try {
			return getTypes(scope.getEnclosingProjects(), new int[] {ICElement.C_NAMESPACE}, new NullProgressMonitor());
		} catch (CoreException e) {
			CCorePlugin.log(e);
			return new ITypeInfo[0];
		}
	}

	/** Returns first type in the cache which matches the given
	 *  type and name.  If no type is found, <code>null</code>
	 *  is returned.

Lines 36-42 Link Here

(-)META-INF/MANIFEST.MF (-1 / +1 lines)
36	org.eclipse.cdt.core.settings.model.extension.impl,	36	org.eclipse.cdt.core.settings.model.extension.impl,
37	org.eclipse.cdt.core.settings.model.util,	37	org.eclipse.cdt.core.settings.model.util,
38	org.eclipse.cdt.internal.core;x-friends:="org.eclipse.cdt.ui",	38	org.eclipse.cdt.internal.core;x-friends:="org.eclipse.cdt.ui",
39	org.eclipse.cdt.internal.core.browser.util;x-internal:=true,	39	org.eclipse.cdt.internal.core.browser.util;x-friends:="org.eclipse.cdt.ui",
40	org.eclipse.cdt.internal.core.dom;x-friends:="org.eclipse.cdt.ui,org.eclipse.cdt.refactoring",	40	org.eclipse.cdt.internal.core.dom;x-friends:="org.eclipse.cdt.ui,org.eclipse.cdt.refactoring",
41	org.eclipse.cdt.internal.core.dom.parser;x-friends:="org.eclipse.cdt.refactoring",	41	org.eclipse.cdt.internal.core.dom.parser;x-friends:="org.eclipse.cdt.refactoring",
42	org.eclipse.cdt.internal.core.dom.parser.c;x-friends:="org.eclipse.cdt.refactoring",	42	org.eclipse.cdt.internal.core.dom.parser.c;x-friends:="org.eclipse.cdt.refactoring",




/*******************************************************************************
 * Copyright (c) 2006, 2007 QNX Software Systems 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:
 * 		QNX - Initial API and implementation
 * 		IBM Corporation
 *      Andrew Ferguson (Symbian)
 *******************************************************************************/
package org.eclipse.cdt.internal.core.browser.util;

import org.eclipse.cdt.core.CCorePlugin;
import org.eclipse.cdt.core.dom.ast.DOMException;
import org.eclipse.cdt.core.dom.ast.IBinding;
import org.eclipse.cdt.core.dom.ast.ICompositeType;
import org.eclipse.cdt.core.dom.ast.IEnumeration;
import org.eclipse.cdt.core.dom.ast.ITypedef;
import org.eclipse.cdt.core.dom.ast.cpp.ICPPClassType;
import org.eclipse.cdt.core.dom.ast.cpp.ICPPNamespace;
import org.eclipse.cdt.core.dom.ast.cpp.ICPPNamespaceAlias;
import org.eclipse.cdt.core.model.ICElement;

/**
 * Convenience class for bridging the model gap between binding types and CModel types
 * 
 * This is internal in case some IBinding's do not have ICElement constants in future
 */
public class IndexModelUtil {
	/**
	 * Returns whether the binding is of any of the specified CElement type constants
	 * @param binding
	 * @param kinds
	 * @return whether the binding is of any of the specified CElement type constants
	 */
	public static boolean bindingHasCElementType(IBinding binding, int[] kinds) {
		try {
			for(int i=0; i<kinds.length; i++) {
				switch(kinds[i]) {
				case ICElement.C_STRUCT:
					if (binding instanceof ICompositeType
							&& ((ICompositeType)binding).getKey() == ICompositeType.k_struct)
						return true;
					break;
				case ICElement.C_UNION:
					if (binding instanceof ICompositeType
							&& ((ICompositeType)binding).getKey() == ICompositeType.k_union)
						return true;
					break;
				case ICElement.C_CLASS:
					if (binding instanceof ICompositeType
							&& ((ICompositeType)binding).getKey() == ICPPClassType.k_class)
						return true;
					break;
				case ICElement.C_NAMESPACE:
					if (binding instanceof ICPPNamespace || binding instanceof ICPPNamespaceAlias)
						return true;
					break;
				case ICElement.C_ENUMERATION:
					if (binding instanceof IEnumeration)
						return true;
					break;
				case ICElement.C_TYPEDEF:
					if(binding instanceof ITypedef)
						return true;
					break;
				}
			}
		} catch(DOMException de) {
			CCorePlugin.log(de);
		}
		return false;
	}
	
	/**
	 * Returns the CElement type constant for the specified binding
	 * @param binding
	 * @return the CElement type constant for the specified binding
	 */
	public static int getElementType(IBinding binding) {
		int elementType = Integer.MIN_VALUE;

		if (binding instanceof ICompositeType) {
			ICompositeType classType = (ICompositeType) binding;
			try {
				if(classType.getKey() == ICPPClassType.k_class) {
					elementType = ICElement.C_CLASS;
				} else if(classType.getKey() == ICPPClassType.k_struct) {
					elementType = ICElement.C_STRUCT;
				} else if(classType.getKey() == ICPPClassType.k_union) {
					elementType = ICElement.C_UNION;
				}
			} catch(DOMException de) {
				CCorePlugin.log(de);
			}
		}

		if (binding instanceof ICPPNamespace || binding instanceof ICPPNamespaceAlias) {
			elementType = ICElement.C_NAMESPACE;
		}

		if (binding instanceof IEnumeration) {
			elementType = ICElement.C_ENUMERATION; 		
		}
		return elementType;
	}
}




/*******************************************************************************
 * Copyright (c) 2006, 2007 QNX Software Systems 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:
 * 		QNX - Initial API and implementation
 * 		IBM Corporation
 *      Andrew Ferguson (Symbian)
 *******************************************************************************/
package org.eclipse.cdt.core.browser;

import org.eclipse.cdt.core.CCorePlugin;
import org.eclipse.cdt.core.dom.ast.IBinding;
import org.eclipse.cdt.core.index.IIndex;
import org.eclipse.cdt.core.index.IIndexBinding;
import org.eclipse.cdt.core.index.IIndexFileLocation;
import org.eclipse.cdt.core.index.IIndexName;
import org.eclipse.cdt.core.index.IndexFilter;
import org.eclipse.cdt.core.model.ICProject;
import org.eclipse.cdt.core.parser.ast.ASTAccessVisibility;
import org.eclipse.cdt.internal.core.browser.util.IndexModelUtil;
import org.eclipse.cdt.internal.core.pdom.dom.PDOMNotImplementedError;
import org.eclipse.core.filesystem.URIUtil;
import org.eclipse.core.resources.IFile;
import org.eclipse.core.resources.IProject;
import org.eclipse.core.resources.ResourcesPlugin;
import org.eclipse.core.runtime.CoreException;
import org.eclipse.core.runtime.IPath;
import org.eclipse.core.runtime.NullProgressMonitor;
import org.eclipse.core.runtime.Path;

/**
 * @author Doug Schaefer
 *
 */
public class IndexTypeInfo implements ITypeInfo {
	private final String[] fqn;
	private final int elementType;
	private final IIndex index;
	private ITypeReference reference; // lazily constructed
	
	public IndexTypeInfo(String[] fqn, int elementType, IIndex index) {
		this.fqn = fqn;
		this.elementType = elementType;
		this.index = index;
	}

	public void addDerivedReference(ITypeReference location) {
		throw new PDOMNotImplementedError();
	}

	public void addReference(ITypeReference location) {
		throw new PDOMNotImplementedError();
	}

	public boolean canSubstituteFor(ITypeInfo info) {
		throw new PDOMNotImplementedError();
	}

	public boolean encloses(ITypeInfo info) {
		throw new PDOMNotImplementedError();
	}

	public boolean exists() {
		throw new PDOMNotImplementedError();
	}

	public int getCElementType() {
		return elementType;
	}

	public ITypeReference[] getDerivedReferences() {
		throw new PDOMNotImplementedError();
	}

	public ITypeInfo[] getEnclosedTypes() {
		throw new PDOMNotImplementedError();
	}

	public ITypeInfo[] getEnclosedTypes(int[] kinds) {
		throw new PDOMNotImplementedError();
	}

	public ITypeInfo getEnclosingNamespace(boolean includeGlobalNamespace) {
		throw new PDOMNotImplementedError();
	}

	public ICProject getEnclosingProject() {
		if(getResolvedReference()!=null) {
			IProject project = reference.getProject();
			if(project!=null) {
				return CCorePlugin.getDefault().getCoreModel().getCModel().getCProject(project.getName());
			}
		}
		return null;
	}

	public ITypeInfo getEnclosingType() {
		// TODO not sure
		return null;
	}

	public ITypeInfo getEnclosingType(int[] kinds) {
		throw new PDOMNotImplementedError();
	}

	public String getName() {
		return fqn[fqn.length-1];
	}

	public IQualifiedTypeName getQualifiedTypeName() {
		return new QualifiedTypeName(fqn);
	}

	public ITypeReference[] getReferences() {
		throw new PDOMNotImplementedError();
	}

	public ITypeReference getResolvedReference() {
		if(reference==null) {
			try {
				index.acquireReadLock();

				char[][] cfqn = new char[fqn.length][];
				for(int i=0; i<fqn.length; i++)
					cfqn[i] = fqn[i].toCharArray();

				IIndexBinding[] ibs = index.findBindings(cfqn, new IndexFilter() {
					public boolean acceptBinding(IBinding binding) {
						return IndexModelUtil.bindingHasCElementType(binding, new int[]{elementType});
					}
				}, new NullProgressMonitor());
				if(ibs.length>0) {
					IIndexName[] names = index.findNames(ibs[0], IIndex.FIND_DEFINITIONS);
					if(names.length>0) {
						IIndexFileLocation ifl = names[0].getFile().getLocation();
						String fullPath = ifl.getFullPath();
						if(fullPath!=null) {
							IFile file = ResourcesPlugin.getWorkspace().getRoot().getFile(new Path(fullPath));
							if(file!=null) {
								reference = new TypeReference(
										file, file.getProject(), names[0].getNodeOffset(), names[0].getNodeLength()
								);
							}
						} else {
							IPath path = URIUtil.toPath(ifl.getURI());
							if(path!=null) {
								reference = new TypeReference(
										path, null, names[0].getNodeOffset(), names[0].getNodeLength()
								);
							}
						}
					}
				}
			} catch(CoreException ce) {
				CCorePlugin.log(ce);				
			} catch (InterruptedException ie) {
				CCorePlugin.log(ie);
			} finally {
				index.releaseReadLock();
			}
		}
		return reference;
	}

	public ITypeInfo getRootNamespace(boolean includeGlobalNamespace) {
		throw new PDOMNotImplementedError();
	}

	public ITypeInfo[] getSubTypes() {
		throw new PDOMNotImplementedError();
	}

	public ASTAccessVisibility getSuperTypeAccess(ITypeInfo subType) {
		throw new PDOMNotImplementedError();
	}

	public ITypeInfo[] getSuperTypes() {
		throw new PDOMNotImplementedError();
	}

	public boolean hasEnclosedTypes() {
		throw new PDOMNotImplementedError();
	}

	public boolean hasSubTypes() {
		throw new PDOMNotImplementedError();
	}

	public boolean hasSuperTypes() {
		throw new PDOMNotImplementedError();
	}

	public boolean isClass() {
		throw new PDOMNotImplementedError();
	}

	public boolean isEnclosed(ITypeInfo info) {
		throw new PDOMNotImplementedError();
	}

	public boolean isEnclosed(ITypeSearchScope scope) {
		throw new PDOMNotImplementedError();
	}

	public boolean isEnclosedType() {
		throw new PDOMNotImplementedError();
	}

	public boolean isEnclosingType() {
		throw new PDOMNotImplementedError();
	}

	public boolean isReferenced(ITypeSearchScope scope) {
		throw new PDOMNotImplementedError();
	}

	public boolean isUndefinedType() {
		throw new PDOMNotImplementedError();
	}

	public void setCElementType(int type) {
		throw new PDOMNotImplementedError();
	}

	public int compareTo(Object arg0) {
		throw new PDOMNotImplementedError();
	}

}




 *
 * Contributors:
 *     QNX Software Systems - initial API and implementation
 *     Andrew Ferguson (Symbian)
 *******************************************************************************/
package org.eclipse.cdt.internal.ui.browser.opentype;


import org.eclipse.ui.PartInitException;
import org.eclipse.ui.texteditor.ITextEditor;

import org.eclipse.cdt.core.browser.AllTypesCache;
import org.eclipse.cdt.core.browser.ITypeInfo;
import org.eclipse.cdt.core.browser.ITypeReference;
import org.eclipse.cdt.core.model.CModelException;

	 * @see org.eclipse.ui.IActionDelegate#run(org.eclipse.jface.action.IAction)
	 */
	public void run(IAction action) {
		ITypeInfo[] elements = AllTypesCache.getAllTypes();
		if (elements.length == 0) {
			String title = OpenTypeMessages.getString("OpenTypeAction.notypes.title"); //$NON-NLS-1$
			String message = OpenTypeMessages.getString("OpenTypeAction.notypes.message"); //$NON-NLS-1$
			MessageDialog.openInformation(getShell(), title, message);
			return;
		}
		
		OpenTypeDialog dialog = new OpenTypeDialog(getShell());
		dialog.setElements(elements);
		int result = dialog.open();
		if (result != IDialogConstants.OK_ID)
			return;

Lines 1-5 Link Here

(-)browser/org/eclipse/cdt/internal/ui/browser/opentype/OpenTypeDialog.java (-2 / +99 lines)
1	/*******************************************************************************	1	/*******************************************************************************
2	* Copyright (c) 2004, 2006 IBM Corporation and others.	2	* Copyright (c) 2004, 2006, 2007 IBM Corporation and others.
3	* All rights reserved. This program and the accompanying materials	3	* All rights reserved. This program and the accompanying materials
4	* are made available under the terms of the Eclipse Public License v1.0	4	* are made available under the terms of the Eclipse Public License v1.0
5	* which accompanies this distribution, and is available at	5	* which accompanies this distribution, and is available at
Lines 8-18 Link Here
8	* Contributors:	8	* Contributors:
9	* IBM Corporation - initial API and implementation	9	* IBM Corporation - initial API and implementation
10	* QNX Software Systems - adapted for use in CDT	10	* QNX Software Systems - adapted for use in CDT
		11	* Andrew Ferguson (Symbian)
11	*******************************************************************************/	12	*******************************************************************************/
12	package org.eclipse.cdt.internal.ui.browser.opentype;	13	package org.eclipse.cdt.internal.ui.browser.opentype;
13		14
14	import org.eclipse.cdt.ui.browser.typeinfo.TypeSelectionDialog;	15	import java.util.ArrayList;
		16	import java.util.List;
		17
		18	import org.eclipse.core.runtime.CoreException;
		19	import org.eclipse.swt.SWT;
		20	import org.eclipse.swt.widgets.Composite;
		21	import org.eclipse.swt.widgets.Event;
		22	import org.eclipse.swt.widgets.Listener;
15	import org.eclipse.swt.widgets.Shell;	23	import org.eclipse.swt.widgets.Shell;
		24	import org.eclipse.swt.widgets.Text;
		25
		26	import org.eclipse.cdt.core.CCorePlugin;
		27	import org.eclipse.cdt.core.browser.ITypeInfo;
		28	import org.eclipse.cdt.core.browser.IndexTypeInfo;
		29	import org.eclipse.cdt.core.dom.ast.DOMException;
		30	import org.eclipse.cdt.core.dom.ast.IBinding;
		31	import org.eclipse.cdt.core.dom.ast.cpp.ICPPBinding;
		32	import org.eclipse.cdt.core.index.IIndex;
		33	import org.eclipse.cdt.core.index.IndexFilter;
		34	import org.eclipse.cdt.core.model.CoreModel;
		35	import org.eclipse.cdt.ui.browser.typeinfo.TypeSelectionDialog;
		36
		37	import org.eclipse.cdt.internal.core.browser.util.IndexModelUtil;
16		38
17	/**	39	/**
18	* A dialog to select a type from a list of types. The selected type will be	40	* A dialog to select a type from a list of types. The selected type will be
Lines 31-35 Link Here
31	setTitle(OpenTypeMessages.getString("OpenTypeDialog.title")); //$NON-NLS-1$	53	setTitle(OpenTypeMessages.getString("OpenTypeDialog.title")); //$NON-NLS-1$
32	setMessage(OpenTypeMessages.getString("OpenTypeDialog.message")); //$NON-NLS-1$	54	setMessage(OpenTypeMessages.getString("OpenTypeDialog.message")); //$NON-NLS-1$
33	setDialogSettings(DIALOG_SETTINGS);	55	setDialogSettings(DIALOG_SETTINGS);
		56
		57	}
		58
		59
		60	char[] toPrefix(String userFilter) {
		61	userFilter= userFilter.trim().replaceAll("^(\\)", ""); //$NON-NLS-1$//$NON-NLS-2$
		62	int asterix= userFilter.indexOf("*"); //$NON-NLS-1$
		63	return (asterix==-1 ? userFilter : userFilter.substring(0, asterix)).toCharArray();
		64	}
		65
		66	/**
		67	* Update the list of elements in AbstractElementListSelectionDialog
		68	*
		69	* Filtering on wildcards and types is done by the superclass - we just provide
		70	* a good starting point
		71	* @param userFilter
		72	*/
		73	public void update(String userFilter) {
		74	char[] prefix = toPrefix(userFilter);
		75	List types = new ArrayList();
		76	if(prefix.length>0)
		77	try {
		78	IIndex index = CCorePlugin.getIndexManager().getIndex(CoreModel.getDefault().getCModel().getCProjects());
		79	try {
		80	index.acquireReadLock();
		81	IBinding[] bindings= index.findBindingsForPrefix(prefix, IndexFilter.ALL, false);
		82	for(int i=0; i<bindings.length; i++) {
		83	IBinding binding = bindings[i];
		84	try {
		85	String[] fqn;
		86
		87	if(binding instanceof ICPPBinding) {
		88	fqn= ((ICPPBinding)binding).getQualifiedName();
		89	} else {
		90	fqn = new String[] {binding.getName()};
		91	}
		92	types.add(new IndexTypeInfo(fqn, IndexModelUtil.getElementType(binding), index));
		93	} catch(DOMException de) {
		94
		95	}
		96	}
		97	} finally {
		98	index.releaseReadLock();
		99	}
		100	} catch(CoreException ce) {
		101	CCorePlugin.log(ce);
		102	} catch(InterruptedException ie) {
		103	CCorePlugin.log(ie);
		104	}
		105	setListElements(types.toArray(new ITypeInfo[types.size()]));
		106	}
		107
		108	protected void setListElements(Object[] elements) {
		109	super.setListElements(elements);
		110	}
		111
		112	/**
		113	* @deprecated
		114	*/
		115	public void setElements(Object[] elements) {
		116	}
		117
		118	protected void handleEmptyList() {
		119	// override super-class behaviour with no-op
120	}
121
122	protected Text createFilterText(Composite parent) {
123	final Text result = super.createFilterText(parent);
124	Listener listener = new Listener() {
125	public void handleEvent(Event e) {
126	update(result.getText());
127	}
128	};
129	result.addListener(SWT.Modify, listener);
130	return result;
34	}	131	}
35	}	132	}

Return to bug 175151

Removed Link Here

(-)browser/org/eclipse/cdt/core/browser/PDOMTypeInfo.java (-197 lines)
1	/*******************************************************************************
2	* Copyright (c) 2006 QNX Software Systems and others.
3	* All rights reserved. This program and the accompanying materials
4	* are made available under the terms of the Eclipse Public License v1.0
5	* which accompanies this distribution, and is available at
6	* http://www.eclipse.org/legal/epl-v10.html
7	*
8	* Contributors:
9	* QNX - Initial API and implementation
10	* IBM Corporation
11	*******************************************************************************/
12
13	package org.eclipse.cdt.core.browser;
14
15	import org.eclipse.cdt.core.CCorePlugin;
16	import org.eclipse.cdt.core.dom.IName;
17	import org.eclipse.cdt.core.dom.ast.DOMException;
18	import org.eclipse.cdt.core.dom.ast.IBinding;
19	import org.eclipse.cdt.core.dom.ast.cpp.ICPPBinding;
20	import org.eclipse.cdt.core.index.IIndex;
21	import org.eclipse.cdt.core.model.ICProject;
22	import org.eclipse.cdt.core.parser.ast.ASTAccessVisibility;
23	import org.eclipse.cdt.internal.core.CCoreInternals;
24	import org.eclipse.cdt.internal.core.dom.parser.cpp.CPPVisitor;
25	import org.eclipse.cdt.internal.core.pdom.PDOM;
26	import org.eclipse.cdt.internal.core.pdom.dom.PDOMNotImplementedError;
27	import org.eclipse.core.runtime.CoreException;
28
29	/**
30	* @author Doug Schaefer
31	*
32	*/
33	public class PDOMTypeInfo implements ITypeInfo {
34
35	private final IBinding binding;
36	private final int elementType;
37	private final ICProject project;
38
39	public PDOMTypeInfo(IBinding binding, int elementType, ICProject project) {
40	this.binding = binding;
41	this.elementType = elementType;
42	this.project = project;
43	}
44
45	public void addDerivedReference(ITypeReference location) {
46	throw new PDOMNotImplementedError();
47	}
48
49	public void addReference(ITypeReference location) {
50	throw new PDOMNotImplementedError();
51	}
52
53	public boolean canSubstituteFor(ITypeInfo info) {
54	throw new PDOMNotImplementedError();
55	}
56
57	public boolean encloses(ITypeInfo info) {
58	throw new PDOMNotImplementedError();
59	}
60
61	public boolean exists() {
62	throw new PDOMNotImplementedError();
63	}
64
65	public int getCElementType() {
66	return elementType;
67	}
68
69	public ITypeReference[] getDerivedReferences() {
70	throw new PDOMNotImplementedError();
71	}
72
73	public ITypeInfo[] getEnclosedTypes() {
74	throw new PDOMNotImplementedError();
75	}
76
77	public ITypeInfo[] getEnclosedTypes(int[] kinds) {
78	throw new PDOMNotImplementedError();
79	}
80
81	public ITypeInfo getEnclosingNamespace(boolean includeGlobalNamespace) {
82	throw new PDOMNotImplementedError();
83	}
84
85	public ICProject getEnclosingProject() {
86	return project;
87	}
88
89	public ITypeInfo getEnclosingType() {
90	// TODO not sure
91	return null;
92	}
93
94	public ITypeInfo getEnclosingType(int[] kinds) {
95	throw new PDOMNotImplementedError();
96	}
97
98	public String getName() {
99	return binding.getName();
100	}
101
102	public IQualifiedTypeName getQualifiedTypeName() {
103	String qn;
104	if(binding instanceof ICPPBinding) {
105	try {
106	qn = CPPVisitor.renderQualifiedName(((ICPPBinding)binding).getQualifiedName());
107	} catch(DOMException de) {
108	CCorePlugin.log(de); // can't happen when (binding instanceof PDOMBinding)
109	return null;
110	}
111	} else {
112	qn = binding.getName();
113	}
114
115	return new QualifiedTypeName(qn);
116	}
117
118	public ITypeReference[] getReferences() {
119	throw new PDOMNotImplementedError();
120	}
121
122	public ITypeReference getResolvedReference() {
123	try {
124	PDOM pdom = (PDOM) CCoreInternals.getPDOMManager().getPDOM(project);
125	IName[] names= pdom.findNames(binding, IIndex.FIND_DEFINITIONS);
126	return names != null && names.length > 0 ? new PDOMTypeReference(names[0], project) : null;
127	} catch (CoreException e) {
128	CCorePlugin.log(e);
129	return null;
130	}
131	}
132
133	public ITypeInfo getRootNamespace(boolean includeGlobalNamespace) {
134	throw new PDOMNotImplementedError();
135	}
136
137	public ITypeInfo[] getSubTypes() {
138	throw new PDOMNotImplementedError();
139	}
140
141	public ASTAccessVisibility getSuperTypeAccess(ITypeInfo subType) {
142	throw new PDOMNotImplementedError();
143	}
144
145	public ITypeInfo[] getSuperTypes() {
146	throw new PDOMNotImplementedError();
147	}
148
149	public boolean hasEnclosedTypes() {
150	throw new PDOMNotImplementedError();
151	}
152
153	public boolean hasSubTypes() {
154	throw new PDOMNotImplementedError();
155	}
156
157	public boolean hasSuperTypes() {
158	throw new PDOMNotImplementedError();
159	}
160
161	public boolean isClass() {
162	throw new PDOMNotImplementedError();
163	}
164
165	public boolean isEnclosed(ITypeInfo info) {
166	throw new PDOMNotImplementedError();
167	}
168
169	public boolean isEnclosed(ITypeSearchScope scope) {
170	throw new PDOMNotImplementedError();
171	}
172
173	public boolean isEnclosedType() {
174	throw new PDOMNotImplementedError();
175	}
176
177	public boolean isEnclosingType() {
178	throw new PDOMNotImplementedError();
179	}
180
181	public boolean isReferenced(ITypeSearchScope scope) {
182	throw new PDOMNotImplementedError();
183	}
184
185	public boolean isUndefinedType() {
186	throw new PDOMNotImplementedError();
187	}
188
189	public void setCElementType(int type) {
190	throw new PDOMNotImplementedError();
191	}
192
193	public int compareTo(Object arg0) {
194	throw new PDOMNotImplementedError();
195	}
196
197	}

Added Link Here

(-)browser/org/eclipse/cdt/internal/core/browser/util/IndexModelUtil.java (+109 lines)
1	/*******************************************************************************
2	* Copyright (c) 2006, 2007 QNX Software Systems and others.
3	* All rights reserved. This program and the accompanying materials
4	* are made available under the terms of the Eclipse Public License v1.0
5	* which accompanies this distribution, and is available at
6	* http://www.eclipse.org/legal/epl-v10.html
7	*
8	* Contributors:
9	* QNX - Initial API and implementation
10	* IBM Corporation
11	* Andrew Ferguson (Symbian)
12	*******************************************************************************/
13	package org.eclipse.cdt.internal.core.browser.util;
14
15	import org.eclipse.cdt.core.CCorePlugin;
16	import org.eclipse.cdt.core.dom.ast.DOMException;
17	import org.eclipse.cdt.core.dom.ast.IBinding;
18	import org.eclipse.cdt.core.dom.ast.ICompositeType;
19	import org.eclipse.cdt.core.dom.ast.IEnumeration;
20	import org.eclipse.cdt.core.dom.ast.ITypedef;
21	import org.eclipse.cdt.core.dom.ast.cpp.ICPPClassType;
22	import org.eclipse.cdt.core.dom.ast.cpp.ICPPNamespace;
23	import org.eclipse.cdt.core.dom.ast.cpp.ICPPNamespaceAlias;
24	import org.eclipse.cdt.core.model.ICElement;
25
26	/**
27	* Convenience class for bridging the model gap between binding types and CModel types
28	*
29	* This is internal in case some IBinding's do not have ICElement constants in future
30	*/
31	public class IndexModelUtil {
32	/**
33	* Returns whether the binding is of any of the specified CElement type constants
34	* @param binding
35	* @param kinds
36	* @return whether the binding is of any of the specified CElement type constants
37	*/
38	public static boolean bindingHasCElementType(IBinding binding, int[] kinds) {
39	try {
40	for(int i=0; i<kinds.length; i++) {
41	switch(kinds[i]) {
42	case ICElement.C_STRUCT:
43	if (binding instanceof ICompositeType
44	&& ((ICompositeType)binding).getKey() == ICompositeType.k_struct)
45	return true;
46	break;
47	case ICElement.C_UNION:
48	if (binding instanceof ICompositeType
49	&& ((ICompositeType)binding).getKey() == ICompositeType.k_union)
50	return true;
51	break;
52	case ICElement.C_CLASS:
53	if (binding instanceof ICompositeType
54	&& ((ICompositeType)binding).getKey() == ICPPClassType.k_class)
55	return true;
56	break;
57	case ICElement.C_NAMESPACE:
58	if (binding instanceof ICPPNamespace \|\| binding instanceof ICPPNamespaceAlias)
59	return true;
60	break;
61	case ICElement.C_ENUMERATION:
62	if (binding instanceof IEnumeration)
63	return true;
64	break;
65	case ICElement.C_TYPEDEF:
66	if(binding instanceof ITypedef)
67	return true;
68	break;
69	}
70	}
71	} catch(DOMException de) {
72	CCorePlugin.log(de);
73	}
74	return false;
75	}
76
77	/**
78	* Returns the CElement type constant for the specified binding
79	* @param binding
80	* @return the CElement type constant for the specified binding
81	*/
82	public static int getElementType(IBinding binding) {
83	int elementType = Integer.MIN_VALUE;
84
85	if (binding instanceof ICompositeType) {
86	ICompositeType classType = (ICompositeType) binding;
87	try {
88	if(classType.getKey() == ICPPClassType.k_class) {
89	elementType = ICElement.C_CLASS;
90	} else if(classType.getKey() == ICPPClassType.k_struct) {
91	elementType = ICElement.C_STRUCT;
92	} else if(classType.getKey() == ICPPClassType.k_union) {
93	elementType = ICElement.C_UNION;
94	}
95	} catch(DOMException de) {
96	CCorePlugin.log(de);
97	}
98	}
99
100	if (binding instanceof ICPPNamespace \|\| binding instanceof ICPPNamespaceAlias) {
101	elementType = ICElement.C_NAMESPACE;
102	}
103
104	if (binding instanceof IEnumeration) {
105	elementType = ICElement.C_ENUMERATION;
106	}
107	return elementType;
108	}
109	}