How to use

FunctionList

in

ca.odell.glazedlists

/**
 * Adapts the given <code>source</code> to the PieDataset interface. The
 * given <code>keyFunction</code> is then applied to each element of the
 * <code>source</code> to produce the unique key for the element and the
 * given <code>valueFunction</code> is applied to produce the value for an
 * element.
 *
 * <p>This constructor should be used when the elements in
 * <code>source</code> do not need to be grouped together in order to
 * represent pie data.
 *
 * @param source the {@link EventList} containing the data to chart
 * @param keyFunction produces the keys of the source elements in the pie chart
 * @param valueFunction produces the values of the source elements in the pie chart
 */
public EventListPieDataset(EventList<E> source, FunctionList.Function<E, Comparable<K>> keyFunction, FunctionList.Function<E, Number> valueFunction) {
  this.groupingList = null;
  this.sourceList = source;
  this.keyList = new FunctionList(source, keyFunction);
  this.valueList = new FunctionList(source, valueFunction);
  source.addListEventListener(this.datasetEventListener);
}

/** {@inheritDoc} */
public void dispose() {
  valueList.removeListEventListener(this);
  valueList.dispose();
  groupingList.dispose();
  keySet = null;
  entrySet = null;
  keyList.clear();
  delegate.clear();
}

/**
 * Returns the key of the value at the given <code>index</code>.
 *
 * @param index the item index (zero-based)
 * @return the key
 *
 * @throws IndexOutOfBoundsException if <code>index</code> is out of bounds
 */
@Override
public Comparable getKey(int index) {
  return this.keyList.get(index);
}

/** {@inheritDoc} */
@Override
public E set(int index, E value) {
  final E updated = get(index);
  source.set(index, reverse(value));
  return updated;
}

this.valueList = new FunctionList<List<V>, List<V>>(this.groupingList, new ValueListFunction());
this.valueList.addListEventListener(this);
for (Iterator<List<V>> i = this.valueList.iterator(); i.hasNext();) {
  final List<V> value = i.next();
  final K key = key(value);

/**
 * Construct a {@link FunctionList} which stores the result of transforming
 * each source element using the given forward {@link Function}. If the
 * reverse {@link Function} is not null, {@link #add(Object)},
 * {@link #add(int, Object)} and {@link #set(int, Object)} will execute
 * as expected.
 *
 * <p> Note: an {@link AdvancedFunction} can be specified for the forward
 * {@link Function} which allows the implementor a chance to examine the
 * prior value that was mapped to a source element when it must be remapped
 * due to a modification (from a call to {@link List#set}).
 *
 * @param source the EventList to decorate with a function transformation
 * @param forward the function to execute on each source element
 * @param reverse the function to map elements of FunctionList back to
 *      element values in the source list
 */
public FunctionList(EventList<S> source, Function<S,E> forward, Function<E,S> reverse) {
  super(source);
  updateForwardFunction(forward);
  setReverseFunction(reverse);
  // save a reference to the source elements
  this.sourceElements = new ArrayList<S>(source);
  // map all of the elements within source
  this.mappedElements = new ArrayList<E>(source.size());
  for (int i = 0, n = source.size(); i < n; i++) {
    this.mappedElements.add(forward(source.get(i)));
  }
  source.addListEventListener(this);
}

  @Override
  public void dispose() {
    summarized3.dispose();
    grouped3.dispose();
    summarized2.dispose();
    grouped2.dispose();
    summarized1.dispose();
    grouped1.dispose();
  }
};

/**
 * Changes the {@link Function} that evaluates source elements to produce
 * mapped elements. Calling this method with a different
 * <code>forward</code> Function will cause all elements in this
 * FunctionList to be reevaluated.
 *
 * <p>Callers of this method typically also want to update the reverse
 * function using {@link #setReverseFunction} if one exists.
 */
public void setForwardFunction(Function<S,E> forward) {
  updateForwardFunction(forward);
  updates.beginEvent(true);
  // remap all of the elements within source
  for (int i = 0, n = source.size(); i < n; i++) {
    final E oldValue = this.mappedElements.set(i, forward(source.get(i)));
    updates.elementUpdated(i, oldValue);
  }
  updates.commitEvent();
}

final E newValueTransformed = forward(newValue);
sourceElements.add(changeIndex, newValue);
mappedElements.add(changeIndex, newValueTransformed);
final E oldValueTransformed = get(changeIndex);
final S newValue = source.get(changeIndex);
final E newValueTransformed = forward(oldValueTransformed, newValue);
sourceElements.set(changeIndex, newValue);
mappedElements.set(changeIndex, newValueTransformed);

/**
 * Returns the index for a given key.
 *
 * @param key the key
 * @return the index, or <code>-1</code> if the key is unrecognised
 */
public int getIndex(Comparable key) {
  return this.keyList.indexOf(key);
}

/** {@inheritDoc} */
@Override
public void add(int index, E value) {
  source.add(index, reverse(value));
}

this.valueList = new FunctionList<List<V>, List<V>>(this.groupingList, new ValueListFunction());
this.valueList.addListEventListener(this);
for (Iterator<List<V>> i = this.valueList.iterator(); i.hasNext();) {
  final List<V> value = i.next();
  final K key = key(value);

/**
 * Construct a {@link FunctionList} which stores the result of transforming
 * each source element using the given forward {@link Function}. If the
 * reverse {@link Function} is not null, {@link #add(Object)},
 * {@link #add(int, Object)} and {@link #set(int, Object)} will execute
 * as expected.
 *
 * <p> Note: an {@link AdvancedFunction} can be specified for the forward
 * {@link Function} which allows the implementor a chance to examine the
 * prior value that was mapped to a source element when it must be remapped
 * due to a modification (from a call to {@link List#set}).
 *
 * @param source the EventList to decorate with a function transformation
 * @param forward the function to execute on each source element
 * @param reverse the function to map elements of FunctionList back to
 *      element values in the source list
 */
public FunctionList(EventList<S> source, Function<S,E> forward, Function<E,S> reverse) {
  super(source);
  updateForwardFunction(forward);
  setReverseFunction(reverse);
  // save a reference to the source elements
  this.sourceElements = new ArrayList<S>(source);
  // map all of the elements within source
  this.mappedElements = new ArrayList<E>(source.size());
  for (int i = 0, n = source.size(); i < n; i++) {
    this.mappedElements.add(forward(source.get(i)));
  }
  source.addListEventListener(this);
}

  public void dispose() {
    if(sortedList != null) {
      sortedList.dispose();
    }
    sourceNodes.dispose();
  }
}

/** {@inheritDoc} */
@Override
public E set(int index, E value) {
  final E updated = get(index);
  source.set(index, reverse(value));
  return updated;
}

/**
 * Changes the {@link Function} that evaluates source elements to produce
 * mapped elements. Calling this method with a different
 * <code>forward</code> Function will cause all elements in this
 * FunctionList to be reevaluated.
 *
 * <p>Callers of this method typically also want to update the reverse
 * function using {@link #setReverseFunction} if one exists.
 */
public void setForwardFunction(Function<S,E> forward) {
  updateForwardFunction(forward);
  updates.beginEvent(true);
  // remap all of the elements within source
  for (int i = 0, n = source.size(); i < n; i++) {
    final E oldValue = this.mappedElements.set(i, forward(source.get(i)));
    updates.elementUpdated(i, oldValue);
  }
  updates.commitEvent();
}

final E newValueTransformed = forward(newValue);
sourceElements.add(changeIndex, newValue);
mappedElements.add(changeIndex, newValueTransformed);
final E oldValueTransformed = get(changeIndex);
final S newValue = source.get(changeIndex);
final E newValueTransformed = forward(oldValueTransformed, newValue);
sourceElements.set(changeIndex, newValue);
mappedElements.set(changeIndex, newValueTransformed);

/**
 * Returns the index for a given key.
 *
 * @param key the key
 * @return the index, or <code>-1</code> if the key is unrecognised
 */
public int getIndex(Comparable key) {
  return this.keyList.indexOf(key);
}

/** {@inheritDoc} */
@Override
public void add(int index, E value) {
  source.add(index, reverse(value));
}

/**
 * Adapts the given <code>source</code> to the PieDataset interface. The
 * given <code>keyFunction</code> is then applied to each element of the
 * <code>source</code> to produce the unique key for the element and the
 * given <code>valueFunction</code> is applied to produce the value for an
 * element.
 *
 * <p>This constructor should be used when the elements in
 * <code>source</code> do not need to be grouped together in order to
 * represent pie data.
 *
 * @param source the {@link EventList} containing the data to chart
 * @param keyFunction produces the keys of the source elements in the pie chart
 * @param valueFunction produces the values of the source elements in the pie chart
 */
public EventListPieDataset(EventList<E> source, FunctionList.Function<E, Comparable<K>> keyFunction, FunctionList.Function<E, Number> valueFunction) {
  this.groupingList = null;
  this.sourceList = source;
  this.keyList = new FunctionList(source, keyFunction);
  this.valueList = new FunctionList(source, valueFunction);
  source.addListEventListener(this.datasetEventListener);
}