/*
* Copyright 2010 Google Inc.
*
* 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 com.google.gwt.view.client;
import com.google.gwt.core.client.Scheduler;
import com.google.gwt.core.client.Scheduler.ScheduledCommand;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;
import java.util.List;
import java.util.ListIterator;
import java.util.NoSuchElementException;
/**
* A concrete subclass of {@link AbstractDataProvider} that is backed by an
* in-memory list.
*
* <p>
* <h3>Example</h3>
* {@example com.google.gwt.examples.view.ListDataProviderExample}
* </p>
*
* @param <T> the data type of the list
*/
public class ListDataProvider<T> extends AbstractDataProvider<T> {
/**
* A wrapper around a list that updates the model on any change.
*/
private class ListWrapper implements List<T> {
/**
* A wrapped ListIterator.
*/
private final class WrappedListIterator implements ListIterator<T> {
/**
* The error message when {@link #add(Object)} or {@link #remove()} is
* called more than once per call to {@link #next()} or
* {@link #previous()}.
*/
private static final String IMPERMEABLE_EXCEPTION =
"Cannot call add/remove more than once per call to next/previous.";
/**
* The index of the object that will be returned by {@link #next()}.
*/
private int i = 0;
/**
* The index of the last object accessed through {@link #next()} or
* {@link #previous()}.
*/
private int last = -1;
private WrappedListIterator() {
}
private WrappedListIterator(int start) {
int size = ListWrapper.this.size();
if (start < 0 || start > size) {
throw new IndexOutOfBoundsException(
"Index: " + start + ", Size: " + size);
}
i = start;
}
public void add(T o) {
if (last < 0) {
throw new IllegalStateException(IMPERMEABLE_EXCEPTION);
}
ListWrapper.this.add(i++, o);
last = -1;
}
public boolean hasNext() {
return i < ListWrapper.this.size();
}
public boolean hasPrevious() {
return i > 0;
}
public T next() {
if (!hasNext()) {
throw new NoSuchElementException();
}
return ListWrapper.this.get(last = i++);
}
public int nextIndex() {
return i;
}
public T previous() {
if (!hasPrevious()) {
throw new NoSuchElementException();
}
return ListWrapper.this.get(last = --i);
}
public int previousIndex() {
return i - 1;
}
public void remove() {
if (last < 0) {
throw new IllegalStateException(IMPERMEABLE_EXCEPTION);
}
ListWrapper.this.remove(last);
i = last;
last = -1;
}
public void set(T o) {
if (last == -1) {
throw new IllegalStateException();
}
ListWrapper.this.set(last, o);
}
}
/**
* The current size of the list.
*/
private int curSize = 0;
/**
* The delegate wrapper.
*/
private final ListWrapper delegate;
/**
* Set to true if the pending flush has been canceled.
*/
private boolean flushCancelled;
/**
* We wait until the end of the current event loop before flushing changes
* so that we don't spam the displays. This also allows users to clear and
* replace all of the data without forcing the display back to page 0.
*/
private ScheduledCommand flushCommand = new ScheduledCommand() {
public void execute() {
flushPending = false;
if (flushCancelled) {
flushCancelled = false;
return;
}
flushNow();
}
};
/**
* Set to true if a flush is pending.
*/
private boolean flushPending;
/**
* The list that backs the wrapper.
*/
private List<T> list;
/**
* If this is a sublist, the offset it the index relative to the main list.
*/
private final int offset;
/**
* If modified is true, the smallest modified index.
*/
private int maxModified = Integer.MIN_VALUE;
/**
* If modified is true, one past the largest modified index.
*/
private int minModified = Integer.MAX_VALUE;
/**
* True if the list data has been modified.
*/
private boolean modified;
public ListWrapper(List<T> list) {
this(list, null, 0);
// Initialize the data size based on the size of the input list.
updateRowCount(list.size(), true);
}
/**
* Construct a new {@link ListWrapper} that delegates flush calls to the
* specified delegate.
*
* @param list the list to wrap
* @param delegate the delegate
* @param offset the offset of this list
*/
private ListWrapper(List<T> list, ListWrapper delegate, int offset) {
this.list = list;
this.delegate = delegate;
this.offset = offset;
}
public void add(int index, T element) {
try {
list.add(index, element);
minModified = Math.min(minModified, index);
maxModified = size();
modified = true;
flush();
} catch (IndexOutOfBoundsException e) {
throw new IndexOutOfBoundsException(e.getMessage());
}
}
public boolean add(T e) {
boolean toRet = list.add(e);
minModified = Math.min(minModified, size() - 1);
maxModified = size();
modified = true;
flush();
return toRet;
}
public boolean addAll(Collection<? extends T> c) {
minModified = Math.min(minModified, size());
boolean toRet = list.addAll(c);
maxModified = size();
modified = true;
flush();
return toRet;
}
public boolean addAll(int index, Collection<? extends T> c) {
try {
boolean toRet = list.addAll(index, c);
minModified = Math.min(minModified, index);
maxModified = size();
modified = true;
flush();
return toRet;
} catch (IndexOutOfBoundsException e) {
throw new IndexOutOfBoundsException(e.getMessage());
}
}
public void clear() {
list.clear();
minModified = maxModified = 0;
modified = true;
flush();
}
public boolean contains(Object o) {
return list.contains(o);
}
public boolean containsAll(Collection<?> c) {
return list.containsAll(c);
}
@Override
public boolean equals(Object o) {
return list.equals(o);
}
public T get(int index) {
return list.get(index);
}
@Override
public int hashCode() {
return list.hashCode();
}
public int indexOf(Object o) {
return list.indexOf(o);
}
public boolean isEmpty() {
return list.isEmpty();
}
public Iterator<T> iterator() {
return listIterator();
}
public int lastIndexOf(Object o) {
return list.lastIndexOf(o);
}
public ListIterator<T> listIterator() {
return new WrappedListIterator();
}
public ListIterator<T> listIterator(int index) {
return new WrappedListIterator(index);
}
public T remove(int index) {
try {
T toRet = list.remove(index);
minModified = Math.min(minModified, index);
maxModified = size();
modified = true;
flush();
return toRet;
} catch (IndexOutOfBoundsException e) {
throw new IndexOutOfBoundsException(e.getMessage());
}
}
public boolean remove(Object o) {
int index = indexOf(o);
if (index == -1) {
return false;
}
remove(index);
return true;
}
public boolean removeAll(Collection<?> c) {
boolean toRet = list.removeAll(c);
minModified = 0;
maxModified = size();
modified = true;
flush();
return toRet;
}
public boolean retainAll(Collection<?> c) {
boolean toRet = list.retainAll(c);
minModified = 0;
maxModified = size();
modified = true;
flush();
return toRet;
}
public T set(int index, T element) {
T toRet = list.set(index, element);
minModified = Math.min(minModified, index);
maxModified = Math.max(maxModified, index + 1);
modified = true;
flush();
return toRet;
}
public int size() {
return list.size();
}
public List<T> subList(int fromIndex, int toIndex) {
return new ListWrapper(list.subList(fromIndex, toIndex), this, fromIndex);
}
public Object[] toArray() {
return list.toArray();
}
public <C> C[] toArray(C[] a) {
return list.toArray(a);
}
/**
* Flush the data to the model.
*/
private void flush() {
// Defer to the delegate.
if (delegate != null) {
delegate.minModified = Math.min(
minModified + offset, delegate.minModified);
delegate.maxModified = Math.max(
maxModified + offset, delegate.maxModified);
delegate.modified = modified || delegate.modified;
delegate.flush();
return;
}
flushCancelled = false;
if (!flushPending) {
flushPending = true;
Scheduler.get().scheduleFinally(flushCommand);
}
}
/**
* Flush pending list changes to the displays. By default,
*/
private void flushNow() {
// Cancel any pending flush command.
if (flushPending) {
flushCancelled = true;
}
// Early exit if this list has been replaced in the data provider.
if (listWrapper != this) {
return;
}
int newSize = list.size();
if (curSize != newSize) {
curSize = newSize;
updateRowCount(curSize, true);
}
if (modified) {
updateRowData(minModified, list.subList(minModified, maxModified));
modified = false;
}
minModified = Integer.MAX_VALUE;
maxModified = Integer.MIN_VALUE;
}
}
/**
* The wrapper around the actual list.
*/
private ListWrapper listWrapper;
/**
* Creates an empty model.
*/
public ListDataProvider() {
this(new ArrayList<T>(), null);
}
/**
* Creates a list model that wraps the given list. Changes to the
* wrapped list must be made via this model in order to be correctly applied
* to displays.
*
* @param listToWrap the List to be wrapped
*/
public ListDataProvider(List<T> listToWrap) {
this(listToWrap, null);
}
/**
* Creates an empty list model that wraps the given collection.
*
* @param keyProvider an instance of ProvidesKey<T>, or null if the record
* object should act as its own key
*/
public ListDataProvider(ProvidesKey<T> keyProvider) {
this(new ArrayList<T>(), keyProvider);
}
/**
* Creates a list model that wraps the given list. Changes to the
* wrapped list must be made via this model in order to be correctly applied
* to displays.
*
* @param listToWrap the List to be wrapped
* @param keyProvider an instance of ProvidesKey<T>, or null if the record
* object should act as its own key
*/
public ListDataProvider(List<T> listToWrap, ProvidesKey<T> keyProvider) {
super(keyProvider);
listWrapper = new ListWrapper(listToWrap);
}
/**
* Flush pending list changes to the displays. By default, displays are
* informed of modifications to the underlying list at the end of the current
* event loop, which makes it possible to perform multiple operations
* synchronously without repeatedly refreshing the displays. This method can
* be called to flush the changes immediately instead of waiting until the end
* of the current event loop.
*/
public void flush() {
listWrapper.flushNow();
}
/**
* Get the list that backs this model. Changes to the list will be reflected
* in the model.
*
* @return the list
*
* @see #setList(List)
*/
public List<T> getList() {
return listWrapper;
}
/**
* Refresh all of the displays listening to this adapter.
*/
public void refresh() {
updateRowData(0, listWrapper);
}
/**
* Replace this model's list.
*
* @param listToWrap the model's new list
*
* @see #getList()
*/
public void setList(List<T> listToWrap) {
listWrapper = new ListWrapper(listToWrap);
listWrapper.minModified = 0;
listWrapper.maxModified = listWrapper.size();
listWrapper.modified = true;
flush();
}
@Override
protected void onRangeChanged(HasData<T> display) {
int size = listWrapper.size();
if (size > 0) {
// Do not push data if the data set is empty.
updateRowData(display, 0, listWrapper);
}
}
}