/** * 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); }
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); }
/** * 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(); } }
/** * 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); }