///<summary>
///Determines whether the specified <see cref="T:System.Object"></see>
/// is equal to the current <see cref="T:System.Object"></see>.
///</summary>
///
///<returns>
///true if the specified <see cref="T:System.Object"></see> is equal to
/// the current <see cref="T:System.Object"></see>; otherwise, false.
///</returns>
///
///<param name="obj">The <see cref="T:System.Object"></see> to compare
/// with the current <see cref="T:System.Object"></see>. </param>
/// <filterpriority>2</filterpriority>
public override bool Equals(object obj)
{
DictionaryEnumerator <Tkey, TValue> e =
obj as DictionaryEnumerator <Tkey, TValue>;
return(e != null && m_wrapped.Equals(e.m_wrapped));
}
public MBBindingList <PrefabVM> Filter(List <PrefabVM> subcategory, int amount)
{
//Category Change Check
var enumerator = subcategory.GetEnumerator();
if (!_enumerator.Equals(enumerator))
{
_enumerator = enumerator;
_pagemodel = new MBBindingList <PrefabVM>();
}
//Add amount to PageModel
return(Enumerate(amount));
}
private void GameEvents_OneSecondTick(object sender, EventArgs e)
{
if (!expPts.Equals(Game1.player.experiencePoints.GetEnumerator()))
{
IEnumerator <int> curPts = Game1.player.experiencePoints.GetEnumerator();
int x = 0;
do
{
int change = curPts.Current - expPts.Current;
if (change > 0 && NearPlayer())
{
Game1.player.gainExperience(x, (int)(change * config.coopMult));
}
x++;
} while (expPts.MoveNext() && curPts.MoveNext());
expPts = Game1.player.experiencePoints.GetEnumerator();
}
}
public RuleResult SatisfiedBy(InputData <TIn> inputData)
{
if (verified && verifiedCount > 0)
{
verifiedCount--;
return(RuleResult.MatchNoEmit);
}
else
{
verified = false;
}
IEnumerator <TIn> condition = conditions.GetEnumerator();
IEnumerator <TIn> input = inputData.Enumerator;
while (condition.MoveNext() && condition.Equals(input.Current))
{
verifiedCount++;
if (!input.MoveNext())
{
break;
}
}
if (verifiedCount == conditions.Count())
{
verified = true;
verifiedCount--;
return(RuleResult.MatchEmit);
}
else
{
verifiedCount = 0;
}
return(RuleResult.NoMatch);
}
public void test_values()
{
EnumMap <Color, Double> enumColorMap = new EnumMap <Color, Double>(typeof(Color));
enumColorMap.Put(Color.Red, 1);
enumColorMap.Put(Color.Blue, 0);
ICollection <double> collection = enumColorMap.Values();
ICollection <double> collection1 = enumColorMap.Values();
Assertion.AssertSame("Should be same", collection1, collection); //$NON-NLS-1$
/*try {
* collection.add(new Integer(1));
* fail("Should throw UnsupportedOperationException"); //$NON-NLS-1$
* } catch (UnsupportedOperationException e) {
* // Expected
* }*/
Assertion.Assert("Returned false for contained object", collection//$NON-NLS-1$
.Contains(1));
//Assertion.Assert("Returned false for contained object", collection//$NON-NLS-1$
// .Contains(null));
Assertion.Assert("Returned true for uncontained object", !collection //$NON-NLS-1$
.Contains(2));
/*Assertion.Assert("Returned false when the object can be removed", collection //$NON-NLS-1$
* .Remove(null));
* Assertion.Assert("Returned true for uncontained object", !collection //$NON-NLS-1$
* .Contains(null));
* Assertion.Assert("Returned true when the object can not be removed", //$NON-NLS-1$
* !collection.Remove(null));*/
// The set is backed by the map so changes to one are reflected by the
// other.
enumColorMap.Put(Color.Blue, 3);
Assertion.Assert("Returned false for contained object", collection//$NON-NLS-1$
.Contains(3));
enumColorMap.Remove(Color.Blue);
Assertion.Assert("Returned true for uncontained object", !collection//$NON-NLS-1$
.Contains(3));
Assertion.AssertEquals("Wrong size", 1, collection.Count); //$NON-NLS-1$
collection.Clear();
Assertion.AssertEquals("Wrong size", 0, collection.Count); //$NON-NLS-1$
enumColorMap = new EnumMap <Color, Double>(typeof(Color));
enumColorMap.Put(Color.Red, 1);
enumColorMap.Put(Color.Blue, 0);
collection = enumColorMap.Values();
IList <double> c = new List <double>();
c.Add(1);
//Assertion.Assert("Should return true", collection.ContainsAll(c)); //$NON-NLS-1$
c.Add(3.4);
//Assertion.Assert("Should return false",! collection.ContainsAll(c)); //$NON-NLS-1$
//Assertion.Assert("Should return true", collection.RemoveAll(c)); //$NON-NLS-1$
//Assertion.AssertEquals("Wrong size", 1, collection.Count); //$NON-NLS-1$
//Assertion.Assert("Should return false", !collection.RemoveAll(c)); //$NON-NLS-1$
/*Assertion.AssertEquals("Wrong size", 1, collection.Count); //$NON-NLS-1$
* try {
* collection.AddAll(c);
* fail("Should throw UnsupportedOperationException"); //$NON-NLS-1$
* } catch (UnsupportedOperationException e) {
* // Expected
* }*/
enumColorMap.Put(Color.Red, 1);
Assertion.AssertEquals("Wrong size", 2, collection.Count); //$NON-NLS-1$
/*Assertion.Assert("Should return true", collection.RetainAll(c)); //$NON-NLS-1$
* Assertion.AssertEquals("Wrong size", 1, collection.Count); //$NON-NLS-1$
* Assertion.Assert("Should return false", !collection.RetainAll(c)); //$NON-NLS-1$*/
Assertion.AssertEquals(2, collection.Count);
double[] array = collection.ToArray();
Assertion.AssertEquals("Wrong length", 2, array.Length); //$NON-NLS-1$
Assertion.AssertEquals("Wrong key", 1, array[0]); //$NON-NLS-1$
enumColorMap = new EnumMap <Color, Double>(typeof(Color));
enumColorMap.Put(Color.Red, 1);
enumColorMap.Put(Color.Blue, 0);
collection = enumColorMap.Values();
Assertion.AssertEquals("Wrong size", 2, collection.Count); //$NON-NLS-1$
Assertion.Assert("Returned true when the object can not be removed", //$NON-NLS-1$
!collection.Remove(Int32.Parse("10"))); //$NON-NLS-1$
IEnumerator <double> iter = enumColorMap.Values().GetEnumerator();
iter.MoveNext();
double value = iter.Current;
Assertion.Assert("Returned false for contained object", collection //$NON-NLS-1$
.Contains(value));
iter.MoveNext();
value = iter.Current;
Assertion.Assert("Returned false for contained object", collection //$NON-NLS-1$
.Contains(value));
enumColorMap.Put(Color.Green, 1);
enumColorMap.Remove(Color.Blue);
Assertion.Assert("Returned true for uncontained object", !collection //$NON-NLS-1$
.Contains(value));
/*iter.Remove();
* try {
* iter.remove();
* fail("Should throw IllegalStateException"); //$NON-NLS-1$
* } catch (IllegalStateException e) {
* // Expected
* }*/
Assertion.Assert("Returned true for uncontained object", !collection //$NON-NLS-1$
.Contains(value));
iter = enumColorMap.Values().GetEnumerator();
iter.MoveNext();
value = iter.Current;
Assertion.Assert("Returned false for contained object", collection //$NON-NLS-1$
.Contains(value));
enumColorMap.Put(Color.Green, 3);
Assertion.Assert("Returned false for contained object", collection //$NON-NLS-1$
.Contains(value));
Assertion.Assert("Returned false for contained object", collection //$NON-NLS-1$
.Remove(Int32.Parse("1"))); //$NON-NLS-1$
Assertion.AssertEquals("Wrong size", 1, collection.Count); //$NON-NLS-1$
collection.Clear();
Assertion.AssertEquals("Wrong size", 0, collection.Count); //$NON-NLS-1$
enumColorMap = new EnumMap <Color, Double>(typeof(Color));
Int32 integer1 = 1;
enumColorMap.Put(Color.Green, integer1);
enumColorMap.Put(Color.Blue, 0);
collection = enumColorMap.Values();
iter = enumColorMap.Values().GetEnumerator();
/* try {
* iter.remove();
* fail("Should throw IllegalStateException"); //$NON-NLS-1$
* } catch (IllegalStateException e) {
* // Expected
* }*/
iter.MoveNext();
value = iter.Current;
Assertion.AssertEquals("Wrong value", integer1, value); //$NON-NLS-1$
Assertion.AssertEquals("Wrong value", integer1, value); //$NON-NLS-1$
Assertion.Assert("Returned true for unequal object", !iter.Equals(value)); //$NON-NLS-1$
/*iter.Remove();
* Assertion.Assert("Returned true for unequal object", !iter.Equals(value)); //$NON-NLS-1$
* try {
* iter.Remove();
* fail("Should throw IllegalStateException"); //$NON-NLS-1$
* } catch (IllegalStateException e) {
* // Expected
* }*/
Assertion.AssertEquals("Wrong size", 2, collection.Count); //$NON-NLS-1$
iter.MoveNext();
value = iter.Current;
Assertion.Assert("Returned true for unequal object", !iter.Equals(value)); //$NON-NLS-1$
//iter.Remove();
/*try {
* iter.next();
* fail("Should throw NoSuchElementException"); //$NON-NLS-1$
* } catch (NoSuchElementException e) {
* // Expected
* }*/
}
public void keySet()
{
EnumMap <Size, Int32> enumSizeMap = new EnumMap <Size, Int32>(typeof(Size));
enumSizeMap.Put(Size.Middle, 2);
//enumSizeMap.Put(Size.Big, null);
ISet <Size> set = enumSizeMap.KeySet();
ISet <Size> set1 = enumSizeMap.KeySet();
Assertion.AssertSame("Should be same", set1, set); //$NON-NLS-1$
Assertion.Assert("Returned false for contained object", set //$NON-NLS-1$
.Contains(Size.Middle));
//Assertion.Assert("Returned false for contained object", set//$NON-NLS-1$
// .Contains(Size.Big));
Assertion.Assert("Returned true for uncontained object", !set //$NON-NLS-1$
.Contains(Size.Small));
//Assertion.Assert("Returned true for uncontained object", !set //$NON-NLS-1$
// .Contains(1));
//Assertion.Assert("Returned false when the object can be removed", set //$NON-NLS-1$
// .Remove(Size.Big));
Assertion.Assert("Returned true for uncontained object", !set //$NON-NLS-1$
.Contains(Size.Big));
Assertion.Assert("Returned true when the object can not be removed", !set //$NON-NLS-1$
.Remove(Size.Big));
//Assertion.Assert("Returned true when the object can not be removed", !set //$NON-NLS-1$
// .Remove(1));
// The set is backed by the map so changes to one are reflected by the
// other.
enumSizeMap.Put(Size.Big, 3);
Assertion.Assert("Returned false for contained object", set//$NON-NLS-1$
.Contains(Size.Big));
enumSizeMap.Remove(Size.Big);
Assertion.Assert("Returned true for uncontained object", !set //$NON-NLS-1$
.Contains(Size.Big));
Assertion.AssertEquals("Wrong size", 1, set.Count); //$NON-NLS-1$
set.Clear();
Assertion.AssertEquals("Wrong size", 0, set.Count); //$NON-NLS-1$
enumSizeMap = new EnumMap <Size, Int32>(typeof(Size));
enumSizeMap.Put(Size.Middle, 1);
enumSizeMap.Put(Size.Big, 0);
set = enumSizeMap.KeySet();
ICollection <Size> c = new List <Size>();
c.Add(Size.Big);
// Assertion.Assert("Should return true", set.ContainsAll(c)); //$NON-NLS-1$
c.Add(Size.Small);
Assertion.Assert("Should return false", !set.ContainsAll(c)); //$NON-NLS-1$
Assertion.Assert("Should return true", set.RemoveAll(c)); //$NON-NLS-1$
Assertion.AssertEquals("Wrong size", 1, set.Count); //$NON-NLS-1$
Assertion.Assert("Should return false", !set.RemoveAll(c)); //$NON-NLS-1$
Assertion.AssertEquals("Wrong size", 1, set.Count); //$NON-NLS-1$
enumSizeMap.Put(Size.Big, 0);
Assertion.AssertEquals("Wrong size", 2, set.Count); //$NON-NLS-1$
Assertion.Assert("Should return true", set.RetainAll(c)); //$NON-NLS-1$
Assertion.AssertEquals("Wrong size", 1, set.Count); //$NON-NLS-1$
Assertion.Assert("Should return false", !set.RetainAll(c)); //$NON-NLS-1$
Assertion.AssertEquals(1, set.Count);
Size[] array = set.ToArray();
Assertion.AssertEquals("Wrong length", 1, array.Length); //$NON-NLS-1$
Assertion.AssertEquals("Wrong key", Size.Big, array[0]); //$NON-NLS-1$
enumSizeMap = new EnumMap <Size, Int32>(typeof(Size));
enumSizeMap.Put(Size.Middle, 1);
enumSizeMap.Put(Size.Big, 0);
set = enumSizeMap.KeySet();
c = new List <Size>();
//c.Add(Color.Blue);
//Assertion.Assert("Should return false", !set.Remove(c)); //$NON-NLS-1$
Assertion.AssertEquals("Wrong size", 2, set.Count); //$NON-NLS-1$
Assertion.Assert("Should return true", set.RetainAll(c)); //$NON-NLS-1$
Assertion.AssertEquals("Wrong size", 0, set.Count); //$NON-NLS-1$
enumSizeMap = new EnumMap <Size, Int32>(typeof(Size));
enumSizeMap.Put(Size.Middle, 1);
enumSizeMap.Put(Size.Big, 0);
set = enumSizeMap.KeySet();
IEnumerator <Size> iter = set.GetEnumerator();
iter.MoveNext();
Enum enumKey = (Enum)iter.Current;
Assertion.Assert("Returned false for contained object", set.Contains((Size)enumKey)); //$NON-NLS-1$
iter.MoveNext();
enumKey = (Enum)iter.Current;
Assertion.Assert("Returned false for contained object", set.Contains((Size)enumKey)); //$NON-NLS-1$
enumSizeMap.Remove(Size.Big);
Assertion.Assert("Returned true for uncontained object", !set //$NON-NLS-1$
.Contains((Size)enumKey));
// iter.Remove();
/*
* try {
* iter.remove();
* fail("Should throw IllegalStateException"); //$NON-NLS-1$
* } catch (IllegalStateException e) {
* // Expected
* }
* assertFalse("Returned true for uncontained object", set //$NON-NLS-1$
* .contains(enumKey));
*/
iter = set.GetEnumerator();
iter.MoveNext();
enumKey = (Enum)iter.Current;
Assertion.Assert("Returned false for contained object", set.Contains((Size)enumKey)); //$NON-NLS-1$
enumSizeMap.Put(Size.Middle, 3);
Assertion.Assert("Returned false for contained object", set.Contains((Size)enumKey)); //$NON-NLS-1$
enumSizeMap = new EnumMap <Size, Int32>(typeof(Size));
enumSizeMap.Put(Size.Middle, 1);
enumSizeMap.Put(Size.Big, 0);
set = enumSizeMap.KeySet();
iter = set.GetEnumerator();
/*try {
* iter.remove();
* fail("Should throw IllegalStateException"); //$NON-NLS-1$
* } catch (IllegalStateException e) {
* // Expected
* }*/
iter.MoveNext();
enumKey = (Enum)iter.Current;
Assertion.AssertEquals("Wrong key", Size.Middle, enumKey); //$NON-NLS-1$
Assertion.AssertEquals("Wrong key", Size.Middle, enumKey); //$NON-NLS-1$
Assertion.Assert("Returned true for unequal object", !iter.Equals(enumKey)); //$NON-NLS-1$
// iter.Remove();
//Assertion.Assert("Returned true for uncontained object", !set //$NON-NLS-1$
// .Contains((Size)enumKey));
/*try {
* iter.remove();
* fail("Should throw IllegalStateException"); //$NON-NLS-1$
* } catch (IllegalStateException e) {
* // Expected
* }*/
Assertion.AssertEquals("Wrong size", 2, set.Count); //$NON-NLS-1$
iter.MoveNext();
enumKey = (Enum)iter.Current;
Assertion.AssertEquals("Wrong key", Size.Big, enumKey); //$NON-NLS-1$
/*iter.remove();
* try {
* iter.next();
* fail("Should throw NoSuchElementException"); //$NON-NLS-1$
* } catch (NoSuchElementException e) {
* // Expected
* }*/
}
static void Main(string[] args)
{
ArrayList a = new ArrayList();
a.Add(12);
a.Add(32);
a.Add(21);
a.Add(45);
a.Sort();
Console.WriteLine(a.Capacity);
Console.WriteLine(a.BinarySearch(32));
Console.WriteLine(a.SyncRoot);
object[] o = a.ToArray();
foreach (object i in o)
{
Console.WriteLine(i);
}
foreach (object i in a)
{
Console.WriteLine(i);
}
Array v = a.ToArray();
foreach (object i in v)
{
Console.WriteLine(i);
}
Console.WriteLine(a.Count);
Console.WriteLine(a.Contains(21));
//elements
foreach (int i in a.GetRange(0, 3))
{
Console.WriteLine(i);
}
IEnumerator aa = a.GetEnumerator();
IEnumerator aaa = a.GetEnumerator(0, 2);
Console.WriteLine(aaa.MoveNext());
Console.WriteLine(aaa.Current);
Console.WriteLine(aa.MoveNext());
Console.WriteLine(aa.Equals(aaa));
Console.WriteLine(a.IndexOf(21));
a.Insert(1, 10);
a.Reverse();
foreach (object i in a)
{
Console.WriteLine(i);
}
Console.WriteLine(a.IsFixedSize);
Console.WriteLine(a.LastIndexOf(45));
a.Remove(45);
foreach (object i in a)
{
Console.WriteLine(i);
}
//sortedList in generic
Console.WriteLine("sortedList in generic mode");
SortedList <int, string> s = new SortedList <int, string>();
s.Add(1, "veera");
s.Add(2, "madhu");
s.Add(0, "veerababu");
foreach (int i in s.Keys)
{
Console.WriteLine(s[i]);
}
foreach (string i in s.Values)
{
Console.WriteLine(i);
}
Console.WriteLine(s.Count);
s.RemoveAt(0);
foreach (string i in s.Values)
{
Console.WriteLine(i);
}
Console.WriteLine(s.ContainsValue("madhu"));
Console.WriteLine(s.ContainsKey(1));
Console.WriteLine(s.ContainsKey(4));
Console.WriteLine(s.IndexOfValue("veerab"));
//sortedLIst in Non-generic mode
Console.WriteLine("sortedList in Non-generic mode");
SortedList ss = new SortedList();
//sorted table automatically sorted based on keys.
ss.Add(1, "veera");
ss.Add(2, "srinu");
ss.Add(0, "sai");
foreach (object i in ss.Keys)
{
Console.WriteLine(i);
}
foreach (object i in ss.Values)
{
Console.WriteLine(i);
}
object m = ss.Clone();
Console.WriteLine(m);
}
