Subversion Repositories SmartDukaan

/**

 * 

 */

package in.shop2020.metamodel.definitions;

import in.shop2020.metamodel.core.Entity;

import in.shop2020.metamodel.core.Feature;

import in.shop2020.metamodel.core.Slide;

import in.shop2020.metamodel.util.ExpandedBullet;

import in.shop2020.metamodel.util.ExpandedEntity;

import in.shop2020.util.DBUtils;

import in.shop2020.util.Utils;

import java.io.Serializable;

import java.util.ArrayList;

import java.util.HashMap;

import java.util.List;

import java.util.Map;

import java.util.TreeMap;

/**

 * Single point access to stored shop2020 core objects

 * 

 * @author naveen

 *

 */

public class EntityContainer implements Serializable {

	/**

	 * 

	 */

	private static final long serialVersionUID = 1L;

	/**

	 * Hashtable of Entity ID to Entity object

	 */

	private Map<Long, Entity> entities;

	/**

	 * Hashtable of Category ID to list of Entity objects

	 */

	private Map<Long, List<Entity>> entitiesbycategory;

	/**

	 * Hashtable of Feature Definition ID to list of learned Bullet objects

	 */

	private Map<Long, List<ExpandedBullet>> learnedBullets;

	/**

	 * Hashtable of Facet Definition ID to list of unique facet values found 

	 * across entities

	 */

	private Map<Long, List<String>> facetDefinitionIDFacetValues;

	/**

	 * Instantiates required data structures only when needed

	 */

	public EntityContainer() {

		// Lazy initialization

	}

	/**

	 * Returns all stored Entity objects 

	 * 

	 * @return Map

	 * @throws Exception 

	 */

	@SuppressWarnings("unchecked")

	public Map<Long, Entity> getEntities() throws Exception {

		// De-serialize

		if(this.entities == null) {

			String entitiesDBFile = Utils.ENTITIES_DB_PATH + "entities.ser";

			String entitiesbycategoryDBFile = Utils.ENTITIES_DB_PATH + 

				"entitiesbycategory.ser";

			this.entities = (Map<Long, Entity>) DBUtils.read(entitiesDBFile);

			this.entitiesbycategory = (Map<Long, List<Entity>>) 

				DBUtils.read(entitiesbycategoryDBFile);

		}

		if(this.entities == null) {

			// A sorted map to ensure sequence

			this.entities = new TreeMap<Long, Entity>();

			this.entitiesbycategory = new TreeMap<Long, List<Entity>>();

		}

		return this.entities;

	}

	/**

	 * Returns hashtable of list bullet objects to feature definition ID

	 * 

	 * @return Map<Long, List<ExpandedBullet>> 

	 * @throws Exception

	 */

	@SuppressWarnings("unchecked")

	public Map<Long, List<ExpandedBullet>> getLearnedBullets() throws Exception{

		// De-serialize

		if(this.learnedBullets == null) {

			String dbFile = Utils.ENTITIES_DB_PATH + "learnedbullets.ser";

			this.learnedBullets = 

				(Map<Long, List<ExpandedBullet>>) DBUtils.read(dbFile);

		}

		if(this.learnedBullets == null) {

			this.learnedBullets = new HashMap<Long, List<ExpandedBullet>>();

		}

		return this.learnedBullets;

	}

	/**

	 * Resolves Feature Definition ID into list of learned Bullet objects

	 * 

	 * @param featureDefinitionID

	 * @return list of ExpandedBullets

	 * @throws Exception

	 */

	public List<ExpandedBullet> getLearnedBullets(long featureDefinitionID) 

		throws Exception {

		if(this.learnedBullets == null) {

			this.getLearnedBullets();

		}

		return this.learnedBullets.get(new Long(featureDefinitionID));

	}

	/** 

	 * Returns hashtable of list entities to category ID

	 * 

	 * @return the entitiesbycategory Entities by category

	 * @throws Exception 

	 */

	public Map<Long, List<Entity>> getEntitiesbyCategory() throws Exception {

		if(this.entities == null) {

			this.getEntities();

		}

		return this.entitiesbycategory;

	}

	/**

	 * Resolves Entity ID into Entity object

	 * 

	 * @param entityID

	 * @return Entity

	 * @throws Exception 

	 */

	public Entity getEntity(long entityID) throws Exception {

		if(this.entities == null) {

			this.getEntities();

		}

		return this.entities.get(new Long(entityID));

	}

	/**

	 * Returns list of entities for a category ID

	 * 

	 * @param categoryID

	 * @return List<Entity>

	 * @throws Exception 

	 */

	public List<Entity> getEntities(long categoryID) throws Exception {

		if(this.entities == null) {

			this.getEntities();

		}

		//Utils.info("this.entitiesbycategory=" + this.entitiesbycategory);

		return this.entitiesbycategory.get(new Long(categoryID));

	}

	/**

	 * Convienience method to add new Entity 

	 * 

	 * @param newEntity

	 * @throws Exception 

	 */

	public void addEntity(Entity newEntity) throws Exception {

		if(this.entities == null) {

			this.getEntities();

		}

		this.entities.put(new Long(newEntity.getID()), newEntity);

		// Keep index by category ID

		List<Entity> catentities = 

			this.entitiesbycategory.get(newEntity.getCategoryID());

		if(catentities == null) {

			catentities = new ArrayList<Entity>();

		}

		catentities.add(newEntity);

		this.entitiesbycategory.put(new Long(newEntity.getCategoryID()), 

				catentities);

	}

	/**

	 * Returns expand form of entity object. All references are resolved into 

	 * corresponding detail object

	 * 

	 * @param entityID

	 * @return ExpandedEntity 

	 * @throws Exception 

	 */

	public ExpandedEntity getExpandedEntity(long entityID) throws Exception {

		Entity entity = this.getEntity(entityID);

		ExpandedEntity expEntity = new ExpandedEntity(entity);

		return expEntity;

	}

	/**

	 * Returns hashtable of list facet values to facet definition ID

	 * 

	 * @return

	 * @throws Exception

	 */

	@SuppressWarnings("unchecked")

	public Map<Long, List<String>> getFacetValues() throws Exception {

		// De-serialize

		if(this.facetDefinitionIDFacetValues == null) {

			String dbFile = Utils.ENTITIES_DB_PATH + "facetvalues.ser";

			this.facetDefinitionIDFacetValues = 

				(Map<Long, List<String>>) DBUtils.read(dbFile);

		}

		if(this.facetDefinitionIDFacetValues == null) {

			this.facetDefinitionIDFacetValues = new HashMap<Long, 

				List<String>>();

		}

		return this.facetDefinitionIDFacetValues;

	}

	/**

	 * Returns list of facet values for a facet definition ID

	 * 

	 * @param facetDefinitionID

	 * @return List<String> 

	 * @throws Exception

	 */

	public List<String> getFacetValues(long facetDefinitionID) 

		throws Exception {

		this.getFacetValues();

		return this.facetDefinitionIDFacetValues.get(

				new Long(facetDefinitionID));

	}

	/**

	 * Utility method to find out Feature object in Entity instance

	 * 

	 * @param entityID

	 * @param featureDefinitionID

	 * @return Feature

	 * @throws Exception 

	 */

	public Feature getFeature(long entityID, long featureDefinitionID) 

		throws Exception {

		Entity entity = this.getEntity(entityID);

		Feature feature = null;

		List<Slide> slides = entity.getSlides();

		for(Slide slide : slides) {

			feature = this.getFeature(slide, featureDefinitionID);

			// Until all slides are searched

			if(feature == null) {

				continue;

			}

			else {

				break;

			}

		}

		return feature;

	}

	/**

	 * 

	 * @param slide

	 * @param featureDefinitionID

	 * @return Feature

	 */

	public Feature getFeature(Slide slide, long featureDefinitionID) {

		List<Feature> features = slide.getFeatures();

		if(features != null) {

			for(Feature feature : features) {

				if(feature.getFeatureDefinitionID() == featureDefinitionID) {

					return feature;

				}

			}

		}

		Feature feature = null;

		List<Slide> childrenSlides = slide.getChildrenSlides();

		if(childrenSlides != null) {

			for(Slide childSlide : childrenSlides) {

				feature = this.getFeature(childSlide, featureDefinitionID);

				if(feature == null) {

					continue;

				}

				else {

					break;

				}

			}

		}

		return feature;

	}

	/**

	 * Utility method to find out Slide object in Entity instance

	 * 

	 * @param entityID

	 * @param slideDefinitionID

	 * @return

	 * @throws Exception 

	 */

	public Slide getSlide(long entityID, long slideDefinitionID) 

		throws Exception {

		Entity entity = this.getEntity(entityID);

		List<Slide> slides = entity.getSlides();

		Slide resultSlide = null;

		if(slides != null) {

			for(Slide slide : slides) {

				if(slide.getSlideDefinitionID() == slideDefinitionID) {

					return slide;

				}

				resultSlide = this.getSlide(slide, slideDefinitionID);

				if(resultSlide == null) {

					continue;

				}

				else {

					break;

				}

			}

		}

		return resultSlide;

	}

	/**

	 * 

	 * @param slide

	 * @param slideDefinitionID

	 * @return

	 */

	public Slide getSlide(Slide slide, long slideDefinitionID) {

		List<Slide> childrenSlides = slide.getChildrenSlides();

		Slide resultSlide = null;

		if(childrenSlides != null) {

			for(Slide childSlide : childrenSlides) {

				if(childSlide.getSlideDefinitionID() == slideDefinitionID) {

					return childSlide;

				}

				resultSlide = this.getSlide(childSlide, slideDefinitionID);

				if(resultSlide == null) {

					continue;

				}

				else {

					break;

				}

			}

		}

		return resultSlide;

	}

	/**

	 * Returns list of borrowed slides

	 * 

	 * @param entity

	 * @return list of borrowed slides

	 */

	public List<Slide> getBorrowedSlides(Entity entity) {

		List<Slide> borrowedSlides = new ArrayList<Slide>();

		List<Slide> slides = entity.getSlides();

		for(Slide slide : slides) {

			if(slide.isBorrowed()) {

				borrowedSlides.add(slide);

			}

		}

		return borrowedSlides;

	}

}