code
stringlengths 63
466k
| code_sememe
stringlengths 141
3.79M
| token_type
stringlengths 274
1.23M
|
|---|---|---|
public static Config getConfig(@Nonnull final URI configLocation, @Nullable final String configName)
{
final ConfigFactory configFactory = new ConfigFactory(configLocation, configName);
return new Config(configFactory.load());
}
|
class class_name[name] begin[{]
method[getConfig, return_type[type[Config]], modifier[public static], parameter[configLocation, configName]] begin[{]
local_variable[type[ConfigFactory], configFactory]
return[ClassCreator(arguments=[MethodInvocation(arguments=[], member=load, postfix_operators=[], prefix_operators=[], qualifier=configFactory, selectors=[], type_arguments=None)], body=None, constructor_type_arguments=None, postfix_operators=[], prefix_operators=[], qualifier=None, selectors=[], type=ReferenceType(arguments=None, dimensions=None, name=Config, sub_type=None))]
end[}]
END[}]
|
Keyword[public] Keyword[static] identifier[Config] identifier[getConfig] operator[SEP] annotation[@] identifier[Nonnull] Keyword[final] identifier[URI] identifier[configLocation] , annotation[@] identifier[Nullable] Keyword[final] identifier[String] identifier[configName] operator[SEP] {
Keyword[final] identifier[ConfigFactory] identifier[configFactory] operator[=] Keyword[new] identifier[ConfigFactory] operator[SEP] identifier[configLocation] , identifier[configName] operator[SEP] operator[SEP] Keyword[return] Keyword[new] identifier[Config] operator[SEP] identifier[configFactory] operator[SEP] identifier[load] operator[SEP] operator[SEP] operator[SEP] operator[SEP]
}
|
public static CommerceOrder fetchByUuid_C_Last(String uuid, long companyId,
OrderByComparator<CommerceOrder> orderByComparator) {
return getPersistence()
.fetchByUuid_C_Last(uuid, companyId, orderByComparator);
}
|
class class_name[name] begin[{]
method[fetchByUuid_C_Last, return_type[type[CommerceOrder]], modifier[public static], parameter[uuid, companyId, orderByComparator]] begin[{]
return[call[.getPersistence, parameter[]]]
end[}]
END[}]
|
Keyword[public] Keyword[static] identifier[CommerceOrder] identifier[fetchByUuid_C_Last] operator[SEP] identifier[String] identifier[uuid] , Keyword[long] identifier[companyId] , identifier[OrderByComparator] operator[<] identifier[CommerceOrder] operator[>] identifier[orderByComparator] operator[SEP] {
Keyword[return] identifier[getPersistence] operator[SEP] operator[SEP] operator[SEP] identifier[fetchByUuid_C_Last] operator[SEP] identifier[uuid] , identifier[companyId] , identifier[orderByComparator] operator[SEP] operator[SEP]
}
|
@Override
public String cipherSuite()
{
if (! (_s instanceof SSLSocket)) {
return super.cipherSuite();
}
SSLSocket sslSocket = (SSLSocket) _s;
SSLSession sslSession = sslSocket.getSession();
if (sslSession != null) {
return sslSession.getCipherSuite();
}
else {
return null;
}
}
|
class class_name[name] begin[{]
method[cipherSuite, return_type[type[String]], modifier[public], parameter[]] begin[{]
if[binary_operation[member[._s], instanceof, type[SSLSocket]]] begin[{]
return[SuperMethodInvocation(arguments=[], member=cipherSuite, postfix_operators=[], prefix_operators=[], qualifier=None, selectors=[], type_arguments=None)]
else begin[{]
None
end[}]
local_variable[type[SSLSocket], sslSocket]
local_variable[type[SSLSession], sslSession]
if[binary_operation[member[.sslSession], !=, literal[null]]] begin[{]
return[call[sslSession.getCipherSuite, parameter[]]]
else begin[{]
return[literal[null]]
end[}]
end[}]
END[}]
|
annotation[@] identifier[Override] Keyword[public] identifier[String] identifier[cipherSuite] operator[SEP] operator[SEP] {
Keyword[if] operator[SEP] operator[!] operator[SEP] identifier[_s] Keyword[instanceof] identifier[SSLSocket] operator[SEP] operator[SEP] {
Keyword[return] Keyword[super] operator[SEP] identifier[cipherSuite] operator[SEP] operator[SEP] operator[SEP]
}
identifier[SSLSocket] identifier[sslSocket] operator[=] operator[SEP] identifier[SSLSocket] operator[SEP] identifier[_s] operator[SEP] identifier[SSLSession] identifier[sslSession] operator[=] identifier[sslSocket] operator[SEP] identifier[getSession] operator[SEP] operator[SEP] operator[SEP] Keyword[if] operator[SEP] identifier[sslSession] operator[!=] Other[null] operator[SEP] {
Keyword[return] identifier[sslSession] operator[SEP] identifier[getCipherSuite] operator[SEP] operator[SEP] operator[SEP]
}
Keyword[else] {
Keyword[return] Other[null] operator[SEP]
}
}
|
public final String prn(final Map<String, Object> pRqVs,
final BigDecimal pVal) {
return this.srvNumberToString.print(pVal.toString(),
(String) pRqVs.get("decSepv"), //user's preferences
(String) pRqVs.get("decGrSepv"),
(Integer) pRqVs.get("priceDp"),
(Integer) pRqVs.get("digInGr"));
}
|
class class_name[name] begin[{]
method[prn, return_type[type[String]], modifier[final public], parameter[pRqVs, pVal]] begin[{]
return[THIS[member[None.srvNumberToString]call[None.print, parameter[call[pVal.toString, parameter[]], Cast(expression=MethodInvocation(arguments=[Literal(postfix_operators=[], prefix_operators=[], qualifier=None, selectors=[], value="decSepv")], member=get, postfix_operators=[], prefix_operators=[], qualifier=pRqVs, selectors=[], type_arguments=None), type=ReferenceType(arguments=None, dimensions=[], name=String, sub_type=None)), Cast(expression=MethodInvocation(arguments=[Literal(postfix_operators=[], prefix_operators=[], qualifier=None, selectors=[], value="decGrSepv")], member=get, postfix_operators=[], prefix_operators=[], qualifier=pRqVs, selectors=[], type_arguments=None), type=ReferenceType(arguments=None, dimensions=[], name=String, sub_type=None)), Cast(expression=MethodInvocation(arguments=[Literal(postfix_operators=[], prefix_operators=[], qualifier=None, selectors=[], value="priceDp")], member=get, postfix_operators=[], prefix_operators=[], qualifier=pRqVs, selectors=[], type_arguments=None), type=ReferenceType(arguments=None, dimensions=[], name=Integer, sub_type=None)), Cast(expression=MethodInvocation(arguments=[Literal(postfix_operators=[], prefix_operators=[], qualifier=None, selectors=[], value="digInGr")], member=get, postfix_operators=[], prefix_operators=[], qualifier=pRqVs, selectors=[], type_arguments=None), type=ReferenceType(arguments=None, dimensions=[], name=Integer, sub_type=None))]]]]
end[}]
END[}]
|
Keyword[public] Keyword[final] identifier[String] identifier[prn] operator[SEP] Keyword[final] identifier[Map] operator[<] identifier[String] , identifier[Object] operator[>] identifier[pRqVs] , Keyword[final] identifier[BigDecimal] identifier[pVal] operator[SEP] {
Keyword[return] Keyword[this] operator[SEP] identifier[srvNumberToString] operator[SEP] identifier[print] operator[SEP] identifier[pVal] operator[SEP] identifier[toString] operator[SEP] operator[SEP] , operator[SEP] identifier[String] operator[SEP] identifier[pRqVs] operator[SEP] identifier[get] operator[SEP] literal[String] operator[SEP] , operator[SEP] identifier[String] operator[SEP] identifier[pRqVs] operator[SEP] identifier[get] operator[SEP] literal[String] operator[SEP] , operator[SEP] identifier[Integer] operator[SEP] identifier[pRqVs] operator[SEP] identifier[get] operator[SEP] literal[String] operator[SEP] , operator[SEP] identifier[Integer] operator[SEP] identifier[pRqVs] operator[SEP] identifier[get] operator[SEP] literal[String] operator[SEP] operator[SEP] operator[SEP]
}
|
public void runBenchmark() throws Exception {
System.out.print(HORIZONTAL_RULE);
System.out.println(" Setup & Initialization");
System.out.println(HORIZONTAL_RULE);
// connect to one or more servers, loop until success
connect(client, config.servers);
for (long i = 0; i < config.tuples; i++) {
ClientResponse response = client.callProcedure("Init", i, i);
if (response.getStatus() != ClientResponse.SUCCESS) {
System.exit(-1);
}
}
System.out.print("\n\n" + HORIZONTAL_RULE);
System.out.println(" Starting Benchmark");
System.out.println(HORIZONTAL_RULE);
System.out.println("\nWarming up...");
final long warmupEndTime = System.currentTimeMillis() + (1000l * config.warmup);
while (warmupEndTime > System.currentTimeMillis()) {
increment();
}
// reset counters before the real benchmark starts post-warmup
incrementCount.set(0);
lastPeriod.set(0);
failureCount.set(0);
lastStatsReportTS = System.currentTimeMillis();
// print periodic statistics to the console
benchmarkStartTS = System.currentTimeMillis();
TimerTask statsPrinting = new TimerTask() {
@Override
public void run() { printStatistics(); }
};
Timer timer = new Timer();
timer.scheduleAtFixedRate(statsPrinting,
config.displayinterval * 1000,
config.displayinterval * 1000);
// Run the benchmark loop for the requested duration
// The throughput may be throttled depending on client configuration
System.out.println("\nRunning benchmark...");
final long benchmarkEndTime = System.currentTimeMillis() + (1000l * config.duration);
while (benchmarkEndTime > System.currentTimeMillis()) {
increment();
}
// cancel periodic stats printing
timer.cancel();
// block until all outstanding txns return
client.drain();
// close down the client connections
client.close();
}
|
class class_name[name] begin[{]
method[runBenchmark, return_type[void], modifier[public], parameter[]] begin[{]
call[System.out.print, parameter[member[.HORIZONTAL_RULE]]]
call[System.out.println, parameter[literal[" Setup & Initialization"]]]
call[System.out.println, parameter[member[.HORIZONTAL_RULE]]]
call[.connect, parameter[member[.client], member[config.servers]]]
ForStatement(body=BlockStatement(label=None, statements=[LocalVariableDeclaration(annotations=[], declarators=[VariableDeclarator(dimensions=[], initializer=MethodInvocation(arguments=[Literal(postfix_operators=[], prefix_operators=[], qualifier=None, selectors=[], value="Init"), MemberReference(member=i, postfix_operators=[], prefix_operators=[], qualifier=, selectors=[]), MemberReference(member=i, postfix_operators=[], prefix_operators=[], qualifier=, selectors=[])], member=callProcedure, postfix_operators=[], prefix_operators=[], qualifier=client, selectors=[], type_arguments=None), name=response)], modifiers=set(), type=ReferenceType(arguments=None, dimensions=[], name=ClientResponse, sub_type=None)), IfStatement(condition=BinaryOperation(operandl=MethodInvocation(arguments=[], member=getStatus, postfix_operators=[], prefix_operators=[], qualifier=response, selectors=[], type_arguments=None), operandr=MemberReference(member=SUCCESS, postfix_operators=[], prefix_operators=[], qualifier=ClientResponse, selectors=[]), operator=!=), else_statement=None, label=None, then_statement=BlockStatement(label=None, statements=[StatementExpression(expression=MethodInvocation(arguments=[Literal(postfix_operators=[], prefix_operators=['-'], qualifier=None, selectors=[], value=1)], member=exit, postfix_operators=[], prefix_operators=[], qualifier=System, selectors=[], type_arguments=None), label=None)]))]), control=ForControl(condition=BinaryOperation(operandl=MemberReference(member=i, postfix_operators=[], prefix_operators=[], qualifier=, selectors=[]), operandr=MemberReference(member=tuples, postfix_operators=[], prefix_operators=[], qualifier=config, selectors=[]), operator=<), init=VariableDeclaration(annotations=[], declarators=[VariableDeclarator(dimensions=None, initializer=Literal(postfix_operators=[], prefix_operators=[], qualifier=None, selectors=[], value=0), name=i)], modifiers=set(), type=BasicType(dimensions=[], name=long)), update=[MemberReference(member=i, postfix_operators=['++'], prefix_operators=[], qualifier=, selectors=[])]), label=None)
call[System.out.print, parameter[binary_operation[literal["\n\n"], +, member[.HORIZONTAL_RULE]]]]
call[System.out.println, parameter[literal[" Starting Benchmark"]]]
call[System.out.println, parameter[member[.HORIZONTAL_RULE]]]
call[System.out.println, parameter[literal["\nWarming up..."]]]
local_variable[type[long], warmupEndTime]
while[binary_operation[member[.warmupEndTime], >, call[System.currentTimeMillis, parameter[]]]] begin[{]
call[.increment, parameter[]]
end[}]
call[incrementCount.set, parameter[literal[0]]]
call[lastPeriod.set, parameter[literal[0]]]
call[failureCount.set, parameter[literal[0]]]
assign[member[.lastStatsReportTS], call[System.currentTimeMillis, parameter[]]]
assign[member[.benchmarkStartTS], call[System.currentTimeMillis, parameter[]]]
local_variable[type[TimerTask], statsPrinting]
local_variable[type[Timer], timer]
call[timer.scheduleAtFixedRate, parameter[member[.statsPrinting], binary_operation[member[config.displayinterval], *, literal[1000]], binary_operation[member[config.displayinterval], *, literal[1000]]]]
call[System.out.println, parameter[literal["\nRunning benchmark..."]]]
local_variable[type[long], benchmarkEndTime]
while[binary_operation[member[.benchmarkEndTime], >, call[System.currentTimeMillis, parameter[]]]] begin[{]
call[.increment, parameter[]]
end[}]
call[timer.cancel, parameter[]]
call[client.drain, parameter[]]
call[client.close, parameter[]]
end[}]
END[}]
|
Keyword[public] Keyword[void] identifier[runBenchmark] operator[SEP] operator[SEP] Keyword[throws] identifier[Exception] {
identifier[System] operator[SEP] identifier[out] operator[SEP] identifier[print] operator[SEP] identifier[HORIZONTAL_RULE] operator[SEP] operator[SEP] identifier[System] operator[SEP] identifier[out] operator[SEP] identifier[println] operator[SEP] literal[String] operator[SEP] operator[SEP] identifier[System] operator[SEP] identifier[out] operator[SEP] identifier[println] operator[SEP] identifier[HORIZONTAL_RULE] operator[SEP] operator[SEP] identifier[connect] operator[SEP] identifier[client] , identifier[config] operator[SEP] identifier[servers] operator[SEP] operator[SEP] Keyword[for] operator[SEP] Keyword[long] identifier[i] operator[=] Other[0] operator[SEP] identifier[i] operator[<] identifier[config] operator[SEP] identifier[tuples] operator[SEP] identifier[i] operator[++] operator[SEP] {
identifier[ClientResponse] identifier[response] operator[=] identifier[client] operator[SEP] identifier[callProcedure] operator[SEP] literal[String] , identifier[i] , identifier[i] operator[SEP] operator[SEP] Keyword[if] operator[SEP] identifier[response] operator[SEP] identifier[getStatus] operator[SEP] operator[SEP] operator[!=] identifier[ClientResponse] operator[SEP] identifier[SUCCESS] operator[SEP] {
identifier[System] operator[SEP] identifier[exit] operator[SEP] operator[-] Other[1] operator[SEP] operator[SEP]
}
}
identifier[System] operator[SEP] identifier[out] operator[SEP] identifier[print] operator[SEP] literal[String] operator[+] identifier[HORIZONTAL_RULE] operator[SEP] operator[SEP] identifier[System] operator[SEP] identifier[out] operator[SEP] identifier[println] operator[SEP] literal[String] operator[SEP] operator[SEP] identifier[System] operator[SEP] identifier[out] operator[SEP] identifier[println] operator[SEP] identifier[HORIZONTAL_RULE] operator[SEP] operator[SEP] identifier[System] operator[SEP] identifier[out] operator[SEP] identifier[println] operator[SEP] literal[String] operator[SEP] operator[SEP] Keyword[final] Keyword[long] identifier[warmupEndTime] operator[=] identifier[System] operator[SEP] identifier[currentTimeMillis] operator[SEP] operator[SEP] operator[+] operator[SEP] Other[1000l] operator[*] identifier[config] operator[SEP] identifier[warmup] operator[SEP] operator[SEP] Keyword[while] operator[SEP] identifier[warmupEndTime] operator[>] identifier[System] operator[SEP] identifier[currentTimeMillis] operator[SEP] operator[SEP] operator[SEP] {
identifier[increment] operator[SEP] operator[SEP] operator[SEP]
}
identifier[incrementCount] operator[SEP] identifier[set] operator[SEP] Other[0] operator[SEP] operator[SEP] identifier[lastPeriod] operator[SEP] identifier[set] operator[SEP] Other[0] operator[SEP] operator[SEP] identifier[failureCount] operator[SEP] identifier[set] operator[SEP] Other[0] operator[SEP] operator[SEP] identifier[lastStatsReportTS] operator[=] identifier[System] operator[SEP] identifier[currentTimeMillis] operator[SEP] operator[SEP] operator[SEP] identifier[benchmarkStartTS] operator[=] identifier[System] operator[SEP] identifier[currentTimeMillis] operator[SEP] operator[SEP] operator[SEP] identifier[TimerTask] identifier[statsPrinting] operator[=] Keyword[new] identifier[TimerTask] operator[SEP] operator[SEP] {
annotation[@] identifier[Override] Keyword[public] Keyword[void] identifier[run] operator[SEP] operator[SEP] {
identifier[printStatistics] operator[SEP] operator[SEP] operator[SEP]
}
} operator[SEP] identifier[Timer] identifier[timer] operator[=] Keyword[new] identifier[Timer] operator[SEP] operator[SEP] operator[SEP] identifier[timer] operator[SEP] identifier[scheduleAtFixedRate] operator[SEP] identifier[statsPrinting] , identifier[config] operator[SEP] identifier[displayinterval] operator[*] Other[1000] , identifier[config] operator[SEP] identifier[displayinterval] operator[*] Other[1000] operator[SEP] operator[SEP] identifier[System] operator[SEP] identifier[out] operator[SEP] identifier[println] operator[SEP] literal[String] operator[SEP] operator[SEP] Keyword[final] Keyword[long] identifier[benchmarkEndTime] operator[=] identifier[System] operator[SEP] identifier[currentTimeMillis] operator[SEP] operator[SEP] operator[+] operator[SEP] Other[1000l] operator[*] identifier[config] operator[SEP] identifier[duration] operator[SEP] operator[SEP] Keyword[while] operator[SEP] identifier[benchmarkEndTime] operator[>] identifier[System] operator[SEP] identifier[currentTimeMillis] operator[SEP] operator[SEP] operator[SEP] {
identifier[increment] operator[SEP] operator[SEP] operator[SEP]
}
identifier[timer] operator[SEP] identifier[cancel] operator[SEP] operator[SEP] operator[SEP] identifier[client] operator[SEP] identifier[drain] operator[SEP] operator[SEP] operator[SEP] identifier[client] operator[SEP] identifier[close] operator[SEP] operator[SEP] operator[SEP]
}
|
protected void buildAndShowDialog(@Nullable Bundle savedInstanceState) {
final AlertDialog.Builder dialogBuilder = new AlertDialog.Builder(this);
final String title = dialogConfiguration.title();
if (title != null) {
dialogBuilder.setTitle(title);
}
final int iconResourceId = dialogConfiguration.resIcon();
if (iconResourceId != ACRAConstants.DEFAULT_RES_VALUE) {
dialogBuilder.setIcon(iconResourceId);
}
dialogBuilder.setView(buildCustomView(savedInstanceState))
.setPositiveButton(dialogConfiguration.positiveButtonText(), this)
.setNegativeButton(dialogConfiguration.negativeButtonText(), this);
mDialog = dialogBuilder.create();
mDialog.setCanceledOnTouchOutside(false);
mDialog.show();
}
|
class class_name[name] begin[{]
method[buildAndShowDialog, return_type[void], modifier[protected], parameter[savedInstanceState]] begin[{]
local_variable[type[AlertDialog], dialogBuilder]
local_variable[type[String], title]
if[binary_operation[member[.title], !=, literal[null]]] begin[{]
call[dialogBuilder.setTitle, parameter[member[.title]]]
else begin[{]
None
end[}]
local_variable[type[int], iconResourceId]
if[binary_operation[member[.iconResourceId], !=, member[ACRAConstants.DEFAULT_RES_VALUE]]] begin[{]
call[dialogBuilder.setIcon, parameter[member[.iconResourceId]]]
else begin[{]
None
end[}]
call[dialogBuilder.setView, parameter[call[.buildCustomView, parameter[member[.savedInstanceState]]]]]
assign[member[.mDialog], call[dialogBuilder.create, parameter[]]]
call[mDialog.setCanceledOnTouchOutside, parameter[literal[false]]]
call[mDialog.show, parameter[]]
end[}]
END[}]
|
Keyword[protected] Keyword[void] identifier[buildAndShowDialog] operator[SEP] annotation[@] identifier[Nullable] identifier[Bundle] identifier[savedInstanceState] operator[SEP] {
Keyword[final] identifier[AlertDialog] operator[SEP] identifier[Builder] identifier[dialogBuilder] operator[=] Keyword[new] identifier[AlertDialog] operator[SEP] identifier[Builder] operator[SEP] Keyword[this] operator[SEP] operator[SEP] Keyword[final] identifier[String] identifier[title] operator[=] identifier[dialogConfiguration] operator[SEP] identifier[title] operator[SEP] operator[SEP] operator[SEP] Keyword[if] operator[SEP] identifier[title] operator[!=] Other[null] operator[SEP] {
identifier[dialogBuilder] operator[SEP] identifier[setTitle] operator[SEP] identifier[title] operator[SEP] operator[SEP]
}
Keyword[final] Keyword[int] identifier[iconResourceId] operator[=] identifier[dialogConfiguration] operator[SEP] identifier[resIcon] operator[SEP] operator[SEP] operator[SEP] Keyword[if] operator[SEP] identifier[iconResourceId] operator[!=] identifier[ACRAConstants] operator[SEP] identifier[DEFAULT_RES_VALUE] operator[SEP] {
identifier[dialogBuilder] operator[SEP] identifier[setIcon] operator[SEP] identifier[iconResourceId] operator[SEP] operator[SEP]
}
identifier[dialogBuilder] operator[SEP] identifier[setView] operator[SEP] identifier[buildCustomView] operator[SEP] identifier[savedInstanceState] operator[SEP] operator[SEP] operator[SEP] identifier[setPositiveButton] operator[SEP] identifier[dialogConfiguration] operator[SEP] identifier[positiveButtonText] operator[SEP] operator[SEP] , Keyword[this] operator[SEP] operator[SEP] identifier[setNegativeButton] operator[SEP] identifier[dialogConfiguration] operator[SEP] identifier[negativeButtonText] operator[SEP] operator[SEP] , Keyword[this] operator[SEP] operator[SEP] identifier[mDialog] operator[=] identifier[dialogBuilder] operator[SEP] identifier[create] operator[SEP] operator[SEP] operator[SEP] identifier[mDialog] operator[SEP] identifier[setCanceledOnTouchOutside] operator[SEP] literal[boolean] operator[SEP] operator[SEP] identifier[mDialog] operator[SEP] identifier[show] operator[SEP] operator[SEP] operator[SEP]
}
|
public ListActiveCoursesInAccountOptions searchTerm(String searchTerm) {
if(searchTerm == null || searchTerm.length() < 3) {
throw new IllegalArgumentException("Search term must be at least 3 characters");
}
addSingleItem("search_term", searchTerm);
return this;
}
|
class class_name[name] begin[{]
method[searchTerm, return_type[type[ListActiveCoursesInAccountOptions]], modifier[public], parameter[searchTerm]] begin[{]
if[binary_operation[binary_operation[member[.searchTerm], ==, literal[null]], ||, binary_operation[call[searchTerm.length, parameter[]], <, literal[3]]]] begin[{]
ThrowStatement(expression=ClassCreator(arguments=[Literal(postfix_operators=[], prefix_operators=[], qualifier=None, selectors=[], value="Search term must be at least 3 characters")], body=None, constructor_type_arguments=None, postfix_operators=[], prefix_operators=[], qualifier=None, selectors=[], type=ReferenceType(arguments=None, dimensions=None, name=IllegalArgumentException, sub_type=None)), label=None)
else begin[{]
None
end[}]
call[.addSingleItem, parameter[literal["search_term"], member[.searchTerm]]]
return[THIS[]]
end[}]
END[}]
|
Keyword[public] identifier[ListActiveCoursesInAccountOptions] identifier[searchTerm] operator[SEP] identifier[String] identifier[searchTerm] operator[SEP] {
Keyword[if] operator[SEP] identifier[searchTerm] operator[==] Other[null] operator[||] identifier[searchTerm] operator[SEP] identifier[length] operator[SEP] operator[SEP] operator[<] Other[3] operator[SEP] {
Keyword[throw] Keyword[new] identifier[IllegalArgumentException] operator[SEP] literal[String] operator[SEP] operator[SEP]
}
identifier[addSingleItem] operator[SEP] literal[String] , identifier[searchTerm] operator[SEP] operator[SEP] Keyword[return] Keyword[this] operator[SEP]
}
|
public static String serializePropertyName(String name) {
StringBuilder stringBuilder = new StringBuilder();
for (char ch : name.toCharArray()) {
if (Character.isLetterOrDigit(ch) || HYPHEN == ch || DOT == ch) {
stringBuilder.append(ch);
} else {
stringBuilder.append(UNDERSCORE + Integer.toString((int) ch) + UNDERSCORE);
}
}
return stringBuilder.toString();
}
|
class class_name[name] begin[{]
method[serializePropertyName, return_type[type[String]], modifier[public static], parameter[name]] begin[{]
local_variable[type[StringBuilder], stringBuilder]
ForStatement(body=BlockStatement(label=None, statements=[IfStatement(condition=BinaryOperation(operandl=BinaryOperation(operandl=MethodInvocation(arguments=[MemberReference(member=ch, postfix_operators=[], prefix_operators=[], qualifier=, selectors=[])], member=isLetterOrDigit, postfix_operators=[], prefix_operators=[], qualifier=Character, selectors=[], type_arguments=None), operandr=BinaryOperation(operandl=MemberReference(member=HYPHEN, postfix_operators=[], prefix_operators=[], qualifier=, selectors=[]), operandr=MemberReference(member=ch, postfix_operators=[], prefix_operators=[], qualifier=, selectors=[]), operator===), operator=||), operandr=BinaryOperation(operandl=MemberReference(member=DOT, postfix_operators=[], prefix_operators=[], qualifier=, selectors=[]), operandr=MemberReference(member=ch, postfix_operators=[], prefix_operators=[], qualifier=, selectors=[]), operator===), operator=||), else_statement=BlockStatement(label=None, statements=[StatementExpression(expression=MethodInvocation(arguments=[BinaryOperation(operandl=BinaryOperation(operandl=MemberReference(member=UNDERSCORE, postfix_operators=[], prefix_operators=[], qualifier=, selectors=[]), operandr=MethodInvocation(arguments=[Cast(expression=MemberReference(member=ch, postfix_operators=[], prefix_operators=[], qualifier=, selectors=[]), type=BasicType(dimensions=[], name=int))], member=toString, postfix_operators=[], prefix_operators=[], qualifier=Integer, selectors=[], type_arguments=None), operator=+), operandr=MemberReference(member=UNDERSCORE, postfix_operators=[], prefix_operators=[], qualifier=, selectors=[]), operator=+)], member=append, postfix_operators=[], prefix_operators=[], qualifier=stringBuilder, selectors=[], type_arguments=None), label=None)]), label=None, then_statement=BlockStatement(label=None, statements=[StatementExpression(expression=MethodInvocation(arguments=[MemberReference(member=ch, postfix_operators=[], prefix_operators=[], qualifier=, selectors=[])], member=append, postfix_operators=[], prefix_operators=[], qualifier=stringBuilder, selectors=[], type_arguments=None), label=None)]))]), control=EnhancedForControl(iterable=MethodInvocation(arguments=[], member=toCharArray, postfix_operators=[], prefix_operators=[], qualifier=name, selectors=[], type_arguments=None), var=VariableDeclaration(annotations=[], declarators=[VariableDeclarator(dimensions=None, initializer=None, name=ch)], modifiers=set(), type=BasicType(dimensions=[], name=char))), label=None)
return[call[stringBuilder.toString, parameter[]]]
end[}]
END[}]
|
Keyword[public] Keyword[static] identifier[String] identifier[serializePropertyName] operator[SEP] identifier[String] identifier[name] operator[SEP] {
identifier[StringBuilder] identifier[stringBuilder] operator[=] Keyword[new] identifier[StringBuilder] operator[SEP] operator[SEP] operator[SEP] Keyword[for] operator[SEP] Keyword[char] identifier[ch] operator[:] identifier[name] operator[SEP] identifier[toCharArray] operator[SEP] operator[SEP] operator[SEP] {
Keyword[if] operator[SEP] identifier[Character] operator[SEP] identifier[isLetterOrDigit] operator[SEP] identifier[ch] operator[SEP] operator[||] identifier[HYPHEN] operator[==] identifier[ch] operator[||] identifier[DOT] operator[==] identifier[ch] operator[SEP] {
identifier[stringBuilder] operator[SEP] identifier[append] operator[SEP] identifier[ch] operator[SEP] operator[SEP]
}
Keyword[else] {
identifier[stringBuilder] operator[SEP] identifier[append] operator[SEP] identifier[UNDERSCORE] operator[+] identifier[Integer] operator[SEP] identifier[toString] operator[SEP] operator[SEP] Keyword[int] operator[SEP] identifier[ch] operator[SEP] operator[+] identifier[UNDERSCORE] operator[SEP] operator[SEP]
}
}
Keyword[return] identifier[stringBuilder] operator[SEP] identifier[toString] operator[SEP] operator[SEP] operator[SEP]
}
|
private String getHalfMatrixString(Permutation permutation) {
StringBuilder builder = new StringBuilder(permutation.size());
int size = permutation.size();
for (int indexI = 0; indexI < size - 1; indexI++) {
for (int indexJ = indexI + 1; indexJ < size; indexJ++) {
builder.append(getConnectivity(permutation.get(indexI), permutation.get(indexJ)));
}
}
return builder.toString();
}
|
class class_name[name] begin[{]
method[getHalfMatrixString, return_type[type[String]], modifier[private], parameter[permutation]] begin[{]
local_variable[type[StringBuilder], builder]
local_variable[type[int], size]
ForStatement(body=BlockStatement(label=None, statements=[ForStatement(body=BlockStatement(label=None, statements=[StatementExpression(expression=MethodInvocation(arguments=[MethodInvocation(arguments=[MethodInvocation(arguments=[MemberReference(member=indexI, postfix_operators=[], prefix_operators=[], qualifier=, selectors=[])], member=get, postfix_operators=[], prefix_operators=[], qualifier=permutation, selectors=[], type_arguments=None), MethodInvocation(arguments=[MemberReference(member=indexJ, postfix_operators=[], prefix_operators=[], qualifier=, selectors=[])], member=get, postfix_operators=[], prefix_operators=[], qualifier=permutation, selectors=[], type_arguments=None)], member=getConnectivity, postfix_operators=[], prefix_operators=[], qualifier=, selectors=[], type_arguments=None)], member=append, postfix_operators=[], prefix_operators=[], qualifier=builder, selectors=[], type_arguments=None), label=None)]), control=ForControl(condition=BinaryOperation(operandl=MemberReference(member=indexJ, postfix_operators=[], prefix_operators=[], qualifier=, selectors=[]), operandr=MemberReference(member=size, postfix_operators=[], prefix_operators=[], qualifier=, selectors=[]), operator=<), init=VariableDeclaration(annotations=[], declarators=[VariableDeclarator(dimensions=None, initializer=BinaryOperation(operandl=MemberReference(member=indexI, postfix_operators=[], prefix_operators=[], qualifier=, selectors=[]), operandr=Literal(postfix_operators=[], prefix_operators=[], qualifier=None, selectors=[], value=1), operator=+), name=indexJ)], modifiers=set(), type=BasicType(dimensions=[], name=int)), update=[MemberReference(member=indexJ, postfix_operators=['++'], prefix_operators=[], qualifier=, selectors=[])]), label=None)]), control=ForControl(condition=BinaryOperation(operandl=MemberReference(member=indexI, postfix_operators=[], prefix_operators=[], qualifier=, selectors=[]), operandr=BinaryOperation(operandl=MemberReference(member=size, postfix_operators=[], prefix_operators=[], qualifier=, selectors=[]), operandr=Literal(postfix_operators=[], prefix_operators=[], qualifier=None, selectors=[], value=1), operator=-), operator=<), init=VariableDeclaration(annotations=[], declarators=[VariableDeclarator(dimensions=None, initializer=Literal(postfix_operators=[], prefix_operators=[], qualifier=None, selectors=[], value=0), name=indexI)], modifiers=set(), type=BasicType(dimensions=[], name=int)), update=[MemberReference(member=indexI, postfix_operators=['++'], prefix_operators=[], qualifier=, selectors=[])]), label=None)
return[call[builder.toString, parameter[]]]
end[}]
END[}]
|
Keyword[private] identifier[String] identifier[getHalfMatrixString] operator[SEP] identifier[Permutation] identifier[permutation] operator[SEP] {
identifier[StringBuilder] identifier[builder] operator[=] Keyword[new] identifier[StringBuilder] operator[SEP] identifier[permutation] operator[SEP] identifier[size] operator[SEP] operator[SEP] operator[SEP] operator[SEP] Keyword[int] identifier[size] operator[=] identifier[permutation] operator[SEP] identifier[size] operator[SEP] operator[SEP] operator[SEP] Keyword[for] operator[SEP] Keyword[int] identifier[indexI] operator[=] Other[0] operator[SEP] identifier[indexI] operator[<] identifier[size] operator[-] Other[1] operator[SEP] identifier[indexI] operator[++] operator[SEP] {
Keyword[for] operator[SEP] Keyword[int] identifier[indexJ] operator[=] identifier[indexI] operator[+] Other[1] operator[SEP] identifier[indexJ] operator[<] identifier[size] operator[SEP] identifier[indexJ] operator[++] operator[SEP] {
identifier[builder] operator[SEP] identifier[append] operator[SEP] identifier[getConnectivity] operator[SEP] identifier[permutation] operator[SEP] identifier[get] operator[SEP] identifier[indexI] operator[SEP] , identifier[permutation] operator[SEP] identifier[get] operator[SEP] identifier[indexJ] operator[SEP] operator[SEP] operator[SEP] operator[SEP]
}
}
Keyword[return] identifier[builder] operator[SEP] identifier[toString] operator[SEP] operator[SEP] operator[SEP]
}
|
@Override
public MonetaryAmount apply(MonetaryAmount amount) {
Objects.requireNonNull(amount, "Amount required.");
return amount.multiply(percentValue);
}
|
class class_name[name] begin[{]
method[apply, return_type[type[MonetaryAmount]], modifier[public], parameter[amount]] begin[{]
call[Objects.requireNonNull, parameter[member[.amount], literal["Amount required."]]]
return[call[amount.multiply, parameter[member[.percentValue]]]]
end[}]
END[}]
|
annotation[@] identifier[Override] Keyword[public] identifier[MonetaryAmount] identifier[apply] operator[SEP] identifier[MonetaryAmount] identifier[amount] operator[SEP] {
identifier[Objects] operator[SEP] identifier[requireNonNull] operator[SEP] identifier[amount] , literal[String] operator[SEP] operator[SEP] Keyword[return] identifier[amount] operator[SEP] identifier[multiply] operator[SEP] identifier[percentValue] operator[SEP] operator[SEP]
}
|
@BetaApi(
"The surface for long-running operations is not stable yet and may change in the future.")
public final OperationFuture<Instance, OperationMetadata> createInstanceAsync(
LocationName parent, String instanceId, Instance instance) {
CreateInstanceRequest request =
CreateInstanceRequest.newBuilder()
.setParent(parent == null ? null : parent.toString())
.setInstanceId(instanceId)
.setInstance(instance)
.build();
return createInstanceAsync(request);
}
|
class class_name[name] begin[{]
method[createInstanceAsync, return_type[type[OperationFuture]], modifier[final public], parameter[parent, instanceId, instance]] begin[{]
local_variable[type[CreateInstanceRequest], request]
return[call[.createInstanceAsync, parameter[member[.request]]]]
end[}]
END[}]
|
annotation[@] identifier[BetaApi] operator[SEP] literal[String] operator[SEP] Keyword[public] Keyword[final] identifier[OperationFuture] operator[<] identifier[Instance] , identifier[OperationMetadata] operator[>] identifier[createInstanceAsync] operator[SEP] identifier[LocationName] identifier[parent] , identifier[String] identifier[instanceId] , identifier[Instance] identifier[instance] operator[SEP] {
identifier[CreateInstanceRequest] identifier[request] operator[=] identifier[CreateInstanceRequest] operator[SEP] identifier[newBuilder] operator[SEP] operator[SEP] operator[SEP] identifier[setParent] operator[SEP] identifier[parent] operator[==] Other[null] operator[?] Other[null] operator[:] identifier[parent] operator[SEP] identifier[toString] operator[SEP] operator[SEP] operator[SEP] operator[SEP] identifier[setInstanceId] operator[SEP] identifier[instanceId] operator[SEP] operator[SEP] identifier[setInstance] operator[SEP] identifier[instance] operator[SEP] operator[SEP] identifier[build] operator[SEP] operator[SEP] operator[SEP] Keyword[return] identifier[createInstanceAsync] operator[SEP] identifier[request] operator[SEP] operator[SEP]
}
|
@XmlElementDecl(namespace = "http://www.opengis.net/gml", name = "MultiPoint", substitutionHeadNamespace = "http://www.opengis.net/gml", substitutionHeadName = "_GeometricAggregate")
public JAXBElement<MultiPointType> createMultiPoint(MultiPointType value) {
return new JAXBElement<MultiPointType>(_MultiPoint_QNAME, MultiPointType.class, null, value);
}
|
class class_name[name] begin[{]
method[createMultiPoint, return_type[type[JAXBElement]], modifier[public], parameter[value]] begin[{]
return[ClassCreator(arguments=[MemberReference(member=_MultiPoint_QNAME, postfix_operators=[], prefix_operators=[], qualifier=, selectors=[]), ClassReference(postfix_operators=[], prefix_operators=[], qualifier=, selectors=[], type=ReferenceType(arguments=None, dimensions=None, name=MultiPointType, sub_type=None)), Literal(postfix_operators=[], prefix_operators=[], qualifier=None, selectors=[], value=null), MemberReference(member=value, postfix_operators=[], prefix_operators=[], qualifier=, selectors=[])], body=None, constructor_type_arguments=None, postfix_operators=[], prefix_operators=[], qualifier=None, selectors=[], type=ReferenceType(arguments=[TypeArgument(pattern_type=None, type=ReferenceType(arguments=None, dimensions=[], name=MultiPointType, sub_type=None))], dimensions=None, name=JAXBElement, sub_type=None))]
end[}]
END[}]
|
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] identifier[JAXBElement] operator[<] identifier[MultiPointType] operator[>] identifier[createMultiPoint] operator[SEP] identifier[MultiPointType] identifier[value] operator[SEP] {
Keyword[return] Keyword[new] identifier[JAXBElement] operator[<] identifier[MultiPointType] operator[>] operator[SEP] identifier[_MultiPoint_QNAME] , identifier[MultiPointType] operator[SEP] Keyword[class] , Other[null] , identifier[value] operator[SEP] operator[SEP]
}
|
public String dumpCounters() {
// CHECK IF STATISTICS ARE ACTIVED
if (recording < 0)
return "Counters: <no recording>";
final StringBuilder buffer = new StringBuilder();
synchronized (counters) {
buffer.append("DUMPING COUNTERS (last reset on: " + lastReset.toString() + ")...");
buffer.append(String.format("\n%50s +-------------------------------------------------------------------+", ""));
buffer.append(String.format("\n%50s | Value |", "Name"));
buffer.append(String.format("\n%50s +-------------------------------------------------------------------+", ""));
final List<String> keys = new ArrayList<String>(counters.keySet());
Collections.sort(keys);
for (String k : keys) {
final Long stat = counters.get(k);
buffer.append(String.format("\n%-50s | %-65d |", k, stat));
}
}
buffer.append(String.format("\n%50s +-------------------------------------------------------------------+", ""));
return buffer.toString();
}
|
class class_name[name] begin[{]
method[dumpCounters, return_type[type[String]], modifier[public], parameter[]] begin[{]
if[binary_operation[member[.recording], <, literal[0]]] begin[{]
return[literal["Counters: <no recording>"]]
else begin[{]
None
end[}]
local_variable[type[StringBuilder], buffer]
SYNCHRONIZED[member[.counters]] BEGIN[{]
call[buffer.append, parameter[binary_operation[binary_operation[literal["DUMPING COUNTERS (last reset on: "], +, call[lastReset.toString, parameter[]]], +, literal[")..."]]]]
call[buffer.append, parameter[call[String.format, parameter[literal["\n%50s +-------------------------------------------------------------------+"], literal[""]]]]]
call[buffer.append, parameter[call[String.format, parameter[literal["\n%50s | Value |"], literal["Name"]]]]]
call[buffer.append, parameter[call[String.format, parameter[literal["\n%50s +-------------------------------------------------------------------+"], literal[""]]]]]
local_variable[type[List], keys]
call[Collections.sort, parameter[member[.keys]]]
ForStatement(body=BlockStatement(label=None, statements=[LocalVariableDeclaration(annotations=[], declarators=[VariableDeclarator(dimensions=[], initializer=MethodInvocation(arguments=[MemberReference(member=k, postfix_operators=[], prefix_operators=[], qualifier=, selectors=[])], member=get, postfix_operators=[], prefix_operators=[], qualifier=counters, selectors=[], type_arguments=None), name=stat)], modifiers={'final'}, type=ReferenceType(arguments=None, dimensions=[], name=Long, sub_type=None)), StatementExpression(expression=MethodInvocation(arguments=[MethodInvocation(arguments=[Literal(postfix_operators=[], prefix_operators=[], qualifier=None, selectors=[], value="\n%-50s | %-65d |"), MemberReference(member=k, postfix_operators=[], prefix_operators=[], qualifier=, selectors=[]), MemberReference(member=stat, postfix_operators=[], prefix_operators=[], qualifier=, selectors=[])], member=format, postfix_operators=[], prefix_operators=[], qualifier=String, selectors=[], type_arguments=None)], member=append, postfix_operators=[], prefix_operators=[], qualifier=buffer, selectors=[], type_arguments=None), label=None)]), control=EnhancedForControl(iterable=MemberReference(member=keys, postfix_operators=[], prefix_operators=[], qualifier=, selectors=[]), var=VariableDeclaration(annotations=[], declarators=[VariableDeclarator(dimensions=None, initializer=None, name=k)], modifiers=set(), type=ReferenceType(arguments=None, dimensions=[], name=String, sub_type=None))), label=None)
END[}]
call[buffer.append, parameter[call[String.format, parameter[literal["\n%50s +-------------------------------------------------------------------+"], literal[""]]]]]
return[call[buffer.toString, parameter[]]]
end[}]
END[}]
|
Keyword[public] identifier[String] identifier[dumpCounters] operator[SEP] operator[SEP] {
Keyword[if] operator[SEP] identifier[recording] operator[<] Other[0] operator[SEP] Keyword[return] literal[String] operator[SEP] Keyword[final] identifier[StringBuilder] identifier[buffer] operator[=] Keyword[new] identifier[StringBuilder] operator[SEP] operator[SEP] operator[SEP] Keyword[synchronized] operator[SEP] identifier[counters] operator[SEP] {
identifier[buffer] operator[SEP] identifier[append] operator[SEP] literal[String] operator[+] identifier[lastReset] operator[SEP] identifier[toString] operator[SEP] operator[SEP] operator[+] literal[String] operator[SEP] operator[SEP] identifier[buffer] operator[SEP] identifier[append] operator[SEP] identifier[String] operator[SEP] identifier[format] operator[SEP] literal[String] , literal[String] operator[SEP] operator[SEP] operator[SEP] identifier[buffer] operator[SEP] identifier[append] operator[SEP] identifier[String] operator[SEP] identifier[format] operator[SEP] literal[String] , literal[String] operator[SEP] operator[SEP] operator[SEP] identifier[buffer] operator[SEP] identifier[append] operator[SEP] identifier[String] operator[SEP] identifier[format] operator[SEP] literal[String] , literal[String] operator[SEP] operator[SEP] operator[SEP] Keyword[final] identifier[List] operator[<] identifier[String] operator[>] identifier[keys] operator[=] Keyword[new] identifier[ArrayList] operator[<] identifier[String] operator[>] operator[SEP] identifier[counters] operator[SEP] identifier[keySet] operator[SEP] operator[SEP] operator[SEP] operator[SEP] identifier[Collections] operator[SEP] identifier[sort] operator[SEP] identifier[keys] operator[SEP] operator[SEP] Keyword[for] operator[SEP] identifier[String] identifier[k] operator[:] identifier[keys] operator[SEP] {
Keyword[final] identifier[Long] identifier[stat] operator[=] identifier[counters] operator[SEP] identifier[get] operator[SEP] identifier[k] operator[SEP] operator[SEP] identifier[buffer] operator[SEP] identifier[append] operator[SEP] identifier[String] operator[SEP] identifier[format] operator[SEP] literal[String] , identifier[k] , identifier[stat] operator[SEP] operator[SEP] operator[SEP]
}
}
identifier[buffer] operator[SEP] identifier[append] operator[SEP] identifier[String] operator[SEP] identifier[format] operator[SEP] literal[String] , literal[String] operator[SEP] operator[SEP] operator[SEP] Keyword[return] identifier[buffer] operator[SEP] identifier[toString] operator[SEP] operator[SEP] operator[SEP]
}
|
public final boolean isReadOnly() {
Entry<?> entry = getEntry();
Calendar calendar = entry.getCalendar();
if (calendar != null) {
return calendar.isReadOnly();
}
return false;
}
|
class class_name[name] begin[{]
method[isReadOnly, return_type[type[boolean]], modifier[final public], parameter[]] begin[{]
local_variable[type[Entry], entry]
local_variable[type[Calendar], calendar]
if[binary_operation[member[.calendar], !=, literal[null]]] begin[{]
return[call[calendar.isReadOnly, parameter[]]]
else begin[{]
None
end[}]
return[literal[false]]
end[}]
END[}]
|
Keyword[public] Keyword[final] Keyword[boolean] identifier[isReadOnly] operator[SEP] operator[SEP] {
identifier[Entry] operator[<] operator[?] operator[>] identifier[entry] operator[=] identifier[getEntry] operator[SEP] operator[SEP] operator[SEP] identifier[Calendar] identifier[calendar] operator[=] identifier[entry] operator[SEP] identifier[getCalendar] operator[SEP] operator[SEP] operator[SEP] Keyword[if] operator[SEP] identifier[calendar] operator[!=] Other[null] operator[SEP] {
Keyword[return] identifier[calendar] operator[SEP] identifier[isReadOnly] operator[SEP] operator[SEP] operator[SEP]
}
Keyword[return] literal[boolean] operator[SEP]
}
|
public void eval(int[] context, double[] outsums) {
for (int oid = 0; oid < numOutcomes; oid++) {
outsums[oid] = iprob;
numfeats[oid] = 0;
}
int[] activeOutcomes;
double[] activeParameters;
for (int i = 0; i < context.length; i++) {
Context predParams = params[context[i]];
activeOutcomes = predParams.getOutcomes();
activeParameters = predParams.getParameters();
for (int j = 0; j < activeOutcomes.length; j++) {
int oid = activeOutcomes[j];
numfeats[oid]++;
outsums[oid] += constantInverse * activeParameters[j];
}
}
double SUM = 0.0;
for (int oid = 0; oid < numOutcomes; oid++) {
outsums[oid] = Math.exp(outsums[oid]);
if (_useSlackParameter) {
outsums[oid] += ((1.0 - ((double) numfeats[oid] / constant)) * correctionParam);
}
SUM += outsums[oid];
}
for (int oid = 0; oid < numOutcomes; oid++)
outsums[oid] /= SUM;
}
|
class class_name[name] begin[{]
method[eval, return_type[void], modifier[public], parameter[context, outsums]] begin[{]
ForStatement(body=BlockStatement(label=None, statements=[StatementExpression(expression=Assignment(expressionl=MemberReference(member=outsums, postfix_operators=[], prefix_operators=[], qualifier=, selectors=[ArraySelector(index=MemberReference(member=oid, postfix_operators=[], prefix_operators=[], qualifier=, selectors=[]))]), type==, value=MemberReference(member=iprob, postfix_operators=[], prefix_operators=[], qualifier=, selectors=[])), label=None), StatementExpression(expression=Assignment(expressionl=MemberReference(member=numfeats, postfix_operators=[], prefix_operators=[], qualifier=, selectors=[ArraySelector(index=MemberReference(member=oid, postfix_operators=[], prefix_operators=[], qualifier=, selectors=[]))]), type==, value=Literal(postfix_operators=[], prefix_operators=[], qualifier=None, selectors=[], value=0)), label=None)]), control=ForControl(condition=BinaryOperation(operandl=MemberReference(member=oid, postfix_operators=[], prefix_operators=[], qualifier=, selectors=[]), operandr=MemberReference(member=numOutcomes, postfix_operators=[], prefix_operators=[], qualifier=, selectors=[]), operator=<), init=VariableDeclaration(annotations=[], declarators=[VariableDeclarator(dimensions=None, initializer=Literal(postfix_operators=[], prefix_operators=[], qualifier=None, selectors=[], value=0), name=oid)], modifiers=set(), type=BasicType(dimensions=[], name=int)), update=[MemberReference(member=oid, postfix_operators=['++'], prefix_operators=[], qualifier=, selectors=[])]), label=None)
local_variable[type[int], activeOutcomes]
local_variable[type[double], activeParameters]
ForStatement(body=BlockStatement(label=None, statements=[LocalVariableDeclaration(annotations=[], declarators=[VariableDeclarator(dimensions=[], initializer=MemberReference(member=params, postfix_operators=[], prefix_operators=[], qualifier=, selectors=[ArraySelector(index=MemberReference(member=context, postfix_operators=[], prefix_operators=[], qualifier=, selectors=[ArraySelector(index=MemberReference(member=i, postfix_operators=[], prefix_operators=[], qualifier=, selectors=[]))]))]), name=predParams)], modifiers=set(), type=ReferenceType(arguments=None, dimensions=[], name=Context, sub_type=None)), StatementExpression(expression=Assignment(expressionl=MemberReference(member=activeOutcomes, postfix_operators=[], prefix_operators=[], qualifier=, selectors=[]), type==, value=MethodInvocation(arguments=[], member=getOutcomes, postfix_operators=[], prefix_operators=[], qualifier=predParams, selectors=[], type_arguments=None)), label=None), StatementExpression(expression=Assignment(expressionl=MemberReference(member=activeParameters, postfix_operators=[], prefix_operators=[], qualifier=, selectors=[]), type==, value=MethodInvocation(arguments=[], member=getParameters, postfix_operators=[], prefix_operators=[], qualifier=predParams, selectors=[], type_arguments=None)), label=None), ForStatement(body=BlockStatement(label=None, statements=[LocalVariableDeclaration(annotations=[], declarators=[VariableDeclarator(dimensions=[], initializer=MemberReference(member=activeOutcomes, postfix_operators=[], prefix_operators=[], qualifier=, selectors=[ArraySelector(index=MemberReference(member=j, postfix_operators=[], prefix_operators=[], qualifier=, selectors=[]))]), name=oid)], modifiers=set(), type=BasicType(dimensions=[], name=int)), StatementExpression(expression=MemberReference(member=numfeats, postfix_operators=['++'], prefix_operators=[], qualifier=, selectors=[ArraySelector(index=MemberReference(member=oid, postfix_operators=[], prefix_operators=[], qualifier=, selectors=[]))]), label=None), StatementExpression(expression=Assignment(expressionl=MemberReference(member=outsums, postfix_operators=[], prefix_operators=[], qualifier=, selectors=[ArraySelector(index=MemberReference(member=oid, postfix_operators=[], prefix_operators=[], qualifier=, selectors=[]))]), type=+=, value=BinaryOperation(operandl=MemberReference(member=constantInverse, postfix_operators=[], prefix_operators=[], qualifier=, selectors=[]), operandr=MemberReference(member=activeParameters, postfix_operators=[], prefix_operators=[], qualifier=, selectors=[ArraySelector(index=MemberReference(member=j, postfix_operators=[], prefix_operators=[], qualifier=, selectors=[]))]), operator=*)), label=None)]), control=ForControl(condition=BinaryOperation(operandl=MemberReference(member=j, postfix_operators=[], prefix_operators=[], qualifier=, selectors=[]), operandr=MemberReference(member=length, postfix_operators=[], prefix_operators=[], qualifier=activeOutcomes, selectors=[]), operator=<), init=VariableDeclaration(annotations=[], declarators=[VariableDeclarator(dimensions=None, initializer=Literal(postfix_operators=[], prefix_operators=[], qualifier=None, selectors=[], value=0), name=j)], modifiers=set(), type=BasicType(dimensions=[], name=int)), update=[MemberReference(member=j, postfix_operators=['++'], prefix_operators=[], qualifier=, selectors=[])]), label=None)]), control=ForControl(condition=BinaryOperation(operandl=MemberReference(member=i, postfix_operators=[], prefix_operators=[], qualifier=, selectors=[]), operandr=MemberReference(member=length, postfix_operators=[], prefix_operators=[], qualifier=context, selectors=[]), operator=<), init=VariableDeclaration(annotations=[], declarators=[VariableDeclarator(dimensions=None, initializer=Literal(postfix_operators=[], prefix_operators=[], qualifier=None, selectors=[], value=0), name=i)], modifiers=set(), type=BasicType(dimensions=[], name=int)), update=[MemberReference(member=i, postfix_operators=['++'], prefix_operators=[], qualifier=, selectors=[])]), label=None)
local_variable[type[double], SUM]
ForStatement(body=BlockStatement(label=None, statements=[StatementExpression(expression=Assignment(expressionl=MemberReference(member=outsums, postfix_operators=[], prefix_operators=[], qualifier=, selectors=[ArraySelector(index=MemberReference(member=oid, postfix_operators=[], prefix_operators=[], qualifier=, selectors=[]))]), type==, value=MethodInvocation(arguments=[MemberReference(member=outsums, postfix_operators=[], prefix_operators=[], qualifier=, selectors=[ArraySelector(index=MemberReference(member=oid, postfix_operators=[], prefix_operators=[], qualifier=, selectors=[]))])], member=exp, postfix_operators=[], prefix_operators=[], qualifier=Math, selectors=[], type_arguments=None)), label=None), IfStatement(condition=MemberReference(member=_useSlackParameter, postfix_operators=[], prefix_operators=[], qualifier=, selectors=[]), else_statement=None, label=None, then_statement=BlockStatement(label=None, statements=[StatementExpression(expression=Assignment(expressionl=MemberReference(member=outsums, postfix_operators=[], prefix_operators=[], qualifier=, selectors=[ArraySelector(index=MemberReference(member=oid, postfix_operators=[], prefix_operators=[], qualifier=, selectors=[]))]), type=+=, value=BinaryOperation(operandl=BinaryOperation(operandl=Literal(postfix_operators=[], prefix_operators=[], qualifier=None, selectors=[], value=1.0), operandr=BinaryOperation(operandl=Cast(expression=MemberReference(member=numfeats, postfix_operators=[], prefix_operators=[], qualifier=, selectors=[ArraySelector(index=MemberReference(member=oid, postfix_operators=[], prefix_operators=[], qualifier=, selectors=[]))]), type=BasicType(dimensions=[], name=double)), operandr=MemberReference(member=constant, postfix_operators=[], prefix_operators=[], qualifier=, selectors=[]), operator=/), operator=-), operandr=MemberReference(member=correctionParam, postfix_operators=[], prefix_operators=[], qualifier=, selectors=[]), operator=*)), label=None)])), StatementExpression(expression=Assignment(expressionl=MemberReference(member=SUM, postfix_operators=[], prefix_operators=[], qualifier=, selectors=[]), type=+=, value=MemberReference(member=outsums, postfix_operators=[], prefix_operators=[], qualifier=, selectors=[ArraySelector(index=MemberReference(member=oid, postfix_operators=[], prefix_operators=[], qualifier=, selectors=[]))])), label=None)]), control=ForControl(condition=BinaryOperation(operandl=MemberReference(member=oid, postfix_operators=[], prefix_operators=[], qualifier=, selectors=[]), operandr=MemberReference(member=numOutcomes, postfix_operators=[], prefix_operators=[], qualifier=, selectors=[]), operator=<), init=VariableDeclaration(annotations=[], declarators=[VariableDeclarator(dimensions=None, initializer=Literal(postfix_operators=[], prefix_operators=[], qualifier=None, selectors=[], value=0), name=oid)], modifiers=set(), type=BasicType(dimensions=[], name=int)), update=[MemberReference(member=oid, postfix_operators=['++'], prefix_operators=[], qualifier=, selectors=[])]), label=None)
ForStatement(body=StatementExpression(expression=Assignment(expressionl=MemberReference(member=outsums, postfix_operators=[], prefix_operators=[], qualifier=, selectors=[ArraySelector(index=MemberReference(member=oid, postfix_operators=[], prefix_operators=[], qualifier=, selectors=[]))]), type=/=, value=MemberReference(member=SUM, postfix_operators=[], prefix_operators=[], qualifier=, selectors=[])), label=None), control=ForControl(condition=BinaryOperation(operandl=MemberReference(member=oid, postfix_operators=[], prefix_operators=[], qualifier=, selectors=[]), operandr=MemberReference(member=numOutcomes, postfix_operators=[], prefix_operators=[], qualifier=, selectors=[]), operator=<), init=VariableDeclaration(annotations=[], declarators=[VariableDeclarator(dimensions=None, initializer=Literal(postfix_operators=[], prefix_operators=[], qualifier=None, selectors=[], value=0), name=oid)], modifiers=set(), type=BasicType(dimensions=[], name=int)), update=[MemberReference(member=oid, postfix_operators=['++'], prefix_operators=[], qualifier=, selectors=[])]), label=None)
end[}]
END[}]
|
Keyword[public] Keyword[void] identifier[eval] operator[SEP] Keyword[int] operator[SEP] operator[SEP] identifier[context] , Keyword[double] operator[SEP] operator[SEP] identifier[outsums] operator[SEP] {
Keyword[for] operator[SEP] Keyword[int] identifier[oid] operator[=] Other[0] operator[SEP] identifier[oid] operator[<] identifier[numOutcomes] operator[SEP] identifier[oid] operator[++] operator[SEP] {
identifier[outsums] operator[SEP] identifier[oid] operator[SEP] operator[=] identifier[iprob] operator[SEP] identifier[numfeats] operator[SEP] identifier[oid] operator[SEP] operator[=] Other[0] operator[SEP]
}
Keyword[int] operator[SEP] operator[SEP] identifier[activeOutcomes] operator[SEP] Keyword[double] operator[SEP] operator[SEP] identifier[activeParameters] operator[SEP] Keyword[for] operator[SEP] Keyword[int] identifier[i] operator[=] Other[0] operator[SEP] identifier[i] operator[<] identifier[context] operator[SEP] identifier[length] operator[SEP] identifier[i] operator[++] operator[SEP] {
identifier[Context] identifier[predParams] operator[=] identifier[params] operator[SEP] identifier[context] operator[SEP] identifier[i] operator[SEP] operator[SEP] operator[SEP] identifier[activeOutcomes] operator[=] identifier[predParams] operator[SEP] identifier[getOutcomes] operator[SEP] operator[SEP] operator[SEP] identifier[activeParameters] operator[=] identifier[predParams] operator[SEP] identifier[getParameters] operator[SEP] operator[SEP] operator[SEP] Keyword[for] operator[SEP] Keyword[int] identifier[j] operator[=] Other[0] operator[SEP] identifier[j] operator[<] identifier[activeOutcomes] operator[SEP] identifier[length] operator[SEP] identifier[j] operator[++] operator[SEP] {
Keyword[int] identifier[oid] operator[=] identifier[activeOutcomes] operator[SEP] identifier[j] operator[SEP] operator[SEP] identifier[numfeats] operator[SEP] identifier[oid] operator[SEP] operator[++] operator[SEP] identifier[outsums] operator[SEP] identifier[oid] operator[SEP] operator[+=] identifier[constantInverse] operator[*] identifier[activeParameters] operator[SEP] identifier[j] operator[SEP] operator[SEP]
}
}
Keyword[double] identifier[SUM] operator[=] literal[Float] operator[SEP] Keyword[for] operator[SEP] Keyword[int] identifier[oid] operator[=] Other[0] operator[SEP] identifier[oid] operator[<] identifier[numOutcomes] operator[SEP] identifier[oid] operator[++] operator[SEP] {
identifier[outsums] operator[SEP] identifier[oid] operator[SEP] operator[=] identifier[Math] operator[SEP] identifier[exp] operator[SEP] identifier[outsums] operator[SEP] identifier[oid] operator[SEP] operator[SEP] operator[SEP] Keyword[if] operator[SEP] identifier[_useSlackParameter] operator[SEP] {
identifier[outsums] operator[SEP] identifier[oid] operator[SEP] operator[+=] operator[SEP] operator[SEP] literal[Float] operator[-] operator[SEP] operator[SEP] Keyword[double] operator[SEP] identifier[numfeats] operator[SEP] identifier[oid] operator[SEP] operator[/] identifier[constant] operator[SEP] operator[SEP] operator[*] identifier[correctionParam] operator[SEP] operator[SEP]
}
identifier[SUM] operator[+=] identifier[outsums] operator[SEP] identifier[oid] operator[SEP] operator[SEP]
}
Keyword[for] operator[SEP] Keyword[int] identifier[oid] operator[=] Other[0] operator[SEP] identifier[oid] operator[<] identifier[numOutcomes] operator[SEP] identifier[oid] operator[++] operator[SEP] identifier[outsums] operator[SEP] identifier[oid] operator[SEP] operator[/=] identifier[SUM] operator[SEP]
}
|
public static SecretKey generateKey(String algorithm, byte[] key) {
Assert.notBlank(algorithm, "Algorithm is blank!");
SecretKey secretKey = null;
if (algorithm.startsWith("PBE")) {
// PBE密钥
secretKey = generatePBEKey(algorithm, (null == key) ? null : StrUtil.str(key, CharsetUtil.CHARSET_UTF_8).toCharArray());
} else if (algorithm.startsWith("DES")) {
// DES密钥
secretKey = generateDESKey(algorithm, key);
} else {
// 其它算法密钥
secretKey = (null == key) ? generateKey(algorithm) : new SecretKeySpec(key, algorithm);
}
return secretKey;
}
|
class class_name[name] begin[{]
method[generateKey, return_type[type[SecretKey]], modifier[public static], parameter[algorithm, key]] begin[{]
call[Assert.notBlank, parameter[member[.algorithm], literal["Algorithm is blank!"]]]
local_variable[type[SecretKey], secretKey]
if[call[algorithm.startsWith, parameter[literal["PBE"]]]] begin[{]
assign[member[.secretKey], call[.generatePBEKey, parameter[member[.algorithm], TernaryExpression(condition=BinaryOperation(operandl=Literal(postfix_operators=[], prefix_operators=[], qualifier=None, selectors=[], value=null), operandr=MemberReference(member=key, postfix_operators=[], prefix_operators=[], qualifier=, selectors=[]), operator===), if_false=MethodInvocation(arguments=[MemberReference(member=key, postfix_operators=[], prefix_operators=[], qualifier=, selectors=[]), MemberReference(member=CHARSET_UTF_8, postfix_operators=[], prefix_operators=[], qualifier=CharsetUtil, selectors=[])], member=str, postfix_operators=[], prefix_operators=[], qualifier=StrUtil, selectors=[MethodInvocation(arguments=[], member=toCharArray, postfix_operators=None, prefix_operators=None, qualifier=None, selectors=None, type_arguments=None)], type_arguments=None), if_true=Literal(postfix_operators=[], prefix_operators=[], qualifier=None, selectors=[], value=null))]]]
else begin[{]
if[call[algorithm.startsWith, parameter[literal["DES"]]]] begin[{]
assign[member[.secretKey], call[.generateDESKey, parameter[member[.algorithm], member[.key]]]]
else begin[{]
assign[member[.secretKey], TernaryExpression(condition=BinaryOperation(operandl=Literal(postfix_operators=[], prefix_operators=[], qualifier=None, selectors=[], value=null), operandr=MemberReference(member=key, postfix_operators=[], prefix_operators=[], qualifier=, selectors=[]), operator===), if_false=ClassCreator(arguments=[MemberReference(member=key, postfix_operators=[], prefix_operators=[], qualifier=, selectors=[]), MemberReference(member=algorithm, postfix_operators=[], prefix_operators=[], qualifier=, selectors=[])], body=None, constructor_type_arguments=None, postfix_operators=[], prefix_operators=[], qualifier=None, selectors=[], type=ReferenceType(arguments=None, dimensions=None, name=SecretKeySpec, sub_type=None)), if_true=MethodInvocation(arguments=[MemberReference(member=algorithm, postfix_operators=[], prefix_operators=[], qualifier=, selectors=[])], member=generateKey, postfix_operators=[], prefix_operators=[], qualifier=, selectors=[], type_arguments=None))]
end[}]
end[}]
return[member[.secretKey]]
end[}]
END[}]
|
Keyword[public] Keyword[static] identifier[SecretKey] identifier[generateKey] operator[SEP] identifier[String] identifier[algorithm] , Keyword[byte] operator[SEP] operator[SEP] identifier[key] operator[SEP] {
identifier[Assert] operator[SEP] identifier[notBlank] operator[SEP] identifier[algorithm] , literal[String] operator[SEP] operator[SEP] identifier[SecretKey] identifier[secretKey] operator[=] Other[null] operator[SEP] Keyword[if] operator[SEP] identifier[algorithm] operator[SEP] identifier[startsWith] operator[SEP] literal[String] operator[SEP] operator[SEP] {
identifier[secretKey] operator[=] identifier[generatePBEKey] operator[SEP] identifier[algorithm] , operator[SEP] Other[null] operator[==] identifier[key] operator[SEP] operator[?] Other[null] operator[:] identifier[StrUtil] operator[SEP] identifier[str] operator[SEP] identifier[key] , identifier[CharsetUtil] operator[SEP] identifier[CHARSET_UTF_8] operator[SEP] operator[SEP] identifier[toCharArray] operator[SEP] operator[SEP] operator[SEP] operator[SEP]
}
Keyword[else] Keyword[if] operator[SEP] identifier[algorithm] operator[SEP] identifier[startsWith] operator[SEP] literal[String] operator[SEP] operator[SEP] {
identifier[secretKey] operator[=] identifier[generateDESKey] operator[SEP] identifier[algorithm] , identifier[key] operator[SEP] operator[SEP]
}
Keyword[else] {
identifier[secretKey] operator[=] operator[SEP] Other[null] operator[==] identifier[key] operator[SEP] operator[?] identifier[generateKey] operator[SEP] identifier[algorithm] operator[SEP] operator[:] Keyword[new] identifier[SecretKeySpec] operator[SEP] identifier[key] , identifier[algorithm] operator[SEP] operator[SEP]
}
Keyword[return] identifier[secretKey] operator[SEP]
}
|
private Boolean getReplaceableValue(Expression expr) {
return TranslationUtil.hasSideEffect(expr) ? null : getKnownValue(expr);
}
|
class class_name[name] begin[{]
method[getReplaceableValue, return_type[type[Boolean]], modifier[private], parameter[expr]] begin[{]
return[TernaryExpression(condition=MethodInvocation(arguments=[MemberReference(member=expr, postfix_operators=[], prefix_operators=[], qualifier=, selectors=[])], member=hasSideEffect, postfix_operators=[], prefix_operators=[], qualifier=TranslationUtil, selectors=[], type_arguments=None), if_false=MethodInvocation(arguments=[MemberReference(member=expr, postfix_operators=[], prefix_operators=[], qualifier=, selectors=[])], member=getKnownValue, postfix_operators=[], prefix_operators=[], qualifier=, selectors=[], type_arguments=None), if_true=Literal(postfix_operators=[], prefix_operators=[], qualifier=None, selectors=[], value=null))]
end[}]
END[}]
|
Keyword[private] identifier[Boolean] identifier[getReplaceableValue] operator[SEP] identifier[Expression] identifier[expr] operator[SEP] {
Keyword[return] identifier[TranslationUtil] operator[SEP] identifier[hasSideEffect] operator[SEP] identifier[expr] operator[SEP] operator[?] Other[null] operator[:] identifier[getKnownValue] operator[SEP] identifier[expr] operator[SEP] operator[SEP]
}
|
public static Function<Object,Integer> methodForInteger(final String methodName, final Object... optionalParameters) {
return new Call<Object,Integer>(Types.INTEGER, methodName, VarArgsUtil.asOptionalObjectArray(Object.class,optionalParameters));
}
|
class class_name[name] begin[{]
method[methodForInteger, return_type[type[Function]], modifier[public static], parameter[methodName, optionalParameters]] begin[{]
return[ClassCreator(arguments=[MemberReference(member=INTEGER, postfix_operators=[], prefix_operators=[], qualifier=Types, selectors=[]), MemberReference(member=methodName, postfix_operators=[], prefix_operators=[], qualifier=, selectors=[]), MethodInvocation(arguments=[ClassReference(postfix_operators=[], prefix_operators=[], qualifier=, selectors=[], type=ReferenceType(arguments=None, dimensions=None, name=Object, sub_type=None)), MemberReference(member=optionalParameters, postfix_operators=[], prefix_operators=[], qualifier=, selectors=[])], member=asOptionalObjectArray, postfix_operators=[], prefix_operators=[], qualifier=VarArgsUtil, selectors=[], type_arguments=None)], body=None, constructor_type_arguments=None, postfix_operators=[], prefix_operators=[], qualifier=None, selectors=[], type=ReferenceType(arguments=[TypeArgument(pattern_type=None, type=ReferenceType(arguments=None, dimensions=[], name=Object, sub_type=None)), TypeArgument(pattern_type=None, type=ReferenceType(arguments=None, dimensions=[], name=Integer, sub_type=None))], dimensions=None, name=Call, sub_type=None))]
end[}]
END[}]
|
Keyword[public] Keyword[static] identifier[Function] operator[<] identifier[Object] , identifier[Integer] operator[>] identifier[methodForInteger] operator[SEP] Keyword[final] identifier[String] identifier[methodName] , Keyword[final] identifier[Object] operator[...] identifier[optionalParameters] operator[SEP] {
Keyword[return] Keyword[new] identifier[Call] operator[<] identifier[Object] , identifier[Integer] operator[>] operator[SEP] identifier[Types] operator[SEP] identifier[INTEGER] , identifier[methodName] , identifier[VarArgsUtil] operator[SEP] identifier[asOptionalObjectArray] operator[SEP] identifier[Object] operator[SEP] Keyword[class] , identifier[optionalParameters] operator[SEP] operator[SEP] operator[SEP]
}
|
private synchronized ListenableFuture<?> updateUserMemory(String allocationTag, long delta)
{
if (delta >= 0) {
enforceUserMemoryLimit(queryMemoryContext.getUserMemory(), delta, maxUserMemory);
return memoryPool.reserve(queryId, allocationTag, delta);
}
memoryPool.free(queryId, allocationTag, -delta);
return NOT_BLOCKED;
}
|
class class_name[name] begin[{]
method[updateUserMemory, return_type[type[ListenableFuture]], modifier[synchronized private], parameter[allocationTag, delta]] begin[{]
if[binary_operation[member[.delta], >=, literal[0]]] begin[{]
call[.enforceUserMemoryLimit, parameter[call[queryMemoryContext.getUserMemory, parameter[]], member[.delta], member[.maxUserMemory]]]
return[call[memoryPool.reserve, parameter[member[.queryId], member[.allocationTag], member[.delta]]]]
else begin[{]
None
end[}]
call[memoryPool.free, parameter[member[.queryId], member[.allocationTag], member[.delta]]]
return[member[.NOT_BLOCKED]]
end[}]
END[}]
|
Keyword[private] Keyword[synchronized] identifier[ListenableFuture] operator[<] operator[?] operator[>] identifier[updateUserMemory] operator[SEP] identifier[String] identifier[allocationTag] , Keyword[long] identifier[delta] operator[SEP] {
Keyword[if] operator[SEP] identifier[delta] operator[>=] Other[0] operator[SEP] {
identifier[enforceUserMemoryLimit] operator[SEP] identifier[queryMemoryContext] operator[SEP] identifier[getUserMemory] operator[SEP] operator[SEP] , identifier[delta] , identifier[maxUserMemory] operator[SEP] operator[SEP] Keyword[return] identifier[memoryPool] operator[SEP] identifier[reserve] operator[SEP] identifier[queryId] , identifier[allocationTag] , identifier[delta] operator[SEP] operator[SEP]
}
identifier[memoryPool] operator[SEP] identifier[free] operator[SEP] identifier[queryId] , identifier[allocationTag] , operator[-] identifier[delta] operator[SEP] operator[SEP] Keyword[return] identifier[NOT_BLOCKED] operator[SEP]
}
|
File findFinalizedEditsFile(long startTxId, long endTxId) throws IOException {
File ret = new File(sd.getCurrentDir(),
NNStorage.getFinalizedEditsFileName(startTxId, endTxId));
if (!ret.exists()) {
throw new IOException(
"No edits file for range " + startTxId + "-" + endTxId);
}
return ret;
}
|
class class_name[name] begin[{]
method[findFinalizedEditsFile, return_type[type[File]], modifier[default], parameter[startTxId, endTxId]] begin[{]
local_variable[type[File], ret]
if[call[ret.exists, parameter[]]] begin[{]
ThrowStatement(expression=ClassCreator(arguments=[BinaryOperation(operandl=BinaryOperation(operandl=BinaryOperation(operandl=Literal(postfix_operators=[], prefix_operators=[], qualifier=None, selectors=[], value="No edits file for range "), operandr=MemberReference(member=startTxId, postfix_operators=[], prefix_operators=[], qualifier=, selectors=[]), operator=+), operandr=Literal(postfix_operators=[], prefix_operators=[], qualifier=None, selectors=[], value="-"), operator=+), operandr=MemberReference(member=endTxId, postfix_operators=[], prefix_operators=[], qualifier=, selectors=[]), operator=+)], body=None, constructor_type_arguments=None, postfix_operators=[], prefix_operators=[], qualifier=None, selectors=[], type=ReferenceType(arguments=None, dimensions=None, name=IOException, sub_type=None)), label=None)
else begin[{]
None
end[}]
return[member[.ret]]
end[}]
END[}]
|
identifier[File] identifier[findFinalizedEditsFile] operator[SEP] Keyword[long] identifier[startTxId] , Keyword[long] identifier[endTxId] operator[SEP] Keyword[throws] identifier[IOException] {
identifier[File] identifier[ret] operator[=] Keyword[new] identifier[File] operator[SEP] identifier[sd] operator[SEP] identifier[getCurrentDir] operator[SEP] operator[SEP] , identifier[NNStorage] operator[SEP] identifier[getFinalizedEditsFileName] operator[SEP] identifier[startTxId] , identifier[endTxId] operator[SEP] operator[SEP] operator[SEP] Keyword[if] operator[SEP] operator[!] identifier[ret] operator[SEP] identifier[exists] operator[SEP] operator[SEP] operator[SEP] {
Keyword[throw] Keyword[new] identifier[IOException] operator[SEP] literal[String] operator[+] identifier[startTxId] operator[+] literal[String] operator[+] identifier[endTxId] operator[SEP] operator[SEP]
}
Keyword[return] identifier[ret] operator[SEP]
}
|
public static TraceFormat getFormatValue(Object newValue, TraceFormat defaultValue) {
if (newValue != null && newValue instanceof String) {
String strValue = ((String) newValue).toUpperCase();
try {
return TraceFormat.valueOf(strValue);
} catch (Exception e) {
}
}
return defaultValue;
}
|
class class_name[name] begin[{]
method[getFormatValue, return_type[type[TraceFormat]], modifier[public static], parameter[newValue, defaultValue]] begin[{]
if[binary_operation[binary_operation[member[.newValue], !=, literal[null]], &&, binary_operation[member[.newValue], instanceof, type[String]]]] begin[{]
local_variable[type[String], strValue]
TryStatement(block=[ReturnStatement(expression=MethodInvocation(arguments=[MemberReference(member=strValue, postfix_operators=[], prefix_operators=[], qualifier=, selectors=[])], member=valueOf, postfix_operators=[], prefix_operators=[], qualifier=TraceFormat, selectors=[], type_arguments=None), label=None)], catches=[CatchClause(block=[], label=None, parameter=CatchClauseParameter(annotations=None, modifiers=None, name=e, types=['Exception']))], finally_block=None, label=None, resources=None)
else begin[{]
None
end[}]
return[member[.defaultValue]]
end[}]
END[}]
|
Keyword[public] Keyword[static] identifier[TraceFormat] identifier[getFormatValue] operator[SEP] identifier[Object] identifier[newValue] , identifier[TraceFormat] identifier[defaultValue] operator[SEP] {
Keyword[if] operator[SEP] identifier[newValue] operator[!=] Other[null] operator[&&] identifier[newValue] Keyword[instanceof] identifier[String] operator[SEP] {
identifier[String] identifier[strValue] operator[=] operator[SEP] operator[SEP] identifier[String] operator[SEP] identifier[newValue] operator[SEP] operator[SEP] identifier[toUpperCase] operator[SEP] operator[SEP] operator[SEP] Keyword[try] {
Keyword[return] identifier[TraceFormat] operator[SEP] identifier[valueOf] operator[SEP] identifier[strValue] operator[SEP] operator[SEP]
}
Keyword[catch] operator[SEP] identifier[Exception] identifier[e] operator[SEP] {
}
}
Keyword[return] identifier[defaultValue] operator[SEP]
}
|
@Override
protected void bind() {
Bindings.bindBidirectional(view().sourceText().textProperty(), object().pSourcePath(), new FileStringConverter());
Bindings.bindBidirectional(view().targetText().textProperty(), object().pTargetPath(), new FileStringConverter());
this.sortedList.comparatorProperty().bind(view().getTable().comparatorProperty());
view().getTable().setItems(this.sortedList);
bindFilterButton();
bindButtonEnabling();
}
|
class class_name[name] begin[{]
method[bind, return_type[void], modifier[protected], parameter[]] begin[{]
call[Bindings.bindBidirectional, parameter[call[.view, parameter[]], call[.object, parameter[]], ClassCreator(arguments=[], body=None, constructor_type_arguments=None, postfix_operators=[], prefix_operators=[], qualifier=None, selectors=[], type=ReferenceType(arguments=None, dimensions=None, name=FileStringConverter, sub_type=None))]]
call[Bindings.bindBidirectional, parameter[call[.view, parameter[]], call[.object, parameter[]], ClassCreator(arguments=[], body=None, constructor_type_arguments=None, postfix_operators=[], prefix_operators=[], qualifier=None, selectors=[], type=ReferenceType(arguments=None, dimensions=None, name=FileStringConverter, sub_type=None))]]
THIS[member[None.sortedList]call[None.comparatorProperty, parameter[]]call[None.bind, parameter[call[.view, parameter[]]]]]
call[.view, parameter[]]
call[.bindFilterButton, parameter[]]
call[.bindButtonEnabling, parameter[]]
end[}]
END[}]
|
annotation[@] identifier[Override] Keyword[protected] Keyword[void] identifier[bind] operator[SEP] operator[SEP] {
identifier[Bindings] operator[SEP] identifier[bindBidirectional] operator[SEP] identifier[view] operator[SEP] operator[SEP] operator[SEP] identifier[sourceText] operator[SEP] operator[SEP] operator[SEP] identifier[textProperty] operator[SEP] operator[SEP] , identifier[object] operator[SEP] operator[SEP] operator[SEP] identifier[pSourcePath] operator[SEP] operator[SEP] , Keyword[new] identifier[FileStringConverter] operator[SEP] operator[SEP] operator[SEP] operator[SEP] identifier[Bindings] operator[SEP] identifier[bindBidirectional] operator[SEP] identifier[view] operator[SEP] operator[SEP] operator[SEP] identifier[targetText] operator[SEP] operator[SEP] operator[SEP] identifier[textProperty] operator[SEP] operator[SEP] , identifier[object] operator[SEP] operator[SEP] operator[SEP] identifier[pTargetPath] operator[SEP] operator[SEP] , Keyword[new] identifier[FileStringConverter] operator[SEP] operator[SEP] operator[SEP] operator[SEP] Keyword[this] operator[SEP] identifier[sortedList] operator[SEP] identifier[comparatorProperty] operator[SEP] operator[SEP] operator[SEP] identifier[bind] operator[SEP] identifier[view] operator[SEP] operator[SEP] operator[SEP] identifier[getTable] operator[SEP] operator[SEP] operator[SEP] identifier[comparatorProperty] operator[SEP] operator[SEP] operator[SEP] operator[SEP] identifier[view] operator[SEP] operator[SEP] operator[SEP] identifier[getTable] operator[SEP] operator[SEP] operator[SEP] identifier[setItems] operator[SEP] Keyword[this] operator[SEP] identifier[sortedList] operator[SEP] operator[SEP] identifier[bindFilterButton] operator[SEP] operator[SEP] operator[SEP] identifier[bindButtonEnabling] operator[SEP] operator[SEP] operator[SEP]
}
|
void becomeInactive() throws InternalLogException
{
if (tc.isEntryEnabled())
Tr.entry(tc, "becomeInactive", this);
_logFileHeader.changeStatus(LogFileHeader.STATUS_INACTIVE);
try
{
writeFileStatus(false);
} catch (InternalLogException exc)
{
FFDCFilter.processException(exc, "com.ibm.ws.recoverylog.spi.LogFileHandle.becomeInactive", "1161", this);
if (tc.isEntryEnabled())
Tr.exit(tc, "becomeInactive", exc);
throw exc;
} catch (Throwable exc)
{
FFDCFilter.processException(exc, "com.ibm.ws.recoverylog.spi.LogFileHandle.becomeInactive", "1167", this);
if (tc.isEntryEnabled())
Tr.exit(tc, "becomeInactive", "InternalLogException");
throw new InternalLogException(exc);
}
if (tc.isEntryEnabled())
Tr.entry(tc, "becomeInactive", this);
}
|
class class_name[name] begin[{]
method[becomeInactive, return_type[void], modifier[default], parameter[]] begin[{]
if[call[tc.isEntryEnabled, parameter[]]] begin[{]
call[Tr.entry, parameter[member[.tc], literal["becomeInactive"], THIS[]]]
else begin[{]
None
end[}]
call[_logFileHeader.changeStatus, parameter[member[LogFileHeader.STATUS_INACTIVE]]]
TryStatement(block=[StatementExpression(expression=MethodInvocation(arguments=[Literal(postfix_operators=[], prefix_operators=[], qualifier=None, selectors=[], value=false)], member=writeFileStatus, postfix_operators=[], prefix_operators=[], qualifier=, selectors=[], type_arguments=None), label=None)], catches=[CatchClause(block=[StatementExpression(expression=MethodInvocation(arguments=[MemberReference(member=exc, postfix_operators=[], prefix_operators=[], qualifier=, selectors=[]), Literal(postfix_operators=[], prefix_operators=[], qualifier=None, selectors=[], value="com.ibm.ws.recoverylog.spi.LogFileHandle.becomeInactive"), Literal(postfix_operators=[], prefix_operators=[], qualifier=None, selectors=[], value="1161"), This(postfix_operators=[], prefix_operators=[], qualifier=None, selectors=[])], member=processException, postfix_operators=[], prefix_operators=[], qualifier=FFDCFilter, selectors=[], type_arguments=None), label=None), IfStatement(condition=MethodInvocation(arguments=[], member=isEntryEnabled, postfix_operators=[], prefix_operators=[], qualifier=tc, selectors=[], type_arguments=None), else_statement=None, label=None, then_statement=StatementExpression(expression=MethodInvocation(arguments=[MemberReference(member=tc, postfix_operators=[], prefix_operators=[], qualifier=, selectors=[]), Literal(postfix_operators=[], prefix_operators=[], qualifier=None, selectors=[], value="becomeInactive"), MemberReference(member=exc, postfix_operators=[], prefix_operators=[], qualifier=, selectors=[])], member=exit, postfix_operators=[], prefix_operators=[], qualifier=Tr, selectors=[], type_arguments=None), label=None)), ThrowStatement(expression=MemberReference(member=exc, postfix_operators=[], prefix_operators=[], qualifier=, selectors=[]), label=None)], label=None, parameter=CatchClauseParameter(annotations=None, modifiers=None, name=exc, types=['InternalLogException'])), CatchClause(block=[StatementExpression(expression=MethodInvocation(arguments=[MemberReference(member=exc, postfix_operators=[], prefix_operators=[], qualifier=, selectors=[]), Literal(postfix_operators=[], prefix_operators=[], qualifier=None, selectors=[], value="com.ibm.ws.recoverylog.spi.LogFileHandle.becomeInactive"), Literal(postfix_operators=[], prefix_operators=[], qualifier=None, selectors=[], value="1167"), This(postfix_operators=[], prefix_operators=[], qualifier=None, selectors=[])], member=processException, postfix_operators=[], prefix_operators=[], qualifier=FFDCFilter, selectors=[], type_arguments=None), label=None), IfStatement(condition=MethodInvocation(arguments=[], member=isEntryEnabled, postfix_operators=[], prefix_operators=[], qualifier=tc, selectors=[], type_arguments=None), else_statement=None, label=None, then_statement=StatementExpression(expression=MethodInvocation(arguments=[MemberReference(member=tc, postfix_operators=[], prefix_operators=[], qualifier=, selectors=[]), Literal(postfix_operators=[], prefix_operators=[], qualifier=None, selectors=[], value="becomeInactive"), Literal(postfix_operators=[], prefix_operators=[], qualifier=None, selectors=[], value="InternalLogException")], member=exit, postfix_operators=[], prefix_operators=[], qualifier=Tr, selectors=[], type_arguments=None), label=None)), ThrowStatement(expression=ClassCreator(arguments=[MemberReference(member=exc, postfix_operators=[], prefix_operators=[], qualifier=, selectors=[])], body=None, constructor_type_arguments=None, postfix_operators=[], prefix_operators=[], qualifier=None, selectors=[], type=ReferenceType(arguments=None, dimensions=None, name=InternalLogException, sub_type=None)), label=None)], label=None, parameter=CatchClauseParameter(annotations=None, modifiers=None, name=exc, types=['Throwable']))], finally_block=None, label=None, resources=None)
if[call[tc.isEntryEnabled, parameter[]]] begin[{]
call[Tr.entry, parameter[member[.tc], literal["becomeInactive"], THIS[]]]
else begin[{]
None
end[}]
end[}]
END[}]
|
Keyword[void] identifier[becomeInactive] operator[SEP] operator[SEP] Keyword[throws] identifier[InternalLogException] {
Keyword[if] operator[SEP] identifier[tc] operator[SEP] identifier[isEntryEnabled] operator[SEP] operator[SEP] operator[SEP] identifier[Tr] operator[SEP] identifier[entry] operator[SEP] identifier[tc] , literal[String] , Keyword[this] operator[SEP] operator[SEP] identifier[_logFileHeader] operator[SEP] identifier[changeStatus] operator[SEP] identifier[LogFileHeader] operator[SEP] identifier[STATUS_INACTIVE] operator[SEP] operator[SEP] Keyword[try] {
identifier[writeFileStatus] operator[SEP] literal[boolean] operator[SEP] operator[SEP]
}
Keyword[catch] operator[SEP] identifier[InternalLogException] identifier[exc] operator[SEP] {
identifier[FFDCFilter] operator[SEP] identifier[processException] operator[SEP] identifier[exc] , literal[String] , literal[String] , Keyword[this] operator[SEP] operator[SEP] Keyword[if] operator[SEP] identifier[tc] operator[SEP] identifier[isEntryEnabled] operator[SEP] operator[SEP] operator[SEP] identifier[Tr] operator[SEP] identifier[exit] operator[SEP] identifier[tc] , literal[String] , identifier[exc] operator[SEP] operator[SEP] Keyword[throw] identifier[exc] operator[SEP]
}
Keyword[catch] operator[SEP] identifier[Throwable] identifier[exc] operator[SEP] {
identifier[FFDCFilter] operator[SEP] identifier[processException] operator[SEP] identifier[exc] , literal[String] , literal[String] , Keyword[this] operator[SEP] operator[SEP] Keyword[if] operator[SEP] identifier[tc] operator[SEP] identifier[isEntryEnabled] operator[SEP] operator[SEP] operator[SEP] identifier[Tr] operator[SEP] identifier[exit] operator[SEP] identifier[tc] , literal[String] , literal[String] operator[SEP] operator[SEP] Keyword[throw] Keyword[new] identifier[InternalLogException] operator[SEP] identifier[exc] operator[SEP] operator[SEP]
}
Keyword[if] operator[SEP] identifier[tc] operator[SEP] identifier[isEntryEnabled] operator[SEP] operator[SEP] operator[SEP] identifier[Tr] operator[SEP] identifier[entry] operator[SEP] identifier[tc] , literal[String] , Keyword[this] operator[SEP] operator[SEP]
}
|
public static File createJarPackage(IResource resource) {
JarModule jarModule = new JarModule(resource);
try {
PlatformUI.getWorkbench().getProgressService().run(false, true,
jarModule);
} catch (Exception e) {
e.printStackTrace();
return null;
}
File jarFile = jarModule.getJarFile();
if (jarFile == null) {
ErrorMessageDialog.display("Run on Hadoop",
"Unable to create or locate the JAR file for the Job");
return null;
}
return jarFile;
}
|
class class_name[name] begin[{]
method[createJarPackage, return_type[type[File]], modifier[public static], parameter[resource]] begin[{]
local_variable[type[JarModule], jarModule]
TryStatement(block=[StatementExpression(expression=MethodInvocation(arguments=[], member=getWorkbench, postfix_operators=[], prefix_operators=[], qualifier=PlatformUI, selectors=[MethodInvocation(arguments=[], member=getProgressService, postfix_operators=None, prefix_operators=None, qualifier=None, selectors=None, type_arguments=None), MethodInvocation(arguments=[Literal(postfix_operators=[], prefix_operators=[], qualifier=None, selectors=[], value=false), Literal(postfix_operators=[], prefix_operators=[], qualifier=None, selectors=[], value=true), MemberReference(member=jarModule, postfix_operators=[], prefix_operators=[], qualifier=, selectors=[])], member=run, postfix_operators=None, prefix_operators=None, qualifier=None, selectors=None, type_arguments=None)], type_arguments=None), label=None)], catches=[CatchClause(block=[StatementExpression(expression=MethodInvocation(arguments=[], member=printStackTrace, postfix_operators=[], prefix_operators=[], qualifier=e, selectors=[], type_arguments=None), label=None), ReturnStatement(expression=Literal(postfix_operators=[], prefix_operators=[], qualifier=None, selectors=[], value=null), label=None)], label=None, parameter=CatchClauseParameter(annotations=None, modifiers=None, name=e, types=['Exception']))], finally_block=None, label=None, resources=None)
local_variable[type[File], jarFile]
if[binary_operation[member[.jarFile], ==, literal[null]]] begin[{]
call[ErrorMessageDialog.display, parameter[literal["Run on Hadoop"], literal["Unable to create or locate the JAR file for the Job"]]]
return[literal[null]]
else begin[{]
None
end[}]
return[member[.jarFile]]
end[}]
END[}]
|
Keyword[public] Keyword[static] identifier[File] identifier[createJarPackage] operator[SEP] identifier[IResource] identifier[resource] operator[SEP] {
identifier[JarModule] identifier[jarModule] operator[=] Keyword[new] identifier[JarModule] operator[SEP] identifier[resource] operator[SEP] operator[SEP] Keyword[try] {
identifier[PlatformUI] operator[SEP] identifier[getWorkbench] operator[SEP] operator[SEP] operator[SEP] identifier[getProgressService] operator[SEP] operator[SEP] operator[SEP] identifier[run] operator[SEP] literal[boolean] , literal[boolean] , identifier[jarModule] operator[SEP] operator[SEP]
}
Keyword[catch] operator[SEP] identifier[Exception] identifier[e] operator[SEP] {
identifier[e] operator[SEP] identifier[printStackTrace] operator[SEP] operator[SEP] operator[SEP] Keyword[return] Other[null] operator[SEP]
}
identifier[File] identifier[jarFile] operator[=] identifier[jarModule] operator[SEP] identifier[getJarFile] operator[SEP] operator[SEP] operator[SEP] Keyword[if] operator[SEP] identifier[jarFile] operator[==] Other[null] operator[SEP] {
identifier[ErrorMessageDialog] operator[SEP] identifier[display] operator[SEP] literal[String] , literal[String] operator[SEP] operator[SEP] Keyword[return] Other[null] operator[SEP]
}
Keyword[return] identifier[jarFile] operator[SEP]
}
|
protected int persistHydrant(
FireHydrant indexToPersist,
DataSchema schema,
Interval interval,
Map<String, Object> metadataElems
)
{
synchronized (indexToPersist) {
if (indexToPersist.hasSwapped()) {
log.info(
"DataSource[%s], Interval[%s], Hydrant[%s] already swapped. Ignoring request to persist.",
schema.getDataSource(), interval, indexToPersist
);
return 0;
}
log.info(
"DataSource[%s], Interval[%s], Metadata [%s] persisting Hydrant[%s]",
schema.getDataSource(),
interval,
metadataElems,
indexToPersist
);
try {
int numRows = indexToPersist.getIndex().size();
final IndexSpec indexSpec = config.getIndexSpec();
indexToPersist.getIndex().getMetadata().putAll(metadataElems);
final File persistedFile = indexMerger.persist(
indexToPersist.getIndex(),
interval,
new File(computePersistDir(schema, interval), String.valueOf(indexToPersist.getCount())),
indexSpec,
config.getSegmentWriteOutMediumFactory()
);
indexToPersist.swapSegment(
new QueryableIndexSegment(indexIO.loadIndex(persistedFile), indexToPersist.getSegmentId())
);
return numRows;
}
catch (IOException e) {
log.makeAlert("dataSource[%s] -- incremental persist failed", schema.getDataSource())
.addData("interval", interval)
.addData("count", indexToPersist.getCount())
.emit();
throw new RuntimeException(e);
}
}
}
|
class class_name[name] begin[{]
method[persistHydrant, return_type[type[int]], modifier[protected], parameter[indexToPersist, schema, interval, metadataElems]] begin[{]
SYNCHRONIZED[member[.indexToPersist]] BEGIN[{]
if[call[indexToPersist.hasSwapped, parameter[]]] begin[{]
call[log.info, parameter[literal["DataSource[%s], Interval[%s], Hydrant[%s] already swapped. Ignoring request to persist."], call[schema.getDataSource, parameter[]], member[.interval], member[.indexToPersist]]]
return[literal[0]]
else begin[{]
None
end[}]
call[log.info, parameter[literal["DataSource[%s], Interval[%s], Metadata [%s] persisting Hydrant[%s]"], call[schema.getDataSource, parameter[]], member[.interval], member[.metadataElems], member[.indexToPersist]]]
TryStatement(block=[LocalVariableDeclaration(annotations=[], declarators=[VariableDeclarator(dimensions=[], initializer=MethodInvocation(arguments=[], member=getIndex, postfix_operators=[], prefix_operators=[], qualifier=indexToPersist, selectors=[MethodInvocation(arguments=[], member=size, postfix_operators=None, prefix_operators=None, qualifier=None, selectors=None, type_arguments=None)], type_arguments=None), name=numRows)], modifiers=set(), type=BasicType(dimensions=[], name=int)), LocalVariableDeclaration(annotations=[], declarators=[VariableDeclarator(dimensions=[], initializer=MethodInvocation(arguments=[], member=getIndexSpec, postfix_operators=[], prefix_operators=[], qualifier=config, selectors=[], type_arguments=None), name=indexSpec)], modifiers={'final'}, type=ReferenceType(arguments=None, dimensions=[], name=IndexSpec, sub_type=None)), StatementExpression(expression=MethodInvocation(arguments=[], member=getIndex, postfix_operators=[], prefix_operators=[], qualifier=indexToPersist, selectors=[MethodInvocation(arguments=[], member=getMetadata, postfix_operators=None, prefix_operators=None, qualifier=None, selectors=None, type_arguments=None), MethodInvocation(arguments=[MemberReference(member=metadataElems, postfix_operators=[], prefix_operators=[], qualifier=, selectors=[])], member=putAll, postfix_operators=None, prefix_operators=None, qualifier=None, selectors=None, type_arguments=None)], type_arguments=None), label=None), LocalVariableDeclaration(annotations=[], declarators=[VariableDeclarator(dimensions=[], initializer=MethodInvocation(arguments=[MethodInvocation(arguments=[], member=getIndex, postfix_operators=[], prefix_operators=[], qualifier=indexToPersist, selectors=[], type_arguments=None), MemberReference(member=interval, postfix_operators=[], prefix_operators=[], qualifier=, selectors=[]), ClassCreator(arguments=[MethodInvocation(arguments=[MemberReference(member=schema, postfix_operators=[], prefix_operators=[], qualifier=, selectors=[]), MemberReference(member=interval, postfix_operators=[], prefix_operators=[], qualifier=, selectors=[])], member=computePersistDir, postfix_operators=[], prefix_operators=[], qualifier=, selectors=[], type_arguments=None), MethodInvocation(arguments=[MethodInvocation(arguments=[], member=getCount, postfix_operators=[], prefix_operators=[], qualifier=indexToPersist, selectors=[], type_arguments=None)], member=valueOf, postfix_operators=[], prefix_operators=[], qualifier=String, selectors=[], type_arguments=None)], body=None, constructor_type_arguments=None, postfix_operators=[], prefix_operators=[], qualifier=None, selectors=[], type=ReferenceType(arguments=None, dimensions=None, name=File, sub_type=None)), MemberReference(member=indexSpec, postfix_operators=[], prefix_operators=[], qualifier=, selectors=[]), MethodInvocation(arguments=[], member=getSegmentWriteOutMediumFactory, postfix_operators=[], prefix_operators=[], qualifier=config, selectors=[], type_arguments=None)], member=persist, postfix_operators=[], prefix_operators=[], qualifier=indexMerger, selectors=[], type_arguments=None), name=persistedFile)], modifiers={'final'}, type=ReferenceType(arguments=None, dimensions=[], name=File, sub_type=None)), StatementExpression(expression=MethodInvocation(arguments=[ClassCreator(arguments=[MethodInvocation(arguments=[MemberReference(member=persistedFile, postfix_operators=[], prefix_operators=[], qualifier=, selectors=[])], member=loadIndex, postfix_operators=[], prefix_operators=[], qualifier=indexIO, selectors=[], type_arguments=None), MethodInvocation(arguments=[], member=getSegmentId, postfix_operators=[], prefix_operators=[], qualifier=indexToPersist, selectors=[], type_arguments=None)], body=None, constructor_type_arguments=None, postfix_operators=[], prefix_operators=[], qualifier=None, selectors=[], type=ReferenceType(arguments=None, dimensions=None, name=QueryableIndexSegment, sub_type=None))], member=swapSegment, postfix_operators=[], prefix_operators=[], qualifier=indexToPersist, selectors=[], type_arguments=None), label=None), ReturnStatement(expression=MemberReference(member=numRows, postfix_operators=[], prefix_operators=[], qualifier=, selectors=[]), label=None)], catches=[CatchClause(block=[StatementExpression(expression=MethodInvocation(arguments=[Literal(postfix_operators=[], prefix_operators=[], qualifier=None, selectors=[], value="dataSource[%s] -- incremental persist failed"), MethodInvocation(arguments=[], member=getDataSource, postfix_operators=[], prefix_operators=[], qualifier=schema, selectors=[], type_arguments=None)], member=makeAlert, postfix_operators=[], prefix_operators=[], qualifier=log, selectors=[MethodInvocation(arguments=[Literal(postfix_operators=[], prefix_operators=[], qualifier=None, selectors=[], value="interval"), MemberReference(member=interval, postfix_operators=[], prefix_operators=[], qualifier=, selectors=[])], member=addData, postfix_operators=None, prefix_operators=None, qualifier=None, selectors=None, type_arguments=None), MethodInvocation(arguments=[Literal(postfix_operators=[], prefix_operators=[], qualifier=None, selectors=[], value="count"), MethodInvocation(arguments=[], member=getCount, postfix_operators=[], prefix_operators=[], qualifier=indexToPersist, selectors=[], type_arguments=None)], member=addData, postfix_operators=None, prefix_operators=None, qualifier=None, selectors=None, type_arguments=None), MethodInvocation(arguments=[], member=emit, postfix_operators=None, prefix_operators=None, qualifier=None, selectors=None, type_arguments=None)], type_arguments=None), label=None), ThrowStatement(expression=ClassCreator(arguments=[MemberReference(member=e, postfix_operators=[], prefix_operators=[], qualifier=, selectors=[])], body=None, constructor_type_arguments=None, postfix_operators=[], prefix_operators=[], qualifier=None, selectors=[], type=ReferenceType(arguments=None, dimensions=None, name=RuntimeException, sub_type=None)), label=None)], label=None, parameter=CatchClauseParameter(annotations=None, modifiers=None, name=e, types=['IOException']))], finally_block=None, label=None, resources=None)
END[}]
end[}]
END[}]
|
Keyword[protected] Keyword[int] identifier[persistHydrant] operator[SEP] identifier[FireHydrant] identifier[indexToPersist] , identifier[DataSchema] identifier[schema] , identifier[Interval] identifier[interval] , identifier[Map] operator[<] identifier[String] , identifier[Object] operator[>] identifier[metadataElems] operator[SEP] {
Keyword[synchronized] operator[SEP] identifier[indexToPersist] operator[SEP] {
Keyword[if] operator[SEP] identifier[indexToPersist] operator[SEP] identifier[hasSwapped] operator[SEP] operator[SEP] operator[SEP] {
identifier[log] operator[SEP] identifier[info] operator[SEP] literal[String] , identifier[schema] operator[SEP] identifier[getDataSource] operator[SEP] operator[SEP] , identifier[interval] , identifier[indexToPersist] operator[SEP] operator[SEP] Keyword[return] Other[0] operator[SEP]
}
identifier[log] operator[SEP] identifier[info] operator[SEP] literal[String] , identifier[schema] operator[SEP] identifier[getDataSource] operator[SEP] operator[SEP] , identifier[interval] , identifier[metadataElems] , identifier[indexToPersist] operator[SEP] operator[SEP] Keyword[try] {
Keyword[int] identifier[numRows] operator[=] identifier[indexToPersist] operator[SEP] identifier[getIndex] operator[SEP] operator[SEP] operator[SEP] identifier[size] operator[SEP] operator[SEP] operator[SEP] Keyword[final] identifier[IndexSpec] identifier[indexSpec] operator[=] identifier[config] operator[SEP] identifier[getIndexSpec] operator[SEP] operator[SEP] operator[SEP] identifier[indexToPersist] operator[SEP] identifier[getIndex] operator[SEP] operator[SEP] operator[SEP] identifier[getMetadata] operator[SEP] operator[SEP] operator[SEP] identifier[putAll] operator[SEP] identifier[metadataElems] operator[SEP] operator[SEP] Keyword[final] identifier[File] identifier[persistedFile] operator[=] identifier[indexMerger] operator[SEP] identifier[persist] operator[SEP] identifier[indexToPersist] operator[SEP] identifier[getIndex] operator[SEP] operator[SEP] , identifier[interval] , Keyword[new] identifier[File] operator[SEP] identifier[computePersistDir] operator[SEP] identifier[schema] , identifier[interval] operator[SEP] , identifier[String] operator[SEP] identifier[valueOf] operator[SEP] identifier[indexToPersist] operator[SEP] identifier[getCount] operator[SEP] operator[SEP] operator[SEP] operator[SEP] , identifier[indexSpec] , identifier[config] operator[SEP] identifier[getSegmentWriteOutMediumFactory] operator[SEP] operator[SEP] operator[SEP] operator[SEP] identifier[indexToPersist] operator[SEP] identifier[swapSegment] operator[SEP] Keyword[new] identifier[QueryableIndexSegment] operator[SEP] identifier[indexIO] operator[SEP] identifier[loadIndex] operator[SEP] identifier[persistedFile] operator[SEP] , identifier[indexToPersist] operator[SEP] identifier[getSegmentId] operator[SEP] operator[SEP] operator[SEP] operator[SEP] operator[SEP] Keyword[return] identifier[numRows] operator[SEP]
}
Keyword[catch] operator[SEP] identifier[IOException] identifier[e] operator[SEP] {
identifier[log] operator[SEP] identifier[makeAlert] operator[SEP] literal[String] , identifier[schema] operator[SEP] identifier[getDataSource] operator[SEP] operator[SEP] operator[SEP] operator[SEP] identifier[addData] operator[SEP] literal[String] , identifier[interval] operator[SEP] operator[SEP] identifier[addData] operator[SEP] literal[String] , identifier[indexToPersist] operator[SEP] identifier[getCount] operator[SEP] operator[SEP] operator[SEP] operator[SEP] identifier[emit] operator[SEP] operator[SEP] operator[SEP] Keyword[throw] Keyword[new] identifier[RuntimeException] operator[SEP] identifier[e] operator[SEP] operator[SEP]
}
}
}
|
public static void validateStatusAtExecutionRestart(long previousExecutionId,
Properties restartJobParameters) throws JobRestartException, JobExecutionNotMostRecentException, JobExecutionAlreadyCompleteException {
Helper helper = new Helper(previousExecutionId, restartJobParameters);
helper.validateRestartableFalseJobsDoNotRestart();
helper.validateJobExecutionIsMostRecent();
helper.validateJobNotCompleteOrAbandonded();
helper.validateJobInstanceFailedOrStopped();
//Added starting since execution is now created on the Dispatcher
helper.validateJobExecutionFailedOrStoppedOrStarting();
helper.validateStepsAndPartitionsInNonFinalStates();
}
|
class class_name[name] begin[{]
method[validateStatusAtExecutionRestart, return_type[void], modifier[public static], parameter[previousExecutionId, restartJobParameters]] begin[{]
local_variable[type[Helper], helper]
call[helper.validateRestartableFalseJobsDoNotRestart, parameter[]]
call[helper.validateJobExecutionIsMostRecent, parameter[]]
call[helper.validateJobNotCompleteOrAbandonded, parameter[]]
call[helper.validateJobInstanceFailedOrStopped, parameter[]]
call[helper.validateJobExecutionFailedOrStoppedOrStarting, parameter[]]
call[helper.validateStepsAndPartitionsInNonFinalStates, parameter[]]
end[}]
END[}]
|
Keyword[public] Keyword[static] Keyword[void] identifier[validateStatusAtExecutionRestart] operator[SEP] Keyword[long] identifier[previousExecutionId] , identifier[Properties] identifier[restartJobParameters] operator[SEP] Keyword[throws] identifier[JobRestartException] , identifier[JobExecutionNotMostRecentException] , identifier[JobExecutionAlreadyCompleteException] {
identifier[Helper] identifier[helper] operator[=] Keyword[new] identifier[Helper] operator[SEP] identifier[previousExecutionId] , identifier[restartJobParameters] operator[SEP] operator[SEP] identifier[helper] operator[SEP] identifier[validateRestartableFalseJobsDoNotRestart] operator[SEP] operator[SEP] operator[SEP] identifier[helper] operator[SEP] identifier[validateJobExecutionIsMostRecent] operator[SEP] operator[SEP] operator[SEP] identifier[helper] operator[SEP] identifier[validateJobNotCompleteOrAbandonded] operator[SEP] operator[SEP] operator[SEP] identifier[helper] operator[SEP] identifier[validateJobInstanceFailedOrStopped] operator[SEP] operator[SEP] operator[SEP] identifier[helper] operator[SEP] identifier[validateJobExecutionFailedOrStoppedOrStarting] operator[SEP] operator[SEP] operator[SEP] identifier[helper] operator[SEP] identifier[validateStepsAndPartitionsInNonFinalStates] operator[SEP] operator[SEP] operator[SEP]
}
|
public static ByteBuffer clearAndEnsureCapacity(ByteBuffer buffer, int elements) {
if (buffer == null || buffer.capacity() < elements) {
buffer = ByteBuffer.allocate(elements);
} else {
buffer.clear();
}
return buffer;
}
|
class class_name[name] begin[{]
method[clearAndEnsureCapacity, return_type[type[ByteBuffer]], modifier[public static], parameter[buffer, elements]] begin[{]
if[binary_operation[binary_operation[member[.buffer], ==, literal[null]], ||, binary_operation[call[buffer.capacity, parameter[]], <, member[.elements]]]] begin[{]
assign[member[.buffer], call[ByteBuffer.allocate, parameter[member[.elements]]]]
else begin[{]
call[buffer.clear, parameter[]]
end[}]
return[member[.buffer]]
end[}]
END[}]
|
Keyword[public] Keyword[static] identifier[ByteBuffer] identifier[clearAndEnsureCapacity] operator[SEP] identifier[ByteBuffer] identifier[buffer] , Keyword[int] identifier[elements] operator[SEP] {
Keyword[if] operator[SEP] identifier[buffer] operator[==] Other[null] operator[||] identifier[buffer] operator[SEP] identifier[capacity] operator[SEP] operator[SEP] operator[<] identifier[elements] operator[SEP] {
identifier[buffer] operator[=] identifier[ByteBuffer] operator[SEP] identifier[allocate] operator[SEP] identifier[elements] operator[SEP] operator[SEP]
}
Keyword[else] {
identifier[buffer] operator[SEP] identifier[clear] operator[SEP] operator[SEP] operator[SEP]
}
Keyword[return] identifier[buffer] operator[SEP]
}
|
public static boolean copyDirectory(final File source, final File destination)
throws FileIsSecurityRestrictedException, IOException, FileIsADirectoryException,
FileIsNotADirectoryException, DirectoryAlreadyExistsException
{
return copyDirectory(source, destination, true);
}
|
class class_name[name] begin[{]
method[copyDirectory, return_type[type[boolean]], modifier[public static], parameter[source, destination]] begin[{]
return[call[.copyDirectory, parameter[member[.source], member[.destination], literal[true]]]]
end[}]
END[}]
|
Keyword[public] Keyword[static] Keyword[boolean] identifier[copyDirectory] operator[SEP] Keyword[final] identifier[File] identifier[source] , Keyword[final] identifier[File] identifier[destination] operator[SEP] Keyword[throws] identifier[FileIsSecurityRestrictedException] , identifier[IOException] , identifier[FileIsADirectoryException] , identifier[FileIsNotADirectoryException] , identifier[DirectoryAlreadyExistsException] {
Keyword[return] identifier[copyDirectory] operator[SEP] identifier[source] , identifier[destination] , literal[boolean] operator[SEP] operator[SEP]
}
|
public ReservedInstancesOffering withPricingDetails(PricingDetail... pricingDetails) {
if (this.pricingDetails == null) {
setPricingDetails(new com.amazonaws.internal.SdkInternalList<PricingDetail>(pricingDetails.length));
}
for (PricingDetail ele : pricingDetails) {
this.pricingDetails.add(ele);
}
return this;
}
|
class class_name[name] begin[{]
method[withPricingDetails, return_type[type[ReservedInstancesOffering]], modifier[public], parameter[pricingDetails]] begin[{]
if[binary_operation[THIS[member[None.pricingDetails]], ==, literal[null]]] begin[{]
call[.setPricingDetails, parameter[ClassCreator(arguments=[MemberReference(member=length, postfix_operators=[], prefix_operators=[], qualifier=pricingDetails, selectors=[])], body=None, constructor_type_arguments=None, postfix_operators=[], prefix_operators=[], qualifier=None, selectors=[], type=ReferenceType(arguments=None, dimensions=None, name=com, sub_type=ReferenceType(arguments=None, dimensions=None, name=amazonaws, sub_type=ReferenceType(arguments=None, dimensions=None, name=internal, sub_type=ReferenceType(arguments=[TypeArgument(pattern_type=None, type=ReferenceType(arguments=None, dimensions=[], name=PricingDetail, sub_type=None))], dimensions=None, name=SdkInternalList, sub_type=None)))))]]
else begin[{]
None
end[}]
ForStatement(body=BlockStatement(label=None, statements=[StatementExpression(expression=This(postfix_operators=[], prefix_operators=[], qualifier=None, selectors=[MemberReference(member=pricingDetails, postfix_operators=None, prefix_operators=None, qualifier=None, selectors=None), MethodInvocation(arguments=[MemberReference(member=ele, postfix_operators=[], prefix_operators=[], qualifier=, selectors=[])], member=add, postfix_operators=None, prefix_operators=None, qualifier=None, selectors=None, type_arguments=None)]), label=None)]), control=EnhancedForControl(iterable=MemberReference(member=pricingDetails, postfix_operators=[], prefix_operators=[], qualifier=, selectors=[]), var=VariableDeclaration(annotations=[], declarators=[VariableDeclarator(dimensions=None, initializer=None, name=ele)], modifiers=set(), type=ReferenceType(arguments=None, dimensions=[], name=PricingDetail, sub_type=None))), label=None)
return[THIS[]]
end[}]
END[}]
|
Keyword[public] identifier[ReservedInstancesOffering] identifier[withPricingDetails] operator[SEP] identifier[PricingDetail] operator[...] identifier[pricingDetails] operator[SEP] {
Keyword[if] operator[SEP] Keyword[this] operator[SEP] identifier[pricingDetails] operator[==] Other[null] operator[SEP] {
identifier[setPricingDetails] operator[SEP] Keyword[new] identifier[com] operator[SEP] identifier[amazonaws] operator[SEP] identifier[internal] operator[SEP] identifier[SdkInternalList] operator[<] identifier[PricingDetail] operator[>] operator[SEP] identifier[pricingDetails] operator[SEP] identifier[length] operator[SEP] operator[SEP] operator[SEP]
}
Keyword[for] operator[SEP] identifier[PricingDetail] identifier[ele] operator[:] identifier[pricingDetails] operator[SEP] {
Keyword[this] operator[SEP] identifier[pricingDetails] operator[SEP] identifier[add] operator[SEP] identifier[ele] operator[SEP] operator[SEP]
}
Keyword[return] Keyword[this] operator[SEP]
}
|
Expression get( int idx ) {
if( parameters.size() <= idx ) {
throw new ParameterOutOfBoundsException();
}
return parameters.get( idx );
}
|
class class_name[name] begin[{]
method[get, return_type[type[Expression]], modifier[default], parameter[idx]] begin[{]
if[binary_operation[call[parameters.size, parameter[]], <=, member[.idx]]] begin[{]
ThrowStatement(expression=ClassCreator(arguments=[], body=None, constructor_type_arguments=None, postfix_operators=[], prefix_operators=[], qualifier=None, selectors=[], type=ReferenceType(arguments=None, dimensions=None, name=ParameterOutOfBoundsException, sub_type=None)), label=None)
else begin[{]
None
end[}]
return[call[parameters.get, parameter[member[.idx]]]]
end[}]
END[}]
|
identifier[Expression] identifier[get] operator[SEP] Keyword[int] identifier[idx] operator[SEP] {
Keyword[if] operator[SEP] identifier[parameters] operator[SEP] identifier[size] operator[SEP] operator[SEP] operator[<=] identifier[idx] operator[SEP] {
Keyword[throw] Keyword[new] identifier[ParameterOutOfBoundsException] operator[SEP] operator[SEP] operator[SEP]
}
Keyword[return] identifier[parameters] operator[SEP] identifier[get] operator[SEP] identifier[idx] operator[SEP] operator[SEP]
}
|
public static String getFileAsString(File file) throws FileNotFoundException, IOException {
byte[] inputbytes;
try (RandomAccessFile inputFile = new RandomAccessFile(file, "r")) {
int length = (int) inputFile.length();
inputbytes = new byte[length];
int numread = inputFile.read(inputbytes);
}
return new String(inputbytes);
}
|
class class_name[name] begin[{]
method[getFileAsString, return_type[type[String]], modifier[public static], parameter[file]] begin[{]
local_variable[type[byte], inputbytes]
TryStatement(block=[LocalVariableDeclaration(annotations=[], declarators=[VariableDeclarator(dimensions=[], initializer=Cast(expression=MethodInvocation(arguments=[], member=length, postfix_operators=[], prefix_operators=[], qualifier=inputFile, selectors=[], type_arguments=None), type=BasicType(dimensions=[], name=int)), name=length)], modifiers=set(), type=BasicType(dimensions=[], name=int)), StatementExpression(expression=Assignment(expressionl=MemberReference(member=inputbytes, postfix_operators=[], prefix_operators=[], qualifier=, selectors=[]), type==, value=ArrayCreator(dimensions=[MemberReference(member=length, postfix_operators=[], prefix_operators=[], qualifier=, selectors=[])], initializer=None, postfix_operators=[], prefix_operators=[], qualifier=None, selectors=[], type=BasicType(dimensions=None, name=byte))), label=None), LocalVariableDeclaration(annotations=[], declarators=[VariableDeclarator(dimensions=[], initializer=MethodInvocation(arguments=[MemberReference(member=inputbytes, postfix_operators=[], prefix_operators=[], qualifier=, selectors=[])], member=read, postfix_operators=[], prefix_operators=[], qualifier=inputFile, selectors=[], type_arguments=None), name=numread)], modifiers=set(), type=BasicType(dimensions=[], name=int))], catches=None, finally_block=None, label=None, resources=[TryResource(annotations=[], modifiers=set(), name=inputFile, type=ReferenceType(arguments=None, dimensions=[], name=RandomAccessFile, sub_type=None), value=ClassCreator(arguments=[MemberReference(member=file, postfix_operators=[], prefix_operators=[], qualifier=, selectors=[]), Literal(postfix_operators=[], prefix_operators=[], qualifier=None, selectors=[], value="r")], body=None, constructor_type_arguments=None, postfix_operators=[], prefix_operators=[], qualifier=None, selectors=[], type=ReferenceType(arguments=None, dimensions=None, name=RandomAccessFile, sub_type=None)))])
return[ClassCreator(arguments=[MemberReference(member=inputbytes, postfix_operators=[], prefix_operators=[], qualifier=, selectors=[])], body=None, constructor_type_arguments=None, postfix_operators=[], prefix_operators=[], qualifier=None, selectors=[], type=ReferenceType(arguments=None, dimensions=None, name=String, sub_type=None))]
end[}]
END[}]
|
Keyword[public] Keyword[static] identifier[String] identifier[getFileAsString] operator[SEP] identifier[File] identifier[file] operator[SEP] Keyword[throws] identifier[FileNotFoundException] , identifier[IOException] {
Keyword[byte] operator[SEP] operator[SEP] identifier[inputbytes] operator[SEP] Keyword[try] operator[SEP] identifier[RandomAccessFile] identifier[inputFile] operator[=] Keyword[new] identifier[RandomAccessFile] operator[SEP] identifier[file] , literal[String] operator[SEP] operator[SEP] {
Keyword[int] identifier[length] operator[=] operator[SEP] Keyword[int] operator[SEP] identifier[inputFile] operator[SEP] identifier[length] operator[SEP] operator[SEP] operator[SEP] identifier[inputbytes] operator[=] Keyword[new] Keyword[byte] operator[SEP] identifier[length] operator[SEP] operator[SEP] Keyword[int] identifier[numread] operator[=] identifier[inputFile] operator[SEP] identifier[read] operator[SEP] identifier[inputbytes] operator[SEP] operator[SEP]
}
Keyword[return] Keyword[new] identifier[String] operator[SEP] identifier[inputbytes] operator[SEP] operator[SEP]
}
|
public void set(V newReference, int newStamp) {
Pair<V> current = pair;
if (newReference != current.reference || newStamp != current.stamp)
this.pair = Pair.of(newReference, newStamp);
}
|
class class_name[name] begin[{]
method[set, return_type[void], modifier[public], parameter[newReference, newStamp]] begin[{]
local_variable[type[Pair], current]
if[binary_operation[binary_operation[member[.newReference], !=, member[current.reference]], ||, binary_operation[member[.newStamp], !=, member[current.stamp]]]] begin[{]
assign[THIS[member[None.pair]], call[Pair.of, parameter[member[.newReference], member[.newStamp]]]]
else begin[{]
None
end[}]
end[}]
END[}]
|
Keyword[public] Keyword[void] identifier[set] operator[SEP] identifier[V] identifier[newReference] , Keyword[int] identifier[newStamp] operator[SEP] {
identifier[Pair] operator[<] identifier[V] operator[>] identifier[current] operator[=] identifier[pair] operator[SEP] Keyword[if] operator[SEP] identifier[newReference] operator[!=] identifier[current] operator[SEP] identifier[reference] operator[||] identifier[newStamp] operator[!=] identifier[current] operator[SEP] identifier[stamp] operator[SEP] Keyword[this] operator[SEP] identifier[pair] operator[=] identifier[Pair] operator[SEP] identifier[of] operator[SEP] identifier[newReference] , identifier[newStamp] operator[SEP] operator[SEP]
}
|
protected double probTB(IntDependency dependency) {
if (verbose) {
// System.out.println("tagIndex: " + tagIndex);
System.err.println("Generating " + dependency);
}
boolean leftHeaded = dependency.leftHeaded && directional;
int hW = dependency.head.word;
int aW = dependency.arg.word;
short hT = dependency.head.tag;
short aT = dependency.arg.tag;
IntTaggedWord aTW = dependency.arg;
IntTaggedWord hTW = dependency.head;
boolean isRoot = rootTW(dependency.head);
double pb_stop_hTWds;
if (isRoot) {
pb_stop_hTWds = 0.0;
} else {
pb_stop_hTWds = getStopProb(dependency);
}
if (dependency.arg.word == STOP_WORD_INT) {
// did we generate stop?
return pb_stop_hTWds;
}
double pb_go_hTWds = 1.0 - pb_stop_hTWds;
// generate the argument
short binDistance = valenceBin(dependency.distance);
// KEY:
// c_ count of (read as joint count of first and second)
// p_ MLE prob of (or MAP if useSmoothTagProjection)
// pb_ MAP prob of (read as prob of first given second thing)
// a arg
// h head
// T tag
// PT projected tag
// W word
// d direction
// ds distance (implicit: there when direction is mentioned!)
IntTaggedWord anyHead = new IntTaggedWord(ANY_WORD_INT, dependency.head.tag);
IntTaggedWord anyArg = new IntTaggedWord(ANY_WORD_INT, dependency.arg.tag);
IntTaggedWord anyTagArg = new IntTaggedWord(dependency.arg.word, ANY_TAG_INT);
IntDependency temp = new IntDependency(dependency.head, dependency.arg, leftHeaded, binDistance);
double c_aTW_hTWd = argCounter.getCount(temp);
temp = new IntDependency(dependency.head, anyArg, leftHeaded, binDistance);
double c_aT_hTWd = argCounter.getCount(temp);
temp = new IntDependency(dependency.head, wildTW, leftHeaded, binDistance);
double c_hTWd = argCounter.getCount(temp);
temp = new IntDependency(anyHead, dependency.arg, leftHeaded, binDistance);
double c_aTW_hTd = argCounter.getCount(temp);
temp = new IntDependency(anyHead, anyArg, leftHeaded, binDistance);
double c_aT_hTd = argCounter.getCount(temp);
temp = new IntDependency(anyHead, wildTW, leftHeaded, binDistance);
double c_hTd = argCounter.getCount(temp);
// for smooth tag projection
short aPT = Short.MIN_VALUE;
double c_aPTW_hPTd = Double.NaN;
double c_aPT_hPTd = Double.NaN;
double c_hPTd = Double.NaN;
double c_aPTW_aPT = Double.NaN;
double c_aPT = Double.NaN;
if (useSmoothTagProjection) {
aPT = tagProject(dependency.arg.tag);
short hPT = tagProject(dependency.head.tag);
IntTaggedWord projectedArg = new IntTaggedWord(dependency.arg.word, aPT);
IntTaggedWord projectedAnyHead = new IntTaggedWord(ANY_WORD_INT, hPT);
IntTaggedWord projectedAnyArg = new IntTaggedWord(ANY_WORD_INT, aPT);
temp = new IntDependency(projectedAnyHead, projectedArg, leftHeaded, binDistance);
c_aPTW_hPTd = argCounter.getCount(temp);
temp = new IntDependency(projectedAnyHead, projectedAnyArg, leftHeaded, binDistance);
c_aPT_hPTd = argCounter.getCount(temp);
temp = new IntDependency(projectedAnyHead, wildTW, leftHeaded, binDistance);
c_hPTd = argCounter.getCount(temp);
temp = new IntDependency(wildTW, projectedArg, false, ANY_DISTANCE_INT);
c_aPTW_aPT = argCounter.getCount(temp);
temp = new IntDependency(wildTW, projectedAnyArg, false, ANY_DISTANCE_INT);
c_aPT = argCounter.getCount(temp);
}
// wild head is always directionless and no use distance
temp = new IntDependency(wildTW, dependency.arg, false, ANY_DISTANCE_INT);
double c_aTW = argCounter.getCount(temp);
temp = new IntDependency(wildTW, anyArg, false, ANY_DISTANCE_INT);
double c_aT = argCounter.getCount(temp);
temp = new IntDependency(wildTW, anyTagArg, false, ANY_DISTANCE_INT);
double c_aW = argCounter.getCount(temp);
// do the Bayesian magic
// MLE probs
double p_aTW_hTd;
double p_aT_hTd;
double p_aTW_aT;
double p_aW;
double p_aPTW_aPT;
double p_aPTW_hPTd;
double p_aPT_hPTd;
// backoffs either mle or themselves bayesian smoothed depending on useSmoothTagProjection
if (useSmoothTagProjection) {
if (useUnigramWordSmoothing) {
p_aW = c_aW > 0.0 ? (c_aW / numWordTokens) : 1.0; // NEED this 1.0 for unknown words!!!
p_aPTW_aPT = (c_aPTW_aPT + smooth_aPTW_aPT * p_aW) / (c_aPT + smooth_aPTW_aPT);
} else {
p_aPTW_aPT = c_aPTW_aPT > 0.0 ? (c_aPTW_aPT / c_aPT) : 1.0; // NEED this 1.0 for unknown words!!!
}
p_aTW_aT = (c_aTW + smooth_aTW_aT * p_aPTW_aPT) / (c_aT + smooth_aTW_aT);
p_aPTW_hPTd = c_hPTd > 0.0 ? (c_aPTW_hPTd / c_hPTd): 0.0;
p_aTW_hTd = (c_aTW_hTd + smooth_aTW_hTd * p_aPTW_hPTd) / (c_hTd + smooth_aTW_hTd);
p_aPT_hPTd = c_hPTd > 0.0 ? (c_aPT_hPTd / c_hPTd) : 0.0;
p_aT_hTd = (c_aT_hTd + smooth_aT_hTd * p_aPT_hPTd) / (c_hTd + smooth_aT_hTd);
} else {
// here word generation isn't smoothed - can't get previously unseen word with tag. Ugh.
if (op.testOptions.useLexiconToScoreDependencyPwGt) {
// We don't know the position. Now -1 means average over 0 and 1.
p_aTW_aT = dependency.leftHeaded ? Math.exp(lex.score(dependency.arg, 1, wordIndex.get(dependency.arg.word))): Math.exp(lex.score(dependency.arg, -1, wordIndex.get(dependency.arg.word)));
// double oldScore = c_aTW > 0.0 ? (c_aTW / c_aT) : 1.0;
// if (oldScore == 1.0) {
// System.err.println("#### arg=" + dependency.arg + " score=" + p_aTW_aT +
// " oldScore=" + oldScore + " c_aTW=" + c_aTW + " c_aW=" + c_aW);
// }
} else {
p_aTW_aT = c_aTW > 0.0 ? (c_aTW / c_aT) : 1.0;
}
p_aTW_hTd = c_hTd > 0.0 ? (c_aTW_hTd / c_hTd) : 0.0;
p_aT_hTd = c_hTd > 0.0 ? (c_aT_hTd / c_hTd) : 0.0;
}
double pb_aTW_hTWd = (c_aTW_hTWd + smooth_aTW_hTWd * p_aTW_hTd) / (c_hTWd + smooth_aTW_hTWd);
double pb_aT_hTWd = (c_aT_hTWd + smooth_aT_hTWd * p_aT_hTd) / (c_hTWd + smooth_aT_hTWd);
double score = (interp * pb_aTW_hTWd + (1.0 - interp) * p_aTW_aT * pb_aT_hTWd) * pb_go_hTWds;
if (verbose) {
NumberFormat nf = NumberFormat.getNumberInstance();
nf.setMaximumFractionDigits(2);
if (useSmoothTagProjection) {
if (useUnigramWordSmoothing) {
System.err.println(" c_aW=" + c_aW + ", numWordTokens=" + numWordTokens + ", p(aW)=" + nf.format(p_aW));
}
System.err.println(" c_aPTW_aPT=" + c_aPTW_aPT + ", c_aPT=" + c_aPT + ", smooth_aPTW_aPT=" + smooth_aPTW_aPT + ", p(aPTW|aPT)=" + nf.format(p_aPTW_aPT));
}
System.err.println(" c_aTW=" + c_aTW + ", c_aT=" + c_aT + ", smooth_aTW_aT=" + smooth_aTW_aT +", ## p(aTW|aT)=" + nf.format(p_aTW_aT));
if (useSmoothTagProjection) {
System.err.println(" c_aPTW_hPTd=" + c_aPTW_hPTd + ", c_hPTd=" + c_hPTd + ", p(aPTW|hPTd)=" + nf.format(p_aPTW_hPTd));
}
System.err.println(" c_aTW_hTd=" + c_aTW_hTd + ", c_hTd=" + c_hTd + ", smooth_aTW_hTd=" + smooth_aTW_hTd +", p(aTW|hTd)=" + nf.format(p_aTW_hTd));
if (useSmoothTagProjection) {
System.err.println(" c_aPT_hPTd=" + c_aPT_hPTd + ", c_hPTd=" + c_hPTd + ", p(aPT|hPTd)=" + nf.format(p_aPT_hPTd));
}
System.err.println(" c_aT_hTd=" + c_aT_hTd + ", c_hTd=" + c_hTd + ", smooth_aT_hTd=" + smooth_aT_hTd +", p(aT|hTd)=" + nf.format(p_aT_hTd));
System.err.println(" c_aTW_hTWd=" + c_aTW_hTWd + ", c_hTWd=" + c_hTWd + ", smooth_aTW_hTWd=" + smooth_aTW_hTWd +", ## p(aTW|hTWd)=" + nf.format(pb_aTW_hTWd));
System.err.println(" c_aT_hTWd=" + c_aT_hTWd + ", c_hTWd=" + c_hTWd + ", smooth_aT_hTWd=" + smooth_aT_hTWd +", ## p(aT|hTWd)=" + nf.format(pb_aT_hTWd));
System.err.println(" interp=" + interp + ", prescore=" + nf.format(interp * pb_aTW_hTWd + (1.0 - interp) * p_aTW_aT * pb_aT_hTWd) +
", P(go|hTWds)=" + nf.format(pb_go_hTWds) + ", score=" + nf.format(score));
}
if (op.testOptions.prunePunc && pruneTW(aTW)) {
return 1.0;
}
if (Double.isNaN(score)) {
score = 0.0;
}
//if (op.testOptions.rightBonus && ! dependency.leftHeaded)
// score -= 0.2;
if (score < MIN_PROBABILITY) {
score = 0.0;
}
return score;
}
|
class class_name[name] begin[{]
method[probTB, return_type[type[double]], modifier[protected], parameter[dependency]] begin[{]
if[member[.verbose]] begin[{]
call[System.err.println, parameter[binary_operation[literal["Generating "], +, member[.dependency]]]]
else begin[{]
None
end[}]
local_variable[type[boolean], leftHeaded]
local_variable[type[int], hW]
local_variable[type[int], aW]
local_variable[type[short], hT]
local_variable[type[short], aT]
local_variable[type[IntTaggedWord], aTW]
local_variable[type[IntTaggedWord], hTW]
local_variable[type[boolean], isRoot]
local_variable[type[double], pb_stop_hTWds]
if[member[.isRoot]] begin[{]
assign[member[.pb_stop_hTWds], literal[0.0]]
else begin[{]
assign[member[.pb_stop_hTWds], call[.getStopProb, parameter[member[.dependency]]]]
end[}]
if[binary_operation[member[dependency.arg.word], ==, member[.STOP_WORD_INT]]] begin[{]
return[member[.pb_stop_hTWds]]
else begin[{]
None
end[}]
local_variable[type[double], pb_go_hTWds]
local_variable[type[short], binDistance]
local_variable[type[IntTaggedWord], anyHead]
local_variable[type[IntTaggedWord], anyArg]
local_variable[type[IntTaggedWord], anyTagArg]
local_variable[type[IntDependency], temp]
local_variable[type[double], c_aTW_hTWd]
assign[member[.temp], ClassCreator(arguments=[MemberReference(member=head, postfix_operators=[], prefix_operators=[], qualifier=dependency, selectors=[]), MemberReference(member=anyArg, postfix_operators=[], prefix_operators=[], qualifier=, selectors=[]), MemberReference(member=leftHeaded, postfix_operators=[], prefix_operators=[], qualifier=, selectors=[]), MemberReference(member=binDistance, postfix_operators=[], prefix_operators=[], qualifier=, selectors=[])], body=None, constructor_type_arguments=None, postfix_operators=[], prefix_operators=[], qualifier=None, selectors=[], type=ReferenceType(arguments=None, dimensions=None, name=IntDependency, sub_type=None))]
local_variable[type[double], c_aT_hTWd]
assign[member[.temp], ClassCreator(arguments=[MemberReference(member=head, postfix_operators=[], prefix_operators=[], qualifier=dependency, selectors=[]), MemberReference(member=wildTW, postfix_operators=[], prefix_operators=[], qualifier=, selectors=[]), MemberReference(member=leftHeaded, postfix_operators=[], prefix_operators=[], qualifier=, selectors=[]), MemberReference(member=binDistance, postfix_operators=[], prefix_operators=[], qualifier=, selectors=[])], body=None, constructor_type_arguments=None, postfix_operators=[], prefix_operators=[], qualifier=None, selectors=[], type=ReferenceType(arguments=None, dimensions=None, name=IntDependency, sub_type=None))]
local_variable[type[double], c_hTWd]
assign[member[.temp], ClassCreator(arguments=[MemberReference(member=anyHead, postfix_operators=[], prefix_operators=[], qualifier=, selectors=[]), MemberReference(member=arg, postfix_operators=[], prefix_operators=[], qualifier=dependency, selectors=[]), MemberReference(member=leftHeaded, postfix_operators=[], prefix_operators=[], qualifier=, selectors=[]), MemberReference(member=binDistance, postfix_operators=[], prefix_operators=[], qualifier=, selectors=[])], body=None, constructor_type_arguments=None, postfix_operators=[], prefix_operators=[], qualifier=None, selectors=[], type=ReferenceType(arguments=None, dimensions=None, name=IntDependency, sub_type=None))]
local_variable[type[double], c_aTW_hTd]
assign[member[.temp], ClassCreator(arguments=[MemberReference(member=anyHead, postfix_operators=[], prefix_operators=[], qualifier=, selectors=[]), MemberReference(member=anyArg, postfix_operators=[], prefix_operators=[], qualifier=, selectors=[]), MemberReference(member=leftHeaded, postfix_operators=[], prefix_operators=[], qualifier=, selectors=[]), MemberReference(member=binDistance, postfix_operators=[], prefix_operators=[], qualifier=, selectors=[])], body=None, constructor_type_arguments=None, postfix_operators=[], prefix_operators=[], qualifier=None, selectors=[], type=ReferenceType(arguments=None, dimensions=None, name=IntDependency, sub_type=None))]
local_variable[type[double], c_aT_hTd]
assign[member[.temp], ClassCreator(arguments=[MemberReference(member=anyHead, postfix_operators=[], prefix_operators=[], qualifier=, selectors=[]), MemberReference(member=wildTW, postfix_operators=[], prefix_operators=[], qualifier=, selectors=[]), MemberReference(member=leftHeaded, postfix_operators=[], prefix_operators=[], qualifier=, selectors=[]), MemberReference(member=binDistance, postfix_operators=[], prefix_operators=[], qualifier=, selectors=[])], body=None, constructor_type_arguments=None, postfix_operators=[], prefix_operators=[], qualifier=None, selectors=[], type=ReferenceType(arguments=None, dimensions=None, name=IntDependency, sub_type=None))]
local_variable[type[double], c_hTd]
local_variable[type[short], aPT]
local_variable[type[double], c_aPTW_hPTd]
local_variable[type[double], c_aPT_hPTd]
local_variable[type[double], c_hPTd]
local_variable[type[double], c_aPTW_aPT]
local_variable[type[double], c_aPT]
if[member[.useSmoothTagProjection]] begin[{]
assign[member[.aPT], call[.tagProject, parameter[member[dependency.arg.tag]]]]
local_variable[type[short], hPT]
local_variable[type[IntTaggedWord], projectedArg]
local_variable[type[IntTaggedWord], projectedAnyHead]
local_variable[type[IntTaggedWord], projectedAnyArg]
assign[member[.temp], ClassCreator(arguments=[MemberReference(member=projectedAnyHead, postfix_operators=[], prefix_operators=[], qualifier=, selectors=[]), MemberReference(member=projectedArg, postfix_operators=[], prefix_operators=[], qualifier=, selectors=[]), MemberReference(member=leftHeaded, postfix_operators=[], prefix_operators=[], qualifier=, selectors=[]), MemberReference(member=binDistance, postfix_operators=[], prefix_operators=[], qualifier=, selectors=[])], body=None, constructor_type_arguments=None, postfix_operators=[], prefix_operators=[], qualifier=None, selectors=[], type=ReferenceType(arguments=None, dimensions=None, name=IntDependency, sub_type=None))]
assign[member[.c_aPTW_hPTd], call[argCounter.getCount, parameter[member[.temp]]]]
assign[member[.temp], ClassCreator(arguments=[MemberReference(member=projectedAnyHead, postfix_operators=[], prefix_operators=[], qualifier=, selectors=[]), MemberReference(member=projectedAnyArg, postfix_operators=[], prefix_operators=[], qualifier=, selectors=[]), MemberReference(member=leftHeaded, postfix_operators=[], prefix_operators=[], qualifier=, selectors=[]), MemberReference(member=binDistance, postfix_operators=[], prefix_operators=[], qualifier=, selectors=[])], body=None, constructor_type_arguments=None, postfix_operators=[], prefix_operators=[], qualifier=None, selectors=[], type=ReferenceType(arguments=None, dimensions=None, name=IntDependency, sub_type=None))]
assign[member[.c_aPT_hPTd], call[argCounter.getCount, parameter[member[.temp]]]]
assign[member[.temp], ClassCreator(arguments=[MemberReference(member=projectedAnyHead, postfix_operators=[], prefix_operators=[], qualifier=, selectors=[]), MemberReference(member=wildTW, postfix_operators=[], prefix_operators=[], qualifier=, selectors=[]), MemberReference(member=leftHeaded, postfix_operators=[], prefix_operators=[], qualifier=, selectors=[]), MemberReference(member=binDistance, postfix_operators=[], prefix_operators=[], qualifier=, selectors=[])], body=None, constructor_type_arguments=None, postfix_operators=[], prefix_operators=[], qualifier=None, selectors=[], type=ReferenceType(arguments=None, dimensions=None, name=IntDependency, sub_type=None))]
assign[member[.c_hPTd], call[argCounter.getCount, parameter[member[.temp]]]]
assign[member[.temp], ClassCreator(arguments=[MemberReference(member=wildTW, postfix_operators=[], prefix_operators=[], qualifier=, selectors=[]), MemberReference(member=projectedArg, postfix_operators=[], prefix_operators=[], qualifier=, selectors=[]), Literal(postfix_operators=[], prefix_operators=[], qualifier=None, selectors=[], value=false), MemberReference(member=ANY_DISTANCE_INT, postfix_operators=[], prefix_operators=[], qualifier=, selectors=[])], body=None, constructor_type_arguments=None, postfix_operators=[], prefix_operators=[], qualifier=None, selectors=[], type=ReferenceType(arguments=None, dimensions=None, name=IntDependency, sub_type=None))]
assign[member[.c_aPTW_aPT], call[argCounter.getCount, parameter[member[.temp]]]]
assign[member[.temp], ClassCreator(arguments=[MemberReference(member=wildTW, postfix_operators=[], prefix_operators=[], qualifier=, selectors=[]), MemberReference(member=projectedAnyArg, postfix_operators=[], prefix_operators=[], qualifier=, selectors=[]), Literal(postfix_operators=[], prefix_operators=[], qualifier=None, selectors=[], value=false), MemberReference(member=ANY_DISTANCE_INT, postfix_operators=[], prefix_operators=[], qualifier=, selectors=[])], body=None, constructor_type_arguments=None, postfix_operators=[], prefix_operators=[], qualifier=None, selectors=[], type=ReferenceType(arguments=None, dimensions=None, name=IntDependency, sub_type=None))]
assign[member[.c_aPT], call[argCounter.getCount, parameter[member[.temp]]]]
else begin[{]
None
end[}]
assign[member[.temp], ClassCreator(arguments=[MemberReference(member=wildTW, postfix_operators=[], prefix_operators=[], qualifier=, selectors=[]), MemberReference(member=arg, postfix_operators=[], prefix_operators=[], qualifier=dependency, selectors=[]), Literal(postfix_operators=[], prefix_operators=[], qualifier=None, selectors=[], value=false), MemberReference(member=ANY_DISTANCE_INT, postfix_operators=[], prefix_operators=[], qualifier=, selectors=[])], body=None, constructor_type_arguments=None, postfix_operators=[], prefix_operators=[], qualifier=None, selectors=[], type=ReferenceType(arguments=None, dimensions=None, name=IntDependency, sub_type=None))]
local_variable[type[double], c_aTW]
assign[member[.temp], ClassCreator(arguments=[MemberReference(member=wildTW, postfix_operators=[], prefix_operators=[], qualifier=, selectors=[]), MemberReference(member=anyArg, postfix_operators=[], prefix_operators=[], qualifier=, selectors=[]), Literal(postfix_operators=[], prefix_operators=[], qualifier=None, selectors=[], value=false), MemberReference(member=ANY_DISTANCE_INT, postfix_operators=[], prefix_operators=[], qualifier=, selectors=[])], body=None, constructor_type_arguments=None, postfix_operators=[], prefix_operators=[], qualifier=None, selectors=[], type=ReferenceType(arguments=None, dimensions=None, name=IntDependency, sub_type=None))]
local_variable[type[double], c_aT]
assign[member[.temp], ClassCreator(arguments=[MemberReference(member=wildTW, postfix_operators=[], prefix_operators=[], qualifier=, selectors=[]), MemberReference(member=anyTagArg, postfix_operators=[], prefix_operators=[], qualifier=, selectors=[]), Literal(postfix_operators=[], prefix_operators=[], qualifier=None, selectors=[], value=false), MemberReference(member=ANY_DISTANCE_INT, postfix_operators=[], prefix_operators=[], qualifier=, selectors=[])], body=None, constructor_type_arguments=None, postfix_operators=[], prefix_operators=[], qualifier=None, selectors=[], type=ReferenceType(arguments=None, dimensions=None, name=IntDependency, sub_type=None))]
local_variable[type[double], c_aW]
local_variable[type[double], p_aTW_hTd]
local_variable[type[double], p_aT_hTd]
local_variable[type[double], p_aTW_aT]
local_variable[type[double], p_aW]
local_variable[type[double], p_aPTW_aPT]
local_variable[type[double], p_aPTW_hPTd]
local_variable[type[double], p_aPT_hPTd]
if[member[.useSmoothTagProjection]] begin[{]
if[member[.useUnigramWordSmoothing]] begin[{]
assign[member[.p_aW], TernaryExpression(condition=BinaryOperation(operandl=MemberReference(member=c_aW, postfix_operators=[], prefix_operators=[], qualifier=, selectors=[]), operandr=Literal(postfix_operators=[], prefix_operators=[], qualifier=None, selectors=[], value=0.0), operator=>), if_false=Literal(postfix_operators=[], prefix_operators=[], qualifier=None, selectors=[], value=1.0), if_true=BinaryOperation(operandl=MemberReference(member=c_aW, postfix_operators=[], prefix_operators=[], qualifier=, selectors=[]), operandr=MemberReference(member=numWordTokens, postfix_operators=[], prefix_operators=[], qualifier=, selectors=[]), operator=/))]
assign[member[.p_aPTW_aPT], binary_operation[binary_operation[member[.c_aPTW_aPT], +, binary_operation[member[.smooth_aPTW_aPT], *, member[.p_aW]]], /, binary_operation[member[.c_aPT], +, member[.smooth_aPTW_aPT]]]]
else begin[{]
assign[member[.p_aPTW_aPT], TernaryExpression(condition=BinaryOperation(operandl=MemberReference(member=c_aPTW_aPT, postfix_operators=[], prefix_operators=[], qualifier=, selectors=[]), operandr=Literal(postfix_operators=[], prefix_operators=[], qualifier=None, selectors=[], value=0.0), operator=>), if_false=Literal(postfix_operators=[], prefix_operators=[], qualifier=None, selectors=[], value=1.0), if_true=BinaryOperation(operandl=MemberReference(member=c_aPTW_aPT, postfix_operators=[], prefix_operators=[], qualifier=, selectors=[]), operandr=MemberReference(member=c_aPT, postfix_operators=[], prefix_operators=[], qualifier=, selectors=[]), operator=/))]
end[}]
assign[member[.p_aTW_aT], binary_operation[binary_operation[member[.c_aTW], +, binary_operation[member[.smooth_aTW_aT], *, member[.p_aPTW_aPT]]], /, binary_operation[member[.c_aT], +, member[.smooth_aTW_aT]]]]
assign[member[.p_aPTW_hPTd], TernaryExpression(condition=BinaryOperation(operandl=MemberReference(member=c_hPTd, postfix_operators=[], prefix_operators=[], qualifier=, selectors=[]), operandr=Literal(postfix_operators=[], prefix_operators=[], qualifier=None, selectors=[], value=0.0), operator=>), if_false=Literal(postfix_operators=[], prefix_operators=[], qualifier=None, selectors=[], value=0.0), if_true=BinaryOperation(operandl=MemberReference(member=c_aPTW_hPTd, postfix_operators=[], prefix_operators=[], qualifier=, selectors=[]), operandr=MemberReference(member=c_hPTd, postfix_operators=[], prefix_operators=[], qualifier=, selectors=[]), operator=/))]
assign[member[.p_aTW_hTd], binary_operation[binary_operation[member[.c_aTW_hTd], +, binary_operation[member[.smooth_aTW_hTd], *, member[.p_aPTW_hPTd]]], /, binary_operation[member[.c_hTd], +, member[.smooth_aTW_hTd]]]]
assign[member[.p_aPT_hPTd], TernaryExpression(condition=BinaryOperation(operandl=MemberReference(member=c_hPTd, postfix_operators=[], prefix_operators=[], qualifier=, selectors=[]), operandr=Literal(postfix_operators=[], prefix_operators=[], qualifier=None, selectors=[], value=0.0), operator=>), if_false=Literal(postfix_operators=[], prefix_operators=[], qualifier=None, selectors=[], value=0.0), if_true=BinaryOperation(operandl=MemberReference(member=c_aPT_hPTd, postfix_operators=[], prefix_operators=[], qualifier=, selectors=[]), operandr=MemberReference(member=c_hPTd, postfix_operators=[], prefix_operators=[], qualifier=, selectors=[]), operator=/))]
assign[member[.p_aT_hTd], binary_operation[binary_operation[member[.c_aT_hTd], +, binary_operation[member[.smooth_aT_hTd], *, member[.p_aPT_hPTd]]], /, binary_operation[member[.c_hTd], +, member[.smooth_aT_hTd]]]]
else begin[{]
if[member[op.testOptions.useLexiconToScoreDependencyPwGt]] begin[{]
assign[member[.p_aTW_aT], TernaryExpression(condition=MemberReference(member=leftHeaded, postfix_operators=[], prefix_operators=[], qualifier=dependency, selectors=[]), if_false=MethodInvocation(arguments=[MethodInvocation(arguments=[MemberReference(member=arg, postfix_operators=[], prefix_operators=[], qualifier=dependency, selectors=[]), Literal(postfix_operators=[], prefix_operators=['-'], qualifier=None, selectors=[], value=1), MethodInvocation(arguments=[MemberReference(member=word, postfix_operators=[], prefix_operators=[], qualifier=dependency.arg, selectors=[])], member=get, postfix_operators=[], prefix_operators=[], qualifier=wordIndex, selectors=[], type_arguments=None)], member=score, postfix_operators=[], prefix_operators=[], qualifier=lex, selectors=[], type_arguments=None)], member=exp, postfix_operators=[], prefix_operators=[], qualifier=Math, selectors=[], type_arguments=None), if_true=MethodInvocation(arguments=[MethodInvocation(arguments=[MemberReference(member=arg, postfix_operators=[], prefix_operators=[], qualifier=dependency, selectors=[]), Literal(postfix_operators=[], prefix_operators=[], qualifier=None, selectors=[], value=1), MethodInvocation(arguments=[MemberReference(member=word, postfix_operators=[], prefix_operators=[], qualifier=dependency.arg, selectors=[])], member=get, postfix_operators=[], prefix_operators=[], qualifier=wordIndex, selectors=[], type_arguments=None)], member=score, postfix_operators=[], prefix_operators=[], qualifier=lex, selectors=[], type_arguments=None)], member=exp, postfix_operators=[], prefix_operators=[], qualifier=Math, selectors=[], type_arguments=None))]
else begin[{]
assign[member[.p_aTW_aT], TernaryExpression(condition=BinaryOperation(operandl=MemberReference(member=c_aTW, postfix_operators=[], prefix_operators=[], qualifier=, selectors=[]), operandr=Literal(postfix_operators=[], prefix_operators=[], qualifier=None, selectors=[], value=0.0), operator=>), if_false=Literal(postfix_operators=[], prefix_operators=[], qualifier=None, selectors=[], value=1.0), if_true=BinaryOperation(operandl=MemberReference(member=c_aTW, postfix_operators=[], prefix_operators=[], qualifier=, selectors=[]), operandr=MemberReference(member=c_aT, postfix_operators=[], prefix_operators=[], qualifier=, selectors=[]), operator=/))]
end[}]
assign[member[.p_aTW_hTd], TernaryExpression(condition=BinaryOperation(operandl=MemberReference(member=c_hTd, postfix_operators=[], prefix_operators=[], qualifier=, selectors=[]), operandr=Literal(postfix_operators=[], prefix_operators=[], qualifier=None, selectors=[], value=0.0), operator=>), if_false=Literal(postfix_operators=[], prefix_operators=[], qualifier=None, selectors=[], value=0.0), if_true=BinaryOperation(operandl=MemberReference(member=c_aTW_hTd, postfix_operators=[], prefix_operators=[], qualifier=, selectors=[]), operandr=MemberReference(member=c_hTd, postfix_operators=[], prefix_operators=[], qualifier=, selectors=[]), operator=/))]
assign[member[.p_aT_hTd], TernaryExpression(condition=BinaryOperation(operandl=MemberReference(member=c_hTd, postfix_operators=[], prefix_operators=[], qualifier=, selectors=[]), operandr=Literal(postfix_operators=[], prefix_operators=[], qualifier=None, selectors=[], value=0.0), operator=>), if_false=Literal(postfix_operators=[], prefix_operators=[], qualifier=None, selectors=[], value=0.0), if_true=BinaryOperation(operandl=MemberReference(member=c_aT_hTd, postfix_operators=[], prefix_operators=[], qualifier=, selectors=[]), operandr=MemberReference(member=c_hTd, postfix_operators=[], prefix_operators=[], qualifier=, selectors=[]), operator=/))]
end[}]
local_variable[type[double], pb_aTW_hTWd]
local_variable[type[double], pb_aT_hTWd]
local_variable[type[double], score]
if[member[.verbose]] begin[{]
local_variable[type[NumberFormat], nf]
call[nf.setMaximumFractionDigits, parameter[literal[2]]]
if[member[.useSmoothTagProjection]] begin[{]
if[member[.useUnigramWordSmoothing]] begin[{]
call[System.err.println, parameter[binary_operation[binary_operation[binary_operation[binary_operation[binary_operation[literal[" c_aW="], +, member[.c_aW]], +, literal[", numWordTokens="]], +, member[.numWordTokens]], +, literal[", p(aW)="]], +, call[nf.format, parameter[member[.p_aW]]]]]]
else begin[{]
None
end[}]
call[System.err.println, parameter[binary_operation[binary_operation[binary_operation[binary_operation[binary_operation[binary_operation[binary_operation[literal[" c_aPTW_aPT="], +, member[.c_aPTW_aPT]], +, literal[", c_aPT="]], +, member[.c_aPT]], +, literal[", smooth_aPTW_aPT="]], +, member[.smooth_aPTW_aPT]], +, literal[", p(aPTW|aPT)="]], +, call[nf.format, parameter[member[.p_aPTW_aPT]]]]]]
else begin[{]
None
end[}]
call[System.err.println, parameter[binary_operation[binary_operation[binary_operation[binary_operation[binary_operation[binary_operation[binary_operation[literal[" c_aTW="], +, member[.c_aTW]], +, literal[", c_aT="]], +, member[.c_aT]], +, literal[", smooth_aTW_aT="]], +, member[.smooth_aTW_aT]], +, literal[", ## p(aTW|aT)="]], +, call[nf.format, parameter[member[.p_aTW_aT]]]]]]
if[member[.useSmoothTagProjection]] begin[{]
call[System.err.println, parameter[binary_operation[binary_operation[binary_operation[binary_operation[binary_operation[literal[" c_aPTW_hPTd="], +, member[.c_aPTW_hPTd]], +, literal[", c_hPTd="]], +, member[.c_hPTd]], +, literal[", p(aPTW|hPTd)="]], +, call[nf.format, parameter[member[.p_aPTW_hPTd]]]]]]
else begin[{]
None
end[}]
call[System.err.println, parameter[binary_operation[binary_operation[binary_operation[binary_operation[binary_operation[binary_operation[binary_operation[literal[" c_aTW_hTd="], +, member[.c_aTW_hTd]], +, literal[", c_hTd="]], +, member[.c_hTd]], +, literal[", smooth_aTW_hTd="]], +, member[.smooth_aTW_hTd]], +, literal[", p(aTW|hTd)="]], +, call[nf.format, parameter[member[.p_aTW_hTd]]]]]]
if[member[.useSmoothTagProjection]] begin[{]
call[System.err.println, parameter[binary_operation[binary_operation[binary_operation[binary_operation[binary_operation[literal[" c_aPT_hPTd="], +, member[.c_aPT_hPTd]], +, literal[", c_hPTd="]], +, member[.c_hPTd]], +, literal[", p(aPT|hPTd)="]], +, call[nf.format, parameter[member[.p_aPT_hPTd]]]]]]
else begin[{]
None
end[}]
call[System.err.println, parameter[binary_operation[binary_operation[binary_operation[binary_operation[binary_operation[binary_operation[binary_operation[literal[" c_aT_hTd="], +, member[.c_aT_hTd]], +, literal[", c_hTd="]], +, member[.c_hTd]], +, literal[", smooth_aT_hTd="]], +, member[.smooth_aT_hTd]], +, literal[", p(aT|hTd)="]], +, call[nf.format, parameter[member[.p_aT_hTd]]]]]]
call[System.err.println, parameter[binary_operation[binary_operation[binary_operation[binary_operation[binary_operation[binary_operation[binary_operation[literal[" c_aTW_hTWd="], +, member[.c_aTW_hTWd]], +, literal[", c_hTWd="]], +, member[.c_hTWd]], +, literal[", smooth_aTW_hTWd="]], +, member[.smooth_aTW_hTWd]], +, literal[", ## p(aTW|hTWd)="]], +, call[nf.format, parameter[member[.pb_aTW_hTWd]]]]]]
call[System.err.println, parameter[binary_operation[binary_operation[binary_operation[binary_operation[binary_operation[binary_operation[binary_operation[literal[" c_aT_hTWd="], +, member[.c_aT_hTWd]], +, literal[", c_hTWd="]], +, member[.c_hTWd]], +, literal[", smooth_aT_hTWd="]], +, member[.smooth_aT_hTWd]], +, literal[", ## p(aT|hTWd)="]], +, call[nf.format, parameter[member[.pb_aT_hTWd]]]]]]
call[System.err.println, parameter[binary_operation[binary_operation[binary_operation[binary_operation[binary_operation[binary_operation[binary_operation[literal[" interp="], +, member[.interp]], +, literal[", prescore="]], +, call[nf.format, parameter[binary_operation[binary_operation[member[.interp], *, member[.pb_aTW_hTWd]], +, binary_operation[binary_operation[binary_operation[literal[1.0], -, member[.interp]], *, member[.p_aTW_aT]], *, member[.pb_aT_hTWd]]]]]], +, literal[", P(go|hTWds)="]], +, call[nf.format, parameter[member[.pb_go_hTWds]]]], +, literal[", score="]], +, call[nf.format, parameter[member[.score]]]]]]
else begin[{]
None
end[}]
if[binary_operation[member[op.testOptions.prunePunc], &&, call[.pruneTW, parameter[member[.aTW]]]]] begin[{]
return[literal[1.0]]
else begin[{]
None
end[}]
if[call[Double.isNaN, parameter[member[.score]]]] begin[{]
assign[member[.score], literal[0.0]]
else begin[{]
None
end[}]
if[binary_operation[member[.score], <, member[.MIN_PROBABILITY]]] begin[{]
assign[member[.score], literal[0.0]]
else begin[{]
None
end[}]
return[member[.score]]
end[}]
END[}]
|
Keyword[protected] Keyword[double] identifier[probTB] operator[SEP] identifier[IntDependency] identifier[dependency] operator[SEP] {
Keyword[if] operator[SEP] identifier[verbose] operator[SEP] {
identifier[System] operator[SEP] identifier[err] operator[SEP] identifier[println] operator[SEP] literal[String] operator[+] identifier[dependency] operator[SEP] operator[SEP]
}
Keyword[boolean] identifier[leftHeaded] operator[=] identifier[dependency] operator[SEP] identifier[leftHeaded] operator[&&] identifier[directional] operator[SEP] Keyword[int] identifier[hW] operator[=] identifier[dependency] operator[SEP] identifier[head] operator[SEP] identifier[word] operator[SEP] Keyword[int] identifier[aW] operator[=] identifier[dependency] operator[SEP] identifier[arg] operator[SEP] identifier[word] operator[SEP] Keyword[short] identifier[hT] operator[=] identifier[dependency] operator[SEP] identifier[head] operator[SEP] identifier[tag] operator[SEP] Keyword[short] identifier[aT] operator[=] identifier[dependency] operator[SEP] identifier[arg] operator[SEP] identifier[tag] operator[SEP] identifier[IntTaggedWord] identifier[aTW] operator[=] identifier[dependency] operator[SEP] identifier[arg] operator[SEP] identifier[IntTaggedWord] identifier[hTW] operator[=] identifier[dependency] operator[SEP] identifier[head] operator[SEP] Keyword[boolean] identifier[isRoot] operator[=] identifier[rootTW] operator[SEP] identifier[dependency] operator[SEP] identifier[head] operator[SEP] operator[SEP] Keyword[double] identifier[pb_stop_hTWds] operator[SEP] Keyword[if] operator[SEP] identifier[isRoot] operator[SEP] {
identifier[pb_stop_hTWds] operator[=] literal[Float] operator[SEP]
}
Keyword[else] {
identifier[pb_stop_hTWds] operator[=] identifier[getStopProb] operator[SEP] identifier[dependency] operator[SEP] operator[SEP]
}
Keyword[if] operator[SEP] identifier[dependency] operator[SEP] identifier[arg] operator[SEP] identifier[word] operator[==] identifier[STOP_WORD_INT] operator[SEP] {
Keyword[return] identifier[pb_stop_hTWds] operator[SEP]
}
Keyword[double] identifier[pb_go_hTWds] operator[=] literal[Float] operator[-] identifier[pb_stop_hTWds] operator[SEP] Keyword[short] identifier[binDistance] operator[=] identifier[valenceBin] operator[SEP] identifier[dependency] operator[SEP] identifier[distance] operator[SEP] operator[SEP] identifier[IntTaggedWord] identifier[anyHead] operator[=] Keyword[new] identifier[IntTaggedWord] operator[SEP] identifier[ANY_WORD_INT] , identifier[dependency] operator[SEP] identifier[head] operator[SEP] identifier[tag] operator[SEP] operator[SEP] identifier[IntTaggedWord] identifier[anyArg] operator[=] Keyword[new] identifier[IntTaggedWord] operator[SEP] identifier[ANY_WORD_INT] , identifier[dependency] operator[SEP] identifier[arg] operator[SEP] identifier[tag] operator[SEP] operator[SEP] identifier[IntTaggedWord] identifier[anyTagArg] operator[=] Keyword[new] identifier[IntTaggedWord] operator[SEP] identifier[dependency] operator[SEP] identifier[arg] operator[SEP] identifier[word] , identifier[ANY_TAG_INT] operator[SEP] operator[SEP] identifier[IntDependency] identifier[temp] operator[=] Keyword[new] identifier[IntDependency] operator[SEP] identifier[dependency] operator[SEP] identifier[head] , identifier[dependency] operator[SEP] identifier[arg] , identifier[leftHeaded] , identifier[binDistance] operator[SEP] operator[SEP] Keyword[double] identifier[c_aTW_hTWd] operator[=] identifier[argCounter] operator[SEP] identifier[getCount] operator[SEP] identifier[temp] operator[SEP] operator[SEP] identifier[temp] operator[=] Keyword[new] identifier[IntDependency] operator[SEP] identifier[dependency] operator[SEP] identifier[head] , identifier[anyArg] , identifier[leftHeaded] , identifier[binDistance] operator[SEP] operator[SEP] Keyword[double] identifier[c_aT_hTWd] operator[=] identifier[argCounter] operator[SEP] identifier[getCount] operator[SEP] identifier[temp] operator[SEP] operator[SEP] identifier[temp] operator[=] Keyword[new] identifier[IntDependency] operator[SEP] identifier[dependency] operator[SEP] identifier[head] , identifier[wildTW] , identifier[leftHeaded] , identifier[binDistance] operator[SEP] operator[SEP] Keyword[double] identifier[c_hTWd] operator[=] identifier[argCounter] operator[SEP] identifier[getCount] operator[SEP] identifier[temp] operator[SEP] operator[SEP] identifier[temp] operator[=] Keyword[new] identifier[IntDependency] operator[SEP] identifier[anyHead] , identifier[dependency] operator[SEP] identifier[arg] , identifier[leftHeaded] , identifier[binDistance] operator[SEP] operator[SEP] Keyword[double] identifier[c_aTW_hTd] operator[=] identifier[argCounter] operator[SEP] identifier[getCount] operator[SEP] identifier[temp] operator[SEP] operator[SEP] identifier[temp] operator[=] Keyword[new] identifier[IntDependency] operator[SEP] identifier[anyHead] , identifier[anyArg] , identifier[leftHeaded] , identifier[binDistance] operator[SEP] operator[SEP] Keyword[double] identifier[c_aT_hTd] operator[=] identifier[argCounter] operator[SEP] identifier[getCount] operator[SEP] identifier[temp] operator[SEP] operator[SEP] identifier[temp] operator[=] Keyword[new] identifier[IntDependency] operator[SEP] identifier[anyHead] , identifier[wildTW] , identifier[leftHeaded] , identifier[binDistance] operator[SEP] operator[SEP] Keyword[double] identifier[c_hTd] operator[=] identifier[argCounter] operator[SEP] identifier[getCount] operator[SEP] identifier[temp] operator[SEP] operator[SEP] Keyword[short] identifier[aPT] operator[=] identifier[Short] operator[SEP] identifier[MIN_VALUE] operator[SEP] Keyword[double] identifier[c_aPTW_hPTd] operator[=] identifier[Double] operator[SEP] identifier[NaN] operator[SEP] Keyword[double] identifier[c_aPT_hPTd] operator[=] identifier[Double] operator[SEP] identifier[NaN] operator[SEP] Keyword[double] identifier[c_hPTd] operator[=] identifier[Double] operator[SEP] identifier[NaN] operator[SEP] Keyword[double] identifier[c_aPTW_aPT] operator[=] identifier[Double] operator[SEP] identifier[NaN] operator[SEP] Keyword[double] identifier[c_aPT] operator[=] identifier[Double] operator[SEP] identifier[NaN] operator[SEP] Keyword[if] operator[SEP] identifier[useSmoothTagProjection] operator[SEP] {
identifier[aPT] operator[=] identifier[tagProject] operator[SEP] identifier[dependency] operator[SEP] identifier[arg] operator[SEP] identifier[tag] operator[SEP] operator[SEP] Keyword[short] identifier[hPT] operator[=] identifier[tagProject] operator[SEP] identifier[dependency] operator[SEP] identifier[head] operator[SEP] identifier[tag] operator[SEP] operator[SEP] identifier[IntTaggedWord] identifier[projectedArg] operator[=] Keyword[new] identifier[IntTaggedWord] operator[SEP] identifier[dependency] operator[SEP] identifier[arg] operator[SEP] identifier[word] , identifier[aPT] operator[SEP] operator[SEP] identifier[IntTaggedWord] identifier[projectedAnyHead] operator[=] Keyword[new] identifier[IntTaggedWord] operator[SEP] identifier[ANY_WORD_INT] , identifier[hPT] operator[SEP] operator[SEP] identifier[IntTaggedWord] identifier[projectedAnyArg] operator[=] Keyword[new] identifier[IntTaggedWord] operator[SEP] identifier[ANY_WORD_INT] , identifier[aPT] operator[SEP] operator[SEP] identifier[temp] operator[=] Keyword[new] identifier[IntDependency] operator[SEP] identifier[projectedAnyHead] , identifier[projectedArg] , identifier[leftHeaded] , identifier[binDistance] operator[SEP] operator[SEP] identifier[c_aPTW_hPTd] operator[=] identifier[argCounter] operator[SEP] identifier[getCount] operator[SEP] identifier[temp] operator[SEP] operator[SEP] identifier[temp] operator[=] Keyword[new] identifier[IntDependency] operator[SEP] identifier[projectedAnyHead] , identifier[projectedAnyArg] , identifier[leftHeaded] , identifier[binDistance] operator[SEP] operator[SEP] identifier[c_aPT_hPTd] operator[=] identifier[argCounter] operator[SEP] identifier[getCount] operator[SEP] identifier[temp] operator[SEP] operator[SEP] identifier[temp] operator[=] Keyword[new] identifier[IntDependency] operator[SEP] identifier[projectedAnyHead] , identifier[wildTW] , identifier[leftHeaded] , identifier[binDistance] operator[SEP] operator[SEP] identifier[c_hPTd] operator[=] identifier[argCounter] operator[SEP] identifier[getCount] operator[SEP] identifier[temp] operator[SEP] operator[SEP] identifier[temp] operator[=] Keyword[new] identifier[IntDependency] operator[SEP] identifier[wildTW] , identifier[projectedArg] , literal[boolean] , identifier[ANY_DISTANCE_INT] operator[SEP] operator[SEP] identifier[c_aPTW_aPT] operator[=] identifier[argCounter] operator[SEP] identifier[getCount] operator[SEP] identifier[temp] operator[SEP] operator[SEP] identifier[temp] operator[=] Keyword[new] identifier[IntDependency] operator[SEP] identifier[wildTW] , identifier[projectedAnyArg] , literal[boolean] , identifier[ANY_DISTANCE_INT] operator[SEP] operator[SEP] identifier[c_aPT] operator[=] identifier[argCounter] operator[SEP] identifier[getCount] operator[SEP] identifier[temp] operator[SEP] operator[SEP]
}
identifier[temp] operator[=] Keyword[new] identifier[IntDependency] operator[SEP] identifier[wildTW] , identifier[dependency] operator[SEP] identifier[arg] , literal[boolean] , identifier[ANY_DISTANCE_INT] operator[SEP] operator[SEP] Keyword[double] identifier[c_aTW] operator[=] identifier[argCounter] operator[SEP] identifier[getCount] operator[SEP] identifier[temp] operator[SEP] operator[SEP] identifier[temp] operator[=] Keyword[new] identifier[IntDependency] operator[SEP] identifier[wildTW] , identifier[anyArg] , literal[boolean] , identifier[ANY_DISTANCE_INT] operator[SEP] operator[SEP] Keyword[double] identifier[c_aT] operator[=] identifier[argCounter] operator[SEP] identifier[getCount] operator[SEP] identifier[temp] operator[SEP] operator[SEP] identifier[temp] operator[=] Keyword[new] identifier[IntDependency] operator[SEP] identifier[wildTW] , identifier[anyTagArg] , literal[boolean] , identifier[ANY_DISTANCE_INT] operator[SEP] operator[SEP] Keyword[double] identifier[c_aW] operator[=] identifier[argCounter] operator[SEP] identifier[getCount] operator[SEP] identifier[temp] operator[SEP] operator[SEP] Keyword[double] identifier[p_aTW_hTd] operator[SEP] Keyword[double] identifier[p_aT_hTd] operator[SEP] Keyword[double] identifier[p_aTW_aT] operator[SEP] Keyword[double] identifier[p_aW] operator[SEP] Keyword[double] identifier[p_aPTW_aPT] operator[SEP] Keyword[double] identifier[p_aPTW_hPTd] operator[SEP] Keyword[double] identifier[p_aPT_hPTd] operator[SEP] Keyword[if] operator[SEP] identifier[useSmoothTagProjection] operator[SEP] {
Keyword[if] operator[SEP] identifier[useUnigramWordSmoothing] operator[SEP] {
identifier[p_aW] operator[=] identifier[c_aW] operator[>] literal[Float] operator[?] operator[SEP] identifier[c_aW] operator[/] identifier[numWordTokens] operator[SEP] operator[:] literal[Float] operator[SEP] identifier[p_aPTW_aPT] operator[=] operator[SEP] identifier[c_aPTW_aPT] operator[+] identifier[smooth_aPTW_aPT] operator[*] identifier[p_aW] operator[SEP] operator[/] operator[SEP] identifier[c_aPT] operator[+] identifier[smooth_aPTW_aPT] operator[SEP] operator[SEP]
}
Keyword[else] {
identifier[p_aPTW_aPT] operator[=] identifier[c_aPTW_aPT] operator[>] literal[Float] operator[?] operator[SEP] identifier[c_aPTW_aPT] operator[/] identifier[c_aPT] operator[SEP] operator[:] literal[Float] operator[SEP]
}
identifier[p_aTW_aT] operator[=] operator[SEP] identifier[c_aTW] operator[+] identifier[smooth_aTW_aT] operator[*] identifier[p_aPTW_aPT] operator[SEP] operator[/] operator[SEP] identifier[c_aT] operator[+] identifier[smooth_aTW_aT] operator[SEP] operator[SEP] identifier[p_aPTW_hPTd] operator[=] identifier[c_hPTd] operator[>] literal[Float] operator[?] operator[SEP] identifier[c_aPTW_hPTd] operator[/] identifier[c_hPTd] operator[SEP] operator[:] literal[Float] operator[SEP] identifier[p_aTW_hTd] operator[=] operator[SEP] identifier[c_aTW_hTd] operator[+] identifier[smooth_aTW_hTd] operator[*] identifier[p_aPTW_hPTd] operator[SEP] operator[/] operator[SEP] identifier[c_hTd] operator[+] identifier[smooth_aTW_hTd] operator[SEP] operator[SEP] identifier[p_aPT_hPTd] operator[=] identifier[c_hPTd] operator[>] literal[Float] operator[?] operator[SEP] identifier[c_aPT_hPTd] operator[/] identifier[c_hPTd] operator[SEP] operator[:] literal[Float] operator[SEP] identifier[p_aT_hTd] operator[=] operator[SEP] identifier[c_aT_hTd] operator[+] identifier[smooth_aT_hTd] operator[*] identifier[p_aPT_hPTd] operator[SEP] operator[/] operator[SEP] identifier[c_hTd] operator[+] identifier[smooth_aT_hTd] operator[SEP] operator[SEP]
}
Keyword[else] {
Keyword[if] operator[SEP] identifier[op] operator[SEP] identifier[testOptions] operator[SEP] identifier[useLexiconToScoreDependencyPwGt] operator[SEP] {
identifier[p_aTW_aT] operator[=] identifier[dependency] operator[SEP] identifier[leftHeaded] operator[?] identifier[Math] operator[SEP] identifier[exp] operator[SEP] identifier[lex] operator[SEP] identifier[score] operator[SEP] identifier[dependency] operator[SEP] identifier[arg] , Other[1] , identifier[wordIndex] operator[SEP] identifier[get] operator[SEP] identifier[dependency] operator[SEP] identifier[arg] operator[SEP] identifier[word] operator[SEP] operator[SEP] operator[SEP] operator[:] identifier[Math] operator[SEP] identifier[exp] operator[SEP] identifier[lex] operator[SEP] identifier[score] operator[SEP] identifier[dependency] operator[SEP] identifier[arg] , operator[-] Other[1] , identifier[wordIndex] operator[SEP] identifier[get] operator[SEP] identifier[dependency] operator[SEP] identifier[arg] operator[SEP] identifier[word] operator[SEP] operator[SEP] operator[SEP] operator[SEP]
}
Keyword[else] {
identifier[p_aTW_aT] operator[=] identifier[c_aTW] operator[>] literal[Float] operator[?] operator[SEP] identifier[c_aTW] operator[/] identifier[c_aT] operator[SEP] operator[:] literal[Float] operator[SEP]
}
identifier[p_aTW_hTd] operator[=] identifier[c_hTd] operator[>] literal[Float] operator[?] operator[SEP] identifier[c_aTW_hTd] operator[/] identifier[c_hTd] operator[SEP] operator[:] literal[Float] operator[SEP] identifier[p_aT_hTd] operator[=] identifier[c_hTd] operator[>] literal[Float] operator[?] operator[SEP] identifier[c_aT_hTd] operator[/] identifier[c_hTd] operator[SEP] operator[:] literal[Float] operator[SEP]
}
Keyword[double] identifier[pb_aTW_hTWd] operator[=] operator[SEP] identifier[c_aTW_hTWd] operator[+] identifier[smooth_aTW_hTWd] operator[*] identifier[p_aTW_hTd] operator[SEP] operator[/] operator[SEP] identifier[c_hTWd] operator[+] identifier[smooth_aTW_hTWd] operator[SEP] operator[SEP] Keyword[double] identifier[pb_aT_hTWd] operator[=] operator[SEP] identifier[c_aT_hTWd] operator[+] identifier[smooth_aT_hTWd] operator[*] identifier[p_aT_hTd] operator[SEP] operator[/] operator[SEP] identifier[c_hTWd] operator[+] identifier[smooth_aT_hTWd] operator[SEP] operator[SEP] Keyword[double] identifier[score] operator[=] operator[SEP] identifier[interp] operator[*] identifier[pb_aTW_hTWd] operator[+] operator[SEP] literal[Float] operator[-] identifier[interp] operator[SEP] operator[*] identifier[p_aTW_aT] operator[*] identifier[pb_aT_hTWd] operator[SEP] operator[*] identifier[pb_go_hTWds] operator[SEP] Keyword[if] operator[SEP] identifier[verbose] operator[SEP] {
identifier[NumberFormat] identifier[nf] operator[=] identifier[NumberFormat] operator[SEP] identifier[getNumberInstance] operator[SEP] operator[SEP] operator[SEP] identifier[nf] operator[SEP] identifier[setMaximumFractionDigits] operator[SEP] Other[2] operator[SEP] operator[SEP] Keyword[if] operator[SEP] identifier[useSmoothTagProjection] operator[SEP] {
Keyword[if] operator[SEP] identifier[useUnigramWordSmoothing] operator[SEP] {
identifier[System] operator[SEP] identifier[err] operator[SEP] identifier[println] operator[SEP] literal[String] operator[+] identifier[c_aW] operator[+] literal[String] operator[+] identifier[numWordTokens] operator[+] literal[String] operator[+] identifier[nf] operator[SEP] identifier[format] operator[SEP] identifier[p_aW] operator[SEP] operator[SEP] operator[SEP]
}
identifier[System] operator[SEP] identifier[err] operator[SEP] identifier[println] operator[SEP] literal[String] operator[+] identifier[c_aPTW_aPT] operator[+] literal[String] operator[+] identifier[c_aPT] operator[+] literal[String] operator[+] identifier[smooth_aPTW_aPT] operator[+] literal[String] operator[+] identifier[nf] operator[SEP] identifier[format] operator[SEP] identifier[p_aPTW_aPT] operator[SEP] operator[SEP] operator[SEP]
}
identifier[System] operator[SEP] identifier[err] operator[SEP] identifier[println] operator[SEP] literal[String] operator[+] identifier[c_aTW] operator[+] literal[String] operator[+] identifier[c_aT] operator[+] literal[String] operator[+] identifier[smooth_aTW_aT] operator[+] literal[String] operator[+] identifier[nf] operator[SEP] identifier[format] operator[SEP] identifier[p_aTW_aT] operator[SEP] operator[SEP] operator[SEP] Keyword[if] operator[SEP] identifier[useSmoothTagProjection] operator[SEP] {
identifier[System] operator[SEP] identifier[err] operator[SEP] identifier[println] operator[SEP] literal[String] operator[+] identifier[c_aPTW_hPTd] operator[+] literal[String] operator[+] identifier[c_hPTd] operator[+] literal[String] operator[+] identifier[nf] operator[SEP] identifier[format] operator[SEP] identifier[p_aPTW_hPTd] operator[SEP] operator[SEP] operator[SEP]
}
identifier[System] operator[SEP] identifier[err] operator[SEP] identifier[println] operator[SEP] literal[String] operator[+] identifier[c_aTW_hTd] operator[+] literal[String] operator[+] identifier[c_hTd] operator[+] literal[String] operator[+] identifier[smooth_aTW_hTd] operator[+] literal[String] operator[+] identifier[nf] operator[SEP] identifier[format] operator[SEP] identifier[p_aTW_hTd] operator[SEP] operator[SEP] operator[SEP] Keyword[if] operator[SEP] identifier[useSmoothTagProjection] operator[SEP] {
identifier[System] operator[SEP] identifier[err] operator[SEP] identifier[println] operator[SEP] literal[String] operator[+] identifier[c_aPT_hPTd] operator[+] literal[String] operator[+] identifier[c_hPTd] operator[+] literal[String] operator[+] identifier[nf] operator[SEP] identifier[format] operator[SEP] identifier[p_aPT_hPTd] operator[SEP] operator[SEP] operator[SEP]
}
identifier[System] operator[SEP] identifier[err] operator[SEP] identifier[println] operator[SEP] literal[String] operator[+] identifier[c_aT_hTd] operator[+] literal[String] operator[+] identifier[c_hTd] operator[+] literal[String] operator[+] identifier[smooth_aT_hTd] operator[+] literal[String] operator[+] identifier[nf] operator[SEP] identifier[format] operator[SEP] identifier[p_aT_hTd] operator[SEP] operator[SEP] operator[SEP] identifier[System] operator[SEP] identifier[err] operator[SEP] identifier[println] operator[SEP] literal[String] operator[+] identifier[c_aTW_hTWd] operator[+] literal[String] operator[+] identifier[c_hTWd] operator[+] literal[String] operator[+] identifier[smooth_aTW_hTWd] operator[+] literal[String] operator[+] identifier[nf] operator[SEP] identifier[format] operator[SEP] identifier[pb_aTW_hTWd] operator[SEP] operator[SEP] operator[SEP] identifier[System] operator[SEP] identifier[err] operator[SEP] identifier[println] operator[SEP] literal[String] operator[+] identifier[c_aT_hTWd] operator[+] literal[String] operator[+] identifier[c_hTWd] operator[+] literal[String] operator[+] identifier[smooth_aT_hTWd] operator[+] literal[String] operator[+] identifier[nf] operator[SEP] identifier[format] operator[SEP] identifier[pb_aT_hTWd] operator[SEP] operator[SEP] operator[SEP] identifier[System] operator[SEP] identifier[err] operator[SEP] identifier[println] operator[SEP] literal[String] operator[+] identifier[interp] operator[+] literal[String] operator[+] identifier[nf] operator[SEP] identifier[format] operator[SEP] identifier[interp] operator[*] identifier[pb_aTW_hTWd] operator[+] operator[SEP] literal[Float] operator[-] identifier[interp] operator[SEP] operator[*] identifier[p_aTW_aT] operator[*] identifier[pb_aT_hTWd] operator[SEP] operator[+] literal[String] operator[+] identifier[nf] operator[SEP] identifier[format] operator[SEP] identifier[pb_go_hTWds] operator[SEP] operator[+] literal[String] operator[+] identifier[nf] operator[SEP] identifier[format] operator[SEP] identifier[score] operator[SEP] operator[SEP] operator[SEP]
}
Keyword[if] operator[SEP] identifier[op] operator[SEP] identifier[testOptions] operator[SEP] identifier[prunePunc] operator[&&] identifier[pruneTW] operator[SEP] identifier[aTW] operator[SEP] operator[SEP] {
Keyword[return] literal[Float] operator[SEP]
}
Keyword[if] operator[SEP] identifier[Double] operator[SEP] identifier[isNaN] operator[SEP] identifier[score] operator[SEP] operator[SEP] {
identifier[score] operator[=] literal[Float] operator[SEP]
}
Keyword[if] operator[SEP] identifier[score] operator[<] identifier[MIN_PROBABILITY] operator[SEP] {
identifier[score] operator[=] literal[Float] operator[SEP]
}
Keyword[return] identifier[score] operator[SEP]
}
|
public void setProperties(Properties sslProps) {
if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled())
Tr.debug(tc, "setProperties");
this.sslProperties = sslProps;
}
|
class class_name[name] begin[{]
method[setProperties, return_type[void], modifier[public], parameter[sslProps]] begin[{]
if[binary_operation[call[TraceComponent.isAnyTracingEnabled, parameter[]], &&, call[tc.isDebugEnabled, parameter[]]]] begin[{]
call[Tr.debug, parameter[member[.tc], literal["setProperties"]]]
else begin[{]
None
end[}]
assign[THIS[member[None.sslProperties]], member[.sslProps]]
end[}]
END[}]
|
Keyword[public] Keyword[void] identifier[setProperties] operator[SEP] identifier[Properties] identifier[sslProps] operator[SEP] {
Keyword[if] operator[SEP] identifier[TraceComponent] operator[SEP] identifier[isAnyTracingEnabled] operator[SEP] operator[SEP] operator[&&] identifier[tc] operator[SEP] identifier[isDebugEnabled] operator[SEP] operator[SEP] operator[SEP] identifier[Tr] operator[SEP] identifier[debug] operator[SEP] identifier[tc] , literal[String] operator[SEP] operator[SEP] Keyword[this] operator[SEP] identifier[sslProperties] operator[=] identifier[sslProps] operator[SEP]
}
|
private void registerExtensions() {
Iterator<Cache2kExtensionProvider> it =
ServiceLoader.load(Cache2kExtensionProvider.class, CacheManager.class.getClassLoader()).iterator();
while (it.hasNext()) {
try {
it.next().registerCache2kExtension();
} catch (ServiceConfigurationError ex) {
Log.getLog(CacheManager.class.getName()).debug("Error loading cache2k extension", ex);
}
}
}
|
class class_name[name] begin[{]
method[registerExtensions, return_type[void], modifier[private], parameter[]] begin[{]
local_variable[type[Iterator], it]
while[call[it.hasNext, parameter[]]] begin[{]
TryStatement(block=[StatementExpression(expression=MethodInvocation(arguments=[], member=next, postfix_operators=[], prefix_operators=[], qualifier=it, selectors=[MethodInvocation(arguments=[], member=registerCache2kExtension, postfix_operators=None, prefix_operators=None, qualifier=None, selectors=None, type_arguments=None)], type_arguments=None), label=None)], catches=[CatchClause(block=[StatementExpression(expression=MethodInvocation(arguments=[ClassReference(postfix_operators=[], prefix_operators=[], qualifier=, selectors=[MethodInvocation(arguments=[], member=getName, postfix_operators=None, prefix_operators=None, qualifier=None, selectors=None, type_arguments=None)], type=ReferenceType(arguments=None, dimensions=None, name=CacheManager, sub_type=None))], member=getLog, postfix_operators=[], prefix_operators=[], qualifier=Log, selectors=[MethodInvocation(arguments=[Literal(postfix_operators=[], prefix_operators=[], qualifier=None, selectors=[], value="Error loading cache2k extension"), MemberReference(member=ex, postfix_operators=[], prefix_operators=[], qualifier=, selectors=[])], member=debug, postfix_operators=None, prefix_operators=None, qualifier=None, selectors=None, type_arguments=None)], type_arguments=None), label=None)], label=None, parameter=CatchClauseParameter(annotations=None, modifiers=None, name=ex, types=['ServiceConfigurationError']))], finally_block=None, label=None, resources=None)
end[}]
end[}]
END[}]
|
Keyword[private] Keyword[void] identifier[registerExtensions] operator[SEP] operator[SEP] {
identifier[Iterator] operator[<] identifier[Cache2kExtensionProvider] operator[>] identifier[it] operator[=] identifier[ServiceLoader] operator[SEP] identifier[load] operator[SEP] identifier[Cache2kExtensionProvider] operator[SEP] Keyword[class] , identifier[CacheManager] operator[SEP] Keyword[class] operator[SEP] identifier[getClassLoader] operator[SEP] operator[SEP] operator[SEP] operator[SEP] identifier[iterator] operator[SEP] operator[SEP] operator[SEP] Keyword[while] operator[SEP] identifier[it] operator[SEP] identifier[hasNext] operator[SEP] operator[SEP] operator[SEP] {
Keyword[try] {
identifier[it] operator[SEP] identifier[next] operator[SEP] operator[SEP] operator[SEP] identifier[registerCache2kExtension] operator[SEP] operator[SEP] operator[SEP]
}
Keyword[catch] operator[SEP] identifier[ServiceConfigurationError] identifier[ex] operator[SEP] {
identifier[Log] operator[SEP] identifier[getLog] operator[SEP] identifier[CacheManager] operator[SEP] Keyword[class] operator[SEP] identifier[getName] operator[SEP] operator[SEP] operator[SEP] operator[SEP] identifier[debug] operator[SEP] literal[String] , identifier[ex] operator[SEP] operator[SEP]
}
}
}
|
public void unlock() {
ArrayList<Runnable> list;
Thread t = Thread.currentThread();
synchronized (this) {
if (t != lockingThread) return;
if (--lockedTimes > 0) return;
lockingThread = null;
list = listeners;
listeners = null;
}
if (list != null) {
for (Runnable r : list) r.run();
}
// notify after listeners
synchronized (this) {
this.notifyAll();
}
}
|
class class_name[name] begin[{]
method[unlock, return_type[void], modifier[public], parameter[]] begin[{]
local_variable[type[ArrayList], list]
local_variable[type[Thread], t]
SYNCHRONIZED[THIS[]] BEGIN[{]
if[binary_operation[member[.t], !=, member[.lockingThread]]] begin[{]
return[None]
else begin[{]
None
end[}]
if[binary_operation[member[.lockedTimes], >, literal[0]]] begin[{]
return[None]
else begin[{]
None
end[}]
assign[member[.lockingThread], literal[null]]
assign[member[.list], member[.listeners]]
assign[member[.listeners], literal[null]]
END[}]
if[binary_operation[member[.list], !=, literal[null]]] begin[{]
ForStatement(body=StatementExpression(expression=MethodInvocation(arguments=[], member=run, postfix_operators=[], prefix_operators=[], qualifier=r, selectors=[], type_arguments=None), label=None), control=EnhancedForControl(iterable=MemberReference(member=list, postfix_operators=[], prefix_operators=[], qualifier=, selectors=[]), var=VariableDeclaration(annotations=[], declarators=[VariableDeclarator(dimensions=None, initializer=None, name=r)], modifiers=set(), type=ReferenceType(arguments=None, dimensions=[], name=Runnable, sub_type=None))), label=None)
else begin[{]
None
end[}]
SYNCHRONIZED[THIS[]] BEGIN[{]
THIS[call[None.notifyAll, parameter[]]]
END[}]
end[}]
END[}]
|
Keyword[public] Keyword[void] identifier[unlock] operator[SEP] operator[SEP] {
identifier[ArrayList] operator[<] identifier[Runnable] operator[>] identifier[list] operator[SEP] identifier[Thread] identifier[t] operator[=] identifier[Thread] operator[SEP] identifier[currentThread] operator[SEP] operator[SEP] operator[SEP] Keyword[synchronized] operator[SEP] Keyword[this] operator[SEP] {
Keyword[if] operator[SEP] identifier[t] operator[!=] identifier[lockingThread] operator[SEP] Keyword[return] operator[SEP] Keyword[if] operator[SEP] operator[--] identifier[lockedTimes] operator[>] Other[0] operator[SEP] Keyword[return] operator[SEP] identifier[lockingThread] operator[=] Other[null] operator[SEP] identifier[list] operator[=] identifier[listeners] operator[SEP] identifier[listeners] operator[=] Other[null] operator[SEP]
}
Keyword[if] operator[SEP] identifier[list] operator[!=] Other[null] operator[SEP] {
Keyword[for] operator[SEP] identifier[Runnable] identifier[r] operator[:] identifier[list] operator[SEP] identifier[r] operator[SEP] identifier[run] operator[SEP] operator[SEP] operator[SEP]
}
Keyword[synchronized] operator[SEP] Keyword[this] operator[SEP] {
Keyword[this] operator[SEP] identifier[notifyAll] operator[SEP] operator[SEP] operator[SEP]
}
}
|
private void pruneExcessiveHistoricalRecordsIfNeeded() {
final int pruneCount = mHistoricalRecords.size() - mHistoryMaxSize;
if (pruneCount <= 0) {
return;
}
mHistoricalRecordsChanged = true;
for (int i = 0; i < pruneCount; i++) {
HistoricalRecord prunedRecord = mHistoricalRecords.remove(0);
if (DEBUG) {
Log.i(LOG_TAG, "Pruned: " + prunedRecord);
}
}
}
|
class class_name[name] begin[{]
method[pruneExcessiveHistoricalRecordsIfNeeded, return_type[void], modifier[private], parameter[]] begin[{]
local_variable[type[int], pruneCount]
if[binary_operation[member[.pruneCount], <=, literal[0]]] begin[{]
return[None]
else begin[{]
None
end[}]
assign[member[.mHistoricalRecordsChanged], literal[true]]
ForStatement(body=BlockStatement(label=None, statements=[LocalVariableDeclaration(annotations=[], declarators=[VariableDeclarator(dimensions=[], initializer=MethodInvocation(arguments=[Literal(postfix_operators=[], prefix_operators=[], qualifier=None, selectors=[], value=0)], member=remove, postfix_operators=[], prefix_operators=[], qualifier=mHistoricalRecords, selectors=[], type_arguments=None), name=prunedRecord)], modifiers=set(), type=ReferenceType(arguments=None, dimensions=[], name=HistoricalRecord, sub_type=None)), IfStatement(condition=MemberReference(member=DEBUG, postfix_operators=[], prefix_operators=[], qualifier=, selectors=[]), else_statement=None, label=None, then_statement=BlockStatement(label=None, statements=[StatementExpression(expression=MethodInvocation(arguments=[MemberReference(member=LOG_TAG, postfix_operators=[], prefix_operators=[], qualifier=, selectors=[]), BinaryOperation(operandl=Literal(postfix_operators=[], prefix_operators=[], qualifier=None, selectors=[], value="Pruned: "), operandr=MemberReference(member=prunedRecord, postfix_operators=[], prefix_operators=[], qualifier=, selectors=[]), operator=+)], member=i, postfix_operators=[], prefix_operators=[], qualifier=Log, selectors=[], type_arguments=None), label=None)]))]), control=ForControl(condition=BinaryOperation(operandl=MemberReference(member=i, postfix_operators=[], prefix_operators=[], qualifier=, selectors=[]), operandr=MemberReference(member=pruneCount, postfix_operators=[], prefix_operators=[], qualifier=, selectors=[]), operator=<), init=VariableDeclaration(annotations=[], declarators=[VariableDeclarator(dimensions=None, initializer=Literal(postfix_operators=[], prefix_operators=[], qualifier=None, selectors=[], value=0), name=i)], modifiers=set(), type=BasicType(dimensions=[], name=int)), update=[MemberReference(member=i, postfix_operators=['++'], prefix_operators=[], qualifier=, selectors=[])]), label=None)
end[}]
END[}]
|
Keyword[private] Keyword[void] identifier[pruneExcessiveHistoricalRecordsIfNeeded] operator[SEP] operator[SEP] {
Keyword[final] Keyword[int] identifier[pruneCount] operator[=] identifier[mHistoricalRecords] operator[SEP] identifier[size] operator[SEP] operator[SEP] operator[-] identifier[mHistoryMaxSize] operator[SEP] Keyword[if] operator[SEP] identifier[pruneCount] operator[<=] Other[0] operator[SEP] {
Keyword[return] operator[SEP]
}
identifier[mHistoricalRecordsChanged] operator[=] literal[boolean] operator[SEP] Keyword[for] operator[SEP] Keyword[int] identifier[i] operator[=] Other[0] operator[SEP] identifier[i] operator[<] identifier[pruneCount] operator[SEP] identifier[i] operator[++] operator[SEP] {
identifier[HistoricalRecord] identifier[prunedRecord] operator[=] identifier[mHistoricalRecords] operator[SEP] identifier[remove] operator[SEP] Other[0] operator[SEP] operator[SEP] Keyword[if] operator[SEP] identifier[DEBUG] operator[SEP] {
identifier[Log] operator[SEP] identifier[i] operator[SEP] identifier[LOG_TAG] , literal[String] operator[+] identifier[prunedRecord] operator[SEP] operator[SEP]
}
}
}
|
@Override
public final void to(ObjectOutput out) throws IOException {
if (out == null) throw new NullPointerException();
// delegate to the equivalent internal method
_to(out);
}
|
class class_name[name] begin[{]
method[to, return_type[void], modifier[final public], parameter[out]] begin[{]
if[binary_operation[member[.out], ==, literal[null]]] begin[{]
ThrowStatement(expression=ClassCreator(arguments=[], body=None, constructor_type_arguments=None, postfix_operators=[], prefix_operators=[], qualifier=None, selectors=[], type=ReferenceType(arguments=None, dimensions=None, name=NullPointerException, sub_type=None)), label=None)
else begin[{]
None
end[}]
call[._to, parameter[member[.out]]]
end[}]
END[}]
|
annotation[@] identifier[Override] Keyword[public] Keyword[final] Keyword[void] identifier[to] operator[SEP] identifier[ObjectOutput] identifier[out] operator[SEP] Keyword[throws] identifier[IOException] {
Keyword[if] operator[SEP] identifier[out] operator[==] Other[null] operator[SEP] Keyword[throw] Keyword[new] identifier[NullPointerException] operator[SEP] operator[SEP] operator[SEP] identifier[_to] operator[SEP] identifier[out] operator[SEP] operator[SEP]
}
|
@Override
public Object[] toArray() {
if (size == 0) {
return new Object[0];
}
Object[] destination = toArray(DEFAULT_DESTINATION);
return destination;
}
|
class class_name[name] begin[{]
method[toArray, return_type[type[Object]], modifier[public], parameter[]] begin[{]
if[binary_operation[member[.size], ==, literal[0]]] begin[{]
return[ArrayCreator(dimensions=[Literal(postfix_operators=[], prefix_operators=[], qualifier=None, selectors=[], value=0)], initializer=None, postfix_operators=[], prefix_operators=[], qualifier=None, selectors=[], type=ReferenceType(arguments=None, dimensions=None, name=Object, sub_type=None))]
else begin[{]
None
end[}]
local_variable[type[Object], destination]
return[member[.destination]]
end[}]
END[}]
|
annotation[@] identifier[Override] Keyword[public] identifier[Object] operator[SEP] operator[SEP] identifier[toArray] operator[SEP] operator[SEP] {
Keyword[if] operator[SEP] identifier[size] operator[==] Other[0] operator[SEP] {
Keyword[return] Keyword[new] identifier[Object] operator[SEP] Other[0] operator[SEP] operator[SEP]
}
identifier[Object] operator[SEP] operator[SEP] identifier[destination] operator[=] identifier[toArray] operator[SEP] identifier[DEFAULT_DESTINATION] operator[SEP] operator[SEP] Keyword[return] identifier[destination] operator[SEP]
}
|
public static void intToNetworkByteOrder(int num, byte[] buf, int start,
int count) {
if (count > 4) {
throw new IllegalArgumentException(
"Cannot handle more than 4 bytes");
}
for (int i = count - 1; i >= 0; i--) {
buf[start + i] = (byte) (num & 0xff);
num >>>= 8;
}
}
|
class class_name[name] begin[{]
method[intToNetworkByteOrder, return_type[void], modifier[public static], parameter[num, buf, start, count]] begin[{]
if[binary_operation[member[.count], >, literal[4]]] begin[{]
ThrowStatement(expression=ClassCreator(arguments=[Literal(postfix_operators=[], prefix_operators=[], qualifier=None, selectors=[], value="Cannot handle more than 4 bytes")], body=None, constructor_type_arguments=None, postfix_operators=[], prefix_operators=[], qualifier=None, selectors=[], type=ReferenceType(arguments=None, dimensions=None, name=IllegalArgumentException, sub_type=None)), label=None)
else begin[{]
None
end[}]
ForStatement(body=BlockStatement(label=None, statements=[StatementExpression(expression=Assignment(expressionl=MemberReference(member=buf, postfix_operators=[], prefix_operators=[], qualifier=, selectors=[ArraySelector(index=BinaryOperation(operandl=MemberReference(member=start, postfix_operators=[], prefix_operators=[], qualifier=, selectors=[]), operandr=MemberReference(member=i, postfix_operators=[], prefix_operators=[], qualifier=, selectors=[]), operator=+))]), type==, value=Cast(expression=BinaryOperation(operandl=MemberReference(member=num, postfix_operators=[], prefix_operators=[], qualifier=, selectors=[]), operandr=Literal(postfix_operators=[], prefix_operators=[], qualifier=None, selectors=[], value=0xff), operator=&), type=BasicType(dimensions=[], name=byte))), label=None), StatementExpression(expression=Assignment(expressionl=MemberReference(member=num, postfix_operators=[], prefix_operators=[], qualifier=, selectors=[]), type=>>>=, value=Literal(postfix_operators=[], prefix_operators=[], qualifier=None, selectors=[], value=8)), label=None)]), control=ForControl(condition=BinaryOperation(operandl=MemberReference(member=i, postfix_operators=[], prefix_operators=[], qualifier=, selectors=[]), operandr=Literal(postfix_operators=[], prefix_operators=[], qualifier=None, selectors=[], value=0), operator=>=), init=VariableDeclaration(annotations=[], declarators=[VariableDeclarator(dimensions=None, initializer=BinaryOperation(operandl=MemberReference(member=count, postfix_operators=[], prefix_operators=[], qualifier=, selectors=[]), operandr=Literal(postfix_operators=[], prefix_operators=[], qualifier=None, selectors=[], value=1), operator=-), name=i)], modifiers=set(), type=BasicType(dimensions=[], name=int)), update=[MemberReference(member=i, postfix_operators=['--'], prefix_operators=[], qualifier=, selectors=[])]), label=None)
end[}]
END[}]
|
Keyword[public] Keyword[static] Keyword[void] identifier[intToNetworkByteOrder] operator[SEP] Keyword[int] identifier[num] , Keyword[byte] operator[SEP] operator[SEP] identifier[buf] , Keyword[int] identifier[start] , Keyword[int] identifier[count] operator[SEP] {
Keyword[if] operator[SEP] identifier[count] operator[>] Other[4] operator[SEP] {
Keyword[throw] Keyword[new] identifier[IllegalArgumentException] operator[SEP] literal[String] operator[SEP] operator[SEP]
}
Keyword[for] operator[SEP] Keyword[int] identifier[i] operator[=] identifier[count] operator[-] Other[1] operator[SEP] identifier[i] operator[>=] Other[0] operator[SEP] identifier[i] operator[--] operator[SEP] {
identifier[buf] operator[SEP] identifier[start] operator[+] identifier[i] operator[SEP] operator[=] operator[SEP] Keyword[byte] operator[SEP] operator[SEP] identifier[num] operator[&] literal[Integer] operator[SEP] operator[SEP] identifier[num] operator[>>>=] Other[8] operator[SEP]
}
}
|
@SuppressWarnings("unchecked")
public static <T extends AbstractHtml> Collection<T> findTagsAssignableToTag(
final boolean parallel, final Class<T> tagClass,
final AbstractHtml... fromTags)
throws NullValueException, InvalidTagException {
if (tagClass == null) {
throw new NullValueException("The tagClass should not be null");
}
if (NoTag.class.isAssignableFrom(tagClass)) {
throw new InvalidTagException(
"classes like NoTag.class cannot be used to find tags as it's not a logical tag in behaviour.");
}
if (fromTags == null) {
throw new NullValueException("The fromTags should not be null");
}
final Collection<Lock> locks = getReadLocks(fromTags);
for (final Lock lock : locks) {
lock.lock();
}
try {
return (Collection<T>) getAllNestedChildrenIncludingParent(parallel,
fromTags).filter(tag -> {
return tagClass.isAssignableFrom(tag.getClass())
&& !NoTag.class
.isAssignableFrom(tag.getClass());
}).collect(Collectors.toSet());
} finally {
for (final Lock lock : locks) {
lock.unlock();
}
}
}
|
class class_name[name] begin[{]
method[findTagsAssignableToTag, return_type[type[Collection]], modifier[public static], parameter[parallel, tagClass, fromTags]] begin[{]
if[binary_operation[member[.tagClass], ==, literal[null]]] begin[{]
ThrowStatement(expression=ClassCreator(arguments=[Literal(postfix_operators=[], prefix_operators=[], qualifier=None, selectors=[], value="The tagClass should not be null")], body=None, constructor_type_arguments=None, postfix_operators=[], prefix_operators=[], qualifier=None, selectors=[], type=ReferenceType(arguments=None, dimensions=None, name=NullValueException, sub_type=None)), label=None)
else begin[{]
None
end[}]
if[ClassReference(postfix_operators=[], prefix_operators=[], qualifier=, selectors=[MethodInvocation(arguments=[MemberReference(member=tagClass, postfix_operators=[], prefix_operators=[], qualifier=, selectors=[])], member=isAssignableFrom, postfix_operators=None, prefix_operators=None, qualifier=None, selectors=None, type_arguments=None)], type=ReferenceType(arguments=None, dimensions=None, name=NoTag, sub_type=None))] begin[{]
ThrowStatement(expression=ClassCreator(arguments=[Literal(postfix_operators=[], prefix_operators=[], qualifier=None, selectors=[], value="classes like NoTag.class cannot be used to find tags as it's not a logical tag in behaviour.")], body=None, constructor_type_arguments=None, postfix_operators=[], prefix_operators=[], qualifier=None, selectors=[], type=ReferenceType(arguments=None, dimensions=None, name=InvalidTagException, sub_type=None)), label=None)
else begin[{]
None
end[}]
if[binary_operation[member[.fromTags], ==, literal[null]]] begin[{]
ThrowStatement(expression=ClassCreator(arguments=[Literal(postfix_operators=[], prefix_operators=[], qualifier=None, selectors=[], value="The fromTags should not be null")], body=None, constructor_type_arguments=None, postfix_operators=[], prefix_operators=[], qualifier=None, selectors=[], type=ReferenceType(arguments=None, dimensions=None, name=NullValueException, sub_type=None)), label=None)
else begin[{]
None
end[}]
local_variable[type[Collection], locks]
ForStatement(body=BlockStatement(label=None, statements=[StatementExpression(expression=MethodInvocation(arguments=[], member=lock, postfix_operators=[], prefix_operators=[], qualifier=lock, selectors=[], type_arguments=None), label=None)]), control=EnhancedForControl(iterable=MemberReference(member=locks, postfix_operators=[], prefix_operators=[], qualifier=, selectors=[]), var=VariableDeclaration(annotations=[], declarators=[VariableDeclarator(dimensions=None, initializer=None, name=lock)], modifiers={'final'}, type=ReferenceType(arguments=None, dimensions=[], name=Lock, sub_type=None))), label=None)
TryStatement(block=[ReturnStatement(expression=Cast(expression=MethodInvocation(arguments=[MemberReference(member=parallel, postfix_operators=[], prefix_operators=[], qualifier=, selectors=[]), MemberReference(member=fromTags, postfix_operators=[], prefix_operators=[], qualifier=, selectors=[])], member=getAllNestedChildrenIncludingParent, postfix_operators=[], prefix_operators=[], qualifier=, selectors=[MethodInvocation(arguments=[LambdaExpression(body=[ReturnStatement(expression=BinaryOperation(operandl=MethodInvocation(arguments=[MethodInvocation(arguments=[], member=getClass, postfix_operators=[], prefix_operators=[], qualifier=tag, selectors=[], type_arguments=None)], member=isAssignableFrom, postfix_operators=[], prefix_operators=[], qualifier=tagClass, selectors=[], type_arguments=None), operandr=ClassReference(postfix_operators=[], prefix_operators=['!'], qualifier=, selectors=[MethodInvocation(arguments=[MethodInvocation(arguments=[], member=getClass, postfix_operators=[], prefix_operators=[], qualifier=tag, selectors=[], type_arguments=None)], member=isAssignableFrom, postfix_operators=None, prefix_operators=None, qualifier=None, selectors=None, type_arguments=None)], type=ReferenceType(arguments=None, dimensions=None, name=NoTag, sub_type=None)), operator=&&), label=None)], parameters=[MemberReference(member=tag, postfix_operators=[], prefix_operators=[], qualifier=, selectors=[])])], member=filter, postfix_operators=None, prefix_operators=None, qualifier=None, selectors=None, type_arguments=None), MethodInvocation(arguments=[MethodInvocation(arguments=[], member=toSet, postfix_operators=[], prefix_operators=[], qualifier=Collectors, selectors=[], type_arguments=None)], member=collect, postfix_operators=None, prefix_operators=None, qualifier=None, selectors=None, type_arguments=None)], type_arguments=None), type=ReferenceType(arguments=[TypeArgument(pattern_type=None, type=ReferenceType(arguments=None, dimensions=[], name=T, sub_type=None))], dimensions=[], name=Collection, sub_type=None)), label=None)], catches=None, finally_block=[ForStatement(body=BlockStatement(label=None, statements=[StatementExpression(expression=MethodInvocation(arguments=[], member=unlock, postfix_operators=[], prefix_operators=[], qualifier=lock, selectors=[], type_arguments=None), label=None)]), control=EnhancedForControl(iterable=MemberReference(member=locks, postfix_operators=[], prefix_operators=[], qualifier=, selectors=[]), var=VariableDeclaration(annotations=[], declarators=[VariableDeclarator(dimensions=None, initializer=None, name=lock)], modifiers={'final'}, type=ReferenceType(arguments=None, dimensions=[], name=Lock, sub_type=None))), label=None)], label=None, resources=None)
end[}]
END[}]
|
annotation[@] identifier[SuppressWarnings] operator[SEP] literal[String] operator[SEP] Keyword[public] Keyword[static] operator[<] identifier[T] Keyword[extends] identifier[AbstractHtml] operator[>] identifier[Collection] operator[<] identifier[T] operator[>] identifier[findTagsAssignableToTag] operator[SEP] Keyword[final] Keyword[boolean] identifier[parallel] , Keyword[final] identifier[Class] operator[<] identifier[T] operator[>] identifier[tagClass] , Keyword[final] identifier[AbstractHtml] operator[...] identifier[fromTags] operator[SEP] Keyword[throws] identifier[NullValueException] , identifier[InvalidTagException] {
Keyword[if] operator[SEP] identifier[tagClass] operator[==] Other[null] operator[SEP] {
Keyword[throw] Keyword[new] identifier[NullValueException] operator[SEP] literal[String] operator[SEP] operator[SEP]
}
Keyword[if] operator[SEP] identifier[NoTag] operator[SEP] Keyword[class] operator[SEP] identifier[isAssignableFrom] operator[SEP] identifier[tagClass] operator[SEP] operator[SEP] {
Keyword[throw] Keyword[new] identifier[InvalidTagException] operator[SEP] literal[String] operator[SEP] operator[SEP]
}
Keyword[if] operator[SEP] identifier[fromTags] operator[==] Other[null] operator[SEP] {
Keyword[throw] Keyword[new] identifier[NullValueException] operator[SEP] literal[String] operator[SEP] operator[SEP]
}
Keyword[final] identifier[Collection] operator[<] identifier[Lock] operator[>] identifier[locks] operator[=] identifier[getReadLocks] operator[SEP] identifier[fromTags] operator[SEP] operator[SEP] Keyword[for] operator[SEP] Keyword[final] identifier[Lock] identifier[lock] operator[:] identifier[locks] operator[SEP] {
identifier[lock] operator[SEP] identifier[lock] operator[SEP] operator[SEP] operator[SEP]
}
Keyword[try] {
Keyword[return] operator[SEP] identifier[Collection] operator[<] identifier[T] operator[>] operator[SEP] identifier[getAllNestedChildrenIncludingParent] operator[SEP] identifier[parallel] , identifier[fromTags] operator[SEP] operator[SEP] identifier[filter] operator[SEP] identifier[tag] operator[->] {
Keyword[return] identifier[tagClass] operator[SEP] identifier[isAssignableFrom] operator[SEP] identifier[tag] operator[SEP] identifier[getClass] operator[SEP] operator[SEP] operator[SEP] operator[&&] operator[!] identifier[NoTag] operator[SEP] Keyword[class] operator[SEP] identifier[isAssignableFrom] operator[SEP] identifier[tag] operator[SEP] identifier[getClass] operator[SEP] operator[SEP] operator[SEP] operator[SEP]
} operator[SEP] operator[SEP] identifier[collect] operator[SEP] identifier[Collectors] operator[SEP] identifier[toSet] operator[SEP] operator[SEP] operator[SEP] operator[SEP]
}
Keyword[finally] {
Keyword[for] operator[SEP] Keyword[final] identifier[Lock] identifier[lock] operator[:] identifier[locks] operator[SEP] {
identifier[lock] operator[SEP] identifier[unlock] operator[SEP] operator[SEP] operator[SEP]
}
}
}
|
public void select(TimelineEvent event, TimelineUpdater timelineUpdater) {
int index = getIndex(event);
if (timelineUpdater != null) {
// update UI
timelineUpdater.select(index);
}
}
|
class class_name[name] begin[{]
method[select, return_type[void], modifier[public], parameter[event, timelineUpdater]] begin[{]
local_variable[type[int], index]
if[binary_operation[member[.timelineUpdater], !=, literal[null]]] begin[{]
call[timelineUpdater.select, parameter[member[.index]]]
else begin[{]
None
end[}]
end[}]
END[}]
|
Keyword[public] Keyword[void] identifier[select] operator[SEP] identifier[TimelineEvent] identifier[event] , identifier[TimelineUpdater] identifier[timelineUpdater] operator[SEP] {
Keyword[int] identifier[index] operator[=] identifier[getIndex] operator[SEP] identifier[event] operator[SEP] operator[SEP] Keyword[if] operator[SEP] identifier[timelineUpdater] operator[!=] Other[null] operator[SEP] {
identifier[timelineUpdater] operator[SEP] identifier[select] operator[SEP] identifier[index] operator[SEP] operator[SEP]
}
}
|
private void showResultTemplate(@NonNull SearchResults results) {
setVisibility(VISIBLE);
setText(applyTemplate(resultTemplate, results));
}
|
class class_name[name] begin[{]
method[showResultTemplate, return_type[void], modifier[private], parameter[results]] begin[{]
call[.setVisibility, parameter[member[.VISIBLE]]]
call[.setText, parameter[call[.applyTemplate, parameter[member[.resultTemplate], member[.results]]]]]
end[}]
END[}]
|
Keyword[private] Keyword[void] identifier[showResultTemplate] operator[SEP] annotation[@] identifier[NonNull] identifier[SearchResults] identifier[results] operator[SEP] {
identifier[setVisibility] operator[SEP] identifier[VISIBLE] operator[SEP] operator[SEP] identifier[setText] operator[SEP] identifier[applyTemplate] operator[SEP] identifier[resultTemplate] , identifier[results] operator[SEP] operator[SEP] operator[SEP]
}
|
private void convertTokenDefinitions() throws GrammarException,
TreeException {
tokenVisibility.clear();
Map<String, ParseTreeNode> helpers = getHelperTokens();
Map<String, ParseTreeNode> tokens = getTokens();
convertTokenDefinitions(helpers, tokens);
}
|
class class_name[name] begin[{]
method[convertTokenDefinitions, return_type[void], modifier[private], parameter[]] begin[{]
call[tokenVisibility.clear, parameter[]]
local_variable[type[Map], helpers]
local_variable[type[Map], tokens]
call[.convertTokenDefinitions, parameter[member[.helpers], member[.tokens]]]
end[}]
END[}]
|
Keyword[private] Keyword[void] identifier[convertTokenDefinitions] operator[SEP] operator[SEP] Keyword[throws] identifier[GrammarException] , identifier[TreeException] {
identifier[tokenVisibility] operator[SEP] identifier[clear] operator[SEP] operator[SEP] operator[SEP] identifier[Map] operator[<] identifier[String] , identifier[ParseTreeNode] operator[>] identifier[helpers] operator[=] identifier[getHelperTokens] operator[SEP] operator[SEP] operator[SEP] identifier[Map] operator[<] identifier[String] , identifier[ParseTreeNode] operator[>] identifier[tokens] operator[=] identifier[getTokens] operator[SEP] operator[SEP] operator[SEP] identifier[convertTokenDefinitions] operator[SEP] identifier[helpers] , identifier[tokens] operator[SEP] operator[SEP]
}
|
@Override
public IScan getScanByNumUpper(int scanNum) {
IScan scan = getNum2scan().ceilingEntry(scanNum).getValue();
if (scan != null) {
return scan;
}
return null;
}
|
class class_name[name] begin[{]
method[getScanByNumUpper, return_type[type[IScan]], modifier[public], parameter[scanNum]] begin[{]
local_variable[type[IScan], scan]
if[binary_operation[member[.scan], !=, literal[null]]] begin[{]
return[member[.scan]]
else begin[{]
None
end[}]
return[literal[null]]
end[}]
END[}]
|
annotation[@] identifier[Override] Keyword[public] identifier[IScan] identifier[getScanByNumUpper] operator[SEP] Keyword[int] identifier[scanNum] operator[SEP] {
identifier[IScan] identifier[scan] operator[=] identifier[getNum2scan] operator[SEP] operator[SEP] operator[SEP] identifier[ceilingEntry] operator[SEP] identifier[scanNum] operator[SEP] operator[SEP] identifier[getValue] operator[SEP] operator[SEP] operator[SEP] Keyword[if] operator[SEP] identifier[scan] operator[!=] Other[null] operator[SEP] {
Keyword[return] identifier[scan] operator[SEP]
}
Keyword[return] Other[null] operator[SEP]
}
|
public static <T> List<T> getListUnsafe(final List list, final Class<T> clazz, final Integer... path) {
return (List<T>) getUnsafe(list, List.class, path);
}
|
class class_name[name] begin[{]
method[getListUnsafe, return_type[type[List]], modifier[public static], parameter[list, clazz, path]] begin[{]
return[Cast(expression=MethodInvocation(arguments=[MemberReference(member=list, postfix_operators=[], prefix_operators=[], qualifier=, selectors=[]), ClassReference(postfix_operators=[], prefix_operators=[], qualifier=, selectors=[], type=ReferenceType(arguments=None, dimensions=None, name=List, sub_type=None)), MemberReference(member=path, postfix_operators=[], prefix_operators=[], qualifier=, selectors=[])], member=getUnsafe, postfix_operators=[], prefix_operators=[], qualifier=, selectors=[], type_arguments=None), type=ReferenceType(arguments=[TypeArgument(pattern_type=None, type=ReferenceType(arguments=None, dimensions=[], name=T, sub_type=None))], dimensions=[], name=List, sub_type=None))]
end[}]
END[}]
|
Keyword[public] Keyword[static] operator[<] identifier[T] operator[>] identifier[List] operator[<] identifier[T] operator[>] identifier[getListUnsafe] operator[SEP] Keyword[final] identifier[List] identifier[list] , Keyword[final] identifier[Class] operator[<] identifier[T] operator[>] identifier[clazz] , Keyword[final] identifier[Integer] operator[...] identifier[path] operator[SEP] {
Keyword[return] operator[SEP] identifier[List] operator[<] identifier[T] operator[>] operator[SEP] identifier[getUnsafe] operator[SEP] identifier[list] , identifier[List] operator[SEP] Keyword[class] , identifier[path] operator[SEP] operator[SEP]
}
|
public R isGreaterThan(V lower) {
return create(e -> Expressions.call(Operators.GREATER_THAN, e, Expressions.literal(lower)));
}
|
class class_name[name] begin[{]
method[isGreaterThan, return_type[type[R]], modifier[public], parameter[lower]] begin[{]
return[call[.create, parameter[LambdaExpression(body=MethodInvocation(arguments=[MemberReference(member=GREATER_THAN, postfix_operators=[], prefix_operators=[], qualifier=Operators, selectors=[]), MemberReference(member=e, postfix_operators=[], prefix_operators=[], qualifier=, selectors=[]), MethodInvocation(arguments=[MemberReference(member=lower, postfix_operators=[], prefix_operators=[], qualifier=, selectors=[])], member=literal, postfix_operators=[], prefix_operators=[], qualifier=Expressions, selectors=[], type_arguments=None)], member=call, postfix_operators=[], prefix_operators=[], qualifier=Expressions, selectors=[], type_arguments=None), parameters=[MemberReference(member=e, postfix_operators=[], prefix_operators=[], qualifier=, selectors=[])])]]]
end[}]
END[}]
|
Keyword[public] identifier[R] identifier[isGreaterThan] operator[SEP] identifier[V] identifier[lower] operator[SEP] {
Keyword[return] identifier[create] operator[SEP] identifier[e] operator[->] identifier[Expressions] operator[SEP] identifier[call] operator[SEP] identifier[Operators] operator[SEP] identifier[GREATER_THAN] , identifier[e] , identifier[Expressions] operator[SEP] identifier[literal] operator[SEP] identifier[lower] operator[SEP] operator[SEP] operator[SEP] operator[SEP]
}
|
public static @CheckForNull URL _findResource(ClassLoader cl, String name) {
return (URL) invoke(FIND_RESOURCE, RuntimeException.class, cl, name);
}
|
class class_name[name] begin[{]
method[_findResource, return_type[type[URL]], modifier[public static], parameter[cl, name]] begin[{]
return[Cast(expression=MethodInvocation(arguments=[MemberReference(member=FIND_RESOURCE, postfix_operators=[], prefix_operators=[], qualifier=, selectors=[]), ClassReference(postfix_operators=[], prefix_operators=[], qualifier=, selectors=[], type=ReferenceType(arguments=None, dimensions=None, name=RuntimeException, sub_type=None)), MemberReference(member=cl, postfix_operators=[], prefix_operators=[], qualifier=, selectors=[]), MemberReference(member=name, postfix_operators=[], prefix_operators=[], qualifier=, selectors=[])], member=invoke, postfix_operators=[], prefix_operators=[], qualifier=, selectors=[], type_arguments=None), type=ReferenceType(arguments=None, dimensions=[], name=URL, sub_type=None))]
end[}]
END[}]
|
Keyword[public] Keyword[static] annotation[@] identifier[CheckForNull] identifier[URL] identifier[_findResource] operator[SEP] identifier[ClassLoader] identifier[cl] , identifier[String] identifier[name] operator[SEP] {
Keyword[return] operator[SEP] identifier[URL] operator[SEP] identifier[invoke] operator[SEP] identifier[FIND_RESOURCE] , identifier[RuntimeException] operator[SEP] Keyword[class] , identifier[cl] , identifier[name] operator[SEP] operator[SEP]
}
|
@NonNull
@Override
public GroupBy groupBy(@NonNull Expression... expressions) {
if (expressions == null) {
throw new IllegalArgumentException("expressions cannot be null.");
}
return new GroupBy(this, Arrays.asList(expressions));
}
|
class class_name[name] begin[{]
method[groupBy, return_type[type[GroupBy]], modifier[public], parameter[expressions]] begin[{]
if[binary_operation[member[.expressions], ==, literal[null]]] begin[{]
ThrowStatement(expression=ClassCreator(arguments=[Literal(postfix_operators=[], prefix_operators=[], qualifier=None, selectors=[], value="expressions cannot be null.")], body=None, constructor_type_arguments=None, postfix_operators=[], prefix_operators=[], qualifier=None, selectors=[], type=ReferenceType(arguments=None, dimensions=None, name=IllegalArgumentException, sub_type=None)), label=None)
else begin[{]
None
end[}]
return[ClassCreator(arguments=[This(postfix_operators=[], prefix_operators=[], qualifier=None, selectors=[]), MethodInvocation(arguments=[MemberReference(member=expressions, postfix_operators=[], prefix_operators=[], qualifier=, selectors=[])], member=asList, postfix_operators=[], prefix_operators=[], qualifier=Arrays, selectors=[], type_arguments=None)], body=None, constructor_type_arguments=None, postfix_operators=[], prefix_operators=[], qualifier=None, selectors=[], type=ReferenceType(arguments=None, dimensions=None, name=GroupBy, sub_type=None))]
end[}]
END[}]
|
annotation[@] identifier[NonNull] annotation[@] identifier[Override] Keyword[public] identifier[GroupBy] identifier[groupBy] operator[SEP] annotation[@] identifier[NonNull] identifier[Expression] operator[...] identifier[expressions] operator[SEP] {
Keyword[if] operator[SEP] identifier[expressions] operator[==] Other[null] operator[SEP] {
Keyword[throw] Keyword[new] identifier[IllegalArgumentException] operator[SEP] literal[String] operator[SEP] operator[SEP]
}
Keyword[return] Keyword[new] identifier[GroupBy] operator[SEP] Keyword[this] , identifier[Arrays] operator[SEP] identifier[asList] operator[SEP] identifier[expressions] operator[SEP] operator[SEP] operator[SEP]
}
|
private Long tokenMatch(SNode tok) {
// check if the span is a matched node
SFeature featMatched = tok.getFeature(ANNIS_NS, FEAT_MATCHEDNODE);
Long matchRaw = featMatched == null ? null : featMatched.getValue_SNUMERIC();
return matchRaw;
}
|
class class_name[name] begin[{]
method[tokenMatch, return_type[type[Long]], modifier[private], parameter[tok]] begin[{]
local_variable[type[SFeature], featMatched]
local_variable[type[Long], matchRaw]
return[member[.matchRaw]]
end[}]
END[}]
|
Keyword[private] identifier[Long] identifier[tokenMatch] operator[SEP] identifier[SNode] identifier[tok] operator[SEP] {
identifier[SFeature] identifier[featMatched] operator[=] identifier[tok] operator[SEP] identifier[getFeature] operator[SEP] identifier[ANNIS_NS] , identifier[FEAT_MATCHEDNODE] operator[SEP] operator[SEP] identifier[Long] identifier[matchRaw] operator[=] identifier[featMatched] operator[==] Other[null] operator[?] Other[null] operator[:] identifier[featMatched] operator[SEP] identifier[getValue_SNUMERIC] operator[SEP] operator[SEP] operator[SEP] Keyword[return] identifier[matchRaw] operator[SEP]
}
|
public static void crossValidate(Job.ValidatedJob job) {
if (job.state != Job.JobState.RUNNING) return; //don't do cross-validation if the full model builder failed
if (job.validation != null)
throw new IllegalArgumentException("Cannot provide validation dataset and n_folds > 0 at the same time.");
if (job.n_folds <= 1)
throw new IllegalArgumentException("n_folds must be >= 2 for cross-validation.");
final String basename = job.destination_key.toString();
long[] offsets = new long[job.n_folds +1];
Frame[] cv_preds = new Frame[job.n_folds];
try {
for (int i = 0; i < job.n_folds; ++i) {
if (job.state != Job.JobState.RUNNING) break;
Key[] destkeys = new Key[]{Key.make(basename + "_xval" + i + "_train"), Key.make(basename + "_xval" + i + "_holdout")};
NFoldFrameExtractor nffe = new NFoldFrameExtractor(job.source, job.n_folds, i, destkeys, Key.make() /*key used for locking only*/);
H2O.submitTask(nffe);
Frame[] splits = nffe.getResult();
// Cross-validate individual splits
try {
job.crossValidate(splits, cv_preds, offsets, i); //this removes the enum-ified response!
job._cv_count++;
} finally {
// clean-up the results
if (!job.keep_cross_validation_splits) for(Frame f : splits) f.delete();
}
}
if (job.state != Job.JobState.RUNNING)
return;
final int resp_idx = job.source.find(job._responseName);
Vec response = job.source.vecs()[resp_idx];
boolean put_back = UKV.get(job.response._key) == null; // In the case of rebalance, rebalance response will be deleted
if (put_back) {
job.response = response;
if (job.classification)
job.response = job.response.toEnum();
DKV.put(job.response._key, job.response); //put enum-ified response back to K-V store
}
((Model)UKV.get(job.destination_key)).scoreCrossValidation(job, job.source, response, cv_preds, offsets);
if (put_back) UKV.remove(job.response._key);
} finally {
// clean-up prediction frames for splits
for(Frame f: cv_preds) if (f!=null) f.delete();
}
}
|
class class_name[name] begin[{]
method[crossValidate, return_type[void], modifier[public static], parameter[job]] begin[{]
if[binary_operation[member[job.state], !=, member[Job.JobState.RUNNING]]] begin[{]
return[None]
else begin[{]
None
end[}]
if[binary_operation[member[job.validation], !=, literal[null]]] begin[{]
ThrowStatement(expression=ClassCreator(arguments=[Literal(postfix_operators=[], prefix_operators=[], qualifier=None, selectors=[], value="Cannot provide validation dataset and n_folds > 0 at the same time.")], body=None, constructor_type_arguments=None, postfix_operators=[], prefix_operators=[], qualifier=None, selectors=[], type=ReferenceType(arguments=None, dimensions=None, name=IllegalArgumentException, sub_type=None)), label=None)
else begin[{]
None
end[}]
if[binary_operation[member[job.n_folds], <=, literal[1]]] begin[{]
ThrowStatement(expression=ClassCreator(arguments=[Literal(postfix_operators=[], prefix_operators=[], qualifier=None, selectors=[], value="n_folds must be >= 2 for cross-validation.")], body=None, constructor_type_arguments=None, postfix_operators=[], prefix_operators=[], qualifier=None, selectors=[], type=ReferenceType(arguments=None, dimensions=None, name=IllegalArgumentException, sub_type=None)), label=None)
else begin[{]
None
end[}]
local_variable[type[String], basename]
local_variable[type[long], offsets]
local_variable[type[Frame], cv_preds]
TryStatement(block=[ForStatement(body=BlockStatement(label=None, statements=[IfStatement(condition=BinaryOperation(operandl=MemberReference(member=state, postfix_operators=[], prefix_operators=[], qualifier=job, selectors=[]), operandr=MemberReference(member=RUNNING, postfix_operators=[], prefix_operators=[], qualifier=Job.JobState, selectors=[]), operator=!=), else_statement=None, label=None, then_statement=BreakStatement(goto=None, label=None)), LocalVariableDeclaration(annotations=[], declarators=[VariableDeclarator(dimensions=[], initializer=ArrayCreator(dimensions=[None], initializer=ArrayInitializer(initializers=[MethodInvocation(arguments=[BinaryOperation(operandl=BinaryOperation(operandl=BinaryOperation(operandl=MemberReference(member=basename, postfix_operators=[], prefix_operators=[], qualifier=, selectors=[]), operandr=Literal(postfix_operators=[], prefix_operators=[], qualifier=None, selectors=[], value="_xval"), operator=+), operandr=MemberReference(member=i, postfix_operators=[], prefix_operators=[], qualifier=, selectors=[]), operator=+), operandr=Literal(postfix_operators=[], prefix_operators=[], qualifier=None, selectors=[], value="_train"), operator=+)], member=make, postfix_operators=[], prefix_operators=[], qualifier=Key, selectors=[], type_arguments=None), MethodInvocation(arguments=[BinaryOperation(operandl=BinaryOperation(operandl=BinaryOperation(operandl=MemberReference(member=basename, postfix_operators=[], prefix_operators=[], qualifier=, selectors=[]), operandr=Literal(postfix_operators=[], prefix_operators=[], qualifier=None, selectors=[], value="_xval"), operator=+), operandr=MemberReference(member=i, postfix_operators=[], prefix_operators=[], qualifier=, selectors=[]), operator=+), operandr=Literal(postfix_operators=[], prefix_operators=[], qualifier=None, selectors=[], value="_holdout"), operator=+)], member=make, postfix_operators=[], prefix_operators=[], qualifier=Key, selectors=[], type_arguments=None)]), postfix_operators=[], prefix_operators=[], qualifier=None, selectors=[], type=ReferenceType(arguments=None, dimensions=None, name=Key, sub_type=None)), name=destkeys)], modifiers=set(), type=ReferenceType(arguments=None, dimensions=[None], name=Key, sub_type=None)), LocalVariableDeclaration(annotations=[], declarators=[VariableDeclarator(dimensions=[], initializer=ClassCreator(arguments=[MemberReference(member=source, postfix_operators=[], prefix_operators=[], qualifier=job, selectors=[]), MemberReference(member=n_folds, postfix_operators=[], prefix_operators=[], qualifier=job, selectors=[]), MemberReference(member=i, postfix_operators=[], prefix_operators=[], qualifier=, selectors=[]), MemberReference(member=destkeys, postfix_operators=[], prefix_operators=[], qualifier=, selectors=[]), MethodInvocation(arguments=[], member=make, postfix_operators=[], prefix_operators=[], qualifier=Key, selectors=[], type_arguments=None)], body=None, constructor_type_arguments=None, postfix_operators=[], prefix_operators=[], qualifier=None, selectors=[], type=ReferenceType(arguments=None, dimensions=None, name=NFoldFrameExtractor, sub_type=None)), name=nffe)], modifiers=set(), type=ReferenceType(arguments=None, dimensions=[], name=NFoldFrameExtractor, sub_type=None)), StatementExpression(expression=MethodInvocation(arguments=[MemberReference(member=nffe, postfix_operators=[], prefix_operators=[], qualifier=, selectors=[])], member=submitTask, postfix_operators=[], prefix_operators=[], qualifier=H2O, selectors=[], type_arguments=None), label=None), LocalVariableDeclaration(annotations=[], declarators=[VariableDeclarator(dimensions=[], initializer=MethodInvocation(arguments=[], member=getResult, postfix_operators=[], prefix_operators=[], qualifier=nffe, selectors=[], type_arguments=None), name=splits)], modifiers=set(), type=ReferenceType(arguments=None, dimensions=[None], name=Frame, sub_type=None)), TryStatement(block=[StatementExpression(expression=MethodInvocation(arguments=[MemberReference(member=splits, postfix_operators=[], prefix_operators=[], qualifier=, selectors=[]), MemberReference(member=cv_preds, postfix_operators=[], prefix_operators=[], qualifier=, selectors=[]), MemberReference(member=offsets, postfix_operators=[], prefix_operators=[], qualifier=, selectors=[]), MemberReference(member=i, postfix_operators=[], prefix_operators=[], qualifier=, selectors=[])], member=crossValidate, postfix_operators=[], prefix_operators=[], qualifier=job, selectors=[], type_arguments=None), label=None), StatementExpression(expression=MemberReference(member=_cv_count, postfix_operators=['++'], prefix_operators=[], qualifier=job, selectors=[]), label=None)], catches=None, finally_block=[IfStatement(condition=MemberReference(member=keep_cross_validation_splits, postfix_operators=[], prefix_operators=['!'], qualifier=job, selectors=[]), else_statement=None, label=None, then_statement=ForStatement(body=StatementExpression(expression=MethodInvocation(arguments=[], member=delete, postfix_operators=[], prefix_operators=[], qualifier=f, selectors=[], type_arguments=None), label=None), control=EnhancedForControl(iterable=MemberReference(member=splits, postfix_operators=[], prefix_operators=[], qualifier=, selectors=[]), var=VariableDeclaration(annotations=[], declarators=[VariableDeclarator(dimensions=None, initializer=None, name=f)], modifiers=set(), type=ReferenceType(arguments=None, dimensions=[], name=Frame, sub_type=None))), label=None))], label=None, resources=None)]), control=ForControl(condition=BinaryOperation(operandl=MemberReference(member=i, postfix_operators=[], prefix_operators=[], qualifier=, selectors=[]), operandr=MemberReference(member=n_folds, postfix_operators=[], prefix_operators=[], qualifier=job, selectors=[]), operator=<), init=VariableDeclaration(annotations=[], declarators=[VariableDeclarator(dimensions=None, initializer=Literal(postfix_operators=[], prefix_operators=[], qualifier=None, selectors=[], value=0), name=i)], modifiers=set(), type=BasicType(dimensions=[], name=int)), update=[MemberReference(member=i, postfix_operators=[], prefix_operators=['++'], qualifier=, selectors=[])]), label=None), IfStatement(condition=BinaryOperation(operandl=MemberReference(member=state, postfix_operators=[], prefix_operators=[], qualifier=job, selectors=[]), operandr=MemberReference(member=RUNNING, postfix_operators=[], prefix_operators=[], qualifier=Job.JobState, selectors=[]), operator=!=), else_statement=None, label=None, then_statement=ReturnStatement(expression=None, label=None)), LocalVariableDeclaration(annotations=[], declarators=[VariableDeclarator(dimensions=[], initializer=MethodInvocation(arguments=[MemberReference(member=_responseName, postfix_operators=[], prefix_operators=[], qualifier=job, selectors=[])], member=find, postfix_operators=[], prefix_operators=[], qualifier=job.source, selectors=[], type_arguments=None), name=resp_idx)], modifiers={'final'}, type=BasicType(dimensions=[], name=int)), LocalVariableDeclaration(annotations=[], declarators=[VariableDeclarator(dimensions=[], initializer=MethodInvocation(arguments=[], member=vecs, postfix_operators=[], prefix_operators=[], qualifier=job.source, selectors=[ArraySelector(index=MemberReference(member=resp_idx, postfix_operators=[], prefix_operators=[], qualifier=, selectors=[]))], type_arguments=None), name=response)], modifiers=set(), type=ReferenceType(arguments=None, dimensions=[], name=Vec, sub_type=None)), LocalVariableDeclaration(annotations=[], declarators=[VariableDeclarator(dimensions=[], initializer=BinaryOperation(operandl=MethodInvocation(arguments=[MemberReference(member=_key, postfix_operators=[], prefix_operators=[], qualifier=job.response, selectors=[])], member=get, postfix_operators=[], prefix_operators=[], qualifier=UKV, selectors=[], type_arguments=None), operandr=Literal(postfix_operators=[], prefix_operators=[], qualifier=None, selectors=[], value=null), operator===), name=put_back)], modifiers=set(), type=BasicType(dimensions=[], name=boolean)), IfStatement(condition=MemberReference(member=put_back, postfix_operators=[], prefix_operators=[], qualifier=, selectors=[]), else_statement=None, label=None, then_statement=BlockStatement(label=None, statements=[StatementExpression(expression=Assignment(expressionl=MemberReference(member=response, postfix_operators=[], prefix_operators=[], qualifier=job, selectors=[]), type==, value=MemberReference(member=response, postfix_operators=[], prefix_operators=[], qualifier=, selectors=[])), label=None), IfStatement(condition=MemberReference(member=classification, postfix_operators=[], prefix_operators=[], qualifier=job, selectors=[]), else_statement=None, label=None, then_statement=StatementExpression(expression=Assignment(expressionl=MemberReference(member=response, postfix_operators=[], prefix_operators=[], qualifier=job, selectors=[]), type==, value=MethodInvocation(arguments=[], member=toEnum, postfix_operators=[], prefix_operators=[], qualifier=job.response, selectors=[], type_arguments=None)), label=None)), StatementExpression(expression=MethodInvocation(arguments=[MemberReference(member=_key, postfix_operators=[], prefix_operators=[], qualifier=job.response, selectors=[]), MemberReference(member=response, postfix_operators=[], prefix_operators=[], qualifier=job, selectors=[])], member=put, postfix_operators=[], prefix_operators=[], qualifier=DKV, selectors=[], type_arguments=None), label=None)])), StatementExpression(expression=Cast(expression=MethodInvocation(arguments=[MemberReference(member=destination_key, postfix_operators=[], prefix_operators=[], qualifier=job, selectors=[])], member=get, postfix_operators=[], prefix_operators=[], qualifier=UKV, selectors=[], type_arguments=None), type=ReferenceType(arguments=None, dimensions=[], name=Model, sub_type=None)), label=None), IfStatement(condition=MemberReference(member=put_back, postfix_operators=[], prefix_operators=[], qualifier=, selectors=[]), else_statement=None, label=None, then_statement=StatementExpression(expression=MethodInvocation(arguments=[MemberReference(member=_key, postfix_operators=[], prefix_operators=[], qualifier=job.response, selectors=[])], member=remove, postfix_operators=[], prefix_operators=[], qualifier=UKV, selectors=[], type_arguments=None), label=None))], catches=None, finally_block=[ForStatement(body=IfStatement(condition=BinaryOperation(operandl=MemberReference(member=f, postfix_operators=[], prefix_operators=[], qualifier=, selectors=[]), operandr=Literal(postfix_operators=[], prefix_operators=[], qualifier=None, selectors=[], value=null), operator=!=), else_statement=None, label=None, then_statement=StatementExpression(expression=MethodInvocation(arguments=[], member=delete, postfix_operators=[], prefix_operators=[], qualifier=f, selectors=[], type_arguments=None), label=None)), control=EnhancedForControl(iterable=MemberReference(member=cv_preds, postfix_operators=[], prefix_operators=[], qualifier=, selectors=[]), var=VariableDeclaration(annotations=[], declarators=[VariableDeclarator(dimensions=None, initializer=None, name=f)], modifiers=set(), type=ReferenceType(arguments=None, dimensions=[], name=Frame, sub_type=None))), label=None)], label=None, resources=None)
end[}]
END[}]
|
Keyword[public] Keyword[static] Keyword[void] identifier[crossValidate] operator[SEP] identifier[Job] operator[SEP] identifier[ValidatedJob] identifier[job] operator[SEP] {
Keyword[if] operator[SEP] identifier[job] operator[SEP] identifier[state] operator[!=] identifier[Job] operator[SEP] identifier[JobState] operator[SEP] identifier[RUNNING] operator[SEP] Keyword[return] operator[SEP] Keyword[if] operator[SEP] identifier[job] operator[SEP] identifier[validation] operator[!=] Other[null] operator[SEP] Keyword[throw] Keyword[new] identifier[IllegalArgumentException] operator[SEP] literal[String] operator[SEP] operator[SEP] Keyword[if] operator[SEP] identifier[job] operator[SEP] identifier[n_folds] operator[<=] Other[1] operator[SEP] Keyword[throw] Keyword[new] identifier[IllegalArgumentException] operator[SEP] literal[String] operator[SEP] operator[SEP] Keyword[final] identifier[String] identifier[basename] operator[=] identifier[job] operator[SEP] identifier[destination_key] operator[SEP] identifier[toString] operator[SEP] operator[SEP] operator[SEP] Keyword[long] operator[SEP] operator[SEP] identifier[offsets] operator[=] Keyword[new] Keyword[long] operator[SEP] identifier[job] operator[SEP] identifier[n_folds] operator[+] Other[1] operator[SEP] operator[SEP] identifier[Frame] operator[SEP] operator[SEP] identifier[cv_preds] operator[=] Keyword[new] identifier[Frame] operator[SEP] identifier[job] operator[SEP] identifier[n_folds] operator[SEP] operator[SEP] Keyword[try] {
Keyword[for] operator[SEP] Keyword[int] identifier[i] operator[=] Other[0] operator[SEP] identifier[i] operator[<] identifier[job] operator[SEP] identifier[n_folds] operator[SEP] operator[++] identifier[i] operator[SEP] {
Keyword[if] operator[SEP] identifier[job] operator[SEP] identifier[state] operator[!=] identifier[Job] operator[SEP] identifier[JobState] operator[SEP] identifier[RUNNING] operator[SEP] Keyword[break] operator[SEP] identifier[Key] operator[SEP] operator[SEP] identifier[destkeys] operator[=] Keyword[new] identifier[Key] operator[SEP] operator[SEP] {
identifier[Key] operator[SEP] identifier[make] operator[SEP] identifier[basename] operator[+] literal[String] operator[+] identifier[i] operator[+] literal[String] operator[SEP] , identifier[Key] operator[SEP] identifier[make] operator[SEP] identifier[basename] operator[+] literal[String] operator[+] identifier[i] operator[+] literal[String] operator[SEP]
} operator[SEP] identifier[NFoldFrameExtractor] identifier[nffe] operator[=] Keyword[new] identifier[NFoldFrameExtractor] operator[SEP] identifier[job] operator[SEP] identifier[source] , identifier[job] operator[SEP] identifier[n_folds] , identifier[i] , identifier[destkeys] , identifier[Key] operator[SEP] identifier[make] operator[SEP] operator[SEP] operator[SEP] operator[SEP] identifier[H2O] operator[SEP] identifier[submitTask] operator[SEP] identifier[nffe] operator[SEP] operator[SEP] identifier[Frame] operator[SEP] operator[SEP] identifier[splits] operator[=] identifier[nffe] operator[SEP] identifier[getResult] operator[SEP] operator[SEP] operator[SEP] Keyword[try] {
identifier[job] operator[SEP] identifier[crossValidate] operator[SEP] identifier[splits] , identifier[cv_preds] , identifier[offsets] , identifier[i] operator[SEP] operator[SEP] identifier[job] operator[SEP] identifier[_cv_count] operator[++] operator[SEP]
}
Keyword[finally] {
Keyword[if] operator[SEP] operator[!] identifier[job] operator[SEP] identifier[keep_cross_validation_splits] operator[SEP] Keyword[for] operator[SEP] identifier[Frame] identifier[f] operator[:] identifier[splits] operator[SEP] identifier[f] operator[SEP] identifier[delete] operator[SEP] operator[SEP] operator[SEP]
}
}
Keyword[if] operator[SEP] identifier[job] operator[SEP] identifier[state] operator[!=] identifier[Job] operator[SEP] identifier[JobState] operator[SEP] identifier[RUNNING] operator[SEP] Keyword[return] operator[SEP] Keyword[final] Keyword[int] identifier[resp_idx] operator[=] identifier[job] operator[SEP] identifier[source] operator[SEP] identifier[find] operator[SEP] identifier[job] operator[SEP] identifier[_responseName] operator[SEP] operator[SEP] identifier[Vec] identifier[response] operator[=] identifier[job] operator[SEP] identifier[source] operator[SEP] identifier[vecs] operator[SEP] operator[SEP] operator[SEP] identifier[resp_idx] operator[SEP] operator[SEP] Keyword[boolean] identifier[put_back] operator[=] identifier[UKV] operator[SEP] identifier[get] operator[SEP] identifier[job] operator[SEP] identifier[response] operator[SEP] identifier[_key] operator[SEP] operator[==] Other[null] operator[SEP] Keyword[if] operator[SEP] identifier[put_back] operator[SEP] {
identifier[job] operator[SEP] identifier[response] operator[=] identifier[response] operator[SEP] Keyword[if] operator[SEP] identifier[job] operator[SEP] identifier[classification] operator[SEP] identifier[job] operator[SEP] identifier[response] operator[=] identifier[job] operator[SEP] identifier[response] operator[SEP] identifier[toEnum] operator[SEP] operator[SEP] operator[SEP] identifier[DKV] operator[SEP] identifier[put] operator[SEP] identifier[job] operator[SEP] identifier[response] operator[SEP] identifier[_key] , identifier[job] operator[SEP] identifier[response] operator[SEP] operator[SEP]
} operator[SEP] operator[SEP] identifier[Model] operator[SEP] identifier[UKV] operator[SEP] identifier[get] operator[SEP] identifier[job] operator[SEP] identifier[destination_key] operator[SEP] operator[SEP] operator[SEP] identifier[scoreCrossValidation] operator[SEP] identifier[job] , identifier[job] operator[SEP] identifier[source] , identifier[response] , identifier[cv_preds] , identifier[offsets] operator[SEP] operator[SEP] Keyword[if] operator[SEP] identifier[put_back] operator[SEP] identifier[UKV] operator[SEP] identifier[remove] operator[SEP] identifier[job] operator[SEP] identifier[response] operator[SEP] identifier[_key] operator[SEP] operator[SEP]
}
Keyword[finally] {
Keyword[for] operator[SEP] identifier[Frame] identifier[f] operator[:] identifier[cv_preds] operator[SEP] Keyword[if] operator[SEP] identifier[f] operator[!=] Other[null] operator[SEP] identifier[f] operator[SEP] identifier[delete] operator[SEP] operator[SEP] operator[SEP]
}
}
|
private void checkHandler(SipServletRequest request) {
MobicentsSipSession sipSessionImpl = (MobicentsSipSession)request.getSession();
if(sipSessionImpl.getHandler() == null) {
try {
sipSessionImpl.setHandler(sipContext.getServletHandler());
// ((SipApplicationSessionImpl)sipSessionImpl.getApplicationSession()).setSipContext(sipContext);
} catch (ServletException se) {
//should never happen
logger.error("Impossible to set the default handler on the newly created request "+ request.toString(),se);
}
}
}
|
class class_name[name] begin[{]
method[checkHandler, return_type[void], modifier[private], parameter[request]] begin[{]
local_variable[type[MobicentsSipSession], sipSessionImpl]
if[binary_operation[call[sipSessionImpl.getHandler, parameter[]], ==, literal[null]]] begin[{]
TryStatement(block=[StatementExpression(expression=MethodInvocation(arguments=[MethodInvocation(arguments=[], member=getServletHandler, postfix_operators=[], prefix_operators=[], qualifier=sipContext, selectors=[], type_arguments=None)], member=setHandler, postfix_operators=[], prefix_operators=[], qualifier=sipSessionImpl, selectors=[], type_arguments=None), label=None)], catches=[CatchClause(block=[StatementExpression(expression=MethodInvocation(arguments=[BinaryOperation(operandl=Literal(postfix_operators=[], prefix_operators=[], qualifier=None, selectors=[], value="Impossible to set the default handler on the newly created request "), operandr=MethodInvocation(arguments=[], member=toString, postfix_operators=[], prefix_operators=[], qualifier=request, selectors=[], type_arguments=None), operator=+), MemberReference(member=se, postfix_operators=[], prefix_operators=[], qualifier=, selectors=[])], member=error, postfix_operators=[], prefix_operators=[], qualifier=logger, selectors=[], type_arguments=None), label=None)], label=None, parameter=CatchClauseParameter(annotations=None, modifiers=None, name=se, types=['ServletException']))], finally_block=None, label=None, resources=None)
else begin[{]
None
end[}]
end[}]
END[}]
|
Keyword[private] Keyword[void] identifier[checkHandler] operator[SEP] identifier[SipServletRequest] identifier[request] operator[SEP] {
identifier[MobicentsSipSession] identifier[sipSessionImpl] operator[=] operator[SEP] identifier[MobicentsSipSession] operator[SEP] identifier[request] operator[SEP] identifier[getSession] operator[SEP] operator[SEP] operator[SEP] Keyword[if] operator[SEP] identifier[sipSessionImpl] operator[SEP] identifier[getHandler] operator[SEP] operator[SEP] operator[==] Other[null] operator[SEP] {
Keyword[try] {
identifier[sipSessionImpl] operator[SEP] identifier[setHandler] operator[SEP] identifier[sipContext] operator[SEP] identifier[getServletHandler] operator[SEP] operator[SEP] operator[SEP] operator[SEP]
}
Keyword[catch] operator[SEP] identifier[ServletException] identifier[se] operator[SEP] {
identifier[logger] operator[SEP] identifier[error] operator[SEP] literal[String] operator[+] identifier[request] operator[SEP] identifier[toString] operator[SEP] operator[SEP] , identifier[se] operator[SEP] operator[SEP]
}
}
}
|
CharPriority[] reserveCharacters(char[] chars, char[] reservedCharacters) {
if (reservedCharacters == null || reservedCharacters.length == 0) {
CharPriority[] result = new CharPriority[chars.length];
for (int i = 0; i < chars.length; i++) {
result[i] = priorityLookupMap.get(chars[i]);
}
return result;
}
Set<Character> charSet = new LinkedHashSet<>(Chars.asList(chars));
for (char reservedCharacter : reservedCharacters) {
charSet.remove(reservedCharacter);
}
CharPriority[] result = new CharPriority[charSet.size()];
int index = 0;
for (char c : charSet) {
result[index++] = priorityLookupMap.get(c);
}
return result;
}
|
class class_name[name] begin[{]
method[reserveCharacters, return_type[type[CharPriority]], modifier[default], parameter[chars, reservedCharacters]] begin[{]
if[binary_operation[binary_operation[member[.reservedCharacters], ==, literal[null]], ||, binary_operation[member[reservedCharacters.length], ==, literal[0]]]] begin[{]
local_variable[type[CharPriority], result]
ForStatement(body=BlockStatement(label=None, statements=[StatementExpression(expression=Assignment(expressionl=MemberReference(member=result, postfix_operators=[], prefix_operators=[], qualifier=, selectors=[ArraySelector(index=MemberReference(member=i, postfix_operators=[], prefix_operators=[], qualifier=, selectors=[]))]), type==, value=MethodInvocation(arguments=[MemberReference(member=chars, postfix_operators=[], prefix_operators=[], qualifier=, selectors=[ArraySelector(index=MemberReference(member=i, postfix_operators=[], prefix_operators=[], qualifier=, selectors=[]))])], member=get, postfix_operators=[], prefix_operators=[], qualifier=priorityLookupMap, selectors=[], type_arguments=None)), label=None)]), control=ForControl(condition=BinaryOperation(operandl=MemberReference(member=i, postfix_operators=[], prefix_operators=[], qualifier=, selectors=[]), operandr=MemberReference(member=length, postfix_operators=[], prefix_operators=[], qualifier=chars, selectors=[]), operator=<), init=VariableDeclaration(annotations=[], declarators=[VariableDeclarator(dimensions=None, initializer=Literal(postfix_operators=[], prefix_operators=[], qualifier=None, selectors=[], value=0), name=i)], modifiers=set(), type=BasicType(dimensions=[], name=int)), update=[MemberReference(member=i, postfix_operators=['++'], prefix_operators=[], qualifier=, selectors=[])]), label=None)
return[member[.result]]
else begin[{]
None
end[}]
local_variable[type[Set], charSet]
ForStatement(body=BlockStatement(label=None, statements=[StatementExpression(expression=MethodInvocation(arguments=[MemberReference(member=reservedCharacter, postfix_operators=[], prefix_operators=[], qualifier=, selectors=[])], member=remove, postfix_operators=[], prefix_operators=[], qualifier=charSet, selectors=[], type_arguments=None), label=None)]), control=EnhancedForControl(iterable=MemberReference(member=reservedCharacters, postfix_operators=[], prefix_operators=[], qualifier=, selectors=[]), var=VariableDeclaration(annotations=[], declarators=[VariableDeclarator(dimensions=None, initializer=None, name=reservedCharacter)], modifiers=set(), type=BasicType(dimensions=[], name=char))), label=None)
local_variable[type[CharPriority], result]
local_variable[type[int], index]
ForStatement(body=BlockStatement(label=None, statements=[StatementExpression(expression=Assignment(expressionl=MemberReference(member=result, postfix_operators=[], prefix_operators=[], qualifier=, selectors=[ArraySelector(index=MemberReference(member=index, postfix_operators=['++'], prefix_operators=[], qualifier=, selectors=[]))]), type==, value=MethodInvocation(arguments=[MemberReference(member=c, postfix_operators=[], prefix_operators=[], qualifier=, selectors=[])], member=get, postfix_operators=[], prefix_operators=[], qualifier=priorityLookupMap, selectors=[], type_arguments=None)), label=None)]), control=EnhancedForControl(iterable=MemberReference(member=charSet, postfix_operators=[], prefix_operators=[], qualifier=, selectors=[]), var=VariableDeclaration(annotations=[], declarators=[VariableDeclarator(dimensions=None, initializer=None, name=c)], modifiers=set(), type=BasicType(dimensions=[], name=char))), label=None)
return[member[.result]]
end[}]
END[}]
|
identifier[CharPriority] operator[SEP] operator[SEP] identifier[reserveCharacters] operator[SEP] Keyword[char] operator[SEP] operator[SEP] identifier[chars] , Keyword[char] operator[SEP] operator[SEP] identifier[reservedCharacters] operator[SEP] {
Keyword[if] operator[SEP] identifier[reservedCharacters] operator[==] Other[null] operator[||] identifier[reservedCharacters] operator[SEP] identifier[length] operator[==] Other[0] operator[SEP] {
identifier[CharPriority] operator[SEP] operator[SEP] identifier[result] operator[=] Keyword[new] identifier[CharPriority] operator[SEP] identifier[chars] operator[SEP] identifier[length] operator[SEP] operator[SEP] Keyword[for] operator[SEP] Keyword[int] identifier[i] operator[=] Other[0] operator[SEP] identifier[i] operator[<] identifier[chars] operator[SEP] identifier[length] operator[SEP] identifier[i] operator[++] operator[SEP] {
identifier[result] operator[SEP] identifier[i] operator[SEP] operator[=] identifier[priorityLookupMap] operator[SEP] identifier[get] operator[SEP] identifier[chars] operator[SEP] identifier[i] operator[SEP] operator[SEP] operator[SEP]
}
Keyword[return] identifier[result] operator[SEP]
}
identifier[Set] operator[<] identifier[Character] operator[>] identifier[charSet] operator[=] Keyword[new] identifier[LinkedHashSet] operator[<] operator[>] operator[SEP] identifier[Chars] operator[SEP] identifier[asList] operator[SEP] identifier[chars] operator[SEP] operator[SEP] operator[SEP] Keyword[for] operator[SEP] Keyword[char] identifier[reservedCharacter] operator[:] identifier[reservedCharacters] operator[SEP] {
identifier[charSet] operator[SEP] identifier[remove] operator[SEP] identifier[reservedCharacter] operator[SEP] operator[SEP]
}
identifier[CharPriority] operator[SEP] operator[SEP] identifier[result] operator[=] Keyword[new] identifier[CharPriority] operator[SEP] identifier[charSet] operator[SEP] identifier[size] operator[SEP] operator[SEP] operator[SEP] operator[SEP] Keyword[int] identifier[index] operator[=] Other[0] operator[SEP] Keyword[for] operator[SEP] Keyword[char] identifier[c] operator[:] identifier[charSet] operator[SEP] {
identifier[result] operator[SEP] identifier[index] operator[++] operator[SEP] operator[=] identifier[priorityLookupMap] operator[SEP] identifier[get] operator[SEP] identifier[c] operator[SEP] operator[SEP]
}
Keyword[return] identifier[result] operator[SEP]
}
|
public void marshall(DeleteEmailChannelRequest deleteEmailChannelRequest, ProtocolMarshaller protocolMarshaller) {
if (deleteEmailChannelRequest == null) {
throw new SdkClientException("Invalid argument passed to marshall(...)");
}
try {
protocolMarshaller.marshall(deleteEmailChannelRequest.getApplicationId(), APPLICATIONID_BINDING);
} catch (Exception e) {
throw new SdkClientException("Unable to marshall request to JSON: " + e.getMessage(), e);
}
}
|
class class_name[name] begin[{]
method[marshall, return_type[void], modifier[public], parameter[deleteEmailChannelRequest, protocolMarshaller]] begin[{]
if[binary_operation[member[.deleteEmailChannelRequest], ==, literal[null]]] begin[{]
ThrowStatement(expression=ClassCreator(arguments=[Literal(postfix_operators=[], prefix_operators=[], qualifier=None, selectors=[], value="Invalid argument passed to marshall(...)")], body=None, constructor_type_arguments=None, postfix_operators=[], prefix_operators=[], qualifier=None, selectors=[], type=ReferenceType(arguments=None, dimensions=None, name=SdkClientException, sub_type=None)), label=None)
else begin[{]
None
end[}]
TryStatement(block=[StatementExpression(expression=MethodInvocation(arguments=[MethodInvocation(arguments=[], member=getApplicationId, postfix_operators=[], prefix_operators=[], qualifier=deleteEmailChannelRequest, selectors=[], type_arguments=None), MemberReference(member=APPLICATIONID_BINDING, postfix_operators=[], prefix_operators=[], qualifier=, selectors=[])], member=marshall, postfix_operators=[], prefix_operators=[], qualifier=protocolMarshaller, selectors=[], type_arguments=None), label=None)], catches=[CatchClause(block=[ThrowStatement(expression=ClassCreator(arguments=[BinaryOperation(operandl=Literal(postfix_operators=[], prefix_operators=[], qualifier=None, selectors=[], value="Unable to marshall request to JSON: "), operandr=MethodInvocation(arguments=[], member=getMessage, postfix_operators=[], prefix_operators=[], qualifier=e, selectors=[], type_arguments=None), operator=+), MemberReference(member=e, postfix_operators=[], prefix_operators=[], qualifier=, selectors=[])], body=None, constructor_type_arguments=None, postfix_operators=[], prefix_operators=[], qualifier=None, selectors=[], type=ReferenceType(arguments=None, dimensions=None, name=SdkClientException, sub_type=None)), label=None)], label=None, parameter=CatchClauseParameter(annotations=None, modifiers=None, name=e, types=['Exception']))], finally_block=None, label=None, resources=None)
end[}]
END[}]
|
Keyword[public] Keyword[void] identifier[marshall] operator[SEP] identifier[DeleteEmailChannelRequest] identifier[deleteEmailChannelRequest] , identifier[ProtocolMarshaller] identifier[protocolMarshaller] operator[SEP] {
Keyword[if] operator[SEP] identifier[deleteEmailChannelRequest] operator[==] Other[null] operator[SEP] {
Keyword[throw] Keyword[new] identifier[SdkClientException] operator[SEP] literal[String] operator[SEP] operator[SEP]
}
Keyword[try] {
identifier[protocolMarshaller] operator[SEP] identifier[marshall] operator[SEP] identifier[deleteEmailChannelRequest] operator[SEP] identifier[getApplicationId] operator[SEP] operator[SEP] , identifier[APPLICATIONID_BINDING] operator[SEP] operator[SEP]
}
Keyword[catch] operator[SEP] identifier[Exception] identifier[e] operator[SEP] {
Keyword[throw] Keyword[new] identifier[SdkClientException] operator[SEP] literal[String] operator[+] identifier[e] operator[SEP] identifier[getMessage] operator[SEP] operator[SEP] , identifier[e] operator[SEP] operator[SEP]
}
}
|
private JButton getBtnCancel() {
if (btnCancel == null) {
btnCancel = new JButton();
btnCancel.setText(Constant.messages.getString("all.button.cancel"));
btnCancel.addActionListener(new java.awt.event.ActionListener() {
@Override
public void actionPerformed(java.awt.event.ActionEvent e) {
getTxtPattern().discardAllEdits();
FilterReplaceDialog.this.dispose();
exitCode = JOptionPane.CANCEL_OPTION;
}
});
}
return btnCancel;
}
|
class class_name[name] begin[{]
method[getBtnCancel, return_type[type[JButton]], modifier[private], parameter[]] begin[{]
if[binary_operation[member[.btnCancel], ==, literal[null]]] begin[{]
assign[member[.btnCancel], ClassCreator(arguments=[], body=None, constructor_type_arguments=None, postfix_operators=[], prefix_operators=[], qualifier=None, selectors=[], type=ReferenceType(arguments=None, dimensions=None, name=JButton, sub_type=None))]
call[btnCancel.setText, parameter[call[Constant.messages.getString, parameter[literal["all.button.cancel"]]]]]
call[btnCancel.addActionListener, parameter[ClassCreator(arguments=[], body=[MethodDeclaration(annotations=[Annotation(element=None, name=Override)], body=[StatementExpression(expression=MethodInvocation(arguments=[], member=getTxtPattern, postfix_operators=[], prefix_operators=[], qualifier=, selectors=[MethodInvocation(arguments=[], member=discardAllEdits, postfix_operators=None, prefix_operators=None, qualifier=None, selectors=None, type_arguments=None)], type_arguments=None), label=None), StatementExpression(expression=This(postfix_operators=[], prefix_operators=[], qualifier=FilterReplaceDialog, selectors=[MethodInvocation(arguments=[], member=dispose, postfix_operators=None, prefix_operators=None, qualifier=None, selectors=None, type_arguments=None)]), label=None), StatementExpression(expression=Assignment(expressionl=MemberReference(member=exitCode, postfix_operators=[], prefix_operators=[], qualifier=, selectors=[]), type==, value=MemberReference(member=CANCEL_OPTION, postfix_operators=[], prefix_operators=[], qualifier=JOptionPane, selectors=[])), label=None)], documentation=None, modifiers={'public'}, name=actionPerformed, parameters=[FormalParameter(annotations=[], modifiers=set(), name=e, type=ReferenceType(arguments=None, dimensions=[], name=java, sub_type=ReferenceType(arguments=None, dimensions=None, name=awt, sub_type=ReferenceType(arguments=None, dimensions=None, name=event, sub_type=ReferenceType(arguments=None, dimensions=None, name=ActionEvent, sub_type=None)))), varargs=False)], return_type=None, throws=None, type_parameters=None)], constructor_type_arguments=None, postfix_operators=[], prefix_operators=[], qualifier=None, selectors=[], type=ReferenceType(arguments=None, dimensions=None, name=java, sub_type=ReferenceType(arguments=None, dimensions=None, name=awt, sub_type=ReferenceType(arguments=None, dimensions=None, name=event, sub_type=ReferenceType(arguments=None, dimensions=None, name=ActionListener, sub_type=None)))))]]
else begin[{]
None
end[}]
return[member[.btnCancel]]
end[}]
END[}]
|
Keyword[private] identifier[JButton] identifier[getBtnCancel] operator[SEP] operator[SEP] {
Keyword[if] operator[SEP] identifier[btnCancel] operator[==] Other[null] operator[SEP] {
identifier[btnCancel] operator[=] Keyword[new] identifier[JButton] operator[SEP] operator[SEP] operator[SEP] identifier[btnCancel] operator[SEP] identifier[setText] operator[SEP] identifier[Constant] operator[SEP] identifier[messages] operator[SEP] identifier[getString] operator[SEP] literal[String] operator[SEP] operator[SEP] operator[SEP] identifier[btnCancel] operator[SEP] identifier[addActionListener] operator[SEP] Keyword[new] identifier[java] operator[SEP] identifier[awt] operator[SEP] identifier[event] operator[SEP] identifier[ActionListener] operator[SEP] operator[SEP] {
annotation[@] identifier[Override] Keyword[public] Keyword[void] identifier[actionPerformed] operator[SEP] identifier[java] operator[SEP] identifier[awt] operator[SEP] identifier[event] operator[SEP] identifier[ActionEvent] identifier[e] operator[SEP] {
identifier[getTxtPattern] operator[SEP] operator[SEP] operator[SEP] identifier[discardAllEdits] operator[SEP] operator[SEP] operator[SEP] identifier[FilterReplaceDialog] operator[SEP] Keyword[this] operator[SEP] identifier[dispose] operator[SEP] operator[SEP] operator[SEP] identifier[exitCode] operator[=] identifier[JOptionPane] operator[SEP] identifier[CANCEL_OPTION] operator[SEP]
}
} operator[SEP] operator[SEP]
}
Keyword[return] identifier[btnCancel] operator[SEP]
}
|
public String getDefaultTableName()
{
String name = getName();
int lastDotPos = name.lastIndexOf('.');
int lastDollarPos = name.lastIndexOf('$');
return lastDollarPos > lastDotPos ? name.substring(lastDollarPos + 1) : name.substring(lastDotPos + 1);
}
|
class class_name[name] begin[{]
method[getDefaultTableName, return_type[type[String]], modifier[public], parameter[]] begin[{]
local_variable[type[String], name]
local_variable[type[int], lastDotPos]
local_variable[type[int], lastDollarPos]
return[TernaryExpression(condition=BinaryOperation(operandl=MemberReference(member=lastDollarPos, postfix_operators=[], prefix_operators=[], qualifier=, selectors=[]), operandr=MemberReference(member=lastDotPos, postfix_operators=[], prefix_operators=[], qualifier=, selectors=[]), operator=>), if_false=MethodInvocation(arguments=[BinaryOperation(operandl=MemberReference(member=lastDotPos, postfix_operators=[], prefix_operators=[], qualifier=, selectors=[]), operandr=Literal(postfix_operators=[], prefix_operators=[], qualifier=None, selectors=[], value=1), operator=+)], member=substring, postfix_operators=[], prefix_operators=[], qualifier=name, selectors=[], type_arguments=None), if_true=MethodInvocation(arguments=[BinaryOperation(operandl=MemberReference(member=lastDollarPos, postfix_operators=[], prefix_operators=[], qualifier=, selectors=[]), operandr=Literal(postfix_operators=[], prefix_operators=[], qualifier=None, selectors=[], value=1), operator=+)], member=substring, postfix_operators=[], prefix_operators=[], qualifier=name, selectors=[], type_arguments=None))]
end[}]
END[}]
|
Keyword[public] identifier[String] identifier[getDefaultTableName] operator[SEP] operator[SEP] {
identifier[String] identifier[name] operator[=] identifier[getName] operator[SEP] operator[SEP] operator[SEP] Keyword[int] identifier[lastDotPos] operator[=] identifier[name] operator[SEP] identifier[lastIndexOf] operator[SEP] literal[String] operator[SEP] operator[SEP] Keyword[int] identifier[lastDollarPos] operator[=] identifier[name] operator[SEP] identifier[lastIndexOf] operator[SEP] literal[String] operator[SEP] operator[SEP] Keyword[return] identifier[lastDollarPos] operator[>] identifier[lastDotPos] operator[?] identifier[name] operator[SEP] identifier[substring] operator[SEP] identifier[lastDollarPos] operator[+] Other[1] operator[SEP] operator[:] identifier[name] operator[SEP] identifier[substring] operator[SEP] identifier[lastDotPos] operator[+] Other[1] operator[SEP] operator[SEP]
}
|
public static <T extends Messages> T getEncoder(Class<T> cls) {
return get(cls, ENCODER);
}
|
class class_name[name] begin[{]
method[getEncoder, return_type[type[T]], modifier[public static], parameter[cls]] begin[{]
return[call[.get, parameter[member[.cls], member[.ENCODER]]]]
end[}]
END[}]
|
Keyword[public] Keyword[static] operator[<] identifier[T] Keyword[extends] identifier[Messages] operator[>] identifier[T] identifier[getEncoder] operator[SEP] identifier[Class] operator[<] identifier[T] operator[>] identifier[cls] operator[SEP] {
Keyword[return] identifier[get] operator[SEP] identifier[cls] , identifier[ENCODER] operator[SEP] operator[SEP]
}
|
public void marshall(CreateHITRequest createHITRequest, ProtocolMarshaller protocolMarshaller) {
if (createHITRequest == null) {
throw new SdkClientException("Invalid argument passed to marshall(...)");
}
try {
protocolMarshaller.marshall(createHITRequest.getMaxAssignments(), MAXASSIGNMENTS_BINDING);
protocolMarshaller.marshall(createHITRequest.getAutoApprovalDelayInSeconds(), AUTOAPPROVALDELAYINSECONDS_BINDING);
protocolMarshaller.marshall(createHITRequest.getLifetimeInSeconds(), LIFETIMEINSECONDS_BINDING);
protocolMarshaller.marshall(createHITRequest.getAssignmentDurationInSeconds(), ASSIGNMENTDURATIONINSECONDS_BINDING);
protocolMarshaller.marshall(createHITRequest.getReward(), REWARD_BINDING);
protocolMarshaller.marshall(createHITRequest.getTitle(), TITLE_BINDING);
protocolMarshaller.marshall(createHITRequest.getKeywords(), KEYWORDS_BINDING);
protocolMarshaller.marshall(createHITRequest.getDescription(), DESCRIPTION_BINDING);
protocolMarshaller.marshall(createHITRequest.getQuestion(), QUESTION_BINDING);
protocolMarshaller.marshall(createHITRequest.getRequesterAnnotation(), REQUESTERANNOTATION_BINDING);
protocolMarshaller.marshall(createHITRequest.getQualificationRequirements(), QUALIFICATIONREQUIREMENTS_BINDING);
protocolMarshaller.marshall(createHITRequest.getUniqueRequestToken(), UNIQUEREQUESTTOKEN_BINDING);
protocolMarshaller.marshall(createHITRequest.getAssignmentReviewPolicy(), ASSIGNMENTREVIEWPOLICY_BINDING);
protocolMarshaller.marshall(createHITRequest.getHITReviewPolicy(), HITREVIEWPOLICY_BINDING);
protocolMarshaller.marshall(createHITRequest.getHITLayoutId(), HITLAYOUTID_BINDING);
protocolMarshaller.marshall(createHITRequest.getHITLayoutParameters(), HITLAYOUTPARAMETERS_BINDING);
} catch (Exception e) {
throw new SdkClientException("Unable to marshall request to JSON: " + e.getMessage(), e);
}
}
|
class class_name[name] begin[{]
method[marshall, return_type[void], modifier[public], parameter[createHITRequest, protocolMarshaller]] begin[{]
if[binary_operation[member[.createHITRequest], ==, literal[null]]] begin[{]
ThrowStatement(expression=ClassCreator(arguments=[Literal(postfix_operators=[], prefix_operators=[], qualifier=None, selectors=[], value="Invalid argument passed to marshall(...)")], body=None, constructor_type_arguments=None, postfix_operators=[], prefix_operators=[], qualifier=None, selectors=[], type=ReferenceType(arguments=None, dimensions=None, name=SdkClientException, sub_type=None)), label=None)
else begin[{]
None
end[}]
TryStatement(block=[StatementExpression(expression=MethodInvocation(arguments=[MethodInvocation(arguments=[], member=getMaxAssignments, postfix_operators=[], prefix_operators=[], qualifier=createHITRequest, selectors=[], type_arguments=None), MemberReference(member=MAXASSIGNMENTS_BINDING, postfix_operators=[], prefix_operators=[], qualifier=, selectors=[])], member=marshall, postfix_operators=[], prefix_operators=[], qualifier=protocolMarshaller, selectors=[], type_arguments=None), label=None), StatementExpression(expression=MethodInvocation(arguments=[MethodInvocation(arguments=[], member=getAutoApprovalDelayInSeconds, postfix_operators=[], prefix_operators=[], qualifier=createHITRequest, selectors=[], type_arguments=None), MemberReference(member=AUTOAPPROVALDELAYINSECONDS_BINDING, postfix_operators=[], prefix_operators=[], qualifier=, selectors=[])], member=marshall, postfix_operators=[], prefix_operators=[], qualifier=protocolMarshaller, selectors=[], type_arguments=None), label=None), StatementExpression(expression=MethodInvocation(arguments=[MethodInvocation(arguments=[], member=getLifetimeInSeconds, postfix_operators=[], prefix_operators=[], qualifier=createHITRequest, selectors=[], type_arguments=None), MemberReference(member=LIFETIMEINSECONDS_BINDING, postfix_operators=[], prefix_operators=[], qualifier=, selectors=[])], member=marshall, postfix_operators=[], prefix_operators=[], qualifier=protocolMarshaller, selectors=[], type_arguments=None), label=None), StatementExpression(expression=MethodInvocation(arguments=[MethodInvocation(arguments=[], member=getAssignmentDurationInSeconds, postfix_operators=[], prefix_operators=[], qualifier=createHITRequest, selectors=[], type_arguments=None), MemberReference(member=ASSIGNMENTDURATIONINSECONDS_BINDING, postfix_operators=[], prefix_operators=[], qualifier=, selectors=[])], member=marshall, postfix_operators=[], prefix_operators=[], qualifier=protocolMarshaller, selectors=[], type_arguments=None), label=None), StatementExpression(expression=MethodInvocation(arguments=[MethodInvocation(arguments=[], member=getReward, postfix_operators=[], prefix_operators=[], qualifier=createHITRequest, selectors=[], type_arguments=None), MemberReference(member=REWARD_BINDING, postfix_operators=[], prefix_operators=[], qualifier=, selectors=[])], member=marshall, postfix_operators=[], prefix_operators=[], qualifier=protocolMarshaller, selectors=[], type_arguments=None), label=None), StatementExpression(expression=MethodInvocation(arguments=[MethodInvocation(arguments=[], member=getTitle, postfix_operators=[], prefix_operators=[], qualifier=createHITRequest, selectors=[], type_arguments=None), MemberReference(member=TITLE_BINDING, postfix_operators=[], prefix_operators=[], qualifier=, selectors=[])], member=marshall, postfix_operators=[], prefix_operators=[], qualifier=protocolMarshaller, selectors=[], type_arguments=None), label=None), StatementExpression(expression=MethodInvocation(arguments=[MethodInvocation(arguments=[], member=getKeywords, postfix_operators=[], prefix_operators=[], qualifier=createHITRequest, selectors=[], type_arguments=None), MemberReference(member=KEYWORDS_BINDING, postfix_operators=[], prefix_operators=[], qualifier=, selectors=[])], member=marshall, postfix_operators=[], prefix_operators=[], qualifier=protocolMarshaller, selectors=[], type_arguments=None), label=None), StatementExpression(expression=MethodInvocation(arguments=[MethodInvocation(arguments=[], member=getDescription, postfix_operators=[], prefix_operators=[], qualifier=createHITRequest, selectors=[], type_arguments=None), MemberReference(member=DESCRIPTION_BINDING, postfix_operators=[], prefix_operators=[], qualifier=, selectors=[])], member=marshall, postfix_operators=[], prefix_operators=[], qualifier=protocolMarshaller, selectors=[], type_arguments=None), label=None), StatementExpression(expression=MethodInvocation(arguments=[MethodInvocation(arguments=[], member=getQuestion, postfix_operators=[], prefix_operators=[], qualifier=createHITRequest, selectors=[], type_arguments=None), MemberReference(member=QUESTION_BINDING, postfix_operators=[], prefix_operators=[], qualifier=, selectors=[])], member=marshall, postfix_operators=[], prefix_operators=[], qualifier=protocolMarshaller, selectors=[], type_arguments=None), label=None), StatementExpression(expression=MethodInvocation(arguments=[MethodInvocation(arguments=[], member=getRequesterAnnotation, postfix_operators=[], prefix_operators=[], qualifier=createHITRequest, selectors=[], type_arguments=None), MemberReference(member=REQUESTERANNOTATION_BINDING, postfix_operators=[], prefix_operators=[], qualifier=, selectors=[])], member=marshall, postfix_operators=[], prefix_operators=[], qualifier=protocolMarshaller, selectors=[], type_arguments=None), label=None), StatementExpression(expression=MethodInvocation(arguments=[MethodInvocation(arguments=[], member=getQualificationRequirements, postfix_operators=[], prefix_operators=[], qualifier=createHITRequest, selectors=[], type_arguments=None), MemberReference(member=QUALIFICATIONREQUIREMENTS_BINDING, postfix_operators=[], prefix_operators=[], qualifier=, selectors=[])], member=marshall, postfix_operators=[], prefix_operators=[], qualifier=protocolMarshaller, selectors=[], type_arguments=None), label=None), StatementExpression(expression=MethodInvocation(arguments=[MethodInvocation(arguments=[], member=getUniqueRequestToken, postfix_operators=[], prefix_operators=[], qualifier=createHITRequest, selectors=[], type_arguments=None), MemberReference(member=UNIQUEREQUESTTOKEN_BINDING, postfix_operators=[], prefix_operators=[], qualifier=, selectors=[])], member=marshall, postfix_operators=[], prefix_operators=[], qualifier=protocolMarshaller, selectors=[], type_arguments=None), label=None), StatementExpression(expression=MethodInvocation(arguments=[MethodInvocation(arguments=[], member=getAssignmentReviewPolicy, postfix_operators=[], prefix_operators=[], qualifier=createHITRequest, selectors=[], type_arguments=None), MemberReference(member=ASSIGNMENTREVIEWPOLICY_BINDING, postfix_operators=[], prefix_operators=[], qualifier=, selectors=[])], member=marshall, postfix_operators=[], prefix_operators=[], qualifier=protocolMarshaller, selectors=[], type_arguments=None), label=None), StatementExpression(expression=MethodInvocation(arguments=[MethodInvocation(arguments=[], member=getHITReviewPolicy, postfix_operators=[], prefix_operators=[], qualifier=createHITRequest, selectors=[], type_arguments=None), MemberReference(member=HITREVIEWPOLICY_BINDING, postfix_operators=[], prefix_operators=[], qualifier=, selectors=[])], member=marshall, postfix_operators=[], prefix_operators=[], qualifier=protocolMarshaller, selectors=[], type_arguments=None), label=None), StatementExpression(expression=MethodInvocation(arguments=[MethodInvocation(arguments=[], member=getHITLayoutId, postfix_operators=[], prefix_operators=[], qualifier=createHITRequest, selectors=[], type_arguments=None), MemberReference(member=HITLAYOUTID_BINDING, postfix_operators=[], prefix_operators=[], qualifier=, selectors=[])], member=marshall, postfix_operators=[], prefix_operators=[], qualifier=protocolMarshaller, selectors=[], type_arguments=None), label=None), StatementExpression(expression=MethodInvocation(arguments=[MethodInvocation(arguments=[], member=getHITLayoutParameters, postfix_operators=[], prefix_operators=[], qualifier=createHITRequest, selectors=[], type_arguments=None), MemberReference(member=HITLAYOUTPARAMETERS_BINDING, postfix_operators=[], prefix_operators=[], qualifier=, selectors=[])], member=marshall, postfix_operators=[], prefix_operators=[], qualifier=protocolMarshaller, selectors=[], type_arguments=None), label=None)], catches=[CatchClause(block=[ThrowStatement(expression=ClassCreator(arguments=[BinaryOperation(operandl=Literal(postfix_operators=[], prefix_operators=[], qualifier=None, selectors=[], value="Unable to marshall request to JSON: "), operandr=MethodInvocation(arguments=[], member=getMessage, postfix_operators=[], prefix_operators=[], qualifier=e, selectors=[], type_arguments=None), operator=+), MemberReference(member=e, postfix_operators=[], prefix_operators=[], qualifier=, selectors=[])], body=None, constructor_type_arguments=None, postfix_operators=[], prefix_operators=[], qualifier=None, selectors=[], type=ReferenceType(arguments=None, dimensions=None, name=SdkClientException, sub_type=None)), label=None)], label=None, parameter=CatchClauseParameter(annotations=None, modifiers=None, name=e, types=['Exception']))], finally_block=None, label=None, resources=None)
end[}]
END[}]
|
Keyword[public] Keyword[void] identifier[marshall] operator[SEP] identifier[CreateHITRequest] identifier[createHITRequest] , identifier[ProtocolMarshaller] identifier[protocolMarshaller] operator[SEP] {
Keyword[if] operator[SEP] identifier[createHITRequest] operator[==] Other[null] operator[SEP] {
Keyword[throw] Keyword[new] identifier[SdkClientException] operator[SEP] literal[String] operator[SEP] operator[SEP]
}
Keyword[try] {
identifier[protocolMarshaller] operator[SEP] identifier[marshall] operator[SEP] identifier[createHITRequest] operator[SEP] identifier[getMaxAssignments] operator[SEP] operator[SEP] , identifier[MAXASSIGNMENTS_BINDING] operator[SEP] operator[SEP] identifier[protocolMarshaller] operator[SEP] identifier[marshall] operator[SEP] identifier[createHITRequest] operator[SEP] identifier[getAutoApprovalDelayInSeconds] operator[SEP] operator[SEP] , identifier[AUTOAPPROVALDELAYINSECONDS_BINDING] operator[SEP] operator[SEP] identifier[protocolMarshaller] operator[SEP] identifier[marshall] operator[SEP] identifier[createHITRequest] operator[SEP] identifier[getLifetimeInSeconds] operator[SEP] operator[SEP] , identifier[LIFETIMEINSECONDS_BINDING] operator[SEP] operator[SEP] identifier[protocolMarshaller] operator[SEP] identifier[marshall] operator[SEP] identifier[createHITRequest] operator[SEP] identifier[getAssignmentDurationInSeconds] operator[SEP] operator[SEP] , identifier[ASSIGNMENTDURATIONINSECONDS_BINDING] operator[SEP] operator[SEP] identifier[protocolMarshaller] operator[SEP] identifier[marshall] operator[SEP] identifier[createHITRequest] operator[SEP] identifier[getReward] operator[SEP] operator[SEP] , identifier[REWARD_BINDING] operator[SEP] operator[SEP] identifier[protocolMarshaller] operator[SEP] identifier[marshall] operator[SEP] identifier[createHITRequest] operator[SEP] identifier[getTitle] operator[SEP] operator[SEP] , identifier[TITLE_BINDING] operator[SEP] operator[SEP] identifier[protocolMarshaller] operator[SEP] identifier[marshall] operator[SEP] identifier[createHITRequest] operator[SEP] identifier[getKeywords] operator[SEP] operator[SEP] , identifier[KEYWORDS_BINDING] operator[SEP] operator[SEP] identifier[protocolMarshaller] operator[SEP] identifier[marshall] operator[SEP] identifier[createHITRequest] operator[SEP] identifier[getDescription] operator[SEP] operator[SEP] , identifier[DESCRIPTION_BINDING] operator[SEP] operator[SEP] identifier[protocolMarshaller] operator[SEP] identifier[marshall] operator[SEP] identifier[createHITRequest] operator[SEP] identifier[getQuestion] operator[SEP] operator[SEP] , identifier[QUESTION_BINDING] operator[SEP] operator[SEP] identifier[protocolMarshaller] operator[SEP] identifier[marshall] operator[SEP] identifier[createHITRequest] operator[SEP] identifier[getRequesterAnnotation] operator[SEP] operator[SEP] , identifier[REQUESTERANNOTATION_BINDING] operator[SEP] operator[SEP] identifier[protocolMarshaller] operator[SEP] identifier[marshall] operator[SEP] identifier[createHITRequest] operator[SEP] identifier[getQualificationRequirements] operator[SEP] operator[SEP] , identifier[QUALIFICATIONREQUIREMENTS_BINDING] operator[SEP] operator[SEP] identifier[protocolMarshaller] operator[SEP] identifier[marshall] operator[SEP] identifier[createHITRequest] operator[SEP] identifier[getUniqueRequestToken] operator[SEP] operator[SEP] , identifier[UNIQUEREQUESTTOKEN_BINDING] operator[SEP] operator[SEP] identifier[protocolMarshaller] operator[SEP] identifier[marshall] operator[SEP] identifier[createHITRequest] operator[SEP] identifier[getAssignmentReviewPolicy] operator[SEP] operator[SEP] , identifier[ASSIGNMENTREVIEWPOLICY_BINDING] operator[SEP] operator[SEP] identifier[protocolMarshaller] operator[SEP] identifier[marshall] operator[SEP] identifier[createHITRequest] operator[SEP] identifier[getHITReviewPolicy] operator[SEP] operator[SEP] , identifier[HITREVIEWPOLICY_BINDING] operator[SEP] operator[SEP] identifier[protocolMarshaller] operator[SEP] identifier[marshall] operator[SEP] identifier[createHITRequest] operator[SEP] identifier[getHITLayoutId] operator[SEP] operator[SEP] , identifier[HITLAYOUTID_BINDING] operator[SEP] operator[SEP] identifier[protocolMarshaller] operator[SEP] identifier[marshall] operator[SEP] identifier[createHITRequest] operator[SEP] identifier[getHITLayoutParameters] operator[SEP] operator[SEP] , identifier[HITLAYOUTPARAMETERS_BINDING] operator[SEP] operator[SEP]
}
Keyword[catch] operator[SEP] identifier[Exception] identifier[e] operator[SEP] {
Keyword[throw] Keyword[new] identifier[SdkClientException] operator[SEP] literal[String] operator[+] identifier[e] operator[SEP] identifier[getMessage] operator[SEP] operator[SEP] , identifier[e] operator[SEP] operator[SEP]
}
}
|
@Override
public void start(PrintStream writer, String[] params) {
// Parse the arguments
parse(params);
// Create a new belief set about neighbours
BeliefSetField[] fields = {new BeliefSetField("name", String.class, true),
new BeliefSetField("gender", String.class, false),};
try {
// Attach this belief set to this agent
this.createBeliefSet(beliefset, fields);
// Add beliefs about neighbours
registerNeighbours(rand, numNeighbours);
Log.debug("Agent " + getName() + " is initialising with " + numNeighbours + " neighbours");
// Post the goal to be friendly
post(new BeFriendly("BeFriendly"));
} catch (BeliefBaseException e) {
Log.error(e.getMessage());
}
}
|
class class_name[name] begin[{]
method[start, return_type[void], modifier[public], parameter[writer, params]] begin[{]
call[.parse, parameter[member[.params]]]
local_variable[type[BeliefSetField], fields]
TryStatement(block=[StatementExpression(expression=This(postfix_operators=[], prefix_operators=[], qualifier=None, selectors=[MethodInvocation(arguments=[MemberReference(member=beliefset, postfix_operators=[], prefix_operators=[], qualifier=, selectors=[]), MemberReference(member=fields, postfix_operators=[], prefix_operators=[], qualifier=, selectors=[])], member=createBeliefSet, postfix_operators=None, prefix_operators=None, qualifier=None, selectors=None, type_arguments=None)]), label=None), StatementExpression(expression=MethodInvocation(arguments=[MemberReference(member=rand, postfix_operators=[], prefix_operators=[], qualifier=, selectors=[]), MemberReference(member=numNeighbours, postfix_operators=[], prefix_operators=[], qualifier=, selectors=[])], member=registerNeighbours, postfix_operators=[], prefix_operators=[], qualifier=, selectors=[], type_arguments=None), label=None), StatementExpression(expression=MethodInvocation(arguments=[BinaryOperation(operandl=BinaryOperation(operandl=BinaryOperation(operandl=BinaryOperation(operandl=Literal(postfix_operators=[], prefix_operators=[], qualifier=None, selectors=[], value="Agent "), operandr=MethodInvocation(arguments=[], member=getName, postfix_operators=[], prefix_operators=[], qualifier=, selectors=[], type_arguments=None), operator=+), operandr=Literal(postfix_operators=[], prefix_operators=[], qualifier=None, selectors=[], value=" is initialising with "), operator=+), operandr=MemberReference(member=numNeighbours, postfix_operators=[], prefix_operators=[], qualifier=, selectors=[]), operator=+), operandr=Literal(postfix_operators=[], prefix_operators=[], qualifier=None, selectors=[], value=" neighbours"), operator=+)], member=debug, postfix_operators=[], prefix_operators=[], qualifier=Log, selectors=[], type_arguments=None), label=None), StatementExpression(expression=MethodInvocation(arguments=[ClassCreator(arguments=[Literal(postfix_operators=[], prefix_operators=[], qualifier=None, selectors=[], value="BeFriendly")], body=None, constructor_type_arguments=None, postfix_operators=[], prefix_operators=[], qualifier=None, selectors=[], type=ReferenceType(arguments=None, dimensions=None, name=BeFriendly, sub_type=None))], member=post, postfix_operators=[], prefix_operators=[], qualifier=, selectors=[], type_arguments=None), label=None)], catches=[CatchClause(block=[StatementExpression(expression=MethodInvocation(arguments=[MethodInvocation(arguments=[], member=getMessage, postfix_operators=[], prefix_operators=[], qualifier=e, selectors=[], type_arguments=None)], member=error, postfix_operators=[], prefix_operators=[], qualifier=Log, selectors=[], type_arguments=None), label=None)], label=None, parameter=CatchClauseParameter(annotations=None, modifiers=None, name=e, types=['BeliefBaseException']))], finally_block=None, label=None, resources=None)
end[}]
END[}]
|
annotation[@] identifier[Override] Keyword[public] Keyword[void] identifier[start] operator[SEP] identifier[PrintStream] identifier[writer] , identifier[String] operator[SEP] operator[SEP] identifier[params] operator[SEP] {
identifier[parse] operator[SEP] identifier[params] operator[SEP] operator[SEP] identifier[BeliefSetField] operator[SEP] operator[SEP] identifier[fields] operator[=] {
Keyword[new] identifier[BeliefSetField] operator[SEP] literal[String] , identifier[String] operator[SEP] Keyword[class] , literal[boolean] operator[SEP] , Keyword[new] identifier[BeliefSetField] operator[SEP] literal[String] , identifier[String] operator[SEP] Keyword[class] , literal[boolean] operator[SEP] ,
} operator[SEP] Keyword[try] {
Keyword[this] operator[SEP] identifier[createBeliefSet] operator[SEP] identifier[beliefset] , identifier[fields] operator[SEP] operator[SEP] identifier[registerNeighbours] operator[SEP] identifier[rand] , identifier[numNeighbours] operator[SEP] operator[SEP] identifier[Log] operator[SEP] identifier[debug] operator[SEP] literal[String] operator[+] identifier[getName] operator[SEP] operator[SEP] operator[+] literal[String] operator[+] identifier[numNeighbours] operator[+] literal[String] operator[SEP] operator[SEP] identifier[post] operator[SEP] Keyword[new] identifier[BeFriendly] operator[SEP] literal[String] operator[SEP] operator[SEP] operator[SEP]
}
Keyword[catch] operator[SEP] identifier[BeliefBaseException] identifier[e] operator[SEP] {
identifier[Log] operator[SEP] identifier[error] operator[SEP] identifier[e] operator[SEP] identifier[getMessage] operator[SEP] operator[SEP] operator[SEP] operator[SEP]
}
}
|
public static RedissonNodeConfig fromJSON(File file) throws IOException {
ConfigSupport support = new ConfigSupport();
return support.fromJSON(file, RedissonNodeConfig.class);
}
|
class class_name[name] begin[{]
method[fromJSON, return_type[type[RedissonNodeConfig]], modifier[public static], parameter[file]] begin[{]
local_variable[type[ConfigSupport], support]
return[call[support.fromJSON, parameter[member[.file], ClassReference(postfix_operators=[], prefix_operators=[], qualifier=, selectors=[], type=ReferenceType(arguments=None, dimensions=None, name=RedissonNodeConfig, sub_type=None))]]]
end[}]
END[}]
|
Keyword[public] Keyword[static] identifier[RedissonNodeConfig] identifier[fromJSON] operator[SEP] identifier[File] identifier[file] operator[SEP] Keyword[throws] identifier[IOException] {
identifier[ConfigSupport] identifier[support] operator[=] Keyword[new] identifier[ConfigSupport] operator[SEP] operator[SEP] operator[SEP] Keyword[return] identifier[support] operator[SEP] identifier[fromJSON] operator[SEP] identifier[file] , identifier[RedissonNodeConfig] operator[SEP] Keyword[class] operator[SEP] operator[SEP]
}
|
public Analysis<SolutionType> setNumRuns(String searchID, int n){
if(!searches.containsKey(searchID)){
throw new UnknownIDException("No search with ID " + searchID + " has been added.");
}
if(n <= 0){
throw new IllegalArgumentException("Number of runs should be strictly positive.");
}
searchNumRuns.put(searchID, n);
return this;
}
|
class class_name[name] begin[{]
method[setNumRuns, return_type[type[Analysis]], modifier[public], parameter[searchID, n]] begin[{]
if[call[searches.containsKey, parameter[member[.searchID]]]] begin[{]
ThrowStatement(expression=ClassCreator(arguments=[BinaryOperation(operandl=BinaryOperation(operandl=Literal(postfix_operators=[], prefix_operators=[], qualifier=None, selectors=[], value="No search with ID "), operandr=MemberReference(member=searchID, postfix_operators=[], prefix_operators=[], qualifier=, selectors=[]), operator=+), operandr=Literal(postfix_operators=[], prefix_operators=[], qualifier=None, selectors=[], value=" has been added."), operator=+)], body=None, constructor_type_arguments=None, postfix_operators=[], prefix_operators=[], qualifier=None, selectors=[], type=ReferenceType(arguments=None, dimensions=None, name=UnknownIDException, sub_type=None)), label=None)
else begin[{]
None
end[}]
if[binary_operation[member[.n], <=, literal[0]]] begin[{]
ThrowStatement(expression=ClassCreator(arguments=[Literal(postfix_operators=[], prefix_operators=[], qualifier=None, selectors=[], value="Number of runs should be strictly positive.")], body=None, constructor_type_arguments=None, postfix_operators=[], prefix_operators=[], qualifier=None, selectors=[], type=ReferenceType(arguments=None, dimensions=None, name=IllegalArgumentException, sub_type=None)), label=None)
else begin[{]
None
end[}]
call[searchNumRuns.put, parameter[member[.searchID], member[.n]]]
return[THIS[]]
end[}]
END[}]
|
Keyword[public] identifier[Analysis] operator[<] identifier[SolutionType] operator[>] identifier[setNumRuns] operator[SEP] identifier[String] identifier[searchID] , Keyword[int] identifier[n] operator[SEP] {
Keyword[if] operator[SEP] operator[!] identifier[searches] operator[SEP] identifier[containsKey] operator[SEP] identifier[searchID] operator[SEP] operator[SEP] {
Keyword[throw] Keyword[new] identifier[UnknownIDException] operator[SEP] literal[String] operator[+] identifier[searchID] operator[+] literal[String] operator[SEP] operator[SEP]
}
Keyword[if] operator[SEP] identifier[n] operator[<=] Other[0] operator[SEP] {
Keyword[throw] Keyword[new] identifier[IllegalArgumentException] operator[SEP] literal[String] operator[SEP] operator[SEP]
}
identifier[searchNumRuns] operator[SEP] identifier[put] operator[SEP] identifier[searchID] , identifier[n] operator[SEP] operator[SEP] Keyword[return] Keyword[this] operator[SEP]
}
|
public static String encodeHash(double latitude, double longitude, int length) {
Preconditions.checkArgument(length > 0 && length <=12, "length must be between 1 and 12");
Preconditions.checkArgument(latitude >= -90 && latitude <= 90,
"latitude must be between -90 and 90 inclusive");
longitude = Position.to180(longitude);
return fromLongToString(encodeHashToLong(latitude, longitude, length));
}
|
class class_name[name] begin[{]
method[encodeHash, return_type[type[String]], modifier[public static], parameter[latitude, longitude, length]] begin[{]
call[Preconditions.checkArgument, parameter[binary_operation[binary_operation[member[.length], >, literal[0]], &&, binary_operation[member[.length], <=, literal[12]]], literal["length must be between 1 and 12"]]]
call[Preconditions.checkArgument, parameter[binary_operation[binary_operation[member[.latitude], >=, literal[90]], &&, binary_operation[member[.latitude], <=, literal[90]]], literal["latitude must be between -90 and 90 inclusive"]]]
assign[member[.longitude], call[Position.to180, parameter[member[.longitude]]]]
return[call[.fromLongToString, parameter[call[.encodeHashToLong, parameter[member[.latitude], member[.longitude], member[.length]]]]]]
end[}]
END[}]
|
Keyword[public] Keyword[static] identifier[String] identifier[encodeHash] operator[SEP] Keyword[double] identifier[latitude] , Keyword[double] identifier[longitude] , Keyword[int] identifier[length] operator[SEP] {
identifier[Preconditions] operator[SEP] identifier[checkArgument] operator[SEP] identifier[length] operator[>] Other[0] operator[&&] identifier[length] operator[<=] Other[12] , literal[String] operator[SEP] operator[SEP] identifier[Preconditions] operator[SEP] identifier[checkArgument] operator[SEP] identifier[latitude] operator[>=] operator[-] Other[90] operator[&&] identifier[latitude] operator[<=] Other[90] , literal[String] operator[SEP] operator[SEP] identifier[longitude] operator[=] identifier[Position] operator[SEP] identifier[to180] operator[SEP] identifier[longitude] operator[SEP] operator[SEP] Keyword[return] identifier[fromLongToString] operator[SEP] identifier[encodeHashToLong] operator[SEP] identifier[latitude] , identifier[longitude] , identifier[length] operator[SEP] operator[SEP] operator[SEP]
}
|
public static Object runMethod(Object object, String method, Object... args) throws JException
{
try
{
final Method m = object.getClass().getMethod(method);
return m.invoke(object, args);
}
catch (Exception e)
{
throw new JException(e);
}
}
|
class class_name[name] begin[{]
method[runMethod, return_type[type[Object]], modifier[public static], parameter[object, method, args]] begin[{]
TryStatement(block=[LocalVariableDeclaration(annotations=[], declarators=[VariableDeclarator(dimensions=[], initializer=MethodInvocation(arguments=[], member=getClass, postfix_operators=[], prefix_operators=[], qualifier=object, selectors=[MethodInvocation(arguments=[MemberReference(member=method, postfix_operators=[], prefix_operators=[], qualifier=, selectors=[])], member=getMethod, postfix_operators=None, prefix_operators=None, qualifier=None, selectors=None, type_arguments=None)], type_arguments=None), name=m)], modifiers={'final'}, type=ReferenceType(arguments=None, dimensions=[], name=Method, sub_type=None)), ReturnStatement(expression=MethodInvocation(arguments=[MemberReference(member=object, postfix_operators=[], prefix_operators=[], qualifier=, selectors=[]), MemberReference(member=args, postfix_operators=[], prefix_operators=[], qualifier=, selectors=[])], member=invoke, postfix_operators=[], prefix_operators=[], qualifier=m, selectors=[], type_arguments=None), label=None)], catches=[CatchClause(block=[ThrowStatement(expression=ClassCreator(arguments=[MemberReference(member=e, postfix_operators=[], prefix_operators=[], qualifier=, selectors=[])], body=None, constructor_type_arguments=None, postfix_operators=[], prefix_operators=[], qualifier=None, selectors=[], type=ReferenceType(arguments=None, dimensions=None, name=JException, sub_type=None)), label=None)], label=None, parameter=CatchClauseParameter(annotations=None, modifiers=None, name=e, types=['Exception']))], finally_block=None, label=None, resources=None)
end[}]
END[}]
|
Keyword[public] Keyword[static] identifier[Object] identifier[runMethod] operator[SEP] identifier[Object] identifier[object] , identifier[String] identifier[method] , identifier[Object] operator[...] identifier[args] operator[SEP] Keyword[throws] identifier[JException] {
Keyword[try] {
Keyword[final] identifier[Method] identifier[m] operator[=] identifier[object] operator[SEP] identifier[getClass] operator[SEP] operator[SEP] operator[SEP] identifier[getMethod] operator[SEP] identifier[method] operator[SEP] operator[SEP] Keyword[return] identifier[m] operator[SEP] identifier[invoke] operator[SEP] identifier[object] , identifier[args] operator[SEP] operator[SEP]
}
Keyword[catch] operator[SEP] identifier[Exception] identifier[e] operator[SEP] {
Keyword[throw] Keyword[new] identifier[JException] operator[SEP] identifier[e] operator[SEP] operator[SEP]
}
}
|
@Override
public void onReceiveSuggestionsResult(final @NonNull SuggestionsResult result, final @NonNull String bucket) {
// Add the mentions and notify the editor/dropdown of the changes on the UI thread
post(new Runnable() {
@Override
public void run() {
if (mSuggestionsAdapter != null) {
mSuggestionsAdapter.addSuggestions(result, bucket, mMentionsEditText);
}
// Make sure the list is scrolled to the top once you receive the first query result
if (mWaitingForFirstResult && mSuggestionsList != null) {
mSuggestionsList.setSelection(0);
mWaitingForFirstResult = false;
}
}
});
}
|
class class_name[name] begin[{]
method[onReceiveSuggestionsResult, return_type[void], modifier[public], parameter[result, bucket]] begin[{]
call[.post, parameter[ClassCreator(arguments=[], body=[MethodDeclaration(annotations=[Annotation(element=None, name=Override)], body=[IfStatement(condition=BinaryOperation(operandl=MemberReference(member=mSuggestionsAdapter, postfix_operators=[], prefix_operators=[], qualifier=, selectors=[]), operandr=Literal(postfix_operators=[], prefix_operators=[], qualifier=None, selectors=[], value=null), operator=!=), else_statement=None, label=None, then_statement=BlockStatement(label=None, statements=[StatementExpression(expression=MethodInvocation(arguments=[MemberReference(member=result, postfix_operators=[], prefix_operators=[], qualifier=, selectors=[]), MemberReference(member=bucket, postfix_operators=[], prefix_operators=[], qualifier=, selectors=[]), MemberReference(member=mMentionsEditText, postfix_operators=[], prefix_operators=[], qualifier=, selectors=[])], member=addSuggestions, postfix_operators=[], prefix_operators=[], qualifier=mSuggestionsAdapter, selectors=[], type_arguments=None), label=None)])), IfStatement(condition=BinaryOperation(operandl=MemberReference(member=mWaitingForFirstResult, postfix_operators=[], prefix_operators=[], qualifier=, selectors=[]), operandr=BinaryOperation(operandl=MemberReference(member=mSuggestionsList, postfix_operators=[], prefix_operators=[], qualifier=, selectors=[]), operandr=Literal(postfix_operators=[], prefix_operators=[], qualifier=None, selectors=[], value=null), operator=!=), operator=&&), else_statement=None, label=None, then_statement=BlockStatement(label=None, statements=[StatementExpression(expression=MethodInvocation(arguments=[Literal(postfix_operators=[], prefix_operators=[], qualifier=None, selectors=[], value=0)], member=setSelection, postfix_operators=[], prefix_operators=[], qualifier=mSuggestionsList, selectors=[], type_arguments=None), label=None), StatementExpression(expression=Assignment(expressionl=MemberReference(member=mWaitingForFirstResult, postfix_operators=[], prefix_operators=[], qualifier=, selectors=[]), type==, value=Literal(postfix_operators=[], prefix_operators=[], qualifier=None, selectors=[], value=false)), label=None)]))], documentation=None, modifiers={'public'}, name=run, parameters=[], return_type=None, throws=None, type_parameters=None)], constructor_type_arguments=None, postfix_operators=[], prefix_operators=[], qualifier=None, selectors=[], type=ReferenceType(arguments=None, dimensions=None, name=Runnable, sub_type=None))]]
end[}]
END[}]
|
annotation[@] identifier[Override] Keyword[public] Keyword[void] identifier[onReceiveSuggestionsResult] operator[SEP] Keyword[final] annotation[@] identifier[NonNull] identifier[SuggestionsResult] identifier[result] , Keyword[final] annotation[@] identifier[NonNull] identifier[String] identifier[bucket] operator[SEP] {
identifier[post] operator[SEP] Keyword[new] identifier[Runnable] operator[SEP] operator[SEP] {
annotation[@] identifier[Override] Keyword[public] Keyword[void] identifier[run] operator[SEP] operator[SEP] {
Keyword[if] operator[SEP] identifier[mSuggestionsAdapter] operator[!=] Other[null] operator[SEP] {
identifier[mSuggestionsAdapter] operator[SEP] identifier[addSuggestions] operator[SEP] identifier[result] , identifier[bucket] , identifier[mMentionsEditText] operator[SEP] operator[SEP]
}
Keyword[if] operator[SEP] identifier[mWaitingForFirstResult] operator[&&] identifier[mSuggestionsList] operator[!=] Other[null] operator[SEP] {
identifier[mSuggestionsList] operator[SEP] identifier[setSelection] operator[SEP] Other[0] operator[SEP] operator[SEP] identifier[mWaitingForFirstResult] operator[=] literal[boolean] operator[SEP]
}
}
} operator[SEP] operator[SEP]
}
|
public String getRequestPath() {
Map<String,String> requestHeaders = getRequestHeaders();
if (requestHeaders == null)
return null;
String path = requestHeaders.get(Listener.METAINFO_REQUEST_PATH);
return path.startsWith("/") ? path : "/" + path;
}
|
class class_name[name] begin[{]
method[getRequestPath, return_type[type[String]], modifier[public], parameter[]] begin[{]
local_variable[type[Map], requestHeaders]
if[binary_operation[member[.requestHeaders], ==, literal[null]]] begin[{]
return[literal[null]]
else begin[{]
None
end[}]
local_variable[type[String], path]
return[TernaryExpression(condition=MethodInvocation(arguments=[Literal(postfix_operators=[], prefix_operators=[], qualifier=None, selectors=[], value="/")], member=startsWith, postfix_operators=[], prefix_operators=[], qualifier=path, selectors=[], type_arguments=None), if_false=BinaryOperation(operandl=Literal(postfix_operators=[], prefix_operators=[], qualifier=None, selectors=[], value="/"), operandr=MemberReference(member=path, postfix_operators=[], prefix_operators=[], qualifier=, selectors=[]), operator=+), if_true=MemberReference(member=path, postfix_operators=[], prefix_operators=[], qualifier=, selectors=[]))]
end[}]
END[}]
|
Keyword[public] identifier[String] identifier[getRequestPath] operator[SEP] operator[SEP] {
identifier[Map] operator[<] identifier[String] , identifier[String] operator[>] identifier[requestHeaders] operator[=] identifier[getRequestHeaders] operator[SEP] operator[SEP] operator[SEP] Keyword[if] operator[SEP] identifier[requestHeaders] operator[==] Other[null] operator[SEP] Keyword[return] Other[null] operator[SEP] identifier[String] identifier[path] operator[=] identifier[requestHeaders] operator[SEP] identifier[get] operator[SEP] identifier[Listener] operator[SEP] identifier[METAINFO_REQUEST_PATH] operator[SEP] operator[SEP] Keyword[return] identifier[path] operator[SEP] identifier[startsWith] operator[SEP] literal[String] operator[SEP] operator[?] identifier[path] operator[:] literal[String] operator[+] identifier[path] operator[SEP]
}
|
protected void adjustIndexMap(Iterable<? extends Element> elements) {
for (Element element : elements) {
if (shouldAddToIndexMap(element)) {
String name = utils.isPackage(element)
? utils.getPackageName((PackageElement)element)
: utils.getSimpleName(element);
char ch = (name.length() == 0) ?
'*' :
Character.toUpperCase(name.charAt(0));
Character unicode = ch;
SortedSet<Element> list = indexmap.computeIfAbsent(unicode,
c -> new TreeSet<>(comparator));
list.add(element);
}
}
}
|
class class_name[name] begin[{]
method[adjustIndexMap, return_type[void], modifier[protected], parameter[elements]] begin[{]
ForStatement(body=BlockStatement(label=None, statements=[IfStatement(condition=MethodInvocation(arguments=[MemberReference(member=element, postfix_operators=[], prefix_operators=[], qualifier=, selectors=[])], member=shouldAddToIndexMap, postfix_operators=[], prefix_operators=[], qualifier=, selectors=[], type_arguments=None), else_statement=None, label=None, then_statement=BlockStatement(label=None, statements=[LocalVariableDeclaration(annotations=[], declarators=[VariableDeclarator(dimensions=[], initializer=TernaryExpression(condition=MethodInvocation(arguments=[MemberReference(member=element, postfix_operators=[], prefix_operators=[], qualifier=, selectors=[])], member=isPackage, postfix_operators=[], prefix_operators=[], qualifier=utils, selectors=[], type_arguments=None), if_false=MethodInvocation(arguments=[MemberReference(member=element, postfix_operators=[], prefix_operators=[], qualifier=, selectors=[])], member=getSimpleName, postfix_operators=[], prefix_operators=[], qualifier=utils, selectors=[], type_arguments=None), if_true=MethodInvocation(arguments=[Cast(expression=MemberReference(member=element, postfix_operators=[], prefix_operators=[], qualifier=, selectors=[]), type=ReferenceType(arguments=None, dimensions=[], name=PackageElement, sub_type=None))], member=getPackageName, postfix_operators=[], prefix_operators=[], qualifier=utils, selectors=[], type_arguments=None)), name=name)], modifiers=set(), type=ReferenceType(arguments=None, dimensions=[], name=String, sub_type=None)), LocalVariableDeclaration(annotations=[], declarators=[VariableDeclarator(dimensions=[], initializer=TernaryExpression(condition=BinaryOperation(operandl=MethodInvocation(arguments=[], member=length, postfix_operators=[], prefix_operators=[], qualifier=name, selectors=[], type_arguments=None), operandr=Literal(postfix_operators=[], prefix_operators=[], qualifier=None, selectors=[], value=0), operator===), if_false=MethodInvocation(arguments=[MethodInvocation(arguments=[Literal(postfix_operators=[], prefix_operators=[], qualifier=None, selectors=[], value=0)], member=charAt, postfix_operators=[], prefix_operators=[], qualifier=name, selectors=[], type_arguments=None)], member=toUpperCase, postfix_operators=[], prefix_operators=[], qualifier=Character, selectors=[], type_arguments=None), if_true=Literal(postfix_operators=[], prefix_operators=[], qualifier=None, selectors=[], value='*')), name=ch)], modifiers=set(), type=BasicType(dimensions=[], name=char)), LocalVariableDeclaration(annotations=[], declarators=[VariableDeclarator(dimensions=[], initializer=MemberReference(member=ch, postfix_operators=[], prefix_operators=[], qualifier=, selectors=[]), name=unicode)], modifiers=set(), type=ReferenceType(arguments=None, dimensions=[], name=Character, sub_type=None)), LocalVariableDeclaration(annotations=[], declarators=[VariableDeclarator(dimensions=[], initializer=MethodInvocation(arguments=[MemberReference(member=unicode, postfix_operators=[], prefix_operators=[], qualifier=, selectors=[]), LambdaExpression(body=ClassCreator(arguments=[MemberReference(member=comparator, postfix_operators=[], prefix_operators=[], qualifier=, selectors=[])], body=None, constructor_type_arguments=None, postfix_operators=[], prefix_operators=[], qualifier=None, selectors=[], type=ReferenceType(arguments=[], dimensions=None, name=TreeSet, sub_type=None)), parameters=[MemberReference(member=c, postfix_operators=[], prefix_operators=[], qualifier=, selectors=[])])], member=computeIfAbsent, postfix_operators=[], prefix_operators=[], qualifier=indexmap, selectors=[], type_arguments=None), name=list)], modifiers=set(), type=ReferenceType(arguments=[TypeArgument(pattern_type=None, type=ReferenceType(arguments=None, dimensions=[], name=Element, sub_type=None))], dimensions=[], name=SortedSet, sub_type=None)), StatementExpression(expression=MethodInvocation(arguments=[MemberReference(member=element, postfix_operators=[], prefix_operators=[], qualifier=, selectors=[])], member=add, postfix_operators=[], prefix_operators=[], qualifier=list, selectors=[], type_arguments=None), label=None)]))]), control=EnhancedForControl(iterable=MemberReference(member=elements, postfix_operators=[], prefix_operators=[], qualifier=, selectors=[]), var=VariableDeclaration(annotations=[], declarators=[VariableDeclarator(dimensions=None, initializer=None, name=element)], modifiers=set(), type=ReferenceType(arguments=None, dimensions=[], name=Element, sub_type=None))), label=None)
end[}]
END[}]
|
Keyword[protected] Keyword[void] identifier[adjustIndexMap] operator[SEP] identifier[Iterable] operator[<] operator[?] Keyword[extends] identifier[Element] operator[>] identifier[elements] operator[SEP] {
Keyword[for] operator[SEP] identifier[Element] identifier[element] operator[:] identifier[elements] operator[SEP] {
Keyword[if] operator[SEP] identifier[shouldAddToIndexMap] operator[SEP] identifier[element] operator[SEP] operator[SEP] {
identifier[String] identifier[name] operator[=] identifier[utils] operator[SEP] identifier[isPackage] operator[SEP] identifier[element] operator[SEP] operator[?] identifier[utils] operator[SEP] identifier[getPackageName] operator[SEP] operator[SEP] identifier[PackageElement] operator[SEP] identifier[element] operator[SEP] operator[:] identifier[utils] operator[SEP] identifier[getSimpleName] operator[SEP] identifier[element] operator[SEP] operator[SEP] Keyword[char] identifier[ch] operator[=] operator[SEP] identifier[name] operator[SEP] identifier[length] operator[SEP] operator[SEP] operator[==] Other[0] operator[SEP] operator[?] literal[String] operator[:] identifier[Character] operator[SEP] identifier[toUpperCase] operator[SEP] identifier[name] operator[SEP] identifier[charAt] operator[SEP] Other[0] operator[SEP] operator[SEP] operator[SEP] identifier[Character] identifier[unicode] operator[=] identifier[ch] operator[SEP] identifier[SortedSet] operator[<] identifier[Element] operator[>] identifier[list] operator[=] identifier[indexmap] operator[SEP] identifier[computeIfAbsent] operator[SEP] identifier[unicode] , identifier[c] operator[->] Keyword[new] identifier[TreeSet] operator[<] operator[>] operator[SEP] identifier[comparator] operator[SEP] operator[SEP] operator[SEP] identifier[list] operator[SEP] identifier[add] operator[SEP] identifier[element] operator[SEP] operator[SEP]
}
}
}
|
public void publishEvents(EventTranslatorVararg<E> translator, int batchStartsAt, int batchSize, Object[]... args) {
checkBounds(batchStartsAt, batchSize, args);
final long finalSequence = sequencer.next(batchSize);
translateAndPublishBatch(translator, batchStartsAt, batchSize, finalSequence, args);
}
|
class class_name[name] begin[{]
method[publishEvents, return_type[void], modifier[public], parameter[translator, batchStartsAt, batchSize, args]] begin[{]
call[.checkBounds, parameter[member[.batchStartsAt], member[.batchSize], member[.args]]]
local_variable[type[long], finalSequence]
call[.translateAndPublishBatch, parameter[member[.translator], member[.batchStartsAt], member[.batchSize], member[.finalSequence], member[.args]]]
end[}]
END[}]
|
Keyword[public] Keyword[void] identifier[publishEvents] operator[SEP] identifier[EventTranslatorVararg] operator[<] identifier[E] operator[>] identifier[translator] , Keyword[int] identifier[batchStartsAt] , Keyword[int] identifier[batchSize] , identifier[Object] operator[SEP] operator[SEP] operator[...] identifier[args] operator[SEP] {
identifier[checkBounds] operator[SEP] identifier[batchStartsAt] , identifier[batchSize] , identifier[args] operator[SEP] operator[SEP] Keyword[final] Keyword[long] identifier[finalSequence] operator[=] identifier[sequencer] operator[SEP] identifier[next] operator[SEP] identifier[batchSize] operator[SEP] operator[SEP] identifier[translateAndPublishBatch] operator[SEP] identifier[translator] , identifier[batchStartsAt] , identifier[batchSize] , identifier[finalSequence] , identifier[args] operator[SEP] operator[SEP]
}
|
public void setPluginList(Path src) {
if (pluginList == null) {
pluginList = src;
} else {
pluginList.append(src);
}
}
|
class class_name[name] begin[{]
method[setPluginList, return_type[void], modifier[public], parameter[src]] begin[{]
if[binary_operation[member[.pluginList], ==, literal[null]]] begin[{]
assign[member[.pluginList], member[.src]]
else begin[{]
call[pluginList.append, parameter[member[.src]]]
end[}]
end[}]
END[}]
|
Keyword[public] Keyword[void] identifier[setPluginList] operator[SEP] identifier[Path] identifier[src] operator[SEP] {
Keyword[if] operator[SEP] identifier[pluginList] operator[==] Other[null] operator[SEP] {
identifier[pluginList] operator[=] identifier[src] operator[SEP]
}
Keyword[else] {
identifier[pluginList] operator[SEP] identifier[append] operator[SEP] identifier[src] operator[SEP] operator[SEP]
}
}
|
private void createRelation(String resourceName, String targetPath, String relationType, boolean importCase)
throws CmsException {
CmsResource resource = readResource(resourceName, CmsResourceFilter.IGNORE_EXPIRATION);
CmsResource target = readResource(targetPath, CmsResourceFilter.IGNORE_EXPIRATION);
createRelation(resource, target, relationType, importCase);
}
|
class class_name[name] begin[{]
method[createRelation, return_type[void], modifier[private], parameter[resourceName, targetPath, relationType, importCase]] begin[{]
local_variable[type[CmsResource], resource]
local_variable[type[CmsResource], target]
call[.createRelation, parameter[member[.resource], member[.target], member[.relationType], member[.importCase]]]
end[}]
END[}]
|
Keyword[private] Keyword[void] identifier[createRelation] operator[SEP] identifier[String] identifier[resourceName] , identifier[String] identifier[targetPath] , identifier[String] identifier[relationType] , Keyword[boolean] identifier[importCase] operator[SEP] Keyword[throws] identifier[CmsException] {
identifier[CmsResource] identifier[resource] operator[=] identifier[readResource] operator[SEP] identifier[resourceName] , identifier[CmsResourceFilter] operator[SEP] identifier[IGNORE_EXPIRATION] operator[SEP] operator[SEP] identifier[CmsResource] identifier[target] operator[=] identifier[readResource] operator[SEP] identifier[targetPath] , identifier[CmsResourceFilter] operator[SEP] identifier[IGNORE_EXPIRATION] operator[SEP] operator[SEP] identifier[createRelation] operator[SEP] identifier[resource] , identifier[target] , identifier[relationType] , identifier[importCase] operator[SEP] operator[SEP]
}
|
public MultiNote[] normalize() {
Hashtable splitter = new Hashtable();
for (int i=0; i<m_notes.size(); i++) {
Note note = (Note)m_notes.elementAt(i);
Short key = note.getStrictDuration();
if (splitter.containsKey(key))
((Vector)splitter.get(key)).addElement(note);
else {
Vector v = new Vector();
v.addElement(note);
splitter.put(key, v);
}
}
short[] strictDurations = getStrictDurations();
MultiNote[] normalizedChords = new MultiNote[strictDurations.length];
for (int i=0; i<strictDurations.length;i++) {
normalizedChords[i] = new MultiNote((Vector)splitter.get(new Short(strictDurations[i])));
}
return normalizedChords;
}
|
class class_name[name] begin[{]
method[normalize, return_type[type[MultiNote]], modifier[public], parameter[]] begin[{]
local_variable[type[Hashtable], splitter]
ForStatement(body=BlockStatement(label=None, statements=[LocalVariableDeclaration(annotations=[], declarators=[VariableDeclarator(dimensions=[], initializer=Cast(expression=MethodInvocation(arguments=[MemberReference(member=i, postfix_operators=[], prefix_operators=[], qualifier=, selectors=[])], member=elementAt, postfix_operators=[], prefix_operators=[], qualifier=m_notes, selectors=[], type_arguments=None), type=ReferenceType(arguments=None, dimensions=[], name=Note, sub_type=None)), name=note)], modifiers=set(), type=ReferenceType(arguments=None, dimensions=[], name=Note, sub_type=None)), LocalVariableDeclaration(annotations=[], declarators=[VariableDeclarator(dimensions=[], initializer=MethodInvocation(arguments=[], member=getStrictDuration, postfix_operators=[], prefix_operators=[], qualifier=note, selectors=[], type_arguments=None), name=key)], modifiers=set(), type=ReferenceType(arguments=None, dimensions=[], name=Short, sub_type=None)), IfStatement(condition=MethodInvocation(arguments=[MemberReference(member=key, postfix_operators=[], prefix_operators=[], qualifier=, selectors=[])], member=containsKey, postfix_operators=[], prefix_operators=[], qualifier=splitter, selectors=[], type_arguments=None), else_statement=BlockStatement(label=None, statements=[LocalVariableDeclaration(annotations=[], declarators=[VariableDeclarator(dimensions=[], initializer=ClassCreator(arguments=[], body=None, constructor_type_arguments=None, postfix_operators=[], prefix_operators=[], qualifier=None, selectors=[], type=ReferenceType(arguments=None, dimensions=None, name=Vector, sub_type=None)), name=v)], modifiers=set(), type=ReferenceType(arguments=None, dimensions=[], name=Vector, sub_type=None)), StatementExpression(expression=MethodInvocation(arguments=[MemberReference(member=note, postfix_operators=[], prefix_operators=[], qualifier=, selectors=[])], member=addElement, postfix_operators=[], prefix_operators=[], qualifier=v, selectors=[], type_arguments=None), label=None), StatementExpression(expression=MethodInvocation(arguments=[MemberReference(member=key, postfix_operators=[], prefix_operators=[], qualifier=, selectors=[]), MemberReference(member=v, postfix_operators=[], prefix_operators=[], qualifier=, selectors=[])], member=put, postfix_operators=[], prefix_operators=[], qualifier=splitter, selectors=[], type_arguments=None), label=None)]), label=None, then_statement=StatementExpression(expression=Cast(expression=MethodInvocation(arguments=[MemberReference(member=key, postfix_operators=[], prefix_operators=[], qualifier=, selectors=[])], member=get, postfix_operators=[], prefix_operators=[], qualifier=splitter, selectors=[], type_arguments=None), type=ReferenceType(arguments=None, dimensions=[], name=Vector, sub_type=None)), label=None))]), control=ForControl(condition=BinaryOperation(operandl=MemberReference(member=i, postfix_operators=[], prefix_operators=[], qualifier=, selectors=[]), operandr=MethodInvocation(arguments=[], member=size, postfix_operators=[], prefix_operators=[], qualifier=m_notes, selectors=[], type_arguments=None), operator=<), init=VariableDeclaration(annotations=[], declarators=[VariableDeclarator(dimensions=None, initializer=Literal(postfix_operators=[], prefix_operators=[], qualifier=None, selectors=[], value=0), name=i)], modifiers=set(), type=BasicType(dimensions=[], name=int)), update=[MemberReference(member=i, postfix_operators=['++'], prefix_operators=[], qualifier=, selectors=[])]), label=None)
local_variable[type[short], strictDurations]
local_variable[type[MultiNote], normalizedChords]
ForStatement(body=BlockStatement(label=None, statements=[StatementExpression(expression=Assignment(expressionl=MemberReference(member=normalizedChords, postfix_operators=[], prefix_operators=[], qualifier=, selectors=[ArraySelector(index=MemberReference(member=i, postfix_operators=[], prefix_operators=[], qualifier=, selectors=[]))]), type==, value=ClassCreator(arguments=[Cast(expression=MethodInvocation(arguments=[ClassCreator(arguments=[MemberReference(member=strictDurations, postfix_operators=[], prefix_operators=[], qualifier=, selectors=[ArraySelector(index=MemberReference(member=i, postfix_operators=[], prefix_operators=[], qualifier=, selectors=[]))])], body=None, constructor_type_arguments=None, postfix_operators=[], prefix_operators=[], qualifier=None, selectors=[], type=ReferenceType(arguments=None, dimensions=None, name=Short, sub_type=None))], member=get, postfix_operators=[], prefix_operators=[], qualifier=splitter, selectors=[], type_arguments=None), type=ReferenceType(arguments=None, dimensions=[], name=Vector, sub_type=None))], body=None, constructor_type_arguments=None, postfix_operators=[], prefix_operators=[], qualifier=None, selectors=[], type=ReferenceType(arguments=None, dimensions=None, name=MultiNote, sub_type=None))), label=None)]), control=ForControl(condition=BinaryOperation(operandl=MemberReference(member=i, postfix_operators=[], prefix_operators=[], qualifier=, selectors=[]), operandr=MemberReference(member=length, postfix_operators=[], prefix_operators=[], qualifier=strictDurations, selectors=[]), operator=<), init=VariableDeclaration(annotations=[], declarators=[VariableDeclarator(dimensions=None, initializer=Literal(postfix_operators=[], prefix_operators=[], qualifier=None, selectors=[], value=0), name=i)], modifiers=set(), type=BasicType(dimensions=[], name=int)), update=[MemberReference(member=i, postfix_operators=['++'], prefix_operators=[], qualifier=, selectors=[])]), label=None)
return[member[.normalizedChords]]
end[}]
END[}]
|
Keyword[public] identifier[MultiNote] operator[SEP] operator[SEP] identifier[normalize] operator[SEP] operator[SEP] {
identifier[Hashtable] identifier[splitter] operator[=] Keyword[new] identifier[Hashtable] operator[SEP] operator[SEP] operator[SEP] Keyword[for] operator[SEP] Keyword[int] identifier[i] operator[=] Other[0] operator[SEP] identifier[i] operator[<] identifier[m_notes] operator[SEP] identifier[size] operator[SEP] operator[SEP] operator[SEP] identifier[i] operator[++] operator[SEP] {
identifier[Note] identifier[note] operator[=] operator[SEP] identifier[Note] operator[SEP] identifier[m_notes] operator[SEP] identifier[elementAt] operator[SEP] identifier[i] operator[SEP] operator[SEP] identifier[Short] identifier[key] operator[=] identifier[note] operator[SEP] identifier[getStrictDuration] operator[SEP] operator[SEP] operator[SEP] Keyword[if] operator[SEP] identifier[splitter] operator[SEP] identifier[containsKey] operator[SEP] identifier[key] operator[SEP] operator[SEP] operator[SEP] operator[SEP] identifier[Vector] operator[SEP] identifier[splitter] operator[SEP] identifier[get] operator[SEP] identifier[key] operator[SEP] operator[SEP] operator[SEP] identifier[addElement] operator[SEP] identifier[note] operator[SEP] operator[SEP] Keyword[else] {
identifier[Vector] identifier[v] operator[=] Keyword[new] identifier[Vector] operator[SEP] operator[SEP] operator[SEP] identifier[v] operator[SEP] identifier[addElement] operator[SEP] identifier[note] operator[SEP] operator[SEP] identifier[splitter] operator[SEP] identifier[put] operator[SEP] identifier[key] , identifier[v] operator[SEP] operator[SEP]
}
}
Keyword[short] operator[SEP] operator[SEP] identifier[strictDurations] operator[=] identifier[getStrictDurations] operator[SEP] operator[SEP] operator[SEP] identifier[MultiNote] operator[SEP] operator[SEP] identifier[normalizedChords] operator[=] Keyword[new] identifier[MultiNote] operator[SEP] identifier[strictDurations] operator[SEP] identifier[length] operator[SEP] operator[SEP] Keyword[for] operator[SEP] Keyword[int] identifier[i] operator[=] Other[0] operator[SEP] identifier[i] operator[<] identifier[strictDurations] operator[SEP] identifier[length] operator[SEP] identifier[i] operator[++] operator[SEP] {
identifier[normalizedChords] operator[SEP] identifier[i] operator[SEP] operator[=] Keyword[new] identifier[MultiNote] operator[SEP] operator[SEP] identifier[Vector] operator[SEP] identifier[splitter] operator[SEP] identifier[get] operator[SEP] Keyword[new] identifier[Short] operator[SEP] identifier[strictDurations] operator[SEP] identifier[i] operator[SEP] operator[SEP] operator[SEP] operator[SEP] operator[SEP]
}
Keyword[return] identifier[normalizedChords] operator[SEP]
}
|
protected static Class mapTypeahead(Class c) {
if(c != null) {
if( PCAModel.class.isAssignableFrom(c) )
return TypeaheadPCAModelKeyRequest.class;
if( NBModel.class.isAssignableFrom(c) )
return TypeaheadNBModelKeyRequest.class;
if( Model.class.isAssignableFrom(c))
return TypeaheadModelKeyRequest.class;
if( Frame.class.isAssignableFrom(c) )
return TypeaheadHexKeyRequest.class;
}
return TypeaheadKeysRequest.class;
}
|
class class_name[name] begin[{]
method[mapTypeahead, return_type[type[Class]], modifier[static protected], parameter[c]] begin[{]
if[binary_operation[member[.c], !=, literal[null]]] begin[{]
if[ClassReference(postfix_operators=[], prefix_operators=[], qualifier=, selectors=[MethodInvocation(arguments=[MemberReference(member=c, postfix_operators=[], prefix_operators=[], qualifier=, selectors=[])], member=isAssignableFrom, postfix_operators=None, prefix_operators=None, qualifier=None, selectors=None, type_arguments=None)], type=ReferenceType(arguments=None, dimensions=None, name=PCAModel, sub_type=None))] begin[{]
return[ClassReference(postfix_operators=[], prefix_operators=[], qualifier=, selectors=[], type=ReferenceType(arguments=None, dimensions=None, name=TypeaheadPCAModelKeyRequest, sub_type=None))]
else begin[{]
None
end[}]
if[ClassReference(postfix_operators=[], prefix_operators=[], qualifier=, selectors=[MethodInvocation(arguments=[MemberReference(member=c, postfix_operators=[], prefix_operators=[], qualifier=, selectors=[])], member=isAssignableFrom, postfix_operators=None, prefix_operators=None, qualifier=None, selectors=None, type_arguments=None)], type=ReferenceType(arguments=None, dimensions=None, name=NBModel, sub_type=None))] begin[{]
return[ClassReference(postfix_operators=[], prefix_operators=[], qualifier=, selectors=[], type=ReferenceType(arguments=None, dimensions=None, name=TypeaheadNBModelKeyRequest, sub_type=None))]
else begin[{]
None
end[}]
if[ClassReference(postfix_operators=[], prefix_operators=[], qualifier=, selectors=[MethodInvocation(arguments=[MemberReference(member=c, postfix_operators=[], prefix_operators=[], qualifier=, selectors=[])], member=isAssignableFrom, postfix_operators=None, prefix_operators=None, qualifier=None, selectors=None, type_arguments=None)], type=ReferenceType(arguments=None, dimensions=None, name=Model, sub_type=None))] begin[{]
return[ClassReference(postfix_operators=[], prefix_operators=[], qualifier=, selectors=[], type=ReferenceType(arguments=None, dimensions=None, name=TypeaheadModelKeyRequest, sub_type=None))]
else begin[{]
None
end[}]
if[ClassReference(postfix_operators=[], prefix_operators=[], qualifier=, selectors=[MethodInvocation(arguments=[MemberReference(member=c, postfix_operators=[], prefix_operators=[], qualifier=, selectors=[])], member=isAssignableFrom, postfix_operators=None, prefix_operators=None, qualifier=None, selectors=None, type_arguments=None)], type=ReferenceType(arguments=None, dimensions=None, name=Frame, sub_type=None))] begin[{]
return[ClassReference(postfix_operators=[], prefix_operators=[], qualifier=, selectors=[], type=ReferenceType(arguments=None, dimensions=None, name=TypeaheadHexKeyRequest, sub_type=None))]
else begin[{]
None
end[}]
else begin[{]
None
end[}]
return[ClassReference(postfix_operators=[], prefix_operators=[], qualifier=, selectors=[], type=ReferenceType(arguments=None, dimensions=None, name=TypeaheadKeysRequest, sub_type=None))]
end[}]
END[}]
|
Keyword[protected] Keyword[static] identifier[Class] identifier[mapTypeahead] operator[SEP] identifier[Class] identifier[c] operator[SEP] {
Keyword[if] operator[SEP] identifier[c] operator[!=] Other[null] operator[SEP] {
Keyword[if] operator[SEP] identifier[PCAModel] operator[SEP] Keyword[class] operator[SEP] identifier[isAssignableFrom] operator[SEP] identifier[c] operator[SEP] operator[SEP] Keyword[return] identifier[TypeaheadPCAModelKeyRequest] operator[SEP] Keyword[class] operator[SEP] Keyword[if] operator[SEP] identifier[NBModel] operator[SEP] Keyword[class] operator[SEP] identifier[isAssignableFrom] operator[SEP] identifier[c] operator[SEP] operator[SEP] Keyword[return] identifier[TypeaheadNBModelKeyRequest] operator[SEP] Keyword[class] operator[SEP] Keyword[if] operator[SEP] identifier[Model] operator[SEP] Keyword[class] operator[SEP] identifier[isAssignableFrom] operator[SEP] identifier[c] operator[SEP] operator[SEP] Keyword[return] identifier[TypeaheadModelKeyRequest] operator[SEP] Keyword[class] operator[SEP] Keyword[if] operator[SEP] identifier[Frame] operator[SEP] Keyword[class] operator[SEP] identifier[isAssignableFrom] operator[SEP] identifier[c] operator[SEP] operator[SEP] Keyword[return] identifier[TypeaheadHexKeyRequest] operator[SEP] Keyword[class] operator[SEP]
}
Keyword[return] identifier[TypeaheadKeysRequest] operator[SEP] Keyword[class] operator[SEP]
}
|
@Override
public AverageClusteringCoefficient<K, VV, EV> run(Graph<K, VV, EV> input)
throws Exception {
super.run(input);
DataSet<LocalClusteringCoefficient.Result<K>> localClusteringCoefficient = input
.run(new LocalClusteringCoefficient<K, VV, EV>()
.setParallelism(parallelism));
averageClusteringCoefficientHelper = new AverageClusteringCoefficientHelper<>();
localClusteringCoefficient
.output(averageClusteringCoefficientHelper)
.name("Average clustering coefficient");
return this;
}
|
class class_name[name] begin[{]
method[run, return_type[type[AverageClusteringCoefficient]], modifier[public], parameter[input]] begin[{]
SuperMethodInvocation(arguments=[MemberReference(member=input, postfix_operators=[], prefix_operators=[], qualifier=, selectors=[])], member=run, postfix_operators=[], prefix_operators=[], qualifier=None, selectors=[], type_arguments=None)
local_variable[type[DataSet], localClusteringCoefficient]
assign[member[.averageClusteringCoefficientHelper], ClassCreator(arguments=[], body=None, constructor_type_arguments=None, postfix_operators=[], prefix_operators=[], qualifier=None, selectors=[], type=ReferenceType(arguments=[], dimensions=None, name=AverageClusteringCoefficientHelper, sub_type=None))]
call[localClusteringCoefficient.output, parameter[member[.averageClusteringCoefficientHelper]]]
return[THIS[]]
end[}]
END[}]
|
annotation[@] identifier[Override] Keyword[public] identifier[AverageClusteringCoefficient] operator[<] identifier[K] , identifier[VV] , identifier[EV] operator[>] identifier[run] operator[SEP] identifier[Graph] operator[<] identifier[K] , identifier[VV] , identifier[EV] operator[>] identifier[input] operator[SEP] Keyword[throws] identifier[Exception] {
Keyword[super] operator[SEP] identifier[run] operator[SEP] identifier[input] operator[SEP] operator[SEP] identifier[DataSet] operator[<] identifier[LocalClusteringCoefficient] operator[SEP] identifier[Result] operator[<] identifier[K] operator[>] operator[>] identifier[localClusteringCoefficient] operator[=] identifier[input] operator[SEP] identifier[run] operator[SEP] Keyword[new] identifier[LocalClusteringCoefficient] operator[<] identifier[K] , identifier[VV] , identifier[EV] operator[>] operator[SEP] operator[SEP] operator[SEP] identifier[setParallelism] operator[SEP] identifier[parallelism] operator[SEP] operator[SEP] operator[SEP] identifier[averageClusteringCoefficientHelper] operator[=] Keyword[new] identifier[AverageClusteringCoefficientHelper] operator[<] operator[>] operator[SEP] operator[SEP] operator[SEP] identifier[localClusteringCoefficient] operator[SEP] identifier[output] operator[SEP] identifier[averageClusteringCoefficientHelper] operator[SEP] operator[SEP] identifier[name] operator[SEP] literal[String] operator[SEP] operator[SEP] Keyword[return] Keyword[this] operator[SEP]
}
|
private Path.Entry<ZipFile> getPackageFile() throws IOException {
// Extract package name from configuration
Value.UTF8 name = configuration.get(Value.UTF8.class, Trie.fromString("package/name"));
// Extract package version from
Value.UTF8 version = configuration.get(Value.UTF8.class, Trie.fromString("package/version"));
// Determine fully qualified package name
Trie pkg = Trie.fromString(name + "-v" + version);
// Dig out the file!
return project.getRepositoryRoot().create(pkg, ZipFile.ContentType);
}
|
class class_name[name] begin[{]
method[getPackageFile, return_type[type[Path]], modifier[private], parameter[]] begin[{]
local_variable[type[Value], name]
local_variable[type[Value], version]
local_variable[type[Trie], pkg]
return[call[project.getRepositoryRoot, parameter[]]]
end[}]
END[}]
|
Keyword[private] identifier[Path] operator[SEP] identifier[Entry] operator[<] identifier[ZipFile] operator[>] identifier[getPackageFile] operator[SEP] operator[SEP] Keyword[throws] identifier[IOException] {
identifier[Value] operator[SEP] identifier[UTF8] identifier[name] operator[=] identifier[configuration] operator[SEP] identifier[get] operator[SEP] identifier[Value] operator[SEP] identifier[UTF8] operator[SEP] Keyword[class] , identifier[Trie] operator[SEP] identifier[fromString] operator[SEP] literal[String] operator[SEP] operator[SEP] operator[SEP] identifier[Value] operator[SEP] identifier[UTF8] identifier[version] operator[=] identifier[configuration] operator[SEP] identifier[get] operator[SEP] identifier[Value] operator[SEP] identifier[UTF8] operator[SEP] Keyword[class] , identifier[Trie] operator[SEP] identifier[fromString] operator[SEP] literal[String] operator[SEP] operator[SEP] operator[SEP] identifier[Trie] identifier[pkg] operator[=] identifier[Trie] operator[SEP] identifier[fromString] operator[SEP] identifier[name] operator[+] literal[String] operator[+] identifier[version] operator[SEP] operator[SEP] Keyword[return] identifier[project] operator[SEP] identifier[getRepositoryRoot] operator[SEP] operator[SEP] operator[SEP] identifier[create] operator[SEP] identifier[pkg] , identifier[ZipFile] operator[SEP] identifier[ContentType] operator[SEP] operator[SEP]
}
|
public final void init(FilterConfig filterConfig) throws ServletException {
Assert.notNull(filterConfig, "FilterConfig must not be null");
logger.debug("Initializing filter '{}'", filterConfig.getFilterName());
this.filterConfig = filterConfig;
initParams(filterConfig);
// Let subclasses do whatever initialization they like.
initFilterBean();
logger.debug("Filter '{}' configured successfully", filterConfig.getFilterName());
}
|
class class_name[name] begin[{]
method[init, return_type[void], modifier[final public], parameter[filterConfig]] begin[{]
call[Assert.notNull, parameter[member[.filterConfig], literal["FilterConfig must not be null"]]]
call[logger.debug, parameter[literal["Initializing filter '{}'"], call[filterConfig.getFilterName, parameter[]]]]
assign[THIS[member[None.filterConfig]], member[.filterConfig]]
call[.initParams, parameter[member[.filterConfig]]]
call[.initFilterBean, parameter[]]
call[logger.debug, parameter[literal["Filter '{}' configured successfully"], call[filterConfig.getFilterName, parameter[]]]]
end[}]
END[}]
|
Keyword[public] Keyword[final] Keyword[void] identifier[init] operator[SEP] identifier[FilterConfig] identifier[filterConfig] operator[SEP] Keyword[throws] identifier[ServletException] {
identifier[Assert] operator[SEP] identifier[notNull] operator[SEP] identifier[filterConfig] , literal[String] operator[SEP] operator[SEP] identifier[logger] operator[SEP] identifier[debug] operator[SEP] literal[String] , identifier[filterConfig] operator[SEP] identifier[getFilterName] operator[SEP] operator[SEP] operator[SEP] operator[SEP] Keyword[this] operator[SEP] identifier[filterConfig] operator[=] identifier[filterConfig] operator[SEP] identifier[initParams] operator[SEP] identifier[filterConfig] operator[SEP] operator[SEP] identifier[initFilterBean] operator[SEP] operator[SEP] operator[SEP] identifier[logger] operator[SEP] identifier[debug] operator[SEP] literal[String] , identifier[filterConfig] operator[SEP] identifier[getFilterName] operator[SEP] operator[SEP] operator[SEP] operator[SEP]
}
|
@SuppressWarnings("unchecked")
public static Throwable getCausedBy(Throwable throwable, Class<? extends Exception>... causeClasses) {
Throwable cause = throwable;
while (cause != null) {
for (Class<? extends Exception> causeClass : causeClasses) {
if (causeClass.isInstance(cause)) {
return cause;
}
}
cause = cause.getCause();
}
return null;
}
|
class class_name[name] begin[{]
method[getCausedBy, return_type[type[Throwable]], modifier[public static], parameter[throwable, causeClasses]] begin[{]
local_variable[type[Throwable], cause]
while[binary_operation[member[.cause], !=, literal[null]]] begin[{]
ForStatement(body=BlockStatement(label=None, statements=[IfStatement(condition=MethodInvocation(arguments=[MemberReference(member=cause, postfix_operators=[], prefix_operators=[], qualifier=, selectors=[])], member=isInstance, postfix_operators=[], prefix_operators=[], qualifier=causeClass, selectors=[], type_arguments=None), else_statement=None, label=None, then_statement=BlockStatement(label=None, statements=[ReturnStatement(expression=MemberReference(member=cause, postfix_operators=[], prefix_operators=[], qualifier=, selectors=[]), label=None)]))]), control=EnhancedForControl(iterable=MemberReference(member=causeClasses, postfix_operators=[], prefix_operators=[], qualifier=, selectors=[]), var=VariableDeclaration(annotations=[], declarators=[VariableDeclarator(dimensions=None, initializer=None, name=causeClass)], modifiers=set(), type=ReferenceType(arguments=[TypeArgument(pattern_type=extends, type=ReferenceType(arguments=None, dimensions=[], name=Exception, sub_type=None))], dimensions=[], name=Class, sub_type=None))), label=None)
assign[member[.cause], call[cause.getCause, parameter[]]]
end[}]
return[literal[null]]
end[}]
END[}]
|
annotation[@] identifier[SuppressWarnings] operator[SEP] literal[String] operator[SEP] Keyword[public] Keyword[static] identifier[Throwable] identifier[getCausedBy] operator[SEP] identifier[Throwable] identifier[throwable] , identifier[Class] operator[<] operator[?] Keyword[extends] identifier[Exception] operator[>] operator[...] identifier[causeClasses] operator[SEP] {
identifier[Throwable] identifier[cause] operator[=] identifier[throwable] operator[SEP] Keyword[while] operator[SEP] identifier[cause] operator[!=] Other[null] operator[SEP] {
Keyword[for] operator[SEP] identifier[Class] operator[<] operator[?] Keyword[extends] identifier[Exception] operator[>] identifier[causeClass] operator[:] identifier[causeClasses] operator[SEP] {
Keyword[if] operator[SEP] identifier[causeClass] operator[SEP] identifier[isInstance] operator[SEP] identifier[cause] operator[SEP] operator[SEP] {
Keyword[return] identifier[cause] operator[SEP]
}
}
identifier[cause] operator[=] identifier[cause] operator[SEP] identifier[getCause] operator[SEP] operator[SEP] operator[SEP]
}
Keyword[return] Other[null] operator[SEP]
}
|
private void fillRampDataIntoBuffers(final int[] leftBuffer, final int[] rightBuffer, final ChannelMemory aktMemo)
{
// Remember changeable values
final int currentTuningPos = aktMemo.currentTuningPos;
final int currentSamplePos = aktMemo.currentSamplePos;
final int currentDirection = aktMemo.currentDirection;
final boolean instrumentFinished = aktMemo.instrumentFinished;
final int actRampVolLeft = aktMemo.actRampVolLeft;
final int actRampVolRight = aktMemo.actRampVolRight;
mixChannelIntoBuffers(leftBuffer, rightBuffer, 0, Helpers.VOL_RAMP_LEN, aktMemo);
// set them back
aktMemo.currentTuningPos = currentTuningPos;
aktMemo.currentSamplePos = currentSamplePos;
aktMemo.instrumentFinished = instrumentFinished;
aktMemo.currentDirection = currentDirection;
aktMemo.actRampVolLeft = actRampVolLeft;
aktMemo.actRampVolRight = actRampVolRight;
}
|
class class_name[name] begin[{]
method[fillRampDataIntoBuffers, return_type[void], modifier[private], parameter[leftBuffer, rightBuffer, aktMemo]] begin[{]
local_variable[type[int], currentTuningPos]
local_variable[type[int], currentSamplePos]
local_variable[type[int], currentDirection]
local_variable[type[boolean], instrumentFinished]
local_variable[type[int], actRampVolLeft]
local_variable[type[int], actRampVolRight]
call[.mixChannelIntoBuffers, parameter[member[.leftBuffer], member[.rightBuffer], literal[0], member[Helpers.VOL_RAMP_LEN], member[.aktMemo]]]
assign[member[aktMemo.currentTuningPos], member[.currentTuningPos]]
assign[member[aktMemo.currentSamplePos], member[.currentSamplePos]]
assign[member[aktMemo.instrumentFinished], member[.instrumentFinished]]
assign[member[aktMemo.currentDirection], member[.currentDirection]]
assign[member[aktMemo.actRampVolLeft], member[.actRampVolLeft]]
assign[member[aktMemo.actRampVolRight], member[.actRampVolRight]]
end[}]
END[}]
|
Keyword[private] Keyword[void] identifier[fillRampDataIntoBuffers] operator[SEP] Keyword[final] Keyword[int] operator[SEP] operator[SEP] identifier[leftBuffer] , Keyword[final] Keyword[int] operator[SEP] operator[SEP] identifier[rightBuffer] , Keyword[final] identifier[ChannelMemory] identifier[aktMemo] operator[SEP] {
Keyword[final] Keyword[int] identifier[currentTuningPos] operator[=] identifier[aktMemo] operator[SEP] identifier[currentTuningPos] operator[SEP] Keyword[final] Keyword[int] identifier[currentSamplePos] operator[=] identifier[aktMemo] operator[SEP] identifier[currentSamplePos] operator[SEP] Keyword[final] Keyword[int] identifier[currentDirection] operator[=] identifier[aktMemo] operator[SEP] identifier[currentDirection] operator[SEP] Keyword[final] Keyword[boolean] identifier[instrumentFinished] operator[=] identifier[aktMemo] operator[SEP] identifier[instrumentFinished] operator[SEP] Keyword[final] Keyword[int] identifier[actRampVolLeft] operator[=] identifier[aktMemo] operator[SEP] identifier[actRampVolLeft] operator[SEP] Keyword[final] Keyword[int] identifier[actRampVolRight] operator[=] identifier[aktMemo] operator[SEP] identifier[actRampVolRight] operator[SEP] identifier[mixChannelIntoBuffers] operator[SEP] identifier[leftBuffer] , identifier[rightBuffer] , Other[0] , identifier[Helpers] operator[SEP] identifier[VOL_RAMP_LEN] , identifier[aktMemo] operator[SEP] operator[SEP] identifier[aktMemo] operator[SEP] identifier[currentTuningPos] operator[=] identifier[currentTuningPos] operator[SEP] identifier[aktMemo] operator[SEP] identifier[currentSamplePos] operator[=] identifier[currentSamplePos] operator[SEP] identifier[aktMemo] operator[SEP] identifier[instrumentFinished] operator[=] identifier[instrumentFinished] operator[SEP] identifier[aktMemo] operator[SEP] identifier[currentDirection] operator[=] identifier[currentDirection] operator[SEP] identifier[aktMemo] operator[SEP] identifier[actRampVolLeft] operator[=] identifier[actRampVolLeft] operator[SEP] identifier[aktMemo] operator[SEP] identifier[actRampVolRight] operator[=] identifier[actRampVolRight] operator[SEP]
}
|
private VirtualTransformedRenditionMetadata getCropRendition(NavigableSet<RenditionMetadata> candidates) {
RenditionMetadata original = getOriginalRendition();
if (original == null) {
return null;
}
Double scaleFactor = getCropScaleFactor();
CropDimension scaledCropDimension = new CropDimension(
Math.round(cropDimension.getLeft() * scaleFactor),
Math.round(cropDimension.getTop() * scaleFactor),
Math.round(cropDimension.getWidth() * scaleFactor),
Math.round(cropDimension.getHeight() * scaleFactor));
return new VirtualTransformedRenditionMetadata(original.getRendition(),
rotateMapWidth(scaledCropDimension.getWidth(), scaledCropDimension.getHeight()),
rotateMapHeight(scaledCropDimension.getWidth(), scaledCropDimension.getHeight()),
scaledCropDimension, rotation);
}
|
class class_name[name] begin[{]
method[getCropRendition, return_type[type[VirtualTransformedRenditionMetadata]], modifier[private], parameter[candidates]] begin[{]
local_variable[type[RenditionMetadata], original]
if[binary_operation[member[.original], ==, literal[null]]] begin[{]
return[literal[null]]
else begin[{]
None
end[}]
local_variable[type[Double], scaleFactor]
local_variable[type[CropDimension], scaledCropDimension]
return[ClassCreator(arguments=[MethodInvocation(arguments=[], member=getRendition, postfix_operators=[], prefix_operators=[], qualifier=original, selectors=[], type_arguments=None), MethodInvocation(arguments=[MethodInvocation(arguments=[], member=getWidth, postfix_operators=[], prefix_operators=[], qualifier=scaledCropDimension, selectors=[], type_arguments=None), MethodInvocation(arguments=[], member=getHeight, postfix_operators=[], prefix_operators=[], qualifier=scaledCropDimension, selectors=[], type_arguments=None)], member=rotateMapWidth, postfix_operators=[], prefix_operators=[], qualifier=, selectors=[], type_arguments=None), MethodInvocation(arguments=[MethodInvocation(arguments=[], member=getWidth, postfix_operators=[], prefix_operators=[], qualifier=scaledCropDimension, selectors=[], type_arguments=None), MethodInvocation(arguments=[], member=getHeight, postfix_operators=[], prefix_operators=[], qualifier=scaledCropDimension, selectors=[], type_arguments=None)], member=rotateMapHeight, postfix_operators=[], prefix_operators=[], qualifier=, selectors=[], type_arguments=None), MemberReference(member=scaledCropDimension, postfix_operators=[], prefix_operators=[], qualifier=, selectors=[]), MemberReference(member=rotation, postfix_operators=[], prefix_operators=[], qualifier=, selectors=[])], body=None, constructor_type_arguments=None, postfix_operators=[], prefix_operators=[], qualifier=None, selectors=[], type=ReferenceType(arguments=None, dimensions=None, name=VirtualTransformedRenditionMetadata, sub_type=None))]
end[}]
END[}]
|
Keyword[private] identifier[VirtualTransformedRenditionMetadata] identifier[getCropRendition] operator[SEP] identifier[NavigableSet] operator[<] identifier[RenditionMetadata] operator[>] identifier[candidates] operator[SEP] {
identifier[RenditionMetadata] identifier[original] operator[=] identifier[getOriginalRendition] operator[SEP] operator[SEP] operator[SEP] Keyword[if] operator[SEP] identifier[original] operator[==] Other[null] operator[SEP] {
Keyword[return] Other[null] operator[SEP]
}
identifier[Double] identifier[scaleFactor] operator[=] identifier[getCropScaleFactor] operator[SEP] operator[SEP] operator[SEP] identifier[CropDimension] identifier[scaledCropDimension] operator[=] Keyword[new] identifier[CropDimension] operator[SEP] identifier[Math] operator[SEP] identifier[round] operator[SEP] identifier[cropDimension] operator[SEP] identifier[getLeft] operator[SEP] operator[SEP] operator[*] identifier[scaleFactor] operator[SEP] , identifier[Math] operator[SEP] identifier[round] operator[SEP] identifier[cropDimension] operator[SEP] identifier[getTop] operator[SEP] operator[SEP] operator[*] identifier[scaleFactor] operator[SEP] , identifier[Math] operator[SEP] identifier[round] operator[SEP] identifier[cropDimension] operator[SEP] identifier[getWidth] operator[SEP] operator[SEP] operator[*] identifier[scaleFactor] operator[SEP] , identifier[Math] operator[SEP] identifier[round] operator[SEP] identifier[cropDimension] operator[SEP] identifier[getHeight] operator[SEP] operator[SEP] operator[*] identifier[scaleFactor] operator[SEP] operator[SEP] operator[SEP] Keyword[return] Keyword[new] identifier[VirtualTransformedRenditionMetadata] operator[SEP] identifier[original] operator[SEP] identifier[getRendition] operator[SEP] operator[SEP] , identifier[rotateMapWidth] operator[SEP] identifier[scaledCropDimension] operator[SEP] identifier[getWidth] operator[SEP] operator[SEP] , identifier[scaledCropDimension] operator[SEP] identifier[getHeight] operator[SEP] operator[SEP] operator[SEP] , identifier[rotateMapHeight] operator[SEP] identifier[scaledCropDimension] operator[SEP] identifier[getWidth] operator[SEP] operator[SEP] , identifier[scaledCropDimension] operator[SEP] identifier[getHeight] operator[SEP] operator[SEP] operator[SEP] , identifier[scaledCropDimension] , identifier[rotation] operator[SEP] operator[SEP]
}
|
public static boolean deleteFile(File file) throws IOException {
if (file.isDirectory()) {
throw new IOException("File " + file + " isn't a file.");
}
if (!file.delete()) {
if (System.getProperty("os.name").equalsIgnoreCase("windows")) {
file = file.getCanonicalFile();
System.gc();
}
try {
Thread.sleep(10);
return file.delete();
} catch (InterruptedException ex) {
return file.delete();
}
}
return true;
}
|
class class_name[name] begin[{]
method[deleteFile, return_type[type[boolean]], modifier[public static], parameter[file]] begin[{]
if[call[file.isDirectory, parameter[]]] begin[{]
ThrowStatement(expression=ClassCreator(arguments=[BinaryOperation(operandl=BinaryOperation(operandl=Literal(postfix_operators=[], prefix_operators=[], qualifier=None, selectors=[], value="File "), operandr=MemberReference(member=file, postfix_operators=[], prefix_operators=[], qualifier=, selectors=[]), operator=+), operandr=Literal(postfix_operators=[], prefix_operators=[], qualifier=None, selectors=[], value=" isn't a file."), operator=+)], body=None, constructor_type_arguments=None, postfix_operators=[], prefix_operators=[], qualifier=None, selectors=[], type=ReferenceType(arguments=None, dimensions=None, name=IOException, sub_type=None)), label=None)
else begin[{]
None
end[}]
if[call[file.delete, parameter[]]] begin[{]
if[call[System.getProperty, parameter[literal["os.name"]]]] begin[{]
assign[member[.file], call[file.getCanonicalFile, parameter[]]]
call[System.gc, parameter[]]
else begin[{]
None
end[}]
TryStatement(block=[StatementExpression(expression=MethodInvocation(arguments=[Literal(postfix_operators=[], prefix_operators=[], qualifier=None, selectors=[], value=10)], member=sleep, postfix_operators=[], prefix_operators=[], qualifier=Thread, selectors=[], type_arguments=None), label=None), ReturnStatement(expression=MethodInvocation(arguments=[], member=delete, postfix_operators=[], prefix_operators=[], qualifier=file, selectors=[], type_arguments=None), label=None)], catches=[CatchClause(block=[ReturnStatement(expression=MethodInvocation(arguments=[], member=delete, postfix_operators=[], prefix_operators=[], qualifier=file, selectors=[], type_arguments=None), label=None)], label=None, parameter=CatchClauseParameter(annotations=None, modifiers=None, name=ex, types=['InterruptedException']))], finally_block=None, label=None, resources=None)
else begin[{]
None
end[}]
return[literal[true]]
end[}]
END[}]
|
Keyword[public] Keyword[static] Keyword[boolean] identifier[deleteFile] operator[SEP] identifier[File] identifier[file] operator[SEP] Keyword[throws] identifier[IOException] {
Keyword[if] operator[SEP] identifier[file] operator[SEP] identifier[isDirectory] operator[SEP] operator[SEP] operator[SEP] {
Keyword[throw] Keyword[new] identifier[IOException] operator[SEP] literal[String] operator[+] identifier[file] operator[+] literal[String] operator[SEP] operator[SEP]
}
Keyword[if] operator[SEP] operator[!] identifier[file] operator[SEP] identifier[delete] operator[SEP] operator[SEP] operator[SEP] {
Keyword[if] operator[SEP] identifier[System] operator[SEP] identifier[getProperty] operator[SEP] literal[String] operator[SEP] operator[SEP] identifier[equalsIgnoreCase] operator[SEP] literal[String] operator[SEP] operator[SEP] {
identifier[file] operator[=] identifier[file] operator[SEP] identifier[getCanonicalFile] operator[SEP] operator[SEP] operator[SEP] identifier[System] operator[SEP] identifier[gc] operator[SEP] operator[SEP] operator[SEP]
}
Keyword[try] {
identifier[Thread] operator[SEP] identifier[sleep] operator[SEP] Other[10] operator[SEP] operator[SEP] Keyword[return] identifier[file] operator[SEP] identifier[delete] operator[SEP] operator[SEP] operator[SEP]
}
Keyword[catch] operator[SEP] identifier[InterruptedException] identifier[ex] operator[SEP] {
Keyword[return] identifier[file] operator[SEP] identifier[delete] operator[SEP] operator[SEP] operator[SEP]
}
}
Keyword[return] literal[boolean] operator[SEP]
}
|
public void marshall(GetDeploymentStatusRequest getDeploymentStatusRequest, ProtocolMarshaller protocolMarshaller) {
if (getDeploymentStatusRequest == null) {
throw new SdkClientException("Invalid argument passed to marshall(...)");
}
try {
protocolMarshaller.marshall(getDeploymentStatusRequest.getDeploymentId(), DEPLOYMENTID_BINDING);
protocolMarshaller.marshall(getDeploymentStatusRequest.getGroupId(), GROUPID_BINDING);
} catch (Exception e) {
throw new SdkClientException("Unable to marshall request to JSON: " + e.getMessage(), e);
}
}
|
class class_name[name] begin[{]
method[marshall, return_type[void], modifier[public], parameter[getDeploymentStatusRequest, protocolMarshaller]] begin[{]
if[binary_operation[member[.getDeploymentStatusRequest], ==, literal[null]]] begin[{]
ThrowStatement(expression=ClassCreator(arguments=[Literal(postfix_operators=[], prefix_operators=[], qualifier=None, selectors=[], value="Invalid argument passed to marshall(...)")], body=None, constructor_type_arguments=None, postfix_operators=[], prefix_operators=[], qualifier=None, selectors=[], type=ReferenceType(arguments=None, dimensions=None, name=SdkClientException, sub_type=None)), label=None)
else begin[{]
None
end[}]
TryStatement(block=[StatementExpression(expression=MethodInvocation(arguments=[MethodInvocation(arguments=[], member=getDeploymentId, postfix_operators=[], prefix_operators=[], qualifier=getDeploymentStatusRequest, selectors=[], type_arguments=None), MemberReference(member=DEPLOYMENTID_BINDING, postfix_operators=[], prefix_operators=[], qualifier=, selectors=[])], member=marshall, postfix_operators=[], prefix_operators=[], qualifier=protocolMarshaller, selectors=[], type_arguments=None), label=None), StatementExpression(expression=MethodInvocation(arguments=[MethodInvocation(arguments=[], member=getGroupId, postfix_operators=[], prefix_operators=[], qualifier=getDeploymentStatusRequest, selectors=[], type_arguments=None), MemberReference(member=GROUPID_BINDING, postfix_operators=[], prefix_operators=[], qualifier=, selectors=[])], member=marshall, postfix_operators=[], prefix_operators=[], qualifier=protocolMarshaller, selectors=[], type_arguments=None), label=None)], catches=[CatchClause(block=[ThrowStatement(expression=ClassCreator(arguments=[BinaryOperation(operandl=Literal(postfix_operators=[], prefix_operators=[], qualifier=None, selectors=[], value="Unable to marshall request to JSON: "), operandr=MethodInvocation(arguments=[], member=getMessage, postfix_operators=[], prefix_operators=[], qualifier=e, selectors=[], type_arguments=None), operator=+), MemberReference(member=e, postfix_operators=[], prefix_operators=[], qualifier=, selectors=[])], body=None, constructor_type_arguments=None, postfix_operators=[], prefix_operators=[], qualifier=None, selectors=[], type=ReferenceType(arguments=None, dimensions=None, name=SdkClientException, sub_type=None)), label=None)], label=None, parameter=CatchClauseParameter(annotations=None, modifiers=None, name=e, types=['Exception']))], finally_block=None, label=None, resources=None)
end[}]
END[}]
|
Keyword[public] Keyword[void] identifier[marshall] operator[SEP] identifier[GetDeploymentStatusRequest] identifier[getDeploymentStatusRequest] , identifier[ProtocolMarshaller] identifier[protocolMarshaller] operator[SEP] {
Keyword[if] operator[SEP] identifier[getDeploymentStatusRequest] operator[==] Other[null] operator[SEP] {
Keyword[throw] Keyword[new] identifier[SdkClientException] operator[SEP] literal[String] operator[SEP] operator[SEP]
}
Keyword[try] {
identifier[protocolMarshaller] operator[SEP] identifier[marshall] operator[SEP] identifier[getDeploymentStatusRequest] operator[SEP] identifier[getDeploymentId] operator[SEP] operator[SEP] , identifier[DEPLOYMENTID_BINDING] operator[SEP] operator[SEP] identifier[protocolMarshaller] operator[SEP] identifier[marshall] operator[SEP] identifier[getDeploymentStatusRequest] operator[SEP] identifier[getGroupId] operator[SEP] operator[SEP] , identifier[GROUPID_BINDING] operator[SEP] operator[SEP]
}
Keyword[catch] operator[SEP] identifier[Exception] identifier[e] operator[SEP] {
Keyword[throw] Keyword[new] identifier[SdkClientException] operator[SEP] literal[String] operator[+] identifier[e] operator[SEP] identifier[getMessage] operator[SEP] operator[SEP] , identifier[e] operator[SEP] operator[SEP]
}
}
|
@BetaApi(
"The surface for long-running operations is not stable yet and may change in the future.")
public final OperationFuture<ExportAssetsResponse, ExportAssetsRequest> exportAssetsAsync(
ExportAssetsRequest request) {
return exportAssetsOperationCallable().futureCall(request);
}
|
class class_name[name] begin[{]
method[exportAssetsAsync, return_type[type[OperationFuture]], modifier[final public], parameter[request]] begin[{]
return[call[.exportAssetsOperationCallable, parameter[]]]
end[}]
END[}]
|
annotation[@] identifier[BetaApi] operator[SEP] literal[String] operator[SEP] Keyword[public] Keyword[final] identifier[OperationFuture] operator[<] identifier[ExportAssetsResponse] , identifier[ExportAssetsRequest] operator[>] identifier[exportAssetsAsync] operator[SEP] identifier[ExportAssetsRequest] identifier[request] operator[SEP] {
Keyword[return] identifier[exportAssetsOperationCallable] operator[SEP] operator[SEP] operator[SEP] identifier[futureCall] operator[SEP] identifier[request] operator[SEP] operator[SEP]
}
|
private DefaultSipApplicationRouterInfo parseSipApplicationRouterInfo(String sipApplicationRouterInfoStringified)
throws ParseException {
// there will always have 6 parameters in a SipApplicationRouterInfo for the default applicationRouterInfo
String[] sipApplicationRouterInfoParameters = new String[SIP_APPLICATION_ROUTER_INFO_PARAM_NB];
for (int i = 0; i < SIP_APPLICATION_ROUTER_INFO_PARAM_NB; i++) {
int indexOfLeftQuote = sipApplicationRouterInfoStringified.indexOf("\"");
if (indexOfLeftQuote == -1) {
throw new ParseException(
"Left quote expected. Cannot parse the following string from the default application router file"
+ sipApplicationRouterInfoStringified, 0);
}
int indexOfRightQuote = sipApplicationRouterInfoStringified.substring(indexOfLeftQuote + 1).indexOf("\"");
if (indexOfRightQuote == -1) {
throw new ParseException(
"Right quote expected. Cannot parse the following string from the default application router file "
+ sipApplicationRouterInfoStringified, 0);
}
indexOfRightQuote += indexOfLeftQuote;
String sipApplicationRouterInfoParameter = sipApplicationRouterInfoStringified.substring(indexOfLeftQuote + 1,
indexOfRightQuote + 1);
sipApplicationRouterInfoParameters[i] = sipApplicationRouterInfoParameter;
sipApplicationRouterInfoStringified = sipApplicationRouterInfoStringified.substring(indexOfRightQuote + 2);
}
// Parse optional DAR field while is a set of key/value pairs
String optionalParameters = null;
int indexOfLeftQuote = sipApplicationRouterInfoStringified.indexOf("\"");
if (indexOfLeftQuote != -1) {
int indexOfRightQuote = sipApplicationRouterInfoStringified.substring(indexOfLeftQuote + 1).indexOf("\"");
if (indexOfRightQuote != -1) {
indexOfRightQuote += indexOfLeftQuote;
optionalParameters = sipApplicationRouterInfoStringified.substring(indexOfLeftQuote + 1, indexOfRightQuote + 1);
} else {
throw new ParseException("Expected a right quote in the optiona parameters", indexOfLeftQuote);
}
}
// Parsing is done
int order = -1;
try {
order = Integer.parseInt(sipApplicationRouterInfoParameters[5]);
} catch (NumberFormatException nfe) {
throw new ParseException("Impossible to parse the state info into an integer for this line "
+ sipApplicationRouterInfoStringified, 0);
}
return new DefaultSipApplicationRouterInfo(
// application name
sipApplicationRouterInfoParameters[0],
// subsriberURI
sipApplicationRouterInfoParameters[1],
// routing region
new SipApplicationRoutingRegion(sipApplicationRouterInfoParameters[2], SipApplicationRoutingRegionType.valueOf(
SipApplicationRoutingRegionType.class, sipApplicationRouterInfoParameters[2])),
// route
new String[] { sipApplicationRouterInfoParameters[3] },
// sip route modifier
SipRouteModifier.valueOf(SipRouteModifier.class, sipApplicationRouterInfoParameters[4]),
// stateinfo
order, optionalParameters);
}
|
class class_name[name] begin[{]
method[parseSipApplicationRouterInfo, return_type[type[DefaultSipApplicationRouterInfo]], modifier[private], parameter[sipApplicationRouterInfoStringified]] begin[{]
local_variable[type[String], sipApplicationRouterInfoParameters]
ForStatement(body=BlockStatement(label=None, statements=[LocalVariableDeclaration(annotations=[], declarators=[VariableDeclarator(dimensions=[], initializer=MethodInvocation(arguments=[Literal(postfix_operators=[], prefix_operators=[], qualifier=None, selectors=[], value="\"")], member=indexOf, postfix_operators=[], prefix_operators=[], qualifier=sipApplicationRouterInfoStringified, selectors=[], type_arguments=None), name=indexOfLeftQuote)], modifiers=set(), type=BasicType(dimensions=[], name=int)), IfStatement(condition=BinaryOperation(operandl=MemberReference(member=indexOfLeftQuote, postfix_operators=[], prefix_operators=[], qualifier=, selectors=[]), operandr=Literal(postfix_operators=[], prefix_operators=['-'], qualifier=None, selectors=[], value=1), operator===), else_statement=None, label=None, then_statement=BlockStatement(label=None, statements=[ThrowStatement(expression=ClassCreator(arguments=[BinaryOperation(operandl=Literal(postfix_operators=[], prefix_operators=[], qualifier=None, selectors=[], value="Left quote expected. Cannot parse the following string from the default application router file"), operandr=MemberReference(member=sipApplicationRouterInfoStringified, postfix_operators=[], prefix_operators=[], qualifier=, selectors=[]), operator=+), Literal(postfix_operators=[], prefix_operators=[], qualifier=None, selectors=[], value=0)], body=None, constructor_type_arguments=None, postfix_operators=[], prefix_operators=[], qualifier=None, selectors=[], type=ReferenceType(arguments=None, dimensions=None, name=ParseException, sub_type=None)), label=None)])), LocalVariableDeclaration(annotations=[], declarators=[VariableDeclarator(dimensions=[], initializer=MethodInvocation(arguments=[BinaryOperation(operandl=MemberReference(member=indexOfLeftQuote, postfix_operators=[], prefix_operators=[], qualifier=, selectors=[]), operandr=Literal(postfix_operators=[], prefix_operators=[], qualifier=None, selectors=[], value=1), operator=+)], member=substring, postfix_operators=[], prefix_operators=[], qualifier=sipApplicationRouterInfoStringified, selectors=[MethodInvocation(arguments=[Literal(postfix_operators=[], prefix_operators=[], qualifier=None, selectors=[], value="\"")], member=indexOf, postfix_operators=None, prefix_operators=None, qualifier=None, selectors=None, type_arguments=None)], type_arguments=None), name=indexOfRightQuote)], modifiers=set(), type=BasicType(dimensions=[], name=int)), IfStatement(condition=BinaryOperation(operandl=MemberReference(member=indexOfRightQuote, postfix_operators=[], prefix_operators=[], qualifier=, selectors=[]), operandr=Literal(postfix_operators=[], prefix_operators=['-'], qualifier=None, selectors=[], value=1), operator===), else_statement=None, label=None, then_statement=BlockStatement(label=None, statements=[ThrowStatement(expression=ClassCreator(arguments=[BinaryOperation(operandl=Literal(postfix_operators=[], prefix_operators=[], qualifier=None, selectors=[], value="Right quote expected. Cannot parse the following string from the default application router file "), operandr=MemberReference(member=sipApplicationRouterInfoStringified, postfix_operators=[], prefix_operators=[], qualifier=, selectors=[]), operator=+), Literal(postfix_operators=[], prefix_operators=[], qualifier=None, selectors=[], value=0)], body=None, constructor_type_arguments=None, postfix_operators=[], prefix_operators=[], qualifier=None, selectors=[], type=ReferenceType(arguments=None, dimensions=None, name=ParseException, sub_type=None)), label=None)])), StatementExpression(expression=Assignment(expressionl=MemberReference(member=indexOfRightQuote, postfix_operators=[], prefix_operators=[], qualifier=, selectors=[]), type=+=, value=MemberReference(member=indexOfLeftQuote, postfix_operators=[], prefix_operators=[], qualifier=, selectors=[])), label=None), LocalVariableDeclaration(annotations=[], declarators=[VariableDeclarator(dimensions=[], initializer=MethodInvocation(arguments=[BinaryOperation(operandl=MemberReference(member=indexOfLeftQuote, postfix_operators=[], prefix_operators=[], qualifier=, selectors=[]), operandr=Literal(postfix_operators=[], prefix_operators=[], qualifier=None, selectors=[], value=1), operator=+), BinaryOperation(operandl=MemberReference(member=indexOfRightQuote, postfix_operators=[], prefix_operators=[], qualifier=, selectors=[]), operandr=Literal(postfix_operators=[], prefix_operators=[], qualifier=None, selectors=[], value=1), operator=+)], member=substring, postfix_operators=[], prefix_operators=[], qualifier=sipApplicationRouterInfoStringified, selectors=[], type_arguments=None), name=sipApplicationRouterInfoParameter)], modifiers=set(), type=ReferenceType(arguments=None, dimensions=[], name=String, sub_type=None)), StatementExpression(expression=Assignment(expressionl=MemberReference(member=sipApplicationRouterInfoParameters, postfix_operators=[], prefix_operators=[], qualifier=, selectors=[ArraySelector(index=MemberReference(member=i, postfix_operators=[], prefix_operators=[], qualifier=, selectors=[]))]), type==, value=MemberReference(member=sipApplicationRouterInfoParameter, postfix_operators=[], prefix_operators=[], qualifier=, selectors=[])), label=None), StatementExpression(expression=Assignment(expressionl=MemberReference(member=sipApplicationRouterInfoStringified, postfix_operators=[], prefix_operators=[], qualifier=, selectors=[]), type==, value=MethodInvocation(arguments=[BinaryOperation(operandl=MemberReference(member=indexOfRightQuote, postfix_operators=[], prefix_operators=[], qualifier=, selectors=[]), operandr=Literal(postfix_operators=[], prefix_operators=[], qualifier=None, selectors=[], value=2), operator=+)], member=substring, postfix_operators=[], prefix_operators=[], qualifier=sipApplicationRouterInfoStringified, selectors=[], type_arguments=None)), label=None)]), control=ForControl(condition=BinaryOperation(operandl=MemberReference(member=i, postfix_operators=[], prefix_operators=[], qualifier=, selectors=[]), operandr=MemberReference(member=SIP_APPLICATION_ROUTER_INFO_PARAM_NB, postfix_operators=[], prefix_operators=[], qualifier=, selectors=[]), operator=<), init=VariableDeclaration(annotations=[], declarators=[VariableDeclarator(dimensions=None, initializer=Literal(postfix_operators=[], prefix_operators=[], qualifier=None, selectors=[], value=0), name=i)], modifiers=set(), type=BasicType(dimensions=[], name=int)), update=[MemberReference(member=i, postfix_operators=['++'], prefix_operators=[], qualifier=, selectors=[])]), label=None)
local_variable[type[String], optionalParameters]
local_variable[type[int], indexOfLeftQuote]
if[binary_operation[member[.indexOfLeftQuote], !=, literal[1]]] begin[{]
local_variable[type[int], indexOfRightQuote]
if[binary_operation[member[.indexOfRightQuote], !=, literal[1]]] begin[{]
assign[member[.indexOfRightQuote], member[.indexOfLeftQuote]]
assign[member[.optionalParameters], call[sipApplicationRouterInfoStringified.substring, parameter[binary_operation[member[.indexOfLeftQuote], +, literal[1]], binary_operation[member[.indexOfRightQuote], +, literal[1]]]]]
else begin[{]
ThrowStatement(expression=ClassCreator(arguments=[Literal(postfix_operators=[], prefix_operators=[], qualifier=None, selectors=[], value="Expected a right quote in the optiona parameters"), MemberReference(member=indexOfLeftQuote, postfix_operators=[], prefix_operators=[], qualifier=, selectors=[])], body=None, constructor_type_arguments=None, postfix_operators=[], prefix_operators=[], qualifier=None, selectors=[], type=ReferenceType(arguments=None, dimensions=None, name=ParseException, sub_type=None)), label=None)
end[}]
else begin[{]
None
end[}]
local_variable[type[int], order]
TryStatement(block=[StatementExpression(expression=Assignment(expressionl=MemberReference(member=order, postfix_operators=[], prefix_operators=[], qualifier=, selectors=[]), type==, value=MethodInvocation(arguments=[MemberReference(member=sipApplicationRouterInfoParameters, postfix_operators=[], prefix_operators=[], qualifier=, selectors=[ArraySelector(index=Literal(postfix_operators=[], prefix_operators=[], qualifier=None, selectors=[], value=5))])], member=parseInt, postfix_operators=[], prefix_operators=[], qualifier=Integer, selectors=[], type_arguments=None)), label=None)], catches=[CatchClause(block=[ThrowStatement(expression=ClassCreator(arguments=[BinaryOperation(operandl=Literal(postfix_operators=[], prefix_operators=[], qualifier=None, selectors=[], value="Impossible to parse the state info into an integer for this line "), operandr=MemberReference(member=sipApplicationRouterInfoStringified, postfix_operators=[], prefix_operators=[], qualifier=, selectors=[]), operator=+), Literal(postfix_operators=[], prefix_operators=[], qualifier=None, selectors=[], value=0)], body=None, constructor_type_arguments=None, postfix_operators=[], prefix_operators=[], qualifier=None, selectors=[], type=ReferenceType(arguments=None, dimensions=None, name=ParseException, sub_type=None)), label=None)], label=None, parameter=CatchClauseParameter(annotations=None, modifiers=None, name=nfe, types=['NumberFormatException']))], finally_block=None, label=None, resources=None)
return[ClassCreator(arguments=[MemberReference(member=sipApplicationRouterInfoParameters, postfix_operators=[], prefix_operators=[], qualifier=, selectors=[ArraySelector(index=Literal(postfix_operators=[], prefix_operators=[], qualifier=None, selectors=[], value=0))]), MemberReference(member=sipApplicationRouterInfoParameters, postfix_operators=[], prefix_operators=[], qualifier=, selectors=[ArraySelector(index=Literal(postfix_operators=[], prefix_operators=[], qualifier=None, selectors=[], value=1))]), ClassCreator(arguments=[MemberReference(member=sipApplicationRouterInfoParameters, postfix_operators=[], prefix_operators=[], qualifier=, selectors=[ArraySelector(index=Literal(postfix_operators=[], prefix_operators=[], qualifier=None, selectors=[], value=2))]), MethodInvocation(arguments=[ClassReference(postfix_operators=[], prefix_operators=[], qualifier=, selectors=[], type=ReferenceType(arguments=None, dimensions=None, name=SipApplicationRoutingRegionType, sub_type=None)), MemberReference(member=sipApplicationRouterInfoParameters, postfix_operators=[], prefix_operators=[], qualifier=, selectors=[ArraySelector(index=Literal(postfix_operators=[], prefix_operators=[], qualifier=None, selectors=[], value=2))])], member=valueOf, postfix_operators=[], prefix_operators=[], qualifier=SipApplicationRoutingRegionType, selectors=[], type_arguments=None)], body=None, constructor_type_arguments=None, postfix_operators=[], prefix_operators=[], qualifier=None, selectors=[], type=ReferenceType(arguments=None, dimensions=None, name=SipApplicationRoutingRegion, sub_type=None)), ArrayCreator(dimensions=[None], initializer=ArrayInitializer(initializers=[MemberReference(member=sipApplicationRouterInfoParameters, postfix_operators=[], prefix_operators=[], qualifier=, selectors=[ArraySelector(index=Literal(postfix_operators=[], prefix_operators=[], qualifier=None, selectors=[], value=3))])]), postfix_operators=[], prefix_operators=[], qualifier=None, selectors=[], type=ReferenceType(arguments=None, dimensions=None, name=String, sub_type=None)), MethodInvocation(arguments=[ClassReference(postfix_operators=[], prefix_operators=[], qualifier=, selectors=[], type=ReferenceType(arguments=None, dimensions=None, name=SipRouteModifier, sub_type=None)), MemberReference(member=sipApplicationRouterInfoParameters, postfix_operators=[], prefix_operators=[], qualifier=, selectors=[ArraySelector(index=Literal(postfix_operators=[], prefix_operators=[], qualifier=None, selectors=[], value=4))])], member=valueOf, postfix_operators=[], prefix_operators=[], qualifier=SipRouteModifier, selectors=[], type_arguments=None), MemberReference(member=order, postfix_operators=[], prefix_operators=[], qualifier=, selectors=[]), MemberReference(member=optionalParameters, postfix_operators=[], prefix_operators=[], qualifier=, selectors=[])], body=None, constructor_type_arguments=None, postfix_operators=[], prefix_operators=[], qualifier=None, selectors=[], type=ReferenceType(arguments=None, dimensions=None, name=DefaultSipApplicationRouterInfo, sub_type=None))]
end[}]
END[}]
|
Keyword[private] identifier[DefaultSipApplicationRouterInfo] identifier[parseSipApplicationRouterInfo] operator[SEP] identifier[String] identifier[sipApplicationRouterInfoStringified] operator[SEP] Keyword[throws] identifier[ParseException] {
identifier[String] operator[SEP] operator[SEP] identifier[sipApplicationRouterInfoParameters] operator[=] Keyword[new] identifier[String] operator[SEP] identifier[SIP_APPLICATION_ROUTER_INFO_PARAM_NB] operator[SEP] operator[SEP] Keyword[for] operator[SEP] Keyword[int] identifier[i] operator[=] Other[0] operator[SEP] identifier[i] operator[<] identifier[SIP_APPLICATION_ROUTER_INFO_PARAM_NB] operator[SEP] identifier[i] operator[++] operator[SEP] {
Keyword[int] identifier[indexOfLeftQuote] operator[=] identifier[sipApplicationRouterInfoStringified] operator[SEP] identifier[indexOf] operator[SEP] literal[String] operator[SEP] operator[SEP] Keyword[if] operator[SEP] identifier[indexOfLeftQuote] operator[==] operator[-] Other[1] operator[SEP] {
Keyword[throw] Keyword[new] identifier[ParseException] operator[SEP] literal[String] operator[+] identifier[sipApplicationRouterInfoStringified] , Other[0] operator[SEP] operator[SEP]
}
Keyword[int] identifier[indexOfRightQuote] operator[=] identifier[sipApplicationRouterInfoStringified] operator[SEP] identifier[substring] operator[SEP] identifier[indexOfLeftQuote] operator[+] Other[1] operator[SEP] operator[SEP] identifier[indexOf] operator[SEP] literal[String] operator[SEP] operator[SEP] Keyword[if] operator[SEP] identifier[indexOfRightQuote] operator[==] operator[-] Other[1] operator[SEP] {
Keyword[throw] Keyword[new] identifier[ParseException] operator[SEP] literal[String] operator[+] identifier[sipApplicationRouterInfoStringified] , Other[0] operator[SEP] operator[SEP]
}
identifier[indexOfRightQuote] operator[+=] identifier[indexOfLeftQuote] operator[SEP] identifier[String] identifier[sipApplicationRouterInfoParameter] operator[=] identifier[sipApplicationRouterInfoStringified] operator[SEP] identifier[substring] operator[SEP] identifier[indexOfLeftQuote] operator[+] Other[1] , identifier[indexOfRightQuote] operator[+] Other[1] operator[SEP] operator[SEP] identifier[sipApplicationRouterInfoParameters] operator[SEP] identifier[i] operator[SEP] operator[=] identifier[sipApplicationRouterInfoParameter] operator[SEP] identifier[sipApplicationRouterInfoStringified] operator[=] identifier[sipApplicationRouterInfoStringified] operator[SEP] identifier[substring] operator[SEP] identifier[indexOfRightQuote] operator[+] Other[2] operator[SEP] operator[SEP]
}
identifier[String] identifier[optionalParameters] operator[=] Other[null] operator[SEP] Keyword[int] identifier[indexOfLeftQuote] operator[=] identifier[sipApplicationRouterInfoStringified] operator[SEP] identifier[indexOf] operator[SEP] literal[String] operator[SEP] operator[SEP] Keyword[if] operator[SEP] identifier[indexOfLeftQuote] operator[!=] operator[-] Other[1] operator[SEP] {
Keyword[int] identifier[indexOfRightQuote] operator[=] identifier[sipApplicationRouterInfoStringified] operator[SEP] identifier[substring] operator[SEP] identifier[indexOfLeftQuote] operator[+] Other[1] operator[SEP] operator[SEP] identifier[indexOf] operator[SEP] literal[String] operator[SEP] operator[SEP] Keyword[if] operator[SEP] identifier[indexOfRightQuote] operator[!=] operator[-] Other[1] operator[SEP] {
identifier[indexOfRightQuote] operator[+=] identifier[indexOfLeftQuote] operator[SEP] identifier[optionalParameters] operator[=] identifier[sipApplicationRouterInfoStringified] operator[SEP] identifier[substring] operator[SEP] identifier[indexOfLeftQuote] operator[+] Other[1] , identifier[indexOfRightQuote] operator[+] Other[1] operator[SEP] operator[SEP]
}
Keyword[else] {
Keyword[throw] Keyword[new] identifier[ParseException] operator[SEP] literal[String] , identifier[indexOfLeftQuote] operator[SEP] operator[SEP]
}
}
Keyword[int] identifier[order] operator[=] operator[-] Other[1] operator[SEP] Keyword[try] {
identifier[order] operator[=] identifier[Integer] operator[SEP] identifier[parseInt] operator[SEP] identifier[sipApplicationRouterInfoParameters] operator[SEP] Other[5] operator[SEP] operator[SEP] operator[SEP]
}
Keyword[catch] operator[SEP] identifier[NumberFormatException] identifier[nfe] operator[SEP] {
Keyword[throw] Keyword[new] identifier[ParseException] operator[SEP] literal[String] operator[+] identifier[sipApplicationRouterInfoStringified] , Other[0] operator[SEP] operator[SEP]
}
Keyword[return] Keyword[new] identifier[DefaultSipApplicationRouterInfo] operator[SEP] identifier[sipApplicationRouterInfoParameters] operator[SEP] Other[0] operator[SEP] , identifier[sipApplicationRouterInfoParameters] operator[SEP] Other[1] operator[SEP] , Keyword[new] identifier[SipApplicationRoutingRegion] operator[SEP] identifier[sipApplicationRouterInfoParameters] operator[SEP] Other[2] operator[SEP] , identifier[SipApplicationRoutingRegionType] operator[SEP] identifier[valueOf] operator[SEP] identifier[SipApplicationRoutingRegionType] operator[SEP] Keyword[class] , identifier[sipApplicationRouterInfoParameters] operator[SEP] Other[2] operator[SEP] operator[SEP] operator[SEP] , Keyword[new] identifier[String] operator[SEP] operator[SEP] {
identifier[sipApplicationRouterInfoParameters] operator[SEP] Other[3] operator[SEP]
} , identifier[SipRouteModifier] operator[SEP] identifier[valueOf] operator[SEP] identifier[SipRouteModifier] operator[SEP] Keyword[class] , identifier[sipApplicationRouterInfoParameters] operator[SEP] Other[4] operator[SEP] operator[SEP] , identifier[order] , identifier[optionalParameters] operator[SEP] operator[SEP]
}
|
public OvhTemplateModem templateModem_name_GET(String name) throws IOException {
String qPath = "/xdsl/templateModem/{name}";
StringBuilder sb = path(qPath, name);
String resp = exec(qPath, "GET", sb.toString(), null);
return convertTo(resp, OvhTemplateModem.class);
}
|
class class_name[name] begin[{]
method[templateModem_name_GET, return_type[type[OvhTemplateModem]], modifier[public], parameter[name]] begin[{]
local_variable[type[String], qPath]
local_variable[type[StringBuilder], sb]
local_variable[type[String], resp]
return[call[.convertTo, parameter[member[.resp], ClassReference(postfix_operators=[], prefix_operators=[], qualifier=, selectors=[], type=ReferenceType(arguments=None, dimensions=None, name=OvhTemplateModem, sub_type=None))]]]
end[}]
END[}]
|
Keyword[public] identifier[OvhTemplateModem] identifier[templateModem_name_GET] operator[SEP] identifier[String] identifier[name] operator[SEP] Keyword[throws] identifier[IOException] {
identifier[String] identifier[qPath] operator[=] literal[String] operator[SEP] identifier[StringBuilder] identifier[sb] operator[=] identifier[path] operator[SEP] identifier[qPath] , identifier[name] operator[SEP] operator[SEP] identifier[String] identifier[resp] operator[=] identifier[exec] operator[SEP] identifier[qPath] , literal[String] , identifier[sb] operator[SEP] identifier[toString] operator[SEP] operator[SEP] , Other[null] operator[SEP] operator[SEP] Keyword[return] identifier[convertTo] operator[SEP] identifier[resp] , identifier[OvhTemplateModem] operator[SEP] Keyword[class] operator[SEP] operator[SEP]
}
|
private boolean defineEntity(String name, char value)
{
StringBuffer sb = new StringBuffer("&");
sb.append(name);
sb.append(';');
String entityString = sb.toString();
boolean extra = defineChar2StringMapping(entityString, value);
return extra;
}
|
class class_name[name] begin[{]
method[defineEntity, return_type[type[boolean]], modifier[private], parameter[name, value]] begin[{]
local_variable[type[StringBuffer], sb]
call[sb.append, parameter[member[.name]]]
call[sb.append, parameter[literal[';']]]
local_variable[type[String], entityString]
local_variable[type[boolean], extra]
return[member[.extra]]
end[}]
END[}]
|
Keyword[private] Keyword[boolean] identifier[defineEntity] operator[SEP] identifier[String] identifier[name] , Keyword[char] identifier[value] operator[SEP] {
identifier[StringBuffer] identifier[sb] operator[=] Keyword[new] identifier[StringBuffer] operator[SEP] literal[String] operator[SEP] operator[SEP] identifier[sb] operator[SEP] identifier[append] operator[SEP] identifier[name] operator[SEP] operator[SEP] identifier[sb] operator[SEP] identifier[append] operator[SEP] literal[String] operator[SEP] operator[SEP] identifier[String] identifier[entityString] operator[=] identifier[sb] operator[SEP] identifier[toString] operator[SEP] operator[SEP] operator[SEP] Keyword[boolean] identifier[extra] operator[=] identifier[defineChar2StringMapping] operator[SEP] identifier[entityString] , identifier[value] operator[SEP] operator[SEP] Keyword[return] identifier[extra] operator[SEP]
}
|
@Override
public boolean isTabu(Move<? super SolutionType> move, SolutionType currentSolution) {
// apply move
move.apply(currentSolution);
// check: contained in tabu memory?
boolean tabu = memory.contains(currentSolution);
// undo move
move.undo(currentSolution);
// return result
return tabu;
}
|
class class_name[name] begin[{]
method[isTabu, return_type[type[boolean]], modifier[public], parameter[move, currentSolution]] begin[{]
call[move.apply, parameter[member[.currentSolution]]]
local_variable[type[boolean], tabu]
call[move.undo, parameter[member[.currentSolution]]]
return[member[.tabu]]
end[}]
END[}]
|
annotation[@] identifier[Override] Keyword[public] Keyword[boolean] identifier[isTabu] operator[SEP] identifier[Move] operator[<] operator[?] Keyword[super] identifier[SolutionType] operator[>] identifier[move] , identifier[SolutionType] identifier[currentSolution] operator[SEP] {
identifier[move] operator[SEP] identifier[apply] operator[SEP] identifier[currentSolution] operator[SEP] operator[SEP] Keyword[boolean] identifier[tabu] operator[=] identifier[memory] operator[SEP] identifier[contains] operator[SEP] identifier[currentSolution] operator[SEP] operator[SEP] identifier[move] operator[SEP] identifier[undo] operator[SEP] identifier[currentSolution] operator[SEP] operator[SEP] Keyword[return] identifier[tabu] operator[SEP]
}
|
@SuppressWarnings("unused")
public void setPrefix(String prefix, String namespace) throws IOException {
if (startTagIncomplete)
closeStartTag();
// assert prefix != null;
// assert namespace != null;
if (prefix == null) {
prefix = "";
}
if (!namesInterned) {
prefix = prefix.intern(); // will throw NPE if prefix==null
} else if (checkNamesInterned) {
checkInterning(prefix);
} else if (prefix == null) {
throw new IllegalArgumentException("prefix must be not null" + getLocation());
}
// check that prefix is not duplicated ...
for (int i = elNamespaceCount[depth]; i < namespaceEnd; i++) {
if (prefix == namespacePrefix[i]) {
throw new IllegalStateException("duplicated prefix " + printable(prefix) + getLocation());
}
}
if (!namesInterned) {
namespace = namespace.intern();
} else if (checkNamesInterned) {
checkInterning(namespace);
} else if (namespace == null) {
throw new IllegalArgumentException("namespace must be not null" + getLocation());
}
if (namespaceEnd >= namespacePrefix.length) {
ensureNamespacesCapacity();
}
namespacePrefix[namespaceEnd] = prefix;
namespaceUri[namespaceEnd] = namespace;
++namespaceEnd;
setPrefixCalled = true;
}
|
class class_name[name] begin[{]
method[setPrefix, return_type[void], modifier[public], parameter[prefix, namespace]] begin[{]
if[member[.startTagIncomplete]] begin[{]
call[.closeStartTag, parameter[]]
else begin[{]
None
end[}]
if[binary_operation[member[.prefix], ==, literal[null]]] begin[{]
assign[member[.prefix], literal[""]]
else begin[{]
None
end[}]
if[member[.namesInterned]] begin[{]
assign[member[.prefix], call[prefix.intern, parameter[]]]
else begin[{]
if[member[.checkNamesInterned]] begin[{]
call[.checkInterning, parameter[member[.prefix]]]
else begin[{]
if[binary_operation[member[.prefix], ==, literal[null]]] begin[{]
ThrowStatement(expression=ClassCreator(arguments=[BinaryOperation(operandl=Literal(postfix_operators=[], prefix_operators=[], qualifier=None, selectors=[], value="prefix must be not null"), operandr=MethodInvocation(arguments=[], member=getLocation, postfix_operators=[], prefix_operators=[], qualifier=, selectors=[], type_arguments=None), operator=+)], body=None, constructor_type_arguments=None, postfix_operators=[], prefix_operators=[], qualifier=None, selectors=[], type=ReferenceType(arguments=None, dimensions=None, name=IllegalArgumentException, sub_type=None)), label=None)
else begin[{]
None
end[}]
end[}]
end[}]
ForStatement(body=BlockStatement(label=None, statements=[IfStatement(condition=BinaryOperation(operandl=MemberReference(member=prefix, postfix_operators=[], prefix_operators=[], qualifier=, selectors=[]), operandr=MemberReference(member=namespacePrefix, postfix_operators=[], prefix_operators=[], qualifier=, selectors=[ArraySelector(index=MemberReference(member=i, postfix_operators=[], prefix_operators=[], qualifier=, selectors=[]))]), operator===), else_statement=None, label=None, then_statement=BlockStatement(label=None, statements=[ThrowStatement(expression=ClassCreator(arguments=[BinaryOperation(operandl=BinaryOperation(operandl=Literal(postfix_operators=[], prefix_operators=[], qualifier=None, selectors=[], value="duplicated prefix "), operandr=MethodInvocation(arguments=[MemberReference(member=prefix, postfix_operators=[], prefix_operators=[], qualifier=, selectors=[])], member=printable, postfix_operators=[], prefix_operators=[], qualifier=, selectors=[], type_arguments=None), operator=+), operandr=MethodInvocation(arguments=[], member=getLocation, postfix_operators=[], prefix_operators=[], qualifier=, selectors=[], type_arguments=None), operator=+)], body=None, constructor_type_arguments=None, postfix_operators=[], prefix_operators=[], qualifier=None, selectors=[], type=ReferenceType(arguments=None, dimensions=None, name=IllegalStateException, sub_type=None)), label=None)]))]), control=ForControl(condition=BinaryOperation(operandl=MemberReference(member=i, postfix_operators=[], prefix_operators=[], qualifier=, selectors=[]), operandr=MemberReference(member=namespaceEnd, postfix_operators=[], prefix_operators=[], qualifier=, selectors=[]), operator=<), init=VariableDeclaration(annotations=[], declarators=[VariableDeclarator(dimensions=None, initializer=MemberReference(member=elNamespaceCount, postfix_operators=[], prefix_operators=[], qualifier=, selectors=[ArraySelector(index=MemberReference(member=depth, postfix_operators=[], prefix_operators=[], qualifier=, selectors=[]))]), name=i)], modifiers=set(), type=BasicType(dimensions=[], name=int)), update=[MemberReference(member=i, postfix_operators=['++'], prefix_operators=[], qualifier=, selectors=[])]), label=None)
if[member[.namesInterned]] begin[{]
assign[member[.namespace], call[namespace.intern, parameter[]]]
else begin[{]
if[member[.checkNamesInterned]] begin[{]
call[.checkInterning, parameter[member[.namespace]]]
else begin[{]
if[binary_operation[member[.namespace], ==, literal[null]]] begin[{]
ThrowStatement(expression=ClassCreator(arguments=[BinaryOperation(operandl=Literal(postfix_operators=[], prefix_operators=[], qualifier=None, selectors=[], value="namespace must be not null"), operandr=MethodInvocation(arguments=[], member=getLocation, postfix_operators=[], prefix_operators=[], qualifier=, selectors=[], type_arguments=None), operator=+)], body=None, constructor_type_arguments=None, postfix_operators=[], prefix_operators=[], qualifier=None, selectors=[], type=ReferenceType(arguments=None, dimensions=None, name=IllegalArgumentException, sub_type=None)), label=None)
else begin[{]
None
end[}]
end[}]
end[}]
if[binary_operation[member[.namespaceEnd], >=, member[namespacePrefix.length]]] begin[{]
call[.ensureNamespacesCapacity, parameter[]]
else begin[{]
None
end[}]
assign[member[.namespacePrefix], member[.prefix]]
assign[member[.namespaceUri], member[.namespace]]
member[.namespaceEnd]
assign[member[.setPrefixCalled], literal[true]]
end[}]
END[}]
|
annotation[@] identifier[SuppressWarnings] operator[SEP] literal[String] operator[SEP] Keyword[public] Keyword[void] identifier[setPrefix] operator[SEP] identifier[String] identifier[prefix] , identifier[String] identifier[namespace] operator[SEP] Keyword[throws] identifier[IOException] {
Keyword[if] operator[SEP] identifier[startTagIncomplete] operator[SEP] identifier[closeStartTag] operator[SEP] operator[SEP] operator[SEP] Keyword[if] operator[SEP] identifier[prefix] operator[==] Other[null] operator[SEP] {
identifier[prefix] operator[=] literal[String] operator[SEP]
}
Keyword[if] operator[SEP] operator[!] identifier[namesInterned] operator[SEP] {
identifier[prefix] operator[=] identifier[prefix] operator[SEP] identifier[intern] operator[SEP] operator[SEP] operator[SEP]
}
Keyword[else] Keyword[if] operator[SEP] identifier[checkNamesInterned] operator[SEP] {
identifier[checkInterning] operator[SEP] identifier[prefix] operator[SEP] operator[SEP]
}
Keyword[else] Keyword[if] operator[SEP] identifier[prefix] operator[==] Other[null] operator[SEP] {
Keyword[throw] Keyword[new] identifier[IllegalArgumentException] operator[SEP] literal[String] operator[+] identifier[getLocation] operator[SEP] operator[SEP] operator[SEP] operator[SEP]
}
Keyword[for] operator[SEP] Keyword[int] identifier[i] operator[=] identifier[elNamespaceCount] operator[SEP] identifier[depth] operator[SEP] operator[SEP] identifier[i] operator[<] identifier[namespaceEnd] operator[SEP] identifier[i] operator[++] operator[SEP] {
Keyword[if] operator[SEP] identifier[prefix] operator[==] identifier[namespacePrefix] operator[SEP] identifier[i] operator[SEP] operator[SEP] {
Keyword[throw] Keyword[new] identifier[IllegalStateException] operator[SEP] literal[String] operator[+] identifier[printable] operator[SEP] identifier[prefix] operator[SEP] operator[+] identifier[getLocation] operator[SEP] operator[SEP] operator[SEP] operator[SEP]
}
}
Keyword[if] operator[SEP] operator[!] identifier[namesInterned] operator[SEP] {
identifier[namespace] operator[=] identifier[namespace] operator[SEP] identifier[intern] operator[SEP] operator[SEP] operator[SEP]
}
Keyword[else] Keyword[if] operator[SEP] identifier[checkNamesInterned] operator[SEP] {
identifier[checkInterning] operator[SEP] identifier[namespace] operator[SEP] operator[SEP]
}
Keyword[else] Keyword[if] operator[SEP] identifier[namespace] operator[==] Other[null] operator[SEP] {
Keyword[throw] Keyword[new] identifier[IllegalArgumentException] operator[SEP] literal[String] operator[+] identifier[getLocation] operator[SEP] operator[SEP] operator[SEP] operator[SEP]
}
Keyword[if] operator[SEP] identifier[namespaceEnd] operator[>=] identifier[namespacePrefix] operator[SEP] identifier[length] operator[SEP] {
identifier[ensureNamespacesCapacity] operator[SEP] operator[SEP] operator[SEP]
}
identifier[namespacePrefix] operator[SEP] identifier[namespaceEnd] operator[SEP] operator[=] identifier[prefix] operator[SEP] identifier[namespaceUri] operator[SEP] identifier[namespaceEnd] operator[SEP] operator[=] identifier[namespace] operator[SEP] operator[++] identifier[namespaceEnd] operator[SEP] identifier[setPrefixCalled] operator[=] literal[boolean] operator[SEP]
}
|
public double get(double x, double epsilon)
{
Point nearest = getNearest(x, epsilon);
return nearest.getY();
}
|
class class_name[name] begin[{]
method[get, return_type[type[double]], modifier[public], parameter[x, epsilon]] begin[{]
local_variable[type[Point], nearest]
return[call[nearest.getY, parameter[]]]
end[}]
END[}]
|
Keyword[public] Keyword[double] identifier[get] operator[SEP] Keyword[double] identifier[x] , Keyword[double] identifier[epsilon] operator[SEP] {
identifier[Point] identifier[nearest] operator[=] identifier[getNearest] operator[SEP] identifier[x] , identifier[epsilon] operator[SEP] operator[SEP] Keyword[return] identifier[nearest] operator[SEP] identifier[getY] operator[SEP] operator[SEP] operator[SEP]
}
|
public static <T> T withProcessApplicationContext(Callable<T> callable, ProcessApplicationReference reference) throws Exception {
try {
setCurrentProcessApplication(reference);
return callable.call();
}
finally {
clear();
}
}
|
class class_name[name] begin[{]
method[withProcessApplicationContext, return_type[type[T]], modifier[public static], parameter[callable, reference]] begin[{]
TryStatement(block=[StatementExpression(expression=MethodInvocation(arguments=[MemberReference(member=reference, postfix_operators=[], prefix_operators=[], qualifier=, selectors=[])], member=setCurrentProcessApplication, postfix_operators=[], prefix_operators=[], qualifier=, selectors=[], type_arguments=None), label=None), ReturnStatement(expression=MethodInvocation(arguments=[], member=call, postfix_operators=[], prefix_operators=[], qualifier=callable, selectors=[], type_arguments=None), label=None)], catches=None, finally_block=[StatementExpression(expression=MethodInvocation(arguments=[], member=clear, postfix_operators=[], prefix_operators=[], qualifier=, selectors=[], type_arguments=None), label=None)], label=None, resources=None)
end[}]
END[}]
|
Keyword[public] Keyword[static] operator[<] identifier[T] operator[>] identifier[T] identifier[withProcessApplicationContext] operator[SEP] identifier[Callable] operator[<] identifier[T] operator[>] identifier[callable] , identifier[ProcessApplicationReference] identifier[reference] operator[SEP] Keyword[throws] identifier[Exception] {
Keyword[try] {
identifier[setCurrentProcessApplication] operator[SEP] identifier[reference] operator[SEP] operator[SEP] Keyword[return] identifier[callable] operator[SEP] identifier[call] operator[SEP] operator[SEP] operator[SEP]
}
Keyword[finally] {
identifier[clear] operator[SEP] operator[SEP] operator[SEP]
}
}
|
public void unlink(Object source, CollectionDescriptor cds, List referencesToUnlink)
{
for(int i = 0; i < referencesToUnlink.size(); i++)
{
unlink(source, cds, referencesToUnlink.get(i));
}
}
|
class class_name[name] begin[{]
method[unlink, return_type[void], modifier[public], parameter[source, cds, referencesToUnlink]] begin[{]
ForStatement(body=BlockStatement(label=None, statements=[StatementExpression(expression=MethodInvocation(arguments=[MemberReference(member=source, postfix_operators=[], prefix_operators=[], qualifier=, selectors=[]), MemberReference(member=cds, postfix_operators=[], prefix_operators=[], qualifier=, selectors=[]), MethodInvocation(arguments=[MemberReference(member=i, postfix_operators=[], prefix_operators=[], qualifier=, selectors=[])], member=get, postfix_operators=[], prefix_operators=[], qualifier=referencesToUnlink, selectors=[], type_arguments=None)], member=unlink, postfix_operators=[], prefix_operators=[], qualifier=, selectors=[], type_arguments=None), label=None)]), control=ForControl(condition=BinaryOperation(operandl=MemberReference(member=i, postfix_operators=[], prefix_operators=[], qualifier=, selectors=[]), operandr=MethodInvocation(arguments=[], member=size, postfix_operators=[], prefix_operators=[], qualifier=referencesToUnlink, selectors=[], type_arguments=None), operator=<), init=VariableDeclaration(annotations=[], declarators=[VariableDeclarator(dimensions=None, initializer=Literal(postfix_operators=[], prefix_operators=[], qualifier=None, selectors=[], value=0), name=i)], modifiers=set(), type=BasicType(dimensions=[], name=int)), update=[MemberReference(member=i, postfix_operators=['++'], prefix_operators=[], qualifier=, selectors=[])]), label=None)
end[}]
END[}]
|
Keyword[public] Keyword[void] identifier[unlink] operator[SEP] identifier[Object] identifier[source] , identifier[CollectionDescriptor] identifier[cds] , identifier[List] identifier[referencesToUnlink] operator[SEP] {
Keyword[for] operator[SEP] Keyword[int] identifier[i] operator[=] Other[0] operator[SEP] identifier[i] operator[<] identifier[referencesToUnlink] operator[SEP] identifier[size] operator[SEP] operator[SEP] operator[SEP] identifier[i] operator[++] operator[SEP] {
identifier[unlink] operator[SEP] identifier[source] , identifier[cds] , identifier[referencesToUnlink] operator[SEP] identifier[get] operator[SEP] identifier[i] operator[SEP] operator[SEP] operator[SEP]
}
}
|
public final static byte[] readByteArray(final ObjectInputStream s) throws IOException {
final byte[] a = new byte[readVByte(s)];
s.readFully(a);
return a;
}
|
class class_name[name] begin[{]
method[readByteArray, return_type[type[byte]], modifier[final public static], parameter[s]] begin[{]
local_variable[type[byte], a]
call[s.readFully, parameter[member[.a]]]
return[member[.a]]
end[}]
END[}]
|
Keyword[public] Keyword[final] Keyword[static] Keyword[byte] operator[SEP] operator[SEP] identifier[readByteArray] operator[SEP] Keyword[final] identifier[ObjectInputStream] identifier[s] operator[SEP] Keyword[throws] identifier[IOException] {
Keyword[final] Keyword[byte] operator[SEP] operator[SEP] identifier[a] operator[=] Keyword[new] Keyword[byte] operator[SEP] identifier[readVByte] operator[SEP] identifier[s] operator[SEP] operator[SEP] operator[SEP] identifier[s] operator[SEP] identifier[readFully] operator[SEP] identifier[a] operator[SEP] operator[SEP] Keyword[return] identifier[a] operator[SEP]
}
|
@Override
public void loadFromProperties(Properties props) {
String strValue = props.getProperty(container.getSimpleName() + "." + name);
if (strValue == null)
return;
try {
long value = Long.parseLong(strValue);
set(value);
} catch (NumberFormatException nfe) {
}
}
|
class class_name[name] begin[{]
method[loadFromProperties, return_type[void], modifier[public], parameter[props]] begin[{]
local_variable[type[String], strValue]
if[binary_operation[member[.strValue], ==, literal[null]]] begin[{]
return[None]
else begin[{]
None
end[}]
TryStatement(block=[LocalVariableDeclaration(annotations=[], declarators=[VariableDeclarator(dimensions=[], initializer=MethodInvocation(arguments=[MemberReference(member=strValue, postfix_operators=[], prefix_operators=[], qualifier=, selectors=[])], member=parseLong, postfix_operators=[], prefix_operators=[], qualifier=Long, selectors=[], type_arguments=None), name=value)], modifiers=set(), type=BasicType(dimensions=[], name=long)), StatementExpression(expression=MethodInvocation(arguments=[MemberReference(member=value, postfix_operators=[], prefix_operators=[], qualifier=, selectors=[])], member=set, postfix_operators=[], prefix_operators=[], qualifier=, selectors=[], type_arguments=None), label=None)], catches=[CatchClause(block=[], label=None, parameter=CatchClauseParameter(annotations=None, modifiers=None, name=nfe, types=['NumberFormatException']))], finally_block=None, label=None, resources=None)
end[}]
END[}]
|
annotation[@] identifier[Override] Keyword[public] Keyword[void] identifier[loadFromProperties] operator[SEP] identifier[Properties] identifier[props] operator[SEP] {
identifier[String] identifier[strValue] operator[=] identifier[props] operator[SEP] identifier[getProperty] operator[SEP] identifier[container] operator[SEP] identifier[getSimpleName] operator[SEP] operator[SEP] operator[+] literal[String] operator[+] identifier[name] operator[SEP] operator[SEP] Keyword[if] operator[SEP] identifier[strValue] operator[==] Other[null] operator[SEP] Keyword[return] operator[SEP] Keyword[try] {
Keyword[long] identifier[value] operator[=] identifier[Long] operator[SEP] identifier[parseLong] operator[SEP] identifier[strValue] operator[SEP] operator[SEP] identifier[set] operator[SEP] identifier[value] operator[SEP] operator[SEP]
}
Keyword[catch] operator[SEP] identifier[NumberFormatException] identifier[nfe] operator[SEP] {
}
}
|
protected void addAccountToString(String sender, List<User> userList2) {
Common.getInstance().getServerCaller().getPlayerCaller().sendMessage(sender, "{{DARK_RED}}Converting accounts. This may take a while.");
Common.getInstance().getStorageHandler().getStorageEngine().saveImporterUsers(userList2);
Common.getInstance().getServerCaller().getPlayerCaller().sendMessage(sender, userList2.size() + " {{DARK_GREEN}}accounts converted! Enjoy!");
}
|
class class_name[name] begin[{]
method[addAccountToString, return_type[void], modifier[protected], parameter[sender, userList2]] begin[{]
call[Common.getInstance, parameter[]]
call[Common.getInstance, parameter[]]
call[Common.getInstance, parameter[]]
end[}]
END[}]
|
Keyword[protected] Keyword[void] identifier[addAccountToString] operator[SEP] identifier[String] identifier[sender] , identifier[List] operator[<] identifier[User] operator[>] identifier[userList2] operator[SEP] {
identifier[Common] operator[SEP] identifier[getInstance] operator[SEP] operator[SEP] operator[SEP] identifier[getServerCaller] operator[SEP] operator[SEP] operator[SEP] identifier[getPlayerCaller] operator[SEP] operator[SEP] operator[SEP] identifier[sendMessage] operator[SEP] identifier[sender] , literal[String] operator[SEP] operator[SEP] identifier[Common] operator[SEP] identifier[getInstance] operator[SEP] operator[SEP] operator[SEP] identifier[getStorageHandler] operator[SEP] operator[SEP] operator[SEP] identifier[getStorageEngine] operator[SEP] operator[SEP] operator[SEP] identifier[saveImporterUsers] operator[SEP] identifier[userList2] operator[SEP] operator[SEP] identifier[Common] operator[SEP] identifier[getInstance] operator[SEP] operator[SEP] operator[SEP] identifier[getServerCaller] operator[SEP] operator[SEP] operator[SEP] identifier[getPlayerCaller] operator[SEP] operator[SEP] operator[SEP] identifier[sendMessage] operator[SEP] identifier[sender] , identifier[userList2] operator[SEP] identifier[size] operator[SEP] operator[SEP] operator[+] literal[String] operator[SEP] operator[SEP]
}
|
public static FullTypeSignature getTypeSignature(String typeSignatureString,
boolean useInternalFormFullyQualifiedName) {
String key;
if (!useInternalFormFullyQualifiedName) {
key = typeSignatureString.replace('.', '/')
.replace('$', '.');
} else {
key = typeSignatureString;
}
// we always use the internal form as a key for cache
FullTypeSignature typeSignature = typeSignatureCache
.get(key);
if (typeSignature == null) {
ClassFileTypeSignatureParser typeSignatureParser = new ClassFileTypeSignatureParser(
typeSignatureString);
typeSignatureParser.setUseInternalFormFullyQualifiedName(useInternalFormFullyQualifiedName);
typeSignature = typeSignatureParser.parseTypeSignature();
typeSignatureCache.put(typeSignatureString, typeSignature);
}
return typeSignature;
}
|
class class_name[name] begin[{]
method[getTypeSignature, return_type[type[FullTypeSignature]], modifier[public static], parameter[typeSignatureString, useInternalFormFullyQualifiedName]] begin[{]
local_variable[type[String], key]
if[member[.useInternalFormFullyQualifiedName]] begin[{]
assign[member[.key], call[typeSignatureString.replace, parameter[literal['.'], literal['/']]]]
else begin[{]
assign[member[.key], member[.typeSignatureString]]
end[}]
local_variable[type[FullTypeSignature], typeSignature]
if[binary_operation[member[.typeSignature], ==, literal[null]]] begin[{]
local_variable[type[ClassFileTypeSignatureParser], typeSignatureParser]
call[typeSignatureParser.setUseInternalFormFullyQualifiedName, parameter[member[.useInternalFormFullyQualifiedName]]]
assign[member[.typeSignature], call[typeSignatureParser.parseTypeSignature, parameter[]]]
call[typeSignatureCache.put, parameter[member[.typeSignatureString], member[.typeSignature]]]
else begin[{]
None
end[}]
return[member[.typeSignature]]
end[}]
END[}]
|
Keyword[public] Keyword[static] identifier[FullTypeSignature] identifier[getTypeSignature] operator[SEP] identifier[String] identifier[typeSignatureString] , Keyword[boolean] identifier[useInternalFormFullyQualifiedName] operator[SEP] {
identifier[String] identifier[key] operator[SEP] Keyword[if] operator[SEP] operator[!] identifier[useInternalFormFullyQualifiedName] operator[SEP] {
identifier[key] operator[=] identifier[typeSignatureString] operator[SEP] identifier[replace] operator[SEP] literal[String] , literal[String] operator[SEP] operator[SEP] identifier[replace] operator[SEP] literal[String] , literal[String] operator[SEP] operator[SEP]
}
Keyword[else] {
identifier[key] operator[=] identifier[typeSignatureString] operator[SEP]
}
identifier[FullTypeSignature] identifier[typeSignature] operator[=] identifier[typeSignatureCache] operator[SEP] identifier[get] operator[SEP] identifier[key] operator[SEP] operator[SEP] Keyword[if] operator[SEP] identifier[typeSignature] operator[==] Other[null] operator[SEP] {
identifier[ClassFileTypeSignatureParser] identifier[typeSignatureParser] operator[=] Keyword[new] identifier[ClassFileTypeSignatureParser] operator[SEP] identifier[typeSignatureString] operator[SEP] operator[SEP] identifier[typeSignatureParser] operator[SEP] identifier[setUseInternalFormFullyQualifiedName] operator[SEP] identifier[useInternalFormFullyQualifiedName] operator[SEP] operator[SEP] identifier[typeSignature] operator[=] identifier[typeSignatureParser] operator[SEP] identifier[parseTypeSignature] operator[SEP] operator[SEP] operator[SEP] identifier[typeSignatureCache] operator[SEP] identifier[put] operator[SEP] identifier[typeSignatureString] , identifier[typeSignature] operator[SEP] operator[SEP]
}
Keyword[return] identifier[typeSignature] operator[SEP]
}
|
public static byte[] readFile(File file) throws IOException {
// Open file
RandomAccessFile f = new RandomAccessFile(file, "r");
try {
// Get and check length
long longlength = f.length();
int length = (int) longlength;
if (length != longlength) {
throw new IOException("File size >= 2 GB");
}
// Read file and return data
byte[] data = new byte[length];
f.readFully(data);
return data;
} finally {
// Close file
f.close();
}
}
|
class class_name[name] begin[{]
method[readFile, return_type[type[byte]], modifier[public static], parameter[file]] begin[{]
local_variable[type[RandomAccessFile], f]
TryStatement(block=[LocalVariableDeclaration(annotations=[], declarators=[VariableDeclarator(dimensions=[], initializer=MethodInvocation(arguments=[], member=length, postfix_operators=[], prefix_operators=[], qualifier=f, selectors=[], type_arguments=None), name=longlength)], modifiers=set(), type=BasicType(dimensions=[], name=long)), LocalVariableDeclaration(annotations=[], declarators=[VariableDeclarator(dimensions=[], initializer=Cast(expression=MemberReference(member=longlength, postfix_operators=[], prefix_operators=[], qualifier=, selectors=[]), type=BasicType(dimensions=[], name=int)), name=length)], modifiers=set(), type=BasicType(dimensions=[], name=int)), IfStatement(condition=BinaryOperation(operandl=MemberReference(member=length, postfix_operators=[], prefix_operators=[], qualifier=, selectors=[]), operandr=MemberReference(member=longlength, postfix_operators=[], prefix_operators=[], qualifier=, selectors=[]), operator=!=), else_statement=None, label=None, then_statement=BlockStatement(label=None, statements=[ThrowStatement(expression=ClassCreator(arguments=[Literal(postfix_operators=[], prefix_operators=[], qualifier=None, selectors=[], value="File size >= 2 GB")], body=None, constructor_type_arguments=None, postfix_operators=[], prefix_operators=[], qualifier=None, selectors=[], type=ReferenceType(arguments=None, dimensions=None, name=IOException, sub_type=None)), label=None)])), LocalVariableDeclaration(annotations=[], declarators=[VariableDeclarator(dimensions=[], initializer=ArrayCreator(dimensions=[MemberReference(member=length, postfix_operators=[], prefix_operators=[], qualifier=, selectors=[])], initializer=None, postfix_operators=[], prefix_operators=[], qualifier=None, selectors=[], type=BasicType(dimensions=None, name=byte)), name=data)], modifiers=set(), type=BasicType(dimensions=[None], name=byte)), StatementExpression(expression=MethodInvocation(arguments=[MemberReference(member=data, postfix_operators=[], prefix_operators=[], qualifier=, selectors=[])], member=readFully, postfix_operators=[], prefix_operators=[], qualifier=f, selectors=[], type_arguments=None), label=None), ReturnStatement(expression=MemberReference(member=data, postfix_operators=[], prefix_operators=[], qualifier=, selectors=[]), label=None)], catches=None, finally_block=[StatementExpression(expression=MethodInvocation(arguments=[], member=close, postfix_operators=[], prefix_operators=[], qualifier=f, selectors=[], type_arguments=None), label=None)], label=None, resources=None)
end[}]
END[}]
|
Keyword[public] Keyword[static] Keyword[byte] operator[SEP] operator[SEP] identifier[readFile] operator[SEP] identifier[File] identifier[file] operator[SEP] Keyword[throws] identifier[IOException] {
identifier[RandomAccessFile] identifier[f] operator[=] Keyword[new] identifier[RandomAccessFile] operator[SEP] identifier[file] , literal[String] operator[SEP] operator[SEP] Keyword[try] {
Keyword[long] identifier[longlength] operator[=] identifier[f] operator[SEP] identifier[length] operator[SEP] operator[SEP] operator[SEP] Keyword[int] identifier[length] operator[=] operator[SEP] Keyword[int] operator[SEP] identifier[longlength] operator[SEP] Keyword[if] operator[SEP] identifier[length] operator[!=] identifier[longlength] operator[SEP] {
Keyword[throw] Keyword[new] identifier[IOException] operator[SEP] literal[String] operator[SEP] operator[SEP]
}
Keyword[byte] operator[SEP] operator[SEP] identifier[data] operator[=] Keyword[new] Keyword[byte] operator[SEP] identifier[length] operator[SEP] operator[SEP] identifier[f] operator[SEP] identifier[readFully] operator[SEP] identifier[data] operator[SEP] operator[SEP] Keyword[return] identifier[data] operator[SEP]
}
Keyword[finally] {
identifier[f] operator[SEP] identifier[close] operator[SEP] operator[SEP] operator[SEP]
}
}
|
public void writeColumn(String value) throws IllegalArgumentException, IOException
{
if (value == null)
{
if (! this.nullableColumns[this.currentColumn])
{
throw new IllegalArgumentException(
"Bulk load will fail as a null value cannot be assigned to column '" + this.columns[this.currentColumn] + "'"
);
}
}
else
{
this.dataFileWriter.write(value);
}
if (this.currentColumn < (this.columns.length - 1))
{
this.dataFileWriter.write(FIELD_TERMINATOR);
}
this.currentColumn++;
}
|
class class_name[name] begin[{]
method[writeColumn, return_type[void], modifier[public], parameter[value]] begin[{]
if[binary_operation[member[.value], ==, literal[null]]] begin[{]
if[THIS[member[None.nullableColumns]ArraySelector(index=This(postfix_operators=[], prefix_operators=[], qualifier=None, selectors=[MemberReference(member=currentColumn, postfix_operators=None, prefix_operators=None, qualifier=None, selectors=None)]))]] begin[{]
ThrowStatement(expression=ClassCreator(arguments=[BinaryOperation(operandl=BinaryOperation(operandl=Literal(postfix_operators=[], prefix_operators=[], qualifier=None, selectors=[], value="Bulk load will fail as a null value cannot be assigned to column '"), operandr=This(postfix_operators=[], prefix_operators=[], qualifier=None, selectors=[MemberReference(member=columns, postfix_operators=None, prefix_operators=None, qualifier=None, selectors=None), ArraySelector(index=This(postfix_operators=[], prefix_operators=[], qualifier=None, selectors=[MemberReference(member=currentColumn, postfix_operators=None, prefix_operators=None, qualifier=None, selectors=None)]))]), operator=+), operandr=Literal(postfix_operators=[], prefix_operators=[], qualifier=None, selectors=[], value="'"), operator=+)], body=None, constructor_type_arguments=None, postfix_operators=[], prefix_operators=[], qualifier=None, selectors=[], type=ReferenceType(arguments=None, dimensions=None, name=IllegalArgumentException, sub_type=None)), label=None)
else begin[{]
None
end[}]
else begin[{]
THIS[member[None.dataFileWriter]call[None.write, parameter[member[.value]]]]
end[}]
if[binary_operation[THIS[member[None.currentColumn]], <, binary_operation[THIS[member[None.columns]member[None.length]], -, literal[1]]]] begin[{]
THIS[member[None.dataFileWriter]call[None.write, parameter[member[.FIELD_TERMINATOR]]]]
else begin[{]
None
end[}]
THIS[member[None.currentColumn]]
end[}]
END[}]
|
Keyword[public] Keyword[void] identifier[writeColumn] operator[SEP] identifier[String] identifier[value] operator[SEP] Keyword[throws] identifier[IllegalArgumentException] , identifier[IOException] {
Keyword[if] operator[SEP] identifier[value] operator[==] Other[null] operator[SEP] {
Keyword[if] operator[SEP] operator[!] Keyword[this] operator[SEP] identifier[nullableColumns] operator[SEP] Keyword[this] operator[SEP] identifier[currentColumn] operator[SEP] operator[SEP] {
Keyword[throw] Keyword[new] identifier[IllegalArgumentException] operator[SEP] literal[String] operator[+] Keyword[this] operator[SEP] identifier[columns] operator[SEP] Keyword[this] operator[SEP] identifier[currentColumn] operator[SEP] operator[+] literal[String] operator[SEP] operator[SEP]
}
}
Keyword[else] {
Keyword[this] operator[SEP] identifier[dataFileWriter] operator[SEP] identifier[write] operator[SEP] identifier[value] operator[SEP] operator[SEP]
}
Keyword[if] operator[SEP] Keyword[this] operator[SEP] identifier[currentColumn] operator[<] operator[SEP] Keyword[this] operator[SEP] identifier[columns] operator[SEP] identifier[length] operator[-] Other[1] operator[SEP] operator[SEP] {
Keyword[this] operator[SEP] identifier[dataFileWriter] operator[SEP] identifier[write] operator[SEP] identifier[FIELD_TERMINATOR] operator[SEP] operator[SEP]
}
Keyword[this] operator[SEP] identifier[currentColumn] operator[++] operator[SEP]
}
|
public void addInheritedMemberSummary(AbstractMemberWriter mw, ClassDoc cd,
ProgramElementDoc member, boolean isFirst, Content linksTree) {
if (! isFirst) {
linksTree.addContent(", ");
}
mw.addInheritedSummaryLink(cd, member, linksTree);
}
|
class class_name[name] begin[{]
method[addInheritedMemberSummary, return_type[void], modifier[public], parameter[mw, cd, member, isFirst, linksTree]] begin[{]
if[member[.isFirst]] begin[{]
call[linksTree.addContent, parameter[literal[", "]]]
else begin[{]
None
end[}]
call[mw.addInheritedSummaryLink, parameter[member[.cd], member[.member], member[.linksTree]]]
end[}]
END[}]
|
Keyword[public] Keyword[void] identifier[addInheritedMemberSummary] operator[SEP] identifier[AbstractMemberWriter] identifier[mw] , identifier[ClassDoc] identifier[cd] , identifier[ProgramElementDoc] identifier[member] , Keyword[boolean] identifier[isFirst] , identifier[Content] identifier[linksTree] operator[SEP] {
Keyword[if] operator[SEP] operator[!] identifier[isFirst] operator[SEP] {
identifier[linksTree] operator[SEP] identifier[addContent] operator[SEP] literal[String] operator[SEP] operator[SEP]
}
identifier[mw] operator[SEP] identifier[addInheritedSummaryLink] operator[SEP] identifier[cd] , identifier[member] , identifier[linksTree] operator[SEP] operator[SEP]
}
|
public int getVersion(final Object iPojo) {
checkOpenness();
final ODocument record = getRecordByUserObject(iPojo, false);
if (record != null)
return record.getVersion();
return OObjectSerializerHelper.getObjectVersion(iPojo);
}
|
class class_name[name] begin[{]
method[getVersion, return_type[type[int]], modifier[public], parameter[iPojo]] begin[{]
call[.checkOpenness, parameter[]]
local_variable[type[ODocument], record]
if[binary_operation[member[.record], !=, literal[null]]] begin[{]
return[call[record.getVersion, parameter[]]]
else begin[{]
None
end[}]
return[call[OObjectSerializerHelper.getObjectVersion, parameter[member[.iPojo]]]]
end[}]
END[}]
|
Keyword[public] Keyword[int] identifier[getVersion] operator[SEP] Keyword[final] identifier[Object] identifier[iPojo] operator[SEP] {
identifier[checkOpenness] operator[SEP] operator[SEP] operator[SEP] Keyword[final] identifier[ODocument] identifier[record] operator[=] identifier[getRecordByUserObject] operator[SEP] identifier[iPojo] , literal[boolean] operator[SEP] operator[SEP] Keyword[if] operator[SEP] identifier[record] operator[!=] Other[null] operator[SEP] Keyword[return] identifier[record] operator[SEP] identifier[getVersion] operator[SEP] operator[SEP] operator[SEP] Keyword[return] identifier[OObjectSerializerHelper] operator[SEP] identifier[getObjectVersion] operator[SEP] identifier[iPojo] operator[SEP] operator[SEP]
}
|
void errorDownload(OfflineDownloadOptions offlineDownload, String error, String errorMessage) {
stateChangeDispatcher.onError(offlineDownload, error, errorMessage);
offlineDownloads.remove(offlineDownload);
}
|
class class_name[name] begin[{]
method[errorDownload, return_type[void], modifier[default], parameter[offlineDownload, error, errorMessage]] begin[{]
call[stateChangeDispatcher.onError, parameter[member[.offlineDownload], member[.error], member[.errorMessage]]]
call[offlineDownloads.remove, parameter[member[.offlineDownload]]]
end[}]
END[}]
|
Keyword[void] identifier[errorDownload] operator[SEP] identifier[OfflineDownloadOptions] identifier[offlineDownload] , identifier[String] identifier[error] , identifier[String] identifier[errorMessage] operator[SEP] {
identifier[stateChangeDispatcher] operator[SEP] identifier[onError] operator[SEP] identifier[offlineDownload] , identifier[error] , identifier[errorMessage] operator[SEP] operator[SEP] identifier[offlineDownloads] operator[SEP] identifier[remove] operator[SEP] identifier[offlineDownload] operator[SEP] operator[SEP]
}
|
protected DatasetBuilder readCatalogRef(DatasetBuilder parent, Element catRefElem) {
String title = catRefElem.getAttributeValue("title", Catalog.xlinkNS);
if (title == null) {
title = catRefElem.getAttributeValue("name");
}
String href = catRefElem.getAttributeValue("href", Catalog.xlinkNS);
CatalogRefBuilder catRef = new CatalogRefBuilder(parent);
readDatasetInfo( catRef, catRefElem);
catRef.setTitle(title);
catRef.setHref(href);
return catRef;
}
|
class class_name[name] begin[{]
method[readCatalogRef, return_type[type[DatasetBuilder]], modifier[protected], parameter[parent, catRefElem]] begin[{]
local_variable[type[String], title]
if[binary_operation[member[.title], ==, literal[null]]] begin[{]
assign[member[.title], call[catRefElem.getAttributeValue, parameter[literal["name"]]]]
else begin[{]
None
end[}]
local_variable[type[String], href]
local_variable[type[CatalogRefBuilder], catRef]
call[.readDatasetInfo, parameter[member[.catRef], member[.catRefElem]]]
call[catRef.setTitle, parameter[member[.title]]]
call[catRef.setHref, parameter[member[.href]]]
return[member[.catRef]]
end[}]
END[}]
|
Keyword[protected] identifier[DatasetBuilder] identifier[readCatalogRef] operator[SEP] identifier[DatasetBuilder] identifier[parent] , identifier[Element] identifier[catRefElem] operator[SEP] {
identifier[String] identifier[title] operator[=] identifier[catRefElem] operator[SEP] identifier[getAttributeValue] operator[SEP] literal[String] , identifier[Catalog] operator[SEP] identifier[xlinkNS] operator[SEP] operator[SEP] Keyword[if] operator[SEP] identifier[title] operator[==] Other[null] operator[SEP] {
identifier[title] operator[=] identifier[catRefElem] operator[SEP] identifier[getAttributeValue] operator[SEP] literal[String] operator[SEP] operator[SEP]
}
identifier[String] identifier[href] operator[=] identifier[catRefElem] operator[SEP] identifier[getAttributeValue] operator[SEP] literal[String] , identifier[Catalog] operator[SEP] identifier[xlinkNS] operator[SEP] operator[SEP] identifier[CatalogRefBuilder] identifier[catRef] operator[=] Keyword[new] identifier[CatalogRefBuilder] operator[SEP] identifier[parent] operator[SEP] operator[SEP] identifier[readDatasetInfo] operator[SEP] identifier[catRef] , identifier[catRefElem] operator[SEP] operator[SEP] identifier[catRef] operator[SEP] identifier[setTitle] operator[SEP] identifier[title] operator[SEP] operator[SEP] identifier[catRef] operator[SEP] identifier[setHref] operator[SEP] identifier[href] operator[SEP] operator[SEP] Keyword[return] identifier[catRef] operator[SEP]
}
|
public SetTimeSeekVodOperation buildSetTimeSeekVodOperation(int hours, int minutes, int seconds){
return new SetTimeSeekVodOperation(getOperationFactory(), hours, minutes, seconds);
}
|
class class_name[name] begin[{]
method[buildSetTimeSeekVodOperation, return_type[type[SetTimeSeekVodOperation]], modifier[public], parameter[hours, minutes, seconds]] begin[{]
return[ClassCreator(arguments=[MethodInvocation(arguments=[], member=getOperationFactory, postfix_operators=[], prefix_operators=[], qualifier=, selectors=[], type_arguments=None), MemberReference(member=hours, postfix_operators=[], prefix_operators=[], qualifier=, selectors=[]), MemberReference(member=minutes, postfix_operators=[], prefix_operators=[], qualifier=, selectors=[]), MemberReference(member=seconds, postfix_operators=[], prefix_operators=[], qualifier=, selectors=[])], body=None, constructor_type_arguments=None, postfix_operators=[], prefix_operators=[], qualifier=None, selectors=[], type=ReferenceType(arguments=None, dimensions=None, name=SetTimeSeekVodOperation, sub_type=None))]
end[}]
END[}]
|
Keyword[public] identifier[SetTimeSeekVodOperation] identifier[buildSetTimeSeekVodOperation] operator[SEP] Keyword[int] identifier[hours] , Keyword[int] identifier[minutes] , Keyword[int] identifier[seconds] operator[SEP] {
Keyword[return] Keyword[new] identifier[SetTimeSeekVodOperation] operator[SEP] identifier[getOperationFactory] operator[SEP] operator[SEP] , identifier[hours] , identifier[minutes] , identifier[seconds] operator[SEP] operator[SEP]
}
|
public static Fragment attributeIndex(
@Nullable VarProperty varProperty, Variable start, Label label, Object attributeValue) {
String attributeIndex = Schema.generateAttributeIndex(label, attributeValue.toString());
return new AutoValue_AttributeIndexFragment(varProperty, start, attributeIndex);
}
|
class class_name[name] begin[{]
method[attributeIndex, return_type[type[Fragment]], modifier[public static], parameter[varProperty, start, label, attributeValue]] begin[{]
local_variable[type[String], attributeIndex]
return[ClassCreator(arguments=[MemberReference(member=varProperty, postfix_operators=[], prefix_operators=[], qualifier=, selectors=[]), MemberReference(member=start, postfix_operators=[], prefix_operators=[], qualifier=, selectors=[]), MemberReference(member=attributeIndex, postfix_operators=[], prefix_operators=[], qualifier=, selectors=[])], body=None, constructor_type_arguments=None, postfix_operators=[], prefix_operators=[], qualifier=None, selectors=[], type=ReferenceType(arguments=None, dimensions=None, name=AutoValue_AttributeIndexFragment, sub_type=None))]
end[}]
END[}]
|
Keyword[public] Keyword[static] identifier[Fragment] identifier[attributeIndex] operator[SEP] annotation[@] identifier[Nullable] identifier[VarProperty] identifier[varProperty] , identifier[Variable] identifier[start] , identifier[Label] identifier[label] , identifier[Object] identifier[attributeValue] operator[SEP] {
identifier[String] identifier[attributeIndex] operator[=] identifier[Schema] operator[SEP] identifier[generateAttributeIndex] operator[SEP] identifier[label] , identifier[attributeValue] operator[SEP] identifier[toString] operator[SEP] operator[SEP] operator[SEP] operator[SEP] Keyword[return] Keyword[new] identifier[AutoValue_AttributeIndexFragment] operator[SEP] identifier[varProperty] , identifier[start] , identifier[attributeIndex] operator[SEP] operator[SEP]
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.