/* (c) Copyright 2003 Caleigo AB, All rights reserved. 
    * 
    * 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, write to the Free Software
   * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
   *  
   */
  
  package org.caleigo.core;
  
  import java.util.*;
  
  import org.caleigo.core.exception.*;
  
  /*** EntityPool is the standard implementation of the IEntityPool interface. 
   * This entity collection class can store zero or more IEntity objects. 
   * The entities stored are not type specified and does not have to be defined 
   * by a single IEntityDescriptor. IEntityPool is not ordered and  not accept 
   * EntityPool duplicates effectively makeing it at a "Set".
   *
   * @author  Dennis Zikovic
   * @version 1.00
   * 
   *//* 
   *
   * WHEN        WHO               WHY & WHAT
   * ------------------------------------------------------------------------------
   * 2001-10-10  Dennis Zikovic    Creation
   */
  public class EntityPool implements IEntityPool 
  {
      // Data members ------------------------------------------------------------
      private Set mEntitySet;
  
      // Constructors ------------------------------------------------------------
      
      public EntityPool()
      {
          mEntitySet = new HashSet();
      }
          
      public EntityPool(IEntityPool entityPool)
      {
          mEntitySet = new HashSet(entityPool.asSet());
      }
      
      // IEntityPool implementation ----------------------------------------------
      
      /*** Return true if any (one or more) of the collections's contained 
       * entities has the DIRTY flag set to true that is have unsaved changes.
       */
      public boolean isDirty()
      {
          Iterator it = this.iterator();
          boolean dirty = false;
          while(!dirty && it.hasNext())
              dirty = ((IEntity)it.next()).isDirty();
          return dirty;
      }
      
      /*** Stores all contained entities that have the DIRTY flag set to true.
       * The entities are stored in a single transaction meaning that if one
       * store fails then all fails.
       */
      public void storeAll()
      {
          // Break if no dirty entity exists.
          if(!this.isDirty() || this.isEmpty())
              return;
          
          // Extract default service and break if none is defined.
          // !! Note that enties with different data sources is not supported. !!
          IDataService service = ((IEntity)this.iterator().next()).getDataSource().getDataService();
          if(service==null)
              throw new DataServiceNotFoundException("No default data service has been set for data source: "+((IEntity)this.iterator().next()).getEntityDescriptor().getDataSourceDescriptor().getCodeName());
         
          // Store all entities in a single transaction
          IDataTransaction trans = service.newTransaction();
          Iterator it = this.iterator();
          while(it.hasNext())
              trans.addStore((IEntity)it.next());
          trans.commit();
      }
      
      /*** Deletes all contained entities. The entities are deleted in a single 
       * transaction meaning that if one delete fails then all fails.
       * USE THIS METHOD WITH CAUTION!
       */
      public void deleteAll()
     {
         // Break if no entities exists.
         if(this.isEmpty())
             return;
         
         // Extract default service and break if none is defined.
         // !! Note that enties with different data sources is not supported. !!
         IDataService service = ((IEntity)this.iterator().next()).getDataSource().getDataService();
         if(service==null)
             throw new DataServiceNotFoundException("No default data service has been set for data source: "+((IEntity)this.iterator().next()).getEntityDescriptor().getDataSourceDescriptor().getCodeName());
        
         // Store all entities in a single transaction
         IDataTransaction trans = service.newTransaction();
         Iterator it = this.iterator();
         while(it.hasNext())
         {
             IEntity entity = (IEntity)it.next();
             if(entity.isDirty())
                 trans.addDelete(entity);
         }
         trans.commit();
     }
     
     /*** Performs a refresh on all contained entities. The refresh is batched
      * to save performance.
      */
     public void refreshAll()
     {
         // Break if no entities exists.
         if(this.isEmpty())
             return;
         
         // Extract default service and break if none is defined.
         // !! Note that enties with different data sources is not supported. !!
         IDataService service = ((IEntity)this.iterator().next()).getDataSource().getDataService();
         if(service==null)
             throw new DataServiceNotFoundException("No default data service has been set for data source: "+((IEntity)this.iterator().next()).getEntityDescriptor().getDataSourceDescriptor().getCodeName());
        
         // Store all entities in a single transaction
         IDataTransaction trans = service.newTransaction();
         Iterator it = this.iterator();
         while(it.hasNext())
             trans.addRefresh((IEntity)it.next());
         trans.commit();
     }   
     
     public boolean addEntity(IEntity entity)
     {
         if(this.doesAccept(entity))
             return mEntitySet.add(entity);
         else
             return false;
     }
     
     public boolean removeEntity(IEntity entity)
     {
         return mEntitySet.remove(entity);
     }
     
     public Iterator iterator()
     {
         return mEntitySet.iterator();
     }
     
     public void clear()
     {
         mEntitySet.clear();
     }
         
     public int size()
     {
         return mEntitySet.size();
     }
     
     public boolean isEmpty()
     {
         return mEntitySet.isEmpty();
     }
         
     public boolean contains(IEntity entity)
     {
         return mEntitySet.contains(entity);
     }
     
     public boolean doesAccept(IEntity entity)
     {
         return !this.contains(entity);
     }
         
     public Set asSet()
     {
         return new EntityPoolSet();
     }    
         
     // Nested classes ----------------------------------------------------------
     protected class EntityPoolSet extends AbstractSet
     {
         public boolean add(Object obj)
         {
             if(obj instanceof IEntity)
                 return EntityPool.this.addEntity((IEntity)obj);
             else
                 return false;
         }
         
         public int size()
         {
             return EntityPool.this.size();
         }
         
         public Iterator iterator()
         {
             return EntityPool.this.iterator();
         }
     }
 }