private static void SetAnnotation(IEnumerable <IEdmDirectValueAnnotation> immutableAnnotations, ref VersioningList <IEdmDirectValueAnnotation> transientAnnotations, string namespaceName, string localName, object value)
        {
            bool needTombstone = false;

            if (immutableAnnotations != null)
            {
                foreach (IEdmDirectValueAnnotation existingAnnotation in immutableAnnotations)
                {
                    if (existingAnnotation.NamespaceUri == namespaceName && existingAnnotation.Name == localName)
                    {
                        needTombstone = true;
                        break;
                    }
                }
            }

            if (value == null)
            {
                // "Removing" an immutable annotation leaves behind a transient annotation with a null value
                // as a tombstone to hide the immutable annotation. The normal logic below makes this happen.
                // Removing a transient annotation actually takes the annotation away.
                if (!needTombstone)
                {
                    RemoveTransientAnnotation(ref transientAnnotations, namespaceName, localName);
                    return;
                }
            }

            IEdmDirectValueAnnotation newAnnotation = value != null ?
                                                      new EdmDirectValueAnnotation(namespaceName, localName, value) :
                                                      new EdmDirectValueAnnotation(namespaceName, localName);

            if (transientAnnotations == null)
            {
                transientAnnotations = VersioningList <IEdmDirectValueAnnotation> .Create().Add(newAnnotation);

                return;
            }

            for (int index = 0; index < transientAnnotations.Count; index++)
            {
                IEdmDirectValueAnnotation existingAnnotation = transientAnnotations[index];
                if (existingAnnotation.NamespaceUri == namespaceName && existingAnnotation.Name == localName)
                {
                    transientAnnotations = transientAnnotations.RemoveAt(index);
                    break;
                }
            }

            transientAnnotations = transientAnnotations.Add(newAnnotation);
        }
Пример #2
0
        public void StringVersioningLists()
        {
            VersioningList <string> list1 = VersioningList <string> .Create();

            string a = "";

            for (int i = 0; i < 1000; i++)
            {
                a     = a + "a";
                list1 = list1.Add(a);
            }

            a = "";
            int count = 0;

            foreach (string s in list1)
            {
                a = a + "a";
                Assert.AreEqual(a, s, "Element value");
                count++;
            }

            Assert.AreEqual(1000, count, "Element count");
        }
Пример #3
0
        private static void SetAnnotation(IEnumerable <IEdmDirectValueAnnotation> immutableAnnotations, ref object transientAnnotations, string namespaceName, string localName, object value)
        {
            bool needTombstone = false;

            if (immutableAnnotations != null)
            {
                if (immutableAnnotations.Any(existingAnnotation => existingAnnotation.NamespaceUri == namespaceName && existingAnnotation.Name == localName))
                {
                    needTombstone = true;
                }
            }

            if (value == null)
            {
                // "Removing" an immutable annotation leaves behind a transient annotation with a null value
                // as a tombstone to hide the immutable annotation. The normal logic below makes this happen.
                // Removing a transient annotation actually takes the annotation away.
                if (!needTombstone)
                {
                    RemoveTransientAnnotation(ref transientAnnotations, namespaceName, localName);
                    return;
                }
            }

            if (namespaceName == EdmConstants.DocumentationUri && value != null && !(value is IEdmDocumentation))
            {
                throw new InvalidOperationException(Edm.Strings.Annotations_DocumentationPun(value.GetType().Name));
            }

            IEdmDirectValueAnnotation newAnnotation = value != null ?
                                                      new EdmDirectValueAnnotation(namespaceName, localName, value) :
                                                      new EdmDirectValueAnnotation(namespaceName, localName);

            if (transientAnnotations == null)
            {
                transientAnnotations = newAnnotation;
                return;
            }

            IEdmDirectValueAnnotation singleAnnotation = transientAnnotations as IEdmDirectValueAnnotation;

            if (singleAnnotation != null)
            {
                if (singleAnnotation.NamespaceUri == namespaceName && singleAnnotation.Name == localName)
                {
                    transientAnnotations = newAnnotation;
                }
                else
                {
                    transientAnnotations = VersioningList <IEdmDirectValueAnnotation> .Create().Add(singleAnnotation).Add(newAnnotation);
                }

                return;
            }

            VersioningList <IEdmDirectValueAnnotation> annotationsList = (VersioningList <IEdmDirectValueAnnotation>)transientAnnotations;

            for (int index = 0; index < annotationsList.Count; index++)
            {
                IEdmDirectValueAnnotation existingAnnotation = annotationsList[index];
                if (existingAnnotation.NamespaceUri == namespaceName && existingAnnotation.Name == localName)
                {
                    annotationsList = annotationsList.RemoveAt(index);
                    break;
                }
            }

            transientAnnotations = annotationsList.Add(newAnnotation);
        }
Пример #4
0
        public void IntegerVersioningLists()
        {
            VersioningList <int> list1 = VersioningList <int> .Create();

            Assert.IsTrue(list1 is VersioningList <int> .EmptyVersioningList, "List type");
            TestList(list1, 0);

            VersioningList <int> list2 = list1.Add(0);

            Assert.IsTrue(list2 is VersioningList <int> .ArrayVersioningList, "List type");
            TestList(list2, 1);

            VersioningList <int> list3 = list1.Add(0);

            Assert.IsTrue(list3 is VersioningList <int> .ArrayVersioningList, "List type");
            TestList(list3, 1);

            VersioningList <int> list4 = list2.Add(10);

            Assert.IsTrue(list4 is VersioningList <int> .ArrayVersioningList, "List type");
            TestList(list4, 2);

            VersioningList <int> list5 = list4.Add(20);

            Assert.IsTrue(list5 is VersioningList <int> .ArrayVersioningList, "List type");
            TestList(list5, 3);

            VersioningList <int> list6 = list5.Add(30);

            Assert.IsTrue(list6 is VersioningList <int> .ArrayVersioningList, "List type");
            TestList(list6, 4);

            VersioningList <int> list7 = list6.Add(40);

            Assert.IsTrue(list7 is VersioningList <int> .ArrayVersioningList, "List type");
            TestList(list7, 5);

            VersioningList <int> list8 = list7.Add(50);

            Assert.IsTrue(list8 is VersioningList <int> .ArrayVersioningList, "List type");
            TestList(list8, 6);

            VersioningList <int> list9 = list8.Add(60);

            Assert.IsTrue(list9 is VersioningList <int> .ArrayVersioningList, "List type");
            TestList(list9, 7);

            TestList(list8, 6);
            TestList(list7, 5);
            TestList(list6, 4);
            TestList(list5, 3);
            TestList(list4, 2);
            TestList(list3, 1);
            TestList(list2, 1);
            TestList(list1, 0);

            for (int index = 0; index < list9.Count; index++)
            {
                VersioningList <int> list00 = list9.RemoveAt(index);
                TestList(list00, 7, index);
            }

            TestList(list9, 7);

            VersioningList <int> shrinker = list9;
            int expectedCount             = list9.Count;

            for (int index = 0; index < list9.Count; index++)
            {
                Assert.AreEqual(index * 10, shrinker[0], "Shrinking value");
                expectedCount--;
                shrinker = shrinker.RemoveAt(0);
                Assert.AreEqual(expectedCount, shrinker.Count, "Shrinking count");
            }

            shrinker      = list9;
            expectedCount = list9.Count;
            for (int index = list9.Count - 1; index >= 0; index--)
            {
                Assert.AreEqual(index * 10, shrinker[index], "Shrinking value");
                expectedCount--;
                shrinker = shrinker.RemoveAt(index);
                Assert.AreEqual(expectedCount, shrinker.Count, "Shrinking count");
            }

            TestList(list9, 7);
        }
Пример #5
0
        private static void SetAnnotation(IEnumerable <IEdmDirectValueAnnotation> immutableAnnotations, ref object transientAnnotations, string namespaceName, string localName, object value)
        {
            IEdmDirectValueAnnotation edmDirectValueAnnotation;
            Func <IEdmDirectValueAnnotation, bool> func = null;
            bool flag = false;

            if (immutableAnnotations != null)
            {
                IEnumerable <IEdmDirectValueAnnotation> edmDirectValueAnnotations = immutableAnnotations;
                if (func == null)
                {
                    func = (IEdmDirectValueAnnotation existingAnnotation) => {
                        if (existingAnnotation.NamespaceUri != namespaceName)
                        {
                            return(false);
                        }
                        else
                        {
                            return(existingAnnotation.Name == localName);
                        }
                    }
                    ;
                }
                if (edmDirectValueAnnotations.Any <IEdmDirectValueAnnotation>(func))
                {
                    flag = true;
                }
            }
            if (value != null || flag)
            {
                if (!(namespaceName == "http://schemas.microsoft.com/ado/2011/04/edm/documentation") || value == null || value as IEdmDocumentation != null)
                {
                    if (value != null)
                    {
                        edmDirectValueAnnotation = new EdmDirectValueAnnotation(namespaceName, localName, value);
                    }
                    else
                    {
                        edmDirectValueAnnotation = new EdmDirectValueAnnotation(namespaceName, localName);
                    }
                    IEdmDirectValueAnnotation edmDirectValueAnnotation1 = edmDirectValueAnnotation;
                    if (transientAnnotations != null)
                    {
                        IEdmDirectValueAnnotation edmDirectValueAnnotation2 = transientAnnotations as IEdmDirectValueAnnotation;
                        if (edmDirectValueAnnotation2 == null)
                        {
                            VersioningList <IEdmDirectValueAnnotation> edmDirectValueAnnotations1 = (VersioningList <IEdmDirectValueAnnotation>)transientAnnotations;
                            int num = 0;
                            while (num < edmDirectValueAnnotations1.Count)
                            {
                                IEdmDirectValueAnnotation item = edmDirectValueAnnotations1[num];
                                if (!(item.NamespaceUri == namespaceName) || !(item.Name == localName))
                                {
                                    num++;
                                }
                                else
                                {
                                    edmDirectValueAnnotations1 = edmDirectValueAnnotations1.RemoveAt(num);
                                    break;
                                }
                            }
                            transientAnnotations = edmDirectValueAnnotations1.Add(edmDirectValueAnnotation1);
                            return;
                        }
                        else
                        {
                            if (!(edmDirectValueAnnotation2.NamespaceUri == namespaceName) || !(edmDirectValueAnnotation2.Name == localName))
                            {
                                transientAnnotations = VersioningList <IEdmDirectValueAnnotation> .Create().Add(edmDirectValueAnnotation2).Add(edmDirectValueAnnotation1);

                                return;
                            }
                            else
                            {
                                transientAnnotations = edmDirectValueAnnotation1;
                                return;
                            }
                        }
                    }
                    else
                    {
                        transientAnnotations = edmDirectValueAnnotation1;
                        return;
                    }
                }
                else
                {
                    throw new InvalidOperationException(Strings.Annotations_DocumentationPun(value.GetType().Name));
                }
            }
            else
            {
                EdmDirectValueAnnotationsManager.RemoveTransientAnnotation(ref transientAnnotations, namespaceName, localName);
                return;
            }
        }