slowCh = make(chan itemOrErr[ObjectInfo], 100)
		)

		if r.Source.Snowball.Disable != nil && !*r.Source.Snowball.Disable && r.Source.Type.isMinio() && r.Target.Type.isMinio() {
			go func() {
				// Snowball currently needs the high level minio-go Client, not the Core one
				cl, err := minio.New(u.Host, &minio.Options{
					Creds:        credentials.NewStaticV4(cred.AccessKey, cred.SecretKey, cred.SessionToken),

   * implementation; otherwise refreshes will be performed during unrelated cache read and write
   * operations.
   *
   * <p>Currently automatic refreshes are performed when the first stale request for an entry
   * occurs. The request triggering refresh will make a synchronous call to {@link
   * CacheLoader#reload}

     * outputs users get when calling this with <Foo> and calling it with <@Nullable Foo>. The only
     * difference is that calling it with <Foo> won't work when an input Future has a @Nullable
     * type. So why even make that error possible by giving callers the choice?
     *

	// Linear search, we likely have to insert at front.
	for i, existing := range x.versions {
		if existing.header.ModTime <= modTime {
			// Insert at current idx. First move current back.
			copy(x.versions[i+1:], x.versions[i:])
			x.versions[i] = xlMetaV2ShallowVersion{
				header: ver.header(),
				meta:   encoded,
			}
			return nil
		}
	}

labels.bad_request=Your request to the URL is invalid.
labels.page_not_found_title=Page Not Found.
labels.check_url=Please check the URL.
labels.busy_title=Service Temporarily Unavailable
labels.busy_message=The server is currently experiencing high load. Please try again later.
labels.user_name=Username
labels.login=Login
labels.login.placeholder_username=Username
labels.login.placeholder_password=Password
labels.login.title=Login

      Iterator<T> iterator, Predicate<? super T> predicate) {
    checkNotNull(predicate, "predicate");
    for (int i = 0; iterator.hasNext(); i++) {
      T current = iterator.next();
      if (predicate.apply(current)) {
        return i;
      }
    }
    return -1;
  }

  /**
   * Returns a view containing the result of applying {@code function} to each element of {@code

      Iterator<T> iterator, Predicate<? super T> predicate) {
    checkNotNull(predicate, "predicate");
    for (int i = 0; iterator.hasNext(); i++) {
      T current = iterator.next();
      if (predicate.apply(current)) {
        return i;
      }
    }
    return -1;
  }

  /**
   * Returns a view containing the result of applying {@code function} to each element of {@code

		if rd || wr {
			// Fetch the data usage of the current bucket
			bui := globalBucketQuotaSys.GetBucketUsageInfo(ctx, bucket.Name)
			size := bui.Size
			objectsCount := bui.ObjectsCount
			objectsHist := bui.ObjectSizesHistogram
			versionsHist := bui.ObjectVersionsHistogram

			// Fetch the prefix usage of the current bucket
			var prefixUsage map[string]uint64
			if enablePrefixUsage {

		}
	}
	return &BucketStatsMap{Stats: bucketStatsMap, Timestamp: time.Now()}, nil
}

// GetBucketStatsHandler - fetches current in-memory bucket stats, currently only
// returns BucketStats, that currently includes ReplicationStats.
func (s *peerRESTServer) GetBucketStatsHandler(vars *grid.MSS) (*BucketStats, *grid.RemoteErr) {
	bucketName := vars.Get(peerRESTBucket)
	if bucketName == "" {

        }

        File current = baseDirectory;
        if (alternatePomFile != null) {
            current = ResolveFile.resolveFile(new File(alternatePomFile), workingDirectory);
        }

        if (modelProcessor != null) {
            current = modelProcessor.locatePom(current);
        }
        return current.isFile() ? current : null;
    }

    // Visible for testing