<execution>
                        <id>security.xml</id>
                        <goals>
                            <goal>java1</goal>
                            <goal>xpp3-reader1</goal>
                            <goal>xpp3-writer1</goal>
                        </goals>
                        <configuration>
                            <version>1.0.0</version>

Similarly, the reader thread must never block on writing because this can deadlock the connection. Consider a client and server that both violate this rule. If you get unlucky, they could fill up their TCP buffers (so that writes block) and then use their reader threads to write a frame. Nobody is reading on either end, and the buffers are never drained.

#### Do-stuff-later pool

            // we called sizeIfKnown and when we started reading the file (or I guess if
            // maxCharsPerByte is wrong)
            // Fallback to an incremental approach
            StringBuilder builder = new StringBuilder(bufIndex + 32);
            builder.append(buffer, 0, bufIndex);
            buffer = null; // release for gc
            CharStreams.copy(reader, builder);
            return builder.toString();
          }

     */
    boolean getHasEmptyContent() throws ResourceException;

    /**
     * Returns an *unbuffered* reader over the content of this resource.
     *
     * <p>Note that this method, or reading from the provided reader, may be expensive when {@link #isContentCached()} returns false, depending on the implementation.
     *

    }

    @Override
    protected SwiftcMetadata parseCompilerOutput(String stdout, String stderr, File swiftc, List<File> path) {
        BufferedReader reader = new BufferedReader(new StringReader(stdout));
        try {
            String line;
            while ((line = reader.readLine()) != null) {
                if (line.contains("Swift version")) {
                    String[] tokens = line.split(" ");

     *
     * @param input input stream that contains the build cache entry
     * @throws IOException when an I/O error occurs when reading the cache entry from the given input stream
     */
    void readFrom(InputStream input) throws IOException;

		return rsc.offset, errors.New("seek past end of object")
	}
	if rsc.reader != nil {
		_ = rsc.reader.Close()
		rsc.reader = nil
	}
	return rsc.offset, nil
}

// Read call to implement io.Reader
func (rsc *ObjectReadSeekCloser) Read(p []byte) (n int, err error) {
	if rsc.reader == nil {
		rsc.reader, err = rsc.segmentReader(rsc.offset)
		if err != nil {
			return 0, err
		}
	}

		return
	}

	// Loop reading from FIFO until EOF to ensure that the reader
	// is not blocked infinitely, otherwise there is something wrong
	// with the netpoller.
	for {
		_, err = r.Read(buf)
		if errors.Is(err, io.EOF) {
			break
		}
		if err != nil && !errors.Is(err, syscall.EAGAIN) {
			t.Errorf("Error reading bytes from fifo: %v", err)
			return
		}
	}

  // Returns a list of function defs in the SavedModel.
  const protobuf::RepeatedPtrField<FunctionDef>& GetFunctionDefs();

  // Returns a BundleReader for reading variable values.
  //
  // This TFPackage retains ownership of the underlying reader.
  tensorflow::BundleReader* GetVariableReader() {
    return variable_reader_.get();
  }

  // Returns whether or not we found a valid checkpoint when loading the

// findEmbed advances the input reader to the next //go:embed comment.
// It reports whether it found a comment.
// (Otherwise it found an error or EOF.)
func (r *importReader) findEmbed(first bool) bool {
	// The import block scan stopped after a non-space character,
	// so the reader is not at the start of a line on the first call.
	// After that, each //go:embed extraction leaves the reader
	// at the end of a line.