QtPrivate Namespace Reference

Namespaces
namespace	_testing
namespace	BindableWarnings
namespace	DateTimeConstants
namespace	detail
namespace	Hijri
namespace	Invoke
namespace	Jalali
namespace	PropertyAdaptorSlotObjectHelpers
namespace	QCheckedIntegers
namespace	QMetaTypeCopyTraits
namespace	QRoundImpl
namespace	Roman
namespace	Tok
namespace	TypeNameHelper

Classes
struct	AlignedQArrayData
struct	AreArgumentsCompatible
struct	AreArgumentsCompatible< A &, A & >
struct	AreArgumentsCompatible< A, void >
struct	AreArgumentsCompatible< A1, A2 & >
struct	AreArgumentsCompatible< void, A >
struct	AreArgumentsCompatible< void, void >
struct	AreArgumentsConvertibleWithoutNarrowingBase
struct	AreArgumentsConvertibleWithoutNarrowingBase< From, To, std::enable_if_t< std::disjunction_v< std::is_same< From, To >, IsConvertibleWithoutNarrowing< From, To > > > >
struct	AreFunctionsCompatible
struct	AreFunctionsCompatible< Prototype, Functor, std::enable_if_t< std::is_same_v< decltype(QtPrivate::makeCallableObject< Prototype >(std::forward< Functor >(std::declval< Functor >()))), QtPrivate::QSlotObjectBase * > > >
struct	ArgBase
struct	ArgResolver
struct	ArgResolver< R(&)(Args...)>
struct	ArgResolver< R(*&)(Args...)>
struct	ArgResolver< R(*)(Args...)>
struct	ArgResolver< R(*const)(Args...)>
struct	ArgResolver< R(Args...)>
struct	ArgResolver< R(Class::*)(Args...) const >
struct	ArgResolver< R(Class::*)(Args...) const noexcept >
struct	ArgResolver< R(Class::*)(Args...) noexcept >
struct	ArgResolver< R(Class::*)(Args...)>
struct	ArgResolver< R(Class::*const)(Args...) const >
struct	ArgResolver< R(Class::*const)(Args...) const noexcept >
struct	ArgResolver< std::reference_wrapper< F > >
struct	ArgsType
struct	ArgsType< Arg, Args... >
struct	ArgsType< QPromise< Arg > &, Args... >
struct	ArgsType<>
struct	Argument
struct	Argument< Iterator, typename std::enable_if< IsDereferenceableValue< Iterator > >::type >
struct	Argument< Sequence, typename std::enable_if< IsIterableValue< Sequence > >::type >
struct	ArrayTypeHelper
struct	ArrayTypeHelper< void, Types... >
struct	ArrowProxy
struct	AssociativeContainerTransformationHelper
struct	AssociativeContainerTransformationHelper< T, true >
struct	AssociativeKeyTypeIsMetaType
struct	AssociativeKeyTypeIsMetaType< T, true >
struct	AssociativeMappedTypeIsMetaType
struct	AssociativeValueTypeIsMetaType
struct	AudioSampleFormatHelper
struct	AudioSampleFormatHelper< QAudioFormat::Float >
struct	AudioSampleFormatHelper< QAudioFormat::Int16 >
struct	AudioSampleFormatHelper< QAudioFormat::Int32 >
struct	AudioSampleFormatHelper< QAudioFormat::UInt8 >
struct	BindingEvaluationState
struct	BindingFunctionVTable
class	BindingStatusOrList
class	BoolList
struct	BuiltinMetaType
struct	BuiltinMetaType< T, std::enable_if_t< QMetaTypeId2< T >::IsBuiltIn > >
struct	Callable
struct	Callable< Func, List< Args... > >
struct	CallableHelper
class	CanceledHandler
struct	CheckCompatibleArguments
struct	CheckCompatibleArguments< List1, List<> >
struct	CheckCompatibleArguments< List< Arg1, Tail1... >, List< Arg2, Tail2... > >
struct	CheckCompatibleArguments< List<>, List<> >
class	CompactContinuation
class	CompareAgainstLiteralZero
struct	CompatPropertySafePoint
struct	ComputeFunctorArgumentCount
struct	ComputeFunctorArgumentCount< Functor, List< ArgList... > >
struct	ComputeFunctorArgumentCountHelper
struct	ComputeFunctorArgumentCountHelper< Functor, List< First, ArgList... >, false >
struct	ConnectionTypes
struct	ConnectionTypes< List< Args... >, true >
struct	ConnectionTypes< List<>, true >
struct	ContextTypeForFunctor
struct	ContextTypeForFunctor< Func, std::enable_if_t< std::conjunction_v< std::negation< std::is_convertible< Func, const char * > >, std::is_member_function_pointer< Func >, std::is_convertible< typename QtPrivate::FunctionPointer< Func >::Object *, QObject * > > > >
struct	ContextTypeForFunctor< Func, std::enable_if_t<!std::disjunction_v< std::is_convertible< Func, const char * >, std::is_member_function_pointer< Func > > > >
struct	ContinuationWrapper
struct	CurrentCompatPropertyThief
class	EffectSlotMapper
struct	EnableInternalData
struct	EnableInternalDataWrap
struct	EnumHasQEnum
struct	EnumHasQEnum< T, true, false >
struct	EnumHasQFlag
struct	EnumHasQFlag< T, true, true >
class	ExceptionStore
class	FailureHandler
class	FixedColumnMatrix
struct	FunctionPointer
struct	FunctionPointer< Ret(*)(Args...) noexcept >
struct	FunctionPointer< Ret(*)(Args...)>
struct	FunctionPointer< Ret(Obj::*)(Args...) const >
struct	FunctionPointer< Ret(Obj::*)(Args...) const noexcept >
struct	FunctionPointer< Ret(Obj::*)(Args...) noexcept >
struct	FunctionPointer< Ret(Obj::*)(Args...)>
struct	FunctorCall
struct	FunctorCall< std::index_sequence< II... >, List< SignalArgs... >, R, Function >
struct	FunctorCall< std::index_sequence< II... >, List< SignalArgs... >, R, SlotRet(Obj::*)(SlotArgs...) const >
struct	FunctorCall< std::index_sequence< II... >, List< SignalArgs... >, R, SlotRet(Obj::*)(SlotArgs...) const noexcept >
struct	FunctorCall< std::index_sequence< II... >, List< SignalArgs... >, R, SlotRet(Obj::*)(SlotArgs...) noexcept >
struct	FunctorCall< std::index_sequence< II... >, List< SignalArgs... >, R, SlotRet(Obj::*)(SlotArgs...)>
struct	FunctorCallable
struct	FunctorCallBase
struct	FunctorReturnType
struct	FunctorReturnType< Functor, List< ArgList... > >
struct	Future
struct	Future< QFuture< T > >
class	GraphicsView
struct	HasCallOperatorAcceptingArgs
struct	HasQ_OBJECT_Macro
struct	hide_char8_t
struct	is_compatible_utf32_char
struct	is_compatible_utf32_char< char32_t >
struct	is_compatible_utf32_char< wchar_t >
struct	is_complete
struct	is_invoke_result_explicitly_convertible
struct	is_standard_or_extended_integer_type
struct	is_standard_or_extended_integer_type_helper
struct	is_std_pair
struct	is_std_pair< std::pair< T1_, T2_ > >
struct	IsAssociativeContainer
struct	IsCompatibleByteArrayPointer
struct	IsCompatibleByteArrayPointerHelper
struct	IsCompatibleByteArrayPointerHelper< Byte * >
struct	IsCompatibleByteType
struct	IsCompatibleByteTypeHelper
struct	IsCompatibleByteTypeHelper< char >
struct	IsCompatibleByteTypeHelper< signed char >
struct	IsCompatibleByteTypeHelper< std::byte >
struct	IsCompatibleByteTypeHelper< unsigned char >
struct	IsCompatibleCharType
struct	IsCompatibleCharTypeHelper
struct	IsCompatiblePointer
struct	IsCompatiblePointer8Helper
struct	IsCompatiblePointer8Helper< Char * >
struct	IsCompatiblePointerHelper
struct	IsCompatiblePointerHelper< Char * >
struct	IsContainerCompatibleWithModelRoleDataSpan
struct	IsContainerCompatibleWithModelRoleDataSpan< T, std::enable_if_t< std::conjunction_v< std::is_convertible< decltype(std::data(std::declval< T & >())), QModelRoleData * >, std::is_convertible< decltype(std::size(std::declval< T & >())), qsizetype >, std::is_convertible< typename std::iterator_traits< decltype(std::begin(std::declval< T & >()))>::value_type, QModelRoleData >, std::is_convertible< decltype(std::begin(std::declval< T & >()) !=std::end(std::declval< T & >())), bool >, std::negation< std::is_same< std::decay_t< T >, QModelRoleDataSpan > > > > >
struct	IsContainerCompatibleWithQByteArrayView
struct	IsContainerCompatibleWithQByteArrayView< T, std::enable_if_t< std::conjunction_v< IsCompatibleByteArrayPointer< decltype(std::data(std::declval< const T & >()))>, std::is_convertible< decltype(std::size(std::declval< const T & >())), qsizetype >, IsCompatibleByteType< typename std::iterator_traits< decltype(std::begin(std::declval< const T & >()))>::value_type >, std::is_convertible< decltype(std::begin(std::declval< const T & >()) !=std::end(std::declval< const T & >())), bool >, std::negation< std::is_same< std::decay_t< T >, QByteArray > >, std::negation< std::is_array< T > >, std::negation< std::is_same< std::decay_t< T >, QByteArrayView > > > > >
struct	IsContainerCompatibleWithQStringView
struct	IsContainerCompatibleWithQStringView< T, std::enable_if_t< std::conjunction_v< IsCompatiblePointer< decltype(std::data(std::declval< const T & >()))>, std::is_convertible< decltype(std::size(std::declval< const T & >())), qsizetype >, IsCompatibleCharType< typename std::iterator_traits< decltype(std::begin(std::declval< const T & >()))>::value_type >, std::is_convertible< decltype(std::begin(std::declval< const T & >()) !=std::end(std::declval< const T & >())), bool >, std::negation< std::is_same< std::decay_t< T >, QString > >,#define QSTRINGVIEW_REFUSES_QSTRINGREF std::negation< std::is_same< q20::remove_cvref_t< T >, QStringRef > >, std::negation< std::is_same< std::decay_t< T >, QStringView > > > > >
struct	IsContainerCompatibleWithQUtf8StringView
struct	IsContainerCompatibleWithQUtf8StringView< T, std::enable_if_t< std::conjunction_v< IsCompatiblePointer8< decltype(std::data(std::declval< const T & >()))>, std::is_convertible< decltype(std::size(std::declval< const T & >())), qsizetype >, IsCompatibleChar8Type< typename std::iterator_traits< decltype(std::begin(std::declval< const T & >()))>::value_type >, std::is_convertible< decltype(std::begin(std::declval< const T & >()) !=std::end(std::declval< const T & >())), bool >, std::negation< std::is_same< std::decay_t< T >, QByteArray > >, std::negation< std::is_same< std::decay_t< T >, QLatin1StringView > >, std::negation< std::disjunction< std::is_same< std::decay_t< T >, QBasicUtf8StringView< true > >, std::is_same< std::decay_t< T >, QBasicUtf8StringView< false > > > > > > >
struct	IsConvertibleWithoutNarrowing
struct	IsConvertibleWithoutNarrowing< From, To, std::void_t< decltype(NarrowingDetector< To >{ {std::declval< From >()} }) > >
struct	IsDereferenceable
struct	IsDereferenceable< T, std::void_t< decltype(*std::declval< T >())> >
struct	IsEnumOrFlags
struct	IsGadgetHelper
struct	IsGadgetHelper< T, typename T::QtGadgetHelper >
struct	IsIterable
struct	IsIterable< T, std::void_t< decltype(std::declval< T >().begin()), decltype(std::declval< T >().end())> >
struct	IsMetaTypePair
struct	IsMetaTypePair< T, true >
struct	IsPair
struct	IsPair< std::pair< T, U > >
struct	IsPointerDeclaredOpaque
struct	IsPointerDeclaredOpaque< const void * >
struct	IsPointerDeclaredOpaque< void * >
struct	IsPointerToGadgetHelper
struct	IsPointerToGadgetHelper< T *, typename T::QtGadgetHelper >
struct	IsPointerToTypeDerivedFromQObject
struct	IsPointerToTypeDerivedFromQObject< const void * >
struct	IsPointerToTypeDerivedFromQObject< QObject * >
struct	IsPointerToTypeDerivedFromQObject< Result(*)(Args...)>
struct	IsPointerToTypeDerivedFromQObject< T * >
struct	IsPointerToTypeDerivedFromQObject< void * >
struct	IsQEnumHelper
struct	IsQEnumHelper< void >
struct	IsQFlags
struct	IsQFlags< QFlags< E > >
struct	IsSequentialContainer
struct	IsSharedPointerToTypeDerivedFromQObject
struct	IsSharedPointerToTypeDerivedFromQObject< QSharedPointer< T > >
struct	IsTrackingPointerToTypeDerivedFromQObject
struct	IsTrackingPointerToTypeDerivedFromQObject< QPointer< T > >
struct	IsWeakPointerToTypeDerivedFromQObject
struct	IsWeakPointerToTypeDerivedFromQObject< QWeakPointer< T > >
struct	List
struct	List< Head, Tail... >
struct	List_Append
struct	List_Append< List< L1... >, List< L2... > >
struct	List_Left
struct	List_Left< L, 0 >
struct	MapResult
struct	MapSequenceResultType
struct	MapSequenceResultType< InputSequence< T... >, MapFunctor >
struct	member_function_traits
struct	member_function_traits< Return(Object::*)(Args...)>
struct	MetaObjectForType
struct	MetaObjectForType< T *, typename std::enable_if< IsPointerToTypeDerivedFromQObject< T * >::Value >::type >
struct	MetaObjectForType< T, std::enable_if_t< std::disjunction_v< std::bool_constant< IsGadgetHelper< T >::IsGadgetOrDerivedFrom >, std::is_base_of< QObject, T > > > >
struct	MetaObjectForType< T, typename std::enable_if< IsPointerToGadgetHelper< T >::IsGadgetOrDerivedFrom >::type >
struct	MetaObjectForType< T, typename std::enable_if< IsQEnumHelper< T >::Value >::type >
struct	MetatypeDecay
struct	MetatypeDecay< const T & >
struct	MetatypeDecay< const T >
struct	MetaTypeDefinedHelper
struct	MetaTypePairHelper
struct	MetaTypeQFutureHelper< QFuture< T > >
struct	MetaTypeSmartPointerHelper
struct	MSVCWorkAround
struct	NarrowingDetector
class	PageItem
class	ParsedNumber
class	ProtectedLayoutAccessor
struct	PushBackWrapper
class	q_boyer_moore_searcher
class	q_boyer_moore_searcher_hashed_needle
struct	QAbstractSocketConstants
struct	QAnyStringArg
struct	QArrayOpsSelector
struct	QArrayOpsSelector< T, typename std::enable_if< !QTypeInfo< T >::isComplex &&QTypeInfo< T >::isRelocatable >::type >
struct	QArrayOpsSelector< T, typename std::enable_if< QTypeInfo< T >::isComplex &&QTypeInfo< T >::isRelocatable >::type >
struct	QAssociativeIterableConvertFunctor
struct	QAssociativeIterableMutableViewFunctor
struct	QAudioBufferChannelView
struct	QAudioBufferDeinterleaveAdaptor
class	QAudioRingBuffer
class	QAutoResetEventEventFD
class	QAutoResetEventKQueue
class	QAutoResetEventPipe
class	QAutoResetEventWin32
struct	QBindableInterface
class	QBindableInterfaceForProperty
class	QBindableInterfaceForProperty< const Property, std::void_t< decltype(std::declval< Property >().binding())> >
class	QBindableInterfaceForProperty< Property, std::void_t< decltype(std::declval< Property >().binding())> >
class	QBindableInterfaceForProperty< QObjectCompatProperty< Class, Ty, Offset, Setter, Signal, Getter >, std::void_t< Class > >
struct	QBindingStatusAccessToken
class	QCalendarDateSectionValidator
class	QCalendarDateValidator
class	QCalendarDayValidator
class	QCalendarDelegate
class	QCalendarModel
class	QCalendarMonthValidator
class	QCalendarRegistry
class	QCalendarTextNavigator
class	QCalendarView
class	QCalendarYearValidator
class	QCallableObject
class	QCalToolButton
struct	QCaseInsensitiveLatin1Hash
struct	QCaseSensitiveLatin1Hash
struct	QCborMapKeyValues
class	QColorLuminancePicker
class	QColorPicker
class	QColorPickingEventFilter
class	QColorShower
class	QColorShowLabel
class	QColorWell
class	QColSpinBox
struct	QCommonArrayOps
struct	QComObjectTraits< IMFActivate >
class	QConstPreservingPointer
struct	QContainerImplHelper
struct	QDataStreamOperatorForType
struct	QDataStreamOperatorForType< T, true >
struct	QDebugStreamOperatorForType
struct	QDebugStreamOperatorForType< T, true >
struct	QDefaultKeyValues
class	QDequeIODevice
struct	QEqualityOperatorForType
struct	QEqualityOperatorForType< T, false >
class	QExplicitlySharedDataPointerV2
struct	QFlagPointerAlignment
struct	QFlagPointerAlignment< void >
class	QFlagsStorage
struct	QFlagsStorageHelper
struct	QFlagsStorageHelper< Enum, sizeof(int)>
class	QForeachContainer
struct	QGenericArrayOps
struct	QHashCombineCommutativeMixer
struct	QHashCombineMixer
struct	QHashCombinerWithSeed
class	QHypotHelper
struct	QHypotType
struct	QHypotType< qfloat16, qfloat16 >
struct	QHypotType< qfloat16, R >
struct	QHypotType< R, qfloat16 >
class	QIODeviceRingBufferReader
class	QIODeviceRingBufferWriter
class	QIODeviceRingBufferWriterBase
class	QIOOperationDataStorage
struct	QJsonObjectKeyValues
class	QKeyValueRange
class	QKeyValueRangeStorage
class	QKeyValueRangeStorage< Map & >
struct	QLatin1StringArg
struct	QLessThanOperatorForType
struct	QLessThanOperatorForType< T, false >
class	QMetaTypeForType
struct	QMetaTypeIdHelper
struct	QMetaTypeIdHelper< T, false >
class	QMetaTypeInterface
struct	QMetaTypeInterfaceWrapper
struct	QMetaTypeInterfaceWrapper< T & >
class	QMetaTypeInterfaceWrapper< void >
struct	QModelIndexWrapper
struct	QMovableArrayOps
struct	QNothrowHashable
struct	QNothrowHashable< T, std::enable_if_t< QNothrowHashableHelper_v< T > > >
struct	QPodArrayOps
class	QPrevNextCalButton
class	QPrivateSlotObject
class	QPropertyAdaptorSlotObject
class	QPropertyBindingData
struct	QPropertyBindingFunction
class	QQuasiVirtualInterface
class	QQuasiVirtualSubclass
class	QRegularExpressionMatchIteratorRangeBasedForIterator
class	QRegularExpressionMatchIteratorRangeBasedForIteratorSentinel
struct	QRemovePointerLike
struct	QSequentialIterableConvertFunctor
struct	QSequentialIterableMutableViewFunctor
struct	QSharedHandle
class	QSlotObjectBase
struct	QSmartPointerConvertFunctor
struct	QSmartPointerConvertFunctor< QWeakPointer< T > >
struct	QStringViewArg
class	QTagPreservingPointerToPointer
struct	QTypeNormalizer
struct	QuickSort
struct	QuickSort< QuickSortData< Pivot, Values... > >
struct	QuickSort< QuickSortData<> >
struct	QuickSortData
struct	QuickSortFilter
struct	QuickSortFilter< Predicate, QuickSortData< Head, Tail... > >
struct	QuickSortFilter< Predicate, QuickSortData<> >
class	QVariantTypeCoercer
struct	QVersionTag
class	QWellArray
struct	ReduceResultType
struct	ReduceResultType< R(*)(A...)>
struct	ReduceResultType< std::function< void(U &, V)> >
struct	ReduceResultType< T(C::*)(U) noexcept >
struct	ReduceResultType< T(C::*)(U)>
struct	ReduceResultType< void(*)(U &, V) noexcept >
struct	ReduceResultType< void(*)(U &, V)>
struct	ReduceResultTypeHelper
struct	ReduceResultTypeHelper< Callable, typename std::enable_if_t< std::is_function_v< std::remove_pointer_t< std::decay_t< Callable > > >||std::is_member_function_pointer_v< std::decay_t< Callable > > > >
struct	ReduceResultTypeHelper< Callable, typename std::enable_if_t<!std::is_function_v< std::remove_pointer_t< std::decay_t< Callable > > > &&hasCallOperator_v< std::decay_t< Callable > > > >
class	RefCount
	\inmodule QtCore More...
struct	RefCounted
struct	RemoveConstRef
struct	RemoveConstRef< const T & >
struct	RemoveRef
struct	RemoveRef< T & >
class	ResultItem
class	ResultIteratorBase
class	ResultStoreBase
struct	ResultTypeHelper
struct	ResultTypeHelper< F, Arg, typename std::enable_if_t< std::is_invocable_v< std::decay_t< F >, QFuture< Arg > > > >
struct	ResultTypeHelper< F, Arg, typename std::enable_if_t<!std::is_invocable_v< std::decay_t< F >, QFuture< Arg > > > >
struct	ResultTypeHelper< F, void, typename std::enable_if_t< std::is_invocable_v< std::decay_t< F >, QFuture< void > > > >
struct	ResultTypeHelper< F, void, typename std::enable_if_t<!std::is_invocable_v< std::decay_t< F >, QFuture< void > > > >
struct	ScopedRTSanDisabler
struct	SectionToken
struct	SequenceHolder
struct	SequentialContainerTransformationHelper
struct	SequentialContainerTransformationHelper< T, true >
struct	SequentialValueTypeIsMetaType
struct	SequentialValueTypeIsMetaType< T, true >
struct	SharedPointerMetaTypeIdHelper
struct	SizeOfList
struct	SizeOfList< List< Ts... > >
struct	SizeOfList< List<> >
class	SlotObjSharedPtr
class	StaticDayOfWeekAssociativeArray
class	StreamStateSaver
struct	TagInfo
struct	treat_as_integral_arg
struct	treat_as_integral_arg< signed char >
struct	treat_as_integral_arg< signed short >
struct	treat_as_integral_arg< unsigned char >
struct	treat_as_integral_arg< unsigned short >
struct	type_dependent_false
struct	TypesAreDeclaredMetaType
struct	TypesAreDeclaredMetaType< List< Arg, Tail... > >
struct	TypesAreDeclaredMetaType< List<> >
struct	UniqueHandleTraitsFromSharedHandleTraits
struct	UnwrapHandler
struct	value_dependent_false
struct	WhenAllContext
struct	WhenAnyContext
struct	wrap_char
struct	wrapped
class	XmlStringRef

Typedefs
using	CompareUnderlyingType = qint8
template<typename Char>
using	IsCompatibleChar32TypeHelper
template<typename Char>
using	IsCompatibleChar32Type = IsCompatibleChar32TypeHelper<q20::remove_cvref_t<Char>>
template<typename Mixer>
using	QHashCombiner = QHashCombinerWithSeed<Mixer>
using	QHashCombine = QHashCombiner<QHashCombineMixer>
using	QHashCombineWithSeed = QHashCombinerWithSeed<QHashCombineMixer>
using	QHashCombineCommutative = QHashCombiner<QHashCombineCommutativeMixer>
using	QHashCombineCommutativeWithSeed = QHashCombinerWithSeed<QHashCombineCommutativeMixer>
template<typename... T>
using	QHashMultiReturnType
template<typename Func>
using	FunctionStorage = QtPrivate::CompactStorage<Func>
using	NonConstMetaTypeInterface = QMetaTypeInterface
template<typename T>
using	IsRealGadget = std::bool_constant<IsGadgetHelper<T>::IsRealGadget>
template<typename Tag, typename Result>
using	wrapped_t = typename wrapped<Tag, Result>::type
template<typename Iterator>
using	IfIsInputIterator
template<typename Iterator>
using	IfIsForwardIterator
template<typename Iterator>
using	IfIsNotForwardIterator
template<typename Iterator>
using	KeyAndValueTest
template<typename Iterator>
using	FirstAndSecondTest
template<typename Iterator>
using	IfAssociativeIteratorHasKeyAndValue
template<typename Iterator>
using	IfAssociativeIteratorHasFirstAndSecond
template<typename Iterator>
using	MoveBackwardsTest
template<typename Iterator>
using	IfIteratorCanMoveBackwards
template<typename T, typename U>
using	IfIsNotSame
template<typename T, typename U>
using	IfIsNotConvertible = typename std::enable_if<!std::is_convertible<T, U>::value, bool>::type
template<class T>
using	ArgumentType = typename Argument<T>::Type
template<class T, class MapFunctor>
using	MapResultType = typename MapResult<T, MapFunctor>::Type
template<class Callable, class Sequence>
using	isInvocable = std::is_invocable<Callable, typename std::decay_t<Sequence>::value_type>
template<typename T>
using	if_volatile = std::enable_if_t<std::is_volatile_v<T>, bool>
using	SlotObjUniquePtr
template<typename T>
using	IsUntypedPropertyData = std::enable_if_t<std::is_base_of_v<QUntypedPropertyData, T>, bool>
using	QPropertyObserverCallback = void (*)(QUntypedPropertyData *)
using	QPropertyBindingWrapper = bool(*)(QMetaType, QUntypedPropertyData *dataPtr, QPropertyBindingFunction)
template<typename Char>
using	IsCompatibleChar8TypeHelper
template<typename Char>
using	IsCompatibleChar8Type = IsCompatibleChar8TypeHelper<q20::remove_cvref_t<Char>>
template<typename Pointer>
using	IsCompatiblePointer8 = IsCompatiblePointer8Helper<q20::remove_cvref_t<Pointer>>
template<class T>
using	EnableForVoid = std::enable_if_t<std::is_same_v<T, void>>
template<class T>
using	EnableForNonVoid = std::enable_if_t<!std::is_same_v<T, void>>
template<class Arg, class... Args>
using	FilterLastPrivateSignalArg
template<class Class, class Callable>
using	EnableIfInvocable
template<class T>
using	isQFuture = std::bool_constant<isQFutureV<T>>
template<class... Args>
using	NotEmpty = std::bool_constant<(sizeof...(Args) > 0)>
template<class Sequence>
using	IsRandomAccessible
template<class Sequence>
using	HasInputIterator
template<class Iterator>
using	IsForwardIterable
template<class T, class U>
using	EnableIfSameOrConvertible = std::enable_if_t<std::is_convertible_v<T, U>>
template<typename Object, typename Tag = void>
using	CompactStorage
template<typename ManualType, typename... Types>
using	ArrayType
template<typename T, bool Predicate>
using	add_const_if_t = std::conditional_t<Predicate, std::add_const_t<T>, T>
using	QAutoResetEvent = QAutoResetEventPipe

Enumerations
enum class	Ordering : CompareUnderlyingType { Equal = 0 , Equivalent = Equal , Less = -1 , Greater = 1 }
enum class	Uncomparable : CompareUnderlyingType { Unordered = }
enum class	LegacyUncomparable : CompareUnderlyingType { Unordered = QtPrivate::LegacyUncomparableValue }
enum class	WakeMode { One = 1 , All = -1 }
enum class	Mutability { Mutable , Immutable }

Functions
Q_CORE_EXPORT Q_DECL_PURE_FUNCTION size_t	expectedAllocSize (size_t allocSize, size_t alignment) noexcept
size_t	fittedAllocSize (size_t headerSize, size_t *capacity, size_t elementSize, size_t unusedCapacity, size_t alignment) noexcept
	Computes the best allocation size for the requested minimum capacity, and updates capacity.
void *	fittedMalloc (size_t headerSize, size_t *capacity, size_t elementSize, size_t unusedCapacity) noexcept
void *	fittedMalloc (size_t headerSize, qsizetype *capacity, size_t elementSize, size_t unusedCapacity=0) noexcept
void *	fittedRealloc (void *ptr, size_t headerSize, size_t *capacity, size_t elementSize, size_t unusedCapacity) noexcept
void *	fittedRealloc (void *ptr, size_t headerSize, qsizetype *capacity, size_t elementSize, size_t unusedCapacity=0) noexcept
Q_CORE_EXPORT void	sizedFree (void *ptr, size_t allocSize) noexcept
void	sizedFree (void *ptr, size_t capacity, size_t elementSize) noexcept
template<typename T>
constexpr std::enable_if_t< std::conjunction_v< std::is_integral< T >, std::is_unsigned< T > >, int >	log2i (T x)
const QString &	asString (const QString &s)
QString &&	asString (QString &&s)
Q_CORE_EXPORT QString	argToQString (QAnyStringView pattern, size_t n, const ArgBase **args)
template<typename... Args>
Q_ALWAYS_INLINE QString	argToQStringDispatch (QAnyStringView pattern, const Args &...args)
constexpr QAnyStringArg	qStringLikeToArg (QAnyStringView s) noexcept
template<qsizetype N>
static Q_ALWAYS_INLINE QStringPrivate	qMakeStringPrivate (const char16_t(&literal)[N])
template<typename Char>
static constexpr qsizetype	lengthHelperPointer (const Char *data) noexcept
template<typename V, typename U>
qsizetype	indexOf (const QList< V > &list, const U &u, qsizetype from) noexcept
template<typename V, typename U>
qsizetype	lastIndexOf (const QList< V > &list, const U &u, qsizetype from) noexcept
template<typename T, typename U>
qsizetype	indexOf (const QList< T > &vector, const U &u, qsizetype from) noexcept
template<typename T, typename U>
qsizetype	lastIndexOf (const QList< T > &vector, const U &u, qsizetype from) noexcept
void Q_CORE_EXPORT	QStringList_sort (QStringList *that, Qt::CaseSensitivity cs)
qsizetype Q_CORE_EXPORT	QStringList_removeDuplicates (QStringList *that)
QString Q_CORE_EXPORT	QStringList_join (const QStringList *that, QStringView sep)
QString Q_CORE_EXPORT	QStringList_join (const QStringList *that, const QChar *sep, qsizetype seplen)
Q_CORE_EXPORT QString	QStringList_join (const QStringList &list, QLatin1StringView sep)
QStringList Q_CORE_EXPORT	QStringList_filter (const QStringList *that, QStringView str, Qt::CaseSensitivity cs)
Q_CORE_EXPORT QStringList	QStringList_filter (const QStringList &that, QLatin1StringView needle, Qt::CaseSensitivity cs)
Q_CORE_EXPORT QStringList	QStringList_filter (const QStringList &that, const QStringMatcher &matcher)
Q_CORE_EXPORT QStringList	QStringList_filter (const QStringList &that, const QLatin1StringMatcher &matcher)
bool Q_CORE_EXPORT	QStringList_contains (const QStringList *that, QStringView str, Qt::CaseSensitivity cs)
bool Q_CORE_EXPORT	QStringList_contains (const QStringList *that, QLatin1StringView str, Qt::CaseSensitivity cs)
void Q_CORE_EXPORT	QStringList_replaceInStrings (QStringList *that, QStringView before, QStringView after, Qt::CaseSensitivity cs)
qsizetype Q_CORE_EXPORT	QStringList_indexOf (const QStringList &that, QStringView str, qsizetype from, Qt::CaseSensitivity cs)
qsizetype Q_CORE_EXPORT	QStringList_indexOf (const QStringList &that, QLatin1StringView str, qsizetype from, Qt::CaseSensitivity cs)
Q_CORE_EXPORT qsizetype	QStringList_lastIndexOf (const QStringList &that, QStringView str, qsizetype from, Qt::CaseSensitivity cs)
Q_CORE_EXPORT qsizetype	QStringList_lastIndexOf (const QStringList &that, QLatin1StringView str, qsizetype from, Qt::CaseSensitivity cs)
bool	shouldLogToStderr ()
	Returns true if logging stderr should be ensured.
template<typename T>
constexpr std::enable_if_t< std::is_unsigned_v< T >, bool >	qAddOverflowGeneric (T v1, T v2, T *r)
template<typename T>
constexpr std::enable_if_t< std::is_same_v< T, decltype(+T{})>, bool >	qMulOverflowWideMultiplication (T v1, T v2, T *r)
template<typename T>
constexpr std::enable_if_t<(std::is_unsigned_v< T >||std::is_signed_v< T >), bool >	qMulOverflowGeneric (T v1, T v2, T *r)
template<typename T, typename std::enable_if_t< std::is_integral_v< T >, bool > = true>
constexpr auto	qUnsignedAbs (T t)
template<typename Result, typename FP, typename std::enable_if_t< std::is_integral_v< Result >, bool > = true, typename std::enable_if_t< std::is_floating_point_v< FP >, bool > = true>
constexpr Result	qCheckedFPConversionToInteger (FP value)
template<typename FP, typename std::enable_if_t< std::is_floating_point_v< FP >, bool > = true>
constexpr int	qSaturateRound (FP value)
template<typename T>
constexpr const T &	min (const T &a, const T &b)
template<typename SequentialContainer>
QDebug	printSequentialContainer (QDebug debug, const char *which, const SequentialContainer &c)
template<typename AssociativeContainer>
QDebug	printAssociativeContainer (QDebug debug, const char *which, const AssociativeContainer &c)
template<typename T>
constexpr const QMetaTypeInterface *	qMetaTypeInterfaceForType ()
template<typename... Args>
auto	invokeMethodHelper (QMetaMethodReturnArgument r, const Args &... arguments)
template<class TgtType, class SrcType>
TgtType	qobject_cast_helper (SrcType *object)
template<typename T>
T	qvariant_cast_qmetatype_converted (const QVariant &v, QMetaType targetType)
template<typename Container>
QDataStream &	readArrayBasedContainer (QDataStream &s, Container &c)
template<typename Container>
QDataStream &	readListBasedContainer (QDataStream &s, Container &c)
template<typename Container>
QDataStream &	readAssociativeContainer (QDataStream &s, Container &c)
template<typename Container>
QDataStream &	writeSequentialContainer (QDataStream &s, const Container &c)
template<typename Container>
QDataStream &	writeAssociativeContainer (QDataStream &s, const Container &c)
template<typename Container>
QDataStream &	writeAssociativeMultiContainer (QDataStream &s, const Container &c)
QObject &	deref_for_methodcall (QObject &o)
QObject &	deref_for_methodcall (QObject *o)
const QObject *	getQObject (const QObjectPrivate *d)
template<typename ObjPrivate>
void	assertObjectType (QObjectPrivate *d)
Q_CORE_EXPORT bool	isAnyBindingEvaluating ()
Q_CORE_EXPORT bool	isPropertyInBindingWrapper (const QUntypedPropertyData *property)
void Q_CORE_EXPORT	initBindingStatusThreadId ()
Q_CORE_EXPORT BindingEvaluationState *	suspendCurrentBindingStatus ()
Q_CORE_EXPORT void	restoreBindingStatus (BindingEvaluationState *status)
	Q_LOGGING_CATEGORY (lcEventDispatcher, "qt.eventdispatcher")
	Q_LOGGING_CATEGORY (lcEventDispatcherTimers, "qt.eventdispatcher.timers")
template<typename From, typename To>
To	convertImplicit (const From &from)
	This template is used for implicit conversion from type From to type To.
template<typename T>
char	qt_getEnumMetaObject (const T &)
template<typename X>
static constexpr bool	checkTypeIsSuitableForMetaType ()
Q_CORE_EXPORT bool	hasRegisteredConverterFunctionToPairVariantInterface (QMetaType m)
Q_CORE_EXPORT bool	hasRegisteredConverterFunctionToIterableMetaSequence (QMetaType m)
Q_CORE_EXPORT bool	hasRegisteredMutableViewFunctionToIterableMetaSequence (QMetaType m)
Q_CORE_EXPORT bool	hasRegisteredConverterFunctionToIterableMetaAssociation (QMetaType m)
Q_CORE_EXPORT bool	hasRegisteredMutableViewFunctionToIterableMetaAssociation (QMetaType m)
constexpr int	qNormalizeType (const char *begin, const char *end, char *output)
template<typename Unique, typename T>
constexpr const QMetaTypeInterface *	qTryMetaTypeInterfaceForType ()
QByteArray Q_CORE_EXPORT	QByteArrayList_join (const QByteArrayList *that, const char *sep, qsizetype len)
QBindingStatus *	getBindingStatus (QtPrivate::QBindingStatusAccessToken)
void	setBindingStatus (QBindingStatus *status, QBindingStatusAccessToken)
	QSEIT_EXCLUDE (bool)
	QSEIT_EXCLUDE (char)
	QSEIT_EXCLUDE (char16_t)
	QSEIT_EXCLUDE (char32_t)
	QSEIT_EXCLUDE (wchar_t)
template<const char * Set, int ForcedLowest = -1>
constexpr auto	makeCharacterSetMatch () noexcept
static int	partiallyParsedDataCount (QStringConverter::State *state)
template<typename T, typename Cmp = std::less<>>
static constexpr bool	q_points_into_range (const T *p, const T *b, const T *e, Cmp less={}) noexcept
template<typename C, typename T>
static constexpr bool	q_points_into_range (const T &p, const C &c) noexcept
template<typename T, typename N>
QT_WARNING_PUSH void	q_uninitialized_move_if_noexcept_n (T *first, N n, T *out)
template<typename T, typename N>
void	q_uninitialized_relocate_n (T *first, N n, T *out)
template<typename T>
QT_WARNING_POP void	q_rotate (T *first, T *mid, T *last)
template<typename T, typename Predicate>
T *	q_uninitialized_remove_copy_if (T *first, T *last, T *out, Predicate &pred)
template<typename iterator, typename N>
void	q_relocate_overlap_n_left_move (iterator first, N n, iterator d_first)
template<typename T, typename N>
void	q_relocate_overlap_n (T *first, N n, T *d_first)
template<typename Container, typename InputIterator, IfIsNotForwardIterator< InputIterator > = true>
void	reserveIfForwardIterator (Container *, InputIterator, InputIterator)
template<typename Container, typename ForwardIterator, IfIsForwardIterator< ForwardIterator > = true>
void	reserveIfForwardIterator (Container *c, ForwardIterator f, ForwardIterator l)
template<typename Container, typename Predicate>
auto	sequential_erase_if (Container &c, Predicate &pred)
template<typename Container, typename T>
auto	sequential_erase (Container &c, const T &t)
template<typename Container, typename T>
auto	sequential_erase_with_copy (Container &c, const T &t)
template<typename Container, typename T>
auto	sequential_erase_one (Container &c, const T &t)
template<typename T, typename Predicate>
qsizetype	qset_erase_if (QSet< T > &set, Predicate &pred)
template<typename Container, typename Predicate>
auto	associative_erase_if (Container &c, Predicate &pred)
Q_CORE_EXPORT Q_DECL_PURE_FUNCTION qsizetype	qustrlen (const char16_t *str) noexcept
Q_CORE_EXPORT Q_DECL_PURE_FUNCTION qsizetype	qustrnlen (const char16_t *str, qsizetype maxlen) noexcept
Q_CORE_EXPORT Q_DECL_PURE_FUNCTION const char16_t *	qustrchr (QStringView str, char16_t ch) noexcept
Q_CORE_EXPORT Q_DECL_PURE_FUNCTION const char16_t *	qustrcasechr (QStringView str, char16_t ch) noexcept
Q_CORE_EXPORT Q_DECL_PURE_FUNCTION int	compareStrings (QStringView lhs, QStringView rhs, Qt::CaseSensitivity cs=Qt::CaseSensitive) noexcept
Q_CORE_EXPORT Q_DECL_PURE_FUNCTION int	compareStrings (QStringView lhs, QLatin1StringView rhs, Qt::CaseSensitivity cs=Qt::CaseSensitive) noexcept
Q_CORE_EXPORT Q_DECL_PURE_FUNCTION int	compareStrings (QStringView lhs, QBasicUtf8StringView< false > rhs, Qt::CaseSensitivity cs=Qt::CaseSensitive) noexcept
Q_CORE_EXPORT Q_DECL_PURE_FUNCTION int	compareStrings (QLatin1StringView lhs, QStringView rhs, Qt::CaseSensitivity cs=Qt::CaseSensitive) noexcept
Q_CORE_EXPORT Q_DECL_PURE_FUNCTION int	compareStrings (QLatin1StringView lhs, QLatin1StringView rhs, Qt::CaseSensitivity cs=Qt::CaseSensitive) noexcept
Q_CORE_EXPORT Q_DECL_PURE_FUNCTION int	compareStrings (QLatin1StringView lhs, QBasicUtf8StringView< false > rhs, Qt::CaseSensitivity cs=Qt::CaseSensitive) noexcept
Q_CORE_EXPORT Q_DECL_PURE_FUNCTION int	compareStrings (QBasicUtf8StringView< false > lhs, QStringView rhs, Qt::CaseSensitivity cs=Qt::CaseSensitive) noexcept
Q_CORE_EXPORT Q_DECL_PURE_FUNCTION int	compareStrings (QBasicUtf8StringView< false > lhs, QLatin1StringView rhs, Qt::CaseSensitivity cs=Qt::CaseSensitive) noexcept
Q_CORE_EXPORT Q_DECL_PURE_FUNCTION int	compareStrings (QBasicUtf8StringView< false > lhs, QBasicUtf8StringView< false > rhs, Qt::CaseSensitivity cs=Qt::CaseSensitive) noexcept
Q_CORE_EXPORT Q_DECL_PURE_FUNCTION bool	equalStrings (QStringView lhs, QStringView rhs) noexcept
Q_CORE_EXPORT Q_DECL_PURE_FUNCTION bool	equalStrings (QStringView lhs, QLatin1StringView rhs) noexcept
Q_CORE_EXPORT Q_DECL_PURE_FUNCTION bool	equalStrings (QStringView lhs, QBasicUtf8StringView< false > rhs) noexcept
Q_CORE_EXPORT Q_DECL_PURE_FUNCTION bool	equalStrings (QLatin1StringView lhs, QStringView rhs) noexcept
Q_CORE_EXPORT Q_DECL_PURE_FUNCTION bool	equalStrings (QLatin1StringView lhs, QLatin1StringView rhs) noexcept
Q_CORE_EXPORT Q_DECL_PURE_FUNCTION bool	equalStrings (QLatin1StringView lhs, QBasicUtf8StringView< false > rhs) noexcept
Q_CORE_EXPORT Q_DECL_PURE_FUNCTION bool	equalStrings (QBasicUtf8StringView< false > lhs, QStringView rhs) noexcept
Q_CORE_EXPORT Q_DECL_PURE_FUNCTION bool	equalStrings (QBasicUtf8StringView< false > lhs, QLatin1StringView rhs) noexcept
Q_CORE_EXPORT Q_DECL_PURE_FUNCTION bool	equalStrings (QBasicUtf8StringView< false > lhs, QBasicUtf8StringView< false > rhs) noexcept
Q_CORE_EXPORT Q_DECL_PURE_FUNCTION bool	startsWith (QStringView haystack, QStringView needle, Qt::CaseSensitivity cs=Qt::CaseSensitive) noexcept
Q_CORE_EXPORT Q_DECL_PURE_FUNCTION bool	startsWith (QStringView haystack, QLatin1StringView needle, Qt::CaseSensitivity cs=Qt::CaseSensitive) noexcept
Q_CORE_EXPORT Q_DECL_PURE_FUNCTION bool	startsWith (QLatin1StringView haystack, QStringView needle, Qt::CaseSensitivity cs=Qt::CaseSensitive) noexcept
Q_CORE_EXPORT Q_DECL_PURE_FUNCTION bool	startsWith (QLatin1StringView haystack, QLatin1StringView needle, Qt::CaseSensitivity cs=Qt::CaseSensitive) noexcept
Q_CORE_EXPORT Q_DECL_PURE_FUNCTION bool	endsWith (QStringView haystack, QStringView needle, Qt::CaseSensitivity cs=Qt::CaseSensitive) noexcept
Q_CORE_EXPORT Q_DECL_PURE_FUNCTION bool	endsWith (QStringView haystack, QLatin1StringView needle, Qt::CaseSensitivity cs=Qt::CaseSensitive) noexcept
Q_CORE_EXPORT Q_DECL_PURE_FUNCTION bool	endsWith (QLatin1StringView haystack, QStringView needle, Qt::CaseSensitivity cs=Qt::CaseSensitive) noexcept
Q_CORE_EXPORT Q_DECL_PURE_FUNCTION bool	endsWith (QLatin1StringView haystack, QLatin1StringView needle, Qt::CaseSensitivity cs=Qt::CaseSensitive) noexcept
qsizetype	findString (QStringView str, qsizetype from, QChar needle, Qt::CaseSensitivity cs=Qt::CaseSensitive) noexcept
Q_CORE_EXPORT Q_DECL_PURE_FUNCTION qsizetype	findString (QStringView haystack, qsizetype from, QStringView needle, Qt::CaseSensitivity cs=Qt::CaseSensitive) noexcept
Q_CORE_EXPORT Q_DECL_PURE_FUNCTION qsizetype	findString (QStringView haystack, qsizetype from, QLatin1StringView needle, Qt::CaseSensitivity cs=Qt::CaseSensitive) noexcept
Q_CORE_EXPORT Q_DECL_PURE_FUNCTION qsizetype	findString (QLatin1StringView haystack, qsizetype from, QStringView needle, Qt::CaseSensitivity cs=Qt::CaseSensitive) noexcept
Q_CORE_EXPORT Q_DECL_PURE_FUNCTION qsizetype	findString (QLatin1StringView haystack, qsizetype from, QLatin1StringView needle, Qt::CaseSensitivity cs=Qt::CaseSensitive) noexcept
Q_CORE_EXPORT Q_DECL_PURE_FUNCTION qsizetype	lastIndexOf (QStringView haystack, qsizetype from, char16_t needle, Qt::CaseSensitivity cs=Qt::CaseSensitive) noexcept
Q_CORE_EXPORT Q_DECL_PURE_FUNCTION qsizetype	lastIndexOf (QStringView haystack, qsizetype from, QStringView needle, Qt::CaseSensitivity cs=Qt::CaseSensitive) noexcept
Q_CORE_EXPORT Q_DECL_PURE_FUNCTION qsizetype	lastIndexOf (QStringView haystack, qsizetype from, QLatin1StringView needle, Qt::CaseSensitivity cs=Qt::CaseSensitive) noexcept
Q_CORE_EXPORT Q_DECL_PURE_FUNCTION qsizetype	lastIndexOf (QLatin1StringView haystack, qsizetype from, QStringView needle, Qt::CaseSensitivity cs=Qt::CaseSensitive) noexcept
Q_CORE_EXPORT Q_DECL_PURE_FUNCTION qsizetype	lastIndexOf (QLatin1StringView haystack, qsizetype from, QLatin1StringView needle, Qt::CaseSensitivity cs=Qt::CaseSensitive) noexcept
Q_CORE_EXPORT Q_DECL_PURE_FUNCTION QStringView	trimmed (QStringView s) noexcept
Q_CORE_EXPORT Q_DECL_PURE_FUNCTION QLatin1StringView	trimmed (QLatin1StringView s) noexcept
Q_CORE_EXPORT Q_DECL_PURE_FUNCTION bool	isLower (QStringView s) noexcept
Q_CORE_EXPORT Q_DECL_PURE_FUNCTION bool	isUpper (QStringView s) noexcept
Q_CORE_EXPORT Q_DECL_PURE_FUNCTION qsizetype	count (QStringView haystack, QChar needle, Qt::CaseSensitivity cs=Qt::CaseSensitive) noexcept
Q_CORE_EXPORT Q_DECL_PURE_FUNCTION qsizetype	count (QStringView haystack, QStringView needle, Qt::CaseSensitivity cs=Qt::CaseSensitive) noexcept
Q_CORE_EXPORT Q_DECL_PURE_FUNCTION qsizetype	count (QStringView haystack, QLatin1StringView needle, Qt::CaseSensitivity cs=Qt::CaseSensitive)
Q_CORE_EXPORT Q_DECL_PURE_FUNCTION qsizetype	count (QLatin1StringView haystack, QLatin1StringView needle, Qt::CaseSensitivity cs=Qt::CaseSensitive)
Q_CORE_EXPORT Q_DECL_PURE_FUNCTION qsizetype	count (QLatin1StringView haystack, QStringView needle, Qt::CaseSensitivity cs=Qt::CaseSensitive)
Q_CORE_EXPORT Q_DECL_PURE_FUNCTION qsizetype	count (QLatin1StringView haystack, QChar needle, Qt::CaseSensitivity cs=Qt::CaseSensitive) noexcept
Q_CORE_EXPORT QString	convertToQString (QAnyStringView s)
Q_CORE_EXPORT QByteArray	convertToLatin1 (QStringView str)
Q_CORE_EXPORT QByteArray	convertToUtf8 (QStringView str)
Q_CORE_EXPORT QByteArray	convertToLocal8Bit (QStringView str)
Q_CORE_EXPORT QList< uint >	convertToUcs4 (QStringView str)
Q_CORE_EXPORT QByteArray	convertToUtf8 (QLatin1StringView str)
Q_CORE_EXPORT Q_DECL_PURE_FUNCTION bool	isRightToLeft (QStringView string) noexcept
Q_CORE_EXPORT Q_DECL_PURE_FUNCTION bool	isAscii (QLatin1StringView s) noexcept
Q_CORE_EXPORT Q_DECL_PURE_FUNCTION bool	isAscii (QStringView s) noexcept
constexpr bool	isLatin1 (QLatin1StringView s) noexcept
Q_CORE_EXPORT Q_DECL_PURE_FUNCTION bool	isLatin1 (QStringView s) noexcept
Q_CORE_EXPORT Q_DECL_PURE_FUNCTION bool	isValidUtf16 (QStringView s) noexcept
template<typename Char, size_t N>
Q_ALWAYS_INLINE constexpr qsizetype	lengthHelperContainerLoop (const Char(&str)[N])
template<typename Char, size_t N>
Q_ALWAYS_INLINE constexpr std::enable_if_t< sizeof(Char)==sizeof(char16_t), qsizetype >	lengthHelperContainer (const Char(&str)[N])
qsizetype	qstrnlen_helper (const char *str, size_t maxlen)
template<typename Char, size_t N>
constexpr std::enable_if_t< sizeof(Char)==1, qsizetype >	lengthHelperContainer (const Char(&str)[N])
template<typename Container>
constexpr qsizetype	lengthHelperContainer (const Container &c) noexcept
void	qfutureWarnIfUnusedResults (qsizetype numResults)
Q_ATOMICWAIT_EXPORT void	_q_atomicWait (const void *address, const void *old, qsizetype size) noexcept
Q_ATOMICWAIT_EXPORT void	_q_atomicWake (void *address, WakeMode) noexcept
static ResultIteratorBase	findResult (const QMap< int, ResultItem > &store, int index)
QPixelFormat	QPixelFormat_createYUV (QPixelFormat::YUVLayout yuvLayout, uchar alphaSize, QPixelFormat::AlphaUsage alphaUsage, QPixelFormat::AlphaPosition alphaPosition, QPixelFormat::AlphaPremultiplied premultiplied, QPixelFormat::TypeInterpretation typeInterpretation, QPixelFormat::ByteOrder byteOrder)
static bool	intersect_rect (const QGraphicsItem *item, const QRectF &exposeRect, Qt::ItemSelectionMode mode, const QTransform &deviceTransform, const void *intersectData)
static bool	intersect_point (const QGraphicsItem *item, const QRectF &exposeRect, Qt::ItemSelectionMode mode, const QTransform &deviceTransform, const void *intersectData)
static bool	intersect_path (const QGraphicsItem *item, const QRectF &exposeRect, Qt::ItemSelectionMode mode, const QTransform &deviceTransform, const void *intersectData)
static size_t	roundUpToMultipleOf (size_t divisor, size_t x)
QString	asString (const QHashedCStringRef &ref)
QString	asString (const QHashedStringRef &ref)
template<typename... Args>
constexpr int	channelConfig (Args... values)
template<typename T, typename = decltype(std::declval<T>().detach())>
void	warnIfContainerIsNotShared (int)
template<typename T>
QForeachContainer< typename std::decay< T >::type >	qMakeForeachContainer (T &&t)
template<typename T, QtPrivate::if_volatile< T > = true>
auto	volatilePreIncrement (T &x)
template<typename T, QtPrivate::if_volatile< T > = true>
auto	volatilePreDecrement (T &x)
template<typename T>
T	legacyEnumValueFromModelData (const QVariant &data)
template<typename T>
T	legacyFlagValueFromModelData (const QVariant &data)
template<typename Applier, size_t ... Is>
void	applyIndexSwitch (size_t index, Applier &&applier, std::index_sequence< Is... >)
template<size_t IndexCount, typename Applier>
void	applyIndexSwitch (size_t index, Applier &&applier)
template<typename Obj>
void	assertObjectType (QObject *o)
template<typename Prototype, typename Functor>
constexpr std::enable_if_t<!std::disjunction_v< std::is_convertible< Prototype, const char * >, std::is_same< std::decay_t< Prototype >, QMetaMethod >, std::is_convertible< Functor, const char * >, std::is_same< std::decay_t< Functor >, QMetaMethod > >, int >	countMatchingArguments ()
SlotObjUniquePtr	copy (const SlotObjUniquePtr &other) noexcept
template<typename Prototype, typename Functor>
static constexpr std::enable_if_t< QtPrivate::countMatchingArguments< Prototype, Functor >() >=0, QtPrivate::QSlotObjectBase * >	makeCallableObject (Functor &&func)
template<typename Prototype, typename Functor>
constexpr bool	AssertCompatibleFunctions ()
Q_CORE_EXPORT Q_DECL_PURE_FUNCTION bool	startsWith (QByteArrayView haystack, QByteArrayView needle) noexcept
Q_CORE_EXPORT Q_DECL_PURE_FUNCTION bool	endsWith (QByteArrayView haystack, QByteArrayView needle) noexcept
qsizetype	findByteArray (QByteArrayView haystack, qsizetype from, char needle) noexcept
Q_CORE_EXPORT Q_DECL_PURE_FUNCTION qsizetype	findByteArray (QByteArrayView haystack, qsizetype from, QByteArrayView needle) noexcept
qsizetype	lastIndexOf (QByteArrayView haystack, qsizetype from, uchar needle) noexcept
Q_CORE_EXPORT Q_DECL_PURE_FUNCTION qsizetype	lastIndexOf (QByteArrayView haystack, qsizetype from, QByteArrayView needle) noexcept
Q_CORE_EXPORT Q_DECL_PURE_FUNCTION qsizetype	count (QByteArrayView haystack, QByteArrayView needle) noexcept
Q_CORE_EXPORT int	compareMemory (QByteArrayView lhs, QByteArrayView rhs)
Q_CORE_EXPORT Q_DECL_PURE_FUNCTION QByteArrayView	trimmed (QByteArrayView s) noexcept
Q_CORE_EXPORT Q_DECL_PURE_FUNCTION bool	isValidUtf8 (QByteArrayView s) noexcept
Q_CORE_EXPORT Q_DECL_PURE_FUNCTION ParsedNumber< double >	toDouble (QByteArrayView a) noexcept
Q_CORE_EXPORT Q_DECL_PURE_FUNCTION ParsedNumber< float >	toFloat (QByteArrayView a) noexcept
Q_CORE_EXPORT Q_DECL_PURE_FUNCTION ParsedNumber< qlonglong >	toSignedInteger (QByteArrayView data, int base)
Q_CORE_EXPORT Q_DECL_PURE_FUNCTION ParsedNumber< qulonglong >	toUnsignedInteger (QByteArrayView data, int base)
template<typename T, typename ByteArrayView, typename = std::enable_if_t<std::is_same_v<ByteArrayView, QByteArrayView>>>
static T	toIntegral (ByteArrayView data, bool *ok, int base)
template<class Tuple, std::size_t... I>
auto	cutTuple (Tuple &&t, std::index_sequence< I... >)
template<class Arg, class... Args>
auto	createTuple (Arg &&arg, Args &&... args)
template<class T>
void	fulfillPromise (QPromise< T > &promise, QFuture< T > &future)
template<class T, class Function>
void	fulfillPromise (QPromise< T > &promise, Function &&handler)
template<typename ValueType>
QFuture< ValueType >	makeReadyRangeFutureImpl (const QList< ValueType > &values)
template<qsizetype Index, typename ContextType, typename... Ts>
void	addCompletionHandlersImpl (const std::shared_ptr< ContextType > &context, const std::tuple< Ts... > &t)
template<typename ContextType, typename... Ts>
void	addCompletionHandlers (const std::shared_ptr< ContextType > &context, const std::tuple< Ts... > &t)
template<typename OutputSequence, typename InputIt, typename ValueType, std::enable_if_t< std::conjunction_v< IsForwardIterable< InputIt >, isQFuture< ValueType > >, bool > = true>
QFuture< OutputSequence >	whenAllImpl (InputIt first, InputIt last)
template<typename OutputSequence, typename... Futures>
QFuture< OutputSequence >	whenAllImpl (Futures &&... futures)
template<typename InputIt, typename ValueType, std::enable_if_t< std::conjunction_v< IsForwardIterable< InputIt >, isQFuture< ValueType > >, bool > = true>
QFuture< QtFuture::WhenAnyResult< typename Future< ValueType >::type > >	whenAnyImpl (InputIt first, InputIt last)
template<typename... Futures>
QFuture< std::variant< std::decay_t< Futures >... > >	whenAnyImpl (Futures &&... futures)
template<typename T>
constexpr T &&	Forward (typename std::remove_reference< T >::type &t) noexcept
template<typename T>
constexpr T &&	Forward (typename std::remove_reference< T >::type &&t) noexcept
template<typename ... Right, typename ... Left>
constexpr QuickSortData< Right..., Left... >	quickSortConcat (QuickSortData< Right... >, QuickSortData< Left... >) noexcept
template<typename ... Right, typename Middle, typename ... Left>
constexpr QuickSortData< Right..., Middle, Left... >	quickSortConcat (QuickSortData< Right... >, QuickSortData< Middle >, QuickSortData< Left... >) noexcept
template<size_t Highest>
constexpr auto	minifyValue ()
template<typename Char, int... Nx>
constexpr auto	makeOffsetStringArray (const Char(&...entries)[Nx])
template<typename T>
constexpr void	swap (QExplicitlySharedDataPointerV2< T > &lhs, QExplicitlySharedDataPointerV2< T > &rhs) noexcept
constexpr quint8	nextByteSize (quint8 bits)
qint64	writeToDevice (QIODevice &device, QSpan< const std::byte > data)
qint64	readFromDevice (QIODevice &device, QSpan< std::byte > outputBuffer)
template<typename SampleType>
qsizetype	pullFromQIODeviceToRingbuffer (QIODevice &device, QAudioRingBuffer< SampleType > &ringbuffer)
template<typename SampleType>
qsizetype	pushToQIODeviceFromRingbuffer (QIODevice &device, QAudioRingBuffer< SampleType > &ringbuffer)
template<typename Functor>
auto	withRTSanDisabled (const Functor &f)
template<typename SampleType>
void	validateBufferFormat (const QAudioBuffer &buffer, int channel)
template<typename SampleType>
auto	makeChannelView (add_const_if_t< QAudioBuffer, std::is_const_v< SampleType > > &buffer, int channel)
template<typename Trait>
void	swap (QSharedHandle< Trait > &lhs, QSharedHandle< Trait > &rhs) noexcept(noexcept(lhs.swap(rhs)))
template<typename T>
constexpr auto	typenameHelper ()

Variables
constexpr CompareUnderlyingType	LegacyUncomparableValue = -127
template<typename T, typename Enable = void>
constexpr bool	HasLargerInt = false
template<typename T>
constexpr bool	HasLargerInt< T, std::void_t< typename QIntegerForSize< sizeof(T) *2 >::Unsigned > > = true
template<typename T>
constexpr bool	QNothrowHashableHelper_v = noexcept(qHash(std::declval<const T &>(), size_t(0)))
template<typename T>
constexpr bool	QNothrowHashable_v = QNothrowHashable<T>::value
template<>
constexpr bool	qIsRelocatable< QVariant > = true
template<typename T>
constexpr bool	IsQmlListType = false
template<typename T, bool = std::is_enum<T>::value>
constexpr bool	IsUnsignedEnum = false
template<typename T>
constexpr bool	IsUnsignedEnum< T, true > = !std::is_signed_v<std::underlying_type_t<T>>
template<typename T>
constexpr bool	is_standard_or_extended_integer_type_v = is_standard_or_extended_integer_type<T>::value
constexpr char	ascii_space_chars []
template<typename T>
constexpr bool	isLatin1OrUtf16View = false
template<>
constexpr bool	isLatin1OrUtf16View< QLatin1StringView > = true
template<>
constexpr bool	isLatin1OrUtf16View< QStringView > = true
template<typename R, typename F, typename ... ArgTypes>
constexpr bool	is_invocable_explicit_r_v
constexpr quintptr	IdealMutexAlignment
template<typename T>
constexpr bool	is_function_pointer_v
template<typename T>
constexpr bool	is_std_function_v = false
template<typename T>
constexpr bool	is_std_function_v< std::function< T > > = true
template<typename T>
constexpr bool	qIsComplex
template<typename T>
constexpr bool	qIsRelocatable = std::is_trivially_copyable_v<T> && std::is_trivially_destructible_v<T>
template<typename T>
constexpr bool	qIsValueInitializationBitwiseZero
template<typename T>
constexpr bool	IsQmlListType< QQmlListProperty< T > > = true
template<QMetaType::Type type>
constexpr BindingFunctionVTable	bindingFunctionVTableForQQmlPropertyBinding
template<typename Binding>
constexpr BindingFunctionVTable	bindingFunctionVTableForQQmlPropertyToBindablePropertyBinding
template<class T>
constexpr bool	IsIterableValue = IsIterable<T>::value
template<class T>
constexpr bool	IsDereferenceableValue = IsDereferenceable<T>::value
template<class T, class Enable = void>
constexpr bool	hasCallOperator_v = false
template<class T>
constexpr bool	hasCallOperator_v< T, std::void_t< decltype(&T::operator())> > = true
template<class T, class Enable = void>
constexpr bool	isIterator_v = false
template<class T>
constexpr bool	isIterator_v< T, std::void_t< typename std::iterator_traits< T >::value_type > >
template<class InitialValueType, class ResultType>
constexpr bool	isInitialValueCompatible_v
template<typename T>
constexpr bool	IsIntegralType_v
template<typename T>
constexpr bool	IsFloatType_v = std::is_floating_point_v<T>
template<typename Functor, typename... Args>
constexpr bool	HasCallOperatorAcceptingArgs_v = HasCallOperatorAcceptingArgs<Functor, Args...>::value
template<typename Callable, typename PropertyType = MSVCWorkAround>
constexpr BindingFunctionVTable	bindingFunctionVTable = BindingFunctionVTable::createFor<Callable, PropertyType>()
template<class T, class Enable = void>
constexpr bool	IsPrivateSignalArg = false
template<class T>
constexpr bool	IsPrivateSignalArg< T, typename std::enable_if_t< std::is_class_v< class T::QPrivateSignal > > > = true
template<class T>
constexpr bool	isQFutureV = false
template<class T>
constexpr bool	isQFutureV< QFuture< T > > = true
constexpr size_t	MaxPrimitiveAlignment = alignof(std::max_align_t)
constexpr qsizetype	MaxAllocSize = (std::numeric_limits<qsizetype>::max)()
constexpr Mutability	QAudioBufferMutable = Mutability::Mutable
constexpr Mutability	QAudioBufferImmutable = Mutability::Immutable

Detailed Description

\qmltype ShaderEffect
\nativetype QQuickShaderEffect
\inqmlmodule QtQuick
\inherits Item
\ingroup qtquick-effects
\brief Applies custom shaders to a rectangle.

The ShaderEffect type applies a custom \l{vertexShader}{vertex} and
\l{fragmentShader}{fragment (pixel)} shader to a rectangle. It allows
adding effects such as drop shadow, blur, colorize and page curl into the
QML scene.

\note Depending on the Qt Quick scenegraph backend in use, the ShaderEffect
type may not be supported. For example, with the \c software backend
effects will not be rendered at all.

\section1 Shaders

In Qt 5, effects were provided in form of GLSL (OpenGL Shading Language)
source code, often embedded as strings into QML. Starting with Qt 5.8,
referring to files, either local ones or in the Qt resource system, became
possible as well.

In Qt 6, Qt Quick has support for graphics APIs, such as Vulkan, Metal, and
Direct3D 11 as well. Therefore, working with GLSL source strings is no
longer feasible. Rather, the new shader pipeline is based on compiling
Vulkan-compatible GLSL code into \l{https://www.khronos.org/spir/}{SPIR-V},
followed by gathering reflection information and translating into other
shading languages, such as HLSL, the Metal Shading Language, and various
GLSL versions. The resulting assets are packed together into a single
package, typically stored in files with an extension of \c{.qsb}. This
process is done offline or at application build time at latest. At run
time, the scene graph and the underlying graphics abstraction consumes
these \c{.qsb} files. Therefore, ShaderEffect expects file (local or qrc)
references in Qt 6 in place of inline shader code.

The \l vertexShader and \l fragmentShader properties are URLs in Qt 6, and
work very similarly to \l{Image::source}{Image.source}, for example. Only
the \c file and \c qrc schemes are supported with ShaderEffect, however. It
is also possible to omit the \c file scheme, allowing to specify a relative
path in a convenient way. Such a path is resolved relative to the
component's (the \c{.qml} file's) location.

\section1 Shader Inputs and Resources

There are two types of input to the \l vertexShader: uniforms and vertex
inputs.

The following inputs are predefined:

\list
\li vec4 qt_Vertex with location 0 - vertex position, the top-left vertex has
   position (0, 0), the bottom-right (\l{Item::width}{width},
   \l{Item::height}{height}).
\li vec2 qt_MultiTexCoord0 with location 1 - texture coordinate, the top-left
   coordinate is (0, 0), the bottom-right (1, 1). If \l supportsAtlasTextures
   is true, coordinates will be based on position in the atlas instead.
\endlist

\note It is only the vertex input location that matters in practice. The
names are freely changeable, while the location must always be \c 0 for
vertex position, \c 1 for texture coordinates. However, be aware that this
applies to vertex inputs only, and is not necessarily true for output
variables from the vertex shader that are then used as inputs in the
fragment shader (typically, the interpolated texture coordinates).

The following uniforms are predefined:

\list
\li mat4 qt_Matrix - combined transformation
   matrix, the product of the matrices from the root item to this
   ShaderEffect, and an orthogonal projection.
\li float qt_Opacity - combined opacity, the product of the
   opacities from the root item to this ShaderEffect.
\endlist

\note Vulkan-style GLSL has no separate uniform variables. Instead, shaders
must always use a uniform block with a binding point of \c 0.

\note The uniform block layout qualifier must always be \c std140.

\note Unlike vertex inputs, the predefined names (qt_Matrix, qt_Opacity)
must not be changed.

In addition, any property that can be mapped to a GLSL type can be made
available to the shaders. The following list shows how properties are
mapped:

\list
\li bool, int, qreal -> bool, int, float - If the type in the shader is not
   the same as in QML, the value is converted automatically.
\li QColor -> vec4 - When colors are passed to the shader, they are first
   premultiplied. Thus Qt.rgba(0.2, 0.6, 1.0, 0.5) becomes
   vec4(0.1, 0.3, 0.5, 0.5) in the shader, for example.
\li QRect, QRectF -> vec4 - Qt.rect(x, y, w, h) becomes vec4(x, y, w, h) in
   the shader.
\li QPoint, QPointF, QSize, QSizeF -> vec2
\li QVector3D -> vec3
\li QVector4D -> vec4
\li QTransform -> mat3
\li QMatrix4x4 -> mat4
\li QQuaternion -> vec4, scalar value is \c w.
\li \l Image -> sampler2D - Origin is in the top-left corner, and the
    color values are premultiplied. The texture is provided as is,
    excluding the Image item's fillMode. To include fillMode, use a
    ShaderEffectSource or Image::layer::enabled.
\li \l ShaderEffectSource -> sampler2D - Origin is in the top-left
    corner, and the color values are premultiplied.
\endlist

Samplers are still declared as separate uniform variables in the shader
code. The shaders are free to choose any binding point for these, except
for \c 0 because that is reserved for the uniform block.

Some shading languages and APIs have a concept of separate image and
sampler objects. Qt Quick always works with combined image sampler objects
in shaders, as supported by SPIR-V. Therefore shaders supplied for
ShaderEffect should always use \c{layout(binding = 1) uniform sampler2D
tex;} style sampler declarations. The underlying abstraction layer and the
shader pipeline takes care of making this work for all the supported APIs
and shading languages, transparently to the applications.

The QML scene graph back-end may choose to allocate textures in texture
atlases. If a texture allocated in an atlas is passed to a ShaderEffect,
it is by default copied from the texture atlas into a stand-alone texture
so that the texture coordinates span from 0 to 1, and you get the expected
wrap modes. However, this will increase the memory usage. To avoid the
texture copy, set \l supportsAtlasTextures for simple shaders using
qt_MultiTexCoord0, or for each "uniform sampler2D <name>" declare a
"uniform vec4 qt_SubRect_<name>" which will be assigned the texture's
normalized source rectangle. For stand-alone textures, the source rectangle
is [0, 1]x[0, 1]. For textures in an atlas, the source rectangle corresponds
to the part of the texture atlas where the texture is stored.
The correct way to calculate the texture coordinate for a texture called
"source" within a texture atlas is
"qt_SubRect_source.xy + qt_SubRect_source.zw * qt_MultiTexCoord0".

The output from the \l fragmentShader should be premultiplied. If
\l blending is enabled, source-over blending is used. However, additive
blending can be achieved by outputting zero in the alpha channel.

\table 70%
\row
\li \image declarative-shadereffectitem.png
\li \qml
    import QtQuick 2.0

    Rectangle {
        width: 200; height: 100
        Row {
            Image { id: img;
                    sourceSize { width: 100; height: 100 } source: "qt-logo.png" }
            ShaderEffect {
                width: 100; height: 100
                property variant src: img
                vertexShader: "myeffect.vert.qsb"
                fragmentShader: "myeffect.frag.qsb"
            }
        }
    }
    \endqml
\endtable

The example assumes \c{myeffect.vert} and \c{myeffect.frag} contain
Vulkan-style GLSL code, processed by the \c qsb tool in order to generate
the \c{.qsb} files.

\badcode
    #version 440
    layout(location = 0) in vec4 qt_Vertex;
    layout(location = 1) in vec2 qt_MultiTexCoord0;
    layout(location = 0) out vec2 coord;
    layout(std140, binding = 0) uniform buf {
        mat4 qt_Matrix;
        float qt_Opacity;
    };
    void main() {
        coord = qt_MultiTexCoord0;
        gl_Position = qt_Matrix * qt_Vertex;
    }
\endcode

\badcode
    #version 440
    layout(location = 0) in vec2 coord;
    layout(location = 0) out vec4 fragColor;
    layout(std140, binding = 0) uniform buf {
        mat4 qt_Matrix;
        float qt_Opacity;
    };
    layout(binding = 1) uniform sampler2D src;
    void main() {
        vec4 tex = texture(src, coord);
        fragColor = vec4(vec3(dot(tex.rgb, vec3(0.344, 0.5, 0.156))), tex.a) * qt_Opacity;
    }
\endcode

\note Scene Graph textures have origin in the top-left corner rather than
bottom-left which is common in OpenGL.

\section1 Having One Shader Only

Specifying both \l vertexShader and \l fragmentShader is not mandatory.
Many ShaderEffect implementations will want to provide a fragment shader
only in practice, while relying on the default, built-in vertex shader.

The default vertex shader passes the texture coordinate along to the
fragment shader as \c{vec2 qt_TexCoord0} at location \c 0.

The default fragment shader expects the texture coordinate to be passed
from the vertex shader as \c{vec2 qt_TexCoord0} at location \c 0, and it
samples from a sampler2D named \c source at binding point \c 1.

\warning When only one of the shaders is specified, the writer of the
shader must be aware of the uniform block layout expected by the default
shaders: qt_Matrix must always be at offset 0, followed by qt_Opacity at
offset 64. Any custom uniforms must be placed after these two. This is
mandatory even when the application-provided shader does not use the matrix
or the opacity, because at run time there is one single uniform buffer that
is exposed to both the vertex and fragment shader.

\warning Unlike with vertex inputs, passing data between the vertex and
fragment shader may, depending on the underlying graphics API, require the
same names to be used, a matching location is not always sufficient. Most
prominently, when specifying a fragment shader while relying on the default,
built-in vertex shader, the texture coordinates are passed on as \c
qt_TexCoord0 at location \c 0, and therefore it is strongly advised that the
fragment shader declares the input with the same name
(qt_TexCoord0). Failing to do so may lead to issues on some platforms, for
example when running with a non-core profile OpenGL context where the
underlying GLSL shader source code has no location qualifiers and matching
is based on the variable names during to shader linking process.

\section1 ShaderEffect and Item Layers

The ShaderEffect type can be combined with \l {Item Layers} {layered items}.

\table
\row
  \li \b {Layer with effect disabled} \inlineimage qml-shadereffect-nolayereffect.png
  \li \b {Layer with effect enabled} \inlineimage qml-shadereffect-layereffect.png
\row
  \li \qml
      Item {
          id: layerRoot
          layer.enabled: true
          layer.effect: ShaderEffect {
             fragmentShader: "effect.frag.qsb"
          }
      }
      \endqml

      \badcode
      #version 440
      layout(location = 0) in vec2 qt_TexCoord0;
      layout(location = 0) out vec4 fragColor;
      layout(std140, binding = 0) uniform buf {
          mat4 qt_Matrix;
          float qt_Opacity;
      };
      layout(binding = 1) uniform sampler2D source;
      void main() {
          vec4 p = texture(source, qt_TexCoord0);
          float g = dot(p.xyz, vec3(0.344, 0.5, 0.156));
          fragColor = vec4(g, g, g, p.a) * qt_Opacity;
      }
      \endcode
\endtable

It is also possible to combine multiple layered items:

\table
\row
  \li \inlineimage qml-shadereffect-opacitymask.png
\row
  \li \qml
      Rectangle {
          id: gradientRect;
          width: 10
          height: 10
          gradient: Gradient {
              GradientStop { position: 0; color: "white" }
              GradientStop { position: 1; color: "steelblue" }
          }
          visible: false; // should not be visible on screen.
          layer.enabled: true;
          layer.smooth: true
       }
       Text {
          id: textItem
          font.pixelSize: 48
          text: "Gradient Text"
          anchors.centerIn: parent
          layer.enabled: true

This item should be used as the 'mask' layer.samplerName: "maskSource" layer.effect: ShaderEffect { property var colorSource: gradientRect; fragmentShader: "mask.frag.qsb" } } \endqml

\badcode #version 440 layout(location = 0) in vec2 qt_TexCoord0; layout(location = 0) out vec4 fragColor; layout(std140, binding = 0) uniform buf { mat4 qt_Matrix; float qt_Opacity; }; layout(binding = 1) uniform sampler2D colorSource; layout(binding = 2) uniform sampler2D maskSource; void main() { fragColor = texture(colorSource, qt_TexCoord0) texture(maskSource, qt_TexCoord0).a qt_Opacity; } \endtable

Typedef Documentation

add_const_if_t

template<typename T, bool Predicate>

using QtPrivate::add_const_if_t = std::conditional_t<Predicate, std::add_const_t<T>, T>

Definition at line 61 of file qaudiobuffer_support_p.h.

ArgumentType

template<class T>

using QtPrivate::ArgumentType = typename Argument<T>::Type

Definition at line 56 of file qtconcurrentfunctionwrappers.h.

ArrayType

template<typename ManualType, typename... Types>

using QtPrivate::ArrayType

Initial value:

 std::array<typename ArrayTypeHelper<ManualType, Types...>::type,
                             sizeof...(Types)>

Definition at line 51 of file qmakearray_p.h.

CompactStorage

template<typename Object, typename Tag = void>

using QtPrivate::CompactStorage

Initial value:

 typename std::conditional_t<
        std::conjunction_v<
            std::is_empty<Object>,
            std::negation<std::is_final<Object>>
        >,
        detail::StorageEmptyBaseClassOptimization<Object, Tag>,
        detail::StorageByValue<Object, Tag>
    >

Definition at line 62 of file qfunctionaltools_impl.h.

CompareUnderlyingType

using QtPrivate::CompareUnderlyingType = qint8

Definition at line 26 of file qcompare.h.

EnableForNonVoid

template<class T>

using QtPrivate::EnableForNonVoid = std::enable_if_t<!std::is_same_v<T, void>>

Definition at line 61 of file qfuture_impl.h.

EnableForVoid

template<class T>

using QtPrivate::EnableForVoid = std::enable_if_t<std::is_same_v<T, void>>

Definition at line 58 of file qfuture_impl.h.

EnableIfInvocable

template<class Class, class Callable>

using QtPrivate::EnableIfInvocable

Initial value:

 std::enable_if_t<
        QtPrivate::ArgResolver<Callable>::template CanInvokeWithArgs<Class, Callable>>

Definition at line 250 of file qfuture_impl.h.

EnableIfSameOrConvertible

template<class T, class U>

using QtPrivate::EnableIfSameOrConvertible = std::enable_if_t<std::is_convertible_v<T, U>>

Definition at line 20 of file qpromise.h.

FilterLastPrivateSignalArg

template<class Arg, class... Args>

using QtPrivate::FilterLastPrivateSignalArg

Initial value:

 
        std::conditional_t<(sizeof...(Args) > 0),
                           std::invoke_result_t<decltype(createTuple<Arg, Args...>), Arg, Args...>,
                           std::conditional_t<IsPrivateSignalArg<Arg>, void, Arg>>

Definition at line 137 of file qfuture_impl.h.

FirstAndSecondTest

template<typename Iterator>

using QtPrivate::FirstAndSecondTest

Initial value:

 decltype(
    (*std::declval<Iterator &>()).first,
    (*std::declval<Iterator &>()).second
)

Definition at line 301 of file qcontainertools_impl.h.

FunctionStorage

template<typename Func>

using QtPrivate::FunctionStorage = QtPrivate::CompactStorage<Func>

Definition at line 248 of file qobject_p.h.

HasInputIterator

template<class Sequence>

using QtPrivate::HasInputIterator

Initial value:

 
        std::is_convertible<typename std::iterator_traits<std::decay_t<decltype(
                                    std::begin(std::declval<Sequence>()))>>::iterator_category,
                            std::input_iterator_tag>

Definition at line 283 of file qfuture_impl.h.

if_volatile

template<typename T>

using QtPrivate::if_volatile = std::enable_if_t<std::is_volatile_v<T>, bool>

Definition at line 24 of file qvolatile_p.h.

IfAssociativeIteratorHasFirstAndSecond

template<typename Iterator>

using QtPrivate::IfAssociativeIteratorHasFirstAndSecond

Initial value:

 
    std::enable_if_t<
        std::conjunction_v<
            std::negation<qxp::is_detected<KeyAndValueTest, Iterator>>,
            qxp::is_detected<FirstAndSecondTest, Iterator>
        >, bool>

Definition at line 311 of file qcontainertools_impl.h.

IfAssociativeIteratorHasKeyAndValue

template<typename Iterator>

using QtPrivate::IfAssociativeIteratorHasKeyAndValue

Initial value:

 
    std::enable_if_t<qxp::is_detected_v<KeyAndValueTest, Iterator>, bool>

Definition at line 307 of file qcontainertools_impl.h.

IfIsForwardIterator

template<typename Iterator>

using QtPrivate::IfIsForwardIterator

Initial value:

 typename std::enable_if<
    std::is_convertible<typename std::iterator_traits<Iterator>::iterator_category, std::forward_iterator_tag>::value,
    bool>::type

Definition at line 270 of file qcontainertools_impl.h.

IfIsInputIterator

template<typename Iterator>

using QtPrivate::IfIsInputIterator

Initial value:

 typename std::enable_if<
    std::is_convertible<typename std::iterator_traits<Iterator>::iterator_category, std::input_iterator_tag>::value,
    bool>::type

Definition at line 265 of file qcontainertools_impl.h.

IfIsNotConvertible

template<typename T, typename U>

using QtPrivate::IfIsNotConvertible = typename std::enable_if<!std::is_convertible<T, U>::value, bool>::type

Definition at line 332 of file qcontainertools_impl.h.

IfIsNotForwardIterator

template<typename Iterator>

using QtPrivate::IfIsNotForwardIterator

Initial value:

 typename std::enable_if<
    !std::is_convertible<typename std::iterator_traits<Iterator>::iterator_category, std::forward_iterator_tag>::value,
    bool>::type

Definition at line 275 of file qcontainertools_impl.h.

IfIsNotSame

template<typename T, typename U>

using QtPrivate::IfIsNotSame

Initial value:

 
    typename std::enable_if<!std::is_same<T, U>::value, bool>::type

Definition at line 328 of file qcontainertools_impl.h.

IfIteratorCanMoveBackwards

template<typename Iterator>

using QtPrivate::IfIteratorCanMoveBackwards

Initial value:

 
    std::enable_if_t<qxp::is_detected_v<MoveBackwardsTest, Iterator>, bool>

Definition at line 324 of file qcontainertools_impl.h.

IsCompatibleChar32Type

template<typename Char>

using QtPrivate::IsCompatibleChar32Type = IsCompatibleChar32TypeHelper<q20::remove_cvref_t<Char>>

Definition at line 60 of file qstring.h.

IsCompatibleChar32TypeHelper

template<typename Char>

using QtPrivate::IsCompatibleChar32TypeHelper

Initial value:

 
    std::is_same<Char, char32_t>

Definition at line 57 of file qstring.h.

IsCompatibleChar8Type

template<typename Char>

using QtPrivate::IsCompatibleChar8Type = IsCompatibleChar8TypeHelper<q20::remove_cvref_t<Char>>

Definition at line 35 of file qutf8stringview.h.

IsCompatibleChar8TypeHelper

template<typename Char>

using QtPrivate::IsCompatibleChar8TypeHelper

Initial value:

 std::disjunction<
 
 
 
        std::is_same<Char, char>,
        std::is_same<Char, uchar>,
        std::is_same<Char, signed char>
    >

Definition at line 26 of file qutf8stringview.h.

IsCompatiblePointer8

template<typename Pointer>

using QtPrivate::IsCompatiblePointer8 = IsCompatiblePointer8Helper<q20::remove_cvref_t<Pointer>>

Definition at line 43 of file qutf8stringview.h.

IsForwardIterable

template<class Iterator>

using QtPrivate::IsForwardIterable

Initial value:

 
        std::is_convertible<typename std::iterator_traits<Iterator>::iterator_category,
                            std::forward_iterator_tag>

Definition at line 289 of file qfuture_impl.h.

isInvocable

template<class Callable, class Sequence>

using QtPrivate::isInvocable = std::is_invocable<Callable, typename std::decay_t<Sequence>::value_type>

Definition at line 124 of file qtconcurrentfunctionwrappers.h.

isQFuture

template<class T>

using QtPrivate::isQFuture = std::bool_constant<isQFutureV<T>>

Definition at line 260 of file qfuture_impl.h.

IsRandomAccessible

template<class Sequence>

using QtPrivate::IsRandomAccessible

Initial value:

 
        std::is_convertible<typename std::iterator_traits<std::decay_t<decltype(
                                    std::begin(std::declval<Sequence>()))>>::iterator_category,
                            std::random_access_iterator_tag>

Definition at line 277 of file qfuture_impl.h.

IsRealGadget

template<typename T>

using QtPrivate::IsRealGadget = std::bool_constant<IsGadgetHelper<T>::IsRealGadget>

Definition at line 958 of file qmetatype.h.

IsUntypedPropertyData

template<typename T>

using QtPrivate::IsUntypedPropertyData = std::enable_if_t<std::is_base_of_v<QUntypedPropertyData, T>, bool>

Definition at line 128 of file qpropertyprivate.h.

KeyAndValueTest

template<typename Iterator>

using QtPrivate::KeyAndValueTest

Initial value:

 decltype(
    std::declval<Iterator &>().key(),
    std::declval<Iterator &>().value()
)

Definition at line 295 of file qcontainertools_impl.h.

MapResultType

template<class T, class MapFunctor>

using QtPrivate::MapResultType = typename MapResult<T, MapFunctor>::Type

Definition at line 67 of file qtconcurrentfunctionwrappers.h.

MoveBackwardsTest

template<typename Iterator>

using QtPrivate::MoveBackwardsTest

Initial value:

 decltype(
    std::declval<Iterator &>().operator--()
)

Definition at line 319 of file qcontainertools_impl.h.

NonConstMetaTypeInterface

using QtPrivate::NonConstMetaTypeInterface = QMetaTypeInterface

Definition at line 265 of file qmetatype.h.

NotEmpty

template<class... Args>

using QtPrivate::NotEmpty = std::bool_constant<(sizeof...(Args) > 0)>

Definition at line 274 of file qfuture_impl.h.

QAutoResetEvent

using QtPrivate::QAutoResetEvent = QAutoResetEventPipe

Definition at line 54 of file qautoresetevent_p.h.

QHashCombine

using QtPrivate::QHashCombine = QHashCombiner<QHashCombineMixer>

Definition at line 348 of file qhashfunctions.h.

QHashCombineCommutative

using QtPrivate::QHashCombineCommutative = QHashCombiner<QHashCombineCommutativeMixer>

Definition at line 360 of file qhashfunctions.h.

QHashCombineCommutativeWithSeed

using QtPrivate::QHashCombineCommutativeWithSeed = QHashCombinerWithSeed<QHashCombineCommutativeMixer>

Definition at line 361 of file qhashfunctions.h.

QHashCombiner

template<typename Mixer>

using QtPrivate::QHashCombiner = QHashCombinerWithSeed<Mixer>

Definition at line 336 of file qhashfunctions.h.

QHashCombineWithSeed

using QtPrivate::QHashCombineWithSeed = QHashCombinerWithSeed<QHashCombineMixer>

Definition at line 349 of file qhashfunctions.h.

QHashMultiReturnType

template<typename... T>

using QtPrivate::QHashMultiReturnType

Initial value:

 decltype(
    std::declval< std::enable_if_t<(sizeof...(T) > 0)> >(),
    (qHash(std::declval<const T &>(), size_t(0)), ...),
    size_t{}
)

Definition at line 364 of file qhashfunctions.h.

QPropertyBindingWrapper

using QtPrivate::QPropertyBindingWrapper = bool(*)(QMetaType, QUntypedPropertyData *dataPtr, QPropertyBindingFunction)

Definition at line 219 of file qpropertyprivate.h.

QPropertyObserverCallback

using QtPrivate::QPropertyObserverCallback = void (*)(QUntypedPropertyData *)

Definition at line 218 of file qpropertyprivate.h.

SlotObjUniquePtr

using QtPrivate::SlotObjUniquePtr

Initial value:

 std::unique_ptr<QSlotObjectBase,
                                             QSlotObjectBase::Deleter>

Definition at line 481 of file qobjectdefs_impl.h.

wrapped_t

template<typename Tag, typename Result>

using QtPrivate::wrapped_t = typename wrapped<Tag, Result>::type

Definition at line 27 of file qanystringview.h.

Enumeration Type Documentation

LegacyUncomparable

enum class QtPrivate::LegacyUncomparable : CompareUnderlyingType

strong

Enumerator
Unordered

Definition at line 675 of file qcompare.h.

Mutability

enum class QtPrivate::Mutability

strong

Enumerator
Mutable
Immutable

Definition at line 25 of file qaudiobuffer_support_p.h.

Ordering

enum class QtPrivate::Ordering : CompareUnderlyingType

strong

Enumerator
Equal
Equivalent
Less
Greater

Definition at line 30 of file qcompare.h.

Uncomparable

enum class QtPrivate::Uncomparable : CompareUnderlyingType

strong

Enumerator
Unordered

Definition at line 38 of file qcompare.h.

WakeMode

enum class QtPrivate::WakeMode

strong

Enumerator
One
All

Definition at line 25 of file qatomicwait_p.h.

Function Documentation

_q_atomicWait()

void QtPrivate::_q_atomicWait ( const void * address, const void * old, qsizetype size )

noexcept

Definition at line 138 of file qatomicwait.cpp.

References atomicLocks(), QT_BEGIN_NAMESPACE::QAtomicWaitLocks::Lock::cond, QT_BEGIN_NAMESPACE::QAtomicWaitLocks::contendedWatchAddress(), QT_BEGIN_NAMESPACE::QAtomicWaitLocks::lockFor(), and QT_BEGIN_NAMESPACE::QAtomicWaitLocks::Lock::watchedAddress.

Here is the call graph for this function:

_q_atomicWake()

void QtPrivate::_q_atomicWake ( void * address, WakeMode mode )

noexcept

Definition at line 163 of file qatomicwait.cpp.

References atomicLocks(), QT_BEGIN_NAMESPACE::QAtomicWaitLocks::Lock::cond, QT_BEGIN_NAMESPACE::QAtomicWaitLocks::lockFor(), One, and QT_BEGIN_NAMESPACE::QAtomicWaitLocks::Lock::watchedAddress.

Here is the call graph for this function:

addCompletionHandlers()

template<typename ContextType, typename... Ts>

void QtPrivate::addCompletionHandlers	(	const std::shared_ptr< ContextType > &	context,
		const std::tuple< Ts... > &	t )

Definition at line 1116 of file qfuture_impl.h.

addCompletionHandlersImpl()

template<qsizetype Index, typename ContextType, typename... Ts>

void QtPrivate::addCompletionHandlersImpl	(	const std::shared_ptr< ContextType > &	context,
		const std::tuple< Ts... > &	t )

Definition at line 1099 of file qfuture_impl.h.

applyIndexSwitch() [1/2]

template<size_t IndexCount, typename Applier>

void QtPrivate::applyIndexSwitch	(	size_t	index,
		Applier &&	applier )

Definition at line 49 of file qrangemodel_impl.h.

applyIndexSwitch() [2/2]

template<typename Applier, size_t ... Is>

void QtPrivate::applyIndexSwitch	(	size_t	index,
		Applier &&	applier,
		std::index_sequence< Is... >	)

Definition at line 37 of file qrangemodel_impl.h.

argToQString()

QString QtPrivate::argToQString ( QAnyStringView pattern, size_t n, const ArgBase ** args )

nodiscard

Definition at line 9209 of file qstring.cpp.

References asString().

Here is the call graph for this function:

argToQStringDispatch()

template<typename... Args>

Q_ALWAYS_INLINE QString QtPrivate::argToQStringDispatch ( QAnyStringView pattern, const Args &... args )

nodiscard

Definition at line 1736 of file qstring.h.

AssertCompatibleFunctions()

template<typename Prototype, typename Functor>

bool QtPrivate::AssertCompatibleFunctions ( )

inlineconstexpr

Definition at line 630 of file qobjectdefs_impl.h.

assertObjectType() [1/2]

template<typename Obj>

void QtPrivate::assertObjectType ( QObject * o )

inline

Definition at line 94 of file qobjectdefs_impl.h.

assertObjectType() [2/2]

template<typename ObjPrivate>

void QtPrivate::assertObjectType ( QObjectPrivate * d )

inline

Definition at line 250 of file qobject_p.h.

associative_erase_if()

template<typename Container, typename Predicate>

auto QtPrivate::associative_erase_if	(	Container &	c,
		Predicate &	pred )

Definition at line 430 of file qcontainertools_impl.h.

asString() [1/4]

QString QtPrivate::asString ( const QHashedCStringRef & ref )

inline

Definition at line 436 of file qhashedstring_p.h.

asString() [2/4]

QString QtPrivate::asString ( const QHashedStringRef & ref )

inline

Definition at line 437 of file qhashedstring_p.h.

asString() [3/4]

const QString & QtPrivate::asString ( const QString & s )

inline

Definition at line 1680 of file qstring.h.

Referenced by CPP::WriteInitialization::acceptActionRef(), CPP::WriteInitialization::acceptConnection(), CPP::WriteInitialization::acceptTabStops(), argToQString(), Python::WriteImports::doAdd(), openFile(), openFile(), parseProvider(), parseTracepoint(), printErr(), printOut(), runRcc(), uiLibWarning(), and Uic::write().

Here is the caller graph for this function:

asString() [4/4]

QString && QtPrivate::asString ( QString && s )

inline

Definition at line 1681 of file qstring.h.

channelConfig()

template<typename... Args>

int QtPrivate::channelConfig ( Args... values )

constexpr

Definition at line 17 of file qaudioformat.h.

checkTypeIsSuitableForMetaType()

template<typename X>

constexpr bool QtPrivate::checkTypeIsSuitableForMetaType ( )

staticconstexpr

Definition at line 1202 of file qmetatype.h.

compareMemory()

int QtPrivate::compareMemory ( QByteArrayView lhs, QByteArrayView rhs )

nodiscard

Definition at line 414 of file qbytearray.cpp.

compareStrings() [1/9]

Q_CORE_EXPORT Q_DECL_PURE_FUNCTION int QtPrivate::compareStrings ( QBasicUtf8StringView< false > lhs, QBasicUtf8StringView< false > rhs, Qt::CaseSensitivity cs = Qt::CaseSensitive )

related

compareStrings() [2/9]

Q_CORE_EXPORT Q_DECL_PURE_FUNCTION int QtPrivate::compareStrings ( QBasicUtf8StringView< false > lhs, QLatin1StringView rhs, Qt::CaseSensitivity cs = Qt::CaseSensitive )

related

compareStrings() [3/9]

Q_CORE_EXPORT Q_DECL_PURE_FUNCTION int QtPrivate::compareStrings ( QBasicUtf8StringView< false > lhs, QStringView rhs, Qt::CaseSensitivity cs = Qt::CaseSensitive )

related

compareStrings() [4/9]

Q_CORE_EXPORT Q_DECL_PURE_FUNCTION int QtPrivate::compareStrings ( QLatin1StringView lhs, QBasicUtf8StringView< false > rhs, Qt::CaseSensitivity cs = Qt::CaseSensitive )

related

compareStrings() [5/9]

Q_CORE_EXPORT Q_DECL_PURE_FUNCTION int QtPrivate::compareStrings ( QLatin1StringView lhs, QLatin1StringView rhs, Qt::CaseSensitivity cs = Qt::CaseSensitive )

related

compareStrings() [6/9]

Q_CORE_EXPORT Q_DECL_PURE_FUNCTION int QtPrivate::compareStrings ( QLatin1StringView lhs, QStringView rhs, Qt::CaseSensitivity cs = Qt::CaseSensitive )

related

compareStrings() [7/9]

Q_CORE_EXPORT Q_DECL_PURE_FUNCTION int QtPrivate::compareStrings ( QStringView lhs, QBasicUtf8StringView< false > rhs, Qt::CaseSensitivity cs = Qt::CaseSensitive )

related

compareStrings() [8/9]

Q_CORE_EXPORT Q_DECL_PURE_FUNCTION int QtPrivate::compareStrings ( QStringView lhs, QLatin1StringView rhs, Qt::CaseSensitivity cs = Qt::CaseSensitive )

related

compareStrings() [9/9]

Q_CORE_EXPORT Q_DECL_PURE_FUNCTION int QtPrivate::compareStrings ( QStringView lhs, QStringView rhs, Qt::CaseSensitivity cs = Qt::CaseSensitive )

related

convertImplicit()

template<typename From, typename To>

To QtPrivate::convertImplicit

(

const From &

from

)

This template is used for implicit conversion from type From to type To.

Definition at line 321 of file qmetatype.h.

convertToLatin1()

Q_CORE_EXPORT QByteArray QtPrivate::convertToLatin1 ( QStringView str )

related

convertToLocal8Bit()

Q_CORE_EXPORT QByteArray QtPrivate::convertToLocal8Bit ( QStringView str )

related

convertToQString()

Q_CORE_EXPORT QString QtPrivate::convertToQString ( QAnyStringView s )

related

convertToUcs4()

Q_CORE_EXPORT QList< uint > QtPrivate::convertToUcs4 ( QStringView str )

related

convertToUtf8() [1/2]

Q_CORE_EXPORT QByteArray QtPrivate::convertToUtf8 ( QLatin1StringView str )

nodiscard

convertToUtf8() [2/2]

Q_CORE_EXPORT QByteArray QtPrivate::convertToUtf8 ( QStringView str )

related

copy()

SlotObjUniquePtr QtPrivate::copy ( const SlotObjUniquePtr & other )

inlinenoexcept

Definition at line 483 of file qobjectdefs_impl.h.

count() [1/7]

qsizetype QtPrivate::count ( QByteArrayView haystack, QByteArrayView needle )

nodiscardnoexcept

Definition at line 2889 of file qbytearray.cpp.

count() [2/7]

qsizetype QtPrivate::count ( QLatin1StringView haystack, QChar needle, Qt::CaseSensitivity cs = Qt::CaseSensitive )

nodiscardnoexcept

Definition at line 9766 of file qstring.cpp.

References QtPrivate::QCaseInsensitiveLatin1Hash::matcher().

Here is the call graph for this function:

count() [3/7]

qsizetype QtPrivate::count ( QLatin1StringView haystack, QLatin1StringView needle, Qt::CaseSensitivity cs = Qt::CaseSensitive )

nodiscard

Definition at line 9723 of file qstring.cpp.

count() [4/7]

qsizetype QtPrivate::count ( QLatin1StringView haystack, QStringView needle, Qt::CaseSensitivity cs = Qt::CaseSensitive )

nodiscard

Definition at line 9735 of file qstring.cpp.

count() [5/7]

qsizetype QtPrivate::count ( QStringView haystack, QChar needle, Qt::CaseSensitivity cs = Qt::CaseSensitive )

nodiscardnoexcept

Definition at line 9713 of file qstring.cpp.

count() [6/7]

qsizetype QtPrivate::count ( QStringView haystack, QLatin1StringView needle, Qt::CaseSensitivity cs = Qt::CaseSensitive )

nodiscard

Definition at line 9757 of file qstring.cpp.

count() [7/7]

qsizetype QtPrivate::count ( QStringView haystack, QStringView needle, Qt::CaseSensitivity cs = Qt::CaseSensitive )

nodiscardnoexcept

Definition at line 9698 of file qstring.cpp.

countMatchingArguments()

template<typename Prototype, typename Functor>

std::enable_if_t<!std::disjunction_v< std::is_convertible< Prototype, const char * >, std::is_same< std::decay_t< Prototype >, QMetaMethod >, std::is_convertible< Functor, const char * >, std::is_same< std::decay_t< Functor >, QMetaMethod > >, int > QtPrivate::countMatchingArguments ( )

inlineconstexpr

Definition at line 398 of file qobjectdefs_impl.h.

createTuple()

template<class Arg, class... Args>

auto QtPrivate::createTuple	(	Arg &&	arg,
		Args &&...	args )

Definition at line 118 of file qfuture_impl.h.

cutTuple()

template<class Tuple, std::size_t... I>

auto QtPrivate::cutTuple	(	Tuple &&	t,
		std::index_sequence< I... >	)

Definition at line 112 of file qfuture_impl.h.

deref_for_methodcall() [1/2]

QObject & QtPrivate::deref_for_methodcall ( QObject & o )

inline

Definition at line 563 of file qobject.h.

deref_for_methodcall() [2/2]

QObject & QtPrivate::deref_for_methodcall ( QObject * o )

inline

Definition at line 564 of file qobject.h.

endsWith() [1/5]

bool QtPrivate::endsWith ( QByteArrayView haystack, QByteArrayView needle )

nodiscardnoexcept

Definition at line 2982 of file qbytearray.cpp.

endsWith() [2/5]

bool QtPrivate::endsWith ( QLatin1StringView haystack, QLatin1StringView needle, Qt::CaseSensitivity cs = Qt::CaseSensitive )

related

Definition at line 9855 of file qstring.cpp.

endsWith() [3/5]

bool QtPrivate::endsWith ( QLatin1StringView haystack, QStringView needle, Qt::CaseSensitivity cs = Qt::CaseSensitive )

nodiscardnoexcept

Since

5.10

Definition at line 9850 of file qstring.cpp.

endsWith() [4/5]

bool QtPrivate::endsWith ( QStringView haystack, QLatin1StringView needle, Qt::CaseSensitivity cs = Qt::CaseSensitive )

nodiscardnoexcept

Since

5.10

Definition at line 9845 of file qstring.cpp.

endsWith() [5/5]

bool QtPrivate::endsWith ( QStringView haystack, QStringView needle, Qt::CaseSensitivity cs = Qt::CaseSensitive )

nodiscardnoexcept

Since

5.10

Definition at line 9840 of file qstring.cpp.

equalStrings() [1/9]

bool QtPrivate::equalStrings ( QBasicUtf8StringView< false > lhs, QBasicUtf8StringView< false > rhs )

nodiscardnoexcept

Definition at line 1419 of file qstring.cpp.

equalStrings() [2/9]

bool QtPrivate::equalStrings ( QBasicUtf8StringView< false > lhs, QLatin1StringView rhs )

nodiscardnoexcept

Definition at line 1414 of file qstring.cpp.

equalStrings() [3/9]

bool QtPrivate::equalStrings ( QBasicUtf8StringView< false > lhs, QStringView rhs )

nodiscardnoexcept

Definition at line 1399 of file qstring.cpp.

equalStrings() [4/9]

bool QtPrivate::equalStrings ( QLatin1StringView lhs, QBasicUtf8StringView< false > rhs )

nodiscardnoexcept

Definition at line 1409 of file qstring.cpp.

equalStrings() [5/9]

bool QtPrivate::equalStrings ( QLatin1StringView lhs, QLatin1StringView rhs )

nodiscardnoexcept

Definition at line 1393 of file qstring.cpp.

equalStrings() [6/9]

bool QtPrivate::equalStrings ( QLatin1StringView lhs, QStringView rhs )

nodiscardnoexcept

Definition at line 1388 of file qstring.cpp.

equalStrings() [7/9]

bool QtPrivate::equalStrings ( QStringView lhs, QBasicUtf8StringView< false > rhs )

nodiscardnoexcept

Definition at line 1404 of file qstring.cpp.

equalStrings() [8/9]

bool QtPrivate::equalStrings ( QStringView lhs, QLatin1StringView rhs )

nodiscardnoexcept

Definition at line 1382 of file qstring.cpp.

equalStrings() [9/9]

bool QtPrivate::equalStrings ( QStringView lhs, QStringView rhs )

nodiscardnoexcept

Definition at line 1376 of file qstring.cpp.

expectedAllocSize()

QT_BEGIN_NAMESPACE size_t QtPrivate::expectedAllocSize ( size_t allocSize, size_t alignment )

noexcept

Returns

the size that would be allocated for the given request.

Computes the actual allocation size for allocSize and alignment, as determined by the active allocator, without performing the allocation.

In practice, it only returns nonzero when using jemalloc.

Definition at line 17 of file qalloc.cpp.

findByteArray() [1/2]

qsizetype QtPrivate::findByteArray ( QByteArrayView haystack, qsizetype from, char needle )

inlinenodiscardnoexcept

Definition at line 407 of file qbytearrayview.h.

findByteArray() [2/2]

qsizetype QtPrivate::findByteArray ( QByteArrayView haystack, qsizetype from, QByteArrayView needle )

nodiscardnoexcept

Definition at line 242 of file qbytearraymatcher.cpp.

findResult()

ResultIteratorBase QtPrivate::findResult ( const QMap< int, ResultItem > & store, int index )

static

Finds result in store by index

Definition at line 16 of file qresultstore.cpp.

findString() [1/5]

qsizetype QtPrivate::findString ( QLatin1StringView haystack, qsizetype from, QLatin1StringView needle, Qt::CaseSensitivity cs = Qt::CaseSensitive )

nodiscardnoexcept

Definition at line 9961 of file qstring.cpp.

References QtPrivate::QCaseInsensitiveLatin1Hash::matcher().

Here is the call graph for this function:

findString() [2/5]

qsizetype QtPrivate::findString ( QLatin1StringView haystack, qsizetype from, QStringView needle, Qt::CaseSensitivity cs = Qt::CaseSensitive )

nodiscardnoexcept

Definition at line 9943 of file qstring.cpp.

findString() [3/5]

qsizetype QtPrivate::findString ( QStringView haystack, qsizetype from, QLatin1StringView needle, Qt::CaseSensitivity cs = Qt::CaseSensitive )

nodiscardnoexcept

Definition at line 9934 of file qstring.cpp.

findString() [4/5]

qsizetype QtPrivate::findString ( QStringView haystack, qsizetype from, QStringView needle, Qt::CaseSensitivity cs = Qt::CaseSensitive )

nodiscardnoexcept

Definition at line 9860 of file qstring.cpp.

findString() [5/5]

qsizetype QtPrivate::findString ( QStringView str, qsizetype from, QChar needle, Qt::CaseSensitivity cs = Qt::CaseSensitive )

inlinenodiscardnoexcept

Definition at line 548 of file qstringview.h.

References QStringView::utf16().

Here is the call graph for this function:

fittedAllocSize()

size_t QtPrivate::fittedAllocSize ( size_t headerSize, size_t * capacity, size_t elementSize, size_t unusedCapacity, size_t alignment )

inlinenoexcept

Computes the best allocation size for the requested minimum capacity, and updates capacity.

Computes the allocation size starting from headerSize and a requested minimum capacity in capacity, multiplied by the elementSize and adjusted by the unusedCapacity. The final capacity is written back into capacity. The headerSize and unusedCapacity values are not included in the final reported capacity.

Definition at line 50 of file qalloc.h.

fittedMalloc() [1/2]

void * QtPrivate::fittedMalloc ( size_t headerSize, qsizetype * capacity, size_t elementSize, size_t unusedCapacity = 0 )

inlinenoexcept

Definition at line 90 of file qalloc.h.

fittedMalloc() [2/2]

void * QtPrivate::fittedMalloc ( size_t headerSize, size_t * capacity, size_t elementSize, size_t unusedCapacity )

inlinenoexcept

Definition at line 80 of file qalloc.h.

fittedRealloc() [1/2]

void * QtPrivate::fittedRealloc ( void * ptr, size_t headerSize, qsizetype * capacity, size_t elementSize, size_t unusedCapacity = 0 )

inlinenoexcept

Definition at line 114 of file qalloc.h.

fittedRealloc() [2/2]

void * QtPrivate::fittedRealloc ( void * ptr, size_t headerSize, size_t * capacity, size_t elementSize, size_t unusedCapacity )

inlinenoexcept

Definition at line 99 of file qalloc.h.

Forward() [1/2]

template<typename T>

T && QtPrivate::Forward ( typename std::remove_reference< T >::type && t )

constexprnoexcept

Definition at line 34 of file qmakearray_p.h.

Forward() [2/2]

template<typename T>

T && QtPrivate::Forward ( typename std::remove_reference< T >::type & t )

constexprnoexcept

Definition at line 28 of file qmakearray_p.h.

fulfillPromise() [1/2]

template<class T, class Function>

void QtPrivate::fulfillPromise	(	QPromise< T > &	promise,
		Function &&	handler )

Definition at line 663 of file qfuture_impl.h.

fulfillPromise() [2/2]

template<class T>

void QtPrivate::fulfillPromise	(	QPromise< T > &	promise,
		QFuture< T > &	future )

Definition at line 652 of file qfuture_impl.h.

getBindingStatus()

QBindingStatus * QtPrivate::getBindingStatus

(

QtPrivate::QBindingStatusAccessToken

)

Returns the binding statusof the current thread.

Definition at line 2497 of file qproperty.cpp.

References QtPrivate::QPropertyAdaptorSlotObject::QT_PREPEND_NAMESPACE.

Here is the call graph for this function:

getQObject()

const QObject * QtPrivate::getQObject ( const QObjectPrivate * d )

inline

Definition at line 245 of file qobject_p.h.

hasRegisteredConverterFunctionToIterableMetaAssociation()

bool QtPrivate::hasRegisteredConverterFunctionToIterableMetaAssociation

(

QMetaType

m

)

Non-template helper ("SCARY") for AssociativeKeyTypeIsMetaType::registerConverter().

Definition at line 2770 of file qmetatype.cpp.

hasRegisteredConverterFunctionToIterableMetaSequence()

bool QtPrivate::hasRegisteredConverterFunctionToIterableMetaSequence

(

QMetaType

m

)

Non-template helper ("SCARY") for SequentialValueTypeIsMetaType::registerConverter().

Definition at line 2760 of file qmetatype.cpp.

hasRegisteredConverterFunctionToPairVariantInterface()

bool QtPrivate::hasRegisteredConverterFunctionToPairVariantInterface

(

QMetaType

m

)

Non-template helper ("SCARY") for IsMetaTypePair::registerConverter().

Definition at line 2750 of file qmetatype.cpp.

hasRegisteredMutableViewFunctionToIterableMetaAssociation()

bool QtPrivate::hasRegisteredMutableViewFunctionToIterableMetaAssociation

(

QMetaType

m

)

Non-template helper ("SCARY") for AssociativeKeyTypeIsMetaType::registerMutableView().

Definition at line 2807 of file qmetatype.cpp.

hasRegisteredMutableViewFunctionToIterableMetaSequence()

bool QtPrivate::hasRegisteredMutableViewFunctionToIterableMetaSequence

(

QMetaType

m

)

Non-template helper ("SCARY") for SequentialValueTypeIsMetaType::registerMutableView().

Definition at line 2797 of file qmetatype.cpp.

indexOf() [1/2]

template<typename T, typename U>

qsizetype QtPrivate::indexOf ( const QList< T > & vector, const U & u, qsizetype from )

noexcept

Definition at line 984 of file qlist.h.

indexOf() [2/2]

template<typename V, typename U>

qsizetype QtPrivate::indexOf ( const QList< V > & list, const U & u, qsizetype from )

noexcept

initBindingStatusThreadId()

void QtPrivate::initBindingStatusThreadId

(

)

Definition at line 2425 of file qproperty.cpp.

intersect_path()

bool QtPrivate::intersect_path ( const QGraphicsItem * item, const QRectF & exposeRect, Qt::ItemSelectionMode mode, const QTransform & deviceTransform, const void * intersectData )

static

Definition at line 126 of file qgraphicssceneindex.cpp.

intersect_point()

bool QtPrivate::intersect_point ( const QGraphicsItem * item, const QRectF & exposeRect, Qt::ItemSelectionMode mode, const QTransform & deviceTransform, const void * intersectData )

static

Definition at line 84 of file qgraphicssceneindex.cpp.

intersect_rect()

bool QtPrivate::intersect_rect ( const QGraphicsItem * item, const QRectF & exposeRect, Qt::ItemSelectionMode mode, const QTransform & deviceTransform, const void * intersectData )

static

Definition at line 35 of file qgraphicssceneindex.cpp.

invokeMethodHelper()

template<typename... Args>

auto QtPrivate::invokeMethodHelper ( QMetaMethodReturnArgument r, const Args &... arguments )

inline

Definition at line 209 of file qobjectdefs.h.

References QMetaMethodReturnArgument::data, QMetaMethodReturnArgument::metaType, and QMetaMethodReturnArgument::name.

isAnyBindingEvaluating()

bool QtPrivate::isAnyBindingEvaluating

(

)

This function can be used to detect whether we are currently evaluating a binding. This can e.g. be used to defer the allocation of extra data for a QPropertyBindingStorage in a getter. Note that this function accesses TLS storage, and is therefore soemwhat costly to call.

Definition at line 2450 of file qproperty.cpp.

isAscii() [1/2]

bool QtPrivate::isAscii ( QLatin1StringView s )

nodiscardnoexcept

Definition at line 851 of file qstring.cpp.

References qt_is_ascii().

Here is the call graph for this function:

isAscii() [2/2]

bool QtPrivate::isAscii ( QStringView s )

nodiscardnoexcept

Definition at line 878 of file qstring.cpp.

References isAscii_helper().

Here is the call graph for this function:

isLatin1() [1/2]

bool QtPrivate::isLatin1 ( QLatin1StringView s )

inlinenodiscardconstexprnoexcept

Definition at line 77 of file qstring.h.

isLatin1() [2/2]

bool QtPrivate::isLatin1 ( QStringView s )

nodiscardnoexcept

Definition at line 886 of file qstring.cpp.

isLower()

bool QtPrivate::isLower ( QStringView s )

nodiscardnoexcept

Definition at line 5580 of file qstring.cpp.

isPropertyInBindingWrapper()

bool QtPrivate::isPropertyInBindingWrapper

(

const QUntypedPropertyData *

property

)

Definition at line 2455 of file qproperty.cpp.

isRightToLeft()

Q_CORE_EXPORT Q_DECL_PURE_FUNCTION bool QtPrivate::isRightToLeft ( QStringView string )

related

isUpper()

bool QtPrivate::isUpper ( QStringView s )

nodiscardnoexcept

Definition at line 5585 of file qstring.cpp.

isValidUtf16()

bool QtPrivate::isValidUtf16 ( QStringView s )

nodiscardnoexcept

Definition at line 906 of file qstring.cpp.

References QStringIterator::hasNext(), and QStringIterator::next().

Here is the call graph for this function:

isValidUtf8()

bool QtPrivate::isValidUtf8 ( QByteArrayView s )

nodiscardnoexcept

Definition at line 430 of file qbytearray.cpp.

lastIndexOf() [1/9]

template<typename T, typename U>

qsizetype QtPrivate::lastIndexOf ( const QList< T > & vector, const U & u, qsizetype from )

noexcept

Definition at line 999 of file qlist.h.

lastIndexOf() [2/9]

template<typename V, typename U>

qsizetype QtPrivate::lastIndexOf ( const QList< V > & list, const U & u, qsizetype from )

noexcept

lastIndexOf() [3/9]

qsizetype QtPrivate::lastIndexOf ( QByteArrayView haystack, qsizetype from, QByteArrayView needle )

nodiscardnoexcept

Definition at line 2812 of file qbytearray.cpp.

lastIndexOf() [4/9]

qsizetype QtPrivate::lastIndexOf ( QByteArrayView haystack, qsizetype from, uchar needle )

inlinenodiscardnoexcept

Definition at line 423 of file qbytearrayview.h.

lastIndexOf() [5/9]

qsizetype QtPrivate::lastIndexOf ( QLatin1StringView haystack, qsizetype from, QLatin1StringView needle, Qt::CaseSensitivity cs = Qt::CaseSensitive )

nodiscardnoexcept

Definition at line 10038 of file qstring.cpp.

lastIndexOf() [6/9]

qsizetype QtPrivate::lastIndexOf ( QLatin1StringView haystack, qsizetype from, QStringView needle, Qt::CaseSensitivity cs = Qt::CaseSensitive )

nodiscardnoexcept

Definition at line 10033 of file qstring.cpp.

lastIndexOf() [7/9]

qsizetype QtPrivate::lastIndexOf ( QStringView haystack, qsizetype from, char16_t needle, Qt::CaseSensitivity cs = Qt::CaseSensitive )

nodiscardnoexcept

Definition at line 10018 of file qstring.cpp.

lastIndexOf() [8/9]

qsizetype QtPrivate::lastIndexOf ( QStringView haystack, qsizetype from, QLatin1StringView needle, Qt::CaseSensitivity cs = Qt::CaseSensitive )

nodiscardnoexcept

Definition at line 10028 of file qstring.cpp.

lastIndexOf() [9/9]

qsizetype QtPrivate::lastIndexOf ( QStringView haystack, qsizetype from, QStringView needle, Qt::CaseSensitivity cs = Qt::CaseSensitive )

nodiscardnoexcept

Definition at line 10023 of file qstring.cpp.

legacyEnumValueFromModelData()

template<typename T>

T QtPrivate::legacyEnumValueFromModelData

(

const QVariant &

data

)

This is a workaround for QTBUG-75172.

Some predefined model roles are supposed to use certain enum/flag types (e.g. fetching Qt::TextAlignmentRole is supposed to return a variant containing a Qt::Alignment object).

For historical reasons, a plain int was used sometimes. This is surprising to end-users and also sloppy on Qt's part; users were forced to use int rather than the correct datatype.

This function tries both the "right" type and plain int, for a given QVariant. This fixes the problem (using the correct datatype) but also keeps compatibility with existing code using int.

Qt 7: get rid of this. Always use the correct datatype.

Definition at line 170 of file qabstractitemmodel_p.h.

legacyFlagValueFromModelData()

template<typename T>

T QtPrivate::legacyFlagValueFromModelData

(

const QVariant &

data

)

Definition at line 184 of file qabstractitemmodel_p.h.

lengthHelperContainer() [1/3]

template<typename Char, size_t N>

Q_ALWAYS_INLINE constexpr std::enable_if_t< sizeof(Char)==sizeof(char16_t), qsizetype > QtPrivate::lengthHelperContainer ( const Char(&) str[N] )

nodiscardconstexpr

Definition at line 154 of file qstringalgorithms.h.

lengthHelperContainer() [2/3]

template<typename Char, size_t N>

std::enable_if_t< sizeof(Char)==1, qsizetype > QtPrivate::lengthHelperContainer ( const Char(&) str[N] )

inlinenodiscardconstexpr

Definition at line 193 of file qstringalgorithms.h.

lengthHelperContainer() [3/3]

template<typename Container>

qsizetype QtPrivate::lengthHelperContainer ( const Container & c )

constexprnoexcept

Definition at line 204 of file qstringalgorithms.h.

lengthHelperContainerLoop()

template<typename Char, size_t N>

Q_ALWAYS_INLINE constexpr qsizetype QtPrivate::lengthHelperContainerLoop ( const Char(&) str[N] )

nodiscardconstexpr

Definition at line 134 of file qstringalgorithms.h.

lengthHelperPointer()

template<typename Char>

constexpr qsizetype QtPrivate::lengthHelperPointer ( const Char * data )

staticconstexprnoexcept

Definition at line 70 of file qbytearrayview.h.

log2i()

template<typename T>

std::enable_if_t< std::conjunction_v< std::is_integral< T >, std::is_unsigned< T > >, int > QtPrivate::log2i ( T x )

constexpr

Definition at line 135 of file qalgorithms.h.

makeCallableObject()

template<typename Prototype, typename Functor>

constexpr std::enable_if_t< QtPrivate::countMatchingArguments< Prototype, Functor >() >=0, QtPrivate::QSlotObjectBase * > QtPrivate::makeCallableObject ( Functor && func )

staticconstexpr

Definition at line 604 of file qobjectdefs_impl.h.

makeChannelView()

template<typename SampleType>

auto QtPrivate::makeChannelView	(	add_const_if_t< QAudioBuffer, std::is_const_v< SampleType > > &	buffer,
		int	channel )

Definition at line 64 of file qaudiobuffer_support_p.h.

makeCharacterSetMatch()

template<const char * Set, int ForcedLowest = -1>

auto QtPrivate::makeCharacterSetMatch ( )

inlineconstexprnoexcept

Definition at line 100 of file qlocale_p.h.

makeOffsetStringArray()

template<typename Char, int... Nx>

auto QtPrivate::makeOffsetStringArray ( const Char(&...entries)[Nx] )

constexpr

Definition at line 118 of file qoffsetstringarray_p.h.

makeReadyRangeFutureImpl()

template<typename ValueType>

QFuture< ValueType > QtPrivate::makeReadyRangeFutureImpl

(

const QList< ValueType > &

values

)

Definition at line 891 of file qfuture_impl.h.

min()

template<typename T>

const T & QtPrivate::min ( const T & a, const T & b )

inlineconstexpr

Definition at line 614 of file qnumeric.h.

minifyValue()

template<size_t Highest>

auto QtPrivate::minifyValue ( )

constexpr

Definition at line 103 of file qoffsetstringarray_p.h.

nextByteSize()

quint8 QtPrivate::nextByteSize ( quint8 bits )

constexpr

Definition at line 15 of file qtaggedpointer.h.

partiallyParsedDataCount()

int QtPrivate::partiallyParsedDataCount ( QStringConverter::State * state )

static

Definition at line 2498 of file qstringconverter.cpp.

printAssociativeContainer()

template<typename AssociativeContainer>

QDebug QtPrivate::printAssociativeContainer ( QDebug debug, const char * which, const AssociativeContainer & c )

inline

Definition at line 385 of file qdebug.h.

printSequentialContainer()

template<typename SequentialContainer>

QDebug QtPrivate::printSequentialContainer ( QDebug debug, const char * which, const SequentialContainer & c )

inline

Definition at line 367 of file qdebug.h.

pullFromQIODeviceToRingbuffer()

template<typename SampleType>

qsizetype QtPrivate::pullFromQIODeviceToRingbuffer	(	QIODevice &	device,
		QAudioRingBuffer< SampleType > &	ringbuffer )

Definition at line 185 of file qaudio_qiodevice_support_p.h.

pushToQIODeviceFromRingbuffer()

template<typename SampleType>

qsizetype QtPrivate::pushToQIODeviceFromRingbuffer	(	QIODevice &	device,
		QAudioRingBuffer< SampleType > &	ringbuffer )

Definition at line 211 of file qaudio_qiodevice_support_p.h.

Q_LOGGING_CATEGORY() [1/2]

QtPrivate::Q_LOGGING_CATEGORY	(	lcEventDispatcher	,
		"qt.eventdispatcher"	)

Q_LOGGING_CATEGORY() [2/2]

QtPrivate::Q_LOGGING_CATEGORY	(	lcEventDispatcherTimers	,
		"qt.eventdispatcher.timers"	)

q_points_into_range() [1/2]

template<typename C, typename T>

constexpr bool QtPrivate::q_points_into_range ( const T & p, const C & c )

staticconstexprnoexcept

Returns whether p is within container c. In its simplest form equivalent to: c.data() <= p < c.data() + c.size()

Definition at line 49 of file qcontainertools_impl.h.

q_points_into_range() [2/2]

template<typename T, typename Cmp = std::less<>>

constexpr bool QtPrivate::q_points_into_range ( const T * p, const T * b, const T * e, Cmp less = {} )

staticconstexprnoexcept

Returns whether p is within a range [b, e). In simplest form equivalent to: b <= p < e.

Definition at line 36 of file qcontainertools_impl.h.

q_relocate_overlap_n()

template<typename T, typename N>

void QtPrivate::q_relocate_overlap_n	(	T *	first,
		N	n,
		T *	d_first )

Relocates a range [first, n) to [d_first, n) taking care of potential memory overlaps. This is a generic equivalent of memmove.

If an exception is thrown during the relocation, all the relocated elements are destroyed and [first, n) may contain valid but unspecified values, including moved-from values (basic exception safety).

Definition at line 236 of file qcontainertools_impl.h.

q_relocate_overlap_n_left_move()

template<typename iterator, typename N>

void QtPrivate::q_relocate_overlap_n_left_move	(	iterator	first,
		N	n,
		iterator	d_first )

Definition at line 147 of file qcontainertools_impl.h.

q_rotate()

template<typename T>

QT_WARNING_POP void QtPrivate::q_rotate	(	T *	first,
		T *	mid,
		T *	last )

A wrapper around std::rotate(), with an optimization for Q_RELOCATABLE_TYPEs. We omit the return value, as it would be more work to compute in the Q_RELOCATABLE_TYPE case and, unlike std::rotate on ForwardIterators, callers can compute the result in constant time themselves.

Definition at line 101 of file qcontainertools_impl.h.

q_uninitialized_move_if_noexcept_n()

template<typename T, typename N>

QT_WARNING_PUSH void QtPrivate::q_uninitialized_move_if_noexcept_n	(	T *	first,
		N	n,
		T *	out )

Definition at line 63 of file qcontainertools_impl.h.

q_uninitialized_relocate_n()

template<typename T, typename N>

void QtPrivate::q_uninitialized_relocate_n	(	T *	first,
		N	n,
		T *	out )

Definition at line 72 of file qcontainertools_impl.h.

q_uninitialized_remove_copy_if()

template<typename T, typename Predicate>

T * QtPrivate::q_uninitialized_remove_copy_if	(	T *	first,
		T *	last,
		T *	out,
		Predicate &	pred )

Copies all elements, except the ones for which pred returns true, from range [first, last), to the uninitialized memory buffer starting at out.

It's undefined behavior if out points into [first, last).

Returns a pointer one past the last copied element.

If an exception is thrown, all the already copied elements in the destination buffer are destroyed.

Definition at line 124 of file qcontainertools_impl.h.

qAddOverflowGeneric()

template<typename T>

std::enable_if_t< std::is_unsigned_v< T >, bool > QtPrivate::qAddOverflowGeneric ( T v1, T v2, T * r )

inlineconstexpr

Definition at line 124 of file qnumeric.h.

QByteArrayList_join()

QByteArray QtPrivate::QByteArrayList_join	(	const QByteArrayList *	that,
		const char *	sep,
		qsizetype	len )

Definition at line 106 of file qbytearraylist.cpp.

qCheckedFPConversionToInteger()

template<typename Result, typename FP, typename std::enable_if_t< std::is_integral_v< Result >, bool > = true, typename std::enable_if_t< std::is_floating_point_v< FP >, bool > = true>

Result QtPrivate::qCheckedFPConversionToInteger ( FP value )

inlineconstexpr

Definition at line 526 of file qnumeric.h.

qfutureWarnIfUnusedResults()

void QtPrivate::qfutureWarnIfUnusedResults

(

qsizetype

numResults

)

Definition at line 51 of file qfutureinterface.cpp.

qMakeForeachContainer()

template<typename T>

QForeachContainer< typename std::decay< T >::type > QtPrivate::qMakeForeachContainer

(

T &&

t

)

Definition at line 49 of file qforeach.h.

qMakeStringPrivate()

template<qsizetype N>

Q_ALWAYS_INLINE QStringPrivate QtPrivate::qMakeStringPrivate ( const char16_t(&) literal[N] )

static

Definition at line 1818 of file qstring.h.

qMetaTypeInterfaceForType()

template<typename T>

const QMetaTypeInterface * QtPrivate::qMetaTypeInterfaceForType ( )

constexpr

Definition at line 2646 of file qmetatype.h.

qMulOverflowGeneric()

template<typename T>

std::enable_if_t<(std::is_unsigned_v< T >||std::is_signed_v< T >), bool > QtPrivate::qMulOverflowGeneric ( T v1, T v2, T * r )

inlineconstexpr

Definition at line 246 of file qnumeric.h.

qMulOverflowWideMultiplication()

template<typename T>

std::enable_if_t< std::is_same_v< T, decltype(+T{})>, bool > QtPrivate::qMulOverflowWideMultiplication ( T v1, T v2, T * r )

inlineconstexpr

Definition at line 138 of file qnumeric.h.

qNormalizeType()

int QtPrivate::qNormalizeType ( const char * begin, const char * end, char * output )

constexpr

Definition at line 2234 of file qmetatype.h.

References QtPrivate::QTypeNormalizer::normalizeType().

Here is the call graph for this function:

qobject_cast_helper()

template<class TgtType, class SrcType>

TgtType QtPrivate::qobject_cast_helper ( SrcType * object )

inline

Definition at line 743 of file qobjectdefs.h.

QPixelFormat_createYUV()

QPixelFormat QtPrivate::QPixelFormat_createYUV	(	QPixelFormat::YUVLayout	yuvLayout,
		uchar	alphaSize,
		QPixelFormat::AlphaUsage	alphaUsage,
		QPixelFormat::AlphaPosition	alphaPosition,
		QPixelFormat::AlphaPremultiplied	premultiplied,
		QPixelFormat::TypeInterpretation	typeInterpretation,
		QPixelFormat::ByteOrder	byteOrder )

Definition at line 552 of file qpixelformat.cpp.

qSaturateRound()

template<typename FP, typename std::enable_if_t< std::is_floating_point_v< FP >, bool > = true>

int QtPrivate::qSaturateRound ( FP value )

inlineconstexpr

Definition at line 579 of file qnumeric.h.

QSEIT_EXCLUDE() [1/5]

QtPrivate::QSEIT_EXCLUDE

(

bool

)

QSEIT_EXCLUDE() [2/5]

QtPrivate::QSEIT_EXCLUDE

(

char

)

QSEIT_EXCLUDE() [3/5]

QtPrivate::QSEIT_EXCLUDE

(

char16_t

)

QSEIT_EXCLUDE() [4/5]

QtPrivate::QSEIT_EXCLUDE

(

char32_t

)

QSEIT_EXCLUDE() [5/5]

QtPrivate::QSEIT_EXCLUDE

(

wchar_t

)

qset_erase_if()

template<typename T, typename Predicate>

qsizetype QtPrivate::qset_erase_if	(	QSet< T > &	set,
		Predicate &	pred )

Definition at line 398 of file qcontainertools_impl.h.

qStringLikeToArg()

QAnyStringArg QtPrivate::qStringLikeToArg ( QAnyStringView s )

inlineconstexprnoexcept

Definition at line 1742 of file qstring.h.

QStringList_contains() [1/2]

bool QtPrivate::QStringList_contains	(	const QStringList *	that,
		QLatin1StringView	str,
		Qt::CaseSensitivity	cs )

Definition at line 376 of file qstringlist.cpp.

QStringList_contains() [2/2]

bool QtPrivate::QStringList_contains	(	const QStringList *	that,
		QStringView	str,
		Qt::CaseSensitivity	cs )

Definition at line 358 of file qstringlist.cpp.

QStringList_filter() [1/4]

QStringList QtPrivate::QStringList_filter	(	const QStringList &	that,
		const QLatin1StringMatcher &	matcher )

Definition at line 304 of file qstringlist.cpp.

QStringList_filter() [2/4]

QStringList QtPrivate::QStringList_filter	(	const QStringList &	that,
		const QStringMatcher &	matcher )

Definition at line 294 of file qstringlist.cpp.

QStringList_filter() [3/4]

QStringList QtPrivate::QStringList_filter	(	const QStringList &	that,
		QLatin1StringView	needle,
		Qt::CaseSensitivity	cs )

Definition at line 320 of file qstringlist.cpp.

QStringList_filter() [4/4]

QStringList QtPrivate::QStringList_filter	(	const QStringList *	that,
		QStringView	str,
		Qt::CaseSensitivity	cs )

Definition at line 255 of file qstringlist.cpp.

QStringList_indexOf() [1/2]

qsizetype QtPrivate::QStringList_indexOf	(	const QStringList &	that,
		QLatin1StringView	str,
		qsizetype	from,
		Qt::CaseSensitivity	cs )

Definition at line 656 of file qstringlist.cpp.

QStringList_indexOf() [2/2]

qsizetype QtPrivate::QStringList_indexOf	(	const QStringList &	that,
		QStringView	str,
		qsizetype	from,
		Qt::CaseSensitivity	cs )

Definition at line 650 of file qstringlist.cpp.

QStringList_join() [1/3]

QString QtPrivate::QStringList_join	(	const QStringList &	list,
		QLatin1StringView	sep )

Definition at line 549 of file qstringlist.cpp.

QStringList_join() [2/3]

QString QtPrivate::QStringList_join	(	const QStringList *	that,
		const QChar *	sep,
		qsizetype	seplen )

Definition at line 527 of file qstringlist.cpp.

QStringList_join() [3/3]

QString QtPrivate::QStringList_join	(	const QStringList *	that,
		QStringView	sep )

Definition at line 570 of file qstringlist.cpp.

QStringList_lastIndexOf() [1/2]

qsizetype QtPrivate::QStringList_lastIndexOf	(	const QStringList &	that,
		QLatin1StringView	str,
		qsizetype	from,
		Qt::CaseSensitivity	cs )

Definition at line 696 of file qstringlist.cpp.

QStringList_lastIndexOf() [2/2]

qsizetype QtPrivate::QStringList_lastIndexOf	(	const QStringList &	that,
		QStringView	str,
		qsizetype	from,
		Qt::CaseSensitivity	cs )

Definition at line 702 of file qstringlist.cpp.

QStringList_removeDuplicates()

qsizetype QtPrivate::QStringList_removeDuplicates

(

QStringList *

that

)

Definition at line 778 of file qstringlist.cpp.

QStringList_replaceInStrings()

void QtPrivate::QStringList_replaceInStrings	(	QStringList *	that,
		QStringView	before,
		QStringView	after,
		Qt::CaseSensitivity	cs )

Definition at line 440 of file qstringlist.cpp.

QStringList_sort()

void QtPrivate::QStringList_sort	(	QStringList *	that,
		Qt::CaseSensitivity	cs )

\fn void QStringList::sort(Qt::CaseSensitivity cs)

Sorts the list of strings in ascending order.

! [comparison-case-sensitivity] If cs is \l Qt::CaseSensitive (the default), the string comparison is case sensitive; otherwise the comparison is case insensitive. ! [comparison-case-sensitivity]

Sorting is performed using the STL's std::sort() algorithm,
which averages \l{linear-logarithmic time}, i.e. O(\e{n} log \e{n}).

If you want to sort your strings in an arbitrary order, consider
using the QMap class. For example, you could use a QMap<QString,
QString> to create a case-insensitive ordering (e.g. with the keys
being lower-case versions of the strings, and the values being the
strings), or a QMap<int, QString> to sort the strings by some
integer index.

Definition at line 208 of file qstringlist.cpp.

qstrnlen_helper()

qsizetype QtPrivate::qstrnlen_helper ( const char * str, size_t maxlen )

inline

Definition at line 183 of file qstringalgorithms.h.

qt_getEnumMetaObject()

template<typename T>

char QtPrivate::qt_getEnumMetaObject

(

const T &

)

qTryMetaTypeInterfaceForType()

template<typename Unique, typename T>

const QMetaTypeInterface * QtPrivate::qTryMetaTypeInterfaceForType ( )

constexpr

Definition at line 2659 of file qmetatype.h.

quickSortConcat() [1/2]

template<typename ... Right, typename ... Left>

QuickSortData< Right..., Left... > QtPrivate::quickSortConcat ( QuickSortData< Right... > , QuickSortData< Left... >  )

constexprnoexcept

quickSortConcat() [2/2]

template<typename ... Right, typename Middle, typename ... Left>

QuickSortData< Right..., Middle, Left... > QtPrivate::quickSortConcat ( QuickSortData< Right... > , QuickSortData< Middle > , QuickSortData< Left... >  )

constexprnoexcept

qUnsignedAbs()

template<typename T, typename std::enable_if_t< std::is_integral_v< T >, bool > = true>

auto QtPrivate::qUnsignedAbs ( T t )

inlineconstexpr

Definition at line 516 of file qnumeric.h.

qustrcasechr()

Q_NEVER_INLINE const char16_t * QtPrivate::qustrcasechr ( QStringView str, char16_t c )

nodiscardnoexcept

Searches case-insensitively for character c in the string str and returns a pointer to it. Iif the character is not found, this function returns a pointer to the end of the string – that is, {str.end()}.

Definition at line 776 of file qstring.cpp.

References foldCase().

Here is the call graph for this function:

qustrchr()

Q_NEVER_INLINE const char16_t * QtPrivate::qustrchr ( QStringView str, char16_t c )

nodiscardnoexcept

Searches for character c in the string str and returns a pointer to it. Unlike strchr() and wcschr() (but like glibc's strchrnul()), if the character is not found, this function returns a pointer to the end of the string – that is, {str.end()}.

Definition at line 688 of file qstring.cpp.

qustrlen()

Q_NEVER_INLINE qsizetype QtPrivate::qustrlen ( const char16_t * str )

nodiscardnoexcept

Definition at line 659 of file qstring.cpp.

qustrnlen()

qsizetype QtPrivate::qustrnlen ( const char16_t * str, qsizetype maxlen )

nodiscardnoexcept

Definition at line 674 of file qstring.cpp.

qvariant_cast_qmetatype_converted()

template<typename T>

T QtPrivate::qvariant_cast_qmetatype_converted ( const QVariant & v, QMetaType targetType )

inline

Definition at line 767 of file qvariant.h.

readArrayBasedContainer()

template<typename Container>

QDataStream & QtPrivate::readArrayBasedContainer	(	QDataStream &	s,
		Container &	c )

Definition at line 301 of file qdatastream.h.

readAssociativeContainer()

template<typename Container>

QDataStream & QtPrivate::readAssociativeContainer	(	QDataStream &	s,
		Container &	c )

Definition at line 350 of file qdatastream.h.

readFromDevice()

qint64 QtPrivate::readFromDevice ( QIODevice & device, QSpan< std::byte > outputBuffer )

inline

Definition at line 179 of file qaudio_qiodevice_support_p.h.

readListBasedContainer()

template<typename Container>

QDataStream & QtPrivate::readListBasedContainer	(	QDataStream &	s,
		Container &	c )

Definition at line 326 of file qdatastream.h.

reserveIfForwardIterator() [1/2]

template<typename Container, typename InputIterator, IfIsNotForwardIterator< InputIterator > = true>

void QtPrivate::reserveIfForwardIterator	(	Container *	,
		InputIterator	,
		InputIterator	)

Definition at line 282 of file qcontainertools_impl.h.

reserveIfForwardIterator() [2/2]

template<typename Container, typename ForwardIterator, IfIsForwardIterator< ForwardIterator > = true>

void QtPrivate::reserveIfForwardIterator	(	Container *	c,
		ForwardIterator	f,
		ForwardIterator	l )

Definition at line 289 of file qcontainertools_impl.h.

restoreBindingStatus()

void QtPrivate::restoreBindingStatus

(

BindingEvaluationState *

status

)

Definition at line 2437 of file qproperty.cpp.

roundUpToMultipleOf()

size_t QtPrivate::roundUpToMultipleOf ( size_t divisor, size_t x )

inlinestatic

Definition at line 20 of file qv4compiler.cpp.

sequential_erase()

template<typename Container, typename T>

auto QtPrivate::sequential_erase	(	Container &	c,
		const T &	t )

Definition at line 372 of file qcontainertools_impl.h.

sequential_erase_if()

template<typename Container, typename Predicate>

auto QtPrivate::sequential_erase_if	(	Container &	c,
		Predicate &	pred )

Definition at line 335 of file qcontainertools_impl.h.

sequential_erase_one()

template<typename Container, typename T>

auto QtPrivate::sequential_erase_one	(	Container &	c,
		const T &	t )

Definition at line 387 of file qcontainertools_impl.h.

sequential_erase_with_copy()

template<typename Container, typename T>

auto QtPrivate::sequential_erase_with_copy	(	Container &	c,
		const T &	t )

Definition at line 380 of file qcontainertools_impl.h.

setBindingStatus()

void QtPrivate::setBindingStatus	(	QBindingStatus *	status,
		QBindingStatusAccessToken	)

Definition at line 2501 of file qproperty.cpp.

shouldLogToStderr()

bool QtPrivate::shouldLogToStderr

(

)

Returns true if logging stderr should be ensured.

This is normally the case if stderr has a console attached, but may be overridden by the user by setting the QT_FORCE_STDERR_LOGGING environment variable to 1.

See also

stderrHasConsoleAttached()

Definition at line 340 of file qlogging.cpp.

References stderrHasConsoleAttached().

Here is the call graph for this function:

sizedFree() [1/2]

void QtPrivate::sizedFree ( void * ptr, size_t allocSize )

noexcept

Definition at line 28 of file qalloc.cpp.

sizedFree() [2/2]

void QtPrivate::sizedFree ( void * ptr, size_t capacity, size_t elementSize )

inlinenoexcept

Definition at line 124 of file qalloc.h.

startsWith() [1/5]

bool QtPrivate::startsWith ( QByteArrayView haystack, QByteArrayView needle )

nodiscardnoexcept

Definition at line 2953 of file qbytearray.cpp.

startsWith() [2/5]

bool QtPrivate::startsWith ( QLatin1StringView haystack, QLatin1StringView needle, Qt::CaseSensitivity cs = Qt::CaseSensitive )

related

Definition at line 9815 of file qstring.cpp.

startsWith() [3/5]

bool QtPrivate::startsWith ( QLatin1StringView haystack, QStringView needle, Qt::CaseSensitivity cs = Qt::CaseSensitive )

nodiscardnoexcept

Since

5.10

Definition at line 9810 of file qstring.cpp.

startsWith() [4/5]

bool QtPrivate::startsWith ( QStringView haystack, QLatin1StringView needle, Qt::CaseSensitivity cs = Qt::CaseSensitive )

nodiscardnoexcept

Since

5.10

Definition at line 9805 of file qstring.cpp.

startsWith() [5/5]

bool QtPrivate::startsWith ( QStringView haystack, QStringView needle, Qt::CaseSensitivity cs = Qt::CaseSensitive )

nodiscardnoexcept

Since

5.10

Definition at line 9800 of file qstring.cpp.

suspendCurrentBindingStatus()

BindingEvaluationState * QtPrivate::suspendCurrentBindingStatus

(

)

Definition at line 2430 of file qproperty.cpp.

References bindingStatus().

Here is the call graph for this function:

swap() [1/2]

template<typename T>

void QtPrivate::swap ( QExplicitlySharedDataPointerV2< T > & lhs, QExplicitlySharedDataPointerV2< T > & rhs )

constexprnoexcept

Definition at line 140 of file qshareddata_impl.h.

swap() [2/2]

template<typename Trait>

void QtPrivate::swap ( QSharedHandle< Trait > & lhs, QSharedHandle< Trait > & rhs )

noexcept

Definition at line 158 of file qsharedhandle_p.h.

toDouble()

auto QtPrivate::toDouble ( QByteArrayView a )

nodiscardnoexcept

Definition at line 4079 of file qbytearray.cpp.

toFloat()

auto QtPrivate::toFloat ( QByteArrayView a )

nodiscardnoexcept

Definition at line 4119 of file qbytearray.cpp.

References QLocaleData::convertDoubleToFloat().

Here is the call graph for this function:

toIntegral()

template<typename T, typename ByteArrayView, typename = std::enable_if_t<std::is_same_v<ByteArrayView, QByteArrayView>>>

T QtPrivate::toIntegral ( ByteArrayView data, bool * ok, int base )

inlinestatic

Definition at line 81 of file qbytearrayalgorithms.h.

toSignedInteger()

auto QtPrivate::toSignedInteger ( QByteArrayView data, int base )

nodiscard

Definition at line 3769 of file qbytearray.cpp.

toUnsignedInteger()

auto QtPrivate::toUnsignedInteger ( QByteArrayView data, int base )

nodiscard

Definition at line 3786 of file qbytearray.cpp.

trimmed() [1/3]

QByteArrayView QtPrivate::trimmed ( QByteArrayView s )

nodiscardnoexcept

Definition at line 3689 of file qbytearray.cpp.

trimmed() [2/3]

QLatin1StringView QtPrivate::trimmed ( QLatin1StringView s )

related

Definition at line 6237 of file qstring.cpp.

trimmed() [3/3]

QStringView QtPrivate::trimmed ( QStringView s )

nodiscardnoexcept

Definition at line 6232 of file qstring.cpp.

typenameHelper()

template<typename T>

auto QtPrivate::TypeNameHelper::typenameHelper ( )

constexpr

Definition at line 2250 of file qmetatype.h.

validateBufferFormat()

template<typename SampleType>

void QtPrivate::validateBufferFormat	(	const QAudioBuffer &	buffer,
		int	channel )

Definition at line 45 of file qaudiobuffer_support_p.h.

volatilePreDecrement()

template<typename T, QtPrivate::if_volatile< T > = true>

auto QtPrivate::volatilePreDecrement

(

T &

x

)

Definition at line 42 of file qvolatile_p.h.

volatilePreIncrement()

template<typename T, QtPrivate::if_volatile< T > = true>

auto QtPrivate::volatilePreIncrement

(

T &

x

)

Definition at line 34 of file qvolatile_p.h.

warnIfContainerIsNotShared()

template<typename T, typename = decltype(std::declval<T>().detach())>

void QtPrivate::warnIfContainerIsNotShared ( int )

inline

Definition at line 37 of file qforeach.h.

whenAllImpl() [1/2]

template<typename OutputSequence, typename... Futures>

QFuture< OutputSequence > QtPrivate::whenAllImpl

(

Futures &&...

futures

)

Definition at line 1148 of file qfuture_impl.h.

whenAllImpl() [2/2]

template<typename OutputSequence, typename InputIt, typename ValueType, std::enable_if_t< std::conjunction_v< IsForwardIterable< InputIt >, isQFuture< ValueType > >, bool > = true>

QFuture< OutputSequence > QtPrivate::whenAllImpl	(	InputIt	first,
		InputIt	last )

Definition at line 1125 of file qfuture_impl.h.

whenAnyImpl() [1/2]

template<typename... Futures>

QFuture< std::variant< std::decay_t< Futures >... > > QtPrivate::whenAnyImpl

(

Futures &&...

futures

)

Definition at line 1191 of file qfuture_impl.h.

whenAnyImpl() [2/2]

template<typename InputIt, typename ValueType, std::enable_if_t< std::conjunction_v< IsForwardIterable< InputIt >, isQFuture< ValueType > >, bool > = true>

QFuture< QtFuture::WhenAnyResult< typename Future< ValueType >::type > > QtPrivate::whenAnyImpl	(	InputIt	first,
		InputIt	last )

Definition at line 1163 of file qfuture_impl.h.

withRTSanDisabled()

template<typename Functor>

auto QtPrivate::withRTSanDisabled

(

const Functor &

f

)

Definition at line 53 of file qaudio_rtsan_support_p.h.

writeAssociativeContainer()

template<typename Container>

QDataStream & QtPrivate::writeAssociativeContainer	(	QDataStream &	s,
		const Container &	c )

Definition at line 386 of file qdatastream.h.

writeAssociativeMultiContainer()

template<typename Container>

QDataStream & QtPrivate::writeAssociativeMultiContainer	(	QDataStream &	s,
		const Container &	c )

Definition at line 401 of file qdatastream.h.

writeSequentialContainer()

template<typename Container>

QDataStream & QtPrivate::writeSequentialContainer	(	QDataStream &	s,
		const Container &	c )

Definition at line 375 of file qdatastream.h.

writeToDevice()

qint64 QtPrivate::writeToDevice ( QIODevice & device, QSpan< const std::byte > data )

inline

Definition at line 174 of file qaudio_qiodevice_support_p.h.

Variable Documentation

ascii_space_chars

char QtPrivate::ascii_space_chars[]

inlineconstexpr

Initial value:

=
        "\t"    
        "\n"    
        "\v"    
        "\f"    
        "\r"    
        " "

Definition at line 91 of file qlocale_p.h.

Referenced by ascii_isspace().

bindingFunctionVTable

template<typename Callable, typename PropertyType = MSVCWorkAround>

BindingFunctionVTable QtPrivate::bindingFunctionVTable = BindingFunctionVTable::createFor<Callable, PropertyType>()

inlineconstexpr

Definition at line 209 of file qpropertyprivate.h.

bindingFunctionVTableForQQmlPropertyBinding

template<QMetaType::Type type>

BindingFunctionVTable QtPrivate::bindingFunctionVTableForQQmlPropertyBinding

inlineconstexpr

Initial value:

= {
    &QQmlPropertyBinding::doEvaluate<type>,
    [](void *qpropertyBinding){
        QQmlPropertyBinding *binding = reinterpret_cast<QQmlPropertyBinding *>(qpropertyBinding);
        binding->jsExpression()->~QQmlPropertyBindingJS();
        binding->~QQmlPropertyBinding();
        auto address = static_cast<std::byte*>(qpropertyBinding);
        delete[] address;
    },
    [](void *, void *){},
    0
}

Definition at line 188 of file qqmlpropertybinding_p.h.

bindingFunctionVTableForQQmlPropertyToBindablePropertyBinding

template<typename Binding>

BindingFunctionVTable QtPrivate::bindingFunctionVTableForQQmlPropertyToBindablePropertyBinding

inlineconstexpr

Initial value:

= {
        &QQmlPropertyToBindablePropertyBinding::update<Binding>,
        [](void *qpropertyBinding) { delete reinterpret_cast<Binding *>(qpropertyBinding); },
        [](void *, void *){},
        0
    }

Definition at line 164 of file qqmlpropertytopropertybinding.cpp.

hasCallOperator_v

template<class T, class Enable = void>

bool QtPrivate::hasCallOperator_v = false

inlineconstexpr

Definition at line 111 of file qtconcurrentfunctionwrappers.h.

hasCallOperator_v< T, std::void_t< decltype(&T::operator())> >

template<class T>

bool QtPrivate::hasCallOperator_v< T, std::void_t< decltype(&T::operator())> > = true

inlineconstexpr

Definition at line 114 of file qtconcurrentfunctionwrappers.h.

HasCallOperatorAcceptingArgs_v

template<typename Functor, typename... Args>

bool QtPrivate::HasCallOperatorAcceptingArgs_v = HasCallOperatorAcceptingArgs<Functor, Args...>::value

constexpr

Definition at line 363 of file qobjectdefs_impl.h.

HasLargerInt

template<typename T, typename Enable = void>

bool QtPrivate::HasLargerInt = false

inlineconstexpr

Definition at line 239 of file qnumeric.h.

HasLargerInt< T, std::void_t< typename QIntegerForSize< sizeof(T) *2 >::Unsigned > >

template<typename T>

bool QtPrivate::HasLargerInt< T, std::void_t< typename QIntegerForSize< sizeof(T) *2 >::Unsigned > > = true

inlineconstexpr

Definition at line 241 of file qnumeric.h.

IdealMutexAlignment

quintptr QtPrivate::IdealMutexAlignment

inlineconstexpr

Initial value:

=
        sizeof(std::mutex) > sizeof(void *) &&
        sizeof(std::condition_variable) > sizeof(void *) ?
            64 : alignof(void*)

Definition at line 33 of file qwaitcondition_p.h.

is_function_pointer_v

template<typename T>

bool QtPrivate::is_function_pointer_v

inlineconstexpr

Initial value:

= std::conjunction_v<
        std::is_pointer<T>,
        std::is_function<std::remove_pointer_t<T>>
    >

Definition at line 103 of file qrunnable.h.

is_invocable_explicit_r_v

template<typename R, typename F, typename ... ArgTypes>

bool QtPrivate::is_invocable_explicit_r_v

constexpr

Initial value:

= std::conjunction_v<
    std::is_invocable<F, ArgTypes...>,
    is_invoke_result_explicitly_convertible<R, F, ArgTypes...>
>

Definition at line 424 of file qcontainertools_impl.h.

is_standard_or_extended_integer_type_v

template<typename T>

bool QtPrivate::is_standard_or_extended_integer_type_v = is_standard_or_extended_integer_type<T>::value

constexpr

Definition at line 88 of file qttypetraits.h.

is_std_function_v

template<typename T>

bool QtPrivate::is_std_function_v = false

inlineconstexpr

Definition at line 108 of file qrunnable.h.

is_std_function_v< std::function< T > >

template<typename T>

bool QtPrivate::is_std_function_v< std::function< T > > = true

inlineconstexpr

Definition at line 110 of file qrunnable.h.

IsDereferenceableValue

template<class T>

bool QtPrivate::IsDereferenceableValue = IsDereferenceable<T>::value

inlineconstexpr

Definition at line 35 of file qtconcurrentcompilertest.h.

IsFloatType_v

template<typename T>

bool QtPrivate::IsFloatType_v = std::is_floating_point_v<T>

constexpr

Definition at line 889 of file qcomparehelpers.h.

isInitialValueCompatible_v

template<class InitialValueType, class ResultType>

bool QtPrivate::isInitialValueCompatible_v

inlineconstexpr

Initial value:

= std::conjunction_v<
        std::is_convertible<InitialValueType, ResultType>,
        std::negation<std::is_same<std::decay_t<InitialValueType>, QtConcurrent::ReduceOption>>>

Definition at line 127 of file qtconcurrentfunctionwrappers.h.

IsIntegralType_v

template<typename T>

bool QtPrivate::IsIntegralType_v

constexpr

Initial value:

= std::numeric_limits<std::remove_const_t<T>>::is_specialized
                                  && std::numeric_limits<std::remove_const_t<T>>::is_integer

Definition at line 885 of file qcomparehelpers.h.

IsIterableValue

template<class T>

bool QtPrivate::IsIterableValue = IsIterable<T>::value

inlineconstexpr

Definition at line 25 of file qtconcurrentcompilertest.h.

isIterator_v

template<class T, class Enable = void>

bool QtPrivate::isIterator_v = false

inlineconstexpr

Definition at line 117 of file qtconcurrentfunctionwrappers.h.

isIterator_v< T, std::void_t< typename std::iterator_traits< T >::value_type > >

template<class T>

bool QtPrivate::isIterator_v< T, std::void_t< typename std::iterator_traits< T >::value_type > >

inlineconstexpr

Initial value:

=
        true

Definition at line 120 of file qtconcurrentfunctionwrappers.h.

isLatin1OrUtf16View

template<typename T>

bool QtPrivate::isLatin1OrUtf16View = false

inlineconstexpr

Definition at line 18 of file qlatin1stringmatcher.h.

isLatin1OrUtf16View< QLatin1StringView >

template<>

bool QtPrivate::isLatin1OrUtf16View< QLatin1StringView > = true

inlineconstexpr

Definition at line 19 of file qlatin1stringmatcher.h.

isLatin1OrUtf16View< QStringView >

template<>

bool QtPrivate::isLatin1OrUtf16View< QStringView > = true

inlineconstexpr

Definition at line 20 of file qlatin1stringmatcher.h.

IsPrivateSignalArg

template<class T, class Enable = void>

bool QtPrivate::IsPrivateSignalArg = false

inlineconstexpr

Definition at line 103 of file qfuture_impl.h.

IsPrivateSignalArg< T, typename std::enable_if_t< std::is_class_v< class T::QPrivateSignal > > >

template<class T>

bool QtPrivate::IsPrivateSignalArg< T, typename std::enable_if_t< std::is_class_v< class T::QPrivateSignal > > > = true

inlineconstexpr

Definition at line 106 of file qfuture_impl.h.

isQFutureV

template<class T>

bool QtPrivate::isQFutureV = false

inlineconstexpr

Definition at line 254 of file qfuture_impl.h.

isQFutureV< QFuture< T > >

template<class T>

bool QtPrivate::isQFutureV< QFuture< T > > = true

inlineconstexpr

Definition at line 257 of file qfuture_impl.h.

IsQmlListType

template<typename T>

bool QtPrivate::IsQmlListType = false

inlineconstexpr

Definition at line 1271 of file qmetatype.h.

IsQmlListType< QQmlListProperty< T > >

template<typename T>

bool QtPrivate::IsQmlListType< QQmlListProperty< T > > = true

inlineconstexpr

Definition at line 232 of file qqmllist.h.

IsUnsignedEnum

template<typename T, bool = std::is_enum<T>::value>

bool QtPrivate::IsUnsignedEnum = false

constexpr

Definition at line 1274 of file qmetatype.h.

IsUnsignedEnum< T, true >

template<typename T>

bool QtPrivate::IsUnsignedEnum< T, true > = !std::is_signed_v<std::underlying_type_t<T>>

constexpr

Definition at line 1276 of file qmetatype.h.

LegacyUncomparableValue

CompareUnderlyingType QtPrivate::LegacyUncomparableValue = -127

constexpr

Definition at line 27 of file qcompare.h.

MaxAllocSize

qsizetype QtPrivate::MaxAllocSize = (std::numeric_limits<qsizetype>::max)()

constexpr

Definition at line 59 of file qcontainerfwd.h.

MaxPrimitiveAlignment

size_t QtPrivate::MaxPrimitiveAlignment = alignof(std::max_align_t)

constexpr

Definition at line 117 of file qarraydata.h.

QAudioBufferImmutable

Mutability QtPrivate::QAudioBufferImmutable = Mutability::Immutable

constexpr

Definition at line 31 of file qaudiobuffer_support_p.h.

QAudioBufferMutable

Mutability QtPrivate::QAudioBufferMutable = Mutability::Mutable

constexpr

Definition at line 30 of file qaudiobuffer_support_p.h.

qIsComplex

template<typename T>

bool QtPrivate::qIsComplex

inlineconstexpr

Initial value:

=
        !std::is_trivially_default_constructible_v<T> || !std::is_trivially_copyable_v<T>

Definition at line 32 of file qtypeinfo.h.

qIsRelocatable

template<typename T>

bool QtPrivate::qIsRelocatable = std::is_trivially_copyable_v<T> && std::is_trivially_destructible_v<T>

inlineconstexpr

Definition at line 43 of file qtypeinfo.h.

qIsRelocatable< QVariant >

template<>

bool QtPrivate::qIsRelocatable< QVariant > = true

inlineconstexpr

Definition at line 63 of file qvariant.h.

qIsValueInitializationBitwiseZero

template<typename T>

bool QtPrivate::qIsValueInitializationBitwiseZero

inlineconstexpr

Initial value:

=
        std::is_scalar_v<T> && !std::is_member_object_pointer_v<T>

Definition at line 52 of file qtypeinfo.h.

QNothrowHashable_v

template<typename T>

bool QtPrivate::QNothrowHashable_v = QNothrowHashable<T>::value

inlineconstexpr

Definition at line 382 of file qhashfunctions.h.

QNothrowHashableHelper_v

template<typename T>

bool QtPrivate::QNothrowHashableHelper_v = noexcept(qHash(std::declval<const T &>(), size_t(0)))

inlineconstexpr

Definition at line 373 of file qhashfunctions.h.