/*
 * Copyright 2003-2010 the original author or authors.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
package groovy.util.slurpersupport;

import java.util.Iterator;
import java.util.Map;

import org.codehaus.groovy.runtime.typehandling.DefaultTypeTransformation;

import groovy.lang.Closure;

/**
 * Lazy evaluated representation of child nodes filtered by a Closure.
 *
 * @author John Wilson
 */
public class FilteredNodeChildren extends NodeChildren {
    private final Closure closure;

    /**
     * @param parent the GPathResult prior to the application of the expression creating this GPathResult
     * @param closure the Closure to use to filter the nodes
     * @param namespaceTagHints the known tag to namespace mappings
     */
    public FilteredNodeChildren(final GPathResult parent, final Closure closure, final Map<String, String> namespaceTagHints) {
        super(parent, parent.name, namespaceTagHints);
        this.closure = closure;
    }

    public Iterator iterator() {
        return new Iterator() {
            final Iterator iter = FilteredNodeChildren.this.parent.iterator();
            Object next = null;

            public boolean hasNext() {
                while (this.iter.hasNext()) {
                    final Object childNode = this.iter.next();
                    if (closureYieldsTrueForNode(childNode)) {
                        this.next = childNode;
                        return true;
                    }
                }
                return false;
            }

            public Object next() {
                return this.next;
            }

            public void remove() {
                throw new UnsupportedOperationException();
            }
        };
    }

    public Iterator nodeIterator() {
        return new NodeIterator(this.parent.nodeIterator()) {
            protected Object getNextNode(final Iterator iter) {
                while (iter.hasNext()) {
                    final Object node = iter.next();
                    if (closureYieldsTrueForNode(new NodeChild((Node) node, FilteredNodeChildren.this.parent, FilteredNodeChildren.this.namespaceTagHints))) {
                        return node;
                    }
                }
                return null;
            }
        };
    }

    private boolean closureYieldsTrueForNode(Object childNode) {
        return DefaultTypeTransformation.castToBoolean(FilteredNodeChildren.this.closure.call(new Object[]{childNode}));
    }
}

@@ -1480,775 +1480,8 @@
  %7D%0A%0A
-    public Iterator iterator() %7B%0A        return new Iterator() %7B%0A            final Iterator iter = FilteredNodeChildren.this.parent.iterator();%0A            Object next = null;%0A%0A            public boolean hasNext() %7B%0A                while (this.iter.hasNext()) %7B%0A                    final Object childNode = this.iter.next();%0A                    if (closureYieldsTrueForNode(childNode)) %7B%0A                        this.next = childNode;%0A                        return true;%0A                    %7D%0A                %7D%0A                return false;%0A            %7D%0A%0A            public Object next() %7B%0A                return this.next;%0A            %7D%0A%0A            public void remove() %7B%0A                throw new UnsupportedOperationException();%0A            %7D%0A        %7D;%0A    %7D%0A%0A
     

Update FilteredNodeChildren.java