/****************************************************************************

**

** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).

** All rights reserved.

** Contact: Nokia Corporation (qt-info@nokia.com)

**

** This file is part of the QtCore module of the Qt Toolkit.

**

** $QT_BEGIN_LICENSE:LGPL$

** No Commercial Usage

** This file contains pre-release code and may not be distributed.

** You may use this file in accordance with the terms and conditions

** contained in the Technology Preview License Agreement accompanying

** this package.

**

** GNU Lesser General Public License Usage

** Alternatively, this file may be used under the terms of the GNU Lesser

** General Public License version 2.1 as published by the Free Software

** Foundation and appearing in the file LICENSE.LGPL included in the

** packaging of this file.  Please review the following information to

** ensure the GNU Lesser General Public License version 2.1 requirements

** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.

**

** In addition, as a special exception, Nokia gives you certain additional

** rights.  These rights are described in the Nokia Qt LGPL Exception

** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.

**

** If you have questions regarding the use of this file, please contact

** Nokia at qt-info@nokia.com.

**

**

**

**

**

**

**

**

** $QT_END_LICENSE$

**

****************************************************************************/

#ifndef QTCONCURRENT_MAP_H

#define QTCONCURRENT_MAP_H

#include <QtCore/qglobal.h>

#ifndef QT_NO_CONCURRENT

#include <QtCore/qtconcurrentmapkernel.h>

#include <QtCore/qtconcurrentreducekernel.h>

#include <QtCore/qtconcurrentfunctionwrappers.h>

#include <QtCore/qstringlist.h>

QT_BEGIN_HEADER

QT_BEGIN_NAMESPACE

QT_MODULE(Core)

#ifdef qdoc

namespace QtConcurrent {

    QFuture<void> map(Sequence &sequence, MapFunction function);

    QFuture<void> map(Iterator begin, Iterator end, MapFunction function);

    template <typename T>

    QFuture<T> mapped(const Sequence &sequence, MapFunction function);

    template <typename T>

    QFuture<T> mapped(ConstIterator begin, ConstIterator end, MapFunction function);

    template <typename T>

    QFuture<T> mappedReduced(const Sequence &sequence,

                             MapFunction function,

                             ReduceFunction function,

                             QtConcurrent::ReduceOptions options = UnorderedReduce | SequentialReduce);

    template <typename T>

    QFuture<T> mappedReduced(ConstIterator begin,

                             ConstIterator end,

                             MapFunction function,

                             ReduceFunction function,

                             QtConcurrent::ReduceOptions options = UnorderedReduce | SequentialReduce);

    void blockingMap(Sequence &sequence, MapFunction function);

    void blockingMap(Iterator begin, Iterator end, MapFunction function);

    template <typename T>

    T blockingMapped(const Sequence &sequence, MapFunction function);

    template <typename T>

    T blockingMapped(ConstIterator begin, ConstIterator end, MapFunction function);

    template <typename T>

    T blockingMappedReduced(const Sequence &sequence,

                            MapFunction function,

                            ReduceFunction function,

                            QtConcurrent::ReduceOptions options = UnorderedReduce | SequentialReduce);

    template <typename T>

    T blockingMappedReduced(ConstIterator begin,

                            ConstIterator end,

                            MapFunction function,

                            ReduceFunction function,

                            QtConcurrent::ReduceOptions options = UnorderedReduce | SequentialReduce);

} // namespace QtConcurrent

#else

namespace QtConcurrent {

// map() on sequences

template <typename Sequence, typename MapFunctor>

QFuture<void> map(Sequence &sequence, MapFunctor map)

{

    return startMap(sequence.begin(), sequence.end(), map);

}

template <typename Sequence, typename T, typename U>

QFuture<void> map(Sequence &sequence, T (map)(U))

{

    return startMap(sequence.begin(), sequence.end(), FunctionWrapper1<T, U>(map));

}

template <typename Sequence, typename T, typename C>

QFuture<void> map(Sequence &sequence, T (C::*map)())

{

    return startMap(sequence.begin(), sequence.end(), MemberFunctionWrapper<T, C>(map));

}

// map() on iterators

template <typename Iterator, typename MapFunctor>

QFuture<void> map(Iterator begin, Iterator end, MapFunctor map)

{

    return startMap(begin, end, map);

}

template <typename Iterator, typename T, typename U>

QFuture<void> map(Iterator begin, Iterator end, T (map)(U))

{

    return startMap(begin, end, FunctionWrapper1<T, U>(map));

}

template <typename Iterator, typename T, typename C>

QFuture<void> map(Iterator begin, Iterator end, T (C::*map)())

{

    return startMap(begin, end, MemberFunctionWrapper<T, C>(map));

}

// mappedReduced() for sequences.

template <typename ResultType, typename Sequence, typename MapFunctor, typename ReduceFunctor>

QFuture<ResultType> mappedReduced(const Sequence &sequence,

                                  MapFunctor map,

                                  ReduceFunctor reduce,

                                  ReduceOptions options = ReduceOptions(UnorderedReduce | SequentialReduce))

{

    return startMappedReduced<typename MapFunctor::result_type, ResultType>

    (sequence, map, reduce, options);

}

template <typename Sequence, typename MapFunctor, typename T, typename U, typename V>

QFuture<U> mappedReduced(const Sequence &sequence,

                         MapFunctor map,

                         T (reduce)(U &, V),

                         ReduceOptions options = ReduceOptions(UnorderedReduce | SequentialReduce))

{

    return startMappedReduced<typename MapFunctor::result_type, U>

    (sequence, map, FunctionWrapper2<T, U &, V>(reduce), options);

}

template <typename Sequence, typename MapFunctor, typename T, typename C, typename U>

QFuture<C> mappedReduced(const Sequence &sequence,

                         MapFunctor map,

                         T (C::*reduce)(U),

                         ReduceOptions options = ReduceOptions(UnorderedReduce | SequentialReduce))

{

    return startMappedReduced<typename MapFunctor::result_type, C>

    (sequence, map, MemberFunctionWrapper1<T, C, U>(reduce), options);

}

template <typename ResultType, typename Sequence, typename T, typename U, typename ReduceFunctor>

QFuture<ResultType> mappedReduced(const Sequence &sequence,

                                  T (map)(U),

                                  ReduceFunctor reduce,

                                  ReduceOptions options = ReduceOptions(UnorderedReduce | SequentialReduce))

{

    return startMappedReduced<T, ResultType>

    (sequence, FunctionWrapper1<T, U>(map), reduce, options);

}

template <typename ResultType, typename Sequence, typename T, typename C, typename ReduceFunctor>

QFuture<ResultType> mappedReduced(const Sequence &sequence,

                                  T (C::*map)() const,

                                  ReduceFunctor reduce,

                                  ReduceOptions options = ReduceOptions(UnorderedReduce | SequentialReduce))

{

    return startMappedReduced<T, ResultType>

    (sequence, ConstMemberFunctionWrapper<T, C>(map), reduce, options);

}

template <typename Sequence, typename T, typename U, typename V, typename W, typename X>

QFuture<W> mappedReduced(const Sequence &sequence,

                         T (map)(U),

                         V (reduce)(W &, X),

                         ReduceOptions options = ReduceOptions(UnorderedReduce | SequentialReduce))

{

    return startMappedReduced<T, W>

    (sequence, FunctionWrapper1<T, U>(map), FunctionWrapper2<V, W &, X>(reduce), options);

}

template <typename Sequence, typename T, typename C, typename U, typename V, typename W>

QFuture<V> mappedReduced(const Sequence &sequence,

                         T (C::*map)() const,

                         U (reduce)(V &, W),

                         ReduceOptions options = ReduceOptions(UnorderedReduce | SequentialReduce))

{

    return startMappedReduced<T, V> (sequence, ConstMemberFunctionWrapper<T, C>(map),

                                    FunctionWrapper2<U, V &, W>(reduce), options);

}

template <typename Sequence, typename T, typename U, typename V, typename C, typename W>

QFuture<C> mappedReduced(const Sequence &sequence,

                         T (map)(U),

                         V (C::*reduce)(W),

                         ReduceOptions options = ReduceOptions(UnorderedReduce | SequentialReduce))

{

    return startMappedReduced<T, C> (sequence, FunctionWrapper1<T, U>(map),

                                     MemberFunctionWrapper1<V, C, W>(reduce), options);

}

template <typename Sequence, typename T, typename C, typename U,typename D, typename V>

QFuture<D> mappedReduced(const Sequence &sequence,

                         T (C::*map)() const,

                         U (D::*reduce)(V),

                         ReduceOptions options = ReduceOptions(UnorderedReduce | SequentialReduce))

{

    return startMappedReduced<T, D>(sequence, ConstMemberFunctionWrapper<T, C>(map),

                                    MemberFunctionWrapper1<U, D, V>(reduce), options);

}

// mappedReduced() for iterators

template <typename ResultType, typename Iterator, typename MapFunctor, typename ReduceFunctor>

QFuture<ResultType> mappedReduced(Iterator begin,

                                  Iterator end,

                                  MapFunctor map,

                                  ReduceFunctor reduce,

                                  ReduceOptions options = ReduceOptions(UnorderedReduce | SequentialReduce))

{

    return startMappedReduced<ResultType, typename MapFunctor::result_type>

    (begin, end, map, reduce, options);

}

template <typename Iterator, typename MapFunctor, typename T, typename U, typename V>

QFuture<U> mappedReduced(Iterator begin,

                         Iterator end,

                         MapFunctor map,

                         T (reduce)(U &, V),

                         ReduceOptions options = ReduceOptions(UnorderedReduce | SequentialReduce))

{

    return startMappedReduced<typename MapFunctor::result_type, U>

    (begin, end, map, FunctionWrapper2<T, U &, V>(reduce), options);

}

template <typename Iterator, typename MapFunctor, typename T, typename C, typename U>

QFuture<C> mappedReduced(Iterator begin,

                         Iterator end,

                         MapFunctor map,

                         T (C::*reduce)(U),

                         ReduceOptions options = ReduceOptions(UnorderedReduce | SequentialReduce))

{

    return startMappedReduced<typename MapFunctor::result_type, C>

    (begin, end, map, MemberFunctionWrapper1<T, C, U>(reduce), options);

}

template <typename ResultType, typename Iterator, typename T, typename U, typename ReduceFunctor>

QFuture<ResultType> mappedReduced(Iterator begin,

                                  Iterator end,

                                  T (map)(U),

                                  ReduceFunctor reduce,

                                  ReduceOptions options = ReduceOptions(UnorderedReduce | SequentialReduce))

{

    return startMappedReduced<T, ResultType>

    (begin, end, FunctionWrapper1<T, U>(map), reduce, options);

}

template <typename ResultType, typename Iterator, typename T, typename C, typename ReduceFunctor>

QFuture<ResultType> mappedReduced(Iterator begin,

                                  Iterator end,

                                  T (C::*map)() const,

                                  ReduceFunctor reduce,

                                  ReduceOptions options = ReduceOptions(UnorderedReduce | SequentialReduce))

{

    return startMappedReduced<T, ResultType>

    (begin, end, ConstMemberFunctionWrapper<T, C>(map), reduce, options);

}

template <typename Iterator, typename T, typename U, typename V, typename W, typename X>

QFuture<W> mappedReduced(Iterator begin,

                         Iterator end,

                         T (map)(U),

                         V (reduce)(W &, X),

                         ReduceOptions options = ReduceOptions(UnorderedReduce | SequentialReduce))

{

    return startMappedReduced<T, W>

    (begin, end, FunctionWrapper1<T, U>(map), FunctionWrapper2<V, W &, X>(reduce), options);

}

template <typename Iterator, typename T, typename C, typename U, typename V, typename W>

QFuture<V> mappedReduced(Iterator begin,

                         Iterator end,

                         T (C::*map)() const,

                         U (reduce)(V &, W),

                         ReduceOptions options = ReduceOptions(UnorderedReduce | SequentialReduce))

{

    return startMappedReduced<T, V>(begin, end, ConstMemberFunctionWrapper<T, C>(map),

                                   FunctionWrapper2<U, V &, W>(reduce), options);

}

template <typename Iterator, typename T, typename U, typename V, typename C, typename W>

QFuture<C> mappedReduced(Iterator begin,

                         Iterator end,

                         T (map)(U),

                         V (C::*reduce)(W),

                         ReduceOptions options = ReduceOptions(UnorderedReduce | SequentialReduce))

{

    return startMappedReduced<T, C>

    (begin, end, FunctionWrapper1<T, U>(map), MemberFunctionWrapper1<V, C, W>(reduce), options);

}

template <typename Iterator, typename T, typename C, typename U,typename D, typename V>

QFuture<D> mappedReduced(Iterator begin,

                         Iterator end,

                         T (C::*map)() const,

                         U (D::*reduce)(V),

                         ReduceOptions options = ReduceOptions(UnorderedReduce | SequentialReduce))

{

    return startMappedReduced<T, D>(begin, end, ConstMemberFunctionWrapper<T, C>(map),

                                    MemberFunctionWrapper1<U, D, V>(reduce), options);

}

// mapped() for sequences

template <typename Sequence, typename MapFunctor>

QFuture<typename MapFunctor::result_type> mapped(const Sequence &sequence, MapFunctor map)

{

    return startMapped<typename MapFunctor::result_type>(sequence, map);

}

template <typename Sequence, typename T, typename U>

QFuture<T> mapped(const Sequence &sequence, T (map)(U))

{

   return startMapped<T>(sequence, FunctionWrapper1<T, U>(map));

}

template <typename Sequence, typename T, typename C>

QFuture<T> mapped(const Sequence &sequence, T (C::*map)() const)

{

    return startMapped<T>(sequence, ConstMemberFunctionWrapper<T, C>(map));

}

// mapped() for iterator ranges.

template <typename Iterator, typename MapFunctor>

QFuture<typename MapFunctor::result_type> mapped(Iterator begin, Iterator end, MapFunctor map)

{

    return startMapped<Q_TYPENAME MapFunctor::result_type>(begin, end, map);

}

template <typename Iterator, typename T, typename U>

QFuture<T> mapped(Iterator begin, Iterator end, T (map)(U))

{

    return startMapped<T>(begin, end, FunctionWrapper1<T, U>(map));

}

template <typename Iterator, typename T, typename C>

QFuture<T> mapped(Iterator begin, Iterator end, T (C::*map)() const)

{

    return startMapped<T>(begin, end, ConstMemberFunctionWrapper<T, C>(map));

}

template <typename Sequence, typename MapFunctor>

void blockingMap(Sequence &sequence, MapFunctor map)

{

    startMap(sequence.begin(), sequence.end(), map).startBlocking();

}

template <typename Sequence, typename T, typename U>

void blockingMap(Sequence &sequence, T (map)(U))

{

    startMap(sequence.begin(), sequence.end(), QtConcurrent::FunctionWrapper1<T, U>(map)).startBlocking();

}

template <typename Sequence, typename T, typename C>

void blockingMap(Sequence &sequence, T (C::*map)())

{

    startMap(sequence.begin(), sequence.end(), QtConcurrent::MemberFunctionWrapper<T, C>(map)).startBlocking();

}

template <typename Iterator, typename MapFunctor>

void blockingMap(Iterator begin, Iterator end, MapFunctor map)

{

    startMap(begin, end, map).startBlocking();

}

template <typename Iterator, typename T, typename U>

void blockingMap(Iterator begin, Iterator end, T (map)(U))

{

    startMap(begin, end, QtConcurrent::FunctionWrapper1<T, U>(map)).startBlocking();

}

template <typename Iterator, typename T, typename C>

void blockingMap(Iterator begin, Iterator end, T (C::*map)())

{

    startMap(begin, end, QtConcurrent::MemberFunctionWrapper<T, C>(map)).startBlocking();

}

template <typename ResultType, typename Sequence, typename MapFunctor, typename ReduceFunctor>

ResultType blockingMappedReduced(const Sequence &sequence,

                                 MapFunctor map,

                                 ReduceFunctor reduce,

                                 ReduceOptions options = ReduceOptions(UnorderedReduce | SequentialReduce))

{

    return QtConcurrent::startMappedReduced<typename MapFunctor::result_type, ResultType>

    (sequence, map, reduce, options).startBlocking();

}

template <typename Sequence, typename MapFunctor, typename T, typename U, typename V>

U blockingMappedReduced(const Sequence &sequence,

                        MapFunctor map,

                        T (reduce)(U &, V),

                        QtConcurrent::ReduceOptions options = QtConcurrent::ReduceOptions(QtConcurrent::UnorderedReduce | QtConcurrent::SequentialReduce))

{

    return QtConcurrent::startMappedReduced<typename MapFunctor::result_type, U>

        (sequence,

         map,

         QtConcurrent::FunctionWrapper2<T, U &, V>(reduce),

         options)

        .startBlocking();

}

template <typename Sequence, typename MapFunctor, typename T, typename C, typename U>

C blockingMappedReduced(const Sequence &sequence,

                        MapFunctor map,

                        T (C::*reduce)(U),

                        QtConcurrent::ReduceOptions options = QtConcurrent::ReduceOptions(QtConcurrent::UnorderedReduce | QtConcurrent::SequentialReduce))

{

    return QtConcurrent::startMappedReduced<typename MapFunctor::result_type, C>

        (sequence,

         map,

         QtConcurrent::MemberFunctionWrapper1<T, C, U>(reduce),

         options)

        .startBlocking();

}

template <typename ResultType, typename Sequence, typename T, typename U, typename ReduceFunctor>

ResultType blockingMappedReduced(const Sequence &sequence,

                                 T (map)(U),

                                 ReduceFunctor reduce,

                                 QtConcurrent::ReduceOptions options = QtConcurrent::ReduceOptions(QtConcurrent::UnorderedReduce | QtConcurrent::SequentialReduce))

{

    return QtConcurrent::startMappedReduced<T, ResultType>

        (sequence,

         QtConcurrent::FunctionWrapper1<T, U>(map),

         reduce,

         options)

        .startBlocking();

}

template <typename ResultType, typename Sequence, typename T, typename C, typename ReduceFunctor>

ResultType blockingMappedReduced(const Sequence &sequence,

                                 T (C::*map)() const,

                                 ReduceFunctor reduce,

                                 QtConcurrent::ReduceOptions options = QtConcurrent::ReduceOptions(QtConcurrent::UnorderedReduce | QtConcurrent::SequentialReduce))

{

    return QtConcurrent::startMappedReduced<T, ResultType>

        (sequence,

         QtConcurrent::ConstMemberFunctionWrapper<T, C>(map),

         reduce,

         options)

        .startBlocking();

}

template <typename Sequence, typename T, typename U, typename V, typename W, typename X>

W blockingMappedReduced(const Sequence &sequence,

                        T (map)(U),

                        V (reduce)(W &, X),

                        QtConcurrent::ReduceOptions options = QtConcurrent::ReduceOptions(QtConcurrent::UnorderedReduce | QtConcurrent::SequentialReduce))

{

    return QtConcurrent::startMappedReduced<T, W>

        (sequence,

         QtConcurrent::FunctionWrapper1<T, U>(map),

         QtConcurrent::FunctionWrapper2<V, W &, X>(reduce),

         options)

        .startBlocking();

}

template <typename Sequence, typename T, typename C, typename U, typename V, typename W>

V blockingMappedReduced(const Sequence &sequence,

                        T (C::*map)() const,

                        U (reduce)(V &, W),

                        QtConcurrent::ReduceOptions options = QtConcurrent::ReduceOptions(QtConcurrent::UnorderedReduce | QtConcurrent::SequentialReduce))

{

    return QtConcurrent::startMappedReduced<T, V>

        (sequence,

         QtConcurrent::ConstMemberFunctionWrapper<T, C>(map),

         QtConcurrent::FunctionWrapper2<U, V &, W>(reduce),

         options)

        .startBlocking();

}

template <typename Sequence, typename T, typename U, typename V, typename C, typename W>

C blockingMappedReduced(const Sequence &sequence,

                        T (map)(U),

                        V (C::*reduce)(W),

                        QtConcurrent::ReduceOptions options = QtConcurrent::ReduceOptions(QtConcurrent::UnorderedReduce | QtConcurrent::SequentialReduce))

{

    return QtConcurrent::startMappedReduced<T, C>

        (sequence,

         QtConcurrent::FunctionWrapper1<T, U>(map),

         QtConcurrent::MemberFunctionWrapper1<V, C, W>(reduce),

         options)

        .startBlocking();

}

template <typename Sequence, typename T, typename C, typename U,typename D, typename V>

D blockingMappedReduced(const Sequence &sequence,

                        T (C::*map)() const,

                        U (D::*reduce)(V),

                        QtConcurrent::ReduceOptions options = QtConcurrent::ReduceOptions(QtConcurrent::UnorderedReduce | QtConcurrent::SequentialReduce))

{

    return QtConcurrent::startMappedReduced<T, D>

        (sequence,