package org.apache.ojb.odmg;
   
   /* 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 org.apache.commons.lang.SerializationUtils;
  import org.apache.commons.lang.builder.ToStringBuilder;
  import org.apache.commons.lang.builder.ToStringStyle;
  import org.apache.ojb.broker.Identity;
  import org.apache.ojb.broker.PBKey;
  import org.apache.ojb.broker.PersistenceBroker;
  import org.apache.ojb.broker.PersistenceBrokerFactory;
  import org.apache.ojb.broker.util.collections.ManageableArrayList;
  import org.apache.ojb.broker.util.configuration.Configuration;
  import org.apache.ojb.broker.util.configuration.ConfigurationException;
  import org.apache.ojb.broker.util.configuration.Configurator;
  import org.apache.ojb.broker.util.factory.ConfigurableFactory;
  import org.apache.ojb.broker.util.logging.Logger;
  import org.apache.ojb.broker.util.logging.LoggerFactory;
  import org.apache.ojb.odmg.locking.LockManager;
  import org.apache.ojb.odmg.locking.LockManagerFactory;
  import org.apache.ojb.odmg.oql.EnhancedOQLQuery;
  import org.apache.ojb.odmg.oql.OQLQueryImpl;
  import org.odmg.DArray;
  import org.odmg.DBag;
  import org.odmg.DList;
  import org.odmg.DMap;
  import org.odmg.DSet;
  import org.odmg.Database;
  import org.odmg.DatabaseClosedException;
  import org.odmg.Implementation;
  import org.odmg.ODMGRuntimeException;
  import org.odmg.Transaction;
  
  
  /**
   * Default implementation of the {@link Implementation} interface.
   *
   * @author <a href="mailto:thma@apache.org">Thomas Mahler<a>
   * @author <a href="mailto:mattbaird@yahoo.com">Matthew Baird</a>
   * @author <a href="mailto:armin@codeAuLait.de">Armin Waibel</a>
   *
   * @version $Id: ImplementationImpl.java,v 1.1 2007-08-24 22:17:37 ewestfal Exp $
   */
  public class ImplementationImpl implements ImplementationExt
  {
      private Logger log = LoggerFactory.getLogger(ImplementationImpl.class);
  
  //    private List usedDatabases = new ArrayList();
      private DatabaseImpl currentDatabase;
      private Configurator configurator;
      private OJBTxManager ojbTxManager;
      private LockManager lockManager;
  
      private Class oqlCollectionClass;
      private boolean impliciteWriteLocks;
      private boolean implicitLocking;
      private boolean implicitLockingBackward;
      private boolean ordering;
  //    private boolean noteUserOrder;
  
      /**
       * private Constructor: use static factory method
       * getInstance() to obtain an instance
       */
      protected ImplementationImpl()
      {
          ojbTxManager = TxManagerFactory.instance();
          lockManager = LockManagerFactory.getLockManager();
          setConfigurator(PersistenceBrokerFactory.getConfigurator());
          Configuration conf = getConfigurator().getConfigurationFor(null);
          oqlCollectionClass = conf.getClass("OqlCollectionClass", ManageableArrayList.class);
          impliciteWriteLocks = (conf.getString("LockAssociations", "WRITE").equalsIgnoreCase("WRITE"));
          implicitLocking = conf.getBoolean("ImplicitLocking", true);
          ordering = conf.getBoolean("Ordering", true);
  //        noteUserOrder = conf.getBoolean("NoteUserOrder", true);
          implicitLockingBackward = conf.getBoolean("ImplicitLockingBackward", false);
          if(log.isEnabledFor(Logger.INFO))
          {
              log.info("Settings: " + this.toString());
          }
      }
  
      public OJBTxManager getTxManager()
      {
          return ojbTxManager;
      }
 
     protected LockManager getLockManager()
     {
         return lockManager;
     }
 
     protected synchronized void setCurrentDatabase(DatabaseImpl curDB)
     {
         currentDatabase = curDB;
     }
 
     protected synchronized DatabaseImpl getCurrentDatabase()
     {
         return currentDatabase;
     }
 
     public PBKey getCurrentPBKey()
     {
         return currentDatabase.getPBKey();
     }
 
     /**
      * Gets the configurator.
      * @return Returns a Configurator
      */
     public Configurator getConfigurator()
     {
         return configurator;
     }
 
     /**
      * Sets the configurator.
      * @param configurator The configurator to set
      */
     public void setConfigurator(Configurator configurator)
     {
         this.configurator = configurator;
     }
 
     /**
      * Create a <code>Transaction</code> object and associate it with the current thread.
      * @return The newly created <code>Transaction</code> instance.
      * @see Transaction
      */
     public Transaction newTransaction()
     {
         if ((getCurrentDatabase() == null))
         {
             throw new DatabaseClosedException("Database is NULL, must have a DB in order to create a transaction");
         }
         TransactionImpl tx = new TransactionImpl(this);
         try
         {
             getConfigurator().configure(tx);
         }
         catch (ConfigurationException e)
         {
             throw new ODMGRuntimeException("Error in configuration of TransactionImpl instance: " + e.getMessage());
         }
         return tx;
     }
 
     /**
      * Get the current <code>Transaction</code> for the thread.
      * @return The current <code>Transaction</code> object or null if there is none.
      * @see Transaction
      */
     public Transaction currentTransaction()
     {
         if ((getCurrentDatabase() == null))
         {
             throw new DatabaseClosedException("Database is NULL, must have a DB in order to create a transaction");
         }
         return ojbTxManager.getTransaction();
     }
 
     public boolean hasOpenTransaction()
     {
         TransactionImpl tx = ojbTxManager.getTransaction();
         return tx != null && tx.isOpen();
     }
 
     /**
      * Create a new <code>Database</code> object.
      * @return The new <code>Database</code> object.
      * @see Database
      */
     public Database newDatabase()
     {
         return new DatabaseImpl(this);
     }
 
     /**
      * Create a new <code>OQLQuery</code> object.
      * @return The new <code>OQLQuery</code> object.
      * @see org.odmg.OQLQuery
      */
     public EnhancedOQLQuery newOQLQuery()
     {
         if ((getCurrentDatabase() == null) || !getCurrentDatabase().isOpen())
         {
             throw new DatabaseClosedException("Database is not open");
         }
         return new OQLQueryImpl(this);
     }
 
     /**
      * Create a new <code>DList</code> object.
      * @return The new <code>DList</code> object.
      * @see DList
      */
     public DList newDList()
     {
         if ((getCurrentDatabase() == null))
         {
             throw new DatabaseClosedException("Database is NULL, cannot create a DList with a null database.");
         }
         return (DList) DListFactory.singleton.createCollectionOrMap(getCurrentPBKey());
     }
 
     /**
      * Create a new <code>DBag</code> object.
      * @return The new <code>DBag</code> object.
      * @see DBag
      */
     public DBag newDBag()
     {
         if ((getCurrentDatabase() == null))
         {
             throw new DatabaseClosedException("Database is NULL, cannot create a DBag with a null database.");
         }
         return (DBag) DBagFactory.singleton.createCollectionOrMap(getCurrentPBKey());
     }
 
     /**
      * Create a new <code>DSet</code> object.
      * @return The new <code>DSet</code> object.
      * @see DSet
      */
     public DSet newDSet()
     {
         if ((getCurrentDatabase() == null))
         {
             throw new DatabaseClosedException("Database is NULL, cannot create a DSet with a null database.");
         }
         return (DSet) DSetFactory.singleton.createCollectionOrMap(getCurrentPBKey());
     }
 
     /**
      * Create a new <code>DArray</code> object.
      * @return The new <code>DArray</code> object.
      * @see DArray
      */
     public DArray newDArray()
     {
         if ((getCurrentDatabase() == null))
         {
             throw new DatabaseClosedException("Database is NULL, cannot create a DArray with a null database.");
         }
         return (DArray) DArrayFactory.singleton.createCollectionOrMap(getCurrentPBKey());
     }
 
     /**
      * Create a new <code>DMap</code> object.
      * @return The new <code>DMap</code> object.
      * @see DMap
      */
     public DMap newDMap()
     {
         if ((getCurrentDatabase() == null))
         {
             throw new DatabaseClosedException("Database is NULL, cannot create a DMap with a null database.");
         }
         return (DMap) DMapFactory.singleton.createCollectionOrMap(getCurrentPBKey());
     }
 
     /**
      * Get a <code>String</code> representation of the object's identifier.
      * OJB returns the serialized Identity of the object.
      * @param obj The object whose identifier is being accessed.
      * @return The object's identifier in the form of a String
      */
     public String getObjectId(Object obj)
     {
         Identity oid = null;
         PersistenceBroker broker = null;
 
         try
         {
             if (getCurrentDatabase() != null)
             {
                 /**
                  * is there an open database we are calling getObjectId against? if yes, use it
                  */
                 broker = PersistenceBrokerFactory.createPersistenceBroker(getCurrentDatabase().getPBKey());
             }
             else
             {
                 log.warn("Can't find open database, try to use the default configuration");
                 /**
                  * otherwise, use default.
                  */
                 broker = PersistenceBrokerFactory.defaultPersistenceBroker();
             }
 
             oid = broker.serviceIdentity().buildIdentity(obj);
         }
         finally
         {
             if(broker != null)
             {
                 broker.close();
             }
         }
         return new String(SerializationUtils.serialize(oid));
     }
 
     /**
      * Returns the current used database or null.
      */
     public Database getDatabase(Object obj)
     {
         /* @todo enhance functionality */
         return getCurrentDatabase();
     }
 
     /**
      * Register opened database via the PBKey.
      */
     protected synchronized void registerOpenDatabase(DatabaseImpl newDB)
     {
         DatabaseImpl old_db = getCurrentDatabase();
         if (old_db != null)
         {
             try
             {
                 if (old_db.isOpen())
                 {
                     log.warn("## There is still an opened database, close old one ##");
                     old_db.close();
                 }
             }
             catch (Throwable t)
             {
                 //ignore
             }
         }
         if (log.isDebugEnabled()) log.debug("Set current database " + newDB + " PBKey was " + newDB.getPBKey());
         setCurrentDatabase(newDB);
 //        usedDatabases.add(newDB.getPBKey());
     }
 
     /**
      * <strong>Note:</strong> Method behavior changed between version 1.0.3 and
      * 1.0.4. Now this method is used to set the global property <em>implicit locking</em>,
      * use method {@link TransactionExt#setImplicitLocking(boolean)} to set the property
      * for a running transaction.
      *
      * @see ImplementationExt#setImplicitLocking(boolean)
      */
 	public void setImplicitLocking(boolean value)
 	{
         if(implicitLockingBackward)
         {
             ((TransactionExt)currentTransaction()).setImplicitLocking(value);
         }
         else
         {
             this.implicitLocking = value;
         }
 	}
 
     /**
      * @see ImplementationExt#isImplicitLocking()
      */
     public boolean isImplicitLocking()
     {
         return implicitLocking;
     }
 
     /**
      * @see ImplementationExt#getOqlCollectionClass()
      */
     public Class getOqlCollectionClass()
     {
         return oqlCollectionClass;
     }
 
     /**
      * @see ImplementationExt#setOqlCollectionClass(Class)
      */
     public void setOqlCollectionClass(Class oqlCollectionClass)
     {
         this.oqlCollectionClass = oqlCollectionClass;
     }
 
     /**
      * @see ImplementationExt#setImpliciteWriteLocks(boolean)
      */
     public void setImpliciteWriteLocks(boolean impliciteWriteLocks)
     {
         this.impliciteWriteLocks = impliciteWriteLocks;
     }
 
     /**
      * @see ImplementationExt#isImpliciteWriteLocks()
      */
     public boolean isImpliciteWriteLocks()
     {
         return impliciteWriteLocks;
     }
 
     public boolean isOrdering()
     {
         return ordering;
     }
 
     public void setOrdering(boolean ordering)
     {
         this.ordering = ordering;
     }
 
 //    public boolean isNoteUserOrder()
 //    {
 //        return noteUserOrder;
 //    }
 //
 //    public void setNoteUserOrder(boolean noteUserOrder)
 //    {
 //        this.noteUserOrder = noteUserOrder;
 //    }
 
     /**
      * Allow to use method {@link #setImplicitLocking(boolean)} in the same way
      * as before version 1.0.4 - if set 'true', recommended setting is 'false'.
      *
      * @deprecated is only for backward compatibility with older versions (before 1.0.4)
      * and will be removed in future versions.
      */
     public void setImplicitLockingBackward(boolean implicitLockingBackward)
     {
         this.implicitLockingBackward = implicitLockingBackward;
     }
 
     public String toString()
     {
         return new ToStringBuilder(this, ToStringStyle.MULTI_LINE_STYLE)
                 .append("implicitLocking", isImplicitLocking())
                 .append("implicitWriteLocks", isImpliciteWriteLocks())
                 .append("ordering", isOrdering())
                 .append("oqlCollectionClass", getOqlCollectionClass())
                 .append("txManager", getTxManager())
                 .append("lockManager", getLockManager())
                 .toString();
     }
 
 
     //*****************************************************
     // inner classes
     //*****************************************************
 
     abstract static class BaseFactory extends ConfigurableFactory
     {
         Object createCollectionOrMap()
         {
             return this.createNewInstance();
         }
 
         Object createCollectionOrMap(PBKey key)
         {
             return createNewInstance(PBKey.class, key);
         }
     }
 
     static final class DListFactory extends BaseFactory
     {
         static final BaseFactory singleton = new DListFactory();
         protected String getConfigurationKey()
         {
             return "DListClass";
         }
     }
 
     static final class DArrayFactory extends BaseFactory
     {
         static final BaseFactory singleton = new DArrayFactory();
         protected String getConfigurationKey()
         {
             return "DArrayClass";
         }
     }
 
     static final class DBagFactory extends BaseFactory
     {
         static final BaseFactory singleton = new DBagFactory();
         protected String getConfigurationKey()
         {
             return "DBagClass";
         }
     }
 
     static final class DSetFactory extends BaseFactory
     {
         static final BaseFactory singleton = new DSetFactory();
         protected String getConfigurationKey()
         {
             return "DSetClass";
         }
     }
 
     static final class DMapFactory extends BaseFactory
     {
         static final BaseFactory singleton = new DMapFactory();
         protected String getConfigurationKey()
         {
             return "DMapClass";
         }
     }
 }