forked from jasder/antlr
398 lines
8.7 KiB
C#
398 lines
8.7 KiB
C#
/*
|
|
* [The "BSD license"]
|
|
* Copyright (c) 2013 Terence Parr
|
|
* Copyright (c) 2013 Sam Harwell
|
|
* All rights reserved.
|
|
*
|
|
* Redistribution and use in source and binary forms, with or without
|
|
* modification, are permitted provided that the following conditions
|
|
* are met:
|
|
*
|
|
* 1. Redistributions of source code must retain the above copyright
|
|
* notice, this list of conditions and the following disclaimer.
|
|
* 2. Redistributions in binary form must reproduce the above copyright
|
|
* notice, this list of conditions and the following disclaimer in the
|
|
* documentation and/or other materials provided with the distribution.
|
|
* 3. The name of the author may not be used to endorse or promote products
|
|
* derived from this software without specific prior written permission.
|
|
*
|
|
* THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
|
|
* IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
|
|
* OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
|
|
* IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
|
|
* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
|
|
* NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
|
|
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
|
|
* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
|
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
|
|
* THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
|
*/
|
|
using System;
|
|
using System.Collections.Generic;
|
|
using System.Text;
|
|
using Antlr4.Runtime.Misc;
|
|
using Sharpen;
|
|
|
|
namespace Antlr4.Runtime.Misc
|
|
{
|
|
/// <summary>
|
|
/// A limited map (many unsupported operations) that lets me use
|
|
/// varying hashCode/equals.
|
|
/// </summary>
|
|
/// <remarks>
|
|
/// A limited map (many unsupported operations) that lets me use
|
|
/// varying hashCode/equals.
|
|
/// </remarks>
|
|
public class FlexibleHashMap<K, V> : IDictionary<K, V>
|
|
{
|
|
public const int InitalCapacity = 16;
|
|
|
|
public const int InitalBucketCapacity = 8;
|
|
|
|
public const double LoadFactor = 0.75;
|
|
|
|
public class Entry<K, V>
|
|
{
|
|
public readonly K key;
|
|
|
|
public V value;
|
|
|
|
public Entry(K key, V value)
|
|
{
|
|
// must be power of 2
|
|
this.key = key;
|
|
this.value = value;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
return key.ToString() + ":" + value.ToString();
|
|
}
|
|
}
|
|
|
|
[NotNull]
|
|
protected internal readonly AbstractEqualityComparator<K> comparator;
|
|
|
|
protected internal List<FlexibleHashMap.Entry<K, V>>[] buckets;
|
|
|
|
/// <summary>How many elements in set</summary>
|
|
protected internal int n = 0;
|
|
|
|
protected internal int threshold = (int)(InitalCapacity * LoadFactor);
|
|
|
|
protected internal int currentPrime = 1;
|
|
|
|
protected internal int initialBucketCapacity = InitalBucketCapacity;
|
|
|
|
public FlexibleHashMap() : this(null, InitalCapacity, InitalBucketCapacity)
|
|
{
|
|
}
|
|
|
|
public FlexibleHashMap(AbstractEqualityComparator<K> comparator) : this(comparator
|
|
, InitalCapacity, InitalBucketCapacity)
|
|
{
|
|
}
|
|
|
|
public FlexibleHashMap(AbstractEqualityComparator<K> comparator, int initialCapacity
|
|
, int initialBucketCapacity)
|
|
{
|
|
// when to expand
|
|
// jump by 4 primes each expand or whatever
|
|
if (comparator == null)
|
|
{
|
|
comparator = ObjectEqualityComparator.Instance;
|
|
}
|
|
this.comparator = comparator;
|
|
this.buckets = CreateEntryListArray(initialBucketCapacity);
|
|
this.initialBucketCapacity = initialBucketCapacity;
|
|
}
|
|
|
|
private static List<FlexibleHashMap.Entry<K, V>>[] CreateEntryListArray<K, V>(int
|
|
length)
|
|
{
|
|
List<FlexibleHashMap.Entry<K, V>>[] result = (List<FlexibleHashMap.Entry<K, V>>[]
|
|
)new List<object>[length];
|
|
return result;
|
|
}
|
|
|
|
protected internal virtual int GetBucket(K key)
|
|
{
|
|
int hash = comparator.HashCode(key);
|
|
int b = hash & (buckets.Length - 1);
|
|
// assumes len is power of 2
|
|
return b;
|
|
}
|
|
|
|
public virtual V Get(object key)
|
|
{
|
|
K typedKey = (K)key;
|
|
if (key == null)
|
|
{
|
|
return null;
|
|
}
|
|
int b = GetBucket(typedKey);
|
|
List<FlexibleHashMap.Entry<K, V>> bucket = buckets[b];
|
|
if (bucket == null)
|
|
{
|
|
return null;
|
|
}
|
|
// no bucket
|
|
foreach (FlexibleHashMap.Entry<K, V> e in bucket)
|
|
{
|
|
if (comparator.Equals(e.key, typedKey))
|
|
{
|
|
return e.value;
|
|
}
|
|
}
|
|
return null;
|
|
}
|
|
|
|
public virtual V Put(K key, V value)
|
|
{
|
|
if (key == null)
|
|
{
|
|
return null;
|
|
}
|
|
if (n > threshold)
|
|
{
|
|
Expand();
|
|
}
|
|
int b = GetBucket(key);
|
|
List<FlexibleHashMap.Entry<K, V>> bucket = buckets[b];
|
|
if (bucket == null)
|
|
{
|
|
bucket = buckets[b] = new List<FlexibleHashMap.Entry<K, V>>();
|
|
}
|
|
foreach (FlexibleHashMap.Entry<K, V> e in bucket)
|
|
{
|
|
if (comparator.Equals(e.key, key))
|
|
{
|
|
V prev = e.value;
|
|
e.value = value;
|
|
n++;
|
|
return prev;
|
|
}
|
|
}
|
|
// not there
|
|
bucket.AddItem(new FlexibleHashMap.Entry<K, V>(key, value));
|
|
n++;
|
|
return null;
|
|
}
|
|
|
|
public virtual V Remove(object key)
|
|
{
|
|
throw new NotSupportedException();
|
|
}
|
|
|
|
public virtual void PutAll<_T0>(IDictionary<_T0> m) where _T0:K
|
|
{
|
|
throw new NotSupportedException();
|
|
}
|
|
|
|
public virtual ICollection<K> Keys
|
|
{
|
|
get
|
|
{
|
|
throw new NotSupportedException();
|
|
}
|
|
}
|
|
|
|
public virtual ICollection<V> Values
|
|
{
|
|
get
|
|
{
|
|
IList<V> a = new List<V>(Count);
|
|
foreach (List<FlexibleHashMap.Entry<K, V>> bucket in buckets)
|
|
{
|
|
if (bucket == null)
|
|
{
|
|
continue;
|
|
}
|
|
foreach (FlexibleHashMap.Entry<K, V> e in bucket)
|
|
{
|
|
a.AddItem(e.value);
|
|
}
|
|
}
|
|
return a;
|
|
}
|
|
}
|
|
|
|
public virtual ICollection<KeyValuePair<K, V>> EntrySet()
|
|
{
|
|
throw new NotSupportedException();
|
|
}
|
|
|
|
public virtual bool ContainsKey(object key)
|
|
{
|
|
return Get(key) != null;
|
|
}
|
|
|
|
public virtual bool ContainsValue(object value)
|
|
{
|
|
throw new NotSupportedException();
|
|
}
|
|
|
|
public override int GetHashCode()
|
|
{
|
|
int h = 0;
|
|
foreach (List<FlexibleHashMap.Entry<K, V>> bucket in buckets)
|
|
{
|
|
if (bucket == null)
|
|
{
|
|
continue;
|
|
}
|
|
foreach (FlexibleHashMap.Entry<K, V> e in bucket)
|
|
{
|
|
if (e == null)
|
|
{
|
|
break;
|
|
}
|
|
h += comparator.HashCode(e.key);
|
|
}
|
|
}
|
|
return h;
|
|
}
|
|
|
|
public override bool Equals(object o)
|
|
{
|
|
throw new NotSupportedException();
|
|
}
|
|
|
|
protected internal virtual void Expand()
|
|
{
|
|
List<FlexibleHashMap.Entry<K, V>>[] old = buckets;
|
|
currentPrime += 4;
|
|
int newCapacity = buckets.Length * 2;
|
|
List<FlexibleHashMap.Entry<K, V>>[] newTable = CreateEntryListArray(newCapacity);
|
|
buckets = newTable;
|
|
threshold = (int)(newCapacity * LoadFactor);
|
|
// System.out.println("new size="+newCapacity+", thres="+threshold);
|
|
// rehash all existing entries
|
|
int oldSize = Count;
|
|
foreach (List<FlexibleHashMap.Entry<K, V>> bucket in old)
|
|
{
|
|
if (bucket == null)
|
|
{
|
|
continue;
|
|
}
|
|
foreach (FlexibleHashMap.Entry<K, V> e in bucket)
|
|
{
|
|
if (e == null)
|
|
{
|
|
break;
|
|
}
|
|
Put(e.key, e.value);
|
|
}
|
|
}
|
|
n = oldSize;
|
|
}
|
|
|
|
public virtual int Count
|
|
{
|
|
get
|
|
{
|
|
return n;
|
|
}
|
|
}
|
|
|
|
public virtual bool IsEmpty()
|
|
{
|
|
return n == 0;
|
|
}
|
|
|
|
public virtual void Clear()
|
|
{
|
|
buckets = CreateEntryListArray(InitalCapacity);
|
|
n = 0;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
if (Count == 0)
|
|
{
|
|
return "{}";
|
|
}
|
|
StringBuilder buf = new StringBuilder();
|
|
buf.Append('{');
|
|
bool first = true;
|
|
foreach (List<FlexibleHashMap.Entry<K, V>> bucket in buckets)
|
|
{
|
|
if (bucket == null)
|
|
{
|
|
continue;
|
|
}
|
|
foreach (FlexibleHashMap.Entry<K, V> e in bucket)
|
|
{
|
|
if (e == null)
|
|
{
|
|
break;
|
|
}
|
|
if (first)
|
|
{
|
|
first = false;
|
|
}
|
|
else
|
|
{
|
|
buf.Append(", ");
|
|
}
|
|
buf.Append(e.ToString());
|
|
}
|
|
}
|
|
buf.Append('}');
|
|
return buf.ToString();
|
|
}
|
|
|
|
public virtual string ToTableString()
|
|
{
|
|
StringBuilder buf = new StringBuilder();
|
|
foreach (List<FlexibleHashMap.Entry<K, V>> bucket in buckets)
|
|
{
|
|
if (bucket == null)
|
|
{
|
|
buf.Append("null\n");
|
|
continue;
|
|
}
|
|
buf.Append('[');
|
|
bool first = true;
|
|
foreach (FlexibleHashMap.Entry<K, V> e in bucket)
|
|
{
|
|
if (first)
|
|
{
|
|
first = false;
|
|
}
|
|
else
|
|
{
|
|
buf.Append(" ");
|
|
}
|
|
if (e == null)
|
|
{
|
|
buf.Append("_");
|
|
}
|
|
else
|
|
{
|
|
buf.Append(e.ToString());
|
|
}
|
|
}
|
|
buf.Append("]\n");
|
|
}
|
|
return buf.ToString();
|
|
}
|
|
|
|
public static void Main(string[] args)
|
|
{
|
|
FlexibleHashMap<string, int> map = new FlexibleHashMap<string, int>();
|
|
map.Put("hi", 1);
|
|
map.Put("mom", 2);
|
|
map.Put("foo", 3);
|
|
map.Put("ach", 4);
|
|
map.Put("cbba", 5);
|
|
map.Put("d", 6);
|
|
map.Put("edf", 7);
|
|
map.Put("mom", 8);
|
|
map.Put("hi", 9);
|
|
System.Console.Out.WriteLine(map);
|
|
System.Console.Out.WriteLine(map.ToTableString());
|
|
}
|
|
}
|
|
}
|