Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
  package org.gawst.asyncdb;
  
  import  android.content.ContentValues;
  
  import java.util.List;

a basic helper class to keep the content of a flat database in an List

Parameters:
<E> the type of items stored in memory by the InMemoryDbList
<L> the type of in memory storage that will be used
Author(s):
Steve Lhomme
 
 public abstract class InMemoryDbList<E, L extends List<E>, INSERT_ID> extends AsynchronousDbHelper<E, INSERT_ID> implements AsynchronousDbErrorHandler<E>/*, List<E>*/ {
 

Parameters:
db The already created android.database.sqlite.SQLiteOpenHelper to use as storage
name Database name for logs
logger The org.gawst.asyncdb.Logger to use for all logs (can be null for the default Android logs)
initCookie Cookie to pass to AsynchronousDbHelper.preloadInit(Object)
 
 	protected InMemoryDbList(DataSource<E, INSERT_ID> dbString nameLogger loggerObject initCookie) {
 		super(dbnameloggerinitCookie);
 		super.setDbErrorHandler(this);
 	}

return the object used to the in-memory elements

Returns:
 
 	abstract protected L getList();
 
 	protected void onDataCleared() {}
 
 	public void setDbErrorHandler(AsynchronousDbErrorHandler<E> listener) {
 		if (listener==null)
 			 = null;
 		else
 	}
 
 	public final void addItemInMemory(E item) {
 		getList().add(item);
 	}

add a new element in memory (synchronous) and in the database (asynchronous)

Parameters:
item to add
 
 	public boolean add(E item) {
 		if (!getList().contains(item)) {
 			if (getList().add(item)) {
 				return true;
 			}
 		}
 		return false;
 	}

add new elements in memory (synchronous) and in the database (asynchronous)

Parameters:
items to add
 
 	public boolean addAll(Collection<? extends E> items) {
 		if (getList().addAll(items)) {
 			return true;
 		}
 		return false;
 	}

remove and item from memory (synchronous) and from the database (asynchronous)

Parameters:
item
Returns:
true if the element was removed
 
 	public boolean remove(E item) {
 		if (!getList().remove(item))
 			return false;
 
 		return true;
 	}
 
 	public boolean remove(int index) {
 		if (index < 0 || index >= getList().size())
 			return false;
 		E removedItem = getList().remove(index);
 		if (removedItem==null)
 			return false;
 
 		scheduleRemoveOperation(removedItem);
 		return true;
	}
	public E get(int position) {
		if (position >= getList().size())
			return null;
		return getList().get(position);
	}
	public E findItem(E similar) {
		int found = getList().indexOf(similar);
		if (found<0)
			return null;
		return getList().get(found);
	}
	public int indexOf(E similar) {
		return getList().indexOf(similar);
	}
	public void notifyItemChanged(E item) {
		int itemPos = getList().indexOf(item);
		if (itemPos>=0) {
			getList().set(itemPositem);
		}
	}
	protected void clearDataInMemory() {
	}
	public boolean replace(int index, E newData) {
		if (index < 0 || index >= getList().size())
			return false;
prevValue = getList().get(index); 
		getList().set(indexnewData);
		scheduleReplaceOperation(prevValuenewData);
		return true;
	}
	public boolean swap(int positionAint positionB) {
		if (positionA < 0 || positionA >= getList().size())
			return false;
		if (positionB < 0 || positionB >= getList().size())
			return false;
aa = getList().get(positionA);
bb = getList().get(positionB);
		getList().set(positionBaa);
		getList().set(positionAbb);
		return true;
	}
	public void onAddItemFailed(AsynchronousDbHelper<E, ?> db, E item, ContentValues valuesThrowable cause) {
		// revert the failed change in memory
		remove(item);
		if (!=null) {
			final AsynchronousDbErrorHandler<E> listener = .get();
			if (listener==null)
				 = null;
			else if (listener != this)
				listener.onAddItemFailed(dbitemvaluescause);
		}
	}
	public void onRemoveItemFailed(AsynchronousDbHelper<E, ?> db, E itemThrowable cause) {
		// revert the failed change in memory
		add(item);
		if (!=null) {
			final AsynchronousDbErrorHandler<E> listener = .get();
			if (listener==null)
				 = null;
			else if (listener != this)
				listener.onRemoveItemFailed(dbitemcause);
		}
	}
	public void onUpdateItemFailed(AsynchronousDbHelper<E, ?> db, E itemThrowable cause) {
		if (!=null) {
			final AsynchronousDbErrorHandler<E> listener = .get();
			if (listener==null)
				 = null;
			else if (listener != this)
				listener.onUpdateItemFailed(dbitemcause);
		}
	}
	public void onReplaceItemFailed(AsynchronousDbHelper<E, ?> db, E original, E replacementThrowable cause) {
		// revert the failed change in memory
		int prevIndex = getList().indexOf(replacement); // TODO: we may store the position somewhere
		if (prevIndex>=0)
			getList().set(prevIndexoriginal);
		if (!=null) {
			final AsynchronousDbErrorHandler<E> listener = .get();
			if (listener==null)
				 = null;
			else if (listener != this)
				listener.onReplaceItemFailed(dboriginalreplacementcause);
		}
	}
	public void onCorruption(AsynchronousDbHelper<E, ?> db) {
		if (!=null) {
			final AsynchronousDbErrorHandler<E> listener = .get();
			if (listener==null)
				 = null;
			else if (listener != this)
				listener.onCorruption(db);
		}
	}
New to GrepCode? Check out our FAQ X