Java 类java.util.Spliterators 实例源码

@Test
public void testSpliteratorAIOBEsFromSpliterators() {
    // origin > fence
    assertThrowsAIOOB(() -> Spliterators.spliterator(new int[]{}, 1, 0, 0));
    assertThrowsAIOOB(() -> Spliterators.spliterator(new long[]{}, 1, 0, 0));
    assertThrowsAIOOB(() -> Spliterators.spliterator(new double[]{}, 1, 0, 0));
    assertThrowsAIOOB(() -> Spliterators.spliterator(new String[]{}, 1, 0, 0));

    // bad origin
    assertThrowsAIOOB(() -> Spliterators.spliterator(new int[]{}, -1, 0, 0));
    assertThrowsAIOOB(() -> Spliterators.spliterator(new long[]{}, -1, 0, 0));
    assertThrowsAIOOB(() -> Spliterators.spliterator(new double[]{}, -1, 0, 0));
    assertThrowsAIOOB(() -> Spliterators.spliterator(new String[]{}, -1, 0, 0));

    // bad fence
    assertThrowsAIOOB(() -> Spliterators.spliterator(new int[]{}, 0, 1, 0));
    assertThrowsAIOOB(() -> Spliterators.spliterator(new long[]{}, 0, 1, 0));
    assertThrowsAIOOB(() -> Spliterators.spliterator(new double[]{}, 0, 1, 0));
    assertThrowsAIOOB(() -> Spliterators.spliterator(new String[]{}, 0, 1, 0));
}

@Test
public void testSpliteratorAIOBEsFromSpliterators() {
    // origin > fence
    assertThrowsAIOOB(() -> Spliterators.spliterator(new int[]{}, 1, 0, 0));
    assertThrowsAIOOB(() -> Spliterators.spliterator(new long[]{}, 1, 0, 0));
    assertThrowsAIOOB(() -> Spliterators.spliterator(new double[]{}, 1, 0, 0));
    assertThrowsAIOOB(() -> Spliterators.spliterator(new String[]{}, 1, 0, 0));

    // bad origin
    assertThrowsAIOOB(() -> Spliterators.spliterator(new int[]{}, -1, 0, 0));
    assertThrowsAIOOB(() -> Spliterators.spliterator(new long[]{}, -1, 0, 0));
    assertThrowsAIOOB(() -> Spliterators.spliterator(new double[]{}, -1, 0, 0));
    assertThrowsAIOOB(() -> Spliterators.spliterator(new String[]{}, -1, 0, 0));

    // bad fence
    assertThrowsAIOOB(() -> Spliterators.spliterator(new int[]{}, 0, 1, 0));
    assertThrowsAIOOB(() -> Spliterators.spliterator(new long[]{}, 0, 1, 0));
    assertThrowsAIOOB(() -> Spliterators.spliterator(new double[]{}, 0, 1, 0));
    assertThrowsAIOOB(() -> Spliterators.spliterator(new String[]{}, 0, 1, 0));
}

public Spliterator<E> trySplit() {
    Node<E> p, q;
    if ((p = current()) == null || (q = p.next) == null)
        return null;
    int i = 0, n = batch = Math.min(batch + 1, MAX_BATCH);
    Object[] a = null;
    do {
        final E e;
        if ((e = p.item) != null) {
            if (a == null)
                a = new Object[n];
            a[i++] = e;
        }
        if (p == (p = q))
            p = first();
    } while (p != null && (q = p.next) != null && i < n);
    setCurrent(p);
    return (i == 0) ? null :
        Spliterators.spliterator(a, 0, i, (Spliterator.ORDERED |
                                           Spliterator.NONNULL |
                                           Spliterator.CONCURRENT));
}

/**
 * Returns an infinite sequential ordered {@code Stream} produced by iterative
 * application of a function {@code f} to an initial element {@code seed},
 * producing a {@code Stream} consisting of {@code seed}, {@code f(seed)},
 * {@code f(f(seed))}, etc.
 *
 * <p>The first element (position {@code 0}) in the {@code Stream} will be
 * the provided {@code seed}.  For {@code n > 0}, the element at position
 * {@code n}, will be the result of applying the function {@code f} to the
 * element at position {@code n - 1}.
 *
 * @param <T> the type of stream elements
 * @param seed the initial element
 * @param f a function to be applied to to the previous element to produce
 *          a new element
 * @return a new sequential {@code Stream}
 */
public static<T> Stream<T> iterate(final T seed, final UnaryOperator<T> f) {
    Objects.requireNonNull(f);
    final Iterator<T> iterator = new Iterator<T>() {
        @SuppressWarnings("unchecked")
        T t = (T) Streams.NONE;

        @Override
        public boolean hasNext() {
            return true;
        }

        @Override
        public T next() {
            return t = (t == Streams.NONE) ? seed : f.apply(t);
        }
    };
    return StreamSupport.stream(Spliterators.spliteratorUnknownSize(
            iterator,
            Spliterator.ORDERED | Spliterator.IMMUTABLE), false);
}

/**
 * Returns an infinite sequential ordered {@code LongStream} produced by iterative
 * application of a function {@code f} to an initial element {@code seed},
 * producing a {@code Stream} consisting of {@code seed}, {@code f(seed)},
 * {@code f(f(seed))}, etc.
 *
 * <p>The first element (position {@code 0}) in the {@code LongStream} will
 * be the provided {@code seed}.  For {@code n > 0}, the element at position
 * {@code n}, will be the result of applying the function {@code f} to the
 * element at position {@code n - 1}.
 *
 * @param seed the initial element
 * @param f a function to be applied to to the previous element to produce
 *          a new element
 * @return a new sequential {@code LongStream}
 */
public static LongStream iterate(final long seed, final LongUnaryOperator f) {
    Objects.requireNonNull(f);
    final PrimitiveIterator.OfLong iterator = new PrimitiveIterator.OfLong() {
        long t = seed;

        @Override
        public boolean hasNext() {
            return true;
        }

        @Override
        public long nextLong() {
            long v = t;
            t = f.applyAsLong(t);
            return v;
        }
    };
    return StreamSupport.longStream(Spliterators.spliteratorUnknownSize(
            iterator,
            Spliterator.ORDERED | Spliterator.IMMUTABLE | Spliterator.NONNULL), false);
}

/**
 * Returns an infinite sequential ordered {@code DoubleStream} produced by iterative
 * application of a function {@code f} to an initial element {@code seed},
 * producing a {@code Stream} consisting of {@code seed}, {@code f(seed)},
 * {@code f(f(seed))}, etc.
 *
 * <p>The first element (position {@code 0}) in the {@code DoubleStream}
 * will be the provided {@code seed}.  For {@code n > 0}, the element at
 * position {@code n}, will be the result of applying the function {@code f}
 *  to the element at position {@code n - 1}.
 *
 * @param seed the initial element
 * @param f a function to be applied to to the previous element to produce
 *          a new element
 * @return a new sequential {@code DoubleStream}
 */
public static DoubleStream iterate(final double seed, final DoubleUnaryOperator f) {
    Objects.requireNonNull(f);
    final PrimitiveIterator.OfDouble iterator = new PrimitiveIterator.OfDouble() {
        double t = seed;

        @Override
        public boolean hasNext() {
            return true;
        }

        @Override
        public double nextDouble() {
            double v = t;
            t = f.applyAsDouble(t);
            return v;
        }
    };
    return StreamSupport.doubleStream(Spliterators.spliteratorUnknownSize(
            iterator,
            Spliterator.ORDERED | Spliterator.IMMUTABLE | Spliterator.NONNULL), false);
}

/**
 * Returns an infinite sequential ordered {@code LongStream} produced by iterative
 * application of a function {@code f} to an initial element {@code seed},
 * producing a {@code Stream} consisting of {@code seed}, {@code f(seed)},
 * {@code f(f(seed))}, etc.
 *
 * <p>The first element (position {@code 0}) in the {@code LongStream} will
 * be the provided {@code seed}.  For {@code n > 0}, the element at position
 * {@code n}, will be the result of applying the function {@code f} to the
 * element at position {@code n - 1}.
 *
 * <p>The action of applying {@code f} for one element
 * <a href="../concurrent/package-summary.html#MemoryVisibility"><i>happens-before</i></a>
 * the action of applying {@code f} for subsequent elements.  For any given
 * element the action may be performed in whatever thread the library
 * chooses.
 *
 * @param seed the initial element
 * @param f a function to be applied to the previous element to produce
 *          a new element
 * @return a new sequential {@code LongStream}
 */
public static LongStream iterate(final long seed, final LongUnaryOperator f) {
    Objects.requireNonNull(f);
    Spliterator.OfLong spliterator = new Spliterators.AbstractLongSpliterator(Long.MAX_VALUE,
           Spliterator.ORDERED | Spliterator.IMMUTABLE | Spliterator.NONNULL) {
        long prev;
        boolean started;

        @Override
        public boolean tryAdvance(LongConsumer action) {
            Objects.requireNonNull(action);
            long t;
            if (started)
                t = f.applyAsLong(prev);
            else {
                t = seed;
                started = true;
            }
            action.accept(prev = t);
            return true;
        }
    };
    return StreamSupport.longStream(spliterator, false);
}

/**
 * Adapted from StackOverflow {@linkplain so http://stackoverflow.com/questions/20746429/limit-a-stream-by-a-predicate}
 *
 * @param splitr the original Spliterator
 * @param predicate the predicate
 * @return a Spliterator.OfInt
 */
private static Spliterator.OfInt takeIntWhile(Spliterator.OfInt splitr, IntPredicate predicate) {
    return new Spliterators.AbstractIntSpliterator(splitr.estimateSize(), 0) {
        boolean stillGoing = true;

        @Override
        public boolean tryAdvance(IntConsumer consumer) {
            if (stillGoing) {
                boolean hadNext = splitr.tryAdvance((int elem) -> {
                    if (predicate.test(elem)) {
                        consumer.accept(elem);
                    } else {
                        stillGoing = false;
                    }
                });
                return hadNext && stillGoing;
            }
            return false;
        }
    };
}

/**
 * Returns an infinite sequential ordered {@code Stream} produced by iterative
 * application of a function {@code f} to an initial element {@code seed},
 * producing a {@code Stream} consisting of {@code seed}, {@code f(seed)},
 * {@code f(f(seed))}, etc.
 *
 * <p>The first element (position {@code 0}) in the {@code Stream} will be
 * the provided {@code seed}.  For {@code n > 0}, the element at position
 * {@code n}, will be the result of applying the function {@code f} to the
 * element at position {@code n - 1}.
 *
 * @param <T> the type of stream elements
 * @param seed the initial element
 * @param f a function to be applied to to the previous element to produce
 *          a new element
 * @return a new sequential {@code Stream}
 */
public static<T> Stream<T> iterate(final T seed, final UnaryOperator<T> f) {
    Objects.requireNonNull(f);
    final Iterator<T> iterator = new Iterator<T>() {
        @SuppressWarnings("unchecked")
        T t = (T) Streams.NONE;

        @Override
        public boolean hasNext() {
            return true;
        }

        @Override
        public T next() {
            return t = (t == Streams.NONE) ? seed : f.apply(t);
        }
    };
    return StreamSupport.stream(Spliterators.spliteratorUnknownSize(
            iterator,
            Spliterator.ORDERED | Spliterator.IMMUTABLE), false);
}

/**
 * Returns an infinite sequential ordered {@code IntStream} produced by iterative
 * application of a function {@code f} to an initial element {@code seed},
 * producing a {@code Stream} consisting of {@code seed}, {@code f(seed)},
 * {@code f(f(seed))}, etc.
 *
 * <p>The first element (position {@code 0}) in the {@code IntStream} will be
 * the provided {@code seed}.  For {@code n > 0}, the element at position
 * {@code n}, will be the result of applying the function {@code f} to the
 * element at position {@code n - 1}.
 *
 * @param seed the initial element
 * @param f a function to be applied to to the previous element to produce
 *          a new element
 * @return A new sequential {@code IntStream}
 */
public static IntStream iterate(final int seed, final IntUnaryOperator f) {
    Objects.requireNonNull(f);
    final PrimitiveIterator.OfInt iterator = new PrimitiveIterator.OfInt() {
        int t = seed;

        @Override
        public boolean hasNext() {
            return true;
        }

        @Override
        public int nextInt() {
            int v = t;
            t = f.applyAsInt(t);
            return v;
        }
    };
    return StreamSupport.intStream(Spliterators.spliteratorUnknownSize(
            iterator,
            Spliterator.ORDERED | Spliterator.IMMUTABLE | Spliterator.NONNULL), false);
}

/**
 * Returns a {@code Stream}, the elements of which are lines read from
 * this {@code BufferedReader}.  The {@link Stream} is lazily populated,
 * i.e., read only occurs during the
 * <a href="../util/stream/package-summary.html#StreamOps">terminal
 * stream operation</a>.
 *
 * <p> The reader must not be operated on during the execution of the
 * terminal stream operation. Otherwise, the result of the terminal stream
 * operation is undefined.
 *
 * <p> After execution of the terminal stream operation there are no
 * guarantees that the reader will be at a specific position from which to
 * read the next character or line.
 *
 * <p> If an {@link IOException} is thrown when accessing the underlying
 * {@code BufferedReader}, it is wrapped in an {@link
 * UncheckedIOException} which will be thrown from the {@code Stream}
 * method that caused the read to take place. This method will return a
 * Stream if invoked on a BufferedReader that is closed. Any operation on
 * that stream that requires reading from the BufferedReader after it is
 * closed, will cause an UncheckedIOException to be thrown.
 *
 * @return a {@code Stream<String>} providing the lines of text
 *         described by this {@code BufferedReader}
 *
 * @since 1.8
 */
public Stream<String> lines() {
    Iterator<String> iter = new Iterator<String>() {
        String nextLine = null;

        @Override
        public boolean hasNext() {
            if (nextLine != null) {
                return true;
            } else {
                try {
                    nextLine = readLine();
                    return (nextLine != null);
                } catch (IOException e) {
                    throw new UncheckedIOException(e);
                }
            }
        }

        @Override
        public String next() {
            if (nextLine != null || hasNext()) {
                String line = nextLine;
                nextLine = null;
                return line;
            } else {
                throw new NoSuchElementException();
            }
        }
    };
    return StreamSupport.stream(Spliterators.spliteratorUnknownSize(
            iter, Spliterator.ORDERED | Spliterator.NONNULL), false);
}

public static <T> Stream<T> enumerationAsStream(Enumeration<T> e) {
    return StreamSupport.stream(
            Spliterators.spliteratorUnknownSize(
                    new Iterator<T>() {
                public T next() {
                    return e.nextElement();
                }

                public boolean hasNext() {
                    return e.hasMoreElements();
                }
            }, Spliterator.ORDERED), false);
}

@Test
public void testSpliteratorNPEsFromSpliterators() {
    assertThrowsNPE(() -> Spliterators.spliterator((int[]) null, 0, 0, 0));
    assertThrowsNPE(() -> Spliterators.spliterator((long[]) null, 0, 0, 0));
    assertThrowsNPE(() -> Spliterators.spliterator((double[]) null, 0, 0, 0));
    assertThrowsNPE(() -> Spliterators.spliterator((String[]) null, 0, 0, 0));
}

/**
 * Returns a stream in which each element is the result of passing the corresponding elementY of
 * each of {@code streamA} and {@code streamB} to {@code function}.
 *
 * <p>For example:
 *
 * <pre>{@code
 * Streams.zip(
 *   Stream.of("foo1", "foo2", "foo3"),
 *   Stream.of("bar1", "bar2"),
 *   (arg1, arg2) -> arg1 + ":" + arg2)
 * }</pre>
 *
 * <p>will return {@code Stream.of("foo1:bar1", "foo2:bar2")}.
 *
 * <p>The resulting stream will only be as long as the shorter of the two input streams; if one
 * stream is longer, its extra elements will be ignored.
 *
 * <p>Note that if you are calling {@link Stream#forEach} on the resulting stream, you might want
 * to consider using {@link #forEachPair} instead of this method.
 *
 * <p><b>Performance note:</b> The resulting stream is not <a
 * href="http://gee.cs.oswego.edu/dl/html/StreamParallelGuidance.html">efficiently splittable</a>.
 * This may harm parallel performance.
 */
public static <A, B, R> Stream<R> zip(
    Stream<A> streamA, Stream<B> streamB, BiFunction<? super A, ? super B, R> function) {
  checkNotNull(streamA);
  checkNotNull(streamB);
  checkNotNull(function);
  boolean isParallel = streamA.isParallel() || streamB.isParallel(); // same as Stream.concat
  Spliterator<A> splitrA = streamA.spliterator();
  Spliterator<B> splitrB = streamB.spliterator();
  int characteristics =
      splitrA.characteristics()
          & splitrB.characteristics()
          & (Spliterator.SIZED | Spliterator.ORDERED);
  Iterator<A> itrA = Spliterators.iterator(splitrA);
  Iterator<B> itrB = Spliterators.iterator(splitrB);
  return StreamSupport.stream(
      new AbstractSpliterator<R>(
          Math.min(splitrA.estimateSize(), splitrB.estimateSize()), characteristics) {
        @Override
        public boolean tryAdvance(Consumer<? super R> action) {
          if (itrA.hasNext() && itrB.hasNext()) {
            action.accept(function.apply(itrA.next(), itrB.next()));
            return true;
          }
          return false;
        }
      },
      isParallel);
}

@Override
Spliterator<Entry<C, V>> entrySpliterator() {
  Map<C, V> map = backingRowMap();
  if (map == null) {
    return Spliterators.emptySpliterator();
  }
  return CollectSpliterators.map(map.entrySet().spliterator(), this::wrapEntry);
}

/**
 * Returns a {@code Stream}, the elements of which are lines read from
 * this {@code BufferedReader}.  The {@link Stream} is lazily populated,
 * i.e., read only occurs during the
 * <a href="../util/stream/package-summary.html#StreamOps">terminal
 * stream operation</a>.
 *
 * <p> The reader must not be operated on during the execution of the
 * terminal stream operation. Otherwise, the result of the terminal stream
 * operation is undefined.
 *
 * <p> After execution of the terminal stream operation there are no
 * guarantees that the reader will be at a specific position from which to
 * read the next character or line.
 *
 * <p> If an {@link IOException} is thrown when accessing the underlying
 * {@code BufferedReader}, it is wrapped in an {@link
 * UncheckedIOException} which will be thrown from the {@code Stream}
 * method that caused the read to take place. This method will return a
 * Stream if invoked on a BufferedReader that is closed. Any operation on
 * that stream that requires reading from the BufferedReader after it is
 * closed, will cause an UncheckedIOException to be thrown.
 *
 * @return a {@code Stream<String>} providing the lines of text
 *         described by this {@code BufferedReader}
 *
 * @since 1.8
 */
public Stream<String> lines() {
    Iterator<String> iter = new Iterator<>() {
        String nextLine = null;

        @Override
        public boolean hasNext() {
            if (nextLine != null) {
                return true;
            } else {
                try {
                    nextLine = readLine();
                    return (nextLine != null);
                } catch (IOException e) {
                    throw new UncheckedIOException(e);
                }
            }
        }

        @Override
        public String next() {
            if (nextLine != null || hasNext()) {
                String line = nextLine;
                nextLine = null;
                return line;
            } else {
                throw new NoSuchElementException();
            }
        }
    };
    return StreamSupport.stream(Spliterators.spliteratorUnknownSize(
            iter, Spliterator.ORDERED | Spliterator.NONNULL), false);
}

/**
 * Return a stream with the data lines.
 *
 * @return a stream with the data lines
 */
public Stream<String[]> stream() {
    final DataIterator iterator = new DataIterator(getResourcePath());
    final Spliterator<String[]> spliterator = Spliterators
        .spliteratorUnknownSize(iterator, 0);

    return StreamSupport
        .stream(spliterator, false)
        .onClose(iterator::close);
}

public Spliterator<E> trySplit() {
    Node<E> h;
    final LinkedBlockingDeque<E> q = this.queue;
    int b = batch;
    int n = (b <= 0) ? 1 : (b >= MAX_BATCH) ? MAX_BATCH : b + 1;
    if (!exhausted &&
        ((h = current) != null || (h = q.first) != null) &&
        h.next != null) {
        Object[] a = new Object[n];
        final ReentrantLock lock = q.lock;
        int i = 0;
        Node<E> p = current;
        lock.lock();
        try {
            if (p != null || (p = q.first) != null) {
                do {
                    if ((a[i] = p.item) != null)
                        ++i;
                } while ((p = p.next) != null && i < n);
            }
        } finally {
            lock.unlock();
        }
        if ((current = p) == null) {
            est = 0L;
            exhausted = true;
        }
        else if ((est -= i) < 0L)
            est = 0L;
        if (i > 0) {
            batch = i;
            return Spliterators.spliterator
                (a, 0, i, Spliterator.ORDERED | Spliterator.NONNULL |
                 Spliterator.CONCURRENT);
        }
    }
    return null;
}

/**
 * Get the value for the streaming member in the {@link JsonNode}.
 */
public String getStreamingMemberValue() {
    return StreamSupport.stream(Spliterators.spliteratorUnknownSize(input.fields(), Spliterator.ORDERED), false)
                        .filter(f -> model.getShapes().get(shapeName)
                                          .getMemberByC2jName(f.getKey())
                                          .getHttp().getIsStreaming())
                        .map(f -> f.getValue().asText())
                        .findFirst()
                        .orElseThrow(() -> new IllegalStateException("Streaming member not found in " + shapeName));
}

SortedTestData(List<T> coll) {
    super("SortedTestData", coll,
          c -> StreamSupport.stream(Spliterators.spliterator(c.toArray(), Spliterator.ORDERED | Spliterator.SORTED), false),
          c -> StreamSupport.stream(Spliterators.spliterator(c.toArray(), Spliterator.ORDERED | Spliterator.SORTED), true),
          c -> Spliterators.spliterator(c.toArray(), Spliterator.ORDERED | Spliterator.SORTED),
          List::size);
}

private static <T> Stream<T> streamFromArray(T[] a) {
    return StreamSupport.stream(
            Spliterators.spliterator(
                    a,
                    Spliterator.DISTINCT | Spliterator.IMMUTABLE | Spliterator.NONNULL),
            false);
}

public Spliterator<E> trySplit() {
    Node<E> h;
    final LinkedBlockingDeque<E> q = this.queue;
    int b = batch;
    int n = (b <= 0) ? 1 : (b >= MAX_BATCH) ? MAX_BATCH : b + 1;
    if (!exhausted &&
        ((h = current) != null || (h = q.first) != null) &&
        h.next != null) {
        Object[] a = new Object[n];
        final ReentrantLock lock = q.lock;
        int i = 0;
        Node<E> p = current;
        lock.lock();
        try {
            if (p != null || (p = q.first) != null) {
                do {
                    if ((a[i] = p.item) != null)
                        ++i;
                } while ((p = p.next) != null && i < n);
            }
        } finally {
            lock.unlock();
        }
        if ((current = p) == null) {
            est = 0L;
            exhausted = true;
        }
        else if ((est -= i) < 0L)
            est = 0L;
        if (i > 0) {
            batch = i;
            return Spliterators.spliterator
                (a, 0, i, Spliterator.ORDERED | Spliterator.NONNULL |
                 Spliterator.CONCURRENT);
        }
    }
    return null;
}

public Spliterator<E> trySplit() {
    Node p;
    final LinkedTransferQueue<E> q = this.queue;
    int b = batch;
    int n = (b <= 0) ? 1 : (b >= MAX_BATCH) ? MAX_BATCH : b + 1;
    if (!exhausted &&
        ((p = current) != null || (p = q.firstDataNode()) != null) &&
        p.next != null) {
        Object[] a = new Object[n];
        int i = 0;
        do {
            if ((a[i] = p.item) != null)
                ++i;
            if (p == (p = p.next))
                p = q.firstDataNode();
        } while (p != null && i < n);
        if ((current = p) == null)
            exhausted = true;
        if (i > 0) {
            batch = i;
            return Spliterators.spliterator
                (a, 0, i, Spliterator.ORDERED | Spliterator.NONNULL |
                 Spliterator.CONCURRENT);
        }
    }
    return null;
}

/**
 * Gets load statistics for all links or for a specific link.
 *
 * @onos.rsModel StatisticsFlowsLink
 * @param deviceId (optional) device ID for a specific link
 * @param port (optional) port number for a specified link
 * @return 200 OK with JSON encoded array of Load objects
 */
@GET
@Path("flows/link")
@Produces(MediaType.APPLICATION_JSON)
public Response getLoads(@QueryParam("device") String deviceId,
                         @QueryParam("port") String port) {
    Iterable<Link> links;

    if (deviceId == null || port == null) {
        links = get(LinkService.class).getLinks();
    } else {
        ConnectPoint connectPoint = new ConnectPoint(deviceId(deviceId),
                portNumber(port));
        links = get(LinkService.class).getLinks(connectPoint);
    }
    ObjectNode result = mapper().createObjectNode();
    ArrayNode loads = mapper().createArrayNode();
    JsonCodec<Load> loadCodec = codec(Load.class);
    StatisticService statsService = getService(StatisticService.class);

    StreamSupport.stream(Spliterators.spliteratorUnknownSize(
            links.iterator(), Spliterator.ORDERED), false)
            .forEach(link -> {
                ObjectNode loadNode = loadCodec.encode(statsService.load(link), this);

                UriBuilder locationBuilder = uriInfo.getBaseUriBuilder()
                        .path("links")
                        .queryParam("device", link.src().deviceId().toString())
                        .queryParam("port", link.src().port().toString());
                loadNode.put("link", locationBuilder.build().toString());
                loads.add(loadNode);
            });
    result.set("loads", loads);
    return ok(result).build();
}

public Spliterator<E> trySplit() {
    Node<E> h;
    if (!exhausted &&
        ((h = current) != null || (h = head.next) != null)
        && h.next != null) {
        int n = batch = Math.min(batch + 1, MAX_BATCH);
        Object[] a = new Object[n];
        int i = 0;
        Node<E> p = current;
        fullyLock();
        try {
            if (p != null || (p = head.next) != null)
                for (; p != null && i < n; p = succ(p))
                    if ((a[i] = p.item) != null)
                        i++;
        } finally {
            fullyUnlock();
        }
        if ((current = p) == null) {
            est = 0L;
            exhausted = true;
        }
        else if ((est -= i) < 0L)
            est = 0L;
        if (i > 0)
            return Spliterators.spliterator
                (a, 0, i, (Spliterator.ORDERED |
                           Spliterator.NONNULL |
                           Spliterator.CONCURRENT));
    }
    return null;
}

public Spliterator<E> spliterator() {
    int lo = offset;
    int hi = offset + size;
    Object[] a = expectedArray;
    if (l.getArray() != a)
        throw new ConcurrentModificationException();
    if (lo < 0 || hi > a.length)
        throw new IndexOutOfBoundsException();
    return Spliterators.spliterator
        (a, lo, hi, Spliterator.IMMUTABLE | Spliterator.ORDERED);
}

public Spliterator<E> trySplit() {
    Node<E> h;
    if (!exhausted &&
        ((h = current) != null || (h = first) != null)
        && h.next != null) {
        int n = batch = Math.min(batch + 1, MAX_BATCH);
        Object[] a = new Object[n];
        final ReentrantLock lock = LinkedBlockingDeque.this.lock;
        int i = 0;
        Node<E> p = current;
        lock.lock();
        try {
            if (p != null || (p = first) != null)
                for (; p != null && i < n; p = succ(p))
                    if ((a[i] = p.item) != null)
                        i++;
        } finally {
            lock.unlock();
        }
        if ((current = p) == null) {
            est = 0L;
            exhausted = true;
        }
        else if ((est -= i) < 0L)
            est = 0L;
        if (i > 0)
            return Spliterators.spliterator
                (a, 0, i, (Spliterator.ORDERED |
                           Spliterator.NONNULL |
                           Spliterator.CONCURRENT));
    }
    return null;
}

/**
 * Returns a {@code Stream}, the elements of which are lines read from
 * this {@code BufferedReader}.  The {@link Stream} is lazily populated,
 * i.e., read only occurs during the
 * <a href="../util/stream/package-summary.html#StreamOps">terminal
 * stream operation</a>.
 *
 * <p> The reader must not be operated on during the execution of the
 * terminal stream operation. Otherwise, the result of the terminal stream
 * operation is undefined.
 *
 * <p> After execution of the terminal stream operation there are no
 * guarantees that the reader will be at a specific position from which to
 * read the next character or line.
 *
 * <p> If an {@link IOException} is thrown when accessing the underlying
 * {@code BufferedReader}, it is wrapped in an {@link
 * UncheckedIOException} which will be thrown from the {@code Stream}
 * method that caused the read to take place. This method will return a
 * Stream if invoked on a BufferedReader that is closed. Any operation on
 * that stream that requires reading from the BufferedReader after it is
 * closed, will cause an UncheckedIOException to be thrown.
 *
 * @return a {@code Stream<String>} providing the lines of text
 *         described by this {@code BufferedReader}
 *
 * @since 1.8
 */
public Stream<String> lines() {
    Iterator<String> iter = new Iterator<String>() {
        String nextLine = null;

        @Override
        public boolean hasNext() {
            if (nextLine != null) {
                return true;
            } else {
                try {
                    nextLine = readLine();
                    return (nextLine != null);
                } catch (IOException e) {
                    throw new UncheckedIOException(e);
                }
            }
        }

        @Override
        public String next() {
            if (nextLine != null || hasNext()) {
                String line = nextLine;
                nextLine = null;
                return line;
            } else {
                throw new NoSuchElementException();
            }
        }
    };
    return StreamSupport.stream(Spliterators.spliteratorUnknownSize(
            iter, Spliterator.ORDERED | Spliterator.NONNULL), false);
}

/**
 * Convert given {@link Enumeration} into a {@link Stream}.
 * @param <T> Enumeration elements type
 * @param e Enumeration to convert
 * @return Stream on enumeration
 */
public static <T> Stream<T> enumerationAsStream(Enumeration<T> e) {
    return StreamSupport.stream(Spliterators.spliteratorUnknownSize(new Iterator<T>() {
        @Override
        public T next() {
            return e.nextElement();
        }

        @Override
        public boolean hasNext() {
            return e.hasMoreElements();
        }
    }, Spliterator.ORDERED), false);
}

/**
 * Returns a stream of {@code int} zero-extending the {@code char} values
 * from this sequence.  Any char which maps to a <a
 * href="{@docRoot}/java/lang/Character.html#unicode">surrogate code
 * point</a> is passed through uninterpreted.
 *
 * <p>If the sequence is mutated while the stream is being read, the
 * result is undefined.
 *
 * @return an IntStream of char values from this sequence
 * @since 1.8
 */
public default IntStream chars() {
    class CharIterator implements PrimitiveIterator.OfInt {
        int cur = 0;

        public boolean hasNext() {
            return cur < length();
        }

        public int nextInt() {
            if (hasNext()) {
                return charAt(cur++);
            } else {
                throw new NoSuchElementException();
            }
        }

        @Override
        public void forEachRemaining(IntConsumer block) {
            for (; cur < length(); cur++) {
                block.accept(charAt(cur));
            }
        }
    }

    return StreamSupport.intStream(() ->
            Spliterators.spliterator(
                    new CharIterator(),
                    length(),
                    Spliterator.ORDERED),
            Spliterator.SUBSIZED | Spliterator.SIZED | Spliterator.ORDERED,
            false);
}

/**
 * Constructor.
 *
 * @param iterator {@link Iterator} of {@link String}, each is a concat of CSV row
 * @param dtoClass DTO
 */
public CsvAsDTO(final Iterator<String> iterator, final Class<T> dtoClass) {
    this(StreamSupport.stream(
            Spliterators.spliteratorUnknownSize(iterator, Spliterator.ORDERED), false
        ), dtoClass
    );
}

public Spliterator<E> trySplit() {
    Node p, q;
    if ((p = current()) == null || (q = p.next) == null)
        return null;
    int i = 0, n = batch = Math.min(batch + 1, MAX_BATCH);
    Object[] a = null;
    do {
        final Object item = p.item;
        if (p.isData) {
            if (item != null) {
                if (a == null)
                    a = new Object[n];
                a[i++] = item;
            }
        } else if (item == null) {
            p = null;
            break;
        }
        if (p == (p = q))
            p = firstDataNode();
    } while (p != null && (q = p.next) != null && i < n);
    setCurrent(p);
    return (i == 0) ? null :
        Spliterators.spliterator(a, 0, i, (Spliterator.ORDERED |
                                           Spliterator.NONNULL |
                                           Spliterator.CONCURRENT));
}

public Spliterator<E> spliterator() {
    synchronized (l.lock) {
        return Spliterators.spliterator(
                getArrayChecked(), offset, offset + size,
                Spliterator.IMMUTABLE | Spliterator.ORDERED);
    }
}

@Override
public Spliterator<TestCase> spliterator() {
    return Spliterators.spliterator(iterator(), Iterators.size(iterator()), 0);
}

@Override
public Spliterator<TClass> spliterator() {
    return Spliterators.spliteratorUnknownSize(iterator(), Spliterator.DISTINCT | Spliterator.NONNULL);
}

@Override
public Spliterator<TInterface> spliterator() {
    return Spliterators.spliteratorUnknownSize(iterator(), Spliterator.DISTINCT | Spliterator.NONNULL);
}

@Override
public PrimitiveIterator.OfLong iterator() {
    return Spliterators.iterator(spliterator());
}

@Override
public Spliterator<T> spliterator() {
    return Spliterators.spliteratorUnknownSize(dataIt, Spliterator.NONNULL);
}

Spliterator<Entry<K, V>> entrySpliterator() {
  return Spliterators.spliterator(
      entryIterator(),
      size(),
      Spliterator.DISTINCT | Spliterator.NONNULL | Spliterator.IMMUTABLE | Spliterator.ORDERED);
}

private static <T> Stream<T> stream(Iterator<? extends T> it) {
  return StreamSupport.stream(
      Spliterators.spliteratorUnknownSize(it, Spliterator.ORDERED), false);
}