code stringlengths 63 466k | code_sememe stringlengths 141 3.79M | token_type stringlengths 274 1.23M |
|---|---|---|
public com.google.privacy.dlp.v2.TimePartConfigOrBuilder getTimePartConfigOrBuilder() {
if (transformationCase_ == 8) {
return (com.google.privacy.dlp.v2.TimePartConfig) transformation_;
}
return com.google.privacy.dlp.v2.TimePartConfig.getDefaultInstance();
} | class class_name[name] begin[{]
method[getTimePartConfigOrBuilder, return_type[type[com]], modifier[public], parameter[]] begin[{]
if[binary_operation[member[.transformationCase_], ==, literal[8]]] begin[{]
return[Cast(expression=MemberReference(member=transformation_, postfix_opera... | Keyword[public] identifier[com] operator[SEP] identifier[google] operator[SEP] identifier[privacy] operator[SEP] identifier[dlp] operator[SEP] identifier[v2] operator[SEP] identifier[TimePartConfigOrBuilder] identifier[getTimePartConfigOrBuilder] operator[SEP] operator[SEP] {
Keyword[if] operator[SEP] identifier... |
@com.fasterxml.jackson.annotation.JsonProperty("ResourceARN")
public void setResourceARN(String resourceARN) {
this.resourceARN = resourceARN;
} | class class_name[name] begin[{]
method[setResourceARN, return_type[void], modifier[public], parameter[resourceARN]] begin[{]
assign[THIS[member[None.resourceARN]], member[.resourceARN]]
end[}]
END[}] | annotation[@] identifier[com] operator[SEP] identifier[fasterxml] operator[SEP] identifier[jackson] operator[SEP] identifier[annotation] operator[SEP] identifier[JsonProperty] operator[SEP] literal[String] operator[SEP] Keyword[public] Keyword[void] identifier[setResourceARN] operator[SEP] identifier[String] identifier... |
public static <T> T[] resize(T[] buffer, int newSize) {
return resize(buffer, newSize, buffer.getClass().getComponentType());
} | class class_name[name] begin[{]
method[resize, return_type[type[T]], modifier[public static], parameter[buffer, newSize]] begin[{]
return[call[.resize, parameter[member[.buffer], member[.newSize], call[buffer.getClass, parameter[]]]]]
end[}]
END[}] | Keyword[public] Keyword[static] operator[<] identifier[T] operator[>] identifier[T] operator[SEP] operator[SEP] identifier[resize] operator[SEP] identifier[T] operator[SEP] operator[SEP] identifier[buffer] , Keyword[int] identifier[newSize] operator[SEP] {
Keyword[return] identifier[resize] operator[SEP] identi... |
public final Note getOccurrenceNote(OccurrenceName name) {
GetOccurrenceNoteRequest request =
GetOccurrenceNoteRequest.newBuilder()
.setName(name == null ? null : name.toString())
.build();
return getOccurrenceNote(request);
} | class class_name[name] begin[{]
method[getOccurrenceNote, return_type[type[Note]], modifier[final public], parameter[name]] begin[{]
local_variable[type[GetOccurrenceNoteRequest], request]
return[call[.getOccurrenceNote, parameter[member[.request]]]]
end[}]
END[}] | Keyword[public] Keyword[final] identifier[Note] identifier[getOccurrenceNote] operator[SEP] identifier[OccurrenceName] identifier[name] operator[SEP] {
identifier[GetOccurrenceNoteRequest] identifier[request] operator[=] identifier[GetOccurrenceNoteRequest] operator[SEP] identifier[newBuilder] operator[SEP] oper... |
public boolean bindingLogin(String username, Object password) throws Exception {
if (StringUtils.isBlank(_userObjectClass)|| StringUtils.isBlank(_userIdAttribute)
|| StringUtils.isBlank(_userBaseDn)){
LOG.error("Failed to get user because at least one of the following is null : " +
"[_userOb... | class class_name[name] begin[{]
method[bindingLogin, return_type[type[boolean]], modifier[public], parameter[username, password]] begin[{]
if[binary_operation[binary_operation[call[StringUtils.isBlank, parameter[member[._userObjectClass]]], ||, call[StringUtils.isBlank, parameter[member[._userI... | Keyword[public] Keyword[boolean] identifier[bindingLogin] operator[SEP] identifier[String] identifier[username] , identifier[Object] identifier[password] operator[SEP] Keyword[throws] identifier[Exception] {
Keyword[if] operator[SEP] identifier[StringUtils] operator[SEP] identifier[isBlank] operator[SEP] identi... |
public void marshall(CodeHook codeHook, ProtocolMarshaller protocolMarshaller) {
if (codeHook == null) {
throw new SdkClientException("Invalid argument passed to marshall(...)");
}
try {
protocolMarshaller.marshall(codeHook.getUri(), URI_BINDING);
protocolMa... | class class_name[name] begin[{]
method[marshall, return_type[void], modifier[public], parameter[codeHook, protocolMarshaller]] begin[{]
if[binary_operation[member[.codeHook], ==, literal[null]]] begin[{]
ThrowStatement(expression=ClassCreator(arguments=[Literal(postfix_operators=[],... | Keyword[public] Keyword[void] identifier[marshall] operator[SEP] identifier[CodeHook] identifier[codeHook] , identifier[ProtocolMarshaller] identifier[protocolMarshaller] operator[SEP] {
Keyword[if] operator[SEP] identifier[codeHook] operator[==] Other[null] operator[SEP] {
Keyword[throw] Keyword[new... |
public DrawerBuilder withDrawerWidthRes(@DimenRes int drawerWidthRes) {
if (mActivity == null) {
throw new RuntimeException("please pass an activity first to use this call");
}
this.mDrawerWidth = mActivity.getResources().getDimensionPixelSize(drawerWidthRes);
return this;
... | class class_name[name] begin[{]
method[withDrawerWidthRes, return_type[type[DrawerBuilder]], modifier[public], parameter[drawerWidthRes]] begin[{]
if[binary_operation[member[.mActivity], ==, literal[null]]] begin[{]
ThrowStatement(expression=ClassCreator(arguments=[Literal(postfix_o... | Keyword[public] identifier[DrawerBuilder] identifier[withDrawerWidthRes] operator[SEP] annotation[@] identifier[DimenRes] Keyword[int] identifier[drawerWidthRes] operator[SEP] {
Keyword[if] operator[SEP] identifier[mActivity] operator[==] Other[null] operator[SEP] {
Keyword[throw] Keyword[new] identif... |
private void assertApplicable( FunctionInputDef inputDef, VarNamePattern varNamePattern) throws IllegalArgumentException
{
if( !varNamePattern.isApplicable( inputDef))
{
throw new IllegalArgumentException( "Can't find variable matching pattern=" + varNamePattern);
}
} | class class_name[name] begin[{]
method[assertApplicable, return_type[void], modifier[private], parameter[inputDef, varNamePattern]] begin[{]
if[call[varNamePattern.isApplicable, parameter[member[.inputDef]]]] begin[{]
ThrowStatement(expression=ClassCreator(arguments=[BinaryOperation... | Keyword[private] Keyword[void] identifier[assertApplicable] operator[SEP] identifier[FunctionInputDef] identifier[inputDef] , identifier[VarNamePattern] identifier[varNamePattern] operator[SEP] Keyword[throws] identifier[IllegalArgumentException] {
Keyword[if] operator[SEP] operator[!] identifier[varNamePattern... |
private <ReqT, RespT> boolean authenticateCall(ServerCall<ReqT, RespT> call, Metadata headers) {
// Fail validation for cancelled server calls.
if (call.isCancelled()) {
LOG.debug("Server call has been cancelled: %s",
call.getMethodDescriptor().getFullMethodName());
return false;
}
... | class class_name[name] begin[{]
method[authenticateCall, return_type[type[boolean]], modifier[private], parameter[call, headers]] begin[{]
if[call[call.isCancelled, parameter[]]] begin[{]
call[LOG.debug, parameter[literal["Server call has been cancelled: %s"], call[call.... | Keyword[private] operator[<] identifier[ReqT] , identifier[RespT] operator[>] Keyword[boolean] identifier[authenticateCall] operator[SEP] identifier[ServerCall] operator[<] identifier[ReqT] , identifier[RespT] operator[>] identifier[call] , identifier[Metadata] identifier[headers] operator[SEP] {
Keyword[if] ... |
public InputStream read() throws IOException {
if(file.exists())
try {
return Files.newInputStream(file.toPath());
} catch (InvalidPathException e) {
throw new IOException(e);
}
// check if the compressed file exists
if(gz.exis... | class class_name[name] begin[{]
method[read, return_type[type[InputStream]], modifier[public], parameter[]] begin[{]
if[call[file.exists, parameter[]]] begin[{]
TryStatement(block=[ReturnStatement(expression=MethodInvocation(arguments=[MethodInvocation(arguments=[], member=toPath, postfix_opera... | Keyword[public] identifier[InputStream] identifier[read] operator[SEP] operator[SEP] Keyword[throws] identifier[IOException] {
Keyword[if] operator[SEP] identifier[file] operator[SEP] identifier[exists] operator[SEP] operator[SEP] operator[SEP] Keyword[try] {
Keyword[return] identifier[Files] operator... |
protected static boolean saveAuthentication(URL url, String authenticationToken, boolean authenticationTokenIsPrivate,
String applicationKey, int timeToLive, String privateKey, Map<String, LinkedList<ChannelPermissions>> permissions, Proxy proxy)
throws IOException {
String postBody = String.format("AT=... | class class_name[name] begin[{]
method[saveAuthentication, return_type[type[boolean]], modifier[static protected], parameter[url, authenticationToken, authenticationTokenIsPrivate, applicationKey, timeToLive, privateKey, permissions, proxy]] begin[{]
local_variable[type[String], postBody]
ForSt... | Keyword[protected] Keyword[static] Keyword[boolean] identifier[saveAuthentication] operator[SEP] identifier[URL] identifier[url] , identifier[String] identifier[authenticationToken] , Keyword[boolean] identifier[authenticationTokenIsPrivate] , identifier[String] identifier[applicationKey] , Keyword[int] identifier[... |
@Override
public KamNode getKamNode(final Kam kam, BelTerm belTerm) {
if (kam == null) throw new InvalidArgument("missing KAM");
if (belTerm == null) throw new InvalidArgument("missing BEL term");
if (!exists(kam)) return null;
return getKamNode(kam, belTerm.getLabel());
} | class class_name[name] begin[{]
method[getKamNode, return_type[type[KamNode]], modifier[public], parameter[kam, belTerm]] begin[{]
if[binary_operation[member[.kam], ==, literal[null]]] begin[{]
ThrowStatement(expression=ClassCreator(arguments=[Literal(postfix_operators=[], prefix_operators=[], ... | annotation[@] identifier[Override] Keyword[public] identifier[KamNode] identifier[getKamNode] operator[SEP] Keyword[final] identifier[Kam] identifier[kam] , identifier[BelTerm] identifier[belTerm] operator[SEP] {
Keyword[if] operator[SEP] identifier[kam] operator[==] Other[null] operator[SEP] Keyword[throw] Key... |
@Override
public Map<String, RamlUriParameter> getResolvedUriParameters() {
Map<String, RamlUriParameter> resolvedUriParameters = new HashMap<>();
RamlResource resource = this;
while (resource != null) {
resolvedUriParameters = Stream
.concat(resolvedUriParameters.entrySet().stream(), resource.getUriPar... | class class_name[name] begin[{]
method[getResolvedUriParameters, return_type[type[Map]], modifier[public], parameter[]] begin[{]
local_variable[type[Map], resolvedUriParameters]
local_variable[type[RamlResource], resource]
while[binary_operation[member[.resource], !=, literal[nu... | annotation[@] identifier[Override] Keyword[public] identifier[Map] operator[<] identifier[String] , identifier[RamlUriParameter] operator[>] identifier[getResolvedUriParameters] operator[SEP] operator[SEP] {
identifier[Map] operator[<] identifier[String] , identifier[RamlUriParameter] operator[>] identifier[re... |
public void reportCompletion(NodeT completed) {
completed.setPreparer(true);
String dependency = completed.key();
for (String dependentKey : nodeTable.get(dependency).dependentKeys()) {
DAGNode<DataT, NodeT> dependent = nodeTable.get(dependentKey);
dependent.lock().lock()... | class class_name[name] begin[{]
method[reportCompletion, return_type[void], modifier[public], parameter[completed]] begin[{]
call[completed.setPreparer, parameter[literal[true]]]
local_variable[type[String], dependency]
ForStatement(body=BlockStatement(label=None, statements=[Lo... | Keyword[public] Keyword[void] identifier[reportCompletion] operator[SEP] identifier[NodeT] identifier[completed] operator[SEP] {
identifier[completed] operator[SEP] identifier[setPreparer] operator[SEP] literal[boolean] operator[SEP] operator[SEP] identifier[String] identifier[dependency] operator[=] identifier[... |
protected void handle(Object job) throws InterruptedException
{
if(job!=null&&job instanceof Runnable)
((Runnable)job).run();
else
log.warn("Invalid job: "+job);
} | class class_name[name] begin[{]
method[handle, return_type[void], modifier[protected], parameter[job]] begin[{]
if[binary_operation[binary_operation[member[.job], !=, literal[null]], &&, binary_operation[member[.job], instanceof, type[Runnable]]]] begin[{]
Cast(expression=MemberRefe... | Keyword[protected] Keyword[void] identifier[handle] operator[SEP] identifier[Object] identifier[job] operator[SEP] Keyword[throws] identifier[InterruptedException] {
Keyword[if] operator[SEP] identifier[job] operator[!=] Other[null] operator[&&] identifier[job] Keyword[instanceof] identifier[Runnable] operator[S... |
public boolean isSet(_Fields field) {
if (field == null) {
throw new IllegalArgumentException();
}
switch (field) {
case METRIC_WINDOW:
return is_set_metricWindow();
}
throw new IllegalStateException();
} | 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 static <T> Optional<T> narrowK(final Higher<optional, T> Optional) {
//has to be an OptionalKind as only OptionalKind can implement Higher<optional, T>
return ((OptionalKind<T>)Optional).boxed;
} | class class_name[name] begin[{]
method[narrowK, return_type[type[Optional]], modifier[public static], parameter[Optional]] begin[{]
return[Cast(expression=MemberReference(member=Optional, postfix_operators=[], prefix_operators=[], qualifier=, selectors=[]), type=ReferenceType(arguments=[TypeArgument(pa... | Keyword[public] Keyword[static] operator[<] identifier[T] operator[>] identifier[Optional] operator[<] identifier[T] operator[>] identifier[narrowK] operator[SEP] Keyword[final] identifier[Higher] operator[<] identifier[optional] , identifier[T] operator[>] identifier[Optional] operator[SEP] {
Keyword[return] o... |
public static <T> void putAt(List<T> self, int idx, T value) {
int size = self.size();
idx = normaliseIndex(idx, size);
if (idx < size) {
self.set(idx, value);
} else {
while (size < idx) {
self.add(size++, null);
}
self.add... | class class_name[name] begin[{]
method[putAt, return_type[void], modifier[public static], parameter[self, idx, value]] begin[{]
local_variable[type[int], size]
assign[member[.idx], call[.normaliseIndex, parameter[member[.idx], member[.size]]]]
if[binary_operation[member[... | Keyword[public] Keyword[static] operator[<] identifier[T] operator[>] Keyword[void] identifier[putAt] operator[SEP] identifier[List] operator[<] identifier[T] operator[>] identifier[self] , Keyword[int] identifier[idx] , identifier[T] identifier[value] operator[SEP] {
Keyword[int] identifier[size] operator[=] ... |
private static Map<ExpectedLabels, Integer> mapLabels(final List<String> labels) {
final Map<ExpectedLabels, Integer> map = new EnumMap<>(ExpectedLabels.class);
final List<ExpectedLabels> unusedLabels = new ArrayList<>(Arrays.asList(ExpectedLabels.values()));
for (int index = 0; index < labels.size(); index+... | class class_name[name] begin[{]
method[mapLabels, return_type[type[Map]], modifier[private static], parameter[labels]] begin[{]
local_variable[type[Map], map]
local_variable[type[List], unusedLabels]
ForStatement(body=BlockStatement(label=None, statements=[LocalVariableDeclaration(annot... | Keyword[private] Keyword[static] identifier[Map] operator[<] identifier[ExpectedLabels] , identifier[Integer] operator[>] identifier[mapLabels] operator[SEP] Keyword[final] identifier[List] operator[<] identifier[String] operator[>] identifier[labels] operator[SEP] {
Keyword[final] identifier[Map] operator[<] i... |
private String formatCoef(double coef) {
double tol = 1e-6; // rounding tolerance
// zero case
if( Math.abs(coef) < tol) {
return "0";
}
// integer case
long num = Math.round(coef);
if( Math.abs(num - coef) < tol) {
return Long.toString(num);
}
// Other small cases
for(int denom = 2; denom ... | class class_name[name] begin[{]
method[formatCoef, return_type[type[String]], modifier[private], parameter[coef]] begin[{]
local_variable[type[double], tol]
if[binary_operation[call[Math.abs, parameter[member[.coef]]], <, member[.tol]]] begin[{]
return[literal["0"]]
... | Keyword[private] identifier[String] identifier[formatCoef] operator[SEP] Keyword[double] identifier[coef] operator[SEP] {
Keyword[double] identifier[tol] operator[=] literal[Float] operator[SEP] Keyword[if] operator[SEP] identifier[Math] operator[SEP] identifier[abs] operator[SEP] identifier[coef] operator[SEP] ... |
@Override
public void close()
throws IOException
{
if (_isClosed.getAndSet(true)) {
return;
}
_ss = null;
if (_stream != null) {
_stream.close();
}
// XXX: can't be locked because of shutdown
_nativeFd = -1;
nativeClose(_socketFd);
} | class class_name[name] begin[{]
method[close, return_type[void], modifier[public], parameter[]] begin[{]
if[call[_isClosed.getAndSet, parameter[literal[true]]]] begin[{]
return[None]
else begin[{]
None
end[}]
assign[member[._ss], literal[null]]
... | annotation[@] identifier[Override] Keyword[public] Keyword[void] identifier[close] operator[SEP] operator[SEP] Keyword[throws] identifier[IOException] {
Keyword[if] operator[SEP] identifier[_isClosed] operator[SEP] identifier[getAndSet] operator[SEP] literal[boolean] operator[SEP] operator[SEP] {
Keyw... |
public static Server forRouter(Function<BuiltInComponents, Router> block) {
return forRouter(Mode.TEST, 0, block);
} | class class_name[name] begin[{]
method[forRouter, return_type[type[Server]], modifier[public static], parameter[block]] begin[{]
return[call[.forRouter, parameter[member[Mode.TEST], literal[0], member[.block]]]]
end[}]
END[}] | Keyword[public] Keyword[static] identifier[Server] identifier[forRouter] operator[SEP] identifier[Function] operator[<] identifier[BuiltInComponents] , identifier[Router] operator[>] identifier[block] operator[SEP] {
Keyword[return] identifier[forRouter] operator[SEP] identifier[Mode] operator[SEP] identifier[T... |
protected Collection<String> getUserRoles(PortletRequest request) {
ArrayList<String> portletUserRolesList = new ArrayList<String>();
for (String role : portletMappableRoles) {
if (request.isUserInRole(role)) {
portletUserRolesList.add(role);
}
}
... | class class_name[name] begin[{]
method[getUserRoles, return_type[type[Collection]], modifier[protected], parameter[request]] begin[{]
local_variable[type[ArrayList], portletUserRolesList]
ForStatement(body=BlockStatement(label=None, statements=[IfStatement(condition=MethodInvocation(arguments=[... | Keyword[protected] identifier[Collection] operator[<] identifier[String] operator[>] identifier[getUserRoles] operator[SEP] identifier[PortletRequest] identifier[request] operator[SEP] {
identifier[ArrayList] operator[<] identifier[String] operator[>] identifier[portletUserRolesList] operator[=] Keyword[new] ide... |
public PlainTimestamp minus(
long amount,
ClockUnit unit
) {
return this.plus(Math.negateExact(amount), unit);
} | class class_name[name] begin[{]
method[minus, return_type[type[PlainTimestamp]], modifier[public], parameter[amount, unit]] begin[{]
return[THIS[call[None.plus, parameter[call[Math.negateExact, parameter[member[.amount]]], member[.unit]]]]]
end[}]
END[}] | Keyword[public] identifier[PlainTimestamp] identifier[minus] operator[SEP] Keyword[long] identifier[amount] , identifier[ClockUnit] identifier[unit] operator[SEP] {
Keyword[return] Keyword[this] operator[SEP] identifier[plus] operator[SEP] identifier[Math] operator[SEP] identifier[negateExact] operator[SEP] ide... |
public void setStackEvents(java.util.Collection<StackEvent> stackEvents) {
if (stackEvents == null) {
this.stackEvents = null;
return;
}
this.stackEvents = new com.amazonaws.internal.SdkInternalList<StackEvent>(stackEvents);
} | class class_name[name] begin[{]
method[setStackEvents, return_type[void], modifier[public], parameter[stackEvents]] begin[{]
if[binary_operation[member[.stackEvents], ==, literal[null]]] begin[{]
assign[THIS[member[None.stackEvents]], literal[null]]
return[No... | Keyword[public] Keyword[void] identifier[setStackEvents] operator[SEP] identifier[java] operator[SEP] identifier[util] operator[SEP] identifier[Collection] operator[<] identifier[StackEvent] operator[>] identifier[stackEvents] operator[SEP] {
Keyword[if] operator[SEP] identifier[stackEvents] operator[==] Other[n... |
@NotNull
public static Collector<CharSequence, ?, String> joining(
@NotNull final CharSequence delimiter,
@NotNull final CharSequence prefix,
@NotNull final CharSequence suffix,
@NotNull final String emptyValue) {
return new CollectorsImpl<CharSequence, String... | class class_name[name] begin[{]
method[joining, return_type[type[Collector]], modifier[public static], parameter[delimiter, prefix, suffix, emptyValue]] begin[{]
return[ClassCreator(arguments=[ClassCreator(arguments=[], body=[MethodDeclaration(annotations=[Annotation(element=None, name=NotNull), Annota... | annotation[@] identifier[NotNull] Keyword[public] Keyword[static] identifier[Collector] operator[<] identifier[CharSequence] , operator[?] , identifier[String] operator[>] identifier[joining] operator[SEP] annotation[@] identifier[NotNull] Keyword[final] identifier[CharSequence] identifier[delimiter] , annotation[@]... |
public static String format(final LocalDateTime self, FormatStyle dateTimeStyle) {
return self.format(DateTimeFormatter.ofLocalizedDateTime(dateTimeStyle));
} | class class_name[name] begin[{]
method[format, return_type[type[String]], modifier[public static], parameter[self, dateTimeStyle]] begin[{]
return[call[self.format, parameter[call[DateTimeFormatter.ofLocalizedDateTime, parameter[member[.dateTimeStyle]]]]]]
end[}]
END[}] | Keyword[public] Keyword[static] identifier[String] identifier[format] operator[SEP] Keyword[final] identifier[LocalDateTime] identifier[self] , identifier[FormatStyle] identifier[dateTimeStyle] operator[SEP] {
Keyword[return] identifier[self] operator[SEP] identifier[format] operator[SEP] identifier[DateTimeFor... |
public OutputDestination withSettings(OutputDestinationSettings... settings) {
if (this.settings == null) {
setSettings(new java.util.ArrayList<OutputDestinationSettings>(settings.length));
}
for (OutputDestinationSettings ele : settings) {
this.settings.add(ele);
... | class class_name[name] begin[{]
method[withSettings, return_type[type[OutputDestination]], modifier[public], parameter[settings]] begin[{]
if[binary_operation[THIS[member[None.settings]], ==, literal[null]]] begin[{]
call[.setSettings, parameter[ClassCreator(arguments=[M... | Keyword[public] identifier[OutputDestination] identifier[withSettings] operator[SEP] identifier[OutputDestinationSettings] operator[...] identifier[settings] operator[SEP] {
Keyword[if] operator[SEP] Keyword[this] operator[SEP] identifier[settings] operator[==] Other[null] operator[SEP] {
identifier[s... |
public TypeSpec generateType(Type type) {
AdapterConstant adapterConstant = profile.getAdapter(type.type());
if (adapterConstant != null) {
return generateAdapterForCustomType(type);
}
if (type instanceof MessageType) {
//noinspection deprecation: Only deprecated as a public API.
retur... | class class_name[name] begin[{]
method[generateType, return_type[type[TypeSpec]], modifier[public], parameter[type]] begin[{]
local_variable[type[AdapterConstant], adapterConstant]
if[binary_operation[member[.adapterConstant], !=, literal[null]]] begin[{]
return[call[.genera... | Keyword[public] identifier[TypeSpec] identifier[generateType] operator[SEP] identifier[Type] identifier[type] operator[SEP] {
identifier[AdapterConstant] identifier[adapterConstant] operator[=] identifier[profile] operator[SEP] identifier[getAdapter] operator[SEP] identifier[type] operator[SEP] identifier[type] ... |
public final AntlrDatatypeRuleToken ruleOpAnd() throws RecognitionException {
AntlrDatatypeRuleToken current = new AntlrDatatypeRuleToken();
Token kw=null;
enterRule();
try {
// InternalPureXbase.g:1219:2: (kw= '&&' )
// InternalPureXbase.g:1220:2: kw= '&&'
... | class class_name[name] begin[{]
method[ruleOpAnd, return_type[type[AntlrDatatypeRuleToken]], modifier[final public], parameter[]] begin[{]
local_variable[type[AntlrDatatypeRuleToken], current]
local_variable[type[Token], kw]
call[.enterRule, parameter[]]
TryStatement(blo... | Keyword[public] Keyword[final] identifier[AntlrDatatypeRuleToken] identifier[ruleOpAnd] operator[SEP] operator[SEP] Keyword[throws] identifier[RecognitionException] {
identifier[AntlrDatatypeRuleToken] identifier[current] operator[=] Keyword[new] identifier[AntlrDatatypeRuleToken] operator[SEP] operator[SEP] ope... |
public static Function<Integer, Integer> create(int baseline) {
return INSTANCE.andThen(t -> t + baseline);
} | class class_name[name] begin[{]
method[create, return_type[type[Function]], modifier[public static], parameter[baseline]] begin[{]
return[call[INSTANCE.andThen, parameter[LambdaExpression(body=BinaryOperation(operandl=MemberReference(member=t, postfix_operators=[], prefix_operators=[], qualifier=, sele... | Keyword[public] Keyword[static] identifier[Function] operator[<] identifier[Integer] , identifier[Integer] operator[>] identifier[create] operator[SEP] Keyword[int] identifier[baseline] operator[SEP] {
Keyword[return] identifier[INSTANCE] operator[SEP] identifier[andThen] operator[SEP] identifier[t] operator[->... |
private boolean isCompletelyCoveredBy(int[] isCovered, List<RuleInterval> intervals) {
for (RuleInterval i : intervals) {
for (int j = i.getStart(); j < i.getEnd(); j++) {
if (isCovered[j] == 0) {
return false;
}
}
}
return true;
} | class class_name[name] begin[{]
method[isCompletelyCoveredBy, return_type[type[boolean]], modifier[private], parameter[isCovered, intervals]] begin[{]
ForStatement(body=BlockStatement(label=None, statements=[ForStatement(body=BlockStatement(label=None, statements=[IfStatement(condition=BinaryOperation(... | Keyword[private] Keyword[boolean] identifier[isCompletelyCoveredBy] operator[SEP] Keyword[int] operator[SEP] operator[SEP] identifier[isCovered] , identifier[List] operator[<] identifier[RuleInterval] operator[>] identifier[intervals] operator[SEP] {
Keyword[for] operator[SEP] identifier[RuleInterval] identifie... |
private boolean canSwap(SubsetSolution solution, Set<Integer> addCandidates, Set<Integer> deleteCandidates){
return !addCandidates.isEmpty()
&& !deleteCandidates.isEmpty()
&& isValidSubsetSize(solution.getNumSelectedIDs());
} | class class_name[name] begin[{]
method[canSwap, return_type[type[boolean]], modifier[private], parameter[solution, addCandidates, deleteCandidates]] begin[{]
return[binary_operation[binary_operation[call[addCandidates.isEmpty, parameter[]], &&, call[deleteCandidates.isEmpty, parameter[]]], &&, call[.is... | Keyword[private] Keyword[boolean] identifier[canSwap] operator[SEP] identifier[SubsetSolution] identifier[solution] , identifier[Set] operator[<] identifier[Integer] operator[>] identifier[addCandidates] , identifier[Set] operator[<] identifier[Integer] operator[>] identifier[deleteCandidates] operator[SEP] {
... |
public String getName() {
String loc = ncd.getLocation();
int pos = loc.lastIndexOf('/');
if (pos < 0)
pos = loc.lastIndexOf('\\');
return (pos < 0) ? loc : loc.substring(pos + 1);
} | class class_name[name] begin[{]
method[getName, return_type[type[String]], modifier[public], parameter[]] begin[{]
local_variable[type[String], loc]
local_variable[type[int], pos]
if[binary_operation[member[.pos], <, literal[0]]] begin[{]
assign[member[.pos], call[lo... | Keyword[public] identifier[String] identifier[getName] operator[SEP] operator[SEP] {
identifier[String] identifier[loc] operator[=] identifier[ncd] operator[SEP] identifier[getLocation] operator[SEP] operator[SEP] operator[SEP] Keyword[int] identifier[pos] operator[=] identifier[loc] operator[SEP] identifier[las... |
private static boolean contains(Object[] arr, Object member) {
for (Object mem : arr) {
if (Objects.equals(mem, member)) {
return true;
}
}
return false;
} | class class_name[name] begin[{]
method[contains, return_type[type[boolean]], modifier[private static], parameter[arr, member]] begin[{]
ForStatement(body=BlockStatement(label=None, statements=[IfStatement(condition=MethodInvocation(arguments=[MemberReference(member=mem, postfix_operators=[], prefix_ope... | Keyword[private] Keyword[static] Keyword[boolean] identifier[contains] operator[SEP] identifier[Object] operator[SEP] operator[SEP] identifier[arr] , identifier[Object] identifier[member] operator[SEP] {
Keyword[for] operator[SEP] identifier[Object] identifier[mem] operator[:] identifier[arr] operator[SEP] {
... |
public static LinearGapAlignmentScoring<AminoAcidSequence> getAminoAcidBLASTScoring(BLASTMatrix matrix, int gapPenalty) {
return new LinearGapAlignmentScoring<>(AminoAcidSequence.ALPHABET,
matrix.getMatrix(),
gapPenalty);
} | class class_name[name] begin[{]
method[getAminoAcidBLASTScoring, return_type[type[LinearGapAlignmentScoring]], modifier[public static], parameter[matrix, gapPenalty]] begin[{]
return[ClassCreator(arguments=[MemberReference(member=ALPHABET, postfix_operators=[], prefix_operators=[], qualifier=AminoAcidS... | Keyword[public] Keyword[static] identifier[LinearGapAlignmentScoring] operator[<] identifier[AminoAcidSequence] operator[>] identifier[getAminoAcidBLASTScoring] operator[SEP] identifier[BLASTMatrix] identifier[matrix] , Keyword[int] identifier[gapPenalty] operator[SEP] {
Keyword[return] Keyword[new] identifier[... |
void fillDeltaEntries(Set<PageLeafEntry> entries,
Row row,
int tail)
{
int rowOffset = _rowHead;
byte []buffer = _buffer;
while (rowOffset < tail) {
int code = buffer[rowOffset] & CODE_MASK;
int len = getLength(code, row);
if (code =... | class class_name[name] begin[{]
method[fillDeltaEntries, return_type[void], modifier[default], parameter[entries, row, tail]] begin[{]
local_variable[type[int], rowOffset]
local_variable[type[byte], buffer]
while[binary_operation[member[.rowOffset], <, member[.tail]]] begin[{]
... | Keyword[void] identifier[fillDeltaEntries] operator[SEP] identifier[Set] operator[<] identifier[PageLeafEntry] operator[>] identifier[entries] , identifier[Row] identifier[row] , Keyword[int] identifier[tail] operator[SEP] {
Keyword[int] identifier[rowOffset] operator[=] identifier[_rowHead] operator[SEP] Keyw... |
public static double compuScoreFreq(Term from, Term term) {
return from.termNatures().allFreq + term.termNatures().allFreq;
} | class class_name[name] begin[{]
method[compuScoreFreq, return_type[type[double]], modifier[public static], parameter[from, term]] begin[{]
return[binary_operation[call[from.termNatures, parameter[]], +, call[term.termNatures, parameter[]]]]
end[}]
END[}] | Keyword[public] Keyword[static] Keyword[double] identifier[compuScoreFreq] operator[SEP] identifier[Term] identifier[from] , identifier[Term] identifier[term] operator[SEP] {
Keyword[return] identifier[from] operator[SEP] identifier[termNatures] operator[SEP] operator[SEP] operator[SEP] identifier[allFreq] oper... |
public MemberSubstitution replaceWithMethod(ElementMatcher<? super MethodDescription> matcher, MethodGraph.Compiler methodGraphCompiler) {
return replaceWith(new Substitution.ForMethodInvocation.OfMatchedMethod(matcher, methodGraphCompiler));
} | class class_name[name] begin[{]
method[replaceWithMethod, return_type[type[MemberSubstitution]], modifier[public], parameter[matcher, methodGraphCompiler]] begin[{]
return[call[.replaceWith, parameter[ClassCreator(arguments=[MemberReference(member=matcher, postfix_operators=[], prefix_operators=[], qua... | Keyword[public] identifier[MemberSubstitution] identifier[replaceWithMethod] operator[SEP] identifier[ElementMatcher] operator[<] operator[?] Keyword[super] identifier[MethodDescription] operator[>] identifier[matcher] , identifier[MethodGraph] operator[SEP] identifier[Compiler] identifier[methodGraphCompiler] operato... |
@Override
public AddThingToBillingGroupResult addThingToBillingGroup(AddThingToBillingGroupRequest request) {
request = beforeClientExecution(request);
return executeAddThingToBillingGroup(request);
} | class class_name[name] begin[{]
method[addThingToBillingGroup, return_type[type[AddThingToBillingGroupResult]], modifier[public], parameter[request]] begin[{]
assign[member[.request], call[.beforeClientExecution, parameter[member[.request]]]]
return[call[.executeAddThingToBillingGroup, ... | annotation[@] identifier[Override] Keyword[public] identifier[AddThingToBillingGroupResult] identifier[addThingToBillingGroup] operator[SEP] identifier[AddThingToBillingGroupRequest] identifier[request] operator[SEP] {
identifier[request] operator[=] identifier[beforeClientExecution] operator[SEP] identifier[req... |
public static boolean isDouble (@Nullable final String sStr)
{
return !Double.isNaN (parseDouble (sStr, Double.NaN));
} | class class_name[name] begin[{]
method[isDouble, return_type[type[boolean]], modifier[public static], parameter[sStr]] begin[{]
return[call[Double.isNaN, parameter[call[.parseDouble, parameter[member[.sStr], member[Double.NaN]]]]]]
end[}]
END[}] | Keyword[public] Keyword[static] Keyword[boolean] identifier[isDouble] operator[SEP] annotation[@] identifier[Nullable] Keyword[final] identifier[String] identifier[sStr] operator[SEP] {
Keyword[return] operator[!] identifier[Double] operator[SEP] identifier[isNaN] operator[SEP] identifier[parseDouble] operator[S... |
protected final UtlInvLine<RS, PurchaseInvoice, PurchaseInvoiceServiceLine,
PurchaseInvoiceTaxLine, PurchaseInvoiceServiceTaxLine> lazyGetUtlPurSrLn(
final Map<String, Object> pAddParam) throws Exception {
UtlInvLine<RS, PurchaseInvoice, PurchaseInvoiceServiceLine,
PurchaseInvoiceTaxLine, PurchaseIn... | class class_name[name] begin[{]
method[lazyGetUtlPurSrLn, return_type[type[UtlInvLine]], modifier[final protected], parameter[pAddParam]] begin[{]
local_variable[type[UtlInvLine], utlInvLn]
if[binary_operation[member[.utlInvLn], ==, literal[null]]] begin[{]
assig... | Keyword[protected] Keyword[final] identifier[UtlInvLine] operator[<] identifier[RS] , identifier[PurchaseInvoice] , identifier[PurchaseInvoiceServiceLine] , identifier[PurchaseInvoiceTaxLine] , identifier[PurchaseInvoiceServiceTaxLine] operator[>] identifier[lazyGetUtlPurSrLn] operator[SEP] Keyword[final] identifie... |
public static EntropyStats entropy(Matrix m) {
if (m instanceof SparseMatrix)
return entropy((SparseMatrix) m);
double sum = 0;
double[] colSums = new double[m.columns()];
double[] rowSums = new double[m.rows()];
for (int r = 0; r < m.rows(); ++r) {
for (... | class class_name[name] begin[{]
method[entropy, return_type[type[EntropyStats]], modifier[public static], parameter[m]] begin[{]
if[binary_operation[member[.m], instanceof, type[SparseMatrix]]] begin[{]
return[call[.entropy, parameter[Cast(expression=MemberReference(member=m, postfix_operators=... | Keyword[public] Keyword[static] identifier[EntropyStats] identifier[entropy] operator[SEP] identifier[Matrix] identifier[m] operator[SEP] {
Keyword[if] operator[SEP] identifier[m] Keyword[instanceof] identifier[SparseMatrix] operator[SEP] Keyword[return] identifier[entropy] operator[SEP] operator[SEP] identifier... |
public String csvItem(CmsListItem item) {
if (m_csvItemFormatter != null) {
return m_csvItemFormatter.csvItem(item);
} else {
StringBuffer csv = new StringBuffer(1024);
Iterator<CmsListColumnDefinition> itCols = m_columns.elementList().iterator();
while (... | class class_name[name] begin[{]
method[csvItem, return_type[type[String]], modifier[public], parameter[item]] begin[{]
if[binary_operation[member[.m_csvItemFormatter], !=, literal[null]]] begin[{]
return[call[m_csvItemFormatter.csvItem, parameter[member[.item]]]]
else begin[... | Keyword[public] identifier[String] identifier[csvItem] operator[SEP] identifier[CmsListItem] identifier[item] operator[SEP] {
Keyword[if] operator[SEP] identifier[m_csvItemFormatter] operator[!=] Other[null] operator[SEP] {
Keyword[return] identifier[m_csvItemFormatter] operator[SEP] identifier[csvIte... |
public static Hashtable[] retrieveProperties(ManagedObject[] mos, String moType,
String[] propPaths) throws InvalidProperty,
RuntimeFault, RemoteException {
if (mos == null) {
throw new IllegalArgumentException("Managed object array cannot... | class class_name[name] begin[{]
method[retrieveProperties, return_type[type[Hashtable]], modifier[public static], parameter[mos, moType, propPaths]] begin[{]
if[binary_operation[member[.mos], ==, literal[null]]] begin[{]
ThrowStatement(expression=ClassCreator(arguments=[Literal(post... | Keyword[public] Keyword[static] identifier[Hashtable] operator[SEP] operator[SEP] identifier[retrieveProperties] operator[SEP] identifier[ManagedObject] operator[SEP] operator[SEP] identifier[mos] , identifier[String] identifier[moType] , identifier[String] operator[SEP] operator[SEP] identifier[propPaths] operator[S... |
protected <X> Specification<ENTITY> buildSpecification(Filter<X> filter, SingularAttribute<? super ENTITY, X>
field) {
return buildSpecification(filter, root -> root.get(field));
} | class class_name[name] begin[{]
method[buildSpecification, return_type[type[Specification]], modifier[protected], parameter[filter, field]] begin[{]
return[call[.buildSpecification, parameter[member[.filter], LambdaExpression(body=MethodInvocation(arguments=[MemberReference(member=field, postfix_operat... | Keyword[protected] operator[<] identifier[X] operator[>] identifier[Specification] operator[<] identifier[ENTITY] operator[>] identifier[buildSpecification] operator[SEP] identifier[Filter] operator[<] identifier[X] operator[>] identifier[filter] , identifier[SingularAttribute] operator[<] operator[?] Keyword[super] i... |
private static String lineExpand(String keyString, Map properties) {
//System.out.println("DEBUG : expand(String, Properties), keyString: " + keyString);
//if ("".equals(keyString))
//throw new Exception("empty key string");
if (resolvesToLiteral(keyString)) {
//System.out... | class class_name[name] begin[{]
method[lineExpand, return_type[type[String]], modifier[private static], parameter[keyString, properties]] begin[{]
if[call[.resolvesToLiteral, parameter[member[.keyString]]]] begin[{]
return[member[.keyString]]
else begin[{]
None
end[}... | Keyword[private] Keyword[static] identifier[String] identifier[lineExpand] operator[SEP] identifier[String] identifier[keyString] , identifier[Map] identifier[properties] operator[SEP] {
Keyword[if] operator[SEP] identifier[resolvesToLiteral] operator[SEP] identifier[keyString] operator[SEP] operator[SEP] {
... |
public void init() throws Exception {
userDir = new File(System.getProperty("user.dir")).getAbsolutePath();
System.setProperty("user.dir", options.getExecutionDirectory().getAbsolutePath());
if (!cfg.exists()) {
ConfigurationManager manager = new ConfigurationManager(cfg, fal... | class class_name[name] begin[{]
method[init, return_type[void], modifier[public], parameter[]] begin[{]
assign[member[.userDir], ClassCreator(arguments=[MethodInvocation(arguments=[Literal(postfix_operators=[], prefix_operators=[], qualifier=None, selectors=[], value="user.dir")], member=getPro... | Keyword[public] Keyword[void] identifier[init] operator[SEP] operator[SEP] Keyword[throws] identifier[Exception] {
identifier[userDir] operator[=] Keyword[new] identifier[File] operator[SEP] identifier[System] operator[SEP] identifier[getProperty] operator[SEP] literal[String] operator[SEP] operator[SEP] operato... |
public static Taint merge(Taint a, Taint b) {
if (a == null) {
if (b == null) {
return null;
} else {
return new Taint(b);
}
} else if (b == null) {
return new Taint(a);
}
assert a != null && b != null;
... | class class_name[name] begin[{]
method[merge, return_type[type[Taint]], modifier[public static], parameter[a, b]] begin[{]
if[binary_operation[member[.a], ==, literal[null]]] begin[{]
if[binary_operation[member[.b], ==, literal[null]]] begin[{]
return[lit... | Keyword[public] Keyword[static] identifier[Taint] identifier[merge] operator[SEP] identifier[Taint] identifier[a] , identifier[Taint] identifier[b] operator[SEP] {
Keyword[if] operator[SEP] identifier[a] operator[==] Other[null] operator[SEP] {
Keyword[if] operator[SEP] identifier[b] operator[==] Oth... |
public static String normalize(CharSequence src, Form form) {
switch (form) {
case NFD: return normalizeNFD(src.toString());
case NFC: return normalizeNFC(src.toString());
case NFKD: return normalizeNFKD(src.toString());
case NFKC: return normalizeNFKC(src.toString());
defa... | class class_name[name] begin[{]
method[normalize, return_type[type[String]], modifier[public static], parameter[src, form]] begin[{]
SwitchStatement(cases=[SwitchStatementCase(case=['NFD'], statements=[ReturnStatement(expression=MethodInvocation(arguments=[MethodInvocation(arguments=[], member=toString... | Keyword[public] Keyword[static] identifier[String] identifier[normalize] operator[SEP] identifier[CharSequence] identifier[src] , identifier[Form] identifier[form] operator[SEP] {
Keyword[switch] operator[SEP] identifier[form] operator[SEP] {
Keyword[case] identifier[NFD] operator[:] Keyword[return]... |
public final ListMetricDescriptorsPagedResponse listMetricDescriptors(ProjectName name) {
ListMetricDescriptorsRequest request =
ListMetricDescriptorsRequest.newBuilder()
.setName(name == null ? null : name.toString())
.build();
return listMetricDescriptors(request);
} | class class_name[name] begin[{]
method[listMetricDescriptors, return_type[type[ListMetricDescriptorsPagedResponse]], modifier[final public], parameter[name]] begin[{]
local_variable[type[ListMetricDescriptorsRequest], request]
return[call[.listMetricDescriptors, parameter[member[.request]]]]
... | Keyword[public] Keyword[final] identifier[ListMetricDescriptorsPagedResponse] identifier[listMetricDescriptors] operator[SEP] identifier[ProjectName] identifier[name] operator[SEP] {
identifier[ListMetricDescriptorsRequest] identifier[request] operator[=] identifier[ListMetricDescriptorsRequest] operator[SEP] id... |
protected static void pushTypeArguments(GeneratorAdapter generatorAdapter, Map<String, Object> types) {
if (types == null || types.isEmpty()) {
generatorAdapter.visitInsn(ACONST_NULL);
return;
}
int len = types.size();
// Build calls to Argument.create(...)
... | class class_name[name] begin[{]
method[pushTypeArguments, return_type[void], modifier[static protected], parameter[generatorAdapter, types]] begin[{]
if[binary_operation[binary_operation[member[.types], ==, literal[null]], ||, call[types.isEmpty, parameter[]]]] begin[{]
... | Keyword[protected] Keyword[static] Keyword[void] identifier[pushTypeArguments] operator[SEP] identifier[GeneratorAdapter] identifier[generatorAdapter] , identifier[Map] operator[<] identifier[String] , identifier[Object] operator[>] identifier[types] operator[SEP] {
Keyword[if] operator[SEP] identifier[types] ... |
public MongoClientOptions getOptions() {
ReadPreference readPreference = proxied.getReadPreference();
if (readPreference != null) {
builder.readPreference(readPreference);
}
ReadConcern readConcern = proxied.getReadConcern();
if (readConcern != null) {
bui... | class class_name[name] begin[{]
method[getOptions, return_type[type[MongoClientOptions]], modifier[public], parameter[]] begin[{]
local_variable[type[ReadPreference], readPreference]
if[binary_operation[member[.readPreference], !=, literal[null]]] begin[{]
call[b... | Keyword[public] identifier[MongoClientOptions] identifier[getOptions] operator[SEP] operator[SEP] {
identifier[ReadPreference] identifier[readPreference] operator[=] identifier[proxied] operator[SEP] identifier[getReadPreference] operator[SEP] operator[SEP] operator[SEP] Keyword[if] operator[SEP] identifier[read... |
CheckedSocket recycle() {
CheckedSocket s;
if (mClosed) {
s = null;
}
else {
s = mSocket;
mSocket = null;
mClosed = true;
}
return s;
} | class class_name[name] begin[{]
method[recycle, return_type[type[CheckedSocket]], modifier[default], parameter[]] begin[{]
local_variable[type[CheckedSocket], s]
if[member[.mClosed]] begin[{]
assign[member[.s], literal[null]]
else begin[{]
... | identifier[CheckedSocket] identifier[recycle] operator[SEP] operator[SEP] {
identifier[CheckedSocket] identifier[s] operator[SEP] Keyword[if] operator[SEP] identifier[mClosed] operator[SEP] {
identifier[s] operator[=] Other[null] operator[SEP]
}
Keyword[else] {
identifier[s] o... |
public static Class<?> getTypeArgument(Class<?> clazz, int index) {
final Type argumentType = TypeUtil.getTypeArgument(clazz, index);
if (null != argumentType && argumentType instanceof Class) {
return (Class<?>) argumentType;
}
return null;
} | class class_name[name] begin[{]
method[getTypeArgument, return_type[type[Class]], modifier[public static], parameter[clazz, index]] begin[{]
local_variable[type[Type], argumentType]
if[binary_operation[binary_operation[literal[null], !=, member[.argumentType]], &&, binary_operation[memb... | Keyword[public] Keyword[static] identifier[Class] operator[<] operator[?] operator[>] identifier[getTypeArgument] operator[SEP] identifier[Class] operator[<] operator[?] operator[>] identifier[clazz] , Keyword[int] identifier[index] operator[SEP] {
Keyword[final] identifier[Type] identifier[argumentType] operat... |
public void takeScreenshot(String name){
if(config.commandLogging){
Log.d(config.commandLoggingTag, "takeScreenshot(\""+name+"\")");
}
takeScreenshot(name, 100);
} | class class_name[name] begin[{]
method[takeScreenshot, return_type[void], modifier[public], parameter[name]] begin[{]
if[member[config.commandLogging]] begin[{]
call[Log.d, parameter[member[config.commandLoggingTag], binary_operation[binary_operation[literal["takeScreens... | Keyword[public] Keyword[void] identifier[takeScreenshot] operator[SEP] identifier[String] identifier[name] operator[SEP] {
Keyword[if] operator[SEP] identifier[config] operator[SEP] identifier[commandLogging] operator[SEP] {
identifier[Log] operator[SEP] identifier[d] operator[SEP] identifier[config] ... |
public void init(Object env, Map<String,Object> properties, Object applet)
{
super.init(env, properties, applet);
Task task = new AutoTask(this, null, null); // This is the base task for this application
m_systemRecordOwner = (RecordOwner)ClassServiceUtility.getClassService().makeObjectFrom... | class class_name[name] begin[{]
method[init, return_type[void], modifier[public], parameter[env, properties, applet]] begin[{]
SuperMethodInvocation(arguments=[MemberReference(member=env, postfix_operators=[], prefix_operators=[], qualifier=, selectors=[]), MemberReference(member=properties, po... | Keyword[public] Keyword[void] identifier[init] operator[SEP] identifier[Object] identifier[env] , identifier[Map] operator[<] identifier[String] , identifier[Object] operator[>] identifier[properties] , identifier[Object] identifier[applet] operator[SEP] {
Keyword[super] operator[SEP] identifier[init] operato... |
public void addColumn(String storeName, String rowKey, String columnName, byte[] columnValue) {
m_columnUpdates.add(new ColumnUpdate(storeName, rowKey, columnName, columnValue));
} | class class_name[name] begin[{]
method[addColumn, return_type[void], modifier[public], parameter[storeName, rowKey, columnName, columnValue]] begin[{]
call[m_columnUpdates.add, parameter[ClassCreator(arguments=[MemberReference(member=storeName, postfix_operators=[], prefix_operators=[], qualifi... | Keyword[public] Keyword[void] identifier[addColumn] operator[SEP] identifier[String] identifier[storeName] , identifier[String] identifier[rowKey] , identifier[String] identifier[columnName] , Keyword[byte] operator[SEP] operator[SEP] identifier[columnValue] operator[SEP] {
identifier[m_columnUpdates] operato... |
public VpnClientIPsecParametersInner getVpnclientIpsecParameters(String resourceGroupName, String virtualNetworkGatewayName) {
return getVpnclientIpsecParametersWithServiceResponseAsync(resourceGroupName, virtualNetworkGatewayName).toBlocking().last().body();
} | class class_name[name] begin[{]
method[getVpnclientIpsecParameters, return_type[type[VpnClientIPsecParametersInner]], modifier[public], parameter[resourceGroupName, virtualNetworkGatewayName]] begin[{]
return[call[.getVpnclientIpsecParametersWithServiceResponseAsync, parameter[member[.resourceGroupName... | Keyword[public] identifier[VpnClientIPsecParametersInner] identifier[getVpnclientIpsecParameters] operator[SEP] identifier[String] identifier[resourceGroupName] , identifier[String] identifier[virtualNetworkGatewayName] operator[SEP] {
Keyword[return] identifier[getVpnclientIpsecParametersWithServiceResponseAsy... |
public void setListener(T listener) {
Assert.notNull(listener, "Listener must not be null");
Assert.isTrue(isSupportedType(listener), "Listener is not of a supported type");
this.listener = listener;
} | class class_name[name] begin[{]
method[setListener, return_type[void], modifier[public], parameter[listener]] begin[{]
call[Assert.notNull, parameter[member[.listener], literal["Listener must not be null"]]]
call[Assert.isTrue, parameter[call[.isSupportedType, parameter[member[.... | Keyword[public] Keyword[void] identifier[setListener] operator[SEP] identifier[T] identifier[listener] operator[SEP] {
identifier[Assert] operator[SEP] identifier[notNull] operator[SEP] identifier[listener] , literal[String] operator[SEP] operator[SEP] identifier[Assert] operator[SEP] identifier[isTrue] operato... |
public static <Input extends ImageBase<Input>, Output extends ImageBase<Output>>
ImageDistort<Input, Output> distort(boolean cached, InterpolationType interpolationType, BorderType borderType,
ImageType<Input> inputType, ImageType<Output> outputType) {
InterpolatePixel<Input> interp =
FactoryInterpolat... | class class_name[name] begin[{]
method[distort, return_type[type[ImageDistort]], modifier[public static], parameter[cached, interpolationType, borderType, inputType, outputType]] begin[{]
local_variable[type[InterpolatePixel], interp]
return[call[.distort, parameter[member[.cached], member[.int... | Keyword[public] Keyword[static] operator[<] identifier[Input] Keyword[extends] identifier[ImageBase] operator[<] identifier[Input] operator[>] , identifier[Output] Keyword[extends] identifier[ImageBase] operator[<] identifier[Output] operator[>] operator[>] identifier[ImageDistort] operator[<] identifier[Input] , ide... |
private void addFieldsForComputedMethod(TypeElement component, Set<String> alreadyDone) {
getMethodsWithAnnotation(component, Computed.class).forEach(method -> {
String propertyName = computedPropertyNameToFieldName(getComputedPropertyName(method));
if (alreadyDone.contains(propertyName)) {
ret... | class class_name[name] begin[{]
method[addFieldsForComputedMethod, return_type[void], modifier[private], parameter[component, alreadyDone]] begin[{]
call[.getMethodsWithAnnotation, parameter[member[.component], ClassReference(postfix_operators=[], prefix_operators=[], qualifier=, selectors=[], ... | Keyword[private] Keyword[void] identifier[addFieldsForComputedMethod] operator[SEP] identifier[TypeElement] identifier[component] , identifier[Set] operator[<] identifier[String] operator[>] identifier[alreadyDone] operator[SEP] {
identifier[getMethodsWithAnnotation] operator[SEP] identifier[component] , ident... |
public static Map<FieldType, String> getDefaultAssignmentFieldMap()
{
Map<FieldType, String> map = new LinkedHashMap<FieldType, String>();
map.put(AssignmentField.UNIQUE_ID, "taskrsrc_id");
map.put(AssignmentField.GUID, "guid");
map.put(AssignmentField.REMAINING_WORK, "remain_qty");
ma... | class class_name[name] begin[{]
method[getDefaultAssignmentFieldMap, return_type[type[Map]], modifier[public static], parameter[]] begin[{]
local_variable[type[Map], map]
call[map.put, parameter[member[AssignmentField.UNIQUE_ID], literal["taskrsrc_id"]]]
call[map.put, pa... | Keyword[public] Keyword[static] identifier[Map] operator[<] identifier[FieldType] , identifier[String] operator[>] identifier[getDefaultAssignmentFieldMap] operator[SEP] operator[SEP] {
identifier[Map] operator[<] identifier[FieldType] , identifier[String] operator[>] identifier[map] operator[=] Keyword[new] i... |
private void ensureIndex(DS session, L label, PrimitivePropertyMethodMetadata<PropertyMetadata> propertyMethodMetadata, boolean unique) {
PropertyMetadata propertyMetadata = propertyMethodMetadata.getDatastoreMetadata();
String statement;
if (unique) {
LOGGER.debug("Creating constrai... | class class_name[name] begin[{]
method[ensureIndex, return_type[void], modifier[private], parameter[session, label, propertyMethodMetadata, unique]] begin[{]
local_variable[type[PropertyMetadata], propertyMetadata]
local_variable[type[String], statement]
if[member[.unique]] begi... | Keyword[private] Keyword[void] identifier[ensureIndex] operator[SEP] identifier[DS] identifier[session] , identifier[L] identifier[label] , identifier[PrimitivePropertyMethodMetadata] operator[<] identifier[PropertyMetadata] operator[>] identifier[propertyMethodMetadata] , Keyword[boolean] identifier[unique] operato... |
public static File createRandomFile(MultipartFile file) {
String extension = MimeTypeMap.getSingleton().getExtensionFromMimeType(file.getContentType().toString());
if (StringUtils.isEmpty(extension)) {
extension = MimeTypeMap.getFileExtensionFromUrl(file.getFilename());
}
Str... | class class_name[name] begin[{]
method[createRandomFile, return_type[type[File]], modifier[public static], parameter[file]] begin[{]
local_variable[type[String], extension]
if[call[StringUtils.isEmpty, parameter[member[.extension]]]] begin[{]
assign[member[.exten... | Keyword[public] Keyword[static] identifier[File] identifier[createRandomFile] operator[SEP] identifier[MultipartFile] identifier[file] operator[SEP] {
identifier[String] identifier[extension] operator[=] identifier[MimeTypeMap] operator[SEP] identifier[getSingleton] operator[SEP] operator[SEP] operator[SEP] iden... |
@Override
public void writeTo(Path path, Class<?> type, Type genericType, Annotation[] annotations, MediaType mediaType,
MultivaluedMap<String, Object> httpHeaders, OutputStream entityStream)
throws IOException, WebApplicationException {
try (InputStream in = Files.newInp... | class class_name[name] begin[{]
method[writeTo, return_type[void], modifier[public], parameter[path, type, genericType, annotations, mediaType, httpHeaders, entityStream]] begin[{]
TryStatement(block=[StatementExpression(expression=MethodInvocation(arguments=[MemberReference(member=in, postfix_operator... | annotation[@] identifier[Override] Keyword[public] Keyword[void] identifier[writeTo] operator[SEP] identifier[Path] identifier[path] , identifier[Class] operator[<] operator[?] operator[>] identifier[type] , identifier[Type] identifier[genericType] , identifier[Annotation] operator[SEP] operator[SEP] identifier[anno... |
public void validate() throws EJBConfigurationException {
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
Tr.entry(tc, "validate " + j2eeName);
boolean asAttributesDefined = false;
if (ivModuleVersion <= J2EE_EJB_VERSION_1_1) {
// it is an EJB Module ve... | class class_name[name] begin[{]
method[validate, return_type[void], modifier[public], parameter[]] begin[{]
if[binary_operation[call[TraceComponent.isAnyTracingEnabled, parameter[]], &&, call[tc.isEntryEnabled, parameter[]]]] begin[{]
call[Tr.entry, parameter[member[.tc], binary_ope... | Keyword[public] Keyword[void] identifier[validate] operator[SEP] operator[SEP] Keyword[throws] identifier[EJBConfigurationException] {
Keyword[if] operator[SEP] identifier[TraceComponent] operator[SEP] identifier[isAnyTracingEnabled] operator[SEP] operator[SEP] operator[&&] identifier[tc] operator[SEP] identifie... |
public static String desc2name(String desc) {
StringBuilder sb = new StringBuilder();
int c = desc.lastIndexOf('[') + 1;
if (desc.length() == c + 1) {
switch (desc.charAt(c)) {
case JVM_VOID: {
sb.append("void");
break;
}
case JVM_BOOLEAN: {
sb.append("boolean");
break;
}
case JV... | class class_name[name] begin[{]
method[desc2name, return_type[type[String]], modifier[public static], parameter[desc]] begin[{]
local_variable[type[StringBuilder], sb]
local_variable[type[int], c]
if[binary_operation[call[desc.length, parameter[]], ==, binary_operation[member[.c... | Keyword[public] Keyword[static] identifier[String] identifier[desc2name] operator[SEP] identifier[String] identifier[desc] operator[SEP] {
identifier[StringBuilder] identifier[sb] operator[=] Keyword[new] identifier[StringBuilder] operator[SEP] operator[SEP] operator[SEP] Keyword[int] identifier[c] operator[=] i... |
public void setTagValues(java.util.Collection<String> tagValues) {
if (tagValues == null) {
this.tagValues = null;
return;
}
this.tagValues = new com.amazonaws.internal.SdkInternalList<String>(tagValues);
} | class class_name[name] begin[{]
method[setTagValues, return_type[void], modifier[public], parameter[tagValues]] begin[{]
if[binary_operation[member[.tagValues], ==, literal[null]]] begin[{]
assign[THIS[member[None.tagValues]], literal[null]]
return[None]
... | Keyword[public] Keyword[void] identifier[setTagValues] operator[SEP] identifier[java] operator[SEP] identifier[util] operator[SEP] identifier[Collection] operator[<] identifier[String] operator[>] identifier[tagValues] operator[SEP] {
Keyword[if] operator[SEP] identifier[tagValues] operator[==] Other[null] opera... |
@Override
public final Object getCurrentWriteMessage() {
WriteRequest req = getCurrentWriteRequest();
if (req == null) {
return null;
}
return req.getMessage();
} | class class_name[name] begin[{]
method[getCurrentWriteMessage, return_type[type[Object]], modifier[final public], parameter[]] begin[{]
local_variable[type[WriteRequest], req]
if[binary_operation[member[.req], ==, literal[null]]] begin[{]
return[literal[null]]
else b... | annotation[@] identifier[Override] Keyword[public] Keyword[final] identifier[Object] identifier[getCurrentWriteMessage] operator[SEP] operator[SEP] {
identifier[WriteRequest] identifier[req] operator[=] identifier[getCurrentWriteRequest] operator[SEP] operator[SEP] operator[SEP] Keyword[if] operator[SEP] identif... |
@Override
public synchronized void complete() {
if (com.ibm.ejs.ras.TraceComponent.isAnyTracingEnabled() && logger.isLoggable(Level.FINEST)) {
logger.entering(CLASS_NAME, "complete",this);
}
if (!lockHeldByDifferentThread())
{
//We can't call this or WebConta... | class class_name[name] begin[{]
method[complete, return_type[void], modifier[synchronized public], parameter[]] begin[{]
if[binary_operation[call[com.ibm.ejs.ras.TraceComponent.isAnyTracingEnabled, parameter[]], &&, call[logger.isLoggable, parameter[member[Level.FINEST]]]]] begin[{]
... | annotation[@] identifier[Override] Keyword[public] Keyword[synchronized] Keyword[void] identifier[complete] operator[SEP] operator[SEP] {
Keyword[if] operator[SEP] identifier[com] operator[SEP] identifier[ibm] operator[SEP] identifier[ejs] operator[SEP] identifier[ras] operator[SEP] identifier[TraceComponent] op... |
@Implementation(minSdk = Build.VERSION_CODES.P)
@HiddenApi
public void setAppStandbyBucket(String packageName, @StandbyBuckets int bucket) {
appStandbyBuckets.put(packageName, bucket);
} | class class_name[name] begin[{]
method[setAppStandbyBucket, return_type[void], modifier[public], parameter[packageName, bucket]] begin[{]
call[appStandbyBuckets.put, parameter[member[.packageName], member[.bucket]]]
end[}]
END[}] | annotation[@] identifier[Implementation] operator[SEP] identifier[minSdk] operator[=] identifier[Build] operator[SEP] identifier[VERSION_CODES] operator[SEP] identifier[P] operator[SEP] annotation[@] identifier[HiddenApi] Keyword[public] Keyword[void] identifier[setAppStandbyBucket] operator[SEP] identifier[String] ide... |
public static Set<Collection<VM>> requiredVMPart(Model mo, JSONObject o, String id) throws JSONConverterException {
Set<Collection<VM>> vms = new HashSet<>();
Object x = o.get(id);
if (!(x instanceof JSONArray)) {
throw new JSONConverterException("Set of identifiers sets expected at ... | class class_name[name] begin[{]
method[requiredVMPart, return_type[type[Set]], modifier[public static], parameter[mo, o, id]] begin[{]
local_variable[type[Set], vms]
local_variable[type[Object], x]
if[binary_operation[member[.x], instanceof, type[JSONArray]]] begin[{]
... | Keyword[public] Keyword[static] identifier[Set] operator[<] identifier[Collection] operator[<] identifier[VM] operator[>] operator[>] identifier[requiredVMPart] operator[SEP] identifier[Model] identifier[mo] , identifier[JSONObject] identifier[o] , identifier[String] identifier[id] operator[SEP] Keyword[throws] ident... |
public static Pair<String, String> readStringPair(DataInputStream in) {
Pair<String, String> p = new Pair<String, String>();
try {
p.first = in.readUTF();
p.second = in.readUTF();
} catch (Exception e) {
e.printStackTrace();
}
return p;
} | class class_name[name] begin[{]
method[readStringPair, return_type[type[Pair]], modifier[public static], parameter[in]] begin[{]
local_variable[type[Pair], p]
TryStatement(block=[StatementExpression(expression=Assignment(expressionl=MemberReference(member=first, postfix_operators=[], prefix_ope... | Keyword[public] Keyword[static] identifier[Pair] operator[<] identifier[String] , identifier[String] operator[>] identifier[readStringPair] operator[SEP] identifier[DataInputStream] identifier[in] operator[SEP] {
identifier[Pair] operator[<] identifier[String] , identifier[String] operator[>] identifier[p] ope... |
public MediaType withCharset(Charset charset) {
checkNotNull(charset);
MediaType withCharset = withParameter(CHARSET_ATTRIBUTE, charset.name());
// precache the charset so we don't need to parse it
withCharset.parsedCharset = Optional.of(charset);
return withCharset;
} | class class_name[name] begin[{]
method[withCharset, return_type[type[MediaType]], modifier[public], parameter[charset]] begin[{]
call[.checkNotNull, parameter[member[.charset]]]
local_variable[type[MediaType], withCharset]
assign[member[withCharset.parsedCharset], call[O... | Keyword[public] identifier[MediaType] identifier[withCharset] operator[SEP] identifier[Charset] identifier[charset] operator[SEP] {
identifier[checkNotNull] operator[SEP] identifier[charset] operator[SEP] operator[SEP] identifier[MediaType] identifier[withCharset] operator[=] identifier[withParameter] operator[S... |
public static double sabrAlphaApproximation(double normalVolatility, double beta, double rho, double nu, double displacement, double underlying, double maturity)
{
// Apply displacement. Displaced model is just a shift on underlying and strike.
underlying += displacement;
// ATM case.
double forwardStrikeAver... | class class_name[name] begin[{]
method[sabrAlphaApproximation, return_type[type[double]], modifier[public static], parameter[normalVolatility, beta, rho, nu, displacement, underlying, maturity]] begin[{]
assign[member[.underlying], member[.displacement]]
local_variable[type[double], for... | Keyword[public] Keyword[static] Keyword[double] identifier[sabrAlphaApproximation] operator[SEP] Keyword[double] identifier[normalVolatility] , Keyword[double] identifier[beta] , Keyword[double] identifier[rho] , Keyword[double] identifier[nu] , Keyword[double] identifier[displacement] , Keyword[double] identifier... |
CloseableIterator<T> createIterator(PreparedQuery<T> preparedQuery, int resultFlags) throws SQLException {
try {
SelectIterator<T, ID> iterator =
statementExecutor.buildIterator(this, connectionSource, preparedQuery, objectCache, resultFlags);
return iterator;
} catch (SQLException e) {
throw SqlExcep... | class class_name[name] begin[{]
method[createIterator, return_type[type[CloseableIterator]], modifier[default], parameter[preparedQuery, resultFlags]] begin[{]
TryStatement(block=[LocalVariableDeclaration(annotations=[], declarators=[VariableDeclarator(dimensions=[], initializer=MethodInvocation(argume... | identifier[CloseableIterator] operator[<] identifier[T] operator[>] identifier[createIterator] operator[SEP] identifier[PreparedQuery] operator[<] identifier[T] operator[>] identifier[preparedQuery] , Keyword[int] identifier[resultFlags] operator[SEP] Keyword[throws] identifier[SQLException] {
Keyword[try] {
... |
public void startWork(String workUnit) throws InterruptedException {
if (waitInProgress.get())
LOG.warn("Claiming work during wait!");
LOG.info("Successfully claimed {}: {}. Starting...", config.workUnitName, workUnit);
final boolean added = myWorkUnits.add(workUnit);
if (ad... | class class_name[name] begin[{]
method[startWork, return_type[void], modifier[public], parameter[workUnit]] begin[{]
if[call[waitInProgress.get, parameter[]]] begin[{]
call[LOG.warn, parameter[literal["Claiming work during wait!"]]]
else begin[{]
None
end[}]
... | Keyword[public] Keyword[void] identifier[startWork] operator[SEP] identifier[String] identifier[workUnit] operator[SEP] Keyword[throws] identifier[InterruptedException] {
Keyword[if] operator[SEP] identifier[waitInProgress] operator[SEP] identifier[get] operator[SEP] operator[SEP] operator[SEP] identifier[LOG] o... |
@Override
protected void handleError(Suppressible s, Throwable t) {
if (t instanceof ErrorProneError) {
throw (ErrorProneError) t;
}
if (t instanceof CompletionFailure) {
throw (CompletionFailure) t;
}
TreePath path = getCurrentPath();
throw new ErrorProneError(
s.canonical... | class class_name[name] begin[{]
method[handleError, return_type[void], modifier[protected], parameter[s, t]] begin[{]
if[binary_operation[member[.t], instanceof, type[ErrorProneError]]] begin[{]
ThrowStatement(expression=Cast(expression=MemberReference(member=t, postfix_operators=[]... | annotation[@] identifier[Override] Keyword[protected] Keyword[void] identifier[handleError] operator[SEP] identifier[Suppressible] identifier[s] , identifier[Throwable] identifier[t] operator[SEP] {
Keyword[if] operator[SEP] identifier[t] Keyword[instanceof] identifier[ErrorProneError] operator[SEP] {
... |
public void setInternetGatewayIds(java.util.Collection<String> internetGatewayIds) {
if (internetGatewayIds == null) {
this.internetGatewayIds = null;
return;
}
this.internetGatewayIds = new com.amazonaws.internal.SdkInternalList<String>(internetGatewayIds);
} | class class_name[name] begin[{]
method[setInternetGatewayIds, return_type[void], modifier[public], parameter[internetGatewayIds]] begin[{]
if[binary_operation[member[.internetGatewayIds], ==, literal[null]]] begin[{]
assign[THIS[member[None.internetGatewayIds]], literal[... | Keyword[public] Keyword[void] identifier[setInternetGatewayIds] operator[SEP] identifier[java] operator[SEP] identifier[util] operator[SEP] identifier[Collection] operator[<] identifier[String] operator[>] identifier[internetGatewayIds] operator[SEP] {
Keyword[if] operator[SEP] identifier[internetGatewayIds] ope... |
public double setPropertyIfNull(String propname, double value)
{
return Double.parseDouble(setPropertyIfNull(propname, Double.toString(value)));
} | class class_name[name] begin[{]
method[setPropertyIfNull, return_type[type[double]], modifier[public], parameter[propname, value]] begin[{]
return[call[Double.parseDouble, parameter[call[.setPropertyIfNull, parameter[member[.propname], call[Double.toString, parameter[member[.value]]]]]]]]
end[}]
EN... | Keyword[public] Keyword[double] identifier[setPropertyIfNull] operator[SEP] identifier[String] identifier[propname] , Keyword[double] identifier[value] operator[SEP] {
Keyword[return] identifier[Double] operator[SEP] identifier[parseDouble] operator[SEP] identifier[setPropertyIfNull] operator[SEP] identifier[pr... |
void load(ReferenceableInstance i) throws RepositoryException {
int pos = idPosMap.get(i.getId());
loadFields(pos, i);
for (HierarchicalTypeStore s : superTypeStores) {
s.load(i);
}
} | class class_name[name] begin[{]
method[load, return_type[void], modifier[default], parameter[i]] begin[{]
local_variable[type[int], pos]
call[.loadFields, parameter[member[.pos], member[.i]]]
ForStatement(body=BlockStatement(label=None, statements=[StatementExpression(expression... | Keyword[void] identifier[load] operator[SEP] identifier[ReferenceableInstance] identifier[i] operator[SEP] Keyword[throws] identifier[RepositoryException] {
Keyword[int] identifier[pos] operator[=] identifier[idPosMap] operator[SEP] identifier[get] operator[SEP] identifier[i] operator[SEP] identifier[getId] oper... |
public final boolean getBooleanDefault(boolean defaultValue, String attribute, String... path)
{
return Boolean.parseBoolean(getNodeStringDefault(String.valueOf(defaultValue), attribute, path));
} | class class_name[name] begin[{]
method[getBooleanDefault, return_type[type[boolean]], modifier[final public], parameter[defaultValue, attribute, path]] begin[{]
return[call[Boolean.parseBoolean, parameter[call[.getNodeStringDefault, parameter[call[String.valueOf, parameter[member[.defaultValue]]], memb... | Keyword[public] Keyword[final] Keyword[boolean] identifier[getBooleanDefault] operator[SEP] Keyword[boolean] identifier[defaultValue] , identifier[String] identifier[attribute] , identifier[String] operator[...] identifier[path] operator[SEP] {
Keyword[return] identifier[Boolean] operator[SEP] identifier[parse... |
protected String redefineArgsIfNeeds(String formatString) {
if (!formatString.contains("{") || !formatString.contains("}")) { // no parameter
return formatString;
}
final List<ScopeInfo> plainVariableList = Srl.extractScopeList(formatString, "{", "}");
if (!plainVariableList.... | class class_name[name] begin[{]
method[redefineArgsIfNeeds, return_type[type[String]], modifier[protected], parameter[formatString]] begin[{]
if[binary_operation[call[formatString.contains, parameter[literal["{"]]], ||, call[formatString.contains, parameter[literal["}"]]]]] begin[{]
... | Keyword[protected] identifier[String] identifier[redefineArgsIfNeeds] operator[SEP] identifier[String] identifier[formatString] operator[SEP] {
Keyword[if] operator[SEP] operator[!] identifier[formatString] operator[SEP] identifier[contains] operator[SEP] literal[String] operator[SEP] operator[||] operator[!] id... |
ClusterConfiguration getLastConfigWithin(Zxid zxid) throws IOException {
String pattern = "cluster_config\\.\\d+_-?\\d+";
String zxidFileName = "cluster_config." + zxid.toSimpleString();
String lastFileName = null;
for (File file : this.rootDir.listFiles()) {
if (!file.isDirectory() && file.getNa... | class class_name[name] begin[{]
method[getLastConfigWithin, return_type[type[ClusterConfiguration]], modifier[default], parameter[zxid]] begin[{]
local_variable[type[String], pattern]
local_variable[type[String], zxidFileName]
local_variable[type[String], lastFileName]
ForStatem... | identifier[ClusterConfiguration] identifier[getLastConfigWithin] operator[SEP] identifier[Zxid] identifier[zxid] operator[SEP] Keyword[throws] identifier[IOException] {
identifier[String] identifier[pattern] operator[=] literal[String] operator[SEP] identifier[String] identifier[zxidFileName] operator[=] literal... |
public static EventEngine getEventService() {
SSLChannelProvider p = instance.get();
if (p != null)
return p.eventService;
throw new IllegalStateException("Requested service is null: no active component instance");
} | class class_name[name] begin[{]
method[getEventService, return_type[type[EventEngine]], modifier[public static], parameter[]] begin[{]
local_variable[type[SSLChannelProvider], p]
if[binary_operation[member[.p], !=, literal[null]]] begin[{]
return[member[p.eventService]]
else beg... | Keyword[public] Keyword[static] identifier[EventEngine] identifier[getEventService] operator[SEP] operator[SEP] {
identifier[SSLChannelProvider] identifier[p] operator[=] identifier[instance] operator[SEP] identifier[get] operator[SEP] operator[SEP] operator[SEP] Keyword[if] operator[SEP] identifier[p] operator[... |
private void checkboxDrawGTActionPerformed(java.awt.event.ActionEvent evt) {//GEN-FIRST:event_checkboxDrawGTActionPerformed
//visualizer.redrawClusterings();
visualizer.setGroundTruthVisibility(checkboxDrawGT.isSelected());
} | class class_name[name] begin[{]
method[checkboxDrawGTActionPerformed, return_type[void], modifier[private], parameter[evt]] begin[{]
call[visualizer.setGroundTruthVisibility, parameter[call[checkboxDrawGT.isSelected, parameter[]]]]
end[}]
END[}] | Keyword[private] Keyword[void] identifier[checkboxDrawGTActionPerformed] operator[SEP] identifier[java] operator[SEP] identifier[awt] operator[SEP] identifier[event] operator[SEP] identifier[ActionEvent] identifier[evt] operator[SEP] {
identifier[visualizer] operator[SEP] identifier[setGroundTruthVisibility] ope... |
public void buildDependencyGraph(AbstractProject owner,DependencyGraph graph) {
for (Object o : this) {
if (o instanceof DependencyDeclarer) {
DependencyDeclarer dd = (DependencyDeclarer) o;
try {
dd.buildDependencyGraph(owner,graph);
... | class class_name[name] begin[{]
method[buildDependencyGraph, return_type[void], modifier[public], parameter[owner, graph]] begin[{]
ForStatement(body=BlockStatement(label=None, statements=[IfStatement(condition=BinaryOperation(operandl=MemberReference(member=o, postfix_operators=[], prefix_operators=[]... | Keyword[public] Keyword[void] identifier[buildDependencyGraph] operator[SEP] identifier[AbstractProject] identifier[owner] , identifier[DependencyGraph] identifier[graph] operator[SEP] {
Keyword[for] operator[SEP] identifier[Object] identifier[o] operator[:] Keyword[this] operator[SEP] {
Keyword[if]... |
public boolean removeLastOccurrence(Object o) {
Objects.requireNonNull(o);
for (Node<E> p = last(); p != null; p = pred(p)) {
final E item;
if ((item = p.item) != null
&& o.equals(item)
&& ITEM.compareAndSet(p, item, null)) {
unlink... | class class_name[name] begin[{]
method[removeLastOccurrence, return_type[type[boolean]], modifier[public], parameter[o]] begin[{]
call[Objects.requireNonNull, parameter[member[.o]]]
ForStatement(body=BlockStatement(label=None, statements=[LocalVariableDeclaration(annotations=[], declara... | Keyword[public] Keyword[boolean] identifier[removeLastOccurrence] operator[SEP] identifier[Object] identifier[o] operator[SEP] {
identifier[Objects] operator[SEP] identifier[requireNonNull] operator[SEP] identifier[o] operator[SEP] operator[SEP] Keyword[for] operator[SEP] identifier[Node] operator[<] identifier[... |
protected PaginatedList<DTO> findPaginatedWithQueryAndSort(DBQuery.Query query, DBSort.SortBuilder sort, int page, int perPage) {
try (final DBCursor<DTO> cursor = db.find(query)
.sort(sort)
.limit(perPage)
.skip(perPage * Math.max(0, page - 1))) {
ret... | class class_name[name] begin[{]
method[findPaginatedWithQueryAndSort, return_type[type[PaginatedList]], modifier[protected], parameter[query, sort, page, perPage]] begin[{]
TryStatement(block=[ReturnStatement(expression=ClassCreator(arguments=[MethodInvocation(arguments=[MemberReference(member=cursor, ... | Keyword[protected] identifier[PaginatedList] operator[<] identifier[DTO] operator[>] identifier[findPaginatedWithQueryAndSort] operator[SEP] identifier[DBQuery] operator[SEP] identifier[Query] identifier[query] , identifier[DBSort] operator[SEP] identifier[SortBuilder] identifier[sort] , Keyword[int] identifier[page]... |
public String getEngineEdition() {
try {
if (getConnection() instanceof JdbcConnection) {
String sql = "SELECT CASE ServerProperty('EngineEdition')\n" +
" WHEN 1 THEN 'Personal'\n" +
" WHEN 2 THEN 'Standard'\n" +
... | class class_name[name] begin[{]
method[getEngineEdition, return_type[type[String]], modifier[public], parameter[]] begin[{]
TryStatement(block=[IfStatement(condition=BinaryOperation(operandl=MethodInvocation(arguments=[], member=getConnection, postfix_operators=[], prefix_operators=[], qualifier=, sele... | Keyword[public] identifier[String] identifier[getEngineEdition] operator[SEP] operator[SEP] {
Keyword[try] {
Keyword[if] operator[SEP] identifier[getConnection] operator[SEP] operator[SEP] Keyword[instanceof] identifier[JdbcConnection] operator[SEP] {
identifier[String] identifier[sql] ... |
public ConfigResponse getConfiguration(String types) throws ApiException {
ApiResponse<ConfigResponse> resp = getConfigurationWithHttpInfo(types);
return resp.getData();
} | class class_name[name] begin[{]
method[getConfiguration, return_type[type[ConfigResponse]], modifier[public], parameter[types]] begin[{]
local_variable[type[ApiResponse], resp]
return[call[resp.getData, parameter[]]]
end[}]
END[}] | Keyword[public] identifier[ConfigResponse] identifier[getConfiguration] operator[SEP] identifier[String] identifier[types] operator[SEP] Keyword[throws] identifier[ApiException] {
identifier[ApiResponse] operator[<] identifier[ConfigResponse] operator[>] identifier[resp] operator[=] identifier[getConfigurationWi... |
private void deleteExportpoint(CmsModule module, String exportpoint) {
List oldExportpoints = module.getExportPoints();
List newExportpoints = new ArrayList();
Iterator i = oldExportpoints.iterator();
while (i.hasNext()) {
CmsExportPoint exp = (CmsExportPoint)i.next();
... | class class_name[name] begin[{]
method[deleteExportpoint, return_type[void], modifier[private], parameter[module, exportpoint]] begin[{]
local_variable[type[List], oldExportpoints]
local_variable[type[List], newExportpoints]
local_variable[type[Iterator], i]
while[call[i... | Keyword[private] Keyword[void] identifier[deleteExportpoint] operator[SEP] identifier[CmsModule] identifier[module] , identifier[String] identifier[exportpoint] operator[SEP] {
identifier[List] identifier[oldExportpoints] operator[=] identifier[module] operator[SEP] identifier[getExportPoints] operator[SEP] ope... |
public static JBBPParser prepare(final String script, final JBBPCustomFieldTypeProcessor customFieldTypeProcessor) {
return JBBPParser.prepare(script, JBBPBitOrder.LSB0, customFieldTypeProcessor, 0);
} | class class_name[name] begin[{]
method[prepare, return_type[type[JBBPParser]], modifier[public static], parameter[script, customFieldTypeProcessor]] begin[{]
return[call[JBBPParser.prepare, parameter[member[.script], member[JBBPBitOrder.LSB0], member[.customFieldTypeProcessor], literal[0]]]]
end[}]... | Keyword[public] Keyword[static] identifier[JBBPParser] identifier[prepare] operator[SEP] Keyword[final] identifier[String] identifier[script] , Keyword[final] identifier[JBBPCustomFieldTypeProcessor] identifier[customFieldTypeProcessor] operator[SEP] {
Keyword[return] identifier[JBBPParser] operator[SEP] identi... |
@NonNull
@Override
public Loader<SortedList<FtpFile>> getLoader() {
return new AsyncTaskLoader<SortedList<FtpFile>>(getContext()) {
@Override
public SortedList<FtpFile> loadInBackground() {
SortedList<FtpFile> sortedList = new SortedList<>(FtpFile.class, new Sorte... | class class_name[name] begin[{]
method[getLoader, return_type[type[Loader]], modifier[public], parameter[]] begin[{]
return[ClassCreator(arguments=[MethodInvocation(arguments=[], member=getContext, postfix_operators=[], prefix_operators=[], qualifier=, selectors=[], type_arguments=None)], body=[MethodD... | annotation[@] identifier[NonNull] annotation[@] identifier[Override] Keyword[public] identifier[Loader] operator[<] identifier[SortedList] operator[<] identifier[FtpFile] operator[>] operator[>] identifier[getLoader] operator[SEP] operator[SEP] {
Keyword[return] Keyword[new] identifier[AsyncTaskLoader] operator[... |
public String contentToString()
{
StringBuffer sb = new StringBuffer();
sb.append(name + " = \n");
for ( IndexMN i : indexSet )
{
sb.append("\t(");
sb.append(i.m + "," + i.n);
sb.append(")");
sb.append("\t" + getReal(i.m, i.n) ... | class class_name[name] begin[{]
method[contentToString, return_type[type[String]], modifier[public], parameter[]] begin[{]
local_variable[type[StringBuffer], sb]
call[sb.append, parameter[binary_operation[member[.name], +, literal[" = \n"]]]]
ForStatement(body=BlockStatement(lab... | Keyword[public] identifier[String] identifier[contentToString] operator[SEP] operator[SEP] {
identifier[StringBuffer] identifier[sb] operator[=] Keyword[new] identifier[StringBuffer] operator[SEP] operator[SEP] operator[SEP] identifier[sb] operator[SEP] identifier[append] operator[SEP] identifier[name] operator[... |
protected void readWithAID() throws CommunicationException {
if (LOGGER.isDebugEnabled()) {
LOGGER.debug("Try to read card with AID");
}
// Test each card from know EMV AID
Application app = new Application();
for (EmvCardScheme type : EmvCardScheme.values()) {
for (byte[] aid : type.getAidByte()) {
... | class class_name[name] begin[{]
method[readWithAID, return_type[void], modifier[protected], parameter[]] begin[{]
if[call[LOGGER.isDebugEnabled, parameter[]]] begin[{]
call[LOGGER.debug, parameter[literal["Try to read card with AID"]]]
else begin[{]
None
... | Keyword[protected] Keyword[void] identifier[readWithAID] operator[SEP] operator[SEP] Keyword[throws] identifier[CommunicationException] {
Keyword[if] operator[SEP] identifier[LOGGER] operator[SEP] identifier[isDebugEnabled] operator[SEP] operator[SEP] operator[SEP] {
identifier[LOGGER] operator[SEP] i... |
public Stream<AbstractHtml> buildAllTagsStream(final boolean parallel) {
return parallel ? tagByWffId.values().parallelStream()
: tagByWffId.values().stream();
} | class class_name[name] begin[{]
method[buildAllTagsStream, return_type[type[Stream]], modifier[public], parameter[parallel]] begin[{]
return[TernaryExpression(condition=MemberReference(member=parallel, postfix_operators=[], prefix_operators=[], qualifier=, selectors=[]), if_false=MethodInvocation(argum... | Keyword[public] identifier[Stream] operator[<] identifier[AbstractHtml] operator[>] identifier[buildAllTagsStream] operator[SEP] Keyword[final] Keyword[boolean] identifier[parallel] operator[SEP] {
Keyword[return] identifier[parallel] operator[?] identifier[tagByWffId] operator[SEP] identifier[values] operator[S... |
private void intersectionMatrix(int[][] res, ArrayList<int[]> partsx, ArrayList<int[]> partsy, int gridsize) {
for(int x = 0; x < gridsize; x++) {
final int[] px = partsx.get(x);
final int[] rowx = res[x];
for(int y = 0; y < gridsize; y++) {
int[] py = partsy.get(y);
rowx[y] = inte... | class class_name[name] begin[{]
method[intersectionMatrix, return_type[void], modifier[private], parameter[res, partsx, partsy, gridsize]] begin[{]
ForStatement(body=BlockStatement(label=None, statements=[LocalVariableDeclaration(annotations=[], declarators=[VariableDeclarator(dimensions=[], initialize... | Keyword[private] Keyword[void] identifier[intersectionMatrix] operator[SEP] Keyword[int] operator[SEP] operator[SEP] operator[SEP] operator[SEP] identifier[res] , identifier[ArrayList] operator[<] Keyword[int] operator[SEP] operator[SEP] operator[>] identifier[partsx] , identifier[ArrayList] operator[<] Keyword[int] ... |
public boolean isSubsetOf(Multiset<O> multiset) throws ParameterException {
Validate.notNull(multiset);
for (O o : multiplicities.keySet()) {
if (multiplicity(o) > multiset.multiplicity(o)) {
return false;
}
}
return true;
} | class class_name[name] begin[{]
method[isSubsetOf, return_type[type[boolean]], modifier[public], parameter[multiset]] begin[{]
call[Validate.notNull, parameter[member[.multiset]]]
ForStatement(body=BlockStatement(label=None, statements=[IfStatement(condition=BinaryOperation(operandl=Met... | Keyword[public] Keyword[boolean] identifier[isSubsetOf] operator[SEP] identifier[Multiset] operator[<] identifier[O] operator[>] identifier[multiset] operator[SEP] Keyword[throws] identifier[ParameterException] {
identifier[Validate] operator[SEP] identifier[notNull] operator[SEP] identifier[multiset] operator[S... |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.