io.qt.concurrent.QtConcurrent

public final class QtConcurrent
extends Object

High-level APIs that make it possible to write multi-threaded programs without using low-level threading primitives

Java wrapper for Qt class QtConcurrent

Nested Class Summary

Nested Classes
Modifier and Type	Class	Description
`static interface`	`QtConcurrent.Callable1<T,A>`
`static interface`	`QtConcurrent.Callable2<T,A,B>`
`static interface`	`QtConcurrent.Callable3<T,A,B,C>`
`static interface`	`QtConcurrent.Callable4<T,A,B,C,D>`
`static interface`	`QtConcurrent.Callable5<T,A,B,C,D,E>`
`static interface`	`QtConcurrent.Callable6<T,A,B,C,D,E,F>`
`static interface`	`QtConcurrent.Callable7<T,A,B,C,D,E,F,G>`
`static interface`	`QtConcurrent.Callable8<T,A,B,C,D,E,F,G,H>`
`static interface`	`QtConcurrent.Callable9<T,A,B,C,D,E,F,G,H,I>`
`static interface`	`QtConcurrent.FilteredFunctor<T>`	An implementation of this interface is given to one of QtConcurrent's filtered() methods.
`static class`	`QtConcurrent.FutureResult`	Java wrapper for Qt enum QtConcurrent::FutureResult
`static interface`	`QtConcurrent.MapFunctor<T>`	An implemetation of this interface is given one to QtConcurrent's map() methods.
`static interface`	`QtConcurrent.MappedFunctor<U,T>`	Implement this interface to perform a mapped operation.
`static class`	`QtConcurrent.QPromiseTaskBuilderVoid0Arg0`
`static class`	`QtConcurrent.QPromiseTaskBuilderVoid1Arg0<A>`
`static class`	`QtConcurrent.QPromiseTaskBuilderVoid1Arg1<A>`
`static class`	`QtConcurrent.QPromiseTaskBuilderVoid2Arg0<A,B>`
`static class`	`QtConcurrent.QPromiseTaskBuilderVoid2Arg1<A,B>`
`static class`	`QtConcurrent.QPromiseTaskBuilderVoid2Arg2<A,B>`
`static class`	`QtConcurrent.QPromiseTaskBuilderVoid3Arg0<A,B,C>`
`static class`	`QtConcurrent.QPromiseTaskBuilderVoid3Arg1<A,B,C>`
`static class`	`QtConcurrent.QPromiseTaskBuilderVoid3Arg2<A,B,C>`
`static class`	`QtConcurrent.QPromiseTaskBuilderVoid3Arg3<A,B,C>`
`static class`	`QtConcurrent.QPromiseTaskBuilderVoid4Arg0<A,B,C,D>`
`static class`	`QtConcurrent.QPromiseTaskBuilderVoid4Arg1<A,B,C,D>`
`static class`	`QtConcurrent.QPromiseTaskBuilderVoid4Arg2<A,B,C,D>`
`static class`	`QtConcurrent.QPromiseTaskBuilderVoid4Arg3<A,B,C,D>`
`static class`	`QtConcurrent.QPromiseTaskBuilderVoid4Arg4<A,B,C,D>`
`static class`	`QtConcurrent.QPromiseTaskBuilderVoid5Arg0<A,B,C,D,E>`
`static class`	`QtConcurrent.QPromiseTaskBuilderVoid5Arg1<A,B,C,D,E>`
`static class`	`QtConcurrent.QPromiseTaskBuilderVoid5Arg2<A,B,C,D,E>`
`static class`	`QtConcurrent.QPromiseTaskBuilderVoid5Arg3<A,B,C,D,E>`
`static class`	`QtConcurrent.QPromiseTaskBuilderVoid5Arg4<A,B,C,D,E>`
`static class`	`QtConcurrent.QPromiseTaskBuilderVoid5Arg5<A,B,C,D,E>`
`static class`	`QtConcurrent.QPromiseTaskBuilderVoid6Arg0<A,B,C,D,E,F>`
`static class`	`QtConcurrent.QPromiseTaskBuilderVoid6Arg1<A,B,C,D,E,F>`
`static class`	`QtConcurrent.QPromiseTaskBuilderVoid6Arg2<A,B,C,D,E,F>`
`static class`	`QtConcurrent.QPromiseTaskBuilderVoid6Arg3<A,B,C,D,E,F>`
`static class`	`QtConcurrent.QPromiseTaskBuilderVoid6Arg4<A,B,C,D,E,F>`
`static class`	`QtConcurrent.QPromiseTaskBuilderVoid6Arg5<A,B,C,D,E,F>`
`static class`	`QtConcurrent.QPromiseTaskBuilderVoid6Arg6<A,B,C,D,E,F>`
`static class`	`QtConcurrent.QPromiseTaskBuilderVoid7Arg0<A,B,C,D,E,F,G>`
`static class`	`QtConcurrent.QPromiseTaskBuilderVoid7Arg1<A,B,C,D,E,F,G>`
`static class`	`QtConcurrent.QPromiseTaskBuilderVoid7Arg2<A,B,C,D,E,F,G>`
`static class`	`QtConcurrent.QPromiseTaskBuilderVoid7Arg3<A,B,C,D,E,F,G>`
`static class`	`QtConcurrent.QPromiseTaskBuilderVoid7Arg4<A,B,C,D,E,F,G>`
`static class`	`QtConcurrent.QPromiseTaskBuilderVoid7Arg5<A,B,C,D,E,F,G>`
`static class`	`QtConcurrent.QPromiseTaskBuilderVoid7Arg6<A,B,C,D,E,F,G>`
`static class`	`QtConcurrent.QPromiseTaskBuilderVoid7Arg7<A,B,C,D,E,F,G>`
`static class`	`QtConcurrent.QPromiseTaskBuilderVoid8Arg0<A,B,C,D,E,F,G,H>`
`static class`	`QtConcurrent.QPromiseTaskBuilderVoid8Arg1<A,B,C,D,E,F,G,H>`
`static class`	`QtConcurrent.QPromiseTaskBuilderVoid8Arg2<A,B,C,D,E,F,G,H>`
`static class`	`QtConcurrent.QPromiseTaskBuilderVoid8Arg3<A,B,C,D,E,F,G,H>`
`static class`	`QtConcurrent.QPromiseTaskBuilderVoid8Arg4<A,B,C,D,E,F,G,H>`
`static class`	`QtConcurrent.QPromiseTaskBuilderVoid8Arg5<A,B,C,D,E,F,G,H>`
`static class`	`QtConcurrent.QPromiseTaskBuilderVoid8Arg6<A,B,C,D,E,F,G,H>`
`static class`	`QtConcurrent.QPromiseTaskBuilderVoid8Arg7<A,B,C,D,E,F,G,H>`
`static class`	`QtConcurrent.QPromiseTaskBuilderVoid8Arg8<A,B,C,D,E,F,G,H>`
`static class`	`QtConcurrent.QPromiseTaskBuilderVoid9Arg0<A,B,C,D,E,F,G,H,I>`
`static class`	`QtConcurrent.QPromiseTaskBuilderVoid9Arg1<A,B,C,D,E,F,G,H,I>`
`static class`	`QtConcurrent.QPromiseTaskBuilderVoid9Arg2<A,B,C,D,E,F,G,H,I>`
`static class`	`QtConcurrent.QPromiseTaskBuilderVoid9Arg3<A,B,C,D,E,F,G,H,I>`
`static class`	`QtConcurrent.QPromiseTaskBuilderVoid9Arg4<A,B,C,D,E,F,G,H,I>`
`static class`	`QtConcurrent.QPromiseTaskBuilderVoid9Arg5<A,B,C,D,E,F,G,H,I>`
`static class`	`QtConcurrent.QPromiseTaskBuilderVoid9Arg6<A,B,C,D,E,F,G,H,I>`
`static class`	`QtConcurrent.QPromiseTaskBuilderVoid9Arg7<A,B,C,D,E,F,G,H,I>`
`static class`	`QtConcurrent.QPromiseTaskBuilderVoid9Arg8<A,B,C,D,E,F,G,H,I>`
`static class`	`QtConcurrent.QPromiseTaskBuilderVoid9Arg9<A,B,C,D,E,F,G,H,I>`
`static class`	`QtConcurrent.QTaskBuilder`
`static class`	`QtConcurrent.QTaskBuilderVoid`
`static class`	`QtConcurrent.QTaskBuilderVoid0Arg0`
`static class`	`QtConcurrent.QTaskBuilderVoid1Arg0<A>`
`static class`	`QtConcurrent.QTaskBuilderVoid1Arg1<A>`
`static class`	`QtConcurrent.QTaskBuilderVoid2Arg0<A,B>`
`static class`	`QtConcurrent.QTaskBuilderVoid2Arg1<A,B>`
`static class`	`QtConcurrent.QTaskBuilderVoid2Arg2<A,B>`
`static class`	`QtConcurrent.QTaskBuilderVoid3Arg0<A,B,C>`
`static class`	`QtConcurrent.QTaskBuilderVoid3Arg1<A,B,C>`
`static class`	`QtConcurrent.QTaskBuilderVoid3Arg2<A,B,C>`
`static class`	`QtConcurrent.QTaskBuilderVoid3Arg3<A,B,C>`
`static class`	`QtConcurrent.QTaskBuilderVoid4Arg0<A,B,C,D>`
`static class`	`QtConcurrent.QTaskBuilderVoid4Arg1<A,B,C,D>`
`static class`	`QtConcurrent.QTaskBuilderVoid4Arg2<A,B,C,D>`
`static class`	`QtConcurrent.QTaskBuilderVoid4Arg3<A,B,C,D>`
`static class`	`QtConcurrent.QTaskBuilderVoid4Arg4<A,B,C,D>`
`static class`	`QtConcurrent.QTaskBuilderVoid5Arg0<A,B,C,D,E>`
`static class`	`QtConcurrent.QTaskBuilderVoid5Arg1<A,B,C,D,E>`
`static class`	`QtConcurrent.QTaskBuilderVoid5Arg2<A,B,C,D,E>`
`static class`	`QtConcurrent.QTaskBuilderVoid5Arg3<A,B,C,D,E>`
`static class`	`QtConcurrent.QTaskBuilderVoid5Arg4<A,B,C,D,E>`
`static class`	`QtConcurrent.QTaskBuilderVoid5Arg5<A,B,C,D,E>`
`static class`	`QtConcurrent.QTaskBuilderVoid6Arg0<A,B,C,D,E,F>`
`static class`	`QtConcurrent.QTaskBuilderVoid6Arg1<A,B,C,D,E,F>`
`static class`	`QtConcurrent.QTaskBuilderVoid6Arg2<A,B,C,D,E,F>`
`static class`	`QtConcurrent.QTaskBuilderVoid6Arg3<A,B,C,D,E,F>`
`static class`	`QtConcurrent.QTaskBuilderVoid6Arg4<A,B,C,D,E,F>`
`static class`	`QtConcurrent.QTaskBuilderVoid6Arg5<A,B,C,D,E,F>`
`static class`	`QtConcurrent.QTaskBuilderVoid6Arg6<A,B,C,D,E,F>`
`static class`	`QtConcurrent.QTaskBuilderVoid7Arg0<A,B,C,D,E,F,G>`
`static class`	`QtConcurrent.QTaskBuilderVoid7Arg1<A,B,C,D,E,F,G>`
`static class`	`QtConcurrent.QTaskBuilderVoid7Arg2<A,B,C,D,E,F,G>`
`static class`	`QtConcurrent.QTaskBuilderVoid7Arg3<A,B,C,D,E,F,G>`
`static class`	`QtConcurrent.QTaskBuilderVoid7Arg4<A,B,C,D,E,F,G>`
`static class`	`QtConcurrent.QTaskBuilderVoid7Arg5<A,B,C,D,E,F,G>`
`static class`	`QtConcurrent.QTaskBuilderVoid7Arg6<A,B,C,D,E,F,G>`
`static class`	`QtConcurrent.QTaskBuilderVoid7Arg7<A,B,C,D,E,F,G>`
`static class`	`QtConcurrent.QTaskBuilderVoid8Arg0<A,B,C,D,E,F,G,H>`
`static class`	`QtConcurrent.QTaskBuilderVoid8Arg1<A,B,C,D,E,F,G,H>`
`static class`	`QtConcurrent.QTaskBuilderVoid8Arg2<A,B,C,D,E,F,G,H>`
`static class`	`QtConcurrent.QTaskBuilderVoid8Arg3<A,B,C,D,E,F,G,H>`
`static class`	`QtConcurrent.QTaskBuilderVoid8Arg4<A,B,C,D,E,F,G,H>`
`static class`	`QtConcurrent.QTaskBuilderVoid8Arg5<A,B,C,D,E,F,G,H>`
`static class`	`QtConcurrent.QTaskBuilderVoid8Arg6<A,B,C,D,E,F,G,H>`
`static class`	`QtConcurrent.QTaskBuilderVoid8Arg7<A,B,C,D,E,F,G,H>`
`static class`	`QtConcurrent.QTaskBuilderVoid8Arg8<A,B,C,D,E,F,G,H>`
`static class`	`QtConcurrent.QTaskBuilderVoid9Arg0<A,B,C,D,E,F,G,H,I>`
`static class`	`QtConcurrent.QTaskBuilderVoid9Arg1<A,B,C,D,E,F,G,H,I>`
`static class`	`QtConcurrent.QTaskBuilderVoid9Arg2<A,B,C,D,E,F,G,H,I>`
`static class`	`QtConcurrent.QTaskBuilderVoid9Arg3<A,B,C,D,E,F,G,H,I>`
`static class`	`QtConcurrent.QTaskBuilderVoid9Arg4<A,B,C,D,E,F,G,H,I>`
`static class`	`QtConcurrent.QTaskBuilderVoid9Arg5<A,B,C,D,E,F,G,H,I>`
`static class`	`QtConcurrent.QTaskBuilderVoid9Arg6<A,B,C,D,E,F,G,H,I>`
`static class`	`QtConcurrent.QTaskBuilderVoid9Arg7<A,B,C,D,E,F,G,H,I>`
`static class`	`QtConcurrent.QTaskBuilderVoid9Arg8<A,B,C,D,E,F,G,H,I>`
`static class`	`QtConcurrent.QTaskBuilderVoid9Arg9<A,B,C,D,E,F,G,H,I>`
`static class`	`QtConcurrent.QTypedPromiseTaskBuilder0Arg0<T>`
`static class`	`QtConcurrent.QTypedPromiseTaskBuilder1Arg0<T,A>`
`static class`	`QtConcurrent.QTypedPromiseTaskBuilder1Arg1<T,A>`
`static class`	`QtConcurrent.QTypedPromiseTaskBuilder2Arg0<T,A,B>`
`static class`	`QtConcurrent.QTypedPromiseTaskBuilder2Arg1<T,A,B>`
`static class`	`QtConcurrent.QTypedPromiseTaskBuilder2Arg2<T,A,B>`
`static class`	`QtConcurrent.QTypedPromiseTaskBuilder3Arg0<T,A,B,C>`
`static class`	`QtConcurrent.QTypedPromiseTaskBuilder3Arg1<T,A,B,C>`
`static class`	`QtConcurrent.QTypedPromiseTaskBuilder3Arg2<T,A,B,C>`
`static class`	`QtConcurrent.QTypedPromiseTaskBuilder3Arg3<T,A,B,C>`
`static class`	`QtConcurrent.QTypedPromiseTaskBuilder4Arg0<T,A,B,C,D>`
`static class`	`QtConcurrent.QTypedPromiseTaskBuilder4Arg1<T,A,B,C,D>`
`static class`	`QtConcurrent.QTypedPromiseTaskBuilder4Arg2<T,A,B,C,D>`
`static class`	`QtConcurrent.QTypedPromiseTaskBuilder4Arg3<T,A,B,C,D>`
`static class`	`QtConcurrent.QTypedPromiseTaskBuilder4Arg4<T,A,B,C,D>`
`static class`	`QtConcurrent.QTypedPromiseTaskBuilder5Arg0<T,A,B,C,D,E>`
`static class`	`QtConcurrent.QTypedPromiseTaskBuilder5Arg1<T,A,B,C,D,E>`
`static class`	`QtConcurrent.QTypedPromiseTaskBuilder5Arg2<T,A,B,C,D,E>`
`static class`	`QtConcurrent.QTypedPromiseTaskBuilder5Arg3<T,A,B,C,D,E>`
`static class`	`QtConcurrent.QTypedPromiseTaskBuilder5Arg4<T,A,B,C,D,E>`
`static class`	`QtConcurrent.QTypedPromiseTaskBuilder5Arg5<T,A,B,C,D,E>`
`static class`	`QtConcurrent.QTypedPromiseTaskBuilder6Arg0<T,A,B,C,D,E,F>`
`static class`	`QtConcurrent.QTypedPromiseTaskBuilder6Arg1<T,A,B,C,D,E,F>`
`static class`	`QtConcurrent.QTypedPromiseTaskBuilder6Arg2<T,A,B,C,D,E,F>`
`static class`	`QtConcurrent.QTypedPromiseTaskBuilder6Arg3<T,A,B,C,D,E,F>`
`static class`	`QtConcurrent.QTypedPromiseTaskBuilder6Arg4<T,A,B,C,D,E,F>`
`static class`	`QtConcurrent.QTypedPromiseTaskBuilder6Arg5<T,A,B,C,D,E,F>`
`static class`	`QtConcurrent.QTypedPromiseTaskBuilder6Arg6<T,A,B,C,D,E,F>`
`static class`	`QtConcurrent.QTypedPromiseTaskBuilder7Arg0<T,A,B,C,D,E,F,G>`
`static class`	`QtConcurrent.QTypedPromiseTaskBuilder7Arg1<T,A,B,C,D,E,F,G>`
`static class`	`QtConcurrent.QTypedPromiseTaskBuilder7Arg2<T,A,B,C,D,E,F,G>`
`static class`	`QtConcurrent.QTypedPromiseTaskBuilder7Arg3<T,A,B,C,D,E,F,G>`
`static class`	`QtConcurrent.QTypedPromiseTaskBuilder7Arg4<T,A,B,C,D,E,F,G>`
`static class`	`QtConcurrent.QTypedPromiseTaskBuilder7Arg5<T,A,B,C,D,E,F,G>`
`static class`	`QtConcurrent.QTypedPromiseTaskBuilder7Arg6<T,A,B,C,D,E,F,G>`
`static class`	`QtConcurrent.QTypedPromiseTaskBuilder7Arg7<T,A,B,C,D,E,F,G>`
`static class`	`QtConcurrent.QTypedPromiseTaskBuilder8Arg0<T,A,B,C,D,E,F,G,H>`
`static class`	`QtConcurrent.QTypedPromiseTaskBuilder8Arg1<T,A,B,C,D,E,F,G,H>`
`static class`	`QtConcurrent.QTypedPromiseTaskBuilder8Arg2<T,A,B,C,D,E,F,G,H>`
`static class`	`QtConcurrent.QTypedPromiseTaskBuilder8Arg3<T,A,B,C,D,E,F,G,H>`
`static class`	`QtConcurrent.QTypedPromiseTaskBuilder8Arg4<T,A,B,C,D,E,F,G,H>`
`static class`	`QtConcurrent.QTypedPromiseTaskBuilder8Arg5<T,A,B,C,D,E,F,G,H>`
`static class`	`QtConcurrent.QTypedPromiseTaskBuilder8Arg6<T,A,B,C,D,E,F,G,H>`
`static class`	`QtConcurrent.QTypedPromiseTaskBuilder8Arg7<T,A,B,C,D,E,F,G,H>`
`static class`	`QtConcurrent.QTypedPromiseTaskBuilder8Arg8<T,A,B,C,D,E,F,G,H>`
`static class`	`QtConcurrent.QTypedPromiseTaskBuilder9Arg0<T,A,B,C,D,E,F,G,H,I>`
`static class`	`QtConcurrent.QTypedPromiseTaskBuilder9Arg1<T,A,B,C,D,E,F,G,H,I>`
`static class`	`QtConcurrent.QTypedPromiseTaskBuilder9Arg2<T,A,B,C,D,E,F,G,H,I>`
`static class`	`QtConcurrent.QTypedPromiseTaskBuilder9Arg3<T,A,B,C,D,E,F,G,H,I>`
`static class`	`QtConcurrent.QTypedPromiseTaskBuilder9Arg4<T,A,B,C,D,E,F,G,H,I>`
`static class`	`QtConcurrent.QTypedPromiseTaskBuilder9Arg5<T,A,B,C,D,E,F,G,H,I>`
`static class`	`QtConcurrent.QTypedPromiseTaskBuilder9Arg6<T,A,B,C,D,E,F,G,H,I>`
`static class`	`QtConcurrent.QTypedPromiseTaskBuilder9Arg7<T,A,B,C,D,E,F,G,H,I>`
`static class`	`QtConcurrent.QTypedPromiseTaskBuilder9Arg8<T,A,B,C,D,E,F,G,H,I>`
`static class`	`QtConcurrent.QTypedPromiseTaskBuilder9Arg9<T,A,B,C,D,E,F,G,H,I>`
`static class`	`QtConcurrent.QTypedTaskBuilder<T>`
`static class`	`QtConcurrent.QTypedTaskBuilder0Arg0<T>`
`static class`	`QtConcurrent.QTypedTaskBuilder1Arg0<T,A>`
`static class`	`QtConcurrent.QTypedTaskBuilder1Arg1<T,A>`
`static class`	`QtConcurrent.QTypedTaskBuilder2Arg0<T,A,B>`
`static class`	`QtConcurrent.QTypedTaskBuilder2Arg1<T,A,B>`
`static class`	`QtConcurrent.QTypedTaskBuilder2Arg2<T,A,B>`
`static class`	`QtConcurrent.QTypedTaskBuilder3Arg0<T,A,B,C>`
`static class`	`QtConcurrent.QTypedTaskBuilder3Arg1<T,A,B,C>`
`static class`	`QtConcurrent.QTypedTaskBuilder3Arg2<T,A,B,C>`
`static class`	`QtConcurrent.QTypedTaskBuilder3Arg3<T,A,B,C>`
`static class`	`QtConcurrent.QTypedTaskBuilder4Arg0<T,A,B,C,D>`
`static class`	`QtConcurrent.QTypedTaskBuilder4Arg1<T,A,B,C,D>`
`static class`	`QtConcurrent.QTypedTaskBuilder4Arg2<T,A,B,C,D>`
`static class`	`QtConcurrent.QTypedTaskBuilder4Arg3<T,A,B,C,D>`
`static class`	`QtConcurrent.QTypedTaskBuilder4Arg4<T,A,B,C,D>`
`static class`	`QtConcurrent.QTypedTaskBuilder5Arg0<T,A,B,C,D,E>`
`static class`	`QtConcurrent.QTypedTaskBuilder5Arg1<T,A,B,C,D,E>`
`static class`	`QtConcurrent.QTypedTaskBuilder5Arg2<T,A,B,C,D,E>`
`static class`	`QtConcurrent.QTypedTaskBuilder5Arg3<T,A,B,C,D,E>`
`static class`	`QtConcurrent.QTypedTaskBuilder5Arg4<T,A,B,C,D,E>`
`static class`	`QtConcurrent.QTypedTaskBuilder5Arg5<T,A,B,C,D,E>`
`static class`	`QtConcurrent.QTypedTaskBuilder6Arg0<T,A,B,C,D,E,F>`
`static class`	`QtConcurrent.QTypedTaskBuilder6Arg1<T,A,B,C,D,E,F>`
`static class`	`QtConcurrent.QTypedTaskBuilder6Arg2<T,A,B,C,D,E,F>`
`static class`	`QtConcurrent.QTypedTaskBuilder6Arg3<T,A,B,C,D,E,F>`
`static class`	`QtConcurrent.QTypedTaskBuilder6Arg4<T,A,B,C,D,E,F>`
`static class`	`QtConcurrent.QTypedTaskBuilder6Arg5<T,A,B,C,D,E,F>`
`static class`	`QtConcurrent.QTypedTaskBuilder6Arg6<T,A,B,C,D,E,F>`
`static class`	`QtConcurrent.QTypedTaskBuilder7Arg0<T,A,B,C,D,E,F,G>`
`static class`	`QtConcurrent.QTypedTaskBuilder7Arg1<T,A,B,C,D,E,F,G>`
`static class`	`QtConcurrent.QTypedTaskBuilder7Arg2<T,A,B,C,D,E,F,G>`
`static class`	`QtConcurrent.QTypedTaskBuilder7Arg3<T,A,B,C,D,E,F,G>`
`static class`	`QtConcurrent.QTypedTaskBuilder7Arg4<T,A,B,C,D,E,F,G>`
`static class`	`QtConcurrent.QTypedTaskBuilder7Arg5<T,A,B,C,D,E,F,G>`
`static class`	`QtConcurrent.QTypedTaskBuilder7Arg6<T,A,B,C,D,E,F,G>`
`static class`	`QtConcurrent.QTypedTaskBuilder7Arg7<T,A,B,C,D,E,F,G>`
`static class`	`QtConcurrent.QTypedTaskBuilder8Arg0<T,A,B,C,D,E,F,G,H>`
`static class`	`QtConcurrent.QTypedTaskBuilder8Arg1<T,A,B,C,D,E,F,G,H>`
`static class`	`QtConcurrent.QTypedTaskBuilder8Arg2<T,A,B,C,D,E,F,G,H>`
`static class`	`QtConcurrent.QTypedTaskBuilder8Arg3<T,A,B,C,D,E,F,G,H>`
`static class`	`QtConcurrent.QTypedTaskBuilder8Arg4<T,A,B,C,D,E,F,G,H>`
`static class`	`QtConcurrent.QTypedTaskBuilder8Arg5<T,A,B,C,D,E,F,G,H>`
`static class`	`QtConcurrent.QTypedTaskBuilder8Arg6<T,A,B,C,D,E,F,G,H>`
`static class`	`QtConcurrent.QTypedTaskBuilder8Arg7<T,A,B,C,D,E,F,G,H>`
`static class`	`QtConcurrent.QTypedTaskBuilder8Arg8<T,A,B,C,D,E,F,G,H>`
`static class`	`QtConcurrent.QTypedTaskBuilder9Arg0<T,A,B,C,D,E,F,G,H,I>`
`static class`	`QtConcurrent.QTypedTaskBuilder9Arg1<T,A,B,C,D,E,F,G,H,I>`
`static class`	`QtConcurrent.QTypedTaskBuilder9Arg2<T,A,B,C,D,E,F,G,H,I>`
`static class`	`QtConcurrent.QTypedTaskBuilder9Arg3<T,A,B,C,D,E,F,G,H,I>`
`static class`	`QtConcurrent.QTypedTaskBuilder9Arg4<T,A,B,C,D,E,F,G,H,I>`
`static class`	`QtConcurrent.QTypedTaskBuilder9Arg5<T,A,B,C,D,E,F,G,H,I>`
`static class`	`QtConcurrent.QTypedTaskBuilder9Arg6<T,A,B,C,D,E,F,G,H,I>`
`static class`	`QtConcurrent.QTypedTaskBuilder9Arg7<T,A,B,C,D,E,F,G,H,I>`
`static class`	`QtConcurrent.QTypedTaskBuilder9Arg8<T,A,B,C,D,E,F,G,H,I>`
`static class`	`QtConcurrent.QTypedTaskBuilder9Arg9<T,A,B,C,D,E,F,G,H,I>`
`static interface`	`QtConcurrent.ReducedFunctor<U,T>`	Implement this interface in order to perform a reduce operation.
`static class`	`QtConcurrent.ReduceOption`	Java wrapper for Qt enum QtConcurrent::ReduceOption
`static class`	`QtConcurrent.ReduceOptions`	QFlags type for enum `QtConcurrent.ReduceOption`
`static interface`	`QtConcurrent.Runnable1<A>`
`static interface`	`QtConcurrent.Runnable2<A,B>`
`static interface`	`QtConcurrent.Runnable3<A,B,C>`
`static interface`	`QtConcurrent.Runnable4<A,B,C,D>`
`static interface`	`QtConcurrent.Runnable5<A,B,C,D,E>`
`static interface`	`QtConcurrent.Runnable6<A,B,C,D,E,F>`
`static interface`	`QtConcurrent.Runnable7<A,B,C,D,E,F,G>`
`static interface`	`QtConcurrent.Runnable8<A,B,C,D,E,F,G,H>`
`static interface`	`QtConcurrent.Runnable9<A,B,C,D,E,F,G,H,I>`
`static interface`	`QtConcurrent.RunnableWithPromise<T>`
`static interface`	`QtConcurrent.RunnableWithPromise1<T,A>`
`static interface`	`QtConcurrent.RunnableWithPromise2<T,A,B>`
`static interface`	`QtConcurrent.RunnableWithPromise3<T,A,B,C>`
`static interface`	`QtConcurrent.RunnableWithPromise4<T,A,B,C,D>`
`static interface`	`QtConcurrent.RunnableWithPromise5<T,A,B,C,D,E>`
`static interface`	`QtConcurrent.RunnableWithPromise6<T,A,B,C,D,E,F>`
`static interface`	`QtConcurrent.RunnableWithPromise7<T,A,B,C,D,E,F,G>`
`static interface`	`QtConcurrent.RunnableWithPromise8<T,A,B,C,D,E,F,G,H>`
`static interface`	`QtConcurrent.RunnableWithPromise9<T,A,B,C,D,E,F,G,H,I>`
`static interface`	`QtConcurrent.RunnableWithVoidPromise`
`static interface`	`QtConcurrent.RunnableWithVoidPromise1<A>`
`static interface`	`QtConcurrent.RunnableWithVoidPromise2<A,B>`
`static interface`	`QtConcurrent.RunnableWithVoidPromise3<A,B,C>`
`static interface`	`QtConcurrent.RunnableWithVoidPromise4<A,B,C,D>`
`static interface`	`QtConcurrent.RunnableWithVoidPromise5<A,B,C,D,E>`
`static interface`	`QtConcurrent.RunnableWithVoidPromise6<A,B,C,D,E,F>`
`static interface`	`QtConcurrent.RunnableWithVoidPromise7<A,B,C,D,E,F,G>`
`static interface`	`QtConcurrent.RunnableWithVoidPromise8<A,B,C,D,E,F,G,H>`
`static interface`	`QtConcurrent.RunnableWithVoidPromise9<A,B,C,D,E,F,G,H,I>`
`static class`	`QtConcurrent.ThreadFunctionResult`	Java wrapper for Qt enum QtConcurrent::ThreadFunctionResult

Method Summary

Modifier and Type	Method	Description
`static <T> void`	`blockingFilter(QThreadPool threadPool, Collection<T> sequence, QtConcurrent.FilteredFunctor<T> filteredFunctor)`	Calls filterFunction once for each item in sequence.
`static <T> void`	`blockingFilter(Collection<T> sequence, QtConcurrent.FilteredFunctor<T> filteredFunctor)`	Calls filterFunction once for each item in sequence.
`static <T> List<T>`	`blockingFiltered(QThreadPool threadPool, Collection<T> sequence, QtConcurrent.FilteredFunctor<T> filteredFunctor)`	Calls filterFunctor's filter() method once for each item in sequence and returns a new Sequence of kept items.
`static <T> List<T>`	`blockingFiltered(Collection<T> sequence, QtConcurrent.FilteredFunctor<T> filteredFunctor)`	Calls filterFunctor's filter() method once for each item in sequence and returns a new Sequence of kept items.
`static <U, T> U`	`blockingFilteredReduced(QThreadPool threadPool, Collection<T> sequence, QtConcurrent.FilteredFunctor<T> filteredFunctor, QtConcurrent.ReducedFunctor<U,T> reducedFunctor)`	This is an overloaded method provided for convenience.
`static <U, T> U`	`blockingFilteredReduced(QThreadPool threadPool, Collection<T> sequence, QtConcurrent.FilteredFunctor<T> filteredFunctor, QtConcurrent.ReducedFunctor<U,T> reducedFunctor, QtConcurrent.ReduceOption... options)`	Calls filterFunction once for each item in sequence.
`static <U, T> U`	`blockingFilteredReduced(QThreadPool threadPool, Collection<T> sequence, QtConcurrent.FilteredFunctor<T> filteredFunctor, QtConcurrent.ReducedFunctor<U,T> reducedFunctor, QtConcurrent.ReduceOptions options)`	Calls filterFunction once for each item in sequence.
`static <U, T> U`	`blockingFilteredReduced(Collection<T> sequence, QtConcurrent.FilteredFunctor<T> filteredFunctor, QtConcurrent.ReducedFunctor<U,T> reducedFunctor)`	This is an overloaded method provided for convenience.
`static <U, T> U`	`blockingFilteredReduced(Collection<T> sequence, QtConcurrent.FilteredFunctor<T> filteredFunctor, QtConcurrent.ReducedFunctor<U,T> reducedFunctor, QtConcurrent.ReduceOption... options)`	Calls filterFunction once for each item in sequence.
`static <U, T> U`	`blockingFilteredReduced(Collection<T> sequence, QtConcurrent.FilteredFunctor<T> filteredFunctor, QtConcurrent.ReducedFunctor<U,T> reducedFunctor, QtConcurrent.ReduceOptions options)`	Calls filterFunction once for each item in sequence.
`static <T> void`	`blockingMap(QThreadPool threadPool, Collection<T> sequence, QtConcurrent.MapFunctor<T> functor)`	Calls function once for each item in sequence.
`static <T> void`	`blockingMap(Collection<T> sequence, QtConcurrent.MapFunctor<T> functor)`	Calls function once for each item in sequence.
`static <U, T> List<U>`	`blockingMapped(QThreadPool threadPool, Collection<T> sequence, QtConcurrent.MappedFunctor<U,T> functor)`	Calls function once for each item in sequence and returns a future with each mapped item as a result.
`static <U, T> List<U>`	`blockingMapped(Collection<T> sequence, QtConcurrent.MappedFunctor<U,T> functor)`	Calls function once for each item in sequence and returns a future with each mapped item as a result.
`static <U, V, T> U`	`blockingMappedReduced(QThreadPool threadPool, Collection<T> sequence, QtConcurrent.MappedFunctor<V,T> functor, QtConcurrent.ReducedFunctor<U,V> reducedFunctor)`	This is an overloaded method provided for convenience.
`static <U, V, T> U`	`blockingMappedReduced(QThreadPool threadPool, Collection<T> sequence, QtConcurrent.MappedFunctor<V,T> functor, QtConcurrent.ReducedFunctor<U,V> reducedFunctor, QtConcurrent.ReduceOption... options)`	Calls mapFunction once for each item in sequence.
`static <U, V, T> U`	`blockingMappedReduced(QThreadPool threadPool, Collection<T> sequence, QtConcurrent.MappedFunctor<V,T> functor, QtConcurrent.ReducedFunctor<U,V> reducedFunctor, QtConcurrent.ReduceOptions options)`	Calls mapFunction once for each item in sequence.
`static <U, V, T> U`	`blockingMappedReduced(Collection<T> sequence, QtConcurrent.MappedFunctor<V,T> functor, QtConcurrent.ReducedFunctor<U,V> reducedFunctor)`	This is an overloaded method provided for convenience.
`static <U, V, T> U`	`blockingMappedReduced(Collection<T> sequence, QtConcurrent.MappedFunctor<V,T> functor, QtConcurrent.ReducedFunctor<U,V> reducedFunctor, QtConcurrent.ReduceOption... options)`	Calls mapFunction once for each item in sequence.
`static <U, V, T> U`	`blockingMappedReduced(Collection<T> sequence, QtConcurrent.MappedFunctor<V,T> functor, QtConcurrent.ReducedFunctor<U,V> reducedFunctor, QtConcurrent.ReduceOptions options)`	Calls mapFunction once for each item in sequence.
`static <T> QVoidFuture`	`filter(QThreadPool threadPool, Collection<T> sequence, QtConcurrent.FilteredFunctor<T> filteredFunctor)`	Calls filterFunctor's filter() method once for each item in sequence and returns a new Sequence of kept items.
`static <T> QVoidFuture`	`filter(Collection<T> sequence, QtConcurrent.FilteredFunctor<T> filteredFunctor)`	Calls filterFunctor's filter() method once for each item in sequence and returns a new Sequence of kept items.
`static <T> QFuture<T>`	`filtered(QThreadPool threadPool, Collection<T> sequence, QtConcurrent.FilteredFunctor<T> filteredFunctor)`	Calls filterFunctor's filter() method once for each item in sequence and returns a new Sequence of kept items.
`static <T> QFuture<T>`	`filtered(Collection<T> sequence, QtConcurrent.FilteredFunctor<T> filteredFunctor)`	Calls filterFunctor's filter() method once for each item in sequence and returns a new Sequence of kept items.
`static <U, T> QFuture<U>`	`filteredReduced(QThreadPool threadPool, Collection<T> sequence, QtConcurrent.FilteredFunctor<T> filteredFunctor, QtConcurrent.ReducedFunctor<U,T> reducedFunctor)`	This is an overloaded method provided for convenience.
`static <U, T> QFuture<U>`	`filteredReduced(QThreadPool threadPool, Collection<T> sequence, QtConcurrent.FilteredFunctor<T> filteredFunctor, QtConcurrent.ReducedFunctor<U,T> reducedFunctor, QtConcurrent.ReduceOption... options)`	Calls filterFunction once for each item in sequence.
`static <U, T> QFuture<U>`	`filteredReduced(QThreadPool threadPool, Collection<T> sequence, QtConcurrent.FilteredFunctor<T> filteredFunctor, QtConcurrent.ReducedFunctor<U,T> reducedFunctor, QtConcurrent.ReduceOptions options)`	Calls filterFunction once for each item in sequence.
`static <U, T> QFuture<U>`	`filteredReduced(Collection<T> sequence, QtConcurrent.FilteredFunctor<T> filteredFunctor, QtConcurrent.ReducedFunctor<U,T> reducedFunctor)`	This is an overloaded method provided for convenience.
`static <U, T> QFuture<U>`	`filteredReduced(Collection<T> sequence, QtConcurrent.FilteredFunctor<T> filteredFunctor, QtConcurrent.ReducedFunctor<U,T> reducedFunctor, QtConcurrent.ReduceOption... options)`	Calls filterFunction once for each item in sequence.
`static <U, T> QFuture<U>`	`filteredReduced(Collection<T> sequence, QtConcurrent.FilteredFunctor<T> filteredFunctor, QtConcurrent.ReducedFunctor<U,T> reducedFunctor, QtConcurrent.ReduceOptions options)`	Calls filterFunction once for each item in sequence.
`static <T> QVoidFuture`	`map(QThreadPool threadPool, Collection<T> sequence, QtConcurrent.MapFunctor<T> functor)`	Calls function once for each item in sequence.
`static <T> QVoidFuture`	`map(Collection<T> sequence, QtConcurrent.MapFunctor<T> functor)`	Calls function once for each item in sequence.
`static <U, T> QFuture<U>`	`mapped(QThreadPool threadPool, Collection<T> sequence, QtConcurrent.MappedFunctor<U,T> functor)`	Calls function once for each item in sequence and returns a future with each mapped item as a result.
`static <U, T> QFuture<U>`	`mapped(Collection<T> sequence, QtConcurrent.MappedFunctor<U,T> functor)`	Calls function once for each item in sequence and returns a future with each mapped item as a result.
`static <U, V, T> QFuture<U>`	`mappedReduced(QThreadPool threadPool, Collection<T> sequence, QtConcurrent.MappedFunctor<V,T> functor, QtConcurrent.ReducedFunctor<U,V> reducedFunctor)`	This is an overloaded method provided for convenience.
`static <U, V, T> QFuture<U>`	`mappedReduced(QThreadPool threadPool, Collection<T> sequence, QtConcurrent.MappedFunctor<V,T> functor, QtConcurrent.ReducedFunctor<U,V> reducedFunctor, QtConcurrent.ReduceOption... options)`	This is an overloaded method provided for convenience.
`static <U, V, T> QFuture<U>`	`mappedReduced(QThreadPool threadPool, Collection<T> sequence, QtConcurrent.MappedFunctor<V,T> functor, QtConcurrent.ReducedFunctor<U,V> reducedFunctor, QtConcurrent.ReduceOptions options)`	Calls mapFunction once for each item in sequence.
`static <U, V, T> QFuture<U>`	`mappedReduced(Collection<T> sequence, QtConcurrent.MappedFunctor<V,T> functor, QtConcurrent.ReducedFunctor<U,V> reducedFunctor)`	This is an overloaded method provided for convenience.
`static <U, V, T> QFuture<U>`	`mappedReduced(Collection<T> sequence, QtConcurrent.MappedFunctor<V,T> functor, QtConcurrent.ReducedFunctor<U,V> reducedFunctor, QtConcurrent.ReduceOption... options)`	This is an overloaded method provided for convenience.
`static <U, V, T> QFuture<U>`	`mappedReduced(Collection<T> sequence, QtConcurrent.MappedFunctor<V,T> functor, QtConcurrent.ReducedFunctor<U,V> reducedFunctor, QtConcurrent.ReduceOptions options)`	Calls mapFunction once for each item in sequence.
`static <T, A> QFuture<T>`	`run(QtConcurrent.Callable1<T,A> runnable, A a)`	Executes the Callable using the QtConcurrent framework.
`static <T, A, B> QFuture<T>`	`run(QtConcurrent.Callable2<T,A,B> runnable, A a, B b)`	Executes the Callable using the QtConcurrent framework.
`static <T, A, B, C> QFuture<T>`	`run(QtConcurrent.Callable3<T,A,B,C> runnable, A a, B b, C c)`	Executes the Callable using the QtConcurrent framework.
`static <T, A, B, C, D> QFuture<T>`	`run(QtConcurrent.Callable4<T,A,B,C,D> runnable, A a, B b, C c, D d)`	Executes the Callable using the QtConcurrent framework.
`static <T, A, B, C, D, E> QFuture<T>`	`run(QtConcurrent.Callable5<T,A,B,C,D,E> runnable, A a, B b, C c, D d, E e)`	Executes the Callable using the QtConcurrent framework.
`static <T, A, B, C, D, E, F> QFuture<T>`	`run(QtConcurrent.Callable6<T,A,B,C,D,E,F> runnable, A a, B b, C c, D d, E e, F f)`	Executes the Callable using the QtConcurrent framework.
`static <T, A, B, C, D, E, F, G> QFuture<T>`	`run(QtConcurrent.Callable7<T,A,B,C,D,E,F,G> runnable, A a, B b, C c, D d, E e, F f, G g)`	Executes the Callable using the QtConcurrent framework.
`static <T, A, B, C, D, E, F, G, H> QFuture<T>`	`run(QtConcurrent.Callable8<T,A,B,C,D,E,F,G,H> runnable, A a, B b, C c, D d, E e, F f, G g, H h)`	Executes the Callable using the QtConcurrent framework.
`static <T, A, B, C, D, E, F, G, H, I> QFuture<T>`	`run(QtConcurrent.Callable9<T,A,B,C,D,E,F,G,H,I> runnable, A a, B b, C c, D d, E e, F f, G g, H h, I i)`	Executes the Callable using the QtConcurrent framework.
`static <A> QVoidFuture`	`run(QtConcurrent.Runnable1<A> runnable, A a)`	Executes the Runnable using the QtConcurrent framework.
`static <A, B> QVoidFuture`	`run(QtConcurrent.Runnable2<A,B> runnable, A a, B b)`	Executes the Runnable using the QtConcurrent framework.
`static <A, B, C> QVoidFuture`	`run(QtConcurrent.Runnable3<A,B,C> runnable, A a, B b, C c)`	Executes the Runnable using the QtConcurrent framework.
`static <A, B, C, D> QVoidFuture`	`run(QtConcurrent.Runnable4<A,B,C,D> runnable, A a, B b, C c, D d)`	Executes the Runnable using the QtConcurrent framework.
`static <A, B, C, D, E> QVoidFuture`	`run(QtConcurrent.Runnable5<A,B,C,D,E> runnable, A a, B b, C c, D d, E e)`	Executes the Runnable using the QtConcurrent framework.
`static <A, B, C, D, E, F> QVoidFuture`	`run(QtConcurrent.Runnable6<A,B,C,D,E,F> runnable, A a, B b, C c, D d, E e, F f)`	Executes the Runnable using the QtConcurrent framework.
`static <A, B, C, D, E, F, G> QVoidFuture`	`run(QtConcurrent.Runnable7<A,B,C,D,E,F,G> runnable, A a, B b, C c, D d, E e, F f, G g)`	Executes the Runnable using the QtConcurrent framework.
`static <A, B, C, D, E, F, G, H> QVoidFuture`	`run(QtConcurrent.Runnable8<A,B,C,D,E,F,G,H> runnable, A a, B b, C c, D d, E e, F f, G g, H h)`	Executes the Runnable using the QtConcurrent framework.
`static <A, B, C, D, E, F, G, H, I> QVoidFuture`	`run(QtConcurrent.Runnable9<A,B,C,D,E,F,G,H,I> runnable, A a, B b, C c, D d, E e, F f, G g, H h, I i)`	Executes the Runnable using the QtConcurrent framework.
`static <T> QFuture<T>`	`run(QtConcurrent.RunnableWithPromise<T> runnable)`	Executes the Callable using the QtConcurrent framework.
`static <T, A> QFuture<T>`	`run(QtConcurrent.RunnableWithPromise1<T,A> runnable, A a)`	Executes the Callable using the QtConcurrent framework.
`static <T, A, B> QFuture<T>`	`run(QtConcurrent.RunnableWithPromise2<T,A,B> runnable, A a, B b)`	Executes the Callable using the QtConcurrent framework.
`static <T, A, B, C> QFuture<T>`	`run(QtConcurrent.RunnableWithPromise3<T,A,B,C> runnable, A a, B b, C c)`	Executes the Callable using the QtConcurrent framework.
`static <T, A, B, C, D> QFuture<T>`	`run(QtConcurrent.RunnableWithPromise4<T,A,B,C,D> runnable, A a, B b, C c, D d)`	Executes the Callable using the QtConcurrent framework.
`static <T, A, B, C, D, E> QFuture<T>`	`run(QtConcurrent.RunnableWithPromise5<T,A,B,C,D,E> runnable, A a, B b, C c, D d, E e)`	Executes the Callable using the QtConcurrent framework.
`static <T, A, B, C, D, E, F> QFuture<T>`	`run(QtConcurrent.RunnableWithPromise6<T,A,B,C,D,E,F> runnable, A a, B b, C c, D d, E e, F f)`	Executes the Callable using the QtConcurrent framework.
`static <T, A, B, C, D, E, F, G> QFuture<T>`	`run(QtConcurrent.RunnableWithPromise7<T,A,B,C,D,E,F,G> runnable, A a, B b, C c, D d, E e, F f, G g)`	Executes the RunnableWithPromise using the QtConcurrent framework.
`static <T, A, B, C, D, E, F, G, H> QFuture<T>`	`run(QtConcurrent.RunnableWithPromise8<T,A,B,C,D,E,F,G,H> runnable, A a, B b, C c, D d, E e, F f, G g, H h)`	Executes the Callable using the QtConcurrent framework.
`static <T, A, B, C, D, E, F, G, H, I> QFuture<T>`	`run(QtConcurrent.RunnableWithPromise9<T,A,B,C,D,E,F,G,H,I> runnable, A a, B b, C c, D d, E e, F f, G g, H h, I i)`	Executes the Callable using the QtConcurrent framework.
`static QVoidFuture`	`run(QtConcurrent.RunnableWithVoidPromise runnable)`	Executes the Runnable using the QtConcurrent framework.
`static <A> QVoidFuture`	`run(QtConcurrent.RunnableWithVoidPromise1<A> runnable, A a)`	Executes the Runnable using the QtConcurrent framework.
`static <A, B> QVoidFuture`	`run(QtConcurrent.RunnableWithVoidPromise2<A,B> runnable, A a, B b)`	Executes the Runnable using the QtConcurrent framework.
`static <A, B, C> QVoidFuture`	`run(QtConcurrent.RunnableWithVoidPromise3<A,B,C> runnable, A a, B b, C c)`	Executes the Runnable using the QtConcurrent framework.
`static <A, B, C, D> QVoidFuture`	`run(QtConcurrent.RunnableWithVoidPromise4<A,B,C,D> runnable, A a, B b, C c, D d)`	Executes the Runnable using the QtConcurrent framework.
`static <A, B, C, D, E> QVoidFuture`	`run(QtConcurrent.RunnableWithVoidPromise5<A,B,C,D,E> runnable, A a, B b, C c, D d, E e)`	Executes the Runnable using the QtConcurrent framework.
`static <A, B, C, D, E, F> QVoidFuture`	`run(QtConcurrent.RunnableWithVoidPromise6<A,B,C,D,E,F> runnable, A a, B b, C c, D d, E e, F f)`	Executes the Runnable using the QtConcurrent framework.
`static <A, B, C, D, E, F, G> QVoidFuture`	`run(QtConcurrent.RunnableWithVoidPromise7<A,B,C,D,E,F,G> runnable, A a, B b, C c, D d, E e, F f, G g)`	Executes the Runnable using the QtConcurrent framework.
`static <A, B, C, D, E, F, G, H> QVoidFuture`	`run(QtConcurrent.RunnableWithVoidPromise8<A,B,C,D,E,F,G,H> runnable, A a, B b, C c, D d, E e, F f, G g, H h)`	Executes the Runnable using the QtConcurrent framework.
`static <A, B, C, D, E, F, G, H, I> QVoidFuture`	`run(QtConcurrent.RunnableWithVoidPromise9<A,B,C,D,E,F,G,H,I> runnable, A a, B b, C c, D d, E e, F f, G g, H h, I i)`	Executes the Runnable using the QtConcurrent framework.
`static <T, A> QFuture<T>`	`run(QThreadPool threadPool, QtConcurrent.Callable1<T,A> runnable, A a)`	Executes the Callable using the QtConcurrent framework.
`static <T, A, B> QFuture<T>`	`run(QThreadPool threadPool, QtConcurrent.Callable2<T,A,B> runnable, A a, B b)`	Executes the Callable using the QtConcurrent framework.
`static <T, A, B, C> QFuture<T>`	`run(QThreadPool threadPool, QtConcurrent.Callable3<T,A,B,C> runnable, A a, B b, C c)`	Executes the Callable using the QtConcurrent framework.
`static <T, A, B, C, D> QFuture<T>`	`run(QThreadPool threadPool, QtConcurrent.Callable4<T,A,B,C,D> runnable, A a, B b, C c, D d)`	Executes the Callable using the QtConcurrent framework.
`static <T, A, B, C, D, E> QFuture<T>`	`run(QThreadPool threadPool, QtConcurrent.Callable5<T,A,B,C,D,E> runnable, A a, B b, C c, D d, E e)`	Executes the Callable using the QtConcurrent framework.
`static <T, A, B, C, D, E, F> QFuture<T>`	`run(QThreadPool threadPool, QtConcurrent.Callable6<T,A,B,C,D,E,F> runnable, A a, B b, C c, D d, E e, F f)`	Executes the Callable using the QtConcurrent framework.
`static <T, A, B, C, D, E, F, G> QFuture<T>`	`run(QThreadPool threadPool, QtConcurrent.Callable7<T,A,B,C,D,E,F,G> runnable, A a, B b, C c, D d, E e, F f, G g)`	Executes the Callable using the QtConcurrent framework.
`static <T, A, B, C, D, E, F, G, H> QFuture<T>`	`run(QThreadPool threadPool, QtConcurrent.Callable8<T,A,B,C,D,E,F,G,H> runnable, A a, B b, C c, D d, E e, F f, G g, H h)`	Executes the Callable using the QtConcurrent framework.
`static <T, A, B, C, D, E, F, G, H, I> QFuture<T>`	`run(QThreadPool threadPool, QtConcurrent.Callable9<T,A,B,C,D,E,F,G,H,I> runnable, A a, B b, C c, D d, E e, F f, G g, H h, I i)`	Executes the Callable using the QtConcurrent framework.
`static <A> QVoidFuture`	`run(QThreadPool threadPool, QtConcurrent.Runnable1<A> runnable, A a)`	Executes the Runnable using the QtConcurrent framework.
`static <A, B> QVoidFuture`	`run(QThreadPool threadPool, QtConcurrent.Runnable2<A,B> runnable, A a, B b)`	Executes the Runnable using the QtConcurrent framework.
`static <A, B, C> QVoidFuture`	`run(QThreadPool threadPool, QtConcurrent.Runnable3<A,B,C> runnable, A a, B b, C c)`	Executes the Runnable using the QtConcurrent framework.
`static <A, B, C, D> QVoidFuture`	`run(QThreadPool threadPool, QtConcurrent.Runnable4<A,B,C,D> runnable, A a, B b, C c, D d)`	Executes the Runnable using the QtConcurrent framework.
`static <A, B, C, D, E> QVoidFuture`	`run(QThreadPool threadPool, QtConcurrent.Runnable5<A,B,C,D,E> runnable, A a, B b, C c, D d, E e)`	Executes the Runnable using the QtConcurrent framework.
`static <A, B, C, D, E, F> QVoidFuture`	`run(QThreadPool threadPool, QtConcurrent.Runnable6<A,B,C,D,E,F> runnable, A a, B b, C c, D d, E e, F f)`	Executes the Runnable using the QtConcurrent framework.
`static <A, B, C, D, E, F, G> QVoidFuture`	`run(QThreadPool threadPool, QtConcurrent.Runnable7<A,B,C,D,E,F,G> runnable, A a, B b, C c, D d, E e, F f, G g)`	Executes the Runnable using the QtConcurrent framework.
`static <A, B, C, D, E, F, G, H> QVoidFuture`	`run(QThreadPool threadPool, QtConcurrent.Runnable8<A,B,C,D,E,F,G,H> runnable, A a, B b, C c, D d, E e, F f, G g, H h)`	Executes the Runnable using the QtConcurrent framework.
`static <A, B, C, D, E, F, G, H, I> QVoidFuture`	`run(QThreadPool threadPool, QtConcurrent.Runnable9<A,B,C,D,E,F,G,H,I> runnable, A a, B b, C c, D d, E e, F f, G g, H h, I i)`	Executes the Runnable using the QtConcurrent framework.
`static <T> QFuture<T>`	`run(QThreadPool threadPool, QtConcurrent.RunnableWithPromise<T> runnable)`	Executes the Callable using the QtConcurrent framework.
`static <T, A> QFuture<T>`	`run(QThreadPool threadPool, QtConcurrent.RunnableWithPromise1<T,A> runnable, A a)`	Executes the Callable using the QtConcurrent framework.
`static <T, A, B> QFuture<T>`	`run(QThreadPool threadPool, QtConcurrent.RunnableWithPromise2<T,A,B> runnable, A a, B b)`	Executes the Callable using the QtConcurrent framework.
`static <T, A, B, C> QFuture<T>`	`run(QThreadPool threadPool, QtConcurrent.RunnableWithPromise3<T,A,B,C> runnable, A a, B b, C c)`	Executes the Callable using the QtConcurrent framework.
`static <T, A, B, C, D> QFuture<T>`	`run(QThreadPool threadPool, QtConcurrent.RunnableWithPromise4<T,A,B,C,D> runnable, A a, B b, C c, D d)`	Executes the Callable using the QtConcurrent framework.
`static <T, A, B, C, D, E> QFuture<T>`	`run(QThreadPool threadPool, QtConcurrent.RunnableWithPromise5<T,A,B,C,D,E> runnable, A a, B b, C c, D d, E e)`	Executes the Callable using the QtConcurrent framework.
`static <T, A, B, C, D, E, F> QFuture<T>`	`run(QThreadPool threadPool, QtConcurrent.RunnableWithPromise6<T,A,B,C,D,E,F> runnable, A a, B b, C c, D d, E e, F f)`	Executes the Callable using the QtConcurrent framework.
`static <T, A, B, C, D, E, F, G> QFuture<T>`	`run(QThreadPool threadPool, QtConcurrent.RunnableWithPromise7<T,A,B,C,D,E,F,G> runnable, A a, B b, C c, D d, E e, F f, G g)`	Executes the Callable using the QtConcurrent framework.
`static <T, A, B, C, D, E, F, G, H> QFuture<T>`	`run(QThreadPool threadPool, QtConcurrent.RunnableWithPromise8<T,A,B,C,D,E,F,G,H> runnable, A a, B b, C c, D d, E e, F f, G g, H h)`	Executes the Callable using the QtConcurrent framework.
`static <T, A, B, C, D, E, F, G, H, I> QFuture<T>`	`run(QThreadPool threadPool, QtConcurrent.RunnableWithPromise9<T,A,B,C,D,E,F,G,H,I> runnable, A a, B b, C c, D d, E e, F f, G g, H h, I i)`	Executes the Callable using the QtConcurrent framework.
`static QVoidFuture`	`run(QThreadPool threadPool, QtConcurrent.RunnableWithVoidPromise runnable)`	Executes the Runnable using the QtConcurrent framework.
`static <A> QVoidFuture`	`run(QThreadPool threadPool, QtConcurrent.RunnableWithVoidPromise1<A> runnable, A a)`	Executes the Runnable using the QtConcurrent framework.
`static <A, B> QVoidFuture`	`run(QThreadPool threadPool, QtConcurrent.RunnableWithVoidPromise2<A,B> runnable, A a, B b)`	Executes the Runnable using the QtConcurrent framework.
`static <A, B, C> QVoidFuture`	`run(QThreadPool threadPool, QtConcurrent.RunnableWithVoidPromise3<A,B,C> runnable, A a, B b, C c)`	Executes the Runnable using the QtConcurrent framework.
`static <A, B, C, D> QVoidFuture`	`run(QThreadPool threadPool, QtConcurrent.RunnableWithVoidPromise4<A,B,C,D> runnable, A a, B b, C c, D d)`	Executes the Runnable using the QtConcurrent framework.
`static <A, B, C, D, E> QVoidFuture`	`run(QThreadPool threadPool, QtConcurrent.RunnableWithVoidPromise5<A,B,C,D,E> runnable, A a, B b, C c, D d, E e)`	Executes the Runnable using the QtConcurrent framework.
`static <A, B, C, D, E, F> QVoidFuture`	`run(QThreadPool threadPool, QtConcurrent.RunnableWithVoidPromise6<A,B,C,D,E,F> runnable, A a, B b, C c, D d, E e, F f)`	Executes the Runnable using the QtConcurrent framework.
`static <A, B, C, D, E, F, G> QVoidFuture`	`run(QThreadPool threadPool, QtConcurrent.RunnableWithVoidPromise7<A,B,C,D,E,F,G> runnable, A a, B b, C c, D d, E e, F f, G g)`	Executes the Runnable using the QtConcurrent framework.
`static <A, B, C, D, E, F, G, H> QVoidFuture`	`run(QThreadPool threadPool, QtConcurrent.RunnableWithVoidPromise8<A,B,C,D,E,F,G,H> runnable, A a, B b, C c, D d, E e, F f, G g, H h)`	Executes the Runnable using the QtConcurrent framework.
`static <A, B, C, D, E, F, G, H, I> QVoidFuture`	`run(QThreadPool threadPool, QtConcurrent.RunnableWithVoidPromise9<A,B,C,D,E,F,G,H,I> runnable, A a, B b, C c, D d, E e, F f, G g, H h, I i)`	Executes the Runnable using the QtConcurrent framework.
`static QVoidFuture`	`run(QThreadPool threadPool, Runnable runnable)`	Executes the Runnable `Void` using the QtConcurrent framework.
`static <T> QFuture<T>`	`run(QThreadPool threadPool, Callable<T> callable)`	Executes the Callable `callable` through the QtConcurrent framework.
`static QVoidFuture`	`run(Runnable runnable)`	Executes the Runnable `Void` using the QtConcurrent framework.
`static <T> QFuture<T>`	`run(Callable<T> callable)`	Executes the Callable `callable` through the QtConcurrent framework.
`static <T, A> QtConcurrent.QTypedTaskBuilder1Arg0<T,A>`	`task(QtConcurrent.Callable1<T,A> callable)`
`static <T, A, B> QtConcurrent.QTypedTaskBuilder2Arg0<T,A,B>`	`task(QtConcurrent.Callable2<T,A,B> callable)`
`static <T, A, B, C> QtConcurrent.QTypedTaskBuilder3Arg0<T,A,B,C>`	`task(QtConcurrent.Callable3<T,A,B,C> callable)`
`static <T, A, B, C, D> QtConcurrent.QTypedTaskBuilder4Arg0<T,A,B,C,D>`	`task(QtConcurrent.Callable4<T,A,B,C,D> callable)`
`static <T, A, B, C, D, E> QtConcurrent.QTypedTaskBuilder5Arg0<T,A,B,C,D,E>`	`task(QtConcurrent.Callable5<T,A,B,C,D,E> callable)`
`static <T, A, B, C, D, E, F> QtConcurrent.QTypedTaskBuilder6Arg0<T,A,B,C,D,E,F>`	`task(QtConcurrent.Callable6<T,A,B,C,D,E,F> callable)`
`static <T, A, B, C, D, E, F, G> QtConcurrent.QTypedTaskBuilder7Arg0<T,A,B,C,D,E,F,G>`	`task(QtConcurrent.Callable7<T,A,B,C,D,E,F,G> callable)`
`static <T, A, B, C, D, E, F, G, H> QtConcurrent.QTypedTaskBuilder8Arg0<T,A,B,C,D,E,F,G,H>`	`task(QtConcurrent.Callable8<T,A,B,C,D,E,F,G,H> callable)`
`static <T, A, B, C, D, E, F, G, H, I> QtConcurrent.QTypedTaskBuilder9Arg0<T,A,B,C,D,E,F,G,H,I>`	`task(QtConcurrent.Callable9<T,A,B,C,D,E,F,G,H,I> callable)`
`static <A> QtConcurrent.QTaskBuilderVoid1Arg0<A>`	`task(QtConcurrent.Runnable1<A> runnable)`
`static <A, B> QtConcurrent.QTaskBuilderVoid2Arg0<A,B>`	`task(QtConcurrent.Runnable2<A,B> runnable)`
`static <A, B, C> QtConcurrent.QTaskBuilderVoid3Arg0<A,B,C>`	`task(QtConcurrent.Runnable3<A,B,C> runnable)`
`static <A, B, C, D> QtConcurrent.QTaskBuilderVoid4Arg0<A,B,C,D>`	`task(QtConcurrent.Runnable4<A,B,C,D> runnable)`
`static <A, B, C, D, E> QtConcurrent.QTaskBuilderVoid5Arg0<A,B,C,D,E>`	`task(QtConcurrent.Runnable5<A,B,C,D,E> runnable)`
`static <A, B, C, D, E, F> QtConcurrent.QTaskBuilderVoid6Arg0<A,B,C,D,E,F>`	`task(QtConcurrent.Runnable6<A,B,C,D,E,F> runnable)`
`static <A, B, C, D, E, F, G> QtConcurrent.QTaskBuilderVoid7Arg0<A,B,C,D,E,F,G>`	`task(QtConcurrent.Runnable7<A,B,C,D,E,F,G> runnable)`
`static <A, B, C, D, E, F, G, H> QtConcurrent.QTaskBuilderVoid8Arg0<A,B,C,D,E,F,G,H>`	`task(QtConcurrent.Runnable8<A,B,C,D,E,F,G,H> runnable)`
`static <A, B, C, D, E, F, G, H, I> QtConcurrent.QTaskBuilderVoid9Arg0<A,B,C,D,E,F,G,H,I>`	`task(QtConcurrent.Runnable9<A,B,C,D,E,F,G,H,I> runnable)`
`static <T> QtConcurrent.QTypedPromiseTaskBuilder0Arg0<T>`	`task(QtConcurrent.RunnableWithPromise<T> callable)`
`static <T, A> QtConcurrent.QTypedPromiseTaskBuilder1Arg0<T,A>`	`task(QtConcurrent.RunnableWithPromise1<T,A> runnable)`
`static <T, A, B> QtConcurrent.QTypedPromiseTaskBuilder2Arg0<T,A,B>`	`task(QtConcurrent.RunnableWithPromise2<T,A,B> runnable)`
`static <T, A, B, C> QtConcurrent.QTypedPromiseTaskBuilder3Arg0<T,A,B,C>`	`task(QtConcurrent.RunnableWithPromise3<T,A,B,C> runnable)`
`static <T, A, B, C, D> QtConcurrent.QTypedPromiseTaskBuilder4Arg0<T,A,B,C,D>`	`task(QtConcurrent.RunnableWithPromise4<T,A,B,C,D> runnable)`
`static <T, A, B, C, D, E> QtConcurrent.QTypedPromiseTaskBuilder5Arg0<T,A,B,C,D,E>`	`task(QtConcurrent.RunnableWithPromise5<T,A,B,C,D,E> runnable)`
`static <T, A, B, C, D, E, F> QtConcurrent.QTypedPromiseTaskBuilder6Arg0<T,A,B,C,D,E,F>`	`task(QtConcurrent.RunnableWithPromise6<T,A,B,C,D,E,F> runnable)`
`static <T, A, B, C, D, E, F, G> QtConcurrent.QTypedPromiseTaskBuilder7Arg0<T,A,B,C,D,E,F,G>`	`task(QtConcurrent.RunnableWithPromise7<T,A,B,C,D,E,F,G> runnable)`
`static <T, A, B, C, D, E, F, G, H> QtConcurrent.QTypedPromiseTaskBuilder8Arg0<T,A,B,C,D,E,F,G,H>`	`task(QtConcurrent.RunnableWithPromise8<T,A,B,C,D,E,F,G,H> runnable)`
`static <T, A, B, C, D, E, F, G, H, I> QtConcurrent.QTypedPromiseTaskBuilder9Arg0<T,A,B,C,D,E,F,G,H,I>`	`task(QtConcurrent.RunnableWithPromise9<T,A,B,C,D,E,F,G,H,I> runnable)`
`static QtConcurrent.QPromiseTaskBuilderVoid0Arg0`	`task(QtConcurrent.RunnableWithVoidPromise runnable)`
`static <A> QtConcurrent.QPromiseTaskBuilderVoid1Arg0<A>`	`task(QtConcurrent.RunnableWithVoidPromise1<A> runnable)`
`static <A, B> QtConcurrent.QPromiseTaskBuilderVoid2Arg0<A,B>`	`task(QtConcurrent.RunnableWithVoidPromise2<A,B> runnable)`
`static <A, B, C> QtConcurrent.QPromiseTaskBuilderVoid3Arg0<A,B,C>`	`task(QtConcurrent.RunnableWithVoidPromise3<A,B,C> runnable)`
`static <A, B, C, D> QtConcurrent.QPromiseTaskBuilderVoid4Arg0<A,B,C,D>`	`task(QtConcurrent.RunnableWithVoidPromise4<A,B,C,D> runnable)`
`static <A, B, C, D, E> QtConcurrent.QPromiseTaskBuilderVoid5Arg0<A,B,C,D,E>`	`task(QtConcurrent.RunnableWithVoidPromise5<A,B,C,D,E> runnable)`
`static <A, B, C, D, E, F> QtConcurrent.QPromiseTaskBuilderVoid6Arg0<A,B,C,D,E,F>`	`task(QtConcurrent.RunnableWithVoidPromise6<A,B,C,D,E,F> runnable)`
`static <A, B, C, D, E, F, G> QtConcurrent.QPromiseTaskBuilderVoid7Arg0<A,B,C,D,E,F,G>`	`task(QtConcurrent.RunnableWithVoidPromise7<A,B,C,D,E,F,G> runnable)`
`static <A, B, C, D, E, F, G, H> QtConcurrent.QPromiseTaskBuilderVoid8Arg0<A,B,C,D,E,F,G,H>`	`task(QtConcurrent.RunnableWithVoidPromise8<A,B,C,D,E,F,G,H> runnable)`
`static <A, B, C, D, E, F, G, H, I> QtConcurrent.QPromiseTaskBuilderVoid9Arg0<A,B,C,D,E,F,G,H,I>`	`task(QtConcurrent.RunnableWithVoidPromise9<A,B,C,D,E,F,G,H,I> runnable)`
`static QtConcurrent.QTaskBuilderVoid0Arg0`	`task(Runnable runnable)`
`static <T> QtConcurrent.QTypedTaskBuilder0Arg0<T>`	`task(Callable<T> callable)`

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Method Details
- map
 
 @QtUninvokable public static <T> QVoidFuture map(Collection<T> sequence, QtConcurrent.MapFunctor<T> functor)
 
 Calls function once for each item in sequence. The function is passed a reference to the item, so that any modifications done to the item will appear in sequence.
- blockingMap
 
 @QtUninvokable public static <T> void blockingMap(Collection<T> sequence, QtConcurrent.MapFunctor<T> functor)
 
 Calls function once for each item in sequence. The function is passed a reference to the item, so that any modifications done to the item will appear in sequence.
- mapped
 
 @QtUninvokable public static <U, T> QFuture mapped(Collection<T> sequence, QtConcurrent.MappedFunctor<U,T> functor)
 
 Calls function once for each item in sequence and returns a future with each mapped item as a result. You can QFutureIterator to iterate through the results.
- blockingMapped
 
 @QtUninvokable public static <U, T> List blockingMapped(Collection<T> sequence, QtConcurrent.MappedFunctor<U,T> functor)
 
 Calls function once for each item in sequence and returns a future with each mapped item as a result. You can QFutureIterator to iterate through the results.
- mappedReduced
 
 @QtUninvokable public static <U, V, T> QFuture mappedReduced(Collection<T> sequence, QtConcurrent.MappedFunctor<V,T> functor, QtConcurrent.ReducedFunctor<U,V> reducedFunctor)
 
 This is an overloaded method provided for convenience.
 It is equivalent of mappedReduced(sequence, functor, reducedFunctor, ReduceOption.UnorderedReduce, ReduceOption.SequentialReduce)
- mappedReduced
 
 @QtUninvokable public static <U, V, T> QFuture mappedReduced(Collection<T> sequence, QtConcurrent.MappedFunctor<V,T> functor, QtConcurrent.ReducedFunctor<U,V> reducedFunctor, QtConcurrent.ReduceOption... options)
 
 This is an overloaded method provided for convenience.
 Note that while mapFunction is called concurrently, only one thread at a time will call reduceFunction. The order in which reduceFunction is called is determined by reduceOptions.
- mappedReduced
 
 @QtUninvokable public static <U, V, T> QFuture mappedReduced(Collection<T> sequence, QtConcurrent.MappedFunctor<V,T> functor, QtConcurrent.ReducedFunctor<U,V> reducedFunctor, QtConcurrent.ReduceOptions options)
 
 Calls mapFunction once for each item in sequence. The return value of each mapFunction is passed to reduceFunction.
 Note that while mapFunction is called concurrently, only one thread at a time will call reduceFunction. The order in which reduceFunction is called is determined by reduceOptions.
- blockingMappedReduced
 
 @QtUninvokable public static <U, V, T> U blockingMappedReduced(Collection<T> sequence, QtConcurrent.MappedFunctor<V,T> functor, QtConcurrent.ReducedFunctor<U,V> reducedFunctor)
 
 This is an overloaded method provided for convenience.
 It is equivalent of calling blockingMappedReduced(sequence, functor, reducedFunctor, ReduceOption.UnorderedReduce, ReduceOption.SequentialReduce)
- blockingMappedReduced
 
 @QtUninvokable public static <U, V, T> U blockingMappedReduced(Collection<T> sequence, QtConcurrent.MappedFunctor<V,T> functor, QtConcurrent.ReducedFunctor<U,V> reducedFunctor, QtConcurrent.ReduceOption... options)
 
 Calls mapFunction once for each item in sequence. The return value of each mapFunction is passed to reduceFunction.
 Note that while mapFunction is called concurrently, only one thread at a time will call reduceFunction. The order in which reduceFunction is called is determined by reduceOptions.
 Note: This function will block until all items in the sequence have been processed.
- blockingMappedReduced
 
 @QtUninvokable public static <U, V, T> U blockingMappedReduced(Collection<T> sequence, QtConcurrent.MappedFunctor<V,T> functor, QtConcurrent.ReducedFunctor<U,V> reducedFunctor, QtConcurrent.ReduceOptions options)
 
 Calls mapFunction once for each item in sequence. The return value of each mapFunction is passed to reduceFunction.
 Note that while mapFunction is called concurrently, only one thread at a time will call reduceFunction. The order in which reduceFunction is called is determined by reduceOptions.
 Note: This function will block until all items in the sequence have been processed.
- filter
 
 @QtUninvokable public static <T> QVoidFuture filter(Collection<T> sequence, QtConcurrent.FilteredFunctor<T> filteredFunctor)
 
 Calls filterFunctor's filter() method once for each item in sequence and returns a new Sequence of kept items. If filterFunction returns true, a copy of the item is put in the new Sequence. Otherwise, the item will not appear in the new Sequence.
- filtered
 
 @QtUninvokable public static <T> QFuture<T> filtered(Collection<T> sequence, QtConcurrent.FilteredFunctor<T> filteredFunctor)
 
 Calls filterFunctor's filter() method once for each item in sequence and returns a new Sequence of kept items. If filterFunction returns true, a copy of the item is put in the new Sequence. Otherwise, the item will not appear in the new Sequence.
- blockingFiltered
 
 @QtUninvokable public static <T> List<T> blockingFiltered(Collection<T> sequence, QtConcurrent.FilteredFunctor<T> filteredFunctor)
 
 Calls filterFunctor's filter() method once for each item in sequence and returns a new Sequence of kept items. If filterFunction returns true, a copy of the item is put in the new Sequence. Otherwise, the item will not appear in the new Sequence.
- blockingFilter
 
 @QtUninvokable public static <T> void blockingFilter(Collection<T> sequence, QtConcurrent.FilteredFunctor<T> filteredFunctor)
 
 Calls filterFunction once for each item in sequence. If filterFunction returns true, the item is kept in sequence; otherwise, the item is removed from sequence. Note: This function will block until all items in the sequence have been processed.
- filteredReduced
 
 @QtUninvokable public static <U, T> QFuture filteredReduced(Collection<T> sequence, QtConcurrent.FilteredFunctor<T> filteredFunctor, QtConcurrent.ReducedFunctor<U,T> reducedFunctor)
 
 This is an overloaded method provided for convenience. It is equivalent of calling filteredReduced(sequence, filteredFunctor, ReduceOption.UnorderedReduce, ReduceOption.Seq This is an overloaded method provided for convenience. It is equivalent of calling filteredReduced)
- filteredReduced
 
 @QtUninvokable public static <U, T> QFuture filteredReduced(Collection<T> sequence, QtConcurrent.FilteredFunctor<T> filteredFunctor, QtConcurrent.ReducedFunctor<U,T> reducedFunctor, QtConcurrent.ReduceOption... options)
 
 Calls filterFunction once for each item in sequence. If filterFunction returns true for an item, that item is then passed to reduceFunction. In other words, the return value is the result of reduceFunction for each item where filterFunction returns true.
 Note that while filterFunction is called concurrently, only one thread at a time will call reduceFunction. The order in which reduceFunction is called is undefined if reduceOptions is QtConcurrent::UnorderedReduce. If reduceOptions is QtConcurrent::OrderedReduce, reduceFunction is called in the order of the original sequence.
- filteredReduced
 
 @QtUninvokable public static <U, T> QFuture filteredReduced(Collection<T> sequence, QtConcurrent.FilteredFunctor<T> filteredFunctor, QtConcurrent.ReducedFunctor<U,T> reducedFunctor, QtConcurrent.ReduceOptions options)
 
 Calls filterFunction once for each item in sequence. If filterFunction returns true for an item, that item is then passed to reduceFunction. In other words, the return value is the result of reduceFunction for each item where filterFunction returns true.
 Note that while filterFunction is called concurrently, only one thread at a time will call reduceFunction. The order in which reduceFunction is called is undefined if reduceOptions is QtConcurrent::UnorderedReduce. If reduceOptions is QtConcurrent::OrderedReduce, reduceFunction is called in the order of the original sequence.
- blockingFilteredReduced
 
 @QtUninvokable public static <U, T> U blockingFilteredReduced(Collection<T> sequence, QtConcurrent.FilteredFunctor<T> filteredFunctor, QtConcurrent.ReducedFunctor<U,T> reducedFunctor)
 
 This is an overloaded method provided for convenience. It is the equivalent of calling blockingFilteredReduced(sequence, filteredFunctor, reducedFunctor, ReduceOption.UnorderedReduce, ReduceOption.SequentialReduce)
- blockingFilteredReduced
 
 @QtUninvokable public static <U, T> U blockingFilteredReduced(Collection<T> sequence, QtConcurrent.FilteredFunctor<T> filteredFunctor, QtConcurrent.ReducedFunctor<U,T> reducedFunctor, QtConcurrent.ReduceOption... options)
 
 Calls filterFunction once for each item in sequence. If filterFunction returns true for an item, that item is then passed to reduceFunction. In other words, the return value is the result of reduceFunction for each item where filterFunction returns true.
 Note that while filterFunction is called concurrently, only one thread at a time will call reduceFunction. The order in which reduceFunction is called is undefined if reduceOptions is QtConcurrent::UnorderedReduce. If reduceOptions is QtConcurrent::OrderedReduce, reduceFunction is called in the order of the original sequence.
- blockingFilteredReduced
 
 @QtUninvokable public static <U, T> U blockingFilteredReduced(Collection<T> sequence, QtConcurrent.FilteredFunctor<T> filteredFunctor, QtConcurrent.ReducedFunctor<U,T> reducedFunctor, QtConcurrent.ReduceOptions options)
 
 Calls filterFunction once for each item in sequence. If filterFunction returns true for an item, that item is then passed to reduceFunction. In other words, the return value is the result of reduceFunction for each item where filterFunction returns true.
 Note that while filterFunction is called concurrently, only one thread at a time will call reduceFunction. The order in which reduceFunction is called is undefined if reduceOptions is QtConcurrent::UnorderedReduce. If reduceOptions is QtConcurrent::OrderedReduce, reduceFunction is called in the order of the original sequence.
- run
 
 @QtUninvokable public static <T> QFuture<T> run(Callable<T> callable)
 
 Executes the Callable callable through the QtConcurrent framework. The returned QFuture object's result will be the return value of callable.
- run
 
 @QtUninvokable public static <T> QFuture<T> run(QThreadPool threadPool, Callable<T> callable)
 
 Executes the Callable callable through the QtConcurrent framework. The thread is taken from the QThreadPool pool. The returned QFuture object's result will be the return value of callable.
- run
 
 @QtUninvokable public static QVoidFuture run(Runnable runnable)
 
 Executes the Runnable Void using the QtConcurrent framework.
- run
 
 @QtUninvokable public static QVoidFuture run(QThreadPool threadPool, Runnable runnable)
 
 Executes the Runnable Void using the QtConcurrent framework. The thread is taken from the QThreadPool pool.
- run
 
 public static <A> QVoidFuture run(QtConcurrent.Runnable1<A> runnable, A a)
 
 Executes the Runnable using the QtConcurrent framework.
- run
 
 public static <A> QVoidFuture run(QThreadPool threadPool, QtConcurrent.Runnable1<A> runnable, A a)
 
 Executes the Runnable using the QtConcurrent framework. The thread is taken from the QThreadPool pool.
- run
 
 public static <A, B> QVoidFuture run(QtConcurrent.Runnable2<A,B> runnable, A a, B b)
 
 Executes the Runnable using the QtConcurrent framework.
- run
 
 public static <A, B> QVoidFuture run(QThreadPool threadPool, QtConcurrent.Runnable2<A,B> runnable, A a, B b)
 
 Executes the Runnable using the QtConcurrent framework. The thread is taken from the QThreadPool pool.
- run
 
 public static <A, B, C> QVoidFuture run(QtConcurrent.Runnable3<A,B,C> runnable, A a, B b, C c)
 
 Executes the Runnable using the QtConcurrent framework.
- run
 
 public static <A, B, C> QVoidFuture run(QThreadPool threadPool, QtConcurrent.Runnable3<A,B,C> runnable, A a, B b, C c)
 
 Executes the Runnable using the QtConcurrent framework. The thread is taken from the QThreadPool pool.
- run
 
 public static <A, B, C, D> QVoidFuture run(QtConcurrent.Runnable4<A,B,C,D> runnable, A a, B b, C c, D d)
 
 Executes the Runnable using the QtConcurrent framework.
- run
 
 public static <A, B, C, D> QVoidFuture run(QThreadPool threadPool, QtConcurrent.Runnable4<A,B,C,D> runnable, A a, B b, C c, D d)
 
 Executes the Runnable using the QtConcurrent framework. The thread is taken from the QThreadPool pool.
- run
 
 public static <A, B, C, D, E> QVoidFuture run(QtConcurrent.Runnable5<A,B,C,D,E> runnable, A a, B b, C c, D d, E e)
 
 Executes the Runnable using the QtConcurrent framework.
- run
 
 public static <A, B, C, D, E> QVoidFuture run(QThreadPool threadPool, QtConcurrent.Runnable5<A,B,C,D,E> runnable, A a, B b, C c, D d, E e)
 
 Executes the Runnable using the QtConcurrent framework. The thread is taken from the QThreadPool pool.
- run
 
 public static <T, A> QFuture<T> run(QtConcurrent.Callable1<T,A> runnable, A a)
 
 Executes the Callable using the QtConcurrent framework.
- run
 
 public static <T, A> QFuture<T> run(QThreadPool threadPool, QtConcurrent.Callable1<T,A> runnable, A a)
 
 Executes the Callable using the QtConcurrent framework. The thread is taken from the QThreadPool pool.
- run
 
 public static <T, A, B> QFuture<T> run(QtConcurrent.Callable2<T,A,B> runnable, A a, B b)
 
 Executes the Callable using the QtConcurrent framework.
- run
 
 public static <T, A, B> QFuture<T> run(QThreadPool threadPool, QtConcurrent.Callable2<T,A,B> runnable, A a, B b)
 
 Executes the Callable using the QtConcurrent framework. The thread is taken from the QThreadPool pool.
- run
 
 public static <T, A, B, C> QFuture<T> run(QtConcurrent.Callable3<T,A,B,C> runnable, A a, B b, C c)
 
 Executes the Callable using the QtConcurrent framework.
- run
 
 public static <T, A, B, C> QFuture<T> run(QThreadPool threadPool, QtConcurrent.Callable3<T,A,B,C> runnable, A a, B b, C c)
 
 Executes the Callable using the QtConcurrent framework. The thread is taken from the QThreadPool pool.
- run
 
 public static <T, A, B, C, D> QFuture<T> run(QtConcurrent.Callable4<T,A,B,C,D> runnable, A a, B b, C c, D d)
 
 Executes the Callable using the QtConcurrent framework.
- run
 
 public static <T, A, B, C, D> QFuture<T> run(QThreadPool threadPool, QtConcurrent.Callable4<T,A,B,C,D> runnable, A a, B b, C c, D d)
 
 Executes the Callable using the QtConcurrent framework. The thread is taken from the QThreadPool pool.
- run
 
 public static <T, A, B, C, D, E> QFuture<T> run(QtConcurrent.Callable5<T,A,B,C,D,E> runnable, A a, B b, C c, D d, E e)
 
 Executes the Callable using the QtConcurrent framework.
- run
 
 public static <T, A, B, C, D, E> QFuture<T> run(QThreadPool threadPool, QtConcurrent.Callable5<T,A,B,C,D,E> runnable, A a, B b, C c, D d, E e)
 
 Executes the Callable using the QtConcurrent framework. The thread is taken from the QThreadPool pool.
- run
 
 public static <A, B, C, D, E, F> QVoidFuture run(QtConcurrent.Runnable6<A,B,C,D,E,F> runnable, A a, B b, C c, D d, E e, F f)
 
 Executes the Runnable using the QtConcurrent framework.
- run
 
 public static <A, B, C, D, E, F> QVoidFuture run(QThreadPool threadPool, QtConcurrent.Runnable6<A,B,C,D,E,F> runnable, A a, B b, C c, D d, E e, F f)
 
 Executes the Runnable using the QtConcurrent framework. The thread is taken from the QThreadPool pool.
- run
 
 public static <A, B, C, D, E, F, G> QVoidFuture run(QtConcurrent.Runnable7<A,B,C,D,E,F,G> runnable, A a, B b, C c, D d, E e, F f, G g)
 
 Executes the Runnable using the QtConcurrent framework.
- run
 
 public static <A, B, C, D, E, F, G> QVoidFuture run(QThreadPool threadPool, QtConcurrent.Runnable7<A,B,C,D,E,F,G> runnable, A a, B b, C c, D d, E e, F f, G g)
 
 Executes the Runnable using the QtConcurrent framework. The thread is taken from the QThreadPool pool.
- run
 
 public static <A, B, C, D, E, F, G, H> QVoidFuture run(QtConcurrent.Runnable8<A,B,C,D,E,F,G,H> runnable, A a, B b, C c, D d, E e, F f, G g, H h)
 
 Executes the Runnable using the QtConcurrent framework.
- run
 
 public static <A, B, C, D, E, F, G, H> QVoidFuture run(QThreadPool threadPool, QtConcurrent.Runnable8<A,B,C,D,E,F,G,H> runnable, A a, B b, C c, D d, E e, F f, G g, H h)
 
 Executes the Runnable using the QtConcurrent framework. The thread is taken from the QThreadPool pool.
- run
 
 public static <A, B, C, D, E, F, G, H, I> QVoidFuture run(QtConcurrent.Runnable9<A,B,C,D,E,F,G,H,I> runnable, A a, B b, C c, D d, E e, F f, G g, H h, I i)
 
 Executes the Runnable using the QtConcurrent framework.
- run
 
 public static <A, B, C, D, E, F, G, H, I> QVoidFuture run(QThreadPool threadPool, QtConcurrent.Runnable9<A,B,C,D,E,F,G,H,I> runnable, A a, B b, C c, D d, E e, F f, G g, H h, I i)
 
 Executes the Runnable using the QtConcurrent framework. The thread is taken from the QThreadPool pool.
- run
 
 public static <T, A, B, C, D, E, F> QFuture<T> run(QtConcurrent.Callable6<T,A,B,C,D,E,F> runnable, A a, B b, C c, D d, E e, F f)
 
 Executes the Callable using the QtConcurrent framework.
- run
 
 public static <T, A, B, C, D, E, F> QFuture<T> run(QThreadPool threadPool, QtConcurrent.Callable6<T,A,B,C,D,E,F> runnable, A a, B b, C c, D d, E e, F f)
 
 Executes the Callable using the QtConcurrent framework. The thread is taken from the QThreadPool pool.
- run
 
 public static <T, A, B, C, D, E, F, G> QFuture<T> run(QtConcurrent.Callable7<T,A,B,C,D,E,F,G> runnable, A a, B b, C c, D d, E e, F f, G g)
 
 Executes the Callable using the QtConcurrent framework.
- run
 
 public static <T, A, B, C, D, E, F, G> QFuture<T> run(QThreadPool threadPool, QtConcurrent.Callable7<T,A,B,C,D,E,F,G> runnable, A a, B b, C c, D d, E e, F f, G g)
 
 Executes the Callable using the QtConcurrent framework. The thread is taken from the QThreadPool pool.
- run
 
 public static <T, A, B, C, D, E, F, G, H> QFuture<T> run(QtConcurrent.Callable8<T,A,B,C,D,E,F,G,H> runnable, A a, B b, C c, D d, E e, F f, G g, H h)
 
 Executes the Callable using the QtConcurrent framework.
- run
 
 public static <T, A, B, C, D, E, F, G, H> QFuture<T> run(QThreadPool threadPool, QtConcurrent.Callable8<T,A,B,C,D,E,F,G,H> runnable, A a, B b, C c, D d, E e, F f, G g, H h)
 
 Executes the Callable using the QtConcurrent framework. The thread is taken from the QThreadPool pool.
- run
 
 public static <T, A, B, C, D, E, F, G, H, I> QFuture<T> run(QtConcurrent.Callable9<T,A,B,C,D,E,F,G,H,I> runnable, A a, B b, C c, D d, E e, F f, G g, H h, I i)
 
 Executes the Callable using the QtConcurrent framework.
- run
 
 public static <T, A, B, C, D, E, F, G, H, I> QFuture<T> run(QThreadPool threadPool, QtConcurrent.Callable9<T,A,B,C,D,E,F,G,H,I> runnable, A a, B b, C c, D d, E e, F f, G g, H h, I i)
 
 Executes the Callable using the QtConcurrent framework. The thread is taken from the QThreadPool pool.
- map
 
 @QtUninvokable public static <T> QVoidFuture map(QThreadPool threadPool, Collection<T> sequence, QtConcurrent.MapFunctor<T> functor)
 
 Calls function once for each item in sequence. The function is passed a reference to the item, so that any modifications done to the item will appear in sequence.
- blockingMap
 
 @QtUninvokable public static <T> void blockingMap(QThreadPool threadPool, Collection<T> sequence, QtConcurrent.MapFunctor<T> functor)
 
 Calls function once for each item in sequence. The function is passed a reference to the item, so that any modifications done to the item will appear in sequence.
- mapped
 
 @QtUninvokable public static <U, T> QFuture mapped(QThreadPool threadPool, Collection<T> sequence, QtConcurrent.MappedFunctor<U,T> functor)
 
 Calls function once for each item in sequence and returns a future with each mapped item as a result. You can QFutureIterator to iterate through the results.
- blockingMapped
 
 @QtUninvokable public static <U, T> List blockingMapped(QThreadPool threadPool, Collection<T> sequence, QtConcurrent.MappedFunctor<U,T> functor)
 
 Calls function once for each item in sequence and returns a future with each mapped item as a result. You can QFutureIterator to iterate through the results.
- mappedReduced
 
 @QtUninvokable public static <U, V, T> QFuture mappedReduced(QThreadPool threadPool, Collection<T> sequence, QtConcurrent.MappedFunctor<V,T> functor, QtConcurrent.ReducedFunctor<U,V> reducedFunctor)
 
 This is an overloaded method provided for convenience.
 It is equivalent of mappedReduced(sequence, functor, reducedFunctor, ReduceOption.UnorderedReduce, ReduceOption.SequentialReduce)
- mappedReduced
 
 @QtUninvokable public static <U, V, T> QFuture mappedReduced(QThreadPool threadPool, Collection<T> sequence, QtConcurrent.MappedFunctor<V,T> functor, QtConcurrent.ReducedFunctor<U,V> reducedFunctor, QtConcurrent.ReduceOption... options)
 
 This is an overloaded method provided for convenience.
 Note that while mapFunction is called concurrently, only one thread at a time will call reduceFunction. The order in which reduceFunction is called is determined by reduceOptions.
- mappedReduced
 
 @QtUninvokable public static <U, V, T> QFuture mappedReduced(QThreadPool threadPool, Collection<T> sequence, QtConcurrent.MappedFunctor<V,T> functor, QtConcurrent.ReducedFunctor<U,V> reducedFunctor, QtConcurrent.ReduceOptions options)
 
 Calls mapFunction once for each item in sequence. The return value of each mapFunction is passed to reduceFunction.
 Note that while mapFunction is called concurrently, only one thread at a time will call reduceFunction. The order in which reduceFunction is called is determined by reduceOptions.
- blockingMappedReduced
 
 @QtUninvokable public static <U, V, T> U blockingMappedReduced(QThreadPool threadPool, Collection<T> sequence, QtConcurrent.MappedFunctor<V,T> functor, QtConcurrent.ReducedFunctor<U,V> reducedFunctor)
 
 This is an overloaded method provided for convenience.
 It is equivalent of calling blockingMappedReduced(sequence, functor, reducedFunctor, ReduceOption.UnorderedReduce, ReduceOption.SequentialReduce)
- blockingMappedReduced
 
 @QtUninvokable public static <U, V, T> U blockingMappedReduced(QThreadPool threadPool, Collection<T> sequence, QtConcurrent.MappedFunctor<V,T> functor, QtConcurrent.ReducedFunctor<U,V> reducedFunctor, QtConcurrent.ReduceOption... options)
 
 Calls mapFunction once for each item in sequence. The return value of each mapFunction is passed to reduceFunction.
 Note that while mapFunction is called concurrently, only one thread at a time will call reduceFunction. The order in which reduceFunction is called is determined by reduceOptions.
 Note: This function will block until all items in the sequence have been processed.
- blockingMappedReduced
 
 @QtUninvokable public static <U, V, T> U blockingMappedReduced(QThreadPool threadPool, Collection<T> sequence, QtConcurrent.MappedFunctor<V,T> functor, QtConcurrent.ReducedFunctor<U,V> reducedFunctor, QtConcurrent.ReduceOptions options)
 
 Calls mapFunction once for each item in sequence. The return value of each mapFunction is passed to reduceFunction.
 Note that while mapFunction is called concurrently, only one thread at a time will call reduceFunction. The order in which reduceFunction is called is determined by reduceOptions.
 Note: This function will block until all items in the sequence have been processed.
- filter
 
 @QtUninvokable public static <T> QVoidFuture filter(QThreadPool threadPool, Collection<T> sequence, QtConcurrent.FilteredFunctor<T> filteredFunctor)
 
 Calls filterFunctor's filter() method once for each item in sequence and returns a new Sequence of kept items. If filterFunction returns true, a copy of the item is put in the new Sequence. Otherwise, the item will not appear in the new Sequence.
- filtered
 
 @QtUninvokable public static <T> QFuture<T> filtered(QThreadPool threadPool, Collection<T> sequence, QtConcurrent.FilteredFunctor<T> filteredFunctor)
 
 Calls filterFunctor's filter() method once for each item in sequence and returns a new Sequence of kept items. If filterFunction returns true, a copy of the item is put in the new Sequence. Otherwise, the item will not appear in the new Sequence.
- blockingFiltered
 
 @QtUninvokable public static <T> List<T> blockingFiltered(QThreadPool threadPool, Collection<T> sequence, QtConcurrent.FilteredFunctor<T> filteredFunctor)
 
 Calls filterFunctor's filter() method once for each item in sequence and returns a new Sequence of kept items. If filterFunction returns true, a copy of the item is put in the new Sequence. Otherwise, the item will not appear in the new Sequence.
- blockingFilter
 
 @QtUninvokable public static <T> void blockingFilter(QThreadPool threadPool, Collection<T> sequence, QtConcurrent.FilteredFunctor<T> filteredFunctor)
 
 Calls filterFunction once for each item in sequence. If filterFunction returns true, the item is kept in sequence; otherwise, the item is removed from sequence. Note: This function will block until all items in the sequence have been processed.
- filteredReduced
 
 @QtUninvokable public static <U, T> QFuture filteredReduced(QThreadPool threadPool, Collection<T> sequence, QtConcurrent.FilteredFunctor<T> filteredFunctor, QtConcurrent.ReducedFunctor<U,T> reducedFunctor)
 
 This is an overloaded method provided for convenience. It is equivalent of calling filteredReduced(sequence, filteredFunctor, ReduceOption.UnorderedReduce, ReduceOption.Seq This is an overloaded method provided for convenience. It is equivalent of calling filteredReduced)
- filteredReduced
 
 @QtUninvokable public static <U, T> QFuture filteredReduced(QThreadPool threadPool, Collection<T> sequence, QtConcurrent.FilteredFunctor<T> filteredFunctor, QtConcurrent.ReducedFunctor<U,T> reducedFunctor, QtConcurrent.ReduceOption... options)
 
 Calls filterFunction once for each item in sequence. If filterFunction returns true for an item, that item is then passed to reduceFunction. In other words, the return value is the result of reduceFunction for each item where filterFunction returns true.
 Note that while filterFunction is called concurrently, only one thread at a time will call reduceFunction. The order in which reduceFunction is called is undefined if reduceOptions is QtConcurrent::UnorderedReduce. If reduceOptions is QtConcurrent::OrderedReduce, reduceFunction is called in the order of the original sequence.
- filteredReduced
 
 @QtUninvokable public static <U, T> QFuture filteredReduced(QThreadPool threadPool, Collection<T> sequence, QtConcurrent.FilteredFunctor<T> filteredFunctor, QtConcurrent.ReducedFunctor<U,T> reducedFunctor, QtConcurrent.ReduceOptions options)
 
 Calls filterFunction once for each item in sequence. If filterFunction returns true for an item, that item is then passed to reduceFunction. In other words, the return value is the result of reduceFunction for each item where filterFunction returns true.
 Note that while filterFunction is called concurrently, only one thread at a time will call reduceFunction. The order in which reduceFunction is called is undefined if reduceOptions is QtConcurrent::UnorderedReduce. If reduceOptions is QtConcurrent::OrderedReduce, reduceFunction is called in the order of the original sequence.
- blockingFilteredReduced
 
 @QtUninvokable public static <U, T> U blockingFilteredReduced(QThreadPool threadPool, Collection<T> sequence, QtConcurrent.FilteredFunctor<T> filteredFunctor, QtConcurrent.ReducedFunctor<U,T> reducedFunctor)
 
 This is an overloaded method provided for convenience. It is the equivalent of calling blockingFilteredReduced(sequence, filteredFunctor, reducedFunctor, ReduceOption.UnorderedReduce, ReduceOption.SequentialReduce)
- blockingFilteredReduced
 
 @QtUninvokable public static <U, T> U blockingFilteredReduced(QThreadPool threadPool, Collection<T> sequence, QtConcurrent.FilteredFunctor<T> filteredFunctor, QtConcurrent.ReducedFunctor<U,T> reducedFunctor, QtConcurrent.ReduceOption... options)
 
 Calls filterFunction once for each item in sequence. If filterFunction returns true for an item, that item is then passed to reduceFunction. In other words, the return value is the result of reduceFunction for each item where filterFunction returns true.
 Note that while filterFunction is called concurrently, only one thread at a time will call reduceFunction. The order in which reduceFunction is called is undefined if reduceOptions is QtConcurrent::UnorderedReduce. If reduceOptions is QtConcurrent::OrderedReduce, reduceFunction is called in the order of the original sequence.
- blockingFilteredReduced
 
 @QtUninvokable public static <U, T> U blockingFilteredReduced(QThreadPool threadPool, Collection<T> sequence, QtConcurrent.FilteredFunctor<T> filteredFunctor, QtConcurrent.ReducedFunctor<U,T> reducedFunctor, QtConcurrent.ReduceOptions options)
 
 Calls filterFunction once for each item in sequence. If filterFunction returns true for an item, that item is then passed to reduceFunction. In other words, the return value is the result of reduceFunction for each item where filterFunction returns true.
 Note that while filterFunction is called concurrently, only one thread at a time will call reduceFunction. The order in which reduceFunction is called is undefined if reduceOptions is QtConcurrent::UnorderedReduce. If reduceOptions is QtConcurrent::OrderedReduce, reduceFunction is called in the order of the original sequence.
- run
 
 public static <T> QFuture<T> run(QtConcurrent.RunnableWithPromise<T> runnable)
 
 Executes the Callable using the QtConcurrent framework.
- run
 
 public static <T> QFuture<T> run(QThreadPool threadPool, QtConcurrent.RunnableWithPromise<T> runnable)
 
 Executes the Callable using the QtConcurrent framework. The thread is taken from the QThreadPool pool.
- run
 
 public static <T, A> QFuture<T> run(QtConcurrent.RunnableWithPromise1<T,A> runnable, A a)
 
 Executes the Callable using the QtConcurrent framework.
- run
 
 public static <T, A> QFuture<T> run(QThreadPool threadPool, QtConcurrent.RunnableWithPromise1<T,A> runnable, A a)
 
 Executes the Callable using the QtConcurrent framework. The thread is taken from the QThreadPool pool.
- run
 
 public static <T, A, B> QFuture<T> run(QtConcurrent.RunnableWithPromise2<T,A,B> runnable, A a, B b)
 
 Executes the Callable using the QtConcurrent framework.
- run
 
 public static <T, A, B> QFuture<T> run(QThreadPool threadPool, QtConcurrent.RunnableWithPromise2<T,A,B> runnable, A a, B b)
 
 Executes the Callable using the QtConcurrent framework. The thread is taken from the QThreadPool pool.
- run
 
 public static <T, A, B, C> QFuture<T> run(QtConcurrent.RunnableWithPromise3<T,A,B,C> runnable, A a, B b, C c)
 
 Executes the Callable using the QtConcurrent framework.
- run
 
 public static <T, A, B, C> QFuture<T> run(QThreadPool threadPool, QtConcurrent.RunnableWithPromise3<T,A,B,C> runnable, A a, B b, C c)
 
 Executes the Callable using the QtConcurrent framework. The thread is taken from the QThreadPool pool.
- run
 
 public static <T, A, B, C, D> QFuture<T> run(QtConcurrent.RunnableWithPromise4<T,A,B,C,D> runnable, A a, B b, C c, D d)
 
 Executes the Callable using the QtConcurrent framework.
- run
 
 public static <T, A, B, C, D> QFuture<T> run(QThreadPool threadPool, QtConcurrent.RunnableWithPromise4<T,A,B,C,D> runnable, A a, B b, C c, D d)
 
 Executes the Callable using the QtConcurrent framework. The thread is taken from the QThreadPool pool.
- run
 
 public static <T, A, B, C, D, E> QFuture<T> run(QtConcurrent.RunnableWithPromise5<T,A,B,C,D,E> runnable, A a, B b, C c, D d, E e)
 
 Executes the Callable using the QtConcurrent framework.
- run
 
 public static <T, A, B, C, D, E> QFuture<T> run(QThreadPool threadPool, QtConcurrent.RunnableWithPromise5<T,A,B,C,D,E> runnable, A a, B b, C c, D d, E e)
 
 Executes the Callable using the QtConcurrent framework. The thread is taken from the QThreadPool pool.
- run
 
 public static <T, A, B, C, D, E, F> QFuture<T> run(QtConcurrent.RunnableWithPromise6<T,A,B,C,D,E,F> runnable, A a, B b, C c, D d, E e, F f)
 
 Executes the Callable using the QtConcurrent framework.
- run
 
 public static <T, A, B, C, D, E, F> QFuture<T> run(QThreadPool threadPool, QtConcurrent.RunnableWithPromise6<T,A,B,C,D,E,F> runnable, A a, B b, C c, D d, E e, F f)
 
 Executes the Callable using the QtConcurrent framework. The thread is taken from the QThreadPool pool.
- run
 
 public static <T, A, B, C, D, E, F, G> QFuture<T> run(QtConcurrent.RunnableWithPromise7<T,A,B,C,D,E,F,G> runnable, A a, B b, C c, D d, E e, F f, G g)
 
 Executes the RunnableWithPromise using the QtConcurrent framework.
- run
 
 public static <T, A, B, C, D, E, F, G> QFuture<T> run(QThreadPool threadPool, QtConcurrent.RunnableWithPromise7<T,A,B,C,D,E,F,G> runnable, A a, B b, C c, D d, E e, F f, G g)
 
 Executes the Callable using the QtConcurrent framework. The thread is taken from the QThreadPool pool.
- run
 
 public static <T, A, B, C, D, E, F, G, H> QFuture<T> run(QtConcurrent.RunnableWithPromise8<T,A,B,C,D,E,F,G,H> runnable, A a, B b, C c, D d, E e, F f, G g, H h)
 
 Executes the Callable using the QtConcurrent framework.
- run
 
 public static <T, A, B, C, D, E, F, G, H> QFuture<T> run(QThreadPool threadPool, QtConcurrent.RunnableWithPromise8<T,A,B,C,D,E,F,G,H> runnable, A a, B b, C c, D d, E e, F f, G g, H h)
 
 Executes the Callable using the QtConcurrent framework. The thread is taken from the QThreadPool pool.
- run
 
 public static <T, A, B, C, D, E, F, G, H, I> QFuture<T> run(QtConcurrent.RunnableWithPromise9<T,A,B,C,D,E,F,G,H,I> runnable, A a, B b, C c, D d, E e, F f, G g, H h, I i)
 
 Executes the Callable using the QtConcurrent framework.
- run
 
 public static <T, A, B, C, D, E, F, G, H, I> QFuture<T> run(QThreadPool threadPool, QtConcurrent.RunnableWithPromise9<T,A,B,C,D,E,F,G,H,I> runnable, A a, B b, C c, D d, E e, F f, G g, H h, I i)
 
 Executes the Callable using the QtConcurrent framework. The thread is taken from the QThreadPool pool.
- run
 
 public static QVoidFuture run(QtConcurrent.RunnableWithVoidPromise runnable)
 
 Executes the Runnable using the QtConcurrent framework.
- run
 
 public static QVoidFuture run(QThreadPool threadPool, QtConcurrent.RunnableWithVoidPromise runnable)
 
 Executes the Runnable using the QtConcurrent framework. The thread is taken from the QThreadPool pool.
- run
 
 public static <A> QVoidFuture run(QtConcurrent.RunnableWithVoidPromise1<A> runnable, A a)
 
 Executes the Runnable using the QtConcurrent framework.
- run
 
 public static <A> QVoidFuture run(QThreadPool threadPool, QtConcurrent.RunnableWithVoidPromise1<A> runnable, A a)
 
 Executes the Runnable using the QtConcurrent framework. The thread is taken from the QThreadPool pool.
- run
 
 public static <A, B> QVoidFuture run(QtConcurrent.RunnableWithVoidPromise2<A,B> runnable, A a, B b)
 
 Executes the Runnable using the QtConcurrent framework.
- run
 
 public static <A, B> QVoidFuture run(QThreadPool threadPool, QtConcurrent.RunnableWithVoidPromise2<A,B> runnable, A a, B b)
 
 Executes the Runnable using the QtConcurrent framework. The thread is taken from the QThreadPool pool.
- run
 
 public static <A, B, C> QVoidFuture run(QtConcurrent.RunnableWithVoidPromise3<A,B,C> runnable, A a, B b, C c)
 
 Executes the Runnable using the QtConcurrent framework.
- run
 
 public static <A, B, C> QVoidFuture run(QThreadPool threadPool, QtConcurrent.RunnableWithVoidPromise3<A,B,C> runnable, A a, B b, C c)
 
 Executes the Runnable using the QtConcurrent framework. The thread is taken from the QThreadPool pool.
- run
 
 public static <A, B, C, D> QVoidFuture run(QtConcurrent.RunnableWithVoidPromise4<A,B,C,D> runnable, A a, B b, C c, D d)
 
 Executes the Runnable using the QtConcurrent framework.
- run
 
 public static <A, B, C, D> QVoidFuture run(QThreadPool threadPool, QtConcurrent.RunnableWithVoidPromise4<A,B,C,D> runnable, A a, B b, C c, D d)
 
 Executes the Runnable using the QtConcurrent framework. The thread is taken from the QThreadPool pool.
- run
 
 public static <A, B, C, D, E> QVoidFuture run(QtConcurrent.RunnableWithVoidPromise5<A,B,C,D,E> runnable, A a, B b, C c, D d, E e)
 
 Executes the Runnable using the QtConcurrent framework.
- run
 
 public static <A, B, C, D, E> QVoidFuture run(QThreadPool threadPool, QtConcurrent.RunnableWithVoidPromise5<A,B,C,D,E> runnable, A a, B b, C c, D d, E e)
 
 Executes the Runnable using the QtConcurrent framework. The thread is taken from the QThreadPool pool.
- run
 
 public static <A, B, C, D, E, F> QVoidFuture run(QtConcurrent.RunnableWithVoidPromise6<A,B,C,D,E,F> runnable, A a, B b, C c, D d, E e, F f)
 
 Executes the Runnable using the QtConcurrent framework.
- run
 
 public static <A, B, C, D, E, F> QVoidFuture run(QThreadPool threadPool, QtConcurrent.RunnableWithVoidPromise6<A,B,C,D,E,F> runnable, A a, B b, C c, D d, E e, F f)
 
 Executes the Runnable using the QtConcurrent framework. The thread is taken from the QThreadPool pool.
- run
 
 public static <A, B, C, D, E, F, G> QVoidFuture run(QtConcurrent.RunnableWithVoidPromise7<A,B,C,D,E,F,G> runnable, A a, B b, C c, D d, E e, F f, G g)
 
 Executes the Runnable using the QtConcurrent framework.
- run
 
 public static <A, B, C, D, E, F, G> QVoidFuture run(QThreadPool threadPool, QtConcurrent.RunnableWithVoidPromise7<A,B,C,D,E,F,G> runnable, A a, B b, C c, D d, E e, F f, G g)
 
 Executes the Runnable using the QtConcurrent framework. The thread is taken from the QThreadPool pool.
- run
 
 public static <A, B, C, D, E, F, G, H> QVoidFuture run(QtConcurrent.RunnableWithVoidPromise8<A,B,C,D,E,F,G,H> runnable, A a, B b, C c, D d, E e, F f, G g, H h)
 
 Executes the Runnable using the QtConcurrent framework.
- run
 
 public static <A, B, C, D, E, F, G, H> QVoidFuture run(QThreadPool threadPool, QtConcurrent.RunnableWithVoidPromise8<A,B,C,D,E,F,G,H> runnable, A a, B b, C c, D d, E e, F f, G g, H h)
 
 Executes the Runnable using the QtConcurrent framework. The thread is taken from the QThreadPool pool.
- run
 
 public static <A, B, C, D, E, F, G, H, I> QVoidFuture run(QtConcurrent.RunnableWithVoidPromise9<A,B,C,D,E,F,G,H,I> runnable, A a, B b, C c, D d, E e, F f, G g, H h, I i)
 
 Executes the Runnable using the QtConcurrent framework.
- run
 
 public static <A, B, C, D, E, F, G, H, I> QVoidFuture run(QThreadPool threadPool, QtConcurrent.RunnableWithVoidPromise9<A,B,C,D,E,F,G,H,I> runnable, A a, B b, C c, D d, E e, F f, G g, H h, I i)
 
 Executes the Runnable using the QtConcurrent framework. The thread is taken from the QThreadPool pool.
- task
 
 public static QtConcurrent.QTaskBuilderVoid0Arg0 task(Runnable runnable)
- task
 
 public static <A> QtConcurrent.QTaskBuilderVoid1Arg0<A> task(QtConcurrent.Runnable1<A> runnable)
- task
 
 public static <A, B> QtConcurrent.QTaskBuilderVoid2Arg0<A,B> task(QtConcurrent.Runnable2<A,B> runnable)
- task
 
 public static <A, B, C> QtConcurrent.QTaskBuilderVoid3Arg0<A,B,C> task(QtConcurrent.Runnable3<A,B,C> runnable)
- task
 
 public static <A, B, C, D> QtConcurrent.QTaskBuilderVoid4Arg0<A,B,C,D> task(QtConcurrent.Runnable4<A,B,C,D> runnable)
- task
 
 public static <A, B, C, D, E> QtConcurrent.QTaskBuilderVoid5Arg0<A,B,C,D,E> task(QtConcurrent.Runnable5<A,B,C,D,E> runnable)
- task
 
 public static <A, B, C, D, E, F> QtConcurrent.QTaskBuilderVoid6Arg0<A,B,C,D,E,F> task(QtConcurrent.Runnable6<A,B,C,D,E,F> runnable)
- task
 
 public static <A, B, C, D, E, F, G> QtConcurrent.QTaskBuilderVoid7Arg0<A,B,C,D,E,F,G> task(QtConcurrent.Runnable7<A,B,C,D,E,F,G> runnable)
- task
 
 public static <A, B, C, D, E, F, G, H> QtConcurrent.QTaskBuilderVoid8Arg0<A,B,C,D,E,F,G,H> task(QtConcurrent.Runnable8<A,B,C,D,E,F,G,H> runnable)
- task
 
 public static <A, B, C, D, E, F, G, H, I> QtConcurrent.QTaskBuilderVoid9Arg0<A,B,C,D,E,F,G,H,I> task(QtConcurrent.Runnable9<A,B,C,D,E,F,G,H,I> runnable)
- task
 
 public static <T> QtConcurrent.QTypedTaskBuilder0Arg0<T> task(Callable<T> callable)
- task
 
 public static <T, A> QtConcurrent.QTypedTaskBuilder1Arg0<T,A> task(QtConcurrent.Callable1<T,A> callable)
- task
 
 public static <T, A, B> QtConcurrent.QTypedTaskBuilder2Arg0<T,A,B> task(QtConcurrent.Callable2<T,A,B> callable)
- task
 
 public static <T, A, B, C> QtConcurrent.QTypedTaskBuilder3Arg0<T,A,B,C> task(QtConcurrent.Callable3<T,A,B,C> callable)
- task
 
 public static <T, A, B, C, D> QtConcurrent.QTypedTaskBuilder4Arg0<T,A,B,C,D> task(QtConcurrent.Callable4<T,A,B,C,D> callable)
- task
 
 public static <T, A, B, C, D, E> QtConcurrent.QTypedTaskBuilder5Arg0<T,A,B,C,D,E> task(QtConcurrent.Callable5<T,A,B,C,D,E> callable)
- task
 
 public static <T, A, B, C, D, E, F> QtConcurrent.QTypedTaskBuilder6Arg0<T,A,B,C,D,E,F> task(QtConcurrent.Callable6<T,A,B,C,D,E,F> callable)
- task
 
 public static <T, A, B, C, D, E, F, G> QtConcurrent.QTypedTaskBuilder7Arg0<T,A,B,C,D,E,F,G> task(QtConcurrent.Callable7<T,A,B,C,D,E,F,G> callable)
- task
 
 public static <T, A, B, C, D, E, F, G, H> QtConcurrent.QTypedTaskBuilder8Arg0<T,A,B,C,D,E,F,G,H> task(QtConcurrent.Callable8<T,A,B,C,D,E,F,G,H> callable)
- task
 
 public static <T, A, B, C, D, E, F, G, H, I> QtConcurrent.QTypedTaskBuilder9Arg0<T,A,B,C,D,E,F,G,H,I> task(QtConcurrent.Callable9<T,A,B,C,D,E,F,G,H,I> callable)
- task
 
 public static QtConcurrent.QPromiseTaskBuilderVoid0Arg0 task(QtConcurrent.RunnableWithVoidPromise runnable)
- task
 
 public static <A> QtConcurrent.QPromiseTaskBuilderVoid1Arg0<A> task(QtConcurrent.RunnableWithVoidPromise1<A> runnable)
- task
 
 public static <A, B> QtConcurrent.QPromiseTaskBuilderVoid2Arg0<A,B> task(QtConcurrent.RunnableWithVoidPromise2<A,B> runnable)
- task
 
 public static <A, B, C> QtConcurrent.QPromiseTaskBuilderVoid3Arg0<A,B,C> task(QtConcurrent.RunnableWithVoidPromise3<A,B,C> runnable)
- task
 
 public static <A, B, C, D> QtConcurrent.QPromiseTaskBuilderVoid4Arg0<A,B,C,D> task(QtConcurrent.RunnableWithVoidPromise4<A,B,C,D> runnable)
- task
 
 public static <A, B, C, D, E> QtConcurrent.QPromiseTaskBuilderVoid5Arg0<A,B,C,D,E> task(QtConcurrent.RunnableWithVoidPromise5<A,B,C,D,E> runnable)
- task
 
 public static <A, B, C, D, E, F> QtConcurrent.QPromiseTaskBuilderVoid6Arg0<A,B,C,D,E,F> task(QtConcurrent.RunnableWithVoidPromise6<A,B,C,D,E,F> runnable)
- task
 
 public static <A, B, C, D, E, F, G> QtConcurrent.QPromiseTaskBuilderVoid7Arg0<A,B,C,D,E,F,G> task(QtConcurrent.RunnableWithVoidPromise7<A,B,C,D,E,F,G> runnable)
- task
 
 public static <A, B, C, D, E, F, G, H> QtConcurrent.QPromiseTaskBuilderVoid8Arg0<A,B,C,D,E,F,G,H> task(QtConcurrent.RunnableWithVoidPromise8<A,B,C,D,E,F,G,H> runnable)
- task
 
 public static <A, B, C, D, E, F, G, H, I> QtConcurrent.QPromiseTaskBuilderVoid9Arg0<A,B,C,D,E,F,G,H,I> task(QtConcurrent.RunnableWithVoidPromise9<A,B,C,D,E,F,G,H,I> runnable)
- task
 
 public static <T> QtConcurrent.QTypedPromiseTaskBuilder0Arg0<T> task(QtConcurrent.RunnableWithPromise<T> callable)
- task
 
 public static <T, A> QtConcurrent.QTypedPromiseTaskBuilder1Arg0<T,A> task(QtConcurrent.RunnableWithPromise1<T,A> runnable)
- task
 
 public static <T, A, B> QtConcurrent.QTypedPromiseTaskBuilder2Arg0<T,A,B> task(QtConcurrent.RunnableWithPromise2<T,A,B> runnable)
- task
 
 public static <T, A, B, C> QtConcurrent.QTypedPromiseTaskBuilder3Arg0<T,A,B,C> task(QtConcurrent.RunnableWithPromise3<T,A,B,C> runnable)
- task
 
 public static <T, A, B, C, D> QtConcurrent.QTypedPromiseTaskBuilder4Arg0<T,A,B,C,D> task(QtConcurrent.RunnableWithPromise4<T,A,B,C,D> runnable)
- task
 
 public static <T, A, B, C, D, E> QtConcurrent.QTypedPromiseTaskBuilder5Arg0<T,A,B,C,D,E> task(QtConcurrent.RunnableWithPromise5<T,A,B,C,D,E> runnable)
- task
 
 public static <T, A, B, C, D, E, F> QtConcurrent.QTypedPromiseTaskBuilder6Arg0<T,A,B,C,D,E,F> task(QtConcurrent.RunnableWithPromise6<T,A,B,C,D,E,F> runnable)
- task
 
 public static <T, A, B, C, D, E, F, G> QtConcurrent.QTypedPromiseTaskBuilder7Arg0<T,A,B,C,D,E,F,G> task(QtConcurrent.RunnableWithPromise7<T,A,B,C,D,E,F,G> runnable)
- task
 
 public static <T, A, B, C, D, E, F, G, H> QtConcurrent.QTypedPromiseTaskBuilder8Arg0<T,A,B,C,D,E,F,G,H> task(QtConcurrent.RunnableWithPromise8<T,A,B,C,D,E,F,G,H> runnable)
- task
 
 public static <T, A, B, C, D, E, F, G, H, I> QtConcurrent.QTypedPromiseTaskBuilder9Arg0<T,A,B,C,D,E,F,G,H,I> task(QtConcurrent.RunnableWithPromise9<T,A,B,C,D,E,F,G,H,I> runnable)

Class QtConcurrent

Nested Class Summary

Method Summary

Methods inherited from class java.lang.Object

Method Details