/*
    Copyright (C) 2007 Grid Systems, S.A.
   
    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., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301 USA
  */
  package com.gridsystems.nextgrid.api.pom.ref;
  
  import java.util.Collections;
  import java.util.HashSet;
  import java.util.Set;
  import java.util.concurrent.locks.Condition;
  import java.util.concurrent.locks.Lock;
  import java.util.concurrent.locks.ReadWriteLock;
  import java.util.concurrent.locks.ReentrantLock;
  import java.util.concurrent.locks.ReentrantReadWriteLock;
  
  import org.apache.commons.logging.Log;
  import org.apache.commons.logging.LogFactory;
  
  import nextgrid.api.pom.Process;
  import nextgrid.api.pom.Reference;
  
  /**
   * ReferenceSupport type.
   *
   * @param <T> The referenced type
   * @author Rodrigo Ruiz
   */
  public abstract class ReferenceSupport<T> implements Reference<T> {
  
    /**
     * Serial Version UID.
     */
    private static final long serialVersionUID = 4543296708806798851L;
  
    /**
     * Enactor logger.
     */
    protected static  final Log LOG = LogFactory.getLog("ENACTOR");
  
    /**
     * The readers collection.
     */
    private Set<Process> readers;
  
    /**
     * The writers collection.
     */
    private Set<Process> writers;
  
    /**
     * Used for locking.
     */
    private ReadWriteLock rwLock = new ReentrantReadWriteLock(true);
  
    /**
     * Used for availability synchronisation.
     */
    private Lock availLock = new ReentrantLock(true);
  
    /**
     * Used for availability synchronisation.
     */
    private Condition cAvailable = availLock.newCondition();
  
    /**
     * Available flag.
     */
    boolean available;
  
    /**
     * Creates a new instance with default reader and writer collections.
     *
     */
    public ReferenceSupport() {
      this(new HashSet<Process>(), new HashSet<Process>());
    }
  
    /**
     * Creates a new instance, allowing to specify the readers and writers
     * instances to use.
     *
     * @param readers A set to store reader processes
     * @param writers A set to store writer processes
     */
    public ReferenceSupport(Set<Process> readers,
      Set<Process> writers) {
 
     this.readers = readers;
     this.writers = writers;
   }
 
   /**
    * {@inheritDoc}
    */
   public final void clearLinks() {
     this.readers.clear();
     this.writers.clear();
   }
 
   /**
    * {@inheritDoc}
    */
   public final void dispose() {
   }
 
   /**
    * {@inheritDoc}
    */
   public final void reset() {
     this.setValue(null);
     this.setAvailable(false);
   }
 
   /**
    * {@inheritDoc}
    */
   public final void addReader(Process reader) {
     this.readers.add(reader);
   }
 
   /**
    * {@inheritDoc}
    */
   public final void addWriter(Process writer) {
     this.writers.add(writer);
   }
 
   /**
    * {@inheritDoc}
    */
   public final Set<Process> getReaders() {
     return Collections.unmodifiableSet(this.readers);
   }
 
   /**
    * {@inheritDoc}
    */
   public final Set<Process> getWriters() {
     return Collections.unmodifiableSet(this.writers);
   }
 
   /**
    * {@inheritDoc}
    */
   public final void removeReader(Process reader) {
     this.readers.remove(reader);
   }
 
   /**
    * {@inheritDoc}
    */
   public final void removeWriter(Process writer) {
     this.writers.remove(writers);
   }
 
   /**
    * {@inheritDoc}
    */
   public Lock readLock() {
     return rwLock.readLock();
   }
 
   /**
    * {@inheritDoc}
    */
   public Lock writeLock() {
     return rwLock.writeLock();
   }
 
   /**
    * {@inheritDoc}
    */
   public boolean isAvailable() {
     availLock.lock();
     try {
       return this.available;
     } finally {
       availLock.unlock();
     }
   }
 
   /**
    * {@inheritDoc}
    */
   public void setAvailable(boolean available) {
     availLock.lock();
     try {
       this.available = available;
       if (available) {
         LOG.debug("Signaling " + this);
         cAvailable.signalAll();
       }
     } finally {
       availLock.unlock();
     }
   }
 
   /**
    * {@inheritDoc}
    */
   public void waitAvailable() throws InterruptedException {
     availLock.lock();
     try {
       if (!this.isAvailable()) {
         LOG.debug("Waiting for " + this);
         cAvailable.await();
       }
     } finally {
       availLock.unlock();
     }
   }
 
   /**
    * {@inheritDoc}
    */
   @SuppressWarnings("unchecked")
   public ReferenceSupport<T> copy() {
     try {
       ReferenceSupport<T> copy = (ReferenceSupport<T>)clone();
 
       copy.rwLock = new ReentrantReadWriteLock(true);
       copy.availLock = new ReentrantLock(true);
       copy.cAvailable = copy.availLock.newCondition();
 
       copy.readers = new HashSet<Process>(this.readers);
       copy.writers = new HashSet<Process>(this.writers);
 
       return copy;
     } catch (CloneNotSupportedException e) {
       throw new InternalError("Unexpected CloneNotSupported exception");
     }
   }
 }