code stringlengths 63 466k | code_sememe stringlengths 141 3.79M | token_type stringlengths 274 1.23M |
|---|---|---|
@Override
public MongodbPubSubHub<ID, DATA> init() {
if (getMongoClient() == null) {
setMongoClient(buildMongoClient(), true);
}
super.init();
if (getMongoClient() == null) {
throw new IllegalStateException("MongoDB Client is null.");
}
retu... | class class_name[name] begin[{]
method[init, return_type[type[MongodbPubSubHub]], modifier[public], parameter[]] begin[{]
if[binary_operation[call[.getMongoClient, parameter[]], ==, literal[null]]] begin[{]
call[.setMongoClient, parameter[call[.buildMongoClient, paramete... | annotation[@] identifier[Override] Keyword[public] identifier[MongodbPubSubHub] operator[<] identifier[ID] , identifier[DATA] operator[>] identifier[init] operator[SEP] operator[SEP] {
Keyword[if] operator[SEP] identifier[getMongoClient] operator[SEP] operator[SEP] operator[==] Other[null] operator[SEP] {
... |
public boolean isTrivial(Integer complexity) {
int len = payload.length;
if ((null == complexity) || (len < 2)) {
return true;
}
else if ((complexity.intValue() > 0) && (len > 2)) {
Set<Character> seen = new TreeSet<Character>();
for (int i = 0; i < len; i++) {
Character c = Ch... | class class_name[name] begin[{]
method[isTrivial, return_type[type[boolean]], modifier[public], parameter[complexity]] begin[{]
local_variable[type[int], len]
if[binary_operation[binary_operation[literal[null], ==, member[.complexity]], ||, binary_operation[member[.len], <, literal[2]]]... | Keyword[public] Keyword[boolean] identifier[isTrivial] operator[SEP] identifier[Integer] identifier[complexity] operator[SEP] {
Keyword[int] identifier[len] operator[=] identifier[payload] operator[SEP] identifier[length] operator[SEP] Keyword[if] operator[SEP] operator[SEP] Other[null] operator[==] identifier[c... |
public com.google.api.Control getControl() {
return control_ == null ? com.google.api.Control.getDefaultInstance() : control_;
} | class class_name[name] begin[{]
method[getControl, return_type[type[com]], modifier[public], parameter[]] begin[{]
return[TernaryExpression(condition=BinaryOperation(operandl=MemberReference(member=control_, postfix_operators=[], prefix_operators=[], qualifier=, selectors=[]), operandr=Literal(postfix_... | Keyword[public] identifier[com] operator[SEP] identifier[google] operator[SEP] identifier[api] operator[SEP] identifier[Control] identifier[getControl] operator[SEP] operator[SEP] {
Keyword[return] identifier[control_] operator[==] Other[null] operator[?] identifier[com] operator[SEP] identifier[google] operator... |
public int readBits(final JBBPBitNumber numOfBitsToRead) throws IOException {
int result;
final int numOfBitsAsNumber = numOfBitsToRead.getBitNumber();
if (this.bitsInBuffer == 0 && numOfBitsAsNumber == 8) {
result = this.readByteFromStream();
if (result >= 0) {
this.byteCounter++;
... | class class_name[name] begin[{]
method[readBits, return_type[type[int]], modifier[public], parameter[numOfBitsToRead]] begin[{]
local_variable[type[int], result]
local_variable[type[int], numOfBitsAsNumber]
if[binary_operation[binary_operation[THIS[member[None.bitsInBuffer]], ==... | Keyword[public] Keyword[int] identifier[readBits] operator[SEP] Keyword[final] identifier[JBBPBitNumber] identifier[numOfBitsToRead] operator[SEP] Keyword[throws] identifier[IOException] {
Keyword[int] identifier[result] operator[SEP] Keyword[final] Keyword[int] identifier[numOfBitsAsNumber] operator[=] identifi... |
@Override
public FSDataOutputStream create(Path f, WriteMode overwriteMode) throws IOException {
return createOutputStream(() -> originalFs.create(f, overwriteMode));
} | class class_name[name] begin[{]
method[create, return_type[type[FSDataOutputStream]], modifier[public], parameter[f, overwriteMode]] begin[{]
return[call[.createOutputStream, parameter[LambdaExpression(body=MethodInvocation(arguments=[MemberReference(member=f, postfix_operators=[], prefix_operators=[],... | annotation[@] identifier[Override] Keyword[public] identifier[FSDataOutputStream] identifier[create] operator[SEP] identifier[Path] identifier[f] , identifier[WriteMode] identifier[overwriteMode] operator[SEP] Keyword[throws] identifier[IOException] {
Keyword[return] identifier[createOutputStream] operator[SEP]... |
@Override
public void terminationComplete(RecoveryAgent recoveryAgent, FailureScope failureScope) throws InvalidFailureScopeException {
if (tc.isEntryEnabled())
Tr.entry(tc, "terminationComplete", new Object[] { recoveryAgent, failureScope, this });
final boolean removed = removeTermina... | class class_name[name] begin[{]
method[terminationComplete, return_type[void], modifier[public], parameter[recoveryAgent, failureScope]] begin[{]
if[call[tc.isEntryEnabled, parameter[]]] begin[{]
call[Tr.entry, parameter[member[.tc], literal["terminationComplete"], ArrayCreator(dime... | annotation[@] identifier[Override] Keyword[public] Keyword[void] identifier[terminationComplete] operator[SEP] identifier[RecoveryAgent] identifier[recoveryAgent] , identifier[FailureScope] identifier[failureScope] operator[SEP] Keyword[throws] identifier[InvalidFailureScopeException] {
Keyword[if] operator[SEP... |
private <I extends Message, O extends Message> void invoke(
ServerMethod<I, O> method, ByteString payload, long requestId, Channel channel) {
FutureCallback<O> callback = new ServerMethodCallback<>(method, requestId, channel);
try {
I request = method.inputParser().parseFrom(payload);
Listenab... | class class_name[name] begin[{]
method[invoke, return_type[void], modifier[private], parameter[method, payload, requestId, channel]] begin[{]
local_variable[type[FutureCallback], callback]
TryStatement(block=[LocalVariableDeclaration(annotations=[], declarators=[VariableDeclarator(dimensions=[]... | Keyword[private] operator[<] identifier[I] Keyword[extends] identifier[Message] , identifier[O] Keyword[extends] identifier[Message] operator[>] Keyword[void] identifier[invoke] operator[SEP] identifier[ServerMethod] operator[<] identifier[I] , identifier[O] operator[>] identifier[method] , identifier[ByteString] id... |
public void setInputUpdates(java.util.Collection<InputUpdate> inputUpdates) {
if (inputUpdates == null) {
this.inputUpdates = null;
return;
}
this.inputUpdates = new java.util.ArrayList<InputUpdate>(inputUpdates);
} | class class_name[name] begin[{]
method[setInputUpdates, return_type[void], modifier[public], parameter[inputUpdates]] begin[{]
if[binary_operation[member[.inputUpdates], ==, literal[null]]] begin[{]
assign[THIS[member[None.inputUpdates]], literal[null]]
retur... | Keyword[public] Keyword[void] identifier[setInputUpdates] operator[SEP] identifier[java] operator[SEP] identifier[util] operator[SEP] identifier[Collection] operator[<] identifier[InputUpdate] operator[>] identifier[inputUpdates] operator[SEP] {
Keyword[if] operator[SEP] identifier[inputUpdates] operator[==] Oth... |
public static Long getSeqMinValue(Properties prop)
{
String result = prop.getProperty(PROP_SEQ_MIN_VALUE, null);
if(result != null)
{
return new Long(Long.parseLong(result));
}
else
{
return null;
}
} | class class_name[name] begin[{]
method[getSeqMinValue, return_type[type[Long]], modifier[public static], parameter[prop]] begin[{]
local_variable[type[String], result]
if[binary_operation[member[.result], !=, literal[null]]] begin[{]
return[ClassCreator(arguments=[MethodInvo... | Keyword[public] Keyword[static] identifier[Long] identifier[getSeqMinValue] operator[SEP] identifier[Properties] identifier[prop] operator[SEP] {
identifier[String] identifier[result] operator[=] identifier[prop] operator[SEP] identifier[getProperty] operator[SEP] identifier[PROP_SEQ_MIN_VALUE] , Other[null] op... |
@Override
public void eUnset(int featureID) {
switch (featureID) {
case AfplibPackage.EII__IMO_NAME:
setImoName(IMO_NAME_EDEFAULT);
return;
}
super.eUnset(featureID);
} | class class_name[name] begin[{]
method[eUnset, return_type[void], modifier[public], parameter[featureID]] begin[{]
SwitchStatement(cases=[SwitchStatementCase(case=[MemberReference(member=EII__IMO_NAME, postfix_operators=[], prefix_operators=[], qualifier=AfplibPackage, selectors=[])], statements=[State... | annotation[@] identifier[Override] Keyword[public] Keyword[void] identifier[eUnset] operator[SEP] Keyword[int] identifier[featureID] operator[SEP] {
Keyword[switch] operator[SEP] identifier[featureID] operator[SEP] {
Keyword[case] identifier[AfplibPackage] operator[SEP] identifier[EII__IMO_NAME] opera... |
@Override
public Map<String, String> getTelemetryProperties() {
final Map<String, String> map = super.getTelemetryProperties();
final WebAppConfiguration webAppConfiguration;
try {
webAppConfiguration = getWebAppConfiguration();
} catch (Exception e) {
... | class class_name[name] begin[{]
method[getTelemetryProperties, return_type[type[Map]], modifier[public], parameter[]] begin[{]
local_variable[type[Map], map]
local_variable[type[WebAppConfiguration], webAppConfiguration]
TryStatement(block=[StatementExpression(expression=Assignment(expr... | annotation[@] identifier[Override] Keyword[public] identifier[Map] operator[<] identifier[String] , identifier[String] operator[>] identifier[getTelemetryProperties] operator[SEP] operator[SEP] {
Keyword[final] identifier[Map] operator[<] identifier[String] , identifier[String] operator[>] identifier[map] oper... |
private boolean doSetScale(double scale) {
boolean res = Math.abs(viewState.getScale() - scale) > .0000001;
viewState = viewState.copyAndSetScale(scale);
return res;
} | class class_name[name] begin[{]
method[doSetScale, return_type[type[boolean]], modifier[private], parameter[scale]] begin[{]
local_variable[type[boolean], res]
assign[member[.viewState], call[viewState.copyAndSetScale, parameter[member[.scale]]]]
return[member[.res]]
end[}]
... | Keyword[private] Keyword[boolean] identifier[doSetScale] operator[SEP] Keyword[double] identifier[scale] operator[SEP] {
Keyword[boolean] identifier[res] operator[=] identifier[Math] operator[SEP] identifier[abs] operator[SEP] identifier[viewState] operator[SEP] identifier[getScale] operator[SEP] operator[SEP] o... |
public static void generateJavadocGeneratedBy(Builder builder) {
if (!BindDataSourceSubProcessor.JUNIT_TEST_MODE) {
builder.addJavadoc("<p><strong>This class is generated by Kripton Annotation Processor - v. $L</strong></p>\n", Version.getVersion());
builder.addJavadoc("<p><strong>Generation-time: $L</strong></... | class class_name[name] begin[{]
method[generateJavadocGeneratedBy, return_type[void], modifier[public static], parameter[builder]] begin[{]
if[member[BindDataSourceSubProcessor.JUNIT_TEST_MODE]] begin[{]
call[builder.addJavadoc, parameter[literal["<p><strong>This class i... | Keyword[public] Keyword[static] Keyword[void] identifier[generateJavadocGeneratedBy] operator[SEP] identifier[Builder] identifier[builder] operator[SEP] {
Keyword[if] operator[SEP] operator[!] identifier[BindDataSourceSubProcessor] operator[SEP] identifier[JUNIT_TEST_MODE] operator[SEP] {
identifier[b... |
public void revokeService(Class serviceClass, BeanContextServiceProvider serviceProvider, boolean revokeCurrentServicesNow)
{
if (serviceClass == null || serviceProvider == null)
{
throw new NullPointerException();
}
synchronized (globalHierarchyLock)
{
synchronized (services)
{
BCSSServiceProv... | class class_name[name] begin[{]
method[revokeService, return_type[void], modifier[public], parameter[serviceClass, serviceProvider, revokeCurrentServicesNow]] begin[{]
if[binary_operation[binary_operation[member[.serviceClass], ==, literal[null]], ||, binary_operation[member[.serviceProvider], ... | Keyword[public] Keyword[void] identifier[revokeService] operator[SEP] identifier[Class] identifier[serviceClass] , identifier[BeanContextServiceProvider] identifier[serviceProvider] , Keyword[boolean] identifier[revokeCurrentServicesNow] operator[SEP] {
Keyword[if] operator[SEP] identifier[serviceClass] operat... |
private List getResources(ZipFile file, String root)
{
List resourceNames = new ArrayList();
Enumeration e = file.entries();
while (e.hasMoreElements())
{
ZipEntry entry = (ZipEntry) e.nextElement();
String name = entry.getName();
if (name.startsWi... | class class_name[name] begin[{]
method[getResources, return_type[type[List]], modifier[private], parameter[file, root]] begin[{]
local_variable[type[List], resourceNames]
local_variable[type[Enumeration], e]
while[call[e.hasMoreElements, parameter[]]] begin[{]
local_... | Keyword[private] identifier[List] identifier[getResources] operator[SEP] identifier[ZipFile] identifier[file] , identifier[String] identifier[root] operator[SEP] {
identifier[List] identifier[resourceNames] operator[=] Keyword[new] identifier[ArrayList] operator[SEP] operator[SEP] operator[SEP] identifier[Enume... |
public final EObject entryRuleXOtherOperatorExpression() throws RecognitionException {
EObject current = null;
EObject iv_ruleXOtherOperatorExpression = null;
try {
// InternalSARL.g:12803:65: (iv_ruleXOtherOperatorExpression= ruleXOtherOperatorExpression EOF )
// Inte... | class class_name[name] begin[{]
method[entryRuleXOtherOperatorExpression, return_type[type[EObject]], modifier[final public], parameter[]] begin[{]
local_variable[type[EObject], current]
local_variable[type[EObject], iv_ruleXOtherOperatorExpression]
TryStatement(block=[BlockStatement(la... | Keyword[public] Keyword[final] identifier[EObject] identifier[entryRuleXOtherOperatorExpression] operator[SEP] operator[SEP] Keyword[throws] identifier[RecognitionException] {
identifier[EObject] identifier[current] operator[=] Other[null] operator[SEP] identifier[EObject] identifier[iv_ruleXOtherOperatorExpress... |
@Override
public Object readFrom(Class<Object> c, Type t, Annotation[] anns, MediaType mt,
MultivaluedMap<String, String> headers, InputStream is) throws IOException, WebApplicationException {
// TODO Auto-generated method stub
//if Type t contains IAttachment, IMutibody, ... | class class_name[name] begin[{]
method[readFrom, return_type[type[Object]], modifier[public], parameter[c, t, anns, mt, headers, is]] begin[{]
call[multipartProvider.setMessageContext, parameter[member[.mc]]]
local_variable[type[ParameterizedType], origType]
local_variable[type[... | annotation[@] identifier[Override] Keyword[public] identifier[Object] identifier[readFrom] operator[SEP] identifier[Class] operator[<] identifier[Object] operator[>] identifier[c] , identifier[Type] identifier[t] , identifier[Annotation] operator[SEP] operator[SEP] identifier[anns] , identifier[MediaType] identifier... |
Iterator<Path> dirIterator() {
if (dataset.getDescriptor().isPartitioned()) {
return Iterators.transform(partitionIterator(), new Function<StorageKey, Path>() {
@Override
@edu.umd.cs.findbugs.annotations.SuppressWarnings(
value="NP_PARAMETER_MUST_BE_NONNULL_BUT_MARKED_AS_NULLABLE",... | class class_name[name] begin[{]
method[dirIterator, return_type[type[Iterator]], modifier[default], parameter[]] begin[{]
if[call[dataset.getDescriptor, parameter[]]] begin[{]
return[call[Iterators.transform, parameter[call[.partitionIterator, parameter[]], ClassCreator(arguments=[]... | identifier[Iterator] operator[<] identifier[Path] operator[>] identifier[dirIterator] operator[SEP] operator[SEP] {
Keyword[if] operator[SEP] identifier[dataset] operator[SEP] identifier[getDescriptor] operator[SEP] operator[SEP] operator[SEP] identifier[isPartitioned] operator[SEP] operator[SEP] operator[SEP] ... |
public boolean isSet(_Fields field) {
if (field == null) {
throw new IllegalArgumentException();
}
switch (field) {
case KEYS:
return is_set_keys();
case SESSION:
return is_set_session();
}
throw new IllegalStateException();
} | class class_name[name] begin[{]
method[isSet, return_type[type[boolean]], modifier[public], parameter[field]] begin[{]
if[binary_operation[member[.field], ==, literal[null]]] begin[{]
ThrowStatement(expression=ClassCreator(arguments=[], body=None, constructor_type_arguments=None, po... | Keyword[public] Keyword[boolean] identifier[isSet] operator[SEP] identifier[_Fields] identifier[field] operator[SEP] {
Keyword[if] operator[SEP] identifier[field] operator[==] Other[null] operator[SEP] {
Keyword[throw] Keyword[new] identifier[IllegalArgumentException] operator[SEP] operator[SEP] opera... |
public EClass getIID() {
if (iidEClass == null) {
iidEClass = (EClass)EPackage.Registry.INSTANCE.getEPackage(AfplibPackage.eNS_URI).getEClassifiers().get(275);
}
return iidEClass;
} | class class_name[name] begin[{]
method[getIID, return_type[type[EClass]], modifier[public], parameter[]] begin[{]
if[binary_operation[member[.iidEClass], ==, literal[null]]] begin[{]
assign[member[.iidEClass], Cast(expression=MethodInvocation(arguments=[MemberReference(m... | Keyword[public] identifier[EClass] identifier[getIID] operator[SEP] operator[SEP] {
Keyword[if] operator[SEP] identifier[iidEClass] operator[==] Other[null] operator[SEP] {
identifier[iidEClass] operator[=] operator[SEP] identifier[EClass] operator[SEP] identifier[EPackage] operator[SEP] identifier[Re... |
public static final H2ONode intern( H2Okey key ) {
H2ONode h2o = INTERN.get(key);
if( h2o != null ) return h2o;
final int idx = UNIQUE.getAndIncrement();
h2o = new H2ONode(key,idx);
H2ONode old = INTERN.putIfAbsent(key,h2o);
if( old != null ) return old;
synchronized(H2O.class) {
while... | class class_name[name] begin[{]
method[intern, return_type[type[H2ONode]], modifier[final public static], parameter[key]] begin[{]
local_variable[type[H2ONode], h2o]
if[binary_operation[member[.h2o], !=, literal[null]]] begin[{]
return[member[.h2o]]
else begin[{]
None
en... | Keyword[public] Keyword[static] Keyword[final] identifier[H2ONode] identifier[intern] operator[SEP] identifier[H2Okey] identifier[key] operator[SEP] {
identifier[H2ONode] identifier[h2o] operator[=] identifier[INTERN] operator[SEP] identifier[get] operator[SEP] identifier[key] operator[SEP] operator[SEP] Keyword... |
private void loadPolicies(final IAsyncHandler<List<PolicyWithConfiguration>> handler) {
final Set<Integer> totalCounter = new HashSet<>();
final Set<Integer> errorCounter = new TreeSet<>();
final List<PolicyWithConfiguration> rval = new ArrayList<>(policies.size());
final List<Throwable>... | class class_name[name] begin[{]
method[loadPolicies, return_type[void], modifier[private], parameter[handler]] begin[{]
local_variable[type[Set], totalCounter]
local_variable[type[Set], errorCounter]
local_variable[type[List], rval]
local_variable[type[List], errors]
loc... | Keyword[private] Keyword[void] identifier[loadPolicies] operator[SEP] Keyword[final] identifier[IAsyncHandler] operator[<] identifier[List] operator[<] identifier[PolicyWithConfiguration] operator[>] operator[>] identifier[handler] operator[SEP] {
Keyword[final] identifier[Set] operator[<] identifier[Integer] op... |
public XCalElement child(ICalDataType dataType) {
String localName = dataType.getName().toLowerCase();
for (Element child : children()) {
if (localName.equals(child.getLocalName()) && XCAL_NS.equals(child.getNamespaceURI())) {
return new XCalElement(child);
}
}
return null;
} | class class_name[name] begin[{]
method[child, return_type[type[XCalElement]], modifier[public], parameter[dataType]] begin[{]
local_variable[type[String], localName]
ForStatement(body=BlockStatement(label=None, statements=[IfStatement(condition=BinaryOperation(operandl=MethodInvocation(argument... | Keyword[public] identifier[XCalElement] identifier[child] operator[SEP] identifier[ICalDataType] identifier[dataType] operator[SEP] {
identifier[String] identifier[localName] operator[=] identifier[dataType] operator[SEP] identifier[getName] operator[SEP] operator[SEP] operator[SEP] identifier[toLowerCase] opera... |
private Collection<Membership> findMembershipsByUserAndGroup(Session session, Node refUserNode, Node groupNode) throws Exception
{
List<Membership> memberships = new ArrayList<Membership>();
NodeIterator refTypes = refUserNode.getNodes();
while (refTypes.hasNext())
{
Node refTypeNod... | class class_name[name] begin[{]
method[findMembershipsByUserAndGroup, return_type[type[Collection]], modifier[private], parameter[session, refUserNode, groupNode]] begin[{]
local_variable[type[List], memberships]
local_variable[type[NodeIterator], refTypes]
while[call[refTypes.h... | Keyword[private] identifier[Collection] operator[<] identifier[Membership] operator[>] identifier[findMembershipsByUserAndGroup] operator[SEP] identifier[Session] identifier[session] , identifier[Node] identifier[refUserNode] , identifier[Node] identifier[groupNode] operator[SEP] Keyword[throws] identifier[Exception]... |
private static String unescapeLiteral(final String text) {
if (text == null) {
return null;
}
StringBuilder strBuilder = null;
final int max = text.length();
int readOffset = 0;
int referenceOffset = 0;
char c;
for (int i = 0; i < max; i+... | class class_name[name] begin[{]
method[unescapeLiteral, return_type[type[String]], modifier[private static], parameter[text]] begin[{]
if[binary_operation[member[.text], ==, literal[null]]] begin[{]
return[literal[null]]
else begin[{]
None
end[}]
local_variab... | Keyword[private] Keyword[static] identifier[String] identifier[unescapeLiteral] operator[SEP] Keyword[final] identifier[String] identifier[text] operator[SEP] {
Keyword[if] operator[SEP] identifier[text] operator[==] Other[null] operator[SEP] {
Keyword[return] Other[null] operator[SEP]
}
... |
public BatchWriteItemResult batchWriteItem(BatchWriteItemRequest batchWriteItemRequest)
throws AmazonServiceException, AmazonClientException {
ExecutionContext executionContext = createExecutionContext(batchWriteItemRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsReque... | class class_name[name] begin[{]
method[batchWriteItem, return_type[type[BatchWriteItemResult]], modifier[public], parameter[batchWriteItemRequest]] begin[{]
local_variable[type[ExecutionContext], executionContext]
local_variable[type[AWSRequestMetrics], awsRequestMetrics]
local_variable... | Keyword[public] identifier[BatchWriteItemResult] identifier[batchWriteItem] operator[SEP] identifier[BatchWriteItemRequest] identifier[batchWriteItemRequest] operator[SEP] Keyword[throws] identifier[AmazonServiceException] , identifier[AmazonClientException] {
identifier[ExecutionContext] identifier[executionCo... |
public static base_response unset(nitro_service client, responderparam resource, String[] args) throws Exception{
responderparam unsetresource = new responderparam();
return unsetresource.unset_resource(client,args);
} | class class_name[name] begin[{]
method[unset, return_type[type[base_response]], modifier[public static], parameter[client, resource, args]] begin[{]
local_variable[type[responderparam], unsetresource]
return[call[unsetresource.unset_resource, parameter[member[.client], member[.args]]]]
end[... | Keyword[public] Keyword[static] identifier[base_response] identifier[unset] operator[SEP] identifier[nitro_service] identifier[client] , identifier[responderparam] identifier[resource] , identifier[String] operator[SEP] operator[SEP] identifier[args] operator[SEP] Keyword[throws] identifier[Exception] {
identi... |
int qua_gain( /* output: quantizer index */
float code[], /* input : fixed codebook vector */
float[] g_coeff, /* input : correlation factors */
int l_subfr, /* input : fcb vector length */
FloatPointer gain_pit, ... | class class_name[name] begin[{]
method[qua_gain, return_type[type[int]], modifier[default], parameter[code, g_coeff, l_subfr, gain_pit, gain_code, tameflag]] begin[{]
local_variable[type[int], i]
local_variable[type[IntegerPointer], cand1]
local_variable[type[FloatPointer], gcode0]
... | Keyword[int] identifier[qua_gain] operator[SEP] Keyword[float] identifier[code] operator[SEP] operator[SEP] , Keyword[float] operator[SEP] operator[SEP] identifier[g_coeff] , Keyword[int] identifier[l_subfr] , identifier[FloatPointer] identifier[gain_pit] , identifier[FloatPointer] identifier[gain_code] , Keyword[... |
@Override
public void destroy() {
try {
this.isWork = false;
try {
if (this.thread != null) {
this.thread.join(2000);
if (this.thread.isAlive()) {
// FIXME: remove ASAP
this.thread.interrupt();
}
thread = null;
}
}
... | class class_name[name] begin[{]
method[destroy, return_type[void], modifier[public], parameter[]] begin[{]
TryStatement(block=[StatementExpression(expression=Assignment(expressionl=This(postfix_operators=[], prefix_operators=[], qualifier=None, selectors=[MemberReference(member=isWork, postfix_operator... | annotation[@] identifier[Override] Keyword[public] Keyword[void] identifier[destroy] operator[SEP] operator[SEP] {
Keyword[try] {
Keyword[this] operator[SEP] identifier[isWork] operator[=] literal[boolean] operator[SEP] Keyword[try] {
Keyword[if] operator[SEP] Keyword[this] operator[SEP... |
@Deprecated
public void sendRow(long sheetId, long rowId, RowEmail email) throws SmartsheetException {
this.createResource("sheets/" + sheetId + "/rows/" + rowId + "/emails", RowEmail.class, email);
} | class class_name[name] begin[{]
method[sendRow, return_type[void], modifier[public], parameter[sheetId, rowId, email]] begin[{]
THIS[call[None.createResource, parameter[binary_operation[binary_operation[binary_operation[binary_operation[literal["sheets/"], +, member[.sheetId]], +, literal["/row... | annotation[@] identifier[Deprecated] Keyword[public] Keyword[void] identifier[sendRow] operator[SEP] Keyword[long] identifier[sheetId] , Keyword[long] identifier[rowId] , identifier[RowEmail] identifier[email] operator[SEP] Keyword[throws] identifier[SmartsheetException] {
Keyword[this] operator[SEP] identifie... |
@Override
public void deserializeInstance(SerializationStreamReader streamReader, OWLAnnotationPropertyDomainAxiomImpl instance) throws SerializationException {
deserialize(streamReader, instance);
} | class class_name[name] begin[{]
method[deserializeInstance, return_type[void], modifier[public], parameter[streamReader, instance]] begin[{]
call[.deserialize, parameter[member[.streamReader], member[.instance]]]
end[}]
END[}] | annotation[@] identifier[Override] Keyword[public] Keyword[void] identifier[deserializeInstance] operator[SEP] identifier[SerializationStreamReader] identifier[streamReader] , identifier[OWLAnnotationPropertyDomainAxiomImpl] identifier[instance] operator[SEP] Keyword[throws] identifier[SerializationException] {
... |
private void populateDistSetTypeNameCombo() {
distsetTypeNameComboBox.setContainerDataSource(getDistSetTypeLazyQueryContainer());
distsetTypeNameComboBox.setItemCaptionPropertyId(SPUILabelDefinitions.VAR_NAME);
distsetTypeNameComboBox.setValue(getDefaultDistributionSetType().getId());
} | class class_name[name] begin[{]
method[populateDistSetTypeNameCombo, return_type[void], modifier[private], parameter[]] begin[{]
call[distsetTypeNameComboBox.setContainerDataSource, parameter[call[.getDistSetTypeLazyQueryContainer, parameter[]]]]
call[distsetTypeNameComboBox.set... | Keyword[private] Keyword[void] identifier[populateDistSetTypeNameCombo] operator[SEP] operator[SEP] {
identifier[distsetTypeNameComboBox] operator[SEP] identifier[setContainerDataSource] operator[SEP] identifier[getDistSetTypeLazyQueryContainer] operator[SEP] operator[SEP] operator[SEP] operator[SEP] identifier[... |
@Override
public int encode ( byte[] dst, int dstIndex ) {
int start = dstIndex;
SMBUtil.writeTime(this.createTime, dst, dstIndex);
dstIndex += 8;
SMBUtil.writeTime(this.lastAccessTime, dst, dstIndex);
dstIndex += 8;
SMBUtil.writeTime(this.lastWriteTime, dst, dstIndex... | class class_name[name] begin[{]
method[encode, return_type[type[int]], modifier[public], parameter[dst, dstIndex]] begin[{]
local_variable[type[int], start]
call[SMBUtil.writeTime, parameter[THIS[member[None.createTime]], member[.dst], member[.dstIndex]]]
assign[member[.... | annotation[@] identifier[Override] Keyword[public] Keyword[int] identifier[encode] operator[SEP] Keyword[byte] operator[SEP] operator[SEP] identifier[dst] , Keyword[int] identifier[dstIndex] operator[SEP] {
Keyword[int] identifier[start] operator[=] identifier[dstIndex] operator[SEP] identifier[SMBUtil] operato... |
@Override
public boolean isRequestedSessionIDValid(String sessionID, int version) {
boolean isValid = false;
if (sessionID != null) {
ISession session = (ISession) getSession(sessionID, version, false, null);
if (session != null) {
isValid = session.isValid();... | class class_name[name] begin[{]
method[isRequestedSessionIDValid, return_type[type[boolean]], modifier[public], parameter[sessionID, version]] begin[{]
local_variable[type[boolean], isValid]
if[binary_operation[member[.sessionID], !=, literal[null]]] begin[{]
local_variable[... | annotation[@] identifier[Override] Keyword[public] Keyword[boolean] identifier[isRequestedSessionIDValid] operator[SEP] identifier[String] identifier[sessionID] , Keyword[int] identifier[version] operator[SEP] {
Keyword[boolean] identifier[isValid] operator[=] literal[boolean] operator[SEP] Keyword[if] operator... |
protected String createWidgetBlockEnd() {
StringBuffer result = new StringBuffer(8);
result.append(createWidgetTableEnd());
result.append(dialogBlockEnd());
return result.toString();
} | class class_name[name] begin[{]
method[createWidgetBlockEnd, return_type[type[String]], modifier[protected], parameter[]] begin[{]
local_variable[type[StringBuffer], result]
call[result.append, parameter[call[.createWidgetTableEnd, parameter[]]]]
call[result.append, para... | Keyword[protected] identifier[String] identifier[createWidgetBlockEnd] operator[SEP] operator[SEP] {
identifier[StringBuffer] identifier[result] operator[=] Keyword[new] identifier[StringBuffer] operator[SEP] Other[8] operator[SEP] operator[SEP] identifier[result] operator[SEP] identifier[append] operator[SEP] i... |
private void createReportLink (final Sink sink, final File sourceDirectory, final File grammarFile, String linkPath)
{
sink.tableRow ();
sink.tableCell ();
if (linkPath.startsWith ("/"))
{
linkPath = linkPath.substring (1);
}
sink.link (linkPath);
String grammarFileRelativePath = sou... | class class_name[name] begin[{]
method[createReportLink, return_type[void], modifier[private], parameter[sink, sourceDirectory, grammarFile, linkPath]] begin[{]
call[sink.tableRow, parameter[]]
call[sink.tableCell, parameter[]]
if[call[linkPath.startsWith, parame... | Keyword[private] Keyword[void] identifier[createReportLink] operator[SEP] Keyword[final] identifier[Sink] identifier[sink] , Keyword[final] identifier[File] identifier[sourceDirectory] , Keyword[final] identifier[File] identifier[grammarFile] , identifier[String] identifier[linkPath] operator[SEP] {
identifie... |
private void handleLongOption(String token) throws OptionParserException {
if (token.indexOf('=') == -1) {
handleLongOptionWithoutEqual(token);
} else {
handleLongOptionWithEqual(token);
}
} | class class_name[name] begin[{]
method[handleLongOption, return_type[void], modifier[private], parameter[token]] begin[{]
if[binary_operation[call[token.indexOf, parameter[literal['=']]], ==, literal[1]]] begin[{]
call[.handleLongOptionWithoutEqual, parameter[member[.tok... | Keyword[private] Keyword[void] identifier[handleLongOption] operator[SEP] identifier[String] identifier[token] operator[SEP] Keyword[throws] identifier[OptionParserException] {
Keyword[if] operator[SEP] identifier[token] operator[SEP] identifier[indexOf] operator[SEP] literal[String] operator[SEP] operator[==] o... |
public NetworkSecurityGroupInner beginUpdateTags(String resourceGroupName, String networkSecurityGroupName, Map<String, String> tags) {
return beginUpdateTagsWithServiceResponseAsync(resourceGroupName, networkSecurityGroupName, tags).toBlocking().single().body();
} | class class_name[name] begin[{]
method[beginUpdateTags, return_type[type[NetworkSecurityGroupInner]], modifier[public], parameter[resourceGroupName, networkSecurityGroupName, tags]] begin[{]
return[call[.beginUpdateTagsWithServiceResponseAsync, parameter[member[.resourceGroupName], member[.networkSecur... | Keyword[public] identifier[NetworkSecurityGroupInner] identifier[beginUpdateTags] operator[SEP] identifier[String] identifier[resourceGroupName] , identifier[String] identifier[networkSecurityGroupName] , identifier[Map] operator[<] identifier[String] , identifier[String] operator[>] identifier[tags] operator[SEP] ... |
public static void escapeJavaScript(final Reader reader, final Writer writer,
final JavaScriptEscapeType type, final JavaScriptEscapeLevel level)
throws IOException {
if (writer == null) {
throw new IllegalArgumentException("Argument 'writer' cann... | class class_name[name] begin[{]
method[escapeJavaScript, return_type[void], modifier[public static], parameter[reader, writer, type, level]] begin[{]
if[binary_operation[member[.writer], ==, literal[null]]] begin[{]
ThrowStatement(expression=ClassCreator(arguments=[Literal(postfix_o... | Keyword[public] Keyword[static] Keyword[void] identifier[escapeJavaScript] operator[SEP] Keyword[final] identifier[Reader] identifier[reader] , Keyword[final] identifier[Writer] identifier[writer] , Keyword[final] identifier[JavaScriptEscapeType] identifier[type] , Keyword[final] identifier[JavaScriptEscapeLevel] id... |
@XmlElementDecl(namespace = "http://www.opengis.net/gml", name = "MultiSolidCoverage", substitutionHeadNamespace = "http://www.opengis.net/gml", substitutionHeadName = "_DiscreteCoverage")
public JAXBElement<MultiSolidCoverageType> createMultiSolidCoverage(MultiSolidCoverageType value) {
return new JAXBElem... | class class_name[name] begin[{]
method[createMultiSolidCoverage, return_type[type[JAXBElement]], modifier[public], parameter[value]] begin[{]
return[ClassCreator(arguments=[MemberReference(member=_MultiSolidCoverage_QNAME, postfix_operators=[], prefix_operators=[], qualifier=, selectors=[]), ClassRefer... | annotation[@] identifier[XmlElementDecl] operator[SEP] identifier[namespace] operator[=] literal[String] , identifier[name] operator[=] literal[String] , identifier[substitutionHeadNamespace] operator[=] literal[String] , identifier[substitutionHeadName] operator[=] literal[String] operator[SEP] Keyword[public] iden... |
public Object lookup(String id,String toFind)
{
return lookup(id,new MyWrapper(toFind));
} | class class_name[name] begin[{]
method[lookup, return_type[type[Object]], modifier[public], parameter[id, toFind]] begin[{]
return[call[.lookup, parameter[member[.id], ClassCreator(arguments=[MemberReference(member=toFind, postfix_operators=[], prefix_operators=[], qualifier=, selectors=[])], body=None... | Keyword[public] identifier[Object] identifier[lookup] operator[SEP] identifier[String] identifier[id] , identifier[String] identifier[toFind] operator[SEP] {
Keyword[return] identifier[lookup] operator[SEP] identifier[id] , Keyword[new] identifier[MyWrapper] operator[SEP] identifier[toFind] operator[SEP] opera... |
public Group updateGroup(Object groupIdOrPath, String name, String path, String description, Visibility visibility,
Boolean lfsEnabled, Boolean requestAccessEnabled, Integer parentId) throws GitLabApiException {
Form formData = new GitLabApiForm()
.withParam("name", name)
... | class class_name[name] begin[{]
method[updateGroup, return_type[type[Group]], modifier[public], parameter[groupIdOrPath, name, path, description, visibility, lfsEnabled, requestAccessEnabled, parentId]] begin[{]
local_variable[type[Form], formData]
local_variable[type[Response], response]
... | Keyword[public] identifier[Group] identifier[updateGroup] operator[SEP] identifier[Object] identifier[groupIdOrPath] , identifier[String] identifier[name] , identifier[String] identifier[path] , identifier[String] identifier[description] , identifier[Visibility] identifier[visibility] , identifier[Boolean] identif... |
@SuppressWarnings("unchecked")
private static void extractTables(
String pdfDirPath,
String outputDirPath,
String parserType) throws IOException
{
/*
* directory existence check
*/
File pdfDir = new File(pdfDirPath);
if (!pdfDir.exists())
{
System.out.printf("[Error] %s ... | class class_name[name] begin[{]
method[extractTables, return_type[void], modifier[private static], parameter[pdfDirPath, outputDirPath, parserType]] begin[{]
local_variable[type[File], pdfDir]
if[call[pdfDir.exists, parameter[]]] begin[{]
call[System.out.printf, ... | annotation[@] identifier[SuppressWarnings] operator[SEP] literal[String] operator[SEP] Keyword[private] Keyword[static] Keyword[void] identifier[extractTables] operator[SEP] identifier[String] identifier[pdfDirPath] , identifier[String] identifier[outputDirPath] , identifier[String] identifier[parserType] operator[SE... |
private void parseBody(Node parent, String tag, String bodyType)
throws JasperException
{
if( bodyType.equalsIgnoreCase( TagInfo.BODY_CONTENT_TAG_DEPENDENT ) ) {
parseTagDependentBody( parent, tag );
}
else if( bodyType.equalsIgnoreCase( TagInfo.BODY_CONTENT_EMPTY ) ) {... | class class_name[name] begin[{]
method[parseBody, return_type[void], modifier[private], parameter[parent, tag, bodyType]] begin[{]
if[call[bodyType.equalsIgnoreCase, parameter[member[TagInfo.BODY_CONTENT_TAG_DEPENDENT]]]] begin[{]
call[.parseTagDependentBody, parameter[m... | Keyword[private] Keyword[void] identifier[parseBody] operator[SEP] identifier[Node] identifier[parent] , identifier[String] identifier[tag] , identifier[String] identifier[bodyType] operator[SEP] Keyword[throws] identifier[JasperException] {
Keyword[if] operator[SEP] identifier[bodyType] operator[SEP] identifi... |
public static VertexData generateCone(float radius, float height) {
final VertexData destination = new VertexData();
final VertexAttribute positionsAttribute = new VertexAttribute("positions", DataType.FLOAT, 3);
destination.addAttribute(0, positionsAttribute);
final TFloatList positions... | class class_name[name] begin[{]
method[generateCone, return_type[type[VertexData]], modifier[public static], parameter[radius, height]] begin[{]
local_variable[type[VertexData], destination]
local_variable[type[VertexAttribute], positionsAttribute]
call[destination.addAttribute,... | Keyword[public] Keyword[static] identifier[VertexData] identifier[generateCone] operator[SEP] Keyword[float] identifier[radius] , Keyword[float] identifier[height] operator[SEP] {
Keyword[final] identifier[VertexData] identifier[destination] operator[=] Keyword[new] identifier[VertexData] operator[SEP] operator... |
private static CtClass[] generateClassField(Class<?>... classes) throws NotFoundException {
CtClass[] result = new CtClass[classes.length];
for (int i = 0; i < classes.length; i++) {
result[i] = cp.get(classes[i].getName());
}
return result;
} | class class_name[name] begin[{]
method[generateClassField, return_type[type[CtClass]], modifier[private static], parameter[classes]] begin[{]
local_variable[type[CtClass], result]
ForStatement(body=BlockStatement(label=None, statements=[StatementExpression(expression=Assignment(expressionl=Memb... | Keyword[private] Keyword[static] identifier[CtClass] operator[SEP] operator[SEP] identifier[generateClassField] operator[SEP] identifier[Class] operator[<] operator[?] operator[>] operator[...] identifier[classes] operator[SEP] Keyword[throws] identifier[NotFoundException] {
identifier[CtClass] operator[SEP] ope... |
public static void addEntry(File zip, ZipEntrySource entry, File destZip) {
addEntries(zip, new ZipEntrySource[] { entry }, destZip);
} | class class_name[name] begin[{]
method[addEntry, return_type[void], modifier[public static], parameter[zip, entry, destZip]] begin[{]
call[.addEntries, parameter[member[.zip], ArrayCreator(dimensions=[None], initializer=ArrayInitializer(initializers=[MemberReference(member=entry, postfix_operat... | Keyword[public] Keyword[static] Keyword[void] identifier[addEntry] operator[SEP] identifier[File] identifier[zip] , identifier[ZipEntrySource] identifier[entry] , identifier[File] identifier[destZip] operator[SEP] {
identifier[addEntries] operator[SEP] identifier[zip] , Keyword[new] identifier[ZipEntrySource]... |
protected SerializationPolicy doGetSerializationPolicy(HttpServletRequest request, String moduleBaseURL,
String strongName) {
if (getSerializationPolicyLocator() == null) {
return super.doGetSerializationPolicy(request, moduleBaseURL, strongName);
} else {
return getSerializationPolicyLocator().loadPolicy(... | class class_name[name] begin[{]
method[doGetSerializationPolicy, return_type[type[SerializationPolicy]], modifier[protected], parameter[request, moduleBaseURL, strongName]] begin[{]
if[binary_operation[call[.getSerializationPolicyLocator, parameter[]], ==, literal[null]]] begin[{]
r... | Keyword[protected] identifier[SerializationPolicy] identifier[doGetSerializationPolicy] operator[SEP] identifier[HttpServletRequest] identifier[request] , identifier[String] identifier[moduleBaseURL] , identifier[String] identifier[strongName] operator[SEP] {
Keyword[if] operator[SEP] identifier[getSerializati... |
public static <T> boolean all(Iterator<T> iterator, Predicate<? super T> predicate) {
checkNotNull(predicate);
while (iterator.hasNext()) {
T element = iterator.next();
if (!predicate.apply(element)) {
return false;
}
}
return true;
} | class class_name[name] begin[{]
method[all, return_type[type[boolean]], modifier[public static], parameter[iterator, predicate]] begin[{]
call[.checkNotNull, parameter[member[.predicate]]]
while[call[iterator.hasNext, parameter[]]] begin[{]
local_variable[type[T], el... | Keyword[public] Keyword[static] operator[<] identifier[T] operator[>] Keyword[boolean] identifier[all] operator[SEP] identifier[Iterator] operator[<] identifier[T] operator[>] identifier[iterator] , identifier[Predicate] operator[<] operator[?] Keyword[super] identifier[T] operator[>] identifier[predicate] operator[SE... |
private void writeObject(final ObjectOutputStream s) throws IOException {
s.defaultWriteObject();
s.writeInt(level);
s.writeInt(syslogEquivalent);
s.writeUTF(levelStr);
} | class class_name[name] begin[{]
method[writeObject, return_type[void], modifier[private], parameter[s]] begin[{]
call[s.defaultWriteObject, parameter[]]
call[s.writeInt, parameter[member[.level]]]
call[s.writeInt, parameter[member[.syslogEquivalent]]]
... | Keyword[private] Keyword[void] identifier[writeObject] operator[SEP] Keyword[final] identifier[ObjectOutputStream] identifier[s] operator[SEP] Keyword[throws] identifier[IOException] {
identifier[s] operator[SEP] identifier[defaultWriteObject] operator[SEP] operator[SEP] operator[SEP] identifier[s] operator[SEP]... |
private void run(String key, ConcurrentLinkedQueue<Work> workQueue) {
Work work = workQueue.poll();
CompletableFuture<Void> future;
try {
future = processEvent(work.getEvent());
} catch (Exception e) {
future = Futures.failedFuture(e);
}
future.wh... | class class_name[name] begin[{]
method[run, return_type[void], modifier[private], parameter[key, workQueue]] begin[{]
local_variable[type[Work], work]
local_variable[type[CompletableFuture], future]
TryStatement(block=[StatementExpression(expression=Assignment(expressionl=MemberReferenc... | Keyword[private] Keyword[void] identifier[run] operator[SEP] identifier[String] identifier[key] , identifier[ConcurrentLinkedQueue] operator[<] identifier[Work] operator[>] identifier[workQueue] operator[SEP] {
identifier[Work] identifier[work] operator[=] identifier[workQueue] operator[SEP] identifier[poll] op... |
public ImageSource BFS(int startI, int startJ, /*String imageName*/ImageSource originalImage) {
LinkedList<Vector2i> queue = new LinkedList<>();
//=============================================================================
int gapX = 30;
int gapY = 30;
MatrixSource letter = ... | class class_name[name] begin[{]
method[BFS, return_type[type[ImageSource]], modifier[public], parameter[startI, startJ, originalImage]] begin[{]
local_variable[type[LinkedList], queue]
local_variable[type[int], gapX]
local_variable[type[int], gapY]
local_variable[type[MatrixSour... | Keyword[public] identifier[ImageSource] identifier[BFS] operator[SEP] Keyword[int] identifier[startI] , Keyword[int] identifier[startJ] , identifier[ImageSource] identifier[originalImage] operator[SEP] {
identifier[LinkedList] operator[<] identifier[Vector2i] operator[>] identifier[queue] operator[=] Keyword[n... |
private ImmutableSetMultimap<Class<? extends Annotation>, Element> validElements(
ImmutableMap<String, Optional<? extends Element>> deferredElements,
RoundEnvironment roundEnv) {
ImmutableSetMultimap.Builder<Class<? extends Annotation>, Element>
deferredElementsByAnnotationBuilder = ImmutableSet... | class class_name[name] begin[{]
method[validElements, return_type[type[ImmutableSetMultimap]], modifier[private], parameter[deferredElements, roundEnv]] begin[{]
local_variable[type[ImmutableSetMultimap], deferredElementsByAnnotationBuilder]
ForStatement(body=BlockStatement(label=None, statemen... | Keyword[private] identifier[ImmutableSetMultimap] operator[<] identifier[Class] operator[<] operator[?] Keyword[extends] identifier[Annotation] operator[>] , identifier[Element] operator[>] identifier[validElements] operator[SEP] identifier[ImmutableMap] operator[<] identifier[String] , identifier[Optional] operator[... |
public TableRef create(String primaryKeyName, StorageDataType primaryKeyDataType, String secondaryKeyName,
StorageDataType secondaryKeyDataType, StorageProvisionType provisionType,
StorageProvisionLoad provisionLoad, OnTableCreation onTableCreation, OnError onError){
PostBodyBuilder pbb = new PostBodyBuilde... | class class_name[name] begin[{]
method[create, return_type[type[TableRef]], modifier[public], parameter[primaryKeyName, primaryKeyDataType, secondaryKeyName, secondaryKeyDataType, provisionType, provisionLoad, onTableCreation, onError]] begin[{]
local_variable[type[PostBodyBuilder], pbb]
... | Keyword[public] identifier[TableRef] identifier[create] operator[SEP] identifier[String] identifier[primaryKeyName] , identifier[StorageDataType] identifier[primaryKeyDataType] , identifier[String] identifier[secondaryKeyName] , identifier[StorageDataType] identifier[secondaryKeyDataType] , identifier[StorageProvis... |
public void splitStart(long stamp)
{
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
SibTr.entry(this, tc, "splitStart", new Object[] {Long.valueOf(stamp), Integer.valueOf(cursor)});
RangeObject ro = (RangeObject) blockVector.get(cursor);
if (ro.startstamp == stamp)
{
if ... | class class_name[name] begin[{]
method[splitStart, return_type[void], modifier[public], parameter[stamp]] begin[{]
if[binary_operation[call[TraceComponent.isAnyTracingEnabled, parameter[]], &&, call[tc.isEntryEnabled, parameter[]]]] begin[{]
call[SibTr.entry, parameter[THIS[], membe... | Keyword[public] Keyword[void] identifier[splitStart] operator[SEP] Keyword[long] identifier[stamp] operator[SEP] {
Keyword[if] operator[SEP] identifier[TraceComponent] operator[SEP] identifier[isAnyTracingEnabled] operator[SEP] operator[SEP] operator[&&] identifier[tc] operator[SEP] identifier[isEntryEnabled] op... |
public Matrix4d rotationY(double ang) {
double sin, cos;
sin = Math.sin(ang);
cos = Math.cosFromSin(sin, ang);
if ((properties & PROPERTY_IDENTITY) == 0)
this._identity();
m00 = cos;
m02 = -sin;
m20 = sin;
m22 = cos;
properties = PROPER... | class class_name[name] begin[{]
method[rotationY, return_type[type[Matrix4d]], modifier[public], parameter[ang]] begin[{]
local_variable[type[double], sin]
assign[member[.sin], call[Math.sin, parameter[member[.ang]]]]
assign[member[.cos], call[Math.cosFromSin, parameter[... | Keyword[public] identifier[Matrix4d] identifier[rotationY] operator[SEP] Keyword[double] identifier[ang] operator[SEP] {
Keyword[double] identifier[sin] , identifier[cos] operator[SEP] identifier[sin] operator[=] identifier[Math] operator[SEP] identifier[sin] operator[SEP] identifier[ang] operator[SEP] operator... |
public java.util.List<String> getCustomDnsServers() {
if (customDnsServers == null) {
customDnsServers = new com.amazonaws.internal.SdkInternalList<String>();
}
return customDnsServers;
} | class class_name[name] begin[{]
method[getCustomDnsServers, return_type[type[java]], modifier[public], parameter[]] begin[{]
if[binary_operation[member[.customDnsServers], ==, literal[null]]] begin[{]
assign[member[.customDnsServers], ClassCreator(arguments=[], body=None... | Keyword[public] identifier[java] operator[SEP] identifier[util] operator[SEP] identifier[List] operator[<] identifier[String] operator[>] identifier[getCustomDnsServers] operator[SEP] operator[SEP] {
Keyword[if] operator[SEP] identifier[customDnsServers] operator[==] Other[null] operator[SEP] {
identi... |
public static boolean isTypeIncludedIn(TypeName value, Type... types) {
for (Type item : types) {
if (value.equals(typeName(item))) {
return true;
}
}
return false;
} | class class_name[name] begin[{]
method[isTypeIncludedIn, return_type[type[boolean]], modifier[public static], parameter[value, types]] begin[{]
ForStatement(body=BlockStatement(label=None, statements=[IfStatement(condition=MethodInvocation(arguments=[MethodInvocation(arguments=[MemberReference(member=i... | Keyword[public] Keyword[static] Keyword[boolean] identifier[isTypeIncludedIn] operator[SEP] identifier[TypeName] identifier[value] , identifier[Type] operator[...] identifier[types] operator[SEP] {
Keyword[for] operator[SEP] identifier[Type] identifier[item] operator[:] identifier[types] operator[SEP] {
... |
public static int calculateQuotientScale(int precision1, int scale1,int precision2, int scale2)
{
return Math.max(scale1 + precision2 -scale2 + 1, 6);
} | class class_name[name] begin[{]
method[calculateQuotientScale, return_type[type[int]], modifier[public static], parameter[precision1, scale1, precision2, scale2]] begin[{]
return[call[Math.max, parameter[binary_operation[binary_operation[binary_operation[member[.scale1], +, member[.precision2]], -, mem... | Keyword[public] Keyword[static] Keyword[int] identifier[calculateQuotientScale] operator[SEP] Keyword[int] identifier[precision1] , Keyword[int] identifier[scale1] , Keyword[int] identifier[precision2] , Keyword[int] identifier[scale2] operator[SEP] {
Keyword[return] identifier[Math] operator[SEP] identifier[... |
public WorkSheet swapRowAndColumns() throws Exception {
WorkSheet swappedWorkSheet = new WorkSheet(getColumns(), getRows());
for (String row : getRows()) {
for (String col : getColumns()) {
String value = getCell(row, col);
swappedWorkSheet.addCell(col, row, value);
}
}
ArrayList<String> metadat... | class class_name[name] begin[{]
method[swapRowAndColumns, return_type[type[WorkSheet]], modifier[public], parameter[]] begin[{]
local_variable[type[WorkSheet], swappedWorkSheet]
ForStatement(body=BlockStatement(label=None, statements=[ForStatement(body=BlockStatement(label=None, statements=[Loc... | Keyword[public] identifier[WorkSheet] identifier[swapRowAndColumns] operator[SEP] operator[SEP] Keyword[throws] identifier[Exception] {
identifier[WorkSheet] identifier[swappedWorkSheet] operator[=] Keyword[new] identifier[WorkSheet] operator[SEP] identifier[getColumns] operator[SEP] operator[SEP] , identifier[... |
protected LocaleSymbol setupConditionLocaleSymbol(final ConditionFormatter formatter, final Token.Condition token) {
final Matcher matcher = PATTERN_CONDITION_LOCALE_SYMBOL.matcher(token.getValue());
if(!matcher.matches()) {
throw new IllegalArgumentException("not match condition:" + to... | class class_name[name] begin[{]
method[setupConditionLocaleSymbol, return_type[type[LocaleSymbol]], modifier[protected], parameter[formatter, token]] begin[{]
local_variable[type[Matcher], matcher]
if[call[matcher.matches, parameter[]]] begin[{]
ThrowStatement(expression=Cla... | Keyword[protected] identifier[LocaleSymbol] identifier[setupConditionLocaleSymbol] operator[SEP] Keyword[final] identifier[ConditionFormatter] identifier[formatter] , Keyword[final] identifier[Token] operator[SEP] identifier[Condition] identifier[token] operator[SEP] {
Keyword[final] identifier[Matcher] identif... |
@NullSafe
@SafeVarargs
public static <T> Set<T> asSet(T... elements) {
return stream(nullSafeArray(elements)).collect(Collectors.toSet());
} | class class_name[name] begin[{]
method[asSet, return_type[type[Set]], modifier[public static], parameter[elements]] begin[{]
return[call[.stream, parameter[call[.nullSafeArray, parameter[member[.elements]]]]]]
end[}]
END[}] | annotation[@] identifier[NullSafe] annotation[@] identifier[SafeVarargs] Keyword[public] Keyword[static] operator[<] identifier[T] operator[>] identifier[Set] operator[<] identifier[T] operator[>] identifier[asSet] operator[SEP] identifier[T] operator[...] identifier[elements] operator[SEP] {
Keyword[return] ide... |
public synchronized void truncate(long len) throws SQLException {
checkFreed();
if (!conn.haveMinimumServerVersion(ServerVersion.v8_3)) {
throw new PSQLException(
GT.tr("Truncation of large objects is only implemented in 8.3 and later servers."),
PSQLState.NOT_IMPLEMENTED);
}
... | class class_name[name] begin[{]
method[truncate, return_type[void], modifier[synchronized public], parameter[len]] begin[{]
call[.checkFreed, parameter[]]
if[call[conn.haveMinimumServerVersion, parameter[member[ServerVersion.v8_3]]]] begin[{]
ThrowStatement(expressio... | Keyword[public] Keyword[synchronized] Keyword[void] identifier[truncate] operator[SEP] Keyword[long] identifier[len] operator[SEP] Keyword[throws] identifier[SQLException] {
identifier[checkFreed] operator[SEP] operator[SEP] operator[SEP] Keyword[if] operator[SEP] operator[!] identifier[conn] operator[SEP] ident... |
public static void stripWhitespaceNodes(Node element) {
Node node, child;
for (child = element.getFirstChild(); child != null; child = node) {
node = child.getNextSibling();
stripWhitespaceNodes(child);
}
if (element.getNodeType() == Node.TEXT_NODE && element.get... | class class_name[name] begin[{]
method[stripWhitespaceNodes, return_type[void], modifier[public static], parameter[element]] begin[{]
local_variable[type[Node], node]
ForStatement(body=BlockStatement(label=None, statements=[StatementExpression(expression=Assignment(expressionl=MemberReference(m... | Keyword[public] Keyword[static] Keyword[void] identifier[stripWhitespaceNodes] operator[SEP] identifier[Node] identifier[element] operator[SEP] {
identifier[Node] identifier[node] , identifier[child] operator[SEP] Keyword[for] operator[SEP] identifier[child] operator[=] identifier[element] operator[SEP] identif... |
public DOMSource createDOMSource(DocumentSource src)
{
try
{
Constructor<? extends DOMSource> constr = getDOMSourceClass().getConstructor(DocumentSource.class);
return constr.newInstance(src);
} catch (Exception e) {
log.warn("BoxFactory: Warning: could no... | class class_name[name] begin[{]
method[createDOMSource, return_type[type[DOMSource]], modifier[public], parameter[src]] begin[{]
TryStatement(block=[LocalVariableDeclaration(annotations=[], declarators=[VariableDeclarator(dimensions=[], initializer=MethodInvocation(arguments=[], member=getDOMSourceClas... | Keyword[public] identifier[DOMSource] identifier[createDOMSource] operator[SEP] identifier[DocumentSource] identifier[src] operator[SEP] {
Keyword[try] {
identifier[Constructor] operator[<] operator[?] Keyword[extends] identifier[DOMSource] operator[>] identifier[constr] operator[=] identifier[getDOMS... |
public static String trimInFront(String buffer) {
// remove spaces in front
int count = 0;
for (int i = 0; i < buffer.length(); i++) {
if (buffer.charAt(i) == SPACE_CHAR)
count++;
else
break;
}
if (count > 0)
ret... | class class_name[name] begin[{]
method[trimInFront, return_type[type[String]], modifier[public static], parameter[buffer]] begin[{]
local_variable[type[int], count]
ForStatement(body=BlockStatement(label=None, statements=[IfStatement(condition=BinaryOperation(operandl=MethodInvocation(arguments... | Keyword[public] Keyword[static] identifier[String] identifier[trimInFront] operator[SEP] identifier[String] identifier[buffer] operator[SEP] {
Keyword[int] identifier[count] operator[=] Other[0] operator[SEP] Keyword[for] operator[SEP] Keyword[int] identifier[i] operator[=] Other[0] operator[SEP] identifier[i] o... |
private void processConfig(final HttpServerExchange exchange, final RequestData requestData) {
// Get the node builder
List<String> hosts = null;
List<String> contexts = null;
final Balancer.BalancerBuilder balancer = Balancer.builder();
final NodeConfig.NodeBuilder node = NodeC... | class class_name[name] begin[{]
method[processConfig, return_type[void], modifier[private], parameter[exchange, requestData]] begin[{]
local_variable[type[List], hosts]
local_variable[type[List], contexts]
local_variable[type[Balancer], balancer]
local_variable[type[NodeConfig],... | Keyword[private] Keyword[void] identifier[processConfig] operator[SEP] Keyword[final] identifier[HttpServerExchange] identifier[exchange] , Keyword[final] identifier[RequestData] identifier[requestData] operator[SEP] {
identifier[List] operator[<] identifier[String] operator[>] identifier[hosts] operator[=] Oth... |
public Notebook loadNotebook() throws EDAMUserException, EDAMSystemException, TException, EDAMNotFoundException {
if (mNotebookGuid == null) {
return null;
}
if (mLinked) {
LinkedNotebook linkedNotebook = NoteRefHelper.getLinkedNotebook(mNotebookGuid);
return... | class class_name[name] begin[{]
method[loadNotebook, return_type[type[Notebook]], modifier[public], parameter[]] begin[{]
if[binary_operation[member[.mNotebookGuid], ==, literal[null]]] begin[{]
return[literal[null]]
else begin[{]
None
end[}]
if[membe... | Keyword[public] identifier[Notebook] identifier[loadNotebook] operator[SEP] operator[SEP] Keyword[throws] identifier[EDAMUserException] , identifier[EDAMSystemException] , identifier[TException] , identifier[EDAMNotFoundException] {
Keyword[if] operator[SEP] identifier[mNotebookGuid] operator[==] Other[null] ... |
@SuppressWarnings({ "squid:S1166" })
private static UserDetails loadUserByUsername(final String username) {
final UserDetailsService userDetailsService = SpringContextHelper.getBean(UserDetailsService.class);
try {
return userDetailsService.loadUserByUsername(username);
} catch (... | class class_name[name] begin[{]
method[loadUserByUsername, return_type[type[UserDetails]], modifier[private static], parameter[username]] begin[{]
local_variable[type[UserDetailsService], userDetailsService]
TryStatement(block=[ReturnStatement(expression=MethodInvocation(arguments=[MemberRefere... | annotation[@] identifier[SuppressWarnings] operator[SEP] {
literal[String]
} operator[SEP] Keyword[private] Keyword[static] identifier[UserDetails] identifier[loadUserByUsername] operator[SEP] Keyword[final] identifier[String] identifier[username] operator[SEP] {
Keyword[final] identifier[UserDetailsSe... |
public Object execute(final Map<Object, Object> iArgs) {
final StringBuilder result = new StringBuilder();
if (optimizeEdges)
result.append(optimizeEdges());
return result.toString();
} | class class_name[name] begin[{]
method[execute, return_type[type[Object]], modifier[public], parameter[iArgs]] begin[{]
local_variable[type[StringBuilder], result]
if[member[.optimizeEdges]] begin[{]
call[result.append, parameter[call[.optimizeEdges, parameter[]]]]
e... | Keyword[public] identifier[Object] identifier[execute] operator[SEP] Keyword[final] identifier[Map] operator[<] identifier[Object] , identifier[Object] operator[>] identifier[iArgs] operator[SEP] {
Keyword[final] identifier[StringBuilder] identifier[result] operator[=] Keyword[new] identifier[StringBuilder] ope... |
public static void enableProxy( String url, String port, String user, String pwd, String nonProxyHosts ) {
_url = url;
_port = port;
_user = user;
_pwd = pwd;
System.setProperty("http.proxyHost", url);
System.setProperty("https.proxyHost", url);
if (port != null ... | class class_name[name] begin[{]
method[enableProxy, return_type[void], modifier[public static], parameter[url, port, user, pwd, nonProxyHosts]] begin[{]
assign[member[._url], member[.url]]
assign[member[._port], member[.port]]
assign[member[._user], member[.user]... | Keyword[public] Keyword[static] Keyword[void] identifier[enableProxy] operator[SEP] identifier[String] identifier[url] , identifier[String] identifier[port] , identifier[String] identifier[user] , identifier[String] identifier[pwd] , identifier[String] identifier[nonProxyHosts] operator[SEP] {
identifier[_ur... |
public BaseField setupField(int iFieldSeq)
{
BaseField field = null;
if (iFieldSeq == 0)
field = new ClassProjectField(this, CLASS_PROJECT_ID, Constants.DEFAULT_FIELD_LENGTH, null, null);
if (iFieldSeq == 1)
field = new StringField(this, NAME, 10, null, null);
... | 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[0]]] 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[0] operator[SEP] identifier[field] operato... |
@Override
public void removeCallback(Callback callback) {
callbacks.remove(callback);
if (manager != null) {
callback.cleanup();
}
} | class class_name[name] begin[{]
method[removeCallback, return_type[void], modifier[public], parameter[callback]] begin[{]
call[callbacks.remove, parameter[member[.callback]]]
if[binary_operation[member[.manager], !=, literal[null]]] begin[{]
call[callback... | annotation[@] identifier[Override] Keyword[public] Keyword[void] identifier[removeCallback] operator[SEP] identifier[Callback] identifier[callback] operator[SEP] {
identifier[callbacks] operator[SEP] identifier[remove] operator[SEP] identifier[callback] operator[SEP] operator[SEP] Keyword[if] operator[SEP] ident... |
public int getDataSize() {
// Data size is given by lvs
int size = 0;
for(int i=0; i<numLVs; i++) {
size += IOUtils.toInt(lvs[i]);
}
return size;
} | class class_name[name] begin[{]
method[getDataSize, return_type[type[int]], modifier[public], parameter[]] begin[{]
local_variable[type[int], size]
ForStatement(body=BlockStatement(label=None, statements=[StatementExpression(expression=Assignment(expressionl=MemberReference(member=size, postfix... | Keyword[public] Keyword[int] identifier[getDataSize] operator[SEP] operator[SEP] {
Keyword[int] identifier[size] operator[=] Other[0] operator[SEP] Keyword[for] operator[SEP] Keyword[int] identifier[i] operator[=] Other[0] operator[SEP] identifier[i] operator[<] identifier[numLVs] operator[SEP] identifier[i] ope... |
public int indexs(final Integer fromIndex, String... indexWith) {
int index = INDEX_NONE_EXISTS;
final String target = ignoreCase ? delegate.get().toLowerCase() : delegate.get();
for (String input : indexWith) {
String target2 = ignoreCase ? input.toLowerCase() : input;
if ((index = target.indexOf(target... | class class_name[name] begin[{]
method[indexs, return_type[type[int]], modifier[public], parameter[fromIndex, indexWith]] begin[{]
local_variable[type[int], index]
local_variable[type[String], target]
ForStatement(body=BlockStatement(label=None, statements=[LocalVariableDeclaration(anno... | Keyword[public] Keyword[int] identifier[indexs] operator[SEP] Keyword[final] identifier[Integer] identifier[fromIndex] , identifier[String] operator[...] identifier[indexWith] operator[SEP] {
Keyword[int] identifier[index] operator[=] identifier[INDEX_NONE_EXISTS] operator[SEP] Keyword[final] identifier[String]... |
public void addAllIfNotExist(Properties properties) {
for (String key : properties.stringPropertyNames()) {
if (!this.specProperties.containsKey(key) && !this.commonProperties.containsKey(key)) {
this.specProperties.setProperty(key, properties.getProperty(key));
}
}
} | class class_name[name] begin[{]
method[addAllIfNotExist, return_type[void], modifier[public], parameter[properties]] begin[{]
ForStatement(body=BlockStatement(label=None, statements=[IfStatement(condition=BinaryOperation(operandl=This(postfix_operators=[], prefix_operators=['!'], qualifier=None, select... | Keyword[public] Keyword[void] identifier[addAllIfNotExist] operator[SEP] identifier[Properties] identifier[properties] operator[SEP] {
Keyword[for] operator[SEP] identifier[String] identifier[key] operator[:] identifier[properties] operator[SEP] identifier[stringPropertyNames] operator[SEP] operator[SEP] operat... |
public static void apply(Activity activity, int viewId, Face type){
TextView text = (TextView) activity.findViewById(viewId);
if(text != null)
apply(text, type);
} | class class_name[name] begin[{]
method[apply, return_type[void], modifier[public static], parameter[activity, viewId, type]] begin[{]
local_variable[type[TextView], text]
if[binary_operation[member[.text], !=, literal[null]]] begin[{]
call[.apply, parameter[member[.text], me... | Keyword[public] Keyword[static] Keyword[void] identifier[apply] operator[SEP] identifier[Activity] identifier[activity] , Keyword[int] identifier[viewId] , identifier[Face] identifier[type] operator[SEP] {
identifier[TextView] identifier[text] operator[=] operator[SEP] identifier[TextView] operator[SEP] identi... |
public static String renameSuffix(String path, String suffix) {
int pos = path.length();
for (--pos; pos > 0; pos--) {
if (path.charAt(pos) == '.')
break;
if (path.charAt(pos) == '/' || path.charAt(pos) == '\\') {
pos = -1;
b... | class class_name[name] begin[{]
method[renameSuffix, return_type[type[String]], modifier[public static], parameter[path, suffix]] begin[{]
local_variable[type[int], pos]
ForStatement(body=BlockStatement(label=None, statements=[IfStatement(condition=BinaryOperation(operandl=MethodInvocation(argu... | Keyword[public] Keyword[static] identifier[String] identifier[renameSuffix] operator[SEP] identifier[String] identifier[path] , identifier[String] identifier[suffix] operator[SEP] {
Keyword[int] identifier[pos] operator[=] identifier[path] operator[SEP] identifier[length] operator[SEP] operator[SEP] operator[SE... |
public void resetIndex(long index, long timestamp) {
currentOperation = OperationType.COMMAND;
operationIndex = index;
currentIndex = index;
currentTimestamp = timestamp;
setCommitIndex(index);
service.tick(new WallClockTimestamp(currentTimestamp));
} | class class_name[name] begin[{]
method[resetIndex, return_type[void], modifier[public], parameter[index, timestamp]] begin[{]
assign[member[.currentOperation], member[OperationType.COMMAND]]
assign[member[.operationIndex], member[.index]]
assign[member[.currentIn... | Keyword[public] Keyword[void] identifier[resetIndex] operator[SEP] Keyword[long] identifier[index] , Keyword[long] identifier[timestamp] operator[SEP] {
identifier[currentOperation] operator[=] identifier[OperationType] operator[SEP] identifier[COMMAND] operator[SEP] identifier[operationIndex] operator[=] ident... |
public static StringBuilder createQueryStringFromMap(Map m, String ampersand) {
StringBuilder aReturn = new StringBuilder("");
Set aEntryS = m.entrySet();
Iterator aEntryI = aEntryS.iterator();
while (aEntryI.hasNext()) {
Map.Entry aEntry = (Map.Entry) aEntryI.next();
Object o = aEntry.getValue();... | class class_name[name] begin[{]
method[createQueryStringFromMap, return_type[type[StringBuilder]], modifier[public static], parameter[m, ampersand]] begin[{]
local_variable[type[StringBuilder], aReturn]
local_variable[type[Set], aEntryS]
local_variable[type[Iterator], aEntryI]
... | Keyword[public] Keyword[static] identifier[StringBuilder] identifier[createQueryStringFromMap] operator[SEP] identifier[Map] identifier[m] , identifier[String] identifier[ampersand] operator[SEP] {
identifier[StringBuilder] identifier[aReturn] operator[=] Keyword[new] identifier[StringBuilder] operator[SEP] lit... |
private boolean applyCorsConfig(final HttpRequest req, final AbstractHttpQuery query)
throws BadRequestException {
final String domain = req.headers().get("Origin");
// catch CORS requests and add the header or refuse them if the domain
// list has been configured
if (query.method() == Htt... | class class_name[name] begin[{]
method[applyCorsConfig, return_type[type[boolean]], modifier[private], parameter[req, query]] begin[{]
local_variable[type[String], domain]
if[binary_operation[binary_operation[call[query.method, parameter[]], ==, member[HttpMethod.OPTIONS]], ||, binary_o... | Keyword[private] Keyword[boolean] identifier[applyCorsConfig] operator[SEP] Keyword[final] identifier[HttpRequest] identifier[req] , Keyword[final] identifier[AbstractHttpQuery] identifier[query] operator[SEP] Keyword[throws] identifier[BadRequestException] {
Keyword[final] identifier[String] identifier[domain]... |
private void returnDocumentBuilderToPool(DocumentBuilder db) {
try {
db.reset();
documentBuilderPool.offerFirst(db);
} catch (UnsupportedOperationException e) {
// document builders that don't support reset() can't be pooled
}
} | class class_name[name] begin[{]
method[returnDocumentBuilderToPool, return_type[void], modifier[private], parameter[db]] begin[{]
TryStatement(block=[StatementExpression(expression=MethodInvocation(arguments=[], member=reset, postfix_operators=[], prefix_operators=[], qualifier=db, selectors=[], type_a... | Keyword[private] Keyword[void] identifier[returnDocumentBuilderToPool] operator[SEP] identifier[DocumentBuilder] identifier[db] operator[SEP] {
Keyword[try] {
identifier[db] operator[SEP] identifier[reset] operator[SEP] operator[SEP] operator[SEP] identifier[documentBuilderPool] operator[SEP] identifi... |
static void rcvSendToExceptionDest(CommsServerByteBuffer request,
Conversation conversation,
int requestNumber,
boolean allocatedFromBufferPool,
boolean partOfExchange)... | class class_name[name] begin[{]
method[rcvSendToExceptionDest, return_type[void], modifier[static], parameter[request, conversation, requestNumber, allocatedFromBufferPool, partOfExchange]] begin[{]
if[binary_operation[call[TraceComponent.isAnyTracingEnabled, parameter[]], &&, call[tc.isEntryEn... | Keyword[static] Keyword[void] identifier[rcvSendToExceptionDest] operator[SEP] identifier[CommsServerByteBuffer] identifier[request] , identifier[Conversation] identifier[conversation] , Keyword[int] identifier[requestNumber] , Keyword[boolean] identifier[allocatedFromBufferPool] , Keyword[boolean] identifier[partO... |
public static Map<DomainParts, String> splitDomain(String domain) {
Map<DomainParts, String> domainParts = null;
String[] dottedParts = domain.trim().toLowerCase(Locale.ENGLISH).split("\\.");
if(dottedParts.length==2) {
domainParts = new HashMap<>();
dom... | class class_name[name] begin[{]
method[splitDomain, return_type[type[Map]], modifier[public static], parameter[domain]] begin[{]
local_variable[type[Map], domainParts]
local_variable[type[String], dottedParts]
if[binary_operation[member[dottedParts.length], ==, literal[2]]] begi... | Keyword[public] Keyword[static] identifier[Map] operator[<] identifier[DomainParts] , identifier[String] operator[>] identifier[splitDomain] operator[SEP] identifier[String] identifier[domain] operator[SEP] {
identifier[Map] operator[<] identifier[DomainParts] , identifier[String] operator[>] identifier[domain... |
public ParameterBuilder<T> property(String key, Object value) {
if (key == null) {
throw new IllegalArgumentException("Key argument must not be null.");
}
this.properties.put(key, value);
return this;
} | class class_name[name] begin[{]
method[property, return_type[type[ParameterBuilder]], modifier[public], parameter[key, value]] begin[{]
if[binary_operation[member[.key], ==, literal[null]]] begin[{]
ThrowStatement(expression=ClassCreator(arguments=[Literal(postfix_operators=[], pref... | Keyword[public] identifier[ParameterBuilder] operator[<] identifier[T] operator[>] identifier[property] operator[SEP] identifier[String] identifier[key] , identifier[Object] identifier[value] operator[SEP] {
Keyword[if] operator[SEP] identifier[key] operator[==] Other[null] operator[SEP] {
Keyword[th... |
@Override
public int[] sort(final int col, final boolean ascending) {
if (!isSortable(col)) {
throw new IllegalStateException("Attempted to sort on column "
+ col + ", which is not sortable");
}
// Obtains the list of top level nodes, sorts them & re-add them in order
TableTreeNode root = getRootNode(... | class class_name[name] begin[{]
method[sort, return_type[type[int]], modifier[public], parameter[col, ascending]] begin[{]
if[call[.isSortable, parameter[member[.col]]]] begin[{]
ThrowStatement(expression=ClassCreator(arguments=[BinaryOperation(operandl=BinaryOperation(operandl=Lite... | annotation[@] identifier[Override] Keyword[public] Keyword[int] operator[SEP] operator[SEP] identifier[sort] operator[SEP] Keyword[final] Keyword[int] identifier[col] , Keyword[final] Keyword[boolean] identifier[ascending] operator[SEP] {
Keyword[if] operator[SEP] operator[!] identifier[isSortable] operator[SEP... |
@CheckForNull
public ActiveRule getActiveRule(Rule rule) {
return getActiveRule(rule.getRepositoryKey(), rule.getKey());
} | class class_name[name] begin[{]
method[getActiveRule, return_type[type[ActiveRule]], modifier[public], parameter[rule]] begin[{]
return[call[.getActiveRule, parameter[call[rule.getRepositoryKey, parameter[]], call[rule.getKey, parameter[]]]]]
end[}]
END[}] | annotation[@] identifier[CheckForNull] Keyword[public] identifier[ActiveRule] identifier[getActiveRule] operator[SEP] identifier[Rule] identifier[rule] operator[SEP] {
Keyword[return] identifier[getActiveRule] operator[SEP] identifier[rule] operator[SEP] identifier[getRepositoryKey] operator[SEP] operator[SEP] ,... |
@Override
protected PreparedStatementCreator getPreparedStatementCreator(String sql, SqlParameterSource parameterSource) {
return new NamedPreparedStatementCreator(sql, parameterSource);
} | class class_name[name] begin[{]
method[getPreparedStatementCreator, return_type[type[PreparedStatementCreator]], modifier[protected], parameter[sql, parameterSource]] begin[{]
return[ClassCreator(arguments=[MemberReference(member=sql, postfix_operators=[], prefix_operators=[], qualifier=, selectors=[])... | annotation[@] identifier[Override] Keyword[protected] identifier[PreparedStatementCreator] identifier[getPreparedStatementCreator] operator[SEP] identifier[String] identifier[sql] , identifier[SqlParameterSource] identifier[parameterSource] operator[SEP] {
Keyword[return] Keyword[new] identifier[NamedPreparedSt... |
public void enable(String jobId, JobEnableOptions jobEnableOptions) {
enableWithServiceResponseAsync(jobId, jobEnableOptions).toBlocking().single().body();
} | class class_name[name] begin[{]
method[enable, return_type[void], modifier[public], parameter[jobId, jobEnableOptions]] begin[{]
call[.enableWithServiceResponseAsync, parameter[member[.jobId], member[.jobEnableOptions]]]
end[}]
END[}] | Keyword[public] Keyword[void] identifier[enable] operator[SEP] identifier[String] identifier[jobId] , identifier[JobEnableOptions] identifier[jobEnableOptions] operator[SEP] {
identifier[enableWithServiceResponseAsync] operator[SEP] identifier[jobId] , identifier[jobEnableOptions] operator[SEP] operator[SEP] i... |
private Double getRangeCost(ProjectCalendar projectCalendar, TimescaleUnits rangeUnits, DateRange range, List<TimephasedCost> assignments, int startIndex)
{
Double result;
switch (rangeUnits)
{
case MINUTES:
case HOURS:
{
result = getRangeCostSubDay(projectCa... | class class_name[name] begin[{]
method[getRangeCost, return_type[type[Double]], modifier[private], parameter[projectCalendar, rangeUnits, range, assignments, startIndex]] begin[{]
local_variable[type[Double], result]
SwitchStatement(cases=[SwitchStatementCase(case=['MINUTES', 'HOURS'], statemen... | Keyword[private] identifier[Double] identifier[getRangeCost] operator[SEP] identifier[ProjectCalendar] identifier[projectCalendar] , identifier[TimescaleUnits] identifier[rangeUnits] , identifier[DateRange] identifier[range] , identifier[List] operator[<] identifier[TimephasedCost] operator[>] identifier[assignments... |
public static Set<Policy> policies(Config config) {
BasicSettings settings = new BasicSettings(config);
return settings.admission().stream().map(admission ->
new SegmentedLruPolicy(admission, config)
).collect(toSet());
} | class class_name[name] begin[{]
method[policies, return_type[type[Set]], modifier[public static], parameter[config]] begin[{]
local_variable[type[BasicSettings], settings]
return[call[settings.admission, parameter[]]]
end[}]
END[}] | Keyword[public] Keyword[static] identifier[Set] operator[<] identifier[Policy] operator[>] identifier[policies] operator[SEP] identifier[Config] identifier[config] operator[SEP] {
identifier[BasicSettings] identifier[settings] operator[=] Keyword[new] identifier[BasicSettings] operator[SEP] identifier[config] op... |
@Override
public com.liferay.commerce.model.CommerceOrderNote getCommerceOrderNote(
long commerceOrderNoteId)
throws com.liferay.portal.kernel.exception.PortalException {
return _commerceOrderNoteLocalService.getCommerceOrderNote(commerceOrderNoteId);
} | class class_name[name] begin[{]
method[getCommerceOrderNote, return_type[type[com]], modifier[public], parameter[commerceOrderNoteId]] begin[{]
return[call[_commerceOrderNoteLocalService.getCommerceOrderNote, parameter[member[.commerceOrderNoteId]]]]
end[}]
END[}] | annotation[@] identifier[Override] Keyword[public] identifier[com] operator[SEP] identifier[liferay] operator[SEP] identifier[commerce] operator[SEP] identifier[model] operator[SEP] identifier[CommerceOrderNote] identifier[getCommerceOrderNote] operator[SEP] Keyword[long] identifier[commerceOrderNoteId] operator[SEP] K... |
protected void addMultiTenantFilterIfNecessary(
HibernatePersistentEntity entity, PersistentClass persistentClass,
InFlightMetadataCollector mappings, String sessionFactoryBeanName) {
if (entity.isMultiTenant()) {
TenantId tenantId = entity.getTenantId();
if (ten... | class class_name[name] begin[{]
method[addMultiTenantFilterIfNecessary, return_type[void], modifier[protected], parameter[entity, persistentClass, mappings, sessionFactoryBeanName]] begin[{]
if[call[entity.isMultiTenant, parameter[]]] begin[{]
local_variable[type[TenantId], tenantId... | Keyword[protected] Keyword[void] identifier[addMultiTenantFilterIfNecessary] operator[SEP] identifier[HibernatePersistentEntity] identifier[entity] , identifier[PersistentClass] identifier[persistentClass] , identifier[InFlightMetadataCollector] identifier[mappings] , identifier[String] identifier[sessionFactoryBean... |
public static <T> T runWithSleepThenReturnValueThrowOnInterrupt(long milliseconds, ReturningRunnable<T> runnable) {
Assert.isTrue(milliseconds > 0, "Milliseconds [%d] must be greater than 0", milliseconds);
T returnValue = runnable.run();
if (!ThreadUtils.sleep(milliseconds, 0)) {
throw new SleepDe... | class class_name[name] begin[{]
method[runWithSleepThenReturnValueThrowOnInterrupt, return_type[type[T]], modifier[public static], parameter[milliseconds, runnable]] begin[{]
call[Assert.isTrue, parameter[binary_operation[member[.milliseconds], >, literal[0]], literal["Milliseconds [%d] must be... | Keyword[public] Keyword[static] operator[<] identifier[T] operator[>] identifier[T] identifier[runWithSleepThenReturnValueThrowOnInterrupt] operator[SEP] Keyword[long] identifier[milliseconds] , identifier[ReturningRunnable] operator[<] identifier[T] operator[>] identifier[runnable] operator[SEP] {
identifier[A... |
public void seekToRecord(long recordNumber) throws IOException {
if (currentRecordNumber == recordNumber)
return;
long skip;
if (recordNumber < fileIndex.getStartingRecordNumber()) {
if (currentRecordNumber < recordNumber)
skip = recordNumber - currentReco... | class class_name[name] begin[{]
method[seekToRecord, return_type[void], modifier[public], parameter[recordNumber]] begin[{]
if[binary_operation[member[.currentRecordNumber], ==, member[.recordNumber]]] begin[{]
return[None]
else begin[{]
None
end[}]
local_variable[type[l... | Keyword[public] Keyword[void] identifier[seekToRecord] operator[SEP] Keyword[long] identifier[recordNumber] operator[SEP] Keyword[throws] identifier[IOException] {
Keyword[if] operator[SEP] identifier[currentRecordNumber] operator[==] identifier[recordNumber] operator[SEP] Keyword[return] operator[SEP] Keyword[l... |
public Deferred<byte[]> resolveTags(final TSDB tsdb,
final Set<String> literals) {
final Config config = tsdb.getConfig();
/**
* Allows the filter to avoid killing the entire query when we can't resolve
* a tag value to a UID.
*/
class TagVErrback implements Callback<byte[], Excep... | class class_name[name] begin[{]
method[resolveTags, return_type[type[Deferred]], modifier[public], parameter[tsdb, literals]] begin[{]
local_variable[type[Config], config]
class class_name[TagVErrback] begin[{]
method[call, return_type[type[byte]], modifier[publ... | Keyword[public] identifier[Deferred] operator[<] Keyword[byte] operator[SEP] operator[SEP] operator[>] identifier[resolveTags] operator[SEP] Keyword[final] identifier[TSDB] identifier[tsdb] , Keyword[final] identifier[Set] operator[<] identifier[String] operator[>] identifier[literals] operator[SEP] {
Keyword[f... |
@Override
public boolean eIsSet(int featureID) {
switch (featureID) {
case AfplibPackage.BCP__RS_NAME:
return RS_NAME_EDEFAULT == null ? rsName != null : !RS_NAME_EDEFAULT.equals(rsName);
case AfplibPackage.BCP__TRIPLETS:
return triplets != null && !triplets.isEmpty();
}
return super.eIsSet(feature... | class class_name[name] begin[{]
method[eIsSet, return_type[type[boolean]], modifier[public], parameter[featureID]] begin[{]
SwitchStatement(cases=[SwitchStatementCase(case=[MemberReference(member=BCP__RS_NAME, postfix_operators=[], prefix_operators=[], qualifier=AfplibPackage, selectors=[])], statement... | annotation[@] identifier[Override] Keyword[public] Keyword[boolean] identifier[eIsSet] operator[SEP] Keyword[int] identifier[featureID] operator[SEP] {
Keyword[switch] operator[SEP] identifier[featureID] operator[SEP] {
Keyword[case] identifier[AfplibPackage] operator[SEP] identifier[BCP__RS_NAME] ope... |
public void importFromMixed(Reader r, boolean deduceFromSeeds) {
BufferedReader reader = new BufferedReader(r);
String s;
Iterator<String> iter =
new RegexLineIterator(
new LineReadingIterator(reader),
RegexLineIterator.COMMENT_LINE,
... | class class_name[name] begin[{]
method[importFromMixed, return_type[void], modifier[public], parameter[r, deduceFromSeeds]] begin[{]
local_variable[type[BufferedReader], reader]
local_variable[type[String], s]
local_variable[type[Iterator], iter]
while[call[iter.hasNext,... | Keyword[public] Keyword[void] identifier[importFromMixed] operator[SEP] identifier[Reader] identifier[r] , Keyword[boolean] identifier[deduceFromSeeds] operator[SEP] {
identifier[BufferedReader] identifier[reader] operator[=] Keyword[new] identifier[BufferedReader] operator[SEP] identifier[r] operator[SEP] oper... |
@Override
public Collection<FacetRank> calculateRank(@NotNull Collection<Facet> facets) {
return rankingAlgorithm.calculate(facets);
} | class class_name[name] begin[{]
method[calculateRank, return_type[type[Collection]], modifier[public], parameter[facets]] begin[{]
return[call[rankingAlgorithm.calculate, parameter[member[.facets]]]]
end[}]
END[}] | annotation[@] identifier[Override] Keyword[public] identifier[Collection] operator[<] identifier[FacetRank] operator[>] identifier[calculateRank] operator[SEP] annotation[@] identifier[NotNull] identifier[Collection] operator[<] identifier[Facet] operator[>] identifier[facets] operator[SEP] {
Keyword[return] ide... |
public static <T extends XMLObject> void addAttributeValue(Attribute attribute, T value) {
attribute.getAttributeValues().add(value);
} | class class_name[name] begin[{]
method[addAttributeValue, return_type[void], modifier[public static], parameter[attribute, value]] begin[{]
call[attribute.getAttributeValues, parameter[]]
end[}]
END[}] | Keyword[public] Keyword[static] operator[<] identifier[T] Keyword[extends] identifier[XMLObject] operator[>] Keyword[void] identifier[addAttributeValue] operator[SEP] identifier[Attribute] identifier[attribute] , identifier[T] identifier[value] operator[SEP] {
identifier[attribute] operator[SEP] identifier[getA... |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.