Java tutorial
/*- * Copyright (C) 2011-2014 by Iwao AVE! * This program is made available under the terms of the MIT License. */ package org.eclipselabs.stlipse.cache; import static org.eclipselabs.stlipse.util.StripesClasses.*; import java.util.ArrayList; import java.util.Collections; import java.util.Iterator; import java.util.LinkedHashMap; import java.util.List; import java.util.Map; import java.util.Map.Entry; import java.util.concurrent.ConcurrentHashMap; import org.eclipse.core.resources.IProject; import org.eclipse.core.runtime.Status; import org.eclipse.jdt.core.Flags; import org.eclipse.jdt.core.IAnnotation; import org.eclipse.jdt.core.ICompilationUnit; import org.eclipse.jdt.core.IField; import org.eclipse.jdt.core.IJavaElement; import org.eclipse.jdt.core.IJavaProject; import org.eclipse.jdt.core.IMethod; import org.eclipse.jdt.core.IType; import org.eclipse.jdt.core.JavaModelException; import org.eclipse.jdt.core.Signature; import org.eclipse.jdt.core.dom.AST; import org.eclipse.jdt.core.dom.ASTParser; import org.eclipse.jdt.core.dom.CompilationUnit; import org.eclipse.jface.text.contentassist.ICompletionProposal; import org.eclipselabs.stlipse.Activator; import org.eclipselabs.stlipse.javaeditor.JavaCompletionProposal; /** * @author Iwao AVE! */ public class BeanPropertyCache { private static final Map<IProject, Map<String, BeanPropertyInfo>> projectCache = new ConcurrentHashMap<IProject, Map<String, BeanPropertyInfo>>(); public static void clearBeanPropertyCache() { projectCache.clear(); } public static void clearBeanPropertyCache(IProject project) { projectCache.remove(project); } public static void clearBeanPropertyCache(IProject project, String qualifiedName) { Map<String, BeanPropertyInfo> beans = projectCache.get(project); if (beans != null) { String topLevelClass = removeExtension(qualifiedName); beans.remove(topLevelClass); // Clear cache for inner classes. String innerClassPrefix = topLevelClass + "."; for (Iterator<Entry<String, BeanPropertyInfo>> it = beans.entrySet().iterator(); it.hasNext();) { Entry<String, BeanPropertyInfo> entry = it.next(); if (entry.getKey().startsWith(innerClassPrefix)) { it.remove(); } } } } public static BeanPropertyInfo getBeanPropertyInfo(IJavaProject project, String fqn) { String qualifiedName = removeExtension(fqn); Map<String, BeanPropertyInfo> beans = projectCache.get(project.getProject()); BeanPropertyInfo beanProps = null; if (beans == null) { beans = new ConcurrentHashMap<String, BeanPropertyInfo>(); projectCache.put(project.getProject(), beans); } beanProps = beans.get(qualifiedName); if (beanProps == null) { final Map<String, String> readableFields = new LinkedHashMap<String, String>(); final Map<String, String> writableFields = new LinkedHashMap<String, String>(); final Map<String, EventProperty> eventHandlers = new LinkedHashMap<String, EventProperty>(); parseBean(project, qualifiedName, readableFields, writableFields, eventHandlers); beanProps = new BeanPropertyInfo(readableFields, writableFields, eventHandlers); } beans.put(qualifiedName, beanProps); return beanProps; } protected static void parseBean(IJavaProject project, String qualifiedName, final Map<String, String> readableFields, final Map<String, String> writableFields, final Map<String, EventProperty> eventHandlers) { try { final IType type = project.findType(qualifiedName); if (type != null) { if (type.isBinary()) { parseBinary(project, type, readableFields, writableFields, eventHandlers); } else { parseSource(project, type, qualifiedName, readableFields, writableFields, eventHandlers); } } } catch (JavaModelException e) { Activator.log(Status.ERROR, "Failed to find type " + qualifiedName, e); } } protected static void parseBinary(IJavaProject project, final IType type, final Map<String, String> readableFields, final Map<String, String> writableFields, final Map<String, EventProperty> eventHandlers) throws JavaModelException { parseBinaryFields(type, readableFields, writableFields); parseBinaryMethods(type, readableFields, writableFields, eventHandlers); String superclass = Signature.toString(type.getSuperclassTypeSignature()); if (!Object.class.getName().equals(superclass)) { parseBean(project, superclass, readableFields, writableFields, eventHandlers); } } protected static void parseBinaryMethods(final IType type, final Map<String, String> readableFields, final Map<String, String> writableFields, final Map<String, EventProperty> eventHandlers) throws JavaModelException { for (IMethod method : type.getMethods()) { int flags = method.getFlags(); if (Flags.isPublic(flags)) { final String methodName = method.getElementName(); final int parameterCount = method.getParameters().length; final String returnType = method.getReturnType(); if (Signature.C_VOID == returnType.charAt(0)) { if (BeanPropertyVisitor.isSetter(methodName, parameterCount)) { String fieldName = BeanPropertyVisitor.getFieldNameFromAccessor(methodName); String paramType = method.getParameterTypes()[0]; writableFields.put(fieldName, Signature.toString(paramType)); } } else { if (BeanPropertyVisitor.isGetter(methodName, parameterCount)) { String fieldName = BeanPropertyVisitor.getFieldNameFromAccessor(methodName); readableFields.put(fieldName, Signature.toString(returnType)); } else if (RESOLUTION.equals(Signature.toString(returnType)) && parameterCount == 0) { parseBinaryEventHandler(method, eventHandlers); } } } } } protected static void parseBinaryEventHandler(IMethod method, final Map<String, EventProperty> eventHandlers) throws JavaModelException { boolean isInterceptor = false; boolean isDefaultHandler = false; String annotationValue = null; for (IAnnotation annotation : method.getAnnotations()) { String annotationType = annotation.getElementName(); if (BEFORE.equals(annotationType) || AFTER.equals(annotationType)) { isInterceptor = true; break; } isDefaultHandler |= DEFAULT_HANDLER.equals(annotationType); if (HANDLES_EVENT.equals(annotationType)) { annotationValue = (String) annotation.getMemberValuePairs()[0].getValue(); } } if (!isInterceptor) { String methodName = method.getElementName(); EventProperty eventProperty = new EventProperty(); eventProperty.setDefaultHandler(isDefaultHandler); eventProperty.setMethodName(methodName); eventHandlers.put(annotationValue == null ? methodName : annotationValue, eventProperty); } } protected static void parseBinaryFields(final IType type, final Map<String, String> readableFields, final Map<String, String> writableFields) throws JavaModelException { for (IField field : type.getFields()) { int flags = field.getFlags(); if (Flags.isPublic(flags)) { String fieldName = field.getElementName(); String qualifiedType = Signature.toString(field.getTypeSignature()); readableFields.put(fieldName, qualifiedType); if (!Flags.isFinal(flags)) { writableFields.put(fieldName, qualifiedType); } } } } protected static void parseSource(IJavaProject project, final IType type, final String qualifiedName, final Map<String, String> readableFields, final Map<String, String> writableFields, final Map<String, EventProperty> eventHandlers) throws JavaModelException { ICompilationUnit compilationUnit = (ICompilationUnit) type.getAncestor(IJavaElement.COMPILATION_UNIT); ASTParser parser = ASTParser.newParser(AST.JLS4); parser.setKind(ASTParser.K_COMPILATION_UNIT); parser.setSource(compilationUnit); parser.setResolveBindings(true); // parser.setIgnoreMethodBodies(true); CompilationUnit astUnit = (CompilationUnit) parser.createAST(null); astUnit.accept( new BeanPropertyVisitor(project, qualifiedName, readableFields, writableFields, eventHandlers)); } public static List<String> searchEventHandler(IJavaProject project, String qualifiedName, String matchStr, boolean isValidation, boolean alwaysIncludeDefault) { final List<String> results = new ArrayList<String>(); final BeanPropertyInfo beanProperty = getBeanPropertyInfo(project, qualifiedName); if (beanProperty != null) { for (Entry<String, EventProperty> eventHandler : beanProperty.getEventHandlers().entrySet()) { String handlerName = eventHandler.getKey(); EventProperty eventProperty = eventHandler.getValue(); if ((alwaysIncludeDefault && eventProperty.isDefaultHandler()) || (isValidation && handlerName.equals(matchStr)) || handlerName.startsWith(matchStr)) { results.add(handlerName); } } } return results; } public static Map<String, EventProperty> getEventHandlers(IJavaProject project, String qualifiedName) { final BeanPropertyInfo beanProperty = getBeanPropertyInfo(project, qualifiedName); return beanProperty == null ? Collections.<String, EventProperty>emptyMap() : beanProperty.getEventHandlers(); } public static Map<String, String> searchFields(IJavaProject project, String qualifiedName, String matchStr, boolean includeReadOnly, int currentIdx, boolean isValidation) { final Map<String, String> results = new LinkedHashMap<String, String>(); String searchStr; final int startIdx = currentIdx + 1; final int dotIdx = getDotIndex(matchStr, startIdx); if (dotIdx == -1) searchStr = matchStr.substring(startIdx); else searchStr = matchStr.substring(startIdx, dotIdx); final int bracePos = searchStr.indexOf("["); searchStr = bracePos > -1 ? searchStr.substring(0, bracePos) : searchStr; final boolean isPrefixMatch = !isValidation && dotIdx == -1; final BeanPropertyInfo beanProperty = getBeanPropertyInfo(project, qualifiedName); if (beanProperty != null) { final Map<String, String> fields = includeReadOnly ? beanProperty.getReadableFields() : beanProperty.getWritableFields(); for (Entry<String, String> entry : fields.entrySet()) { final String fieldName = entry.getKey(); final String fieldQualifiedName = entry.getValue(); if (matched(fieldName, searchStr, isPrefixMatch)) { if (dotIdx > -1) { return searchFields(project, fieldQualifiedName, matchStr, includeReadOnly, dotIdx, isValidation); } else { results.put(fieldName, fieldQualifiedName); } } } } return results; } public static List<ICompletionProposal> buildFieldNameProposal(Map<String, String> fields, final String input, final int offset, final int replacementLength) { List<ICompletionProposal> proposalList = new ArrayList<ICompletionProposal>(); int lastDot = input.lastIndexOf("."); String prefix = lastDot > -1 ? input.substring(0, lastDot) : ""; int relevance = fields.size(); for (Entry<String, String> fieldEntry : fields.entrySet()) { String fieldName = fieldEntry.getKey(); String qualifiedName = fieldEntry.getValue(); StringBuilder replaceStr = new StringBuilder(); if (lastDot > -1) replaceStr.append(prefix).append('.'); replaceStr.append(fieldName); StringBuilder displayStr = new StringBuilder(); displayStr.append(fieldName).append(" - ").append(qualifiedName); ICompletionProposal proposal = new JavaCompletionProposal(replaceStr.toString(), offset, replacementLength, replaceStr.length(), Activator.getIcon(), displayStr.toString(), null, null, relevance--); proposalList.add(proposal); } return proposalList; } private static String removeExtension(String src) { if (src != null && src.endsWith(".java")) return src.substring(0, src.length() - 5); else return src; } private static int getDotIndex(String str, int startIdx) { boolean isIndexedProperty = false; for (int i = startIdx; i < str.length(); i++) { char c = str.charAt(i); if (!isIndexedProperty && c == '.') return i; else if (!isIndexedProperty && c == '[') isIndexedProperty = true; else if (c == ']') isIndexedProperty = false; } return -1; } private static boolean matched(String fieldName, String searchStr, boolean prefixMatch) { return (searchStr == null || searchStr.length() == 0) || (prefixMatch ? fieldName.toLowerCase().startsWith(searchStr.toLowerCase()) : fieldName.equals(searchStr)); } }