ResultContainer.java from ThinkCap Collaborative Knowledge Portal at Krugle

Show ResultContainer.java syntax highlighted

package org.integratedmodelling.thinkcap;

import java.util.ArrayList;
import java.util.Collection;

import org.integratedmodelling.thinklab.KnowledgeManager;
import org.integratedmodelling.thinklab.exception.ThinklabException;
import org.integratedmodelling.thinklab.exception.ThinklabResourceNotFoundException;
import org.integratedmodelling.thinklab.interfaces.IKnowledgeSubject;


/*
 * a simple container for results of a query. Also acts as a container for paging information, 
 * although there's no requirement for the values to represent the specific pages.
 */
public class ResultContainer {
	
	int offset = 0;
	int max = 10;
	int page = 0;
	
	public class Result {
		public IKnowledgeSubject result;
		public double score;
		
		public Result(IKnowledgeSubject result, double d) {
			this.result = result;
			this.score = d;
		}
		
		public IKnowledgeSubject getObject() {
			return result;
		}
		
		public int getScore() {
			return (int) Math.round(score * 100.0);
		}
	}
	
	ArrayList<Result> results = new ArrayList<Result>();
	private int totalResultCount;
	
	public ResultContainer(int offset, int max, int page) {
		this.offset = offset;
		this.max = max;
		this.page = page;
	}

	public ResultContainer() {
		// TODO Auto-generated constructor stub
	}

	public int getPageCount(int resultsPerPage) {
		int np = totalResultCount/resultsPerPage;
		if ((np*resultsPerPage) < totalResultCount)
			np ++;
		return np;
	}
	
	public boolean isPageCurrent(int nPage, int offset, int nResultsPerPage) {
		return ((nPage*nResultsPerPage) >= offset) && (((nPage+1)*nResultsPerPage) < offset);
	}
	
	public int getOffsetForPage(int nPage, int nResultsPerPage) {
		return nPage*nResultsPerPage;
	}
	
	public int getMaxResultPerPage(int nPage, int nResultsPerPage) {
		int ret = nPage*nResultsPerPage;
		if (ret > totalResultCount)
			ret = totalResultCount;
		return ret;
	}

	private String getLinkTemplate(String linkTemplate, int offset, int max, int pageNumber,
			boolean isEllipsis) {

		String ret = linkTemplate.replaceAll("@OFFSET@", new Integer(offset).toString());

		ret = ret.replaceAll("@MAX@", new Integer(max).toString());
		ret = ret.replaceAll("@PAGENUMBER@", new Integer(pageNumber).toString());

		/* FIXME won't work */
		if (isEllipsis) {
			ret = ret.replaceAll("@DISPLAYPAGENUMBER@", "...");
		} else {
			ret = ret.replaceAll("@DISPLAYPAGENUMBER@", new Integer(pageNumber+1).toString());
		}
		return ret;
	}
	
	public String getPageNavigator(int currentPage, String linkTemplate, 
			int maxPagesBeforeEllipsis, int resultsPerPage) {
		
		/* determine where to start */
		int nPages = getPageCount(resultsPerPage);
		int startPage = (currentPage - (currentPage % maxPagesBeforeEllipsis))/maxPagesBeforeEllipsis;

		String ret = "";
		
		if (startPage > 0) {
			/* start with ellipsis text, linked to startPage - 1*/
			ret += getLinkTemplate(linkTemplate, 
					getOffsetForPage(startPage -1, resultsPerPage),
					getMaxResultPerPage(startPage -1, resultsPerPage),
					startPage-1, true);
		}
		
		for (int i = 0; i < Math.min(maxPagesBeforeEllipsis, nPages); i++) {
			int page = startPage + i;
			if (page == currentPage) {
				/* just add page number + 1 */
				ret += (startPage+i+1)+"&nbsp;";
			} else {
				/* add link to page number */
				ret += getLinkTemplate(linkTemplate, 
						getOffsetForPage(startPage+i, resultsPerPage),
						getMaxResultPerPage(startPage+i, resultsPerPage),
						startPage+i, false);
			}
		}
		
		if ((startPage + maxPagesBeforeEllipsis) < nPages) {
			/* add ellipsis linked to startPage + maxPagesBeforeEllipsis + 1 */
			ret += getLinkTemplate(linkTemplate, 
					getOffsetForPage(startPage+maxPagesBeforeEllipsis+1, resultsPerPage),
					getMaxResultPerPage(startPage+maxPagesBeforeEllipsis+1, resultsPerPage),
					startPage + maxPagesBeforeEllipsis + 1, true);
		}
				
		return ret;
		
	}

	
	public void add(IKnowledgeSubject result, double d) {
		results.add(new Result(result, d));
	}

	public void add(String resultID, float score) throws ThinklabException {

		IKnowledgeSubject result = KnowledgeManager.KM().retrieveConcept(resultID);
		if (result == null)
			result = KnowledgeManager.KM().retrieveInstance(resultID);
		
		if (result == null)
			throw new ThinklabResourceNotFoundException("internal: resource " + resultID + " not found in knowledge base");
		
		results.add(new Result(result, score));
	}

	
	public int size() {
		return results.size();
	}
	
	public IKnowledgeSubject getResult(int i) {
		return results.get(i).result;
	}
	
	public int getScore(int i) {
		return (int) Math.round(results.get(i).score * 100.0);
	}
	
	public Collection<Result> getResults() {
		return results;
	}

	public void setTotalResultCount(int ret) {
		totalResultCount = ret;
	}
	
	public int getTotalResultCount() {
		return totalResultCount;
	}
	
}
See more files for this project here