    001// Copyright 2010, 2011 The Apache Software Foundation
    002//
    003// Licensed under the Apache License, Version 2.0 (the "License");
    004// you may not use this file except in compliance with the License.
    005// You may obtain a copy of the License at
    006//
    007// http://www.apache.org/licenses/LICENSE-2.0
    008//
    009// Unless required by applicable law or agreed to in writing, software
    010// distributed under the License is distributed on an "AS IS" BASIS,
    011// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
    012// See the License for the specific language governing permissions and
    013// limitations under the License.
    014
    015package org.apache.tapestry5.func;
    016
    017import java.util.Map;
    018
    019/**
    020 * The result of the {@link Flow#zipWith(Flow)} method (or created from a Map via {@link F#zippedFlow(Map)}), a Flow of
    021 * combined {@link Tuple} values (that can be deconstructed, eventually, using {@link #unzip()}).
    022 *
    023 * @param <A> first type
    024 * @param <B> second type
    025 * @since 5.3
    026 */
    027public interface ZippedFlow<A, B> extends FlowOperations<Tuple<A, B>, ZippedFlow<A, B>>
    028{
    029    /**
    030     * Mapping for zipped flows; a mapper is used to map tuples of this zipped flow into new tuples
    031     * with a new type, forming the resulting zipped flow. This is a lazy operation.
    032     */
    033    <X, Y> ZippedFlow<X, Y> mapTuples(Mapper<Tuple<A, B>, Tuple<X, Y>> mapper);
    034
    035    /**
    036     * A ZippedFlow is a Flow of Tuples; this inverts that, splitting each Tuple into
    037     * a Flow of elements, then assembling the result as a Tuple of two values. This is a lazy
    038     * operation.
    039     *
    040     * @return two flows of unzipped Tuples
    041     */
    042    Tuple<Flow<A>, Flow<B>> unzip();
    043
    044    /**
    045     * Returns a flow of the first values of the tuples of the zipped flow. This is a lazy
    046     * operation.
    047     */
    048    Flow<A> firsts();
    049
    050    /**
    051     * Returns a flow of the second values of the tuples of the zipped flow. This is a lazy
    052     * operation.
    053     */
    054    Flow<B> seconds();
    055
    056    /**
    057     * Filters the tuples in the zipped flow by applying a predicate to the first value in each tuple.
    058     * This is a lazy operation.
    059     */
    060    ZippedFlow<A, B> filterOnFirst(Predicate<? super A> predicate);
    061
    062    /**
    063     * Filters the tuples in the zipped flow by applying a predicate to the second value in each tuple. This
    064     * is a lazy operations.
    065     */
    066    ZippedFlow<A, B> filterOnSecond(Predicate<? super B> predicate);
    067
    068    /**
    069     * Removes tuples from the zipped flow by applying a predicate to the first value in each tuple.
    070     * This is a lazy operation.
    071     */
    072    ZippedFlow<A, B> removeOnFirst(Predicate<? super A> predicate);
    073
    074    /**
    075     * Removes tuples from the zipped flow by applying a predicate to the second value in each tuple. This
    076     * is a lazy operations.
    077     */
    078    ZippedFlow<A, B> removeOnSecond(Predicate<? super B> predicate);
    079
    080    /**
    081     * Constructs a HashMap by converting the tuples of the zipped flow into keys (first tuple value) and values (second
    082     * tuple value).
    083     */
    084    Map<A, B> toMap();
    085}