({(void*)mPair.mFirst} = {*mPair.mFirst}) ({nullptr}) (void*)mPair.mFirst *mPair.mFirst ({(void*)mpValue} = {*mpValue}) ({nullptr}) (void*)mpValue *mpValue mpRefCount->mRefCount mpRefCount->mWeakRefCount {((mpRefCount && mpRefCount->mRefCount) ? mpValue : nullptr)} mpRefCount && mpRefCount->mRefCount ? mpValue : nullptr [{$T2}] {{}} [{$T2}] {{ {*mValue} }} [{$T2}] {{ {*mValue}, {*(mValue+1)} }} [{$T2}] {{ {*mValue}, {*(mValue+1)}, {*(mValue+2)} }} [{$T2}] {{ {*mValue}, {*(mValue+1)}, {*(mValue+2)}, {*(mValue+3)} }} [{$T2}] {{ {*mValue}, {*(mValue+1)}, {*(mValue+2)}, {*(mValue+3)}, {*(mValue+4)} }} [{$T2}] {{ {*mValue}, {*(mValue+1)}, {*(mValue+2)}, {*(mValue+3)}, {*(mValue+4)}, {*(mValue+5)} }} [{$T2}] {{ {*mValue}, {*(mValue+1)}, {*(mValue+2)}, {*(mValue+3)}, {*(mValue+4)}, {*(mValue+5)}, ... }} $T2 $T2 mValue "{mPair.mFirst.heap.mpBegin,sb}" "{mPair.mFirst.sso.mData,sb}" mPair.mFirst.heap.mnSize (mPair.mFirst.heap.mnCapacity & ~kHeapMask) mPair.mFirst.heap.mpBegin,sb mPair.mFirst.sso.mRemainingSizeField.mnRemainingSize SSOLayout::SSO_CAPACITY mPair.mFirst.sso.mData,sb !!(mPair.mFirst.sso.mRemainingSizeField.mnRemainingSize & kSSOMask) {mPair.mFirst.heap.mpBegin,su} {mPair.mFirst.sso.mData,su} mPair.mFirst.heap.mnSize (mPair.mFirst.heap.mnCapacity & ~kHeapMask) mPair.mFirst.heap.mpBegin,su mPair.mFirst.sso.mRemainingSizeField.mnRemainingSize SSOLayout::SSO_CAPACITY mPair.mFirst.sso.mData,su !!(mPair.mFirst.sso.mRemainingSizeField.mnRemainingSize & kSSOMask) ({first}, {second}) first second [{mnSize}] {{}} [{mnSize}] {{ {*mpData} }} [{mnSize}] {{ {*mpData}, {*(mpData+1)} }} [{mnSize}] {{ {*mpData}, {*(mpData+1)}, {*(mpData+2)} }} [{mnSize}] {{ {*mpData}, {*(mpData+1)}, {*(mpData+2)}, {*(mpData+3)} }} [{mnSize}] {{ {*mpData}, {*(mpData+1)}, {*(mpData+2)}, {*(mpData+3)}, {*(mpData+4)} }} [{mnSize}] {{ {*mpData}, {*(mpData+1)}, {*(mpData+2)}, {*(mpData+3)}, {*(mpData+4)}, {*(mpData+5)} }} [{mnSize}] {{ {*mpData}, {*(mpData+1)}, {*(mpData+2)}, {*(mpData+3)}, {*(mpData+4)}, {*(mpData+5)}, ... }} mnSize mnSize mpData [{mpEnd - mpBegin}] {{}} [{mpEnd - mpBegin}] {{ {*mpBegin} }} [{mpEnd - mpBegin}] {{ {*mpBegin}, {*(mpBegin+1)} }} [{mpEnd - mpBegin}] {{ {*mpBegin}, {*(mpBegin+1)}, {*(mpBegin+2)} }} [{mpEnd - mpBegin}] {{ {*mpBegin}, {*(mpBegin+1)}, {*(mpBegin+2)}, {*(mpBegin+3)} }} [{mpEnd - mpBegin}] {{ {*mpBegin}, {*(mpBegin+1)}, {*(mpBegin+2)}, {*(mpBegin+3)}, {*(mpBegin+4)} }} [{mpEnd - mpBegin}] {{ {*mpBegin}, {*(mpBegin+1)}, {*(mpBegin+2)}, {*(mpBegin+3)}, {*(mpBegin+4)}, {*(mpBegin+5)} }} [{mpEnd - mpBegin}] {{ {*mpBegin}, {*(mpBegin+1)}, {*(mpBegin+2)}, {*(mpBegin+3)}, {*(mpBegin+4)}, {*(mpBegin+5)}, ... }} mpEnd - mpBegin mCapacityAllocator.mFirst - mpBegin mpEnd - mpBegin mpBegin [0] {{}} [1] {{ {*mItBegin.mpCurrent} }} [{(mItEnd.mpCurrentArrayPtr - mItBegin.mpCurrentArrayPtr) * $T3 + (mItEnd.mpCurrent-mItEnd.mpBegin) - (mItBegin.mpCurrent-mItBegin.mpBegin)}] {{ {*mItBegin.mpCurrent}, ... }} (mItEnd.mpCurrentArrayPtr - mItBegin.mpCurrentArrayPtr) * $T3 + (mItEnd.mpCurrent-mItEnd.mpBegin) - (mItBegin.mpCurrent-mItBegin.mpBegin) (mItEnd.mpCurrentArrayPtr - mItBegin.mpCurrentArrayPtr) * $T3 + (mItEnd.mpCurrent-mItEnd.mpBegin) - (mItBegin.mpCurrent-mItBegin.mpBegin) mItBegin.mpCurrentArrayPtr[(mItBegin.mpCurrent-mItBegin.mpBegin + $i) / $T3][(mItBegin.mpCurrent-mItBegin.mpBegin + $i) % $T3] {*mpCurrent} *mpCurrent *(*(mpCurrentArrayPtr-1) + (mpEnd-mpBegin) - 1) *(mpCurrent-1) **(mpCurrentArrayPtr+1) *(mpCurrent+1) mpCurrent == mpBegin mpCurrent+1 == mpEnd {c} c [0] {{}} [1] {{ {((eastl::ListNode<$T1>*)mNodeAllocator.mFirst.mpNext)->mValue} }} [2] {{ {((eastl::ListNode<$T1>*)mNodeAllocator.mFirst.mpNext)->mValue}, {((eastl::ListNode<$T1>*)mNodeAllocator.mFirst.mpNext->mpNext)->mValue} }} [?] {{ {((eastl::ListNode<$T1>*)mNodeAllocator.mFirst.mpNext)->mValue}, {((eastl::ListNode<$T1>*)mNodeAllocator.mFirst.mpNext->mpNext)->mValue}, ... }} Content of lists will repeat indefinitely. Keep that in mind! mNodeAllocator.mFirst.mpNext mpNext ((eastl::ListNode<$T1>*)this)->mValue {mValue} mValue *(eastl::ListNode<$T1>*)mpNext *(eastl::ListNode<$T1>*)mpPrev Content of lists will repeat indefinitely. Keep that in mind! The rest of the list follows: (eastl::ListNode<$T1>*)mpNext->mpNext (eastl::ListNode<$T1>*)mpNext mValue {*mpNode} mpNode [0] {{}} [1] {{ {((eastl::SListNode<$T1>*)mNode.mpNext)->mValue} }} [2] {{ {((eastl::SListNode<$T1>*)mNode.mpNext)->mValue}, {((eastl::SListNode<$T1>*)mNode.mpNext->mpNext)->mValue} }} [?] {{ {((eastl::SListNode<$T1>*)mNode.mpNext)->mValue}, {((eastl::SListNode<$T1>*)mNode.mpNext->mpNext)->mValue}, ... }} mNode.mpNext mpNext ((eastl::SListNode<$T1>*)this)->mValue {mValue} mValue *(eastl::SListNode<$T1>*)mpNext The rest of the list follows: mpNext == nullptr ? nullptr : (eastl::SListNode<$T1>*)mpNext->mpNext (eastl::SListNode<$T1>*)mpNext mValue {*mpNode} *mpNode [0] {{}} [1] {{ {mAnchor.mpNext} }} [?] {{ {mAnchor.mpNext}, ... }} Content of intrusive lists will repeat indefinitely. Keep that in mind! mAnchor.mpNext mpNext *this {*mpNode} *mpNode [0] {{}} [1] {{ {((eastl::rbtree_node<$T1>*)mAnchor.mpNodeLeft)->mValue} }} [{mnSize}] {{ {((eastl::rbtree_node<$T1>*)mAnchor.mpNodeLeft)->mValue}, ... }} mnSize mnSize mAnchor.mpNodeParent mpNodeLeft mpNodeRight ((eastl::rbtree_node<$T1>*)this)->mValue [0] {{}} [1] {{ {((eastl::rbtree_node<$T2>*)mAnchor.mpNodeLeft)->mValue} }} [{mnSize}] {{ {((eastl::rbtree_node<$T2>*)mAnchor.mpNodeLeft)->mValue}, ... }} mnSize mnSize mAnchor.mpNodeParent mpNodeLeft mpNodeRight ((eastl::rbtree_node<$T2>*)this)->mValue {mValue} mValue It is possible to expand parents that do not exist. *(eastl::rbtree_node<$T2>*)(mpNodeParent.value & (~uintptr_t(1))) *(eastl::rbtree_node<$T2>*)mpNodeLeft *(eastl::rbtree_node<$T2>*)mpNodeRight {*mpNode} mpNode [{mnElementCount}] {{}} [{mnElementCount}] {{ ... }} mnBucketCount mpBucketArray {mValue}, {*mpNext} {mValue} this mpNext mValue {mpNode->mValue} mpNode->mValue {*(mIterator-1)} mIterator-1 {{count = {kSize}}} kSize kSize bBitValue = ((mWord[iWord] >> iBitInWord) % 2) != 0 ? true : false bBitValue iBitInWord++ iWord++ iBitInWord = 0 {c} c {mpBegin,[mnCount]} mpBegin,[mnCount] ({mFirst}, {mSecond}) ({mSecond}) ({mFirst}) (empty) (empty) ({mFirst}, {mSecond}) nullopt {value()} value() {$T1} to {$T2}} {mRep} nanoseconds {mRep} microseconds {mRep} milliseconds {mRep} seconds {mRep} minutes {mRep} hours {mRep} duration with ratio = [{$T2} : {$T3}] empty {mInvokeFuncPtr} {*val} empty {m_storage.external_storage} {mFlag.mAtomic}