|<< Prev||- Up -||Next >>|
Once a value is displayed, it can be examined more closely by using the context menus attached to its nodes. A node's context menu offers a configurable set of type-specific operations on that node and can be opened by right-clicking the node's so-called access point.
Node access points are defined as follows:
Any atomic node is a node access point for itself. (An atomic node is a node that has no subnodes.)
For any tuple excluding lists, the label and the parentheses are access points for the entire tuple node.
For any record, the label and and the parentheses are access points for the entire record node. In particular, the record's features are defined not to be node access points.
The node access points of lists depend on the display mode. In tree mode, the brackets and pipe symbols (
'|') are node access points for the entire list. In graph mode, each pipe symbol is a node access point for the sublist starting at that point.
The Inspector offers three types of operations on nodes: exploration, filtering and mapping, and actions (see Figure 3.1).
Exploration allows to locally modify the depth and width exploration limits, thereby expanding or shrinking the value to the region of interest.
Mappings allow to transform values for display with respect to a given mapping function. This makes it possible to either arbitrarily prune regions of the value (also called filtering) or to extract information from abstract datatypes.
Actions allow to apply side-effecting operations on displayed values. For instance, this allows to make values available to external tools such as the experimental Constraint Investigator, for gathering information beyond the scope of the Inspector.
These types of operations are explained in the following sections.
When inspecting a large data structure, one often needs to zoom in on a subvalue or hide currently irrevelant data. This is what the exploration operations are intended for. Two different kinds of operations exist, for modifying the depth and the width limits respectively (see Figure 3.2).
Applying the operation ``Depth +n'' to a node causes the subtree starting at that node to be redrawn, with a depth of n levels. Applying the operation ``Depth -n'' causes the node to be pruned, as well as its n - 1 parent nodes. The effect of the global depth limit is that when new values are inspected, immediately the operation ``Depth +d'' is applied to them, where d is the global depth limit.
Every node also has a display width associated with it. If a node has a display width w, only its first w subtrees will be displayed (in the case that w is zero, that means none). Initially, all nodes are created with the default display width. Applying the operation ``Width +n'' or ``Width -n'' to a node modifies that node's display width by the specified amount and causes it to be redrawn accordingly.
Figure 3.2 shows some examples of the effects of the operations described above. They have all been obtained from inspecting the sample tuple given above, and applying operations to it as follows:
The sample tuple has been shrinked by applying ``Width -5''.
The sample tuple has been subject to applying ``Width -5'' once and ``Width +1'' twice.
The sample tuple has been collapsed by applying ``Depth -1''.
The sample tuple is only partially displayed when applying ``Depth +1''. Note that the operation does not augment the display depth, but replaces it.
The sample tuple has been partially displayed using ``Depth +1'' and then shrinked in width by applying ``Width -1'' twice. This shows that the exploration functions are compositional.
The Inspector defines default mappings for many data types, to perform commonly-used operations such as inspecting the state of mutable data structures. Figure 3.3 demonstrates an example of this: By default, dictionaries are displayed as the unspecific tag
<dictionary>. The default mapping ``Show Items'' for dictionaries replaces the dictionary node by a snapshot of its contents (specifically, as the result of the
Note how the different choice of background color indicates that this is, in fact, a mapped representation. Mappings can be undone using the context menu option ``unmap''.
Mappings have the following properties:
Mappings are fully compositional, meaning that any other mapping can be applied to an already-mapped node.
Mapping works on a per-node basis. In particular, the Inspector will apply new mappings to any child nodes of a mapped node.
Mapping functions are type-specific. That means that every type offers its own collection of mapping functions.
Mapping functions can be applied automaticly before inspection of the value. See Section 4.1 for details on how to do this. Keep in mind that the results can be confusing due to the per-node mapping strategy.
Figure 3.4 demonstrates the invocation of an action. The by-need future is forced, whereupon the Inspector will update its display accordingly, showing its value.
Like mappings, actions are type-specific. See Section 5.5.3 for details on how to register new actions.
Some of the operations presented above can also be triggered on the selected node by the ``Selection'' menu. To ``select'' a node means to left-click a node access point: The corresponding node will be drawn with a selection frame around it. Figure 3.5 shows the operations that can be applied to the selected node.
Figure 3.6 demonstrates another application of selections: Any selected substructure can be lifted to toplevel by applying the ``Clear all but Selection'' command from the Inspector menu.
Substructure lifting is intended to rapidly prune large trees and currently works only with one structure selection. It cannot be undone.
|<< Prev||- Up -||Next >>|