/*
**               j###t  ########## ####   ####
**              j###t   ########## ####   ####
**             j###T               "###L J###"
**          ######P'    ##########  #########
**          ######k,    ##########   T######T
**          ####~###L   ####
**          #### q###L  ##########   .#####
**          ####  \###L ##########   #####"
**
**  $Id$
**
**  Class History
**
**  Date        Name         Description
**  ---------|------------|-----------------------------------------------
**  19Aug98     subtle       start of recorded history
**
*/

package key.collections;

import key.*;

import key.util.FilteredEnumeration;

import java.util.Enumeration;
import java.util.StringTokenizer;
import java.io.IOException;
import java.io.DataInput;
import java.io.DataOutput;
import java.util.NoSuchElementException;

/**
  *  You should not link references into this collection as normal -
  *  only atom's should be used.  It will store references, though.
 */
public class ReferencingProxyCollection
implements Collection, ReferenceEnumeratorFilter.EnumeratedThing
{
	Collection proxy;

	public ReferencingProxyCollection( Collection p )
	{
		proxy = p;
	}
	
	public void noSideEffectRemove( Reference r ) throws BadKeyException, NonUniqueKeyException, NoSuchElementException
	{
		proxy.unlink( r );
	}
	
	public void link( Symbol added ) throws BadKeyException, NonUniqueKeyException
	{
		proxy.link( ((Atom)added).getThis() );
	}
	
	public void partialLink( Symbol added ) throws BadKeyException, NonUniqueKeyException
	{
		proxy.partialLink( ((Atom)added).getThis() );
	}

	public void unlink( Symbol removed ) throws NonUniqueKeyException,NoSuchElementException,BadKeyException
	{
		proxy.unlink( ((Atom)removed).getThis() );
	}
	
	public Enumeration elements()
	{
			//  there is no need for a indirection agent here as seen 
			//  in Player.java and Container.java - the  noSideEffectRemove
			//  method is public, since access to instances of this class
			//  can only occur through delegation from a trusted class
			//  (Container, generally)
		return( new FilteredEnumeration( 
				proxy.elements(),
				new ReferenceEnumeratorFilter( this, true ) ) );
	}
	
    public int count()
	{
		return( proxy.count() );
	}
	
	public boolean contains( Symbol o )
	{
		return( proxy.contains( ((Atom)o).getThis() ) );
	}
	
	public Object get( Object key )
	{
		return( ((Reference)proxy.get( key )).get() );
	}
	
	public Symbol getExact( String key )
	{
		return( ((Reference)proxy.getExact( key )).get() );
	}
	
	/**
	  *  Conceal the symbol - if possible
	 */
	public void conceal( Symbol a )
	{
		proxy.conceal( ((Atom)a).getThis() );
	}
	
	/**
	  *  Unconceal the symbol, if its concealed
	 */
	public void reveal( Symbol a )
	{
		proxy.reveal( ((Atom)a).getThis() );
	}

	/**
	  *  While this is false, even conceal'd
	  *  symbols are visible.  It starts out
	  *  as false, is set to true, and can
	  *  never be reset again.
	 */
	public void concealable( boolean t )
	{
		proxy.concealable( t );
	}
	
	/**
	  * Called when anything cached can be 'deallocated'
	 */
	public void deallocate()
	{
		proxy.deallocate();
	}

	/**
	  *  Called when theres an opportunity to index the
	  *  elements in the collection in some ordered way
	  *  (as opposed to the haphazard way they're normally
	  *  treated ;)
	 */
	public void sort()
	{
		proxy.sort();
	}

	/**
	  *  Get multi-matches.  Only implemented in some
	  *  Collections.  (Not required) Marked for
	  *  removal
	 */
	public Object getTrieFor( String match )
	{
		return( proxy.getTrieFor( match ) );
	}
	
		// remove these next two, too
	public Symbol getElementAt( int c )
	{
		return( ((Reference)proxy.getElementAt( c )).get() );
	}
	
	public void removeElementAt( int c ) throws NonUniqueKeyException,NoSuchElementException,BadKeyException
	{
		proxy.removeElementAt( c );
	}
}