Example #1
0
        public void MapStringInsertion()
        {
            VersioningDictionary <string, int> stringMap = VersioningDictionary <string, int> .Create(CompareStrings);

            stringMap = stringMap.Set("Fred", 1);
            stringMap = stringMap.Set("Wilma", 2);
            stringMap = stringMap.Set("Betty", 3);
            stringMap = stringMap.Set("Barney", 4);
            Assert.IsTrue(stringMap is VersioningDictionary <string, int> .TreeDictionary, "Dictionary type");
            Assert.AreEqual(stringMap.Get("Fred"), 1, "Key value");
            Assert.AreEqual(stringMap.Get("Barney"), 4, "Key value");
            Assert.AreEqual(stringMap.Get("Betty"), 3, "Key value");
            Assert.AreEqual(stringMap.Get("Wilma"), 2, "Key value");

            for (int i = 1; i < 1000; i++)
            {
                stringMap = stringMap.Set("Fred" + i, i + 1);
                stringMap = stringMap.Set("Wilma" + i, i + 2);
                stringMap = stringMap.Set("Betty" + i, i + 3);
                stringMap = stringMap.Set("Barney" + i, i + 4);
            }
            Assert.IsTrue(stringMap is VersioningDictionary <string, int> .HashTreeDictionary, "Dictionary type");
            Assert.AreEqual(stringMap.Get("Fred"), 1, "Key value");
            Assert.AreEqual(stringMap.Get("Barney"), 4, "Key value");
            Assert.AreEqual(stringMap.Get("Betty"), 3, "Key value");
            Assert.AreEqual(stringMap.Get("Wilma"), 2, "Key value");
            for (int i = 1; i < 1000; i++)
            {
                Assert.AreEqual(stringMap.Get("Fred" + i), i + 1, "Key value");
                Assert.AreEqual(stringMap.Get("Wilma" + i), i + 2, "Key value");
                Assert.AreEqual(stringMap.Get("Betty" + i), i + 3, "Key value");
                Assert.AreEqual(stringMap.Get("Barney" + i), i + 4, "Key value");
            }
        }
Example #2
0
        private void SetAnnotationValue(IEdmElement element, string namespaceName, string localName, object value, ref VersioningDictionary <IEdmElement, object> annotationsDictionary)
        {
            object transientAnnotations = EdmDirectValueAnnotationsManager.GetTransientAnnotations(element, annotationsDictionary);
            object obj = transientAnnotations;

            EdmDirectValueAnnotationsManager.SetAnnotation(this.GetAttachedAnnotations(element), ref transientAnnotations, namespaceName, localName, value);
            if (transientAnnotations != obj)
            {
                annotationsDictionary = annotationsDictionary.Set(element, transientAnnotations);
            }
        }
Example #3
0
        private void SetAnnotationValue(IEdmElement element, string namespaceName, string localName, object value, ref VersioningDictionary <IEdmElement, object> annotationsDictionary)
        {
            object transientAnnotations          = GetTransientAnnotations(element, annotationsDictionary);
            object transientAnnotationsBeforeSet = transientAnnotations;

            SetAnnotation(this.GetAttachedAnnotations(element), ref transientAnnotations, namespaceName, localName, value);

            // There is at least one case (removing an annotation that was not present to begin with) where the transient annotations are not changed,
            // so test to see if updating the dictionary is necessary.
            if (transientAnnotations != transientAnnotationsBeforeSet)
            {
                annotationsDictionary = annotationsDictionary.Set(element, transientAnnotations);
            }
        }
        public static void SetNamespaceAlias(this IEdmModel model, string namespaceName, string alias)
        {
            VersioningDictionary <string, string> annotationValue = model.GetAnnotationValue <VersioningDictionary <string, string> >(model, "http://schemas.microsoft.com/ado/2011/04/edm/internal", "NamespaceAlias");

            if (annotationValue == null)
            {
                annotationValue = VersioningDictionary <string, string> .Create(new Func <string, string, int>(string.CompareOrdinal));
            }
            if (alias != null)
            {
                annotationValue = annotationValue.Set(namespaceName, alias);
            }
            else
            {
                annotationValue = annotationValue.Remove(namespaceName);
            }
            model.SetAnnotationValue(model, "http://schemas.microsoft.com/ado/2011/04/edm/internal", "NamespaceAlias", annotationValue);
        }
        /// <summary>
        /// Sets the serialization alias for a given namespace
        /// </summary>
        /// <param name="model">Model that will be serialized.</param>
        /// <param name="namespaceName">The namespace to set the alias for.</param>
        /// <param name="alias">The alias for that namespace.</param>
        public static void SetNamespaceAlias(this IEdmModel model, string namespaceName, string alias)
        {
            VersioningDictionary <string, string> mappings = model.GetAnnotationValue <VersioningDictionary <string, string> >(model, EdmConstants.InternalUri, CsdlConstants.NamespaceAliasAnnotation);

            if (mappings == null)
            {
                mappings = VersioningDictionary <string, string> .Create(string.CompareOrdinal);
            }

            if (alias == null)
            {
                mappings = mappings.Remove(namespaceName);
            }
            else
            {
                mappings = mappings.Set(namespaceName, alias);
            }

            model.SetAnnotationValue(model, EdmConstants.InternalUri, CsdlConstants.NamespaceAliasAnnotation, mappings);
        }
        /// <summary>
        /// Sets the serialization alias for a given namespace(including current model's schemas namespace-alias, and referenced models' schemas namespace-alias)
        /// TODO: REF make sure no duplicated alias.
        /// </summary>
        /// <param name="model">Model that will be serialized.</param>
        /// <param name="namespaceName">The namespace to set the alias for.</param>
        /// <param name="alias">The alias for that namespace.</param>
        public static void SetNamespaceAlias(this IEdmModel model, string namespaceName, string alias)
        {
            VersioningDictionary <string, string> mappings = model.GetAnnotationValue <VersioningDictionary <string, string> >(model, EdmConstants.InternalUri, CsdlConstants.NamespaceAliasAnnotation);

            if (mappings == null)
            {
                mappings = VersioningDictionary <string, string> .Create(string.CompareOrdinal);
            }

            if (EdmUtil.IsNullOrWhiteSpaceInternal(alias))
            {
                string val;
                if (mappings.TryGetValue(namespaceName, out val))
                {
                    mappings = mappings.Remove(namespaceName);
                }
            }
            else
            {
                mappings = mappings.Set(namespaceName, alias);
            }

            model.SetAnnotationValue(model, EdmConstants.InternalUri, CsdlConstants.NamespaceAliasAnnotation, mappings);

            var list = model.GetAnnotationValue <VersioningList <string> >(model, EdmConstants.InternalUri, CsdlConstants.UsedNamespacesAnnotation);

            if (list == null)
            {
                list = VersioningList <string> .Create();
            }

            if (!string.IsNullOrEmpty(namespaceName) && !list.Contains(namespaceName))
            {
                list = list.Add(namespaceName);
            }

            model.SetAnnotationValue(model, EdmConstants.InternalUri, CsdlConstants.UsedNamespacesAnnotation, list);
        }
        private void SetAnnotationValue(IEdmElement element, string namespaceName, string localName, object value, ref VersioningDictionary<IEdmElement, object> annotationsDictionary)
        {
            object transientAnnotations = GetTransientAnnotations(element, annotationsDictionary);
            object transientAnnotationsBeforeSet = transientAnnotations;
            SetAnnotation(this.GetAttachedAnnotations(element), ref transientAnnotations, namespaceName, localName, value);

            // There is at least one case (removing an annotation that was not present to begin with) where the transient annotations are not changed,
            // so test to see if updating the dictionary is necessary.
            if (transientAnnotations != transientAnnotationsBeforeSet)
            {
                annotationsDictionary = annotationsDictionary.Set(element, transientAnnotations);
            }
        }
		private void SetAnnotationValue(IEdmElement element, string namespaceName, string localName, object value, ref VersioningDictionary<IEdmElement, object> annotationsDictionary)
		{
			object transientAnnotations = EdmDirectValueAnnotationsManager.GetTransientAnnotations(element, annotationsDictionary);
			object obj = transientAnnotations;
			EdmDirectValueAnnotationsManager.SetAnnotation(this.GetAttachedAnnotations(element), ref transientAnnotations, namespaceName, localName, value);
			if (transientAnnotations != obj)
			{
				annotationsDictionary = annotationsDictionary.Set(element, transientAnnotations);
			}
		}
Example #9
0
        public void MapIntegerInsertionAndDeletion()
        {
            VersioningDictionary <int, int> map = VersioningDictionary <int, int> .Create(CompareIntegers);

            int value;

            Assert.IsTrue(map is VersioningDictionary <int, int> .EmptyVersioningDictionary, "Dictionary type");
            Assert.IsFalse(map.TryGetValue(0, out value), "Zero key");

            // Test conversions back and forth between EmptyDictionary, OneKeyDictionary, and TwoKeyDictionary.

            map = map.Set(1, 10);
            Assert.IsTrue(map is VersioningDictionary <int, int> .OneKeyDictionary, "Dictionary type");
            Assert.AreEqual(map.Get(1), 10, "Key value");
            Assert.IsFalse(map.TryGetValue(0, out value), "Zero key");

            map = map.Set(1, 100);
            Assert.IsTrue(map is VersioningDictionary <int, int> .OneKeyDictionary, "Dictionary type");
            Assert.AreEqual(map.Get(1), 100, "Key value");
            Assert.IsFalse(map.TryGetValue(0, out value), "Zero key");

            map = map.Remove(1);
            Assert.IsTrue(map is VersioningDictionary <int, int> .EmptyVersioningDictionary, "Dictionary type");

            map = map.Set(1, 10);
            map = map.Set(2, 20);
            Assert.IsTrue(map is VersioningDictionary <int, int> .TwoKeyDictionary, "Dictionary type");
            Assert.AreEqual(map.Get(1), 10, "Key value");
            Assert.AreEqual(map.Get(2), 20, "Key value");
            Assert.IsFalse(map.TryGetValue(0, out value), "Zero key");

            map = map.Set(1, 100);
            Assert.IsTrue(map is VersioningDictionary <int, int> .TwoKeyDictionary, "Dictionary type");
            Assert.AreEqual(map.Get(1), 100, "Key value");
            Assert.AreEqual(map.Get(2), 20, "Key value");

            map = map.Set(2, 200);
            Assert.IsTrue(map is VersioningDictionary <int, int> .TwoKeyDictionary, "Dictionary type");
            Assert.AreEqual(map.Get(1), 100, "Key value");
            Assert.AreEqual(map.Get(2), 200, "Key value");

            VersioningDictionary <int, int> oneMap = map.Remove(1);

            Assert.IsTrue(oneMap is VersioningDictionary <int, int> .OneKeyDictionary, "Dictionary type");
            Assert.AreEqual(oneMap.Get(2), 200, "Key value");

            Assert.IsTrue(map is VersioningDictionary <int, int> .TwoKeyDictionary, "Dictionary type");
            Assert.AreEqual(map.Get(1), 100, "Key value");
            Assert.AreEqual(map.Get(2), 200, "Key value");
            Assert.IsFalse(map.TryGetValue(0, out value), "Zero key");

            oneMap = map.Remove(2);
            Assert.IsTrue(oneMap is VersioningDictionary <int, int> .OneKeyDictionary, "Dictionary type");
            Assert.AreEqual(oneMap.Get(1), 100, "Key value");

            Assert.IsTrue(map is VersioningDictionary <int, int> .TwoKeyDictionary, "Dictionary type");
            Assert.AreEqual(map.Get(1), 100, "Key value");
            Assert.AreEqual(map.Get(2), 200, "Key value");

            // Test conversion to a TreeDictionary.

            map = map.Set(3, 30);
            Assert.IsTrue(map is VersioningDictionary <int, int> .TreeDictionary, "Dictionary type");
            Assert.AreEqual(map.Get(1), 100, "Key value");
            Assert.AreEqual(map.Get(2), 200, "Key value");
            Assert.AreEqual(map.Get(3), 30, "Key value");
            Assert.IsFalse(map.TryGetValue(0, out value), "Zero key");

            map = map.Set(3, 300);
            Assert.IsTrue(map is VersioningDictionary <int, int> .TreeDictionary, "Dictionary type");
            Assert.AreEqual(map.Get(1), 100, "Key value");
            Assert.AreEqual(map.Get(2), 200, "Key value");
            Assert.AreEqual(map.Get(3), 300, "Key value");

            // Test that a significant number of keys does not force conversion to a HashKeyDictionary.

            for (int i = 1; i <= 100; i++)
            {
                map = map.Set(i, i * 10);
            }
            Assert.IsTrue(map is VersioningDictionary <int, int> .TreeDictionary, "Dictionary type");
            for (int i = 1; i <= 100; i++)
            {
                Assert.AreEqual(i * 10, map.Get(i), "Key value");
            }
            Assert.IsFalse(map.TryGetValue(0, out value), "Zero key");

            // Test removing half the keys.

            for (int i = 1; i < 100; i += 2)
            {
                map = map.Remove(i);
            }
            Assert.IsTrue(map is VersioningDictionary <int, int> .TreeDictionary, "Dictionary type");
            for (int i = 1; i < 100; i += 2)
            {
                Assert.IsFalse(map.TryGetValue(i, out value), "Odd key");
                Assert.AreEqual((i + 1) * 10, map.Get(i + 1), "Even key value");
            }

            // Test conversion to a HashTreeDictionary.

            for (int i = 1; i <= 10000; i++)
            {
                map = map.Set(i, i * 2);
            }
            Assert.IsTrue(map is VersioningDictionary <int, int> .HashTreeDictionary, "Dictionary type");
            for (int i = 1; i <= 10000; i++)
            {
                Assert.AreEqual(i * 2, map.Get(i), "Key value");
            }
            Assert.IsFalse(map.TryGetValue(0, out value), "Zero key");

            // Test removing half the keys.

            for (int i = 1; i < 10000; i += 2)
            {
                map = map.Remove(i);
            }
            Assert.IsTrue(map is VersioningDictionary <int, int> .HashTreeDictionary, "Dictionary type");
            for (int i = 1; i < 10000; i += 2)
            {
                Assert.IsFalse(map.TryGetValue(i, out value), "Odd key");
                Assert.AreEqual((i + 1) * 2, map.Get(i + 1), "Even key value");
            }
        }