TF_RETURN_IF_ERROR(
        ConsumePrefix(text_proto, prefix_to_strip, &text_proto_without_prefix));
  }
  protobuf::io::ArrayInputStream input_stream(text_proto_without_prefix.data(),
                                              text_proto_without_prefix.size());
  if (parser.Parse(&input_stream, parsed_proto)) {
    return absl::OkStatus();
  }
  parsed_proto->Clear();

absl::StatusOr<QuantizationSpecs> ParseTextProto(
    const absl::string_view text_proto) {
  QuantizationSpecs quantization_specs;
  TextFormat::Parser parser;
  ArrayInputStream input_stream(text_proto.data(), text_proto.size());
  if (parser.Parse(&input_stream, &quantization_specs)) {
    return quantization_specs;
  }
  return absl::InvalidArgumentError("Could not parse text proto.");
}

  TF_RETURN_IF_ERROR(
      env->NewRandomAccessFile(string(gzipped_pbtxt_file_path), &file_reader));
  std::unique_ptr<io::RandomAccessInputStream> input_stream(
      new io::RandomAccessInputStream(file_reader.get()));
  constexpr int k_buffer_size = 256 << 10;  // 256kb
  io::ZlibInputStream in(input_stream.get(),
                         /*input_buffer_bytes=*/k_buffer_size,
                         /*output_buffer_bytes=*/k_buffer_size,

absl::Status ParseTextProto(absl::string_view text_proto,
                            Message* parsed_proto) {
  TextFormat::Parser parser;
  // Attempt to parse as text.
  ArrayInputStream input_stream(text_proto.data(), text_proto.size());
  if (parser.Parse(&input_stream, parsed_proto)) {
    return absl::OkStatus();
  }
  parsed_proto->Clear();
  return absl::InvalidArgumentError(
      absl::StrCat("Could not parse text proto: ", text_proto));
}

                try {
                    return createNewInstance(inputStream);
                } catch (IOException e) {
                    throw UncheckedException.throwAsUncheckedException(e);
                }
            }
        };
    }

    protected ExceptionReplacingObjectInputStream createNewInstance(InputStream inputStream) throws IOException {

     *
     * @param inputSteam stream to read the object from
     * @param classLoader loader used to load exception classes
     * @return the de-serialized object
     */
    public static Object receive(InputStream inputSteam, ClassLoader classLoader)
            throws IOException, ClassNotFoundException {
        ObjectInputStream ois = new ExceptionReplacingObjectInputStream(inputSteam, classLoader);

        }

        public XmlReaderRequestBuilder url(URL url) {
            this.url = url;
            return this;
        }

        public XmlReaderRequestBuilder inputStream(InputStream inputStream) {
            this.inputStream = inputStream;
            return this;
        }

        public XmlReaderRequestBuilder reader(Reader reader) {
            this.reader = reader;
            return this;
        }

import java.io.IOException;
import java.io.InputStream;
import java.util.Properties;

public class Application {
    public Properties readBuildInfo() throws IOException {
        Properties prop = new Properties();
        InputStream inputStream = null;

        try {
            inputStream = Application.class.getClassLoader().getResourceAsStream("build-info.properties");
            prop.load(inputStream);
        } finally {

import java.io.IOException;
import java.io.InputStream;

/**
 * This inputstream ignores a close method.
 *
 * @author shinsuke
 *
 */
public class IgnoreCloseInputStream extends InputStream {

    private transient InputStream inputStream;

    public IgnoreCloseInputStream(final InputStream inputStream) {
        this.inputStream = inputStream;
    }

    @Override

    public ExecOutputHandleRunner(String displayName, InputStream inputStream, OutputStream outputStream, CountDownLatch completed) {
        this(displayName, inputStream, outputStream, 8192, completed);
    }

    ExecOutputHandleRunner(String displayName, InputStream inputStream, OutputStream outputStream, int bufferSize, CountDownLatch completed) {
        this.displayName = displayName;
        this.inputStream = inputStream;