- Creates a link:{groovyDslPath}/org.gradle.api.Project.html[`Project`] instance for every project.
Phase 2. Configuration::
- Evaluates the build scripts, `build.gradle(.kts)`, of every project participating in the build.
- Creates a task graph for requested tasks.
Phase 3. Execution::
- Schedules and executes the selected tasks.
- Dependencies between tasks determine execution order.

			ID:     i,
			Status: ps.Info.Status.String(),
			Used:   float64(diskStats[i].TotalSpace-diskStats[i].AvailableSpace) / float64(diskStats[i].TotalSpace),
		}
		if !ps.Participating {
			continue
		}
		// for participating pools, total bytes to be rebalanced by this pool is given by,
		// pf_c = (f_i + x)/c_i,
		// pf_c - percentage free space across pools, f_i - ith pool's free space, c_i - ith pool's capacity

 * limitations under the License.
 */

package org.gradle.internal.build;

/**
 * A stand alone nested build, which is a nested build that runs as part of some containing build as a single atomic step, without participating in task execution of the containing build.
 */
public interface StandAloneNestedBuild extends NestedBuildState, BuildActionTarget {
    BuildState getOwner();

public interface ConflictResolutionResult {

    /**
     * Performs an action on all conflicting modules.
     * @param action the action to execute on each participating module
     */
    void withParticipatingModules(Action<? super ModuleIdentifier> action);

    /**
     * The actual selected component.
     */
    ComponentState getSelected();

package org.gradle.internal.classpath;

import org.gradle.api.NonNullApi;

/**
 * Represents a closure that can participate in dynamic calls instrumentation.
 * Initially, such a closure may not be completely prepared for participating in dynamic call interception,
 * which is a performance optimization. <p>
 *
 * Upon an invocation of {@link InstrumentableClosure#makeEffectivelyInstrumented} the instance must perform

	BLT	tail_2
	MOVWZ	(R3), R12
	CMPB	R12, R5, R12
	SLD	$32, R12, R12	// Remove non-participating matches.
	POPCNTD	R12, R12
	ADD	R12, R18, R18
	ADD	$4, R3, R3
	ADD	$-4, R4, R4

tail_2:	// Count the remaining 0 - 3 bytes.
	CMP	R4, $2
	BLT	tail_1
	MOVHZ	(R3), R12
	CMPB	R12, R5, R12
	SLD	$48, R12, R12	// Remove non-participating matches.
	POPCNTD	R12, R12
	ADD	R12, R18, R18
	ADD	$2, R3, R3
	ADD	$-2, R4, R4

public interface PotentialConflict {
    /**
     * Executes an action with each module that participates in the conflict.
     * In a typical version conflict, e.g. org:foo:1.0 VS org:foo:2.0 there is only one participating module: org:foo.
     */
    void withParticipatingModules(Action<ModuleIdentifier> action);

    /**
     * informs whether the conflict exists
     */
    boolean conflictExists();

			}
		case "bs":
			z.Bytes, err = dc.ReadUint64()
			if err != nil {
				err = msgp.WrapError(err, "Bytes")
				return
			}
		case "par":
			z.Participating, err = dc.ReadBool()
			if err != nil {
				err = msgp.WrapError(err, "Participating")
				return
			}
		case "inf":
			err = z.Info.DecodeMsg(dc)
			if err != nil {
				err = msgp.WrapError(err, "Info")
				return
			}
		default:

     *
     * @since 1.11
     */
    boolean isExpected();

    /**
     * Informs whether the selected component is a project substitute from a build participating in a composite build.
     *
     * @since 4.5
     */
    boolean isCompositeSubstitution();

    /**
     * Informs whether the selected component version has been influenced by a dependency constraint.

	NumVersions       uint64        `json:"numVersions" msg:"nv"`        // Number of versions rebalanced
	Bytes             uint64        `json:"bytes" msg:"bs"`              // Number of bytes rebalanced
	Participating     bool          `json:"participating" msg:"par"`
	Info              rebalanceInfo `json:"info" msg:"inf"`
}

func (rs *rebalanceStats) update(bucket string, fi FileInfo) {
	if fi.IsLatest {
		rs.NumObjects++
	}