/* Copyright (C) 2002 Univ. of Massachusetts Amherst, Computer Science Dept.
This file is part of "MALLET" (MAchine Learning for LanguagE Toolkit).
http://www.cs.umass.edu/~mccallum/mallet
This software is provided under the terms of the Common Public License,
version 1.0, as published by http://www.opensource.org. For further
information, see the file `LICENSE' included with this distribution. */
/**
@author Andrew McCallum mccallum@cs.umass.edu
*/
package cc.mallet.types;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.ObjectStreamException;
import java.io.OutputStreamWriter;
import java.io.PrintStream;
import java.io.PrintWriter;
import java.io.Serializable;
import java.rmi.dgc.VMID;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.ConcurrentMap;
import java.util.concurrent.locks.ReadWriteLock;
import java.util.concurrent.locks.ReentrantReadWriteLock;
import com.carrotsearch.hppc.ObjectIntHashMap;
/**
* A mapping between integers and objects where the mapping in each
* direction is efficient. Integers are assigned consecutively, starting
* at zero, as objects are added to the Alphabet. Objects can not be
* deleted from the Alphabet and thus the integers are never reused.
*
* The most common use of an alphabet is as a dictionary of feature names
* associated with a {@link cc.mallet.types.FeatureVector} in an
* {@link cc.mallet.types.Instance}. In a simple document
* classification usage,
* each unique word in a document would be a unique entry in the Alphabet
* with a unique integer associated with it. FeatureVectors rely on
* the integer part of the mapping to efficiently represent the subset of
* the Alphabet present in the FeatureVector.
* @see FeatureVector
* @see Instance
* @see cc.mallet.pipe.Pipe
*/
public class Alphabet implements Serializable
{
ObjectIntHashMap map;
ArrayList entries;
volatile boolean growthStopped = false;
Class entryClass = null;
VMID instanceId = new VMID(); //used in readResolve to identify persitent instances
private transient ReadWriteLock lock = new ReentrantReadWriteLock();
public Alphabet (int capacity, Class entryClass)
{
this.map = new ObjectIntHashMap (capacity);
this.entries = new ArrayList (capacity);
this.entryClass = entryClass;
// someone could try to deserialize us into this image (e.g., by RMI). Handle this.
deserializedEntries.putIfAbsent(instanceId, this);
}
public Alphabet (Class entryClass)
{
this (8, entryClass);
}
public Alphabet (int capacity)
{
this (capacity, null);
}
public Alphabet ()
{
this (8, null);
}
public Alphabet (Object[] entries) {
this (entries.length);
for (Object entry : entries)
this.lookupIndex(entry);
}
public Object clone ()
{
lock.readLock().lock();
try {
Alphabet ret = new Alphabet();
ret.map = (ObjectIntHashMap) map.clone();
ret.entries = (ArrayList) entries.clone();
ret.growthStopped = growthStopped;
ret.entryClass = entryClass;
return ret;
} finally {
lock.readLock().unlock();
}
}
/** Return -1 if entry isn't present. */
public int lookupIndex (Object entry, boolean addIfNotPresent)
{
if (entry == null)
throw new IllegalArgumentException ("Can't lookup \"null\" in an Alphabet.");
if (entryClass == null) {
entryClass = entry.getClass();
} else {
// Insist that all entries in the Alphabet are of the same
// class. This may not be strictly necessary, but will catch a
// bunch of easily-made errors.
if (entry.getClass() != entryClass)
throw new IllegalArgumentException("Non-matching entry class, " + entry.getClass() + ", was " + entryClass);
}
lock.readLock().lock();
try {
if (map.containsKey(entry)) {
return map.get(entry);
}
} finally {
lock.readLock().unlock();
}
if (!growthStopped && addIfNotPresent) {
lock.writeLock().lock();
try {
int retIndex = entries.size();
map.put(entry, retIndex);
entries.add(entry);
return retIndex;
} finally {
lock.writeLock().unlock();
}
}
return -1;
}
public int lookupIndex (Object entry)
{
return lookupIndex (entry, true);
}
public Object lookupObject (int index)
{
lock.readLock().lock();
try {
return entries.get(index);
} finally {
lock.readLock().unlock();
}
}
public Object[] toArray () {
lock.readLock().lock();
try {
return entries.toArray();
} finally {
lock.readLock().unlock();
}
}
/**
* Returns an array containing all the entries in the Alphabet.
* The runtime type of the returned array is the runtime type of in.
* If in is large enough to hold everything in the alphabet, then it
* it used. The returned array is such that for all entries obj,
* ret[lookupIndex(obj)] = obj .
*/
public Object[] toArray (Object[] in) {
lock.readLock().lock();
try {
return entries.toArray(in);
} finally {
lock.readLock().unlock();
}
}
// xxx This should disable the iterator's remove method...
// for thread safety returns a _copy_ of the array; should probably use size() and lookupObject() instead
public Iterator iterator () {
lock.readLock().lock();
try {
ArrayList copy = new ArrayList();
copy.addAll(entries);
return copy.iterator();
} finally {
lock.readLock().unlock();
}
}
public Object[] lookupObjects (int[] indices)
{
lock.readLock().lock();
try {
Object[] ret = new Object[indices.length];
for (int i = 0; i < indices.length; i++)
ret[i] = entries.get(indices[i]);
return ret;
} finally {
lock.readLock().unlock();
}
}
/**
* Returns an array of the objects corresponding to
* @param indices An array of indices to look up
* @param buf An array to store the returned objects in.
* @return An array of values from this Alphabet. The runtime type of the array is the same as buf
*/
public Object[] lookupObjects (int[] indices, Object[] buf)
{
lock.readLock().lock();
try {
for (int i = 0; i < indices.length; i++)
buf[i] = entries.get(indices[i]);
return buf;
} finally {
lock.readLock().unlock();
}
}
public int[] lookupIndices (Object[] objects, boolean addIfNotPresent)
{
int[] ret = new int[objects.length];
for (int i = 0; i < objects.length; i++)
ret[i] = lookupIndex (objects[i], addIfNotPresent);
return ret;
}
public boolean contains (Object entry)
{
lock.readLock().lock();
try {
return map.containsKey(entry);
} finally {
lock.readLock().unlock();
}
}
public int size ()
{
lock.readLock().lock();
try {
return entries.size();
} finally {
lock.readLock().unlock();
}
}
public void stopGrowth ()
{
growthStopped = true;
}
public void startGrowth ()
{
growthStopped = false;
}
public boolean growthStopped ()
{
return growthStopped;
}
public Class entryClass ()
{
return entryClass;
}
/** Return String representation of all Alphabet entries, each
separated by a newline. */
public String toString()
{
lock.readLock().lock();
try {
StringBuffer sb = new StringBuffer();
for (int i = 0; i < entries.size(); i++) {
sb.append(entries.get(i).toString());
sb.append('\n');
}
return sb.toString();
} finally {
lock.readLock().unlock();
}
}
public void dump () { dump (System.out); }
public void dump (PrintStream out)
{
dump (new PrintWriter (new OutputStreamWriter (out), true));
}
public void dump (PrintWriter out)
{
lock.readLock().lock();
try {
for (int i = 0; i < entries.size(); i++) {
out.println(i + " => " + entries.get(i));
}
} finally {
lock.readLock().unlock();
}
}
/** Convenience method that can often implement alphabetsMatch in classes that implement the AlphabetsCarrying interface. */
public static boolean alphabetsMatch (AlphabetCarrying object1, AlphabetCarrying object2) {
Alphabet[] a1 = object1.getAlphabets();
Alphabet[] a2 = object2.getAlphabets();
if (a1.length != a2.length) return false;
for (int i = 0; i < a1.length; i++) {
if (a1[i] == a2[i]) continue;
if (a1[i] == null || a2[i] == null) return false; // One is null, but the other isn't
if (! a1[i].equals(a2[i])) return false;
}
return true;
}
public VMID getInstanceId() { return instanceId;} // for debugging
public void setInstanceId(VMID id) { this.instanceId = id; }
// Serialization
private static final long serialVersionUID = 1;
private static final int CURRENT_SERIAL_VERSION = 1;
private void writeObject (ObjectOutputStream out) throws IOException {
lock.readLock().lock();
try {
out.writeInt(CURRENT_SERIAL_VERSION);
out.writeInt(entries.size());
for (int i = 0; i < entries.size(); i++)
out.writeObject(entries.get(i));
out.writeBoolean(growthStopped);
out.writeObject(entryClass);
out.writeObject(instanceId);
} finally {
lock.readLock().unlock();
}
}
private void readObject (ObjectInputStream in) throws IOException, ClassNotFoundException {
lock = new ReentrantReadWriteLock();
lock.writeLock().lock();
try {
int version = in.readInt();
int size = in.readInt();
entries = new ArrayList(size);
map = new ObjectIntHashMap(size);
for (int i = 0; i < size; i++) {
Object o = in.readObject();
map.put(o, i);
entries.add(o);
}
growthStopped = in.readBoolean();
entryClass = (Class) in.readObject();
if (version > 0) { // instanced id added in version 1S
instanceId = (VMID) in.readObject();
}
} finally {
lock.writeLock().unlock();
}
}
private transient static ConcurrentMap deserializedEntries = new ConcurrentHashMap();
/**
* This gets called after readObject; it lets the object decide whether
* to return itself or return a previously read in version.
* We use a hashMap of instanceIds to determine if we have already read
* in this object.
* @return
* @throws ObjectStreamException
*/
public Object readResolve() throws ObjectStreamException {
Object previous = deserializedEntries.get(instanceId);
if (previous != null){
//System.out.println(" ***Alphabet ReadResolve:Resolving to previous instance. instance id= " + instanceId);
return previous;
}
if (instanceId != null){
Object prev = deserializedEntries.putIfAbsent(instanceId, this);
if (prev != null) {
return prev;
}
}
//System.out.println(" *** Alphabet ReadResolve: new instance. instance id= " + instanceId);
return this;
}
}
Ads help maintain this website.