Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
  /*
   * JBoss, Home of Professional Open Source
   * Copyright ${year}, Red Hat, Inc. and individual contributors
   * by the @authors tag. See the copyright.txt in the distribution for a
   * full listing of individual contributors.
   *
   * This is free software; you can redistribute it and/or modify it
   * under the terms of the GNU Lesser General Public License as
   * published by the Free Software Foundation; either version 2.1 of
  * the License, or (at your option) any later version.
  *
  * This software is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
  * Lesser General Public License for more details.
  *
  * You should have received a copy of the GNU Lesser General Public
  * License along with this software; if not, write to the Free
  * Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
  * 02110-1301 USA, or see the FSF site: http://www.fsf.org.
  */
 package org.richfaces.model;
 
 import static org.richfaces.application.configuration.ConfigurationServiceHelper.getBooleanConfigurationValue;
 
 import java.util.List;
 import java.util.Map;
 
 import  javax.faces.context.FacesContext;
 import  javax.faces.model.DataModelListener;
 
 import  org.ajax4jsf.model.DataVisitResult;
 import  org.ajax4jsf.model.DataVisitor;
 import  org.ajax4jsf.model.ExtendedDataModel;
 import  org.ajax4jsf.model.Range;
 import  org.ajax4jsf.model.SequenceRange;
 import  org.richfaces.component.SortOrder;

Author(s):
Konstantin Mishin
 
 public class ArrangeableModel extends ExtendedDataModel<Objectimplements Arrangeable {
     private ArrangeableState state;
     private List<ObjectrowKeys;
     private ExtendedDataModel<?> originalModel;
     private String var;
     private String filterVar;
     private Comparator<? super StringstringComparator;
 
     public ArrangeableModel(ExtendedDataModel<?> originalModelString varString filterVar) {
         this. = originalModel;
         this. = var;
         this. = filterVar;
     }
 
     public void addDataModelListener(DataModelListener listener) {
         .addDataModelListener(listener);
     }
 
     public void removeDataModelListener(DataModelListener listener) {
         .removeDataModelListener(listener);
     }
 
     public DataModelListener[] getDataModelListeners() {
         return .getDataModelListeners();
     }
 
     /*
      * (non-Javadoc)
      *
      * @see org.ajax4jsf.model.ExtendedDataModel#getRowKey()
      */
     public Object getRowKey() {
         return .getRowKey();
     }
 
     /*
      * (non-Javadoc)
      *
      * @see org.ajax4jsf.model.ExtendedDataModel#setRowKey(java.lang.Object)
      */
     public void setRowKey(Object key) {
         .setRowKey(key);
     }
 
     /*
      * (non-Javadoc)
      *
      * @see org.ajax4jsf.model.ExtendedDataModel#walk(javax.faces.context.FacesContext, org.ajax4jsf.model.DataVisitor,
      * org.ajax4jsf.model.Range, java.lang.Object)
     */
    public void walk(FacesContext context, DataVisitor visitor, Range rangeObject argument) {
        final SequenceRange seqRange = (SequenceRange) range;
        int rows = seqRange.getRows();
        int rowCount = getRowCount();
        int currentRow = seqRange.getFirstRow();
        if (rows > 0) {
            rows += currentRow;
            rows = Math.min(rowsrowCount);
        } else {
            rows = rowCount;
        }
        for (; currentRow < rowscurrentRow++) {
            visitor.process(context.get(currentRow), argument);
        }
    }
    /*
     * (non-Javadoc)
     *
     * @see javax.faces.model.DataModel#getRowCount()
     */
    public int getRowCount() {
        if ( == null) {
            return -1;
        } else {
            return .size();
        }
    }
    /*
     * (non-Javadoc)
     *
     * @see javax.faces.model.DataModel#getRowData()
     */
    public Object getRowData() {
        return .getRowData();
    }
    /*
     * (non-Javadoc)
     *
     * @see javax.faces.model.DataModel#getRowIndex()
     */
    public int getRowIndex() {
        return .indexOf(.getRowKey());
    }
    /*
     * (non-Javadoc)
     *
     * @see javax.faces.model.DataModel#getWrappedData()
     */
    public Object getWrappedData() {
        return .getWrappedData();
    }
    /*
     * (non-Javadoc)
     *
     * @see javax.faces.model.DataModel#isRowAvailable()
     */
    public boolean isRowAvailable() {
        return .isRowAvailable();
    }
    /*
     * (non-Javadoc)
     *
     * @see javax.faces.model.DataModel#setRowIndex(int)
     */
    public void setRowIndex(int rowIndex) {
        Object originalKey = null;
        if (rowIndex >= 0 && rowIndex < .size()) {
            originalKey = .get(rowIndex);
        }
        .setRowKey(originalKey);
    }
    /*
     * (non-Javadoc)
     *
     * @see javax.faces.model.DataModel#setWrappedData(java.lang.Object)
     */
    public void setWrappedData(Object data) {
        .setWrappedData(data);
    }
    /*
     * (non-Javadoc)
     *
     * @see org.richfaces.model.Modifiable#modify(org.richfaces.model.ModifiableState)
     */
    public void arrange(FacesContext context, ArrangeableState state) {
        initializeRowKeys(context);
        if (state != null) {
            this. = state;
            Map<StringObjectmap = context.getExternalContext().getRequestMap();
            Object value = null;
            Object filterValue = null;
            if ( != null && .length() > 0) {
                value = map.get();
            }
            if ( != null && .length() > 0) {
                filterValue = map.get();
            }
            filter(context);
            sort(context);
            if ( != null && .length() > 0) {
                map.put(value);
            }
            if ( != null && .length() > 0) {
                map.put(filterValue);
            }
        }
    }
    private void initializeRowKeys(FacesContext context) {
        int rowCount = .getRowCount();
        if (rowCount > 0) {
             = new ArrayList<Object>(rowCount);
        } else {
             = new ArrayList<Object>();
        }
        Object rowKey = .getRowKey();
        .walk(contextnew DataVisitor() {
            public DataVisitResult process(FacesContext contextObject rowKeyObject argument) {
                .setRowKey(rowKey);
                if (.isRowAvailable()) {
                    .add(rowKey);
                }
                return DataVisitResult.CONTINUE;
            }
        }, new SequenceRange(0, -1), null);
        .setRowKey(rowKey);
    }
    private void filter(FacesContext context) {
        List<FilterField> filterFields = .getFilterFields();
        if (filterFields != null && !filterFields.isEmpty()) {
            List<ObjectfilteredCollection = new ArrayList<Object>();
            for (Object rowKey : ) {
                if (accept(contextrowKey)) {
                    filteredCollection.add(rowKey);
                }
            }
             = filteredCollection;
        }
    }
    private void sort(final FacesContext context) {
        List<SortField> sortFields = .getSortFields();
        if (sortFields != null && !sortFields.isEmpty()) {
            Collections.sort(new Comparator<Object>() {
                public int compare(Object rowKey1Object rowKey2) {
                    return ArrangeableModel.this.compare(contextrowKey1rowKey2);
                }
            });
        }
    }
    private boolean accept(FacesContext contextObject rowKey) {
        .setRowKey(rowKey);
        Object object = .getRowData();
        updateVar(contextobject);
        for (FilterField filterField : .getFilterFields()) {
            Filter filter = filterField.getFilter();
            if (filter != null && !filter.accept(object)) {
                return false;
            } else {
                ValueExpression filterExpression = filterField.getFilterExpression();
                if (filterExpression != null) {
                    updateVar(contextfilterField.getFilterValue());
                    if (..equals(filterExpression.getValue(context.getELContext()))) {
                        return false;
                    }
                }
            }
        }
        return true;
    }
    private int compare(FacesContext contextObject rowKey1Object rowKey2) {
        .setRowKey(rowKey1);
        Object object1 = .getRowData();
        .setRowKey(rowKey2);
        Object object2 = .getRowData();
        int result = 0;
        for (Iterator<SortField> iterator = .getSortFields().iterator(); iterator.hasNext() && result == 0;) {
            SortField sortField = iterator.next();
            SortOrder sortOrder = sortField.getSortOrder();
            if (sortOrder != null && !SortOrder.unsorted.equals(sortOrder)) {
                Comparator comparator = sortField.getComparator();
                if (comparator != null) {
                    result = comparator.compare(object1object2);
                } else {
                    ValueExpression sortBy = sortField.getSortBy();
                    if (sortBy != null) {
                        updateVar(contextobject1);
                        Object value1 = sortBy.getValue(context.getELContext());
                        updateVar(contextobject2);
                        Object value2 = sortBy.getValue(context.getELContext());
                        result = compareSortByValues(contextvalue1value2);
                    }
                }
                if (SortOrder.descending.equals(sortOrder)) {
                    result = -result;
                }
            }
        }
        return result;
    }
    private int compareSortByValues(FacesContext contextObject value1Object value2) {
        int result = 0;
        if (value1 instanceof String && value2 instanceof String) {
            if ( == null) {
                 = createStringComparator(context);
            }
            result = .compare(((Stringvalue1).trim(), ((Stringvalue2).trim());
        } else if (value1 == null && value2 != null) {
            result = -1;
        } else if (value2 == null && value1 != null) {
            result = 1;
        } else if (value1 instanceof Comparable<?>) {
            result = ((Comparablevalue1).compareTo(value2);
        }
        return result;
    }
    private Comparator<? super StringcreateStringComparator(FacesContext context) {
        Comparator<? super Stringcomparator = null;
        Locale locale = .getLocale();
        if (locale != null
            && getBooleanConfigurationValue(context..)) {
            comparator = Collator.getInstance(locale);
        } else {
            comparator = new Comparator<String>() {
                public int compare(String o1String o2) {
                    return o1.compareToIgnoreCase(o2);
                }
            };
        }
        return comparator;
    }
    private void updateVar(FacesContext contextString varObject value) {
        if (var != null && var.length() > 0) {
            context.getExternalContext().getRequestMap().put(varvalue);
        }
    }
New to GrepCode? Check out our FAQ X