Many resources are needed to download a project. Please understand that we have to compensate our server costs. Thank you in advance. Project price only 1 $
You can buy this project and download/modify it how often you want.
/*
* Copyright 2004-2014 ICEsoft Technologies Canada Corp.
*
* 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 org.icefaces.ace.model.table;
import org.icefaces.ace.util.CollectionUtils;
import org.icefaces.ace.util.collections.EntrySetToKeyListTransformer;
import org.icefaces.ace.util.collections.Predicate;
import javax.faces.component.UIComponent;
import javax.faces.model.DataModel;
import java.io.Serializable;
import java.util.*;
/**
* A Map that defines the ace:dataTable feature state of the row objects of a given ace:dataTable.
*
* States can be added at initialization, or will be created as needed during row object rendering if no state exists.
*/
public class RowStateMap implements Map, Serializable {
private Map map = new HashMap();
private static Predicate selectedPredicate = new SelectedPredicate();
private static Predicate selectablePredicate = new SelectablePredicate();
private static Predicate editablePredicate = new EditablePredicate();
private static Predicate expandablePredicate = new ExpandablePredicate();
private static Predicate expandedPredicate = new ExpandedPredicate();
private static Predicate visiblePredicate = new VisiblePredicate();
private static Predicate rowExpansionPredicate = new RowExpansionPredicate();
private static Predicate panelExpansionPredicate = new PanelExpansionPredicate();
private static Predicate hasSelectedCellsPredicate = new SelectedCellsPredicate();
/**
* Put a new state for a specific row object. Overwrites old states.
* @param o row object
* @param s new state
* @return old state or null if none existed
*/
public RowState put(Object o, RowState s) {
return map.put(o, s);
}
/**
* Put a empty state for a specific row object. Overwrites old states.
* @param o row object
*/
public void add(Object o) {
map.put(o, new RowState());
}
/**
* Get the number of states held in this map
* @return map entry count
*/
public int size() {
return map.size();
}
/**
* Get if this map is empty
* @return if this map empty
*/
public boolean isEmpty() {
return map.isEmpty();
}
/**
* Get if this map contains a state for a particular row object
* @param key row object
* @return if this map contains the row object param
*/
public boolean containsKey(Object key) {
return map.containsKey(key);
}
/**
* Get if this map contains a particular row state
* @param value row state
* @return if this map contains the row state param
*/
public boolean containsValue(Object value) {
return map.containsValue(value);
}
/**
* Get the row state for a particular row object
* @param o row object
* @return row state
*/
public RowState get(Object o) {
RowState s = map.get(o);
if (s == null) {
add(o);
s = map.get(o);
}
return s;
}
/**
* Remove the row state for a particular row object. A new empty state will
* be added for the row if it is rendered in a coming request.
* @param o
* @return the rowstate returned by the remove method.
*/
public RowState remove(Object o) {
return map.remove(o);
}
/**
* Add all entries from the input map to this map.
* @param m input map
*/
public void putAll(Map m) {
map.putAll(m);
}
/**
* Remove all row states from this map.
*/
public void clear() {
map.clear();
}
/**
* Get the set of all row objects with attached RowStates
* @return set of row objects that have state
*/
public Set keySet() {
return map.keySet();
}
/**
* Get the collection of all RowStates
* @return the state of every row in this map
*/
public Collection values() {
return map.values();
}
/**
* Get the collection of all Map Entry objects, defining a key row object and value row state.
* @return row object state entry collection
*/
public Set entrySet() {
return map.entrySet();
}
/**
* Replace a row object with one that hashes identically but is a distinct copy.
* Useful for updating the row state map when replacing the data set with a copy.
* @param o
*/
public void updateData(Object o) {
map.put(o, map.remove(o));
}
/**
* This method will look up state entries with keys in the input list, and update their
* key with the copy from the input list.
*
* This method is useful in applications where row data is updated by replacing a row
* with an object copy that is equal() but contains differences that must be reflected in methods
* that return row data from the rowStateMap. Without updating, in this circumstance, the key is still a
* reference to the old copy of the data, and though the state will be correctly correlated to the new key,
* methods returning the key, will return the old key.
*
* @param data - A list of row data equal() to some key already in the rowStateMap, but with changes that require the current key to be replaced.
*/
public void updateData(List data) {
List values = new ArrayList(data.size());
for (Object d : data) {
values.add(map.remove(d));
}
int i = 0;
for (RowState v : values) {
if (v != null) map.put(data.get(i), v);
//else {
// System.out.println("Updating a null state!");
//}
i++;
}
}
/**
* This method will remove all entries from the map with keys in this list.
* @param data the row data to remove states for
*/
public void removeStates(List data) {
Set keys = map.keySet();
keys.removeAll(data);
}
/**
* This method will remove all entries from the map but those with keys in this list.
* @param data the row data list to keep states for
*/
public void filterStates(List data) {
Set keys = map.keySet();
keys.retainAll(data);
}
/**
* This method will remove all entries from the map but those with keys in this data model.
* @param model The data model to keep states for
*/
public void filterStates(DataModel model) {
Set keys = map.keySet();
ArrayList rowDataList = new ArrayList
