PersistenceAsync example

A simple persistenceAsync example.

public class PersistenceDaoAsync {

public class PersistenceDaoAsync<T, K> {

private PersistenceAsync persistence;
private Class<T> baseClass;

public PersistenceDaoAsync(Class<T> baseClass) {
    this.baseClass = baseClass;

    persistence = PersistenceUtil.INSTANCE.getPersistenceAsync();

}

public boolean insert(T bean) {
    return persistence.insert(bean);
}

public boolean remove(T bean) {
    return persistence.delete(bean);
}

public boolean removeFromRowKey(K rowKey) {
    return persistence.deleteByKey(rowKey, baseClass);
}

public boolean update(T bean) {
    return persistence.update(bean);
}
public void retrieve(K id, ResultAsyncCallBack<T> resultCallBack) {
    persistence.findByKey(id, baseClass, resultCallBack);
}

public void listAll(ResultAsyncCallBack<List<T>> resultCallBack) {
    persistence.findAll(baseClass, resultCallBack);
}

public void listByIndex(String indexName, Object index,
        ResultAsyncCallBack<List<T>> resultCallBack) {
    persistence.findByIndex(indexName, index, baseClass, resultCallBack);
}

public boolean executeUpdate(String query) {
	return persistence.executeUpdate(query);
}

public void count(ResultAsyncCallBack<Long> resultCallBack) {
    persistence.count(baseClass, resultCallBack);
}

public boolean executeUpdateCql(String string) {
    return persistence.executeUpdate(string);
}
public SelectBuilder<T> select() {
    return persistence.selectBuilder(baseClass);
}
public UpdateBuilder<T> update() {
    return persistence.updateBuilder(baseClass);
}

public InsertBuilder<T> insertBuilder() {
    return persistence.insertBuilder(baseClass);
}
public InsertBuilder<T> insertBuilder(T bean) {
    return persistence.insertBuilder(bean);
}

public DeleteBuilder<T> deleteBuilder(String... columnNames) {
    return persistence.deleteBuilder(baseClass, columnNames);
}

public DeleteBuilder<T> deleteBuilder(Object id, String... columnNames) {
    return persistence.deleteBuilder(baseClass, id, columnNames);
}

public void removeAll() {
    persistence.removeAll(baseClass);
}

public BatchBuilder batchBuilder() {
    return persistence.batchBuilder();
}
public UpdateBuilder<T> update(SimpleID id) {

    return persistence.updateBuilder(baseClass, id);
}

Using on a DAO

public class PersonDAOASyncTest {

private PersistenceDaoAsync<Person, Long> dao = new PersistenceDaoAsync<>(
        Person.class);

public void insert() {

    Person person = getPerson();
    person.setName(NAME);
    person.setId(FOUR);
    person.setYear(YEAR);
    Address address = getAddress();
    person.setAddress(address);
    dao.insert(person);

}

public void retrieve() {
    dao.retrieve(FOUR, new ResultAsyncCallBack<Person>() {
        @Override
        public void result(Person bean) {
            //do some thing

        }

    });

}

public void removeFromRowKey() {
    dao.removeFromRowKey(new Long(2));
}

public void remove() {
    Person person = getPerson();
    person.setId(1L);
    dao.remove(person);
}

public void list() {
    dao.listAll(new ResultAsyncCallBack<List<Person>>() {

        @Override
        public void result(List<Person> beans) {
            //do some thing
        }
    });

}

public void findIndex() {
    dao.listByIndex("name", NAME, new ResultAsyncCallBack<List<Person>>() {

        @Override
        public void result(List<Person> persons) {
            //action

        }
    });
}

public void count() {
    dao.count(new ResultAsyncCallBack<Long>() {

        @Override
        public void result(Long count) {
            //

        }
    });
}
}