# Sourcing this enables local disk cache
if [[ $(uname -s) == "Darwin" ]]; then
  echo "Please note that using disk cache on macOS is not recommended because the"
  echo "cache can end up being pretty big and make the build process inefficient."
fi

# Compression Guide [![Slack](https://slack.min.io/slack?type=svg)](https://slack.min.io)

MinIO server allows streaming compression to ensure efficient disk space usage.
Compression happens inflight, i.e objects are compressed before being written to disk(s).
MinIO uses [`klauspost/compress/s2`](https://github.com/klauspost/compress/tree/master/s2)
streaming compression due to its stability and performance.

# The Go Programming Language

Go is an open source programming language that makes it easy to build simple,
reliable, and efficient software.

![Gopher image](https://golang.org/doc/gopher/fiveyears.jpg)
*Gopher image by [Renee French][rf], licensed under [Creative Commons 4.0 Attribution license][cc4-by].*

Our canonical Git repository is located at https://go.googlesource.com/go.
There is a mirror of the repository at https://github.com/golang/go.

 * which processes classes annotated with {@link org.apache.maven.api.di.Named} and creates an index file
 * that allows for efficient discovery of injectable components at runtime.
 * <p>
 * The generated index is stored at {@code META-INF/maven/org.apache.maven.api.di.Inject} and contains
 * the fully qualified names of all classes annotated with {@code @Named}.

@GwtCompatible
public final class Utf8 {
  /**
   * Returns the number of bytes in the UTF-8-encoded form of {@code sequence}. For a string, this
   * method is equivalent to {@code string.getBytes(UTF_8).length}, but is more efficient in both
   * time and space.
   *
   * @throws IllegalArgumentException if {@code sequence} contains ill-formed UTF-16 (unpaired
   *     surrogates)
   */
  public static int encodedLength(CharSequence sequence) {

@GwtCompatible
public final class Utf8 {
  /**
   * Returns the number of bytes in the UTF-8-encoded form of {@code sequence}. For a string, this
   * method is equivalent to {@code string.getBytes(UTF_8).length}, but is more efficient in both
   * time and space.
   *
   * @throws IllegalArgumentException if {@code sequence} contains ill-formed UTF-16 (unpaired
   *     surrogates)
   */
  public static int encodedLength(CharSequence sequence) {

     */
    protected String wildcard;

    /**
     * The DOS file attributes to filter on.
     */
    protected int attributes;

    /**
     * This filter can be considerably more efficient than other file filters
     * as the specified wildcard and attributes are passed to the server for
     * filtering there (although attributes are largely ignored by servers

     * The DOS file attributes to filter on.
     */
    protected int attributes;

    /**
     * Creates a DOS file filter with the specified wildcard and attributes.
     * This filter can be considerably more efficient than other file filters
     * as the specified wildcard and attributes are passed to the server for
     * filtering there (although attributes are largely ignored by servers

    return new LinkedHashMultiset<>(distinctElements);
  }

  /**
   * Creates a new {@code LinkedHashMultiset} containing the specified elements.
   *
   * <p>This implementation is highly efficient when {@code elements} is itself a {@link Multiset}.
   *
   * @param elements the elements that the multiset should contain
   */
  public static <E extends @Nullable Object> LinkedHashMultiset<E> create(

 * scopes and their associated implied scopes, so that the user can filter apply a series of implication rules in a
 * single step. This should be a more efficient implementation of multiple standard {@link ScopeArtifactFilter}
 * instances ORed together.
 *
 */
public class CumulativeScopeArtifactFilter extends AbstractScopeArtifactFilter {

    private Set<String> scopes;