JD2022-TU1/main/extern/gear4/tools/natvis/gear4.generics.natvis

364 lines
13 KiB
XML

<?xml version="1.0" encoding="utf-8"?>
<AutoVisualizer xmlns="http://schemas.microsoft.com/vstudio/debugger/natvis/2010">
<!--
Ref:
http://msdn.microsoft.com/en-us/library/jj620914(v=vs.110).aspx
http://blogs.msdn.com/b/vcblog/archive/2013/06/28/using-visual-studio-2013-to-write-maintainable-native-visualizations-natvis.aspx
<Type Name="G4::MyType">
<AlternativeType Name="G4::MyType2" />
<DisplayString>info</DisplayString>
<StringView>string viewer info</StringView>
<Expand>
<Item Name="item1">m_item1</Item>
<Item Name="item2">m_item2</Item>
<Item Name="item3"><![CDATA[
item3 value expression with some no-xml-friendly characters (<, >, &...)
]]></Item>
<ArrayItems>
<Size>m_size</Size>
<ValuePointer>m_array</ValuePointer>
</ArrayItems>
</Expand>
</Type>
-->
<!-- G4::Array<*, *> -->
<Type Name="G4::Array&lt;*,*&gt;">
<DisplayString>{{ size={$T2} }}</DisplayString>
<Expand>
<Item Name="size">$T2</Item>
<ArrayItems>
<Size>$T2</Size>
<ValuePointer>m_array</ValuePointer>
</ArrayItems>
</Expand>
</Type>
<Type Name="G4::Array&lt;*,*&gt;::iterator">
<AlternativeType Name="G4::Array&lt;*,*&gt;::const_iterator" />
<AlternativeType Name="G4::Array&lt;*,*&gt;::reverse_iterator" />
<AlternativeType Name="G4::Array&lt;*,*&gt;::const_reverse_iterator" />
<DisplayString>{*m_iter}</DisplayString>
<Expand>
<Item Name="ptr">m_iter</Item>
</Expand>
</Type>
<!-- G4::BitArray<*, *> -->
<Type Name="G4::BitArray&lt;*,*&gt;">
<DisplayString>{{ size={m_NbElement} }}</DisplayString>
<Expand>
<Item Name="size">m_NbElement</Item>
<IndexListItems>
<Size>m_NbElement</Size>
<ValueNode><![CDATA[
m_BitPerElement > (32 - ((m_BitPerElement * $i) - (((m_BitPerElement * $i) / 32) * 32))) ? ((((&(m_pArray[((m_BitPerElement * $i) / 32)]))[0] & ((0xFFFFFFFF >> (32 - m_BitPerElement)) << ((m_BitPerElement * $i) - (((m_BitPerElement * $i) / 32) * 32)))) >> ((m_BitPerElement * $i) - (((m_BitPerElement * $i) / 32) * 32))) | (((&(m_pArray[((m_BitPerElement * $i) / 32)]))[1] & ((0xFFFFFFFF >> (32 - m_BitPerElement)) >> (32 - ((m_BitPerElement * $i) - (((m_BitPerElement * $i) / 32) * 32))))) << (32 - ((m_BitPerElement * $i) - (((m_BitPerElement * $i) / 32) * 32))))) : (((&(m_pArray[((m_BitPerElement * $i) / 32)]))[0] & ((0xFFFFFFFF >> (32 - m_BitPerElement)) << ((m_BitPerElement * $i) - (((m_BitPerElement * $i) / 32) * 32)))) >> ((m_BitPerElement * $i) - (((m_BitPerElement * $i) / 32) * 32)))
]]></ValueNode>
</IndexListItems>
</Expand>
</Type>
<!-- G4::BitVector<*> -->
<Type Name="G4::BitVector&lt;*&gt;">
<DisplayString>{{ size={$T1} }}</DisplayString>
<Expand>
<Item Name="size">$T1</Item>
<Item Name="values">*m_pBits</Item>
<IndexListItems>
<Size>$T1</Size>
<ValueNode><![CDATA[
(m_pBits[$i >> 5] >> ($i & 31)) & 1
]]></ValueNode>
</IndexListItems>
</Expand>
</Type>
<!-- G4::CircularBuffer<*> -->
<Type Name="G4::CircularBuffer&lt;*&gt;">
<DisplayString>{{ size={m_array.m_size}, NextRead={m_array.m_array[m_elementReadPos]} }}</DisplayString>
<Expand>
<Item Name="size">m_array.m_size</Item>
<Item Name="available">m_availablelement</Item>
<Item Name="read position">m_elementReadPos</Item>
<Item Name="write position">m_elementWritePos</Item>
<Item Name="circular write">m_circularWrite</Item>
<Synthetic Name="Read order:" Condition="m_availablelement > 0">
</Synthetic>
<IndexListItems>
<Size>m_availablelement</Size>
<ValueNode>m_array.m_array[(m_elementReadPos + $i) % m_array.m_size]</ValueNode>
</IndexListItems>
<Synthetic Name="Raw buffer:" Condition="m_array.m_size > 0">
</Synthetic>
<ArrayItems>
<Size>m_array.m_size</Size>
<ValuePointer>m_array.m_array</ValuePointer>
</ArrayItems>
</Expand>
</Type>
<!-- G4::Deque<*> -->
<Type Name="G4::Deque&lt;*&gt;">
<DisplayString>{{ size={m_begin &lt;= m_end ? m_end - m_begin : (m_capacity - m_begin) + m_end} }}</DisplayString>
<Expand>
<Item Name="size">m_begin &lt;= m_end ? m_end - m_begin : (m_capacity - m_begin) + m_end</Item>
<Item Name="capacity">m_capacity</Item>
<Item Name="[front]" Condition="m_capacity > 0">m_array[m_begin]</Item>
<Item Name="[back]" Condition="m_capacity > 0">m_array[(m_end - 1 + m_capacity) % m_capacity]</Item>
<IndexListItems>
<Size><![CDATA[
m_begin <= m_end ? m_end - m_begin : (m_capacity - m_begin) + m_end
]]></Size>
<ValueNode>m_array[(m_begin + $i) % m_capacity]</ValueNode>
</IndexListItems>
</Expand>
</Type>
<Type Name="G4::Deque&lt;*&gt;::iterator">
<AlternativeType Name="G4::Deque&lt;*&gt;::const_iterator" />
<AlternativeType Name="G4::Deque&lt;*&gt;::reverse_iterator" />
<AlternativeType Name="G4::Deque&lt;*&gt;::const_reverse_iterator" />
<DisplayString>{m_parent->m_array[m_pos]}</DisplayString>
<Expand>
<Item Name="index">m_pos - m_parent->m_begin</Item>
<Item Name="ptr"><![CDATA[
&(m_parent->m_array[m_pos])
]]></Item>
</Expand>
</Type>
<!-- G4::List<*> -->
<Type Name="G4::List&lt;*&gt;">
<DisplayString>{{ ... }}</DisplayString>
<Expand>
<!-- Support for Circular Linked Lists only in vs2013: http://blogs.msdn.com/b/vcblog/archive/2013/06/28/using-visual-studio-2013-to-write-maintainable-native-visualizations-natvis.aspx -->
<Synthetic Name="vs2012 warning:">
<DisplayString>Circular Linked Lists are not handled properly and will loop indefinitly in vs2012 (use vs2013+ for correct behavior)</DisplayString>
</Synthetic>
<LinkedListItems>
<HeadPointer>m_node.m_next</HeadPointer>
<NextPointer>m_next</NextPointer>
<ValueNode><![CDATA[
((G4::ListNode<$T1>*)this)->mValue
]]></ValueNode>
</LinkedListItems>
</Expand>
</Type>
<Type Name="G4::List&lt;*&gt;::iterator">
<AlternativeType Name="G4::List&lt;*&gt;::const_iterator" />
<AlternativeType Name="G4::List&lt;*&gt;::reverse_iterator" />
<AlternativeType Name="G4::List&lt;*&gt;::const_reverse_iterator" />
<DisplayString>{m_node->mValue}</DisplayString>
<Expand>
<Item Name="ptr"><![CDATA[
&(m_node)
]]></Item>
</Expand>
</Type>
<!-- G4::Map<*,*,*> -->
<!-- G4::MultiMap<*,*,*> -->
<Type Name="G4::Map&lt;*,*,*&gt;">
<AlternativeType Name="G4::MultiMap&lt;*,*,*&gt;" />
<DisplayString>{{ size={m_tree.m_count} }}</DisplayString>
<Expand>
<Item Name="comp">m_tree.m_keyCompare</Item>
<Item Name="size">m_tree.m_count</Item>
<TreeItems>
<Size>m_tree.m_count</Size>
<HeadPointer>m_tree.m_tree.m_parent</HeadPointer>
<LeftPointer>m_left</LeftPointer>
<RightPointer>m_right</RightPointer>
<ValueNode><![CDATA[
((G4::RBTree<G4::Pair<$T1 const ,$T2>,$T1,$T3,G4::Select1st<G4::Pair<$T1 const ,$T2> > >::TreeNode*)this)->m_element
]]></ValueNode>
</TreeItems>
</Expand>
</Type>
<!-- G4::Set<*,*> -->
<!-- G4::MultiSet<*,*> -->
<Type Name="G4::Set&lt;*,*&gt;">
<AlternativeType Name="G4::MultiSet&lt;*,*&gt;" />
<DisplayString>{{ size={m_tree.m_count} }}</DisplayString>
<Expand>
<Item Name="comp">m_tree.m_keyCompare</Item>
<Item Name="size">m_tree.m_count</Item>
<TreeItems>
<Size>m_tree.m_count</Size>
<HeadPointer>m_tree.m_tree.m_parent</HeadPointer>
<LeftPointer>m_left</LeftPointer>
<RightPointer>m_right</RightPointer>
<ValueNode><![CDATA[
((G4::RBTree<$T1,$T1,$T2,G4::IdentityFunctor<$T1> >::TreeNode*)this)->m_element
]]></ValueNode>
</TreeItems>
</Expand>
</Type>
<!-- G4::Pair<*,*> -->
<Type Name="G4::Pair&lt;*,*&gt;">
<DisplayString>{{ {first}, {second} }}</DisplayString>
</Type>
<!-- G4::PriorityQueue<*,*,*> -->
<Type Name="G4::PriorityQueue&lt;*,*,*&gt;">
<DisplayString>{m_container}</DisplayString>
<Expand>
<Item Name="comp">m_comparator</Item>
<Item Name="c">m_container</Item>
</Expand>
</Type>
<!-- G4::Queue<*,*> -->
<Type Name="G4::Queue&lt;*,*&gt;">
<DisplayString>{m_container}</DisplayString>
<Expand>
<Item Name="c">m_container</Item>
</Expand>
</Type>
<!-- G4::RBTree<*,*,*,*> -->
<Type Name="G4::RBTree&lt;*,*,*,*&gt;">
<DisplayString>{{ size={m_count} }}</DisplayString>
<Expand>
<Item Name="comp">m_keyCompare</Item>
<Item Name="size">m_count</Item>
<Item Name="tree"><![CDATA[
(*(G4::RBTree<$T1,$T2,$T3,$T4>::TreeNode*)m_tree.m_parent)
]]></Item>
<TreeItems>
<Size>m_count</Size>
<HeadPointer>m_tree.m_parent</HeadPointer>
<LeftPointer>m_left</LeftPointer>
<RightPointer>m_right</RightPointer>
<ValueNode><![CDATA[
((G4::RBTree<$T1,$T2,$T3,$T4>::TreeNode*)this)->m_element
]]></ValueNode>
</TreeItems>
</Expand>
</Type>
<Type Name="G4::RBTree&lt;*,*,*,*&gt;::Iterator">
<AlternativeType Name="G4::RBTree&lt;*,*,*,*&gt;::ConstIterator" />
<AlternativeType Name="G4::RBTree&lt;*,*,*,*&gt;::ReverseIterator" />
<AlternativeType Name="G4::RBTree&lt;*,*,*,*&gt;::ConstReverseIterator" />
<DisplayString><![CDATA[
{((G4::RBTree<$T1,$T2,$T3,$T4>::TreeNode*)m_node)->m_element}
]]></DisplayString>
</Type>
<Type Name="G4::RBTree&lt;*,*,*,*&gt;::TreeNode">
<DisplayString>{{ element={m_element}, color={m_color} ... }}</DisplayString>
<Expand>
<Item Name="element">m_element</Item>
<Item Name="color">m_color</Item>
<Item Name="left" Condition="m_left > 0"><![CDATA[
*(G4::RBTree<$T1,$T2,$T3,$T4>::TreeNode*)m_left
]]></Item>
<Item Name="right" Condition="m_right > 0"><![CDATA[
*(G4::RBTree<$T1,$T2,$T3,$T4>::TreeNode*)m_right
]]></Item>
</Expand>
</Type>
<!-- G4::SparseVector<*> -->
<Type Name="G4::SparseVector&lt;*&gt;">
<DisplayString>{{ size={m_size} }}</DisplayString>
<Expand>
<Item Name="size">m_size</Item>
<IndexListItems>
<Size>m_size</Size>
<ValueNode><![CDATA[
m_bucketList.m_array[((($i + m_begin) / m_bucketSize) + m_bucketList.m_begin + m_bucketList.m_capacity) % m_bucketList.m_capacity] ? m_bucketList.m_array[((($i + m_begin) / m_bucketSize) + m_bucketList.m_begin + m_bucketList.m_capacity) % m_bucketList.m_capacity][($i + m_begin) % m_bucketSize] : $T1()
]]></ValueNode>
</IndexListItems>
</Expand>
</Type>
<!-- G4::Stack<*,*> -->
<Type Name="G4::Stack&lt;*,*&gt;">
<DisplayString>{m_container}</DisplayString>
<Expand>
<Item Name="c">m_container</Item>
</Expand>
</Type>
<!-- G4::StaticVector<*,*> -->
<Type Name="G4::StaticVector&lt;*,*&gt;">
<DisplayString>{{ size={m_size} }}</DisplayString>
<Expand>
<Item Name="size">m_size</Item>
<Item Name="max size">$T2</Item>
<ArrayItems>
<Size>m_size</Size>
<ValuePointer>m_staticArray.m_array</ValuePointer>
</ArrayItems>
</Expand>
</Type>
<!-- G4::UnorderedMap<*,*,*,*> -->
<Type Name="G4::UnorderedMap&lt;*,*,*,*&gt;">
<DisplayString>{{ size={m_uiCount} }}</DisplayString>
<Expand>
<Item Name="hash">m_hashingMethod</Item>
<Item Name="equal">m_keyEqual</Item>
<Synthetic Name="natvis warning:">
<DisplayString>Natvis doesn't support displaying this type properly, follow the link and vote for this feature to be supported: http://visualstudio.uservoice.com/forums/121579-visual-studio/suggestions/4256222-add-support-for-bucketed-linked-lists-in-natvis-fi</DisplayString>
</Synthetic>
<ArrayItems>
<Size>m_uiHashSize</Size>
<ValuePointer>m_pHashTable</ValuePointer>
</ArrayItems>
</Expand>
</Type>
<Type Name="G4::UnorderedBase&lt;*&gt;::iterator">
<AlternativeType Name="G4::UnorderedBase&lt;*&gt;::const_iterator" />
<AlternativeType Name="G4::UnorderedBase&lt;*&gt;::reverse_iterator" />
<AlternativeType Name="G4::UnorderedBase&lt;*&gt;::const_reverse_iterator" />
<DisplayString>{m_iterator->m_val}</DisplayString>
<Expand>
<Item Name="ptr">m_iterator</Item>
</Expand>
</Type>
<!-- G4::Vector<*> -->
<Type Name="G4::Vector&lt;*&gt;">
<DisplayString>{{ size={m_size} }}</DisplayString>
<Expand>
<Item Name="size">m_size</Item>
<Item Name="capacity">m_capacity</Item>
<ArrayItems>
<Size>m_size</Size>
<ValuePointer>m_array</ValuePointer>
</ArrayItems>
</Expand>
</Type>
<Type Name="G4::Vector&lt;*&gt;::iterator">
<AlternativeType Name="G4::Vector&lt;*&gt;::const_iterator" />
<AlternativeType Name="G4::Vector&lt;*&gt;::reverse_iterator" />
<AlternativeType Name="G4::Vector&lt;*&gt;::const_reverse_iterator" />
<DisplayString>{*m_iterator}</DisplayString>
<Expand>
<Item Name="ptr">m_iterator</Item>
</Expand>
</Type>
<!-- G4::GearBasicString<*> -->
<Type Name="G4::GearBasicString&lt;*&gt;">
<DisplayString>{m_string ? m_string->data : ""}</DisplayString>
<Expand>
<Item Name="size" Condition="m_string != 0">m_string->size</Item>
<Item Name="capacity" Condition="m_string != 0">m_string->capacity</Item>
<Item Name="refCount" Condition="m_string != 0">m_string->refCount</Item>
</Expand>
</Type>
</AutoVisualizer>