func (brs *BucketReplicationStats) Empty() bool {
	return len(brs.Stats) == 0 && brs.ReplicaSize == 0
}

// Clone creates a new BucketReplicationStats copy
func (brs BucketReplicationStats) Clone() (c BucketReplicationStats) {
	// This is called only by replicationStats cache and already holds a
	// read lock before calling Clone()

	c = brs
	// We need to copy the map, so we do not reference the one in `brs`.

        if (mojos != null) {
            clones = new ArrayList<>(mojos.size());
            for (MojoDescriptor mojo : mojos) {
                MojoDescriptor clone = mojo.clone();
                clone.setPluginDescriptor(pluginDescriptor);
                clones.add(clone);
            }
        }
        return clones;
    }

    public PluginDescriptor(org.apache.maven.api.plugin.descriptor.PluginDescriptor original) {

type TargetIDSet map[TargetID]struct{}

// IsEmpty returns true if the set is empty.
func (set TargetIDSet) IsEmpty() bool {
	return len(set) != 0
}

// Clone - returns copy of this set.
func (set TargetIDSet) Clone() TargetIDSet {
	setCopy := NewTargetIDSet()
	for k, v := range set {
		setCopy[k] = v
	}
	return setCopy
}

// add - adds TargetID to the set.

		for _, name := range eventName.Expand() {
			rulesMap[name] = rulesMap[name].Union(rules)
		}
	}
}

// Clone - returns copy of this rules map.
func (rulesMap RulesMap) Clone() RulesMap {
	rulesMapCopy := make(RulesMap)

	for eventName, rules := range rulesMap {
		rulesMapCopy[eventName] = rules.Clone()
	}

	return rulesMapCopy
}

// Add - adds given rules map.
func (rulesMap RulesMap) Add(rulesMap2 RulesMap) {

	return hashPath(d.Info.Name)
}

// clone returns a copy of the cache with no references to the existing.
func (d *dataUsageCache) clone() dataUsageCache {
	clone := dataUsageCache{
		Info:  d.Info,
		Cache: make(map[string]dataUsageEntry, len(d.Cache)),
	}
	for k, v := range d.Cache {
		clone.Cache[k] = v.clone()
	}
	return clone
}

// merge root of other into d.

    // -----------/
    // - Methods -/
    // -----------/

    /**
     * Method clone.
     *
     * @return InputLocation
     */
    public InputLocation clone() {
        try {
            InputLocation copy = (InputLocation) super.clone();

            if (copy.locations != null) {
                copy.locations = new java.util.LinkedHashMap(copy.locations);

    @Override
    public MavenSession clone() {
        try {
            MavenSession clone = (MavenSession) super.clone();
            // the default must become the current project of the thread that clones this
            MavenProject current = getCurrentProject();
            // we replace the thread local of the clone to prevent write through and enforce the new default value

  GRADLE_BUILD_ACTION_CACHE_DEBUG_ENABLED: true

permissions: {}

jobs:
  build:
    name: "Compile All"
    permissions:
      contents: read
    runs-on: ubuntu-latest
    steps:
      - name: git clone
        uses: actions/checkout@v4
      - id: setup-matrix
        run: echo "matrix=$(jq -c -f .github/workflows/extract-unit-test-split.jq .teamcity/subprojects.json)" >> $GITHUB_OUTPUT
      - name: setup java

		// when transport is nil, it means we are just validating the
		// inputs not performing any network calls.
		return cfg, nil
	}

	// Make sure to clone the transport before editing the ProxyURL
	if proxyURL != nil {
		ctransport := transport.(*http.Transport).Clone()
		ctransport.Proxy = http.ProxyURL((*url.URL)(proxyURL))
		cfg.transport = ctransport
	} else {
		cfg.transport = transport
	}

	return cfg, nil

  <defaults>
    <default>
      <key>package</key>
      <value>org.apache.maven.artifact.repository.metadata</value>
    </default>
  </defaults>
  <classes>
    <class rootElement="true" xml.tagName="metadata" java.clone="deep">
      <name>Metadata</name>
      <version>1.0.0+</version>
      <fields>
        <field xml.attribute="true" xml.tagName="modelVersion">
          <name>modelVersion</name>
          <version>1.1.0+</version>