Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
  /*
   * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER.
   *
   * Copyright (c) 1997-2010 Oracle and/or its affiliates. All rights reserved.
   *
   * The contents of this file are subject to the terms of either the GNU
   * General Public License Version 2 only ("GPL") or the Common Development
   * and Distribution License("CDDL") (collectively, the "License").  You
   * may not use this file except in compliance with the License.  You can
  * obtain a copy of the License at
  * https://glassfish.dev.java.net/public/CDDL+GPL_1_1.html
  * or packager/legal/LICENSE.txt.  See the License for the specific
  * language governing permissions and limitations under the License.
  *
  * When distributing the software, include this License Header Notice in each
  * file and include the License file at packager/legal/LICENSE.txt.
  *
  * GPL Classpath Exception:
  * Oracle designates this particular file as subject to the "Classpath"
  * exception as provided by Oracle in the GPL Version 2 section of the License
  * file that accompanied this code.
  *
  * Modifications:
  * If applicable, add the following below the License Header, with the fields
  * enclosed by brackets [] replaced by your own identifying information:
  * "Portions Copyright [year] [name of copyright owner]"
  *
  * Contributor(s):
  * If you wish your version of this file to be governed by only the CDDL or
  * only the GPL Version 2, indicate your decision by adding "[Contributor]
  * elects to include this software in this distribution under the [CDDL or GPL
  * Version 2] license."  If you don't indicate a single choice of license, a
  * recipient has the option to distribute your version of this file under
  * either the CDDL, the GPL Version 2 or to extend the choice of license to
  * its licensees as provided above.  However, if you add GPL Version 2 code
  * and therefore, elected the GPL Version 2 license, then the option applies
  * only if the new code is made subject to such option by the copyright
  * holder.
  */
 
 package javax.faces.component;
 
 import java.util.Map;
 

Package private class for iterating over the set of javax.faces.model.SelectItems for a parent UISelectMany or UISelectOne.

// RELEASE_PENDING (rlubke,driscoll) performanc review
 
 final class SelectItemsIterator implements Iterator<SelectItem> {
 
 
     // ------------------------------------------------------------ Constructors
 

    

Construct an iterator instance for the specified parent component.

Parameters:
ctx the javax.faces.context.FacesContext for the current request
parent The parent UIComponent whose children will be processed
 
     public SelectItemsIterator(FacesContext ctxUIComponent parent) {
 
          = parent.getChildren().listIterator();
         this. = ctx;
 
     }
 
 
     // ------------------------------------------------------ Instance Variables
 

    

Iterator over the SelectItem elements pointed at by a UISelectItems component, or null.

 
     private Iterator<SelectItemitems;


    

Iterator over the children of the parent component.

 
     private ListIterator<UIComponentkids;


    
Expose single SelectItems via an Iterator. This iterator will be reset/reused for each individual SelectItem instance encountered.
    private SingleElementIterator singleItemIterator;


    
The javax.faces.context.FacesContext for the current request.
    private FacesContext ctx;
    // -------------------------------------------------------- Iterator Methods


    

Return true if the iteration has more elements.

    public boolean hasNext() {
        if ( != null) {
            if (.hasNext()) {
                return (true);
            } else {
                 = null;
            }
        }
        Object next = findNextValidChild();
        while (next != null) {
            initializeItems(next);
            if ( != null) {
                return true;
            } else {
                next = findNextValidChild();
            }
        }
        return false;
    }


    

Return the next element in the iteration.

Throws:
NoSuchElementException if there are no more elements
    @SuppressWarnings({"unchecked"})
    public SelectItem next() {
        if (!hasNext()) {
            throw new NoSuchElementException();
        }
        if ( != null) {
            return (.next());
        }
        return next();
    }


    

Throw UnsupportedOperationException.

    public void remove() {
        throw new UnsupportedOperationException();
    }
    // --------------------------------------------------------- Private Methods


    

Initializes the items instance variable with an Iterator appropriate to the UISelectItem(s) value.

    private void initializeItems(Object kid) {
        if (kid instanceof UISelectItem) {
            UISelectItem ui = (UISelectItemkid;
            SelectItem item = (SelectItemui.getValue();
            if (item == null) {
                item = new SelectItem(ui.getItemValue(),
                                      ui.getItemLabel(),
                                      ui.getItemDescription(),
                                      ui.isItemDisabled(),
                                      ui.isItemEscaped(),
                                      ui.isNoSelectionOption());
            }
            updateSingeItemIterator(item);
             = ;
        } else if (kid instanceof UISelectItems) {
            UISelectItems ui = (UISelectItemskid;
            Object value = ui.getValue();
            if (value != null) {
                if (value instanceof SelectItem) {
                    updateSingeItemIterator((SelectItemvalue);
                     = ;
                } else if (value.getClass().isArray()) {
                     = new ArrayIterator(, (UISelectItemskidvalue);
                } else if (value instanceof Iterable) {
                     = new IterableItemIterator(,
                                                     (UISelectItemskid,
                                                     (Iterable<?>) value);
                } else if (value instanceof Map) {
                     = new MapIterator((Mapvalue);
                } else {
                    throw new IllegalArgumentException();
                }
            }
            if ( != null && !.hasNext()) {
                 = null;
            }
        } 
    }


    

Returns:
the next valid child for processing
    private Object findNextValidChild() {
        if (.hasNext()) {
            Object next = .next();
            while (.hasNext() && !(next instanceof UISelectItem || next instanceof UISelectItems)) {
                next = .next();
            }
            if (next instanceof UISelectItem || next instanceof UISelectItems) {
                return next;
            }
        }
        return null;
    }


    
Update the singleItemIterator with the provided item

Parameters:
item the javax.faces.model.SelectItem to expose as an Iterator
    private void updateSingeItemIterator(SelectItem item) {
        if ( == null) {
             = new SingleElementIterator();
        }
        .updateItem(item);
    }
    // ---------------------------------------------------------- Nested Classes


    
Exposes single javax.faces.model.SelectItem instances as an Iterator.
    private static final class SingleElementIterator implements Iterator<SelectItem> {
        private SelectItem item;
        private boolean nextCalled;
        // ----------------------------------------------- Methods from Iterator
        public boolean hasNext() {
            return !;
        }
        public SelectItem next() {
            if () {
                throw new NoSuchElementException();
            }
             = true;
            return ;
        }
        public void remove() {
            throw new UnsupportedOperationException();
        }
        // ----------------------------------------------------- Private Methods
        private void updateItem(SelectItem item) {
            this. = item;
             = false;
        }
    } // END SingleElementIterator


    
Iterates over a Map of values exposing each entry as a SelectItem. Note that this will do so re-using the same SelectItem but changing the value and label as appropriate.
    private static final class MapIterator implements Iterator<SelectItem> {
        private SelectItem item = new SelectItem();
        private Iterator iterator;
        // -------------------------------------------------------- Constructors
        private MapIterator(Map map) {
            this. = map.entrySet().iterator();
        }
        // ----------------------------------------------- Methods from Iterator
        public boolean hasNext() {
            return .hasNext();
        }
        public SelectItem next() {
            Map.Entry entry = (Map.Entry.next();
            Object key = entry.getKey();
            Object value = entry.getValue();
            .setLabel(((key != null) ? key.toString() : value.toString()));
            .setValue(((value != null) ? value : ""));
            return ;
            
        }
        public void remove() {
            throw new UnsupportedOperationException();
        }
    } // END MapIterator


    

Base class to support iterating over Collections or Arrays that may or may not contain SelectItem instances.

    private static abstract class GenericObjectSelectItemIterator implements Iterator<SelectItem> {

        
SelectItem that is updated based on the current Object being iterated over.
        private GenericObjectSelectItem genericObjectSI;

        
The source UISelectItems.
        protected UISelectItems sourceComponent;
        // -------------------------------------------------------- Constructors
        protected GenericObjectSelectItemIterator(UISelectItems sourceComponent) {
            this. = sourceComponent;
        }
        // --------------------------------------------------- Protected Methods
        protected SelectItem getSelectItemFor(FacesContext ctxObject value) {
            if ( == null) {
                 = new GenericObjectSelectItem();
            }
            .updateItem(ctxvalue);
            return ;
            
        }
        // ------------------------------------------------------ Nested Classes


        
A SelectItem implementation to support generating unique SelectItem values based on ValueExpressions from the owning UISelectItems instance.
        @SuppressWarnings({"serial"})
        private static final class GenericObjectSelectItem extends SelectItem {
            private static final String VAR = "var";
            private static final String ITEM_VALUE = "itemValue";
            private static final String ITEM_LABEL = "itemLabel";
            private static final String ITEM_DESCRIPTION = "itemDescription";
            private static final String ITEM_ESCAPED = "itemLabelEscaped";
            private static final String ITEM_DISABLED = "itemDisabled";
            private static final String NO_SELECTION_OPTION = "noSelectionOption";

            
Resolves to the value of the SelectItem.
            private ValueExpression itemValue;

            
Resolves to the label of the SelectItem.
            private ValueExpression itemLabel;

            
Resolves to the description of the SelectItem.
            private ValueExpression itemDescription;

            
Determines the value for the escaped property of the SelectItem.
            private ValueExpression itemEscaped;

            
Determines the value for the disabled property of the SelectItem/
            private ValueExpression itemDisabled;

            
Determines the value for the noSelectionOption property of the SelectItem/
            private ValueExpression noSelectionOption;

            
The request-scoped variable under which the current object will be exposed.
            private String var;
            private UISelectItems sourceComponent;
            // -------------------------------------------------------- Constructors
            private GenericObjectSelectItem(UISelectItems sourceComponent) {
                 = (StringsourceComponent.getAttributes().get();
                this. = sourceComponent;
                //itemValue = sourceComponent.getValueExpression(ITEM_VALUE);
                //itemLabel = sourceComponent.getValueExpression(ITEM_LABEL);
                //itemDescription = sourceComponent.getValueExpression(ITEM_DESCRIPTION);
                //itemEscaped = sourceComponent.getValueExpression(ITEM_ESCAPED);
                //itemDisabled = sourceComponent.getValueExpression(ITEM_DISABLED);
                //noSelectionOption = sourceComponent.getValueExpression(NO_SELECTION_OPTION);
            }
            // ----------------------------------------------------- Private Methods


            
Updates the SelectItem properties based on the current value.

Parameters:
ctx the javax.faces.context.FacesContext for the current request
value the value to build the updated values from
            private void updateItem(FacesContext ctxObject value) {
                Map<StringObjectreqMap =
                      ctx.getExternalContext().getRequestMap();
                Object oldVarValue = null;
                if ( != null) {
                    oldVarValue = reqMap.put(value);
                }
                try {
                    Map<String,Objectattrs = .getAttributes();
                    Object itemValueResult = attrs.get();
                    Object itemLabelResult = attrs.get();
                    Object itemDescriptionResult = attrs.get();
                    Object itemEscapedResult = attrs.get();
                    Object itemDisabledResult = attrs.get();
                    Object noSelectionOptionResult = attrs.get();
                    setValue(((itemValueResult != null) ? itemValueResult : value));
                    setLabel(((itemLabelResult != null)
                                  ? itemLabelResult.toString()
                                  : value.toString()));
                    setDescription(((itemDescriptionResult != null)
                                        ? itemDescriptionResult.toString()
                                        : null));
                    setEscape(((itemEscapedResult != null)
                                   ? Boolean.valueOf(itemEscapedResult.toString())
                                   : false));
                    setDisabled(((itemDisabledResult != null)
                                     ? Boolean.valueOf(itemDisabledResult.toString())
                                     : false));
                    setNoSelectionOption(((noSelectionOptionResult != null)
                                     ? Boolean.valueOf(noSelectionOptionResult.toString())
                                    : false));
                } finally {
                    if ( != null) {
                        if (oldVarValue != null) {
                            reqMap.put(oldVarValue);
                        } else {
                            reqMap.remove();
                        }
                    }
                }
            }
            // --------------------------------------- Methods from Serializable
            private void writeObject(ObjectOutputStream outthrows IOException {
                throw new NotSerializableException();
            }
            private void readObject(ObjectInputStream inthrows IOException {
                throw new NotSerializableException();
            }
        } // END GenericObjectSelectItem
    } // END GenericObjectSelectItemIterator


    
Handles arrays of SelectItems, generic Objects, or combintations of both. A single GenericObjectSelectItem will be leverage for any non-SelectItem objects encountered.
    private static final class ArrayIterator extends GenericObjectSelectItemIterator {
        private FacesContext ctx;
        private Object array;
        private int count;
        private int index;
        // -------------------------------------------------------- Constructors
        private ArrayIterator(FacesContext ctx,
                              UISelectItems sourceComponent,
                              Object array) {
            super(sourceComponent);
            this. = ctx;
            this. = array;
             = Array.getLength(array);
        }
        // ----------------------------------------------- Methods from Iterator
        public boolean hasNext() {
            return ( < );
        }
        public SelectItem next() {
            if ( >= ) {
                throw new NoSuchElementException();
            }
            Object item = Array.get(++);
            if (item instanceof SelectItem) {
                return (SelectItemitem;
            } else {
                return getSelectItemFor(item);
            }
        }
        public void remove() {
            throw new UnsupportedOperationException();
        }
    } // END ArrayIterator


    
Handles Collections of SelectItems, generic Objects, or combintations of both. A single GenericObjectSelectItem will be leverage for any non-SelectItem objects encountered.
    private static final class IterableItemIterator extends GenericObjectSelectItemIterator {
        private FacesContext ctx;
        private Iterator<?> iterator;
        // -------------------------------------------------------- Constructors
        private IterableItemIterator(FacesContext ctx,
                                     UISelectItems sourceComponent,
                                     Iterable<?> iterable) {
            super(sourceComponent);
            this. = ctx;
            this. = iterable.iterator();
        }
        // ----------------------------------------------- Methods from Iterator
        public boolean hasNext() {
            return .hasNext();
        }
        public SelectItem next() {
            Object item = .next();
            if (item instanceof SelectItem) {
                return (SelectItemitem;
            } else {
                return getSelectItemFor(item);
            }
        }
        public void remove() {
            throw new UnsupportedOperationException();
            
        }
    } // END CollectionItemIterator
New to GrepCode? Check out our FAQ X