Example usage for org.eclipse.jdt.core IJavaModelStatusConstants ELEMENT_DOES_NOT_EXIST

List of usage examples for org.eclipse.jdt.core IJavaModelStatusConstants ELEMENT_DOES_NOT_EXIST

Introduction

In this page you can find the example usage for org.eclipse.jdt.core IJavaModelStatusConstants ELEMENT_DOES_NOT_EXIST.

Prototype

int ELEMENT_DOES_NOT_EXIST

To view the source code for org.eclipse.jdt.core IJavaModelStatusConstants ELEMENT_DOES_NOT_EXIST.

Click Source Link

Document

Status constant indicating that one or more elements supplied do not exist.

Usage

From source file:com.centurylink.mdw.plugin.codegen.Generator.java

License:Apache License

/**
 * Sets the MDWCommon.jar file as CLASSPATH variable in Eclipse. Needed so
 * that the JET Emitter framework can find MDWCommon at runtime.
 *//*from   ww w .  ja v  a2 s .  c  om*/
protected void setMdwCommonClasspathVariable() throws JavaModelException {
    URL url = null;
    try {
        url = PluginUtil.getLocalResourceUrl("base/APP-INF/lib/MDWCommon.jar");
    } catch (IOException e) {
        int code = IJavaModelStatusConstants.ELEMENT_DOES_NOT_EXIST;
        JavaModelException jme = new JavaModelException(e, code);
        throw jme;
    }
    IPath path = new Path(url.getFile());
    if (!path.equals(JavaCore.getClasspathVariable("MDW_COMMON"))) {
        JavaCore.setClasspathVariable("MDW_COMMON", path, null);
    }
}

From source file:com.codenvy.ide.ext.java.server.internal.core.ClassFile.java

License:Open Source License

public byte[] getBytes() throws JavaModelException {
    JavaElement pkg = (JavaElement) getParent();
    if (pkg instanceof JarPackageFragment) {
        JarPackageFragmentRoot root = (JarPackageFragmentRoot) pkg.getParent();
        ZipFile zip = null;/* w  w  w  .j  ava  2 s . co m*/
        try {
            zip = root.getJar();
            String entryName = Util.concatWith(((PackageFragment) pkg).names, getElementName(), '/');
            ZipEntry ze = zip.getEntry(entryName);
            if (ze != null) {
                return org.eclipse.jdt.internal.compiler.util.Util.getZipEntryByteContent(ze, zip);
            }
            throw new JavaModelException(
                    new JavaModelStatus(IJavaModelStatusConstants.ELEMENT_DOES_NOT_EXIST, this));
        } catch (IOException ioe) {
            throw new JavaModelException(ioe, IJavaModelStatusConstants.IO_EXCEPTION);
        } catch (CoreException e) {
            if (e instanceof JavaModelException) {
                throw (JavaModelException) e;
            } else {
                throw new JavaModelException(e);
            }
        } finally {
            manager.closeZipFile(zip);
        }
    } else {
        IFile file = (IFile) resource();
        return Util.getResourceContentsAsByteArray(file);
    }
}

From source file:com.codenvy.ide.ext.java.server.internal.core.CompilationUnit.java

License:Open Source License

protected IStatus validateCompilationUnit(File resource) {
    IPackageFragmentRoot root = getPackageFragmentRoot();
    // root never null as validation is not done for working copies
    try {/*from w w  w. ja v  a 2 s .co m*/
        if (root.getKind() != IPackageFragmentRoot.K_SOURCE)
            return new JavaModelStatus(IJavaModelStatusConstants.INVALID_ELEMENT_TYPES, root);
    } catch (JavaModelException e) {
        return e.getJavaModelStatus();
    }
    if (resource != null) {
        char[][] inclusionPatterns = ((PackageFragmentRoot) root).fullInclusionPatternChars();
        char[][] exclusionPatterns = ((PackageFragmentRoot) root).fullExclusionPatternChars();
        if (Util.isExcluded(new Path(resource.getPath()), inclusionPatterns, exclusionPatterns, false))
            return new JavaModelStatus(IJavaModelStatusConstants.ELEMENT_NOT_ON_CLASSPATH, this);
        if (!resource.exists())
            return new JavaModelStatus(IJavaModelStatusConstants.ELEMENT_DOES_NOT_EXIST, this);
    }
    IJavaProject project = getJavaProject();
    return JavaConventions.validateCompilationUnitName(getElementName(),
            project.getOption(JavaCore.COMPILER_SOURCE, true),
            project.getOption(JavaCore.COMPILER_COMPLIANCE, true));
}

From source file:com.codenvy.ide.ext.java.server.internal.core.JavaElement.java

License:Open Source License

protected IJavaModelStatus newDoesNotExistStatus() {
    return new com.codenvy.ide.ext.java.server.internal.core.JavaModelStatus(
            IJavaModelStatusConstants.ELEMENT_DOES_NOT_EXIST, this);
}

From source file:com.codenvy.ide.ext.java.server.internal.core.util.ResourceCompilationUnit.java

License:Open Source License

public char[] getContents() {
    if (this.contents != null)
        return this.contents; // answer the cached source

    // otherwise retrieve it
    try {//from   w w  w  .jav  a 2s  . c o  m
        // Get resource contents
        InputStream stream = null;
        try {
            stream = new FileInputStream(file);
        } catch (FileNotFoundException e) {
            throw new JavaModelException(e, IJavaModelStatusConstants.ELEMENT_DOES_NOT_EXIST);
        }
        try {
            return org.eclipse.jdt.internal.compiler.util.Util.getInputStreamAsCharArray(stream,
                    (int) file.length(), "UTF-8");
        } catch (IOException e) {
            throw new JavaModelException(e, IJavaModelStatusConstants.IO_EXCEPTION);
        } finally {
            try {
                stream.close();
            } catch (IOException e) {
                // ignore
            }
        }
    } catch (CoreException e) {
        return CharOperation.NO_CHAR;
    }
}

From source file:com.codenvy.ide.ext.java.server.internal.core.util.Util.java

License:Open Source License

public static char[] getResourceContentsAsCharArray(File file, String encoding) throws JavaModelException {
    // Get file length
    // workaround https://bugs.eclipse.org/bugs/show_bug.cgi?id=130736 by using java.io.File if possible
    //        IPath location = file.getLocation();
    long length;/*from w  w w  .j  a v a2s  . co m*/
    //        if (location == null) {
    //            // non local file
    //            try {
    //                URI locationURI = file.getLocationURI();
    //                if (locationURI == null)
    //                    throw new CoreException(new Status(IStatus.ERROR, JavaCore.PLUGIN_ID, Messages
    //                            .bind(Messages.file_notFound, file.getFullPath().toString())));
    //                length = EFS.getStore(locationURI).fetchInfo().getLength();
    //            } catch (CoreException e) {
    //                throw new JavaModelException(e, IJavaModelStatusConstants.ELEMENT_DOES_NOT_EXIST);
    //            }
    //        } else {
    //            // local file
    length = file.length();
    //        }

    // Get resource contents
    InputStream stream = null;
    try {
        stream = new FileInputStream(file);
    } catch (FileNotFoundException e) {
        throw new JavaModelException(e, IJavaModelStatusConstants.ELEMENT_DOES_NOT_EXIST);
    }
    try {
        return org.eclipse.jdt.internal.compiler.util.Util.getInputStreamAsCharArray(stream, (int) length,
                encoding);
    } catch (IOException e) {
        throw new JavaModelException(e, IJavaModelStatusConstants.IO_EXCEPTION);
    } finally {
        try {
            stream.close();
        } catch (IOException e) {
            // ignore
        }
    }
}

From source file:net.sf.j2s.core.builder.AbstractImageBuilder.java

License:Open Source License

protected void createProblemFor(IResource resource, IMember javaElement, String message,
        String problemSeverity) {
    try {//w w w .j  a va 2s . c om
        IMarker marker = resource.createMarker(IJavaModelMarker.JAVA_MODEL_PROBLEM_MARKER);
        int severity = problemSeverity.equals(JavaCore.WARNING) ? IMarker.SEVERITY_WARNING
                : IMarker.SEVERITY_ERROR;

        ISourceRange range = null;
        if (javaElement != null) {
            try {
                range = javaElement.getNameRange();
            } catch (JavaModelException e) {
                if (e.getJavaModelStatus().getCode() != IJavaModelStatusConstants.ELEMENT_DOES_NOT_EXIST) {
                    throw e;
                }
                if (!CharOperation.equals(javaElement.getElementName().toCharArray(),
                        TypeConstants.PACKAGE_INFO_NAME)) {
                    throw e;
                }
                // else silently swallow the exception as the synthetic interface type package-info has no
                // source range really. See https://bugs.eclipse.org/bugs/show_bug.cgi?id=258145
            }
        }
        int start = range == null ? 0 : range.getOffset();
        int end = range == null ? 1 : start + range.getLength();
        marker.setAttributes(
                new String[] { IMarker.MESSAGE, IMarker.SEVERITY, IMarker.CHAR_START, IMarker.CHAR_END,
                        IMarker.SOURCE_ID },
                new Object[] { message, new Integer(severity), new Integer(start), new Integer(end),
                        JavaBuilder.SOURCE_ID });
    } catch (CoreException e) {
        throw internalException(e);
    }
}

From source file:org.codehaus.jdt.groovy.model.GroovyCompilationUnit.java

License:Open Source License

@SuppressWarnings({ "unchecked", "rawtypes", "nls", "restriction" })
@Override//from   ww  w . j  a  v a 2 s  .com
protected boolean buildStructure(OpenableElementInfo info, IProgressMonitor pm, Map newElements,
        IResource underlyingResource) throws JavaModelException {
    try {
        depth.set(depth.get() + 1);

        // if (!isOnBuildPath()) {
        // return false;
        // }

        if (GroovyLogManager.manager.hasLoggers()) {
            GroovyLogManager.manager.log(TraceCategory.COMPILER, "Build Structure starting for " + this.name);
            GroovyLogManager.manager
                    .logStart("Build structure: " + name + " : " + Thread.currentThread().getName());
        }

        CompilationUnitElementInfo unitInfo = (CompilationUnitElementInfo) info;

        // ensure buffer is opened
        IBuffer buffer = getBufferManager().getBuffer(this);
        if (buffer == null) {
            openBuffer(pm, unitInfo); // open buffer independently from the
            // info, since we are building the info
        }

        // generate structure and compute syntax problems if needed
        GroovyCompilationUnitStructureRequestor requestor = new GroovyCompilationUnitStructureRequestor(this,
                unitInfo, newElements);
        JavaModelManager.PerWorkingCopyInfo perWorkingCopyInfo = getPerWorkingCopyInfo();
        JavaProject project = (JavaProject) getJavaProject();

        // determine what kind of buildStructure we are doing
        boolean createAST;
        int reconcileFlags;
        boolean resolveBindings;
        HashMap problems;
        if (info instanceof ASTHolderCUInfo) {
            ASTHolderCUInfo astHolder = (ASTHolderCUInfo) info;
            createAST = ((Integer) ReflectionUtils.getPrivateField(ASTHolderCUInfo.class, "astLevel", //$NON-NLS-1$
                    astHolder)).intValue() != NO_AST;
            resolveBindings = ((Boolean) ReflectionUtils.getPrivateField(ASTHolderCUInfo.class,
                    "resolveBindings", astHolder)).booleanValue();
            reconcileFlags = ((Integer) ReflectionUtils.getPrivateField(ASTHolderCUInfo.class, "reconcileFlags", //$NON-NLS-1$
                    astHolder)).intValue();
            problems = (HashMap) ReflectionUtils.getPrivateField(ASTHolderCUInfo.class, "problems", astHolder);
        } else {
            createAST = false;
            resolveBindings = false;
            reconcileFlags = 0;
            problems = null;
        }

        boolean computeProblems = perWorkingCopyInfo != null && perWorkingCopyInfo.isActive() && project != null
                && JavaProject.hasJavaNature(project.getProject());
        IProblemFactory problemFactory = new DefaultProblemFactory();

        // compiler options
        Map<String, String> options = (project == null ? JavaCore.getOptions() : project.getOptions(true));
        if (!computeProblems) {
            // disable task tags checking to speed up parsing
            options.put(JavaCore.COMPILER_TASK_TAGS, ""); //$NON-NLS-1$
        }

        // FIXASC deal with the case of project==null to reduce duplication in this next line and call to setGroovyClasspath
        // Required for Groovy, but not for Java
        options.put(CompilerOptions.OPTIONG_BuildGroovyFiles, CompilerOptions.ENABLED);

        CompilerOptions compilerOptions = new CompilerOptions(options);

        if (project != null) {
            CompilerUtils.setGroovyClasspath(compilerOptions, project);
        }

        // Required for Groovy, but not for Java
        ProblemReporter reporter = new ProblemReporter(new GroovyErrorHandlingPolicy(!computeProblems),
                compilerOptions, new DefaultProblemFactory());

        SourceElementParser parser = new MultiplexingSourceElementRequestorParser(reporter, requestor, /*
                                                                                                       * not needed if
                                                                                                       * computing groovy only
                                                                                                       */
                problemFactory, compilerOptions, true/* report local declarations */, !createAST /*
                                                                                                 * optimize string literals only if not
                                                                                                 * creating a DOM AST
                                                                                                 */);
        parser.reportOnlyOneSyntaxError = !computeProblems;
        // maybe not needed for groovy, but I don't want to find out.
        parser.setMethodsFullRecovery(true);
        parser.setStatementsRecovery((reconcileFlags & ICompilationUnit.ENABLE_STATEMENTS_RECOVERY) != 0);

        if (!computeProblems && !resolveBindings && !createAST) // disable javadoc parsing if not computing problems, not
            // resolving
            // and not creating ast
            parser.javadocParser.checkDocComment = false;
        requestor.setParser(parser);

        // update timestamp (might be IResource.NULL_STAMP if original does not
        // exist)
        if (underlyingResource == null) {
            underlyingResource = getResource();
        }
        // underlying resource is null in the case of a working copy on a class
        // file in a jar
        if (underlyingResource != null) {
            ReflectionUtils.setPrivateField(CompilationUnitElementInfo.class, "timestamp", unitInfo, //$NON-NLS-1$
                    underlyingResource.getModificationStamp());
        }

        GroovyCompilationUnitDeclaration compilationUnitDeclaration = null;
        CompilationUnit source = cloneCachingContents();
        try {
            // GROOVY
            // note that this is a slightly different approach than taken by super.buildStructure
            // in super.buildStructure, there is a test here to see if computeProblems is true.
            // if false, then parser.parserCompilationUnit is called.
            // this will not work for Groovy because we need to ensure bindings are resolved
            // for many operations (content assist and code select) to work.
            // So, for groovy, always use CompilationUnitProblemFinder.process and then process problems
            // separately only if necessary
            // addendum (GRECLIPSE-942). The testcase for that bug includes a package with 200
            // types in that refer to each other in a chain, through field references. If a reconcile
            // references the top of the chain we can go through a massive number of recursive calls into
            // this buildStructure for each one. The 'full' parse (with bindings) is only required for
            // the top most (regardless of the computeProblems setting) and so we track how many recursive
            // calls we have made - if we are at depth 2 we do what JDT was going to do (the quick thing).
            if (computeProblems || depth.get() < 2) {
                if (problems == null) {
                    // report problems to the problem requestor
                    problems = new HashMap();
                    compilationUnitDeclaration = (GroovyCompilationUnitDeclaration) CompilationUnitProblemFinder
                            .process(source, parser, this.owner, problems, createAST, reconcileFlags, pm);
                    if (computeProblems) {
                        try {
                            perWorkingCopyInfo.beginReporting();
                            for (Iterator iteraror = problems.values().iterator(); iteraror.hasNext();) {
                                CategorizedProblem[] categorizedProblems = (CategorizedProblem[]) iteraror
                                        .next();
                                if (categorizedProblems == null)
                                    continue;
                                for (int i = 0, length = categorizedProblems.length; i < length; i++) {
                                    perWorkingCopyInfo.acceptProblem(categorizedProblems[i]);
                                }
                            }
                        } finally {
                            perWorkingCopyInfo.endReporting();
                        }
                    }
                } else {
                    // collect problems
                    compilationUnitDeclaration = (GroovyCompilationUnitDeclaration) CompilationUnitProblemFinder
                            .process(source, parser, this.owner, problems, createAST, reconcileFlags, pm);
                }
            } else {
                compilationUnitDeclaration = (GroovyCompilationUnitDeclaration) parser
                        .parseCompilationUnit(source, true /* full parse to find local elements */, pm);
            }

            // GROOVY
            // if this is a working copy, then we have more work to do
            maybeCacheModuleNode(perWorkingCopyInfo, compilationUnitDeclaration);

            // create the DOM AST from the compiler AST
            if (createAST) {
                org.eclipse.jdt.core.dom.CompilationUnit ast;
                try {
                    ast = AST.convertCompilationUnit(AST.JLS3, compilationUnitDeclaration, options,
                            computeProblems, source, reconcileFlags, pm);
                    ReflectionUtils.setPrivateField(ASTHolderCUInfo.class, "ast", info, ast); //$NON-NLS-1$
                } catch (OperationCanceledException e) {
                    // catch this exception so as to not enter the catch(RuntimeException e) below
                    // might need to do the same for AbortCompilation
                    throw e;
                } catch (IllegalArgumentException e) {
                    // if necessary, we can do some better reporting here.
                    Util.log(e, "Problem with build structure: Offset for AST node is incorrect in " //$NON-NLS-1$
                            + this.getParent().getElementName() + "." + getElementName()); //$NON-NLS-1$
                } catch (Exception e) {
                    Util.log(e, "Problem with build structure for " + this.getElementName()); //$NON-NLS-1$
                }
            }
        } catch (OperationCanceledException e) {
            // catch this exception so as to not enter the catch(RuntimeException e) below
            // might need to do the same for AbortCompilation
            throw e;
        } catch (JavaModelException e) {
            // GRECLIPSE-1480 don't log element does not exist exceptions. since this could occur when element is in a non-java
            // project
            if (e.getStatus().getCode() != IJavaModelStatusConstants.ELEMENT_DOES_NOT_EXIST
                    || this.getJavaProject().exists()) {
                Util.log(e, "Problem with build structure for " + this.getElementName()); //$NON-NLS-1$
            }
        } catch (Exception e) {
            // GROOVY: The groovy compiler does not handle broken code well in many situations
            // use this general catch clause so that exceptions thrown by broken code
            // do not bubble up the stack.
            Util.log(e, "Problem with build structure for " + this.getElementName()); //$NON-NLS-1$
        } finally {
            if (compilationUnitDeclaration != null) {
                compilationUnitDeclaration.cleanUp();
            }
        }
        return unitInfo.isStructureKnown();
    } finally {
        depth.set(depth.get() - 1);
        if (GroovyLogManager.manager.hasLoggers()) {
            GroovyLogManager.manager.logEnd(
                    "Build structure: " + name + " : " + Thread.currentThread().getName(),
                    TraceCategory.COMPILER);
        }
    }
}

From source file:org.eclipse.ajdt.core.reconcile.AJReconcileWorkingCopyOperation.java

License:Open Source License

protected IJavaModelStatus verify() {
    IJavaModelStatus status = super.verify();
    if (!status.isOK()) {
        return status;
    }//from  w w w .j  a  v  a 2 s.c  om
    CompilationUnit workingCopy = getWorkingCopy();
    if (!workingCopy.isWorkingCopy()) {
        return new JavaModelStatus(IJavaModelStatusConstants.ELEMENT_DOES_NOT_EXIST, workingCopy); //was destroyed
    }
    return status;
}

From source file:org.eclipse.che.jdt.internal.core.JavaElement.java

License:Open Source License

protected IJavaModelStatus newDoesNotExistStatus() {
    return new org.eclipse.che.jdt.internal.core.JavaModelStatus(
            IJavaModelStatusConstants.ELEMENT_DOES_NOT_EXIST, this);
}