Qt
Internal/Contributor docs for the Qt SDK. Note: These are NOT official API docs; those are found at https://doc.qt.io/
Loading...
Searching...
No Matches
QtPrivate Namespace Reference

Namespaces

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

Classes

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

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 T>
using DetectResult = decltype(std::declval<const T &>().result)
template<typename T>
using DetectFd = decltype(std::declval<const T &>().fd)
template<typename T>
using DetectHasFd = decltype(std::declval<const T &>().fd)
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  Operation : quint8 { NumOperations }
enum class  WakeMode { One = 1 , All = -1 }
enum class  SynthesizedAccessFunction : quint8 { IterableSize , SequenceAt }
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 T, typename S>
constexpr bool fuzzyCompare (const T &lhs, const S &rhs) noexcept
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)
 Q_ENUM_NS (Operation)
static const IORingApiTable * getApiTable ()
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)
template<typename Indirect>
QVariant associativeIteratorToVariant (const Indirect &referred)
template<typename Indirect>
QVariant sequentialIteratorToVariant (const Indirect &referred)
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)
QDebug operator<< (QDebug debug, const QQuickAttachedPropertyPropagator *propagator)
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)
Q_CORE_EXPORT void warnSynthesizedIterableAccess (SynthesizedAccessFunction function)
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 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 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 HasResultMember = qxp::is_detected_v<DetectResult, T>
template<typename T>
constexpr bool HasFdMember = qxp::is_detected_v<DetectFd, T>
template<typename T>
constexpr bool OperationHasFd_v = qxp::is_detected_v<DetectHasFd, T>
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)>
type
GLenum type
Definition qopengles2ext.h:150

Definition at line 52 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 121 of file qfunctionaltools_impl.h.

◆ CompareUnderlyingType

using QtPrivate::CompareUnderlyingType = qint8

Definition at line 26 of file qcompare.h.

◆ DetectFd

template<typename T>
using QtPrivate::DetectFd = decltype(std::declval<const T &>().fd)

Definition at line 340 of file qioring_linux.cpp.

◆ DetectHasFd

template<typename T>
using QtPrivate::DetectHasFd = decltype(std::declval<const T &>().fd)

Definition at line 454 of file qioring_win.cpp.

◆ DetectResult

template<typename T>
using QtPrivate::DetectResult = decltype(std::declval<const T &>().result)

Definition at line 87 of file qioring.cpp.

◆ 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>>
QtPrivate::createTuple
auto createTuple(Arg &&arg, Args &&... args)
Definition qfuture_impl.h:118
void
DBusConnection const char DBusError DBusBusType DBusError return DBusConnection DBusHandleMessageFunction void DBusFreeFunction return DBusConnection return DBusConnection return const char DBusError return DBusConnection DBusMessage dbus_uint32_t return DBusConnection dbus_bool_t DBusConnection DBusAddWatchFunction DBusRemoveWatchFunction DBusWatchToggledFunction void DBusFreeFunction return DBusConnection DBusDispatchStatusFunction void DBusFreeFunction DBusTimeout return DBusTimeout return DBusWatch return DBusWatch unsigned int return DBusError const DBusError return const DBusMessage return DBusMessage return DBusMessage return DBusMessage return DBusMessage return DBusMessage return DBusMessageIter int const void return DBusMessageIter DBusMessageIter return DBusMessageIter void DBusMessageIter void int return DBusMessage DBusMessageIter return DBusMessageIter return DBusMessageIter DBusMessageIter const char const char const char const char return DBusMessage return DBusMessage const char return DBusMessage dbus_bool_t return DBusMessage dbus_uint32_t return DBusMessage void
Definition qdbus_symbols_p.h:410

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 302 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>
qxp::is_detected
typename _detail::detector< qxp::nonesuch, void, Op, Args... >::value_t is_detected
Definition qxptype_traits.h:54

Definition at line 312 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 308 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
value
EGLOutputLayerEXT EGLint EGLAttrib value
[3]
Definition qeglstreamconvenience_p.h:46

Definition at line 271 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 266 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 333 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 276 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 329 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 325 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 296 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 320 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 350 of file qhashfunctions.h.

◆ QHashCombineCommutative

using QtPrivate::QHashCombineCommutative = QHashCombiner<QHashCombineCommutativeMixer>

Definition at line 362 of file qhashfunctions.h.

◆ QHashCombineCommutativeWithSeed

using QtPrivate::QHashCombineCommutativeWithSeed = QHashCombinerWithSeed<QHashCombineCommutativeMixer>

Definition at line 363 of file qhashfunctions.h.

◆ QHashCombiner

template<typename Mixer>
using QtPrivate::QHashCombiner = QHashCombinerWithSeed<Mixer>

Definition at line 338 of file qhashfunctions.h.

◆ QHashCombineWithSeed

using QtPrivate::QHashCombineWithSeed = QHashCombinerWithSeed<QHashCombineMixer>

Definition at line 351 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{}
)
qHash
size_t qHash(const Employee &key, size_t seed)
Definition src_corelib_tools_qhash.cpp:144

Definition at line 366 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 738 of file qcompare.h.

◆ Mutability

enum class QtPrivate::Mutability
strong
Enumerator
Mutable 
Immutable 

Definition at line 25 of file qaudiobuffer_support_p.h.

◆ Operation

enum class QtPrivate::Operation : quint8
strong
Enumerator
NumOperations 

Definition at line 86 of file qioring_p.h.

◆ Ordering

enum class QtPrivate::Ordering : CompareUnderlyingType
strong
Enumerator
Equal 
Equivalent 
Less 
Greater 

Definition at line 30 of file qcompare.h.

◆ SynthesizedAccessFunction

enum class QtPrivate::SynthesizedAccessFunction : quint8
strong
Enumerator
IterableSize 
SequenceAt 

Definition at line 64 of file qiterable.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 1123 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 1106 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 40 of file qquasivirtual_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 28 of file qquasivirtual_impl.h.

◆ argToQString()

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

Definition at line 9177 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 1735 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 431 of file qcontainertools_impl.h.

◆ associativeIteratorToVariant()

template<typename Indirect>
QVariant QtPrivate::associativeIteratorToVariant ( const Indirect & referred)

Definition at line 77 of file qmetaassociation.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 1678 of file qstring.h.

Referenced by CPP::WriteInitialization::acceptActionRef(), CPP::WriteInitialization::acceptConnection(), CPP::WriteInitialization::acceptTabStops(), argToQString(), createProject(), Python::WriteImports::doAdd(), EvalHandler::fileMessage(), getResources(), EvalHandler::message(), openFile(), openFile(), parseProvider(), parseTracepoint(), runRcc(), uiLibWarning(), Driver::unique(), Uic::write(), and Uic::write().

Here is the caller graph for this function:

◆ asString() [4/4]

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

Definition at line 1679 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 9734 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 9691 of file qstring.cpp.

◆ count() [4/7]

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

Definition at line 9703 of file qstring.cpp.

◆ count() [5/7]

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

Definition at line 9681 of file qstring.cpp.

◆ count() [6/7]

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

Definition at line 9725 of file qstring.cpp.

◆ count() [7/7]

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

Definition at line 9666 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 9823 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 9818 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 9813 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 9808 of file qstring.cpp.

◆ equalStrings() [1/9]

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

Definition at line 1417 of file qstring.cpp.

◆ equalStrings() [2/9]

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

Definition at line 1412 of file qstring.cpp.

◆ equalStrings() [3/9]

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

Definition at line 1397 of file qstring.cpp.

◆ equalStrings() [4/9]

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

Definition at line 1407 of file qstring.cpp.

◆ equalStrings() [5/9]

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

Definition at line 1391 of file qstring.cpp.

◆ equalStrings() [6/9]

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

Definition at line 1386 of file qstring.cpp.

◆ equalStrings() [7/9]

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

Definition at line 1402 of file qstring.cpp.

◆ equalStrings() [8/9]

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

Definition at line 1380 of file qstring.cpp.

◆ equalStrings() [9/9]

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

Definition at line 1374 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 408 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 9929 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 9911 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 9902 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 9828 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 529 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 51 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 91 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 81 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 115 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 100 of file qalloc.h.

◆ Forward() [1/2]

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

Definition at line 35 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 29 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.

◆ fuzzyCompare()

template<typename T, typename S>
bool QtPrivate::fuzzyCompare ( const T & lhs,
const S & rhs )
nodiscardconstexprnoexcept

Definition at line 641 of file qnumeric.h.

◆ getApiTable()

const IORingApiTable * QtPrivate::getApiTable ( )
static

Definition at line 58 of file qioring_win.cpp.

Referenced by buildReadOperation(), and buildWriteOperation().

Here is the caller graph for this function:

◆ getBindingStatus()

QBindingStatus * QtPrivate::getBindingStatus ( QtPrivate::QBindingStatusAccessToken )

Returns the binding statusof the current thread.

Definition at line 2530 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 2865 of file qmetatype.cpp.

Referenced by QtPrivate::AssociativeKeyTypeIsMetaType< T, true >::registerConverter().

Here is the caller graph for this function:

◆ hasRegisteredConverterFunctionToIterableMetaSequence()

bool QtPrivate::hasRegisteredConverterFunctionToIterableMetaSequence ( QMetaType m)

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

Definition at line 2855 of file qmetatype.cpp.

Referenced by QtPrivate::SequentialValueTypeIsMetaType< T, true >::registerConverter().

Here is the caller graph for this function:

◆ hasRegisteredConverterFunctionToPairVariantInterface()

bool QtPrivate::hasRegisteredConverterFunctionToPairVariantInterface ( QMetaType m)

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

Definition at line 2845 of file qmetatype.cpp.

Referenced by QtPrivate::IsMetaTypePair< T, true >::registerConverter().

Here is the caller graph for this function:

◆ hasRegisteredMutableViewFunctionToIterableMetaAssociation()

bool QtPrivate::hasRegisteredMutableViewFunctionToIterableMetaAssociation ( QMetaType m)

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

Definition at line 2902 of file qmetatype.cpp.

Referenced by QtPrivate::AssociativeKeyTypeIsMetaType< T, true >::registerMutableView().

Here is the caller graph for this function:

◆ hasRegisteredMutableViewFunctionToIterableMetaSequence()

bool QtPrivate::hasRegisteredMutableViewFunctionToIterableMetaSequence ( QMetaType m)

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

Definition at line 2892 of file qmetatype.cpp.

Referenced by QtPrivate::SequentialValueTypeIsMetaType< T, true >::registerMutableView().

Here is the caller graph for this function:

◆ indexOf() [1/2]

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

Definition at line 1001 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 2458 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 2483 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 5514 of file qstring.cpp.

◆ isPropertyInBindingWrapper()

bool QtPrivate::isPropertyInBindingWrapper ( const QUntypedPropertyData * property)

Definition at line 2488 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 5519 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 1016 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 424 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 10006 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 10001 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 9986 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 9996 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 9991 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>
std::enable_if_t< sizeof(Char)==1, qsizetype > QtPrivate::lengthHelperContainer ( const Char(&) str[N])
inlinenodiscardconstexpr

Definition at line 193 of file qstringalgorithms.h.

◆ lengthHelperContainer() [2/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() [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 71 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 136 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 119 of file qoffsetstringarray_p.h.

◆ makeReadyRangeFutureImpl()

template<typename ValueType>
QFuture< ValueType > QtPrivate::makeReadyRangeFutureImpl ( const QList< ValueType > & values)

Definition at line 898 of file qfuture_impl.h.

◆ min()

template<typename T>
const T & QtPrivate::min ( const T & a,
const T & b )
inlineconstexpr

Definition at line 592 of file qnumeric.h.

◆ minifyValue()

template<size_t Highest>
auto QtPrivate::minifyValue ( )
constexpr

Definition at line 104 of file qoffsetstringarray_p.h.

◆ nextByteSize()

quint8 QtPrivate::nextByteSize ( quint8 bits)
constexpr

Definition at line 16 of file qtaggedpointer.h.

◆ operator<<()

QDebug QtPrivate::operator<< ( QDebug debug,
const QQuickAttachedPropertyPropagator * propagator )

Definition at line 423 of file qquickattachedpropertypropagator.cpp.

◆ partiallyParsedDataCount()

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

Definition at line 2504 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_ENUM_NS()

QtPrivate::Q_ENUM_NS ( Operation )

◆ 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 50 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 37 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 237 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 148 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 102 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 64 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 73 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 125 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 112 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 504 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 1817 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 234 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 126 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 745 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 557 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 399 of file qcontainertools_impl.h.

◆ qStringLikeToArg()

QAnyStringArg QtPrivate::qStringLikeToArg ( QAnyStringView s)
inlineconstexprnoexcept

Definition at line 1741 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 494 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 938 of file qvariant.h.

◆ readArrayBasedContainer()

template<typename Container>
QDataStream & QtPrivate::readArrayBasedContainer ( QDataStream & s,
Container & c )

Definition at line 302 of file qdatastream.h.

◆ readAssociativeContainer()

template<typename Container>
QDataStream & QtPrivate::readAssociativeContainer ( QDataStream & s,
Container & c )

Definition at line 351 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 327 of file qdatastream.h.

◆ reserveIfForwardIterator() [1/2]

template<typename Container, typename InputIterator, IfIsNotForwardIterator< InputIterator > = true>
void QtPrivate::reserveIfForwardIterator ( Container * ,
InputIterator ,
InputIterator  )

Definition at line 283 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 290 of file qcontainertools_impl.h.

◆ restoreBindingStatus()

void QtPrivate::restoreBindingStatus ( BindingEvaluationState * status)

Definition at line 2470 of file qproperty.cpp.

◆ roundUpToMultipleOf()

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

Definition at line 21 of file qv4compiler.cpp.

◆ sequential_erase()

template<typename Container, typename T>
auto QtPrivate::sequential_erase ( Container & c,
const T & t )

Definition at line 373 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 336 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 388 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 381 of file qcontainertools_impl.h.

◆ sequentialIteratorToVariant()

template<typename Indirect>
QVariant QtPrivate::sequentialIteratorToVariant ( const Indirect & referred)

Definition at line 57 of file qmetasequence.h.

◆ setBindingStatus()

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

Definition at line 2534 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 125 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 9783 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 9778 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 9773 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 9768 of file qstring.cpp.

◆ suspendCurrentBindingStatus()

BindingEvaluationState * QtPrivate::suspendCurrentBindingStatus ( )

Definition at line 2463 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 141 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 6171 of file qstring.cpp.

◆ trimmed() [3/3]

QStringView QtPrivate::trimmed ( QStringView s)
nodiscardnoexcept

Definition at line 6166 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.

◆ warnSynthesizedIterableAccess()

void QtPrivate::warnSynthesizedIterableAccess ( QtPrivate::SynthesizedAccessFunction function)

Definition at line 649 of file qiterable.cpp.

Referenced by QIterable< Container >::size().

Here is the caller graph for this function:

◆ whenAllImpl() [1/2]

template<typename OutputSequence, typename... Futures>
QFuture< OutputSequence > QtPrivate::whenAllImpl ( Futures &&... futures)

Definition at line 1155 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 1132 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 1198 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 1170 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 387 of file qdatastream.h.

◆ writeAssociativeMultiContainer()

template<typename Container>
QDataStream & QtPrivate::writeAssociativeMultiContainer ( QDataStream & s,
const Container & c )

Definition at line 402 of file qdatastream.h.

◆ writeSequentialContainer()

template<typename Container>
QDataStream & QtPrivate::writeSequentialContainer ( QDataStream & s,
const Container & c )

Definition at line 376 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
}
QQmlPropertyBinding::doEvaluate
static bool doEvaluate(QMetaType metaType, QUntypedPropertyData *dataPtr, void *f)
Definition qqmlpropertybinding_p.h:120
QQmlPropertyBinding::jsExpression
QQmlPropertyBindingJS * jsExpression()
Definition qqmlpropertybinding_p.h:71
address
GLuint GLuint64EXT address
Definition qopenglext.h:11428

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
}
QQmlPropertyToBindablePropertyBinding::update
static bool update(QMetaType metaType, QUntypedPropertyData *dataPtr, void *f)
Definition qqmlpropertytopropertybinding_p.h:145
Binding
@ Binding
Definition qqmlprofilerclientdefinitions_p.h:54

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.

◆ HasFdMember

template<typename T>
bool QtPrivate::HasFdMember = qxp::is_detected_v<DetectFd, T>
constexpr

Definition at line 343 of file qioring_linux.cpp.

◆ HasLargerInt

template<typename T, typename Enable = void>
bool QtPrivate::HasLargerInt = false
inlineconstexpr

Definition at line 227 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 229 of file qnumeric.h.

◆ HasResultMember

template<typename T>
bool QtPrivate::HasResultMember = qxp::is_detected_v<DetectResult, T>
constexpr

Definition at line 90 of file qioring.cpp.

◆ 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...>
>
F
#define F(x, y, z)
QtPrivate::is_invoke_result_explicitly_convertible
Definition qcontainertools_impl.h:420

Definition at line 425 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>>>
QtConcurrent::ReduceOption
ReduceOption
This enum specifies the order of which results from the map or filter function are passed to the redu...
Definition qtconcurrentreducekernel.h:67

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 238 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 60 of file qcontainerfwd.h.

◆ MaxPrimitiveAlignment

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

Definition at line 118 of file qarraydata.h.

◆ OperationHasFd_v

template<typename T>
bool QtPrivate::OperationHasFd_v = qxp::is_detected_v<DetectHasFd, T>
constexpr

Definition at line 457 of file qioring_win.cpp.

◆ 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 384 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 375 of file qhashfunctions.h.