Message/DOM/TreeWalker.pm

package Message::DOM::TreeWalker;
use strict;
our $VERSION=do{my @r=(q$Revision: 1.8 $=~/\d+/g);sprintf "%d."."%02d" x $#r,@r};
push our @ISA, 'Message::IF::TreeWalker';
             
sub AUTOLOAD {
  my $method_name = our $AUTOLOAD;
  $method_name =~ s/.*:://;
  return if $method_name eq 'DESTROY';

  if ({
    expand_entity_references => 1,
    filter => 1,
    root => 1,
    what_to_show => 1,
  }->{$method_name}) {
    no strict 'refs';
    eval qq{
      sub $method_name (\$) { \$_[0]->{$method_name} }
    };
    goto &{ $AUTOLOAD };
  } else {
    require Carp;
    Carp::croak (qq<Can't locate method "$AUTOLOAD">);
  }
} # AUTOLOAD

sub ___report_error ($$) { $_[1]->throw }

## TODO: Documentation
sub clone ($) {
  return bless {%{$_[0]}}, ref $_[0];
} # clone

## |TreeWalker| attributes

sub current_node ($;$) {
  if (@_ > 1) {
    if (defined $_[1]) {
      $_[0]->{current_node} = $_[1];
    } else {
      require Message::DOM::DOMException;
      report Message::DOM::DOMException
          -object => $_[0],
          -type => 'NOT_SUPPORTED_ERR',
          -subtype => 'NULLPO_ERR';
    }
  }

  return $_[0]->{current_node};
} # current_node

sub expand_entity_references ($);

sub filter ($);

sub root ($);

sub what_to_show ($);

## |TreeWalker| methods

sub first_child ($) {
  local $Error::Depth = $Error::Depth + 1;

  my $sresult = $_[0]->_test_node ($_[0]->{current_node});

  if ($sresult != 12101) { # MANAKAI_FILTER_OPAQUE
    my @target = (@{$_[0]->{current_node}->child_nodes});
    A: while (@target) {
      my $target = shift @target;
      my $result = $_[0]->_test_node ($target);
      if ($result == 1 or $result == 12101) {
        # FILTER_ACCEPT, MANAKAI_FILTER_OPAQUE
        return ($_[0]->{current_node} = $target);
      } elsif ($result == 3) { # FILTER_SKIP
        unshift @target, @{$target->child_nodes};
      }
    } # A
  } # not opaque

  return undef;
} # first_child

sub last_child ($) {
  local $Error::Depth = $Error::Depth + 1;

  my $sresult = $_[0]->_test_node ($_[0]->{current_node});
  if ($sresult != 12101) { # MANAKAI_FILTER_OPAQUE
    my @target = (@{$_[0]->{current_node}->child_nodes});
    A: while (@target) {
      my $target = pop @target;
      my $result = $_[0]->_test_node ($target);
      if ($result == 1 or $result == 12101) {
        # FILTER_ACCEPT, MANAKAI_FILTER_OPAQUE
        return ($_[0]->{current_node} = $target);
      } elsif ($result == 3) { # FILTER_SKIP
        push @target, @{$target->child_nodes};
      }
    } # A
  }

  return undef;
} # last_child

sub next_node ($) {
  local $Error::Depth = $Error::Depth + 1;
  
  my $target = $_[0]->{current_node};
  my $tw = $_[0]->clone;
  $tw->{current_node} = $target;
  $tw->{root} = $target;
  my $fc = $tw->first_child;
  if (defined $fc) {
    return ($_[0]->{current_node} = $fc);
  }

  while (defined $target) {
    my $current = $target;
    undef $target;
    P: while (defined $current and not $current eq $_[0]->{root}) {
      $target = $current->next_sibling;
      last P if defined $target;
      $current = $current->parent_node;
    } # P
    return undef unless defined $target;
  
    my $result = $_[0]->_test_node ($target);
    if ($result == 1 or $result == 12101) {
      # FILTER_ACCEPT, MANAKAI_FILTER_OPAQUE
      return ($_[0]->{current_node} = $target);
    } elsif ($result == 3) { # FILTER_SKIP
      my $tw = $_[0]->clone;
      $tw->{current_node} = $target;
      $tw->{root} = $target;
      my $fc = $tw->first_child;
      if (defined $fc) {
        return ($_[0]->{current_node} = $fc);
      }
    }
  }

  return undef;
} # next_node

sub next_sibling ($) {
  local $Error::Depth = $Error::Depth + 1;

  my $target = $_[0]->{current_node};
  while (defined $target) {
    my $current = $target;
    undef $target;
    P: while (defined $current and not $current eq $_[0]->{root}) {
      $target = $current->next_sibling;
      last P if defined $target;
      $current = $current->parent_node;
      last P unless defined $current;
      my $presult = $_[0]->_test_node ($current);
      last P if $presult != 3; # FILTER_SKIP
    } # P
    return undef unless defined $target;
  
    my $result = $_[0]->_test_node ($target);
    if ($result == 1 or $result == 12101) {
      # FILTER_ACCEPT, MANAKAI_FILTER_OPAQUE
      return ($_[0]->{current_node} = $target);
    } elsif ($result == 3) { # FILTER_SKIP
      my $tw = $_[0]->clone;
      $tw->{current_node} = $target;
      $tw->{root} = $target;
      my $fc = $tw->first_child;
      if (defined $fc) {
        return ($_[0]->{current_node} = $fc);
      }
    }
  }

  return undef;
} # next_sibling

sub parent_node ($) {
  local $Error::Depth = $Error::Depth + 1;

  unless ($_[0]->{current_node} eq $_[0]->{root}) {
    my $target = $_[0]->{current_node}->parent_node;
    T: while (defined $target) {
      my $result = $_[0]->_test_node ($target);
      if ($result == 1 or $result == 12101) {
        # FILTER_ACCEPT, MANAKAI_FILTER_OPAQUE
        return ($_[0]->{current_node} = $target);
      } elsif ($target eq $_[0]->{root}) {
        return undef;
      }
      $target = $target->parent_node;
    } # T
  }

  return undef;
} # parent_node

sub previous_node ($) {
  local $Error::Depth = $Error::Depth + 1;

  my $target = $_[0]->{current_node};
  T: {
    return undef if $target eq $_[0]->{root};

    P: {
      my $ptarget = $target->previous_sibling;
      if (defined $ptarget) {
        my $result = $_[0]->_test_node ($ptarget);
        if ($result == 12101) { # MANAKAI_FILTER_OPAQUE
          return ($_[0]->{current_node} = $ptarget);
        } elsif ($result != 2) { # FILTER_REJECT
          my $tw = $_[0]->clone;
          $tw->{current_node} = $ptarget;
          $tw->{root} = $ptarget;
          my $lc = $tw->last_child;
          return ($_[0]->{current_node} = defined $lc ? $lc : $ptarget);
        } else {
          $target = $ptarget;
          redo P;
        }
      }
    } # P

    my $ptarget = $target->parent_node;
    if (defined $ptarget) {
      my $result = $_[0]->_test_node ($ptarget);
      if ($result == 1 or $result == 12101) {
        # FILTER_ACCEPT, MANAKAI_FILTER_OPAQUE
        return ($_[0]->{current_node} = $ptarget);
      } else {
        $target = $ptarget;
        redo T;
      }
    }
  } # T

  return undef;
} # previous_node

sub previous_sibling ($) {
  local $Error::Depth = $Error::Depth + 1;

  my $target = $_[0]->{current_node};
  while (defined $target) {
    my $current = $target;
    undef $target;
    P: while (defined $current and not $current eq $_[0]->{root}) {
      $target = $current->previous_sibling;
      last P if defined $target;

      $current = $current->parent_node;
      last P unless defined $current;
      my $presult = $_[0]->_test_node ($current);
      if ($presult != 3 and $presult != 2) { # FILTER_SKIP, FILTER_REJECT
        last P;
      }
    } # P
    return undef unless defined $target;
  
    my $result = $_[0]->_test_node ($target);
    if ($result == 1 or $result == 12101) {
      # FILTER_ACCEPT, MANAKAI_FILTER_OPAQUE
      return ($_[0]->{current_node} = $target);
    } elsif ($result == 3) { # FILTER_SKIP
      my $tw = $_[0]->clone;
      $tw->{current_node} = $target;
      $tw->{root} = $target;
      my $fc = $tw->last_child;
      if (defined $fc) {
        return ($_[0]->{current_node} = $fc);
      }
    }
  }

  return undef;
} # previous_sibling

## TODO: Document Perl binding for |NodeFilter|.
## TODO: |NodeFilter| constants...

sub _test_node ($$) {
  ## NOTE: There is a code clone in |SerialWalker.pm|.

  unless ($_[0]->{expand_entity_references}) {
    my $parent = $_[1]->parent_node;
    if (defined $parent and $parent->node_type == 5) { # ENTITY_REFERENCE_NODE
      return 2; # FILTER_REJECT ## NOTE: Even if |NodeIterator|.
    }
  }
    
  if ($_[0]->{what_to_show} != 0xFFFFFFFF) { # SHOW_ALL
    my $nt = $_[1]->node_type;
    if ($nt < 33 and ($_[0]->{what_to_show} & (1 << ($nt-1)))) {
      #
    } else {
      return 3; # FILTER_SKIP
    }
  }

  if (defined $_[0]->{filter}) {
    local $Error::Depth = $Error::Depth + 1;
    return $_[0]->{filter}->($_[1]);
  } else {
    return 1; # FILTER_ACCEPT
  }
} # _test_node

package Message::IF::TreeWalker;

package Message::DOM::Document;

sub create_tree_walker ($$;$$$) {
  unless (defined $_[1]) {
    require Message::DOM::DOMException;
    report Message::DOM::DOMException
        -object => $_[0],
        -type => 'NOT_SUPPORTED_ERR',
        -subtype => 'NULLPO_ERR';
  }
  
  return bless {
                root => $_[1],
                what_to_show => 0+($_[2] or 0),
                filter => $_[3],
                expand_entity_references => $_[4] ? 1 : 0,
                current_node => $_[1],
               }, 'Message::DOM::TreeWalker';
} # create_tree_walker

=pod 

 TODO: Documentation...

 FirstChild:
          If the <IF::NodeFilter>, if any, returns 
          <C::NodeFilter.MANAKAI_FILTER_OPAQUE> for the
          <A::TreeWalker.currentNode>, this method
          <kwd:MUST> return <DOM::null>.

            {NOTE::
              By definition, the parent of the
              <M::TreeWalker.firstChild> node, if any, is
              either a child of the <A::TreeWalker.currentNode>
              or a descendant of the <A::TreeWalker.currentNode>
              where all ancestors between <A::TreeWalker.currentNode>
              and that node is <C::NodeFilter.FILTER_SKIP>ped.
              That means that the only node that might be
              <C::NodeFilter.MANAKAI_FILTER_OPAQUE> is the
              <A::TreeWalker.currentNode>.
            }


  @L2Method:
    @@Name: lastChild

          If the <IF::NodeFilter>, if any, returns 
          <C::NodeFilter.MANAKAI_FILTER_OPAQUE> for the
          <A::TreeWalker.currentNode>, this method
          <kwd:MUST> return <DOM::null>.

            {NOTE::
              By definition, the parent of the
              <M::TreeWalker.lastChild> node, if any, is
              either a child of the <A::TreeWalker.currentNode>
              or a descendant of the <A::TreeWalker.currentNode>
              where all ancestors between <A::TreeWalker.currentNode>
              and that node is <C::NodeFilter.FILTER_SKIP>ped.
              That means that the only node that might be
              <C::NodeFilter.MANAKAI_FILTER_OPAQUE> is the
              <A::TreeWalker.currentNode>.
            }

 parentNode:
          For the purpose of this method, <C::NodeFilter.MANAKAI_FILTER_OPAQUE>
          <kwd:MUST> be handled by the same way as 
          <C::NodeFilter.FILTER_ACCEPT>.

nextNode:
          If the <A::TreeWalker.currentNode> is marked as 
          <C::NodeFilter.MANAKAI_FILTER_OPAQUE> by the <IF::NodeFilter>,
          the method <kwd:MUST-NOT> return any descendant of
          the <A::TreeWalker.currentNode>.  Otherwise,
          it <kwd:MUST> be treated as if <C::NodeFilter.FILTER_ACCEPT>.

 nextSibling:
      The <C::NodeFilter.MANAKAI_FILTER_OPAQUE> value <kwd:MUST>
      be treated as if <C::NodeFilter.FILTER_ACCEPT> is specified.

 previousNode:
      This method <kwd:MUST-NOT> return a descendant
      of a sibling of the <A::TreeWalker.currentNode> if 
      an ancestor between the descendant and the parent
      of the <A::TreeWalker.currentNode> (exclusive)
      is marked as <C::NodeFilter.MANAKAI_FILTER_OPAQUE> by
      the <IF::NodeFilter> if any.  If the node that is
      a candidate to return is an ancestor of the
      <A::TreeWalker.currentNode>, the <C::NodeFilter.MANAKAI_FILTER_OPAQUE>
      value returned by a <IF::NodeFilter> <kwd:MUST> be
      treated as if the <C::NodeFilter.FILTER_ACCEPT> value
      is returned.

 previousSibling:
      If a node that is a candicate to be returned is marked as
      <C::NodeFilter.MANAKAI_FILTER_OPAQUE>, it <kwd:MUST>
      be treated as <C::NodeFilter.FILTER_ACCEPT> when the
      node is a sibling of the <A::TreeWalker.currentNode>,
      or as in <M::TreeWalker.lastChild> where the
      <A::TreeWalker.currentNode> would be the sibling
      of the actual <A::TreeWalker.currentNode> otherwise.

    @@mConst:
      @@@Name: MANAKAI_FILTER_OPAQUE
      @@@intValue: 12101
      @@@enDesc:
        Accept the node itself while rejecting its children if any.

        If the <C::NodeFilter.MANAKAI_FILTER_OPAQUE> value is 
        specified for a node, the node itself <kwd:MUST> be treated
        as if the <C::NodeFilter.FILTER_ACCEPT> value is specified.
        However, any descendant of the node <kwd:MUST> be
        hidden from the logical view as if the
        <C::NodeFilter.FILTER_REJECT> value is specified for
        the ancestor node.

          {NOTE::
            This value can be used to emulate the
            <A::TreeWalker.expandEntityReferences> flag.
            However, unlike that flag, this filtering option
            makes the engine behave for descendants as if the node is
            rejected rather than the descendants of the node
            is rejected.
          }

          {ISSUE::
            Better name?  Any verb?
          }

          {ISSUE::
            Interaction to <IF::NodeIterator>s
          }

        {NOTE::
          The <C::Node.ELEMENT_TYPE_DEFINITION_NODE> and
          <C::Node.ATTRIBUTE_TYPE_DEFINITION> <A::Node.nodeType>s,
          extended by manakai, has values greater than <CODE::32>
          so that it cannot be controled by the <CODE::whatToShow>
          flags.
        }

=head1 LICENSE

Copyright 2007 Wakaba <w@suika.fam.cx>

This program is free software; you can redistribute it and/or
modify it under the same terms as Perl itself.

=cut

1;
## $Date: 2007/07/14 09:19:11 $
1	package Message::DOM::TreeWalker;
2	use strict;
3	our $VERSION=do{my @r=(q$Revision: 1.8 $=~/\d+/g);sprintf "%d."."%02d" x $#r,@r};
4	push our @ISA, 'Message::IF::TreeWalker';
5
6	sub AUTOLOAD {
7	my $method_name = our $AUTOLOAD;
8	$method_name =~ s/.*:://;
9	return if $method_name eq 'DESTROY';
10
11	if ({
12	expand_entity_references => 1,
13	filter => 1,
14	root => 1,
15	what_to_show => 1,
16	}->{$method_name}) {
17	no strict 'refs';
18	eval qq{
19	sub $method_name (\$) { \$_[0]->{$method_name} }
20	};
21	goto &{ $AUTOLOAD };
22	} else {
23	require Carp;
24	Carp::croak (qq<Can't locate method "$AUTOLOAD">);
25	}
26	} # AUTOLOAD
27
28	sub ___report_error ($$) { $_[1]->throw }
29
30	## TODO: Documentation
31	sub clone ($) {
32	return bless {%{$_[0]}}, ref $_[0];
33	} # clone
34
35	## \|TreeWalker\| attributes
36
37	sub current_node ($;$) {
38	if (@_ > 1) {
39	if (defined $_[1]) {
40	$_[0]->{current_node} = $_[1];
41	} else {
42	require Message::DOM::DOMException;
43	report Message::DOM::DOMException
44	-object => $_[0],
45	-type => 'NOT_SUPPORTED_ERR',
46	-subtype => 'NULLPO_ERR';
47	}
48	}
49
50	return $_[0]->{current_node};
51	} # current_node
52
53	sub expand_entity_references ($);
54
55	sub filter ($);
56
57	sub root ($);
58
59	sub what_to_show ($);
60
61	## \|TreeWalker\| methods
62
63	sub first_child ($) {
64	local $Error::Depth = $Error::Depth + 1;
65
66	my $sresult = $_[0]->_test_node ($_[0]->{current_node});
67
68	if ($sresult != 12101) { # MANAKAI_FILTER_OPAQUE
69	my @target = (@{$_[0]->{current_node}->child_nodes});
70	A: while (@target) {
71	my $target = shift @target;
72	my $result = $_[0]->_test_node ($target);
73	if ($result == 1 or $result == 12101) {
74	# FILTER_ACCEPT, MANAKAI_FILTER_OPAQUE
75	return ($_[0]->{current_node} = $target);
76	} elsif ($result == 3) { # FILTER_SKIP
77	unshift @target, @{$target->child_nodes};
78	}
79	} # A
80	} # not opaque
81
82	return undef;
83	} # first_child
84
85	sub last_child ($) {
86	local $Error::Depth = $Error::Depth + 1;
87
88	my $sresult = $_[0]->_test_node ($_[0]->{current_node});
89	if ($sresult != 12101) { # MANAKAI_FILTER_OPAQUE
90	my @target = (@{$_[0]->{current_node}->child_nodes});
91	A: while (@target) {
92	my $target = pop @target;
93	my $result = $_[0]->_test_node ($target);
94	if ($result == 1 or $result == 12101) {
95	# FILTER_ACCEPT, MANAKAI_FILTER_OPAQUE
96	return ($_[0]->{current_node} = $target);
97	} elsif ($result == 3) { # FILTER_SKIP
98	push @target, @{$target->child_nodes};
99	}
100	} # A
101	}
102
103	return undef;
104	} # last_child
105
106	sub next_node ($) {
107	local $Error::Depth = $Error::Depth + 1;
108
109	my $target = $_[0]->{current_node};
110	my $tw = $_[0]->clone;
111	$tw->{current_node} = $target;
112	$tw->{root} = $target;
113	my $fc = $tw->first_child;
114	if (defined $fc) {
115	return ($_[0]->{current_node} = $fc);
116	}
117
118	while (defined $target) {
119	my $current = $target;
120	undef $target;
121	P: while (defined $current and not $current eq $_[0]->{root}) {
122	$target = $current->next_sibling;
123	last P if defined $target;
124	$current = $current->parent_node;
125	} # P
126	return undef unless defined $target;
127
128	my $result = $_[0]->_test_node ($target);
129	if ($result == 1 or $result == 12101) {
130	# FILTER_ACCEPT, MANAKAI_FILTER_OPAQUE
131	return ($_[0]->{current_node} = $target);
132	} elsif ($result == 3) { # FILTER_SKIP
133	my $tw = $_[0]->clone;
134	$tw->{current_node} = $target;
135	$tw->{root} = $target;
136	my $fc = $tw->first_child;
137	if (defined $fc) {
138	return ($_[0]->{current_node} = $fc);
139	}
140	}
141	}
142
143	return undef;
144	} # next_node
145
146	sub next_sibling ($) {
147	local $Error::Depth = $Error::Depth + 1;
148
149	my $target = $_[0]->{current_node};
150	while (defined $target) {
151	my $current = $target;
152	undef $target;
153	P: while (defined $current and not $current eq $_[0]->{root}) {
154	$target = $current->next_sibling;
155	last P if defined $target;
156	$current = $current->parent_node;
157	last P unless defined $current;
158	my $presult = $_[0]->_test_node ($current);
159	last P if $presult != 3; # FILTER_SKIP
160	} # P
161	return undef unless defined $target;
162
163	my $result = $_[0]->_test_node ($target);
164	if ($result == 1 or $result == 12101) {
165	# FILTER_ACCEPT, MANAKAI_FILTER_OPAQUE
166	return ($_[0]->{current_node} = $target);
167	} elsif ($result == 3) { # FILTER_SKIP
168	my $tw = $_[0]->clone;
169	$tw->{current_node} = $target;
170	$tw->{root} = $target;
171	my $fc = $tw->first_child;
172	if (defined $fc) {
173	return ($_[0]->{current_node} = $fc);
174	}
175	}
176	}
177
178	return undef;
179	} # next_sibling
180
181	sub parent_node ($) {
182	local $Error::Depth = $Error::Depth + 1;
183
184	unless ($_[0]->{current_node} eq $_[0]->{root}) {
185	my $target = $_[0]->{current_node}->parent_node;
186	T: while (defined $target) {
187	my $result = $_[0]->_test_node ($target);
188	if ($result == 1 or $result == 12101) {
189	# FILTER_ACCEPT, MANAKAI_FILTER_OPAQUE
190	return ($_[0]->{current_node} = $target);
191	} elsif ($target eq $_[0]->{root}) {
192	return undef;
193	}
194	$target = $target->parent_node;
195	} # T
196	}
197
198	return undef;
199	} # parent_node
200
201	sub previous_node ($) {
202	local $Error::Depth = $Error::Depth + 1;
203
204	my $target = $_[0]->{current_node};
205	T: {
206	return undef if $target eq $_[0]->{root};
207
208	P: {
209	my $ptarget = $target->previous_sibling;
210	if (defined $ptarget) {
211	my $result = $_[0]->_test_node ($ptarget);
212	if ($result == 12101) { # MANAKAI_FILTER_OPAQUE
213	return ($_[0]->{current_node} = $ptarget);
214	} elsif ($result != 2) { # FILTER_REJECT
215	my $tw = $_[0]->clone;
216	$tw->{current_node} = $ptarget;
217	$tw->{root} = $ptarget;
218	my $lc = $tw->last_child;
219	return ($_[0]->{current_node} = defined $lc ? $lc : $ptarget);
220	} else {
221	$target = $ptarget;
222	redo P;
223	}
224	}
225	} # P
226
227	my $ptarget = $target->parent_node;
228	if (defined $ptarget) {
229	my $result = $_[0]->_test_node ($ptarget);
230	if ($result == 1 or $result == 12101) {
231	# FILTER_ACCEPT, MANAKAI_FILTER_OPAQUE
232	return ($_[0]->{current_node} = $ptarget);
233	} else {
234	$target = $ptarget;
235	redo T;
236	}
237	}
238	} # T
239
240	return undef;
241	} # previous_node
242
243	sub previous_sibling ($) {
244	local $Error::Depth = $Error::Depth + 1;
245
246	my $target = $_[0]->{current_node};
247	while (defined $target) {
248	my $current = $target;
249	undef $target;
250	P: while (defined $current and not $current eq $_[0]->{root}) {
251	$target = $current->previous_sibling;
252	last P if defined $target;
253
254	$current = $current->parent_node;
255	last P unless defined $current;
256	my $presult = $_[0]->_test_node ($current);
257	if ($presult != 3 and $presult != 2) { # FILTER_SKIP, FILTER_REJECT
258	last P;
259	}
260	} # P
261	return undef unless defined $target;
262
263	my $result = $_[0]->_test_node ($target);
264	if ($result == 1 or $result == 12101) {
265	# FILTER_ACCEPT, MANAKAI_FILTER_OPAQUE
266	return ($_[0]->{current_node} = $target);
267	} elsif ($result == 3) { # FILTER_SKIP
268	my $tw = $_[0]->clone;
269	$tw->{current_node} = $target;
270	$tw->{root} = $target;
271	my $fc = $tw->last_child;
272	if (defined $fc) {
273	return ($_[0]->{current_node} = $fc);
274	}
275	}
276	}
277
278	return undef;
279	} # previous_sibling
280
281	## TODO: Document Perl binding for \|NodeFilter\|.
282	## TODO: \|NodeFilter\| constants...
283
284	sub _test_node ($$) {
285	## NOTE: There is a code clone in \|SerialWalker.pm\|.
286
287	unless ($_[0]->{expand_entity_references}) {
288	my $parent = $_[1]->parent_node;
289	if (defined $parent and $parent->node_type == 5) { # ENTITY_REFERENCE_NODE
290	return 2; # FILTER_REJECT ## NOTE: Even if \|NodeIterator\|.
291	}
292	}
293
294	if ($_[0]->{what_to_show} != 0xFFFFFFFF) { # SHOW_ALL
295	my $nt = $_[1]->node_type;
296	if ($nt < 33 and ($_[0]->{what_to_show} & (1 << ($nt-1)))) {
297	#
298	} else {
299	return 3; # FILTER_SKIP
300	}
301	}
302
303	if (defined $_[0]->{filter}) {
304	local $Error::Depth = $Error::Depth + 1;
305	return $_[0]->{filter}->($_[1]);
306	} else {
307	return 1; # FILTER_ACCEPT
308	}
309	} # _test_node
310
311	package Message::IF::TreeWalker;
312
313	package Message::DOM::Document;
314
315	sub create_tree_walker ($$;$$$) {
316	unless (defined $_[1]) {
317	require Message::DOM::DOMException;
318	report Message::DOM::DOMException
319	-object => $_[0],
320	-type => 'NOT_SUPPORTED_ERR',
321	-subtype => 'NULLPO_ERR';
322	}
323
324	return bless {
325	root => $_[1],
326	what_to_show => 0+($_[2] or 0),
327	filter => $_[3],
328	expand_entity_references => $_[4] ? 1 : 0,
329	current_node => $_[1],
330	}, 'Message::DOM::TreeWalker';
331	} # create_tree_walker
332
333	=pod
334
335	TODO: Documentation...
336
337	FirstChild:
338	If the <IF::NodeFilter>, if any, returns
339	<C::NodeFilter.MANAKAI_FILTER_OPAQUE> for the
340	<A::TreeWalker.currentNode>, this method
341	<kwd:MUST> return <DOM::null>.
342
343	{NOTE::
344	By definition, the parent of the
345	<M::TreeWalker.firstChild> node, if any, is
346	either a child of the <A::TreeWalker.currentNode>
347	or a descendant of the <A::TreeWalker.currentNode>
348	where all ancestors between <A::TreeWalker.currentNode>
349	and that node is <C::NodeFilter.FILTER_SKIP>ped.
350	That means that the only node that might be
351	<C::NodeFilter.MANAKAI_FILTER_OPAQUE> is the
352	<A::TreeWalker.currentNode>.
353	}
354
355
356	@L2Method:
357	@@Name: lastChild
358
359	If the <IF::NodeFilter>, if any, returns
360	<C::NodeFilter.MANAKAI_FILTER_OPAQUE> for the
361	<A::TreeWalker.currentNode>, this method
362	<kwd:MUST> return <DOM::null>.
363
364	{NOTE::
365	By definition, the parent of the
366	<M::TreeWalker.lastChild> node, if any, is
367	either a child of the <A::TreeWalker.currentNode>
368	or a descendant of the <A::TreeWalker.currentNode>
369	where all ancestors between <A::TreeWalker.currentNode>
370	and that node is <C::NodeFilter.FILTER_SKIP>ped.
371	That means that the only node that might be
372	<C::NodeFilter.MANAKAI_FILTER_OPAQUE> is the
373	<A::TreeWalker.currentNode>.
374	}
375
376	parentNode:
377	For the purpose of this method, <C::NodeFilter.MANAKAI_FILTER_OPAQUE>
378	<kwd:MUST> be handled by the same way as
379	<C::NodeFilter.FILTER_ACCEPT>.
380
381	nextNode:
382	If the <A::TreeWalker.currentNode> is marked as
383	<C::NodeFilter.MANAKAI_FILTER_OPAQUE> by the <IF::NodeFilter>,
384	the method <kwd:MUST-NOT> return any descendant of
385	the <A::TreeWalker.currentNode>. Otherwise,
386	it <kwd:MUST> be treated as if <C::NodeFilter.FILTER_ACCEPT>.
387
388	nextSibling:
389	The <C::NodeFilter.MANAKAI_FILTER_OPAQUE> value <kwd:MUST>
390	be treated as if <C::NodeFilter.FILTER_ACCEPT> is specified.
391
392	previousNode:
393	This method <kwd:MUST-NOT> return a descendant
394	of a sibling of the <A::TreeWalker.currentNode> if
395	an ancestor between the descendant and the parent
396	of the <A::TreeWalker.currentNode> (exclusive)
397	is marked as <C::NodeFilter.MANAKAI_FILTER_OPAQUE> by
398	the <IF::NodeFilter> if any. If the node that is
399	a candidate to return is an ancestor of the
400	<A::TreeWalker.currentNode>, the <C::NodeFilter.MANAKAI_FILTER_OPAQUE>
401	value returned by a <IF::NodeFilter> <kwd:MUST> be
402	treated as if the <C::NodeFilter.FILTER_ACCEPT> value
403	is returned.
404
405	previousSibling:
406	If a node that is a candicate to be returned is marked as
407	<C::NodeFilter.MANAKAI_FILTER_OPAQUE>, it <kwd:MUST>
408	be treated as <C::NodeFilter.FILTER_ACCEPT> when the
409	node is a sibling of the <A::TreeWalker.currentNode>,
410	or as in <M::TreeWalker.lastChild> where the
411	<A::TreeWalker.currentNode> would be the sibling
412	of the actual <A::TreeWalker.currentNode> otherwise.
413
414	@@mConst:
415	@@@Name: MANAKAI_FILTER_OPAQUE
416	@@@intValue: 12101
417	@@@enDesc:
418	Accept the node itself while rejecting its children if any.
419
420	If the <C::NodeFilter.MANAKAI_FILTER_OPAQUE> value is
421	specified for a node, the node itself <kwd:MUST> be treated
422	as if the <C::NodeFilter.FILTER_ACCEPT> value is specified.
423	However, any descendant of the node <kwd:MUST> be
424	hidden from the logical view as if the
425	<C::NodeFilter.FILTER_REJECT> value is specified for
426	the ancestor node.
427
428	{NOTE::
429	This value can be used to emulate the
430	<A::TreeWalker.expandEntityReferences> flag.
431	However, unlike that flag, this filtering option
432	makes the engine behave for descendants as if the node is
433	rejected rather than the descendants of the node
434	is rejected.
435	}
436
437	{ISSUE::
438	Better name? Any verb?
439	}
440
441	{ISSUE::
442	Interaction to <IF::NodeIterator>s
443	}
444
445	{NOTE::
446	The <C::Node.ELEMENT_TYPE_DEFINITION_NODE> and
447	<C::Node.ATTRIBUTE_TYPE_DEFINITION> <A::Node.nodeType>s,
448	extended by manakai, has values greater than <CODE::32>
449	so that it cannot be controled by the <CODE::whatToShow>
450	flags.
451	}
452
453	=head1 LICENSE
454
455	Copyright 2007 Wakaba <w@suika.fam.cx>
456
457	This program is free software; you can redistribute it and/or
458	modify it under the same terms as Perl itself.
459
460	=cut
461
462	1;
463	## $Date: 2007/07/14 09:19:11 $