code stringlengths 63 466k | code_sememe stringlengths 141 3.79M | token_type stringlengths 274 1.23M |
|---|---|---|
public static <E> ImmutableList<ImmutableList<E>> partitionAlmostEvenly(final List<E> list,
final int partitions) {
checkNotNull(list);
checkArgument(partitions > 0,
"Number of partitions must be positive");
checkArgument(partitions <= list.size(),
"Cannot request more partitions than ... | class class_name[name] begin[{]
method[partitionAlmostEvenly, return_type[type[ImmutableList]], modifier[public static], parameter[list, partitions]] begin[{]
call[.checkNotNull, parameter[member[.list]]]
call[.checkArgument, parameter[binary_operation[member[.partitions], >, li... | Keyword[public] Keyword[static] operator[<] identifier[E] operator[>] identifier[ImmutableList] operator[<] identifier[ImmutableList] operator[<] identifier[E] operator[>] operator[>] identifier[partitionAlmostEvenly] operator[SEP] Keyword[final] identifier[List] operator[<] identifier[E] operator[>] identifier[list] ,... |
final public String explainScore(String s, String t) {
return explainScore(prepare(s),prepare(t));
} | class class_name[name] begin[{]
method[explainScore, return_type[type[String]], modifier[final public], parameter[s, t]] begin[{]
return[call[.explainScore, parameter[call[.prepare, parameter[member[.s]]], call[.prepare, parameter[member[.t]]]]]]
end[}]
END[}] | Keyword[final] Keyword[public] identifier[String] identifier[explainScore] operator[SEP] identifier[String] identifier[s] , identifier[String] identifier[t] operator[SEP] {
Keyword[return] identifier[explainScore] operator[SEP] identifier[prepare] operator[SEP] identifier[s] operator[SEP] , identifier[prepare]... |
public void setFaceMatches(java.util.Collection<CompareFacesMatch> faceMatches) {
if (faceMatches == null) {
this.faceMatches = null;
return;
}
this.faceMatches = new java.util.ArrayList<CompareFacesMatch>(faceMatches);
} | class class_name[name] begin[{]
method[setFaceMatches, return_type[void], modifier[public], parameter[faceMatches]] begin[{]
if[binary_operation[member[.faceMatches], ==, literal[null]]] begin[{]
assign[THIS[member[None.faceMatches]], literal[null]]
return[No... | Keyword[public] Keyword[void] identifier[setFaceMatches] operator[SEP] identifier[java] operator[SEP] identifier[util] operator[SEP] identifier[Collection] operator[<] identifier[CompareFacesMatch] operator[>] identifier[faceMatches] operator[SEP] {
Keyword[if] operator[SEP] identifier[faceMatches] operator[==] ... |
public Response<Double> incrByFloat(final String key, final double increment) {
writeAsync(key, () -> shadowPipeline.incrByFloat(key, increment));
return DynoDualWriterPipeline.super.incrByFloat(key,increment);
} | class class_name[name] begin[{]
method[incrByFloat, return_type[type[Response]], modifier[public], parameter[key, increment]] begin[{]
call[.writeAsync, parameter[member[.key], LambdaExpression(body=MethodInvocation(arguments=[MemberReference(member=key, postfix_operators=[], prefix_operators=[... | Keyword[public] identifier[Response] operator[<] identifier[Double] operator[>] identifier[incrByFloat] operator[SEP] Keyword[final] identifier[String] identifier[key] , Keyword[final] Keyword[double] identifier[increment] operator[SEP] {
identifier[writeAsync] operator[SEP] identifier[key] , operator[SEP] ope... |
public MessageToSend prepareMessageToSend() {
originalMessage.getParts().clear();
originalMessage.getParts().addAll(publicParts);
return originalMessage;
} | class class_name[name] begin[{]
method[prepareMessageToSend, return_type[type[MessageToSend]], modifier[public], parameter[]] begin[{]
call[originalMessage.getParts, parameter[]]
call[originalMessage.getParts, parameter[]]
return[member[.originalMessage]]
end[}]
END[... | Keyword[public] identifier[MessageToSend] identifier[prepareMessageToSend] operator[SEP] operator[SEP] {
identifier[originalMessage] operator[SEP] identifier[getParts] operator[SEP] operator[SEP] operator[SEP] identifier[clear] operator[SEP] operator[SEP] operator[SEP] identifier[originalMessage] operator[SEP] i... |
@Override
public MediaFeed searchMedia(double latitude, double longitude, int distance)
throws InstagramException {
Map<String, String> params = new HashMap<String, String>();
params.put(QueryParam.LATITUDE, Double.toString(latitude));
params.put(QueryParam.LONGITUDE, Double.to... | class class_name[name] begin[{]
method[searchMedia, return_type[type[MediaFeed]], modifier[public], parameter[latitude, longitude, distance]] begin[{]
local_variable[type[Map], params]
call[params.put, parameter[member[QueryParam.LATITUDE], call[Double.toString, parameter[member[.latitu... | annotation[@] identifier[Override] Keyword[public] identifier[MediaFeed] identifier[searchMedia] operator[SEP] Keyword[double] identifier[latitude] , Keyword[double] identifier[longitude] , Keyword[int] identifier[distance] operator[SEP] Keyword[throws] identifier[InstagramException] {
identifier[Map] operator... |
private Violation isFieldImmutable(
Optional<Tree> tree,
ImmutableSet<String> immutableTyParams,
ClassSymbol classSym,
ClassType classType,
VarSymbol var,
ViolationReporter reporter) {
if (bugChecker.isSuppressed(var)) {
return Violation.absent();
}
if (!var.getModi... | class class_name[name] begin[{]
method[isFieldImmutable, return_type[type[Violation]], modifier[private], parameter[tree, immutableTyParams, classSym, classType, var, reporter]] begin[{]
if[call[bugChecker.isSuppressed, parameter[member[.var]]]] begin[{]
return[call[Violation.absent... | Keyword[private] identifier[Violation] identifier[isFieldImmutable] operator[SEP] identifier[Optional] operator[<] identifier[Tree] operator[>] identifier[tree] , identifier[ImmutableSet] operator[<] identifier[String] operator[>] identifier[immutableTyParams] , identifier[ClassSymbol] identifier[classSym] , identif... |
public void setConnectionLostTimeout( int connectionLostTimeout ) {
synchronized (syncConnectionLost) {
this.connectionLostTimeout = TimeUnit.SECONDS.toNanos(connectionLostTimeout);
if (this.connectionLostTimeout <= 0) {
log.trace("Connection lost timer stopped");
... | class class_name[name] begin[{]
method[setConnectionLostTimeout, return_type[void], modifier[public], parameter[connectionLostTimeout]] begin[{]
SYNCHRONIZED[member[.syncConnectionLost]] BEGIN[{]
assign[THIS[member[None.connectionLostTimeout]], call[TimeUnit.SECONDS.toNa... | Keyword[public] Keyword[void] identifier[setConnectionLostTimeout] operator[SEP] Keyword[int] identifier[connectionLostTimeout] operator[SEP] {
Keyword[synchronized] operator[SEP] identifier[syncConnectionLost] operator[SEP] {
Keyword[this] operator[SEP] identifier[connectionLostTimeout] operator[=] i... |
public void verify(PublicKey key)
throws CRLException, NoSuchAlgorithmException, InvalidKeyException,
NoSuchProviderException, SignatureException {
verify(key, "");
} | class class_name[name] begin[{]
method[verify, return_type[void], modifier[public], parameter[key]] begin[{]
call[.verify, parameter[member[.key], literal[""]]]
end[}]
END[}] | Keyword[public] Keyword[void] identifier[verify] operator[SEP] identifier[PublicKey] identifier[key] operator[SEP] Keyword[throws] identifier[CRLException] , identifier[NoSuchAlgorithmException] , identifier[InvalidKeyException] , identifier[NoSuchProviderException] , identifier[SignatureException] {
identif... |
public AzkabanClientStatus deleteProject(String projectName) throws AzkabanClientException {
AzkabanMultiCallables.DeleteProjectCallable callable =
AzkabanMultiCallables.DeleteProjectCallable.builder()
.client(this)
.projectName(projectName)
.build();
return runWith... | class class_name[name] begin[{]
method[deleteProject, return_type[type[AzkabanClientStatus]], modifier[public], parameter[projectName]] begin[{]
local_variable[type[AzkabanMultiCallables], callable]
return[call[.runWithRetry, parameter[member[.callable], ClassReference(postfix_operators=[], pre... | Keyword[public] identifier[AzkabanClientStatus] identifier[deleteProject] operator[SEP] identifier[String] identifier[projectName] operator[SEP] Keyword[throws] identifier[AzkabanClientException] {
identifier[AzkabanMultiCallables] operator[SEP] identifier[DeleteProjectCallable] identifier[callable] operator[=] ... |
public Iterable<Vertex> getVertices(final String iKey, Object iValue) {
makeActive();
if (iKey.equals("@class"))
return getVerticesOfClass(iValue.toString());
int pos = iKey.indexOf('.');
final String className = pos > -1 ? iKey.substring(0, pos) : OrientVertexType.CLASS_NAME;
final String k... | class class_name[name] begin[{]
method[getVertices, return_type[type[Iterable]], modifier[public], parameter[iKey, iValue]] begin[{]
call[.makeActive, parameter[]]
if[call[iKey.equals, parameter[literal["@class"]]]] begin[{]
return[call[.getVerticesOfClass, parameter[call[iValue... | Keyword[public] identifier[Iterable] operator[<] identifier[Vertex] operator[>] identifier[getVertices] operator[SEP] Keyword[final] identifier[String] identifier[iKey] , identifier[Object] identifier[iValue] operator[SEP] {
identifier[makeActive] operator[SEP] operator[SEP] operator[SEP] Keyword[if] operator[S... |
private static void processEmoticonsToRegex() {
List<String> emoticons=new ArrayList<String>();
for(Emoji e: emojiData) {
if(e.getEmoticons()!=null) {
emoticons.addAll(e.getEmoticons());
}
}
//List of emotions should be pre-processed to handle instances of subtrings like :-) :-
//Without th... | class class_name[name] begin[{]
method[processEmoticonsToRegex, return_type[void], modifier[private static], parameter[]] begin[{]
local_variable[type[List], emoticons]
ForStatement(body=BlockStatement(label=None, statements=[IfStatement(condition=BinaryOperation(operandl=MethodInvocation(argum... | Keyword[private] Keyword[static] Keyword[void] identifier[processEmoticonsToRegex] operator[SEP] operator[SEP] {
identifier[List] operator[<] identifier[String] operator[>] identifier[emoticons] operator[=] Keyword[new] identifier[ArrayList] operator[<] identifier[String] operator[>] operator[SEP] operator[SEP] ... |
protected boolean tomcatIsRunning() {
CloseableHttpClient client= HttpClients.createDefault();
CloseableHttpResponse response = null;
try {
HttpGet httpget = new HttpGet("http://localhost:" + getPort() + "/alfresco");
response = client.execute(httpget);
get... | class class_name[name] begin[{]
method[tomcatIsRunning, return_type[type[boolean]], modifier[protected], parameter[]] begin[{]
local_variable[type[CloseableHttpClient], client]
local_variable[type[CloseableHttpResponse], response]
TryStatement(block=[LocalVariableDeclaration(annotations... | Keyword[protected] Keyword[boolean] identifier[tomcatIsRunning] operator[SEP] operator[SEP] {
identifier[CloseableHttpClient] identifier[client] operator[=] identifier[HttpClients] operator[SEP] identifier[createDefault] operator[SEP] operator[SEP] operator[SEP] identifier[CloseableHttpResponse] identifier[respo... |
protected SerializationPolicy getSerializationPolicy(CmsObject cms, String moduleBaseURL, String strongName) {
if (m_serializationPolicyPath == null) {
m_serializationPolicyPath = getSerializationPolicyPath(moduleBaseURL, strongName);
}
return getSerializationPolicy(cms);
} | class class_name[name] begin[{]
method[getSerializationPolicy, return_type[type[SerializationPolicy]], modifier[protected], parameter[cms, moduleBaseURL, strongName]] begin[{]
if[binary_operation[member[.m_serializationPolicyPath], ==, literal[null]]] begin[{]
assign[mem... | Keyword[protected] identifier[SerializationPolicy] identifier[getSerializationPolicy] operator[SEP] identifier[CmsObject] identifier[cms] , identifier[String] identifier[moduleBaseURL] , identifier[String] identifier[strongName] operator[SEP] {
Keyword[if] operator[SEP] identifier[m_serializationPolicyPath] op... |
private void notifyHandlers(Room sfsRoom, User sfsUser) {
ApiRoom apiRoom = AgentUtil.getRoomAgent(sfsRoom);
ApiUser apiUser = AgentUtil.getUserAgent(sfsUser);
for(RoomHandlerClass handler : handlers) {
Object userAgent = checkUserAgent(handler, apiUser);
if(!checkHandler... | class class_name[name] begin[{]
method[notifyHandlers, return_type[void], modifier[private], parameter[sfsRoom, sfsUser]] begin[{]
local_variable[type[ApiRoom], apiRoom]
local_variable[type[ApiUser], apiUser]
ForStatement(body=BlockStatement(label=None, statements=[LocalVariableDeclarat... | Keyword[private] Keyword[void] identifier[notifyHandlers] operator[SEP] identifier[Room] identifier[sfsRoom] , identifier[User] identifier[sfsUser] operator[SEP] {
identifier[ApiRoom] identifier[apiRoom] operator[=] identifier[AgentUtil] operator[SEP] identifier[getRoomAgent] operator[SEP] identifier[sfsRoom] o... |
public void fireQueryChanged(String newgroup, String newquery, String newid) {
for (SavedQueriesPanelListener listener : listeners) {
listener.selectedQueryChanged(newgroup, newquery, newid);
}
} | class class_name[name] begin[{]
method[fireQueryChanged, return_type[void], modifier[public], parameter[newgroup, newquery, newid]] begin[{]
ForStatement(body=BlockStatement(label=None, statements=[StatementExpression(expression=MethodInvocation(arguments=[MemberReference(member=newgroup, postfix_opera... | Keyword[public] Keyword[void] identifier[fireQueryChanged] operator[SEP] identifier[String] identifier[newgroup] , identifier[String] identifier[newquery] , identifier[String] identifier[newid] operator[SEP] {
Keyword[for] operator[SEP] identifier[SavedQueriesPanelListener] identifier[listener] operator[:] id... |
public static Fetch createDefaultAttributeFetch(Attribute attr, String languageCode) {
Fetch fetch;
if (isReferenceType(attr)) {
fetch = new Fetch();
EntityType refEntityType = attr.getRefEntity();
String idAttrName = refEntityType.getIdAttribute().getName();
fetch.field(idAttrName);
... | class class_name[name] begin[{]
method[createDefaultAttributeFetch, return_type[type[Fetch]], modifier[public static], parameter[attr, languageCode]] begin[{]
local_variable[type[Fetch], fetch]
if[call[.isReferenceType, parameter[member[.attr]]]] begin[{]
assign[... | Keyword[public] Keyword[static] identifier[Fetch] identifier[createDefaultAttributeFetch] operator[SEP] identifier[Attribute] identifier[attr] , identifier[String] identifier[languageCode] operator[SEP] {
identifier[Fetch] identifier[fetch] operator[SEP] Keyword[if] operator[SEP] identifier[isReferenceType] ope... |
@SuppressWarnings("rawtypes")
@Override
public List getSerListFromCtObjChart(final Object ctObjChart) {
if (ctObjChart instanceof CTBarChart) {
return ((CTBarChart) ctObjChart).getSerList();
}
return emptySerlist;
} | class class_name[name] begin[{]
method[getSerListFromCtObjChart, return_type[type[List]], modifier[public], parameter[ctObjChart]] begin[{]
if[binary_operation[member[.ctObjChart], instanceof, type[CTBarChart]]] begin[{]
return[Cast(expression=MemberReference(member=ctObjChart, post... | annotation[@] identifier[SuppressWarnings] operator[SEP] literal[String] operator[SEP] annotation[@] identifier[Override] Keyword[public] identifier[List] identifier[getSerListFromCtObjChart] operator[SEP] Keyword[final] identifier[Object] identifier[ctObjChart] operator[SEP] {
Keyword[if] operator[SEP] identifi... |
@Override
public final void unlock(int handle) throws DataStoreException
{
if (SAFE_MODE) checkHandle(handle);
if (locks.flip(handle))
{
locks.flip(handle); // Restore state
throw new DataStoreException("Handle was not locked : "+handle);
}
} | class class_name[name] begin[{]
method[unlock, return_type[void], modifier[final public], parameter[handle]] begin[{]
if[member[.SAFE_MODE]] begin[{]
call[.checkHandle, parameter[member[.handle]]]
else begin[{]
None
end[}]
if[call[locks.flip, paramete... | annotation[@] identifier[Override] Keyword[public] Keyword[final] Keyword[void] identifier[unlock] operator[SEP] Keyword[int] identifier[handle] operator[SEP] Keyword[throws] identifier[DataStoreException] {
Keyword[if] operator[SEP] identifier[SAFE_MODE] operator[SEP] identifier[checkHandle] operator[SEP] ident... |
public static <E> E toObject(Class<E> clazz, List<Entity> entities,
Map<com.google.appengine.api.datastore.Key, Object> references,
AppEngineDatastoreService datastore) {
return toObject(clazz, entities, references, datastore, 0);
} | class class_name[name] begin[{]
method[toObject, return_type[type[E]], modifier[public static], parameter[clazz, entities, references, datastore]] begin[{]
return[call[.toObject, parameter[member[.clazz], member[.entities], member[.references], member[.datastore], literal[0]]]]
end[}]
END[}] | Keyword[public] Keyword[static] operator[<] identifier[E] operator[>] identifier[E] identifier[toObject] operator[SEP] identifier[Class] operator[<] identifier[E] operator[>] identifier[clazz] , identifier[List] operator[<] identifier[Entity] operator[>] identifier[entities] , identifier[Map] operator[<] identifier[c... |
public static int[] getAppWidgetIds(AppWidgetManager appWidgetManager, Context context, Class<?> clazz) {
return appWidgetManager.getAppWidgetIds(new ComponentName(context, clazz));
} | class class_name[name] begin[{]
method[getAppWidgetIds, return_type[type[int]], modifier[public static], parameter[appWidgetManager, context, clazz]] begin[{]
return[call[appWidgetManager.getAppWidgetIds, parameter[ClassCreator(arguments=[MemberReference(member=context, postfix_operators=[], prefix_ope... | Keyword[public] Keyword[static] Keyword[int] operator[SEP] operator[SEP] identifier[getAppWidgetIds] operator[SEP] identifier[AppWidgetManager] identifier[appWidgetManager] , identifier[Context] identifier[context] , identifier[Class] operator[<] operator[?] operator[>] identifier[clazz] operator[SEP] {
Keywor... |
@Override
protected void doHandle(CommandContext ctx) throws CommandLineException {
final ForControlFlow forCF = ForControlFlow.get(ctx);
if (forCF == null) {
throw new CommandLineException("done is not available outside 'for' loop");
}
forCF.run(ctx, discard.isPresent(c... | class class_name[name] begin[{]
method[doHandle, return_type[void], modifier[protected], parameter[ctx]] begin[{]
local_variable[type[ForControlFlow], forCF]
if[binary_operation[member[.forCF], ==, literal[null]]] begin[{]
ThrowStatement(expression=ClassCreator(arguments=[Li... | annotation[@] identifier[Override] Keyword[protected] Keyword[void] identifier[doHandle] operator[SEP] identifier[CommandContext] identifier[ctx] operator[SEP] Keyword[throws] identifier[CommandLineException] {
Keyword[final] identifier[ForControlFlow] identifier[forCF] operator[=] identifier[ForControlFlow] ope... |
private CompletableFuture<Void> applyInitialize(Indexed<InitializeEntry> entry) {
for (RaftServiceContext service : raft.getServices()) {
service.keepAliveSessions(entry.index(), entry.entry().timestamp());
}
return CompletableFuture.completedFuture(null);
} | class class_name[name] begin[{]
method[applyInitialize, return_type[type[CompletableFuture]], modifier[private], parameter[entry]] begin[{]
ForStatement(body=BlockStatement(label=None, statements=[StatementExpression(expression=MethodInvocation(arguments=[MethodInvocation(arguments=[], member=index, po... | Keyword[private] identifier[CompletableFuture] operator[<] identifier[Void] operator[>] identifier[applyInitialize] operator[SEP] identifier[Indexed] operator[<] identifier[InitializeEntry] operator[>] identifier[entry] operator[SEP] {
Keyword[for] operator[SEP] identifier[RaftServiceContext] identifier[service]... |
public synchronized void removeSessionLogs(SessionId sessionId) {
if (storeLogsOnSessionQuit) {
return;
}
ThreadKey threadId = sessionToThreadMap.get(sessionId);
SessionId sessionIdForThread = threadToSessionMap.get(threadId);
if (threadId != null && sessionIdForThread != null && sessionIdForT... | class class_name[name] begin[{]
method[removeSessionLogs, return_type[void], modifier[synchronized public], parameter[sessionId]] begin[{]
if[member[.storeLogsOnSessionQuit]] begin[{]
return[None]
else begin[{]
None
end[}]
local_variable[type[ThreadKey], thre... | Keyword[public] Keyword[synchronized] Keyword[void] identifier[removeSessionLogs] operator[SEP] identifier[SessionId] identifier[sessionId] operator[SEP] {
Keyword[if] operator[SEP] identifier[storeLogsOnSessionQuit] operator[SEP] {
Keyword[return] operator[SEP]
}
identifier[ThreadKey] i... |
public static String cutFromIndexOf(String string, final String substring) {
int i = string.indexOf(substring);
if (i != -1) {
string = string.substring(i);
}
return string;
} | class class_name[name] begin[{]
method[cutFromIndexOf, return_type[type[String]], modifier[public static], parameter[string, substring]] begin[{]
local_variable[type[int], i]
if[binary_operation[member[.i], !=, literal[1]]] begin[{]
assign[member[.string], call[s... | Keyword[public] Keyword[static] identifier[String] identifier[cutFromIndexOf] operator[SEP] identifier[String] identifier[string] , Keyword[final] identifier[String] identifier[substring] operator[SEP] {
Keyword[int] identifier[i] operator[=] identifier[string] operator[SEP] identifier[indexOf] operator[SEP] id... |
public boolean replace(final int key, final int oldValue, final int newValue)
{
final int curValue = get(key);
if (curValue != oldValue || curValue == missingValue)
{
return false;
}
put(key, newValue);
return true;
} | class class_name[name] begin[{]
method[replace, return_type[type[boolean]], modifier[public], parameter[key, oldValue, newValue]] begin[{]
local_variable[type[int], curValue]
if[binary_operation[binary_operation[member[.curValue], !=, member[.oldValue]], ||, binary_operation[member[.cur... | Keyword[public] Keyword[boolean] identifier[replace] operator[SEP] Keyword[final] Keyword[int] identifier[key] , Keyword[final] Keyword[int] identifier[oldValue] , Keyword[final] Keyword[int] identifier[newValue] operator[SEP] {
Keyword[final] Keyword[int] identifier[curValue] operator[=] identifier[get] opera... |
public EClass getIfcCrewResource() {
if (ifcCrewResourceEClass == null) {
ifcCrewResourceEClass = (EClass) EPackage.Registry.INSTANCE.getEPackage(Ifc2x3tc1Package.eNS_URI)
.getEClassifiers().get(129);
}
return ifcCrewResourceEClass;
} | class class_name[name] begin[{]
method[getIfcCrewResource, return_type[type[EClass]], modifier[public], parameter[]] begin[{]
if[binary_operation[member[.ifcCrewResourceEClass], ==, literal[null]]] begin[{]
assign[member[.ifcCrewResourceEClass], Cast(expression=MethodInv... | Keyword[public] identifier[EClass] identifier[getIfcCrewResource] operator[SEP] operator[SEP] {
Keyword[if] operator[SEP] identifier[ifcCrewResourceEClass] operator[==] Other[null] operator[SEP] {
identifier[ifcCrewResourceEClass] operator[=] operator[SEP] identifier[EClass] operator[SEP] identifier[E... |
public static List<Integer> arrayToList(int[] array, int codeLen) {
List<Integer> result = new ArrayList<>();
for (int x = 0; x < codeLen; x++) {
result.add(array[x]);
}
return result;
} | class class_name[name] begin[{]
method[arrayToList, return_type[type[List]], modifier[public static], parameter[array, codeLen]] begin[{]
local_variable[type[List], result]
ForStatement(body=BlockStatement(label=None, statements=[StatementExpression(expression=MethodInvocation(arguments=[Member... | Keyword[public] Keyword[static] identifier[List] operator[<] identifier[Integer] operator[>] identifier[arrayToList] operator[SEP] Keyword[int] operator[SEP] operator[SEP] identifier[array] , Keyword[int] identifier[codeLen] operator[SEP] {
identifier[List] operator[<] identifier[Integer] operator[>] identifier... |
@NonNull
public List<Span> getSpans(int start, int end) {
final int length = length();
if (!isPositionValid(length, start, end)) {
// we might as well throw here
return Collections.emptyList();
}
// all requested
if (start == 0
&& le... | class class_name[name] begin[{]
method[getSpans, return_type[type[List]], modifier[public], parameter[start, end]] begin[{]
local_variable[type[int], length]
if[call[.isPositionValid, parameter[member[.length], member[.start], member[.end]]]] begin[{]
return[call[Collections... | annotation[@] identifier[NonNull] Keyword[public] identifier[List] operator[<] identifier[Span] operator[>] identifier[getSpans] operator[SEP] Keyword[int] identifier[start] , Keyword[int] identifier[end] operator[SEP] {
Keyword[final] Keyword[int] identifier[length] operator[=] identifier[length] operator[SEP]... |
public com.google.api.ads.admanager.axis.v201808.CreativeAsset getFallbackImageAsset() {
return fallbackImageAsset;
} | class class_name[name] begin[{]
method[getFallbackImageAsset, return_type[type[com]], modifier[public], parameter[]] begin[{]
return[member[.fallbackImageAsset]]
end[}]
END[}] | Keyword[public] identifier[com] operator[SEP] identifier[google] operator[SEP] identifier[api] operator[SEP] identifier[ads] operator[SEP] identifier[admanager] operator[SEP] identifier[axis] operator[SEP] identifier[v201808] operator[SEP] identifier[CreativeAsset] identifier[getFallbackImageAsset] operator[SEP] operat... |
public static DatagramPacket buildPacket(PacketType type, ByteBuffer deviceName, ByteBuffer payload) {
ByteBuffer content = ByteBuffer.allocate(0x1f + payload.remaining());
content.put(getMagicHeader());
content.put(type.protocolValue);
content.put(deviceName);
content.put(payloa... | class class_name[name] begin[{]
method[buildPacket, return_type[type[DatagramPacket]], modifier[public static], parameter[type, deviceName, payload]] begin[{]
local_variable[type[ByteBuffer], content]
call[content.put, parameter[call[.getMagicHeader, parameter[]]]]
call[... | Keyword[public] Keyword[static] identifier[DatagramPacket] identifier[buildPacket] operator[SEP] identifier[PacketType] identifier[type] , identifier[ByteBuffer] identifier[deviceName] , identifier[ByteBuffer] identifier[payload] operator[SEP] {
identifier[ByteBuffer] identifier[content] operator[=] identifier... |
protected List<String> extractWords() throws IOException
{
while( true ) {
lineNumber++;
String line = in.readLine();
if( line == null ) {
return null;
}
// skip comment lines
if( hasComment ) {
if( line... | class class_name[name] begin[{]
method[extractWords, return_type[type[List]], modifier[protected], parameter[]] begin[{]
while[literal[true]] begin[{]
member[.lineNumber]
local_variable[type[String], line]
if[binary_operation[member[.l... | Keyword[protected] identifier[List] operator[<] identifier[String] operator[>] identifier[extractWords] operator[SEP] operator[SEP] Keyword[throws] identifier[IOException] {
Keyword[while] operator[SEP] literal[boolean] operator[SEP] {
identifier[lineNumber] operator[++] operator[SEP] identifier[Strin... |
@Override
public ImmutableSet<Cell<V>> cells() {
ImmutableSet<Cell<V>> c = cellSet;
if (c == null) {
c = ImmutableSet.copyOf(cells);
cellSet = c;
}
return c;
} | class class_name[name] begin[{]
method[cells, return_type[type[ImmutableSet]], modifier[public], parameter[]] begin[{]
local_variable[type[ImmutableSet], c]
if[binary_operation[member[.c], ==, literal[null]]] begin[{]
assign[member[.c], call[ImmutableSet.copyOf, ... | annotation[@] identifier[Override] Keyword[public] identifier[ImmutableSet] operator[<] identifier[Cell] operator[<] identifier[V] operator[>] operator[>] identifier[cells] operator[SEP] operator[SEP] {
identifier[ImmutableSet] operator[<] identifier[Cell] operator[<] identifier[V] operator[>] operator[>] identi... |
public void marshall(BatchDeleteImportDataError batchDeleteImportDataError, ProtocolMarshaller protocolMarshaller) {
if (batchDeleteImportDataError == null) {
throw new SdkClientException("Invalid argument passed to marshall(...)");
}
try {
protocolMarshaller.marshall(b... | class class_name[name] begin[{]
method[marshall, return_type[void], modifier[public], parameter[batchDeleteImportDataError, protocolMarshaller]] begin[{]
if[binary_operation[member[.batchDeleteImportDataError], ==, literal[null]]] begin[{]
ThrowStatement(expression=ClassCreator(argu... | Keyword[public] Keyword[void] identifier[marshall] operator[SEP] identifier[BatchDeleteImportDataError] identifier[batchDeleteImportDataError] , identifier[ProtocolMarshaller] identifier[protocolMarshaller] operator[SEP] {
Keyword[if] operator[SEP] identifier[batchDeleteImportDataError] operator[==] Other[null]... |
public final TreeModelFilter<SQLPPTriplesMap> type() throws RecognitionException {
TreeModelFilter<SQLPPTriplesMap> value = null;
try {
// C:\\Project\\Obdalib\\obdalib-parent\\obdalib-core\\src\\main\\java\\it\\unibz\\inf\\obda\\gui\\swing\\utils\\MappingFilter.g:69:3: ( ID | TEXT | TARGE... | class class_name[name] begin[{]
method[type, return_type[type[TreeModelFilter]], modifier[final public], parameter[]] begin[{]
local_variable[type[TreeModelFilter], value]
TryStatement(block=[LocalVariableDeclaration(annotations=[], declarators=[VariableDeclarator(dimensions=[], initializer=Lit... | Keyword[public] Keyword[final] identifier[TreeModelFilter] operator[<] identifier[SQLPPTriplesMap] operator[>] identifier[type] operator[SEP] operator[SEP] Keyword[throws] identifier[RecognitionException] {
identifier[TreeModelFilter] operator[<] identifier[SQLPPTriplesMap] operator[>] identifier[value] operator... |
public static vpnsessionpolicy[] get_filtered(nitro_service service, String filter) throws Exception{
vpnsessionpolicy obj = new vpnsessionpolicy();
options option = new options();
option.set_filter(filter);
vpnsessionpolicy[] response = (vpnsessionpolicy[]) obj.getfiltered(service, option);
return response;
... | class class_name[name] begin[{]
method[get_filtered, return_type[type[vpnsessionpolicy]], modifier[public static], parameter[service, filter]] begin[{]
local_variable[type[vpnsessionpolicy], obj]
local_variable[type[options], option]
call[option.set_filter, parameter[member[.fil... | Keyword[public] Keyword[static] identifier[vpnsessionpolicy] operator[SEP] operator[SEP] identifier[get_filtered] operator[SEP] identifier[nitro_service] identifier[service] , identifier[String] identifier[filter] operator[SEP] Keyword[throws] identifier[Exception] {
identifier[vpnsessionpolicy] identifier[obj]... |
public OperationFuture<List<Server>> powerOff(GroupFilter groupFilter) {
return serverService().powerOff(
getServerSearchCriteria(groupFilter)
);
} | class class_name[name] begin[{]
method[powerOff, return_type[type[OperationFuture]], modifier[public], parameter[groupFilter]] begin[{]
return[call[.serverService, parameter[]]]
end[}]
END[}] | Keyword[public] identifier[OperationFuture] operator[<] identifier[List] operator[<] identifier[Server] operator[>] operator[>] identifier[powerOff] operator[SEP] identifier[GroupFilter] identifier[groupFilter] operator[SEP] {
Keyword[return] identifier[serverService] operator[SEP] operator[SEP] operator[SEP] id... |
public CharBuffer append (CharSequence csq) {
if (csq != null) {
return put(csq.toString());
}
return put("null"); //$NON-NLS-1$
} | class class_name[name] begin[{]
method[append, return_type[type[CharBuffer]], modifier[public], parameter[csq]] begin[{]
if[binary_operation[member[.csq], !=, literal[null]]] begin[{]
return[call[.put, parameter[call[csq.toString, parameter[]]]]]
else begin[{]
None
e... | Keyword[public] identifier[CharBuffer] identifier[append] operator[SEP] identifier[CharSequence] identifier[csq] operator[SEP] {
Keyword[if] operator[SEP] identifier[csq] operator[!=] Other[null] operator[SEP] {
Keyword[return] identifier[put] operator[SEP] identifier[csq] operator[SEP] identifier[toS... |
void persist() {
getPreferences(EvernoteSession.getInstance().getApplicationContext())
.edit()
.putString(KEY_AUTH_TOKEN, mAuthToken)
.putString(KEY_NOTESTORE_URL, mNoteStoreUrl)
.putString(KEY_WEB_API_URL_PREFIX, mWebApiUrlPrefix)
... | class class_name[name] begin[{]
method[persist, return_type[void], modifier[default], parameter[]] begin[{]
call[.getPreferences, parameter[call[EvernoteSession.getInstance, parameter[]]]]
end[}]
END[}] | Keyword[void] identifier[persist] operator[SEP] operator[SEP] {
identifier[getPreferences] operator[SEP] identifier[EvernoteSession] operator[SEP] identifier[getInstance] operator[SEP] operator[SEP] operator[SEP] identifier[getApplicationContext] operator[SEP] operator[SEP] operator[SEP] operator[SEP] identifier... |
protected void doRender(final String html, final HttpServletRequest request, final HttpServletResponse response) throws Exception {
PrintWriter writer;
try {
writer = response.getWriter();
} catch (final Exception e) {
writer = new PrintWriter(response.getOutputStream());... | class class_name[name] begin[{]
method[doRender, return_type[void], modifier[protected], parameter[html, request, response]] begin[{]
local_variable[type[PrintWriter], writer]
TryStatement(block=[StatementExpression(expression=Assignment(expressionl=MemberReference(member=writer, postfix_operat... | Keyword[protected] Keyword[void] identifier[doRender] operator[SEP] Keyword[final] identifier[String] identifier[html] , Keyword[final] identifier[HttpServletRequest] identifier[request] , Keyword[final] identifier[HttpServletResponse] identifier[response] operator[SEP] Keyword[throws] identifier[Exception] {
... |
public List<Post> queuedPosts(Map<String, ?> options) {
return client.blogQueuedPosts(name, options);
} | class class_name[name] begin[{]
method[queuedPosts, return_type[type[List]], modifier[public], parameter[options]] begin[{]
return[call[client.blogQueuedPosts, parameter[member[.name], member[.options]]]]
end[}]
END[}] | Keyword[public] identifier[List] operator[<] identifier[Post] operator[>] identifier[queuedPosts] operator[SEP] identifier[Map] operator[<] identifier[String] , operator[?] operator[>] identifier[options] operator[SEP] {
Keyword[return] identifier[client] operator[SEP] identifier[blogQueuedPosts] operator[SEP] ... |
public static long firstLong(Cursor cursor, boolean close) {
long l = cursor.moveToFirst() ? cursor.getLong(0) : Long.MIN_VALUE;
close(cursor, close);
return l;
} | class class_name[name] begin[{]
method[firstLong, return_type[type[long]], modifier[public static], parameter[cursor, close]] begin[{]
local_variable[type[long], l]
call[.close, parameter[member[.cursor], member[.close]]]
return[member[.l]]
end[}]
END[}] | Keyword[public] Keyword[static] Keyword[long] identifier[firstLong] operator[SEP] identifier[Cursor] identifier[cursor] , Keyword[boolean] identifier[close] operator[SEP] {
Keyword[long] identifier[l] operator[=] identifier[cursor] operator[SEP] identifier[moveToFirst] operator[SEP] operator[SEP] operator[?] id... |
public void putCachedAttributesFor(final RegisteredService registeredService,
final CachingPrincipalAttributesRepository repository,
final String id, final Map<String, List<Object>> attributes) {
val cache = getRegisteredServiceCacheI... | class class_name[name] begin[{]
method[putCachedAttributesFor, return_type[void], modifier[public], parameter[registeredService, repository, id, attributes]] begin[{]
local_variable[type[val], cache]
call[cache.put, parameter[member[.id], member[.attributes]]]
end[}]
END[}] | Keyword[public] Keyword[void] identifier[putCachedAttributesFor] operator[SEP] Keyword[final] identifier[RegisteredService] identifier[registeredService] , Keyword[final] identifier[CachingPrincipalAttributesRepository] identifier[repository] , Keyword[final] identifier[String] identifier[id] , Keyword[final] identi... |
public static Query select(Column... columns) {
return new Query(Arrays.asList(nullSafeArray(columns, Column.class)));
} | class class_name[name] begin[{]
method[select, return_type[type[Query]], modifier[public static], parameter[columns]] begin[{]
return[ClassCreator(arguments=[MethodInvocation(arguments=[MethodInvocation(arguments=[MemberReference(member=columns, postfix_operators=[], prefix_operators=[], qualifier=, se... | Keyword[public] Keyword[static] identifier[Query] identifier[select] operator[SEP] identifier[Column] operator[...] identifier[columns] operator[SEP] {
Keyword[return] Keyword[new] identifier[Query] operator[SEP] identifier[Arrays] operator[SEP] identifier[asList] operator[SEP] identifier[nullSafeArray] operator... |
public ClasspathScanDescriptorProvider scanPackage(final String packageName, final boolean recursive) {
return scanPackage(packageName, recursive, ClassLoaderUtils.getParentClassLoader(), false);
} | class class_name[name] begin[{]
method[scanPackage, return_type[type[ClasspathScanDescriptorProvider]], modifier[public], parameter[packageName, recursive]] begin[{]
return[call[.scanPackage, parameter[member[.packageName], member[.recursive], call[ClassLoaderUtils.getParentClassLoader, parameter[]], l... | Keyword[public] identifier[ClasspathScanDescriptorProvider] identifier[scanPackage] operator[SEP] Keyword[final] identifier[String] identifier[packageName] , Keyword[final] Keyword[boolean] identifier[recursive] operator[SEP] {
Keyword[return] identifier[scanPackage] operator[SEP] identifier[packageName] , ide... |
public void marshall(DescribeConfigRulesRequest describeConfigRulesRequest, ProtocolMarshaller protocolMarshaller) {
if (describeConfigRulesRequest == 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[describeConfigRulesRequest, protocolMarshaller]] begin[{]
if[binary_operation[member[.describeConfigRulesRequest], ==, literal[null]]] begin[{]
ThrowStatement(expression=ClassCreator(argu... | Keyword[public] Keyword[void] identifier[marshall] operator[SEP] identifier[DescribeConfigRulesRequest] identifier[describeConfigRulesRequest] , identifier[ProtocolMarshaller] identifier[protocolMarshaller] operator[SEP] {
Keyword[if] operator[SEP] identifier[describeConfigRulesRequest] operator[==] Other[null]... |
CssFormatter comment( String msg ) {
getOutput().append( insets ).append( msg ).append( '\n' );
return this;
} | class class_name[name] begin[{]
method[comment, return_type[type[CssFormatter]], modifier[default], parameter[msg]] begin[{]
call[.getOutput, parameter[]]
return[THIS[]]
end[}]
END[}] | identifier[CssFormatter] identifier[comment] operator[SEP] identifier[String] identifier[msg] operator[SEP] {
identifier[getOutput] operator[SEP] operator[SEP] operator[SEP] identifier[append] operator[SEP] identifier[insets] operator[SEP] operator[SEP] identifier[append] operator[SEP] identifier[msg] operator[S... |
@POST
@Consumes(MediaType.APPLICATION_JSON)
@Produces(MediaType.APPLICATION_JSON)
@RequiresPermissions(I18nPermissions.LOCALE_WRITE)
public Response addAvailableLocale(LocaleRepresentation representation,
@Context UriInfo uriInfo) throws URISyntaxException {
WebAssertions.assertNotNu... | class class_name[name] begin[{]
method[addAvailableLocale, return_type[type[Response]], modifier[public], parameter[representation, uriInfo]] begin[{]
call[WebAssertions.assertNotNull, parameter[member[.representation], member[.LOCALE_SHOULD_NOT_BE_BLANK]]]
local_variable[type[Locale], ... | annotation[@] identifier[POST] annotation[@] identifier[Consumes] operator[SEP] identifier[MediaType] operator[SEP] identifier[APPLICATION_JSON] operator[SEP] annotation[@] identifier[Produces] operator[SEP] identifier[MediaType] operator[SEP] identifier[APPLICATION_JSON] operator[SEP] annotation[@] identifier[Requires... |
protected File executePartialPut(HttpServletRequest req, CmsWebdavRange range, String path) throws IOException {
// Append data specified in ranges to existing content for this
// resource - create a temp. file on the local filesystem to
// perform this operation
File tempDir = (File)ge... | class class_name[name] begin[{]
method[executePartialPut, return_type[type[File]], modifier[protected], parameter[req, range, path]] begin[{]
local_variable[type[File], tempDir]
local_variable[type[String], convertedResourcePath]
local_variable[type[File], contentFile]
c... | Keyword[protected] identifier[File] identifier[executePartialPut] operator[SEP] identifier[HttpServletRequest] identifier[req] , identifier[CmsWebdavRange] identifier[range] , identifier[String] identifier[path] operator[SEP] Keyword[throws] identifier[IOException] {
identifier[File] identifier[tempDir] operat... |
private static boolean mayBrowse(
final IAuthorizationPrincipal principal, final String targetId) {
Validate.notNull(principal, "Cannot determine permissions for a null user.");
Validate.notNull(targetId, "Cannot determine permissions on a null target.");
return (principal.hasPermis... | class class_name[name] begin[{]
method[mayBrowse, return_type[type[boolean]], modifier[private static], parameter[principal, targetId]] begin[{]
call[Validate.notNull, parameter[member[.principal], literal["Cannot determine permissions for a null user."]]]
call[Validate.notNull,... | Keyword[private] Keyword[static] Keyword[boolean] identifier[mayBrowse] operator[SEP] Keyword[final] identifier[IAuthorizationPrincipal] identifier[principal] , Keyword[final] identifier[String] identifier[targetId] operator[SEP] {
identifier[Validate] operator[SEP] identifier[notNull] operator[SEP] identifier[... |
@CheckForSigned
protected int findByte (final byte nValue, final int nPos)
{
for (int i = nPos; i < m_nTail; i++)
if (m_aBuffer[i] == nValue)
return i;
return -1;
} | class class_name[name] begin[{]
method[findByte, return_type[type[int]], modifier[protected], parameter[nValue, nPos]] begin[{]
ForStatement(body=IfStatement(condition=BinaryOperation(operandl=MemberReference(member=m_aBuffer, postfix_operators=[], prefix_operators=[], qualifier=, selectors=[ArraySelec... | annotation[@] identifier[CheckForSigned] Keyword[protected] Keyword[int] identifier[findByte] operator[SEP] Keyword[final] Keyword[byte] identifier[nValue] , Keyword[final] Keyword[int] identifier[nPos] operator[SEP] {
Keyword[for] operator[SEP] Keyword[int] identifier[i] operator[=] identifier[nPos] operator[S... |
@Override
public EClass getMethodMetric() {
if (methodMetricEClass == null) {
methodMetricEClass = (EClass) EPackage.Registry.INSTANCE.getEPackage(StorePackage.eNS_URI).getEClassifiers().get(102);
}
return methodMetricEClass;
} | class class_name[name] begin[{]
method[getMethodMetric, return_type[type[EClass]], modifier[public], parameter[]] begin[{]
if[binary_operation[member[.methodMetricEClass], ==, literal[null]]] begin[{]
assign[member[.methodMetricEClass], Cast(expression=MethodInvocation(a... | annotation[@] identifier[Override] Keyword[public] identifier[EClass] identifier[getMethodMetric] operator[SEP] operator[SEP] {
Keyword[if] operator[SEP] identifier[methodMetricEClass] operator[==] Other[null] operator[SEP] {
identifier[methodMetricEClass] operator[=] operator[SEP] identifier[EClass] ... |
protected boolean eventTargetsPopup(NativeEvent event) {
EventTarget target = event.getEventTarget();
if (Element.is(target)) {
return getElement().isOrHasChild(Element.as(target));
}
return false;
} | class class_name[name] begin[{]
method[eventTargetsPopup, return_type[type[boolean]], modifier[protected], parameter[event]] begin[{]
local_variable[type[EventTarget], target]
if[call[Element.is, parameter[member[.target]]]] begin[{]
return[call[.getElement, parameter[]]]
... | Keyword[protected] Keyword[boolean] identifier[eventTargetsPopup] operator[SEP] identifier[NativeEvent] identifier[event] operator[SEP] {
identifier[EventTarget] identifier[target] operator[=] identifier[event] operator[SEP] identifier[getEventTarget] operator[SEP] operator[SEP] operator[SEP] Keyword[if] operato... |
private SelectorBuilderImpl multipleValuePredicate(String field, String[] propertyValues,
PredicateOperator operator) {
if (propertyValues == null) {
return this;
}
Predicate predicate = new Predicate();
predicate.setOperator(operator);
predicate.setField(field);
String[] values = ... | class class_name[name] begin[{]
method[multipleValuePredicate, return_type[type[SelectorBuilderImpl]], modifier[private], parameter[field, propertyValues, operator]] begin[{]
if[binary_operation[member[.propertyValues], ==, literal[null]]] begin[{]
return[THIS[]]
else begin[... | Keyword[private] identifier[SelectorBuilderImpl] identifier[multipleValuePredicate] operator[SEP] identifier[String] identifier[field] , identifier[String] operator[SEP] operator[SEP] identifier[propertyValues] , identifier[PredicateOperator] identifier[operator] operator[SEP] {
Keyword[if] operator[SEP] ident... |
@Override
public void createMaxXFunction() {
createFunction(MAX_X_FUNCTION, new GeometryFunction() {
@Override
public Object execute(GeoPackageGeometryData data) {
Object value = null;
GeometryEnvelope envelope = getEnvelope(data);
if (envelope != null) {
value = envelope.getMaxX();
}
... | class class_name[name] begin[{]
method[createMaxXFunction, return_type[void], modifier[public], parameter[]] begin[{]
call[.createFunction, parameter[member[.MAX_X_FUNCTION], ClassCreator(arguments=[], body=[MethodDeclaration(annotations=[Annotation(element=None, name=Override)], body=[LocalVar... | annotation[@] identifier[Override] Keyword[public] Keyword[void] identifier[createMaxXFunction] operator[SEP] operator[SEP] {
identifier[createFunction] operator[SEP] identifier[MAX_X_FUNCTION] , Keyword[new] identifier[GeometryFunction] operator[SEP] operator[SEP] {
annotation[@] identifier[Override... |
public static <P> Setting of(
String description, ListProperty<P> items, ObjectProperty<P> selection) {
return new Setting<>(
description,
Field.ofSingleSelectionType(items, selection)
.label(description)
.render(new SimpleComboBoxControl<>()),
selection);
} | class class_name[name] begin[{]
method[of, return_type[type[Setting]], modifier[public static], parameter[description, items, selection]] begin[{]
return[ClassCreator(arguments=[MemberReference(member=description, postfix_operators=[], prefix_operators=[], qualifier=, selectors=[]), MethodInvocation(ar... | Keyword[public] Keyword[static] operator[<] identifier[P] operator[>] identifier[Setting] identifier[of] operator[SEP] identifier[String] identifier[description] , identifier[ListProperty] operator[<] identifier[P] operator[>] identifier[items] , identifier[ObjectProperty] operator[<] identifier[P] operator[>] identi... |
public final Future<List<InetAddress>> resolveAll(String inetHost, Iterable<DnsRecord> additionals) {
return resolveAll(inetHost, additionals, executor().<List<InetAddress>>newPromise());
} | class class_name[name] begin[{]
method[resolveAll, return_type[type[Future]], modifier[final public], parameter[inetHost, additionals]] begin[{]
return[call[.resolveAll, parameter[member[.inetHost], member[.additionals], call[.executor, parameter[]]]]]
end[}]
END[}] | Keyword[public] Keyword[final] identifier[Future] operator[<] identifier[List] operator[<] identifier[InetAddress] operator[>] operator[>] identifier[resolveAll] operator[SEP] identifier[String] identifier[inetHost] , identifier[Iterable] operator[<] identifier[DnsRecord] operator[>] identifier[additionals] operator[S... |
private static File computeCacheDirectory() {
String path = System.getenv("COURSIER_CACHE");
if (path == null)
path = System.getProperty("coursier.cache");
File baseXdgDir = new File(coursierDirectories.cacheDir);
File xdgDir = new File(baseXdgDir, "v1");
String xdg... | class class_name[name] begin[{]
method[computeCacheDirectory, return_type[type[File]], modifier[private static], parameter[]] begin[{]
local_variable[type[String], path]
if[binary_operation[member[.path], ==, literal[null]]] begin[{]
assign[member[.path], call[System.getProp... | Keyword[private] Keyword[static] identifier[File] identifier[computeCacheDirectory] operator[SEP] operator[SEP] {
identifier[String] identifier[path] operator[=] identifier[System] operator[SEP] identifier[getenv] operator[SEP] literal[String] operator[SEP] operator[SEP] Keyword[if] operator[SEP] identifier[path... |
private boolean notifyOnSkip() {
boolean result = true;
NavigationPreference selectedNavigationPreference =
navigationFragment.getSelectedNavigationPreference();
if (selectedNavigationPreference != null && preferenceFragment != null) {
for (WizardListener listener : ... | class class_name[name] begin[{]
method[notifyOnSkip, return_type[type[boolean]], modifier[private], parameter[]] begin[{]
local_variable[type[boolean], result]
local_variable[type[NavigationPreference], selectedNavigationPreference]
if[binary_operation[binary_operation[member[.s... | Keyword[private] Keyword[boolean] identifier[notifyOnSkip] operator[SEP] operator[SEP] {
Keyword[boolean] identifier[result] operator[=] literal[boolean] operator[SEP] identifier[NavigationPreference] identifier[selectedNavigationPreference] operator[=] identifier[navigationFragment] operator[SEP] identifier[get... |
public static String extractIPAddress(final HttpServletRequest request) {
String ip = request.getHeader("x-forwarded-for");
if (isIPAdressValid(ip)) {
return ip;
}
ip = request.getHeader("Proxy-Client-IP");
if (isIPAdressValid(ip)) {
return ip;
}
... | class class_name[name] begin[{]
method[extractIPAddress, return_type[type[String]], modifier[public static], parameter[request]] begin[{]
local_variable[type[String], ip]
if[call[.isIPAdressValid, parameter[member[.ip]]]] begin[{]
return[member[.ip]]
else begin[{]
No... | Keyword[public] Keyword[static] identifier[String] identifier[extractIPAddress] operator[SEP] Keyword[final] identifier[HttpServletRequest] identifier[request] operator[SEP] {
identifier[String] identifier[ip] operator[=] identifier[request] operator[SEP] identifier[getHeader] operator[SEP] literal[String] opera... |
public void setSection (Section section)
{
_sections.put(key(section.x, section.y), section);
} | class class_name[name] begin[{]
method[setSection, return_type[void], modifier[public], parameter[section]] begin[{]
call[_sections.put, parameter[call[.key, parameter[member[section.x], member[section.y]]], member[.section]]]
end[}]
END[}] | Keyword[public] Keyword[void] identifier[setSection] operator[SEP] identifier[Section] identifier[section] operator[SEP] {
identifier[_sections] operator[SEP] identifier[put] operator[SEP] identifier[key] operator[SEP] identifier[section] operator[SEP] identifier[x] , identifier[section] operator[SEP] identifie... |
public UpdateRequest updateUpdateRequest(long sheetId, UpdateRequest updateRequest) throws SmartsheetException {
return this.updateResource("sheets/" + sheetId + "/updaterequests/" + updateRequest.getId(),
UpdateRequest.class, updateRequest);
} | class class_name[name] begin[{]
method[updateUpdateRequest, return_type[type[UpdateRequest]], modifier[public], parameter[sheetId, updateRequest]] begin[{]
return[THIS[call[None.updateResource, parameter[binary_operation[binary_operation[binary_operation[literal["sheets/"], +, member[.sheetId]], +, lit... | Keyword[public] identifier[UpdateRequest] identifier[updateUpdateRequest] operator[SEP] Keyword[long] identifier[sheetId] , identifier[UpdateRequest] identifier[updateRequest] operator[SEP] Keyword[throws] identifier[SmartsheetException] {
Keyword[return] Keyword[this] operator[SEP] identifier[updateResource] o... |
public void onItemClick() {
if (selected) {
selected = false;
getView().reset();
if (onResetCommand != null) {
onResetCommand.execute();
}
}
else {
selected = true;
getView().select();
if (onSel... | class class_name[name] begin[{]
method[onItemClick, return_type[void], modifier[public], parameter[]] begin[{]
if[member[.selected]] begin[{]
assign[member[.selected], literal[false]]
call[.getView, parameter[]]
if[binary_o... | Keyword[public] Keyword[void] identifier[onItemClick] operator[SEP] operator[SEP] {
Keyword[if] operator[SEP] identifier[selected] operator[SEP] {
identifier[selected] operator[=] literal[boolean] operator[SEP] identifier[getView] operator[SEP] operator[SEP] operator[SEP] identifier[reset] operator[SE... |
public static float cublasSdot(int n, Pointer x, int incx, Pointer y, int incy)
{
float result = cublasSdotNative(n, x, incx, y, incy);
checkResultBLAS();
return result;
} | class class_name[name] begin[{]
method[cublasSdot, return_type[type[float]], modifier[public static], parameter[n, x, incx, y, incy]] begin[{]
local_variable[type[float], result]
call[.checkResultBLAS, parameter[]]
return[member[.result]]
end[}]
END[}] | Keyword[public] Keyword[static] Keyword[float] identifier[cublasSdot] operator[SEP] Keyword[int] identifier[n] , identifier[Pointer] identifier[x] , Keyword[int] identifier[incx] , identifier[Pointer] identifier[y] , Keyword[int] identifier[incy] operator[SEP] {
Keyword[float] identifier[result] operator[=] ... |
public static void main(String[] args) {
// Parse the command line options
ArgumentsLoader.parse(args);
// Load the configuration
Config config = ArgumentsLoader.getConfig();
// Initialise the system with the given arguments
if (!init(config)) {
return;
}
// load all extensions
... | class class_name[name] begin[{]
method[main, return_type[void], modifier[public static], parameter[args]] begin[{]
call[ArgumentsLoader.parse, parameter[member[.args]]]
local_variable[type[Config], config]
if[call[.init, parameter[member[.config]]]] begin[{]
... | Keyword[public] Keyword[static] Keyword[void] identifier[main] operator[SEP] identifier[String] operator[SEP] operator[SEP] identifier[args] operator[SEP] {
identifier[ArgumentsLoader] operator[SEP] identifier[parse] operator[SEP] identifier[args] operator[SEP] operator[SEP] identifier[Config] identifier[config]... |
public boolean isSet(_Fields field) {
if (field == null) {
throw new IllegalArgumentException();
}
switch (field) {
case COLUMN_FAMILY:
return isSetColumn_family();
case SUPER_COLUMN:
return isSetSuper_column();
case COLUMN:
return isSetColumn();
}
throw new Ille... | class class_name[name] begin[{]
method[isSet, return_type[type[boolean]], modifier[public], parameter[field]] begin[{]
if[binary_operation[member[.field], ==, literal[null]]] begin[{]
ThrowStatement(expression=ClassCreator(arguments=[], body=None, constructor_type_arguments=None, po... | Keyword[public] Keyword[boolean] identifier[isSet] operator[SEP] identifier[_Fields] identifier[field] operator[SEP] {
Keyword[if] operator[SEP] identifier[field] operator[==] Other[null] operator[SEP] {
Keyword[throw] Keyword[new] identifier[IllegalArgumentException] operator[SEP] operator[SEP] opera... |
public void marshall(GetGroupRequest getGroupRequest, ProtocolMarshaller protocolMarshaller) {
if (getGroupRequest == null) {
throw new SdkClientException("Invalid argument passed to marshall(...)");
}
try {
protocolMarshaller.marshall(getGroupRequest.getGroupId(), GROU... | class class_name[name] begin[{]
method[marshall, return_type[void], modifier[public], parameter[getGroupRequest, protocolMarshaller]] begin[{]
if[binary_operation[member[.getGroupRequest], ==, literal[null]]] begin[{]
ThrowStatement(expression=ClassCreator(arguments=[Literal(postfix... | Keyword[public] Keyword[void] identifier[marshall] operator[SEP] identifier[GetGroupRequest] identifier[getGroupRequest] , identifier[ProtocolMarshaller] identifier[protocolMarshaller] operator[SEP] {
Keyword[if] operator[SEP] identifier[getGroupRequest] operator[==] Other[null] operator[SEP] {
Keywo... |
public final void batchWriteSpans(ProjectName name, List<Span> spans) {
BatchWriteSpansRequest request =
BatchWriteSpansRequest.newBuilder()
.setName(name == null ? null : name.toString())
.addAllSpans(spans)
.build();
batchWriteSpans(request);
} | class class_name[name] begin[{]
method[batchWriteSpans, return_type[void], modifier[final public], parameter[name, spans]] begin[{]
local_variable[type[BatchWriteSpansRequest], request]
call[.batchWriteSpans, parameter[member[.request]]]
end[}]
END[}] | Keyword[public] Keyword[final] Keyword[void] identifier[batchWriteSpans] operator[SEP] identifier[ProjectName] identifier[name] , identifier[List] operator[<] identifier[Span] operator[>] identifier[spans] operator[SEP] {
identifier[BatchWriteSpansRequest] identifier[request] operator[=] identifier[BatchWriteSp... |
private static Scope getRootScope() {
if (root == null) {
synchronized (Scope.class) {
root = new Scope(true);
root.create("pi").makeConstant(Math.PI);
root.create("euler").makeConstant(Math.E);
}
}
return root;
} | class class_name[name] begin[{]
method[getRootScope, return_type[type[Scope]], modifier[private static], parameter[]] begin[{]
if[binary_operation[member[.root], ==, literal[null]]] begin[{]
SYNCHRONIZED[ClassReference(postfix_operators=[], prefix_operators=[], qualifier... | Keyword[private] Keyword[static] identifier[Scope] identifier[getRootScope] operator[SEP] operator[SEP] {
Keyword[if] operator[SEP] identifier[root] operator[==] Other[null] operator[SEP] {
Keyword[synchronized] operator[SEP] identifier[Scope] operator[SEP] Keyword[class] operator[SEP] {
... |
public ConfigParseOptions setOriginDescription(String originDescription) {
// findbugs complains about == here but is wrong, do not "fix"
if (this.originDescription == originDescription)
return this;
else if (this.originDescription != null && originDescription != null
... | class class_name[name] begin[{]
method[setOriginDescription, return_type[type[ConfigParseOptions]], modifier[public], parameter[originDescription]] begin[{]
if[binary_operation[THIS[member[None.originDescription]], ==, member[.originDescription]]] begin[{]
return[THIS[]]
else begin[{]
... | Keyword[public] identifier[ConfigParseOptions] identifier[setOriginDescription] operator[SEP] identifier[String] identifier[originDescription] operator[SEP] {
Keyword[if] operator[SEP] Keyword[this] operator[SEP] identifier[originDescription] operator[==] identifier[originDescription] operator[SEP] Keyword[retur... |
@SuppressWarnings({"unchecked", "rawtypes"})
public Collection<KeywordAnnotation> parseKeywordAnnotations()
throws EnhancementParserException {
Multimap<Enhancement, String> relations = ArrayListMultimap.create();
Map<String, Enhancement> enhancementsByUri = Maps.newHashMap();
t... | class class_name[name] begin[{]
method[parseKeywordAnnotations, return_type[type[Collection]], modifier[public], parameter[]] begin[{]
local_variable[type[Multimap], relations]
local_variable[type[Map], enhancementsByUri]
TryStatement(block=[LocalVariableDeclaration(annotations=[], decl... | annotation[@] identifier[SuppressWarnings] operator[SEP] {
literal[String] , literal[String]
} operator[SEP] Keyword[public] identifier[Collection] operator[<] identifier[KeywordAnnotation] operator[>] identifier[parseKeywordAnnotations] operator[SEP] operator[SEP] Keyword[throws] identifier[EnhancementParse... |
@Override
public void flush(int requestNumber) {
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
SibTr.entry(this, tc, "flush", "" + requestNumber);
try {
// Make sure it is stopped before we activate it
if (mainConsumer.isStarted())
... | class class_name[name] begin[{]
method[flush, return_type[void], modifier[public], parameter[requestNumber]] begin[{]
if[binary_operation[call[TraceComponent.isAnyTracingEnabled, parameter[]], &&, call[tc.isEntryEnabled, parameter[]]]] begin[{]
call[SibTr.entry, parameter[THIS[], me... | annotation[@] identifier[Override] Keyword[public] Keyword[void] identifier[flush] operator[SEP] Keyword[int] identifier[requestNumber] operator[SEP] {
Keyword[if] operator[SEP] identifier[TraceComponent] operator[SEP] identifier[isAnyTracingEnabled] operator[SEP] operator[SEP] operator[&&] identifier[tc] operat... |
public static Matcher<AssignmentTree> assignment(
final Matcher<ExpressionTree> variableMatcher,
final Matcher<? super ExpressionTree> expressionMatcher) {
return new Matcher<AssignmentTree>() {
@Override
public boolean matches(AssignmentTree t, VisitorState state) {
return variableM... | class class_name[name] begin[{]
method[assignment, return_type[type[Matcher]], modifier[public static], parameter[variableMatcher, expressionMatcher]] begin[{]
return[ClassCreator(arguments=[], body=[MethodDeclaration(annotations=[Annotation(element=None, name=Override)], body=[ReturnStatement(expressi... | Keyword[public] Keyword[static] identifier[Matcher] operator[<] identifier[AssignmentTree] operator[>] identifier[assignment] operator[SEP] Keyword[final] identifier[Matcher] operator[<] identifier[ExpressionTree] operator[>] identifier[variableMatcher] , Keyword[final] identifier[Matcher] operator[<] operator[?] Keyw... |
public void draw() {
//=================================================================
//Now plot the STP with the Utility.PlotSTPTemporalModule class
//=================================================================
PlotSTPTemporalModule view;
Toolkit tk = Toolkit.getDefaultToolkit();
int xSize =... | class class_name[name] begin[{]
method[draw, return_type[void], modifier[public], parameter[]] begin[{]
local_variable[type[PlotSTPTemporalModule], view]
local_variable[type[Toolkit], tk]
local_variable[type[int], xSize]
local_variable[type[int], ySize]
assign[me... | Keyword[public] Keyword[void] identifier[draw] operator[SEP] operator[SEP] {
identifier[PlotSTPTemporalModule] identifier[view] operator[SEP] identifier[Toolkit] identifier[tk] operator[=] identifier[Toolkit] operator[SEP] identifier[getDefaultToolkit] operator[SEP] operator[SEP] operator[SEP] Keyword[int] ident... |
@Override
public List<ExportFormat> exportFormats(IssueServiceConfiguration issueServiceConfiguration) {
return issueExportServiceFactory.getIssueExportServices().stream()
.map(IssueExportService::getExportFormat)
.collect(Collectors.toList());
} | class class_name[name] begin[{]
method[exportFormats, return_type[type[List]], modifier[public], parameter[issueServiceConfiguration]] begin[{]
return[call[issueExportServiceFactory.getIssueExportServices, parameter[]]]
end[}]
END[}] | annotation[@] identifier[Override] Keyword[public] identifier[List] operator[<] identifier[ExportFormat] operator[>] identifier[exportFormats] operator[SEP] identifier[IssueServiceConfiguration] identifier[issueServiceConfiguration] operator[SEP] {
Keyword[return] identifier[issueExportServiceFactory] operator[S... |
@PublicEvolving
static <T extends Writable> TypeInformation<T> getWritableTypeInfo(Class<T> typeClass) {
if (Writable.class.isAssignableFrom(typeClass) && !typeClass.equals(Writable.class)) {
return new WritableTypeInfo<T>(typeClass);
}
else {
throw new InvalidTypesException("The given class is no subclass... | class class_name[name] begin[{]
method[getWritableTypeInfo, return_type[type[TypeInformation]], modifier[static], parameter[typeClass]] begin[{]
if[binary_operation[ClassReference(postfix_operators=[], prefix_operators=[], qualifier=, selectors=[MethodInvocation(arguments=[MemberReference(membe... | annotation[@] identifier[PublicEvolving] Keyword[static] operator[<] identifier[T] Keyword[extends] identifier[Writable] operator[>] identifier[TypeInformation] operator[<] identifier[T] operator[>] identifier[getWritableTypeInfo] operator[SEP] identifier[Class] operator[<] identifier[T] operator[>] identifier[typeClas... |
public void validate(FacesContext context,
UIComponent component,
Object value) throws ValidatorException {
if (null == context || null == component) {
throw new NullPointerException();
}
try {
methodBinding.invoke(context, new Object[]... | class class_name[name] begin[{]
method[validate, return_type[void], modifier[public], parameter[context, component, value]] begin[{]
if[binary_operation[binary_operation[literal[null], ==, member[.context]], ||, binary_operation[literal[null], ==, member[.component]]]] begin[{]
Thro... | Keyword[public] Keyword[void] identifier[validate] operator[SEP] identifier[FacesContext] identifier[context] , identifier[UIComponent] identifier[component] , identifier[Object] identifier[value] operator[SEP] Keyword[throws] identifier[ValidatorException] {
Keyword[if] operator[SEP] Other[null] operator[==] ... |
public void init(CEEvaluator ceEval,
BaseTypeFactory factory,
ClauseFactory clauseFactory,
ServerDDS sdds,
List<AST> nodes)
{
this.ceEval = ceEval;
this.clauseFactory = clauseFactory;
this.factory = factory;
... | class class_name[name] begin[{]
method[init, return_type[void], modifier[public], parameter[ceEval, factory, clauseFactory, sdds, nodes]] begin[{]
assign[THIS[member[None.ceEval]], member[.ceEval]]
assign[THIS[member[None.clauseFactory]], member[.clauseFactory]]
... | Keyword[public] Keyword[void] identifier[init] operator[SEP] identifier[CEEvaluator] identifier[ceEval] , identifier[BaseTypeFactory] identifier[factory] , identifier[ClauseFactory] identifier[clauseFactory] , identifier[ServerDDS] identifier[sdds] , identifier[List] operator[<] identifier[AST] operator[>] identifi... |
public void addMailHost(String hostname, String order, String protocol, String username, String password) {
addMailHost(hostname, "25", order, protocol, null, username, password);
} | class class_name[name] begin[{]
method[addMailHost, return_type[void], modifier[public], parameter[hostname, order, protocol, username, password]] begin[{]
call[.addMailHost, parameter[member[.hostname], literal["25"], member[.order], member[.protocol], literal[null], member[.username], member[... | Keyword[public] Keyword[void] identifier[addMailHost] operator[SEP] identifier[String] identifier[hostname] , identifier[String] identifier[order] , identifier[String] identifier[protocol] , identifier[String] identifier[username] , identifier[String] identifier[password] operator[SEP] {
identifier[addMailHo... |
public synchronized Object get(@Sensitive String key) {
Object curEntry = primaryTable.get(key);
// Not found in primary
if (curEntry == null) {
curEntry = secondaryTable.get(key);
// Not found in primary or secondary
if (curEntry == null) {
... | class class_name[name] begin[{]
method[get, return_type[type[Object]], modifier[synchronized public], parameter[key]] begin[{]
local_variable[type[Object], curEntry]
if[binary_operation[member[.curEntry], ==, literal[null]]] begin[{]
assign[member[.curEntry], cal... | Keyword[public] Keyword[synchronized] identifier[Object] identifier[get] operator[SEP] annotation[@] identifier[Sensitive] identifier[String] identifier[key] operator[SEP] {
identifier[Object] identifier[curEntry] operator[=] identifier[primaryTable] operator[SEP] identifier[get] operator[SEP] identifier[key] op... |
public JsPermittedChainUsage fromString(String name)
{
JsPermittedChainUsage result = null;
for (int i = 0; i < _set.length && result == null; i++)
{
if (name.equals(_set[i].toString())) result = _set[i];
}
return result;
} | class class_name[name] begin[{]
method[fromString, return_type[type[JsPermittedChainUsage]], modifier[public], parameter[name]] begin[{]
local_variable[type[JsPermittedChainUsage], result]
ForStatement(body=BlockStatement(label=None, statements=[IfStatement(condition=MethodInvocation(arguments=... | Keyword[public] identifier[JsPermittedChainUsage] identifier[fromString] operator[SEP] identifier[String] identifier[name] operator[SEP] {
identifier[JsPermittedChainUsage] identifier[result] operator[=] Other[null] operator[SEP] Keyword[for] operator[SEP] Keyword[int] identifier[i] operator[=] Other[0] operator... |
private String getStatsString() {
SplitTypeStats allTypeStats = splitTypeStatsMap.get(SplitType.ALL);
Map<String, Map<String, Number>> statsMapMap =
new HashMap<String, Map<String, Number>>();
for (Map.Entry<SplitType, SplitTypeStats> entry :
splitTypeStatsMap.entrySet()) {
Map<String, N... | class class_name[name] begin[{]
method[getStatsString, return_type[type[String]], modifier[private], parameter[]] begin[{]
local_variable[type[SplitTypeStats], allTypeStats]
local_variable[type[Map], statsMapMap]
ForStatement(body=BlockStatement(label=None, statements=[LocalVariableDecl... | Keyword[private] identifier[String] identifier[getStatsString] operator[SEP] operator[SEP] {
identifier[SplitTypeStats] identifier[allTypeStats] operator[=] identifier[splitTypeStatsMap] operator[SEP] identifier[get] operator[SEP] identifier[SplitType] operator[SEP] identifier[ALL] operator[SEP] operator[SEP] id... |
protected void removeItem(int item, int bin) throws ContradictionException {
updateLoads(item, bin);
if (decoKPSimple != null) {
decoKPSimple.postRemoveItem(item, bin);
}
} | class class_name[name] begin[{]
method[removeItem, return_type[void], modifier[protected], parameter[item, bin]] begin[{]
call[.updateLoads, parameter[member[.item], member[.bin]]]
if[binary_operation[member[.decoKPSimple], !=, literal[null]]] begin[{]
ca... | Keyword[protected] Keyword[void] identifier[removeItem] operator[SEP] Keyword[int] identifier[item] , Keyword[int] identifier[bin] operator[SEP] Keyword[throws] identifier[ContradictionException] {
identifier[updateLoads] operator[SEP] identifier[item] , identifier[bin] operator[SEP] operator[SEP] Keyword[if] ... |
@Deprecated
public AtomixClusterBuilder setBroadcastInterval(Duration interval) {
GroupMembershipProtocolConfig protocolConfig = config.getProtocolConfig();
if (protocolConfig instanceof HeartbeatMembershipProtocolConfig) {
((HeartbeatMembershipProtocolConfig) protocolConfig).setHeartbeatInterval(interv... | class class_name[name] begin[{]
method[setBroadcastInterval, return_type[type[AtomixClusterBuilder]], modifier[public], parameter[interval]] begin[{]
local_variable[type[GroupMembershipProtocolConfig], protocolConfig]
if[binary_operation[member[.protocolConfig], instanceof, type[Heartbe... | annotation[@] identifier[Deprecated] Keyword[public] identifier[AtomixClusterBuilder] identifier[setBroadcastInterval] operator[SEP] identifier[Duration] identifier[interval] operator[SEP] {
identifier[GroupMembershipProtocolConfig] identifier[protocolConfig] operator[=] identifier[config] operator[SEP] identifi... |
public boolean isPositiveLS(long utc) {
if (utc <= 0) {
return false;
}
final ExtendedLSE[] events = this.getEventsInDescendingOrder();
for (int i = 0; i < events.length; i++) {
long comp = events[i].utc();
if (comp == utc) {
return... | class class_name[name] begin[{]
method[isPositiveLS, return_type[type[boolean]], modifier[public], parameter[utc]] begin[{]
if[binary_operation[member[.utc], <=, literal[0]]] begin[{]
return[literal[false]]
else begin[{]
None
end[}]
local_variable[type[Extend... | Keyword[public] Keyword[boolean] identifier[isPositiveLS] operator[SEP] Keyword[long] identifier[utc] operator[SEP] {
Keyword[if] operator[SEP] identifier[utc] operator[<=] Other[0] operator[SEP] {
Keyword[return] literal[boolean] operator[SEP]
}
Keyword[final] identifier[ExtendedLSE] op... |
public static <T> List<T> getParents(DirectedGraph g, T n) {
List<IndexedEdge> incoming = new ArrayList(g.incomingEdgesOf(n));
Collections.sort(incoming);
List<T> ret = new ArrayList();
for(IndexedEdge e: incoming) {
ret.add((T)e.source);
}
return ret;... | class class_name[name] begin[{]
method[getParents, return_type[type[List]], modifier[public static], parameter[g, n]] begin[{]
local_variable[type[List], incoming]
call[Collections.sort, parameter[member[.incoming]]]
local_variable[type[List], ret]
ForStatement(body=Bloc... | Keyword[public] Keyword[static] operator[<] identifier[T] operator[>] identifier[List] operator[<] identifier[T] operator[>] identifier[getParents] operator[SEP] identifier[DirectedGraph] identifier[g] , identifier[T] identifier[n] operator[SEP] {
identifier[List] operator[<] identifier[IndexedEdge] operator[>]... |
protected Logic resolveLogic (String path)
{
// look for a cached logic instance
String lclass = _app.generateClass(path);
Logic logic = _logic.get(lclass);
if (logic == null) {
logic = instantiateLogic(path, lclass);
// if something failed, use a dummy in i... | class class_name[name] begin[{]
method[resolveLogic, return_type[type[Logic]], modifier[protected], parameter[path]] begin[{]
local_variable[type[String], lclass]
local_variable[type[Logic], logic]
if[binary_operation[member[.logic], ==, literal[null]]] begin[{]
... | Keyword[protected] identifier[Logic] identifier[resolveLogic] operator[SEP] identifier[String] identifier[path] operator[SEP] {
identifier[String] identifier[lclass] operator[=] identifier[_app] operator[SEP] identifier[generateClass] operator[SEP] identifier[path] operator[SEP] operator[SEP] identifier[Logic] i... |
protected void buildTokens(final char commandPrefix, final List<Token> tokens, final List<NodeOc> depth,
final List<NodeOc> line, final String value)
{
for (int n = 0; n < line.size(); n++)
{
if (depth.size() <= n)
{
/*
* This is a... | class class_name[name] begin[{]
method[buildTokens, return_type[void], modifier[protected], parameter[commandPrefix, tokens, depth, line, value]] begin[{]
ForStatement(body=BlockStatement(label=None, statements=[IfStatement(condition=BinaryOperation(operandl=MethodInvocation(arguments=[], member=size, ... | Keyword[protected] Keyword[void] identifier[buildTokens] operator[SEP] Keyword[final] Keyword[char] identifier[commandPrefix] , Keyword[final] identifier[List] operator[<] identifier[Token] operator[>] identifier[tokens] , Keyword[final] identifier[List] operator[<] identifier[NodeOc] operator[>] identifier[depth] , ... |
public static double haversineFormulaDeg(double lat1, double lon1, double lat2, double lon2) {
return haversineFormulaRad(deg2rad(lat1), deg2rad(lon1), deg2rad(lat2), deg2rad(lon2));
} | class class_name[name] begin[{]
method[haversineFormulaDeg, return_type[type[double]], modifier[public static], parameter[lat1, lon1, lat2, lon2]] begin[{]
return[call[.haversineFormulaRad, parameter[call[.deg2rad, parameter[member[.lat1]]], call[.deg2rad, parameter[member[.lon1]]], call[.deg2rad, para... | Keyword[public] Keyword[static] Keyword[double] identifier[haversineFormulaDeg] operator[SEP] Keyword[double] identifier[lat1] , Keyword[double] identifier[lon1] , Keyword[double] identifier[lat2] , Keyword[double] identifier[lon2] operator[SEP] {
Keyword[return] identifier[haversineFormulaRad] operator[SEP] ... |
public Observable<ServiceResponse<Page<KeyItem>>> getKeysNextSinglePageAsync(final String nextPageLink) {
if (nextPageLink == null) {
throw new IllegalArgumentException("Parameter nextPageLink is required and cannot be null.");
}
String nextUrl = String.format("%s", nextPageLink);
... | class class_name[name] begin[{]
method[getKeysNextSinglePageAsync, return_type[type[Observable]], modifier[public], parameter[nextPageLink]] begin[{]
if[binary_operation[member[.nextPageLink], ==, literal[null]]] begin[{]
ThrowStatement(expression=ClassCreator(arguments=[Literal(pos... | Keyword[public] identifier[Observable] operator[<] identifier[ServiceResponse] operator[<] identifier[Page] operator[<] identifier[KeyItem] operator[>] operator[>] operator[>] identifier[getKeysNextSinglePageAsync] operator[SEP] Keyword[final] identifier[String] identifier[nextPageLink] operator[SEP] {
Keyword[i... |
boolean process(InputStream inputStream) throws IOException {
LOG.entering(CLASS_NAME, "process");
int b;
for (;;) {
switch (state) {
// handle alignment with start-of-frame boundary (after mark)
case START_OF_FRAME:
b = inputStrea... | class class_name[name] begin[{]
method[process, return_type[type[boolean]], modifier[default], parameter[inputStream]] begin[{]
call[LOG.entering, parameter[member[.CLASS_NAME], literal["process"]]]
local_variable[type[int], b]
ForStatement(body=BlockStatement(label=None, statem... | Keyword[boolean] identifier[process] operator[SEP] identifier[InputStream] identifier[inputStream] operator[SEP] Keyword[throws] identifier[IOException] {
identifier[LOG] operator[SEP] identifier[entering] operator[SEP] identifier[CLASS_NAME] , literal[String] operator[SEP] operator[SEP] Keyword[int] identifier... |
public void setExcludedRules(java.util.Collection<ExcludedRule> excludedRules) {
if (excludedRules == null) {
this.excludedRules = null;
return;
}
this.excludedRules = new java.util.ArrayList<ExcludedRule>(excludedRules);
} | class class_name[name] begin[{]
method[setExcludedRules, return_type[void], modifier[public], parameter[excludedRules]] begin[{]
if[binary_operation[member[.excludedRules], ==, literal[null]]] begin[{]
assign[THIS[member[None.excludedRules]], literal[null]]
r... | Keyword[public] Keyword[void] identifier[setExcludedRules] operator[SEP] identifier[java] operator[SEP] identifier[util] operator[SEP] identifier[Collection] operator[<] identifier[ExcludedRule] operator[>] identifier[excludedRules] operator[SEP] {
Keyword[if] operator[SEP] identifier[excludedRules] operator[==]... |
protected boolean isNameDifferentBetweenPropertyAndColumn(
EntityDesc entityDesc, EntityPropertyDesc propertyDesc) {
String propertyName = propertyDesc.getName();
String columnName = propertyDesc.getColumnName();
NamingType namingType = entityDesc.getNamingType();
return !columnName.equalsIgnoreCa... | class class_name[name] begin[{]
method[isNameDifferentBetweenPropertyAndColumn, return_type[type[boolean]], modifier[protected], parameter[entityDesc, propertyDesc]] begin[{]
local_variable[type[String], propertyName]
local_variable[type[String], columnName]
local_variable[type[NamingTy... | Keyword[protected] Keyword[boolean] identifier[isNameDifferentBetweenPropertyAndColumn] operator[SEP] identifier[EntityDesc] identifier[entityDesc] , identifier[EntityPropertyDesc] identifier[propertyDesc] operator[SEP] {
identifier[String] identifier[propertyName] operator[=] identifier[propertyDesc] operator[... |
private static String formatLogParam(Clob obj) {
String result="";
try {
result= "(cblob of length "+obj.length()+")";
} catch (SQLException e) {
result = "(cblob of unknown length)";
}
return result;
} | class class_name[name] begin[{]
method[formatLogParam, return_type[type[String]], modifier[private static], parameter[obj]] begin[{]
local_variable[type[String], result]
TryStatement(block=[StatementExpression(expression=Assignment(expressionl=MemberReference(member=result, postfix_operators=[]... | Keyword[private] Keyword[static] identifier[String] identifier[formatLogParam] operator[SEP] identifier[Clob] identifier[obj] operator[SEP] {
identifier[String] identifier[result] operator[=] literal[String] operator[SEP] Keyword[try] {
identifier[result] operator[=] literal[String] operator[+] identi... |
@Pure
@Inline(value = "PhysicsUtil.getPhysicsEngine().motionNewtonLaw(($1), ($2), ($3))",
imported = {PhysicsUtil.class})
public static double motionNewtonLaw(
double speed,
double acceleration,
double dt) {
return engine.motionNewtonLaw(speed, acceleration, dt);
} | class class_name[name] begin[{]
method[motionNewtonLaw, return_type[type[double]], modifier[public static], parameter[speed, acceleration, dt]] begin[{]
return[call[engine.motionNewtonLaw, parameter[member[.speed], member[.acceleration], member[.dt]]]]
end[}]
END[}] | annotation[@] identifier[Pure] annotation[@] identifier[Inline] operator[SEP] identifier[value] operator[=] literal[String] , identifier[imported] operator[=] {
identifier[PhysicsUtil] operator[SEP] Keyword[class]
} operator[SEP] Keyword[public] Keyword[static] Keyword[double] identifier[motionNewtonLaw] ope... |
private final static Throwable getNestedThrowable(Throwable t) {
// This is the current list of Throwables that we know of that support nested
// exceptions. Add to the list if more show up.
// D200273
// Throwables that support nested exceptions using getCause are not special any more ... | class class_name[name] begin[{]
method[getNestedThrowable, return_type[type[Throwable]], modifier[final private static], parameter[t]] begin[{]
local_variable[type[Class], cName]
if[call[cName.getName, parameter[]]] begin[{]
return[Cast(expression=MethodInvocation(arguments=[MemberRefer... | Keyword[private] Keyword[final] Keyword[static] identifier[Throwable] identifier[getNestedThrowable] operator[SEP] identifier[Throwable] identifier[t] operator[SEP] {
identifier[Class] operator[<] operator[?] operator[>] identifier[cName] operator[=] identifier[t] operator[SEP] identifier[getClass] operator[SEP]... |
@Trivial
static boolean isImmediateExpression(String expression, boolean mask) {
final String methodName = "isImmediateExpression";
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) {
Tr.entry(tc, methodName, new Object[] { (expression == null) ? null : mask ? OBFUSCATED_S... | class class_name[name] begin[{]
method[isImmediateExpression, return_type[type[boolean]], modifier[static], parameter[expression, mask]] begin[{]
local_variable[type[String], methodName]
if[binary_operation[call[TraceComponent.isAnyTracingEnabled, parameter[]], &&, call[tc.isEntryEnable... | annotation[@] identifier[Trivial] Keyword[static] Keyword[boolean] identifier[isImmediateExpression] operator[SEP] identifier[String] identifier[expression] , Keyword[boolean] identifier[mask] operator[SEP] {
Keyword[final] identifier[String] identifier[methodName] operator[=] literal[String] operator[SEP] Keyw... |
@Override
public void release() throws CpoException {
for (CpoReleasible releasible : releasibles) {
try {
releasible.release();
} catch (CpoException ce) {
logger.error("Error Releasing Callable Statement Transform Object", ce);
throw ce;
}
}
} | class class_name[name] begin[{]
method[release, return_type[void], modifier[public], parameter[]] begin[{]
ForStatement(body=BlockStatement(label=None, statements=[TryStatement(block=[StatementExpression(expression=MethodInvocation(arguments=[], member=release, postfix_operators=[], prefix_operators=[]... | annotation[@] identifier[Override] Keyword[public] Keyword[void] identifier[release] operator[SEP] operator[SEP] Keyword[throws] identifier[CpoException] {
Keyword[for] operator[SEP] identifier[CpoReleasible] identifier[releasible] operator[:] identifier[releasibles] operator[SEP] {
Keyword[try] {
... |
public long restart(String str, PrintStream stream) {
long elapsed = this.report(str, stream);
this.start();
return elapsed;
} | class class_name[name] begin[{]
method[restart, return_type[type[long]], modifier[public], parameter[str, stream]] begin[{]
local_variable[type[long], elapsed]
THIS[call[None.start, parameter[]]]
return[member[.elapsed]]
end[}]
END[}] | Keyword[public] Keyword[long] identifier[restart] operator[SEP] identifier[String] identifier[str] , identifier[PrintStream] identifier[stream] operator[SEP] {
Keyword[long] identifier[elapsed] operator[=] Keyword[this] operator[SEP] identifier[report] operator[SEP] identifier[str] , identifier[stream] operato... |
public T deserialize(String xml) {
if (xml == null || xml.equals("")) {
throw new RuntimeException("XML cannot be null or empty");
} else {
return deserialize(new StreamSource(new StringReader(xml)));
}
} | class class_name[name] begin[{]
method[deserialize, return_type[type[T]], modifier[public], parameter[xml]] begin[{]
if[binary_operation[binary_operation[member[.xml], ==, literal[null]], ||, call[xml.equals, parameter[literal[""]]]]] begin[{]
ThrowStatement(expression=ClassCreator(... | Keyword[public] identifier[T] identifier[deserialize] operator[SEP] identifier[String] identifier[xml] operator[SEP] {
Keyword[if] operator[SEP] identifier[xml] operator[==] Other[null] operator[||] identifier[xml] operator[SEP] identifier[equals] operator[SEP] literal[String] operator[SEP] operator[SEP] {
... |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.