}
	return nil
}

// LookupWorm - check if worm is enabled
func LookupWorm() (bool, error) {
	return ParseBool(env.Get(EnvWorm, EnableOff))
}

// Carries all the renamed sub-systems from their
// previously known names
var renamedSubsys = map[string]string{
	CrawlerSubSys: ScannerSubSys,
	// Add future sub-system renames
}

const ( // deprecated keys

	yyyymmdd        = "20060102"
)

type serviceType string

const (
	serviceS3  serviceType = "s3"
	serviceSTS serviceType = "sts"
)

// getCanonicalHeaders generate a list of request headers with their values
func getCanonicalHeaders(signedHeaders http.Header) string {
	var headers []string
	vals := make(http.Header, len(signedHeaders))
	for k, vv := range signedHeaders {
		k = strings.ToLower(k)

  boolean isEmpty();

  /** Returns the number of row key / column key / value mappings in the table. */
  int size();

  /**
   * Compares the specified object with this table for equality. Two tables are equal when their
   * cell views, as returned by {@link #cellSet}, are equal.
   */
  @Override
  boolean equals(@Nullable Object obj);

  /**

	return shuffleWithDist[int](parts, distribution)
}

// shuffleDisks - shuffle input disks slice depending on the
// erasure distribution. Return shuffled slice of disks with
// their expected distribution.
func shuffleDisks(disks []StorageAPI, distribution []int) []StorageAPI {
	return shuffleWithDist[StorageAPI](disks, distribution)
}

// evalDisks - returns a new slice of disks where nil is set if

immutability and chained builders. The API now offers asynchronous callbacks
in addition to synchronous blocking calls.

#### API Changes

 *  **New Request and Response types,** each with their own builder. There's also
    a `RequestBody` class to write the request body to the network and a
    `ResponseBody` to read the response body from the network. The standalone

            The type of artifact this project produces, for example {@code jar},
              {@code war},
              {@code ear},
              {@code pom}.
            Plugins can create their own packaging, and
            therefore their own packaging types,
            so this list does not contain all possible types.
          </description>
          <type>String</type>
          <defaultValue>jar</defaultValue>

   * Begins a new hash code computation as {@link #newHasher()}, but provides a hint of the expected
   * size of the input (in bytes). This is only important for non-streaming hash functions (hash
   * functions that need to buffer their whole input before processing any of it).
   */
  Hasher newHasher(int expectedInputSize);

  /**
   * Shortcut for {@code newHasher().putInt(input).hash()}; returns the hash code for the given

   * Begins a new hash code computation as {@link #newHasher()}, but provides a hint of the expected
   * size of the input (in bytes). This is only important for non-streaming hash functions (hash
   * functions that need to buffer their whole input before processing any of it).
   */
  Hasher newHasher(int expectedInputSize);

  /**
   * Shortcut for {@code newHasher().putInt(input).hash()}; returns the hash code for the given

        } catch (MavenExecutionException e) {
            return addExceptionToResult(result, e);
        }

        //
        // The projects need to be topologically after the participants have run their afterProjectsRead(session)
        // because the participant is free to change the dependencies of a project which can potentially change the

		return nil
	}
	return map[string]string{
		c.Type.String():       c.Encoded,
		xhttp.AmzChecksumType: c.Type.ObjType(),
	}
}

// Equal returns whether two checksum structs are equal in all their fields.
func (c *Checksum) Equal(s *Checksum) bool {
	if c == nil || s == nil {
		return c == s
	}
	return c.Type == s.Type &&
		c.Encoded == s.Encoded &&
		bytes.Equal(c.Raw, s.Raw) &&