" ".separated(
                            { typeRenderer.annotationsRenderer.renderAnnotations(analysisSession, type, printer) },
                            { append(lower.classId.asFqNameString().replace("Mutable", "(Mutable)")) },
                        )
                        printCollectionIfNotEmpty(lower.typeArguments, prefix = "<", postfix = ">") { typeArgument ->

    /**
     * Creates a (potentially) mutable view over this node's value. When this node is not mutable, an immutable view is returned instead.
     *
     * Callers should try to {@link ModelView#close()} the returned view when it is done with, allowing any internal cleanup to occur.
     *
     * Throws if this node can't be expressed as a mutable view of the requested type.
     */

  // Whether to enable TFLite variables or not, this will allow
  // mutable variables and produce ReadVariable/AssignVariable ops in TFLite.
  bool enable_tflite_variables = false;
  // Whether to disable the variable freezing pass or not.
  // By default we freeze all variables and disallow mutable variables. When
  // 'enable_tflite_variables' is true then we allow mutable variable only.
  bool disable_variable_freezing = false;

    if (global_tensor.getIsMutable()) {
      if (allow_mutable_tensors) continue;
      global_tensor.emitError()
          << "is not immutable, try removing mutable variables in your model "
             "since mutable variables are currently not supported through "
             "this converter";
      return signalPassFailure();
    }
  }

            new DefaultSoftwareComponentVariant("test", AttributeTestUtil.attributesFactory().mutable()),
            new DefaultSoftwareComponentVariant("test", AttributeTestUtil.attributesFactory().mutable())
        )
    }

    private TargetMachine targetMachine(String os, String arch) {
        def objectFactory = TestUtil.objectFactory()

            // most cases. We could create an empty attribute set directly in the AbstractDependencyImpl,
            // but then it wouldn't be mutable. Therefore we proceed with "late injection" of the attributes
            ((AbstractDependencyImpl<?>) dependencyMetadata).setAttributes(attributesFactory.mutable());
        }

        T adapted = adapt(dependencyMetadata);
        if (configureAction != null) {

import org.gradle.model.internal.core.rule.describe.ModelRuleDescriptor;

public interface ModelViewFactory<M> {
    ModelView<M> toView(MutableModelNode modelNode, ModelRuleDescriptor ruleDescriptor, boolean mutable);

		connectionPool = &networking.ConnectionPoolSettings{}
	}
	cb.applyConnectionPool(opts.mesh, opts.mutable, connectionPool)
	if opts.direction != model.TrafficDirectionInbound {
		cb.applyH2Upgrade(opts.mutable, opts.port, opts.mesh, connectionPool)
		applyOutlierDetection(opts.mutable.cluster, outlierDetection)
		applyLoadBalancer(opts.mutable.cluster, loadBalancer, opts.port, cb.locality, cb.proxyLabels, opts.mesh)

        this.path = path;
        this.type = type;
        this.elementType = elementType;
        this.modelNode = modelNode;
        this.overwritable = overwritable;
        this.state = new DefaultModelViewState(path, type, descriptor, mutable, false);
    }

    @Override
    public ModelPath getPath() {
        return path;

    /**
     * Have the projects been loaded, ie has {@link #ensureProjectsLoaded()} already completed for this build?
     */
    boolean isProjectsLoaded();

    /**
     * Has the mutable model for projects been created yet?
     *
     * @see ProjectState#isCreated()
     */
    boolean isProjectsCreated();

    /**
     * Ensures all projects in this build are configured, if not already done.