/*
   Wotonomy: OpenStep design patterns for pure Java applications.
   Copyright (C) 2000 Michael Powers
   
   This library is free software; you can redistribute it and/or
   modify it under the terms of the GNU Lesser General Public
   License as published by the Free Software Foundation; either
   version 2.1 of the License, or (at your option) any later version.
   
  This library is distributed in the hope that it will be useful,
  but WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  Lesser General Public License for more details.
  
  You should have received a copy of the GNU Lesser General Public
  License along with this library; if not, see http://www.gnu.org
  */
  
  package net.wotonomy.datastore;
  
  import java.util.Comparator;
  import java.util.Iterator;
  import java.util.LinkedList;
  import java.util.List;
  import java.util.TreeMap;
  
  /***
  * This implementation of DataIndex wraps a TreeMap and
  * adds the ability to contain objects with duplicate keys.
  */
  public class DefaultDataIndex implements DataIndex
  {
  	static final long serialVersionUID = -3759982714240822885L;
  
      protected String name;
      protected String property;
      private TreeMap treeMap;    
      private Comparator comparator;
      
      public DefaultDataIndex()
      {
          comparator = new DefaultComparator();
          setTreeMap( new TreeMap( new DefaultComparator() ) );
      }
      
      public DefaultDataIndex( String aName, String aProperty )
      {
          this();
      	setName( aName );
  		setProperty( aProperty );
      }
  
      // included for xml serialization    
      public Comparator getComparator() { return comparator; }
      public void setComparator( Comparator aComparator ) 
      { 
          comparator = aComparator; 
          // set comparator and copy contents
          TreeMap map = getTreeMap();
          setTreeMap( new TreeMap( comparator ) );
          getTreeMap().putAll( map );
          
      }
      
      public String getName() { return name; };
      public void setName( String aName ) { name = aName; }
      public String getProperty() { return property; };
      public void setProperty( String aProperty ) { property = aProperty; }
      public TreeMap getTreeMap() { return treeMap; }
      public void setTreeMap( TreeMap aMap ) { treeMap = aMap; }
      
      public List query( Object beginValue, Object endValue )
      {
  //System.out.println( "DefaultDataIndex.query: " + beginValue + " : " + endValue );
  		List result = new LinkedList();
      	if ( endValue == null )
  	    {
  	    	if ( beginValue == null )
  		    {
  		    	// begin and end are null, return entire set
  		    	populateListFromIterator( result, treeMap.values().iterator() );
  			    return result;
  		    }
  		    
  		    // only end is null, return all starting from beginValue
  		    populateListFromIterator( result,
  		    	treeMap.tailMap( beginValue ).values().iterator() );
  			return result;
  	    }
  	    else
  	    if ( beginValue == null )
  	    {
  	    	// only begin is null, return all ending with endValue
              populateListFromIterator( result,
                  treeMap.headMap( endValue ).values().iterator() );
  	    }
  	    else
  	    {
      		// begin and end are specified, return all inclusive
             populateListFromIterator( result,
                 treeMap.subMap( beginValue, endValue ).values().iterator() );
 		}
 		
 		// append endValue results, so it's inclusive
     	Object o = treeMap.get( endValue );
 	    if ( o != null )
 	    {
             if ( o instanceof DuplicateList )
             {
                 populateListFromIterator( result,
                     ((DuplicateList)o).iterator() );
             }
             else
             {
                 result.add( o );
             }
 		}
 		
 		// return complete result
 		return result;
 	}
     
     protected void populateListFromIterator( List aList, Iterator it )
     {
     	Object o;
     	while ( it.hasNext() )
 	    {
 	    	o = it.next();
 		    if ( o instanceof DuplicateList )
 		    {
 		    	populateListFromIterator( 
 			    	aList, ((DuplicateList)o).iterator() );
 		    }
 		    else
 		    {
 		    	aList.add( o );
 		    }
 	    }
     }
     
     public Object addObject( Object anObject, Object newValue )
     {
     	Object o = treeMap.get( newValue );
         if ( o != null )
         {
             if ( o instanceof DuplicateList )
             {
                 ((DuplicateList)o).add( anObject );
                 return anObject;
             }
 
             DuplicateList list = new DuplicateList();
             list.add( o );
             list.add( anObject );
             anObject = list;
 
         }
 if ( anObject == null ) new RuntimeException().printStackTrace();
 
     	treeMap.put( newValue, anObject );
 	    return anObject;
     }
     
     public Object updateObject( Object anObject, 
     	Object oldValue, Object newValue )
     {
     	removeObject( anObject, oldValue );
 		return addObject( anObject, newValue );
     }
     
     public Object removeObject( Object anObject, Object oldValue )
     {
     	Object o = treeMap.get( oldValue );
         if ( o != null )
         {
             if ( o instanceof DuplicateList )
             {
                 // remove this item from the list
                 DuplicateList list = (DuplicateList) o;
                 list.remove( anObject );
 		
 				// if there are still duplicates, return
                 if ( list.size() > 1 )
                     return anObject;
 
                 // else, list size must be one
                 if ( list.size() == 0 )
                 {
                     System.out.println( "DefaultDataIndex.deleteObject: " + oldValue
                         + " : list size is 1 : this should never happen." );
 					return null;
                 }
 
                 // replace existing list with remaining item from list
                 treeMap.remove( oldValue );
 	            treeMap.put( oldValue, list.getFirst() );
     	        return anObject;
             }
 
 			// otherwise, proceed normally
             treeMap.remove( oldValue );
         }
 		return anObject;
     }
     
     public void clear()
     {
     	treeMap.clear();
     }    
     
     public String toString() 
     {
        return "DefaultDataIndex: " + name + " : " + property + " : " + treeMap.toString();
     }
         
 }
 
 /*
  * $Log$
  * Revision 1.2  2006/02/19 16:26:19  cgruber
  * Move non-unit-test code to tests project
  * Fix up code to work with proper imports
  * Fix maven dependencies.
  *
  * Revision 1.1  2006/02/16 13:18:56  cgruber
  * Check in all sources in eclipse-friendly maven-enabled packages.
  *
  * Revision 1.2  2003/08/14 19:29:38  chochos
  * minor cleanup (imports, static method calls, etc)
  *
  * Revision 1.1.1.1  2000/12/21 15:47:11  mpowers
  * Contributing wotonomy.
  *
  * Revision 1.3  2000/12/20 16:25:36  michael
  * Added log to all files.
  *
  *
  */