*
     * @param actions The actions to make a composite of.
     * @param <T> The type of the object that action is for
     * @return The composite action.
     */
    public static <T> Action<T> composite(Iterable<? extends Action<? super T>> actions) {
        ImmutableList.Builder<Action<? super T>> builder = ImmutableList.builder();
        for (Action<? super T> action : actions) {
            if (doesSomething(action)) {

 */
package org.gradle.api;

/**
 * Performs some action against objects of type T.
 *
 * @param <T> The type of object which this action accepts.
 */
@HasImplicitReceiver
public interface Action<T> {
    /**
     * Performs this action against the given object.
     *
     * @param t The object to perform the action on.
     */
    void execute(T t);

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

package org.gradle.internal;

public interface BiAction<A, B> {

    void execute(A a, B b);

import org.lastaflute.web.response.StreamResponse;

public class GoAction extends FessSearchAction {

    // ===================================================================================
    //                                                                            Constant
    //
    private static final Logger logger = LogManager.getLogger(GoAction.class);

    @Resource
    protected PathMappingHelper pathMappingHelper;

        return new BiAction<A, B>() {
            @Override
            public void execute(A a, B b) {
                for (BiAction<? super A, ? super B> action : actions) {
                    action.execute(a, b);
                }
            }
        };
    }

    public static <A> BiAction<A, Object> usingFirstArgument(final Action<? super A> action) {

            return this;
        }

        public Builder action(ModelActionRole role, ModelAction action) {
            this.actions.put(role, action);
            return this;
        }

        public Builder action(ModelActionRole role, Action<? super MutableModelNode> action) {
            return action(role, new NoInputsBuilderAction(reference, descriptorReference, action));
        }

        client?.stop()
    }

    def "manages contention for multiple locks"() {
        def action1 = new AtomicBoolean()
        def action2 = new AtomicBoolean()

        when:
        int port = handler.reservePort()
        handler.start(10, { action1.set(true) })
        handler.start(11, { action2.set(true) })

        client.maybePingOwner(port, 10, "lock 1", 50000, null)

                            ModelActionRole role = actionInRole.getKey();
                            ModelAction action = actionInRole.getValue();
                            node.applyToSelf(role, action);
                        }
                    }
                });
            }

            registration.action(ModelActionRole.Initialize,

    }

    public <I> ModelAction action(ModelPath modelPath, Class<I> inputType, BiAction<? super T, ? super I> action) {
        return action(modelPath, ModelType.of(inputType), action);
    }

    public <I> ModelAction action(String modelPath, Class<I> inputType, BiAction<? super T, ? super I> action) {
        return action(ModelPath.path(modelPath), ModelType.of(inputType), action);
    }

            "afterEvaluate action cannot execute before beforeEvaluate"
        }
        executeAll(actions.afterProject, project)
    }

    private
    fun executeAll(actions: IsolatedProjectActionList, project: Project) {
        for (action in actions) {
            action.execute(project)
        }
    }

    private
    fun isolatedActions() = IsolateOwners.OwnerGradle(gradle).let { owner ->