/**
    * Copyright (C) 2006 - 2010
    *   Pawel Kedzior
    *   Tomasz Kmiecik
    *   Kamil Pietak
    *   Krzysztof Sikora
    *   Adam Wos
    *   and other students of AGH University of Science and Technology
    *   as indicated in each file separately.
   *
   * This file is part of jAgE.
   *
   * jAgE is free software: you can redistribute it and/or modify
   * it under the terms of the GNU General Public License as published by
   * the Free Software Foundation, either version 3 of the License, or
   * (at your option) any later version.
   *
   * jAgE 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 General Public License for more details.
   *
   * You should have received a copy of the GNU General Public License
   * along with jAgE.  If not, see http://www.gnu.org/licenses/
   */
  /*
   * File: ReaderWriterLock.java
   * Created: 2008-10-07
   * Author: awos
   * $Id: ReaderWriterLock.java 1013 2011-10-20 22:37:38Z faber $
   */
  
  package org.jage.util;
  
  import java.util.HashMap;
  import java.util.Map;
  
  /**
   * <tt>ReaderWriterLock</tt> solves the classic problem of readers and writers. <br>
   * It prevents starvation of readers and writers.
   * <p>
   * Assumptions: <br>
   * <li>If there are any waiting writers new readers have to wait (at least) until the first of them finishes writing
   * <li>If there are any waiting readers they will be resumed before the next writing
   * 
   * @author AGH AgE Team
   */
  public class ReaderWriterLock {
  
  	/**
  	 * Number of readers which have set the lock.
  	 */
  	private int readerCount = 0;
  
  	/**
  	 * Threads of all readers key: thread of a reader value: number of reader locks aquired by the thread
  	 */
  	private final Map<Thread, Integer> readersToCounts = new HashMap<Thread, Integer>();
  
  	/**
  	 * Indicates that writer lock have been set.
  	 */
  	private boolean writerLock = false;
  
  	/**
  	 * Number of readers waiting.
  	 */
  	private int waitingReaders = 0;
  
  	/**
  	 * Number of writers waiting.
  	 */
  	private int waitingWriters = 0;
  
  	/**
  	 * Number of readers to be woken.
  	 */
  	private int wakeUpReaders = 0;
  
  	/**
  	 * Number of writers to be woken. Actually only zero and 1 is allowed.
  	 */
  	private int wakeUpWriters = 0;
  
  	/**
  	 * Common monitor for all kinds of events. _monitor.notifyAll() must be called whenever an event occurs.
  	 */
  	private final Object monitor = new Object();
  
  	/**
  	 * Constructor.
  	 */
  	public ReaderWriterLock() {
  		// empty
  	}
  
  	/**
  	 * Waits for waking up all readers or writers, which should be woken. In order to call this, _monitor must be
  	 * synchronized.
 	 * 
 	 * @throws InterruptedException
 	 */
 	private void waitForWakingUp() throws InterruptedException {
 		while (wakeUpWriters != 0 || wakeUpReaders != 0) {
 			monitor.wait();
 		}
 	}
 
 	/**
 	 * Acquires reader's lock.
 	 * 
 	 * @throws InterruptedException
 	 */
 	public void acquireReaderLock() throws InterruptedException {
 		synchronized (monitor) {
 			waitForWakingUp();
 
 			// If a writer aquired a lock then wait,
 			// if a writer is waiting then also wait,
 			// if you already aquired the lock in this thread, than
 			// don't wait, even if there is a writer waiting because it will
 			// cause a deadlock.
 			if (writerLock || (waitingWriters > 0 && !hasReaderLock(Thread.currentThread()))) {
 				waitingReaders++;
 				try {
 					do {
 						monitor.wait();
 						if (wakeUpReaders > 0) {
 							wakeUpReaders--;
 							monitor.notifyAll();
 							break;
 						}
 					} while (true);
 				} finally {
 					waitingReaders--;
 				}
 			}
 			readerCount++;
 			addReader(Thread.currentThread());
 		}
 	}
 
 	private void addReader(Thread thread) {
 		Integer count = readersToCounts.get(thread);
 		if (count == null) {
 			readersToCounts.put(thread, Integer.valueOf(1));
 		} else {
 			readersToCounts.put(thread, Integer.valueOf(count.intValue() + 1));
 		}
 	}
 
 	private void removeReader(Thread thread) {
 		Integer count = readersToCounts.get(thread);
 		readersToCounts.put(thread, Integer.valueOf(count.intValue() - 1));
 	}
 
 	private boolean hasReaderLock(Thread thread) {
 		Integer count = readersToCounts.get(thread);
 		if ((count != null) && (count.intValue() > 0)) {
 			return true;
 		}
 		return false;
 	}
 
 	/**
 	 * Releases reader's lock.
 	 * 
 	 * @throws InterruptedException
 	 */
 	public void releaseReaderLock() throws InterruptedException {
 		synchronized (monitor) {
 			waitForWakingUp();
 			// when all which should be woken, are woken then:
 			readerCount--;
 			removeReader(Thread.currentThread());
 			if (readerCount == 0) {
 				if (waitingWriters >= 1) {
 					wakeUpWriters = 1;
 					monitor.notifyAll();
 				}
 			}
 		}
 	}
 
 	/**
 	 * Acquires writer's lock.
 	 * 
 	 * @throws InterruptedException
 	 */
 	public void acquireWriterLock() throws InterruptedException {
 		synchronized (monitor) {
 			waitForWakingUp();
 
 			if (readerCount > 0 || writerLock) {
 				waitingWriters++;
 				try {
 					do {
 						monitor.wait();
 						if (wakeUpWriters == 1) {
 							wakeUpWriters = 0;
 							monitor.notifyAll();
 							break;
 						}
 					} while (true);
 				} finally {
 					waitingWriters--;
 				}
 			}
 			writerLock = true;
 		}
 	}
 
 	/**
 	 * Releases the writer's lock.
 	 * 
 	 * @throws InterruptedException
 	 */
 	public void releaseWriterLock() throws InterruptedException {
 		synchronized (monitor) {
 			waitForWakingUp();
 
 			writerLock = false;
 			if (waitingReaders > 0) {
 				wakeUpReaders = waitingReaders;
 				monitor.notifyAll();
 			} else {
 				if (waitingWriters >= 1) {
 					wakeUpWriters = 1;
 					monitor.notifyAll();
 				}
 			}
 		}
 	}
 }