/*
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER.
 * 
 * Copyright 1997-2007 Sun Microsystems, Inc. All rights reserved.
 * 
 * The contents of this file are subject to the terms of either the GNU
 * General Public License Version 2 only ("GPL") or the Common Development
 * and Distribution License("CDDL") (collectively, the "License").  You
 * may not use this file except in compliance with the License. You can obtain
 * a copy of the License at https://glassfish.dev.java.net/public/CDDL+GPL.html
 * or glassfish/bootstrap/legal/LICENSE.txt.  See the License for the specific
 * language governing permissions and limitations under the License.
 * 
 * When distributing the software, include this License Header Notice in each
 * file and include the License file at glassfish/bootstrap/legal/LICENSE.txt.
 * Sun designates this particular file as subject to the "Classpath" exception
 * as provided by Sun in the GPL Version 2 section of the License file that
 * accompanied this code.  If applicable, add the following below the License
 * Header, with the fields enclosed by brackets [] replaced by your own
 * identifying information: "Portions Copyrighted [year]
 * [name of copyright owner]"
 * 
 * Contributor(s):
 * 
 * If you wish your version of this file to be governed by only the CDDL or
 * only the GPL Version 2, indicate your decision by adding "[Contributor]
 * elects to include this software in this distribution under the [CDDL or GPL
 * Version 2] license."  If you don't indicate a single choice of license, a
 * recipient has the option to distribute your version of this file under
 * either the CDDL, the GPL Version 2 or to extend the choice of license to
 * its licensees as provided above.  However, if you add GPL Version 2 code
 * and therefore, elected the GPL Version 2 license, then the option applies
 * only if the new code is made subject to such option by the copyright
 * holder.
 */

/*
 * ConnectionImpl.java
 *
 * Create on March 3, 2000
 */

package com.sun.jdo.spi.persistence.utility;

/**
 * This class defines a thread-safe double linked-list.
 * The list is usable by any class that implements the
 * com.forte.util.Linkable interface.  This class allows
 * a linkable object it be inserted or removed from anywhere
 * in the list.
 *
 * RESTRICTION: An object can only be a member of 1 list
 * at a time.
 */
public class DoubleLinkedList
{

	// Instance variables.

	/**
	 * Head of linked list.
	 */
	public Linkable						head;

	/**
	 * Tail of linked list.
	 */
	public Linkable						tail;

	/**
	 * Size of linked list.
	 */
	public int							size;

	/**
	 * Default constructor.
	 */
	public DoubleLinkedList()
	{
		this.head = null;
		this.size = 0;
		this.tail = null;
	}


	// Public Methods.

	/**
	 * Return the object at the head of a linked list.
	 *
	 */
	public synchronized Linkable getHead()
	{
		return this.head;
	}

	/**
	 * Return the object at the tail of a linked list.
	 *
	 */
	public synchronized Linkable getTail()
	{
		return this.tail;
	}


	/**
	 * Return size of the linked list.
	 *
	 */
	public synchronized int getSize()
	{
		return this.size;
	}


	/**
	 * Insert an object at the head of a linked list.
	 *
	 */
	public synchronized void insertAtHead(Linkable node)
	{
		if (node instanceof Linkable)
		{
			if (this.head == null)
			{
				node.setNext(null);				// Fixup node nextlink.
				node.setPrevious(null);			// Fixup node backlink.
				this.head = node;				// Insert node at head of list.
			}
			else
			{
				Linkable oldHead = this.head;	// Fixup current head node.
				oldHead.setPrevious(node);		// Set backlink to new node.
				node.setNext(oldHead);			// Fixup new node nextlink.
				node.setPrevious(null);			// Fixup new node backlink.
				this.head = node;				// Insert node at head of list.
			}
			if (this.tail == null)				// If list was empty,
			{
				this.tail = node;				// Insert node at tail of list.
			}
			this.size++;
		}
	}

	/**
	 * Insert an object at the tail of a linked list.
	 *
	 */
	public synchronized void insertAtTail(Linkable node)
	{
		if (node instanceof Linkable)
		{
			if (this.tail == null)
			{
				node.setNext(null);				// Fixup node nextlink.
				node.setPrevious(null);			// Fixup node backlink.
				this.tail = node;				// Insert node at end of list.
			}
			else
			{
				Linkable oldTail = this.tail;	// Fixup current tail node.
				oldTail.setNext(node);			// Set backlink to new node.
				node.setNext(null) ;			// Fixup new node backlink.
				node.setPrevious(oldTail);		// Fixup new node nextlink.
				this.tail = node;				// Insert node at end of list.
			}
			if (this.head == null)				// If list was empty,
			{
				this.head = node;				// Insert node at head of list.
			}
			this.size++;
		}
	}



	/**
	 * Remove and return an object from the head of a linked list.
	 *
	 */
	public synchronized Linkable removeFromHead()
	{
		Linkable node = this.head;
		if (node instanceof Linkable)
		{
			this.head = node.getNext();	// Set head to next node.
			if (this.head == null)		// If we emptied the list,
			{
				this.tail = null;		// Fixup the tail pointer.
			}
			else
			{
				this.head.setPrevious(null);// Clear head node backlink.
			}
			node.setNext(null);			// Clear removed node nextlink.
			node.setPrevious(null);		// Clear romoved node backlink.
			this.size--;
		}
		return node;
	}

	/**
	 * Remove and return an object from the tail of a linked list.
	 *
	 */
	public synchronized Linkable removeFromTail()
	{
		Linkable node = this.tail;
		if (node instanceof Linkable)
		{
			this.tail = node.getPrevious();	// Set tail to previous node.
			if (this.tail == null)			// If we emptied the list,
			{
				this.head = null;			// Fixup the head pointer.
			}
			else
			{
				this.tail.setNext(null);	// Clear tail node nextlink.
			}
			node.setNext(null);				// Clear removed node nextlink.
			node.setPrevious(null);			// Clear removed node backlink.
			this.size--;
		}
		return node;
	}

	/**
	 * Remove the specified object from anywhere in the linked list.
	 * This method is usually used by the object to remove itself
	 * from the list.
	 *
	 */
	public synchronized void removeFromList(Linkable node)
	{
		if ((this.size <= 0) || ((this.head == null) && (this.tail == null)))
		{
			return;
		} 
		if (node instanceof Linkable)
		{
			Linkable p = node.getPrevious();	// Reference to previous node.
			Linkable n = node.getNext();		// Reference to next node. 

			if (p == null)			// Is this the first (or only) node in the list?
			{
				this.head = n;		// Yes, set the head of the list to point to the next.
			}
			else
			{
				p.setNext(n);		// No, set the previous node to point to the next.
			}

			if (n == null)			// Is this the last (or only) node in the list?
			{
				this.tail = p;		// Yes, set the tail to point to the previous.
			}
			else
			{
				n.setPrevious(p);	// No, set the next node to point to the previous.
			}

			node.setNext(null);
			node.setPrevious(null);
			this.size--;
		}
	}


	/**
	 * Insert an object anywhere into the linked list.
	 *
	 * @param afternode			the new node will be inserted after this node
	 * @param newnode			the new node to be inserted
	 */
	public synchronized void insertIntoList(Linkable afternode, Linkable newnode)
	{
		if ((newnode instanceof Linkable) && (afternode instanceof Linkable))
		{
			if (this.tail == afternode)			// If inserting at the tail,
			{
				this.insertAtTail(newnode);		// Use insertAtTail method.
			}
			else
			{
				Linkable nextnode = afternode.getNext();
				newnode.setNext(nextnode);		// Point to next node.
				newnode.setPrevious(afternode);	// Point to previous node.
				afternode.setNext(newnode);		// Fixup backlink in afternode.
				nextnode.setPrevious(newnode);	// Fixup nextlink in next node.
			}
			this.size++;
		}
	}

	/**
	 * Return a string representation of this DoubleLinkedList object.
	 * <p> 
	 * @return  String representation of this object.
	 */
	public synchronized String toString()
	{
		/*		boolean dif = ThreadContext.lgr().test
			(	// Check for trace flag sp:1:1
				TraceLogger.CONFIGURATION,
				TraceLogger.SVC_SP,
				SPLogFlags.CFG_DIFFABLE_EXCEPTS,
				1
			);
		String buf = "DoubleLinkedList@\n";
		if(!dif)
		{
			buf = buf + "      head = " + this.head + "\n";
			buf = buf + "      tail = " + this.tail + "\n";
		}
		buf = buf + "      size = " + this.size + "\n";
        return buf;
		*/

		return null;
    }
}

