001/*
002 * ============================================================================
003 * Copyright © 2002-2023 by Thomas Thrien.
004 * All Rights Reserved.
005 * ============================================================================
006 * Licensed to the public under the agreements of the GNU Lesser General Public
007 * License, version 3.0 (the "License"). You may obtain a copy of the License at
008 *
009 *      http://www.gnu.org/licenses/lgpl.html
010 *
011 * Unless required by applicable law or agreed to in writing, software
012 * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
013 * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
014 * License for the specific language governing permissions and limitations
015 * under the License.
016 */
017
018package org.tquadrat.foundation.stream;
019
020import static org.apiguardian.api.API.Status.STABLE;
021import static org.tquadrat.foundation.lang.Objects.requireNonNullArgument;
022
023import java.util.Comparator;
024import java.util.Iterator;
025import java.util.Optional;
026import java.util.Spliterator;
027import java.util.function.BiConsumer;
028import java.util.function.BiFunction;
029import java.util.function.BinaryOperator;
030import java.util.function.Consumer;
031import java.util.function.Function;
032import java.util.function.IntFunction;
033import java.util.function.Predicate;
034import java.util.function.Supplier;
035import java.util.function.ToDoubleFunction;
036import java.util.function.ToIntFunction;
037import java.util.function.ToLongFunction;
038import java.util.stream.Collector;
039import java.util.stream.DoubleStream;
040import java.util.stream.IntStream;
041import java.util.stream.LongStream;
042import java.util.stream.Stream;
043
044import org.apiguardian.api.API;
045import org.tquadrat.foundation.annotation.ClassVersion;
046import org.tquadrat.foundation.annotation.MountPoint;
047
048/**
049 *  This class allows to intercept the calls to the methods of
050 *  {@link Stream}. The default implementations of the methods will just
051 *  delegate to the wrapped stream.
052 *
053 *  @extauthor Thomas Thrien - thomas.thrien@tquadrat.org
054 *  @version $Id: StreamAdapter.java 1060 2023-09-24 19:21:40Z tquadrat $
055 *  @since 0.0.7
056 *
057 *  @param  <T> The type of the stream's elements.
058 *
059 *  @UMLGraph.link
060 */
061@ClassVersion( sourceVersion = "$Id: StreamAdapter.java 1060 2023-09-24 19:21:40Z tquadrat $" )
062@API( status = STABLE, since = "0.0.7" )
063public class StreamAdapter<T> implements Stream<T>
064{
065        /*------------*\
066    ====** Attributes **=======================================================
067        \*------------*/
068    /**
069     *  The wrapped stream.
070     */
071    private final Stream<T> m_Wrapped;
072
073        /*--------------*\
074    ====** Constructors **=====================================================
075        \*--------------*/
076    /**
077     *  Creates a new {@code StreamAdapter} instance.
078     *
079     *  @param  wrapped The stream that is wrapped by this adapter.
080     */
081    public StreamAdapter( final Stream<T> wrapped )
082    {
083        m_Wrapped = requireNonNullArgument( wrapped, "wrapped" );
084    }   //  StreamAdapter()
085
086        /*---------*\
087    ====** Methods **==========================================================
088        \*---------*/
089    /**
090     *  {@inheritDoc}
091     */
092    @MountPoint
093    @Override
094    public boolean allMatch( final Predicate<? super T> predicate ) { return m_Wrapped.allMatch( predicate ); }
095
096    /**
097     *  {@inheritDoc}
098     */
099    @MountPoint
100    @Override
101    public boolean anyMatch( final Predicate<? super T> predicate ) { return m_Wrapped.anyMatch( predicate ); }
102
103    /**
104     *  {@inheritDoc}
105     */
106    @MountPoint
107    @Override
108    public void close() { m_Wrapped.close(); }
109
110    /**
111     *  {@inheritDoc}
112     */
113    @MountPoint
114    @Override
115    public <R,A> R collect( final Collector<? super T,A,R> collector ) { return m_Wrapped.collect( collector ); }
116
117    /**
118     *  {@inheritDoc}
119     */
120    @MountPoint
121    @Override
122    public <R> R collect( final Supplier<R> supplier, final BiConsumer<R,? super T> accumulator, final BiConsumer<R,R> combiner ) { return m_Wrapped.collect( supplier, accumulator, combiner ); }
123
124    /**
125     *  {@inheritDoc}
126     */
127    @MountPoint
128    @Override
129    public long count() { return m_Wrapped.count(); }
130
131    /**
132     *  {@inheritDoc}
133     */
134    @MountPoint
135    @Override
136    public Stream<T> distinct() { return m_Wrapped.distinct(); }
137
138    /**
139     *  {@inheritDoc}
140     */
141    @MountPoint
142    @Override
143    public Stream<T> dropWhile( final Predicate<? super T> predicate ) { return m_Wrapped.dropWhile( predicate ); }
144
145    /**
146     *  {@inheritDoc}
147     */
148    @MountPoint
149    @Override
150    public Stream<T> filter( final Predicate<? super T> predicate ) { return m_Wrapped.filter( predicate ); }
151
152    /**
153     *  {@inheritDoc}
154     */
155    @MountPoint
156    @Override
157    public Optional<T> findAny() { return m_Wrapped.findAny(); }
158
159    /**
160     *  {@inheritDoc}
161     */
162    @MountPoint
163    @Override
164    public Optional<T> findFirst() { return m_Wrapped.findFirst(); }
165
166    /**
167     *  {@inheritDoc}
168     */
169    @MountPoint
170    @Override
171    public <R> Stream<R> flatMap( final Function<? super T,? extends Stream<? extends R>> mapper ) { return m_Wrapped.flatMap( mapper ); }
172
173    /**
174     *  {@inheritDoc}
175     */
176    @MountPoint
177    @Override
178    public DoubleStream flatMapToDouble( final Function<? super T,? extends DoubleStream> mapper ) { return m_Wrapped.flatMapToDouble( mapper ); }
179
180    /**
181     *  {@inheritDoc}
182     */
183    @MountPoint
184    @Override
185    public IntStream flatMapToInt( final Function<? super T,? extends IntStream> mapper ) { return m_Wrapped.flatMapToInt( mapper ); }
186
187    /**
188     *  {@inheritDoc}
189     */
190    @MountPoint
191    @Override
192    public LongStream flatMapToLong( final Function<? super T,? extends LongStream> mapper ) { return m_Wrapped.flatMapToLong( mapper ); }
193
194    /**
195     *  {@inheritDoc}
196     */
197    @MountPoint
198    @Override
199    public void forEach( final Consumer<? super T> action ) { m_Wrapped.forEach( action ); }
200
201    /**
202     *  {@inheritDoc}
203     */
204    @MountPoint
205    @Override
206    public void forEachOrdered( final Consumer<? super T> action ) { m_Wrapped.forEachOrdered( action ); }
207
208    /**
209     *  {@inheritDoc}
210     */
211    @MountPoint
212    @Override
213    public boolean isParallel() { return m_Wrapped.isParallel(); }
214
215    /**
216     *  {@inheritDoc}
217     */
218    @MountPoint
219    @Override
220    public Iterator<T> iterator() { return m_Wrapped.iterator(); }
221
222    /**
223     *  {@inheritDoc}
224     */
225    @MountPoint
226    @Override
227    public Stream<T> limit( final long maxSize ) { return m_Wrapped.limit( maxSize ); }
228
229    /**
230     *  {@inheritDoc}
231     */
232    @MountPoint
233    @Override
234    public <R> Stream<R> map( final Function<? super T,? extends R> mapper ) { return m_Wrapped.map( mapper ); }
235
236    /**
237     *  {@inheritDoc}
238     */
239    @MountPoint
240    @Override
241    public DoubleStream mapToDouble( final ToDoubleFunction<? super T> mapper ) { return m_Wrapped.mapToDouble( mapper ); }
242
243    /**
244     *  {@inheritDoc}
245     */
246    @MountPoint
247    @Override
248    public IntStream mapToInt( final ToIntFunction<? super T> mapper ) { return m_Wrapped.mapToInt( mapper ); }
249
250    /**
251     *  {@inheritDoc}
252     */
253    @MountPoint
254    @Override
255    public LongStream mapToLong( final ToLongFunction<? super T> mapper ) { return m_Wrapped.mapToLong( mapper ); }
256
257    /**
258     *  {@inheritDoc}
259     */
260    @MountPoint
261    @Override
262    public Optional<T> max( final Comparator<? super T> comparator ) { return m_Wrapped.max( comparator ); }
263
264    /**
265     *  {@inheritDoc}
266     */
267    @MountPoint
268    @Override
269    public Optional<T> min( final Comparator<? super T> comparator ) { return m_Wrapped.min( comparator ); }
270
271    /**
272     *  {@inheritDoc}
273     */
274    @MountPoint
275    @Override
276    public boolean noneMatch( final Predicate<? super T> predicate ) { return m_Wrapped.noneMatch( predicate ); }
277
278    /**
279     *  {@inheritDoc}
280     */
281    @MountPoint
282    @Override
283    public Stream<T> onClose( final Runnable closeHandler ) { return m_Wrapped.onClose( closeHandler ); }
284
285    /**
286     *  {@inheritDoc}
287     */
288    @MountPoint
289    @Override
290    public Stream<T> parallel() { return m_Wrapped.parallel(); }
291
292    /**
293     *  {@inheritDoc}
294     */
295    @MountPoint
296    @Override
297    public Stream<T> peek( final Consumer<? super T> action ) { return m_Wrapped.peek( action ); }
298
299    /**
300     *  {@inheritDoc}
301     */
302    @MountPoint
303    @Override
304    public Optional<T> reduce( final BinaryOperator<T> accumulator ) { return m_Wrapped.reduce( accumulator ); }
305
306    /**
307     *  {@inheritDoc}
308     */
309    @MountPoint
310    @Override
311    public T reduce( final T identity, final BinaryOperator<T> accumulator ) { return m_Wrapped.reduce( identity, accumulator ); }
312
313    /**
314     *  {@inheritDoc}
315     */
316    @MountPoint
317    @Override
318    public <U> U reduce( final U identity, final BiFunction<U,? super T,U> accumulator, final BinaryOperator<U> combiner ) { return m_Wrapped.reduce( identity, accumulator, combiner ); }
319
320    /**
321     *  {@inheritDoc}
322     */
323    @MountPoint
324    @Override
325    public Stream<T> sequential() { return m_Wrapped.sequential(); }
326
327    /**
328     *  {@inheritDoc}
329     */
330    @MountPoint
331    @Override
332    public Stream<T> skip( final long n ) { return m_Wrapped.skip( n ); }
333
334    /**
335     *  {@inheritDoc}
336     */
337    @MountPoint
338    @Override
339    public Stream<T> sorted() { return m_Wrapped.sorted(); }
340
341    /**
342     *  {@inheritDoc}
343     */
344    @MountPoint
345    @Override
346    public Stream<T> sorted( final Comparator<? super T> comparator ) { return m_Wrapped.sorted( comparator ); }
347
348    /**
349     *  {@inheritDoc}
350     */
351    @MountPoint
352    @Override
353    public Spliterator<T> spliterator() { return m_Wrapped.spliterator(); }
354
355    /**
356     *  {@inheritDoc}
357     */
358    @MountPoint
359    @Override
360    public Stream<T> takeWhile( final Predicate<? super T> predicate ) { return m_Wrapped.takeWhile( predicate ); }
361
362    /**
363     *  {@inheritDoc}
364     */
365    @MountPoint
366    @Override
367    public Object [] toArray() { return m_Wrapped.toArray(); }
368
369    /**
370     *  {@inheritDoc}
371     */
372    @MountPoint
373    @Override
374    public <A> A [] toArray( final IntFunction<A []> generator ) { return m_Wrapped.toArray( generator ); }
375
376    /**
377     *  {@inheritDoc}
378     */
379    @MountPoint
380    @Override
381    public Stream<T> unordered() { return m_Wrapped.unordered(); }
382}
383//  class StreamAdapter
384
385/*
386 *  End of File
387 */