code stringlengths 63 466k | code_sememe stringlengths 141 3.79M | token_type stringlengths 274 1.23M |
|---|---|---|
@Override
public void validate () throws SchedulerException
{
super.validate ();
if (m_eRepeatIntervalUnit == null ||
!(m_eRepeatIntervalUnit.equals (EIntervalUnit.SECOND) ||
m_eRepeatIntervalUnit.equals (EIntervalUnit.MINUTE) ||
m_eRepeatIntervalUnit.equals (EIntervalUnit.HOUR)... | class class_name[name] begin[{]
method[validate, return_type[void], modifier[public], parameter[]] begin[{]
SuperMethodInvocation(arguments=[], member=validate, postfix_operators=[], prefix_operators=[], qualifier=None, selectors=[], type_arguments=None)
if[binary_operation[bina... | annotation[@] identifier[Override] Keyword[public] Keyword[void] identifier[validate] operator[SEP] operator[SEP] Keyword[throws] identifier[SchedulerException] {
Keyword[super] operator[SEP] identifier[validate] operator[SEP] operator[SEP] operator[SEP] Keyword[if] operator[SEP] identifier[m_eRepeatIntervalUnit... |
public FessMessages addSuccessUpdateCrawlerParams(String property) {
assertPropertyNotNull(property);
add(property, new UserMessage(SUCCESS_update_crawler_params));
return this;
} | class class_name[name] begin[{]
method[addSuccessUpdateCrawlerParams, return_type[type[FessMessages]], modifier[public], parameter[property]] begin[{]
call[.assertPropertyNotNull, parameter[member[.property]]]
call[.add, parameter[member[.property], ClassCreator(arguments=[Membe... | Keyword[public] identifier[FessMessages] identifier[addSuccessUpdateCrawlerParams] operator[SEP] identifier[String] identifier[property] operator[SEP] {
identifier[assertPropertyNotNull] operator[SEP] identifier[property] operator[SEP] operator[SEP] identifier[add] operator[SEP] identifier[property] , Keyword[n... |
protected <T> void handle(Class<T> event) {
if (!event.isInterface())
throw new IllegalArgumentException(
"Event type has to be an interface but was: " + event);
initbind(event).to((Initialiser<T>) (listener,
injector) -> injector.resolve(EventProcessor.class).register(
event, listener));
bind(e... | class class_name[name] begin[{]
method[handle, return_type[void], modifier[protected], parameter[event]] begin[{]
if[call[event.isInterface, parameter[]]] begin[{]
ThrowStatement(expression=ClassCreator(arguments=[BinaryOperation(operandl=Literal(postfix_operators=[], prefix_operators=[], quali... | Keyword[protected] operator[<] identifier[T] operator[>] Keyword[void] identifier[handle] operator[SEP] identifier[Class] operator[<] identifier[T] operator[>] identifier[event] operator[SEP] {
Keyword[if] operator[SEP] operator[!] identifier[event] operator[SEP] identifier[isInterface] operator[SEP] operator[SE... |
public static void encodeDesc(double value, byte[] dst, int dstOffset) {
long bits = Double.doubleToLongBits(value);
if (bits >= 0) {
bits ^= 0x7fffffffffffffffL;
}
int w = (int)(bits >> 32);
dst[dstOffset ] = (byte)(w >> 24);
dst[dstOffset + 1] = (b... | class class_name[name] begin[{]
method[encodeDesc, return_type[void], modifier[public static], parameter[value, dst, dstOffset]] begin[{]
local_variable[type[long], bits]
if[binary_operation[member[.bits], >=, literal[0]]] begin[{]
assign[member[.bits], literal[0... | Keyword[public] Keyword[static] Keyword[void] identifier[encodeDesc] operator[SEP] Keyword[double] identifier[value] , Keyword[byte] operator[SEP] operator[SEP] identifier[dst] , Keyword[int] identifier[dstOffset] operator[SEP] {
Keyword[long] identifier[bits] operator[=] identifier[Double] operator[SEP] ident... |
@SuppressWarnings("unchecked")
public static Predicate basicCreatePredicateFromSingleCriteria(CriteriaBuilder builder, Expression entityField, QueryCriteria criteria) {
Predicate predicate = null;
List<Object> parameters = criteria.getParameters();
int numParameters = parameters.size();
... | class class_name[name] begin[{]
method[basicCreatePredicateFromSingleCriteria, return_type[type[Predicate]], modifier[public static], parameter[builder, entityField, criteria]] begin[{]
local_variable[type[Predicate], predicate]
local_variable[type[List], parameters]
local_variable[type... | annotation[@] identifier[SuppressWarnings] operator[SEP] literal[String] operator[SEP] Keyword[public] Keyword[static] identifier[Predicate] identifier[basicCreatePredicateFromSingleCriteria] operator[SEP] identifier[CriteriaBuilder] identifier[builder] , identifier[Expression] identifier[entityField] , identifier[Qu... |
@Override
public Object lookup(final Name dn) {
return executeReadOnly(new ContextExecutor() {
public Object executeWithContext(DirContext ctx) throws javax.naming.NamingException {
return ctx.lookup(dn);
}
});
} | class class_name[name] begin[{]
method[lookup, return_type[type[Object]], modifier[public], parameter[dn]] begin[{]
return[call[.executeReadOnly, parameter[ClassCreator(arguments=[], body=[MethodDeclaration(annotations=[], body=[ReturnStatement(expression=MethodInvocation(arguments=[MemberReference(mem... | annotation[@] identifier[Override] Keyword[public] identifier[Object] identifier[lookup] operator[SEP] Keyword[final] identifier[Name] identifier[dn] operator[SEP] {
Keyword[return] identifier[executeReadOnly] operator[SEP] Keyword[new] identifier[ContextExecutor] operator[SEP] operator[SEP] {
Keyword... |
@Override
public boolean contains(U unit) {
for (Item<?> item : this.getTotalLength()) {
if (item.getUnit().equals(unit)) {
return (item.getAmount() > 0);
}
}
return false;
} | class class_name[name] begin[{]
method[contains, return_type[type[boolean]], modifier[public], parameter[unit]] begin[{]
ForStatement(body=BlockStatement(label=None, statements=[IfStatement(condition=MethodInvocation(arguments=[], member=getUnit, postfix_operators=[], prefix_operators=[], qualifier=ite... | annotation[@] identifier[Override] Keyword[public] Keyword[boolean] identifier[contains] operator[SEP] identifier[U] identifier[unit] operator[SEP] {
Keyword[for] operator[SEP] identifier[Item] operator[<] operator[?] operator[>] identifier[item] operator[:] Keyword[this] operator[SEP] identifier[getTotalLength... |
private boolean matchesQualifiedName(String qname, int endIndex) {
int start = qname.lastIndexOf('.', endIndex - 1) + 1;
switch (this.getToken()) {
case NAME:
String name = getString();
return start == 0 && !name.isEmpty() && name.length() == endIndex && qname.startsWith(name);
case... | class class_name[name] begin[{]
method[matchesQualifiedName, return_type[type[boolean]], modifier[private], parameter[qname, endIndex]] begin[{]
local_variable[type[int], start]
SwitchStatement(cases=[SwitchStatementCase(case=['NAME'], statements=[LocalVariableDeclaration(annotations=[], declar... | Keyword[private] Keyword[boolean] identifier[matchesQualifiedName] operator[SEP] identifier[String] identifier[qname] , Keyword[int] identifier[endIndex] operator[SEP] {
Keyword[int] identifier[start] operator[=] identifier[qname] operator[SEP] identifier[lastIndexOf] operator[SEP] literal[String] , identifier... |
private static SiteDomainInfo getDomainInfo(Collection<String> uris) {
Set<String> rootDomains = Sets.newHashSet();
Set<String> domains = Sets.newHashSet();
boolean invalidPort = false;
for (String uriStr : uris) {
try {
URI uri = new URI(uriStr);
... | class class_name[name] begin[{]
method[getDomainInfo, return_type[type[SiteDomainInfo]], modifier[private static], parameter[uris]] begin[{]
local_variable[type[Set], rootDomains]
local_variable[type[Set], domains]
local_variable[type[boolean], invalidPort]
ForStatement(body=Blo... | Keyword[private] Keyword[static] identifier[SiteDomainInfo] identifier[getDomainInfo] operator[SEP] identifier[Collection] operator[<] identifier[String] operator[>] identifier[uris] operator[SEP] {
identifier[Set] operator[<] identifier[String] operator[>] identifier[rootDomains] operator[=] identifier[Sets] op... |
public void waitUntilFinished()
{
flushTermination();
flushUpdate();
flushInsert();
shutdown();
for (int i = 0; i < numberOfQueues; i++)
{
while (!executors[i].isTerminated())
{
try
{
... | class class_name[name] begin[{]
method[waitUntilFinished, return_type[void], modifier[public], parameter[]] begin[{]
call[.flushTermination, parameter[]]
call[.flushUpdate, parameter[]]
call[.flushInsert, parameter[]]
call[.shutdown, parameter[]]
... | Keyword[public] Keyword[void] identifier[waitUntilFinished] operator[SEP] operator[SEP] {
identifier[flushTermination] operator[SEP] operator[SEP] operator[SEP] identifier[flushUpdate] operator[SEP] operator[SEP] operator[SEP] identifier[flushInsert] operator[SEP] operator[SEP] operator[SEP] identifier[shutdown]... |
public synchronized WriteSession createSession() throws ApplicationContextException {
if(this.threadSession.containsKey(Thread.currentThread().getId())) {
throw failure("Thread already has an active session");
}
if(this.delegate.isOffline()) {
throw failure("The Application Engine is off-line");
}
Wri... | class class_name[name] begin[{]
method[createSession, return_type[type[WriteSession]], modifier[synchronized public], parameter[]] begin[{]
if[THIS[member[None.threadSession]call[None.containsKey, parameter[call[Thread.currentThread, parameter[]]]]]] begin[{]
ThrowStatement(expressi... | Keyword[public] Keyword[synchronized] identifier[WriteSession] identifier[createSession] operator[SEP] operator[SEP] Keyword[throws] identifier[ApplicationContextException] {
Keyword[if] operator[SEP] Keyword[this] operator[SEP] identifier[threadSession] operator[SEP] identifier[containsKey] operator[SEP] identi... |
int assignPosition(Id id) throws RepositoryException {
int pos = -1;
if (!freePositions.isEmpty()) {
pos = freePositions.remove(0);
} else {
pos = nextPos++;
ensureCapacity(pos);
}
idPosMap.put(id, pos);
for (HierarchicalTypeStore s ... | class class_name[name] begin[{]
method[assignPosition, return_type[type[int]], modifier[default], parameter[id]] begin[{]
local_variable[type[int], pos]
if[call[freePositions.isEmpty, parameter[]]] begin[{]
assign[member[.pos], call[freePositions.remove, paramete... | Keyword[int] identifier[assignPosition] operator[SEP] identifier[Id] identifier[id] operator[SEP] Keyword[throws] identifier[RepositoryException] {
Keyword[int] identifier[pos] operator[=] operator[-] Other[1] operator[SEP] Keyword[if] operator[SEP] operator[!] identifier[freePositions] operator[SEP] identifier[... |
public int getNumberOfElements() {
int count = 0;
for (FormSectionController section : getSections()) {
count += section.getElements().size();
}
return count;
} | class class_name[name] begin[{]
method[getNumberOfElements, return_type[type[int]], modifier[public], parameter[]] begin[{]
local_variable[type[int], count]
ForStatement(body=BlockStatement(label=None, statements=[StatementExpression(expression=Assignment(expressionl=MemberReference(member=coun... | Keyword[public] Keyword[int] identifier[getNumberOfElements] operator[SEP] operator[SEP] {
Keyword[int] identifier[count] operator[=] Other[0] operator[SEP] Keyword[for] operator[SEP] identifier[FormSectionController] identifier[section] operator[:] identifier[getSections] operator[SEP] operator[SEP] operator[S... |
public void marshall(ListApplicationSnapshotsRequest listApplicationSnapshotsRequest, ProtocolMarshaller protocolMarshaller) {
if (listApplicationSnapshotsRequest == null) {
throw new SdkClientException("Invalid argument passed to marshall(...)");
}
try {
protocolMarsha... | class class_name[name] begin[{]
method[marshall, return_type[void], modifier[public], parameter[listApplicationSnapshotsRequest, protocolMarshaller]] begin[{]
if[binary_operation[member[.listApplicationSnapshotsRequest], ==, literal[null]]] begin[{]
ThrowStatement(expression=ClassCr... | Keyword[public] Keyword[void] identifier[marshall] operator[SEP] identifier[ListApplicationSnapshotsRequest] identifier[listApplicationSnapshotsRequest] , identifier[ProtocolMarshaller] identifier[protocolMarshaller] operator[SEP] {
Keyword[if] operator[SEP] identifier[listApplicationSnapshotsRequest] operator[... |
protected List<List<Row<I>>> incorporateCounterExample(DefaultQuery<I, D> ce) {
return ObservationTableCEXHandlers.handleClassicLStar(ce, table, oracle);
} | class class_name[name] begin[{]
method[incorporateCounterExample, return_type[type[List]], modifier[protected], parameter[ce]] begin[{]
return[call[ObservationTableCEXHandlers.handleClassicLStar, parameter[member[.ce], member[.table], member[.oracle]]]]
end[}]
END[}] | Keyword[protected] identifier[List] operator[<] identifier[List] operator[<] identifier[Row] operator[<] identifier[I] operator[>] operator[>] operator[>] identifier[incorporateCounterExample] operator[SEP] identifier[DefaultQuery] operator[<] identifier[I] , identifier[D] operator[>] identifier[ce] operator[SEP] {
... |
private static void copy(Class<?> toType, Object to, Object... from) {
int f = 0, fi = 0,
length = Array.getLength(from[0]),
total = from.length > 1 ? Array.getLength(to) : length;
if ( Types.arrayDimensions(to.getClass()) == 1 ) {
for ( int i = 0; i < total; i++ ) {
... | class class_name[name] begin[{]
method[copy, return_type[void], modifier[private static], parameter[toType, to, from]] begin[{]
local_variable[type[int], f]
if[binary_operation[call[Types.arrayDimensions, parameter[call[to.getClass, parameter[]]]], ==, literal[1]]] begin[{]
... | Keyword[private] Keyword[static] Keyword[void] identifier[copy] operator[SEP] identifier[Class] operator[<] operator[?] operator[>] identifier[toType] , identifier[Object] identifier[to] , identifier[Object] operator[...] identifier[from] operator[SEP] {
Keyword[int] identifier[f] operator[=] Other[0] , ident... |
public static void readRAMFiles(DataInput in, RAMDirectory dir)
throws IOException {
int numFiles = in.readInt();
for (int i = 0; i < numFiles; i++) {
String name = Text.readString(in);
long length = in.readLong();
if (length > 0) {
// can we avoid the extra copy?
... | class class_name[name] begin[{]
method[readRAMFiles, return_type[void], modifier[public static], parameter[in, dir]] begin[{]
local_variable[type[int], numFiles]
ForStatement(body=BlockStatement(label=None, statements=[LocalVariableDeclaration(annotations=[], declarators=[VariableDeclarator(dim... | Keyword[public] Keyword[static] Keyword[void] identifier[readRAMFiles] operator[SEP] identifier[DataInput] identifier[in] , identifier[RAMDirectory] identifier[dir] operator[SEP] Keyword[throws] identifier[IOException] {
Keyword[int] identifier[numFiles] operator[=] identifier[in] operator[SEP] identifier[readI... |
public List<Map> getValues() {
if (values == null) {
values = Reflection.toTypedList(getMap().get(BATCH_INSERTION_VALUES_KEY), Map.class);
}
return values;
} | class class_name[name] begin[{]
method[getValues, return_type[type[List]], modifier[public], parameter[]] begin[{]
if[binary_operation[member[.values], ==, literal[null]]] begin[{]
assign[member[.values], call[Reflection.toTypedList, parameter[call[.getMap, parameter[]],... | Keyword[public] identifier[List] operator[<] identifier[Map] operator[>] identifier[getValues] operator[SEP] operator[SEP] {
Keyword[if] operator[SEP] identifier[values] operator[==] Other[null] operator[SEP] {
identifier[values] operator[=] identifier[Reflection] operator[SEP] identifier[toTypedList]... |
void execute(final ActivityHandle realHandle, final ActivityHandle refHandle,
final FireableEventType eventType, final Object event,
final Address address, final ReceivableService receivableService,
final int eventFlags) throws ActivityIsEndingException,
FireEventException, SLEEException,
UnrecognizedAct... | class class_name[name] begin[{]
method[execute, return_type[void], modifier[default], parameter[realHandle, refHandle, eventType, event, address, receivableService, eventFlags]] begin[{]
local_variable[type[SleeTransaction], tx]
TryStatement(block=[StatementExpression(expression=MethodInvocatio... | Keyword[void] identifier[execute] operator[SEP] Keyword[final] identifier[ActivityHandle] identifier[realHandle] , Keyword[final] identifier[ActivityHandle] identifier[refHandle] , Keyword[final] identifier[FireableEventType] identifier[eventType] , Keyword[final] identifier[Object] identifier[event] , Keyword[fina... |
public static void setVCConnectionType(VirtualConnection vc, ConnectionType connType) {
if (vc == null || connType == null) {
return;
}
Map<Object, Object> map = vc.getStateMap();
// Internal connections are both inbound and outbound (they're connections
// to ourse... | class class_name[name] begin[{]
method[setVCConnectionType, return_type[void], modifier[public static], parameter[vc, connType]] begin[{]
if[binary_operation[binary_operation[member[.vc], ==, literal[null]], ||, binary_operation[member[.connType], ==, literal[null]]]] begin[{]
retur... | Keyword[public] Keyword[static] Keyword[void] identifier[setVCConnectionType] operator[SEP] identifier[VirtualConnection] identifier[vc] , identifier[ConnectionType] identifier[connType] operator[SEP] {
Keyword[if] operator[SEP] identifier[vc] operator[==] Other[null] operator[||] identifier[connType] operator[... |
public int poll(final FragmentHandler fragmentHandler, final int fragmentLimit)
{
if (isClosed)
{
return 0;
}
final long position = subscriberPosition.get();
return TermReader.read(
activeTermBuffer(position),
(int)position & termLengthMa... | class class_name[name] begin[{]
method[poll, return_type[type[int]], modifier[public], parameter[fragmentHandler, fragmentLimit]] begin[{]
if[member[.isClosed]] begin[{]
return[literal[0]]
else begin[{]
None
end[}]
local_variable[type[long], position]
... | Keyword[public] Keyword[int] identifier[poll] operator[SEP] Keyword[final] identifier[FragmentHandler] identifier[fragmentHandler] , Keyword[final] Keyword[int] identifier[fragmentLimit] operator[SEP] {
Keyword[if] operator[SEP] identifier[isClosed] operator[SEP] {
Keyword[return] Other[0] operator[S... |
private static void loginOnly(final String userId, final String password, final TokenChangedHandler tokenHandler) {
LoginRequest request = new LoginRequest();
request.setLogin(userId);
request.setPassword(password);
GwtCommand command = new GwtCommand(LoginRequest.COMMAND);
command.setCommandRequest(request);... | class class_name[name] begin[{]
method[loginOnly, return_type[void], modifier[private static], parameter[userId, password, tokenHandler]] begin[{]
local_variable[type[LoginRequest], request]
call[request.setLogin, parameter[member[.userId]]]
call[request.setPassword, par... | Keyword[private] Keyword[static] Keyword[void] identifier[loginOnly] operator[SEP] Keyword[final] identifier[String] identifier[userId] , Keyword[final] identifier[String] identifier[password] , Keyword[final] identifier[TokenChangedHandler] identifier[tokenHandler] operator[SEP] {
identifier[LoginRequest] ide... |
public Observable<List<EntityRole>> getClosedListEntityRolesAsync(UUID appId, String versionId, UUID entityId) {
return getClosedListEntityRolesWithServiceResponseAsync(appId, versionId, entityId).map(new Func1<ServiceResponse<List<EntityRole>>, List<EntityRole>>() {
@Override
public Lis... | class class_name[name] begin[{]
method[getClosedListEntityRolesAsync, return_type[type[Observable]], modifier[public], parameter[appId, versionId, entityId]] begin[{]
return[call[.getClosedListEntityRolesWithServiceResponseAsync, parameter[member[.appId], member[.versionId], member[.entityId]]]]
en... | Keyword[public] identifier[Observable] operator[<] identifier[List] operator[<] identifier[EntityRole] operator[>] operator[>] identifier[getClosedListEntityRolesAsync] operator[SEP] identifier[UUID] identifier[appId] , identifier[String] identifier[versionId] , identifier[UUID] identifier[entityId] operator[SEP] {
... |
@Override
public void mouseClicked(MouseEvent evt) {
if (evt.getClickCount() == 2) {
triggerMaximisation((Component) evt.getSource());
}
} | class class_name[name] begin[{]
method[mouseClicked, return_type[void], modifier[public], parameter[evt]] begin[{]
if[binary_operation[call[evt.getClickCount, parameter[]], ==, literal[2]]] begin[{]
call[.triggerMaximisation, parameter[Cast(expression=MethodInvocation(ar... | annotation[@] identifier[Override] Keyword[public] Keyword[void] identifier[mouseClicked] operator[SEP] identifier[MouseEvent] identifier[evt] operator[SEP] {
Keyword[if] operator[SEP] identifier[evt] operator[SEP] identifier[getClickCount] operator[SEP] operator[SEP] operator[==] Other[2] operator[SEP] {
... |
public void addEmptyRow(int row, int size) {
layoutComponents.add( new LayoutComponent( null, size, row, null));
} | class class_name[name] begin[{]
method[addEmptyRow, return_type[void], modifier[public], parameter[row, size]] begin[{]
call[layoutComponents.add, parameter[ClassCreator(arguments=[Literal(postfix_operators=[], prefix_operators=[], qualifier=None, selectors=[], value=null), MemberReference(memb... | Keyword[public] Keyword[void] identifier[addEmptyRow] operator[SEP] Keyword[int] identifier[row] , Keyword[int] identifier[size] operator[SEP] {
identifier[layoutComponents] operator[SEP] identifier[add] operator[SEP] Keyword[new] identifier[LayoutComponent] operator[SEP] Other[null] , identifier[size] , iden... |
private void addQueryToMap(String query)
{
String[] params = SS.split(query);
for(int i = 0; i < params.length; i++)
{
String param = params[i];
if(param.length() == 0)
continue;
int idx = param.indexOf('=');
if(idx == -1)
addParameterToMap(decode(param), null);
... | class class_name[name] begin[{]
method[addQueryToMap, return_type[void], modifier[private], parameter[query]] begin[{]
local_variable[type[String], params]
ForStatement(body=BlockStatement(label=None, statements=[LocalVariableDeclaration(annotations=[], declarators=[VariableDeclarator(dimension... | Keyword[private] Keyword[void] identifier[addQueryToMap] operator[SEP] identifier[String] identifier[query] operator[SEP] {
identifier[String] operator[SEP] operator[SEP] identifier[params] operator[=] identifier[SS] operator[SEP] identifier[split] operator[SEP] identifier[query] operator[SEP] operator[SEP] Keyw... |
@Override
public int getUOWTimeout() throws IllegalStateException {
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
Tr.entry(tc, "getUOWTimeout", this);
final int timeout;
final int uowType = getUOWType();
switch (uowType) {
case UOWSynchron... | class class_name[name] begin[{]
method[getUOWTimeout, return_type[type[int]], modifier[public], parameter[]] begin[{]
if[binary_operation[call[TraceComponent.isAnyTracingEnabled, parameter[]], &&, call[tc.isEntryEnabled, parameter[]]]] begin[{]
call[Tr.entry, parameter[member[.tc], ... | annotation[@] identifier[Override] Keyword[public] Keyword[int] identifier[getUOWTimeout] operator[SEP] operator[SEP] Keyword[throws] identifier[IllegalStateException] {
Keyword[if] operator[SEP] identifier[TraceComponent] operator[SEP] identifier[isAnyTracingEnabled] operator[SEP] operator[SEP] operator[&&] ide... |
public Matrix4f translationRotate(float tx, float ty, float tz, float qx, float qy, float qz, float qw) {
float w2 = qw * qw;
float x2 = qx * qx;
float y2 = qy * qy;
float z2 = qz * qz;
float zw = qz * qw;
float xy = qx * qy;
float xz = qx * qz;
float yw =... | class class_name[name] begin[{]
method[translationRotate, return_type[type[Matrix4f]], modifier[public], parameter[tx, ty, tz, qx, qy, qz, qw]] begin[{]
local_variable[type[float], w2]
local_variable[type[float], x2]
local_variable[type[float], y2]
local_variable[type[float], z2... | Keyword[public] identifier[Matrix4f] identifier[translationRotate] operator[SEP] Keyword[float] identifier[tx] , Keyword[float] identifier[ty] , Keyword[float] identifier[tz] , Keyword[float] identifier[qx] , Keyword[float] identifier[qy] , Keyword[float] identifier[qz] , Keyword[float] identifier[qw] operator[SE... |
public static Filter populateFilter(final EntityManager entityManager, final Map<String, String> paramMap, final String filterName,
final String tagPrefix, final String groupTagPrefix, final String categoryInternalPrefix, final String categoryExternalPrefix,
final String localePrefix, final IFie... | class class_name[name] begin[{]
method[populateFilter, return_type[type[Filter]], modifier[public static], parameter[entityManager, paramMap, filterName, tagPrefix, groupTagPrefix, categoryInternalPrefix, categoryExternalPrefix, localePrefix, fieldFilter]] begin[{]
local_variable[type[Integer], filterI... | Keyword[public] Keyword[static] identifier[Filter] identifier[populateFilter] operator[SEP] Keyword[final] identifier[EntityManager] identifier[entityManager] , Keyword[final] identifier[Map] operator[<] identifier[String] , identifier[String] operator[>] identifier[paramMap] , Keyword[final] identifier[String] iden... |
public void billingAccount_service_serviceName_PUT(String billingAccount, String serviceName, OvhTelephonyService body) throws IOException {
String qPath = "/telephony/{billingAccount}/service/{serviceName}";
StringBuilder sb = path(qPath, billingAccount, serviceName);
exec(qPath, "PUT", sb.toString(), body);
} | class class_name[name] begin[{]
method[billingAccount_service_serviceName_PUT, return_type[void], modifier[public], parameter[billingAccount, serviceName, body]] begin[{]
local_variable[type[String], qPath]
local_variable[type[StringBuilder], sb]
call[.exec, parameter[member[.qP... | Keyword[public] Keyword[void] identifier[billingAccount_service_serviceName_PUT] operator[SEP] identifier[String] identifier[billingAccount] , identifier[String] identifier[serviceName] , identifier[OvhTelephonyService] identifier[body] operator[SEP] Keyword[throws] identifier[IOException] {
identifier[String]... |
public void write(String logService, LogLevel level, String msg, Throwable t)
{
doWrite(logService, level, msg, t);
} | class class_name[name] begin[{]
method[write, return_type[void], modifier[public], parameter[logService, level, msg, t]] begin[{]
call[.doWrite, parameter[member[.logService], member[.level], member[.msg], member[.t]]]
end[}]
END[}] | Keyword[public] Keyword[void] identifier[write] operator[SEP] identifier[String] identifier[logService] , identifier[LogLevel] identifier[level] , identifier[String] identifier[msg] , identifier[Throwable] identifier[t] operator[SEP] {
identifier[doWrite] operator[SEP] identifier[logService] , identifier[lev... |
@Override
public <T> T get(String name, Class<T> type) {
Object value = get(name);
if (value == null) {
value = findInherited(name, type);
if (value == null) {
value = UNDEFINED;
}
put(name, value); // cache the found value
}
... | class class_name[name] begin[{]
method[get, return_type[type[T]], modifier[public], parameter[name, type]] begin[{]
local_variable[type[Object], value]
if[binary_operation[member[.value], ==, literal[null]]] begin[{]
assign[member[.value], call[.findInherited, pa... | annotation[@] identifier[Override] Keyword[public] operator[<] identifier[T] operator[>] identifier[T] identifier[get] operator[SEP] identifier[String] identifier[name] , identifier[Class] operator[<] identifier[T] operator[>] identifier[type] operator[SEP] {
identifier[Object] identifier[value] operator[=] ide... |
public void setPortOffset(String socketBindingGroupName, String sysPropName, int offset) throws Exception {
String offsetValue;
if (sysPropName != null) {
offsetValue = "${" + sysPropName + ":" + offset + "}";
} else {
offsetValue = String.valueOf(offset);
}
... | class class_name[name] begin[{]
method[setPortOffset, return_type[void], modifier[public], parameter[socketBindingGroupName, sysPropName, offset]] begin[{]
local_variable[type[String], offsetValue]
if[binary_operation[member[.sysPropName], !=, literal[null]]] begin[{]
... | Keyword[public] Keyword[void] identifier[setPortOffset] operator[SEP] identifier[String] identifier[socketBindingGroupName] , identifier[String] identifier[sysPropName] , Keyword[int] identifier[offset] operator[SEP] Keyword[throws] identifier[Exception] {
identifier[String] identifier[offsetValue] operator[SE... |
public void scheduleSaveConversationData() {
boolean scheduled = conversationDataQueue().dispatchAsyncOnce(saveConversationTask);
if (scheduled) {
ApptentiveLog.v(CONVERSATION, "Scheduling conversation save.");
} else {
ApptentiveLog.d(CONVERSATION, "Conversation save already scheduled.");
}
} | class class_name[name] begin[{]
method[scheduleSaveConversationData, return_type[void], modifier[public], parameter[]] begin[{]
local_variable[type[boolean], scheduled]
if[member[.scheduled]] begin[{]
call[ApptentiveLog.v, parameter[member[.CONVERSATION], literal... | Keyword[public] Keyword[void] identifier[scheduleSaveConversationData] operator[SEP] operator[SEP] {
Keyword[boolean] identifier[scheduled] operator[=] identifier[conversationDataQueue] operator[SEP] operator[SEP] operator[SEP] identifier[dispatchAsyncOnce] operator[SEP] identifier[saveConversationTask] operator... |
public static Viewable newProtected(String name, Object model) {
return new Viewable(PROTECTED_DIR_PATH + getPath(name), model);
} | class class_name[name] begin[{]
method[newProtected, return_type[type[Viewable]], modifier[public static], parameter[name, model]] begin[{]
return[ClassCreator(arguments=[BinaryOperation(operandl=MemberReference(member=PROTECTED_DIR_PATH, postfix_operators=[], prefix_operators=[], qualifier=, selectors... | Keyword[public] Keyword[static] identifier[Viewable] identifier[newProtected] operator[SEP] identifier[String] identifier[name] , identifier[Object] identifier[model] operator[SEP] {
Keyword[return] Keyword[new] identifier[Viewable] operator[SEP] identifier[PROTECTED_DIR_PATH] operator[+] identifier[getPath] op... |
public static void writeAll(WritableByteChannel ch, ByteBuffer bb) throws IOException
{
int count = 0;
while (bb.hasRemaining())
{
int rc = ch.write(bb);
if (rc == 0)
{
count++;
}
if (count > 100)
... | class class_name[name] begin[{]
method[writeAll, return_type[void], modifier[public static], parameter[ch, bb]] begin[{]
local_variable[type[int], count]
while[call[bb.hasRemaining, parameter[]]] begin[{]
local_variable[type[int], rc]
if[binary_operat... | Keyword[public] Keyword[static] Keyword[void] identifier[writeAll] operator[SEP] identifier[WritableByteChannel] identifier[ch] , identifier[ByteBuffer] identifier[bb] operator[SEP] Keyword[throws] identifier[IOException] {
Keyword[int] identifier[count] operator[=] Other[0] operator[SEP] Keyword[while] operato... |
public synchronized void sortResultsByEnergies() throws CDKException {
// System.out.println("\nSort By Energies");
Map<Integer, Map<Integer, Integer>> allEnergyMCS = new TreeMap<Integer, Map<Integer, Integer>>();
Map<Integer, Map<IAtom, IAtom>> allEnergyAtomMCS = new TreeMap<Integer, Ma... | class class_name[name] begin[{]
method[sortResultsByEnergies, return_type[void], modifier[synchronized public], parameter[]] begin[{]
local_variable[type[Map], allEnergyMCS]
local_variable[type[Map], allEnergyAtomMCS]
local_variable[type[Map], stereoScoreMap]
local_variable[type... | Keyword[public] Keyword[synchronized] Keyword[void] identifier[sortResultsByEnergies] operator[SEP] operator[SEP] Keyword[throws] identifier[CDKException] {
identifier[Map] operator[<] identifier[Integer] , identifier[Map] operator[<] identifier[Integer] , identifier[Integer] operator[>] operator[>] identifier... |
protected final void flushBuffer(boolean closeConn) throws IOException {
if (!flushed && closeConn) {
response.setHeader("connection", "close");
// if(showVersion)response.setHeader(Constants.NAME+"-Version", version);
}
initOut();
byte[] barr = _toString(true).getBytes(ReqRspUtil.getCharacterEncoding(nu... | class class_name[name] begin[{]
method[flushBuffer, return_type[void], modifier[final protected], parameter[closeConn]] begin[{]
if[binary_operation[member[.flushed], &&, member[.closeConn]]] begin[{]
call[response.setHeader, parameter[literal["connection"], literal["clo... | Keyword[protected] Keyword[final] Keyword[void] identifier[flushBuffer] operator[SEP] Keyword[boolean] identifier[closeConn] operator[SEP] Keyword[throws] identifier[IOException] {
Keyword[if] operator[SEP] operator[!] identifier[flushed] operator[&&] identifier[closeConn] operator[SEP] {
identifier[r... |
private Node getParent(Node n) {
if (n.y_s == null) {
return null;
}
Node c = n.y_s;
if (c.o_c == n) {
return c;
}
Node p1 = c.y_s;
if (p1 != null && p1.o_c == n) {
return p1;
}
return c;
} | class class_name[name] begin[{]
method[getParent, return_type[type[Node]], modifier[private], parameter[n]] begin[{]
if[binary_operation[member[n.y_s], ==, literal[null]]] begin[{]
return[literal[null]]
else begin[{]
None
end[}]
local_variable[type[Node], c]
... | Keyword[private] identifier[Node] identifier[getParent] operator[SEP] identifier[Node] identifier[n] operator[SEP] {
Keyword[if] operator[SEP] identifier[n] operator[SEP] identifier[y_s] operator[==] Other[null] operator[SEP] {
Keyword[return] Other[null] operator[SEP]
}
identifier[Node]... |
protected Specification<ENTITY> buildStringSpecification(StringFilter filter, SingularAttribute<? super ENTITY,
String> field) {
if (filter.getEquals() != null) {
return equalsSpecification(field, filter.getEquals());
} else if (filter.getIn() != null) {
return valueIn(fi... | class class_name[name] begin[{]
method[buildStringSpecification, return_type[type[Specification]], modifier[protected], parameter[filter, field]] begin[{]
if[binary_operation[call[filter.getEquals, parameter[]], !=, literal[null]]] begin[{]
return[call[.equalsSpecification, paramete... | Keyword[protected] identifier[Specification] operator[<] identifier[ENTITY] operator[>] identifier[buildStringSpecification] operator[SEP] identifier[StringFilter] identifier[filter] , identifier[SingularAttribute] operator[<] operator[?] Keyword[super] identifier[ENTITY] , identifier[String] operator[>] identifier[f... |
public Icon clip(int offsetX, int offsetY, int width, int height)
{
this.width = width;
this.height = height;
offset(offsetX, offsetY);
return this;
} | class class_name[name] begin[{]
method[clip, return_type[type[Icon]], modifier[public], parameter[offsetX, offsetY, width, height]] begin[{]
assign[THIS[member[None.width]], member[.width]]
assign[THIS[member[None.height]], member[.height]]
call[.offset, paramete... | Keyword[public] identifier[Icon] identifier[clip] operator[SEP] Keyword[int] identifier[offsetX] , Keyword[int] identifier[offsetY] , Keyword[int] identifier[width] , Keyword[int] identifier[height] operator[SEP] {
Keyword[this] operator[SEP] identifier[width] operator[=] identifier[width] operator[SEP] Keywo... |
public void addFilter(Filter filter) {
List<Filter> filters = filterFactory.getAllFilter();
int index = searchFilterIndex(filters, filter.getId(), 0, filters.size());
if (index == -1) {
// not found - put at the end
filters.add(filter);
} else {
filters.add(index, filter);
}
} | class class_name[name] begin[{]
method[addFilter, return_type[void], modifier[public], parameter[filter]] begin[{]
local_variable[type[List], filters]
local_variable[type[int], index]
if[binary_operation[member[.index], ==, literal[1]]] begin[{]
call[filt... | Keyword[public] Keyword[void] identifier[addFilter] operator[SEP] identifier[Filter] identifier[filter] operator[SEP] {
identifier[List] operator[<] identifier[Filter] operator[>] identifier[filters] operator[=] identifier[filterFactory] operator[SEP] identifier[getAllFilter] operator[SEP] operator[SEP] operator... |
@Override
public void writeByte(byte value) throws JMSException
{
try
{
getOutput().writeByte(value);
}
catch (IOException e)
{
throw new FFMQException("Cannot write message body","IO_ERROR",e);
}
} | class class_name[name] begin[{]
method[writeByte, return_type[void], modifier[public], parameter[value]] begin[{]
TryStatement(block=[StatementExpression(expression=MethodInvocation(arguments=[], member=getOutput, postfix_operators=[], prefix_operators=[], qualifier=, selectors=[MethodInvocation(argume... | annotation[@] identifier[Override] Keyword[public] Keyword[void] identifier[writeByte] operator[SEP] Keyword[byte] identifier[value] operator[SEP] Keyword[throws] identifier[JMSException] {
Keyword[try] {
identifier[getOutput] operator[SEP] operator[SEP] operator[SEP] identifier[writeByte] operator[SE... |
protected double calcDistTSAndPattern(double[] ts, double[] pValue) {
double INF = 10000000000000000000f;
double bestDist = INF;
int patternLen = pValue.length;
int lastStartP = ts.length - pValue.length + 1;
if (lastStartP < 1)
return bestDist;
Random rand = new Random();
... | class class_name[name] begin[{]
method[calcDistTSAndPattern, return_type[type[double]], modifier[protected], parameter[ts, pValue]] begin[{]
local_variable[type[double], INF]
local_variable[type[double], bestDist]
local_variable[type[int], patternLen]
local_variable[type[int], l... | Keyword[protected] Keyword[double] identifier[calcDistTSAndPattern] operator[SEP] Keyword[double] operator[SEP] operator[SEP] identifier[ts] , Keyword[double] operator[SEP] operator[SEP] identifier[pValue] operator[SEP] {
Keyword[double] identifier[INF] operator[=] literal[Float] operator[SEP] Keyword[double] i... |
public PropertyComponent getProperty(String code) {
for (PropertyComponent pd : getProperty()) {
if (pd.getCode().equalsIgnoreCase(code))
return pd;
}
return null;
} | class class_name[name] begin[{]
method[getProperty, return_type[type[PropertyComponent]], modifier[public], parameter[code]] begin[{]
ForStatement(body=BlockStatement(label=None, statements=[IfStatement(condition=MethodInvocation(arguments=[], member=getCode, postfix_operators=[], prefix_operators=[], ... | Keyword[public] identifier[PropertyComponent] identifier[getProperty] operator[SEP] identifier[String] identifier[code] operator[SEP] {
Keyword[for] operator[SEP] identifier[PropertyComponent] identifier[pd] operator[:] identifier[getProperty] operator[SEP] operator[SEP] operator[SEP] {
Keyword[if] o... |
protected String nextLatinString(int c) throws IOException
{
isb.clear();
if ( c > 65280 ) c -= 65248;
if ( c >= 65 && c <= 90 ) c += 32;
isb.append((char)c);
int ch;
int _ctype = 0;
ctrlMask &= ~ISegment.CHECK_EC_MASK;
while ( (ch =... | class class_name[name] begin[{]
method[nextLatinString, return_type[type[String]], modifier[protected], parameter[c]] begin[{]
call[isb.clear, parameter[]]
if[binary_operation[member[.c], >, literal[65280]]] begin[{]
assign[member[.c], literal[65248]]
else be... | Keyword[protected] identifier[String] identifier[nextLatinString] operator[SEP] Keyword[int] identifier[c] operator[SEP] Keyword[throws] identifier[IOException] {
identifier[isb] operator[SEP] identifier[clear] operator[SEP] operator[SEP] operator[SEP] Keyword[if] operator[SEP] identifier[c] operator[>] Other[65... |
public ByteBuffer createMessage(boolean compress, int version)
{
int header = 0;
// set compression bit.
if (compress)
header |= 4;
// set streaming bit
header |= 8;
// Setting up the version bit
header |= (version << 8);
byte[] bytes;
... | class class_name[name] begin[{]
method[createMessage, return_type[type[ByteBuffer]], modifier[public], parameter[compress, version]] begin[{]
local_variable[type[int], header]
if[member[.compress]] begin[{]
assign[member[.header], literal[4]]
else begin[{]
None
... | Keyword[public] identifier[ByteBuffer] identifier[createMessage] operator[SEP] Keyword[boolean] identifier[compress] , Keyword[int] identifier[version] operator[SEP] {
Keyword[int] identifier[header] operator[=] Other[0] operator[SEP] Keyword[if] operator[SEP] identifier[compress] operator[SEP] identifier[heade... |
public static boolean isUnanimousCandidate(final ClusterMember[] clusterMembers, final ClusterMember candidate)
{
for (final ClusterMember member : clusterMembers)
{
if (NULL_POSITION == member.logPosition || compareLog(candidate, member) < 0)
{
return false;
... | class class_name[name] begin[{]
method[isUnanimousCandidate, return_type[type[boolean]], modifier[public static], parameter[clusterMembers, candidate]] begin[{]
ForStatement(body=BlockStatement(label=None, statements=[IfStatement(condition=BinaryOperation(operandl=BinaryOperation(operandl=MemberReferen... | Keyword[public] Keyword[static] Keyword[boolean] identifier[isUnanimousCandidate] operator[SEP] Keyword[final] identifier[ClusterMember] operator[SEP] operator[SEP] identifier[clusterMembers] , Keyword[final] identifier[ClusterMember] identifier[candidate] operator[SEP] {
Keyword[for] operator[SEP] Keyword[fina... |
public static String getBase64EncodedImage(String imgSrc, BinaryResourcesHandler binaryRsHandler,
HttpServletRequest request) {
String encodedResult = null;
if (null == binaryRsHandler) {
throw new JawrLinkRenderingException(
"You are using a Jawr image tag while the Jawr Image servlet has not been init... | class class_name[name] begin[{]
method[getBase64EncodedImage, return_type[type[String]], modifier[public static], parameter[imgSrc, binaryRsHandler, request]] begin[{]
local_variable[type[String], encodedResult]
if[binary_operation[literal[null], ==, member[.binaryRsHandler]]] begin[{]
... | Keyword[public] Keyword[static] identifier[String] identifier[getBase64EncodedImage] operator[SEP] identifier[String] identifier[imgSrc] , identifier[BinaryResourcesHandler] identifier[binaryRsHandler] , identifier[HttpServletRequest] identifier[request] operator[SEP] {
identifier[String] identifier[encodedRes... |
@Nonnull
public HCNodeList createSelectedFileEdit (@Nullable final String sPlaceholder)
{
final HCEdit aEdit = new HCEdit ().setPlaceholder (sPlaceholder).setReadOnly (true);
final HCScriptInline aScript = new HCScriptInline (JQuery.idRef (m_aEdit)
... | class class_name[name] begin[{]
method[createSelectedFileEdit, return_type[type[HCNodeList]], modifier[public], parameter[sPlaceholder]] begin[{]
local_variable[type[HCEdit], aEdit]
local_variable[type[HCScriptInline], aScript]
return[ClassCreator(arguments=[], body=None, constructor_ty... | annotation[@] identifier[Nonnull] Keyword[public] identifier[HCNodeList] identifier[createSelectedFileEdit] operator[SEP] annotation[@] identifier[Nullable] Keyword[final] identifier[String] identifier[sPlaceholder] operator[SEP] {
Keyword[final] identifier[HCEdit] identifier[aEdit] operator[=] Keyword[new] iden... |
private static Matcher<ExpressionTree> methodReturnsSameTypeAsReceiver() {
return new Matcher<ExpressionTree>() {
@Override
public boolean matches(ExpressionTree expressionTree, VisitorState state) {
return isSameType(
ASTHelpers.getReceiverType(expressionTree),
ASTHelper... | class class_name[name] begin[{]
method[methodReturnsSameTypeAsReceiver, return_type[type[Matcher]], modifier[private static], parameter[]] begin[{]
return[ClassCreator(arguments=[], body=[MethodDeclaration(annotations=[Annotation(element=None, name=Override)], body=[ReturnStatement(expression=MethodInv... | Keyword[private] Keyword[static] identifier[Matcher] operator[<] identifier[ExpressionTree] operator[>] identifier[methodReturnsSameTypeAsReceiver] operator[SEP] operator[SEP] {
Keyword[return] Keyword[new] identifier[Matcher] operator[<] identifier[ExpressionTree] operator[>] operator[SEP] operator[SEP] {
... |
public static SslContextBuilder forServer(File keyCertChainFile, File keyFile) {
return new SslContextBuilder(true).keyManager(keyCertChainFile, keyFile);
} | class class_name[name] begin[{]
method[forServer, return_type[type[SslContextBuilder]], modifier[public static], parameter[keyCertChainFile, keyFile]] begin[{]
return[ClassCreator(arguments=[Literal(postfix_operators=[], prefix_operators=[], qualifier=None, selectors=[], value=true)], body=None, constr... | Keyword[public] Keyword[static] identifier[SslContextBuilder] identifier[forServer] operator[SEP] identifier[File] identifier[keyCertChainFile] , identifier[File] identifier[keyFile] operator[SEP] {
Keyword[return] Keyword[new] identifier[SslContextBuilder] operator[SEP] literal[boolean] operator[SEP] operator[... |
public static File locateFile(String name, String basedir) {
// Try exact match first.
File f = new File(name);
if(f.exists()) {
return f;
}
// Try with base directory
if(basedir != null) {
if((f = new File(basedir, name)).exists()) {
return f;
}
}
// try stripp... | class class_name[name] begin[{]
method[locateFile, return_type[type[File]], modifier[public static], parameter[name, basedir]] begin[{]
local_variable[type[File], f]
if[call[f.exists, parameter[]]] begin[{]
return[member[.f]]
else begin[{]
None
end[}]
... | Keyword[public] Keyword[static] identifier[File] identifier[locateFile] operator[SEP] identifier[String] identifier[name] , identifier[String] identifier[basedir] operator[SEP] {
identifier[File] identifier[f] operator[=] Keyword[new] identifier[File] operator[SEP] identifier[name] operator[SEP] operator[SEP] K... |
public static JaxWsServerMetaData getJaxWsServerMetaData(ModuleMetaData mmd) {
JaxWsServerMetaData serverMetaData = null;
if (mmd != null) {
if (tc.isDebugEnabled()) {
Tr.debug(tc, "Getting client metadata from module metadata instance: " + mmd);
}
J... | class class_name[name] begin[{]
method[getJaxWsServerMetaData, return_type[type[JaxWsServerMetaData]], modifier[public static], parameter[mmd]] begin[{]
local_variable[type[JaxWsServerMetaData], serverMetaData]
if[binary_operation[member[.mmd], !=, literal[null]]] begin[{]
... | Keyword[public] Keyword[static] identifier[JaxWsServerMetaData] identifier[getJaxWsServerMetaData] operator[SEP] identifier[ModuleMetaData] identifier[mmd] operator[SEP] {
identifier[JaxWsServerMetaData] identifier[serverMetaData] operator[=] Other[null] operator[SEP] Keyword[if] operator[SEP] identifier[mmd] op... |
public double foldNonZeroInRow(int i, VectorAccumulator accumulator) {
eachNonZeroInRow(i, Vectors.asAccumulatorProcedure(accumulator));
return accumulator.accumulate();
} | class class_name[name] begin[{]
method[foldNonZeroInRow, return_type[type[double]], modifier[public], parameter[i, accumulator]] begin[{]
call[.eachNonZeroInRow, parameter[member[.i], call[Vectors.asAccumulatorProcedure, parameter[member[.accumulator]]]]]
return[call[accumulator.accumul... | Keyword[public] Keyword[double] identifier[foldNonZeroInRow] operator[SEP] Keyword[int] identifier[i] , identifier[VectorAccumulator] identifier[accumulator] operator[SEP] {
identifier[eachNonZeroInRow] operator[SEP] identifier[i] , identifier[Vectors] operator[SEP] identifier[asAccumulatorProcedure] operator[... |
public Map<String, List<String>> unapplyAll(Iterable<String> values)
{
if (values == null) {
return Collections.emptyMap();
}
Map<String, List<String>> map = new HashMap<>();
for (String value : values) {
map.put(value, unapply(value));
}
return map;
} | class class_name[name] begin[{]
method[unapplyAll, return_type[type[Map]], modifier[public], parameter[values]] begin[{]
if[binary_operation[member[.values], ==, literal[null]]] begin[{]
return[call[Collections.emptyMap, parameter[]]]
else begin[{]
None
end[}]
... | Keyword[public] identifier[Map] operator[<] identifier[String] , identifier[List] operator[<] identifier[String] operator[>] operator[>] identifier[unapplyAll] operator[SEP] identifier[Iterable] operator[<] identifier[String] operator[>] identifier[values] operator[SEP] {
Keyword[if] operator[SEP] identifier[va... |
private LogChunkType readNextChunk()
{
// clear the current chunk
currentChunk = Slices.EMPTY_SLICE;
// read the next block if necessary
if (currentBlock.available() < HEADER_SIZE) {
if (!readNextBlock()) {
if (eof) {
return EOF;
... | class class_name[name] begin[{]
method[readNextChunk, return_type[type[LogChunkType]], modifier[private], parameter[]] begin[{]
assign[member[.currentChunk], member[Slices.EMPTY_SLICE]]
if[binary_operation[call[currentBlock.available, parameter[]], <, member[.HEADER_SIZE]]] begi... | Keyword[private] identifier[LogChunkType] identifier[readNextChunk] operator[SEP] operator[SEP] {
identifier[currentChunk] operator[=] identifier[Slices] operator[SEP] identifier[EMPTY_SLICE] operator[SEP] Keyword[if] operator[SEP] identifier[currentBlock] operator[SEP] identifier[available] operator[SEP] operat... |
public void send(Type type, final String message) {
final CmsNotificationMessage notificationMessage = new CmsNotificationMessage(Mode.NORMAL, type, message);
m_messages.add(notificationMessage);
if (hasWidget()) {
m_widget.addMessage(notificationMessage);
}
Timer ti... | class class_name[name] begin[{]
method[send, return_type[void], modifier[public], parameter[type, message]] begin[{]
local_variable[type[CmsNotificationMessage], notificationMessage]
call[m_messages.add, parameter[member[.notificationMessage]]]
if[call[.hasWidget, parame... | Keyword[public] Keyword[void] identifier[send] operator[SEP] identifier[Type] identifier[type] , Keyword[final] identifier[String] identifier[message] operator[SEP] {
Keyword[final] identifier[CmsNotificationMessage] identifier[notificationMessage] operator[=] Keyword[new] identifier[CmsNotificationMessage] ope... |
public OPartitionedObjectPool.PoolEntry<ScriptEngine> acquireDatabaseEngine(final String databaseName, final String language) {
ODatabaseScriptManager dbManager = dbManagers.get(databaseName);
if (dbManager == null) {
// CREATE A NEW DATABASE SCRIPT MANAGER
dbManager = new ODatabaseScriptManager... | class class_name[name] begin[{]
method[acquireDatabaseEngine, return_type[type[OPartitionedObjectPool]], modifier[public], parameter[databaseName, language]] begin[{]
local_variable[type[ODatabaseScriptManager], dbManager]
if[binary_operation[member[.dbManager], ==, literal[null]]] begi... | Keyword[public] identifier[OPartitionedObjectPool] operator[SEP] identifier[PoolEntry] operator[<] identifier[ScriptEngine] operator[>] identifier[acquireDatabaseEngine] operator[SEP] Keyword[final] identifier[String] identifier[databaseName] , Keyword[final] identifier[String] identifier[language] operator[SEP] {
... |
private void _forwardElimination (final float scales[]) throws MatrixException
{
// Loop once per pivot row 0..nRows-1.
for (int rPivot = 0; rPivot < m_nRows - 1; ++rPivot)
{
float largestScaledElmt = 0;
int rLargest = 0;
// Starting from the pivot row rPivot, look down
// column ... | class class_name[name] begin[{]
method[_forwardElimination, return_type[void], modifier[private], parameter[scales]] begin[{]
ForStatement(body=BlockStatement(label=None, statements=[LocalVariableDeclaration(annotations=[], declarators=[VariableDeclarator(dimensions=[], initializer=Literal(postfix_oper... | Keyword[private] Keyword[void] identifier[_forwardElimination] operator[SEP] Keyword[final] Keyword[float] identifier[scales] operator[SEP] operator[SEP] operator[SEP] Keyword[throws] identifier[MatrixException] {
Keyword[for] operator[SEP] Keyword[int] identifier[rPivot] operator[=] Other[0] operator[SEP] ident... |
@Override
public UpdateEnvironmentResult updateEnvironment(UpdateEnvironmentRequest request) {
request = beforeClientExecution(request);
return executeUpdateEnvironment(request);
} | class class_name[name] begin[{]
method[updateEnvironment, return_type[type[UpdateEnvironmentResult]], modifier[public], parameter[request]] begin[{]
assign[member[.request], call[.beforeClientExecution, parameter[member[.request]]]]
return[call[.executeUpdateEnvironment, parameter[membe... | annotation[@] identifier[Override] Keyword[public] identifier[UpdateEnvironmentResult] identifier[updateEnvironment] operator[SEP] identifier[UpdateEnvironmentRequest] identifier[request] operator[SEP] {
identifier[request] operator[=] identifier[beforeClientExecution] operator[SEP] identifier[request] operator[... |
private static String readAnnotationProperty(String ref, TypeDef source, Property property) {
return convertReference(ref, source, ((ClassRef)property.getTypeRef()).getDefinition());
} | class class_name[name] begin[{]
method[readAnnotationProperty, return_type[type[String]], modifier[private static], parameter[ref, source, property]] begin[{]
return[call[.convertReference, parameter[member[.ref], member[.source], Cast(expression=MethodInvocation(arguments=[], member=getTypeRef, postfi... | Keyword[private] Keyword[static] identifier[String] identifier[readAnnotationProperty] operator[SEP] identifier[String] identifier[ref] , identifier[TypeDef] identifier[source] , identifier[Property] identifier[property] operator[SEP] {
Keyword[return] identifier[convertReference] operator[SEP] identifier[ref]... |
@FromString
public static DateTimeZone forID(String id) {
if (id == null) {
return getDefault();
}
if (id.equals("UTC")) {
return DateTimeZone.UTC;
}
DateTimeZone zone = getProvider().getZone(id);
if (zone != null) {
return zone;
... | class class_name[name] begin[{]
method[forID, return_type[type[DateTimeZone]], modifier[public static], parameter[id]] begin[{]
if[binary_operation[member[.id], ==, literal[null]]] begin[{]
return[call[.getDefault, parameter[]]]
else begin[{]
None
end[}]
... | annotation[@] identifier[FromString] Keyword[public] Keyword[static] identifier[DateTimeZone] identifier[forID] operator[SEP] identifier[String] identifier[id] operator[SEP] {
Keyword[if] operator[SEP] identifier[id] operator[==] Other[null] operator[SEP] {
Keyword[return] identifier[getDefault] opera... |
public static double[] timesMinus(final double[] v1, final double s1, final double[] v2) {
assert v1.length == v2.length : ERR_VEC_DIMENSIONS;
final double[] sub = new double[v1.length];
for(int i = 0; i < v1.length; i++) {
sub[i] = v1[i] * s1 - v2[i];
}
return sub;
} | class class_name[name] begin[{]
method[timesMinus, return_type[type[double]], modifier[public static], parameter[v1, s1, v2]] begin[{]
AssertStatement(condition=BinaryOperation(operandl=MemberReference(member=length, postfix_operators=[], prefix_operators=[], qualifier=v1, selectors=[]), operandr=Membe... | Keyword[public] Keyword[static] Keyword[double] operator[SEP] operator[SEP] identifier[timesMinus] operator[SEP] Keyword[final] Keyword[double] operator[SEP] operator[SEP] identifier[v1] , Keyword[final] Keyword[double] identifier[s1] , Keyword[final] Keyword[double] operator[SEP] operator[SEP] identifier[v2] operato... |
public Observable<Page<DatabaseInner>> listByServerAsync(final String resourceGroupName, final String serverName) {
return listByServerWithServiceResponseAsync(resourceGroupName, serverName)
.map(new Func1<ServiceResponse<Page<DatabaseInner>>, Page<DatabaseInner>>() {
@Override
... | class class_name[name] begin[{]
method[listByServerAsync, return_type[type[Observable]], modifier[public], parameter[resourceGroupName, serverName]] begin[{]
return[call[.listByServerWithServiceResponseAsync, parameter[member[.resourceGroupName], member[.serverName]]]]
end[}]
END[}] | Keyword[public] identifier[Observable] operator[<] identifier[Page] operator[<] identifier[DatabaseInner] operator[>] operator[>] identifier[listByServerAsync] operator[SEP] Keyword[final] identifier[String] identifier[resourceGroupName] , Keyword[final] identifier[String] identifier[serverName] operator[SEP] {
... |
public ArrayList<Activity> getAllOpenedActivities()
{
ArrayList<Activity> activities = new ArrayList<Activity>();
Iterator<WeakReference<Activity>> activityStackIterator = activityStack.iterator();
while(activityStackIterator.hasNext()){
Activity activity = activityStackIterator.next().get();
if(activity... | class class_name[name] begin[{]
method[getAllOpenedActivities, return_type[type[ArrayList]], modifier[public], parameter[]] begin[{]
local_variable[type[ArrayList], activities]
local_variable[type[Iterator], activityStackIterator]
while[call[activityStackIterator.hasNext, parame... | Keyword[public] identifier[ArrayList] operator[<] identifier[Activity] operator[>] identifier[getAllOpenedActivities] operator[SEP] operator[SEP] {
identifier[ArrayList] operator[<] identifier[Activity] operator[>] identifier[activities] operator[=] Keyword[new] identifier[ArrayList] operator[<] identifier[Activ... |
public static long parseUnsignedLong(CharSequence s, final int start, final int end) throws NumberFormatException {
long ret = 0;
for (int i = start; i < end; i++) {
final char c = s.charAt(i);
if (c < '0' || c > '9') {
throw new NumberFormatException("Not a valid... | class class_name[name] begin[{]
method[parseUnsignedLong, return_type[type[long]], modifier[public static], parameter[s, start, end]] begin[{]
local_variable[type[long], ret]
ForStatement(body=BlockStatement(label=None, statements=[LocalVariableDeclaration(annotations=[], declarators=[VariableD... | Keyword[public] Keyword[static] Keyword[long] identifier[parseUnsignedLong] operator[SEP] identifier[CharSequence] identifier[s] , Keyword[final] Keyword[int] identifier[start] , Keyword[final] Keyword[int] identifier[end] operator[SEP] Keyword[throws] identifier[NumberFormatException] {
Keyword[long] identifi... |
public JSONWriter arrayBegin() throws IOException {
beforeValue();
writer.write(JSON.LSQUARE);
stack.push(state);
state = new State(ARRAY);
return this;
} | class class_name[name] begin[{]
method[arrayBegin, return_type[type[JSONWriter]], modifier[public], parameter[]] begin[{]
call[.beforeValue, parameter[]]
call[writer.write, parameter[member[JSON.LSQUARE]]]
call[stack.push, parameter[member[.state]]]
... | Keyword[public] identifier[JSONWriter] identifier[arrayBegin] operator[SEP] operator[SEP] Keyword[throws] identifier[IOException] {
identifier[beforeValue] operator[SEP] operator[SEP] operator[SEP] identifier[writer] operator[SEP] identifier[write] operator[SEP] identifier[JSON] operator[SEP] identifier[LSQUARE]... |
public static Map<String, CellRangeAddress> indexMergedRegion(
final Sheet sheet1) {
int numRegions = sheet1.getNumMergedRegions();
Map<String, CellRangeAddress> cellRangeMap = new HashMap<>();
for (int i = 0; i < numRegions; i++) {
CellRangeAddress caddress = sheet1.getMergedRegion(i);
if (cad... | class class_name[name] begin[{]
method[indexMergedRegion, return_type[type[Map]], modifier[public static], parameter[sheet1]] begin[{]
local_variable[type[int], numRegions]
local_variable[type[Map], cellRangeMap]
ForStatement(body=BlockStatement(label=None, statements=[LocalVariableDecl... | Keyword[public] Keyword[static] identifier[Map] operator[<] identifier[String] , identifier[CellRangeAddress] operator[>] identifier[indexMergedRegion] operator[SEP] Keyword[final] identifier[Sheet] identifier[sheet1] operator[SEP] {
Keyword[int] identifier[numRegions] operator[=] identifier[sheet1] operator[SE... |
private TableView getDefaultTableView() {
// No user input.
String viewStr = System.getProperty("use.view");
if ( viewStr == null ) {
jmiGetter.setEnabled( false );
return new GetterTableView( currFile );
}
// Valid user input.
if ( viewStr.equalsI... | class class_name[name] begin[{]
method[getDefaultTableView, return_type[type[TableView]], modifier[private], parameter[]] begin[{]
local_variable[type[String], viewStr]
if[binary_operation[member[.viewStr], ==, literal[null]]] begin[{]
call[jmiGetter.setEnabled, ... | Keyword[private] identifier[TableView] identifier[getDefaultTableView] operator[SEP] operator[SEP] {
identifier[String] identifier[viewStr] operator[=] identifier[System] operator[SEP] identifier[getProperty] operator[SEP] literal[String] operator[SEP] operator[SEP] Keyword[if] operator[SEP] identifier[viewStr] ... |
public void initialize(UimaContext context)
throws ResourceInitializationException {
super.initialize(context);
this.context = context;
mLogger = context.getLogger();
if (mLogger.isLoggable(Level.INFO)) {
mLogger.log(Level.INFO, "Initializing the CoGrOO annotator.");
}
ComponentFactory factory = ... | class class_name[name] begin[{]
method[initialize, return_type[void], modifier[public], parameter[context]] begin[{]
SuperMethodInvocation(arguments=[MemberReference(member=context, postfix_operators=[], prefix_operators=[], qualifier=, selectors=[])], member=initialize, postfix_operators=[], p... | Keyword[public] Keyword[void] identifier[initialize] operator[SEP] identifier[UimaContext] identifier[context] operator[SEP] Keyword[throws] identifier[ResourceInitializationException] {
Keyword[super] operator[SEP] identifier[initialize] operator[SEP] identifier[context] operator[SEP] operator[SEP] Keyword[this... |
public List<TransportCandidate> getCandidatesList() {
List<TransportCandidate> result;
synchronized (candidates) {
result = new ArrayList<>(candidates);
}
return result;
} | class class_name[name] begin[{]
method[getCandidatesList, return_type[type[List]], modifier[public], parameter[]] begin[{]
local_variable[type[List], result]
SYNCHRONIZED[member[.candidates]] BEGIN[{]
assign[member[.result], ClassCreator(arguments=[MemberReferenc... | Keyword[public] identifier[List] operator[<] identifier[TransportCandidate] operator[>] identifier[getCandidatesList] operator[SEP] operator[SEP] {
identifier[List] operator[<] identifier[TransportCandidate] operator[>] identifier[result] operator[SEP] Keyword[synchronized] operator[SEP] identifier[candidates] o... |
public OkCoinMoreTradeResult batchTrade(String symbol, String type, String ordersData)
throws IOException {
OkCoinMoreTradeResult tradeResult =
okCoin.batchTrade(apikey, symbol, type, ordersData, signatureCreator());
return returnOrThrow(tradeResult);
} | class class_name[name] begin[{]
method[batchTrade, return_type[type[OkCoinMoreTradeResult]], modifier[public], parameter[symbol, type, ordersData]] begin[{]
local_variable[type[OkCoinMoreTradeResult], tradeResult]
return[call[.returnOrThrow, parameter[member[.tradeResult]]]]
end[}]
END[}] | Keyword[public] identifier[OkCoinMoreTradeResult] identifier[batchTrade] operator[SEP] identifier[String] identifier[symbol] , identifier[String] identifier[type] , identifier[String] identifier[ordersData] operator[SEP] Keyword[throws] identifier[IOException] {
identifier[OkCoinMoreTradeResult] identifier[tra... |
public static void setTextDirection(TextView textView, int textDirection) {
if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.JELLY_BEAN_MR1) {
UiCompatNotCrash.setTextDirection(textView, textDirection);
}
} | class class_name[name] begin[{]
method[setTextDirection, return_type[void], modifier[public static], parameter[textView, textDirection]] begin[{]
if[binary_operation[member[Build.VERSION.SDK_INT], >=, member[Build.VERSION_CODES.JELLY_BEAN_MR1]]] begin[{]
call[UiCompatNot... | Keyword[public] Keyword[static] Keyword[void] identifier[setTextDirection] operator[SEP] identifier[TextView] identifier[textView] , Keyword[int] identifier[textDirection] operator[SEP] {
Keyword[if] operator[SEP] identifier[Build] operator[SEP] identifier[VERSION] operator[SEP] identifier[SDK_INT] operator[>=]... |
protected CompletableFuture<JsonObjectBuilder> makeBuilder(int instanceId) {
CompletableFuture<T> futureValue = getValue();
if (futureValue == null) {
logger.error("Could not retrieve value " + this.getClass().getName());
return null;
}
return futureValue
.exceptionally(
... | class class_name[name] begin[{]
method[makeBuilder, return_type[type[CompletableFuture]], modifier[protected], parameter[instanceId]] begin[{]
local_variable[type[CompletableFuture], futureValue]
if[binary_operation[member[.futureValue], ==, literal[null]]] begin[{]
... | Keyword[protected] identifier[CompletableFuture] operator[<] identifier[JsonObjectBuilder] operator[>] identifier[makeBuilder] operator[SEP] Keyword[int] identifier[instanceId] operator[SEP] {
identifier[CompletableFuture] operator[<] identifier[T] operator[>] identifier[futureValue] operator[=] identifier[getVa... |
@Override
public void complete(final LineReader reader, final ParsedLine line, final List<Candidate> candidates) {
String buffer = line.line().substring(0, line.cursor());
String[] parts = getLineParts(buffer);
int pos = buffer.length();
int len = parts.length;
// コード補完する引数の番号を特定。
int startArgNo = getStar... | class class_name[name] begin[{]
method[complete, return_type[void], modifier[public], parameter[reader, line, candidates]] begin[{]
local_variable[type[String], buffer]
local_variable[type[String], parts]
local_variable[type[int], pos]
local_variable[type[int], len]
loca... | annotation[@] identifier[Override] Keyword[public] Keyword[void] identifier[complete] operator[SEP] Keyword[final] identifier[LineReader] identifier[reader] , Keyword[final] identifier[ParsedLine] identifier[line] , Keyword[final] identifier[List] operator[<] identifier[Candidate] operator[>] identifier[candidates] o... |
public void progressUpdate(String layerId, String status, String progressMessage) {
if (!batchMode && log.isInfoEnabled() && StringUtils.isNotEmpty(layerId)) {
if (useAnsi) {
updateAnsiProgress(layerId, status, progressMessage);
} else {
updateNonAnsiProgr... | class class_name[name] begin[{]
method[progressUpdate, return_type[void], modifier[public], parameter[layerId, status, progressMessage]] begin[{]
if[binary_operation[binary_operation[member[.batchMode], &&, call[log.isInfoEnabled, parameter[]]], &&, call[StringUtils.isNotEmpty, parameter[member... | Keyword[public] Keyword[void] identifier[progressUpdate] operator[SEP] identifier[String] identifier[layerId] , identifier[String] identifier[status] , identifier[String] identifier[progressMessage] operator[SEP] {
Keyword[if] operator[SEP] operator[!] identifier[batchMode] operator[&&] identifier[log] operato... |
@Override
public void cacheResult(
CommerceDiscountUsageEntry commerceDiscountUsageEntry) {
entityCache.putResult(CommerceDiscountUsageEntryModelImpl.ENTITY_CACHE_ENABLED,
CommerceDiscountUsageEntryImpl.class,
commerceDiscountUsageEntry.getPrimaryKey(),
commerceDiscountUsageEntry);
commerceDiscountUsag... | class class_name[name] begin[{]
method[cacheResult, return_type[void], modifier[public], parameter[commerceDiscountUsageEntry]] begin[{]
call[entityCache.putResult, parameter[member[CommerceDiscountUsageEntryModelImpl.ENTITY_CACHE_ENABLED], ClassReference(postfix_operators=[], prefix_operators=... | annotation[@] identifier[Override] Keyword[public] Keyword[void] identifier[cacheResult] operator[SEP] identifier[CommerceDiscountUsageEntry] identifier[commerceDiscountUsageEntry] operator[SEP] {
identifier[entityCache] operator[SEP] identifier[putResult] operator[SEP] identifier[CommerceDiscountUsageEntryModel... |
public static RangeInclusiveL checkRangeIncludedInLong(
final RangeInclusiveL inner,
final String inner_name,
final RangeInclusiveL outer,
final String outer_name)
{
Objects.requireNonNull(inner, "Inner range");
Objects.requireNonNull(inner_name, "Inner range name");
Objects.requireNonNull... | class class_name[name] begin[{]
method[checkRangeIncludedInLong, return_type[type[RangeInclusiveL]], modifier[public static], parameter[inner, inner_name, outer, outer_name]] begin[{]
call[Objects.requireNonNull, parameter[member[.inner], literal["Inner range"]]]
call[Objects.re... | Keyword[public] Keyword[static] identifier[RangeInclusiveL] identifier[checkRangeIncludedInLong] operator[SEP] Keyword[final] identifier[RangeInclusiveL] identifier[inner] , Keyword[final] identifier[String] identifier[inner_name] , Keyword[final] identifier[RangeInclusiveL] identifier[outer] , Keyword[final] identi... |
@Override
protected void doClean()
{
if (cache.getStatus() == ComponentStatus.RUNNING)
{
for (LockData lockData : getLockList())
{
doRemove(lockData);
}
}
} | class class_name[name] begin[{]
method[doClean, return_type[void], modifier[protected], parameter[]] begin[{]
if[binary_operation[call[cache.getStatus, parameter[]], ==, member[ComponentStatus.RUNNING]]] begin[{]
ForStatement(body=BlockStatement(label=None, statements=[StatementExpr... | annotation[@] identifier[Override] Keyword[protected] Keyword[void] identifier[doClean] operator[SEP] operator[SEP] {
Keyword[if] operator[SEP] identifier[cache] operator[SEP] identifier[getStatus] operator[SEP] operator[SEP] operator[==] identifier[ComponentStatus] operator[SEP] identifier[RUNNING] operator[SEP... |
@SuppressWarnings({"unchecked"})
public static <T extends MessageBundle> T create(final Class<T> type) {
checkNotNull(type);
return (T) Proxy.newProxyInstance(type.getClassLoader(), new Class[]{type}, new Handler(type));
} | class class_name[name] begin[{]
method[create, return_type[type[T]], modifier[public static], parameter[type]] begin[{]
call[.checkNotNull, parameter[member[.type]]]
return[Cast(expression=MethodInvocation(arguments=[MethodInvocation(arguments=[], member=getClassLoader, postfix_operator... | annotation[@] identifier[SuppressWarnings] operator[SEP] {
literal[String]
} operator[SEP] Keyword[public] Keyword[static] operator[<] identifier[T] Keyword[extends] identifier[MessageBundle] operator[>] identifier[T] identifier[create] operator[SEP] Keyword[final] identifier[Class] operator[<] identifier[T] ... |
public synchronized void log(String tag,
Object o,
Frame frame,
long time)
{
StringBuffer buf = new StringBuffer(160);
// Log the time stamp
if (_logTimeStamps)
{
... | class class_name[name] begin[{]
method[log, return_type[void], modifier[synchronized public], parameter[tag, o, frame, time]] begin[{]
local_variable[type[StringBuffer], buf]
if[member[._logTimeStamps]] begin[{]
call[buf.append, parameter[call[_dateFormat.format,... | Keyword[public] Keyword[synchronized] Keyword[void] identifier[log] operator[SEP] identifier[String] identifier[tag] , identifier[Object] identifier[o] , identifier[Frame] identifier[frame] , Keyword[long] identifier[time] operator[SEP] {
identifier[StringBuffer] identifier[buf] operator[=] Keyword[new] ident... |
@Override
public void registerInterceptors(EjbDescriptor<?> ejbDescriptor, InterceptorBindings interceptorBindings) {
if (interceptorBindings != null) {
final Collection<Interceptor<?>> interceptors = interceptorBindings.getAllInterceptors();
if (interceptors != null) {
... | class class_name[name] begin[{]
method[registerInterceptors, return_type[void], modifier[public], parameter[ejbDescriptor, interceptorBindings]] begin[{]
if[binary_operation[member[.interceptorBindings], !=, literal[null]]] begin[{]
local_variable[type[Collection], interceptors]
... | annotation[@] identifier[Override] Keyword[public] Keyword[void] identifier[registerInterceptors] operator[SEP] identifier[EjbDescriptor] operator[<] operator[?] operator[>] identifier[ejbDescriptor] , identifier[InterceptorBindings] identifier[interceptorBindings] operator[SEP] {
Keyword[if] operator[SEP] iden... |
public static base_responses unset(nitro_service client, vpnclientlessaccessprofile resources[], String[] args) throws Exception {
base_responses result = null;
if (resources != null && resources.length > 0) {
vpnclientlessaccessprofile unsetresources[] = new vpnclientlessaccessprofile[resources.length];
for... | class class_name[name] begin[{]
method[unset, return_type[type[base_responses]], modifier[public static], parameter[client, resources, args]] begin[{]
local_variable[type[base_responses], result]
if[binary_operation[binary_operation[member[.resources], !=, literal[null]], &&, binary_ope... | Keyword[public] Keyword[static] identifier[base_responses] identifier[unset] operator[SEP] identifier[nitro_service] identifier[client] , identifier[vpnclientlessaccessprofile] identifier[resources] operator[SEP] operator[SEP] , identifier[String] operator[SEP] operator[SEP] identifier[args] operator[SEP] Keyword[thr... |
public double calculateSigmaElectronegativity(IAtomContainer ac, IAtom atom, int maxIterations, int maxResonStruc) {
maxI = maxIterations;
maxRS = maxResonStruc;
double electronegativity = 0;
try {
if (!ac.equals(acOldS)) {
molSigma = ac.getBuilder().newInst... | class class_name[name] begin[{]
method[calculateSigmaElectronegativity, return_type[type[double]], modifier[public], parameter[ac, atom, maxIterations, maxResonStruc]] begin[{]
assign[member[.maxI], member[.maxIterations]]
assign[member[.maxRS], member[.maxResonStruc]]
l... | Keyword[public] Keyword[double] identifier[calculateSigmaElectronegativity] operator[SEP] identifier[IAtomContainer] identifier[ac] , identifier[IAtom] identifier[atom] , Keyword[int] identifier[maxIterations] , Keyword[int] identifier[maxResonStruc] operator[SEP] {
identifier[maxI] operator[=] identifier[max... |
private CouchbaseResponse handleGetDesignDocumentResponse(final GetDesignDocumentRequest request) {
ResponseStatus status = ResponseStatusConverter.fromHttp(responseHeader.getStatus().code());
return new GetDesignDocumentResponse(request.name(), request.development(), responseContent.copy(), status,
... | class class_name[name] begin[{]
method[handleGetDesignDocumentResponse, return_type[type[CouchbaseResponse]], modifier[private], parameter[request]] begin[{]
local_variable[type[ResponseStatus], status]
return[ClassCreator(arguments=[MethodInvocation(arguments=[], member=name, postfix_operators... | Keyword[private] identifier[CouchbaseResponse] identifier[handleGetDesignDocumentResponse] operator[SEP] Keyword[final] identifier[GetDesignDocumentRequest] identifier[request] operator[SEP] {
identifier[ResponseStatus] identifier[status] operator[=] identifier[ResponseStatusConverter] operator[SEP] identifier[f... |
public static File getWebRoot() {
final String classPath = ClassUtil.getClassPath();
if (StrUtil.isNotBlank(classPath)) {
return getParent(file(classPath), 2);
}
return null;
} | class class_name[name] begin[{]
method[getWebRoot, return_type[type[File]], modifier[public static], parameter[]] begin[{]
local_variable[type[String], classPath]
if[call[StrUtil.isNotBlank, parameter[member[.classPath]]]] begin[{]
return[call[.getParent, parameter[call[.fil... | Keyword[public] Keyword[static] identifier[File] identifier[getWebRoot] operator[SEP] operator[SEP] {
Keyword[final] identifier[String] identifier[classPath] operator[=] identifier[ClassUtil] operator[SEP] identifier[getClassPath] operator[SEP] operator[SEP] operator[SEP] Keyword[if] operator[SEP] identifier[Str... |
public static void createNewFile(@NonNull final File file, final boolean overwrite)
throws IOException {
Condition.INSTANCE.ensureNotNull(file, "The file may not be null");
boolean result = file.createNewFile();
if (!result) {
if (overwrite) {
try {
... | class class_name[name] begin[{]
method[createNewFile, return_type[void], modifier[public static], parameter[file, overwrite]] begin[{]
call[Condition.INSTANCE.ensureNotNull, parameter[member[.file], literal["The file may not be null"]]]
local_variable[type[boolean], result]
... | Keyword[public] Keyword[static] Keyword[void] identifier[createNewFile] operator[SEP] annotation[@] identifier[NonNull] Keyword[final] identifier[File] identifier[file] , Keyword[final] Keyword[boolean] identifier[overwrite] operator[SEP] Keyword[throws] identifier[IOException] {
identifier[Condition] operator[... |
final int getGregorianYearFromFixedDate(long fixedDate) {
long d0;
int d1, d2, d3, d4;
int n400, n100, n4, n1;
int year;
if (fixedDate > 0) {
d0 = fixedDate - 1;
n400 = (int)(d0 / 146097);
d1 = (int)(d0 % 146097);
n100 = d1 / 36... | class class_name[name] begin[{]
method[getGregorianYearFromFixedDate, return_type[type[int]], modifier[final], parameter[fixedDate]] begin[{]
local_variable[type[long], d0]
local_variable[type[int], d1]
local_variable[type[int], n400]
local_variable[type[int], year]
... | Keyword[final] Keyword[int] identifier[getGregorianYearFromFixedDate] operator[SEP] Keyword[long] identifier[fixedDate] operator[SEP] {
Keyword[long] identifier[d0] operator[SEP] Keyword[int] identifier[d1] , identifier[d2] , identifier[d3] , identifier[d4] operator[SEP] Keyword[int] identifier[n400] , ident... |
public OvhTask organizationName_service_exchangeService_protocol_activeSyncMailNotification_POST(String organizationName, String exchangeService, Long notifiedAccountId) throws IOException {
String qPath = "/email/exchange/{organizationName}/service/{exchangeService}/protocol/activeSyncMailNotification";
StringBuil... | class class_name[name] begin[{]
method[organizationName_service_exchangeService_protocol_activeSyncMailNotification_POST, return_type[type[OvhTask]], modifier[public], parameter[organizationName, exchangeService, notifiedAccountId]] begin[{]
local_variable[type[String], qPath]
local_variable[ty... | Keyword[public] identifier[OvhTask] identifier[organizationName_service_exchangeService_protocol_activeSyncMailNotification_POST] operator[SEP] identifier[String] identifier[organizationName] , identifier[String] identifier[exchangeService] , identifier[Long] identifier[notifiedAccountId] operator[SEP] Keyword[throws... |
public void postInitialize() throws ContradictionException {
final int[] biggest = new int[prop.nbDims];
for (int i = 0; i < prop.bins.length; i++) {
for (int d = 0; d < prop.nbDims; d++) {
biggest[d] = Math.max(biggest[d], prop.iSizes[d][i]);
}
if (!p... | class class_name[name] begin[{]
method[postInitialize, return_type[void], modifier[public], parameter[]] begin[{]
local_variable[type[int], biggest]
ForStatement(body=BlockStatement(label=None, statements=[ForStatement(body=BlockStatement(label=None, statements=[StatementExpression(expression=A... | Keyword[public] Keyword[void] identifier[postInitialize] operator[SEP] operator[SEP] Keyword[throws] identifier[ContradictionException] {
Keyword[final] Keyword[int] operator[SEP] operator[SEP] identifier[biggest] operator[=] Keyword[new] Keyword[int] operator[SEP] identifier[prop] operator[SEP] identifier[nbDim... |
@GuardedBy("mLock")
private void validateWriteRequest(alluxio.grpc.WriteRequest request)
throws InvalidArgumentException {
if (request.hasCommand() && request.getCommand().hasOffset()
&& request.getCommand().getOffset() != mContext.getPos()) {
throw new InvalidArgumentException(String.format(
... | class class_name[name] begin[{]
method[validateWriteRequest, return_type[void], modifier[private], parameter[request]] begin[{]
if[binary_operation[binary_operation[call[request.hasCommand, parameter[]], &&, call[request.getCommand, parameter[]]], &&, binary_operation[call[request.getCommand, p... | annotation[@] identifier[GuardedBy] operator[SEP] literal[String] operator[SEP] Keyword[private] Keyword[void] identifier[validateWriteRequest] operator[SEP] identifier[alluxio] operator[SEP] identifier[grpc] operator[SEP] identifier[WriteRequest] identifier[request] operator[SEP] Keyword[throws] identifier[InvalidArgu... |
@UiThread
public void expandParent(@NonNull P parent) {
ExpandableWrapper<P, C> parentWrapper = new ExpandableWrapper<>(parent);
int flatParentPosition = mFlatItemList.indexOf(parentWrapper);
if (flatParentPosition == INVALID_FLAT_POSITION) {
return;
}
expandView... | class class_name[name] begin[{]
method[expandParent, return_type[void], modifier[public], parameter[parent]] begin[{]
local_variable[type[ExpandableWrapper], parentWrapper]
local_variable[type[int], flatParentPosition]
if[binary_operation[member[.flatParentPosition], ==, member[... | annotation[@] identifier[UiThread] Keyword[public] Keyword[void] identifier[expandParent] operator[SEP] annotation[@] identifier[NonNull] identifier[P] identifier[parent] operator[SEP] {
identifier[ExpandableWrapper] operator[<] identifier[P] , identifier[C] operator[>] identifier[parentWrapper] operator[=] Key... |
public void willInvoke(Method method, List<JsonNode> arguments) {
for (InvocationListener invocationListener : invocationListeners) {
invocationListener.willInvoke(method, arguments);
}
} | class class_name[name] begin[{]
method[willInvoke, return_type[void], modifier[public], parameter[method, arguments]] begin[{]
ForStatement(body=BlockStatement(label=None, statements=[StatementExpression(expression=MethodInvocation(arguments=[MemberReference(member=method, postfix_operators=[], prefix_... | Keyword[public] Keyword[void] identifier[willInvoke] operator[SEP] identifier[Method] identifier[method] , identifier[List] operator[<] identifier[JsonNode] operator[>] identifier[arguments] operator[SEP] {
Keyword[for] operator[SEP] identifier[InvocationListener] identifier[invocationListener] operator[:] ide... |
public static Percentile createCoerced(double percentile) {
// Percentile range is entirely positive, so no need for abs().
double clamped = Math.max(MIN_PERCENTILE, Math.min(MAX_PERCENTILE, percentile));
// Since the range is 0-100, and only 2 decimal places this technique is fine.
dou... | class class_name[name] begin[{]
method[createCoerced, return_type[type[Percentile]], modifier[public static], parameter[percentile]] begin[{]
local_variable[type[double], clamped]
local_variable[type[double], rounded]
return[ClassCreator(arguments=[MemberReference(member=rounded, postfi... | Keyword[public] Keyword[static] identifier[Percentile] identifier[createCoerced] operator[SEP] Keyword[double] identifier[percentile] operator[SEP] {
Keyword[double] identifier[clamped] operator[=] identifier[Math] operator[SEP] identifier[max] operator[SEP] identifier[MIN_PERCENTILE] , identifier[Math] operato... |
@Override
public CPDefinition findByGroupId_First(long groupId,
OrderByComparator<CPDefinition> orderByComparator)
throws NoSuchCPDefinitionException {
CPDefinition cpDefinition = fetchByGroupId_First(groupId,
orderByComparator);
if (cpDefinition != null) {
return cpDefinition;
}
StringBundler msg... | class class_name[name] begin[{]
method[findByGroupId_First, return_type[type[CPDefinition]], modifier[public], parameter[groupId, orderByComparator]] begin[{]
local_variable[type[CPDefinition], cpDefinition]
if[binary_operation[member[.cpDefinition], !=, literal[null]]] begin[{]
... | annotation[@] identifier[Override] Keyword[public] identifier[CPDefinition] identifier[findByGroupId_First] operator[SEP] Keyword[long] identifier[groupId] , identifier[OrderByComparator] operator[<] identifier[CPDefinition] operator[>] identifier[orderByComparator] operator[SEP] Keyword[throws] identifier[NoSuchCPDef... |
public void addN(final int[] dat, final int offset, final int n) {
Container currentcont = null;
short currenthb = 0;
int currentcontainerindex = 0;
int j = 0;
if(j < n) {
int val = dat[j + offset];
currenthb = Util.highbits(val);
currentcontainerindex = highLowContainer.getIndex(c... | class class_name[name] begin[{]
method[addN, return_type[void], modifier[public], parameter[dat, offset, n]] begin[{]
local_variable[type[Container], currentcont]
local_variable[type[short], currenthb]
local_variable[type[int], currentcontainerindex]
local_variable[type[int], j]... | Keyword[public] Keyword[void] identifier[addN] operator[SEP] Keyword[final] Keyword[int] operator[SEP] operator[SEP] identifier[dat] , Keyword[final] Keyword[int] identifier[offset] , Keyword[final] Keyword[int] identifier[n] operator[SEP] {
identifier[Container] identifier[currentcont] operator[=] Other[null]... |
private void findPathOnParentSubclasses(Path<?> parent, Class<?> targetType, List<Path<?>> candidatePaths) {
for (Class child : ReflectionUtils.getSubclasses(parent.getType(), entityManager)) {
try {
Class clazz = Class.forName(child.getPackage().getName() + ".Q" + child.getSimpleNam... | class class_name[name] begin[{]
method[findPathOnParentSubclasses, return_type[void], modifier[private], parameter[parent, targetType, candidatePaths]] begin[{]
ForStatement(body=BlockStatement(label=None, statements=[TryStatement(block=[LocalVariableDeclaration(annotations=[], declarators=[VariableDec... | Keyword[private] Keyword[void] identifier[findPathOnParentSubclasses] operator[SEP] identifier[Path] operator[<] operator[?] operator[>] identifier[parent] , identifier[Class] operator[<] operator[?] operator[>] identifier[targetType] , identifier[List] operator[<] identifier[Path] operator[<] operator[?] operator[>]... |
private void monitor() {
_lastMonitoringStep = _clock.nanoTime();
_nextAllowedLogging = _lastMonitoringStep;
while(!_stopped) {
try {
_clock.sleepNano(_checkIntervalNano);
} catch (InterruptedException e) {
break;
}
monitorStep();
}
} | class class_name[name] begin[{]
method[monitor, return_type[void], modifier[private], parameter[]] begin[{]
assign[member[._lastMonitoringStep], call[_clock.nanoTime, parameter[]]]
assign[member[._nextAllowedLogging], member[._lastMonitoringStep]]
while[member[._... | Keyword[private] Keyword[void] identifier[monitor] operator[SEP] operator[SEP] {
identifier[_lastMonitoringStep] operator[=] identifier[_clock] operator[SEP] identifier[nanoTime] operator[SEP] operator[SEP] operator[SEP] identifier[_nextAllowedLogging] operator[=] identifier[_lastMonitoringStep] operator[SEP] Ke... |
@Override
public DeleteLayerResult deleteLayer(DeleteLayerRequest request) {
request = beforeClientExecution(request);
return executeDeleteLayer(request);
} | class class_name[name] begin[{]
method[deleteLayer, return_type[type[DeleteLayerResult]], modifier[public], parameter[request]] begin[{]
assign[member[.request], call[.beforeClientExecution, parameter[member[.request]]]]
return[call[.executeDeleteLayer, parameter[member[.request]]]]
... | annotation[@] identifier[Override] Keyword[public] identifier[DeleteLayerResult] identifier[deleteLayer] operator[SEP] identifier[DeleteLayerRequest] identifier[request] operator[SEP] {
identifier[request] operator[=] identifier[beforeClientExecution] operator[SEP] identifier[request] operator[SEP] operator[SEP]... |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.