/*

 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.

  *

  *

  */