htmldatatablehack.java

一个使用struts+hibernate+spring开发的完的网站源代码。

        {
            UIComponent child = (UIComponent)it.next();
            //clear this descendant's clientId:
            child.setId(child.getId()); //HACK: This assumes that setId always clears the cached clientId. Can we be sure?
            if (child instanceof EditableValueHolder)
            {
                if (states != null)
                {
                    states[counter].restore((EditableValueHolder)child);
                }
                else if (initialStates != null)
                {
                    initialStates[counter].restore((EditableValueHolder)child);
                }
                else
                {
                    // No state saved yet and no initial state !?
                    // Should never be possible, but let's reset the component
                    // state to null values
                    ((EditableValueHolder)child).setValue(null);
                    ((EditableValueHolder)child).setLocalValueSet(false);
                    ((EditableValueHolder)child).setValid(true);
                    ((EditableValueHolder)child).setSubmittedValue(null);
                }
                counter++;
            }
            counter = restoreDescendantComponentStates(child, states, initialStates, counter,level+1);
        }
        return counter;
    }

    private static Iterator getChildrenAndOptionalFacetsIterator(int level, UIComponent component)
    {
        Iterator it;

        if(level>1)
        {
            it = component.getFacetsAndChildren();
        }
        else
        {
            it = component.getChildren().iterator();
        }
        return it;
    }


    public void setValueBinding(String name,
                                ValueBinding binding)
    {
        if (name == null)
        {
            throw new NullPointerException("name");
        }
        else if (name.equals("value"))
        {
            _dataModel = null;
        }
        else if (name.equals("var") || name.equals("rowIndex"))
        {
            throw new IllegalArgumentException("name " + name);
        }
        super.setValueBinding(name, binding);
    }


    private DataModel getDataModel()
    {
        UIData embeddingUIData = getEmbeddingUIData();
        if (embeddingUIData != null)
        {
            //This UIData is nested in another UIData, so we must not
            //do simple caching of the current DataModel. We must associate
            //the DataModel that we want to cache with the clientId of the
            //embedding UIData. This clientId will be different for every
            //row of the embedding UIData.
            if (_dataModelMap == null)
            {
                _dataModelMap = new HashMap();
            }
            String embeddingClientId = embeddingUIData.getClientId(FacesContext.getCurrentInstance());
            DataModel dataModel = (DataModel) _dataModelMap.get(embeddingClientId);
            if (dataModel == null)
            {
                dataModel = createDataModel();
                _dataModelMap.put(embeddingClientId, dataModel);
            }
            return dataModel;
        }
        else
        {
            //This UIData is not nested within another UIData. So there
            //is no need for the DataModel Map.
            if (_dataModel == null)
            {
                _dataModel = createDataModel();
            }
            return _dataModel;
        }
    }

    /**
     * Creates a new DataModel around the current value.
     */
    private DataModel createDataModel()
    {
        Object value = getValue();
        if (value == null)
        {
            return EMPTY_DATA_MODEL;
        }
        else if (value instanceof DataModel)
        {
            return (DataModel)value;
        }
        else if (value instanceof List)
        {
            return new ListDataModel((List)value);
        }
        else if (OBJECT_ARRAY_CLASS.isAssignableFrom(value.getClass()))
        {
            return new ArrayDataModel((Object[])value);
        }
        else if (value instanceof ResultSet)
        {
            return new ResultSetDataModel((ResultSet)value);
        }
        else if (value instanceof Result)
        {
            return new ResultDataModel((Result)value);
        }
        else
        {
            return new ScalarDataModel(value);
        }
    }

    /**
     * Looks for an embedding UIData component
     * @return the embedding UIData or null
     */
    private UIData getEmbeddingUIData()
    {
        if (_isEmbeddedUIData == null)
        {
            UIComponent findParentUIData = getParent();
            while (findParentUIData != null &&
                   !(findParentUIData instanceof UIData))
            {
                findParentUIData = findParentUIData.getParent();
            }
            if (findParentUIData != null)
            {
                _embeddingUIData = (UIData)findParentUIData;
                _isEmbeddedUIData = Boolean.TRUE;
            }
            else
            {
                _isEmbeddedUIData = Boolean.FALSE;
            }
        }

        if (_isEmbeddedUIData.booleanValue())
        {
            return _embeddingUIData;
        }
        else
        {
            return null;
        }
    }


    private static final DataModel EMPTY_DATA_MODEL = new DataModel()
    {
        public boolean isRowAvailable()
        {
            return false;
        }

        public int getRowCount()
        {
            return 0;
        }

        public Object getRowData()
        {
            throw new IllegalArgumentException();
        }

        public int getRowIndex()
        {
            return -1;
        }

        public void setRowIndex(int i)
        {
            if (i < -1) throw new IllegalArgumentException();
        }

        public Object getWrappedData()
        {
            return null;
        }

        public void setWrappedData(Object obj)
        {
            if (obj == null) return; //Clearing is allowed
            throw new UnsupportedOperationException(this.getClass().getName() + " UnsupportedOperationException");
        }
    };


    private static class EditableValueHolderState
            implements Serializable
    {
        private Object _localValue;
        private boolean _localValueSet;
        private boolean _valid;
        private Object _submittedValue;

        public EditableValueHolderState(EditableValueHolder vh)
        {
            _localValue = vh.getLocalValue();
            _localValueSet = vh.isLocalValueSet();
            _valid = vh.isValid();
            _submittedValue = vh.getSubmittedValue();
        }

        public void restore(EditableValueHolder vh)
        {
            vh.setValue(_localValue);
            vh.setLocalValueSet(_localValueSet);
            vh.setValid(_valid);
            vh.setSubmittedValue(_submittedValue);
        }
    }


    public Object saveState(FacesContext context)
    {
        Object values[] = new Object[7];
        values[0] = super.saveState(context);
        values[1] = _saveDescendantStates ? _descendantStates : null;
        values[2] = _saveDescendantStates ? new Integer(_descendantEditableValueHolderCount) : INTEGER_MINUS1;
        return values;
    }

    public void restoreState(FacesContext context, Object state)
    {
        Object values[] = (Object[])state;
        super.restoreState(context, values[0]);
        _descendantStates = (Object[])values[1];
        _descendantEditableValueHolderCount = ((Integer)values[2]).intValue();
    }

}