@Override protected Type doTypecheck(Environment env, Optional<Type> expected) { Type[] newTypes = new Type[objects.length]; for (int i = 0; i < objects.length; i++) { final int sti = i; newTypes[i] = objects[i].typecheck( env, expected.map( exp -> { if (exp instanceof Tuple) return ((Tuple) exp).getTypeArray()[sti]; if (exp instanceof Intersection) return ((Intersection) exp) .getTypes() .stream() .filter(tpe -> tpe instanceof Tuple) .filter(tpe -> ((Tuple) tpe).getTypeArray().length == objects.length) .findFirst() .get(); ToolError.reportError( ErrorMessage.ACTUAL_FORMAL_TYPE_MISMATCH, this, getType().toString(), exp.toString()); throw new RuntimeException(); })); } return new Tuple(newTypes); }
@Override public PropertyNode getEnabledFlagNode() { Optional<VariableNode> propertyNode = getPropertyNode(ServerDiagnosticsType.ENABLED_FLAG.getBrowseName()); return propertyNode.map(n -> (PropertyNode) n).orElse(null); }
/** * Buying articles for business customers as employee. * * @param cart cart for the business customer, will be cleared * @param nickname nickname of the currently logged in employee * @param success notification of successfully buying articles * @return redirect to template "index" (home page) */ @RequestMapping(value = "/checkout_employee", method = RequestMethod.POST) public String buyforbusinesscustomer( @ModelAttribute Cart cart, @RequestParam("bcustomer") String nickname, RedirectAttributes success) { Optional<UserAccount> businessCustomer = userAccountManager.findByUsername(nickname); return businessCustomer .map( account -> { Order order = new Order(account, Cash.CASH); cart.addItemsTo(order); orderManager.payOrder(order); orderManager.completeOrder(order); cart.clear(); success.addFlashAttribute( "success", "Die Bestellung für den Geschäftskunden ist abgeschlossen."); return "redirect:/"; }) .orElse("redirect:/cart"); }
public static void respond( HttpExchange exchange, String redirectUrl, String name, Optional<String> message) throws IOException { LOG.finer( () -> "Redirecting to " + name + " [" + redirectUrl + "]" + message.map(m -> ": " + m).orElse("")); exchange.getResponseHeaders().set("Location", redirectUrl); exchange.sendResponseHeaders(302, 0); if ("HEAD".equals(exchange.getRequestMethod())) return; try (PrintStream out = new PrintStream(exchange.getResponseBody())) { HeaderResponse.send(out, SessionFilter.getSession(exchange), "Redirection to " + name); out.println("<DIV>"); message.ifPresent(m -> out.printf("%s<BR>\n", m)); out.printf("Go to: <A href=\"%s\"><B>%s</B></A>", redirectUrl, name); out.println("</DIV>"); } catch (Exception e) { LOG.log(Level.SEVERE, e, () -> "Failed generating redirection to '" + name + "': "); throw (e); } }
@Override @Transactional public UserDetails loadUserByUsername(final String login) { log.debug("Authenticating {}", login); String lowercaseLogin = login.toLowerCase(); Optional<User> userFromDatabase = userRepository.findOneByLogin(lowercaseLogin); return userFromDatabase .map( user -> { if (!user.getActivated()) { throw new UserNotActivatedException( "User " + lowercaseLogin + " was not activated"); } List<GrantedAuthority> grantedAuthorities = user.getAuthorities() .stream() .map(authority -> new SimpleGrantedAuthority(authority.getName())) .collect(Collectors.toList()); return new org.springframework.security.core.userdetails.User( lowercaseLogin, user.getPassword(), grantedAuthorities); }) .orElseThrow( () -> new UsernameNotFoundException( "User " + lowercaseLogin + " was not found in the database")); }
/** * Adds an all-in-one computer (combined with four freely customizable parts) to the cart. * * @param article requested all-in-one computer * @param number the amount of requested articles * @param cart contains a fresh initialized cart * @param success notification about adding an article to the cart * @return redirect to template "allinone" */ @RequestMapping(value = "/cart2", method = RequestMethod.POST) public String addcomp( @RequestParam("pid") Computer article, @RequestParam("number") int number, @ModelAttribute Cart cart, RedirectAttributes success) { Optional<InventoryItem> item = inventory.findByProductIdentifier(article.getIdentifier()); Quantity quantity = item.map(InventoryItem::getQuantity).orElse(NONE); BigDecimal amount1 = quantity.getAmount(); int i = amount1.intValue(); int amount = number; if (number <= 0) { amount = 1; } if (number >= i) { amount = i; } cart.addOrUpdateItem(article, Quantity.of(amount)); cart.addOrUpdateItem(article.getProzessor().get(0), Quantity.of(amount)); cart.addOrUpdateItem(article.getGraka().get(0), Quantity.of(amount)); cart.addOrUpdateItem(article.getHdd().get(0), Quantity.of(amount)); cart.addOrUpdateItem(article.getRam().get(0), Quantity.of(amount)); article.getGraka().clear(); article.getHdd().clear(); article.getProzessor().clear(); article.getRam().clear(); success.addFlashAttribute( "success", "Der Artikel wurde erfolgreich Ihrem Warenkorb hinzugefügt."); return "redirect:allinone"; }
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(); } }
@Provides @Singleton public Filter filter( final QueryParser parser, final FilterFactory filters, final ExtraParameters params) { return Optionals.pickOptional( filter.map(parser::parseFilter), params.getFilter(INGESTION_FILTER_PARAM, parser)) .orElseGet(filters::t); }
@Override public LocalizedText getToState() { Optional<VariableNode> component = getVariableComponent("ToState"); return component .map(node -> (LocalizedText) node.getValue().getValue().getValue()) .orElse(null); }
@Override public Optional<Type> getCommonSuperType(List<? extends Type> types) { checkArgument(!types.isEmpty(), "types is empty"); Optional<TypeSignature> commonSuperTypeSignature = getCommonSuperTypeSignature( types.stream().map(Type::getTypeSignature).collect(toImmutableList())); return commonSuperTypeSignature.map(this::getType); }
@Override public ServerDiagnosticsSummaryDataType getServerDiagnosticsSummary() { Optional<VariableNode> component = getVariableComponent("ServerDiagnosticsSummary"); return component .map(node -> (ServerDiagnosticsSummaryDataType) node.getValue().getValue().getValue()) .orElse(null); }
@Override public SubscriptionDiagnosticsDataType[] getSubscriptionDiagnosticsArray() { Optional<VariableNode> component = getVariableComponent("SubscriptionDiagnosticsArray"); return component .map(node -> (SubscriptionDiagnosticsDataType[]) node.getValue().getValue().getValue()) .orElse(null); }
public Vec2 convertCoordinateSystem(Vec2 event) { Optional<Drawing> drawing = this.find(Drawing.drawing, both()).findFirst(); return drawing .map(x -> x.windowSystemToDrawingSystem(event)) .orElseThrow( () -> new IllegalArgumentException( " cant mouse around something without drawing support (to provide coordinate system)")); }
private void setConfirmResultConverter() { setResultConverter( (dialogButton) -> { List<PickerAssignee> finalUsers = state.getCurrentUsersList(); Optional<PickerAssignee> selectedAssignee = PickerAssignee.getSelectedAssignee(finalUsers); return new AssigneePickerDialogResponse( dialogButton, selectedAssignee.map(PickerAssignee::getLoginName)); }); }
private static <T> Optional<T> get( final JsonNode jsonResult, final String key, final Class<T> type) { final Optional<JsonNode> fieldNode = Optional.ofNullable(jsonResult.get(key)); return fieldNode.map( f -> { try { return EVENT_PARAMETERS_READER.treeToValue(f, type); } catch (final JsonProcessingException e) { log.info("Unable to map field: " + key, e); return null; } }); }
@Test public void _07_옵션_다루기() { final Optional<String> optional = words.stream().filter(w -> w.contains("red")).findFirst(); try { optional.ifPresent( v -> { throw new RuntimeException(); }); assert false; // 이 행은 실행되면 안됨. } catch (RuntimeException e) { } // 비어있는 경우는 실행되지 않음. Optional.empty() .ifPresent( v -> { throw new RuntimeException(); }); Set<String> results = new HashSet<>(); optional.ifPresent(results::add); assertThat(results.contains("tired"), is(true)); // 실행 결과를 받고 싶은 경우에는 map 사용. results = new HashSet<>(); Optional<Boolean> added = optional.map(results::add); assertThat(added, is(Optional.of(Boolean.TRUE))); // 대상이 빈경우에는 empty Optional 반환 Optional<Boolean> a = Optional.empty().map(v -> true); assertThat(a.isPresent(), is(false)); Optional<String> emptyOptional = Optional.empty(); // orElse로 기본값 지정 가능 String result = emptyOptional.orElse("기본값"); assertThat(result, is("기본값")); // 기본값 생성하는 코드 호출 가능 result = emptyOptional.orElseGet(() -> System.getProperty("user.dir")); assertThat(result, is(System.getProperty("user.dir"))); // 값이 없는 경우 예외 던지기 try { emptyOptional.orElseThrow(NoSuchElementException::new); assert false; } catch (NoSuchElementException e) { } }
@Override public void tweet() { // アカウントとテキストはnullにできない Objects.requireNonNull(twitter, "User is null."); Objects.requireNonNull(text, "TweetText is null."); StatusUpdate status = new StatusUpdate(text); reply.map(Tweet::getStatusId).ifPresent(status::setInReplyToStatusId); try { twitter.updateStatus(status); } catch (TwitterException e) { e.printStackTrace(); } }
@GET @Path("/entry/{entry-number}") @Produces({ ExtraMediaType.TEXT_HTML, MediaType.APPLICATION_JSON, ExtraMediaType.TEXT_YAML, ExtraMediaType.TEXT_CSV, ExtraMediaType.TEXT_TSV, ExtraMediaType.TEXT_TTL }) public AttributionView findByEntryNumber(@PathParam("entry-number") int entryNumber) { Optional<Entry> entry = entryDAO.findByEntryNumber(entryNumber); return entry.map(viewFactory::getEntryView).orElseThrow(NotFoundException::new); }
public static <S, V extends Comparable<V>> Move<S> best(Evaluate.Directional<S, V> eval) { return (S incumbent, Stream<S> locality) -> { Optional<S> max = locality.max( new Comparator<S>() { public int compare(S a, S b) { return eval.apply(a).compareTo(eval.apply(b)); } }); Optional<S> best = max.map((S s) -> eval.prefer(incumbent, s)); return Optional.of(best.orElse(incumbent)); }; }
public SpritzOutputStream(final Optional<String> fname, final String key, final OutputStream out) throws IOException { internalName = fname; encrypter = new SpritzEncrypter(key, out); byte[] nameBytes = fname .map(n -> new File(n).getName()) .orElse("") .getBytes(java.nio.charset.StandardCharsets.UTF_8); encrypter.write(nameBytes.length); encrypter.write(nameBytes); final Deflater zlibAlgo = new Deflater(Deflater.BEST_COMPRESSION); deflater = new DeflaterOutputStream(encrypter, zlibAlgo); }
public void accept(ObjectMapper mapper) { JaxbAnnotationModule module = new JaxbAnnotationModule(); // configure as necessary inc.map(include -> mapper.setSerializationInclusion(include)); mapper.registerModule(module); PluginLoader.INSTANCE .plugins .get() .stream() .filter(m -> m.jacksonModules() != null) .flatMap(m -> m.jacksonModules().stream()) .forEach(m -> mapper.registerModule(m)); mapper.registerModule(new Jdk8Module()); }
private Theme getRenderingTheme(API api) { Optional<String> sessionThemeName = api.getSession().map(Session::getThemeName); if (!sessionThemeName.isPresent()) { return defaultTheme; } return sessionThemeName .map(themes::get) .orElseThrow( () -> new IllegalArgumentException( "Theme '" + sessionThemeName.get() + "' which is set as for the current session of app '" + name + "' does not exists.")); }
/** * Parse request and set logon user in request scope. * * @param request HttpServletRequest * @param response HttpServletResponse * @param chain FilterChain * @throws IOException IOException * @throws ServletException ServletException */ public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain) throws IOException, ServletException { HttpServletRequest httpServletRequest = (HttpServletRequest) request; HttpServletResponse httpServletResponse = (HttpServletResponse) response; if (isIgnored(httpServletRequest)) { logger.info("Ignore request by userAuthenticationFilter"); chain.doFilter(httpServletRequest, httpServletResponse); return; } Optional<String> userIdOpt = getUserId(httpServletRequest); Optional<User> userOpt = userIdOpt .map( userId -> Optional.of( User.newBuilder() .withEmail(userId) .withUserId(userId) .withUsername(userId) .build())) .orElseGet( () -> { if (Boolean.valueOf(testUserEnabled)) { User user = User.newBuilder() .withEmail(testUserEmail) .withUserId(testUserId) .withUsername(testUsername) .build(); return Optional.of(user); } else { return Optional.empty(); } }); if (hasLogon(userOpt)) { authenticated(httpServletRequest, userOpt); } else { unauthenticated(httpServletResponse); return; } chain.doFilter(request, response); }
@Override public VulnerabilityUpdateStatus updateForComponent(String componentId) throws TException { Optional<Component> component = vulnerabilityConnector.getComponent(componentId); return component .map( c -> c.isSetReleaseIds() ? c.getReleaseIds() .stream() .map(this::updateForRelease) .reduce( getEmptyVulnerabilityUpdateStatus(), (r1, r2) -> reduceVulnerabilityUpdateStatus(r1, r2)) : getEmptyVulnerabilityUpdateStatus()) .orElse(getEmptyVulnerabilityUpdateStatus(RequestStatus.FAILURE)); }
/** * Attempts to parse the 'Authorization' header for Basic Authorization. * * @return a {@link LeoMap} with 'username' and 'password' properties */ public LeoMap auth() { Optional<BasicAuthCredentials> auth = parseBasicAuth(); return auth.map( b -> { LeoMap result = new LeoMap(); result.putByString("username", LeoString.valueOf(b.getUsername())); result.putByString("password", LeoString.valueOf(b.getPassword())); return result; }) .orElseGet( () -> { LeoMap result = new LeoMap(); result.putByString("username", LeoString.valueOf("")); result.putByString("password", LeoString.valueOf("")); return result; }); }
/** * Sets the given AnnotationSet as the "selected" one. If null is passed then all AnnotationSets * will be unselected. * * <p>Note: Currently switching selection is not supported when the currently selected * AnnotationSet has collapsed clusters. It is the responsibility of the UI to expand all the * clusters before switching the AnnotationSet. * * <p>MKTODO: It would be better for the model to handle expanding the clusters, but for now we * will force the UI to do it. * * @throws IllegalStateException If the currently active AnnotationSet has collapsed clusters. */ public void select(AnnotationSet annotationSet) { if (annotationSet == null || annotationSets.contains(annotationSet)) { if (Optional.ofNullable(annotationSet).equals(activeSet)) { return; } if (activeSet.map(AnnotationSet::hasCollapsedCluster).orElse(false)) { throw new IllegalStateException("Current AnnotationSet has collapsed clusters"); } CyNetwork network = networkView.getModel(); activeSet = Optional.ofNullable(annotationSet); // ModelManager.handle(AboutToRemoveNodesEvent) only removes nodes from the active annotation // set. // When switching to a new annotation set we need to "fix" the clusters to remove any nodes // that // were deleted previously. // MKTODO: probably need to test for deleted nodes when serializing the model if (annotationSet != null) { Set<Cluster> clusters = annotationSet.getClusters(); for (Cluster cluster : new HashSet<>( clusters)) { // avoid ConcurrentModificationException because removeNodes() can call // delete() Set<CyNode> nodesToRemove = cluster .getNodes() .stream() .filter(node -> !network.containsNode(node)) .collect(Collectors.toSet()); // Fires ClusterChangedEvent, UI listeners should test if the cluster is part of the // active annotation set. if (!nodesToRemove.isEmpty()) { cluster.removeNodes(nodesToRemove); } } } parent.postEvent(new ModelEvents.AnnotationSetSelected(this, activeSet)); } }
@Override public VulnerabilityUpdateStatus updateForProject(String projectId) throws TException { Optional<Project> project = vulnerabilityConnector.getProject(projectId); return project .map( r -> r.isSetReleaseIdToUsage() ? r.getReleaseIdToUsage() .keySet() .stream() .map(this::updateForRelease) .reduce( getEmptyVulnerabilityUpdateStatus(), (r1, r2) -> reduceVulnerabilityUpdateStatus(r1, r2)) : getEmptyVulnerabilityUpdateStatus()) .orElse(getEmptyVulnerabilityUpdateStatus(RequestStatus.FAILURE)); }
@Override protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException { Optional<ContentFactoryPair> factoryOptional = inputConfig.getFactory(Optional.of(request.getContentType()).map(MediaType::valueOf)); if (!factoryOptional.isPresent()) { response.setStatus(HttpServletResponse.SC_UNSUPPORTED_MEDIA_TYPE); String msg = "Unsupported Content-Type: " + request.getContentType(); response.getOutputStream().write(msg.getBytes(StandardCharsets.UTF_8)); return; } TTransport transport = new TIOStreamTransport(request.getInputStream(), response.getOutputStream()); TProtocol inputProtocol = factoryOptional.get().getProtocol(transport); Optional<String> acceptHeader = Optional.ofNullable(request.getHeader(ACCEPT)); Optional<MediaType> acceptType = Optional.empty(); if (acceptHeader.isPresent()) { try { acceptType = acceptHeader.map(MediaType::valueOf); } catch (IllegalArgumentException e) { // Thrown if the Accept header contains more than one type or something else we can't // parse, we just treat is as no header (which will pick up the default value). acceptType = Optional.empty(); } } ContentFactoryPair outputProtocolFactory = outputConfig.getFactory(acceptType); response.setContentType(outputProtocolFactory.getOutputType().toString()); TProtocol outputProtocol = outputProtocolFactory.getProtocol(transport); try { processor.process(inputProtocol, outputProtocol); response.getOutputStream().flush(); } catch (TException e) { throw new ServletException(e); } }
public void update() { StringBuilder sb = new StringBuilder(); ExportFormats.entryNumber = 1; // Set entry number in case that is included in the preview layout. entry.ifPresent( entry -> layout.ifPresent( layout -> sb.append( layout.doLayout( entry, databaseContext.map(BibDatabaseContext::getDatabase).orElse(null), highlightPattern)))); String newValue = sb.toString(); previewPane.setText(newValue); previewPane.revalidate(); // Scroll to top: scrollToTop(); }
@Override public URL getResource(String name) { URL result = super.getResource(name); if (result == null) { Optional<byte[]> resourceAsBytes = getResourceAsBytes(name); if (resourceAsBytes.isPresent()) {} result = resourceAsBytes .map( bb -> { try { return new URL( "remoteUrl", "localhost", 0, "name", new RemoteURLStreamHandler(bb)); } catch (Exception e) { throw new RuntimeException(e); } }) .orElse(null); } return result; }