public void Run()
{
if (this.enumerator.MoveNext())
{
CountedSet <TValue> .Node current = this.enumerator.Current;
if (current.Release())
{
this.s.totalRetains--;
this.count++;
this.Run();
this.dict.Remove(current.v);
this.s.nodeCount--;
this.array[this.count--] = current.v;
}
else
{
this.s.totalRetains--;
}
}
else
{
this.Dispose();
if (this.count > 0)
{
this.array = new TValue[this.count];
}
this.count--;
}
}
private bool CompareNonNull(IEnumerable <T> actual, IEnumerable <T> expected)
{
Debug.Assert(actual != null);
Debug.Assert(expected != null);
var actualCount = new CountedSet(actual, comparer);
var expectedCount = new CountedSet(expected, comparer);
if (actualCount.Count != expectedCount.Count)
{
return(false);
}
if (actualCount.NullCount != expectedCount.NullCount)
{
return(false);
}
foreach (T item in actualCount)
{
if (actualCount.HowMany(item) != expectedCount.HowMany(item))
{
return(false);
}
}
return(true);
}
public void CountedSetInitialisesWithSpecifiedCollection()
{
var set = new CountedSet <string>(new[] { "foo", "foo", "bar" });
Assert.IsNotNull(set);
Assert.AreEqual(2, set.Count);
}
public void RemoveReturnsFalseIfSetDoesNotContainItem()
{
var set = new CountedSet <string>();
bool result = set.Remove("foo");
Assert.IsFalse(result);
}
private void _btnWeakCacheDetails_Click(object sender, System.EventArgs e)
{
HashSet hashSet = new HashSet();
int totalMemorySize = 0;
CountedSet cacheEntries = new CountedSet();
foreach (IntHashTable.Entry entry in MyPalStorage.Storage.ResourceWeakCache)
{
WeakReference weakRef = (WeakReference)entry.Value;
Resource res = (Resource)weakRef.Target;
hashSet.Add(res.Id);
cacheEntries.Add(res.Type);
totalMemorySize += res.EstimateMemorySize();
}
foreach (Resource res in MyPalStorage.Storage.ResourceCache)
{
if (res != null && !hashSet.Contains(res.Id))
{
cacheEntries.Add(res.Type);
totalMemorySize += res.EstimateMemorySize();
}
}
StringBuilder builder = new StringBuilder();
cacheEntries.SortByCount();
foreach (CountedSet.Entry de in cacheEntries)
{
builder.Append(de.Count + " - " + de.Value + "\n");
}
builder.Append("Estimated memory size " + totalMemorySize / 1024 + "K");
_lblResourceWeakCacheDetails.Text = builder.ToString();
}
public void CountedSetTryGetCountReturnsFalseIfItemIsNotPresent()
{
var set = new CountedSet <string>();
bool result = set.TryGetCount("foo", out _);
Assert.IsFalse(result);
}
public void CountedSetClearEmptiesSet()
{
var set = new CountedSet <string>(new[] { "foo", "foo", "bar" });
set.Clear();
Assert.IsEmpty(set);
}
public void CountedSetAddsItem()
{
var set = new CountedSet <string>();
set.Add("foo");
Assert.AreEqual(1, set.Count);
}
public void CountedSetTryGetCountReturnsZeroIfItemIsNotPresent()
{
var set = new CountedSet <string>();
int count;
Assert.IsFalse(set.TryGetCount("foo", out count));
Assert.AreEqual(0, count);
}
public void IfItemIsAddedToSetOnceRemoveCompletelyRemovesItem()
{
var set = new CountedSet <string>();
set.Add("foo");
set.Remove("foo");
Assert.IsFalse(set.Contains("foo"));
}
public ReleaseRecursor(CountedSet <TValue> v)
{
this.s = v;
this.dict = this.s.index;
this.enumerator = this.dict.Values.GetEnumerator();
this.array = CountedSet <TValue> .empty;
this.count = 0;
this.disposed = false;
}
public void RetainAll()
{
foreach (CountedSet <TValue> .Node value in this.index.Values)
{
value.Retain();
CountedSet <TValue> countedSet = this;
countedSet.totalRetains = countedSet.totalRetains + 1;
}
}
public void IfItemIsAddedToSetOnceAssociatedCountIsOne()
{
int count = 0;
var set = new CountedSet <string>();
set.Add("foo");
set.TryGetCount("foo", out count);
Assert.AreEqual(1, count);
}
public void IfItemIsAddedToSetMultipleTimesRemoveDoesNotCompletelyRemoveItem()
{
var set = new CountedSet <string>();
set.Add("foo");
set.Add("foo");
set.Remove("foo");
Assert.IsTrue(set.Contains("foo"));
}
public void CountedSetSupportsLookupByKey()
{
var set = new CountedSet <string>();
set.Add("foo");
set.Add("foo");
int count = set["foo"];
Assert.AreEqual(2, count);
}
public bool Retain()
{
if (this.done)
{
return(false);
}
CountedSet <TValue> .Node node = this;
uint num = node.count;
uint num1 = num;
node.count = num + 1;
return(num1 == 0);
}
public void CountedSetSupportsGenericIteration()
{
var set = new CountedSet <string>(new[] { "foo", "foo", "foo", "bar", "bar" });
Assert.DoesNotThrow(() =>
{
IEnumerator <string> enumerator = set.GetEnumerator();
while (enumerator.MoveNext())
{
//ignore empty block
}
});
}
public void CountedSetSupportsNonGenericIteration()
{
var set = new CountedSet <string>(new[] { "foo", "foo", "foo", "bar", "bar" });
Assert.DoesNotThrow(() =>
{
System.Collections.IEnumerator enumerator = (set as System.Collections.IEnumerable).GetEnumerator();
while (enumerator.MoveNext())
{
//ignore empty block
}
});
}
public void CountSetSupportsNonGenericIterationForExpectedNumberOfElements()
{
const int expected = 2;
int count = 0;
var set = new CountedSet <string>(new[] { "foo", "foo", "foo", "bar", "bar" });
System.Collections.IEnumerator enumerator = (set as System.Collections.IEnumerable).GetEnumerator();
while (enumerator.MoveNext())
{
count++;
}
Assert.AreEqual(expected, count);
}
public TValue[] ReleaseAll()
{
TValue[] tValueArray;
CountedSet <TValue> .ReleaseRecursor releaseRecursor = new CountedSet <TValue> .ReleaseRecursor(this);
try
{
releaseRecursor.Run();
tValueArray = releaseRecursor.array;
}
finally
{
((IDisposable)(object)releaseRecursor).Dispose();
}
return(tValueArray);
}
public bool Release()
{
bool flag;
if (this.done)
{
flag = false;
}
else
{
CountedSet <TValue> .Node node = this;
UInt32 num = node.count - 1;
uint num1 = num;
node.count = num;
flag = num1 == 0;
}
return(flag);
}
public void IfItemIsAddedToSetMultipleTimesRemoveReducesCountByOne()
{
int firstCount = 0;
int secondCount = 0;
var set = new CountedSet <string>();
set.Add("foo");
set.Add("foo");
set.TryGetCount("foo", out firstCount);
set.Remove("foo");
set.TryGetCount("foo", out secondCount);
Assert.AreEqual(2, firstCount);
Assert.AreEqual(1, secondCount);
}
public void CountedSetMaintainsDistinctCountForDifferentItems()
{
int fooCount = 0;
int barCount = 0;
var set = new CountedSet <string>();
set.Add("foo");
set.Add("foo");
set.Add("foo");
set.Add("bar");
set.Add("bar");
set.TryGetCount("foo", out fooCount);
set.TryGetCount("bar", out barCount);
Assert.AreEqual(3, fooCount);
Assert.AreEqual(2, barCount);
}
public int Release(TValue value)
{
CountedSet <TValue> .Node node;
if (!this.index.TryGetValue(value, out node))
{
return(-1);
}
bool flag = node.Release();
CountedSet <TValue> countedSet = this;
countedSet.totalRetains = countedSet.totalRetains - 1;
if (flag)
{
this.index.Remove(value);
CountedSet <TValue> countedSet1 = this;
countedSet1.nodeCount = countedSet1.nodeCount - 1;
}
return((int)node.count);
}
public void Run()
{
if (!this.enumerator.MoveNext())
{
this.Dispose();
if (this.count > 0)
{
this.array = new TValue[this.count];
}
CountedSet <TValue> .ReleaseRecursor releaseRecursor = this;
releaseRecursor.count = releaseRecursor.count - 1;
}
else
{
CountedSet <TValue> .Node current = this.enumerator.Current;
if (!current.Release())
{
CountedSet <TValue> tValues = this.s;
tValues.totalRetains = tValues.totalRetains - 1;
}
else
{
CountedSet <TValue> tValues1 = this.s;
tValues1.totalRetains = tValues1.totalRetains - 1;
CountedSet <TValue> .ReleaseRecursor releaseRecursor1 = this;
releaseRecursor1.count = releaseRecursor1.count + 1;
this.Run();
this.dict.Remove(current.v);
CountedSet <TValue> tValues2 = this.s;
tValues2.nodeCount = tValues2.nodeCount - 1;
TValue[] tValueArray = this.array;
CountedSet <TValue> .ReleaseRecursor releaseRecursor2 = this;
int num = releaseRecursor2.count;
int num1 = num;
releaseRecursor2.count = num - 1;
tValueArray[num1] = current.v;
}
}
}
public void IfItemIsAddedToSetMutlipleTimesItMustBeRemovedAnEqualNumberOfTimes()
{
bool firstCheck = false;
bool secondCheck = false;
bool thirdCheck = false;
var set = new CountedSet <string>();
set.Add("foo");
set.Add("foo");
set.Add("foo");
set.Remove("foo");
firstCheck = set.Contains("foo");
set.Remove("foo");
secondCheck = set.Contains("foo");
set.Remove("foo");
thirdCheck = set.Contains("foo");
Assert.IsTrue(firstCheck);
Assert.IsTrue(secondCheck);
Assert.IsFalse(thirdCheck);
}
public bool Apply(IEnumerable <T> actual)
{
var expectedSet = new CountedSet <T>(expected, comparer);
var actualSet = new CountedSet <T>(actual, comparer);
if (actualSet.TotalCount > expectedSet.TotalCount)
{
return(false);
}
foreach (var actualKvp in actualSet)
{
int actualCount = actualKvp.Value;
int expectedCount = expectedSet[actualKvp.Key];
if (actualCount > expectedCount)
{
return(false);
}
}
return(true);
}
public int Retain(TValue value)
{
CountedSet <TValue> .Node node;
if (!this.index.TryGetValue(value, out node))
{
Dictionary <TValue, CountedSet <TValue> .Node> tValues = this.index;
CountedSet <TValue> .Node node1 = new CountedSet <TValue> .Node()
{
v = value
};
node = node1;
tValues[value] = node1;
CountedSet <TValue> countedSet = this;
countedSet.nodeCount = countedSet.nodeCount + 1;
}
uint num = node.count;
node.Retain();
CountedSet <TValue> countedSet1 = this;
countedSet1.totalRetains = countedSet1.totalRetains + 1;
return((int)num);
}
public void IfItemIsAddedToSetMultipleTimesAssociatedCountIsIncreasedByOne()
{
int firstCount = 0;
int secondCount = 0;
int thirdCount = 0;
var set = new CountedSet <string>();
//add first time
set.Add("foo");
set.TryGetCount("foo", out firstCount);
//add second time
set.Add("foo");
set.TryGetCount("foo", out secondCount);
//add third time
set.Add("foo");
set.TryGetCount("foo", out thirdCount);
Assert.AreEqual(1, firstCount);
Assert.AreEqual(2, secondCount);
Assert.AreEqual(3, thirdCount);
}
public override int GetHashCode(CountedSet <TValue> .Node obj)
{
return(this.Comparer.GetHashCode(obj.v));
}
