public GradleApiSpecAggregator(ClassLoader classLoader, Instantiator instantiator) {
        this.classLoader = classLoader;
        this.instantiator = instantiator;
    }

    public Spec aggregate() {
        List<Class<? extends GradleApiSpecProvider>> providers = providers();
        if (providers.isEmpty()) {
            return emptySpec();
        }

        if (providers.size() == 1) {

	atomic.AddUint64(&m.bytesSinceLastWindow, bytes)
}

// updateExponentialMovingAverage processes the measurements captured so far.
func (m *bucketMeasurement) updateExponentialMovingAverage(endTime time.Time) {
	// Calculate aggregate avg bandwidth and exp window avg
	m.lock.Lock()
	defer func() {
		m.startTime = endTime
		m.lock.Unlock()
	}()

	if m.startTime.IsZero() {
		return
	}

	if endTime.Before(m.startTime) {
		return

import com.google.errorprone.annotations.concurrent.LazyInit;
import java.util.Collections;
import java.util.List;
import javax.annotation.CheckForNull;
import org.checkerframework.checker.nullness.qual.Nullable;

/** Aggregate future that collects (stores) results of each future. */
@GwtCompatible(emulated = true)
@ElementTypesAreNonnullByDefault
abstract class CollectionFuture<V extends @Nullable Object, C extends @Nullable Object>

		cl.forwardTo(cm.UpdatedAt)
		merged.UpdatedAt = cm.UpdatedAt
	}

	for i := range cl.Bins {
		merged.Bins[i] = cl.Bins[i].add(cm.Bins[i])
	}

	return merged
}

// DailyAllTierStats is used to aggregate last day tier stats across MinIO servers
type DailyAllTierStats map[string]lastDayTierStats

func (l DailyAllTierStats) merge(m DailyAllTierStats) {
	for tier, st := range m {
		l[tier] = l[tier].merge(st)
	}
}

func (bs BitFields) ParseSigned(i [2]uint32) int64 {
	u, l := bs.parse(i)
	return int64(u) << (64 - l) >> (64 - l)
}

// Count the number of bits in the aggregate BitFields
func (bs BitFields) NumBits() int {
	num := 0
	for _, b := range bs {
		num += int(b.Bits)
	}
	return num

                .setSnapshotPolicy(buildRepositoryPolicy(repository.getSnapshots()))
                .build());
    }

    @Override
    public List<RemoteRepository> aggregate(
            Session session,
            List<RemoteRepository> dominant,
            List<RemoteRepository> recessive,
            boolean processRecessive) {

     *
     * @return conflict resolution
     */
    ConflictResolution getConflictResolution();

    /**
     * @return the dependency substitution rule (may aggregate multiple rules)
     */
    ImmutableActionSet<DependencySubstitutionInternal> getDependencySubstitutionRule();

    /**
     * Used by tests to validate behaviour of the 'task graph modified' state
     */

`assemble`::
_Depends on_: `jar`
+
Aggregate task that assembles all the archives in the project. This task is added by the Base Plugin.

`check`::
_Depends on_: `test`
+

```

where "usability.observability.status" is the feature, and "exist-by-default" is the scenario in the first case, and the second case has no scenario.

Depends on: `linkDebug` when linkage includes `shared` or `createDebug` otherwise.
::
Aggregate task that assembles the debug variant of the shared library (if available) for the current host (if present) in the project.
This task is added by the <<base_plugin.adoc#base_plugin,Base Plugin>>.

`check` - Task (lifecycle)::
Aggregate task that performs verification tasks, such as running the tests.