Method step_do

UnitTests/TestApp/pugixml.cpp:8697–8752

	template<class T>
	xpath_node_set_raw step_do(const xpath_context& c, const xpath_stack& stack, T v)
	{
		const axis_t axis = T::axis;
		bool attributes =
			(axis == axis_ancestor || axis == axis_ancestor_or_self || axis == axis_descendant_or_self ||
			 axis == axis_following || axis == axis_parent || axis == axis_preceding || axis == axis_self);

		xpath_node_set_raw ns;
		ns.set_type(
			(axis == axis_ancestor || axis == axis_ancestor_or_self || axis == axis_preceding ||
			 axis == axis_preceding_sibling)
				? xpath_node_set::type_sorted_reverse
				: xpath_node_set::type_sorted);

		if (_left)
		{
			xpath_node_set_raw s = _left->eval_node_set(c, stack);

			// self axis preserves the original order
			if (axis == axis_self)
				ns.set_type(s.type());

			for (const xpath_node* it = s.begin(); it != s.end(); ++it)
			{
				size_t size = ns.size();

				// in general, all axes generate elements in a particular order, but there is no order guarantee if axis is applied to two nodes
				if (axis != axis_self && size != 0)
					ns.set_type(xpath_node_set::type_unsorted);

				if (it->node())
					step_fill(ns, it->node(), stack.result, v);
				else if (attributes)
					step_fill(ns, it->attribute(), it->parent(), stack.result, v);

				apply_predicates(ns, size, stack);
			}
		}
		else
		{
			if (c.n.node())
				step_fill(ns, c.n.node(), stack.result, v);
			else if (attributes)
				step_fill(ns, c.n.attribute(), c.n.parent(), stack.result, v);

			apply_predicates(ns, 0, stack);
		}

		// child, attribute and self axes always generate unique set of nodes
		// for other axis, if the set stayed sorted, it stayed unique because the traversal algorithms do not visit the same node twice
		if (axis != axis_child && axis != axis_attribute && axis != axis_self &&
			ns.type() == xpath_node_set::type_unsorted)
			ns.remove_duplicates();

		return ns;
	}

public: