//
// ========================================================================
// Copyright (c) 1995-2017 Mort Bay Consulting Pty. Ltd.
// ------------------------------------------------------------------------
// All rights reserved. This program and the accompanying materials
// are made available under the terms of the Eclipse Public License v1.0
// and Apache License v2.0 which accompanies this distribution.
//
// The Eclipse Public License is available at
// http://www.eclipse.org/legal/epl-v10.html
//
// The Apache License v2.0 is available at
// http://www.opensource.org/licenses/apache2.0.php
//
// You may elect to redistribute this code under either of these licenses.
// ========================================================================
//
package org.eclipse.jetty.util;
import java.nio.ByteBuffer;
import java.util.AbstractMap;
import java.util.Arrays;
import java.util.HashSet;
import java.util.Map;
import java.util.Set;
/**
* <p>A Ternary Trie String lookup data structure.</p>
* <p>
* This Trie is of a fixed size and cannot grow (which can be a good thing with regards to DOS when used as a cache).
* </p>
* <p>
* The Trie is stored in 3 arrays:
* </p>
* <dl>
* <dt>char[] _tree</dt><dd>This is semantically 2 dimensional array flattened into a 1 dimensional char array. The second dimension
* is that every 4 sequential elements represents a row of: character; hi index; eq index; low index, used to build a
* ternary trie of key strings.</dd>
* <dt>String[] _key</dt><dd>An array of key values where each element matches a row in the _tree array. A non zero key element
* indicates that the _tree row is a complete key rather than an intermediate character of a longer key.</dd>
* <dt>V[] _value</dt><dd>An array of values corresponding to the _key array</dd>
* </dl>
* <p>The lookup of a value will iterate through the _tree array matching characters. If the equal tree branch is followed,
* then the _key array is looked up to see if this is a complete match. If a match is found then the _value array is looked up
* to return the matching value.
* </p>
* <p>
* This Trie may be instantiated either as case sensitive or insensitive.
* </p>
* <p>This Trie is not Threadsafe and contains no mutual exclusion
* or deliberate memory barriers. It is intended for an ArrayTrie to be
* built by a single thread and then used concurrently by multiple threads
* and not mutated during that access. If concurrent mutations of the
* Trie is required external locks need to be applied.
* </p>
*
* @param <V> the Entry type
*/
public class ArrayTernaryTrie<V> extends AbstractTrie<V>
{
private static int LO=1;
private static int EQ=2;
private static int HI=3;
/**
* The Size of a Trie row is the char, and the low, equal and high
* child pointers
*/
private static final int ROW_SIZE = 4;
/**
* The Trie rows in a single array which allows a lookup of row,character
* to the next row in the Trie. This is actually a 2 dimensional
* array that has been flattened to achieve locality of reference.
*/
private final char[] _tree;
/**
* The key (if any) for a Trie row.
* A row may be a leaf, a node or both in the Trie tree.
*/
private final String[] _key;
/**
* The value (if any) for a Trie row.
* A row may be a leaf, a node or both in the Trie tree.
*/
private final V[] _value;
/**
* The number of rows allocated
*/
private char _rows;
/* ------------------------------------------------------------ */
/** Create a case insensitive Trie of default capacity.
*/
public ArrayTernaryTrie()
{
this(128);
}
/* ------------------------------------------------------------ */
/** Create a Trie of default capacity
* @param insensitive true if the Trie is insensitive to the case of the key.
*/
public ArrayTernaryTrie(boolean insensitive)
{
this(insensitive,128);
}
/* ------------------------------------------------------------ */
/** Create a case insensitive Trie
* @param capacity The capacity of the Trie, which is in the worst case
* is the total number of characters of all keys stored in the Trie.
* The capacity needed is dependent of the shared prefixes of the keys.
* For example, a capacity of 6 nodes is required to store keys "foo"
* and "bar", but a capacity of only 4 is required to
* store "bar" and "bat".
*/
public ArrayTernaryTrie(int capacity)
{
this(true,capacity);
}
/* ------------------------------------------------------------ */
/** Create a Trie
* @param insensitive true if the Trie is insensitive to the case of the key.
* @param capacity The capacity of the Trie, which is in the worst case
* is the total number of characters of all keys stored in the Trie.
* The capacity needed is dependent of the shared prefixes of the keys.
* For example, a capacity of 6 nodes is required to store keys "foo"
* and "bar", but a capacity of only 4 is required to
* store "bar" and "bat".
*/
public ArrayTernaryTrie(boolean insensitive, int capacity)
{
super(insensitive);
_value=(V[])new Object[capacity];
_tree=new char[capacity*ROW_SIZE];
_key=new String[capacity];
}
/* ------------------------------------------------------------ */
/** Copy Trie and change capacity by a factor
* @param trie the trie to copy from
* @param factor the factor to grow the capacity by
*/
public ArrayTernaryTrie(ArrayTernaryTrie<V> trie, double factor)
{
super(trie.isCaseInsensitive());
int capacity=(int)(trie._value.length*factor);
_rows=trie._rows;
_value=Arrays.copyOf(trie._value, capacity);
_tree=Arrays.copyOf(trie._tree, capacity*ROW_SIZE);
_key=Arrays.copyOf(trie._key, capacity);
}
/* ------------------------------------------------------------ */
@Override
public void clear()
{
_rows=0;
Arrays.fill(_value,null);
Arrays.fill(_tree,(char)0);
Arrays.fill(_key,null);
}
/* ------------------------------------------------------------ */
@Override
public boolean put(String s, V v)
{
int t=0;
int limit = s.length();
int last=0;
for(int k=0; k < limit; k++)
{
char c=s.charAt(k);
if(isCaseInsensitive() && c<128)
c=StringUtil.lowercases[c];
while (true)
{
int row=ROW_SIZE*t;
// Do we need to create the new row?
if (t==_rows)
{
_rows++;
if (_rows>=_key.length)
{
_rows--;
return false;
}
_tree[row]=c;
}
char n=_tree[row];
int diff=n-c;
if (diff==0)
t=_tree[last=(row+EQ)];
else if (diff<0)
t=_tree[last=(row+LO)];
else
t=_tree[last=(row+HI)];
// do we need a new row?
if (t==0)
{
t=_rows;
_tree[last]=(char)t;
}
if (diff==0)
break;
}
}
// Do we need to create the new row?
if (t==_rows)
{
_rows++;
if (_rows>=_key.length)
{
_rows--;
return false;
}
}
// Put the key and value
_key[t]=v==null?null:s;
_value[t] = v;
return true;
}
/* ------------------------------------------------------------ */
@Override
public V get(String s,int offset, int len)
{
int t = 0;
for(int i=0; i < len;)
{
char c=s.charAt(offset+i++);
if(isCaseInsensitive() && c<128)
c=StringUtil.lowercases[c];
while (true)
{
int row = ROW_SIZE*t;
char n=_tree[row];
int diff=n-c;
if (diff==0)
{
t=_tree[row+EQ];
if (t==0)
return null;
break;
}
t=_tree[row+hilo(diff)];
if (t==0)
return null;
}
}
return _value[t];
}
@Override
public V get(ByteBuffer b, int offset, int len)
{
int t = 0;
offset+=b.position();
for(int i=0; i < len;)
{
byte c=(byte)(b.get(offset+i++)&0x7f);
if(isCaseInsensitive())
c=(byte)StringUtil.lowercases[c];
while (true)
{
int row = ROW_SIZE*t;
char n=_tree[row];
int diff=n-c;
if (diff==0)
{
t=_tree[row+EQ];
if (t==0)
return null;
break;
}
t=_tree[row+hilo(diff)];
if (t==0)
return null;
}
}
return (V)_value[t];
}
/* ------------------------------------------------------------ */
@Override
public V getBest(String s)
{
return getBest(0,s,0,s.length());
}
/* ------------------------------------------------------------ */
@Override
public V getBest(String s, int offset, int length)
{
return getBest(0,s,offset,length);
}
/* ------------------------------------------------------------ */
private V getBest(int t,String s,int offset,int len)
{
int node=t;
int end=offset+len;
loop: while(offset<end)
{
char c=s.charAt(offset++);
len--;
if(isCaseInsensitive() && c<128)
c=StringUtil.lowercases[c];
while (true)
{
int row = ROW_SIZE*t;
char n=_tree[row];
int diff=n-c;
if (diff==0)
{
t=_tree[row+EQ];
if (t==0)
break loop;
// if this node is a match, recurse to remember
if (_key[t]!=null)
{
node=t;
V better=getBest(t,s,offset,len);
if (better!=null)
return better;
}
break;
}
t=_tree[row+hilo(diff)];
if (t==0)
break loop;
}
}
return (V)_value[node];
}
/* ------------------------------------------------------------ */
@Override
public V getBest(ByteBuffer b, int offset, int len)
{
if (b.hasArray())
return getBest(0,b.array(),b.arrayOffset()+b.position()+offset,len);
return getBest(0,b,offset,len);
}
/* ------------------------------------------------------------ */
private V getBest(int t,byte[] b, int offset, int len)
{
int node=t;
int end=offset+len;
loop: while(offset<end)
{
byte c=(byte)(b[offset++]&0x7f);
len--;
if(isCaseInsensitive())
c=(byte)StringUtil.lowercases[c];
while (true)
{
int row = ROW_SIZE*t;
char n=_tree[row];
int diff=n-c;
if (diff==0)
{
t=_tree[row+EQ];
if (t==0)
break loop;
// if this node is a match, recurse to remember
if (_key[t]!=null)
{
node=t;
V better=getBest(t,b,offset,len);
if (better!=null)
return better;
}
break;
}
t=_tree[row+hilo(diff)];
if (t==0)
break loop;
}
}
return (V)_value[node];
}
/* ------------------------------------------------------------ */
private V getBest(int t,ByteBuffer b, int offset, int len)
{
int node=t;
int o= offset+b.position();
loop: for(int i=0; i<len; i++)
{
byte c=(byte)(b.get(o+i)&0x7f);
if(isCaseInsensitive())
c=(byte)StringUtil.lowercases[c];
while (true)
{
int row = ROW_SIZE*t;
char n=_tree[row];
int diff=n-c;
if (diff==0)
{
t=_tree[row+EQ];
if (t==0)
break loop;
// if this node is a match, recurse to remember
if (_key[t]!=null)
{
node=t;
V best=getBest(t,b,offset+i+1,len-i-1);
if (best!=null)
return best;
}
break;
}
t=_tree[row+hilo(diff)];
if (t==0)
break loop;
}
}
return (V)_value[node];
}
@Override
public String toString()
{
StringBuilder buf = new StringBuilder();
for (int r=0;r<=_rows;r++)
{
if (_key[r]!=null && _value[r]!=null)
{
buf.append(',');
buf.append(_key[r]);
buf.append('=');
buf.append(_value[r].toString());
}
}
if (buf.length()==0)
return "{}";
buf.setCharAt(0,'{');
buf.append('}');
return buf.toString();
}
@Override
public Set<String> keySet()
{
Set<String> keys = new HashSet<>();
for (int r=0;r<=_rows;r++)
{
if (_key[r]!=null && _value[r]!=null)
keys.add(_key[r]);
}
return keys;
}
public int size()
{
int s=0;
for (int r=0;r<=_rows;r++)
{
if (_key[r]!=null && _value[r]!=null)
s++;
}
return s;
}
public boolean isEmpty()
{
for (int r=0;r<=_rows;r++)
{
if (_key[r]!=null && _value[r]!=null)
return false;
}
return true;
}
public Set<Map.Entry<String,V>> entrySet()
{
Set<Map.Entry<String,V>> entries = new HashSet<>();
for (int r=0;r<=_rows;r++)
{
if (_key[r]!=null && _value[r]!=null)
entries.add(new AbstractMap.SimpleEntry<>(_key[r],_value[r]));
}
return entries;
}
@Override
public boolean isFull()
{
return _rows+1==_key.length;
}
public static int hilo(int diff)
{
// branchless equivalent to return ((diff<0)?LO:HI);
// return 3+2*((diff&Integer.MIN_VALUE)>>Integer.SIZE-1);
return 1+(diff|Integer.MAX_VALUE)/(Integer.MAX_VALUE/2);
}
public void dump()
{
for (int r=0;r<_rows;r++)
{
char c=_tree[r*ROW_SIZE+0];
System.err.printf("%4d [%s,%d,%d,%d] '%s':%s%n",
r,
(c<' '||c>127)?(""+(int)c):"'"+c+"'",
(int)_tree[r*ROW_SIZE+LO],
(int)_tree[r*ROW_SIZE+EQ],
(int)_tree[r*ROW_SIZE+HI],
_key[r],
_value[r]);
}
}
public static class Growing<V> implements Trie<V>
{
private final int _growby;
private ArrayTernaryTrie<V> _trie;
public Growing()
{
this(1024,1024);
}
public Growing(int capacity, int growby)
{
_growby=growby;
_trie = new ArrayTernaryTrie<>(capacity);
}
public Growing(boolean insensitive, int capacity, int growby)
{
_growby=growby;
_trie = new ArrayTernaryTrie<>(insensitive,capacity);
}
public boolean put(V v)
{
return put(v.toString(),v);
}
public int hashCode()
{
return _trie.hashCode();
}
public V remove(String s)
{
return _trie.remove(s);
}
public V get(String s)
{
return _trie.get(s);
}
public V get(ByteBuffer b)
{
return _trie.get(b);
}
public V getBest(byte[] b, int offset, int len)
{
return _trie.getBest(b,offset,len);
}
public boolean isCaseInsensitive()
{
return _trie.isCaseInsensitive();
}
public boolean equals(Object obj)
{
return _trie.equals(obj);
}
public void clear()
{
_trie.clear();
}
public boolean put(String s, V v)
{
boolean added = _trie.put(s,v);
while (!added && _growby>0)
{
ArrayTernaryTrie<V> bigger = new ArrayTernaryTrie<>(_trie._key.length+_growby);
for (Map.Entry<String,V> entry : _trie.entrySet())
bigger.put(entry.getKey(),entry.getValue());
_trie = bigger;
added = _trie.put(s,v);
}
return added;
}
public V get(String s, int offset, int len)
{
return _trie.get(s,offset,len);
}
public V get(ByteBuffer b, int offset, int len)
{
return _trie.get(b,offset,len);
}
public V getBest(String s)
{
return _trie.getBest(s);
}
public V getBest(String s, int offset, int length)
{
return _trie.getBest(s,offset,length);
}
public V getBest(ByteBuffer b, int offset, int len)
{
return _trie.getBest(b,offset,len);
}
public String toString()
{
return _trie.toString();
}
public Set<String> keySet()
{
return _trie.keySet();
}
public boolean isFull()
{
return false;
}
public void dump()
{
_trie.dump();
}
public boolean isEmpty()
{
return _trie.isEmpty();
}
public int size()
{
return _trie.size();
}
}
}