- **I/O Operations** (`org.codelibs.core.io`) - File handling, resource management, stream utilities, and traversal utilities for efficient resource processing
- **Reflection** (`org.codelibs.core.lang`) - Class loading, method/field access, type introspection utilities, and generics support

        }
        if (value instanceof String[]) {
            return (String[]) value;
        }
        if (value instanceof List) {
            return ((List<?>) value).stream().map(Object::toString).toArray(String[]::new);
        }
        if (value != null) {
            return new String[] { value.toString() };
        }

        return new String[0];
    }

    /**

   * response was received without TLS.
   */
  @get:JvmName("handshake") val handshake: Handshake?,
  /** Returns the HTTP headers. */
  @get:JvmName("headers") val headers: Headers,
  /**
   * Returns a non-null stream with the server's response. The returned value must be
   * [closed][ResponseBody] and may be consumed only once.
   *
   * If this is a [cacheResponse], [networkResponse], or [priorResponse], the server's response body

            headerCount,
          )
          nextHeaderIndex += entriesToEvict
        }
        return entriesToEvict
      }

      /**
       * Read `byteCount` bytes of headers from the source stream. This implementation does not
       * propagate the never indexed flag of a header.
       */
      @Throws(IOException::class)
      fun readHeaders() {
        while (!source.exhausted()) {

 * under the License.
 */
package org.apache.maven.artifact.repository.metadata;

import javax.inject.Inject;
import javax.inject.Named;
import javax.inject.Singleton;
import javax.xml.stream.XMLStreamException;

import java.io.File;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.nio.file.Files;

                // Verify expected shares are present
                List<String> shareList = List.of(shares);
                boolean hasPublic = shareList.stream().anyMatch(s -> s.toLowerCase().contains("public"));
                boolean hasShared = shareList.stream().anyMatch(s -> s.toLowerCase().contains("shared"));

                assertTrue(hasPublic || hasShared, "Should contain expected shares");

	// We can safely allow RenameFile errors up to len(er.getDisks()) - writeQuorum
	// otherwise return failure. Cleanup successful renames.
	return evalDisks(disks, errs), err
}

// PutObjectPart - reads incoming stream and internally erasure codes
// them. This call is similar to single put operation but it is part
// of the multipart transaction.
//
// Implements S3 compatible Upload Part API.

   * this reason.
   *
   * <p><b>Java 8+ users:</b> many use cases for this method are better addressed by {@link
   * java.util.stream.Stream#map}. This method is not being deprecated, but we gently encourage you
   * to migrate to streams.
   */
  public static <F extends @Nullable Object, T extends @Nullable Object> List<T> transform(
      List<F> fromList, Function<? super F, ? extends T> function) {

		if err != nil {
			return written, err
		}

		if nw != int64(len(buf)) {
			return written, io.ErrShortWrite
		}

		if totalSize > 0 && written == totalSize {
			// we have written the entire stream, return right here.
			return written, nil
		}

		if eof {
			// We reached EOF prematurely but we did not write everything
			// that we promised that we would write.

         */
        public boolean isTeminated() {
            return teminated;
        }
    }

    /**
     * Thread to read and buffer output from an input stream.
     */
    protected static class InputStreamThread extends Thread {

        private BufferedReader br;

        private final List<String> list = new LinkedList<>();