path: root/guava/src/com/google/common/io/GwtWorkarounds.java

/*
 * Copyright (C) 2012 The Guava Authors
 *
 * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except
 * in compliance with the License. You may obtain a copy of the License at
 *
 * http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software distributed under the License
 * is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express
 * or implied. See the License for the specific language governing permissions and limitations under
 * the License.
 */

package com.google.common.io;

import static com.google.common.base.Preconditions.checkNotNull;
import static com.google.common.base.Preconditions.checkPositionIndexes;

import com.google.common.annotations.GwtCompatible;
import com.google.common.annotations.GwtIncompatible;

import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.io.Reader;
import java.io.Writer;

/**
 * Provides simple GWT-compatible substitutes for {@code InputStream}, {@code OutputStream},
 * {@code Reader}, and {@code Writer} so that {@code BaseEncoding} can use streaming implementations
 * while remaining GWT-compatible.
 *
 * @author Louis Wasserman
 */
@GwtCompatible(emulated = true)
final class GwtWorkarounds {
  private GwtWorkarounds() {}

  /**
   * A GWT-compatible substitute for a {@code Reader}.
   */
  interface CharInput {
    int read() throws IOException;
    void close() throws IOException;
  }

  /**
   * Views a {@code Reader} as a {@code CharInput}.
   */
  @GwtIncompatible("Reader")
  static CharInput asCharInput(final Reader reader) {
    checkNotNull(reader);
    return new CharInput() {
      @Override
      public int read() throws IOException {
        return reader.read();
      }

      @Override
      public void close() throws IOException {
        reader.close();
      }
    };
  }

  /**
   * Views a {@code CharSequence} as a {@code CharInput}.
   */
  static CharInput asCharInput(final CharSequence chars) {
    checkNotNull(chars);
    return new CharInput() {
      int index = 0;

      @Override
      public int read() {
        if (index < chars.length()) {
          return chars.charAt(index++);
        } else {
          return -1;
        }
      }

      @Override
      public void close() {
        index = chars.length();
      }
    };
  }

  /**
   * A GWT-compatible substitute for an {@code InputStream}.
   */
  interface ByteInput {
    int read() throws IOException;
    void close() throws IOException;
  }

  /**
   * Views a {@code ByteInput} as an {@code InputStream}.
   */
  @GwtIncompatible("InputStream")
  static InputStream asInputStream(final ByteInput input) {
    checkNotNull(input);
    return new InputStream() {
      @Override
      public int read() throws IOException {
        return input.read();
      }

      @Override
      public int read(byte[] b, int off, int len) throws IOException {
        checkNotNull(b);
        checkPositionIndexes(off, off + len, b.length);
        if (len == 0) {
          return 0;
        }
        int firstByte = read();
        if (firstByte == -1) {
          return -1;
        }
        b[off] = (byte) firstByte;
        for (int dst = 1; dst < len; dst++) {
          int readByte = read();
          if (readByte == -1) {
            return dst;
          }
          b[off + dst] = (byte) readByte;
        }
        return len;
      }

      @Override
      public void close() throws IOException {
        input.close();
      }
    };
  }

  /**
   * A GWT-compatible substitute for an {@code OutputStream}.
   */
  interface ByteOutput {
    void write(byte b) throws IOException;
    void flush() throws IOException;
    void close() throws IOException;
  }

  /**
   * Views a {@code ByteOutput} as an {@code OutputStream}.
   */
  @GwtIncompatible("OutputStream")
  static OutputStream asOutputStream(final ByteOutput output) {
    checkNotNull(output);
    return new OutputStream() {
      @Override
      public void write(int b) throws IOException {
        output.write((byte) b);
      }

      @Override
      public void flush() throws IOException {
        output.flush();
      }

      @Override
      public void close() throws IOException {
        output.close();
      }
    };
  }

  /**
   * A GWT-compatible substitute for a {@code Writer}.
   */
  interface CharOutput {
    void write(char c) throws IOException;
    void flush() throws IOException;
    void close() throws IOException;
  }

  /**
   * Views a {@code Writer} as a {@code CharOutput}.
   */
  @GwtIncompatible("Writer")
  static CharOutput asCharOutput(final Writer writer) {
    checkNotNull(writer);
    return new CharOutput() {
      @Override
      public void write(char c) throws IOException {
        writer.append(c);
      }

      @Override
      public void flush() throws IOException {
        writer.flush();
      }

      @Override
      public void close() throws IOException {
        writer.close();
      }
    };
  }

  /**
   * Returns a {@code CharOutput} whose {@code toString()} method can be used
   * to get the combined output.
   */
  static CharOutput stringBuilderOutput(int initialSize) {
    final StringBuilder builder = new StringBuilder(initialSize);
    return new CharOutput() {

      @Override
      public void write(char c) {
        builder.append(c);
      }

      @Override
      public void flush() {}

      @Override
      public void close() {}

      @Override
      public String toString() {
        return builder.toString();
      }
    };
  }
}