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>
024 * @param <B>
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}