Datasets:
Mlxa
/
java_methods

Dataset card Data Studio Files
xet
 Community
1
Unnamed: 0
int64
0
305k
body
stringlengths
7
52.9k
name
stringlengths
1
185
248,600
CompositeParameterTargetedValue (@NotNull String localValue, @NotNull Promise<String> remoteValue) { myValues.add(new ParameterTargetValuePart.PromiseValue(localValue, remoteValue)); return this; }
addTargetPart
248,601
String () { if (myValues.isEmpty()) return ""; if (myValues.size() == 1) return myValues.get(0).getLocalValue(); StringBuilder value = new StringBuilder(); for (ParameterTargetValue parameterTargetValue : myValues) { value.append(parameterTargetValue.getLocalValue()); } return value.toString(); }
getLocalValue
248,602
List<ParameterTargetValuePart> () { return Collections.unmodifiableList(myValues); }
getParts
248,603
String () { if (myValues.isEmpty()) return ""; if (myValues.size() == 1) { return myValues.get(0).toString(); } return myValues.toString(); }
toString
248,604
boolean (@NotNull @NonNls String parameter) { return ContainerUtil.lastIndexOf(myParameters, value -> parameter.equals(value.getLocalValue())) != -1; }
hasParameter
248,605
boolean (@NotNull @NonNls String propertyName) { return getPropertyValue(propertyName) != null; }
hasProperty
248,606
String (@NotNull @NonNls String propertyName) { String exact = "-D" + propertyName; String prefix = "-D" + propertyName + "="; int index = indexOfLocalParameter(o -> o.equals(exact) || o.startsWith(prefix)); if (index < 0) return null; String str = myParameters.get(index).getLocalValue(); return str.length() == exact.l...
getPropertyValue
248,607
String () { return join(getList()); }
getParametersString
248,608
List<String> () { if (myGroups.isEmpty()) { return getLocalParameters(); } List<String> params = new ArrayList<>(getLocalParameters()); for (ParamsGroup group : myGroups) { params.addAll(group.getParameters()); } return Collections.unmodifiableList(params); }
getList
248,609
List<CompositeParameterTargetedValue> () { if (myGroups.isEmpty()) { return Collections.unmodifiableList(myParameters); } List<CompositeParameterTargetedValue> params = new ArrayList<>(myParameters); for (ParamsGroup group : myGroups) { params.addAll(CompositeParameterTargetedValue.targetizeParameters(group.getParamete...
getTargetedList
248,610
List<String> () { return ContainerUtil.map(myParameters, CompositeParameterTargetedValue::getLocalValue); }
getLocalParameters
248,611
CompositeParameterTargetedValue (String param) { return new CompositeParameterTargetedValue(expandMacros(param)); }
createExpandedLocalValue
248,612
void () { myParameters.clear(); myGroups.clear(); }
clearAll
248,613
void (@NotNull @NonNls String parameter) { addAt(0, parameter); }
prepend
248,614
void (@Nullable CompositeParameterTargetedValue parameterTargetedValue) { myParameters.add(0, parameterTargetedValue); }
prepend
248,615
void (@NonNls String @NotNull ... parameter) { addAll(parameter); Collections.rotate(myParameters, parameter.length); }
prependAll
248,616
void (@Nullable @NonNls String parameters) { if (StringUtil.isEmptyOrSpaces(parameters)) return; for (String param : parse(parameters)) { add(param); } }
addParametersString
248,617
void (@Nullable @NonNls String parameter) { if (parameter == null) return; myParameters.add(createExpandedLocalValue(parameter)); }
add
248,618
void (@Nullable CompositeParameterTargetedValue parameterTargetedValue) { if (parameterTargetedValue == null) return; myParameters.add(parameterTargetedValue); }
add
248,619
ParamsGroup (@NotNull @NonNls String groupId) { return addParamsGroup(new ParamsGroup(groupId)); }
addParamsGroup
248,620
ParamsGroup (@NotNull ParamsGroup group) { myGroups.add(group); return group; }
addParamsGroup
248,621
ParamsGroup (int index, @NotNull ParamsGroup group) { myGroups.add(index, group); return group; }
addParamsGroupAt
248,622
ParamsGroup (int index, @NotNull @NonNls String groupId) { ParamsGroup group = new ParamsGroup(groupId); myGroups.add(index, group); return group; }
addParamsGroupAt
248,623
int () { return myParameters.size(); }
getParametersCount
248,624
int () { return myGroups.size(); }
getParamsGroupsCount
248,625
List<String> () { return getLocalParameters(); }
getParameters
248,626
List<ParamsGroup> () { return Collections.unmodifiableList(myGroups); }
getParamsGroups
248,627
ParamsGroup (int index) { return myGroups.get(index); }
getParamsGroupAt
248,628
ParamsGroup (@NotNull @NonNls String name) { for (ParamsGroup group : myGroups) { if (name.equals(group.getId())) return group; } return null; }
getParamsGroup
248,629
ParamsGroup (int index) { return myGroups.remove(index); }
removeParamsGroup
248,630
void (int index, @NotNull @NonNls String parameter) { myParameters.add(index, createExpandedLocalValue(parameter)); }
addAt
248,631
void (@NotNull @NonNls String propertyName) { defineProperty(propertyName, System.getProperty(propertyName)); }
defineSystemProperty
248,632
void (@NotNull @NonNls String propertyName, @Nullable @NonNls String propertyValue) { if (propertyValue == null) return; @NlsSafe String exact = "-D" + propertyName; @NlsSafe String prefix = "-D" + propertyName + "="; int index = indexOfLocalParameter(o -> o.equals(exact) || o.startsWith(prefix)); if (index > -1) retur...
defineProperty
248,633
void (@NotNull @NonNls String propertyName) { @NlsSafe String exact = "-D" + propertyName; @NlsSafe String prefix = "-D" + propertyName + "="; replaceOrAddAt(new CompositeParameterTargetedValue(exact), myParameters.size(), o -> o.equals(exact) || o.startsWith(prefix)); }
addProperty
248,634
void (@NotNull @NonNls String propertyName, @Nullable @NonNls String propertyValue) { if (propertyValue == null) return; @NlsSafe String exact = "-D" + propertyName; @NlsSafe String prefix = "-D" + propertyName + "="; String value = propertyValue.isEmpty() ? exact : prefix + expandMacros(propertyValue); replaceOrAddAt(...
addProperty
248,635
void (@NotNull @NonNls String propertyName, @Nullable @NonNls String propertyValue) { if (StringUtil.isEmptyOrSpaces(propertyValue)) return; addProperty(propertyName, propertyValue); }
addNotEmptyProperty
248,636
void (@NotNull @NonNls String parameterPrefix, @NotNull @NonNls String replacement) { replaceOrAddAt(createExpandedLocalValue(replacement), myParameters.size(), o -> o.startsWith(parameterPrefix)); }
replaceOrAppend
248,637
void (@NotNull @NonNls String parameterPrefix, @NotNull @NonNls String replacement) { replaceOrAddAt(createExpandedLocalValue(replacement), 0, o -> o.startsWith(parameterPrefix)); }
replaceOrPrepend
248,638
void (@NotNull CompositeParameterTargetedValue replacement, int position, @NotNull Condition<? super String> existingCondition) { int index = indexOfLocalParameter(existingCondition); boolean setNewValue = StringUtil.isNotEmpty(replacement.getLocalValue()); if (index > -1 && setNewValue) { myParameters.set(index, repla...
replaceOrAddAt
248,639
int (@NotNull @NonNls Condition<? super String> condition) { return ContainerUtil.lastIndexOf(myParameters, value -> condition.value(value.getLocalValue())); }
indexOfLocalParameter
248,640
void (int ind, @NotNull @NonNls String value) { myParameters.set(ind, new CompositeParameterTargetedValue(value)); }
set
248,641
String (int ind) { return myParameters.get(ind).getLocalValue(); }
get
248,642
String () { return myParameters.size() > 0 ? myParameters.get(myParameters.size() - 1).getLocalValue() : null; }
getLast
248,643
void (@NotNull @NonNls String name, @NotNull @NonNls String value) { myParameters.add(new CompositeParameterTargetedValue(name)); // do not expand macros in parameter name add(value); }
add
248,644
void (@NonNls String @NotNull ... parameters) { addAll(Arrays.asList(parameters)); }
addAll
248,645
void (@NotNull @NonNls List<String> parameters) { // Don't use myParameters.addAll(parameters) , it does not call expandMacros(parameter) for (String parameter : parameters) { add(parameter); } }
addAll
248,646
ParametersList () { return copyTo(new ParametersList()); }
clone
248,647
ParametersList (@NotNull ParametersList target) { target.myParameters.addAll(myParameters); for (ParamsGroup group : myGroups) { target.myGroups.add(group.clone()); } return target; }
copyTo
248,648
String (@NotNull @NonNls List<String> parameters) { return ParametersListUtil.join(parameters); }
join
248,649
String (@NonNls String @NotNull ... parameters) { return ParametersListUtil.join(parameters); }
join
248,650
String (@NotNull @NonNls String text) { int start = text.indexOf("${"); if (start < 0) return text; Map<String, String> macroMap = myMacroMap.getValue(); Matcher matcher = MACRO_PATTERN.matcher(text); StringBuilder sb = null; while (matcher.find(start)) { String value = macroMap.get(matcher.group(1)); if (value != null...
expandMacros
248,651
void (Map<String, String> envs) { myMacroMap.getValue().putAll(envs); }
patchMacroWithEnvs
248,652
void (@Nullable @NonNls Map<String, String> testMacros) { ourTestMacros = testMacros; }
setTestMacros
248,653
String () { return myParameters + (myGroups.isEmpty() ? "" : " and " + myGroups); }
toString
248,654
String () { return myGroupId; }
getId
248,655
void (@NotNull String parameter) { myParamList.add(parameter); }
addParameter
248,656
void (int index, @NotNull String parameter) { myParamList.addAt(index, parameter); }
addParameterAt
248,657
void (@NotNull String @NotNull ... parameters) { for (String parameter : parameters) { addParameter(parameter); } }
addParameters
248,658
void (@NotNull List<String> parameters) { for (String parameter : parameters) { addParameter(parameter); } }
addParameters
248,659
void (@NotNull String parametersString) { addParameters(ParametersList.parse(parametersString)); }
addParametersString
248,660
List<String> () { return myParamList.getList(); }
getParameters
248,661
ParametersList () { return myParamList; }
getParametersList
248,662
ParamsGroup () { return new ParamsGroup(myGroupId, myParamList.clone()); }
clone
248,663
String () { return myGroupId + ":" + myParamList; }
toString
248,664
File (@NotNull @NonNls String fileBaseName) { return findInPath(fileBaseName, null); }
findInPath
248,665
File (@NotNull String fileBaseName, @Nullable FileFilter filter) { return findInPath(fileBaseName, getPathVariableValue(), filter); }
findInPath
248,666
File (@NotNull String fileBaseName, @Nullable String pathVariableValue, @Nullable FileFilter filter) { List<File> exeFiles = findExeFilesInPath(true, filter, pathVariableValue, fileBaseName); return ContainerUtil.getFirstItem(exeFiles); }
findInPath
248,667
List<File> (@NotNull String fileBaseName) { return findAllExeFilesInPath(fileBaseName, null); }
findAllExeFilesInPath
248,668
List<File> (@NotNull String fileBaseName, @Nullable FileFilter filter) { return findExeFilesInPath(false, filter, getPathVariableValue(), fileBaseName); }
findAllExeFilesInPath
248,669
List<File> (boolean stopAfterFirstMatch, @Nullable FileFilter filter, @Nullable String pathEnvVarValue, String @NotNull ... fileBaseNames) { if (pathEnvVarValue == null) { return Collections.emptyList(); } List<File> result = new SmartList<>(); List<String> dirPaths = getPathDirs(pathEnvVarValue); for (String dirPath :...
findExeFilesInPath
248,670
List<String> (@NotNull String pathEnvVarValue) { return StringUtil.split(pathEnvVarValue, File.pathSeparator, true, true); }
getPathDirs
248,671
List<String> () { if (SystemInfo.isWindows) { String allExtensions = System.getenv("PATHEXT"); if (allExtensions != null) { Collection<String> extensions = StringUtil.split(allExtensions, ";", true, true); extensions = ContainerUtil.filter(extensions, s -> !StringUtil.isEmpty(s) && s.startsWith(".")); return ContainerU...
getWindowsExecutableFileExtensions
248,672
String (@NotNull String exePath) { return findExecutableInWindowsPath(exePath, exePath); }
findExecutableInWindowsPath
248,673
String (@NotNull String exePath, @Nullable String defaultPath) { if (SystemInfo.isWindows) { if (!StringUtil.containsChar(exePath, '/') && !StringUtil.containsChar(exePath, '\\')) { List<String> executableFileExtensions = getWindowsExecutableFileExtensions(); String[] baseNames = ContainerUtil.map2Array(executableFileE...
findExecutableInWindowsPath
248,674
String () { return EnvironmentUtil.getValue(PATH); }
getPathVariableValue
248,675
File (@NotNull @NonNls String fileBaseName) { if (SystemInfo.isWindows) { String[] fileNames = ContainerUtil.map2Array(getWindowsExecutableFileExtensions(), String.class, (String extension) -> fileBaseName + extension); List<File> exeFiles = findExeFilesInPath(true, null, getPathVariableValue(), fileNames); return Cont...
findExecutableInPathOnAnyOS
248,676
Charset () { return LoadingState.COMPONENTS_LOADED.isOccurred() ? EncodingManager.getInstance().getDefaultConsoleEncoding() : Charset.defaultCharset(); }
defaultCharset
248,677
GeneralCommandLine (@NotNull String exePath) { myExePath = exePath.trim(); return this; }
withExePath
248,678
void (@NotNull String exePath) { withExePath(exePath); }
setExePath
248,679
File () { return myWorkDirectory; }
getWorkDirectory
248,680
GeneralCommandLine (@Nullable String path) { return withWorkDirectory(path != null ? new File(path) : null); }
withWorkDirectory
248,681
GeneralCommandLine (@Nullable File workDirectory) { myWorkDirectory = workDirectory; return this; }
withWorkDirectory
248,682
void (@Nullable String path) { withWorkDirectory(path); }
setWorkDirectory
248,683
void (@Nullable File workDirectory) { withWorkDirectory(workDirectory); }
setWorkDirectory
248,684
GeneralCommandLine (@Nullable Map<String, String> environment) { if (environment != null) { getEnvironment().putAll(environment); } return this; }
withEnvironment
248,685
GeneralCommandLine (@NotNull String key, @NotNull String value) { getEnvironment().put(key, value); return this; }
withEnvironment
248,686
boolean () { return myParentEnvironmentType != ParentEnvironmentType.NONE; }
isPassParentEnvironment
248,687
void (boolean passParentEnvironment) { withParentEnvironmentType(passParentEnvironment ? ParentEnvironmentType.CONSOLE : ParentEnvironmentType.NONE); }
setPassParentEnvironment
248,688
ParentEnvironmentType () { return myParentEnvironmentType; }
getParentEnvironmentType
248,689
GeneralCommandLine (@NotNull ParentEnvironmentType type) { myParentEnvironmentType = type; return this; }
withParentEnvironmentType
248,690
void (String @NotNull ... parameters) { withParameters(parameters); }
addParameters
248,691
void (@NotNull List<String> parameters) { withParameters(parameters); }
addParameters
248,692
GeneralCommandLine (@NotNull String @NotNull ... parameters) { for (String parameter : parameters) addParameter(parameter); return this; }
withParameters
248,693
GeneralCommandLine (@NotNull List<String> parameters) { for (String parameter : parameters) addParameter(parameter); return this; }
withParameters
248,694
void (@NotNull String parameter) { myProgramParams.add(parameter); }
addParameter
248,695
ParametersList () { return myProgramParams; }
getParametersList
248,696
Charset () { return myCharset; }
getCharset
248,697
GeneralCommandLine (@NotNull Charset charset) { myCharset = charset; return this; }
withCharset
248,698
void (@NotNull Charset charset) { withCharset(charset); }
setCharset
248,699
boolean () { return myRedirectErrorStream; }
isRedirectErrorStream