public ReactiveSeq<Tuple2<String,String>> extractResources() { return resources.stream().peek(resource -> logMissingPath(resource)) .filter(resource-> resource.getClass().getAnnotation(Path.class)!=null) .map(resource -> Tuple.tuple(resource.getClass().getName(), resource.getClass().getAnnotation(Path.class).value())); }
@Override public LinkedHashMap<Class<? extends Exception>, Tuple2<String, Status>> getErrorMappings() { LinkedHashMap<Class<? extends Exception>, Tuple2<String, Status>> map = new LinkedHashMap<>(); map.put(MyException.class, Tuple.tuple("my-error",Status.BAD_GATEWAY)); return map; }
public MicroserverEnvironment(Properties propertyFactory, Collection<ModuleBean> modules) { modulePort = HashMap.fromStream(modules.stream().map(m-> tuple(m.getModule().getContext(),m))); this.properties = propertyFactory; }
@Override public Response toResponse(final Exception ex) { final String errorTrackingId = UUID.randomUUID().toString(); Tuple2<String, Status> error = new Tuple2<>(MapOfExceptionsToErrorCodes.INTERNAL_SERVER_ERROR, Status.INTERNAL_SERVER_ERROR); Optional<Tuple2<String, Status>> errorFromLookup = find(ex.getClass()); if (errorFromLookup.isPresent()) { error = errorFromLookup.get(); } else { if(ex instanceof javax.ws.rs.WebApplicationException){ javax.ws.rs.WebApplicationException rsEx = ((javax.ws.rs.WebApplicationException)ex); error = tuple(rsEx.getResponse().getStatusInfo().getReasonPhrase(),Status.fromStatusCode(rsEx.getResponse().getStatus())); } } logger.error(String.format("%s Error id: %s, %s", error._1(), errorTrackingId, ex.getMessage()), ex); Response.ResponseBuilder responseBuilder = Response.status(error._2()).type(MediaType.APPLICATION_JSON_TYPE); if (showDetails) { responseBuilder.entity(new ExceptionWrapper(error._1(), String.format("Error id: %s %s", errorTrackingId, ex.getMessage()))); } else { responseBuilder.entity(new ExceptionWrapper(MapOfExceptionsToErrorCodes.INTERNAL_SERVER_ERROR, errorTrackingId)); } return responseBuilder.build(); } }
@Override public Future<T> loadAndGet() { String correlationId = "" + System.currentTimeMillis() + ":" + r.nextLong(); Supplier<MapX<String, String>> dataMap = () -> MapX.fromMap(HashMapBuilder.map(MANIFEST_COMPARATOR_DATA_LOADER_KEY, comparator.toString()) .build()); return Future.of(() -> Tuple.tuple(comparator.load(), comparator.getData()), executorService) .peek(t -> bus.post(SystemData.<String, String> builder() .correlationId(correlationId) .dataMap(dataMap.get()) .errors(0) .processed(t._1() ? 1 : 0) .build())) // add // recover // option // here // also // with // cyclops-react // 1.0.0-final .map(t -> t._2()); }
@Override public Tuple1<Node<K, V>[]> unapply() { return Tuple.tuple(nodes); } }
@Override public Tuple2<ReactiveSeq<T>, ReactiveSeq<T>> partition(final Predicate<? super T> splitter) { final Tuple2<ReactiveSeq<T>, ReactiveSeq<T>> Tuple2 = duplicate(); return Tuple.tuple( Tuple2._1().filter(splitter), Tuple2._2().filter(splitter.negate())); } @Override
@Override public Tuple2<ReactiveSeq<T>, ReactiveSeq<T>> splitAt(final int where) { final Tuple2<ReactiveSeq<T>, ReactiveSeq<T>> Tuple2 = duplicate(); return Tuple.tuple( Tuple2._1().limit(where), Tuple2._2().skip(where)); }
@Test public void testUnzipWithLimits() { Supplier<Streamable<Tuple2<Integer, String>>> s = () -> of(Tuple.tuple(1, "a"), Tuple.tuple(2, "b"), Tuple.tuple(3, "c")); Tuple2<Streamable<Integer>, Streamable<String>> u1 = Streamable.unzip(s.get()); assertTrue(u1._1().limit(2).toList().containsAll(Arrays.asList(1, 2))); assertTrue(u1._2().toList().containsAll(asList("a", "b", "c"))); }
@Override public Node<K, V> plus(int bitShiftDepth, int hash, K key, V value) { ImmutableList<Tuple2<K, V>> filtered = bucket.filter(t -> !Objects.equals(key, t._1())); if (this.hash == hash) { return filtered.size() == 0 ? new ValueNode<>(hash, key, value) : new CollisionNode<>(hash, filtered.prepend(Tuple.tuple(key, value))); } return merge(bitShiftDepth, hash, new ValueNode<>(hash, key, value)); }
@Test public void splitAtTest(){ assertThat(of(1,2,3).splitAt(4) ,equalTo(Tuple.tuple(of(1,2,3),of()))); assertThat(of(1,2,3).splitAt(3) ,equalTo(Tuple.tuple(of(1,2,3),of()))); assertThat(of(1,2,3).splitAt(2) ,equalTo(Tuple.tuple(of(1,2),of(3)))); assertThat(of(1,2,3).splitAt(1) ,equalTo(Tuple.tuple(of(1),of(2,3)))); assertThat(of(1,2,3).splitAt(0) ,equalTo(Tuple.tuple(of(),of(1,2,3)))); assertThat(of(1,2,3).splitAt(-1) ,equalTo(Tuple.tuple(of(),of(1,2,3)))); } @Test
@Test public void splitAtTest(){ assertThat(of(1,2,3).splitAt(4) ,equalTo(Tuple.tuple(of(1,2,3),of()))); assertThat(of(1,2,3).splitAt(3) ,equalTo(Tuple.tuple(of(1,2,3),of()))); assertThat(of(1,2,3).splitAt(2) ,equalTo(Tuple.tuple(of(1,2),of(3)))); assertThat(of(1,2,3).splitAt(1) ,equalTo(Tuple.tuple(of(1),of(2,3)))); assertThat(of(1,2,3).splitAt(0) ,equalTo(Tuple.tuple(of(),of(1,2,3)))); assertThat(of(1,2,3).splitAt(-1) ,equalTo(Tuple.tuple(of(),of(1,2,3)))); } @Test
@Test public void testUnfold(){ Function<Integer,Option<Tuple2<Integer,Integer>>> fn= i-> i<=6 ? Option.of(Tuple.tuple(i,i+1)) : Option.none(); assertThat(unfold(1,fn ).size(),equalTo(6)); }
@Test public void unevenTest(){ assertEquals(asList(tuple("a", 0L)), of("a","b","c").zip(of(0L)).toList()); } @Test
@Override public Tuple2<ReactiveSeq<T>, ReactiveSeq<T>> duplicate() { Seq<Iterable<T>> copy = Streams.toBufferingCopier(() -> Spliterators.iterator(copy()), 2); return Tuple.tuple(createSeq(new IteratableSpliterator<>(copy.getOrElseGet(0,()->ReactiveSeq.empty()))), createSeq(new IteratableSpliterator<>(copy.getOrElseGet(1,()->ReactiveSeq.empty())))); } @Override
@Override public Tuple2<ReactiveSeq<T>, ReactiveSeq<T>> duplicate(Supplier<Deque<T>> bufferFactory) { Seq<Iterable<T>> copy = Streams.toBufferingCopier(() -> Spliterators.iterator(copy()), 2,bufferFactory); return Tuple.tuple(createSeq(new IteratableSpliterator<>(copy.getOrElseGet(0,()->ReactiveSeq.empty()))), createSeq(new IteratableSpliterator<>(copy.getOrElseGet(1,()->ReactiveSeq.empty())))); }
@Test public void testZipWithIndex() { assertEquals(asList(), of().zipWithIndex().toList()); assertThat(of("a").zipWithIndex().map(t -> t._2()).headOption().orElse(-1l), is(0l)); assertEquals(asList(Tuple.tuple("a", 0L)), of("a").zipWithIndex().toList()); }
@Override @SuppressWarnings("unchecked") public Tuple4<ReactiveSeq<T>, ReactiveSeq<T>, ReactiveSeq<T>, ReactiveSeq<T>> quadruplicate(Supplier<Deque<T>> bufferFactory) { Seq<Iterable<T>> copy = Streams.toBufferingCopier(() -> Spliterators.iterator(copy()), 4,bufferFactory); return Tuple.tuple(createSeq(new IteratableSpliterator<>(copy.getOrElseGet(0,()->ReactiveSeq.empty()))), createSeq(new IteratableSpliterator<>(copy.getOrElseGet(1,()->ReactiveSeq.empty()))), createSeq(new IteratableSpliterator<>(copy.getOrElseGet(2,()->ReactiveSeq.empty()))), createSeq(new IteratableSpliterator<>(copy.getOrElseGet(3,()->ReactiveSeq.empty())))); }