import org.gradle.internal.service.scopes.Scope


@EventScope(Scope.Build::class)
interface CoupledProjectsListener {
    /**
     * Notified when the build logic for a [referrer] project accesses the mutable state of some other [target] project.
     *
     * The [referrer] and [target] might represent the same project, and the listener implementation

            .mutate {
            it.path "values" node {
                it.addLinkInstance("values.mutable", new MutableValue())
            }
        }

        when:
        registry.get("values")

        then:
        registry.get("values.mutable", MutableValue).value == "foo"
    }

    static class ByTypeBindingSubjectRule extends RuleSource {
        @Mutate

            }

            class TestAttributes {
                // shared mutable state for tests, don't do this at home!
                static AttributeContainer INSTANCE
            }
            TestAttributes.INSTANCE = project.services.get(org.gradle.api.internal.attributes.ImmutableAttributesFactory)
               .mutable()
               .attribute(Attribute.of("test.attribute", String), "value")

    }

    public int size() {
        return children.size();
    }

    @Override
    public DefaultMutableAttributeContainer mutable() {
        return new DefaultMutableAttributeContainer(this);
    }

    @Override
    public HierarchicalAttributeContainer mutable(AttributeContainerInternal fallback) {
        return join(fallback, new DefaultMutableAttributeContainer(this));
    }

    @Override

      pre-calculated execution plan that stays the same during the execution.

      If deciding to add mutable state to this class, it should be at least considered to
      separate this into a separate mutable structure.

    */

    private final List<ExecutionPlanItem> planItem;

    private final Map<String, ExecutionPlanItem> lastMojoExecutionForAllPhases;

 * limitations under the License.
 */

package org.gradle.internal;

import javax.annotation.concurrent.NotThreadSafe;
import java.io.Serializable;

/**
 * A non-thread-safe type to hold a mutable boolean value.
 */
@NotThreadSafe
public final class MutableBoolean implements Serializable {
    private boolean value;

    public MutableBoolean() {
        this(false);
    }

				mutable := &MutableGatewayListener{}
				mutableopts[lname] = mutableListenerOpts{mutable: mutable, opts: opts, transport: transport}
			} else {
				mopts.opts.filterChainOpts = append(mopts.opts.filterChainOpts, opts.filterChainOpts...)
			}
		}
	}
	listeners := make([]*listener.Listener, 0)
	for _, ml := range mutableopts {
		ml.mutable.Listener = buildGatewayListener(*ml.opts, ml.transport)

 * <p>
 * Finalize rules execute after {@link Mutate} rules, but before {@link Validate} rules.
 * The first parameter of the rule is the rule subject, which is mutable for the duration of the rule.
 * <p>
 * Please see {@link RuleSource} for more information on method rules.
 */
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.METHOD)
@Incubating
public @interface Finalize {

 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
package org.gradle.internal;

import org.gradle.api.Action;

/**
 * A mutable composite {@link Action}. Actions are executed in the order added, stopping on the first failure.
 *
 * This type is not thread-safe.
 *
 * Consider using {@link org.gradle.internal.ImmutableActionSet} instead of this.
 *

    /**
     * This method is used to initialize the TransformerContext
     *
     * @param request the modelBuildingRequest
     * @param problems the problemCollector
     * @return the mutable transformerContext
     */
    TransformerContext initialize(ModelBuildingRequest request, ModelProblemCollector problems);

    /**
     * The immutable transformerContext, can be used after the buildplan is finished.