jasder
/
antlr
1
0
Fork 1
Code Issues Pull Requests Releases 1 Wiki Activity

Use Dictionary instead of FlexibleHashMap

This commit is contained in:
Sam Harwell 2013-02-17 15:26:43 -06:00
parent f0ef7a5a28
commit 4ff0791120
5 changed files with 4 additions and 400 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
Antlr4.Runtime/Atn/PredictionContext.cs
View File

@ -519,7 +519,7 @@ outer_break: ;
return Sharpen.Collections.ToArray(result, new string[result.Count]);
}
public sealed class IdentityHashMap : FlexibleHashMap<PredictionContext, PredictionContext
public sealed class IdentityHashMap : Dictionary<PredictionContext, PredictionContext
>
{
public IdentityHashMap() : base(PredictionContext.IdentityEqualityComparator.Instance

2
Antlr4.Runtime/Atn/PredictionMode.cs
View File

@ -77,7 +77,7 @@ namespace Antlr4.Runtime.Atn
/// <summary>A Map that uses just the state and the stack context as the key.</summary>
/// <remarks>A Map that uses just the state and the stack context as the key.</remarks>
internal class AltAndContextMap : FlexibleHashMap<ATNConfig, BitArray>
internal class AltAndContextMap : Dictionary<ATNConfig, BitArray>
{
public AltAndContextMap() : base(PredictionMode.AltAndContextConfigEqualityComparator
.Instance)

397
Antlr4.Runtime/Misc/FlexibleHashMap`2.cs
View File

@ -1,397 +0,0 @@
/*
* [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 EqualityComparer<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(EqualityComparer<K> comparator) : this(comparator, InitalCapacity
, InitalBucketCapacity)
{
}
public FlexibleHashMap(EqualityComparer<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.GetHashCode(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 ISet<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 ISet<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.GetHashCode(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());
}
}
}

2
reference/antlr4

@ -1 +1 @@
Subproject commit 6ae81b1b8e2b827dadea9e34db365c99bbb93828
Subproject commit c501dc8ca6b6425179b693638979cceaa4202ec5

1
reference/sharpen-all-options.txt
View File

@ -192,6 +192,7 @@
-typeMapping org.antlr.v4.runtime.misc.EqualityComparator<> System.Collections.Generic.IEqualityComparer
-methodMapping org.antlr.v4.runtime.misc.EqualityComparator.hashCode GetHashCode
-typeMapping org.antlr.v4.runtime.misc.AbstractEqualityComparator<> System.Collections.Generic.EqualityComparer
-typeMapping org.antlr.v4.runtime.misc.FlexibleHashMap<,> System.Collections.Generic.Dictionary
-typeMapping org.antlr.v4.runtime.misc.Tuple System.Tuple
-typeMapping org.antlr.v4.runtime.misc.Tuple2<,> System.Tuple