text stringlengths 10 2.72M |
|---|
package front.menu;
import back.GameDifficulty;
import front.Button;
import front.Window;
import java.awt.Color;
import java.awt.Dimension;
import java.awt.Font;
import java.awt.Graphics;
import java.awt.GridBagConstraints;
import java.awt.GridBagLayout;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.io.File;
import java.io.IOException;
import javax.imageio.ImageIO;
import javax.swing.JButton;
import javax.swing.JLabel;
import javax.swing.JOptionPane;
import javax.swing.JPanel;
/**
*
* @author Peter
*/
public class MenuPanel extends JPanel implements ActionListener {
private Window parent;
private JButton newgame = new Button("Helyi játék", ".\\img\\button\\green", new Font("Serif", Font.PLAIN, 30), Color.WHITE);
private JButton netgame = new Button("Hálózati játék", ".\\img\\button\\green", new Font("Serif", Font.PLAIN, 30), Color.WHITE);
private JButton stats = new Button("Statisztika", ".\\img\\button\\brown", new Font("Serif", Font.PLAIN, 30), Color.WHITE);
private JButton rules = new Button("Játékszabályok", ".\\img\\button\\brown", new Font("Serif", Font.PLAIN, 30), Color.WHITE);
private JButton quit = new Button("Kilépés", ".\\img\\button\\brown", new Font("Serif", Font.PLAIN, 30), Color.WHITE);
public MenuPanel(Window window) {
parent = window;
setMinimumSize(new Dimension(900, 660));
setLayout(new GridBagLayout());
GridBagConstraints cont = new GridBagConstraints();
cont.fill = GridBagConstraints.VERTICAL;
cont.gridx = 0;
cont.gridy++;
add(new JLabel("<html><br><br></html>"), cont);
cont.gridy++;
newgame.addActionListener(this);
add(newgame, cont);
cont.gridy++;
add(new JLabel("<html><br></html>"), cont);
cont.gridy++;
netgame.addActionListener(this);
add(netgame, cont);
cont.gridy++;
add(new JLabel("<html><br></html>"), cont);
cont.gridy++;
stats.addActionListener(this);
add(stats, cont);
cont.gridy++;
add(new JLabel("<html><br></html>"), cont);
cont.gridy++;
rules.addActionListener(this);
add(rules, cont);
cont.gridy++;
add(new JLabel("<html><br></html>"), cont);
cont.gridy++;
quit.addActionListener(this);
add(quit, cont);
}
@Override
public void actionPerformed(ActionEvent e) {
if (e.getSource().equals(newgame)) {
//Új játék
DifficultyDialog dialog = new DifficultyDialog(parent);
dialog.display();
if(dialog.getDifficulty()!=null)
{
if(dialog.getDifficulty() != GameDifficulty.CUSTOM)
{
parent.startLocalGame(dialog.getDifficulty());
}
else
{
parent.startGame(dialog.getMapFile());
}
}
}
else if(e.getSource().equals(netgame))
{
NetworkDialog dialog = new NetworkDialog(parent);
dialog.display();
if(dialog.getAction() != 0)
{
if(dialog.getAction() == 1)
{
JOptionPane.showMessageDialog(this, "Ez a funkció még nem érhető el!");
}
else if(dialog.getAction() == 2)
{
JOptionPane.showMessageDialog(this, "Ez a funkció még nem érhető el!");
}
}
}
else if (e.getSource().equals(rules)) {
//Szabályok
parent.showRules();
} else if (e.getSource().equals(stats)) {
//Statisztika
parent.showStats();
} else if (e.getSource().equals(quit)) {
//Kilépés
System.exit(0);
}
}
@Override
protected void paintComponent(Graphics g) {
super.paintComponent(g);
try {
g.drawImage(ImageIO.read(new File("./img/title.png")), 0, 0, this);
} catch (IOException ex) {
}
}
}
|
package org.elasticsearch.plugin.zentity;
import com.fasterxml.jackson.core.JsonParseException;
import com.fasterxml.jackson.databind.ObjectWriter;
import io.zentity.common.CompletableFutureUtil;
import io.zentity.common.FunctionalUtil.UnCheckedFunction;
import io.zentity.common.FunctionalUtil.UnCheckedSupplier;
import io.zentity.common.Json;
import io.zentity.common.SecurityUtil;
import io.zentity.common.StreamUtil;
import io.zentity.model.Model;
import io.zentity.resolution.BulkResolutionResponse;
import io.zentity.resolution.Job;
import io.zentity.resolution.ResolutionResponse;
import io.zentity.resolution.input.Input;
import org.elasticsearch.action.get.GetResponse;
import org.elasticsearch.client.node.NodeClient;
import org.elasticsearch.common.CheckedFunction;
import org.elasticsearch.common.CheckedSupplier;
import org.elasticsearch.common.settings.Settings;
import org.elasticsearch.common.unit.TimeValue;
import org.elasticsearch.common.util.concurrent.EsExecutors;
import org.elasticsearch.common.util.concurrent.ThreadContext;
import org.elasticsearch.plugin.zentity.exceptions.BadRequestException;
import org.elasticsearch.plugin.zentity.exceptions.NotFoundException;
import org.elasticsearch.rest.BytesRestResponse;
import org.elasticsearch.rest.RestRequest;
import org.elasticsearch.rest.RestResponse;
import org.elasticsearch.rest.RestStatus;
import java.io.IOException;
import java.time.Duration;
import java.util.Arrays;
import java.util.List;
import java.util.Map;
import java.util.concurrent.CompletableFuture;
import java.util.concurrent.CompletionException;
import java.util.concurrent.Executor;
import java.util.concurrent.TimeUnit;
import java.util.function.Supplier;
import java.util.stream.Collectors;
import static java.util.Collections.emptyMap;
import static org.elasticsearch.plugin.zentity.ActionUtil.channelErrorHandler;
import static org.elasticsearch.plugin.zentity.ActionUtil.errorHandlingConsumer;
import static org.elasticsearch.rest.RestRequest.Method.POST;
public class ResolutionAction extends BaseZentityAction {
private final Executor resolutionExecutor;
private final ModelsAction modelsAction;
// All parameters known to the request
private static final String PARAM_ENTITY_TYPE = "entity_type";
private static final String PARAM_PRETTY = "pretty";
private static final String PARAM_INCLUDE_ATTRIBUTES = "_attributes";
private static final String PARAM_INCLUDE_ERROR_TRACE = "error_trace";
private static final String PARAM_INCLUDE_EXPLANATION = "_explanation";
private static final String PARAM_INCLUDE_HITS = "hits";
private static final String PARAM_INCLUDE_QUERIES = "queries";
private static final String PARAM_INCLUDE_SCORE = "_score";
private static final String PARAM_INCLUDE_SEQ_NO_PRIMARY_TERM = "_seq_no_primary_term";
private static final String PARAM_INCLUDE_SOURCE = "_source";
private static final String PARAM_INCLUDE_VERSION = "_version";
private static final String PARAM_MAX_DOCS_PER_QUERY = "max_docs_per_query";
private static final String PARAM_MAX_HOPS = "max_hops";
private static final String PARAM_MAX_TIME_PER_QUERY = "max_time_per_query";
private static final String PARAM_PROFILE = "profile";
private static final String PARAM_SEARCH_ALLOW_PARTIAL_SEARCH_RESULTS = "search.allow_partial_search_results";
private static final String PARAM_SEARCH_BATCHED_REDUCE_SIZE = "search.batched_reduce_size";
private static final String PARAM_SEARCH_MAX_CONCURRENT_SHARD_REQUESTS = "search.max_concurrent_shard_requests";
private static final String PARAM_SEARCH_PRE_FILTER_SHARD_SIZE = "search.pre_filter_shard_size";
private static final String PARAM_SEARCH_REQUEST_CACHE = "search.request_cache";
private static final String PARAM_SEARCH_PREFERENCE = "search.preference";
public ResolutionAction(ZentityConfig config) {
super(config);
modelsAction = new ModelsAction(config);
// setup a scaling executor that always keeps a few threads on hand but can
// increase as the load increases
resolutionExecutor = EsExecutors.newScaling(
"zentity-resolution",
3,
this.config.getResolutionMaxConcurrentJobs(),
60,
TimeUnit.SECONDS,
EsExecutors.daemonThreadFactory("zentity-resolution"),
new ThreadContext(Settings.EMPTY)
);
}
CompletableFuture<Input> getInputAsync(NodeClient client, String entityType, String body) {
return CompletableFuture
.supplyAsync(
UnCheckedSupplier.from(() -> {
// Validate the request body.
if (body == null || body.equals("")) {
throw new BadRequestException("Request body is missing.");
}
// Parse and validate the job input.
if (entityType == null || entityType.equals("")) {
return new Input(body);
}
return null;
}),
resolutionExecutor
).thenCompose((input) -> {
if (input != null) {
return CompletableFuture.completedFuture(input);
}
return modelsAction.getEntityModel(entityType, client)
.thenApply(UnCheckedFunction.from(
// cast needed to appease the compiler for the thrown checked exceptions
(CheckedFunction<GetResponse, Input, IOException>)
(res) -> {
if (!res.isExists()) {
throw new NotFoundException("Entity type '" + entityType + "' not found.");
}
// TODO: build directly from response
String model = res.getSourceAsString();
return new Input(body, new Model(model));
}));
})
.exceptionally((ex) -> {
Throwable cause = CompletableFutureUtil.getCause(ex);
if (cause instanceof JsonParseException) {
throw new BadRequestException("Invalid JSON body", cause);
}
throw new CompletionException(cause);
});
}
CompletableFuture<Job> buildJobAsync(NodeClient client, String body, Map<String, String> params, Map<String, String> reqParams) {
final String entityType = ParamsUtil.optString(PARAM_ENTITY_TYPE, null, params, reqParams);
return getInputAsync(client, entityType, body)
.thenApply(
(input) -> {
// Parse the request params that will be passed to the job configuration
final boolean includeAttributes = ParamsUtil.optBoolean(PARAM_INCLUDE_ATTRIBUTES, Job.DEFAULT_INCLUDE_ATTRIBUTES, params, reqParams);
final boolean includeErrorTrace = ParamsUtil.optBoolean(PARAM_INCLUDE_ERROR_TRACE, Job.DEFAULT_INCLUDE_ERROR_TRACE, params, reqParams);
final boolean includeExplanation = ParamsUtil.optBoolean(PARAM_INCLUDE_EXPLANATION, Job.DEFAULT_INCLUDE_EXPLANATION, params, reqParams);
final boolean includeHits = ParamsUtil.optBoolean(PARAM_INCLUDE_HITS, Job.DEFAULT_INCLUDE_HITS, params, reqParams);
final boolean includeQueries = ParamsUtil.optBoolean(PARAM_INCLUDE_QUERIES, Job.DEFAULT_INCLUDE_QUERIES, params, reqParams);
final boolean includeScore = ParamsUtil.optBoolean(PARAM_INCLUDE_SCORE, Job.DEFAULT_INCLUDE_SCORE, params, reqParams);
final boolean includeSeqNoPrimaryTerm = ParamsUtil.optBoolean(PARAM_INCLUDE_SEQ_NO_PRIMARY_TERM, Job.DEFAULT_INCLUDE_SEQ_NO_PRIMARY_TERM, params, reqParams);
final boolean includeSource = ParamsUtil.optBoolean(PARAM_INCLUDE_SOURCE, Job.DEFAULT_INCLUDE_SOURCE, params, reqParams);
final boolean includeVersion = ParamsUtil.optBoolean(PARAM_INCLUDE_VERSION, Job.DEFAULT_INCLUDE_VERSION, params, reqParams);
final int maxDocsPerQuery = ParamsUtil.optInteger(PARAM_MAX_DOCS_PER_QUERY, Job.DEFAULT_MAX_DOCS_PER_QUERY, params, reqParams);
final int maxHops = ParamsUtil.optInteger(PARAM_MAX_HOPS, Job.DEFAULT_MAX_HOPS, params, reqParams);
final TimeValue maxTimePerQuery = ParamsUtil.optTimeValue(PARAM_MAX_TIME_PER_QUERY, Job.DEFAULT_MAX_TIME_PER_QUERY, params, reqParams);
final boolean profile = ParamsUtil.optBoolean(PARAM_PROFILE, Job.DEFAULT_PROFILE, params, reqParams);
// Parse any optional search parameters that will be passed to the job configuration.
final Boolean searchAllowPartialSearchResults = ParamsUtil.optBoolean(PARAM_SEARCH_ALLOW_PARTIAL_SEARCH_RESULTS, null, params, reqParams);
final Integer searchBatchedReduceSize = ParamsUtil.optInteger(PARAM_SEARCH_BATCHED_REDUCE_SIZE, null, params, reqParams);
final Integer searchMaxConcurrentShardRequests = ParamsUtil.optInteger(PARAM_SEARCH_MAX_CONCURRENT_SHARD_REQUESTS, null, params, reqParams);
final Integer searchPreFilterShardSize = ParamsUtil.optInteger(PARAM_SEARCH_PRE_FILTER_SHARD_SIZE, null, params, reqParams);
final Boolean searchRequestCache = ParamsUtil.optBoolean(PARAM_SEARCH_REQUEST_CACHE, null, params, reqParams);
final String searchPreference = ParamsUtil.optString(PARAM_SEARCH_PREFERENCE, null, params, reqParams);
return Job.newBuilder()
.client(client)
.includeAttributes(includeAttributes)
.includeErrorTrace(includeErrorTrace)
.includeExplanation(includeExplanation)
.includeHits(includeHits)
.includeQueries(includeQueries)
.includeScore(includeScore)
.includeSeqNoPrimaryTerm(includeSeqNoPrimaryTerm)
.includeSource(includeSource)
.includeVersion(includeVersion)
.maxDocsPerQuery(maxDocsPerQuery)
.maxHops(maxHops)
.maxTimePerQuery(maxTimePerQuery)
.profile(profile)
.input(input)
.searchAllowPartialSearchResults(searchAllowPartialSearchResults)
.searchBatchedReduceSize(searchBatchedReduceSize)
.searchMaxConcurrentShardRequests(searchMaxConcurrentShardRequests)
.searchPreFilterShardSize(searchPreFilterShardSize)
.searchPreference(searchPreference)
.searchRequestCache(searchRequestCache)
.build();
}
);
}
CompletableFuture<ResolutionResponse> buildAndRunJobAsync(NodeClient client, String body, Map<String, String> params, Map<String, String> reqParams) {
return buildJobAsync(client, body, params, reqParams)
.handleAsync((job, err) -> {
if (err == null) {
return job.runAsync().join();
}
ResolutionResponse failureResponse = new ResolutionResponse();
failureResponse.error = CompletableFutureUtil.getCause(err);
return failureResponse;
}, resolutionExecutor);
}
CompletableFuture<RestResponse> handleBulkJobRequest(final NodeClient client, final ObjectWriter responseWriter, final String reqBody, final Map<String, String> reqParams) {
String[] lines = reqBody.split("\\n");
if (lines.length % 2 != 0) {
throw new BadRequestException("Bulk request must have repeating pairs of params and resolution body on separate lines.");
}
// TODO: these suppliers seem to be executing on the transport thread
// that might be causing blocking, so we should change this to allow passing an executor to `runParallel`
List<Supplier<CompletableFuture<ResolutionResponse>>> runJobsSuppliers =
Arrays.stream(lines)
.flatMap(StreamUtil.tupleFlatmapper(new String[2]))
.map((tuple) -> (Supplier<CompletableFuture<ResolutionResponse>>) () -> {
final String paramsStr = tuple[0];
Map<String, String> params;
try {
params = Json.toStringMap(paramsStr);
} catch (Exception ex) {
ResolutionResponse failureResponse = new ResolutionResponse();
failureResponse.error = new BadRequestException("Could not parse parameters: " + paramsStr);
return CompletableFuture.completedFuture(failureResponse);
}
final String body = tuple[1];
return buildAndRunJobAsync(client, body, params, reqParams);
})
.collect(Collectors.toList());
int maxConcurrentJobs = config.getResolutionMaxConcurrentJobsPerRequest();
// Start timer and begin the jobs
final long startTime = System.nanoTime();
// maybe this belongs better in a BulkJob class
return CompletableFuture.supplyAsync(() -> CompletableFutureUtil.runParallel(runJobsSuppliers, maxConcurrentJobs).join(), resolutionExecutor)
.thenApply(UnCheckedFunction.from((jobResponses) -> {
BulkResolutionResponse response = new BulkResolutionResponse();
// mark as an error if any of the jobs failed
response.errors = jobResponses.stream().anyMatch(ResolutionResponse::isFailure);
response.items = jobResponses;
response.tookMs = Duration.ofNanos(System.nanoTime() - startTime).toMillis();
// Jackson needs reflection access, which requires escalated security
String responseJson = SecurityUtil.doPrivileged(
(CheckedSupplier<String, ?>) () -> responseWriter.writeValueAsString(response)
);
return new BytesRestResponse(RestStatus.OK, "application/json", responseJson);
}));
}
CompletableFuture<RestResponse> handleSingleJobRequest(NodeClient client, ObjectWriter responseWriter, String body, Map<String, String> reqParams) {
return buildAndRunJobAsync(client, body, reqParams, emptyMap())
.thenApply(UnCheckedFunction.from((res) -> {
// Jackson needs reflection access, which requires escalated security
String responseJson = SecurityUtil.doPrivileged((
CheckedSupplier<String, ?>) () -> responseWriter.writeValueAsString(res)
);
RestStatus status = res.isFailure() ? RestStatus.INTERNAL_SERVER_ERROR : RestStatus.OK;
return new BytesRestResponse(status, "application/json", responseJson);
}));
}
@Override
public List<Route> routes() {
return List.of(
new Route(POST, "_zentity/resolution"),
new Route(POST, "_zentity/resolution/_bulk"),
new Route(POST, "_zentity/resolution/{entity_type}"),
new Route(POST, "_zentity/resolution/{entity_type}/_bulk")
);
}
@Override
public String getName() {
return "zentity_resolution_action";
}
@Override
protected RestChannelConsumer prepareRequest(RestRequest restRequest, NodeClient client) {
if (!restRequest.hasContent()) {
// Validate the request body.
throw new BadRequestException("Request body is missing.");
}
// build and run all jobs, with a max concurrency for bulk jobs
// would be better to handle incoming content as a stream for bulk,
// but alas, unsure how to use the StreamInput format
final String body = restRequest.content().utf8ToString();
// Read all possible parameters into a map so that the handler knows we've consumed them
// and all other unknowns will be thrown as unrecognized
Map<String, String> reqParams = ParamsUtil.readAll(
restRequest,
PARAM_ENTITY_TYPE,
PARAM_PRETTY,
PARAM_INCLUDE_ATTRIBUTES,
PARAM_INCLUDE_ERROR_TRACE,
PARAM_INCLUDE_EXPLANATION,
PARAM_INCLUDE_HITS,
PARAM_INCLUDE_QUERIES,
PARAM_INCLUDE_SCORE,
PARAM_INCLUDE_SEQ_NO_PRIMARY_TERM,
PARAM_INCLUDE_SOURCE,
PARAM_INCLUDE_VERSION,
PARAM_MAX_DOCS_PER_QUERY,
PARAM_MAX_HOPS,
PARAM_MAX_TIME_PER_QUERY,
PARAM_PROFILE,
PARAM_SEARCH_ALLOW_PARTIAL_SEARCH_RESULTS,
PARAM_SEARCH_BATCHED_REDUCE_SIZE,
PARAM_SEARCH_MAX_CONCURRENT_SHARD_REQUESTS,
PARAM_SEARCH_PRE_FILTER_SHARD_SIZE,
PARAM_SEARCH_REQUEST_CACHE,
PARAM_SEARCH_PREFERENCE
);
// Parse the request params that govern the entire request/response
final boolean pretty = ParamsUtil.optBoolean(PARAM_PRETTY, false, reqParams, emptyMap());
return errorHandlingConsumer(channel -> {
final ObjectWriter writer = pretty
? Json.ORDERED_MAPPER.writerWithDefaultPrettyPrinter()
: Json.MAPPER.writer();
boolean isBulkRequest = restRequest.path().endsWith("_bulk");
CompletableFuture<RestResponse> handleFut = isBulkRequest
? handleBulkJobRequest(client, writer, body, reqParams)
: handleSingleJobRequest(client, writer, body, reqParams);
handleFut
.thenAccept(channel::sendResponse)
.exceptionally(channelErrorHandler(channel));
});
}
}
|
package com.mygdx.game;
import com.badlogic.gdx.graphics.Texture;
import com.badlogic.gdx.graphics.g2d.Animation;
import com.badlogic.gdx.graphics.g2d.SpriteBatch;
import com.badlogic.gdx.graphics.g2d.TextureRegion;
/**
* Created by dkotenko on 7/23/18.
*/
public class BulletAlien {
private final int SPEED = 8;
private static Texture texture;
Collision collision;
float x, y;
public boolean remove;
TextureRegion textureSplit[][];
TextureRegion textureAnimation[];
Animation animation;
public BulletAlien(float x, float y) {
this.x = x;
this.y = y;
remove = false;
texture = new Texture("BulletAlien.png");
textureSplit = TextureRegion.split(texture, 20, 20);
textureAnimation = new TextureRegion[15];
textureAnimation[0] = textureSplit[0][0];
textureAnimation[1] = textureSplit[0][1];
textureAnimation[2] = textureSplit[0][2];
textureAnimation[3] = textureSplit[0][3];
textureAnimation[4] = textureSplit[1][0];
textureAnimation[5] = textureSplit[1][1];
textureAnimation[6] = textureSplit[1][2];
textureAnimation[7] = textureSplit[1][3];
textureAnimation[8] = textureSplit[1][2];
textureAnimation[9] = textureSplit[1][1];
textureAnimation[10] = textureSplit[1][0];
textureAnimation[11] = textureSplit[0][3];
textureAnimation[12] = textureSplit[0][2];
textureAnimation[13] = textureSplit[0][1];
textureAnimation[14] = textureSplit[0][0];
animation = new Animation(1f/6f, textureAnimation);
collision = new Collision(18, 18, x, y);
}
public void update() {
y -= SPEED;
if (y < 0)
remove = true;
collision.update(x, y);
}
public void render(SpriteBatch batch, float elepsedTime) {
//batch.draw(tx, pos.x, pos.y);
batch.draw((TextureRegion) animation.getKeyFrame(elepsedTime, true), x, y);
}
public void checkPlayerCollision(Player player) {
if (collision.CollisionCheck(player.getCollision())) {
player.setLive(player.getLive() - 2);
remove = true;
}
}
}
|
package f.star.iota.milk.ui.meitumen.meitu;
import org.jsoup.Jsoup;
import org.jsoup.nodes.Element;
import org.jsoup.select.Elements;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import f.star.iota.milk.base.PVContract;
import f.star.iota.milk.base.StringPresenter;
public class MeiTuMenPresenter extends StringPresenter<List<MeiTuMenBean>> {
public MeiTuMenPresenter(PVContract.View view) {
super(view);
}
@Override
protected List<MeiTuMenBean> dealResponse(String s, HashMap<String, String> headers) {
List<MeiTuMenBean> list = new ArrayList<>();
Elements select = Jsoup.parse(s).select("#load-img > div.pos__1.camWholeBox.borderTop > ul > li.min-h-imgall");
for (Element element : select) {
MeiTuMenBean bean = new MeiTuMenBean();
String preview = element.select("a > img").attr("src");
bean.setPreview(preview);
String url = element.select("a").attr("href");
bean.setUrl(url);
bean.setHeaders(headers);
String description = element.select("a").attr("title");
bean.setDescription(description);
list.add(bean);
}
return list;
}
}
|
package com.becool.baidu.pojo;
public class HospitalDeptPrice {
private String name;
private String price;
private String apparatus;
private String therapy;
private String comfort;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getPrice() {
return price;
}
public void setPrice(String price) {
this.price = price;
}
public String getApparatus() {
return apparatus;
}
public void setApparatus(String apparatus) {
this.apparatus = apparatus;
}
public String getTherapy() {
return therapy;
}
public void setTherapy(String therapy) {
this.therapy = therapy;
}
public String getComfort() {
return comfort;
}
public void setComfort(String comfort) {
this.comfort = comfort;
}
}
|
package ru.gnkoshelev.jbreak2018.perf_tests.strings;
import org.openjdk.jmh.annotations.Benchmark;
import org.openjdk.jmh.annotations.BenchmarkMode;
import org.openjdk.jmh.annotations.Fork;
import org.openjdk.jmh.annotations.Measurement;
import org.openjdk.jmh.annotations.Mode;
import org.openjdk.jmh.annotations.OutputTimeUnit;
import org.openjdk.jmh.annotations.Param;
import org.openjdk.jmh.annotations.Scope;
import org.openjdk.jmh.annotations.Setup;
import org.openjdk.jmh.annotations.State;
import org.openjdk.jmh.annotations.Warmup;
import org.openjdk.jmh.infra.Blackhole;
import java.util.Random;
import java.util.concurrent.TimeUnit;
/**
* Created by kgn on 17.03.2018.
*/
@Fork(value = 3, warmups = 0)
@Warmup(iterations = 5, time = 1_500, timeUnit = TimeUnit.MILLISECONDS)
@Measurement(iterations = 10, time = 1_500, timeUnit = TimeUnit.MILLISECONDS)
@OutputTimeUnit(value = TimeUnit.MICROSECONDS)
@BenchmarkMode(Mode.AverageTime)
@State(Scope.Benchmark)
public class ImmutableStringBenchmark {
@Param({"10", "100", "1000", "10000"})
public int N;
public String[] strings;
@Setup
public void setup() {
Random rand = new Random(42);
strings = new String[N];
for (int i = 0; i < N; i++) {
strings[i] = String.valueOf(rand.nextInt());
}
}
@Benchmark
public void concatenationBenchmark(Blackhole bh) {
bh.consume(constructThroughConcatenation(strings));
}
@Benchmark
public void builderBenchmark(Blackhole bh) {
bh.consume(constructThroughBuilder(strings));
}
public static String constructThroughConcatenation(String[] strings) {
String result = "";
for (String s : strings) {
result = result + s;
}
return result;
}
public static String constructThroughBuilder(String[] strings) {
StringBuilder sb = new StringBuilder();
for (String s : strings) {
sb.append(s);
}
return sb.toString();
}
}
|
package com.fragrancepluscustomerdatabase.scottauman;
import android.app.Activity;
import android.support.v4.app.Fragment;
/**
* Created by Scott on 3/3/2016.
*/
public interface BackToActivity {
void attachNewFragment(Fragment fragment);
void openNewActiviyt(Activity activity);
}
|
package org.ohdsi.webapi.test;
import org.junit.Test;
import org.ohdsi.webapi.vocabulary.Domain;
import org.ohdsi.webapi.vocabulary.Vocabulary;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.http.ResponseEntity;
/**
*
*/
public class VocabularyServiceIT extends WebApiIT {
@Value("${vocabularyservice.endpoint.vocabularies}")
private String endpointVocabularies;
@Value("${vocabularyservice.endpoint.concept}")
private String endpointConcept;
@Value("${vocabularyservice.endpoint.domains}")
private String endpointDomains;
@Test
public void concept() {
log.info("Testing concept endpoint");
final ResponseEntity<String> entity = getRestTemplate().getForEntity(this.endpointConcept, String.class);
assertOK(entity);
}
@Test
public void vocabularies() {
log.info("Testing vocabulary endpoint");
final ResponseEntity<String> entity = getRestTemplate().getForEntity(this.endpointVocabularies, String.class);
assertOK(entity);
//or
Vocabulary[] vocabularies = getRestTemplate().getForObject(this.endpointVocabularies, Vocabulary[].class);
for (Vocabulary v : vocabularies) {
log.debug("Vocab: " + v.vocabularyName);
}
}
@Test
public void domains() {
log.info("Testing domain endpoint");
final ResponseEntity<String> entity = getRestTemplate().getForEntity(this.endpointDomains, String.class);
assertOK(entity);
//or
Domain[] domains = getRestTemplate().getForObject(this.endpointDomains, Domain[].class);
for (Domain d : domains) {
log.debug("Domain:" + d.domainName);
}
}
}
|
package com.git.cloud.resmgt.network.model.po;
import com.git.cloud.common.model.base.BaseBO;
/**
* @Title RmNwSecureAreaPo.java
* @Package com.git.cloud.resmgt.network.model.po
* @author syp
* @date 2014-9-15下午4:32:26
* @version 1.0.0
* @Description
*
*/
public class RmNwSecureAreaPo extends BaseBO implements java.io.Serializable{
// Fields
private static final long serialVersionUID = 1L;
private String secureAreaId;
private String secureAreaName;
private String isActive;
// private String createUser;
// private Timestamp createTime;
// private String updateUser;
// private Timestamp updateTime;
// Constructors
/** default constructor */
public RmNwSecureAreaPo() {
}
/** full constructor */
public RmNwSecureAreaPo(String secureAreaId, String secureAreaName,
String isActive
// , String createUser, Timestamp createTime,String updateUser, Timestamp updateTime
) {
super();
this.secureAreaId = secureAreaId;
this.secureAreaName = secureAreaName;
this.isActive = isActive;
// this.createUser = createUser;
// this.createTime = createTime;
// this.updateUser = updateUser;
// this.updateTime = updateTime;
}
// Property accessors
public String getSecureAreaId() {
return secureAreaId;
}
public void setSecureAreaId(String secureAreaId) {
this.secureAreaId = secureAreaId;
}
public String getSecureAreaName() {
return secureAreaName;
}
public void setSecureAreaName(String secureAreaName) {
this.secureAreaName = secureAreaName;
}
public String getIsActive() {
return isActive;
}
public void setIsActive(String isActive) {
this.isActive = isActive;
}
/* (non-Javadoc)
* @see com.git.cloud.common.model.base.BaseBO#getBizId()
*/
@Override
public String getBizId() {
// TODO Auto-generated method stub
return null;
}
}
|
package tw.org.iiijava;
import java.io.File;
import java.io.FileReader;
public class zora36 {
public static void main(String[] args) {
File file1 = new File("test/this1");
try{
FileReader reader = new FileReader(file1);
int c;
while((c=reader.read()) != -1){
System.out.print((char)c);
}
reader.close();
}catch(Exception e){
System.out.println(e.toString());
}
}
}
|
package net.yustinus.crud.web.base;
import org.zkoss.bind.annotation.GlobalCommand;
import org.zkoss.zk.ui.Executions;
public class NavbarVM {
@GlobalCommand("logout")
public void logout() {
Executions.sendRedirect("/login?logout");
}
}
|
package baitap;
import java.util.Scanner;
public class bai2 {
public static void main(String[]args) {
Scanner scanner = new Scanner(System.in);
int a;
int b;
int c;
a = scanner.nextInt();
b = scanner.nextInt();
c = scanner.nextInt();
if (a==0) {
if(b==0) {
if (c==0) {
System.out.println(" phuong trinh vo so nghiem");
}}else if(b != 0) {
System.out.println(" phuong trinh co 1 nghiem");
}else {
System.out.println(" phuong trinh vo nghiem");
}
}else if (a !=0 ){
int d = (b*b-4*a*c) ;
if(d<0) {
System.out.println(" phuong trinh vo nghiem");
}else if(d==0) {
int x= -b/(2*a) ;
System.out.println(" phuong trinh có 1 nghiem kep ");
}else {
int x1=(-b+sqrt(d))/(2*a);
int x2=(-b-sqrt(d))/(2*a);
System.out.println(" phuong trinh có 2 nghiem phan biêt ");
}
}
}
private static int sqrt(int d) {
// TODO Auto-generated method stub
return 0;
}
}
|
package phase01;
import java.util.ArrayList;
import java.util.Scanner;
public class TextUtilities extends Formatting{
/************************** Attribute ************************/
public static int lengthText = 0; // Total characters
public int wordCount = 0; // Total words
// Constructor with parameter
public TextUtilities(String input) {
super(input);
}
// Constructor default
public TextUtilities() {
super();
}
/************************** METHOD **************************/
// Break lines text after re-format
public String[] breakLines(String str) {
str = this.reformatText(str);
String[] arr = str.split("(?<=[.])");
return arr;
}
// Sort text after break lines
public String sortText(String str) {
return null;
}
// Add line number for each line after sort text
public String addLine(String str) {
return null;
}
// Count Words from input text
public int countWords(String str) {
// Remove extra space
str = str.replaceAll("\\s{2,}", " ").trim();
if(str.charAt(0) != ' ') {
wordCount = 1;
wordCount+= str.length() - str.replaceAll(" ", "").length();
}
return wordCount;
}
// Get Number List from raw text
public int[] getNumberList(String str) {
str = str.replaceAll("[^0-9]+", " ");
Scanner scanner = new Scanner(str);
ArrayList<Integer> list = new ArrayList<Integer>();
while (scanner.hasNextInt()) {
list.add(scanner.nextInt());
}
scanner.close();
int[] result = new int[list.size()];
for(int i=0; i<list.size(); i++) {
result[i] = list.get(i);
}
return result;
}
// Print array int
public String printArrayInt(int[] arr) {
String result = "";
for(int i:arr) {
result+= arr[i] + ", ";
}
return result;
}
//Print array String
public String printArrayString(String[] arr){
String result = "";
for(String a:arr) {
result+= a + "\n";
}
return result;
}
}
|
package com.java.util.fuxi.demo5;
public class SmartPhoneTest {
public static void main(String[] args) {
SmartPhone smartPhone = new SmartPhone();
smartPhone.sendMessage();
}
}
|
/**
* Definition for singly-linked list.
* public class ListNode {
* int val;
* ListNode next;
* ListNode(int x) {
* val = x;
* next = null;
* }
* }
*/
public class Solution {
public ListNode getIntersectionNode(ListNode headA, ListNode headB) {
if(headA == null || headB == null) return null;
ListNode run = headA;
ListNode run2 = headA;
//
int length1 = 0;
while(run != null){
run = run.next;
length1++;
}
//
run = headB;
int length2 = 0;
while(run != null){
run = run.next;
length2++;
}
//
int diff = 0;
if(length1 >= length2){
diff = length1 - length2;
run = headA;
run2 = headB;
}else{
diff = length2 - length1;
run = headB;
}
for(int i = 0; i < diff; i++){
run = run.next;
}
while(run != null && run2 != null){
if(run == run2) return run;
run = run.next;
run2 = run2.next;
}
return null;
}
}
|
package com.ctg.itrdc.janus.common.compiler.support;
import static org.hamcrest.CoreMatchers.allOf;
import static org.junit.Assert.assertThat;
import static org.junit.matchers.JUnitMatchers.containsString;
import javassist.ClassPool;
import javassist.LoaderClassPath;
import org.junit.Test;
import com.ctg.itrdc.janus.common.compiler.Compiler;
import com.ctg.itrdc.janus.common.utils.ClassHelper;
/**
* @author Administrator
*/
public class JavassistCompilerTest extends BaseCompilerTest {
JavassistCompiler compiler = new JavassistCompiler();
public void before() {
ClassPool pool = new ClassPool(true);
pool.appendClassPath(new LoaderClassPath(ClassHelper
.getCallerClassLoader(getClass())));
}
@Override
protected Compiler getCompiler() {
return compiler;
}
@Test
public void testErrorClass() throws Exception {
try {
String classContent = readErrorClassContent();
getCompiler().compile(classContent,
JdkCompiler.class.getClassLoader());
} catch (IllegalStateException expected) {
assertThat(expected.getMessage(),
allOf(containsString("Failed to compile class")));
}
}
}
|
package com.esum.comp.uadacom;
import java.util.HashMap;
import java.util.Map;
import com.esum.framework.core.component.code.ComponentCode;
/**
* UA Dacom Error Codes.
*/
public class UaDacomCode extends ComponentCode {
/*
번호 에러코드 에러원인
1 UADA01 UAINFO 로딩 에러
2 UADA02 DACOM 서버 접속 에러
3 UADA03 DACOM 서버 와의 통신중 에러
*/
public static final String ERROR_LOAD_UAINFO = "UADA01";
public static final String ERROR_CONN_DACOM = "UADA02";
public static final String ERROR_COMM_DACOM = "UADA03";
public static Map<String, String> codeMap = new HashMap<String, String>();
static {
codeMap.put("000", "Normal");
codeMap.put("001", "System Fault!!");
codeMap.put("002", "UserID Error!!");
codeMap.put("003", "Password Error!!");
codeMap.put("004", "Job Type Error!!");
codeMap.put("005", "No Correspondent Data!!");
codeMap.put("006", "Message Type Error!!");
codeMap.put("007", "Transmission Bytes Error!!");
codeMap.put("008", "Transmission Type Error!!");
codeMap.put("010", "Communication Buffer Size Error!!");
codeMap.put("015", "Already connected!!");
codeMap.put("099", "Extra Error!!");
}
public static String getRespCode(String index){
return codeMap.get(index);
}
}
|
import javafx.event.ActionEvent;
import javafx.fxml.FXML;
import javafx.fxml.FXMLLoader;
import javafx.fxml.Initializable;
import javafx.scene.Node;
import javafx.scene.Parent;
import javafx.scene.Scene;
import javafx.scene.control.Button;
import javafx.scene.control.TextArea;
import javafx.stage.Stage;
import java.net.URL;
import java.util.ResourceBundle;
public class AddWord implements Initializable {
@FXML
public TextArea english;
@FXML
public TextArea vietnamese;
@FXML
public Button add;
@Override
public void initialize(URL location, ResourceBundle resources) {
}
public void add(ActionEvent event) throws Exception {
String e=english.getText();
String v= vietnamese.getText();
Word temp = new Word(e, v);
Dictionary.addWord(temp);
Controller.updateFile();
Stage stage = (Stage)((Node) event.getSource()).getScene().getWindow();
FXMLLoader loader = new FXMLLoader();
loader.setLocation(getClass().getResource("sample.fxml"));
Parent add = loader.load();
Scene scene = new Scene(add);
stage.setScene(scene);
}
}
|
package fr.eni.groupe2.bll;
import java.util.ArrayList;
import java.util.List;
import fr.eni.groupe2.bo.Utilisateur;
import fr.eni.groupe2.dal.DAO;
import fr.eni.groupe2.dal.DAOFactory;
import fr.eni.groupe2.messages.BusinessException;
import fr.eni.groupe2.messages.DALException;
/**
*
* @author groupe 2
* UtilisateurManager permet la communication avec la couche DAL pour la lecture et l'enregistrement des données
*
*
*/
public class UtilisateurManager {
// mes attibues
private static DAO<Utilisateur> utilisateurDAO= DAOFactory.getUtilisateurDAO();
/**
* ajouterUtilisateur vérifie l'existance et ajoute un utilisateur à la base.
* @param utilisateur
* @return
* @throws DALException
* @throws BusinessException
*/
public static boolean ajouterUtilisateur(Utilisateur utilisateur) throws DALException, BusinessException {
boolean ok = false ;
List<Utilisateur> utilisateurs = new ArrayList<Utilisateur>();
utilisateurs = listerUtlisateur();
//vérification avant insertion pour éviter les doublons
for (Utilisateur utilisateurVerif : utilisateurs) {
if (utilisateurVerif.getPseudo().equals(utilisateur.getPseudo())
&&(utilisateurVerif.getNom().equals(utilisateur.getNom()))
&&(utilisateurVerif.getPrenom().equals(utilisateur.getPrenom()))
&&(utilisateurVerif.getEmail().equals(utilisateur.getEmail()))){
ok = false;
}else {
ok = true;
}
}
if (ok) {
utilisateurDAO.insert(utilisateur);
}
return ok;
}
/**
* listerUtilisateur permet de rendre la liste de tout les utilisateurs
* @throws DALException
* @throws BusinessException
*/
public static List<Utilisateur> listerUtlisateur () throws DALException, BusinessException{
return utilisateurDAO.selectAll();
}
/**
* rechercherUtilisateur permet de rechercher un utilisateur en base via son ID.
* @throws DALException
* @throws BusinessException
*/
public static Utilisateur rechercherUtilisateur(int id) throws DALException, BusinessException {
return utilisateurDAO.selectByID(id);
}
/**
* modificationUtilisateur permet de mettre à jour les données d'un utilisateur.
* @param noUtilisateur
* @param pseudo
* @param nom
* @param prenom
* @param email
* @param telephone
* @param rue
* @param codePostal
* @param ville
* @param motDePasse
* @param motDePasseBis
* @param credit
* @param administrateur
* @return
*/
public Utilisateur modificationUtilisateur(int noUtilisateur, String pseudo, String nom, String prenom,
String email, String telephone, String rue, String codePostal, String ville, String motDePasse,
String motDePasseBis, int credit, boolean administrateur) {
Utilisateur utilisateur = null;
try {
utilisateur = new Utilisateur(noUtilisateur, pseudo, nom, prenom, email, telephone, rue, codePostal,
ville, motDePasse, credit, administrateur);
DAOFactory.getUtilisateurDAO().update(utilisateur);
return utilisateur;
} catch (BusinessException | DALException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
return utilisateur;
}
}
|
// Class name should be the same as File name
// one class per file
// public
public class KPointMain {
// special method: main()
// where the program starts
// public or private
// static
// have to have: return type!! (void)
// method name (main)
// list of arguments (or empty () )
// { }
public static void main(String[] args){
System.out.println("Starting class KPointMain");
}
// mininmal method
void test1(){
}
} |
package com.example.event_project.model;
import lombok.AllArgsConstructor;
import lombok.Builder;
import lombok.Data;
import lombok.NoArgsConstructor;
import javax.persistence.*;
@Data
@Entity
@Builder
@NoArgsConstructor
@AllArgsConstructor
public class OrganizerToAdd {
@Id
@GeneratedValue(strategy = GenerationType.IDENTITY)
private Long id;
@ManyToOne
private Event event;
private String userEmail;
public OrganizerToAdd(Event event, String userEmail) {
this.event = event;
this.userEmail = userEmail;
}
}
|
package Aviary;
import java.util.HashMap;
import java.util.Map;
public class Aviary<T> {
private AviarySize aviarySize;
public Aviary(AviarySize aviarySize) {
this.aviarySize = aviarySize;
}
public Aviary() {
aviarySize = AviarySize.MEDIUM;
}
private final Map<String, T> listAnimals = new HashMap<>();
public void printAnimals() {
for (String key: listAnimals.keySet()) {
System.out.println(key + " " + listAnimals.get(key));
}
}
public T getAnimal (String id) {
return listAnimals.get(id);
}
public void delAnimal (String id) {
listAnimals.remove(id);
}
public void addAnimal(String id, T animal, AviarySize aviarySize) {
if (this.aviarySize == aviarySize) {
listAnimals.put(id, animal);
}
}
}
|
package com.infohold.elh.base.model;
import javax.persistence.Entity;
import javax.persistence.Table;
import com.infohold.core.model.BaseIdModel;
/**
* 医生常规就诊时间安排
* @author Administrator
*
*/
@Entity
@Table(name="ELH_DOCTOR_DUTY")
public class DoctorDuty extends BaseIdModel {
/**
*
*/
private static final long serialVersionUID = 1826210740042076986L;
private String doctor;//医生
private String name; //医生名字
private String dayBy;//时间单位
private int day;//日期
private String noon;//上下午
private int startHour;//开始时间（小时）
private int endHour;//结束时间（小时）
private String amount;//挂号费
public String getDoctor() {
return doctor;
}
public void setDoctor(String doctor) {
this.doctor = doctor;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getDayBy() {
return dayBy;
}
public void setDayBy(String dayBy) {
this.dayBy = dayBy;
}
public int getDay() {
return day;
}
public void setDay(int day) {
this.day = day;
}
public String getNoon() {
return noon;
}
public void setNoon(String noon) {
this.noon = noon;
}
public int getStartHour() {
return startHour;
}
public void setStartHour(int startHour) {
this.startHour = startHour;
}
public int getEndHour() {
return endHour;
}
public void setEndHour(int endHour) {
this.endHour = endHour;
}
public String getAmount() {
return amount;
}
public void setAmount(String amount) {
this.amount = amount;
}
}
|
package br.edu.unoescsmo.aluga.regras;
import java.util.List;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import br.edu.unoescsmo.aluga.interfaces.ImovelInterface;
import br.edu.unoescsmo.aluga.model.Imovel;
import br.edu.unoescsmo.aluga.repository.ImovelRepository;
@Service
public class ImovelPadrao implements ImovelInterface {
@Autowired
private ImovelRepository imovelRepository;
@Override
public void salvar(Imovel professor) {
imovelRepository.save(professor);
}
@Override
public void delete(Imovel professor) {
imovelRepository.delete(professor);
}
@Override
public List<Imovel> listar() {
return imovelRepository.findAll();
}
@Override
public Imovel buscarPorCodigo(Long codigo) {
return imovelRepository.findById(codigo).orElse(new Imovel());
}
}
|
package com.sbs.sbsattend.model;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Date;
import java.util.List;
import com.sbs.sbsattend.db.DBConnection;
import com.sbs.tool.MySignal;
import com.sbs.tool.SpecialCalendar;
public class Logic {
//private static String path = "http://10.0.2.2:8080/web/";
private static String path = "http://192.168.0.200:8081/web/";
public static Person login(String name, String pwd) throws Exception
{
String sql = "select * from dbo.permission where userid ='" + name + "' and pwd='" + pwd +"'";
String subpath = "LoginServlet";
//POST发送查询指令
List<Person> pes = DBConnection.getPerson(sql, path + subpath);
if(!pes.isEmpty() && pes.size()== 1)
{
return pes.get(0);
}else
{
System.out.println("获取人员信息失败");
return null;
}
}
public static List<Leave> query_leavetimeall()
{
String subpath = "ReivewLeaveServlet";
SimpleDateFormat df = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");//设置日期格式
String date = df.format(new Date());
String time = date.substring(0,4) + "-" + date.substring(5,7);
//String sql = "select * from dbo.workoff where convert(varchar(50),starttime,120) like '"+ time + "%' and approve=4";
String sql = "select * from dbo.workoff where (convert(varchar(50),starttime,120) like '"+ time + "%' or convert(varchar(50),endtime,120) like '"+time + "%') and approve=4";
//POST发送查询指令
return DBConnection.getLeave(sql, path + subpath);
}
//导出请假申请
public static List<Leave> query_leavetime()
{
String sql = "select * from dbo.workoff where approve=-1";
String subpath = "ReivewLeaveServlet";
//POST发送查询指令
return DBConnection.getLeave(sql, path + subpath);
}
//导出本月值班表
public static List<WorkHistory> query_monthlyworkinfo()
{
String subpath = "QueryWorktHistoryServlet";
SimpleDateFormat df = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");//设置日期格式
Date now = new Date();
String date = df.format(now);
String time = date.substring(0,7);
SpecialCalendar sp = new SpecialCalendar();
//本月
String sql = "select * from workhistory where convert(varchar(50),worktime,120) like '"+ time +"%'";
List<WorkHistory> wh = DBConnection.getWorkHistory(sql, path+subpath);
//上月末最后一天
time = sp.getlastdaystr();
sql = "select * from workhistory where convert(varchar(50),worktime,120) like '"+ time +"%'";
wh.add(0,(WorkHistory) DBConnection.getWorkHistory(sql, path+subpath).get(0));
return wh;
}
//导出本月调休申请结果
public static List<Work> query_monthlyovertime(String name)
{
String subpath = "ReivewOverTimeServlet";
SimpleDateFormat df = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");//设置日期格式
String date = df.format(new Date());
String time = date.substring(0,4) + "-" + date.substring(5,7);
//String sql = "select * from dbo.overtime where convert(varchar(50),originwork,120) like '"+ time + "%' and name='"+ name +"'";
SpecialCalendar sp = new SpecialCalendar();
String time2 = sp.getlastdaystr();
String sql = "select * from dbo.overtime where convert(varchar(50),originwork,120) like '"+ time + "%' or convert(varchar(50),originwork,120) like '"+time2+"%' and name='"+ name +"'";
System.out.println(sql);
//POST发送查询指令
return DBConnection.getWork(sql, path + subpath);
}
//导出本月请假申请结果
public static List<Leave> query_monthlyleavetime(String name)
{
String subpath = "ReivewLeaveServlet";
SimpleDateFormat df = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");//设置日期格式
String date = df.format(new Date());
String time = date.substring(0,4) + "-" + date.substring(5,7);
String sql = "select * from workoff where convert(varchar(50),starttime,120) like '"+ time + "%' and name='"+ name +"'";
//POST发送查询指令
return DBConnection.getLeave(sql, path + subpath);
}
//请假申请
public static int commit_leaevtime(String name, String start, String end, String originshift, String currentshift, String oweek, String cweek, String res)
{
int flag = 0;
String subpath = "CommitTakeLeaveServlet";
//生成请假申请信息
String sql = "insert into dbo.workoff values('" + name + "','" + start + "','"+ end + "','"+ originshift + "','"+ currentshift + "','"
+ oweek + "','" + cweek + "','"+ res +"',-1)";
//POST发送查询指令
flag = DBConnection.exectue(sql, path + subpath);
return flag;
}
//提交调休审核结果
public static int approve_overtime(Work work)
{
int flag = 0;
String subpath = "CommitOverTimeServlet";
String sql = "update dbo.overtime set approve = "+ work.getApprove() +"where name='" + work.getName() + "' and ID="+ work.getId();
//POST发送查询指令
flag = DBConnection.exectue(sql, path + subpath);
return flag;
}
//提交请假审核结果
public static int approve_leavetime(Leave leave)
{
int flag = 0;
String subpath = "CommitTakeLeaveServlet";
String sql = "update workoff set approve = "+ leave.getApprove() +"where name='" + leave.getName() + "' and ID="+ leave.getID();
//POST发送查询指令
flag = DBConnection.exectue(sql, path + subpath);
return flag;
}
//导出某人当月调休信息
public static List<String> query_work(String name){
String subpath = "QueryWorktTimeServlet";
SimpleDateFormat df = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");//设置日期格式
Date now = new Date();
String date = df.format(now);
String time = date.substring(0,7);
SpecialCalendar sp = new SpecialCalendar();
List<String> result = new ArrayList<String>();
List<String> early = query_early(name, time, path + subpath);//当月
List<String> late = query_late(name, time, path + subpath);
List<String> last = null; //上个月最后一天
//上月末最后一天
time = sp.getlastdaystr();
last = query_late(name, time, path + subpath);
for(String l : early)
{
result.add(l+" 当天下午");
}
for(String l : late)
{
result.add(l+" 明天上午");
}
if(!last.get(0).equals("-1")){
result.add(last.get(0).toString() +" 明天上午");
}
return result;
}
/*导出本月所有人员的调休申请信息，此接口已废弃*/
public static List<Work> query_overtimeall()
{
String subpath = "ReivewOverTimeServlet";
SimpleDateFormat df = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");//设置日期格式
String date = df.format(new Date());
String time = date.substring(0,4) + "-" + date.substring(5,7);
//String sql = "select * from dbo.overtime where convert(varchar(50),originwork,120) like '"+ time + "%' and approve=4";
String sql = "select * from dbo.overtime where (convert(varchar(50),originwork,120) like '"+ time + "%' or convert(varchar(50),overwork,120) like '"+time +"%') and approve=4";
//POST发送查询指令
return DBConnection.getWork(sql, path + subpath);
}
public static List<Work> query_overtime()
{
String sql = "select * from dbo.overtime where approve=-1";
String subpath = "ReivewOverTimeServlet";
//POST发送查询指令
return DBConnection.getWork(sql, path + subpath);
}
//早班
public static List<String> query_early(String name, String time, String path)
{
String sql = "select convert(varchar(50),worktime,120) as worktime from workhistory where convert(varchar(50),worktime,120) like '"+ time +"%'" + "and worker='"
+ name + "'";
return DBConnection.getWorkInfo(sql, path);
}
//晚班
public static List<String> query_late(String name, String time, String path)
{
String sql = "select convert(varchar(50),worktime,120) as worktime from workhistory where convert(varchar(50),worktime,120) like '"+ time +"%'" + "and worker1='"
+ name + "'";
System.out.println(sql);
return DBConnection.getWorkInfo(sql, path);
}
//调休申请
public static int commit_overtime(String name, String origin, String current, String origin_shift, String current_shift, String currentweek, String originweek, String res)
{
int flag = 0;
String subpath = "CommitOverTimeServlet";
//生存调休申请信息
String sql = "insert into dbo.overtime values('" + name + "','" + origin+ "','"+ current + "','"+ origin_shift+ "','"+ current_shift
+ "','" + originweek + "','" + currentweek + "','"+ res +"',-1)";
//POST发送查询指令
flag = DBConnection.exectue(sql, path + subpath);
return flag;
}
//此接口暂保留，但无用，获取原始调休时间对应值班记录
/*public static Work query_overinfo(String name, String date)
{
String subpath = "QueryWorktInfoServlet";
String day = date.substring(0, date.indexOf(" "));
String sql = "select worker, worker1 as affectnum from dbo.workhistory where convert(varchar(50),worktime,120) like '" + day +"%'"
+ "and (worker = '" + name +"' or worker1 = '" + name +"')";
System.out.println(sql);
return DBConnection.getWork(sql, path + subpath);
}*/
//此接口暂保留，但无用
/*public static int query_overtime(String name, String date)
{
String subpath = "QueryWorktTimeServlet";
//仅值班当天可选调休,当天应只有一条记录
int flag = 0;
String day = date.substring(0, date.indexOf(" ")) ;
System.out.println(day);
String sql = "select count(*) as affectnum from dbo.workhistory where convert(varchar(50),worktime,120) like '" + day +"%'"
+ "and (worker = '" + name +"' or worker1 = '" + name +"')";
flag = DBConnection.exectue(sql, path + subpath);
System.out.println("affectnum:"+flag);
return flag;
}*/
}
|
package com.lfalch.korome;
import java.io.IOException;
import java.net.DatagramSocket;
import java.net.InetAddress;
import java.net.SocketException;
import java.net.UnknownHostException;
import com.lfalch.korome.packets.InvalidPacketException;
import com.lfalch.korome.packets.Packet;
import com.lfalch.korome.packets.PacketMethod;
@Deprecated
public class Client extends Thread{
public Client() throws UnknownHostException, SocketException {
super();
address = InetAddress.getByName("localhost");
socket = new DatagramSocket();
}
InetAddress address;
int port = 45565;
DatagramSocket socket;
@Override
public void run() {
try {
Packet p = new Packet(PacketMethod.LOGIN, PacketMethod.LOGIN.generateAttribute("Id", "Words! Yes!"));
p.send(socket, address, port);
p = Packet.receive(socket);
System.out.println(p.getAddress().getHostAddress() + ":" + p.getPort() + " " + p.getContent());
p = new Packet(PacketMethod.DISCONNECT, PacketMethod.DISCONNECT.generateAttribute("Reason", "User disconnect"));
socket.close();
}
catch (IOException e) {
e.printStackTrace();
}catch (InvalidPacketException e) {
e.printStackTrace();
}
socket.close();
}
}
|
package rdfsynopsis.eval;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.PrintStream;
import java.io.PrintWriter;
import java.util.ArrayList;
import java.util.List;
import rdfsynopsis.analyzer.Analyzer;
import rdfsynopsis.statistics.StatisticalCriterion;
public abstract class AbstractAnalysisLogger extends AbstractEvaluator
implements Analyzer {
protected List<StatisticalCriterion> criteria;
private PrintWriter printer;
public AbstractAnalysisLogger(String title, boolean timeStamp) {
super(title, timeStamp);
criteria = new ArrayList<StatisticalCriterion>();
}
@Override
public void evaluate(File outDir, String titleAddition) {
// initialize criteria
for (StatisticalCriterion sc : criteria) {
sc.init();
}
try {
File outFile = makeTitleFile(title + titleAddition, outDir,".csv",timeStamp);
printer = new PrintWriter(outFile);
performAnalysis(null);
} catch (FileNotFoundException e) {
logger.error(e);
} finally {
if (printer != null)
printer.close();
}
}
protected void writeLogLine(String line) {
logger.trace("New log line: "+line);
printer.println(line);
}
@Override
public abstract void performAnalysis(PrintStream ps);
@Override
public AbstractAnalysisLogger addCriterion(StatisticalCriterion sc) {
criteria.add(sc);
return this;
}
@Override
public List<StatisticalCriterion> getCriteria() {
return criteria;
}
@Override
public int hashCode() {
final int prime = 31;
int result = 1;
result = prime * result
+ ((criteria == null) ? 0 : criteria.hashCode());
return result;
}
@Override
public boolean equals(Object obj) {
if (this == obj)
return true;
if (obj == null)
return false;
if (getClass() != obj.getClass())
return false;
AbstractAnalysisLogger other = (AbstractAnalysisLogger) obj;
if (criteria == null) {
if (other.criteria != null)
return false;
} else if (!criteria.equals(other.criteria))
return false;
return true;
}
}
|
package dao;
public class GoodsListSearchKeywordsDto {
private String goodsNo;
private String color;
private String memo;
private String goodsName;
private String fromYear;
private String fromMonth;
private String fromDay;
private String toYear;
private String toMonth;
private String toDay;
private String kind;
public String getGoodsNo() {
return goodsNo != null ? goodsNo : "";
}
public void setGoodsNo(String goodsNo) {
this.goodsNo = goodsNo;
}
public String getColor() {
return color != null ? color : "";
}
public void setColor(String color) {
this.color = color;
}
public String getMemo() {
return memo != null ? memo : "";
}
public void setMemo(String memo) {
this.memo = memo;
}
public String getGoodsName() {
return goodsName != null ? goodsName : "";
}
public void setGoodsName(String goodsName) {
this.goodsName = goodsName;
}
public String getFromYear() {
return fromYear != null ? fromYear : "";
}
public void setFromYear(String fromYear) {
this.fromYear = fromYear;
}
public String getFromMonth() {
return fromMonth != null ? fromMonth : "";
}
public void setFromMonth(String fromMonth) {
this.fromMonth = fromMonth;
}
public String getFromDay() {
return fromDay != null ? fromDay : "";
}
public void setFromDay(String fromDay) {
this.fromDay = fromDay;
}
public String getToYear() {
return toYear != null ? toYear : "";
}
public void setToYear(String toYear) {
this.toYear = toYear;
}
public String getToMonth() {
return toMonth != null ? toMonth : "";
}
public void setToMonth(String toMonth) {
this.toMonth = toMonth;
}
public String getToDay() {
return toDay != null ? toDay : "";
}
public void setToDay(String toDay) {
this.toDay = toDay;
}
public String getKind() {
return kind != null ? kind : "";
}
public void setKind(String kind) {
this.kind = kind;
}
}
|
package hu.logout.example.divinity.phone;
import android.Manifest;
import android.content.pm.PackageManager;
import android.os.Bundle;
import android.support.design.widget.TabLayout;
import android.support.v4.app.ActivityCompat;
import android.support.v4.app.Fragment;
import android.support.v4.app.FragmentManager;
import android.support.v4.app.FragmentPagerAdapter;
import android.support.v4.view.ViewPager;
import android.support.v7.app.AppCompatActivity;
import android.support.v7.widget.Toolbar;
import android.util.Log;
import java.util.ArrayList;
import java.util.List;
import hu.logout.example.divinity.phone.fragments.Contacts2Fragment;
import hu.logout.example.divinity.phone.fragments.DialerFragment;
public class MainActivity extends AppCompatActivity {
private Toolbar toolbar;
private TabLayout tabLayout;
private ViewPager viewPager;
final int MY_PERMISSIONS = 0;
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
ActivityCompat.requestPermissions(
MainActivity.this,
new String[]{
Manifest.permission.CALL_PHONE,
Manifest.permission.READ_CONTACTS},
MY_PERMISSIONS);
setContentView(R.layout.activity_main);
toolbar = findViewById(R.id.toolbar);
setSupportActionBar(toolbar);
getSupportActionBar().setDisplayHomeAsUpEnabled(false);
viewPager = findViewById(R.id.container);
tabLayout = findViewById(R.id.tabs);
tabLayout.setupWithViewPager(viewPager);
}
private void setupViewPager(ViewPager viewPager) {
ViewPagerAdapter adapter = new ViewPagerAdapter(getSupportFragmentManager());
adapter.addFragment(new DialerFragment(), "Dialer");
adapter.addFragment(new Contacts2Fragment(), "Contacts");
viewPager.setAdapter(adapter);
}
@Override
public void onRequestPermissionsResult(int requestCode,
String permissions[], int[] grantResults) {
switch (requestCode) {
case MY_PERMISSIONS: {
// Ha a kérelmezésel lett utasítva a tömb üres
if (grantResults.length > 0
&& grantResults[0] == PackageManager.PERMISSION_GRANTED
&& grantResults[1] == PackageManager.PERMISSION_GRANTED) {
Log.d("REQUESTS:", "GRANTED");
// Ha mind a két jog meg lett adva csak akkor inicializáljuk a ViewPager-t
setupViewPager(viewPager);
} else {
Log.d("REQUESTS:", "DENIED");
}
return;
}
}
}
class ViewPagerAdapter extends FragmentPagerAdapter {
private final List<Fragment> mFragmentList = new ArrayList<>();
private final List<String> mFragmentTitleList = new ArrayList<>();
public ViewPagerAdapter(FragmentManager manager) {
super(manager);
}
@Override
public Fragment getItem(int position) {
return mFragmentList.get(position);
}
@Override
public int getCount() {
return mFragmentList.size();
}
public void addFragment(Fragment fragment, String title) {
mFragmentList.add(fragment);
mFragmentTitleList.add(title);
}
@Override
public CharSequence getPageTitle(int position) {
return mFragmentTitleList.get(position);
}
}
} |
/**
* This class is generated by jOOQ
*/
package schema.tables.records;
import javax.annotation.Generated;
import org.jooq.Field;
import org.jooq.Record1;
import org.jooq.Record4;
import org.jooq.Row4;
import org.jooq.impl.UpdatableRecordImpl;
import schema.tables.AssessmentTrainingexample;
/**
* This class is generated by jOOQ.
*/
@Generated(
value = {
"http://www.jooq.org",
"jOOQ version:3.8.4"
},
comments = "This class is generated by jOOQ"
)
@SuppressWarnings({ "all", "unchecked", "rawtypes" })
public class AssessmentTrainingexampleRecord extends UpdatableRecordImpl<AssessmentTrainingexampleRecord> implements Record4<Integer, String, String, Integer> {
private static final long serialVersionUID = -1380638913;
/**
* Setter for <code>bitnami_edx.assessment_trainingexample.id</code>.
*/
public void setId(Integer value) {
set(0, value);
}
/**
* Getter for <code>bitnami_edx.assessment_trainingexample.id</code>.
*/
public Integer getId() {
return (Integer) get(0);
}
/**
* Setter for <code>bitnami_edx.assessment_trainingexample.raw_answer</code>.
*/
public void setRawAnswer(String value) {
set(1, value);
}
/**
* Getter for <code>bitnami_edx.assessment_trainingexample.raw_answer</code>.
*/
public String getRawAnswer() {
return (String) get(1);
}
/**
* Setter for <code>bitnami_edx.assessment_trainingexample.content_hash</code>.
*/
public void setContentHash(String value) {
set(2, value);
}
/**
* Getter for <code>bitnami_edx.assessment_trainingexample.content_hash</code>.
*/
public String getContentHash() {
return (String) get(2);
}
/**
* Setter for <code>bitnami_edx.assessment_trainingexample.rubric_id</code>.
*/
public void setRubricId(Integer value) {
set(3, value);
}
/**
* Getter for <code>bitnami_edx.assessment_trainingexample.rubric_id</code>.
*/
public Integer getRubricId() {
return (Integer) get(3);
}
// -------------------------------------------------------------------------
// Primary key information
// -------------------------------------------------------------------------
/**
* {@inheritDoc}
*/
@Override
public Record1<Integer> key() {
return (Record1) super.key();
}
// -------------------------------------------------------------------------
// Record4 type implementation
// -------------------------------------------------------------------------
/**
* {@inheritDoc}
*/
@Override
public Row4<Integer, String, String, Integer> fieldsRow() {
return (Row4) super.fieldsRow();
}
/**
* {@inheritDoc}
*/
@Override
public Row4<Integer, String, String, Integer> valuesRow() {
return (Row4) super.valuesRow();
}
/**
* {@inheritDoc}
*/
@Override
public Field<Integer> field1() {
return AssessmentTrainingexample.ASSESSMENT_TRAININGEXAMPLE.ID;
}
/**
* {@inheritDoc}
*/
@Override
public Field<String> field2() {
return AssessmentTrainingexample.ASSESSMENT_TRAININGEXAMPLE.RAW_ANSWER;
}
/**
* {@inheritDoc}
*/
@Override
public Field<String> field3() {
return AssessmentTrainingexample.ASSESSMENT_TRAININGEXAMPLE.CONTENT_HASH;
}
/**
* {@inheritDoc}
*/
@Override
public Field<Integer> field4() {
return AssessmentTrainingexample.ASSESSMENT_TRAININGEXAMPLE.RUBRIC_ID;
}
/**
* {@inheritDoc}
*/
@Override
public Integer value1() {
return getId();
}
/**
* {@inheritDoc}
*/
@Override
public String value2() {
return getRawAnswer();
}
/**
* {@inheritDoc}
*/
@Override
public String value3() {
return getContentHash();
}
/**
* {@inheritDoc}
*/
@Override
public Integer value4() {
return getRubricId();
}
/**
* {@inheritDoc}
*/
@Override
public AssessmentTrainingexampleRecord value1(Integer value) {
setId(value);
return this;
}
/**
* {@inheritDoc}
*/
@Override
public AssessmentTrainingexampleRecord value2(String value) {
setRawAnswer(value);
return this;
}
/**
* {@inheritDoc}
*/
@Override
public AssessmentTrainingexampleRecord value3(String value) {
setContentHash(value);
return this;
}
/**
* {@inheritDoc}
*/
@Override
public AssessmentTrainingexampleRecord value4(Integer value) {
setRubricId(value);
return this;
}
/**
* {@inheritDoc}
*/
@Override
public AssessmentTrainingexampleRecord values(Integer value1, String value2, String value3, Integer value4) {
value1(value1);
value2(value2);
value3(value3);
value4(value4);
return this;
}
// -------------------------------------------------------------------------
// Constructors
// -------------------------------------------------------------------------
/**
* Create a detached AssessmentTrainingexampleRecord
*/
public AssessmentTrainingexampleRecord() {
super(AssessmentTrainingexample.ASSESSMENT_TRAININGEXAMPLE);
}
/**
* Create a detached, initialised AssessmentTrainingexampleRecord
*/
public AssessmentTrainingexampleRecord(Integer id, String rawAnswer, String contentHash, Integer rubricId) {
super(AssessmentTrainingexample.ASSESSMENT_TRAININGEXAMPLE);
set(0, id);
set(1, rawAnswer);
set(2, contentHash);
set(3, rubricId);
}
}
|
package nl.tue.win.dbt.data;
import com.google.common.collect.HashBasedTable;
import com.google.common.collect.RangeSet;
import com.google.common.collect.Table;
import nl.tue.win.dbt.util.IntegerRangeSets;
import java.io.Serializable;
import java.util.*;
import java.util.function.Function;
public class LabeledVersionGraph<V, E, L> extends LabeledGraph<V, E, L> implements Serializable {
private final int size;
private final Map<V, BitSet> vertexLifespans;
private final Map<E, BitSet> edgeLifespans;
private final Table<V, L, BitSet> labelLifespans;
public LabeledVersionGraph(int size) {
super(null); // TODO
if(size <= 0) {
throw new IllegalArgumentException("An LVG requires a positive size");
}
this.size = size;
this.vertexLifespans = new HashMap<>();
this.edgeLifespans = new HashMap<>();
this.labelLifespans = HashBasedTable.create();
}
public <G extends LabeledGraph<V, E, L>> LabeledVersionGraph(
final LabeledHistoryGraph<G, V, E, L> historyGraph) {
super(historyGraph.flatten());
this.size = historyGraph.size();
this.vertexLifespans = new HashMap<>();
this.initMapLifespans(
this.vertexLifespans,
super.vertexSet(),
historyGraph::vertexLifespan);
this.edgeLifespans = new HashMap<>();
this.initMapLifespans(
this.edgeLifespans,
super.edgeSet(),
historyGraph::edgeLifespan);
this.labelLifespans = HashBasedTable.create();
RangeSet<Integer> lifespan;
BitSet bs;
for(V vertex: this.vertexSet()) {
for(L label: this.getLabels(vertex)) {
lifespan = historyGraph.labelLifespan(vertex, label);
bs = IntegerRangeSets.toBitSet(lifespan, this.size);
this.labelLifespans.put(vertex, label, bs);
}
}
}
protected final <T> void initMapLifespans(
final Map<T, BitSet> lifespans,
final Set<T> data,
final Function<T, RangeSet<Integer>> mapper) {
RangeSet<Integer> lifespan;
BitSet bs;
for(T t: data) {
lifespan = mapper.apply(t);
bs = IntegerRangeSets.toBitSet(lifespan, this.size);
lifespans.put(t, bs);
}
}
public int getSize() {
return this.size;
}
public BitSet vertexLifespan(V vertex) {
return this.vertexLifespans.get(vertex);
}
public BitSet edgeLifespan(E edge) {
return this.edgeLifespans.get(edge);
}
public BitSet labelLifespan(V vertex, L label) {
return this.labelLifespans.get(vertex, label);
}
public BitSet changeVertexLifespan(V vertex, BitSet lifespan) {
Objects.requireNonNull(lifespan);
assertCorrectLifespanLength(lifespan);
return this.vertexLifespans.put(vertex, lifespan);
}
public BitSet changeEdgeLifespan(E edge, BitSet lifespan) {
Objects.requireNonNull(lifespan);
assertCorrectLifespanLength(lifespan);
return this.edgeLifespans.put(edge, lifespan);
}
public BitSet changeLabelLifespan(V vertex, L label, BitSet lifespan) {
Objects.requireNonNull(lifespan);
assertCorrectLifespanLength(lifespan);
return this.labelLifespans.put(vertex, label, lifespan);
}
private void assertCorrectLifespanLength(BitSet lifespan) {
if(lifespan.length() != this.size) {
throw new IllegalArgumentException(
String.format("Expected a lifespan of length %s.", this.size));
}
}
public E addEdge(V v, V v1, BitSet lifespan) {
Objects.requireNonNull(lifespan);
assertCorrectLifespanLength(lifespan);
E edge = super.addEdge(v, v1);
if(edge != null) {
this.edgeLifespans.put(edge, lifespan);
}
return edge;
}
public boolean addEdge(V v, V v1, E e, BitSet lifespan) {
Objects.requireNonNull(lifespan);
assertCorrectLifespanLength(lifespan);
boolean modified = super.addEdge(v, v1, e);
if(modified) {
this.edgeLifespans.put(e, lifespan);
}
return modified;
}
public boolean addVertex(V v, BitSet lifespan) {
Objects.requireNonNull(lifespan);
assertCorrectLifespanLength(lifespan);
boolean modified = super.addVertex(v);
if(modified) {
this.vertexLifespans.put(v, lifespan);
}
return modified;
}
public boolean addLabel(V vertex, L label, BitSet lifespan) {
Objects.requireNonNull(lifespan);
assertCorrectLifespanLength(lifespan);
boolean modified = super.addLabel(vertex, label);
if(modified) {
this.labelLifespans.put(vertex, label, new BitSet(this.size));
}
return modified;
}
public boolean addAllLabels(V vertex, Collection<? extends L> labels, BitSet lifespan) {
Objects.requireNonNull(lifespan);
assertCorrectLifespanLength(lifespan);
boolean modified = super.addAllLabels(vertex, labels);
if(modified) {
labels.forEach(l -> this.labelLifespans.put(vertex, l, lifespan));
}
return modified;
}
@Override
public boolean addLabel(V vertex, L label) {
return this.addLabel(vertex, label, new BitSet(this.size));
}
@Override
public boolean addAllLabels(V vertex, Collection<? extends L> labels) {
return this.addAllLabels(vertex, labels, new BitSet(this.size));
}
@Override
public boolean removeLabel(V vertex, L label) {
this.labelLifespans.remove(vertex, label);
return super.removeLabel(vertex, label);
}
@Override
public Set<L> removeAllLabels(V vertex) {
this.labelLifespans.row(vertex).clear();
return super.removeAllLabels(vertex);
}
@Override
public void removeAllLabels() {
this.labelLifespans.clear();
super.removeAllLabels();
}
@Override
public E addEdge(V v, V v1) {
return this.addEdge(v, v1, new BitSet(this.size));
}
@Override
public boolean addEdge(V v, V v1, E e) {
return this.addEdge(v, v1, e, new BitSet(this.size));
}
@Override
public boolean addVertex(V v) {
return this.addVertex(v, new BitSet(this.size));
}
@Override
public boolean removeAllEdges(Collection<? extends E> collection) {
collection.forEach(this.edgeLifespans::remove);
return super.removeAllEdges(collection);
}
@Override
public Set<E> removeAllEdges(V v, V v1) {
this.getAllEdges(v, v1).forEach(this.edgeLifespans::remove);
return super.removeAllEdges(v, v1);
}
@Override
public boolean removeAllVertices(Collection<? extends V> collection) {
for(V vertex: collection) {
this.vertexLifespans.remove(vertex);
this.edgesOf(vertex).forEach(this.edgeLifespans::remove);
this.labelLifespans.row(vertex).clear();
}
return super.removeAllVertices(collection);
}
@Override
public E removeEdge(V v, V v1) {
this.edgeLifespans.remove(this.getEdge(v, v1));
return super.removeEdge(v, v1);
}
@Override
public boolean removeEdge(E e) {
this.edgeLifespans.remove(e);
return super.removeEdge(e);
}
@Override
public boolean removeVertex(V v) {
this.vertexLifespans.remove(v);
this.edgesOf(v).forEach(this.edgeLifespans::remove);
this.labelLifespans.row(v).clear();
return super.removeVertex(v);
}
@Override
public boolean equals(Object o) {
if (this == o) return true;
if (o == null || getClass() != o.getClass()) return false;
if (!super.equals(o)) return false;
LabeledVersionGraph<?, ?, ?> that = (LabeledVersionGraph<?, ?, ?>) o;
if (size != that.size) return false;
if (vertexLifespans != null ? !vertexLifespans.equals(that.vertexLifespans) : that.vertexLifespans != null)
return false;
if (edgeLifespans != null ? !edgeLifespans.equals(that.edgeLifespans) : that.edgeLifespans != null)
return false;
return labelLifespans != null ? labelLifespans.equals(that.labelLifespans) : that.labelLifespans == null;
}
@Override
public int hashCode() {
int result = super.hashCode();
result = 31 * result + size;
result = 31 * result + (vertexLifespans != null ? vertexLifespans.hashCode() : 0);
result = 31 * result + (edgeLifespans != null ? edgeLifespans.hashCode() : 0);
result = 31 * result + (labelLifespans != null ? labelLifespans.hashCode() : 0);
return result;
}
@Override
public String toString() {
return "LabeledVersionGraph{" +
"size=" + size +
", vertexLifespans=" + vertexLifespans +
", edgeLifespans=" + edgeLifespans +
", labelLifespans=" + labelLifespans +
'}';
}
}
|
package com.yash.function;
import java.util.Objects;
import java.util.function.Predicate;
public class PredicateDemo {
public static void main(String[] args) {
Predicate<String> predicateString=(s)->s.length()>6;
System.out.println("Predicate Result:"+predicateString.test("shabbir"));
Predicate<String> predicateIsEmpty=String::isEmpty;
System.out.println("If string is empty:"+predicateIsEmpty.test(" "));
Predicate<Object> predicateObject=Objects::isNull;
Boolean b=null;
System.out.println("is null?:"+predicateObject.test(b));
}
}
|
package com.example.photoshare;
import androidx.annotation.NonNull;
import androidx.appcompat.app.AppCompatActivity;
import android.os.Bundle;
import android.util.Patterns;
import android.view.View;
import android.widget.Button;
import android.widget.TextView;
import android.widget.Toast;
import com.google.android.gms.tasks.OnCompleteListener;
import com.google.android.gms.tasks.Task;
import com.google.firebase.auth.AuthResult;
import com.google.firebase.auth.FirebaseAuth;
public class SignUpActivity extends AppCompatActivity {
Button backToSignInButton, signUpButton;
TextView signUpEmail, signUpPass, signUpConfirm;
FirebaseAuth mFirebaseAuth;
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_sign_up);
backToSignInButton = findViewById(R.id.backToSignIn);
signUpButton = findViewById(R.id.signUpButton);
signUpEmail = findViewById(R.id.signUpEmail);
signUpPass = findViewById(R.id.signUpPassword);
signUpConfirm = findViewById(R.id.signUpPasswordConfirm);
mFirebaseAuth = FirebaseAuth.getInstance();
backToSignInButton.setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View v) {
finish();
}
});
signUpButton.setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View v) {
String email = signUpEmail.getText().toString();
String password = signUpPass.getText().toString();
String confirm = signUpConfirm.getText().toString();
if(email.isEmpty() || password.isEmpty() || confirm.isEmpty()) {
Toast.makeText(SignUpActivity.this, "Please fill all the fields", Toast.LENGTH_SHORT).show();
return;
}
if(!Patterns.EMAIL_ADDRESS.matcher(email).matches()) {
signUpEmail.setError("Please enter a valid email address");
signUpEmail.requestFocus();
return;
}
if(!password.equals(confirm)) {
signUpConfirm.setError("Passwords do not match");
System.out.println("incorrect password: " + password + " " + confirm);
signUpConfirm.requestFocus();
return;
}
mFirebaseAuth.createUserWithEmailAndPassword(email, password).addOnCompleteListener(new OnCompleteListener<AuthResult>() {
@Override
public void onComplete(@NonNull Task<AuthResult> task) {
if(!task.isSuccessful()) {
Toast.makeText(SignUpActivity.this, "Failed to sign you up", Toast.LENGTH_SHORT).show();
} else {
Toast.makeText(SignUpActivity.this, "Signed up successfully!", Toast.LENGTH_SHORT).show();
finish();
}
}
});
}
});
}
}
|
package academy.softserve.service;
import org.testng.annotations.BeforeMethod;
import org.testng.annotations.Test;
public class ValidatorServiceTest {
@BeforeMethod
public void setUp() {
}
@Test
public void testValidate() {
}
} |
import java.util.Scanner;
class WrongAnswer extends java.lang.Exception {
/**
* random generated
*/
private static final long serialVersionUID = 9042451774593630116L;
WrongAnswer(String message)
{
super(message);
}
}
/*
* Rename this class to Main!
*/
public final class T1_Assignment3 {
/**
* god i'm lazy
*
* @param args
*/
@SuppressWarnings("resource")
public static void main(String[] args)
{
Scanner input = new Scanner(System.in);
int buffer;
System.out.println("Welcome. What is your name?");
System.out.println("Hello " + input.nextLine() + ". Try your best to crack the code!");
try
{
System.out.println("PHASE 1\nEnter a number:");
if (input.nextInt() != 3)
{
throw new WrongAnswer("phase 1 wrong");
}
System.out.println("Correct!\n\nPHASE 2\r\nEnter a number:");
buffer = input.nextInt();
if (!(buffer == 1 || (buffer >= 33 && buffer <= 100)))
{
throw new WrongAnswer("phase 2 wrong");
}
System.out.println("Correct!\n\nPHASE 3\r\nEnter a number:");
buffer = input.nextInt();
if (!(buffer > 0 && (buffer % 3 == 0 || buffer % 7 == 0)))
{
throw new WrongAnswer("phase 3 wrong");
}
System.out.println("Correct!\nYou have cracked the code!");
} catch (WrongAnswer error)
{
System.out.println("Sorry, that was incorrect!\nBetter luck next time!");
}
input.close();
}
}
|
package com.omg.omguw;
import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.net.HttpURLConnection;
import java.net.MalformedURLException;
import java.net.URL;
import java.net.URLConnection;
import android.app.Activity;
import android.os.Bundle;
import android.view.View;
import android.widget.Button;
import android.widget.EditText;
public class PostComment extends Activity {
EditText et1;
Button btn1;
@Override
public void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.post_comment);
et1 = (EditText) findViewById(R.id.editText2);
btn1 = (Button) findViewById(R.id.button1);
}
public void submitComment(View v)
{
String text= et1.getText().toString();
Bundle extras = getIntent().getExtras();
String url = extras.getString("URL");
try {
URL link = new URL(url);
URLConnection conn = link.openConnection();
conn.setDoOutput(true);
conn.setDoInput(true);
((HttpURLConnection)conn).setRequestMethod("POST");
conn.setRequestProperty("Content-Type", " application/atom+xml");
OutputStreamWriter wr = new OutputStreamWriter(
conn.getOutputStream());
wr.write("<entry xmlns='http://www.w3.org/2005/Atom'><title type=\"text\"></title> <content type=\"html\">"
+ text + "</content></entry>");
wr.flush();
BufferedReader rd = new BufferedReader(new InputStreamReader(conn.getInputStream()));
String line;
while((line = rd.readLine()) !=null)
{
System.out.println(line);
}
wr.close();
rd.close();
} catch (Exception e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
finish();
}
}
|
package frc.built_groups;
import java.util.ArrayList;
import edu.wpi.first.wpilibj2.command.Command;
public final class GroupBuilder {
GroupBuilder() {
}
final ArrayList<Command> commands = new ArrayList<>();
public void add(Command c) {
commands.add(c);
}
} |
package com.fgtit.app;
public class TempVals {
private static TempVals instance;
public static TempVals getInstance() {
if(null == instance) {
instance = new TempVals();
}
return instance;
}
public byte[] tempInfo=new byte[512];
public byte[] tempFP=new byte[2048];
public int fpCount=0;
}
|
/*
* Copyright 2002-2017 the original author or authors.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* https://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.apache.commons.logging.impl;
import java.io.Serializable;
import org.apache.commons.logging.Log;
/**
* Trivial implementation of {@link Log} that throws away all messages.
*
* @author Juergen Hoeller (for the {@code spring-jcl} variant)
* @since 5.0
*/
@SuppressWarnings("serial")
public class NoOpLog implements Log, Serializable {
public NoOpLog() {
}
public NoOpLog(String name) {
}
@Override
public boolean isFatalEnabled() {
return false;
}
@Override
public boolean isErrorEnabled() {
return false;
}
@Override
public boolean isWarnEnabled() {
return false;
}
@Override
public boolean isInfoEnabled() {
return false;
}
@Override
public boolean isDebugEnabled() {
return false;
}
@Override
public boolean isTraceEnabled() {
return false;
}
@Override
public void fatal(Object message) {
}
@Override
public void fatal(Object message, Throwable t) {
}
@Override
public void error(Object message) {
}
@Override
public void error(Object message, Throwable t) {
}
@Override
public void warn(Object message) {
}
@Override
public void warn(Object message, Throwable t) {
}
@Override
public void info(Object message) {
}
@Override
public void info(Object message, Throwable t) {
}
@Override
public void debug(Object message) {
}
@Override
public void debug(Object message, Throwable t) {
}
@Override
public void trace(Object message) {
}
@Override
public void trace(Object message, Throwable t) {
}
}
|
import java.util.*;
public class PtManager {
List<PT> ptlist = new ArrayList<>();
Calendar cal = Calendar.getInstance();
int daynum = cal.getActualMaximum(Calendar.DATE);
public void ScheduleInit() {
for(int i=0; i<=40; i++) {
ptlist.add(new PT(" "," "," "," "));
}
}
public void modify(int day,PT pt) {
ptlist.remove(day);
ptlist.add(day, pt);
}
public void printAll() throws Exception {
int year = cal.get(Calendar.YEAR);
int month = cal.get(Calendar.MONTH)+1;
int week = cal.get(Calendar.WEEK_OF_MONTH);
int day = cal.get(Calendar.DAY_OF_MONTH);
int dayof = cal.get(Calendar.DAY_OF_WEEK);
int endofweek = 0;
for(int i=0; i<7; i++) {
if((dayof+i)%7 == 0) {
endofweek=(day+i);
break;
}
}
System.out.println("PT Schdule 2주");
System.out.println(year + "년도 " + month + "월 " + week + "주 PT " );
System.out.println("일" + "\t" + "월"+ "\t"+ "화"+ "\t"+"수"+ "\t"+"목"+ "\t"+"금"+ "\t"+"토");
for(int i=1;i<dayof;i++) { //시작 날짜
System.out.print("\t");
}
for(int i=day; i<=endofweek; i++) { //이번주 날짜 입력
int n = i%daynum;
if(n==0) n=daynum;
System.out.print("*" + n + "*" + "\t");
}
System.out.println();
//이번주 피티 입력
for(int i=0;i<4;i++) {
for(int j=1; j<dayof; j++) {
System.out.print("\t");
}
for(int j=day;j<=endofweek; j++) {
int n= j%daynum;
System.out.print(ptlist.get(n).getPt()[i] + "\t");
}
System.out.println();
}
//다음주 날짜 입력
for(int i=(endofweek+1);i<=(endofweek+7);i++ ) {
int n = i%daynum;
if(n==0) n=daynum;
System.out.print("*" + n + "*" + "\t");
}
System.out.println();
//다음주 피티 입력
for(int i=0;i<4;i++) {
for(int j= (endofweek+1); j<=(endofweek+7); j++) {
int n = j%daynum;
if(n==0) n=daynum;
System.out.print(ptlist.get(n).getPt()[i] + "\t");
}
System.out.println();
}
}
public List<PT> getPtlist(){
return ptlist;
}
public void setptlist(List<PT> ptlist) {
this.ptlist=ptlist;
}
}
|
/*
* Copyright (C) 2017 The Android Open Source Project
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.android.ahat.heapdump;
/**
* Reference represents a reference from 'src' to 'ref' through 'field'.
* Field is a string description for human consumption. This is typically
* either "." followed by the field name or an array subscript such as "[4]".
* reachability describes whether the reference is strong/soft/weak/etc.
*/
class Reference {
public final AhatInstance src;
public final String field;
public final AhatInstance ref;
public final Reachability reachability;
public Reference(AhatInstance src, String field, AhatInstance ref, Reachability reachability) {
this.src = src;
this.field = field;
this.ref = ref;
this.reachability = reachability;
}
}
|
package kuntosali;
import java.io.OutputStream;
import java.io.PrintStream;
import fi.jyu.mit.ohj2.Mjonot;
/**
* @author antti
* @version 3.8.2020
*
*/
public class Ryhmaliikunta implements Cloneable {
private int tunnusNro;
private int asiakasNro;
private String nimi = "";
private String viikonpv = "";
private String klo = "";
private static int seuraavaNro = 1;
/**
* @return ryhmaliikunnan kenttien lkm
*/
public int getKenttia() {
return 5;
}
/**
* @return ekan täytettävän kentan indeksi
*/
public int ekaKentta() {
return 2;
}
/**
* @param k mones tietokenttä
* @return k tietokentän sisältö merkkijonona
*/
public String anna(int k) {
switch (k) {
case 0:
return "" + tunnusNro;
case 1:
return "" + asiakasNro;
case 2:
return "" + nimi;
case 3:
return "" + viikonpv;
case 4:
return "" + klo;
default:
return "Jees Jees";
}
}
/**
* * Asettaa k:n kentän arvoksi parametrina tuodun merkkijonon arvon
* @param k kuinka monennen kentän arvo asetetaan
* @param jono jonoa joka asetetaan kentän arvoksi
* @return null jos asettaminen onnistuu, muuten vastaava virheilmoitus.
* @example
* <pre name="test">
* Ryhmaliikunta jasen = new Ryhmaliikunta();
* jasen.aseta(2,"Ankka") === null;
* jasen.aseta(3,"maanantai") === null;
* jasen.aseta(4,"63.00-17.00") === "Anna muodossa 15.30-16.00";
* </pre>
*/
public String aseta(int k, String jono) {
String tjono = jono.trim();
StringBuffer sb = new StringBuffer(tjono);
switch (k) {
case 0:
setTunnusNro(Mjonot.erota(sb, '§', getTunnusNro()));
return null;
case 1:
setAsiakasNro(Mjonot.erota(sb, '§', getAsiakasNro()));
return null;
case 2:
nimi = tjono;
return null;
case 3:
if (tjono.matches(
"maanantai|tiistai|keskiviikko|torstai|perjantai|lauantai|sunnuntai")) {
viikonpv = tjono;
return null;
}
return "Anna viikonpäivä";
case 4:
if (tjono.matches(
"^(0[0-9]|1[0-9]|2[0-3])\\.[0-5][0-9]-(0[0-9]|1[0-9]|2[0-3])\\.[0-5][0-9]$")) {
klo = tjono;
return null;
}
return "Anna muodossa 15.30-16.00";
default:
return "JeJee";
}
}
/**
* Alustetaan ryhmaliikunta
*/
public Ryhmaliikunta() {
// ei tehdä vielä mitään
}
/**
* Alustetaan tietyn asiakkaan ryhmaliikunta
* @param asiakasNro asikkaan yksilöivä nro
*/
public Ryhmaliikunta(int asiakasNro) {
this.asiakasNro = asiakasNro;
}
/**
* getteri ryhmaliikunnan nimelle
* @return palauttaa nimi attribuutin
*/
public String getNimi() {
return nimi;
}
/**
* testailua varten aliohjelma, joka täyttää olion tiedot. Nimen perään tulee yksilöivä random arvo
* @param numero mille asiakkaalle ryhmaliikunta sijoitetaan
*/
public void taytaRyhmaliikunta(int numero) {
asiakasNro = numero;
this.nimi = "kuntopiiri" + Math.random();
this.viikonpv = "torstai";
this.klo = "18.00";
}
/**
* Tulostetaan ryhmäliikunnan tiedot
* @param out tietovirta johon tulostetaan
*/
public void tulosta(PrintStream out) {
out.println(String.format("%03d", this.tunnusNro) + " " + this.nimi);
out.println(" Viikonpäivä: " + this.viikonpv);
out.println(" Kellonaika: " + this.klo);
}
/**
* Tulostetaan ryhmäliikunnan tiedot
* @param os tietovirta johon tulostetaan
*/
public void tulosta(OutputStream os) {
tulosta(new PrintStream(os));
}
/**
* Antaa ryhmäliikunnalle seuraavan rekisterinumeron.
* @return ryhmäliikunnan uusi tunnusNro
* @example
* <pre name="test">
* Ryhmaliikunta testi1 = new Ryhmaliikunta();
* testi1.getTunnusNro() === 0;
* testi1.rekisteroi();
* Ryhmaliikunta testi2 = new Ryhmaliikunta();
* testi2.rekisteroi();
* int n1 = testi1.getTunnusNro();
* int n2 = testi2.getTunnusNro();
* n1 === n2-1;
* </pre>
*/
public int rekisteroi() {
tunnusNro = seuraavaNro;
seuraavaNro++;
return tunnusNro;
}
/**
* Palauttaa ryhmaliikunnan tunnusnumeron.
* @return ryhmaliikunnan tunnusnumero
*/
public int getTunnusNro() {
return this.tunnusNro;
}
/**
* Asettaa tunnusnumeron ja samalla varmistaa että
* seuraava numero on aina suurempi kuin tähän mennessä suurin.
* @param nr asetettava tunnusnumero
*/
private void setTunnusNro(int nr) {
tunnusNro = nr;
if (tunnusNro >= seuraavaNro)
seuraavaNro = tunnusNro + 1;
}
/**
* @param nro numero, joka asetetaan asiakasNro:ksi
*/
public void setAsiakasNro(int nro) {
asiakasNro = nro;
}
/**
* Palautetaan mille asiakkaalle ryhmaliikunta kuuluu
* @return jäsenen id
*/
public int getAsiakasNro() {
return asiakasNro;
}
@Override
public String toString() {
return "" + getTunnusNro() + "|" + asiakasNro + "|" + nimi + "|"
+ viikonpv + "|" + klo;
}
/**
* Selvitää ryhmäliikunnan tiedot | erotellusta merkkijonosta.
* Pitää huolen että seuraavaNro on suurempi kuin tuleva tunnusnro.
* @param rivi josta ryhmäliikunnan tiedot otetaan
* @example
* <pre name="test">
* Ryhmaliikunta rl = new Ryhmaliikunta();
* rl.parse(" 1 | 4 | kuntopiiri | torstai | 18.00 ");
* rl.getAsiakasNro() === 4;
* rl.toString() === "1|4|kuntopiiri|torstai|18.00";
* </pre>
*/
public void parse(String rivi) {
StringBuffer sb = new StringBuffer(rivi);
setTunnusNro(Mjonot.erota(sb, '|', getTunnusNro()));
asiakasNro = Mjonot.erota(sb, '|', asiakasNro);
nimi = Mjonot.erota(sb, '|', nimi);
viikonpv = Mjonot.erota(sb, '|', viikonpv);
klo = Mjonot.erota(sb, '|', klo);
}
/**
* testi pääohjelma yhdelle ryhmäliikunnalle
* @param args ei käytössä
*/
public static void main(String[] args) {
Ryhmaliikunta ryhma1 = new Ryhmaliikunta(),
ryhma2 = new Ryhmaliikunta();
ryhma1.rekisteroi();
ryhma2.rekisteroi();
ryhma1.taytaRyhmaliikunta(1);
ryhma2.taytaRyhmaliikunta(2);
ryhma1.tulosta(System.out);
ryhma2.tulosta(System.out);
}
/**
* Tehdään identtinen klooni ryhmäliikunnasta
* @return Object kloonattu rl
* @example
* <pre name="test">
* #THROWS CloneNotSupportedException
* Ryhmaliikunta har = new Ryhmaliikunta();
* har.parse(" 2 | 10 | Kalastus | 1949 | 22 t ");
* Ryhmaliikunta kopio = har.clone();
* kopio.toString() === har.toString();
* har.parse(" 1 | 11 | Uinti | 1949 | 22 t ");
* kopio.toString().equals(har.toString()) === false;
* </pre>
*/
@Override
public Ryhmaliikunta clone() throws CloneNotSupportedException {
return (Ryhmaliikunta) super.clone();
}
/**
* @param k Palauttaa asiakkaan K kentän kysymyksen
* @return k kenttää vastaava kysymys
*/
public String getKysymys(int k) {
switch (k) {
case 0:
return "Tunnus nro";
case 1:
return "AsiakasNro";
case 2:
return "Nimi";
case 3:
return "ViikonPv";
case 4:
return "Klo";
default:
return "jeeje";
}
}
}
|
package art4muslim.macbook.rahatydriver.adapters;
import android.app.Activity;
import android.content.Context;
import android.support.v4.app.FragmentTransaction;
import android.view.LayoutInflater;
import android.view.View;
import android.view.ViewGroup;
import android.widget.BaseAdapter;
import android.widget.LinearLayout;
import android.widget.TextView;
import art4muslim.macbook.rahatydriver.R;
import art4muslim.macbook.rahatydriver.application.BaseApplication;
import art4muslim.macbook.rahatydriver.models.Notification;
import art4muslim.macbook.rahatydriver.session.Constants;
import art4muslim.macbook.rahatydriver.session.SessionManager;
import java.util.List;
public class CustomNotifListAdapter extends BaseAdapter {
private Activity _mContext;
private LayoutInflater inflater;
private List<Notification> myOrderModelItems;
private String activityName;
FragmentTransaction fragmentTransaction;
SessionManager session;
String languageToLoad;
public CustomNotifListAdapter(Activity activity, List<Notification> myOrderModelItems,
String activityName, FragmentTransaction fragmentTransaction) {
this._mContext = activity;
this.myOrderModelItems = myOrderModelItems;
this.activityName=activityName;
this.fragmentTransaction =fragmentTransaction;
session = new SessionManager(_mContext);
languageToLoad = BaseApplication.session.getKey_LANGUAGE();
}
@Override
public int getCount() {
return myOrderModelItems.size();
}
@Override
public Object getItem(int location) {
return myOrderModelItems.get(location);
}
@Override
public long getItemId(int position) {
return position;
}
@Override
public View getView(int position, View convertView, ViewGroup parent) {
if (inflater == null)
inflater = (LayoutInflater) _mContext.getSystemService(Context.LAYOUT_INFLATER_SERVICE);
if (convertView == null)
convertView = inflater.inflate(R.layout.list_row_notif, null);
TextView _txt_order_number = (TextView) convertView.findViewById(R.id.txt_order_number);
TextView date = (TextView) convertView.findViewById(R.id.txt_date);
TextView time = (TextView) convertView.findViewById(R.id.txt_time);
LinearLayout _linear_cancel = (LinearLayout) convertView.findViewById(R.id.linear_cancel);
final Notification m = myOrderModelItems.get(position);
if (!myOrderModelItems.isEmpty()){
// getting movie data for the row
// thumbnail image
// thumbNail.setImageUrl(m.getThumbnailUrl(), imageLoader);
// title
if (languageToLoad.equals(Constants.arabic)){
_txt_order_number.setText(m.getTitle_ar());
}else{
_txt_order_number.setText(m.getTitle_en());
}
// rating
date.setText(m.getDate());
time.setText(m.getTime());
}
convertView.setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View v) {
// Intent intent=new Intent(_mContext, OrderDetailsAcitivty.class);
// intent.putExtra("RequestNumber",m.getOrderId());
// _mContext.startActivity(intent);
/*if(m.getStatus_id().equals("1") ){
OrderDetailsFragment schedule = new OrderDetailsFragment();
Bundle args =new Bundle();
args.putInt("RequestNumber", Integer.parseInt(m.getRequest_id()));
//args.putString("LAT", m.getWorker_mapx() );
//args.putString("LNG", m.getWorker_mapy() );
args.putString("MY_LAT", ""+session.getUserMapx());
args.putString("MY_LNG", ""+session.getUserMapy());
args.putString("PHOTO", ""+m.getRequest_photo1());
args.putString("TYPE","NEW");
schedule.setArguments(args);
//FragmentTransaction fragmentTransaction = _mContext.getSupportFragmentManager().beginTransaction();
fragmentTransaction.replace(R.id.frame,schedule,"myOrders Fragment");
fragmentTransaction.commit();
}
*/
}
});
return convertView;
}
public void clear() {
// TODO Auto-generated method stub
myOrderModelItems.clear();
}
} |
package com.meetingapp.android.util;
import android.content.Context;
import android.graphics.Typeface;
/**
* This class is used for defining the typeface
*/
public class TypeFaceUtils {
public static Typeface getTypeFace(Context context, int font) {
String str;
switch (font) {
case 1:
str = "fonts/Roboto_Regular.ttf";
break;
case 2:
str = "fonts/Roboto_Medium.ttf";
break;
case 3:
str = "fonts/Roboto_Bold.ttf";
break;
default:
str = "fonts/Roboto_Regular.ttf";
break;
}
return FontManager.getInstance(context).loadFont(str);
}
}
|
package com.sample.estimote;
import android.os.Bundle;
import android.os.RemoteException;
import android.support.v7.app.AppCompatActivity;
import android.util.Log;
import android.widget.BaseExpandableListAdapter;
import android.widget.TextView;
import org.altbeacon.beacon.Beacon;
import org.altbeacon.beacon.BeaconConsumer;
import org.altbeacon.beacon.BeaconManager;
import org.altbeacon.beacon.BeaconParser;
import org.altbeacon.beacon.RangeNotifier;
import org.altbeacon.beacon.Region;
import java.util.Collection;
import java.util.Iterator;
public class MainActivity extends AppCompatActivity implements BeaconConsumer {
protected static final String TAG = "RangingActivity";
private BeaconManager beaconManager;
private TextView mMainTv;
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
mMainTv = (TextView) findViewById(R.id.main_tv);
beaconManager = BeaconManager.getInstanceForApplication(this);
// To detect proprietary beacons, you must add a line like below corresponding to your beacon
// type. Do a web search for "setBeaconLayout" to get the proper expression.
beaconManager.getBeaconParsers().add(new BeaconParser().setBeaconLayout("m:2-3=0215,i:4-19,i:20-21,i:22-23,p:24-24"));
beaconManager.bind(this);
}
@Override
protected void onDestroy() {
super.onDestroy();
beaconManager.unbind(this);
}
@Override
public void onBeaconServiceConnect() {
beaconManager.addRangeNotifier(new RangeNotifier() {
@Override
public void didRangeBeaconsInRegion(final Collection<Beacon> beacons, Region region) {
Log.d("beacons", beacons.size() + "");
if (beacons.size() > 0) {
runOnUiThread(new Runnable() {
@Override
public void run() {
Iterator<Beacon> beaconIterator = beacons.iterator();
double distance = 1000f;
while (beaconIterator.hasNext()) {
Beacon beacon = beaconIterator.next();
Log.i("beacons", "The first beacon I see is about " + beacon.getBluetoothAddress() + " meters away.");
if (beacon.getBluetoothAddress().equals("C9:FE:F5:0D:BB:3A"))
distance = beacon.getDistance();
}
mMainTv.setText("Min distance: " + distance);
}
});
}
}
});
try {
beaconManager.startRangingBeaconsInRegion(new Region("myRangingUniqueId", null, null, null));
} catch (RemoteException e) {
}
}
}
|
package ah.rest;
import org.slf4j.event.Level;
import org.springframework.http.HttpHeaders;
import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.ControllerAdvice;
import org.springframework.web.bind.annotation.ExceptionHandler;
import org.springframework.web.context.request.WebRequest;
import org.springframework.web.servlet.mvc.method.annotation.ResponseEntityExceptionHandler;
import ah.helper.StripeGatewayException;
@ControllerAdvice
public class AhExceptionResponseHandler extends ResponseEntityExceptionHandler {
@ExceptionHandler(value = { StripeGatewayException.class })
protected ResponseEntity<Object> handleStripeGatewayException(StripeGatewayException cause, WebRequest request) {
return handle(
HttpStatus.NOT_FOUND,
cause.getCause().getClass().getName(),
cause.getLocalizedMessage(),
Level.INFO,
cause,
request
);
}
private ResponseEntity<Object> handle(HttpStatus status, String type, String message, Level level, Throwable cause, WebRequest request) {
return responseEntityHandler(
AhError.builder()
.status(status)
.message(message)
.cause(cause)
.build(),
request
);
}
private ResponseEntity<Object> responseEntityHandler(AhError failure, WebRequest request) {
return handleExceptionInternal(
(Exception) failure.getCause(),
failure,
new HttpHeaders(),
failure.getStatus(),
request
);
}
}
|
package edu.si.trippi.impl.sparql.converters;
import static java.net.URI.create;
import static org.apache.jena.graph.NodeFactory.createBlankNode;
import static org.apache.jena.graph.NodeFactory.createURI;
import static org.trippi.impl.RDFFactories.createResource;
import org.apache.jena.ext.com.google.common.base.Converter;
import org.apache.jena.graph.Node;
import org.apache.jena.graph.NodeFactory;
import org.apache.jena.graph.Node_Blank;
import org.jrdf.graph.BlankNode;
import org.jrdf.graph.GraphElementFactoryException;
import org.jrdf.graph.ObjectNode;
import org.junit.runner.RunWith;
import org.junit.runners.Suite;
import org.junit.runners.Suite.SuiteClasses;
import org.trippi.impl.RDFFactories;
import edu.si.trippi.impl.sparql.converters.ObjectConverterTest.BlankObject;
import edu.si.trippi.impl.sparql.converters.ObjectConverterTest.LiteralObject;
import edu.si.trippi.impl.sparql.converters.ObjectConverterTest.UriObject;
@RunWith(Suite.class)
@SuiteClasses({UriObject.class, BlankObject.class, LiteralObject.class})
public class ObjectConverterTest {
public static class UriObject extends TestConversionAndInversion<ObjectNode, Node> {
@Override
protected Converter<ObjectNode, Node> converter() {
return ObjectConverter.objectConverter;
}
private static final String testURI = "info:test";
@Override
protected ObjectNode from() throws GraphElementFactoryException {
return createResource(create(testURI));
}
@Override
protected Node to() {
return createURI(testURI);
}
}
public static class BlankObject extends TestConversionAndInversion<ObjectNode, Node> {
@Override
protected Converter<ObjectNode, Node> converter() {
return ObjectConverter.objectConverter;
}
private static final BlankNode testBlankNode;
private static final Node_Blank testNodeBlank;
static {
try {
testBlankNode = createResource();
testNodeBlank = (Node_Blank) createBlankNode(testBlankNode.getID());
} catch (final GraphElementFactoryException e) {
throw new AssertionError(e);
}
}
@Override
protected ObjectNode from() {
return testBlankNode;
}
@Override
protected Node to() {
return testNodeBlank;
}
}
public static class LiteralObject extends TestConversionAndInversion<ObjectNode, Node> {
@Override
protected Converter<ObjectNode, Node> converter() {
return ObjectConverter.objectConverter;
}
private final String simple = "Simple literal.";
@Override
protected ObjectNode from() throws GraphElementFactoryException {
return RDFFactories.createLiteral(simple);
}
@Override
protected Node to() {
return NodeFactory.createLiteral(simple);
}
}
}
|
package com.camila.web.service;
import static org.junit.Assert.assertNotNull;
import org.junit.Test;
import com.camila.web.dominio.services.ClienteService;
public class ClienteTest {
private ClienteService clienteServ;
//GET LISTA
@Test
public void t() {
assertNotNull(clienteServ.lista());
}
}
|
/*
* Origin of the benchmark:
* repo: https://github.com/diffblue/cbmc.git
* branch: develop
* directory: regression/cbmc-java/boolean1
* The benchmark was taken from the repo: 24 January 2018
*/
class Main {
static public void main(String[] args)
{
boolean my_boolean = args.length > 3;
// Boolean shall be either true or false.
if(my_boolean == true) return;
if(my_boolean == false) return;
assert false;
}
};
|
package io.electrum.sdk.masking2;
import com.fasterxml.jackson.core.JsonGenerator;
import com.fasterxml.jackson.databind.JsonSerializer;
import com.fasterxml.jackson.databind.SerializerProvider;
import java.io.IOException;
class DoNotPersistSerializer extends JsonSerializer<Object> {
private String replacementValue;
public DoNotPersistSerializer(String replacementValue) {
this.replacementValue = replacementValue;
}
@Override
public void serialize(Object value, JsonGenerator gen, SerializerProvider serializers) throws IOException {
gen.writeString(replacementValue);
}
} |
package com.arthur.leetcode;
import java.util.ArrayList;
import java.util.Arrays;
/**
* @program: leetcode
* @description: 把数组排成最小的数
* @title: JZoffer45
* @Author hengmingji
* @Date: 2022/1/1 18:53
* @Version 1.0
*/
public class JZoffer45 {
public String minNumber(int[] nums) {
Integer[] ans = Arrays.stream(nums).boxed().toArray(Integer[]::new);
Arrays.sort(ans, (o1, o2) -> {
return ("" + o1 + o2).compareTo("" + o2 + o1);
});
StringBuilder s = new StringBuilder();
for (Integer str : ans) {
s.append(str);
}
return s.toString();
}
}
|
package clique;
import java.io.IOException;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Iterator;
import java.util.LinkedList;
import java.util.List;
import java.util.Map;
import java.util.Set;
import org.apache.hadoop.io.Text;
import org.apache.hadoop.mapreduce.Reducer;
public class CK_Graph_Reducer extends Reducer<Text, Text, Text, Text> {
// 判断两个团是否临接
public boolean isAdjacent(Set<Integer> c1, Set<Integer> c2) {
int common = 0;
for (int n1 : c1)
if (c2.contains(n1))
common++;
int min = c1.size();
if (c2.size() < min)
min = c2.size();
if (common >= min - 1)
return true;
else
return false;
}
/**
* 已经合并的团是否包含与新团临接的团
*
* @param cliques
* @param clique
* @return -1表示不包含 其他值表示与指定团临接的团的index
*/
public int contain(List<Set<Integer>> cliques, Set<Integer> clique) {
for (int i = 0; i < cliques.size(); i++) {
if (isAdjacent(cliques.get(i), clique))
return i;
}
return -1;
}
public void reduce(Text key, Iterable<Text> values, Context context)
throws IOException, InterruptedException {
List<Set<Integer>> cliques = new LinkedList<Set<Integer>>();
Map<Integer, Integer> index_cliqueID = new HashMap<Integer, Integer>();
Iterator<Text> iter = values.iterator();
while (iter.hasNext()) {
String[] contents = iter.next().toString().split("\t");
int cliqueID = Integer.valueOf(contents[0]);
Set<Integer> clique = new HashSet<Integer>();
for (String node : contents[1].substring(1,
contents[1].length() - 1).split(",")) {
clique.add(Integer.valueOf(node.trim()));
}
cliques.add(clique);
index_cliqueID.put(cliques.size() - 1, cliqueID);
}
if (cliques.size() == 1)
return;
for (int i = 0; i < cliques.size(); i++)
for (int j = i + 1; j < cliques.size(); j++)
if (isAdjacent(cliques.get(i), cliques.get(j))) {
int clique_i = index_cliqueID.get(i);
int clique_j = index_cliqueID.get(j);
Text t = new Text();
if(clique_i < clique_j)
t.set(clique_i+","+clique_j);
else
t.set(clique_j+","+clique_i);
context.write(null, t);
}
}
public static void main(String[] args) {
}
}
|
package com.fhsoft.subject.service;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import com.fhsoft.base.bean.Page;
import com.fhsoft.base.bean.TreeNodeAttribute;
import com.fhsoft.base.bean.TreeNodeBean;
import com.fhsoft.model.Menu;
import com.fhsoft.model.SubjectProperty;
import com.fhsoft.subject.dao.SubjectPropertyDao;
import com.fhsoft.system.dao.MenuDao;
/**
* @ClassName:com.fhsoft.subject.service.SubjectPropertyService
* @Description:学科属性的service处理
*
* @Author:liyi
* @Date:2015年10月16日上午11:13:25
*
*/
@Service("subjectPropertyService")
@Transactional
public class SubjectPropertyService {
@Autowired
private SubjectPropertyDao subjectPropertyDao;
@Autowired
private MenuDao menuDao;
/**
* @Description:学科属性列表
* @param pageNo
* @param pageSize
* @param id
* @param status
* @return
* @Date:2015年10月22日上午10:56:26
*
*/
public Page getByPage(int pageNo, int pageSize, String id, String status) {
Page page = subjectPropertyDao.getByPage(pageNo,pageSize,id,status);
return page;
}
/**
* @Description:添加
* @param subjectProperty
* @Date:2015年10月22日下午3:48:13
*
*/
public void add(SubjectProperty subjectProperty) {
//获得父节点下子节点的数目
int index = subjectPropertyDao.getChildrenCountByParentId(subjectProperty.getParentId()) + 1;
//设置该属性对应的列名
subjectProperty.setCol("property" + index);
subjectPropertyDao.add(subjectProperty);
}
/**
* @Description:根据id获得SubjectProperty对象
* @param id
* @return
* @Date:2015年10月23日下午3:20:28
*
*/
public SubjectProperty getById(int id) {
return subjectPropertyDao.getById(id);
}
/**
* @Description:更新SubjectProperty对象
* @param subjectProperty
* @Date:2015年10月26日上午9:27:05
*
*/
public void update(SubjectProperty subjectProperty) {
subjectPropertyDao.update(subjectProperty);
}
/**
* @Description:获得复制节点树
* @return
* @Date:2015年10月26日上午10:28:31
*
*/
public List<TreeNodeBean> getCopyToTree() {
List<TreeNodeBean> nodes = new ArrayList<TreeNodeBean>();
List<Menu> menus = menuDao.getMenusByType(3,null);
for(Menu menu : menus){
TreeNodeBean node = new TreeNodeBean();
node.setId(menu.getId());
node.setText(menu.getName());
node.setPid(menu.getParentId());
node.setAttributes(new TreeNodeAttribute(menu.getUrl()));
node.setState("open");
nodes.add(node);
}
List<SubjectProperty> props = subjectPropertyDao.getBySubjectType1();
for(SubjectProperty prop : props){
TreeNodeBean node = new TreeNodeBean();
node.setId(prop.getId());
node.setText(prop.getName());
node.setPid(prop.getParentId());
node.setState("open");
nodes.add(node);
}
return nodes;
}
/**
* @Description:复制属性到某节点下
* @param subjectPropertyId
* @param parentId
* @param coptToId
* @Date:2015年10月26日上午11:33:09
*
*/
public void copy(int subjectPropertyId, int parentId, int coptToId) {
//map中存放的是复制前id和复制后id的对应关系
Map<Integer,Integer> map = new HashMap<Integer, Integer>();
map.put(parentId, coptToId);
List<SubjectProperty> props = subjectPropertyDao.getChildrenById(subjectPropertyId);
for(SubjectProperty prop : props){
prop.setParentId(map.get(prop.getParentId()));
int id = subjectPropertyDao.insert(prop);
map.put(prop.getId(), id);
}
//获得父节点下子节点的数目
int index = subjectPropertyDao.getChildrenCountByParentId(coptToId);
String col = "property" + index;
//更新学科属性的col列数据
subjectPropertyDao.updateCol(col, map.get(subjectPropertyId));
}
/**
* @Description:学科属性名称是否存在
* @param name
* @param pid
* @param id
* @return
* @Date:2015年11月4日下午2:36:11
*
*/
public boolean isExistByNameAndPid(String name, String pid, String id) {
List<SubjectProperty> list = subjectPropertyDao.getByNameAndPid(name,pid,id);
if(list != null && list.size() > 0){
return false;
}
return true;
}
}
|
package pp.model.comparators;
import pp.model.xml.CGlad;
import java.util.Comparator;
/**
* Created by IntelliJ IDEA.
* User: alsa
* Date: 08.12.11
* Time: 1:52
* To change this template use File | Settings | File Templates.
*/
public class GladCanTankComparator implements Comparator<CGlad> {
@Override
public int compare(CGlad o1, CGlad o2) {
Boolean canTank1 = o1.getVit() + o1.getDex() > (o1.getAcc() + o1.getStr()) * 1.2;
Boolean canTank2 = o2.getVit() + o2.getDex() > (o2.getAcc() + o2.getStr()) * 1.2;
return canTank1.compareTo(canTank2);
}
}
|
package org.wso2.carbon.identity.user.endpoint.dto;
import java.util.ArrayList;
import java.util.List;
import org.wso2.carbon.identity.user.endpoint.dto.BasicProfileDTO;
import org.wso2.carbon.identity.user.endpoint.dto.ConsentReceiptDTO;
import org.wso2.carbon.identity.user.endpoint.dto.SecurityDTO;
import io.swagger.annotations.*;
import com.fasterxml.jackson.annotation.*;
import javax.validation.constraints.NotNull;
@ApiModel(description = "")
public class ExportedUserDTO {
private BasicProfileDTO basic = null;
private List<ConsentReceiptDTO> consents = new ArrayList<ConsentReceiptDTO>();
private SecurityDTO security = null;
/**
**/
@ApiModelProperty(value = "")
@JsonProperty("basic")
public BasicProfileDTO getBasic() {
return basic;
}
public void setBasic(BasicProfileDTO basic) {
this.basic = basic;
}
/**
**/
@ApiModelProperty(value = "")
@JsonProperty("consents")
public List<ConsentReceiptDTO> getConsents() {
return consents;
}
public void setConsents(List<ConsentReceiptDTO> consents) {
this.consents = consents;
}
/**
**/
@ApiModelProperty(value = "")
@JsonProperty("security")
public SecurityDTO getSecurity() {
return security;
}
public void setSecurity(SecurityDTO security) {
this.security = security;
}
@Override
public String toString() {
StringBuilder sb = new StringBuilder();
sb.append("class ExportedUserDTO {\n");
sb.append(" basic: ").append(basic).append("\n");
sb.append(" consents: ").append(consents).append("\n");
sb.append(" security: ").append(security).append("\n");
sb.append("}\n");
return sb.toString();
}
}
|
public interface Default1 {
}
|
package com.myvodafone.android.front.widget;
import android.app.PendingIntent;
import android.appwidget.AppWidgetManager;
import android.appwidget.AppWidgetProvider;
import android.appwidget.AppWidgetProviderInfo;
import android.content.Context;
import android.content.Intent;
import android.content.res.Configuration;
import android.graphics.Bitmap;
import android.graphics.Canvas;
import android.graphics.Color;
import android.graphics.PorterDuff;
import android.os.Build;
import android.os.Bundle;
import android.support.v4.content.ContextCompat;
import android.util.DisplayMetrics;
import android.view.LayoutInflater;
import android.view.View;
import android.view.ViewGroup;
import android.widget.RemoteViews;
import com.google.gson.Gson;
import com.google.gson.GsonBuilder;
import com.myvodafone.android.R;
import com.myvodafone.android.business.managers.MemoryCacheManager;
import com.myvodafone.android.business.managers.WidgetManager;
import com.myvodafone.android.front.intro.ActSplash;
import com.myvodafone.android.model.business.VFAccount;
import com.myvodafone.android.model.business.VFMobileAccount;
import com.myvodafone.android.model.business.VFMobileXGAccount;
import com.myvodafone.android.utils.StaticTools;
import com.myvodafone.android.utils.VFPreferences;
import java.util.HashMap;
import uk.co.exus.circulargauge.GaugeLayout;
/**
* Created by p.koutsias on 3/21/2016.
*/
public class VFGRWidget extends AppWidgetProvider {
public static final int WIDGET_STATUS_FAILED = 0;
public static final int WIDGET_STATUS_OK = 1;
public static final int WIDGET_STATUS_NO_XG = 2;
public static final int WIDGET_STATUS_UPDATE_FAILED = 3;
public static final int WIDGET_STATUS_UPDATING = 4;
public static final String WIDGET_UPDATED = "com.myvodafone.android.WIDGET_UPDATED";
public static final String FORCE_WIDGET_UPDATE = "com.myvodafone.android.FORCE_WIDGET_UPDATE";
public static final String WIDGET_NAVIGATION_FORWARD = "com.myvodafone.android.WIDGET_NAVIGATION_FORWARD";
public static final String WIDGET_NAVIGATION_BACKWARD = "com.myvodafone.android.WIDGET_NAVIGATION_BACKWARD";
private static HashMap<Integer, WidgetModel> widgetModels;
@Override
public void onReceive(Context context, Intent intent) {
super.onReceive(context, intent);
final String action = intent.getAction();
final Bundle extras = intent.getExtras();
StaticTools.Log("Widget received action", action);
if (FORCE_WIDGET_UPDATE.equals(action)) {
int widgetId = extras.getInt(AppWidgetManager.EXTRA_APPWIDGET_ID, AppWidgetManager.INVALID_APPWIDGET_ID);
checkWidgetId(widgetId);
AppWidgetManager appWidgetManager = AppWidgetManager.getInstance(context);
showRefreshingWidget(widgetId, context, appWidgetManager);
context.startService(new Intent(context, WidgetManager.class));
} else if (WIDGET_NAVIGATION_FORWARD.equals(action)) {
int widgetId = extras.getInt(AppWidgetManager.EXTRA_APPWIDGET_ID, AppWidgetManager.INVALID_APPWIDGET_ID);
checkWidgetId(widgetId);
onNavigate(context, widgetId, R.id.rightArrow);
} else if (WIDGET_NAVIGATION_BACKWARD.equals(action)) {
int widgetId = extras.getInt(AppWidgetManager.EXTRA_APPWIDGET_ID, AppWidgetManager.INVALID_APPWIDGET_ID);
checkWidgetId(widgetId);
onNavigate(context, widgetId, R.id.leftArrow);
} else if (WIDGET_UPDATED.equals(action)) {
int widgetId = extras.getInt(AppWidgetManager.EXTRA_APPWIDGET_ID, AppWidgetManager.INVALID_APPWIDGET_ID);
checkWidgetId(widgetId);
updateWidget(context, widgetId);
}
}
private void checkWidgetId(int widgetId) {
if (!getWidgetModels().containsKey(widgetId)) {
getWidgetModels().put(widgetId, getWidgetModel(widgetId));
}
}
@Override
public void onDeleted(Context context, int[] appWidgetIds) {
for (int appWidgetId : appWidgetIds) {
VFPreferences.removeWidgetSettings(appWidgetId);
}
super.onDeleted(context, appWidgetIds);
}
@Override
public void onAppWidgetOptionsChanged(Context context, AppWidgetManager appWidgetManager, int appWidgetId, Bundle newOptions) {
updateWidget(context, appWidgetId);
}
private void checkHeight(int maxHeight, int minHeight, float heightBreakpoint, int appWidgetId, RemoteViews views, AppWidgetManager appWidgetManager, Context context) {
StaticTools.Log("Widget max height", String.valueOf(maxHeight));
StaticTools.Log("Widget min height", String.valueOf(minHeight));
float avgHeight = (maxHeight + minHeight) / 2;
StaticTools.Log("Widget avg height", String.valueOf(avgHeight));
StaticTools.Log("Widget height breakpoint", String.valueOf(heightBreakpoint));
WidgetModel model = getWidgetModels().get(appWidgetId);
if (avgHeight < heightBreakpoint || (StaticTools.isTablet(context) && context.getResources().getConfiguration().orientation == Configuration.ORIENTATION_PORTRAIT)) {
views.setViewVisibility(R.id.singleGaugeContainer, View.VISIBLE);
views.setViewVisibility(R.id.gaugeContainer, View.GONE);
model.setWidgetSize(WidgetModel.WidgetSize.SMALL);
} else {
views.setViewVisibility(R.id.singleGaugeContainer, View.GONE);
views.setViewVisibility(R.id.gaugeContainer, View.VISIBLE);
model.setWidgetSize(WidgetModel.WidgetSize.NORMAL);
}
if (model.getWidgetStatus() == WIDGET_STATUS_OK) {
appWidgetManager.updateAppWidget(appWidgetId, views);
}
}
public void updateWidget(Context context, int widgetId) {
AppWidgetManager appWidgetManager = AppWidgetManager.getInstance(context);
WidgetModel widgetModel = getWidgetModels().get(widgetId);
if (widgetModel != null) {
switch (widgetModel.getWidgetStatus()) {
case WIDGET_STATUS_OK:
StaticTools.Log("Widget status", widgetId + ": WIDGET_STATUS_OK");
RemoteViews views = new RemoteViews(context.getPackageName(), R.layout.widget_regular);
showUsageOnWidget(widgetModel, views, widgetId, context, appWidgetManager);
break;
case WIDGET_STATUS_UPDATE_FAILED:
StaticTools.Log("Widget status", widgetId + ": WIDGET_STATUS_UPDATE_FAILED");
case WIDGET_STATUS_FAILED:
StaticTools.Log("Widget status", widgetId + ": WIDGET_STATUS_FAILED");
case WIDGET_STATUS_NO_XG:
StaticTools.Log("Widget status", widgetId + ": WIDGET_STATUS_NO_XG");
showNoXgWidget(widgetId, context, appWidgetManager);
break;
case WIDGET_STATUS_UPDATING:
StaticTools.Log("Widget status", widgetId + ": WIDGET_STATUS_UPDATING");
showRefreshingWidget(widgetId, context, appWidgetManager);
}
} else {
showNoXgWidget(widgetId, context, appWidgetManager);
}
}
private void showUsageOnWidget(WidgetModel widgetModel, RemoteViews views, int widgetId, Context context, AppWidgetManager appWidgetManager) {
StaticTools.Log("Widget", widgetId + ": showUsageOnWidget");
AppWidgetProviderInfo appWidgetProviderInfo = appWidgetManager.getAppWidgetInfo(widgetId);
if (appWidgetProviderInfo == null || widgetModel == null) {
return;
}
int size = appWidgetProviderInfo.minWidth / 2;
GaugeLayout v = (GaugeLayout) LayoutInflater.from(context).inflate(R.layout.widget_gauge_layout, null, false);
v.setLayoutParams(new ViewGroup.LayoutParams(size, size));
v.setGaugeBackColor(ContextCompat.getColor(context, R.color.gaugeInnerCircle));
v.setGaugeFrontColor(ContextCompat.getColor(context, R.color.gaugeOuterCircle));
int measureSpec = View.MeasureSpec.makeMeasureSpec(size, View.MeasureSpec.AT_MOST);
Bitmap bitmap = Bitmap.createBitmap(size, size, Bitmap.Config.ARGB_8888);
Canvas canvas = new Canvas(bitmap);
if (widgetModel.getDataPercentage() >= 0) {
v.setGaugeValue(widgetModel.getDataPercentage(), false);
} else {
v.setShowOuterCircle(false);
}
v.measure(measureSpec, measureSpec);
v.layout(0, 0, size, size);
v.draw(canvas);
views.setImageViewBitmap(R.id.dataGaugeView, bitmap.copy(bitmap.getConfig(), true));
views.setTextViewText(R.id.remainingData, widgetModel.getRemainingData());
views.setImageViewBitmap(R.id.dataGaugeViewFlipper, bitmap.copy(bitmap.getConfig(), true));
views.setTextViewText(R.id.remainingDataFlipper, widgetModel.getRemainingData());
int dataIconResourceId = widgetModel.isDataNotification() ? R.drawable.widget_data_notif : R.drawable.widget_data;
views.setImageViewResource(R.id.dataIcon, dataIconResourceId);
views.setImageViewResource(R.id.dataIconSingle, dataIconResourceId);
canvas.drawColor(Color.TRANSPARENT, PorterDuff.Mode.CLEAR);
if (widgetModel.getVoicePercentage() >= 0) {
v.setGaugeValue(widgetModel.getVoicePercentage(), false);
} else {
v.setShowOuterCircle(false);
}
v.measure(measureSpec, measureSpec);
v.layout(0, 0, size, size);
v.draw(canvas);
views.setImageViewBitmap(R.id.voiceGaugeView, bitmap.copy(bitmap.getConfig(), true));
views.setTextViewText(R.id.remainingVoice, widgetModel.getRemainingVoice());
views.setImageViewBitmap(R.id.voiceGaugeViewFlipper, bitmap.copy(bitmap.getConfig(), true));
views.setTextViewText(R.id.remainingVoiceFlipper, widgetModel.getRemainingVoiceSmall());
int voiceIconResourceId = widgetModel.isVoiceNotification() ? R.drawable.widget_voice_notif : R.drawable.widget_voice;
views.setImageViewResource(R.id.voiceIcon, voiceIconResourceId);
views.setImageViewResource(R.id.voiceIconSingle, voiceIconResourceId);
canvas.drawColor(Color.TRANSPARENT, PorterDuff.Mode.CLEAR);
if (widgetModel.getSmsPercentage() >= 0) {
v.setGaugeValue(widgetModel.getSmsPercentage(), false);
} else {
v.setShowOuterCircle(false);
}
v.measure(measureSpec, measureSpec);
v.layout(0, 0, size, size);
v.draw(canvas);
views.setImageViewBitmap(R.id.smsGaugeView, bitmap.copy(bitmap.getConfig(), true));
views.setTextViewText(R.id.remainingSms, widgetModel.getRemainingSms());
views.setImageViewBitmap(R.id.smsGaugeViewFlipper, bitmap.copy(bitmap.getConfig(), true));
views.setTextViewText(R.id.remainingSmsFlipper, widgetModel.getRemainingSmsSmall());
int smsIconResourceId = widgetModel.isSmsNotification() ? R.drawable.widget_sms_notif : R.drawable.widget_sms;
views.setImageViewResource(R.id.smsIcon, smsIconResourceId);
views.setImageViewResource(R.id.smsIconSingle, smsIconResourceId);
views.setTextViewText(R.id.msisdn, widgetModel.getMsisdn());
views.setTextViewText(R.id.lastRefresh, widgetModel.getLastRefresh());
views.setTextViewText(R.id.remainingBalance, widgetModel.getPrepayBalance());
if (widgetModel.isFlexible()) {
views.setViewVisibility(R.id.flexibleIndicator, View.VISIBLE);
views.setTextViewText(R.id.flexibleIndicator, context.getString(R.string.flexy_case_gauge));
} else {
views.setViewVisibility(R.id.flexibleIndicator, View.INVISIBLE);
}
addClickListeners(widgetId, views, context);
views.setOnClickPendingIntent(R.id.widget_logo, getLaunchIntent(context));
DisplayMetrics displayMetrics = context.getResources().getDisplayMetrics();
StaticTools.Log("Widget display metrics", displayMetrics.toString());
if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.JELLY_BEAN) {
Bundle widgetOptions = appWidgetManager.getAppWidgetOptions(widgetId);
if (widgetOptions != null && widgetOptions.containsKey(AppWidgetManager.OPTION_APPWIDGET_MIN_HEIGHT)) {
int maxHeight = widgetOptions.getInt(AppWidgetManager.OPTION_APPWIDGET_MAX_HEIGHT);
int minHeight = widgetOptions.getInt(AppWidgetManager.OPTION_APPWIDGET_MIN_HEIGHT);
float breakpoint = context.getResources().getDimension(R.dimen.widget_breakpoint);
checkHeight(maxHeight, minHeight, breakpoint/displayMetrics.density, widgetId, views, appWidgetManager, context);
} else {
appWidgetManager.updateAppWidget(widgetId, views);
}
} else {
appWidgetManager.updateAppWidget(widgetId, views);
}
}
private void showNoXgWidget(int widgetId, Context context, AppWidgetManager appWidgetManager) {
StaticTools.Log("Widget", widgetId + ": showNoXgWidget");
RemoteViews views = new RemoteViews(context.getPackageName(), R.layout.widget_loading);
views.setTextViewText(R.id.widgetMessage, context.getString(R.string.message_unavailability_body));
views.setOnClickPendingIntent(R.id.gaugeContainer, getRefreshIntent(widgetId, context));
views.setViewVisibility(R.id.widgetProgress, View.GONE);
views.setViewVisibility(R.id.refresh, View.VISIBLE);
views.setOnClickPendingIntent(R.id.widget_logo, getLaunchIntent(context));
appWidgetManager.updateAppWidget(widgetId, views);
}
private void showRefreshingWidget(int widgetId, Context context, AppWidgetManager appWidgetManager) {
StaticTools.Log("Widget", widgetId + ": showRefreshingWidget");
RemoteViews views = new RemoteViews(context.getPackageName(), R.layout.widget_loading);
views.setTextViewText(R.id.widgetMessage, "");
views.setViewVisibility(R.id.widgetProgress, View.VISIBLE);
views.setViewVisibility(R.id.refresh, View.GONE);
views.setOnClickPendingIntent(R.id.widget_logo, getLaunchIntent(context));
appWidgetManager.updateAppWidget(widgetId, views);
}
protected void addClickListeners(int widgetId, RemoteViews root, Context context) {
root.setOnClickPendingIntent(R.id.leftArrow, getNavigationIntent(widgetId, R.id.leftArrow, context));
root.setOnClickPendingIntent(R.id.rightArrow, getNavigationIntent(widgetId, R.id.rightArrow, context));
root.setOnClickPendingIntent(R.id.lastRefresh, getRefreshIntent(widgetId, context));
root.setOnClickPendingIntent(R.id.widget_configuration, getConfigurationIntent(widgetId, context));
}
private PendingIntent getLaunchIntent(Context context) {
Intent intentOpen = new Intent(context, ActSplash.class);
intentOpen.setFlags(Intent.FLAG_ACTIVITY_NEW_TASK | Intent.FLAG_ACTIVITY_RESET_TASK_IF_NEEDED);
intentOpen.addCategory(Intent.CATEGORY_LAUNCHER);
intentOpen.setAction(Intent.ACTION_MAIN);
return PendingIntent.getActivity(context, 0, intentOpen, PendingIntent.FLAG_UPDATE_CURRENT);
}
protected PendingIntent getNavigationIntent(int widgetId, int id, Context context) {
Intent clickIntent = new Intent(context, VFGRWidget.class);
clickIntent.setAction(id == R.id.rightArrow ? WIDGET_NAVIGATION_FORWARD : WIDGET_NAVIGATION_BACKWARD);
clickIntent.putExtra(AppWidgetManager.EXTRA_APPWIDGET_ID, widgetId);
return PendingIntent.getBroadcast(context, widgetId, clickIntent, PendingIntent.FLAG_UPDATE_CURRENT);
}
protected PendingIntent getRefreshIntent(int widgetId, Context context) {
Intent clickIntent = new Intent(context, VFGRWidget.class);
clickIntent.setAction(FORCE_WIDGET_UPDATE);
clickIntent.putExtra(AppWidgetManager.EXTRA_APPWIDGET_ID, widgetId);
return PendingIntent.getBroadcast(context, widgetId, clickIntent, PendingIntent.FLAG_UPDATE_CURRENT);
}
protected PendingIntent getConfigurationIntent(int widgetId, Context context) {
Intent configurationIntent = new Intent(context, ActWidgetSettings.class);
configurationIntent.putExtra(AppWidgetManager.EXTRA_APPWIDGET_ID, widgetId);
configurationIntent.setFlags(Intent.FLAG_ACTIVITY_EXCLUDE_FROM_RECENTS | Intent.FLAG_ACTIVITY_NO_HISTORY | Intent.FLAG_ACTIVITY_CLEAR_TOP | Intent.FLAG_ACTIVITY_NEW_TASK);
return PendingIntent.getActivity(context, widgetId, configurationIntent, PendingIntent.FLAG_UPDATE_CURRENT);
}
protected void onNavigate(Context context, Integer widgetId, int id) {
AppWidgetManager appWidgetManager = AppWidgetManager.getInstance(context);
RemoteViews root = new RemoteViews(context.getPackageName(), R.layout.widget_regular);
if (id == R.id.leftArrow) {
root.showPrevious(R.id.gaugeFlipper);
} else {
root.showNext(R.id.gaugeFlipper);
}
appWidgetManager.updateAppWidget(widgetId, root);
}
@Override
public void onEnabled(Context context) {
super.onEnabled(context);
StaticTools.Log("Widget", "onEnabled");
widgetModels = new HashMap<>();
StaticTools.loadLanguage(context);
}
@Override
public void onDisabled(Context context) {
super.onDisabled(context);
StaticTools.Log("Widget", "onDisabled");
context.stopService(new Intent(context, WidgetManager.class));
widgetModels = null;
VFPreferences.removeAllWidgetSettings();
}
@Override
public void onUpdate(Context context, final AppWidgetManager appWidgetManager, int[] appWidgetIds) {
super.onUpdate(context, appWidgetManager, appWidgetIds);
StaticTools.Log("Widget", "onUpdate");
if (widgetModels == null) {
widgetModels = new HashMap<>();
}
for (final int appWidgetId : appWidgetIds) {
WidgetModel widgetModel = null;
if (!getWidgetModels().containsKey(appWidgetId)) {
widgetModel = getWidgetModel(appWidgetId);
if (widgetModel != null) {
getWidgetModels().put(appWidgetId, widgetModel);
}
}
if (widgetModel != null) {
if (!(widgetModel.getAccount() instanceof VFMobileXGAccount) || StaticTools.checkVodafone3G(context)) {
showRefreshingWidget(appWidgetId, context, appWidgetManager);
} else {
showNoXgWidget(appWidgetId, context, appWidgetManager);
}
}
}
context.startService(new Intent(context, WidgetManager.class));
}
public static void storeWidgetSettings(WidgetModel model) {
Gson gson = new GsonBuilder().registerTypeAdapterFactory(MemoryCacheManager.adapter).create();
VFAccount currentAccount = model.getAccount();
VFAccount transientAccount = buildTransientAccount();
model.setAccount(transientAccount);
String jsonModel = gson.toJson(model, WidgetModel.class);
VFPreferences.setWidgetSettings(model.getWidgetId(), jsonModel);
model.setAccount(currentAccount);
}
private WidgetModel getWidgetModel(int widgetId) {
String modelJson = VFPreferences.getWidgetSettings(widgetId);
if (!"".equals(modelJson)) {
StaticTools.Log("Widget model", modelJson);
Gson gson = new GsonBuilder().excludeFieldsWithoutExposeAnnotation().registerTypeAdapterFactory(MemoryCacheManager.adapter).create();
return gson.fromJson(modelJson, WidgetModel.class);
} else {
VFPreferences.removeWidgetSettings(widgetId);
return null;
}
}
static VFAccount buildTransientAccount() {
VFMobileXGAccount transientAccount = new VFMobileXGAccount();
transientAccount.setAccountType(VFAccount.TYPE_MOBILE_VF3G);
return transientAccount;
}
public static HashMap<Integer, WidgetModel> getWidgetModels() {
if (widgetModels == null) {
widgetModels = new HashMap<>();
}
return widgetModels;
}
}
|
package br.com.wasys.library.service;
import android.content.Context;
import android.content.pm.PackageManager;
import android.support.v4.content.ContextCompat;
import org.apache.commons.lang3.ArrayUtils;
import br.com.wasys.library.Application;
/**
* Created by pascke on 05/09/16.
*/
public abstract class Service {
public static boolean isPermissionGranted(String... permissions) {
boolean granted = false;
if (ArrayUtils.isNotEmpty(permissions)) {
granted = true;
Context context = Application.getContext();
for (String permission : permissions) {
if (ContextCompat.checkSelfPermission(context, permission) != PackageManager.PERMISSION_GRANTED) {
granted = false;
break;
}
}
}
return granted;
}
}
|
package com.gsccs.sme.plat.bass.service;
/**
* 查询参数
*
* @author x.d zhang
*
*/
public class QueryParam {
private String siteId;
private String keyword;
private String cateId;
// 分页参数
private int page = 1;
private int rows = 10;
private String order = "score desc";
public String getSiteId() {
return siteId;
}
public void setSiteId(String siteId) {
this.siteId = siteId;
}
public String getKeyword() {
return keyword;
}
public void setKeyword(String keyword) {
this.keyword = keyword;
}
public String getCateId() {
return cateId;
}
public void setCateId(String cateId) {
this.cateId = cateId;
}
public int getPage() {
return page;
}
public void setPage(int page) {
this.page = page;
}
public int getRows() {
return rows;
}
public void setRows(int rows) {
this.rows = rows;
}
public int getStart() {
return (getPage() - 1) * getRows();
}
public String getOrder() {
return order;
}
public void setOrder(String order) {
this.order = order;
}
}
|
/*
* To change this license header, choose License Headers in Project Properties.
* To change this template file, choose Tools | Templates
* and open the template in the editor.
*/
package livraria.vo;
import java.io.Serializable;
/**
*
* @author Nilliam Ometto
*/
public class VendaItem implements Serializable {
private Livro livro;
private Integer qtd;
private Double preco;
public Livro getLivro() {
return livro;
}
public void setLivro(Livro livro) {
this.livro = livro;
}
public Integer getQtd() {
return qtd;
}
public void setQtd(Integer qtd) {
this.qtd = qtd;
}
public Double getPreco() {
return preco;
}
public void setPreco(Double preco) {
this.preco = preco;
}
}
|
/**
* Sencha GXT 1.0.0-SNAPSHOT - Sencha for GWT
* Copyright (c) 2006-2018, Sencha Inc.
*
* licensing@sencha.com
* http://www.sencha.com/products/gxt/license/
*
* ================================================================================
* Commercial License
* ================================================================================
* This version of Sencha GXT is licensed commercially and is the appropriate
* option for the vast majority of use cases.
*
* Please see the Sencha GXT Licensing page at:
* http://www.sencha.com/products/gxt/license/
*
* For clarification or additional options, please contact:
* licensing@sencha.com
* ================================================================================
*
*
*
*
*
*
*
*
* ================================================================================
* Disclaimer
* ================================================================================
* THIS SOFTWARE IS DISTRIBUTED "AS-IS" WITHOUT ANY WARRANTIES, CONDITIONS AND
* REPRESENTATIONS WHETHER EXPRESS OR IMPLIED, INCLUDING WITHOUT LIMITATION THE
* IMPLIED WARRANTIES AND CONDITIONS OF MERCHANTABILITY, MERCHANTABLE QUALITY,
* FITNESS FOR A PARTICULAR PURPOSE, DURABILITY, NON-INFRINGEMENT, PERFORMANCE AND
* THOSE ARISING BY STATUTE OR FROM CUSTOM OR USAGE OF TRADE OR COURSE OF DEALING.
* ================================================================================
*/
package com.sencha.gxt.explorer.client.misc;
import com.google.gwt.core.client.EntryPoint;
import com.google.gwt.user.client.ui.IsWidget;
import com.google.gwt.user.client.ui.Widget;
import com.sencha.gxt.cell.core.client.form.ComboBoxCell.TriggerAction;
import com.sencha.gxt.core.client.util.Margins;
import com.sencha.gxt.data.shared.StringLabelProvider;
import com.sencha.gxt.examples.resources.client.Utils;
import com.sencha.gxt.examples.resources.client.Utils.Theme;
import com.sencha.gxt.explorer.client.app.ui.ExampleContainer;
import com.sencha.gxt.explorer.client.model.Example.Detail;
import com.sencha.gxt.widget.core.client.ContentPanel;
import com.sencha.gxt.widget.core.client.FramedPanel;
import com.sencha.gxt.widget.core.client.box.AlertMessageBox;
import com.sencha.gxt.widget.core.client.button.TextButton;
import com.sencha.gxt.widget.core.client.container.CssFloatLayoutContainer;
import com.sencha.gxt.widget.core.client.container.CssFloatLayoutContainer.CssFloatData;
import com.sencha.gxt.widget.core.client.container.MarginData;
import com.sencha.gxt.widget.core.client.event.SelectEvent;
import com.sencha.gxt.widget.core.client.event.SelectEvent.SelectHandler;
import com.sencha.gxt.widget.core.client.form.FieldLabel;
import com.sencha.gxt.widget.core.client.form.NumberField;
import com.sencha.gxt.widget.core.client.form.NumberPropertyEditor.IntegerPropertyEditor;
import com.sencha.gxt.widget.core.client.form.SimpleComboBox;
import com.sencha.gxt.widget.core.client.form.TextField;
import com.sencha.gxt.widget.core.client.form.validator.EmptyValidator;
import com.sencha.gxt.widget.core.client.form.validator.MinNumberValidator;
import com.sencha.gxt.widget.core.client.info.DefaultInfoConfig;
import com.sencha.gxt.widget.core.client.info.Info;
import com.sencha.gxt.widget.core.client.info.InfoConfig.InfoPosition;
@Detail(
name = "Notification",
category = "Miscellaneous",
icon = "notification",
preferredHeight = NotificationExample.PREFERRED_HEIGHT,
preferredWidth = NotificationExample.PREFERRED_WIDTH,
classes = { Utils.class }
)
public class NotificationExample implements IsWidget, EntryPoint {
protected static final int PREFERRED_HEIGHT = -1;
protected static final int PREFERRED_WIDTH = 400;
private ContentPanel panel;
@Override
public Widget asWidget() {
if (panel == null) {
final TextField title = new TextField();
title.setValue("Notification Title");
final TextField text = new TextField();
text.setValue("This is the notification text");
final SimpleComboBox<InfoPosition> positionCombo = new SimpleComboBox<InfoPosition>(
new StringLabelProvider<InfoPosition>());
positionCombo.add(InfoPosition.TOP_LEFT);
positionCombo.add(InfoPosition.TOP_RIGHT);
positionCombo.add(InfoPosition.BOTTOM_LEFT);
positionCombo.add(InfoPosition.BOTTOM_RIGHT);
positionCombo.setEditable(false);
positionCombo.setTriggerAction(TriggerAction.ALL);
positionCombo.setValue(InfoPosition.TOP_RIGHT);
final NumberField<Integer> display = new NumberField<Integer>(new IntegerPropertyEditor());
display.setValue(2500);
display.addValidator(new EmptyValidator<Integer>());
display.addValidator(new MinNumberValidator<Integer>(100));
TextButton showButton = new TextButton("Show Notification");
showButton.addSelectHandler(new SelectHandler() {
@Override
public void onSelect(SelectEvent event) {
if (display.isCurrentValid()) {
DefaultInfoConfig config = new DefaultInfoConfig(title.getValue(), text.getValue());
config.setPosition(positionCombo.getValue());
config.setDisplay(display.getValue());
Info.display(config);
} else {
AlertMessageBox d = new AlertMessageBox("Alert", "Please increase the Display (ms) to 100+.");
d.show();
}
}
});
CssFloatLayoutContainer container = new CssFloatLayoutContainer();
container.add(new FieldLabel(title, "Title"), new CssFloatData(1, new Margins(0, 0, 10, 0)));
container.add(new FieldLabel(text, "Text"), new CssFloatData(1, new Margins(0, 0, 10, 0)));
container.add(new FieldLabel(positionCombo, "Position"), new CssFloatData(1, new Margins(0, 0, 10, 0)));
container.add(new FieldLabel(display, "Display (ms)"), new CssFloatData(1));
panel = Theme.BLUE.isActive() || Theme.GRAY.isActive() ? new FramedPanel() : new ContentPanel();
panel.setHeading("Notification");
panel.add(container, new MarginData(10));
panel.addButton(showButton);
}
return panel;
}
@Override
public void onModuleLoad() {
new ExampleContainer(this)
.setPreferredHeight(PREFERRED_HEIGHT)
.setPreferredWidth(PREFERRED_WIDTH)
.doStandalone();
}
}
|
public class Solution {
int[] dp;
public int util(int n) {
if(dp[n] != -1) return dp[n];
dp[n] = util(n-1) + util(n-2);
return dp[n];
}
public int climbStairs(int n) {
dp = new int[n+1];
Arrays.fill(dp, -1);
dp[0] = 1; dp[1] = 1;
if(n<=1) return dp[n];
return util(n);
}
}
|
package co.sblock.commands.info;
import java.math.RoundingMode;
import java.text.DecimalFormat;
import java.util.ArrayList;
import java.util.List;
import org.bukkit.Material;
import org.bukkit.command.CommandSender;
import org.bukkit.entity.Player;
import org.bukkit.inventory.ItemStack;
import com.google.common.collect.ImmutableList;
import co.sblock.Sblock;
import co.sblock.captcha.Captcha;
import co.sblock.captcha.CruxiteDowel;
import co.sblock.commands.SblockCommand;
import co.sblock.effects.Effects;
import co.sblock.utilities.Experience;
import co.sblock.utilities.InventoryUtils;
/**
* SblockCommand for getting information about grist costs and totals.
*
* @author Jikoo
*/
public class GristCommand extends SblockCommand {
private final Captcha captcha;
private final Effects effects;
private final DecimalFormat format;
public GristCommand(Sblock plugin) {
super(plugin, "grist");
this.captcha = plugin.getModule(Captcha.class);
this.effects = plugin.getModule(Effects.class);
this.format = new DecimalFormat("#,###,###,###.###");
this.format.setRoundingMode(RoundingMode.CEILING);
}
@Override
protected boolean onCommand(CommandSender sender, String label, String[] args) {
if (args.length < 1) {
return false;
}
try {
if (args[0].length() > 1) {
char lastChar = args[0].charAt(args[0].length() - 1);
if (lastChar == 'L' || lastChar == 'l') {
int level = Integer.parseInt(args[0].substring(0, args[0].length() - 1));
sender.sendMessage(this.getLang().getValue("command.grist.level")
.replace("{LEVEL}", this.format.format(level))
.replace("{EXP}", this.format.format(Experience.getExpFromLevel(level))));
return true;
}
}
int grist = Integer.parseInt(args[0]);
sender.sendMessage(this.getLang().getValue("command.grist.exp")
.replace("{LEVEL}", this.format.format(Experience.getLevelFromExp(grist)))
.replace("{EXP}", this.format.format(grist)));
return true;
} catch (NumberFormatException e) {
if (!args[0].equalsIgnoreCase("cost") && !args[0].equalsIgnoreCase("current")) {
return false;
}
}
if (!(sender instanceof Player)) {
sender.sendMessage("/grist <(exp)|(level)L>");
return true;
}
Player player = (Player) sender;
if (args[0].equalsIgnoreCase("current")) {
sender.sendMessage(this.getLang().getValue("command.grist.current")
.replace("{EXP}", this.format.format(Experience.getExp(player))));
return true;
}
ItemStack hand = player.getInventory().getItemInMainHand();
if (Captcha.isUsedCaptcha(hand) || Captcha.isPunch(hand) || CruxiteDowel.isDowel(hand)) {
hand = captcha.captchaToItem(hand);
}
if (hand == null || hand.getType() == Material.AIR) {
sender.sendMessage(this.getLang().getValue("command.grist.nothing"));
return true;
}
int exp = CruxiteDowel.expCost(effects, hand);
if (exp == Integer.MAX_VALUE) {
sender.sendMessage(this.getLang().getValue("command.grist.expensive")
.replace("{ITEM}", InventoryUtils.getItemName(hand)));
} else {
sender.sendMessage(this.getLang().getValue("command.grist.cost")
.replace("{ITEM}", InventoryUtils.getItemName(hand))
.replace("{EXP}", this.format.format(exp)));
}
return true;
}
@Override
public List<String> tabComplete(CommandSender sender, String alias, String[] args) {
if (!sender.hasPermission(this.getPermission()) || args.length != 1) {
return ImmutableList.of();
}
args[0] = args[0].toLowerCase();
List<String> completions = new ArrayList<>();
if ("cost".startsWith(args[0])) {
completions.add("cost");
}
if ("current".startsWith(args[0])) {
completions.add("current");
}
return completions;
}
}
|
class Solution {
public int[] dailyTemperatures(int[] temperatures) {
int n = temperatures.length;
int hottest = 0;
int answer[] = new int[n];
for (int currDay = n - 1; currDay >= 0; currDay--) {
int currentTemp = temperatures[currDay];
if (currentTemp >= hottest) {
hottest = currentTemp;
continue;
}
int days = 1;
while (temperatures[currDay + days] <= currentTemp) {
// Use information from answer to search for the next warmer day
days += answer[currDay + days];
}
answer[currDay] = days;
}
return answer;
}
} |
package example.imp;
import java.io.FileInputStream;
import java.text.SimpleDateFormat;
import java.util.List;
import org.apache.poi.ss.usermodel.Sheet;
import org.apache.poi.ss.usermodel.Workbook;
import org.apache.poi.ss.usermodel.WorkbookFactory;
import com.alibaba.fastjson.JSON;
import excel.ExcelImportUtils;
import excel.ParseSheetCallback;
public class MainClass {
public static void main(String[] args) throws Exception {
parseSheet();
parseSheetWithCallback();
}
/**
* 解析excel
* @throws Exception
*/
public static void parseSheet() throws Exception {
Workbook wb = WorkbookFactory.create(new FileInputStream("src/test/java/example/imp/import.xlsx"));
Sheet sheet = wb.getSheetAt(0);
// parseSheet
List<Member> list = ExcelImportUtils.parseSheet(
Member.class, MemberVerifyBuilder.getInstance(), sheet, 1);
System.out.println(JSON.toJSONString(list));
}
/**
* 解析excel带回调函数：做一些额外字段填充
* @throws Exception
*/
public static void parseSheetWithCallback() throws Exception {
Workbook wb = WorkbookFactory.create(new FileInputStream("src/test/java/example/imp/import.xlsx"));
Sheet sheet = wb.getSheetAt(0);
final SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
// parseSheet
List<Member> list = ExcelImportUtils.parseSheet(
Member.class, MemberVerifyBuilder.getInstance(), sheet, 1, new ParseSheetCallback<Member>() {
public void callback(Member t, int rowNum) throws Exception {
t.setDateDesc(sdf.format(t.getDate()));
}
});
System.out.println(JSON.toJSONString(list));
}
}
|
package com.meehoo.biz.core.basic.concurrency.task;
/**
* @author zc
* @date 2020-12-31
*/
public interface IBuilder {
}
|
package com.datagraph.core.db.model.impl;
import com.datagraph.core.db.model.TaskDao;
import com.datagraph.core.engine.tasks.Task;
/**
* Created by Denny Joseph on 6/17/16.
*/
public class TaskJDBIDao implements TaskDao {
@Override
public int create(Task task) {
return 0;
}
@Override
public boolean update(Task task) {
return false;
}
@Override
public Task find(long id) {
return null;
}
@Override
public boolean delete(long id) {
return false;
}
}
|
/**
*
*/
package com.cassandra.TrialWithIText;
/**
* @author Cassandra Mae
*
*/
public enum ToolsOptions {
RECTANGLE("Rectangle"),
SELECT("Select");
public final String label;
ToolsOptions(String label) {
this.label = label;
}
}
|
package de.netempire.state.classes;
public class Fork {
private boolean taken;
private int id;
public synchronized void put() {
// Fork is placed back on the table. -> status: not taken
taken = false;
notify();
}
public synchronized void get() throws InterruptedException {
// Fork is taken from the table. -> status: taken
while (taken) {
wait(); // wait until the fork is back on the table.
}
taken = true;
}
public boolean isTaken() {
return taken;
}
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
} |
package com.karya.model;
import java.io.Serializable;
import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.Table;
@Entity
@Table(name="crmsplead001mb")
public class CrmspLead001MB implements Serializable{
private static final long serialVersionUID = -723583058586873479L;
@Id
@GeneratedValue(strategy=GenerationType.AUTO)
@Column(name = "slineId")
private int slineId;
@Column(name="personName")
private String personName;
@Column(name="orgName")
private String orgName;
@Column(name="status")
private String status;
public int getSlineId() {
return slineId;
}
public void setSlineId(int slineId) {
this.slineId = slineId;
}
public String getPersonName() {
return personName;
}
public void setPersonName(String personName) {
this.personName = personName;
}
public String getOrgName() {
return orgName;
}
public void setOrgName(String orgName) {
this.orgName = orgName;
}
public String getStatus() {
return status;
}
public void setStatus(String status) {
this.status = status;
}
public static long getSerialversionuid() {
return serialVersionUID;
}
}
|
package com.aof.webapp.action.prm.report;
import java.sql.SQLException;
import java.util.Hashtable;
import java.util.LinkedList;
import java.util.List;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import net.sf.hibernate.HibernateException;
import net.sf.hibernate.Query;
import net.sf.hibernate.Transaction;
import org.apache.log4j.Logger;
import org.apache.struts.action.ActionErrors;
import org.apache.struts.action.ActionForm;
import org.apache.struts.action.ActionForward;
import org.apache.struts.action.ActionMapping;
import com.aof.component.domain.party.Party;
import com.aof.component.domain.party.PartyHelper;
import com.aof.component.domain.party.UserLogin;
import com.aof.component.prm.project.ProjectMaster;
import com.aof.component.prm.report.BackLog;
import com.aof.component.prm.report.BackLogBean;
import com.aof.component.prm.report.BackLogMaster;
import com.aof.component.prm.report.BackLogService;
import com.aof.component.prm.report.ProjectBean;
import com.aof.core.persistence.Persistencer;
import com.aof.core.persistence.hibernate.Hibernate2Session;
import com.aof.core.persistence.jdbc.SQLExecutor;
import com.aof.core.persistence.jdbc.SQLResults;
import com.aof.core.persistence.util.EntityUtil;
import com.aof.util.Constants;
import com.aof.webapp.action.ActionErrorLog;
import com.aof.webapp.action.BaseAction;
public class ViewBackLogAction extends BaseAction {
protected ActionErrors errors = new ActionErrors();
protected ActionErrorLog actionDebug = new ActionErrorLog();
public ActionForward perform(ActionMapping mapping, ActionForm form,
HttpServletRequest request, HttpServletResponse response) {
// Extract attributes we will need
ActionErrors errors = this.getActionErrors(request.getSession());
Logger log = Logger.getLogger(ViewBackLogAction.class.getName());
try {
String action = request.getParameter("formaction");
String cyear = request.getParameter("cyear");
String cmonth = request.getParameter("cmonth");
String status = request.getParameter("status");
String department = request.getParameter("departmentId");
String type = request.getParameter("type");
String flag = request.getParameter("recurringflag");
String attr_department = "";
String attr_flag ="";
log.info("action="+action);
if ((action == null)||(action.equalsIgnoreCase("formaction"))) {
action = (String) request.getAttribute("formaction");
if(!((cyear!=null&&(cyear.length()>0)))){
cyear = (String) request.getAttribute("cyear");
cmonth = (String) request.getAttribute("cmonth");
}
attr_department = (String)request.getAttribute("departmentId");
attr_flag = (String)request.getAttribute("recurringflag");
action = "draft";
}
log.info("action="+action);
net.sf.hibernate.Session hs = Hibernate2Session.currentSession();
Transaction tx = null;
tx = hs.beginTransaction();
String bldate = cyear + "-" + "1-1";
List securitylist = new LinkedList();
List depcodelist = new LinkedList();
List partyList = null;
String departmentdesc = ((Party)hs.load(Party.class,department)).getDescription();
UserLogin ul = (UserLogin) request.getSession().getAttribute(
Constants.USERLOGIN_KEY);
if(ul.getParty().getPartyId()==null)
return null;
long start=System.currentTimeMillis();
Query query = hs
.createQuery("select distinct pt from Party as p inner join p.relationships as pr inner join pr.partyTo as pt"
+ " where p.partyId=? and pr.relationshipType=?");
if((department==null)&&(department.length()<1))
{
query.setString(0,attr_department);
}
else
query.setString(0, department);
query.setString(1, "GROUP_ROLLUP");
partyList = query.list();
Party childparty=(Party)hs.load(Party.class,department);
if (partyList.size() == 0) {
partyList = new LinkedList();
}
partyList.add(0,childparty);
for (int x = 0; x < partyList.size(); x++) {
securitylist.add(((Party) partyList.get(x)).getDescription());
depcodelist.add(((Party) partyList.get(x)).getPartyId());
}
request.setAttribute("securitylist", securitylist);
String strquery="";
if(depcodelist.size()==1)
strquery=strquery+"'"+depcodelist.get(0)+"'";
else if(depcodelist.size()>1)
for(int n=0;n<depcodelist.size();n++)
{
strquery=strquery+"'"+depcodelist.get(n)+"'";
if(n!=depcodelist.size()-1)
strquery+=",";
}
// System.out.println("the query string for backlog is: "+strquery);
if (action.equalsIgnoreCase("realtime")) {
BackLogService blservice = new BackLogService(cyear, cmonth, department);
blservice.execuSQL(hs,strquery);
}
query = hs
.createQuery("select bl from BackLog as bl inner join bl.project as pm"
+ " where pm.projectCategory.Id='c'"
+ " and (pm.projStatus='wip' or pm.closeDate >= case when (pm.projStatus='pc')then convert(datetime,?)"
+ " end or pm.closeDate >= case when (pm.projStatus='close')then convert(datetime,?) end) and "
+ " pm.department.partyId in("+strquery+")order by blm.project");
query.setString(0,bldate);
query.setString(1,bldate);
List backlist = new LinkedList();
backlist = query.list();
Hashtable backtable = new Hashtable();
for (int b = 0; b < backlist.size(); b++) {
BackLog backlog = (BackLog) backlist.get(b);
if (backtable.get(backlog.getproject().getProjId()) == null) {
List rcdlist = new LinkedList();
rcdlist.add(backlog);
backtable.put(backlog.getProject().getProjId(), rcdlist);
} else {
List rcdlist = null;
rcdlist = (List) backtable.get(backlog.getproject()
.getProjId());
rcdlist.add(backlog);
}
}
query = hs.createQuery("select blm from BackLogMaster as blm inner join blm.project as pm "
+ " where pm.projectCategory.Id='c'"
+ " and (pm.projStatus='wip' or pm.closeDate >= case when (pm.projStatus='pc')then convert(datetime,?)"
+ " end or pm.closeDate >= case when (pm.projStatus='close')then convert(datetime,?) end)"
+ " and pm.department.partyId in("+strquery+") order by blm.project");
query.setString(0,bldate);
query.setString(1,bldate);
List masterlist = null;
masterlist = query.list();
Hashtable mastertable = new Hashtable();
if((masterlist!=null)&&(masterlist.size()!=0)){
for (int b = 0; b < masterlist.size(); b++) {
BackLogMaster master = (BackLogMaster) masterlist.get(b);
if (mastertable.get(master.getProject()) == null) {
List rcdlist = new LinkedList();
rcdlist.add(master);
mastertable.put(master.getProject().getProjId(), rcdlist);
} else {
List rcdlist = null;
rcdlist = (List) mastertable.get(master.getProject().getProjId());
rcdlist.add(master);
}
}
}
for (int p = 0; p < depcodelist.size(); p++) {
List recordlist = new LinkedList();
SQLExecutor sqlExec = new SQLExecutor(Persistencer
.getSQLExecutorConnection(EntityUtil
.getConnectionByName("jdbc/aofdb")));
String SqlStr;
SqlStr = "select proj_id, proj_name,dep_id,proj_pm_user,total_service_value"
+ ",start_date,end_date,proj_status,contracttype,proj_caf_flag,total_service_value,"
+ "close_date,cust.description,cp.t2_code,ind_description,duration from proj_mstr inner join party as cust"
+ " on proj_mstr.cust_id=cust.party_id inner join custprofile as cp on proj_mstr.cust_id=cp.party_id "
+ " inner join industry as ind on cust_industry=ind.ind_id ";
SqlStr = SqlStr
+ " where proj_mstr.dep_id="+(String) depcodelist.get(p)+" and proj_mstr.proj_Category='c'";
SqlStr = SqlStr
+ " and (proj_status='wip' or close_date >= case when (proj_status='pc')then convert(datetime,'"+bldate+"')";
SqlStr = SqlStr
+ " end or close_date >= case when (proj_status='close')then convert(datetime,'"+bldate+"') end)" ;
if((flag!=null)&&((flag.equalsIgnoreCase("on"))||(flag.equalsIgnoreCase("y")))){
SqlStr =SqlStr+" and duration='recurring'";
request.setAttribute("recurringflag","y");
}
if((attr_flag!=null)&&((attr_flag.equalsIgnoreCase("on"))||(attr_flag.equalsIgnoreCase("y"))))
{
SqlStr =SqlStr+" and duration='recurring'";
request.setAttribute("recurringflag","y");
}
// else
// request.setAttribute("recurringflag","n");
if ((type!=null)){
if(!type.equalsIgnoreCase("all")){
SqlStr =SqlStr+" and duration='"+type+"'";
if(type.trim().equalsIgnoreCase("recurring"))
request.setAttribute("recurringflag","y");
}
else{
SqlStr =SqlStr+" and duration!='other'";
}
request.setAttribute("type",type);
}
SqlStr = SqlStr
+ " order by duration desc,proj_id";
// System.out.println(SqlStr);
SQLResults sr = sqlExec.runQueryCloseCon(SqlStr);
int row = 0;
if (sr.getRowCount() != 0) {
for (int i = 0; i < sr.getRowCount(); i++) {
ProjectBean pb = new ProjectBean(sr.getString(row,
"proj_id"), sr.getString(row, "proj_name"), sr
.getString(row, "description"), sr.getString(
row, "dep_id"), sr
.getString(row, "proj_status"), sr.getString(
row, "proj_pm_user"), sr.getString(row,
"proj_caf_flag"), sr.getDouble(row,
"total_service_value"), sr.getString(row,
"proj_id"), sr.getString(row, "contracttype"),
sr.getDate(row, "start_date"), sr.getDate(row,
"end_date"), sr.getString(row,
"t2_code"), sr.getString(row,
"ind_description"),sr.getString(row,"duration"));
List bllist = (List) backtable.get(sr.getString(row,
"proj_id"));
List mstlist = (List)mastertable.get(sr.getString(row,
"proj_id"));
if (bllist == null)
bllist = new LinkedList();
if(mstlist==null)
mstlist=new LinkedList();
BackLogBean bean = new BackLogBean();
bean.initial(pb, bllist, cyear, cmonth, action,mstlist);
bean.setBean();
recordlist.add(bean);
row++;
}
request.setAttribute((String) securitylist.get(p),
recordlist);
}
else
{
request.setAttribute((String) securitylist.get(p),
new LinkedList());
}
}
request.setAttribute("enter_month", cmonth);
request.setAttribute("enter_year", cyear);
request.setAttribute("departmentId", department);
request.setAttribute("departmentdesc",departmentdesc);
hs.flush();
tx.commit();
// System.out.println(action);
if ((action.equalsIgnoreCase("export"))&&(status!=null)&&(status.equalsIgnoreCase("export")))
return (mapping.findForward("export"));
if (action.equalsIgnoreCase("draft")
|| (action.equalsIgnoreCase("realtime"))||(action.equalsIgnoreCase("requery"))){
return (mapping.findForward("view"));
}
else
return (mapping.findForward("error"));
} catch (Exception e) {
e.printStackTrace();
log.error(e.getMessage());
return (mapping.findForward("error"));
} finally {
try {
Hibernate2Session.closeSession();
} catch (HibernateException e1) {
log.error(e1.getMessage());
e1.printStackTrace();
} catch (SQLException e1) {
log.error(e1.getMessage());
e1.printStackTrace();
}
}
}
}
|
package com.culturaloffers.maps.component;
import com.culturaloffers.maps.helper.OnRegistrationCompleteEvent;
import com.culturaloffers.maps.model.User;
import com.culturaloffers.maps.services.UserDetailsServiceImpl;
import com.culturaloffers.maps.services.UserService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.ApplicationListener;
import org.springframework.mail.SimpleMailMessage;
import org.springframework.mail.javamail.JavaMailSender;
import org.springframework.stereotype.Component;
import java.util.UUID;
@Component
public class RegistrationListener implements
ApplicationListener<OnRegistrationCompleteEvent> {
@Autowired
private UserDetailsServiceImpl userDetailsService;
@Autowired
private JavaMailSender mailSender;
@Override
public void onApplicationEvent(OnRegistrationCompleteEvent event) {
this.confirmRegistration(event);
}
private void confirmRegistration(OnRegistrationCompleteEvent event) {
User user = event.getUser();
String token = UUID.randomUUID().toString();
userDetailsService.createVerificationToken(user, token);
String recipientAddress = user.getEmailAddress();
String subject = "Registration confirmation";
String confirmationUrl = "/registrationConfirm?token=" + token;
String message = "For finishing your registration please follow this link: ";
SimpleMailMessage email = new SimpleMailMessage();
email.setTo(recipientAddress);
email.setSubject(subject);
email.setText(message + "\r\n" + "http://localhost:4200" + confirmationUrl);
mailSender.send(email);
}
}
|
package com.kevin.cloud.service.feign;
import com.kevin.cloud.commons.dto.user.dto.UmsAdminDto;
import com.kevin.cloud.configuration.fegin.configuration.FeignRequestConfiguration;
import org.springframework.cloud.openfeign.FeignClient;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
/**
* @ClassName UserServiceFeign
* @Author pwc kevin
* @Date 1/6/2020 3:43 PM
* Version 1.0
**/
@FeignClient(value = "service-user" ,path = "user" ,configuration = FeignRequestConfiguration.class
/*, fallback = UserServiceFeignFallBack.class*/)
public interface UserServiceFeign {
/**
* 获取个人信息
*
* @param username {@code String} 用户名
* @return {@code String} JSON
*/
@GetMapping(value = "info/{username}")
String info(@PathVariable String username);
@GetMapping(value = "getCurrentUser")
UmsAdminDto getCurrentUser();
}
|
package no.hvl.dat100;
import static javax.swing.JOptionPane.*;
public class Oppgave6_uke_36 {
public static void main(String[] args) {
// lage et program som regner n! = n fakultet. (5! = 1*2*3*4*5 = 120)
int n = Integer.parseInt(showInputDialog("Skriv in verdi for n "));
int a = 1; // lager en telle variabel til løkken
for (int i = 1; n >= i; i++) { // setter inn int i = 1 siden vi vil at den skal begynne fra 1.
a*= i; //
}
showMessageDialog(null, n + "! til svar: " + a);
}
}
|
package com.ecommerceserver.controller;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.util.ArrayList;
import java.util.Date;
import java.util.List;
import java.util.Optional;
import java.util.regex.Pattern;
import com.ecommerceserver.model.Category;
import com.ecommerceserver.model.Product;
import com.ecommerceserver.model.ReviewStar;
import com.ecommerceserver.model.Seller;
import com.ecommerceserver.model.User;
import com.ecommerceserver.respository.UserRepository;
import com.ecommerceserver.security.services.UserDetailsImpl;
import com.ecommerceserver.services.CategoryService;
import com.ecommerceserver.services.ProductService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.domain.Sort;
import org.springframework.http.HttpStatus;
import org.springframework.http.MediaType;
import org.springframework.http.ResponseEntity;
import org.springframework.security.access.prepost.PreAuthorize;
import org.springframework.security.core.context.SecurityContextHolder;
import org.springframework.web.bind.annotation.CrossOrigin;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;
import org.springframework.web.multipart.MultipartFile;
@CrossOrigin
@RestController
@RequestMapping("/product")
public class ProductController {
@Autowired
ProductService productService;
@Autowired
CategoryService categoryService;
@Autowired
UserRepository userRepository;
@GetMapping("/{id}")
public ResponseEntity<?> getProductById(@PathVariable String id) {
Optional<Product> product = productService.findById(id);
if (product.isPresent()) {
return ResponseEntity.ok(product);
}
return ResponseEntity.noContent().build();
}
@GetMapping("/shop")
@PreAuthorize("hasRole('ROLE_SELLER')")
public List<Product> getProductOfShop() {
Object principal = SecurityContextHolder.getContext().getAuthentication().getPrincipal();
String sellerId = ((UserDetailsImpl) principal).getId();
List<Product> listProduct = productService.findAll();
listProduct.removeIf(p -> (!p.getSeller().getId().equals(sellerId)));
return listProduct;
}
@PostMapping
@PreAuthorize("hasRole('ROLE_SELLER')")
public List<Product> addProduct(@RequestBody Product product) {
Object principal = SecurityContextHolder.getContext().getAuthentication().getPrincipal();
String sellerId = ((UserDetailsImpl) principal).getId();
User seller = userRepository.findById(sellerId).get();
ReviewStar reviewStar = new ReviewStar();
product.setSeller(seller);
product.setReviewStar(reviewStar);
productService.addProduct(product);
return productService.findBySellerId(sellerId);
}
@PostMapping("/edit")
@PreAuthorize("hasRole('ROLE_SELLER')")
public List<Product> editProduct(@RequestBody Product product) {
Product temp = productService.editProduct(product);
return productService.findBySellerId(product.getSeller().getId());
}
@PostMapping("/delete/{productId}")
@PreAuthorize("hasRole('ROLE_SELLER')")
public List<Product> deleteProduct(@PathVariable String productId) {
Product temp = productService.deleteById(productId);
Object principal = SecurityContextHolder.getContext().getAuthentication().getPrincipal();
String sellerId = ((UserDetailsImpl) principal).getId();
return productService.findBySellerId(sellerId);
}
@GetMapping("/home")
public List<Product> getHomeProduct() {
List<Category> listCategory = categoryService.getList();
List<Product> listHomeProduct = new ArrayList<>();
for (Category iCategory : listCategory) {
List<Product> temp = productService.getFirst6(iCategory.getId());
for (Product iProduct : temp) {
listHomeProduct.add(iProduct);
}
}
return listHomeProduct;
}
@GetMapping("")
public List<Product> getProductByCategory(@RequestParam(defaultValue = "1") Integer page,
@RequestParam(defaultValue = "title") String sortBy,
@RequestParam(defaultValue = "ascending") String sortDirection, @RequestParam(defaultValue = "") String title,
@RequestParam(defaultValue = "") String categoryId, @RequestParam Long priceFrom, @RequestParam Long priceTo,
@RequestParam Integer reviewStar, @RequestParam(defaultValue = "") String search) {
String asc = "ascending";
Sort sort;
List<Product> temp;
page--;
// set sort
if (sortDirection.equals(asc)) {
sort = Sort.by(Sort.Direction.ASC, sortBy);
} else {
sort = Sort.by(Sort.Direction.DESC, sortBy);
}
temp = productService.getProduct(sort);
// apply filter
List<Product> list = new ArrayList<Product>();
if (title.isEmpty()) {
temp.removeIf(product -> product.getPrice() < priceFrom || product.getPrice() > priceTo
|| product.getAvarageStar() < reviewStar || !product.getCategory().getId().equals(categoryId));
} else {
temp.removeIf(product -> product.getPrice() < priceFrom || product.getPrice() > priceTo
|| product.getAvarageStar() < reviewStar
|| !Pattern.compile(Pattern.quote(title), Pattern.CASE_INSENSITIVE | Pattern.UNICODE_CASE)
.matcher(product.getTitle()).find());
}
for (int i = page * 15, n = temp.size(); i < n && list.size() < 15; i++) {
list.add(temp.get(i));
}
return list;
}
@RequestMapping(value = "/image", method = RequestMethod.POST, consumes = MediaType.MULTIPART_FORM_DATA_VALUE)
public ResponseEntity<Object> uploadImage(@RequestParam("file") MultipartFile file) throws IOException {
Date date = new Date();
String[] namePart = file.getOriginalFilename().split("\\.");
String fileName = Long.toString(date.getTime()) + "." + namePart[1];
String path = "D:\\" + fileName;
File convertFile = new File(path);
convertFile.createNewFile();
FileOutputStream fout = null;
try {
fout = new FileOutputStream(convertFile);
fout.write(file.getBytes());
} catch (FileNotFoundException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} finally {
fout.close();
}
return new ResponseEntity<>(fileName, HttpStatus.OK);
}
}
|
package com.git.cloud.resmgt.storage.dao;
import java.sql.SQLException;
import java.util.List;
import com.git.cloud.common.dao.ICommonDAO;
import com.git.cloud.resmgt.storage.model.po.SePoolLevelRulePo;
import com.git.cloud.resmgt.storage.model.vo.SePoolRuleCellVo;
public interface ISePoolLevelRuleDAO extends ICommonDAO{
public List<SePoolLevelRulePo> getPoolRuleByRuleType(String ruleType);
public void savePoolRuleValues(List<SePoolRuleCellVo> list,String ruleType) throws SQLException ;
public void savePoolRuleNasValues(List<SePoolLevelRulePo> list,String ruleType) throws SQLException ;
}
|
package com.needii.dashboard.model.form;
import com.needii.dashboard.model.OrderDetail;
import com.needii.dashboard.model.OrderDetailStatusEnum;
public class OrderDetailForm {
private String skuName;
private String skuImage;
private float unitPrice;
private float promotionPrice;
private float shippingFee;
private int quantity;
private float totalPrice;
private float cashback;
private int orderDetailStatus;
private String note;
private String cancelReasone;
private String historyLog;
private SupplierForm supplierForm;
public OrderDetailForm(){}
public OrderDetailForm(OrderDetail entity){
this.skuImage = entity.getSkuImage();
this.skuName = entity.getSkuName();
this.unitPrice = entity.getUnitPrice();
this.promotionPrice = entity.getPromotionPrice();
this.shippingFee = entity.getShippingFee();
this.quantity = entity.getQuantity();
this.totalPrice = entity.getTotalPrice();
this.cashback = entity.getCashback();
this.orderDetailStatus = entity.getOrderDetailStatus();
this.note = entity.getNote();
this.cancelReasone = entity.getCancelReason();
this.historyLog = entity.getHistoryLog();
this.supplierForm = new SupplierForm(entity.getSupplier());
}
public String getSkuName() {
return skuName;
}
public void setSkuName(String skuName) {
this.skuName = skuName;
}
public String getSkuImage() {
return skuImage;
}
public void setSkuImage(String skuImage) {
this.skuImage = skuImage;
}
public float getUnitPrice() {
return unitPrice;
}
public void setUnitPrice(float unitPrice) {
this.unitPrice = unitPrice;
}
public float getPromotionPrice() {
return promotionPrice;
}
public void setPromotionPrice(float promotionPrice) {
this.promotionPrice = promotionPrice;
}
public float getShippingFee() {
return shippingFee;
}
public void setShippingFee(float shippingFee) {
this.shippingFee = shippingFee;
}
public int getQuantity() {
return quantity;
}
public void setQuantity(int quantity) {
this.quantity = quantity;
}
public float getTotalPrice() {
return totalPrice;
}
public void setTotalPrice(float totalPrice) {
this.totalPrice = totalPrice;
}
public float getCashback() {
return cashback;
}
public void setCashback(float cashback) {
this.cashback = cashback;
}
public int getOrderDetailStatus() {
return orderDetailStatus;
}
public void setOrderDetailStatus(int orderDetailStatus) {
this.orderDetailStatus = orderDetailStatus;
}
public String getNote() {
return note;
}
public void setNote(String note) {
this.note = note;
}
public String getCancelReasone() {
return cancelReasone;
}
public void setCancelReasone(String cancelReasone) {
this.cancelReasone = cancelReasone;
}
public String getHistoryLog() {
return historyLog;
}
public void setHistoryLog(String historyLog) {
this.historyLog = historyLog;
}
public SupplierForm getSupplierForm() {
return supplierForm;
}
public void setSupplierForm(SupplierForm supplierForm) {
this.supplierForm = supplierForm;
}
public OrderDetailStatusEnum getOrderDetailStatusEnum() {
switch(orderDetailStatus) {
case 1:
return OrderDetailStatusEnum.PROCESSING;
case 2:
return OrderDetailStatusEnum.PACKAGED;
case 3:
return OrderDetailStatusEnum.DELIVERING;
case 4:
return OrderDetailStatusEnum.COMPLETED;
case 5:
return OrderDetailStatusEnum.CANCEL;
default:
return OrderDetailStatusEnum.CANCEL;
}
}
}
|
package com.exp.mapi.controller;
/**
* Create By xiayang on 2018/8/8
*/
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
@RestController
@RequestMapping("user")
public class UserController {
@RequestMapping("id")
public int getId(){
return 3;
}
}
|
package commonwealth.scenes;
import java.awt.Color;
import java.awt.Font;
import java.awt.Graphics;
import java.awt.image.BufferedImage;
import commonwealth.game.BufferedImageLoader;
import commonwealth.game.Game;
import commonwealth.game.Game.STATE;
import commonwealth.game.Map;
public class Origin {
BufferedImageLoader loader = new BufferedImageLoader();
BufferedImage origin = null;
int timer = 0;
public Origin(Game game){
try{
origin = loader.loadImage("/tex/Promotional.png");
}catch(Exception e){
e.printStackTrace();
}
}
public void tick(){
timer++;
}
public void render(Graphics g){
g.drawImage(origin, 0, 0, Game.width, Game.height, null);
if(timer < 255){
g.setColor(new Color(0, 0, 0, 255 - timer));
g.fillRect(0, 0, Game.width, Game.height);
}
g.setFont(new Font("Courier New", 0, 20));
if(timer >= 250){
if(timer < 350){
g.setColor(new Color(255, 255, 255, (timer - 250) * (5/2)));
}else{
g.setColor(Color.white);
}
g.drawString("In the year 2217, " + Map.nationName + " lost contact with Earth", 10, 20);
}
if(timer >= 400){
if(timer < 500){
g.setColor(new Color(255, 255, 255, (timer - 400) * (5 / 2)));
}else{
g.setColor(Color.white);
}
g.drawString("Each district in the colony established values and cultures", 10, 50);
}
if(timer >= 550){
if(timer < 650){
g.setColor(new Color(255, 255, 255, (timer - 550) * (5 / 2)));
}else{
g.setColor(Color.white);
}
g.drawString("And together, they created an independent nation.", 10, 80);
}
if(timer >= 700){
if(timer < 800){
g.setColor(new Color(255, 255, 255, (timer - 700) * (5 / 2)));
}else{
g.setColor(Color.white);
}
g.drawString("Now, in the year 2230, you have been elected leader", 10, 140);
}
if(timer >= 850){
if(timer < 950){
g.setColor(new Color(255, 255, 255, (timer - 850) * (5 / 2)));
}else{
g.setColor(Color.white);
}
g.drawString("to lead " + Map.nationName + " to a flourishing future...", 10, 170);
}
if(timer >= 1000){
if(timer < 1100){
g.setColor(new Color(255, 255, 255, (timer - 1000) * (5 / 2)));
}else{
g.setColor(Color.white);
}
g.drawString("...or what could be the end of the colony.", 10, 200);
}
if(timer > 1200){
g.setColor(new Color(0, 0, 0, timer - 1200));
g.fillRect(0, 0, Game.width, Game.height);
}
if(timer > 1450){
Game.gameState = STATE.game;
}
}
}
|
/**
* Created with IntelliJ IDEA.
* User: dexctor
* Date: 12-11-28
* Time: 下午1:44
* To change this template use File | Settings | File Templates.
*/
public class LinkedListSort {
public static void main(String[] args)
{
int N = StdIn.readInt();
MyLinkedList<Integer> list = new MyLinkedList<Integer>();
for(int i = 0; i < N; ++i)
list.enqueue(i);
list.print();
}
}
class MyLinkedList<Item extends Comparable<Item>>
{
private class Node
{
public Item item;
public Node next;
}
private Node first;
private Node last;
public MyLinkedList()
{
first = new Node();
first.next = null;
last = first;
}
private MyLinkedList(Node first)
{
this.first = first;
last = first;
}
private int N;
public boolean isEmpty()
{
return N == 0;
}
public int size()
{
return N;
}
public void enqueue(Item item)
{
Node oldlast = last;
last = new Node();
last.item = item;
oldlast.next = last;
N++;
}
private void enqueue(Node node)
{
Node oldlast = last;
last = node;
oldlast.next = last;
N++;
}
public Item dequeue()
{
Item item = first.next.item;
first.next = first.next.next;
N--;
if(isEmpty())
last = first;
return item;
}
public void sort()
{
while (true)
{
Node prelo = first;
Node mid = first.next;
Node hi;
while(mid != null && mid.next !=null && less(mid, mid.next))
mid = mid.next;
if(mid == null || mid.next == null)
return;
while (true)
{
hi = mid.next;
while (hi != null && hi.next != null && less(hi, hi.next))
hi = hi.next;
prelo = merge(prelo, mid, hi);
mid = prelo.next;
while(mid != null && mid.next !=null && less(mid, mid.next))
mid = mid.next;
if(mid == null || mid.next == null)
break;
}
}
}
private Node merge(Node prelo, Node mid, Node hi)
{
Node rest = hi.next;
Node newListFirst = prelo;
Node pointNew = prelo;
Node point1 = prelo.next;
Node point2 = mid.next;
while (point1 != mid.next && point2 != hi.next)
if(less(point1, point2))
{
pointNew.next = point1;
pointNew = pointNew.next;
point1 = point1.next;
}
else
{
pointNew.next = point2;
pointNew = pointNew.next;
point2 = point2.next;
}
if(point1 == mid.next)
{
pointNew.next = point2;
return hi;
}
else
{
pointNew.next = point1;
mid.next = rest;
return mid;
}
}
public boolean less(Node a, Node b)
{
return a.item.compareTo(b.item) < 0;
}
public void print()
{
Node point = first.next;
while (! (point == null) )
{
StdOut.print(point.item + " ");
point = point.next;
}
StdOut.println();
}
private void shuffle()
{
if(size() <= 1)
return;
MyLinkedList<Item> list1 = new MyLinkedList<Item>();
MyLinkedList<Item> list2 = new MyLinkedList<Item>();
Node point = first.next;
while (point != null)
{
Node tmp = point;
point = point.next;
if(StdRandom.bernoulli(0.5))
list1.enqueue(tmp);
else list2.enqueue(tmp);
}
list1.shuffle();
list2.shuffle();
list1.last.next = list2.first.next;
first = list1.first;
}
public static void main(String[] args)
{
int N = 30;
MyLinkedList<Integer> list = new MyLinkedList<Integer>();
int[] a = new int[N];
for(int i = 0; i < N; ++i)
a[i] = i;
for(int i = 0; i < N; ++i)
list.enqueue(a[i]);
list.shuffle();
list.print();
list.sort();
list.print();
}
} |
package com.chenqk.springmvc.dao;
import java.util.List;
import com.chenqk.springmvc.entity.Tree;
public interface TreeDao {
/**
* 获取当前节点id所对应的tree对象
* @param id
* @return tree 实例对象
*/
public Tree getNodeById(int id);
/**
* 获取当前节点下的所有子节点，不包括二级以后的节点
* @param pid 父节点
* @return list 子节点对象
*/
public List<Tree> getNodesById(int pid);
/**
* 添加新的节点
* @param tree 实例对象
* @return 成功失败
*/
public boolean addTreeNode(Tree tree);
/**
* 修改节点信息，一般修改显示名
* @param tree 实例对象
* @return 成功失败
*/
public boolean updateTreeNode(Tree tree);
/**
* 删除节点
* @param id 实例id
* @return 删除结果
*/
public boolean deleteTreeNode(int id);
}
|
import java.util.Calendar;
public class Czas {
public Czas() {
}
public static String getGodzina(){
Calendar now = Calendar.getInstance();
String time ="";
int h = now.get(Calendar.HOUR_OF_DAY);
int m = now.get(Calendar.MINUTE);
if(h < 10) {
time += "0" + h;
}
else {
time += h;
}
time += ":";
if(m < 10) {
time += "0" + m;
}
else {
time += m;
}
return time;
}
}
|
package com.revature.models;
import java.util.Objects;
public class BankAccount {
private int id;
private double balance;
private boolean isApproved;
private int customerId;
public BankAccount() {
super();
}
public BankAccount(int id, double balance, boolean isApproved, int customerId) {
super();
this.id = id;
this.balance = balance;
this.isApproved = isApproved;
this.customerId = customerId;
}
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public double getBalance() {
return balance;
}
public void setBalance(double balance) {
this.balance = balance;
}
public boolean isApproved() {
return isApproved;
}
public void setApproved(boolean isApproved) {
this.isApproved = isApproved;
}
public int getCustomerId() {
return customerId;
}
public void setCustomerId(int customerId) {
this.customerId = customerId;
}
@Override
public int hashCode() {
return Objects.hash(balance, customerId, id, isApproved);
}
@Override
public boolean equals(Object obj) {
if (this == obj)
return true;
if (obj == null)
return false;
if (getClass() != obj.getClass())
return false;
BankAccount other = (BankAccount) obj;
return Double.doubleToLongBits(balance) == Double.doubleToLongBits(other.balance)
&& customerId == other.customerId && id == other.id && isApproved == other.isApproved;
}
@Override
public String toString() {
return "BankAccount [id=" + id + ", balance=" + balance + ", isApproved=" + isApproved + ", customerId="
+ customerId + "]";
}
}
|
package com.example.demo.entity;
import com.fasterxml.jackson.annotation.JsonManagedReference;
import lombok.Data;
import javax.persistence.*;
import java.math.BigDecimal;
@Data
@Entity
public class Product {
@Id
@GeneratedValue
private Long id;
@ManyToOne(fetch = FetchType.EAGER)
private Category category;
private String name;
private String brand;
private BigDecimal price;
@JsonManagedReference
@OneToOne(mappedBy = "product")
private Stock stock;
}
|
package uno.iut.fr.uno.modele;
import java.io.File;
import java.io.Serializable;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
import java.util.LinkedList;
import java.util.Stack;
import uno.iut.fr.uno.modele.carte.BlackCarteEvent;
import uno.iut.fr.uno.modele.carte.Carte;
/**
* Created by Max on 04/03/2015.
*/
public class Board implements Serializable{
ArrayList<Carte>pile = Game.getGame();
Stack<Carte> pioche;
Stack<Carte> tas = new Stack<>();
LinkedList<Player>players;
private static Board ourInstance = new Board();
public static Board getInstance(){return ourInstance;}
private Board(){}
public void setPlayers(ArrayList<Player>players){this.players = new LinkedList<>(players);}
private void shuffle (){
Collections.shuffle(pile);
}
public void giveCarte(){
this.shuffle();
for(Player p : players){
for(int i=0 ; i<7 ; i++){
p.addCarte(pile.get(1));
pile.remove(1);
}
}
tas.push(pile.remove(1));
pioche = new Stack<>();
pioche.containsAll(pile);
}
public void play(){
while(true){
Player player = players.removeFirst();
player.play();
players.push(player);
}
}
public boolean pullCarte (Carte carte){
if(carte instanceof BlackCarteEvent){
tas.push(carte);
return true;
}
else if (carte.equals(tas.firstElement())){
tas.push(carte);
return true;
}
return false;
}
public void changeOrderPlayer(){
Collections.reverse(players);
}
@Override
public String toString (){
StringBuffer str = new StringBuffer();
for(Player p : players){
str.append(p.toString() + " ");
}
return str.toString();
}
public void piocherCarte (Player player){
player.addCarte(pioche.remove(pioche.indexOf(pioche.firstElement())));
}
}
|
/*
* Copyright 2017 Lantrack Corporation All Rights Reserved.
*
* The source code contained or described herein and all documents related to
* the source code ("Material") are owned by Lantrack Corporation or its suppliers
* or licensors. Title to the Material remains with Lantrack Corporation or its
* suppliers and licensors. The Material contains trade secrets and proprietary
* and confidential information of Lantrack or its suppliers and licensors. The
* Material is protected by worldwide copyright and trade secret laws and
* treaty provisions.
* No part of the Material may be used, copied, reproduced, modified, published
* , uploaded, posted, transmitted, distributed, or disclosed in any way
* without Lantrack's prior express written permission.
*
* No license under any patent, copyright, trade secret or other intellectual
* property right is granted to or conferred upon you by disclosure or delivery
* of the Materials, either expressly, by implication, inducement, estoppel or
* otherwise. Any license under such intellectual property rights must be
* express and approved by Intel in writing.
*
*/
package net.lantrack.framework.sysbase.service.imp;
import net.lantrack.framework.core.entity.BaseEntity;
import net.lantrack.framework.core.entity.PageEntity;
import net.lantrack.framework.core.lcexception.ServiceException;
import net.lantrack.framework.core.service.BaseService;
import net.lantrack.framework.core.service.PageService;
import net.lantrack.framework.sysbase.dao.DutyDao;
import net.lantrack.framework.sysbase.dao.DutyMenuDao;
import net.lantrack.framework.sysbase.entity.Duty;
import net.lantrack.framework.sysbase.entity.DutyExample;
import net.lantrack.framework.sysbase.entity.DutyMenu;
import net.lantrack.framework.sysbase.model.menu.MenuTreeModel;
import net.lantrack.framework.sysbase.service.DutyService;
import net.lantrack.framework.sysbase.service.SysMenuService;
import net.lantrack.framework.sysbase.service.SysOfficeTreeService;
import net.lantrack.framework.sysbase.util.UserUtil;
import org.apache.commons.lang3.StringUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
/**
* 职务管理service
* 2018年1月16日
* @author lin
*/
@Service
public class DutyServiceImpl extends BaseService implements DutyService{
@Autowired()
PageService pageService;
@Autowired
DutyDao dutyDao;
@Autowired
DutyMenuDao dutyMenuDao;
@Autowired
SysMenuService sysMenuService;
@Autowired
SysOfficeTreeService sysOfficeService;
@Override
public Duty update(Duty entity) throws ServiceException {
DutyExample dutyExample = new DutyExample();
DutyExample.Criteria cr = dutyExample.createCriteria();
cr.andDutyNameEqualTo(entity.getDutyName());
cr.andOfficeIdEqualTo(entity.getOfficeId());
List<Duty> list = this.dutyDao.selectByExample(dutyExample);
boolean up=false;
if(list!=null&&list.size()>0){
Duty dict = list.get(0);
// entity.setCreateBy(dict.getCreateBy());
if(dict.getId().equals(entity.getId())){
up = true;
}
}else{
up=true;
}
if(up){
try {
// //获得部门信息
// SysOffice s =sysOfficeService.queryById(entity.getOfficeId());
// entity.setOfficeName(s.getOfficeName());
this.dutyDao.updateByPrimaryKeySelective(entity);
} catch (Exception e) {
this.logger.error(e);
throw new ServiceException(e.getMessage());
}
}else{
throw new ServiceException("当前部门下已存在相同职务！");
}
return entity;
}
@Override
public Duty save(Duty entity) throws ServiceException {
DutyExample dutyExample = new DutyExample();
DutyExample.Criteria cr = dutyExample.createCriteria();
cr.andDutyNameEqualTo(entity.getDutyName());
cr.andOfficeIdEqualTo(entity.getOfficeId());
List<Duty> list = this.dutyDao.selectByExample(dutyExample);
if (list != null && list.size() > 0) {
throw new ServiceException("当前部门下已存在相同职务！");
} else {
try {
// //获得部门信息
// SysOffice s =sysOfficeService.queryById(entity.getOfficeId());
// entity.setOfficeName(s.getOfficeName());
this.dutyDao.insertSelective(entity);
} catch (Exception e) {
this.logger.error(e);
throw new ServiceException(e.getMessage());
}
}
return entity;
}
/**
* 保存带权限的职务信息
* @param entity
* @param menus
* @return entity Duty类型
* @throws ServiceException
*/
@Override
@Transactional
public Duty save(Duty entity, String menus) throws ServiceException {
entity = this.save(entity);
this.addPermission(entity.getId(), menus);
return entity;
}
/**
* 修改带权限的职务信息
* @param entity
* @param menus
* @return
* @throws ServiceException
*/
@Override
@Transactional
public Duty update(Duty entity, String menus) throws ServiceException {
entity = this.update(entity);
this.addPermission(entity.getId(), menus);
return entity;
}
@Override
public Duty queryById(Object id) {
if (id==null) {
this.logger.error("id can not be null or empty!");
throw new ServiceException("id can not be null or empty!");
}
Integer pasId = Integer.valueOf(id.toString());
Duty duty = null;
try {
duty = this.dutyDao.selectByPrimaryKey(pasId);
} catch (Exception e) {
e.printStackTrace();
this.logger.error(e);
throw new ServiceException(e.getMessage());
}
return duty;
}
@Override
public void deleteById(Object id, String upBy, boolean ifLogic) throws ServiceException {
if (id==null) {
throw new ServiceException("id can not be null or empty!");
}
Integer pasId = Integer.valueOf(id.toString());
if (!ifLogic) {
// 物理删除
this.dutyDao.deleteByPrimaryKey(pasId);
} else {
// 逻辑删除结束
Duty duty = new Duty();
duty.setCreateDate(null);
duty.setUpdateBy(upBy);
duty.setDelFlag(BaseEntity.YES);
duty.setId(pasId);
this.dutyDao.updateByPrimaryKeySelective(duty);
}
}
@Override
@Transactional
public void deleteByIds(String ids, String upBy, boolean ifLogic) throws ServiceException {
if (StringUtils.isBlank(ids)) {
this.logger.error("id can not be null or empty!");
throw new ServiceException("id can not be null or empty!");
}
String[] split = ids.split(",");
// 添加条件
DutyExample dutyExample = new DutyExample();
DutyExample.Criteria cr = dutyExample.createCriteria();
cr.andIdIn(Arrays.asList(split));
try {
if (!ifLogic) {
// 物理删除
this.dutyDao.deleteByExample(dutyExample);
} else {
// 此处用逻辑删除
Duty duty = new Duty();
duty.setCreateDate(null);
duty.setUpdateBy(upBy);
duty.setDelFlag(BaseEntity.YES);
this.dutyDao.updateByExampleSelective(duty, dutyExample);
}
//删除其下所有权限
this.dutyMenuDao.deleteByDutyId(Arrays.asList(split));
} catch (Exception e) {
this.logger.error(e);
throw new ServiceException(e.getMessage());
}
}
@Override
public void getPage(Duty entity, PageEntity pageentity) throws ServiceException{
this.pageService.getPage(pageentity.getPerPageCount(), pageentity.getCurrentPage());
try {
List<Duty> result = this.dutyDao.getDutyListPage(pageentity, entity);
pageentity.setContent(result);
} catch (Exception e) {
this.logger.error(e.getMessage());
throw new ServiceException(e.getMessage());
}
}
/* (non-Javadoc)
* @see net.lantrack.framework.core.service.CrudService#getPageRe(net.lantrack.framework.core.entity.BaseEntity, net.lantrack.framework.core.entity.PageEntity)
*/
@Override
public void getPageRe(Duty entity, PageEntity pageentity) {
}
/* (non-Javadoc)
* @see net.lantrack.framework.core.service.CrudService#deleteByIdsRe(java.lang.String, java.lang.String)
*/
@Override
public void deleteByIdsRe(String ids, String update_by) throws ServiceException {
}
/* (non-Javadoc)
* @see net.lantrack.framework.core.service.CrudService#getAll(net.lantrack.framework.core.entity.BaseEntity)
*/
@Override
public List<Duty> getAll(Duty entity) {
return null;
}
/**
* 根据部门id获取其下职务
*/
@Override
public List<Duty> getDutyByOfficeId(String id) {
if(StringUtils.isBlank(id)){
this.logger.error("id can not be null or empty!");
throw new ServiceException("id can not be null or empty!");
}
DutyExample dutyExample = new DutyExample();
DutyExample.Criteria cr = dutyExample.createCriteria();
cr.andOfficeIdEqualTo(id);
try {
List<Duty> list = this.dutyDao.selectByExample(dutyExample);
return list;
} catch (Exception e) {
this.logger.error(e);
throw new ServiceException(e.getMessage());
}
}
/**
* 配置权限
*/
@Override
public void addPermission(Integer id, String menus) throws ServiceException{
if(id==null||StringUtils.isBlank(menus)){
throw new ServiceException("参数异常");
}
String[] split = menus.split(",");
List<DutyMenu> dmList = new ArrayList<DutyMenu>(split.length);
for(String menu:split){
DutyMenu dm = new DutyMenu(id, Integer.valueOf(menu));
dmList.add(dm);
}
List<String> duList = new ArrayList<String>(1);
duList.add(id.toString());
this.dutyMenuDao.deleteByDutyId(duList);
//单条插入
// for(DutyMenu dm:dmList){
// try {
// this.dutyMenuDao.insert(dm);
// } catch (Exception e) {
// continue;
// }
// }
//批量插入
try {
this.dutyMenuDao.insertList(dmList);
} catch (Exception e) {
this.logger.error(e);
throw new ServiceException(e.getMessage());
}
}
@Override
public Map<String, Object> getMenuTreeByDutyId(Integer id) throws ServiceException{
Map<String, Object> map = new HashMap<String, Object>();
List<MenuTreeModel> currentMenuList = new ArrayList<MenuTreeModel>();
List<MenuTreeModel> menuList = new ArrayList<MenuTreeModel>();
List<Integer> checkedMenus = new ArrayList<Integer>();
// 先获取当前登录用户所有的权限列表
String currentUserId = UserUtil.getCurrentUser();
if (StringUtils.isNotBlank(currentUserId)) {
if (UserUtil.ifAdmin()) {
currentMenuList = sysMenuService.getAllMenuTree();
} else {
currentMenuList = this.dutyMenuDao.getMenuByDutyId(id);
}
map.put("menusAll", currentMenuList.size()>0 ? currentMenuList : "");
}
// 再获取操作的角色目前已有的权限列表
menuList = this.dutyMenuDao.getMenuByDutyId(id);
if (menuList != null && menuList.size() > 0) {
for (MenuTreeModel menu : menuList) {
checkedMenus.add(menu.getId());
}
}
map.put("checkedMenus", checkedMenus);
return map;
}
@Override
public Map<Integer, String> getMapByOfficeId(String officeId) {
Map<Integer, String> map = new HashMap<Integer, String>();
DutyExample example = new DutyExample();
DutyExample.Criteria cr = example.createCriteria();
cr.andDelFlagEqualTo("0");
if (StringUtils.isNotBlank(officeId)) {
cr.andOfficeIdEqualTo(officeId);
}
List<Duty> list = this.dutyDao.selectByExample(example);
if (list != null && list.size() > 0) {
for (int i=0; i < list.size(); i++) {
Duty duty = list.get(i);
map.put(duty.getId(), duty.getDutyName());
}
return map;
} else {
this.logger.warn("DutyServiceImp getMapByOfficeId(officeId) return empty");
return null;
}
}
}
|
package com.cs.player;
import javax.xml.bind.annotation.XmlEnum;
import javax.xml.bind.annotation.XmlRootElement;
/**
* @author Hadi Movaghar
*/
@XmlRootElement
@XmlEnum
public enum TrustLevel {
BLACK, RED, YELLOW, BLUE, GREEN
}
|
package Functions;
import java.util.Scanner;
public class AreaPeriRect {
public static int area(int a, int b) {
int ans;
ans = a * b;
return ans;
}
public static int peri(int a, int b) {
int ans;
ans = 2 * (a + b);
return ans;
}
public static void main(String args[]) {
Scanner sc = new Scanner(System.in);
int z;
System.out.println("Enter the length and breadth.");
int l = sc.nextInt();
int b = sc.nextInt();
System.out.println("What function would you like to use?");
System.out.println("1. Area \n2. Perimeter");
int ch = sc.nextInt();
if (ch == 1)
z = area(l, b);
else
z = peri(l, b);
System.out.println(z);
}
}
|
/*
* Copyright (c) 2014, Vuzix Corporation
All rights reserved.
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions
are met:
* Redistributions of source code must retain the above copyright
notice, this list of conditions and the following disclaimer.
* Redistributions in binary form must reproduce the above copyright
notice, this list of conditions and the following disclaimer in the
documentation and/or other materials provided with the distribution.
* Neither the name of Vuzix Corporation nor the names of
its contributors may be used to endorse or promote products derived
from this software without specific prior written permission.
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
package com.wearablehack;
import android.app.Activity;
import android.content.Context;
import android.hardware.Sensor;
import android.hardware.SensorEvent;
import android.hardware.SensorEventListener;
import android.hardware.SensorManager;
import android.os.Bundle;
import android.util.Log;
import android.widget.TextView;
import java.text.DecimalFormat;
import java.util.List;
//information on motion sensors: http://developer.android.com/guide/topics/sensors/sensors_motion.html
public class SensorActivity extends Activity implements SensorEventListener
{
SensorManager mSensorManager;
String sensorList;
// sensors available
Sensor lightSensor, proximitySensor, rotationVectorSensor, gravitySensor,
accelerationSensor, orientationSensor, gyroscopeSensor;
// textviews for activity
TextView rotateX, gyroX, accelX, orientX, gravX,
rotateY, gyroY, accelY, orientY, gravY,
rotateZ, gyroZ, accelZ, orientZ, gravZ;
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_sensor);
sensorList = "";
mSensorManager = (SensorManager) getSystemService(Context.SENSOR_SERVICE);
// get list of sensors available
List<Sensor> deviceSensors = mSensorManager.getSensorList(Sensor.TYPE_ALL);
for(Sensor s : deviceSensors){
if(!s.getName().contains("MPL")){
sensorList+=" " + s.getName() + ",";
}
}
//print created string
Log.w("M100Dev","all sensors: " + sensorList);
// There are warnings, but since we are on a lower android version they are unavoidable.
rotationVectorSensor = mSensorManager.getDefaultSensor(Sensor.TYPE_ROTATION_VECTOR);
gravitySensor = mSensorManager.getDefaultSensor(Sensor.TYPE_GRAVITY);
accelerationSensor = mSensorManager.getDefaultSensor(Sensor.TYPE_LINEAR_ACCELERATION);
orientationSensor = mSensorManager.getDefaultSensor(Sensor.TYPE_ORIENTATION);
gyroscopeSensor = mSensorManager.getDefaultSensor(Sensor.TYPE_GYROSCOPE);
// this is alot of text :D
rotateX=(TextView)findViewById(R.id.rotate_x);rotateY=(TextView)findViewById(R.id.rotate_y);rotateZ=(TextView)findViewById(R.id.rotate_z);
gravX=(TextView)findViewById(R.id.grav_x);gravY=(TextView)findViewById(R.id.grav_y);gravZ=(TextView)findViewById(R.id.grav_z);
accelX=(TextView)findViewById(R.id.accel_x);accelY=(TextView)findViewById(R.id.accel_y);accelZ=(TextView)findViewById(R.id.accel_z);
orientX=(TextView)findViewById(R.id.orient_x);orientY=(TextView)findViewById(R.id.orient_y);orientZ=(TextView)findViewById(R.id.orient_z);
gyroX=(TextView)findViewById(R.id.gyro_x);gyroY=(TextView)findViewById(R.id.gyro_y);gyroZ=(TextView)findViewById(R.id.gyro_z);
}
@Override
protected void onResume() {
// Register listeners for the sensor.
super.onResume();
mSensorManager.registerListener(this, gyroscopeSensor, SensorManager.SENSOR_DELAY_NORMAL);
mSensorManager.registerListener(this, rotationVectorSensor, SensorManager.SENSOR_DELAY_NORMAL);
mSensorManager.registerListener(this, gravitySensor, SensorManager.SENSOR_DELAY_NORMAL);
mSensorManager.registerListener(this, accelerationSensor, SensorManager.SENSOR_DELAY_NORMAL);
mSensorManager.registerListener(this, orientationSensor, SensorManager.SENSOR_DELAY_NORMAL);
}
@Override
protected void onPause() {
// Be sure to unregister the sensors when the activity pauses so we don't kill several things
super.onPause();
mSensorManager.unregisterListener(this);
}
@Override
public void onAccuracyChanged(Sensor sensor, int accuracy) {
Log.w("M100Dev","ACCURACY CHANGED: " +sensor.getName());
}
// catch sensors' information
@Override
public void onSensorChanged(SensorEvent event) {
Sensor sensor = event.sensor;
// string format for readability
DecimalFormat df = new DecimalFormat("##.##");
// store values
String x = "X: " + df.format(event.values[0]);
String y = "Y: " + df.format(event.values[1]);
String z = "Z: " + df.format(event.values[2]);
// print info
switch(sensor.getType()){
case Sensor.TYPE_ROTATION_VECTOR:
rotateX.setText(x);
rotateY.setText(y);
rotateZ.setText(z);
break;
case Sensor.TYPE_GRAVITY:
gravX.setText(x);
gravY.setText(y);
gravZ.setText(z);
break;
case Sensor.TYPE_LINEAR_ACCELERATION:
accelX.setText(x);
accelY.setText(y);
accelZ.setText(z);
break;
case Sensor.TYPE_ORIENTATION:
orientX.setText(x);
orientY.setText(y);
orientZ.setText(z);
break;
case Sensor.TYPE_GYROSCOPE:
gyroX.setText(x);
gyroY.setText(y);
gyroZ.setText(z);
break;
default:
Log.w("M100Dev","something interesting is happening with: "+sensor.getName());
break;
}
}
}
|
/*
* Copyright 2016 Shakuganns.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package me.imirai.library;
import android.content.Context;
import android.content.Intent;
import android.content.res.TypedArray;
import android.graphics.Color;
import android.graphics.Typeface;
import android.net.Uri;
import android.text.SpannableString;
import android.text.Spanned;
import android.text.TextPaint;
import android.text.TextUtils;
import android.text.method.LinkMovementMethod;
import android.text.style.ClickableSpan;
import android.text.style.RelativeSizeSpan;
import android.util.AttributeSet;
import android.util.Log;
import android.view.View;
import android.widget.TextView;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
/**
* Created by Shakugan on 2016/11/17.
*/
public class KeywordTextView extends TextView {
private String keywords;
private int keywordsColor;
private int urlColor;
private int numColor;
private boolean keywordsUnderline;
private boolean urlUnderline;
private boolean numUnderline;
private boolean urlHighlight;
private boolean numHighlight;
private float keywordsRelativeSize;
private float urlRelativeSize;
private float numRelativeSize;
private SpannableString spannableString;
private static String URL_REGEX = "(((http|ftp|https)://)|(www\\.))[a-zA-Z0-9\\._-]+\\.[a-zA-Z]{2,6}(:[0-9]{1,4})?(/[a-zA-Z0-9\\&%_\\./-~-]*)?";
private Pattern urlPattern = Pattern.compile(URL_REGEX);
private static String NUM_REGEX = "\\d{6,18}";
private Pattern numPattern = Pattern.compile(NUM_REGEX);
private OnKeywordClickListener listener;
private OnUrlClickListener onUrlClickListener;
public KeywordTextView(Context context) {
this(context,null);
}
public KeywordTextView(Context context, AttributeSet attrs) {
this(context,attrs,0);
}
public KeywordTextView(
Context context, AttributeSet attrs, int defStyleAttr) {
super(context, attrs, defStyleAttr);
init(context,attrs,defStyleAttr);
}
private void init(Context context,AttributeSet attrs, int defStyleAttr) {
TypedArray typedArray = context.obtainStyledAttributes(attrs,R.styleable.KeywordTextView,defStyleAttr,0);
keywords = typedArray.getString(R.styleable.KeywordTextView_keyword);
keywordsColor = typedArray.getColor(R.styleable.KeywordTextView_keyword_color,Color.BLUE);
urlColor = typedArray.getColor(R.styleable.KeywordTextView_url_color,Color.BLUE);
numColor = typedArray.getColor(R.styleable.KeywordTextView_num_color,Color.BLUE);
keywordsUnderline = typedArray.getBoolean(R.styleable.KeywordTextView_keywords_underline,true);
urlUnderline = typedArray.getBoolean(R.styleable.KeywordTextView_url_underline,true);
numUnderline = typedArray.getBoolean(R.styleable.KeywordTextView_num_underline,true);
urlHighlight = typedArray.getBoolean(R.styleable.KeywordTextView_url_highlight,false);
numHighlight = typedArray.getBoolean(R.styleable.KeywordTextView_num_highlight,false);
keywordsRelativeSize = typedArray.getFloat(R.styleable.KeywordTextView_keywords_relativeSize,1.0f);
urlRelativeSize = typedArray.getFloat(R.styleable.KeywordTextView_url_relativeSize,1.0f);
numRelativeSize = typedArray.getFloat(R.styleable.KeywordTextView_num_relativeSize,1.0f);
typedArray.recycle();
setTextWithKeyword(getText(),keywords);
setMovementMethod(LinkMovementMethod.getInstance());
}
private void findNum() {
String flagString = spannableString.toString();
Matcher matcher = numPattern.matcher(spannableString);
boolean find = matcher.find();
while (find) {
String s = "";
for (int i = 0 ; i < matcher.group().length() ; i++) {
s = s+"^";
}
flagString = flagString.replaceFirst(matcher.group(),s);
Log.i("flagString",flagString);
String text = spannableString.toString();
spannableString.setSpan(new RelativeSizeSpan(numRelativeSize), flagString.indexOf(s),
flagString.indexOf(s) + s.length(), Spanned.SPAN_EXCLUSIVE_EXCLUSIVE);
spannableString.setSpan(new ClickableSpan() {
@Override
public void onClick(View widget) {
}
@Override
public void updateDrawState(TextPaint ds) {
super.updateDrawState(ds);
ds.setColor(numColor);
ds.setUnderlineText(numUnderline);
}
}, text.indexOf(matcher.group()), text.indexOf(matcher.group()) + matcher.group().length(), Spanned.SPAN_EXCLUSIVE_EXCLUSIVE);
matcher = numPattern.matcher(flagString);
find = matcher.find();
}
}
/**
* 在文本中找出url并且高亮显示
*/
private void findUrl() {
String flagString = spannableString.toString();
Matcher matcher = urlPattern.matcher(spannableString);
boolean find = matcher.find();
while (find) {
String s = "";
final String url = matcher.group();
for (int i = 0 ; i < matcher.group().length() ; i++) {
s = s+"^";
}
flagString = flagString.replaceFirst(matcher.group(),s);
String text = spannableString.toString();
spannableString.setSpan(new RelativeSizeSpan(urlRelativeSize), flagString.indexOf(s),
flagString.indexOf(s) + s.length(), Spanned.SPAN_EXCLUSIVE_EXCLUSIVE);
spannableString.setSpan(new ClickableSpan() {
@Override
public void onClick(View widget) {
if (onUrlClickListener != null) {
onUrlClickListener.onClick(widget, url);
} else {
Intent intent = new Intent();
intent.setAction("android.intent.action.VIEW");
Uri uri = Uri.parse(url);
intent.setData(uri);
widget.getContext().startActivity(intent);
}
}
@Override
public void updateDrawState(TextPaint ds) {
super.updateDrawState(ds);
ds.setColor(urlColor);
ds.setUnderlineText(urlUnderline);
}
}, text.indexOf(matcher.group()), text.indexOf(matcher.group()) + matcher.group().length(), Spanned.SPAN_EXCLUSIVE_EXCLUSIVE);
matcher = urlPattern.matcher(flagString);
find = matcher.find();
}
}
/**
*
* @param text 显示的文本
* @param keyword 需要添加超链接的关键字;多个关键字用,隔开 如："fuck,shit,……"
*/
public void setTextWithKeyword(CharSequence text, final CharSequence keyword) {
if (text == null) {
return;
} else {
spannableString = new SpannableString(text);
}
if (!TextUtils.isEmpty(keyword)) {
String[] values = keyword.toString().split(",");
String flagString = text.toString();
for (final String s:values) {
String flag = "";
for (int i = 0 ; i < s.length() ; i++) {
flag = flag+"^";
}
while(flagString.contains(s)) {
spannableString.setSpan(new RelativeSizeSpan(keywordsRelativeSize), flagString.indexOf(s),
flagString.indexOf(s) + s.length(), Spanned.SPAN_EXCLUSIVE_EXCLUSIVE);
spannableString.setSpan(new ClickableSpan() {
@Override
public void onClick(View widget) {
if (listener != null) {
listener.onClick(widget , s);
}
}
@Override
public void updateDrawState(TextPaint ds) {
super.updateDrawState(ds);
ds.setColor(keywordsColor);
ds.setUnderlineText(keywordsUnderline);
}
}, flagString.indexOf(s), flagString.indexOf(s) + s.length(), Spanned.SPAN_EXCLUSIVE_EXCLUSIVE);
flagString = flagString.replaceFirst(s,flag);
}
}
}
if (urlHighlight) {
findUrl();
}
if (numHighlight) {
findNum();
}
setText(spannableString);
}
public SpannableString getSpannableText() {
return spannableString;
}
public int getKeywordsColor() {
return keywordsColor;
}
public int getNumColor() {
return numColor;
}
public int getUrlColor() {
return urlColor;
}
public String getKeywords() {
return keywords;
}
public float getKeywordsRelativeSize() {
return keywordsRelativeSize;
}
public float getNumRelativeSize() {
return numRelativeSize;
}
public float getUrlRelativeSize() {
return urlRelativeSize;
}
public void setOnKeywordClickListener(OnKeywordClickListener listener) {
this.listener = listener;
}
public void setOnUrlClickListener(OnUrlClickListener onUrlClickListener) {
this.onUrlClickListener = onUrlClickListener;
}
public interface OnKeywordClickListener {
void onClick(View view,String keyword);
}
public interface OnUrlClickListener {
void onClick(View view,String url);
}
}
|
/*
* To change this license header, choose License Headers in Project Properties.
* To change this template file, choose Tools | Templates
* and open the template in the editor.
*/
package javaPackage;
import datos.PersonaJDBC;
import java.io.IOException;
import java.io.PrintWriter;
import javax.servlet.ServletException;
import javax.servlet.annotation.WebServlet;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
/**
*
* @author USUARIO
*/
@WebServlet(urlPatterns = {"/rifaData"})
public class rifaData extends HttpServlet {
/**
* Processes requests for both HTTP <code>GET</code> and <code>POST</code>
* methods.
*
* @param request servlet request
* @param response servlet response
* @throws ServletException if a servlet-specific error occurs
* @throws IOException if an I/O error occurs
*/
protected void processRequest(HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException {
response.setContentType("text/html;charset=UTF-8");
try (PrintWriter out = response.getWriter()) {
/* TODO output your page here. You may use following sample code. */
datos.PersonaJDBC datos = new PersonaJDBC();
String numeros="",numerosSele="";
try {
numeros = datos.select();
numerosSele=datos.select2();
} catch (Exception e) {
}
out.println("<!DOCTYPE html>");
out.println("<html>");
out.println(" <head>");
out.println(" <title>Rifa virtual</title>");
out.println(" <meta charset=\"UTF-8\">");
out.println(" <meta name=\"viewport\" content=\"width=device-width, initial-scale=1.0\">");
out.println(" <link href=\"codeCSS.css\" type=\"text/css\" rel=\"stylesheet\"/>");
out.println(" <link rel=\"icon\" type=\"image/png\" href=\"\" />");
out.println(" </head>");
out.println(" <body>");
out.println(" <div id=\"encabezado\">");
out.println(" <h2>Rifa virtual</h2> ");
out.println(" <input type=\"text\" id=\"numerosS\" style=\"display:none\" value="+numeros+">");
out.println(" <input type=\"text\" id=\"numerosSe\" style=\"display:none\" value="+numerosSele+">");
out.println(" </div>");
out.println(" <div id=\"reg\">");
out.println(" <form id=\"formulario\" name=\"formularioUsuario\" method=\"post\" ");
out.println(" action=\"/Rifa/rifaData\" ");
out.println(" onsubmit=\"return confirmar()\">");
out.println(" <h2>Datos Usuario</h2>");
out.println(" <input type=\"text\" name=\"txtNombre\" id=\"txtNombre\" placeholder=\"Nombre\" required/>");
out.println(" <br>");
out.println(" <input type=\"number\" name=\"txtCedula\" id=\"txtCedula\" placeholder=\"Cédula\" required/>");
out.println(" <br>");
out.println(" <input type=\"number\" name=\"txtTelefono\" id=\"txtTelefono\" placeholder=\"Telefono\" required/>");
out.println(" <input type=\"text\" name=\"txtNumeros\" id=\"nums\" style=\"display:none\"/>");
out.println(" <br>");
out.println(" <input type=\"submit\" name=\"btnEnviar\" value=\"Quiero ir a Cancun\"/>");
out.println(" </form>");
out.println(" </div>");
out.println(" <div id=\"conten\"><h2>Números</h2></div> ");
out.println(" <script src=\"codeJavaScript.js\"></script>");
out.println(" </body>");
out.println("</html>");
}
}
// <editor-fold defaultstate="collapsed" desc="HttpServlet methods. Click on the + sign on the left to edit the code.">
/**
* Handles the HTTP <code>GET</code> method.
*
* @param request servlet request
* @param response servlet response
* @throws ServletException if a servlet-specific error occurs
* @throws IOException if an I/O error occurs
*/
@Override
protected void doGet(HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException
{
processRequest(request, response);
}
/**
* Handles the HTTP <code>POST</code> method.
*
* @param request servlet request
* @param response servlet response
* @throws ServletException if a servlet-specific error occurs
* @throws IOException if an I/O error occurs
*/
@Override
protected void doPost(HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException
{
response.setContentType("text/html;charset=UTF-8");
try (PrintWriter out = response.getWriter()) {
String cedula = request.getParameter("txtCedula");
String numero = request.getParameter("txtNumeros");
String nombre = request.getParameter("txtNombre");
String telefono = request.getParameter("txtTelefono");
String [] nums = numero.split(",");
java.sql.Connection userConn=null;
try {
userConn = new datos.Conexion().getConnection();
if (userConn.getAutoCommit())
{
userConn.setAutoCommit(false);
}
datos.PersonaJDBC datos = new PersonaJDBC(userConn);
for (int i = 0; i < nums.length; i++)
{
try {
datos.update(nums[i], nombre, cedula, telefono);
} catch (Exception e) {
}
}
userConn.commit();
} catch (Exception e)
{
try {
userConn.rollback();
} catch (Exception r) {}
}
processRequest(request, response);
}
}
/**
* Returns a short description of the servlet.
*
* @return a String containing servlet description
*/
@Override
public String getServletInfo() {
return "Short description";
}// </editor-fold>
}
|
package objetos.aeronaves.enemigos;
import movimiento.Posicion;
import movimiento.patrones.Circular;
import objetos.Energia;
import objetos.aeronaves.Enemigo;
import objetos.armas.CuartoArmas;
import org.jdom.*;
import vistas.FactoryVistas;
import ar.uba.fi.algo3.titiritero.ControladorJuego;
import ar.uba.fi.algo3.titiritero.vista.Imagen;
import auxiliares.Vector;
/*
* Clase que modela al explorador enemigo
*/
public class Scout extends Enemigo {
public Scout() {
super();
this.setTamanio(24);
this.setEnergia(new Energia(15));
this.setVelocidad(new Vector(0, 2));
this.setPatron(new Circular(15));
this.setPuntajeOtorgado(50);
this.setVelocidadHuida(new Vector(0, -2));
}
public Scout(Posicion posicion) {
this();
this.setPosicion(posicion);
}
public Scout(int x, int y) {
this(new Posicion(x, y));
}
@Override
public Imagen darVista(ControladorJuego controlador) {
return FactoryVistas.crearVista(this, controlador);
}
/* Persistencia */
/* Constructor a partir de nodoXML */
public Scout(Element nodo) {
this(Integer.parseInt(nodo.getAttributeValue("posicionX")), Integer
.parseInt(nodo.getAttributeValue("posicionY")));
this.setArsenal(new CuartoArmas(nodo.getChild("cuartoArmas")));
this.getArsenal().setBase(this);
}
/* NodoXML a partir de instancia */
@Override
public Element obtenerNodo() {
Element nodo = new Element("scout");
nodo.setAttribute(new Attribute("posicionX", Integer.toString(this
.getPosicion().getEnX())));
nodo.setAttribute(new Attribute("posicionY", Integer.toString(this
.getPosicion().getEnY())));
nodo.addContent(this.getArsenal().obtenerNodo());
return nodo;
}
}
|
package second;
import java.time.LocalDate;
import java.time.LocalTime;
public class TimeExample {
public static void main(String[] args) {
// TODO Auto-generated method stub
String time="16:30:00";
LocalDate dateofbirth=LocalDate.parse("2020-02-02");
LocalTime cabpickuptime=LocalTime.parse(time);
System.out.println(cabpickuptime);
LocalDate currentdate=LocalDate.now();
if(dateofbirth.isBefore(currentdate)) {
System.out.println("isBefore");
}
else
{
System.out.println("isAfter");
}
int hour=cabpickuptime.getHour();
System.out.println("Hour"+ hour);
if (hour>=16&& hour<18)
{
System.out.println("peakhour");
}
else
{
System.out.println("not a peakhour");
}
String cabType="micro";
if(cabType.equals("micro"))
{
System.out.println("happy journey");
}
else
{
System.out.println("safe journey");
}
if(dateofbirth.isEqual(LocalDate.now()));
{
System.out.println("Given date is today date");
}
long mobileNo=1234567890;
String mobileNoString=String.valueOf(mobileNo);
if(mobileNoString.length()==10)
{
System.out.println("mobileno: "+ mobileNo);
}
}
}
|
package com.myneu.project.Controller;
import javax.servlet.http.HttpServletRequest;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.mail.SimpleMailMessage;
import org.springframework.mail.javamail.JavaMailSender;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import com.myneu.project.Dao.EmailDao;
import com.myneu.project.pojo.Contactus;
@Controller
@RequestMapping("/feedback.htm")
public class EmailController {
@Autowired
private JavaMailSender mailSender;
@RequestMapping(method = RequestMethod.POST)
public String doSendEmail(HttpServletRequest request) {
// takes input from e-mail form
String name = request.getParameter("name");
String email1 = request.getParameter("email");
String mess = request.getParameter("message");
/* String recipientAddress = request.getParameter("recipient");
String subject = request.getParameter("subject");*/
/* String message = request.getParameter("message");*/
EmailDao emailDao = new EmailDao();
Contactus contactus =new Contactus();
contactus.setEmail(email1);
contactus.setMessage(mess);
contactus.setName(name);
emailDao.contactUs(contactus);
// prints debug info
System.out.println("To: " + email1);
System.out.println("Subject: " + "Ordered Items");
System.out.println("Message: " + "Thank you for Shopping!!! Please Visit Again");
// creates a simple e-mail object
SimpleMailMessage email = new SimpleMailMessage();
email.setTo(email1);
email.setSubject("Order placed Successfully");
email.setText("Thank you for Shopping!!!");
// sends the e-mail
mailSender.send(email);
// forwards to the view named "Result"
return "ThanksForFeedback";
}
} |
package com.bcil.testtablayoutviewpager;
import androidx.appcompat.app.AppCompatActivity;
import androidx.viewpager.widget.ViewPager;
import android.os.Bundle;
import com.google.android.material.tabs.TabLayout;
import com.google.android.material.tabs.TabLayout.TabLayoutOnPageChangeListener;
public class MainActivity extends AppCompatActivity {
TabLayout myTabLayout;
ViewPager myViewPager;
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
// Obtain reference to TabLayout and ViewPager
myTabLayout = (TabLayout) findViewById(R.id.myTabLayout);
myViewPager = (ViewPager) findViewById(R.id.myViewPager);
// Create the tabs
// These 2 lines makes long tab lists (not recommended from UX) scrollable automatically
myTabLayout.setTabGravity(TabLayout.GRAVITY_CENTER);
myTabLayout.setTabMode(TabLayout.MODE_SCROLLABLE);
// Add the tabs
myTabLayout.addTab(myTabLayout.newTab().setText("Home"));
myTabLayout.addTab(myTabLayout.newTab().setText("Sport"));
myTabLayout.addTab(myTabLayout.newTab().setText("Movie"));
myTabLayout.addTab(myTabLayout.newTab().setText("Long Tab 4"));
myTabLayout.addTab(myTabLayout.newTab().setText("Tab 5"));
myTabLayout.addTab(myTabLayout.newTab().setText("Tab 6"));
myTabLayout.addTab(myTabLayout.newTab().setText("Tab 7"));
// Setup ViewPager adapter
final MyAdapter myAdapter = new MyAdapter(this, getSupportFragmentManager(), myTabLayout.getTabCount());
myViewPager.setAdapter(myAdapter);
// Setup PageChange listener so as to call TabLayout's to keep tab highlights in sync
myViewPager.addOnPageChangeListener(new TabLayoutOnPageChangeListener(myTabLayout));
myTabLayout.addOnTabSelectedListener(new TabLayout.OnTabSelectedListener() {
@Override
public void onTabSelected(TabLayout.Tab tab) {
myViewPager.setCurrentItem(tab.getPosition());
}
@Override
public void onTabUnselected(TabLayout.Tab tab) {
}
@Override
public void onTabReselected(TabLayout.Tab tab) {
}
});
}
}
|
package com.master;
import org.mybatis.spring.annotation.MapperScan;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.annotation.ComponentScan;
@ComponentScan("com.master")
@MapperScan("com.master.dao")
@SpringBootApplication
public class StartApplication {
public static void main(String[] args) {
SpringApplication.run(StartApplication.class, args);
}
}
|
import java.io.BufferedReader;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationTargetException;
import java.util.ArrayList;
import java.io.PrintStream;
public class Simulator {
/**
* it works for multiple houses
*/
private ArrayList<House> houseList;
PrintStream printer = new PrintStream("Register.txt");
/**
* everything is done in the constructor
* the main method only has to create a new simulator object and it will work by itself
*/
public Simulator() throws FileNotFoundException {
int housenumber = 0;
houseList = new ArrayList<House>();
House myhouse = new House();
String currentLine;
BufferedReader reader = null;
int numberline = 0;
/**
* create a new BufferedReader that will read the source file
* */
try {
reader = new BufferedReader(new FileReader("myHouse.txt"));
} catch (FileNotFoundException e) {
e.printStackTrace();
}
/**
* this is the interpreter
* based on some patterns in the source file it creates new objects with different values in the constructor
* */
try {
while ((currentLine = reader.readLine()) != null) {
numberline++;
if (!currentLine.equals("House:")) {
try {
if (currentLine.split(":")[0].endsWith("Meter")) {
this.retreiveMeter(myhouse, currentLine);
} else if (currentLine.split(":")[0].equals("Person")) {
this.retreivePerson(currentLine.split(":")[1], myhouse);
} else if (myhouse.getHousePersons().isEmpty()) {
this.retreiveAppliace(currentLine, myhouse);
} else
this.retreiveTask(myhouse.getLastPerson(), currentLine, myhouse);
} catch (Exception e) {
System.err.println("Data not recognised. Please check line " + numberline + " of the input file");
// Error is thrown if the input does not correspond to any pattern
}
} else if (currentLine.equals("House:")) {
myhouse = new House();
houseList.add(myhouse);
}
}
} catch (Exception e) {
System.err.println("myHouse.txt not found !");
//Error is thrown if there is no myHouse.txt file
}
/**
* iterates over the list of houses
* does the simulation for every house
* */
for (House house : houseList) {
housenumber++;
System.out.println("House number " + housenumber);
printer.println("House number " + housenumber);
house.go();
}
}
private void retreiveMeter(House myhouse, String currentLine) {
int consumed = 0;
boolean canGenerate = false;
Meter meter = null; // create a new instance of the appliance
Class cl = null;
try {
cl = Class.forName(currentLine.split(":")[0]);
} catch (ClassNotFoundException e) {
e.printStackTrace();
}
/**
* this means we do not have to enter another switch method just to know what kind of appliance to create
* */
Constructor constructor = null; // create a new constructor based on the newly created appliance
try {
constructor = cl.getConstructor(int.class, boolean.class);
} catch (NoSuchMethodException e) {
e.printStackTrace();
}
if (currentLine.split(":").length > 1) {
if (currentLine.split(":")[1].contains(",")) {
consumed = Integer.parseInt(currentLine.split(":")[1].split(",")[0]);
if (currentLine.split(":")[1].split(",")[1].equals("true"))
canGenerate = true;
} else if (currentLine.split(":")[1].equals("true") || currentLine.split(":")[1].equals("false")) {
canGenerate = Boolean.valueOf(currentLine.split(":")[1]);
} else consumed = Integer.parseInt(currentLine.split(":")[1]);
}
try {
meter = (Meter) constructor.newInstance(consumed, canGenerate);
} catch (InstantiationException e) {
e.printStackTrace();
} catch (IllegalAccessException e) {
e.printStackTrace();
} catch (InvocationTargetException e) {
e.printStackTrace();
}
myhouse.addMeter(meter); // add meter to the house
}
/**
* Simple method wich creates a new person object
* If the age parameter is under 18, the object will be Child
* Otherwise it creates a GrownUp
*/
private void retreivePerson(String personDetails, House myhouse) {
Person newPerson;
int x = Integer.parseInt(personDetails.split(",")[1]);
if (x > 17) {
newPerson = new GrownUp(personDetails.split(",")[0], x, personDetails.split(",")[2]);
} else newPerson = new Child(personDetails.split(",")[0], x, personDetails.split(",")[2]);
myhouse.addPerson(newPerson);
}
/**
* This method uses reflection in order to create the right type of appliance
*/
private void retreiveAppliace(String currentLine, House myhouse) {
int electricityUse = 0;
int gasUse = 0;
int waterUse = 0;
Appliance appliance = null;
Class cl = null;
try {
cl = Class.forName(currentLine.split(":")[0]);
} catch (ClassNotFoundException e) {
e.printStackTrace();
} // cl will represent the class with the name which has been read
Constructor constructor = null; // create a new constructor for the newly created appliance
try {
constructor = cl.getConstructor(int.class, int.class, int.class, int.class, House.class);
} catch (NoSuchMethodException e) {
e.printStackTrace();
}
/**
* Check if there are any details given about the appliance
* if there are, they will be used in the constructor
* else it will have some default values as constructor arguments
* every Appliance has it's own default values
* */
if (currentLine.split(":").length > 1) {
if (currentLine.split(":")[1].contains(",")) {
if (currentLine.split(":")[1].split(",").length > 2) {
electricityUse = Integer.parseInt(currentLine.split(":")[1].split(",")[0]);
gasUse = Integer.parseInt(currentLine.split(":")[1].split(",")[1]);
waterUse = Integer.parseInt(currentLine.split(":")[1].split(",")[2]);
} else {
electricityUse = Integer.parseInt(currentLine.split(":")[1].split(",")[0]);
gasUse = Integer.parseInt(currentLine.split(":")[1].split(",")[1]);
}
} else electricityUse = Integer.parseInt(currentLine.split(":")[1]);
}
/**
* Creating the new appliance
* */
try {
appliance = (Appliance) constructor.newInstance(electricityUse, gasUse, waterUse, 0, myhouse);
} catch (InstantiationException e) {
e.printStackTrace();
} catch (IllegalAccessException e) {
e.printStackTrace();
} catch (InvocationTargetException e) {
e.printStackTrace();
}
myhouse.addAppliance(appliance); // add appliance to the house
}
/**
* This method creates new Tasks
* If the input is correct, the constructor receives all his arguments
* Assign the task to the las person that has been read and added to the house
*/
private void retreiveTask(Person person, String currentLine, House myhouse) {
String taskname = currentLine.split(":")[0];
int time = Integer.parseInt(currentLine.split(":")[1]);
if (time < 1 || time > 96) System.err.println("Task time out of bounds");
Task task = new Task(taskname, time, myhouse);
try {
person.addTask(task);
} catch (Exception e) {
System.err.println("The following task cannot be done by " + person.getName() + " :" + taskname);
}
}
}
|
package com.myth.springboot.controller;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.servlet.ModelAndView;
@Controller
public class JumpController {
//页面跳转-----------------------------------------------------------------
// @RequestMapping("/")
// public String index(){
// return "index";
// }
@RequestMapping("/")
public String index(){
return "login";
}
@RequestMapping("/a")
public String a(){
return "aaa";
}
@RequestMapping("/toLogin")
public String toLogin(){
return "login";
}
@RequestMapping("/main")
public String main(){
return "index";
}
//
@RequestMapping("/toStudentList")
public String toStudentList(){
return "student/student-list";
}
@RequestMapping("/toStudentAdd")
public String toStudentAdd(){
return "student/student-add";
}
@RequestMapping("/test")
public ModelAndView test(){
ModelAndView mv = new ModelAndView("login");
return mv;
}
//
@RequestMapping("/toTeacherList")
public String toTeacherList(){
return "teacher/teacher-list";
}
@RequestMapping("/toTeacherAdd")
public String toTeacherAdd(){
return "teacher/teacher-add";
}
@RequestMapping("/toWelcome")
public String toWelcome(){
return "welcome";
}
//
@RequestMapping("/toClassList")
public String toClassList(){
return "class/class-list";
}
@RequestMapping("/toClassAdd")
public String toClassAdd(){
return "class/class-add";
}
//
@RequestMapping("/tcCourseList")
public String tcCourseList(){
return "course/course-list";
}
@RequestMapping("/tcCourseAdd")
public String tcCourseAdd(){
return "course/course-add";
}
//
@RequestMapping("/toDeptList")
public String toDeptList(){
return "dept/dept-list";
}
@RequestMapping("toDeptAdd")
public String toDeptAdd(){
return "dept/dept-add";
}
//
@RequestMapping("/toUserList")
public String toUserList(){
return "user/user-list";
}
@RequestMapping("/toUserAdd")
public String toUserAdd(){
return "user/user-add";
}
//
@RequestMapping("/toTypeList")
public String toTypeList(){
return "type/type-list";
}
@RequestMapping("/toTypeAdd")
public String toTypeAdd(){
return "type/type-add";
}
//
@RequestMapping("/toTeachingList")
public String toTeachingList(){
return "teaching/teaching-list";
}
@RequestMapping("/toTeachingAdd")
public String toTeachingAdd(){
return "teaching/teaching-add";
}
//
@RequestMapping("/toBatchList")
public String toBatchList(){
return "batch/batch-list";
}
@RequestMapping("/toBatchAdd")
public String toBatchAdd(){
return "batch/batch-add";
}
//
@RequestMapping("/toResultList")
public String toResultList(){
return "result/result-list";
}
//
@RequestMapping("toList")
public String toList(){
return "s/list";
}
@RequestMapping("toS")
public String toS(){
return "s/s-list";
}
@RequestMapping("toS1")
public String toS1(){
return "s/s-list1";
}
@RequestMapping("toT")
public String toT(){
return "t/t-list";
}
@RequestMapping("toT1")
public String toT1(){
return "t/list";
}
//跳转到学生试题添加页面
@RequestMapping("/toQuestionAdd")
public String toQuestionAdd(){
return "question/question-add";
}
//跳转到学生试题查看页面
@RequestMapping("/toQuestionList")
public String toQuestionList(){
return "question/question-list";
}
//跳转到学生试题修改页面
@RequestMapping("/toQuestionUpdate")
public String toQuestionUpdate(){
return "question/question-update";
}
//跳转到教师试题添加页面
@RequestMapping("/toQuestionsAdd")
public String toQuestionsAdd(){
return "questions/questions-add";
}
//跳转到教师试题查看页面
@RequestMapping("/toQuestionsList")
public String toQuestionsList(){
return "questions/questions-list";
}
//跳转到教师试题修改页面
@RequestMapping("/toQuestionsUpdate")
public String toQuestionsUpdate(){
return "questions/questions-update";
}
////得到数据表
@RequestMapping("/show")
public String toShow(){
return "t/show";
}
@RequestMapping("/toUpdatePass")
public String toUpdatePass(){
return "/updatePassword";
}
}
|
package javacode;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;
import java.text.DecimalFormat;
import java.text.NumberFormat;
import java.util.logging.Level;
import java.util.logging.Logger;
import schema.db_connect;
public class cgpa implements CalculateResult{
String grade[][]=new String[15][2];
@Override
public String[][] cal_res(double grd[],String[] course,int l) {
int i;
double n,tn;
db_connect db=db_connect.get_connection();
Statement st=db.statement;
double Tcredit=0.0,gpa,credit=0.0,finalgpa=0.0;
for(i=0;i<l;i++)
{
if(grd[i]>=79.5)
{
grade[i][0]="A+";
grade[i][1]="4.00";
gpa=4.00;
}
else if(grd[i]>=74.5)
{
grade[i][0]="A";
grade[i][1]="3.75";
gpa=3.75;
}
else if(grd[i]>=69.5)
{
grade[i][0]="A-";
grade[i][1]="3.50";
gpa=3.5;
}
else if(grd[i]>=64.5)
{
grade[i][0]="B+";
grade[i][1]="3.25";
gpa=3.25;
}
else if(grd[i]>=59.5)
{
grade[i][0]="B";
grade[i][1]="3.00";
gpa=3.00;
}
else if(grd[i]>=54.5)
{
grade[i][0]="B-";
grade[i][1]="2.75";
gpa=2.75;
}
else if(grd[i]>=49.5)
{
grade[i][0]="C+";
grade[i][1]="2.50";
gpa=2.5;
}
else if(grd[i]>=44.5)
{
grade[i][0]="C";
grade[i][1]="2.25";
gpa=2.25;
}
else if(grd[i]>=39.5)
{
grade[i][0]="D";
grade[i][1]="2.00";
gpa=2.00;
}
else
{
grade[i][0]="F";
grade[i][1]="0.00";
gpa=0.00;
}
try{
ResultSet rs=st.executeQuery("SELECT credit FROM `course` WHERE course_code='"+course[i]+"'");
rs.next();
credit+=1.0*rs.getFloat(1);
Tcredit+=gpa*(1.0*rs.getFloat(1));
} catch (SQLException ex) {
Logger.getLogger(cgpa.class.getName()).log(Level.SEVERE, null, ex);
}
}
finalgpa=Tcredit/credit;
//finalgpa=1.00;
NumberFormat formatter = new DecimalFormat("#0.00");
grade[l][0]=" ";
grade[l][1]=formatter.format(finalgpa).toString();
//Double.toString(formatter.format(finalgpa));
//formatter.format(finalgpa).toString();
return grade;
}
} |
package com.github.bot.curiosone.core.nlp.tokenizer.interfaces;
import com.github.bot.curiosone.core.nlp.tokenizer.Sentence;
import com.github.bot.curiosone.core.nlp.tokenizer.SentenceType;
import com.github.bot.curiosone.core.nlp.tokenizer.Token;
import java.util.List;
/**
* Sentence info.
*
* @author Andrea Rivitto && Eugenio Schintu
*/
public interface ISentence {
/**
* Get type.
*
* @see Sentence#getType()
*/
SentenceType getType();
/**
* Get original.
*
* @see Sentence#getOriginal()
*/
String getOriginal();
/**
* Get tokens.
*
* @see Sentence#getTokens()
*/
List<IToken> getTokens();
/**
* Add a new token to {@link #tokens} .
*
* @see #tokens
* @see Token
*/
void addToken(IToken token);
/**
* Set a new {@link #type} value provided in input.
*
* @see #type
*/
void setType(SentenceType type);
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.