Unnamed: 0 int64 0 305k | body stringlengths 7 52.9k | name stringlengths 1 185 |
|---|---|---|
4,600 | String (Iterable<? extends File> path, boolean caseSensitiveFS) { return null; // this will cause FileManager to delegate to JVM implementation } | inferBinaryName |
4,601 | ByteArrayOutputStream () { return new ByteArrayOutputStream() { private boolean isClosed = false; private synchronized boolean markClosed() { return !isClosed && (isClosed = true); } @Override public void close() throws IOException { if (markClosed()) { try { super.close(); } finally { myContent = new BinaryContent(buf, 0, size()); if (myContext != null) { myContext.consumeOutputFile(OutputFileObject.this); } } } } }; } | openOutputStream |
4,602 | BinaryContent () { return myContent; } | getContent |
4,603 | void (@NotNull byte[] updatedContent) { myContent = new BinaryContent(updatedContent, 0, updatedContent.length); } | updateContent |
4,604 | boolean (Object s) { return s != null; } | fun |
4,605 | boolean (Iterable<?> iterable) { return isEmptyCollection(iterable) || !iterable.iterator().hasNext(); } | isEmpty |
4,606 | boolean (Iterable<?> iterable) { return iterable == null || iterable instanceof Collection && ((Collection<?>)iterable).isEmpty(); } | isEmptyCollection |
4,607 | Iterator<T> () { return getDelegate().iterator(); } | iterator |
4,608 | Iterable<T> () { Iterable<T> delegate = myDelegate; if (delegate == null) { myDelegate = delegate = provider.get(); } return delegate; } | getDelegate |
4,609 | Iterator<T> () { return flat(first.iterator(), second.iterator()); } | iterator |
4,610 | boolean () { return first.hasNext() || second.hasNext(); } | hasNext |
4,611 | T () { return first.hasNext()? first.next() : second.next(); } | next |
4,612 | Iterator<T> () { return flat(map(parts.iterator(), new Function<Iterable<? extends T>, Iterator<T>>() { @Override public Iterator<T> fun(Iterable<? extends T> itr) { return asIterator(itr); } })); } | iterator |
4,613 | Iterator<T> (Iterable<? extends T> itr) { return asIterator(itr); } | fun |
4,614 | boolean () { return findNext() != null; } | hasNext |
4,615 | T () { Iterator<T> group = findNext(); if (group != null) { return group.next(); } throw new NoSuchElementException(); } | next |
4,616 | Iterator<T> () { if (currentGroup == null || !currentGroup.hasNext()) { do { currentGroup = groupsIterator.hasNext() ? groupsIterator.next() : null; } while (currentGroup != null && !currentGroup.hasNext()); } return currentGroup; } | findNext |
4,617 | Iterator<T> () { return asIterator(elem); } | iterator |
4,618 | boolean () { return available; } | hasNext |
4,619 | T () { if (available) { available = false; return elem; } throw new NoSuchElementException(); } | next |
4,620 | Iterator<O> () { return map(from.iterator(), mapper); } | iterator |
4,621 | boolean () { return it.hasNext(); } | hasNext |
4,622 | O () { return mapper.fun(it.next()); } | next |
4,623 | Iterator<T> () { return filter(it.iterator(), predicate); } | iterator |
4,624 | boolean () { if (!isPending) { findNext(); } return isPending; } | hasNext |
4,625 | T () { try { if (!isPending) { findNext(); if (!isPending) { throw new NoSuchElementException(); } } return current; } finally { current = null; isPending = false; } } | next |
4,626 | void () { isPending = false; current = null; while (it.hasNext()) { final T next = it.next(); if (predicate.fun(next)) { isPending = true; current = next; break; } } } | findNext |
4,627 | Iterator<T> () { return filterWithOrder(from.iterator(), predicates.iterator()); } | iterator |
4,628 | Iterator<T> (BooleanFunction<? super T> pred) { if (!buffer.isEmpty()) { for (Iterator<T> it = buffer.iterator(); it.hasNext(); ) { final T elem = it.next(); if (pred.fun(elem)) { it.remove(); return asIterator(elem); } } } while(from.hasNext()) { final T elem = from.next(); if (pred.fun(elem)) { return asIterator(elem); } buffer.add(elem); } buffer.clear(); return Collections.emptyIterator(); } | fun |
4,629 | Iterator<T> () { return unique(it.iterator()); } | iterator |
4,630 | boolean (T t) { if (processed == null) { processed = new HashSet<>(); } return processed.add(t); } | fun |
4,631 | Iterator<T> () { return filter(it.iterator(), predicateFactory.get()); } | iterator |
4,632 | Iterator<T> () { return new Object() { private final Set<T> traversed = new HashSet<>(); private Iterator<T> recurse(final T elem, boolean includeHead) { if (!traversed.add(elem)) { return Collections.emptyIterator(); } if (!includeHead) { return tailOf(elem); } return flat(asIterator(elem), new LazyIterator<T>() { @Override protected Iterator<? extends T> create() { return tailOf(elem); } }); } @NotNull private Iterator<T> tailOf(final T elem) { final Iterable<? extends T> tail = filter(step.fun(elem), new BooleanFunction<T>() { @Override public boolean fun(T e) { return !traversed.contains(e); } }); return flat(tail.iterator(), flat(map(tail.iterator(), new Function<T, Iterator<T>>() { @Override public Iterator<T> fun(T obj) { return recurse(obj, false); } }))); } }.recurse(item, includeHead); } | iterator |
4,633 | Iterator<T> (final T elem, boolean includeHead) { if (!traversed.add(elem)) { return Collections.emptyIterator(); } if (!includeHead) { return tailOf(elem); } return flat(asIterator(elem), new LazyIterator<T>() { @Override protected Iterator<? extends T> create() { return tailOf(elem); } }); } | recurse |
4,634 | Iterator<T> (final T elem) { final Iterable<? extends T> tail = filter(step.fun(elem), new BooleanFunction<T>() { @Override public boolean fun(T e) { return !traversed.contains(e); } }); return flat(tail.iterator(), flat(map(tail.iterator(), new Function<T, Iterator<T>>() { @Override public Iterator<T> fun(T obj) { return recurse(obj, false); } }))); } | tailOf |
4,635 | boolean (T e) { return !traversed.contains(e); } | fun |
4,636 | Iterator<T> (T obj) { return recurse(obj, false); } | fun |
4,637 | Iterator<T> () { return new Object() { private final Set<T> visited = new HashSet<>(); private Iterator<T> recurse(final T elem, boolean includeHead) { if (!visited.add(elem)) { return Collections.emptyIterator(); } if (!includeHead) { return flat(map(step.fun(elem).iterator(), new Function<T, Iterator<T>>() { @Override public Iterator<T> fun(T obj) { return recurse(obj, true); } })); } Iterator<? extends T> tail = new LazyIterator<T>() { @Override protected Iterator<? extends T> create() { return step.fun(elem).iterator(); } }; return flat(asIterator(elem), flat(map(tail, new Function<T, Iterator<T>>() { @Override public Iterator<T> fun(T obj) { return recurse(obj, true); } }))); } }.recurse(item, includeHead); } | iterator |
4,638 | Iterator<T> (final T elem, boolean includeHead) { if (!visited.add(elem)) { return Collections.emptyIterator(); } if (!includeHead) { return flat(map(step.fun(elem).iterator(), new Function<T, Iterator<T>>() { @Override public Iterator<T> fun(T obj) { return recurse(obj, true); } })); } Iterator<? extends T> tail = new LazyIterator<T>() { @Override protected Iterator<? extends T> create() { return step.fun(elem).iterator(); } }; return flat(asIterator(elem), flat(map(tail, new Function<T, Iterator<T>>() { @Override public Iterator<T> fun(T obj) { return recurse(obj, true); } }))); } | recurse |
4,639 | Iterator<T> (T obj) { return recurse(obj, true); } | fun |
4,640 | Iterator<T> (T obj) { return recurse(obj, true); } | fun |
4,641 | void () { throw new UnsupportedOperationException(); } | remove |
4,642 | boolean () { return getDelegate().hasNext(); } | hasNext |
4,643 | T () { return getDelegate().next(); } | next |
4,644 | void () { getDelegate().remove(); } | remove |
4,645 | String (String path) { return path != null? path.replace('\\', '/') : null; } | convertPath |
4,646 | DiagnosticOutputConsumer () { return myDiagnosticSink; } | getDiagnosticSink |
4,647 | boolean (MessageLite message) { try { final JavacRemoteProto.Message msg = (JavacRemoteProto.Message)message; final JavacRemoteProto.Message.Type messageType = msg.getMessageType(); if (messageType == JavacRemoteProto.Message.Type.RESPONSE) { final JavacRemoteProto.Message.Response response = msg.getResponse(); final JavacRemoteProto.Message.Response.Type responseType = response.getResponseType(); if (responseType == JavacRemoteProto.Message.Response.Type.BUILD_MESSAGE) { final JavacRemoteProto.Message.Response.CompileMessage compileMessage = response.getCompileMessage(); final JavacRemoteProto.Message.Response.CompileMessage.Kind messageKind = compileMessage.getKind(); if (messageKind == JavacRemoteProto.Message.Response.CompileMessage.Kind.STD_OUT) { if (compileMessage.hasText()) { myDiagnosticSink.outputLineAvailable(compileMessage.getText()); } } else { final String sourceUri = compileMessage.hasSourceUri()? compileMessage.getSourceUri() : null; final JavaFileObject srcFileObject = sourceUri != null? new DummyJavaFileObject(URI.create(sourceUri)) : null; myDiagnosticSink.report(new DummyDiagnostic(convertKind(messageKind), srcFileObject, compileMessage)); } return false; } if (responseType == JavacRemoteProto.Message.Response.Type.OUTPUT_OBJECT) { final JavacRemoteProto.Message.Response.OutputObject outputObject = response.getOutputObject(); final JavacRemoteProto.Message.Response.OutputObject.Kind kind = outputObject.getKind(); final String outputRoot = outputObject.hasOutputRoot()? outputObject.getOutputRoot() : null; final File outputRootFile = outputRoot != null? new File(myWslSupport.convertPath(outputRoot)) : null; final BinaryContent fileObjectContent; final ByteString content = outputObject.hasContent()? outputObject.getContent() : null; if (content != null) { final byte[] bytes = content.toByteArray(); fileObjectContent = new BinaryContent(bytes, 0, bytes.length); } else { fileObjectContent = null; } final JavaFileManager.Location location = outputObject.hasLocation()? StandardLocation.locationFor(outputObject.getLocation()) : null; Collection<URI> sources = new ArrayList<>(); for (String uri : outputObject.getSourceUriList()) { sources.add(URI.create(uri)); } final OutputFileObject fileObject = new OutputFileObject( null, outputRootFile, outputObject.hasRelativePath()? outputObject.getRelativePath() : null, new File(myWslSupport.convertPath(outputObject.getFilePath())), convertKind(kind), outputObject.hasClassName()? outputObject.getClassName() : null, sources, myEncodingName, fileObjectContent, location, outputObject.getIsGenerated() ); myOutputSink.save(fileObject); return false; } if (responseType == JavacRemoteProto.Message.Response.Type.SRC_FILE_LOADED) { final JavacRemoteProto.Message.Response.OutputObject outputObject = response.getOutputObject(); final File file = new File(myWslSupport.convertPath(outputObject.getFilePath())); myDiagnosticSink.javaFileLoaded(file); return false; } if (responseType == JavacRemoteProto.Message.Response.Type.CUSTOM_OUTPUT_OBJECT) { final JavacRemoteProto.Message.Response.OutputObject outputObject = response.getOutputObject(); final String pluginId = outputObject.getFilePath(); final String name = outputObject.getClassName(); final byte[] content = outputObject.hasContent()? outputObject.getContent().toByteArray() : new byte[0]; myDiagnosticSink.customOutputData(pluginId, name, content); return false; } if (responseType == JavacRemoteProto.Message.Response.Type.BUILD_COMPLETED) { if (response.hasCompletionStatus()) { myTerminatedSuccessfully = response.getCompletionStatus(); } return true; } throw new Exception("Unsupported response type: " + responseType.name()); } if (messageType == JavacRemoteProto.Message.Type.FAILURE) { final JavacRemoteProto.Message.Failure failure = msg.getFailure(); final StringBuilder buf = new StringBuilder(); if (failure.hasDescription()) { buf.append(failure.getDescription()); } if (failure.hasStacktrace()) { if (buf.length() > 0) { buf.append("\n"); } buf.append(failure.getStacktrace()); } //noinspection HardCodedStringLiteral myDiagnosticSink.report(new PlainMessageDiagnostic(Diagnostic.Kind.ERROR, buf.toString())); return true; } throw new Exception("Unsupported message type: " + messageType.name()); } catch (Throwable e) { myDiagnosticSink.report(new PlainMessageDiagnostic(Diagnostic.Kind.ERROR, e.getMessage())); return true; } } | handleMessage |
4,648 | boolean () { return myTerminatedSuccessfully; } | isTerminatedSuccessfully |
4,649 | Kind () { return myMessageKind; } | getKind |
4,650 | JavaFileObject () { return mySrcFileObject; } | getSource |
4,651 | long () { return myCompileMessage.hasProblemLocationOffset()? myCompileMessage.getProblemLocationOffset() : -1; } | getPosition |
4,652 | long () { return myCompileMessage.hasProblemBeginOffset()? myCompileMessage.getProblemBeginOffset() : -1; } | getStartPosition |
4,653 | long () { return myCompileMessage.hasProblemEndOffset()? myCompileMessage.getProblemEndOffset() : -1; } | getEndPosition |
4,654 | long () { return myCompileMessage.hasLine()? myCompileMessage.getLine() : -1; } | getLineNumber |
4,655 | long () { return myCompileMessage.hasColumn()? myCompileMessage.getColumn() : -1; } | getColumnNumber |
4,656 | String () { return null; } | getCode |
4,657 | String (Locale locale) { //noinspection HardCodedStringLiteral return myCompileMessage.hasText()? myCompileMessage.getText() : null; } | getMessage |
4,658 | boolean (T data) { return JpsFileObject.findKind(myToNameConverter.fun(data)) == JavaFileObject.Kind.OTHER; } | fun |
4,659 | boolean (T data) { final String name = myToNameConverter.fun(data); return name.regionMatches(true, name.length() - kind.extension.length(), kind.extension, 0, kind.extension.length()); } | fun |
4,660 | BooleanFunction<T> (final Set<JavaFileObject.Kind> kinds) { // optimization for a single-element collection final Iterator<JavaFileObject.Kind> it = kinds.iterator(); if (it.hasNext()) { final JavaFileObject.Kind kind = it.next(); if (!it.hasNext()) { return myFilterMap.get(kind); } } // OR-filter, quite rare case return new BooleanFunction<T>() { @Override public boolean fun(T data) { for (JavaFileObject.Kind kind : kinds) { if (myFilterMap.get(kind).fun(data)) { return true; } } return false; } }; } | getFor |
4,661 | boolean (T data) { for (JavaFileObject.Kind kind : kinds) { if (myFilterMap.get(kind).fun(data)) { return true; } } return false; } | fun |
4,662 | File () { return myFile.getAbsoluteFile(); } | get |
4,663 | File () { return myFile; } | getFile |
4,664 | long () { return myFile.lastModified(); } | getLastModified |
4,665 | boolean () { return myFile.delete(); } | delete |
4,666 | String (Iterable<? extends File> path, final boolean caseSensitiveFS) { final String fPath = myFile.getPath(); for (File dir: path) { String dirPath = dir.getPath(); if (dirPath.length() == 0) { dirPath = System.getProperty("user.dir"); } if (!fPath.regionMatches(!caseSensitiveFS, 0, dirPath, 0, dirPath.length())) { continue; } final int pathLength = fPath.length(); final boolean endsWithSeparator = dirPath.endsWith(File.separator); if (!endsWithSeparator) { // need to check if the next char in fPath is file separator final int separatorIdx = dirPath.length(); if (pathLength <= separatorIdx || fPath.charAt(separatorIdx) != File.separatorChar) { continue; } } // fPath starts with dirPath final int startIndex = endsWithSeparator ? dirPath.length() : dirPath.length() + 1; int endIndex = fPath.lastIndexOf('.'); if (endIndex <= startIndex) { endIndex = fPath.length(); } final int length = endIndex - startIndex; final StringBuilder buf = new StringBuilder(length).append(fPath, startIndex, endIndex); for (int idx = 0; idx < length; idx++) { if (buf.charAt(idx) == File.separatorChar) { buf.setCharAt(idx, '.'); } } return buf.toString(); } return null; } | inferBinaryName |
4,667 | boolean (@NotNull String cn, JavaFileObject.Kind kind) { if (kind == Kind.OTHER && getKind() != kind) { return false; } final String n = cn + kind.extension; String name = myFile.getName(); if (name.equals(n)) { return true; } if (name.equalsIgnoreCase(n)) { // if we are on a case-insensitive file system, // try to compare against the real (exactly as on the disk) file name // try { // todo: use NIO API if available like in the commented code below //return n.equals(myFile.toPath().toRealPath(LinkOption.NOFOLLOW_LINKS).getFileName().toString()); return n.equals(myFile.getCanonicalFile().getName()); } catch (IOException ignored) { } } return false; } | isNameCompatible |
4,668 | boolean (Object other) { if (this == other) { return true; } if (!(other instanceof InputFileObject)) { return false; } final InputFileObject o = (InputFileObject)other; return getAbsoluteFile().equals(o.getAbsoluteFile()); } | equals |
4,669 | int () { return getAbsoluteFile().hashCode(); } | hashCode |
4,670 | File () { return myAbsFile.get(); } | getAbsoluteFile |
4,671 | boolean (Iterable<? extends String> options, Iterable<? extends File> sources, Iterable<? extends File> classpath, Iterable<? extends File> platformClasspath, ModulePath modulePath, Iterable<? extends File> upgradeModulePath, Iterable<? extends File> sourcePath, final Map<File, Set<File>> outputDirToRoots, final DiagnosticOutputConsumer diagnosticConsumer, final OutputFileConsumer outputSink, CanceledStatus canceledStatus, @NotNull JavaCompilingTool compilingTool) { JavaCompiler compiler; try { compiler = compilingTool.createCompiler(); } catch (CannotCreateJavaCompilerException e) { diagnosticConsumer.report(new PlainMessageDiagnostic(Diagnostic.Kind.ERROR, e.getMessage())); return false; } for (File outputDir : outputDirToRoots.keySet()) { outputDir.mkdirs(); } final boolean usingJavac = compilingTool instanceof JavacCompilerTool; final boolean javacBefore9 = usingJavac && JAVA_RUNTIME_PRE_9; // since java 9 internal API's used by the optimizedFileManager have changed final JpsJavacFileManager fileManager = new JpsJavacFileManager( new ContextImpl(compiler, diagnosticConsumer, outputSink, modulePath, canceledStatus), javacBefore9, JavaSourceTransformer.getTransformers() ); if (javacBefore9 && !Iterators.isEmpty(platformClasspath)) { // for javac6 this will prevent lazy initialization of Paths.bootClassPathRtJar // and thus usage of symbol file for resolution, when this file is not expected to be used fileManager.handleOption("-bootclasspath", Collections.singleton("").iterator()); fileManager.handleOption("-extdirs", Collections.singleton("").iterator()); // this will clear cached stuff fileManager.handleOption("-endorseddirs", Collections.singleton("").iterator()); // this will clear cached stuff } final Iterable<String> _options = prepareOptions(options, compilingTool); try { // to be on the safe side, we'll have to apply all options _before_ calling any of manager's methods // i.e. getJavaFileObjectsFromFiles() // This way the manager will be properly initialized. Namely, the encoding will be set correctly // Note that due to lazy initialization in various components inside javac, handleOption() should be called before setLocation() and others // update: for some options their repetitive initialization would be considered as error: e.g. '--patch-module', // therefore we do the trick only for those options that may influence FileManager's state initialization before passing it to getTask() method for (Iterator<String> iterator = _options.iterator(); iterator.hasNext(); ) { final String option = iterator.next(); if (FILE_MANAGER_EARLY_INIT_OPTIONS.contains(option)) { fileManager.handleOption(option, iterator); } } try { fileManager.setOutputDirectories(outputDirToRoots); } catch (IOException e) { fileManager.getContext().reportMessage(Diagnostic.Kind.ERROR, e.getMessage()); return false; } if (!Iterators.isEmpty(platformClasspath)) { try { fileManager.handleOption("-bootclasspath", Collections.singleton("").iterator()); // this will clear cached stuff fileManager.setLocation(StandardLocation.PLATFORM_CLASS_PATH, buildPlatformClasspath(platformClasspath, _options)); } catch (IOException e) { fileManager.getContext().reportMessage(Diagnostic.Kind.ERROR, e.getMessage()); return false; } } if (!Iterators.isEmpty(upgradeModulePath)) { try { setLocation(fileManager, "UPGRADE_MODULE_PATH", upgradeModulePath); } catch (IOException e) { fileManager.getContext().reportMessage(Diagnostic.Kind.ERROR, e.getMessage()); return false; } } final boolean isAnnotationProcessingEnabled = isAnnotationProcessingEnabled(_options); if (!modulePath.isEmpty()) { try { setLocation(fileManager, "MODULE_PATH", modulePath.getPath()); if (isAnnotationProcessingEnabled && getLocation(fileManager, "ANNOTATION_PROCESSOR_MODULE_PATH") == null && fileManager.getLocation(StandardLocation.ANNOTATION_PROCESSOR_PATH) == null) { // default annotation processing discovery path to module path if not explicitly set setLocation(fileManager, "ANNOTATION_PROCESSOR_MODULE_PATH", Iterators.filter(modulePath.getPath(), new BooleanFunction<File>() { @Override public boolean fun(File file) { return !outputDirToRoots.containsKey(file); } })); } } catch (IOException e) { fileManager.getContext().reportMessage(Diagnostic.Kind.ERROR, e.getMessage()); return false; } } if (!Iterators.isEmpty(classpath)) { // because module path has priority if present, initialize classpath after the module path try { fileManager.setLocation(StandardLocation.CLASS_PATH, classpath); if (!usingJavac && isAnnotationProcessingEnabled && !Iterators.contains(_options, "-processorpath") && !Iterators.contains(_options, "--processor-module-path") && getLocation(fileManager, "ANNOTATION_PROCESSOR_MODULE_PATH") == null) { // for non-javac file manager ensure annotation processor path defaults to classpath fileManager.setLocation(StandardLocation.ANNOTATION_PROCESSOR_PATH, classpath); } } catch (IOException e) { fileManager.getContext().reportMessage(Diagnostic.Kind.ERROR, e.getMessage()); return false; } } if (javacBefore9 || !Iterators.isEmpty(sourcePath) || modulePath.isEmpty()) { try { // ensure the source path is set; // otherwise, if not set, javac attempts to search both classes and sources in classpath; // so if some classpath jars contain sources, it will attempt to compile them // starting from javac9 it seems that setting empty source path may affect module compilation logic, so starting from javac9 // we avoid forcing empty sourcepath fileManager.setLocation(StandardLocation.SOURCE_PATH, sourcePath); } catch (IOException e) { fileManager.getContext().reportMessage(Diagnostic.Kind.ERROR, e.getMessage()); return false; } } final APIWrappers.ProcessingContext procContext; final DiagnosticOutputConsumer diagnosticListener; if (TRACK_AP_GENERATED_DEPENDENCIES && isAnnotationProcessingEnabled) { procContext = new APIWrappers.ProcessingContext(fileManager); // use real processor class names and not names of processor wrappers diagnosticListener = APIWrappers.newDiagnosticListenerWrapper(procContext, diagnosticConsumer); } else { procContext = null; diagnosticListener = diagnosticConsumer; } final LineOutputWriter out = new LineOutputWriter() { @Override protected void lineAvailable(String line) { if (usingJavac) { diagnosticListener.outputLineAvailable(line); } else { // todo: filter too verbose eclipse output? } } }; // methods added to newer versions of StandardJavaFileManager interfaces have default implementations that // do not delegate to corresponding methods of FileManager's base implementation // this proxy object makes sure the calls, not implemented in our file manager, are dispatched further to the base file manager implementation final StandardJavaFileManager fm = APIWrappers.wrap(StandardJavaFileManager.class, fileManager, fileManager.getClass().getSuperclass(), fileManager.getStdManager()); final JavaCompiler.CompilationTask task = tryInstallClientCodeWrapperCallDispatcher(compiler.getTask( out, fm, diagnosticListener, _options, null, fileManager.setInputSources(sources) ), fm); for (JavaCompilerToolExtension extension : JavaCompilerToolExtension.getExtensions()) { try { extension.beforeCompileTaskExecution(compilingTool, task, _options, diagnosticConsumer); } catch (Throwable e) { fileManager.getContext().reportMessage(Diagnostic.Kind.MANDATORY_WARNING, extension.getClass() + " : " + e.getMessage()); e.printStackTrace(System.err); } } if (TRACK_AP_GENERATED_DEPENDENCIES && isAnnotationProcessingEnabled) { final Iterable<Processor> processors = lookupAnnotationProcessors(procContext, getAnnotationProcessorNames(_options)); if (processors != null) { task.setProcessors(processors); } } return task.call(); } catch(IllegalArgumentException | IllegalStateException e) { diagnosticConsumer.report(new PlainMessageDiagnostic(Diagnostic.Kind.ERROR, e.getMessage())); } catch (CompilationCanceledException e) { diagnosticConsumer.report(new JpsInfoDiagnostic(e.getMessage())); } catch (RuntimeException e) { final Throwable cause = e.getCause(); if (cause != null) { if (cause instanceof CompilationCanceledException) { diagnosticConsumer.report(new JpsInfoDiagnostic(cause.getMessage())); } else { diagnosticConsumer.report(new PlainMessageDiagnostic(Diagnostic.Kind.ERROR, buildCompilerErrorMessage(e))); throw e; } } else { throw e; } } finally { fileManager.close(); if (usingJavac) { cleanupJavacNameTable(); } } return false; } | compile |
4,672 | boolean (File file) { return !outputDirToRoots.containsKey(file); } | fun |
4,673 | void (String line) { if (usingJavac) { diagnosticListener.outputLineAvailable(line); } else { // todo: filter too verbose eclipse output? } } | lineAvailable |
4,674 | Iterable<Processor> (final APIWrappers.ProcessingContext procContext, @Nullable Iterable<String> processorNames) { try { Iterable<Processor> processors = null; if (hasLocation(procContext.getFileManager(), "ANNOTATION_PROCESSOR_MODULE_PATH")) { // this is equivalent to //processors = fileManager.getServiceLoader(StandardLocation.locationFor("ANNOTATION_PROCESSOR_MODULE_PATH"), Processor.class); // if java modules are involved, they should be properly handled by the fileManager //noinspection unchecked processors = (ServiceLoader<Processor>)JavaFileManager.class.getMethod("getServiceLoader", JavaFileManager.Location.class, Class.class).invoke( procContext.getFileManager(), StandardLocation.locationFor("ANNOTATION_PROCESSOR_MODULE_PATH"), Processor.class ); if (processorNames != null) { processors = Iterators.filterWithOrder(processors, Iterators.map(processorNames, new Function<String, BooleanFunction<? super Processor>>() { @Override public BooleanFunction<? super Processor> fun(final String procName) { return new BooleanFunction<Processor>() { @Override public boolean fun(Processor processor) { return procName.equals(processor.getClass().getName()); } }; } })); } } else { final ClassLoader processorClassLoader = procContext.getFileManager().getClassLoader( // If processorpath is not explicitly set, use the classpath. procContext.getFileManager().hasLocation(StandardLocation.ANNOTATION_PROCESSOR_PATH) ? StandardLocation.ANNOTATION_PROCESSOR_PATH : StandardLocation.CLASS_PATH ); if (processorClassLoader != null) { if (processorNames != null) { final List<Processor> loaded = new ArrayList<>(); for (String procName : processorNames) { loaded.add((Processor)processorClassLoader.loadClass(procName).getDeclaredConstructor().newInstance()); } processors = loaded; } else { processors = ServiceLoader.load(Processor.class, processorClassLoader); } } } if (processors != null) { return procContext.wrapProcessors(processors); } } catch (RuntimeException e) { throw e; } catch (Throwable e) { throw new RuntimeException(e); } return null; } | lookupAnnotationProcessors |
4,675 | boolean (Processor processor) { return procName.equals(processor.getClass().getName()); } | fun |
4,676 | Iterable<String> (Iterable<String> options) { for (Iterator<String> it = options.iterator(); it.hasNext(); ) { final String option = it.next(); if ("-processor".equals(option)) { return it.hasNext()? Arrays.asList(it.next().split(",")) : null; } } return null; } | getAnnotationProcessorNames |
4,677 | String (Throwable e) { return new Object() { @Nls final StringBuilder buf = new StringBuilder(); @Nls String collectAllMessages(Throwable e, Set<Throwable> processed) { if (e != null && processed.add(e)) { final String msg = e.getMessage(); if (msg != null && !msg.trim().isEmpty() && buf.indexOf(msg) < 0) { if (buf.length() > 0) { buf.append("\n"); } buf.append(msg); } return collectAllMessages(e.getCause(), processed); } return buf.toString(); } }.collectAllMessages(e, new HashSet<Throwable>()); } | buildCompilerErrorMessage |
4,678 | boolean (Field field) { return contextClass.equals(field.getType()); } | fun |
4,679 | void (final Object obj, final StandardJavaFileManager delegateTo, final Set<Object> visited) { if (obj instanceof JavaFileManager && visited.add(obj)) { forEachField(obj.getClass(), new BooleanFunction<Field>() { @Override public boolean fun(Field field) { try { if (JavaFileManager.class.isAssignableFrom(field.getType())) { final Object value = field.get(obj); if (isClientCodeWrapper(value, delegateTo)) { field.set(obj, APIWrappers.wrap(StandardJavaFileManager.class, value, Object.class, delegateTo)); } else { installCallDispatcherRecursively(value, delegateTo, visited); } } } catch (Throwable ignored) { } return true; } }); } } | installCallDispatcherRecursively |
4,680 | boolean (Field field) { try { if (JavaFileManager.class.isAssignableFrom(field.getType())) { final Object value = field.get(obj); if (isClientCodeWrapper(value, delegateTo)) { field.set(obj, APIWrappers.wrap(StandardJavaFileManager.class, value, Object.class, delegateTo)); } else { installCallDispatcherRecursively(value, delegateTo, visited); } } } catch (Throwable ignored) { } return true; } | fun |
4,681 | boolean (final Object obj, final StandardJavaFileManager delegateTo) { return obj instanceof StandardJavaFileManager && findField(obj.getClass(), new BooleanFunction<Field>() { @Override public boolean fun(Field f) { try { return f.get(obj) == delegateTo; } catch (Throwable ignored) { return false; } } }) != null; } | isClientCodeWrapper |
4,682 | boolean (Field f) { try { return f.get(obj) == delegateTo; } catch (Throwable ignored) { return false; } } | fun |
4,683 | Field (final Class<?> aClass, final BooleanFunction<? super Field> cond) { final Field[] res = new Field[]{null}; forEachField(aClass, new BooleanFunction<Field>() { @Override public boolean fun(Field field) { if (!cond.fun(field)) { return true; // continue } res[0] = field; return false; // stop } }); return res[0]; } | findField |
4,684 | boolean (Field field) { if (!cond.fun(field)) { return true; // continue } res[0] = field; return false; // stop } | fun |
4,685 | void (final Class<?> aClass, final BooleanFunction<? super Field> func) { for (Class<?> from = aClass; from != null && !Object.class.equals(from); from = from.getSuperclass()) { for (Field field : from.getDeclaredFields()) { try { if (!field.isAccessible()) { field.setAccessible(true); } if (!func.fun(field)) { return; } } catch (Throwable ignored) { } } } } | forEachField |
4,686 | boolean (StandardJavaFileManager fileManager, String locationId) { final JavaFileManager.Location location = StandardLocation.locationFor(locationId); return location != null && fileManager.hasLocation(location); } | hasLocation |
4,687 | boolean (final Iterable<String> options) { return !Iterators.contains(options, "-proc:none"); } | isAnnotationProcessingEnabled |
4,688 | Iterable<String> (final Iterable<? extends String> options, @NotNull JavaCompilingTool compilingTool) { final List<String> result = new ArrayList<>(compilingTool.getDefaultCompilerOptions()); boolean skip = false; for (String option : options) { if (FILTERED_OPTIONS.contains(option)) { skip = true; continue; } if (!skip) { if (!FILTERED_SINGLE_OPTIONS.contains(option) && !compilingTool.getDefaultCompilerOptions().contains(option)) { result.add(option); } } skip = false; } compilingTool.preprocessOptions(result); return result; } | prepareOptions |
4,689 | void (Map<PathOption, String> args, PathOption option, Collection<? super File> container, boolean listDir) { final String path = args.get(option); if (path == null) { return; } final StringTokenizer tokenizer = new StringTokenizer(path, File.pathSeparator, false); while (tokenizer.hasMoreTokens()) { final File file = new File(tokenizer.nextToken()); if (listDir) { final File[] files = file.listFiles(); if (files != null) { for (File f : files) { final String fName = f.getName(); if (fName.endsWith(".jar") || fName.endsWith(".zip")) { container.add(f); } } } } else { container.add(file); } } } | appendFiles |
4,690 | boolean (Map<PathOption, String> container, String arg, Iterator<String> rest) { if (myIsSuffix) { if (arg.startsWith(myArgName)) { container.put(this, arg.substring(myArgName.length())); return true; } } else { if (arg.equals(myArgName)) { if (rest.hasNext()) { container.put(this, rest.next()); } return true; } } return false; } | parse |
4,691 | String (File pathElement) { return myModulePath.getModuleName(pathElement); } | getExplodedAutomaticModuleName |
4,692 | boolean () { return myCanceledStatus.isCanceled(); } | isCanceled |
4,693 | StandardJavaFileManager () { return myStdManager; } | getStandardFileManager |
4,694 | void (final Diagnostic.Kind kind, @Nls String message) { myOutConsumer.report(new PlainMessageDiagnostic(kind, message)); } | reportMessage |
4,695 | void (@NotNull final OutputFileObject cls) { myOutputFileSink.save(cls); } | consumeOutputFile |
4,696 | void () { try { final Field freelistField = NameTableCleanupDataHolder.freelistField; final Object emptyList = NameTableCleanupDataHolder.emptyList; // both parameters should be non-null if properly initialized if (freelistField != null && emptyList != null) { // the access to static 'freeList' field is synchronized inside javac, so we must use "synchronized" too synchronized (freelistField.getDeclaringClass()) { freelistField.set(null, emptyList); } } } catch (Throwable ignored) { } } | cleanupJavacNameTable |
4,697 | void () { if (zipCacheCleanupPossible) { final Method clearMethod = ZipFileIndexCleanupDataHolder.cacheClearMethod; if (clearMethod != null) { final Method getter = ZipFileIndexCleanupDataHolder.cacheInstanceGetter; try { Object instance = getter != null? getter.invoke(null) : null; clearMethod.invoke(instance); } catch (Throwable e) { zipCacheCleanupPossible = false; } } else { zipCacheCleanupPossible = false; } } } | clearCompilerZipFileCache |
4,698 | void ( com.google.protobuf.ExtensionRegistryLite registry) { } | registerAllExtensions |
4,699 | void ( com.google.protobuf.ExtensionRegistry registry) { registerAllExtensions( (com.google.protobuf.ExtensionRegistryLite) registry); } | registerAllExtensions |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.