View Javadoc
   package com.bonevich.erj.model;
   
   import com.bonevich.util.dependency.Dynamic;
   import com.bonevich.java.util.ImmutableIterator;
   import java.util.*;
   
   /*** A class that represents ...
    * 
    * @see Schema
   * @see Attribute
   * @author Jeffrey D. Bonevich <bonevich@telocity.com>
   */
  public final class Relation extends ModelElement
  {
  	//////////////////////////////////////////////////////////
  	// Constants
  	public static final String NEW_RELATION_STR = "relation_";
  	public static final String EMPTY_STR  = "";
  
  	//////////////////////////////////////////////////////////
  	// Attributes
  	{
  		 _name        = EMPTY_STR;
  		 _identifier  = EMPTY_STR;
  		 _description = EMPTY_STR;
  	}
  
  	private int _attributeCount = 0;
  	private int _keyCount       = 0;
  
  	//////////////////////////////////////////////////////////
  	// Associations
  	private Schema _schema;
  	private List   _attributes = new LinkedList();
  	private List   _keys       = new LinkedList();
  
  	/////////////////////////////////////////////////////////
  	// Dynamic Sentries
  	private Dynamic _dyn_attributes  = new Dynamic();
  	private Dynamic _dyn_keys        = new Dynamic();
  
  	//////////////////////////////////////////////////////////
  	// Constructors
  	public Relation(Schema schema)
  	{
  		setSchema(schema);
  		setIdentifier(NEW_RELATION_STR + _schema.getRelationCount()); 
  		setName(getIdentifier());
  	}
  
  	public Schema getSchema()
  	{
  		return _schema;
  	}
  	private void setSchema(Schema schema)
  	{
  		_schema = schema;
  	}
  
  
  	//////////////////////////////////////////////////////////
  	// Operations
  	public Attribute createAttribute()
  	{
  		return createAttribute(null);
  	}
  	public Attribute createAttribute(Attribute ref)
  	{
  		// FIXME: how check that attribute identifiers do not conflict
  		_dyn_attributes.onSet();
  		++_attributeCount;
  		Attribute attribute = new Attribute(this, ref);
  		_attributes.add(attribute);
  		return attribute;
  	}
  	public void moveAttributeUp(Attribute attribute)
  	{
  		int index = _attributes.indexOf(attribute);
  		if (index > 0)
  		{
  			_attributes.remove(index);
  			_attributes.add(--index, attribute);
  			_dyn_attributes.onSet();
  		}
  	}
  	public void moveAttributeDown(Attribute attribute)
  	{
  		int index = _attributes.indexOf(attribute);
  		if (index < _attributes.size() - 1)
  		{
  			_attributes.remove(index);
  			_attributes.add(++index, attribute);
  			_dyn_attributes.onSet();
  		}
  	}
  	public void deleteAttribute(Attribute attribute)
  	{
  		if (_attributes.remove(attribute))
  		{
 			_dyn_attributes.onSet();
 			attribute.dispose();
 		}
 	}
 	public Iterator getAttributeIterator()
 	{
 		_dyn_attributes.onGet();
 		return new ImmutableIterator(_attributes.iterator());
 	}
 	public int getAttributeCount()
 	{
 		return _attributeCount;
 	}
 	public Attribute getAttribute(String identifier)
 	{
 		Iterator attributes = getAttributeIterator();
 		while (attributes.hasNext())
 		{
 			Attribute attr = (Attribute) attributes.next();
 			if (attr.getIdentifier().equals(identifier))
 			{
 				return attr;
 			}
 		}
 		return null;
 	}
 
 	public UniqueKey createUniqueKey(Attribute[] attributes)
 	{
 		_dyn_keys.onSet();
 		++_keyCount;
 		UniqueKey key = new UniqueKey(this, attributes);
 		_keys.add(key);
 		return key;
 	}
 	public PrimaryKey createPrimaryKey(Attribute[] attributes)
 	{
 		_dyn_keys.onSet();
 		++_keyCount;
 		PrimaryKey key = new PrimaryKey(this, attributes);
 		// KeyConstraint.equals() will ensure that only a single 
 		//PK is present; but what to do with one that already exists??
 		_keys.add(key);
 		return key;
 	}
 	public ForeignKey createForeignKey(Relation referent)
 	{
 		// See if the referent relation has a primary key;
 		// if so, make new attributes in our relation
 		Iterator keys = referent.getKeyIterator();
 		List attrList = new LinkedList();
 		while (keys.hasNext())
 		{
 			KeyConstraint key = (KeyConstraint)keys.next();
 			if (key instanceof PrimaryKey)
 			{
 				Iterator attributes = key.getAttributeIterator();
 				while (attributes.hasNext())
 				{
 					Attribute attribute = (Attribute)attributes.next();
 					Attribute newAttribute = createAttribute(attribute);
 					attrList.add(newAttribute);
 				}
 				break;
 			}
 		}
 
 		Attribute[] attrArray = new Attribute[attrList.size()];
 		attrArray = (Attribute[])attrList.toArray(attrArray);
 		return createForeignKey(referent, attrArray);
 	}
 	public ForeignKey createForeignKey(Relation referent, Attribute[] attributes)
 	{
 		_dyn_keys.onSet();
 		++_keyCount;
 		ForeignKey key = new ForeignKey(this, attributes, referent);
 		_keys.add(key);
 
 		// All foreign keys need to be registered with the schema
 		_schema.addKey(key);
 
 		return key;
 	}
 
 	public void deleteKey(ForeignKey key)
 	{
 		deleteKey((KeyConstraint)key);
 
 		// Inform the schema it no longer needs to track this FK
 		_schema.removeKey(key);
 	}
 	public void deleteKey(KeyConstraint key)
 	{
 		if (_keys.remove(key))
 		{
 			_dyn_keys.onSet();
 			key.dispose();
 		}
 	}
 	public Iterator getKeyIterator()
 	{
 		_dyn_keys.onGet();
 		return new ImmutableIterator(_keys.iterator());
 	}
 	public int getKeyCount()
 	{
 		return _keyCount;
 	}
 
 	public void dispose()
 	{
 		Iterator keys = getKeyIterator();
 		while (keys.hasNext())
 		{
 			((KeyConstraint) keys.next()).dispose();
 		}
 
 		Iterator attributes = getAttributeIterator();
 		while (attributes.hasNext())
 		{
 			((Attribute) attributes.next()).dispose();
 		}
 	}
 
 	public boolean equals(Object rhs)
 	{
 		if (rhs != null && rhs instanceof Relation)
 		{
 			Relation that = (Relation)rhs;
 			if (getSchema() == that.getSchema() && 
 					that.getIdentifier().equals(getIdentifier())
 			   ) 
 			{
 				return true;
 			}
 		}
 		return false;
 	}
 
 	public void accept(ModelElementVisitor visitor)
 	{
 		visitor.visitRelation(this);
 	}
 
 } /* end class Relation */