@SuppressWarnings("unchecked")
public ResidentConverter(List<ObjectConverter.ColumnInfo> allColumns) throws java.io.IOException {
Optional<ObjectConverter.ColumnInfo> column;
final java.util.List<ObjectConverter.ColumnInfo> columns =
allColumns
.stream()
.filter(
it ->
"mixinReference".equals(it.typeSchema) && "Resident_entity".equals(it.typeName))
.collect(Collectors.toList());
columnCount = columns.size();
readers = new ObjectConverter.Reader[columnCount];
for (int i = 0; i < readers.length; i++) {
readers[i] = (instance, rdr, ctx) -> StringConverter.skip(rdr, ctx);
}
final java.util.List<ObjectConverter.ColumnInfo> columnsExtended =
allColumns
.stream()
.filter(
it ->
"mixinReference".equals(it.typeSchema)
&& "-ngs_Resident_type-".equals(it.typeName))
.collect(Collectors.toList());
columnCountExtended = columnsExtended.size();
readersExtended = new ObjectConverter.Reader[columnCountExtended];
for (int i = 0; i < readersExtended.length; i++) {
readersExtended[i] = (instance, rdr, ctx) -> StringConverter.skip(rdr, ctx);
}
column = columns.stream().filter(it -> "id".equals(it.columnName)).findAny();
if (!column.isPresent())
throw new java.io.IOException(
"Unable to find 'id' column in mixinReference Resident_entity. Check if DB is in sync");
__index___id = (int) column.get().order - 1;
column = columnsExtended.stream().filter(it -> "id".equals(it.columnName)).findAny();
if (!column.isPresent())
throw new java.io.IOException(
"Unable to find 'id' column in mixinReference Resident. Check if DB is in sync");
__index__extended_id = (int) column.get().order - 1;
column = columns.stream().filter(it -> "birth".equals(it.columnName)).findAny();
if (!column.isPresent())
throw new java.io.IOException(
"Unable to find 'birth' column in mixinReference Resident_entity. Check if DB is in sync");
__index___birth = (int) column.get().order - 1;
column = columnsExtended.stream().filter(it -> "birth".equals(it.columnName)).findAny();
if (!column.isPresent())
throw new java.io.IOException(
"Unable to find 'birth' column in mixinReference Resident. Check if DB is in sync");
__index__extended_birth = (int) column.get().order - 1;
}
@Override
protected boolean specificValidate(SymbolResolver resolver, ErrorCollector errorCollector) {
if (baseType.isPresent()) {
if (!baseType.get().isReferenceTypeUsage()
|| !baseType.get().asReferenceTypeUsage().isClass(resolver)) {
errorCollector.recordSemanticError(
baseType.get().getPosition(), "Only classes can be extended");
return false;
}
}
for (TypeUsageNode typeUsage : interfaces) {
if (!typeUsage.isReferenceTypeUsage()
|| !typeUsage.asReferenceTypeUsage().isInterface(resolver)) {
errorCollector.recordSemanticError(
typeUsage.getPosition(), "Only interfaces can be implemented");
return false;
}
}
if (getExplicitConstructors().size() > 1) {
for (TurinTypeContructorDefinitionNode contructorDefinition : getExplicitConstructors()) {
errorCollector.recordSemanticError(
contructorDefinition.getPosition(), "At most one explicit constructor can be defined");
}
return false;
}
return super.specificValidate(resolver, errorCollector);
}
public static Container setup(
DataSource dataSource,
Properties properties,
Optional<File> pluginsPath,
Optional<ClassLoader> classLoader)
throws IOException {
ClassLoader loader;
if (pluginsPath.isPresent()) {
File[] jars = pluginsPath.get().listFiles(f -> f.getPath().toLowerCase().endsWith(".jar"));
List<URL> urls = new ArrayList<>(jars.length);
for (File j : jars) {
try {
urls.add(j.toURI().toURL());
} catch (MalformedURLException ex) {
throw new IOException(ex);
}
}
loader =
classLoader.isPresent()
? new URLClassLoader(urls.toArray(new URL[urls.size()]), classLoader.get())
: new URLClassLoader(urls.toArray(new URL[urls.size()]));
} else if (classLoader.isPresent()) {
loader = classLoader.get();
} else {
loader = Thread.currentThread().getContextClassLoader();
}
ServiceLoader<SystemAspect> aspects = ServiceLoader.load(SystemAspect.class, loader);
return setup(dataSource, properties, Optional.of(loader), aspects.iterator());
}
public Optional<byte[]> get(
Optional<String> table,
Optional<String> family,
Optional<String> qualifier,
Optional<String> key) {
if (!valid) {
Logger.error("CANNOT GET! NO VALID CONNECTION");
return Optional.empty();
}
if (table.isPresent()
&& family.isPresent()
&& qualifier.isPresent()
&& key.isPresent()
&& !key.get().isEmpty()) {
try {
final Table htable = connection.getTable(TableName.valueOf(table.get()));
Result result = htable.get(new Get(key.get().getBytes("UTF8")));
return Optional.ofNullable(
result.getValue(family.get().getBytes("UTF8"), qualifier.get().getBytes("UTF8")));
} catch (IOException e) {
e.printStackTrace();
}
}
return Optional.empty();
}
/**
* PUT /users : Updates an existing User.
*
* @param managedUserVM the user to update
* @return the ResponseEntity with status 200 (OK) and with body the updated user, or with status
* 400 (Bad Request) if the login or email is already in use, or with status 500 (Internal
* Server Error) if the user couldn't be updated
*/
@PutMapping("/users")
@Timed
@Secured(AuthoritiesConstants.ADMIN)
public ResponseEntity<ManagedUserVM> updateUser(@RequestBody ManagedUserVM managedUserVM) {
log.debug("REST request to update User : {}", managedUserVM);
Optional<User> existingUser = userRepository.findOneByEmail(managedUserVM.getEmail());
if (existingUser.isPresent() && (!existingUser.get().getId().equals(managedUserVM.getId()))) {
return ResponseEntity.badRequest()
.headers(
HeaderUtil.createFailureAlert(
"userManagement", "emailexists", "E-mail already in use"))
.body(null);
}
existingUser = userRepository.findOneByLogin(managedUserVM.getLogin().toLowerCase());
if (existingUser.isPresent() && (!existingUser.get().getId().equals(managedUserVM.getId()))) {
return ResponseEntity.badRequest()
.headers(
HeaderUtil.createFailureAlert("userManagement", "userexists", "Login already in use"))
.body(null);
}
userService.updateUser(
managedUserVM.getId(),
managedUserVM.getLogin(),
managedUserVM.getFirstName(),
managedUserVM.getLastName(),
managedUserVM.getEmail(),
managedUserVM.isActivated(),
managedUserVM.getLangKey(),
managedUserVM.getAuthorities());
return ResponseEntity.ok()
.headers(HeaderUtil.createAlert("userManagement.updated", managedUserVM.getLogin()))
.body(new ManagedUserVM(userService.getUserWithAuthorities(managedUserVM.getId())));
}
@Override
public Card deal() {
Optional<Card> nextCard = cards.stream().findFirst();
if (nextCard.isPresent()) {
cards.remove(nextCard.get());
}
return nextCard.get();
}
/**
* Create a Trezor hard wallet from a backup summary, decrypting it with a password created from
* the Trezor supplied entropy
*/
private boolean createTrezorHardWallet() {
// Get the model that contains the selected wallet backup to use
SelectBackupSummaryModel selectedBackupSummaryModel =
getWizardModel().getSelectBackupSummaryModel();
if (selectedBackupSummaryModel == null
|| selectedBackupSummaryModel.getValue() == null
|| selectedBackupSummaryModel.getValue().getFile() == null) {
log.debug("No wallet backup to use from the model");
return false;
}
log.debug(
"Loading hard wallet backup '" + selectedBackupSummaryModel.getValue().getFile() + "'");
try {
// For Trezor hard wallets the backups are encrypted with the entropy derived password
String walletPassword = null;
Optional<HardwareWalletService> hardwareWalletService =
CoreServices.getOrCreateHardwareWalletService();
if (hardwareWalletService.isPresent()
&& hardwareWalletService.get().getContext().getEntropy().isPresent()) {
walletPassword =
Hex.toHexString(hardwareWalletService.get().getContext().getEntropy().get());
}
// Check there is a wallet password - if not then cannot decrypt backup
if (walletPassword == null) {
log.debug(
"Cannot work out the password to decrypt the backup - there is no entropy from the Trezor");
return false;
}
KeyParameter backupAESKey =
AESUtils.createAESKey(
walletPassword.getBytes(Charsets.UTF_8), WalletManager.scryptSalt());
WalletId loadedWalletId =
BackupManager.INSTANCE.loadZipBackup(
selectedBackupSummaryModel.getValue().getFile(), backupAESKey);
// Attempt to open the wallet
final Optional<WalletSummary> walletSummaryOptional =
WalletManager.INSTANCE.openWalletFromWalletId(
InstallationManager.getOrCreateApplicationDataDirectory(),
loadedWalletId,
walletPassword);
// If the wallet is present then it was opened successfully
return walletSummaryOptional.isPresent();
} catch (Exception e) {
log.error("Failed to restore Trezor hard wallet.", e);
}
// Must have failed to be here
return false;
}
@Test
public void testDataExtractor() throws Exception {
BasicSampleExtractor extractor = new BasicSampleExtractor();
Optional<SampleData> sampleData = extractor.extractSample(new JsonObject(buildMessage()));
assertTrue(sampleData.isPresent());
assertEquals(sampleData.get().getPublishId(), "norbert");
assertEquals(sampleData.get().getTime(), NOW);
assertEquals(sampleData.get().getMedian(), 10.5);
assertTrue(sampleData.get().getReadings().length > 0);
}
@Override
public void configure(String cfgString, MessageEvent event, ServerConfig cfg) {
if (cfgString == null) {
Optional<String> chans =
event
.getGuild()
.getTextChannels()
.stream()
.filter(c -> availableChats.contains(c.getId()))
.map(Channel::getName)
.reduce((s1, s2) -> s1 + ", " + s2);
MessageUtil.reply(
event,
cfg,
"Use addChannel/removeChannel CHANNELNAME to add/remove channels to whitelist"
+ "\nCurrent channels: "
+ (chans.isPresent() ? chans.get() : "All"));
return;
}
String[] split = cfgString.toLowerCase().split("\\s+", 2);
if (split.length != 2) {
MessageUtil.reply(event, cfg, "Invalid Syntax");
} else {
Optional<TextChannel> chan =
event
.getGuild()
.getTextChannels()
.stream()
.filter(c -> c.getName().toLowerCase().equals(split[1]))
.findAny();
if (split[0].equals("addchannel")) {
if (chan.isPresent()) {
availableChats.add(chan.get().getId());
updateConfig();
cfg.save();
MessageUtil.reply(event, cfg, "Channel added");
} else {
MessageUtil.reply(event, cfg, "Channel not found!");
}
} else if (split[0].equals("removechannel")) {
if (chan.isPresent()) {
availableChats.remove(chan.get().getId());
updateConfig();
cfg.save();
MessageUtil.reply(event, cfg, "Channel removed");
} else {
MessageUtil.reply(event, cfg, "Channel not found!");
}
} else {
MessageUtil.reply(event, cfg, "Invalid Syntax");
}
}
}
@Override
public OntrackSVNRevisionInfo getOntrackRevisionInfo(SVNRepository repository, long revision) {
// Gets information about the revision
SVNRevisionInfo basicInfo = svnService.getRevisionInfo(repository, revision);
SVNChangeLogRevision changeLogRevision =
svnService.createChangeLogRevision(repository, basicInfo);
// Gets the first copy event on this path after this revision
SVNLocation firstCopy = svnService.getFirstCopyAfter(repository, basicInfo.toLocation());
// Data to collect
Collection<BuildView> buildViews = new ArrayList<>();
Collection<BranchStatusView> branchStatusViews = new ArrayList<>();
// Loops over all authorised branches
for (Project project : structureService.getProjectList()) {
// Filter on SVN configuration: must be present and equal to the one the revision info is
// looked into
Property<SVNProjectConfigurationProperty> projectSvnConfig =
propertyService.getProperty(project, SVNProjectConfigurationPropertyType.class);
if (!projectSvnConfig.isEmpty()
&& repository
.getConfiguration()
.getName()
.equals(projectSvnConfig.getValue().getConfiguration().getName())) {
for (Branch branch : structureService.getBranchesForProject(project.getId())) {
// Filter on branch type
// Filter on SVN configuration: must be present
if (branch.getType() != BranchType.TEMPLATE_DEFINITION
&& propertyService.hasProperty(branch, SVNBranchConfigurationPropertyType.class)) {
// Identifies a possible build given the path/revision and the first copy
Optional<Build> build = lookupBuild(basicInfo.toLocation(), firstCopy, branch);
// Build found
if (build.isPresent()) {
// Gets the build view
BuildView buildView = structureService.getBuildView(build.get());
// Adds it to the list
buildViews.add(buildView);
// Collects the promotions for the branch
branchStatusViews.add(structureService.getEarliestPromotionsAfterBuild(build.get()));
}
}
}
}
}
// OK
return new OntrackSVNRevisionInfo(
repository.getConfiguration(), changeLogRevision, buildViews, branchStatusViews);
}
static void optionalTest() {
// 不要这样,这与!=null没什么区别
Optional<String> stringOptional = Optional.of("alibaba");
if (stringOptional.isPresent()) {
System.out.println(stringOptional.get().length());
}
Optional<String> optionalValue = Optional.of("alibaba");
// 下面是推荐的常用操作
optionalValue.ifPresent(s -> System.out.println(s + " contains red"));
// 增加到集合汇总
List<String> results = Lists.newArrayList();
optionalValue.ifPresent(results::add);
// 增加到集合中，并返回操作结果
Optional<Boolean> added = optionalValue.map(results::add);
// 无值的optional
Optional<String> optionalString = Optional.empty();
// 不存在值，返回“No word”
String result = optionalValue.orElse("No word");
// 没值，计算一个默认值
result = optionalString.orElseGet(() -> System.getProperty("user.dir"));
// 无值，抛一个异常
try {
result = optionalString.orElseThrow(NoSuchElementException::new);
} catch (Throwable t) {
t.getCause();
}
}
private Map<String, Function> getByAssignable(
Map<String, Map<String, Function>> cache,
Map<Class, Map<String, Map<String, Function>>> rawMap,
Class clazz,
String name) {
Set<Class> classes = rawMap.keySet();
Optional<Class> candidate =
classes.stream().findFirst().filter(it -> it.isAssignableFrom(clazz));
if (candidate.isPresent()) {
Class candidateClass = candidate.get();
Map<String, Map<String, Function>> namedFunctionMap = rawMap.get(candidateClass);
Map<String, Function> functionMap = namedFunctionMap.get(name);
if (functionMap != null) {
String key = clazz + "#" + name;
cache.put(key, functionMap);
return functionMap;
}
}
return null;
}
@Override
public Board.Path requestPlayerMove(
Player player, Board board, Set<Location<Integer>> blockedLocations, int distance) {
this.out.printf("Enter a move of length %d.\n", distance);
this.out.printf(
"Moves are in the format UDLR, where such a move would mean go up, then down, then left, then right.\n\n");
List<Direction> moveSequence = new ArrayList<>();
String charSequence = this.scanner.next();
if (charSequence.length() != distance) {
return this.requestPlayerMove(player, board, blockedLocations, distance);
}
for (int i = 0; i < charSequence.length(); i++) {
char c = charSequence.charAt(i);
Direction dir = Direction.fromCharacter(c);
if (dir == null) {
return this.requestPlayerMove(player, board, blockedLocations, distance);
}
moveSequence.add(dir);
}
Optional<Board.Path> path =
board.directionsToPath(player.location(), moveSequence, blockedLocations);
return path.isPresent()
? path.get()
: this.requestPlayerMove(player, board, blockedLocations, distance);
}
@Test
@Transactional
public void testRegisterAdminIsIgnored() throws Exception {
UserDTO u =
new UserDTO(
"badguy", // login
"password", // password
"Bad", // firstName
"Guy", // lastName
"*****@*****.**", // e-mail
true, // activated
"en", // langKey
new HashSet<>(
Arrays.asList(
AuthoritiesConstants.ADMIN)) // <-- only admin should be able to do that
);
restMvc
.perform(
post("/api/register")
.contentType(TestUtil.APPLICATION_JSON_UTF8)
.content(TestUtil.convertObjectToJsonBytes(u)))
.andExpect(status().isCreated());
Optional<User> userDup = userRepository.findOneByLogin("badguy");
assertThat(userDup.isPresent()).isTrue();
assertThat(userDup.get().getAuthorities())
.hasSize(1)
.containsExactly(authorityRepository.findOne(AuthoritiesConstants.USER));
}
public RefsModel(
@NotNull Map<VirtualFile, CompressedRefs> refs,
@NotNull Set<Integer> heads,
@NotNull VcsLogStorage hashMap,
@NotNull Map<VirtualFile, VcsLogProvider> providers) {
myRefs = refs;
myHashMap = hashMap;
myBestRefForHead = new TIntObjectHashMap<>();
myRootForHead = new TIntObjectHashMap<>();
for (int head : heads) {
CommitId commitId = myHashMap.getCommitId(head);
if (commitId != null) {
VirtualFile root = commitId.getRoot();
myRootForHead.put(head, root);
Optional<VcsRef> bestRef =
myRefs
.get(root)
.refsToCommit(head)
.stream()
.min(providers.get(root).getReferenceManager().getBranchLayoutComparator());
if (bestRef.isPresent()) {
myBestRefForHead.put(head, bestRef.get());
} else {
LOG.warn("No references at head " + commitId);
}
}
}
}
/** POST /account -> update the current user information. */
@RequestMapping(
value = "/account",
method = RequestMethod.POST,
produces = MediaType.APPLICATION_JSON_VALUE)
@Timed
public ResponseEntity<String> saveAccount(@RequestBody UserDTO userDTO) {
Optional<User> existingUser = userRepository.findOneByEmail(userDTO.getEmail());
if (existingUser.isPresent()
&& (!existingUser.get().getLogin().equalsIgnoreCase(userDTO.getLogin()))) {
return ResponseEntity.badRequest()
.headers(
HeaderUtil.createFailureAlert(
"user-management", "emailexists", "Email already in use"))
.body(null);
}
return userRepository
.findOneByLogin(SecurityUtils.getCurrentUser().getUsername())
.map(
u -> {
userService.updateUserInformation(
userDTO.getFirstName(),
userDTO.getLastName(),
userDTO.getEmail(),
userDTO.getLangKey());
return new ResponseEntity<String>(HttpStatus.OK);
})
.orElseGet(() -> new ResponseEntity<>(HttpStatus.INTERNAL_SERVER_ERROR));
}
@Override
public void unpublish(String id, Handler<AsyncResult<Void>> resultHandler) {
Objects.requireNonNull(id);
if (resultHandler == null) {
resultHandler = (v) -> {};
}
Handler<AsyncResult<Void>> handler = resultHandler;
acquireLock(
resultHandler,
lock ->
getRegistry(
lock,
handler,
map ->
vertx.<Void>executeBlocking(
future -> {
Optional<JsonObject> match =
map.values()
.stream()
.filter(reg -> reg.getString("service.id").equals(id))
.findFirst();
if (match.isPresent()) {
map.remove(match.get().getString("service.address"));
future.complete();
} else {
future.fail("Service registration not found");
}
},
result -> {
handler.handle(result);
lock.release();
})));
}
@Override
public void validate(
final String key,
final long totalOccurrences,
final double percentContaining,
final String... types) {
final Optional<VarietyEntry> first =
entries.stream().filter(entry -> entry.getKey().equals(key)).findFirst();
if (!first.isPresent()) {
Assert.fail("Entry with key '" + key + "' not found in variety results");
}
final VarietyEntry varietyEntry = first.get();
Assert.assertEquals(
"Failed to verify types of key " + key,
new HashSet<>(Arrays.asList(types)),
varietyEntry.getTypes());
Assert.assertEquals(
"Failed to verify total occurrences of key " + key,
totalOccurrences,
varietyEntry.getTotalOccurrences());
Assert.assertEquals(
"Failed to verify percents of key " + key,
percentContaining,
varietyEntry.getPercentContaining(),
1e-15); // TODO: precision?
}
@RequestMapping(
value = "/api/broadcast",
method = RequestMethod.POST,
produces = "application/json")
public List<BroadcastGroup> broadcastMessage(
@RequestParam("name") String name,
@RequestParam("set") Integer setId,
@RequestParam("message") String message) {
BroadcastGroup group = broadcastRepository.findOne(name);
if (group != null) {
Optional<BroadcastSet> setOptional =
group.getBroadcastSets().stream().filter(set -> set.getId() == setId).findFirst();
if (setOptional.isPresent()) {
BroadcastSet set = setOptional.get();
set.getMessages().add(new BroadcastMessage(message, new Date()));
broadcastRepository.save(group);
executorService.execute(
() -> {
set.getUsers()
.forEach(
userId -> {
SlackUser user = session.findUserById(userId);
session.sendMessageToUser(user, message, null);
});
});
} else {
log.error("Can't find set with id {}", setId);
}
} else {
log.error("Can't find group with name {}", name);
}
return broadcastRepository.findAll();
}
public Optional<Response> get(Optional<Request> request) {
if (!valid) {
Logger.error("CANNOT GET! NO VALID CONNECTION");
return Optional.empty();
}
Response response = new Response();
if (request.isPresent()) {
Request r = request.get();
response.key = r.key;
response.table = r.table;
try {
final Table htable = connection.getTable(TableName.valueOf(r.table));
Result result = htable.get(new Get(r.key));
if (result == null || result.isEmpty()) {
return Optional.empty();
}
r.columns.forEach(
c ->
response.columns.add(
new Request.Column(
c.family,
c.qualifier,
result.getValue(c.family.getBytes(), c.qualifier.getBytes()))));
} catch (IOException e) {
e.printStackTrace();
}
}
return Optional.of(response);
}
@Override
public List<Catalog> fineEpisodesBySeriesAndSeason(int id, int season) {
Optional<Catalog> series = findBySeriesId(id);
List<Catalog> episodes = getSeriesEpisodes(series.get(), season);
return episodes;
}
/**
* PUT /users : Updates an existing User.
*
* @param managedUserDTO the user to update
* @return the ResponseEntity with status 200 (OK) and with body the updated user, or with status
* 400 (Bad Request) if the login or email is already in use, or with status 500 (Internal
* Server Error) if the user couldnt be updated
*/
@RequestMapping(
value = "/users",
method = RequestMethod.PUT,
produces = MediaType.APPLICATION_JSON_VALUE)
@Timed
@Transactional
@Secured(AuthoritiesConstants.ADMIN)
public ResponseEntity<ManagedUserDTO> updateUser(@RequestBody ManagedUserDTO managedUserDTO) {
log.debug("REST request to update User : {}", managedUserDTO);
Optional<User> existingUser = userRepository.findOneByEmail(managedUserDTO.getEmail());
if (existingUser.isPresent() && (!existingUser.get().getId().equals(managedUserDTO.getId()))) {
return ResponseEntity.badRequest()
.headers(
HeaderUtil.createFailureAlert(
"userManagement", "emailexists", "E-mail already in use"))
.body(null);
}
existingUser = userRepository.findOneByLogin(managedUserDTO.getLogin().toLowerCase());
if (existingUser.isPresent() && (!existingUser.get().getId().equals(managedUserDTO.getId()))) {
return ResponseEntity.badRequest()
.headers(
HeaderUtil.createFailureAlert("userManagement", "userexists", "Login already in use"))
.body(null);
}
return userRepository
.findOneById(managedUserDTO.getId())
.map(
user -> {
user.setLogin(managedUserDTO.getLogin());
user.setFirstName(managedUserDTO.getFirstName());
user.setLastName(managedUserDTO.getLastName());
user.setEmail(managedUserDTO.getEmail());
user.setActivated(managedUserDTO.isActivated());
user.setLangKey(managedUserDTO.getLangKey());
Set<Authority> authorities = user.getAuthorities();
authorities.clear();
managedUserDTO
.getAuthorities()
.stream()
.forEach(authority -> authorities.add(authorityRepository.findOne(authority)));
return ResponseEntity.ok()
.headers(
HeaderUtil.createAlert("userManagement.updated", managedUserDTO.getLogin()))
.body(new ManagedUserDTO(userRepository.findOne(managedUserDTO.getId())));
})
.orElseGet(() -> new ResponseEntity<>(HttpStatus.INTERNAL_SERVER_ERROR));
}
@Test
public void _03_filter() {
Stream<String> longWords = words.stream().filter(w -> w.length() > 12);
Optional<String> first = longWords.findFirst();
assertThat(first.isPresent(), is(true));
assertThat(first.get(), is("conversations"));
}
public void setCapability(int engineNumber, double capability) {
Optional<HostCapability> c1 =
(capabilitySet.stream().filter((c) -> c.geteNum() == engineNumber).findFirst());
if (c1.isPresent()) {
c1.get().setCapability(capability);
}
capabilitySet.add(new HostCapability(this, engineNumber));
}
@Override
public EmployeeDTO getEmployeeById(long id) {
Optional<Employee> employee = Optional.ofNullable(employeeRepository.findOne(id));
if (employee.isPresent()) {
return mapEmployeeToEmployeeDtoObject(employee.get());
} else {
throw new IllegalArgumentException("there is no employee found with id " + id);
}
}
/**
* Tests that replaceIssueAssigneeOnServer finds issue with the right id and successfully modify
* the issue's assignee
*/
@Test
public void replaceIssueAssignee_successful() {
String repoId = "testowner/testrepo";
String originalAssignee = "user1";
String newAssignee = "user2";
TurboIssue issue1 = LogicTests.createIssueWithAssignee(1, originalAssignee);
TurboIssue issue2 = LogicTests.createIssueWithAssignee(2, originalAssignee);
TurboIssue issue3 = LogicTests.createIssueWithAssignee(3, originalAssignee);
List<TurboIssue> issues = Arrays.asList(issue3, issue2, issue1);
Model model =
new Model(repoId, issues, new ArrayList<>(), new ArrayList<>(), new ArrayList<>());
Optional<TurboIssue> result =
model.replaceIssueAssignee(issue1.getId(), Optional.of(newAssignee));
assertEquals(1, result.get().getId());
assertEquals(newAssignee, result.get().getAssignee().get());
}
public void exit() {
Alert alert = new Alert(Alert.AlertType.CONFIRMATION);
alert.setTitle("Quit?");
alert.setHeaderText("You've selected to quit this program.");
alert.setContentText("Are you sure you want to quit?");
Optional<ButtonType> result = alert.showAndWait();
if (result.get() == ButtonType.OK) System.exit(0);
}
@Test
public void _06_단순리덕션() {
Optional<String> largest = words.stream().max(String::compareToIgnoreCase);
if (largest.isPresent()) {
System.out.println("큰값: " + largest.get());
} else {
System.out.println("Empty~");
}
}
public double getCapability(int engineNumber) {
Optional<HostCapability> c1 =
(capabilitySet.stream().filter((c) -> c.geteNum() == engineNumber).findFirst());
if (c1.isPresent()) {
return c1.get().getCapability();
}
capabilitySet.add(new HostCapability(this, engineNumber));
return 0;
}
@Override
public EmployeeDTO getEmployeeDtoByEmail(String email) {
Optional<Employee> employee = employeeRepository.findOneByEmail(email);
if (employee.isPresent()) {
return mapEmployeeToEmployeeDtoObject(employee.get());
} else {
throw new IllegalArgumentException(
"there is no employee found with email ' " + email + " '.");
}
}
