/// <summary> Remove nodes not matching the given filter.</summary>
/// <param name="filter">The filter to use.
/// </param>
/// <param name="recursive">If <code>true<code> digs into the children recursively.
/// </param>
public virtual void KeepAllNodesThatMatch(NodeFilter filter, bool recursive)
{
INode node;
NodeList children;
for (int i = 0; i < m_iSize;)
{
node = nodeData[i];
if (!filter.Accept(node))
{
Remove(i);
}
else
{
if (recursive)
{
children = node.Children;
if (null != children)
{
children.KeepAllNodesThatMatch(filter, recursive);
}
}
i++;
}
}
}
/// <summary> Filter the list with the given filter.</summary>
/// <param name="filter">The filter to use.
/// </param>
/// <param name="recursive">If <code>true<code> digs into the children recursively.
/// </param>
/// <returns> A new node array containing the nodes accepted by the filter.
/// This is a linear list and preserves the nested structure of the returned
/// nodes only.
/// </returns>
public virtual NodeList ExtractAllNodesThatMatch(NodeFilter filter, bool recursive)
{
INode node;
NodeList children;
NodeList ret;
ret = new NodeList();
for (int i = 0; i < m_iSize; i++)
{
node = nodeData[i];
if (filter.Accept(node))
{
ret.Add(node);
}
if (recursive)
{
children = node.Children;
if (null != children)
{
ret.Add(children.ExtractAllNodesThatMatch(filter, recursive));
}
}
}
return(ret);
}
/// <summary> Collect this node and its child nodes (if-applicable) into the collectionList parameter, provided the node
/// satisfies the filtering criteria.<P>
///
/// This mechanism allows powerful filtering code to be written very easily,
/// without bothering about collection of embedded tags separately.
/// e.g. when we try to get all the links on a page, it is not possible to
/// get it at the top-level, as many tags (like form tags), can contain
/// links embedded in them. We could get the links out by checking if the
/// current node is a <see cref="CompositeTag"></see>, and going through its children.
/// So this method provides a convenient way to do this.<P>
///
/// Using collectInto(), programs get a lot shorter. Now, the code to
/// extract all links from a page would look like:
/// <pre>
/// NodeList collectionList = new NodeList();
/// NodeFilter filter = new TagNameFilter ("A");
/// for (NodeIterator e = parser.elements(); e.hasMoreNodes();)
/// e.nextNode().collectInto(collectionList, filter);
/// </pre>
/// Thus, collectionList will hold all the link nodes, irrespective of how
/// deep the links are embedded.<P>
///
/// Another way to accomplish the same objective is:
/// <pre>
/// NodeList collectionList = new NodeList();
/// NodeFilter filter = new TagClassFilter (LinkTag.class);
/// for (NodeIterator e = parser.elements(); e.hasMoreNodes();)
/// e.nextNode().collectInto(collectionList, filter);
/// </pre>
/// This is slightly less specific because the LinkTag class may be
/// registered for more than one node name, e.g. <LINK> tags too.
/// </summary>
/// <param name="list">The node list to collect acceptable nodes into.
/// </param>
/// <param name="filter">The filter to determine which nodes are retained.
/// </param>
public virtual void CollectInto(NodeList list, NodeFilter filter)
{
if (filter.Accept(this))
{
list.Add(this);
}
}
/// <summary> Remove nodes not matching the given filter.</summary>
/// <param name="filter">The filter to use.
/// </param>
/// <param name="recursive">If <code>true<code> digs into the children recursively.
/// </param>
public virtual void KeepAllNodesThatMatch(NodeFilter filter, bool recursive)
{
INode node;
NodeList children;
for (int i = 0; i < m_iSize; )
{
node = nodeData[i];
if (!filter.Accept(node))
Remove(i);
else
{
if (recursive)
{
children = node.Children;
if (null != children)
children.KeepAllNodesThatMatch(filter, recursive);
}
i++;
}
}
}
/// <summary> Filter the list with the given filter.</summary>
/// <param name="filter">The filter to use.
/// </param>
/// <param name="recursive">If <code>true<code> digs into the children recursively.
/// </param>
/// <returns> A new node array containing the nodes accepted by the filter.
/// This is a linear list and preserves the nested structure of the returned
/// nodes only.
/// </returns>
public virtual NodeList ExtractAllNodesThatMatch(NodeFilter filter, bool recursive)
{
INode node;
NodeList children;
NodeList ret;
ret = new NodeList();
for (int i = 0; i < m_iSize; i++)
{
node = nodeData[i];
if (filter.Accept(node))
ret.Add(node);
if (recursive)
{
children = node.Children;
if (null != children)
ret.Add(children.ExtractAllNodesThatMatch(filter, recursive));
}
}
return (ret);
}
/// <summary> Accept nodes that are not acceptable to the predicate filter.</summary>
/// <param name="node">The node to check.
/// </param>
/// <returns> <code>true</code> if the node is not acceptable to the
/// predicate filter, <code>false</code> otherwise.
/// </returns>
public virtual bool Accept(INode node)
{
return((null != mPredicate) && !mPredicate.Accept(node));
}
/// <summary> Collect this node and its child nodes (if-applicable) into the collectionList parameter, provided the node
/// satisfies the filtering criteria.<P>
///
/// This mechanism allows powerful filtering code to be written very easily,
/// without bothering about collection of embedded tags separately.
/// e.g. when we try to get all the links on a page, it is not possible to
/// get it at the top-level, as many tags (like form tags), can contain
/// links embedded in them. We could get the links out by checking if the
/// current node is a <see cref="CompositeTag"></see>, and going through its children.
/// So this method provides a convenient way to do this.<P>
///
/// Using collectInto(), programs get a lot shorter. Now, the code to
/// extract all links from a page would look like:
/// <pre>
/// NodeList collectionList = new NodeList();
/// NodeFilter filter = new TagNameFilter ("A");
/// for (NodeIterator e = parser.elements(); e.hasMoreNodes();)
/// e.nextNode().collectInto(collectionList, filter);
/// </pre>
/// Thus, collectionList will hold all the link nodes, irrespective of how
/// deep the links are embedded.<P>
///
/// Another way to accomplish the same objective is:
/// <pre>
/// NodeList collectionList = new NodeList();
/// NodeFilter filter = new TagClassFilter (LinkTag.class);
/// for (NodeIterator e = parser.elements(); e.hasMoreNodes();)
/// e.nextNode().collectInto(collectionList, filter);
/// </pre>
/// This is slightly less specific because the LinkTag class may be
/// registered for more than one node name, e.g. <LINK> tags too.
/// </summary>
/// <param name="list">The node list to collect acceptable nodes into.
/// </param>
/// <param name="filter">The filter to determine which nodes are retained.
/// </param>
public virtual void CollectInto(NodeList list, NodeFilter filter)
{
if (filter.Accept(this))
{
list.Add(this);
}
}
