code stringlengths 63 466k | code_sememe stringlengths 141 3.79M | token_type stringlengths 274 1.23M |
|---|---|---|
public static Object getObjectIndex(Object obj, double dblIndex,
Context cx, Scriptable scope)
{
Scriptable sobj = toObjectOrNull(cx, obj, scope);
if (sobj == null) {
throw undefReadError(obj, toString(dblIndex));
}
int index = (in... | class class_name[name] begin[{]
method[getObjectIndex, return_type[type[Object]], modifier[public static], parameter[obj, dblIndex, cx, scope]] begin[{]
local_variable[type[Scriptable], sobj]
if[binary_operation[member[.sobj], ==, literal[null]]] begin[{]
ThrowStatement(expr... | Keyword[public] Keyword[static] identifier[Object] identifier[getObjectIndex] operator[SEP] identifier[Object] identifier[obj] , Keyword[double] identifier[dblIndex] , identifier[Context] identifier[cx] , identifier[Scriptable] identifier[scope] operator[SEP] {
identifier[Scriptable] identifier[sobj] operator... |
static void addExtern(AbstractCompiler compiler) {
Node name = IR.name(PROTECTOR_FN);
name.putBooleanProp(Node.IS_CONSTANT_NAME, true);
Node var = IR.var(name);
JSDocInfoBuilder builder = new JSDocInfoBuilder(false);
var.setJSDocInfo(builder.build());
CompilerInput input = compiler.getSynthesize... | class class_name[name] begin[{]
method[addExtern, return_type[void], modifier[static], parameter[compiler]] begin[{]
local_variable[type[Node], name]
call[name.putBooleanProp, parameter[member[Node.IS_CONSTANT_NAME], literal[true]]]
local_variable[type[Node], var]
local_... | Keyword[static] Keyword[void] identifier[addExtern] operator[SEP] identifier[AbstractCompiler] identifier[compiler] operator[SEP] {
identifier[Node] identifier[name] operator[=] identifier[IR] operator[SEP] identifier[name] operator[SEP] identifier[PROTECTOR_FN] operator[SEP] operator[SEP] identifier[name] opera... |
@VisibleForTesting
public static TagValue[] createTagValues(int size, String name) {
TagValue[] values = new TagValue[size];
for (int i = 0; i < size; i++) {
values[i] = TagValue.create(name + i);
}
return values;
} | class class_name[name] begin[{]
method[createTagValues, return_type[type[TagValue]], modifier[public static], parameter[size, name]] begin[{]
local_variable[type[TagValue], values]
ForStatement(body=BlockStatement(label=None, statements=[StatementExpression(expression=Assignment(expressionl=Mem... | annotation[@] identifier[VisibleForTesting] Keyword[public] Keyword[static] identifier[TagValue] operator[SEP] operator[SEP] identifier[createTagValues] operator[SEP] Keyword[int] identifier[size] , identifier[String] identifier[name] operator[SEP] {
identifier[TagValue] operator[SEP] operator[SEP] identifier[v... |
protected Apikey createFromMap(@Nullable String user, long start, long duration, @Nullable List<String> roles, Map<String, Object> nameAndValMap) {
return createFromMap(user, start, duration, toArr(roles), nameAndValMap);
} | class class_name[name] begin[{]
method[createFromMap, return_type[type[Apikey]], modifier[protected], parameter[user, start, duration, roles, nameAndValMap]] begin[{]
return[call[.createFromMap, parameter[member[.user], member[.start], member[.duration], call[.toArr, parameter[member[.roles]]], member[... | Keyword[protected] identifier[Apikey] identifier[createFromMap] operator[SEP] annotation[@] identifier[Nullable] identifier[String] identifier[user] , Keyword[long] identifier[start] , Keyword[long] identifier[duration] , annotation[@] identifier[Nullable] identifier[List] operator[<] identifier[String] operator[>] ... |
public static vpnvserver_vpnnexthopserver_binding[] get(nitro_service service, String name) throws Exception{
vpnvserver_vpnnexthopserver_binding obj = new vpnvserver_vpnnexthopserver_binding();
obj.set_name(name);
vpnvserver_vpnnexthopserver_binding response[] = (vpnvserver_vpnnexthopserver_binding[]) obj.get_re... | class class_name[name] begin[{]
method[get, return_type[type[vpnvserver_vpnnexthopserver_binding]], modifier[public static], parameter[service, name]] begin[{]
local_variable[type[vpnvserver_vpnnexthopserver_binding], obj]
call[obj.set_name, parameter[member[.name]]]
local_varia... | Keyword[public] Keyword[static] identifier[vpnvserver_vpnnexthopserver_binding] operator[SEP] operator[SEP] identifier[get] operator[SEP] identifier[nitro_service] identifier[service] , identifier[String] identifier[name] operator[SEP] Keyword[throws] identifier[Exception] {
identifier[vpnvserver_vpnnexthopserv... |
public void addDataSourceProperty(String propertyName, Object value)
{
checkIfSealed();
dataSourceProperties.put(propertyName, value);
} | class class_name[name] begin[{]
method[addDataSourceProperty, return_type[void], modifier[public], parameter[propertyName, value]] begin[{]
call[.checkIfSealed, parameter[]]
call[dataSourceProperties.put, parameter[member[.propertyName], member[.value]]]
end[}]
END[}] | Keyword[public] Keyword[void] identifier[addDataSourceProperty] operator[SEP] identifier[String] identifier[propertyName] , identifier[Object] identifier[value] operator[SEP] {
identifier[checkIfSealed] operator[SEP] operator[SEP] operator[SEP] identifier[dataSourceProperties] operator[SEP] identifier[put] oper... |
@Override
public DataSource getSelectedDataSource() {
final String dataSourceName = selectableDataSourceHolder.getCurrentSelectableDataSourceKey();
if (dataSourceName != null) {
return selectableDataSourceHolder.getSelectedDataSource();
} else { // means no name set on thread loc... | class class_name[name] begin[{]
method[getSelectedDataSource, return_type[type[DataSource]], modifier[public], parameter[]] begin[{]
local_variable[type[String], dataSourceName]
if[binary_operation[member[.dataSourceName], !=, literal[null]]] begin[{]
return[call[selectableD... | annotation[@] identifier[Override] Keyword[public] identifier[DataSource] identifier[getSelectedDataSource] operator[SEP] operator[SEP] {
Keyword[final] identifier[String] identifier[dataSourceName] operator[=] identifier[selectableDataSourceHolder] operator[SEP] identifier[getCurrentSelectableDataSourceKey] ope... |
public boolean subscribe(IConsumer consumer, Map<String, Object> paramMap) {
// pipe is possibly used by dozens of threads at once (like many subscribers for one server stream)
boolean success = consumers.addIfAbsent(consumer);
// if consumer is listener object register it as listener and consum... | class class_name[name] begin[{]
method[subscribe, return_type[type[boolean]], modifier[public], parameter[consumer, paramMap]] begin[{]
local_variable[type[boolean], success]
if[binary_operation[member[.success], &&, binary_operation[member[.consumer], instanceof, type[IPipeConnectionLi... | Keyword[public] Keyword[boolean] identifier[subscribe] operator[SEP] identifier[IConsumer] identifier[consumer] , identifier[Map] operator[<] identifier[String] , identifier[Object] operator[>] identifier[paramMap] operator[SEP] {
Keyword[boolean] identifier[success] operator[=] identifier[consumers] operator[... |
public Tile getTile (int fqTileId, TileSet.Colorizer rizer)
throws NoSuchTileSetException
{
return getTile(TileUtil.getTileSetId(fqTileId), TileUtil.getTileIndex(fqTileId), rizer);
} | class class_name[name] begin[{]
method[getTile, return_type[type[Tile]], modifier[public], parameter[fqTileId, rizer]] begin[{]
return[call[.getTile, parameter[call[TileUtil.getTileSetId, parameter[member[.fqTileId]]], call[TileUtil.getTileIndex, parameter[member[.fqTileId]]], member[.rizer]]]]
end... | Keyword[public] identifier[Tile] identifier[getTile] operator[SEP] Keyword[int] identifier[fqTileId] , identifier[TileSet] operator[SEP] identifier[Colorizer] identifier[rizer] operator[SEP] Keyword[throws] identifier[NoSuchTileSetException] {
Keyword[return] identifier[getTile] operator[SEP] identifier[TileUti... |
public FSArray getCandidateAnswers() {
if (SearchResult_Type.featOkTst && ((SearchResult_Type)jcasType).casFeat_candidateAnswers == null)
jcasType.jcas.throwFeatMissing("candidateAnswers", "edu.cmu.lti.oaqa.type.retrieval.SearchResult");
return (FSArray)(jcasType.ll_cas.ll_getFSForRef(jcasType.ll_cas.ll_g... | class class_name[name] begin[{]
method[getCandidateAnswers, return_type[type[FSArray]], modifier[public], parameter[]] begin[{]
if[binary_operation[member[SearchResult_Type.featOkTst], &&, binary_operation[Cast(expression=MemberReference(member=jcasType, postfix_operators=[], prefix_operators=[... | Keyword[public] identifier[FSArray] identifier[getCandidateAnswers] operator[SEP] operator[SEP] {
Keyword[if] operator[SEP] identifier[SearchResult_Type] operator[SEP] identifier[featOkTst] operator[&&] operator[SEP] operator[SEP] identifier[SearchResult_Type] operator[SEP] identifier[jcasType] operator[SEP] ope... |
public static double elementMax( DMatrixSparseCSC A ) {
if( A.nz_length == 0)
return 0;
// if every element is assigned a value then the first element can be a max.
// Otherwise zero needs to be considered
double max = A.isFull() ? A.nz_values[0] : 0;
for(int i = 0; ... | class class_name[name] begin[{]
method[elementMax, return_type[type[double]], modifier[public static], parameter[A]] begin[{]
if[binary_operation[member[A.nz_length], ==, literal[0]]] begin[{]
return[literal[0]]
else begin[{]
None
end[}]
local_variable[type[double], max]... | Keyword[public] Keyword[static] Keyword[double] identifier[elementMax] operator[SEP] identifier[DMatrixSparseCSC] identifier[A] operator[SEP] {
Keyword[if] operator[SEP] identifier[A] operator[SEP] identifier[nz_length] operator[==] Other[0] operator[SEP] Keyword[return] Other[0] operator[SEP] Keyword[double] id... |
@Override
public void afterCompletion(TransactionCommon transaction, boolean committed)
{
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
SibTr.entry(tc, "afterCompletion", new Object[] { transaction, Boolean.valueOf(committed) });
synchronized (this)
{
... | class class_name[name] begin[{]
method[afterCompletion, return_type[void], modifier[public], parameter[transaction, committed]] begin[{]
if[binary_operation[call[TraceComponent.isAnyTracingEnabled, parameter[]], &&, call[tc.isEntryEnabled, parameter[]]]] begin[{]
call[SibTr.entry, p... | annotation[@] identifier[Override] Keyword[public] Keyword[void] identifier[afterCompletion] operator[SEP] identifier[TransactionCommon] identifier[transaction] , Keyword[boolean] identifier[committed] operator[SEP] {
Keyword[if] operator[SEP] identifier[TraceComponent] operator[SEP] identifier[isAnyTracingEnab... |
public PlanNode removeFromParent() {
PlanNode result = this.parent;
if (this.parent != null) {
// Remove this node from its current parent ...
this.parent.children.remove(this);
this.parent = null;
}
return result;
} | class class_name[name] begin[{]
method[removeFromParent, return_type[type[PlanNode]], modifier[public], parameter[]] begin[{]
local_variable[type[PlanNode], result]
if[binary_operation[THIS[member[None.parent]], !=, literal[null]]] begin[{]
THIS[member[None.paren... | Keyword[public] identifier[PlanNode] identifier[removeFromParent] operator[SEP] operator[SEP] {
identifier[PlanNode] identifier[result] operator[=] Keyword[this] operator[SEP] identifier[parent] operator[SEP] Keyword[if] operator[SEP] Keyword[this] operator[SEP] identifier[parent] operator[!=] Other[null] operat... |
public void sendAckExpectedMessage(
long ackExpStamp,
int priority,
Reliability reliability,
SIBUuid12 stream)
throws SIResourceException
{
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
SibTr.entry(
tc,
"sendAckExpectedMessage",
new Object[] {
... | class class_name[name] begin[{]
method[sendAckExpectedMessage, return_type[void], modifier[public], parameter[ackExpStamp, priority, reliability, stream]] begin[{]
if[binary_operation[call[TraceComponent.isAnyTracingEnabled, parameter[]], &&, call[tc.isEntryEnabled, parameter[]]]] begin[{]
... | Keyword[public] Keyword[void] identifier[sendAckExpectedMessage] operator[SEP] Keyword[long] identifier[ackExpStamp] , Keyword[int] identifier[priority] , identifier[Reliability] identifier[reliability] , identifier[SIBUuid12] identifier[stream] operator[SEP] Keyword[throws] identifier[SIResourceException] {
... |
@Override
public ListRegexMatchSetsResult listRegexMatchSets(ListRegexMatchSetsRequest request) {
request = beforeClientExecution(request);
return executeListRegexMatchSets(request);
} | class class_name[name] begin[{]
method[listRegexMatchSets, return_type[type[ListRegexMatchSetsResult]], modifier[public], parameter[request]] begin[{]
assign[member[.request], call[.beforeClientExecution, parameter[member[.request]]]]
return[call[.executeListRegexMatchSets, parameter[me... | annotation[@] identifier[Override] Keyword[public] identifier[ListRegexMatchSetsResult] identifier[listRegexMatchSets] operator[SEP] identifier[ListRegexMatchSetsRequest] identifier[request] operator[SEP] {
identifier[request] operator[=] identifier[beforeClientExecution] operator[SEP] identifier[request] operat... |
protected Structure makeStructure(String partName, List<Dimension> dimensions, boolean includeMissing) {
List<GempakParameter> params = gemreader.getParameters(partName);
if (params == null) {
return null;
}
Structure sVar = new Structure(ncfile, null, null, partName);
sVar.setDimensions... | class class_name[name] begin[{]
method[makeStructure, return_type[type[Structure]], modifier[protected], parameter[partName, dimensions, includeMissing]] begin[{]
local_variable[type[List], params]
if[binary_operation[member[.params], ==, literal[null]]] begin[{]
return[lite... | Keyword[protected] identifier[Structure] identifier[makeStructure] operator[SEP] identifier[String] identifier[partName] , identifier[List] operator[<] identifier[Dimension] operator[>] identifier[dimensions] , Keyword[boolean] identifier[includeMissing] operator[SEP] {
identifier[List] operator[<] identifier[... |
public void setRtfDocument(RtfDocument doc) {
super.setRtfDocument(doc);
for(int i = 0; i < this.chunks.size(); i++) {
((RtfBasicElement) this.chunks.get(i)).setRtfDocument(this.document);
}
} | class class_name[name] begin[{]
method[setRtfDocument, return_type[void], modifier[public], parameter[doc]] begin[{]
SuperMethodInvocation(arguments=[MemberReference(member=doc, postfix_operators=[], prefix_operators=[], qualifier=, selectors=[])], member=setRtfDocument, postfix_operators=[], p... | Keyword[public] Keyword[void] identifier[setRtfDocument] operator[SEP] identifier[RtfDocument] identifier[doc] operator[SEP] {
Keyword[super] operator[SEP] identifier[setRtfDocument] operator[SEP] identifier[doc] operator[SEP] operator[SEP] Keyword[for] operator[SEP] Keyword[int] identifier[i] operator[=] Other[... |
private User authcz(final Cache<AuthCredentials, User> cache, Cache<User, Set<String>> roleCache, final AuthCredentials ac,
final AuthenticationBackend authBackend, final Set<AuthorizationBackend> authorizers) {
if (ac == null) {
return null;
}
try {
//noop b... | class class_name[name] begin[{]
method[authcz, return_type[type[User]], modifier[private], parameter[cache, roleCache, ac, authBackend, authorizers]] begin[{]
if[binary_operation[member[.ac], ==, literal[null]]] begin[{]
return[literal[null]]
else begin[{]
None
end[}... | Keyword[private] identifier[User] identifier[authcz] operator[SEP] Keyword[final] identifier[Cache] operator[<] identifier[AuthCredentials] , identifier[User] operator[>] identifier[cache] , identifier[Cache] operator[<] identifier[User] , identifier[Set] operator[<] identifier[String] operator[>] operator[>] identi... |
@SuppressWarnings("unused")
public void setCancelColor(@ColorInt int color) {
mCancelColor = Color.argb(255, Color.red(color), Color.green(color), Color.blue(color));
} | class class_name[name] begin[{]
method[setCancelColor, return_type[void], modifier[public], parameter[color]] begin[{]
assign[member[.mCancelColor], call[Color.argb, parameter[literal[255], call[Color.red, parameter[member[.color]]], call[Color.green, parameter[member[.color]]], call[Color.blue... | annotation[@] identifier[SuppressWarnings] operator[SEP] literal[String] operator[SEP] Keyword[public] Keyword[void] identifier[setCancelColor] operator[SEP] annotation[@] identifier[ColorInt] Keyword[int] identifier[color] operator[SEP] {
identifier[mCancelColor] operator[=] identifier[Color] operator[SEP] iden... |
private List<List<ConceptId>> getComputePathResultList(Multimap<ConceptId, ConceptId> resultGraph, ConceptId fromID) {
List<List<ConceptId>> allPaths = new ArrayList<>();
List<ConceptId> firstPath = new ArrayList<>();
firstPath.add(fromID);
Deque<List<ConceptId>> queue = new ArrayDeque<... | class class_name[name] begin[{]
method[getComputePathResultList, return_type[type[List]], modifier[private], parameter[resultGraph, fromID]] begin[{]
local_variable[type[List], allPaths]
local_variable[type[List], firstPath]
call[firstPath.add, parameter[member[.fromID]]]
... | Keyword[private] identifier[List] operator[<] identifier[List] operator[<] identifier[ConceptId] operator[>] operator[>] identifier[getComputePathResultList] operator[SEP] identifier[Multimap] operator[<] identifier[ConceptId] , identifier[ConceptId] operator[>] identifier[resultGraph] , identifier[ConceptId] identif... |
private CloseableJobListener getParallelCombinedJobListener(JobState jobState, JobListener jobListener) {
List<JobListener> jobListeners = Lists.newArrayList(this.mandatoryJobListeners);
jobListeners.add(jobListener);
Set<String> jobListenerClassNames = jobState.getPropAsSet(ConfigurationKeys.JOB_LISTENERS... | class class_name[name] begin[{]
method[getParallelCombinedJobListener, return_type[type[CloseableJobListener]], modifier[private], parameter[jobState, jobListener]] begin[{]
local_variable[type[List], jobListeners]
call[jobListeners.add, parameter[member[.jobListener]]]
local_va... | Keyword[private] identifier[CloseableJobListener] identifier[getParallelCombinedJobListener] operator[SEP] identifier[JobState] identifier[jobState] , identifier[JobListener] identifier[jobListener] operator[SEP] {
identifier[List] operator[<] identifier[JobListener] operator[>] identifier[jobListeners] operato... |
private <R> R execute(String segmentName, Callable<R> operation) throws StreamSegmentException {
Exceptions.checkNotClosed(this.closed.get(), this);
try {
return operation.call();
} catch (Exception e) {
return throwException(segmentName, e);
}
} | class class_name[name] begin[{]
method[execute, return_type[type[R]], modifier[private], parameter[segmentName, operation]] begin[{]
call[Exceptions.checkNotClosed, parameter[THIS[member[None.closed]call[None.get, parameter[]]], THIS[]]]
TryStatement(block=[ReturnStatement(expression=Me... | Keyword[private] operator[<] identifier[R] operator[>] identifier[R] identifier[execute] operator[SEP] identifier[String] identifier[segmentName] , identifier[Callable] operator[<] identifier[R] operator[>] identifier[operation] operator[SEP] Keyword[throws] identifier[StreamSegmentException] {
identifier[Excep... |
@Override
public int deleteById(TableColumnKey id) throws SQLException {
int count = 0;
if (id != null) {
GeometryColumnsSqlMm geometryColumns = queryForId(id);
if (geometryColumns != null) {
count = delete(geometryColumns);
}
}
return count;
} | class class_name[name] begin[{]
method[deleteById, return_type[type[int]], modifier[public], parameter[id]] begin[{]
local_variable[type[int], count]
if[binary_operation[member[.id], !=, literal[null]]] begin[{]
local_variable[type[GeometryColumnsSqlMm], geometryColumns]
... | annotation[@] identifier[Override] Keyword[public] Keyword[int] identifier[deleteById] operator[SEP] identifier[TableColumnKey] identifier[id] operator[SEP] Keyword[throws] identifier[SQLException] {
Keyword[int] identifier[count] operator[=] Other[0] operator[SEP] Keyword[if] operator[SEP] identifier[id] operat... |
static public ThreddsMetadata.Variables extractVariables(InvDatasetImpl threddsDataset) throws IOException {
ThreddsDataFactory.Result result = null;
try {
result = new ThreddsDataFactory().openFeatureDataset(threddsDataset, null);
if (result.fatalError) {
System.out.println(" openDatatype ... | class class_name[name] begin[{]
method[extractVariables, return_type[type[ThreddsMetadata]], modifier[public static], parameter[threddsDataset]] begin[{]
local_variable[type[ThreddsDataFactory], result]
TryStatement(block=[StatementExpression(expression=Assignment(expressionl=MemberReference(me... | Keyword[static] Keyword[public] identifier[ThreddsMetadata] operator[SEP] identifier[Variables] identifier[extractVariables] operator[SEP] identifier[InvDatasetImpl] identifier[threddsDataset] operator[SEP] Keyword[throws] identifier[IOException] {
identifier[ThreddsDataFactory] operator[SEP] identifier[Result] ... |
@Override
public List<CPDefinitionLink> getCPDefinitionLinks(int start, int end) {
return cpDefinitionLinkPersistence.findAll(start, end);
} | class class_name[name] begin[{]
method[getCPDefinitionLinks, return_type[type[List]], modifier[public], parameter[start, end]] begin[{]
return[call[cpDefinitionLinkPersistence.findAll, parameter[member[.start], member[.end]]]]
end[}]
END[}] | annotation[@] identifier[Override] Keyword[public] identifier[List] operator[<] identifier[CPDefinitionLink] operator[>] identifier[getCPDefinitionLinks] operator[SEP] Keyword[int] identifier[start] , Keyword[int] identifier[end] operator[SEP] {
Keyword[return] identifier[cpDefinitionLinkPersistence] operator[S... |
public Object invoke(TargetMetaDef targetMetaDef, Method m, Object[] args) throws Throwable {
Object result = null;
getThreadLock();
int currentRequestNb = requestNb++;
Debug.logVerbose("[JdonFramework]Start remote call " + currentRequestNb + " " + m.getName(), module);
// 准备参数
HttpRequest reque... | class class_name[name] begin[{]
method[invoke, return_type[type[Object]], modifier[public], parameter[targetMetaDef, m, args]] begin[{]
local_variable[type[Object], result]
call[.getThreadLock, parameter[]]
local_variable[type[int], currentRequestNb]
call[Debug.l... | Keyword[public] identifier[Object] identifier[invoke] operator[SEP] identifier[TargetMetaDef] identifier[targetMetaDef] , identifier[Method] identifier[m] , identifier[Object] operator[SEP] operator[SEP] identifier[args] operator[SEP] Keyword[throws] identifier[Throwable] {
identifier[Object] identifier[result... |
public Observable<HybridConnectionKeyInner> listHybridConnectionKeysAsync(String resourceGroupName, String name, String namespaceName, String relayName) {
return listHybridConnectionKeysWithServiceResponseAsync(resourceGroupName, name, namespaceName, relayName).map(new Func1<ServiceResponse<HybridConnectionKeyI... | class class_name[name] begin[{]
method[listHybridConnectionKeysAsync, return_type[type[Observable]], modifier[public], parameter[resourceGroupName, name, namespaceName, relayName]] begin[{]
return[call[.listHybridConnectionKeysWithServiceResponseAsync, parameter[member[.resourceGroupName], member[.name... | Keyword[public] identifier[Observable] operator[<] identifier[HybridConnectionKeyInner] operator[>] identifier[listHybridConnectionKeysAsync] operator[SEP] identifier[String] identifier[resourceGroupName] , identifier[String] identifier[name] , identifier[String] identifier[namespaceName] , identifier[String] identi... |
@Override
public String getCookieName() {
if (allowedProps != null) {
return (String) allowedProps.get(CFG_COOKIE_NAME);
}
return null;
} | class class_name[name] begin[{]
method[getCookieName, return_type[type[String]], modifier[public], parameter[]] begin[{]
if[binary_operation[member[.allowedProps], !=, literal[null]]] begin[{]
return[Cast(expression=MethodInvocation(arguments=[MemberReference(member=CFG_COOKIE_NAME,... | annotation[@] identifier[Override] Keyword[public] identifier[String] identifier[getCookieName] operator[SEP] operator[SEP] {
Keyword[if] operator[SEP] identifier[allowedProps] operator[!=] Other[null] operator[SEP] {
Keyword[return] operator[SEP] identifier[String] operator[SEP] identifier[allowedPro... |
private UserDetailsService getUserDetailsService() {
Map<String, ?> beans = getBeansOfType(CachingUserDetailsService.class);
if (beans.size() == 0) {
beans = getBeansOfType(UserDetailsService.class);
}
if (beans.size() == 0) {
throw new ApplicationContextException("No UserDetailsService registered.");
... | class class_name[name] begin[{]
method[getUserDetailsService, return_type[type[UserDetailsService]], modifier[private], parameter[]] begin[{]
local_variable[type[Map], beans]
if[binary_operation[call[beans.size, parameter[]], ==, literal[0]]] begin[{]
assign[memb... | Keyword[private] identifier[UserDetailsService] identifier[getUserDetailsService] operator[SEP] operator[SEP] {
identifier[Map] operator[<] identifier[String] , operator[?] operator[>] identifier[beans] operator[=] identifier[getBeansOfType] operator[SEP] identifier[CachingUserDetailsService] operator[SEP] Keyw... |
public static DefaultAuthenticationTransaction of(final Service service, final Credential... credentials) {
val creds = sanitizeCredentials(credentials);
return new DefaultAuthenticationTransaction(service, creds);
} | class class_name[name] begin[{]
method[of, return_type[type[DefaultAuthenticationTransaction]], modifier[public static], parameter[service, credentials]] begin[{]
local_variable[type[val], creds]
return[ClassCreator(arguments=[MemberReference(member=service, postfix_operators=[], prefix_operato... | Keyword[public] Keyword[static] identifier[DefaultAuthenticationTransaction] identifier[of] operator[SEP] Keyword[final] identifier[Service] identifier[service] , Keyword[final] identifier[Credential] operator[...] identifier[credentials] operator[SEP] {
identifier[val] identifier[creds] operator[=] identifier[... |
@Override
public EEnum getIfcMotorConnectionTypeEnum() {
if (ifcMotorConnectionTypeEnumEEnum == null) {
ifcMotorConnectionTypeEnumEEnum = (EEnum) EPackage.Registry.INSTANCE.getEPackage(Ifc4Package.eNS_URI)
.getEClassifiers().get(1019);
}
return ifcMotorConnectionTypeEnumEEnum;
} | class class_name[name] begin[{]
method[getIfcMotorConnectionTypeEnum, return_type[type[EEnum]], modifier[public], parameter[]] begin[{]
if[binary_operation[member[.ifcMotorConnectionTypeEnumEEnum], ==, literal[null]]] begin[{]
assign[member[.ifcMotorConnectionTypeEnumEEn... | annotation[@] identifier[Override] Keyword[public] identifier[EEnum] identifier[getIfcMotorConnectionTypeEnum] operator[SEP] operator[SEP] {
Keyword[if] operator[SEP] identifier[ifcMotorConnectionTypeEnumEEnum] operator[==] Other[null] operator[SEP] {
identifier[ifcMotorConnectionTypeEnumEEnum] operat... |
public static HTMLElement resolveElement(HTMLElement context, String identifier) {
Element element = DATA_ELEMENT.select(context, identifier);
HTMLElement htmlElement = Js.cast(element);
return htmlElement;
} | class class_name[name] begin[{]
method[resolveElement, return_type[type[HTMLElement]], modifier[public static], parameter[context, identifier]] begin[{]
local_variable[type[Element], element]
local_variable[type[HTMLElement], htmlElement]
return[member[.htmlElement]]
end[}]
END[}] | Keyword[public] Keyword[static] identifier[HTMLElement] identifier[resolveElement] operator[SEP] identifier[HTMLElement] identifier[context] , identifier[String] identifier[identifier] operator[SEP] {
identifier[Element] identifier[element] operator[=] identifier[DATA_ELEMENT] operator[SEP] identifier[select] o... |
@Override
public EClass getListOfELong() {
if (listOfELongEClass == null) {
listOfELongEClass = (EClass) EPackage.Registry.INSTANCE.getEPackage(Ifc4Package.eNS_URI).getEClassifiers()
.get(1178);
}
return listOfELongEClass;
} | class class_name[name] begin[{]
method[getListOfELong, return_type[type[EClass]], modifier[public], parameter[]] begin[{]
if[binary_operation[member[.listOfELongEClass], ==, literal[null]]] begin[{]
assign[member[.listOfELongEClass], Cast(expression=MethodInvocation(argu... | annotation[@] identifier[Override] Keyword[public] identifier[EClass] identifier[getListOfELong] operator[SEP] operator[SEP] {
Keyword[if] operator[SEP] identifier[listOfELongEClass] operator[==] Other[null] operator[SEP] {
identifier[listOfELongEClass] operator[=] operator[SEP] identifier[EClass] ope... |
public static <T> T doWithSingleContext(ContextSource contextSource,
LdapOperationsCallback<T> callback,
boolean useReadOnly,
boolean ignorePartialResultException,
... | class class_name[name] begin[{]
method[doWithSingleContext, return_type[type[T]], modifier[public static], parameter[contextSource, callback, useReadOnly, ignorePartialResultException, ignoreNameNotFoundException]] begin[{]
local_variable[type[SingleContextSource], singleContextSource]
... | Keyword[public] Keyword[static] operator[<] identifier[T] operator[>] identifier[T] identifier[doWithSingleContext] operator[SEP] identifier[ContextSource] identifier[contextSource] , identifier[LdapOperationsCallback] operator[<] identifier[T] operator[>] identifier[callback] , Keyword[boolean] identifier[useReadOnl... |
public void setLedVisible(final boolean VISIBLE) {
if (null == ledVisible) {
_ledVisible = VISIBLE;
fireUpdateEvent(VISIBILITY_EVENT);
} else {
ledVisible.set(VISIBLE);
}
} | class class_name[name] begin[{]
method[setLedVisible, return_type[void], modifier[public], parameter[VISIBLE]] begin[{]
if[binary_operation[literal[null], ==, member[.ledVisible]]] begin[{]
assign[member[._ledVisible], member[.VISIBLE]]
call[.fire... | Keyword[public] Keyword[void] identifier[setLedVisible] operator[SEP] Keyword[final] Keyword[boolean] identifier[VISIBLE] operator[SEP] {
Keyword[if] operator[SEP] Other[null] operator[==] identifier[ledVisible] operator[SEP] {
identifier[_ledVisible] operator[=] identifier[VISIBLE] operator[SEP] iden... |
@Override
public PGPPublicKeyRingCollection getAnnouncedPublicKeys() throws IOException, PGPException {
PGPSecretKeyRing secretKeys = getSigningKeyRing();
PGPPublicKeyRing publicKeys = getAnyPublicKeys().getPublicKeyRing(secretKeys.getPublicKey().getKeyID());
publicKeys = BCUtil.removeUnasso... | class class_name[name] begin[{]
method[getAnnouncedPublicKeys, return_type[type[PGPPublicKeyRingCollection]], modifier[public], parameter[]] begin[{]
local_variable[type[PGPSecretKeyRing], secretKeys]
local_variable[type[PGPPublicKeyRing], publicKeys]
assign[member[.publicKeys],... | annotation[@] identifier[Override] Keyword[public] identifier[PGPPublicKeyRingCollection] identifier[getAnnouncedPublicKeys] operator[SEP] operator[SEP] Keyword[throws] identifier[IOException] , identifier[PGPException] {
identifier[PGPSecretKeyRing] identifier[secretKeys] operator[=] identifier[getSigningKeyRi... |
public static <T, R> Collector<T, ?, R> streaming(final long maxWaitIntervalInMillis, final Supplier<? extends BlockingQueue<T>> queueSupplier,
final Function<? super Stream<T>, R> streamingCollector) {
final Function<Stream<T>, ContinuableFuture<R>> streamingCollector2 = new Function<Stream<T>, C... | class class_name[name] begin[{]
method[streaming, return_type[type[Collector]], modifier[public static], parameter[maxWaitIntervalInMillis, queueSupplier, streamingCollector]] begin[{]
local_variable[type[Function], streamingCollector2]
return[call[.streaming, parameter[member[.queueSupplier], ... | Keyword[public] Keyword[static] operator[<] identifier[T] , identifier[R] operator[>] identifier[Collector] operator[<] identifier[T] , operator[?] , identifier[R] operator[>] identifier[streaming] operator[SEP] Keyword[final] Keyword[long] identifier[maxWaitIntervalInMillis] , Keyword[final] identifier[Supplier] o... |
@Override
public CPOption removeByC_ERC(long companyId, String externalReferenceCode)
throws NoSuchCPOptionException {
CPOption cpOption = findByC_ERC(companyId, externalReferenceCode);
return remove(cpOption);
} | class class_name[name] begin[{]
method[removeByC_ERC, return_type[type[CPOption]], modifier[public], parameter[companyId, externalReferenceCode]] begin[{]
local_variable[type[CPOption], cpOption]
return[call[.remove, parameter[member[.cpOption]]]]
end[}]
END[}] | annotation[@] identifier[Override] Keyword[public] identifier[CPOption] identifier[removeByC_ERC] operator[SEP] Keyword[long] identifier[companyId] , identifier[String] identifier[externalReferenceCode] operator[SEP] Keyword[throws] identifier[NoSuchCPOptionException] {
identifier[CPOption] identifier[cpOption]... |
public static BigDecimal maximum(BigDecimal... values)
{
int len = values.length;
if (len == 1)
{
if (values[0] == null)
{
throw new IllegalArgumentException("Cannot passed null BigDecimal entry to maximum()");
}
return values[0... | class class_name[name] begin[{]
method[maximum, return_type[type[BigDecimal]], modifier[public static], parameter[values]] begin[{]
local_variable[type[int], len]
if[binary_operation[member[.len], ==, literal[1]]] begin[{]
if[binary_operation[member[.values], ==,... | Keyword[public] Keyword[static] identifier[BigDecimal] identifier[maximum] operator[SEP] identifier[BigDecimal] operator[...] identifier[values] operator[SEP] {
Keyword[int] identifier[len] operator[=] identifier[values] operator[SEP] identifier[length] operator[SEP] Keyword[if] operator[SEP] identifier[len] ope... |
public static <T> T unmarshal(final String xmlData, final Class<?>... classesToBeBound) {
return unmarshal(xmlData, null, classesToBeBound);
} | class class_name[name] begin[{]
method[unmarshal, return_type[type[T]], modifier[public static], parameter[xmlData, classesToBeBound]] begin[{]
return[call[.unmarshal, parameter[member[.xmlData], literal[null], member[.classesToBeBound]]]]
end[}]
END[}] | Keyword[public] Keyword[static] operator[<] identifier[T] operator[>] identifier[T] identifier[unmarshal] operator[SEP] Keyword[final] identifier[String] identifier[xmlData] , Keyword[final] identifier[Class] operator[<] operator[?] operator[>] operator[...] identifier[classesToBeBound] operator[SEP] {
Keyword[... |
protected StyledString signatureWithoutReturnType(StyledString simpleName, JvmExecutable element) {
return simpleName.append(this.uiStrings.styledParameters(element));
} | class class_name[name] begin[{]
method[signatureWithoutReturnType, return_type[type[StyledString]], modifier[protected], parameter[simpleName, element]] begin[{]
return[call[simpleName.append, parameter[THIS[member[None.uiStrings]call[None.styledParameters, parameter[member[.element]]]]]]]
end[}]
E... | Keyword[protected] identifier[StyledString] identifier[signatureWithoutReturnType] operator[SEP] identifier[StyledString] identifier[simpleName] , identifier[JvmExecutable] identifier[element] operator[SEP] {
Keyword[return] identifier[simpleName] operator[SEP] identifier[append] operator[SEP] Keyword[this] ope... |
private static void radixPass(int[] src, int[] dst, int[] v, int vi,
final int n, final int K, int start, int[] cnt) {
// check counter array's size.
assert cnt.length >= K + 1;
Arrays.fill(cnt, 0, K + 1, 0);
// count occurrences
for (int i = 0;... | class class_name[name] begin[{]
method[radixPass, return_type[void], modifier[private static], parameter[src, dst, v, vi, n, K, start, cnt]] begin[{]
AssertStatement(condition=BinaryOperation(operandl=MemberReference(member=length, postfix_operators=[], prefix_operators=[], qualifier=cnt, selectors=[])... | Keyword[private] Keyword[static] Keyword[void] identifier[radixPass] operator[SEP] Keyword[int] operator[SEP] operator[SEP] identifier[src] , Keyword[int] operator[SEP] operator[SEP] identifier[dst] , Keyword[int] operator[SEP] operator[SEP] identifier[v] , Keyword[int] identifier[vi] , Keyword[final] Keyword[int] ... |
public static void badConversion(Field destinationField, Class<?> destinationClass, Field sourceField, Class<?> sourceClass,String plus){
throw new UndefinedMappingException(MSG.INSTANCE.message(undefinedMappingException,destinationField.getName(),destinationClass.getSimpleName(),sourceField.getName(),sourceClass.ge... | class class_name[name] begin[{]
method[badConversion, return_type[void], modifier[public static], parameter[destinationField, destinationClass, sourceField, sourceClass, plus]] begin[{]
ThrowStatement(expression=ClassCreator(arguments=[BinaryOperation(operandl=BinaryOperation(operandl=MethodInvocation(... | Keyword[public] Keyword[static] Keyword[void] identifier[badConversion] operator[SEP] identifier[Field] identifier[destinationField] , identifier[Class] operator[<] operator[?] operator[>] identifier[destinationClass] , identifier[Field] identifier[sourceField] , identifier[Class] operator[<] operator[?] operator[>]... |
@Override
public void start() {
if (this.started) {
throw new IllegalStateException("The stub server has been started already.");
}
logger.debug("starting the underlying stub server...");
this.server.registerRequestManager(this);
try {
... | class class_name[name] begin[{]
method[start, return_type[void], modifier[public], parameter[]] begin[{]
if[THIS[member[None.started]]] begin[{]
ThrowStatement(expression=ClassCreator(arguments=[Literal(postfix_operators=[], prefix_operators=[], qualifier=None, selectors=[], value="... | annotation[@] identifier[Override] Keyword[public] Keyword[void] identifier[start] operator[SEP] operator[SEP] {
Keyword[if] operator[SEP] Keyword[this] operator[SEP] identifier[started] operator[SEP] {
Keyword[throw] Keyword[new] identifier[IllegalStateException] operator[SEP] literal[String] operato... |
@Override
public void prepareFileTypeAnalyzer(Engine engine) throws InitializationException {
LOGGER.debug("Initializing Artifactory analyzer");
final boolean enabled = isEnabled();
LOGGER.debug("Artifactory analyzer enabled: {}", enabled);
if (enabled) {
searcher = new A... | class class_name[name] begin[{]
method[prepareFileTypeAnalyzer, return_type[void], modifier[public], parameter[engine]] begin[{]
call[LOGGER.debug, parameter[literal["Initializing Artifactory analyzer"]]]
local_variable[type[boolean], enabled]
call[LOGGER.debug, paramete... | annotation[@] identifier[Override] Keyword[public] Keyword[void] identifier[prepareFileTypeAnalyzer] operator[SEP] identifier[Engine] identifier[engine] operator[SEP] Keyword[throws] identifier[InitializationException] {
identifier[LOGGER] operator[SEP] identifier[debug] operator[SEP] literal[String] operator[SE... |
private boolean isAtEOL() {
int next = skipLineSpace(index);
return next >= tokens.size() || tokens.get(next).kind == NewLine;
} | class class_name[name] begin[{]
method[isAtEOL, return_type[type[boolean]], modifier[private], parameter[]] begin[{]
local_variable[type[int], next]
return[binary_operation[binary_operation[member[.next], >=, call[tokens.size, parameter[]]], ||, binary_operation[call[tokens.get, parameter[membe... | Keyword[private] Keyword[boolean] identifier[isAtEOL] operator[SEP] operator[SEP] {
Keyword[int] identifier[next] operator[=] identifier[skipLineSpace] operator[SEP] identifier[index] operator[SEP] operator[SEP] Keyword[return] identifier[next] operator[>=] identifier[tokens] operator[SEP] identifier[size] opera... |
public void marshall(CancelWorkflowExecutionDecisionAttributes cancelWorkflowExecutionDecisionAttributes, ProtocolMarshaller protocolMarshaller) {
if (cancelWorkflowExecutionDecisionAttributes == null) {
throw new SdkClientException("Invalid argument passed to marshall(...)");
}
tr... | class class_name[name] begin[{]
method[marshall, return_type[void], modifier[public], parameter[cancelWorkflowExecutionDecisionAttributes, protocolMarshaller]] begin[{]
if[binary_operation[member[.cancelWorkflowExecutionDecisionAttributes], ==, literal[null]]] begin[{]
ThrowStatemen... | Keyword[public] Keyword[void] identifier[marshall] operator[SEP] identifier[CancelWorkflowExecutionDecisionAttributes] identifier[cancelWorkflowExecutionDecisionAttributes] , identifier[ProtocolMarshaller] identifier[protocolMarshaller] operator[SEP] {
Keyword[if] operator[SEP] identifier[cancelWorkflowExecutio... |
public void setInitializer(/* @Nullable */ JvmField field, /* @Nullable */ XExpression expr) {
if (field == null || expr == null)
return;
removeExistingBody(field);
associator.associateLogicalContainer(expr, field);
} | class class_name[name] begin[{]
method[setInitializer, return_type[void], modifier[public], parameter[field, expr]] begin[{]
if[binary_operation[binary_operation[member[.field], ==, literal[null]], ||, binary_operation[member[.expr], ==, literal[null]]]] begin[{]
return[None]
else begin... | Keyword[public] Keyword[void] identifier[setInitializer] operator[SEP] identifier[JvmField] identifier[field] , identifier[XExpression] identifier[expr] operator[SEP] {
Keyword[if] operator[SEP] identifier[field] operator[==] Other[null] operator[||] identifier[expr] operator[==] Other[null] operator[SEP] Keywo... |
private boolean explanSpecialCondWithBothSidesAreLiterals(SQLBinaryOpExpr bExpr, Where where) throws SqlParseException {
if ((bExpr.getLeft() instanceof SQLNumericLiteralExpr || bExpr.getLeft() instanceof SQLCharExpr) &&
(bExpr.getRight() instanceof SQLNumericLiteralExpr || bExpr.getRight() inst... | class class_name[name] begin[{]
method[explanSpecialCondWithBothSidesAreLiterals, return_type[type[boolean]], modifier[private], parameter[bExpr, where]] begin[{]
if[binary_operation[binary_operation[binary_operation[call[bExpr.getLeft, parameter[]], instanceof, type[SQLNumericLiteralExpr]], ||... | Keyword[private] Keyword[boolean] identifier[explanSpecialCondWithBothSidesAreLiterals] operator[SEP] identifier[SQLBinaryOpExpr] identifier[bExpr] , identifier[Where] identifier[where] operator[SEP] Keyword[throws] identifier[SqlParseException] {
Keyword[if] operator[SEP] operator[SEP] identifier[bExpr] operat... |
protected String extractHeaderToken(HttpServletRequest request) {
Enumeration<String> headers = request.getHeaders("Authorization");
while (headers.hasMoreElements()) { // typically there is only one (most servers enforce that)
String value = headers.nextElement();
if ((value.toLowerCase().startsWith(OAuth2Ac... | class class_name[name] begin[{]
method[extractHeaderToken, return_type[type[String]], modifier[protected], parameter[request]] begin[{]
local_variable[type[Enumeration], headers]
while[call[headers.hasMoreElements, parameter[]]] begin[{]
local_variable[type[String], value]
... | Keyword[protected] identifier[String] identifier[extractHeaderToken] operator[SEP] identifier[HttpServletRequest] identifier[request] operator[SEP] {
identifier[Enumeration] operator[<] identifier[String] operator[>] identifier[headers] operator[=] identifier[request] operator[SEP] identifier[getHeaders] operato... |
public void receivedBytesRead(int bytes) {
if (log.isDebugEnabled()) {
log.debug("Client received {} bytes, written {} bytes, {} messages pending", new Object[] { bytes, getWrittenBytes(), getPendingMessages() });
}
clientBytesRead.addAndGet(bytes);
} | class class_name[name] begin[{]
method[receivedBytesRead, return_type[void], modifier[public], parameter[bytes]] begin[{]
if[call[log.isDebugEnabled, parameter[]]] begin[{]
call[log.debug, parameter[literal["Client received {} bytes, written {} bytes, {} messages pending... | Keyword[public] Keyword[void] identifier[receivedBytesRead] operator[SEP] Keyword[int] identifier[bytes] operator[SEP] {
Keyword[if] operator[SEP] identifier[log] operator[SEP] identifier[isDebugEnabled] operator[SEP] operator[SEP] operator[SEP] {
identifier[log] operator[SEP] identifier[debug] operat... |
public static void main(String[] args) {
RequestOneScenario.runWith(
args,
benchmarkSettings ->
new StandaloneBenchmarkState(
benchmarkSettings,
"http",
(address, loopResources) ->
Client.http(
Cl... | class class_name[name] begin[{]
method[main, return_type[void], modifier[public static], parameter[args]] begin[{]
call[RequestOneScenario.runWith, parameter[member[.args], LambdaExpression(body=ClassCreator(arguments=[MemberReference(member=benchmarkSettings, postfix_operators=[], prefix_opera... | Keyword[public] Keyword[static] Keyword[void] identifier[main] operator[SEP] identifier[String] operator[SEP] operator[SEP] identifier[args] operator[SEP] {
identifier[RequestOneScenario] operator[SEP] identifier[runWith] operator[SEP] identifier[args] , identifier[benchmarkSettings] operator[->] Keyword[new] i... |
@Reference(cardinality=ReferenceCardinality.MULTIPLE, policy=ReferencePolicy.DYNAMIC)
public void addFactory(FileSetProvider factory) {
if (logger.isLoggable(Level.FINER)) {
logger.finer("Adding factory: " + factory);
}
filters.add(factory);
} | class class_name[name] begin[{]
method[addFactory, return_type[void], modifier[public], parameter[factory]] begin[{]
if[call[logger.isLoggable, parameter[member[Level.FINER]]]] begin[{]
call[logger.finer, parameter[binary_operation[literal["Adding factory: "], +, member[... | annotation[@] identifier[Reference] operator[SEP] identifier[cardinality] operator[=] identifier[ReferenceCardinality] operator[SEP] identifier[MULTIPLE] , identifier[policy] operator[=] identifier[ReferencePolicy] operator[SEP] identifier[DYNAMIC] operator[SEP] Keyword[public] Keyword[void] identifier[addFactory] ope... |
@Override
public <B> Try<T, B> zip(Applicative<Function<? super A, ? extends B>, Try<T, ?>> appFn) {
return Monad.super.zip(appFn).coerce();
} | class class_name[name] begin[{]
method[zip, return_type[type[Try]], modifier[public], parameter[appFn]] begin[{]
return[member[.Monad]]
end[}]
END[}] | annotation[@] identifier[Override] Keyword[public] operator[<] identifier[B] operator[>] identifier[Try] operator[<] identifier[T] , identifier[B] operator[>] identifier[zip] operator[SEP] identifier[Applicative] operator[<] identifier[Function] operator[<] operator[?] Keyword[super] identifier[A] , operator[?] Keywo... |
public static Package parse(File file) throws IOException
{
ObjectMapper mapper = new ObjectMapper();
return mapper.readValue(file, Package.class);
} | class class_name[name] begin[{]
method[parse, return_type[type[Package]], modifier[public static], parameter[file]] begin[{]
local_variable[type[ObjectMapper], mapper]
return[call[mapper.readValue, parameter[member[.file], ClassReference(postfix_operators=[], prefix_operators=[], qualifier=, se... | Keyword[public] Keyword[static] identifier[Package] identifier[parse] operator[SEP] identifier[File] identifier[file] operator[SEP] Keyword[throws] identifier[IOException] {
identifier[ObjectMapper] identifier[mapper] operator[=] Keyword[new] identifier[ObjectMapper] operator[SEP] operator[SEP] operator[SEP] Key... |
@Transactional
@PostMapping(
value = "/{entityTypeId}/{id}",
params = "_method=PUT",
headers = "Content-Type=multipart/form-data")
@ResponseStatus(NO_CONTENT)
public void updateFromFormPostMultiPart(
@PathVariable("entityTypeId") String entityTypeId,
@PathVariable("id") String untype... | class class_name[name] begin[{]
method[updateFromFormPostMultiPart, return_type[void], modifier[public], parameter[entityTypeId, untypedId, request]] begin[{]
local_variable[type[Map], paramMap]
ForStatement(body=BlockStatement(label=None, statements=[LocalVariableDeclaration(annotations=[], de... | annotation[@] identifier[Transactional] annotation[@] identifier[PostMapping] operator[SEP] identifier[value] operator[=] literal[String] , identifier[params] operator[=] literal[String] , identifier[headers] operator[=] literal[String] operator[SEP] annotation[@] identifier[ResponseStatus] operator[SEP] identifier[N... |
@Override
public GetSAMLProviderResult getSAMLProvider(GetSAMLProviderRequest request) {
request = beforeClientExecution(request);
return executeGetSAMLProvider(request);
} | class class_name[name] begin[{]
method[getSAMLProvider, return_type[type[GetSAMLProviderResult]], modifier[public], parameter[request]] begin[{]
assign[member[.request], call[.beforeClientExecution, parameter[member[.request]]]]
return[call[.executeGetSAMLProvider, parameter[member[.req... | annotation[@] identifier[Override] Keyword[public] identifier[GetSAMLProviderResult] identifier[getSAMLProvider] operator[SEP] identifier[GetSAMLProviderRequest] identifier[request] operator[SEP] {
identifier[request] operator[=] identifier[beforeClientExecution] operator[SEP] identifier[request] operator[SEP] o... |
private void readRectangle(DataInput pStream, Rectangle pDestRect) throws IOException {
int y = pStream.readUnsignedShort();
int x = pStream.readUnsignedShort();
int h = pStream.readUnsignedShort();
int w = pStream.readUnsignedShort();
pDestRect.setLocation(getXPtCoord(x), getYP... | class class_name[name] begin[{]
method[readRectangle, return_type[void], modifier[private], parameter[pStream, pDestRect]] begin[{]
local_variable[type[int], y]
local_variable[type[int], x]
local_variable[type[int], h]
local_variable[type[int], w]
call[pDestRect.... | Keyword[private] Keyword[void] identifier[readRectangle] operator[SEP] identifier[DataInput] identifier[pStream] , identifier[Rectangle] identifier[pDestRect] operator[SEP] Keyword[throws] identifier[IOException] {
Keyword[int] identifier[y] operator[=] identifier[pStream] operator[SEP] identifier[readUnsignedS... |
public void isValidLogin( AsyncCallback<Boolean> responder )
{
String userToken = UserTokenStorageFactory.instance().getStorage().get();
if( userToken != null && !userToken.equals( "" ) )
{
Invoker.invokeAsync( USER_MANAGER_SERVER_ALIAS, "isValidUserToken", new Object[] { userToken }, responder );
... | class class_name[name] begin[{]
method[isValidLogin, return_type[void], modifier[public], parameter[responder]] begin[{]
local_variable[type[String], userToken]
if[binary_operation[binary_operation[member[.userToken], !=, literal[null]], &&, call[userToken.equals, parameter[literal[""]]... | Keyword[public] Keyword[void] identifier[isValidLogin] operator[SEP] identifier[AsyncCallback] operator[<] identifier[Boolean] operator[>] identifier[responder] operator[SEP] {
identifier[String] identifier[userToken] operator[=] identifier[UserTokenStorageFactory] operator[SEP] identifier[instance] operator[SEP... |
public final Ix<Ix<T>> window(int size, int skip) {
if (size == skip) {
return window(size);
}
if (size < skip) {
return new IxWindowSkip<T>(this, positive(size, "size"), positive(skip, "skip"));
}
return new IxWindowOverlap<T>(this, positive(size, "size")... | class class_name[name] begin[{]
method[window, return_type[type[Ix]], modifier[final public], parameter[size, skip]] begin[{]
if[binary_operation[member[.size], ==, member[.skip]]] begin[{]
return[call[.window, parameter[member[.size]]]]
else begin[{]
None
end[}]
... | Keyword[public] Keyword[final] identifier[Ix] operator[<] identifier[Ix] operator[<] identifier[T] operator[>] operator[>] identifier[window] operator[SEP] Keyword[int] identifier[size] , Keyword[int] identifier[skip] operator[SEP] {
Keyword[if] operator[SEP] identifier[size] operator[==] identifier[skip] opera... |
public void recordedTooLong() {
if (null != dialog && dialog.isShowing()) {
mImageView.setImageResource(R.drawable.hlklib_record_too_short);
mWarningText.setText(R.string.hlklib_voice_recorder_warning_text_too_long);
}
} | class class_name[name] begin[{]
method[recordedTooLong, return_type[void], modifier[public], parameter[]] begin[{]
if[binary_operation[binary_operation[literal[null], !=, member[.dialog]], &&, call[dialog.isShowing, parameter[]]]] begin[{]
call[mImageView.setImageResourc... | Keyword[public] Keyword[void] identifier[recordedTooLong] operator[SEP] operator[SEP] {
Keyword[if] operator[SEP] Other[null] operator[!=] identifier[dialog] operator[&&] identifier[dialog] operator[SEP] identifier[isShowing] operator[SEP] operator[SEP] operator[SEP] {
identifier[mImageView] operator[... |
@Override
public void removeByResource(Resource resource) {
checkNotNull(resource,"Resource cannot be null");
this.lock.writeLock().lock();
try {
ResourceId resourceId = resource.id();
for(String constraintsId:this.failureIds.get(resourceId)) {
this.reports.remove(ConstraintReportId.create(resourceId, ... | class class_name[name] begin[{]
method[removeByResource, return_type[void], modifier[public], parameter[resource]] begin[{]
call[.checkNotNull, parameter[member[.resource], literal["Resource cannot be null"]]]
THIS[member[None.lock]call[None.writeLock, parameter[]]call[None.lock... | annotation[@] identifier[Override] Keyword[public] Keyword[void] identifier[removeByResource] operator[SEP] identifier[Resource] identifier[resource] operator[SEP] {
identifier[checkNotNull] operator[SEP] identifier[resource] , literal[String] operator[SEP] operator[SEP] Keyword[this] operator[SEP] identifier[l... |
@Override
public void start() {
if (mIsRunning || mAnimationBackend == null || mAnimationBackend.getFrameCount() <= 1) {
return;
}
mIsRunning = true;
mStartTimeMs = now();
mExpectedRenderTimeMs = mStartTimeMs;
mLastFrameAnimationTimeMs = -1;
mLastDrawnFrameNumber = -1;
invalidate... | class class_name[name] begin[{]
method[start, return_type[void], modifier[public], parameter[]] begin[{]
if[binary_operation[binary_operation[member[.mIsRunning], ||, binary_operation[member[.mAnimationBackend], ==, literal[null]]], ||, binary_operation[call[mAnimationBackend.getFrameCount, par... | annotation[@] identifier[Override] Keyword[public] Keyword[void] identifier[start] operator[SEP] operator[SEP] {
Keyword[if] operator[SEP] identifier[mIsRunning] operator[||] identifier[mAnimationBackend] operator[==] Other[null] operator[||] identifier[mAnimationBackend] operator[SEP] identifier[getFrameCount] ... |
public void setRequestWaitTime(int requestWait) {
this.requestWait = requestWait;
this.getConfig().setProperty(SPIDER_REQUEST_WAIT, Integer.toString(requestWait));
} | class class_name[name] begin[{]
method[setRequestWaitTime, return_type[void], modifier[public], parameter[requestWait]] begin[{]
assign[THIS[member[None.requestWait]], member[.requestWait]]
THIS[call[None.getConfig, parameter[]]call[None.setProperty, parameter[member[.SPIDER_REQ... | Keyword[public] Keyword[void] identifier[setRequestWaitTime] operator[SEP] Keyword[int] identifier[requestWait] operator[SEP] {
Keyword[this] operator[SEP] identifier[requestWait] operator[=] identifier[requestWait] operator[SEP] Keyword[this] operator[SEP] identifier[getConfig] operator[SEP] operator[SEP] opera... |
private void onValidateEmbeddable(Object embeddedObject, EmbeddableType embeddedColumn)
{
if (embeddedObject instanceof Collection)
{
for (Object obj : (Collection) embeddedObject)
{
for (Object column : embeddedColumn.getAttributes())
... | class class_name[name] begin[{]
method[onValidateEmbeddable, return_type[void], modifier[private], parameter[embeddedObject, embeddedColumn]] begin[{]
if[binary_operation[member[.embeddedObject], instanceof, type[Collection]]] begin[{]
ForStatement(body=BlockStatement(label=None, st... | Keyword[private] Keyword[void] identifier[onValidateEmbeddable] operator[SEP] identifier[Object] identifier[embeddedObject] , identifier[EmbeddableType] identifier[embeddedColumn] operator[SEP] {
Keyword[if] operator[SEP] identifier[embeddedObject] Keyword[instanceof] identifier[Collection] operator[SEP] {
... |
private static boolean issues(X509CertImpl cert, X509CRLImpl crl,
String provider) throws IOException
{
boolean matched = false;
AdaptableX509CertSelector issuerSelector =
new AdaptableX509CertSelector();
// check certif... | class class_name[name] begin[{]
method[issues, return_type[type[boolean]], modifier[private static], parameter[cert, crl, provider]] begin[{]
local_variable[type[boolean], matched]
local_variable[type[AdaptableX509CertSelector], issuerSelector]
local_variable[type[boolean], usages]
... | Keyword[private] Keyword[static] Keyword[boolean] identifier[issues] operator[SEP] identifier[X509CertImpl] identifier[cert] , identifier[X509CRLImpl] identifier[crl] , identifier[String] identifier[provider] operator[SEP] Keyword[throws] identifier[IOException] {
Keyword[boolean] identifier[matched] operator[... |
private <I, D> void writeInternal(ObservationTable<I, D> table,
Function<? super Word<? extends I>, ? extends String> wordToString,
Function<? super D, ? extends String> outputToString,
Appendable out) thro... | class class_name[name] begin[{]
method[writeInternal, return_type[void], modifier[private], parameter[table, wordToString, outputToString, out]] begin[{]
local_variable[type[List], suffixes]
local_variable[type[int], numSuffixes]
local_variable[type[int], colWidth]
local_variabl... | Keyword[private] operator[<] identifier[I] , identifier[D] operator[>] Keyword[void] identifier[writeInternal] operator[SEP] identifier[ObservationTable] operator[<] identifier[I] , identifier[D] operator[>] identifier[table] , identifier[Function] operator[<] operator[?] Keyword[super] identifier[Word] operator[<] ... |
public boolean isServerInRecoveryMode() {
String thisMethodName = CLASS_NAME + ".isServerInRecoveryMode()";
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) {
SibTr.entry(tc, thisMethodName, this);
}
boolean ret = false;// (_serverMode == Server.RECOVERY_MO... | class class_name[name] begin[{]
method[isServerInRecoveryMode, return_type[type[boolean]], modifier[public], parameter[]] begin[{]
local_variable[type[String], thisMethodName]
if[binary_operation[call[TraceComponent.isAnyTracingEnabled, parameter[]], &&, call[tc.isEntryEnabled, paramete... | Keyword[public] Keyword[boolean] identifier[isServerInRecoveryMode] operator[SEP] operator[SEP] {
identifier[String] identifier[thisMethodName] operator[=] identifier[CLASS_NAME] operator[+] literal[String] operator[SEP] Keyword[if] operator[SEP] identifier[TraceComponent] operator[SEP] identifier[isAnyTracingEn... |
public static double[][] invert(double[][] weights, boolean normalize) {
double[][] result = new double[weights.length][weights[0].length];
for (int indexOfWeight = 0; indexOfWeight < weights.length; indexOfWeight++) {
if (normalize) {
double sum = 0;
for (int indexOfComponent = 0; indexOfCompone... | class class_name[name] begin[{]
method[invert, return_type[type[double]], modifier[public static], parameter[weights, normalize]] begin[{]
local_variable[type[double], result]
ForStatement(body=BlockStatement(label=None, statements=[IfStatement(condition=MemberReference(member=normalize, postfi... | Keyword[public] Keyword[static] Keyword[double] operator[SEP] operator[SEP] operator[SEP] operator[SEP] identifier[invert] operator[SEP] Keyword[double] operator[SEP] operator[SEP] operator[SEP] operator[SEP] identifier[weights] , Keyword[boolean] identifier[normalize] operator[SEP] {
Keyword[double] operator[S... |
@Override
public int compareTo(DistanceEntry<E> o) {
int comp = Double.compare(distance, o.distance);
return comp;
// return comp != 0 ? comp :
// entry.getEntryID().compareTo(o.entry.getEntryID());
} | class class_name[name] begin[{]
method[compareTo, return_type[type[int]], modifier[public], parameter[o]] begin[{]
local_variable[type[int], comp]
return[member[.comp]]
end[}]
END[}] | annotation[@] identifier[Override] Keyword[public] Keyword[int] identifier[compareTo] operator[SEP] identifier[DistanceEntry] operator[<] identifier[E] operator[>] identifier[o] operator[SEP] {
Keyword[int] identifier[comp] operator[=] identifier[Double] operator[SEP] identifier[compare] operator[SEP] identifier... |
public static <T,U> T identity(
@DelegatesTo.Target("self") U self,
@DelegatesTo(value=DelegatesTo.Target.class,
target="self",
strategy=Closure.DELEGATE_FIRST)
@ClosureParams(FirstParam.class)
Closure<T> closure) {
... | class class_name[name] begin[{]
method[identity, return_type[type[T]], modifier[public static], parameter[self, closure]] begin[{]
return[call[DefaultGroovyMethods.with, parameter[member[.self], member[.closure]]]]
end[}]
END[}] | Keyword[public] Keyword[static] operator[<] identifier[T] , identifier[U] operator[>] identifier[T] identifier[identity] operator[SEP] annotation[@] identifier[DelegatesTo] operator[SEP] identifier[Target] operator[SEP] literal[String] operator[SEP] identifier[U] identifier[self] , annotation[@] identifier[DelegatesT... |
@Override
public void chainStopped(ChainData chainData) {
final ActiveConfiguration cfg = currentConfig;
int oldState = chainState.getAndSet(ChainState.STOPPED.val);
if (oldState > ChainState.QUIESCED.val) {
quiesceChain();
}
// Wake up anything waiting for the ... | class class_name[name] begin[{]
method[chainStopped, return_type[void], modifier[public], parameter[chainData]] begin[{]
local_variable[type[ActiveConfiguration], cfg]
local_variable[type[int], oldState]
if[binary_operation[member[.oldState], >, member[ChainState.QUIESCED.val]]]... | annotation[@] identifier[Override] Keyword[public] Keyword[void] identifier[chainStopped] operator[SEP] identifier[ChainData] identifier[chainData] operator[SEP] {
Keyword[final] identifier[ActiveConfiguration] identifier[cfg] operator[=] identifier[currentConfig] operator[SEP] Keyword[int] identifier[oldState] ... |
private static SphereCluster calculateCenter(ArrayList<Cluster> assigned, int dimensions) {
double[] result = new double[dimensions];
for (int i = 0; i < result.length; i++) {
result[i] = 0.0;
}
if (assigned.size() == 0) {
return new SphereCluster(result, 0.0);
}
for (Cluster point : assigned) {
... | class class_name[name] begin[{]
method[calculateCenter, return_type[type[SphereCluster]], modifier[private static], parameter[assigned, dimensions]] begin[{]
local_variable[type[double], result]
ForStatement(body=BlockStatement(label=None, statements=[StatementExpression(expression=Assignment(e... | Keyword[private] Keyword[static] identifier[SphereCluster] identifier[calculateCenter] operator[SEP] identifier[ArrayList] operator[<] identifier[Cluster] operator[>] identifier[assigned] , Keyword[int] identifier[dimensions] operator[SEP] {
Keyword[double] operator[SEP] operator[SEP] identifier[result] operato... |
protected Set<String> getExclusions(AnnotationMetadata metadata,
AnnotationAttributes attributes) {
Set<String> excluded = new LinkedHashSet<>();
excluded.addAll(asList(attributes, "exclude"));
excluded.addAll(Arrays.asList(attributes.getStringArray("excludeName")));
excluded.addAll(getExcludeAutoConfigurati... | class class_name[name] begin[{]
method[getExclusions, return_type[type[Set]], modifier[protected], parameter[metadata, attributes]] begin[{]
local_variable[type[Set], excluded]
call[excluded.addAll, parameter[call[.asList, parameter[member[.attributes], literal["exclude"]]]]]
... | Keyword[protected] identifier[Set] operator[<] identifier[String] operator[>] identifier[getExclusions] operator[SEP] identifier[AnnotationMetadata] identifier[metadata] , identifier[AnnotationAttributes] identifier[attributes] operator[SEP] {
identifier[Set] operator[<] identifier[String] operator[>] identifie... |
public ListDeploymentsResult withDeployments(String... deployments) {
if (this.deployments == null) {
setDeployments(new com.amazonaws.internal.SdkInternalList<String>(deployments.length));
}
for (String ele : deployments) {
this.deployments.add(ele);
}
re... | class class_name[name] begin[{]
method[withDeployments, return_type[type[ListDeploymentsResult]], modifier[public], parameter[deployments]] begin[{]
if[binary_operation[THIS[member[None.deployments]], ==, literal[null]]] begin[{]
call[.setDeployments, parameter[ClassCrea... | Keyword[public] identifier[ListDeploymentsResult] identifier[withDeployments] operator[SEP] identifier[String] operator[...] identifier[deployments] operator[SEP] {
Keyword[if] operator[SEP] Keyword[this] operator[SEP] identifier[deployments] operator[==] Other[null] operator[SEP] {
identifier[setDepl... |
private static CloudStorageAccount tryConfigureDevStore(final Map<String, String> settings)
throws URISyntaxException {
if (matchesSpecification(
settings,
allRequired(USE_DEVELOPMENT_STORAGE_NAME),
optional(DEVELOPMENT_STORAGE_PROXY_URI_NAME))) {
... | class class_name[name] begin[{]
method[tryConfigureDevStore, return_type[type[CloudStorageAccount]], modifier[private static], parameter[settings]] begin[{]
if[call[.matchesSpecification, parameter[member[.settings], call[.allRequired, parameter[member[.USE_DEVELOPMENT_STORAGE_NAME]]], call[.op... | Keyword[private] Keyword[static] identifier[CloudStorageAccount] identifier[tryConfigureDevStore] operator[SEP] Keyword[final] identifier[Map] operator[<] identifier[String] , identifier[String] operator[>] identifier[settings] operator[SEP] Keyword[throws] identifier[URISyntaxException] {
Keyword[if] operator[... |
public static BufferedImage makeColorTransparent( BufferedImage bufferedImageToProcess, final Color colorToMakeTransparent ) {
ImageFilter filter = new RGBImageFilter(){
public int markerRGB = colorToMakeTransparent.getRGB() | 0xFF000000;
public final int filterRGB( int x, int y, int rgb... | class class_name[name] begin[{]
method[makeColorTransparent, return_type[type[BufferedImage]], modifier[public static], parameter[bufferedImageToProcess, colorToMakeTransparent]] begin[{]
local_variable[type[ImageFilter], filter]
local_variable[type[ImageProducer], ip]
local_variable[ty... | Keyword[public] Keyword[static] identifier[BufferedImage] identifier[makeColorTransparent] operator[SEP] identifier[BufferedImage] identifier[bufferedImageToProcess] , Keyword[final] identifier[Color] identifier[colorToMakeTransparent] operator[SEP] {
identifier[ImageFilter] identifier[filter] operator[=] Keywo... |
@Override
public void store(final Map<String, String> paramMap, final Map<String, Object> dataMap) {
final long startTime = System.currentTimeMillis();
final FessConfig fessConfig = ComponentUtil.getFessConfig();
final FessEsClient fessEsClient = ComponentUtil.getFessEsClient();
if ... | class class_name[name] begin[{]
method[store, return_type[void], modifier[public], parameter[paramMap, dataMap]] begin[{]
local_variable[type[long], startTime]
local_variable[type[FessConfig], fessConfig]
local_variable[type[FessEsClient], fessEsClient]
if[call[logger.is... | annotation[@] identifier[Override] Keyword[public] Keyword[void] identifier[store] operator[SEP] Keyword[final] identifier[Map] operator[<] identifier[String] , identifier[String] operator[>] identifier[paramMap] , Keyword[final] identifier[Map] operator[<] identifier[String] , identifier[Object] operator[>] identif... |
@Override
public ResourceBundlePathsIterator getBundlePaths(String bundleId,
ConditionalCommentCallbackHandler commentCallbackHandler, Map<String, String> variants) {
return rsHandler.getBundlePaths(bundleId, commentCallbackHandler, variants);
} | class class_name[name] begin[{]
method[getBundlePaths, return_type[type[ResourceBundlePathsIterator]], modifier[public], parameter[bundleId, commentCallbackHandler, variants]] begin[{]
return[call[rsHandler.getBundlePaths, parameter[member[.bundleId], member[.commentCallbackHandler], member[.variants]]... | annotation[@] identifier[Override] Keyword[public] identifier[ResourceBundlePathsIterator] identifier[getBundlePaths] operator[SEP] identifier[String] identifier[bundleId] , identifier[ConditionalCommentCallbackHandler] identifier[commentCallbackHandler] , identifier[Map] operator[<] identifier[String] , identifier[... |
public void shutdown() {
logger.info("Closing Retrieval Manager");
workerPool.shutdown();
try {
workerPool.awaitTermination(30, TimeUnit.MINUTES);
} catch (InterruptedException e) {
// Exit wait on interruption
}
complete = true;
} | class class_name[name] begin[{]
method[shutdown, return_type[void], modifier[public], parameter[]] begin[{]
call[logger.info, parameter[literal["Closing Retrieval Manager"]]]
call[workerPool.shutdown, parameter[]]
TryStatement(block=[StatementExpression(expression=Method... | Keyword[public] Keyword[void] identifier[shutdown] operator[SEP] operator[SEP] {
identifier[logger] operator[SEP] identifier[info] operator[SEP] literal[String] operator[SEP] operator[SEP] identifier[workerPool] operator[SEP] identifier[shutdown] operator[SEP] operator[SEP] operator[SEP] Keyword[try] {
... |
@Override
public IAtomContainer get(int i) {
Point3d[] tmp = coordinates.get(i);
for (int j = 0; j < atomContainer.getAtomCount(); j++) {
IAtom atom = atomContainer.getAtom(j);
atom.setPoint3d(tmp[j]);
}
return atomContainer;
} | class class_name[name] begin[{]
method[get, return_type[type[IAtomContainer]], modifier[public], parameter[i]] begin[{]
local_variable[type[Point3d], tmp]
ForStatement(body=BlockStatement(label=None, statements=[LocalVariableDeclaration(annotations=[], declarators=[VariableDeclarator(dimensions... | annotation[@] identifier[Override] Keyword[public] identifier[IAtomContainer] identifier[get] operator[SEP] Keyword[int] identifier[i] operator[SEP] {
identifier[Point3d] operator[SEP] operator[SEP] identifier[tmp] operator[=] identifier[coordinates] operator[SEP] identifier[get] operator[SEP] identifier[i] oper... |
@Deprecated
public static String collect(String string, CodePointFunction function)
{
return StringIterate.collectCodePoint(string, function);
} | class class_name[name] begin[{]
method[collect, return_type[type[String]], modifier[public static], parameter[string, function]] begin[{]
return[call[StringIterate.collectCodePoint, parameter[member[.string], member[.function]]]]
end[}]
END[}] | annotation[@] identifier[Deprecated] Keyword[public] Keyword[static] identifier[String] identifier[collect] operator[SEP] identifier[String] identifier[string] , identifier[CodePointFunction] identifier[function] operator[SEP] {
Keyword[return] identifier[StringIterate] operator[SEP] identifier[collectCodePoint... |
public static Socket safeClose(Socket socket) {
if (null != socket)
try {
socket.close();
socket = null;
}
catch (IOException e) {
throw Lang.wrapThrow(e);
}
return null;
} | class class_name[name] begin[{]
method[safeClose, return_type[type[Socket]], modifier[public static], parameter[socket]] begin[{]
if[binary_operation[literal[null], !=, member[.socket]]] begin[{]
TryStatement(block=[StatementExpression(expression=MethodInvocation(arguments=[], member=close, pos... | Keyword[public] Keyword[static] identifier[Socket] identifier[safeClose] operator[SEP] identifier[Socket] identifier[socket] operator[SEP] {
Keyword[if] operator[SEP] Other[null] operator[!=] identifier[socket] operator[SEP] Keyword[try] {
identifier[socket] operator[SEP] identifier[close] operator[SE... |
@Override
public void serviceRequest(final Request request) {
// Only apply for POST
if ("POST".equals(request.getMethod())) {
// Apply Controls (Use values on request)
SubordinateControlHelper.applyRegisteredControls(request, true);
}
// Service Request
super.serviceRequest(request);
} | class class_name[name] begin[{]
method[serviceRequest, return_type[void], modifier[public], parameter[request]] begin[{]
if[literal["POST"]] begin[{]
call[SubordinateControlHelper.applyRegisteredControls, parameter[member[.request], literal[true]]]
else begin[{]
... | annotation[@] identifier[Override] Keyword[public] Keyword[void] identifier[serviceRequest] operator[SEP] Keyword[final] identifier[Request] identifier[request] operator[SEP] {
Keyword[if] operator[SEP] literal[String] operator[SEP] identifier[equals] operator[SEP] identifier[request] operator[SEP] identifier[ge... |
private static void query(String filename) throws Exception
{
ProjectFile mpx = new UniversalProjectReader().read(filename);
listProjectProperties(mpx);
listResources(mpx);
listTasks(mpx);
listAssignments(mpx);
listAssignmentsByTask(mpx);
listAssignmentsByResource(mpx)... | class class_name[name] begin[{]
method[query, return_type[void], modifier[private static], parameter[filename]] begin[{]
local_variable[type[ProjectFile], mpx]
call[.listProjectProperties, parameter[member[.mpx]]]
call[.listResources, parameter[member[.mpx]]]
... | Keyword[private] Keyword[static] Keyword[void] identifier[query] operator[SEP] identifier[String] identifier[filename] operator[SEP] Keyword[throws] identifier[Exception] {
identifier[ProjectFile] identifier[mpx] operator[=] Keyword[new] identifier[UniversalProjectReader] operator[SEP] operator[SEP] operator[SEP... |
@Benchmark
@BenchmarkMode(Mode.SampleTime)
@OutputTimeUnit(TimeUnit.NANOSECONDS)
public CallOptions withOption() {
CallOptions opts = CallOptions.DEFAULT;
for (int i = 0; i < customOptions.size(); i++) {
opts = opts.withOption(customOptions.get(i), "value");
}
return opts;
} | class class_name[name] begin[{]
method[withOption, return_type[type[CallOptions]], modifier[public], parameter[]] begin[{]
local_variable[type[CallOptions], opts]
ForStatement(body=BlockStatement(label=None, statements=[StatementExpression(expression=Assignment(expressionl=MemberReference(membe... | annotation[@] identifier[Benchmark] annotation[@] identifier[BenchmarkMode] operator[SEP] identifier[Mode] operator[SEP] identifier[SampleTime] operator[SEP] annotation[@] identifier[OutputTimeUnit] operator[SEP] identifier[TimeUnit] operator[SEP] identifier[NANOSECONDS] operator[SEP] Keyword[public] identifier[CallOpt... |
@RequestMapping(value = "/v4-3/portlet/{fname}.html", method = RequestMethod.GET)
public @ResponseBody String getRenderedPortlet(
HttpServletRequest req, HttpServletResponse res, @PathVariable String fname) {
// Does the portlet exist in the registry?
final IPortletDefinition portletDef... | class class_name[name] begin[{]
method[getRenderedPortlet, return_type[type[String]], modifier[public], parameter[req, res, fname]] begin[{]
local_variable[type[IPortletDefinition], portletDef]
if[binary_operation[member[.portletDef], ==, literal[null]]] begin[{]
... | annotation[@] identifier[RequestMapping] operator[SEP] identifier[value] operator[=] literal[String] , identifier[method] operator[=] identifier[RequestMethod] operator[SEP] identifier[GET] operator[SEP] Keyword[public] annotation[@] identifier[ResponseBody] identifier[String] identifier[getRenderedPortlet] operator[S... |
public synchronized void addLiveObject( Com4jObject r ) {// TODO: why is this public?
if(r instanceof Wrapper) {
liveComObjects.add(((Wrapper)r).ref);
}
if(!listeners.isEmpty()) {
for( int i=listeners.size()-1; i>=0; i-- )
listeners.get(i).onNewObject(r);
... | class class_name[name] begin[{]
method[addLiveObject, return_type[void], modifier[synchronized public], parameter[r]] begin[{]
if[binary_operation[member[.r], instanceof, type[Wrapper]]] begin[{]
call[liveComObjects.add, parameter[Cast(expression=MemberReference(member=r... | Keyword[public] Keyword[synchronized] Keyword[void] identifier[addLiveObject] operator[SEP] identifier[Com4jObject] identifier[r] operator[SEP] {
Keyword[if] operator[SEP] identifier[r] Keyword[instanceof] identifier[Wrapper] operator[SEP] {
identifier[liveComObjects] operator[SEP] identifier[add] ope... |
public static Date toDate(String pString, String pFormat) {
// Get the format from cache, or create new and insert
// Return new date
return toDate(pString, new SimpleDateFormat(pFormat));
} | class class_name[name] begin[{]
method[toDate, return_type[type[Date]], modifier[public static], parameter[pString, pFormat]] begin[{]
return[call[.toDate, parameter[member[.pString], ClassCreator(arguments=[MemberReference(member=pFormat, postfix_operators=[], prefix_operators=[], qualifier=, selector... | Keyword[public] Keyword[static] identifier[Date] identifier[toDate] operator[SEP] identifier[String] identifier[pString] , identifier[String] identifier[pFormat] operator[SEP] {
Keyword[return] identifier[toDate] operator[SEP] identifier[pString] , Keyword[new] identifier[SimpleDateFormat] operator[SEP] identi... |
@SuppressWarnings("unchecked")
protected void fireEntryUpdated(K key, V value) {
for (final DMapListener<? super K, ? super V> listener : this.listeners.getListeners(DMapListener.class)) {
listener.entryUpdated(key, value);
}
} | class class_name[name] begin[{]
method[fireEntryUpdated, return_type[void], modifier[protected], parameter[key, value]] begin[{]
ForStatement(body=BlockStatement(label=None, statements=[StatementExpression(expression=MethodInvocation(arguments=[MemberReference(member=key, postfix_operators=[], prefix_o... | annotation[@] identifier[SuppressWarnings] operator[SEP] literal[String] operator[SEP] Keyword[protected] Keyword[void] identifier[fireEntryUpdated] operator[SEP] identifier[K] identifier[key] , identifier[V] identifier[value] operator[SEP] {
Keyword[for] operator[SEP] Keyword[final] identifier[DMapListener] op... |
public synchronized void setWorkbenchEntry(final WorkbenchEntry workbenchEntry) {
assert ! acquired : this;
this.workbenchEntry = workbenchEntry;
if (! isEmpty()) workbenchEntry.add(this, frontier.workbench);
} | class class_name[name] begin[{]
method[setWorkbenchEntry, return_type[void], modifier[synchronized public], parameter[workbenchEntry]] begin[{]
AssertStatement(condition=MemberReference(member=acquired, postfix_operators=[], prefix_operators=['!'], qualifier=, selectors=[]), label=None, value=This(post... | Keyword[public] Keyword[synchronized] Keyword[void] identifier[setWorkbenchEntry] operator[SEP] Keyword[final] identifier[WorkbenchEntry] identifier[workbenchEntry] operator[SEP] {
Keyword[assert] operator[!] identifier[acquired] operator[:] Keyword[this] operator[SEP] Keyword[this] operator[SEP] identifier[wor... |
public static LongStream uniform(int lowerBound, int upperBound, int events) {
return generate(new UniformLongGenerator(lowerBound, upperBound), events);
} | class class_name[name] begin[{]
method[uniform, return_type[type[LongStream]], modifier[public static], parameter[lowerBound, upperBound, events]] begin[{]
return[call[.generate, parameter[ClassCreator(arguments=[MemberReference(member=lowerBound, postfix_operators=[], prefix_operators=[], qualifier=, ... | Keyword[public] Keyword[static] identifier[LongStream] identifier[uniform] operator[SEP] Keyword[int] identifier[lowerBound] , Keyword[int] identifier[upperBound] , Keyword[int] identifier[events] operator[SEP] {
Keyword[return] identifier[generate] operator[SEP] Keyword[new] identifier[UniformLongGenerator] o... |
void andNot(LongBitSet other) {
int pos = Math.min(numWords, other.numWords);
while (--pos >= 0) {
bits[pos] &= ~other.bits[pos];
}
} | class class_name[name] begin[{]
method[andNot, return_type[void], modifier[default], parameter[other]] begin[{]
local_variable[type[int], pos]
while[binary_operation[member[.pos], >=, literal[0]]] begin[{]
assign[member[.bits], member[other.bits]]
end[}]
... | Keyword[void] identifier[andNot] operator[SEP] identifier[LongBitSet] identifier[other] operator[SEP] {
Keyword[int] identifier[pos] operator[=] identifier[Math] operator[SEP] identifier[min] operator[SEP] identifier[numWords] , identifier[other] operator[SEP] identifier[numWords] operator[SEP] operator[SEP] Ke... |
public SerDeserializers register(Class<?> type, SerDeserializer deserializer) {
deserializers.put(type, deserializer);
return this;
} | class class_name[name] begin[{]
method[register, return_type[type[SerDeserializers]], modifier[public], parameter[type, deserializer]] begin[{]
call[deserializers.put, parameter[member[.type], member[.deserializer]]]
return[THIS[]]
end[}]
END[}] | Keyword[public] identifier[SerDeserializers] identifier[register] operator[SEP] identifier[Class] operator[<] operator[?] operator[>] identifier[type] , identifier[SerDeserializer] identifier[deserializer] operator[SEP] {
identifier[deserializers] operator[SEP] identifier[put] operator[SEP] identifier[type] , ... |
private CompletableFuture<Long> submitAssignmentWithRetry(SegmentInfo segmentInfo, Duration timeout) {
return retryWithCleanup(() -> submitAssignment(segmentInfo, false, timeout));
} | class class_name[name] begin[{]
method[submitAssignmentWithRetry, return_type[type[CompletableFuture]], modifier[private], parameter[segmentInfo, timeout]] begin[{]
return[call[.retryWithCleanup, parameter[LambdaExpression(body=MethodInvocation(arguments=[MemberReference(member=segmentInfo, postfix_ope... | Keyword[private] identifier[CompletableFuture] operator[<] identifier[Long] operator[>] identifier[submitAssignmentWithRetry] operator[SEP] identifier[SegmentInfo] identifier[segmentInfo] , identifier[Duration] identifier[timeout] operator[SEP] {
Keyword[return] identifier[retryWithCleanup] operator[SEP] operat... |
protected boolean rememberMeRequested(HttpServletRequest request, String parameter) {
String rememberMe = request.getParameter(parameter);
if (rememberMe != null) {
if (rememberMe.equalsIgnoreCase("true") || rememberMe.equalsIgnoreCase("on")
|| rememberMe.equalsIgnoreCase("yes") || rememberMe.equals("1")) {... | class class_name[name] begin[{]
method[rememberMeRequested, return_type[type[boolean]], modifier[protected], parameter[request, parameter]] begin[{]
local_variable[type[String], rememberMe]
if[binary_operation[member[.rememberMe], !=, literal[null]]] begin[{]
if[... | Keyword[protected] Keyword[boolean] identifier[rememberMeRequested] operator[SEP] identifier[HttpServletRequest] identifier[request] , identifier[String] identifier[parameter] operator[SEP] {
identifier[String] identifier[rememberMe] operator[=] identifier[request] operator[SEP] identifier[getParameter] operato... |
public void saveModification(MaterialInstance materialInstance, Modification modification) {
modification.setMaterialInstance(materialInstance);
try {
getHibernateTemplate().saveOrUpdate(modification);
removeLatestCachedModification(materialInstance, modification);
re... | class class_name[name] begin[{]
method[saveModification, return_type[void], modifier[public], parameter[materialInstance, modification]] begin[{]
call[modification.setMaterialInstance, parameter[member[.materialInstance]]]
TryStatement(block=[StatementExpression(expression=MethodInvocat... | Keyword[public] Keyword[void] identifier[saveModification] operator[SEP] identifier[MaterialInstance] identifier[materialInstance] , identifier[Modification] identifier[modification] operator[SEP] {
identifier[modification] operator[SEP] identifier[setMaterialInstance] operator[SEP] identifier[materialInstance]... |
@Nonnull
@Override
public RunnableFuture<SnapshotResult<KeyedStateHandle>> snapshot(
final long checkpointId,
final long timestamp,
@Nonnull final CheckpointStreamFactory streamFactory,
@Nonnull CheckpointOptions checkpointOptions) throws Exception {
long startTime = System.currentTimeMillis();
// flush... | class class_name[name] begin[{]
method[snapshot, return_type[type[RunnableFuture]], modifier[public], parameter[checkpointId, timestamp, streamFactory, checkpointOptions]] begin[{]
local_variable[type[long], startTime]
call[writeBatchWrapper.flush, parameter[]]
local_variable[ty... | annotation[@] identifier[Nonnull] annotation[@] identifier[Override] Keyword[public] identifier[RunnableFuture] operator[<] identifier[SnapshotResult] operator[<] identifier[KeyedStateHandle] operator[>] operator[>] identifier[snapshot] operator[SEP] Keyword[final] Keyword[long] identifier[checkpointId] , Keyword[fina... |
void onSurfaceCreated() {
Log.v(TAG, "onSurfaceCreated");
Thread currentThread = Thread.currentThread();
// Reduce contention with other Android processes
currentThread.setPriority(Thread.MAX_PRIORITY);
// we know that the current thread is a GL one, so we store it to
... | class class_name[name] begin[{]
method[onSurfaceCreated, return_type[void], modifier[default], parameter[]] begin[{]
call[Log.v, parameter[member[.TAG], literal["onSurfaceCreated"]]]
local_variable[type[Thread], currentThread]
call[currentThread.setPriority, parameter[me... | Keyword[void] identifier[onSurfaceCreated] operator[SEP] operator[SEP] {
identifier[Log] operator[SEP] identifier[v] operator[SEP] identifier[TAG] , literal[String] operator[SEP] operator[SEP] identifier[Thread] identifier[currentThread] operator[=] identifier[Thread] operator[SEP] identifier[currentThread] ope... |
public synchronized boolean validate(java.io.PrintStream printStream)
throws ObjectManagerException
{
if (Tracing.isAnyTracingEnabled() && trace.isEntryEnabled())
trace.entry(this,
cclass,
"validate",
new... | class class_name[name] begin[{]
method[validate, return_type[type[boolean]], modifier[synchronized public], parameter[printStream]] begin[{]
if[binary_operation[call[Tracing.isAnyTracingEnabled, parameter[]], &&, call[trace.isEntryEnabled, parameter[]]]] begin[{]
call[trace.entry, p... | Keyword[public] Keyword[synchronized] Keyword[boolean] identifier[validate] operator[SEP] identifier[java] operator[SEP] identifier[io] operator[SEP] identifier[PrintStream] identifier[printStream] operator[SEP] Keyword[throws] identifier[ObjectManagerException] {
Keyword[if] operator[SEP] identifier[Tracing] op... |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.