repo stringlengths 7 58 | path stringlengths 12 218 | func_name stringlengths 3 140 | original_string stringlengths 73 34.1k | language stringclasses 1 value | code stringlengths 73 34.1k | code_tokens list | docstring stringlengths 3 16k | docstring_tokens list | sha stringlengths 40 40 | url stringlengths 105 339 | partition stringclasses 1 value |
|---|---|---|---|---|---|---|---|---|---|---|---|
spotbugs/spotbugs | spotbugs/src/main/java/edu/umd/cs/findbugs/ba/SourceFinder.java | SourceFinder.openSource | public InputStream openSource(String packageName, String fileName) throws IOException {
SourceFile sourceFile = findSourceFile(packageName, fileName);
return sourceFile.getInputStream();
} | java | public InputStream openSource(String packageName, String fileName) throws IOException {
SourceFile sourceFile = findSourceFile(packageName, fileName);
return sourceFile.getInputStream();
} | [
"public",
"InputStream",
"openSource",
"(",
"String",
"packageName",
",",
"String",
"fileName",
")",
"throws",
"IOException",
"{",
"SourceFile",
"sourceFile",
"=",
"findSourceFile",
"(",
"packageName",
",",
"fileName",
")",
";",
"return",
"sourceFile",
".",
"getIn... | Open an input stream on a source file in given package.
@param packageName
the name of the package containing the class whose source file
is given
@param fileName
the unqualified name of the source file
@return an InputStream on the source file
@throws IOException
if a matching source file cannot be found | [
"Open",
"an",
"input",
"stream",
"on",
"a",
"source",
"file",
"in",
"given",
"package",
"."
] | f6365c6eea6515035bded38efa4a7c8b46ccf28c | https://github.com/spotbugs/spotbugs/blob/f6365c6eea6515035bded38efa4a7c8b46ccf28c/spotbugs/src/main/java/edu/umd/cs/findbugs/ba/SourceFinder.java#L442-L445 | train |
spotbugs/spotbugs | spotbugs/src/main/java/edu/umd/cs/findbugs/ba/SourceFinder.java | SourceFinder.findSourceFile | public SourceFile findSourceFile(String packageName, String fileName) throws IOException {
// On windows the fileName specification is different between a file in
// a directory tree, and a
// file in a zip file. In a directory tree the separator used is '\',
// while in a zip it's '/'
// Therefore for each repository figure out what kind it is and use the
// appropriate separator.
// In all practicality, this code could just use the hardcoded '/' char,
// as windows can open
// files with this separator, but to allow for the mythical 'other'
// platform that uses an
// alternate separator, make a distinction
String platformName = getPlatformName(packageName, fileName);
String canonicalName = getCanonicalName(packageName, fileName);
// Is the file in the cache already? Always cache it with the canonical
// name
SourceFile sourceFile = cache.get(canonicalName);
if (sourceFile != null) {
return sourceFile;
}
// Find this source file, add its data to the cache
if (DEBUG) {
System.out.println("Trying " + fileName + " in package " + packageName + "...");
}
// Query each element of the source path to find the requested source
// file
for (SourceRepository repos : repositoryList) {
if (repos instanceof BlockingSourceRepository && !((BlockingSourceRepository) repos).isReady()) {
continue;
}
fileName = repos.isPlatformDependent() ? platformName : canonicalName;
if (DEBUG) {
System.out.println("Looking in " + repos + " for " + fileName);
}
if (repos.contains(fileName)) {
// Found it
sourceFile = new SourceFile(repos.getDataSource(fileName));
cache.put(canonicalName, sourceFile); // always cache with
// canonicalName
return sourceFile;
}
}
throw new FileNotFoundException("Can't find source file " + fileName);
} | java | public SourceFile findSourceFile(String packageName, String fileName) throws IOException {
// On windows the fileName specification is different between a file in
// a directory tree, and a
// file in a zip file. In a directory tree the separator used is '\',
// while in a zip it's '/'
// Therefore for each repository figure out what kind it is and use the
// appropriate separator.
// In all practicality, this code could just use the hardcoded '/' char,
// as windows can open
// files with this separator, but to allow for the mythical 'other'
// platform that uses an
// alternate separator, make a distinction
String platformName = getPlatformName(packageName, fileName);
String canonicalName = getCanonicalName(packageName, fileName);
// Is the file in the cache already? Always cache it with the canonical
// name
SourceFile sourceFile = cache.get(canonicalName);
if (sourceFile != null) {
return sourceFile;
}
// Find this source file, add its data to the cache
if (DEBUG) {
System.out.println("Trying " + fileName + " in package " + packageName + "...");
}
// Query each element of the source path to find the requested source
// file
for (SourceRepository repos : repositoryList) {
if (repos instanceof BlockingSourceRepository && !((BlockingSourceRepository) repos).isReady()) {
continue;
}
fileName = repos.isPlatformDependent() ? platformName : canonicalName;
if (DEBUG) {
System.out.println("Looking in " + repos + " for " + fileName);
}
if (repos.contains(fileName)) {
// Found it
sourceFile = new SourceFile(repos.getDataSource(fileName));
cache.put(canonicalName, sourceFile); // always cache with
// canonicalName
return sourceFile;
}
}
throw new FileNotFoundException("Can't find source file " + fileName);
} | [
"public",
"SourceFile",
"findSourceFile",
"(",
"String",
"packageName",
",",
"String",
"fileName",
")",
"throws",
"IOException",
"{",
"// On windows the fileName specification is different between a file in",
"// a directory tree, and a",
"// file in a zip file. In a directory tree the... | Open a source file in given package.
@param packageName
the name of the package containing the class whose source file
is given
@param fileName
the unqualified name of the source file
@return the source file
@throws IOException
if a matching source file cannot be found | [
"Open",
"a",
"source",
"file",
"in",
"given",
"package",
"."
] | f6365c6eea6515035bded38efa4a7c8b46ccf28c | https://github.com/spotbugs/spotbugs/blob/f6365c6eea6515035bded38efa4a7c8b46ccf28c/spotbugs/src/main/java/edu/umd/cs/findbugs/ba/SourceFinder.java#L468-L516 | train |
spotbugs/spotbugs | spotbugs/src/main/java/edu/umd/cs/findbugs/FuzzyBugComparator.java | FuzzyBugComparator.compareSourceLines | public int compareSourceLines(BugCollection lhsCollection, BugCollection rhsCollection, SourceLineAnnotation lhs,
SourceLineAnnotation rhs) {
if (lhs == null || rhs == null) {
return compareNullElements(lhs, rhs);
}
// Classes must match fuzzily.
int cmp = compareClassesByName(lhsCollection, rhsCollection, lhs.getClassName(), rhs.getClassName());
if (cmp != 0) {
return cmp;
}
return 0;
} | java | public int compareSourceLines(BugCollection lhsCollection, BugCollection rhsCollection, SourceLineAnnotation lhs,
SourceLineAnnotation rhs) {
if (lhs == null || rhs == null) {
return compareNullElements(lhs, rhs);
}
// Classes must match fuzzily.
int cmp = compareClassesByName(lhsCollection, rhsCollection, lhs.getClassName(), rhs.getClassName());
if (cmp != 0) {
return cmp;
}
return 0;
} | [
"public",
"int",
"compareSourceLines",
"(",
"BugCollection",
"lhsCollection",
",",
"BugCollection",
"rhsCollection",
",",
"SourceLineAnnotation",
"lhs",
",",
"SourceLineAnnotation",
"rhs",
")",
"{",
"if",
"(",
"lhs",
"==",
"null",
"||",
"rhs",
"==",
"null",
")",
... | Compare source line annotations.
@param rhsCollection
lhs BugCollection
@param lhsCollection
rhs BugCollection
@param lhs
a SourceLineAnnotation
@param rhs
another SourceLineAnnotation
@return comparison of lhs and rhs | [
"Compare",
"source",
"line",
"annotations",
"."
] | f6365c6eea6515035bded38efa4a7c8b46ccf28c | https://github.com/spotbugs/spotbugs/blob/f6365c6eea6515035bded38efa4a7c8b46ccf28c/spotbugs/src/main/java/edu/umd/cs/findbugs/FuzzyBugComparator.java#L298-L311 | train |
spotbugs/spotbugs | spotbugs/src/main/java/edu/umd/cs/findbugs/xml/QuoteMetaCharacters.java | QuoteMetaCharacters.process | public void process() throws IOException {
int pos = 0;
do {
int meta = findNextMeta(text, pos);
if (meta >= 0) {
emitLiteral(text.substring(pos, meta));
emitLiteral(map.getReplacement(text.substring(meta, meta + 1)));
pos = meta + 1;
} else {
emitLiteral(text.substring(pos, text.length()));
pos = text.length();
}
} while (pos < text.length());
} | java | public void process() throws IOException {
int pos = 0;
do {
int meta = findNextMeta(text, pos);
if (meta >= 0) {
emitLiteral(text.substring(pos, meta));
emitLiteral(map.getReplacement(text.substring(meta, meta + 1)));
pos = meta + 1;
} else {
emitLiteral(text.substring(pos, text.length()));
pos = text.length();
}
} while (pos < text.length());
} | [
"public",
"void",
"process",
"(",
")",
"throws",
"IOException",
"{",
"int",
"pos",
"=",
"0",
";",
"do",
"{",
"int",
"meta",
"=",
"findNextMeta",
"(",
"text",
",",
"pos",
")",
";",
"if",
"(",
"meta",
">=",
"0",
")",
"{",
"emitLiteral",
"(",
"text",
... | Quote metacharacters in the text. | [
"Quote",
"metacharacters",
"in",
"the",
"text",
"."
] | f6365c6eea6515035bded38efa4a7c8b46ccf28c | https://github.com/spotbugs/spotbugs/blob/f6365c6eea6515035bded38efa4a7c8b46ccf28c/spotbugs/src/main/java/edu/umd/cs/findbugs/xml/QuoteMetaCharacters.java#L60-L73 | train |
spotbugs/spotbugs | spotbugs/src/main/java/edu/umd/cs/findbugs/classfile/ReflectionDatabaseFactory.java | ReflectionDatabaseFactory.createUsingConstructor | private E createUsingConstructor() throws CheckedAnalysisException {
Constructor<E> constructor;
try {
constructor = databaseClass.getConstructor(new Class[0]);
} catch (NoSuchMethodException e) {
return null;
}
try {
return constructor.newInstance(new Object[0]);
} catch (InstantiationException e) {
throw new CheckedAnalysisException("Could not create " + databaseClass.getName(), e);
} catch (IllegalAccessException e) {
throw new CheckedAnalysisException("Could not create " + databaseClass.getName(), e);
} catch (InvocationTargetException e) {
throw new CheckedAnalysisException("Could not create " + databaseClass.getName(), e);
}
} | java | private E createUsingConstructor() throws CheckedAnalysisException {
Constructor<E> constructor;
try {
constructor = databaseClass.getConstructor(new Class[0]);
} catch (NoSuchMethodException e) {
return null;
}
try {
return constructor.newInstance(new Object[0]);
} catch (InstantiationException e) {
throw new CheckedAnalysisException("Could not create " + databaseClass.getName(), e);
} catch (IllegalAccessException e) {
throw new CheckedAnalysisException("Could not create " + databaseClass.getName(), e);
} catch (InvocationTargetException e) {
throw new CheckedAnalysisException("Could not create " + databaseClass.getName(), e);
}
} | [
"private",
"E",
"createUsingConstructor",
"(",
")",
"throws",
"CheckedAnalysisException",
"{",
"Constructor",
"<",
"E",
">",
"constructor",
";",
"try",
"{",
"constructor",
"=",
"databaseClass",
".",
"getConstructor",
"(",
"new",
"Class",
"[",
"0",
"]",
")",
";... | Try to create the database using a no-arg constructor.
@return the database, or null if there is no no-arg constructor
@throws CheckedAnalysisException | [
"Try",
"to",
"create",
"the",
"database",
"using",
"a",
"no",
"-",
"arg",
"constructor",
"."
] | f6365c6eea6515035bded38efa4a7c8b46ccf28c | https://github.com/spotbugs/spotbugs/blob/f6365c6eea6515035bded38efa4a7c8b46ccf28c/spotbugs/src/main/java/edu/umd/cs/findbugs/classfile/ReflectionDatabaseFactory.java#L104-L121 | train |
spotbugs/spotbugs | eclipsePlugin/src/de/tobject/findbugs/actions/ClearMarkersAction.java | ClearMarkersAction.work | @Override
protected void work(final IWorkbenchPart part, IResource resource, final List<WorkItem> resources) {
FindBugsJob clearMarkersJob = new ClearMarkersJob(resource, resources);
clearMarkersJob.addJobChangeListener(new JobChangeAdapter() {
@Override
public void done(IJobChangeEvent event) {
refreshViewer(part, resources);
}
});
clearMarkersJob.scheduleInteractive();
} | java | @Override
protected void work(final IWorkbenchPart part, IResource resource, final List<WorkItem> resources) {
FindBugsJob clearMarkersJob = new ClearMarkersJob(resource, resources);
clearMarkersJob.addJobChangeListener(new JobChangeAdapter() {
@Override
public void done(IJobChangeEvent event) {
refreshViewer(part, resources);
}
});
clearMarkersJob.scheduleInteractive();
} | [
"@",
"Override",
"protected",
"void",
"work",
"(",
"final",
"IWorkbenchPart",
"part",
",",
"IResource",
"resource",
",",
"final",
"List",
"<",
"WorkItem",
">",
"resources",
")",
"{",
"FindBugsJob",
"clearMarkersJob",
"=",
"new",
"ClearMarkersJob",
"(",
"resource... | Clear the FindBugs markers on each project in the given selection,
displaying a progress monitor. | [
"Clear",
"the",
"FindBugs",
"markers",
"on",
"each",
"project",
"in",
"the",
"given",
"selection",
"displaying",
"a",
"progress",
"monitor",
"."
] | f6365c6eea6515035bded38efa4a7c8b46ccf28c | https://github.com/spotbugs/spotbugs/blob/f6365c6eea6515035bded38efa4a7c8b46ccf28c/eclipsePlugin/src/de/tobject/findbugs/actions/ClearMarkersAction.java#L49-L59 | train |
spotbugs/spotbugs | spotbugs/src/main/java/edu/umd/cs/findbugs/ba/Frame.java | Frame.pushValue | public void pushValue(ValueType value) {
if (VERIFY_INTEGRITY && value == null) {
throw new IllegalArgumentException();
}
if (!isValid()) {
throw new IllegalStateException("accessing top or bottom frame");
}
slotList.add(value);
} | java | public void pushValue(ValueType value) {
if (VERIFY_INTEGRITY && value == null) {
throw new IllegalArgumentException();
}
if (!isValid()) {
throw new IllegalStateException("accessing top or bottom frame");
}
slotList.add(value);
} | [
"public",
"void",
"pushValue",
"(",
"ValueType",
"value",
")",
"{",
"if",
"(",
"VERIFY_INTEGRITY",
"&&",
"value",
"==",
"null",
")",
"{",
"throw",
"new",
"IllegalArgumentException",
"(",
")",
";",
"}",
"if",
"(",
"!",
"isValid",
"(",
")",
")",
"{",
"th... | Push a value onto the Java operand stack.
@param value
the ValueType to push | [
"Push",
"a",
"value",
"onto",
"the",
"Java",
"operand",
"stack",
"."
] | f6365c6eea6515035bded38efa4a7c8b46ccf28c | https://github.com/spotbugs/spotbugs/blob/f6365c6eea6515035bded38efa4a7c8b46ccf28c/spotbugs/src/main/java/edu/umd/cs/findbugs/ba/Frame.java#L174-L182 | train |
spotbugs/spotbugs | spotbugs/src/main/java/edu/umd/cs/findbugs/ba/Frame.java | Frame.popValue | public ValueType popValue() throws DataflowAnalysisException {
if (!isValid()) {
throw new DataflowAnalysisException("accessing top or bottom frame");
}
if (slotList.size() == numLocals) {
throw new DataflowAnalysisException("operand stack empty");
}
return slotList.remove(slotList.size() - 1);
} | java | public ValueType popValue() throws DataflowAnalysisException {
if (!isValid()) {
throw new DataflowAnalysisException("accessing top or bottom frame");
}
if (slotList.size() == numLocals) {
throw new DataflowAnalysisException("operand stack empty");
}
return slotList.remove(slotList.size() - 1);
} | [
"public",
"ValueType",
"popValue",
"(",
")",
"throws",
"DataflowAnalysisException",
"{",
"if",
"(",
"!",
"isValid",
"(",
")",
")",
"{",
"throw",
"new",
"DataflowAnalysisException",
"(",
"\"accessing top or bottom frame\"",
")",
";",
"}",
"if",
"(",
"slotList",
"... | Pop a value off of the Java operand stack.
@return the value that was popped
@throws DataflowAnalysisException
if the Java operand stack is empty | [
"Pop",
"a",
"value",
"off",
"of",
"the",
"Java",
"operand",
"stack",
"."
] | f6365c6eea6515035bded38efa4a7c8b46ccf28c | https://github.com/spotbugs/spotbugs/blob/f6365c6eea6515035bded38efa4a7c8b46ccf28c/spotbugs/src/main/java/edu/umd/cs/findbugs/ba/Frame.java#L191-L199 | train |
spotbugs/spotbugs | spotbugs/src/main/java/edu/umd/cs/findbugs/ba/Frame.java | Frame.getTopValue | public ValueType getTopValue() throws DataflowAnalysisException {
if (!isValid()) {
throw new DataflowAnalysisException("accessing top or bottom frame");
}
assert slotList.size() >= numLocals;
if (slotList.size() == numLocals) {
throw new DataflowAnalysisException("operand stack is empty");
}
return slotList.get(slotList.size() - 1);
} | java | public ValueType getTopValue() throws DataflowAnalysisException {
if (!isValid()) {
throw new DataflowAnalysisException("accessing top or bottom frame");
}
assert slotList.size() >= numLocals;
if (slotList.size() == numLocals) {
throw new DataflowAnalysisException("operand stack is empty");
}
return slotList.get(slotList.size() - 1);
} | [
"public",
"ValueType",
"getTopValue",
"(",
")",
"throws",
"DataflowAnalysisException",
"{",
"if",
"(",
"!",
"isValid",
"(",
")",
")",
"{",
"throw",
"new",
"DataflowAnalysisException",
"(",
"\"accessing top or bottom frame\"",
")",
";",
"}",
"assert",
"slotList",
"... | Get the value on the top of the Java operand stack.
@throws DataflowAnalysisException
if the Java operand stack is empty | [
"Get",
"the",
"value",
"on",
"the",
"top",
"of",
"the",
"Java",
"operand",
"stack",
"."
] | f6365c6eea6515035bded38efa4a7c8b46ccf28c | https://github.com/spotbugs/spotbugs/blob/f6365c6eea6515035bded38efa4a7c8b46ccf28c/spotbugs/src/main/java/edu/umd/cs/findbugs/ba/Frame.java#L207-L216 | train |
spotbugs/spotbugs | spotbugs/src/main/java/edu/umd/cs/findbugs/ba/Frame.java | Frame.getTopStackWords | public void getTopStackWords(ValueType[] valueList) throws DataflowAnalysisException {
int stackDepth = getStackDepth();
if (valueList.length > stackDepth) {
throw new DataflowAnalysisException("not enough values on stack");
}
int numSlots = slotList.size();
for (int i = numSlots - valueList.length, j = 0; i < numSlots; ++i, ++j) {
valueList[j] = slotList.get(i);
}
} | java | public void getTopStackWords(ValueType[] valueList) throws DataflowAnalysisException {
int stackDepth = getStackDepth();
if (valueList.length > stackDepth) {
throw new DataflowAnalysisException("not enough values on stack");
}
int numSlots = slotList.size();
for (int i = numSlots - valueList.length, j = 0; i < numSlots; ++i, ++j) {
valueList[j] = slotList.get(i);
}
} | [
"public",
"void",
"getTopStackWords",
"(",
"ValueType",
"[",
"]",
"valueList",
")",
"throws",
"DataflowAnalysisException",
"{",
"int",
"stackDepth",
"=",
"getStackDepth",
"(",
")",
";",
"if",
"(",
"valueList",
".",
"length",
">",
"stackDepth",
")",
"{",
"throw... | Get the values on the top of the Java operand stack. The top stack item
is placed at the end of the array, so that to restore the values to the
stack, you would push them in the order they appear in the array. | [
"Get",
"the",
"values",
"on",
"the",
"top",
"of",
"the",
"Java",
"operand",
"stack",
".",
"The",
"top",
"stack",
"item",
"is",
"placed",
"at",
"the",
"end",
"of",
"the",
"array",
"so",
"that",
"to",
"restore",
"the",
"values",
"to",
"the",
"stack",
"... | f6365c6eea6515035bded38efa4a7c8b46ccf28c | https://github.com/spotbugs/spotbugs/blob/f6365c6eea6515035bded38efa4a7c8b46ccf28c/spotbugs/src/main/java/edu/umd/cs/findbugs/ba/Frame.java#L223-L232 | train |
spotbugs/spotbugs | spotbugs/src/main/java/edu/umd/cs/findbugs/ba/Frame.java | Frame.getStackValue | public ValueType getStackValue(int loc) throws DataflowAnalysisException {
if (!isValid()) {
throw new DataflowAnalysisException("Accessing TOP or BOTTOM frame!");
}
int stackDepth = getStackDepth();
if (loc >= stackDepth) {
throw new DataflowAnalysisException("not enough values on stack: access=" + loc + ", avail=" + stackDepth);
}
if (loc < 0) {
throw new DataflowAnalysisException("can't get position " + loc + " of stack");
}
int pos = slotList.size() - (loc + 1);
return slotList.get(pos);
} | java | public ValueType getStackValue(int loc) throws DataflowAnalysisException {
if (!isValid()) {
throw new DataflowAnalysisException("Accessing TOP or BOTTOM frame!");
}
int stackDepth = getStackDepth();
if (loc >= stackDepth) {
throw new DataflowAnalysisException("not enough values on stack: access=" + loc + ", avail=" + stackDepth);
}
if (loc < 0) {
throw new DataflowAnalysisException("can't get position " + loc + " of stack");
}
int pos = slotList.size() - (loc + 1);
return slotList.get(pos);
} | [
"public",
"ValueType",
"getStackValue",
"(",
"int",
"loc",
")",
"throws",
"DataflowAnalysisException",
"{",
"if",
"(",
"!",
"isValid",
"(",
")",
")",
"{",
"throw",
"new",
"DataflowAnalysisException",
"(",
"\"Accessing TOP or BOTTOM frame!\"",
")",
";",
"}",
"int",... | Get a value on the operand stack.
@param loc
the stack location, counting downwards from the top (location
0) | [
"Get",
"a",
"value",
"on",
"the",
"operand",
"stack",
"."
] | f6365c6eea6515035bded38efa4a7c8b46ccf28c | https://github.com/spotbugs/spotbugs/blob/f6365c6eea6515035bded38efa4a7c8b46ccf28c/spotbugs/src/main/java/edu/umd/cs/findbugs/ba/Frame.java#L241-L254 | train |
spotbugs/spotbugs | spotbugs/src/main/java/edu/umd/cs/findbugs/ba/Frame.java | Frame.getStackLocation | public int getStackLocation(int loc) throws DataflowAnalysisException {
int stackDepth = getStackDepth();
if (loc >= stackDepth) {
throw new DataflowAnalysisException("not enough values on stack: access=" + loc + ", avail=" + stackDepth);
}
return slotList.size() - (loc + 1);
} | java | public int getStackLocation(int loc) throws DataflowAnalysisException {
int stackDepth = getStackDepth();
if (loc >= stackDepth) {
throw new DataflowAnalysisException("not enough values on stack: access=" + loc + ", avail=" + stackDepth);
}
return slotList.size() - (loc + 1);
} | [
"public",
"int",
"getStackLocation",
"(",
"int",
"loc",
")",
"throws",
"DataflowAnalysisException",
"{",
"int",
"stackDepth",
"=",
"getStackDepth",
"(",
")",
";",
"if",
"(",
"loc",
">=",
"stackDepth",
")",
"{",
"throw",
"new",
"DataflowAnalysisException",
"(",
... | Get a the location in the frame of a value on the operand stack.
@param loc
the stack location, counting downwards from the top (location
0) | [
"Get",
"a",
"the",
"location",
"in",
"the",
"frame",
"of",
"a",
"value",
"on",
"the",
"operand",
"stack",
"."
] | f6365c6eea6515035bded38efa4a7c8b46ccf28c | https://github.com/spotbugs/spotbugs/blob/f6365c6eea6515035bded38efa4a7c8b46ccf28c/spotbugs/src/main/java/edu/umd/cs/findbugs/ba/Frame.java#L263-L269 | train |
spotbugs/spotbugs | spotbugs/src/main/java/edu/umd/cs/findbugs/ba/Frame.java | Frame.getInstanceSlot | public int getInstanceSlot(Instruction ins, ConstantPoolGen cpg) throws DataflowAnalysisException {
if (!isValid()) {
throw new DataflowAnalysisException("Accessing invalid frame at " + ins);
}
int numConsumed = ins.consumeStack(cpg);
if (numConsumed == Const.UNPREDICTABLE) {
throw new DataflowAnalysisException("Unpredictable stack consumption in " + ins);
}
if (numConsumed > getStackDepth()) {
throw new DataflowAnalysisException("Stack underflow " + ins);
}
return getNumSlots() - numConsumed;
} | java | public int getInstanceSlot(Instruction ins, ConstantPoolGen cpg) throws DataflowAnalysisException {
if (!isValid()) {
throw new DataflowAnalysisException("Accessing invalid frame at " + ins);
}
int numConsumed = ins.consumeStack(cpg);
if (numConsumed == Const.UNPREDICTABLE) {
throw new DataflowAnalysisException("Unpredictable stack consumption in " + ins);
}
if (numConsumed > getStackDepth()) {
throw new DataflowAnalysisException("Stack underflow " + ins);
}
return getNumSlots() - numConsumed;
} | [
"public",
"int",
"getInstanceSlot",
"(",
"Instruction",
"ins",
",",
"ConstantPoolGen",
"cpg",
")",
"throws",
"DataflowAnalysisException",
"{",
"if",
"(",
"!",
"isValid",
"(",
")",
")",
"{",
"throw",
"new",
"DataflowAnalysisException",
"(",
"\"Accessing invalid frame... | Get the slot the object instance referred to by given instruction is
located in.
@param ins
the Instruction
@param cpg
the ConstantPoolGen for the method
@return stack slot the object instance is in
@throws DataflowAnalysisException | [
"Get",
"the",
"slot",
"the",
"object",
"instance",
"referred",
"to",
"by",
"given",
"instruction",
"is",
"located",
"in",
"."
] | f6365c6eea6515035bded38efa4a7c8b46ccf28c | https://github.com/spotbugs/spotbugs/blob/f6365c6eea6515035bded38efa4a7c8b46ccf28c/spotbugs/src/main/java/edu/umd/cs/findbugs/ba/Frame.java#L324-L336 | train |
spotbugs/spotbugs | spotbugs/src/main/java/edu/umd/cs/findbugs/ba/Frame.java | Frame.getNumArguments | public int getNumArguments(InvokeInstruction ins, ConstantPoolGen cpg) {
SignatureParser parser = new SignatureParser(ins.getSignature(cpg));
return parser.getNumParameters();
} | java | public int getNumArguments(InvokeInstruction ins, ConstantPoolGen cpg) {
SignatureParser parser = new SignatureParser(ins.getSignature(cpg));
return parser.getNumParameters();
} | [
"public",
"int",
"getNumArguments",
"(",
"InvokeInstruction",
"ins",
",",
"ConstantPoolGen",
"cpg",
")",
"{",
"SignatureParser",
"parser",
"=",
"new",
"SignatureParser",
"(",
"ins",
".",
"getSignature",
"(",
"cpg",
")",
")",
";",
"return",
"parser",
".",
"getN... | Get the number of arguments passed to given method invocation.
@param ins
the method invocation instruction
@param cpg
the ConstantPoolGen for the class containing the method
@return number of arguments; note that this excludes the object instance
for instance methods | [
"Get",
"the",
"number",
"of",
"arguments",
"passed",
"to",
"given",
"method",
"invocation",
"."
] | f6365c6eea6515035bded38efa4a7c8b46ccf28c | https://github.com/spotbugs/spotbugs/blob/f6365c6eea6515035bded38efa4a7c8b46ccf28c/spotbugs/src/main/java/edu/umd/cs/findbugs/ba/Frame.java#L348-L351 | train |
spotbugs/spotbugs | spotbugs/src/main/java/edu/umd/cs/findbugs/ba/Frame.java | Frame.getNumArgumentsIncludingObjectInstance | public int getNumArgumentsIncludingObjectInstance(InvokeInstruction ins, ConstantPoolGen cpg)
throws DataflowAnalysisException {
int numConsumed = ins.consumeStack(cpg);
if (numConsumed == Const.UNPREDICTABLE) {
throw new DataflowAnalysisException("Unpredictable stack consumption in " + ins);
}
return numConsumed;
} | java | public int getNumArgumentsIncludingObjectInstance(InvokeInstruction ins, ConstantPoolGen cpg)
throws DataflowAnalysisException {
int numConsumed = ins.consumeStack(cpg);
if (numConsumed == Const.UNPREDICTABLE) {
throw new DataflowAnalysisException("Unpredictable stack consumption in " + ins);
}
return numConsumed;
} | [
"public",
"int",
"getNumArgumentsIncludingObjectInstance",
"(",
"InvokeInstruction",
"ins",
",",
"ConstantPoolGen",
"cpg",
")",
"throws",
"DataflowAnalysisException",
"{",
"int",
"numConsumed",
"=",
"ins",
".",
"consumeStack",
"(",
"cpg",
")",
";",
"if",
"(",
"numCo... | Get the number of arguments passed to given method invocation, including
the object instance if the call is to an instance method.
@param ins
the method invocation instruction
@param cpg
the ConstantPoolGen for the class containing the method
@return number of arguments, including object instance if appropriate
@throws DataflowAnalysisException | [
"Get",
"the",
"number",
"of",
"arguments",
"passed",
"to",
"given",
"method",
"invocation",
"including",
"the",
"object",
"instance",
"if",
"the",
"call",
"is",
"to",
"an",
"instance",
"method",
"."
] | f6365c6eea6515035bded38efa4a7c8b46ccf28c | https://github.com/spotbugs/spotbugs/blob/f6365c6eea6515035bded38efa4a7c8b46ccf28c/spotbugs/src/main/java/edu/umd/cs/findbugs/ba/Frame.java#L364-L371 | train |
spotbugs/spotbugs | spotbugs/src/main/java/edu/umd/cs/findbugs/ba/Frame.java | Frame.getArgumentSet | public BitSet getArgumentSet(InvokeInstruction invokeInstruction, ConstantPoolGen cpg, DataflowValueChooser<ValueType> chooser)
throws DataflowAnalysisException {
BitSet chosenArgSet = new BitSet();
SignatureParser sigParser = new SignatureParser(invokeInstruction.getSignature(cpg));
for (int i = 0; i < sigParser.getNumParameters(); ++i) {
ValueType value = getArgument(invokeInstruction, cpg, i, sigParser);
if (chooser.choose(value)) {
chosenArgSet.set(i);
}
}
return chosenArgSet;
} | java | public BitSet getArgumentSet(InvokeInstruction invokeInstruction, ConstantPoolGen cpg, DataflowValueChooser<ValueType> chooser)
throws DataflowAnalysisException {
BitSet chosenArgSet = new BitSet();
SignatureParser sigParser = new SignatureParser(invokeInstruction.getSignature(cpg));
for (int i = 0; i < sigParser.getNumParameters(); ++i) {
ValueType value = getArgument(invokeInstruction, cpg, i, sigParser);
if (chooser.choose(value)) {
chosenArgSet.set(i);
}
}
return chosenArgSet;
} | [
"public",
"BitSet",
"getArgumentSet",
"(",
"InvokeInstruction",
"invokeInstruction",
",",
"ConstantPoolGen",
"cpg",
",",
"DataflowValueChooser",
"<",
"ValueType",
">",
"chooser",
")",
"throws",
"DataflowAnalysisException",
"{",
"BitSet",
"chosenArgSet",
"=",
"new",
"Bit... | Get set of arguments passed to a method invocation which match given
predicate.
@param invokeInstruction
the InvokeInstruction
@param cpg
the ConstantPoolGen
@param chooser
predicate to choose which argument values should be in the
returned set
@return BitSet specifying which arguments match the predicate, indexed by
argument number (starting from 0)
@throws DataflowAnalysisException | [
"Get",
"set",
"of",
"arguments",
"passed",
"to",
"a",
"method",
"invocation",
"which",
"match",
"given",
"predicate",
"."
] | f6365c6eea6515035bded38efa4a7c8b46ccf28c | https://github.com/spotbugs/spotbugs/blob/f6365c6eea6515035bded38efa4a7c8b46ccf28c/spotbugs/src/main/java/edu/umd/cs/findbugs/ba/Frame.java#L468-L481 | train |
spotbugs/spotbugs | spotbugs/src/main/java/edu/umd/cs/findbugs/ba/Frame.java | Frame.clearStack | public void clearStack() {
if (!isValid()) {
throw new IllegalStateException("accessing top or bottom frame");
}
assert slotList.size() >= numLocals;
if (slotList.size() > numLocals) {
slotList.subList(numLocals, slotList.size()).clear();
}
} | java | public void clearStack() {
if (!isValid()) {
throw new IllegalStateException("accessing top or bottom frame");
}
assert slotList.size() >= numLocals;
if (slotList.size() > numLocals) {
slotList.subList(numLocals, slotList.size()).clear();
}
} | [
"public",
"void",
"clearStack",
"(",
")",
"{",
"if",
"(",
"!",
"isValid",
"(",
")",
")",
"{",
"throw",
"new",
"IllegalStateException",
"(",
"\"accessing top or bottom frame\"",
")",
";",
"}",
"assert",
"slotList",
".",
"size",
"(",
")",
">=",
"numLocals",
... | Clear the Java operand stack. Only local variable slots will remain in
the frame. | [
"Clear",
"the",
"Java",
"operand",
"stack",
".",
"Only",
"local",
"variable",
"slots",
"will",
"remain",
"in",
"the",
"frame",
"."
] | f6365c6eea6515035bded38efa4a7c8b46ccf28c | https://github.com/spotbugs/spotbugs/blob/f6365c6eea6515035bded38efa4a7c8b46ccf28c/spotbugs/src/main/java/edu/umd/cs/findbugs/ba/Frame.java#L487-L495 | train |
spotbugs/spotbugs | spotbugs/src/main/java/edu/umd/cs/findbugs/ba/Frame.java | Frame.sameAs | public boolean sameAs(Frame<ValueType> other) {
if (isTop != other.isTop) {
return false;
}
if (isTop && other.isTop) {
return true;
}
if (isBottom != other.isBottom) {
return false;
}
if (isBottom && other.isBottom) {
return true;
}
if (getNumSlots() != other.getNumSlots()) {
return false;
}
for (int i = 0; i < getNumSlots(); ++i) {
if (!getValue(i).equals(other.getValue(i))) {
return false;
}
}
return true;
} | java | public boolean sameAs(Frame<ValueType> other) {
if (isTop != other.isTop) {
return false;
}
if (isTop && other.isTop) {
return true;
}
if (isBottom != other.isBottom) {
return false;
}
if (isBottom && other.isBottom) {
return true;
}
if (getNumSlots() != other.getNumSlots()) {
return false;
}
for (int i = 0; i < getNumSlots(); ++i) {
if (!getValue(i).equals(other.getValue(i))) {
return false;
}
}
return true;
} | [
"public",
"boolean",
"sameAs",
"(",
"Frame",
"<",
"ValueType",
">",
"other",
")",
"{",
"if",
"(",
"isTop",
"!=",
"other",
".",
"isTop",
")",
"{",
"return",
"false",
";",
"}",
"if",
"(",
"isTop",
"&&",
"other",
".",
"isTop",
")",
"{",
"return",
"tru... | Return true if this stack frame is the same as the one given as a
parameter.
@param other
the other Frame
@return true if the frames are the same, false otherwise | [
"Return",
"true",
"if",
"this",
"stack",
"frame",
"is",
"the",
"same",
"as",
"the",
"one",
"given",
"as",
"a",
"parameter",
"."
] | f6365c6eea6515035bded38efa4a7c8b46ccf28c | https://github.com/spotbugs/spotbugs/blob/f6365c6eea6515035bded38efa4a7c8b46ccf28c/spotbugs/src/main/java/edu/umd/cs/findbugs/ba/Frame.java#L570-L598 | train |
spotbugs/spotbugs | spotbugs/src/main/java/edu/umd/cs/findbugs/ba/Frame.java | Frame.copyFrom | public void copyFrom(Frame<ValueType> other) {
lastUpdateTimestamp = other.lastUpdateTimestamp;
slotList = new ArrayList<>(other.slotList);
isTop = other.isTop;
isBottom = other.isBottom;
} | java | public void copyFrom(Frame<ValueType> other) {
lastUpdateTimestamp = other.lastUpdateTimestamp;
slotList = new ArrayList<>(other.slotList);
isTop = other.isTop;
isBottom = other.isBottom;
} | [
"public",
"void",
"copyFrom",
"(",
"Frame",
"<",
"ValueType",
">",
"other",
")",
"{",
"lastUpdateTimestamp",
"=",
"other",
".",
"lastUpdateTimestamp",
";",
"slotList",
"=",
"new",
"ArrayList",
"<>",
"(",
"other",
".",
"slotList",
")",
";",
"isTop",
"=",
"o... | Make this Frame exactly the same as the one given as a parameter.
@param other
the Frame to make this object the same as | [
"Make",
"this",
"Frame",
"exactly",
"the",
"same",
"as",
"the",
"one",
"given",
"as",
"a",
"parameter",
"."
] | f6365c6eea6515035bded38efa4a7c8b46ccf28c | https://github.com/spotbugs/spotbugs/blob/f6365c6eea6515035bded38efa4a7c8b46ccf28c/spotbugs/src/main/java/edu/umd/cs/findbugs/ba/Frame.java#L606-L611 | train |
spotbugs/spotbugs | spotbugs/src/main/java/edu/umd/cs/findbugs/classfile/analysis/ClassInfo.java | ClassInfo.addAnnotation | public void addAnnotation(AnnotationValue annotationValue) {
HashMap<ClassDescriptor, AnnotationValue> updatedMap = new HashMap<>(classAnnotations);
updatedMap.put(annotationValue.getAnnotationClass(), annotationValue);
classAnnotations = Util.immutableMap(updatedMap);
} | java | public void addAnnotation(AnnotationValue annotationValue) {
HashMap<ClassDescriptor, AnnotationValue> updatedMap = new HashMap<>(classAnnotations);
updatedMap.put(annotationValue.getAnnotationClass(), annotationValue);
classAnnotations = Util.immutableMap(updatedMap);
} | [
"public",
"void",
"addAnnotation",
"(",
"AnnotationValue",
"annotationValue",
")",
"{",
"HashMap",
"<",
"ClassDescriptor",
",",
"AnnotationValue",
">",
"updatedMap",
"=",
"new",
"HashMap",
"<>",
"(",
"classAnnotations",
")",
";",
"updatedMap",
".",
"put",
"(",
"... | Destructively add an annotation to the object. In general, this is not a
great idea, since it could cause the same class to appear to have
different annotations at different times. However, this method is
necessary for "built-in" annotations that FindBugs adds to system
classes. As long as we add such annotations early enough that nobody will
notice, we should be ok.
@param annotationValue
an AnnotationValue to add to the class | [
"Destructively",
"add",
"an",
"annotation",
"to",
"the",
"object",
".",
"In",
"general",
"this",
"is",
"not",
"a",
"great",
"idea",
"since",
"it",
"could",
"cause",
"the",
"same",
"class",
"to",
"appear",
"to",
"have",
"different",
"annotations",
"at",
"di... | f6365c6eea6515035bded38efa4a7c8b46ccf28c | https://github.com/spotbugs/spotbugs/blob/f6365c6eea6515035bded38efa4a7c8b46ccf28c/spotbugs/src/main/java/edu/umd/cs/findbugs/classfile/analysis/ClassInfo.java#L440-L444 | train |
spotbugs/spotbugs | spotbugs/src/main/java/edu/umd/cs/findbugs/classfile/impl/DirectoryCodeBase.java | DirectoryCodeBase.getResourceName | String getResourceName(String fileName) {
// FIXME: there is probably a more robust way to do this
// Strip off the directory part.
String dirPath = directory.getPath();
if (!fileName.startsWith(dirPath)) {
throw new IllegalStateException("Filename " + fileName + " not inside directory " + dirPath);
}
// The problem here is that we need to take the relative part of the
// filename
// and break it into components that we can then reconstruct into
// a resource name (using '/' characters to separate the components).
// Unfortunately, the File class does not make this task particularly
// easy.
String relativeFileName = fileName.substring(dirPath.length());
File file = new File(relativeFileName);
LinkedList<String> partList = new LinkedList<>();
do {
partList.addFirst(file.getName());
} while ((file = file.getParentFile()) != null);
StringBuilder buf = new StringBuilder();
for (String part : partList) {
if (buf.length() > 0) {
buf.append('/');
}
buf.append(part);
}
return buf.toString();
} | java | String getResourceName(String fileName) {
// FIXME: there is probably a more robust way to do this
// Strip off the directory part.
String dirPath = directory.getPath();
if (!fileName.startsWith(dirPath)) {
throw new IllegalStateException("Filename " + fileName + " not inside directory " + dirPath);
}
// The problem here is that we need to take the relative part of the
// filename
// and break it into components that we can then reconstruct into
// a resource name (using '/' characters to separate the components).
// Unfortunately, the File class does not make this task particularly
// easy.
String relativeFileName = fileName.substring(dirPath.length());
File file = new File(relativeFileName);
LinkedList<String> partList = new LinkedList<>();
do {
partList.addFirst(file.getName());
} while ((file = file.getParentFile()) != null);
StringBuilder buf = new StringBuilder();
for (String part : partList) {
if (buf.length() > 0) {
buf.append('/');
}
buf.append(part);
}
return buf.toString();
} | [
"String",
"getResourceName",
"(",
"String",
"fileName",
")",
"{",
"// FIXME: there is probably a more robust way to do this",
"// Strip off the directory part.",
"String",
"dirPath",
"=",
"directory",
".",
"getPath",
"(",
")",
";",
"if",
"(",
"!",
"fileName",
".",
"star... | Get the resource name given a full filename.
@param fileName
the full filename (which must be inside the directory)
@return the resource name (i.e., the filename with the directory stripped
off) | [
"Get",
"the",
"resource",
"name",
"given",
"a",
"full",
"filename",
"."
] | f6365c6eea6515035bded38efa4a7c8b46ccf28c | https://github.com/spotbugs/spotbugs/blob/f6365c6eea6515035bded38efa4a7c8b46ccf28c/spotbugs/src/main/java/edu/umd/cs/findbugs/classfile/impl/DirectoryCodeBase.java#L172-L204 | train |
spotbugs/spotbugs | eclipsePlugin/src/de/tobject/findbugs/actions/SaveXmlAction.java | SaveXmlAction.work | private void work(final IProject project, final String fileName) {
FindBugsJob runFindBugs = new FindBugsJob("Saving SpotBugs XML data to " + fileName + "...", project) {
@Override
protected void runWithProgress(IProgressMonitor monitor) throws CoreException {
BugCollection bugCollection = FindbugsPlugin.getBugCollection(project, monitor);
try {
bugCollection.writeXML(fileName);
} catch (IOException e) {
CoreException ex = new CoreException(FindbugsPlugin.createErrorStatus(
"Can't write SpotBugs bug collection from project " + project + " to file " + fileName, e));
throw ex;
}
}
};
runFindBugs.setRule(project);
runFindBugs.scheduleInteractive();
} | java | private void work(final IProject project, final String fileName) {
FindBugsJob runFindBugs = new FindBugsJob("Saving SpotBugs XML data to " + fileName + "...", project) {
@Override
protected void runWithProgress(IProgressMonitor monitor) throws CoreException {
BugCollection bugCollection = FindbugsPlugin.getBugCollection(project, monitor);
try {
bugCollection.writeXML(fileName);
} catch (IOException e) {
CoreException ex = new CoreException(FindbugsPlugin.createErrorStatus(
"Can't write SpotBugs bug collection from project " + project + " to file " + fileName, e));
throw ex;
}
}
};
runFindBugs.setRule(project);
runFindBugs.scheduleInteractive();
} | [
"private",
"void",
"work",
"(",
"final",
"IProject",
"project",
",",
"final",
"String",
"fileName",
")",
"{",
"FindBugsJob",
"runFindBugs",
"=",
"new",
"FindBugsJob",
"(",
"\"Saving SpotBugs XML data to \"",
"+",
"fileName",
"+",
"\"...\"",
",",
"project",
")",
... | Save the XML result of a FindBugs analysis on the given project,
displaying a progress monitor.
@param project
The selected project.
@param fileName
The file name to store the XML to. | [
"Save",
"the",
"XML",
"result",
"of",
"a",
"FindBugs",
"analysis",
"on",
"the",
"given",
"project",
"displaying",
"a",
"progress",
"monitor",
"."
] | f6365c6eea6515035bded38efa4a7c8b46ccf28c | https://github.com/spotbugs/spotbugs/blob/f6365c6eea6515035bded38efa4a7c8b46ccf28c/eclipsePlugin/src/de/tobject/findbugs/actions/SaveXmlAction.java#L126-L142 | train |
spotbugs/spotbugs | spotbugs/src/main/java/edu/umd/cs/findbugs/TextUIBugReporter.java | TextUIBugReporter.printBug | protected void printBug(BugInstance bugInstance) {
if (showRank) {
int rank = BugRanker.findRank(bugInstance);
outputStream.printf("%2d ", rank);
}
switch (bugInstance.getPriority()) {
case Priorities.EXP_PRIORITY:
outputStream.print("E ");
break;
case Priorities.LOW_PRIORITY:
outputStream.print("L ");
break;
case Priorities.NORMAL_PRIORITY:
outputStream.print("M ");
break;
case Priorities.HIGH_PRIORITY:
outputStream.print("H ");
break;
default:
assert false;
}
BugPattern pattern = bugInstance.getBugPattern();
if (pattern != null) {
String categoryAbbrev = null;
BugCategory bcat = DetectorFactoryCollection.instance().getBugCategory(pattern.getCategory());
if (bcat != null) {
categoryAbbrev = bcat.getAbbrev();
}
if (categoryAbbrev == null) {
categoryAbbrev = OTHER_CATEGORY_ABBREV;
}
outputStream.print(categoryAbbrev);
outputStream.print(" ");
}
if (useLongBugCodes) {
outputStream.print(bugInstance.getType());
outputStream.print(" ");
}
if (reportHistory) {
long first = bugInstance.getFirstVersion();
long last = bugInstance.getLastVersion();
outputStream.print(first);
outputStream.print(" ");
outputStream.print(last);
outputStream.print(" ");
}
SourceLineAnnotation line = bugInstance.getPrimarySourceLineAnnotation();
outputStream.println(bugInstance.getMessage().replace('\n', ' ') + " " + line.toString());
} | java | protected void printBug(BugInstance bugInstance) {
if (showRank) {
int rank = BugRanker.findRank(bugInstance);
outputStream.printf("%2d ", rank);
}
switch (bugInstance.getPriority()) {
case Priorities.EXP_PRIORITY:
outputStream.print("E ");
break;
case Priorities.LOW_PRIORITY:
outputStream.print("L ");
break;
case Priorities.NORMAL_PRIORITY:
outputStream.print("M ");
break;
case Priorities.HIGH_PRIORITY:
outputStream.print("H ");
break;
default:
assert false;
}
BugPattern pattern = bugInstance.getBugPattern();
if (pattern != null) {
String categoryAbbrev = null;
BugCategory bcat = DetectorFactoryCollection.instance().getBugCategory(pattern.getCategory());
if (bcat != null) {
categoryAbbrev = bcat.getAbbrev();
}
if (categoryAbbrev == null) {
categoryAbbrev = OTHER_CATEGORY_ABBREV;
}
outputStream.print(categoryAbbrev);
outputStream.print(" ");
}
if (useLongBugCodes) {
outputStream.print(bugInstance.getType());
outputStream.print(" ");
}
if (reportHistory) {
long first = bugInstance.getFirstVersion();
long last = bugInstance.getLastVersion();
outputStream.print(first);
outputStream.print(" ");
outputStream.print(last);
outputStream.print(" ");
}
SourceLineAnnotation line = bugInstance.getPrimarySourceLineAnnotation();
outputStream.println(bugInstance.getMessage().replace('\n', ' ') + " " + line.toString());
} | [
"protected",
"void",
"printBug",
"(",
"BugInstance",
"bugInstance",
")",
"{",
"if",
"(",
"showRank",
")",
"{",
"int",
"rank",
"=",
"BugRanker",
".",
"findRank",
"(",
"bugInstance",
")",
";",
"outputStream",
".",
"printf",
"(",
"\"%2d \"",
",",
"rank",
")",... | Print bug in one-line format.
@param bugInstance
the bug to print | [
"Print",
"bug",
"in",
"one",
"-",
"line",
"format",
"."
] | f6365c6eea6515035bded38efa4a7c8b46ccf28c | https://github.com/spotbugs/spotbugs/blob/f6365c6eea6515035bded38efa4a7c8b46ccf28c/spotbugs/src/main/java/edu/umd/cs/findbugs/TextUIBugReporter.java#L88-L139 | train |
spotbugs/spotbugs | spotbugs/src/main/java/edu/umd/cs/findbugs/model/ClassFeatureSet.java | ClassFeatureSet.initialize | public ClassFeatureSet initialize(JavaClass javaClass) {
this.className = javaClass.getClassName();
this.isInterface = javaClass.isInterface();
addFeature(CLASS_NAME_KEY + transformClassName(javaClass.getClassName()));
for (Method method : javaClass.getMethods()) {
if (!isSynthetic(method)) {
String transformedMethodSignature = transformMethodSignature(method.getSignature());
if (method.isStatic() || !overridesSuperclassMethod(javaClass, method)) {
addFeature(METHOD_NAME_KEY + method.getName() + ":" + transformedMethodSignature);
}
Code code = method.getCode();
if (code != null && code.getCode() != null && code.getCode().length >= MIN_CODE_LENGTH) {
addFeature(CODE_LENGTH_KEY + method.getName() + ":" + transformedMethodSignature + ":"
+ code.getCode().length);
}
}
}
for (Field field : javaClass.getFields()) {
if (!isSynthetic(field)) {
addFeature(FIELD_NAME_KEY + field.getName() + ":" + transformSignature(field.getSignature()));
}
}
return this;
} | java | public ClassFeatureSet initialize(JavaClass javaClass) {
this.className = javaClass.getClassName();
this.isInterface = javaClass.isInterface();
addFeature(CLASS_NAME_KEY + transformClassName(javaClass.getClassName()));
for (Method method : javaClass.getMethods()) {
if (!isSynthetic(method)) {
String transformedMethodSignature = transformMethodSignature(method.getSignature());
if (method.isStatic() || !overridesSuperclassMethod(javaClass, method)) {
addFeature(METHOD_NAME_KEY + method.getName() + ":" + transformedMethodSignature);
}
Code code = method.getCode();
if (code != null && code.getCode() != null && code.getCode().length >= MIN_CODE_LENGTH) {
addFeature(CODE_LENGTH_KEY + method.getName() + ":" + transformedMethodSignature + ":"
+ code.getCode().length);
}
}
}
for (Field field : javaClass.getFields()) {
if (!isSynthetic(field)) {
addFeature(FIELD_NAME_KEY + field.getName() + ":" + transformSignature(field.getSignature()));
}
}
return this;
} | [
"public",
"ClassFeatureSet",
"initialize",
"(",
"JavaClass",
"javaClass",
")",
"{",
"this",
".",
"className",
"=",
"javaClass",
".",
"getClassName",
"(",
")",
";",
"this",
".",
"isInterface",
"=",
"javaClass",
".",
"isInterface",
"(",
")",
";",
"addFeature",
... | Initialize from given JavaClass.
@param javaClass
the JavaClass
@return this object | [
"Initialize",
"from",
"given",
"JavaClass",
"."
] | f6365c6eea6515035bded38efa4a7c8b46ccf28c | https://github.com/spotbugs/spotbugs/blob/f6365c6eea6515035bded38efa4a7c8b46ccf28c/spotbugs/src/main/java/edu/umd/cs/findbugs/model/ClassFeatureSet.java#L82-L111 | train |
spotbugs/spotbugs | spotbugs/src/main/java/edu/umd/cs/findbugs/model/ClassFeatureSet.java | ClassFeatureSet.overridesSuperclassMethod | private boolean overridesSuperclassMethod(JavaClass javaClass, Method method) {
if (method.isStatic()) {
return false;
}
try {
JavaClass[] superclassList = javaClass.getSuperClasses();
if (superclassList != null) {
JavaClassAndMethod match = Hierarchy.findMethod(superclassList, method.getName(), method.getSignature(),
Hierarchy.INSTANCE_METHOD);
if (match != null) {
return true;
}
}
JavaClass[] interfaceList = javaClass.getAllInterfaces();
if (interfaceList != null) {
JavaClassAndMethod match = Hierarchy.findMethod(interfaceList, method.getName(), method.getSignature(),
Hierarchy.INSTANCE_METHOD);
if (match != null) {
return true;
}
}
return false;
} catch (ClassNotFoundException e) {
return true;
}
} | java | private boolean overridesSuperclassMethod(JavaClass javaClass, Method method) {
if (method.isStatic()) {
return false;
}
try {
JavaClass[] superclassList = javaClass.getSuperClasses();
if (superclassList != null) {
JavaClassAndMethod match = Hierarchy.findMethod(superclassList, method.getName(), method.getSignature(),
Hierarchy.INSTANCE_METHOD);
if (match != null) {
return true;
}
}
JavaClass[] interfaceList = javaClass.getAllInterfaces();
if (interfaceList != null) {
JavaClassAndMethod match = Hierarchy.findMethod(interfaceList, method.getName(), method.getSignature(),
Hierarchy.INSTANCE_METHOD);
if (match != null) {
return true;
}
}
return false;
} catch (ClassNotFoundException e) {
return true;
}
} | [
"private",
"boolean",
"overridesSuperclassMethod",
"(",
"JavaClass",
"javaClass",
",",
"Method",
"method",
")",
"{",
"if",
"(",
"method",
".",
"isStatic",
"(",
")",
")",
"{",
"return",
"false",
";",
"}",
"try",
"{",
"JavaClass",
"[",
"]",
"superclassList",
... | Determine if given method overrides a superclass or superinterface
method.
@param javaClass
class defining the method
@param method
the method
@return true if the method overrides a superclass/superinterface method,
false if not | [
"Determine",
"if",
"given",
"method",
"overrides",
"a",
"superclass",
"or",
"superinterface",
"method",
"."
] | f6365c6eea6515035bded38efa4a7c8b46ccf28c | https://github.com/spotbugs/spotbugs/blob/f6365c6eea6515035bded38efa4a7c8b46ccf28c/spotbugs/src/main/java/edu/umd/cs/findbugs/model/ClassFeatureSet.java#L124-L152 | train |
spotbugs/spotbugs | spotbugs/src/main/java/edu/umd/cs/findbugs/model/ClassFeatureSet.java | ClassFeatureSet.transformClassName | public static String transformClassName(String className) {
int lastDot = className.lastIndexOf('.');
if (lastDot >= 0) {
String pkg = className.substring(0, lastDot);
if (!isUnlikelyToBeRenamed(pkg)) {
className = className.substring(lastDot + 1);
}
}
return className;
} | java | public static String transformClassName(String className) {
int lastDot = className.lastIndexOf('.');
if (lastDot >= 0) {
String pkg = className.substring(0, lastDot);
if (!isUnlikelyToBeRenamed(pkg)) {
className = className.substring(lastDot + 1);
}
}
return className;
} | [
"public",
"static",
"String",
"transformClassName",
"(",
"String",
"className",
")",
"{",
"int",
"lastDot",
"=",
"className",
".",
"lastIndexOf",
"(",
"'",
"'",
")",
";",
"if",
"(",
"lastDot",
">=",
"0",
")",
"{",
"String",
"pkg",
"=",
"className",
".",
... | Transform a class name by stripping its package name.
@param className
a class name
@return the transformed class name | [
"Transform",
"a",
"class",
"name",
"by",
"stripping",
"its",
"package",
"name",
"."
] | f6365c6eea6515035bded38efa4a7c8b46ccf28c | https://github.com/spotbugs/spotbugs/blob/f6365c6eea6515035bded38efa4a7c8b46ccf28c/spotbugs/src/main/java/edu/umd/cs/findbugs/model/ClassFeatureSet.java#L224-L233 | train |
spotbugs/spotbugs | spotbugs/src/main/java/edu/umd/cs/findbugs/model/ClassFeatureSet.java | ClassFeatureSet.transformMethodSignature | public static String transformMethodSignature(String signature) {
StringBuilder buf = new StringBuilder();
buf.append('(');
SignatureParser parser = new SignatureParser(signature);
for (Iterator<String> i = parser.parameterSignatureIterator(); i.hasNext();) {
String param = i.next();
param = transformSignature(param);
buf.append(param);
}
buf.append(')');
return buf.toString();
} | java | public static String transformMethodSignature(String signature) {
StringBuilder buf = new StringBuilder();
buf.append('(');
SignatureParser parser = new SignatureParser(signature);
for (Iterator<String> i = parser.parameterSignatureIterator(); i.hasNext();) {
String param = i.next();
param = transformSignature(param);
buf.append(param);
}
buf.append(')');
return buf.toString();
} | [
"public",
"static",
"String",
"transformMethodSignature",
"(",
"String",
"signature",
")",
"{",
"StringBuilder",
"buf",
"=",
"new",
"StringBuilder",
"(",
")",
";",
"buf",
".",
"append",
"(",
"'",
"'",
")",
";",
"SignatureParser",
"parser",
"=",
"new",
"Signa... | Transform a method signature to allow it to be compared even if any of
its parameter types are moved to another package.
@param signature
a method signature
@return the transformed signature | [
"Transform",
"a",
"method",
"signature",
"to",
"allow",
"it",
"to",
"be",
"compared",
"even",
"if",
"any",
"of",
"its",
"parameter",
"types",
"are",
"moved",
"to",
"another",
"package",
"."
] | f6365c6eea6515035bded38efa4a7c8b46ccf28c | https://github.com/spotbugs/spotbugs/blob/f6365c6eea6515035bded38efa4a7c8b46ccf28c/spotbugs/src/main/java/edu/umd/cs/findbugs/model/ClassFeatureSet.java#L255-L270 | train |
spotbugs/spotbugs | spotbugs/src/main/java/edu/umd/cs/findbugs/model/ClassFeatureSet.java | ClassFeatureSet.transformSignature | public static String transformSignature(String signature) {
StringBuilder buf = new StringBuilder();
int lastBracket = signature.lastIndexOf('[');
if (lastBracket > 0) {
buf.append(signature.substring(0, lastBracket + 1));
signature = signature.substring(lastBracket + 1);
}
if (signature.startsWith("L")) {
signature = signature.substring(1, signature.length() - 1).replace('/', '.');
signature = transformClassName(signature);
signature = "L" + signature.replace('.', '/') + ";";
}
buf.append(signature);
return buf.toString();
} | java | public static String transformSignature(String signature) {
StringBuilder buf = new StringBuilder();
int lastBracket = signature.lastIndexOf('[');
if (lastBracket > 0) {
buf.append(signature.substring(0, lastBracket + 1));
signature = signature.substring(lastBracket + 1);
}
if (signature.startsWith("L")) {
signature = signature.substring(1, signature.length() - 1).replace('/', '.');
signature = transformClassName(signature);
signature = "L" + signature.replace('.', '/') + ";";
}
buf.append(signature);
return buf.toString();
} | [
"public",
"static",
"String",
"transformSignature",
"(",
"String",
"signature",
")",
"{",
"StringBuilder",
"buf",
"=",
"new",
"StringBuilder",
"(",
")",
";",
"int",
"lastBracket",
"=",
"signature",
".",
"lastIndexOf",
"(",
"'",
"'",
")",
";",
"if",
"(",
"l... | Transform a field or method parameter signature to allow it to be
compared even if it is moved to another package.
@param signature
the signature
@return the transformed signature | [
"Transform",
"a",
"field",
"or",
"method",
"parameter",
"signature",
"to",
"allow",
"it",
"to",
"be",
"compared",
"even",
"if",
"it",
"is",
"moved",
"to",
"another",
"package",
"."
] | f6365c6eea6515035bded38efa4a7c8b46ccf28c | https://github.com/spotbugs/spotbugs/blob/f6365c6eea6515035bded38efa4a7c8b46ccf28c/spotbugs/src/main/java/edu/umd/cs/findbugs/model/ClassFeatureSet.java#L280-L297 | train |
spotbugs/spotbugs | spotbugs/src/main/java/edu/umd/cs/findbugs/ba/BetterCFGBuilder2.java | BetterCFGBuilder2.handleExceptions | private void handleExceptions(Subroutine subroutine, InstructionHandle pei, BasicBlock etb) {
etb.setExceptionThrower(pei);
// Remember whether or not a universal exception handler
// is reachable. If so, then we know that exceptions raised
// at this instruction cannot propagate out of the method.
boolean sawUniversalExceptionHandler = false;
List<CodeExceptionGen> exceptionHandlerList = exceptionHandlerMap.getHandlerList(pei);
if (exceptionHandlerList != null) {
for (CodeExceptionGen exceptionHandler : exceptionHandlerList) {
InstructionHandle handlerStart = exceptionHandler.getHandlerPC();
subroutine.addEdgeAndExplore(etb, handlerStart, HANDLED_EXCEPTION_EDGE);
if (Hierarchy.isUniversalExceptionHandler(exceptionHandler.getCatchType())) {
sawUniversalExceptionHandler = true;
}
}
}
// If required, mark this block as throwing an unhandled exception.
// For now, we assume that if there is no reachable handler that handles
// ANY exception type, then the exception can be thrown out of the
// method.
if (!sawUniversalExceptionHandler) {
if (DEBUG) {
System.out.println("Adding unhandled exception edge from " + pei);
}
subroutine.setUnhandledExceptionBlock(etb);
}
} | java | private void handleExceptions(Subroutine subroutine, InstructionHandle pei, BasicBlock etb) {
etb.setExceptionThrower(pei);
// Remember whether or not a universal exception handler
// is reachable. If so, then we know that exceptions raised
// at this instruction cannot propagate out of the method.
boolean sawUniversalExceptionHandler = false;
List<CodeExceptionGen> exceptionHandlerList = exceptionHandlerMap.getHandlerList(pei);
if (exceptionHandlerList != null) {
for (CodeExceptionGen exceptionHandler : exceptionHandlerList) {
InstructionHandle handlerStart = exceptionHandler.getHandlerPC();
subroutine.addEdgeAndExplore(etb, handlerStart, HANDLED_EXCEPTION_EDGE);
if (Hierarchy.isUniversalExceptionHandler(exceptionHandler.getCatchType())) {
sawUniversalExceptionHandler = true;
}
}
}
// If required, mark this block as throwing an unhandled exception.
// For now, we assume that if there is no reachable handler that handles
// ANY exception type, then the exception can be thrown out of the
// method.
if (!sawUniversalExceptionHandler) {
if (DEBUG) {
System.out.println("Adding unhandled exception edge from " + pei);
}
subroutine.setUnhandledExceptionBlock(etb);
}
} | [
"private",
"void",
"handleExceptions",
"(",
"Subroutine",
"subroutine",
",",
"InstructionHandle",
"pei",
",",
"BasicBlock",
"etb",
")",
"{",
"etb",
".",
"setExceptionThrower",
"(",
"pei",
")",
";",
"// Remember whether or not a universal exception handler",
"// is reachab... | Add exception edges for given instruction.
@param subroutine
the subroutine containing the instruction
@param pei
the instruction which throws an exception
@param etb
the exception thrower block (ETB) for the instruction | [
"Add",
"exception",
"edges",
"for",
"given",
"instruction",
"."
] | f6365c6eea6515035bded38efa4a7c8b46ccf28c | https://github.com/spotbugs/spotbugs/blob/f6365c6eea6515035bded38efa4a7c8b46ccf28c/spotbugs/src/main/java/edu/umd/cs/findbugs/ba/BetterCFGBuilder2.java#L941-L971 | train |
spotbugs/spotbugs | spotbugs/src/main/java/edu/umd/cs/findbugs/ba/BetterCFGBuilder2.java | BetterCFGBuilder2.isPEI | private boolean isPEI(InstructionHandle handle) throws CFGBuilderException {
Instruction ins = handle.getInstruction();
if (!(ins instanceof ExceptionThrower)) {
return false;
}
if (ins instanceof NEW) {
return false;
}
// if (ins instanceof ATHROW) return false;
if (ins instanceof GETSTATIC) {
return false;
}
if (ins instanceof PUTSTATIC) {
return false;
}
if (ins instanceof ReturnInstruction) {
return false;
}
if (ins instanceof INSTANCEOF) {
return false;
}
if (ins instanceof MONITOREXIT) {
return false;
}
if (ins instanceof LDC) {
return false;
}
if (ins instanceof GETFIELD && !methodGen.isStatic()) {
// Assume that GETFIELD on this object is not PEI
return !isSafeFieldSource(handle.getPrev());
}
if (ins instanceof PUTFIELD && !methodGen.isStatic()) {
// Assume that PUTFIELD on this object is not PEI
int depth = ins.consumeStack(cpg);
for(InstructionHandle prev = handle.getPrev(); prev != null; prev = prev.getPrev()) {
Instruction prevInst = prev.getInstruction();
if(prevInst instanceof BranchInstruction) {
if(prevInst instanceof GotoInstruction) {
// Currently we support only jumps to the PUTFIELD itself
// This will cover simple cases like this.a = flag ? foo : bar
if(((BranchInstruction) prevInst).getTarget() == handle) {
depth = ins.consumeStack(cpg);
} else {
return true;
}
} else if (!(prevInst instanceof IfInstruction)) {
// As IF instructions may fall through then the stack depth remains unchanged
// Actually we should not go here for normal Java bytecode: switch or jsr should not appear in this context
return true;
}
}
depth = depth - prevInst.produceStack(cpg) + prevInst.consumeStack(cpg);
if(depth < 1) {
throw new CFGBuilderException("Invalid stack at "+prev+" when checking "+handle);
}
if(depth == 1) {
InstructionHandle prevPrev = prev.getPrev();
if(prevPrev != null && prevPrev.getInstruction() instanceof BranchInstruction) {
continue;
}
return !isSafeFieldSource(prevPrev);
}
}
}
return true;
} | java | private boolean isPEI(InstructionHandle handle) throws CFGBuilderException {
Instruction ins = handle.getInstruction();
if (!(ins instanceof ExceptionThrower)) {
return false;
}
if (ins instanceof NEW) {
return false;
}
// if (ins instanceof ATHROW) return false;
if (ins instanceof GETSTATIC) {
return false;
}
if (ins instanceof PUTSTATIC) {
return false;
}
if (ins instanceof ReturnInstruction) {
return false;
}
if (ins instanceof INSTANCEOF) {
return false;
}
if (ins instanceof MONITOREXIT) {
return false;
}
if (ins instanceof LDC) {
return false;
}
if (ins instanceof GETFIELD && !methodGen.isStatic()) {
// Assume that GETFIELD on this object is not PEI
return !isSafeFieldSource(handle.getPrev());
}
if (ins instanceof PUTFIELD && !methodGen.isStatic()) {
// Assume that PUTFIELD on this object is not PEI
int depth = ins.consumeStack(cpg);
for(InstructionHandle prev = handle.getPrev(); prev != null; prev = prev.getPrev()) {
Instruction prevInst = prev.getInstruction();
if(prevInst instanceof BranchInstruction) {
if(prevInst instanceof GotoInstruction) {
// Currently we support only jumps to the PUTFIELD itself
// This will cover simple cases like this.a = flag ? foo : bar
if(((BranchInstruction) prevInst).getTarget() == handle) {
depth = ins.consumeStack(cpg);
} else {
return true;
}
} else if (!(prevInst instanceof IfInstruction)) {
// As IF instructions may fall through then the stack depth remains unchanged
// Actually we should not go here for normal Java bytecode: switch or jsr should not appear in this context
return true;
}
}
depth = depth - prevInst.produceStack(cpg) + prevInst.consumeStack(cpg);
if(depth < 1) {
throw new CFGBuilderException("Invalid stack at "+prev+" when checking "+handle);
}
if(depth == 1) {
InstructionHandle prevPrev = prev.getPrev();
if(prevPrev != null && prevPrev.getInstruction() instanceof BranchInstruction) {
continue;
}
return !isSafeFieldSource(prevPrev);
}
}
}
return true;
} | [
"private",
"boolean",
"isPEI",
"(",
"InstructionHandle",
"handle",
")",
"throws",
"CFGBuilderException",
"{",
"Instruction",
"ins",
"=",
"handle",
".",
"getInstruction",
"(",
")",
";",
"if",
"(",
"!",
"(",
"ins",
"instanceof",
"ExceptionThrower",
")",
")",
"{"... | Return whether or not the given instruction can throw exceptions.
@param handle
the instruction
@return true if the instruction can throw an exception, false otherwise
@throws CFGBuilderException | [
"Return",
"whether",
"or",
"not",
"the",
"given",
"instruction",
"can",
"throw",
"exceptions",
"."
] | f6365c6eea6515035bded38efa4a7c8b46ccf28c | https://github.com/spotbugs/spotbugs/blob/f6365c6eea6515035bded38efa4a7c8b46ccf28c/spotbugs/src/main/java/edu/umd/cs/findbugs/ba/BetterCFGBuilder2.java#L981-L1048 | train |
spotbugs/spotbugs | spotbugs/src/main/java/edu/umd/cs/findbugs/ba/BetterCFGBuilder2.java | BetterCFGBuilder2.isMerge | private static boolean isMerge(InstructionHandle handle) {
if (handle.hasTargeters()) {
// Check all targeters of this handle to see if any
// of them are branches. If so, the instruction is a merge.
InstructionTargeter[] targeterList = handle.getTargeters();
for (InstructionTargeter targeter : targeterList) {
if (targeter instanceof BranchInstruction) {
return true;
}
}
}
return false;
} | java | private static boolean isMerge(InstructionHandle handle) {
if (handle.hasTargeters()) {
// Check all targeters of this handle to see if any
// of them are branches. If so, the instruction is a merge.
InstructionTargeter[] targeterList = handle.getTargeters();
for (InstructionTargeter targeter : targeterList) {
if (targeter instanceof BranchInstruction) {
return true;
}
}
}
return false;
} | [
"private",
"static",
"boolean",
"isMerge",
"(",
"InstructionHandle",
"handle",
")",
"{",
"if",
"(",
"handle",
".",
"hasTargeters",
"(",
")",
")",
"{",
"// Check all targeters of this handle to see if any",
"// of them are branches. If so, the instruction is a merge.",
"Instru... | Determine whether or not the given instruction is a control flow merge.
@param handle
the instruction
@return true if the instruction is a control merge, false otherwise | [
"Determine",
"whether",
"or",
"not",
"the",
"given",
"instruction",
"is",
"a",
"control",
"flow",
"merge",
"."
] | f6365c6eea6515035bded38efa4a7c8b46ccf28c | https://github.com/spotbugs/spotbugs/blob/f6365c6eea6515035bded38efa4a7c8b46ccf28c/spotbugs/src/main/java/edu/umd/cs/findbugs/ba/BetterCFGBuilder2.java#L1077-L1089 | train |
spotbugs/spotbugs | spotbugs/src/main/java/edu/umd/cs/findbugs/ba/BetterCFGBuilder2.java | BetterCFGBuilder2.inlineAll | private CFG inlineAll() throws CFGBuilderException {
CFG result = new CFG();
Context rootContext = new Context(null, topLevelSubroutine, result);
rootContext.mapBlock(topLevelSubroutine.getEntry(), result.getEntry());
rootContext.mapBlock(topLevelSubroutine.getExit(), result.getExit());
BasicBlock resultStartBlock = rootContext.getBlock(topLevelSubroutine.getStartBlock());
result.createEdge(result.getEntry(), resultStartBlock, START_EDGE);
inline(rootContext);
return result;
} | java | private CFG inlineAll() throws CFGBuilderException {
CFG result = new CFG();
Context rootContext = new Context(null, topLevelSubroutine, result);
rootContext.mapBlock(topLevelSubroutine.getEntry(), result.getEntry());
rootContext.mapBlock(topLevelSubroutine.getExit(), result.getExit());
BasicBlock resultStartBlock = rootContext.getBlock(topLevelSubroutine.getStartBlock());
result.createEdge(result.getEntry(), resultStartBlock, START_EDGE);
inline(rootContext);
return result;
} | [
"private",
"CFG",
"inlineAll",
"(",
")",
"throws",
"CFGBuilderException",
"{",
"CFG",
"result",
"=",
"new",
"CFG",
"(",
")",
";",
"Context",
"rootContext",
"=",
"new",
"Context",
"(",
"null",
",",
"topLevelSubroutine",
",",
"result",
")",
";",
"rootContext",... | Inline all JSR subroutines into the top-level subroutine. This produces a
complete CFG for the entire method, in which all JSR subroutines are
inlined.
@return the CFG for the method | [
"Inline",
"all",
"JSR",
"subroutines",
"into",
"the",
"top",
"-",
"level",
"subroutine",
".",
"This",
"produces",
"a",
"complete",
"CFG",
"for",
"the",
"entire",
"method",
"in",
"which",
"all",
"JSR",
"subroutines",
"are",
"inlined",
"."
] | f6365c6eea6515035bded38efa4a7c8b46ccf28c | https://github.com/spotbugs/spotbugs/blob/f6365c6eea6515035bded38efa4a7c8b46ccf28c/spotbugs/src/main/java/edu/umd/cs/findbugs/ba/BetterCFGBuilder2.java#L1098-L1111 | train |
spotbugs/spotbugs | spotbugs/src/main/java/edu/umd/cs/findbugs/ba/BetterCFGBuilder2.java | BetterCFGBuilder2.main | public static void main(String[] argv) throws Exception {
if (argv.length != 1) {
System.err.println("Usage: " + BetterCFGBuilder2.class.getName() + " <class file>");
System.exit(1);
}
String methodName = SystemProperties.getProperty("cfgbuilder.method");
JavaClass jclass = new ClassParser(argv[0]).parse();
ClassGen classGen = new ClassGen(jclass);
Method[] methodList = jclass.getMethods();
for (Method method : methodList) {
if (method.isAbstract() || method.isNative()) {
continue;
}
if (methodName != null && !method.getName().equals(methodName)) {
continue;
}
MethodDescriptor descriptor = DescriptorFactory.instance().getMethodDescriptor(jclass, method);
MethodGen methodGen = new MethodGen(method, jclass.getClassName(), classGen.getConstantPool());
CFGBuilder cfgBuilder = new BetterCFGBuilder2(descriptor, methodGen);
cfgBuilder.build();
CFG cfg = cfgBuilder.getCFG();
CFGPrinter cfgPrinter = new CFGPrinter(cfg);
System.out.println("---------------------------------------------------------------------");
System.out.println("Method: " + SignatureConverter.convertMethodSignature(methodGen));
System.out.println("---------------------------------------------------------------------");
cfgPrinter.print(System.out);
}
} | java | public static void main(String[] argv) throws Exception {
if (argv.length != 1) {
System.err.println("Usage: " + BetterCFGBuilder2.class.getName() + " <class file>");
System.exit(1);
}
String methodName = SystemProperties.getProperty("cfgbuilder.method");
JavaClass jclass = new ClassParser(argv[0]).parse();
ClassGen classGen = new ClassGen(jclass);
Method[] methodList = jclass.getMethods();
for (Method method : methodList) {
if (method.isAbstract() || method.isNative()) {
continue;
}
if (methodName != null && !method.getName().equals(methodName)) {
continue;
}
MethodDescriptor descriptor = DescriptorFactory.instance().getMethodDescriptor(jclass, method);
MethodGen methodGen = new MethodGen(method, jclass.getClassName(), classGen.getConstantPool());
CFGBuilder cfgBuilder = new BetterCFGBuilder2(descriptor, methodGen);
cfgBuilder.build();
CFG cfg = cfgBuilder.getCFG();
CFGPrinter cfgPrinter = new CFGPrinter(cfg);
System.out.println("---------------------------------------------------------------------");
System.out.println("Method: " + SignatureConverter.convertMethodSignature(methodGen));
System.out.println("---------------------------------------------------------------------");
cfgPrinter.print(System.out);
}
} | [
"public",
"static",
"void",
"main",
"(",
"String",
"[",
"]",
"argv",
")",
"throws",
"Exception",
"{",
"if",
"(",
"argv",
".",
"length",
"!=",
"1",
")",
"{",
"System",
".",
"err",
".",
"println",
"(",
"\"Usage: \"",
"+",
"BetterCFGBuilder2",
".",
"class... | Test driver. | [
"Test",
"driver",
"."
] | f6365c6eea6515035bded38efa4a7c8b46ccf28c | https://github.com/spotbugs/spotbugs/blob/f6365c6eea6515035bded38efa4a7c8b46ccf28c/spotbugs/src/main/java/edu/umd/cs/findbugs/ba/BetterCFGBuilder2.java#L1271-L1306 | train |
spotbugs/spotbugs | spotbugs/src/main/java/edu/umd/cs/findbugs/ba/XFactory.java | XFactory.createXField | public static XField createXField(String className, Field field) {
String fieldName = field.getName();
String fieldSig = field.getSignature();
XField xfield = getExactXField(className, fieldName, fieldSig, field.isStatic());
assert xfield.isResolved() : "Could not exactly resolve " + xfield;
return xfield;
} | java | public static XField createXField(String className, Field field) {
String fieldName = field.getName();
String fieldSig = field.getSignature();
XField xfield = getExactXField(className, fieldName, fieldSig, field.isStatic());
assert xfield.isResolved() : "Could not exactly resolve " + xfield;
return xfield;
} | [
"public",
"static",
"XField",
"createXField",
"(",
"String",
"className",
",",
"Field",
"field",
")",
"{",
"String",
"fieldName",
"=",
"field",
".",
"getName",
"(",
")",
";",
"String",
"fieldSig",
"=",
"field",
".",
"getSignature",
"(",
")",
";",
"XField",... | Create an XField object from a BCEL Field.
@param className
the name of the Java class containing the field
@param field
the Field within the JavaClass
@return the created XField | [
"Create",
"an",
"XField",
"object",
"from",
"a",
"BCEL",
"Field",
"."
] | f6365c6eea6515035bded38efa4a7c8b46ccf28c | https://github.com/spotbugs/spotbugs/blob/f6365c6eea6515035bded38efa4a7c8b46ccf28c/spotbugs/src/main/java/edu/umd/cs/findbugs/ba/XFactory.java#L509-L516 | train |
spotbugs/spotbugs | spotbugs/src/main/java/edu/umd/cs/findbugs/ba/XFactory.java | XFactory.createXMethod | public static XMethod createXMethod(InvokeInstruction invokeInstruction, ConstantPoolGen cpg) {
String className = invokeInstruction.getClassName(cpg);
String methodName = invokeInstruction.getName(cpg);
String methodSig = invokeInstruction.getSignature(cpg);
if (invokeInstruction instanceof INVOKEDYNAMIC) {
// XXX the lambda representation makes no sense for XMethod
// "classical" instruction attributes are filled with garbage, causing
// the code later to produce crazy errors (looking for non existing types etc)
// We should NOT be called here from our code, but 3rd party code still may
// use this method. So *at least* provide a valid class name, which is
// (don't ask me why) is encoded in the first argument type of the lambda
// className = invokeInstruction.getArgumentTypes(cpg)[0].toString();
className = Values.DOTTED_JAVA_LANG_OBJECT;
}
return createXMethod(className, methodName, methodSig, invokeInstruction.getOpcode() == Const.INVOKESTATIC);
} | java | public static XMethod createXMethod(InvokeInstruction invokeInstruction, ConstantPoolGen cpg) {
String className = invokeInstruction.getClassName(cpg);
String methodName = invokeInstruction.getName(cpg);
String methodSig = invokeInstruction.getSignature(cpg);
if (invokeInstruction instanceof INVOKEDYNAMIC) {
// XXX the lambda representation makes no sense for XMethod
// "classical" instruction attributes are filled with garbage, causing
// the code later to produce crazy errors (looking for non existing types etc)
// We should NOT be called here from our code, but 3rd party code still may
// use this method. So *at least* provide a valid class name, which is
// (don't ask me why) is encoded in the first argument type of the lambda
// className = invokeInstruction.getArgumentTypes(cpg)[0].toString();
className = Values.DOTTED_JAVA_LANG_OBJECT;
}
return createXMethod(className, methodName, methodSig, invokeInstruction.getOpcode() == Const.INVOKESTATIC);
} | [
"public",
"static",
"XMethod",
"createXMethod",
"(",
"InvokeInstruction",
"invokeInstruction",
",",
"ConstantPoolGen",
"cpg",
")",
"{",
"String",
"className",
"=",
"invokeInstruction",
".",
"getClassName",
"(",
"cpg",
")",
";",
"String",
"methodName",
"=",
"invokeIn... | Create an XMethod object from an InvokeInstruction.
@param invokeInstruction
the InvokeInstruction
@param cpg
ConstantPoolGen from the class containing the instruction
@return XMethod representing the method called by the InvokeInstruction | [
"Create",
"an",
"XMethod",
"object",
"from",
"an",
"InvokeInstruction",
"."
] | f6365c6eea6515035bded38efa4a7c8b46ccf28c | https://github.com/spotbugs/spotbugs/blob/f6365c6eea6515035bded38efa4a7c8b46ccf28c/spotbugs/src/main/java/edu/umd/cs/findbugs/ba/XFactory.java#L616-L631 | train |
spotbugs/spotbugs | spotbugs/src/main/java/edu/umd/cs/findbugs/ba/XFactory.java | XFactory.createXMethod | public static XMethod createXMethod(PreorderVisitor visitor) {
JavaClass javaClass = visitor.getThisClass();
Method method = visitor.getMethod();
XMethod m = createXMethod(javaClass, method);
return m;
} | java | public static XMethod createXMethod(PreorderVisitor visitor) {
JavaClass javaClass = visitor.getThisClass();
Method method = visitor.getMethod();
XMethod m = createXMethod(javaClass, method);
return m;
} | [
"public",
"static",
"XMethod",
"createXMethod",
"(",
"PreorderVisitor",
"visitor",
")",
"{",
"JavaClass",
"javaClass",
"=",
"visitor",
".",
"getThisClass",
"(",
")",
";",
"Method",
"method",
"=",
"visitor",
".",
"getMethod",
"(",
")",
";",
"XMethod",
"m",
"=... | Create an XMethod object from the method currently being visited by the
given PreorderVisitor.
@param visitor
the PreorderVisitor
@return the XMethod representing the method currently being visited | [
"Create",
"an",
"XMethod",
"object",
"from",
"the",
"method",
"currently",
"being",
"visited",
"by",
"the",
"given",
"PreorderVisitor",
"."
] | f6365c6eea6515035bded38efa4a7c8b46ccf28c | https://github.com/spotbugs/spotbugs/blob/f6365c6eea6515035bded38efa4a7c8b46ccf28c/spotbugs/src/main/java/edu/umd/cs/findbugs/ba/XFactory.java#L641-L646 | train |
spotbugs/spotbugs | spotbugs/src/main/java/edu/umd/cs/findbugs/ba/XFactory.java | XFactory.createXField | public static XField createXField(PreorderVisitor visitor) {
JavaClass javaClass = visitor.getThisClass();
Field field = visitor.getField();
XField f = createXField(javaClass, field);
return f;
} | java | public static XField createXField(PreorderVisitor visitor) {
JavaClass javaClass = visitor.getThisClass();
Field field = visitor.getField();
XField f = createXField(javaClass, field);
return f;
} | [
"public",
"static",
"XField",
"createXField",
"(",
"PreorderVisitor",
"visitor",
")",
"{",
"JavaClass",
"javaClass",
"=",
"visitor",
".",
"getThisClass",
"(",
")",
";",
"Field",
"field",
"=",
"visitor",
".",
"getField",
"(",
")",
";",
"XField",
"f",
"=",
"... | Create an XField object from the field currently being visited by the
given PreorderVisitor.
@param visitor
the PreorderVisitor
@return the XField representing the method currently being visited | [
"Create",
"an",
"XField",
"object",
"from",
"the",
"field",
"currently",
"being",
"visited",
"by",
"the",
"given",
"PreorderVisitor",
"."
] | f6365c6eea6515035bded38efa4a7c8b46ccf28c | https://github.com/spotbugs/spotbugs/blob/f6365c6eea6515035bded38efa4a7c8b46ccf28c/spotbugs/src/main/java/edu/umd/cs/findbugs/ba/XFactory.java#L656-L661 | train |
spotbugs/spotbugs | spotbugs/src/main/java/edu/umd/cs/findbugs/ba/XFactory.java | XFactory.getXClass | public @CheckForNull
XClass getXClass(ClassDescriptor classDescriptor) {
try {
IAnalysisCache analysisCache = Global.getAnalysisCache();
return analysisCache.getClassAnalysis(XClass.class, classDescriptor);
} catch (CheckedAnalysisException e) {
return null;
}
} | java | public @CheckForNull
XClass getXClass(ClassDescriptor classDescriptor) {
try {
IAnalysisCache analysisCache = Global.getAnalysisCache();
return analysisCache.getClassAnalysis(XClass.class, classDescriptor);
} catch (CheckedAnalysisException e) {
return null;
}
} | [
"public",
"@",
"CheckForNull",
"XClass",
"getXClass",
"(",
"ClassDescriptor",
"classDescriptor",
")",
"{",
"try",
"{",
"IAnalysisCache",
"analysisCache",
"=",
"Global",
".",
"getAnalysisCache",
"(",
")",
";",
"return",
"analysisCache",
".",
"getClassAnalysis",
"(",
... | Get the XClass object providing information about the class named by the
given ClassDescriptor.
@param classDescriptor
a ClassDescriptor
@return an XClass object providing information about the class, or null
if the class cannot be found | [
"Get",
"the",
"XClass",
"object",
"providing",
"information",
"about",
"the",
"class",
"named",
"by",
"the",
"given",
"ClassDescriptor",
"."
] | f6365c6eea6515035bded38efa4a7c8b46ccf28c | https://github.com/spotbugs/spotbugs/blob/f6365c6eea6515035bded38efa4a7c8b46ccf28c/spotbugs/src/main/java/edu/umd/cs/findbugs/ba/XFactory.java#L684-L692 | train |
spotbugs/spotbugs | eclipsePlugin/src/de/tobject/findbugs/actions/FindBugsAction.java | FindBugsAction.work | protected void work(IWorkbenchPart part, final IResource resource, final List<WorkItem> resources) {
FindBugsJob runFindBugs = new StartedFromViewJob("Finding bugs in " + resource.getName() + "...", resource, resources, part);
runFindBugs.scheduleInteractive();
} | java | protected void work(IWorkbenchPart part, final IResource resource, final List<WorkItem> resources) {
FindBugsJob runFindBugs = new StartedFromViewJob("Finding bugs in " + resource.getName() + "...", resource, resources, part);
runFindBugs.scheduleInteractive();
} | [
"protected",
"void",
"work",
"(",
"IWorkbenchPart",
"part",
",",
"final",
"IResource",
"resource",
",",
"final",
"List",
"<",
"WorkItem",
">",
"resources",
")",
"{",
"FindBugsJob",
"runFindBugs",
"=",
"new",
"StartedFromViewJob",
"(",
"\"Finding bugs in \"",
"+",
... | Run a FindBugs analysis on the given resource, displaying a progress
monitor.
@param part
@param resources
The resource to run the analysis on. | [
"Run",
"a",
"FindBugs",
"analysis",
"on",
"the",
"given",
"resource",
"displaying",
"a",
"progress",
"monitor",
"."
] | f6365c6eea6515035bded38efa4a7c8b46ccf28c | https://github.com/spotbugs/spotbugs/blob/f6365c6eea6515035bded38efa4a7c8b46ccf28c/eclipsePlugin/src/de/tobject/findbugs/actions/FindBugsAction.java#L167-L170 | train |
spotbugs/spotbugs | spotbugs-ant/src/main/java/edu/umd/cs/findbugs/anttask/AbstractFindBugsTask.java | AbstractFindBugsTask.setClasspath | public void setClasspath(Path src) {
if (classpath == null) {
classpath = src;
} else {
classpath.append(src);
}
} | java | public void setClasspath(Path src) {
if (classpath == null) {
classpath = src;
} else {
classpath.append(src);
}
} | [
"public",
"void",
"setClasspath",
"(",
"Path",
"src",
")",
"{",
"if",
"(",
"classpath",
"==",
"null",
")",
"{",
"classpath",
"=",
"src",
";",
"}",
"else",
"{",
"classpath",
".",
"append",
"(",
"src",
")",
";",
"}",
"}"
] | Set the classpath to use.
@param src
classpath to use | [
"Set",
"the",
"classpath",
"to",
"use",
"."
] | f6365c6eea6515035bded38efa4a7c8b46ccf28c | https://github.com/spotbugs/spotbugs/blob/f6365c6eea6515035bded38efa4a7c8b46ccf28c/spotbugs-ant/src/main/java/edu/umd/cs/findbugs/anttask/AbstractFindBugsTask.java#L200-L206 | train |
spotbugs/spotbugs | spotbugs-ant/src/main/java/edu/umd/cs/findbugs/anttask/AbstractFindBugsTask.java | AbstractFindBugsTask.setClasspathRef | public void setClasspathRef(Reference r) {
Path path = createClasspath();
path.setRefid(r);
path.toString(); // Evaluated for its side-effects (throwing a
// BuildException)
} | java | public void setClasspathRef(Reference r) {
Path path = createClasspath();
path.setRefid(r);
path.toString(); // Evaluated for its side-effects (throwing a
// BuildException)
} | [
"public",
"void",
"setClasspathRef",
"(",
"Reference",
"r",
")",
"{",
"Path",
"path",
"=",
"createClasspath",
"(",
")",
";",
"path",
".",
"setRefid",
"(",
"r",
")",
";",
"path",
".",
"toString",
"(",
")",
";",
"// Evaluated for its side-effects (throwing a",
... | Adds a reference to a classpath defined elsewhere.
@param r
reference to a classpath defined elsewhere | [
"Adds",
"a",
"reference",
"to",
"a",
"classpath",
"defined",
"elsewhere",
"."
] | f6365c6eea6515035bded38efa4a7c8b46ccf28c | https://github.com/spotbugs/spotbugs/blob/f6365c6eea6515035bded38efa4a7c8b46ccf28c/spotbugs-ant/src/main/java/edu/umd/cs/findbugs/anttask/AbstractFindBugsTask.java#L226-L231 | train |
spotbugs/spotbugs | spotbugs-ant/src/main/java/edu/umd/cs/findbugs/anttask/AbstractFindBugsTask.java | AbstractFindBugsTask.checkParameters | protected void checkParameters() {
if (homeDir == null && classpath == null) {
throw new BuildException("either home attribute or " + "classpath attributes "
+ " must be defined for task <" + getTaskName() + "/>", getLocation());
}
if (pluginList != null) {
// Make sure that all plugins are actually Jar files.
String[] pluginFileList = pluginList.list();
for (String pluginFile : pluginFileList) {
if (!pluginFile.endsWith(".jar")) {
throw new BuildException("plugin file " + pluginFile + " is not a Jar file " + "in task <" + getTaskName()
+ "/>", getLocation());
}
}
}
for (SystemProperty systemProperty : systemPropertyList) {
if (systemProperty.getName() == null || systemProperty.getValue() == null) {
throw new BuildException("systemProperty elements must have name and value attributes");
}
}
} | java | protected void checkParameters() {
if (homeDir == null && classpath == null) {
throw new BuildException("either home attribute or " + "classpath attributes "
+ " must be defined for task <" + getTaskName() + "/>", getLocation());
}
if (pluginList != null) {
// Make sure that all plugins are actually Jar files.
String[] pluginFileList = pluginList.list();
for (String pluginFile : pluginFileList) {
if (!pluginFile.endsWith(".jar")) {
throw new BuildException("plugin file " + pluginFile + " is not a Jar file " + "in task <" + getTaskName()
+ "/>", getLocation());
}
}
}
for (SystemProperty systemProperty : systemPropertyList) {
if (systemProperty.getName() == null || systemProperty.getValue() == null) {
throw new BuildException("systemProperty elements must have name and value attributes");
}
}
} | [
"protected",
"void",
"checkParameters",
"(",
")",
"{",
"if",
"(",
"homeDir",
"==",
"null",
"&&",
"classpath",
"==",
"null",
")",
"{",
"throw",
"new",
"BuildException",
"(",
"\"either home attribute or \"",
"+",
"\"classpath attributes \"",
"+",
"\" must be defined f... | Check that all required attributes have been set. | [
"Check",
"that",
"all",
"required",
"attributes",
"have",
"been",
"set",
"."
] | f6365c6eea6515035bded38efa4a7c8b46ccf28c | https://github.com/spotbugs/spotbugs/blob/f6365c6eea6515035bded38efa4a7c8b46ccf28c/spotbugs-ant/src/main/java/edu/umd/cs/findbugs/anttask/AbstractFindBugsTask.java#L288-L310 | train |
spotbugs/spotbugs | spotbugs-ant/src/main/java/edu/umd/cs/findbugs/anttask/AbstractFindBugsTask.java | AbstractFindBugsTask.execFindbugs | private void execFindbugs() throws BuildException {
System.out.println("Executing SpotBugs " + this.getClass().getSimpleName() + " from ant task");
createFindbugsEngine();
configureFindbugsEngine();
beforeExecuteJavaProcess();
if (getDebug()) {
log(getFindbugsEngine().getCommandLine().describeCommand());
}
/*
* set property containing return code of child process using a task
* identifier and a UUID to ensure exit code corresponds to this
* execution (the base Ant Task won't overwrite return code once it's
* been set, so unique identifiers must be used for each execution if we
* want to get the exit code)
*/
String execReturnCodeIdentifier = execResultProperty + "." + UUID.randomUUID().toString();
getFindbugsEngine().setResultProperty(execReturnCodeIdentifier);
/*
* if the execution fails, we'll report it ourself -- prevent the
* underlying Ant Java object from throwing an exception
*/
getFindbugsEngine().setFailonerror(false);
try {
getFindbugsEngine().execute();
} catch (BuildException be) {
// setFailonerror(false) should ensure that this doesn't happen,
// but...
log(be.toString());
}
String returnProperty = getFindbugsEngine().getProject().getProperty(execReturnCodeIdentifier);
int rc = returnProperty == null ? 0 : Integer.parseInt(returnProperty);
afterExecuteJavaProcess(rc);
} | java | private void execFindbugs() throws BuildException {
System.out.println("Executing SpotBugs " + this.getClass().getSimpleName() + " from ant task");
createFindbugsEngine();
configureFindbugsEngine();
beforeExecuteJavaProcess();
if (getDebug()) {
log(getFindbugsEngine().getCommandLine().describeCommand());
}
/*
* set property containing return code of child process using a task
* identifier and a UUID to ensure exit code corresponds to this
* execution (the base Ant Task won't overwrite return code once it's
* been set, so unique identifiers must be used for each execution if we
* want to get the exit code)
*/
String execReturnCodeIdentifier = execResultProperty + "." + UUID.randomUUID().toString();
getFindbugsEngine().setResultProperty(execReturnCodeIdentifier);
/*
* if the execution fails, we'll report it ourself -- prevent the
* underlying Ant Java object from throwing an exception
*/
getFindbugsEngine().setFailonerror(false);
try {
getFindbugsEngine().execute();
} catch (BuildException be) {
// setFailonerror(false) should ensure that this doesn't happen,
// but...
log(be.toString());
}
String returnProperty = getFindbugsEngine().getProject().getProperty(execReturnCodeIdentifier);
int rc = returnProperty == null ? 0 : Integer.parseInt(returnProperty);
afterExecuteJavaProcess(rc);
} | [
"private",
"void",
"execFindbugs",
"(",
")",
"throws",
"BuildException",
"{",
"System",
".",
"out",
".",
"println",
"(",
"\"Executing SpotBugs \"",
"+",
"this",
".",
"getClass",
"(",
")",
".",
"getSimpleName",
"(",
")",
"+",
"\" from ant task\"",
")",
";",
"... | Create a new JVM to do the work.
@since Ant 1.5 | [
"Create",
"a",
"new",
"JVM",
"to",
"do",
"the",
"work",
"."
] | f6365c6eea6515035bded38efa4a7c8b46ccf28c | https://github.com/spotbugs/spotbugs/blob/f6365c6eea6515035bded38efa4a7c8b46ccf28c/spotbugs-ant/src/main/java/edu/umd/cs/findbugs/anttask/AbstractFindBugsTask.java#L400-L438 | train |
spotbugs/spotbugs | spotbugs/src/main/java/edu/umd/cs/findbugs/FindBugs.java | FindBugs.configureTrainingDatabases | public static void configureTrainingDatabases(IFindBugsEngine findBugs) throws IOException {
if (findBugs.emitTrainingOutput()) {
String trainingOutputDir = findBugs.getTrainingOutputDir();
if (!new File(trainingOutputDir).isDirectory()) {
throw new IOException("Training output directory " + trainingOutputDir + " does not exist");
}
AnalysisContext.currentAnalysisContext().setDatabaseOutputDir(trainingOutputDir);
// XXX: hack
System.setProperty("findbugs.checkreturn.savetraining", new File(trainingOutputDir, "checkReturn.db").getPath());
}
if (findBugs.useTrainingInput()) {
String trainingInputDir = findBugs.getTrainingInputDir();
if (!new File(trainingInputDir).isDirectory()) {
throw new IOException("Training input directory " + trainingInputDir + " does not exist");
}
AnalysisContext.currentAnalysisContext().setDatabaseInputDir(trainingInputDir);
AnalysisContext.currentAnalysisContext().loadInterproceduralDatabases();
// XXX: hack
System.setProperty("findbugs.checkreturn.loadtraining", new File(trainingInputDir, "checkReturn.db").getPath());
} else {
AnalysisContext.currentAnalysisContext().loadDefaultInterproceduralDatabases();
}
} | java | public static void configureTrainingDatabases(IFindBugsEngine findBugs) throws IOException {
if (findBugs.emitTrainingOutput()) {
String trainingOutputDir = findBugs.getTrainingOutputDir();
if (!new File(trainingOutputDir).isDirectory()) {
throw new IOException("Training output directory " + trainingOutputDir + " does not exist");
}
AnalysisContext.currentAnalysisContext().setDatabaseOutputDir(trainingOutputDir);
// XXX: hack
System.setProperty("findbugs.checkreturn.savetraining", new File(trainingOutputDir, "checkReturn.db").getPath());
}
if (findBugs.useTrainingInput()) {
String trainingInputDir = findBugs.getTrainingInputDir();
if (!new File(trainingInputDir).isDirectory()) {
throw new IOException("Training input directory " + trainingInputDir + " does not exist");
}
AnalysisContext.currentAnalysisContext().setDatabaseInputDir(trainingInputDir);
AnalysisContext.currentAnalysisContext().loadInterproceduralDatabases();
// XXX: hack
System.setProperty("findbugs.checkreturn.loadtraining", new File(trainingInputDir, "checkReturn.db").getPath());
} else {
AnalysisContext.currentAnalysisContext().loadDefaultInterproceduralDatabases();
}
} | [
"public",
"static",
"void",
"configureTrainingDatabases",
"(",
"IFindBugsEngine",
"findBugs",
")",
"throws",
"IOException",
"{",
"if",
"(",
"findBugs",
".",
"emitTrainingOutput",
"(",
")",
")",
"{",
"String",
"trainingOutputDir",
"=",
"findBugs",
".",
"getTrainingOu... | Configure training databases.
@param findBugs
the IFindBugsEngine to configure
@throws IOException | [
"Configure",
"training",
"databases",
"."
] | f6365c6eea6515035bded38efa4a7c8b46ccf28c | https://github.com/spotbugs/spotbugs/blob/f6365c6eea6515035bded38efa4a7c8b46ccf28c/spotbugs/src/main/java/edu/umd/cs/findbugs/FindBugs.java#L218-L242 | train |
spotbugs/spotbugs | spotbugs/src/main/java/edu/umd/cs/findbugs/FindBugs.java | FindBugs.isDetectorEnabled | public static boolean isDetectorEnabled(IFindBugsEngine findBugs, DetectorFactory factory, int rankThreshold) {
if (!findBugs.getUserPreferences().isDetectorEnabled(factory)) {
return false;
}
if (!factory.isEnabledForCurrentJRE()) {
return false;
}
// Slow first pass detectors are usually disabled, but may be explicitly
// enabled
if (!AnalysisContext.currentAnalysisContext().getBoolProperty(FindBugsAnalysisFeatures.INTERPROCEDURAL_ANALYSIS)
&& factory.isDetectorClassSubtypeOf(InterproceduralFirstPassDetector.class)) {
return false;
}
int maxRank = Integer.MAX_VALUE;
Set<BugPattern> reportedBugPatterns = factory.getReportedBugPatterns();
boolean isNonReportingDetector = factory.isDetectorClassSubtypeOf(FirstPassDetector.class);
if (!isNonReportingDetector && !reportedBugPatterns.isEmpty()) {
for (BugPattern b : reportedBugPatterns) {
int rank = BugRanker.findRank(b, factory);
if (maxRank > rank) {
maxRank = rank;
}
}
if (maxRank > rankThreshold) {
return false;
}
}
// Training detectors are enabled if, and only if, we are emitting
// training output
boolean isTrainingDetector = factory.isDetectorClassSubtypeOf(TrainingDetector.class);
if (findBugs.emitTrainingOutput()) {
return isTrainingDetector || isNonReportingDetector;
}
return !isTrainingDetector;
} | java | public static boolean isDetectorEnabled(IFindBugsEngine findBugs, DetectorFactory factory, int rankThreshold) {
if (!findBugs.getUserPreferences().isDetectorEnabled(factory)) {
return false;
}
if (!factory.isEnabledForCurrentJRE()) {
return false;
}
// Slow first pass detectors are usually disabled, but may be explicitly
// enabled
if (!AnalysisContext.currentAnalysisContext().getBoolProperty(FindBugsAnalysisFeatures.INTERPROCEDURAL_ANALYSIS)
&& factory.isDetectorClassSubtypeOf(InterproceduralFirstPassDetector.class)) {
return false;
}
int maxRank = Integer.MAX_VALUE;
Set<BugPattern> reportedBugPatterns = factory.getReportedBugPatterns();
boolean isNonReportingDetector = factory.isDetectorClassSubtypeOf(FirstPassDetector.class);
if (!isNonReportingDetector && !reportedBugPatterns.isEmpty()) {
for (BugPattern b : reportedBugPatterns) {
int rank = BugRanker.findRank(b, factory);
if (maxRank > rank) {
maxRank = rank;
}
}
if (maxRank > rankThreshold) {
return false;
}
}
// Training detectors are enabled if, and only if, we are emitting
// training output
boolean isTrainingDetector = factory.isDetectorClassSubtypeOf(TrainingDetector.class);
if (findBugs.emitTrainingOutput()) {
return isTrainingDetector || isNonReportingDetector;
}
return !isTrainingDetector;
} | [
"public",
"static",
"boolean",
"isDetectorEnabled",
"(",
"IFindBugsEngine",
"findBugs",
",",
"DetectorFactory",
"factory",
",",
"int",
"rankThreshold",
")",
"{",
"if",
"(",
"!",
"findBugs",
".",
"getUserPreferences",
"(",
")",
".",
"isDetectorEnabled",
"(",
"facto... | Determines whether or not given DetectorFactory should be enabled.
@param findBugs
the IFindBugsEngine
@param factory
the DetectorFactory
@param rankThreshold
TODO
@return true if the DetectorFactory should be enabled, false otherwise | [
"Determines",
"whether",
"or",
"not",
"given",
"DetectorFactory",
"should",
"be",
"enabled",
"."
] | f6365c6eea6515035bded38efa4a7c8b46ccf28c | https://github.com/spotbugs/spotbugs/blob/f6365c6eea6515035bded38efa4a7c8b46ccf28c/spotbugs/src/main/java/edu/umd/cs/findbugs/FindBugs.java#L255-L295 | train |
spotbugs/spotbugs | spotbugs/src/main/java/edu/umd/cs/findbugs/FindBugs.java | FindBugs.handleBugCategories | public static Set<String> handleBugCategories(String categories) {
// Parse list of bug categories
Set<String> categorySet = new HashSet<>();
StringTokenizer tok = new StringTokenizer(categories, ",");
while (tok.hasMoreTokens()) {
categorySet.add(tok.nextToken());
}
return categorySet;
} | java | public static Set<String> handleBugCategories(String categories) {
// Parse list of bug categories
Set<String> categorySet = new HashSet<>();
StringTokenizer tok = new StringTokenizer(categories, ",");
while (tok.hasMoreTokens()) {
categorySet.add(tok.nextToken());
}
return categorySet;
} | [
"public",
"static",
"Set",
"<",
"String",
">",
"handleBugCategories",
"(",
"String",
"categories",
")",
"{",
"// Parse list of bug categories",
"Set",
"<",
"String",
">",
"categorySet",
"=",
"new",
"HashSet",
"<>",
"(",
")",
";",
"StringTokenizer",
"tok",
"=",
... | Process -bugCategories option.
@param categories
comma-separated list of bug categories
@return Set of categories to be used | [
"Process",
"-",
"bugCategories",
"option",
"."
] | f6365c6eea6515035bded38efa4a7c8b46ccf28c | https://github.com/spotbugs/spotbugs/blob/f6365c6eea6515035bded38efa4a7c8b46ccf28c/spotbugs/src/main/java/edu/umd/cs/findbugs/FindBugs.java#L305-L314 | train |
spotbugs/spotbugs | spotbugs/src/main/java/edu/umd/cs/findbugs/FindBugs.java | FindBugs.processCommandLine | public static void processCommandLine(TextUICommandLine commandLine, String[] argv, IFindBugsEngine findBugs)
throws IOException, FilterException {
// Expand option files in command line.
// An argument beginning with "@" is treated as specifying
// the name of an option file.
// Each line of option files are treated as a single argument.
// Blank lines and comment lines (beginning with "#")
// are ignored.
try {
argv = commandLine.expandOptionFiles(argv, true, true);
} catch (HelpRequestedException e) {
showHelp(commandLine);
}
int argCount = 0;
try {
argCount = commandLine.parse(argv);
} catch (IllegalArgumentException e) {
LOG.severe(e.getMessage());
showHelp(commandLine);
} catch (HelpRequestedException e) {
showHelp(commandLine);
}
Project project = commandLine.getProject();
for (int i = argCount; i < argv.length; ++i) {
project.addFile(argv[i]);
}
commandLine.handleXArgs();
commandLine.configureEngine(findBugs);
if (commandLine.getProject().getFileCount() == 0 &&
!commandLine.justPrintConfiguration() && !commandLine.justPrintVersion()) {
LOG.warning("No files to be analyzed");
showHelp(commandLine);
}
} | java | public static void processCommandLine(TextUICommandLine commandLine, String[] argv, IFindBugsEngine findBugs)
throws IOException, FilterException {
// Expand option files in command line.
// An argument beginning with "@" is treated as specifying
// the name of an option file.
// Each line of option files are treated as a single argument.
// Blank lines and comment lines (beginning with "#")
// are ignored.
try {
argv = commandLine.expandOptionFiles(argv, true, true);
} catch (HelpRequestedException e) {
showHelp(commandLine);
}
int argCount = 0;
try {
argCount = commandLine.parse(argv);
} catch (IllegalArgumentException e) {
LOG.severe(e.getMessage());
showHelp(commandLine);
} catch (HelpRequestedException e) {
showHelp(commandLine);
}
Project project = commandLine.getProject();
for (int i = argCount; i < argv.length; ++i) {
project.addFile(argv[i]);
}
commandLine.handleXArgs();
commandLine.configureEngine(findBugs);
if (commandLine.getProject().getFileCount() == 0 &&
!commandLine.justPrintConfiguration() && !commandLine.justPrintVersion()) {
LOG.warning("No files to be analyzed");
showHelp(commandLine);
}
} | [
"public",
"static",
"void",
"processCommandLine",
"(",
"TextUICommandLine",
"commandLine",
",",
"String",
"[",
"]",
"argv",
",",
"IFindBugsEngine",
"findBugs",
")",
"throws",
"IOException",
",",
"FilterException",
"{",
"// Expand option files in command line.",
"// An arg... | Process the command line.
@param commandLine
the TextUICommandLine object which will parse the command line
@param argv
the command line arguments
@param findBugs
the IFindBugsEngine to configure
@throws IOException
@throws FilterException | [
"Process",
"the",
"command",
"line",
"."
] | f6365c6eea6515035bded38efa4a7c8b46ccf28c | https://github.com/spotbugs/spotbugs/blob/f6365c6eea6515035bded38efa4a7c8b46ccf28c/spotbugs/src/main/java/edu/umd/cs/findbugs/FindBugs.java#L328-L365 | train |
spotbugs/spotbugs | spotbugs/src/main/java/edu/umd/cs/findbugs/FindBugs.java | FindBugs.showHelp | @SuppressFBWarnings("DM_EXIT")
public static void showHelp(TextUICommandLine commandLine) {
showSynopsis();
ShowHelp.showGeneralOptions();
FindBugs.showCommandLineOptions(commandLine);
System.exit(1);
} | java | @SuppressFBWarnings("DM_EXIT")
public static void showHelp(TextUICommandLine commandLine) {
showSynopsis();
ShowHelp.showGeneralOptions();
FindBugs.showCommandLineOptions(commandLine);
System.exit(1);
} | [
"@",
"SuppressFBWarnings",
"(",
"\"DM_EXIT\"",
")",
"public",
"static",
"void",
"showHelp",
"(",
"TextUICommandLine",
"commandLine",
")",
"{",
"showSynopsis",
"(",
")",
";",
"ShowHelp",
".",
"showGeneralOptions",
"(",
")",
";",
"FindBugs",
".",
"showCommandLineOpt... | Show -help message.
@param commandLine | [
"Show",
"-",
"help",
"message",
"."
] | f6365c6eea6515035bded38efa4a7c8b46ccf28c | https://github.com/spotbugs/spotbugs/blob/f6365c6eea6515035bded38efa4a7c8b46ccf28c/spotbugs/src/main/java/edu/umd/cs/findbugs/FindBugs.java#L372-L378 | train |
spotbugs/spotbugs | spotbugs/src/main/java/edu/umd/cs/findbugs/FindBugs.java | FindBugs.runMain | @SuppressFBWarnings("DM_EXIT")
public static void runMain(IFindBugsEngine findBugs, TextUICommandLine commandLine) throws IOException {
boolean verbose = !commandLine.quiet();
try {
findBugs.execute();
} catch (InterruptedException e) {
assert false; // should not occur
checkExitCodeFail(commandLine, e);
throw new RuntimeException(e);
} catch (RuntimeException | IOException e) {
checkExitCodeFail(commandLine, e);
throw e;
}
int bugCount = findBugs.getBugCount();
int missingClassCount = findBugs.getMissingClassCount();
int errorCount = findBugs.getErrorCount();
if (verbose || commandLine.setExitCode()) {
LOG.log(FINE, "Warnings generated: {0}", bugCount);
LOG.log(FINE, "Missing classes: {0}", missingClassCount);
LOG.log(FINE, "Analysis errors: {0}", errorCount);
}
if (commandLine.setExitCode()) {
int exitCode = 0;
LOG.info("Calculating exit code...");
if (errorCount > 0) {
exitCode |= ExitCodes.ERROR_FLAG;
LOG.log(FINE, "Setting 'errors encountered' flag ({0})", ExitCodes.ERROR_FLAG);
}
if (missingClassCount > 0) {
exitCode |= ExitCodes.MISSING_CLASS_FLAG;
LOG.log(FINE, "Setting 'missing class' flag ({0})", ExitCodes.MISSING_CLASS_FLAG);
}
if (bugCount > 0) {
exitCode |= ExitCodes.BUGS_FOUND_FLAG;
LOG.log(FINE, "Setting 'bugs found' flag ({0})", ExitCodes.BUGS_FOUND_FLAG);
}
LOG.log(FINE, "Exit code set to: {0}", exitCode);
System.exit(exitCode);
}
} | java | @SuppressFBWarnings("DM_EXIT")
public static void runMain(IFindBugsEngine findBugs, TextUICommandLine commandLine) throws IOException {
boolean verbose = !commandLine.quiet();
try {
findBugs.execute();
} catch (InterruptedException e) {
assert false; // should not occur
checkExitCodeFail(commandLine, e);
throw new RuntimeException(e);
} catch (RuntimeException | IOException e) {
checkExitCodeFail(commandLine, e);
throw e;
}
int bugCount = findBugs.getBugCount();
int missingClassCount = findBugs.getMissingClassCount();
int errorCount = findBugs.getErrorCount();
if (verbose || commandLine.setExitCode()) {
LOG.log(FINE, "Warnings generated: {0}", bugCount);
LOG.log(FINE, "Missing classes: {0}", missingClassCount);
LOG.log(FINE, "Analysis errors: {0}", errorCount);
}
if (commandLine.setExitCode()) {
int exitCode = 0;
LOG.info("Calculating exit code...");
if (errorCount > 0) {
exitCode |= ExitCodes.ERROR_FLAG;
LOG.log(FINE, "Setting 'errors encountered' flag ({0})", ExitCodes.ERROR_FLAG);
}
if (missingClassCount > 0) {
exitCode |= ExitCodes.MISSING_CLASS_FLAG;
LOG.log(FINE, "Setting 'missing class' flag ({0})", ExitCodes.MISSING_CLASS_FLAG);
}
if (bugCount > 0) {
exitCode |= ExitCodes.BUGS_FOUND_FLAG;
LOG.log(FINE, "Setting 'bugs found' flag ({0})", ExitCodes.BUGS_FOUND_FLAG);
}
LOG.log(FINE, "Exit code set to: {0}", exitCode);
System.exit(exitCode);
}
} | [
"@",
"SuppressFBWarnings",
"(",
"\"DM_EXIT\"",
")",
"public",
"static",
"void",
"runMain",
"(",
"IFindBugsEngine",
"findBugs",
",",
"TextUICommandLine",
"commandLine",
")",
"throws",
"IOException",
"{",
"boolean",
"verbose",
"=",
"!",
"commandLine",
".",
"quiet",
... | Given a fully-configured IFindBugsEngine and the TextUICommandLine used
to configure it, execute the analysis.
@param findBugs
a fully-configured IFindBugsEngine
@param commandLine
the TextUICommandLine used to configure the IFindBugsEngine | [
"Given",
"a",
"fully",
"-",
"configured",
"IFindBugsEngine",
"and",
"the",
"TextUICommandLine",
"used",
"to",
"configure",
"it",
"execute",
"the",
"analysis",
"."
] | f6365c6eea6515035bded38efa4a7c8b46ccf28c | https://github.com/spotbugs/spotbugs/blob/f6365c6eea6515035bded38efa4a7c8b46ccf28c/spotbugs/src/main/java/edu/umd/cs/findbugs/FindBugs.java#L389-L433 | train |
spotbugs/spotbugs | spotbugs/src/main/java/edu/umd/cs/findbugs/FindBugs.java | FindBugs.configureBaselineFilter | public static BugReporter configureBaselineFilter(BugReporter bugReporter, String baselineFileName) throws IOException,
DocumentException {
return new ExcludingHashesBugReporter(bugReporter, baselineFileName);
} | java | public static BugReporter configureBaselineFilter(BugReporter bugReporter, String baselineFileName) throws IOException,
DocumentException {
return new ExcludingHashesBugReporter(bugReporter, baselineFileName);
} | [
"public",
"static",
"BugReporter",
"configureBaselineFilter",
"(",
"BugReporter",
"bugReporter",
",",
"String",
"baselineFileName",
")",
"throws",
"IOException",
",",
"DocumentException",
"{",
"return",
"new",
"ExcludingHashesBugReporter",
"(",
"bugReporter",
",",
"baseli... | Configure a baseline bug instance filter.
@param bugReporter
a DelegatingBugReporter
@param baselineFileName
filename of baseline Filter
@throws java.io.IOException
@throws org.dom4j.DocumentException | [
"Configure",
"a",
"baseline",
"bug",
"instance",
"filter",
"."
] | f6365c6eea6515035bded38efa4a7c8b46ccf28c | https://github.com/spotbugs/spotbugs/blob/f6365c6eea6515035bded38efa4a7c8b46ccf28c/spotbugs/src/main/java/edu/umd/cs/findbugs/FindBugs.java#L500-L503 | train |
spotbugs/spotbugs | spotbugs/src/main/java/edu/umd/cs/findbugs/ba/AbstractFrameModelingVisitor.java | AbstractFrameModelingVisitor.analyzeInstruction | public void analyzeInstruction(Instruction ins) throws DataflowAnalysisException {
if (frame.isValid()) {
try {
ins.accept(this);
} catch (InvalidBytecodeException e) {
String message = "Invalid bytecode: could not analyze instr. " + ins + " at frame " + frame;
throw new DataflowAnalysisException(message, e);
}
}
} | java | public void analyzeInstruction(Instruction ins) throws DataflowAnalysisException {
if (frame.isValid()) {
try {
ins.accept(this);
} catch (InvalidBytecodeException e) {
String message = "Invalid bytecode: could not analyze instr. " + ins + " at frame " + frame;
throw new DataflowAnalysisException(message, e);
}
}
} | [
"public",
"void",
"analyzeInstruction",
"(",
"Instruction",
"ins",
")",
"throws",
"DataflowAnalysisException",
"{",
"if",
"(",
"frame",
".",
"isValid",
"(",
")",
")",
"{",
"try",
"{",
"ins",
".",
"accept",
"(",
"this",
")",
";",
"}",
"catch",
"(",
"Inval... | Analyze the given Instruction.
@param ins
the Instruction
@throws DataflowAnalysisException
if an error occurs analyzing the instruction; in most cases,
this indicates that the bytecode for the method being
analyzed is invalid | [
"Analyze",
"the",
"given",
"Instruction",
"."
] | f6365c6eea6515035bded38efa4a7c8b46ccf28c | https://github.com/spotbugs/spotbugs/blob/f6365c6eea6515035bded38efa4a7c8b46ccf28c/spotbugs/src/main/java/edu/umd/cs/findbugs/ba/AbstractFrameModelingVisitor.java#L81-L90 | train |
spotbugs/spotbugs | spotbugs/src/main/java/edu/umd/cs/findbugs/ba/AbstractFrameModelingVisitor.java | AbstractFrameModelingVisitor.getNumWordsConsumed | public int getNumWordsConsumed(Instruction ins) {
int numWordsConsumed = ins.consumeStack(cpg);
if (numWordsConsumed == Const.UNPREDICTABLE) {
throw new InvalidBytecodeException("Unpredictable stack consumption");
}
return numWordsConsumed;
} | java | public int getNumWordsConsumed(Instruction ins) {
int numWordsConsumed = ins.consumeStack(cpg);
if (numWordsConsumed == Const.UNPREDICTABLE) {
throw new InvalidBytecodeException("Unpredictable stack consumption");
}
return numWordsConsumed;
} | [
"public",
"int",
"getNumWordsConsumed",
"(",
"Instruction",
"ins",
")",
"{",
"int",
"numWordsConsumed",
"=",
"ins",
".",
"consumeStack",
"(",
"cpg",
")",
";",
"if",
"(",
"numWordsConsumed",
"==",
"Const",
".",
"UNPREDICTABLE",
")",
"{",
"throw",
"new",
"Inva... | Get the number of words consumed by given instruction. | [
"Get",
"the",
"number",
"of",
"words",
"consumed",
"by",
"given",
"instruction",
"."
] | f6365c6eea6515035bded38efa4a7c8b46ccf28c | https://github.com/spotbugs/spotbugs/blob/f6365c6eea6515035bded38efa4a7c8b46ccf28c/spotbugs/src/main/java/edu/umd/cs/findbugs/ba/AbstractFrameModelingVisitor.java#L140-L146 | train |
spotbugs/spotbugs | spotbugs/src/main/java/edu/umd/cs/findbugs/ba/AbstractFrameModelingVisitor.java | AbstractFrameModelingVisitor.getNumWordsProduced | public int getNumWordsProduced(Instruction ins) {
int numWordsProduced = ins.produceStack(cpg);
if (numWordsProduced == Const.UNPREDICTABLE) {
throw new InvalidBytecodeException("Unpredictable stack productions");
}
return numWordsProduced;
} | java | public int getNumWordsProduced(Instruction ins) {
int numWordsProduced = ins.produceStack(cpg);
if (numWordsProduced == Const.UNPREDICTABLE) {
throw new InvalidBytecodeException("Unpredictable stack productions");
}
return numWordsProduced;
} | [
"public",
"int",
"getNumWordsProduced",
"(",
"Instruction",
"ins",
")",
"{",
"int",
"numWordsProduced",
"=",
"ins",
".",
"produceStack",
"(",
"cpg",
")",
";",
"if",
"(",
"numWordsProduced",
"==",
"Const",
".",
"UNPREDICTABLE",
")",
"{",
"throw",
"new",
"Inva... | Get the number of words produced by given instruction. | [
"Get",
"the",
"number",
"of",
"words",
"produced",
"by",
"given",
"instruction",
"."
] | f6365c6eea6515035bded38efa4a7c8b46ccf28c | https://github.com/spotbugs/spotbugs/blob/f6365c6eea6515035bded38efa4a7c8b46ccf28c/spotbugs/src/main/java/edu/umd/cs/findbugs/ba/AbstractFrameModelingVisitor.java#L151-L158 | train |
spotbugs/spotbugs | spotbugs/src/main/java/edu/umd/cs/findbugs/ba/AbstractFrameModelingVisitor.java | AbstractFrameModelingVisitor.visitConversionInstruction | @Override
public final void visitConversionInstruction(ConversionInstruction obj) {
visitConversionInstruction2(obj);
if (obj instanceof NULL2Z) {
visitNULL2Z((NULL2Z) obj);
} else if (obj instanceof NONNULL2Z) {
visitNONNULL2Z((NONNULL2Z) obj);
}
} | java | @Override
public final void visitConversionInstruction(ConversionInstruction obj) {
visitConversionInstruction2(obj);
if (obj instanceof NULL2Z) {
visitNULL2Z((NULL2Z) obj);
} else if (obj instanceof NONNULL2Z) {
visitNONNULL2Z((NONNULL2Z) obj);
}
} | [
"@",
"Override",
"public",
"final",
"void",
"visitConversionInstruction",
"(",
"ConversionInstruction",
"obj",
")",
"{",
"visitConversionInstruction2",
"(",
"obj",
")",
";",
"if",
"(",
"obj",
"instanceof",
"NULL2Z",
")",
"{",
"visitNULL2Z",
"(",
"(",
"NULL2Z",
"... | To allow for calls to visitNULL2Z and visitNONNULL2Z, this method is made final.
If you want to override it, override visitConversionInstruction2 instead. | [
"To",
"allow",
"for",
"calls",
"to",
"visitNULL2Z",
"and",
"visitNONNULL2Z",
"this",
"method",
"is",
"made",
"final",
".",
"If",
"you",
"want",
"to",
"override",
"it",
"override",
"visitConversionInstruction2",
"instead",
"."
] | f6365c6eea6515035bded38efa4a7c8b46ccf28c | https://github.com/spotbugs/spotbugs/blob/f6365c6eea6515035bded38efa4a7c8b46ccf28c/spotbugs/src/main/java/edu/umd/cs/findbugs/ba/AbstractFrameModelingVisitor.java#L202-L210 | train |
spotbugs/spotbugs | spotbugs/src/main/java/edu/umd/cs/findbugs/ba/AbstractFrameModelingVisitor.java | AbstractFrameModelingVisitor.handleStoreInstruction | public void handleStoreInstruction(StoreInstruction obj) {
try {
int numConsumed = obj.consumeStack(cpg);
if (numConsumed == Const.UNPREDICTABLE) {
throw new InvalidBytecodeException("Unpredictable stack consumption");
}
int index = obj.getIndex();
// Store values into consecutive locals corresponding
// to the order in which the values appeared on the stack.
while (numConsumed-- > 0) {
Value value = frame.popValue();
frame.setValue(index++, value);
}
} catch (DataflowAnalysisException e) {
throw new InvalidBytecodeException(e.toString());
}
} | java | public void handleStoreInstruction(StoreInstruction obj) {
try {
int numConsumed = obj.consumeStack(cpg);
if (numConsumed == Const.UNPREDICTABLE) {
throw new InvalidBytecodeException("Unpredictable stack consumption");
}
int index = obj.getIndex();
// Store values into consecutive locals corresponding
// to the order in which the values appeared on the stack.
while (numConsumed-- > 0) {
Value value = frame.popValue();
frame.setValue(index++, value);
}
} catch (DataflowAnalysisException e) {
throw new InvalidBytecodeException(e.toString());
}
} | [
"public",
"void",
"handleStoreInstruction",
"(",
"StoreInstruction",
"obj",
")",
"{",
"try",
"{",
"int",
"numConsumed",
"=",
"obj",
".",
"consumeStack",
"(",
"cpg",
")",
";",
"if",
"(",
"numConsumed",
"==",
"Const",
".",
"UNPREDICTABLE",
")",
"{",
"throw",
... | Handler for all instructions which pop values from the stack and store
them in a local variable. Note that two locals are stored into for long
and double stores. | [
"Handler",
"for",
"all",
"instructions",
"which",
"pop",
"values",
"from",
"the",
"stack",
"and",
"store",
"them",
"in",
"a",
"local",
"variable",
".",
"Note",
"that",
"two",
"locals",
"are",
"stored",
"into",
"for",
"long",
"and",
"double",
"stores",
"."
... | f6365c6eea6515035bded38efa4a7c8b46ccf28c | https://github.com/spotbugs/spotbugs/blob/f6365c6eea6515035bded38efa4a7c8b46ccf28c/spotbugs/src/main/java/edu/umd/cs/findbugs/ba/AbstractFrameModelingVisitor.java#L311-L329 | train |
spotbugs/spotbugs | spotbugs/src/main/java/edu/umd/cs/findbugs/ba/AbstractFrameModelingVisitor.java | AbstractFrameModelingVisitor.modelInstruction | public void modelInstruction(Instruction ins, int numWordsConsumed, int numWordsProduced, Value pushValue) {
if (frame.getStackDepth() < numWordsConsumed) {
try {
throw new IllegalArgumentException(" asked to pop " + numWordsConsumed + " stack elements but only "
+ frame.getStackDepth() + " elements remain in " + frame + " while processing " + ins);
} catch (Exception e) {
throw new IllegalArgumentException(" asked to pop " + numWordsConsumed + " stack elements but only "
+ frame.getStackDepth() + " elements remain while processing " + ins);
}
}
try {
while (numWordsConsumed-- > 0) {
frame.popValue();
}
} catch (DataflowAnalysisException e) {
throw new InvalidBytecodeException("Not enough values on the stack", e);
}
while (numWordsProduced-- > 0) {
frame.pushValue(pushValue);
}
} | java | public void modelInstruction(Instruction ins, int numWordsConsumed, int numWordsProduced, Value pushValue) {
if (frame.getStackDepth() < numWordsConsumed) {
try {
throw new IllegalArgumentException(" asked to pop " + numWordsConsumed + " stack elements but only "
+ frame.getStackDepth() + " elements remain in " + frame + " while processing " + ins);
} catch (Exception e) {
throw new IllegalArgumentException(" asked to pop " + numWordsConsumed + " stack elements but only "
+ frame.getStackDepth() + " elements remain while processing " + ins);
}
}
try {
while (numWordsConsumed-- > 0) {
frame.popValue();
}
} catch (DataflowAnalysisException e) {
throw new InvalidBytecodeException("Not enough values on the stack", e);
}
while (numWordsProduced-- > 0) {
frame.pushValue(pushValue);
}
} | [
"public",
"void",
"modelInstruction",
"(",
"Instruction",
"ins",
",",
"int",
"numWordsConsumed",
",",
"int",
"numWordsProduced",
",",
"Value",
"pushValue",
")",
"{",
"if",
"(",
"frame",
".",
"getStackDepth",
"(",
")",
"<",
"numWordsConsumed",
")",
"{",
"try",
... | Primitive to model the stack effect of a single instruction, explicitly
specifying the value to be pushed on the stack.
@param ins
the Instruction to model
@param numWordsConsumed
number of stack words consumed
@param numWordsProduced
number of stack words produced
@param pushValue
value to push on the stack | [
"Primitive",
"to",
"model",
"the",
"stack",
"effect",
"of",
"a",
"single",
"instruction",
"explicitly",
"specifying",
"the",
"value",
"to",
"be",
"pushed",
"on",
"the",
"stack",
"."
] | f6365c6eea6515035bded38efa4a7c8b46ccf28c | https://github.com/spotbugs/spotbugs/blob/f6365c6eea6515035bded38efa4a7c8b46ccf28c/spotbugs/src/main/java/edu/umd/cs/findbugs/ba/AbstractFrameModelingVisitor.java#L390-L411 | train |
spotbugs/spotbugs | spotbugs/src/main/java/edu/umd/cs/findbugs/classfile/impl/ClassPathBuilder.java | ClassPathBuilder.locateCodebasesRequiredForAnalysis | private void locateCodebasesRequiredForAnalysis(IClassPath classPath, IClassPathBuilderProgress progress)
throws InterruptedException, IOException, ResourceNotFoundException {
boolean foundJavaLangObject = false;
boolean foundFindBugsAnnotations = false;
boolean foundJSR305Annotations = false;
for (DiscoveredCodeBase discoveredCodeBase : discoveredCodeBaseList) {
if (!foundJavaLangObject) {
foundJavaLangObject = probeCodeBaseForResource(discoveredCodeBase, "java/lang/Object.class");
}
if (!foundFindBugsAnnotations) {
foundFindBugsAnnotations = probeCodeBaseForResource(discoveredCodeBase,
"edu/umd/cs/findbugs/annotations/Nonnull.class");
}
if (!foundJSR305Annotations) {
foundJSR305Annotations = probeCodeBaseForResource(discoveredCodeBase, "javax/annotation/meta/TypeQualifier.class");
if (DEBUG) {
System.out.println("foundJSR305Annotations: " + foundJSR305Annotations);
}
}
}
if (!foundJavaLangObject) {
processWorkList(classPath, buildSystemCodebaseList(), progress);
}
// If we're running findbugs-full.jar, IT contains the contents
// of jsr305.jar and annotations.jar. So, add it to the classpath.
if (runningFindBugsFullJar()) {
processWorkList(classPath, buildFindBugsFullJarCodebaseList(), progress);
return;
}
// Not running findbugs-full.jar: try to find jsr305.jar and
// annotations.jar.
if (!foundFindBugsAnnotations) {
processWorkList(classPath, buildFindBugsAnnotationCodebaseList(), progress);
}
if (!foundJSR305Annotations) {
processWorkList(classPath, buildJSR305AnnotationsCodebaseList(), progress);
}
} | java | private void locateCodebasesRequiredForAnalysis(IClassPath classPath, IClassPathBuilderProgress progress)
throws InterruptedException, IOException, ResourceNotFoundException {
boolean foundJavaLangObject = false;
boolean foundFindBugsAnnotations = false;
boolean foundJSR305Annotations = false;
for (DiscoveredCodeBase discoveredCodeBase : discoveredCodeBaseList) {
if (!foundJavaLangObject) {
foundJavaLangObject = probeCodeBaseForResource(discoveredCodeBase, "java/lang/Object.class");
}
if (!foundFindBugsAnnotations) {
foundFindBugsAnnotations = probeCodeBaseForResource(discoveredCodeBase,
"edu/umd/cs/findbugs/annotations/Nonnull.class");
}
if (!foundJSR305Annotations) {
foundJSR305Annotations = probeCodeBaseForResource(discoveredCodeBase, "javax/annotation/meta/TypeQualifier.class");
if (DEBUG) {
System.out.println("foundJSR305Annotations: " + foundJSR305Annotations);
}
}
}
if (!foundJavaLangObject) {
processWorkList(classPath, buildSystemCodebaseList(), progress);
}
// If we're running findbugs-full.jar, IT contains the contents
// of jsr305.jar and annotations.jar. So, add it to the classpath.
if (runningFindBugsFullJar()) {
processWorkList(classPath, buildFindBugsFullJarCodebaseList(), progress);
return;
}
// Not running findbugs-full.jar: try to find jsr305.jar and
// annotations.jar.
if (!foundFindBugsAnnotations) {
processWorkList(classPath, buildFindBugsAnnotationCodebaseList(), progress);
}
if (!foundJSR305Annotations) {
processWorkList(classPath, buildJSR305AnnotationsCodebaseList(), progress);
}
} | [
"private",
"void",
"locateCodebasesRequiredForAnalysis",
"(",
"IClassPath",
"classPath",
",",
"IClassPathBuilderProgress",
"progress",
")",
"throws",
"InterruptedException",
",",
"IOException",
",",
"ResourceNotFoundException",
"{",
"boolean",
"foundJavaLangObject",
"=",
"fal... | Make an effort to find the codebases containing any files required for
analysis. | [
"Make",
"an",
"effort",
"to",
"find",
"the",
"codebases",
"containing",
"any",
"files",
"required",
"for",
"analysis",
"."
] | f6365c6eea6515035bded38efa4a7c8b46ccf28c | https://github.com/spotbugs/spotbugs/blob/f6365c6eea6515035bded38efa4a7c8b46ccf28c/spotbugs/src/main/java/edu/umd/cs/findbugs/classfile/impl/ClassPathBuilder.java#L292-L334 | train |
spotbugs/spotbugs | spotbugs/src/main/java/edu/umd/cs/findbugs/classfile/impl/ClassPathBuilder.java | ClassPathBuilder.probeCodeBaseForResource | private boolean probeCodeBaseForResource(DiscoveredCodeBase discoveredCodeBase, String resourceName) {
ICodeBaseEntry resource = discoveredCodeBase.getCodeBase().lookupResource(resourceName);
return resource != null;
} | java | private boolean probeCodeBaseForResource(DiscoveredCodeBase discoveredCodeBase, String resourceName) {
ICodeBaseEntry resource = discoveredCodeBase.getCodeBase().lookupResource(resourceName);
return resource != null;
} | [
"private",
"boolean",
"probeCodeBaseForResource",
"(",
"DiscoveredCodeBase",
"discoveredCodeBase",
",",
"String",
"resourceName",
")",
"{",
"ICodeBaseEntry",
"resource",
"=",
"discoveredCodeBase",
".",
"getCodeBase",
"(",
")",
".",
"lookupResource",
"(",
"resourceName",
... | Probe a codebase to see if a given source exists in that code base.
@param resourceName
name of a resource
@return true if the resource exists in the codebase, false if not | [
"Probe",
"a",
"codebase",
"to",
"see",
"if",
"a",
"given",
"source",
"exists",
"in",
"that",
"code",
"base",
"."
] | f6365c6eea6515035bded38efa4a7c8b46ccf28c | https://github.com/spotbugs/spotbugs/blob/f6365c6eea6515035bded38efa4a7c8b46ccf28c/spotbugs/src/main/java/edu/umd/cs/findbugs/classfile/impl/ClassPathBuilder.java#L366-L369 | train |
spotbugs/spotbugs | spotbugs/src/main/java/edu/umd/cs/findbugs/classfile/impl/ClassPathBuilder.java | ClassPathBuilder.addWorkListItemsForClasspath | private void addWorkListItemsForClasspath(LinkedList<WorkListItem> workList, String path) {
if (path == null) {
return;
}
StringTokenizer st = new StringTokenizer(path, File.pathSeparator);
while (st.hasMoreTokens()) {
String entry = st.nextToken();
if (DEBUG) {
System.out.println("System classpath entry: " + entry);
}
addToWorkList(workList, new WorkListItem(classFactory.createFilesystemCodeBaseLocator(entry), false,
ICodeBase.Discovered.IN_SYSTEM_CLASSPATH));
}
} | java | private void addWorkListItemsForClasspath(LinkedList<WorkListItem> workList, String path) {
if (path == null) {
return;
}
StringTokenizer st = new StringTokenizer(path, File.pathSeparator);
while (st.hasMoreTokens()) {
String entry = st.nextToken();
if (DEBUG) {
System.out.println("System classpath entry: " + entry);
}
addToWorkList(workList, new WorkListItem(classFactory.createFilesystemCodeBaseLocator(entry), false,
ICodeBase.Discovered.IN_SYSTEM_CLASSPATH));
}
} | [
"private",
"void",
"addWorkListItemsForClasspath",
"(",
"LinkedList",
"<",
"WorkListItem",
">",
"workList",
",",
"String",
"path",
")",
"{",
"if",
"(",
"path",
"==",
"null",
")",
"{",
"return",
";",
"}",
"StringTokenizer",
"st",
"=",
"new",
"StringTokenizer",
... | Add worklist items from given system classpath.
@param workList
the worklist
@param path
a system classpath | [
"Add",
"worklist",
"items",
"from",
"given",
"system",
"classpath",
"."
] | f6365c6eea6515035bded38efa4a7c8b46ccf28c | https://github.com/spotbugs/spotbugs/blob/f6365c6eea6515035bded38efa4a7c8b46ccf28c/spotbugs/src/main/java/edu/umd/cs/findbugs/classfile/impl/ClassPathBuilder.java#L519-L533 | train |
spotbugs/spotbugs | spotbugs/src/main/java/edu/umd/cs/findbugs/classfile/impl/ClassPathBuilder.java | ClassPathBuilder.addWorkListItemsForExtDir | private void addWorkListItemsForExtDir(LinkedList<WorkListItem> workList, String extDir) {
File dir = new File(extDir);
File[] fileList = dir.listFiles((FileFilter) pathname -> {
String path = pathname.getPath();
boolean isArchive = Archive.isArchiveFileName(path);
return isArchive;
});
if (fileList == null) {
return;
}
for (File archive : fileList) {
addToWorkList(workList, new WorkListItem(classFactory.createFilesystemCodeBaseLocator(archive.getPath()), false,
ICodeBase.Discovered.IN_SYSTEM_CLASSPATH));
}
} | java | private void addWorkListItemsForExtDir(LinkedList<WorkListItem> workList, String extDir) {
File dir = new File(extDir);
File[] fileList = dir.listFiles((FileFilter) pathname -> {
String path = pathname.getPath();
boolean isArchive = Archive.isArchiveFileName(path);
return isArchive;
});
if (fileList == null) {
return;
}
for (File archive : fileList) {
addToWorkList(workList, new WorkListItem(classFactory.createFilesystemCodeBaseLocator(archive.getPath()), false,
ICodeBase.Discovered.IN_SYSTEM_CLASSPATH));
}
} | [
"private",
"void",
"addWorkListItemsForExtDir",
"(",
"LinkedList",
"<",
"WorkListItem",
">",
"workList",
",",
"String",
"extDir",
")",
"{",
"File",
"dir",
"=",
"new",
"File",
"(",
"extDir",
")",
";",
"File",
"[",
"]",
"fileList",
"=",
"dir",
".",
"listFile... | Add worklist items from given extensions directory.
@param workList
the worklist
@param extDir
an extensions directory | [
"Add",
"worklist",
"items",
"from",
"given",
"extensions",
"directory",
"."
] | f6365c6eea6515035bded38efa4a7c8b46ccf28c | https://github.com/spotbugs/spotbugs/blob/f6365c6eea6515035bded38efa4a7c8b46ccf28c/spotbugs/src/main/java/edu/umd/cs/findbugs/classfile/impl/ClassPathBuilder.java#L543-L558 | train |
spotbugs/spotbugs | spotbugs/src/main/java/edu/umd/cs/findbugs/classfile/impl/ClassPathBuilder.java | ClassPathBuilder.parseClassName | private void parseClassName(ICodeBaseEntry entry) {
DataInputStream in = null;
try {
InputStream resourceIn = entry.openResource();
if (resourceIn == null) {
throw new NullPointerException("Got null resource");
}
in = new DataInputStream(resourceIn);
ClassParserInterface parser = new ClassParser(in, null, entry);
ClassNameAndSuperclassInfo.Builder builder = new ClassNameAndSuperclassInfo.Builder();
parser.parse(builder);
String trueResourceName = builder.build().getClassDescriptor().toResourceName();
if (!trueResourceName.equals(entry.getResourceName())) {
entry.overrideResourceName(trueResourceName);
}
} catch (IOException e) {
errorLogger.logError("Invalid class resource " + entry.getResourceName() + " in " + entry, e);
} catch (InvalidClassFileFormatException e) {
errorLogger.logError("Invalid class resource " + entry.getResourceName() + " in " + entry, e);
} finally {
IO.close(in);
}
} | java | private void parseClassName(ICodeBaseEntry entry) {
DataInputStream in = null;
try {
InputStream resourceIn = entry.openResource();
if (resourceIn == null) {
throw new NullPointerException("Got null resource");
}
in = new DataInputStream(resourceIn);
ClassParserInterface parser = new ClassParser(in, null, entry);
ClassNameAndSuperclassInfo.Builder builder = new ClassNameAndSuperclassInfo.Builder();
parser.parse(builder);
String trueResourceName = builder.build().getClassDescriptor().toResourceName();
if (!trueResourceName.equals(entry.getResourceName())) {
entry.overrideResourceName(trueResourceName);
}
} catch (IOException e) {
errorLogger.logError("Invalid class resource " + entry.getResourceName() + " in " + entry, e);
} catch (InvalidClassFileFormatException e) {
errorLogger.logError("Invalid class resource " + entry.getResourceName() + " in " + entry, e);
} finally {
IO.close(in);
}
} | [
"private",
"void",
"parseClassName",
"(",
"ICodeBaseEntry",
"entry",
")",
"{",
"DataInputStream",
"in",
"=",
"null",
";",
"try",
"{",
"InputStream",
"resourceIn",
"=",
"entry",
".",
"openResource",
"(",
")",
";",
"if",
"(",
"resourceIn",
"==",
"null",
")",
... | Attempt to parse data of given resource in order to divine the real name
of the class contained in the resource.
@param entry
the resource | [
"Attempt",
"to",
"parse",
"data",
"of",
"given",
"resource",
"in",
"order",
"to",
"divine",
"the",
"real",
"name",
"of",
"the",
"class",
"contained",
"in",
"the",
"resource",
"."
] | f6365c6eea6515035bded38efa4a7c8b46ccf28c | https://github.com/spotbugs/spotbugs/blob/f6365c6eea6515035bded38efa4a7c8b46ccf28c/spotbugs/src/main/java/edu/umd/cs/findbugs/classfile/impl/ClassPathBuilder.java#L723-L746 | train |
spotbugs/spotbugs | spotbugs/src/main/java/edu/umd/cs/findbugs/classfile/impl/ClassPathBuilder.java | ClassPathBuilder.scanJarManifestForClassPathEntries | private void scanJarManifestForClassPathEntries(LinkedList<WorkListItem> workList, ICodeBase codeBase) throws IOException {
// See if this codebase has a jar manifest
ICodeBaseEntry manifestEntry = codeBase.lookupResource("META-INF/MANIFEST.MF");
if (manifestEntry == null) {
// Do nothing - no Jar manifest found
return;
}
// Try to read the manifest
InputStream in = null;
try {
in = manifestEntry.openResource();
Manifest manifest = new Manifest(in);
Attributes mainAttrs = manifest.getMainAttributes();
String classPath = mainAttrs.getValue("Class-Path");
if (classPath != null) {
String[] pathList = classPath.split("\\s+");
for (String path : pathList) {
// Create a codebase locator for the classpath entry
// relative to the codebase in which we discovered the Jar
// manifest
ICodeBaseLocator relativeCodeBaseLocator = codeBase.getCodeBaseLocator().createRelativeCodeBaseLocator(path);
// Codebases found in Class-Path entries are always
// added to the aux classpath, not the application.
addToWorkList(workList, new WorkListItem(relativeCodeBaseLocator, false, ICodeBase.Discovered.IN_JAR_MANIFEST));
}
}
} finally {
if (in != null) {
IO.close(in);
}
}
} | java | private void scanJarManifestForClassPathEntries(LinkedList<WorkListItem> workList, ICodeBase codeBase) throws IOException {
// See if this codebase has a jar manifest
ICodeBaseEntry manifestEntry = codeBase.lookupResource("META-INF/MANIFEST.MF");
if (manifestEntry == null) {
// Do nothing - no Jar manifest found
return;
}
// Try to read the manifest
InputStream in = null;
try {
in = manifestEntry.openResource();
Manifest manifest = new Manifest(in);
Attributes mainAttrs = manifest.getMainAttributes();
String classPath = mainAttrs.getValue("Class-Path");
if (classPath != null) {
String[] pathList = classPath.split("\\s+");
for (String path : pathList) {
// Create a codebase locator for the classpath entry
// relative to the codebase in which we discovered the Jar
// manifest
ICodeBaseLocator relativeCodeBaseLocator = codeBase.getCodeBaseLocator().createRelativeCodeBaseLocator(path);
// Codebases found in Class-Path entries are always
// added to the aux classpath, not the application.
addToWorkList(workList, new WorkListItem(relativeCodeBaseLocator, false, ICodeBase.Discovered.IN_JAR_MANIFEST));
}
}
} finally {
if (in != null) {
IO.close(in);
}
}
} | [
"private",
"void",
"scanJarManifestForClassPathEntries",
"(",
"LinkedList",
"<",
"WorkListItem",
">",
"workList",
",",
"ICodeBase",
"codeBase",
")",
"throws",
"IOException",
"{",
"// See if this codebase has a jar manifest",
"ICodeBaseEntry",
"manifestEntry",
"=",
"codeBase",... | Check a codebase for a Jar manifest to examine for Class-Path entries.
@param workList
the worklist
@param codeBase
the codebase for examine for a Jar manifest
@throws IOException | [
"Check",
"a",
"codebase",
"for",
"a",
"Jar",
"manifest",
"to",
"examine",
"for",
"Class",
"-",
"Path",
"entries",
"."
] | f6365c6eea6515035bded38efa4a7c8b46ccf28c | https://github.com/spotbugs/spotbugs/blob/f6365c6eea6515035bded38efa4a7c8b46ccf28c/spotbugs/src/main/java/edu/umd/cs/findbugs/classfile/impl/ClassPathBuilder.java#L757-L792 | train |
spotbugs/spotbugs | spotbugs/src/main/java/edu/umd/cs/findbugs/ResourceCollection.java | ResourceCollection.addCreatedResource | public void addCreatedResource(Location location, Resource resource) {
resourceList.add(resource);
locationToResourceMap.put(location, resource);
} | java | public void addCreatedResource(Location location, Resource resource) {
resourceList.add(resource);
locationToResourceMap.put(location, resource);
} | [
"public",
"void",
"addCreatedResource",
"(",
"Location",
"location",
",",
"Resource",
"resource",
")",
"{",
"resourceList",
".",
"add",
"(",
"resource",
")",
";",
"locationToResourceMap",
".",
"put",
"(",
"location",
",",
"resource",
")",
";",
"}"
] | Add a resource created within the analyzed method.
@param location
the location
@param resource
the resource created at that location | [
"Add",
"a",
"resource",
"created",
"within",
"the",
"analyzed",
"method",
"."
] | f6365c6eea6515035bded38efa4a7c8b46ccf28c | https://github.com/spotbugs/spotbugs/blob/f6365c6eea6515035bded38efa4a7c8b46ccf28c/spotbugs/src/main/java/edu/umd/cs/findbugs/ResourceCollection.java#L77-L80 | train |
spotbugs/spotbugs | eclipsePlugin/src/de/tobject/findbugs/properties/DetectorConfigurationTab.java | DetectorConfigurationTab.syncUserPreferencesWithTable | protected void syncUserPreferencesWithTable() {
TableItem[] itemList = availableFactoriesTableViewer.getTable().getItems();
UserPreferences currentProps = getCurrentProps();
for (int i = 0; i < itemList.length; i++) {
DetectorFactory factory = (DetectorFactory) itemList[i].getData();
// set enabled if defined in configuration
currentProps.enableDetector(factory, itemList[i].getChecked());
}
} | java | protected void syncUserPreferencesWithTable() {
TableItem[] itemList = availableFactoriesTableViewer.getTable().getItems();
UserPreferences currentProps = getCurrentProps();
for (int i = 0; i < itemList.length; i++) {
DetectorFactory factory = (DetectorFactory) itemList[i].getData();
// set enabled if defined in configuration
currentProps.enableDetector(factory, itemList[i].getChecked());
}
} | [
"protected",
"void",
"syncUserPreferencesWithTable",
"(",
")",
"{",
"TableItem",
"[",
"]",
"itemList",
"=",
"availableFactoriesTableViewer",
".",
"getTable",
"(",
")",
".",
"getItems",
"(",
")",
";",
"UserPreferences",
"currentProps",
"=",
"getCurrentProps",
"(",
... | Disables all unchecked detector factories and enables checked factory
detectors, leaving those not in the table unmodified. | [
"Disables",
"all",
"unchecked",
"detector",
"factories",
"and",
"enables",
"checked",
"factory",
"detectors",
"leaving",
"those",
"not",
"in",
"the",
"table",
"unmodified",
"."
] | f6365c6eea6515035bded38efa4a7c8b46ccf28c | https://github.com/spotbugs/spotbugs/blob/f6365c6eea6515035bded38efa4a7c8b46ccf28c/eclipsePlugin/src/de/tobject/findbugs/properties/DetectorConfigurationTab.java#L513-L521 | train |
spotbugs/spotbugs | eclipsePlugin/src/de/tobject/findbugs/properties/DetectorConfigurationTab.java | DetectorConfigurationTab.createDetectorsTableViewer | private Table createDetectorsTableViewer(Composite parent, IProject project) {
final BugPatternTableSorter sorter = new BugPatternTableSorter(this);
int tableStyle = SWT.BORDER | SWT.H_SCROLL | SWT.V_SCROLL | SWT.SINGLE | SWT.FULL_SELECTION | SWT.CHECK;
availableFactoriesTableViewer = CheckboxTableViewer.newCheckList(parent, tableStyle);
availableFactoriesTableViewer.addCheckStateListener(new ICheckStateListener() {
@Override
public void checkStateChanged(CheckStateChangedEvent event) {
syncUserPreferencesWithTable();
}
});
int currentColumnIdx = 0;
Table factoriesTable = availableFactoriesTableViewer.getTable();
TableColumn factoryNameColumn = createColumn(currentColumnIdx, factoriesTable, getMessage("property.detectorName"), 230,
COLUMN.DETECTOR_NAME);
addColumnSelectionListener(sorter, factoryNameColumn, COLUMN.DETECTOR_NAME);
currentColumnIdx++;
TableColumn bugsAbbrevColumn = createColumn(currentColumnIdx, factoriesTable, getMessage("property.bugCodes"), 75,
COLUMN.BUG_CODES);
addColumnSelectionListener(sorter, bugsAbbrevColumn, COLUMN.BUG_CODES);
currentColumnIdx++;
TableColumn speedColumn = createColumn(currentColumnIdx, factoriesTable, getMessage("property.speed"), 70,
COLUMN.DETECTOR_SPEED);
addColumnSelectionListener(sorter, speedColumn, COLUMN.DETECTOR_SPEED);
currentColumnIdx++;
TableColumn pluginColumn = createColumn(currentColumnIdx, factoriesTable, getMessage("property.provider"), 100,
COLUMN.PLUGIN);
addColumnSelectionListener(sorter, pluginColumn, COLUMN.PLUGIN);
currentColumnIdx++;
TableColumn categoryColumn = createColumn(currentColumnIdx, factoriesTable, getMessage("property.category"), 75,
COLUMN.BUG_CATEGORIES);
addColumnSelectionListener(sorter, categoryColumn, COLUMN.BUG_CATEGORIES);
factoriesTable.setLinesVisible(true);
factoriesTable.setHeaderVisible(true);
// initial sort indicator
factoriesTable.setSortDirection(sorter.revertOrder ? SWT.UP : SWT.DOWN);
factoriesTable.setSortColumn(factoryNameColumn);
sorter.setSortColumnIndex(COLUMN.DETECTOR_NAME);
availableFactoriesTableViewer.setContentProvider(new DetectorFactoriesContentProvider());
availableFactoriesTableViewer.setLabelProvider(new DetectorFactoryLabelProvider(this));
availableFactoriesTableViewer.setSorter(sorter);
populateAvailableRulesTable(project);
factoriesTable.setEnabled(true);
return factoriesTable;
} | java | private Table createDetectorsTableViewer(Composite parent, IProject project) {
final BugPatternTableSorter sorter = new BugPatternTableSorter(this);
int tableStyle = SWT.BORDER | SWT.H_SCROLL | SWT.V_SCROLL | SWT.SINGLE | SWT.FULL_SELECTION | SWT.CHECK;
availableFactoriesTableViewer = CheckboxTableViewer.newCheckList(parent, tableStyle);
availableFactoriesTableViewer.addCheckStateListener(new ICheckStateListener() {
@Override
public void checkStateChanged(CheckStateChangedEvent event) {
syncUserPreferencesWithTable();
}
});
int currentColumnIdx = 0;
Table factoriesTable = availableFactoriesTableViewer.getTable();
TableColumn factoryNameColumn = createColumn(currentColumnIdx, factoriesTable, getMessage("property.detectorName"), 230,
COLUMN.DETECTOR_NAME);
addColumnSelectionListener(sorter, factoryNameColumn, COLUMN.DETECTOR_NAME);
currentColumnIdx++;
TableColumn bugsAbbrevColumn = createColumn(currentColumnIdx, factoriesTable, getMessage("property.bugCodes"), 75,
COLUMN.BUG_CODES);
addColumnSelectionListener(sorter, bugsAbbrevColumn, COLUMN.BUG_CODES);
currentColumnIdx++;
TableColumn speedColumn = createColumn(currentColumnIdx, factoriesTable, getMessage("property.speed"), 70,
COLUMN.DETECTOR_SPEED);
addColumnSelectionListener(sorter, speedColumn, COLUMN.DETECTOR_SPEED);
currentColumnIdx++;
TableColumn pluginColumn = createColumn(currentColumnIdx, factoriesTable, getMessage("property.provider"), 100,
COLUMN.PLUGIN);
addColumnSelectionListener(sorter, pluginColumn, COLUMN.PLUGIN);
currentColumnIdx++;
TableColumn categoryColumn = createColumn(currentColumnIdx, factoriesTable, getMessage("property.category"), 75,
COLUMN.BUG_CATEGORIES);
addColumnSelectionListener(sorter, categoryColumn, COLUMN.BUG_CATEGORIES);
factoriesTable.setLinesVisible(true);
factoriesTable.setHeaderVisible(true);
// initial sort indicator
factoriesTable.setSortDirection(sorter.revertOrder ? SWT.UP : SWT.DOWN);
factoriesTable.setSortColumn(factoryNameColumn);
sorter.setSortColumnIndex(COLUMN.DETECTOR_NAME);
availableFactoriesTableViewer.setContentProvider(new DetectorFactoriesContentProvider());
availableFactoriesTableViewer.setLabelProvider(new DetectorFactoryLabelProvider(this));
availableFactoriesTableViewer.setSorter(sorter);
populateAvailableRulesTable(project);
factoriesTable.setEnabled(true);
return factoriesTable;
} | [
"private",
"Table",
"createDetectorsTableViewer",
"(",
"Composite",
"parent",
",",
"IProject",
"project",
")",
"{",
"final",
"BugPatternTableSorter",
"sorter",
"=",
"new",
"BugPatternTableSorter",
"(",
"this",
")",
";",
"int",
"tableStyle",
"=",
"SWT",
".",
"BORDE... | Build rule table viewer | [
"Build",
"rule",
"table",
"viewer"
] | f6365c6eea6515035bded38efa4a7c8b46ccf28c | https://github.com/spotbugs/spotbugs/blob/f6365c6eea6515035bded38efa4a7c8b46ccf28c/eclipsePlugin/src/de/tobject/findbugs/properties/DetectorConfigurationTab.java#L550-L606 | train |
spotbugs/spotbugs | eclipsePlugin/src/de/tobject/findbugs/properties/DetectorConfigurationTab.java | DetectorConfigurationTab.populateAvailableRulesTable | private void populateAvailableRulesTable(IProject project) {
List<DetectorFactory> allAvailableList = new ArrayList<>();
factoriesToBugAbbrev = new HashMap<>();
Iterator<DetectorFactory> iterator = DetectorFactoryCollection.instance().factoryIterator();
while (iterator.hasNext()) {
DetectorFactory factory = iterator.next();
// Only configure non-hidden factories
if (factory.isHidden() && !isHiddenVisible()) {
continue;
}
allAvailableList.add(factory);
addBugsAbbreviation(factory);
}
availableFactoriesTableViewer.setInput(allAvailableList);
TableItem[] itemList = availableFactoriesTableViewer.getTable().getItems();
UserPreferences userPreferences = getCurrentProps();
for (int i = 0; i < itemList.length; i++) {
DetectorFactory rule = (DetectorFactory) itemList[i].getData();
// set enabled if defined in configuration
if (userPreferences.isDetectorEnabled(rule)) {
itemList[i].setChecked(true);
}
}
} | java | private void populateAvailableRulesTable(IProject project) {
List<DetectorFactory> allAvailableList = new ArrayList<>();
factoriesToBugAbbrev = new HashMap<>();
Iterator<DetectorFactory> iterator = DetectorFactoryCollection.instance().factoryIterator();
while (iterator.hasNext()) {
DetectorFactory factory = iterator.next();
// Only configure non-hidden factories
if (factory.isHidden() && !isHiddenVisible()) {
continue;
}
allAvailableList.add(factory);
addBugsAbbreviation(factory);
}
availableFactoriesTableViewer.setInput(allAvailableList);
TableItem[] itemList = availableFactoriesTableViewer.getTable().getItems();
UserPreferences userPreferences = getCurrentProps();
for (int i = 0; i < itemList.length; i++) {
DetectorFactory rule = (DetectorFactory) itemList[i].getData();
// set enabled if defined in configuration
if (userPreferences.isDetectorEnabled(rule)) {
itemList[i].setChecked(true);
}
}
} | [
"private",
"void",
"populateAvailableRulesTable",
"(",
"IProject",
"project",
")",
"{",
"List",
"<",
"DetectorFactory",
">",
"allAvailableList",
"=",
"new",
"ArrayList",
"<>",
"(",
")",
";",
"factoriesToBugAbbrev",
"=",
"new",
"HashMap",
"<>",
"(",
")",
";",
"... | Populate the rule table | [
"Populate",
"the",
"rule",
"table"
] | f6365c6eea6515035bded38efa4a7c8b46ccf28c | https://github.com/spotbugs/spotbugs/blob/f6365c6eea6515035bded38efa4a7c8b46ccf28c/eclipsePlugin/src/de/tobject/findbugs/properties/DetectorConfigurationTab.java#L643-L669 | train |
spotbugs/spotbugs | spotbugs/src/main/java/edu/umd/cs/findbugs/ba/npe/ReturnPathType.java | ReturnPathType.mergeWith | public void mergeWith(ReturnPathType fact) {
if (fact.isTop()) {
// other fact is top: no change to this one
return;
} else if (this.isTop()) {
// this fact is top: copy other fact
this.copyFrom(fact);
} else {
// neither fact is top: as long as one of the two
// facts represents a (possible) normal return, then the result
// is a possible normal return
if (fact.type == CAN_RETURN_NORMALLY) {
this.type = CAN_RETURN_NORMALLY;
}
}
} | java | public void mergeWith(ReturnPathType fact) {
if (fact.isTop()) {
// other fact is top: no change to this one
return;
} else if (this.isTop()) {
// this fact is top: copy other fact
this.copyFrom(fact);
} else {
// neither fact is top: as long as one of the two
// facts represents a (possible) normal return, then the result
// is a possible normal return
if (fact.type == CAN_RETURN_NORMALLY) {
this.type = CAN_RETURN_NORMALLY;
}
}
} | [
"public",
"void",
"mergeWith",
"(",
"ReturnPathType",
"fact",
")",
"{",
"if",
"(",
"fact",
".",
"isTop",
"(",
")",
")",
"{",
"// other fact is top: no change to this one",
"return",
";",
"}",
"else",
"if",
"(",
"this",
".",
"isTop",
"(",
")",
")",
"{",
"... | Merge this fact with given fact.
@param fact
another dataflow fact | [
"Merge",
"this",
"fact",
"with",
"given",
"fact",
"."
] | f6365c6eea6515035bded38efa4a7c8b46ccf28c | https://github.com/spotbugs/spotbugs/blob/f6365c6eea6515035bded38efa4a7c8b46ccf28c/spotbugs/src/main/java/edu/umd/cs/findbugs/ba/npe/ReturnPathType.java#L103-L118 | train |
spotbugs/spotbugs | spotbugs/src/gui/main/edu/umd/cs/findbugs/gui2/OSXAdapter.java | OSXAdapter.handleAbout | @Override
public void handleAbout(ApplicationEvent ae) {
if (mainApp != null) {
ae.setHandled(true);
// We need to invoke modal About Dialog asynchronously
// otherwise the Application queue is locked for the duration
// of the about Dialog, which results in a deadlock if a URL is
// selected, and we get a ReOpenApplication event when user
// switches back to Findbugs.
javax.swing.SwingUtilities.invokeLater(() -> mainApp.about());
} else {
throw new IllegalStateException("handleAbout: " + "MyApp instance detached from listener");
}
} | java | @Override
public void handleAbout(ApplicationEvent ae) {
if (mainApp != null) {
ae.setHandled(true);
// We need to invoke modal About Dialog asynchronously
// otherwise the Application queue is locked for the duration
// of the about Dialog, which results in a deadlock if a URL is
// selected, and we get a ReOpenApplication event when user
// switches back to Findbugs.
javax.swing.SwingUtilities.invokeLater(() -> mainApp.about());
} else {
throw new IllegalStateException("handleAbout: " + "MyApp instance detached from listener");
}
} | [
"@",
"Override",
"public",
"void",
"handleAbout",
"(",
"ApplicationEvent",
"ae",
")",
"{",
"if",
"(",
"mainApp",
"!=",
"null",
")",
"{",
"ae",
".",
"setHandled",
"(",
"true",
")",
";",
"// We need to invoke modal About Dialog asynchronously",
"// otherwise the Appli... | over from another platform. | [
"over",
"from",
"another",
"platform",
"."
] | f6365c6eea6515035bded38efa4a7c8b46ccf28c | https://github.com/spotbugs/spotbugs/blob/f6365c6eea6515035bded38efa4a7c8b46ccf28c/spotbugs/src/gui/main/edu/umd/cs/findbugs/gui2/OSXAdapter.java#L50-L63 | train |
Polidea/RxAndroidBle | rxandroidble/src/main/java/com/polidea/rxandroidble2/internal/connection/LoggingIllegalOperationHandler.java | LoggingIllegalOperationHandler.handleMismatchData | @Override
public BleIllegalOperationException handleMismatchData(BluetoothGattCharacteristic characteristic, int neededProperties) {
RxBleLog.w(messageCreator.createMismatchMessage(characteristic, neededProperties));
return null;
} | java | @Override
public BleIllegalOperationException handleMismatchData(BluetoothGattCharacteristic characteristic, int neededProperties) {
RxBleLog.w(messageCreator.createMismatchMessage(characteristic, neededProperties));
return null;
} | [
"@",
"Override",
"public",
"BleIllegalOperationException",
"handleMismatchData",
"(",
"BluetoothGattCharacteristic",
"characteristic",
",",
"int",
"neededProperties",
")",
"{",
"RxBleLog",
".",
"w",
"(",
"messageCreator",
".",
"createMismatchMessage",
"(",
"characteristic",... | This method logs a warning.
@param characteristic the characteristic upon which the operation was requested
@param neededProperties bitmask of properties needed by the operation | [
"This",
"method",
"logs",
"a",
"warning",
"."
] | c6e4a9753c834d710e255306bb290e9244cdbc10 | https://github.com/Polidea/RxAndroidBle/blob/c6e4a9753c834d710e255306bb290e9244cdbc10/rxandroidble/src/main/java/com/polidea/rxandroidble2/internal/connection/LoggingIllegalOperationHandler.java#L26-L30 | train |
Polidea/RxAndroidBle | sample/src/main/java/com/polidea/rxandroidble2/sample/SampleApplication.java | SampleApplication.getRxBleClient | public static RxBleClient getRxBleClient(Context context) {
SampleApplication application = (SampleApplication) context.getApplicationContext();
return application.rxBleClient;
} | java | public static RxBleClient getRxBleClient(Context context) {
SampleApplication application = (SampleApplication) context.getApplicationContext();
return application.rxBleClient;
} | [
"public",
"static",
"RxBleClient",
"getRxBleClient",
"(",
"Context",
"context",
")",
"{",
"SampleApplication",
"application",
"=",
"(",
"SampleApplication",
")",
"context",
".",
"getApplicationContext",
"(",
")",
";",
"return",
"application",
".",
"rxBleClient",
";"... | In practise you will use some kind of dependency injection pattern. | [
"In",
"practise",
"you",
"will",
"use",
"some",
"kind",
"of",
"dependency",
"injection",
"pattern",
"."
] | c6e4a9753c834d710e255306bb290e9244cdbc10 | https://github.com/Polidea/RxAndroidBle/blob/c6e4a9753c834d710e255306bb290e9244cdbc10/sample/src/main/java/com/polidea/rxandroidble2/sample/SampleApplication.java#L21-L24 | train |
Polidea/RxAndroidBle | rxandroidble/src/main/java/com/polidea/rxandroidble2/internal/connection/IllegalOperationChecker.java | IllegalOperationChecker.checkAnyPropertyMatches | public Completable checkAnyPropertyMatches(final BluetoothGattCharacteristic characteristic,
final @BluetoothGattCharacteristicProperty int neededProperties) {
return Completable.fromAction(new Action() {
public void run() {
final int characteristicProperties = characteristic.getProperties();
if ((characteristicProperties & neededProperties) == 0) {
BleIllegalOperationException exception = resultHandler.handleMismatchData(characteristic, neededProperties);
if (exception != null) {
throw exception;
}
}
}
});
} | java | public Completable checkAnyPropertyMatches(final BluetoothGattCharacteristic characteristic,
final @BluetoothGattCharacteristicProperty int neededProperties) {
return Completable.fromAction(new Action() {
public void run() {
final int characteristicProperties = characteristic.getProperties();
if ((characteristicProperties & neededProperties) == 0) {
BleIllegalOperationException exception = resultHandler.handleMismatchData(characteristic, neededProperties);
if (exception != null) {
throw exception;
}
}
}
});
} | [
"public",
"Completable",
"checkAnyPropertyMatches",
"(",
"final",
"BluetoothGattCharacteristic",
"characteristic",
",",
"final",
"@",
"BluetoothGattCharacteristicProperty",
"int",
"neededProperties",
")",
"{",
"return",
"Completable",
".",
"fromAction",
"(",
"new",
"Action"... | This method checks whether the supplied characteristic possesses properties supporting the requested kind of operation, specified by
the supplied bitmask.
Emits {@link BleIllegalOperationException} if there was no match between supported and necessary properties of characteristic and
check has not been suppressed
@param characteristic a {@link BluetoothGattCharacteristic} the operation is done on
@param neededProperties properties required for the operation to be successfully completed
@return {@link Completable} deferring execution of the check till subscription | [
"This",
"method",
"checks",
"whether",
"the",
"supplied",
"characteristic",
"possesses",
"properties",
"supporting",
"the",
"requested",
"kind",
"of",
"operation",
"specified",
"by",
"the",
"supplied",
"bitmask",
"."
] | c6e4a9753c834d710e255306bb290e9244cdbc10 | https://github.com/Polidea/RxAndroidBle/blob/c6e4a9753c834d710e255306bb290e9244cdbc10/rxandroidble/src/main/java/com/polidea/rxandroidble2/internal/connection/IllegalOperationChecker.java#L36-L50 | train |
Polidea/RxAndroidBle | sample/src/main/java/com/polidea/rxandroidble2/sample/util/ScanExceptionHandler.java | ScanExceptionHandler.handleException | public static void handleException(final Activity context, final BleScanException exception) {
final String text;
final int reason = exception.getReason();
// Special case, as there might or might not be a retry date suggestion
if (reason == BleScanException.UNDOCUMENTED_SCAN_THROTTLE) {
text = getUndocumentedScanThrottleErrorMessage(context, exception.getRetryDateSuggestion());
} else {
// Handle all other possible errors
final Integer resId = ERROR_MESSAGES.get(reason);
if (resId != null) {
text = context.getString(resId);
} else {
// unknown error - return default message
Log.w("Scanning", String.format("No message found for reason=%d. Consider adding one.", reason));
text = context.getString(R.string.error_unknown_error);
}
}
Log.w("Scanning", text, exception);
Toast.makeText(context, text, Toast.LENGTH_SHORT).show();
} | java | public static void handleException(final Activity context, final BleScanException exception) {
final String text;
final int reason = exception.getReason();
// Special case, as there might or might not be a retry date suggestion
if (reason == BleScanException.UNDOCUMENTED_SCAN_THROTTLE) {
text = getUndocumentedScanThrottleErrorMessage(context, exception.getRetryDateSuggestion());
} else {
// Handle all other possible errors
final Integer resId = ERROR_MESSAGES.get(reason);
if (resId != null) {
text = context.getString(resId);
} else {
// unknown error - return default message
Log.w("Scanning", String.format("No message found for reason=%d. Consider adding one.", reason));
text = context.getString(R.string.error_unknown_error);
}
}
Log.w("Scanning", text, exception);
Toast.makeText(context, text, Toast.LENGTH_SHORT).show();
} | [
"public",
"static",
"void",
"handleException",
"(",
"final",
"Activity",
"context",
",",
"final",
"BleScanException",
"exception",
")",
"{",
"final",
"String",
"text",
";",
"final",
"int",
"reason",
"=",
"exception",
".",
"getReason",
"(",
")",
";",
"// Specia... | Show toast with error message appropriate to exception reason.
@param context current Activity context
@param exception BleScanException to show error message for | [
"Show",
"toast",
"with",
"error",
"message",
"appropriate",
"to",
"exception",
"reason",
"."
] | c6e4a9753c834d710e255306bb290e9244cdbc10 | https://github.com/Polidea/RxAndroidBle/blob/c6e4a9753c834d710e255306bb290e9244cdbc10/sample/src/main/java/com/polidea/rxandroidble2/sample/util/ScanExceptionHandler.java#L63-L84 | train |
Polidea/RxAndroidBle | rxandroidble/src/main/java/com/polidea/rxandroidble2/internal/operations/ConnectOperation.java | ConnectOperation.getConnectedBluetoothGatt | @NonNull
private Single<BluetoothGatt> getConnectedBluetoothGatt() {
// start connecting the BluetoothGatt
// note: Due to different Android BLE stack implementations it is not certain whether `connectGatt()` or `BluetoothGattCallback`
// will emit BluetoothGatt first
return Single.create(new SingleOnSubscribe<BluetoothGatt>() {
@Override
public void subscribe(final SingleEmitter<BluetoothGatt> emitter) throws Exception {
final DisposableSingleObserver<BluetoothGatt> disposableGattObserver = getBluetoothGattAndChangeStatusToConnected()
// when the connected state will be emitted bluetoothGattProvider should contain valid Gatt
.delaySubscription(
rxBleGattCallback
.getOnConnectionStateChange()
.filter(new Predicate<RxBleConnection.RxBleConnectionState>() {
@Override
public boolean test(RxBleConnection.RxBleConnectionState rxBleConnectionState)
throws Exception {
return rxBleConnectionState == CONNECTED;
}
})
)
// disconnect may happen even if the connection was not established yet
.mergeWith(rxBleGattCallback.<BluetoothGatt>observeDisconnect().firstOrError())
.firstOrError()
.subscribeWith(disposableSingleObserverFromEmitter(emitter));
emitter.setDisposable(disposableGattObserver);
connectionStateChangedAction.onConnectionStateChange(CONNECTING);
/*
* Apparently the connection may be established fast enough to introduce a race condition so the subscription
* must be established first before starting the connection.
* https://github.com/Polidea/RxAndroidBle/issues/178
* */
final BluetoothGatt bluetoothGatt = connectionCompat
.connectGatt(bluetoothDevice, autoConnect, rxBleGattCallback.getBluetoothGattCallback());
/*
* Update BluetoothGatt when connection is initiated. It is not certain
* if this or RxBleGattCallback.onConnectionStateChange will be first.
* */
bluetoothGattProvider.updateBluetoothGatt(bluetoothGatt);
}
});
} | java | @NonNull
private Single<BluetoothGatt> getConnectedBluetoothGatt() {
// start connecting the BluetoothGatt
// note: Due to different Android BLE stack implementations it is not certain whether `connectGatt()` or `BluetoothGattCallback`
// will emit BluetoothGatt first
return Single.create(new SingleOnSubscribe<BluetoothGatt>() {
@Override
public void subscribe(final SingleEmitter<BluetoothGatt> emitter) throws Exception {
final DisposableSingleObserver<BluetoothGatt> disposableGattObserver = getBluetoothGattAndChangeStatusToConnected()
// when the connected state will be emitted bluetoothGattProvider should contain valid Gatt
.delaySubscription(
rxBleGattCallback
.getOnConnectionStateChange()
.filter(new Predicate<RxBleConnection.RxBleConnectionState>() {
@Override
public boolean test(RxBleConnection.RxBleConnectionState rxBleConnectionState)
throws Exception {
return rxBleConnectionState == CONNECTED;
}
})
)
// disconnect may happen even if the connection was not established yet
.mergeWith(rxBleGattCallback.<BluetoothGatt>observeDisconnect().firstOrError())
.firstOrError()
.subscribeWith(disposableSingleObserverFromEmitter(emitter));
emitter.setDisposable(disposableGattObserver);
connectionStateChangedAction.onConnectionStateChange(CONNECTING);
/*
* Apparently the connection may be established fast enough to introduce a race condition so the subscription
* must be established first before starting the connection.
* https://github.com/Polidea/RxAndroidBle/issues/178
* */
final BluetoothGatt bluetoothGatt = connectionCompat
.connectGatt(bluetoothDevice, autoConnect, rxBleGattCallback.getBluetoothGattCallback());
/*
* Update BluetoothGatt when connection is initiated. It is not certain
* if this or RxBleGattCallback.onConnectionStateChange will be first.
* */
bluetoothGattProvider.updateBluetoothGatt(bluetoothGatt);
}
});
} | [
"@",
"NonNull",
"private",
"Single",
"<",
"BluetoothGatt",
">",
"getConnectedBluetoothGatt",
"(",
")",
"{",
"// start connecting the BluetoothGatt",
"// note: Due to different Android BLE stack implementations it is not certain whether `connectGatt()` or `BluetoothGattCallback`",
"// will ... | Emits BluetoothGatt and completes after connection is established.
@return BluetoothGatt after connection reaches {@link com.polidea.rxandroidble2.RxBleConnection.RxBleConnectionState#CONNECTED}
state.
@throws com.polidea.rxandroidble2.exceptions.BleDisconnectedException if connection was disconnected/failed before
it was established. | [
"Emits",
"BluetoothGatt",
"and",
"completes",
"after",
"connection",
"is",
"established",
"."
] | c6e4a9753c834d710e255306bb290e9244cdbc10 | https://github.com/Polidea/RxAndroidBle/blob/c6e4a9753c834d710e255306bb290e9244cdbc10/rxandroidble/src/main/java/com/polidea/rxandroidble2/internal/operations/ConnectOperation.java#L120-L165 | train |
Polidea/RxAndroidBle | rxandroidble/src/main/java/com/polidea/rxandroidble2/internal/scan/ScanSettingsEmulator.java | ScanSettingsEmulator.repeatedWindowTransformer | private ObservableTransformer<RxBleInternalScanResult, RxBleInternalScanResult> repeatedWindowTransformer(
@IntRange(from = 0, to = 4999) final int windowInMillis
) {
final long repeatCycleTimeInMillis = TimeUnit.SECONDS.toMillis(5);
final long delayToNextWindow = Math.max(repeatCycleTimeInMillis - windowInMillis, 0); // to be sure that it won't be negative
return new ObservableTransformer<RxBleInternalScanResult, RxBleInternalScanResult>() {
@Override
public Observable<RxBleInternalScanResult> apply(final Observable<RxBleInternalScanResult> rxBleInternalScanResultObservable) {
return rxBleInternalScanResultObservable.take(windowInMillis, TimeUnit.MILLISECONDS, scheduler)
.repeatWhen(new Function<Observable<Object>, ObservableSource<?>>() {
@Override
public ObservableSource<?> apply(Observable<Object> observable) throws Exception {
return observable.delay(delayToNextWindow, TimeUnit.MILLISECONDS, scheduler
);
}
});
}
};
} | java | private ObservableTransformer<RxBleInternalScanResult, RxBleInternalScanResult> repeatedWindowTransformer(
@IntRange(from = 0, to = 4999) final int windowInMillis
) {
final long repeatCycleTimeInMillis = TimeUnit.SECONDS.toMillis(5);
final long delayToNextWindow = Math.max(repeatCycleTimeInMillis - windowInMillis, 0); // to be sure that it won't be negative
return new ObservableTransformer<RxBleInternalScanResult, RxBleInternalScanResult>() {
@Override
public Observable<RxBleInternalScanResult> apply(final Observable<RxBleInternalScanResult> rxBleInternalScanResultObservable) {
return rxBleInternalScanResultObservable.take(windowInMillis, TimeUnit.MILLISECONDS, scheduler)
.repeatWhen(new Function<Observable<Object>, ObservableSource<?>>() {
@Override
public ObservableSource<?> apply(Observable<Object> observable) throws Exception {
return observable.delay(delayToNextWindow, TimeUnit.MILLISECONDS, scheduler
);
}
});
}
};
} | [
"private",
"ObservableTransformer",
"<",
"RxBleInternalScanResult",
",",
"RxBleInternalScanResult",
">",
"repeatedWindowTransformer",
"(",
"@",
"IntRange",
"(",
"from",
"=",
"0",
",",
"to",
"=",
"4999",
")",
"final",
"int",
"windowInMillis",
")",
"{",
"final",
"lo... | A convenience method for running a scan for a period of time and repeat in five seconds intervals.
@param windowInMillis window for which the observable should be active
@return Observable.Transformer that will take the original observable for specific time and repeat subscription after 5 seconds | [
"A",
"convenience",
"method",
"for",
"running",
"a",
"scan",
"for",
"a",
"period",
"of",
"time",
"and",
"repeat",
"in",
"five",
"seconds",
"intervals",
"."
] | c6e4a9753c834d710e255306bb290e9244cdbc10 | https://github.com/Polidea/RxAndroidBle/blob/c6e4a9753c834d710e255306bb290e9244cdbc10/rxandroidble/src/main/java/com/polidea/rxandroidble2/internal/scan/ScanSettingsEmulator.java#L104-L122 | train |
Polidea/RxAndroidBle | rxandroidble/src/main/java/com/polidea/rxandroidble2/scan/ScanFilter.java | ScanFilter.matchesServiceUuids | private boolean matchesServiceUuids(ParcelUuid uuid, ParcelUuid parcelUuidMask,
List<ParcelUuid> uuids) {
if (uuid == null) {
return true;
}
if (uuids == null) {
return false;
}
for (ParcelUuid parcelUuid : uuids) {
UUID uuidMask = parcelUuidMask == null ? null : parcelUuidMask.getUuid();
if (matchesServiceUuid(uuid.getUuid(), uuidMask, parcelUuid.getUuid())) {
return true;
}
}
return false;
} | java | private boolean matchesServiceUuids(ParcelUuid uuid, ParcelUuid parcelUuidMask,
List<ParcelUuid> uuids) {
if (uuid == null) {
return true;
}
if (uuids == null) {
return false;
}
for (ParcelUuid parcelUuid : uuids) {
UUID uuidMask = parcelUuidMask == null ? null : parcelUuidMask.getUuid();
if (matchesServiceUuid(uuid.getUuid(), uuidMask, parcelUuid.getUuid())) {
return true;
}
}
return false;
} | [
"private",
"boolean",
"matchesServiceUuids",
"(",
"ParcelUuid",
"uuid",
",",
"ParcelUuid",
"parcelUuidMask",
",",
"List",
"<",
"ParcelUuid",
">",
"uuids",
")",
"{",
"if",
"(",
"uuid",
"==",
"null",
")",
"{",
"return",
"true",
";",
"}",
"if",
"(",
"uuids",
... | Check if the uuid pattern is contained in a list of parcel uuids. | [
"Check",
"if",
"the",
"uuid",
"pattern",
"is",
"contained",
"in",
"a",
"list",
"of",
"parcel",
"uuids",
"."
] | c6e4a9753c834d710e255306bb290e9244cdbc10 | https://github.com/Polidea/RxAndroidBle/blob/c6e4a9753c834d710e255306bb290e9244cdbc10/rxandroidble/src/main/java/com/polidea/rxandroidble2/scan/ScanFilter.java#L314-L330 | train |
Polidea/RxAndroidBle | rxandroidble/src/main/java/com/polidea/rxandroidble2/internal/util/CheckerLocationPermission.java | CheckerLocationPermission.isPermissionGranted | private boolean isPermissionGranted(String permission) {
if (permission == null) {
throw new IllegalArgumentException("permission is null");
}
return context.checkPermission(permission, android.os.Process.myPid(), Process.myUid()) == PackageManager.PERMISSION_GRANTED;
} | java | private boolean isPermissionGranted(String permission) {
if (permission == null) {
throw new IllegalArgumentException("permission is null");
}
return context.checkPermission(permission, android.os.Process.myPid(), Process.myUid()) == PackageManager.PERMISSION_GRANTED;
} | [
"private",
"boolean",
"isPermissionGranted",
"(",
"String",
"permission",
")",
"{",
"if",
"(",
"permission",
"==",
"null",
")",
"{",
"throw",
"new",
"IllegalArgumentException",
"(",
"\"permission is null\"",
")",
";",
"}",
"return",
"context",
".",
"checkPermissio... | Copied from android.support.v4.content.ContextCompat for backwards compatibility
@param permission the permission to check
@return true is granted | [
"Copied",
"from",
"android",
".",
"support",
".",
"v4",
".",
"content",
".",
"ContextCompat",
"for",
"backwards",
"compatibility"
] | c6e4a9753c834d710e255306bb290e9244cdbc10 | https://github.com/Polidea/RxAndroidBle/blob/c6e4a9753c834d710e255306bb290e9244cdbc10/rxandroidble/src/main/java/com/polidea/rxandroidble2/internal/util/CheckerLocationPermission.java#L30-L36 | train |
Polidea/RxAndroidBle | rxandroidble/src/main/java/com/polidea/rxandroidble2/internal/util/UUIDUtil.java | UUIDUtil.parseServiceUuid | private static int parseServiceUuid(byte[] scanRecord, int currentPos, int dataLength,
int uuidLength, List<ParcelUuid> serviceUuids) {
while (dataLength > 0) {
byte[] uuidBytes = extractBytes(scanRecord, currentPos,
uuidLength);
serviceUuids.add(parseUuidFrom(uuidBytes));
dataLength -= uuidLength;
currentPos += uuidLength;
}
return currentPos;
} | java | private static int parseServiceUuid(byte[] scanRecord, int currentPos, int dataLength,
int uuidLength, List<ParcelUuid> serviceUuids) {
while (dataLength > 0) {
byte[] uuidBytes = extractBytes(scanRecord, currentPos,
uuidLength);
serviceUuids.add(parseUuidFrom(uuidBytes));
dataLength -= uuidLength;
currentPos += uuidLength;
}
return currentPos;
} | [
"private",
"static",
"int",
"parseServiceUuid",
"(",
"byte",
"[",
"]",
"scanRecord",
",",
"int",
"currentPos",
",",
"int",
"dataLength",
",",
"int",
"uuidLength",
",",
"List",
"<",
"ParcelUuid",
">",
"serviceUuids",
")",
"{",
"while",
"(",
"dataLength",
">",... | Parse service UUIDs. | [
"Parse",
"service",
"UUIDs",
"."
] | c6e4a9753c834d710e255306bb290e9244cdbc10 | https://github.com/Polidea/RxAndroidBle/blob/c6e4a9753c834d710e255306bb290e9244cdbc10/rxandroidble/src/main/java/com/polidea/rxandroidble2/internal/util/UUIDUtil.java#L248-L258 | train |
Polidea/RxAndroidBle | rxandroidble/src/main/java/com/polidea/rxandroidble2/internal/util/UUIDUtil.java | UUIDUtil.extractBytes | private static byte[] extractBytes(byte[] scanRecord, int start, int length) {
byte[] bytes = new byte[length];
System.arraycopy(scanRecord, start, bytes, 0, length);
return bytes;
} | java | private static byte[] extractBytes(byte[] scanRecord, int start, int length) {
byte[] bytes = new byte[length];
System.arraycopy(scanRecord, start, bytes, 0, length);
return bytes;
} | [
"private",
"static",
"byte",
"[",
"]",
"extractBytes",
"(",
"byte",
"[",
"]",
"scanRecord",
",",
"int",
"start",
",",
"int",
"length",
")",
"{",
"byte",
"[",
"]",
"bytes",
"=",
"new",
"byte",
"[",
"length",
"]",
";",
"System",
".",
"arraycopy",
"(",
... | Helper method to extract bytes from byte array. | [
"Helper",
"method",
"to",
"extract",
"bytes",
"from",
"byte",
"array",
"."
] | c6e4a9753c834d710e255306bb290e9244cdbc10 | https://github.com/Polidea/RxAndroidBle/blob/c6e4a9753c834d710e255306bb290e9244cdbc10/rxandroidble/src/main/java/com/polidea/rxandroidble2/internal/util/UUIDUtil.java#L261-L265 | train |
Polidea/RxAndroidBle | rxandroidble/src/main/java/com/polidea/rxandroidble2/helpers/ValueInterpreter.java | ValueInterpreter.unsignedBytesToInt | private static int unsignedBytesToInt(byte b0, byte b1, byte b2, byte b3) {
return (unsignedByteToInt(b0) + (unsignedByteToInt(b1) << 8))
+ (unsignedByteToInt(b2) << 16) + (unsignedByteToInt(b3) << 24);
} | java | private static int unsignedBytesToInt(byte b0, byte b1, byte b2, byte b3) {
return (unsignedByteToInt(b0) + (unsignedByteToInt(b1) << 8))
+ (unsignedByteToInt(b2) << 16) + (unsignedByteToInt(b3) << 24);
} | [
"private",
"static",
"int",
"unsignedBytesToInt",
"(",
"byte",
"b0",
",",
"byte",
"b1",
",",
"byte",
"b2",
",",
"byte",
"b3",
")",
"{",
"return",
"(",
"unsignedByteToInt",
"(",
"b0",
")",
"+",
"(",
"unsignedByteToInt",
"(",
"b1",
")",
"<<",
"8",
")",
... | Convert signed bytes to a 32-bit unsigned int. | [
"Convert",
"signed",
"bytes",
"to",
"a",
"32",
"-",
"bit",
"unsigned",
"int",
"."
] | c6e4a9753c834d710e255306bb290e9244cdbc10 | https://github.com/Polidea/RxAndroidBle/blob/c6e4a9753c834d710e255306bb290e9244cdbc10/rxandroidble/src/main/java/com/polidea/rxandroidble2/helpers/ValueInterpreter.java#L199-L202 | train |
Polidea/RxAndroidBle | rxandroidble/src/main/java/com/polidea/rxandroidble2/helpers/ValueInterpreter.java | ValueInterpreter.bytesToFloat | private static float bytesToFloat(byte b0, byte b1) {
int mantissa = unsignedToSigned(unsignedByteToInt(b0)
+ ((unsignedByteToInt(b1) & 0x0F) << 8), 12);
int exponent = unsignedToSigned(unsignedByteToInt(b1) >> 4, 4);
return (float) (mantissa * Math.pow(10, exponent));
} | java | private static float bytesToFloat(byte b0, byte b1) {
int mantissa = unsignedToSigned(unsignedByteToInt(b0)
+ ((unsignedByteToInt(b1) & 0x0F) << 8), 12);
int exponent = unsignedToSigned(unsignedByteToInt(b1) >> 4, 4);
return (float) (mantissa * Math.pow(10, exponent));
} | [
"private",
"static",
"float",
"bytesToFloat",
"(",
"byte",
"b0",
",",
"byte",
"b1",
")",
"{",
"int",
"mantissa",
"=",
"unsignedToSigned",
"(",
"unsignedByteToInt",
"(",
"b0",
")",
"+",
"(",
"(",
"unsignedByteToInt",
"(",
"b1",
")",
"&",
"0x0F",
")",
"<<"... | Convert signed bytes to a 16-bit short float value. | [
"Convert",
"signed",
"bytes",
"to",
"a",
"16",
"-",
"bit",
"short",
"float",
"value",
"."
] | c6e4a9753c834d710e255306bb290e9244cdbc10 | https://github.com/Polidea/RxAndroidBle/blob/c6e4a9753c834d710e255306bb290e9244cdbc10/rxandroidble/src/main/java/com/polidea/rxandroidble2/helpers/ValueInterpreter.java#L207-L212 | train |
Polidea/RxAndroidBle | rxandroidble/src/main/java/com/polidea/rxandroidble2/helpers/ValueInterpreter.java | ValueInterpreter.bytesToFloat | private static float bytesToFloat(byte b0, byte b1, byte b2, byte b3) {
int mantissa = unsignedToSigned(unsignedByteToInt(b0)
+ (unsignedByteToInt(b1) << 8)
+ (unsignedByteToInt(b2) << 16), 24);
return (float) (mantissa * Math.pow(10, b3));
} | java | private static float bytesToFloat(byte b0, byte b1, byte b2, byte b3) {
int mantissa = unsignedToSigned(unsignedByteToInt(b0)
+ (unsignedByteToInt(b1) << 8)
+ (unsignedByteToInt(b2) << 16), 24);
return (float) (mantissa * Math.pow(10, b3));
} | [
"private",
"static",
"float",
"bytesToFloat",
"(",
"byte",
"b0",
",",
"byte",
"b1",
",",
"byte",
"b2",
",",
"byte",
"b3",
")",
"{",
"int",
"mantissa",
"=",
"unsignedToSigned",
"(",
"unsignedByteToInt",
"(",
"b0",
")",
"+",
"(",
"unsignedByteToInt",
"(",
... | Convert signed bytes to a 32-bit short float value. | [
"Convert",
"signed",
"bytes",
"to",
"a",
"32",
"-",
"bit",
"short",
"float",
"value",
"."
] | c6e4a9753c834d710e255306bb290e9244cdbc10 | https://github.com/Polidea/RxAndroidBle/blob/c6e4a9753c834d710e255306bb290e9244cdbc10/rxandroidble/src/main/java/com/polidea/rxandroidble2/helpers/ValueInterpreter.java#L217-L222 | train |
Polidea/RxAndroidBle | rxandroidble/src/main/java/com/polidea/rxandroidble2/helpers/ValueInterpreter.java | ValueInterpreter.unsignedToSigned | private static int unsignedToSigned(int unsigned, int size) {
if ((unsigned & (1 << size - 1)) != 0) {
unsigned = -1 * ((1 << size - 1) - (unsigned & ((1 << size - 1) - 1)));
}
return unsigned;
} | java | private static int unsignedToSigned(int unsigned, int size) {
if ((unsigned & (1 << size - 1)) != 0) {
unsigned = -1 * ((1 << size - 1) - (unsigned & ((1 << size - 1) - 1)));
}
return unsigned;
} | [
"private",
"static",
"int",
"unsignedToSigned",
"(",
"int",
"unsigned",
",",
"int",
"size",
")",
"{",
"if",
"(",
"(",
"unsigned",
"&",
"(",
"1",
"<<",
"size",
"-",
"1",
")",
")",
"!=",
"0",
")",
"{",
"unsigned",
"=",
"-",
"1",
"*",
"(",
"(",
"1... | Convert an unsigned integer value to a two's-complement encoded
signed value. | [
"Convert",
"an",
"unsigned",
"integer",
"value",
"to",
"a",
"two",
"s",
"-",
"complement",
"encoded",
"signed",
"value",
"."
] | c6e4a9753c834d710e255306bb290e9244cdbc10 | https://github.com/Polidea/RxAndroidBle/blob/c6e4a9753c834d710e255306bb290e9244cdbc10/rxandroidble/src/main/java/com/polidea/rxandroidble2/helpers/ValueInterpreter.java#L228-L233 | train |
Polidea/RxAndroidBle | sample/src/main/java/com/polidea/rxandroidble2/sample/example4_characteristic/advanced/Presenter.java | Presenter.repeatAfterCompleted | @NonNull
private static <T> ObservableTransformer<T, T> repeatAfterCompleted() {
return observable -> observable.repeatWhen(completedNotification -> completedNotification);
} | java | @NonNull
private static <T> ObservableTransformer<T, T> repeatAfterCompleted() {
return observable -> observable.repeatWhen(completedNotification -> completedNotification);
} | [
"@",
"NonNull",
"private",
"static",
"<",
"T",
">",
"ObservableTransformer",
"<",
"T",
",",
"T",
">",
"repeatAfterCompleted",
"(",
")",
"{",
"return",
"observable",
"->",
"observable",
".",
"repeatWhen",
"(",
"completedNotification",
"->",
"completedNotification",... | A convenience function creating a transformer that will repeat the source observable whenever it will complete
@param <T> the type of the transformed observable
@return transformer that will emit observable that will never complete (source will be subscribed again) | [
"A",
"convenience",
"function",
"creating",
"a",
"transformer",
"that",
"will",
"repeat",
"the",
"source",
"observable",
"whenever",
"it",
"will",
"complete"
] | c6e4a9753c834d710e255306bb290e9244cdbc10 | https://github.com/Polidea/RxAndroidBle/blob/c6e4a9753c834d710e255306bb290e9244cdbc10/sample/src/main/java/com/polidea/rxandroidble2/sample/example4_characteristic/advanced/Presenter.java#L261-L264 | train |
Polidea/RxAndroidBle | rxandroidble/src/main/java/com/polidea/rxandroidble2/internal/RxBleLog.java | RxBleLog.updateLogOptions | public static void updateLogOptions(LogOptions logOptions) {
LoggerSetup oldLoggerSetup = RxBleLog.loggerSetup;
LoggerSetup newLoggerSetup = oldLoggerSetup.merge(logOptions);
d("Received new options (%s) and merged with old setup: %s. New setup: %s", logOptions, oldLoggerSetup, newLoggerSetup);
RxBleLog.loggerSetup = newLoggerSetup;
} | java | public static void updateLogOptions(LogOptions logOptions) {
LoggerSetup oldLoggerSetup = RxBleLog.loggerSetup;
LoggerSetup newLoggerSetup = oldLoggerSetup.merge(logOptions);
d("Received new options (%s) and merged with old setup: %s. New setup: %s", logOptions, oldLoggerSetup, newLoggerSetup);
RxBleLog.loggerSetup = newLoggerSetup;
} | [
"public",
"static",
"void",
"updateLogOptions",
"(",
"LogOptions",
"logOptions",
")",
"{",
"LoggerSetup",
"oldLoggerSetup",
"=",
"RxBleLog",
".",
"loggerSetup",
";",
"LoggerSetup",
"newLoggerSetup",
"=",
"oldLoggerSetup",
".",
"merge",
"(",
"logOptions",
")",
";",
... | Method to update current logger setup with new LogOptions. Only set options will be updated. Options that were not set or set to null
on the LogOptions will not update the current setup leaving the previous values untouched.
@param logOptions the new log options | [
"Method",
"to",
"update",
"current",
"logger",
"setup",
"with",
"new",
"LogOptions",
".",
"Only",
"set",
"options",
"will",
"be",
"updated",
".",
"Options",
"that",
"were",
"not",
"set",
"or",
"set",
"to",
"null",
"on",
"the",
"LogOptions",
"will",
"not",
... | c6e4a9753c834d710e255306bb290e9244cdbc10 | https://github.com/Polidea/RxAndroidBle/blob/c6e4a9753c834d710e255306bb290e9244cdbc10/rxandroidble/src/main/java/com/polidea/rxandroidble2/internal/RxBleLog.java#L130-L135 | train |
Polidea/RxAndroidBle | sample/src/main/java/com/polidea/rxandroidble2/sample/example4_characteristic/CharacteristicOperationExampleActivity.java | CharacteristicOperationExampleActivity.updateUI | private void updateUI(BluetoothGattCharacteristic characteristic) {
connectButton.setText(characteristic != null ? R.string.disconnect : R.string.connect);
readButton.setEnabled(hasProperty(characteristic, BluetoothGattCharacteristic.PROPERTY_READ));
writeButton.setEnabled(hasProperty(characteristic, BluetoothGattCharacteristic.PROPERTY_WRITE));
notifyButton.setEnabled(hasProperty(characteristic, BluetoothGattCharacteristic.PROPERTY_NOTIFY));
} | java | private void updateUI(BluetoothGattCharacteristic characteristic) {
connectButton.setText(characteristic != null ? R.string.disconnect : R.string.connect);
readButton.setEnabled(hasProperty(characteristic, BluetoothGattCharacteristic.PROPERTY_READ));
writeButton.setEnabled(hasProperty(characteristic, BluetoothGattCharacteristic.PROPERTY_WRITE));
notifyButton.setEnabled(hasProperty(characteristic, BluetoothGattCharacteristic.PROPERTY_NOTIFY));
} | [
"private",
"void",
"updateUI",
"(",
"BluetoothGattCharacteristic",
"characteristic",
")",
"{",
"connectButton",
".",
"setText",
"(",
"characteristic",
"!=",
"null",
"?",
"R",
".",
"string",
".",
"disconnect",
":",
"R",
".",
"string",
".",
"connect",
")",
";",
... | This method updates the UI to a proper state.
@param characteristic a nullable {@link BluetoothGattCharacteristic}. If it is null then UI is assuming a disconnected state. | [
"This",
"method",
"updates",
"the",
"UI",
"to",
"a",
"proper",
"state",
"."
] | c6e4a9753c834d710e255306bb290e9244cdbc10 | https://github.com/Polidea/RxAndroidBle/blob/c6e4a9753c834d710e255306bb290e9244cdbc10/sample/src/main/java/com/polidea/rxandroidble2/sample/example4_characteristic/CharacteristicOperationExampleActivity.java#L209-L214 | train |
Polidea/RxAndroidBle | rxandroidble/src/main/java/com/polidea/rxandroidble2/internal/util/ClientStateObservable.java | ClientStateObservable.checkPermissionUntilGranted | @NonNull
private static Single<Boolean> checkPermissionUntilGranted(
final LocationServicesStatus locationServicesStatus,
Scheduler timerScheduler
) {
return Observable.interval(0, 1L, TimeUnit.SECONDS, timerScheduler)
.takeWhile(new Predicate<Long>() {
@Override
public boolean test(Long timer) {
return !locationServicesStatus.isLocationPermissionOk();
}
})
.count()
.map(new Function<Long, Boolean>() {
@Override
public Boolean apply(Long count) {
// if no elements were emitted then the permission was granted from the beginning
return count == 0;
}
});
} | java | @NonNull
private static Single<Boolean> checkPermissionUntilGranted(
final LocationServicesStatus locationServicesStatus,
Scheduler timerScheduler
) {
return Observable.interval(0, 1L, TimeUnit.SECONDS, timerScheduler)
.takeWhile(new Predicate<Long>() {
@Override
public boolean test(Long timer) {
return !locationServicesStatus.isLocationPermissionOk();
}
})
.count()
.map(new Function<Long, Boolean>() {
@Override
public Boolean apply(Long count) {
// if no elements were emitted then the permission was granted from the beginning
return count == 0;
}
});
} | [
"@",
"NonNull",
"private",
"static",
"Single",
"<",
"Boolean",
">",
"checkPermissionUntilGranted",
"(",
"final",
"LocationServicesStatus",
"locationServicesStatus",
",",
"Scheduler",
"timerScheduler",
")",
"{",
"return",
"Observable",
".",
"interval",
"(",
"0",
",",
... | Observable that emits `true` if the permission was granted on the time of subscription
@param locationServicesStatus the LocationServicesStatus
@param timerScheduler the Scheduler
@return the observable | [
"Observable",
"that",
"emits",
"true",
"if",
"the",
"permission",
"was",
"granted",
"on",
"the",
"time",
"of",
"subscription"
] | c6e4a9753c834d710e255306bb290e9244cdbc10 | https://github.com/Polidea/RxAndroidBle/blob/c6e4a9753c834d710e255306bb290e9244cdbc10/rxandroidble/src/main/java/com/polidea/rxandroidble2/internal/util/ClientStateObservable.java#L59-L79 | train |
chrisjenx/Calligraphy | calligraphy/src/main/java/uk/co/chrisjenx/calligraphy/CalligraphyLayoutInflater.java | CalligraphyLayoutInflater.onCreateView | @Override
@TargetApi(Build.VERSION_CODES.HONEYCOMB)
protected View onCreateView(View parent, String name, AttributeSet attrs) throws ClassNotFoundException {
return mCalligraphyFactory.onViewCreated(super.onCreateView(parent, name, attrs),
getContext(), attrs);
} | java | @Override
@TargetApi(Build.VERSION_CODES.HONEYCOMB)
protected View onCreateView(View parent, String name, AttributeSet attrs) throws ClassNotFoundException {
return mCalligraphyFactory.onViewCreated(super.onCreateView(parent, name, attrs),
getContext(), attrs);
} | [
"@",
"Override",
"@",
"TargetApi",
"(",
"Build",
".",
"VERSION_CODES",
".",
"HONEYCOMB",
")",
"protected",
"View",
"onCreateView",
"(",
"View",
"parent",
",",
"String",
"name",
",",
"AttributeSet",
"attrs",
")",
"throws",
"ClassNotFoundException",
"{",
"return",... | The LayoutInflater onCreateView is the fourth port of call for LayoutInflation.
BUT only for none CustomViews. | [
"The",
"LayoutInflater",
"onCreateView",
"is",
"the",
"fourth",
"port",
"of",
"call",
"for",
"LayoutInflation",
".",
"BUT",
"only",
"for",
"none",
"CustomViews",
"."
] | 085e441954d787bd4ef31f245afe5f2f2a311ea5 | https://github.com/chrisjenx/Calligraphy/blob/085e441954d787bd4ef31f245afe5f2f2a311ea5/calligraphy/src/main/java/uk/co/chrisjenx/calligraphy/CalligraphyLayoutInflater.java#L145-L150 | train |
chrisjenx/Calligraphy | calligraphy/src/main/java/uk/co/chrisjenx/calligraphy/CalligraphyUtils.java | CalligraphyUtils.applyTypefaceSpan | public static CharSequence applyTypefaceSpan(CharSequence s, Typeface typeface) {
if (s != null && s.length() > 0) {
if (!(s instanceof Spannable)) {
s = new SpannableString(s);
}
((Spannable) s).setSpan(TypefaceUtils.getSpan(typeface), 0, s.length(), Spanned.SPAN_EXCLUSIVE_EXCLUSIVE);
}
return s;
} | java | public static CharSequence applyTypefaceSpan(CharSequence s, Typeface typeface) {
if (s != null && s.length() > 0) {
if (!(s instanceof Spannable)) {
s = new SpannableString(s);
}
((Spannable) s).setSpan(TypefaceUtils.getSpan(typeface), 0, s.length(), Spanned.SPAN_EXCLUSIVE_EXCLUSIVE);
}
return s;
} | [
"public",
"static",
"CharSequence",
"applyTypefaceSpan",
"(",
"CharSequence",
"s",
",",
"Typeface",
"typeface",
")",
"{",
"if",
"(",
"s",
"!=",
"null",
"&&",
"s",
".",
"length",
"(",
")",
">",
"0",
")",
"{",
"if",
"(",
"!",
"(",
"s",
"instanceof",
"S... | Applies a custom typeface span to the text.
@param s text to apply it too.
@param typeface typeface to apply.
@return Either the passed in Object or new Spannable with the typeface span applied. | [
"Applies",
"a",
"custom",
"typeface",
"span",
"to",
"the",
"text",
"."
] | 085e441954d787bd4ef31f245afe5f2f2a311ea5 | https://github.com/chrisjenx/Calligraphy/blob/085e441954d787bd4ef31f245afe5f2f2a311ea5/calligraphy/src/main/java/uk/co/chrisjenx/calligraphy/CalligraphyUtils.java#L34-L42 | train |
chrisjenx/Calligraphy | calligraphy/src/main/java/uk/co/chrisjenx/calligraphy/CalligraphyUtils.java | CalligraphyUtils.applyFontToTextView | public static boolean applyFontToTextView(final TextView textView, final Typeface typeface, boolean deferred) {
if (textView == null || typeface == null) return false;
textView.setPaintFlags(textView.getPaintFlags() | Paint.SUBPIXEL_TEXT_FLAG | Paint.ANTI_ALIAS_FLAG);
textView.setTypeface(typeface);
if (deferred) {
textView.setText(applyTypefaceSpan(textView.getText(), typeface), TextView.BufferType.SPANNABLE);
textView.addTextChangedListener(new TextWatcher() {
@Override
public void beforeTextChanged(CharSequence s, int start, int count, int after) {
}
@Override
public void onTextChanged(CharSequence s, int start, int before, int count) {
}
@Override
public void afterTextChanged(Editable s) {
applyTypefaceSpan(s, typeface);
}
});
}
return true;
} | java | public static boolean applyFontToTextView(final TextView textView, final Typeface typeface, boolean deferred) {
if (textView == null || typeface == null) return false;
textView.setPaintFlags(textView.getPaintFlags() | Paint.SUBPIXEL_TEXT_FLAG | Paint.ANTI_ALIAS_FLAG);
textView.setTypeface(typeface);
if (deferred) {
textView.setText(applyTypefaceSpan(textView.getText(), typeface), TextView.BufferType.SPANNABLE);
textView.addTextChangedListener(new TextWatcher() {
@Override
public void beforeTextChanged(CharSequence s, int start, int count, int after) {
}
@Override
public void onTextChanged(CharSequence s, int start, int before, int count) {
}
@Override
public void afterTextChanged(Editable s) {
applyTypefaceSpan(s, typeface);
}
});
}
return true;
} | [
"public",
"static",
"boolean",
"applyFontToTextView",
"(",
"final",
"TextView",
"textView",
",",
"final",
"Typeface",
"typeface",
",",
"boolean",
"deferred",
")",
"{",
"if",
"(",
"textView",
"==",
"null",
"||",
"typeface",
"==",
"null",
")",
"return",
"false",... | Applies a Typeface to a TextView, if deferred,its recommend you don't call this multiple
times, as this adds a TextWatcher.
Deferring should really only be used on tricky views which get Typeface set by the system at
weird times.
@param textView Not null, TextView or child of.
@param typeface Not null, Typeface to apply to the TextView.
@param deferred If true we use Typefaces and TextChange listener to make sure font is always
applied, but this sometimes conflicts with other
{@link android.text.Spannable}'s.
@return true if applied otherwise false.
@see #applyFontToTextView(android.widget.TextView, android.graphics.Typeface) | [
"Applies",
"a",
"Typeface",
"to",
"a",
"TextView",
"if",
"deferred",
"its",
"recommend",
"you",
"don",
"t",
"call",
"this",
"multiple",
"times",
"as",
"this",
"adds",
"a",
"TextWatcher",
"."
] | 085e441954d787bd4ef31f245afe5f2f2a311ea5 | https://github.com/chrisjenx/Calligraphy/blob/085e441954d787bd4ef31f245afe5f2f2a311ea5/calligraphy/src/main/java/uk/co/chrisjenx/calligraphy/CalligraphyUtils.java#L74-L96 | train |
chrisjenx/Calligraphy | calligraphy/src/main/java/uk/co/chrisjenx/calligraphy/CalligraphyUtils.java | CalligraphyUtils.pullFontPathFromView | static String pullFontPathFromView(Context context, AttributeSet attrs, int[] attributeId) {
if (attributeId == null || attrs == null)
return null;
final String attributeName;
try {
attributeName = context.getResources().getResourceEntryName(attributeId[0]);
} catch (Resources.NotFoundException e) {
// invalid attribute ID
return null;
}
final int stringResourceId = attrs.getAttributeResourceValue(null, attributeName, -1);
return stringResourceId > 0
? context.getString(stringResourceId)
: attrs.getAttributeValue(null, attributeName);
} | java | static String pullFontPathFromView(Context context, AttributeSet attrs, int[] attributeId) {
if (attributeId == null || attrs == null)
return null;
final String attributeName;
try {
attributeName = context.getResources().getResourceEntryName(attributeId[0]);
} catch (Resources.NotFoundException e) {
// invalid attribute ID
return null;
}
final int stringResourceId = attrs.getAttributeResourceValue(null, attributeName, -1);
return stringResourceId > 0
? context.getString(stringResourceId)
: attrs.getAttributeValue(null, attributeName);
} | [
"static",
"String",
"pullFontPathFromView",
"(",
"Context",
"context",
",",
"AttributeSet",
"attrs",
",",
"int",
"[",
"]",
"attributeId",
")",
"{",
"if",
"(",
"attributeId",
"==",
"null",
"||",
"attrs",
"==",
"null",
")",
"return",
"null",
";",
"final",
"S... | Tries to pull the Custom Attribute directly from the TextView.
@param context Activity Context
@param attrs View Attributes
@param attributeId if -1 returns null.
@return null if attribute is not defined or added to View | [
"Tries",
"to",
"pull",
"the",
"Custom",
"Attribute",
"directly",
"from",
"the",
"TextView",
"."
] | 085e441954d787bd4ef31f245afe5f2f2a311ea5 | https://github.com/chrisjenx/Calligraphy/blob/085e441954d787bd4ef31f245afe5f2f2a311ea5/calligraphy/src/main/java/uk/co/chrisjenx/calligraphy/CalligraphyUtils.java#L157-L173 | train |
chrisjenx/Calligraphy | calligraphy/src/main/java/uk/co/chrisjenx/calligraphy/CalligraphyUtils.java | CalligraphyUtils.pullFontPathFromStyle | static String pullFontPathFromStyle(Context context, AttributeSet attrs, int[] attributeId) {
if (attributeId == null || attrs == null)
return null;
final TypedArray typedArray = context.obtainStyledAttributes(attrs, attributeId);
if (typedArray != null) {
try {
// First defined attribute
String fontFromAttribute = typedArray.getString(0);
if (!TextUtils.isEmpty(fontFromAttribute)) {
return fontFromAttribute;
}
} catch (Exception ignore) {
// Failed for some reason.
} finally {
typedArray.recycle();
}
}
return null;
} | java | static String pullFontPathFromStyle(Context context, AttributeSet attrs, int[] attributeId) {
if (attributeId == null || attrs == null)
return null;
final TypedArray typedArray = context.obtainStyledAttributes(attrs, attributeId);
if (typedArray != null) {
try {
// First defined attribute
String fontFromAttribute = typedArray.getString(0);
if (!TextUtils.isEmpty(fontFromAttribute)) {
return fontFromAttribute;
}
} catch (Exception ignore) {
// Failed for some reason.
} finally {
typedArray.recycle();
}
}
return null;
} | [
"static",
"String",
"pullFontPathFromStyle",
"(",
"Context",
"context",
",",
"AttributeSet",
"attrs",
",",
"int",
"[",
"]",
"attributeId",
")",
"{",
"if",
"(",
"attributeId",
"==",
"null",
"||",
"attrs",
"==",
"null",
")",
"return",
"null",
";",
"final",
"... | Tries to pull the Font Path from the View Style as this is the next decendent after being
defined in the View's xml.
@param context Activity Activity Context
@param attrs View Attributes
@param attributeId if -1 returns null.
@return null if attribute is not defined or found in the Style | [
"Tries",
"to",
"pull",
"the",
"Font",
"Path",
"from",
"the",
"View",
"Style",
"as",
"this",
"is",
"the",
"next",
"decendent",
"after",
"being",
"defined",
"in",
"the",
"View",
"s",
"xml",
"."
] | 085e441954d787bd4ef31f245afe5f2f2a311ea5 | https://github.com/chrisjenx/Calligraphy/blob/085e441954d787bd4ef31f245afe5f2f2a311ea5/calligraphy/src/main/java/uk/co/chrisjenx/calligraphy/CalligraphyUtils.java#L184-L202 | train |
chrisjenx/Calligraphy | calligraphy/src/main/java/uk/co/chrisjenx/calligraphy/CalligraphyUtils.java | CalligraphyUtils.pullFontPathFromTextAppearance | static String pullFontPathFromTextAppearance(final Context context, AttributeSet attrs, int[] attributeId) {
if (attributeId == null || attrs == null) {
return null;
}
int textAppearanceId = -1;
final TypedArray typedArrayAttr = context.obtainStyledAttributes(attrs, ANDROID_ATTR_TEXT_APPEARANCE);
if (typedArrayAttr != null) {
try {
textAppearanceId = typedArrayAttr.getResourceId(0, -1);
} catch (Exception ignored) {
// Failed for some reason
return null;
} finally {
typedArrayAttr.recycle();
}
}
final TypedArray textAppearanceAttrs = context.obtainStyledAttributes(textAppearanceId, attributeId);
if (textAppearanceAttrs != null) {
try {
return textAppearanceAttrs.getString(0);
} catch (Exception ignore) {
// Failed for some reason.
return null;
} finally {
textAppearanceAttrs.recycle();
}
}
return null;
} | java | static String pullFontPathFromTextAppearance(final Context context, AttributeSet attrs, int[] attributeId) {
if (attributeId == null || attrs == null) {
return null;
}
int textAppearanceId = -1;
final TypedArray typedArrayAttr = context.obtainStyledAttributes(attrs, ANDROID_ATTR_TEXT_APPEARANCE);
if (typedArrayAttr != null) {
try {
textAppearanceId = typedArrayAttr.getResourceId(0, -1);
} catch (Exception ignored) {
// Failed for some reason
return null;
} finally {
typedArrayAttr.recycle();
}
}
final TypedArray textAppearanceAttrs = context.obtainStyledAttributes(textAppearanceId, attributeId);
if (textAppearanceAttrs != null) {
try {
return textAppearanceAttrs.getString(0);
} catch (Exception ignore) {
// Failed for some reason.
return null;
} finally {
textAppearanceAttrs.recycle();
}
}
return null;
} | [
"static",
"String",
"pullFontPathFromTextAppearance",
"(",
"final",
"Context",
"context",
",",
"AttributeSet",
"attrs",
",",
"int",
"[",
"]",
"attributeId",
")",
"{",
"if",
"(",
"attributeId",
"==",
"null",
"||",
"attrs",
"==",
"null",
")",
"{",
"return",
"n... | Tries to pull the Font Path from the Text Appearance.
@param context Activity Context
@param attrs View Attributes
@param attributeId if -1 returns null.
@return returns null if attribute is not defined or if no TextAppearance is found. | [
"Tries",
"to",
"pull",
"the",
"Font",
"Path",
"from",
"the",
"Text",
"Appearance",
"."
] | 085e441954d787bd4ef31f245afe5f2f2a311ea5 | https://github.com/chrisjenx/Calligraphy/blob/085e441954d787bd4ef31f245afe5f2f2a311ea5/calligraphy/src/main/java/uk/co/chrisjenx/calligraphy/CalligraphyUtils.java#L212-L242 | train |
chrisjenx/Calligraphy | calligraphy/src/main/java/uk/co/chrisjenx/calligraphy/CalligraphyUtils.java | CalligraphyUtils.canCheckForV7Toolbar | static boolean canCheckForV7Toolbar() {
if (sToolbarCheck == null) {
try {
Class.forName("android.support.v7.widget.Toolbar");
sToolbarCheck = Boolean.TRUE;
} catch (ClassNotFoundException e) {
sToolbarCheck = Boolean.FALSE;
}
}
return sToolbarCheck;
} | java | static boolean canCheckForV7Toolbar() {
if (sToolbarCheck == null) {
try {
Class.forName("android.support.v7.widget.Toolbar");
sToolbarCheck = Boolean.TRUE;
} catch (ClassNotFoundException e) {
sToolbarCheck = Boolean.FALSE;
}
}
return sToolbarCheck;
} | [
"static",
"boolean",
"canCheckForV7Toolbar",
"(",
")",
"{",
"if",
"(",
"sToolbarCheck",
"==",
"null",
")",
"{",
"try",
"{",
"Class",
".",
"forName",
"(",
"\"android.support.v7.widget.Toolbar\"",
")",
";",
"sToolbarCheck",
"=",
"Boolean",
".",
"TRUE",
";",
"}",... | See if the user has added appcompat-v7, this is done at runtime, so we only check once.
@return true if the v7.Toolbar is on the classpath | [
"See",
"if",
"the",
"user",
"has",
"added",
"appcompat",
"-",
"v7",
"this",
"is",
"done",
"at",
"runtime",
"so",
"we",
"only",
"check",
"once",
"."
] | 085e441954d787bd4ef31f245afe5f2f2a311ea5 | https://github.com/chrisjenx/Calligraphy/blob/085e441954d787bd4ef31f245afe5f2f2a311ea5/calligraphy/src/main/java/uk/co/chrisjenx/calligraphy/CalligraphyUtils.java#L323-L333 | train |
chrisjenx/Calligraphy | calligraphy/src/main/java/uk/co/chrisjenx/calligraphy/CalligraphyUtils.java | CalligraphyUtils.canAddV7AppCompatViews | static boolean canAddV7AppCompatViews() {
if (sAppCompatViewCheck == null) {
try {
Class.forName("android.support.v7.widget.AppCompatTextView");
sAppCompatViewCheck = Boolean.TRUE;
} catch (ClassNotFoundException e) {
sAppCompatViewCheck = Boolean.FALSE;
}
}
return sAppCompatViewCheck;
} | java | static boolean canAddV7AppCompatViews() {
if (sAppCompatViewCheck == null) {
try {
Class.forName("android.support.v7.widget.AppCompatTextView");
sAppCompatViewCheck = Boolean.TRUE;
} catch (ClassNotFoundException e) {
sAppCompatViewCheck = Boolean.FALSE;
}
}
return sAppCompatViewCheck;
} | [
"static",
"boolean",
"canAddV7AppCompatViews",
"(",
")",
"{",
"if",
"(",
"sAppCompatViewCheck",
"==",
"null",
")",
"{",
"try",
"{",
"Class",
".",
"forName",
"(",
"\"android.support.v7.widget.AppCompatTextView\"",
")",
";",
"sAppCompatViewCheck",
"=",
"Boolean",
".",... | See if the user has added appcompat-v7 with AppCompatViews
@return true if AppcompatTextView is on the classpath | [
"See",
"if",
"the",
"user",
"has",
"added",
"appcompat",
"-",
"v7",
"with",
"AppCompatViews"
] | 085e441954d787bd4ef31f245afe5f2f2a311ea5 | https://github.com/chrisjenx/Calligraphy/blob/085e441954d787bd4ef31f245afe5f2f2a311ea5/calligraphy/src/main/java/uk/co/chrisjenx/calligraphy/CalligraphyUtils.java#L340-L350 | train |
chrisjenx/Calligraphy | calligraphy/src/main/java/uk/co/chrisjenx/calligraphy/CalligraphyConfig.java | CalligraphyConfig.addAppCompatViews | private static void addAppCompatViews() {
DEFAULT_STYLES.put(android.support.v7.widget.AppCompatTextView.class, android.R.attr.textViewStyle);
DEFAULT_STYLES.put(android.support.v7.widget.AppCompatButton.class, android.R.attr.buttonStyle);
DEFAULT_STYLES.put(android.support.v7.widget.AppCompatEditText.class, android.R.attr.editTextStyle);
DEFAULT_STYLES.put(android.support.v7.widget.AppCompatAutoCompleteTextView.class, android.R.attr.autoCompleteTextViewStyle);
DEFAULT_STYLES.put(android.support.v7.widget.AppCompatMultiAutoCompleteTextView.class, android.R.attr.autoCompleteTextViewStyle);
DEFAULT_STYLES.put(android.support.v7.widget.AppCompatCheckBox.class, android.R.attr.checkboxStyle);
DEFAULT_STYLES.put(android.support.v7.widget.AppCompatRadioButton.class, android.R.attr.radioButtonStyle);
DEFAULT_STYLES.put(android.support.v7.widget.AppCompatCheckedTextView.class, android.R.attr.checkedTextViewStyle);
} | java | private static void addAppCompatViews() {
DEFAULT_STYLES.put(android.support.v7.widget.AppCompatTextView.class, android.R.attr.textViewStyle);
DEFAULT_STYLES.put(android.support.v7.widget.AppCompatButton.class, android.R.attr.buttonStyle);
DEFAULT_STYLES.put(android.support.v7.widget.AppCompatEditText.class, android.R.attr.editTextStyle);
DEFAULT_STYLES.put(android.support.v7.widget.AppCompatAutoCompleteTextView.class, android.R.attr.autoCompleteTextViewStyle);
DEFAULT_STYLES.put(android.support.v7.widget.AppCompatMultiAutoCompleteTextView.class, android.R.attr.autoCompleteTextViewStyle);
DEFAULT_STYLES.put(android.support.v7.widget.AppCompatCheckBox.class, android.R.attr.checkboxStyle);
DEFAULT_STYLES.put(android.support.v7.widget.AppCompatRadioButton.class, android.R.attr.radioButtonStyle);
DEFAULT_STYLES.put(android.support.v7.widget.AppCompatCheckedTextView.class, android.R.attr.checkedTextViewStyle);
} | [
"private",
"static",
"void",
"addAppCompatViews",
"(",
")",
"{",
"DEFAULT_STYLES",
".",
"put",
"(",
"android",
".",
"support",
".",
"v7",
".",
"widget",
".",
"AppCompatTextView",
".",
"class",
",",
"android",
".",
"R",
".",
"attr",
".",
"textViewStyle",
")... | AppCompat will inflate special versions of views for Material tinting etc,
this adds those classes to the style lookup map | [
"AppCompat",
"will",
"inflate",
"special",
"versions",
"of",
"views",
"for",
"Material",
"tinting",
"etc",
"this",
"adds",
"those",
"classes",
"to",
"the",
"style",
"lookup",
"map"
] | 085e441954d787bd4ef31f245afe5f2f2a311ea5 | https://github.com/chrisjenx/Calligraphy/blob/085e441954d787bd4ef31f245afe5f2f2a311ea5/calligraphy/src/main/java/uk/co/chrisjenx/calligraphy/CalligraphyConfig.java#L53-L62 | train |
chrisjenx/Calligraphy | calligraphy/src/main/java/uk/co/chrisjenx/calligraphy/CalligraphyContextWrapper.java | CalligraphyContextWrapper.get | static CalligraphyActivityFactory get(Activity activity) {
if (!(activity.getLayoutInflater() instanceof CalligraphyLayoutInflater)) {
throw new RuntimeException("This activity does not wrap the Base Context! See CalligraphyContextWrapper.wrap(Context)");
}
return (CalligraphyActivityFactory) activity.getLayoutInflater();
} | java | static CalligraphyActivityFactory get(Activity activity) {
if (!(activity.getLayoutInflater() instanceof CalligraphyLayoutInflater)) {
throw new RuntimeException("This activity does not wrap the Base Context! See CalligraphyContextWrapper.wrap(Context)");
}
return (CalligraphyActivityFactory) activity.getLayoutInflater();
} | [
"static",
"CalligraphyActivityFactory",
"get",
"(",
"Activity",
"activity",
")",
"{",
"if",
"(",
"!",
"(",
"activity",
".",
"getLayoutInflater",
"(",
")",
"instanceof",
"CalligraphyLayoutInflater",
")",
")",
"{",
"throw",
"new",
"RuntimeException",
"(",
"\"This ac... | Get the Calligraphy Activity Fragment Instance to allow callbacks for when views are created.
@param activity The activity the original that the ContextWrapper was attached too.
@return Interface allowing you to call onActivityViewCreated | [
"Get",
"the",
"Calligraphy",
"Activity",
"Fragment",
"Instance",
"to",
"allow",
"callbacks",
"for",
"when",
"views",
"are",
"created",
"."
] | 085e441954d787bd4ef31f245afe5f2f2a311ea5 | https://github.com/chrisjenx/Calligraphy/blob/085e441954d787bd4ef31f245afe5f2f2a311ea5/calligraphy/src/main/java/uk/co/chrisjenx/calligraphy/CalligraphyContextWrapper.java#L68-L73 | train |
chrisjenx/Calligraphy | calligraphy/src/main/java/uk/co/chrisjenx/calligraphy/CalligraphyFactory.java | CalligraphyFactory.getStyleForTextView | protected static int[] getStyleForTextView(TextView view) {
final int[] styleIds = new int[]{-1, -1};
// Try to find the specific actionbar styles
if (isActionBarTitle(view)) {
styleIds[0] = android.R.attr.actionBarStyle;
styleIds[1] = android.R.attr.titleTextStyle;
} else if (isActionBarSubTitle(view)) {
styleIds[0] = android.R.attr.actionBarStyle;
styleIds[1] = android.R.attr.subtitleTextStyle;
}
if (styleIds[0] == -1) {
// Use TextAppearance as default style
styleIds[0] = CalligraphyConfig.get().getClassStyles().containsKey(view.getClass())
? CalligraphyConfig.get().getClassStyles().get(view.getClass())
: android.R.attr.textAppearance;
}
return styleIds;
} | java | protected static int[] getStyleForTextView(TextView view) {
final int[] styleIds = new int[]{-1, -1};
// Try to find the specific actionbar styles
if (isActionBarTitle(view)) {
styleIds[0] = android.R.attr.actionBarStyle;
styleIds[1] = android.R.attr.titleTextStyle;
} else if (isActionBarSubTitle(view)) {
styleIds[0] = android.R.attr.actionBarStyle;
styleIds[1] = android.R.attr.subtitleTextStyle;
}
if (styleIds[0] == -1) {
// Use TextAppearance as default style
styleIds[0] = CalligraphyConfig.get().getClassStyles().containsKey(view.getClass())
? CalligraphyConfig.get().getClassStyles().get(view.getClass())
: android.R.attr.textAppearance;
}
return styleIds;
} | [
"protected",
"static",
"int",
"[",
"]",
"getStyleForTextView",
"(",
"TextView",
"view",
")",
"{",
"final",
"int",
"[",
"]",
"styleIds",
"=",
"new",
"int",
"[",
"]",
"{",
"-",
"1",
",",
"-",
"1",
"}",
";",
"// Try to find the specific actionbar styles",
"if... | Some styles are in sub styles, such as actionBarTextStyle etc..
@param view view to check.
@return 2 element array, default to -1 unless a style has been found. | [
"Some",
"styles",
"are",
"in",
"sub",
"styles",
"such",
"as",
"actionBarTextStyle",
"etc",
".."
] | 085e441954d787bd4ef31f245afe5f2f2a311ea5 | https://github.com/chrisjenx/Calligraphy/blob/085e441954d787bd4ef31f245afe5f2f2a311ea5/calligraphy/src/main/java/uk/co/chrisjenx/calligraphy/CalligraphyFactory.java#L25-L42 | train |
chrisjenx/Calligraphy | calligraphy/src/main/java/uk/co/chrisjenx/calligraphy/CalligraphyFactory.java | CalligraphyFactory.matchesResourceIdName | protected static boolean matchesResourceIdName(View view, String matches) {
if (view.getId() == View.NO_ID) return false;
final String resourceEntryName = view.getResources().getResourceEntryName(view.getId());
return resourceEntryName.equalsIgnoreCase(matches);
} | java | protected static boolean matchesResourceIdName(View view, String matches) {
if (view.getId() == View.NO_ID) return false;
final String resourceEntryName = view.getResources().getResourceEntryName(view.getId());
return resourceEntryName.equalsIgnoreCase(matches);
} | [
"protected",
"static",
"boolean",
"matchesResourceIdName",
"(",
"View",
"view",
",",
"String",
"matches",
")",
"{",
"if",
"(",
"view",
".",
"getId",
"(",
")",
"==",
"View",
".",
"NO_ID",
")",
"return",
"false",
";",
"final",
"String",
"resourceEntryName",
... | Use to match a view against a potential view id. Such as ActionBar title etc.
@param view not null view you want to see has resource matching name.
@param matches not null resource name to match against. Its not case sensitive.
@return true if matches false otherwise. | [
"Use",
"to",
"match",
"a",
"view",
"against",
"a",
"potential",
"view",
"id",
".",
"Such",
"as",
"ActionBar",
"title",
"etc",
"."
] | 085e441954d787bd4ef31f245afe5f2f2a311ea5 | https://github.com/chrisjenx/Calligraphy/blob/085e441954d787bd4ef31f245afe5f2f2a311ea5/calligraphy/src/main/java/uk/co/chrisjenx/calligraphy/CalligraphyFactory.java#L87-L91 | train |
chrisjenx/Calligraphy | calligraphy/src/main/java/uk/co/chrisjenx/calligraphy/CalligraphyFactory.java | CalligraphyFactory.onViewCreated | public View onViewCreated(View view, Context context, AttributeSet attrs) {
if (view != null && view.getTag(R.id.calligraphy_tag_id) != Boolean.TRUE) {
onViewCreatedInternal(view, context, attrs);
view.setTag(R.id.calligraphy_tag_id, Boolean.TRUE);
}
return view;
} | java | public View onViewCreated(View view, Context context, AttributeSet attrs) {
if (view != null && view.getTag(R.id.calligraphy_tag_id) != Boolean.TRUE) {
onViewCreatedInternal(view, context, attrs);
view.setTag(R.id.calligraphy_tag_id, Boolean.TRUE);
}
return view;
} | [
"public",
"View",
"onViewCreated",
"(",
"View",
"view",
",",
"Context",
"context",
",",
"AttributeSet",
"attrs",
")",
"{",
"if",
"(",
"view",
"!=",
"null",
"&&",
"view",
".",
"getTag",
"(",
"R",
".",
"id",
".",
"calligraphy_tag_id",
")",
"!=",
"Boolean",... | Handle the created view
@param view nullable.
@param context shouldn't be null.
@param attrs shouldn't be null.
@return null if null is passed in. | [
"Handle",
"the",
"created",
"view"
] | 085e441954d787bd4ef31f245afe5f2f2a311ea5 | https://github.com/chrisjenx/Calligraphy/blob/085e441954d787bd4ef31f245afe5f2f2a311ea5/calligraphy/src/main/java/uk/co/chrisjenx/calligraphy/CalligraphyFactory.java#L108-L114 | train |
chrisjenx/Calligraphy | calligraphy/src/main/java/uk/co/chrisjenx/calligraphy/CalligraphyFactory.java | CalligraphyFactory.resolveFontPath | private String resolveFontPath(Context context, AttributeSet attrs) {
// Try view xml attributes
String textViewFont = CalligraphyUtils.pullFontPathFromView(context, attrs, mAttributeId);
// Try view style attributes
if (TextUtils.isEmpty(textViewFont)) {
textViewFont = CalligraphyUtils.pullFontPathFromStyle(context, attrs, mAttributeId);
}
// Try View TextAppearance
if (TextUtils.isEmpty(textViewFont)) {
textViewFont = CalligraphyUtils.pullFontPathFromTextAppearance(context, attrs, mAttributeId);
}
return textViewFont;
} | java | private String resolveFontPath(Context context, AttributeSet attrs) {
// Try view xml attributes
String textViewFont = CalligraphyUtils.pullFontPathFromView(context, attrs, mAttributeId);
// Try view style attributes
if (TextUtils.isEmpty(textViewFont)) {
textViewFont = CalligraphyUtils.pullFontPathFromStyle(context, attrs, mAttributeId);
}
// Try View TextAppearance
if (TextUtils.isEmpty(textViewFont)) {
textViewFont = CalligraphyUtils.pullFontPathFromTextAppearance(context, attrs, mAttributeId);
}
return textViewFont;
} | [
"private",
"String",
"resolveFontPath",
"(",
"Context",
"context",
",",
"AttributeSet",
"attrs",
")",
"{",
"// Try view xml attributes",
"String",
"textViewFont",
"=",
"CalligraphyUtils",
".",
"pullFontPathFromView",
"(",
"context",
",",
"attrs",
",",
"mAttributeId",
... | Resolving font path from xml attrs, style attrs or text appearance | [
"Resolving",
"font",
"path",
"from",
"xml",
"attrs",
"style",
"attrs",
"or",
"text",
"appearance"
] | 085e441954d787bd4ef31f245afe5f2f2a311ea5 | https://github.com/chrisjenx/Calligraphy/blob/085e441954d787bd4ef31f245afe5f2f2a311ea5/calligraphy/src/main/java/uk/co/chrisjenx/calligraphy/CalligraphyFactory.java#L181-L196 | train |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.