private OperatorGraphVisualizationInfo(OperatorGraphVisualizationInfo original, Cloner cloner)
: base(original, cloner) {
operatorShapeInfoMapping = new BidirectionalLookup<IOperator, IOperatorShapeInfo>();
operatorParameterCollectionMapping = new BidirectionalLookup<IOperator, IKeyedItemCollection<string, IParameter>>();
parameterOperatorMapping = new Dictionary<IParameter, IOperator>();
operatorGraph = cloner.Clone(original.operatorGraph);
RegisterOperatorGraphEvents();
oldInitialShape = cloner.Clone(original.oldInitialShape);
oldInitialShapeColor = original.oldInitialShapeColor;
foreach (KeyValuePair<IOperator, IOperatorShapeInfo> pair in original.operatorShapeInfoMapping.FirstEnumerable) {
IOperator op = cloner.Clone(pair.Key);
IOperatorShapeInfo shapeInfo = cloner.Clone(pair.Value);
RegisterOperatorEvents(op);
operatorParameterCollectionMapping.Add(op, op.Parameters);
operatorShapeInfoMapping.Add(op, shapeInfo);
}
foreach (IOperator oper in operatorShapeInfoMapping.FirstValues) {
foreach (IParameter param in oper.Parameters) {
parameterOperatorMapping.Add(param, oper);
IValueParameter opParam = param as IValueParameter;
if (opParam != null && typeof(IOperator).IsAssignableFrom(param.DataType))
RegisterOperatorParameterEvents(opParam);
else
RegisterParameterEvents(param);
}
}
}
public void ClearInverse()
{
var lookup = new BidirectionalLookup <string, string>();
lookup.Add("foo", "bar");
lookup.Clear();
Assert.AreEqual(0, lookup.Count);
Assert.AreEqual(0, lookup.Inverse.Count);
Assert.IsFalse(lookup.Contains("foo"));
CollectionAssert.IsEmpty(lookup["foo"]);
CollectionAssert.IsEmpty(lookup.Inverse["bar"]);
}
public void RemoveElementInverse()
{
var lookup = new BidirectionalLookup <string, string>();
lookup.Add("baz", "bar");
lookup.Add("foo", "bar");
lookup.Add("foo", "baz");
lookup.Remove("foo", "bar");
CollectionAssert.DoesNotContain(lookup["foo"], "bar");
CollectionAssert.DoesNotContain(lookup.Inverse["bar"], "foo");
CollectionAssert.Contains(lookup["foo"], "baz");
CollectionAssert.Contains(lookup.Inverse["bar"], "baz");
}
public void AddCustomValueComparer()
{
var comparer = new DelegatedEqualityComparer <string, int> (s => s.Length);
var lookup = new BidirectionalLookup <string, string> (comparer, comparer);
lookup.Add("foo", "bar1");
lookup.Add("bar", "baz1");
Assert.IsTrue(lookup.Contains("baz"));
Assert.IsTrue(lookup.Inverse.Contains("foo1"));
CollectionAssert.Contains(lookup["foo"], "bar1");
CollectionAssert.Contains(lookup["foo"], "baz1");
CollectionAssert.Contains(lookup["bar"], "bar1");
CollectionAssert.Contains(lookup["bar"], "bar1");
}
public void RemoveKeyInverse()
{
var lookup = new BidirectionalLookup <string, string>();
lookup.Add("baz", "bar");
lookup.Add("foo", "bar");
lookup.Add("foo", "baz");
lookup.Inverse.Remove("bar");
Assert.IsFalse(lookup.Contains("baz"));
Assert.IsFalse(lookup.Inverse.Contains("bar"));
CollectionAssert.Contains(lookup["foo"], "baz");
CollectionAssert.DoesNotContain(lookup["foo"], "bar");
CollectionAssert.IsEmpty(lookup["baz"]);
CollectionAssert.IsEmpty(lookup.Inverse["bar"]);
CollectionAssert.Contains(lookup.Inverse["baz"], "foo");
}
public void AddInverse()
{
var lookup = new BidirectionalLookup <string, string>();
lookup.Add("foo", "bar");
lookup.Add("foo", "baz");
lookup.Add("baz", "bar");
Assert.AreEqual(2, lookup.Count);
Assert.AreEqual(2, lookup.Count);
Assert.IsTrue(lookup.Contains("foo"));
Assert.IsTrue(lookup.Contains("baz"));
Assert.IsFalse(lookup.Contains("bar"));
Assert.IsFalse(lookup.Inverse.Contains("foo"));
Assert.IsTrue(lookup.Inverse.Contains("bar"));
Assert.IsTrue(lookup.Inverse.Contains("baz"));
CollectionAssert.Contains(lookup["foo"], "bar");
CollectionAssert.Contains(lookup["foo"], "baz");
CollectionAssert.Contains(lookup.Inverse["bar"], "foo");
CollectionAssert.Contains(lookup.Inverse["bar"], "baz");
CollectionAssert.Contains(lookup["baz"], "bar");
}
public void TestBidirectionalLookup()
{
var lookup1 = new BidirectionalLookup <int, double>();
lookup1.Add(4, 2);
Assert.IsTrue(lookup1.ContainsFirst(4) && lookup1.ContainsSecond(2));
lookup1.Add(4, 3);
Assert.IsTrue(lookup1.GetByFirst(4).Count() == 2);
Assert.IsTrue(lookup1.GetBySecond(2).Contains(4));
Assert.IsTrue(lookup1.CountFirst == 1);
Assert.IsTrue(lookup1.CountSecond == 2);
lookup1.Add(3, 2);
lookup1.Add(2, 2);
lookup1.Add(1, 2);
Assert.IsTrue(lookup1.GetByFirst(1).Single() == 2);
Assert.IsTrue(lookup1.GetBySecond(2).Count() == 4);
lookup1.RemovePair(2, 2);
Assert.IsTrue(!lookup1.ContainsFirst(2));
Assert.IsTrue(lookup1.GetBySecond(2).Count() == 3);
lookup1.RemoveByFirst(4);
Assert.IsTrue(lookup1.CountFirst == 2);
Assert.IsTrue(lookup1.CountSecond == 1);
lookup1.RemoveBySecond(2);
Assert.IsTrue(lookup1.CountFirst == 0);
Assert.IsTrue(lookup1.CountSecond == 0);
lookup1.Clear();
Assert.IsTrue(lookup1.CountFirst == 0);
Assert.IsTrue(lookup1.CountSecond == 0);
var dict2 = new BidirectionalLookup <ComplexType, int>(new ComplexTypeEqualityComparer());
Assert.IsTrue(!dict2.FirstEnumerable.Any());
dict2.Add(new ComplexType(1), 2);
Assert.IsTrue(dict2.SecondEnumerable.Any());
dict2.Add(new ComplexType(2), 1);
Assert.IsTrue(dict2.ContainsFirst(new ComplexType(2)));
Assert.IsTrue(dict2.ContainsSecond(2));
dict2.Add(new ComplexType(2), 3);
Assert.IsTrue(dict2.GetByFirst(new ComplexType(2)).Count() == 2);
Assert.IsTrue(dict2.GetByFirst(new ComplexType(2)).Contains(1));
Assert.IsTrue(dict2.GetByFirst(new ComplexType(2)).Contains(3));
dict2.Add(new ComplexType(3), 1);
Assert.IsTrue(dict2.GetBySecond(1).Count() == 2);
Assert.IsTrue(dict2.GetBySecond(1).Any(x => x.Field == 2));
Assert.IsTrue(dict2.GetBySecond(1).Any(x => x.Field == 3));
Assert.IsTrue(dict2.CountFirst == 3);
Assert.IsTrue(dict2.CountSecond == 3);
dict2.Add(new ComplexType(2), 2);
Assert.IsTrue(dict2.CountFirst == 3);
Assert.IsTrue(dict2.CountSecond == 3);
dict2.Add(new ComplexType(2), 4);
Assert.IsTrue(dict2.CountFirst == 3);
Assert.IsTrue(dict2.CountSecond == 4);
dict2.RemoveByFirst(new ComplexType(2));
Assert.IsTrue(dict2.CountFirst == 2);
Assert.IsTrue(dict2.CountSecond == 2);
dict2.RemovePair(new ComplexType(1), 1);
Assert.IsTrue(dict2.CountFirst == 2);
Assert.IsTrue(dict2.CountSecond == 2);
dict2.RemovePair(new ComplexType(1), 2);
Assert.IsTrue(dict2.CountFirst == 1);
Assert.IsTrue(dict2.CountSecond == 1);
dict2.Clear();
Assert.IsTrue(!dict2.SecondEnumerable.Any());
}
private OperatorGraphVisualizationInfo(bool deserializing)
: base(deserializing) {
this.operatorParameterCollectionMapping = new BidirectionalLookup<IOperator, IKeyedItemCollection<string, IParameter>>();
this.parameterOperatorMapping = new Dictionary<IParameter, IOperator>();
}
