Unnamed: 0
int64 0
305k
| body
stringlengths 7
52.9k
| name
stringlengths 1
185
|
|---|---|---|
4,400 |
String () { return myId; }
|
getId
|
4,401 |
String () { return myName; }
|
getName
|
4,402 |
String () { return myUrl; }
|
getUrl
|
4,403 |
JpsRemoteRepositoryService () { return JpsServiceManager.getInstance().getService(JpsRemoteRepositoryService.class); }
|
getInstance
|
4,404 |
JpsServiceManager () { return InstanceHolder.INSTANCE; }
|
getInstance
|
4,405 |
SharedThreadPool () { return JpsServiceManager.getInstance().getService(SharedThreadPool.class); }
|
getInstance
|
4,406 |
Collection<T> () { final Collection<T> cached = myCached; if (cached != null) { return cached; } final ServiceLoader<T> loader = ServiceLoader.load(myExtensionClass, myExtensionClass.getClassLoader()); final List<T> extensions = new ArrayList<>(); for (T extension : loader) { extensions.add(extension); } myCached = extensions; return extensions; }
|
getExtensions
|
4,407 |
Collection<JavaSourceTransformer> () { return ourExtSupport.getExtensions(); }
|
getTransformers
|
4,408 |
String () { return null; }
|
getAlternativeId
|
4,409 |
boolean () { return false; }
|
isCompilerTreeAPISupported
|
4,410 |
List<String> () { return Collections.emptyList(); }
|
getDefaultCompilerOptions
|
4,411 |
void (List<String> options) { }
|
preprocessOptions
|
4,412 |
String () { return ID; }
|
getId
|
4,413 |
String () { return ALTERNATIVE_ID; }
|
getAlternativeId
|
4,414 |
boolean () { return true; }
|
isCompilerTreeAPISupported
|
4,415 |
String () { return "javac " + System.getProperty("java.version"); }
|
getDescription
|
4,416 |
String (final String header, Throwable ex) { StringWriter stringWriter = new StringWriter(); stringWriter.write(header); stringWriter.write(":\n"); ex.printStackTrace(new PrintWriter(stringWriter)); return stringWriter.getBuffer().toString(); }
|
formatErrorMessage
|
4,417 |
List<File> () { return Collections.emptyList(); }
|
getAdditionalClasspath
|
4,418 |
List<String> () { return Collections.singletonList("-implicit:class"); }
|
getDefaultCompilerOptions
|
4,419 |
boolean () { return false; }
|
isCanceled
|
4,420 |
void (int c) { processData(new CharSequenceIterator(c)); }
|
write
|
4,421 |
void (char[] cbuf) { processData(new CharSequenceIterator(cbuf)); }
|
write
|
4,422 |
void (String str) { processData(new CharSequenceIterator(str)); }
|
write
|
4,423 |
void (String str, int off, int len) { processData(new CharSequenceIterator(str.subSequence(off, off + len))); }
|
write
|
4,424 |
Writer (CharSequence csq) { processData(new CharSequenceIterator(csq)); return this; }
|
append
|
4,425 |
Writer (CharSequence csq, int start, int end) { processData(new CharSequenceIterator(csq.subSequence(start, end))); return this; }
|
append
|
4,426 |
Writer (char c) { processData(new CharSequenceIterator(c)); return this; }
|
append
|
4,427 |
void (char[] cbuf, int off, int len) { processData(new CharSequenceIterator(cbuf, off, len)); }
|
write
|
4,428 |
void (CharIterator data) { while (myLineParser.parse(data)) { final String line = myLineParser.getResult(); myLineParser.reset(); lineAvailable(line); } }
|
processData
|
4,429 |
boolean (CharIterator it) { while (it.hasData()) { final char ch = it.nextChar(); if (ch == '\r') { myFoundCR = true; } else if (ch == '\n') { myFoundCR = false; return true; } else { if (myFoundCR) { myData.append('\r'); myFoundCR = false; } myData.append(ch); } } return false; }
|
parse
|
4,430 |
boolean () { return myData.length() > 0; }
|
hasData
|
4,431 |
String () { return myData.toString(); }
|
getResult
|
4,432 |
void () { myFoundCR = false; myData.setLength(0); }
|
reset
|
4,433 |
char () { return myChars.charAt(myCursor++); }
|
nextChar
|
4,434 |
boolean () { return myCursor < myChars.length(); }
|
hasData
|
4,435 |
int () { return 1; }
|
length
|
4,436 |
char (int index) { if (index != 0) { throw new IndexOutOfBoundsException("Index out of bounds: " + index); } return myCh; }
|
charAt
|
4,437 |
CharSequence (int start, int end) { throw new RuntimeException("Method subSequence not implemented"); }
|
subSequence
|
4,438 |
String () { return String.valueOf(myCh); }
|
toString
|
4,439 |
byte[] () { return myBuffer; }
|
getBuffer
|
4,440 |
int () { return myOffset; }
|
getOffset
|
4,441 |
int () { return myLength; }
|
getLength
|
4,442 |
byte[] () { return Arrays.copyOfRange(myBuffer, myOffset, myOffset + myLength); }
|
toByteArray
|
4,443 |
JpsJavacFileManager () { return myFileManager; }
|
getFileManager
|
4,444 |
ProcessingEnvironment (ProcessingEnvironment processingEnv) { ProcessingEnvironment wrapped = myWrappers.get(processingEnv); if (wrapped == null) { myWrappers.put(processingEnv, wrapped = wrap(ProcessingEnvironment.class, new ProcessingEnvironmentWrapper(processingEnv, myFileManager))); } return wrapped; }
|
getWrappedProcessingEnvironment
|
4,445 |
String (Processor proc) { return (proc instanceof WrapperDelegateAccessor<?>? ((WrapperDelegateAccessor<?>)proc).getWrapperDelegate() : proc).getClass().getName(); }
|
getProcessorName
|
4,446 |
Iterable<Processor> (Iterable<? extends Processor> processors) { return myAllProcessors = Iterators.map(processors, new Function<Processor, Processor>() { @Override public Processor fun(Processor processor) { return wrap(Processor.class, new ProcessorWrapper(processor, ProcessingContext.this)); } }); }
|
wrapProcessors
|
4,447 |
Processor (Processor processor) { return wrap(Processor.class, new ProcessorWrapper(processor, ProcessingContext.this)); }
|
fun
|
4,448 |
String (String message) { if (message != null) { try { final String realProcName = myLastProcName; if (realProcName != null && !realProcName.isEmpty()) { final String wrappedName = lookupWrappedProcName(realProcName); if (wrappedName != null) { return message.replace(wrappedName, realProcName); } } } catch (Throwable ignored) { //iterating namesMap may cause unexpected AP class loading exceptions } } return message; }
|
adjustMessage
|
4,449 |
String (String procName) { String wrappedName = myProcNamesMap.get(procName); if (wrappedName == null) { for (Processor proc : myAllProcessors) { if (proc instanceof WrapperDelegateAccessor<?>) { myProcNamesMap.put(getProcessorName(proc), proc.getClass().getName()); } } wrappedName = myProcNamesMap.get(procName); } return wrappedName; }
|
lookupWrappedProcName
|
4,450 |
T () { return myDelegate; }
|
getWrapperDelegate
|
4,451 |
void (String line) { getWrapperDelegate().outputLineAvailable(myProcContext.adjustMessage(line)); }
|
outputLineAvailable
|
4,452 |
void (Diagnostic<? extends T> diagnostic) { getWrapperDelegate().report(wrap(Diagnostic.class, new DiagnosticWrapper<>(myProcContext, (Diagnostic<T>)diagnostic))); }
|
report
|
4,453 |
String (Locale locale) { return myProcContext.adjustMessage(getWrapperDelegate().getMessage(locale)); }
|
getMessage
|
4,454 |
void (ProcessingEnvironment processingEnv) { myProcessingEnv = processingEnv; final Ref<ClassLoader> oldCtxLoader = setupContextClassLoader(); try { getWrapperDelegate().init(myProcessingContext.getWrappedProcessingEnvironment(processingEnv)); } catch (IllegalArgumentException e) { sendDiagnosticWarning(processingEnv, e); throw e; } finally { restoreContextClassLoader(oldCtxLoader); } }
|
init
|
4,455 |
boolean (Set<? extends TypeElement> annotations, RoundEnvironment roundEnv) { final Ref<ClassLoader> oldCtxLoader = setupContextClassLoader(); try { final Processor delegate = getWrapperDelegate(); myProcessingContext.setLastExecutedProcessorName(delegate); return delegate.process(annotations, roundEnv); } catch (IllegalArgumentException e) { sendDiagnosticWarning(myProcessingEnv, e); throw e; } finally { restoreContextClassLoader(oldCtxLoader); } }
|
process
|
4,456 |
Ref<ClassLoader> () { final Processor delegate = getWrapperDelegate(); if (delegate != null) { final Thread currentThread = Thread.currentThread(); final ClassLoader processorLoader = delegate.getClass().getClassLoader(); final ClassLoader currentCtxLoader = currentThread.getContextClassLoader(); if (processorLoader != currentCtxLoader) { currentThread.setContextClassLoader(processorLoader); return Ref.create(currentCtxLoader); } } return null; }
|
setupContextClassLoader
|
4,457 |
void (@Nullable Ref<ClassLoader> loaderRef) { if (loaderRef != null) { Thread.currentThread().setContextClassLoader(loaderRef.get()); } }
|
restoreContextClassLoader
|
4,458 |
void (ProcessingEnvironment processingEnv, Throwable e) { if (processingEnv != null && !myCodeShown) { processingEnv.getMessager().printMessage( Diagnostic.Kind.MANDATORY_WARNING, "The " + e.getClass() + " may be caused by the wrapped ProcessingEnvironment object.\n" + "Please pass the wrapped ProcessingEnvironment further to super.init().\n"+ "If you need to access the original ProcessingEnvironment object (e.g. for creating com.sun.source.util.Trees.instance(ProcessingEnvironment)), you may use following code in the processor implementation:\n\n" + getUnwrapCodeSuggestion(ProcessingEnvironment.class, "processingEnv") ); processingEnv.getMessager().printMessage( Diagnostic.Kind.MANDATORY_WARNING, "Workaround: to make project compile with the current annotation processor implementation, start JPS with VM option: -D"+JavacMain.TRACK_AP_GENERATED_DEPENDENCIES_PROPERTY + "=false\n" + "When run from IDE, the option can be set in \"Compiler Settings | build process VM options\"" ); myCodeShown = true; } }
|
sendDiagnosticWarning
|
4,459 |
Filer () { Filer impl = myFilerImpl; if (impl == null) { final Filer delegateFiler = getWrapperDelegate().getFiler(); myFilerImpl = impl = wrap(Filer.class, new FilerWrapper(delegateFiler, myFileManager, getWrapperDelegate().getElementUtils())); } return impl; }
|
getFiler
|
4,460 |
void (CharSequence resourceName, final Collection<? extends Element> elements) { if (resourceName != null && resourceName.length() > 0 && !elements.isEmpty()) { myFileManager.addAnnotationProcessingClassMapping(resourceName.toString(), Iterators.filter(Iterators.map(elements, convertToClassName), Iterators.notNullFilter())); } }
|
addMapping
|
4,461 |
T () { return delegateTo; }
|
getWrapperDelegate
|
4,462 |
String (Element element) { Name qName = null; while (element != null) { if (element instanceof TypeElement) { qName = ((TypeElement)element).getQualifiedName(); } else if (element instanceof PackageElement) { qName = ((PackageElement)element).getQualifiedName(); } else if (ourGetQualifiedNameMethod != null && ourGetQualifiedNameMethod.getDeclaringClass().isAssignableFrom(element.getClass())) { try { qName = (Name)ourGetQualifiedNameMethod.invoke(element); } catch (Throwable ignored) { } } if (qName != null) { if (!qName.equals(myEmptyName)) { return qName.toString(); } qName = null; } element = element.getEnclosingElement(); } return null; }
|
fun
|
4,463 |
String (Class<?> ifaceClass, String objVarName) { return ifaceClass.getSimpleName() + " unwrapped" + objVarName + " = " + "jbUnwrap(" + ifaceClass.getSimpleName() + ".class, " + objVarName + ");" + "\n\n\t\twhere\n\n" + "private static <T> T jbUnwrap(Class<? extends T> iface, T wrapper) {\n" + " T unwrapped = null;\n" + " try {\n" + " final Class<?> apiWrappers = wrapper.getClass().getClassLoader().loadClass(\"org.jetbrains.jps.javac.APIWrappers\");\n" + " final Method unwrapMethod = apiWrappers.getDeclaredMethod(\"unwrap\", Class.class, Object.class);\n" + " unwrapped = iface.cast(unwrapMethod.invoke(null, iface, wrapper));\n" + " }\n" + " catch (Throwable ignored) {}\n" + " return unwrapped != null? unwrapped : wrapper;\n" + "}"; }
|
getUnwrapCodeSuggestion
|
4,464 |
URI (final File zipFile, String relPath) { final String p = FileUtilRt.toSystemIndependentName(zipFile.getPath()); final StringBuilder buf = new StringBuilder(p.length() + relPath.length() + 5); if (!p.startsWith("/")) { buf.append("///"); } else if (!p.startsWith("//")) { buf.append("//"); } buf.append(p).append(relPath.startsWith("/") ? "!" : "!/").append(relPath); try { return new URI("jar", null, buf.toString(), null); } catch (URISyntaxException e) { throw new Error("Cannot create URI " + buf, e); } }
|
createUri
|
4,465 |
long () { return myEntry.getTime(); }
|
getLastModified
|
4,466 |
boolean () { throw new UnsupportedOperationException(); }
|
delete
|
4,467 |
String (Iterable<? extends File> path, final boolean caseSensitiveFS) { final String name = myEntry.getName(); int idx = name.lastIndexOf("."); return (idx < 0 ? name : name.substring(0, idx)).replace('/', '.'); }
|
inferBinaryName
|
4,468 |
boolean (@NotNull String cn, Kind kind) { if (kind == Kind.OTHER) { return getKind() == kind; } if (getKind() != kind) { return false; } final String name = myEntry.getName(); return name.length() == (cn.length() + kind.extension.length()) && name.startsWith(cn) && name.endsWith(kind.extension); }
|
isNameCompatible
|
4,469 |
boolean (Object other) { return other instanceof ZipFileObject && super.equals(other); }
|
equals
|
4,470 |
Iterator<File> () { return Collections.emptyIterator(); }
|
iterator
|
4,471 |
String () { return "NULL_ITERABLE"; }
|
toString
|
4,472 |
Iterable<JavaFileObject> (String relPath, Set<JavaFileObject.Kind> kinds, boolean recurse) { return Collections.emptyList(); }
|
list
|
4,473 |
void () { }
|
close
|
4,474 |
String () { return "NULL_ARCHIVE"; }
|
toString
|
4,475 |
Iterable<File> (final File file, final boolean recursively) { final Iterable<File> childrenIterable = Iterators.lazy(new Iterators.Provider<Iterable<File>>() { @Override public Iterable<File> get() { final Iterable<File> children = listChildren(file); return children == null? Collections.<File>emptyList() : children; } }); return !recursively? childrenIterable : Iterators.flat(Iterators.map(childrenIterable, new Function<File, Iterable<File>>() { @Override public Iterable<File> fun(File ff) { return asRecursiveIterable(ff); } })); }
|
listFiles
|
4,476 |
Iterable<File> () { final Iterable<File> children = listChildren(file); return children == null? Collections.<File>emptyList() : children; }
|
get
|
4,477 |
Iterable<File> (File ff) { return asRecursiveIterable(ff); }
|
fun
|
4,478 |
Iterable<File> (final File file) { return Iterators.flat(Iterators.map(Iterators.asIterable(file), new Function<File, Iterable<File>>() { @Override public Iterable<File> fun(File f) { final Iterable<File> children = listChildren(f); if (children == null) { // not a dir return Iterators.asIterable(f); } if (Iterators.isEmptyCollection(children)) { return children; } return Iterators.flat(Iterators.map(children, new Function<File, Iterable<File>>() { @Override public Iterable<File> fun(File ff) { return asRecursiveIterable(ff); } })); } })); }
|
asRecursiveIterable
|
4,479 |
Iterable<File> (File f) { final Iterable<File> children = listChildren(f); if (children == null) { // not a dir return Iterators.asIterable(f); } if (Iterators.isEmptyCollection(children)) { return children; } return Iterators.flat(Iterators.map(children, new Function<File, Iterable<File>>() { @Override public Iterable<File> fun(File ff) { return asRecursiveIterable(ff); } })); }
|
fun
|
4,480 |
Iterable<File> (File ff) { return asRecursiveIterable(ff); }
|
fun
|
4,481 |
boolean (File file) { Boolean cachedIsFile = myIsFile.get(file); if (cachedIsFile == null) { myIsFile.put(file, cachedIsFile = file.isFile()); } return cachedIsFile.booleanValue(); }
|
isFile
|
4,482 |
void (@Nullable File file) { if (file != null) { myDirectoryCache.clear(); final Archive arch = myArchiveCache.remove(file); if (arch != null) { try { arch.close(); } catch (IOException ignored) { } } } else { myDirectoryCache.clear(); myIsFile.clear(); final Map<File, FileOperations.Archive> archCache = myArchiveCache; for (Map.Entry<File, FileOperations.Archive> entry : archCache.entrySet()) { try { entry.getValue().close(); } catch (Throwable ignored) { } } archCache.clear(); } }
|
clearCaches
|
4,483 |
Archive (File file) { final Archive arch = myArchiveCache.get(file); return arch == NULL_ARCHIVE ? null : arch; }
|
lookupArchive
|
4,484 |
Iterable<File> (File file) { Iterable<File> cached = myDirectoryCache.get(file); if (cached == null) { final Iterable<File> parentFiles = lookupCachedParent(file); if (parentFiles == null || (parentFiles != NULL_ITERABLE && !Iterators.isEmptyCollection(parentFiles))) { try { cached = listFiles(file); } catch (IOException e) { throw new RuntimeException(e); } } myDirectoryCache.put(file, cached == null? NULL_ITERABLE : cached); } return cached == NULL_ITERABLE? null : cached; }
|
listChildren
|
4,485 |
Iterable<File> (File file) { if (!myDirectoryCache.isEmpty()) { File parent = file.getParentFile(); for (int i = 0; i < 10 && parent != null; i++) { // at most 10 levels upwards final Iterable<File> cached = myDirectoryCache.get(parent); if (cached != null) { return cached; } parent = parent.getParentFile(); } } return null; }
|
lookupCachedParent
|
4,486 |
String (ZipEntry zipEntry) { return zipEntry.getName(); }
|
fun
|
4,487 |
JavaFileObject (ZipEntry zipEntry) { return new ZipFileObject(root, myZip, zipEntry, encodingName, location); }
|
fun
|
4,488 |
boolean (Map.Entry<String, Collection<ZipEntry>> e) { final String dir = e.getKey(); return dir.startsWith(relPath) && (dir.length() == relPath.length() || dir.charAt(relPath.length()) == '/'); }
|
fun
|
4,489 |
Iterable<ZipEntry> (Map.Entry<String, Collection<ZipEntry>> e) { return e.getValue(); }
|
fun
|
4,490 |
String (String path) { int idx = path.lastIndexOf('/'); if (idx == path.length() - 1) { // the very last char idx = path.lastIndexOf('/', idx - 1); } if (idx < 0) { return ""; } return path.substring(0, idx); }
|
getParentPath
|
4,491 |
boolean () { return getPath().isEmpty(); }
|
isEmpty
|
4,492 |
String (File pathElement) { return null; }
|
getModuleName
|
4,493 |
ModulePath (Collection<? extends File> path) { if (path.isEmpty()) { return EMPTY; } final Collection<File> files = Collections.unmodifiableCollection(path); return new ModulePath() { @Override public Collection<? extends File> getPath() { return files; } @Override public String getModuleName(File pathElement) { return null; } }; }
|
create
|
4,494 |
String (File pathElement) { return null; }
|
getModuleName
|
4,495 |
Builder () { return new Builder() { private final Map<File, String> myMap = new HashMap<>(); private final Collection<File> myPath = new ArrayList<>(); @Override public Builder add(String moduleName, File pathElement) { myPath.add(pathElement); if (moduleName != null) { myMap.put(pathElement, moduleName); } return this; } @Override public ModulePath create() { if (myPath.isEmpty()) { return EMPTY; } final Collection<File> files = Collections.unmodifiableCollection(myPath); return new ModulePath() { @Override public Collection<? extends File> getPath() { return files; } @Override public String getModuleName(File pathElement) { return myMap.get(pathElement); } }; } }; }
|
newBuilder
|
4,496 |
Builder (String moduleName, File pathElement) { myPath.add(pathElement); if (moduleName != null) { myMap.put(pathElement, moduleName); } return this; }
|
add
|
4,497 |
ModulePath () { if (myPath.isEmpty()) { return EMPTY; } final Collection<File> files = Collections.unmodifiableCollection(myPath); return new ModulePath() { @Override public Collection<? extends File> getPath() { return files; } @Override public String getModuleName(File pathElement) { return myMap.get(pathElement); } }; }
|
create
|
4,498 |
String (File pathElement) { return myMap.get(pathElement); }
|
getModuleName
|
4,499 |
String (LogRecord record) { return record.getMessage() + "\n"; }
|
format
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.