public static <T> Optional<List<T>> immutableCopyOf(Optional<? extends List<T>> list) { return list.transform(ImmutableList::copyOf); } }
/** * Ends a {@link com.codahale.metrics.Timer.Context} only if it exists. * @param timer an Optional<{@link com.codahale.metrics.Timer.Context}$gt; */ public static void endTimer(Optional<Timer.Context> timer) { timer.transform(new Function<Timer.Context, Timer.Context>() { @Override public Timer.Context apply(@Nonnull Timer.Context input) { input.close(); return input; } }); }
/** * Returns a {@link com.codahale.metrics.Timer.Context} only if {@link org.apache.gobblin.metrics.MetricContext} is defined. * @param context an Optional<{@link org.apache.gobblin.metrics.MetricContext}$gt; * @param name name of the timer. * @return an Optional<{@link com.codahale.metrics.Timer.Context}$gt; */ public static Optional<Timer.Context> timerContext(Optional<MetricContext> context, final String name) { return context.transform(new Function<MetricContext, Timer.Context>() { @Override public Timer.Context apply(@Nonnull MetricContext input) { return input.timer(name).time(); } }); }
/** * Marks a meter only if it is defined. * @param meter an Optional<{@link com.codahale.metrics.Meter}> * @param value value to mark */ public static void markMeter(Optional<Meter> meter, final long value) { meter.transform(new Function<Meter, Meter>() { @Override public Meter apply(@Nonnull Meter input) { input.mark(value); return input; } }); }
/** * Updates a timer only if it is defined. * @param timer an Optional<{@link com.codahale.metrics.Timer}> * @param duration * @param unit */ public static void updateTimer(Optional<Timer> timer, final long duration, final TimeUnit unit) { timer.transform(new Function<Timer, Timer>() { @Override public Timer apply(@Nonnull Timer input) { input.update(duration, unit); return input; } }); }
private void initPattern(String patternString) { this.pattern = Optional.of(patternString).transform(new Function<String, Pattern>() { @Nullable @Override public Pattern apply(String input) { return Pattern.compile(input); } }); }
public final Optional<HttpsCertificate> getHttpsCertificate() { return httpsArg.transform(toCertificate()); }
@Override public String getFallbackName(Class<?> enclosingType, Method commandMethod) { String commandDefaultFallback = commandMethod.getAnnotation(HystrixCommand.class).defaultFallback(); String classDefaultFallback = Optional.fromNullable(enclosingType.getAnnotation(DefaultProperties.class)) .transform(new Function<DefaultProperties, String>() { @Override public String apply(DefaultProperties input) { return input.defaultFallback(); } }).or(StringUtils.EMPTY); return StringUtils.defaultIfEmpty(commandDefaultFallback, classDefaultFallback); }
public void testTransform_absent_functionReturnsNull() { assertEquals( Optional.absent(), Optional.absent() .transform( new Function<Object, Object>() { @Override public Object apply(Object input) { return null; } })); }
public void testTransform_present_functionReturnsNull() { try { Optional<String> unused = Optional.of("a") .transform( new Function<String, String>() { @Override public String apply(String input) { return null; } }); fail("Should throw if Function returns null."); } catch (NullPointerException expected) { } }
@SuppressWarnings("unused") @Subscribe public void handleNewContainerRequest(NewContainerRequest newContainerRequest) { if (!this.maxResourceCapacity.isPresent()) { LOGGER.error(String.format( "Unable to handle new container request as maximum resource capacity is not available: " + "[memory (MBs) requested = %d, vcores requested = %d]", this.requestedContainerMemoryMbs, this.requestedContainerCores)); return; } requestContainer(newContainerRequest.getReplacedContainer().transform(new Function<Container, String>() { @Override public String apply(Container container) { return container.getNodeId().getHost(); } })); }
public void testTransform_presentToString() { assertEquals(Optional.of("42"), Optional.of(42).transform(Functions.toStringFunction())); }
private Optional<SslHandler> sslHandler() { return serverSetting.getCertificate().transform(toSslHandler()); }
public void testTransform_presentIdentity() { assertEquals(Optional.of("a"), Optional.of("a").transform(Functions.identity())); }
@Value.Lazy public Optional<StyleInfo> style() { Optional<StyleInfo> style = StyleMirror.find(element()).transform(ToStyleInfo.FUNCTION); if (style.isPresent()) { return style; } for (MetaAnnotated m : metaAnnotated()) { Optional<StyleInfo> metaStyle = m.style(); if (metaStyle.isPresent()) { return metaStyle; } } return Optional.absent(); }
@Value.Derived @Value.Auxiliary public Optional<StyleInfo> style() { return StyleMirror.find(element()).transform(ToStyleInfo.FUNCTION); }
@Value.Derived @Value.Auxiliary public Optional<InjectionInfo> injectAnnotation() { if (environment().hasAnnotateModule()) { return InjectAnnotationMirror.find(element()) .transform(ToInjectionInfo.FUNCTION); } return Optional.absent(); }
@Value.Lazy public Optional<ValueImmutableInfo> features() { Optional<ValueImmutableInfo> immutableAnnotation = ImmutableMirror.find(element()).transform(ToImmutableInfo.FUNCTION); if (immutableAnnotation.isPresent()) { return immutableAnnotation; } for (String a : environment().round().customImmutableAnnotations()) { if (isAnnotatedWith(element(), a)) { return Optional.of(environment().defaultStyles().defaults()); } } return Optional.absent(); }
@Override public List<JCStatement> inlineStatements(final Inliner inliner) throws CouldNotResolveImportException { try { Optional<List<JCStatement>> binding = inliner.getOptionalBinding(placeholder().blockKey()); // If a placeholder was used as an expression binding in the @BeforeTemplate, // and as a bare statement or as a return in the @AfterTemplate, we may need to convert. Optional<JCExpression> exprBinding = inliner.getOptionalBinding(placeholder().exprKey()); binding = binding.or( exprBinding.transform( (JCExpression expr) -> { switch (implementationFlow()) { case NEVER_EXITS: return List.of((JCStatement) inliner.maker().Exec(expr)); case ALWAYS_RETURNS: return List.of((JCStatement) inliner.maker().Return(expr)); default: throw new AssertionError(); } })); return UPlaceholderExpression.copier(arguments(), inliner).copy(binding.get(), inliner); } catch (UncheckedCouldNotResolveImportException e) { throw e.getCause(); } } }