protected void iterate(FacesContext context, PhaseId phaseId) {

        // Process each facet of this component exactly once
        setRowIndex(-1);
        if (getFacetCount() > 0) {
            for (UIComponent facet : getFacets().values()) {
                if (phaseId == PhaseId.APPLY_REQUEST_VALUES) {
                    facet.processDecodes(context);
                } else if (phaseId == PhaseId.PROCESS_VALIDATIONS) {
                    facet.processValidators(context);
                } else if (phaseId == PhaseId.UPDATE_MODEL_VALUES) {
                    facet.processUpdates(context);
                } else {
                    throw new IllegalArgumentException();
                }
            }
        }

        // collect rendered columns once
        List<UIColumn> renderedColumns = new ArrayList<>(getChildCount());
        if (getChildCount() > 0) {
        	for (UIComponent child : getChildren()) {
        		if (child instanceof UIColumn && child.isRendered()) {
        			renderedColumns.add((UIColumn)child);
        		}
        	}
        }

        // Process each facet of our child UIColumn components exactly once
        setRowIndex(-1);
        for (UIColumn column : renderedColumns) {
            if (column.getFacetCount() > 0) {
                for (UIComponent columnFacet : column.getFacets().values()) {
                    if (phaseId == PhaseId.APPLY_REQUEST_VALUES) {
                        columnFacet.processDecodes(context);
                    } else if (phaseId == PhaseId.PROCESS_VALIDATIONS) {
                        columnFacet.processValidators(context);
                    } else if (phaseId == PhaseId.UPDATE_MODEL_VALUES) {
                        columnFacet.processUpdates(context);
                    } else {
                        throw new IllegalArgumentException();
                    }
                }
            }
        }

        // Iterate over our UIColumn children, once per row
        int processed = 0;
        int rowIndex = getFirst() - 1;
        int rows = getRows();

        while (true) {

            // Have we processed the requested number of rows?
            if ((rows > 0) && (++processed > rows)) {
                break;
            }

            // Expose the current row in the specified request attribute
            setRowIndex(++rowIndex);
            if (!isRowAvailable()) {
                break; // Scrolled past the last row
            }

            // Perform phase-specific processing as required
            // on the *children* of the UIColumn (facets have
            // been done a single time with rowIndex=-1 already)
            for (UIColumn kid : renderedColumns) {
                if (kid.getChildCount() > 0) {
                    for (UIComponent grandkid : kid.getChildren()) {
                        if (!grandkid.isRendered()) {
                            continue;
                        }
                        if (phaseId == PhaseId.APPLY_REQUEST_VALUES) {
                            grandkid.processDecodes(context);
                        } else if (phaseId == PhaseId.PROCESS_VALIDATIONS) {
                            grandkid.processValidators(context);
                        } else if (phaseId == PhaseId.UPDATE_MODEL_VALUES) {
                            grandkid.processUpdates(context);
                        } else {
                            throw new IllegalArgumentException();
                        }
                    }
                }
            }

        }

        // Clean up after ourselves
        setRowIndex(-1);

    }
<p>Perform the appropriate phase-specific processing and per-row
iteration for the specified phase, as follows:
<ul>
<li>Set the <code>rowIndex</code> property to -1, and process the facets
    of this {@link UIData} component exactly once.</li>
<li>Set the <code>rowIndex</code> property to -1, and process the facets
    of the {@link UIColumn} children of this {@link UIData} component
    exactly once.</li>
<li>Iterate over the relevant rows, based on the <code>first</code>
    and <code>row</code> properties, and process the children
    of the {@link UIColumn} children of this {@link UIData} component
    once per row.</li>
</ul>

@param context {@link FacesContext} for the current request
@param phaseId {@link PhaseId} of the phase we are currently running
primefaces/src/main/java/org/primefaces/component/patch/UIDataPatch.java