Example usage for org.eclipse.jdt.core IJavaElement PACKAGE_FRAGMENT_ROOT

List of usage examples for org.eclipse.jdt.core IJavaElement PACKAGE_FRAGMENT_ROOT

  1. HOME
  2. Java
  3. org.eclipse.jdt
  4. org.eclipse.jdt.core.*
  5. IJavaElement
  6. PACKAGE_FRAGMENT_ROOT

Introduction

In this page you can find the example usage for org.eclipse.jdt.core IJavaElement PACKAGE_FRAGMENT_ROOT.

Prototype

int PACKAGE_FRAGMENT_ROOT

To view the source code for org.eclipse.jdt.core IJavaElement PACKAGE_FRAGMENT_ROOT.

Click Source Link

Document

Constant representing a package fragment root.

Usage

From source file:org.jboss.tools.jst.jsp.jspeditor.info.JavaStringELInfoHover.java

License:Open Source License

/**
 * Adds full information to the hover//from  w ww  . ja  va  2s .c om
 * Returns base URL if exists
 * 
 * @param buffer
 * @param element
 * @return
 */
private static String addFullInfo(StringBuffer buffer, IJavaElement element, boolean useFullHTML) {
    String base = null;

    if (element instanceof IMember) {
        IMember member = (IMember) element;
        HTMLPrinter.addSmallHeader(buffer, getInfoText(member, true, useFullHTML));
        Reader reader;
        try {
            String content = JavadocContentAccess2.getHTMLContent(member, true);
            reader = content == null ? null : new StringReader(content);

            // Provide hint why there's no Javadoc
            if (reader == null && member.isBinary()) {
                boolean hasAttachedJavadoc = JavaDocLocations.getJavadocBaseLocation(member) != null;
                IPackageFragmentRoot root = (IPackageFragmentRoot) member
                        .getAncestor(IJavaElement.PACKAGE_FRAGMENT_ROOT);
                boolean hasAttachedSource = root != null && root.getSourceAttachmentPath() != null;
                IOpenable openable = member.getOpenable();
                boolean hasSource = openable.getBuffer() != null;

                if (!hasAttachedSource && !hasAttachedJavadoc)
                    reader = new StringReader(ELInfoHoverMessages.ELInfoHover_noAttachments);
                else if (!hasAttachedJavadoc && !hasSource)
                    reader = new StringReader(ELInfoHoverMessages.ELInfoHover_noAttachedJavadoc);
                else if (!hasAttachedSource)
                    reader = new StringReader(ELInfoHoverMessages.ELInfoHover_noAttachedJavaSource);
                else if (!hasSource)
                    reader = new StringReader(ELInfoHoverMessages.ELInfoHover_noInformation);

            } else {
                base = JavaDocLocations.getBaseURL(member);
            }

        } catch (JavaModelException ex) {
            reader = new StringReader(ELInfoHoverMessages.ELInfoHover_error_gettingJavadoc);
            JavaPlugin.log(ex);
        }

        if (reader != null) {
            HTMLPrinter.addParagraph(buffer, reader);
        }

    } else if (element.getElementType() == IJavaElement.LOCAL_VARIABLE
            || element.getElementType() == IJavaElement.TYPE_PARAMETER) {
        HTMLPrinter.addSmallHeader(buffer, getInfoText(element, true, useFullHTML));
    }
    return base;
}

From source file:org.jboss.tools.ws.creation.core.utils.JBossWSCreationUtils.java

License:Open Source License

public static ICompilationUnit findUnitByFileName(IJavaElement javaElem, String filePath) throws Exception {
    ICompilationUnit unit = null;/*from ww w. j  a  v  a2s . c om*/

    if (!javaElem.getOpenable().isOpen()) {
        javaElem.getOpenable().open(null);
    }

    IJavaElement[] elems = null;

    if (javaElem instanceof IParent) {
        IParent parent = (IParent) javaElem;
        elems = parent.getChildren();
    }

    if (elems == null) {
        return null;
    }

    for (IJavaElement elem : elems) {
        if (elem.getElementType() == IJavaElement.PACKAGE_FRAGMENT_ROOT) {
            IPackageFragmentRoot root = (IPackageFragmentRoot) elem;

            if (root.getKind() == IPackageFragmentRoot.K_SOURCE) {
                unit = findUnitByFileName(elem, filePath);

                if (unit != null) {
                    return unit;
                }
            }
        } else if ((elem.getElementType() == IJavaElement.PACKAGE_FRAGMENT)
                || (elem.getElementType() == IJavaElement.JAVA_PROJECT)) {
            unit = findUnitByFileName(elem, filePath);

            if (unit != null) {
                return unit;
            }
        } else if (elem.getElementType() == IJavaElement.COMPILATION_UNIT) {
            ICompilationUnit compUnit = (ICompilationUnit) elem;

            if (compUnit.getPath().toString().equals(filePath)) {
                compUnit.open(null);

                return compUnit;
            }
        }
    }

    return null;
}

From source file:org.jboss.tools.ws.jaxrs.core.internal.metamodel.builder.JavaElementDeltaFilter.java

License:Open Source License

/**
 * /*from w w  w. j  a  v  a 2s  .  co m*/
 * @param element
 * @return true if the given java element is a Jar archive.
 */
private boolean isJarArchive(IJavaElement element) {
    return (element.getElementType() == IJavaElement.PACKAGE_FRAGMENT_ROOT
            && ((IPackageFragmentRoot) element).isArchive());

}

From source file:org.jboss.tools.ws.jaxrs.core.internal.metamodel.builder.JavaElementDeltaScanner.java

License:Open Source License

/**
 * Recursively analyse the given Java Element Delta.
 * /*  www  .  j  av a2s. c  o m*/
 * @param delta
 * @param eventType
 * @throws CoreException
 * @see https://bugs.eclipse.org/bugs/show_bug.cgi?id=100267
 */
private List<JavaElementChangedEvent> scanDelta(final IJavaElementDelta delta, final int eventType)
        throws CoreException {
    final List<JavaElementChangedEvent> events = new ArrayList<JavaElementChangedEvent>();
    final IJavaElement element = delta.getElement();
    // skip as the project is closed
    if (element == null) {
        Logger.debug("** skipping this build because the delta element is null **");
        return Collections.emptyList();
    } else if (element.getElementType() == IJavaElement.JAVA_PROJECT
            && !element.getJavaProject().getProject().isOpen() && delta.getFlags() != F_OPENED) {
        Logger.debug("** skipping this build because the java project is closed. **");
        return Collections.emptyList();
    } else if ((element.getElementType() == IJavaElement.PACKAGE_FRAGMENT_ROOT)) {
        final IPackageFragmentRoot packageFragmentRoot = (IPackageFragmentRoot) element;
        if (!packageFragmentRoot.isExternal()
                && (packageFragmentRoot.getResource() == null || !packageFragmentRoot.getResource().exists())) {
            return Collections.emptyList();
        }
    } else if (element.getResource() == null || !element.getResource().exists()) {
        return Collections.emptyList();
    }
    final int elementKind = element.getElementType();
    final int deltaKind = retrieveDeltaKind(delta);
    final Flags flags = new Flags(delta.getFlags());
    if (elementKind == JAVA_PROJECT) {
        final JavaElementChangedEvent event = new JavaElementChangedEvent(element, delta.getKind(), eventType,
                null, new Flags(delta.getFlags()));
        if (javaElementChangedEventFilter.apply(event)) {
            events.add(event);
            // skip anything below
            return events;
        }
    }
    final CompilationUnit compilationUnitAST = getCompilationUnitAST(delta);
    if (elementKind == COMPILATION_UNIT) {
        final ICompilationUnit compilationUnit = (ICompilationUnit) element;
        // compilationUnitAST is null when the given compilation unit'w
        // working copy is being commited (ie, Java Editor is being closed
        // for the given compilation unit, etc.)
        if (compilationUnit.exists() // see https://issues.jboss.org/browse/JBIDE-12760: compilationUnit may not exist
                && compilationUnit.isWorkingCopy() && compilationUnitAST != null) {
            // assuming possible changes in the method signatures (return type,
            // param types and param annotations). Other changes in methods
            // (renaming, adding/removing params) result in add+remove
            // events on the given method itself.
            if (requiresDiffsComputation(flags)) {
                for (IType type : compilationUnit.getAllTypes()) {
                    for (IMethod javaMethod : type.getMethods()) {
                        final JavaElementChangedEvent event = new JavaElementChangedEvent(javaMethod, CHANGED,
                                eventType, compilationUnitAST, new Flags(F_SIGNATURE));
                        if (javaElementChangedEventFilter.apply(event)) {
                            events.add(event);
                        }
                    }
                }
            }
        }
    }
    // element is part of the compilation unit
    else if (compilationUnitAST != null) {
        final JavaElementChangedEvent event = new JavaElementChangedEvent(element, deltaKind, eventType,
                compilationUnitAST, flags);
        if (javaElementChangedEventFilter.apply(event)) {
            events.add(event);
        }
    }
    // continue with children elements, both on annotations and other java
    // elements.
    for (IJavaElementDelta affectedChild : delta.getAffectedChildren()) {
        events.addAll(scanDelta(affectedChild, eventType));
    }
    for (IJavaElementDelta annotation : delta.getAnnotationDeltas()) {
        events.addAll(scanDelta(annotation, eventType));
    }
    return events;
}

From source file:org.jboss.tools.ws.jaxrs.core.internal.metamodel.builder.ResourceChangedProcessor.java

License:Open Source License

public List<JaxrsElementDelta> processEvent(ResourceDelta event, IProgressMonitor progressMonitor)
        throws CoreException {
    Logger.debug("Processing {}", event);
    final List<JaxrsElementDelta> results = new ArrayList<JaxrsElementDelta>();
    final IResource resource = event.getResource();
    if (resource == null) {
        return results;
    }/*from   w w w  .j a  v  a 2  s . c om*/
    final IJavaElement javaElement = JavaCore.create(resource);
    final JaxrsMetamodel metamodel = JaxrsMetamodelLocator.get(resource.getProject());
    final int deltaKind = event.getDeltaKind();
    if (javaElement != null &&
    // ignore changes on binary files (added/removed/changed jars to improve builder performances)
            !(javaElement.getElementType() == IJavaElement.PACKAGE_FRAGMENT_ROOT
                    && ((IPackageFragmentRoot) javaElement).isArchive())) {
        switch (deltaKind) {
        case ADDED:
        case CHANGED:
            results.addAll(
                    processApplicationChangesOnScopeAdditionOrChange(javaElement, metamodel, progressMonitor));
            results.addAll(
                    processHttpMethodChangesOnScopeAdditionOrChange(javaElement, metamodel, progressMonitor));
            results.addAll(processResourceChangesOnScopeAdditionOrChange(javaElement, metamodel, deltaKind,
                    progressMonitor));
            break;
        case REMOVED:
            results.addAll(processApplicationChangesOnScopeRemoval(javaElement, metamodel, progressMonitor));
            results.addAll(processHttpMethodChangesOnScopeRemoval(javaElement, metamodel, progressMonitor));
            results.addAll(processResourceChangesOnScopeRemoval(javaElement, metamodel, progressMonitor));
            break;
        }
    } else if (WtpUtils.isWebDeploymentDescriptor(resource)) {
        switch (deltaKind) {
        case ADDED:
        case CHANGED:
            results.addAll(
                    processApplicationChangesOnWebxmlAdditionOrChange(resource, metamodel, progressMonitor));
            break;
        case REMOVED:
            results.addAll(processApplicationChangesOnWebxmlRemoval(resource, metamodel, progressMonitor));
            break;
        }
    }
    for (JaxrsElementDelta delta : results) {
        Logger.debug("Resulting event: {}", delta);
    }
    return results;
}

From source file:org.jboss.tools.ws.jaxrs.core.internal.metamodel.domain.JaxrsElementFactory.java

License:Open Source License

private static Set<IJaxrsElement> internalCreateElements(final IJavaElement scope, final CompilationUnit ast,
        final JaxrsMetamodel metamodel, final IProgressMonitor progressMonitor) throws CoreException {
    if (scope.getElementType() == IJavaElement.PACKAGE_FRAGMENT_ROOT
            && ((IPackageFragmentRoot) scope).isArchive()) {
        Logger.debug("Ignoring archive {}", scope.getElementName());
        return Collections.emptySet();
    }/*  w w w .  j  a v  a 2s. c om*/
    final Set<IJaxrsElement> elements = new HashSet<IJaxrsElement>();
    // let's see if the given scope contains JAX-RS Application
    final Set<IType> matchingApplicationTypes = JavaElementsSearcher.findApplicationTypes(scope,
            progressMonitor);
    for (IType type : matchingApplicationTypes) {
        final JaxrsJavaApplication application = JaxrsJavaApplication.from(type).withMetamodel(metamodel)
                .build();
        if (application != null) {
            elements.add(application);
        }
    }
    // let's see if the given scope contains JAX-RS HTTP Methods
    final Set<IType> matchingHttpMethodTypes = JavaElementsSearcher.findHttpMethodTypes(scope, progressMonitor);
    for (IType type : matchingHttpMethodTypes) {
        final JaxrsHttpMethod httpMethod = JaxrsHttpMethod.from(type).withMetamodel(metamodel).build();
        if (httpMethod != null) {
            elements.add(httpMethod);
        }
    }
    // let's see if the given scope contains JAX-RS Name Bindings
    final Set<IType> matchingNameBindingsTypes = JavaElementsSearcher.findNameBindingTypes(scope,
            progressMonitor);
    for (IType type : matchingNameBindingsTypes) {
        final JaxrsNameBinding nameBinding = JaxrsNameBinding.from(type).withMetamodel(metamodel).build();
        if (nameBinding != null) {
            elements.add(nameBinding);
        }
    }
    // let's see if the given scope contains JAX-RS Resources
    final Set<IType> matchingResourceTypes = JavaElementsSearcher.findResourceTypes(scope, progressMonitor);
    for (IType type : matchingResourceTypes) {
        final JaxrsResource resource = JaxrsResource.from(type, metamodel.findAllHttpMethodNames())
                .withMetamodel(metamodel).build();
        if (resource != null) {
            elements.add(resource);
            elements.addAll(resource.getAllMethods());
            elements.addAll(resource.getAllFields());
        }
    }
    // now,let's see if the given type can be a ParamConverterProvider
    final Set<IType> matchingParamConverterProviderTypes = JavaElementsSearcher
            .findParamConverterProviderTypes(scope, progressMonitor);
    for (IType type : matchingParamConverterProviderTypes) {
        final JaxrsParamConverterProvider paramConverterProvider = JaxrsParamConverterProvider.from(type)
                .withMetamodel(metamodel).build();
        if (paramConverterProvider != null) {
            elements.add(paramConverterProvider);
        }
    }
    // now,let's see if the given type can be a Parameter Aggregator
    final Set<IType> matchingParameterAggregatorTypes = JavaElementsSearcher.findParameterAggregatorTypes(scope,
            progressMonitor);
    for (IType type : matchingParameterAggregatorTypes) {
        final JaxrsParameterAggregator parameterAggregator = JaxrsParameterAggregator.from(type)
                .buildInMetamodel(metamodel);
        if (parameterAggregator != null) {
            elements.add(parameterAggregator);
            elements.addAll(parameterAggregator.getAllProperties());
            elements.addAll(parameterAggregator.getAllFields());
        }
    }
    // let's see if the given scope contains JAX-RS Providers
    final Set<IType> matchingProviderTypes = JavaElementsSearcher.findProviderTypes(scope, progressMonitor);
    for (IType type : matchingProviderTypes) {
        final JaxrsProvider provider = JaxrsProvider.from(type).withMetamodel(metamodel).build();
        if (provider != null) {
            elements.add(provider);
        }
    }
    return elements;
}

From source file:org.jboss.tools.ws.jaxrs.core.internal.metamodel.domain.JaxrsMetamodel.java

License:Open Source License

/**
 * Process a single Java Element change//from w ww  .j a v a  2s. c om
 * 
 * @param delta
 * @param progressMonitor
 * @throws CoreException
 */
public void processJavaElementChange(final JavaElementChangedEvent delta,
        final IProgressMonitor progressMonitor) throws CoreException {
    try {
        Logger.debug("Processing {}", delta);
        readWriteLock.writeLock().lock();
        final IJavaElement element = delta.getElement();
        final CompilationUnit ast = delta.getCompilationUnitAST();
        final int deltaKind = delta.getKind();
        switch (element.getElementType()) {
        case IJavaElement.JAVA_PROJECT:
        case IJavaElement.PACKAGE_FRAGMENT_ROOT:
            processProject(progressMonitor);
            break;
        case IJavaElement.ANNOTATION:
            processJavaAnnotationChange((IAnnotation) element, deltaKind, ast, progressMonitor);
            break;
        case IJavaElement.COMPILATION_UNIT:
        case IJavaElement.TYPE:
        case IJavaElement.METHOD:
        case IJavaElement.FIELD:
            processJavaElementChange(element, deltaKind, ast, progressMonitor);
            break;
        default:
            // ignore
            break;
        }
    } finally {
        this.initializing = false;
        progressMonitor.done();
        readWriteLock.writeLock().unlock();
        setBuildStatus(Status.OK_STATUS);
        Logger.debug("Done processing Java changes: " + getStatus());
    }
}

From source file:org.jboss.tools.ws.jaxrs.core.internal.metamodel.domain.JaxrsMetamodel.java

License:Open Source License

/**
 * Search for the JAX-RS java-based elements matching the given
 * {@link IJavaElement} in the metamodel.
 * /*from   ww  w .  ja  va  2  s  .c o  m*/
 * @param element
 * @param ast
 * @return the matching JAX-RS Elements or an empty set if no JAX-RS
 *         element matched in the metamodel.
 * @throws JavaModelException
 */
private List<IJaxrsElement> searchJaxrsElements(final IJavaElement element) throws JavaModelException {
    if (element == null) {
        return Collections.emptyList();
    }
    try {
        readWriteLock.readLock().lock();
        final List<IJaxrsElement> result = new ArrayList<IJaxrsElement>();
        final Term javaElementTerm = new Term(FIELD_JAVA_ELEMENT, Boolean.TRUE.toString());
        switch (element.getElementType()) {
        case IJavaElement.JAVA_PROJECT:
            final Term javaProjectIdentifier = new Term(FIELD_JAVA_PROJECT_IDENTIFIER,
                    element.getHandleIdentifier());
            result.addAll(searchJaxrsElements(javaElementTerm, javaProjectIdentifier));
            break;
        case IJavaElement.PACKAGE_FRAGMENT_ROOT:
            final Term packageFragmentRootIdentifier = new Term(FIELD_PACKAGE_FRAGMENT_ROOT_IDENTIFIER,
                    element.getHandleIdentifier());
            result.addAll(searchJaxrsElements(javaElementTerm, packageFragmentRootIdentifier));
            break;
        case IJavaElement.COMPILATION_UNIT:
            final Term compilationUnitTerm = new Term(FIELD_COMPILATION_UNIT_IDENTIFIER,
                    element.getHandleIdentifier());
            result.addAll(searchJaxrsElements(javaElementTerm, compilationUnitTerm));
            break;
        case IJavaElement.TYPE:
        case IJavaElement.FIELD:
        case IJavaElement.METHOD:
            final IJaxrsElement foundElement = this.elements.get(element.getHandleIdentifier());
            if (foundElement != null) {
                result.add(foundElement);
            }
            break;
        }
        return result;
    } finally {
        readWriteLock.readLock().unlock();
    }

}

From source file:org.jboss.tools.ws.jaxrs.core.internal.metamodel.domain.JaxrsMetamodel.java

License:Open Source License

/**
 * Searches and returns all JAX-RS Java-based Elements matching the given
 * {@link IJavaElement}, which can be {@link Annotation} {@link IProject},
 * {@link IPackageFragmentRoot}, {@link ICompilationUnit} or an
 * {@link IMember}//  w  w w. jav  a 2s.  c om
 * 
 * @param javaElement
 *            the java element
 * 
 * @return the JAX-RS Elements matching the given Java Element or empty list
 *         if none matches.
 */
public <T extends IJaxrsElement> Set<T> findElements(final IJavaElement javaElement) {
    if (javaElement == null) {
        return Collections.emptySet();
    }
    try {
        readWriteLock.readLock().lock();
        final String identifier = javaElement.getHandleIdentifier();
        switch (javaElement.getElementType()) {
        case IJavaElement.JAVA_PROJECT:
            return searchJaxrsElements(new Term(FIELD_JAVA_PROJECT_IDENTIFIER, identifier));
        case IJavaElement.PACKAGE_FRAGMENT_ROOT:
            return searchJaxrsElements(new Term(FIELD_PACKAGE_FRAGMENT_ROOT_IDENTIFIER, identifier));
        case IJavaElement.COMPILATION_UNIT:
            return searchJaxrsElements(new Term(FIELD_COMPILATION_UNIT_IDENTIFIER, identifier));
        default:
            return searchJaxrsElements(LuceneDocumentFactory.getIdentifierTerm(javaElement));
        }
    } finally {
        readWriteLock.readLock().unlock();
    }
}

From source file:org.jboss.tools.ws.jaxrs.core.internal.metamodel.indexation.LuceneDocumentFactory.java

License:Open Source License

/**
 * Initialize a base Lucene Document for the given JAX-RS element.
 * /*from   ww  w . jav  a2  s  .c om*/
 * @param element
 * @return a base document, to be completed with specific fields within the
 *         calling method.
 */
private static Document createBaseDocument(JaxrsJavaElement<?> element) {
    final Document document = new Document();
    addFieldToDocument(document, FIELD_JAVA_PROJECT_IDENTIFIER,
            getHandleIdentifier(element.getMetamodel().getJavaProject()));
    addFieldToDocument(document, FIELD_CATEGORY, element.getElementKind().getCategory().toString());
    addFieldToDocument(document, FIELD_IDENTIFIER, element.getIdentifier());
    if (element.getJavaElement() != null) {
        addFieldToDocument(document, FIELD_JAVA_ELEMENT, Boolean.TRUE.toString());
        addFieldToDocument(document, FIELD_COMPILATION_UNIT_IDENTIFIER,
                getHandleIdentifier(element.getJavaElement().getAncestor(IJavaElement.COMPILATION_UNIT)));
        addFieldToDocument(document, FIELD_PACKAGE_FRAGMENT_ROOT_IDENTIFIER,
                getHandleIdentifier(element.getJavaElement().getAncestor(IJavaElement.PACKAGE_FRAGMENT_ROOT)));

        if (element.getJavaElement().getElementType() == IJavaElement.TYPE) {
            addFieldToDocument(document, FIELD_JAVA_CLASS_NAME,
                    ((IType) element.getJavaElement()).getFullyQualifiedName());
        }
    }
    for (Entry<String, Annotation> entry : element.getAnnotations().entrySet()) {
        addFieldToDocument(document, FIELD_ANNOTATION_NAME, entry.getValue().getFullyQualifiedName());
        addFieldToDocument(document, FIELD_PARENT_IDENTIFIER,
                getHandleIdentifier(entry.getValue().getJavaParent()));
    }
    if (element.getResource() != null) {
        addFieldToDocument(document, FIELD_RESOURCE_PATH,
                element.getResource().getFullPath().toPortableString());
    }
    return document;
}