* See the License for the specific language governing permissions and
 * limitations under the License.
 */

package org.gradle.internal;

/**
 * Mutable value type for which mutation can be disabled at a certain point in time,
 * by calling the {@code disableFurtherMutations()} method.
 * <p>

 * @since 4.6
 */
public interface InjectedPluginDependencies {
    /**
     * Add a dependency on the plugin with the given id.
     *
     * @param id the id of the plugin to depend on
     *
     * @return a mutable injected plugin dependency that can be used to further refine the dependency
     */
    InjectedPluginDependency id(String id);

  static SessionOptions MakeDefaultSessionOptions(const string& target);
  Status MaybeExtendGraph() const;

  std::unique_ptr<Session> session_;
  std::shared_ptr<Graph> graph_;

  mutable mutex mu_;
  mutable int last_num_graph_nodes_ TF_GUARDED_BY(mu_) = 0;
};

ClientSession::ClientSession(const Scope& scope, const string& target)
    : ClientSession(scope, Impl::MakeDefaultSessionOptions(target)) {}

 * limitations under the License.
 */

package com.google.common.collect;

import com.google.common.annotations.GwtCompatible;
import java.io.Serializable;
import javax.annotation.CheckForNull;

/**
 * A mutable value of type {@code int}, for multisets to use in tracking counts of values.
 *
 * @author Louis Wasserman
 */
@GwtCompatible
@ElementTypesAreNonnullByDefault
final class Count implements Serializable {

        validateMutation();
    }

    @Override
    public void copyTo(AbstractExternalModuleDependency target) {
        super.copyTo(target);
    }

    // Intentionally changes to the mutable version.
    @Override
    public DefaultMutableMinimalDependency copy() {

    }

    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);
      }
    }

 * so while the value of the variable does not change, the value itself may still be mutable.</p>
 *
 * <p>When a task property has a value of this type, it will be implicitly finalized when the task starts execution, to prevent accidental changes to the task parameters as the task runs.</p>
 *

import org.gradle.api.model.ObjectFactory;
import org.gradle.api.provider.Provider;

import javax.annotation.Nullable;
import java.io.File;

/**
 * Represents some configurable regular file location, whose value is mutable.
 *
 * <p>
 * You can create a {@link RegularFileProperty} using {@link ObjectFactory#fileProperty()}.
 * </p>
 *
 * <p><b>Note:</b> This interface is not intended for implementation by build script or plugin authors.</p>

            modelView = getAdapter().asImmutable(type, this, ruleDescriptor);
        }
        if (modelView == null) {
            throw new IllegalStateException("Model element " + getPath() + " cannot be expressed as a mutable view of type " + type);
        }
        return modelView;
    }

    @Override
    public <T> T getPrivateData(Class<T> type) {
        return getPrivateData(ModelType.of(type));
    }

    @Override

import org.gradle.tooling.provider.model.internal.ToolingModelScope;

import java.util.List;
import java.util.function.Supplier;

public interface BuildTreeModelController {
    /**
     * Returns the mutable model, configuring if necessary.
     */
    GradleInternal getConfiguredModel();

    ToolingModelScope locateBuilderForDefaultTarget(String modelName, boolean param);