code stringlengths 63 466k | code_sememe stringlengths 141 3.79M | token_type stringlengths 274 1.23M |
|---|---|---|
public boolean anyMatch(@NotNull IntPredicate predicate) {
while(iterator.hasNext()) {
if(predicate.test(iterator.nextInt()))
return true;
}
return false;
} | class class_name[name] begin[{]
method[anyMatch, return_type[type[boolean]], modifier[public], parameter[predicate]] begin[{]
while[call[iterator.hasNext, parameter[]]] begin[{]
if[call[predicate.test, parameter[call[iterator.nextInt, parameter[]]]]] begin[{]
return[lite... | Keyword[public] Keyword[boolean] identifier[anyMatch] operator[SEP] annotation[@] identifier[NotNull] identifier[IntPredicate] identifier[predicate] operator[SEP] {
Keyword[while] operator[SEP] identifier[iterator] operator[SEP] identifier[hasNext] operator[SEP] operator[SEP] operator[SEP] {
Keyword[i... |
public String hyphenate(String text, Character shy, Character zwsp) throws StandardHyphenationException {
if (shy == null && zwsp == null)
return text;
byte[] hyphens = hyphenate(text);
StringBuffer hyphenatedText = new StringBuffer();
int i;
for (i = 0; i < hyphens.length; i++) {
hyphenatedText.append(... | class class_name[name] begin[{]
method[hyphenate, return_type[type[String]], modifier[public], parameter[text, shy, zwsp]] begin[{]
if[binary_operation[binary_operation[member[.shy], ==, literal[null]], &&, binary_operation[member[.zwsp], ==, literal[null]]]] begin[{]
return[member[.text]]
... | Keyword[public] identifier[String] identifier[hyphenate] operator[SEP] identifier[String] identifier[text] , identifier[Character] identifier[shy] , identifier[Character] identifier[zwsp] operator[SEP] Keyword[throws] identifier[StandardHyphenationException] {
Keyword[if] operator[SEP] identifier[shy] operator... |
protected final int getColumnWidthCompatible() {
if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.JELLY_BEAN) {
return super.getColumnWidth();
} else {
try {
Field columnWidth = GridView.class.getDeclaredField("mColumnWidth");
columnWidth.setAccess... | class class_name[name] begin[{]
method[getColumnWidthCompatible, return_type[type[int]], modifier[final protected], parameter[]] begin[{]
if[binary_operation[member[Build.VERSION.SDK_INT], >=, member[Build.VERSION_CODES.JELLY_BEAN]]] begin[{]
return[SuperMethodInvocation(arguments=[... | Keyword[protected] Keyword[final] Keyword[int] identifier[getColumnWidthCompatible] operator[SEP] operator[SEP] {
Keyword[if] operator[SEP] identifier[Build] operator[SEP] identifier[VERSION] operator[SEP] identifier[SDK_INT] operator[>=] identifier[Build] operator[SEP] identifier[VERSION_CODES] operator[SEP] id... |
public Optional<CdoSnapshot> getHistorical(GlobalId globalId, LocalDateTime timePoint) {
argumentsAreNotNull(globalId, timePoint);
return delegate.getStateHistory(globalId, QueryParamsBuilder.withLimit(1).to(timePoint).build())
.stream().findFirst();
} | class class_name[name] begin[{]
method[getHistorical, return_type[type[Optional]], modifier[public], parameter[globalId, timePoint]] begin[{]
call[.argumentsAreNotNull, parameter[member[.globalId], member[.timePoint]]]
return[call[delegate.getStateHistory, parameter[member[.globalId], c... | Keyword[public] identifier[Optional] operator[<] identifier[CdoSnapshot] operator[>] identifier[getHistorical] operator[SEP] identifier[GlobalId] identifier[globalId] , identifier[LocalDateTime] identifier[timePoint] operator[SEP] {
identifier[argumentsAreNotNull] operator[SEP] identifier[globalId] , identifie... |
protected void validate(String operationType) throws Exception
{
super.validate(operationType);
MPSString file_name_validator = new MPSString();
file_name_validator.setConstraintIsReq(MPSConstants.DELETE_CONSTRAINT, true);
file_name_validator.setConstraintMaxStrLen(MPSConstants.GENERIC_CONSTRAINT, 256);... | class class_name[name] begin[{]
method[validate, return_type[void], modifier[protected], parameter[operationType]] begin[{]
SuperMethodInvocation(arguments=[MemberReference(member=operationType, postfix_operators=[], prefix_operators=[], qualifier=, selectors=[])], member=validate, postfix_oper... | Keyword[protected] Keyword[void] identifier[validate] operator[SEP] identifier[String] identifier[operationType] operator[SEP] Keyword[throws] identifier[Exception] {
Keyword[super] operator[SEP] identifier[validate] operator[SEP] identifier[operationType] operator[SEP] operator[SEP] identifier[MPSString] identi... |
@Override
public void renderInline(final String templateInline, final Map<String, Object> context, final Map<String, WComponent> taggedComponents,
final Writer writer, final Map<String, Object> options) {
LOG.debug("Rendering inline plain text template.");
boolean xmlEncode = options.containsKey(XML_ENCODE);
... | class class_name[name] begin[{]
method[renderInline, return_type[void], modifier[public], parameter[templateInline, context, taggedComponents, writer, options]] begin[{]
call[LOG.debug, parameter[literal["Rendering inline plain text template."]]]
local_variable[type[boolean], xmlEncode]... | annotation[@] identifier[Override] Keyword[public] Keyword[void] identifier[renderInline] operator[SEP] Keyword[final] identifier[String] identifier[templateInline] , Keyword[final] identifier[Map] operator[<] identifier[String] , identifier[Object] operator[>] identifier[context] , Keyword[final] identifier[Map] op... |
public void setJobDefinitions(java.util.Collection<JobDefinition> jobDefinitions) {
if (jobDefinitions == null) {
this.jobDefinitions = null;
return;
}
this.jobDefinitions = new java.util.ArrayList<JobDefinition>(jobDefinitions);
} | class class_name[name] begin[{]
method[setJobDefinitions, return_type[void], modifier[public], parameter[jobDefinitions]] begin[{]
if[binary_operation[member[.jobDefinitions], ==, literal[null]]] begin[{]
assign[THIS[member[None.jobDefinitions]], literal[null]]
... | Keyword[public] Keyword[void] identifier[setJobDefinitions] operator[SEP] identifier[java] operator[SEP] identifier[util] operator[SEP] identifier[Collection] operator[<] identifier[JobDefinition] operator[>] identifier[jobDefinitions] operator[SEP] {
Keyword[if] operator[SEP] identifier[jobDefinitions] operator... |
public EtcdKeyPutRequest put(String key, String value) {
return new EtcdKeyPutRequest(client, key, retryHandler).value(value);
} | class class_name[name] begin[{]
method[put, return_type[type[EtcdKeyPutRequest]], modifier[public], parameter[key, value]] begin[{]
return[ClassCreator(arguments=[MemberReference(member=client, postfix_operators=[], prefix_operators=[], qualifier=, selectors=[]), MemberReference(member=key, postfix_ope... | Keyword[public] identifier[EtcdKeyPutRequest] identifier[put] operator[SEP] identifier[String] identifier[key] , identifier[String] identifier[value] operator[SEP] {
Keyword[return] Keyword[new] identifier[EtcdKeyPutRequest] operator[SEP] identifier[client] , identifier[key] , identifier[retryHandler] operato... |
public void trace(Object message, Throwable t) {
doLog(Level.TRACE, FQCN, message, null, t);
} | class class_name[name] begin[{]
method[trace, return_type[void], modifier[public], parameter[message, t]] begin[{]
call[.doLog, parameter[member[Level.TRACE], member[.FQCN], member[.message], literal[null], member[.t]]]
end[}]
END[}] | Keyword[public] Keyword[void] identifier[trace] operator[SEP] identifier[Object] identifier[message] , identifier[Throwable] identifier[t] operator[SEP] {
identifier[doLog] operator[SEP] identifier[Level] operator[SEP] identifier[TRACE] , identifier[FQCN] , identifier[message] , Other[null] , identifier[t] ... |
public Object xpathQuery(String xpath, QName type, NamespaceContext nsContext)
throws XPathExpressionException {
XPathFactory xpathFactory = XPathFactory.newInstance();
XPath xPath = xpathFactory.newXPath();
if (nsContext != null) {
xPath.setNamespaceContext(n... | class class_name[name] begin[{]
method[xpathQuery, return_type[type[Object]], modifier[public], parameter[xpath, type, nsContext]] begin[{]
local_variable[type[XPathFactory], xpathFactory]
local_variable[type[XPath], xPath]
if[binary_operation[member[.nsContext], !=, literal[nul... | Keyword[public] identifier[Object] identifier[xpathQuery] operator[SEP] identifier[String] identifier[xpath] , identifier[QName] identifier[type] , identifier[NamespaceContext] identifier[nsContext] operator[SEP] Keyword[throws] identifier[XPathExpressionException] {
identifier[XPathFactory] identifier[xpathFa... |
public void saveInheritedContainer(
CmsObject cms,
CmsResource pageResource,
String name,
boolean newOrder,
List<CmsContainerElementBean> elements)
throws CmsException {
CmsContainerConfigurationWriter writer = new CmsContainerConfigurationWriter();
writer.sa... | class class_name[name] begin[{]
method[saveInheritedContainer, return_type[void], modifier[public], parameter[cms, pageResource, name, newOrder, elements]] begin[{]
local_variable[type[CmsContainerConfigurationWriter], writer]
call[writer.save, parameter[member[.cms], member[.name], mem... | Keyword[public] Keyword[void] identifier[saveInheritedContainer] operator[SEP] identifier[CmsObject] identifier[cms] , identifier[CmsResource] identifier[pageResource] , identifier[String] identifier[name] , Keyword[boolean] identifier[newOrder] , identifier[List] operator[<] identifier[CmsContainerElementBean] ope... |
public final void entryRuleXReturnExpression() throws RecognitionException {
try {
// InternalXbase.g:1434:1: ( ruleXReturnExpression EOF )
// InternalXbase.g:1435:1: ruleXReturnExpression EOF
{
if ( state.backtracking==0 ) {
before(grammarAccess.ge... | class class_name[name] begin[{]
method[entryRuleXReturnExpression, return_type[void], modifier[final public], parameter[]] begin[{]
TryStatement(block=[BlockStatement(label=None, statements=[IfStatement(condition=BinaryOperation(operandl=MemberReference(member=backtracking, postfix_operators=[], prefix... | Keyword[public] Keyword[final] Keyword[void] identifier[entryRuleXReturnExpression] operator[SEP] operator[SEP] Keyword[throws] identifier[RecognitionException] {
Keyword[try] {
{
Keyword[if] operator[SEP] identifier[state] operator[SEP] identifier[backtracking] operator[==] Other[0] op... |
byte[] readCodewords() throws FormatException {
FormatInformation formatInfo = readFormatInformation();
Version version = readVersion();
// Get the data mask for the format used in this QR Code. This will exclude
// some bits from reading as we wind through the bit matrix.
DataMask dataMask = Data... | class class_name[name] begin[{]
method[readCodewords, return_type[type[byte]], modifier[default], parameter[]] begin[{]
local_variable[type[FormatInformation], formatInfo]
local_variable[type[Version], version]
local_variable[type[DataMask], dataMask]
local_variable[type[int], d... | Keyword[byte] operator[SEP] operator[SEP] identifier[readCodewords] operator[SEP] operator[SEP] Keyword[throws] identifier[FormatException] {
identifier[FormatInformation] identifier[formatInfo] operator[=] identifier[readFormatInformation] operator[SEP] operator[SEP] operator[SEP] identifier[Version] identifier... |
public boolean isCollection()
{
return type.equals(Relation.ForeignKey.ONE_TO_MANY) || type.equals(Relation.ForeignKey.MANY_TO_MANY);
} | class class_name[name] begin[{]
method[isCollection, return_type[type[boolean]], modifier[public], parameter[]] begin[{]
return[binary_operation[call[type.equals, parameter[member[Relation.ForeignKey.ONE_TO_MANY]]], ||, call[type.equals, parameter[member[Relation.ForeignKey.MANY_TO_MANY]]]]]
end[}]... | Keyword[public] Keyword[boolean] identifier[isCollection] operator[SEP] operator[SEP] {
Keyword[return] identifier[type] operator[SEP] identifier[equals] operator[SEP] identifier[Relation] operator[SEP] identifier[ForeignKey] operator[SEP] identifier[ONE_TO_MANY] operator[SEP] operator[||] identifier[type] opera... |
public static ImmutableList<Path> listFiles(Path dir) throws IOException {
try (DirectoryStream<Path> stream = Files.newDirectoryStream(dir)) {
return ImmutableList.copyOf(stream);
} catch (DirectoryIteratorException e) {
throw e.getCause();
}
} | class class_name[name] begin[{]
method[listFiles, return_type[type[ImmutableList]], modifier[public static], parameter[dir]] begin[{]
TryStatement(block=[ReturnStatement(expression=MethodInvocation(arguments=[MemberReference(member=stream, postfix_operators=[], prefix_operators=[], qualifier=, selector... | Keyword[public] Keyword[static] identifier[ImmutableList] operator[<] identifier[Path] operator[>] identifier[listFiles] operator[SEP] identifier[Path] identifier[dir] operator[SEP] Keyword[throws] identifier[IOException] {
Keyword[try] operator[SEP] identifier[DirectoryStream] operator[<] identifier[Path] opera... |
@Override
public String onCompleted() throws Exception {
futureDone();
if (closed.get()) return "";
if (status == Socket.STATUS.ERROR) {
return "";
}
if (options.reconnect()) {
close(false);
if (options.reconnectTimeoutInMilliseconds() >... | class class_name[name] begin[{]
method[onCompleted, return_type[type[String]], modifier[public], parameter[]] begin[{]
call[.futureDone, parameter[]]
if[call[closed.get, parameter[]]] begin[{]
return[literal[""]]
else begin[{]
None
end[}]
if[binar... | annotation[@] identifier[Override] Keyword[public] identifier[String] identifier[onCompleted] operator[SEP] operator[SEP] Keyword[throws] identifier[Exception] {
identifier[futureDone] operator[SEP] operator[SEP] operator[SEP] Keyword[if] operator[SEP] identifier[closed] operator[SEP] identifier[get] operator[SE... |
public DynaFormRow createRegularRow() {
final DynaFormRow dynaFormRow = new DynaFormRow(regularRows.size() + 1, false, this);
regularRows.add(dynaFormRow);
return dynaFormRow;
} | class class_name[name] begin[{]
method[createRegularRow, return_type[type[DynaFormRow]], modifier[public], parameter[]] begin[{]
local_variable[type[DynaFormRow], dynaFormRow]
call[regularRows.add, parameter[member[.dynaFormRow]]]
return[member[.dynaFormRow]]
end[}]
END[}] | Keyword[public] identifier[DynaFormRow] identifier[createRegularRow] operator[SEP] operator[SEP] {
Keyword[final] identifier[DynaFormRow] identifier[dynaFormRow] operator[=] Keyword[new] identifier[DynaFormRow] operator[SEP] identifier[regularRows] operator[SEP] identifier[size] operator[SEP] operator[SEP] opera... |
public void propagateDirtyRegions (ActiveRepaintManager repmgr, JRootPane root)
{
if (_metamgr.needsPaint()) {
// tell the repaint manager about our raw (unmerged) dirty regions so that it can dirty
// only components that are actually impacted
List<Rectangle> dlist = _me... | class class_name[name] begin[{]
method[propagateDirtyRegions, return_type[void], modifier[public], parameter[repmgr, root]] begin[{]
if[call[_metamgr.needsPaint, parameter[]]] begin[{]
local_variable[type[List], dlist]
ForStatement(body=BlockStatement(label=None, stateme... | Keyword[public] Keyword[void] identifier[propagateDirtyRegions] operator[SEP] identifier[ActiveRepaintManager] identifier[repmgr] , identifier[JRootPane] identifier[root] operator[SEP] {
Keyword[if] operator[SEP] identifier[_metamgr] operator[SEP] identifier[needsPaint] operator[SEP] operator[SEP] operator[SEP]... |
public Token createPiiTokenSynchronous(@NonNull String personalId)
throws AuthenticationException,
InvalidRequestException,
APIConnectionException,
CardException,
APIException {
return createPiiTokenSynchronous(personalId, mDefaultPublishableKey);
... | class class_name[name] begin[{]
method[createPiiTokenSynchronous, return_type[type[Token]], modifier[public], parameter[personalId]] begin[{]
return[call[.createPiiTokenSynchronous, parameter[member[.personalId], member[.mDefaultPublishableKey]]]]
end[}]
END[}] | Keyword[public] identifier[Token] identifier[createPiiTokenSynchronous] operator[SEP] annotation[@] identifier[NonNull] identifier[String] identifier[personalId] operator[SEP] Keyword[throws] identifier[AuthenticationException] , identifier[InvalidRequestException] , identifier[APIConnectionException] , identifier[C... |
protected Response addToTask(HttpHeaders headers, String containerId, Long tInstanceId, boolean removeExisting, String payload, int operation) {
Variant v = getVariant(headers);
String type = getContentType(headers);
Header conversationIdHeader = buildConversationIdHeader(containerId, context, h... | class class_name[name] begin[{]
method[addToTask, return_type[type[Response]], modifier[protected], parameter[headers, containerId, tInstanceId, removeExisting, payload, operation]] begin[{]
local_variable[type[Variant], v]
local_variable[type[String], type]
local_variable[type[Header],... | Keyword[protected] identifier[Response] identifier[addToTask] operator[SEP] identifier[HttpHeaders] identifier[headers] , identifier[String] identifier[containerId] , identifier[Long] identifier[tInstanceId] , Keyword[boolean] identifier[removeExisting] , identifier[String] identifier[payload] , Keyword[int] ident... |
public static Properties fileToProperties(String fileName, Configuration conf)
throws IOException, ConfigurationException {
PropertiesConfiguration propsConfig = new PropertiesConfiguration();
Path filePath = new Path(fileName);
URI fileURI = filePath.toUri();
if (fileURI.getScheme() == null && ... | class class_name[name] begin[{]
method[fileToProperties, return_type[type[Properties]], modifier[public static], parameter[fileName, conf]] begin[{]
local_variable[type[PropertiesConfiguration], propsConfig]
local_variable[type[Path], filePath]
local_variable[type[URI], fileURI]
... | Keyword[public] Keyword[static] identifier[Properties] identifier[fileToProperties] operator[SEP] identifier[String] identifier[fileName] , identifier[Configuration] identifier[conf] operator[SEP] Keyword[throws] identifier[IOException] , identifier[ConfigurationException] {
identifier[PropertiesConfiguration]... |
public static String urlEncode(String value) {
if (value == null) {
return value;
}
try {
value = URLEncoder.encode(value, CommonWebConstants.UTF_8);
} catch (UnsupportedEncodingException e) {
// Do nothing - UTF-8 should always be supported
}
... | class class_name[name] begin[{]
method[urlEncode, return_type[type[String]], modifier[public static], parameter[value]] begin[{]
if[binary_operation[member[.value], ==, literal[null]]] begin[{]
return[member[.value]]
else begin[{]
None
end[}]
TryStatement(blo... | Keyword[public] Keyword[static] identifier[String] identifier[urlEncode] operator[SEP] identifier[String] identifier[value] operator[SEP] {
Keyword[if] operator[SEP] identifier[value] operator[==] Other[null] operator[SEP] {
Keyword[return] identifier[value] operator[SEP]
}
Keyword[try] ... |
final CompletableFuture<T> postFire(CompletableFuture<?> a, CompletableFuture<?> b, int mode) {
if (b != null && b.stack != null) { // clean second source
Object r;
if ((r = b.result) == null)
b.cleanStack();
if (mode >= 0 && (r != null || b.result != null))
b.postComplete();
}... | class class_name[name] begin[{]
method[postFire, return_type[type[CompletableFuture]], modifier[final], parameter[a, b, mode]] begin[{]
if[binary_operation[binary_operation[member[.b], !=, literal[null]], &&, binary_operation[member[b.stack], !=, literal[null]]]] begin[{]
local_vari... | Keyword[final] identifier[CompletableFuture] operator[<] identifier[T] operator[>] identifier[postFire] operator[SEP] identifier[CompletableFuture] operator[<] operator[?] operator[>] identifier[a] , identifier[CompletableFuture] operator[<] operator[?] operator[>] identifier[b] , Keyword[int] identifier[mode] operat... |
public static WebServiceCommunication newInstance() throws Exception {
SystemConfiguration sysConfig = SystemConfiguration.getInstance();
String host = sysConfig.getProperty(WebServiceCommunication.SYSPROP_HOST, "localhost");
int port = sysConfig.getIntProperty(WebServiceCommunication.SYSPROP_PO... | class class_name[name] begin[{]
method[newInstance, return_type[type[WebServiceCommunication]], modifier[public static], parameter[]] begin[{]
local_variable[type[SystemConfiguration], sysConfig]
local_variable[type[String], host]
local_variable[type[int], port]
local_variable[t... | Keyword[public] Keyword[static] identifier[WebServiceCommunication] identifier[newInstance] operator[SEP] operator[SEP] Keyword[throws] identifier[Exception] {
identifier[SystemConfiguration] identifier[sysConfig] operator[=] identifier[SystemConfiguration] operator[SEP] identifier[getInstance] operator[SEP] ope... |
@Override
public ProcessorResult handleWrite(Object action) throws ODataException {
Operation operation;
if (action instanceof Operation) {
operation = (Operation) action;
Object data = operation.doOperation(getODataRequestContext(), getDataSourceFactory());
if (d... | class class_name[name] begin[{]
method[handleWrite, return_type[type[ProcessorResult]], modifier[public], parameter[action]] begin[{]
local_variable[type[Operation], operation]
if[binary_operation[member[.action], instanceof, type[Operation]]] begin[{]
assign[mem... | annotation[@] identifier[Override] Keyword[public] identifier[ProcessorResult] identifier[handleWrite] operator[SEP] identifier[Object] identifier[action] operator[SEP] Keyword[throws] identifier[ODataException] {
identifier[Operation] identifier[operation] operator[SEP] Keyword[if] operator[SEP] identifier[acti... |
public String readLine() throws IOException {
synchronized (in) {
if (buf == null) {
throw new IOException("LineReader is closed");
}
// Read more data if we are at the end of the buffered data.
// Though it's an error to read after an exception, we will let {@code fillBuf()}
// throw again if tha... | class class_name[name] begin[{]
method[readLine, return_type[type[String]], modifier[public], parameter[]] begin[{]
SYNCHRONIZED[member[.in]] BEGIN[{]
if[binary_operation[member[.buf], ==, literal[null]]] begin[{]
ThrowStatement(expression=ClassCreator(ar... | Keyword[public] identifier[String] identifier[readLine] operator[SEP] operator[SEP] Keyword[throws] identifier[IOException] {
Keyword[synchronized] operator[SEP] identifier[in] operator[SEP] {
Keyword[if] operator[SEP] identifier[buf] operator[==] Other[null] operator[SEP] {
Keyword[thr... |
public final UptimeCheckConfig updateUptimeCheckConfig(UptimeCheckConfig uptimeCheckConfig) {
UpdateUptimeCheckConfigRequest request =
UpdateUptimeCheckConfigRequest.newBuilder().setUptimeCheckConfig(uptimeCheckConfig).build();
return updateUptimeCheckConfig(request);
} | class class_name[name] begin[{]
method[updateUptimeCheckConfig, return_type[type[UptimeCheckConfig]], modifier[final public], parameter[uptimeCheckConfig]] begin[{]
local_variable[type[UpdateUptimeCheckConfigRequest], request]
return[call[.updateUptimeCheckConfig, parameter[member[.request]]]]
... | Keyword[public] Keyword[final] identifier[UptimeCheckConfig] identifier[updateUptimeCheckConfig] operator[SEP] identifier[UptimeCheckConfig] identifier[uptimeCheckConfig] operator[SEP] {
identifier[UpdateUptimeCheckConfigRequest] identifier[request] operator[=] identifier[UpdateUptimeCheckConfigRequest] operator... |
public static BaseMessage createMessage(String strMessageClassName, BaseMessageHeader messageHeader, Object data)
{
BaseMessage message = null;
if ((strMessageClassName == null)
&& (messageHeader != null))
{
strMessageClassName = (String)messageHeader.get(BaseMessa... | class class_name[name] begin[{]
method[createMessage, return_type[type[BaseMessage]], modifier[public static], parameter[strMessageClassName, messageHeader, data]] begin[{]
local_variable[type[BaseMessage], message]
if[binary_operation[binary_operation[member[.strMessageClassName], ==, ... | Keyword[public] Keyword[static] identifier[BaseMessage] identifier[createMessage] operator[SEP] identifier[String] identifier[strMessageClassName] , identifier[BaseMessageHeader] identifier[messageHeader] , identifier[Object] identifier[data] operator[SEP] {
identifier[BaseMessage] identifier[message] operator... |
@Override
public Integer get_version(String path, boolean watch) throws Exception {
return zkObj.getVersion(zk, path, watch);
} | class class_name[name] begin[{]
method[get_version, return_type[type[Integer]], modifier[public], parameter[path, watch]] begin[{]
return[call[zkObj.getVersion, parameter[member[.zk], member[.path], member[.watch]]]]
end[}]
END[}] | annotation[@] identifier[Override] Keyword[public] identifier[Integer] identifier[get_version] operator[SEP] identifier[String] identifier[path] , Keyword[boolean] identifier[watch] operator[SEP] Keyword[throws] identifier[Exception] {
Keyword[return] identifier[zkObj] operator[SEP] identifier[getVersion] opera... |
public static Set<Dependency> getAllDependencies(final Module module, final List<String> producedArtifacts) {
final Set<Dependency> dependencies = new HashSet<Dependency>();
for(final Dependency dependency: module.getDependencies()){
if(!producedArtifacts.contains(dependency.getTarget().get... | class class_name[name] begin[{]
method[getAllDependencies, return_type[type[Set]], modifier[public static], parameter[module, producedArtifacts]] begin[{]
local_variable[type[Set], dependencies]
ForStatement(body=BlockStatement(label=None, statements=[IfStatement(condition=MethodInvocation(argu... | Keyword[public] Keyword[static] identifier[Set] operator[<] identifier[Dependency] operator[>] identifier[getAllDependencies] operator[SEP] Keyword[final] identifier[Module] identifier[module] , Keyword[final] identifier[List] operator[<] identifier[String] operator[>] identifier[producedArtifacts] operator[SEP] {
... |
public void setType(MsgType type) {
this.type = type;
if (type == MsgType.flash) {
this.mclass = MClassType.flash;
} else {
this.mclass = MClassType.normal;
}
} | class class_name[name] begin[{]
method[setType, return_type[void], modifier[public], parameter[type]] begin[{]
assign[THIS[member[None.type]], member[.type]]
if[binary_operation[member[.type], ==, member[MsgType.flash]]] begin[{]
assign[THIS[member[None.m... | Keyword[public] Keyword[void] identifier[setType] operator[SEP] identifier[MsgType] identifier[type] operator[SEP] {
Keyword[this] operator[SEP] identifier[type] operator[=] identifier[type] operator[SEP] Keyword[if] operator[SEP] identifier[type] operator[==] identifier[MsgType] operator[SEP] identifier[flash] ... |
List<Long> includeUpdateBatch(long segmentId, TableKeyBatch batch, long batchOffset) {
SegmentKeyCache cache;
int generation;
synchronized (this.segmentCaches) {
generation = this.currentCacheGeneration;
cache = this.segmentCaches.computeIfAbsent(segmentId, s -> new Segme... | class class_name[name] begin[{]
method[includeUpdateBatch, return_type[type[List]], modifier[default], parameter[segmentId, batch, batchOffset]] begin[{]
local_variable[type[SegmentKeyCache], cache]
local_variable[type[int], generation]
SYNCHRONIZED[THIS[member[None.segmentCache... | identifier[List] operator[<] identifier[Long] operator[>] identifier[includeUpdateBatch] operator[SEP] Keyword[long] identifier[segmentId] , identifier[TableKeyBatch] identifier[batch] , Keyword[long] identifier[batchOffset] operator[SEP] {
identifier[SegmentKeyCache] identifier[cache] operator[SEP] Keyword[in... |
public void addIntentFilterForActivity(ComponentName componentName, IntentFilter filter)
throws NameNotFoundException {
addIntentFilterForComponent(componentName, filter, activityFilters);
} | class class_name[name] begin[{]
method[addIntentFilterForActivity, return_type[void], modifier[public], parameter[componentName, filter]] begin[{]
call[.addIntentFilterForComponent, parameter[member[.componentName], member[.filter], member[.activityFilters]]]
end[}]
END[}] | Keyword[public] Keyword[void] identifier[addIntentFilterForActivity] operator[SEP] identifier[ComponentName] identifier[componentName] , identifier[IntentFilter] identifier[filter] operator[SEP] Keyword[throws] identifier[NameNotFoundException] {
identifier[addIntentFilterForComponent] operator[SEP] identifier[... |
private boolean hasEagerSingletonBinding() {
for (Key<?> key : bindings.keySet()) {
GinScope scope = determineScope(key);
if (GinScope.EAGER_SINGLETON.equals(scope)) {
return true;
}
}
return false;
} | class class_name[name] begin[{]
method[hasEagerSingletonBinding, return_type[type[boolean]], modifier[private], parameter[]] begin[{]
ForStatement(body=BlockStatement(label=None, statements=[LocalVariableDeclaration(annotations=[], declarators=[VariableDeclarator(dimensions=[], initializer=MethodInvoca... | Keyword[private] Keyword[boolean] identifier[hasEagerSingletonBinding] operator[SEP] operator[SEP] {
Keyword[for] operator[SEP] identifier[Key] operator[<] operator[?] operator[>] identifier[key] operator[:] identifier[bindings] operator[SEP] identifier[keySet] operator[SEP] operator[SEP] operator[SEP] {
... |
private void appendSelectionCriteria(TableAlias alias, PathInfo pathInfo, SelectionCriteria c, StringBuffer buf)
{
appendColName(alias, pathInfo, c.isTranslateAttribute(), buf);
buf.append(c.getClause());
appendParameter(c.getValue(), buf);
} | class class_name[name] begin[{]
method[appendSelectionCriteria, return_type[void], modifier[private], parameter[alias, pathInfo, c, buf]] begin[{]
call[.appendColName, parameter[member[.alias], member[.pathInfo], call[c.isTranslateAttribute, parameter[]], member[.buf]]]
call[buf... | Keyword[private] Keyword[void] identifier[appendSelectionCriteria] operator[SEP] identifier[TableAlias] identifier[alias] , identifier[PathInfo] identifier[pathInfo] , identifier[SelectionCriteria] identifier[c] , identifier[StringBuffer] identifier[buf] operator[SEP] {
identifier[appendColName] operator[SEP]... |
public T withRetryPolicy(RetryPolicy retryPolicy) {
getOptions().setRetryPolicy(Optional.of(retryPolicy));
return getThis();
} | class class_name[name] begin[{]
method[withRetryPolicy, return_type[type[T]], modifier[public], parameter[retryPolicy]] begin[{]
call[.getOptions, parameter[]]
return[call[.getThis, parameter[]]]
end[}]
END[}] | Keyword[public] identifier[T] identifier[withRetryPolicy] operator[SEP] identifier[RetryPolicy] identifier[retryPolicy] operator[SEP] {
identifier[getOptions] operator[SEP] operator[SEP] operator[SEP] identifier[setRetryPolicy] operator[SEP] identifier[Optional] operator[SEP] identifier[of] operator[SEP] identif... |
protected void refreshDeviceCache(final BluetoothGatt gatt, final boolean force) {
/*
* If the device is bonded this is up to the Service Changed characteristic to notify Android that the services has changed.
* There is no need for this trick in that case.
* If not bonded, the Android should not keep the se... | class class_name[name] begin[{]
method[refreshDeviceCache, return_type[void], modifier[protected], parameter[gatt, force]] begin[{]
if[binary_operation[member[.force], ||, binary_operation[call[gatt.getDevice, parameter[]], ==, member[BluetoothDevice.BOND_NONE]]]] begin[{]
... | Keyword[protected] Keyword[void] identifier[refreshDeviceCache] operator[SEP] Keyword[final] identifier[BluetoothGatt] identifier[gatt] , Keyword[final] Keyword[boolean] identifier[force] operator[SEP] {
Keyword[if] operator[SEP] identifier[force] operator[||] identifier[gatt] operator[SEP] identifier[getDevice... |
public static void writeInPemFormat(final X509Certificate certificate,
final @NonNull OutputStream outputStream) throws IOException, CertificateEncodingException
{
write(certificate, outputStream, KeyFileFormat.PEM);
} | class class_name[name] begin[{]
method[writeInPemFormat, return_type[void], modifier[public static], parameter[certificate, outputStream]] begin[{]
call[.write, parameter[member[.certificate], member[.outputStream], member[KeyFileFormat.PEM]]]
end[}]
END[}] | Keyword[public] Keyword[static] Keyword[void] identifier[writeInPemFormat] operator[SEP] Keyword[final] identifier[X509Certificate] identifier[certificate] , Keyword[final] annotation[@] identifier[NonNull] identifier[OutputStream] identifier[outputStream] operator[SEP] Keyword[throws] identifier[IOException] , ident... |
@Override
public void putAllFailure(Map<? extends K, ? extends V> entries, StoreAccessException e) {
try {
loaderWriter.writeAll(entries.entrySet()); // FIXME: bad typing that we should fix
} catch(BulkCacheWritingException e1) {
throw e1;
} catch (Exception e1) {
throw ExceptionFactory.... | class class_name[name] begin[{]
method[putAllFailure, return_type[void], modifier[public], parameter[entries, e]] begin[{]
TryStatement(block=[StatementExpression(expression=MethodInvocation(arguments=[MethodInvocation(arguments=[], member=entrySet, postfix_operators=[], prefix_operators=[], qualifier=... | annotation[@] identifier[Override] Keyword[public] Keyword[void] identifier[putAllFailure] operator[SEP] identifier[Map] operator[<] operator[?] Keyword[extends] identifier[K] , operator[?] Keyword[extends] identifier[V] operator[>] identifier[entries] , identifier[StoreAccessException] identifier[e] operator[SEP] {... |
public static List<InetAddress> getMulticastAddresses() throws SocketException {
Enumeration<NetworkInterface> nifs = NetworkInterface.getNetworkInterfaces();
List<InetAddress> ret = new ArrayList<InetAddress>();
while (nifs.hasMoreElements()) {
NetworkInterface nif = nifs.nextElemen... | class class_name[name] begin[{]
method[getMulticastAddresses, return_type[type[List]], modifier[public static], parameter[]] begin[{]
local_variable[type[Enumeration], nifs]
local_variable[type[List], ret]
while[call[nifs.hasMoreElements, parameter[]]] begin[{]
local... | Keyword[public] Keyword[static] identifier[List] operator[<] identifier[InetAddress] operator[>] identifier[getMulticastAddresses] operator[SEP] operator[SEP] Keyword[throws] identifier[SocketException] {
identifier[Enumeration] operator[<] identifier[NetworkInterface] operator[>] identifier[nifs] operator[=] id... |
public void setYMap(Integer newYMap) {
Integer oldYMap = yMap;
yMap = newYMap;
if (eNotificationRequired())
eNotify(new ENotificationImpl(this, Notification.SET, AfplibPackage.IOC__YMAP, oldYMap, yMap));
} | class class_name[name] begin[{]
method[setYMap, return_type[void], modifier[public], parameter[newYMap]] begin[{]
local_variable[type[Integer], oldYMap]
assign[member[.yMap], member[.newYMap]]
if[call[.eNotificationRequired, parameter[]]] begin[{]
call[.eNoti... | Keyword[public] Keyword[void] identifier[setYMap] operator[SEP] identifier[Integer] identifier[newYMap] operator[SEP] {
identifier[Integer] identifier[oldYMap] operator[=] identifier[yMap] operator[SEP] identifier[yMap] operator[=] identifier[newYMap] operator[SEP] Keyword[if] operator[SEP] identifier[eNotificat... |
private void applyAsyncPersist(AsyncPersistRequestEntry entry) {
applyUpdateInode(UpdateInodeEntry.newBuilder().setId(entry.getFileId())
.setPersistenceState(PersistenceState.TO_BE_PERSISTED.name()).build());
} | class class_name[name] begin[{]
method[applyAsyncPersist, return_type[void], modifier[private], parameter[entry]] begin[{]
call[.applyUpdateInode, parameter[call[UpdateInodeEntry.newBuilder, parameter[]]]]
end[}]
END[}] | Keyword[private] Keyword[void] identifier[applyAsyncPersist] operator[SEP] identifier[AsyncPersistRequestEntry] identifier[entry] operator[SEP] {
identifier[applyUpdateInode] operator[SEP] identifier[UpdateInodeEntry] operator[SEP] identifier[newBuilder] operator[SEP] operator[SEP] operator[SEP] identifier[setId... |
@Override
public double getDouble(@NonNull String key) {
if (key == null) { throw new IllegalArgumentException("key cannot be null."); }
synchronized (lock) {
return CBLConverter.asDouble(getMValue(internalDict, key), internalDict);
}
} | class class_name[name] begin[{]
method[getDouble, return_type[type[double]], modifier[public], parameter[key]] begin[{]
if[binary_operation[member[.key], ==, literal[null]]] begin[{]
ThrowStatement(expression=ClassCreator(arguments=[Literal(postfix_operators=[], prefix_operators=[],... | annotation[@] identifier[Override] Keyword[public] Keyword[double] identifier[getDouble] operator[SEP] annotation[@] identifier[NonNull] identifier[String] identifier[key] operator[SEP] {
Keyword[if] operator[SEP] identifier[key] operator[==] Other[null] operator[SEP] {
Keyword[throw] Keyword[new] ide... |
public static String getExtension(String resourceName) {
String result = null;
if (!resourceName.endsWith("/")) {
// folders don't have any extension
resourceName = CmsResource.getName(resourceName);
int index = resourceName.lastIndexOf(".") + 1;
if ((ind... | class class_name[name] begin[{]
method[getExtension, return_type[type[String]], modifier[public static], parameter[resourceName]] begin[{]
local_variable[type[String], result]
if[call[resourceName.endsWith, parameter[literal["/"]]]] begin[{]
assign[member[.resour... | Keyword[public] Keyword[static] identifier[String] identifier[getExtension] operator[SEP] identifier[String] identifier[resourceName] operator[SEP] {
identifier[String] identifier[result] operator[=] Other[null] operator[SEP] Keyword[if] operator[SEP] operator[!] identifier[resourceName] operator[SEP] identifier... |
@Override
public Tag visitTag(Context context, Tag tag) {
return filter.filterTag(tag);
} | class class_name[name] begin[{]
method[visitTag, return_type[type[Tag]], modifier[public], parameter[context, tag]] begin[{]
return[call[filter.filterTag, parameter[member[.tag]]]]
end[}]
END[}] | annotation[@] identifier[Override] Keyword[public] identifier[Tag] identifier[visitTag] operator[SEP] identifier[Context] identifier[context] , identifier[Tag] identifier[tag] operator[SEP] {
Keyword[return] identifier[filter] operator[SEP] identifier[filterTag] operator[SEP] identifier[tag] operator[SEP] opera... |
public static void addGaussian(GrayS16 input, Random rand , double sigma , int lowerBound , int upperBound ) {
for (int y = 0; y < input.height; y++) {
int index = input.getStartIndex() + y * input.getStride();
for (int x = 0; x < input.width; x++) {
int value = (input.data[index] ) + (int)(rand.nextGaussi... | class class_name[name] begin[{]
method[addGaussian, return_type[void], modifier[public static], parameter[input, rand, sigma, lowerBound, upperBound]] begin[{]
ForStatement(body=BlockStatement(label=None, statements=[LocalVariableDeclaration(annotations=[], declarators=[VariableDeclarator(dimensions=[]... | Keyword[public] Keyword[static] Keyword[void] identifier[addGaussian] operator[SEP] identifier[GrayS16] identifier[input] , identifier[Random] identifier[rand] , Keyword[double] identifier[sigma] , Keyword[int] identifier[lowerBound] , Keyword[int] identifier[upperBound] operator[SEP] {
Keyword[for] operator... |
public static @Nonnull Predicate nameContains(final @Nonnull Pattern pattern) {
return new Predicate() {
@Override
public boolean isValid(@Nonnull ProcessThread<?, ?, ?> thread) {
return pattern.matcher(thread.getName()).find();
}
};
} | class class_name[name] begin[{]
method[nameContains, return_type[type[Predicate]], modifier[public static], parameter[pattern]] begin[{]
return[ClassCreator(arguments=[], body=[MethodDeclaration(annotations=[Annotation(element=None, name=Override)], body=[ReturnStatement(expression=MethodInvocation(arg... | Keyword[public] Keyword[static] annotation[@] identifier[Nonnull] identifier[Predicate] identifier[nameContains] operator[SEP] Keyword[final] annotation[@] identifier[Nonnull] identifier[Pattern] identifier[pattern] operator[SEP] {
Keyword[return] Keyword[new] identifier[Predicate] operator[SEP] operator[SEP] {... |
public static VAlarm display(Trigger trigger, String displayText) {
VAlarm alarm = new VAlarm(Action.display(), trigger);
alarm.setDescription(displayText);
return alarm;
} | class class_name[name] begin[{]
method[display, return_type[type[VAlarm]], modifier[public static], parameter[trigger, displayText]] begin[{]
local_variable[type[VAlarm], alarm]
call[alarm.setDescription, parameter[member[.displayText]]]
return[member[.alarm]]
end[}]
END[}] | Keyword[public] Keyword[static] identifier[VAlarm] identifier[display] operator[SEP] identifier[Trigger] identifier[trigger] , identifier[String] identifier[displayText] operator[SEP] {
identifier[VAlarm] identifier[alarm] operator[=] Keyword[new] identifier[VAlarm] operator[SEP] identifier[Action] operator[SEP... |
private void buildOutMessage(Exchange exchange, Message message) {
org.apache.camel.Message reply = exchange.getOut();
for (Map.Entry<String, Object> header : message.getHeaders().entrySet()) {
if (!header.getKey().startsWith(MessageHeaders.PREFIX)) {
reply.setHeader(header.g... | class class_name[name] begin[{]
method[buildOutMessage, return_type[void], modifier[private], parameter[exchange, message]] begin[{]
local_variable[type[org], reply]
ForStatement(body=BlockStatement(label=None, statements=[IfStatement(condition=MethodInvocation(arguments=[], member=getKey, post... | Keyword[private] Keyword[void] identifier[buildOutMessage] operator[SEP] identifier[Exchange] identifier[exchange] , identifier[Message] identifier[message] operator[SEP] {
identifier[org] operator[SEP] identifier[apache] operator[SEP] identifier[camel] operator[SEP] identifier[Message] identifier[reply] operat... |
public static byte[] readBytes(InputStream is) throws IOException {
try (ByteArrayOutputStream bos = new ByteArrayOutputStream(is.available())) {
copy(is, bos);
return bos.toByteArray();
}
} | class class_name[name] begin[{]
method[readBytes, return_type[type[byte]], modifier[public static], parameter[is]] begin[{]
TryStatement(block=[StatementExpression(expression=MethodInvocation(arguments=[MemberReference(member=is, postfix_operators=[], prefix_operators=[], qualifier=, selectors=[]), Mem... | Keyword[public] Keyword[static] Keyword[byte] operator[SEP] operator[SEP] identifier[readBytes] operator[SEP] identifier[InputStream] identifier[is] operator[SEP] Keyword[throws] identifier[IOException] {
Keyword[try] operator[SEP] identifier[ByteArrayOutputStream] identifier[bos] operator[=] Keyword[new] identi... |
public SDVariable reshape(SDVariable x, SDVariable shape) {
return reshape(null, x, shape);
} | class class_name[name] begin[{]
method[reshape, return_type[type[SDVariable]], modifier[public], parameter[x, shape]] begin[{]
return[call[.reshape, parameter[literal[null], member[.x], member[.shape]]]]
end[}]
END[}] | Keyword[public] identifier[SDVariable] identifier[reshape] operator[SEP] identifier[SDVariable] identifier[x] , identifier[SDVariable] identifier[shape] operator[SEP] {
Keyword[return] identifier[reshape] operator[SEP] Other[null] , identifier[x] , identifier[shape] operator[SEP] operator[SEP]
}
|
@MainThread
public void consume(final Product product) {
if (product.getProductType().getItemType().equals(ItemType.MANAGED)) {
String token = product.getPurchase().getToken();
String productId = product.getId();
if (StringUtils.isBlank(token)) {
ErrorCodeException errorCodeException = InAppBillingError... | class class_name[name] begin[{]
method[consume, return_type[void], modifier[public], parameter[product]] begin[{]
if[call[product.getProductType, parameter[]]] begin[{]
local_variable[type[String], token]
local_variable[type[String], productId]
if... | annotation[@] identifier[MainThread] Keyword[public] Keyword[void] identifier[consume] operator[SEP] Keyword[final] identifier[Product] identifier[product] operator[SEP] {
Keyword[if] operator[SEP] identifier[product] operator[SEP] identifier[getProductType] operator[SEP] operator[SEP] operator[SEP] identifier[g... |
@Override
public String serialize(ScriptModuleSpec moduleSpec) {
Objects.requireNonNull(moduleSpec, "moduleSpec");
String json = SERIALIZER.toJson(moduleSpec);
return json;
} | class class_name[name] begin[{]
method[serialize, return_type[type[String]], modifier[public], parameter[moduleSpec]] begin[{]
call[Objects.requireNonNull, parameter[member[.moduleSpec], literal["moduleSpec"]]]
local_variable[type[String], json]
return[member[.json]]
end[}]
... | annotation[@] identifier[Override] Keyword[public] identifier[String] identifier[serialize] operator[SEP] identifier[ScriptModuleSpec] identifier[moduleSpec] operator[SEP] {
identifier[Objects] operator[SEP] identifier[requireNonNull] operator[SEP] identifier[moduleSpec] , literal[String] operator[SEP] operator... |
@Value.Derived
protected boolean referenceCharOffsetsSequential() {
for (int i = 1; i < characterRegions().size(); ++i) {
if (!characterRegions().get(i - 1).referenceEndOffsetInclusive().charOffset()
.precedesOrEquals(
characterRegions().get(i).referenceStartOffsetInclusive().charOff... | class class_name[name] begin[{]
method[referenceCharOffsetsSequential, return_type[type[boolean]], modifier[protected], parameter[]] begin[{]
ForStatement(body=BlockStatement(label=None, statements=[IfStatement(condition=MethodInvocation(arguments=[], member=characterRegions, postfix_operators=[], pref... | annotation[@] identifier[Value] operator[SEP] identifier[Derived] Keyword[protected] Keyword[boolean] identifier[referenceCharOffsetsSequential] operator[SEP] operator[SEP] {
Keyword[for] operator[SEP] Keyword[int] identifier[i] operator[=] Other[1] operator[SEP] identifier[i] operator[<] identifier[characterReg... |
public ApplyProfile createDefaultProfile(String profileType) throws RuntimeFault, RemoteException {
return createDefaultProfile(profileType, null, null);
} | class class_name[name] begin[{]
method[createDefaultProfile, return_type[type[ApplyProfile]], modifier[public], parameter[profileType]] begin[{]
return[call[.createDefaultProfile, parameter[member[.profileType], literal[null], literal[null]]]]
end[}]
END[}] | Keyword[public] identifier[ApplyProfile] identifier[createDefaultProfile] operator[SEP] identifier[String] identifier[profileType] operator[SEP] Keyword[throws] identifier[RuntimeFault] , identifier[RemoteException] {
Keyword[return] identifier[createDefaultProfile] operator[SEP] identifier[profileType] , Othe... |
@Override
public void addUninvertingMappings(Map<String, Type> uninvertingMap) {
for (String fieldName : getFieldNames()) {
uninvertingMap.put(fieldName, Type.SORTED);
}
} | class class_name[name] begin[{]
method[addUninvertingMappings, return_type[void], modifier[public], parameter[uninvertingMap]] begin[{]
ForStatement(body=BlockStatement(label=None, statements=[StatementExpression(expression=MethodInvocation(arguments=[MemberReference(member=fieldName, postfix_operators... | annotation[@] identifier[Override] Keyword[public] Keyword[void] identifier[addUninvertingMappings] operator[SEP] identifier[Map] operator[<] identifier[String] , identifier[Type] operator[>] identifier[uninvertingMap] operator[SEP] {
Keyword[for] operator[SEP] identifier[String] identifier[fieldName] operator[... |
@Override
public void configure(Properties configuration) {
String u = configuration.getProperty(ANDROLOG_REPORTER_MAIL_ADDRESS);
if (u == null) {
Log.e(this, "The Property " + ANDROLOG_REPORTER_MAIL_ADDRESS
+ " is mandatory");
return;
}
to... | class class_name[name] begin[{]
method[configure, return_type[void], modifier[public], parameter[configuration]] begin[{]
local_variable[type[String], u]
if[binary_operation[member[.u], ==, literal[null]]] begin[{]
call[Log.e, parameter[THIS[], binary_operation[b... | annotation[@] identifier[Override] Keyword[public] Keyword[void] identifier[configure] operator[SEP] identifier[Properties] identifier[configuration] operator[SEP] {
identifier[String] identifier[u] operator[=] identifier[configuration] operator[SEP] identifier[getProperty] operator[SEP] identifier[ANDROLOG_REPO... |
public void resolveFromRepositories( Artifact artifact, List remoteRepositories,
ArtifactRepository localRepository )
throws MojoExecutionException
{
try
{
artifactResolver.resolve( artifact, remoteRepositories, localRepository );
... | class class_name[name] begin[{]
method[resolveFromRepositories, return_type[void], modifier[public], parameter[artifact, remoteRepositories, localRepository]] begin[{]
TryStatement(block=[StatementExpression(expression=MethodInvocation(arguments=[MemberReference(member=artifact, postfix_operators=[], p... | Keyword[public] Keyword[void] identifier[resolveFromRepositories] operator[SEP] identifier[Artifact] identifier[artifact] , identifier[List] identifier[remoteRepositories] , identifier[ArtifactRepository] identifier[localRepository] operator[SEP] Keyword[throws] identifier[MojoExecutionException] {
Keyword[try... |
public static long readFullyToFile(InputStream is, File toFile)
throws IOException {
OutputStream os = org.apache.commons.io.FileUtils.openOutputStream(toFile);
try {
return IOUtils.copyLarge(is, os);
} finally {
IOUtils.closeQuietly(os);
IOUtils... | class class_name[name] begin[{]
method[readFullyToFile, return_type[type[long]], modifier[public static], parameter[is, toFile]] begin[{]
local_variable[type[OutputStream], os]
TryStatement(block=[ReturnStatement(expression=MethodInvocation(arguments=[MemberReference(member=is, postfix_operator... | Keyword[public] Keyword[static] Keyword[long] identifier[readFullyToFile] operator[SEP] identifier[InputStream] identifier[is] , identifier[File] identifier[toFile] operator[SEP] Keyword[throws] identifier[IOException] {
identifier[OutputStream] identifier[os] operator[=] identifier[org] operator[SEP] identifie... |
private void waitIndexingNotSuspended() {
boolean suspendedNotified = false;
synchronized (suspendLock) {
while (suspend > 0) {
if (!suspendedNotified) {
suspendedNotified = true;
}
try {
suspendLock.wait... | class class_name[name] begin[{]
method[waitIndexingNotSuspended, return_type[void], modifier[private], parameter[]] begin[{]
local_variable[type[boolean], suspendedNotified]
SYNCHRONIZED[member[.suspendLock]] BEGIN[{]
while[binary_operation[member[.suspend], >, l... | Keyword[private] Keyword[void] identifier[waitIndexingNotSuspended] operator[SEP] operator[SEP] {
Keyword[boolean] identifier[suspendedNotified] operator[=] literal[boolean] operator[SEP] Keyword[synchronized] operator[SEP] identifier[suspendLock] operator[SEP] {
Keyword[while] operator[SEP] identifie... |
public static void parse(DocListener document, String file) {
HtmlParser p = new HtmlParser();
p.go(document, file);
} | class class_name[name] begin[{]
method[parse, return_type[void], modifier[public static], parameter[document, file]] begin[{]
local_variable[type[HtmlParser], p]
call[p.go, parameter[member[.document], member[.file]]]
end[}]
END[}] | Keyword[public] Keyword[static] Keyword[void] identifier[parse] operator[SEP] identifier[DocListener] identifier[document] , identifier[String] identifier[file] operator[SEP] {
identifier[HtmlParser] identifier[p] operator[=] Keyword[new] identifier[HtmlParser] operator[SEP] operator[SEP] operator[SEP] identifi... |
public static double getRadius(Atom atom) {
if (atom.getElement()==null) {
logger.warn("Unrecognised atom "+atom.getName()+" with serial "+atom.getPDBserial()+
", assigning the default vdw radius (Nitrogen vdw radius).");
return Element.N.getVDWRadius();
}
Group res = atom.getGroup();
if (res==nul... | class class_name[name] begin[{]
method[getRadius, return_type[type[double]], modifier[public static], parameter[atom]] begin[{]
if[binary_operation[call[atom.getElement, parameter[]], ==, literal[null]]] begin[{]
call[logger.warn, parameter[binary_operation[binary_operat... | Keyword[public] Keyword[static] Keyword[double] identifier[getRadius] operator[SEP] identifier[Atom] identifier[atom] operator[SEP] {
Keyword[if] operator[SEP] identifier[atom] operator[SEP] identifier[getElement] operator[SEP] operator[SEP] operator[==] Other[null] operator[SEP] {
identifier[logger] ... |
public Field createFieldTrueFalse(Field formFieldParam)
{
if(formFieldParam != null && this.serviceTicket != null) {
formFieldParam.setServiceTicket(this.serviceTicket);
}
if(formFieldParam != null) {
formFieldParam.setTypeAsEnum(Field.Type.TrueFalse);
fo... | class class_name[name] begin[{]
method[createFieldTrueFalse, return_type[type[Field]], modifier[public], parameter[formFieldParam]] begin[{]
if[binary_operation[binary_operation[member[.formFieldParam], !=, literal[null]], &&, binary_operation[THIS[member[None.serviceTicket]], !=, literal[null]... | Keyword[public] identifier[Field] identifier[createFieldTrueFalse] operator[SEP] identifier[Field] identifier[formFieldParam] operator[SEP] {
Keyword[if] operator[SEP] identifier[formFieldParam] operator[!=] Other[null] operator[&&] Keyword[this] operator[SEP] identifier[serviceTicket] operator[!=] Other[null] o... |
public void setAllocatedResource(final AllocatedResource allocatedResource) {
if (allocatedResource == null) {
throw new IllegalArgumentException("Argument allocatedResource must not be null");
}
final AllocatedResource previousResource = this.allocatedResource.getAndSet(allocatedResource);
if (previousRes... | class class_name[name] begin[{]
method[setAllocatedResource, return_type[void], modifier[public], parameter[allocatedResource]] begin[{]
if[binary_operation[member[.allocatedResource], ==, literal[null]]] begin[{]
ThrowStatement(expression=ClassCreator(arguments=[Literal(postfix_ope... | Keyword[public] Keyword[void] identifier[setAllocatedResource] operator[SEP] Keyword[final] identifier[AllocatedResource] identifier[allocatedResource] operator[SEP] {
Keyword[if] operator[SEP] identifier[allocatedResource] operator[==] Other[null] operator[SEP] {
Keyword[throw] Keyword[new] identifie... |
@Override
public AnswerMessage createANM(int cic) {
AnswerMessage msg = createANM();
CircuitIdentificationCode code = this.parameterFactory.createCircuitIdentificationCode();
code.setCIC(cic);
msg.setCircuitIdentificationCode(code);
return msg;
} | class class_name[name] begin[{]
method[createANM, return_type[type[AnswerMessage]], modifier[public], parameter[cic]] begin[{]
local_variable[type[AnswerMessage], msg]
local_variable[type[CircuitIdentificationCode], code]
call[code.setCIC, parameter[member[.cic]]]
... | annotation[@] identifier[Override] Keyword[public] identifier[AnswerMessage] identifier[createANM] operator[SEP] Keyword[int] identifier[cic] operator[SEP] {
identifier[AnswerMessage] identifier[msg] operator[=] identifier[createANM] operator[SEP] operator[SEP] operator[SEP] identifier[CircuitIdentificationCode]... |
public void marshall(IntentMetadata intentMetadata, ProtocolMarshaller protocolMarshaller) {
if (intentMetadata == null) {
throw new SdkClientException("Invalid argument passed to marshall(...)");
}
try {
protocolMarshaller.marshall(intentMetadata.getName(), NAME_BINDIN... | class class_name[name] begin[{]
method[marshall, return_type[void], modifier[public], parameter[intentMetadata, protocolMarshaller]] begin[{]
if[binary_operation[member[.intentMetadata], ==, literal[null]]] begin[{]
ThrowStatement(expression=ClassCreator(arguments=[Literal(postfix_o... | Keyword[public] Keyword[void] identifier[marshall] operator[SEP] identifier[IntentMetadata] identifier[intentMetadata] , identifier[ProtocolMarshaller] identifier[protocolMarshaller] operator[SEP] {
Keyword[if] operator[SEP] identifier[intentMetadata] operator[==] Other[null] operator[SEP] {
Keyword[... |
public final void readInt(int[] pa, int start, int n) throws IOException {
for (int i = 0; i < n; i++) {
pa[start + i] = readInt();
}
} | class class_name[name] begin[{]
method[readInt, return_type[void], modifier[final public], parameter[pa, start, n]] begin[{]
ForStatement(body=BlockStatement(label=None, statements=[StatementExpression(expression=Assignment(expressionl=MemberReference(member=pa, postfix_operators=[], prefix_operators=[... | Keyword[public] Keyword[final] Keyword[void] identifier[readInt] operator[SEP] Keyword[int] operator[SEP] operator[SEP] identifier[pa] , Keyword[int] identifier[start] , Keyword[int] identifier[n] operator[SEP] Keyword[throws] identifier[IOException] {
Keyword[for] operator[SEP] Keyword[int] identifier[i] oper... |
public Object evaluate(Object pContext,
VariableResolver pResolver,
Map functions,
String defaultPrefix,
Logger pLogger)
throws ELException {
if (pResolver == null) {
return null;
... | class class_name[name] begin[{]
method[evaluate, return_type[type[Object]], modifier[public], parameter[pContext, pResolver, functions, defaultPrefix, pLogger]] begin[{]
if[binary_operation[member[.pResolver], ==, literal[null]]] begin[{]
return[literal[null]]
else begin[{]
... | Keyword[public] identifier[Object] identifier[evaluate] operator[SEP] identifier[Object] identifier[pContext] , identifier[VariableResolver] identifier[pResolver] , identifier[Map] identifier[functions] , identifier[String] identifier[defaultPrefix] , identifier[Logger] identifier[pLogger] operator[SEP] Keyword[thr... |
@Override
public DisassociateDeviceFromRoomResult disassociateDeviceFromRoom(DisassociateDeviceFromRoomRequest request) {
request = beforeClientExecution(request);
return executeDisassociateDeviceFromRoom(request);
} | class class_name[name] begin[{]
method[disassociateDeviceFromRoom, return_type[type[DisassociateDeviceFromRoomResult]], modifier[public], parameter[request]] begin[{]
assign[member[.request], call[.beforeClientExecution, parameter[member[.request]]]]
return[call[.executeDisassociateDevi... | annotation[@] identifier[Override] Keyword[public] identifier[DisassociateDeviceFromRoomResult] identifier[disassociateDeviceFromRoom] operator[SEP] identifier[DisassociateDeviceFromRoomRequest] identifier[request] operator[SEP] {
identifier[request] operator[=] identifier[beforeClientExecution] operator[SEP] id... |
public boolean validate(final List<Map<String, Object>> details) {
if (this.getMetric() == null || this.getMetric().isEmpty()) {
if (details != null) {
details.add(getHttpDetails("Metric name was empty"));
}
LOG.warn("Metric name was empty: " + this);
return false;
}
//TODO ... | class class_name[name] begin[{]
method[validate, return_type[type[boolean]], modifier[public], parameter[details]] begin[{]
if[binary_operation[binary_operation[THIS[call[None.getMetric, parameter[]]], ==, literal[null]], ||, THIS[call[None.getMetric, parameter[]]call[None.isEmpty, parameter[]]... | Keyword[public] Keyword[boolean] identifier[validate] operator[SEP] Keyword[final] identifier[List] operator[<] identifier[Map] operator[<] identifier[String] , identifier[Object] operator[>] operator[>] identifier[details] operator[SEP] {
Keyword[if] operator[SEP] Keyword[this] operator[SEP] identifier[getMetr... |
public List<String> validate(Entity entity) throws APIException, ConnectionException, OidException {
Asset asset = v1Instance.getAsset(entity.getInstanceKey()) != null ? v1Instance.getAsset(entity.getInstanceKey()) : v1Instance.getAsset(entity.getID());
return validate(asset);
} | class class_name[name] begin[{]
method[validate, return_type[type[List]], modifier[public], parameter[entity]] begin[{]
local_variable[type[Asset], asset]
return[call[.validate, parameter[member[.asset]]]]
end[}]
END[}] | Keyword[public] identifier[List] operator[<] identifier[String] operator[>] identifier[validate] operator[SEP] identifier[Entity] identifier[entity] operator[SEP] Keyword[throws] identifier[APIException] , identifier[ConnectionException] , identifier[OidException] {
identifier[Asset] identifier[asset] operator... |
public double[] toWraparoundOrder(double data[], int i0, int stride) {
if ((i0==0)&&(stride==2)) return data;
double newdata[] = new double[2*n];
for(int i=0; i<n; i++){
newdata[2*i] = data[i0+stride*i];
newdata[2*i+1] = data[i0+stride*i+1]; }
return newdata; } | class class_name[name] begin[{]
method[toWraparoundOrder, return_type[type[double]], modifier[public], parameter[data, i0, stride]] begin[{]
if[binary_operation[binary_operation[member[.i0], ==, literal[0]], &&, binary_operation[member[.stride], ==, literal[2]]]] begin[{]
return[member[.data]]
... | Keyword[public] Keyword[double] operator[SEP] operator[SEP] identifier[toWraparoundOrder] operator[SEP] Keyword[double] identifier[data] operator[SEP] operator[SEP] , Keyword[int] identifier[i0] , Keyword[int] identifier[stride] operator[SEP] {
Keyword[if] operator[SEP] operator[SEP] identifier[i0] operator[==... |
public void forEachResourceError (@Nonnull final Consumer <? super IError> aConsumer)
{
ValueEnforcer.notNull (aConsumer, "Consumer");
m_aRWLock.readLocked ( () -> m_aErrors.forEach (aConsumer));
} | class class_name[name] begin[{]
method[forEachResourceError, return_type[void], modifier[public], parameter[aConsumer]] begin[{]
call[ValueEnforcer.notNull, parameter[member[.aConsumer], literal["Consumer"]]]
call[m_aRWLock.readLocked, parameter[LambdaExpression(body=MethodInvoc... | Keyword[public] Keyword[void] identifier[forEachResourceError] operator[SEP] annotation[@] identifier[Nonnull] Keyword[final] identifier[Consumer] operator[<] operator[?] Keyword[super] identifier[IError] operator[>] identifier[aConsumer] operator[SEP] {
identifier[ValueEnforcer] operator[SEP] identifier[notNull... |
public static base_response update(nitro_service client, vpnsessionpolicy resource) throws Exception {
vpnsessionpolicy updateresource = new vpnsessionpolicy();
updateresource.name = resource.name;
updateresource.rule = resource.rule;
updateresource.action = resource.action;
return updateresource.update_resou... | class class_name[name] begin[{]
method[update, return_type[type[base_response]], modifier[public static], parameter[client, resource]] begin[{]
local_variable[type[vpnsessionpolicy], updateresource]
assign[member[updateresource.name], member[resource.name]]
assign[member... | Keyword[public] Keyword[static] identifier[base_response] identifier[update] operator[SEP] identifier[nitro_service] identifier[client] , identifier[vpnsessionpolicy] identifier[resource] operator[SEP] Keyword[throws] identifier[Exception] {
identifier[vpnsessionpolicy] identifier[updateresource] operator[=] Ke... |
public static CodeAnalysisResult countingCode(File file,
CodeAnalysisConf conf) {
if (!Files.isFile(file)) {
throw new RuntimeException("file is not a File, can't analysis it.");
}
if (null == conf) {
conf = CODE_INFO_JAVA... | class class_name[name] begin[{]
method[countingCode, return_type[type[CodeAnalysisResult]], modifier[public static], parameter[file, conf]] begin[{]
if[call[Files.isFile, parameter[member[.file]]]] begin[{]
ThrowStatement(expression=ClassCreator(arguments=[Literal(postfix_operators=... | Keyword[public] Keyword[static] identifier[CodeAnalysisResult] identifier[countingCode] operator[SEP] identifier[File] identifier[file] , identifier[CodeAnalysisConf] identifier[conf] operator[SEP] {
Keyword[if] operator[SEP] operator[!] identifier[Files] operator[SEP] identifier[isFile] operator[SEP] identifie... |
public void deselectByLabel(String label) {
getDispatcher().beforeDeselect(this, label);
new Select(getElement()).deselectByVisibleText(label);
if (Config.getBoolConfigProperty(ConfigProperty.ENABLE_GUI_LOGGING)) {
logUIActions(UIActions.CLEARED, label);
}
... | class class_name[name] begin[{]
method[deselectByLabel, return_type[void], modifier[public], parameter[label]] begin[{]
call[.getDispatcher, parameter[]]
ClassCreator(arguments=[MethodInvocation(arguments=[], member=getElement, postfix_operators=[], prefix_operators=[], qualifie... | Keyword[public] Keyword[void] identifier[deselectByLabel] operator[SEP] identifier[String] identifier[label] operator[SEP] {
identifier[getDispatcher] operator[SEP] operator[SEP] operator[SEP] identifier[beforeDeselect] operator[SEP] Keyword[this] , identifier[label] operator[SEP] operator[SEP] Keyword[new] ide... |
public Geometry transform(Geometry geometry, RenderSpace from, RenderSpace to) {
switch (from) {
case SCREEN:
switch (to) {
case SCREEN:
return GeometryService.clone(geometry);
case WORLD:
return screenToWorld(geometry);
}
case WORLD:
switch (to) {
case SCREEN:
retur... | class class_name[name] begin[{]
method[transform, return_type[type[Geometry]], modifier[public], parameter[geometry, from, to]] begin[{]
SwitchStatement(cases=[SwitchStatementCase(case=['SCREEN'], statements=[SwitchStatement(cases=[SwitchStatementCase(case=['SCREEN'], statements=[ReturnStatement(expres... | Keyword[public] identifier[Geometry] identifier[transform] operator[SEP] identifier[Geometry] identifier[geometry] , identifier[RenderSpace] identifier[from] , identifier[RenderSpace] identifier[to] operator[SEP] {
Keyword[switch] operator[SEP] identifier[from] operator[SEP] {
Keyword[case] identifi... |
public synchronized Map<PoolInfo, PoolInfo> getRedirects() {
return (poolInfoToRedirect == null) ? null :
new HashMap<PoolInfo, PoolInfo>(poolInfoToRedirect);
} | class class_name[name] begin[{]
method[getRedirects, return_type[type[Map]], modifier[synchronized public], parameter[]] begin[{]
return[TernaryExpression(condition=BinaryOperation(operandl=MemberReference(member=poolInfoToRedirect, postfix_operators=[], prefix_operators=[], qualifier=, selectors=[]), ... | Keyword[public] Keyword[synchronized] identifier[Map] operator[<] identifier[PoolInfo] , identifier[PoolInfo] operator[>] identifier[getRedirects] operator[SEP] operator[SEP] {
Keyword[return] operator[SEP] identifier[poolInfoToRedirect] operator[==] Other[null] operator[SEP] operator[?] Other[null] operator[:]... |
private static int decode4to3(byte[] source, int srcOffset,
byte[] destination, int destOffset, int options) {
byte[] DECODABET = getDecodabet(options);
// Example: Dk==
if (source[srcOffset + 2] == EQUALS_SIGN) {
// Two ways to do the same thing. Don't know which way I ... | class class_name[name] begin[{]
method[decode4to3, return_type[type[int]], modifier[private static], parameter[source, srcOffset, destination, destOffset, options]] begin[{]
local_variable[type[byte], DECODABET]
if[binary_operation[member[.source], ==, member[.EQUALS_SIGN]]] begin[{]
... | Keyword[private] Keyword[static] Keyword[int] identifier[decode4to3] operator[SEP] Keyword[byte] operator[SEP] operator[SEP] identifier[source] , Keyword[int] identifier[srcOffset] , Keyword[byte] operator[SEP] operator[SEP] identifier[destination] , Keyword[int] identifier[destOffset] , Keyword[int] identifier[opt... |
public static ClassLoader[] classLoaders(ClassLoader... classLoaders) {
if (classLoaders != null && classLoaders.length != 0) {
return classLoaders;
} else {
ClassLoader contextClassLoader = contextClassLoader(), staticClassLoader = staticClassLoader();
return context... | class class_name[name] begin[{]
method[classLoaders, return_type[type[ClassLoader]], modifier[public static], parameter[classLoaders]] begin[{]
if[binary_operation[binary_operation[member[.classLoaders], !=, literal[null]], &&, binary_operation[member[classLoaders.length], !=, literal[0]]]] beg... | Keyword[public] Keyword[static] identifier[ClassLoader] operator[SEP] operator[SEP] identifier[classLoaders] operator[SEP] identifier[ClassLoader] operator[...] identifier[classLoaders] operator[SEP] {
Keyword[if] operator[SEP] identifier[classLoaders] operator[!=] Other[null] operator[&&] identifier[classLoader... |
public static Properties loadProperties(String filePath) throws MnoConfigurationException {
Properties properties = new Properties();
InputStream input = getInputStreamFromClassPathOrFile(filePath);
try {
properties.load(input);
} catch (IOException e) {
throw new MnoConfigurationException("Could not load... | class class_name[name] begin[{]
method[loadProperties, return_type[type[Properties]], modifier[public static], parameter[filePath]] begin[{]
local_variable[type[Properties], properties]
local_variable[type[InputStream], input]
TryStatement(block=[StatementExpression(expression=MethodInv... | Keyword[public] Keyword[static] identifier[Properties] identifier[loadProperties] operator[SEP] identifier[String] identifier[filePath] operator[SEP] Keyword[throws] identifier[MnoConfigurationException] {
identifier[Properties] identifier[properties] operator[=] Keyword[new] identifier[Properties] operator[SEP]... |
@BetaApi(
"The surface for long-running operations is not stable yet and may change in the future.")
public final OperationFuture<Instance, CreateInstanceMetadata> createInstanceAsync(
CreateInstanceRequest request) {
return createInstanceOperationCallable().futureCall(request);
} | class class_name[name] begin[{]
method[createInstanceAsync, return_type[type[OperationFuture]], modifier[final public], parameter[request]] begin[{]
return[call[.createInstanceOperationCallable, parameter[]]]
end[}]
END[}] | annotation[@] identifier[BetaApi] operator[SEP] literal[String] operator[SEP] Keyword[public] Keyword[final] identifier[OperationFuture] operator[<] identifier[Instance] , identifier[CreateInstanceMetadata] operator[>] identifier[createInstanceAsync] operator[SEP] identifier[CreateInstanceRequest] identifier[request] ... |
public static Block fromFieldBlocks(int positionCount, Optional<boolean[]> rowIsNull, Block[] fieldBlocks)
{
int[] fieldBlockOffsets = new int[positionCount + 1];
for (int position = 0; position < positionCount; position++) {
fieldBlockOffsets[position + 1] = fieldBlockOffsets[position] ... | class class_name[name] begin[{]
method[fromFieldBlocks, return_type[type[Block]], modifier[public static], parameter[positionCount, rowIsNull, fieldBlocks]] begin[{]
local_variable[type[int], fieldBlockOffsets]
ForStatement(body=BlockStatement(label=None, statements=[StatementExpression(express... | Keyword[public] Keyword[static] identifier[Block] identifier[fromFieldBlocks] operator[SEP] Keyword[int] identifier[positionCount] , identifier[Optional] operator[<] Keyword[boolean] operator[SEP] operator[SEP] operator[>] identifier[rowIsNull] , identifier[Block] operator[SEP] operator[SEP] identifier[fieldBlocks] o... |
public static <T> T max( T[] array, String sortBy ) {
if ( array.length > 1 ) {
Sorting.sortDesc(array, sortBy);
return array[0];
} else {
return null;
}
} | class class_name[name] begin[{]
method[max, return_type[type[T]], modifier[public static], parameter[array, sortBy]] begin[{]
if[binary_operation[member[array.length], >, literal[1]]] begin[{]
call[Sorting.sortDesc, parameter[member[.array], member[.sortBy]]]
... | Keyword[public] Keyword[static] operator[<] identifier[T] operator[>] identifier[T] identifier[max] operator[SEP] identifier[T] operator[SEP] operator[SEP] identifier[array] , identifier[String] identifier[sortBy] operator[SEP] {
Keyword[if] operator[SEP] identifier[array] operator[SEP] identifier[length] opera... |
static void pingNode(final Node node, final HttpServerExchange exchange, final PingCallback callback) {
if (node == null) {
callback.failed();
return;
}
final int timeout = node.getNodeConfig().getPing();
exchange.dispatch(exchange.isInIoThread() ? SameThreadExec... | class class_name[name] begin[{]
method[pingNode, return_type[void], modifier[static], parameter[node, exchange, callback]] begin[{]
if[binary_operation[member[.node], ==, literal[null]]] begin[{]
call[callback.failed, parameter[]]
return[None]
else be... | Keyword[static] Keyword[void] identifier[pingNode] operator[SEP] Keyword[final] identifier[Node] identifier[node] , Keyword[final] identifier[HttpServerExchange] identifier[exchange] , Keyword[final] identifier[PingCallback] identifier[callback] operator[SEP] {
Keyword[if] operator[SEP] identifier[node] operat... |
@Override
public void clearCache() {
entityCache.clearCache(CPRuleUserSegmentRelImpl.class);
finderCache.clearCache(FINDER_CLASS_NAME_ENTITY);
finderCache.clearCache(FINDER_CLASS_NAME_LIST_WITH_PAGINATION);
finderCache.clearCache(FINDER_CLASS_NAME_LIST_WITHOUT_PAGINATION);
} | class class_name[name] begin[{]
method[clearCache, return_type[void], modifier[public], parameter[]] begin[{]
call[entityCache.clearCache, parameter[ClassReference(postfix_operators=[], prefix_operators=[], qualifier=, selectors=[], type=ReferenceType(arguments=None, dimensions=None, name=CPRul... | annotation[@] identifier[Override] Keyword[public] Keyword[void] identifier[clearCache] operator[SEP] operator[SEP] {
identifier[entityCache] operator[SEP] identifier[clearCache] operator[SEP] identifier[CPRuleUserSegmentRelImpl] operator[SEP] Keyword[class] operator[SEP] operator[SEP] identifier[finderCache] op... |
public boolean hasAbsentKeysOrValues() {
for (Entry<String, KeyValue<K, V>> entry : underlyingMap.entrySet()) {
if (keyOrValueIsAbsent(entry)) {
return true;
}
}
return false;
} | class class_name[name] begin[{]
method[hasAbsentKeysOrValues, return_type[type[boolean]], modifier[public], parameter[]] begin[{]
ForStatement(body=BlockStatement(label=None, statements=[IfStatement(condition=MethodInvocation(arguments=[MemberReference(member=entry, postfix_operators=[], prefix_operato... | Keyword[public] Keyword[boolean] identifier[hasAbsentKeysOrValues] operator[SEP] operator[SEP] {
Keyword[for] operator[SEP] identifier[Entry] operator[<] identifier[String] , identifier[KeyValue] operator[<] identifier[K] , identifier[V] operator[>] operator[>] identifier[entry] operator[:] identifier[underly... |
private JsDocToken parseIdGeneratorTag(JsDocToken token) {
String idgenKind = "unique";
if (token == JsDocToken.LEFT_CURLY) {
if (match(JsDocToken.STRING)) {
String name = stream.getString();
if (!idGeneratorAnnotationKeywords.contains(name)
&& !jsdocBuilder.hasParameter(name))... | class class_name[name] begin[{]
method[parseIdGeneratorTag, return_type[type[JsDocToken]], modifier[private], parameter[token]] begin[{]
local_variable[type[String], idgenKind]
if[binary_operation[member[.token], ==, member[JsDocToken.LEFT_CURLY]]] begin[{]
if[ca... | Keyword[private] identifier[JsDocToken] identifier[parseIdGeneratorTag] operator[SEP] identifier[JsDocToken] identifier[token] operator[SEP] {
identifier[String] identifier[idgenKind] operator[=] literal[String] operator[SEP] Keyword[if] operator[SEP] identifier[token] operator[==] identifier[JsDocToken] operato... |
public String contents()
{
StringBuffer buf = new StringBuffer();
synchronized(buf)
{
for (int i=0; i <elements.size() ; i++)
{
Object element = elements.get(i);
if (element==null)
buf.append("null");
... | class class_name[name] begin[{]
method[contents, return_type[type[String]], modifier[public], parameter[]] begin[{]
local_variable[type[StringBuffer], buf]
SYNCHRONIZED[member[.buf]] BEGIN[{]
ForStatement(body=BlockStatement(label=None, statements=[LocalVariableDeclaration(a... | Keyword[public] identifier[String] identifier[contents] operator[SEP] operator[SEP] {
identifier[StringBuffer] identifier[buf] operator[=] Keyword[new] identifier[StringBuffer] operator[SEP] operator[SEP] operator[SEP] Keyword[synchronized] operator[SEP] identifier[buf] operator[SEP] {
Keyword[for] op... |
public int compare(Object o1, Object o2) {
List list1 = (List) o1;
List list2 = (List) o2;
for (int i = 0; i < list1.size(); i++) {
if (list2.size() > i) {
Comparable component1 = (Comparable) list1.get(i);
Comparable component2 = (Comparable) list2.get(i);
int componentsCompared = compone... | class class_name[name] begin[{]
method[compare, return_type[type[int]], modifier[public], parameter[o1, o2]] begin[{]
local_variable[type[List], list1]
local_variable[type[List], list2]
ForStatement(body=BlockStatement(label=None, statements=[IfStatement(condition=BinaryOperation(operan... | Keyword[public] Keyword[int] identifier[compare] operator[SEP] identifier[Object] identifier[o1] , identifier[Object] identifier[o2] operator[SEP] {
identifier[List] identifier[list1] operator[=] operator[SEP] identifier[List] operator[SEP] identifier[o1] operator[SEP] identifier[List] identifier[list2] operato... |
public EClass getIfcAxis2Placement2D() {
if (ifcAxis2Placement2DEClass == null) {
ifcAxis2Placement2DEClass = (EClass) EPackage.Registry.INSTANCE.getEPackage(Ifc2x3tc1Package.eNS_URI)
.getEClassifiers().get(34);
}
return ifcAxis2Placement2DEClass;
} | class class_name[name] begin[{]
method[getIfcAxis2Placement2D, return_type[type[EClass]], modifier[public], parameter[]] begin[{]
if[binary_operation[member[.ifcAxis2Placement2DEClass], ==, literal[null]]] begin[{]
assign[member[.ifcAxis2Placement2DEClass], Cast(expressi... | Keyword[public] identifier[EClass] identifier[getIfcAxis2Placement2D] operator[SEP] operator[SEP] {
Keyword[if] operator[SEP] identifier[ifcAxis2Placement2DEClass] operator[==] Other[null] operator[SEP] {
identifier[ifcAxis2Placement2DEClass] operator[=] operator[SEP] identifier[EClass] operator[SEP] ... |
public boolean isQuery(final String sql) {
for (final Pattern p : queryDetection) {
if (p.matcher(sql).lookingAt()) {
return true;
} // end of if
} // end of for
return false;
} | class class_name[name] begin[{]
method[isQuery, return_type[type[boolean]], modifier[public], parameter[sql]] begin[{]
ForStatement(body=BlockStatement(label=None, statements=[IfStatement(condition=MethodInvocation(arguments=[MemberReference(member=sql, postfix_operators=[], prefix_operators=[], qualif... | Keyword[public] Keyword[boolean] identifier[isQuery] operator[SEP] Keyword[final] identifier[String] identifier[sql] operator[SEP] {
Keyword[for] operator[SEP] Keyword[final] identifier[Pattern] identifier[p] operator[:] identifier[queryDetection] operator[SEP] {
Keyword[if] operator[SEP] identifier[... |
private void processIgnorePropertiesAnnotation(IgnoreProperties properties,
Map<Class<?>, Collection<String>> pojoAndNamesMap) {
IgnoreProperty[] values = properties.value();
AllowProperty[] allowProperties = properties.allow();
if (allowPrope... | class class_name[name] begin[{]
method[processIgnorePropertiesAnnotation, return_type[void], modifier[private], parameter[properties, pojoAndNamesMap]] begin[{]
local_variable[type[IgnoreProperty], values]
local_variable[type[AllowProperty], allowProperties]
if[binary_operation[... | Keyword[private] Keyword[void] identifier[processIgnorePropertiesAnnotation] operator[SEP] identifier[IgnoreProperties] identifier[properties] , identifier[Map] operator[<] identifier[Class] operator[<] operator[?] operator[>] , identifier[Collection] operator[<] identifier[String] operator[>] operator[>] identifier[... |
@Override
public EEnum getIfcObjectiveEnum() {
if (ifcObjectiveEnumEEnum == null) {
ifcObjectiveEnumEEnum = (EEnum) EPackage.Registry.INSTANCE.getEPackage(Ifc4Package.eNS_URI)
.getEClassifiers().get(1022);
}
return ifcObjectiveEnumEEnum;
} | class class_name[name] begin[{]
method[getIfcObjectiveEnum, return_type[type[EEnum]], modifier[public], parameter[]] begin[{]
if[binary_operation[member[.ifcObjectiveEnumEEnum], ==, literal[null]]] begin[{]
assign[member[.ifcObjectiveEnumEEnum], Cast(expression=MethodInv... | annotation[@] identifier[Override] Keyword[public] identifier[EEnum] identifier[getIfcObjectiveEnum] operator[SEP] operator[SEP] {
Keyword[if] operator[SEP] identifier[ifcObjectiveEnumEEnum] operator[==] Other[null] operator[SEP] {
identifier[ifcObjectiveEnumEEnum] operator[=] operator[SEP] identifier... |
public synchronized void start() throws SocketException {
if (!isRunning()) {
socket.set(new DatagramSocket(ANNOUNCEMENT_PORT));
startTime.set(System.currentTimeMillis());
deliverLifecycleAnnouncement(logger, true);
final byte[] buffer = new byte[512];
... | class class_name[name] begin[{]
method[start, return_type[void], modifier[synchronized public], parameter[]] begin[{]
if[call[.isRunning, parameter[]]] begin[{]
call[socket.set, parameter[ClassCreator(arguments=[MemberReference(member=ANNOUNCEMENT_PORT, postfix_operators... | Keyword[public] Keyword[synchronized] Keyword[void] identifier[start] operator[SEP] operator[SEP] Keyword[throws] identifier[SocketException] {
Keyword[if] operator[SEP] operator[!] identifier[isRunning] operator[SEP] operator[SEP] operator[SEP] {
identifier[socket] operator[SEP] identifier[set] opera... |
public static <T> Map<ByteBuffer, List<T>> transformThriftResult(ColumnFamilyType columnFamilyType,
List<KeySlice> keySlices, ThriftRow row)
{
Map<ByteBuffer, List<T>> output = new HashMap<ByteBuffer, List<T>>();
for (KeySlice keySlice : keySlices)
{
output.put(Byte... | class class_name[name] begin[{]
method[transformThriftResult, return_type[type[Map]], modifier[public static], parameter[columnFamilyType, keySlices, row]] begin[{]
local_variable[type[Map], output]
ForStatement(body=BlockStatement(label=None, statements=[StatementExpression(expression=MethodIn... | Keyword[public] Keyword[static] operator[<] identifier[T] operator[>] identifier[Map] operator[<] identifier[ByteBuffer] , identifier[List] operator[<] identifier[T] operator[>] operator[>] identifier[transformThriftResult] operator[SEP] identifier[ColumnFamilyType] identifier[columnFamilyType] , identifier[List] ope... |
@SuppressWarnings("checkstyle:all")
protected StringConcatenationClient generateFieldsAndMethods(boolean forInterface, boolean forAppender) {
TypeReference scriptInterface = getCodeElementExtractor().getLanguageScriptInterface();
return new StringConcatenationClient() {
@Override
protected void appendTo(Targ... | class class_name[name] begin[{]
method[generateFieldsAndMethods, return_type[type[StringConcatenationClient]], modifier[protected], parameter[forInterface, forAppender]] begin[{]
local_variable[type[TypeReference], scriptInterface]
return[ClassCreator(arguments=[], body=[MethodDeclaration(annot... | annotation[@] identifier[SuppressWarnings] operator[SEP] literal[String] operator[SEP] Keyword[protected] identifier[StringConcatenationClient] identifier[generateFieldsAndMethods] operator[SEP] Keyword[boolean] identifier[forInterface] , Keyword[boolean] identifier[forAppender] operator[SEP] {
identifier[TypeR... |
protected void appendAndPush(
StylesheetHandler handler, ElemTemplateElement elem)
throws org.xml.sax.SAXException
{
super.appendAndPush(handler, elem);
elem.setDOMBackPointer(handler.getOriginatingNode());
handler.getStylesheet().setTemplate((ElemTemplate) elem);
} | class class_name[name] begin[{]
method[appendAndPush, return_type[void], modifier[protected], parameter[handler, elem]] begin[{]
SuperMethodInvocation(arguments=[MemberReference(member=handler, postfix_operators=[], prefix_operators=[], qualifier=, selectors=[]), MemberReference(member=elem, po... | Keyword[protected] Keyword[void] identifier[appendAndPush] operator[SEP] identifier[StylesheetHandler] identifier[handler] , identifier[ElemTemplateElement] identifier[elem] operator[SEP] Keyword[throws] identifier[org] operator[SEP] identifier[xml] operator[SEP] identifier[sax] operator[SEP] identifier[SAXException] ... |
public static DbPipe toDbPipe(String pipeName, final String[] array) throws DevFailed {
DbPipe dbPipe = new DbPipe(pipeName);
try {
int index = 3;
final int nbProperties = Integer.parseInt(array[index++]);
for (int i=0 ; i<nbProperties ; i++) {
String ... | class class_name[name] begin[{]
method[toDbPipe, return_type[type[DbPipe]], modifier[public static], parameter[pipeName, array]] begin[{]
local_variable[type[DbPipe], dbPipe]
TryStatement(block=[LocalVariableDeclaration(annotations=[], declarators=[VariableDeclarator(dimensions=[], initializer=... | Keyword[public] Keyword[static] identifier[DbPipe] identifier[toDbPipe] operator[SEP] identifier[String] identifier[pipeName] , Keyword[final] identifier[String] operator[SEP] operator[SEP] identifier[array] operator[SEP] Keyword[throws] identifier[DevFailed] {
identifier[DbPipe] identifier[dbPipe] operator[=] ... |
public static FieldPath of(@Nonnull String... fieldNames) {
Preconditions.checkArgument(
fieldNames.length > 0, "Invalid field path. Provided path must not be empty.");
for (int i = 0; i < fieldNames.length; ++i) {
Preconditions.checkArgument(
fieldNames[i] != null && !fieldNames[i].isE... | class class_name[name] begin[{]
method[of, return_type[type[FieldPath]], modifier[public static], parameter[fieldNames]] begin[{]
call[Preconditions.checkArgument, parameter[binary_operation[member[fieldNames.length], >, literal[0]], literal["Invalid field path. Provided path must not be empty.... | Keyword[public] Keyword[static] identifier[FieldPath] identifier[of] operator[SEP] annotation[@] identifier[Nonnull] identifier[String] operator[...] identifier[fieldNames] operator[SEP] {
identifier[Preconditions] operator[SEP] identifier[checkArgument] operator[SEP] identifier[fieldNames] operator[SEP] identif... |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.