AbstractPersistenceManager.java

package siena;

import java.util.HashMap;
import java.util.List;
import java.util.Map;

import siena.core.BaseMany;
import siena.core.BaseOne;
import siena.core.Many4PM;
import siena.core.One4PM;
import siena.core.SienaIterablePerPage;
import siena.core.batch.BaseBatch;
import siena.core.batch.Batch;
import siena.core.options.PmOption;
import siena.core.options.PmOptionStickiness;
import siena.core.options.QueryOption;
import siena.core.options.QueryOptionFetchType;
import siena.core.options.QueryOptionOffset;
import siena.core.options.QueryOptionState;

public abstract class AbstractPersistenceManager implements PersistenceManager {
	protected ThreadLocal<Map<Integer, PmOption>> options = new ThreadLocal<Map<Integer, PmOption>>();
	protected Map<Integer, PmOption> optionsSticky = new HashMap<Integer, PmOption>();
	
	public <T> Query<T> createQuery(Class<T> clazz) {
		return new BaseQuery<T>(this, clazz);
	}
	
	public <T> Query<T> createQuery(BaseQueryData<T> data) {
		return new BaseQuery<T>(this, data);
	}

	public <T> Batch<T> createBatch(Class<T> clazz) {
		return new BaseBatch<T>(this, clazz);
	}

	public PersistenceManager option(PmOption opt)
	{
		return option(opt, PmOptionStickiness.STICKY);
	}
	
    public PersistenceManager option(PmOption opt, PmOptionStickiness stick) {
        Map<Integer, PmOption> map = optionsSticky;
        
        if (PmOptionStickiness.NOT_STICKY.equals(stick))
        {
		    map = options.get(); 
		    if(map == null){
			    map = new HashMap<Integer, PmOption>();
			    options.set(map);
		     }
		}
		map.put(opt.type, opt);
		
		return this;
	}
	
	public PmOption option(int type){
		return options().get(type);
	}
	
	public Map<Integer, PmOption> options() {
		Map<Integer, PmOption> res = new HashMap<Integer, PmOption>();
		res.putAll(optionsSticky);
		if (options.get() != null)
		{
			res.putAll(options.get());
		}
		return res;
	}

	public void resetOptions(PmOptionStickiness stick) {
		if (PmOptionStickiness.NOT_STICKY.equals(stick))
        {
        	options.remove();
        }
        else
        {
            optionsSticky.clear();
        }
	}

	public void resetOptions()
	{
		resetOptions(PmOptionStickiness.STICKY);
	}

	public <T> Many4PM<T> createMany(Class<T> clazz) {
		return new BaseMany<T>(this, clazz);
	}
	
	public <T> One4PM<T> createOne(Class<T> clazz) {
		return new BaseOne<T>(this, clazz);
	}	
	
	public <T> T get(Query<T> query) {
		List<T> list = fetch(query, 1);
		if(list.isEmpty()) { return null; }
		return list.get(0);
	}

	public <T> void release(Query<T> query) {
		QueryOptionOffset offset = (QueryOptionOffset)query.option(QueryOptionOffset.ID);
		QueryOption state = query.option(QueryOptionState.ID);
		
		// resets offset
		if(offset.isActive()) 
			offset.offset=0;
		// disables reusable and cludge
		if(state.isActive()){
			state.passivate();
		}
	}

	public <T> Iterable<T> iterPerPage(Query<T> query, int pageSize) {
		((QueryOptionFetchType)query.option(QueryOptionFetchType.ID)).fetchType=QueryOptionFetchType.Type.ITER_PER_PAGE;
		return new SienaIterablePerPage<T>(query, pageSize);
	}

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