Doc: Remove duplicated Qt Concurrent overview

- The "Concurrent Programming" page is an exact duplicate of the Qt Concurrent module landing
  page.
- The "qtconcurrent intro" target is not referenced anywhere.

Change-Id: Ice9b4360783013fe972258ca54a0004be43b8766
Reviewed-by: Jerome Pasion <jerome.pasion@digia.com>

src/concurrent/qtconcurrentfilter.cpp

@@ -47,7 +47,7 @@
     \brief The <QtConcurrentFilter> header provides concurrent Filter and
     Filter-Reduce.
 
-    These functions are a part of the \l {Concurrent Programming}{Qt Concurrent} framework.
+    These functions are a part of the \l {Qt Concurrent} framework.
 
     The QtConcurrent::filter(), QtConcurrent::filtered() and
     QtConcurrent::filteredReduced() functions filter items in a sequence such

src/concurrent/qtconcurrentmap.cpp

@@ -47,8 +47,8 @@
     possible to write multi-threaded programs without using low-level
     threading primitives.
 
-    See the \l {Concurrent Programming}{Qt Concurrent} chapter in
+    See the \l {Qt Concurrent} module documentation for an overview of available
-    the \l{threads.html}{threading} documentation.
+    functions, or see below for detailed information on each function.
 
     \inheaderfile QtConcurrent
     \ingroup thread
@@ -74,7 +74,7 @@
 
     \brief The <QtConcurrentMap> header provides concurrent Map and MapReduce.
 
-    These functions are a part of the \l {Concurrent Programming}{Qt Concurrent} framework.
+    These functions are a part of the \l {Qt Concurrent} framework.
 
     The QtConcurrent::map(), QtConcurrent::mapped() and
     QtConcurrent::mappedReduced() functions run computations in parallel on

src/concurrent/qtconcurrentrun.cpp

@@ -48,7 +48,7 @@
 
     \ingroup thread
 
-    This function is a part of the \l {Concurrent Programming}{Qt Concurrent} framework.
+    This function is a part of the \l {Qt Concurrent} framework.
 
     The QtConcurrent::run() function runs a function in a separate thread.
     The return value of the function is made available through the QFuture API.

src/corelib/doc/src/threads.qdoc

@@ -63,7 +63,6 @@
     \li \l{Synchronizing Threads}
     \li \l{Reentrancy and Thread-Safety}
     \li \l{Threads and QObjects}
-    \li \l{Concurrent Programming}
     \li \l{Thread-Support in Qt Modules}
     \endlist
 
@@ -449,7 +448,7 @@
 
     \previouspage Reentrancy and Thread Safety
     \contentspage Thread Support in Qt
-    \nextpage Concurrent Programming
+    \nextpage Thread-Support in Qt Modules
 
     QThread inherits QObject. It emits signals to indicate that the
     thread started or finished executing, and provides a few slots as
@@ -645,114 +644,11 @@
     a TCP server asynchronously.
 */
 
-/*!
-    \page threads-qtconcurrent.html
-    \title Concurrent Programming
-
-    \previouspage Threads and QObjects
-    \contentspage Thread Support in Qt
-    \nextpage Thread-Support in Qt Modules
-
-    \target qtconcurrent intro
-
-    The QtConcurrent namespace provides high-level APIs that make it
-    possible to write multi-threaded programs without using low-level
-    threading primitives such as mutexes, read-write locks, wait
-    conditions, or semaphores. Programs written with QtConcurrent
-    automatically adjust the number of threads used according to the
-    number of processor cores available. This means that applications
-    written today will continue to scale when deployed on multi-core
-    systems in the future.
-
-    QtConcurrent includes functional programming style APIs for
-    parallel list processing, including a MapReduce and FilterReduce
-    implementation for shared-memory (non-distributed) systems, and
-    classes for managing asynchronous computations in GUI
-    applications:
-
-    \list
-
-    \li QtConcurrent::map() applies a function to every item in a container,
-    modifying the items in-place.
-
-    \li QtConcurrent::mapped() is like map(), except that it returns a new
-    container with the modifications.
-
-    \li QtConcurrent::mappedReduced() is like mapped(), except that the
-    modified results are reduced or folded into a single result.
-
-    \li QtConcurrent::filter() removes all items from a container based on the
-    result of a filter function.
-
-    \li QtConcurrent::filtered() is like filter(), except that it returns a new
-    container with the filtered results.
-
-    \li QtConcurrent::filteredReduced() is like filtered(), except that the
-    filtered results are reduced or folded into a single result.
-
-    \li QtConcurrent::run() runs a function in another thread.
-
-    \li QFuture represents the result of an asynchronous computation.
-
-    \li QFutureIterator allows iterating through results available via QFuture.
-
-    \li QFutureWatcher allows monitoring a QFuture using signals-and-slots.
-
-    \li QFutureSynchronizer is a convenience class that automatically
-    synchronizes several QFutures.
-
-    \endlist
-
-    Qt Concurrent supports several STL-compatible container and iterator types,
-    but works best with Qt containers that have random-access iterators, such as
-    QList or QVector. The map and filter functions accept both containers and begin/end iterators.
-
-    STL Iterator support overview:
-
-    \table
-    \header
-        \li Iterator Type
-        \li Example classes
-        \li Support status
-    \row
-        \li Input Iterator
-        \li
-        \li Not Supported
-    \row
-        \li Output Iterator
-        \li
-        \li Not Supported
-    \row
-        \li Forward Iterator
-        \li std::slist
-        \li Supported
-    \row
-        \li Bidirectional Iterator
-        \li QLinkedList, std::list
-        \li Supported
-    \row
-        \li Random Access Iterator
-        \li QList, QVector, std::vector
-        \li Supported and Recommended
-    \endtable
-
-    Random access iterators can be faster in cases where Qt Concurrent is iterating
-    over a large number of lightweight items, since they allow skipping to any point
-    in the container. In addition, using random access iterators allows Qt Concurrent
-    to provide progress information trough QFuture::progressValue() and QFutureWatcher::
-    progressValueChanged().
-
-    The non in-place modifying functions such as mapped() and filtered() makes a
-    copy of the container when called. If you are using STL containers this copy operation
-    might take some time, in this case we recommend specifying the begin and end iterators
-    for the container instead.
-*/
-
 /*!
     \page threads-modules.html
     \title Thread-Support in Qt Modules
 
-    \previouspage Concurrent Programming
+    \previouspage Threads and QObjects
     \contentspage Thread Support in Qt
 
     \section1 Threads and the SQL Module

src/corelib/thread/qfuture.qdoc

@@ -47,8 +47,7 @@
 
     \ingroup thread
 
-    To start a computation, use one of the APIs in the
+    To start a computation, use one of the APIs in the \l {Qt Concurrent} framework.
-    \l {Concurrent Programming}{Qt Concurrent} framework.
 
     QFuture allows threads to be synchronized against one or more results
     which will be ready at a later point in time. The result can be of any type
@@ -93,7 +92,7 @@
 
     To interact with running tasks using signals and slots, use QFutureWatcher.
 
-    \sa QFutureWatcher, {Concurrent Programming}{Qt Concurrent}
+    \sa QFutureWatcher, {Qt Concurrent}
 */
 
 /*! \fn QFuture::QFuture()

src/corelib/thread/qfuturesynchronizer.qdoc

@@ -66,7 +66,7 @@
     You can query the status of the cancel-on-wait feature using the
     cancelOnWait() function.
 
-    \sa QFuture, QFutureWatcher, {Concurrent Programming}{Qt Concurrent}
+    \sa QFuture, QFutureWatcher, {Qt Concurrent}
 */
 
 /*!

src/corelib/thread/qfuturewatcher.cpp

@@ -98,7 +98,7 @@ QT_BEGIN_NAMESPACE
     QFutureWatcher<void> as well. This is useful if only status or progress
     information is needed; not the actual result data.
 
-    \sa QFuture, {Concurrent Programming}{Qt Concurrent}
+    \sa QFuture, {Qt Concurrent}
 */
 
 /*! \fn QFutureWatcher::QFutureWatcher(QObject *parent)