PersistenceManagerLifeCycleWrapper.java

package siena.core;

import java.util.List;
import java.util.Map;
import java.util.Properties;

import siena.BaseQueryData;
import siena.ClassInfo;
import siena.PersistenceManager;
import siena.Query;
import siena.core.async.PersistenceManagerAsync;
import siena.core.batch.Batch;
import siena.core.lifecycle.LifeCyclePhase;
import siena.core.lifecycle.LifeCycleUtils;
import siena.core.options.PmOption;

public class PersistenceManagerLifeCycleWrapper implements PersistenceManager{
	PersistenceManager pm;
	
	public PersistenceManagerLifeCycleWrapper(PersistenceManager pm){
		this.pm = pm;
	}

	@Override
	public void init(Properties p) {
		pm.init(p);
	}

	@Override
	public PersistenceManager option(PmOption opt) {
		return pm.option(opt);
	}

	@Override
	public PmOption option(int type) {
		return pm.option(type);
	}

	@Override
	public Map<Integer, PmOption> options() {
		return pm.options();
	}

	@Override
	public void resetOptions() {
		pm.resetOptions();
	}

	@Override
	public <T> Query<T> createQuery(Class<T> clazz) {
		return pm.createQuery(clazz);
	}

	@Override
	public <T> Query<T> createQuery(BaseQueryData<T> query) {
		return pm.createQuery(query);
	}

	@Override
	public <T> Batch<T> createBatch(Class<T> clazz) {
		return pm.createBatch(clazz);
	}
	
	@Override
	public <T> Many4PM<T> createMany(Class<T> clazz) {
		return pm.createMany(clazz);
	}
	
	@Override
	public <T> One4PM<T> createOne(Class<T> clazz) {
		return pm.createOne(clazz);
	}

	@Override
	public void get(Object obj) {
		ClassInfo ci = ClassInfo.getClassInfo(obj.getClass());
		LifeCycleUtils.executeMethods(LifeCyclePhase.PRE_FETCH, ci, obj);
		pm.get(obj);
		LifeCycleUtils.executeMethods(LifeCyclePhase.POST_FETCH, ci, obj);
	}

	@Override
	public void insert(Object obj) {
		ClassInfo ci = ClassInfo.getClassInfo(obj.getClass());
		LifeCycleUtils.executeMethods(LifeCyclePhase.PRE_INSERT, ci, obj);
		pm.insert(obj);
		LifeCycleUtils.executeMethods(LifeCyclePhase.POST_INSERT, ci, obj);
	}

	@Override
	public void delete(Object obj) {
		ClassInfo ci = ClassInfo.getClassInfo(obj.getClass());
		LifeCycleUtils.executeMethods(LifeCyclePhase.PRE_DELETE, ci, obj);
		pm.delete(obj);
		LifeCycleUtils.executeMethods(LifeCyclePhase.POST_DELETE, ci, obj);
	}

	@Override
	public void update(Object obj) {
		ClassInfo ci = ClassInfo.getClassInfo(obj.getClass());
		LifeCycleUtils.executeMethods(LifeCyclePhase.PRE_UPDATE, ci, obj);
		pm.update(obj);
		LifeCycleUtils.executeMethods(LifeCyclePhase.POST_UPDATE, ci, obj);
	}

	@Override
	public void save(Object obj) {
		ClassInfo ci = ClassInfo.getClassInfo(obj.getClass());
		LifeCycleUtils.executeMethods(LifeCyclePhase.PRE_SAVE, ci, obj);
		pm.save(obj);
		LifeCycleUtils.executeMethods(LifeCyclePhase.POST_SAVE, ci, obj);
	}

	@Override
	public <T> T get(Query<T> query) {
		ClassInfo ci = ClassInfo.getClassInfo(query.getQueriedClass());
		T obj = pm.get(query);
		LifeCycleUtils.executeMethods(LifeCyclePhase.POST_FETCH, ci, obj);
		return obj;
	}

	@Override
	public <T> int delete(Query<T> query) {
		return pm.delete(query);
	}

	@Override
	public <T> int update(Query<T> query, Map<String, ?> fieldValues) {
		return pm.update(query, fieldValues);
	}

	@Override
	public <T> int count(Query<T> query) {
		return pm.count(query);
	}

	@Override
	public <T> List<T> fetch(Query<T> query) {
		return pm.fetch(query);
	}

	@Override
	public <T> List<T> fetch(Query<T> query, int limit) {
		return pm.fetch(query, limit);
	}

	@Override
	public <T> List<T> fetch(Query<T> query, int limit, Object offset) {
		return pm.fetch(query, limit, offset);
	}

	@Override
	public <T> List<T> fetchKeys(Query<T> query) {
		return pm.fetchKeys(query);
	}

	@Override
	public <T> List<T> fetchKeys(Query<T> query, int limit) {
		return pm.fetchKeys(query, limit);
	}

	@Override
	public <T> List<T> fetchKeys(Query<T> query, int limit, Object offset) {
		return pm.fetchKeys(query, limit, offset);
	}

	@Override
	public <T> Iterable<T> iter(Query<T> query) {
		return pm.iter(query);
	}

	@Override
	public <T> Iterable<T> iter(Query<T> query, int limit) {
		return pm.iter(query, limit);
	}

	@Override
	public <T> Iterable<T> iter(Query<T> query, int limit, Object offset) {
		return pm.iter(query, limit, offset);
	}

	@Override
	public <T> Iterable<T> iterPerPage(Query<T> query, int pageSize) {
		return pm.iterPerPage(query, pageSize);
	}

	@Override
	public int save(Object... objects) {
		return pm.save(objects);
	}

	@Override
	public int save(Iterable<?> objects) {
		return pm.save(objects);
	}

	@Override
	public int insert(Object... objects) {
		return pm.insert(objects);
	}

	@Override
	public int insert(Iterable<?> objects) {
		return pm.insert(objects);
	}

	@Override
	public int delete(Object... models) {
		return pm.delete(models);
	}

	@Override
	public int delete(Iterable<?> models) {
		return pm.delete(models);
	}

	@Override
	public <T> int deleteByKeys(Class<T> clazz, Object... keys) {
		return pm.deleteByKeys(clazz, keys);
	}

	@Override
	public <T> int deleteByKeys(Class<T> clazz, Iterable<?> keys) {
		return pm.deleteByKeys(clazz, keys);
	}

	@Override
	public int get(Object... models) {
		return pm.get(models);
	}

	@Override
	public <T> int get(Iterable<T> models) {
		return pm.get(models);
	}

	@Override
	public <T> T getByKey(Class<T> clazz, Object key) {
		return pm.getByKey(clazz, key);
	}

	@Override
	public <T> List<T> getByKeys(Class<T> clazz, Object... keys) {
		return pm.getByKeys(clazz, keys);
	}

	@Override
	public <T> List<T> getByKeys(Class<T> clazz, Iterable<?> keys) {
		return pm.getByKeys(clazz, keys);
	}

	@Override
	public <T> int update(Object... models) {
		return pm.update(models);
	}

	@Override
	public <T> int update(Iterable<T> models) {
		return pm.update(models);
	}

	@Override
	public void beginTransaction(int isolationLevel) {
		pm.beginTransaction(isolationLevel);
	}

	@Override
	public void beginTransaction() {
		pm.beginTransaction();
	}
	
	@Override
	public void commitTransaction() {
		pm.commitTransaction();
	}

	@Override
	public void rollbackTransaction() {
		pm.rollbackTransaction();
	}

	@Override
	public void closeConnection() {
		pm.closeConnection();
	}
	
	@Override
	public <T> void release(Query<T> query) {
		pm.release(query);
	}

	@Override
	public <T> void paginate(Query<T> query) {
		pm.paginate(query);
	}

	@Override
	public <T> void nextPage(Query<T> query) {
		pm.nextPage(query);
	}

	@Override
	public <T> void previousPage(Query<T> query) {
		pm.previousPage(query);
	}

	@Override
	public <T> PersistenceManagerAsync async() {
		return pm.async();
	}

	@Override
	public String[] supportedOperators() {
		return pm.supportedOperators();
	}

	@Deprecated
	@Override
	public <T> int count(Query<T> query, int limit) {
		return pm.count(query, limit);
	}

	@Deprecated
	@Override	
	public <T> int count(Query<T> query, int limit, Object offset) {
		return pm.count(query, limit, offset);
	}
	
	
}