edu.berkeley.nlp.util.Trie Maven / Gradle / Ivy

Go to download
Show more of this group Show more artifacts with this name
Show all versions of berkeleyparser Show documentation
The Berkeley parser analyzes the grammatical structure of natural language using probabilistic context-free grammars (PCFGs).
The newest version!
package edu.berkeley.nlp.util;

import java.util.AbstractSet;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.Collections;
import java.util.HashMap;
import java.util.IdentityHashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.NoSuchElementException;
import java.util.Set;

public class Trie implements Map, V>
{

	public static class TrieMapFactory extends MapFactory, V>
	{

		private boolean identity;

		public TrieMapFactory(boolean identity)
		{
			this.identity = identity;
		}

		@Override
		public Map, V> buildMap()
		{
			return new Trie(identity);
		}

	}




	public class SuffixLengthIterable implements Iterable>
	{

		private final int suffixLength;

		public SuffixLengthIterable(int suffixLength)
		{
			this.suffixLength = suffixLength;
		}

		public Iterator> iterator()
		{
			return new SuffixLengthIterator();
		}

		public class SuffixLengthIterator implements Iterator>
		{

			private final Iterator> allIter;

			private List next;

			private List curr;

			public SuffixLengthIterator()
			{
				allIter = Trie.this.setIterator();
				advanceIter();
				curr = next;
			}

			private void advanceIter()
			{
				curr = next;
				while (allIter.hasNext())
				{
					final List currNext = allIter.next();
					if (currNext.size() == suffixLength)
					{
						next = currNext;
					}
				}
			}

			public boolean hasNext()
			{
				return next != null;
			}

			public List next()
			{
				if (!hasNext()) throw new UnsupportedOperationException();
				advanceIter();
				return curr;
			}

			public void remove()
			{
				throw new UnsupportedOperationException();

			}

		}

	}

	private Map> map;
	
	
	private V v;

	private int size;

	private final boolean useIdentity;

	public Trie(boolean useIdentity)
	{
		this(useIdentity, null,null,null);
	}

	public Trie()
	{
		this(false, null,null,null);
	}

	public static int id = 0;
	protected Trie(boolean useIdentity, K k, V v, Trie backPointer)
	{
		this.useIdentity = useIdentity;
		//		this.useIdentity = false;
		this.v = v;
		map = useIdentity ? new IdentityHashMap>() : new HashMap>(3);
		id++;
	}

	public Trie getNextTrie(K k)
	{

		return map.get(k);
		
	}

	public Trie getPartialList(List ts)
	{
		if (ts.isEmpty()) return null;
		K t = ts.get(0);
		final Trie trie = map.get(t);
		
		if (trie == null) return null;
		if (ts.size() == 1)
		{
			return trie;
		}
		else
		{
			return trie.getPartialList(ts.subList(1, ts.size()));
		}
	}
	

	//	public void compactify()
	//	{
	//		if (map.size() == 0)
	//		{
	//			map = Collections.emptyMap();
	//		}
	//		if (map.size() == 1)
	//		{
	//			Map.Entry> entry = map.entrySet().iterator().next();
	//			map = Collections.singletonMap(entry.getKey(),entry.getValue());
	//		}
	//		else if (map.size() > 1)
	//		{
	//			if (useIdentity)
	//			{
	//			Map> tmp  = new IdentityHashMap>(map.size());
	//			tmp.putAll(map);
	//			map = tmp;
	//			}
	//			else
	//			{
	//				Map> tmp = new HashMap>(map);
	//				map = tmp;
	//			}
	//		}
	//		for (Map.Entry> entry : map.entrySet())
	//		{
	//			entry.getValue().compactify();
	//		}
	//	}
	

	@Override
	public String toString()
	{
		StringBuilder sb = new StringBuilder("[");
		boolean added = false;
		for (List t : this.keySet())
		{
			if (added) sb.append(",");
			sb.append(t);
			sb.append("=");
			sb.append(this.get(t));
			added = true;
		}
		sb.append("]");
		return sb.toString();
	}

	
	
	public V put(List k, V v)
	{

		
		put(k, v, 0);
		return null;
	}

	
	private void put(List k, V v, int start)
	{
		final K first = k.get(start);
		Trie trie = map.get(first);
		if (trie == null)
		{

			if (k.size() - start == 1)
			{
				map.put(first, newTrie(useIdentity, first, v, this));
			}
			else
			{
				trie = newTrie(useIdentity, first, null, this);

				map.put(first, trie);
				trie.put(k, v, start + 1);
			}

		}
		else
		{

			if (k.size() - start == 1)
			{
				trie.v = v;
			}
			else
			{
				trie.put(k, v, start + 1);
			}
		}
	}
	protected Trie newTrie(boolean useIdentity2, K first, V v2, Trie trie)
	{
		return new Trie(useIdentity2, first, v2, trie);
	}

	public void putAll(Map, ? extends V> c)
	{

		for (final List e : c.keySet())
		{
			put(e, c.get(e));
		}

	}

	public void clear()
	{
		map.clear();
		size = 0;
	}

	public Iterable nextElements()
	{
		return Iterators.able(map.keySet().iterator());
	}

	@SuppressWarnings("unchecked")
	public boolean containsKey(Object o)
	{
		return get(o) != null;
	}

	public boolean isEmpty()
	{
		return map.isEmpty();
	}

	private MyIterator setIterator()
	{
		return new MyIterator();
	}

	private class MyIterator implements Iterator>
	{

		private boolean hasNext;

		private boolean activeTokenAlreadyReturned = true;

		private boolean alreadyAdvanced;

		private K currToken;

		private MyIterator currSuffixIter;

		private final Iterator tokenIter;

		private Map getMap()
		{
			return map;
		}

		public MyIterator()
		{
			tokenIter = map.keySet().iterator();
			advanceIter();

			alreadyAdvanced = true;

		}

		private void advanceIter()
		{
			

			if (currToken == null)
			{
				if (!tokenIter.hasNext())
				{
					alreadyAdvanced = true;
					hasNext = false;
					return;
				}
				currToken = tokenIter.next();
				final Trie trie = map.get(currToken);
				currSuffixIter = trie == null ? null : trie.setIterator();
				if (trie.v != null)
				{
					activeTokenAlreadyReturned = false;
					hasNext = true;
					alreadyAdvanced = true;
					return;
				}

			}
			final Trie trie = map.get(currToken);
			if (currSuffixIter == null)
			{
				currSuffixIter = trie == null ? null : trie.setIterator();
			}
			if (currSuffixIter == null || !currSuffixIter.hasNext())
			{
				currToken = null;
				advanceIter();
			}
			else
			{
				hasNext = true;
			}
			alreadyAdvanced = true;
			return;

		}

		public boolean hasNext()
		{
			if (!alreadyAdvanced) advanceIter();

			return hasNext;
		}

		public List next()
		{

			if (!hasNext()) { throw new NoSuchElementException(); }
			alreadyAdvanced = false;
			List retVal = null;
			if (!activeTokenAlreadyReturned)
			{
				activeTokenAlreadyReturned = true;

				return Collections.singletonList(currToken);
			}

			retVal = new ArrayList();
			retVal.add(currToken);
			retVal.addAll(currSuffixIter.next());

			return retVal;
		}

		public void remove()
		{
			throw new UnsupportedOperationException();

		}

	}

	public Iterable> bySuffixLength(int suffixLength)
	{
		return new SuffixLengthIterable(suffixLength);
	}

	/**
	 * Always return null.
	 */
	public V remove(Object o)
	{
		if (!(o instanceof List)) return null;
		List k = (List) o;
		final K first = k.get(0);
		if (k.size() == 1)
		{
			final Trie remove = map.get(first);
			if (remove == null) return null;
			remove.v = null;
			if (remove.isEmpty()) map.remove(first);
			return null;

		}
		final Trie trie = map.get(first);
		if (trie == null) return null;
		

			
				
				
				
			
		trie.remove(k.subList(1, k.size()));
		if (trie.isEmpty() && trie.v == null) map.remove(first);
		return null;
			
		
	}

	public int size()
	{
		return size;
	}

	public Object[] toArray()
	{
		throw new UnsupportedOperationException();
	}

	public  E[] toArray(E[] a)
	{
		throw new UnsupportedOperationException();
	}

	public static void main(String[] argv)
	{
		final Trie tree = new Trie();
		tree.put(Arrays.asList("c", "a"), true);

		tree.put(Arrays.asList("c"), true);
		tree.put(Arrays.asList("a", "b", "c"), true);
		tree.put(Arrays.asList("a", "b"), true);
		tree.put(Arrays.asList("a", "b", "c"), true);
		tree.put(Arrays.asList("a", "b", "x", "y", "z", "c"), true);
		tree.put(Arrays.asList("a", "b", "y", "c"), true);
		tree.put(Arrays.asList("a", "d", "c"), true);
		tree.put(Arrays.asList("a", "d", "e"), true);
		tree.put(Arrays.asList("1", "2", "3", "4", "t", "v"), true);
		tree.put(Arrays.asList("1", "2", "3"), true);
		tree.put(Arrays.asList("1", "2", "3", "4"), true);

		tree.put(Arrays.asList("1", "2", "3", "4", "t"), true);
		tree.put(Arrays.asList("4", "5", "6"), true);
		Iterator> iter = tree.keySet().iterator();
		while (iter.hasNext())
		{
			List list = iter.next();
			System.out.println(list);
		}
		tree.remove(Arrays.asList("1", "2", "3", "4", "t"));
		System.out.println();
		iter = tree.keySet().iterator();
		while (iter.hasNext())
		{
			List list = iter.next();
			System.out.println(list);
		}
		tree.remove(Arrays.asList("1", "2", "3", "4"));
		System.out.println();
		iter = tree.keySet().iterator();
		while (iter.hasNext())
		{
			List list = iter.next();
			System.out.println(list);
		}
		tree.remove(Arrays.asList("1", "2", "3", "4", "t", "v"));
		System.out.println();
		iter = tree.keySet().iterator();
		while (iter.hasNext())
		{
			List list = iter.next();
			System.out.println(list);
		}
	}

	public boolean containsElement(K t)
	{
		return map.containsKey(t);
	}

	public boolean containsValue(Object value)
	{
		throw new UnsupportedOperationException();
	}

	public Set, V>> entrySet()
	{
		throw new UnsupportedOperationException();
	}

	@SuppressWarnings("unchecked")
	public V get(Object key)
	{

		if (!(key instanceof List)) return null;
		final List l = (List) key;
		return get(l, 0);

	}

	private V get(List l, int start)
	{
		final K first = l.get(start);
		final Trie trie = map.get(first);
		if (trie == null) return null;
		if (start == l.size() - 1) return trie.v;
		
		return trie.get(l, start + 1);
	}

	public Set> keySet()
	{
		return new AbstractSet>()
		{

			@Override
			public Iterator> iterator()
			{
				return setIterator();
			}

			@Override
			public int size()
			{
				return size;
			}

		};
	}

	public Collection values()
	{
		throw new UnsupportedOperationException();
	}
	
	public V getNodeValue()
	{
		return v;
	}

	

}