This method returns a list of all the nodes of the given type.
It is much like searchByTag() in that it heirarchically walks
the STAR tree and calls the searchForType() functions of the subtrees
within the tree. In this way it is possible to call this function
at any level of the STAR file.
The second parameter is optional and is only useful when you are
searching for DATAVALUENODEs. It determines the kind of
DATAVALUENODE you are searching for, by delimiter type. For
example, you could search for only those DATAVALUENODEs that
are semicolon-delimited by passing DataValueNode::SEMICOLON
as the second argument. Or you could look for just framecodes
by passing DataValueNode::FRAMECODE as the second parameter.
Passing a negative number says you want all the DataValueNodes,
regardless of their delimiter type.
Although the second parameter is an integer, think of it as
the enum DataValueNode::ValType. The only reason it is shown
as an integer in the prototype here is that this class (ASTnode)
needs to be defined before the class "DataValueNode" can be defined,
and thus at this point the compiler has no clue what
"DataValueNode::ValType" means yet.
If the search is for some ASTtype other than DATAVALUENODE, then
it is irrelevant what the second parameter of this function is, as
it will never be used - You can just leave it off and accept the
default.
- Parameters:
- type - - type to search for
delim - - DataValueNode::ValType to look for. Default = "dont-care".
const string& getPreComment( void )
- void setPreComment( const string &cmt )
- These functions are used to give each node in the AST tree the ability to remember a comment to be pasted into the file in front of that node.
- These functions are used to give each node in the
AST tree the ability to remember a comment to be
pasted into the file in front of that node. This
is useful if you want to insert header comments of
some sort into the output produced by Unparse().
As of this writing, no provisions are being made
to handle the parsing of comments from the original
file and storing them via these functions. The
grammar to do that would be rather convoluted.
These functions are only intended to be used by programs
insterting their own comments after the file has
been read.
The string must contain the comment characters embedded
inside, like so: "# this is a\n# multiline comment.",
not like this: "this is a\nmultiline comment." This is
so that the caller is allowed to have the comment contain
blank lines like this:
* # This is an example comment.
*
* # The comment has some blank
*
* # lines in it.
*
If the Unparse() function were designed to insert the comment
characters (#) itself, then such a comment block would be impossible
to create.
Note that the comment lines are not syntax-checked in any way, so
using these functions it is entirely possible to create invalid
STAR files, since these "comments" can really be strings with
anything at all in them - so be careful.
To get rid of the preComment if you change your mind, set it to
a zero-length string with setPreComment().
- virtual int getColNum( void ) const
- virtual void setColNum( const int num )
- These functions return the column number and set the column number on which this node was found in the STAR file.
- These functions return the column number and set the
column number on which this node was found in the STAR
file. Note that a negative number is an indicator that
the node was not in the original file when it was parsed,
and hence has no column number.
These functions start counting at 1, not zero.
These functions actually give the location where
the particular part of speech ENDED, not where it
started. For example, with a DataLoopNode, the location
given is the location of the closing "stop_" keyword,
not the opening "loop_" keyword. This is an unfortunate
neccessity due to the way the parser reads the data. It
doesn't know whether or not it has encountered a complete
grammatical construct until it reaches the end of the
construct, at which point it has lost track of what the
location was at the start of the grammatical construct.
- virtual int getLineNum( void ) const
- virtual void setLineNum( const int num )
- These functions return the line number and set the line number on which this node was found in the STAR file.
- These functions return the line number and set the line
number on which this node was found in the STAR file.
Note that a negative number is an indicator that the
node was not in the original file when it was parsed,
and hence has no line number.
These functions start counting at 1, not zero.
These functions actually give the location where
the particular part of speech ENDED, not where it
started. For example, with a DataLoopNode, the location
given is the location of the closing "stop_" keyword,
not the opening "loop_" keyword. This is an unfortunate
neccessity due to the way the parser reads the data. It
doesn't know whether or not it has encountered a complete
grammatical construct until it reaches the end of the
construct, at which point it has lost track of what the
location was at the start of the grammatical construct.
- virtual ASTnode* myParallelCopy( void )
- void setPeer( ASTnode* )
- This method returns a pointer to an ASTnode.
- This method returns a pointer to an ASTnode. The ASTnode
returned is the parallel 'other' version of this node
in the parallel tree. Incedentally, since the two parallel
trees are aware of each other, the parallel copy of the
parallel copy is the orginial node, so this function is
self-inverting, like this:
foo->myParallelCopy()->myParallelCopy() == foo
If there is no parallel node corresponding to this node,
then this method will return a NULL pointer. This can happen
if a node in the parallel tree was deleted after the
parallel copy was made.
- virtual List<ASTnode*> * searchForTypeByTagValue( ASTtype type, string &tag, string &value)
- Overloaded Version
- virtual List<ASTnode*> * searchForTypeByTagValue( ASTtype type, string &tag, char* value )
- Overloaded Version
Just calls the above version of this function. There is no
need to override this function in subclasses of ASTnode.
WARNING: The list returned is allocated in heap space. It is
the caller's responsibility to delete the list after it is no
longer needed.
- virtual List<ASTnode*> * searchForTypeByTagValue( ASTtype type, char* tag, string &value)
- Overloaded Version
Just calls the above version of this function. There is no
need to override this function in subclasses of ASTnode.
- virtual List<ASTnode*> * searchForTypeByTagValue( ASTtype type, char* tag, char* value )
- Overloaded Version
Just calls the above version of this function. There is no
need to override this function in subclasses of ASTnode.
- This method is exactly like 'searchByTag()', except that it tries to return an object of the type given.
- This method is exactly like 'searchByTag()', except that
it tries to return an object of the type given. Other
than the fact that it calls searchByTagValue() instead
of searchByTag(), it behaves exactly as searchForTypeByTag()
(see above).
YOU NEVER NEED TO OVERRIDE THESE FUNCTIONS IN ANY OF THE
SUBCLASSES OF ASTNODE! THEY OPERATE THE SAME WAY IN ALL
THE SUBCLASSES. THEY MAKE ALL THEIR CALLS THROUGH THE
EXISTING searchByTag() calls.
- Parameters:
- type - - type to search for
- tag - tag name to search for
value - - where it has this value
- virtual List<ASTnode*> * searchForTypeByTag( ASTtype type, string &tag)
- Overloaded Version
- virtual List<ASTnode*> * searchForTypeByTag( ASTtype type, char* tag)
- Overloaded Version
- This method is exactly the same as 'searchByTag()', except that it tries to return an object of the type given.
- This method is exactly the same as 'searchByTag()', except that
it tries to return an object of the type given. What it does
is this: it calls searchByTag(), then it 'walks' up the parent
list until it finds an ASTnode-derived object that is of the
type given. Thus if you search for a ASTnode::SAVEFRAMENODE
type of object with this function, it will return the save frame
in which the match was found, rather than the match itself.
Also note that this method will consider derived subtypes of
a class as valid 'hits' as well. For example, you could
search for an ASTnode::DATANODE and if a DATAITEMNODE or
DATALOOPNODE or SAVEFRAMENODE were found, they would be
returned as valid hits.
If an empty list is returned, that could be either because
no matching tags were found OR because there were matches
found, but they were not inside any objects of the requested
type.
This search is case-insensitive. The names of things, according
to the STAR specification, are supposed to be case-insensitive.
This is being applied not only to tag names but also to
saveframe names and datablock names.
(However, the values are case-sensitive. A search for a
tag of _t1 is identical to a search for a tag of _T1,
but a search for a value of "V1" is different from a search for
a value of "v1".)
YOU NEVER NEED TO OVERRIDE THESE FUNCTIONS IN ANY OF THE
SUBCLASSES OF ASTNODE! THEY OPERATE THE SAME WAY IN ALL
THE SUBCLASSES. THEY MAKE ALL THEIR CALLS THROUGH THE
EXISTING searchByTag() calls.
- Parameters:
- type - - the type to search for.
tab - - the tag (name) to search for.
- virtual List<ASTnode*> * searchByTagValue( string &tag, string &value)
- Given a tag name and a value, find the AST object that that
particular tag and value pair resides in. This is like
performing an SQL search: WHERE tag = value.
Only searches starting at the node it was called from, and
its children. Recurses downward, but does not recurse upward.
This function is only capable of returning one answer, so it
cannot be called at the same levels where searchByTag() can
be called (see above).
This search is case-insensitive. The names of things, according
to the STAR specification, are supposed to be case-insensitive.
This is being applied not only to tag names but also to
saveframe names and datablock names.
(However, the values are case-sensitive. A search for a
tag of _t1 is identical to a search for a tag of _T1,
but a search for a value of "V1" is different from a search for
a value of "v1".)
WARNING: The list returned is allocated in heap space. It is
the caller's responsibility to delete the list after it is no
longer needed.
- Parameters:
- - tag - Look for this tag...
value - - Where it has this value.
- virtual List<ASTnode*> * searchByTagValue( string &tag, char* value)
- Overloaded Version
Just calls the above version of this function. There is no
need to override this function in subclasses of ASTnode.
WARNING: The list returned is allocated in heap space. It is
the caller's responsibility to delete the list after it is no
longer needed.
- virtual List<ASTnode*> * searchByTagValue( char* tag, string &value)
- Overloaded Version
Just calls the above version of this function. There is no
need to override this function in subclasses of ASTnode.
- virtual List<ASTnode*> * searchByTagValue( char* tag, char* value)
- Overloaded Version
Just calls the above version of this function. There is no
need to override this function in subclasses of ASTnode.
![[more]](icon1.gif)
