@J2ktIncompatible
@GwtIncompatible
@ElementTypesAreNonnullByDefault
public interface FinalizableReference {
  /**
   * Invoked on a background thread after the referent has been garbage collected unless security
   * restrictions prevented starting a background thread, in which case this method is invoked when
   * new references are created.
   */
  void finalizeReferent();

    public ProjectionOnlyNodeInitializer(ModelProjection... projections) {
        this.projections = projections;
    }

    @Override
    public Multimap<ModelActionRole, ModelAction> getActions(ModelReference<?> subject, ModelRuleDescriptor descriptor) {
        return ImmutableSetMultimap.<ModelActionRole, ModelAction>builder()

        def task = TestUtil.create(temporaryFolder).createTask(TestTask, project, name)
        assertTrue(TestTask.isAssignableFrom(task.getClass()))
        return task
    }

    def "can add action to a task via Task.getActions() List"() {
        setup:
        def task = createTask("task")
        when:
        def actions = task.actions
        and:
        def action = Mock(Action)

        actions.add(action)
        then:

										LocalObjectReference: api.LocalObjectReference{Name: "foo"},
									},
								},
							},
						},
					},
				},
			},
		},
	}
	// validate enforces restrictions on secret mounts when operation==create and subresource=='' or operation==update and subresource==ephemeralcontainers"

 * limitations under the License.
 */

package org.gradle.internal;

/**
 * Equivalent to {@code Transformer}, but does not declare nullability due to Java 6 restrictions.
 *
 * <p>A {@code Transformer} transforms objects of type.</p>
 *
 * <p>Implementations are free to return new objects or mutate the incoming value.</p>
 *
 * @param <OUT> The type the value is transformed to.

    @Override
    public void finished() {
        actions.clear();
    }

    @Override
    public List<Action<? super ProjectInternal>> getActions() {
        return actions;
    }

    @Override
    public void add(Action<? super ProjectInternal> action) {
        actions.add(action);
    }

    @Override
    public void add(Closure action) {

/**
 * A container responsible for managing the configuration of a project.
 */
public interface ProjectConfigurationActionContainer {
    void finished();

    Iterable<Action<? super ProjectInternal>> getActions();

    /**
     * Registers an action to execute to configure the project. Actions are executed in an arbitrary order.
     */
    void add(Action<? super ProjectInternal> action);

    /**

    ModelRuleDescriptor getDescriptor();

    ModelPath getPath();

    /**
     * Actions that need to be registered when the node is registered.
     */
    Multimap<ModelActionRole, ? extends ModelAction> getActions();

    /**
     * Returns whether the registered node is hidden.
     */
    boolean isHidden();

			// avoid anonymous interface cycles.
			hash += 3*hashString(m.Name()) + 5*h.shallowHash(m.Type())
		}

		// Hash type restrictions.
		terms, err := typeparams.InterfaceTermSet(t)
		// if err != nil t has invalid type restrictions.
		if err == nil {
			hash += h.hashTermSet(terms)
		}

		return hash

	case *types.Map:
		return 9109 + 2*h.Hash(t.Key()) + 3*h.Hash(t.Elem())

@J2ktIncompatible
@GwtIncompatible
@ElementTypesAreNonnullByDefault
public interface FinalizableReference {
  /**
   * Invoked on a background thread after the referent has been garbage collected unless security
   * restrictions prevented starting a background thread, in which case this method is invoked when
   * new references are created.
   */
  void finalizeReferent();