code stringlengths 63 466k | code_sememe stringlengths 141 3.79M | token_type stringlengths 274 1.23M |
|---|---|---|
public void perform() {
for (int i = 0; i < operations.size(); i++) {
operations.get(i).process();
}
} | class class_name[name] begin[{]
method[perform, return_type[void], modifier[public], parameter[]] begin[{]
ForStatement(body=BlockStatement(label=None, statements=[StatementExpression(expression=MethodInvocation(arguments=[MemberReference(member=i, postfix_operators=[], prefix_operators=[], qualifier=,... | Keyword[public] Keyword[void] identifier[perform] operator[SEP] operator[SEP] {
Keyword[for] operator[SEP] Keyword[int] identifier[i] operator[=] Other[0] operator[SEP] identifier[i] operator[<] identifier[operations] operator[SEP] identifier[size] operator[SEP] operator[SEP] operator[SEP] identifier[i] operator... |
public USCBYPSIDEN createUSCBYPSIDENFromString(EDataType eDataType, String initialValue) {
USCBYPSIDEN result = USCBYPSIDEN.get(initialValue);
if (result == null) throw new IllegalArgumentException("The value '" + initialValue + "' is not a valid enumerator of '" + eDataType.getName() + "'");
return result;
} | class class_name[name] begin[{]
method[createUSCBYPSIDENFromString, return_type[type[USCBYPSIDEN]], modifier[public], parameter[eDataType, initialValue]] begin[{]
local_variable[type[USCBYPSIDEN], result]
if[binary_operation[member[.result], ==, literal[null]]] begin[{]
ThrowStatement(e... | Keyword[public] identifier[USCBYPSIDEN] identifier[createUSCBYPSIDENFromString] operator[SEP] identifier[EDataType] identifier[eDataType] , identifier[String] identifier[initialValue] operator[SEP] {
identifier[USCBYPSIDEN] identifier[result] operator[=] identifier[USCBYPSIDEN] operator[SEP] identifier[get] ope... |
private void putFrame() {
final int nLocal = currentFrame[1];
final int nStack = currentFrame[2];
if (symbolTable.getMajorVersion() < Opcodes.V1_6) {
// Generate a StackMap attribute entry, which are always uncompressed.
stackMapTableEntries.putShort(currentFrame[0]).putShort(nLocal);
putA... | class class_name[name] begin[{]
method[putFrame, return_type[void], modifier[private], parameter[]] begin[{]
local_variable[type[int], nLocal]
local_variable[type[int], nStack]
if[binary_operation[call[symbolTable.getMajorVersion, parameter[]], <, member[Opcodes.V1_6]]] begin[{]... | Keyword[private] Keyword[void] identifier[putFrame] operator[SEP] operator[SEP] {
Keyword[final] Keyword[int] identifier[nLocal] operator[=] identifier[currentFrame] operator[SEP] Other[1] operator[SEP] operator[SEP] Keyword[final] Keyword[int] identifier[nStack] operator[=] identifier[currentFrame] operator[SEP... |
private List<CmsResource> getResources() {
List<CmsResource> result = new LinkedList<CmsResource>();
CmsObject cms = getCms();
CmsResourceFilter filter = CmsResourceFilter.ALL;
try {
for (String path : m_paths) {
List<CmsResource> resources = cms.readResource... | class class_name[name] begin[{]
method[getResources, return_type[type[List]], modifier[private], parameter[]] begin[{]
local_variable[type[List], result]
local_variable[type[CmsObject], cms]
local_variable[type[CmsResourceFilter], filter]
TryStatement(block=[ForStatement(body=Bl... | Keyword[private] identifier[List] operator[<] identifier[CmsResource] operator[>] identifier[getResources] operator[SEP] operator[SEP] {
identifier[List] operator[<] identifier[CmsResource] operator[>] identifier[result] operator[=] Keyword[new] identifier[LinkedList] operator[<] identifier[CmsResource] operator... |
KJoin newJoin(final KJoin join) {
return new KJoin() {
@Override
public boolean isEnabled(KProcess process) {
return !process.getElementsInError().contains(KWhileLoop.this) && predicate.verify(process)
&& (started.contains(process) || join
.isEnabled(process));
}
@Override
public vo... | class class_name[name] begin[{]
method[newJoin, return_type[type[KJoin]], modifier[default], parameter[join]] begin[{]
return[ClassCreator(arguments=[], body=[MethodDeclaration(annotations=[Annotation(element=None, name=Override)], body=[ReturnStatement(expression=BinaryOperation(operandl=BinaryOperati... | identifier[KJoin] identifier[newJoin] operator[SEP] Keyword[final] identifier[KJoin] identifier[join] operator[SEP] {
Keyword[return] Keyword[new] identifier[KJoin] operator[SEP] operator[SEP] {
annotation[@] identifier[Override] Keyword[public] Keyword[boolean] identifier[isEnabled] operator[SEP] ide... |
@Programmatic
public ApplicationTenancy newTenancy(
final String name,
final String path,
final ApplicationTenancy parent) {
ApplicationTenancy tenancy = findByPath(path);
if (tenancy == null) {
tenancy = getApplicationTenancyFactory().newApplicationTe... | class class_name[name] begin[{]
method[newTenancy, return_type[type[ApplicationTenancy]], modifier[public], parameter[name, path, parent]] begin[{]
local_variable[type[ApplicationTenancy], tenancy]
if[binary_operation[member[.tenancy], ==, literal[null]]] begin[{]
... | annotation[@] identifier[Programmatic] Keyword[public] identifier[ApplicationTenancy] identifier[newTenancy] operator[SEP] Keyword[final] identifier[String] identifier[name] , Keyword[final] identifier[String] identifier[path] , Keyword[final] identifier[ApplicationTenancy] identifier[parent] operator[SEP] {
i... |
void setPathToNamesInternal(Set<GeneralNameInterface> names) {
// set names to non-null dummy value
// this breaks getPathToNames()
pathToNames = Collections.<List<?>>emptySet();
pathToGeneralNames = names;
} | class class_name[name] begin[{]
method[setPathToNamesInternal, return_type[void], modifier[default], parameter[names]] begin[{]
assign[member[.pathToNames], call[.Collections, parameter[]]]
assign[member[.pathToGeneralNames], member[.names]]
end[}]
END[}] | Keyword[void] identifier[setPathToNamesInternal] operator[SEP] identifier[Set] operator[<] identifier[GeneralNameInterface] operator[>] identifier[names] operator[SEP] {
identifier[pathToNames] operator[=] identifier[Collections] operator[SEP] operator[<] identifier[List] operator[<] operator[?] operator[>] oper... |
public static Map<String, String> jsonize(String msgFormat, Object... args)
{
return ImmutableMap.of("error", StringUtils.nonStrictFormat(msgFormat, args));
} | class class_name[name] begin[{]
method[jsonize, return_type[type[Map]], modifier[public static], parameter[msgFormat, args]] begin[{]
return[call[ImmutableMap.of, parameter[literal["error"], call[StringUtils.nonStrictFormat, parameter[member[.msgFormat], member[.args]]]]]]
end[}]
END[}] | Keyword[public] Keyword[static] identifier[Map] operator[<] identifier[String] , identifier[String] operator[>] identifier[jsonize] operator[SEP] identifier[String] identifier[msgFormat] , identifier[Object] operator[...] identifier[args] operator[SEP] {
Keyword[return] identifier[ImmutableMap] operator[SEP] i... |
@Override
public long getLogFileTimestamp(File file) {
String name = file.getName();
// Check name for extension
if (name == null || name.length() == 0 || !name.startsWith(TEXTLOGPREF) || !name.endsWith(TEXTLOGEXT)) {
return -1L;
}
long result = -1L;
try {
Date date = DATEFORMAT.parse(name.substring(... | class class_name[name] begin[{]
method[getLogFileTimestamp, return_type[type[long]], modifier[public], parameter[file]] begin[{]
local_variable[type[String], name]
if[binary_operation[binary_operation[binary_operation[binary_operation[member[.name], ==, literal[null]], ||, binary_operat... | annotation[@] identifier[Override] Keyword[public] Keyword[long] identifier[getLogFileTimestamp] operator[SEP] identifier[File] identifier[file] operator[SEP] {
identifier[String] identifier[name] operator[=] identifier[file] operator[SEP] identifier[getName] operator[SEP] operator[SEP] operator[SEP] Keyword[if]... |
public ListenableFuture<Boolean> deleteAsync(final TwilioRestClient client) {
return Twilio.getExecutorService().submit(new Callable<Boolean>() {
public Boolean call() {
return delete(client);
}
});
} | class class_name[name] begin[{]
method[deleteAsync, return_type[type[ListenableFuture]], modifier[public], parameter[client]] begin[{]
return[call[Twilio.getExecutorService, parameter[]]]
end[}]
END[}] | Keyword[public] identifier[ListenableFuture] operator[<] identifier[Boolean] operator[>] identifier[deleteAsync] operator[SEP] Keyword[final] identifier[TwilioRestClient] identifier[client] operator[SEP] {
Keyword[return] identifier[Twilio] operator[SEP] identifier[getExecutorService] operator[SEP] operator[SEP]... |
public Result<MoveAlongSurfaceResult> moveAlongSurface(long startRef, float[] startPos, float[] endPos,
QueryFilter filter) {
// Validate input
if (!m_nav.isValidPolyRef(startRef) || Objects.isNull(startPos) || !vIsFinite(startPos)
|| Objects.isNull(endPos) || !vIsFinite(end... | class class_name[name] begin[{]
method[moveAlongSurface, return_type[type[Result]], modifier[public], parameter[startRef, startPos, endPos, filter]] begin[{]
if[binary_operation[binary_operation[binary_operation[binary_operation[binary_operation[call[m_nav.isValidPolyRef, parameter[member[.star... | Keyword[public] identifier[Result] operator[<] identifier[MoveAlongSurfaceResult] operator[>] identifier[moveAlongSurface] operator[SEP] Keyword[long] identifier[startRef] , Keyword[float] operator[SEP] operator[SEP] identifier[startPos] , Keyword[float] operator[SEP] operator[SEP] identifier[endPos] , identifier[Qu... |
public Optional<AlertCondition> update(AlertCondition condition)
{
return HTTP.PUT(String.format("/v2/alerts_conditions/%d.json", condition.getId()), condition, ALERT_CONDITION);
} | class class_name[name] begin[{]
method[update, return_type[type[Optional]], modifier[public], parameter[condition]] begin[{]
return[call[HTTP.PUT, parameter[call[String.format, parameter[literal["/v2/alerts_conditions/%d.json"], call[condition.getId, parameter[]]]], member[.condition], member[.ALERT_CO... | Keyword[public] identifier[Optional] operator[<] identifier[AlertCondition] operator[>] identifier[update] operator[SEP] identifier[AlertCondition] identifier[condition] operator[SEP] {
Keyword[return] identifier[HTTP] operator[SEP] identifier[PUT] operator[SEP] identifier[String] operator[SEP] identifier[format... |
private void ensureColumn(FieldDescriptorDef fieldDef, String checkLevel)
{
if (!fieldDef.hasProperty(PropertyHelper.OJB_PROPERTY_COLUMN))
{
String javaname = fieldDef.getName();
if (fieldDef.isNested())
{
int pos = javaname.indexOf(":... | class class_name[name] begin[{]
method[ensureColumn, return_type[void], modifier[private], parameter[fieldDef, checkLevel]] begin[{]
if[call[fieldDef.hasProperty, parameter[member[PropertyHelper.OJB_PROPERTY_COLUMN]]]] begin[{]
local_variable[type[String], javaname]
... | Keyword[private] Keyword[void] identifier[ensureColumn] operator[SEP] identifier[FieldDescriptorDef] identifier[fieldDef] , identifier[String] identifier[checkLevel] operator[SEP] {
Keyword[if] operator[SEP] operator[!] identifier[fieldDef] operator[SEP] identifier[hasProperty] operator[SEP] identifier[Property... |
private static void addFunctionDependence(Function function, Procedure procedure, Statement catalogStmt) {
String funcDeps = function.getStmtdependers();
Set<String> stmtSet = new TreeSet<>();
for (String stmtName : funcDeps.split(",")) {
if (! stmtName.isEmpty()) {
s... | class class_name[name] begin[{]
method[addFunctionDependence, return_type[void], modifier[private static], parameter[function, procedure, catalogStmt]] begin[{]
local_variable[type[String], funcDeps]
local_variable[type[Set], stmtSet]
ForStatement(body=BlockStatement(label=None, stateme... | Keyword[private] Keyword[static] Keyword[void] identifier[addFunctionDependence] operator[SEP] identifier[Function] identifier[function] , identifier[Procedure] identifier[procedure] , identifier[Statement] identifier[catalogStmt] operator[SEP] {
identifier[String] identifier[funcDeps] operator[=] identifier[f... |
private void cleanFlagReactiveCenter(IAtomContainer ac) {
for (int j = 0; j < ac.getAtomCount(); j++)
ac.getAtom(j).setFlag(CDKConstants.REACTIVE_CENTER, false);
for (int j = 0; j < ac.getBondCount(); j++)
ac.getBond(j).setFlag(CDKConstants.REACTIVE_CENTER, false);
} | class class_name[name] begin[{]
method[cleanFlagReactiveCenter, return_type[void], modifier[private], parameter[ac]] begin[{]
ForStatement(body=StatementExpression(expression=MethodInvocation(arguments=[MemberReference(member=j, postfix_operators=[], prefix_operators=[], qualifier=, selectors=[])], mem... | Keyword[private] Keyword[void] identifier[cleanFlagReactiveCenter] operator[SEP] identifier[IAtomContainer] identifier[ac] operator[SEP] {
Keyword[for] operator[SEP] Keyword[int] identifier[j] operator[=] Other[0] operator[SEP] identifier[j] operator[<] identifier[ac] operator[SEP] identifier[getAtomCount] opera... |
private PGPKeyRingGenerator createKeyRingGenerator(String userId, String password, int keySize) {
LOGGER.trace("createKeyRingGenerator(String, String, int)");
LOGGER.trace("User ID: {}, Password: {}, Key Size: {}", userId, password == null ? "not set" : "********", keySize);
PGPKeyRingGenerator generator = ... | class class_name[name] begin[{]
method[createKeyRingGenerator, return_type[type[PGPKeyRingGenerator]], modifier[private], parameter[userId, password, keySize]] begin[{]
call[LOGGER.trace, parameter[literal["createKeyRingGenerator(String, String, int)"]]]
call[LOGGER.trace, param... | Keyword[private] identifier[PGPKeyRingGenerator] identifier[createKeyRingGenerator] operator[SEP] identifier[String] identifier[userId] , identifier[String] identifier[password] , Keyword[int] identifier[keySize] operator[SEP] {
identifier[LOGGER] operator[SEP] identifier[trace] operator[SEP] literal[String] o... |
public void addSite(String siteKey) {
ValueMap gv = new ValueMap(siteKey);
if (!this.valueMaps.contains(gv)) {
this.valueMaps.add(gv);
}
} | class class_name[name] begin[{]
method[addSite, return_type[void], modifier[public], parameter[siteKey]] begin[{]
local_variable[type[ValueMap], gv]
if[THIS[member[None.valueMaps]call[None.contains, parameter[member[.gv]]]]] begin[{]
THIS[member[None.valueMaps]ca... | Keyword[public] Keyword[void] identifier[addSite] operator[SEP] identifier[String] identifier[siteKey] operator[SEP] {
identifier[ValueMap] identifier[gv] operator[=] Keyword[new] identifier[ValueMap] operator[SEP] identifier[siteKey] operator[SEP] operator[SEP] Keyword[if] operator[SEP] operator[!] Keyword[this... |
public static void dec_lag3( /* Decode the pitch lag */
int index, /* input : received pitch index */
int pit_min, /* input : minimum pitch lag */
int pit_max, /* input : maximum pitch lag */
int i_subfr, /* input : subframe flag ... | class class_name[name] begin[{]
method[dec_lag3, return_type[void], modifier[public static], parameter[index, pit_min, pit_max, i_subfr, T0, T0_frac]] begin[{]
local_variable[type[int], i]
local_variable[type[int], T0_min]
if[binary_operation[member[.i_subfr], ==, literal[0]]] b... | Keyword[public] Keyword[static] Keyword[void] identifier[dec_lag3] operator[SEP] Keyword[int] identifier[index] , Keyword[int] identifier[pit_min] , Keyword[int] identifier[pit_max] , Keyword[int] identifier[i_subfr] , identifier[IntegerPointer] identifier[T0] , identifier[IntegerPointer] identifier[T0_frac] opera... |
public static final ThreadHistoryEvent created(long threadId, String threadName){
return new ThreadHistoryEvent(threadId, threadName, OPERATION.CREATED);
} | class class_name[name] begin[{]
method[created, return_type[type[ThreadHistoryEvent]], modifier[final public static], parameter[threadId, threadName]] begin[{]
return[ClassCreator(arguments=[MemberReference(member=threadId, postfix_operators=[], prefix_operators=[], qualifier=, selectors=[]), MemberRef... | Keyword[public] Keyword[static] Keyword[final] identifier[ThreadHistoryEvent] identifier[created] operator[SEP] Keyword[long] identifier[threadId] , identifier[String] identifier[threadName] operator[SEP] {
Keyword[return] Keyword[new] identifier[ThreadHistoryEvent] operator[SEP] identifier[threadId] , identif... |
void switchTwoRows(int rowIndex, int rowToIndex) {
checkForInit();
int cellData = mRowHeights[rowToIndex];
mRowHeights[rowToIndex] = mRowHeights[rowIndex];
mRowHeights[rowIndex] = cellData;
} | class class_name[name] begin[{]
method[switchTwoRows, return_type[void], modifier[default], parameter[rowIndex, rowToIndex]] begin[{]
call[.checkForInit, parameter[]]
local_variable[type[int], cellData]
assign[member[.mRowHeights], member[.mRowHeights]]
a... | Keyword[void] identifier[switchTwoRows] operator[SEP] Keyword[int] identifier[rowIndex] , Keyword[int] identifier[rowToIndex] operator[SEP] {
identifier[checkForInit] operator[SEP] operator[SEP] operator[SEP] Keyword[int] identifier[cellData] operator[=] identifier[mRowHeights] operator[SEP] identifier[rowToInd... |
public Observable<DatabaseInner> pauseAsync(String resourceGroupName, String serverName, String databaseName) {
return pauseWithServiceResponseAsync(resourceGroupName, serverName, databaseName).map(new Func1<ServiceResponse<DatabaseInner>, DatabaseInner>() {
@Override
public DatabaseInne... | class class_name[name] begin[{]
method[pauseAsync, return_type[type[Observable]], modifier[public], parameter[resourceGroupName, serverName, databaseName]] begin[{]
return[call[.pauseWithServiceResponseAsync, parameter[member[.resourceGroupName], member[.serverName], member[.databaseName]]]]
end[}]... | Keyword[public] identifier[Observable] operator[<] identifier[DatabaseInner] operator[>] identifier[pauseAsync] operator[SEP] identifier[String] identifier[resourceGroupName] , identifier[String] identifier[serverName] , identifier[String] identifier[databaseName] operator[SEP] {
Keyword[return] identifier[pau... |
public static boolean cs_happly(DZcs V, int i, double beta, DZcsa x)
{
int p, Vp[], Vi[] ;
DZcsa Vx = new DZcsa() ;
double[] tau = cs_czero() ;
if (!CS_CSC (V) || x == null) return (false) ; /* check inputs */
Vp = V.p ; Vi = V.i ; Vx.x = V.x ;
for (p = Vp [i] ; p < Vp [i+1] ; p++) /* tau = v'*x */... | class class_name[name] begin[{]
method[cs_happly, return_type[type[boolean]], modifier[public static], parameter[V, i, beta, x]] begin[{]
local_variable[type[int], p]
local_variable[type[DZcsa], Vx]
local_variable[type[double], tau]
if[binary_operation[call[.CS_CSC, para... | Keyword[public] Keyword[static] Keyword[boolean] identifier[cs_happly] operator[SEP] identifier[DZcs] identifier[V] , Keyword[int] identifier[i] , Keyword[double] identifier[beta] , identifier[DZcsa] identifier[x] operator[SEP] {
Keyword[int] identifier[p] , identifier[Vp] operator[SEP] operator[SEP] , iden... |
public static List<Pattern> getNoProxyHostPatterns(String noProxyHost) {
if (noProxyHost==null) return Collections.emptyList();
List<Pattern> r = Lists.newArrayList();
for (String s : noProxyHost.split("[ \t\n,|]+")) {
if (s.length()==0) continue;
r.add(Pattern.compile... | class class_name[name] begin[{]
method[getNoProxyHostPatterns, return_type[type[List]], modifier[public static], parameter[noProxyHost]] begin[{]
if[binary_operation[member[.noProxyHost], ==, literal[null]]] begin[{]
return[call[Collections.emptyList, parameter[]]]
else begin[{]
None
... | Keyword[public] Keyword[static] identifier[List] operator[<] identifier[Pattern] operator[>] identifier[getNoProxyHostPatterns] operator[SEP] identifier[String] identifier[noProxyHost] operator[SEP] {
Keyword[if] operator[SEP] identifier[noProxyHost] operator[==] Other[null] operator[SEP] Keyword[return] identif... |
private VoltTable[] aggregateProcedureStats(VoltTable[] baseStats)
{
if (baseStats == null || baseStats.length != 1) {
return baseStats;
}
VoltTable result = new VoltTable(
new ColumnInfo("TIMESTAMP", VoltType.BIGINT),
new ColumnInfo(VoltSystemProcedure.C... | class class_name[name] begin[{]
method[aggregateProcedureStats, return_type[type[VoltTable]], modifier[private], parameter[baseStats]] begin[{]
if[binary_operation[binary_operation[member[.baseStats], ==, literal[null]], ||, binary_operation[member[baseStats.length], !=, literal[1]]]] begin[{]
... | Keyword[private] identifier[VoltTable] operator[SEP] operator[SEP] identifier[aggregateProcedureStats] operator[SEP] identifier[VoltTable] operator[SEP] operator[SEP] identifier[baseStats] operator[SEP] {
Keyword[if] operator[SEP] identifier[baseStats] operator[==] Other[null] operator[||] identifier[baseStats] ... |
public static Polynomial wrap( double ...coefficients ) {
Polynomial p = new Polynomial(coefficients.length);
p.setTo(coefficients,coefficients.length);
return p;
} | class class_name[name] begin[{]
method[wrap, return_type[type[Polynomial]], modifier[public static], parameter[coefficients]] begin[{]
local_variable[type[Polynomial], p]
call[p.setTo, parameter[member[.coefficients], member[coefficients.length]]]
return[member[.p]]
end[}]
E... | Keyword[public] Keyword[static] identifier[Polynomial] identifier[wrap] operator[SEP] Keyword[double] operator[...] identifier[coefficients] operator[SEP] {
identifier[Polynomial] identifier[p] operator[=] Keyword[new] identifier[Polynomial] operator[SEP] identifier[coefficients] operator[SEP] identifier[length]... |
private static boolean matchesPrototypeInstanceVar(Node node, NodeMetadata metadata,
String name) {
String[] parts = name.split(".prototype.");
String className = parts[0];
String propertyName = parts[1];
JSType providedJsType = getJsType(metadata, className);
if (providedJsType == null) {
... | class class_name[name] begin[{]
method[matchesPrototypeInstanceVar, return_type[type[boolean]], modifier[private static], parameter[node, metadata, name]] begin[{]
local_variable[type[String], parts]
local_variable[type[String], className]
local_variable[type[String], propertyName]
... | Keyword[private] Keyword[static] Keyword[boolean] identifier[matchesPrototypeInstanceVar] operator[SEP] identifier[Node] identifier[node] , identifier[NodeMetadata] identifier[metadata] , identifier[String] identifier[name] operator[SEP] {
identifier[String] operator[SEP] operator[SEP] identifier[parts] operat... |
public void setProxyClass(Class newProxyClass)
{
proxyClass = newProxyClass;
if (proxyClass == null)
{
setProxyClassName(null);
}
else
{
proxyClassName = proxyClass.getName();
}
} | class class_name[name] begin[{]
method[setProxyClass, return_type[void], modifier[public], parameter[newProxyClass]] begin[{]
assign[member[.proxyClass], member[.newProxyClass]]
if[binary_operation[member[.proxyClass], ==, literal[null]]] begin[{]
call[.s... | Keyword[public] Keyword[void] identifier[setProxyClass] operator[SEP] identifier[Class] identifier[newProxyClass] operator[SEP] {
identifier[proxyClass] operator[=] identifier[newProxyClass] operator[SEP] Keyword[if] operator[SEP] identifier[proxyClass] operator[==] Other[null] operator[SEP] {
identif... |
void addTransactionManager(TransactionManager transactionManager) {
if (transactionManager == null) return;
this.transactionManagers.add(new TransactionManagerDefinition(transactionManager.name()));
} | class class_name[name] begin[{]
method[addTransactionManager, return_type[void], modifier[default], parameter[transactionManager]] begin[{]
if[binary_operation[member[.transactionManager], ==, literal[null]]] begin[{]
return[None]
else begin[{]
None
end[}]
THIS[m... | Keyword[void] identifier[addTransactionManager] operator[SEP] identifier[TransactionManager] identifier[transactionManager] operator[SEP] {
Keyword[if] operator[SEP] identifier[transactionManager] operator[==] Other[null] operator[SEP] Keyword[return] operator[SEP] Keyword[this] operator[SEP] identifier[transact... |
private boolean matches6004( ApiDifference apiDiff )
{
throwIfMissing( true, false, true, true );
if ( !SelectorUtils.matchPath( field, apiDiff.getAffectedField() ) )
{
return false;
}
String[] args = getArgs( apiDiff );
String diffFrom = args[0];
... | class class_name[name] begin[{]
method[matches6004, return_type[type[boolean]], modifier[private], parameter[apiDiff]] begin[{]
call[.throwIfMissing, parameter[literal[true], literal[false], literal[true], literal[true]]]
if[call[SelectorUtils.matchPath, parameter[member[.field]... | Keyword[private] Keyword[boolean] identifier[matches6004] operator[SEP] identifier[ApiDifference] identifier[apiDiff] operator[SEP] {
identifier[throwIfMissing] operator[SEP] literal[boolean] , literal[boolean] , literal[boolean] , literal[boolean] operator[SEP] operator[SEP] Keyword[if] operator[SEP] operato... |
public <R> R doInContext(SearchContext context, Supplier<R> action) {
R result;
if (context == null) {
result = action.get();
} else {
// store current context (without triggering exception if it was stale)
SearchContext currentSearchContext = currentContext;
... | class class_name[name] begin[{]
method[doInContext, return_type[type[R]], modifier[public], parameter[context, action]] begin[{]
local_variable[type[R], result]
if[binary_operation[member[.context], ==, literal[null]]] begin[{]
assign[member[.result], call[action... | Keyword[public] operator[<] identifier[R] operator[>] identifier[R] identifier[doInContext] operator[SEP] identifier[SearchContext] identifier[context] , identifier[Supplier] operator[<] identifier[R] operator[>] identifier[action] operator[SEP] {
identifier[R] identifier[result] operator[SEP] Keyword[if] opera... |
public static synchronized void loadLibrary(File jar) throws NoAvailableBackendException {
try {
/*We are using reflection here to circumvent encapsulation; addURL is not public*/
java.net.URLClassLoader loader = (java.net.URLClassLoader) ClassLoader.getSystemClassLoader();
j... | class class_name[name] begin[{]
method[loadLibrary, return_type[void], modifier[synchronized public static], parameter[jar]] begin[{]
TryStatement(block=[LocalVariableDeclaration(annotations=[], declarators=[VariableDeclarator(dimensions=[], initializer=Cast(expression=MethodInvocation(arguments=[], me... | Keyword[public] Keyword[static] Keyword[synchronized] Keyword[void] identifier[loadLibrary] operator[SEP] identifier[File] identifier[jar] operator[SEP] Keyword[throws] identifier[NoAvailableBackendException] {
Keyword[try] {
identifier[java] operator[SEP] identifier[net] operator[SEP] identifier[URLC... |
@XmlElementDecl(namespace = "http://www.opengis.net/gml", name = "maximalComplex")
public JAXBElement<TopoComplexMemberType> createMaximalComplex(TopoComplexMemberType value) {
return new JAXBElement<TopoComplexMemberType>(_MaximalComplex_QNAME, TopoComplexMemberType.class, null, value);
} | class class_name[name] begin[{]
method[createMaximalComplex, return_type[type[JAXBElement]], modifier[public], parameter[value]] begin[{]
return[ClassCreator(arguments=[MemberReference(member=_MaximalComplex_QNAME, postfix_operators=[], prefix_operators=[], qualifier=, selectors=[]), ClassReference(pos... | annotation[@] identifier[XmlElementDecl] operator[SEP] identifier[namespace] operator[=] literal[String] , identifier[name] operator[=] literal[String] operator[SEP] Keyword[public] identifier[JAXBElement] operator[<] identifier[TopoComplexMemberType] operator[>] identifier[createMaximalComplex] operator[SEP] identifi... |
private static BoxRetentionPolicy.Info createRetentionPolicy(BoxAPIConnection api, String name, String type,
int length, String action) {
return createRetentionPolicy(api, name, type, length, action, null);
} | class class_name[name] begin[{]
method[createRetentionPolicy, return_type[type[BoxRetentionPolicy]], modifier[private static], parameter[api, name, type, length, action]] begin[{]
return[call[.createRetentionPolicy, parameter[member[.api], member[.name], member[.type], member[.length], member[.action],... | Keyword[private] Keyword[static] identifier[BoxRetentionPolicy] operator[SEP] identifier[Info] identifier[createRetentionPolicy] operator[SEP] identifier[BoxAPIConnection] identifier[api] , identifier[String] identifier[name] , identifier[String] identifier[type] , Keyword[int] identifier[length] , identifier[Strin... |
public void setBooleanParameter(BooleanParameterType newBooleanParameter) {
((FeatureMap.Internal)getMixed()).set(BpsimPackage.Literals.DOCUMENT_ROOT__BOOLEAN_PARAMETER, newBooleanParameter);
} | class class_name[name] begin[{]
method[setBooleanParameter, return_type[void], modifier[public], parameter[newBooleanParameter]] begin[{]
Cast(expression=MethodInvocation(arguments=[], member=getMixed, postfix_operators=[], prefix_operators=[], qualifier=, selectors=[], type_arguments=None), ty... | Keyword[public] Keyword[void] identifier[setBooleanParameter] operator[SEP] identifier[BooleanParameterType] identifier[newBooleanParameter] operator[SEP] {
operator[SEP] operator[SEP] identifier[FeatureMap] operator[SEP] identifier[Internal] operator[SEP] identifier[getMixed] operator[SEP] operator[SEP] operato... |
public void setDeveloperUserIdentifierList(java.util.Collection<String> developerUserIdentifierList) {
if (developerUserIdentifierList == null) {
this.developerUserIdentifierList = null;
return;
}
this.developerUserIdentifierList = new java.util.ArrayList<String>(develop... | class class_name[name] begin[{]
method[setDeveloperUserIdentifierList, return_type[void], modifier[public], parameter[developerUserIdentifierList]] begin[{]
if[binary_operation[member[.developerUserIdentifierList], ==, literal[null]]] begin[{]
assign[THIS[member[None.dev... | Keyword[public] Keyword[void] identifier[setDeveloperUserIdentifierList] operator[SEP] identifier[java] operator[SEP] identifier[util] operator[SEP] identifier[Collection] operator[<] identifier[String] operator[>] identifier[developerUserIdentifierList] operator[SEP] {
Keyword[if] operator[SEP] identifier[devel... |
public static Point2D_F64 closestPoint( LineSegment2D_F64 line,
Point2D_F64 p,
Point2D_F64 output ) {
if( output == null )
output = new Point2D_F64();
double slopeX = line.b.x - line.a.x;
double slopeY = line.b.y - line.a.y;
double t = slopeX * ( p.x - line.a.x ) + slopeY * ( p.y - l... | class class_name[name] begin[{]
method[closestPoint, return_type[type[Point2D_F64]], modifier[public static], parameter[line, p, output]] begin[{]
if[binary_operation[member[.output], ==, literal[null]]] begin[{]
assign[member[.output], ClassCreator(arguments=[], body=None, construc... | Keyword[public] Keyword[static] identifier[Point2D_F64] identifier[closestPoint] operator[SEP] identifier[LineSegment2D_F64] identifier[line] , identifier[Point2D_F64] identifier[p] , identifier[Point2D_F64] identifier[output] operator[SEP] {
Keyword[if] operator[SEP] identifier[output] operator[==] Other[null... |
@NotNull
public Map<String,Integer> extractCountedGrams(@NotNull CharSequence text) {
text = applyPadding(text);
int len = text.length();
int initialCapacity = 0;
for (Integer gramLength : gramLengths) {
initialCapacity += guessNumDistinctiveGrams(len, gramLength);
... | class class_name[name] begin[{]
method[extractCountedGrams, return_type[type[Map]], modifier[public], parameter[text]] begin[{]
assign[member[.text], call[.applyPadding, parameter[member[.text]]]]
local_variable[type[int], len]
local_variable[type[int], initialCapacity]
... | annotation[@] identifier[NotNull] Keyword[public] identifier[Map] operator[<] identifier[String] , identifier[Integer] operator[>] identifier[extractCountedGrams] operator[SEP] annotation[@] identifier[NotNull] identifier[CharSequence] identifier[text] operator[SEP] {
identifier[text] operator[=] identifier[app... |
public StringClauses append(Enum name, StringClauses subclauses) {
return this.append(name.name(), subclauses);
} | class class_name[name] begin[{]
method[append, return_type[type[StringClauses]], modifier[public], parameter[name, subclauses]] begin[{]
return[THIS[call[None.append, parameter[call[name.name, parameter[]], member[.subclauses]]]]]
end[}]
END[}] | Keyword[public] identifier[StringClauses] identifier[append] operator[SEP] identifier[Enum] identifier[name] , identifier[StringClauses] identifier[subclauses] operator[SEP] {
Keyword[return] Keyword[this] operator[SEP] identifier[append] operator[SEP] identifier[name] operator[SEP] identifier[name] operator[SE... |
public static String replaceFullRequestContent(
String requestContentTemplate, String replacementString) {
return (requestContentTemplate.replace(
PcConstants.COMMAND_VAR_DEFAULT_REQUEST_CONTENT,
replacementString));
} | class class_name[name] begin[{]
method[replaceFullRequestContent, return_type[type[String]], modifier[public static], parameter[requestContentTemplate, replacementString]] begin[{]
return[call[requestContentTemplate.replace, parameter[member[PcConstants.COMMAND_VAR_DEFAULT_REQUEST_CONTENT], member[.rep... | Keyword[public] Keyword[static] identifier[String] identifier[replaceFullRequestContent] operator[SEP] identifier[String] identifier[requestContentTemplate] , identifier[String] identifier[replacementString] operator[SEP] {
Keyword[return] operator[SEP] identifier[requestContentTemplate] operator[SEP] identifie... |
public static void setAdditionalPreference(CmsObject cms, String key, String value) {
CmsUser user = cms.getRequestContext().getCurrentUser();
CmsUserSettings settings = new CmsUserSettings(user);
settings.setAdditionalPreference(key, value);
try {
settings.save(cms);
... | class class_name[name] begin[{]
method[setAdditionalPreference, return_type[void], modifier[public static], parameter[cms, key, value]] begin[{]
local_variable[type[CmsUser], user]
local_variable[type[CmsUserSettings], settings]
call[settings.setAdditionalPreference, parameter[m... | Keyword[public] Keyword[static] Keyword[void] identifier[setAdditionalPreference] operator[SEP] identifier[CmsObject] identifier[cms] , identifier[String] identifier[key] , identifier[String] identifier[value] operator[SEP] {
identifier[CmsUser] identifier[user] operator[=] identifier[cms] operator[SEP] identi... |
@NullSafe
private File validateDirectory(File directory) {
return Optional.ofNullable(directory).filter(File::isDirectory)
.orElseThrow(() -> newIllegalArgumentException("File [%s] is not a valid directory", directory));
} | class class_name[name] begin[{]
method[validateDirectory, return_type[type[File]], modifier[private], parameter[directory]] begin[{]
return[call[Optional.ofNullable, parameter[member[.directory]]]]
end[}]
END[}] | annotation[@] identifier[NullSafe] Keyword[private] identifier[File] identifier[validateDirectory] operator[SEP] identifier[File] identifier[directory] operator[SEP] {
Keyword[return] identifier[Optional] operator[SEP] identifier[ofNullable] operator[SEP] identifier[directory] operator[SEP] operator[SEP] identif... |
public Object getRepeatedField(final FieldDescriptorType descriptor,
final int index) {
if (!descriptor.isRepeated()) {
throw new IllegalArgumentException(
"getRepeatedField() can only be called on repeated fields.");
}
final Object value = getField(descriptor... | class class_name[name] begin[{]
method[getRepeatedField, return_type[type[Object]], modifier[public], parameter[descriptor, index]] begin[{]
if[call[descriptor.isRepeated, parameter[]]] begin[{]
ThrowStatement(expression=ClassCreator(arguments=[Literal(postfix_operators=[], prefix_o... | Keyword[public] identifier[Object] identifier[getRepeatedField] operator[SEP] Keyword[final] identifier[FieldDescriptorType] identifier[descriptor] , Keyword[final] Keyword[int] identifier[index] operator[SEP] {
Keyword[if] operator[SEP] operator[!] identifier[descriptor] operator[SEP] identifier[isRepeated] op... |
public void setAll(Map<String, String> params) {
for (Map.Entry<String, String> entry : params.entrySet()) {
setParameter(entry.getKey(), entry.getValue());
}
} | class class_name[name] begin[{]
method[setAll, return_type[void], modifier[public], parameter[params]] begin[{]
ForStatement(body=BlockStatement(label=None, statements=[StatementExpression(expression=MethodInvocation(arguments=[MethodInvocation(arguments=[], member=getKey, postfix_operators=[], prefix_... | Keyword[public] Keyword[void] identifier[setAll] operator[SEP] identifier[Map] operator[<] identifier[String] , identifier[String] operator[>] identifier[params] operator[SEP] {
Keyword[for] operator[SEP] identifier[Map] operator[SEP] identifier[Entry] operator[<] identifier[String] , identifier[String] operat... |
public List<GanttDesignerRemark.Task> getTask()
{
if (task == null)
{
task = new ArrayList<GanttDesignerRemark.Task>();
}
return this.task;
} | class class_name[name] begin[{]
method[getTask, return_type[type[List]], modifier[public], parameter[]] begin[{]
if[binary_operation[member[.task], ==, literal[null]]] begin[{]
assign[member[.task], ClassCreator(arguments=[], body=None, constructor_type_arguments=None, p... | Keyword[public] identifier[List] operator[<] identifier[GanttDesignerRemark] operator[SEP] identifier[Task] operator[>] identifier[getTask] operator[SEP] operator[SEP] {
Keyword[if] operator[SEP] identifier[task] operator[==] Other[null] operator[SEP] {
identifier[task] operator[=] Keyword[new] identi... |
public static Endpoint update(final String domainId, final String endpointId, final String password,
final String applicationId, final String description, final boolean enabled) throws AppPlatformException, ParseException, Exception {
final BandwidthClient client = BandwidthClient.getInstance();
... | class class_name[name] begin[{]
method[update, return_type[type[Endpoint]], modifier[public static], parameter[domainId, endpointId, password, applicationId, description, enabled]] begin[{]
local_variable[type[BandwidthClient], client]
AssertStatement(condition=BinaryOperation(operandl=MemberRe... | Keyword[public] Keyword[static] identifier[Endpoint] identifier[update] operator[SEP] Keyword[final] identifier[String] identifier[domainId] , Keyword[final] identifier[String] identifier[endpointId] , Keyword[final] identifier[String] identifier[password] , Keyword[final] identifier[String] identifier[applicationId... |
public static <T extends View> T mount(T v, Renderable r) {
Mount m = new Mount(v, r);
mounts.put(v, m);
render(v);
return v;
} | class class_name[name] begin[{]
method[mount, return_type[type[T]], modifier[public static], parameter[v, r]] begin[{]
local_variable[type[Mount], m]
call[mounts.put, parameter[member[.v], member[.m]]]
call[.render, parameter[member[.v]]]
return[member[.v]]
e... | Keyword[public] Keyword[static] operator[<] identifier[T] Keyword[extends] identifier[View] operator[>] identifier[T] identifier[mount] operator[SEP] identifier[T] identifier[v] , identifier[Renderable] identifier[r] operator[SEP] {
identifier[Mount] identifier[m] operator[=] Keyword[new] identifier[Mount] oper... |
public BaseField setupField(int iFieldSeq)
{
BaseField field = null;
//if (iFieldSeq == 0)
//{
// field = new CounterField(this, ID, Constants.DEFAULT_FIELD_LENGTH, null, null);
// field.setHidden(true);
//}
//if (iFieldSeq == 1)
//{
// fiel... | class class_name[name] begin[{]
method[setupField, return_type[type[BaseField]], modifier[public], parameter[iFieldSeq]] begin[{]
local_variable[type[BaseField], field]
if[binary_operation[member[.iFieldSeq], ==, literal[3]]] begin[{]
assign[member[.field], ClassCreator(argu... | Keyword[public] identifier[BaseField] identifier[setupField] operator[SEP] Keyword[int] identifier[iFieldSeq] operator[SEP] {
identifier[BaseField] identifier[field] operator[=] Other[null] operator[SEP] Keyword[if] operator[SEP] identifier[iFieldSeq] operator[==] Other[3] operator[SEP] identifier[field] operato... |
public String toFirstUpper(String name) {
if (name.length() == 0) {
return name;
} else {
return name.substring(0, 1).toUpperCase() + name.substring(1);
}
} | class class_name[name] begin[{]
method[toFirstUpper, return_type[type[String]], modifier[public], parameter[name]] begin[{]
if[binary_operation[call[name.length, parameter[]], ==, literal[0]]] begin[{]
return[member[.name]]
else begin[{]
return[binary_operation[c... | Keyword[public] identifier[String] identifier[toFirstUpper] operator[SEP] identifier[String] identifier[name] operator[SEP] {
Keyword[if] operator[SEP] identifier[name] operator[SEP] identifier[length] operator[SEP] operator[SEP] operator[==] Other[0] operator[SEP] {
Keyword[return] identifier[name] o... |
public static DbArtifact createDbArtifact(final String gavc) {
final DbArtifact artifact = new DbArtifact();
final String[] artifactInfo = gavc.split(":");
if(artifactInfo.length > 0){
artifact.setGroupId(artifactInfo[0]);
}
if(artifactInfo.length > 1){
... | class class_name[name] begin[{]
method[createDbArtifact, return_type[type[DbArtifact]], modifier[public static], parameter[gavc]] begin[{]
local_variable[type[DbArtifact], artifact]
local_variable[type[String], artifactInfo]
if[binary_operation[member[artifactInfo.length], >, li... | Keyword[public] Keyword[static] identifier[DbArtifact] identifier[createDbArtifact] operator[SEP] Keyword[final] identifier[String] identifier[gavc] operator[SEP] {
Keyword[final] identifier[DbArtifact] identifier[artifact] operator[=] Keyword[new] identifier[DbArtifact] operator[SEP] operator[SEP] operator[SEP]... |
private static byte[] deobfuscateBytes(byte[] source) {
byte[] result = new byte[source.length - 1];
System.arraycopy(source, 1, result, 0, source.length - 1);
for (int i = 0; i < result.length; i++) {
result[i] = (byte)(0xFF & (result[i] ^ source[0]));
}
return resu... | class class_name[name] begin[{]
method[deobfuscateBytes, return_type[type[byte]], modifier[private static], parameter[source]] begin[{]
local_variable[type[byte], result]
call[System.arraycopy, parameter[member[.source], literal[1], member[.result], literal[0], binary_operation[member[s... | Keyword[private] Keyword[static] Keyword[byte] operator[SEP] operator[SEP] identifier[deobfuscateBytes] operator[SEP] Keyword[byte] operator[SEP] operator[SEP] identifier[source] operator[SEP] {
Keyword[byte] operator[SEP] operator[SEP] identifier[result] operator[=] Keyword[new] Keyword[byte] operator[SEP] iden... |
protected void adjustPositionY(int velocityY) {
int childCount = getChildCount();
if (childCount > 0) {
int curPosition = ViewUtils.getCenterYChildPosition(this);
int childHeight = getHeight() - getPaddingTop() - getPaddingBottom();
int flingCount = getFlingCount(velo... | class class_name[name] begin[{]
method[adjustPositionY, return_type[void], modifier[protected], parameter[velocityY]] begin[{]
local_variable[type[int], childCount]
if[binary_operation[member[.childCount], >, literal[0]]] begin[{]
local_variable[type[int], curPosition]
... | Keyword[protected] Keyword[void] identifier[adjustPositionY] operator[SEP] Keyword[int] identifier[velocityY] operator[SEP] {
Keyword[int] identifier[childCount] operator[=] identifier[getChildCount] operator[SEP] operator[SEP] operator[SEP] Keyword[if] operator[SEP] identifier[childCount] operator[>] Other[0] o... |
public Rectangular hsplit(Rectangular other)
{
if (this.intersects(other))
{
Rectangular a = new Rectangular(this);
Rectangular b = new Rectangular(this);
if (a.x2 > other.x1 - 1) a.x2 = other.x1 - 1;
if (b.x1 < other.x2 + 1) b.x1 = other.x2 + 1;
... | class class_name[name] begin[{]
method[hsplit, return_type[type[Rectangular]], modifier[public], parameter[other]] begin[{]
if[THIS[call[None.intersects, parameter[member[.other]]]]] begin[{]
local_variable[type[Rectangular], a]
local_variable[type[Rectangular], b]
... | Keyword[public] identifier[Rectangular] identifier[hsplit] operator[SEP] identifier[Rectangular] identifier[other] operator[SEP] {
Keyword[if] operator[SEP] Keyword[this] operator[SEP] identifier[intersects] operator[SEP] identifier[other] operator[SEP] operator[SEP] {
identifier[Rectangular] identifi... |
public final void doFilter(final ServletRequest pRequest, final ServletResponse pResponse, final FilterChain pFilterChain) throws IOException, ServletException {
// If request filter and already run, continue chain and return fast
if (oncePerRequest && isRunOnce(pRequest)) {
pFilterChain.... | class class_name[name] begin[{]
method[doFilter, return_type[void], modifier[final public], parameter[pRequest, pResponse, pFilterChain]] begin[{]
if[binary_operation[member[.oncePerRequest], &&, call[.isRunOnce, parameter[member[.pRequest]]]]] begin[{]
call[pFilterChain... | Keyword[public] Keyword[final] Keyword[void] identifier[doFilter] operator[SEP] Keyword[final] identifier[ServletRequest] identifier[pRequest] , Keyword[final] identifier[ServletResponse] identifier[pResponse] , Keyword[final] identifier[FilterChain] identifier[pFilterChain] operator[SEP] Keyword[throws] identifier[I... |
public <T> Converter<T, RequestBody> nextRequestBodyConverter(
@Nullable Converter.Factory skipPast, Type type, Annotation[] parameterAnnotations,
Annotation[] methodAnnotations) {
checkNotNull(type, "type == null");
checkNotNull(parameterAnnotations, "parameterAnnotations == null");
checkNotNul... | class class_name[name] begin[{]
method[nextRequestBodyConverter, return_type[type[Converter]], modifier[public], parameter[skipPast, type, parameterAnnotations, methodAnnotations]] begin[{]
call[.checkNotNull, parameter[member[.type], literal["type == null"]]]
call[.checkNotNull... | Keyword[public] operator[<] identifier[T] operator[>] identifier[Converter] operator[<] identifier[T] , identifier[RequestBody] operator[>] identifier[nextRequestBodyConverter] operator[SEP] annotation[@] identifier[Nullable] identifier[Converter] operator[SEP] identifier[Factory] identifier[skipPast] , identifier[Ty... |
private List<CmsSelectWidgetOption> getFieldList() {
List<CmsSelectWidgetOption> retVal = new ArrayList<CmsSelectWidgetOption>();
try {
Iterator<CmsSearchField> i = getSearchFields().iterator();
while (i.hasNext()) {
CmsLuceneField field = (CmsLuceneField)i.next(... | class class_name[name] begin[{]
method[getFieldList, return_type[type[List]], modifier[private], parameter[]] begin[{]
local_variable[type[List], retVal]
TryStatement(block=[LocalVariableDeclaration(annotations=[], declarators=[VariableDeclarator(dimensions=[], initializer=MethodInvocation(argu... | Keyword[private] identifier[List] operator[<] identifier[CmsSelectWidgetOption] operator[>] identifier[getFieldList] operator[SEP] operator[SEP] {
identifier[List] operator[<] identifier[CmsSelectWidgetOption] operator[>] identifier[retVal] operator[=] Keyword[new] identifier[ArrayList] operator[<] identifier[Cm... |
public SearchResult<WorkflowSummary> searchWorkflowsByTasks(int start, int size, String sort, String freeText, String query) {
return executionService.searchWorkflowByTasks(query, freeText, start, size, ServiceUtils.convertStringToList(sort));
} | class class_name[name] begin[{]
method[searchWorkflowsByTasks, return_type[type[SearchResult]], modifier[public], parameter[start, size, sort, freeText, query]] begin[{]
return[call[executionService.searchWorkflowByTasks, parameter[member[.query], member[.freeText], member[.start], member[.size], call[... | Keyword[public] identifier[SearchResult] operator[<] identifier[WorkflowSummary] operator[>] identifier[searchWorkflowsByTasks] operator[SEP] Keyword[int] identifier[start] , Keyword[int] identifier[size] , identifier[String] identifier[sort] , identifier[String] identifier[freeText] , identifier[String] identifier... |
public void rollback() throws HibernateException {
Transaction tr = (Transaction) SessionFactoryHolder.getTransaction();
if (tr != null) {
tr.rollback();
}
SessionFactoryHolder.setTransaction(null);
} | class class_name[name] begin[{]
method[rollback, return_type[void], modifier[public], parameter[]] begin[{]
local_variable[type[Transaction], tr]
if[binary_operation[member[.tr], !=, literal[null]]] begin[{]
call[tr.rollback, parameter[]]
else begin[{]
No... | Keyword[public] Keyword[void] identifier[rollback] operator[SEP] operator[SEP] Keyword[throws] identifier[HibernateException] {
identifier[Transaction] identifier[tr] operator[=] operator[SEP] identifier[Transaction] operator[SEP] identifier[SessionFactoryHolder] operator[SEP] identifier[getTransaction] operator... |
@Override
public Object evaluate(TaskRequest req, TaskResponse res) {
final String seqName = (String) this.seqNamePhrase.evaluate(req, res);
final ICounterStore counterStore = CounterStoreLocator.getCounterStore();
try {
return counterStore.getNextId(seqName);
} catch (E... | class class_name[name] begin[{]
method[evaluate, return_type[type[Object]], modifier[public], parameter[req, res]] begin[{]
local_variable[type[String], seqName]
local_variable[type[ICounterStore], counterStore]
TryStatement(block=[ReturnStatement(expression=MethodInvocation(arguments=[... | annotation[@] identifier[Override] Keyword[public] identifier[Object] identifier[evaluate] operator[SEP] identifier[TaskRequest] identifier[req] , identifier[TaskResponse] identifier[res] operator[SEP] {
Keyword[final] identifier[String] identifier[seqName] operator[=] operator[SEP] identifier[String] operator[... |
void init() throws V4L4JException{
try {
super.init();
} catch (ImageFormatException ife){
if(format == -1){
String msg =
"v4l4j was unable to find image format supported by the"
+ " \nvideo device and that can be converted to YUV420.\n"
+ "Please let the author know about this, so that su... | class class_name[name] begin[{]
method[init, return_type[void], modifier[default], parameter[]] begin[{]
TryStatement(block=[StatementExpression(expression=SuperMethodInvocation(arguments=[], member=init, postfix_operators=[], prefix_operators=[], qualifier=None, selectors=[], type_arguments=None), lab... | Keyword[void] identifier[init] operator[SEP] operator[SEP] Keyword[throws] identifier[V4L4JException] {
Keyword[try] {
Keyword[super] operator[SEP] identifier[init] operator[SEP] operator[SEP] operator[SEP]
}
Keyword[catch] operator[SEP] identifier[ImageFormatException] identifier[ife] o... |
public Javalin delete(@NotNull String path, @NotNull Handler handler) {
return addHandler(HandlerType.DELETE, path, handler);
} | class class_name[name] begin[{]
method[delete, return_type[type[Javalin]], modifier[public], parameter[path, handler]] begin[{]
return[call[.addHandler, parameter[member[HandlerType.DELETE], member[.path], member[.handler]]]]
end[}]
END[}] | Keyword[public] identifier[Javalin] identifier[delete] operator[SEP] annotation[@] identifier[NotNull] identifier[String] identifier[path] , annotation[@] identifier[NotNull] identifier[Handler] identifier[handler] operator[SEP] {
Keyword[return] identifier[addHandler] operator[SEP] identifier[HandlerType] oper... |
protected void updatePropertyFile() {
final String methodName = "updatePropertyFile()";
final File f = new File(htodPropertyFileName);
final CacheOnDisk cod = this;
traceDebug(methodName, "cacheName=" + this.cacheName);
AccessController.doPrivileged(new PrivilegedAction() {
... | class class_name[name] begin[{]
method[updatePropertyFile, return_type[void], modifier[protected], parameter[]] begin[{]
local_variable[type[String], methodName]
local_variable[type[File], f]
local_variable[type[CacheOnDisk], cod]
call[.traceDebug, parameter[member[.meth... | Keyword[protected] Keyword[void] identifier[updatePropertyFile] operator[SEP] operator[SEP] {
Keyword[final] identifier[String] identifier[methodName] operator[=] literal[String] operator[SEP] Keyword[final] identifier[File] identifier[f] operator[=] Keyword[new] identifier[File] operator[SEP] identifier[htodPro... |
@SuppressWarnings("deprecation")
public void killJob(JobID jobId, Map<String, InetAddress> allTrackers) {
for (Map.Entry<String, InetAddress> entry : allTrackers.entrySet()) {
String trackerName = entry.getKey();
InetAddress addr = entry.getValue();
String description = "KillJobAction " + jobId;... | class class_name[name] begin[{]
method[killJob, return_type[void], modifier[public], parameter[jobId, allTrackers]] begin[{]
ForStatement(body=BlockStatement(label=None, statements=[LocalVariableDeclaration(annotations=[], declarators=[VariableDeclarator(dimensions=[], initializer=MethodInvocation(argu... | annotation[@] identifier[SuppressWarnings] operator[SEP] literal[String] operator[SEP] Keyword[public] Keyword[void] identifier[killJob] operator[SEP] identifier[JobID] identifier[jobId] , identifier[Map] operator[<] identifier[String] , identifier[InetAddress] operator[>] identifier[allTrackers] operator[SEP] {
... |
protected int getNextAttributeIdentity(int identity) {
// Assume that attributes and namespace nodes immediately follow the element
while (DTM.NULL != (identity = getNextNodeIdentity(identity))) {
int type = _type(identity);
if (type == DTM.ATTRIBUTE_NODE) {
return identity;
} else if... | class class_name[name] begin[{]
method[getNextAttributeIdentity, return_type[type[int]], modifier[protected], parameter[identity]] begin[{]
while[binary_operation[member[DTM.NULL], !=, assign[member[.identity], call[.getNextNodeIdentity, parameter[member[.identity]]]]]] begin[{]
loc... | Keyword[protected] Keyword[int] identifier[getNextAttributeIdentity] operator[SEP] Keyword[int] identifier[identity] operator[SEP] {
Keyword[while] operator[SEP] identifier[DTM] operator[SEP] identifier[NULL] operator[!=] operator[SEP] identifier[identity] operator[=] identifier[getNextNodeIdentity] operator[SEP... |
private void addRawPut(List<Put> puts, byte[] rowKey, byte[] rawColumn,
byte[] lastModificationColumn, FileStatus fileStatus) throws IOException {
byte[] rawBytes = readJobFile(fileStatus);
Put raw = new Put(rowKey);
byte[] rawLastModifiedMillis =
Bytes.toBytes(fileStatus.getModificationTime... | class class_name[name] begin[{]
method[addRawPut, return_type[void], modifier[private], parameter[puts, rowKey, rawColumn, lastModificationColumn, fileStatus]] begin[{]
local_variable[type[byte], rawBytes]
local_variable[type[Put], raw]
local_variable[type[byte], rawLastModifiedMillis]
... | Keyword[private] Keyword[void] identifier[addRawPut] operator[SEP] identifier[List] operator[<] identifier[Put] operator[>] identifier[puts] , Keyword[byte] operator[SEP] operator[SEP] identifier[rowKey] , Keyword[byte] operator[SEP] operator[SEP] identifier[rawColumn] , Keyword[byte] operator[SEP] operator[SEP] ide... |
@Override
public EJBHome getEJBHome()
{
try
{
EJSWrapper wrapper = home.getWrapper().getRemoteWrapper();
Object wrapperRef = container.getEJBRuntime().getRemoteReference(wrapper);
// The EJB spec does not require us to narrow to the actual home
//... | class class_name[name] begin[{]
method[getEJBHome, return_type[type[EJBHome]], modifier[public], parameter[]] begin[{]
TryStatement(block=[LocalVariableDeclaration(annotations=[], declarators=[VariableDeclarator(dimensions=[], initializer=MethodInvocation(arguments=[], member=getWrapper, postfix_operat... | annotation[@] identifier[Override] Keyword[public] identifier[EJBHome] identifier[getEJBHome] operator[SEP] operator[SEP] {
Keyword[try] {
identifier[EJSWrapper] identifier[wrapper] operator[=] identifier[home] operator[SEP] identifier[getWrapper] operator[SEP] operator[SEP] operator[SEP] identifier[g... |
public static<R> R execute(Transactional<R> exe, TransactionalProvider provider, TimestampProvider times) throws BackendException {
StoreTransaction txh = null;
try {
txh = provider.openTx();
if (!txh.getConfiguration().hasCommitTime()) txh.getConfiguration().setCommitTime(times.... | class class_name[name] begin[{]
method[execute, return_type[type[R]], modifier[public static], parameter[exe, provider, times]] begin[{]
local_variable[type[StoreTransaction], txh]
TryStatement(block=[StatementExpression(expression=Assignment(expressionl=MemberReference(member=txh, postfix_oper... | Keyword[public] Keyword[static] operator[<] identifier[R] operator[>] identifier[R] identifier[execute] operator[SEP] identifier[Transactional] operator[<] identifier[R] operator[>] identifier[exe] , identifier[TransactionalProvider] identifier[provider] , identifier[TimestampProvider] identifier[times] operator[SEP]... |
public <T> T queryColumns(K key, List<N> columns,
ColumnFamilyRowMapper<K, N, T> mapper) {
HSlicePredicate<N> predicate = new HSlicePredicate<N>(topSerializer);
predicate.setColumnNames(columns);
return doExecuteSlice(key, predicate, mapper);
} | class class_name[name] begin[{]
method[queryColumns, return_type[type[T]], modifier[public], parameter[key, columns, mapper]] begin[{]
local_variable[type[HSlicePredicate], predicate]
call[predicate.setColumnNames, parameter[member[.columns]]]
return[call[.doExecuteSlice, parame... | Keyword[public] operator[<] identifier[T] operator[>] identifier[T] identifier[queryColumns] operator[SEP] identifier[K] identifier[key] , identifier[List] operator[<] identifier[N] operator[>] identifier[columns] , identifier[ColumnFamilyRowMapper] operator[<] identifier[K] , identifier[N] , identifier[T] operator... |
private static ByteBuffer putUnsignedLong(ByteBuffer buffer, long v) {
buffer.putInt(0);
return putUnsignedInt(buffer, (int)v);
} | class class_name[name] begin[{]
method[putUnsignedLong, return_type[type[ByteBuffer]], modifier[private static], parameter[buffer, v]] begin[{]
call[buffer.putInt, parameter[literal[0]]]
return[call[.putUnsignedInt, parameter[member[.buffer], Cast(expression=MemberReference(member=v, po... | Keyword[private] Keyword[static] identifier[ByteBuffer] identifier[putUnsignedLong] operator[SEP] identifier[ByteBuffer] identifier[buffer] , Keyword[long] identifier[v] operator[SEP] {
identifier[buffer] operator[SEP] identifier[putInt] operator[SEP] Other[0] operator[SEP] operator[SEP] Keyword[return] identif... |
public void loadFromProperties(java.util.Properties properties) {
for (Iterator i = properties.keySet().iterator(); i.hasNext(); ) {
String key = (String) i.next();
if (!key.endsWith(".desc")) {
try {
Class clazz = Class.forName(properties.getProperty(key));
String desc = pro... | class class_name[name] begin[{]
method[loadFromProperties, return_type[void], modifier[public], parameter[properties]] begin[{]
ForStatement(body=BlockStatement(label=None, statements=[LocalVariableDeclaration(annotations=[], declarators=[VariableDeclarator(dimensions=[], initializer=Cast(expression=Me... | Keyword[public] Keyword[void] identifier[loadFromProperties] operator[SEP] identifier[java] operator[SEP] identifier[util] operator[SEP] identifier[Properties] identifier[properties] operator[SEP] {
Keyword[for] operator[SEP] identifier[Iterator] identifier[i] operator[=] identifier[properties] operator[SEP] ide... |
private byte[] blockForWrite(int index) throws IOException {
if (index >= blockCount) {
int additionalBlocksNeeded = index - blockCount + 1;
disk.allocate(this, additionalBlocksNeeded);
}
return blocks[index];
} | class class_name[name] begin[{]
method[blockForWrite, return_type[type[byte]], modifier[private], parameter[index]] begin[{]
if[binary_operation[member[.index], >=, member[.blockCount]]] begin[{]
local_variable[type[int], additionalBlocksNeeded]
call[disk.all... | Keyword[private] Keyword[byte] operator[SEP] operator[SEP] identifier[blockForWrite] operator[SEP] Keyword[int] identifier[index] operator[SEP] Keyword[throws] identifier[IOException] {
Keyword[if] operator[SEP] identifier[index] operator[>=] identifier[blockCount] operator[SEP] {
Keyword[int] identif... |
public IfcPropertySetTemplateTypeEnum createIfcPropertySetTemplateTypeEnumFromString(EDataType eDataType,
String initialValue) {
IfcPropertySetTemplateTypeEnum result = IfcPropertySetTemplateTypeEnum.get(initialValue);
if (result == null)
throw new IllegalArgumentException(
"The value '" + initialVa... | class class_name[name] begin[{]
method[createIfcPropertySetTemplateTypeEnumFromString, return_type[type[IfcPropertySetTemplateTypeEnum]], modifier[public], parameter[eDataType, initialValue]] begin[{]
local_variable[type[IfcPropertySetTemplateTypeEnum], result]
if[binary_operation[membe... | Keyword[public] identifier[IfcPropertySetTemplateTypeEnum] identifier[createIfcPropertySetTemplateTypeEnumFromString] operator[SEP] identifier[EDataType] identifier[eDataType] , identifier[String] identifier[initialValue] operator[SEP] {
identifier[IfcPropertySetTemplateTypeEnum] identifier[result] operator[=] ... |
public void setSubscribers(java.util.Collection<String> subscribers) {
if (subscribers == null) {
this.subscribers = null;
return;
}
this.subscribers = new java.util.ArrayList<String>(subscribers);
} | class class_name[name] begin[{]
method[setSubscribers, return_type[void], modifier[public], parameter[subscribers]] begin[{]
if[binary_operation[member[.subscribers], ==, literal[null]]] begin[{]
assign[THIS[member[None.subscribers]], literal[null]]
return[No... | Keyword[public] Keyword[void] identifier[setSubscribers] operator[SEP] identifier[java] operator[SEP] identifier[util] operator[SEP] identifier[Collection] operator[<] identifier[String] operator[>] identifier[subscribers] operator[SEP] {
Keyword[if] operator[SEP] identifier[subscribers] operator[==] Other[null]... |
public void insertItem(T value, String text, int index) {
insertItemInternal(value, text, index, true);
} | class class_name[name] begin[{]
method[insertItem, return_type[void], modifier[public], parameter[value, text, index]] begin[{]
call[.insertItemInternal, parameter[member[.value], member[.text], member[.index], literal[true]]]
end[}]
END[}] | Keyword[public] Keyword[void] identifier[insertItem] operator[SEP] identifier[T] identifier[value] , identifier[String] identifier[text] , Keyword[int] identifier[index] operator[SEP] {
identifier[insertItemInternal] operator[SEP] identifier[value] , identifier[text] , identifier[index] , literal[boolean] o... |
public void setExportOnlyColumns(final String[] exportOnlyColumns) {
if (exportOnlyColumns != null) {
this.exportOnlyColumns = exportOnlyColumns.clone();
} else {
this.exportOnlyColumns = null;
}
} | class class_name[name] begin[{]
method[setExportOnlyColumns, return_type[void], modifier[public], parameter[exportOnlyColumns]] begin[{]
if[binary_operation[member[.exportOnlyColumns], !=, literal[null]]] begin[{]
assign[THIS[member[None.exportOnlyColumns]], call[exportO... | Keyword[public] Keyword[void] identifier[setExportOnlyColumns] operator[SEP] Keyword[final] identifier[String] operator[SEP] operator[SEP] identifier[exportOnlyColumns] operator[SEP] {
Keyword[if] operator[SEP] identifier[exportOnlyColumns] operator[!=] Other[null] operator[SEP] {
Keyword[this] operat... |
public void setSnapshotDetails(java.util.Collection<SnapshotDetail> snapshotDetails) {
if (snapshotDetails == null) {
this.snapshotDetails = null;
return;
}
this.snapshotDetails = new com.amazonaws.internal.SdkInternalList<SnapshotDetail>(snapshotDetails);
} | class class_name[name] begin[{]
method[setSnapshotDetails, return_type[void], modifier[public], parameter[snapshotDetails]] begin[{]
if[binary_operation[member[.snapshotDetails], ==, literal[null]]] begin[{]
assign[THIS[member[None.snapshotDetails]], literal[null]]
... | Keyword[public] Keyword[void] identifier[setSnapshotDetails] operator[SEP] identifier[java] operator[SEP] identifier[util] operator[SEP] identifier[Collection] operator[<] identifier[SnapshotDetail] operator[>] identifier[snapshotDetails] operator[SEP] {
Keyword[if] operator[SEP] identifier[snapshotDetails] oper... |
public JoinClause crossJoinAllNodesAs( String alias ) {
// Expect there to be a source already ...
return new JoinClause(namedSelector(AllNodes.ALL_NODES_NAME + " AS " + alias), JoinType.CROSS);
} | class class_name[name] begin[{]
method[crossJoinAllNodesAs, return_type[type[JoinClause]], modifier[public], parameter[alias]] begin[{]
return[ClassCreator(arguments=[MethodInvocation(arguments=[BinaryOperation(operandl=BinaryOperation(operandl=MemberReference(member=ALL_NODES_NAME, postfix_operators=[... | Keyword[public] identifier[JoinClause] identifier[crossJoinAllNodesAs] operator[SEP] identifier[String] identifier[alias] operator[SEP] {
Keyword[return] Keyword[new] identifier[JoinClause] operator[SEP] identifier[namedSelector] operator[SEP] identifier[AllNodes] operator[SEP] identifier[ALL_NODES_NAME] operato... |
private static String arraysToString(final Object[] a) {
if (a == null) {
return "null";
}
final int iMax = a.length - 1;
if (iMax == -1) {
return "[]";
}
final StringBuilder b = new StringBuilder();
b.append('[');
for (int i = 0;; i++) {
b.append(String.valueOf(a[i]))... | class class_name[name] begin[{]
method[arraysToString, return_type[type[String]], modifier[private static], parameter[a]] begin[{]
if[binary_operation[member[.a], ==, literal[null]]] begin[{]
return[literal["null"]]
else begin[{]
None
end[}]
local_variable[ty... | Keyword[private] Keyword[static] identifier[String] identifier[arraysToString] operator[SEP] Keyword[final] identifier[Object] operator[SEP] operator[SEP] identifier[a] operator[SEP] {
Keyword[if] operator[SEP] identifier[a] operator[==] Other[null] operator[SEP] {
Keyword[return] literal[String] oper... |
public void setLinearFactor(float x, float y, float z) {
Native3DRigidBody.setLinearFactor(getNative(), x, y, z);
} | class class_name[name] begin[{]
method[setLinearFactor, return_type[void], modifier[public], parameter[x, y, z]] begin[{]
call[Native3DRigidBody.setLinearFactor, parameter[call[.getNative, parameter[]], member[.x], member[.y], member[.z]]]
end[}]
END[}] | Keyword[public] Keyword[void] identifier[setLinearFactor] operator[SEP] Keyword[float] identifier[x] , Keyword[float] identifier[y] , Keyword[float] identifier[z] operator[SEP] {
identifier[Native3DRigidBody] operator[SEP] identifier[setLinearFactor] operator[SEP] identifier[getNative] operator[SEP] operator[S... |
public void setStatusMapping(Map<String, Integer> statusMapping) {
Assert.notNull(statusMapping, "StatusMapping must not be null");
this.statusMapping = new HashMap<>(statusMapping);
} | class class_name[name] begin[{]
method[setStatusMapping, return_type[void], modifier[public], parameter[statusMapping]] begin[{]
call[Assert.notNull, parameter[member[.statusMapping], literal["StatusMapping must not be null"]]]
assign[THIS[member[None.statusMapping]], ClassCreat... | Keyword[public] Keyword[void] identifier[setStatusMapping] operator[SEP] identifier[Map] operator[<] identifier[String] , identifier[Integer] operator[>] identifier[statusMapping] operator[SEP] {
identifier[Assert] operator[SEP] identifier[notNull] operator[SEP] identifier[statusMapping] , literal[String] oper... |
@Override
public void execute() throws MojoExecutionException, MojoFailureException {
validateConfiguration();
try {
// set git flow configuration
initGitFlowConfig();
// check uncommitted changes
checkUncommittedChanges();
String tag = ... | class class_name[name] begin[{]
method[execute, return_type[void], modifier[public], parameter[]] begin[{]
call[.validateConfiguration, parameter[]]
TryStatement(block=[StatementExpression(expression=MethodInvocation(arguments=[], member=initGitFlowConfig, postfix_operators=[], prefix_o... | annotation[@] identifier[Override] Keyword[public] Keyword[void] identifier[execute] operator[SEP] operator[SEP] Keyword[throws] identifier[MojoExecutionException] , identifier[MojoFailureException] {
identifier[validateConfiguration] operator[SEP] operator[SEP] operator[SEP] Keyword[try] {
identifie... |
@Override
protected Annotation[] getValidators() {
// Si l'annotation en cours est nulle
if(this.annotation == null) {
// On retourne null
return null;
}
// Si l'annotation en cours n'est pas de l'instance
if(!(annotation instanceof SizeDAOValidators)) {
// On retourne nul... | class class_name[name] begin[{]
method[getValidators, return_type[type[Annotation]], modifier[protected], parameter[]] begin[{]
if[binary_operation[THIS[member[None.annotation]], ==, literal[null]]] begin[{]
return[literal[null]]
else begin[{]
None
end[}]
... | annotation[@] identifier[Override] Keyword[protected] identifier[Annotation] operator[SEP] operator[SEP] identifier[getValidators] operator[SEP] operator[SEP] {
Keyword[if] operator[SEP] Keyword[this] operator[SEP] identifier[annotation] operator[==] Other[null] operator[SEP] {
Keyword[return] Other[n... |
static <T> String join(Iterable<T> elems, String delim) {
if (elems == null)
return "";
StringBuilder result = new StringBuilder();
for (T elem : elems)
result.append(elem).append(delim);
if (result.length() > 0)
result.setLength(result.length() - deli... | class class_name[name] begin[{]
method[join, return_type[type[String]], modifier[static], parameter[elems, delim]] begin[{]
if[binary_operation[member[.elems], ==, literal[null]]] begin[{]
return[literal[""]]
else begin[{]
None
end[}]
local_variable[type[StringBuilder], ... | Keyword[static] operator[<] identifier[T] operator[>] identifier[String] identifier[join] operator[SEP] identifier[Iterable] operator[<] identifier[T] operator[>] identifier[elems] , identifier[String] identifier[delim] operator[SEP] {
Keyword[if] operator[SEP] identifier[elems] operator[==] Other[null] operato... |
public double getLowerBound(final int numStdDev) {
if (!isEstimationMode()) { return getRetainedEntries(); }
return BinomialBoundsN.getLowerBound(getRetainedEntries(), getTheta(), numStdDev, isEmpty_);
} | class class_name[name] begin[{]
method[getLowerBound, return_type[type[double]], modifier[public], parameter[numStdDev]] begin[{]
if[call[.isEstimationMode, parameter[]]] begin[{]
return[call[.getRetainedEntries, parameter[]]]
else begin[{]
None
end[}]
return... | Keyword[public] Keyword[double] identifier[getLowerBound] operator[SEP] Keyword[final] Keyword[int] identifier[numStdDev] operator[SEP] {
Keyword[if] operator[SEP] operator[!] identifier[isEstimationMode] operator[SEP] operator[SEP] operator[SEP] {
Keyword[return] identifier[getRetainedEntries] operat... |
public S tableNamePrefix(String tableNamePrefix) {
attributes.attribute(TABLE_NAME_PREFIX).set(tableNamePrefix);
return self();
} | class class_name[name] begin[{]
method[tableNamePrefix, return_type[type[S]], modifier[public], parameter[tableNamePrefix]] begin[{]
call[attributes.attribute, parameter[member[.TABLE_NAME_PREFIX]]]
return[call[.self, parameter[]]]
end[}]
END[}] | Keyword[public] identifier[S] identifier[tableNamePrefix] operator[SEP] identifier[String] identifier[tableNamePrefix] operator[SEP] {
identifier[attributes] operator[SEP] identifier[attribute] operator[SEP] identifier[TABLE_NAME_PREFIX] operator[SEP] operator[SEP] identifier[set] operator[SEP] identifier[tableN... |
public Element getGlobalVariable(String name) {
GlobalVariable gvar = globalVariables.get(name);
return (gvar != null) ? gvar.getValue() : null;
} | class class_name[name] begin[{]
method[getGlobalVariable, return_type[type[Element]], modifier[public], parameter[name]] begin[{]
local_variable[type[GlobalVariable], gvar]
return[TernaryExpression(condition=BinaryOperation(operandl=MemberReference(member=gvar, postfix_operators=[], prefix_oper... | Keyword[public] identifier[Element] identifier[getGlobalVariable] operator[SEP] identifier[String] identifier[name] operator[SEP] {
identifier[GlobalVariable] identifier[gvar] operator[=] identifier[globalVariables] operator[SEP] identifier[get] operator[SEP] identifier[name] operator[SEP] operator[SEP] Keyword[... |
public synchronized JsMessage get(short sessionId)
throws SIResourceException, SIConnectionDroppedException, SIConnectionLostException
{
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) SibTr.entry(this, tc, "get", sessionId);
JsMessage retValue = null;
QueueData rhData = re... | class class_name[name] begin[{]
method[get, return_type[type[JsMessage]], modifier[synchronized public], parameter[sessionId]] begin[{]
if[binary_operation[call[TraceComponent.isAnyTracingEnabled, parameter[]], &&, call[tc.isEntryEnabled, parameter[]]]] begin[{]
call[SibTr.entry, pa... | Keyword[public] Keyword[synchronized] identifier[JsMessage] identifier[get] operator[SEP] Keyword[short] identifier[sessionId] operator[SEP] Keyword[throws] identifier[SIResourceException] , identifier[SIConnectionDroppedException] , identifier[SIConnectionLostException] {
Keyword[if] operator[SEP] identifier[... |
private void initialize() {
this.setLayout(new BorderLayout());
this.setName(Constant.messages.getString("output.panel.title")); // ZAP: i18n
if (Model.getSingleton().getOptionsParam().getViewParam().getWmUiHandlingOption() == 0) {
this.setSize(243, 119);
}
// ZAP: Added Ou... | class class_name[name] begin[{]
method[initialize, return_type[void], modifier[private], parameter[]] begin[{]
THIS[call[None.setLayout, parameter[ClassCreator(arguments=[], body=None, constructor_type_arguments=None, postfix_operators=[], prefix_operators=[], qualifier=None, selectors=[], type... | Keyword[private] Keyword[void] identifier[initialize] operator[SEP] operator[SEP] {
Keyword[this] operator[SEP] identifier[setLayout] operator[SEP] Keyword[new] identifier[BorderLayout] operator[SEP] operator[SEP] operator[SEP] operator[SEP] Keyword[this] operator[SEP] identifier[setName] operator[SEP] identifie... |
public static List<ProducerDecoratorBean> getDecoratedProducers(HttpServletRequest req, List<ProducerAO> producers, Map<String, GraphDataBean> graphData){
Map<IDecorator, List<ProducerAO>> decoratorMap = new HashMap<>(producers.size());
for (ProducerAO producer : producers){
try{
... | class class_name[name] begin[{]
method[getDecoratedProducers, return_type[type[List]], modifier[public static], parameter[req, producers, graphData]] begin[{]
local_variable[type[Map], decoratorMap]
ForStatement(body=BlockStatement(label=None, statements=[TryStatement(block=[LocalVariableDeclar... | Keyword[public] Keyword[static] identifier[List] operator[<] identifier[ProducerDecoratorBean] operator[>] identifier[getDecoratedProducers] operator[SEP] identifier[HttpServletRequest] identifier[req] , identifier[List] operator[<] identifier[ProducerAO] operator[>] identifier[producers] , identifier[Map] operator[<... |
public void addFieldError (@Nonnull @Nonempty final String sFieldName, @Nonnull @Nonempty final String sText)
{
add (SingleError.builderError ().setErrorFieldName (sFieldName).setErrorText (sText).build ());
} | class class_name[name] begin[{]
method[addFieldError, return_type[void], modifier[public], parameter[sFieldName, sText]] begin[{]
call[.add, parameter[call[SingleError.builderError, parameter[]]]]
end[}]
END[}] | Keyword[public] Keyword[void] identifier[addFieldError] operator[SEP] annotation[@] identifier[Nonnull] annotation[@] identifier[Nonempty] Keyword[final] identifier[String] identifier[sFieldName] , annotation[@] identifier[Nonnull] annotation[@] identifier[Nonempty] Keyword[final] identifier[String] identifier[sText] ... |
protected void processBundle(Bundle bundle) {
Properties props = readMessageRouterProps(bundle);
if (props != null) {
msgRouter.modified(props);
}
} | class class_name[name] begin[{]
method[processBundle, return_type[void], modifier[protected], parameter[bundle]] begin[{]
local_variable[type[Properties], props]
if[binary_operation[member[.props], !=, literal[null]]] begin[{]
call[msgRouter.modified, parameter[m... | Keyword[protected] Keyword[void] identifier[processBundle] operator[SEP] identifier[Bundle] identifier[bundle] operator[SEP] {
identifier[Properties] identifier[props] operator[=] identifier[readMessageRouterProps] operator[SEP] identifier[bundle] operator[SEP] operator[SEP] Keyword[if] operator[SEP] identifier[... |
protected void addSpacing(float extraspace, float oldleading, Font f) {
if (extraspace == 0) return;
if (pageEmpty) return;
if (currentHeight + line.height() + leading > indentTop() - indentBottom()) return;
leading = extraspace;
carriageReturn();
if (f.isUnderlined() || f.isStrik... | class class_name[name] begin[{]
method[addSpacing, return_type[void], modifier[protected], parameter[extraspace, oldleading, f]] begin[{]
if[binary_operation[member[.extraspace], ==, literal[0]]] begin[{]
return[None]
else begin[{]
None
end[}]
if[member[.pageEmpt... | Keyword[protected] Keyword[void] identifier[addSpacing] operator[SEP] Keyword[float] identifier[extraspace] , Keyword[float] identifier[oldleading] , identifier[Font] identifier[f] operator[SEP] {
Keyword[if] operator[SEP] identifier[extraspace] operator[==] Other[0] operator[SEP] Keyword[return] operator[SEP]... |
public static IntRange GetRange( int[] values, double percent ){
int total = 0, n = values.length;
// for all values
for ( int i = 0; i < n; i++ )
{
// accumalate total
total += values[i];
}
int min, max, hits;
int h = (int) ( total * ( p... | class class_name[name] begin[{]
method[GetRange, return_type[type[IntRange]], modifier[public static], parameter[values, percent]] begin[{]
local_variable[type[int], total]
ForStatement(body=BlockStatement(label=None, statements=[StatementExpression(expression=Assignment(expressionl=MemberRefer... | Keyword[public] Keyword[static] identifier[IntRange] identifier[GetRange] operator[SEP] Keyword[int] operator[SEP] operator[SEP] identifier[values] , Keyword[double] identifier[percent] operator[SEP] {
Keyword[int] identifier[total] operator[=] Other[0] , identifier[n] operator[=] identifier[values] operator[S... |
public KriptonContentValues contentValues(SQLiteStatement compiledStatement) {
KriptonContentValues content = contentValues.get();
content.clear(compiledStatement);
return content;
} | class class_name[name] begin[{]
method[contentValues, return_type[type[KriptonContentValues]], modifier[public], parameter[compiledStatement]] begin[{]
local_variable[type[KriptonContentValues], content]
call[content.clear, parameter[member[.compiledStatement]]]
return[member[.c... | Keyword[public] identifier[KriptonContentValues] identifier[contentValues] operator[SEP] identifier[SQLiteStatement] identifier[compiledStatement] operator[SEP] {
identifier[KriptonContentValues] identifier[content] operator[=] identifier[contentValues] operator[SEP] identifier[get] operator[SEP] operator[SEP] o... |
@Override
public void run()
{
ObjectInputStream ois = null;
try
{
ois = new ObjectInputStream(new BufferedInputStream(socket.getInputStream()));
clientAddress = socket.getInetAddress().getHostAddress();
inetAddressFromClient = socket.getInetAddress();
while (true)
{
final Object object = ois.... | class class_name[name] begin[{]
method[run, return_type[void], modifier[public], parameter[]] begin[{]
local_variable[type[ObjectInputStream], ois]
TryStatement(block=[StatementExpression(expression=Assignment(expressionl=MemberReference(member=ois, postfix_operators=[], prefix_operators=[], qu... | annotation[@] identifier[Override] Keyword[public] Keyword[void] identifier[run] operator[SEP] operator[SEP] {
identifier[ObjectInputStream] identifier[ois] operator[=] Other[null] operator[SEP] Keyword[try] {
identifier[ois] operator[=] Keyword[new] identifier[ObjectInputStream] operator[SEP] Keyword... |
public EClass getIfcSectionReinforcementProperties() {
if (ifcSectionReinforcementPropertiesEClass == null) {
ifcSectionReinforcementPropertiesEClass = (EClass) EPackage.Registry.INSTANCE
.getEPackage(Ifc2x3tc1Package.eNS_URI).getEClassifiers().get(505);
}
return ifcSectionReinforcementPropertiesECla... | class class_name[name] begin[{]
method[getIfcSectionReinforcementProperties, return_type[type[EClass]], modifier[public], parameter[]] begin[{]
if[binary_operation[member[.ifcSectionReinforcementPropertiesEClass], ==, literal[null]]] begin[{]
assign[member[.ifcSectionRei... | Keyword[public] identifier[EClass] identifier[getIfcSectionReinforcementProperties] operator[SEP] operator[SEP] {
Keyword[if] operator[SEP] identifier[ifcSectionReinforcementPropertiesEClass] operator[==] Other[null] operator[SEP] {
identifier[ifcSectionReinforcementPropertiesEClass] operator[=] opera... |
public Method getSourceMethod() {
Method method = sourceMethodReference.get();
if (method != null || sourceMethodName == CTOR_METHOD_NAME) {
return method;
}
for (Method m : ReflectionHelper.getDeclaredMethods(getSourceClass())) {
if (m.getName().equals(sourceMeth... | class class_name[name] begin[{]
method[getSourceMethod, return_type[type[Method]], modifier[public], parameter[]] begin[{]
local_variable[type[Method], method]
if[binary_operation[binary_operation[member[.method], !=, literal[null]], ||, binary_operation[member[.sourceMethodName], ==, m... | Keyword[public] identifier[Method] identifier[getSourceMethod] operator[SEP] operator[SEP] {
identifier[Method] identifier[method] operator[=] identifier[sourceMethodReference] operator[SEP] identifier[get] operator[SEP] operator[SEP] operator[SEP] Keyword[if] operator[SEP] identifier[method] operator[!=] Other[... |
public static <K,T> Cache2kBuilder<K,T> of(Class<K> _keyType, Class<T> _valueType) {
return new Cache2kBuilder<K, T>(CacheTypeCapture.of(_keyType), CacheTypeCapture.of(_valueType));
} | class class_name[name] begin[{]
method[of, return_type[type[Cache2kBuilder]], modifier[public static], parameter[_keyType, _valueType]] begin[{]
return[ClassCreator(arguments=[MethodInvocation(arguments=[MemberReference(member=_keyType, postfix_operators=[], prefix_operators=[], qualifier=, selectors=[... | Keyword[public] Keyword[static] operator[<] identifier[K] , identifier[T] operator[>] identifier[Cache2kBuilder] operator[<] identifier[K] , identifier[T] operator[>] identifier[of] operator[SEP] identifier[Class] operator[<] identifier[K] operator[>] identifier[_keyType] , identifier[Class] operator[<] identifier[T... |
private void processScores(String line) {
String[] values = line.trim().split(" +");
// increment the current row we are talking about
currentRowPos++;
for ( int i =0 ; i < values.length ; i++){
if ( values[i].endsWith(".")) {
values[i] = values[i] + "0";
}
// special case: MEHP950101
if ... | class class_name[name] begin[{]
method[processScores, return_type[void], modifier[private], parameter[line]] begin[{]
local_variable[type[String], values]
member[.currentRowPos]
ForStatement(body=BlockStatement(label=None, statements=[IfStatement(condition=MemberReference(member... | Keyword[private] Keyword[void] identifier[processScores] operator[SEP] identifier[String] identifier[line] operator[SEP] {
identifier[String] operator[SEP] operator[SEP] identifier[values] operator[=] identifier[line] operator[SEP] identifier[trim] operator[SEP] operator[SEP] operator[SEP] identifier[split] oper... |
private void processElementNormal(GeneratorSingleCluster cluster, Node cur) {
double mean = 0.0;
double stddev = 1.0;
String meanstr = ((Element) cur).getAttribute(ATTR_MEAN);
if(meanstr != null && meanstr.length() > 0) {
mean = ParseUtil.parseDouble(meanstr);
}
String stddevstr = ((Elemen... | class class_name[name] begin[{]
method[processElementNormal, return_type[void], modifier[private], parameter[cluster, cur]] begin[{]
local_variable[type[double], mean]
local_variable[type[double], stddev]
local_variable[type[String], meanstr]
if[binary_operation[binary_o... | Keyword[private] Keyword[void] identifier[processElementNormal] operator[SEP] identifier[GeneratorSingleCluster] identifier[cluster] , identifier[Node] identifier[cur] operator[SEP] {
Keyword[double] identifier[mean] operator[=] literal[Float] operator[SEP] Keyword[double] identifier[stddev] operator[=] literal... |
public static <T> int binarySearch(final T[] a, final int fromIndex, final int toIndex, final T key, final Comparator<? super T> cmp) {
return Array.binarySearch(a, fromIndex, toIndex, key, cmp);
} | class class_name[name] begin[{]
method[binarySearch, return_type[type[int]], modifier[public static], parameter[a, fromIndex, toIndex, key, cmp]] begin[{]
return[call[Array.binarySearch, parameter[member[.a], member[.fromIndex], member[.toIndex], member[.key], member[.cmp]]]]
end[}]
END[}] | Keyword[public] Keyword[static] operator[<] identifier[T] operator[>] Keyword[int] identifier[binarySearch] operator[SEP] Keyword[final] identifier[T] operator[SEP] operator[SEP] identifier[a] , Keyword[final] Keyword[int] identifier[fromIndex] , Keyword[final] Keyword[int] identifier[toIndex] , Keyword[final] ident... |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.