method stringlengths 13 441k | clean_method stringlengths 7 313k | doc stringlengths 17 17.3k | comment stringlengths 3 1.42k | method_name stringlengths 1 273 | extra dict | imports list | imports_info stringlengths 19 34.8k | cluster_imports_info stringlengths 15 3.66k | libraries list | libraries_info stringlengths 6 661 | id int64 0 2.92M |
|---|---|---|---|---|---|---|---|---|---|---|---|
public static HttpStatus forbidden()
{
return new HttpStatus(HttpServletResponse.SC_FORBIDDEN);
} | static HttpStatus function() { return new HttpStatus(HttpServletResponse.SC_FORBIDDEN); } | /**
* Creates an instance with status code <code>403 Forbidden</code>.
*/ | Creates an instance with status code <code>403 Forbidden</code> | forbidden | {
"repo_name": "apache/tapestry-5",
"path": "tapestry-core/src/main/java/org/apache/tapestry5/services/HttpStatus.java",
"license": "apache-2.0",
"size": 8173
} | [
"javax.servlet.http.HttpServletResponse"
] | import javax.servlet.http.HttpServletResponse; | import javax.servlet.http.*; | [
"javax.servlet"
] | javax.servlet; | 515,359 |
public BigDecimal getA_Split_Percent ()
{
BigDecimal bd = (BigDecimal)get_Value(COLUMNNAME_A_Split_Percent);
if (bd == null)
return Env.ZERO;
return bd;
} | BigDecimal function () { BigDecimal bd = (BigDecimal)get_Value(COLUMNNAME_A_Split_Percent); if (bd == null) return Env.ZERO; return bd; } | /** Get Split Percentage.
@return Split Percentage */ | Get Split Percentage | getA_Split_Percent | {
"repo_name": "arthurmelo88/palmetalADP",
"path": "adempiere_360/base/src/org/compiere/model/X_A_Asset_Change.java",
"license": "gpl-2.0",
"size": 39409
} | [
"java.math.BigDecimal",
"org.compiere.util.Env"
] | import java.math.BigDecimal; import org.compiere.util.Env; | import java.math.*; import org.compiere.util.*; | [
"java.math",
"org.compiere.util"
] | java.math; org.compiere.util; | 2,312,026 |
public void setDocumentLocator(Locator locator) {
this.locator = locator;
} | void function(Locator locator) { this.locator = locator; } | /**
* Sets the locator in the project helper for future reference.
*
* @param locator The locator used by the parser.
* Will not be <code>null</code>.
* @see org.xml.sax.ContentHandler#setDocumentLocator(Locator)
*/ | Sets the locator in the project helper for future reference | setDocumentLocator | {
"repo_name": "antlibs/ant-contrib",
"path": "src/main/java/net/sf/antcontrib/walls/WallsFileHandler.java",
"license": "apache-2.0",
"size": 5257
} | [
"org.xml.sax.Locator"
] | import org.xml.sax.Locator; | import org.xml.sax.*; | [
"org.xml.sax"
] | org.xml.sax; | 1,847,205 |
@Test
public void testSelectWhereIsNotNull() {
SelectStatement stmt = new SelectStatement().from(new TableReference(TEST_TABLE))
.where(Criterion.isNotNull(new FieldReference(INT_FIELD)));
String expectedSql = "SELECT * FROM " + tableName(TEST_TABLE) + " WHERE (intField IS NOT NULL)";
assertEquals("Select with not null clause", expectedSql, testDialect.convertStatementToSQL(stmt));
}
| void function() { SelectStatement stmt = new SelectStatement().from(new TableReference(TEST_TABLE)) .where(Criterion.isNotNull(new FieldReference(INT_FIELD))); String expectedSql = STR + tableName(TEST_TABLE) + STR; assertEquals(STR, expectedSql, testDialect.convertStatementToSQL(stmt)); } | /**
* Tests a select with a not null check clause.
*/ | Tests a select with a not null check clause | testSelectWhereIsNotNull | {
"repo_name": "badgerwithagun/morf",
"path": "morf-testsupport/src/main/java/org/alfasoftware/morf/jdbc/AbstractSqlDialectTest.java",
"license": "apache-2.0",
"size": 201465
} | [
"org.alfasoftware.morf.sql.SelectStatement",
"org.alfasoftware.morf.sql.element.Criterion",
"org.alfasoftware.morf.sql.element.FieldReference",
"org.alfasoftware.morf.sql.element.TableReference",
"org.junit.Assert"
] | import org.alfasoftware.morf.sql.SelectStatement; import org.alfasoftware.morf.sql.element.Criterion; import org.alfasoftware.morf.sql.element.FieldReference; import org.alfasoftware.morf.sql.element.TableReference; import org.junit.Assert; | import org.alfasoftware.morf.sql.*; import org.alfasoftware.morf.sql.element.*; import org.junit.*; | [
"org.alfasoftware.morf",
"org.junit"
] | org.alfasoftware.morf; org.junit; | 2,713,264 |
static IntCollector<?, char[]> toCharArray() {
return of(CharBuffer::new, CharBuffer::add, CharBuffer::addAll, CharBuffer::toArray);
}
| static IntCollector<?, char[]> toCharArray() { return of(CharBuffer::new, CharBuffer::add, CharBuffer::addAll, CharBuffer::toArray); } | /**
* Returns an {@code IntCollector} that produces the {@code char[]} array of
* the input elements converting them via {@code (char)} casting. If no
* elements are present, the result is an empty array.
*
* @return an {@code IntCollector} that produces the {@code char[]} array of
* the input elements
*/ | Returns an IntCollector that produces the char[] array of the input elements converting them via (char) casting. If no elements are present, the result is an empty array | toCharArray | {
"repo_name": "amaembo/streamex",
"path": "src/main/java/one/util/streamex/IntCollector.java",
"license": "apache-2.0",
"size": 25112
} | [
"one.util.streamex.Internals"
] | import one.util.streamex.Internals; | import one.util.streamex.*; | [
"one.util.streamex"
] | one.util.streamex; | 2,245,275 |
@Test
public void testFilterAuthenticatedUserOverridesTrustedUser() throws Exception
{
String expectedUserId = "testUser";
HashMap<String, Object> requestHeaders = new HashMap<>();
// Execute filters with security disabled
Authentication authentication1 = executeAuthenticationFilters(false, requestHeaders);
assertAuthenticatedUserId(TrustedApplicationUserBuilder.TRUSTED_USER_ID, TrustedApplicationUserBuilder.TRUSTED_USER_FIRST_NAME, null, authentication1);
// Execute filters with security disabled
requestHeaders.put("userId", expectedUserId);
Authentication authentication2 = executeAuthenticationFilters(true, requestHeaders);
assertAuthenticatedUserId(expectedUserId, null, null, authentication2);
} | void function() throws Exception { String expectedUserId = STR; HashMap<String, Object> requestHeaders = new HashMap<>(); Authentication authentication1 = executeAuthenticationFilters(false, requestHeaders); assertAuthenticatedUserId(TrustedApplicationUserBuilder.TRUSTED_USER_ID, TrustedApplicationUserBuilder.TRUSTED_USER_FIRST_NAME, null, authentication1); requestHeaders.put(STR, expectedUserId); Authentication authentication2 = executeAuthenticationFilters(true, requestHeaders); assertAuthenticatedUserId(expectedUserId, null, null, authentication2); } | /**
* When the filters are executed with security disabled, and the filters are run again with security enabled, the trusted user should no longer be in the
* context and instead the user should be created based on the headers given in the request.
*
* @throws Exception
*/ | When the filters are executed with security disabled, and the filters are run again with security enabled, the trusted user should no longer be in the context and instead the user should be created based on the headers given in the request | testFilterAuthenticatedUserOverridesTrustedUser | {
"repo_name": "FINRAOS/herd",
"path": "herd-code/herd-app/src/test/java/org/finra/herd/app/security/SecurityFilterChainTest.java",
"license": "apache-2.0",
"size": 10149
} | [
"java.util.HashMap",
"org.springframework.security.core.Authentication"
] | import java.util.HashMap; import org.springframework.security.core.Authentication; | import java.util.*; import org.springframework.security.core.*; | [
"java.util",
"org.springframework.security"
] | java.util; org.springframework.security; | 134,537 |
public void setTitleStyle(Style s) {
title.setUnselectedStyle(s);
} | void function(Style s) { title.setUnselectedStyle(s); } | /**
* Sets the style of the title programmatically
*
* @param s new style
* @deprecated this method doesn't take into consideration multiple styles
*/ | Sets the style of the title programmatically | setTitleStyle | {
"repo_name": "skyHALud/codenameone",
"path": "CodenameOne/src/com/codename1/ui/Form.java",
"license": "gpl-2.0",
"size": 99398
} | [
"com.codename1.ui.plaf.Style"
] | import com.codename1.ui.plaf.Style; | import com.codename1.ui.plaf.*; | [
"com.codename1.ui"
] | com.codename1.ui; | 651,482 |
ReceiveSubscriptionMessageResult receiveSubscriptionMessage(
String topicPath, String subscriptionName,
ReceiveMessageOptions options) throws ServiceException; | ReceiveSubscriptionMessageResult receiveSubscriptionMessage( String topicPath, String subscriptionName, ReceiveMessageOptions options) throws ServiceException; | /**
* Receives a subscription message using the specified receive message
* options.
*
* @param topicPath
* A <code>String</code> object that represents the name of the
* topic to receive.
* @param subscriptionName
* A <code>String</code> object that represents the name of the
* subscription from the message will be received.
* @param options
* A <code>ReceiveMessageOptions</code> object that represents
* the receive message options.
* @return A <code>ReceiveSubscriptionMessageResult</code> object that
* represents the result.
* @throws ServiceException
* If a service exception is encountered.
*/ | Receives a subscription message using the specified receive message options | receiveSubscriptionMessage | {
"repo_name": "flydream2046/azure-sdk-for-java",
"path": "services/azure-servicebus/src/main/java/com/microsoft/windowsazure/services/servicebus/ServiceBusContract.java",
"license": "apache-2.0",
"size": 23765
} | [
"com.microsoft.windowsazure.exception.ServiceException",
"com.microsoft.windowsazure.services.servicebus.models.ReceiveMessageOptions",
"com.microsoft.windowsazure.services.servicebus.models.ReceiveSubscriptionMessageResult"
] | import com.microsoft.windowsazure.exception.ServiceException; import com.microsoft.windowsazure.services.servicebus.models.ReceiveMessageOptions; import com.microsoft.windowsazure.services.servicebus.models.ReceiveSubscriptionMessageResult; | import com.microsoft.windowsazure.exception.*; import com.microsoft.windowsazure.services.servicebus.models.*; | [
"com.microsoft.windowsazure"
] | com.microsoft.windowsazure; | 330,662 |
void reportJobIssuesAsEvents(EventSubmitter eventSubmitter)
throws TroubleshooterException; | void reportJobIssuesAsEvents(EventSubmitter eventSubmitter) throws TroubleshooterException; | /**
* Sends the current collection of issues as GobblinTrackingEvents.
*
* Those events can be consumed by upstream and analytical systems.
*
* Can be disabled with
* {@link org.apache.gobblin.configuration.ConfigurationKeys.TROUBLESHOOTER_DISABLE_EVENT_REPORTING}.
* */ | Sends the current collection of issues as GobblinTrackingEvents. Those events can be consumed by upstream and analytical systems. Can be disabled with <code>org.apache.gobblin.configuration.ConfigurationKeys.TROUBLESHOOTER_DISABLE_EVENT_REPORTING</code> | reportJobIssuesAsEvents | {
"repo_name": "shirshanka/gobblin",
"path": "gobblin-runtime/src/main/java/org/apache/gobblin/runtime/troubleshooter/AutomaticTroubleshooter.java",
"license": "apache-2.0",
"size": 3591
} | [
"org.apache.gobblin.metrics.event.EventSubmitter"
] | import org.apache.gobblin.metrics.event.EventSubmitter; | import org.apache.gobblin.metrics.event.*; | [
"org.apache.gobblin"
] | org.apache.gobblin; | 643,788 |
public BpmnModel createOneTaskTestProcess() {
BpmnModel model = new BpmnModel();
org.activiti.bpmn.model.Process process = new org.activiti.bpmn.model.Process();
model.addProcess(process);
process.setId("oneTaskProcess");
process.setName("The one task process");
StartEvent startEvent = new StartEvent();
startEvent.setId("start");
process.addFlowElement(startEvent);
UserTask userTask = new UserTask();
userTask.setName("The Task");
userTask.setId("theTask");
userTask.setAssignee("kermit");
process.addFlowElement(userTask);
EndEvent endEvent = new EndEvent();
endEvent.setId("theEnd");
process.addFlowElement(endEvent);
process.addFlowElement(new SequenceFlow("start", "theTask"));
process.addFlowElement(new SequenceFlow("theTask", "theEnd"));
return model;
} | BpmnModel function() { BpmnModel model = new BpmnModel(); org.activiti.bpmn.model.Process process = new org.activiti.bpmn.model.Process(); model.addProcess(process); process.setId(STR); process.setName(STR); StartEvent startEvent = new StartEvent(); startEvent.setId("start"); process.addFlowElement(startEvent); UserTask userTask = new UserTask(); userTask.setName(STR); userTask.setId(STR); userTask.setAssignee(STR); process.addFlowElement(userTask); EndEvent endEvent = new EndEvent(); endEvent.setId(STR); process.addFlowElement(endEvent); process.addFlowElement(new SequenceFlow("start", STR)); process.addFlowElement(new SequenceFlow(STR, STR)); return model; } | /**
* Since the 'one task process' is used everywhere the actual process content
* doesn't matter, instead of copying around the BPMN 2.0 xml one could use
* this method which gives a {@link BpmnModel} version of the same process back.
*/ | Since the 'one task process' is used everywhere the actual process content doesn't matter, instead of copying around the BPMN 2.0 xml one could use this method which gives a <code>BpmnModel</code> version of the same process back | createOneTaskTestProcess | {
"repo_name": "stefan-ziel/Activiti",
"path": "modules/activiti5-test/src/main/java/org/activiti5/engine/impl/test/AbstractActivitiTestCase.java",
"license": "apache-2.0",
"size": 14456
} | [
"org.activiti.bpmn.model.BpmnModel",
"org.activiti.bpmn.model.EndEvent",
"org.activiti.bpmn.model.SequenceFlow",
"org.activiti.bpmn.model.StartEvent",
"org.activiti.bpmn.model.UserTask"
] | import org.activiti.bpmn.model.BpmnModel; import org.activiti.bpmn.model.EndEvent; import org.activiti.bpmn.model.SequenceFlow; import org.activiti.bpmn.model.StartEvent; import org.activiti.bpmn.model.UserTask; | import org.activiti.bpmn.model.*; | [
"org.activiti.bpmn"
] | org.activiti.bpmn; | 2,767,832 |
@Override
public void draw(Graphics2D g2, CategoryPlot plot, Rectangle2D dataArea,
CategoryAxis domainAxis, ValueAxis rangeAxis) {
CategoryDataset dataset = plot.getDataset();
int catIndex = dataset.getColumnIndex(this.category);
int catCount = dataset.getColumnCount();
float anchorX = 0.0f;
float anchorY = 0.0f;
PlotOrientation orientation = plot.getOrientation();
RectangleEdge domainEdge = Plot.resolveDomainAxisLocation(
plot.getDomainAxisLocation(), orientation);
RectangleEdge rangeEdge = Plot.resolveRangeAxisLocation(
plot.getRangeAxisLocation(), orientation);
if (orientation == PlotOrientation.HORIZONTAL) {
anchorY = (float) domainAxis.getCategoryJava2DCoordinate(
this.categoryAnchor, catIndex, catCount, dataArea,
domainEdge);
anchorX = (float) rangeAxis.valueToJava2D(this.value, dataArea,
rangeEdge);
}
else if (orientation == PlotOrientation.VERTICAL) {
anchorX = (float) domainAxis.getCategoryJava2DCoordinate(
this.categoryAnchor, catIndex, catCount, dataArea,
domainEdge);
anchorY = (float) rangeAxis.valueToJava2D(this.value, dataArea,
rangeEdge);
}
g2.setFont(getFont());
g2.setPaint(getPaint());
TextUtils.drawRotatedString(getText(), g2, anchorX, anchorY,
getTextAnchor(), getRotationAngle(), getRotationAnchor());
} | void function(Graphics2D g2, CategoryPlot plot, Rectangle2D dataArea, CategoryAxis domainAxis, ValueAxis rangeAxis) { CategoryDataset dataset = plot.getDataset(); int catIndex = dataset.getColumnIndex(this.category); int catCount = dataset.getColumnCount(); float anchorX = 0.0f; float anchorY = 0.0f; PlotOrientation orientation = plot.getOrientation(); RectangleEdge domainEdge = Plot.resolveDomainAxisLocation( plot.getDomainAxisLocation(), orientation); RectangleEdge rangeEdge = Plot.resolveRangeAxisLocation( plot.getRangeAxisLocation(), orientation); if (orientation == PlotOrientation.HORIZONTAL) { anchorY = (float) domainAxis.getCategoryJava2DCoordinate( this.categoryAnchor, catIndex, catCount, dataArea, domainEdge); anchorX = (float) rangeAxis.valueToJava2D(this.value, dataArea, rangeEdge); } else if (orientation == PlotOrientation.VERTICAL) { anchorX = (float) domainAxis.getCategoryJava2DCoordinate( this.categoryAnchor, catIndex, catCount, dataArea, domainEdge); anchorY = (float) rangeAxis.valueToJava2D(this.value, dataArea, rangeEdge); } g2.setFont(getFont()); g2.setPaint(getPaint()); TextUtils.drawRotatedString(getText(), g2, anchorX, anchorY, getTextAnchor(), getRotationAngle(), getRotationAnchor()); } | /**
* Draws the annotation.
*
* @param g2 the graphics device.
* @param plot the plot.
* @param dataArea the data area.
* @param domainAxis the domain axis.
* @param rangeAxis the range axis.
*/ | Draws the annotation | draw | {
"repo_name": "jfree/jfreechart",
"path": "src/main/java/org/jfree/chart/annotations/CategoryTextAnnotation.java",
"license": "lgpl-2.1",
"size": 8545
} | [
"java.awt.Graphics2D",
"java.awt.geom.Rectangle2D",
"org.jfree.chart.api.RectangleEdge",
"org.jfree.chart.axis.CategoryAxis",
"org.jfree.chart.axis.ValueAxis",
"org.jfree.chart.plot.CategoryPlot",
"org.jfree.chart.plot.Plot",
"org.jfree.chart.plot.PlotOrientation",
"org.jfree.chart.text.TextUtils",
"org.jfree.data.category.CategoryDataset"
] | import java.awt.Graphics2D; import java.awt.geom.Rectangle2D; import org.jfree.chart.api.RectangleEdge; import org.jfree.chart.axis.CategoryAxis; import org.jfree.chart.axis.ValueAxis; import org.jfree.chart.plot.CategoryPlot; import org.jfree.chart.plot.Plot; import org.jfree.chart.plot.PlotOrientation; import org.jfree.chart.text.TextUtils; import org.jfree.data.category.CategoryDataset; | import java.awt.*; import java.awt.geom.*; import org.jfree.chart.api.*; import org.jfree.chart.axis.*; import org.jfree.chart.plot.*; import org.jfree.chart.text.*; import org.jfree.data.category.*; | [
"java.awt",
"org.jfree.chart",
"org.jfree.data"
] | java.awt; org.jfree.chart; org.jfree.data; | 1,429,859 |
private HorizonBindingProvider findFirstMatchingBindingProvider(String itemName, Command command) {
HorizonBindingProvider firstMatchingProvider = null;
for (HorizonBindingProvider provider : this.providers) {
String commandLine = provider.getHorizonCommand(itemName, command.toString());
if (commandLine != null) {
firstMatchingProvider = provider;
break;
}
}
return firstMatchingProvider;
} | HorizonBindingProvider function(String itemName, Command command) { HorizonBindingProvider firstMatchingProvider = null; for (HorizonBindingProvider provider : this.providers) { String commandLine = provider.getHorizonCommand(itemName, command.toString()); if (commandLine != null) { firstMatchingProvider = provider; break; } } return firstMatchingProvider; } | /**
* Find the first matching {@link HorizonBindingProvider} according to
* <code>itemName</code> and <code>command</code>. If no direct match is
* found, a second match is issued with wilcard-command '*'.
*
* @param itemName
* @param command
*
* @return the matching binding provider or <code>null</code> if no binding
* provider could be found
*/ | Find the first matching <code>HorizonBindingProvider</code> according to <code>itemName</code> and <code>command</code>. If no direct match is found, a second match is issued with wilcard-command '*' | findFirstMatchingBindingProvider | {
"repo_name": "computergeek1507/openhab",
"path": "bundles/binding/org.openhab.binding.horizon/src/main/java/org/openhab/binding/horizon/internal/HorizonBinding.java",
"license": "epl-1.0",
"size": 6197
} | [
"org.openhab.binding.horizon.HorizonBindingProvider",
"org.openhab.core.types.Command"
] | import org.openhab.binding.horizon.HorizonBindingProvider; import org.openhab.core.types.Command; | import org.openhab.binding.horizon.*; import org.openhab.core.types.*; | [
"org.openhab.binding",
"org.openhab.core"
] | org.openhab.binding; org.openhab.core; | 1,714,332 |
@Override
public int hashCode() {
int hash = 7;
hash = 29 * hash + this.value;
hash = 29 * hash + Objects.hashCode(this.numeral);
return hash;
} | int function() { int hash = 7; hash = 29 * hash + this.value; hash = 29 * hash + Objects.hashCode(this.numeral); return hash; } | /**
* Returns the hash of this RomanInteger.
* <p>
* The hashcode is created using the int value and the RomanNumeral. Uses
* {@link Objects#hashCode(java.lang.Object)} and overrides
* {@link Object#hashCode()}.
*
* @return the hash of this RomanInteger.
* @see Object#hashCode()
*/ | Returns the hash of this RomanInteger. The hashcode is created using the int value and the RomanNumeral. Uses <code>Objects#hashCode(java.lang.Object)</code> and overrides <code>Object#hashCode()</code> | hashCode | {
"repo_name": "TheMatjaz/jNumerus",
"path": "src/main/java/it/matjaz/jnumerus/RomanInteger.java",
"license": "mpl-2.0",
"size": 10653
} | [
"java.util.Objects"
] | import java.util.Objects; | import java.util.*; | [
"java.util"
] | java.util; | 2,711,375 |
@Test
public void geodeLoggerLogsToMainLogFileWithHigherSecurityLogLevel() {
Properties config = new Properties();
config.setProperty(LOCATORS, "");
config.setProperty(LOG_FILE, mainLogFilePath);
config.setProperty(LOG_LEVEL, FINE.name());
config.setProperty(SECURITY_LOG_LEVEL, INFO.name());
system = (InternalDistributedSystem) DistributedSystem.connect(config);
DistributionConfig distributionConfig = system.getConfig();
await().untilAsserted(() -> assertThat(mainLogFile).exists());
assertThat(distributionConfig.getLogLevel()).isEqualTo(FINE.intLevel());
assertThat(distributionConfig.getSecurityLogLevel()).isEqualTo(INFO.intLevel());
assertThat(geodeLogger.getLevel()).isEqualTo(Level.DEBUG);
String message = createMessage(Level.TRACE);
geodeLogger.trace(message);
LogFileAssert.assertThat(mainLogFile).doesNotContain(message);
message = createMessage(Level.DEBUG);
geodeLogger.debug(message);
LogFileAssert.assertThat(mainLogFile).contains(message);
message = createMessage(Level.INFO);
geodeLogger.info(message);
LogFileAssert.assertThat(mainLogFile).contains(message);
message = createMessage(Level.WARN);
geodeLogger.warn(message);
LogFileAssert.assertThat(mainLogFile).contains(message);
message = createMessage(Level.ERROR);
geodeLogger.error(message);
LogFileAssert.assertThat(mainLogFile).contains(message);
message = createMessage(Level.FATAL);
geodeLogger.fatal(message);
LogFileAssert.assertThat(mainLogFile).contains(message);
} | void function() { Properties config = new Properties(); config.setProperty(LOCATORS, ""); config.setProperty(LOG_FILE, mainLogFilePath); config.setProperty(LOG_LEVEL, FINE.name()); config.setProperty(SECURITY_LOG_LEVEL, INFO.name()); system = (InternalDistributedSystem) DistributedSystem.connect(config); DistributionConfig distributionConfig = system.getConfig(); await().untilAsserted(() -> assertThat(mainLogFile).exists()); assertThat(distributionConfig.getLogLevel()).isEqualTo(FINE.intLevel()); assertThat(distributionConfig.getSecurityLogLevel()).isEqualTo(INFO.intLevel()); assertThat(geodeLogger.getLevel()).isEqualTo(Level.DEBUG); String message = createMessage(Level.TRACE); geodeLogger.trace(message); LogFileAssert.assertThat(mainLogFile).doesNotContain(message); message = createMessage(Level.DEBUG); geodeLogger.debug(message); LogFileAssert.assertThat(mainLogFile).contains(message); message = createMessage(Level.INFO); geodeLogger.info(message); LogFileAssert.assertThat(mainLogFile).contains(message); message = createMessage(Level.WARN); geodeLogger.warn(message); LogFileAssert.assertThat(mainLogFile).contains(message); message = createMessage(Level.ERROR); geodeLogger.error(message); LogFileAssert.assertThat(mainLogFile).contains(message); message = createMessage(Level.FATAL); geodeLogger.fatal(message); LogFileAssert.assertThat(mainLogFile).contains(message); } | /**
* tests scenario where security log has not been set but a level has been set to a less granular
* level than that of the regular log. Verifies that the correct logs for security show up in the
* regular log as expected
*/ | tests scenario where security log has not been set but a level has been set to a less granular level than that of the regular log. Verifies that the correct logs for security show up in the regular log as expected | geodeLoggerLogsToMainLogFileWithHigherSecurityLogLevel | {
"repo_name": "davebarnes97/geode",
"path": "geode-log4j/src/integrationTest/java/org/apache/geode/logging/log4j/internal/impl/LoggingWithDistributedSystemIntegrationTest.java",
"license": "apache-2.0",
"size": 59167
} | [
"java.util.Properties",
"org.apache.geode.distributed.DistributedSystem",
"org.apache.geode.distributed.internal.DistributionConfig",
"org.apache.geode.distributed.internal.InternalDistributedSystem",
"org.apache.geode.logging.internal.spi.LogWriterLevel",
"org.apache.geode.test.assertj.LogFileAssert",
"org.apache.geode.test.awaitility.GeodeAwaitility",
"org.apache.logging.log4j.Level",
"org.assertj.core.api.Assertions"
] | import java.util.Properties; import org.apache.geode.distributed.DistributedSystem; import org.apache.geode.distributed.internal.DistributionConfig; import org.apache.geode.distributed.internal.InternalDistributedSystem; import org.apache.geode.logging.internal.spi.LogWriterLevel; import org.apache.geode.test.assertj.LogFileAssert; import org.apache.geode.test.awaitility.GeodeAwaitility; import org.apache.logging.log4j.Level; import org.assertj.core.api.Assertions; | import java.util.*; import org.apache.geode.distributed.*; import org.apache.geode.distributed.internal.*; import org.apache.geode.logging.internal.spi.*; import org.apache.geode.test.assertj.*; import org.apache.geode.test.awaitility.*; import org.apache.logging.log4j.*; import org.assertj.core.api.*; | [
"java.util",
"org.apache.geode",
"org.apache.logging",
"org.assertj.core"
] | java.util; org.apache.geode; org.apache.logging; org.assertj.core; | 2,081,686 |
public com.mozu.api.contracts.commerceruntime.fulfillment.DigitalPackage createDigitalPackage(com.mozu.api.contracts.commerceruntime.fulfillment.DigitalPackage digitalPackage, String orderId, String responseFields) throws Exception
{
MozuClient<com.mozu.api.contracts.commerceruntime.fulfillment.DigitalPackage> client = com.mozu.api.clients.commerce.orders.DigitalPackageClient.createDigitalPackageClient( digitalPackage, orderId, responseFields);
client.setContext(_apiContext);
client.executeRequest();
return client.getResult();
} | com.mozu.api.contracts.commerceruntime.fulfillment.DigitalPackage function(com.mozu.api.contracts.commerceruntime.fulfillment.DigitalPackage digitalPackage, String orderId, String responseFields) throws Exception { MozuClient<com.mozu.api.contracts.commerceruntime.fulfillment.DigitalPackage> client = com.mozu.api.clients.commerce.orders.DigitalPackageClient.createDigitalPackageClient( digitalPackage, orderId, responseFields); client.setContext(_apiContext); client.executeRequest(); return client.getResult(); } | /**
* Lets you apply a digital package to the order using the orderId and digitalPackage parameters.
* <p><pre><code>
* DigitalPackage digitalpackage = new DigitalPackage();
* DigitalPackage digitalPackage = digitalpackage.createDigitalPackage( digitalPackage, orderId, responseFields);
* </code></pre></p>
* @param orderId Unique identifier of the order.
* @param responseFields Use this field to include those fields which are not included by default.
* @param digitalPackage Lets you manage an order's digital packages, by applying a digital package to the order.
* @return com.mozu.api.contracts.commerceruntime.fulfillment.DigitalPackage
* @see com.mozu.api.contracts.commerceruntime.fulfillment.DigitalPackage
* @see com.mozu.api.contracts.commerceruntime.fulfillment.DigitalPackage
*/ | Lets you apply a digital package to the order using the orderId and digitalPackage parameters. <code><code> DigitalPackage digitalpackage = new DigitalPackage(); DigitalPackage digitalPackage = digitalpackage.createDigitalPackage( digitalPackage, orderId, responseFields); </code></code> | createDigitalPackage | {
"repo_name": "lakshmi-nair/mozu-java",
"path": "mozu-java-core/src/main/java/com/mozu/api/resources/commerce/orders/DigitalPackageResource.java",
"license": "mit",
"size": 10245
} | [
"com.mozu.api.MozuClient"
] | import com.mozu.api.MozuClient; | import com.mozu.api.*; | [
"com.mozu.api"
] | com.mozu.api; | 2,733,425 |
public synchronized void flush() throws IOException {
checkNotClosed();
trimToSize();
journalWriter.flush();
} | synchronized void function() throws IOException { checkNotClosed(); trimToSize(); journalWriter.flush(); } | /**
* Force buffered operations to the filesystem.
*/ | Force buffered operations to the filesystem | flush | {
"repo_name": "msdgwzhy6/AndroidDemo",
"path": "app/src/main/java/com/socks/androiddemo/utils/cache/DiskLruCache.java",
"license": "apache-2.0",
"size": 33905
} | [
"java.io.IOException"
] | import java.io.IOException; | import java.io.*; | [
"java.io"
] | java.io; | 555,473 |
private ShardSnapshotMetaDeleteResult deleteFromShardSnapshotMeta(
Set<SnapshotId> survivingSnapshots,
IndexId indexId,
int snapshotShardId,
Collection<SnapshotId> snapshotIds,
BlobContainer shardContainer,
Set<String> blobs,
BlobStoreIndexShardSnapshots snapshots,
long indexGeneration
) {
// Build a list of snapshots that should be preserved
List<SnapshotFiles> newSnapshotsList = new ArrayList<>();
final Set<String> survivingSnapshotNames = survivingSnapshots.stream().map(SnapshotId::getName).collect(Collectors.toSet());
for (SnapshotFiles point : snapshots) {
if (survivingSnapshotNames.contains(point.snapshot())) {
newSnapshotsList.add(point);
}
}
ShardGeneration writtenGeneration = null;
try {
if (newSnapshotsList.isEmpty()) {
return new ShardSnapshotMetaDeleteResult(indexId, snapshotShardId, ShardGenerations.DELETED_SHARD_GEN, blobs);
} else {
final BlobStoreIndexShardSnapshots updatedSnapshots = new BlobStoreIndexShardSnapshots(newSnapshotsList);
if (indexGeneration < 0L) {
writtenGeneration = ShardGeneration.newGeneration();
INDEX_SHARD_SNAPSHOTS_FORMAT.write(updatedSnapshots, shardContainer, writtenGeneration.toBlobNamePart(), compress);
} else {
writtenGeneration = new ShardGeneration(indexGeneration);
writeShardIndexBlobAtomic(shardContainer, indexGeneration, updatedSnapshots);
}
final Set<String> survivingSnapshotUUIDs = survivingSnapshots.stream().map(SnapshotId::getUUID).collect(Collectors.toSet());
return new ShardSnapshotMetaDeleteResult(
indexId,
snapshotShardId,
writtenGeneration,
unusedBlobs(blobs, survivingSnapshotUUIDs, updatedSnapshots)
);
}
} catch (IOException e) {
throw new RepositoryException(
metadata.name(),
"Failed to finalize snapshot deletion "
+ snapshotIds
+ " with shard index ["
+ INDEX_SHARD_SNAPSHOTS_FORMAT.blobName(writtenGeneration.toBlobNamePart())
+ "]",
e
);
}
} | ShardSnapshotMetaDeleteResult function( Set<SnapshotId> survivingSnapshots, IndexId indexId, int snapshotShardId, Collection<SnapshotId> snapshotIds, BlobContainer shardContainer, Set<String> blobs, BlobStoreIndexShardSnapshots snapshots, long indexGeneration ) { List<SnapshotFiles> newSnapshotsList = new ArrayList<>(); final Set<String> survivingSnapshotNames = survivingSnapshots.stream().map(SnapshotId::getName).collect(Collectors.toSet()); for (SnapshotFiles point : snapshots) { if (survivingSnapshotNames.contains(point.snapshot())) { newSnapshotsList.add(point); } } ShardGeneration writtenGeneration = null; try { if (newSnapshotsList.isEmpty()) { return new ShardSnapshotMetaDeleteResult(indexId, snapshotShardId, ShardGenerations.DELETED_SHARD_GEN, blobs); } else { final BlobStoreIndexShardSnapshots updatedSnapshots = new BlobStoreIndexShardSnapshots(newSnapshotsList); if (indexGeneration < 0L) { writtenGeneration = ShardGeneration.newGeneration(); INDEX_SHARD_SNAPSHOTS_FORMAT.write(updatedSnapshots, shardContainer, writtenGeneration.toBlobNamePart(), compress); } else { writtenGeneration = new ShardGeneration(indexGeneration); writeShardIndexBlobAtomic(shardContainer, indexGeneration, updatedSnapshots); } final Set<String> survivingSnapshotUUIDs = survivingSnapshots.stream().map(SnapshotId::getUUID).collect(Collectors.toSet()); return new ShardSnapshotMetaDeleteResult( indexId, snapshotShardId, writtenGeneration, unusedBlobs(blobs, survivingSnapshotUUIDs, updatedSnapshots) ); } } catch (IOException e) { throw new RepositoryException( metadata.name(), STR + snapshotIds + STR + INDEX_SHARD_SNAPSHOTS_FORMAT.blobName(writtenGeneration.toBlobNamePart()) + "]", e ); } } | /**
* Delete snapshot from shard level metadata.
*
* @param indexGeneration generation to write the new shard level level metadata to. If negative a uuid id shard generation should be
* used
*/ | Delete snapshot from shard level metadata | deleteFromShardSnapshotMeta | {
"repo_name": "ern/elasticsearch",
"path": "server/src/main/java/org/elasticsearch/repositories/blobstore/BlobStoreRepository.java",
"license": "apache-2.0",
"size": 176266
} | [
"java.io.IOException",
"java.util.ArrayList",
"java.util.Collection",
"java.util.List",
"java.util.Set",
"java.util.stream.Collectors",
"org.elasticsearch.common.blobstore.BlobContainer",
"org.elasticsearch.index.snapshots.blobstore.BlobStoreIndexShardSnapshots",
"org.elasticsearch.index.snapshots.blobstore.SnapshotFiles",
"org.elasticsearch.repositories.IndexId",
"org.elasticsearch.repositories.RepositoryException",
"org.elasticsearch.repositories.ShardGeneration",
"org.elasticsearch.repositories.ShardGenerations",
"org.elasticsearch.snapshots.SnapshotId"
] | import java.io.IOException; import java.util.ArrayList; import java.util.Collection; import java.util.List; import java.util.Set; import java.util.stream.Collectors; import org.elasticsearch.common.blobstore.BlobContainer; import org.elasticsearch.index.snapshots.blobstore.BlobStoreIndexShardSnapshots; import org.elasticsearch.index.snapshots.blobstore.SnapshotFiles; import org.elasticsearch.repositories.IndexId; import org.elasticsearch.repositories.RepositoryException; import org.elasticsearch.repositories.ShardGeneration; import org.elasticsearch.repositories.ShardGenerations; import org.elasticsearch.snapshots.SnapshotId; | import java.io.*; import java.util.*; import java.util.stream.*; import org.elasticsearch.common.blobstore.*; import org.elasticsearch.index.snapshots.blobstore.*; import org.elasticsearch.repositories.*; import org.elasticsearch.snapshots.*; | [
"java.io",
"java.util",
"org.elasticsearch.common",
"org.elasticsearch.index",
"org.elasticsearch.repositories",
"org.elasticsearch.snapshots"
] | java.io; java.util; org.elasticsearch.common; org.elasticsearch.index; org.elasticsearch.repositories; org.elasticsearch.snapshots; | 2,155,122 |
public void update(long time) throws ObjectNotSupportedException {
Iterator<Transformation> it = transformations.iterator();
while (it.hasNext()) {
Transformation trans = it.next();
if (time >= trans.getBegin() && time <= trans.getEnd()) {
trans.apply(this, time);
}
}
} | void function(long time) throws ObjectNotSupportedException { Iterator<Transformation> it = transformations.iterator(); while (it.hasNext()) { Transformation trans = it.next(); if (time >= trans.getBegin() && time <= trans.getEnd()) { trans.apply(this, time); } } } | /**
* Update characteristics according to the given time and the
* transformations of the light.
*
* @param time
* the time in the scene for the update.
*/ | Update characteristics according to the given time and the transformations of the light | update | {
"repo_name": "guiguito/SiJaRay",
"path": "src/Raytracer/RaytracerObject.java",
"license": "apache-2.0",
"size": 2631
} | [
"java.util.Iterator"
] | import java.util.Iterator; | import java.util.*; | [
"java.util"
] | java.util; | 95,902 |
// try to get the resource input stream
if (isContentCache()) {
synchronized (this) {
if (buffer == null) {
log.debug("Reading resource: {} into the content cache", resourceUri);
try (InputStream is = getResourceAsInputStreamWithoutCache()) {
ByteArrayOutputStream bos = new ByteArrayOutputStream();
IOHelper.copy(IOHelper.buffered(is), bos);
buffer = bos.toByteArray();
}
}
}
log.debug("Using resource: {} from the content cache", resourceUri);
return new ByteArrayInputStream(buffer);
}
return getResourceAsInputStreamWithoutCache();
} | if (isContentCache()) { synchronized (this) { if (buffer == null) { log.debug(STR, resourceUri); try (InputStream is = getResourceAsInputStreamWithoutCache()) { ByteArrayOutputStream bos = new ByteArrayOutputStream(); IOHelper.copy(IOHelper.buffered(is), bos); buffer = bos.toByteArray(); } } } log.debug(STR, resourceUri); return new ByteArrayInputStream(buffer); } return getResourceAsInputStreamWithoutCache(); } | /**
* Gets the resource as an input stream considering the cache flag as well.
* <p/>
* If cache is enabled then the resource content is cached in an internal buffer and this content is
* returned to avoid loading the resource over and over again.
*
* @return the input stream
* @throws IOException is thrown if error loading the content of the resource to the local cache buffer
*/ | Gets the resource as an input stream considering the cache flag as well. If cache is enabled then the resource content is cached in an internal buffer and this content is returned to avoid loading the resource over and over again | getResourceAsInputStream | {
"repo_name": "punkhorn/camel-upstream",
"path": "core/camel-support/src/main/java/org/apache/camel/component/ResourceEndpoint.java",
"license": "apache-2.0",
"size": 6400
} | [
"java.io.ByteArrayInputStream",
"java.io.ByteArrayOutputStream",
"java.io.InputStream",
"org.apache.camel.util.IOHelper"
] | import java.io.ByteArrayInputStream; import java.io.ByteArrayOutputStream; import java.io.InputStream; import org.apache.camel.util.IOHelper; | import java.io.*; import org.apache.camel.util.*; | [
"java.io",
"org.apache.camel"
] | java.io; org.apache.camel; | 930,836 |
public static <T> int hashCodeForSet(final Collection<T> set) {
if (set == null) {
return 0;
}
int hashCode = 0;
for (final T obj : set) {
if (obj != null) {
hashCode += obj.hashCode();
}
}
return hashCode;
}
//-----------------------------------------------------------------------
/**
* Returns a synchronized set backed by the given set.
* <p>
* You must manually synchronize on the returned set's iterator to
* avoid non-deterministic behavior:
*
* <pre>
* Set s = SetUtils.synchronizedSet(mySet);
* synchronized (s) {
* Iterator i = s.iterator();
* while (i.hasNext()) {
* process (i.next());
* }
* } | static <T> int function(final Collection<T> set) { if (set == null) { return 0; } int hashCode = 0; for (final T obj : set) { if (obj != null) { hashCode += obj.hashCode(); } } return hashCode; } /** * Returns a synchronized set backed by the given set. * <p> * You must manually synchronize on the returned set's iterator to * avoid non-deterministic behavior: * * <pre> * Set s = SetUtils.synchronizedSet(mySet); * synchronized (s) { * Iterator i = s.iterator(); * while (i.hasNext()) { * process (i.next()); * } * } | /**
* Generates a hash code using the algorithm specified in
* {@link java.util.Set#hashCode()}.
* <p>
* This method is useful for implementing <code>Set</code> when you cannot
* extend AbstractSet. The method takes Collection instances to enable other
* collection types to use the Set implementation algorithm.
*
* @param <T> the element type
* @see java.util.Set#hashCode()
* @param set the set to calculate the hash code for, may be null
* @return the hash code
*/ | Generates a hash code using the algorithm specified in <code>java.util.Set#hashCode()</code>. This method is useful for implementing <code>Set</code> when you cannot extend AbstractSet. The method takes Collection instances to enable other collection types to use the Set implementation algorithm | hashCodeForSet | {
"repo_name": "krivachy/compgs03_mutation_testing",
"path": "src/main/java/org/apache/commons/collections4/SetUtils.java",
"license": "apache-2.0",
"size": 12929
} | [
"java.util.Collection",
"java.util.Set"
] | import java.util.Collection; import java.util.Set; | import java.util.*; | [
"java.util"
] | java.util; | 1,463,401 |
context.addPropertyAccessor(new BeanFactoryAccessor());
context.setBeanResolver(new BeanFactoryResolver(applicationContext));
context.setRootObject(applicationContext);
} | context.addPropertyAccessor(new BeanFactoryAccessor()); context.setBeanResolver(new BeanFactoryResolver(applicationContext)); context.setRootObject(applicationContext); } | /**
* To set application context
* @param applicationContext must not be {@literal null}.
* @throws BeansException the bean exception
*/ | To set application context | setApplicationContext | {
"repo_name": "selvasingh/azure-sdk-for-java",
"path": "sdk/cosmos/azure-spring-data-cosmos/src/main/java/com/azure/spring/data/cosmos/core/mapping/BasicCosmosPersistentEntity.java",
"license": "mit",
"size": 2069
} | [
"org.springframework.context.expression.BeanFactoryAccessor",
"org.springframework.context.expression.BeanFactoryResolver"
] | import org.springframework.context.expression.BeanFactoryAccessor; import org.springframework.context.expression.BeanFactoryResolver; | import org.springframework.context.expression.*; | [
"org.springframework.context"
] | org.springframework.context; | 2,104,470 |
public static double getValueAsDouble(byte[] key,
NavigableMap<byte[], byte[]> infoValues) {
byte[] value = infoValues.get(key);
if (value != null) {
return Bytes.toDouble(value);
} else {
return 0.0;
}
} | static double function(byte[] key, NavigableMap<byte[], byte[]> infoValues) { byte[] value = infoValues.get(key); if (value != null) { return Bytes.toDouble(value); } else { return 0.0; } } | /**
* return a value from the NavigableMap as a Double
* @param key to be looked up for the value
* @param infoValues - the map containing the key values
* @return value as Double or 0.0
*/ | return a value from the NavigableMap as a Double | getValueAsDouble | {
"repo_name": "ogre0403/hraven",
"path": "hraven-core/src/main/java/com/twitter/hraven/util/ByteUtil.java",
"license": "apache-2.0",
"size": 10013
} | [
"java.util.NavigableMap",
"org.apache.hadoop.hbase.util.Bytes"
] | import java.util.NavigableMap; import org.apache.hadoop.hbase.util.Bytes; | import java.util.*; import org.apache.hadoop.hbase.util.*; | [
"java.util",
"org.apache.hadoop"
] | java.util; org.apache.hadoop; | 676,996 |
public File getCurrentDir() {
return new File(root, STORAGE_DIR_CURRENT);
} | File function() { return new File(root, STORAGE_DIR_CURRENT); } | /**
* Directory {@code current} contains latest files defining
* the file system meta-data.
*
* @return the directory path
*/ | Directory current contains latest files defining the file system meta-data | getCurrentDir | {
"repo_name": "messi49/hadoop",
"path": "hadoop-hdfs-project/hadoop-hdfs/src/main/java/org/apache/hadoop/hdfs/server/common/Storage.java",
"license": "apache-2.0",
"size": 40355
} | [
"java.io.File"
] | import java.io.File; | import java.io.*; | [
"java.io"
] | java.io; | 2,681,076 |
@Nonnull
public ThumbnailSetRequest expand(@Nonnull final String value) {
addExpandOption(value);
return this;
} | ThumbnailSetRequest function(@Nonnull final String value) { addExpandOption(value); return this; } | /**
* Sets the expand clause for the request
*
* @param value the expand clause
* @return the updated request
*/ | Sets the expand clause for the request | expand | {
"repo_name": "microsoftgraph/msgraph-sdk-java",
"path": "src/main/java/com/microsoft/graph/requests/ThumbnailSetRequest.java",
"license": "mit",
"size": 5772
} | [
"javax.annotation.Nonnull"
] | import javax.annotation.Nonnull; | import javax.annotation.*; | [
"javax.annotation"
] | javax.annotation; | 192,100 |
public void onClick_left(View v){
double longitudeDouble = Double.valueOf(longitude);
longitudeDouble -= scrollSpeed/Math.pow(2,zoom);
longitude = "" + longitudeDouble;
showMap();
}
| void function(View v){ double longitudeDouble = Double.valueOf(longitude); longitudeDouble -= scrollSpeed/Math.pow(2,zoom); longitude = "" + longitudeDouble; showMap(); } | /**
* Decreases the center point's longitude (moves the map west) and updates with a new map image.
*
* The longitude decrease is proportional to the zoom level, so a consistent "movement" of the map is achieved
* regardless of zoom level.
*/ | Decreases the center point's longitude (moves the map west) and updates with a new map image. The longitude decrease is proportional to the zoom level, so a consistent "movement" of the map is achieved regardless of zoom level | onClick_left | {
"repo_name": "CMPUT301W15T14/ExpenseExpress",
"path": "src/team14/expenseexpress/maps/MapActivity.java",
"license": "gpl-3.0",
"size": 11058
} | [
"android.view.View"
] | import android.view.View; | import android.view.*; | [
"android.view"
] | android.view; | 1,266,682 |
@Override
public SimpleEdgeStream<K, EV> filterVertices(FilterFunction<Vertex<K, NullValue>> filter) {
DataStream<Edge<K, EV>> remainingEdges = this.edges
.filter(new ApplyVertexFilterToEdges<K, EV>(filter));
return new SimpleEdgeStream<>(remainingEdges, this.context);
}
private static final class ApplyVertexFilterToEdges<K, EV>
implements FilterFunction<Edge<K, EV>> {
private FilterFunction<Vertex<K, NullValue>> vertexFilter;
public ApplyVertexFilterToEdges(FilterFunction<Vertex<K, NullValue>> vertexFilter) {
this.vertexFilter = vertexFilter;
}
| SimpleEdgeStream<K, EV> function(FilterFunction<Vertex<K, NullValue>> filter) { DataStream<Edge<K, EV>> remainingEdges = this.edges .filter(new ApplyVertexFilterToEdges<K, EV>(filter)); return new SimpleEdgeStream<>(remainingEdges, this.context); } private static final class ApplyVertexFilterToEdges<K, EV> implements FilterFunction<Edge<K, EV>> { private FilterFunction<Vertex<K, NullValue>> vertexFilter; public ApplyVertexFilterToEdges(FilterFunction<Vertex<K, NullValue>> vertexFilter) { this.vertexFilter = vertexFilter; } | /**
* Apply a filter to each vertex in the graph stream
* Since this is an edge-only stream, the vertex filter can only access the key of vertices
*
* @param filter the filter function to apply.
* @return the filtered graph stream.
*/ | Apply a filter to each vertex in the graph stream Since this is an edge-only stream, the vertex filter can only access the key of vertices | filterVertices | {
"repo_name": "BenjaminSchiller/FlinkWrapper",
"path": "src/main/java/org/apache/flink/graph/streaming/SimpleEdgeStream.java",
"license": "apache-2.0",
"size": 18058
} | [
"org.apache.flink.api.common.functions.FilterFunction",
"org.apache.flink.graph.Edge",
"org.apache.flink.graph.Vertex",
"org.apache.flink.streaming.api.datastream.DataStream",
"org.apache.flink.types.NullValue"
] | import org.apache.flink.api.common.functions.FilterFunction; import org.apache.flink.graph.Edge; import org.apache.flink.graph.Vertex; import org.apache.flink.streaming.api.datastream.DataStream; import org.apache.flink.types.NullValue; | import org.apache.flink.api.common.functions.*; import org.apache.flink.graph.*; import org.apache.flink.streaming.api.datastream.*; import org.apache.flink.types.*; | [
"org.apache.flink"
] | org.apache.flink; | 784,474 |
public static BitSet union(BitSet set0, BitSet... sets) {
final BitSet s = (BitSet) set0.clone();
for (BitSet set : sets) {
s.or(set);
}
return s;
} | static BitSet function(BitSet set0, BitSet... sets) { final BitSet s = (BitSet) set0.clone(); for (BitSet set : sets) { s.or(set); } return s; } | /** Returns a BitSet that is the union of the given BitSets. Does not modify
* any of the inputs. */ | Returns a BitSet that is the union of the given BitSets. Does not modify | union | {
"repo_name": "sreev/incubator-calcite",
"path": "core/src/main/java/org/apache/calcite/util/BitSets.java",
"license": "apache-2.0",
"size": 10403
} | [
"java.util.BitSet"
] | import java.util.BitSet; | import java.util.*; | [
"java.util"
] | java.util; | 1,539,552 |
@VisibleForTesting static URI getClassPathEntry(File jarFile, String path)
throws URISyntaxException {
URI uri = new URI(path);
return uri.isAbsolute()
? uri
: new File(jarFile.getParentFile(), path.replace('/', File.separatorChar)).toURI();
}
} | @VisibleForTesting static URI getClassPathEntry(File jarFile, String path) throws URISyntaxException { URI uri = new URI(path); return uri.isAbsolute() ? uri : new File(jarFile.getParentFile(), path.replace('/', File.separatorChar)).toURI(); } } | /**
* Returns the absolute uri of the Class-Path entry value as specified in
* <a
* href="http://docs.oracle.com/javase/6/docs/technotes/guides/jar/jar.html#Main%20Attributes">
* JAR File Specification</a>. Even though the specification only talks about relative urls,
* absolute urls are actually supported too (for example, in Maven surefire plugin).
*/ | Returns the absolute uri of the Class-Path entry value as specified in JAR File Specification. Even though the specification only talks about relative urls, absolute urls are actually supported too (for example, in Maven surefire plugin) | getClassPathEntry | {
"repo_name": "cmelchior/caliper",
"path": "old/caliper/main/java/com/google/caliper/runner/JarFinder.java",
"license": "apache-2.0",
"size": 7180
} | [
"com.google.common.annotations.VisibleForTesting",
"java.io.File",
"java.net.URISyntaxException"
] | import com.google.common.annotations.VisibleForTesting; import java.io.File; import java.net.URISyntaxException; | import com.google.common.annotations.*; import java.io.*; import java.net.*; | [
"com.google.common",
"java.io",
"java.net"
] | com.google.common; java.io; java.net; | 1,750,381 |
@SuppressWarnings("deprecation")
public void setBehindWidth(int i) {
int width;
Display display = ((WindowManager) getContext().getSystemService(
Context.WINDOW_SERVICE)).getDefaultDisplay();
try {
Class<?> cls = Display.class;
Class<?>[] parameterTypes = { Point.class };
Point parameter = new Point();
Method method = cls.getMethod("getSize", parameterTypes);
method.invoke(display, parameter);
width = parameter.x;
} catch (Exception e) {
width = display.getWidth();
}
setBehindOffset(width - i);
} | @SuppressWarnings(STR) void function(int i) { int width; Display display = ((WindowManager) getContext().getSystemService( Context.WINDOW_SERVICE)).getDefaultDisplay(); try { Class<?> cls = Display.class; Class<?>[] parameterTypes = { Point.class }; Point parameter = new Point(); Method method = cls.getMethod(STR, parameterTypes); method.invoke(display, parameter); width = parameter.x; } catch (Exception e) { width = display.getWidth(); } setBehindOffset(width - i); } | /**
* Sets the behind width.
*
* @param i
* The width the Sliding Menu will open to, in pixels
*/ | Sets the behind width | setBehindWidth | {
"repo_name": "Amuck/SlidingMenuLib",
"path": "src/com/jeremyfeinstein/slidingmenu/lib/SlidingMenu.java",
"license": "apache-2.0",
"size": 30629
} | [
"android.content.Context",
"android.graphics.Point",
"android.view.Display",
"android.view.WindowManager",
"java.lang.reflect.Method"
] | import android.content.Context; import android.graphics.Point; import android.view.Display; import android.view.WindowManager; import java.lang.reflect.Method; | import android.content.*; import android.graphics.*; import android.view.*; import java.lang.reflect.*; | [
"android.content",
"android.graphics",
"android.view",
"java.lang"
] | android.content; android.graphics; android.view; java.lang; | 1,671,986 |
public static KeyStore getKeystore() {
KeyStore trustStore = null;
try {
trustStore = KeyStore.getInstance(KeyStore.getDefaultType());
trustStore.load(null, null);
} catch (Throwable t) {
t.printStackTrace();
}
return trustStore;
} | static KeyStore function() { KeyStore trustStore = null; try { trustStore = KeyStore.getInstance(KeyStore.getDefaultType()); trustStore.load(null, null); } catch (Throwable t) { t.printStackTrace(); } return trustStore; } | /**
* Gets a Default KeyStore
*
* @return KeyStore
*/ | Gets a Default KeyStore | getKeystore | {
"repo_name": "jinmiao0601/demo",
"path": "app/src/main/java/com/appcutt/libs/net/http/MySSLSocketFactory.java",
"license": "apache-2.0",
"size": 7299
} | [
"java.security.KeyStore"
] | import java.security.KeyStore; | import java.security.*; | [
"java.security"
] | java.security; | 834,603 |
EAttribute getLocationType_IncludeSource(); | EAttribute getLocationType_IncludeSource(); | /**
* Returns the meta object for the attribute '{@link bitub.support.p2.LocationType#isIncludeSource <em>Include Source</em>}'.
* <!-- begin-user-doc -->
* <!-- end-user-doc -->
* @return the meta object for the attribute '<em>Include Source</em>'.
* @see bitub.support.p2.LocationType#isIncludeSource()
* @see #getLocationType()
* @generated
*/ | Returns the meta object for the attribute '<code>bitub.support.p2.LocationType#isIncludeSource Include Source</code>'. | getLocationType_IncludeSource | {
"repo_name": "bekraft/bitub.support",
"path": "plugins/bitub.support.p2/src-gen/bitub/support/p2/P2Package.java",
"license": "epl-1.0",
"size": 41896
} | [
"org.eclipse.emf.ecore.EAttribute"
] | import org.eclipse.emf.ecore.EAttribute; | import org.eclipse.emf.ecore.*; | [
"org.eclipse.emf"
] | org.eclipse.emf; | 55,428 |
public static boolean isExprCall(Node n) {
return n.isExprResult()
&& n.getFirstChild().isCall();
} | static boolean function(Node n) { return n.isExprResult() && n.getFirstChild().isCall(); } | /**
* Is this node a call expression statement?
*
* @param n The node
* @return True if {@code n} is EXPR_RESULT and {@code n}'s
* first child is CALL
*/ | Is this node a call expression statement | isExprCall | {
"repo_name": "shantanusharma/closure-compiler",
"path": "src/com/google/javascript/jscomp/NodeUtil.java",
"license": "apache-2.0",
"size": 180617
} | [
"com.google.javascript.rhino.Node"
] | import com.google.javascript.rhino.Node; | import com.google.javascript.rhino.*; | [
"com.google.javascript"
] | com.google.javascript; | 533,333 |
public ShortAssert assertShort(int index) {
Object value = value(index);
return Assertions.assertShort(value);
} | ShortAssert function(int index) { Object value = value(index); return Assertions.assertShort(value); } | /**
* Asserts that there is a {@link Short} at the given index returning the
* {@link ShortAssert} object so that further assertions can be chained
*/ | Asserts that there is a <code>Short</code> at the given index returning the <code>ShortAssert</code> object so that further assertions can be chained | assertShort | {
"repo_name": "dhirajsb/fabric8",
"path": "components/jolokia-assertions/src/main/java/io/fabric8/jolokia/assertions/JSONArrayAssert.java",
"license": "apache-2.0",
"size": 6834
} | [
"org.assertj.core.api.ShortAssert"
] | import org.assertj.core.api.ShortAssert; | import org.assertj.core.api.*; | [
"org.assertj.core"
] | org.assertj.core; | 767,797 |
@ZapApiIgnore
public String[] getSecurityProtocolsEnabled() {
return Arrays.copyOf(securityProtocolsEnabled, securityProtocolsEnabled.length);
} | String[] function() { return Arrays.copyOf(securityProtocolsEnabled, securityProtocolsEnabled.length); } | /**
* Returns the security protocols enabled (SSL/TLS) for outgoing connections.
*
* @return the security protocols enabled for outgoing connections.
* @since 2.3.0
*/ | Returns the security protocols enabled (SSL/TLS) for outgoing connections | getSecurityProtocolsEnabled | {
"repo_name": "gmaran23/zaproxy",
"path": "zap/src/main/java/org/parosproxy/paros/network/ConnectionParam.java",
"license": "apache-2.0",
"size": 40611
} | [
"java.util.Arrays"
] | import java.util.Arrays; | import java.util.*; | [
"java.util"
] | java.util; | 1,345,247 |
public SVGAnimatedString getIn1() {
return in;
} | SVGAnimatedString function() { return in; } | /**
* <b>DOM</b>: Implements {@link
* SVGFEDisplacementMapElement#getIn1()}.
*/ | DOM: Implements <code>SVGFEDisplacementMapElement#getIn1()</code> | getIn1 | {
"repo_name": "Groostav/CMPT880-term-project",
"path": "intruder/benchs/batik/batik-1.7/sources/org/apache/batik/dom/svg/SVGOMFEDisplacementMapElement.java",
"license": "apache-2.0",
"size": 6084
} | [
"org.w3c.dom.svg.SVGAnimatedString"
] | import org.w3c.dom.svg.SVGAnimatedString; | import org.w3c.dom.svg.*; | [
"org.w3c.dom"
] | org.w3c.dom; | 1,772,056 |
@SuppressWarnings("rawtypes")
@Override
public Object getAdapter(Class key) {
if (key.equals(IContentOutlinePage.class)) {
return showOutlineView() ? getContentOutlinePage() : null;
}
else if (key.equals(IPropertySheetPage.class)) {
return getPropertySheetPage();
}
else if (key.equals(IGotoMarker.class)) {
return this;
}
else {
return super.getAdapter(key);
}
} | @SuppressWarnings(STR) Object function(Class key) { if (key.equals(IContentOutlinePage.class)) { return showOutlineView() ? getContentOutlinePage() : null; } else if (key.equals(IPropertySheetPage.class)) { return getPropertySheetPage(); } else if (key.equals(IGotoMarker.class)) { return this; } else { return super.getAdapter(key); } } | /**
* This is how the framework determines which interfaces we implement.
* <!-- begin-user-doc -->
* <!-- end-user-doc -->
* @generated
*/ | This is how the framework determines which interfaces we implement. | getAdapter | {
"repo_name": "KAMP-Research/KAMP",
"path": "bundles/Toometa/de.uka.ipd.sdq.dsexplore.qml.contracttype.editor/src/de/uka/ipd/sdq/dsexplore/qml/contracttype/presentation/QMLContractTypeEditor.java",
"license": "apache-2.0",
"size": 55387
} | [
"org.eclipse.ui.ide.IGotoMarker",
"org.eclipse.ui.views.contentoutline.IContentOutlinePage",
"org.eclipse.ui.views.properties.IPropertySheetPage"
] | import org.eclipse.ui.ide.IGotoMarker; import org.eclipse.ui.views.contentoutline.IContentOutlinePage; import org.eclipse.ui.views.properties.IPropertySheetPage; | import org.eclipse.ui.ide.*; import org.eclipse.ui.views.contentoutline.*; import org.eclipse.ui.views.properties.*; | [
"org.eclipse.ui"
] | org.eclipse.ui; | 2,757,979 |
@Override
public DcObject createItem() {
return new Loan();
} | DcObject function() { return new Loan(); } | /**
* Creates a new instance of a loan.
* @see Loan
*/ | Creates a new instance of a loan | createItem | {
"repo_name": "alexeq/datacrown",
"path": "datacrow-core/_source/net/datacrow/core/modules/LoanModule.java",
"license": "gpl-3.0",
"size": 7053
} | [
"net.datacrow.core.objects.DcObject",
"net.datacrow.core.objects.Loan"
] | import net.datacrow.core.objects.DcObject; import net.datacrow.core.objects.Loan; | import net.datacrow.core.objects.*; | [
"net.datacrow.core"
] | net.datacrow.core; | 2,856,616 |
Map<Long, ConfigGroup> getConfigGroups(); | Map<Long, ConfigGroup> getConfigGroups(); | /**
* Get config groups associated with this cluster
* @return unmodifiable map of config group id to config group. Will not return null.
*/ | Get config groups associated with this cluster | getConfigGroups | {
"repo_name": "sekikn/ambari",
"path": "ambari-server/src/main/java/org/apache/ambari/server/state/Cluster.java",
"license": "apache-2.0",
"size": 24252
} | [
"java.util.Map",
"org.apache.ambari.server.state.configgroup.ConfigGroup"
] | import java.util.Map; import org.apache.ambari.server.state.configgroup.ConfigGroup; | import java.util.*; import org.apache.ambari.server.state.configgroup.*; | [
"java.util",
"org.apache.ambari"
] | java.util; org.apache.ambari; | 860,444 |
void reinitialize(File f) {
if(contains(f)) {
// int row = getRow(f);
// get(row).initialize(f);
// fireTableRowsUpdated(row, row);
}
} | void reinitialize(File f) { if(contains(f)) { } } | /**
* Reinitializes a dataline that is using the given initialize object.
*/ | Reinitializes a dataline that is using the given initialize object | reinitialize | {
"repo_name": "titus08/frostwire-desktop",
"path": "src/com/frostwire/gui/library/LibraryInternetRadioTableModel.java",
"license": "gpl-3.0",
"size": 3564
} | [
"java.io.File"
] | import java.io.File; | import java.io.*; | [
"java.io"
] | java.io; | 2,845,011 |
public List<Function> getFunctions(TFunctionCategory category,
String dbName, String fnPattern, boolean exactMatch)
throws DatabaseNotFoundException {
RetryTracker retries = new RetryTracker(
String.format("fetching functions from %s", dbName));
while (true) {
try {
return doGetFunctions(category, dbName, fnPattern, exactMatch);
} catch(InconsistentMetadataFetchException e) {
retries.handleRetryOrThrow(e);
}
}
} | List<Function> function(TFunctionCategory category, String dbName, String fnPattern, boolean exactMatch) throws DatabaseNotFoundException { RetryTracker retries = new RetryTracker( String.format(STR, dbName)); while (true) { try { return doGetFunctions(category, dbName, fnPattern, exactMatch); } catch(InconsistentMetadataFetchException e) { retries.handleRetryOrThrow(e); } } } | /**
* Returns all function signatures that match the pattern. If pattern is null,
* matches all functions. If exactMatch is true, treats fnPattern as a function
* name instead of pattern and returns exact match only.
*/ | Returns all function signatures that match the pattern. If pattern is null, matches all functions. If exactMatch is true, treats fnPattern as a function name instead of pattern and returns exact match only | getFunctions | {
"repo_name": "cloudera/Impala",
"path": "fe/src/main/java/org/apache/impala/service/Frontend.java",
"license": "apache-2.0",
"size": 67467
} | [
"java.util.List",
"org.apache.impala.catalog.DatabaseNotFoundException",
"org.apache.impala.catalog.Function",
"org.apache.impala.catalog.local.InconsistentMetadataFetchException",
"org.apache.impala.thrift.TFunctionCategory"
] | import java.util.List; import org.apache.impala.catalog.DatabaseNotFoundException; import org.apache.impala.catalog.Function; import org.apache.impala.catalog.local.InconsistentMetadataFetchException; import org.apache.impala.thrift.TFunctionCategory; | import java.util.*; import org.apache.impala.catalog.*; import org.apache.impala.catalog.local.*; import org.apache.impala.thrift.*; | [
"java.util",
"org.apache.impala"
] | java.util; org.apache.impala; | 886,136 |
public static String[] getNodeAttributes( Node node ) {
NamedNodeMap nnm = node.getAttributes();
if ( nnm != null ) {
String[] attributes = new String[nnm.getLength()];
for ( int i = 0; i < nnm.getLength(); i++ ) {
Node attr = nnm.item( i );
attributes[i] = attr.getNodeName();
}
return attributes;
}
return null;
} | static String[] function( Node node ) { NamedNodeMap nnm = node.getAttributes(); if ( nnm != null ) { String[] attributes = new String[nnm.getLength()]; for ( int i = 0; i < nnm.getLength(); i++ ) { Node attr = nnm.item( i ); attributes[i] = attr.getNodeName(); } return attributes; } return null; } | /**
* Get all the attributes in a certain node (on the root level)
*
* @param node
* The node to examine
* @return an array of strings containing the names of the attributes.
*/ | Get all the attributes in a certain node (on the root level) | getNodeAttributes | {
"repo_name": "codek/pentaho-kettle",
"path": "core/src/org/pentaho/di/core/xml/XMLHandler.java",
"license": "apache-2.0",
"size": 37433
} | [
"org.w3c.dom.NamedNodeMap",
"org.w3c.dom.Node"
] | import org.w3c.dom.NamedNodeMap; import org.w3c.dom.Node; | import org.w3c.dom.*; | [
"org.w3c.dom"
] | org.w3c.dom; | 1,743,467 |
public String getMapperClassName() {
return getClass(
PAMapReduceFrameworkProperties
.getPropertyAsString(PAMapReduceFrameworkProperties.HADOOP_MAPPER_CLASS_PROPERTY_NAME
.getKey()), Mapper.class).getName();
} | String function() { return getClass( PAMapReduceFrameworkProperties .getPropertyAsString(PAMapReduceFrameworkProperties.HADOOP_MAPPER_CLASS_PROPERTY_NAME .getKey()), Mapper.class).getName(); } | /**
* Retrieve the {@link Mapper} class for the Hadoop job
*
* @return the {@link Mapper} class
*/ | Retrieve the <code>Mapper</code> class for the Hadoop job | getMapperClassName | {
"repo_name": "acontes/scheduling",
"path": "src/scheduler/src/org/ow2/proactive/scheduler/ext/mapreduce/PAHadoopJobConfiguration.java",
"license": "agpl-3.0",
"size": 16286
} | [
"org.apache.hadoop.mapreduce.Mapper"
] | import org.apache.hadoop.mapreduce.Mapper; | import org.apache.hadoop.mapreduce.*; | [
"org.apache.hadoop"
] | org.apache.hadoop; | 243,451 |
private void adjustTaxLotsUnits(BigDecimal totalTaxLotsUnits, BigDecimal transLineUnits, EndowmentTransactionTaxLotLine oldestTaxLot, boolean isSource) {
if (totalTaxLotsUnits.compareTo(transLineUnits) != 0 && oldestTaxLot != null) {
BigDecimal diff = transLineUnits.subtract(totalTaxLotsUnits);
if (isSource) {
oldestTaxLot.setLotUnits(oldestTaxLot.getLotUnits().add(diff.negate()));
}
else {
oldestTaxLot.setLotUnits(oldestTaxLot.getLotUnits().add(diff));
}
}
}
| void function(BigDecimal totalTaxLotsUnits, BigDecimal transLineUnits, EndowmentTransactionTaxLotLine oldestTaxLot, boolean isSource) { if (totalTaxLotsUnits.compareTo(transLineUnits) != 0 && oldestTaxLot != null) { BigDecimal diff = transLineUnits.subtract(totalTaxLotsUnits); if (isSource) { oldestTaxLot.setLotUnits(oldestTaxLot.getLotUnits().add(diff.negate())); } else { oldestTaxLot.setLotUnits(oldestTaxLot.getLotUnits().add(diff)); } } } | /**
* Adjusts the oldest tax lot units if the transaction line units do not match the total of the tax lot units.
*
* @param totalTaxLotsUnits
* @param transLineUnits
* @param oldestTaxLot
* @param isSource
*/ | Adjusts the oldest tax lot units if the transaction line units do not match the total of the tax lot units | adjustTaxLotsUnits | {
"repo_name": "ua-eas/ua-kfs-5.3",
"path": "work/src/org/kuali/kfs/module/endow/document/service/impl/UpdateUnitShareAdjustmentDocumentTaxLotsServiceImpl.java",
"license": "agpl-3.0",
"size": 8730
} | [
"java.math.BigDecimal",
"org.kuali.kfs.module.endow.businessobject.EndowmentTransactionTaxLotLine"
] | import java.math.BigDecimal; import org.kuali.kfs.module.endow.businessobject.EndowmentTransactionTaxLotLine; | import java.math.*; import org.kuali.kfs.module.endow.businessobject.*; | [
"java.math",
"org.kuali.kfs"
] | java.math; org.kuali.kfs; | 2,757,164 |
@Transactional
public Result saveManualAssessment(ModelingSubmission modelingSubmission, List<Feedback> modelingAssessment, ModelingExercise modelingExercise) {
Result result = modelingSubmission.getResult();
if (result == null) {
result = new Result();
}
// check the assessment due date if the user tries to override an existing submitted result
if (result.getCompletionDate() != null) {
checkAssessmentDueDate(modelingExercise);
}
checkGeneralFeedback(modelingAssessment);
result.setHasComplaint(false);
result.setExampleResult(modelingSubmission.isExampleSubmission());
result.setAssessmentType(AssessmentType.MANUAL);
User user = userService.getUser();
result.setAssessor(user);
result.setNewFeedback(modelingAssessment);
// Note: this boolean flag is only used for programming exercises
result.setHasFeedback(false);
if (result.getSubmission() == null) {
result.setSubmission(modelingSubmission);
modelingSubmission.setResult(result);
modelingSubmissionRepository.save(modelingSubmission);
}
// Note: This also saves the feedback objects in the database because of the 'cascade =
// CascadeType.ALL' option.
return resultRepository.save(result);
} | Result function(ModelingSubmission modelingSubmission, List<Feedback> modelingAssessment, ModelingExercise modelingExercise) { Result result = modelingSubmission.getResult(); if (result == null) { result = new Result(); } if (result.getCompletionDate() != null) { checkAssessmentDueDate(modelingExercise); } checkGeneralFeedback(modelingAssessment); result.setHasComplaint(false); result.setExampleResult(modelingSubmission.isExampleSubmission()); result.setAssessmentType(AssessmentType.MANUAL); User user = userService.getUser(); result.setAssessor(user); result.setNewFeedback(modelingAssessment); result.setHasFeedback(false); if (result.getSubmission() == null) { result.setSubmission(modelingSubmission); modelingSubmission.setResult(result); modelingSubmissionRepository.save(modelingSubmission); } return resultRepository.save(result); } | /**
* This function is used for saving a manual assessment/result. It sets the assessment type to MANUAL and sets the assessor attribute. Furthermore, it saves the result in the
* database.
*
* @param modelingSubmission the modeling submission to which the feedback belongs to
* @param modelingAssessment the assessment as a feedback list that should be added to the result of the corresponding submission
*/ | This function is used for saving a manual assessment/result. It sets the assessment type to MANUAL and sets the assessor attribute. Furthermore, it saves the result in the database | saveManualAssessment | {
"repo_name": "ls1intum/ArTEMiS",
"path": "src/main/java/de/tum/in/www1/artemis/service/ModelingAssessmentService.java",
"license": "mit",
"size": 6526
} | [
"de.tum.in.www1.artemis.domain.Feedback",
"de.tum.in.www1.artemis.domain.Result",
"de.tum.in.www1.artemis.domain.User",
"de.tum.in.www1.artemis.domain.enumeration.AssessmentType",
"de.tum.in.www1.artemis.domain.modeling.ModelingExercise",
"de.tum.in.www1.artemis.domain.modeling.ModelingSubmission",
"java.util.List"
] | import de.tum.in.www1.artemis.domain.Feedback; import de.tum.in.www1.artemis.domain.Result; import de.tum.in.www1.artemis.domain.User; import de.tum.in.www1.artemis.domain.enumeration.AssessmentType; import de.tum.in.www1.artemis.domain.modeling.ModelingExercise; import de.tum.in.www1.artemis.domain.modeling.ModelingSubmission; import java.util.List; | import de.tum.in.www1.artemis.domain.*; import de.tum.in.www1.artemis.domain.enumeration.*; import de.tum.in.www1.artemis.domain.modeling.*; import java.util.*; | [
"de.tum.in",
"java.util"
] | de.tum.in; java.util; | 1,703,461 |
public static Aspect.Builder all(Collection<Class<? extends Component>> types) {
return new Builder().all(types);
} | static Aspect.Builder function(Collection<Class<? extends Component>> types) { return new Builder().all(types); } | /**
* Returns an aspect where an entity must possess all of the specified
* component types.
*
* @param types
* a required component type
*
* @return an aspect that can be matched against entities
*/ | Returns an aspect where an entity must possess all of the specified component types | all | {
"repo_name": "snorrees/artemis-odb",
"path": "artemis/src/main/java/com/artemis/Aspect.java",
"license": "apache-2.0",
"size": 10707
} | [
"java.util.Collection"
] | import java.util.Collection; | import java.util.*; | [
"java.util"
] | java.util; | 2,677,845 |
public String replacement(String input) {
Matcher matcher = pattern.matcher(input);
if (matcher.matches()) {
StringBuilder sb = new StringBuilder();
boolean group = false;
for (int i = 0; i < rule.length(); i++) {
char ch = rule.charAt(i);
if (group) {
sb.append(matcher.group(Character.digit(ch, 10)));
group = false;
} else if (ch == '\\') {
group = true;
} else {
sb.append(ch);
}
}
return sb.toString();
} else {
return null;
}
}
} | String function(String input) { Matcher matcher = pattern.matcher(input); if (matcher.matches()) { StringBuilder sb = new StringBuilder(); boolean group = false; for (int i = 0; i < rule.length(); i++) { char ch = rule.charAt(i); if (group) { sb.append(matcher.group(Character.digit(ch, 10))); group = false; } else if (ch == '\\') { group = true; } else { sb.append(ch); } } return sb.toString(); } else { return null; } } } | /**
* Replace the input if it matches the pattern.
*
* @param input the input string.
* @return the replacement, if the input matches, otherwise null.
*/ | Replace the input if it matches the pattern | replacement | {
"repo_name": "agentlab/org.glassfish.jersey",
"path": "plugins/org.glassfish.jersey.common/src/main/java/org/glassfish/jersey/message/internal/NounInflector.java",
"license": "epl-1.0",
"size": 27261
} | [
"java.util.regex.Matcher"
] | import java.util.regex.Matcher; | import java.util.regex.*; | [
"java.util"
] | java.util; | 940,029 |
public boolean wasInsertedDuringTransaction(EntityPersister persister, Serializable id);
public static interface NaturalIdHelper {
public static final Serializable INVALID_NATURAL_ID_REFERENCE = new Serializable() {}; | boolean function(EntityPersister persister, Serializable id); public static interface NaturalIdHelper { public static final Serializable INVALID_NATURAL_ID_REFERENCE = new Serializable() {}; | /**
* Allows callers to check to see if the identified entity was inserted during the current transaction.
*
* @param persister The entity persister
* @param id The id
*
* @return True if inserted during this transaction, false otherwise.
*/ | Allows callers to check to see if the identified entity was inserted during the current transaction | wasInsertedDuringTransaction | {
"repo_name": "HerrB92/obp",
"path": "OpenBeaconPackage/libraries/hibernate-release-4.2.7.SP1/project/hibernate-core/src/main/java/org/hibernate/engine/spi/PersistenceContext.java",
"license": "mit",
"size": 29150
} | [
"java.io.Serializable",
"org.hibernate.persister.entity.EntityPersister"
] | import java.io.Serializable; import org.hibernate.persister.entity.EntityPersister; | import java.io.*; import org.hibernate.persister.entity.*; | [
"java.io",
"org.hibernate.persister"
] | java.io; org.hibernate.persister; | 2,835,838 |
public List<Concept> process(Query query) {
List<Facet> facets = query.getFacets();
if (facets != null) {
for (Facet facet : facets) {
facet.accept(visitor);
}
}
return null;
} | List<Concept> function(Query query) { List<Facet> facets = query.getFacets(); if (facets != null) { for (Facet facet : facets) { facet.accept(visitor); } } return null; } | /**
* Transforms a query into a list of concepts contained in the query
*
* @param query The query
* @return A list of concepts
*/ | Transforms a query into a list of concepts contained in the query | process | {
"repo_name": "mucke/mucke",
"path": "mucke-backend/src/main/java/at/tuwien/mucke/query/QueryManager.java",
"license": "gpl-3.0",
"size": 6006
} | [
"at.tuwien.mucke.concept.Concept",
"at.tuwien.mucke.documentmodel.Facet",
"java.util.List"
] | import at.tuwien.mucke.concept.Concept; import at.tuwien.mucke.documentmodel.Facet; import java.util.List; | import at.tuwien.mucke.concept.*; import at.tuwien.mucke.documentmodel.*; import java.util.*; | [
"at.tuwien.mucke",
"java.util"
] | at.tuwien.mucke; java.util; | 465,762 |
@GET("/hello")
@PermitAll
public Message helloPublic(String who) {
return new Message().setMessage(String.format(
"hello %s, it's %s",
who, DateTime.now().toString("HH:mm:ss")));
}
public static class MyPOJO {
@NotNull
String value;
public String getValue(){ return value; } | @GET(STR) Message function(String who) { return new Message().setMessage(String.format( STR, who, DateTime.now().toString(STR))); } public static class MyPOJO { String value; public String getValue(){ return value; } | /**
* Say hello to anybody.
*
* Does not require authentication.
*
* @return a Message to say hello
*/ | Say hello to anybody. Does not require authentication | helloPublic | {
"repo_name": "code-troopers/jenkins-workflow-demo-repo",
"path": "srv/src/main/java/com/codetroopers/demo/jenkins/rest/HelloResource.java",
"license": "mit",
"size": 1733
} | [
"com.codetroopers.demo.jenkins.domain.Message",
"org.joda.time.DateTime"
] | import com.codetroopers.demo.jenkins.domain.Message; import org.joda.time.DateTime; | import com.codetroopers.demo.jenkins.domain.*; import org.joda.time.*; | [
"com.codetroopers.demo",
"org.joda.time"
] | com.codetroopers.demo; org.joda.time; | 605,848 |
void doDataflowEdit(WorkflowBundle dataflow, Edit<?> edit)
throws EditException; | void doDataflowEdit(WorkflowBundle dataflow, Edit<?> edit) throws EditException; | /**
* Do an {@link Edit} affecting the given {@link WorkflowBundle}.
* <p>
* The edit is {@link Edit#doEdit() performed} and the edit can later be
* undone using {@link EditManager#undoDataflowEdit(WorkflowBundle)}.
* <p>
* Note that any events previously undone with
* {@link EditManager#undoDataflowEdit(WorkflowBundle)} for the given
* dataflow can no longer be
* {@link EditManager#redoDataflowEdit(WorkflowBundle) redone} after calling
* this method.
*
* @see EditManager#undoDataflowEdit(WorkflowBundle)
* @param dataflow
* {@link WorkflowBundle} this edit is affecting
* @param edit
* {@link Edit} that should be done using {@link Edit#doEdit()}.
* @throws EditException
* If {@link Edit#doEdit()} fails
*/ | Do an <code>Edit</code> affecting the given <code>WorkflowBundle</code>. The edit is <code>Edit#doEdit() performed</code> and the edit can later be undone using <code>EditManager#undoDataflowEdit(WorkflowBundle)</code>. Note that any events previously undone with <code>EditManager#undoDataflowEdit(WorkflowBundle)</code> for the given dataflow can no longer be <code>EditManager#redoDataflowEdit(WorkflowBundle) redone</code> after calling this method | doDataflowEdit | {
"repo_name": "ThilinaManamgoda/incubator-taverna-workbench",
"path": "taverna-edits-api/src/main/java/org/apache/taverna/workbench/edits/EditManager.java",
"license": "apache-2.0",
"size": 7802
} | [
"org.apache.taverna.scufl2.api.container.WorkflowBundle"
] | import org.apache.taverna.scufl2.api.container.WorkflowBundle; | import org.apache.taverna.scufl2.api.container.*; | [
"org.apache.taverna"
] | org.apache.taverna; | 1,614,416 |
public void viewDisplay(ImageDisplay node, boolean internal)
{
if (!(node instanceof ImageNode)) return;
EventBus bus = DataBrowserAgent.getRegistry().getEventBus();
DataObject data = null;
Object uo = node.getHierarchyObject();
Object go;
ViewImageObject object;
if (uo instanceof ImageData) {
if (model instanceof SearchModel || model instanceof AdvancedResultSearchModel) {
ImageData img = (ImageData) uo;
SecurityContext ctx = new SecurityContext(img.getGroupId());
object = new ViewImageObject(img);
go = view.getParentOfNodes();
if (go instanceof DataObject)
data = (DataObject) go;
object.setContext(data, null);
if (DataBrowserAgent.runAsPlugin() == LookupNames.IMAGE_J) {
ViewInPluginEvent evt = new ViewInPluginEvent(ctx,
img, LookupNames.IMAGE_J);
bus.post(evt);
} else {
bus.post(new LaunchViewer(ctx, object));
}
} else {
if (internal)
firePropertyChange(INTERNAL_VIEW_NODE_PROPERTY, null, uo);
else firePropertyChange(VIEW_IMAGE_NODE_PROPERTY, null, uo);
}
} else if (uo instanceof WellSampleData) {
WellSampleData wellSample = (WellSampleData) uo;
object = new ViewImageObject(wellSample);
WellSampleNode wsn = (WellSampleNode) node;
Object parent = wsn.getParentObject();
if (parent instanceof DataObject) {
go = view.getGrandParentOfNodes();
if (go instanceof DataObject)
data = (DataObject) go;
object.setContext((DataObject) parent, data);
}
if (DataBrowserAgent.runAsPlugin() == LookupNames.IMAGE_J) {
ViewInPluginEvent evt = new ViewInPluginEvent(
model.getSecurityContext(),
wellSample.getImage(), LookupNames.IMAGE_J);
bus.post(evt);
} else {
bus.post(new LaunchViewer(model.getSecurityContext(), object));
}
}
}
| void function(ImageDisplay node, boolean internal) { if (!(node instanceof ImageNode)) return; EventBus bus = DataBrowserAgent.getRegistry().getEventBus(); DataObject data = null; Object uo = node.getHierarchyObject(); Object go; ViewImageObject object; if (uo instanceof ImageData) { if (model instanceof SearchModel model instanceof AdvancedResultSearchModel) { ImageData img = (ImageData) uo; SecurityContext ctx = new SecurityContext(img.getGroupId()); object = new ViewImageObject(img); go = view.getParentOfNodes(); if (go instanceof DataObject) data = (DataObject) go; object.setContext(data, null); if (DataBrowserAgent.runAsPlugin() == LookupNames.IMAGE_J) { ViewInPluginEvent evt = new ViewInPluginEvent(ctx, img, LookupNames.IMAGE_J); bus.post(evt); } else { bus.post(new LaunchViewer(ctx, object)); } } else { if (internal) firePropertyChange(INTERNAL_VIEW_NODE_PROPERTY, null, uo); else firePropertyChange(VIEW_IMAGE_NODE_PROPERTY, null, uo); } } else if (uo instanceof WellSampleData) { WellSampleData wellSample = (WellSampleData) uo; object = new ViewImageObject(wellSample); WellSampleNode wsn = (WellSampleNode) node; Object parent = wsn.getParentObject(); if (parent instanceof DataObject) { go = view.getGrandParentOfNodes(); if (go instanceof DataObject) data = (DataObject) go; object.setContext((DataObject) parent, data); } if (DataBrowserAgent.runAsPlugin() == LookupNames.IMAGE_J) { ViewInPluginEvent evt = new ViewInPluginEvent( model.getSecurityContext(), wellSample.getImage(), LookupNames.IMAGE_J); bus.post(evt); } else { bus.post(new LaunchViewer(model.getSecurityContext(), object)); } } } | /**
* Implemented as specified by the {@link DataBrowser} interface.
* @see DataBrowser#viewDisplay(ImageDisplay, boolean)
*/ | Implemented as specified by the <code>DataBrowser</code> interface | viewDisplay | {
"repo_name": "knabar/openmicroscopy",
"path": "components/insight/SRC/org/openmicroscopy/shoola/agents/dataBrowser/view/DataBrowserComponent.java",
"license": "gpl-2.0",
"size": 57362
} | [
"org.openmicroscopy.shoola.agents.dataBrowser.DataBrowserAgent",
"org.openmicroscopy.shoola.agents.dataBrowser.browser.ImageDisplay",
"org.openmicroscopy.shoola.agents.dataBrowser.browser.ImageNode",
"org.openmicroscopy.shoola.agents.dataBrowser.browser.WellSampleNode",
"org.openmicroscopy.shoola.agents.events.hiviewer.LaunchViewer",
"org.openmicroscopy.shoola.agents.events.iviewer.ViewImageObject",
"org.openmicroscopy.shoola.env.LookupNames",
"org.openmicroscopy.shoola.env.data.events.ViewInPluginEvent",
"org.openmicroscopy.shoola.env.event.EventBus"
] | import org.openmicroscopy.shoola.agents.dataBrowser.DataBrowserAgent; import org.openmicroscopy.shoola.agents.dataBrowser.browser.ImageDisplay; import org.openmicroscopy.shoola.agents.dataBrowser.browser.ImageNode; import org.openmicroscopy.shoola.agents.dataBrowser.browser.WellSampleNode; import org.openmicroscopy.shoola.agents.events.hiviewer.LaunchViewer; import org.openmicroscopy.shoola.agents.events.iviewer.ViewImageObject; import org.openmicroscopy.shoola.env.LookupNames; import org.openmicroscopy.shoola.env.data.events.ViewInPluginEvent; import org.openmicroscopy.shoola.env.event.EventBus; | import org.openmicroscopy.shoola.agents.*; import org.openmicroscopy.shoola.agents.events.hiviewer.*; import org.openmicroscopy.shoola.agents.events.iviewer.*; import org.openmicroscopy.shoola.env.*; import org.openmicroscopy.shoola.env.data.events.*; import org.openmicroscopy.shoola.env.event.*; | [
"org.openmicroscopy.shoola"
] | org.openmicroscopy.shoola; | 684,145 |
private Result pDirectDeclarator$$Tail1(final int yyStart)
throws IOException {
Result yyResult;
int yyBase;
int yyOption1;
Node yyOpValue1;
Action<Node> yyValue;
ParseError yyError = ParseError.DUMMY;
// Alternative 1.
yyResult = pSymbol(yyStart);
if (yyResult.hasValue("(")) {
yyResult = pPushScope(yyResult.index);
yyError = yyResult.select(yyError);
if (yyResult.hasValue()) {
final int yyChoice1 = yyResult.index;
// Nested alternative 1.
yyResult = pParameterTypeList(yyChoice1);
yyError = yyResult.select(yyError);
if (yyResult.hasValue()) {
final Node v$g$2 = yyResult.semanticValue();
yyBase = yyResult.index;
yyResult = pSymbol(yyBase);
if (yyResult.hasValue(")")) {
yyResult = pParameterContext(yyResult.index);
yyError = yyResult.select(yyError);
if (yyResult.hasValue()) {
yyResult = pJavaThrows(yyResult.index);
yyError = yyResult.select(yyError);
if (yyResult.hasValue()) {
final Node javaThrows = yyResult.semanticValue(); | private Result pDirectDeclarator$$Tail1(final int yyStart) throws IOException { Result yyResult; int yyBase; int yyOption1; Node yyOpValue1; Action<Node> yyValue; ParseError yyError = ParseError.DUMMY; yyResult = pSymbol(yyStart); if (yyResult.hasValue("(")) { yyResult = pPushScope(yyResult.index); yyError = yyResult.select(yyError); if (yyResult.hasValue()) { final int yyChoice1 = yyResult.index; yyResult = pParameterTypeList(yyChoice1); yyError = yyResult.select(yyError); if (yyResult.hasValue()) { final Node v$g$2 = yyResult.semanticValue(); yyBase = yyResult.index; yyResult = pSymbol(yyBase); if (yyResult.hasValue(")")) { yyResult = pParameterContext(yyResult.index); yyError = yyResult.select(yyError); if (yyResult.hasValue()) { yyResult = pJavaThrows(yyResult.index); yyError = yyResult.select(yyError); if (yyResult.hasValue()) { final Node javaThrows = yyResult.semanticValue(); | /**
* Parse synthetic nonterminal
* xtc.lang.jeannie.Jeannie.DirectDeclarator$$Tail1.
*
* @param yyStart The index.
* @return The result.
* @throws IOException Signals an I/O error.
*/ | Parse synthetic nonterminal xtc.lang.jeannie.Jeannie.DirectDeclarator$$Tail1 | pDirectDeclarator$$Tail1 | {
"repo_name": "wandoulabs/xtc-rats",
"path": "xtc-core/src/main/java/xtc/lang/jeannie/JeannieParser.java",
"license": "lgpl-2.1",
"size": 647687
} | [
"java.io.IOException",
"xtc.parser.ParseError",
"xtc.parser.Result",
"xtc.tree.Node",
"xtc.util.Action"
] | import java.io.IOException; import xtc.parser.ParseError; import xtc.parser.Result; import xtc.tree.Node; import xtc.util.Action; | import java.io.*; import xtc.parser.*; import xtc.tree.*; import xtc.util.*; | [
"java.io",
"xtc.parser",
"xtc.tree",
"xtc.util"
] | java.io; xtc.parser; xtc.tree; xtc.util; | 2,001,435 |
public void tightMarshal2(OpenWireFormat wireFormat, Object o, DataOutput dataOut, BooleanStream bs) throws IOException {
super.tightMarshal2(wireFormat, o, dataOut, bs);
DataResponse info = (DataResponse)o;
tightMarshalNestedObject2(wireFormat, (DataStructure)info.getData(), dataOut, bs);
} | void function(OpenWireFormat wireFormat, Object o, DataOutput dataOut, BooleanStream bs) throws IOException { super.tightMarshal2(wireFormat, o, dataOut, bs); DataResponse info = (DataResponse)o; tightMarshalNestedObject2(wireFormat, (DataStructure)info.getData(), dataOut, bs); } | /**
* Write a object instance to data output stream
*
* @param o the instance to be marshaled
* @param dataOut the output stream
* @throws IOException thrown if an error occurs
*/ | Write a object instance to data output stream | tightMarshal2 | {
"repo_name": "Mark-Booth/daq-eclipse",
"path": "uk.ac.diamond.org.apache.activemq/org/apache/activemq/openwire/v1/DataResponseMarshaller.java",
"license": "epl-1.0",
"size": 4371
} | [
"java.io.DataOutput",
"java.io.IOException",
"org.apache.activemq.command.DataResponse",
"org.apache.activemq.command.DataStructure",
"org.apache.activemq.openwire.BooleanStream",
"org.apache.activemq.openwire.OpenWireFormat"
] | import java.io.DataOutput; import java.io.IOException; import org.apache.activemq.command.DataResponse; import org.apache.activemq.command.DataStructure; import org.apache.activemq.openwire.BooleanStream; import org.apache.activemq.openwire.OpenWireFormat; | import java.io.*; import org.apache.activemq.command.*; import org.apache.activemq.openwire.*; | [
"java.io",
"org.apache.activemq"
] | java.io; org.apache.activemq; | 1,539,610 |
public Feature[] getPeaks() {
return peaks.values().toArray(new Feature[0]);
}
| Feature[] function() { return peaks.values().toArray(new Feature[0]); } | /**
* Return peaks assigned to this row
*/ | Return peaks assigned to this row | getPeaks | {
"repo_name": "dyrlund/mzmine2",
"path": "src/main/java/net/sf/mzmine/datamodel/impl/SimplePeakListRow.java",
"license": "gpl-2.0",
"size": 8685
} | [
"net.sf.mzmine.datamodel.Feature"
] | import net.sf.mzmine.datamodel.Feature; | import net.sf.mzmine.datamodel.*; | [
"net.sf.mzmine"
] | net.sf.mzmine; | 1,895,610 |
public Map<String, String> getMetadataHeaders() {
return metadataHeaders;
} | Map<String, String> function() { return metadataHeaders; } | /**
* Request metadata headers
* @return mapping <HTTP header name, Metadata key name> for copying HTTP headers to Tile metadata
* @since 31125
*/ | Request metadata headers | getMetadataHeaders | {
"repo_name": "danyalzia/ShortestPath",
"path": "src/org/openstreetmap/gui/jmapviewer/tilesources/TileSourceInfo.java",
"license": "gpl-3.0",
"size": 4416
} | [
"java.util.Map"
] | import java.util.Map; | import java.util.*; | [
"java.util"
] | java.util; | 2,344,988 |
public static UserTransaction getUserTransaction() throws NamingException {
if (utx == null) {
Context ctx= (Context) new InitialContext();
String url = AppConstants.getInstance().getProperty(USERTRANSACTION_URL1_KEY,null);
log.debug("looking up UserTransaction ["+url+"] in context ["+ctx.toString()+"]");
try {
utx = (UserTransaction)ctx.lookup(url);
} catch (Exception e) {
log.debug("Could not lookup UserTransaction from url ["+url+"], will try alternative uri: "+e.getMessage());
url = AppConstants.getInstance().getProperty(USERTRANSACTION_URL2_KEY,null);
log.debug("looking up UserTransaction ["+url+"] in context ["+ctx.toString()+"]");
utx = (UserTransaction)ctx.lookup(url);
}
}
return utx;
}
| static UserTransaction function() throws NamingException { if (utx == null) { Context ctx= (Context) new InitialContext(); String url = AppConstants.getInstance().getProperty(USERTRANSACTION_URL1_KEY,null); log.debug(STR+url+STR+ctx.toString()+"]"); try { utx = (UserTransaction)ctx.lookup(url); } catch (Exception e) { log.debug(STR+url+STR+e.getMessage()); url = AppConstants.getInstance().getProperty(USERTRANSACTION_URL2_KEY,null); log.debug(STR+url+STR+ctx.toString()+"]"); utx = (UserTransaction)ctx.lookup(url); } } return utx; } | /**
* Returns a UserTransaction object, that is used by Receivers and PipeLines to demarcate transactions.
*/ | Returns a UserTransaction object, that is used by Receivers and PipeLines to demarcate transactions | getUserTransaction | {
"repo_name": "smhoekstra/iaf",
"path": "JavaSource/nl/nn/adapterframework/util/JtaUtil.java",
"license": "apache-2.0",
"size": 16518
} | [
"javax.naming.Context",
"javax.naming.InitialContext",
"javax.naming.NamingException",
"javax.transaction.UserTransaction"
] | import javax.naming.Context; import javax.naming.InitialContext; import javax.naming.NamingException; import javax.transaction.UserTransaction; | import javax.naming.*; import javax.transaction.*; | [
"javax.naming",
"javax.transaction"
] | javax.naming; javax.transaction; | 1,441,220 |
protected Object convertToString(Class type, Object value) {
if (value instanceof Date) {
DateFormat df = new SimpleDateFormat(DateUtil.getDatePattern());
if (value instanceof Timestamp) {
df = new SimpleDateFormat(DateUtil.getDateTimePattern());
}
try {
return df.format(value);
} catch (Exception e) {
e.printStackTrace();
throw new ConversionException("Error converting Date to String");
}
} else {
return value.toString();
}
} | Object function(Class type, Object value) { if (value instanceof Date) { DateFormat df = new SimpleDateFormat(DateUtil.getDatePattern()); if (value instanceof Timestamp) { df = new SimpleDateFormat(DateUtil.getDateTimePattern()); } try { return df.format(value); } catch (Exception e) { e.printStackTrace(); throw new ConversionException(STR); } } else { return value.toString(); } } | /**
* Convert a java.util.Date to a String
* @param type Date or Timestamp
* @param value value to convert
* @return Converted value for property population
*/ | Convert a java.util.Date to a String | convertToString | {
"repo_name": "kumaramit01/DIY",
"path": "core/src/main/java/org/imirsel/nema/util/DateConverter.java",
"license": "apache-2.0",
"size": 3206
} | [
"java.sql.Timestamp",
"java.text.DateFormat",
"java.text.SimpleDateFormat",
"java.util.Date",
"org.apache.commons.beanutils.ConversionException"
] | import java.sql.Timestamp; import java.text.DateFormat; import java.text.SimpleDateFormat; import java.util.Date; import org.apache.commons.beanutils.ConversionException; | import java.sql.*; import java.text.*; import java.util.*; import org.apache.commons.beanutils.*; | [
"java.sql",
"java.text",
"java.util",
"org.apache.commons"
] | java.sql; java.text; java.util; org.apache.commons; | 176,326 |
Observable<TopicSearchResult> searchInTopic(User user, Topic topic, long startFromPostId, String word, String author, boolean firstSearch); | Observable<TopicSearchResult> searchInTopic(User user, Topic topic, long startFromPostId, String word, String author, boolean firstSearch); | /**
* Searches a particular word and/or author in a topic, starting at a given post id.
*/ | Searches a particular word and/or author in a topic, starting at a given post id | searchInTopic | {
"repo_name": "Ayuget/Redface",
"path": "app/src/main/java/com/ayuget/redface/data/api/MDService.java",
"license": "apache-2.0",
"size": 5380
} | [
"com.ayuget.redface.data.api.model.Topic",
"com.ayuget.redface.data.api.model.TopicSearchResult",
"com.ayuget.redface.data.api.model.User"
] | import com.ayuget.redface.data.api.model.Topic; import com.ayuget.redface.data.api.model.TopicSearchResult; import com.ayuget.redface.data.api.model.User; | import com.ayuget.redface.data.api.model.*; | [
"com.ayuget.redface"
] | com.ayuget.redface; | 1,432,525 |
int opus_multistream_encode_float(PointerByReference st, FloatByReference pcm, int frame_size, Pointer data,
int max_data_bytes); | int opus_multistream_encode_float(PointerByReference st, FloatByReference pcm, int frame_size, Pointer data, int max_data_bytes); | /**
* Opus multistream encode float.
*
* @param st the st
* @param pcm the pcm
* @param frame_size the frame size
* @param data the data
* @param max_data_bytes the max data bytes
* @return the int
*/ | Opus multistream encode float | opus_multistream_encode_float | {
"repo_name": "lpatino10/android-sdk",
"path": "library/src/main/java/com/ibm/watson/developer_cloud/android/library/audio/opus/JNAOpus.java",
"license": "apache-2.0",
"size": 40064
} | [
"com.sun.jna.Pointer",
"com.sun.jna.ptr.FloatByReference",
"com.sun.jna.ptr.PointerByReference"
] | import com.sun.jna.Pointer; import com.sun.jna.ptr.FloatByReference; import com.sun.jna.ptr.PointerByReference; | import com.sun.jna.*; import com.sun.jna.ptr.*; | [
"com.sun.jna"
] | com.sun.jna; | 554,740 |
public void setMaxSize( int maxRows , int maxCols )
{
this.maxRows = maxRows; this.maxCols = maxCols;
Q = new DenseMatrix64F(maxRows,maxRows);
R = new DenseMatrix64F(maxRows,maxCols);
Y = new DenseMatrix64F(maxRows,1);
Z = new DenseMatrix64F(maxRows,1);
} | void function( int maxRows , int maxCols ) { this.maxRows = maxRows; this.maxCols = maxCols; Q = new DenseMatrix64F(maxRows,maxRows); R = new DenseMatrix64F(maxRows,maxCols); Y = new DenseMatrix64F(maxRows,1); Z = new DenseMatrix64F(maxRows,1); } | /**
* Changes the size of the matrix it can solve for
*
* @param maxRows Maximum number of rows in the matrix it will decompose.
* @param maxCols Maximum number of columns in the matrix it will decompose.
*/ | Changes the size of the matrix it can solve for | setMaxSize | {
"repo_name": "benralexander/efficient-java-matrix-library",
"path": "src/org/ejml/alg/dense/linsol/qr/LinearSolverQr.java",
"license": "apache-2.0",
"size": 4507
} | [
"org.ejml.data.DenseMatrix64F"
] | import org.ejml.data.DenseMatrix64F; | import org.ejml.data.*; | [
"org.ejml.data"
] | org.ejml.data; | 2,422,904 |
protected void onSelected() {
// Fire change
ValueChangeEvent.fire(this, value);
} | void function() { ValueChangeEvent.fire(this, value); } | /**
* Fire ValueChangeHandler classes attached to this object if there are any.
*
*/ | Fire ValueChangeHandler classes attached to this object if there are any | onSelected | {
"repo_name": "freemed/freemed",
"path": "ui/gwt/src/main/java/org/freemedsoftware/gwt/client/widget/AsyncPicklistWidgetBase.java",
"license": "gpl-2.0",
"size": 6939
} | [
"com.google.gwt.event.logical.shared.ValueChangeEvent"
] | import com.google.gwt.event.logical.shared.ValueChangeEvent; | import com.google.gwt.event.logical.shared.*; | [
"com.google.gwt"
] | com.google.gwt; | 1,791,881 |
public void setCancelDate(Date cancelDate) {
this.cancelDate = cancelDate;
} | void function(Date cancelDate) { this.cancelDate = cancelDate; } | /**
* Sets the cancelDate attribute value.
*
* @param cancelDate The cancelDate to set.
*/ | Sets the cancelDate attribute value | setCancelDate | {
"repo_name": "bhutchinson/kfs",
"path": "kfs-core/src/main/java/org/kuali/kfs/fp/document/DisbursementVoucherDocument.java",
"license": "agpl-3.0",
"size": 80760
} | [
"java.sql.Date"
] | import java.sql.Date; | import java.sql.*; | [
"java.sql"
] | java.sql; | 899,694 |
public K lastKey() {
if ( size == 0 ) throw new NoSuchElementException();
return key[ last ];
}
public Comparator <? super K> comparator() { return null; } | K function() { if ( size == 0 ) throw new NoSuchElementException(); return key[ last ]; } public Comparator <? super K> comparator() { return null; } | /** Returns the last key of this map in iteration order.
*
* @return the last key in iteration order.
*/ | Returns the last key of this map in iteration order | lastKey | {
"repo_name": "karussell/fastutil",
"path": "src/it/unimi/dsi/fastutil/objects/Object2IntLinkedOpenHashMap.java",
"license": "apache-2.0",
"size": 49106
} | [
"java.util.Comparator",
"java.util.NoSuchElementException"
] | import java.util.Comparator; import java.util.NoSuchElementException; | import java.util.*; | [
"java.util"
] | java.util; | 1,351,356 |
private void testCaseExecution() throws InterruptedException, RemoteException {
LOG.entering("ManInTheMiddle", "testCaseExecution()");
//Collection<MethodDescription> remainingMethods = schedule.methods();
//while (remainingMethods.size() > 0) {
while(true) {
MethodDescription md = tester.takeMethodDescription();
this.methodExecution(md);
this.waitForExecutionFinished();
//remainingMethods.remove(md);
}
//LOG.exiting("ManInTheMiddle", "testCaseExecution()");
} | void function() throws InterruptedException, RemoteException { LOG.entering(STR, STR); while(true) { MethodDescription md = tester.takeMethodDescription(); this.methodExecution(md); this.waitForExecutionFinished(); } } | /**
* Waits for execution messages from parent and dispatches to children.
*
* @throws InterruptedException
* @throws RemoteException
*/ | Waits for execution messages from parent and dispatches to children | testCaseExecution | {
"repo_name": "sunye/Macaw",
"path": "horda-coordinator/src/main/java/org/atlanmod/horda/coordinator/distributed/MiddleTester.java",
"license": "gpl-3.0",
"size": 10016
} | [
"java.rmi.RemoteException",
"org.atlanmod.commons.common.MethodDescription"
] | import java.rmi.RemoteException; import org.atlanmod.commons.common.MethodDescription; | import java.rmi.*; import org.atlanmod.commons.common.*; | [
"java.rmi",
"org.atlanmod.commons"
] | java.rmi; org.atlanmod.commons; | 482,896 |
public static void writeIteratorsToConf(Class<?> implementingClass, Configuration conf,
Collection<IteratorSetting> iterators) {
String confKey = enumToConfKey(implementingClass, ScanOpts.ITERATORS);
StringBuilder iterBuilder = new StringBuilder();
int count = 0;
for (IteratorSetting cfg : iterators) {
ByteArrayOutputStream baos = new ByteArrayOutputStream();
String newIter;
try {
cfg.write(new DataOutputStream(baos));
newIter = Base64.getEncoder().encodeToString(baos.toByteArray());
baos.close();
} catch (IOException e) {
throw new IllegalArgumentException("unable to serialize IteratorSetting");
}
if (count == 0) {
iterBuilder.append(newIter);
} else {
// append the next iterator & reset
iterBuilder.append(StringUtils.COMMA_STR + newIter);
}
count++;
}
// Store the iterators w/ the job
conf.set(confKey, iterBuilder.toString());
} | static void function(Class<?> implementingClass, Configuration conf, Collection<IteratorSetting> iterators) { String confKey = enumToConfKey(implementingClass, ScanOpts.ITERATORS); StringBuilder iterBuilder = new StringBuilder(); int count = 0; for (IteratorSetting cfg : iterators) { ByteArrayOutputStream baos = new ByteArrayOutputStream(); String newIter; try { cfg.write(new DataOutputStream(baos)); newIter = Base64.getEncoder().encodeToString(baos.toByteArray()); baos.close(); } catch (IOException e) { throw new IllegalArgumentException(STR); } if (count == 0) { iterBuilder.append(newIter); } else { iterBuilder.append(StringUtils.COMMA_STR + newIter); } count++; } conf.set(confKey, iterBuilder.toString()); } | /**
* Serialize the iterators to the hadoop configuration under one key.
*/ | Serialize the iterators to the hadoop configuration under one key | writeIteratorsToConf | {
"repo_name": "phrocker/accumulo-1",
"path": "hadoop-mapreduce/src/main/java/org/apache/accumulo/hadoopImpl/mapreduce/lib/InputConfigurator.java",
"license": "apache-2.0",
"size": 38769
} | [
"java.io.ByteArrayOutputStream",
"java.io.DataOutputStream",
"java.io.IOException",
"java.util.Base64",
"java.util.Collection",
"org.apache.accumulo.core.client.IteratorSetting",
"org.apache.hadoop.conf.Configuration",
"org.apache.hadoop.util.StringUtils"
] | import java.io.ByteArrayOutputStream; import java.io.DataOutputStream; import java.io.IOException; import java.util.Base64; import java.util.Collection; import org.apache.accumulo.core.client.IteratorSetting; import org.apache.hadoop.conf.Configuration; import org.apache.hadoop.util.StringUtils; | import java.io.*; import java.util.*; import org.apache.accumulo.core.client.*; import org.apache.hadoop.conf.*; import org.apache.hadoop.util.*; | [
"java.io",
"java.util",
"org.apache.accumulo",
"org.apache.hadoop"
] | java.io; java.util; org.apache.accumulo; org.apache.hadoop; | 2,396,535 |
public static String getString(Context context, String key) {
SharedPreferences mainPref =
context.getSharedPreferences(context.getResources()
.getString(R.string.shared_pref_package),
Context.MODE_PRIVATE
);
return mainPref.getString(key, null);
} | static String function(Context context, String key) { SharedPreferences mainPref = context.getSharedPreferences(context.getResources() .getString(R.string.shared_pref_package), Context.MODE_PRIVATE ); return mainPref.getString(key, null); } | /**
* Retrieve string data from shared preferences in private mode.
* @param context - The context of activity which is requesting to put data.
* @param key - Used to identify the value to to be retrieved.
*/ | Retrieve string data from shared preferences in private mode | getString | {
"repo_name": "laki88/product-mdm",
"path": "modules/mobile-agents/android/system-service/app/src/main/java/org/wso2/emm/system/service/utils/Preference.java",
"license": "apache-2.0",
"size": 5646
} | [
"android.content.Context",
"android.content.SharedPreferences"
] | import android.content.Context; import android.content.SharedPreferences; | import android.content.*; | [
"android.content"
] | android.content; | 1,655,310 |
@Nullable
public Teamwork patch(@Nonnull final Teamwork sourceTeamwork) throws ClientException {
return send(HttpMethod.PATCH, sourceTeamwork);
} | Teamwork function(@Nonnull final Teamwork sourceTeamwork) throws ClientException { return send(HttpMethod.PATCH, sourceTeamwork); } | /**
* Patches this Teamwork with a source
*
* @param sourceTeamwork the source object with updates
* @return the updated Teamwork
* @throws ClientException this exception occurs if the request was unable to complete for any reason
*/ | Patches this Teamwork with a source | patch | {
"repo_name": "microsoftgraph/msgraph-sdk-java",
"path": "src/main/java/com/microsoft/graph/requests/TeamworkRequest.java",
"license": "mit",
"size": 5705
} | [
"com.microsoft.graph.core.ClientException",
"com.microsoft.graph.http.HttpMethod",
"com.microsoft.graph.models.Teamwork",
"javax.annotation.Nonnull"
] | import com.microsoft.graph.core.ClientException; import com.microsoft.graph.http.HttpMethod; import com.microsoft.graph.models.Teamwork; import javax.annotation.Nonnull; | import com.microsoft.graph.core.*; import com.microsoft.graph.http.*; import com.microsoft.graph.models.*; import javax.annotation.*; | [
"com.microsoft.graph",
"javax.annotation"
] | com.microsoft.graph; javax.annotation; | 1,350,712 |
public OperatorGraph build(Class<? extends FlowDescription> flowClass) {
FlowDescription description = analyze(flowClass);
return driver.build(description);
} | OperatorGraph function(Class<? extends FlowDescription> flowClass) { FlowDescription description = analyze(flowClass); return driver.build(description); } | /**
* Builds an operator graph.
* @param flowClass the target flow-part class
* @return the built operator graph
*/ | Builds an operator graph | build | {
"repo_name": "akirakw/asakusafw-compiler",
"path": "compiler-project/analyzer/src/main/java/com/asakusafw/lang/compiler/analyzer/FlowPartBuilder.java",
"license": "apache-2.0",
"size": 9955
} | [
"com.asakusafw.lang.compiler.model.graph.OperatorGraph",
"com.asakusafw.vocabulary.flow.FlowDescription"
] | import com.asakusafw.lang.compiler.model.graph.OperatorGraph; import com.asakusafw.vocabulary.flow.FlowDescription; | import com.asakusafw.lang.compiler.model.graph.*; import com.asakusafw.vocabulary.flow.*; | [
"com.asakusafw.lang",
"com.asakusafw.vocabulary"
] | com.asakusafw.lang; com.asakusafw.vocabulary; | 438,004 |
public PointF getDrawablePointFromTouchPoint(PointF p) {
return transformCoordTouchToBitmap(p.x, p.y, true);
} | PointF function(PointF p) { return transformCoordTouchToBitmap(p.x, p.y, true); } | /**
* For a given point on the view (ie, a touch event), returns the
* point relative to the original drawable's coordinate system.
*
* @param p
* @return PointF relative to original drawable's coordinate system.
*/ | For a given point on the view (ie, a touch event), returns the point relative to the original drawable's coordinate system | getDrawablePointFromTouchPoint | {
"repo_name": "mirajp1/footprints-x4-android",
"path": "app/src/main/java/com/techo/fpx4/TouchImageView.java",
"license": "gpl-2.0",
"size": 31550
} | [
"android.graphics.PointF"
] | import android.graphics.PointF; | import android.graphics.*; | [
"android.graphics"
] | android.graphics; | 2,162,727 |
public UpdateResponse deleteById(String id, int commitWithinMs) throws SolrServerException, IOException {
UpdateRequest req = new UpdateRequest();
req.deleteById(id);
req.setCommitWithin(commitWithinMs);
return req.process(this);
} | UpdateResponse function(String id, int commitWithinMs) throws SolrServerException, IOException { UpdateRequest req = new UpdateRequest(); req.deleteById(id); req.setCommitWithin(commitWithinMs); return req.process(this); } | /**
* Deletes a single document by unique ID, specifying max time before commit
* @param id the ID of the document to delete
* @param commitWithinMs max time (in ms) before a commit will happen
* @throws SolrServerException
* @throws IOException
* @since 3.6
*/ | Deletes a single document by unique ID, specifying max time before commit | deleteById | {
"repo_name": "Lythimus/lptv",
"path": "apache-solr-3.6.0/solr/solrj/src/java/org/apache/solr/client/solrj/SolrServer.java",
"license": "gpl-2.0",
"size": 12363
} | [
"java.io.IOException",
"org.apache.solr.client.solrj.request.UpdateRequest",
"org.apache.solr.client.solrj.response.UpdateResponse"
] | import java.io.IOException; import org.apache.solr.client.solrj.request.UpdateRequest; import org.apache.solr.client.solrj.response.UpdateResponse; | import java.io.*; import org.apache.solr.client.solrj.request.*; import org.apache.solr.client.solrj.response.*; | [
"java.io",
"org.apache.solr"
] | java.io; org.apache.solr; | 698,035 |
public String munge( String str )
{
if ( str == null )
return Str.EMPTY;
str = Str.trimToNull(WHITESPACE_REGEX.matcher(str).replaceAll(" "));
if ( str == null )
return Str.EMPTY;
for ( Munger munger : mungers )
{
final String munged = munger.munge(str);
if ( munged != null )
return munged;
}
return str;
} | String function( String str ) { if ( str == null ) return Str.EMPTY; str = Str.trimToNull(WHITESPACE_REGEX.matcher(str).replaceAll(" ")); if ( str == null ) return Str.EMPTY; for ( Munger munger : mungers ) { final String munged = munger.munge(str); if ( munged != null ) return munged; } return str; } | /**
* Perform the substitution operation on the string.
*
* @param str
* String to perform the substitution on.
* @return The substituted string, or <code>str</code> trimmed of any leading
* and trailing white space if there was no substitution.
*/ | Perform the substitution operation on the string | munge | {
"repo_name": "evmcl/erudite",
"path": "src/main/java/com/evanmclean/erudite/config/TitleMunger.java",
"license": "apache-2.0",
"size": 6024
} | [
"com.evanmclean.evlib.lang.Str"
] | import com.evanmclean.evlib.lang.Str; | import com.evanmclean.evlib.lang.*; | [
"com.evanmclean.evlib"
] | com.evanmclean.evlib; | 53,606 |
private void initData(Context context) {
gestureDetector = new GestureDetector(context, gestureListener);
gestureDetector.setIsLongpressEnabled(false);
scroller = new Scroller(context);
} | void function(Context context) { gestureDetector = new GestureDetector(context, gestureListener); gestureDetector.setIsLongpressEnabled(false); scroller = new Scroller(context); } | /**
* Initializes class data
*
* @param context
* the context
*/ | Initializes class data | initData | {
"repo_name": "slowfall/tel",
"path": "TLEShine/src/com/tranway/Oband_Fitnessband/widget/WheelView.java",
"license": "apache-2.0",
"size": 25412
} | [
"android.content.Context",
"android.view.GestureDetector",
"android.widget.Scroller"
] | import android.content.Context; import android.view.GestureDetector; import android.widget.Scroller; | import android.content.*; import android.view.*; import android.widget.*; | [
"android.content",
"android.view",
"android.widget"
] | android.content; android.view; android.widget; | 1,718,186 |
@Override
public Application getApplicationById(int id) throws APIManagementException {
Application application = apiMgtDAO.getApplicationById(id);
if (application != null) {
Set<APIKey> keys = getApplicationKeys(application.getId());
for (APIKey key : keys) {
application.addKey(key);
}
}
return application;
} | Application function(int id) throws APIManagementException { Application application = apiMgtDAO.getApplicationById(id); if (application != null) { Set<APIKey> keys = getApplicationKeys(application.getId()); for (APIKey key : keys) { application.addKey(key); } } return application; } | /**
* Returns the corresponding application given the Id
* @param id Id of the Application
* @return it will return Application corresponds to the id.
* @throws APIManagementException
*/ | Returns the corresponding application given the Id | getApplicationById | {
"repo_name": "jaadds/carbon-apimgt",
"path": "components/apimgt/org.wso2.carbon.apimgt.impl/src/main/java/org/wso2/carbon/apimgt/impl/APIConsumerImpl.java",
"license": "apache-2.0",
"size": 317390
} | [
"java.util.Set",
"org.wso2.carbon.apimgt.api.APIManagementException",
"org.wso2.carbon.apimgt.api.model.APIKey",
"org.wso2.carbon.apimgt.api.model.Application"
] | import java.util.Set; import org.wso2.carbon.apimgt.api.APIManagementException; import org.wso2.carbon.apimgt.api.model.APIKey; import org.wso2.carbon.apimgt.api.model.Application; | import java.util.*; import org.wso2.carbon.apimgt.api.*; import org.wso2.carbon.apimgt.api.model.*; | [
"java.util",
"org.wso2.carbon"
] | java.util; org.wso2.carbon; | 945,007 |
@Override
protected JPanel createButtonPanel() {
JPanel panel = new JPanel(new FlowLayout(FlowLayout.LEFT, 5, 5));
JButton copyBtn = new JButton("Copy to clipboard");
copyBtn.addActionListener(e -> copyToClipboard());
panel.add(copyBtn);
JButton okBtn = new JButton("Done");
okBtn.addActionListener(e -> onOK());
panel.add(okBtn);
return panel;
} | JPanel function() { JPanel panel = new JPanel(new FlowLayout(FlowLayout.LEFT, 5, 5)); JButton copyBtn = new JButton(STR); copyBtn.addActionListener(e -> copyToClipboard()); panel.add(copyBtn); JButton okBtn = new JButton("Done"); okBtn.addActionListener(e -> onOK()); panel.add(okBtn); return panel; } | /**
* Creates the button panel with 'Done' and 'Copy to clipboard' buttons.
*
* @return the button panel
*/ | Creates the button panel with 'Done' and 'Copy to clipboard' buttons | createButtonPanel | {
"repo_name": "geotools/geotools",
"path": "modules/unsupported/swing/src/main/java/org/geotools/swing/dialog/JAboutDialog.java",
"license": "lgpl-2.1",
"size": 9108
} | [
"java.awt.FlowLayout",
"javax.swing.JButton",
"javax.swing.JPanel"
] | import java.awt.FlowLayout; import javax.swing.JButton; import javax.swing.JPanel; | import java.awt.*; import javax.swing.*; | [
"java.awt",
"javax.swing"
] | java.awt; javax.swing; | 535,204 |
@Test
public void testInLoGetPosition() throws IOException {
Repository<InductionLoop> inLoRepo = conn.getInductionLoopRepository();
InductionLoop loop = inLoRepo.getByID("e1_0");
assertEquals(30, loop.getPosition(), 0);
}
| void function() throws IOException { Repository<InductionLoop> inLoRepo = conn.getInductionLoopRepository(); InductionLoop loop = inLoRepo.getByID("e1_0"); assertEquals(30, loop.getPosition(), 0); } | /**
* Checks the get position method of an induction loop (E1).
*
* @throws IOException
*/ | Checks the get position method of an induction loop (E1) | testInLoGetPosition | {
"repo_name": "702nADOS/sumo",
"path": "tools/contributed/traci4j/test/java/it/polito/appeal/traci/test/TraCITest.java",
"license": "gpl-3.0",
"size": 32242
} | [
"it.polito.appeal.traci.InductionLoop",
"it.polito.appeal.traci.Repository",
"java.io.IOException",
"org.junit.Assert"
] | import it.polito.appeal.traci.InductionLoop; import it.polito.appeal.traci.Repository; import java.io.IOException; import org.junit.Assert; | import it.polito.appeal.traci.*; import java.io.*; import org.junit.*; | [
"it.polito.appeal",
"java.io",
"org.junit"
] | it.polito.appeal; java.io; org.junit; | 1,797,906 |
private static PBXObjectRef createPBXBuildFile(PBXObjectRef fileRef,
Map<String, Object> settings) {
Map<String, Object> map = new HashMap<String, Object>();
map.put("fileRef", fileRef);
map.put("isa", "PBXBuildFile");
if (settings != null) {
map.put("settings", settings);
}
return new PBXObjectRef(map);
} | static PBXObjectRef function(PBXObjectRef fileRef, Map<String, Object> settings) { Map<String, Object> map = new HashMap<String, Object>(); map.put(STR, fileRef); map.put("isa", STR); if (settings != null) { map.put(STR, settings); } return new PBXObjectRef(map); } | /**
* Create PBXBuildFile.
*
* @param fileRef source file.
* @param settings build settings.
* @return PBXBuildFile.
*/ | Create PBXBuildFile | createPBXBuildFile | {
"repo_name": "dougm/ant-contrib-cpptasks",
"path": "src/main/java/net/sf/antcontrib/cpptasks/apple/XcodeProjectWriter.java",
"license": "apache-2.0",
"size": 41651
} | [
"java.util.HashMap",
"java.util.Map"
] | import java.util.HashMap; import java.util.Map; | import java.util.*; | [
"java.util"
] | java.util; | 1,994,869 |
public String makeDisplayValue(MessageBroker messageBroker, Parameter parameter) {
Codes codes = getCodes();
if (isSingleValue()) {
String sValue = formatValue(parameter,getSingleValue().getValue());
sValue = codes.lookupDisplayValue(messageBroker,sValue);
return sValue;
} else {
StringBuffer sb = new StringBuffer();
String sDelimiter = ",";
for (ContentValue value: getMultipleValues()) {
String sValue = Val.chkStr(value.getValue());
sValue = codes.lookupDisplayValue(messageBroker,sValue);
if (sValue.length() > 0) {
if (sb.length() > 0) {
sb.append(sDelimiter).append(" ");
}
sb.append(sValue);
}
}
return sb.toString();
}
} | String function(MessageBroker messageBroker, Parameter parameter) { Codes codes = getCodes(); if (isSingleValue()) { String sValue = formatValue(parameter,getSingleValue().getValue()); sValue = codes.lookupDisplayValue(messageBroker,sValue); return sValue; } else { StringBuffer sb = new StringBuffer(); String sDelimiter = ","; for (ContentValue value: getMultipleValues()) { String sValue = Val.chkStr(value.getValue()); sValue = codes.lookupDisplayValue(messageBroker,sValue); if (sValue.length() > 0) { if (sb.length() > 0) { sb.append(sDelimiter).append(" "); } sb.append(sValue); } } return sb.toString(); } } | /**
* Makes the display value for a parameter.
* <p/>
* The output component is suitable for display on the
* metadata details page.
* @param messageBroker the message broker
* @param parameter the associated parameter
* @return the UI input component
*/ | Makes the display value for a parameter. The output component is suitable for display on the metadata details page | makeDisplayValue | {
"repo_name": "Esri/geoportal-server",
"path": "geoportal/src/com/esri/gpt/catalog/schema/Content.java",
"license": "apache-2.0",
"size": 24264
} | [
"com.esri.gpt.framework.jsf.MessageBroker",
"com.esri.gpt.framework.util.Val"
] | import com.esri.gpt.framework.jsf.MessageBroker; import com.esri.gpt.framework.util.Val; | import com.esri.gpt.framework.jsf.*; import com.esri.gpt.framework.util.*; | [
"com.esri.gpt"
] | com.esri.gpt; | 540,848 |
@SuppressWarnings("rawtypes")
public PurApItem getItemByLineNumber(int lineNumber) {
for (Iterator iter = items.iterator(); iter.hasNext(); ) {
PurApItem item = (PurApItem) iter.next();
if (item.getItemLineNumber().intValue() == lineNumber) {
return item;
}
}
return null;
} | @SuppressWarnings(STR) PurApItem function(int lineNumber) { for (Iterator iter = items.iterator(); iter.hasNext(); ) { PurApItem item = (PurApItem) iter.next(); if (item.getItemLineNumber().intValue() == lineNumber) { return item; } } return null; } | /**
* Iterates through the items of the document and returns the item with the line number equal to the number given, or null if a
* match is not found.
*
* @param lineNumber line number to match on.
* @return the PurchasingAp Item if a match is found, else null.
*/ | Iterates through the items of the document and returns the item with the line number equal to the number given, or null if a match is not found | getItemByLineNumber | {
"repo_name": "quikkian-ua-devops/will-financials",
"path": "kfs-purap/src/main/java/org/kuali/kfs/module/purap/document/PurchasingAccountsPayableDocumentBase.java",
"license": "agpl-3.0",
"size": 52309
} | [
"java.util.Iterator",
"org.kuali.kfs.module.purap.businessobject.PurApItem"
] | import java.util.Iterator; import org.kuali.kfs.module.purap.businessobject.PurApItem; | import java.util.*; import org.kuali.kfs.module.purap.businessobject.*; | [
"java.util",
"org.kuali.kfs"
] | java.util; org.kuali.kfs; | 19,083 |
public void invertExpense(int recordID) {
SelectBillDetails billDet = new SelectBillDetails();
billDet.SelectBillDetailsWithID("" + recordID);
//System.out.println(billDet.toString());
InsertIncome newInc = new InsertIncome(Integer.parseInt(billDet.getCID()),billDet.getPrice(),billDet.getDateOfPayment(),billDet.getComment());
} | void function(int recordID) { SelectBillDetails billDet = new SelectBillDetails(); billDet.SelectBillDetailsWithID("" + recordID); InsertIncome newInc = new InsertIncome(Integer.parseInt(billDet.getCID()),billDet.getPrice(),billDet.getDateOfPayment(),billDet.getComment()); } | /**
* This method will invert an expense record by creating the reverse income
* record
*/ | This method will invert an expense record by creating the reverse income record | invertExpense | {
"repo_name": "nickapos/myBill",
"path": "src/main/java/gr/oncrete/nick/mybill/BusinessLogic/InvertRecord.java",
"license": "gpl-3.0",
"size": 1816
} | [
"gr.oncrete.nick.mybill.BusinessLogic"
] | import gr.oncrete.nick.mybill.BusinessLogic; | import gr.oncrete.nick.mybill.*; | [
"gr.oncrete.nick"
] | gr.oncrete.nick; | 2,640,617 |
public static Map<Bytes, Set<Column>> toRCM(String... entries) {
Map<Bytes, Set<Column>> ret = new HashMap<>();
for (String entry : entries) {
String[] rcv = entry.split(",");
if (rcv.length != 2) {
throw new IllegalArgumentException(
"expected <row>,<col fam>:<col qual>[:col vis] but saw : " + entry);
}
Bytes row = Bytes.of(rcv[0]);
String[] colFields = rcv[1].split(":");
Column col;
if (colFields.length == 3) {
col = new Column(colFields[0], colFields[1], colFields[2]);
} else if (colFields.length == 2) {
col = new Column(colFields[0], colFields[1]);
} else {
throw new IllegalArgumentException(
"expected <row>,<col fam>:<col qual>[:col vis],<value> but saw : " + entry);
}
Set<Column> cols = ret.get(row);
if (cols == null) {
cols = new HashSet<>();
ret.put(row, cols);
}
cols.add(col);
}
return ret;
} | static Map<Bytes, Set<Column>> function(String... entries) { Map<Bytes, Set<Column>> ret = new HashMap<>(); for (String entry : entries) { String[] rcv = entry.split(","); if (rcv.length != 2) { throw new IllegalArgumentException( STR + entry); } Bytes row = Bytes.of(rcv[0]); String[] colFields = rcv[1].split(":"); Column col; if (colFields.length == 3) { col = new Column(colFields[0], colFields[1], colFields[2]); } else if (colFields.length == 2) { col = new Column(colFields[0], colFields[1]); } else { throw new IllegalArgumentException( STR + entry); } Set<Column> cols = ret.get(row); if (cols == null) { cols = new HashSet<>(); ret.put(row, cols); } cols.add(col); } return ret; } | /**
* toRCM stands for "To Row Column Map". This is a convenience function that takes strings of the
* format {@code <row>,<col fam>:<col qual>[:col vis]} and generates a row, column map.
*/ | toRCM stands for "To Row Column Map". This is a convenience function that takes strings of the format ,:[:col vis] and generates a row, column map | toRCM | {
"repo_name": "keith-turner/fluo-recipes",
"path": "modules/core/src/test/java/org/apache/fluo/recipes/core/types/MockSnapshotBase.java",
"license": "apache-2.0",
"size": 5440
} | [
"java.util.HashMap",
"java.util.HashSet",
"java.util.Map",
"java.util.Set",
"org.apache.fluo.api.data.Bytes",
"org.apache.fluo.api.data.Column"
] | import java.util.HashMap; import java.util.HashSet; import java.util.Map; import java.util.Set; import org.apache.fluo.api.data.Bytes; import org.apache.fluo.api.data.Column; | import java.util.*; import org.apache.fluo.api.data.*; | [
"java.util",
"org.apache.fluo"
] | java.util; org.apache.fluo; | 1,319,268 |
// TODO should probably be pulled up as a common API
public static String getHostPort(SocketAddress socketAddress) {
if (socketAddress == null) {
return ThriftConstants.UNKNOWN_ADDRESS;
}
if (socketAddress instanceof InetSocketAddress) {
InetSocketAddress addr = (InetSocketAddress)socketAddress;
return addr.getHostName() + ":" + addr.getPort();
}
return getSocketAddress(socketAddress);
}
| static String function(SocketAddress socketAddress) { if (socketAddress == null) { return ThriftConstants.UNKNOWN_ADDRESS; } if (socketAddress instanceof InetSocketAddress) { InetSocketAddress addr = (InetSocketAddress)socketAddress; return addr.getHostName() + ":" + addr.getPort(); } return getSocketAddress(socketAddress); } | /**
* Returns the hostname and port information retrieved from the given {@link SocketAddress}.
*
* @param inetSocketAddress the <tt>InetSocketAddress</tt> instance to retrieve the host/port information from
* @return the host/port retrieved from the given <tt>socketAddress</tt>,
* or {@literal ThriftConstants.UNKNOWN_ADDRESS} if it cannot be retrieved
*/ | Returns the hostname and port information retrieved from the given <code>SocketAddress</code> | getHostPort | {
"repo_name": "gspandy/pinpoint",
"path": "plugins/thrift/src/main/java/com/navercorp/pinpoint/plugin/thrift/ThriftUtils.java",
"license": "apache-2.0",
"size": 7206
} | [
"java.net.InetSocketAddress",
"java.net.SocketAddress"
] | import java.net.InetSocketAddress; import java.net.SocketAddress; | import java.net.*; | [
"java.net"
] | java.net; | 34,675 |
@Override
public int update(final Uri uri, final ContentValues values,
final String where, final String[] whereArgs) {
Helpers.validateSelection(where, sAppReadableColumnsSet);
SQLiteDatabase db = mOpenHelper.getWritableDatabase();
int count;
boolean startService = false;
if (values.containsKey(Downloads.Impl.COLUMN_DELETED)) {
if (values.getAsInteger(Downloads.Impl.COLUMN_DELETED) == 1) {
// some rows are to be 'deleted'. need to start DownloadService.
startService = true;
}
}
ContentValues filteredValues;
if (Binder.getCallingPid() != Process.myPid()) {
filteredValues = new ContentValues();
copyString(Downloads.Impl.COLUMN_APP_DATA, values, filteredValues);
copyInteger(Downloads.Impl.COLUMN_VISIBILITY, values, filteredValues);
Integer i = values.getAsInteger(Downloads.Impl.COLUMN_CONTROL);
if (i != null) {
filteredValues.put(Downloads.Impl.COLUMN_CONTROL, i);
startService = true;
}
copyInteger(Downloads.Impl.COLUMN_CONTROL, values, filteredValues);
copyString(Downloads.Impl.COLUMN_TITLE, values, filteredValues);
copyString(Downloads.Impl.COLUMN_MEDIAPROVIDER_URI, values, filteredValues);
copyString(Downloads.Impl.COLUMN_DESCRIPTION, values, filteredValues);
copyInteger(Downloads.Impl.COLUMN_DELETED, values, filteredValues);
} else {
filteredValues = values;
String filename = values.getAsString(Downloads.Impl._DATA);
if (filename != null) {
Cursor c = query(uri, new String[]
{ Downloads.Impl.COLUMN_TITLE }, null, null, null);
if (!c.moveToFirst() || c.getString(0).contentEquals("")) {
values.put(Downloads.Impl.COLUMN_TITLE, new File(filename).getName());
}
c.close();
}
Integer status = values.getAsInteger(Downloads.Impl.COLUMN_STATUS);
boolean isRestart = status != null && status == Downloads.Impl.STATUS_PENDING;
boolean isUserBypassingSizeLimit =
values.containsKey(Downloads.Impl.COLUMN_BYPASS_RECOMMENDED_SIZE_LIMIT);
if (isRestart || isUserBypassingSizeLimit) {
startService = true;
}
}
int match = sURIMatcher.match(uri);
switch (match) {
case MY_DOWNLOADS:
case MY_DOWNLOADS_ID:
case ALL_DOWNLOADS:
case ALL_DOWNLOADS_ID:
SqlSelection selection = getWhereClause(uri, where, whereArgs, match);
if (filteredValues.size() > 0) {
count = db.update(DB_TABLE, filteredValues, selection.getSelection(),
selection.getParameters());
} else {
count = 0;
}
break;
default:
Log.d(Constants.TAG, "updating unknown/invalid URI: " + uri);
throw new UnsupportedOperationException("Cannot update URI: " + uri);
}
notifyContentChanged(uri, match);
if (startService) {
Context context = getContext();
context.startService(new Intent(context, DownloadService.class));
}
return count;
}
/**
* Notify of a change through both URIs (/my_downloads and /all_downloads)
* @param uri either URI for the changed download(s)
* @param uriMatch the match ID from {@link #sURIMatcher} | int function(final Uri uri, final ContentValues values, final String where, final String[] whereArgs) { Helpers.validateSelection(where, sAppReadableColumnsSet); SQLiteDatabase db = mOpenHelper.getWritableDatabase(); int count; boolean startService = false; if (values.containsKey(Downloads.Impl.COLUMN_DELETED)) { if (values.getAsInteger(Downloads.Impl.COLUMN_DELETED) == 1) { startService = true; } } ContentValues filteredValues; if (Binder.getCallingPid() != Process.myPid()) { filteredValues = new ContentValues(); copyString(Downloads.Impl.COLUMN_APP_DATA, values, filteredValues); copyInteger(Downloads.Impl.COLUMN_VISIBILITY, values, filteredValues); Integer i = values.getAsInteger(Downloads.Impl.COLUMN_CONTROL); if (i != null) { filteredValues.put(Downloads.Impl.COLUMN_CONTROL, i); startService = true; } copyInteger(Downloads.Impl.COLUMN_CONTROL, values, filteredValues); copyString(Downloads.Impl.COLUMN_TITLE, values, filteredValues); copyString(Downloads.Impl.COLUMN_MEDIAPROVIDER_URI, values, filteredValues); copyString(Downloads.Impl.COLUMN_DESCRIPTION, values, filteredValues); copyInteger(Downloads.Impl.COLUMN_DELETED, values, filteredValues); } else { filteredValues = values; String filename = values.getAsString(Downloads.Impl._DATA); if (filename != null) { Cursor c = query(uri, new String[] { Downloads.Impl.COLUMN_TITLE }, null, null, null); if (!c.moveToFirst() c.getString(0).contentEquals(STRupdating unknown/invalid URI: STRCannot update URI: " + uri); } notifyContentChanged(uri, match); if (startService) { Context context = getContext(); context.startService(new Intent(context, DownloadService.class)); } return count; } /** * Notify of a change through both URIs (/my_downloads and /all_downloads) * @param uri either URI for the changed download(s) * @param uriMatch the match ID from {@link #sURIMatcher} | /**
* Updates a row in the database
*/ | Updates a row in the database | update | {
"repo_name": "msafin/wmc",
"path": "src/com/sharegogo/wireless/download/DownloadProvider.java",
"license": "gpl-2.0",
"size": 48644
} | [
"android.content.ContentValues",
"android.content.Context",
"android.content.Intent",
"android.database.Cursor",
"android.database.sqlite.SQLiteDatabase",
"android.net.Uri",
"android.os.Binder",
"android.os.Process"
] | import android.content.ContentValues; import android.content.Context; import android.content.Intent; import android.database.Cursor; import android.database.sqlite.SQLiteDatabase; import android.net.Uri; import android.os.Binder; import android.os.Process; | import android.content.*; import android.database.*; import android.database.sqlite.*; import android.net.*; import android.os.*; | [
"android.content",
"android.database",
"android.net",
"android.os"
] | android.content; android.database; android.net; android.os; | 2,061,463 |
ChronoLocalDate getMaximumLocalDate(); | ChronoLocalDate getMaximumLocalDate(); | /**
* Get the maximum value for the column.
* @return maximum value as a LocalDate
*/ | Get the maximum value for the column | getMaximumLocalDate | {
"repo_name": "omalley/orc",
"path": "java/core/src/java/org/apache/orc/DateColumnStatistics.java",
"license": "apache-2.0",
"size": 1884
} | [
"java.time.chrono.ChronoLocalDate"
] | import java.time.chrono.ChronoLocalDate; | import java.time.chrono.*; | [
"java.time"
] | java.time; | 1,847,580 |
@Schema(example = "ACME Corp.", description = "User's company")
public String getCompany() {
return company;
} | @Schema(example = STR, description = STR) String function() { return company; } | /**
* User's company
* @return company
**/ | User's company | getCompany | {
"repo_name": "iterate-ch/cyberduck",
"path": "brick/src/main/java/ch/cyberduck/core/brick/io/swagger/client/model/UsersBody.java",
"license": "gpl-3.0",
"size": 36113
} | [
"io.swagger.v3.oas.annotations.media.Schema"
] | import io.swagger.v3.oas.annotations.media.Schema; | import io.swagger.v3.oas.annotations.media.*; | [
"io.swagger.v3"
] | io.swagger.v3; | 976,705 |
public void setProperties(Properties props, boolean printProps) {
this.props = props;
StringBuilder sb = new StringBuilder(stringRep);
for (Enumeration e = props.propertyNames(); e.hasMoreElements();) {
String key = (String) e.nextElement();
String val = props.getProperty(key);
if (!(key.length() == 0 && val.length() == 0)) {
if (printProps) {
System.err.println(key + '=' + val);
}
sb.append(key).append('=').append(val).append('\n');
}
if (key.equalsIgnoreCase("macro")) {
if (Boolean.parseBoolean(val)) {
useObservedSequencesOnly = true;
readerAndWriter = "edu.stanford.nlp.sequences.CoNLLDocumentReaderAndWriter";
// useClassFeature = true;
// submit
useLongSequences = true;
useTaggySequences = true;
useNGrams = true;
usePrev = true;
useNext = true;
useTags = true;
useWordPairs = true;
useSequences = true;
usePrevSequences = true;
// noMidNGrams
noMidNGrams = true;
// reverse
useReverse = true;
// typeseqs3
useTypeSeqs = true;
useTypeSeqs2 = true;
useTypeySequences = true;
// wordtypes2 && known
wordShape = WordShapeClassifier.WORDSHAPEDAN2USELC;
// occurrence
useOccurrencePatterns = true;
// realword
useLastRealWord = true;
useNextRealWord = true;
// smooth
sigma = 3.0;
// normalize
normalize = true;
normalizeTimex = true;
}
} else if (key.equalsIgnoreCase("goodCoNLL")) {
if (Boolean.parseBoolean(val)) {
// featureFactory = "edu.stanford.nlp.ie.NERFeatureFactory";
readerAndWriter = "edu.stanford.nlp.sequences.CoNLLDocumentReaderAndWriter";
useObservedSequencesOnly = true;
// useClassFeature = true;
useLongSequences = true;
useTaggySequences = true;
useNGrams = true;
usePrev = true;
useNext = true;
useTags = true;
useWordPairs = true;
useSequences = true;
usePrevSequences = true;
// noMidNGrams
noMidNGrams = true;
// should this be set?? maxNGramLeng = 6; No (to get best score).
// reverse
useReverse = false;
// typeseqs3
useTypeSeqs = true;
useTypeSeqs2 = true;
useTypeySequences = true;
// wordtypes2 && known
wordShape = WordShapeClassifier.WORDSHAPEDAN2USELC;
// occurrence
useOccurrencePatterns = true;
// realword
useLastRealWord = true;
useNextRealWord = true;
// smooth
sigma = 50.0; // increased Aug 2006 from 20; helpful with less feats
// normalize
normalize = true;
normalizeTimex = true;
maxLeft = 2;
useDisjunctive = true;
disjunctionWidth = 4; // clearly optimal for CoNLL
useBoundarySequences = true;
useLemmas = true; // no-op except for German
usePrevNextLemmas = true; // no-op except for German
inputEncoding = "iso-8859-1"; // needed for CoNLL German files
// opt
useQN = true;
QNsize = 15;
}
} else if (key.equalsIgnoreCase("conllNoTags")) {
if (Boolean.parseBoolean(val)) {
readerAndWriter = "edu.stanford.nlp.sequences.ColumnDocumentReaderAndWriter";
// trainMap=testMap="word=0,answer=1";
map = "word=0,answer=1";
useObservedSequencesOnly = true;
// useClassFeature = true;
useLongSequences = true;
// useTaggySequences = true;
useNGrams = true;
usePrev = true;
useNext = true;
// useTags = true;
useWordPairs = true;
useSequences = true;
usePrevSequences = true;
// noMidNGrams
noMidNGrams = true;
// reverse
useReverse = false;
// typeseqs3
useTypeSeqs = true;
useTypeSeqs2 = true;
useTypeySequences = true;
// wordtypes2 && known
wordShape = WordShapeClassifier.WORDSHAPEDAN2USELC;
// occurrence
// useOccurrencePatterns = true;
// realword
useLastRealWord = true;
useNextRealWord = true;
// smooth
sigma = 20.0;
adaptSigma = 20.0;
// normalize
normalize = true;
normalizeTimex = true;
maxLeft = 2;
useDisjunctive = true;
disjunctionWidth = 4;
useBoundarySequences = true;
// useLemmas = true; // no-op except for German
// usePrevNextLemmas = true; // no-op except for German
inputEncoding = "iso-8859-1";
// opt
useQN = true;
QNsize = 15;
}
} else if (key.equalsIgnoreCase("notags")) {
if (Boolean.parseBoolean(val)) {
// turn off all features that use POS tags
// this is slightly crude: it also turns off a few things that
// don't use tags in e.g., useTaggySequences
useTags = false;
useSymTags = false;
useTaggySequences = false;
useOccurrencePatterns = false;
}
} else if (key.equalsIgnoreCase("submit")) {
if (Boolean.parseBoolean(val)) {
useLongSequences = true;
useTaggySequences = true;
useNGrams = true;
usePrev = true;
useNext = true;
useTags = true;
useWordPairs = true;
wordShape = WordShapeClassifier.WORDSHAPEDAN1;
useSequences = true;
usePrevSequences = true;
}
} else if (key.equalsIgnoreCase("binnedLengths")) {
if (val != null) {
String[] binnedLengthStrs = val.split("[, ]+");
binnedLengths = new int[binnedLengthStrs.length];
for (int i = 0; i < binnedLengths.length; i++) {
binnedLengths[i] = Integer.parseInt(binnedLengthStrs[i]);
}
}
} else if (key.equalsIgnoreCase("makeConsistent")) {
makeConsistent = Boolean.parseBoolean(val);
} else if (key.equalsIgnoreCase("dump")) {
dump = Boolean.parseBoolean(val);
} else if (key.equalsIgnoreCase("useNGrams")) {
useNGrams = Boolean.parseBoolean(val);
} else if (key.equalsIgnoreCase("useNeighborNGrams")) {
useNeighborNGrams = Boolean.parseBoolean(val);
} else if (key.equalsIgnoreCase("wordFunction")) {
wordFunction = ReflectionLoading.loadByReflection(val);
} else if (key.equalsIgnoreCase("conjoinShapeNGrams")) {
conjoinShapeNGrams = Boolean.parseBoolean(val);
} else if (key.equalsIgnoreCase("lowercaseNGrams")) {
lowercaseNGrams = Boolean.parseBoolean(val);
} else if (key.equalsIgnoreCase("useIsURL")) {
useIsURL = Boolean.parseBoolean(val);
} else if (key.equalsIgnoreCase("useURLSequences")) {
useURLSequences = Boolean.parseBoolean(val);
} else if (key.equalsIgnoreCase("useEntityTypes")) {
useEntityTypes = Boolean.parseBoolean(val);
} else if (key.equalsIgnoreCase("useEntityRule")) {
useEntityRule = Boolean.parseBoolean(val);
} else if (key.equalsIgnoreCase("useOrdinal")) {
useOrdinal = Boolean.parseBoolean(val);
} else if (key.equalsIgnoreCase("useEntityTypeSequences")) {
useEntityTypeSequences = Boolean.parseBoolean(val);
} else if (key.equalsIgnoreCase("useIsDateRange")) {
useIsDateRange = Boolean.parseBoolean(val);
} else if (key.equalsIgnoreCase("dehyphenateNGrams")) {
dehyphenateNGrams = Boolean.parseBoolean(val);
} else if (key.equalsIgnoreCase("lowerNewgeneThreshold")) {
lowerNewgeneThreshold = Boolean.parseBoolean(val);
} else if (key.equalsIgnoreCase("usePrev")) {
usePrev = Boolean.parseBoolean(val);
} else if (key.equalsIgnoreCase("useNext")) {
useNext = Boolean.parseBoolean(val);
} else if (key.equalsIgnoreCase("useTags")) {
useTags = Boolean.parseBoolean(val);
} else if (key.equalsIgnoreCase("useWordPairs")) {
useWordPairs = Boolean.parseBoolean(val);
} else if (key.equalsIgnoreCase("useGazettes")) {
useGazettes = Boolean.parseBoolean(val);
} else if (key.equalsIgnoreCase("wordShape")) {
wordShape = WordShapeClassifier.lookupShaper(val);
} else if (key.equalsIgnoreCase("useShapeStrings")) {
useShapeStrings = Boolean.parseBoolean(val);
} else if (key.equalsIgnoreCase("useGoodForNamesCpC")) {
useGoodForNamesCpC = Boolean.parseBoolean(val);
} else if (key.equalsIgnoreCase("useDictionaryConjunctions")) {
useDictionaryConjunctions = Boolean.parseBoolean(val);
} else if (key.equalsIgnoreCase("useDictionaryConjunctions3")) {
useDictionaryConjunctions3 = Boolean.parseBoolean(val);
} else if (key.equalsIgnoreCase("expandMidDot")) {
expandMidDot = Boolean.parseBoolean(val);
} else if (key.equalsIgnoreCase("useSequences")) {
useSequences = Boolean.parseBoolean(val);
} else if (key.equalsIgnoreCase("usePrevSequences")) {
usePrevSequences = Boolean.parseBoolean(val);
} else if (key.equalsIgnoreCase("useNextSequences")) {
useNextSequences = Boolean.parseBoolean(val);
} else if (key.equalsIgnoreCase("useLongSequences")) {
useLongSequences = Boolean.parseBoolean(val);
} else if (key.equalsIgnoreCase("useBoundarySequences")) {
useBoundarySequences = Boolean.parseBoolean(val);
} else if (key.equalsIgnoreCase("useTaggySequences")) {
useTaggySequences = Boolean.parseBoolean(val);
} else if (key.equalsIgnoreCase("useExtraTaggySequences")) {
useExtraTaggySequences = Boolean.parseBoolean(val);
} else if (key.equalsIgnoreCase("useTaggySequencesShapeInteraction")) {
useTaggySequencesShapeInteraction = Boolean.parseBoolean(val);
} else if (key.equalsIgnoreCase("strictlyZeroethOrder")) {
strictlyZeroethOrder = Boolean.parseBoolean(val);
} else if (key.equalsIgnoreCase("strictlyFirstOrder")) {
strictlyFirstOrder = Boolean.parseBoolean(val);
} else if (key.equalsIgnoreCase("strictlySecondOrder")) {
strictlySecondOrder = Boolean.parseBoolean(val);
} else if (key.equalsIgnoreCase("strictlyThirdOrder")) {
strictlyThirdOrder = Boolean.parseBoolean(val);
} else if (key.equalsIgnoreCase("dontExtendTaggy")) {
dontExtendTaggy = Boolean.parseBoolean(val);
} else if (key.equalsIgnoreCase("entitySubclassification")) {
entitySubclassification = val;
} else if (key.equalsIgnoreCase("useGazettePhrases")) {
useGazettePhrases = Boolean.parseBoolean(val);
} else if (key.equalsIgnoreCase("phraseGazettes")) {
StringTokenizer st = new StringTokenizer(val, " ,;\t");
if (phraseGazettes == null) {
phraseGazettes = new ArrayList<String>();
}
while (st.hasMoreTokens()) {
phraseGazettes.add(st.nextToken());
}
} else if (key.equalsIgnoreCase("useSum")) {
useSum = Boolean.parseBoolean(val);
} else if (key.equalsIgnoreCase("verboseMode")) {
verboseMode = Boolean.parseBoolean(val);
} else if (key.equalsIgnoreCase("tolerance")) {
tolerance = Double.parseDouble(val);
} else if (key.equalsIgnoreCase("maxIterations")) {
maxIterations = Integer.parseInt(val);
} else if (key.equalsIgnoreCase("exportFeatures")) {
exportFeatures = val;
} else if (key.equalsIgnoreCase("printFeatures")) {
printFeatures = val;
} else if (key.equalsIgnoreCase("printFeaturesUpto")) {
printFeaturesUpto = Integer.parseInt(val);
} else if (key.equalsIgnoreCase("lastNameList")) {
lastNameList = val;
} else if (key.equalsIgnoreCase("maleNameList")) {
maleNameList = val;
} else if (key.equalsIgnoreCase("femaleNameList")) {
femaleNameList = val;
} else if (key.equalsIgnoreCase("useSymTags")) {
useSymTags = Boolean.parseBoolean(val);
} else if (key.equalsIgnoreCase("useSymWordPairs")) {
useSymWordPairs = Boolean.parseBoolean(val);
} else if (key.equalsIgnoreCase("printClassifier")) {
printClassifier = val;
} else if (key.equalsIgnoreCase("printClassifierParam")) {
printClassifierParam = Integer.parseInt(val);
} else if (key.equalsIgnoreCase("intern")) {
intern = Boolean.parseBoolean(val);
} else if (key.equalsIgnoreCase("mergetags")) {
mergeTags = Boolean.parseBoolean(val);
} else if (key.equalsIgnoreCase("iobtags")) {
iobTags = Boolean.parseBoolean(val);
} else if (key.equalsIgnoreCase("useViterbi")) {
useViterbi = Boolean.parseBoolean(val);
} else if (key.equalsIgnoreCase("intern2")) {
intern2 = Boolean.parseBoolean(val);
} else if (key.equalsIgnoreCase("selfTest")) {
selfTest = Boolean.parseBoolean(val);
} else if (key.equalsIgnoreCase("sloppyGazette")) {
sloppyGazette = Boolean.parseBoolean(val);
} else if (key.equalsIgnoreCase("cleanGazette")) {
cleanGazette = Boolean.parseBoolean(val);
} else if (key.equalsIgnoreCase("noMidNGrams")) {
noMidNGrams = Boolean.parseBoolean(val);
} else if (key.equalsIgnoreCase("useReverse")) {
useReverse = Boolean.parseBoolean(val);
} else if (key.equalsIgnoreCase("retainEntitySubclassification")) {
retainEntitySubclassification = Boolean.parseBoolean(val);
} else if (key.equalsIgnoreCase("useLemmas")) {
useLemmas = Boolean.parseBoolean(val);
} else if (key.equalsIgnoreCase("usePrevNextLemmas")) {
usePrevNextLemmas = Boolean.parseBoolean(val);
} else if (key.equalsIgnoreCase("normalizeTerms")) {
normalizeTerms = Boolean.parseBoolean(val);
} else if (key.equalsIgnoreCase("normalizeTimex")) {
normalizeTimex = Boolean.parseBoolean(val);
} else if (key.equalsIgnoreCase("useNB")) {
useNB = Boolean.parseBoolean(val);
} else if (key.equalsIgnoreCase("useParenMatching")) {
useParenMatching = Boolean.parseBoolean(val);
} else if (key.equalsIgnoreCase("useTypeSeqs")) {
useTypeSeqs = Boolean.parseBoolean(val);
} else if (key.equalsIgnoreCase("useTypeSeqs2")) {
useTypeSeqs2 = Boolean.parseBoolean(val);
} else if (key.equalsIgnoreCase("useTypeSeqs3")) {
useTypeSeqs3 = Boolean.parseBoolean(val);
} else if (key.equalsIgnoreCase("useDisjunctive")) {
useDisjunctive = Boolean.parseBoolean(val);
} else if (key.equalsIgnoreCase("disjunctionWidth")) {
disjunctionWidth = Integer.parseInt(val);
} else if (key.equalsIgnoreCase("useDisjunctiveShapeInteraction")) {
useDisjunctiveShapeInteraction = Boolean.parseBoolean(val);
} else if (key.equalsIgnoreCase("useWideDisjunctive")) {
useWideDisjunctive = Boolean.parseBoolean(val);
} else if (key.equalsIgnoreCase("wideDisjunctionWidth")) {
wideDisjunctionWidth = Integer.parseInt(val);
} else if (key.equalsIgnoreCase("useDisjShape")) {
useDisjShape = Boolean.parseBoolean(val);
} else if (key.equalsIgnoreCase("useTitle")) {
useTitle = Boolean.parseBoolean(val);
} else if (key.equalsIgnoreCase("booleanFeatures")) {
booleanFeatures = Boolean.parseBoolean(val);
} else if (key.equalsIgnoreCase("useClassFeature")) {
useClassFeature = Boolean.parseBoolean(val);
} else if (key.equalsIgnoreCase("useShapeConjunctions")) {
useShapeConjunctions = Boolean.parseBoolean(val);
} else if (key.equalsIgnoreCase("useWordTag")) {
useWordTag = Boolean.parseBoolean(val);
} else if (key.equalsIgnoreCase("useNPHead")) {
useNPHead = Boolean.parseBoolean(val);
} else if (key.equalsIgnoreCase("useNPGovernor")) {
useNPGovernor = Boolean.parseBoolean(val);
} else if (key.equalsIgnoreCase("useHeadGov")) {
useHeadGov = Boolean.parseBoolean(val);
} else if (key.equalsIgnoreCase("useLastRealWord")) {
useLastRealWord = Boolean.parseBoolean(val);
} else if (key.equalsIgnoreCase("useNextRealWord")) {
useNextRealWord = Boolean.parseBoolean(val);
} else if (key.equalsIgnoreCase("useOccurrencePatterns")) {
useOccurrencePatterns = Boolean.parseBoolean(val);
} else if (key.equalsIgnoreCase("useTypeySequences")) {
useTypeySequences = Boolean.parseBoolean(val);
} else if (key.equalsIgnoreCase("justify")) {
justify = Boolean.parseBoolean(val);
} else if (key.equalsIgnoreCase("normalize")) {
normalize = Boolean.parseBoolean(val);
} else if (key.equalsIgnoreCase("priorType")) {
priorType = val;
} else if (key.equalsIgnoreCase("sigma")) {
sigma = Double.parseDouble(val);
} else if (key.equalsIgnoreCase("epsilon")) {
epsilon = Double.parseDouble(val);
} else if (key.equalsIgnoreCase("beamSize")) {
beamSize = Integer.parseInt(val);
} else if (key.equalsIgnoreCase("removeTopN")) {
removeTopN = Integer.parseInt(val);
} else if (key.equalsIgnoreCase("removeTopNPercent")) {
removeTopNPercent = Double.parseDouble(val);
} else if (key.equalsIgnoreCase("randomizedRatio")) {
randomizedRatio = Double.parseDouble(val);
} else if (key.equalsIgnoreCase("numTimesRemoveTopN")) {
numTimesRemoveTopN = Integer.parseInt(val);
} else if (key.equalsIgnoreCase("maxLeft")) {
maxLeft = Integer.parseInt(val);
} else if (key.equalsIgnoreCase("maxRight")) {
maxRight = Integer.parseInt(val);
} else if (key.equalsIgnoreCase("maxNGramLeng")) {
maxNGramLeng = Integer.parseInt(val);
} else if (key.equalsIgnoreCase("useGazFeatures")) {
useGazFeatures = Boolean.parseBoolean(val);
} else if (key.equalsIgnoreCase("useAltGazFeatures")) {
useAltGazFeatures = Boolean.parseBoolean(val);
} else if (key.equalsIgnoreCase("useMoreGazFeatures")) {
useMoreGazFeatures = Boolean.parseBoolean(val);
} else if (key.equalsIgnoreCase("useAbbr")) {
useAbbr = Boolean.parseBoolean(val);
} else if (key.equalsIgnoreCase("useMinimalAbbr")) {
useMinimalAbbr = Boolean.parseBoolean(val);
} else if (key.equalsIgnoreCase("useAbbr1")) {
useAbbr1 = Boolean.parseBoolean(val);
} else if (key.equalsIgnoreCase("useMinimalAbbr1")) {
useMinimalAbbr1 = Boolean.parseBoolean(val);
} else if (key.equalsIgnoreCase("documentReader")) {
System.err.println("You are using an outdated flag: -documentReader " + val);
System.err.println("Please use -readerAndWriter instead.");
} else if (key.equalsIgnoreCase("deleteBlankLines")) {
deleteBlankLines = Boolean.parseBoolean(val);
} else if (key.equalsIgnoreCase("answerFile")) {
answerFile = val;
} else if (key.equalsIgnoreCase("altAnswerFile")) {
altAnswerFile = val;
} else if (key.equalsIgnoreCase("loadClassifier")) {
loadClassifier = val;
} else if (key.equalsIgnoreCase("loadTextClassifier")) {
loadTextClassifier = val;
} else if (key.equalsIgnoreCase("loadJarClassifier")) {
loadJarClassifier = val;
} else if (key.equalsIgnoreCase("loadAuxClassifier")) {
loadAuxClassifier = val;
} else if (key.equalsIgnoreCase("serializeTo")) {
serializeTo = val;
} else if (key.equalsIgnoreCase("serializeToText")) {
serializeToText = val;
} else if (key.equalsIgnoreCase("serializeDatasetsDir")) {
serializeDatasetsDir = val;
} else if (key.equalsIgnoreCase("loadDatasetsDir")) {
loadDatasetsDir = val;
} else if (key.equalsIgnoreCase("pushDir")) {
pushDir = val;
} else if (key.equalsIgnoreCase("purgeDatasets")) {
purgeDatasets = Boolean.parseBoolean(val);
} else if (key.equalsIgnoreCase("keepOBInMemory")) {
keepOBInMemory = Boolean.parseBoolean(val);
} else if (key.equalsIgnoreCase("fakeDataset")) {
fakeDataset = Boolean.parseBoolean(val);
} else if (key.equalsIgnoreCase("numDatasetsPerFile")) {
numDatasetsPerFile = Integer.parseInt(val);
} else if (key.equalsIgnoreCase("trainFile")) {
trainFile = val;
} else if (key.equalsIgnoreCase("biasedTrainFile")) {
biasedTrainFile = val;
} else if (key.equalsIgnoreCase("classBias")) {
classBias = val;
} else if (key.equalsIgnoreCase("confusionMatrix")) {
confusionMatrix = val;
} else if (key.equalsIgnoreCase("adaptFile")) {
adaptFile = val;
} else if (key.equalsIgnoreCase("devFile")) {
devFile = val;
} else if (key.equalsIgnoreCase("testFile")) {
testFile = val;
} else if (key.equalsIgnoreCase("outputFile")) {
outputFile = val;
} else if (key.equalsIgnoreCase("textFile")) {
textFile = val;
} else if (key.equalsIgnoreCase("readStdin")) {
readStdin = Boolean.parseBoolean(val);
} else if (key.equalsIgnoreCase("initialWeights")) {
initialWeights = val;
} else if (key.equalsIgnoreCase("interimOutputFreq")) {
interimOutputFreq = Integer.parseInt(val);
} else if (key.equalsIgnoreCase("inputEncoding")) {
inputEncoding = val;
} else if (key.equalsIgnoreCase("outputEncoding")) {
outputEncoding = val;
} else if (key.equalsIgnoreCase("gazette")) {
useGazettes = true;
StringTokenizer st = new StringTokenizer(val, " ,;\t");
if (gazettes == null) {
gazettes = new ArrayList<String>();
} // for after deserialization, as gazettes is transient
while (st.hasMoreTokens()) {
gazettes.add(st.nextToken());
}
} else if (key.equalsIgnoreCase("useQN")) {
useQN = Boolean.parseBoolean(val);
} else if (key.equalsIgnoreCase("QNsize")) {
QNsize = Integer.parseInt(val);
} else if (key.equalsIgnoreCase("QNsize2")) {
QNsize2 = Integer.parseInt(val);
} else if (key.equalsIgnoreCase("l1reg")) {
useQN = false;
l1reg = Double.parseDouble(val);
} else if (key.equalsIgnoreCase("useFloat")) {
useFloat = Boolean.parseBoolean(val);
} else if (key.equalsIgnoreCase("trainMap")) {
System.err.println("trainMap and testMap are no longer valid options - please use map instead.");
throw new RuntimeException();
} else if (key.equalsIgnoreCase("testMap")) {
System.err.println("trainMap and testMap are no longer valid options - please use map instead.");
throw new RuntimeException();
} else if (key.equalsIgnoreCase("map")) {
map = val;
} else if (key.equalsIgnoreCase("useMoreAbbr")) {
useMoreAbbr = Boolean.parseBoolean(val);
} else if (key.equalsIgnoreCase("usePrevVB")) {
usePrevVB = Boolean.parseBoolean(val);
} else if (key.equalsIgnoreCase("useNextVB")) {
useNextVB = Boolean.parseBoolean(val);
} else if (key.equalsIgnoreCase("useVB")) {
if (Boolean.parseBoolean(val)) {
useVB = true;
usePrevVB = true;
useNextVB = true;
}
} else if (key.equalsIgnoreCase("useChunks")) {
useChunks = Boolean.parseBoolean(val);
} else if (key.equalsIgnoreCase("useChunkySequences")) {
useChunkySequences = Boolean.parseBoolean(val);
} else if (key.equalsIgnoreCase("greekifyNGrams")) {
greekifyNGrams = Boolean.parseBoolean(val);
} else if (key.equalsIgnoreCase("restrictTransitionsTimit")) {
restrictTransitionsTimit = Boolean.parseBoolean(val);
} else if (key.equalsIgnoreCase("useMoreTags")) {
useMoreTags = Boolean.parseBoolean(val);
} else if (key.equalsIgnoreCase("useBeginSent")) {
useBeginSent = Boolean.parseBoolean(val);
} else if (key.equalsIgnoreCase("usePosition")) {
usePosition = Boolean.parseBoolean(val);
} else if (key.equalsIgnoreCase("useGenia")) {
useGENIA = Boolean.parseBoolean(val);
} else if (key.equalsIgnoreCase("useAbstr")) {
useABSTR = Boolean.parseBoolean(val);
} else if (key.equalsIgnoreCase("useWeb")) {
useWEB = Boolean.parseBoolean(val);
} else if (key.equalsIgnoreCase("useAnte")) {
useANTE = Boolean.parseBoolean(val);
} else if (key.equalsIgnoreCase("useAcr")) {
useACR = Boolean.parseBoolean(val);
} else if (key.equalsIgnoreCase("useTok")) {
useTOK = Boolean.parseBoolean(val);
} else if (key.equalsIgnoreCase("useAbgene")) {
useABGENE = Boolean.parseBoolean(val);
} else if (key.equalsIgnoreCase("useAbstrFreqDict")) {
useABSTRFreqDict = Boolean.parseBoolean(val);
} else if (key.equalsIgnoreCase("useAbstrFreq")) {
useABSTRFreq = Boolean.parseBoolean(val);
} else if (key.equalsIgnoreCase("useFreq")) {
useFREQ = Boolean.parseBoolean(val);
} else if (key.equalsIgnoreCase("usewebfreqdict")) {
useWEBFreqDict = Boolean.parseBoolean(val);
} else if (key.equalsIgnoreCase("bioSubmitOutput")) {
bioSubmitOutput = Boolean.parseBoolean(val);
} else if (key.equalsIgnoreCase("subCWGaz")) {
subCWGaz = Boolean.parseBoolean(val);
} else if (key.equalsIgnoreCase("splitOnHead")) {
splitOnHead = Boolean.parseBoolean(val);
} else if (key.equalsIgnoreCase("featureCountThreshold")) {
featureCountThreshold = Integer.parseInt(val);
} else if (key.equalsIgnoreCase("useWord")) {
useWord = Boolean.parseBoolean(val);
} else if (key.equalsIgnoreCase("memoryThrift")) {
memoryThrift = Boolean.parseBoolean(val);
} else if (key.equalsIgnoreCase("timitDatum")) {
timitDatum = Boolean.parseBoolean(val);
} else if (key.equalsIgnoreCase("splitDocuments")) {
splitDocuments = Boolean.parseBoolean(val);
} else if (key.equalsIgnoreCase("featureWeightThreshold")) {
featureWeightThreshold = Double.parseDouble(val);
} else if (key.equalsIgnoreCase("backgroundSymbol")) {
backgroundSymbol = val;
} else if (key.equalsIgnoreCase("featureFactory")) {
featureFactory = val;
if (featureFactory.equalsIgnoreCase("SuperSimpleFeatureFactory")) {
featureFactory = "edu.stanford.nlp.sequences.SuperSimpleFeatureFactory";
} else if (featureFactory.equalsIgnoreCase("NERFeatureFactory")) {
featureFactory = "edu.stanford.nlp.ie.NERFeatureFactory";
} else if (featureFactory.equalsIgnoreCase("GazNERFeatureFactory")) {
featureFactory = "edu.stanford.nlp.sequences.GazNERFeatureFactory";
} else if (featureFactory.equalsIgnoreCase("IncludeAllFeatureFactory")) {
featureFactory = "edu.stanford.nlp.sequences.IncludeAllFeatureFactory";
} else if (featureFactory.equalsIgnoreCase("PhraseFeatureFactory")) {
featureFactory = "edu.stanford.nlp.article.extraction.PhraseFeatureFactory";
}
} else if (key.equalsIgnoreCase("printXML")) {
printXML = Boolean.parseBoolean(val); // todo: This appears unused now.
// Was it replaced by
// outputFormat?
} else if (key.equalsIgnoreCase("useSeenFeaturesOnly")) {
useSeenFeaturesOnly = Boolean.parseBoolean(val);
// chinese word-segmenter features
} else if (key.equalsIgnoreCase("useRadical")) {
useRadical = Boolean.parseBoolean(val);
} else if (key.equalsIgnoreCase("useBigramInTwoClique")) {
useBigramInTwoClique = Boolean.parseBoolean(val);
} else if (key.equalsIgnoreCase("useReverseAffix")) {
useReverseAffix = Boolean.parseBoolean(val);
} else if (key.equalsIgnoreCase("charHalfWindow")) {
charHalfWindow = Integer.parseInt(val);
} else if (key.equalsIgnoreCase("purgeFeatures")) {
purgeFeatures = Integer.parseInt(val);
} else if (key.equalsIgnoreCase("ocrFold")) {
ocrFold = Integer.parseInt(val);
} else if (key.equalsIgnoreCase("morphFeatureFile")) {
morphFeatureFile = val;
} else if (key.equalsIgnoreCase("svmModelFile")) {
svmModelFile = val;
} else if (key.equalsIgnoreCase("useDictleng")) {
useDictleng = Boolean.parseBoolean(val);
} else if (key.equalsIgnoreCase("useDict2")) {
useDict2 = Boolean.parseBoolean(val);
} else if (key.equalsIgnoreCase("useOutDict2")) {
useOutDict2 = Boolean.parseBoolean(val);
} else if (key.equalsIgnoreCase("outDict2")) {
outDict2 = val;
} else if (key.equalsIgnoreCase("useDictCTB2")) {
useDictCTB2 = Boolean.parseBoolean(val);
} else if (key.equalsIgnoreCase("useDictASBC2")) {
useDictASBC2 = Boolean.parseBoolean(val);
} else if (key.equalsIgnoreCase("useDictPK2")) {
useDictPK2 = Boolean.parseBoolean(val);
} else if (key.equalsIgnoreCase("useDictHK2")) {
useDictHK2 = Boolean.parseBoolean(val);
} else if (key.equalsIgnoreCase("useWord1")) {
useWord1 = Boolean.parseBoolean(val);
} else if (key.equalsIgnoreCase("useWord2")) {
useWord2 = Boolean.parseBoolean(val);
} else if (key.equalsIgnoreCase("useWord3")) {
useWord3 = Boolean.parseBoolean(val);
} else if (key.equalsIgnoreCase("useWord4")) {
useWord4 = Boolean.parseBoolean(val);
} else if (key.equalsIgnoreCase("useRad1")) {
useRad1 = Boolean.parseBoolean(val);
} else if (key.equalsIgnoreCase("useRad2")) {
useRad2 = Boolean.parseBoolean(val);
} else if (key.equalsIgnoreCase("useRad2b")) {
useRad2b = Boolean.parseBoolean(val);
} else if (key.equalsIgnoreCase("useWordn")) {
useWordn = Boolean.parseBoolean(val);
} else if (key.equalsIgnoreCase("useCTBPre1")) {
useCTBPre1 = Boolean.parseBoolean(val);
} else if (key.equalsIgnoreCase("useCTBSuf1")) {
useCTBSuf1 = Boolean.parseBoolean(val);
} else if (key.equalsIgnoreCase("useASBCPre1")) {
useASBCPre1 = Boolean.parseBoolean(val);
} else if (key.equalsIgnoreCase("useASBCSuf1")) {
useASBCSuf1 = Boolean.parseBoolean(val);
} else if (key.equalsIgnoreCase("useHKPre1")) {
useHKPre1 = Boolean.parseBoolean(val);
} else if (key.equalsIgnoreCase("useHKSuf1")) {
useHKSuf1 = Boolean.parseBoolean(val);
} else if (key.equalsIgnoreCase("usePKPre1")) {
usePKPre1 = Boolean.parseBoolean(val);
} else if (key.equalsIgnoreCase("usePKSuf1")) {
usePKSuf1 = Boolean.parseBoolean(val);
} else if (key.equalsIgnoreCase("useCTBChar2")) {
useCTBChar2 = Boolean.parseBoolean(val);
} else if (key.equalsIgnoreCase("usePrediction")) {
usePrediction = Boolean.parseBoolean(val);
} else if (key.equalsIgnoreCase("useASBCChar2")) {
useASBCChar2 = Boolean.parseBoolean(val);
} else if (key.equalsIgnoreCase("useHKChar2")) {
useHKChar2 = Boolean.parseBoolean(val);
} else if (key.equalsIgnoreCase("usePKChar2")) {
usePKChar2 = Boolean.parseBoolean(val);
} else if (key.equalsIgnoreCase("useRule2")) {
useRule2 = Boolean.parseBoolean(val);
} else if (key.equalsIgnoreCase("useBig5")) {
useBig5 = Boolean.parseBoolean(val);
} else if (key.equalsIgnoreCase("useNegDict2")) {
useNegDict2 = Boolean.parseBoolean(val);
} else if (key.equalsIgnoreCase("useNegDict3")) {
useNegDict3 = Boolean.parseBoolean(val);
} else if (key.equalsIgnoreCase("useNegDict4")) {
useNegDict4 = Boolean.parseBoolean(val);
} else if (key.equalsIgnoreCase("useNegCTBDict2")) {
useNegCTBDict2 = Boolean.parseBoolean(val);
} else if (key.equalsIgnoreCase("useNegCTBDict3")) {
useNegCTBDict3 = Boolean.parseBoolean(val);
} else if (key.equalsIgnoreCase("useNegCTBDict4")) {
useNegCTBDict4 = Boolean.parseBoolean(val);
} else if (key.equalsIgnoreCase("useNegASBCDict2")) {
useNegASBCDict2 = Boolean.parseBoolean(val);
} else if (key.equalsIgnoreCase("useNegASBCDict3")) {
useNegASBCDict3 = Boolean.parseBoolean(val);
} else if (key.equalsIgnoreCase("useNegASBCDict4")) {
useNegASBCDict4 = Boolean.parseBoolean(val);
} else if (key.equalsIgnoreCase("useNegPKDict2")) {
useNegPKDict2 = Boolean.parseBoolean(val);
} else if (key.equalsIgnoreCase("useNegPKDict3")) {
useNegPKDict3 = Boolean.parseBoolean(val);
} else if (key.equalsIgnoreCase("useNegPKDict4")) {
useNegPKDict4 = Boolean.parseBoolean(val);
} else if (key.equalsIgnoreCase("useNegHKDict2")) {
useNegHKDict2 = Boolean.parseBoolean(val);
} else if (key.equalsIgnoreCase("useNegHKDict3")) {
useNegHKDict3 = Boolean.parseBoolean(val);
} else if (key.equalsIgnoreCase("useNegHKDict4")) {
useNegHKDict4 = Boolean.parseBoolean(val);
} else if (key.equalsIgnoreCase("usePre")) {
usePre = Boolean.parseBoolean(val);
} else if (key.equalsIgnoreCase("useSuf")) {
useSuf = Boolean.parseBoolean(val);
} else if (key.equalsIgnoreCase("useRule")) {
useRule = Boolean.parseBoolean(val);
} else if (key.equalsIgnoreCase("useAs")) {
useAs = Boolean.parseBoolean(val);
} else if (key.equalsIgnoreCase("usePk")) {
usePk = Boolean.parseBoolean(val);
} else if (key.equalsIgnoreCase("useHk")) {
useHk = Boolean.parseBoolean(val);
} else if (key.equalsIgnoreCase("useMsr")) {
useMsr = Boolean.parseBoolean(val);
} else if (key.equalsIgnoreCase("useMSRChar2")) {
useMSRChar2 = Boolean.parseBoolean(val);
} else if (key.equalsIgnoreCase("useFeaturesC4gram")) {
useFeaturesC4gram = Boolean.parseBoolean(val);
} else if (key.equalsIgnoreCase("useFeaturesC5gram")) {
useFeaturesC5gram = Boolean.parseBoolean(val);
} else if (key.equalsIgnoreCase("useFeaturesC6gram")) {
useFeaturesC6gram = Boolean.parseBoolean(val);
} else if (key.equalsIgnoreCase("useFeaturesCpC4gram")) {
useFeaturesCpC4gram = Boolean.parseBoolean(val);
} else if (key.equalsIgnoreCase("useFeaturesCpC5gram")) {
useFeaturesCpC5gram = Boolean.parseBoolean(val);
} else if (key.equalsIgnoreCase("useFeaturesCpC6gram")) {
useFeaturesCpC6gram = Boolean.parseBoolean(val);
} else if (key.equalsIgnoreCase("useUnicodeType")) {
useUnicodeType = Boolean.parseBoolean(val);
} else if (key.equalsIgnoreCase("useUnicodeBlock")) {
useUnicodeBlock = Boolean.parseBoolean(val);
} else if (key.equalsIgnoreCase("useUnicodeType4gram")) {
useUnicodeType4gram = Boolean.parseBoolean(val);
} else if (key.equalsIgnoreCase("useUnicodeType5gram")) {
useUnicodeType5gram = Boolean.parseBoolean(val);
} else if (key.equalsIgnoreCase("useShapeStrings1")) {
useShapeStrings1 = Boolean.parseBoolean(val);
} else if (key.equalsIgnoreCase("useShapeStrings3")) {
useShapeStrings3 = Boolean.parseBoolean(val);
} else if (key.equalsIgnoreCase("useShapeStrings4")) {
useShapeStrings4 = Boolean.parseBoolean(val);
} else if (key.equalsIgnoreCase("useShapeStrings5")) {
useShapeStrings5 = Boolean.parseBoolean(val);
} else if (key.equalsIgnoreCase("useWordUTypeConjunctions2")) {
useWordUTypeConjunctions2 = Boolean.parseBoolean(val);
} else if (key.equalsIgnoreCase("useWordUTypeConjunctions3")) {
useWordUTypeConjunctions3 = Boolean.parseBoolean(val);
} else if (key.equalsIgnoreCase("useWordShapeConjunctions2")) {
useWordShapeConjunctions2 = Boolean.parseBoolean(val);
} else if (key.equalsIgnoreCase("useWordShapeConjunctions3")) {
useWordShapeConjunctions3 = Boolean.parseBoolean(val);
} else if (key.equalsIgnoreCase("useMidDotShape")) {
useMidDotShape = Boolean.parseBoolean(val);
} else if (key.equalsIgnoreCase("augmentedDateChars")) {
augmentedDateChars = Boolean.parseBoolean(val);
} else if (key.equalsIgnoreCase("suppressMidDotPostprocessing")) {
suppressMidDotPostprocessing = Boolean.parseBoolean(val);
} else if (key.equalsIgnoreCase("printNR")) {
printNR = Boolean.parseBoolean(val);
} else if (key.equalsIgnoreCase("use4Clique")) {
use4Clique = Boolean.parseBoolean(val);
} else if (key.equalsIgnoreCase("useFilter")) {
useFilter = Boolean.parseBoolean(val);
} else if (key.equalsIgnoreCase("largeChSegFile")) {
largeChSegFile = Boolean.parseBoolean(val);
} else if (key.equalsIgnoreCase("keepEnglishWhitespaces")) {
keepEnglishWhitespaces = Boolean.parseBoolean(val);
} else if (key.equalsIgnoreCase("keepAllWhitespaces")) {
keepAllWhitespaces = Boolean.parseBoolean(val);
} else if (key.equalsIgnoreCase("sighanPostProcessing")) {
sighanPostProcessing = Boolean.parseBoolean(val);
} else if (key.equalsIgnoreCase("useChPos")) {
useChPos = Boolean.parseBoolean(val);
} else if (key.equalsIgnoreCase("sighanCorporaDict")) {
sighanCorporaDict = val;
// end chinese word-segmenter features
} else if (key.equalsIgnoreCase("useObservedSequencesOnly")) {
useObservedSequencesOnly = Boolean.parseBoolean(val);
} else if (key.equalsIgnoreCase("maxDocSize")) {
maxDocSize = Integer.parseInt(val);
splitDocuments = true;
} else if (key.equalsIgnoreCase("printProbs")) {
printProbs = Boolean.parseBoolean(val);
} else if (key.equalsIgnoreCase("printFirstOrderProbs")) {
printFirstOrderProbs = Boolean.parseBoolean(val);
} else if (key.equalsIgnoreCase("saveFeatureIndexToDisk")) {
saveFeatureIndexToDisk = Boolean.parseBoolean(val);
} else if (key.equalsIgnoreCase("removeBackgroundSingletonFeatures")) {
removeBackgroundSingletonFeatures = Boolean.parseBoolean(val);
} else if (key.equalsIgnoreCase("doGibbs")) {
doGibbs = Boolean.parseBoolean(val);
} else if (key.equalsIgnoreCase("useNERPrior")) {
useNERPrior = Boolean.parseBoolean(val);
} else if (key.equalsIgnoreCase("useAcqPrior")) {
useAcqPrior = Boolean.parseBoolean(val);
} else if (key.equalsIgnoreCase("useSemPrior")) {
useSemPrior = Boolean.parseBoolean(val);
} else if (key.equalsIgnoreCase("useMUCFeatures")) {
useMUCFeatures = Boolean.parseBoolean(val);
} else if (key.equalsIgnoreCase("initViterbi")) {
initViterbi = Boolean.parseBoolean(val);
} else if (key.equalsIgnoreCase("checkNameList")) {
checkNameList = Boolean.parseBoolean(val);
} else if (key.equalsIgnoreCase("useFirstWord")) {
useFirstWord = Boolean.parseBoolean(val);
} else if (key.equalsIgnoreCase("useUnknown")) {
useUnknown = Boolean.parseBoolean(val);
} else if (key.equalsIgnoreCase("cacheNGrams")) {
cacheNGrams = Boolean.parseBoolean(val);
} else if (key.equalsIgnoreCase("useNumberFeature")) {
useNumberFeature = Boolean.parseBoolean(val);
} else if (key.equalsIgnoreCase("annealingRate")) {
annealingRate = Double.parseDouble(val);
} else if (key.equalsIgnoreCase("annealingType")) {
if (val.equalsIgnoreCase("linear") || val.equalsIgnoreCase("exp") || val.equalsIgnoreCase("exponential")) {
annealingType = val;
} else {
System.err.println("unknown annealingType: " + val + ". Please use linear|exp|exponential");
}
} else if (key.equalsIgnoreCase("numSamples")) {
numSamples = Integer.parseInt(val);
} else if (key.equalsIgnoreCase("inferenceType")) {
inferenceType = val;
} else if (key.equalsIgnoreCase("loadProcessedData")) {
loadProcessedData = val;
} else if (key.equalsIgnoreCase("normalizationTable")) {
normalizationTable = val;
} else if (key.equalsIgnoreCase("dictionary")) {
// don't set if empty string or spaces or true: revert it to null
// special case so can empty out dictionary list on command line!
val = val.trim();
if (val.length() > 0 && !"true".equals(val) && !"null".equals(val) && !"false".equals("val")) {
dictionary = val;
} else {
dictionary = null;
}
} else if (key.equalsIgnoreCase("serDictionary")) {
// don't set if empty string or spaces or true: revert it to null
// special case so can empty out dictionary list on command line!
val = val.trim();
if (val.length() > 0 && !"true".equals(val) && !"null".equals(val) && !"false".equals("val")) {
serializedDictionary = val;
} else {
serializedDictionary = null;
}
} else if (key.equalsIgnoreCase("dictionary2")) {
// don't set if empty string or spaces or true: revert it to null
// special case so can empty out dictionary list on command line!
val = val.trim();
if (val.length() > 0 && !"true".equals(val) && !"null".equals(val) && !"false".equals("val")) {
dictionary2 = val;
} else {
dictionary2 = null;
}
} else if (key.equalsIgnoreCase("normTableEncoding")) {
normTableEncoding = val;
} else if (key.equalsIgnoreCase("useLemmaAsWord")) {
useLemmaAsWord = Boolean.parseBoolean(val);
} else if (key.equalsIgnoreCase("type")) {
type = val;
} else if (key.equalsIgnoreCase("readerAndWriter")) {
readerAndWriter = val;
} else if (key.equalsIgnoreCase("plainTextDocumentReaderAndWriter")) {
plainTextDocumentReaderAndWriter = val;
} else if (key.equalsIgnoreCase("gazFilesFile")) {
gazFilesFile = val;
} else if (key.equalsIgnoreCase("baseTrainDir")) {
baseTrainDir = val;
} else if (key.equalsIgnoreCase("baseTestDir")) {
baseTestDir = val;
} else if (key.equalsIgnoreCase("trainFiles")) {
trainFiles = val;
} else if (key.equalsIgnoreCase("trainFileList")) {
trainFileList = val;
} else if (key.equalsIgnoreCase("trainDirs")) {
trainDirs = val;
} else if (key.equalsIgnoreCase("testDirs")) {
testDirs = val;
} else if (key.equalsIgnoreCase("testFiles")) {
testFiles = val;
} else if (key.equalsIgnoreCase("usePrediction2")) {
usePrediction2 = Boolean.parseBoolean(val);
} else if (key.equalsIgnoreCase("useObservedFeaturesOnly")) {
useObservedFeaturesOnly = Boolean.parseBoolean(val);
} else if (key.equalsIgnoreCase("iobWrapper")) {
iobWrapper = Boolean.parseBoolean(val);
} else if (key.equalsIgnoreCase("useDistSim")) {
useDistSim = Boolean.parseBoolean(val);
} else if (key.equalsIgnoreCase("casedDistSim")) {
casedDistSim = Boolean.parseBoolean(val);
} else if (key.equalsIgnoreCase("distSimFileFormat")) {
distSimFileFormat = val;
} else if (key.equalsIgnoreCase("distSimMaxBits")) {
distSimMaxBits = Integer.parseInt(val);
} else if (key.equalsIgnoreCase("numberEquivalenceDistSim")) {
numberEquivalenceDistSim = Boolean.parseBoolean(val);
} else if (key.equalsIgnoreCase("unknownWordDistSimClass")) {
unknownWordDistSimClass = val;
} else if (key.equalsIgnoreCase("useOnlySeenWeights")) {
useOnlySeenWeights = Boolean.parseBoolean(val);
} else if (key.equalsIgnoreCase("predProp")) {
predProp = val;
} else if (key.equalsIgnoreCase("distSimLexicon")) {
distSimLexicon = val;
} else if (key.equalsIgnoreCase("useSegmentation")) {
useSegmentation = Boolean.parseBoolean(val);
} else if (key.equalsIgnoreCase("useInternal")) {
useInternal = Boolean.parseBoolean(val);
} else if (key.equalsIgnoreCase("useExternal")) {
useExternal = Boolean.parseBoolean(val);
} else if (key.equalsIgnoreCase("useEitherSideWord")) {
useEitherSideWord = Boolean.parseBoolean(val);
} else if (key.equalsIgnoreCase("useEitherSideDisjunctive")) {
useEitherSideDisjunctive = Boolean.parseBoolean(val);
} else if (key.equalsIgnoreCase("featureDiffThresh")) {
featureDiffThresh = Double.parseDouble(val);
if (props.getProperty("numTimesPruneFeatures") == null) {
numTimesPruneFeatures = 1;
}
} else if (key.equalsIgnoreCase("numTimesPruneFeatures")) {
numTimesPruneFeatures = Integer.parseInt(val);
} else if (key.equalsIgnoreCase("newgeneThreshold")) {
newgeneThreshold = Double.parseDouble(val);
} else if (key.equalsIgnoreCase("adaptFile")) {
adaptFile = val;
} else if (key.equalsIgnoreCase("doAdaptation")) {
doAdaptation = Boolean.parseBoolean(val);
} else if (key.equalsIgnoreCase("selfTrainFile")) {
selfTrainFile = val;
} else if (key.equalsIgnoreCase("selfTrainIterations")) {
selfTrainIterations = Integer.parseInt(val);
} else if (key.equalsIgnoreCase("selfTrainWindowSize")) {
selfTrainWindowSize = Integer.parseInt(val);
} else if (key.equalsIgnoreCase("selfTrainConfidenceThreshold")) {
selfTrainConfidenceThreshold = Double.parseDouble(val);
} else if (key.equalsIgnoreCase("numFolds")) {
numFolds = Integer.parseInt(val);
} else if (key.equalsIgnoreCase("startFold")) {
startFold = Integer.parseInt(val);
} else if (key.equalsIgnoreCase("endFold")) {
endFold = Integer.parseInt(val);
} else if (key.equalsIgnoreCase("adaptSigma")) {
adaptSigma = Double.parseDouble(val);
} else if (key.startsWith("prop") && !key.equals("prop")) {
comboProps.add(val);
} else if (key.equalsIgnoreCase("outputFormat")) {
outputFormat = val;
} else if (key.equalsIgnoreCase("useSMD")) {
useSMD = Boolean.parseBoolean(val);
} else if (key.equalsIgnoreCase("useScaledSGD")) {
useScaledSGD = Boolean.parseBoolean(val);
} else if (key.equalsIgnoreCase("scaledSGDMethod")) {
scaledSGDMethod = Integer.parseInt(val);
} else if (key.equalsIgnoreCase("tuneSGD")) {
tuneSGD = Boolean.parseBoolean(val);
} else if (key.equalsIgnoreCase("StochasticCalculateMethod")) {
if (val.equalsIgnoreCase("AlgorithmicDifferentiation")) {
stochasticMethod = StochasticCalculateMethods.AlgorithmicDifferentiation;
} else if (val.equalsIgnoreCase("IncorporatedFiniteDifference")) {
stochasticMethod = StochasticCalculateMethods.IncorporatedFiniteDifference;
} else if (val.equalsIgnoreCase("ExternalFinitedifference")) {
stochasticMethod = StochasticCalculateMethods.ExternalFiniteDifference;
}
} else if (key.equalsIgnoreCase("initialGain")) {
initialGain = Double.parseDouble(val);
} else if (key.equalsIgnoreCase("stochasticBatchSize")) {
stochasticBatchSize = Integer.parseInt(val);
} else if (key.equalsIgnoreCase("SGD2QNhessSamples")) {
SGD2QNhessSamples = Integer.parseInt(val);
} else if (key.equalsIgnoreCase("useSGD")) {
useSGD = Boolean.parseBoolean(val);
} else if (key.equalsIgnoreCase("useInPlaceSGD")) {
useInPlaceSGD = Boolean.parseBoolean(val);
} else if (key.equalsIgnoreCase("useSGDtoQN")) {
useSGDtoQN = Boolean.parseBoolean(val);
} else if (key.equalsIgnoreCase("SGDPasses")) {
SGDPasses = Integer.parseInt(val);
} else if (key.equalsIgnoreCase("QNPasses")) {
QNPasses = Integer.parseInt(val);
} else if (key.equalsIgnoreCase("gainSGD")) {
gainSGD = Double.parseDouble(val);
} else if (key.equalsIgnoreCase("useHybrid")) {
useHybrid = Boolean.parseBoolean(val);
} else if (key.equalsIgnoreCase("hybridCutoffIteration")) {
hybridCutoffIteration = Integer.parseInt(val);
} else if (key.equalsIgnoreCase("useStochasticQN")) {
useStochasticQN = Boolean.parseBoolean(val);
} else if (key.equalsIgnoreCase("outputIterationsToFile")) {
outputIterationsToFile = Boolean.parseBoolean(val);
} else if (key.equalsIgnoreCase("testObjFunction")) {
testObjFunction = Boolean.parseBoolean(val);
} else if (key.equalsIgnoreCase("testVariance")) {
testVariance = Boolean.parseBoolean(val);
} else if (key.equalsIgnoreCase("CRForder")) {
CRForder = Integer.parseInt(val);
} else if (key.equalsIgnoreCase("CRFwindow")) {
CRFwindow = Integer.parseInt(val);
} else if (key.equalsIgnoreCase("testHessSamples")) {
testHessSamples = Boolean.parseBoolean(val);
} else if (key.equalsIgnoreCase("estimateInitial")) {
estimateInitial = Boolean.parseBoolean(val);
} else if (key.equalsIgnoreCase("printLabelValue")) {
printLabelValue = Boolean.parseBoolean(val);
} else if (key.equalsIgnoreCase("searchGraphPrefix")) {
searchGraphPrefix = val;
} else if (key.equalsIgnoreCase("searchGraphPrune")) {
searchGraphPrune = Double.parseDouble(val);
} else if (key.equalsIgnoreCase("kBest")) {
useKBest = true;
kBest = Integer.parseInt(val);
} else if (key.equalsIgnoreCase("useRobustQN")) {
useRobustQN = true;
} else if (key.equalsIgnoreCase("combo")) {
combo = Boolean.parseBoolean(val);
} else if (key.equalsIgnoreCase("verboseForTrueCasing")) {
verboseForTrueCasing = Boolean.parseBoolean(val);
} else if (key.equalsIgnoreCase("trainHierarchical")) {
trainHierarchical = val;
} else if (key.equalsIgnoreCase("domain")) {
domain = val;
} else if (key.equalsIgnoreCase("baseline")) {
baseline = Boolean.parseBoolean(val);
} else if (key.equalsIgnoreCase("doFE")) {
doFE = Boolean.parseBoolean(val);
} else if (key.equalsIgnoreCase("restrictLabels")) {
restrictLabels = Boolean.parseBoolean(val);
} else if (key.equalsIgnoreCase("transferSigmas")) {
transferSigmas = val;
} else if (key.equalsIgnoreCase("announceObjectBankEntries")) {
announceObjectBankEntries = true;
} else if (key.equalsIgnoreCase("usePos")) {
usePos = Boolean.parseBoolean(val);
} else if (key.equalsIgnoreCase("useAgreement")) {
useAgreement = Boolean.parseBoolean(val);
} else if (key.equalsIgnoreCase("useAccCase")) {
useAccCase = Boolean.parseBoolean(val);
} else if (key.equalsIgnoreCase("useInna")) {
useInna = Boolean.parseBoolean(val);
} else if (key.equalsIgnoreCase("useConcord")) {
useConcord = Boolean.parseBoolean(val);
} else if (key.equalsIgnoreCase("useFirstNgram")) {
useFirstNgram = Boolean.parseBoolean(val);
} else if (key.equalsIgnoreCase("useLastNgram")) {
useLastNgram = Boolean.parseBoolean(val);
} else if (key.equalsIgnoreCase("collapseNN")) {
collapseNN = Boolean.parseBoolean(val);
} else if (key.equalsIgnoreCase("useTagsCpC")) {
useTagsCpC = Boolean.parseBoolean(val);
} else if (key.equalsIgnoreCase("useTagsCpCp2C")) {
useTagsCpCp2C = Boolean.parseBoolean(val);
} else if (key.equalsIgnoreCase("useTagsCpCp2Cp3C")) {
useTagsCpCp2Cp3C = Boolean.parseBoolean(val);
} else if (key.equalsIgnoreCase("useTagsCpCp2Cp3Cp4C")) {
useTagsCpCp2Cp3Cp4C = Boolean.parseBoolean(val);
} else if (key.equalsIgnoreCase("numTags")) {
numTags = Integer.parseInt(val);
} else if (key.equalsIgnoreCase("useConjBreak")) {
useConjBreak = Boolean.parseBoolean(val);
} else if (key.equalsIgnoreCase("useAuxPairs")) {
useAuxPairs = Boolean.parseBoolean(val);
} else if (key.equalsIgnoreCase("usePPVBPairs")) {
usePPVBPairs = Boolean.parseBoolean(val);
} else if (key.equalsIgnoreCase("useAnnexing")) {
useAnnexing = Boolean.parseBoolean(val);
} else if (key.equalsIgnoreCase("useTemporalNN")) {
useTemporalNN = Boolean.parseBoolean(val);
} else if (key.equalsIgnoreCase("markProperNN")) {
markProperNN = Boolean.parseBoolean(val);
} else if (key.equalsIgnoreCase("usePath")) {
usePath = Boolean.parseBoolean(val);
} else if (key.equalsIgnoreCase("markMasdar")) {
markMasdar = Boolean.parseBoolean(val);
} else if (key.equalsIgnoreCase("innaPPAttach")) {
innaPPAttach = Boolean.parseBoolean(val);
} else if (key.equalsIgnoreCase("useSVO")) {
useSVO = Boolean.parseBoolean(val);
} else if (key.equalsIgnoreCase("mixedCaseMapFile")) {
mixedCaseMapFile = val;
} else if (key.equalsIgnoreCase("auxTrueCaseModels")) {
auxTrueCaseModels = val;
} else if (key.equalsIgnoreCase("use2W")) {
use2W = Boolean.parseBoolean(val);
} else if (key.equalsIgnoreCase("useLC")) {
useLC = Boolean.parseBoolean(val);
} else if (key.equalsIgnoreCase("useYetMoreCpCShapes")) {
useYetMoreCpCShapes = Boolean.parseBoolean(val);
} else if (key.equalsIgnoreCase("useIfInteger")) {
useIfInteger = Boolean.parseBoolean(val);
} else if (key.equalsIgnoreCase("twoStage")) {
twoStage = Boolean.parseBoolean(val);
} else if (key.equalsIgnoreCase("evaluateIters")) {
evaluateIters = Integer.parseInt(val);
} else if (key.equalsIgnoreCase("evalCmd")) {
evalCmd = val;
} else if (key.equalsIgnoreCase("evaluateTrain")) {
evaluateTrain = Boolean.parseBoolean(val);
} else if (key.equalsIgnoreCase("evaluateIOB")) {
evaluateIOB = Boolean.parseBoolean(val);
} else if (key.equalsIgnoreCase("tuneSampleSize")) {
tuneSampleSize = Integer.parseInt(val);
} else if (key.equalsIgnoreCase("useTopics")) {
useTopics = Boolean.parseBoolean(val);
} else if (key.equalsIgnoreCase("usePhraseFeatures")) {
usePhraseFeatures = Boolean.parseBoolean(val);
} else if (key.equalsIgnoreCase("usePhraseWords")) {
usePhraseWords = Boolean.parseBoolean(val);
} else if (key.equalsIgnoreCase("usePhraseWordTags")) {
usePhraseWordTags = Boolean.parseBoolean(val);
} else if (key.equalsIgnoreCase("usePhraseWordSpecialTags")) {
usePhraseWordSpecialTags = Boolean.parseBoolean(val);
} else if (key.equalsIgnoreCase("useProtoFeatures")) {
useProtoFeatures = Boolean.parseBoolean(val);
} else if (key.equalsIgnoreCase("useWordnetFeatures")) {
useWordnetFeatures = Boolean.parseBoolean(val);
} else if (key.equalsIgnoreCase("wikiFeatureDbFile")) {
wikiFeatureDbFile = val;
} else if (key.equalsIgnoreCase("tokenizerOptions")) {
tokenizerOptions = val;
} else if (key.equalsIgnoreCase("useCommonWordsFeature")) {
useCommonWordsFeature = Boolean.parseBoolean(val);
} else if (key.equalsIgnoreCase("useYear")) {
useYear = Boolean.parseBoolean(val);
} else if (key.equalsIgnoreCase("useSentenceNumber")) {
useSentenceNumber = Boolean.parseBoolean(val);
} else if (key.equalsIgnoreCase("useLabelSource")) {
useLabelSource = Boolean.parseBoolean(val);
} else if (key.equalsIgnoreCase("tokenFactory")) {
tokenFactory = val;
} else if (key.equalsIgnoreCase("tokensAnnotationClassName")) {
tokensAnnotationClassName = val;
} else if (key.equalsIgnoreCase("useLVMorphoAnalyzer")) {
useLVMorphoAnalyzer = Boolean.parseBoolean(val);
} else if (key.equalsIgnoreCase("LVMorphoAnalyzerTag")) {
lvMorphoAnalyzerTag = val;
} else if (key.equalsIgnoreCase("useLVMorphoAnalyzerPOS")) {
useLVMorphoAnalyzerPOS = Boolean.parseBoolean(val);
} else if (key.equalsIgnoreCase("useLVMorphoAnalyzerTag")) {
useLVMorphoAnalyzerTag = Boolean.parseBoolean(val);
} else if (key.equalsIgnoreCase("useLVMorphoAnalyzerPrev")) {
useLVMorphoAnalyzerPrev = Boolean.parseBoolean(val);
} else if (key.equalsIgnoreCase("useLVMorphoAnalyzerNext")) {
useLVMorphoAnalyzerNext = Boolean.parseBoolean(val);
} else if (key.equalsIgnoreCase("useLVMorphoAnalyzerItemIDs")) {
useLVMorphoAnalyzerItemIDs = Boolean.parseBoolean(val);
} else if (key.equalsIgnoreCase("useMorphologyFeatures")) {
useMorphologyFeatures = Boolean.parseBoolean(val);
} else if (key.equalsIgnoreCase("useMorphoCase")) {
useMorphoCase = Boolean.parseBoolean(val);
} else if (key.equalsIgnoreCase("useMorphoPOS")) {
useMorphoPOS = Boolean.parseBoolean(val);
} else if (key.equalsIgnoreCase("useMorphoLetaLemma")) {
useMorphoLetaLemma = Boolean.parseBoolean(val);
} else if (key.equalsIgnoreCase("useMorphoNumber")) {
useMorphoNumber = Boolean.parseBoolean(val);
// ADD VALUE ABOVE HERE
} else if (key.length() > 0 && !key.equals("prop")) {
System.err.println("Unknown property: |" + key + '|');
}
}
if (startFold > numFolds) {
System.err.println("startFold > numFolds -> setting startFold to 1");
startFold = 1;
}
if (endFold > numFolds) {
System.err.println("endFold > numFolds -> setting to numFolds");
endFold = numFolds;
}
if (combo) {
splitDocuments = false;
}
stringRep = sb.toString();
} // end setProperties()
| void function(Properties props, boolean printProps) { this.props = props; StringBuilder sb = new StringBuilder(stringRep); for (Enumeration e = props.propertyNames(); e.hasMoreElements();) { String key = (String) e.nextElement(); String val = props.getProperty(key); if (!(key.length() == 0 && val.length() == 0)) { if (printProps) { System.err.println(key + '=' + val); } sb.append(key).append('=').append(val).append('\n'); } if (key.equalsIgnoreCase("macro")) { if (Boolean.parseBoolean(val)) { useObservedSequencesOnly = true; readerAndWriter = STR; useLongSequences = true; useTaggySequences = true; useNGrams = true; usePrev = true; useNext = true; useTags = true; useWordPairs = true; useSequences = true; usePrevSequences = true; noMidNGrams = true; useReverse = true; useTypeSeqs = true; useTypeSeqs2 = true; useTypeySequences = true; wordShape = WordShapeClassifier.WORDSHAPEDAN2USELC; useOccurrencePatterns = true; useLastRealWord = true; useNextRealWord = true; sigma = 3.0; normalize = true; normalizeTimex = true; } } else if (key.equalsIgnoreCase(STR)) { if (Boolean.parseBoolean(val)) { readerAndWriter = STR; useObservedSequencesOnly = true; useLongSequences = true; useTaggySequences = true; useNGrams = true; usePrev = true; useNext = true; useTags = true; useWordPairs = true; useSequences = true; usePrevSequences = true; noMidNGrams = true; useReverse = false; useTypeSeqs = true; useTypeSeqs2 = true; useTypeySequences = true; wordShape = WordShapeClassifier.WORDSHAPEDAN2USELC; useOccurrencePatterns = true; useLastRealWord = true; useNextRealWord = true; sigma = 50.0; normalize = true; normalizeTimex = true; maxLeft = 2; useDisjunctive = true; disjunctionWidth = 4; useBoundarySequences = true; useLemmas = true; usePrevNextLemmas = true; inputEncoding = STR; useQN = true; QNsize = 15; } } else if (key.equalsIgnoreCase(STR)) { if (Boolean.parseBoolean(val)) { readerAndWriter = STR; map = STR; useObservedSequencesOnly = true; useLongSequences = true; useNGrams = true; usePrev = true; useNext = true; useWordPairs = true; useSequences = true; usePrevSequences = true; noMidNGrams = true; useReverse = false; useTypeSeqs = true; useTypeSeqs2 = true; useTypeySequences = true; wordShape = WordShapeClassifier.WORDSHAPEDAN2USELC; useLastRealWord = true; useNextRealWord = true; sigma = 20.0; adaptSigma = 20.0; normalize = true; normalizeTimex = true; maxLeft = 2; useDisjunctive = true; disjunctionWidth = 4; useBoundarySequences = true; inputEncoding = STR; useQN = true; QNsize = 15; } } else if (key.equalsIgnoreCase(STR)) { if (Boolean.parseBoolean(val)) { useTags = false; useSymTags = false; useTaggySequences = false; useOccurrencePatterns = false; } } else if (key.equalsIgnoreCase(STR)) { if (Boolean.parseBoolean(val)) { useLongSequences = true; useTaggySequences = true; useNGrams = true; usePrev = true; useNext = true; useTags = true; useWordPairs = true; wordShape = WordShapeClassifier.WORDSHAPEDAN1; useSequences = true; usePrevSequences = true; } } else if (key.equalsIgnoreCase(STR)) { if (val != null) { String[] binnedLengthStrs = val.split(STR); binnedLengths = new int[binnedLengthStrs.length]; for (int i = 0; i < binnedLengths.length; i++) { binnedLengths[i] = Integer.parseInt(binnedLengthStrs[i]); } } } else if (key.equalsIgnoreCase(STR)) { makeConsistent = Boolean.parseBoolean(val); } else if (key.equalsIgnoreCase("dump")) { dump = Boolean.parseBoolean(val); } else if (key.equalsIgnoreCase(STR)) { useNGrams = Boolean.parseBoolean(val); } else if (key.equalsIgnoreCase(STR)) { useNeighborNGrams = Boolean.parseBoolean(val); } else if (key.equalsIgnoreCase(STR)) { wordFunction = ReflectionLoading.loadByReflection(val); } else if (key.equalsIgnoreCase(STR)) { conjoinShapeNGrams = Boolean.parseBoolean(val); } else if (key.equalsIgnoreCase(STR)) { lowercaseNGrams = Boolean.parseBoolean(val); } else if (key.equalsIgnoreCase(STR)) { useIsURL = Boolean.parseBoolean(val); } else if (key.equalsIgnoreCase(STR)) { useURLSequences = Boolean.parseBoolean(val); } else if (key.equalsIgnoreCase(STR)) { useEntityTypes = Boolean.parseBoolean(val); } else if (key.equalsIgnoreCase(STR)) { useEntityRule = Boolean.parseBoolean(val); } else if (key.equalsIgnoreCase(STR)) { useOrdinal = Boolean.parseBoolean(val); } else if (key.equalsIgnoreCase(STR)) { useEntityTypeSequences = Boolean.parseBoolean(val); } else if (key.equalsIgnoreCase(STR)) { useIsDateRange = Boolean.parseBoolean(val); } else if (key.equalsIgnoreCase(STR)) { dehyphenateNGrams = Boolean.parseBoolean(val); } else if (key.equalsIgnoreCase(STR)) { lowerNewgeneThreshold = Boolean.parseBoolean(val); } else if (key.equalsIgnoreCase(STR)) { usePrev = Boolean.parseBoolean(val); } else if (key.equalsIgnoreCase(STR)) { useNext = Boolean.parseBoolean(val); } else if (key.equalsIgnoreCase(STR)) { useTags = Boolean.parseBoolean(val); } else if (key.equalsIgnoreCase(STR)) { useWordPairs = Boolean.parseBoolean(val); } else if (key.equalsIgnoreCase(STR)) { useGazettes = Boolean.parseBoolean(val); } else if (key.equalsIgnoreCase(STR)) { wordShape = WordShapeClassifier.lookupShaper(val); } else if (key.equalsIgnoreCase(STR)) { useShapeStrings = Boolean.parseBoolean(val); } else if (key.equalsIgnoreCase(STR)) { useGoodForNamesCpC = Boolean.parseBoolean(val); } else if (key.equalsIgnoreCase(STR)) { useDictionaryConjunctions = Boolean.parseBoolean(val); } else if (key.equalsIgnoreCase(STR)) { useDictionaryConjunctions3 = Boolean.parseBoolean(val); } else if (key.equalsIgnoreCase(STR)) { expandMidDot = Boolean.parseBoolean(val); } else if (key.equalsIgnoreCase(STR)) { useSequences = Boolean.parseBoolean(val); } else if (key.equalsIgnoreCase(STR)) { usePrevSequences = Boolean.parseBoolean(val); } else if (key.equalsIgnoreCase(STR)) { useNextSequences = Boolean.parseBoolean(val); } else if (key.equalsIgnoreCase(STR)) { useLongSequences = Boolean.parseBoolean(val); } else if (key.equalsIgnoreCase(STR)) { useBoundarySequences = Boolean.parseBoolean(val); } else if (key.equalsIgnoreCase(STR)) { useTaggySequences = Boolean.parseBoolean(val); } else if (key.equalsIgnoreCase(STR)) { useExtraTaggySequences = Boolean.parseBoolean(val); } else if (key.equalsIgnoreCase(STR)) { useTaggySequencesShapeInteraction = Boolean.parseBoolean(val); } else if (key.equalsIgnoreCase(STR)) { strictlyZeroethOrder = Boolean.parseBoolean(val); } else if (key.equalsIgnoreCase(STR)) { strictlyFirstOrder = Boolean.parseBoolean(val); } else if (key.equalsIgnoreCase(STR)) { strictlySecondOrder = Boolean.parseBoolean(val); } else if (key.equalsIgnoreCase(STR)) { strictlyThirdOrder = Boolean.parseBoolean(val); } else if (key.equalsIgnoreCase(STR)) { dontExtendTaggy = Boolean.parseBoolean(val); } else if (key.equalsIgnoreCase(STR)) { entitySubclassification = val; } else if (key.equalsIgnoreCase(STR)) { useGazettePhrases = Boolean.parseBoolean(val); } else if (key.equalsIgnoreCase(STR)) { StringTokenizer st = new StringTokenizer(val, STR); if (phraseGazettes == null) { phraseGazettes = new ArrayList<String>(); } while (st.hasMoreTokens()) { phraseGazettes.add(st.nextToken()); } } else if (key.equalsIgnoreCase(STR)) { useSum = Boolean.parseBoolean(val); } else if (key.equalsIgnoreCase(STR)) { verboseMode = Boolean.parseBoolean(val); } else if (key.equalsIgnoreCase(STR)) { tolerance = Double.parseDouble(val); } else if (key.equalsIgnoreCase(STR)) { maxIterations = Integer.parseInt(val); } else if (key.equalsIgnoreCase(STR)) { exportFeatures = val; } else if (key.equalsIgnoreCase(STR)) { printFeatures = val; } else if (key.equalsIgnoreCase(STR)) { printFeaturesUpto = Integer.parseInt(val); } else if (key.equalsIgnoreCase(STR)) { lastNameList = val; } else if (key.equalsIgnoreCase(STR)) { maleNameList = val; } else if (key.equalsIgnoreCase(STR)) { femaleNameList = val; } else if (key.equalsIgnoreCase(STR)) { useSymTags = Boolean.parseBoolean(val); } else if (key.equalsIgnoreCase(STR)) { useSymWordPairs = Boolean.parseBoolean(val); } else if (key.equalsIgnoreCase(STR)) { printClassifier = val; } else if (key.equalsIgnoreCase(STR)) { printClassifierParam = Integer.parseInt(val); } else if (key.equalsIgnoreCase(STR)) { intern = Boolean.parseBoolean(val); } else if (key.equalsIgnoreCase(STR)) { mergeTags = Boolean.parseBoolean(val); } else if (key.equalsIgnoreCase(STR)) { iobTags = Boolean.parseBoolean(val); } else if (key.equalsIgnoreCase(STR)) { useViterbi = Boolean.parseBoolean(val); } else if (key.equalsIgnoreCase(STR)) { intern2 = Boolean.parseBoolean(val); } else if (key.equalsIgnoreCase(STR)) { selfTest = Boolean.parseBoolean(val); } else if (key.equalsIgnoreCase(STR)) { sloppyGazette = Boolean.parseBoolean(val); } else if (key.equalsIgnoreCase(STR)) { cleanGazette = Boolean.parseBoolean(val); } else if (key.equalsIgnoreCase(STR)) { noMidNGrams = Boolean.parseBoolean(val); } else if (key.equalsIgnoreCase(STR)) { useReverse = Boolean.parseBoolean(val); } else if (key.equalsIgnoreCase(STR)) { retainEntitySubclassification = Boolean.parseBoolean(val); } else if (key.equalsIgnoreCase(STR)) { useLemmas = Boolean.parseBoolean(val); } else if (key.equalsIgnoreCase(STR)) { usePrevNextLemmas = Boolean.parseBoolean(val); } else if (key.equalsIgnoreCase(STR)) { normalizeTerms = Boolean.parseBoolean(val); } else if (key.equalsIgnoreCase(STR)) { normalizeTimex = Boolean.parseBoolean(val); } else if (key.equalsIgnoreCase("useNB")) { useNB = Boolean.parseBoolean(val); } else if (key.equalsIgnoreCase(STR)) { useParenMatching = Boolean.parseBoolean(val); } else if (key.equalsIgnoreCase(STR)) { useTypeSeqs = Boolean.parseBoolean(val); } else if (key.equalsIgnoreCase(STR)) { useTypeSeqs2 = Boolean.parseBoolean(val); } else if (key.equalsIgnoreCase(STR)) { useTypeSeqs3 = Boolean.parseBoolean(val); } else if (key.equalsIgnoreCase(STR)) { useDisjunctive = Boolean.parseBoolean(val); } else if (key.equalsIgnoreCase(STR)) { disjunctionWidth = Integer.parseInt(val); } else if (key.equalsIgnoreCase(STR)) { useDisjunctiveShapeInteraction = Boolean.parseBoolean(val); } else if (key.equalsIgnoreCase(STR)) { useWideDisjunctive = Boolean.parseBoolean(val); } else if (key.equalsIgnoreCase(STR)) { wideDisjunctionWidth = Integer.parseInt(val); } else if (key.equalsIgnoreCase(STR)) { useDisjShape = Boolean.parseBoolean(val); } else if (key.equalsIgnoreCase(STR)) { useTitle = Boolean.parseBoolean(val); } else if (key.equalsIgnoreCase(STR)) { booleanFeatures = Boolean.parseBoolean(val); } else if (key.equalsIgnoreCase(STR)) { useClassFeature = Boolean.parseBoolean(val); } else if (key.equalsIgnoreCase(STR)) { useShapeConjunctions = Boolean.parseBoolean(val); } else if (key.equalsIgnoreCase(STR)) { useWordTag = Boolean.parseBoolean(val); } else if (key.equalsIgnoreCase(STR)) { useNPHead = Boolean.parseBoolean(val); } else if (key.equalsIgnoreCase(STR)) { useNPGovernor = Boolean.parseBoolean(val); } else if (key.equalsIgnoreCase(STR)) { useHeadGov = Boolean.parseBoolean(val); } else if (key.equalsIgnoreCase(STR)) { useLastRealWord = Boolean.parseBoolean(val); } else if (key.equalsIgnoreCase(STR)) { useNextRealWord = Boolean.parseBoolean(val); } else if (key.equalsIgnoreCase(STR)) { useOccurrencePatterns = Boolean.parseBoolean(val); } else if (key.equalsIgnoreCase(STR)) { useTypeySequences = Boolean.parseBoolean(val); } else if (key.equalsIgnoreCase(STR)) { justify = Boolean.parseBoolean(val); } else if (key.equalsIgnoreCase(STR)) { normalize = Boolean.parseBoolean(val); } else if (key.equalsIgnoreCase(STR)) { priorType = val; } else if (key.equalsIgnoreCase("sigma")) { sigma = Double.parseDouble(val); } else if (key.equalsIgnoreCase(STR)) { epsilon = Double.parseDouble(val); } else if (key.equalsIgnoreCase(STR)) { beamSize = Integer.parseInt(val); } else if (key.equalsIgnoreCase(STR)) { removeTopN = Integer.parseInt(val); } else if (key.equalsIgnoreCase(STR)) { removeTopNPercent = Double.parseDouble(val); } else if (key.equalsIgnoreCase(STR)) { randomizedRatio = Double.parseDouble(val); } else if (key.equalsIgnoreCase(STR)) { numTimesRemoveTopN = Integer.parseInt(val); } else if (key.equalsIgnoreCase(STR)) { maxLeft = Integer.parseInt(val); } else if (key.equalsIgnoreCase(STR)) { maxRight = Integer.parseInt(val); } else if (key.equalsIgnoreCase(STR)) { maxNGramLeng = Integer.parseInt(val); } else if (key.equalsIgnoreCase(STR)) { useGazFeatures = Boolean.parseBoolean(val); } else if (key.equalsIgnoreCase(STR)) { useAltGazFeatures = Boolean.parseBoolean(val); } else if (key.equalsIgnoreCase(STR)) { useMoreGazFeatures = Boolean.parseBoolean(val); } else if (key.equalsIgnoreCase(STR)) { useAbbr = Boolean.parseBoolean(val); } else if (key.equalsIgnoreCase(STR)) { useMinimalAbbr = Boolean.parseBoolean(val); } else if (key.equalsIgnoreCase(STR)) { useAbbr1 = Boolean.parseBoolean(val); } else if (key.equalsIgnoreCase(STR)) { useMinimalAbbr1 = Boolean.parseBoolean(val); } else if (key.equalsIgnoreCase(STR)) { System.err.println(STR + val); System.err.println(STR); } else if (key.equalsIgnoreCase(STR)) { deleteBlankLines = Boolean.parseBoolean(val); } else if (key.equalsIgnoreCase(STR)) { answerFile = val; } else if (key.equalsIgnoreCase(STR)) { altAnswerFile = val; } else if (key.equalsIgnoreCase(STR)) { loadClassifier = val; } else if (key.equalsIgnoreCase(STR)) { loadTextClassifier = val; } else if (key.equalsIgnoreCase(STR)) { loadJarClassifier = val; } else if (key.equalsIgnoreCase(STR)) { loadAuxClassifier = val; } else if (key.equalsIgnoreCase(STR)) { serializeTo = val; } else if (key.equalsIgnoreCase(STR)) { serializeToText = val; } else if (key.equalsIgnoreCase(STR)) { serializeDatasetsDir = val; } else if (key.equalsIgnoreCase(STR)) { loadDatasetsDir = val; } else if (key.equalsIgnoreCase(STR)) { pushDir = val; } else if (key.equalsIgnoreCase(STR)) { purgeDatasets = Boolean.parseBoolean(val); } else if (key.equalsIgnoreCase(STR)) { keepOBInMemory = Boolean.parseBoolean(val); } else if (key.equalsIgnoreCase(STR)) { fakeDataset = Boolean.parseBoolean(val); } else if (key.equalsIgnoreCase(STR)) { numDatasetsPerFile = Integer.parseInt(val); } else if (key.equalsIgnoreCase(STR)) { trainFile = val; } else if (key.equalsIgnoreCase(STR)) { biasedTrainFile = val; } else if (key.equalsIgnoreCase(STR)) { classBias = val; } else if (key.equalsIgnoreCase(STR)) { confusionMatrix = val; } else if (key.equalsIgnoreCase(STR)) { adaptFile = val; } else if (key.equalsIgnoreCase(STR)) { devFile = val; } else if (key.equalsIgnoreCase(STR)) { testFile = val; } else if (key.equalsIgnoreCase(STR)) { outputFile = val; } else if (key.equalsIgnoreCase(STR)) { textFile = val; } else if (key.equalsIgnoreCase(STR)) { readStdin = Boolean.parseBoolean(val); } else if (key.equalsIgnoreCase(STR)) { initialWeights = val; } else if (key.equalsIgnoreCase(STR)) { interimOutputFreq = Integer.parseInt(val); } else if (key.equalsIgnoreCase(STR)) { inputEncoding = val; } else if (key.equalsIgnoreCase(STR)) { outputEncoding = val; } else if (key.equalsIgnoreCase(STR)) { useGazettes = true; StringTokenizer st = new StringTokenizer(val, STR); if (gazettes == null) { gazettes = new ArrayList<String>(); } while (st.hasMoreTokens()) { gazettes.add(st.nextToken()); } } else if (key.equalsIgnoreCase("useQN")) { useQN = Boolean.parseBoolean(val); } else if (key.equalsIgnoreCase(STR)) { QNsize = Integer.parseInt(val); } else if (key.equalsIgnoreCase(STR)) { QNsize2 = Integer.parseInt(val); } else if (key.equalsIgnoreCase("l1reg")) { useQN = false; l1reg = Double.parseDouble(val); } else if (key.equalsIgnoreCase(STR)) { useFloat = Boolean.parseBoolean(val); } else if (key.equalsIgnoreCase(STR)) { System.err.println(STR); throw new RuntimeException(); } else if (key.equalsIgnoreCase(STR)) { System.err.println(STR); throw new RuntimeException(); } else if (key.equalsIgnoreCase("map")) { map = val; } else if (key.equalsIgnoreCase(STR)) { useMoreAbbr = Boolean.parseBoolean(val); } else if (key.equalsIgnoreCase(STR)) { usePrevVB = Boolean.parseBoolean(val); } else if (key.equalsIgnoreCase(STR)) { useNextVB = Boolean.parseBoolean(val); } else if (key.equalsIgnoreCase("useVB")) { if (Boolean.parseBoolean(val)) { useVB = true; usePrevVB = true; useNextVB = true; } } else if (key.equalsIgnoreCase(STR)) { useChunks = Boolean.parseBoolean(val); } else if (key.equalsIgnoreCase(STR)) { useChunkySequences = Boolean.parseBoolean(val); } else if (key.equalsIgnoreCase(STR)) { greekifyNGrams = Boolean.parseBoolean(val); } else if (key.equalsIgnoreCase(STR)) { restrictTransitionsTimit = Boolean.parseBoolean(val); } else if (key.equalsIgnoreCase(STR)) { useMoreTags = Boolean.parseBoolean(val); } else if (key.equalsIgnoreCase(STR)) { useBeginSent = Boolean.parseBoolean(val); } else if (key.equalsIgnoreCase(STR)) { usePosition = Boolean.parseBoolean(val); } else if (key.equalsIgnoreCase(STR)) { useGENIA = Boolean.parseBoolean(val); } else if (key.equalsIgnoreCase(STR)) { useABSTR = Boolean.parseBoolean(val); } else if (key.equalsIgnoreCase(STR)) { useWEB = Boolean.parseBoolean(val); } else if (key.equalsIgnoreCase(STR)) { useANTE = Boolean.parseBoolean(val); } else if (key.equalsIgnoreCase(STR)) { useACR = Boolean.parseBoolean(val); } else if (key.equalsIgnoreCase(STR)) { useTOK = Boolean.parseBoolean(val); } else if (key.equalsIgnoreCase(STR)) { useABGENE = Boolean.parseBoolean(val); } else if (key.equalsIgnoreCase(STR)) { useABSTRFreqDict = Boolean.parseBoolean(val); } else if (key.equalsIgnoreCase(STR)) { useABSTRFreq = Boolean.parseBoolean(val); } else if (key.equalsIgnoreCase(STR)) { useFREQ = Boolean.parseBoolean(val); } else if (key.equalsIgnoreCase(STR)) { useWEBFreqDict = Boolean.parseBoolean(val); } else if (key.equalsIgnoreCase(STR)) { bioSubmitOutput = Boolean.parseBoolean(val); } else if (key.equalsIgnoreCase(STR)) { subCWGaz = Boolean.parseBoolean(val); } else if (key.equalsIgnoreCase(STR)) { splitOnHead = Boolean.parseBoolean(val); } else if (key.equalsIgnoreCase(STR)) { featureCountThreshold = Integer.parseInt(val); } else if (key.equalsIgnoreCase(STR)) { useWord = Boolean.parseBoolean(val); } else if (key.equalsIgnoreCase(STR)) { memoryThrift = Boolean.parseBoolean(val); } else if (key.equalsIgnoreCase(STR)) { timitDatum = Boolean.parseBoolean(val); } else if (key.equalsIgnoreCase(STR)) { splitDocuments = Boolean.parseBoolean(val); } else if (key.equalsIgnoreCase(STR)) { featureWeightThreshold = Double.parseDouble(val); } else if (key.equalsIgnoreCase(STR)) { backgroundSymbol = val; } else if (key.equalsIgnoreCase(STR)) { featureFactory = val; if (featureFactory.equalsIgnoreCase(STR)) { featureFactory = STR; } else if (featureFactory.equalsIgnoreCase(STR)) { featureFactory = STR; } else if (featureFactory.equalsIgnoreCase(STR)) { featureFactory = STR; } else if (featureFactory.equalsIgnoreCase(STR)) { featureFactory = STR; } else if (featureFactory.equalsIgnoreCase(STR)) { featureFactory = STR; } } else if (key.equalsIgnoreCase(STR)) { printXML = Boolean.parseBoolean(val); } else if (key.equalsIgnoreCase(STR)) { useSeenFeaturesOnly = Boolean.parseBoolean(val); } else if (key.equalsIgnoreCase(STR)) { useRadical = Boolean.parseBoolean(val); } else if (key.equalsIgnoreCase(STR)) { useBigramInTwoClique = Boolean.parseBoolean(val); } else if (key.equalsIgnoreCase(STR)) { useReverseAffix = Boolean.parseBoolean(val); } else if (key.equalsIgnoreCase(STR)) { charHalfWindow = Integer.parseInt(val); } else if (key.equalsIgnoreCase(STR)) { purgeFeatures = Integer.parseInt(val); } else if (key.equalsIgnoreCase(STR)) { ocrFold = Integer.parseInt(val); } else if (key.equalsIgnoreCase(STR)) { morphFeatureFile = val; } else if (key.equalsIgnoreCase(STR)) { svmModelFile = val; } else if (key.equalsIgnoreCase(STR)) { useDictleng = Boolean.parseBoolean(val); } else if (key.equalsIgnoreCase(STR)) { useDict2 = Boolean.parseBoolean(val); } else if (key.equalsIgnoreCase(STR)) { useOutDict2 = Boolean.parseBoolean(val); } else if (key.equalsIgnoreCase(STR)) { outDict2 = val; } else if (key.equalsIgnoreCase(STR)) { useDictCTB2 = Boolean.parseBoolean(val); } else if (key.equalsIgnoreCase(STR)) { useDictASBC2 = Boolean.parseBoolean(val); } else if (key.equalsIgnoreCase(STR)) { useDictPK2 = Boolean.parseBoolean(val); } else if (key.equalsIgnoreCase(STR)) { useDictHK2 = Boolean.parseBoolean(val); } else if (key.equalsIgnoreCase(STR)) { useWord1 = Boolean.parseBoolean(val); } else if (key.equalsIgnoreCase(STR)) { useWord2 = Boolean.parseBoolean(val); } else if (key.equalsIgnoreCase(STR)) { useWord3 = Boolean.parseBoolean(val); } else if (key.equalsIgnoreCase(STR)) { useWord4 = Boolean.parseBoolean(val); } else if (key.equalsIgnoreCase(STR)) { useRad1 = Boolean.parseBoolean(val); } else if (key.equalsIgnoreCase(STR)) { useRad2 = Boolean.parseBoolean(val); } else if (key.equalsIgnoreCase(STR)) { useRad2b = Boolean.parseBoolean(val); } else if (key.equalsIgnoreCase(STR)) { useWordn = Boolean.parseBoolean(val); } else if (key.equalsIgnoreCase(STR)) { useCTBPre1 = Boolean.parseBoolean(val); } else if (key.equalsIgnoreCase(STR)) { useCTBSuf1 = Boolean.parseBoolean(val); } else if (key.equalsIgnoreCase(STR)) { useASBCPre1 = Boolean.parseBoolean(val); } else if (key.equalsIgnoreCase(STR)) { useASBCSuf1 = Boolean.parseBoolean(val); } else if (key.equalsIgnoreCase(STR)) { useHKPre1 = Boolean.parseBoolean(val); } else if (key.equalsIgnoreCase(STR)) { useHKSuf1 = Boolean.parseBoolean(val); } else if (key.equalsIgnoreCase(STR)) { usePKPre1 = Boolean.parseBoolean(val); } else if (key.equalsIgnoreCase(STR)) { usePKSuf1 = Boolean.parseBoolean(val); } else if (key.equalsIgnoreCase(STR)) { useCTBChar2 = Boolean.parseBoolean(val); } else if (key.equalsIgnoreCase(STR)) { usePrediction = Boolean.parseBoolean(val); } else if (key.equalsIgnoreCase(STR)) { useASBCChar2 = Boolean.parseBoolean(val); } else if (key.equalsIgnoreCase(STR)) { useHKChar2 = Boolean.parseBoolean(val); } else if (key.equalsIgnoreCase(STR)) { usePKChar2 = Boolean.parseBoolean(val); } else if (key.equalsIgnoreCase(STR)) { useRule2 = Boolean.parseBoolean(val); } else if (key.equalsIgnoreCase(STR)) { useBig5 = Boolean.parseBoolean(val); } else if (key.equalsIgnoreCase(STR)) { useNegDict2 = Boolean.parseBoolean(val); } else if (key.equalsIgnoreCase(STR)) { useNegDict3 = Boolean.parseBoolean(val); } else if (key.equalsIgnoreCase(STR)) { useNegDict4 = Boolean.parseBoolean(val); } else if (key.equalsIgnoreCase(STR)) { useNegCTBDict2 = Boolean.parseBoolean(val); } else if (key.equalsIgnoreCase(STR)) { useNegCTBDict3 = Boolean.parseBoolean(val); } else if (key.equalsIgnoreCase(STR)) { useNegCTBDict4 = Boolean.parseBoolean(val); } else if (key.equalsIgnoreCase(STR)) { useNegASBCDict2 = Boolean.parseBoolean(val); } else if (key.equalsIgnoreCase(STR)) { useNegASBCDict3 = Boolean.parseBoolean(val); } else if (key.equalsIgnoreCase(STR)) { useNegASBCDict4 = Boolean.parseBoolean(val); } else if (key.equalsIgnoreCase(STR)) { useNegPKDict2 = Boolean.parseBoolean(val); } else if (key.equalsIgnoreCase(STR)) { useNegPKDict3 = Boolean.parseBoolean(val); } else if (key.equalsIgnoreCase(STR)) { useNegPKDict4 = Boolean.parseBoolean(val); } else if (key.equalsIgnoreCase(STR)) { useNegHKDict2 = Boolean.parseBoolean(val); } else if (key.equalsIgnoreCase(STR)) { useNegHKDict3 = Boolean.parseBoolean(val); } else if (key.equalsIgnoreCase(STR)) { useNegHKDict4 = Boolean.parseBoolean(val); } else if (key.equalsIgnoreCase(STR)) { usePre = Boolean.parseBoolean(val); } else if (key.equalsIgnoreCase(STR)) { useSuf = Boolean.parseBoolean(val); } else if (key.equalsIgnoreCase(STR)) { useRule = Boolean.parseBoolean(val); } else if (key.equalsIgnoreCase("useAs")) { useAs = Boolean.parseBoolean(val); } else if (key.equalsIgnoreCase("usePk")) { usePk = Boolean.parseBoolean(val); } else if (key.equalsIgnoreCase("useHk")) { useHk = Boolean.parseBoolean(val); } else if (key.equalsIgnoreCase(STR)) { useMsr = Boolean.parseBoolean(val); } else if (key.equalsIgnoreCase(STR)) { useMSRChar2 = Boolean.parseBoolean(val); } else if (key.equalsIgnoreCase(STR)) { useFeaturesC4gram = Boolean.parseBoolean(val); } else if (key.equalsIgnoreCase(STR)) { useFeaturesC5gram = Boolean.parseBoolean(val); } else if (key.equalsIgnoreCase(STR)) { useFeaturesC6gram = Boolean.parseBoolean(val); } else if (key.equalsIgnoreCase(STR)) { useFeaturesCpC4gram = Boolean.parseBoolean(val); } else if (key.equalsIgnoreCase(STR)) { useFeaturesCpC5gram = Boolean.parseBoolean(val); } else if (key.equalsIgnoreCase(STR)) { useFeaturesCpC6gram = Boolean.parseBoolean(val); } else if (key.equalsIgnoreCase(STR)) { useUnicodeType = Boolean.parseBoolean(val); } else if (key.equalsIgnoreCase(STR)) { useUnicodeBlock = Boolean.parseBoolean(val); } else if (key.equalsIgnoreCase(STR)) { useUnicodeType4gram = Boolean.parseBoolean(val); } else if (key.equalsIgnoreCase(STR)) { useUnicodeType5gram = Boolean.parseBoolean(val); } else if (key.equalsIgnoreCase(STR)) { useShapeStrings1 = Boolean.parseBoolean(val); } else if (key.equalsIgnoreCase(STR)) { useShapeStrings3 = Boolean.parseBoolean(val); } else if (key.equalsIgnoreCase(STR)) { useShapeStrings4 = Boolean.parseBoolean(val); } else if (key.equalsIgnoreCase(STR)) { useShapeStrings5 = Boolean.parseBoolean(val); } else if (key.equalsIgnoreCase(STR)) { useWordUTypeConjunctions2 = Boolean.parseBoolean(val); } else if (key.equalsIgnoreCase(STR)) { useWordUTypeConjunctions3 = Boolean.parseBoolean(val); } else if (key.equalsIgnoreCase(STR)) { useWordShapeConjunctions2 = Boolean.parseBoolean(val); } else if (key.equalsIgnoreCase(STR)) { useWordShapeConjunctions3 = Boolean.parseBoolean(val); } else if (key.equalsIgnoreCase(STR)) { useMidDotShape = Boolean.parseBoolean(val); } else if (key.equalsIgnoreCase(STR)) { augmentedDateChars = Boolean.parseBoolean(val); } else if (key.equalsIgnoreCase(STR)) { suppressMidDotPostprocessing = Boolean.parseBoolean(val); } else if (key.equalsIgnoreCase(STR)) { printNR = Boolean.parseBoolean(val); } else if (key.equalsIgnoreCase(STR)) { use4Clique = Boolean.parseBoolean(val); } else if (key.equalsIgnoreCase(STR)) { useFilter = Boolean.parseBoolean(val); } else if (key.equalsIgnoreCase(STR)) { largeChSegFile = Boolean.parseBoolean(val); } else if (key.equalsIgnoreCase(STR)) { keepEnglishWhitespaces = Boolean.parseBoolean(val); } else if (key.equalsIgnoreCase(STR)) { keepAllWhitespaces = Boolean.parseBoolean(val); } else if (key.equalsIgnoreCase(STR)) { sighanPostProcessing = Boolean.parseBoolean(val); } else if (key.equalsIgnoreCase(STR)) { useChPos = Boolean.parseBoolean(val); } else if (key.equalsIgnoreCase(STR)) { sighanCorporaDict = val; } else if (key.equalsIgnoreCase(STR)) { useObservedSequencesOnly = Boolean.parseBoolean(val); } else if (key.equalsIgnoreCase(STR)) { maxDocSize = Integer.parseInt(val); splitDocuments = true; } else if (key.equalsIgnoreCase(STR)) { printProbs = Boolean.parseBoolean(val); } else if (key.equalsIgnoreCase(STR)) { printFirstOrderProbs = Boolean.parseBoolean(val); } else if (key.equalsIgnoreCase(STR)) { saveFeatureIndexToDisk = Boolean.parseBoolean(val); } else if (key.equalsIgnoreCase(STR)) { removeBackgroundSingletonFeatures = Boolean.parseBoolean(val); } else if (key.equalsIgnoreCase(STR)) { doGibbs = Boolean.parseBoolean(val); } else if (key.equalsIgnoreCase(STR)) { useNERPrior = Boolean.parseBoolean(val); } else if (key.equalsIgnoreCase(STR)) { useAcqPrior = Boolean.parseBoolean(val); } else if (key.equalsIgnoreCase(STR)) { useSemPrior = Boolean.parseBoolean(val); } else if (key.equalsIgnoreCase(STR)) { useMUCFeatures = Boolean.parseBoolean(val); } else if (key.equalsIgnoreCase(STR)) { initViterbi = Boolean.parseBoolean(val); } else if (key.equalsIgnoreCase(STR)) { checkNameList = Boolean.parseBoolean(val); } else if (key.equalsIgnoreCase(STR)) { useFirstWord = Boolean.parseBoolean(val); } else if (key.equalsIgnoreCase(STR)) { useUnknown = Boolean.parseBoolean(val); } else if (key.equalsIgnoreCase(STR)) { cacheNGrams = Boolean.parseBoolean(val); } else if (key.equalsIgnoreCase(STR)) { useNumberFeature = Boolean.parseBoolean(val); } else if (key.equalsIgnoreCase(STR)) { annealingRate = Double.parseDouble(val); } else if (key.equalsIgnoreCase(STR)) { if (val.equalsIgnoreCase(STR) val.equalsIgnoreCase("exp") val.equalsIgnoreCase(STR)) { annealingType = val; } else { System.err.println(STR + val + STR); } } else if (key.equalsIgnoreCase(STR)) { numSamples = Integer.parseInt(val); } else if (key.equalsIgnoreCase(STR)) { inferenceType = val; } else if (key.equalsIgnoreCase(STR)) { loadProcessedData = val; } else if (key.equalsIgnoreCase(STR)) { normalizationTable = val; } else if (key.equalsIgnoreCase(STR)) { val = val.trim(); if (val.length() > 0 && !"true".equals(val) && !"null".equals(val) && !"false".equals("val")) { dictionary = val; } else { dictionary = null; } } else if (key.equalsIgnoreCase(STR)) { val = val.trim(); if (val.length() > 0 && !"true".equals(val) && !"null".equals(val) && !"false".equals("val")) { serializedDictionary = val; } else { serializedDictionary = null; } } else if (key.equalsIgnoreCase(STR)) { val = val.trim(); if (val.length() > 0 && !"true".equals(val) && !"null".equals(val) && !"false".equals("val")) { dictionary2 = val; } else { dictionary2 = null; } } else if (key.equalsIgnoreCase(STR)) { normTableEncoding = val; } else if (key.equalsIgnoreCase(STR)) { useLemmaAsWord = Boolean.parseBoolean(val); } else if (key.equalsIgnoreCase("type")) { type = val; } else if (key.equalsIgnoreCase(STR)) { readerAndWriter = val; } else if (key.equalsIgnoreCase(STR)) { plainTextDocumentReaderAndWriter = val; } else if (key.equalsIgnoreCase(STR)) { gazFilesFile = val; } else if (key.equalsIgnoreCase(STR)) { baseTrainDir = val; } else if (key.equalsIgnoreCase(STR)) { baseTestDir = val; } else if (key.equalsIgnoreCase(STR)) { trainFiles = val; } else if (key.equalsIgnoreCase(STR)) { trainFileList = val; } else if (key.equalsIgnoreCase(STR)) { trainDirs = val; } else if (key.equalsIgnoreCase(STR)) { testDirs = val; } else if (key.equalsIgnoreCase(STR)) { testFiles = val; } else if (key.equalsIgnoreCase(STR)) { usePrediction2 = Boolean.parseBoolean(val); } else if (key.equalsIgnoreCase(STR)) { useObservedFeaturesOnly = Boolean.parseBoolean(val); } else if (key.equalsIgnoreCase(STR)) { iobWrapper = Boolean.parseBoolean(val); } else if (key.equalsIgnoreCase(STR)) { useDistSim = Boolean.parseBoolean(val); } else if (key.equalsIgnoreCase(STR)) { casedDistSim = Boolean.parseBoolean(val); } else if (key.equalsIgnoreCase(STR)) { distSimFileFormat = val; } else if (key.equalsIgnoreCase(STR)) { distSimMaxBits = Integer.parseInt(val); } else if (key.equalsIgnoreCase(STR)) { numberEquivalenceDistSim = Boolean.parseBoolean(val); } else if (key.equalsIgnoreCase(STR)) { unknownWordDistSimClass = val; } else if (key.equalsIgnoreCase(STR)) { useOnlySeenWeights = Boolean.parseBoolean(val); } else if (key.equalsIgnoreCase(STR)) { predProp = val; } else if (key.equalsIgnoreCase(STR)) { distSimLexicon = val; } else if (key.equalsIgnoreCase(STR)) { useSegmentation = Boolean.parseBoolean(val); } else if (key.equalsIgnoreCase(STR)) { useInternal = Boolean.parseBoolean(val); } else if (key.equalsIgnoreCase(STR)) { useExternal = Boolean.parseBoolean(val); } else if (key.equalsIgnoreCase(STR)) { useEitherSideWord = Boolean.parseBoolean(val); } else if (key.equalsIgnoreCase(STR)) { useEitherSideDisjunctive = Boolean.parseBoolean(val); } else if (key.equalsIgnoreCase(STR)) { featureDiffThresh = Double.parseDouble(val); if (props.getProperty(STR) == null) { numTimesPruneFeatures = 1; } } else if (key.equalsIgnoreCase(STR)) { numTimesPruneFeatures = Integer.parseInt(val); } else if (key.equalsIgnoreCase(STR)) { newgeneThreshold = Double.parseDouble(val); } else if (key.equalsIgnoreCase(STR)) { adaptFile = val; } else if (key.equalsIgnoreCase(STR)) { doAdaptation = Boolean.parseBoolean(val); } else if (key.equalsIgnoreCase(STR)) { selfTrainFile = val; } else if (key.equalsIgnoreCase(STR)) { selfTrainIterations = Integer.parseInt(val); } else if (key.equalsIgnoreCase(STR)) { selfTrainWindowSize = Integer.parseInt(val); } else if (key.equalsIgnoreCase(STR)) { selfTrainConfidenceThreshold = Double.parseDouble(val); } else if (key.equalsIgnoreCase(STR)) { numFolds = Integer.parseInt(val); } else if (key.equalsIgnoreCase(STR)) { startFold = Integer.parseInt(val); } else if (key.equalsIgnoreCase(STR)) { endFold = Integer.parseInt(val); } else if (key.equalsIgnoreCase(STR)) { adaptSigma = Double.parseDouble(val); } else if (key.startsWith("prop") && !key.equals("prop")) { comboProps.add(val); } else if (key.equalsIgnoreCase(STR)) { outputFormat = val; } else if (key.equalsIgnoreCase(STR)) { useSMD = Boolean.parseBoolean(val); } else if (key.equalsIgnoreCase(STR)) { useScaledSGD = Boolean.parseBoolean(val); } else if (key.equalsIgnoreCase(STR)) { scaledSGDMethod = Integer.parseInt(val); } else if (key.equalsIgnoreCase(STR)) { tuneSGD = Boolean.parseBoolean(val); } else if (key.equalsIgnoreCase(STR)) { if (val.equalsIgnoreCase(STR)) { stochasticMethod = StochasticCalculateMethods.AlgorithmicDifferentiation; } else if (val.equalsIgnoreCase(STR)) { stochasticMethod = StochasticCalculateMethods.IncorporatedFiniteDifference; } else if (val.equalsIgnoreCase(STR)) { stochasticMethod = StochasticCalculateMethods.ExternalFiniteDifference; } } else if (key.equalsIgnoreCase(STR)) { initialGain = Double.parseDouble(val); } else if (key.equalsIgnoreCase(STR)) { stochasticBatchSize = Integer.parseInt(val); } else if (key.equalsIgnoreCase(STR)) { SGD2QNhessSamples = Integer.parseInt(val); } else if (key.equalsIgnoreCase(STR)) { useSGD = Boolean.parseBoolean(val); } else if (key.equalsIgnoreCase(STR)) { useInPlaceSGD = Boolean.parseBoolean(val); } else if (key.equalsIgnoreCase(STR)) { useSGDtoQN = Boolean.parseBoolean(val); } else if (key.equalsIgnoreCase(STR)) { SGDPasses = Integer.parseInt(val); } else if (key.equalsIgnoreCase(STR)) { QNPasses = Integer.parseInt(val); } else if (key.equalsIgnoreCase(STR)) { gainSGD = Double.parseDouble(val); } else if (key.equalsIgnoreCase(STR)) { useHybrid = Boolean.parseBoolean(val); } else if (key.equalsIgnoreCase(STR)) { hybridCutoffIteration = Integer.parseInt(val); } else if (key.equalsIgnoreCase(STR)) { useStochasticQN = Boolean.parseBoolean(val); } else if (key.equalsIgnoreCase(STR)) { outputIterationsToFile = Boolean.parseBoolean(val); } else if (key.equalsIgnoreCase(STR)) { testObjFunction = Boolean.parseBoolean(val); } else if (key.equalsIgnoreCase(STR)) { testVariance = Boolean.parseBoolean(val); } else if (key.equalsIgnoreCase(STR)) { CRForder = Integer.parseInt(val); } else if (key.equalsIgnoreCase(STR)) { CRFwindow = Integer.parseInt(val); } else if (key.equalsIgnoreCase(STR)) { testHessSamples = Boolean.parseBoolean(val); } else if (key.equalsIgnoreCase(STR)) { estimateInitial = Boolean.parseBoolean(val); } else if (key.equalsIgnoreCase(STR)) { printLabelValue = Boolean.parseBoolean(val); } else if (key.equalsIgnoreCase(STR)) { searchGraphPrefix = val; } else if (key.equalsIgnoreCase(STR)) { searchGraphPrune = Double.parseDouble(val); } else if (key.equalsIgnoreCase("kBest")) { useKBest = true; kBest = Integer.parseInt(val); } else if (key.equalsIgnoreCase(STR)) { useRobustQN = true; } else if (key.equalsIgnoreCase("combo")) { combo = Boolean.parseBoolean(val); } else if (key.equalsIgnoreCase(STR)) { verboseForTrueCasing = Boolean.parseBoolean(val); } else if (key.equalsIgnoreCase(STR)) { trainHierarchical = val; } else if (key.equalsIgnoreCase(STR)) { domain = val; } else if (key.equalsIgnoreCase(STR)) { baseline = Boolean.parseBoolean(val); } else if (key.equalsIgnoreCase("doFE")) { doFE = Boolean.parseBoolean(val); } else if (key.equalsIgnoreCase(STR)) { restrictLabels = Boolean.parseBoolean(val); } else if (key.equalsIgnoreCase(STR)) { transferSigmas = val; } else if (key.equalsIgnoreCase(STR)) { announceObjectBankEntries = true; } else if (key.equalsIgnoreCase(STR)) { usePos = Boolean.parseBoolean(val); } else if (key.equalsIgnoreCase(STR)) { useAgreement = Boolean.parseBoolean(val); } else if (key.equalsIgnoreCase(STR)) { useAccCase = Boolean.parseBoolean(val); } else if (key.equalsIgnoreCase(STR)) { useInna = Boolean.parseBoolean(val); } else if (key.equalsIgnoreCase(STR)) { useConcord = Boolean.parseBoolean(val); } else if (key.equalsIgnoreCase(STR)) { useFirstNgram = Boolean.parseBoolean(val); } else if (key.equalsIgnoreCase(STR)) { useLastNgram = Boolean.parseBoolean(val); } else if (key.equalsIgnoreCase(STR)) { collapseNN = Boolean.parseBoolean(val); } else if (key.equalsIgnoreCase(STR)) { useTagsCpC = Boolean.parseBoolean(val); } else if (key.equalsIgnoreCase(STR)) { useTagsCpCp2C = Boolean.parseBoolean(val); } else if (key.equalsIgnoreCase(STR)) { useTagsCpCp2Cp3C = Boolean.parseBoolean(val); } else if (key.equalsIgnoreCase(STR)) { useTagsCpCp2Cp3Cp4C = Boolean.parseBoolean(val); } else if (key.equalsIgnoreCase(STR)) { numTags = Integer.parseInt(val); } else if (key.equalsIgnoreCase(STR)) { useConjBreak = Boolean.parseBoolean(val); } else if (key.equalsIgnoreCase(STR)) { useAuxPairs = Boolean.parseBoolean(val); } else if (key.equalsIgnoreCase(STR)) { usePPVBPairs = Boolean.parseBoolean(val); } else if (key.equalsIgnoreCase(STR)) { useAnnexing = Boolean.parseBoolean(val); } else if (key.equalsIgnoreCase(STR)) { useTemporalNN = Boolean.parseBoolean(val); } else if (key.equalsIgnoreCase(STR)) { markProperNN = Boolean.parseBoolean(val); } else if (key.equalsIgnoreCase(STR)) { usePath = Boolean.parseBoolean(val); } else if (key.equalsIgnoreCase(STR)) { markMasdar = Boolean.parseBoolean(val); } else if (key.equalsIgnoreCase(STR)) { innaPPAttach = Boolean.parseBoolean(val); } else if (key.equalsIgnoreCase(STR)) { useSVO = Boolean.parseBoolean(val); } else if (key.equalsIgnoreCase(STR)) { mixedCaseMapFile = val; } else if (key.equalsIgnoreCase(STR)) { auxTrueCaseModels = val; } else if (key.equalsIgnoreCase("use2W")) { use2W = Boolean.parseBoolean(val); } else if (key.equalsIgnoreCase("useLC")) { useLC = Boolean.parseBoolean(val); } else if (key.equalsIgnoreCase(STR)) { useYetMoreCpCShapes = Boolean.parseBoolean(val); } else if (key.equalsIgnoreCase(STR)) { useIfInteger = Boolean.parseBoolean(val); } else if (key.equalsIgnoreCase(STR)) { twoStage = Boolean.parseBoolean(val); } else if (key.equalsIgnoreCase(STR)) { evaluateIters = Integer.parseInt(val); } else if (key.equalsIgnoreCase(STR)) { evalCmd = val; } else if (key.equalsIgnoreCase(STR)) { evaluateTrain = Boolean.parseBoolean(val); } else if (key.equalsIgnoreCase(STR)) { evaluateIOB = Boolean.parseBoolean(val); } else if (key.equalsIgnoreCase(STR)) { tuneSampleSize = Integer.parseInt(val); } else if (key.equalsIgnoreCase(STR)) { useTopics = Boolean.parseBoolean(val); } else if (key.equalsIgnoreCase(STR)) { usePhraseFeatures = Boolean.parseBoolean(val); } else if (key.equalsIgnoreCase(STR)) { usePhraseWords = Boolean.parseBoolean(val); } else if (key.equalsIgnoreCase(STR)) { usePhraseWordTags = Boolean.parseBoolean(val); } else if (key.equalsIgnoreCase(STR)) { usePhraseWordSpecialTags = Boolean.parseBoolean(val); } else if (key.equalsIgnoreCase(STR)) { useProtoFeatures = Boolean.parseBoolean(val); } else if (key.equalsIgnoreCase(STR)) { useWordnetFeatures = Boolean.parseBoolean(val); } else if (key.equalsIgnoreCase(STR)) { wikiFeatureDbFile = val; } else if (key.equalsIgnoreCase(STR)) { tokenizerOptions = val; } else if (key.equalsIgnoreCase(STR)) { useCommonWordsFeature = Boolean.parseBoolean(val); } else if (key.equalsIgnoreCase(STR)) { useYear = Boolean.parseBoolean(val); } else if (key.equalsIgnoreCase(STR)) { useSentenceNumber = Boolean.parseBoolean(val); } else if (key.equalsIgnoreCase(STR)) { useLabelSource = Boolean.parseBoolean(val); } else if (key.equalsIgnoreCase(STR)) { tokenFactory = val; } else if (key.equalsIgnoreCase(STR)) { tokensAnnotationClassName = val; } else if (key.equalsIgnoreCase(STR)) { useLVMorphoAnalyzer = Boolean.parseBoolean(val); } else if (key.equalsIgnoreCase(STR)) { lvMorphoAnalyzerTag = val; } else if (key.equalsIgnoreCase(STR)) { useLVMorphoAnalyzerPOS = Boolean.parseBoolean(val); } else if (key.equalsIgnoreCase(STR)) { useLVMorphoAnalyzerTag = Boolean.parseBoolean(val); } else if (key.equalsIgnoreCase(STR)) { useLVMorphoAnalyzerPrev = Boolean.parseBoolean(val); } else if (key.equalsIgnoreCase(STR)) { useLVMorphoAnalyzerNext = Boolean.parseBoolean(val); } else if (key.equalsIgnoreCase(STR)) { useLVMorphoAnalyzerItemIDs = Boolean.parseBoolean(val); } else if (key.equalsIgnoreCase(STR)) { useMorphologyFeatures = Boolean.parseBoolean(val); } else if (key.equalsIgnoreCase(STR)) { useMorphoCase = Boolean.parseBoolean(val); } else if (key.equalsIgnoreCase(STR)) { useMorphoPOS = Boolean.parseBoolean(val); } else if (key.equalsIgnoreCase(STR)) { useMorphoLetaLemma = Boolean.parseBoolean(val); } else if (key.equalsIgnoreCase(STR)) { useMorphoNumber = Boolean.parseBoolean(val); } else if (key.length() > 0 && !key.equals("prop")) { System.err.println(STR + key + ' '); } } if (startFold > numFolds) { System.err.println(STR); startFold = 1; } if (endFold > numFolds) { System.err.println(STR); endFold = numFolds; } if (combo) { splitDocuments = false; } stringRep = sb.toString(); } | /**
* Initialize using values in Properties file.
*
* @param props
* The properties object used for initialization
* @param printProps
* Whether to print the properties to stderr as it works.
*/ | Initialize using values in Properties file | setProperties | {
"repo_name": "PeterisP/LVTagger",
"path": "src/main/java/edu/stanford/nlp/sequences/SeqClassifierFlags.java",
"license": "gpl-2.0",
"size": 92782
} | [
"edu.stanford.nlp.optimization.StochasticCalculateMethods",
"edu.stanford.nlp.process.WordShapeClassifier",
"edu.stanford.nlp.util.ReflectionLoading",
"java.util.ArrayList",
"java.util.Enumeration",
"java.util.Properties",
"java.util.StringTokenizer"
] | import edu.stanford.nlp.optimization.StochasticCalculateMethods; import edu.stanford.nlp.process.WordShapeClassifier; import edu.stanford.nlp.util.ReflectionLoading; import java.util.ArrayList; import java.util.Enumeration; import java.util.Properties; import java.util.StringTokenizer; | import edu.stanford.nlp.optimization.*; import edu.stanford.nlp.process.*; import edu.stanford.nlp.util.*; import java.util.*; | [
"edu.stanford.nlp",
"java.util"
] | edu.stanford.nlp; java.util; | 900,304 |
public void testGetFileLinkPathForDeletedFile() throws IOException, SAXException {
final HashMap<String,Path> pathMap = createPathMap("rawchangelog-with-deleted-file");
final Path path = pathMap.get("bar");
final URL fileLink = bitbucketWeb.getFileLink(path);
assertEquals(BITBUCKET_URL + "/history/bar", String.valueOf(fileLink));
} | void function() throws IOException, SAXException { final HashMap<String,Path> pathMap = createPathMap(STR); final Path path = pathMap.get("bar"); final URL fileLink = bitbucketWeb.getFileLink(path); assertEquals(BITBUCKET_URL + STR, String.valueOf(fileLink)); } | /**
* Test method for {@link BitbucketWeb#getFileLink(hudson.plugins.git.GitChangeSet.Path)}.
* @throws org.xml.sax.SAXException
* @throws java.io.IOException
*/ | Test method for <code>BitbucketWeb#getFileLink(hudson.plugins.git.GitChangeSet.Path)</code> | testGetFileLinkPathForDeletedFile | {
"repo_name": "jglick/git-plugin",
"path": "src/test/java/hudson/plugins/git/browser/BitbucketWebTest.java",
"license": "mit",
"size": 5128
} | [
"hudson.plugins.git.GitChangeSet",
"java.io.IOException",
"java.util.HashMap",
"org.xml.sax.SAXException"
] | import hudson.plugins.git.GitChangeSet; import java.io.IOException; import java.util.HashMap; import org.xml.sax.SAXException; | import hudson.plugins.git.*; import java.io.*; import java.util.*; import org.xml.sax.*; | [
"hudson.plugins.git",
"java.io",
"java.util",
"org.xml.sax"
] | hudson.plugins.git; java.io; java.util; org.xml.sax; | 709,874 |
FlowScope getOutcomeFlowScope(int nodeType, boolean outcome) {
if (nodeType == Token.AND && outcome ||
nodeType == Token.OR && !outcome) {
// We know that the whole expression must have executed.
return rightScope;
} else {
return getJoinedFlowScope();
}
}
} | FlowScope getOutcomeFlowScope(int nodeType, boolean outcome) { if (nodeType == Token.AND && outcome nodeType == Token.OR && !outcome) { return rightScope; } else { return getJoinedFlowScope(); } } } | /**
* Gets the outcome scope if we do know the outcome of the entire
* expression.
*/ | Gets the outcome scope if we do know the outcome of the entire expression | getOutcomeFlowScope | {
"repo_name": "superkonduktr/closure-compiler",
"path": "src/com/google/javascript/jscomp/TypeInference.java",
"license": "apache-2.0",
"size": 64389
} | [
"com.google.javascript.jscomp.type.FlowScope",
"com.google.javascript.rhino.Token"
] | import com.google.javascript.jscomp.type.FlowScope; import com.google.javascript.rhino.Token; | import com.google.javascript.jscomp.type.*; import com.google.javascript.rhino.*; | [
"com.google.javascript"
] | com.google.javascript; | 2,211,348 |
private void simulateSkeleton() {
if (constraints != null && constraints.size() > 0) {
boolean applyStaticConstraints = true;
if (animations != null) {
TempVars vars = TempVars.get();
AnimChannel animChannel = animControl.createChannel();
for (Animation animation : animations) {
float[] animationTimeBoundaries = this.computeAnimationTimeBoundaries(animation);
int maxFrame = (int) animationTimeBoundaries[0];
float maxTime = animationTimeBoundaries[1];
Map<Integer, VirtualTrack> tracks = new HashMap<Integer, VirtualTrack>();
Map<Integer, Transform> previousTransforms = new HashMap<Integer, Transform>();
for (int frame = 0; frame < maxFrame; ++frame) {
// this MUST be done here, otherwise setting next frame of animation will
// lead to possible errors
this.reset();
// first set proper time for all bones in all the tracks ...
for (Track track : animation.getTracks()) {
float time = ((BoneTrack) track).getTimes()[frame];
Integer boneIndex = ((BoneTrack) track).getTargetBoneIndex();
track.setTime(time, 1, animControl, animChannel, vars);
skeleton.updateWorldVectors();
Transform previousTransform = previousTransforms.get(boneIndex);
if (previousTransform == null) {
Bone bone = skeleton.getBone(boneIndex);
previousTransform = new Transform();
previousTransform.setTranslation(bone.getLocalPosition());
previousTransform.setRotation(bone.getLocalRotation());
previousTransform.setScale(bone.getLocalScale());
previousTransforms.put(boneIndex, previousTransform);
}
}
// ... and then apply constraints ...
for (Constraint constraint : constraints) {
constraint.apply(frame);
}
// ... and fill in another frame in the result track
for (Track track : animation.getTracks()) {
Integer boneIndex = ((BoneTrack) track).getTargetBoneIndex();
Bone bone = skeleton.getBone(boneIndex);
// take the initial transform of a bone
Transform previousTransform = previousTransforms.get(boneIndex);
VirtualTrack vTrack = tracks.get(boneIndex);
if (vTrack == null) {
vTrack = new VirtualTrack(maxFrame, maxTime);
tracks.put(boneIndex, vTrack);
}
Vector3f bonePositionDifference = bone.getLocalPosition().subtract(previousTransform.getTranslation());
Quaternion boneRotationDifference = bone.getLocalRotation().mult(previousTransform.getRotation().inverse()).normalizeLocal();
Vector3f boneScaleDifference = bone.getLocalScale().divide(previousTransform.getScale());
if (frame > 0) {
bonePositionDifference = vTrack.translations.get(frame - 1).add(bonePositionDifference);
boneRotationDifference = vTrack.rotations.get(frame - 1).mult(boneRotationDifference);
boneScaleDifference = vTrack.scales.get(frame - 1).mult(boneScaleDifference);
}
vTrack.setTransform(frame, new Transform(bonePositionDifference, boneRotationDifference, boneScaleDifference));
previousTransform.setTranslation(bone.getLocalPosition());
previousTransform.setRotation(bone.getLocalRotation());
previousTransform.setScale(bone.getLocalScale());
}
}
for (Entry<Integer, VirtualTrack> trackEntry : tracks.entrySet()) {
Track newTrack = trackEntry.getValue().getAsBoneTrack(trackEntry.getKey());
if (newTrack != null) {
for (Track track : animation.getTracks()) {
if (((BoneTrack) track).getTargetBoneIndex() == trackEntry.getKey().intValue()) {
animation.removeTrack(track);
animation.addTrack(newTrack);
break;
}
}
}
applyStaticConstraints = false;
}
}
vars.release();
animControl.clearChannels();
this.reset();
}
// if there are no animations then just constraint the static
// object's transformation
if (applyStaticConstraints) {
for (Constraint constraint : constraints) {
constraint.apply(0);
}
}
}
} | void function() { if (constraints != null && constraints.size() > 0) { boolean applyStaticConstraints = true; if (animations != null) { TempVars vars = TempVars.get(); AnimChannel animChannel = animControl.createChannel(); for (Animation animation : animations) { float[] animationTimeBoundaries = this.computeAnimationTimeBoundaries(animation); int maxFrame = (int) animationTimeBoundaries[0]; float maxTime = animationTimeBoundaries[1]; Map<Integer, VirtualTrack> tracks = new HashMap<Integer, VirtualTrack>(); Map<Integer, Transform> previousTransforms = new HashMap<Integer, Transform>(); for (int frame = 0; frame < maxFrame; ++frame) { this.reset(); for (Track track : animation.getTracks()) { float time = ((BoneTrack) track).getTimes()[frame]; Integer boneIndex = ((BoneTrack) track).getTargetBoneIndex(); track.setTime(time, 1, animControl, animChannel, vars); skeleton.updateWorldVectors(); Transform previousTransform = previousTransforms.get(boneIndex); if (previousTransform == null) { Bone bone = skeleton.getBone(boneIndex); previousTransform = new Transform(); previousTransform.setTranslation(bone.getLocalPosition()); previousTransform.setRotation(bone.getLocalRotation()); previousTransform.setScale(bone.getLocalScale()); previousTransforms.put(boneIndex, previousTransform); } } for (Constraint constraint : constraints) { constraint.apply(frame); } for (Track track : animation.getTracks()) { Integer boneIndex = ((BoneTrack) track).getTargetBoneIndex(); Bone bone = skeleton.getBone(boneIndex); Transform previousTransform = previousTransforms.get(boneIndex); VirtualTrack vTrack = tracks.get(boneIndex); if (vTrack == null) { vTrack = new VirtualTrack(maxFrame, maxTime); tracks.put(boneIndex, vTrack); } Vector3f bonePositionDifference = bone.getLocalPosition().subtract(previousTransform.getTranslation()); Quaternion boneRotationDifference = bone.getLocalRotation().mult(previousTransform.getRotation().inverse()).normalizeLocal(); Vector3f boneScaleDifference = bone.getLocalScale().divide(previousTransform.getScale()); if (frame > 0) { bonePositionDifference = vTrack.translations.get(frame - 1).add(bonePositionDifference); boneRotationDifference = vTrack.rotations.get(frame - 1).mult(boneRotationDifference); boneScaleDifference = vTrack.scales.get(frame - 1).mult(boneScaleDifference); } vTrack.setTransform(frame, new Transform(bonePositionDifference, boneRotationDifference, boneScaleDifference)); previousTransform.setTranslation(bone.getLocalPosition()); previousTransform.setRotation(bone.getLocalRotation()); previousTransform.setScale(bone.getLocalScale()); } } for (Entry<Integer, VirtualTrack> trackEntry : tracks.entrySet()) { Track newTrack = trackEntry.getValue().getAsBoneTrack(trackEntry.getKey()); if (newTrack != null) { for (Track track : animation.getTracks()) { if (((BoneTrack) track).getTargetBoneIndex() == trackEntry.getKey().intValue()) { animation.removeTrack(track); animation.addTrack(newTrack); break; } } } applyStaticConstraints = false; } } vars.release(); animControl.clearChannels(); this.reset(); } if (applyStaticConstraints) { for (Constraint constraint : constraints) { constraint.apply(0); } } } } | /**
* Simulates the bone node.
*/ | Simulates the bone node | simulateSkeleton | {
"repo_name": "PlanetWaves/clockworkengine",
"path": "branches/3.0/engine/src/blender/com/clockwork/scene/plugins/blender/constraints/SimulationNode.java",
"license": "apache-2.0",
"size": 18526
} | [
"com.clockwork.animation.AnimChannel",
"com.clockwork.animation.Animation",
"com.clockwork.animation.Bone",
"com.clockwork.animation.BoneTrack",
"com.clockwork.animation.Track",
"com.clockwork.math.Quaternion",
"com.clockwork.math.Transform",
"com.clockwork.math.Vector3f",
"com.clockwork.util.TempVars",
"java.util.HashMap",
"java.util.Map"
] | import com.clockwork.animation.AnimChannel; import com.clockwork.animation.Animation; import com.clockwork.animation.Bone; import com.clockwork.animation.BoneTrack; import com.clockwork.animation.Track; import com.clockwork.math.Quaternion; import com.clockwork.math.Transform; import com.clockwork.math.Vector3f; import com.clockwork.util.TempVars; import java.util.HashMap; import java.util.Map; | import com.clockwork.animation.*; import com.clockwork.math.*; import com.clockwork.util.*; import java.util.*; | [
"com.clockwork.animation",
"com.clockwork.math",
"com.clockwork.util",
"java.util"
] | com.clockwork.animation; com.clockwork.math; com.clockwork.util; java.util; | 1,361,267 |
public final Property<HistoricalTimeSeriesMaster> historicalTimeSeriesMaster() {
return metaBean().historicalTimeSeriesMaster().createProperty(this);
} | final Property<HistoricalTimeSeriesMaster> function() { return metaBean().historicalTimeSeriesMaster().createProperty(this); } | /**
* Gets the the {@code historicalTimeSeriesMaster} property.
* @return the property, not null
*/ | Gets the the historicalTimeSeriesMaster property | historicalTimeSeriesMaster | {
"repo_name": "jeorme/OG-Platform",
"path": "projects/OG-Web/src/main/java/com/opengamma/web/historicaltimeseries/WebHistoricalTimeSeriesData.java",
"license": "apache-2.0",
"size": 17835
} | [
"com.opengamma.master.historicaltimeseries.HistoricalTimeSeriesMaster",
"org.joda.beans.Property"
] | import com.opengamma.master.historicaltimeseries.HistoricalTimeSeriesMaster; import org.joda.beans.Property; | import com.opengamma.master.historicaltimeseries.*; import org.joda.beans.*; | [
"com.opengamma.master",
"org.joda.beans"
] | com.opengamma.master; org.joda.beans; | 920,976 |
return CodeChangeSettings.class.equals(clazz);
}
/**
* {@inheritDoc} | return CodeChangeSettings.class.equals(clazz); } /** * {@inheritDoc} | /**
* This validator only supports {@link org.codeqinvest.quality.CodeChangeSettings} type.
*/ | This validator only supports <code>org.codeqinvest.quality.CodeChangeSettings</code> type | supports | {
"repo_name": "CodeQInvest/codeq-invest",
"path": "web-ui/src/main/java/org/codeqinvest/web/project/CodeChangeSettingsValidator.java",
"license": "gpl-3.0",
"size": 1824
} | [
"org.codeqinvest.quality.CodeChangeSettings"
] | import org.codeqinvest.quality.CodeChangeSettings; | import org.codeqinvest.quality.*; | [
"org.codeqinvest.quality"
] | org.codeqinvest.quality; | 1,371,957 |
void save(Data buff, FileStore file, UndoLog log) {
buff.reset();
append(buff, log);
filePos = (int) (file.getFilePointer() / Constants.FILE_BLOCK_SIZE);
file.write(buff.getBytes(), 0, buff.length());
row = null;
state = STORED;
} | void save(Data buff, FileStore file, UndoLog log) { buff.reset(); append(buff, log); filePos = (int) (file.getFilePointer() / Constants.FILE_BLOCK_SIZE); file.write(buff.getBytes(), 0, buff.length()); row = null; state = STORED; } | /**
* Save the row in the file using a buffer.
*
* @param buff the buffer
* @param file the file
* @param log the undo log
*/ | Save the row in the file using a buffer | save | {
"repo_name": "miloszpiglas/h2mod",
"path": "src/main/org/h2/engine/UndoLogRecord.java",
"license": "mpl-2.0",
"size": 7995
} | [
"org.h2.store.Data",
"org.h2.store.FileStore"
] | import org.h2.store.Data; import org.h2.store.FileStore; | import org.h2.store.*; | [
"org.h2.store"
] | org.h2.store; | 1,731,692 |
public long getTimeDurationHelper(String name, String vStr, TimeUnit unit) {
vStr = vStr.trim();
vStr = StringUtils.toLowerCase(vStr);
ParsedTimeDuration vUnit = ParsedTimeDuration.unitFor(vStr);
if (null == vUnit) {
logDeprecation("No unit for " + name + "(" + vStr + ") assuming " + unit);
vUnit = ParsedTimeDuration.unitFor(unit);
} else {
vStr = vStr.substring(0, vStr.lastIndexOf(vUnit.suffix()));
}
long raw = Long.parseLong(vStr);
long converted = unit.convert(raw, vUnit.unit());
if (vUnit.unit().convert(converted, unit) < raw) {
logDeprecation(
"Possible loss of precision converting "
+ vStr
+ vUnit.suffix()
+ " to "
+ unit
+ " for "
+ name);
}
return converted;
} | long function(String name, String vStr, TimeUnit unit) { vStr = vStr.trim(); vStr = StringUtils.toLowerCase(vStr); ParsedTimeDuration vUnit = ParsedTimeDuration.unitFor(vStr); if (null == vUnit) { logDeprecation(STR + name + "(" + vStr + STR + unit); vUnit = ParsedTimeDuration.unitFor(unit); } else { vStr = vStr.substring(0, vStr.lastIndexOf(vUnit.suffix())); } long raw = Long.parseLong(vStr); long converted = unit.convert(raw, vUnit.unit()); if (vUnit.unit().convert(converted, unit) < raw) { logDeprecation( STR + vStr + vUnit.suffix() + STR + unit + STR + name); } return converted; } | /**
* Return time duration in the given time unit. Valid units are encoded in properties as
* suffixes: nanoseconds (ns), microseconds (us), milliseconds (ms), seconds (s), minutes (m),
* hours (h), and days (d).
*
* @param name Property name
* @param vStr The string value with time unit suffix to be converted.
* @param unit Unit to convert the stored property, if it exists.
*/ | Return time duration in the given time unit. Valid units are encoded in properties as suffixes: nanoseconds (ns), microseconds (us), milliseconds (ms), seconds (s), minutes (m), hours (h), and days (d) | getTimeDurationHelper | {
"repo_name": "apache/flink",
"path": "flink-filesystems/flink-fs-hadoop-shaded/src/main/java/org/apache/hadoop/conf/Configuration.java",
"license": "apache-2.0",
"size": 134180
} | [
"java.util.concurrent.TimeUnit",
"org.apache.hadoop.util.StringUtils"
] | import java.util.concurrent.TimeUnit; import org.apache.hadoop.util.StringUtils; | import java.util.concurrent.*; import org.apache.hadoop.util.*; | [
"java.util",
"org.apache.hadoop"
] | java.util; org.apache.hadoop; | 1,962,119 |
@Selector
public void getSessionsForDeviceOwner(Person teacher, HttpRequest request) {
Transaction tx = teacher.tx().getPackage().connect(teacher);
try {
// The device's label is included in the request and the
// device should be retrieved using the label.
Device device = (Device) APIUtils.getObjectFromRequest("Device", teacher.tx(), request);
// Retrieve devices owned by this owner
Iterable<Device> devices = Persons.getOwnedDevices(teacher.tx(), teacher);
if (device != null) { // If device is not null, check if the device
// is owned by the teacher or not
boolean contains = false;
for (Device d : devices)
if (d.equals(device)) {
contains = true;
break;
}
if (!contains) {
RealmResponse.send(request, 403, "User is not authorized to access this device");
return;
}
// Retrieve the sessions for this device and add them to
// response
Iterable<Session> sessions = Devices.getSessions(tx, device);
APIUtils.addQueryResultToResponse(sessions, request);
} else { // Retrieve sessions for all devices owned by this owner
// and add them to response
ArrayList<Session> sessions = new ArrayList<Session>();
for (Device d : devices) {
Iterable<Session> deviceSessions = Devices.getSessions(tx, d);
for (Session s : deviceSessions) {
if (!sessions.contains(s)) sessions.add(s);
}
}
// Add sessions to response
APIUtils.addQueryResultToResponse(sessions, request);
}
}
catch (IOException e) {
e.printStackTrace();
}
finally {
tx.close();
}
} | void function(Person teacher, HttpRequest request) { Transaction tx = teacher.tx().getPackage().connect(teacher); try { Device device = (Device) APIUtils.getObjectFromRequest(STR, teacher.tx(), request); Iterable<Device> devices = Persons.getOwnedDevices(teacher.tx(), teacher); if (device != null) { boolean contains = false; for (Device d : devices) if (d.equals(device)) { contains = true; break; } if (!contains) { RealmResponse.send(request, 403, STR); return; } Iterable<Session> sessions = Devices.getSessions(tx, device); APIUtils.addQueryResultToResponse(sessions, request); } else { ArrayList<Session> sessions = new ArrayList<Session>(); for (Device d : devices) { Iterable<Session> deviceSessions = Devices.getSessions(tx, d); for (Session s : deviceSessions) { if (!sessions.contains(s)) sessions.add(s); } } APIUtils.addQueryResultToResponse(sessions, request); } } catch (IOException e) { e.printStackTrace(); } finally { tx.close(); } } | /**
* Is called by a teacher user to get the list of sessions for a device. The
* teacher should be the owner of the device. If the deivce is null, the
* method finds the sessions for all devices owned by the teacher
*
* @param teacher
* The Person object containing the teacher info
* @param request
* The http request containing the device info
*/ | Is called by a teacher user to get the list of sessions for a device. The teacher should be the owner of the device. If the deivce is null, the method finds the sessions for all devices owned by the teacher | getSessionsForDeviceOwner | {
"repo_name": "whilkes/realm-platform",
"path": "api/src/main/java/net/realmproject/platform/api/ITeacherAPIReceiver.java",
"license": "gpl-3.0",
"size": 22648
} | [
"java.io.IOException",
"java.util.ArrayList",
"net.objectof.corc.web.v2.HttpRequest",
"net.objectof.model.Transaction",
"net.realmproject.platform.api.utils.APIUtils",
"net.realmproject.platform.schema.Device",
"net.realmproject.platform.schema.Person",
"net.realmproject.platform.schema.Session",
"net.realmproject.platform.util.RealmResponse",
"net.realmproject.platform.util.model.Devices",
"net.realmproject.platform.util.model.Persons"
] | import java.io.IOException; import java.util.ArrayList; import net.objectof.corc.web.v2.HttpRequest; import net.objectof.model.Transaction; import net.realmproject.platform.api.utils.APIUtils; import net.realmproject.platform.schema.Device; import net.realmproject.platform.schema.Person; import net.realmproject.platform.schema.Session; import net.realmproject.platform.util.RealmResponse; import net.realmproject.platform.util.model.Devices; import net.realmproject.platform.util.model.Persons; | import java.io.*; import java.util.*; import net.objectof.corc.web.v2.*; import net.objectof.model.*; import net.realmproject.platform.api.utils.*; import net.realmproject.platform.schema.*; import net.realmproject.platform.util.*; import net.realmproject.platform.util.model.*; | [
"java.io",
"java.util",
"net.objectof.corc",
"net.objectof.model",
"net.realmproject.platform"
] | java.io; java.util; net.objectof.corc; net.objectof.model; net.realmproject.platform; | 2,167,393 |
public float setupProgress() throws IOException; | float function() throws IOException; | /**
* Get the <i>progress</i> of the job's setup-tasks, as a float between 0.0
* and 1.0. When all setup tasks have completed, the function returns 1.0.
*
* @return the progress of the job's setup-tasks.
* @throws IOException
*/ | Get the progress of the job's setup-tasks, as a float between 0.0 and 1.0. When all setup tasks have completed, the function returns 1.0 | setupProgress | {
"repo_name": "apache/hadoop-common",
"path": "src/mapred/org/apache/hadoop/mapred/RunningJob.java",
"license": "apache-2.0",
"size": 5750
} | [
"java.io.IOException"
] | import java.io.IOException; | import java.io.*; | [
"java.io"
] | java.io; | 238,243 |
public SamlSpMetadataBuilder signingCertificate(X509Certificate signingCertificate) {
this.signingCertificate = signingCertificate;
return this;
} | SamlSpMetadataBuilder function(X509Certificate signingCertificate) { this.signingCertificate = signingCertificate; return this; } | /**
* The certificate that the service provider users to sign SAML requests.
*/ | The certificate that the service provider users to sign SAML requests | signingCertificate | {
"repo_name": "robin13/elasticsearch",
"path": "x-pack/plugin/security/src/main/java/org/elasticsearch/xpack/security/authc/saml/SamlSpMetadataBuilder.java",
"license": "apache-2.0",
"size": 18509
} | [
"java.security.cert.X509Certificate"
] | import java.security.cert.X509Certificate; | import java.security.cert.*; | [
"java.security"
] | java.security; | 2,531,206 |
private void initialize() {
frame = new JFrame();
frame.setIconImage(Toolkit.getDefaultToolkit().getImage(
ArmasNPC.class
.getResource("/images/Historias de Zagas, logo.png")));
frame.setTitle("Historias de Zagas");
frame.setBounds(100, 100, 380, 301);
frame.setLocationRelativeTo(null);
frame.setDefaultCloseOperation(JFrame.DO_NOTHING_ON_CLOSE);
frame.setResizable(false);
frame.getContentPane().setLayout(null);
txtDescripcin = new JTextField();
txtDescripcin.setOpaque(false);
txtDescripcin.setForeground(Color.WHITE);
txtDescripcin.setBackground(new Color(205, 133, 63));
txtDescripcin.setText("Descripci\u00F3n:");
txtDescripcin.setFont(mf.MyFont(0, 13));
txtDescripcin.setEditable(false);
txtDescripcin.setColumns(10);
txtDescripcin.setBorder(null);
txtDescripcin.setBounds(135, 20, 90, 20);
frame.getContentPane().add(txtDescripcin);
JScrollPane scrollPane = new JScrollPane();
scrollPane.setBounds(135, 51, 221, 99);
frame.getContentPane().add(scrollPane);
JTextArea textArea = new JTextArea();
textArea.setBackground(Color.WHITE);
textArea.setForeground(new Color(0, 0, 0));
textArea.setFont(mf.MyFont(0, 13));
textArea.setLineWrap(true);
textArea.setWrapStyleWord(true);
textArea.setEditable(false);
scrollPane.setViewportView(textArea);
JScrollPane scrollPane_1 = new JScrollPane();
scrollPane_1.setBounds(135, 153, 221, 99);
frame.getContentPane().add(scrollPane_1);
JTextArea textArea_1 = new JTextArea();
textArea_1.setBackground(Color.WHITE);
textArea_1.setForeground(new Color(0, 0, 0));
textArea_1.setWrapStyleWord(true);
textArea_1.setText("");
textArea_1.setLineWrap(true);
textArea_1.setFont(mf.MyFont(0, 13));
textArea_1.setEditable(false);
scrollPane_1.setViewportView(textArea_1);
if (ModificarEquipo.accesories3.isPosesion() == true || ModificarEquipo.accesories3.isLegendaria() == true) {
ArrayList<String> pos = ModificarEquipo.accesories3.getPossesion()
.getPos();
for (int i = 0; i < pos.size(); i++) {
if (pos.get(i) != ("-Propiedad-")) {
textArea_1.append(pos.get(i) + "\n");
}
}
}
txtTipoDeAccesorio = new JTextField();
txtTipoDeAccesorio.setOpaque(false);
txtTipoDeAccesorio.setForeground(Color.WHITE);
txtTipoDeAccesorio.setBackground(new Color(205, 133, 63));
txtTipoDeAccesorio.setText("Tipo de Accesorio:");
txtTipoDeAccesorio.setFont(mf.MyFont(0, 13));
txtTipoDeAccesorio.setEditable(false);
txtTipoDeAccesorio.setColumns(10);
txtTipoDeAccesorio.setBorder(null);
txtTipoDeAccesorio.setBounds(10, 20, 115, 20);
frame.getContentPane().add(txtTipoDeAccesorio);
textField = new JTextField();
textField.setForeground(new Color(0, 0, 0));
textField.setBackground(Color.WHITE);
textField.setEditable(false);
textField.setFont(mf.MyFont(0, 11));
textField.setColumns(10);
textField.setBounds(10, 51, 115, 20);
frame.getContentPane().add(textField);
| void function() { frame = new JFrame(); frame.setIconImage(Toolkit.getDefaultToolkit().getImage( ArmasNPC.class .getResource(STR))); frame.setTitle(STR); frame.setBounds(100, 100, 380, 301); frame.setLocationRelativeTo(null); frame.setDefaultCloseOperation(JFrame.DO_NOTHING_ON_CLOSE); frame.setResizable(false); frame.getContentPane().setLayout(null); txtDescripcin = new JTextField(); txtDescripcin.setOpaque(false); txtDescripcin.setForeground(Color.WHITE); txtDescripcin.setBackground(new Color(205, 133, 63)); txtDescripcin.setText(STR); txtDescripcin.setFont(mf.MyFont(0, 13)); txtDescripcin.setEditable(false); txtDescripcin.setColumns(10); txtDescripcin.setBorder(null); txtDescripcin.setBounds(135, 20, 90, 20); frame.getContentPane().add(txtDescripcin); JScrollPane scrollPane = new JScrollPane(); scrollPane.setBounds(135, 51, 221, 99); frame.getContentPane().add(scrollPane); JTextArea textArea = new JTextArea(); textArea.setBackground(Color.WHITE); textArea.setForeground(new Color(0, 0, 0)); textArea.setFont(mf.MyFont(0, 13)); textArea.setLineWrap(true); textArea.setWrapStyleWord(true); textArea.setEditable(false); scrollPane.setViewportView(textArea); JScrollPane scrollPane_1 = new JScrollPane(); scrollPane_1.setBounds(135, 153, 221, 99); frame.getContentPane().add(scrollPane_1); JTextArea textArea_1 = new JTextArea(); textArea_1.setBackground(Color.WHITE); textArea_1.setForeground(new Color(0, 0, 0)); textArea_1.setWrapStyleWord(true); textArea_1.setText(STR-Propiedad-STR\nSTRTipo de Accesorio:"); txtTipoDeAccesorio.setFont(mf.MyFont(0, 13)); txtTipoDeAccesorio.setEditable(false); txtTipoDeAccesorio.setColumns(10); txtTipoDeAccesorio.setBorder(null); txtTipoDeAccesorio.setBounds(10, 20, 115, 20); frame.getContentPane().add(txtTipoDeAccesorio); textField = new JTextField(); textField.setForeground(new Color(0, 0, 0)); textField.setBackground(Color.WHITE); textField.setEditable(false); textField.setFont(mf.MyFont(0, 11)); textField.setColumns(10); textField.setBounds(10, 51, 115, 20); frame.getContentPane().add(textField); | /**
* Initialize the contents of the frame.
*/ | Initialize the contents of the frame | initialize | {
"repo_name": "ZagasTales/HistoriasdeZagas",
"path": "src Graf/es/thesinsprods/zagastales/juegozagas/jugar/master/InfoAcc3NPC.java",
"license": "cc0-1.0",
"size": 7615
} | [
"java.awt.Color",
"java.awt.Toolkit",
"javax.swing.JFrame",
"javax.swing.JScrollPane",
"javax.swing.JTextArea",
"javax.swing.JTextField"
] | import java.awt.Color; import java.awt.Toolkit; import javax.swing.JFrame; import javax.swing.JScrollPane; import javax.swing.JTextArea; import javax.swing.JTextField; | import java.awt.*; import javax.swing.*; | [
"java.awt",
"javax.swing"
] | java.awt; javax.swing; | 1,686,327 |
static boolean nodeTypeMayHaveSideEffects(Node n) {
return nodeTypeMayHaveSideEffects(n, null);
} | static boolean nodeTypeMayHaveSideEffects(Node n) { return nodeTypeMayHaveSideEffects(n, null); } | /**
* Returns true if the current node's type implies side effects.
*
* This is a non-recursive version of the may have side effects
* check; used to check wherever the current node's type is one of
* the reason's why a subtree has side effects.
*/ | Returns true if the current node's type implies side effects. This is a non-recursive version of the may have side effects check; used to check wherever the current node's type is one of the reason's why a subtree has side effects | nodeTypeMayHaveSideEffects | {
"repo_name": "007slm/kissy",
"path": "tools/module-compiler/src/com/google/javascript/jscomp/NodeUtil.java",
"license": "mit",
"size": 77263
} | [
"com.google.javascript.rhino.Node"
] | import com.google.javascript.rhino.Node; | import com.google.javascript.rhino.*; | [
"com.google.javascript"
] | com.google.javascript; | 2,186,516 |
public VendorCreditMemoDocument getCreditMemoDocumentById(Integer purchasingDocumentIdentifier); | VendorCreditMemoDocument function(Integer purchasingDocumentIdentifier); | /**
* Retrieves the Credit Memo document by the purapDocumentIdentifier.
*
* @param purchasingDocumentIdentifier The purapDocumentIdentifier of the credit memo to be retrieved.
* @return The credit memo document whose purapDocumentIdentifier matches the input parameter.
*/ | Retrieves the Credit Memo document by the purapDocumentIdentifier | getCreditMemoDocumentById | {
"repo_name": "bhutchinson/kfs",
"path": "kfs-purap/src/main/java/org/kuali/kfs/module/purap/document/service/CreditMemoService.java",
"license": "agpl-3.0",
"size": 7182
} | [
"org.kuali.kfs.module.purap.document.VendorCreditMemoDocument"
] | import org.kuali.kfs.module.purap.document.VendorCreditMemoDocument; | import org.kuali.kfs.module.purap.document.*; | [
"org.kuali.kfs"
] | org.kuali.kfs; | 991,290 |
@Pure
@Inline(value = "$3.compare($1, $2)", constantExpression = true, imported = Integer.class)
public static int operator_spaceship(short left, int right) {
return Integer.compare(left, right);
} | @Inline(value = STR, constantExpression = true, imported = Integer.class) static int function(short left, int right) { return Integer.compare(left, right); } | /** The number comparison operator. This is equivalent to the Java
* {@code compareTo} function on numbers. This function is null-safe.
*
* @param left a number
* @param right a number.
* @return the value {@code 0} if {@code left == right};
* a value less than {@code 0} if {@code left < right}; and
* a value greater than {@code 0} if {@code left > right}.
*/ | The number comparison operator. This is equivalent to the Java compareTo function on numbers. This function is null-safe | operator_spaceship | {
"repo_name": "sarl/sarl",
"path": "main/coreplugins/io.sarl.lang.core/src/io/sarl/lang/scoping/extensions/numbers/comparison/PrimitiveShortComparisonExtensions.java",
"license": "apache-2.0",
"size": 13360
} | [
"org.eclipse.xtext.xbase.lib.Inline"
] | import org.eclipse.xtext.xbase.lib.Inline; | import org.eclipse.xtext.xbase.lib.*; | [
"org.eclipse.xtext"
] | org.eclipse.xtext; | 138,410 |
public ControllerAxis getAxis(Driver driver, Axis.Type axisType) throws Exception {
ControllerAxis found = null;
for (ControllerAxis axis : getAxes(driver)) {
if (axis.getType() == axisType) {
if (found != null) {
// Make this future-proof:
// Getting axes by type will no longer be allowed inside motion blending applications.
throw new Exception("Axes "+found.getName()+" and "+axis.getName()+" have duplicate type "+axisType+" assigned.");
}
found = axis;
}
}
return found;
} | ControllerAxis function(Driver driver, Axis.Type axisType) throws Exception { ControllerAxis found = null; for (ControllerAxis axis : getAxes(driver)) { if (axis.getType() == axisType) { if (found != null) { throw new Exception(STR+found.getName()+STR+axis.getName()+STR+axisType+STR); } found = axis; } } return found; } | /**
* From the AxisLocation, return the driver axis of the given type.
*
* @param driver
* @param axisType
* @return
* @throws Exception
*/ | From the AxisLocation, return the driver axis of the given type | getAxis | {
"repo_name": "openpnp/openpnp",
"path": "src/main/java/org/openpnp/model/AxesLocation.java",
"license": "gpl-3.0",
"size": 23830
} | [
"org.openpnp.spi.Axis",
"org.openpnp.spi.ControllerAxis",
"org.openpnp.spi.Driver"
] | import org.openpnp.spi.Axis; import org.openpnp.spi.ControllerAxis; import org.openpnp.spi.Driver; | import org.openpnp.spi.*; | [
"org.openpnp.spi"
] | org.openpnp.spi; | 2,094,882 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.