}

    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;

    }

    void add(Object o) {
      checkNotNull(o);
      if (element == null) {
        this.element = o;
      } else if (extras.isEmpty()) {
        // Replace immutable empty list with mutable list.
        extras = new ArrayList<>(MAX_EXTRAS);
        extras.add(o);
      } else if (extras.size() < MAX_EXTRAS) {
        extras.add(o);
      } else {
        throw multiples(true);
      }
    }

 * 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.

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

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

 * @since 8.1
 */
@Incubating
public interface FlowActionSpec<P extends FlowParameters> {

    /**
     * Returns the parameters defined by the configured {@link FlowAction dataflow action}.
     *
     * @return mutable parameters object, never null.
     * @since 8.1
     */
    P getParameters();

    /**
     * Configures the {@link P parameters} for the {@link FlowAction flow action}.
     *
     * @since 8.7
     */