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);
        }
      }
    }
Пример #2
0
        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"]);
        }
Пример #3
0
        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");
        }
Пример #4
0
        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");
        }
Пример #5
0
        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");
        }
Пример #6
0
        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>();
 }