_id stringlengths 2 7 | title stringlengths 3 140 | partition stringclasses 3
values | text stringlengths 73 34.1k | language stringclasses 1
value | meta_information dict |
|---|---|---|---|---|---|
q16400 | BasicRandomRoutingTable.removeNeighbors | train | @Override
public void removeNeighbors(final Collection<TrustGraphNodeId> neighbors) {
synchronized(this) {
// remove the neighbors from the ordering in bulk
removeNeighborsFromOrdering(neighbors);
// just loop over the neighbors and use the single removal operation.
for (TrustGraphNodeId n : neighbors) { removeNeighborFromRoutingTable(n); }
}
} | java | {
"resource": ""
} |
q16401 | BasicRandomRoutingTable.addNeighborToOrdering | train | protected void addNeighborToOrdering(TrustGraphNodeId neighbor) {
int position = rng.nextInt(orderedNeighbors.size()+1);
if (position == orderedNeighbors.size()) {
orderedNeighbors.add(neighbor);
}
else {
orderedNeighbors.add(position, neighbor);
}
} | java | {
"resource": ""
} |
q16402 | BasicRandomRoutingTable.snapshot | train | @Override
public RandomRoutingTable.Snapshot snapshot() {
// block modification operations while creating the snapshot
synchronized (this) {
return new Snapshot(new HashMap<TrustGraphNodeId,TrustGraphNodeId>(routingTable),
new ArrayList<TrustGraphNodeId>(orderedNeighbors));
}
} | java | {
"resource": ""
} |
q16403 | P3Parse.getStates | train | public List<IncEvalState> getStates() {
List<IncEvalState> states = Lists.newArrayList();
getStatesHelper(states);
return states;
} | java | {
"resource": ""
} |
q16404 | Cron4jTask.actuallyExecute | train | protected RunnerResult actuallyExecute(JobIdentityAttr identityProvider, String cronExp, VaryingCronOption cronOption,
TaskExecutionContext context, OptionalThing<LaunchNowOption> nowOption) { // in synchronized world
adjustThreadNameIfNeeds(cronOption);
return runJob(identityProvider, cronExp, cronOption, context, nowOption);
} | java | {
"resource": ""
} |
q16405 | TrustGraphNode.forwardAdvertisement | train | protected boolean forwardAdvertisement(TrustGraphAdvertisement message) {
// don't forward if the forwarding policy rejects
if (!shouldForward(message)) {
return false;
}
// determine the next hop to send to
TrustGraphNodeId nextHop = getRoutingTable().getNextHop(message);
// if there is no next hop, reject
if (nextHop == null) {
return false;
}
// forward the message to the next node on the route
// with ttl decreased by 1
sendAdvertisement(message, nextHop, message.getInboundTTL() - 1);
return true;
} | java | {
"resource": ""
} |
q16406 | AuthManager.getUserFromAuthToken | train | public Observable<BackendUser> getUserFromAuthToken(final String authToken){
return Observable.create(new Observable.OnSubscribe<BackendUser>() {
@Override
public void call(Subscriber<? super BackendUser> subscriber) {
try{
setLoginState(LOGGING_IN);
logger.debug("getWebService(): " + getWebService());
logger.debug("getuserFromAuthToken: " + authToken);
ValidCredentials validCredentials = getWebService().getUserFromAuthToken(authToken).toBlocking().first();
if(validCredentials == null) throw new Exception("Null User Returned");
subscriber.onNext(setUser(validCredentials));
}catch (Exception e){
setLoginState(LOGGED_OUT);
subscriber.onError(e);
}
}
});
} | java | {
"resource": ""
} |
q16407 | AuthManager.getUserFromRecoveryToken | train | public Observable<BackendUser> getUserFromRecoveryToken(final String recoveryToken){
return Observable.create(new Observable.OnSubscribe<BackendUser>() {
@Override
public void call(Subscriber<? super BackendUser> subscriber) {
try{
setLoginState(LOGGING_IN);
ValidCredentials validCredentials = getWebService().getUserFromRecoveryToken(recoveryToken).toBlockingObservable().first();
if(validCredentials == null) throw new Exception("Null User Returned");
subscriber.onNext(setUser(validCredentials));
}catch (Exception e){
setLoginState(LOGGED_OUT);
subscriber.onError(e);
}
}
});
} | java | {
"resource": ""
} |
q16408 | AuthManager.logout | train | public void logout(){
List<LocalCredentials> accountList = accountStorage.getAccounts();
if(accountList.size() == 1){
String userName = accountList.get(0).getName();
logger.debug("logout: " + userName);
accountStorage.removeAccount(userName);
user = null;
}
setLoginState(LoginState.LOGGED_OUT);
} | java | {
"resource": ""
} |
q16409 | AuthManager.getServerKey | train | public PublicKey getServerKey(){
logger.debug("getServerKey()");
try {
if(serverPublicKey!=null) return serverPublicKey;
byte[] pubKey = getWebService().getPublicKey();
logger.debug("pubKey: " + String.valueOf(pubKey));
serverPublicKey = Crypto.pubKeyFromBytes(pubKey);
return serverPublicKey;
} catch (Exception e) {
logger.error("Failed to getServerKey()", e);
}
return null;
} | java | {
"resource": ""
} |
q16410 | AuthManager.signUp | train | public SignUpResponse signUp(SignUpCredentials loginCreds){
logger.debug("signUp(" + loginCreds + ")");
try {
setLoginState(LOGGING_IN);
PublicKey key = Crypto.pubKeyFromBytes(getWebService().getPublicKey());
loginCreds.encryptPassword(key);
logger.debug("Login Creds: " + loginCreds);
ServerResponse<ValidCredentials> response = ServerResponse.from(ValidCredentials.class, getWebService().userSignUp(loginCreds));
logger.debug("Response: " + response.getStatus());
BackendUser user;
if (response.getStatus().isSuccess()) {
user = setUser(response.get());
} else {
return new SignUpResponse(null, Status.SERVER_ERROR_INTERNAL, " null user returned");
}
return new SignUpResponse(user, response.getStatus(), response.getError());
} catch (Exception e) {
logger.error("SignUp Failure(" + loginCreds.getEmailAddress() + ")", e);
return new SignUpResponse(null, Status.SERVER_ERROR_INTERNAL, e.getLocalizedMessage());
}
} | java | {
"resource": ""
} |
q16411 | AuthManager.signUpASync | train | public Observable<BackendUser> signUpASync(final SignUpCredentials signInCreds){
logger.debug("signUpASync("+signInCreds+")");
try {
setLoginState(LOGGING_IN);
return getWebService().getPublicKeyA().flatMap(new Func1<byte[], Observable<SignUpCredentials>>() {
@Override
public Observable<SignUpCredentials> call(byte[] bytes) {
try {
PublicKey key = Crypto.pubKeyFromBytes(bytes);
signInCreds.encryptPassword(key);
return Observable.from(signInCreds);
}catch (Exception e) {
return Observable.error(e);
}
}
}).flatMap(new Func1<SignUpCredentials, Observable<ValidCredentials>>() {
@Override
public Observable<ValidCredentials> call(SignUpCredentials o) {
return getWebService().userSignUpA(signInCreds);
}
}).map(new Func1<ValidCredentials, BackendUser>() {
@Override
public BackendUser call(ValidCredentials validCredentials) {
return setUser(validCredentials);
}
})
.subscribeOn(Schedulers.io()).observeOn(config.observeOn());
} catch (Exception e) {
logger.error("Failed to signUp(" + signInCreds.getEmailAddress() + ")", e);
return Observable.error(e);
}
} | java | {
"resource": ""
} |
q16412 | AuthManager.login | train | public SignInResponse login(final LoginCredentials loginCreds){
logger.debug("login("+loginCreds+")");
try{
setLoginState(LOGGING_IN);
if(!loginCreds.isEncrypted()){
PublicKey key = Crypto.pubKeyFromBytes(getWebService().getPublicKey());
loginCreds.encryptPassword(key);
}
logger.debug("Login Creds: " + loginCreds);
ServerResponse<ValidCredentials> response = ServerResponse.from(ValidCredentials.class,getWebService().login(loginCreds));
BackendUser user;
if(response.getStatus().isSuccess()){
user = setUser(response.get());
} else {
logger.error("Login Failure("+loginCreds.getEmailAddress()+"): " + response.getStatus().getCode() + " " + response.getError());
setLoginState(LOGGED_OUT);
return new SignInResponse(null, Status.SERVER_ERROR_INTERNAL,"Login failed");
}
return new SignInResponse(user,response.getStatus(),response.getError());
}catch (Exception e){
logger.error("Login Failure("+loginCreds.getEmailAddress()+")",e);
setLoginState(LOGGED_OUT);
return new SignInResponse(null, Status.SERVER_ERROR_INTERNAL,e.getLocalizedMessage());
}
} | java | {
"resource": ""
} |
q16413 | AuthManager.loginASync | train | public Observable<BackendUser> loginASync(final LoginCredentials loginCreds){
logger.debug("loginASync("+loginCreds+")");
try{
setLoginState(LOGGING_IN);
return getWebService().getPublicKeyA().flatMap(new Func1<byte[], Observable<LoginCredentials>>() {
@Override
public Observable<LoginCredentials> call(byte[] bytes) {
try {
if (!loginCreds.isEncrypted()) {
PublicKey key = Crypto.pubKeyFromBytes(bytes);
loginCreds.encryptPassword(key);
}
return Observable.from(loginCreds);
} catch (Exception e) {
return Observable.error(e);
}
}
}).flatMap(new Func1<LoginCredentials, Observable<ValidCredentials>>() {
@Override
public Observable<ValidCredentials> call(LoginCredentials credentials) {
return getWebService().loginA(credentials);
}
}).map(new Func1<ValidCredentials, BackendUser>() {
@Override
public BackendUser call(ValidCredentials validCredentials) {
return setUser(validCredentials);
}
})
.subscribeOn(Schedulers.io()).observeOn(config.observeOn());
}catch (Exception e){
logger.error("Failed to SignIn("+loginCreds.getEmailAddress()+")",e);
setLoginState(LOGGED_OUT);
return Observable.error(e);
}
} | java | {
"resource": ""
} |
q16414 | AuthManager.sendUserData | train | public Observable<Void> sendUserData(BackendUser backendUser){
return getWebService().sendUserData(isLoggedIn(),backendUser.getOwnerId()+"",backendUser.getUserData())
.subscribeOn(config.subscribeOn()).observeOn(config.observeOn());
} | java | {
"resource": ""
} |
q16415 | AuthManager.getUserData | train | public Observable<Map<String,Object>> getUserData(BackendUser backendUser){
return getWebService().getUserData(isLoggedIn(), backendUser.getOwnerId() + "")
.subscribeOn(config.subscribeOn()).observeOn(config.observeOn());
} | java | {
"resource": ""
} |
q16416 | AuthManager.addLoginListener | train | public void addLoginListener(LoginListener listener){
logger.debug("addLoginListener");
Subscription subscription = loginEventPublisher
.subscribeOn(config.subscribeOn())
.observeOn(config.observeOn())
.subscribe(listener);
listener.setSubscription(subscription);
} | java | {
"resource": ""
} |
q16417 | AbstractCli.processOptions | train | private void processOptions(OptionSet options) {
Pseudorandom.get().setSeed(options.valueOf(randomSeed));
if (opts.contains(CommonOptions.MAP_REDUCE)) {
MapReduceConfiguration.setMapReduceExecutor(new LocalMapReduceExecutor(
options.valueOf(mrMaxThreads), options.valueOf(mrMaxBatchesPerThread)));
}
if (opts.contains(CommonOptions.STOCHASTIC_GRADIENT) || opts.contains(CommonOptions.LBFGS)) {
LogFunction log = null;
if (parsedOptions.has(logBrief)) {
log = new NullLogFunction();
} else {
log = new DefaultLogFunction(parsedOptions.valueOf(logInterval), false,
options.valueOf(logParametersInterval), options.valueOf(logParametersDir));
}
LogFunctions.setLogFunction(log);
}
} | java | {
"resource": ""
} |
q16418 | ByteArray.toBase64 | train | public static String toBase64(byte[] byteArray) {
String result = null;
if (byteArray != null) {
result = Base64.encodeBase64String(byteArray);
}
return result;
} | java | {
"resource": ""
} |
q16419 | ByteArray.fromBase64 | train | public static byte[] fromBase64(String base64String) {
byte[] result = null;
if (base64String != null) {
result = Base64.decodeBase64(base64String);
}
return result;
} | java | {
"resource": ""
} |
q16420 | ByteArray.fromString | train | public static byte[] fromString(String unicodeString) {
byte[] result = null;
if (unicodeString != null) {
result = unicodeString.getBytes(StandardCharsets.UTF_8);
}
return result;
} | java | {
"resource": ""
} |
q16421 | TypeInference.infer | train | public void infer() {
scopes = StaticAnalysis.getScopes(expression);
expressionTypes = Maps.newHashMap();
constraints = ConstraintSet.empty();
for (Scope scope : scopes.getScopes()) {
for (String variable : scope.getBoundVariables()) {
int location = scope.getBindingIndex(variable);
if (!expressionTypes.containsKey(location)) {
expressionTypes.put(location, constraints.getFreshTypeVar());
}
}
}
populateExpressionTypes(0);
// TODO: root type.
solved = constraints.solve(typeDeclaration);
for (int k : expressionTypes.keySet()) {
expressionTypes.put(k, expressionTypes.get(k).substitute(solved.getBindings()));
}
} | java | {
"resource": ""
} |
q16422 | Crypto.concat | train | private static byte[] concat(byte[] a, byte[] b)
{
byte[] c = new byte[a.length + b.length];
System.arraycopy(a, 0, c, 0, a.length);
System.arraycopy(b, 0, c, a.length, b.length);
return c;
} | java | {
"resource": ""
} |
q16423 | CcgSyntaxTree.getAllSpannedLexiconEntries | train | public List<SyntacticCategory> getAllSpannedLexiconEntries() {
List<SyntacticCategory> categories = Lists.newArrayList();
getAllSpannedLexiconEntriesHelper(categories);
return categories;
} | java | {
"resource": ""
} |
q16424 | Base64.encodeEnternal | train | private static byte[] encodeEnternal(byte[] d)
{
if (d == null) return null;
byte data[] = new byte[d.length+2];
System.arraycopy(d, 0, data, 0, d.length);
byte dest[] = new byte[(data.length/3)*4];
// 3-byte to 4-byte conversion
for (int sidx = 0, didx=0; sidx < d.length; sidx += 3, didx += 4)
{
dest[didx] = (byte) ((data[sidx] >>> 2) & 077);
dest[didx+1] = (byte) ((data[sidx+1] >>> 4) & 017 |
(data[sidx] << 4) & 077);
dest[didx+2] = (byte) ((data[sidx+2] >>> 6) & 003 |
(data[sidx+1] << 2) & 077);
dest[didx+3] = (byte) (data[sidx+2] & 077);
}
// 0-63 to ascii printable conversion
for (int idx = 0; idx <dest.length; idx++)
{
if (dest[idx] < 26) dest[idx] = (byte)(dest[idx] + 'A');
else if (dest[idx] < 52) dest[idx] = (byte)(dest[idx] + 'a' - 26);
else if (dest[idx] < 62) dest[idx] = (byte)(dest[idx] + '0' - 52);
else if (dest[idx] < 63) dest[idx] = (byte)'+';
else dest[idx] = (byte)'/';
}
// add padding
for (int idx = dest.length-1; idx > (d.length*4)/3; idx--)
{
dest[idx] = (byte)'=';
}
return dest;
} | java | {
"resource": ""
} |
q16425 | Base64.decodeInternal | train | private static byte[] decodeInternal(byte[] data)
{
int tail = data.length;
while (data[tail-1] == '=') tail--;
byte dest[] = new byte[tail - data.length/4];
// ascii printable to 0-63 conversion
for (int idx = 0; idx <data.length; idx++)
{
if (data[idx] == '=') data[idx] = 0;
else if (data[idx] == '/') data[idx] = 63;
else if (data[idx] == '+') data[idx] = 62;
else if (data[idx] >= '0' && data[idx] <= '9')
data[idx] = (byte)(data[idx] - ('0' - 52));
else if (data[idx] >= 'a' && data[idx] <= 'z')
data[idx] = (byte)(data[idx] - ('a' - 26));
else if (data[idx] >= 'A' && data[idx] <= 'Z')
data[idx] = (byte)(data[idx] - 'A');
}
// 4-byte to 3-byte conversion
int sidx, didx;
for (sidx = 0, didx=0; didx < dest.length-2; sidx += 4, didx += 3)
{
dest[didx] = (byte) ( ((data[sidx] << 2) & 255) |
((data[sidx+1] >>> 4) & 3) );
dest[didx+1] = (byte) ( ((data[sidx+1] << 4) & 255) |
((data[sidx+2] >>> 2) & 017) );
dest[didx+2] = (byte) ( ((data[sidx+2] << 6) & 255) |
(data[sidx+3] & 077) );
}
if (didx < dest.length)
{
dest[didx] = (byte) ( ((data[sidx] << 2) & 255) |
((data[sidx+1] >>> 4) & 3) );
}
if (++didx < dest.length)
{
dest[didx] = (byte) ( ((data[sidx+1] << 4) & 255) |
((data[sidx+2] >>> 2) & 017) );
}
return dest;
} | java | {
"resource": ""
} |
q16426 | DB_PostgreSQL.jsonToObject | train | private Object jsonToObject(String recordValue) throws JsonParseException, JsonMappingException, IOException{
ObjectMapper mapper = new ObjectMapper();
Object json = mapper.readValue(recordValue, Object.class);
return json;
} | java | {
"resource": ""
} |
q16427 | DB_PostgreSQL.correctDataTypes | train | @Override
public void correctDataTypes(DAO[] daoList, ModelDef model) {
for(DAO dao : daoList){
correctDataTypes(dao, model);
}
} | java | {
"resource": ""
} |
q16428 | DB_PostgreSQL.correctDataType | train | private Object correctDataType(Object value, String dataType) {
if(value == null ){return null;}
return value;
} | java | {
"resource": ""
} |
q16429 | FilterableFixtureProxy.filter | train | @Override
public boolean filter(Object entity) {
if (fixture instanceof FilterableFixture) {
return filterableFixture().filter(entity);
}
return true;
} | java | {
"resource": ""
} |
q16430 | UniPunyCode.isUnicode | train | public static boolean isUnicode(String str) {
if (str == null) {
return false;
}
return (!IDN.toASCII(str).equals(str));
} | java | {
"resource": ""
} |
q16431 | UniPunyCode.isPunycode | train | public static boolean isPunycode(String str) {
if (str == null) {
return false;
}
return (!IDN.toUnicode(str).equals(str));
} | java | {
"resource": ""
} |
q16432 | FactorGraph.outcomeToAssignment | train | public Assignment outcomeToAssignment(List<String> factorVariables, List<? extends Object> outcome) {
assert factorVariables.size() == outcome.size();
int[] varNums = new int[factorVariables.size()];
Object[] values = new Object[factorVariables.size()];
for (int i = 0; i < factorVariables.size(); i++) {
int varInd = getVariables().getVariableByName(factorVariables.get(i));
varNums[i] = varInd;
values[i] = outcome.get(i);
}
return Assignment.fromUnsortedArrays(varNums, values);
} | java | {
"resource": ""
} |
q16433 | FactorGraph.getSharedVariables | train | public Set<Integer> getSharedVariables(int factor1, int factor2) {
Set<Integer> varNums = new HashSet<Integer>(factorVariableMap.get(factor1));
varNums.retainAll(factorVariableMap.get(factor2));
return varNums;
} | java | {
"resource": ""
} |
q16434 | FeatureGenerators.convertingFeatureGenerator | train | public static <A, B, C> FeatureGenerator<A, C> convertingFeatureGenerator(
FeatureGenerator<B, C> generator, Function<A, B> converter) {
return new ConvertingFeatureGenerator<A, B, C>(generator, converter);
} | java | {
"resource": ""
} |
q16435 | FeatureGenerators.postConvertingFeatureGenerator | train | public static <A, B, C> FeatureGenerator<A, C> postConvertingFeatureGenerator(
FeatureGenerator<A, B> generator, Function<B, C> converter) {
return new PostConvertingFeatureGenerator<A, B, C>(generator, converter);
} | java | {
"resource": ""
} |
q16436 | TableAssignment.getTuples | train | public List<List<Object>> getTuples() {
Iterator<KeyValue> keyValueIter = indicators.keyValueIterator();
List<List<Object>> tuples = Lists.newArrayList();
while (keyValueIter.hasNext()) {
KeyValue keyValue = keyValueIter.next();
if (keyValue.getValue() != 0.0) {
tuples.add(vars.intArrayToAssignment(keyValue.getKey()).getValues());
}
}
return tuples;
} | java | {
"resource": ""
} |
q16437 | DB_Jdbc.executeSelect | train | public DAO[] executeSelect(String sql, Object[] parameters)
throws DatabaseException {
ResultSet rs = executeSelectSQL(sql, parameters, null, false);
return resultSetToDAO(rs, null);
} | java | {
"resource": ""
} |
q16438 | DB_Jdbc.getPreparedStatement | train | public Statement getPreparedStatement(String sql,
Object[] parameters, boolean returnValues) throws DatabaseException {
Statement stmt = null;
try {
if(supportPreparedStatement()){
if (appendReturningColumnClause() && returnValues) {
stmt = connection.prepareStatement(sql, PreparedStatement.RETURN_GENERATED_KEYS);
} else {
stmt = connection.prepareStatement(sql);
}
if (parameters != null) {
for (int i = 0; i < parameters.length; i++) {
((PreparedStatement)stmt).setObject(i + 1,getEquivalentDBObject(parameters[i]));
}
}
}else{//no substition of parameters
stmt = connection.createStatement();
return stmt;
}
} catch (SQLException e) {
logSQL(stmt, sql, parameters, true);
e.printStackTrace();
throw new DataEntryException(e.getMessage());
}
return stmt;
} | java | {
"resource": ""
} |
q16439 | HeadedSyntacticCategory.getCanonicalForm | train | public HeadedSyntacticCategory getCanonicalForm(Map<Integer, Integer> relabeling) {
Preconditions.checkArgument(relabeling.size() == 0);
int[] relabeledVariables = canonicalizeVariableArray(semanticVariables, relabeling);
return new HeadedSyntacticCategory(syntacticCategory.getCanonicalForm(), relabeledVariables, rootIndex);
} | java | {
"resource": ""
} |
q16440 | HeadedSyntacticCategory.getArgumentType | train | public HeadedSyntacticCategory getArgumentType() {
SyntacticCategory argumentSyntax = syntacticCategory.getArgument();
int[] argumentSemantics = ArrayUtils.copyOfRange(semanticVariables, rootIndex + 1, semanticVariables.length);
int argumentRoot = argumentSyntax.getNumReturnSubcategories();
return new HeadedSyntacticCategory(argumentSyntax, argumentSemantics, argumentRoot);
} | java | {
"resource": ""
} |
q16441 | HeadedSyntacticCategory.getArgumentTypes | train | public List<HeadedSyntacticCategory> getArgumentTypes() {
List<HeadedSyntacticCategory> arguments = Lists.newArrayList();
HeadedSyntacticCategory cat = this;
while (!cat.isAtomic()) {
arguments.add(cat.getArgumentType());
cat = cat.getReturnType();
}
return arguments;
} | java | {
"resource": ""
} |
q16442 | HeadedSyntacticCategory.getReturnType | train | public HeadedSyntacticCategory getReturnType() {
SyntacticCategory returnSyntax = syntacticCategory.getReturn();
int[] returnSemantics = ArrayUtils.copyOf(semanticVariables, rootIndex);
int returnRoot = returnSyntax.getNumReturnSubcategories();
return new HeadedSyntacticCategory(returnSyntax, returnSemantics, returnRoot);
} | java | {
"resource": ""
} |
q16443 | Credentials.getSafe | train | public Credentials getSafe(){
Credentials safeCreds = new Credentials(this);
safeCreds.meta_remove(PASSWORD_KEY);
safeCreds.meta_remove(AUTH_TOKEN_KEY);
safeCreds.meta_remove(AUTH_TOKEN_EXPIRE_KEY);
safeCreds.meta_remove(VALIDATION_KEY);
safeCreds.meta_remove(PUSH_MESSAGING_KEY);
safeCreds.meta_remove(RECOVERY_TOKEN_KEY);
return safeCreds;
} | java | {
"resource": ""
} |
q16444 | CfgParser.parseMarginal | train | public CfgParseChart parseMarginal(List<?> terminals, Object root, boolean useSumProduct) {
CfgParseChart chart = createParseChart(terminals, useSumProduct);
Factor rootFactor = TableFactor.pointDistribution(parentVar,
parentVar.outcomeArrayToAssignment(root));
return marginal(chart, terminals, rootFactor);
} | java | {
"resource": ""
} |
q16445 | CfgParser.parseMarginal | train | public CfgParseChart parseMarginal(List<?> terminals, boolean useSumProduct) {
Factor rootDist = TableFactor.unity(parentVar);
return parseMarginal(terminals, rootDist, useSumProduct);
} | java | {
"resource": ""
} |
q16446 | CfgParser.parseMarginal | train | public CfgParseChart parseMarginal(List<?> terminals, Factor rootDist, boolean useSumProduct) {
return marginal(createParseChart(terminals, useSumProduct), terminals, rootDist);
} | java | {
"resource": ""
} |
q16447 | CfgParser.createParseChart | train | private CfgParseChart createParseChart(List<?> terminals, boolean useSumProduct) {
return new CfgParseChart(terminals, parentVar, leftVar, rightVar, terminalVar, ruleTypeVar,
binaryDistribution, useSumProduct);
} | java | {
"resource": ""
} |
q16448 | CfgParser.initializeBeamSearchChart | train | private void initializeBeamSearchChart(List<Object> terminals, BeamSearchCfgParseChart chart,
long[] treeEncodingOffsets) {
Variable terminalListValue = terminalVar.getOnlyVariable();
// Adding this to a tree key indicates that the tree is a terminal.
long terminalSignal = ((long) chart.chartSize()) * (treeEncodingOffsets[3] + treeEncodingOffsets[2]);
for (int i = 0; i < terminals.size(); i++) {
for (int j = i; j < terminals.size(); j++) {
if (terminalListValue.canTakeValue(terminals.subList(i, j + 1))) {
Assignment assignment = terminalVar.outcomeArrayToAssignment(terminals.subList(i, j + 1));
Iterator<Outcome> iterator = terminalDistribution.outcomePrefixIterator(assignment);
while (iterator.hasNext()) {
Outcome bestOutcome = iterator.next();
int root = nonterminalVariableType.getValueIndex(bestOutcome.getAssignment().getValue(parentVar.getOnlyVariableNum()));
int ruleType = ruleVariableType.getValueIndex(bestOutcome.getAssignment().getValue(ruleTypeVar.getOnlyVariableNum()));
long partialKeyNum = (root * treeEncodingOffsets[4]) + (ruleType * treeEncodingOffsets[5]);
chart.addParseTreeKeyForSpan(i, j, terminalSignal + partialKeyNum,
bestOutcome.getProbability());
}
// System.out.println(i + "." + j + ": " + assignment + " : " +
// chart.getParseTreesForSpan(i, j));
}
}
}
} | java | {
"resource": ""
} |
q16449 | ClassContainer.isExportable | train | public boolean isExportable() {
return fieldContainerMap.entrySet().stream().anyMatch(e -> format.isTypeSupported(e.getValue().getType()));
} | java | {
"resource": ""
} |
q16450 | PairCountAccumulator.toTableString | train | public String toTableString(boolean probs) {
Set<B> key2s = Sets.newHashSet();
for (A key : counts.keySet()) {
key2s.addAll(counts.get(key).keySet());
}
List<B> key2List = Lists.newArrayList(key2s);
StringBuilder sb = new StringBuilder();
sb.append("\t");
for (B key2 : key2List) {
sb.append(key2);
sb.append("\t");
}
sb.append("\n");
for (A key1 : counts.keySet()) {
sb.append(key1);
sb.append("\t");
for (B key2 : key2List) {
if (probs) {
sb.append(String.format("%.3f", getProbability(key1, key2)));
} else {
sb.append(getCount(key1, key2));
}
sb.append("\t");
}
sb.append("\n");
}
return sb.toString();
} | java | {
"resource": ""
} |
q16451 | IntMultimap.reindexItems | train | public void reindexItems() {
if (numUnsortedItems > 0) {
int[] newSortedKeys = Arrays.copyOf(sortedKeys, sortedKeys.length + numUnsortedItems);
int[] newSortedValues = Arrays.copyOf(sortedValues, sortedValues.length + numUnsortedItems);
int oldLength = sortedKeys.length;
for (int i = 0; i < numUnsortedItems; i++) {
newSortedKeys[i + oldLength] = unsortedKeys[i];
newSortedValues[i + oldLength] = unsortedValues[i];
}
ArrayUtils.sortKeyValuePairs(newSortedKeys, newSortedValues, 0, newSortedKeys.length);
sortedKeys = newSortedKeys;
sortedValues = newSortedValues;
numUnsortedItems = 0;
rebuildKeySet();
}
} | java | {
"resource": ""
} |
q16452 | IntMultimap.resizeMap | train | private void resizeMap() {
int[] newUnsortedKeys = Arrays.copyOf(unsortedKeys, unsortedKeys.length * 2);
int[] newUnsortedValues = Arrays.copyOf(unsortedValues, unsortedValues.length * 2);
unsortedKeys = newUnsortedKeys;
unsortedValues = newUnsortedValues;
} | java | {
"resource": ""
} |
q16453 | BackendUser.from | train | public static BackendUser from(ValidCredentials credentials){
BackendUser beu = new BackendUser();
beu.initFrom(credentials);
return beu;
} | java | {
"resource": ""
} |
q16454 | BackendUser.signIn | train | public static SignInResponse signIn(String email, String password){
return signIn(new LoginCredentials(email,password));
} | java | {
"resource": ""
} |
q16455 | BackendUser.signUp | train | public static SignUpResponse signUp(String username, String email, String password){
return signUp(new SignUpCredentials(username,email,password));
} | java | {
"resource": ""
} |
q16456 | BackendUser.signInInBackground | train | public static Observable<BackendUser> signInInBackground(String email, String password){
return getAM().loginASync(new LoginCredentials(email, password));
} | java | {
"resource": ""
} |
q16457 | BackendUser.signUpInBackground | train | public static Observable<BackendUser> signUpInBackground(String username, String email, String password){
return getAM().signUpASync(new SignUpCredentials(username, email, password));
} | java | {
"resource": ""
} |
q16458 | BackendUser.signUp | train | public boolean signUp(){
SignUpCredentials creds = new SignUpCredentials(getUsername(),getEmailAddress(),getPassword());
SignUpResponse response = getAM().signUp(creds);
if(response.getStatus().isSuccess()){
this.initFrom(response.get());
return true;
} else return false;
} | java | {
"resource": ""
} |
q16459 | Packer.generateKeyPair | train | public static KeyPair generateKeyPair(final int keyLen) throws NoSuchAlgorithmException {
final String name = ASYM_CIPHER_CHAIN_PADDING;
final int offset = name.indexOf('/');
final String alg = ((offset < 0) ? name : name.substring(0, offset));
final KeyPairGenerator generator = KeyPairGenerator.getInstance(alg);
generator.initialize(keyLen);
return generator.genKeyPair();
} | java | {
"resource": ""
} |
q16460 | Packer.getByteBuffer | train | public ByteBuffer getByteBuffer() {
final ByteBuffer bb = ByteBuffer.wrap(buf);
bb.limit(bufLimit);
bb.position(bufPosition);
return bb;
} | java | {
"resource": ""
} |
q16461 | Packer.outputBytes | train | public byte[] outputBytes() {
byte[] tmpBuf = buf;
int len = bufLimit;
int flags = 0;
if (useCompress) {
flags |= FLAG_COMPRESS;
tmpBuf = deflate(tmpBuf, len);
len = tmpBuf.length;
}
if (aesKey != null) {
flags |= FLAG_AES;
try {
tmpBuf = crypto(tmpBuf, 0, len, false);
} catch (Exception e) {
throw new IllegalArgumentException("AES Encryption failed", e);
}
len = tmpBuf.length;
//
if (aesIV != null) {
switch (aesTypeIV) {
case RANDOM_IV: { // useAES + randomIV
flags |= FLAG_RANDOM_IV;
final byte[] ivBuf = aesIV.getIV();
tmpBuf = resizeBuffer(tmpBuf, len + ivBuf.length);
System.arraycopy(ivBuf, 0, tmpBuf, len, ivBuf.length);
len = tmpBuf.length;
break;
}
case RANDOM_INT_IV: { // useAES + integerIV
flags |= FLAG_RANDOM_INT_IV;
final byte[] ivBuf = intToByteArray(integerIV);
tmpBuf = resizeBuffer(tmpBuf, len + ivBuf.length);
System.arraycopy(ivBuf, 0, tmpBuf, len, ivBuf.length);
len = tmpBuf.length;
break;
}
}
}
}
if (rsaKeyForEncrypt != null) {
flags |= FLAG_RSA;
try {
tmpBuf = cryptoAsym(tmpBuf, 0, len, false);
} catch (Exception e) {
throw new IllegalArgumentException("RSA Encryption failed", e);
}
len = tmpBuf.length;
}
if (useCRC) {
flags |= FLAG_CRC;
tmpBuf = resizeBuffer(tmpBuf, len + 1);
tmpBuf[len] = (byte) crc8(tmpBuf, 0, len);
len = tmpBuf.length;
}
if (mdHash != null) { // useHASH
flags |= FLAG_HASH;
final byte[] mdBuf = hash(tmpBuf, 0, len);
tmpBuf = resizeBuffer(tmpBuf, len + mdBuf.length);
System.arraycopy(mdBuf, 0, tmpBuf, len, mdBuf.length);
len = tmpBuf.length;
}
if (hMac != null) { // useHMAC
flags |= FLAG_HMAC;
final byte[] hmacBuf = hmac(tmpBuf, 0, len);
tmpBuf = resizeBuffer(tmpBuf, len + hmacBuf.length);
System.arraycopy(hmacBuf, 0, tmpBuf, len, hmacBuf.length);
len = tmpBuf.length;
}
if (useFlagFooter) {
tmpBuf = resizeBuffer(tmpBuf, ++len);
tmpBuf[len - 1] = (byte) (flags & 0xFF);
} else {
tmpBuf = resizeBuffer(tmpBuf, len);
}
return tmpBuf;
} | java | {
"resource": ""
} |
q16462 | Packer.loadStringHex | train | public Packer loadStringHex(final String in) throws InvalidInputDataException {
try {
return loadBytes(fromHex(in));
} catch (ParseException e) {
throw new IllegalArgumentException("Invalid input string", e);
}
} | java | {
"resource": ""
} |
q16463 | Packer.crypto | train | final byte[] crypto(final byte[] input, final int offset, final int len, final boolean decrypt)
throws InvalidKeyException, InvalidAlgorithmParameterException, IllegalBlockSizeException,
BadPaddingException {
aesCipher.init(decrypt ? Cipher.DECRYPT_MODE : Cipher.ENCRYPT_MODE, aesKey, aesIV);
return aesCipher.doFinal(input, offset, len);
} | java | {
"resource": ""
} |
q16464 | Packer.cryptoAsym | train | final byte[] cryptoAsym(final byte[] input, final int offset, final int len, final boolean decrypt)
throws InvalidKeyException, InvalidAlgorithmParameterException, IllegalBlockSizeException,
BadPaddingException {
rsaCipher.init(decrypt ? Cipher.DECRYPT_MODE : Cipher.ENCRYPT_MODE, decrypt ? rsaKeyForDecrypt
: rsaKeyForEncrypt);
return rsaCipher.doFinal(input, offset, len);
} | java | {
"resource": ""
} |
q16465 | Packer.resizeBuffer | train | static final byte[] resizeBuffer(final byte[] buf, final int newsize) {
if (buf.length == newsize)
return buf;
final byte[] newbuf = new byte[newsize];
System.arraycopy(buf, 0, newbuf, 0, Math.min(buf.length, newbuf.length));
return newbuf;
} | java | {
"resource": ""
} |
q16466 | Packer.compareBuffer | train | static final boolean compareBuffer(final byte[] buf1, final int offset1, final byte[] buf2,
final int offset2, final int len) {
for (int i = 0; i < len; i++) {
final byte b1 = buf1[offset1 + i];
final byte b2 = buf2[offset2 + i];
if (b1 != b2) {
return false;
}
}
return true;
} | java | {
"resource": ""
} |
q16467 | Packer.toHex | train | static final String toHex(final byte[] input, final int len, final boolean upper) {
final char[] hex = new char[len << 1];
for (int i = 0, j = 0; i < len; i++) {
final int bx = input[i];
final int bh = ((bx >> 4) & 0xF);
final int bl = (bx & 0xF);
if ((bh >= 0) && (bh <= 9)) {
hex[j++] |= (bh + '0');
} else if ((bh >= 0xA) && (bh <= 0xF)) {
hex[j++] |= (bh - 0xA + (upper ? 'A' : 'a'));
}
if ((bl >= 0x0) && (bl <= 0x9)) {
hex[j++] |= (bl + '0');
} else if ((bl >= 0xA) && (bl <= 0xF)) {
hex[j++] |= (bl - 0xA + (upper ? 'A' : 'a'));
}
}
return new String(hex);
} | java | {
"resource": ""
} |
q16468 | Packer.fromHex | train | static final byte[] fromHex(final String hex) throws ParseException {
final int len = hex.length();
final byte[] out = new byte[len / 2];
for (int i = 0, j = 0; i < len; i++) {
char c = hex.charAt(i);
int v = 0;
if ((c >= '0') && (c <= '9')) {
v = (c - '0');
} else if ((c >= 'A') && (c <= 'F')) {
v = (c - 'A') + 0xA;
} else if ((c >= 'a') && (c <= 'f')) {
v = (c - 'a') + 0xA;
} else {
throw new ParseException("Invalid char", j);
}
if ((i & 1) == 0) {
out[j] |= (v << 4);
} else {
out[j++] |= v;
}
}
return out;
} | java | {
"resource": ""
} |
q16469 | Packer.deflate | train | static final byte[] deflate(final byte[] in, final int len) {
byte[] defBuf = new byte[len << 1];
int payloadLength;
synchronized (deflater) {
deflater.reset();
deflater.setInput(in, 0, len);
deflater.finish();
payloadLength = deflater.deflate(defBuf);
}
return resizeBuffer(defBuf, payloadLength);
} | java | {
"resource": ""
} |
q16470 | Packer.inflate | train | static final byte[] inflate(final byte[] in, final int offset, final int length)
throws DataFormatException {
byte[] infBuf = new byte[length << 1];
int payloadLength;
synchronized (inflater) {
inflater.reset();
inflater.setInput(in, offset, length);
payloadLength = inflater.inflate(infBuf);
}
return resizeBuffer(infBuf, payloadLength);
} | java | {
"resource": ""
} |
q16471 | FileUtils.copyFile | train | public static boolean copyFile(File srcFile, File destFile) {
boolean result = false;
try {
InputStream in = new FileInputStream(srcFile);
try {
result = copyToFile(in, destFile);
} finally {
in.close();
}
} catch (IOException e) {
result = false;
}
return result;
} | java | {
"resource": ""
} |
q16472 | FileUtils.copyToFile | train | public static boolean copyToFile(InputStream inputStream, File destFile) {
try {
OutputStream out = new FileOutputStream(destFile);
try {
byte[] buffer = new byte[4096];
int bytesRead;
while ((bytesRead = inputStream.read(buffer)) >= 0) {
out.write(buffer, 0, bytesRead);
}
} finally {
out.close();
}
return true;
} catch (IOException e) {
return false;
}
} | java | {
"resource": ""
} |
q16473 | FileUtils.readTextFile | train | public static String readTextFile(File file, int max, String ellipsis) throws IOException {
InputStream input = new FileInputStream(file);
try {
if (max > 0) { // "head" mode: read the first N bytes
byte[] data = new byte[max + 1];
int length = input.read(data);
if (length <= 0) return "";
if (length <= max) return new String(data, 0, length);
if (ellipsis == null) return new String(data, 0, max);
return new String(data, 0, max) + ellipsis;
} else if (max < 0) { // "tail" mode: read it all, keep the last N
int len;
boolean rolled = false;
byte[] last = null, data = null;
do {
if (last != null) rolled = true;
byte[] tmp = last; last = data; data = tmp;
if (data == null) data = new byte[-max];
len = input.read(data);
} while (len == data.length);
if (last == null && len <= 0) return "";
if (last == null) return new String(data, 0, len);
if (len > 0) {
rolled = true;
System.arraycopy(last, len, last, 0, last.length - len);
System.arraycopy(data, 0, last, last.length - len, len);
}
if (ellipsis == null || !rolled) return new String(last);
return ellipsis + new String(last);
} else { // "cat" mode: read it all
ByteArrayOutputStream contents = new ByteArrayOutputStream();
int len;
byte[] data = new byte[1024];
do {
len = input.read(data);
if (len > 0) contents.write(data, 0, len);
} while (len == data.length);
return contents.toString();
}
} finally {
input.close();
}
} | java | {
"resource": ""
} |
q16474 | TransientObject.setFilePermissions | train | public void setFilePermissions(FilePermissions filePermissions){
if(isWritable()){
meta_data.put(PERMISSIONS_KEY.KEY,gson.toJson(filePermissions,FilePermissions.class));
}
} | java | {
"resource": ""
} |
q16475 | TransientObject.setOwnerId | train | protected void setOwnerId(Integer id){
if(getOwnerId() != null){
logger.warn("Attempting to set owner id for an object where it as previously been set. Ignoring new id");
return;
}
meta_put(OWNER_ID_KEY, id); // dont allow null
} | java | {
"resource": ""
} |
q16476 | DAOArray.fromDao | train | public DAOArray fromDao(DAO[] daoList) throws DAOArrayException{
for(DAO dao : daoList){
add(dao);
}
return this;
} | java | {
"resource": ""
} |
q16477 | DAOArray.convert | train | public DAO[] convert(){
int size = data.size();
DAO[] daoList = new DAO[size];
for(int i = 0; i < size; i++){
Object[] dat = data.get(i);
DAO dao = new DAO(modelName);
for(int j = 0; j < attributes.length; j++){
dao.set_Value(attributes[j], dat[j]);
}
daoList[i] = dao;
}
return daoList;
} | java | {
"resource": ""
} |
q16478 | CountAccumulator.getSortedKeys | train | public List<T> getSortedKeys() {
List<T> l = Lists.newArrayList(counts.keySet());
Collections.sort(l, Ordering.natural().reverse().onResultOf(Functions.forMap(counts.getBaseMap())));
return l;
} | java | {
"resource": ""
} |
q16479 | ListSupertaggedSentence.createWithUnobservedSupertags | train | public static ListSupertaggedSentence createWithUnobservedSupertags(List<String> words, List<String> pos) {
return new ListSupertaggedSentence(WordAndPos.createExample(words, pos),
Collections.nCopies(words.size(), Collections.<HeadedSyntacticCategory>emptyList()),
Collections.nCopies(words.size(), Collections.<Double>emptyList()));
} | java | {
"resource": ""
} |
q16480 | GeneratedFixture.next | train | @Override
public Object next() {
assertGeneratorStarted();
if (!hasNext()) {
throw new NoSuchElementException("No more object to generate");
}
Object object = currentFixtureGenerator.next();
logger.debug("Generated {}", object);
extractorDelegate.extractEntity(object);
return object;
} | java | {
"resource": ""
} |
q16481 | MapReduceConfiguration.getMapReduceExecutor | train | public static MapReduceExecutor getMapReduceExecutor() {
if (executor == null) {
// Default to using a local executor with one thread per CPU.
executor = new LocalMapReduceExecutor(
Runtime.getRuntime().availableProcessors(), 20);
}
return executor;
} | java | {
"resource": ""
} |
q16482 | DiscreteFactor.getNonzeroAssignments | train | public List<Assignment> getNonzeroAssignments() {
Iterator<Outcome> outcomeIter = outcomeIterator();
List<Assignment> assignments = Lists.newArrayList();
while (outcomeIter.hasNext()) {
Outcome outcome = outcomeIter.next();
if (outcome.getProbability() != 0.0) {
assignments.add(outcome.getAssignment());
}
}
return assignments;
} | java | {
"resource": ""
} |
q16483 | DiscreteFactor.getPartitionFunction | train | private double getPartitionFunction() {
if (partitionFunction != -1.0) {
return partitionFunction;
}
partitionFunction = 0.0;
Iterator<Outcome> outcomeIterator = outcomeIterator();
while (outcomeIterator.hasNext()) {
partitionFunction += outcomeIterator.next().getProbability();
}
return partitionFunction;
} | java | {
"resource": ""
} |
q16484 | MapUtils.fromLists | train | public static <A, B> Map<A, B> fromLists(List<A> keys, List<B> values) {
Preconditions.checkArgument(keys.size() == values.size());
Map<A, B> map = Maps.newHashMap();
for (int i = 0; i < keys.size(); i++) {
map.put(keys.get(i), values.get(i));
}
return map;
} | java | {
"resource": ""
} |
q16485 | StaticAnalysis.inferType | train | public static Type inferType(Expression2 expression, Type rootType, TypeDeclaration typeDeclaration) {
Map<Integer, Type> subexpressionTypeMap = inferTypeMap(expression, rootType, typeDeclaration);
return subexpressionTypeMap.get(0);
} | java | {
"resource": ""
} |
q16486 | DateUtils.eventDateValid | train | public static boolean eventDateValid(String eventDate) {
boolean result = false;
if (extractDate(eventDate)!=null) {
result = true;
} else {
Interval interval = extractInterval(eventDate);
if (interval!=null) {
if (interval.getStart().isBefore(interval.getEnd())) {
result = true;
}
}
}
return result;
} | java | {
"resource": ""
} |
q16487 | DateUtils.extractDateFromVerbatim | train | public static Map<String,String> extractDateFromVerbatim(String verbatimEventDate) {
return extractDateFromVerbatim(verbatimEventDate, DateUtils.YEAR_BEFORE_SUSPECT);
} | java | {
"resource": ""
} |
q16488 | DateUtils.isRange | train | public static boolean isRange(String eventDate) {
boolean isRange = false;
if (eventDate!=null) {
String[] dateBits = eventDate.split("/");
if (dateBits!=null && dateBits.length==2) {
//probably a range.
DateTimeParser[] parsers = {
DateTimeFormat.forPattern("yyyy-MM").getParser(),
DateTimeFormat.forPattern("yyyy").getParser(),
ISODateTimeFormat.dateOptionalTimeParser().getParser()
};
DateTimeFormatter formatter = new DateTimeFormatterBuilder().append( null, parsers ).toFormatter();
try {
// must be at least a 4 digit year.
if (dateBits[0].length()>3 && dateBits[1].length()>3) {
DateMidnight startDate = LocalDate.parse(dateBits[0],formatter).toDateMidnight();
DateMidnight endDate = LocalDate.parse(dateBits[1],formatter).toDateMidnight();
// both start date and end date must parse as dates.
isRange = true;
}
} catch (Exception e) {
// not a date range
e.printStackTrace();
logger.debug(e.getMessage());
}
} else if (dateBits!=null && dateBits.length==1) {
logger.debug(dateBits[0]);
// Date bits does not contain a /
// Is eventDate in the form yyyy-mm-dd, if so, not a range
DateTimeParser[] parsers = {
DateTimeFormat.forPattern("yyyy-MM-dd").getParser(),
};
DateTimeFormatter formatter = new DateTimeFormatterBuilder().append( null, parsers ).toFormatter();
try {
DateMidnight date = DateMidnight.parse(eventDate,formatter);
isRange = false;
} catch (Exception e) {
logger.debug(e.getMessage());
// not parsable with the yyyy-mm-dd parser.
DateTimeParser[] parsers2 = {
DateTimeFormat.forPattern("yyyy-MM").getParser(),
DateTimeFormat.forPattern("yyyy").getParser(),
};
formatter = new DateTimeFormatterBuilder().append( null, parsers2 ).toFormatter();
try {
// must be at least a 4 digit year.
if (dateBits[0].length()>3) {
DateMidnight startDate = DateMidnight.parse(dateBits[0],formatter);
// date must parse as either year or year and month dates.
isRange = true;
}
} catch (Exception e1) {
// not a date range
}
}
}
}
return isRange;
} | java | {
"resource": ""
} |
q16489 | DateUtils.extractInterval | train | public static Interval extractInterval(String eventDate) {
Interval result = null;
DateTimeParser[] parsers = {
DateTimeFormat.forPattern("yyyy-MM").getParser(),
DateTimeFormat.forPattern("yyyy").getParser(),
ISODateTimeFormat.dateOptionalTimeParser().getParser()
};
DateTimeFormatter formatter = new DateTimeFormatterBuilder().append( null, parsers ).toFormatter();
if (eventDate!=null && eventDate.contains("/") && isRange(eventDate)) {
String[] dateBits = eventDate.split("/");
try {
// must be at least a 4 digit year.
if (dateBits[0].length()>3 && dateBits[1].length()>3) {
DateMidnight startDate = DateMidnight.parse(dateBits[0],formatter);
DateTime endDate = DateTime.parse(dateBits[1],formatter);
logger.debug(startDate);
logger.debug(endDate);
if (dateBits[1].length()==4) {
result = new Interval(startDate,endDate.plusMonths(12).minus(1l));
} else if (dateBits[1].length()==7) {
result = new Interval(startDate,endDate.plusMonths(1).minus(1l));
} else {
result = new Interval(startDate, endDate.plusDays(1).minus(1l));
}
logger.debug(result);
}
} catch (Exception e) {
// not a date range
logger.error(e.getMessage());
}
} else {
try {
DateMidnight startDate = DateMidnight.parse(eventDate, formatter);
logger.debug(startDate);
if (eventDate.length()==4) {
DateTime endDate = startDate.toDateTime().plusMonths(12).minus(1l);
result = new Interval(startDate, endDate);
logger.debug(result);
} else if (eventDate.length()==7) {
DateTime endDate = startDate.toDateTime().plusMonths(1).minus(1l);
result = new Interval(startDate,endDate);
logger.debug(result);
} else {
DateTime endDate = startDate.toDateTime().plusDays(1).minus(1l);
result = new Interval(startDate,endDate);
logger.debug(result);
}
} catch (Exception e) {
// not a date
logger.error(e.getMessage());
}
}
return result;
} | java | {
"resource": ""
} |
q16490 | DateUtils.extractDate | train | public static DateMidnight extractDate(String eventDate) {
DateMidnight result = null;
DateTimeParser[] parsers = {
DateTimeFormat.forPattern("yyyy-MM").getParser(),
DateTimeFormat.forPattern("yyyy").getParser(),
DateTimeFormat.forPattern("yyyy-MM-dd/yyyy-MM-dd").getParser(),
ISODateTimeFormat.dateOptionalTimeParser().getParser(),
ISODateTimeFormat.date().getParser()
};
DateTimeFormatter formatter = new DateTimeFormatterBuilder().append( null, parsers ).toFormatter();
try {
result = DateMidnight.parse(eventDate, formatter);
logger.debug(result);
} catch (Exception e) {
// not a date
logger.error(e.getMessage());
}
return result;
} | java | {
"resource": ""
} |
q16491 | DateUtils.isConsistent | train | public static boolean isConsistent(String eventDate, String startDayOfYear, String endDayOfYear, String year, String month, String day) {
if (isEmpty(eventDate) || (isEmpty(startDayOfYear) && isEmpty(endDayOfYear) && isEmpty(year) && isEmpty(month) && isEmpty(day))) {
return true;
}
// TODO: Add support for eventTime
boolean result = false;
result = isConsistent(eventDate,year,month,day);
logger.debug(result);
if ((result || (!isEmpty(eventDate) && isEmpty(year) && isEmpty(month) && isEmpty(day))) && (!isEmpty(startDayOfYear) || !isEmpty(endDayOfYear))) {
if (endDayOfYear==null || endDayOfYear.trim().length()==0 || startDayOfYear.trim().equals(endDayOfYear.trim())) {
int startDayInt = -1;
try {
startDayInt = Integer.parseInt(startDayOfYear);
} catch (NumberFormatException e) {
logger.debug(e.getMessage());
logger.debug(startDayOfYear + " is not an integer.");
result = false;
}
if (DateUtils.extractDate(eventDate)!=null && DateUtils.extractDate(eventDate).getDayOfYear() == startDayInt) {
result=true;
} else {
result = false;
}
} else {
int startDayInt = -1;
int endDayInt = -1;
try {
startDayInt = Integer.parseInt(startDayOfYear);
endDayInt = Integer.parseInt(endDayOfYear);
} catch (NumberFormatException e) {
logger.debug(e.getMessage());
result = false;
}
Interval eventDateInterval = DateUtils.extractDateInterval(eventDate);
logger.debug(eventDateInterval);
int endDayOfInterval = eventDateInterval.getEnd().getDayOfYear(); // midnight on the next day, so subtract 1 to get the same integer day.
if (eventDateInterval.getStart().getDayOfYear() == startDayInt && endDayOfInterval == endDayInt ) {
result=true;
} else {
result = false;
}
}
}
return result;
} | java | {
"resource": ""
} |
q16492 | DateUtils.isEmpty | train | public static boolean isEmpty(String aString) {
boolean result = true;
if (aString != null && aString.trim().length()>0) {
if (!aString.trim().toUpperCase().equals("NULL")) {
result = false;
}
}
return result;
} | java | {
"resource": ""
} |
q16493 | DateUtils.specificToDay | train | public static boolean specificToDay(String eventDate) {
boolean result = false;
if (!isEmpty(eventDate)) {
Interval eventDateInterval = extractInterval(eventDate);
logger.debug(eventDateInterval);
logger.debug(eventDateInterval.toDuration());
if (eventDateInterval.toDuration().getStandardDays()<1l) {
result = true;
} else if (eventDateInterval.toDuration().getStandardDays()==1l && eventDateInterval.getStart().getDayOfYear()==eventDateInterval.getEnd().getDayOfYear()) {
result = true;
}
}
return result;
} | java | {
"resource": ""
} |
q16494 | DateUtils.specificToDecadeScale | train | public static boolean specificToDecadeScale(String eventDate) {
boolean result = false;
if (!isEmpty(eventDate)) {
Interval eventDateInterval = extractDateInterval(eventDate);
if (eventDateInterval.toDuration().getStandardDays()<=3650l) {
result = true;
}
}
return result;
} | java | {
"resource": ""
} |
q16495 | DateUtils.instantToStringTime | train | protected static String instantToStringTime(Instant instant) {
String result = "";
if (instant!=null) {
StringBuffer time = new StringBuffer();
time.append(String.format("%02d",instant.get(DateTimeFieldType.hourOfDay())));
time.append(":").append(String.format("%02d",instant.get(DateTimeFieldType.minuteOfHour())));
time.append(":").append(String.format("%02d",instant.get(DateTimeFieldType.secondOfMinute())));
time.append(".").append(String.format("%03d",instant.get(DateTimeFieldType.millisOfSecond())));
String timeZone = instant.getZone().getID();
if (timeZone.equals("UTC")) {
time.append("Z");
} else {
time.append(timeZone);
}
result = time.toString();
}
return result;
} | java | {
"resource": ""
} |
q16496 | DateUtils.countLeapDays | train | public static int countLeapDays(String eventDate) {
int result = 0;
if (!DateUtils.isEmpty(eventDate) && DateUtils.eventDateValid(eventDate)) {
Interval interval = extractInterval(eventDate);
Integer sYear = interval.getStart().getYear();
Integer eYear = interval.getEnd().getYear();
String startYear = Integer.toString(sYear).trim();
String endYear = Integer.toString(eYear).trim();
String leapDay = startYear + "-02-29";
logger.debug(leapDay);
if (DateUtils.eventDateValid(leapDay)) {
if (interval.contains(DateUtils.extractInterval(leapDay))) {
result = 1;
}
}
// Range spanning more than one year, check last year
if (!endYear.equals(startYear)) {
leapDay = endYear + "-02-29";
logger.debug(leapDay);
if (DateUtils.eventDateValid(leapDay)) {
if (interval.contains(DateUtils.extractInterval(leapDay))) {
result++;
}
}
}
// Ranges of more than two years, check intermediate years
if (eYear > sYear + 1) {
for (int testYear = sYear+1; testYear<eYear; testYear++) {
leapDay = Integer.toString(testYear).trim() + "-02-29";
logger.debug(leapDay);
if (DateUtils.eventDateValid(leapDay)) {
if (interval.contains(DateUtils.extractInterval(leapDay))) {
result++;
}
}
}
}
}
return result;
} | java | {
"resource": ""
} |
q16497 | JsonFileRoutingPersistence.store | train | @Override
public void store(final RandomRoutingTable.Snapshot snapshot) throws IOException {
try {
saveString(serialize(snapshot));
} catch (final JsonGenerationException e) {
throw new IOException("Error serializing routing snapshot", e);
} catch (final JsonMappingException e) {
throw new IOException("Error serializing routing snapshot", e);
}
} | java | {
"resource": ""
} |
q16498 | XmlExporter.buildClassListTag | train | private <T> String buildClassListTag(final T t) {
return (exportClassFullName != null)
? exportClassFullName
: t.getClass().getSimpleName() + exportClassEnding;
} | java | {
"resource": ""
} |
q16499 | SqlExporter.buildDefaultDataTypeMap | train | private HashMap<Class, String> buildDefaultDataTypeMap() {
return new HashMap<Class, String>() {{
put(boolean.class, "BOOLEAN");
put(Boolean.class, "BOOLEAN");
put(byte.class, "BYTE");
put(Byte.class, "BYTE");
put(short.class, "INT");
put(Short.class, "INT");
put(int.class, "INT");
put(Integer.class, "INT");
put(long.class, "BIGINT");
put(Long.class, "BIGINT");
put(float.class, "DOUBLE PRECISION");
put(Float.class, "DOUBLE PRECISION");
put(double.class, "DOUBLE PRECISION");
put(Double.class, "DOUBLE PRECISION");
put(char.class, "CHAR");
put(Character.class, "CHAR");
put(Date.class, "BIGINT");
put(String.class, "VARCHAR");
put(Object.class, "VARCHAR");
put(Timestamp.class, "TIMESTAMP");
put(LocalDate.class, "TIMESTAMP");
put(LocalTime.class, "TIMESTAMP");
put(LocalDateTime.class, "TIMESTAMP");
}};
} | java | {
"resource": ""
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.