SoPath — path that points to a list of hierarchical nodes

       A path represents a scene graph or subgraph. It contains a list of pointers to nodes forming a chain from
       some  root  to some descendent. Each node in the chain is a child of the previous node. Paths are used to
       refer to some object in a scene graph precisely and unambiguously, even if there are  many  instances  of
       the object. Therefore, paths are returned by both the SoRayPickAction and SoSearchAction.

       When  an  action  is applied to a path, only the nodes in the subgraph defined by the path are traversed.
       These include: the nodes in the path chain, all nodes (if any) below the last node in the path,  and  all
       nodes whose effects are inherited by any of these nodes.

       SoPath  attempts to maintain consistency of paths even when the structure of the scene graph changes. For
       example, removing a child from its parent when both are in a path chain  cuts  the  path  chain  at  that
       point,  leaving  the top part intact. Removing the node to the left of a node in a path adjusts the index
       for that node. Replacing a child of a node when both the parent and the child are in the  chain  replaces
       the child in the chain with the new child, truncating the path below the new child.

       Note  that  only  public children of nodes are accessible from an SoPath. Nodes like node kits that limit
       access to their children may  provide  other  ways  to  get  more  information,  such  as  by  using  the
       SoNodeKitPath class.

SoPath{[headnode][numberofremainingindices][index]...[index]}

     Note  that  the  indices  in  a written path are adjusted based on the nodes that are actually written to a
     file. Since nodes in the graph that have no effect on the path (such  as  some  separator  nodes)  are  not
     written,  the  siblings  of  such nodes must undergo index adjustment when written. The actual nodes in the
     graph remain unchanged.

       SoBase > SoPath

SoPath()
          Constructs an empty path.

                         SoPath(intapproxLength)
          Constructs a path with a hint to length (number of nodes in chain).

                         SoPath(SoNode*node)
          Constructs a path and sets the head node to the given node.

     voidsetHead(SoNode*node)
          Sets  head node (first node in chain). The head node must be set before the append() or push() methods
          may be called.

     voidappend(intchildIndex)
          Adds node to end of chain; the node is the childIndex'th child of the current tail node.

     voidappend(SoNode*childNode)
          Adds node to end of chain; uses the first occurrence of childNode as child of current  tail  node.  If
          the path is empty, this is equivalent to setHead(childNode).

     voidappend(constSoPath*fromPath)
          Adds all nodes in fromPath's chain to end of chain; the head node of fromPath must be the same as or a
          child of the current tail node.

     voidpush(intchildIndex)voidpop()
          These allow a path to be treated as a stack; they push a node at the end of the chain and pop the last
          node off.

     SoNode*getHead()constSoNode*getTail()const
          These return the first and last nodes in a path chain.

     SoNode*getNode(inti)constintgetIndex(inti)const
          These  return  a  pointer  to  the  i'th node or the index of the i'th node (within its parent) in the
          chain. Calling getNode(0) is equivalent to calling getHead().

     SoNode*getNodeFromTail(inti)constintgetIndexFromTail(inti)const
          These return a pointer to the i'th node or the index of the i'th  node  (within  its  parent)  in  the
          chain, counting backward from the tail node. Passing 0 for i returns the tail node or its index.

     intgetLength()const
          Returns length of path chain (number of nodes).

     voidtruncate(intstart)
          Truncates  the  path  chain,  removing all nodes from index start on. Calling truncate(0)  empties the
          path entirely.

     SbBoolcontainsNode(constSoNode*node)const
          Returns TRUE if the node is found anywhere in the path chain.

     SbBoolcontainsPath(constSoPath*path)const
          Returns TRUE if the nodes in the chain in the passed path are contained (in consecutive order) in this
          path chain.

     intfindFork(constSoPath*path)const
          If the two paths have different head nodes, this returns -1. Otherwise,  it  returns  the  path  chain
          index of the last node (starting at the head) that is the same for both paths.

     SoPath*copy(intstartFromNodeIndex=0,intnumNodes=0)const
          Creates and returns a new path that is a copy of some or all of this path. Copying starts at the given
          index  (default is 0, which is the head node). A numNodes of 0 (the default) means copy all nodes from
          the starting index to the end. Returns NULL on error.

     friendintoperator==(constSoPath&p1,constSoPath&p2)
          Returns TRUE if all node pointers in the two path chains are identical.

     staticSoPath*getByName(constSbName&name)staticintgetByName(constSbName&name,SoPathList&list)
          These methods lookup and return paths with a given name. Paths are named by  calling  their  setName()
          method  (defined  by the SoBase class). The first form returns the last path that was given that name,
          either by setName() or by reading in a named path from a file. If there is  no  path  with  the  given
          name,  NULL  will be returned. The second form appends all paths with the given name to the given path
          list and returns the number of paths that were added. If there are no paths with the given name,  zero
          will be returned and nothing will be added to the list.

       SoPath — path that points to a list of hierarchical nodes

SoNode,SoRayPickAction,SoSearchAction,SoNodeKitPathSoPath(3IV)()

#include<Inventor/SoPath.h>

          Methods from class SoPath:

                         SoPath()SoPath(intapproxLength)SoPath(SoNode*node)voidsetHead(SoNode*node)voidappend(intchildIndex)voidappend(SoNode*childNode)voidappend(constSoPath*fromPath)voidpush(intchildIndex)voidpop()SoNode*getHead()constSoNode*getTail()constSoNode*getNode(inti)constintgetIndex(inti)constSoNode*getNodeFromTail(inti)constintgetIndexFromTail(inti)constintgetLength()constvoidtruncate(intstart)SbBoolcontainsNode(constSoNode*node)constSbBoolcontainsPath(constSoPath*path)constintfindFork(constSoPath*path)constSoPath*copy(intstartFromNodeIndex=0,intnumNodes=0)constfriendintoperator==(constSoPath&p1,constSoPath&p2)staticSoPath*getByName(constSbName&name)staticintgetByName(constSbName&name,SoPathList&list)

          Methods from class SoBase:

     voidref()voidunref()constvoidunrefNoDelete()constvoidtouch()staticSoTypegetClassTypeId()virtualSoTypegetTypeId()constSbBoolisOfType(SoTypetype)constvirtualvoidsetName(constSbName&name)virtualSbNamegetName()const