code stringlengths 63 466k | code_sememe stringlengths 141 3.79M | token_type stringlengths 274 1.23M |
|---|---|---|
protected String getLabel(ArgumentComponent argumentComponent, Token token)
{
StringBuilder sb = new StringBuilder(argumentComponent.getClass().getSimpleName());
if ("BIO".equals(this.codingGranularity)) {
// Does the component begin here?
if (argumentComponent.getBegin() ==... | class class_name[name] begin[{]
method[getLabel, return_type[type[String]], modifier[protected], parameter[argumentComponent, token]] begin[{]
local_variable[type[StringBuilder], sb]
if[literal["BIO"]] begin[{]
if[binary_operation[call[argumentComponent.getBegin,... | Keyword[protected] identifier[String] identifier[getLabel] operator[SEP] identifier[ArgumentComponent] identifier[argumentComponent] , identifier[Token] identifier[token] operator[SEP] {
identifier[StringBuilder] identifier[sb] operator[=] Keyword[new] identifier[StringBuilder] operator[SEP] identifier[argument... |
private boolean symmetryBreakingForStayingVMs(ReconfigurationProblem rp) {
for (VM vm : rp.getFutureRunningVMs()) {
VMTransition a = rp.getVMAction(vm);
Slice dSlice = a.getDSlice();
Slice cSlice = a.getCSlice();
if (dSlice != null && cSlice != null) {
... | class class_name[name] begin[{]
method[symmetryBreakingForStayingVMs, return_type[type[boolean]], modifier[private], parameter[rp]] begin[{]
ForStatement(body=BlockStatement(label=None, statements=[LocalVariableDeclaration(annotations=[], declarators=[VariableDeclarator(dimensions=[], initializer=Metho... | Keyword[private] Keyword[boolean] identifier[symmetryBreakingForStayingVMs] operator[SEP] identifier[ReconfigurationProblem] identifier[rp] operator[SEP] {
Keyword[for] operator[SEP] identifier[VM] identifier[vm] operator[:] identifier[rp] operator[SEP] identifier[getFutureRunningVMs] operator[SEP] operator[SEP... |
public static void setBytes(long address, byte[] buffer, int bufferOffset, int count)
{
assert buffer != null;
assert !(bufferOffset < 0 || count < 0 || bufferOffset + count > buffer.length);
setBytes(buffer, bufferOffset, address, count);
} | class class_name[name] begin[{]
method[setBytes, return_type[void], modifier[public static], parameter[address, buffer, bufferOffset, count]] begin[{]
AssertStatement(condition=BinaryOperation(operandl=MemberReference(member=buffer, postfix_operators=[], prefix_operators=[], qualifier=, selectors=[]), ... | Keyword[public] Keyword[static] Keyword[void] identifier[setBytes] operator[SEP] Keyword[long] identifier[address] , Keyword[byte] operator[SEP] operator[SEP] identifier[buffer] , Keyword[int] identifier[bufferOffset] , Keyword[int] identifier[count] operator[SEP] {
Keyword[assert] identifier[buffer] operator... |
private ListenableFuture<TaskStatus> attachCallbacks(final Task task, final ListenableFuture<TaskStatus> statusFuture)
{
final ServiceMetricEvent.Builder metricBuilder = new ServiceMetricEvent.Builder();
IndexTaskUtils.setTaskDimensions(metricBuilder, task);
Futures.addCallback(
statusFuture,
... | class class_name[name] begin[{]
method[attachCallbacks, return_type[type[ListenableFuture]], modifier[private], parameter[task, statusFuture]] begin[{]
local_variable[type[ServiceMetricEvent], metricBuilder]
call[IndexTaskUtils.setTaskDimensions, parameter[member[.metricBuilder], member... | Keyword[private] identifier[ListenableFuture] operator[<] identifier[TaskStatus] operator[>] identifier[attachCallbacks] operator[SEP] Keyword[final] identifier[Task] identifier[task] , Keyword[final] identifier[ListenableFuture] operator[<] identifier[TaskStatus] operator[>] identifier[statusFuture] operator[SEP] {
... |
public static InsertType detectInsertType(SQLiteModelMethod method) {
SQLiteDaoDefinition daoDefinition = method.getParent();
SQLiteEntity entity = method.getEntity();
TypeName beanTypeName = typeName(entity.getElement());
InsertType insertResultType = null;
// check type of arguments
int beanCounter = 0;... | class class_name[name] begin[{]
method[detectInsertType, return_type[type[InsertType]], modifier[public static], parameter[method]] begin[{]
local_variable[type[SQLiteDaoDefinition], daoDefinition]
local_variable[type[SQLiteEntity], entity]
local_variable[type[TypeName], beanTypeName]
... | Keyword[public] Keyword[static] identifier[InsertType] identifier[detectInsertType] operator[SEP] identifier[SQLiteModelMethod] identifier[method] operator[SEP] {
identifier[SQLiteDaoDefinition] identifier[daoDefinition] operator[=] identifier[method] operator[SEP] identifier[getParent] operator[SEP] operator[SE... |
public static Map<FastaSequence,float[]> getDisorderScores(List<FastaSequence> sequences) {
Map<FastaSequence,float[]> results = new TreeMap<FastaSequence, float[]>();
for(FastaSequence fsequence : sequences) {
results.put(fsequence, predictSerial(fsequence));
}
return results;
} | class class_name[name] begin[{]
method[getDisorderScores, return_type[type[Map]], modifier[public static], parameter[sequences]] begin[{]
local_variable[type[Map], results]
ForStatement(body=BlockStatement(label=None, statements=[StatementExpression(expression=MethodInvocation(arguments=[Member... | Keyword[public] Keyword[static] identifier[Map] operator[<] identifier[FastaSequence] , Keyword[float] operator[SEP] operator[SEP] operator[>] identifier[getDisorderScores] operator[SEP] identifier[List] operator[<] identifier[FastaSequence] operator[>] identifier[sequences] operator[SEP] {
identifier[Map] oper... |
@Action(
semantics = SemanticsOf.SAFE // obviously, a mistake
)
@ActionLayout(
describedAs = "'Mistakenly' annotated as being invoked with safe semantics, not annotated as a Command; should persist anyway"
)
public SomeCommandAnnotatedObject changeNameWithSafeSemantics(
... | class class_name[name] begin[{]
method[changeNameWithSafeSemantics, return_type[type[SomeCommandAnnotatedObject]], modifier[public], parameter[newName]] begin[{]
call[.setName, parameter[member[.newName]]]
return[THIS[]]
end[}]
END[}] | annotation[@] identifier[Action] operator[SEP] identifier[semantics] operator[=] identifier[SemanticsOf] operator[SEP] identifier[SAFE] operator[SEP] annotation[@] identifier[ActionLayout] operator[SEP] identifier[describedAs] operator[=] literal[String] operator[SEP] Keyword[public] identifier[SomeCommandAnnotatedObje... |
private int awaitWork(WorkQueue w) {
int stat = 0;
if (w != null && w.scanState < 0) {
long c = ctl;
if ((int)(c >> AC_SHIFT) + (config & SMASK) <= 0)
stat = timedAwaitWork(w, c); // possibly quiescent
else if ((runState & STOP) != 0)
... | class class_name[name] begin[{]
method[awaitWork, return_type[type[int]], modifier[private], parameter[w]] begin[{]
local_variable[type[int], stat]
if[binary_operation[binary_operation[member[.w], !=, literal[null]], &&, binary_operation[member[w.scanState], <, literal[0]]]] begin[{]
... | Keyword[private] Keyword[int] identifier[awaitWork] operator[SEP] identifier[WorkQueue] identifier[w] operator[SEP] {
Keyword[int] identifier[stat] operator[=] Other[0] operator[SEP] Keyword[if] operator[SEP] identifier[w] operator[!=] Other[null] operator[&&] identifier[w] operator[SEP] identifier[scanState] op... |
public static <U, T> StreamEx<T> ofPairs(U[] array, BiFunction<? super U, ? super U, ? extends T> mapper) {
return ofPairs(Arrays.asList(array), mapper);
} | class class_name[name] begin[{]
method[ofPairs, return_type[type[StreamEx]], modifier[public static], parameter[array, mapper]] begin[{]
return[call[.ofPairs, parameter[call[Arrays.asList, parameter[member[.array]]], member[.mapper]]]]
end[}]
END[}] | Keyword[public] Keyword[static] operator[<] identifier[U] , identifier[T] operator[>] identifier[StreamEx] operator[<] identifier[T] operator[>] identifier[ofPairs] operator[SEP] identifier[U] operator[SEP] operator[SEP] identifier[array] , identifier[BiFunction] operator[<] operator[?] Keyword[super] identifier[U] ,... |
public BeanDefinitionHolder decorateBeanDefinitionIfRequired(Element ele,
BeanDefinitionHolder definitionHolder) {
return decorateBeanDefinitionIfRequired(ele, definitionHolder, null);
} | class class_name[name] begin[{]
method[decorateBeanDefinitionIfRequired, return_type[type[BeanDefinitionHolder]], modifier[public], parameter[ele, definitionHolder]] begin[{]
return[call[.decorateBeanDefinitionIfRequired, parameter[member[.ele], member[.definitionHolder], literal[null]]]]
end[}]
EN... | Keyword[public] identifier[BeanDefinitionHolder] identifier[decorateBeanDefinitionIfRequired] operator[SEP] identifier[Element] identifier[ele] , identifier[BeanDefinitionHolder] identifier[definitionHolder] operator[SEP] {
Keyword[return] identifier[decorateBeanDefinitionIfRequired] operator[SEP] identifier[el... |
public Response findByIds(@NotNull @PathParam("ids") URI_ID id,
@NotNull @PathParam("ids") final PathSegment ids,
@QueryParam("include_deleted") final boolean includeDeleted) throws Exception {
final Query<MODEL> query = server.find(modelType);
... | class class_name[name] begin[{]
method[findByIds, return_type[type[Response]], modifier[public], parameter[id, ids, includeDeleted]] begin[{]
local_variable[type[Query], query]
local_variable[type[MODEL_ID], firstId]
local_variable[type[Set], idSet]
local_variable[type[Set], idC... | Keyword[public] identifier[Response] identifier[findByIds] operator[SEP] annotation[@] identifier[NotNull] annotation[@] identifier[PathParam] operator[SEP] literal[String] operator[SEP] identifier[URI_ID] identifier[id] , annotation[@] identifier[NotNull] annotation[@] identifier[PathParam] operator[SEP] literal[Stri... |
protected void loadPosition()
{
CSSDecoder dec = new CSSDecoder(ctx);
int contw = getContainingBlock().width;
int conth = getContainingBlock().height;
CSSProperty.Top ptop = style.getProperty("top");
CSSProperty.Right pright = style.getProperty("right");
CSS... | class class_name[name] begin[{]
method[loadPosition, return_type[void], modifier[protected], parameter[]] begin[{]
local_variable[type[CSSDecoder], dec]
local_variable[type[int], contw]
local_variable[type[int], conth]
local_variable[type[CSSProperty], ptop]
local_variab... | Keyword[protected] Keyword[void] identifier[loadPosition] operator[SEP] operator[SEP] {
identifier[CSSDecoder] identifier[dec] operator[=] Keyword[new] identifier[CSSDecoder] operator[SEP] identifier[ctx] operator[SEP] operator[SEP] Keyword[int] identifier[contw] operator[=] identifier[getContainingBlock] operat... |
private INDArray asMatrix(BytePointer bytes, long length) throws IOException {
PIXA pixa;
pixa = pixaReadMemMultipageTiff(bytes, length);
INDArray data;
INDArray currentD;
INDArrayIndex[] index = null;
switch (this.multiPageMode) {
case MINIBATCH:
... | class class_name[name] begin[{]
method[asMatrix, return_type[type[INDArray]], modifier[private], parameter[bytes, length]] begin[{]
local_variable[type[PIXA], pixa]
assign[member[.pixa], call[.pixaReadMemMultipageTiff, parameter[member[.bytes], member[.length]]]]
local_variable[... | Keyword[private] identifier[INDArray] identifier[asMatrix] operator[SEP] identifier[BytePointer] identifier[bytes] , Keyword[long] identifier[length] operator[SEP] Keyword[throws] identifier[IOException] {
identifier[PIXA] identifier[pixa] operator[SEP] identifier[pixa] operator[=] identifier[pixaReadMemMultipa... |
@Override
public ORecordIteratorCluster<REC> begin() {
browsedRecords = 0;
updateRangesOnLiveUpdate();
resetCurrentPosition();
currentRecord = readCurrentRecord(getRecord(), +1);
return this;
} | class class_name[name] begin[{]
method[begin, return_type[type[ORecordIteratorCluster]], modifier[public], parameter[]] begin[{]
assign[member[.browsedRecords], literal[0]]
call[.updateRangesOnLiveUpdate, parameter[]]
call[.resetCurrentPosition, parameter[]]
... | annotation[@] identifier[Override] Keyword[public] identifier[ORecordIteratorCluster] operator[<] identifier[REC] operator[>] identifier[begin] operator[SEP] operator[SEP] {
identifier[browsedRecords] operator[=] Other[0] operator[SEP] identifier[updateRangesOnLiveUpdate] operator[SEP] operator[SEP] operator[SEP... |
public static base_response add(nitro_service client, dnssoarec resource) throws Exception {
dnssoarec addresource = new dnssoarec();
addresource.domain = resource.domain;
addresource.originserver = resource.originserver;
addresource.contact = resource.contact;
addresource.serial = resource.serial;
addresou... | class class_name[name] begin[{]
method[add, return_type[type[base_response]], modifier[public static], parameter[client, resource]] begin[{]
local_variable[type[dnssoarec], addresource]
assign[member[addresource.domain], member[resource.domain]]
assign[member[addresource... | Keyword[public] Keyword[static] identifier[base_response] identifier[add] operator[SEP] identifier[nitro_service] identifier[client] , identifier[dnssoarec] identifier[resource] operator[SEP] Keyword[throws] identifier[Exception] {
identifier[dnssoarec] identifier[addresource] operator[=] Keyword[new] identifie... |
private String encode(Object value) {
return BaseEncoding.base16().encode(valueSerializer.encode(value));
} | class class_name[name] begin[{]
method[encode, return_type[type[String]], modifier[private], parameter[value]] begin[{]
return[call[BaseEncoding.base16, parameter[]]]
end[}]
END[}] | Keyword[private] identifier[String] identifier[encode] operator[SEP] identifier[Object] identifier[value] operator[SEP] {
Keyword[return] identifier[BaseEncoding] operator[SEP] identifier[base16] operator[SEP] operator[SEP] operator[SEP] identifier[encode] operator[SEP] identifier[valueSerializer] operator[SEP] ... |
public static void phase( ImageInterleaved transform , GrayF phase ) {
if( transform instanceof InterleavedF32 ) {
DiscreteFourierTransformOps.phase((InterleavedF32) transform, (GrayF32) phase);
} else if( transform instanceof InterleavedF64 ) {
DiscreteFourierTransformOps.phase((InterleavedF64) transform, (G... | class class_name[name] begin[{]
method[phase, return_type[void], modifier[public static], parameter[transform, phase]] begin[{]
if[binary_operation[member[.transform], instanceof, type[InterleavedF32]]] begin[{]
call[DiscreteFourierTransformOps.phase, parameter[Cast(expr... | Keyword[public] Keyword[static] Keyword[void] identifier[phase] operator[SEP] identifier[ImageInterleaved] identifier[transform] , identifier[GrayF] identifier[phase] operator[SEP] {
Keyword[if] operator[SEP] identifier[transform] Keyword[instanceof] identifier[InterleavedF32] operator[SEP] {
identif... |
public void parse(byte[] data) throws ParseException {
Text text = new Text();
text.strain(data, 0, data.length);
init(text);
} | class class_name[name] begin[{]
method[parse, return_type[void], modifier[public], parameter[data]] begin[{]
local_variable[type[Text], text]
call[text.strain, parameter[member[.data], literal[0], member[data.length]]]
call[.init, parameter[member[.text]]]
end[}]
END... | Keyword[public] Keyword[void] identifier[parse] operator[SEP] Keyword[byte] operator[SEP] operator[SEP] identifier[data] operator[SEP] Keyword[throws] identifier[ParseException] {
identifier[Text] identifier[text] operator[=] Keyword[new] identifier[Text] operator[SEP] operator[SEP] operator[SEP] identifier[text... |
public ManagedInstanceInner getByResourceGroup(String resourceGroupName, String managedInstanceName) {
return getByResourceGroupWithServiceResponseAsync(resourceGroupName, managedInstanceName).toBlocking().single().body();
} | class class_name[name] begin[{]
method[getByResourceGroup, return_type[type[ManagedInstanceInner]], modifier[public], parameter[resourceGroupName, managedInstanceName]] begin[{]
return[call[.getByResourceGroupWithServiceResponseAsync, parameter[member[.resourceGroupName], member[.managedInstanceName]]]... | Keyword[public] identifier[ManagedInstanceInner] identifier[getByResourceGroup] operator[SEP] identifier[String] identifier[resourceGroupName] , identifier[String] identifier[managedInstanceName] operator[SEP] {
Keyword[return] identifier[getByResourceGroupWithServiceResponseAsync] operator[SEP] identifier[reso... |
public static List<double[]> op(@javax.annotation.Nonnull final List<double[]> a, @javax.annotation.Nonnull final List<double[]> b, @javax.annotation.Nonnull final DoubleBinaryOperator fn) {
assert a.size() == b.size();
return IntStream.range(0, a.size()).parallel().mapToObj(i -> {
assert a.get(i).length ... | class class_name[name] begin[{]
method[op, return_type[type[List]], modifier[public static], parameter[a, b, fn]] begin[{]
AssertStatement(condition=BinaryOperation(operandl=MethodInvocation(arguments=[], member=size, postfix_operators=[], prefix_operators=[], qualifier=a, selectors=[], type_arguments=... | Keyword[public] Keyword[static] identifier[List] operator[<] Keyword[double] operator[SEP] operator[SEP] operator[>] identifier[op] operator[SEP] annotation[@] identifier[javax] operator[SEP] identifier[annotation] operator[SEP] identifier[Nonnull] Keyword[final] identifier[List] operator[<] Keyword[double] operator[SE... |
private static Optional<Class> resolveSingleTypeArgument(Type genericType) {
if (genericType instanceof ParameterizedType) {
ParameterizedType pt = (ParameterizedType) genericType;
Type[] actualTypeArguments = pt.getActualTypeArguments();
if (actualTypeArguments.length == 1) ... | class class_name[name] begin[{]
method[resolveSingleTypeArgument, return_type[type[Optional]], modifier[private static], parameter[genericType]] begin[{]
if[binary_operation[member[.genericType], instanceof, type[ParameterizedType]]] begin[{]
local_variable[type[ParameterizedType], ... | Keyword[private] Keyword[static] identifier[Optional] operator[<] identifier[Class] operator[>] identifier[resolveSingleTypeArgument] operator[SEP] identifier[Type] identifier[genericType] operator[SEP] {
Keyword[if] operator[SEP] identifier[genericType] Keyword[instanceof] identifier[ParameterizedType] operator... |
public WrappedByteBuffer putLongAt(int index, long v) {
_checkForWriteAt(index, 8);
_buf.putLong(index, v);
return this;
} | class class_name[name] begin[{]
method[putLongAt, return_type[type[WrappedByteBuffer]], modifier[public], parameter[index, v]] begin[{]
call[._checkForWriteAt, parameter[member[.index], literal[8]]]
call[_buf.putLong, parameter[member[.index], member[.v]]]
return[THIS[]]... | Keyword[public] identifier[WrappedByteBuffer] identifier[putLongAt] operator[SEP] Keyword[int] identifier[index] , Keyword[long] identifier[v] operator[SEP] {
identifier[_checkForWriteAt] operator[SEP] identifier[index] , Other[8] operator[SEP] operator[SEP] identifier[_buf] operator[SEP] identifier[putLong] o... |
@Nonnull
public static <T1, T2> LToFltBiFunctionBuilder<T1, T2> toFltBiFunction(Consumer<LToFltBiFunction<T1, T2>> consumer) {
return new LToFltBiFunctionBuilder(consumer);
} | class class_name[name] begin[{]
method[toFltBiFunction, return_type[type[LToFltBiFunctionBuilder]], modifier[public static], parameter[consumer]] begin[{]
return[ClassCreator(arguments=[MemberReference(member=consumer, postfix_operators=[], prefix_operators=[], qualifier=, selectors=[])], body=None, co... | annotation[@] identifier[Nonnull] Keyword[public] Keyword[static] operator[<] identifier[T1] , identifier[T2] operator[>] identifier[LToFltBiFunctionBuilder] operator[<] identifier[T1] , identifier[T2] operator[>] identifier[toFltBiFunction] operator[SEP] identifier[Consumer] operator[<] identifier[LToFltBiFunction] ... |
public static AOL getAOL(final MavenProject project, final String architecture, final String os, final Linker linker,
final String aol, final Log log) throws MojoFailureException, MojoExecutionException {
/*
To support a linker that is not the default linker specified in the aol.properties
* */
S... | class class_name[name] begin[{]
method[getAOL, return_type[type[AOL]], modifier[public static], parameter[project, architecture, os, linker, aol, log]] begin[{]
local_variable[type[String], aol_linker]
if[binary_operation[binary_operation[member[.linker], !=, literal[null]], &, binary_o... | Keyword[public] Keyword[static] identifier[AOL] identifier[getAOL] operator[SEP] Keyword[final] identifier[MavenProject] identifier[project] , Keyword[final] identifier[String] identifier[architecture] , Keyword[final] identifier[String] identifier[os] , Keyword[final] identifier[Linker] identifier[linker] , Keywor... |
public Observable<ServiceResponseWithHeaders<InputInner, InputsCreateOrReplaceHeaders>> createOrReplaceWithServiceResponseAsync(String resourceGroupName, String jobName, String inputName, InputInner input) {
if (this.client.subscriptionId() == null) {
throw new IllegalArgumentException("Parameter th... | class class_name[name] begin[{]
method[createOrReplaceWithServiceResponseAsync, return_type[type[Observable]], modifier[public], parameter[resourceGroupName, jobName, inputName, input]] begin[{]
if[binary_operation[THIS[member[None.client]call[None.subscriptionId, parameter[]]], ==, literal[nul... | Keyword[public] identifier[Observable] operator[<] identifier[ServiceResponseWithHeaders] operator[<] identifier[InputInner] , identifier[InputsCreateOrReplaceHeaders] operator[>] operator[>] identifier[createOrReplaceWithServiceResponseAsync] operator[SEP] identifier[String] identifier[resourceGroupName] , identifie... |
public String getPublicationString() {
byte[] imprint = publicationHash.getImprint();
byte[] data = new byte[imprint.length + 8];
System.arraycopy(Util.toByteArray(publicationTime.getTime() / 1000), 0, data, 0, 8);
System.arraycopy(imprint, 0, data, 8, imprint.length);
return Ba... | class class_name[name] begin[{]
method[getPublicationString, return_type[type[String]], modifier[public], parameter[]] begin[{]
local_variable[type[byte], imprint]
local_variable[type[byte], data]
call[System.arraycopy, parameter[call[Util.toByteArray, parameter[binary_operation... | Keyword[public] identifier[String] identifier[getPublicationString] operator[SEP] operator[SEP] {
Keyword[byte] operator[SEP] operator[SEP] identifier[imprint] operator[=] identifier[publicationHash] operator[SEP] identifier[getImprint] operator[SEP] operator[SEP] operator[SEP] Keyword[byte] operator[SEP] operat... |
@Override
@SuppressWarnings("unchecked")
public <E> Matcher<E> getMatcher() {
Matcher<E> localMatcher = (Matcher<E>) MatcherHolder.get();
Assert.state(localMatcher != null || matcher != null,
"A reference to a Matcher used by this Searcher ({0}) for searching and matching elements in the collection w... | class class_name[name] begin[{]
method[getMatcher, return_type[type[Matcher]], modifier[public], parameter[]] begin[{]
local_variable[type[Matcher], localMatcher]
call[Assert.state, parameter[binary_operation[binary_operation[member[.localMatcher], !=, literal[null]], ||, binary_operati... | annotation[@] identifier[Override] annotation[@] identifier[SuppressWarnings] operator[SEP] literal[String] operator[SEP] Keyword[public] operator[<] identifier[E] operator[>] identifier[Matcher] operator[<] identifier[E] operator[>] identifier[getMatcher] operator[SEP] operator[SEP] {
identifier[Matcher] operat... |
@Override
public CompressionInputStream createInputStream(InputStream in,
Decompressor decompressor) throws IOException {
if (!isNativeSnappyLoaded(conf)) {
throw new RuntimeException("native snappy library not available");
}
return new BlockDecompressorStream(in, decompressor, conf.getInt(
... | class class_name[name] begin[{]
method[createInputStream, return_type[type[CompressionInputStream]], modifier[public], parameter[in, decompressor]] begin[{]
if[call[.isNativeSnappyLoaded, parameter[member[.conf]]]] begin[{]
ThrowStatement(expression=ClassCreator(arguments=[Literal(p... | annotation[@] identifier[Override] Keyword[public] identifier[CompressionInputStream] identifier[createInputStream] operator[SEP] identifier[InputStream] identifier[in] , identifier[Decompressor] identifier[decompressor] operator[SEP] Keyword[throws] identifier[IOException] {
Keyword[if] operator[SEP] operator[... |
public byte[] getDataBytes() throws IOException {
byte[] retVal = new byte[length];
synchronized (data) {
data.reset();
data.getBytes(retVal);
}
return retVal;
} | class class_name[name] begin[{]
method[getDataBytes, return_type[type[byte]], modifier[public], parameter[]] begin[{]
local_variable[type[byte], retVal]
SYNCHRONIZED[member[.data]] BEGIN[{]
call[data.reset, parameter[]]
call[data.getBytes,... | Keyword[public] Keyword[byte] operator[SEP] operator[SEP] identifier[getDataBytes] operator[SEP] operator[SEP] Keyword[throws] identifier[IOException] {
Keyword[byte] operator[SEP] operator[SEP] identifier[retVal] operator[=] Keyword[new] Keyword[byte] operator[SEP] identifier[length] operator[SEP] operator[SEP]... |
public static List<DeltaError> applyDelta(Object source, List<Delta> commands, final ID idFetcher, DeltaProcessor deltaProcessor, boolean ... failFast)
{
// Index all objects in source graph
final Map srcMap = new HashMap();
Traverser.traverse(source, new Traverser.Visitor()
{
... | class class_name[name] begin[{]
method[applyDelta, return_type[type[List]], modifier[public static], parameter[source, commands, idFetcher, deltaProcessor, failFast]] begin[{]
local_variable[type[Map], srcMap]
call[Traverser.traverse, parameter[member[.source], ClassCreator(arguments=[]... | Keyword[public] Keyword[static] identifier[List] operator[<] identifier[DeltaError] operator[>] identifier[applyDelta] operator[SEP] identifier[Object] identifier[source] , identifier[List] operator[<] identifier[Delta] operator[>] identifier[commands] , Keyword[final] identifier[ID] identifier[idFetcher] , identifi... |
public Observable<AvailableProvidersListInner> listAvailableProvidersAsync(String resourceGroupName, String networkWatcherName, AvailableProvidersListParameters parameters) {
return listAvailableProvidersWithServiceResponseAsync(resourceGroupName, networkWatcherName, parameters).map(new Func1<ServiceResponse<Av... | class class_name[name] begin[{]
method[listAvailableProvidersAsync, return_type[type[Observable]], modifier[public], parameter[resourceGroupName, networkWatcherName, parameters]] begin[{]
return[call[.listAvailableProvidersWithServiceResponseAsync, parameter[member[.resourceGroupName], member[.networkW... | Keyword[public] identifier[Observable] operator[<] identifier[AvailableProvidersListInner] operator[>] identifier[listAvailableProvidersAsync] operator[SEP] identifier[String] identifier[resourceGroupName] , identifier[String] identifier[networkWatcherName] , identifier[AvailableProvidersListParameters] identifier[pa... |
public static boolean isListedAsParametrisation(JClass classToCheck, JType type) {
return type instanceof JClass && ((JClass) type).getTypeParameters().contains(classToCheck);
} | class class_name[name] begin[{]
method[isListedAsParametrisation, return_type[type[boolean]], modifier[public static], parameter[classToCheck, type]] begin[{]
return[binary_operation[binary_operation[member[.type], instanceof, type[JClass]], &&, Cast(expression=MemberReference(member=type, postfix_oper... | Keyword[public] Keyword[static] Keyword[boolean] identifier[isListedAsParametrisation] operator[SEP] identifier[JClass] identifier[classToCheck] , identifier[JType] identifier[type] operator[SEP] {
Keyword[return] identifier[type] Keyword[instanceof] identifier[JClass] operator[&&] operator[SEP] operator[SEP] i... |
public boolean checkError() {
if (out != null)
flush();
if (out instanceof java.io.PrintStream) {
PrintStream ps = (PrintStream) out;
return ps.checkError();
}
return trouble;
} | class class_name[name] begin[{]
method[checkError, return_type[type[boolean]], modifier[public], parameter[]] begin[{]
if[binary_operation[member[.out], !=, literal[null]]] begin[{]
call[.flush, parameter[]]
else begin[{]
None
end[}]
if[binary_operati... | Keyword[public] Keyword[boolean] identifier[checkError] operator[SEP] operator[SEP] {
Keyword[if] operator[SEP] identifier[out] operator[!=] Other[null] operator[SEP] identifier[flush] operator[SEP] operator[SEP] operator[SEP] Keyword[if] operator[SEP] identifier[out] Keyword[instanceof] identifier[java] operato... |
private Map<String, Integer> getTargetColumnType(Connection conn, MappingConfig config) {
DbMapping dbMapping = config.getDbMapping();
String cacheKey = config.getDestination() + "." + dbMapping.getDatabase() + "." + dbMapping.getTable();
Map<String, Integer> columnType = columnsTypeCache.get(ca... | class class_name[name] begin[{]
method[getTargetColumnType, return_type[type[Map]], modifier[private], parameter[conn, config]] begin[{]
local_variable[type[DbMapping], dbMapping]
local_variable[type[String], cacheKey]
local_variable[type[Map], columnType]
if[binary_oper... | Keyword[private] identifier[Map] operator[<] identifier[String] , identifier[Integer] operator[>] identifier[getTargetColumnType] operator[SEP] identifier[Connection] identifier[conn] , identifier[MappingConfig] identifier[config] operator[SEP] {
identifier[DbMapping] identifier[dbMapping] operator[=] identifi... |
public <OUT> DataStreamSource<OUT> fromCollection(Collection<OUT> data) {
Preconditions.checkNotNull(data, "Collection must not be null");
if (data.isEmpty()) {
throw new IllegalArgumentException("Collection must not be empty");
}
OUT first = data.iterator().next();
if (first == null) {
throw new Illeg... | class class_name[name] begin[{]
method[fromCollection, return_type[type[DataStreamSource]], modifier[public], parameter[data]] begin[{]
call[Preconditions.checkNotNull, parameter[member[.data], literal["Collection must not be null"]]]
if[call[data.isEmpty, parameter[]]] begin[{]... | Keyword[public] operator[<] identifier[OUT] operator[>] identifier[DataStreamSource] operator[<] identifier[OUT] operator[>] identifier[fromCollection] operator[SEP] identifier[Collection] operator[<] identifier[OUT] operator[>] identifier[data] operator[SEP] {
identifier[Preconditions] operator[SEP] identifier[... |
public boolean replaceIn(final StrBuilder source) {
if (source == null) {
return false;
}
return substitute(source, 0, source.length());
} | class class_name[name] begin[{]
method[replaceIn, return_type[type[boolean]], modifier[public], parameter[source]] begin[{]
if[binary_operation[member[.source], ==, literal[null]]] begin[{]
return[literal[false]]
else begin[{]
None
end[}]
return[call[.substit... | Keyword[public] Keyword[boolean] identifier[replaceIn] operator[SEP] Keyword[final] identifier[StrBuilder] identifier[source] operator[SEP] {
Keyword[if] operator[SEP] identifier[source] operator[==] Other[null] operator[SEP] {
Keyword[return] literal[boolean] operator[SEP]
}
Keyword[ret... |
public static void putAt(DefaultTableModel self, int index, Object row) {
if (row == null) {
// adds an empty row
self.insertRow(index, (Object[]) null);
return;
}
self.insertRow(index, buildRowData(self, row));
} | class class_name[name] begin[{]
method[putAt, return_type[void], modifier[public static], parameter[self, index, row]] begin[{]
if[binary_operation[member[.row], ==, literal[null]]] begin[{]
call[self.insertRow, parameter[member[.index], Cast(expression=Literal(postfix_o... | Keyword[public] Keyword[static] Keyword[void] identifier[putAt] operator[SEP] identifier[DefaultTableModel] identifier[self] , Keyword[int] identifier[index] , identifier[Object] identifier[row] operator[SEP] {
Keyword[if] operator[SEP] identifier[row] operator[==] Other[null] operator[SEP] {
identi... |
public void eventProcessingFailed(FailureReason failureReason) {
raEntity.getResourceAdaptorObject().eventProcessingFailed(activityHandle, fireableEventType,
failureReason, address, receivableService, eventFlags,
failureReason);
} | class class_name[name] begin[{]
method[eventProcessingFailed, return_type[void], modifier[public], parameter[failureReason]] begin[{]
call[raEntity.getResourceAdaptorObject, parameter[]]
end[}]
END[}] | Keyword[public] Keyword[void] identifier[eventProcessingFailed] operator[SEP] identifier[FailureReason] identifier[failureReason] operator[SEP] {
identifier[raEntity] operator[SEP] identifier[getResourceAdaptorObject] operator[SEP] operator[SEP] operator[SEP] identifier[eventProcessingFailed] operator[SEP] ident... |
private int resolveFlats( int pitsCount ) {
int stillPitsCount;
currentPitsCount = pitsCount;
do {
if (pm.isCanceled()) {
return -1;
}
pitsCount = currentPitsCount;
currentPitsCount = 0;
for( int ip = 1; ip <= pitsCount... | class class_name[name] begin[{]
method[resolveFlats, return_type[type[int]], modifier[private], parameter[pitsCount]] begin[{]
local_variable[type[int], stillPitsCount]
assign[member[.currentPitsCount], member[.pitsCount]]
do[binary_operation[member[.currentPitsCount], <... | Keyword[private] Keyword[int] identifier[resolveFlats] operator[SEP] Keyword[int] identifier[pitsCount] operator[SEP] {
Keyword[int] identifier[stillPitsCount] operator[SEP] identifier[currentPitsCount] operator[=] identifier[pitsCount] operator[SEP] Keyword[do] {
Keyword[if] operator[SEP] identifier[... |
public void addRootPackageOf(final Class actionClass, final String mapping) {
addRootPackage(actionClass.getPackage().getName(), mapping);
} | class class_name[name] begin[{]
method[addRootPackageOf, return_type[void], modifier[public], parameter[actionClass, mapping]] begin[{]
call[.addRootPackage, parameter[call[actionClass.getPackage, parameter[]], member[.mapping]]]
end[}]
END[}] | Keyword[public] Keyword[void] identifier[addRootPackageOf] operator[SEP] Keyword[final] identifier[Class] identifier[actionClass] , Keyword[final] identifier[String] identifier[mapping] operator[SEP] {
identifier[addRootPackage] operator[SEP] identifier[actionClass] operator[SEP] identifier[getPackage] operator... |
public @Nonnull Iterable<JsonArray> arrays() {
final JsonArray parent=this;
return () -> {
final Iterator<JsonElement> iterator = parent.iterator();
return new Iterator<JsonArray>() {
@Override
public boolean hasNext() {
return... | class class_name[name] begin[{]
method[arrays, return_type[type[Iterable]], modifier[public], parameter[]] begin[{]
local_variable[type[JsonArray], parent]
return[LambdaExpression(body=[LocalVariableDeclaration(annotations=[], declarators=[VariableDeclarator(dimensions=[], initializer=MethodInv... | Keyword[public] annotation[@] identifier[Nonnull] identifier[Iterable] operator[<] identifier[JsonArray] operator[>] identifier[arrays] operator[SEP] operator[SEP] {
Keyword[final] identifier[JsonArray] identifier[parent] operator[=] Keyword[this] operator[SEP] Keyword[return] operator[SEP] operator[SEP] operato... |
@Override public JCTree visitVariable(VariableTree node, Void p) {
JCVariableDecl original = node instanceof JCVariableDecl ? (JCVariableDecl) node : null;
JCVariableDecl copy = (JCVariableDecl) super.visitVariable(node, p);
if (original == null) return copy;
copy.sym = original.sym;
if (copy.sym != null) cop... | class class_name[name] begin[{]
method[visitVariable, return_type[type[JCTree]], modifier[public], parameter[node, p]] begin[{]
local_variable[type[JCVariableDecl], original]
local_variable[type[JCVariableDecl], copy]
if[binary_operation[member[.original], ==, literal[null]]] be... | annotation[@] identifier[Override] Keyword[public] identifier[JCTree] identifier[visitVariable] operator[SEP] identifier[VariableTree] identifier[node] , identifier[Void] identifier[p] operator[SEP] {
identifier[JCVariableDecl] identifier[original] operator[=] identifier[node] Keyword[instanceof] identifier[JCV... |
public JsonLdModule configure(ConfigParam param, String value) {
Objects.requireNonNull(param);
configuration.set(param, value);
return this;
} | class class_name[name] begin[{]
method[configure, return_type[type[JsonLdModule]], modifier[public], parameter[param, value]] begin[{]
call[Objects.requireNonNull, parameter[member[.param]]]
call[configuration.set, parameter[member[.param], member[.value]]]
return[THIS[]... | Keyword[public] identifier[JsonLdModule] identifier[configure] operator[SEP] identifier[ConfigParam] identifier[param] , identifier[String] identifier[value] operator[SEP] {
identifier[Objects] operator[SEP] identifier[requireNonNull] operator[SEP] identifier[param] operator[SEP] operator[SEP] identifier[config... |
@Nullable
public ExpressionTreeElement addTreeElement(@Nonnull final ExpressionTreeElement element) {
assertNotEmptySlot();
assertNotNull("The element is null", element);
final int newElementPriority = element.getPriority();
ExpressionTreeElement result = this;
final ExpressionTreeElement paren... | class class_name[name] begin[{]
method[addTreeElement, return_type[type[ExpressionTreeElement]], modifier[public], parameter[element]] begin[{]
call[.assertNotEmptySlot, parameter[]]
call[.assertNotNull, parameter[literal["The element is null"], member[.element]]]
local_... | annotation[@] identifier[Nullable] Keyword[public] identifier[ExpressionTreeElement] identifier[addTreeElement] operator[SEP] annotation[@] identifier[Nonnull] Keyword[final] identifier[ExpressionTreeElement] identifier[element] operator[SEP] {
identifier[assertNotEmptySlot] operator[SEP] operator[SEP] operator[... |
public static <T> TypeSerializer<T> tryReadSerializer(DataInputView in, ClassLoader userCodeClassLoader) throws IOException {
return tryReadSerializer(in, userCodeClassLoader, false);
} | class class_name[name] begin[{]
method[tryReadSerializer, return_type[type[TypeSerializer]], modifier[public static], parameter[in, userCodeClassLoader]] begin[{]
return[call[.tryReadSerializer, parameter[member[.in], member[.userCodeClassLoader], literal[false]]]]
end[}]
END[}] | Keyword[public] Keyword[static] operator[<] identifier[T] operator[>] identifier[TypeSerializer] operator[<] identifier[T] operator[>] identifier[tryReadSerializer] operator[SEP] identifier[DataInputView] identifier[in] , identifier[ClassLoader] identifier[userCodeClassLoader] operator[SEP] Keyword[throws] identifier[... |
public static byte optByte(@Nullable Bundle bundle, @Nullable String key, byte fallback) {
if (bundle == null) {
return fallback;
}
return bundle.getByte(key, fallback);
} | class class_name[name] begin[{]
method[optByte, return_type[type[byte]], modifier[public static], parameter[bundle, key, fallback]] begin[{]
if[binary_operation[member[.bundle], ==, literal[null]]] begin[{]
return[member[.fallback]]
else begin[{]
None
end[}]
... | Keyword[public] Keyword[static] Keyword[byte] identifier[optByte] operator[SEP] annotation[@] identifier[Nullable] identifier[Bundle] identifier[bundle] , annotation[@] identifier[Nullable] identifier[String] identifier[key] , Keyword[byte] identifier[fallback] operator[SEP] {
Keyword[if] operator[SEP] identif... |
private void fetchAllOutstanding() {
// Start by retrieving our shared state within a synchronized block.
String[] blockIdsToFetch;
int numRetries;
RetryingBlockFetchListener myListener;
synchronized (this) {
blockIdsToFetch = outstandingBlocksIds.toArray(new String[outstandingBlocksIds.size()... | class class_name[name] begin[{]
method[fetchAllOutstanding, return_type[void], modifier[private], parameter[]] begin[{]
local_variable[type[String], blockIdsToFetch]
local_variable[type[int], numRetries]
local_variable[type[RetryingBlockFetchListener], myListener]
SYNCHR... | Keyword[private] Keyword[void] identifier[fetchAllOutstanding] operator[SEP] operator[SEP] {
identifier[String] operator[SEP] operator[SEP] identifier[blockIdsToFetch] operator[SEP] Keyword[int] identifier[numRetries] operator[SEP] identifier[RetryingBlockFetchListener] identifier[myListener] operator[SEP] Keywo... |
public void setType(String type)
throws JspException
{
_type = setRequiredValueAttribute(type, "type");
if (_type != null) {
if (!type.equals("number") && !type.equals("currency") && !type.equals("percent")) {
String s = Bundle.getString("Tags_NumberFormatWron... | class class_name[name] begin[{]
method[setType, return_type[void], modifier[public], parameter[type]] begin[{]
assign[member[._type], call[.setRequiredValueAttribute, parameter[member[.type], literal["type"]]]]
if[binary_operation[member[._type], !=, literal[null]]] begin[{]
... | Keyword[public] Keyword[void] identifier[setType] operator[SEP] identifier[String] identifier[type] operator[SEP] Keyword[throws] identifier[JspException] {
identifier[_type] operator[=] identifier[setRequiredValueAttribute] operator[SEP] identifier[type] , literal[String] operator[SEP] operator[SEP] Keyword[if... |
@Override
public void setDeploymentDatacenter(String value) {
super.setDeploymentDatacenter(value);
setValueInConfig(DEPLOYMENT_DATACENTER_PROPERTY, value);
setValueInConfig(ContextKey.datacenter.getKey(), value);
} | class class_name[name] begin[{]
method[setDeploymentDatacenter, return_type[void], modifier[public], parameter[value]] begin[{]
SuperMethodInvocation(arguments=[MemberReference(member=value, postfix_operators=[], prefix_operators=[], qualifier=, selectors=[])], member=setDeploymentDatacenter, p... | annotation[@] identifier[Override] Keyword[public] Keyword[void] identifier[setDeploymentDatacenter] operator[SEP] identifier[String] identifier[value] operator[SEP] {
Keyword[super] operator[SEP] identifier[setDeploymentDatacenter] operator[SEP] identifier[value] operator[SEP] operator[SEP] identifier[setValueI... |
public static HashingInputStream createHashingStream( String digestName,
InputStream inputStream ) throws NoSuchAlgorithmException {
MessageDigest digest = MessageDigest.getInstance(digestName);
return new HashingInputStream(digest, inputStream);... | class class_name[name] begin[{]
method[createHashingStream, return_type[type[HashingInputStream]], modifier[public static], parameter[digestName, inputStream]] begin[{]
local_variable[type[MessageDigest], digest]
return[ClassCreator(arguments=[MemberReference(member=digest, postfix_operators=[]... | Keyword[public] Keyword[static] identifier[HashingInputStream] identifier[createHashingStream] operator[SEP] identifier[String] identifier[digestName] , identifier[InputStream] identifier[inputStream] operator[SEP] Keyword[throws] identifier[NoSuchAlgorithmException] {
identifier[MessageDigest] identifier[diges... |
private static Mirror getMirror(FeatureProvider provider, Collision collision)
{
if (collision.hasMirror() && provider.hasFeature(Mirrorable.class))
{
return provider.getFeature(Mirrorable.class).getMirror();
}
return Mirror.NONE;
} | class class_name[name] begin[{]
method[getMirror, return_type[type[Mirror]], modifier[private static], parameter[provider, collision]] begin[{]
if[binary_operation[call[collision.hasMirror, parameter[]], &&, call[provider.hasFeature, parameter[ClassReference(postfix_operators=[], prefix_operato... | Keyword[private] Keyword[static] identifier[Mirror] identifier[getMirror] operator[SEP] identifier[FeatureProvider] identifier[provider] , identifier[Collision] identifier[collision] operator[SEP] {
Keyword[if] operator[SEP] identifier[collision] operator[SEP] identifier[hasMirror] operator[SEP] operator[SEP] o... |
public void newRound(Context context) {
this.context = context;
this.log = Log.instance(context);
clearRoundState();
} | class class_name[name] begin[{]
method[newRound, return_type[void], modifier[public], parameter[context]] begin[{]
assign[THIS[member[None.context]], member[.context]]
assign[THIS[member[None.log]], call[Log.instance, parameter[member[.context]]]]
call[.clearRoun... | Keyword[public] Keyword[void] identifier[newRound] operator[SEP] identifier[Context] identifier[context] operator[SEP] {
Keyword[this] operator[SEP] identifier[context] operator[=] identifier[context] operator[SEP] Keyword[this] operator[SEP] identifier[log] operator[=] identifier[Log] operator[SEP] identifier[i... |
public EClass getIfcColourOrFactor() {
if (ifcColourOrFactorEClass == null) {
ifcColourOrFactorEClass = (EClass) EPackage.Registry.INSTANCE.getEPackage(Ifc2x3tc1Package.eNS_URI)
.getEClassifiers().get(943);
}
return ifcColourOrFactorEClass;
} | class class_name[name] begin[{]
method[getIfcColourOrFactor, return_type[type[EClass]], modifier[public], parameter[]] begin[{]
if[binary_operation[member[.ifcColourOrFactorEClass], ==, literal[null]]] begin[{]
assign[member[.ifcColourOrFactorEClass], Cast(expression=Met... | Keyword[public] identifier[EClass] identifier[getIfcColourOrFactor] operator[SEP] operator[SEP] {
Keyword[if] operator[SEP] identifier[ifcColourOrFactorEClass] operator[==] Other[null] operator[SEP] {
identifier[ifcColourOrFactorEClass] operator[=] operator[SEP] identifier[EClass] operator[SEP] identi... |
public static void printCode(String code, String desc) {
System.out.println("--------------------------" + desc + " begin--------------------------");
System.out.println(code);
System.out.println("--------------------------" + desc + " end--------------------------");
} | class class_name[name] begin[{]
method[printCode, return_type[void], modifier[public static], parameter[code, desc]] begin[{]
call[System.out.println, parameter[binary_operation[binary_operation[literal["--------------------------"], +, member[.desc]], +, literal[" begin------------------------... | Keyword[public] Keyword[static] Keyword[void] identifier[printCode] operator[SEP] identifier[String] identifier[code] , identifier[String] identifier[desc] operator[SEP] {
identifier[System] operator[SEP] identifier[out] operator[SEP] identifier[println] operator[SEP] literal[String] operator[+] identifier[desc... |
public ApiResponse<ApiSuccessResponse> supervisorRemoteOperationWithHttpInfo(String operationName, String dbid) throws ApiException {
com.squareup.okhttp.Call call = supervisorRemoteOperationValidateBeforeCall(operationName, dbid, null, null);
Type localVarReturnType = new TypeToken<ApiSuccessResponse>(... | class class_name[name] begin[{]
method[supervisorRemoteOperationWithHttpInfo, return_type[type[ApiResponse]], modifier[public], parameter[operationName, dbid]] begin[{]
local_variable[type[com], call]
local_variable[type[Type], localVarReturnType]
return[call[apiClient.execute, paramete... | Keyword[public] identifier[ApiResponse] operator[<] identifier[ApiSuccessResponse] operator[>] identifier[supervisorRemoteOperationWithHttpInfo] operator[SEP] identifier[String] identifier[operationName] , identifier[String] identifier[dbid] operator[SEP] Keyword[throws] identifier[ApiException] {
identifier[co... |
public void setPeriod(ReadableInstant start, ReadableInstant end) {
if (start == end) {
setPeriod(0L);
} else {
long startMillis = DateTimeUtils.getInstantMillis(start);
long endMillis = DateTimeUtils.getInstantMillis(end);
Chronology chrono = DateTimeUtil... | class class_name[name] begin[{]
method[setPeriod, return_type[void], modifier[public], parameter[start, end]] begin[{]
if[binary_operation[member[.start], ==, member[.end]]] begin[{]
call[.setPeriod, parameter[literal[0L]]]
else begin[{]
local_variabl... | Keyword[public] Keyword[void] identifier[setPeriod] operator[SEP] identifier[ReadableInstant] identifier[start] , identifier[ReadableInstant] identifier[end] operator[SEP] {
Keyword[if] operator[SEP] identifier[start] operator[==] identifier[end] operator[SEP] {
identifier[setPeriod] operator[SEP] Ot... |
public LifecycleCallbackType<WebFragmentDescriptor> getOrCreatePostConstruct()
{
List<Node> nodeList = model.get("post-construct");
if (nodeList != null && nodeList.size() > 0)
{
return new LifecycleCallbackTypeImpl<WebFragmentDescriptor>(this, "post-construct", model, nodeList.get(0));
... | class class_name[name] begin[{]
method[getOrCreatePostConstruct, return_type[type[LifecycleCallbackType]], modifier[public], parameter[]] begin[{]
local_variable[type[List], nodeList]
if[binary_operation[binary_operation[member[.nodeList], !=, literal[null]], &&, binary_operation[call[n... | Keyword[public] identifier[LifecycleCallbackType] operator[<] identifier[WebFragmentDescriptor] operator[>] identifier[getOrCreatePostConstruct] operator[SEP] operator[SEP] {
identifier[List] operator[<] identifier[Node] operator[>] identifier[nodeList] operator[=] identifier[model] operator[SEP] identifier[get]... |
@Override
protected void processChildElement(XMLObject parentObject, XMLObject childObject) throws UnmarshallingException {
CurrentAddressStructuredType address = (CurrentAddressStructuredType) parentObject;
if (childObject instanceof PoBox) {
address.setPoBox(((PoBox) childObject).getValue());
}
... | class class_name[name] begin[{]
method[processChildElement, return_type[void], modifier[protected], parameter[parentObject, childObject]] begin[{]
local_variable[type[CurrentAddressStructuredType], address]
if[binary_operation[member[.childObject], instanceof, type[PoBox]]] begin[{]
... | annotation[@] identifier[Override] Keyword[protected] Keyword[void] identifier[processChildElement] operator[SEP] identifier[XMLObject] identifier[parentObject] , identifier[XMLObject] identifier[childObject] operator[SEP] Keyword[throws] identifier[UnmarshallingException] {
identifier[CurrentAddressStructuredT... |
public void deleteCookie(Cookie cookie) {
cookies.remove(cookie.name());
deletePersistedCookie(cookie.name());
} | class class_name[name] begin[{]
method[deleteCookie, return_type[void], modifier[public], parameter[cookie]] begin[{]
call[cookies.remove, parameter[call[cookie.name, parameter[]]]]
call[.deletePersistedCookie, parameter[call[cookie.name, parameter[]]]]
end[}]
END[}] | Keyword[public] Keyword[void] identifier[deleteCookie] operator[SEP] identifier[Cookie] identifier[cookie] operator[SEP] {
identifier[cookies] operator[SEP] identifier[remove] operator[SEP] identifier[cookie] operator[SEP] identifier[name] operator[SEP] operator[SEP] operator[SEP] operator[SEP] identifier[delete... |
public List<StepExecution> getStepThreadExecutionsRunning(PersistenceServiceUnit psu, final long jobExecutionId) {
final EntityManager em = psu.createEntityManager();
try {
List<StepExecution> exec = new TranRequest<List<StepExecution>>(em) {
@Override
publi... | class class_name[name] begin[{]
method[getStepThreadExecutionsRunning, return_type[type[List]], modifier[public], parameter[psu, jobExecutionId]] begin[{]
local_variable[type[EntityManager], em]
TryStatement(block=[LocalVariableDeclaration(annotations=[], declarators=[VariableDeclarator(dimensi... | Keyword[public] identifier[List] operator[<] identifier[StepExecution] operator[>] identifier[getStepThreadExecutionsRunning] operator[SEP] identifier[PersistenceServiceUnit] identifier[psu] , Keyword[final] Keyword[long] identifier[jobExecutionId] operator[SEP] {
Keyword[final] identifier[EntityManager] identi... |
public static final <T extends UIObject> void removeAnimationOnEnd(final T widget, final String animation) {
if (widget != null && animation != null) {
removeAnimationOnEnd(widget.getElement(), animation);
}
} | class class_name[name] begin[{]
method[removeAnimationOnEnd, return_type[void], modifier[final public static], parameter[widget, animation]] begin[{]
if[binary_operation[binary_operation[member[.widget], !=, literal[null]], &&, binary_operation[member[.animation], !=, literal[null]]]] begin[{]
... | Keyword[public] Keyword[static] Keyword[final] operator[<] identifier[T] Keyword[extends] identifier[UIObject] operator[>] Keyword[void] identifier[removeAnimationOnEnd] operator[SEP] Keyword[final] identifier[T] identifier[widget] , Keyword[final] identifier[String] identifier[animation] operator[SEP] {
Keywor... |
public int getShowYear() {
Calendar cal = Calendar.getInstance();
cal.setTime(getDate());
return cal.get(Calendar.YEAR);
} | class class_name[name] begin[{]
method[getShowYear, return_type[type[int]], modifier[public], parameter[]] begin[{]
local_variable[type[Calendar], cal]
call[cal.setTime, parameter[call[.getDate, parameter[]]]]
return[call[cal.get, parameter[member[Calendar.YEAR]]]]
end[}]
EN... | Keyword[public] Keyword[int] identifier[getShowYear] operator[SEP] operator[SEP] {
identifier[Calendar] identifier[cal] operator[=] identifier[Calendar] operator[SEP] identifier[getInstance] operator[SEP] operator[SEP] operator[SEP] identifier[cal] operator[SEP] identifier[setTime] operator[SEP] identifier[getDa... |
private static Set<String> getHopByHopHeaders(HttpSession session) {
List<String> connectionHeaders = session.getReadHeaders(HEADER_CONNECTION);
if (connectionHeaders == null) {
connectionHeaders = Collections.emptyList();
}
Set<String> hopByHopHeaders = new TreeSet<>(String.... | class class_name[name] begin[{]
method[getHopByHopHeaders, return_type[type[Set]], modifier[private static], parameter[session]] begin[{]
local_variable[type[List], connectionHeaders]
if[binary_operation[member[.connectionHeaders], ==, literal[null]]] begin[{]
as... | Keyword[private] Keyword[static] identifier[Set] operator[<] identifier[String] operator[>] identifier[getHopByHopHeaders] operator[SEP] identifier[HttpSession] identifier[session] operator[SEP] {
identifier[List] operator[<] identifier[String] operator[>] identifier[connectionHeaders] operator[=] identifier[ses... |
private void shrink() {
int oldCapacity = data.length;
if (oldCapacity == 1)
return;
E[] oldData = data;
int newCapacity = oldCapacity >> 1;
@SuppressWarnings("unchecked")
E[] newData = (E[]) new Object[newCapacity];
for (int i = 0; i < oldCapacity; i++) {
E e = oldData[i];
if (e != null)
Lin... | class class_name[name] begin[{]
method[shrink, return_type[void], modifier[private], parameter[]] begin[{]
local_variable[type[int], oldCapacity]
if[binary_operation[member[.oldCapacity], ==, literal[1]]] begin[{]
return[None]
else begin[{]
None
end[}]
local_vari... | Keyword[private] Keyword[void] identifier[shrink] operator[SEP] operator[SEP] {
Keyword[int] identifier[oldCapacity] operator[=] identifier[data] operator[SEP] identifier[length] operator[SEP] Keyword[if] operator[SEP] identifier[oldCapacity] operator[==] Other[1] operator[SEP] Keyword[return] operator[SEP] iden... |
public static AVUser signUpOrLoginByMobilePhone(String mobilePhoneNumber, String smsCode) {
return signUpOrLoginByMobilePhone(mobilePhoneNumber, smsCode, internalUserClazz());
} | class class_name[name] begin[{]
method[signUpOrLoginByMobilePhone, return_type[type[AVUser]], modifier[public static], parameter[mobilePhoneNumber, smsCode]] begin[{]
return[call[.signUpOrLoginByMobilePhone, parameter[member[.mobilePhoneNumber], member[.smsCode], call[.internalUserClazz, parameter[]]]]... | Keyword[public] Keyword[static] identifier[AVUser] identifier[signUpOrLoginByMobilePhone] operator[SEP] identifier[String] identifier[mobilePhoneNumber] , identifier[String] identifier[smsCode] operator[SEP] {
Keyword[return] identifier[signUpOrLoginByMobilePhone] operator[SEP] identifier[mobilePhoneNumber] , ... |
public synchronized void moveCursor(Cursor cursor)
{
if (tc.isEntryEnabled())
SibTr.entry(tc, "moveCursor", new Object[] { cursor });
checkEntryParent();
synchronized(parentList)
{
//make sure that the cursor is pointing to an entry in the same list
if(cursor != null && c... | class class_name[name] begin[{]
method[moveCursor, return_type[void], modifier[synchronized public], parameter[cursor]] begin[{]
if[call[tc.isEntryEnabled, parameter[]]] begin[{]
call[SibTr.entry, parameter[member[.tc], literal["moveCursor"], ArrayCreator(dimensions=[None], initiali... | Keyword[public] Keyword[synchronized] Keyword[void] identifier[moveCursor] operator[SEP] identifier[Cursor] identifier[cursor] operator[SEP] {
Keyword[if] operator[SEP] identifier[tc] operator[SEP] identifier[isEntryEnabled] operator[SEP] operator[SEP] operator[SEP] identifier[SibTr] operator[SEP] identifier[ent... |
private static HashSet<String> parseExcludeFilter(List<Filter> customFilters) {
HashSet<String> excludeKeys = new HashSet<String>();
if (CommonUtils.isNotEmpty(customFilters)) {
for (Filter filter : customFilters) {
if (filter instanceof ExcludeFilter) {
/... | class class_name[name] begin[{]
method[parseExcludeFilter, return_type[type[HashSet]], modifier[private static], parameter[customFilters]] begin[{]
local_variable[type[HashSet], excludeKeys]
if[call[CommonUtils.isNotEmpty, parameter[member[.customFilters]]]] begin[{]
ForStat... | Keyword[private] Keyword[static] identifier[HashSet] operator[<] identifier[String] operator[>] identifier[parseExcludeFilter] operator[SEP] identifier[List] operator[<] identifier[Filter] operator[>] identifier[customFilters] operator[SEP] {
identifier[HashSet] operator[<] identifier[String] operator[>] identif... |
public String encode(String text) {
Assert.notNull(text, "Text should not be null.");
text = text.toUpperCase();
final StringBuilder morseBuilder = new StringBuilder();
final int len = text.codePointCount(0, text.length());
for (int i = 0; i < len; i++) {
int codePoint = text.codePointAt(i);
... | class class_name[name] begin[{]
method[encode, return_type[type[String]], modifier[public], parameter[text]] begin[{]
call[Assert.notNull, parameter[member[.text], literal["Text should not be null."]]]
assign[member[.text], call[text.toUpperCase, parameter[]]]
local_vari... | Keyword[public] identifier[String] identifier[encode] operator[SEP] identifier[String] identifier[text] operator[SEP] {
identifier[Assert] operator[SEP] identifier[notNull] operator[SEP] identifier[text] , literal[String] operator[SEP] operator[SEP] identifier[text] operator[=] identifier[text] operator[SEP] id... |
public <T extends Pointer> T getHelperWorkspace(String key){
return helperWorkspacePointers == null ? null : (T)helperWorkspacePointers.get(key);
} | class class_name[name] begin[{]
method[getHelperWorkspace, return_type[type[T]], modifier[public], parameter[key]] begin[{]
return[TernaryExpression(condition=BinaryOperation(operandl=MemberReference(member=helperWorkspacePointers, postfix_operators=[], prefix_operators=[], qualifier=, selectors=[]), o... | Keyword[public] operator[<] identifier[T] Keyword[extends] identifier[Pointer] operator[>] identifier[T] identifier[getHelperWorkspace] operator[SEP] identifier[String] identifier[key] operator[SEP] {
Keyword[return] identifier[helperWorkspacePointers] operator[==] Other[null] operator[?] Other[null] operator[:]... |
public synchronized void setBlob(String parameterName,
Blob x) throws SQLException {
super.setBlob(findParameterIndex(parameterName), x);
} | class class_name[name] begin[{]
method[setBlob, return_type[void], modifier[synchronized public], parameter[parameterName, x]] begin[{]
SuperMethodInvocation(arguments=[MethodInvocation(arguments=[MemberReference(member=parameterName, postfix_operators=[], prefix_operators=[], qualifier=, selec... | Keyword[public] Keyword[synchronized] Keyword[void] identifier[setBlob] operator[SEP] identifier[String] identifier[parameterName] , identifier[Blob] identifier[x] operator[SEP] Keyword[throws] identifier[SQLException] {
Keyword[super] operator[SEP] identifier[setBlob] operator[SEP] identifier[findParameterInde... |
public int updateExpirationTime(Object id, long oldExpirationTime, int size, long newExpirationTime, long newValidatorExpirationTime) {
int returnCode = this.htod.updateExpirationTime(id, oldExpirationTime, size, newExpirationTime, newValidatorExpirationTime);
if (returnCode == HTODDynacache.DISK_EXCEPT... | class class_name[name] begin[{]
method[updateExpirationTime, return_type[type[int]], modifier[public], parameter[id, oldExpirationTime, size, newExpirationTime, newValidatorExpirationTime]] begin[{]
local_variable[type[int], returnCode]
if[binary_operation[member[.returnCode], ==, membe... | Keyword[public] Keyword[int] identifier[updateExpirationTime] operator[SEP] identifier[Object] identifier[id] , Keyword[long] identifier[oldExpirationTime] , Keyword[int] identifier[size] , Keyword[long] identifier[newExpirationTime] , Keyword[long] identifier[newValidatorExpirationTime] operator[SEP] {
Keyw... |
public Observable<Page<SyncMemberInner>> listBySyncGroupAsync(final String resourceGroupName, final String serverName, final String databaseName, final String syncGroupName) {
return listBySyncGroupWithServiceResponseAsync(resourceGroupName, serverName, databaseName, syncGroupName)
.map(new Func1<Se... | class class_name[name] begin[{]
method[listBySyncGroupAsync, return_type[type[Observable]], modifier[public], parameter[resourceGroupName, serverName, databaseName, syncGroupName]] begin[{]
return[call[.listBySyncGroupWithServiceResponseAsync, parameter[member[.resourceGroupName], member[.serverName], ... | Keyword[public] identifier[Observable] operator[<] identifier[Page] operator[<] identifier[SyncMemberInner] operator[>] operator[>] identifier[listBySyncGroupAsync] operator[SEP] Keyword[final] identifier[String] identifier[resourceGroupName] , Keyword[final] identifier[String] identifier[serverName] , Keyword[final]... |
public static Set<Currency> getAvailableCurrencies() {
Set<Currency> result = new LinkedHashSet<Currency>();
for (String currencyCode : availableCurrencyCodes) {
result.add(Currency.getInstance(currencyCode));
}
return result;
} | class class_name[name] begin[{]
method[getAvailableCurrencies, return_type[type[Set]], modifier[public static], parameter[]] begin[{]
local_variable[type[Set], result]
ForStatement(body=BlockStatement(label=None, statements=[StatementExpression(expression=MethodInvocation(arguments=[MethodInvoc... | Keyword[public] Keyword[static] identifier[Set] operator[<] identifier[Currency] operator[>] identifier[getAvailableCurrencies] operator[SEP] operator[SEP] {
identifier[Set] operator[<] identifier[Currency] operator[>] identifier[result] operator[=] Keyword[new] identifier[LinkedHashSet] operator[<] identifier[C... |
public QiniuBlockResponseData createBlockInQiniu(int blockSize, int firstChunkSize,
final byte[] firstChunkData, int retry) {
try {
String endPoint = String.format(QINIU_CREATE_BLOCK_EP, this.uploadUrl, blockSize);
Request.Builder builder = new Request... | class class_name[name] begin[{]
method[createBlockInQiniu, return_type[type[QiniuBlockResponseData]], modifier[public], parameter[blockSize, firstChunkSize, firstChunkData, retry]] begin[{]
TryStatement(block=[LocalVariableDeclaration(annotations=[], declarators=[VariableDeclarator(dimensions=[], initi... | Keyword[public] identifier[QiniuBlockResponseData] identifier[createBlockInQiniu] operator[SEP] Keyword[int] identifier[blockSize] , Keyword[int] identifier[firstChunkSize] , Keyword[final] Keyword[byte] operator[SEP] operator[SEP] identifier[firstChunkData] , Keyword[int] identifier[retry] operator[SEP] {
Ke... |
private static Field.Index getIndexParameter(int flags)
{
if ((flags & INDEXED_FLAG) == 0)
{
return Field.Index.NO;
}
else if ((flags & TOKENIZED_FLAG) > 0)
{
return Field.Index.ANALYZED;
}
else
{
return Field.Index.NOT_ANALYZED;
}
} | class class_name[name] begin[{]
method[getIndexParameter, return_type[type[Field]], modifier[private static], parameter[flags]] begin[{]
if[binary_operation[binary_operation[member[.flags], &, member[.INDEXED_FLAG]], ==, literal[0]]] begin[{]
return[member[Field.Index.NO]]
e... | Keyword[private] Keyword[static] identifier[Field] operator[SEP] identifier[Index] identifier[getIndexParameter] operator[SEP] Keyword[int] identifier[flags] operator[SEP] {
Keyword[if] operator[SEP] operator[SEP] identifier[flags] operator[&] identifier[INDEXED_FLAG] operator[SEP] operator[==] Other[0] operator... |
@Lorsque("Si '(.*)' vérifie '(.*)', je fais '(.*)' fois:")
@Then("If '(.*)' matches '(.*)', I do '(.*)' times:")
public void loop(String actual, String expected, int times, List<GherkinConditionedLoopedStep> steps) {
try {
if (new GherkinStepCondition("loopKey", expected, actual).checkCo... | class class_name[name] begin[{]
method[loop, return_type[void], modifier[public], parameter[actual, expected, times, steps]] begin[{]
TryStatement(block=[IfStatement(condition=ClassCreator(arguments=[Literal(postfix_operators=[], prefix_operators=[], qualifier=None, selectors=[], value="loopKey"), Memb... | annotation[@] identifier[Lorsque] operator[SEP] literal[String] operator[SEP] annotation[@] identifier[Then] operator[SEP] literal[String] operator[SEP] Keyword[public] Keyword[void] identifier[loop] operator[SEP] identifier[String] identifier[actual] , identifier[String] identifier[expected] , Keyword[int] identifie... |
@Deprecated
public PackageDoc[] importedPackages() {
// information is not available for binary classfiles
if (tsym.sourcefile == null) return new PackageDoc[0];
ListBuffer<PackageDocImpl> importedPackages = new ListBuffer<>();
//### Add the implicit "import java.lang.*" to the res... | class class_name[name] begin[{]
method[importedPackages, return_type[type[PackageDoc]], modifier[public], parameter[]] begin[{]
if[binary_operation[member[tsym.sourcefile], ==, literal[null]]] begin[{]
return[ArrayCreator(dimensions=[Literal(postfix_operators=[], prefix_operators=[], qualifier=... | annotation[@] identifier[Deprecated] Keyword[public] identifier[PackageDoc] operator[SEP] operator[SEP] identifier[importedPackages] operator[SEP] operator[SEP] {
Keyword[if] operator[SEP] identifier[tsym] operator[SEP] identifier[sourcefile] operator[==] Other[null] operator[SEP] Keyword[return] Keyword[new] id... |
@Override
public void sawOpcode(int seen) {
switch (state) {
case IN_CLINIT:
sawCLInitOpcode(seen);
break;
case IN_INIT:
sawInitOpcode(seen);
break;
case IN_METHOD:
sawMethodOpcode(seen);
... | class class_name[name] begin[{]
method[sawOpcode, return_type[void], modifier[public], parameter[seen]] begin[{]
SwitchStatement(cases=[SwitchStatementCase(case=['IN_CLINIT'], statements=[StatementExpression(expression=MethodInvocation(arguments=[MemberReference(member=seen, postfix_operators=[], prefi... | annotation[@] identifier[Override] Keyword[public] Keyword[void] identifier[sawOpcode] operator[SEP] Keyword[int] identifier[seen] operator[SEP] {
Keyword[switch] operator[SEP] identifier[state] operator[SEP] {
Keyword[case] identifier[IN_CLINIT] operator[:] identifier[sawCLInitOpcode] operator[SEP] ... |
@TargetApi(Build.VERSION_CODES.ICE_CREAM_SANDWICH)
public static synchronized void register(android.app.Application application) {
if (application == null) {
Logger.i("Application instance is null/system API is too old");
return;
}
if (registered) {
Logge... | class class_name[name] begin[{]
method[register, return_type[void], modifier[synchronized public static], parameter[application]] begin[{]
if[binary_operation[member[.application], ==, literal[null]]] begin[{]
call[Logger.i, parameter[literal["Application instance is nul... | annotation[@] identifier[TargetApi] operator[SEP] identifier[Build] operator[SEP] identifier[VERSION_CODES] operator[SEP] identifier[ICE_CREAM_SANDWICH] operator[SEP] Keyword[public] Keyword[static] Keyword[synchronized] Keyword[void] identifier[register] operator[SEP] identifier[android] operator[SEP] identifier[app] ... |
public static RoaringBitmap naive_xor(Iterator<? extends RoaringBitmap> bitmaps) {
RoaringBitmap answer = new RoaringBitmap();
while (bitmaps.hasNext()) {
answer.xor(bitmaps.next());
}
return answer;
} | class class_name[name] begin[{]
method[naive_xor, return_type[type[RoaringBitmap]], modifier[public static], parameter[bitmaps]] begin[{]
local_variable[type[RoaringBitmap], answer]
while[call[bitmaps.hasNext, parameter[]]] begin[{]
call[answer.xor, parameter[cal... | Keyword[public] Keyword[static] identifier[RoaringBitmap] identifier[naive_xor] operator[SEP] identifier[Iterator] operator[<] operator[?] Keyword[extends] identifier[RoaringBitmap] operator[>] identifier[bitmaps] operator[SEP] {
identifier[RoaringBitmap] identifier[answer] operator[=] Keyword[new] identifier[Ro... |
@Override
public void addListener(Runnable listener, Executor executor) {
checkNotNull(listener, "Runnable was null.");
checkNotNull(executor, "Executor was null.");
// Checking isDone and listeners != TOMBSTONE may seem redundant, but our contract for
// addListener says that listeners execute 'immed... | class class_name[name] begin[{]
method[addListener, return_type[void], modifier[public], parameter[listener, executor]] begin[{]
call[.checkNotNull, parameter[member[.listener], literal["Runnable was null."]]]
call[.checkNotNull, parameter[member[.executor], literal["Executor wa... | annotation[@] identifier[Override] Keyword[public] Keyword[void] identifier[addListener] operator[SEP] identifier[Runnable] identifier[listener] , identifier[Executor] identifier[executor] operator[SEP] {
identifier[checkNotNull] operator[SEP] identifier[listener] , literal[String] operator[SEP] operator[SEP] ... |
public static List<Connector> createDefaultConnectors(Map<String, Object> properties) {
List<Connector> connectors = Lists.newArrayList();
Map<String, Map<String, String>> propertiesMap = Maps.newLinkedHashMap();
for (String key : properties.keySet()) {
if (key.startsWith(Connector.C... | class class_name[name] begin[{]
method[createDefaultConnectors, return_type[type[List]], modifier[public static], parameter[properties]] begin[{]
local_variable[type[List], connectors]
local_variable[type[Map], propertiesMap]
ForStatement(body=BlockStatement(label=None, statements=[IfSt... | Keyword[public] Keyword[static] identifier[List] operator[<] identifier[Connector] operator[>] identifier[createDefaultConnectors] operator[SEP] identifier[Map] operator[<] identifier[String] , identifier[Object] operator[>] identifier[properties] operator[SEP] {
identifier[List] operator[<] identifier[Connecto... |
@Override protected void initGraphics() {
super.initGraphics();
matrix = PixelMatrixBuilder.create()
.pixelShape(PixelShape.SQUARE)
.useSpacer(true)
.squarePixels(false)
... | class class_name[name] begin[{]
method[initGraphics, return_type[void], modifier[protected], parameter[]] begin[{]
SuperMethodInvocation(arguments=[], member=initGraphics, postfix_operators=[], prefix_operators=[], qualifier=None, selectors=[], type_arguments=None)
assign[member... | annotation[@] identifier[Override] Keyword[protected] Keyword[void] identifier[initGraphics] operator[SEP] operator[SEP] {
Keyword[super] operator[SEP] identifier[initGraphics] operator[SEP] operator[SEP] operator[SEP] identifier[matrix] operator[=] identifier[PixelMatrixBuilder] operator[SEP] identifier[create]... |
public NetworkSecurityGroupInner updateTags(String resourceGroupName, String networkSecurityGroupName, Map<String, String> tags) {
return updateTagsWithServiceResponseAsync(resourceGroupName, networkSecurityGroupName, tags).toBlocking().last().body();
} | class class_name[name] begin[{]
method[updateTags, return_type[type[NetworkSecurityGroupInner]], modifier[public], parameter[resourceGroupName, networkSecurityGroupName, tags]] begin[{]
return[call[.updateTagsWithServiceResponseAsync, parameter[member[.resourceGroupName], member[.networkSecurityGroupNa... | Keyword[public] identifier[NetworkSecurityGroupInner] identifier[updateTags] operator[SEP] identifier[String] identifier[resourceGroupName] , identifier[String] identifier[networkSecurityGroupName] , identifier[Map] operator[<] identifier[String] , identifier[String] operator[>] identifier[tags] operator[SEP] {
... |
private MembershipByUserGroupTypeWrapper findMembership(Session session, String id) throws Exception
{
IdComponents ids;
try
{
ids = utils.splitId(id);
}
catch (IndexOutOfBoundsException e)
{
throw new ItemNotFoundException("Can not find membership by id=" + id, ... | class class_name[name] begin[{]
method[findMembership, return_type[type[MembershipByUserGroupTypeWrapper]], modifier[private], parameter[session, id]] begin[{]
local_variable[type[IdComponents], ids]
TryStatement(block=[StatementExpression(expression=Assignment(expressionl=MemberReference(membe... | Keyword[private] identifier[MembershipByUserGroupTypeWrapper] identifier[findMembership] operator[SEP] identifier[Session] identifier[session] , identifier[String] identifier[id] operator[SEP] Keyword[throws] identifier[Exception] {
identifier[IdComponents] identifier[ids] operator[SEP] Keyword[try] {
... |
public static String decrypt(String c, String key) {
try {
SecretKeySpec skeySpec = new SecretKeySpec(Hex.decodeHex(key.toCharArray()), "AES");
Cipher cipher = Cipher.getInstance("AES");
cipher.init(Cipher.DECRYPT_MODE, skeySpec);
byte[] decoded = cipher.doFinal(H... | class class_name[name] begin[{]
method[decrypt, return_type[type[String]], modifier[public static], parameter[c, key]] begin[{]
TryStatement(block=[LocalVariableDeclaration(annotations=[], declarators=[VariableDeclarator(dimensions=[], initializer=ClassCreator(arguments=[MethodInvocation(arguments=[Met... | Keyword[public] Keyword[static] identifier[String] identifier[decrypt] operator[SEP] identifier[String] identifier[c] , identifier[String] identifier[key] operator[SEP] {
Keyword[try] {
identifier[SecretKeySpec] identifier[skeySpec] operator[=] Keyword[new] identifier[SecretKeySpec] operator[SEP] ide... |
public void processAnnotations(DescriptorPolicy descriptorPolicy) {
processEntityAnnotations(descriptorPolicy);
declaredGenuineVariableDescriptorMap = new LinkedHashMap<>();
declaredShadowVariableDescriptorMap = new LinkedHashMap<>();
declaredPinEntityFilterList = new ArrayList<>(2);
... | class class_name[name] begin[{]
method[processAnnotations, return_type[void], modifier[public], parameter[descriptorPolicy]] begin[{]
call[.processEntityAnnotations, parameter[member[.descriptorPolicy]]]
assign[member[.declaredGenuineVariableDescriptorMap], ClassCreator(argument... | Keyword[public] Keyword[void] identifier[processAnnotations] operator[SEP] identifier[DescriptorPolicy] identifier[descriptorPolicy] operator[SEP] {
identifier[processEntityAnnotations] operator[SEP] identifier[descriptorPolicy] operator[SEP] operator[SEP] identifier[declaredGenuineVariableDescriptorMap] operato... |
private void printTimeOfMapMatchQuery(final GraphHopper hopper, final MapMatching mapMatching) {
// pick random start/end points to create a route, then pick random points from the route,
// and then run the random points through map-matching.
final double latDelta = bbox.maxLat - bbox.minLat;
... | class class_name[name] begin[{]
method[printTimeOfMapMatchQuery, return_type[void], modifier[private], parameter[hopper, mapMatching]] begin[{]
local_variable[type[double], latDelta]
local_variable[type[double], lonDelta]
local_variable[type[Random], rand]
local_variable[type[Mi... | Keyword[private] Keyword[void] identifier[printTimeOfMapMatchQuery] operator[SEP] Keyword[final] identifier[GraphHopper] identifier[hopper] , Keyword[final] identifier[MapMatching] identifier[mapMatching] operator[SEP] {
Keyword[final] Keyword[double] identifier[latDelta] operator[=] identifier[bbox] operator[S... |
@SuppressWarnings("ReferenceEquality")
private void logImpl(String message, Object... args) {
this.args = args;
// Evaluate any (rare) LazyArg instances early. This may throw exceptions from user code, but
// it seems reasonable to propagate them in this case (they would have been thrown if the
// arg... | class class_name[name] begin[{]
method[logImpl, return_type[void], modifier[private], parameter[message, args]] begin[{]
assign[THIS[member[None.args]], member[.args]]
ForStatement(body=BlockStatement(label=None, statements=[IfStatement(condition=BinaryOperation(operandl=MemberReference... | annotation[@] identifier[SuppressWarnings] operator[SEP] literal[String] operator[SEP] Keyword[private] Keyword[void] identifier[logImpl] operator[SEP] identifier[String] identifier[message] , identifier[Object] operator[...] identifier[args] operator[SEP] {
Keyword[this] operator[SEP] identifier[args] operator... |
public static ReservationFetcher fetcher(final String pathWorkspaceSid,
final String pathTaskSid,
final String pathSid) {
return new ReservationFetcher(pathWorkspaceSid, pathTaskSid, pathSid);
} | class class_name[name] begin[{]
method[fetcher, return_type[type[ReservationFetcher]], modifier[public static], parameter[pathWorkspaceSid, pathTaskSid, pathSid]] begin[{]
return[ClassCreator(arguments=[MemberReference(member=pathWorkspaceSid, postfix_operators=[], prefix_operators=[], qualifier=, sele... | Keyword[public] Keyword[static] identifier[ReservationFetcher] identifier[fetcher] operator[SEP] Keyword[final] identifier[String] identifier[pathWorkspaceSid] , Keyword[final] identifier[String] identifier[pathTaskSid] , Keyword[final] identifier[String] identifier[pathSid] operator[SEP] {
Keyword[return] Key... |
@Override
public final Object getValueAt(final int row, final int col) {
TableTreeNode rowNode = getNodeAtLine(row);
return getValueAt(rowNode, col);
} | class class_name[name] begin[{]
method[getValueAt, return_type[type[Object]], modifier[final public], parameter[row, col]] begin[{]
local_variable[type[TableTreeNode], rowNode]
return[call[.getValueAt, parameter[member[.rowNode], member[.col]]]]
end[}]
END[}] | annotation[@] identifier[Override] Keyword[public] Keyword[final] identifier[Object] identifier[getValueAt] operator[SEP] Keyword[final] Keyword[int] identifier[row] , Keyword[final] Keyword[int] identifier[col] operator[SEP] {
identifier[TableTreeNode] identifier[rowNode] operator[=] identifier[getNodeAtLine] ... |
@Override
@Nullable
public String getSubCenterName(int subcenter) {
if (nwsoSubCenter == null)
nwsoSubCenter = readNwsoSubCenter("resources/grib1/noaa_rfc/tableC.txt");
if (nwsoSubCenter == null) return null;
return nwsoSubCenter.get(subcenter);
} | class class_name[name] begin[{]
method[getSubCenterName, return_type[type[String]], modifier[public], parameter[subcenter]] begin[{]
if[binary_operation[member[.nwsoSubCenter], ==, literal[null]]] begin[{]
assign[member[.nwsoSubCenter], call[.readNwsoSubCenter, parameter[literal["re... | annotation[@] identifier[Override] annotation[@] identifier[Nullable] Keyword[public] identifier[String] identifier[getSubCenterName] operator[SEP] Keyword[int] identifier[subcenter] operator[SEP] {
Keyword[if] operator[SEP] identifier[nwsoSubCenter] operator[==] Other[null] operator[SEP] identifier[nwsoSubCente... |
public java.util.List<EnvironmentLink> getEnvironmentLinks() {
if (environmentLinks == null) {
environmentLinks = new com.amazonaws.internal.SdkInternalList<EnvironmentLink>();
}
return environmentLinks;
} | class class_name[name] begin[{]
method[getEnvironmentLinks, return_type[type[java]], modifier[public], parameter[]] begin[{]
if[binary_operation[member[.environmentLinks], ==, literal[null]]] begin[{]
assign[member[.environmentLinks], ClassCreator(arguments=[], body=None... | Keyword[public] identifier[java] operator[SEP] identifier[util] operator[SEP] identifier[List] operator[<] identifier[EnvironmentLink] operator[>] identifier[getEnvironmentLinks] operator[SEP] operator[SEP] {
Keyword[if] operator[SEP] identifier[environmentLinks] operator[==] Other[null] operator[SEP] {
... |
public Vector3f set(int index, ByteBuffer buffer) {
MemUtil.INSTANCE.get(this, index, buffer);
return this;
} | class class_name[name] begin[{]
method[set, return_type[type[Vector3f]], modifier[public], parameter[index, buffer]] begin[{]
call[MemUtil.INSTANCE.get, parameter[THIS[], member[.index], member[.buffer]]]
return[THIS[]]
end[}]
END[}] | Keyword[public] identifier[Vector3f] identifier[set] operator[SEP] Keyword[int] identifier[index] , identifier[ByteBuffer] identifier[buffer] operator[SEP] {
identifier[MemUtil] operator[SEP] identifier[INSTANCE] operator[SEP] identifier[get] operator[SEP] Keyword[this] , identifier[index] , identifier[buffer... |
@Nullable
public <P> P getListener(Class<P> type) {
if (mListener != null) {
return type.cast(mListener);
}
return null;
} | class class_name[name] begin[{]
method[getListener, return_type[type[P]], modifier[public], parameter[type]] begin[{]
if[binary_operation[member[.mListener], !=, literal[null]]] begin[{]
return[call[type.cast, parameter[member[.mListener]]]]
else begin[{]
None
end[}]... | annotation[@] identifier[Nullable] Keyword[public] operator[<] identifier[P] operator[>] identifier[P] identifier[getListener] operator[SEP] identifier[Class] operator[<] identifier[P] operator[>] identifier[type] operator[SEP] {
Keyword[if] operator[SEP] identifier[mListener] operator[!=] Other[null] operator[S... |
@SuppressWarnings("unchecked")
public void distributedProcess(ResponseBuilder rb, ComponentFields mtasFields)
throws IOException {
// rewrite
NamedList<Object> mtasResponse = null;
try {
mtasResponse = (NamedList<Object>) rb.rsp.getValues().get("mtas");
} catch (ClassCastException e) {
... | class class_name[name] begin[{]
method[distributedProcess, return_type[void], modifier[public], parameter[rb, mtasFields]] begin[{]
local_variable[type[NamedList], mtasResponse]
TryStatement(block=[StatementExpression(expression=Assignment(expressionl=MemberReference(member=mtasResponse, postfi... | annotation[@] identifier[SuppressWarnings] operator[SEP] literal[String] operator[SEP] Keyword[public] Keyword[void] identifier[distributedProcess] operator[SEP] identifier[ResponseBuilder] identifier[rb] , identifier[ComponentFields] identifier[mtasFields] operator[SEP] Keyword[throws] identifier[IOException] {
... |
private void startRevive() {
bot.setRunning(true);
Thread thread = new Thread(new ChatLoop(bot));
thread.setName("wechat-listener");
thread.setDaemon(true);
thread.start();
} | class class_name[name] begin[{]
method[startRevive, return_type[void], modifier[private], parameter[]] begin[{]
call[bot.setRunning, parameter[literal[true]]]
local_variable[type[Thread], thread]
call[thread.setName, parameter[literal["wechat-listener"]]]
... | Keyword[private] Keyword[void] identifier[startRevive] operator[SEP] operator[SEP] {
identifier[bot] operator[SEP] identifier[setRunning] operator[SEP] literal[boolean] operator[SEP] operator[SEP] identifier[Thread] identifier[thread] operator[=] Keyword[new] identifier[Thread] operator[SEP] Keyword[new] identif... |
protected void processDump(HttpServerExchange exchange) throws IOException {
final String data = processDumpString();
exchange.getResponseHeaders().add(Headers.SERVER, MOD_CLUSTER_EXPOSED_VERSION);
sendResponse(exchange, data);
} | class class_name[name] begin[{]
method[processDump, return_type[void], modifier[protected], parameter[exchange]] begin[{]
local_variable[type[String], data]
call[exchange.getResponseHeaders, parameter[]]
call[.sendResponse, parameter[member[.exchange], member[.data]]]
... | Keyword[protected] Keyword[void] identifier[processDump] operator[SEP] identifier[HttpServerExchange] identifier[exchange] operator[SEP] Keyword[throws] identifier[IOException] {
Keyword[final] identifier[String] identifier[data] operator[=] identifier[processDumpString] operator[SEP] operator[SEP] operator[SEP]... |
public int getRabbitMqPort() {
String portValue = this.envVars.get(RabbitMqEnvVar.NODE_PORT.getEnvVarName());
if (portValue == null) {
return RabbitMqEnvVar.DEFAULT_NODE_PORT;
} else {
return Integer.parseInt(portValue);
}
} | class class_name[name] begin[{]
method[getRabbitMqPort, return_type[type[int]], modifier[public], parameter[]] begin[{]
local_variable[type[String], portValue]
if[binary_operation[member[.portValue], ==, literal[null]]] begin[{]
return[member[RabbitMqEnvVar.DEFAULT_NODE_PORT... | Keyword[public] Keyword[int] identifier[getRabbitMqPort] operator[SEP] operator[SEP] {
identifier[String] identifier[portValue] operator[=] Keyword[this] operator[SEP] identifier[envVars] operator[SEP] identifier[get] operator[SEP] identifier[RabbitMqEnvVar] operator[SEP] identifier[NODE_PORT] operator[SEP] iden... |
private Collection<Map<String, Object>> getActiveSsoSessions(final SsoSessionReportOptions option) {
val activeSessions = new ArrayList<Map<String, Object>>();
val dateFormat = new ISOStandardDateFormat();
getNonExpiredTicketGrantingTickets().stream().map(TicketGrantingTicket.class::cast)
... | class class_name[name] begin[{]
method[getActiveSsoSessions, return_type[type[Collection]], modifier[private], parameter[option]] begin[{]
local_variable[type[val], activeSessions]
local_variable[type[val], dateFormat]
call[.getNonExpiredTicketGrantingTickets, parameter[]]
... | Keyword[private] identifier[Collection] operator[<] identifier[Map] operator[<] identifier[String] , identifier[Object] operator[>] operator[>] identifier[getActiveSsoSessions] operator[SEP] Keyword[final] identifier[SsoSessionReportOptions] identifier[option] operator[SEP] {
identifier[val] identifier[activeSe... |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.