package org.apache.ojb.odmg.collections;
   
   /* Copyright 2002-2005 The Apache Software Foundation
    *
    * Licensed under the Apache License, Version 2.0 (the "License");
    * you may not use this file except in compliance with the License.
    * You may obtain a copy of the License at
    *
    *     http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   */
  
  import java.io.Serializable;
  import java.util.AbstractSet;
  import java.util.ArrayList;
  import java.util.Iterator;
  import java.util.List;
  import java.util.Vector;
  import java.util.Collection;
  
  import org.apache.ojb.broker.PBKey;
  import org.apache.ojb.broker.PersistenceBroker;
  import org.apache.ojb.broker.PersistenceBrokerAware;
  import org.apache.ojb.broker.PersistenceBrokerException;
  import org.apache.ojb.broker.ManageableCollection;
  import org.apache.ojb.broker.core.ValueContainer;
  import org.apache.ojb.broker.metadata.ClassDescriptor;
  import org.apache.ojb.broker.metadata.FieldDescriptor;
  import org.apache.ojb.broker.query.Criteria;
  import org.apache.ojb.broker.query.Query;
  import org.apache.ojb.broker.query.QueryByCriteria;
  import org.apache.ojb.broker.util.logging.Logger;
  import org.apache.ojb.broker.util.logging.LoggerFactory;
  import org.apache.ojb.odmg.PBCapsule;
  import org.apache.ojb.odmg.TransactionImpl;
  import org.apache.ojb.odmg.TxManagerFactory;
  import org.apache.ojb.odmg.RuntimeObject;
  import org.apache.ojb.odmg.oql.OQLQueryImpl;
  import org.odmg.DCollection;
  import org.odmg.DList;
  import org.odmg.DSet;
  import org.odmg.ODMGRuntimeException;
  import org.odmg.OQLQuery;
  import org.odmg.Transaction;
  
  
  /**
   *
   */
  public class DSetImpl extends AbstractSet implements DSet, Serializable, PersistenceBrokerAware, ManageableCollection
  {
  	private static final long serialVersionUID = -4459673364598652639L;
  
      private transient Logger log;
  
      private Integer id;
      private List elements;
  
      private PBKey pbKey;
  
      /**
       * Used by PB-Kernel to instantiate ManageableCollections
       * FOR INTERNAL USE ONLY
       */
      public DSetImpl()
      {
          super();
          elements = new ArrayList();
  //        if(getTransaction() == null)
  //        {
  //            throw new TransactionNotInProgressException("Materialization of DCollection instances must be done" +
  //                    " within a odmg-tx");
  //        }
          getPBKey();
      }
  
      /**
       * DSetImpl constructor comment.
       */
      public DSetImpl(PBKey pbKey)
      {
          this();
          this.pbKey = pbKey;
      }
  
      protected Logger getLog()
      {
          if (log == null)
          {
              log = LoggerFactory.getLogger(DSetImpl.class);
          }
          return log;
      }
  
     private DSetEntry prepareEntry(Object obj)
     {
         return new DSetEntry(this, obj);
     }
 
     protected TransactionImpl getTransaction()
     {
         return TxManagerFactory.instance().getTransaction();
     }
 
     protected boolean checkForOpenTransaction(TransactionImpl tx)
     {
         boolean result = false;
         if(tx != null && tx.isOpen())
         {
             result = true;
         }
         return result;
     }
 
     public PBKey getPBKey()
     {
         if(pbKey == null)
         {
             TransactionImpl tx = getTransaction();
             if(tx != null && tx.isOpen())
             {
                 pbKey = tx.getBroker().getPBKey();
             }
         }
         return pbKey;
     }
 
     public void setPBKey(PBKey pbKey)
     {
         this.pbKey = pbKey;
     }
 
     public boolean remove(Object o)
     {
         return super.remove(o);
     }
 
     public boolean removeAll(Collection c)
     {
         return super.removeAll(c);
     }
 
     public boolean add(Object o)
     {
         if (!this.contains(o))
         {
             DSetEntry entry = prepareEntry(o);
             elements.add(entry);
             // if we are in a transaction: get locks !
             TransactionImpl tx = getTransaction();
             if ((tx != null) && (tx.isOpen()))
             {
                 List regList = tx.getRegistrationList();
                 RuntimeObject rt = new RuntimeObject(this, tx);
                 tx.lockAndRegister(rt, Transaction.WRITE, false, regList);
 
                 rt = new RuntimeObject(o, tx);
                 tx.lockAndRegister(rt, Transaction.READ, regList);
 
                 rt = new RuntimeObject(entry, tx, true);
                 tx.lockAndRegister(rt, Transaction.WRITE, false, regList);
             }
             return true;
         }
         else
         {
             return false;
         }
     }
 
     /**
      * Create a new <code>DSet</code> object that contains the elements of this
      * collection minus the elements in <code>otherSet</code>.
      * @param	otherSet	A set containing elements that should not be in the result set.
      * @return	A newly created <code>DSet</code> instance that contains the elements
      * of this set minus those elements in <code>otherSet</code>.
      */
     public DSet difference(DSet otherSet)
     {
         DSetImpl result = new DSetImpl(getPBKey());
         Iterator iter = this.iterator();
         while (iter.hasNext())
         {
             Object candidate = iter.next();
             if (!otherSet.contains(candidate))
             {
                 result.add(candidate);
             }
         }
         return result;
     }
 
     /**
      * Determines whether there is an element of the collection that evaluates to true
      * for the predicate.
      * @param	predicate	An OQL boolean query predicate.
      * @return	True if there is an element of the collection that evaluates to true
      * for the predicate, otherwise false.
      * @exception	org.odmg.QueryInvalidException	The query predicate is invalid.
      */
     public boolean existsElement(String predicate) throws org.odmg.QueryInvalidException
     {
         DList results = (DList) this.query(predicate);
         if (results == null || results.size() == 0)
             return false;
         else
             return true;
     }
 
     public List getElements()
     {
         return elements;
     }
 
     public void setElements(List elements)
     {
         this.elements = elements;
     }
 
     public Integer getId()
     {
         return id;
     }
 
     /**
      * Create a new <code>DSet</code> object that is the set intersection of this
      * <code>DSet</code> object and the set referenced by <code>otherSet</code>.
      * @param	otherSet	The other set to be used in the intersection operation.
      * @return	A newly created <code>DSet</code> instance that contains the
      * intersection of the two sets.
      */
     public DSet intersection(DSet otherSet)
     {
         DSet union = this.union(otherSet);
         DSetImpl result = new DSetImpl(getPBKey());
         Iterator iter = union.iterator();
         while (iter.hasNext())
         {
             Object candidate = iter.next();
             if (this.contains(candidate) && otherSet.contains(candidate))
             {
                 result.add(candidate);
             }
         }
         return result;
     }
 
     /**
      * Returns an iterator over the elements in this collection.  There are no
      * guarantees concerning the order in which the elements are returned
      * (unless this collection is an instance of some class that provides a
      * guarantee).
      *
      * @return an <tt>Iterator</tt> over the elements in this collection
      */
     public Iterator iterator()
     {
         return new DSetIterator(this);
     }
 
     /**
      * Determine whether this set is a proper subset of the set referenced by
      * <code>otherSet</code>.
      * @param	otherSet	Another set.
      * @return True if this set is a proper subset of the set referenced by
      * <code>otherSet</code>, otherwise false.
      */
     public boolean properSubsetOf(org.odmg.DSet otherSet)
     {
         return (this.size() > 0 && this.size() < otherSet.size() && this.subsetOf(otherSet));
     }
 
     /**
      * Determine whether this set is a proper superset of the set referenced by
      * <code>otherSet</code>.
      * @param	otherSet	Another set.
      * @return True if this set is a proper superset of the set referenced by
      * <code>otherSet</code>, otherwise false.
      */
     public boolean properSupersetOf(org.odmg.DSet otherSet)
     {
         return (otherSet.size() > 0 && otherSet.size() < this.size() && this.supersetOf(otherSet));
     }
 
     /**
      * Evaluate the boolean query predicate for each element of the collection and
      * return a new collection that contains each element that evaluated to true.
      * @param	predicate	An OQL boolean query predicate.
      * @return	A new collection containing the elements that evaluated true for the predicate.
      * @exception	org.odmg.QueryInvalidException	The query predicate is invalid.
      */
     public DCollection query(String predicate) throws org.odmg.QueryInvalidException
     {
         // 1.build complete OQL statement
         String oql = "select all from java.lang.Object where " + predicate;
         TransactionImpl tx = getTransaction();
 
         OQLQuery predicateQuery = tx.getImplementation().newOQLQuery();
 
         PBCapsule capsule = new PBCapsule(tx.getImplementation().getCurrentPBKey(), tx);
         PersistenceBroker broker = capsule.getBroker();
 
         try
         {
             predicateQuery.create(oql);
             Query pQ = ((OQLQueryImpl) predicateQuery).getQuery();
             Criteria pCrit = pQ.getCriteria();
 
             Criteria allElementsCriteria = this.getPkCriteriaForAllElements(broker);
             // join selection of elements with predicate criteria:
             pCrit.addAndCriteria(allElementsCriteria);
             Class clazz = this.getElementsExtentClass(broker);
             Query q = new QueryByCriteria(clazz, pCrit);
             if (log.isDebugEnabled()) log.debug(q.toString());
             // 2. perfom query
             return (DSetImpl) broker.getCollectionByQuery(DSetImpl.class, q);
         }
         catch (PersistenceBrokerException e)
         {
             throw new ODMGRuntimeException(e.getMessage());
         }
         finally
         {
             capsule.destroy();
         }
     }
 
     private Criteria getPkCriteriaForAllElements(PersistenceBroker broker)
     {
         try
         {
             Criteria crit = null;
             for (int i = 0; i < elements.size(); i++)
             {
                 DListEntry entry = (DListEntry) elements.get(i);
                 Object obj = entry.getRealSubject();
                 ClassDescriptor cld = broker.getClassDescriptor(obj.getClass());
 
                 FieldDescriptor[] pkFields = cld.getPkFields();
                 ValueContainer[] pkValues = broker.serviceBrokerHelper().getKeyValues(cld, obj);
 
                 Criteria criteria = new Criteria();
                 for (int j = 0; j < pkFields.length; j++)
                 {
                     FieldDescriptor fld = pkFields[j];
                     criteria.addEqualTo(fld.getPersistentField().getName(), pkValues[j].getValue());
                 }
 
                 if (crit == null)
                     crit = criteria;
                 else
                     crit.addOrCriteria(criteria);
             }
             return crit;
         }
         catch (PersistenceBrokerException e)
         {
             log.error(e);
             return null;
         }
     }
 
     private Class getElementsExtentClass(PersistenceBroker broker) throws PersistenceBrokerException
     {
         // we ll have to compute the most general extent class here !!!
         DListEntry entry = (DListEntry) elements.get(0);
         Class elementsClass = entry.getRealSubject().getClass();
         Class extentClass = broker.getTopLevelClass(elementsClass);
         return extentClass;
     }
 
 
     /**
      * Access all of the elements of the collection that evaluate to true for the
      * provided query predicate.
      * @param	predicate	An OQL boolean query predicate.
      * @return	An iterator used to iterate over the elements that evaluated true for the predicate.
      * @exception	org.odmg.QueryInvalidException	The query predicate is invalid.
      */
     public Iterator select(String predicate) throws org.odmg.QueryInvalidException
     {
         return this.query(predicate).iterator();
     }
 
     /**
      * Selects the single element of the collection for which the provided OQL query
      * predicate is true.
      * @param	predicate	An OQL boolean query predicate.
      * @return The element that evaluates to true for the predicate. If no element
      * evaluates to true, null is returned.
      * @exception	org.odmg.QueryInvalidException	The query predicate is invalid.
      */
     public Object selectElement(String predicate) throws org.odmg.QueryInvalidException
     {
         return ((DList) this.query(predicate)).get(0);
     }
 
     /**
      * Sets the elements.
      * @param elements The elements to set
      */
     public void setElements(Vector elements)
     {
         this.elements = elements;
     }
 
     /**
      * Sets the id.
      * @param id The id to set
      */
     public void setId(Integer id)
     {
         this.id = id;
     }
 
     /**
      * Returns the number of elements in this collection.  If this collection
      * contains more than <tt>Integer.MAX_VALUE</tt> elements, returns
      * <tt>Integer.MAX_VALUE</tt>.
      *
      * @return the number of elements in this collection
      */
     public int size()
     {
         return elements.size();
     }
 
     /**
      * Determine whether this set is a subset of the set referenced by <code>otherSet</code>.
      * @param	otherSet	Another set.
      * @return True if this set is a subset of the set referenced by <code>otherSet</code>,
      * otherwise false.
      */
     public boolean subsetOf(DSet otherSet)
     {
         return otherSet.containsAll(this);
     }
 
     /**
      * Determine whether this set is a superset of the set referenced by <code>otherSet</code>.
      * @param	otherSet	Another set.
      * @return True if this set is a superset of the set referenced by <code>otherSet</code>,
      * otherwise false.
      */
     public boolean supersetOf(DSet otherSet)
     {
         return this.containsAll(otherSet);
     }
 
     /**
      * Create a new <code>DSet</code> object that is the set union of this
      * <code>DSet</code> object and the set referenced by <code>otherSet</code>.
      * @param	otherSet	The other set to be used in the union operation.
      * @return	A newly created <code>DSet</code> instance that contains the union of the two sets.
      */
     public DSet union(DSet otherSet)
     {
         DSetImpl result = new DSetImpl(getPBKey());
         result.addAll(this);
         result.addAll(otherSet);
         return result;
     }
 
 
     //***************************************************************
     // ManageableCollection interface
     //***************************************************************
 
     /**
      * add a single Object to the Collection. This method is used during reading Collection elements
      * from the database. Thus it is is save to cast anObject to the underlying element type of the
      * collection.
      */
     public void ojbAdd(Object anObject)
     {
         DSetEntry entry = prepareEntry(anObject);
         entry.setPosition(elements.size());
         elements.add(entry);
     }
 
     /**
      * adds a Collection to this collection. Used in reading Extents from the Database.
      * Thus it is save to cast otherCollection to this.getClass().
      */
     public void ojbAddAll(ManageableCollection otherCollection)
     {
         // don't use this to avoid locking
         // this.addAll((DListImpl) otherCollection);
         Iterator it = otherCollection.ojbIterator();
         while (it.hasNext())
         {
             ojbAdd(it.next());
         }
     }
 
     public void afterStore(PersistenceBroker broker) throws PersistenceBrokerException
     {
     }
 
     /**
      * returns an Iterator over all elements in the collection. Used during store and delete Operations.
      * If the implementor does not return an iterator over ALL elements, OJB cannot store and delete all elements properly.
      */
     public Iterator ojbIterator()
     {
         return this.iterator();
     }
 
     //***************************************************************
     // PersistenceBrokerAware interface
     //***************************************************************
 
     /**
      * prepare itself for persistence. Each DList entry generates an
      * {@link org.apache.ojb.broker.Identity} for the wrapped persistent
      * object.
      */
     public void beforeInsert(PersistenceBroker broker) throws PersistenceBrokerException
     {
 //        Iterator it = elements.iterator();
 //        DSetEntry entry;
 //        while (it.hasNext())
 //        {
 //            entry = (DSetEntry) it.next();
 //            entry.prepareForPersistency(broker);
 //        }
     }
 
     /**
      * noop
      */
     public void beforeUpdate(PersistenceBroker broker) throws PersistenceBrokerException
     {
     }
 
     /**
      * noop
      */
     public void beforeDelete(PersistenceBroker broker) throws PersistenceBrokerException
     {
     }
 
     /**
      * noop
      */
     public void afterUpdate(PersistenceBroker broker) throws PersistenceBrokerException
     {
     }
 
     /**
      * noop
      */
     public void afterInsert(PersistenceBroker broker) throws PersistenceBrokerException
     {
     }
 
     /**
      * noop
      */
     public void afterDelete(PersistenceBroker broker) throws PersistenceBrokerException
     {
     }
 
     /**
      * noop
      */
     public void afterLookup(PersistenceBroker broker) throws PersistenceBrokerException
     {
     }
 }