code stringlengths 63 466k | code_sememe stringlengths 141 3.79M | token_type stringlengths 274 1.23M |
|---|---|---|
public UNode addArrayNode(String name, String tagName) {
return addChildNode(UNode.createArrayNode(name, tagName));
} | class class_name[name] begin[{]
method[addArrayNode, return_type[type[UNode]], modifier[public], parameter[name, tagName]] begin[{]
return[call[.addChildNode, parameter[call[UNode.createArrayNode, parameter[member[.name], member[.tagName]]]]]]
end[}]
END[}] | Keyword[public] identifier[UNode] identifier[addArrayNode] operator[SEP] identifier[String] identifier[name] , identifier[String] identifier[tagName] operator[SEP] {
Keyword[return] identifier[addChildNode] operator[SEP] identifier[UNode] operator[SEP] identifier[createArrayNode] operator[SEP] identifier[name] ... |
private static void freeTempLOB(ClobWrapper clob, BlobWrapper blob)
{
try
{
if (clob != null)
{
// If the CLOB is open, close it
if (clob.isOpen())
{
clob.close();
}
// Free the memory used by this CLOB
clob.freeTemporary();
}
if (blob != null)
{
... | class class_name[name] begin[{]
method[freeTempLOB, return_type[void], modifier[private static], parameter[clob, blob]] begin[{]
TryStatement(block=[IfStatement(condition=BinaryOperation(operandl=MemberReference(member=clob, postfix_operators=[], prefix_operators=[], qualifier=, selectors=[]), operandr... | Keyword[private] Keyword[static] Keyword[void] identifier[freeTempLOB] operator[SEP] identifier[ClobWrapper] identifier[clob] , identifier[BlobWrapper] identifier[blob] operator[SEP] {
Keyword[try] {
Keyword[if] operator[SEP] identifier[clob] operator[!=] Other[null] operator[SEP] {
Ke... |
public void closeToRight() {
if (viewDragHelper.smoothSlideViewTo(dragView, transformer.getOriginalWidth(),
getHeight() - transformer.getMinHeightPlusMargin())) {
ViewCompat.postInvalidateOnAnimation(this);
notifyCloseToRightListener();
}
} | class class_name[name] begin[{]
method[closeToRight, return_type[void], modifier[public], parameter[]] begin[{]
if[call[viewDragHelper.smoothSlideViewTo, parameter[member[.dragView], call[transformer.getOriginalWidth, parameter[]], binary_operation[call[.getHeight, parameter[]], -, call[transfo... | Keyword[public] Keyword[void] identifier[closeToRight] operator[SEP] operator[SEP] {
Keyword[if] operator[SEP] identifier[viewDragHelper] operator[SEP] identifier[smoothSlideViewTo] operator[SEP] identifier[dragView] , identifier[transformer] operator[SEP] identifier[getOriginalWidth] operator[SEP] operator[SEP... |
Expr sharedMethod() {
Tok tok = peek();
if (tok.sym != Sym.ID) {
return indexMethodField(null);
}
if (move().sym != Sym.LPAREN) {
resetForward(forward - 1);
return indexMethodField(null);
}
move();
if (peek().sym == Sym.RPAREN) {
SharedMethod sharedMethod = new SharedMethod(engi... | class class_name[name] begin[{]
method[sharedMethod, return_type[type[Expr]], modifier[default], parameter[]] begin[{]
local_variable[type[Tok], tok]
if[binary_operation[member[tok.sym], !=, member[Sym.ID]]] begin[{]
return[call[.indexMethodField, parameter[literal[null]]]]
... | identifier[Expr] identifier[sharedMethod] operator[SEP] operator[SEP] {
identifier[Tok] identifier[tok] operator[=] identifier[peek] operator[SEP] operator[SEP] operator[SEP] Keyword[if] operator[SEP] identifier[tok] operator[SEP] identifier[sym] operator[!=] identifier[Sym] operator[SEP] identifier[ID] operator... |
private JPanel createContentCanvas()
{
if (contentCanvas != null)
{
contentCanvas = new BrowserPanel(proc.getPage());
contentCanvas.setLayout(null);
selection = new Selection();
contentCanvas.add(selection);
selection.setVisible(false);
... | class class_name[name] begin[{]
method[createContentCanvas, return_type[type[JPanel]], modifier[private], parameter[]] begin[{]
if[binary_operation[member[.contentCanvas], !=, literal[null]]] begin[{]
assign[member[.contentCanvas], ClassCreator(arguments=[MethodInvocatio... | Keyword[private] identifier[JPanel] identifier[createContentCanvas] operator[SEP] operator[SEP] {
Keyword[if] operator[SEP] identifier[contentCanvas] operator[!=] Other[null] operator[SEP] {
identifier[contentCanvas] operator[=] Keyword[new] identifier[BrowserPanel] operator[SEP] identifier[proc] oper... |
public static <E extends Enum<E>> long generateBitVector(final Class<E> enumClass, final Iterable<? extends E> values) {
checkBitVectorable(enumClass);
Validate.notNull(values);
long total = 0;
for (final E constant : values) {
Validate.isTrue(constant != null, NULL_ELEMENTS_... | class class_name[name] begin[{]
method[generateBitVector, return_type[type[long]], modifier[public static], parameter[enumClass, values]] begin[{]
call[.checkBitVectorable, parameter[member[.enumClass]]]
call[Validate.notNull, parameter[member[.values]]]
local_variable[t... | Keyword[public] Keyword[static] operator[<] identifier[E] Keyword[extends] identifier[Enum] operator[<] identifier[E] operator[>] operator[>] Keyword[long] identifier[generateBitVector] operator[SEP] Keyword[final] identifier[Class] operator[<] identifier[E] operator[>] identifier[enumClass] , Keyword[final] identifie... |
public DataSource[] getDataSources() {
Entity[] entities;
try {
entities = getEntitiesByClassName(StorageConstants.DATASOURCES_ROOT, DataSource.class.getName());
} catch (NotFoundException e) {
// never happening
throw new RuntimeException(e);
}
DataSource[] dataSources = new DataSource[entities.leng... | class class_name[name] begin[{]
method[getDataSources, return_type[type[DataSource]], modifier[public], parameter[]] begin[{]
local_variable[type[Entity], entities]
TryStatement(block=[StatementExpression(expression=Assignment(expressionl=MemberReference(member=entities, postfix_operators=[], p... | Keyword[public] identifier[DataSource] operator[SEP] operator[SEP] identifier[getDataSources] operator[SEP] operator[SEP] {
identifier[Entity] operator[SEP] operator[SEP] identifier[entities] operator[SEP] Keyword[try] {
identifier[entities] operator[=] identifier[getEntitiesByClassName] operator[SEP]... |
private static <T> T createCustomComponent(Class<T> componentType, String componentSpec,
Map<String, String> configProperties, IPluginRegistry pluginRegistry) throws Exception {
return createCustomComponent(componentType, componentSpec, configProperties, pluginRegistry, null);
} | class class_name[name] begin[{]
method[createCustomComponent, return_type[type[T]], modifier[private static], parameter[componentType, componentSpec, configProperties, pluginRegistry]] begin[{]
return[call[.createCustomComponent, parameter[member[.componentType], member[.componentSpec], member[.configP... | Keyword[private] Keyword[static] operator[<] identifier[T] operator[>] identifier[T] identifier[createCustomComponent] operator[SEP] identifier[Class] operator[<] identifier[T] operator[>] identifier[componentType] , identifier[String] identifier[componentSpec] , identifier[Map] operator[<] identifier[String] , iden... |
static void flushMetricsLogger(final MetricsLogger metricsLogger) {
metricsLogger.flushToString(MetricsManager::queue);
MetricsManager.rootMetricsLogger.flushToString(MetricsManager::queue);
} | class class_name[name] begin[{]
method[flushMetricsLogger, return_type[void], modifier[static], parameter[metricsLogger]] begin[{]
call[metricsLogger.flushToString, parameter[MethodReference(expression=MemberReference(member=MetricsManager, postfix_operators=[], prefix_operators=[], qualifier=,... | Keyword[static] Keyword[void] identifier[flushMetricsLogger] operator[SEP] Keyword[final] identifier[MetricsLogger] identifier[metricsLogger] operator[SEP] {
identifier[metricsLogger] operator[SEP] identifier[flushToString] operator[SEP] identifier[MetricsManager] operator[::] identifier[queue] operator[SEP] ope... |
public static void mapZipFile(final byte[] zipFile, final Map<String, byte[]> output, final String keyPrefix,
final String keyUnPrefix) {
try {
final String fixedKeyPrefix = keyPrefix == null ? "" : keyPrefix;
final String fixedKeyUnPrefix = keyUnPrefix == null ? "" : key... | class class_name[name] begin[{]
method[mapZipFile, return_type[void], modifier[public static], parameter[zipFile, output, keyPrefix, keyUnPrefix]] begin[{]
TryStatement(block=[LocalVariableDeclaration(annotations=[], declarators=[VariableDeclarator(dimensions=[], initializer=TernaryExpression(condition... | Keyword[public] Keyword[static] Keyword[void] identifier[mapZipFile] operator[SEP] Keyword[final] Keyword[byte] operator[SEP] operator[SEP] identifier[zipFile] , Keyword[final] identifier[Map] operator[<] identifier[String] , Keyword[byte] operator[SEP] operator[SEP] operator[>] identifier[output] , Keyword[final] i... |
public ArrayList<JTSFeature> getFeaturesByCategory(String category, double minX, double minY, double maxX,
double maxY, List<Param> optionalParams) throws Exception {
List<String> ids = serviceManager.getAvailableServices().getServicesIDByCategory(category);
ArrayList<JTSFeature> features = new ArrayList<JTSFeat... | class class_name[name] begin[{]
method[getFeaturesByCategory, return_type[type[ArrayList]], modifier[public], parameter[category, minX, minY, maxX, maxY, optionalParams]] begin[{]
local_variable[type[List], ids]
local_variable[type[ArrayList], features]
ForStatement(body=BlockStatement(... | Keyword[public] identifier[ArrayList] operator[<] identifier[JTSFeature] operator[>] identifier[getFeaturesByCategory] operator[SEP] identifier[String] identifier[category] , Keyword[double] identifier[minX] , Keyword[double] identifier[minY] , Keyword[double] identifier[maxX] , Keyword[double] identifier[maxY] , ... |
@Override
public ProducerSession createProducerSession(
SIDestinationAddress destAddr,
String discriminator,
DestinationType destType,
... | class class_name[name] begin[{]
method[createProducerSession, return_type[type[ProducerSession]], modifier[public], parameter[destAddr, discriminator, destType, extendedMessageOrderingContext, alternateUser, fixedQueuePoint, preferLocal, clearPubSubFingerprints]] begin[{]
if[binary_operation[ca... | annotation[@] identifier[Override] Keyword[public] identifier[ProducerSession] identifier[createProducerSession] operator[SEP] identifier[SIDestinationAddress] identifier[destAddr] , identifier[String] identifier[discriminator] , identifier[DestinationType] identifier[destType] , identifier[OrderingContext] identifi... |
void handleRemove(SimpleTest test, Conjunction selector,
MatchTarget object, InternTable subExpr, OrdinalPosition parentId) throws MatchingException
{
if (tc.isEntryEnabled())
tc.entry(this,cclass, "handleRemove","test: "+test+ ",selector: "+selector+", object: "+object);
if (t... | class class_name[name] begin[{]
method[handleRemove, return_type[void], modifier[default], parameter[test, selector, object, subExpr, parentId]] begin[{]
if[call[tc.isEntryEnabled, parameter[]]] begin[{]
call[tc.entry, parameter[THIS[], member[.cclass], literal["handleRemove"], bina... | Keyword[void] identifier[handleRemove] operator[SEP] identifier[SimpleTest] identifier[test] , identifier[Conjunction] identifier[selector] , identifier[MatchTarget] identifier[object] , identifier[InternTable] identifier[subExpr] , identifier[OrdinalPosition] identifier[parentId] operator[SEP] Keyword[throws] iden... |
public Object set(final int index, final Object obj) {
maintain();
SoftObject soft = SoftObject.create(obj, queue);
soft = (SoftObject)list.set(index, soft);
return Objects.deref(soft);
} | class class_name[name] begin[{]
method[set, return_type[type[Object]], modifier[public], parameter[index, obj]] begin[{]
call[.maintain, parameter[]]
local_variable[type[SoftObject], soft]
assign[member[.soft], Cast(expression=MethodInvocation(arguments=[MemberReference(... | Keyword[public] identifier[Object] identifier[set] operator[SEP] Keyword[final] Keyword[int] identifier[index] , Keyword[final] identifier[Object] identifier[obj] operator[SEP] {
identifier[maintain] operator[SEP] operator[SEP] operator[SEP] identifier[SoftObject] identifier[soft] operator[=] identifier[SoftObj... |
public static void ensureCurrentState(Service.STATE state,
Service.STATE expectedState) {
if (state != expectedState) {
throw new IllegalStateException("For this operation, the " +
"current service state must be "
... | class class_name[name] begin[{]
method[ensureCurrentState, return_type[void], modifier[public static], parameter[state, expectedState]] begin[{]
if[binary_operation[member[.state], !=, member[.expectedState]]] begin[{]
ThrowStatement(expression=ClassCreator(arguments=[BinaryOperatio... | Keyword[public] Keyword[static] Keyword[void] identifier[ensureCurrentState] operator[SEP] identifier[Service] operator[SEP] identifier[STATE] identifier[state] , identifier[Service] operator[SEP] identifier[STATE] identifier[expectedState] operator[SEP] {
Keyword[if] operator[SEP] identifier[state] operator[!=... |
public void setupCellPositoin(final int rowIndex, final int columnIndex) {
if(topLeftPoisitoin == null) {
this.topLeftPoisitoin = new Point(columnIndex, rowIndex);
}
if(bottomRightPosition == null) {
this.bottomRightPosition = new Point(columnInde... | class class_name[name] begin[{]
method[setupCellPositoin, return_type[void], modifier[public], parameter[rowIndex, columnIndex]] begin[{]
if[binary_operation[member[.topLeftPoisitoin], ==, literal[null]]] begin[{]
assign[THIS[member[None.topLeftPoisitoin]], ClassCreator(... | Keyword[public] Keyword[void] identifier[setupCellPositoin] operator[SEP] Keyword[final] Keyword[int] identifier[rowIndex] , Keyword[final] Keyword[int] identifier[columnIndex] operator[SEP] {
Keyword[if] operator[SEP] identifier[topLeftPoisitoin] operator[==] Other[null] operator[SEP] {
Keyword[this... |
public void marshall(DeleteVoiceConnectorTerminationCredentialsRequest deleteVoiceConnectorTerminationCredentialsRequest,
ProtocolMarshaller protocolMarshaller) {
if (deleteVoiceConnectorTerminationCredentialsRequest == null) {
throw new SdkClientException("Invalid argument passed to ma... | class class_name[name] begin[{]
method[marshall, return_type[void], modifier[public], parameter[deleteVoiceConnectorTerminationCredentialsRequest, protocolMarshaller]] begin[{]
if[binary_operation[member[.deleteVoiceConnectorTerminationCredentialsRequest], ==, literal[null]]] begin[{]
... | Keyword[public] Keyword[void] identifier[marshall] operator[SEP] identifier[DeleteVoiceConnectorTerminationCredentialsRequest] identifier[deleteVoiceConnectorTerminationCredentialsRequest] , identifier[ProtocolMarshaller] identifier[protocolMarshaller] operator[SEP] {
Keyword[if] operator[SEP] identifier[delete... |
public OvhOrder hosting_privateDatabase_serviceName_ram_duration_POST(String serviceName, String duration, OvhAvailableRamSizeEnum ram) throws IOException {
String qPath = "/order/hosting/privateDatabase/{serviceName}/ram/{duration}";
StringBuilder sb = path(qPath, serviceName, duration);
HashMap<String, Object>o... | class class_name[name] begin[{]
method[hosting_privateDatabase_serviceName_ram_duration_POST, return_type[type[OvhOrder]], modifier[public], parameter[serviceName, duration, ram]] begin[{]
local_variable[type[String], qPath]
local_variable[type[StringBuilder], sb]
local_variable[type[Ha... | Keyword[public] identifier[OvhOrder] identifier[hosting_privateDatabase_serviceName_ram_duration_POST] operator[SEP] identifier[String] identifier[serviceName] , identifier[String] identifier[duration] , identifier[OvhAvailableRamSizeEnum] identifier[ram] operator[SEP] Keyword[throws] identifier[IOException] {
... |
public Api getActionResult(String action, String params, TokenResult token,
Object pFormData, String format) throws Exception {
String text = this.getActionResultText(action, params, token, pFormData,
format);
Api api = null;
if ("xml".equals(format)) {
if (debug) {
// convert th... | class class_name[name] begin[{]
method[getActionResult, return_type[type[Api]], modifier[public], parameter[action, params, token, pFormData, format]] begin[{]
local_variable[type[String], text]
local_variable[type[Api], api]
if[literal["xml"]] begin[{]
i... | Keyword[public] identifier[Api] identifier[getActionResult] operator[SEP] identifier[String] identifier[action] , identifier[String] identifier[params] , identifier[TokenResult] identifier[token] , identifier[Object] identifier[pFormData] , identifier[String] identifier[format] operator[SEP] Keyword[throws] identif... |
@SuppressWarnings("unchecked")
@Override
public <T> T findById(Object id, String collectionName) {
CollectionMetaData cmd = cmdMap.get(collectionName);
Map<Object, T> collection = (Map<Object, T>) collectionsRef.get().get(collectionName);
if((null == cmd) || null == collection) {
throw new Invalid... | class class_name[name] begin[{]
method[findById, return_type[type[T]], modifier[public], parameter[id, collectionName]] begin[{]
local_variable[type[CollectionMetaData], cmd]
local_variable[type[Map], collection]
if[binary_operation[binary_operation[literal[null], ==, member[.cm... | annotation[@] identifier[SuppressWarnings] operator[SEP] literal[String] operator[SEP] annotation[@] identifier[Override] Keyword[public] operator[<] identifier[T] operator[>] identifier[T] identifier[findById] operator[SEP] identifier[Object] identifier[id] , identifier[String] identifier[collectionName] operator[SEP... |
public static TransactionIsolation forName(String v)
{
if (v != null && !v.trim().equals(""))
{
if ("TRANSACTION_READ_UNCOMMITTED".equalsIgnoreCase(v) || "1".equalsIgnoreCase(v))
{
return TRANSACTION_READ_UNCOMMITTED;
}
else if ("TRANSACTION_READ_COMMITTED"... | class class_name[name] begin[{]
method[forName, return_type[type[TransactionIsolation]], modifier[public static], parameter[v]] begin[{]
if[binary_operation[binary_operation[member[.v], !=, literal[null]], &&, call[v.trim, parameter[]]]] begin[{]
if[binary_operation[lite... | Keyword[public] Keyword[static] identifier[TransactionIsolation] identifier[forName] operator[SEP] identifier[String] identifier[v] operator[SEP] {
Keyword[if] operator[SEP] identifier[v] operator[!=] Other[null] operator[&&] operator[!] identifier[v] operator[SEP] identifier[trim] operator[SEP] operator[SEP] op... |
public static void picture(double x, double y, String filename)
{
Image image = getImageFromFile(filename);
double xs = scaleX(x);
double ys = scaleY(y);
int ws = image.getWidth(null);
int hs = image.getHeight(null);
if (ws < 0 || hs < 0)
throw new IllegalArgumentException("image " + fil... | class class_name[name] begin[{]
method[picture, return_type[void], modifier[public static], parameter[x, y, filename]] begin[{]
local_variable[type[Image], image]
local_variable[type[double], xs]
local_variable[type[double], ys]
local_variable[type[int], ws]
local_variab... | Keyword[public] Keyword[static] Keyword[void] identifier[picture] operator[SEP] Keyword[double] identifier[x] , Keyword[double] identifier[y] , identifier[String] identifier[filename] operator[SEP] {
identifier[Image] identifier[image] operator[=] identifier[getImageFromFile] operator[SEP] identifier[filename]... |
public boolean contains(Object o) {
for(T e : elemArray) {
if((o == e) || ((o != null) && o.equals(e))) {
return true;
}
}
return false;
} | class class_name[name] begin[{]
method[contains, return_type[type[boolean]], modifier[public], parameter[o]] begin[{]
ForStatement(body=BlockStatement(label=None, statements=[IfStatement(condition=BinaryOperation(operandl=BinaryOperation(operandl=MemberReference(member=o, postfix_operators=[], prefix_o... | Keyword[public] Keyword[boolean] identifier[contains] operator[SEP] identifier[Object] identifier[o] operator[SEP] {
Keyword[for] operator[SEP] identifier[T] identifier[e] operator[:] identifier[elemArray] operator[SEP] {
Keyword[if] operator[SEP] operator[SEP] identifier[o] operator[==] identifier[e... |
private void writeObject(java.io.ObjectOutputStream s)
throws java.io.IOException {
s.defaultWriteObject();
Object[] elements = getArray();
// Write out array length
s.writeInt(elements.length);
// Write out all elements in the proper order.
for (Ob... | class class_name[name] begin[{]
method[writeObject, return_type[void], modifier[private], parameter[s]] begin[{]
call[s.defaultWriteObject, parameter[]]
local_variable[type[Object], elements]
call[s.writeInt, parameter[member[elements.length]]]
ForStatement(body=... | Keyword[private] Keyword[void] identifier[writeObject] operator[SEP] identifier[java] operator[SEP] identifier[io] operator[SEP] identifier[ObjectOutputStream] identifier[s] operator[SEP] Keyword[throws] identifier[java] operator[SEP] identifier[io] operator[SEP] identifier[IOException] {
identifier[s] operator[... |
public static br delete(nitro_service client, br resource) throws Exception
{
resource.validate("delete");
return ((br[]) resource.delete_resource(client))[0];
} | class class_name[name] begin[{]
method[delete, return_type[type[br]], modifier[public static], parameter[client, resource]] begin[{]
call[resource.validate, parameter[literal["delete"]]]
return[Cast(expression=MethodInvocation(arguments=[MemberReference(member=client, postfix_operators=... | Keyword[public] Keyword[static] identifier[br] identifier[delete] operator[SEP] identifier[nitro_service] identifier[client] , identifier[br] identifier[resource] operator[SEP] Keyword[throws] identifier[Exception] {
identifier[resource] operator[SEP] identifier[validate] operator[SEP] literal[String] operator[... |
protected base_resource[] get_nitro_bulk_response(nitro_service service, String response) throws Exception
{
host_interface_responses result = (host_interface_responses) service.get_payload_formatter().string_to_resource(host_interface_responses.class, response);
if(result.errorcode != 0)
{
if (result.er... | class class_name[name] begin[{]
method[get_nitro_bulk_response, return_type[type[base_resource]], modifier[protected], parameter[service, response]] begin[{]
local_variable[type[host_interface_responses], result]
if[binary_operation[member[result.errorcode], !=, literal[0]]] begin[{]
... | Keyword[protected] identifier[base_resource] operator[SEP] operator[SEP] identifier[get_nitro_bulk_response] operator[SEP] identifier[nitro_service] identifier[service] , identifier[String] identifier[response] operator[SEP] Keyword[throws] identifier[Exception] {
identifier[host_interface_responses] identifier... |
private static void writeTraceHeaderInfo(PrintStream out) {
final SimpleDateFormat dateFormat = new SimpleDateFormat("EEE MMM dd HH:mm:ss zzz YYYY");
out.println("Date: "+dateFormat.format(new Date()));
out.println("\nProcess ID: "+pid);
out.println("\nSystem properties:");
final Properties sysPr... | class class_name[name] begin[{]
method[writeTraceHeaderInfo, return_type[void], modifier[private static], parameter[out]] begin[{]
local_variable[type[SimpleDateFormat], dateFormat]
call[out.println, parameter[binary_operation[literal["Date: "], +, call[dateFormat.format, parameter[Clas... | Keyword[private] Keyword[static] Keyword[void] identifier[writeTraceHeaderInfo] operator[SEP] identifier[PrintStream] identifier[out] operator[SEP] {
Keyword[final] identifier[SimpleDateFormat] identifier[dateFormat] operator[=] Keyword[new] identifier[SimpleDateFormat] operator[SEP] literal[String] operator[SEP... |
public <K, V> CallbackBuilder withMapCallback(final Class<K> keyClass,
final Class<V> valueClass,
final Callback<Map<K, V>> callback) {
this.callback = callback;
return this;
} | class class_name[name] begin[{]
method[withMapCallback, return_type[type[CallbackBuilder]], modifier[public], parameter[keyClass, valueClass, callback]] begin[{]
assign[THIS[member[None.callback]], member[.callback]]
return[THIS[]]
end[}]
END[}] | Keyword[public] operator[<] identifier[K] , identifier[V] operator[>] identifier[CallbackBuilder] identifier[withMapCallback] operator[SEP] Keyword[final] identifier[Class] operator[<] identifier[K] operator[>] identifier[keyClass] , Keyword[final] identifier[Class] operator[<] identifier[V] operator[>] identifier[va... |
public TransformInner update(String resourceGroupName, String accountName, String transformName, TransformInner parameters) {
return updateWithServiceResponseAsync(resourceGroupName, accountName, transformName, parameters).toBlocking().single().body();
} | class class_name[name] begin[{]
method[update, return_type[type[TransformInner]], modifier[public], parameter[resourceGroupName, accountName, transformName, parameters]] begin[{]
return[call[.updateWithServiceResponseAsync, parameter[member[.resourceGroupName], member[.accountName], member[.transformNa... | Keyword[public] identifier[TransformInner] identifier[update] operator[SEP] identifier[String] identifier[resourceGroupName] , identifier[String] identifier[accountName] , identifier[String] identifier[transformName] , identifier[TransformInner] identifier[parameters] operator[SEP] {
Keyword[return] identifie... |
public static <E> E[] merge(E[] a, E[] b) {
List<E> list = merge(Arrays.asList(a), Arrays.asList(b));
return list.toArray(a);
} | class class_name[name] begin[{]
method[merge, return_type[type[E]], modifier[public static], parameter[a, b]] begin[{]
local_variable[type[List], list]
return[call[list.toArray, parameter[member[.a]]]]
end[}]
END[}] | Keyword[public] Keyword[static] operator[<] identifier[E] operator[>] identifier[E] operator[SEP] operator[SEP] identifier[merge] operator[SEP] identifier[E] operator[SEP] operator[SEP] identifier[a] , identifier[E] operator[SEP] operator[SEP] identifier[b] operator[SEP] {
identifier[List] operator[<] identifie... |
@Override
public String getToolTip() {
ComponentModel model = getComponentModel();
return I18nUtilities.format(null, model.getToolTip());
} | class class_name[name] begin[{]
method[getToolTip, return_type[type[String]], modifier[public], parameter[]] begin[{]
local_variable[type[ComponentModel], model]
return[call[I18nUtilities.format, parameter[literal[null], call[model.getToolTip, parameter[]]]]]
end[}]
END[}] | annotation[@] identifier[Override] Keyword[public] identifier[String] identifier[getToolTip] operator[SEP] operator[SEP] {
identifier[ComponentModel] identifier[model] operator[=] identifier[getComponentModel] operator[SEP] operator[SEP] operator[SEP] Keyword[return] identifier[I18nUtilities] operator[SEP] ident... |
public static LinkedHashMap<String, DNASequence> readFastaDNASequence(File file, boolean lazySequenceLoad) throws IOException {
if (!lazySequenceLoad) {
return readFastaDNASequence(file);
}
FastaReader<DNASequence, NucleotideCompound> fastaProxyReader =
new FastaReader<DNASequence, NucleotideCompound>(
... | class class_name[name] begin[{]
method[readFastaDNASequence, return_type[type[LinkedHashMap]], modifier[public static], parameter[file, lazySequenceLoad]] begin[{]
if[member[.lazySequenceLoad]] begin[{]
return[call[.readFastaDNASequence, parameter[member[.file]]]]
else begin... | Keyword[public] Keyword[static] identifier[LinkedHashMap] operator[<] identifier[String] , identifier[DNASequence] operator[>] identifier[readFastaDNASequence] operator[SEP] identifier[File] identifier[file] , Keyword[boolean] identifier[lazySequenceLoad] operator[SEP] Keyword[throws] identifier[IOException] {
... |
public static String propertiesToURL(String strURL, Map<String,Object> properties)
{
if (properties != null)
{
for (String strKey : properties.keySet())
{
Object strValue = properties.get(strKey);
strURL = Utility.addURLParam(strURL, strKey.toS... | class class_name[name] begin[{]
method[propertiesToURL, return_type[type[String]], modifier[public static], parameter[strURL, properties]] begin[{]
if[binary_operation[member[.properties], !=, literal[null]]] begin[{]
ForStatement(body=BlockStatement(label=None, statements=[LocalVar... | Keyword[public] Keyword[static] identifier[String] identifier[propertiesToURL] operator[SEP] identifier[String] identifier[strURL] , identifier[Map] operator[<] identifier[String] , identifier[Object] operator[>] identifier[properties] operator[SEP] {
Keyword[if] operator[SEP] identifier[properties] operator[!... |
public String toUnicodeHostString() {
if (!_is_hostname) {
return toString();
}
try {
StringBuilder buf = new StringBuilder();
if (_scheme != null) {
buf.append(_scheme);
buf.append(':');
}
if (... | class class_name[name] begin[{]
method[toUnicodeHostString, return_type[type[String]], modifier[public], parameter[]] begin[{]
if[member[._is_hostname]] begin[{]
return[call[.toString, parameter[]]]
else begin[{]
None
end[}]
TryStatement(block=[LocalVariableD... | Keyword[public] identifier[String] identifier[toUnicodeHostString] operator[SEP] operator[SEP] {
Keyword[if] operator[SEP] operator[!] identifier[_is_hostname] operator[SEP] {
Keyword[return] identifier[toString] operator[SEP] operator[SEP] operator[SEP]
}
Keyword[try] {
ident... |
@Override
public void start() {
if ((this.encoder == null) || (this.encoder.getLayout() == null)) {
addError("No layout set for the appender named [" + name + "].");
return;
}
// tag encoder is optional but needs a layout
if (this.tagEncoder != null) {
final Layout<?> layout = this.... | class class_name[name] begin[{]
method[start, return_type[void], modifier[public], parameter[]] begin[{]
if[binary_operation[binary_operation[THIS[member[None.encoder]], ==, literal[null]], ||, binary_operation[THIS[member[None.encoder]call[None.getLayout, parameter[]]], ==, literal[null]]]] be... | annotation[@] identifier[Override] Keyword[public] Keyword[void] identifier[start] operator[SEP] operator[SEP] {
Keyword[if] operator[SEP] operator[SEP] Keyword[this] operator[SEP] identifier[encoder] operator[==] Other[null] operator[SEP] operator[||] operator[SEP] Keyword[this] operator[SEP] identifier[encoder... |
public static String getParameterName(Parameter parameter) {
// identify parameter name and pattern from method signature
String methodParameterName = parameter.getName();
if (parameter.isAnnotationPresent(Param.class)) {
Param param = parameter.getAnnotation(Param.class);
... | class class_name[name] begin[{]
method[getParameterName, return_type[type[String]], modifier[public static], parameter[parameter]] begin[{]
local_variable[type[String], methodParameterName]
if[call[parameter.isAnnotationPresent, parameter[ClassReference(postfix_operators=[], prefix_oper... | Keyword[public] Keyword[static] identifier[String] identifier[getParameterName] operator[SEP] identifier[Parameter] identifier[parameter] operator[SEP] {
identifier[String] identifier[methodParameterName] operator[=] identifier[parameter] operator[SEP] identifier[getName] operator[SEP] operator[SEP] operator[SEP... |
public void doMain(String[] args)
{
int firstFileIndex = processOptions(args);
int fileCount = args.length - firstFileIndex;
String[] files = new String[fileCount];
System.arraycopy(args, firstFileIndex, files, 0, fileCount);
if (optionsAreValid(files))
{
... | class class_name[name] begin[{]
method[doMain, return_type[void], modifier[public], parameter[args]] begin[{]
local_variable[type[int], firstFileIndex]
local_variable[type[int], fileCount]
local_variable[type[String], files]
call[System.arraycopy, parameter[member[.args]... | Keyword[public] Keyword[void] identifier[doMain] operator[SEP] identifier[String] operator[SEP] operator[SEP] identifier[args] operator[SEP] {
Keyword[int] identifier[firstFileIndex] operator[=] identifier[processOptions] operator[SEP] identifier[args] operator[SEP] operator[SEP] Keyword[int] identifier[fileCoun... |
public void rmLittlePath() {
int maxTo = -1;
Term temp = null;
Term maxTerm = null;
// 是否有交叉
boolean flag = false;
final int length = terms.length - 1;
for (int i = 0; i < length; i++) {
maxTerm = getMaxTerm(i);
if (maxTerm == null) {
continue;
}
maxTo = maxTerm.toValue();
/**
* 对... | class class_name[name] begin[{]
method[rmLittlePath, return_type[void], modifier[public], parameter[]] begin[{]
local_variable[type[int], maxTo]
local_variable[type[Term], temp]
local_variable[type[Term], maxTerm]
local_variable[type[boolean], flag]
local_variable[type[i... | Keyword[public] Keyword[void] identifier[rmLittlePath] operator[SEP] operator[SEP] {
Keyword[int] identifier[maxTo] operator[=] operator[-] Other[1] operator[SEP] identifier[Term] identifier[temp] operator[=] Other[null] operator[SEP] identifier[Term] identifier[maxTerm] operator[=] Other[null] operator[SEP] Key... |
public static UnicodeUtil getInstance() {
if (instance == null) {
synchronized (UnicodeUtilImpl.class) {
if (instance == null) {
new UnicodeUtilImpl().initialize();
}
}
}
return instance;
} | class class_name[name] begin[{]
method[getInstance, return_type[type[UnicodeUtil]], modifier[public static], parameter[]] begin[{]
if[binary_operation[member[.instance], ==, literal[null]]] begin[{]
SYNCHRONIZED[ClassReference(postfix_operators=[], prefix_operators=[], q... | Keyword[public] Keyword[static] identifier[UnicodeUtil] identifier[getInstance] operator[SEP] operator[SEP] {
Keyword[if] operator[SEP] identifier[instance] operator[==] Other[null] operator[SEP] {
Keyword[synchronized] operator[SEP] identifier[UnicodeUtilImpl] operator[SEP] Keyword[class] operator[SE... |
public boolean isSet(_Fields field) {
if (field == null) {
throw new IllegalArgumentException();
}
switch (field) {
case STATUS:
return isSetStatus();
case METADATA_IN_JSON:
return isSetMetadataInJson();
case COLUMNS_LIST:
return isSetColumnsList();
case DATA_TYPE:
... | class class_name[name] begin[{]
method[isSet, return_type[type[boolean]], modifier[public], parameter[field]] begin[{]
if[binary_operation[member[.field], ==, literal[null]]] begin[{]
ThrowStatement(expression=ClassCreator(arguments=[], body=None, constructor_type_arguments=None, po... | Keyword[public] Keyword[boolean] identifier[isSet] operator[SEP] identifier[_Fields] identifier[field] operator[SEP] {
Keyword[if] operator[SEP] identifier[field] operator[==] Other[null] operator[SEP] {
Keyword[throw] Keyword[new] identifier[IllegalArgumentException] operator[SEP] operator[SEP] opera... |
protected void reportWorked(int workIncrement, int currentUnitIndex) {
if (this.progress != null) {
if (this.progress.isCanceled()) {
// Only AbortCompilation can stop the compiler cleanly.
// We check cancellation again following the call to compile.
... | class class_name[name] begin[{]
method[reportWorked, return_type[void], modifier[protected], parameter[workIncrement, currentUnitIndex]] begin[{]
if[binary_operation[THIS[member[None.progress]], !=, literal[null]]] begin[{]
if[THIS[member[None.progress]call[None.isCancel... | Keyword[protected] Keyword[void] identifier[reportWorked] operator[SEP] Keyword[int] identifier[workIncrement] , Keyword[int] identifier[currentUnitIndex] operator[SEP] {
Keyword[if] operator[SEP] Keyword[this] operator[SEP] identifier[progress] operator[!=] Other[null] operator[SEP] {
Keyword[if] op... |
public void zincrby(final byte[] key, final double score, final byte[] member) {
sendCommand(Command.ZINCRBY, key, RedisProtocol.toByteArray(score), member);
} | class class_name[name] begin[{]
method[zincrby, return_type[void], modifier[public], parameter[key, score, member]] begin[{]
call[.sendCommand, parameter[member[Command.ZINCRBY], member[.key], call[RedisProtocol.toByteArray, parameter[member[.score]]], member[.member]]]
end[}]
END[}] | Keyword[public] Keyword[void] identifier[zincrby] operator[SEP] Keyword[final] Keyword[byte] operator[SEP] operator[SEP] identifier[key] , Keyword[final] Keyword[double] identifier[score] , Keyword[final] Keyword[byte] operator[SEP] operator[SEP] identifier[member] operator[SEP] {
identifier[sendCommand] opera... |
private static Collection<ZipEntry> checkEntries(ZipFile zip, String path, String extension)
{
final Collection<ZipEntry> entries = new ArrayList<>();
final Enumeration<? extends ZipEntry> zipEntries = zip.entries();
while (zipEntries.hasMoreElements())
{
final ZipEntry e... | class class_name[name] begin[{]
method[checkEntries, return_type[type[Collection]], modifier[private static], parameter[zip, path, extension]] begin[{]
local_variable[type[Collection], entries]
local_variable[type[Enumeration], zipEntries]
while[call[zipEntries.hasMoreElements, ... | Keyword[private] Keyword[static] identifier[Collection] operator[<] identifier[ZipEntry] operator[>] identifier[checkEntries] operator[SEP] identifier[ZipFile] identifier[zip] , identifier[String] identifier[path] , identifier[String] identifier[extension] operator[SEP] {
Keyword[final] identifier[Collection] ... |
public void put_property(DbDatum property)
throws DevFailed {
DbAttribute db_att = new DbAttribute(deviceName);
db_att.add(property);
dev.put_attribute_property(db_att);
} | class class_name[name] begin[{]
method[put_property, return_type[void], modifier[public], parameter[property]] begin[{]
local_variable[type[DbAttribute], db_att]
call[db_att.add, parameter[member[.property]]]
call[dev.put_attribute_property, parameter[member[.db_att]]]
... | Keyword[public] Keyword[void] identifier[put_property] operator[SEP] identifier[DbDatum] identifier[property] operator[SEP] Keyword[throws] identifier[DevFailed] {
identifier[DbAttribute] identifier[db_att] operator[=] Keyword[new] identifier[DbAttribute] operator[SEP] identifier[deviceName] operator[SEP] operat... |
public BatchGetItemResult withResponses(java.util.Map<String, java.util.List<java.util.Map<String, AttributeValue>>> responses) {
setResponses(responses);
return this;
} | class class_name[name] begin[{]
method[withResponses, return_type[type[BatchGetItemResult]], modifier[public], parameter[responses]] begin[{]
call[.setResponses, parameter[member[.responses]]]
return[THIS[]]
end[}]
END[}] | Keyword[public] identifier[BatchGetItemResult] identifier[withResponses] operator[SEP] identifier[java] operator[SEP] identifier[util] operator[SEP] identifier[Map] operator[<] identifier[String] , identifier[java] operator[SEP] identifier[util] operator[SEP] identifier[List] operator[<] identifier[java] operator[SEP]... |
public Object nullMethodResult(Map context, Object target, String methodName, Object[] args)
{
return null;
} | class class_name[name] begin[{]
method[nullMethodResult, return_type[type[Object]], modifier[public], parameter[context, target, methodName, args]] begin[{]
return[literal[null]]
end[}]
END[}] | Keyword[public] identifier[Object] identifier[nullMethodResult] operator[SEP] identifier[Map] identifier[context] , identifier[Object] identifier[target] , identifier[String] identifier[methodName] , identifier[Object] operator[SEP] operator[SEP] identifier[args] operator[SEP] {
Keyword[return] Other[null] op... |
@VisibleForTesting
void clear() {
insertServiceName.clear();
if (insertRemoteServiceName != null) insertRemoteServiceName.clear();
insertSpanName.clear();
indexer.clear();
if (insertAutocompleteValue != null) insertAutocompleteValue.clear();
} | class class_name[name] begin[{]
method[clear, return_type[void], modifier[default], parameter[]] begin[{]
call[insertServiceName.clear, parameter[]]
if[binary_operation[member[.insertRemoteServiceName], !=, literal[null]]] begin[{]
call[insertRemoteServiceName.clear,... | annotation[@] identifier[VisibleForTesting] Keyword[void] identifier[clear] operator[SEP] operator[SEP] {
identifier[insertServiceName] operator[SEP] identifier[clear] operator[SEP] operator[SEP] operator[SEP] Keyword[if] operator[SEP] identifier[insertRemoteServiceName] operator[!=] Other[null] operator[SEP] id... |
protected boolean call(Object... paramListIn) {
m_perCallStats = m_statsCollector.beginProcedure();
// if we're keeping track, calculate parameter size
if (m_perCallStats.samplingProcedure()) {
ParameterSet params = ParameterSet.fromArrayNoCopy(paramListIn);
m_perCallSta... | class class_name[name] begin[{]
method[call, return_type[type[boolean]], modifier[protected], parameter[paramListIn]] begin[{]
assign[member[.m_perCallStats], call[m_statsCollector.beginProcedure, parameter[]]]
if[call[m_perCallStats.samplingProcedure, parameter[]]] begin[{]
... | Keyword[protected] Keyword[boolean] identifier[call] operator[SEP] identifier[Object] operator[...] identifier[paramListIn] operator[SEP] {
identifier[m_perCallStats] operator[=] identifier[m_statsCollector] operator[SEP] identifier[beginProcedure] operator[SEP] operator[SEP] operator[SEP] Keyword[if] operator[S... |
public String getSuperClientName()
{
ClassType superType = _clientDecl.getSuperclass();
while ( superType != null )
{
ClassDeclaration superDecl = superType.getDeclaration();
Collection<FieldDeclaration> declaredFields = superDecl.getFields();
for (Field... | class class_name[name] begin[{]
method[getSuperClientName, return_type[type[String]], modifier[public], parameter[]] begin[{]
local_variable[type[ClassType], superType]
while[binary_operation[member[.superType], !=, literal[null]]] begin[{]
local_variable[type[ClassDeclarati... | Keyword[public] identifier[String] identifier[getSuperClientName] operator[SEP] operator[SEP] {
identifier[ClassType] identifier[superType] operator[=] identifier[_clientDecl] operator[SEP] identifier[getSuperclass] operator[SEP] operator[SEP] operator[SEP] Keyword[while] operator[SEP] identifier[superType] oper... |
public static JSONObject parseObject(InputStream is, Charset charSet) throws IOException {
return (JSONObject)parse(is, charSet);
} | class class_name[name] begin[{]
method[parseObject, return_type[type[JSONObject]], modifier[public static], parameter[is, charSet]] begin[{]
return[Cast(expression=MethodInvocation(arguments=[MemberReference(member=is, postfix_operators=[], prefix_operators=[], qualifier=, selectors=[]), MemberReferenc... | Keyword[public] Keyword[static] identifier[JSONObject] identifier[parseObject] operator[SEP] identifier[InputStream] identifier[is] , identifier[Charset] identifier[charSet] operator[SEP] Keyword[throws] identifier[IOException] {
Keyword[return] operator[SEP] identifier[JSONObject] operator[SEP] identifier[pars... |
public double evaluate(PrintWriter fout) {
int i;
if (model.data.tstData.size() <= 0) {
return 0.0;
}
for (i = 0; i < humanLabelCounts.length; i++) {
humanLabelCounts[i] = 0;
modelLabelCounts[i] = 0;
humanModelCounts[i] = 0;
}
for (i = 0; i < model.data.tstData.size(); i... | class class_name[name] begin[{]
method[evaluate, return_type[type[double]], modifier[public], parameter[fout]] begin[{]
local_variable[type[int], i]
if[binary_operation[call[model.data.tstData.size, parameter[]], <=, literal[0]]] begin[{]
return[literal[0.0]]
else be... | Keyword[public] Keyword[double] identifier[evaluate] operator[SEP] identifier[PrintWriter] identifier[fout] operator[SEP] {
Keyword[int] identifier[i] operator[SEP] Keyword[if] operator[SEP] identifier[model] operator[SEP] identifier[data] operator[SEP] identifier[tstData] operator[SEP] identifier[size] operator... |
@Override
public void process(Packet message, MessageContext ctx)
{
EntityPlayerSP player = (EntityPlayerSP) Utils.getClientPlayer();
Container c = player.openContainer;
if (message.windowId != c.windowId || !(c instanceof MalisisInventoryContainer))
return;
MalisisInventoryContainer container = (MalisisI... | class class_name[name] begin[{]
method[process, return_type[void], modifier[public], parameter[message, ctx]] begin[{]
local_variable[type[EntityPlayerSP], player]
local_variable[type[Container], c]
if[binary_operation[binary_operation[member[message.windowId], !=, member[c.wind... | annotation[@] identifier[Override] Keyword[public] Keyword[void] identifier[process] operator[SEP] identifier[Packet] identifier[message] , identifier[MessageContext] identifier[ctx] operator[SEP] {
identifier[EntityPlayerSP] identifier[player] operator[=] operator[SEP] identifier[EntityPlayerSP] operator[SEP] ... |
protected static int safeToInt (String intstr)
{
if (!StringUtil.isBlank(intstr)) {
try {
return Integer.parseInt(intstr);
} catch (NumberFormatException nfe) {
}
}
return -1;
} | class class_name[name] begin[{]
method[safeToInt, return_type[type[int]], modifier[static protected], parameter[intstr]] begin[{]
if[call[StringUtil.isBlank, parameter[member[.intstr]]]] begin[{]
TryStatement(block=[ReturnStatement(expression=MethodInvocation(arguments=[MemberRefere... | Keyword[protected] Keyword[static] Keyword[int] identifier[safeToInt] operator[SEP] identifier[String] identifier[intstr] operator[SEP] {
Keyword[if] operator[SEP] operator[!] identifier[StringUtil] operator[SEP] identifier[isBlank] operator[SEP] identifier[intstr] operator[SEP] operator[SEP] {
Keywor... |
@Override
public SetRiskConfigurationResult setRiskConfiguration(SetRiskConfigurationRequest request) {
request = beforeClientExecution(request);
return executeSetRiskConfiguration(request);
} | class class_name[name] begin[{]
method[setRiskConfiguration, return_type[type[SetRiskConfigurationResult]], modifier[public], parameter[request]] begin[{]
assign[member[.request], call[.beforeClientExecution, parameter[member[.request]]]]
return[call[.executeSetRiskConfiguration, parame... | annotation[@] identifier[Override] Keyword[public] identifier[SetRiskConfigurationResult] identifier[setRiskConfiguration] operator[SEP] identifier[SetRiskConfigurationRequest] identifier[request] operator[SEP] {
identifier[request] operator[=] identifier[beforeClientExecution] operator[SEP] identifier[request] ... |
@Nullable
public static Cookie [] getRequestCookies (@Nullable final HttpServletRequest aRequest)
{
Cookie [] ret = null;
if (aRequest != null)
try
{
ret = aRequest.getCookies ();
}
catch (final Exception ex)
{
// fall through
if (isLogExceptions ())
... | class class_name[name] begin[{]
method[getRequestCookies, return_type[type[Cookie]], modifier[public static], parameter[aRequest]] begin[{]
local_variable[type[Cookie], ret]
if[binary_operation[member[.aRequest], !=, literal[null]]] begin[{]
TryStatement(block=[StatementExpression(expre... | annotation[@] identifier[Nullable] Keyword[public] Keyword[static] identifier[Cookie] operator[SEP] operator[SEP] identifier[getRequestCookies] operator[SEP] annotation[@] identifier[Nullable] Keyword[final] identifier[HttpServletRequest] identifier[aRequest] operator[SEP] {
identifier[Cookie] operator[SEP] oper... |
public com.squareup.okhttp.Call subscribeAsync(StatisticsSubscribeData statisticsSubscribeData, final ApiCallback<InlineResponse2002> callback) throws ApiException {
ProgressResponseBody.ProgressListener progressListener = null;
ProgressRequestBody.ProgressRequestListener progressRequestListener = null... | class class_name[name] begin[{]
method[subscribeAsync, return_type[type[com]], modifier[public], parameter[statisticsSubscribeData, callback]] begin[{]
local_variable[type[ProgressResponseBody], progressListener]
local_variable[type[ProgressRequestBody], progressRequestListener]
... | Keyword[public] identifier[com] operator[SEP] identifier[squareup] operator[SEP] identifier[okhttp] operator[SEP] identifier[Call] identifier[subscribeAsync] operator[SEP] identifier[StatisticsSubscribeData] identifier[statisticsSubscribeData] , Keyword[final] identifier[ApiCallback] operator[<] identifier[InlineRespo... |
@Override
public boolean eIsSet(int featureID)
{
switch (featureID)
{
case SimpleAntlrPackage.RULE_OPTIONS__OPTIONS:
return options != null;
case SimpleAntlrPackage.RULE_OPTIONS__ELEMENT:
return element != null;
}
return super.eIsSet(featureID);
} | class class_name[name] begin[{]
method[eIsSet, return_type[type[boolean]], modifier[public], parameter[featureID]] begin[{]
SwitchStatement(cases=[SwitchStatementCase(case=[MemberReference(member=RULE_OPTIONS__OPTIONS, postfix_operators=[], prefix_operators=[], qualifier=SimpleAntlrPackage, selectors=[... | annotation[@] identifier[Override] Keyword[public] Keyword[boolean] identifier[eIsSet] operator[SEP] Keyword[int] identifier[featureID] operator[SEP] {
Keyword[switch] operator[SEP] identifier[featureID] operator[SEP] {
Keyword[case] identifier[SimpleAntlrPackage] operator[SEP] identifier[RULE_OPTIONS... |
public List<URL> getAllPaths() {
List<URL> all = CollectUtils.newArrayList();
if (null != global) all.add(global);
if (null != locals) all.addAll(locals);
if (null != user) all.add(user);
return all;
} | class class_name[name] begin[{]
method[getAllPaths, return_type[type[List]], modifier[public], parameter[]] begin[{]
local_variable[type[List], all]
if[binary_operation[literal[null], !=, member[.global]]] begin[{]
call[all.add, parameter[member[.global]]]
else begin... | Keyword[public] identifier[List] operator[<] identifier[URL] operator[>] identifier[getAllPaths] operator[SEP] operator[SEP] {
identifier[List] operator[<] identifier[URL] operator[>] identifier[all] operator[=] identifier[CollectUtils] operator[SEP] identifier[newArrayList] operator[SEP] operator[SEP] operator[... |
private boolean checkZoneRequirement(HashMap<Integer, Integer> requiredRepFactor, int zoneId) {
if(requiredRepFactor.containsKey(zoneId)) {
if(requiredRepFactor.get(zoneId) == 0) {
return false;
} else {
requiredRepFactor.put(zoneId, requiredRepFactor.get(... | class class_name[name] begin[{]
method[checkZoneRequirement, return_type[type[boolean]], modifier[private], parameter[requiredRepFactor, zoneId]] begin[{]
if[call[requiredRepFactor.containsKey, parameter[member[.zoneId]]]] begin[{]
if[binary_operation[call[requiredRepFac... | Keyword[private] Keyword[boolean] identifier[checkZoneRequirement] operator[SEP] identifier[HashMap] operator[<] identifier[Integer] , identifier[Integer] operator[>] identifier[requiredRepFactor] , Keyword[int] identifier[zoneId] operator[SEP] {
Keyword[if] operator[SEP] identifier[requiredRepFactor] operator... |
public short[] getShortArray(final String key, final short[] def) {
try {
final short[] result = getShortArray(key);
return result != null ? result : def;
} catch (final NumberFormatException nfe) {
return def;
}
} | class class_name[name] begin[{]
method[getShortArray, return_type[type[short]], modifier[public], parameter[key, def]] begin[{]
TryStatement(block=[LocalVariableDeclaration(annotations=[], declarators=[VariableDeclarator(dimensions=[], initializer=MethodInvocation(arguments=[MemberReference(member=key,... | Keyword[public] Keyword[short] operator[SEP] operator[SEP] identifier[getShortArray] operator[SEP] Keyword[final] identifier[String] identifier[key] , Keyword[final] Keyword[short] operator[SEP] operator[SEP] identifier[def] operator[SEP] {
Keyword[try] {
Keyword[final] Keyword[short] operator[SEP] o... |
@Transient
public String getFormattedAddress() {
final Feature location = getLocation();
if (location == null) {
return null;
}
return location.getProperty("formattedAddress");
} | class class_name[name] begin[{]
method[getFormattedAddress, return_type[type[String]], modifier[public], parameter[]] begin[{]
local_variable[type[Feature], location]
if[binary_operation[member[.location], ==, literal[null]]] begin[{]
return[literal[null]]
else begin... | annotation[@] identifier[Transient] Keyword[public] identifier[String] identifier[getFormattedAddress] operator[SEP] operator[SEP] {
Keyword[final] identifier[Feature] identifier[location] operator[=] identifier[getLocation] operator[SEP] operator[SEP] operator[SEP] Keyword[if] operator[SEP] identifier[location]... |
public static void removeLinkRef(String name) throws NamingException
{
InitialContext ctx = new InitialContext();
removeLinkRef(ctx, name);
} | class class_name[name] begin[{]
method[removeLinkRef, return_type[void], modifier[public static], parameter[name]] begin[{]
local_variable[type[InitialContext], ctx]
call[.removeLinkRef, parameter[member[.ctx], member[.name]]]
end[}]
END[}] | Keyword[public] Keyword[static] Keyword[void] identifier[removeLinkRef] operator[SEP] identifier[String] identifier[name] operator[SEP] Keyword[throws] identifier[NamingException] {
identifier[InitialContext] identifier[ctx] operator[=] Keyword[new] identifier[InitialContext] operator[SEP] operator[SEP] operator... |
private void reloadProperties() {
Properties temp = new Properties();
BufferedReader bufferedReader = null;
try {
File properties = new File(propertiesPath);
bufferedReader = new BufferedReader(new InputStreamReader(new FileInputStream(properties), "UTF8"));
t... | class class_name[name] begin[{]
method[reloadProperties, return_type[void], modifier[private], parameter[]] begin[{]
local_variable[type[Properties], temp]
local_variable[type[BufferedReader], bufferedReader]
TryStatement(block=[LocalVariableDeclaration(annotations=[], declarators=[Vari... | Keyword[private] Keyword[void] identifier[reloadProperties] operator[SEP] operator[SEP] {
identifier[Properties] identifier[temp] operator[=] Keyword[new] identifier[Properties] operator[SEP] operator[SEP] operator[SEP] identifier[BufferedReader] identifier[bufferedReader] operator[=] Other[null] operator[SEP] K... |
public Discriminator getDiscriminator() {
if (tc.isEntryEnabled())
SibTr.entry(this, tc, "getDiscriminator");
if (tc.isEntryEnabled())
SibTr.exit(this, tc, "getDiscriminator", discriminator);
return discriminator;
} | class class_name[name] begin[{]
method[getDiscriminator, return_type[type[Discriminator]], modifier[public], parameter[]] begin[{]
if[call[tc.isEntryEnabled, parameter[]]] begin[{]
call[SibTr.entry, parameter[THIS[], member[.tc], literal["getDiscriminator"]]]
else begin[{]
N... | Keyword[public] identifier[Discriminator] identifier[getDiscriminator] operator[SEP] operator[SEP] {
Keyword[if] operator[SEP] identifier[tc] operator[SEP] identifier[isEntryEnabled] operator[SEP] operator[SEP] operator[SEP] identifier[SibTr] operator[SEP] identifier[entry] operator[SEP] Keyword[this] , identif... |
private Snapshot createMemorySnapshot(SnapshotDescriptor descriptor) {
HeapBuffer buffer = HeapBuffer.allocate(SnapshotDescriptor.BYTES, Integer.MAX_VALUE);
Snapshot snapshot = new MemorySnapshot(buffer, descriptor.copyTo(buffer), this);
LOGGER.debug("Created memory snapshot: {}", snapshot);
return snap... | class class_name[name] begin[{]
method[createMemorySnapshot, return_type[type[Snapshot]], modifier[private], parameter[descriptor]] begin[{]
local_variable[type[HeapBuffer], buffer]
local_variable[type[Snapshot], snapshot]
call[LOGGER.debug, parameter[literal["Created memory sna... | Keyword[private] identifier[Snapshot] identifier[createMemorySnapshot] operator[SEP] identifier[SnapshotDescriptor] identifier[descriptor] operator[SEP] {
identifier[HeapBuffer] identifier[buffer] operator[=] identifier[HeapBuffer] operator[SEP] identifier[allocate] operator[SEP] identifier[SnapshotDescriptor] o... |
private void addAgent(AsteriskAgentImpl agent)
{
synchronized (agents)
{
agents.put(agent.getAgentId(), agent);
}
server.fireNewAgent(agent);
} | class class_name[name] begin[{]
method[addAgent, return_type[void], modifier[private], parameter[agent]] begin[{]
SYNCHRONIZED[member[.agents]] BEGIN[{]
call[agents.put, parameter[call[agent.getAgentId, parameter[]], member[.agent]]]
END[}]
call[s... | Keyword[private] Keyword[void] identifier[addAgent] operator[SEP] identifier[AsteriskAgentImpl] identifier[agent] operator[SEP] {
Keyword[synchronized] operator[SEP] identifier[agents] operator[SEP] {
identifier[agents] operator[SEP] identifier[put] operator[SEP] identifier[agent] operator[SEP] identi... |
@Override
public <T extends ApiUser> List<T> getSpectatorsList() {
return CommandUtil.getApiUserList(room.getSpectatorsList());
} | class class_name[name] begin[{]
method[getSpectatorsList, return_type[type[List]], modifier[public], parameter[]] begin[{]
return[call[CommandUtil.getApiUserList, parameter[call[room.getSpectatorsList, parameter[]]]]]
end[}]
END[}] | annotation[@] identifier[Override] Keyword[public] operator[<] identifier[T] Keyword[extends] identifier[ApiUser] operator[>] identifier[List] operator[<] identifier[T] operator[>] identifier[getSpectatorsList] operator[SEP] operator[SEP] {
Keyword[return] identifier[CommandUtil] operator[SEP] identifier[getApiU... |
public void addExceptionHandler(Block block, String handler, List<? extends TypeMirror> thrownTypes)
{
Label label = getLabel(handler);
if (!thrownTypes.isEmpty())
{
for (TypeMirror thrownType : thrownTypes)
{
exceptionTableList.add(new Exceptio... | class class_name[name] begin[{]
method[addExceptionHandler, return_type[void], modifier[public], parameter[block, handler, thrownTypes]] begin[{]
local_variable[type[Label], label]
if[call[thrownTypes.isEmpty, parameter[]]] begin[{]
ForStatement(body=BlockStatement(label=Non... | Keyword[public] Keyword[void] identifier[addExceptionHandler] operator[SEP] identifier[Block] identifier[block] , identifier[String] identifier[handler] , identifier[List] operator[<] operator[?] Keyword[extends] identifier[TypeMirror] operator[>] identifier[thrownTypes] operator[SEP] {
identifier[Label] ident... |
@Override
public void eventFired(EventModel event) {
if (event.containsDescriptor(SoundIDs.StartRequest.descriptor)) {
Identification identification = event.getListResourceContainer().provideResource("izou.common.resource.selector").stream()
.map(ResourceModel::getResource)
... | class class_name[name] begin[{]
method[eventFired, return_type[void], modifier[public], parameter[event]] begin[{]
if[call[event.containsDescriptor, parameter[member[SoundIDs.StartRequest.descriptor]]]] begin[{]
local_variable[type[Identification], identification]
local_... | annotation[@] identifier[Override] Keyword[public] Keyword[void] identifier[eventFired] operator[SEP] identifier[EventModel] identifier[event] operator[SEP] {
Keyword[if] operator[SEP] identifier[event] operator[SEP] identifier[containsDescriptor] operator[SEP] identifier[SoundIDs] operator[SEP] identifier[Start... |
@Override
public boolean
hasNext()
{
int stop = this.rank;
switch (this.state) {
case INITIAL:
return true;
case STARTED:
int i;
for(i = stop - 1; i >= 0; i--) { // walk backwards
if(this.index.indices[i] <= this.endpoint[i]... | class class_name[name] begin[{]
method[hasNext, return_type[type[boolean]], modifier[public], parameter[]] begin[{]
local_variable[type[int], stop]
SwitchStatement(cases=[SwitchStatementCase(case=['INITIAL'], statements=[ReturnStatement(expression=Literal(postfix_operators=[], prefix_operators=... | annotation[@] identifier[Override] Keyword[public] Keyword[boolean] identifier[hasNext] operator[SEP] operator[SEP] {
Keyword[int] identifier[stop] operator[=] Keyword[this] operator[SEP] identifier[rank] operator[SEP] Keyword[switch] operator[SEP] Keyword[this] operator[SEP] identifier[state] operator[SEP] {
... |
@Override
public void retry(Face face, Interest interest, OnData onData, OnTimeout onTimeout) throws IOException {
RetryContext context = new RetryContext(face, interest, onData, onTimeout);
retryInterest(context);
} | class class_name[name] begin[{]
method[retry, return_type[void], modifier[public], parameter[face, interest, onData, onTimeout]] begin[{]
local_variable[type[RetryContext], context]
call[.retryInterest, parameter[member[.context]]]
end[}]
END[}] | annotation[@] identifier[Override] Keyword[public] Keyword[void] identifier[retry] operator[SEP] identifier[Face] identifier[face] , identifier[Interest] identifier[interest] , identifier[OnData] identifier[onData] , identifier[OnTimeout] identifier[onTimeout] operator[SEP] Keyword[throws] identifier[IOException] {... |
public static Object toData(TypedLiteral lit) {
if (lit == null) throw new IllegalArgumentException("Can't convert null literal");
Conversion<?> c = uriConversions.get(lit.getDataType());
if (c == null) throw new IllegalArgumentException("Don't know how to convert literal of type " + lit.getDataType());
... | class class_name[name] begin[{]
method[toData, return_type[type[Object]], modifier[public static], parameter[lit]] begin[{]
if[binary_operation[member[.lit], ==, literal[null]]] begin[{]
ThrowStatement(expression=ClassCreator(arguments=[Literal(postfix_operators=[], prefix_operators=[], qualifi... | Keyword[public] Keyword[static] identifier[Object] identifier[toData] operator[SEP] identifier[TypedLiteral] identifier[lit] operator[SEP] {
Keyword[if] operator[SEP] identifier[lit] operator[==] Other[null] operator[SEP] Keyword[throw] Keyword[new] identifier[IllegalArgumentException] operator[SEP] literal[Stri... |
public void addFormatter(Formatter formatter) {
if(_formatters == null)
_formatters = new ArrayList/*<Formatter>*/();
_formatters.add(formatter);
} | class class_name[name] begin[{]
method[addFormatter, return_type[void], modifier[public], parameter[formatter]] begin[{]
if[binary_operation[member[._formatters], ==, literal[null]]] begin[{]
assign[member[._formatters], ClassCreator(arguments=[], body=None, constructor_type_argumen... | Keyword[public] Keyword[void] identifier[addFormatter] operator[SEP] identifier[Formatter] identifier[formatter] operator[SEP] {
Keyword[if] operator[SEP] identifier[_formatters] operator[==] Other[null] operator[SEP] identifier[_formatters] operator[=] Keyword[new] identifier[ArrayList] operator[SEP] operator[S... |
public static String getClassFileName(Class<?> clazz) {
Assert.notNull(clazz, "Class must not be null");
String className = clazz.getName();
int lastDotIndex = className.lastIndexOf(PACKAGE_SEPARATOR);
return className.substring(lastDotIndex + 1) + CLASS_FILE_SUFFIX;
} | class class_name[name] begin[{]
method[getClassFileName, return_type[type[String]], modifier[public static], parameter[clazz]] begin[{]
call[Assert.notNull, parameter[member[.clazz], literal["Class must not be null"]]]
local_variable[type[String], className]
local_variable[type[... | Keyword[public] Keyword[static] identifier[String] identifier[getClassFileName] operator[SEP] identifier[Class] operator[<] operator[?] operator[>] identifier[clazz] operator[SEP] {
identifier[Assert] operator[SEP] identifier[notNull] operator[SEP] identifier[clazz] , literal[String] operator[SEP] operator[SEP]... |
public String[] getServiceDefinitions(Context context,
String PID,
Date asOfDateTime)
throws ServerException {
//m_ipRestriction.enforce(context);
return da.getServiceDefinitions(context, PID, asOfDateTime)... | class class_name[name] begin[{]
method[getServiceDefinitions, return_type[type[String]], modifier[public], parameter[context, PID, asOfDateTime]] begin[{]
return[call[da.getServiceDefinitions, parameter[member[.context], member[.PID], member[.asOfDateTime]]]]
end[}]
END[}] | Keyword[public] identifier[String] operator[SEP] operator[SEP] identifier[getServiceDefinitions] operator[SEP] identifier[Context] identifier[context] , identifier[String] identifier[PID] , identifier[Date] identifier[asOfDateTime] operator[SEP] Keyword[throws] identifier[ServerException] {
Keyword[return] ide... |
public Canvas draw (Drawable image, float x, float y, float w, float h) {
image.draw(gc(), x, y, w, h);
isDirty = true;
return this;
} | class class_name[name] begin[{]
method[draw, return_type[type[Canvas]], modifier[public], parameter[image, x, y, w, h]] begin[{]
call[image.draw, parameter[call[.gc, parameter[]], member[.x], member[.y], member[.w], member[.h]]]
assign[member[.isDirty], literal[true]]
re... | Keyword[public] identifier[Canvas] identifier[draw] operator[SEP] identifier[Drawable] identifier[image] , Keyword[float] identifier[x] , Keyword[float] identifier[y] , Keyword[float] identifier[w] , Keyword[float] identifier[h] operator[SEP] {
identifier[image] operator[SEP] identifier[draw] operator[SEP] i... |
@Override
public WithdrawByoipCidrResult withdrawByoipCidr(WithdrawByoipCidrRequest request) {
request = beforeClientExecution(request);
return executeWithdrawByoipCidr(request);
} | class class_name[name] begin[{]
method[withdrawByoipCidr, return_type[type[WithdrawByoipCidrResult]], modifier[public], parameter[request]] begin[{]
assign[member[.request], call[.beforeClientExecution, parameter[member[.request]]]]
return[call[.executeWithdrawByoipCidr, parameter[membe... | annotation[@] identifier[Override] Keyword[public] identifier[WithdrawByoipCidrResult] identifier[withdrawByoipCidr] operator[SEP] identifier[WithdrawByoipCidrRequest] identifier[request] operator[SEP] {
identifier[request] operator[=] identifier[beforeClientExecution] operator[SEP] identifier[request] operator[... |
public static boolean emsa_pss_verify(SignatureParamSpec spec, byte[] msg, byte[] EM, int emBits) {
int emLen = emBits >> 3;
if ((emBits & 7) != 0) {
emLen++;
}
byte[] mHash = hash(spec, msg);
// System.out.println("mHash: "+Utils.bytes2String(mHash));
Messa... | class class_name[name] begin[{]
method[emsa_pss_verify, return_type[type[boolean]], modifier[public static], parameter[spec, msg, EM, emBits]] begin[{]
local_variable[type[int], emLen]
if[binary_operation[binary_operation[member[.emBits], &, literal[7]], !=, literal[0]]] begin[{]
... | Keyword[public] Keyword[static] Keyword[boolean] identifier[emsa_pss_verify] operator[SEP] identifier[SignatureParamSpec] identifier[spec] , Keyword[byte] operator[SEP] operator[SEP] identifier[msg] , Keyword[byte] operator[SEP] operator[SEP] identifier[EM] , Keyword[int] identifier[emBits] operator[SEP] {
Ke... |
public int compareTo(Date anotherDate) {
long thisTime = getMillisOf(this);
long anotherTime = getMillisOf(anotherDate);
return (thisTime<anotherTime ? -1 : (thisTime==anotherTime ? 0 : 1));
} | class class_name[name] begin[{]
method[compareTo, return_type[type[int]], modifier[public], parameter[anotherDate]] begin[{]
local_variable[type[long], thisTime]
local_variable[type[long], anotherTime]
return[TernaryExpression(condition=BinaryOperation(operandl=MemberReference(member=th... | Keyword[public] Keyword[int] identifier[compareTo] operator[SEP] identifier[Date] identifier[anotherDate] operator[SEP] {
Keyword[long] identifier[thisTime] operator[=] identifier[getMillisOf] operator[SEP] Keyword[this] operator[SEP] operator[SEP] Keyword[long] identifier[anotherTime] operator[=] identifier[get... |
@NonNull
private Transition getTransition(@NonNull Scene scene) {
Transition transition;
ViewGroup sceneRoot = scene.getSceneRoot();
// TODO: cached in Scene instead? long-term, cache in View itself
Scene currScene = Scene.getCurrentScene(sceneRoot);
if (currScene != null) {
... | class class_name[name] begin[{]
method[getTransition, return_type[type[Transition]], modifier[private], parameter[scene]] begin[{]
local_variable[type[Transition], transition]
local_variable[type[ViewGroup], sceneRoot]
local_variable[type[Scene], currScene]
if[binary_ope... | annotation[@] identifier[NonNull] Keyword[private] identifier[Transition] identifier[getTransition] operator[SEP] annotation[@] identifier[NonNull] identifier[Scene] identifier[scene] operator[SEP] {
identifier[Transition] identifier[transition] operator[SEP] identifier[ViewGroup] identifier[sceneRoot] operator[... |
public void setResourceAwsIamAccessKeyCreatedAt(java.util.Collection<DateFilter> resourceAwsIamAccessKeyCreatedAt) {
if (resourceAwsIamAccessKeyCreatedAt == null) {
this.resourceAwsIamAccessKeyCreatedAt = null;
return;
}
this.resourceAwsIamAccessKeyCreatedAt = new java.u... | class class_name[name] begin[{]
method[setResourceAwsIamAccessKeyCreatedAt, return_type[void], modifier[public], parameter[resourceAwsIamAccessKeyCreatedAt]] begin[{]
if[binary_operation[member[.resourceAwsIamAccessKeyCreatedAt], ==, literal[null]]] begin[{]
assign[THIS[... | Keyword[public] Keyword[void] identifier[setResourceAwsIamAccessKeyCreatedAt] operator[SEP] identifier[java] operator[SEP] identifier[util] operator[SEP] identifier[Collection] operator[<] identifier[DateFilter] operator[>] identifier[resourceAwsIamAccessKeyCreatedAt] operator[SEP] {
Keyword[if] operator[SEP] id... |
@SuppressWarnings("unchecked")
public static List<Float> getAt(float[] array, ObjectRange range) {
return primitiveArrayGet(array, range);
} | class class_name[name] begin[{]
method[getAt, return_type[type[List]], modifier[public static], parameter[array, range]] begin[{]
return[call[.primitiveArrayGet, parameter[member[.array], member[.range]]]]
end[}]
END[}] | annotation[@] identifier[SuppressWarnings] operator[SEP] literal[String] operator[SEP] Keyword[public] Keyword[static] identifier[List] operator[<] identifier[Float] operator[>] identifier[getAt] operator[SEP] Keyword[float] operator[SEP] operator[SEP] identifier[array] , identifier[ObjectRange] identifier[range] oper... |
public static List<Certificate> loadCertificates(final Reader reader) throws IOException,
CertificateException {
try (PEMParser pemParser = new PEMParser(reader)) {
List<Certificate> certificates = new ArrayList<>();
JcaX509CertificateConverter certificateConverter = new Jca... | class class_name[name] begin[{]
method[loadCertificates, return_type[type[List]], modifier[public static], parameter[reader]] begin[{]
TryStatement(block=[LocalVariableDeclaration(annotations=[], declarators=[VariableDeclarator(dimensions=[], initializer=ClassCreator(arguments=[], body=None, constructo... | Keyword[public] Keyword[static] identifier[List] operator[<] identifier[Certificate] operator[>] identifier[loadCertificates] operator[SEP] Keyword[final] identifier[Reader] identifier[reader] operator[SEP] Keyword[throws] identifier[IOException] , identifier[CertificateException] {
Keyword[try] operator[SEP] i... |
public void marshall(ScheduleActivityTaskFailedEventAttributes scheduleActivityTaskFailedEventAttributes, ProtocolMarshaller protocolMarshaller) {
if (scheduleActivityTaskFailedEventAttributes == null) {
throw new SdkClientException("Invalid argument passed to marshall(...)");
}
tr... | class class_name[name] begin[{]
method[marshall, return_type[void], modifier[public], parameter[scheduleActivityTaskFailedEventAttributes, protocolMarshaller]] begin[{]
if[binary_operation[member[.scheduleActivityTaskFailedEventAttributes], ==, literal[null]]] begin[{]
ThrowStatemen... | Keyword[public] Keyword[void] identifier[marshall] operator[SEP] identifier[ScheduleActivityTaskFailedEventAttributes] identifier[scheduleActivityTaskFailedEventAttributes] , identifier[ProtocolMarshaller] identifier[protocolMarshaller] operator[SEP] {
Keyword[if] operator[SEP] identifier[scheduleActivityTaskFa... |
@Override
protected void runInto() throws JRebirthThreadException {
try {
// Call the innerRun available with package visibility
this.command.innerRun(this.wave);
} catch (final CommandException ce) {
// Log all exception thrown during the execution of this comma... | class class_name[name] begin[{]
method[runInto, return_type[void], modifier[protected], parameter[]] begin[{]
TryStatement(block=[StatementExpression(expression=This(postfix_operators=[], prefix_operators=[], qualifier=None, selectors=[MemberReference(member=command, postfix_operators=None, prefix_oper... | annotation[@] identifier[Override] Keyword[protected] Keyword[void] identifier[runInto] operator[SEP] operator[SEP] Keyword[throws] identifier[JRebirthThreadException] {
Keyword[try] {
Keyword[this] operator[SEP] identifier[command] operator[SEP] identifier[innerRun] operator[SEP] Keyword[this] operat... |
protected IDataStore newApplicationDataStore()
{
final StoreSettings storeSettings = getStoreSettings();
final Bytes maxSizePerSession = storeSettings.getMaxSizePerSession();
final File fileStoreFolder = storeSettings.getFileStoreFolder();
return new DiskDataStore(this.getName(), fileStoreFolder, maxSizePerSes... | class class_name[name] begin[{]
method[newApplicationDataStore, return_type[type[IDataStore]], modifier[protected], parameter[]] begin[{]
local_variable[type[StoreSettings], storeSettings]
local_variable[type[Bytes], maxSizePerSession]
local_variable[type[File], fileStoreFolder]
... | Keyword[protected] identifier[IDataStore] identifier[newApplicationDataStore] operator[SEP] operator[SEP] {
Keyword[final] identifier[StoreSettings] identifier[storeSettings] operator[=] identifier[getStoreSettings] operator[SEP] operator[SEP] operator[SEP] Keyword[final] identifier[Bytes] identifier[maxSizePerS... |
public List<MapRow> readTable(TableReader reader) throws IOException
{
reader.read();
return reader.getRows();
} | class class_name[name] begin[{]
method[readTable, return_type[type[List]], modifier[public], parameter[reader]] begin[{]
call[reader.read, parameter[]]
return[call[reader.getRows, parameter[]]]
end[}]
END[}] | Keyword[public] identifier[List] operator[<] identifier[MapRow] operator[>] identifier[readTable] operator[SEP] identifier[TableReader] identifier[reader] operator[SEP] Keyword[throws] identifier[IOException] {
identifier[reader] operator[SEP] identifier[read] operator[SEP] operator[SEP] operator[SEP] Keyword[re... |
protected ClassCollector createCollector(CompilationUnit unit, SourceUnit su) {
InnerLoader loader = AccessController.doPrivileged(new PrivilegedAction<InnerLoader>() {
public InnerLoader run() {
return new InnerLoader(GroovyClassLoader.this);
}
});
return... | class class_name[name] begin[{]
method[createCollector, return_type[type[ClassCollector]], modifier[protected], parameter[unit, su]] begin[{]
local_variable[type[InnerLoader], loader]
return[ClassCreator(arguments=[MemberReference(member=loader, postfix_operators=[], prefix_operators=[], qualif... | Keyword[protected] identifier[ClassCollector] identifier[createCollector] operator[SEP] identifier[CompilationUnit] identifier[unit] , identifier[SourceUnit] identifier[su] operator[SEP] {
identifier[InnerLoader] identifier[loader] operator[=] identifier[AccessController] operator[SEP] identifier[doPrivileged] ... |
@Override
public void play()
{
final String name = media.getPath();
if (Medias.getResourcesLoader().isPresent())
{
if (cache == null)
{
cache = extractFromJar(media);
}
play(cache, name);
}
else
{
... | class class_name[name] begin[{]
method[play, return_type[void], modifier[public], parameter[]] begin[{]
local_variable[type[String], name]
if[call[Medias.getResourcesLoader, parameter[]]] begin[{]
if[binary_operation[member[.cache], ==, literal[null]]] begin[{]
... | annotation[@] identifier[Override] Keyword[public] Keyword[void] identifier[play] operator[SEP] operator[SEP] {
Keyword[final] identifier[String] identifier[name] operator[=] identifier[media] operator[SEP] identifier[getPath] operator[SEP] operator[SEP] operator[SEP] Keyword[if] operator[SEP] identifier[Medias]... |
public static ErrorMessageFactory shouldNotBeBetween(Date actual, Date start, Date end, boolean inclusiveStart,
boolean inclusiveEnd) {
return new ShouldNotBeBetween(actual, start, end, inclusiveStart, inclusiveEnd);
} | class class_name[name] begin[{]
method[shouldNotBeBetween, return_type[type[ErrorMessageFactory]], modifier[public static], parameter[actual, start, end, inclusiveStart, inclusiveEnd]] begin[{]
return[ClassCreator(arguments=[MemberReference(member=actual, postfix_operators=[], prefix_operators=[], qual... | Keyword[public] Keyword[static] identifier[ErrorMessageFactory] identifier[shouldNotBeBetween] operator[SEP] identifier[Date] identifier[actual] , identifier[Date] identifier[start] , identifier[Date] identifier[end] , Keyword[boolean] identifier[inclusiveStart] , Keyword[boolean] identifier[inclusiveEnd] operator[... |
public static List<TransportAddress> convertInetSocketAddresses(List<InetSocketAddress> inetSocketAddresses) {
if (inetSocketAddresses == null) {
return null;
} else {
List<TransportAddress> converted;
converted = new ArrayList<>(inetSocketAddresses.size());
for (InetSocketAddress address : inetSocketAd... | class class_name[name] begin[{]
method[convertInetSocketAddresses, return_type[type[List]], modifier[public static], parameter[inetSocketAddresses]] begin[{]
if[binary_operation[member[.inetSocketAddresses], ==, literal[null]]] begin[{]
return[literal[null]]
else begin[{]
... | Keyword[public] Keyword[static] identifier[List] operator[<] identifier[TransportAddress] operator[>] identifier[convertInetSocketAddresses] operator[SEP] identifier[List] operator[<] identifier[InetSocketAddress] operator[>] identifier[inetSocketAddresses] operator[SEP] {
Keyword[if] operator[SEP] identifier[in... |
@Override
public RegionLocator getRegionLocator(TableName tableName) throws IOException {
RegionLocator locator = getCachedLocator(tableName);
if (locator == null) {
locator = new BigtableRegionLocator(tableName, getOptions(), getSession().getDataClientWrapper()) {
@Override
public Sam... | class class_name[name] begin[{]
method[getRegionLocator, return_type[type[RegionLocator]], modifier[public], parameter[tableName]] begin[{]
local_variable[type[RegionLocator], locator]
if[binary_operation[member[.locator], ==, literal[null]]] begin[{]
assign[memb... | annotation[@] identifier[Override] Keyword[public] identifier[RegionLocator] identifier[getRegionLocator] operator[SEP] identifier[TableName] identifier[tableName] operator[SEP] Keyword[throws] identifier[IOException] {
identifier[RegionLocator] identifier[locator] operator[=] identifier[getCachedLocator] operat... |
public java.util.Map<String, java.util.List<String>> getSecretVersionsToStages() {
return secretVersionsToStages;
} | class class_name[name] begin[{]
method[getSecretVersionsToStages, return_type[type[java]], modifier[public], parameter[]] begin[{]
return[member[.secretVersionsToStages]]
end[}]
END[}] | Keyword[public] identifier[java] operator[SEP] identifier[util] operator[SEP] identifier[Map] operator[<] identifier[String] , identifier[java] operator[SEP] identifier[util] operator[SEP] identifier[List] operator[<] identifier[String] operator[>] operator[>] identifier[getSecretVersionsToStages] operator[SEP] operat... |
public void setReadReplicaDBClusterIdentifiers(java.util.Collection<String> readReplicaDBClusterIdentifiers) {
if (readReplicaDBClusterIdentifiers == null) {
this.readReplicaDBClusterIdentifiers = null;
return;
}
this.readReplicaDBClusterIdentifiers = new com.amazonaws.i... | class class_name[name] begin[{]
method[setReadReplicaDBClusterIdentifiers, return_type[void], modifier[public], parameter[readReplicaDBClusterIdentifiers]] begin[{]
if[binary_operation[member[.readReplicaDBClusterIdentifiers], ==, literal[null]]] begin[{]
assign[THIS[mem... | Keyword[public] Keyword[void] identifier[setReadReplicaDBClusterIdentifiers] operator[SEP] identifier[java] operator[SEP] identifier[util] operator[SEP] identifier[Collection] operator[<] identifier[String] operator[>] identifier[readReplicaDBClusterIdentifiers] operator[SEP] {
Keyword[if] operator[SEP] identifi... |
public InstrumentationResult instrument(byte[] input, InstrumentationSettings settings) {
Validate.notNull(input);
Validate.notNull(settings);
Validate.isTrue(input.length > 0);
// Read class as tree model -- because we're using SimpleClassNode, JSR blocks get inlined
ClassRea... | class class_name[name] begin[{]
method[instrument, return_type[type[InstrumentationResult]], modifier[public], parameter[input, settings]] begin[{]
call[Validate.notNull, parameter[member[.input]]]
call[Validate.notNull, parameter[member[.settings]]]
call[Validat... | Keyword[public] identifier[InstrumentationResult] identifier[instrument] operator[SEP] Keyword[byte] operator[SEP] operator[SEP] identifier[input] , identifier[InstrumentationSettings] identifier[settings] operator[SEP] {
identifier[Validate] operator[SEP] identifier[notNull] operator[SEP] identifier[input] ope... |
public void marshall(ImportSourceCredentialsRequest importSourceCredentialsRequest, ProtocolMarshaller protocolMarshaller) {
if (importSourceCredentialsRequest == null) {
throw new SdkClientException("Invalid argument passed to marshall(...)");
}
try {
protocolMarshalle... | class class_name[name] begin[{]
method[marshall, return_type[void], modifier[public], parameter[importSourceCredentialsRequest, protocolMarshaller]] begin[{]
if[binary_operation[member[.importSourceCredentialsRequest], ==, literal[null]]] begin[{]
ThrowStatement(expression=ClassCrea... | Keyword[public] Keyword[void] identifier[marshall] operator[SEP] identifier[ImportSourceCredentialsRequest] identifier[importSourceCredentialsRequest] , identifier[ProtocolMarshaller] identifier[protocolMarshaller] operator[SEP] {
Keyword[if] operator[SEP] identifier[importSourceCredentialsRequest] operator[==]... |
public void printDualGraph() {
System.out.println("============= Dual");
int l = BoofMiscOps.numDigits(vertexes.size);
String format = "%"+l+"d";
for( Vertex n : vertexes.toList() ) {
ChessboardCorner c = corners.get(n.index);
System.out.printf("["+format+"] {%3.0f, %3.0f} -> 90[ ",n.index,c.x,c.y);
... | class class_name[name] begin[{]
method[printDualGraph, return_type[void], modifier[public], parameter[]] begin[{]
call[System.out.println, parameter[literal["============= Dual"]]]
local_variable[type[int], l]
local_variable[type[String], format]
ForStatement(body=BlockS... | Keyword[public] Keyword[void] identifier[printDualGraph] operator[SEP] operator[SEP] {
identifier[System] operator[SEP] identifier[out] operator[SEP] identifier[println] operator[SEP] literal[String] operator[SEP] operator[SEP] Keyword[int] identifier[l] operator[=] identifier[BoofMiscOps] operator[SEP] identifi... |
@NotNull
public static List<String> toList(@Nullable final String stringList, @NotNull final String delimiter) {
return new ArrayList<>(Arrays.asList(toArray(stringList, delimiter)));
} | class class_name[name] begin[{]
method[toList, return_type[type[List]], modifier[public static], parameter[stringList, delimiter]] begin[{]
return[ClassCreator(arguments=[MethodInvocation(arguments=[MethodInvocation(arguments=[MemberReference(member=stringList, postfix_operators=[], prefix_operators=[]... | annotation[@] identifier[NotNull] Keyword[public] Keyword[static] identifier[List] operator[<] identifier[String] operator[>] identifier[toList] operator[SEP] annotation[@] identifier[Nullable] Keyword[final] identifier[String] identifier[stringList] , annotation[@] identifier[NotNull] Keyword[final] identifier[String... |
public Content getContentsList(DeprecatedAPIListBuilder deprapi) {
Content headContent = getResource("doclet.Deprecated_API");
Content heading = HtmlTree.HEADING(HtmlConstants.TITLE_HEADING, true,
HtmlStyle.title, headContent);
Content div = HtmlTree.DIV(HtmlStyle.header, heading... | class class_name[name] begin[{]
method[getContentsList, return_type[type[Content]], modifier[public], parameter[deprapi]] begin[{]
local_variable[type[Content], headContent]
local_variable[type[Content], heading]
local_variable[type[Content], div]
local_variable[type[Content], h... | Keyword[public] identifier[Content] identifier[getContentsList] operator[SEP] identifier[DeprecatedAPIListBuilder] identifier[deprapi] operator[SEP] {
identifier[Content] identifier[headContent] operator[=] identifier[getResource] operator[SEP] literal[String] operator[SEP] operator[SEP] identifier[Content] iden... |
public static <T> Optional<T> getValueOptional(Object target, String dPath, Class<T> clazz) {
return Optional.ofNullable(getValue(target, dPath, clazz));
} | class class_name[name] begin[{]
method[getValueOptional, return_type[type[Optional]], modifier[public static], parameter[target, dPath, clazz]] begin[{]
return[call[Optional.ofNullable, parameter[call[.getValue, parameter[member[.target], member[.dPath], member[.clazz]]]]]]
end[}]
END[}] | Keyword[public] Keyword[static] operator[<] identifier[T] operator[>] identifier[Optional] operator[<] identifier[T] operator[>] identifier[getValueOptional] operator[SEP] identifier[Object] identifier[target] , identifier[String] identifier[dPath] , identifier[Class] operator[<] identifier[T] operator[>] identifier[... |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.