;------------------------------------------------------------------------------
; GEAR types visualizer
;------------------------------------------------------------------------------
; How to install :
; - Select and copy the text below.
; - Open autoexp.dat at location C:\Program Files\Microsoft Visual Studio 8\Common7\Packages\Debugger
; - Append the text under the [Visualizer] section to the VS file.
;
; You don't need to restart or stop Visual Studio when doing this as this file is always reloaded everytime
; the debugger start.


;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
; Gear
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

; Some things to know that are not explained in the original autoexp.dat
;
; $c vs $e
;     In the preview block:
;         $c refers to the top level container of the current preview line in the debugger
;             ex: If A previews B which previews C, $c in C's preview block will refer to A
;         $e refers to the element of the actual rule
;     In the children block:
;         $c and $e both refers the element of the actual rule
;     In a #tree or #array:
;         $c and $e behaves the same way than in a preview block (see above), except:
;         In a #tree specification, #tree(...) : $e refers to the dereference of node pointers
;
; In short, use $e everywhere unless you have a good reason to use $c
;
; #tree(
;     head: pointer to the starting node
;     left: pointer to the left node
;     right: pointer to the right node
;     skip: [optional] pointer value used as the end of a branch (so it won't be evaluated)
;     size: [optional] limit the number of nodes to display as an array
;
; useful readings:
; http://www.virtualdub.org/blog/pivot/entry.php?id=120
; http://www.virtualdub.org/blog/pivot/entry.php?id=172
;

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
; Gear::GearBasicString
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

; Ansi version
Gear::GearBasicString<char,*> {
    preview (
        #(
            "length=",      [$e.m_string->size, u],
            ", capacity=",  [$e.m_string->capacity, u],
            ", string=",    [$e.m_string->data, s]
        )
    )

    stringview ( [$e.m_string->data, sb] )
}

; All other are considered as unicode...
Gear::GearBasicString<*> {
    preview (
        #(
            "length=",      [$e.m_string->size, u],
            ", capacity=",  [$e.m_string->capacity, u],
            ", string=",    [$e.m_string->data, su]
        )
    )

    stringview ( [$e.m_string->data, sub] )
}



;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;                               GEAR MATH TYPES
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

;------------------------------------------------------------------------------
;  Gear::Fixed32
;------------------------------------------------------------------------------
Gear::Fixed32{
    preview
    (
        #( [$e.m_Fixed32 / 4096.0f,g] )
    )

	children
	(
		#( m_Fixed32: [$c.m_Fixed32,d] )
	)
}


;------------------------------------------------------------------------------
;  Gear::VectorGeneric<float>, Gear::VectorGeneric<double>, Gear::VectorGeneric<Gear::Fixed32>
;------------------------------------------------------------------------------
Gear::VectorGeneric<float,*>|Gear::VectorGeneric<double,*>{
	children
	(
        #array
        (
		    expr : 	[$e.v[$i],g],
		    size : $T1
	    )
	)

    preview
    (
        #(
			"{",
			#array
            (
			    expr : 	[$e.v[$i],g],
			    size : $T1
		    ),
		    "}"
		 )
	)
}

Gear::VectorGeneric<Gear::Fixed32,*>{
	children
	(
        #array
        (
		    expr : $e.v[$i],
		    size : $T1
	    )
	)

    preview
    (
        #(
			"{",
			#array
            (
			    expr : $e.v[$i],
			    size : $T1
		    ),
		    "}"
		 )
	)
}


;------------------------------------------------------------------------------
;  __m128 - To reorder the fields in the preview
;------------------------------------------------------------------------------
__m128{
    preview
    (
        #( "{",[$e.m128_f32[0],g],", ",[$e.m128_f32[1],g],", ",[$e.m128_f32[2],g],", ",[$e.m128_f32[3],g],"}")
    )
}

;------------------------------------------------------------------------------
;  Gear::Vector2, Gear::Vector3, Gear::Vector4
;------------------------------------------------------------------------------

Gear::Vector2<*>{
    preview
    (
        #( "{",[(($T1*)&$c)[0]],", ",[(($T1*)&$c)[1]],"}" )
    )
    
    children
	(
	    #(
    	    #(x: [(($T1*)&$c)[0]]),
    	    #(y: [(($T1*)&$c)[1]])
	    )
	)
}

Gear::Vector3<*>{
    preview
    (
        #( "{",[(($T1*)&$c)[0]],", ",[(($T1*)&$c)[1]],", ",[(($T1*)&$c)[2]],"}" )
    )
    
    children
	(
	    #(
    	    #(x: [(($T1*)&$c)[0]]),
    	    #(y: [(($T1*)&$c)[1]]),
    	    #(z: [(($T1*)&$c)[2]])
	    )
	)
}

Gear::Vector4<*>{
    preview
    (
        #( "{",[(($T1*)&$c)[0]],", ",[(($T1*)&$c)[1]],", ",[(($T1*)&$c)[2]],", ",[(($T1*)&$c)[3]],"}" )
    )
    
    children
	(
	    #(
    	    #(x: [(($T1*)&$c)[0]]),
    	    #(y: [(($T1*)&$c)[1]]),
    	    #(z: [(($T1*)&$c)[2]]),
    	    #(w: [(($T1*)&$c)[3]])
	    )
	)
}

;------------------------------------------------------------------------------
;  Gear::Quaternion4
;------------------------------------------------------------------------------
Gear::Quaternion4<*>{
    preview
	(
		#( $c.q.v )
	)
}


;------------------------------------------------------------------------------
;  Gear::Matrix22, Gear::Matrix33, Gear::Matrix34, Gear::Matrix44
;------------------------------------------------------------------------------
Gear::Matrix22<*>{
    preview
	(
	   #( $e.m[0], $e.m[1] )
	)

	children
	(
		#array
		(
			expr : $c.m[$i],
			size : 2
		)
	)
}

Gear::Matrix33<*>{
    preview
	(
	    #( $e.m[0], $e.m[1], $e.m[2] )
	)

	children
	(
		#array
		(
			expr : $c.m[$i],
			size : 3
		)
	)
}

Gear::Matrix34<*>|Gear::Matrix44<*>{
    preview
	(
	    #( $e.m[0], $e.m[1], $e.m[2], $e.m[3] )
	)

	children
	(
		#array
		(
			expr : $c.m[$i],
			size : 4
		)
	)
}

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;                               GEAR CONTAINERS
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

;------------------------------------------------------------------------------
;  Gear::GearVector, Gear::SacVector
;------------------------------------------------------------------------------
Gear::GearVector<*,*,*,*>|Gear::SacVector<*,*,*,*>{

    preview
    (
        #(
			"{size=" , $c.m_size,
            " ...}"
		)
	)

	children
	(
	    #(
	        [original]: [$c,!],
	        size: $c.m_size,
            #array
            (
		        expr :	(($T1*)$c.m_array)[$i],
		        size :	$c.m_size
	        )
		  )
	)
}

Gear::SacVector<*,*,*,*>::ConstIterator|Gear::SacVector<*,*,*,*>::Iterator|Gear::SacVector<*,*,*,*>::ConstReverseIterator|Gear::SacVector<*,*,*,*>::ReverseIterator{
    preview
    (
        #(
			"{value=" , *($c.m_iterator),
            " ...}"
		)
	)

	children
	(
	    #(
	        [original]: [$c,!],
	        value : *($c.m_iterator)
		  )
	)

}

;------------------------------------------------------------------------------
;  Gear::GearMap, Gear::GearRBTree, Gear::SacRBTree
;------------------------------------------------------------------------------

; Because of a limitation of this parser, the template parameter that depends on a previous template parameter must partially be hardcoded, and thus $T5 == $T1

; IsLessThanFunctor specialisation
Gear::GearMap<*,*,*,*,Gear::IsLessThanFunctor<*> >|Gear::SacMap<*,*,*,*,Gear::IsLessThanFunctor<*> >{
    preview
    (
        #(
            "{count=" , $e.m_count,
            "} root=", (*((Gear::SacRBTree<Gear::SacPair<$T1 const ,$T2>,$T1,$T3,$T4,Gear::IsLessThanFunctor<$T5>,Gear::Select1st<Gear::SacPair<$T1 const ,$T2> > >::TreeNode*)$e.m_tree.m_parent)),
            " ...}"
	    )
	)

    children
    (
        #(
            #tree
            (
                head : $e.m_tree.m_parent,
                skip : 0,
                size : $e.m_count,
                left : m_left,
                right : m_right
            ) : (*((Gear::SacRBTree<Gear::SacPair<$T1 const ,$T2>,$T1,$T3,$T4,Gear::IsLessThanFunctor<$T5>,Gear::Select1st<Gear::SacPair<$T1 const ,$T2> > >::TreeNode*)&$e)),
            #(
                root: (*((Gear::SacRBTree<Gear::SacPair<$T1 const ,$T2>,$T1,$T3,$T4,Gear::IsLessThanFunctor<$T5>,Gear::Select1st<Gear::SacPair<$T1 const ,$T2> > >::TreeNode*)$e.m_tree.m_parent)),
                left most: (*((Gear::SacRBTree<Gear::SacPair<$T1 const ,$T2>,$T1,$T3,$T4,Gear::IsLessThanFunctor<$T5>,Gear::Select1st<Gear::SacPair<$T1 const ,$T2> > >::TreeNode*)$e.m_tree.m_left)),
                right most: (*((Gear::SacRBTree<Gear::SacPair<$T1 const ,$T2>,$T1,$T3,$T4,Gear::IsLessThanFunctor<$T5>,Gear::Select1st<Gear::SacPair<$T1 const ,$T2> > >::TreeNode*)$e.m_tree.m_right)),
                count: $e.m_count,
                [original] : [$e,!]
            )
        )
    )
}

Gear::GearRBTree<*,*,*,*,*,*>|Gear::SacRBTree<*,*,*,*,*,*>{
    preview
    (
        #(
            "{count=" , $e.m_count,
            "} root=", (*((Gear::SacRBTree<$T1,$T2,$T3,$T4,$T5,$T6>::TreeNode*)$e.m_tree.m_parent)),
            " ...}"
	    )
	)

    children
    (
        #(
            #tree
            (
                head : $e.m_tree.m_parent,
                skip : 0,
                size : $e.m_count,
                left : m_left,
                right : m_right
            ) : (*((Gear::SacRBTree<$T1,$T2,$T3,$T4,$T5,$T6>::TreeNode*)&$e)),
            #(
                root: (*((Gear::SacRBTree<$T1,$T2,$T3,$T4,$T5,$T6>::TreeNode*)$e.m_tree.m_parent)),
                left most: (*((Gear::SacRBTree<$T1,$T2,$T3,$T4,$T5,$T6>::TreeNode*)$e.m_tree.m_left)),
                right most: (*((Gear::SacRBTree<$T1,$T2,$T3,$T4,$T5,$T6>::TreeNode*)$e.m_tree.m_right)),
                count: $e.m_count,
                [original] : [$e,!]
            )
        )
    )
}

Gear::SacRBTree<*,*,*,*,*,*>::TreeNode{

    preview
    (
        #(
            "{element=" , $e.m_element,
            " color=" , $e.m_color,
            " ...}"
        )
	)

    children
    (
       #(
            [original]:[$e,!],
            left:
                  #if ($e.m_left > 0)
                  (
                    (Gear::SacRBTree<$T1,$T2,$T3,$T4,$T5,$T6>::TreeNode *)$e.m_left
                  )
                  #else
                  (
                    (void *)$e.m_left
                  )
                  ,
            right:
                  #if ($e.m_right > 0)
                  (
                    (Gear::SacRBTree<$T1,$T2,$T3,$T4,$T5,$T6>::TreeNode *)$e.m_right
                  )
                  #else
                  (
                    (void *)$e.m_right
                  )
                  ,
            color:$e.m_color,
            element:$e.m_element
         )
    )
}

Gear::SacRBTree<*,*,*,*,*,*>::ConstIterator|Gear::SacRBTree<*,*,*,*,*,*>::Iterator|Gear::SacRBTree<*,*,*,*,*,*>::ConstReverseIterator|Gear::SacRBTree<*,*,*,*,*,*>::ReverseIterator{
    preview
    (
        #(
            "{ ",
            ((Gear::SacRBTree<$T1,$T2,$T3,$T4,$T5,$T6>::TreeNode *)$e.m_node)->m_element,
            " ...}"
        )
    )

    children
    (
        #(
            [original]: [$e,!],
            value : ((Gear::SacRBTree<$T1,$T2,$T3,$T4,$T5,$T6>::TreeNode *)$e.m_node)->m_element
        )
    )
}


;------------------------------------------------------------------------------
;  Gear::GearList, Gear::SacList
;------------------------------------------------------------------------------
Gear::GearList<*,*,*>|Gear::SacList<*,*,*>{
    preview
    (
	        #(
			        "{size=" , $c.m_size,
                    " ...}"
		        )
	)

    children
    (
        #(
            #list
            (
              head: $c.m_node.m_next,
              next: m_next,
              size: $c.m_size
            ) : ((Gear::SacList<$T1,$T2,$T3>::ListNode *)&$e)->m_element


        )
    )

}

Gear::SacList<*,*,*>::ConstIterator|Gear::SacList<*,*,*>::Iterator|Gear::SacList<*,*,*>::ConstReverseIterator|Gear::SacList<*,*,*>::ReverseIterator{
    preview
    (
        #(
			"{ ",
			((Gear::SacList<$T1,$T2,$T3>::ListNode *)$c.m_node)->m_element,
            " ...}"
		)
	)

	children
	(
	    #(
	        [original]: [$c,!],
	        value : ((Gear::SacList<$T1,$T2,$T3>::ListNode *)$c.m_node)->m_element
		  )
	)

}



;------------------------------------------------------------------------------
;  Gear::GearQueue, Gear::SacQueue ; Gear::GearDeque, Gear::SacDeque
;------------------------------------------------------------------------------
Gear::GearQueue<*,*,*,*>|Gear::SacQueue<*,*,*,*>|Gear::GearDeque<*,*,*,*>|Gear::SacDeque<*,*,*,*>{

    preview
    (
        #(
			"{size=",
                    #if($c.m_begin <= $c.m_end)
                    (
                        [$c.m_end - $c.m_begin,i]
                    )
                    #else
                    (
                        [($c.m_capacity - $c.m_begin) + $c.m_end,i]
                    )
                    ,
            " ...}"
		)
	)

    children
    (
        #(
           [original]:[$c,!],
           size:
                    #if($c.m_begin <= $c.m_end)
                    (
                        [$c.m_end - $c.m_begin,i]
                    )
                    #else
                    (
                        [($c.m_capacity - $c.m_begin) + $c.m_end,i]
                    )
                    ,
           front: $c.m_array[$c.m_begin % $c.m_capacity],
           back:
                    #if ($c.m_end == 0)
                    (
                        $c.m_array[$c.m_capacity - 1]
                    )
                    #else
                    (
                        $c.m_array[$c.m_end - 1]
                    )
                    ,
           capacity : $c.m_capacity,
           #array (
                    expr: $c.m_array[($c.m_begin + $i) % $c.m_capacity],
                    size:
                          #if($c.m_begin <= $c.m_end)
                          (
                             [$c.m_end - $c.m_begin,i]
                          )
                          #else
                          (
                             [($c.m_capacity - $c.m_begin) + $c.m_end,i]
                          )
           )
        )
    )

}

Gear::SacQueue<*,*,*,*>::ConstIterator|Gear::SacQueue<*,*,*,*>::Iterator|Gear::SacQueue<*,*,*,*>::ConstReverseIterator|Gear::SacQueue<*,*,*,*>::ReverseIterator|Gear::SacDeque<*,*,*,*>::ConstIterator|Gear::SacDeque<*,*,*,*>::Iterator|Gear::SacDeque<*,*,*,*>::ConstReverseIterator|Gear::SacDeque<*,*,*,*>::ReverseIterator{
    preview
    (
        #(
			"{ ",  $c.m_parent->m_array[$c.m_iterator % $c.m_parent->m_capacity] ,
            " ...}"
		)
	)

	children
	(
	    #(
	        [original]: [$c,!],
	        value: $c.m_parent->m_array[$c.m_iterator % $c.m_parent->m_capacity]
		  )
	)

}

;------------------------------------------------------------------------------
;  Gear::GearPriorityQueue, Gear::SacPriorityQueue
;------------------------------------------------------------------------------
Gear::GearPriorityQueue<*,*,*,*,*>|Gear::SacPriorityQueue<*,*,*,*,*>{

    preview
    (
        #(
			"{size=" , $c.m_internalArray.m_size,
            " ...}"
		)
	)

	children
	(
	    #(
	        [original]: [$c,!],
	        top:
	               #if ( $c.m_internalArray.m_size > 0 )
	               (
	                    ($c.m_internalArray.m_array)[0]
	               )
	               #else
	               (
	                    0x00000000
	               )
	               ,
	        size: $c.m_internalArray.m_size,
	        #if ( $c.m_internalArray.m_size > 0)
	        (
                #array
                (
		            expr :	($c.m_internalArray.m_array)[$i],
		            size :	$c.m_internalArray.m_size
	            )
	         )

		  )
	)
}

;------------------------------------------------------------------------------
;  Gear::SacStaticVector, Gear::SacStaticVector
;------------------------------------------------------------------------------
Gear::GearStaticVector<*,*,*,*>|Gear::SacStaticVector<*,*,*,*>{

    preview
    (
        #(
			"{size=" , $c.m_size,
            " ...}"
		)
	)

	children
	(
	    #(
	        [original]: [$c,!],
	        size: $c.m_size,
	         #array
                (
		            expr :	(($T1 *)&$c.m_staticArray)[$i],
		            size :	$c.m_size
	            )
		  )
	)
}

Gear::SacStaticVector<*,*,*,*>::ConstIterator|Gear::SacStaticVector<*,*,*,*>::Iterator|Gear::SacStaticVector<*,*,*,*>::ConstReverseIterator|Gear::SacStaticVector<*,*,*,*>::ReverseIterator{
    preview
    (
        #(
			"{ ",  ($T1 *)$c.m_iterator,
            " ...}"
		)
	)

	children
	(
	    #(
	        [original]: [$c,!],
	        value: (($T1 *)$c.m_iterator)
		  )
	)

}

;------------------------------------------------------------------------------
;  Gear::GearSparseVector, Gear::SacSparseVector
;------------------------------------------------------------------------------
Gear::GearSparseVector<*,*,*,*>|Gear::SacSparseVector<*,*,*,*>{

    preview
    (
        #(
			"{size=" , $c.m_size,
            " ...}"
		)
	)

	children
    (
        #(
           [original]:[$c,!],
           size: $c.m_size,
           front: (($T1 *)$c.m_bucketList.m_array[$c.m_bucketList.m_begin / $c.m_bucketsize])[$c.m_bucketList.m_begin % $c.m_bucketsize],
           back:  (($T1 *)$c.m_bucketList.m_array[($c.m_bucketList.m_begin + $c.m_size - 1) / $c.m_bucketsize])[($c.m_bucketList.m_begin + $c.m_size - 1 ) % $c.m_bucketsize],
           #array (
                    expr: (($T1 *)$c.m_bucketList.m_array[($c.m_bucketList.m_begin + $i) / $c.m_bucketsize])[($c.m_bucketList.m_begin + $i ) % $c.m_bucketsize],
                    size: $c.m_size
                  )
        )
    )
}

Gear::SacSparseVector<*,*,*,*>::ConstIterator|Gear::SacSparseVector<*,*,*,*>::Iterator|Gear::SacSparseVector<*,*,*,*>::ConstReverseIterator|Gear::SacSparseVector<*,*,*,*>::ReverseIterator{
    preview
    (
        #(
			"{ ",  (($T1 *)$c.m_parent->m_bucketList.m_array[($c.m_parent->m_bucketList.m_begin + $c.m_iterator) / $c.m_parent->m_bucketsize])[($c.m_parent->m_bucketList.m_begin + $c.m_iterator ) % $c.m_parent->m_bucketsize],
            " ...}"
		)
	)

	children
	(
	    #(
	        [original]: [$c,!],
	        value: (($T1 *)$c.m_parent->m_bucketList.m_array[($c.m_parent->m_bucketList.m_begin + $c.m_iterator) / $c.m_parent->m_bucketsize])[($c.m_parent->m_bucketList.m_begin + $c.m_iterator ) % $c.m_parent->m_bucketsize]
		  )
	)
}

;------------------------------------------------------------------------------
;  Gear::BitArray
;------------------------------------------------------------------------------
Gear::BitArray<*,*,*>{
    preview
    (
        #(
			"{size=" , $c.m_NbElement,
            " ...}"
		)
	)

	children
    (
        #(
           [original]:[$c,!],
           size : $c.m_NbElement,
           #array (
                    expr: #if ($c.m_BitPerElement > (32 - (( $c.m_BitPerElement * $i ) - ( ( ($c.m_BitPerElement * $i) / 32 ) * 32 ))) )
                          (
                            ((((&($c.m_pArray[(($c.m_BitPerElement * $i) / 32)]))[0] & ((0xFFFFFFFF >> (32 - $c.m_BitPerElement)) << (( $c.m_BitPerElement * $i ) - ( ( ($c.m_BitPerElement * $i) / 32 ) * 32 )))) >> (( $c.m_BitPerElement * $i ) - ( ( ($c.m_BitPerElement * $i) / 32 ) * 32 ))) | (((&($c.m_pArray[(($c.m_BitPerElement * $i) / 32)]))[1] & ((0xFFFFFFFF >> (32 - $c.m_BitPerElement)) >> (32 - (( $c.m_BitPerElement * $i ) - ( ( ($c.m_BitPerElement * $i) / 32 ) * 32 ))))) << (32 - (( $c.m_BitPerElement * $i ) - ( ( ($c.m_BitPerElement * $i) / 32 ) * 32 )))))
                          )
                          #else
                          (
                            (((&($c.m_pArray[(($c.m_BitPerElement * $i) / 32)]))[0] & ((0xFFFFFFFF >> (32 - $c.m_BitPerElement)) << (( $c.m_BitPerElement * $i ) - ( ( ($c.m_BitPerElement * $i) / 32 ) * 32 )))) >> (( $c.m_BitPerElement * $i ) - ( ( ($c.m_BitPerElement * $i) / 32 ) * 32 )))
                          )
                            ,
                    size: $c.m_NbElement
                  )


        )
    )
}

;------------------------------------------------------------------------------
;  Gear::GearStack, Gear::SacStack
;------------------------------------------------------------------------------
Gear::GearStack<*,*,*,*>|Gear::SacStack<*,*,*,*>{

    preview
    (
        #(
			"{size=" , $c.m_internalArray.m_size,
            " ...}"
		)
	)

	children
	(
	    #(
	        [original]: [$c,!],
	        size: $c.m_internalArray.m_size,
	        top : ($c.m_internalArray.m_array)[$c.m_internalArray.m_size - 1],
            #array
            (
		        expr :	($c.m_internalArray.m_array)[$i],
		        size :	$c.m_internalArray.m_size
	        )
		  )
	)
}

;------------------------------------------------------------------------------
;  Gear::BitVector, Gear::BitVector
;------------------------------------------------------------------------------
Gear::BitVector<*>{

    preview
    (
        #(
			"{size=" , $T1,
            " ...}"
		)
	)

	children
	(
	    #(
	        [original]: [$c,!],
	        size: $T1,
	        value : ($c.m_pBits[((0) >> 5)]),
	        bitnumber : ((0) & 31),
	        #array
	        (
	            expr: (($c.m_pBits[(($i) >> 5)]) >> (($i) & 31)) & 1,
	            size : $T1
	        )
		  )
	)
}

;------------------------------------------------------------------------------
;  Gear::CircularBuffer
;------------------------------------------------------------------------------
Gear::CircularBuffer<*,*>{

    preview
    (
        #(
			"{size=" , $c.m_elementCount,
            " ...}"
		)
	)

	children
	(
	    #(
	        [original]: [$c,!],
	        size: $c.m_elementCount,
	        read position : $c.m_elementReadPos,
	        write position :  $c.m_elementWritePos,
	        avalaible : $c.m_availablelement,
	        #array
            (
		        expr :	$c.m_buffer[$i],
		        size :	$c.m_elementCount
	        )
		  )
	)
}

;------------------------------------------------------------------------------
;  Gear::GearHashMap, Gear::SacHashMap
;------------------------------------------------------------------------------
Gear::GearHashMap<*,*,*,*,*,*>|Gear::SacHashMap<*,*,*,*,*,*>{
    preview
    (
	        #(
			        "{count=" , $c.m_uiCount,
                    " ...}"
		        )
	)

    children
    (
        #(
            [original] : [$c,!],
            count : $c.m_uiCount,
            hash size : $c.m_uiHashSize,
            #array
            (
		        expr :($c.m_pHashTable)[$i],
		        size :	$c.m_uiHashSize
	        )
        )
    )

}

Gear::SacHashMap<*,*,*,*,*,*>::HashMapItem{
    preview
    (
	        #(
			        "{key=" , $c.m_key,
			        " value=" , $c.m_val,
                    " ...}"
		        )
	)

    children
    (
        #(
            [original] : [$c,!],
			 #if ( $c.m_pNext > 0)
			 (
			    #(
			        key : $c.m_key,
			        value : $c.m_val,
			        next  : $c.m_pNext
			      )
			 )
			 #else
			 (
			     #(
			        key : $c.m_key,
			        value : $c.m_val
			      )
			 )
        )
    )

}

Gear::SacHashMap<*,*,*,*,*,*>::ConstIterator|Gear::SacHashMap<*,*,*,*,*,*>::Iterator|Gear::SacHashMap<*,*,*,*,*,*>::ConstReverseIterator|Gear::SacHashMap<*,*,*,*,*,*>::ReverseIterator{
    preview
    (
        #(
			 "{key=" , ((Gear::SacHashMap<$T1,$T2,$T3,$T4,$T5,$T6>::HashMapItem*)$c.m_iterator)->m_key,
			 " value=" , ((Gear::SacHashMap<$T1,$T2,$T3,$T4,$T5,$T6>::HashMapItem*)$c.m_iterator)->m_val,
             " ...}"
		 )
	)

	children
	(
	    #(
		    key : ((Gear::SacHashMap<$T1,$T2,$T3,$T4,$T5,$T6>::HashMapItem*)$c.m_iterator)->m_key,
			value : ((Gear::SacHashMap<$T1,$T2,$T3,$T4,$T5,$T6>::HashMapItem*)$c.m_iterator)->m_val
		 )
	)
}

;------------------------------------------------------------------------------
;  Shears types
;------------------------------------------------------------------------------
Gear::Shears::DataStream{
    preview
    (
        #(
            [$e.m_name,s]
         )
    )
}

Gear::Shears::Barrier{
    preview
    (
        #(
            [$e.m_name,s]
         )
    )
}

Gear::Shears::Condition{
    preview
    (
        #(
            [$e.m_name,s]
         )
    )
}

Gear::Shears::BaseTask{
    preview
    (
        #(
            [$e.m_name,s]
         )
    )
}

Gear::Shears::StoryboardTask{
    preview
    (
        #(
            $e.m_baseTask
         )
    )
}

Gear::Shears::WorkUnit{
    preview
    (
        #(
            $e.m_baseTask
         )
    )
}