code stringlengths 63 466k | code_sememe stringlengths 141 3.79M | token_type stringlengths 274 1.23M |
|---|---|---|
public Matrix4x3f translationRotateScaleMul(Vector3fc translation, Quaternionfc quat, Vector3fc scale, Matrix4x3f m) {
return translationRotateScaleMul(translation.x(), translation.y(), translation.z(), quat.x(), quat.y(), quat.z(), quat.w(), scale.x(), scale.y(), scale.z(), m);
} | class class_name[name] begin[{]
method[translationRotateScaleMul, return_type[type[Matrix4x3f]], modifier[public], parameter[translation, quat, scale, m]] begin[{]
return[call[.translationRotateScaleMul, parameter[call[translation.x, parameter[]], call[translation.y, parameter[]], call[translation.z, p... | Keyword[public] identifier[Matrix4x3f] identifier[translationRotateScaleMul] operator[SEP] identifier[Vector3fc] identifier[translation] , identifier[Quaternionfc] identifier[quat] , identifier[Vector3fc] identifier[scale] , identifier[Matrix4x3f] identifier[m] operator[SEP] {
Keyword[return] identifier[trans... |
public SoapClient setMethod(String methodName) {
return setMethod(methodName, ObjectUtil.defaultIfNull(this.namespaceURI, XMLConstants.NULL_NS_URI));
} | class class_name[name] begin[{]
method[setMethod, return_type[type[SoapClient]], modifier[public], parameter[methodName]] begin[{]
return[call[.setMethod, parameter[member[.methodName], call[ObjectUtil.defaultIfNull, parameter[THIS[member[None.namespaceURI]], member[XMLConstants.NULL_NS_URI]]]]]]
e... | Keyword[public] identifier[SoapClient] identifier[setMethod] operator[SEP] identifier[String] identifier[methodName] operator[SEP] {
Keyword[return] identifier[setMethod] operator[SEP] identifier[methodName] , identifier[ObjectUtil] operator[SEP] identifier[defaultIfNull] operator[SEP] Keyword[this] operator[SE... |
public @CheckForNull
SourceLineRange getFieldLine(String className, String fieldName) {
return fieldLineMap.get(new FieldDescriptor(className, fieldName));
} | class class_name[name] begin[{]
method[getFieldLine, return_type[type[SourceLineRange]], modifier[public], parameter[className, fieldName]] begin[{]
return[call[fieldLineMap.get, parameter[ClassCreator(arguments=[MemberReference(member=className, postfix_operators=[], prefix_operators=[], qualifier=, s... | Keyword[public] annotation[@] identifier[CheckForNull] identifier[SourceLineRange] identifier[getFieldLine] operator[SEP] identifier[String] identifier[className] , identifier[String] identifier[fieldName] operator[SEP] {
Keyword[return] identifier[fieldLineMap] operator[SEP] identifier[get] operator[SEP] Keywo... |
protected String getCellValue(final HtmlRenderingContext context, final int row, final int col,
final Object value) {
final String stringValue = LabelUtils.getValueLabel(value);
return context.escapeHtml(stringValue);
} | class class_name[name] begin[{]
method[getCellValue, return_type[type[String]], modifier[protected], parameter[context, row, col, value]] begin[{]
local_variable[type[String], stringValue]
return[call[context.escapeHtml, parameter[member[.stringValue]]]]
end[}]
END[}] | Keyword[protected] identifier[String] identifier[getCellValue] operator[SEP] Keyword[final] identifier[HtmlRenderingContext] identifier[context] , Keyword[final] Keyword[int] identifier[row] , Keyword[final] Keyword[int] identifier[col] , Keyword[final] identifier[Object] identifier[value] operator[SEP] {
Key... |
private static int merging3(int[] buffer, int x) {
int cnt1;
int cnt2;
int cnt = 0;
for (int i = x; i < x + 24; i += 3) {
cnt1 = buffer[i];
cnt2 = buffer[i + 1];
final int w = buffer[i + 2];
cnt1 = cnt1 - ((cnt1 >>> 1) & 0x55555555) + (w & 0x55555555);
cnt2 = cnt2 - ((cnt2 >>> 1) & 0x555... | class class_name[name] begin[{]
method[merging3, return_type[type[int]], modifier[private static], parameter[buffer, x]] begin[{]
local_variable[type[int], cnt1]
local_variable[type[int], cnt2]
local_variable[type[int], cnt]
ForStatement(body=BlockStatement(label=None, statement... | Keyword[private] Keyword[static] Keyword[int] identifier[merging3] operator[SEP] Keyword[int] operator[SEP] operator[SEP] identifier[buffer] , Keyword[int] identifier[x] operator[SEP] {
Keyword[int] identifier[cnt1] operator[SEP] Keyword[int] identifier[cnt2] operator[SEP] Keyword[int] identifier[cnt] operator[... |
public void setMin(final T pmin) {
if (pmin == null) {
getInputElement().removeAttribute("min");
} else {
getInputElement().setMin(this.numberRenderer.render(pmin));
}
} | class class_name[name] begin[{]
method[setMin, return_type[void], modifier[public], parameter[pmin]] begin[{]
if[binary_operation[member[.pmin], ==, literal[null]]] begin[{]
call[.getInputElement, parameter[]]
else begin[{]
call[.getInputE... | Keyword[public] Keyword[void] identifier[setMin] operator[SEP] Keyword[final] identifier[T] identifier[pmin] operator[SEP] {
Keyword[if] operator[SEP] identifier[pmin] operator[==] Other[null] operator[SEP] {
identifier[getInputElement] operator[SEP] operator[SEP] operator[SEP] identifier[removeAttrib... |
public static List<CommerceWishList> toModels(
CommerceWishListSoap[] soapModels) {
if (soapModels == null) {
return null;
}
List<CommerceWishList> models = new ArrayList<CommerceWishList>(soapModels.length);
for (CommerceWishListSoap soapModel : soapModels) {
models.add(toModel(soapModel));
}
re... | class class_name[name] begin[{]
method[toModels, return_type[type[List]], modifier[public static], parameter[soapModels]] begin[{]
if[binary_operation[member[.soapModels], ==, literal[null]]] begin[{]
return[literal[null]]
else begin[{]
None
end[}]
local_vari... | Keyword[public] Keyword[static] identifier[List] operator[<] identifier[CommerceWishList] operator[>] identifier[toModels] operator[SEP] identifier[CommerceWishListSoap] operator[SEP] operator[SEP] identifier[soapModels] operator[SEP] {
Keyword[if] operator[SEP] identifier[soapModels] operator[==] Other[null] op... |
private void printReport() {
System.out.println("Processed " + this.countItems + " items:");
System.out.println(" * Properties encountered: "
+ this.propertyRecords.size());
System.out.println(" * Property documents: " + this.countProperties);
System.out.println(" * Classes encountered: "
+ this.classRe... | class class_name[name] begin[{]
method[printReport, return_type[void], modifier[private], parameter[]] begin[{]
call[System.out.println, parameter[binary_operation[binary_operation[literal["Processed "], +, THIS[member[None.countItems]]], +, literal[" items:"]]]]
call[System.out... | Keyword[private] Keyword[void] identifier[printReport] operator[SEP] operator[SEP] {
identifier[System] operator[SEP] identifier[out] operator[SEP] identifier[println] operator[SEP] literal[String] operator[+] Keyword[this] operator[SEP] identifier[countItems] operator[+] literal[String] operator[SEP] operator[S... |
public static List<GrantedAuthority> createAllAuthorityList() {
return SpPermission.getAllAuthorities().stream().map(SimpleGrantedAuthority::new).collect(Collectors.toList());
} | class class_name[name] begin[{]
method[createAllAuthorityList, return_type[type[List]], modifier[public static], parameter[]] begin[{]
return[call[SpPermission.getAllAuthorities, parameter[]]]
end[}]
END[}] | Keyword[public] Keyword[static] identifier[List] operator[<] identifier[GrantedAuthority] operator[>] identifier[createAllAuthorityList] operator[SEP] operator[SEP] {
Keyword[return] identifier[SpPermission] operator[SEP] identifier[getAllAuthorities] operator[SEP] operator[SEP] operator[SEP] identifier[stream] ... |
public static boolean secKeyVerify(byte[] seckey) {
Preconditions.checkArgument(seckey.length == 32);
ByteBuffer byteBuff = nativeECDSABuffer.get();
if (byteBuff == null || byteBuff.capacity() < seckey.length) {
byteBuff = ByteBuffer.allocateDirect(seckey.length);
byteBu... | class class_name[name] begin[{]
method[secKeyVerify, return_type[type[boolean]], modifier[public static], parameter[seckey]] begin[{]
call[Preconditions.checkArgument, parameter[binary_operation[member[seckey.length], ==, literal[32]]]]
local_variable[type[ByteBuffer], byteBuff]
... | Keyword[public] Keyword[static] Keyword[boolean] identifier[secKeyVerify] operator[SEP] Keyword[byte] operator[SEP] operator[SEP] identifier[seckey] operator[SEP] {
identifier[Preconditions] operator[SEP] identifier[checkArgument] operator[SEP] identifier[seckey] operator[SEP] identifier[length] operator[==] Oth... |
@Override
public boolean isRRSTransactional() {
if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) {
Tr.debug(tc, hexId() + ":isRRSTransactional()=" + true);
}
return true;
} | class class_name[name] begin[{]
method[isRRSTransactional, return_type[type[boolean]], modifier[public], parameter[]] begin[{]
if[binary_operation[call[TraceComponent.isAnyTracingEnabled, parameter[]], &&, call[tc.isDebugEnabled, parameter[]]]] begin[{]
call[Tr.debug, pa... | annotation[@] identifier[Override] Keyword[public] Keyword[boolean] identifier[isRRSTransactional] operator[SEP] operator[SEP] {
Keyword[if] operator[SEP] identifier[TraceComponent] operator[SEP] identifier[isAnyTracingEnabled] operator[SEP] operator[SEP] operator[&&] identifier[tc] operator[SEP] identifier[isDe... |
public void recordValueWithCount(final long value, final long count) throws ArrayIndexOutOfBoundsException {
long criticalValueAtEnter = recordingPhaser.writerCriticalSectionEnter();
try {
activeHistogram.recordValueWithCount(value, count);
} finally {
recordingPhaser.wri... | class class_name[name] begin[{]
method[recordValueWithCount, return_type[void], modifier[public], parameter[value, count]] begin[{]
local_variable[type[long], criticalValueAtEnter]
TryStatement(block=[StatementExpression(expression=MethodInvocation(arguments=[MemberReference(member=value, postf... | Keyword[public] Keyword[void] identifier[recordValueWithCount] operator[SEP] Keyword[final] Keyword[long] identifier[value] , Keyword[final] Keyword[long] identifier[count] operator[SEP] Keyword[throws] identifier[ArrayIndexOutOfBoundsException] {
Keyword[long] identifier[criticalValueAtEnter] operator[=] ident... |
public String substituteLink(
CmsObject cms,
String link,
String siteRoot,
String targetDetailPage,
boolean forceSecure) {
if (targetDetailPage != null) {
return m_linkSubstitutionHandler.getLink(cms, link, siteRoot, targetDetailPage, forceSecure);
} ... | class class_name[name] begin[{]
method[substituteLink, return_type[type[String]], modifier[public], parameter[cms, link, siteRoot, targetDetailPage, forceSecure]] begin[{]
if[binary_operation[member[.targetDetailPage], !=, literal[null]]] begin[{]
return[call[m_linkSubstitutionHandl... | Keyword[public] identifier[String] identifier[substituteLink] operator[SEP] identifier[CmsObject] identifier[cms] , identifier[String] identifier[link] , identifier[String] identifier[siteRoot] , identifier[String] identifier[targetDetailPage] , Keyword[boolean] identifier[forceSecure] operator[SEP] {
Keywor... |
@Override
public void include(InputStream is, String source) throws IOException
{
include(is, Charset.defaultCharset(), source);
} | class class_name[name] begin[{]
method[include, return_type[void], modifier[public], parameter[is, source]] begin[{]
call[.include, parameter[member[.is], call[Charset.defaultCharset, parameter[]], member[.source]]]
end[}]
END[}] | annotation[@] identifier[Override] Keyword[public] Keyword[void] identifier[include] operator[SEP] identifier[InputStream] identifier[is] , identifier[String] identifier[source] operator[SEP] Keyword[throws] identifier[IOException] {
identifier[include] operator[SEP] identifier[is] , identifier[Charset] operat... |
public void marshall(CreateCertificateFromCsrRequest createCertificateFromCsrRequest, ProtocolMarshaller protocolMarshaller) {
if (createCertificateFromCsrRequest == null) {
throw new SdkClientException("Invalid argument passed to marshall(...)");
}
try {
protocolMarsha... | class class_name[name] begin[{]
method[marshall, return_type[void], modifier[public], parameter[createCertificateFromCsrRequest, protocolMarshaller]] begin[{]
if[binary_operation[member[.createCertificateFromCsrRequest], ==, literal[null]]] begin[{]
ThrowStatement(expression=ClassCr... | Keyword[public] Keyword[void] identifier[marshall] operator[SEP] identifier[CreateCertificateFromCsrRequest] identifier[createCertificateFromCsrRequest] , identifier[ProtocolMarshaller] identifier[protocolMarshaller] operator[SEP] {
Keyword[if] operator[SEP] identifier[createCertificateFromCsrRequest] operator[... |
public static boolean getBoolean(Cursor cursor, String columnName) {
return cursor != null && cursor.getInt(cursor.getColumnIndex(columnName)) == TRUE;
} | class class_name[name] begin[{]
method[getBoolean, return_type[type[boolean]], modifier[public static], parameter[cursor, columnName]] begin[{]
return[binary_operation[binary_operation[member[.cursor], !=, literal[null]], &&, binary_operation[call[cursor.getInt, parameter[call[cursor.getColumnIndex, pa... | Keyword[public] Keyword[static] Keyword[boolean] identifier[getBoolean] operator[SEP] identifier[Cursor] identifier[cursor] , identifier[String] identifier[columnName] operator[SEP] {
Keyword[return] identifier[cursor] operator[!=] Other[null] operator[&&] identifier[cursor] operator[SEP] identifier[getInt] ope... |
public StructureData getScalarStructure(int recnum, StructureMembers.Member m) {
if (m.getDataType() != DataType.STRUCTURE)
throw new IllegalArgumentException("Type is " + m.getDataType() + ", must be Structure");
ArrayStructure data = (ArrayStructure) m.getDataArray();
return data.getStructureD... | class class_name[name] begin[{]
method[getScalarStructure, return_type[type[StructureData]], modifier[public], parameter[recnum, m]] begin[{]
if[binary_operation[call[m.getDataType, parameter[]], !=, member[DataType.STRUCTURE]]] begin[{]
ThrowStatement(expression=ClassCreator(arguments=[BinaryO... | Keyword[public] identifier[StructureData] identifier[getScalarStructure] operator[SEP] Keyword[int] identifier[recnum] , identifier[StructureMembers] operator[SEP] identifier[Member] identifier[m] operator[SEP] {
Keyword[if] operator[SEP] identifier[m] operator[SEP] identifier[getDataType] operator[SEP] operato... |
@Override
public byte[] get(final ResultSet rs, final int index, final int dbSqlType) throws SQLException {
return rs.getBytes(index);
} | class class_name[name] begin[{]
method[get, return_type[type[byte]], modifier[public], parameter[rs, index, dbSqlType]] begin[{]
return[call[rs.getBytes, parameter[member[.index]]]]
end[}]
END[}] | annotation[@] identifier[Override] Keyword[public] Keyword[byte] operator[SEP] operator[SEP] identifier[get] operator[SEP] Keyword[final] identifier[ResultSet] identifier[rs] , Keyword[final] Keyword[int] identifier[index] , Keyword[final] Keyword[int] identifier[dbSqlType] operator[SEP] Keyword[throws] identifier[SQ... |
protected void notifyChangeListeners() {
ChangeEvent e = new ChangeEvent(this);
for (ChangeListener l : changeListeners) {
l.stateChanged(e);
}
} | class class_name[name] begin[{]
method[notifyChangeListeners, return_type[void], modifier[protected], parameter[]] begin[{]
local_variable[type[ChangeEvent], e]
ForStatement(body=BlockStatement(label=None, statements=[StatementExpression(expression=MethodInvocation(arguments=[MemberReference(me... | Keyword[protected] Keyword[void] identifier[notifyChangeListeners] operator[SEP] operator[SEP] {
identifier[ChangeEvent] identifier[e] operator[=] Keyword[new] identifier[ChangeEvent] operator[SEP] Keyword[this] operator[SEP] operator[SEP] Keyword[for] operator[SEP] identifier[ChangeListener] identifier[l] opera... |
@Override
public String getURLPrefix(Map<String, String> variants) {
if (null == this.urlPrefix)
throw new IllegalStateException("The bundleDataHashCode must be set before accessing the url prefix.");
if (variants != null && !variants.isEmpty()) {
String key = getAvailableVariant(variants);
if (StringUt... | class class_name[name] begin[{]
method[getURLPrefix, return_type[type[String]], modifier[public], parameter[variants]] begin[{]
if[binary_operation[literal[null], ==, THIS[member[None.urlPrefix]]]] begin[{]
ThrowStatement(expression=ClassCreator(arguments=[Literal(postfix_operators=[], prefix_o... | annotation[@] identifier[Override] Keyword[public] identifier[String] identifier[getURLPrefix] operator[SEP] identifier[Map] operator[<] identifier[String] , identifier[String] operator[>] identifier[variants] operator[SEP] {
Keyword[if] operator[SEP] Other[null] operator[==] Keyword[this] operator[SEP] identif... |
@SuppressWarnings("PMD.UseVarargs")
public boolean handles(Eligible event, Eligible[] channels) {
return filter.includes(event, channels);
} | class class_name[name] begin[{]
method[handles, return_type[type[boolean]], modifier[public], parameter[event, channels]] begin[{]
return[call[filter.includes, parameter[member[.event], member[.channels]]]]
end[}]
END[}] | annotation[@] identifier[SuppressWarnings] operator[SEP] literal[String] operator[SEP] Keyword[public] Keyword[boolean] identifier[handles] operator[SEP] identifier[Eligible] identifier[event] , identifier[Eligible] operator[SEP] operator[SEP] identifier[channels] operator[SEP] {
Keyword[return] identifier[filt... |
public final int strNCmp(byte[]bytes, int p, int end, byte[]ascii, int asciiP, int n) {
while (n-- > 0) {
if (p >= end) return ascii[asciiP];
int c = mbcToCode(bytes, p, end);
int x = ascii[asciiP] - c;
if (x != 0) return x;
asciiP++;
p +=... | class class_name[name] begin[{]
method[strNCmp, return_type[type[int]], modifier[final public], parameter[bytes, p, end, ascii, asciiP, n]] begin[{]
while[binary_operation[member[.n], >, literal[0]]] begin[{]
if[binary_operation[member[.p], >=, member[.end]]] begin[{]
re... | Keyword[public] Keyword[final] Keyword[int] identifier[strNCmp] operator[SEP] Keyword[byte] operator[SEP] operator[SEP] identifier[bytes] , Keyword[int] identifier[p] , Keyword[int] identifier[end] , Keyword[byte] operator[SEP] operator[SEP] identifier[ascii] , Keyword[int] identifier[asciiP] , Keyword[int] identi... |
private int readFrac(CharArr arr, int lim) throws IOException {
nstate = HAS_FRACTION; // deliberate set instead of '|'
while(--lim>=0) {
int ch = getChar();
if (ch>='0' && ch<='9') {
arr.write(ch);
} else if (ch=='e' || ch=='E') {
arr.write(ch);
return readExp(arr,lim... | class class_name[name] begin[{]
method[readFrac, return_type[type[int]], modifier[private], parameter[arr, lim]] begin[{]
assign[member[.nstate], member[.HAS_FRACTION]]
while[binary_operation[member[.lim], >=, literal[0]]] begin[{]
local_variable[type[int], ch]
... | Keyword[private] Keyword[int] identifier[readFrac] operator[SEP] identifier[CharArr] identifier[arr] , Keyword[int] identifier[lim] operator[SEP] Keyword[throws] identifier[IOException] {
identifier[nstate] operator[=] identifier[HAS_FRACTION] operator[SEP] Keyword[while] operator[SEP] operator[--] identifier[l... |
public void calc(CsvReader reader)
{
if(reader == null || reader.isEmpty())
return;
init();
reader.sortRowsForIndexByType(timeMsIndex, DataType.Long);
long tsMS, startTsMS = -1;
int size = reader.size();
for(int i=0; i < size;i++)
{
tsMS = reader.get(i,timeMsIndex, DataType.Long);
thi... | class class_name[name] begin[{]
method[calc, return_type[void], modifier[public], parameter[reader]] begin[{]
if[binary_operation[binary_operation[member[.reader], ==, literal[null]], ||, call[reader.isEmpty, parameter[]]]] begin[{]
return[None]
else begin[{]
None
end[}]
... | Keyword[public] Keyword[void] identifier[calc] operator[SEP] identifier[CsvReader] identifier[reader] operator[SEP] {
Keyword[if] operator[SEP] identifier[reader] operator[==] Other[null] operator[||] identifier[reader] operator[SEP] identifier[isEmpty] operator[SEP] operator[SEP] operator[SEP] Keyword[return] o... |
public boolean partSubstringMatches(Part part, String s) {
return part.length == s.length() && msg.regionMatches(part.index, s, 0, part.length);
} | class class_name[name] begin[{]
method[partSubstringMatches, return_type[type[boolean]], modifier[public], parameter[part, s]] begin[{]
return[binary_operation[binary_operation[member[part.length], ==, call[s.length, parameter[]]], &&, call[msg.regionMatches, parameter[member[part.index], member[.s], l... | Keyword[public] Keyword[boolean] identifier[partSubstringMatches] operator[SEP] identifier[Part] identifier[part] , identifier[String] identifier[s] operator[SEP] {
Keyword[return] identifier[part] operator[SEP] identifier[length] operator[==] identifier[s] operator[SEP] identifier[length] operator[SEP] operato... |
protected List<String> createOption(final String option, final List<String> values) {
if (values == null){
return new ArrayList<String>();
}
final List<String> list = new ArrayList<String>();
for (String value: values) {
list.add(option);
list.add(valu... | class class_name[name] begin[{]
method[createOption, return_type[type[List]], modifier[protected], parameter[option, values]] begin[{]
if[binary_operation[member[.values], ==, literal[null]]] begin[{]
return[ClassCreator(arguments=[], body=None, constructor_type_arguments=None, post... | Keyword[protected] identifier[List] operator[<] identifier[String] operator[>] identifier[createOption] operator[SEP] Keyword[final] identifier[String] identifier[option] , Keyword[final] identifier[List] operator[<] identifier[String] operator[>] identifier[values] operator[SEP] {
Keyword[if] operator[SEP] ide... |
@SuppressWarnings("unchecked")
private void parseOptionsFromFile(String optionFileName)
throws ParseException {
List<String> options = OptionsFileLoader.loadOptions(optionFileName);
options.addAll(commandLine.getArgList());
commandLine = cliParser.parse(cliOptions, options.toArray(new String[0]));
... | class class_name[name] begin[{]
method[parseOptionsFromFile, return_type[void], modifier[private], parameter[optionFileName]] begin[{]
local_variable[type[List], options]
call[options.addAll, parameter[call[commandLine.getArgList, parameter[]]]]
assign[member[.commandLin... | annotation[@] identifier[SuppressWarnings] operator[SEP] literal[String] operator[SEP] Keyword[private] Keyword[void] identifier[parseOptionsFromFile] operator[SEP] identifier[String] identifier[optionFileName] operator[SEP] Keyword[throws] identifier[ParseException] {
identifier[List] operator[<] identifier[Str... |
public static Set<String> retainMatchingKeys(Counter<String> counter, List<Pattern> matchPatterns) {
Set<String> removed = new HashSet<String>();
for (String key : counter.keySet()) {
boolean matched = false;
for (Pattern pattern : matchPatterns) {
if (pattern.matcher(key).matches()) {
... | class class_name[name] begin[{]
method[retainMatchingKeys, return_type[type[Set]], modifier[public static], parameter[counter, matchPatterns]] begin[{]
local_variable[type[Set], removed]
ForStatement(body=BlockStatement(label=None, statements=[LocalVariableDeclaration(annotations=[], declarator... | Keyword[public] Keyword[static] identifier[Set] operator[<] identifier[String] operator[>] identifier[retainMatchingKeys] operator[SEP] identifier[Counter] operator[<] identifier[String] operator[>] identifier[counter] , identifier[List] operator[<] identifier[Pattern] operator[>] identifier[matchPatterns] operator[SE... |
private static String toSource(
Node root,
Format outputFormat,
CompilerOptions options,
SourceMap sourceMap,
boolean tagAsTypeSummary,
boolean tagAsStrict,
boolean lineBreak,
CodeGeneratorFactory codeGeneratorFactory) {
checkState(options.sourceMapDetailLevel != null... | class class_name[name] begin[{]
method[toSource, return_type[type[String]], modifier[private static], parameter[root, outputFormat, options, sourceMap, tagAsTypeSummary, tagAsStrict, lineBreak, codeGeneratorFactory]] begin[{]
call[.checkState, parameter[binary_operation[member[options.sourceMap... | Keyword[private] Keyword[static] identifier[String] identifier[toSource] operator[SEP] identifier[Node] identifier[root] , identifier[Format] identifier[outputFormat] , identifier[CompilerOptions] identifier[options] , identifier[SourceMap] identifier[sourceMap] , Keyword[boolean] identifier[tagAsTypeSummary] , Ke... |
private VectorClock toVectorClock(List<Entry<String, Long>> replicaLogicalTimestamps) {
final VectorClock timestamps = new VectorClock();
for (Entry<String, Long> replicaTimestamp : replicaLogicalTimestamps) {
timestamps.setReplicaTimestamp(replicaTimestamp.getKey(), replicaTimestamp.getValu... | class class_name[name] begin[{]
method[toVectorClock, return_type[type[VectorClock]], modifier[private], parameter[replicaLogicalTimestamps]] begin[{]
local_variable[type[VectorClock], timestamps]
ForStatement(body=BlockStatement(label=None, statements=[StatementExpression(expression=MethodInvo... | Keyword[private] identifier[VectorClock] identifier[toVectorClock] operator[SEP] identifier[List] operator[<] identifier[Entry] operator[<] identifier[String] , identifier[Long] operator[>] operator[>] identifier[replicaLogicalTimestamps] operator[SEP] {
Keyword[final] identifier[VectorClock] identifier[timesta... |
public RowComparator comparator(Search search) {
if (search != null) {
if (search.usesSorting()) // Sort with search itself
{
return new RowComparatorSorting(rowMapper, search.getSort());
} else if (search.usesRelevance()) // Sort with row's score
... | class class_name[name] begin[{]
method[comparator, return_type[type[RowComparator]], modifier[public], parameter[search]] begin[{]
if[binary_operation[member[.search], !=, literal[null]]] begin[{]
if[call[search.usesSorting, parameter[]]] begin[{]
return[... | Keyword[public] identifier[RowComparator] identifier[comparator] operator[SEP] identifier[Search] identifier[search] operator[SEP] {
Keyword[if] operator[SEP] identifier[search] operator[!=] Other[null] operator[SEP] {
Keyword[if] operator[SEP] identifier[search] operator[SEP] identifier[usesSorting] ... |
public static void main(String[] args) throws Exception {
MesosExecutorDriver driver = new MesosExecutorDriver(new AlluxioWorkerExecutor());
System.exit(driver.run() == Protos.Status.DRIVER_STOPPED ? 0 : 1);
} | class class_name[name] begin[{]
method[main, return_type[void], modifier[public static], parameter[args]] begin[{]
local_variable[type[MesosExecutorDriver], driver]
call[System.exit, parameter[TernaryExpression(condition=BinaryOperation(operandl=MethodInvocation(arguments=[], member=run... | Keyword[public] Keyword[static] Keyword[void] identifier[main] operator[SEP] identifier[String] operator[SEP] operator[SEP] identifier[args] operator[SEP] Keyword[throws] identifier[Exception] {
identifier[MesosExecutorDriver] identifier[driver] operator[=] Keyword[new] identifier[MesosExecutorDriver] operator[S... |
private <R> R doWithWriteLock(Action<K, V, R> action) {
writeLock.lock();
try {
return action.doWith(commonCache);
} finally {
writeLock.unlock();
}
} | class class_name[name] begin[{]
method[doWithWriteLock, return_type[type[R]], modifier[private], parameter[action]] begin[{]
call[writeLock.lock, parameter[]]
TryStatement(block=[ReturnStatement(expression=MethodInvocation(arguments=[MemberReference(member=commonCache, postfix_operators... | Keyword[private] operator[<] identifier[R] operator[>] identifier[R] identifier[doWithWriteLock] operator[SEP] identifier[Action] operator[<] identifier[K] , identifier[V] , identifier[R] operator[>] identifier[action] operator[SEP] {
identifier[writeLock] operator[SEP] identifier[lock] operator[SEP] operator[... |
private String stringForBig(BigInteger big, int sigchars, boolean remainder)
{
char[] chars = new char[sigchars + (remainder ? 1 : 0)];
if (remainder)
// remaining bit is the most significant in the last char
chars[sigchars] |= 0x8000;
for (int i = 0; i < sigchars; i+... | class class_name[name] begin[{]
method[stringForBig, return_type[type[String]], modifier[private], parameter[big, sigchars, remainder]] begin[{]
local_variable[type[char], chars]
if[member[.remainder]] begin[{]
assign[member[.chars], literal[0x8000]]
else begin[{]
No... | Keyword[private] identifier[String] identifier[stringForBig] operator[SEP] identifier[BigInteger] identifier[big] , Keyword[int] identifier[sigchars] , Keyword[boolean] identifier[remainder] operator[SEP] {
Keyword[char] operator[SEP] operator[SEP] identifier[chars] operator[=] Keyword[new] Keyword[char] opera... |
protected AbcTune parseAbcHeader(AbcNode abcHeader) {
// X: number
AbcNode digits = abcHeader.getChild(FieldNumber+"/"+DIGITS);
if (digits != null)
m_tune.setReferenceNumber(Integer.parseInt(digits.getValue()));
// T: titles
parseTitleFields(abcHeader.getChild(TitleFields));
parseOtherFields(abcHe... | class class_name[name] begin[{]
method[parseAbcHeader, return_type[type[AbcTune]], modifier[protected], parameter[abcHeader]] begin[{]
local_variable[type[AbcNode], digits]
if[binary_operation[member[.digits], !=, literal[null]]] begin[{]
call[m_tune.setReferenceNumber, para... | Keyword[protected] identifier[AbcTune] identifier[parseAbcHeader] operator[SEP] identifier[AbcNode] identifier[abcHeader] operator[SEP] {
identifier[AbcNode] identifier[digits] operator[=] identifier[abcHeader] operator[SEP] identifier[getChild] operator[SEP] identifier[FieldNumber] operator[+] literal[String] o... |
public synchronized Vector getExtentClasses()
{
if (extentClassNames.size() != extentClasses.size())
{
extentClasses.clear();
for (Iterator iter = extentClassNames.iterator(); iter.hasNext();)
{
String classname = (String) iter.next();
... | class class_name[name] begin[{]
method[getExtentClasses, return_type[type[Vector]], modifier[synchronized public], parameter[]] begin[{]
if[binary_operation[call[extentClassNames.size, parameter[]], !=, call[extentClasses.size, parameter[]]]] begin[{]
call[extentClasses.... | Keyword[public] Keyword[synchronized] identifier[Vector] identifier[getExtentClasses] operator[SEP] operator[SEP] {
Keyword[if] operator[SEP] identifier[extentClassNames] operator[SEP] identifier[size] operator[SEP] operator[SEP] operator[!=] identifier[extentClasses] operator[SEP] identifier[size] operator[SEP]... |
private static void splitProjectionsForGroupBy(QueryPlanningInfo info, OCommandContext ctx) {
if (info.projection == null) {
return;
}
OProjection preAggregate = new OProjection(-1);
preAggregate.setItems(new ArrayList<>());
OProjection aggregate = new OProjection(-1);
aggregate.setItems(... | class class_name[name] begin[{]
method[splitProjectionsForGroupBy, return_type[void], modifier[private static], parameter[info, ctx]] begin[{]
if[binary_operation[member[info.projection], ==, literal[null]]] begin[{]
return[None]
else begin[{]
None
end[}]
loc... | Keyword[private] Keyword[static] Keyword[void] identifier[splitProjectionsForGroupBy] operator[SEP] identifier[QueryPlanningInfo] identifier[info] , identifier[OCommandContext] identifier[ctx] operator[SEP] {
Keyword[if] operator[SEP] identifier[info] operator[SEP] identifier[projection] operator[==] Other[null... |
protected void updateValueCell(BandData rootBand, BandData bandData, String templateCellValue, HSSFCell resultCell, HSSFPatriarch patriarch) {
String parameterName = templateCellValue;
parameterName = unwrapParameterName(parameterName);
String fullParameterName = bandData.getName() + "." + param... | class class_name[name] begin[{]
method[updateValueCell, return_type[void], modifier[protected], parameter[rootBand, bandData, templateCellValue, resultCell, patriarch]] begin[{]
local_variable[type[String], parameterName]
assign[member[.parameterName], call[.unwrapParameterName, paramet... | Keyword[protected] Keyword[void] identifier[updateValueCell] operator[SEP] identifier[BandData] identifier[rootBand] , identifier[BandData] identifier[bandData] , identifier[String] identifier[templateCellValue] , identifier[HSSFCell] identifier[resultCell] , identifier[HSSFPatriarch] identifier[patriarch] operator... |
public void marshall(DeleteJobRequest deleteJobRequest, ProtocolMarshaller protocolMarshaller) {
if (deleteJobRequest == null) {
throw new SdkClientException("Invalid argument passed to marshall(...)");
}
try {
protocolMarshaller.marshall(deleteJobRequest.getAppId(), AP... | class class_name[name] begin[{]
method[marshall, return_type[void], modifier[public], parameter[deleteJobRequest, protocolMarshaller]] begin[{]
if[binary_operation[member[.deleteJobRequest], ==, literal[null]]] begin[{]
ThrowStatement(expression=ClassCreator(arguments=[Literal(postf... | Keyword[public] Keyword[void] identifier[marshall] operator[SEP] identifier[DeleteJobRequest] identifier[deleteJobRequest] , identifier[ProtocolMarshaller] identifier[protocolMarshaller] operator[SEP] {
Keyword[if] operator[SEP] identifier[deleteJobRequest] operator[==] Other[null] operator[SEP] {
Ke... |
private void clinkstep8(DBIDRef id, DBIDArrayIter it, int n, WritableDBIDDataStore pi, WritableDoubleDataStore lambda, WritableDoubleDataStore m) {
DBIDVar p_i = DBIDUtil.newVar(), pp_i = DBIDUtil.newVar();
for(it.seek(0); it.getOffset() < n; it.advance()) {
p_i.from(pi, it); // p_i = pi[i]
pp_i.fro... | class class_name[name] begin[{]
method[clinkstep8, return_type[void], modifier[private], parameter[id, it, n, pi, lambda, m]] begin[{]
local_variable[type[DBIDVar], p_i]
ForStatement(body=BlockStatement(label=None, statements=[StatementExpression(expression=MethodInvocation(arguments=[MemberRef... | Keyword[private] Keyword[void] identifier[clinkstep8] operator[SEP] identifier[DBIDRef] identifier[id] , identifier[DBIDArrayIter] identifier[it] , Keyword[int] identifier[n] , identifier[WritableDBIDDataStore] identifier[pi] , identifier[WritableDoubleDataStore] identifier[lambda] , identifier[WritableDoubleDataS... |
public Observable<InputStream> getRemoteDesktopAsync(String poolId, String nodeId) {
return getRemoteDesktopWithServiceResponseAsync(poolId, nodeId).map(new Func1<ServiceResponseWithHeaders<InputStream, ComputeNodeGetRemoteDesktopHeaders>, InputStream>() {
@Override
public InputStream ca... | class class_name[name] begin[{]
method[getRemoteDesktopAsync, return_type[type[Observable]], modifier[public], parameter[poolId, nodeId]] begin[{]
return[call[.getRemoteDesktopWithServiceResponseAsync, parameter[member[.poolId], member[.nodeId]]]]
end[}]
END[}] | Keyword[public] identifier[Observable] operator[<] identifier[InputStream] operator[>] identifier[getRemoteDesktopAsync] operator[SEP] identifier[String] identifier[poolId] , identifier[String] identifier[nodeId] operator[SEP] {
Keyword[return] identifier[getRemoteDesktopWithServiceResponseAsync] operator[SEP] ... |
@NonNull
@Override
protected Single<RxBleDeviceServices> timeoutFallbackProcedure(
final BluetoothGatt bluetoothGatt,
final RxBleGattCallback rxBleGattCallback,
final Scheduler timeoutScheduler
) {
return Single.defer(new Callable<SingleSource<? extends RxBleDevic... | class class_name[name] begin[{]
method[timeoutFallbackProcedure, return_type[type[Single]], modifier[protected], parameter[bluetoothGatt, rxBleGattCallback, timeoutScheduler]] begin[{]
return[call[Single.defer, parameter[ClassCreator(arguments=[], body=[MethodDeclaration(annotations=[Annotation(element... | annotation[@] identifier[NonNull] annotation[@] identifier[Override] Keyword[protected] identifier[Single] operator[<] identifier[RxBleDeviceServices] operator[>] identifier[timeoutFallbackProcedure] operator[SEP] Keyword[final] identifier[BluetoothGatt] identifier[bluetoothGatt] , Keyword[final] identifier[RxBleGattC... |
@Override
public Object eGet(int featureID, boolean resolve, boolean coreType) {
switch (featureID) {
case AfplibPackage.PGP1__XOSET:
return getXOset();
case AfplibPackage.PGP1__YOSET:
return getYOset();
}
return super.eGet(featureID, resolve, coreType);
} | class class_name[name] begin[{]
method[eGet, return_type[type[Object]], modifier[public], parameter[featureID, resolve, coreType]] begin[{]
SwitchStatement(cases=[SwitchStatementCase(case=[MemberReference(member=PGP1__XOSET, postfix_operators=[], prefix_operators=[], qualifier=AfplibPackage, selectors=... | annotation[@] identifier[Override] Keyword[public] identifier[Object] identifier[eGet] operator[SEP] Keyword[int] identifier[featureID] , Keyword[boolean] identifier[resolve] , Keyword[boolean] identifier[coreType] operator[SEP] {
Keyword[switch] operator[SEP] identifier[featureID] operator[SEP] {
K... |
public static <T extends Collection<String>> T readLines(InputStream in, Charset charset, T collection) throws IORuntimeException {
return readLines(getReader(in, charset), collection);
} | class class_name[name] begin[{]
method[readLines, return_type[type[T]], modifier[public static], parameter[in, charset, collection]] begin[{]
return[call[.readLines, parameter[call[.getReader, parameter[member[.in], member[.charset]]], member[.collection]]]]
end[}]
END[}] | Keyword[public] Keyword[static] operator[<] identifier[T] Keyword[extends] identifier[Collection] operator[<] identifier[String] operator[>] operator[>] identifier[T] identifier[readLines] operator[SEP] identifier[InputStream] identifier[in] , identifier[Charset] identifier[charset] , identifier[T] identifier[collect... |
public EClass getIfcSweptAreaSolid() {
if (ifcSweptAreaSolidEClass == null) {
ifcSweptAreaSolidEClass = (EClass) EPackage.Registry.INSTANCE.getEPackage(Ifc2x3tc1Package.eNS_URI)
.getEClassifiers().get(585);
}
return ifcSweptAreaSolidEClass;
} | class class_name[name] begin[{]
method[getIfcSweptAreaSolid, return_type[type[EClass]], modifier[public], parameter[]] begin[{]
if[binary_operation[member[.ifcSweptAreaSolidEClass], ==, literal[null]]] begin[{]
assign[member[.ifcSweptAreaSolidEClass], Cast(expression=Met... | Keyword[public] identifier[EClass] identifier[getIfcSweptAreaSolid] operator[SEP] operator[SEP] {
Keyword[if] operator[SEP] identifier[ifcSweptAreaSolidEClass] operator[==] Other[null] operator[SEP] {
identifier[ifcSweptAreaSolidEClass] operator[=] operator[SEP] identifier[EClass] operator[SEP] identi... |
public static RemoteException RemoteException(String message,
Throwable cause) {
RemoteException remote = null;
// -----------------------------------------------------------------------
// If a cause was not specified, then this method has been... | class class_name[name] begin[{]
method[RemoteException, return_type[type[RemoteException]], modifier[public static], parameter[message, cause]] begin[{]
local_variable[type[RemoteException], remote]
if[binary_operation[member[.cause], ==, literal[null]]] begin[{]
... | Keyword[public] Keyword[static] identifier[RemoteException] identifier[RemoteException] operator[SEP] identifier[String] identifier[message] , identifier[Throwable] identifier[cause] operator[SEP] {
identifier[RemoteException] identifier[remote] operator[=] Other[null] operator[SEP] Keyword[if] operator[SEP] id... |
public static Number minus(Number left, Number right) {
return NumberMath.subtract(left, right);
} | class class_name[name] begin[{]
method[minus, return_type[type[Number]], modifier[public static], parameter[left, right]] begin[{]
return[call[NumberMath.subtract, parameter[member[.left], member[.right]]]]
end[}]
END[}] | Keyword[public] Keyword[static] identifier[Number] identifier[minus] operator[SEP] identifier[Number] identifier[left] , identifier[Number] identifier[right] operator[SEP] {
Keyword[return] identifier[NumberMath] operator[SEP] identifier[subtract] operator[SEP] identifier[left] , identifier[right] operator[SEP... |
public static String getObjectPropertyValue(final Object obj,
final String propertyName, final boolean ignoreNonExisting) {
try {
Method method = obj.getClass()
.getMethod("get"
+ Character.toUpperCase(propertyName.charAt(0))
+ propertyName.substring(1));
return (String) method.invo... | class class_name[name] begin[{]
method[getObjectPropertyValue, return_type[type[String]], modifier[public static], parameter[obj, propertyName, ignoreNonExisting]] begin[{]
TryStatement(block=[LocalVariableDeclaration(annotations=[], declarators=[VariableDeclarator(dimensions=[], initializer=MethodInvo... | Keyword[public] Keyword[static] identifier[String] identifier[getObjectPropertyValue] operator[SEP] Keyword[final] identifier[Object] identifier[obj] , Keyword[final] identifier[String] identifier[propertyName] , Keyword[final] Keyword[boolean] identifier[ignoreNonExisting] operator[SEP] {
Keyword[try] {
... |
@Override
public void redo() {
// Build a node according to the shape type
switch (this.shapeType) {
case Circle:
this.createdNode = CircleBuilder.create().fill(Color.BLUE).layoutX(60).layoutY(60).radius(30).build();
break;
case Square... | class class_name[name] begin[{]
method[redo, return_type[void], modifier[public], parameter[]] begin[{]
SwitchStatement(cases=[SwitchStatementCase(case=['Circle'], statements=[StatementExpression(expression=Assignment(expressionl=This(postfix_operators=[], prefix_operators=[], qualifier=None, selectors... | annotation[@] identifier[Override] Keyword[public] Keyword[void] identifier[redo] operator[SEP] operator[SEP] {
Keyword[switch] operator[SEP] Keyword[this] operator[SEP] identifier[shapeType] operator[SEP] {
Keyword[case] identifier[Circle] operator[:] Keyword[this] operator[SEP] identifier[createdNo... |
public static Pipe newPipe(byte[] data, int offset, int len)
{
final ByteArrayInput byteArrayInput = new ByteArrayInput(data, offset, len, false);
return new Pipe()
{
protected Input begin(Pipe.Schema<?> pipeSchema) throws IOException
{
return b... | class class_name[name] begin[{]
method[newPipe, return_type[type[Pipe]], modifier[public static], parameter[data, offset, len]] begin[{]
local_variable[type[ByteArrayInput], byteArrayInput]
return[ClassCreator(arguments=[], body=[MethodDeclaration(annotations=[], body=[ReturnStatement(expressio... | Keyword[public] Keyword[static] identifier[Pipe] identifier[newPipe] operator[SEP] Keyword[byte] operator[SEP] operator[SEP] identifier[data] , Keyword[int] identifier[offset] , Keyword[int] identifier[len] operator[SEP] {
Keyword[final] identifier[ByteArrayInput] identifier[byteArrayInput] operator[=] Keyword... |
public void updateStreamRecording(UpdateStreamRecordingRequest request) {
checkNotNull(request, "The parameter request should NOT be null.");
checkStringNotEmpty(request.getDomain(), "Domain should NOT be empty.");
checkStringNotEmpty(request.getApp(), "App should NOT be empty");
checkS... | class class_name[name] begin[{]
method[updateStreamRecording, return_type[void], modifier[public], parameter[request]] begin[{]
call[.checkNotNull, parameter[member[.request], literal["The parameter request should NOT be null."]]]
call[.checkStringNotEmpty, parameter[call[reques... | Keyword[public] Keyword[void] identifier[updateStreamRecording] operator[SEP] identifier[UpdateStreamRecordingRequest] identifier[request] operator[SEP] {
identifier[checkNotNull] operator[SEP] identifier[request] , literal[String] operator[SEP] operator[SEP] identifier[checkStringNotEmpty] operator[SEP] identi... |
public CDownloadRequest setRange( long offset, long length )
{
if ( length == 0 ) {
// Indicate we want to download 0 bytes ?! We ignore such specification
length = -1;
}
if ( offset < 0 && length < 0 ) {
byteRange = null;
} else {
byte... | class class_name[name] begin[{]
method[setRange, return_type[type[CDownloadRequest]], modifier[public], parameter[offset, length]] begin[{]
if[binary_operation[member[.length], ==, literal[0]]] begin[{]
assign[member[.length], literal[1]]
else begin[{]
None
... | Keyword[public] identifier[CDownloadRequest] identifier[setRange] operator[SEP] Keyword[long] identifier[offset] , Keyword[long] identifier[length] operator[SEP] {
Keyword[if] operator[SEP] identifier[length] operator[==] Other[0] operator[SEP] {
identifier[length] operator[=] operator[-] Other[1] op... |
private void logRunException(final Exception e) {
if (shutDown) {
getLogger().debug("Exception occurred during shutdown", e);
} else {
getLogger().warn("Problem handling memcached IO", e);
}
} | class class_name[name] begin[{]
method[logRunException, return_type[void], modifier[private], parameter[e]] begin[{]
if[member[.shutDown]] begin[{]
call[.getLogger, parameter[]]
else begin[{]
call[.getLogger, parameter[]]
end[}]
... | Keyword[private] Keyword[void] identifier[logRunException] operator[SEP] Keyword[final] identifier[Exception] identifier[e] operator[SEP] {
Keyword[if] operator[SEP] identifier[shutDown] operator[SEP] {
identifier[getLogger] operator[SEP] operator[SEP] operator[SEP] identifier[debug] operator[SEP] lit... |
public static FragmentHandler printStringMessage(final int streamId) {
return (buffer, offset, length, header) -> {
final byte[] data = new byte[length];
buffer.getBytes(offset, data);
System.out.println(String.format("Message to stream %d from session %d (%d@%d) <<%s>>", st... | class class_name[name] begin[{]
method[printStringMessage, return_type[type[FragmentHandler]], modifier[public static], parameter[streamId]] begin[{]
return[LambdaExpression(body=[LocalVariableDeclaration(annotations=[], declarators=[VariableDeclarator(dimensions=[], initializer=ArrayCreator(dimensions... | Keyword[public] Keyword[static] identifier[FragmentHandler] identifier[printStringMessage] operator[SEP] Keyword[final] Keyword[int] identifier[streamId] operator[SEP] {
Keyword[return] operator[SEP] identifier[buffer] , identifier[offset] , identifier[length] , identifier[header] operator[SEP] operator[->] ... |
public static String getTitleFromApptentivePush(Intent intent) {
if (!ApptentiveInternal.checkRegistered()) {
return null;
}
if (intent != null) {
return getTitleFromApptentivePush(intent.getExtras());
}
return null;
} | class class_name[name] begin[{]
method[getTitleFromApptentivePush, return_type[type[String]], modifier[public static], parameter[intent]] begin[{]
if[call[ApptentiveInternal.checkRegistered, parameter[]]] begin[{]
return[literal[null]]
else begin[{]
None
end[}]
... | Keyword[public] Keyword[static] identifier[String] identifier[getTitleFromApptentivePush] operator[SEP] identifier[Intent] identifier[intent] operator[SEP] {
Keyword[if] operator[SEP] operator[!] identifier[ApptentiveInternal] operator[SEP] identifier[checkRegistered] operator[SEP] operator[SEP] operator[SEP] {... |
public static JobInfo schedule(String name, Runnable task, long delay, long repeat) {
JobInfo info = new JobInfo(name,delay,repeat);
Future future = list.remove(info);
if (future != null && !future.isDone()) future.cancel(false);
ScheduledFuture<?> newFuture = Pools.SCHEDULED.scheduleWi... | class class_name[name] begin[{]
method[schedule, return_type[type[JobInfo]], modifier[public static], parameter[name, task, delay, repeat]] begin[{]
local_variable[type[JobInfo], info]
local_variable[type[Future], future]
if[binary_operation[binary_operation[member[.future], !=,... | Keyword[public] Keyword[static] identifier[JobInfo] identifier[schedule] operator[SEP] identifier[String] identifier[name] , identifier[Runnable] identifier[task] , Keyword[long] identifier[delay] , Keyword[long] identifier[repeat] operator[SEP] {
identifier[JobInfo] identifier[info] operator[=] Keyword[new] ... |
public static boolean isAnnotationPresent(Class<?> target, Class<? extends Annotation> annotation) {
Class<?> clazz = target;
if (clazz.isAnnotationPresent(annotation)) {
return true;
}
while((clazz = clazz.getSuperclass()) != null) {
if (clazz.isAnnotationPresent... | class class_name[name] begin[{]
method[isAnnotationPresent, return_type[type[boolean]], modifier[public static], parameter[target, annotation]] begin[{]
local_variable[type[Class], clazz]
if[call[clazz.isAnnotationPresent, parameter[member[.annotation]]]] begin[{]
return[lit... | Keyword[public] Keyword[static] Keyword[boolean] identifier[isAnnotationPresent] operator[SEP] identifier[Class] operator[<] operator[?] operator[>] identifier[target] , identifier[Class] operator[<] operator[?] Keyword[extends] identifier[Annotation] operator[>] identifier[annotation] operator[SEP] {
identifie... |
public void setAccessKeyMetadata(java.util.Collection<AccessKeyMetadata> accessKeyMetadata) {
if (accessKeyMetadata == null) {
this.accessKeyMetadata = null;
return;
}
this.accessKeyMetadata = new com.amazonaws.internal.SdkInternalList<AccessKeyMetadata>(accessKeyMetadat... | class class_name[name] begin[{]
method[setAccessKeyMetadata, return_type[void], modifier[public], parameter[accessKeyMetadata]] begin[{]
if[binary_operation[member[.accessKeyMetadata], ==, literal[null]]] begin[{]
assign[THIS[member[None.accessKeyMetadata]], literal[null... | Keyword[public] Keyword[void] identifier[setAccessKeyMetadata] operator[SEP] identifier[java] operator[SEP] identifier[util] operator[SEP] identifier[Collection] operator[<] identifier[AccessKeyMetadata] operator[>] identifier[accessKeyMetadata] operator[SEP] {
Keyword[if] operator[SEP] identifier[accessKeyMetad... |
public Observable<ServiceResponse<Void>> deleteWithServiceResponseAsync(String resourceGroupName, String resourceProviderNamespace, String parentResourcePath, String resourceType, String resourceName, String apiVersion) {
if (resourceGroupName == null) {
throw new IllegalArgumentException("Parameter... | class class_name[name] begin[{]
method[deleteWithServiceResponseAsync, return_type[type[Observable]], modifier[public], parameter[resourceGroupName, resourceProviderNamespace, parentResourcePath, resourceType, resourceName, apiVersion]] begin[{]
if[binary_operation[member[.resourceGroupName], =... | Keyword[public] identifier[Observable] operator[<] identifier[ServiceResponse] operator[<] identifier[Void] operator[>] operator[>] identifier[deleteWithServiceResponseAsync] operator[SEP] identifier[String] identifier[resourceGroupName] , identifier[String] identifier[resourceProviderNamespace] , identifier[String] ... |
protected boolean containsChangesWithExternalDependencies( AtomicReference<Set<NodeKey>> affectedNodeKeys )
throws RepositoryException {
Set<NodeKey> allChanges = sessionCache().getChangedNodeKeys();
Set<NodeKey> changesAtOrBelowThis = sessionCache().getChangedNodeKeysAtOrBelow(this.node());
... | class class_name[name] begin[{]
method[containsChangesWithExternalDependencies, return_type[type[boolean]], modifier[protected], parameter[affectedNodeKeys]] begin[{]
local_variable[type[Set], allChanges]
local_variable[type[Set], changesAtOrBelowThis]
call[.removeReferrerChange... | Keyword[protected] Keyword[boolean] identifier[containsChangesWithExternalDependencies] operator[SEP] identifier[AtomicReference] operator[<] identifier[Set] operator[<] identifier[NodeKey] operator[>] operator[>] identifier[affectedNodeKeys] operator[SEP] Keyword[throws] identifier[RepositoryException] {
identi... |
public static <M extends Message> ProtobufConverter<M> newInstance(Class<M> protoClass) {
return new ProtobufConverter<M>(new TypeRef<M>(protoClass){});
} | class class_name[name] begin[{]
method[newInstance, return_type[type[ProtobufConverter]], modifier[public static], parameter[protoClass]] begin[{]
return[ClassCreator(arguments=[ClassCreator(arguments=[MemberReference(member=protoClass, postfix_operators=[], prefix_operators=[], qualifier=, selectors=[... | Keyword[public] Keyword[static] operator[<] identifier[M] Keyword[extends] identifier[Message] operator[>] identifier[ProtobufConverter] operator[<] identifier[M] operator[>] identifier[newInstance] operator[SEP] identifier[Class] operator[<] identifier[M] operator[>] identifier[protoClass] operator[SEP] {
Keywo... |
public void setClusterVersions(java.util.Collection<ClusterVersion> clusterVersions) {
if (clusterVersions == null) {
this.clusterVersions = null;
return;
}
this.clusterVersions = new com.amazonaws.internal.SdkInternalList<ClusterVersion>(clusterVersions);
} | class class_name[name] begin[{]
method[setClusterVersions, return_type[void], modifier[public], parameter[clusterVersions]] begin[{]
if[binary_operation[member[.clusterVersions], ==, literal[null]]] begin[{]
assign[THIS[member[None.clusterVersions]], literal[null]]
... | Keyword[public] Keyword[void] identifier[setClusterVersions] operator[SEP] identifier[java] operator[SEP] identifier[util] operator[SEP] identifier[Collection] operator[<] identifier[ClusterVersion] operator[>] identifier[clusterVersions] operator[SEP] {
Keyword[if] operator[SEP] identifier[clusterVersions] oper... |
public void write( SystemInputDef systemInput)
{
JsonWriterFactory writerFactory = Json.createWriterFactory( MapBuilder.of( PRETTY_PRINTING, true).build());
JsonWriter jsonWriter = writerFactory.createWriter( getWriter());
jsonWriter.write( SystemInputJson.toJson( systemInput));
} | class class_name[name] begin[{]
method[write, return_type[void], modifier[public], parameter[systemInput]] begin[{]
local_variable[type[JsonWriterFactory], writerFactory]
local_variable[type[JsonWriter], jsonWriter]
call[jsonWriter.write, parameter[call[SystemInputJson.toJson, p... | Keyword[public] Keyword[void] identifier[write] operator[SEP] identifier[SystemInputDef] identifier[systemInput] operator[SEP] {
identifier[JsonWriterFactory] identifier[writerFactory] operator[=] identifier[Json] operator[SEP] identifier[createWriterFactory] operator[SEP] identifier[MapBuilder] operator[SEP] id... |
public void addToolbarButtons(ToolScreen toolScreen)
{
new SCannedBox(toolScreen.getNextLocation(ScreenConstants.NEXT_LOGICAL, ScreenConstants.SET_ANCHOR), toolScreen, null, ScreenConstants.DEFAULT_DISPLAY, null, MenuConstants.FORMDETAIL, MenuConstants.FORMDETAIL, MenuConstants.FORMDETAIL, null);
ne... | class class_name[name] begin[{]
method[addToolbarButtons, return_type[void], modifier[public], parameter[toolScreen]] begin[{]
ClassCreator(arguments=[MethodInvocation(arguments=[MemberReference(member=NEXT_LOGICAL, postfix_operators=[], prefix_operators=[], qualifier=ScreenConstants, selectors... | Keyword[public] Keyword[void] identifier[addToolbarButtons] operator[SEP] identifier[ToolScreen] identifier[toolScreen] operator[SEP] {
Keyword[new] identifier[SCannedBox] operator[SEP] identifier[toolScreen] operator[SEP] identifier[getNextLocation] operator[SEP] identifier[ScreenConstants] operator[SEP] identi... |
public static List<ApiImplementor> getAllImplementors() {
List<ApiImplementor> imps = new ArrayList<>();
ApiImplementor api;
imps.add(new AlertAPI(null));
api = new AntiCsrfAPI(null);
api.addApiOptions(new AntiCsrfParam());
imps.add(api);
imps.add(new PassiveScanAPI(null));
imps.add(new SearchAP... | class class_name[name] begin[{]
method[getAllImplementors, return_type[type[List]], modifier[public static], parameter[]] begin[{]
local_variable[type[List], imps]
local_variable[type[ApiImplementor], api]
call[imps.add, parameter[ClassCreator(arguments=[Literal(postfix_operator... | Keyword[public] Keyword[static] identifier[List] operator[<] identifier[ApiImplementor] operator[>] identifier[getAllImplementors] operator[SEP] operator[SEP] {
identifier[List] operator[<] identifier[ApiImplementor] operator[>] identifier[imps] operator[=] Keyword[new] identifier[ArrayList] operator[<] operator... |
String findKnownSymbol(int sid)
{
String name = null;
if (sid <= myMaxId)
{
int i, previousBaseSid = 0;
for (i = 1; i < myImports.length; i++)
{
int baseSid = myBaseSids[i];
if (sid <= baseSid)
{
... | class class_name[name] begin[{]
method[findKnownSymbol, return_type[type[String]], modifier[default], parameter[sid]] begin[{]
local_variable[type[String], name]
if[binary_operation[member[.sid], <=, member[.myMaxId]]] begin[{]
local_variable[type[int], i]
ForSta... | identifier[String] identifier[findKnownSymbol] operator[SEP] Keyword[int] identifier[sid] operator[SEP] {
identifier[String] identifier[name] operator[=] Other[null] operator[SEP] Keyword[if] operator[SEP] identifier[sid] operator[<=] identifier[myMaxId] operator[SEP] {
Keyword[int] identifier[i] , i... |
public Interval getIntervalOnlyIfExisting(String aName) {
Interval interval = intervalsByName.get(aName);
if (interval == null) {
throw new UnknownIntervalException(aName);
}
return interval;
} | class class_name[name] begin[{]
method[getIntervalOnlyIfExisting, return_type[type[Interval]], modifier[public], parameter[aName]] begin[{]
local_variable[type[Interval], interval]
if[binary_operation[member[.interval], ==, literal[null]]] begin[{]
ThrowStatement(expression=... | Keyword[public] identifier[Interval] identifier[getIntervalOnlyIfExisting] operator[SEP] identifier[String] identifier[aName] operator[SEP] {
identifier[Interval] identifier[interval] operator[=] identifier[intervalsByName] operator[SEP] identifier[get] operator[SEP] identifier[aName] operator[SEP] operator[SEP]... |
private static long lowMask(char first, char last) {
long m = 0;
int f = Math.max(Math.min(first, 63), 0);
int l = Math.max(Math.min(last, 63), 0);
for (int i = f; i <= l; i++)
m |= 1L << i;
return m;
} | class class_name[name] begin[{]
method[lowMask, return_type[type[long]], modifier[private static], parameter[first, last]] begin[{]
local_variable[type[long], m]
local_variable[type[int], f]
local_variable[type[int], l]
ForStatement(body=StatementExpression(expression=Assignment... | Keyword[private] Keyword[static] Keyword[long] identifier[lowMask] operator[SEP] Keyword[char] identifier[first] , Keyword[char] identifier[last] operator[SEP] {
Keyword[long] identifier[m] operator[=] Other[0] operator[SEP] Keyword[int] identifier[f] operator[=] identifier[Math] operator[SEP] identifier[max] o... |
private File calculateLogFile(long timestamp) {
if (ivSubDirectory == null)
getControllingProcessDirectory(timestamp, svPid) ;
return getLogFile(ivSubDirectory, timestamp);
} | class class_name[name] begin[{]
method[calculateLogFile, return_type[type[File]], modifier[private], parameter[timestamp]] begin[{]
if[binary_operation[member[.ivSubDirectory], ==, literal[null]]] begin[{]
call[.getControllingProcessDirectory, parameter[member[.timestamp], member[.s... | Keyword[private] identifier[File] identifier[calculateLogFile] operator[SEP] Keyword[long] identifier[timestamp] operator[SEP] {
Keyword[if] operator[SEP] identifier[ivSubDirectory] operator[==] Other[null] operator[SEP] identifier[getControllingProcessDirectory] operator[SEP] identifier[timestamp] , identifier... |
@Override
public DeleteApplicationInputProcessingConfigurationResult deleteApplicationInputProcessingConfiguration(
DeleteApplicationInputProcessingConfigurationRequest request) {
request = beforeClientExecution(request);
return executeDeleteApplicationInputProcessingConfiguration(reques... | class class_name[name] begin[{]
method[deleteApplicationInputProcessingConfiguration, return_type[type[DeleteApplicationInputProcessingConfigurationResult]], modifier[public], parameter[request]] begin[{]
assign[member[.request], call[.beforeClientExecution, parameter[member[.request]]]]
... | annotation[@] identifier[Override] Keyword[public] identifier[DeleteApplicationInputProcessingConfigurationResult] identifier[deleteApplicationInputProcessingConfiguration] operator[SEP] identifier[DeleteApplicationInputProcessingConfigurationRequest] identifier[request] operator[SEP] {
identifier[request] opera... |
public ProvisioningArtifactProperties withInfo(java.util.Map<String, String> info) {
setInfo(info);
return this;
} | class class_name[name] begin[{]
method[withInfo, return_type[type[ProvisioningArtifactProperties]], modifier[public], parameter[info]] begin[{]
call[.setInfo, parameter[member[.info]]]
return[THIS[]]
end[}]
END[}] | Keyword[public] identifier[ProvisioningArtifactProperties] identifier[withInfo] operator[SEP] identifier[java] operator[SEP] identifier[util] operator[SEP] identifier[Map] operator[<] identifier[String] , identifier[String] operator[>] identifier[info] operator[SEP] {
identifier[setInfo] operator[SEP] identifie... |
protected void parse(
StylesheetHandler handler, String uri, String localName, String rawName, Attributes attributes)
throws org.xml.sax.SAXException
{
TransformerFactoryImpl processor = handler.getStylesheetProcessor();
URIResolver uriresolver = processor.getURIResolver();
try
... | class class_name[name] begin[{]
method[parse, return_type[void], modifier[protected], parameter[handler, uri, localName, rawName, attributes]] begin[{]
local_variable[type[TransformerFactoryImpl], processor]
local_variable[type[URIResolver], uriresolver]
TryStatement(block=[LocalVariabl... | Keyword[protected] Keyword[void] identifier[parse] operator[SEP] identifier[StylesheetHandler] identifier[handler] , identifier[String] identifier[uri] , identifier[String] identifier[localName] , identifier[String] identifier[rawName] , identifier[Attributes] identifier[attributes] operator[SEP] Keyword[throws] id... |
public static LocalizationContext getLocalizationContext(PageContext pc, String basename) {
LocalizationContext locCtxt = null;
ResourceBundle bundle = null;
if ((basename == null) || basename.equals("")) {
return new LocalizationContext();
}
// Try prefer... | class class_name[name] begin[{]
method[getLocalizationContext, return_type[type[LocalizationContext]], modifier[public static], parameter[pc, basename]] begin[{]
local_variable[type[LocalizationContext], locCtxt]
local_variable[type[ResourceBundle], bundle]
if[binary_operation[b... | Keyword[public] Keyword[static] identifier[LocalizationContext] identifier[getLocalizationContext] operator[SEP] identifier[PageContext] identifier[pc] , identifier[String] identifier[basename] operator[SEP] {
identifier[LocalizationContext] identifier[locCtxt] operator[=] Other[null] operator[SEP] identifier[R... |
public E remove (int index) {
E e = data[index]; // make copy of element to remove so it can be returned
data[index] = data[--size]; // overwrite item to remove with last element
data[size] = null; // null last element, so gc can do its work
return e;
} | class class_name[name] begin[{]
method[remove, return_type[type[E]], modifier[public], parameter[index]] begin[{]
local_variable[type[E], e]
assign[member[.data], member[.data]]
assign[member[.data], literal[null]]
return[member[.e]]
end[}]
END[}] | Keyword[public] identifier[E] identifier[remove] operator[SEP] Keyword[int] identifier[index] operator[SEP] {
identifier[E] identifier[e] operator[=] identifier[data] operator[SEP] identifier[index] operator[SEP] operator[SEP] identifier[data] operator[SEP] identifier[index] operator[SEP] operator[=] identifier[... |
private void renderOption(final WMultiSelect listBox, final Object option,
final int optionIndex, final XmlStringBuilder html,
final List<?> selections, final boolean renderSelectionsOnly) {
boolean selected = selections.contains(option);
if (selected || !renderSelectionsOnly) {
// Get Code and Desc
St... | class class_name[name] begin[{]
method[renderOption, return_type[void], modifier[private], parameter[listBox, option, optionIndex, html, selections, renderSelectionsOnly]] begin[{]
local_variable[type[boolean], selected]
if[binary_operation[member[.selected], ||, member[.renderSelection... | Keyword[private] Keyword[void] identifier[renderOption] operator[SEP] Keyword[final] identifier[WMultiSelect] identifier[listBox] , Keyword[final] identifier[Object] identifier[option] , Keyword[final] Keyword[int] identifier[optionIndex] , Keyword[final] identifier[XmlStringBuilder] identifier[html] , Keyword[fina... |
private void checkM() throws DatatypeException, IOException {
if (context.length() == 0) {
appendToContext(current);
}
current = reader.read();
appendToContext(current);
skipSpaces();
checkArg('M', "x coordinate");
skipCommaSpaces();
checkArg(... | class class_name[name] begin[{]
method[checkM, return_type[void], modifier[private], parameter[]] begin[{]
if[binary_operation[call[context.length, parameter[]], ==, literal[0]]] begin[{]
call[.appendToContext, parameter[member[.current]]]
else begin[{]
None
... | Keyword[private] Keyword[void] identifier[checkM] operator[SEP] operator[SEP] Keyword[throws] identifier[DatatypeException] , identifier[IOException] {
Keyword[if] operator[SEP] identifier[context] operator[SEP] identifier[length] operator[SEP] operator[SEP] operator[==] Other[0] operator[SEP] {
iden... |
public static final void validateToken(AuthToken token) throws IllegalArgumentException {
if (token.getExpiresOn().before(new Date())) {
throw new IllegalArgumentException("Authentication token expired: " + token.getExpiresOn()); //$NON-NLS-1$
}
String validSig = generateSignature(to... | class class_name[name] begin[{]
method[validateToken, return_type[void], modifier[final public static], parameter[token]] begin[{]
if[call[token.getExpiresOn, parameter[]]] begin[{]
ThrowStatement(expression=ClassCreator(arguments=[BinaryOperation(operandl=Literal(postfix_operators=... | Keyword[public] Keyword[static] Keyword[final] Keyword[void] identifier[validateToken] operator[SEP] identifier[AuthToken] identifier[token] operator[SEP] Keyword[throws] identifier[IllegalArgumentException] {
Keyword[if] operator[SEP] identifier[token] operator[SEP] identifier[getExpiresOn] operator[SEP] operat... |
@Override
public void removeByUuid_C(String uuid, long companyId) {
for (CProduct cProduct : findByUuid_C(uuid, companyId,
QueryUtil.ALL_POS, QueryUtil.ALL_POS, null)) {
remove(cProduct);
}
} | class class_name[name] begin[{]
method[removeByUuid_C, return_type[void], modifier[public], parameter[uuid, companyId]] begin[{]
ForStatement(body=BlockStatement(label=None, statements=[StatementExpression(expression=MethodInvocation(arguments=[MemberReference(member=cProduct, postfix_operators=[], pre... | annotation[@] identifier[Override] Keyword[public] Keyword[void] identifier[removeByUuid_C] operator[SEP] identifier[String] identifier[uuid] , Keyword[long] identifier[companyId] operator[SEP] {
Keyword[for] operator[SEP] identifier[CProduct] identifier[cProduct] operator[:] identifier[findByUuid_C] operator[... |
@Override
public void setMaxY(double y) {
double o = this.minyProperty.doubleValue() ;
if (o>y) {
this.maxyProperty.set( o);
this.minyProperty.set(y);
}
else {
this.maxyProperty.set(y);
}
} | class class_name[name] begin[{]
method[setMaxY, return_type[void], modifier[public], parameter[y]] begin[{]
local_variable[type[double], o]
if[binary_operation[member[.o], >, member[.y]]] begin[{]
THIS[member[None.maxyProperty]call[None.set, parameter[member[.o]]... | annotation[@] identifier[Override] Keyword[public] Keyword[void] identifier[setMaxY] operator[SEP] Keyword[double] identifier[y] operator[SEP] {
Keyword[double] identifier[o] operator[=] Keyword[this] operator[SEP] identifier[minyProperty] operator[SEP] identifier[doubleValue] operator[SEP] operator[SEP] operato... |
protected Authentication attemptExitUser(HttpServletRequest request)
throws AuthenticationCredentialsNotFoundException {
// need to check to see if the current user has a SwitchUserGrantedAuthority
Authentication current = SecurityContextHolder.getContext().getAuthentication();
if (null == current) {
throw... | class class_name[name] begin[{]
method[attemptExitUser, return_type[type[Authentication]], modifier[protected], parameter[request]] begin[{]
local_variable[type[Authentication], current]
if[binary_operation[literal[null], ==, member[.current]]] begin[{]
ThrowStatement(expres... | Keyword[protected] identifier[Authentication] identifier[attemptExitUser] operator[SEP] identifier[HttpServletRequest] identifier[request] operator[SEP] Keyword[throws] identifier[AuthenticationCredentialsNotFoundException] {
identifier[Authentication] identifier[current] operator[=] identifier[SecurityContextHo... |
public Iterable<DContact> queryByCompanyName(Object parent, java.lang.String companyName) {
return queryByField(parent, DContactMapper.Field.COMPANYNAME.getFieldName(), companyName);
} | class class_name[name] begin[{]
method[queryByCompanyName, return_type[type[Iterable]], modifier[public], parameter[parent, companyName]] begin[{]
return[call[.queryByField, parameter[member[.parent], call[DContactMapper.Field.COMPANYNAME.getFieldName, parameter[]], member[.companyName]]]]
end[}]
E... | Keyword[public] identifier[Iterable] operator[<] identifier[DContact] operator[>] identifier[queryByCompanyName] operator[SEP] identifier[Object] identifier[parent] , identifier[java] operator[SEP] identifier[lang] operator[SEP] identifier[String] identifier[companyName] operator[SEP] {
Keyword[return] identifi... |
public static StringBuilder appendColumns(StringBuilder builder, List<String> columns, String selectQuery,
CQLTranslator translator)
{
if (columns != null)
{
for (String column : columns)
{
translator.appendColumnName(builder, column);
... | class class_name[name] begin[{]
method[appendColumns, return_type[type[StringBuilder]], modifier[public static], parameter[builder, columns, selectQuery, translator]] begin[{]
if[binary_operation[member[.columns], !=, literal[null]]] begin[{]
ForStatement(body=BlockStatement(label=N... | Keyword[public] Keyword[static] identifier[StringBuilder] identifier[appendColumns] operator[SEP] identifier[StringBuilder] identifier[builder] , identifier[List] operator[<] identifier[String] operator[>] identifier[columns] , identifier[String] identifier[selectQuery] , identifier[CQLTranslator] identifier[transla... |
public ApiResponse<TagsEnvelope> getTagsByCategoriesWithHttpInfo(String categories) throws ApiException {
com.squareup.okhttp.Call call = getTagsByCategoriesValidateBeforeCall(categories, null, null);
Type localVarReturnType = new TypeToken<TagsEnvelope>(){}.getType();
return apiClient.execute(c... | class class_name[name] begin[{]
method[getTagsByCategoriesWithHttpInfo, return_type[type[ApiResponse]], modifier[public], parameter[categories]] begin[{]
local_variable[type[com], call]
local_variable[type[Type], localVarReturnType]
return[call[apiClient.execute, parameter[member[.call]... | Keyword[public] identifier[ApiResponse] operator[<] identifier[TagsEnvelope] operator[>] identifier[getTagsByCategoriesWithHttpInfo] operator[SEP] identifier[String] identifier[categories] operator[SEP] Keyword[throws] identifier[ApiException] {
identifier[com] operator[SEP] identifier[squareup] operator[SEP] id... |
Document convertSelectorToDocument(Document selector) {
Document document = new Document();
for (String key : selector.keySet()) {
if (key.startsWith("$")) {
continue;
}
Object value = selector.get(key);
if (!Utils.containsQueryExpression(... | class class_name[name] begin[{]
method[convertSelectorToDocument, return_type[type[Document]], modifier[default], parameter[selector]] begin[{]
local_variable[type[Document], document]
ForStatement(body=BlockStatement(label=None, statements=[IfStatement(condition=MethodInvocation(arguments=[Lit... | identifier[Document] identifier[convertSelectorToDocument] operator[SEP] identifier[Document] identifier[selector] operator[SEP] {
identifier[Document] identifier[document] operator[=] Keyword[new] identifier[Document] operator[SEP] operator[SEP] operator[SEP] Keyword[for] operator[SEP] identifier[String] identi... |
@Override
public DBObject getUpdateClause() {
if (clear) {
// If new items were added, they'll be placed on the updateList. Either way We use $set to ensure old
// values are removed from the underlying store.
BasicDBList updateList = new BasicDBList();
updat... | class class_name[name] begin[{]
method[getUpdateClause, return_type[type[DBObject]], modifier[public], parameter[]] begin[{]
if[member[.clear]] begin[{]
local_variable[type[BasicDBList], updateList]
call[updateList.addAll, parameter[member[.updates]]]
... | annotation[@] identifier[Override] Keyword[public] identifier[DBObject] identifier[getUpdateClause] operator[SEP] operator[SEP] {
Keyword[if] operator[SEP] identifier[clear] operator[SEP] {
identifier[BasicDBList] identifier[updateList] operator[=] Keyword[new] identifier[BasicDBList] operator[SEP] op... |
public ContextAwareHistogram contextAwareHistogram(String name, long windowSize, TimeUnit unit) {
ContextAwareMetricFactoryArgs.SlidingTimeWindowArgs args = new ContextAwareMetricFactoryArgs.SlidingTimeWindowArgs(
this.innerMetricContext.getMetricContext().get(), name, windowSize, unit);
return this.inn... | class class_name[name] begin[{]
method[contextAwareHistogram, return_type[type[ContextAwareHistogram]], modifier[public], parameter[name, windowSize, unit]] begin[{]
local_variable[type[ContextAwareMetricFactoryArgs], args]
return[THIS[member[None.innerMetricContext]call[None.getOrCreate, param... | Keyword[public] identifier[ContextAwareHistogram] identifier[contextAwareHistogram] operator[SEP] identifier[String] identifier[name] , Keyword[long] identifier[windowSize] , identifier[TimeUnit] identifier[unit] operator[SEP] {
identifier[ContextAwareMetricFactoryArgs] operator[SEP] identifier[SlidingTimeWind... |
public Result generateCode() throws JsonIOException, IOException {
if (moduleManager == null) {
loadModulesFromKmdFiles();
}
if (internalTemplates != null) {
templatesDir = getInternalTemplatesDir(internalTemplates);
}
if (templatesDir != null) {
Path configFile = templatesDir.r... | class class_name[name] begin[{]
method[generateCode, return_type[type[Result]], modifier[public], parameter[]] begin[{]
if[binary_operation[member[.moduleManager], ==, literal[null]]] begin[{]
call[.loadModulesFromKmdFiles, parameter[]]
else begin[{]
None
... | Keyword[public] identifier[Result] identifier[generateCode] operator[SEP] operator[SEP] Keyword[throws] identifier[JsonIOException] , identifier[IOException] {
Keyword[if] operator[SEP] identifier[moduleManager] operator[==] Other[null] operator[SEP] {
identifier[loadModulesFromKmdFiles] operator[SEP... |
public Option[] getOptions() throws IllegalAccessException, InvocationTargetException, InstantiationException
{
if (m_options == null)
{
List<Option> options = new ArrayList<Option>();
Configuration config = getMethod().getAnnotation(Configuration.class);
for (Cl... | class class_name[name] begin[{]
method[getOptions, return_type[type[Option]], modifier[public], parameter[]] begin[{]
if[binary_operation[member[.m_options], ==, literal[null]]] begin[{]
local_variable[type[List], options]
local_variable[type[Configuration], config]
... | Keyword[public] identifier[Option] operator[SEP] operator[SEP] identifier[getOptions] operator[SEP] operator[SEP] Keyword[throws] identifier[IllegalAccessException] , identifier[InvocationTargetException] , identifier[InstantiationException] {
Keyword[if] operator[SEP] identifier[m_options] operator[==] Other[... |
@Override
public CompilerInput getInput(InputId id) {
// TODO(bradfordcsmith): Allowing null id is less ideal. Add checkNotNull(id) here and fix
// call sites that break.
if (id == null) {
return null;
}
return inputsById.get(id);
} | class class_name[name] begin[{]
method[getInput, return_type[type[CompilerInput]], modifier[public], parameter[id]] begin[{]
if[binary_operation[member[.id], ==, literal[null]]] begin[{]
return[literal[null]]
else begin[{]
None
end[}]
return[call[inputsById.g... | annotation[@] identifier[Override] Keyword[public] identifier[CompilerInput] identifier[getInput] operator[SEP] identifier[InputId] identifier[id] operator[SEP] {
Keyword[if] operator[SEP] identifier[id] operator[==] Other[null] operator[SEP] {
Keyword[return] Other[null] operator[SEP]
}
... |
public void setDistanceInstancePool(DistanceInstanceIterator it)
{
// need to save out the i-th field, if it's been prepared.
List buffer = asMultiDistanceInstanceList(it);
if (buffer.size()==0) return;
MyMultiDistanceInstance instance = (MyMultiDistanceInstance)buffer.get(0);
MultiStringWrapper prototype =... | class class_name[name] begin[{]
method[setDistanceInstancePool, return_type[void], modifier[public], parameter[it]] begin[{]
local_variable[type[List], buffer]
if[binary_operation[call[buffer.size, parameter[]], ==, literal[0]]] begin[{]
return[None]
else begin[{]
None
e... | Keyword[public] Keyword[void] identifier[setDistanceInstancePool] operator[SEP] identifier[DistanceInstanceIterator] identifier[it] operator[SEP] {
identifier[List] identifier[buffer] operator[=] identifier[asMultiDistanceInstanceList] operator[SEP] identifier[it] operator[SEP] operator[SEP] Keyword[if] operator... |
public void notifyAboutViewChanges() {
final T view = this.view;
if (view != null && view instanceof ImagesLoadListenerProvider) {
this.listener = ((ImagesLoadListenerProvider)view).getImagesLoadListener();
}
} | class class_name[name] begin[{]
method[notifyAboutViewChanges, return_type[void], modifier[public], parameter[]] begin[{]
local_variable[type[T], view]
if[binary_operation[binary_operation[member[.view], !=, literal[null]], &&, binary_operation[member[.view], instanceof, type[ImagesLoad... | Keyword[public] Keyword[void] identifier[notifyAboutViewChanges] operator[SEP] operator[SEP] {
Keyword[final] identifier[T] identifier[view] operator[=] Keyword[this] operator[SEP] identifier[view] operator[SEP] Keyword[if] operator[SEP] identifier[view] operator[!=] Other[null] operator[&&] identifier[view] Key... |
public static boolean hasNonEmptyAttribute(HtmlElement element, String attributeName) {
return hasAttribute(element, attributeName) && !element.getAttribute(attributeName).isEmpty();
} | class class_name[name] begin[{]
method[hasNonEmptyAttribute, return_type[type[boolean]], modifier[public static], parameter[element, attributeName]] begin[{]
return[binary_operation[call[.hasAttribute, parameter[member[.element], member[.attributeName]]], &&, call[element.getAttribute, parameter[member... | Keyword[public] Keyword[static] Keyword[boolean] identifier[hasNonEmptyAttribute] operator[SEP] identifier[HtmlElement] identifier[element] , identifier[String] identifier[attributeName] operator[SEP] {
Keyword[return] identifier[hasAttribute] operator[SEP] identifier[element] , identifier[attributeName] opera... |
public ListStreamsResult withStreamInfoList(StreamInfo... streamInfoList) {
if (this.streamInfoList == null) {
setStreamInfoList(new java.util.ArrayList<StreamInfo>(streamInfoList.length));
}
for (StreamInfo ele : streamInfoList) {
this.streamInfoList.add(ele);
}
... | class class_name[name] begin[{]
method[withStreamInfoList, return_type[type[ListStreamsResult]], modifier[public], parameter[streamInfoList]] begin[{]
if[binary_operation[THIS[member[None.streamInfoList]], ==, literal[null]]] begin[{]
call[.setStreamInfoList, parameter[C... | Keyword[public] identifier[ListStreamsResult] identifier[withStreamInfoList] operator[SEP] identifier[StreamInfo] operator[...] identifier[streamInfoList] operator[SEP] {
Keyword[if] operator[SEP] Keyword[this] operator[SEP] identifier[streamInfoList] operator[==] Other[null] operator[SEP] {
identifie... |
public static ProjectModel getProjectModel() {
synchronized (Modules.class) {
if (Modules.projectModel == null) {
ClassLoader classLoader = Modules.class.getClassLoader();
Config config = new Config(new Properties());
try (InputStream in = classLoader
.getResourceAsStream("jabsaw.properties")) {
... | class class_name[name] begin[{]
method[getProjectModel, return_type[type[ProjectModel]], modifier[public static], parameter[]] begin[{]
SYNCHRONIZED[ClassReference(postfix_operators=[], prefix_operators=[], qualifier=, selectors=[], type=ReferenceType(arguments=None, dimensions=None, name=Modul... | Keyword[public] Keyword[static] identifier[ProjectModel] identifier[getProjectModel] operator[SEP] operator[SEP] {
Keyword[synchronized] operator[SEP] identifier[Modules] operator[SEP] Keyword[class] operator[SEP] {
Keyword[if] operator[SEP] identifier[Modules] operator[SEP] identifier[projectModel] o... |
public int createAndSendURLMessage(String strMessageTransport, MessageDetailTarget recMessageDetailTarget, String strURL, Map<String,Object> properties)
{
String strBaseURL = strURL;
URL url = this.getTask().getApplication().getResourceURL(strURL, null);
strURL = url.toString();
if (... | class class_name[name] begin[{]
method[createAndSendURLMessage, return_type[type[int]], modifier[public], parameter[strMessageTransport, recMessageDetailTarget, strURL, properties]] begin[{]
local_variable[type[String], strBaseURL]
local_variable[type[URL], url]
assign[member[.s... | Keyword[public] Keyword[int] identifier[createAndSendURLMessage] operator[SEP] identifier[String] identifier[strMessageTransport] , identifier[MessageDetailTarget] identifier[recMessageDetailTarget] , identifier[String] identifier[strURL] , identifier[Map] operator[<] identifier[String] , identifier[Object] operato... |
public void marshall(DescribePermissionsRequest describePermissionsRequest, ProtocolMarshaller protocolMarshaller) {
if (describePermissionsRequest == null) {
throw new SdkClientException("Invalid argument passed to marshall(...)");
}
try {
protocolMarshaller.marshall(d... | class class_name[name] begin[{]
method[marshall, return_type[void], modifier[public], parameter[describePermissionsRequest, protocolMarshaller]] begin[{]
if[binary_operation[member[.describePermissionsRequest], ==, literal[null]]] begin[{]
ThrowStatement(expression=ClassCreator(argu... | Keyword[public] Keyword[void] identifier[marshall] operator[SEP] identifier[DescribePermissionsRequest] identifier[describePermissionsRequest] , identifier[ProtocolMarshaller] identifier[protocolMarshaller] operator[SEP] {
Keyword[if] operator[SEP] identifier[describePermissionsRequest] operator[==] Other[null]... |
public boolean load(String path)
{
String binPath = path + Predefine.BIN_EXT;
if (load(ByteArrayStream.createByteArrayStream(binPath))) return true;
if (!loadTxt(path)) return false;
try
{
logger.info("正在缓存" + binPath);
DataOutputStream out = new DataO... | class class_name[name] begin[{]
method[load, return_type[type[boolean]], modifier[public], parameter[path]] begin[{]
local_variable[type[String], binPath]
if[call[.load, parameter[call[ByteArrayStream.createByteArrayStream, parameter[member[.binPath]]]]]] begin[{]
return[literal[true]]
... | Keyword[public] Keyword[boolean] identifier[load] operator[SEP] identifier[String] identifier[path] operator[SEP] {
identifier[String] identifier[binPath] operator[=] identifier[path] operator[+] identifier[Predefine] operator[SEP] identifier[BIN_EXT] operator[SEP] Keyword[if] operator[SEP] identifier[load] oper... |
public SslPolicy withSslProtocols(String... sslProtocols) {
if (this.sslProtocols == null) {
setSslProtocols(new java.util.ArrayList<String>(sslProtocols.length));
}
for (String ele : sslProtocols) {
this.sslProtocols.add(ele);
}
return this;
} | class class_name[name] begin[{]
method[withSslProtocols, return_type[type[SslPolicy]], modifier[public], parameter[sslProtocols]] begin[{]
if[binary_operation[THIS[member[None.sslProtocols]], ==, literal[null]]] begin[{]
call[.setSslProtocols, parameter[ClassCreator(argu... | Keyword[public] identifier[SslPolicy] identifier[withSslProtocols] operator[SEP] identifier[String] operator[...] identifier[sslProtocols] operator[SEP] {
Keyword[if] operator[SEP] Keyword[this] operator[SEP] identifier[sslProtocols] operator[==] Other[null] operator[SEP] {
identifier[setSslProtocols]... |
@GwtIncompatible("ObjectInputStream")
public static CompilerOptions deserialize(InputStream objectInputStream)
throws IOException, ClassNotFoundException {
return (CompilerOptions) new java.io.ObjectInputStream(objectInputStream).readObject();
} | class class_name[name] begin[{]
method[deserialize, return_type[type[CompilerOptions]], modifier[public static], parameter[objectInputStream]] begin[{]
return[Cast(expression=ClassCreator(arguments=[MemberReference(member=objectInputStream, postfix_operators=[], prefix_operators=[], qualifier=, selecto... | annotation[@] identifier[GwtIncompatible] operator[SEP] literal[String] operator[SEP] Keyword[public] Keyword[static] identifier[CompilerOptions] identifier[deserialize] operator[SEP] identifier[InputStream] identifier[objectInputStream] operator[SEP] Keyword[throws] identifier[IOException] , identifier[ClassNotFoundE... |
public static byte[] rjust(byte[] bytes, int width) {
if (bytes.length >= width) {
return Arrays.copyOfRange(bytes, bytes.length - width, bytes.length);
} else {
byte[] rjustied = new byte[width];
System.arraycopy(bytes, 0, rjustied, width - bytes.length, bytes.length);
return rjustied;
... | class class_name[name] begin[{]
method[rjust, return_type[type[byte]], modifier[public static], parameter[bytes, width]] begin[{]
if[binary_operation[member[bytes.length], >=, member[.width]]] begin[{]
return[call[Arrays.copyOfRange, parameter[member[.bytes], binary_operation[member... | Keyword[public] Keyword[static] Keyword[byte] operator[SEP] operator[SEP] identifier[rjust] operator[SEP] Keyword[byte] operator[SEP] operator[SEP] identifier[bytes] , Keyword[int] identifier[width] operator[SEP] {
Keyword[if] operator[SEP] identifier[bytes] operator[SEP] identifier[length] operator[>=] identif... |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.