com.tangosol.util.RecyclingLinkedList Maven / Gradle / Ivy
Go to download
Show more of this group Show more artifacts with this name
Show all versions of coherence Show documentation
Show all versions of coherence Show documentation
Oracle Coherence Community Edition
/*
* Copyright (c) 2000, 2020, Oracle and/or its affiliates.
*
* Licensed under the Universal Permissive License v 1.0 as shown at
* http://oss.oracle.com/licenses/upl.
*/
package com.tangosol.util;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.Serializable;
import java.util.Collection;
/**
* Extends SafeLinkedList and adds recycling of Node objects.
*
* @author cp 2002.01.06
*/
public class RecyclingLinkedList
extends SafeLinkedList
implements Cloneable, Serializable
{
// ----- constructors ---------------------------------------------------
/**
* Construct an empty List.
*/
public RecyclingLinkedList()
{
initRecycling(DEFAULT_RECYCLE_MAX);
}
/**
* Construct an empty List.
*
* @param cMaxRecycle the maximum number of Nodes to recycle at any
* given time
*/
public RecyclingLinkedList(int cMaxRecycle)
{
initRecycling(cMaxRecycle);
}
/**
* Construct a List containing the elements of the specified Collection.
*
* @param collection the Collection to fill this List from
*/
public RecyclingLinkedList(Collection collection)
{
super(collection);
initRecycling(DEFAULT_RECYCLE_MAX);
}
/**
* Construct a List containing the elements of the specified Collection.
*
* @param collection the Collection to fill this List from
* @param cMaxRecycle the maximum number of Nodes to recycle at any
* given time
*/
public RecyclingLinkedList(Collection collection, int cMaxRecycle)
{
super(collection);
initRecycling(cMaxRecycle);
}
// ----- recycling support ----------------------------------------------
/**
* Initializing the recycling data structures.
*
* @param cMaxRecycle the maximum number of Nodes to recycle at any
* given time
*/
protected void initRecycling(int cMaxRecycle)
{
m_anodeRecycled = new Node[cMaxRecycle];
m_cRecycleMax = cMaxRecycle;
m_cRecycleNodes = 0;
}
/**
* Instantiate a Node. (Factory pattern.) This method is over-ridden by
* inheriting implementations if the inheriting implementation extends the
* inner Node class.
*
* @param o the value for the Node
*/
protected SafeLinkedList.Node instantiateNode(Object o)
{
Node node;
int cRecycleNodes = m_cRecycleNodes;
if (cRecycleNodes > 0)
{
m_cRecycleNodes = --cRecycleNodes;
Node[] anodeRecycled = m_anodeRecycled;
node = anodeRecycled[cRecycleNodes];
anodeRecycled[cRecycleNodes] = null;
node.setObject(o);
}
else
{
node = new Node(o);
}
return node;
}
/**
* Recycle the passed Node.
*
* @param node the Node object to recycle
*/
protected void recycleNode(Node node)
{
int cRecycleNodes = m_cRecycleNodes;
if (cRecycleNodes < m_cRecycleMax)
{
m_anodeRecycled[cRecycleNodes] = node;
m_cRecycleNodes = cRecycleNodes + 1;
}
}
// ----- Object methods -------------------------------------------------
/**
* Create a deep clone of the list.
*
* @return a clone of this list
*/
public Object clone()
{
RecyclingLinkedList that = (RecyclingLinkedList) super.clone();
that.initRecycling(this.m_cRecycleMax);
return that;
}
// ----- Serializable interface -----------------------------------------
/**
* The writeObject method is responsible for writing the state of the
* object for its particular class so that the corresponding
* readObject method can restore it.
*
* @param out the stream to write the object to
*
* @exception IOException Includes any I/O exceptions that may occur
*/
private void writeObject(ObjectOutputStream out)
throws IOException
{
out.writeInt(m_cRecycleMax);
}
/**
* The readObject method is responsible for reading from the stream
* and restoring the classes fields.
*
* @param in the stream to read data from in order to restore the object
*
* @exception IOException if I/O errors occur
* @exception ClassNotFoundException If the class for an object being
* restored cannot be found.
*/
private void readObject(ObjectInputStream in)
throws IOException, ClassNotFoundException
{
m_cRecycleMax = in.readInt();
initRecycling(m_cRecycleMax);
}
// ----- inner classes --------------------------------------------------
/**
* A Node in the List. Nodes are doubly-linked and store a value.
*/
protected class Node
extends SafeLinkedList.Node
{
// ----- constructors -------------------------------------
/**
* Construct a blank Node.
*/
public Node()
{
}
/**
* Construct a Node with a value.
*
* @param o the value to store in the Node
*/
public Node(Object o)
{
super(o);
}
// ----- methods ------------------------------------------
/**
* Delink this Node and discard its value.
*
* @return the value of this Node before it was discarded
*/
protected Object discard()
{
Object o = super.discard();
// the following call does not need to be synchronized because
// discard() is only called from within methods that are
// synchronized on RecyclingLinkedList.this
RecyclingLinkedList.this.recycleNode(this);
return o;
}
}
// ----- data members ---------------------------------------------------
/**
* The Nodes to recycle.
*/
protected transient Node[] m_anodeRecycled;
/**
* The current number of Nodes being recycle.
*/
protected transient int m_cRecycleNodes;
/**
* The maximum number of Nodes to recycle.
*/
protected int m_cRecycleMax;
/**
* The default maximum number of Nodes to recycle.
*/
protected static final int DEFAULT_RECYCLE_MAX = 256;
}