/*
    * @author Giorgos Anestis, TUC/MUSIC
    *  
    * @version 2.0
    */
   package org.dbe.studio.tools.ontologyviewer.metamodels.odm;
   
   import java.util.Hashtable;
   import java.util.Vector;
  
  /***
   * Properties let us assert general facts about the members of classes and
   * specific facts about individuals. From a mathematical point of view a 
   * property is a binary relation. Two types of properties are distinguished:
   * - Object properties link individuals to individuals.  They are relations 
   *   between instances of two classes
   * - Datatype properties link individuals to data values. They are relations 
   *   between instances of classes and RDF literals and XML Schema datatypes
   * 
   * ObjectProperty concept corresponds to the relationship (among entities) 
   * in the Databases field while Datatype properties correspond to entity's 
   * attributes. 
   */
  public abstract class OdmProperty {
  
  	String name;
  	String id;
  	Vector annotationProps;  //list of OdmAnnotationProperty class instances
  	
  	/* 
  	 * It is actually the conjuction of class descriptions
  	 * This conjuction restricts the domain of the property to those
  	 * individuals that belong to the intersection of the class descriptions
  	 * 
  	 * An rdfs:domain axiom asserts that the subjects of such property 
  	 * statements must belong to the class extension of the indicated class 
  	 * description
  	 * 
  	 * List of OntologyClass instances
  	 */
  	Vector domain;		
  	
  	/*
  	 * It is actually the conjuction of class descriptions or of data ranges
  	 * In other words, Multiple range restrictions are interpreted as stating
  	 * that the range of the property is the intersection of all ranges 
  	 * (i.e., the intersection of the class extension of the class descriptions 
  	 * c.q. the intersection of the data ranges).
  	 * 
  	 * An rdfs:range axiom asserts that the values of this property must belong
  	 * to the class extension of the class description or to data values in the
  	 * specified data range
  	 * 
  	 * List of OntologyClass or DataRange class intances.  
  	 */
  	Vector range;
  	
  	/*
  	 * A rdfs:subPropertyOf axiom defines that the property is a subproperty
  	 * of some other property. Formally this means that if P1 is a subproperty
  	 * of P2, then the property extension of P1 (a set of pairs) should be a
  	 * subset of the property extension of P2 (also a set of pairs).
  	 * 
  	 * A consider that subPropertyOf suports multiple inheritance, that is why
  	 * the variable is define as Vector
  	 * 
  	 * List of Poperty instances
  	 */
  	Vector subPropertyOf;
  	Hashtable superPropertyOf;
  	
  	/*
  	 * The owl:equivalentProperty construct can be used to state that two 
  	 * properties have the same property extension. Syntactically, 
  	 * owl:equivalentProperty is a built-in OWL property with rdf:Property
  	 * as both its domain and range.
  	 * 
  	 * List of Property class instances
  	 */
  	Vector equivalentProperties; 
  	
  	/*
  	 * A functional property is a property that can have only one (unique)
  	 * value y for each instance x, i.e. there cannot be two distinct values
  	 * y1 and y2 such that the pairs (x,y1) and (x,y2) are both instances of
  	 * this property. Both object properties and datatype properties can be
  	 * declared as "functional" 
  	 */
  	boolean isFunctional;	
  	
  	/*
  	 * The ontology into which a Property is defined
  	 */
  	OdmOntology ontology;
  	
  	public OdmProperty() {
  		
  	}
  	
 	public OdmProperty(OdmOntology ontology, String name, String id) {
 		
 		//It keeps a reference to the ontology it belongs to
 		this.ontology = ontology;
 		//It adds itself to the ontology it belongs to !!
 			
 		this.name = name;
 		this.id = id;
 		
 		if (this instanceof OdmObjectProperty) {
 			this.ontology.addObjectProperty((OdmObjectProperty)this);
 		}
 	}
 	
 	public void addDomain(OdmOntologyClass oc) {
 		if (domain == null) {
 			domain = new Vector();			
 		}
 		domain.add(oc);
 	}
 	
 	public void removeDomain(OdmOntologyClass oc) {
 		if (domain != null) {
 			domain.remove(oc);
 		}
 	}
 	
 	public void addSubproperty(OdmProperty p) {
 		if (subPropertyOf == null) {
 			subPropertyOf = new Vector();
 		}
 		// it ensures that the super and subproperty is of the same kind,
 		// i.e. they are both object or datatype properties
 		if (this.getClass() == p.getClass()) {
 			subPropertyOf.add(p);
 		}
 	}
 	
 	public void removeSubproperty(OdmProperty p) {
 		if (subPropertyOf != null) {
 			subPropertyOf.remove(p);
 		}
 	}
 	
 	public void addSuperProperty(OdmProperty p) {
 		if (superPropertyOf == null) {
 			superPropertyOf = new Hashtable();			
 		}
 		superPropertyOf.put(p.getId(), p);
 	}
 
 	public void removeSuperProperty(OdmProperty p) {
 		if (superPropertyOf != null) {
 			superPropertyOf.remove(p.getId());
 		}
 	}
 	
 	public void addEquivalentProperty(OdmProperty p) {
 		if (equivalentProperties == null) {
 			equivalentProperties = new Vector();			
 		}
 		if (this.getClass() == p.getClass()) {
 			equivalentProperties.add(p);
 		}
 	}
 
 	public void removeEquivalentProperty(OdmProperty p) {
 		if (equivalentProperties != null) {
 			equivalentProperties.remove(p);
 		}
 	}
 	
 	public void addAnnotationProp(OdmAnnotationProperty ap) {
 		if ( annotationProps == null ) {
 			annotationProps = new Vector();
 		}
 		annotationProps.add(ap);
 		
 	}
 	
 	public void removeAnnotationProp(OdmAnnotationProperty ap) {
 		if (annotationProps != null) {
 			annotationProps.remove(ap);
 		}
 	}
 			
 	public void setName(String name) {
 		this.name = name;
 	}
 	
 	public void setId(String id) {
 		this.id = id;
 	}
 	
 	public void setOntology(OdmOntology ont) {
 		ontology = ont;
 	}
 	
 	public void setAnnotationProps(Vector a) {
 		annotationProps = a;
 	}
 	
 	public void setIsFunctional( boolean iF) {
 		isFunctional = iF;
 	}	
 	
 	public String getName() {
 		return name;
 	}
 	
 	public String getId() {
 		return id;
 	}
 	
 	public OdmOntology getOntology() {
 		return ontology;
 	}
 	
 	public Vector getAnnotationProps() {
 		return annotationProps;
 	}
 	
 	public boolean getIsFunctional() {
 		return isFunctional;
 	}
 	
 	public Vector getDomain() {
 		return domain;
 	}
 	
 	public Vector getRange() {
 		return range;
 	}
 	
 	public Vector getSubPropertyOf() {
 		return subPropertyOf;
 	}
 	
 	public Hashtable getSuperPropertyOf() {
 		return superPropertyOf;
 	}
 	
 	public Vector getEquivalentProperties() {
 		return equivalentProperties;
 	}
 }