Subversion Repositories SmartDukaan

/**

 * 

 */

package in.shop2020.metamodel.definitions;

import in.shop2020.metamodel.util.ExpandedCMPSlideRuleDefinition;

import in.shop2020.metamodel.util.ExpandedCategory;

import in.shop2020.metamodel.util.ExpandedCategoryFacetDefinition;

import in.shop2020.metamodel.util.ExpandedFacetDefinition;

import in.shop2020.util.DBUtils;

import in.shop2020.util.Utils;

import java.io.Serializable;

import java.util.ArrayList;

import java.util.Iterator;

import java.util.List;

import java.util.Map;

/**

 * Single point of access to all definition objects

 * 

 * @author naveen

 *

 */

public class DefinitionsContainer implements Serializable {

	/** 

	 * 

	 */

	private static final long serialVersionUID = 1L;

	/**

	 * Hashtable of Category ID to Category object

	 */

	private Map<Long, Category> categories;

	/**

	 * Hashtable of Slide ID to SlideDefinition object

	 */

	private Map<Long, SlideDefinition> slideDefinitions;

	/**

	 * Hashtable of Feature Definition ID to FeatureDefinition object

	 */

	private Map<Long, FeatureDefinition> featureDefinitions;

	/**

	 * Hashtable of Datatype Definition ID to DatatypeDefinition object

	 */

	private Map<Long, DatatypeDefinition> datatypeDefinitions;

	/**

	 * Hashtable of Enum value ID to EnumValue object

	 */

	private Map<Long, EnumValue> enumValues;

	/**

	 * Hashtable of Unit ID to Unit object

	 */

	private Map<Long, Unit> units;

	/**

	 * Hashtable of Facet Definition ID to FacetDefinition object

	 */

	private Map<Long, FacetDefinition> facetDefinitions;

	/**

	 * Hashtable of Category Facet Definition ID to CategoryFacetDefinition 

	 * object

	 */

	private Map<Long, CategoryFacetDefinition> categoryFacetDefinitions;

	/**

	 * Hashtable of IR Data Rule ID to RuleDefinition object

	 */

	private Map<Long, RuleDefinition> irDataRuleDefinitions;	

	/**

	 * Hashtable of IR Meta Data Rule ID to RuleDefinition object

	 */

	private Map<Long, RuleDefinition> irMetaDataRuleDefinitions;

	/**

	 * Hashtable of Comparison Rule ID to CMPRuleDefinition object

	 */

	private Map<Long, CMPRuleDefinition> cmpRuleDefinitions;	

	/**

	 * Hashtable of SlideDefinition ID to CMPSlideRuleDefinition object

	 */

	private Map<Long, CMPSlideRuleDefinition> cmpSlideRuleDefinitions;

	/**

	 * Empty constructor. Data structures are initialised as needed

	 */

	public DefinitionsContainer() {

		// Lazy initialization

	}

	/**

	 * Returns all Unit objects in the database

	 * 

	 * @return Map Null if units are not imported into definitions db 

	 * (serialized java objects)

	 * 

	 * @throws Exception 

	 */

	@SuppressWarnings("unchecked")

	public Map<Long, Unit> getUnits() throws Exception {		

		// De-serialize

		if(this.units == null) {

			String dbFile = Utils.DEFINITIONS_DB_PATH + "units" + ".ser";

			this.units = (Map<Long, Unit>) DBUtils.read(dbFile);

		}

		return this.units;

	}

	/**

	 * Resolves Unit ID into Unit object

	 * 

	 * @param unitID Unit ID

	 * @return Unit

	 * @throws Exception 

	 */

	public Unit getUnit(long unitID) throws Exception {		

		// Initialize 

		if(this.units == null) {

			this.getUnits();

		}

		return this.units.get(new Long(unitID));

	}

	/**

	 * Returns all DatatypeDefintion object in database

	 * 

	 * @return the datatypeDefinitions List of DatatypeDefinition objects

	 * @throws Exception 

	 */

	@SuppressWarnings("unchecked")

	public Map<Long, DatatypeDefinition> getDatatypeDefinitions() 

		throws Exception {

		// De-serialize

		if(this.datatypeDefinitions == null) {

			String dbFile = Utils.DEFINITIONS_DB_PATH + "datatypedefinitions" + 

				".ser";

			this.datatypeDefinitions = 

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

		}

		return this.datatypeDefinitions;

	}

	/**

	 * Resolves Datatype Definition ID into DatetypeDefinition object

	 * 

	 * @param unitID Unit ID

	 * @return Unit

	 * @throws Exception 

	 */

	public DatatypeDefinition getDatatypeDefinition(long id) throws Exception {

		// Initialize 

		if(this.datatypeDefinitions == null) {

			this.getDatatypeDefinitions();

		}

		return this.datatypeDefinitions.get(new Long(id));

	}

	/**

	 * Returns EnumValue ID for datatype definition ID and enum value string 

	 * to match. Match is case insensitive

	 * 

	 * @param datatypeDefID DatatypeDefinition ID

	 * @param value query enum value string

	 * @return long enumValueID - "-1" if not found

	 * @throws Exception 

	 */

	public long getEnumValueID(long datatypeDefID, String value) 

		throws Exception {

		long enumValueID = -1L;

		// Let the callers catch ClassCastException

		EnumDefinition enumDef = 

			(EnumDefinition)this.getDatatypeDefinition(datatypeDefID);

		List<EnumValue> enumValues = enumDef.getEnumValues();

		for(EnumValue enumValue : enumValues) {

			if(value.equalsIgnoreCase(enumValue.getValue())) {

				enumValueID = enumValue.getID();

				break;

			}

		}

		return enumValueID;

	}

	/**

	 * Returns all category objects in the database

	 * 

	 * @return the categories

	 * @throws Exception 

	 */

	@SuppressWarnings("unchecked")

	public Map<Long, Category> getCategories() throws Exception {

		// De-serialize

		if(this.categories == null) {

			String dbFile = Utils.DEFINITIONS_DB_PATH + "categories" + ".ser";

			this.categories = (Map<Long, Category>) DBUtils.read(dbFile);

		}

		return this.categories;

	}

	/**

	 * Resolves Category ID into Category object

	 * 

	 * @param categoryID Category ID

	 * @return Category

	 * @throws Exception 

	 */

	public Category getCategory(long categoryID) throws Exception {

		// Initialize 

		if(this.categories == null) {

			this.getCategories();

		}

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

	}

	/**

	 * Returns expanded Category object. All numeric identifiers are resolved 

	 * into detailed objects

	 * 

	 * @param categoryID

	 * @return ExpandedCategory

	 * @throws Exception

	 */

	public ExpandedCategory getExpandedCategory(long categoryID) 

		throws Exception {

		Category category = this.getCategory(categoryID);

		ExpandedCategory expCategory = new ExpandedCategory(category);

		return expCategory;

	}

	/**

	 * Returns all children categories for a Category ID

	 * 

	 * @param categoryID

	 * @return List<Category> Children Categories

	 * @throws Exception

	 */

	public List<Category> getChildrenCategories(long categoryID) 

		throws Exception {

		// Initialize 

		if(this.categories == null) {

			this.getCategories();

		}

		return this.categories.get(new Long(categoryID)).getChildrenCategory();

	}

	/**

	 * Returns all CategorySlideDefinition objects for a Category ID

	 * 

	 * @param categoryID Category ID

	 * @return List<CategorySlideDefinition> 

	 * @throws Exception 

	 */

	public List<CategorySlideDefinition> getCategorySlideDefinitions(

			long categoryID) throws Exception {

		Category category = this.getCategory(categoryID);

		return category.getCategorySlideDefintions();

	}

	/**

	 * Returns All SlideDefinition objects in database

	 * 

	 * @return the slideDefinitions

	 * @throws Exception 

	 */

	@SuppressWarnings("unchecked")

	public Map<Long, SlideDefinition> getSlideDefinitions() throws Exception {

		// De-serialize

		if(this.slideDefinitions == null) {

			String dbFile = Utils.DEFINITIONS_DB_PATH + "slidedefinitions" + 

				".ser";

			this.slideDefinitions = 

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

		}

		return this.slideDefinitions;

	}

	/**

	 * Resolves SlideDefinition ID into SlideDefinition object

	 * 

	 * @param id

	 * @return SlideDefinition

	 * @throws Exception

	 */

	public SlideDefinition getSlideDefinition(long id) throws Exception {

		// Initialize 

		if(this.slideDefinitions == null) {

			this.getSlideDefinitions();

		}

		return this.slideDefinitions.get(new Long(id));

	}

	/**

	 * Returns SlideDefinition objects for a category and matching slide label

	 * 

	 * @param label

	 * @return List<SlideDefinition>

	 * @throws Exception

	 */

	public List<SlideDefinition> getSlideDefinitions(long categoryID, 

			String label) throws Exception {

		// RE-VISIT

		// May be we need a new data structure, category id to slide definitions

		// for now

		List<SlideDefinition> matchingSlides = new ArrayList<SlideDefinition>();

		List<CategorySlideDefinition> csDefs = this.getCategorySlideDefinitions(

				categoryID);

		for(CategorySlideDefinition csDef : csDefs) {

			SlideDefinition sDef = this.getSlideDefinition(

					csDef.getSlideDefintionID());

			if(sDef.getLabel().equalsIgnoreCase(label)) {

				matchingSlides.add(sDef);

			}

		}

		return matchingSlides;

	}

	/**

	 * Resolves Category ID into Category object

	 * 

	 * @param categoryID

	 * @return List<SlideDefinition> 

	 * @throws Exception

	 */

	public List<SlideDefinition> getSlideDefinitions(long categoryID) 

		throws Exception {

		// RE-VISIT

		// May be we need a new data structure, category id to slide definitions

		// for now

		List<SlideDefinition> matchingSlides = new ArrayList<SlideDefinition>();

		List<CategorySlideDefinition> csDefs = this.getCategorySlideDefinitions(

				categoryID);

		for(CategorySlideDefinition csDef : csDefs) {

			SlideDefinition sDef = this.getSlideDefinition(

					csDef.getSlideDefintionID());

			matchingSlides.add(sDef);

		}

		return matchingSlides;

	}

	/**

	 * Returns list of SlideDefinition objects for a category and editorial 

	 * importance value

	 * 

	 * @param categoryID

	 * @param EditorialImportance imp

	 * @return List<SlideDefinition>

	 * @throws Exception 

	 */

	public List<SlideDefinition> getSlides(long categoryID, 

			EditorialImportance imp) 

		throws Exception {

		List<CategorySlideDefinition> catSlideDefs = 

			this.getCategorySlideDefinitions(categoryID);

		Iterator<CategorySlideDefinition> itCatSlideDefs = 

			catSlideDefs.iterator();

		List<SlideDefinition> slideDefs = new ArrayList<SlideDefinition>();

		while(itCatSlideDefs.hasNext()) {

			CategorySlideDefinition catSlideDef = itCatSlideDefs.next();

			if(catSlideDef.getEditorialImportance() == imp) {

				long slideDefID = catSlideDef.getSlideDefintionID();

				slideDefs.add(this.getSlideDefinition(slideDefID));

			}

		}

		return slideDefs;

	}

	/**

	 * Returns all FeatureDefinition object in database

	 * 

	 * @return Map<Long, FeatureDefinition>

	 * @throws Exception

	 */

	@SuppressWarnings("unchecked")

	public Map<Long, FeatureDefinition> getFeatureDefinitions() 

		throws Exception {

		// De-serialize

		if(this.featureDefinitions == null) {

			String dbFile = Utils.DEFINITIONS_DB_PATH + "featuredefinitions" + 

				".ser";

			this.featureDefinitions = 

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

		}

		return this.featureDefinitions;

	}

	/**

	 * Returns all FeatureDefinition objects for a slide

	 * 

	 * @param slideID

	 * @return List<FeatureDefinition> 

	 * @throws Exception

	 */

	public List<FeatureDefinition> getFeatureDefinitions(long slideID) 

		throws Exception {

		List<FeatureDefinition> featureDefs = 

			new ArrayList<FeatureDefinition>();

		SlideDefinition slideDef = this.getSlideDefinition(slideID);

		List<SlideFeatureDefinition> slideFeatureDefs = 

			slideDef.getSlideFeatureDefinitions();

		for(int i=0; i<slideFeatureDefs.size(); i++) {

			featureDefs.add(this.getFeatureDefinition(

					slideFeatureDefs.get(i).getFeatureDefintionID()));

		}

		return featureDefs;

	}

	/**

	 * Returns list of FeatureDefinition objects for a slide given editorial 

	 * importance

	 * 

	 * @param slideID

	 * @param imp Editorial Importance enum object

	 * @return List<FeatureDefinition>

	 * @throws Exception

	 */

	public List<FeatureDefinition> getFeatureDefinitions(long slideID, 

			EditorialImportance imp)  throws Exception {

		List<FeatureDefinition> featureDefs = 

			new ArrayList<FeatureDefinition>();

		SlideDefinition slideDef = this.getSlideDefinition(slideID);

		List<SlideFeatureDefinition> slideFeatureDefs = 

			slideDef.getSlideFeatureDefinitions();

		for(SlideFeatureDefinition slideFeatureDef : slideFeatureDefs) {

			if(slideFeatureDef.getEditorialImportance() == imp) {

				featureDefs.add(this.getFeatureDefinition(

						slideFeatureDef.getFeatureDefintionID()));

			}

		}

		return featureDefs;

	}

	/**

	 * Resolves Feature Definition ID into FeatureDefinition object

	 * 

	 * @param id Feature Definition ID 

	 * @return FeatureDefinition

	 * @throws Exception

	 */

	public FeatureDefinition getFeatureDefinition(long id) throws Exception {

		// Initialize 

		if(this.featureDefinitions == null) {

			this.getFeatureDefinitions();

		}

		return this.featureDefinitions.get(new Long(id));

	}	

	/**

	 * Returns matching FeatureDefinition object for slide ID and feature label.

	 * Label matching is case insensitive.

	 * 

	 * @param slideID Slide ID

	 * @param featureLabel label to match, case is ignored

	 * @return FeatureDefinition 

	 * @throws Exception

	 */

	public FeatureDefinition getFeatureDefinition(long slideID, 

			String featureLabel) throws Exception {

		FeatureDefinition featureDef = null;

		SlideDefinition slideDef = this.getSlideDefinition(slideID);

		for(SlideFeatureDefinition slideFeatureDef : 

			slideDef.getSlideFeatureDefinitions()) {

			long featureDefID = slideFeatureDef.getFeatureDefintionID();

			FeatureDefinition thisFeatureDef = this.getFeatureDefinition(

					featureDefID);

			if(featureLabel.equalsIgnoreCase(thisFeatureDef.getLabel())) {

				featureDef = thisFeatureDef;

			}

		}

		return featureDef;

	}

	/**

	 * Returns all EnumValue objects in the database

	 * 

	 * @return the enumValues

	 * @throws Exception 

	 */

	@SuppressWarnings("unchecked")

	public Map<Long, EnumValue> getEnumValues() throws Exception {

		// De-serialise

		if(this.enumValues == null) {

			String dbFile = Utils.DEFINITIONS_DB_PATH + "enumvalues" + 

				".ser";

			this.enumValues = 

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

		}

		return this.enumValues;

	}

	/**

	 * Resolves Enum value ID into EnumValue object

	 * 

	 * @param enumValueID

	 * @return EnumValue

	 * @throws Exception

	 */

	public EnumValue getEnumValue(long enumValueID) throws Exception {

		// Initialise

		if(this.enumValues == null) {

			this.getEnumValues();

		}

		return this.enumValues.get(new Long(enumValueID));

	}

	/**

	 * Returns all FacetDefinition objects in the database

	 * 

	 * @return Map Null if facet definitions are not imported into definitions 

	 * db (serialized java objects)

	 * 

	 * @throws Exception 

	 */

	@SuppressWarnings("unchecked")

	public Map<Long, FacetDefinition> getFacetDefinitions() throws Exception {

		// De-serialize

		if(this.facetDefinitions == null) {

			String dbFile = Utils.DEFINITIONS_DB_PATH + "facetdefinitions" + 

				".ser";

			this.facetDefinitions = 

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

		}

		return this.facetDefinitions;

	}

	/**

	 * Resolves Facet Definition ID into FacetDefinition object

	 * 

	 * @param facetDefinitionID

	 * @return FacetDefinition

	 * @throws Exception

	 */

	public FacetDefinition getFacetDefinition(long facetDefinitionID) 

		throws Exception {

		if(this.facetDefinitions == null) {

			this.getFacetDefinitions();

		}

		return this.facetDefinitions.get(new Long(facetDefinitionID));

	}

	/**

	 * Utility method to get Expanded version of ExpandedFacetDefinition object 

	 * 

	 * @param facetDefinitionID

	 * @return ExpandedFacetDefinition

	 * @throws Exception

	 */

	public ExpandedFacetDefinition getExpandedFacetDefinition(

			long facetDefinitionID) throws Exception {

		FacetDefinition facetDefinition = 

			this.getFacetDefinition(facetDefinitionID);

		ExpandedFacetDefinition expFacetDefinition = 

			new ExpandedFacetDefinition(facetDefinition);

		return expFacetDefinition;

	}

	/**

	 * Returns all CategoryFacetDefinition objects in the database

	 * 

	 * @return Map Null if category facet definitions are not imported into 

	 * definitions db (serialized java objects)

	 * 

	 * @throws Exception 

	 */

	@SuppressWarnings("unchecked")

	public Map<Long, CategoryFacetDefinition> getCategoryFacetDefinitions() 

		throws Exception {

		// De-serialize

		if(this.categoryFacetDefinitions == null) {

			String dbFile = Utils.DEFINITIONS_DB_PATH + 

				"categoryfacetdefinitions" + ".ser";

			this.categoryFacetDefinitions = 

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

		}

		return this.categoryFacetDefinitions;

	}

	/**

	 * Resolves Category-Facet Definition ID into CategoryFacetDefinition object

	 * 

	 * @param categoryID

	 * @return CategoryFacetDefinition

	 * @throws Exception

	 */

	public CategoryFacetDefinition getCategoryFacetDefinition(

			long categoryID) throws Exception {

		if(this.categoryFacetDefinitions == null) {

			this.getCategoryFacetDefinitions();

		}

		return this.categoryFacetDefinitions.get(

				new Long(categoryID));

	}

	/**

	 * Utility method to get Expanded version of CategoryFacetDefinition object 

	 * 

	 * @param categoryID

	 * @return ExpandedCategoryFacetDefinition

	 * @throws Exception

	 */

	public ExpandedCategoryFacetDefinition getExpandedCategoryFacetDefinition(

			long categoryID) throws Exception  {

		CategoryFacetDefinition categoryFacetDef = 

			this.getCategoryFacetDefinition(categoryID);

		ExpandedCategoryFacetDefinition expCategoryFacetDef = 

			new ExpandedCategoryFacetDefinition(categoryFacetDef);

		return expCategoryFacetDef;

	}

	/**

	 * Returns all IR Data RuleDefintion objects in the database

	 * 

	 * @return Map Null if IR data rule definitions are not imported into 

	 * definitions db (serialized java objects)

	 * 

	 * @throws Exception 

	 */

	@SuppressWarnings("unchecked")

	public Map<Long, RuleDefinition> getIrDataRuleDefinitions() 

		throws Exception {

		// De-serialize

		if(this.irDataRuleDefinitions == null) {

			String dbFile = Utils.DEFINITIONS_DB_PATH + "irdatarules" + ".ser";

			this.irDataRuleDefinitions = 

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

		}

		return this.irDataRuleDefinitions;

	}

	/**

	 * Resolves IR Data Rule Definition ID into RuleDefinition object

	 * 

	 * @param irDataRuleDefinitionID

	 * @return RuleDefinition

	 * @throws Exception

	 */

	public RuleDefinition getIrDataRuleDefinition(

			long irDataRuleDefinitionID) throws Exception {

		if(this.irDataRuleDefinitions == null) {

			this.getIrDataRuleDefinitions();

		}

		return this.irDataRuleDefinitions.get(new Long(irDataRuleDefinitionID));

	}

	/**

	 * Returns all IR Meta Data RuleDefintion objects in the database

	 * 

	 * @return Map Null if IR meta-data rule definitions are not imported into 

	 * definitions db (serialized java objects)

	 * 

	 * @throws Exception 

	 */

	@SuppressWarnings("unchecked")

	public Map<Long, RuleDefinition> getIrMetaDataRuleDefinitions() 

		throws Exception {

		// De-serialize

		if(this.irMetaDataRuleDefinitions == null) {

			String dbFile = Utils.DEFINITIONS_DB_PATH + "irmetadatarules" + 

				".ser";

			this.irMetaDataRuleDefinitions = 

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

		}

		return this.irMetaDataRuleDefinitions;

	}

	/**

	 * Resolves IR Meta Data Rule Definition ID into RuleDefinition object

	 * 

	 * @param irMetaDataRuleDefinitionID

	 * @return RuleDefinition

	 * @throws Exception

	 */

	public RuleDefinition getIrMetaDataRuleDefinition(

			long irMetaDataRuleDefinitionID) throws Exception {

		if(this.irMetaDataRuleDefinitions == null) {

			this.getIrMetaDataRuleDefinitions();

		}

		return this.irMetaDataRuleDefinitions.get(

				new Long(irMetaDataRuleDefinitionID));

	}

	/**

	 * Returns all Comparison RuleDefintion objects in the database

	 * 

	 * @return Map Null if Comparison rule definitions are not imported into 

	 * definitions db (serialized java objects)

	 * 

	 * @throws Exception 

	 */

	@SuppressWarnings("unchecked")

	public Map<Long, CMPRuleDefinition> getComparisonRuleDefinitions() 

		throws Exception {

		// De-serialize

		if(this.cmpRuleDefinitions == null) {

			String dbFile = Utils.DEFINITIONS_DB_PATH + "comparisonrules" + 

				".ser";

			this.cmpRuleDefinitions = 

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

		}

		return this.cmpRuleDefinitions;

	}

	/**

	 * Resolves IR Data Rule Definition ID into RuleDefinition object

	 * 

	 * @param cmpRuleDefinitionID

	 * @return CMPRuleDefinition

	 * @throws Exception

	 */

	public CMPRuleDefinition getComparisonRuleDefinition(

			long cmpRuleDefinitionID) throws Exception {

		if(this.cmpRuleDefinitions == null) {

			this.getComparisonRuleDefinitions();

		}

		return this.cmpRuleDefinitions.get(new Long(cmpRuleDefinitionID));

	}

	/**

	 * Returns all ComparisonSlideRuleDefintion objects in the database

	 * 

	 * @return Map Null if Comparison slide-rule definitions are not imported 

	 * into definitions db (serialized java objects)

	 * 

	 * @throws Exception 

	 */

	@SuppressWarnings("unchecked")

	public Map<Long, CMPSlideRuleDefinition> getComparisonSlideRuleDefinitions() 

		throws Exception {

		// De-serialize

		if(this.cmpSlideRuleDefinitions == null) {

			String dbFile = Utils.DEFINITIONS_DB_PATH +	

				"comparisondefinitions.ser";

			Utils.info("dbFile=" + dbFile);

			this.cmpSlideRuleDefinitions = 

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

			//Utils.info("this.cmpSlideRuleDefinitions=" +

			//		this.cmpSlideRuleDefinitions);

		}

		return this.cmpSlideRuleDefinitions;

	}

	/**

	 * Resolves Category ID into List of CMPSlideRuleDefinition object

	 * 

	 * @param categoryID

	 * @return List<CMPSlideRuleDefinition> 

	 * @throws Exception

	 */

	public CMPSlideRuleDefinition getComparisonSlideRuleDefinition(

			long slideDefinitionID) throws Exception {

		if(this.cmpSlideRuleDefinitions == null) {

			this.getComparisonSlideRuleDefinitions();

		}

		return this.cmpSlideRuleDefinitions.get(new Long(slideDefinitionID));

	}

	/**

	 * Resolves Slide Definition ID into ExpandedCMPSlideRuleDefinition object

	 * 

	 * @param categoryID

	 * @return ExpandedCMPSlideRuleDefinition 

	 * @throws Exception

	 */

	public ExpandedCMPSlideRuleDefinition

		getExpandedComparisonSlideRuleDefinition(long slideDefinitionID) 

		throws Exception {

		Utils.info("slideDefinitionID=" + slideDefinitionID);

		CMPSlideRuleDefinition cmpSlideRuleDef = 

			this.getComparisonSlideRuleDefinition(slideDefinitionID);

		if(cmpSlideRuleDef == null) {

			return null;

		}

		ExpandedCMPSlideRuleDefinition expDef = 

			new ExpandedCMPSlideRuleDefinition(cmpSlideRuleDef);

		return expDef;

	}

}