/**
  * Discards {@code n} characters of data from the reader. This method will block until the full
  * amount has been skipped. Does not close the reader.
  *
  * @param reader the reader to read from
  * @param n the number of characters to skip
  * @throws EOFException if this stream reaches the end before skipping all the characters
  * @throws IOException if an I/O error occurs
  */
 public static void skipFully(Reader reader, long n) throws IOException {
   checkNotNull(reader);
   while (n > 0) {
     long amt = reader.skip(n);
     if (amt == 0) {
       // force a blocking read
       if (reader.read() == -1) {
         throw new EOFException();
       }
       n--;
     } else {
       n -= amt;
     }
   }
 }
 @Override
 public SortedMap<R, Map<C, V>> subMap(R fromKey, R toKey) {
   checkNotNull(fromKey);
   checkNotNull(toKey);
   return new StandardRowSortedTable<R, C, V>(sortedBackingMap().subMap(fromKey, toKey), factory)
       .rowMap();
 }
  /**
   * Streams lines from a {@link Readable} object, stopping when the processor returns {@code false}
   * or all lines have been read and returning the result produced by the processor. Does not close
   * {@code readable}. Note that this method may not fully consume the contents of {@code readable}
   * if the processor stops processing early.
   *
   * @throws IOException if an I/O error occurs
   * @since 14.0
   */
  public static <T> T readLines(Readable readable, LineProcessor<T> processor) throws IOException {
    checkNotNull(readable);
    checkNotNull(processor);

    LineReader lineReader = new LineReader(readable);
    String line;
    while ((line = lineReader.readLine()) != null) {
      if (!processor.processLine(line)) {
        break;
      }
    }
    return processor.getResult();
  }
 /**
  * Copies all characters between the {@link Readable} and {@link Appendable} objects. Does not
  * close or flush either object.
  *
  * @param from the object to read from
  * @param to the object to write to
  * @return the number of characters copied
  * @throws IOException if an I/O error occurs
  */
 public static long copy(Readable from, Appendable to) throws IOException {
   checkNotNull(from);
   checkNotNull(to);
   CharBuffer buf = CharBuffer.allocate(BUF_SIZE);
   long total = 0;
   while (from.read(buf) != -1) {
     buf.flip();
     to.append(buf);
     total += buf.remaining();
     buf.clear();
   }
   return total;
 }
  /**
   * Streams lines from a {@link Readable} and {@link Closeable} object supplied by a factory,
   * stopping when our callback returns false, or we have read all of the lines.
   *
   * @param supplier the factory to read from
   * @param callback the LineProcessor to use to handle the lines
   * @return the output of processing the lines
   * @throws IOException if an I/O error occurs
   * @deprecated Use {@link CharSource#readLines(LineProcessor)} instead. This method is scheduled
   *     for removal in Guava 18.0.
   */
  @Deprecated
  public static <R extends Readable & Closeable, T> T readLines(
      InputSupplier<R> supplier, LineProcessor<T> callback) throws IOException {
    checkNotNull(supplier);
    checkNotNull(callback);

    Closer closer = Closer.create();
    try {
      R r = closer.register(supplier.getInput());
      return readLines(r, callback);
    } catch (Throwable e) {
      throw closer.rethrow(e);
    } finally {
      closer.close();
    }
  }
Exemple #6
0
 /**
  * Drains the queue as {@link BlockingQueue#drainTo(Collection, int)}, but if the requested {@code
  * numElements} elements are not available, it will wait for them up to the specified timeout.
  *
  * @param q the blocking queue to be drained
  * @param buffer where to add the transferred elements
  * @param numElements the number of elements to be waited for
  * @param timeout how long to wait before giving up, in units of {@code unit}
  * @param unit a {@code TimeUnit} determining how to interpret the timeout parameter
  * @return the number of elements transferred
  * @throws InterruptedException if interrupted while waiting
  */
 @Beta
 public static <E> int drain(
     BlockingQueue<E> q,
     Collection<? super E> buffer,
     int numElements,
     long timeout,
     TimeUnit unit)
     throws InterruptedException {
   Preconditions.checkNotNull(buffer);
   /*
    * This code performs one System.nanoTime() more than necessary, and in return, the time to
    * execute Queue#drainTo is not added *on top* of waiting for the timeout (which could make
    * the timeout arbitrarily inaccurate, given a queue that is slow to drain).
    */
   long deadline = System.nanoTime() + unit.toNanos(timeout);
   int added = 0;
   while (added < numElements) {
     // we could rely solely on #poll, but #drainTo might be more efficient when there are multiple
     // elements already available (e.g. LinkedBlockingQueue#drainTo locks only once)
     added += q.drainTo(buffer, numElements - added);
     if (added < numElements) { // not enough elements immediately available; will have to poll
       E e = q.poll(deadline - System.nanoTime(), TimeUnit.NANOSECONDS);
       if (e == null) {
         break; // we already waited enough, and there are no more elements in sight
       }
       buffer.add(e);
       added++;
     }
   }
   return added;
 }
  /**
   * Returns an iterable that applies {@code convert} to each element of {@code fromIterable}. The
   * conversion is done lazily.
   *
   * <p>The returned iterable's iterator supports {@code remove()} if the input iterator does. After
   * a successful {@code remove()} call, {@code fromIterable} no longer contains the corresponding
   * element.
   */
  public Iterable<B> convertAll(final Iterable<? extends A> fromIterable) {
    checkNotNull(fromIterable, "fromIterable");
    return new Iterable<B>() {
      @Override
      public Iterator<B> iterator() {
        return new Iterator<B>() {
          private final Iterator<? extends A> fromIterator = fromIterable.iterator();

          @Override
          public boolean hasNext() {
            return fromIterator.hasNext();
          }

          @Override
          public B next() {
            return convert(fromIterator.next());
          }

          @Override
          public void remove() {
            fromIterator.remove();
          }
        };
      }
    };
  }
  /**
   * Returns a view of the given {@code Appendable} supplier as a {@code CharSink}.
   *
   * <p>This method is a temporary method provided for easing migration from suppliers to sources
   * and sinks.
   *
   * @since 15.0
   * @deprecated Convert all {@code OutputSupplier<? extends Appendable>} implementations to extend
   *     {@link CharSink} or provide a method for viewing the object as a {@code CharSink}. This
   *     method is scheduled for removal in Guava 18.0.
   */
  @Deprecated
  public static CharSink asCharSink(final OutputSupplier<? extends Appendable> supplier) {
    checkNotNull(supplier);
    return new CharSink() {
      @Override
      public Writer openStream() throws IOException {
        return asWriter(supplier.getOutput());
      }

      @Override
      public String toString() {
        return "CharStreams.asCharSink(" + supplier + ")";
      }
    };
  }
  /**
   * Returns a view of the given {@code Readable} supplier as a {@code CharSource}.
   *
   * <p>This method is a temporary method provided for easing migration from suppliers to sources
   * and sinks.
   *
   * @since 15.0
   * @deprecated Convert all {@code InputSupplier<? extends Readable>} implementations to extend
   *     {@link CharSource} or provide a method for viewing the object as a {@code CharSource}. This
   *     method is scheduled for removal in Guava 18.0.
   */
  @Deprecated
  public static CharSource asCharSource(final InputSupplier<? extends Readable> supplier) {
    checkNotNull(supplier);
    return new CharSource() {
      @Override
      public Reader openStream() throws IOException {
        return asReader(supplier.getInput());
      }

      @Override
      public String toString() {
        return "CharStreams.asCharSource(" + supplier + ")";
      }
    };
  }
 /**
  * Joins multiple {@link Reader} suppliers into a single supplier. Reader returned from the
  * supplier will contain the concatenated data from the readers of the underlying suppliers.
  *
  * <p>Reading from the joined reader will throw a {@link NullPointerException} if any of the
  * suppliers are null or return null.
  *
  * <p>Only one underlying reader will be open at a time. Closing the joined reader will close the
  * open underlying reader.
  *
  * @param suppliers the suppliers to concatenate
  * @return a supplier that will return a reader containing the concatenated data
  * @deprecated Use {@link CharSource#concat(Iterable)} instead. This method is scheduled for
  *     removal in Guava 18.0.
  */
 @Deprecated
 public static InputSupplier<Reader> join(
     final Iterable<? extends InputSupplier<? extends Reader>> suppliers) {
   checkNotNull(suppliers);
   Iterable<CharSource> sources =
       Iterables.transform(
           suppliers,
           new Function<InputSupplier<? extends Reader>, CharSource>() {
             @Override
             public CharSource apply(InputSupplier<? extends Reader> input) {
               return asCharSource(input);
             }
           });
   return asInputSupplier(CharSource.concat(sources));
 }
Exemple #11
0
 /**
  * Drains the queue as {@linkplain #drain(BlockingQueue, Collection, int, long, TimeUnit)}, but
  * with a different behavior in case it is interrupted while waiting. In that case, the operation
  * will continue as usual, and in the end the thread's interruption status will be set (no {@code
  * InterruptedException} is thrown).
  *
  * @param q the blocking queue to be drained
  * @param buffer where to add the transferred elements
  * @param numElements the number of elements to be waited for
  * @param timeout how long to wait before giving up, in units of {@code unit}
  * @param unit a {@code TimeUnit} determining how to interpret the timeout parameter
  * @return the number of elements transferred
  */
 @Beta
 public static <E> int drainUninterruptibly(
     BlockingQueue<E> q,
     Collection<? super E> buffer,
     int numElements,
     long timeout,
     TimeUnit unit) {
   Preconditions.checkNotNull(buffer);
   long deadline = System.nanoTime() + unit.toNanos(timeout);
   int added = 0;
   boolean interrupted = false;
   try {
     while (added < numElements) {
       // we could rely solely on #poll, but #drainTo might be more efficient when there are
       // multiple elements already available (e.g. LinkedBlockingQueue#drainTo locks only once)
       added += q.drainTo(buffer, numElements - added);
       if (added < numElements) { // not enough elements immediately available; will have to poll
         E e; // written exactly once, by a successful (uninterrupted) invocation of #poll
         while (true) {
           try {
             e = q.poll(deadline - System.nanoTime(), TimeUnit.NANOSECONDS);
             break;
           } catch (InterruptedException ex) {
             interrupted = true; // note interruption and retry
           }
         }
         if (e == null) {
           break; // we already waited enough, and there are no more elements in sight
         }
         buffer.add(e);
         added++;
       }
     }
   } finally {
     if (interrupted) {
       Thread.currentThread().interrupt();
     }
   }
   return added;
 }
  static Reader asReader(final Readable readable) {
    checkNotNull(readable);
    if (readable instanceof Reader) {
      return (Reader) readable;
    }
    return new Reader() {
      @Override
      public int read(char[] cbuf, int off, int len) throws IOException {
        return read(CharBuffer.wrap(cbuf, off, len));
      }

      @Override
      public int read(CharBuffer target) throws IOException {
        return readable.read(target);
      }

      @Override
      public void close() throws IOException {
        if (readable instanceof Closeable) {
          ((Closeable) readable).close();
        }
      }
    };
  }
 @Override
 public SortedMap<R, Map<C, V>> headMap(R toKey) {
   checkNotNull(toKey);
   return new StandardRowSortedTable<R, C, V>(sortedBackingMap().headMap(toKey), factory)
       .rowMap();
 }
 @Override
 public Writer append(CharSequence csq) {
   checkNotNull(csq);
   return this;
 }
 @Override
 public void write(String str) {
   checkNotNull(str);
 }
 @Override
 public void write(char[] cbuf) {
   checkNotNull(cbuf);
 }