PCTree (SAFS API DOCUMENT)

java.lang.Object
- org.safs.Tree
- - org.safs.PCTree

All Implemented Interfaces:: java.io.Serializable

public class PCTree
extends Tree

PCTree, used by various testing tool's ProcessContainer, is used to produce consistent recognition strings across all tools.

Historically, the algorithm used here and in the ProcessContainer classes was intended to mirror the algorithm used by earlier versions of SQA Robot a.k.a Rational Robot. In this way, recognition strings that would work for Robot would also work in other testing tools that might be used simultaneously. This allowed one App Map to work for all testing tools involved.

However, more recent versions of Robot have introduced large and critical departures from the traditional algorithm in different environments. For example, the .Net support in Robot has introduced a completely different algorithm for object recognition that is inconsistent with previous versions of Robot and other environments supported by Robot.

Consequently, the algorithm here is no longer guaranteed to mirror these later versions of Robot recognition algorithms. Instead, we will stick with this single, fairly well-defined algorithm that should provide consistency and interoperability for all current and future SAFS engines EXCEPT for later versions of IBM's Rational Robot in certain environments (like later versions of .NET).

The tradional algorithm:

For a type, a child will increment the index, depth first, a sibling will also increment the index, breadth second.

example:

 
                  1
                  |
         _________2___________
         \                    \     
      ___3________         ___4_________
     /   /\    \  \       /   /\    \   \  
    4   5  7    9  10    5   6  8    10  11
        /   \                /   \        
       6     8              7     9       
       /      \             /      \
   text1,2   text3,4    text5,6   text7,8

Items with onlyOneChildVisible like TabControls are an exception, because their immediate child containers share the same space and are not all visible

example:

1 | _________2____________________________________ \ \ TabControl ___4________ \ \____tabN______ / /\ \ \ \ \ / / \ \ \ visible not-visible 5 6 8 10 11 ___3________ ___3________ / \ / /\ \ \ / /\ \ \ 7 9 4 5 7 9 10 4 5 7 9 10 / \ / \ / \ text5,6 text7,8 6 8 6 8 / \ / \ text1,2 text3,4 text1 text2

Same app with TabControl with different Tab visible:

 
                 1
                 |
        _________2____________________________________
        \                                             \
      TabControl                                   ___4________
         \     \____tabN______                    /   /\   \   \
          \                   \                  /   /  \   \   \
       not-visible          visible             5   6    8  10  11
       ___3________         ___3________           /      \
      /   /\    \  \       /   /\    \  \         7        9
     4   5  7    9  10    4   5  7    9  10      /          \
        /    \               /    \           text3,4     text5,6
       6      8             6      8       
      /        \           /        \
   text1,2   text3,4    text1     text2 
   
 clicking on yet a another tab may find:

 1-2--TabControl
         \
         3
         /
       table1

Note how all containers immediately under each tab start with the same index. In other words, the sibling breadth layer does not increment the index. This is because at any given time only one pane will be visible and it will always be found at Index=3 (given the example above).

There are known shortcomings to this algorithm. Most notable is the changing indices of components shown in the rightmost Panel #4 when different Tabs are selected in the TabControl. Alternative algorithms may be used in later releases allowing the user to choose between using the traditional algorithm, and any new one.

Since:: OCT 13, 2003
OCT 13, 2003 (DBauman) Original Release
OCT 14, 2003 (DBauman) adding all of the 'part' info, WE does the generation of the recognition string, so now we have lots of properties like 'name', 'type', 'myclass', 'nameValue', 'caption', 'classIndex', 'path', and 'parent'
OCT 31, 2003 (DBauman) adding comments
SEP 16, 2005 (Carl Nagle) Major overall to make recognition strings more consistent across technologies like Java, .NET, and WIN32.
JUL 08, 2008 (JunwuMa) added method getComponentRecogString(boolean), which returns the recognition string of the PCTree on this level. Called by STAFProcessContainer.RsPCTreeMap.CreateJTreeNodes()
NOV 06, 2008 (JunwuMa) Added methods isIgnoredNode() and toIniStringWithoutIgnoredNodes() supporting ignoring some containers both in mapping file and in component hierarchy. Called by STAFProcessContainer.
NOV 11, 2008 (JunwuMa) Introduced a new member, objectclass, for holding the real class name of the represented component. Modified ignoreParentRecognitionString(PCTree), added code ignoring the container that is one of the #containerClassesIgnoredForRecognition.
NOV 27, 2008 (JunwuMa) Add member ID for holding the ID of represented component. Modify getRecogString(boolean) adding ID qualifier for generating R-Strings.
JAN 16, 2009 (JunwuMa) Add member indexOnly to decide whether using 'Index/ClassIndex' or not (Auto Qualifier) when generating R-Strings by calling getRecogString(bool). See org.safs.tools.drivers.RStringStrategy.
MAY 01, 2009 (Carl Nagle) Changes to complete FULLPATH_SEARCH_MODE implementation.
MAY 25, 2011 (Dharmesh4) Updated RFSM Search Flex recognition string support.
APR 15, 2013 (Lei Wang) Update to permit user to update the tree node's name.
JUN 14, 2013 (Lei Wang) Update to add extra qualifier "index=" for objects having the same ID/Name.
Author:: DBauman
See Also:: Serialized Form

Field Summary

Fields
Modifier and Type	Field and Description
`static java.lang.String`	`captionPart`
`static java.lang.String`	`classIndexPart`
`static java.lang.String`	`classPart`
`static java.lang.String`	`idPart`
`static java.lang.String`	`indexPart`
`static java.lang.String`	`namePart`
`static java.lang.String`	`partSeparator`
`static java.lang.String`	`pathPart`
`static java.lang.String`	`processName`
`static java.lang.String`	`recogSeparator`
`static java.lang.String`	`textPart`
`static int`	`totalChildCountWithCommentsAndBlankLines`
`static java.lang.String`	`typePart`

Fields inherited from class org.safs.Tree
EQUAL_SEPARATOR, PATH_SEPARATOR

Constructor Summary

Constructors
Constructor and Description

PCTree()

Constructors
Constructor and Description
`PCTree()`

Method Summary

All Methods Static Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`boolean`	`doAppendCompInfo()` Return TRUE if we are to append CompType info to output recognition strings.
`protected java.lang.String`	`generateMapKey(java.lang.String prefix, java.lang.String value)` Generate a key to be used for map `idNameIndexMap`
`protected java.lang.String`	`getAppendedCompInfo()`
`protected java.lang.String`	`getBlankLine()` Output a blank line and 'Child of' information if the parent control has onlyOneChildVisible (like TabControls).
`java.lang.String`	`getClassAbsIndex()` Get absolute class index return from engine (use for RFSM mode)
`java.util.Map`	`getCompMap()`
`java.lang.String`	`getComponentRecogString(boolean includeParentPart)` generate recognition string for the PCTree on this level.
`java.lang.String`	`getDefaultRecognition()` Return any defaultRecognition set.
`java.lang.String`	`getDomainName()`
`protected java.lang.String`	`getHeader()` Output header String (like '[windowname]'), if isContainerTypesUsedToSetupIndexMap.
`java.lang.String`	`getId()`
`java.lang.String[]`	`getIndex_types()`
`java.lang.String`	`getIndex_typesIndex(int index)`
`protected int`	`getIndex()` Get index, first try using the 'indexMap' setup with setupCompIndex, then try getIndexOld
`protected int`	`getIndex(java.lang.String type)` if type equals our type, return getIndex()+1, basically incrementing any previous index for a component of the same type.
`protected int`	`getIndexBase()` Generate base index based on this algorithm: getting our matching index based on all of our siblings, and our position.
`protected int`	`getIndexOld()` Generate index based on this algorithm: First get a starting index by asking our parent for an index for the type.
`boolean`	`getIndexOnly()`
`java.lang.String`	`getMyclass()`
`java.lang.String`	`getName()`
`java.lang.String`	`getNameValue()`
`java.lang.String`	`getObjectClass()`
`PCTree`	`getParent()`
`protected java.lang.String`	`getParentRecogString()` Recursively get all of the parent->parent->...
`java.lang.String`	`getPath()`
`protected int`	`getPathIndex()` (Future) Currently ALWAYS returns 0
`protected java.lang.String`	`getRecogString(boolean origCallerIsParent)` Build the piece of the recognition string that represents this component only.
`protected java.lang.String`	`getRFSMRecogString(boolean origCallerIsParent)` Build the piece of RFSM the recognition string that represents this component only.
`int`	`getSiblingIndex()`
`int`	`getTotalChildCountFromFirstChild()` Calculate the total child count of all children of this component.
`java.lang.String`	`getType()`
`protected boolean`	`ignoreParentRecognitionString(PCTree aparent)`
`boolean`	`isCaption()`
`boolean`	`isClassIndex()`
`boolean`	`isComponentVisible()`
`boolean`	`isFullPathSearchMode()`
`boolean`	`isIgnoredNode()` See if this node can be ignored according to 'shortenGeneralRecognition'.
`boolean`	`isMappedClassSearchMode()`
`boolean`	`isOnlyOneChildVisible()`
`boolean`	`isRfsmSearchMode()`
`boolean`	`isShortenGeneralRecognition()`
`boolean`	`isTextValue()`
`boolean`	`isWithCommentsAndBlankLines()`
`boolean`	`isWithNameIncludeOnlyCaption()`
`static void`	`main(java.lang.String[] args)` For testing only.
`static java.lang.String`	`removeNonNameChars(java.lang.String text)` Remove most typical non-alphanumeric characters from the provided text.
`static java.lang.String`	`removeNonNameChars(java.lang.String text, java.lang.String nextChar)` Remove all occurrences of nextChar from the text string.
`void`	`setAppendCompInfo(boolean appendCompInfo)` Set TRUE to append CompType info at the end of output recognition strings.
`void`	`setCaption(boolean caption)` Set true if the NameValue stored represents a components Caption= value.
`void`	`setClassAbsIndex(java.lang.String classAbsIndex)` Set absoulate class index
`void`	`setClassIndex(boolean classIndex)` Set true if the index stored for this component is considered to be a ClassIndex index instead of the normal object type index.
`void`	`setCompMap(java.util.Map compMap)` Set the Map object that holds the PCTrees for all objects encountered up to this point in the object hierarchy.
`void`	`setComponentVisible(boolean setVisible)` Set true if this component was visible at the time of processing.
`void`	`setDefaultRecognition(java.lang.String recog)` Usually only for the topmost parent, the recognition string provided by the user (or Process Container) Can be null;
`void`	`setDomainName(java.lang.String domainName)`
`void`	`setFullPathSearchMode(boolean fullPathSearchMode)`
`void`	`setId(java.lang.String id)`
`void`	`setIndex_types(java.lang.String[] index_types)`
`void`	`setIndexOnly(boolean indexOnly)`
`void`	`setMappedClassSearchMode(boolean mappedClassSearchMode)` set if MappedClassSearchMode is to be used.
`void`	`setMyclass(java.lang.String myclass)` Sets the class for the represented component.
`void`	`setName(java.lang.String name)` Sets the user-friendly name deduced for the represented component by something like ProcessContainer.
`void`	`setNameValue(java.lang.String nameValue)` Sets the text associated with any Name=, Caption=, or Text= recognition string.
`void`	`setObjectClass(java.lang.String objectclass)` Sets the class for the represented component.
`void`	`setOnlyOneChildVisible(boolean onlyOneChildVisible)` Set true if this component, like TabControls, has multiple children, but only one is visible at any given time.
`void`	`setParent(PCTree parent)` Set the parent PCTree object that represents the parent component of the component represented by this PCTree object.
`void`	`setPath(java.lang.String path)` Set the Path= information that may exist for some components (like menuitems).
`void`	`setRfsmSearchMode(boolean rfsmSearchMode)`
`void`	`setShortenGeneralRecognition(boolean shorten)` Set true if recognition strings should be stripped of intermediate parent recognition info that may be deemed unnecessary.
`void`	`setSiblingIndex(int siblingIndex)` Set the index of this sibling among all siblings.
`void`	`setTextValue(boolean textval)` Set true if the NameValue stored represents a components Text= value.
`void`	`setType(java.lang.String type)` Set the deduced component type for the represented component.
`protected void`	`setupIndexForIDName()` Set the absolute index for tree nodes who have the same ID or Name. It will be called during the traversal of the whole tree.
`void`	`setupIndexMap()` Setup the IndexMap values based on our described algorithm.
`protected void`	`setupIndexMap(int rdepth, java.util.HashMap indexMap, boolean onlyOneChildVisible, java.util.HashMap altMap)` Setup the IndexMap values based on our described algorithm.
`void`	`setWithCommentsAndBlankLines(boolean withCommentsAndBlankLines)` Set true if output is to include comments and\or blank lines.
`void`	`setWithNameIncludeOnlyCaption(boolean withNameIncludeOnlyCaption)` Set true if recognition strings should be stripped of intermediate parent recognition info that may be deemed unnecessary when we have a (uniquely) named target component.
`java.lang.String`	`toIniString()`
`java.lang.String`	`toIniStringWithoutIgnoredNodes()`
`java.lang.String`	`toString()` Output the PCTree
`boolean`	`updateName(java.lang.String oldName, java.lang.String newName)` Update the tree node's name.

Methods inherited from class org.safs.Tree
exactMatchPath, findMatchPath, getChildCount, getFirstChild, getLevel, getNextSibling, getSiblingCount, getUserObject, setChildCount, setFirstChild, setLevel, setNextSibling, setSiblingCount, setUserObject, toStringArray, toStringArrayWOSiblings

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, wait, wait, wait

- Field Detail
  - totalChildCountWithCommentsAndBlankLines
```
public static final int totalChildCountWithCommentsAndBlankLines
```
    See Also:
    
    Constant Field Values
  - recogSeparator
```
public static final java.lang.String recogSeparator
```
    See Also:
    
    Constant Field Values
  - typePart
```
public static final java.lang.String typePart
```
    See Also:
    
    Constant Field Values
  - classPart
```
public static final java.lang.String classPart
```
    See Also:
    
    Constant Field Values
  - partSeparator
```
public static final java.lang.String partSeparator
```
    See Also:
    
    Constant Field Values
  - namePart
```
public static final java.lang.String namePart
```
    See Also:
    
    Constant Field Values
  - captionPart
```
public static final java.lang.String captionPart
```
    See Also:
    
    Constant Field Values
  - indexPart
```
public static final java.lang.String indexPart
```
    See Also:
    
    Constant Field Values
  - pathPart
```
public static final java.lang.String pathPart
```
    See Also:
    
    Constant Field Values
  - textPart
```
public static final java.lang.String textPart
```
    See Also:
    
    Constant Field Values
  - classIndexPart
```
public static final java.lang.String classIndexPart
```
    See Also:
    
    Constant Field Values
  - idPart
```
public static final java.lang.String idPart
```
    See Also:
    
    Constant Field Values
  - processName
```
public static final java.lang.String processName
```
    See Also:
    
    Constant Field Values
- Constructor Detail
  - PCTree
```
public PCTree()
```
- Method Detail
  - isRfsmSearchMode
```
public boolean isRfsmSearchMode()
```
    Returns:
    
    true if rfsmSearchMode is true
  - setRfsmSearchMode
```
public void setRfsmSearchMode(boolean rfsmSearchMode)
```
    Parameters:
    
    set - true if rfsmSearchMode is to be used.
  - isFullPathSearchMode
```
public boolean isFullPathSearchMode()
```
    Returns:
    
    true if fullPathSearchMode is true
  - setFullPathSearchMode
```
public void setFullPathSearchMode(boolean fullPathSearchMode)
```
    Parameters:
    
    set - true if fullPathSearchMode is to be used.
  - isMappedClassSearchMode
```
public boolean isMappedClassSearchMode()
```
    Returns:
    
    true if mappedClassSearchMode is true
  - setMappedClassSearchMode
```
public void setMappedClassSearchMode(boolean mappedClassSearchMode)
```
    set if MappedClassSearchMode is to be used.
    
    Parameters:
    
    mappedClassSearchMode -
  - setDefaultRecognition
```
public void setDefaultRecognition(java.lang.String recog)
```
    Usually only for the topmost parent, the recognition string provided by the user (or Process Container) Can be null;
  - getDefaultRecognition
```
public java.lang.String getDefaultRecognition()
```
    Return any defaultRecognition set. May be null.
    
    See Also:
    
    setDefaultRecognition(String)
  - setAppendCompInfo
```
public void setAppendCompInfo(boolean appendCompInfo)
```
    Set TRUE to append CompType info at the end of output recognition strings. This is useful when using the App Map output to import component information into other tools. However, this information is not compatible with normal App Map usage (during testing) because the recognition string is no longer properly formed.
  - doAppendCompInfo
```
public boolean doAppendCompInfo()
```
    Return TRUE if we are to append CompType info to output recognition strings.
    
    See Also:
    
    setAppendCompInfo(boolean)
  - getId
```
public java.lang.String getId()
```
    Returns:
    
    the ID for represented component.
  - setId
```
public void setId(java.lang.String id)
```
  - getIndexOnly
```
public boolean getIndexOnly()
```
  - setIndexOnly
```
public void setIndexOnly(boolean indexOnly)
```
  - getName
```
public java.lang.String getName()
```
    Returns:
    
    the user-friendly name deduced for the represented component by something like ProcessContainer. This may be null if no name has ever been set.
  - updateName
```
public boolean updateName(java.lang.String oldName,
                          java.lang.String newName)
```
    Update the tree node's name.
    
    Parameters:
    
    oldName -
    
    newName -
    
    Returns:
  - setName
```
public void setName(java.lang.String name)
```
    Sets the user-friendly name deduced for the represented component by something like ProcessContainer.
  - getIndex_types
```
public java.lang.String[] getIndex_types()
```
    Returns:
    
    the index_types
  - getIndex_typesIndex
```
public java.lang.String getIndex_typesIndex(int index)
```
    Returns:
    
    the nth index_types item or null if invalid index
  - setIndex_types
```
public void setIndex_types(java.lang.String[] index_types)
```
    Parameters:
    
    index_types - the index_types to set
  - getType
```
public java.lang.String getType()
```
    Returns:
    
    the deduced component type for the represented component. If set, this generally comes from info derived from subclasses of GuiObjectData.
    
    See Also:
    
    GuiClassData
  - setType
```
public void setType(java.lang.String type)
```
    Set the deduced component type for the represented component. If set, this generally comes from info derived from subclasses of GuiClassData.
    
    See Also:
    
    GuiClassData
  - getObjectClass
```
public java.lang.String getObjectClass()
```
    Returns:
    
    the class for the represented component.
  - setObjectClass
```
public void setObjectClass(java.lang.String objectclass)
```
    Sets the class for the represented component.
  - getMyclass
```
public java.lang.String getMyclass()
```
    Returns:
    
    the class for the represented component.
  - setMyclass
```
public void setMyclass(java.lang.String myclass)
```
    Sets the class for the represented component.
  - getNameValue
```
public java.lang.String getNameValue()
```
    Returns:
    
    the text associated with any Name=, Caption=, or Text= recognition string.
  - setNameValue
```
public void setNameValue(java.lang.String nameValue)
```
    Sets the text associated with any Name=, Caption=, or Text= recognition string.
  - isCaption
```
public boolean isCaption()
```
    Returns:
    
    true if the NameValue stored represents a components Caption= value.
  - setCaption
```
public void setCaption(boolean caption)
```
    Set true if the NameValue stored represents a components Caption= value.
  - isTextValue
```
public boolean isTextValue()
```
    Returns:
    
    true if the NameValue stored represents a components Text= value.
  - setTextValue
```
public void setTextValue(boolean textval)
```
    Set true if the NameValue stored represents a components Text= value.
  - isWithNameIncludeOnlyCaption
```
public boolean isWithNameIncludeOnlyCaption()
```
    Returns:
    
    true if recognition strings should be stripped of intermediate parent recognition info that may be deemed unnecessary when we have a (uniquely) named target component.
  - setWithNameIncludeOnlyCaption
```
public void setWithNameIncludeOnlyCaption(boolean withNameIncludeOnlyCaption)
```
    Set true if recognition strings should be stripped of intermediate parent recognition info that may be deemed unnecessary when we have a (uniquely) named target component.
  - isWithCommentsAndBlankLines
```
public boolean isWithCommentsAndBlankLines()
```
    Returns:
    
    true if output is to include comments and\or blank lines?
  - setWithCommentsAndBlankLines
```
public void setWithCommentsAndBlankLines(boolean withCommentsAndBlankLines)
```
    Set true if output is to include comments and\or blank lines.
  - isShortenGeneralRecognition
```
public boolean isShortenGeneralRecognition()
```
    Returns:
    
    true if recognition strings should be stripped of intermediate parent recognition info that may be deemed unnecessary. For example, we know that the contentPane and layoutPane exist in Java JFrames so including them in the recognition string is usually unnecessary.
  - setShortenGeneralRecognition
```
public void setShortenGeneralRecognition(boolean shorten)
```
    Set true if recognition strings should be stripped of intermediate parent recognition info that may be deemed unnecessary.
  - isOnlyOneChildVisible
```
public boolean isOnlyOneChildVisible()
```
    Returns:
    
    true if this component, like TabControls, has multiple children, but only one is visible at any given time.
  - setOnlyOneChildVisible
```
public void setOnlyOneChildVisible(boolean onlyOneChildVisible)
```
    Set true if this component, like TabControls, has multiple children, but only one is visible at any given time.
  - isComponentVisible
```
public boolean isComponentVisible()
```
    Returns:
    
    true if this component was visible at the time of processing.
  - setComponentVisible
```
public void setComponentVisible(boolean setVisible)
```
    Set true if this component was visible at the time of processing.
  - isClassIndex
```
public boolean isClassIndex()
```
    Returns:
    
    true if the index stored for this component is considered to be a ClassIndex index instead of the normal object type index.
  - setClassIndex
```
public void setClassIndex(boolean classIndex)
```
    Set true if the index stored for this component is considered to be a ClassIndex index instead of the normal object type index.
  - getClassAbsIndex
```
public java.lang.String getClassAbsIndex()
```
    Get absolute class index return from engine (use for RFSM mode)
    
    Returns:
  - setClassAbsIndex
```
public void setClassAbsIndex(java.lang.String classAbsIndex)
```
    Set absoulate class index
    
    Parameters:
    
    classAbsIndex -
  - getSiblingIndex
```
public int getSiblingIndex()
```
    Returns:
    
    the index of this sibling among all siblings.
  - setSiblingIndex
```
public void setSiblingIndex(int siblingIndex)
```
    Set the index of this sibling among all siblings.
  - getPath
```
public java.lang.String getPath()
```
    Returns:
    
    the Path= information that may exist for some components (like menuitems). This value may be null if the component is not one found via Path= information.
  - setPath
```
public void setPath(java.lang.String path)
```
    Set the Path= information that may exist for some components (like menuitems). Generally, components found by Path= are not considered children of their parent object, but an additional recognition Path property added to the parent object. For example, the "File->Exit" menuitem is a Path property tacked onto the parent menu as in:
    - ExitItem="Type=Window;Name=Main;\;Type=Menu;Index=1;Path=File->Exit"
  - getParent
```
public PCTree getParent()
```
    Returns:
    
    the PCTree object (if any) that represents the parent component of the component represented by this PCTree object. This may be null if no parent object exists or has been set.
  - setParent
```
public void setParent(PCTree parent)
```
    Set the parent PCTree object that represents the parent component of the component represented by this PCTree object.
  - getCompMap
```
public java.util.Map getCompMap()
```
    Returns:
    
    the Map object that holds the PCTrees for all objects encountered up to this point in the object hierarchy.
  - setCompMap
```
public void setCompMap(java.util.Map compMap)
```
    Set the Map object that holds the PCTrees for all objects encountered up to this point in the object hierarchy.
  - setDomainName
```
public void setDomainName(java.lang.String domainName)
```
  - getDomainName
```
public java.lang.String getDomainName()
```
  - getAppendedCompInfo
```
protected java.lang.String getAppendedCompInfo()
```
  - getRecogString
```
protected java.lang.String getRecogString(boolean origCallerIsParent)
```
    Build the piece of the recognition string that represents this component only. Parent recognition information will be retrieved and prepended separately.
    
    Parameters:
    
    origCallerIsParent - true if this component is the topmost parent window.
    
    See Also:
    
    getParentRecogString()
  - getRFSMRecogString
```
protected java.lang.String getRFSMRecogString(boolean origCallerIsParent)
```
    Build the piece of RFSM the recognition string that represents this component only. Parent recognition information will be retrieved and prepended separately.
    
    Parameters:
    
    origCallerIsParent - true if this component is the topmost parent window.
    
    origCallerIsParent -
    
    Returns:
    
    See Also:
    
    getParentRecogString()
  - getIndex
```
protected int getIndex()
```
    Get index, first try using the 'indexMap' setup with setupCompIndex, then try getIndexOld
  - getIndex
```
protected int getIndex(java.lang.String type)
```
    if type equals our type, return getIndex()+1, basically incrementing any previous index for a component of the same type. else if parent is not null, return parent.getIndex(type), maybe success at upper levels. else return 0
    
    Parameters:
    
    type, - String type (getType)
    
    Returns:
    
    int index
  - getIndexOld
```
protected int getIndexOld()
```
    Generate index based on this algorithm: First get a starting index by asking our parent for an index for the type. Then we get our 'Base' index by: getting our matching index based on all of our siblings, and our position. We use 'getCompMap()' which is a Map keyed by 'type' of component. The values in the Map are ArrayLists of PCTree elements. If we match ourselves in that list then that index is the index we want. We then add in the parent index previously obtained from 'getIndex(getType())'
    
    Returns:
    
    int index
  - getIndexBase
```
protected int getIndexBase()
```
    Generate base index based on this algorithm: getting our matching index based on all of our siblings, and our position. We use 'getCompMap()' which is a Map keyed by 'type' of component. The values in the Map are ArrayLists of PCTree elements. If we match ourselves in that list then that index is the index we want.
    
    Returns:
    
    int index
  - setupIndexMap
```
protected void setupIndexMap(int rdepth,
                             java.util.HashMap indexMap,
                             boolean onlyOneChildVisible,
                             java.util.HashMap altMap)
```
    Setup the IndexMap values based on our described algorithm.
    
    Parameters:
    
    rdepth, - int depth into the hierarchy as we recursively drill down
    
    indexMap, - Map, used to keep the types with index appended (keys),the values are the PCTree instances themselves.
    
    onlyOneChildVisible, - boolean, used to indicate containers like TabControls
    
    altMap, - Map, alternate map cloned for siblings under containers like TabControls with onlyOneChildVisible
  - setupIndexForIDName
```
protected void setupIndexForIDName()
```
    Set the absolute index for tree nodes who have the same ID or Name.
    It will be called during the traversal of the whole tree.
    
    See Also:
    
    setupIndexMap(int, HashMap, boolean, HashMap)
  - generateMapKey
```
protected java.lang.String generateMapKey(java.lang.String prefix,
                                          java.lang.String value)
```
    Generate a key to be used for map idNameIndexMap
    
    Parameters:
    
    prefix - String, the key prefix, like NAME_INDEX_PREFIX or ID_INDEX_PREFIX
    
    value - String, the object's name or object's id
    
    Returns:
    
    String, prefix+":"+value
    
    See Also:
    
    setupIndexForIDName()
  - setupIndexMap
```
public void setupIndexMap()
```
    Setup the IndexMap values based on our described algorithm.
    Note: This version calls the other 'protected' version, which uses recursion, and passes 'false' for the parameter 'onlyOneChildVisible' Note: All of the top level siblings are split out into separate calls if they are of type 'Window' or 'JavaWindow' using separate HashMaps
  - getPathIndex
```
protected int getPathIndex()
```
    (Future) Currently ALWAYS returns 0
  - toString
```
public java.lang.String toString()
```
    Output the PCTree
    
    Overrides:
    
    toString in class Tree
    
    Returns:
    
    our string
  - ignoreParentRecognitionString
```
protected boolean ignoreParentRecognitionString(PCTree aparent)
```
    Parameters:
    
    aparent -
    
    Returns:
    
    true if the provided PCTree, usually a parent or ancestor, is one of the containerTypesIgnoredForRecognition or has one of the containerNamesIgnoredForRecognition or is one of the containerClassesIgnoredForRecognition.
    
    See Also:
    
    #containerTypesIgnoredForRecognition, #containerNamesIgnoredForRecognition, GuiObjectRecognition.containerClassesIgnoredForRecognition
  - getParentRecogString
```
protected java.lang.String getParentRecogString()
```
    Recursively get all of the parent->parent->... recog strings. If withNameIncludeOnlyCaption is true and this component is identified by Name then only the topmost parent info is returned.
    Other items which modify the completeness or format of the recognition information include:
    - If the component is found via Path= (getPath() != null)
    - If shortenGeneralRecognition has been set to true
    - When ignoreParentRecognitionString returns true on certain ancestors
    Returns:
    
    String representation of full parent hierarchy. This does NOT include any portion of the recognition string for the local component itself. That would be appended to the parent recognition information provided here.
    
    See Also:
    
    getRecogString(boolean)
  - getHeader
```
protected java.lang.String getHeader()
```
    Output header String (like '[windowname]'), if isContainerTypesUsedToSetupIndexMap. Otherwise we just return an empty string. This is used during output of AppMap formatted information.
  - getBlankLine
```
protected java.lang.String getBlankLine()
```
    Output a blank line and 'Child of' information if the parent control has onlyOneChildVisible (like TabControls). This visually separates the children of different tabs. The routine also provides similar 'Child of' information at regular intervals for objects with a great many children. Only provides such non-empty output if withCommentsAndBlankLines is true. Otherwise, simply returns an empty string.
  - getTotalChildCountFromFirstChild
```
public int getTotalChildCountFromFirstChild()
```
    Calculate the total child count of all children of this component.
    
    Returns:
    
    int 0 if this component has no firstChild.
  - toIniString
```
public java.lang.String toIniString()
```
    Returns:
    
    String representing an INI formatted name=value representation of the component with recognition string. An INI section header and any separating blank lines will also be included where appropriate. The output will include the output from all children and subsequent siblings.
  - toIniStringWithoutIgnoredNodes
```
public java.lang.String toIniStringWithoutIgnoredNodes()
```
    Returns:
    
    String like returned by toIniString(). If isIgnoredNode() is true, the ignored containers will NOT be included in the INI formatted string.
  - isIgnoredNode
```
public boolean isIgnoredNode()
```
    See if this node can be ignored according to 'shortenGeneralRecognition'. Called by STAFPC
  - getComponentRecogString
```
public java.lang.String getComponentRecogString(boolean includeParentPart)
```
    generate recognition string for the PCTree on this level.
    
    Parameters:
    
    includeParentPart -
    
    Returns:
    
    recognition string.
  - main
```
public static void main(java.lang.String[] args)
```
    For testing only. Loads inputfile, write outputfile opens outfilename for write, process the pctree stored in the xmlinput file
    
    Parameters:
    
    infilename, - String
    
    outfilename, - String
  - removeNonNameChars
```
public static java.lang.String removeNonNameChars(java.lang.String text)
```
    Remove most typical non-alphanumeric characters from the provided text. " ;:'/\"\\-=!@#%^&*()+{}[]|<>?.,"
    
    Parameters:
    
    text, - String
    
    Returns:
    
    String without the non-alphanumeric chars
  - removeNonNameChars
```
public static java.lang.String removeNonNameChars(java.lang.String text,
                                                  java.lang.String nextChar)
```
    Remove all occurrences of nextChar from the text string.
    
    Parameters:
    
    text, - String
    
    nextChar, - String of one character
    
    Returns:
    
    String without any 'nextChar'

Class PCTree

Field Summary

Fields inherited from class org.safs.Tree

Constructor Summary

Method Summary

Methods inherited from class org.safs.Tree

Methods inherited from class java.lang.Object

Field Detail

totalChildCountWithCommentsAndBlankLines

recogSeparator

typePart

classPart

partSeparator

namePart

captionPart

indexPart

pathPart

textPart

classIndexPart

idPart

processName

Constructor Detail

PCTree

Method Detail

isRfsmSearchMode

setRfsmSearchMode

isFullPathSearchMode

setFullPathSearchMode

isMappedClassSearchMode

setMappedClassSearchMode

setDefaultRecognition

getDefaultRecognition

setAppendCompInfo

doAppendCompInfo

getId

setId

getIndexOnly

setIndexOnly

getName

updateName

setName

getIndex_types

getIndex_typesIndex

setIndex_types

getType

setType

getObjectClass

setObjectClass

getMyclass

setMyclass

getNameValue

setNameValue

isCaption

setCaption

isTextValue

setTextValue

isWithNameIncludeOnlyCaption

setWithNameIncludeOnlyCaption

isWithCommentsAndBlankLines

setWithCommentsAndBlankLines

isShortenGeneralRecognition

setShortenGeneralRecognition

isOnlyOneChildVisible

setOnlyOneChildVisible

isComponentVisible

setComponentVisible

isClassIndex

setClassIndex

getClassAbsIndex

setClassAbsIndex

getSiblingIndex

setSiblingIndex

getPath

setPath

getParent

setParent

getCompMap

setCompMap

setDomainName

getDomainName