/*
    * @(#) Monitor.java Jan 15, 2004
    * 
    * Copyright (c) 2003 Delft University of Technology Jaffalaan 5, 2628 BX Delft,
    * the Netherlands All rights reserved.
    * 
    * This software is proprietary information of Delft University of Technology
    * The code is published under the General Public License
    */
  package nl.tudelft.simulation.language.concurrent;
  
  import java.util.HashMap;
  import java.util.Map;
  
  /***
   * In the Java programming language there is a lock associated with every
   * object. The language does not provide a way to perform separate lock and
   * unlock operations; instead, they are implicitly performed by high-level
   * constructs that always arrange to pair such operations correctly. This
   * Monitor class, however, provides separate monitorenter and monitorexit
   * instructions that implement the lock and unlock operations.) <br>
   * (c) copyright 2003 <a href="http://www.simulation.tudelft.nl">Delft
   * University of Technology </a>, the Netherlands. <br>
   * See for project information <a
   * href="http://www.simulation.tudelft.nl">www.simulation.tudelft.nl </a> <br>
   * License of use: <a href="http://www.gnu.org/copyleft/gpl.html">General Public
   * License (GPL) </a>, no warranty <br>
   * 
   * @author <a href="http://www.simulation.tudelft.nl/people/jacobs.html">Peter
   *         Jacobs </a>
   * @version 1.0 Jan 15, 2004 <br>
   * @since 1.3
   */
  public final class Monitor
  {
  	/*** the locks held */
  	private static Map locks = new HashMap();
  
  	/***
  	 * constructs a new Monitor
  	 */
  	private Monitor()
  	{
  		super();
  		//unreachable code
  	}
  
  	/***
  	 * locks an object for the current thread
  	 * 
  	 * @param object the object to lock
  	 */
  	public static void lock(final Object object)
  	{
  		Monitor.lock(object, Thread.currentThread());
  	}
  
  	/***
  	 * locks an object for the given requestor.
  	 * 
  	 * @param object the object to lock.
  	 * @param requestor the requesting thread.
  	 */
  	public static void lock(final Object object, final Thread requestor)
  	{
  		synchronized (Monitor.locks)
  		{
  			if (!Monitor.locks.containsKey(object))
  			{
  				Monitor.locks.put(object, new MonitorThread(requestor, object));
  			} else
  			{
  				MonitorThread thread = (MonitorThread) Monitor.locks
  						.get(object);
  				if (thread.getOwner().equals(requestor))
  				{
  					thread.increaseCounter();
  				} else
  				{
  					synchronized (object)
  					{
  						//We wait until we gained access to the monitor
  						Monitor.locks.put(object, new MonitorThread(requestor,
  								object));
  					}
  				}
  			}
  		}
  	}
  
  	/***
  	 * unlocks an object locked by the current Thread
  	 * 
  	 * @param object the object to unlock
  	 */
  	public static void unlock(final Object object)
  	{
  		Monitor.unlock(object, Thread.currentThread());
  	}
 
 	/***
 	 * unlocks an object locked by owner.
 	 * 
 	 * @param object the object to unlock.
 	 * @param owner the owning thread.
 	 */
 	public static void unlock(final Object object, final Thread owner)
 	{
 		synchronized (Monitor.locks)
 		{
 			MonitorThread thread = (MonitorThread) Monitor.locks.get(object);
 			if (thread == null)
 			{
 				throw new IllegalMonitorStateException("object(" + object
 						+ ") is not locked");
 			}
 			if (!thread.getOwner().equals(owner))
 			{
 				throw new IllegalMonitorStateException(owner + " cannot"
 						+ " unlock object owned by " + thread.getOwner());
 			}
 			thread.decreaseCounter();
 			if (thread.getCounter() == 0)
 			{
 				thread.interrupt();
 				Monitor.locks.remove(object);
 			}
 		}
 	}
 
 	/***
 	 * A MonitorThread is used to lock an object
 	 */
 	private static class MonitorThread extends Thread
 	{
 		/*** the monitor to use */
 		private Object object = null;
 
 		/*** the owning thread */
 		private Thread owner = null;
 
 		/*** the counter */
 		private int counter = 0;
 
 		/***
 		 * constructs a new MonitorThread
 		 * 
 		 * @param owner the owning thread
 		 * @param object the object
 		 */
 		public MonitorThread(final Thread owner, final Object object)
 		{
 			super("MonitorThread on " + object.getClass());
 			this.setDaemon(true);
 			this.owner = owner;
 			synchronized (object)
 			{
 				this.object = object;
 				this.counter++;
 				this.start();
 			}
 			synchronized (owner)
 			{
 				try
 				{
 					this.owner.wait();
 				} catch (InterruptedException exception)
 				{
 					exception = null;
 					//This interrupted exception is thrown because this monitor
 					// thread
 					//has started and interrupted its constructor. We now know
 					//object is locked and may therefore return.
 				}
 			}
 		}
 
 		/***
 		 * @return Returns the counter.
 		 */
 		public synchronized int getCounter()
 		{
 			return this.counter;
 		}
 
 		/***
 		 * decreases the counter with one
 		 */
 		public synchronized void decreaseCounter()
 		{
 			this.counter = Math.max(0, this.counter - 1);
 		}
 
 		/***
 		 * increases the counter of this thread with one
 		 */
 		public synchronized void increaseCounter()
 		{
 			this.counter++;
 		}
 
 		/***
 		 * @return Returns the owning thread.
 		 */
 		public Thread getOwner()
 		{
 			return this.owner;
 		}
 
 		/***
 		 * @see java.lang.Runnable#run()
 		 */
 		public void run()
 		{
 			try
 			{
 				//We lock the object
 				synchronized (this.object)
 				{
 					//Since we have locked the object, we can now return
 					//the constructor
 					this.owner.interrupt();
 
 					//We join
 					this.join();
 				}
 			} catch (Exception exception)
 			{
 				// This is OK.. We use this construction in the
 				// MonitorTest.unlock to release a lock
 				exception = null;
 			}
 		}
 	}
 }