private object GetAnnotationValue(IEdmElement element, string namespaceName, string localName, VersioningDictionary <IEdmElement, object> annotationsDictionary) { IEdmDirectValueAnnotation annotation = FindTransientAnnotation(GetTransientAnnotations(element, annotationsDictionary), namespaceName, localName); if (annotation != null) { return(annotation.Value); } IEnumerable <IEdmDirectValueAnnotation> immutableAnnotations = this.GetAttachedAnnotations(element); if (immutableAnnotations != null) { foreach (IEdmDirectValueAnnotation existingAnnotation in immutableAnnotations) { if (existingAnnotation.NamespaceUri == namespaceName && existingAnnotation.Name == localName) { // No need to check that the immutable annotation isn't Dead, because if it were // the tombstone would have been found in the transient annotations. return(existingAnnotation.Value); } } } return(null); }
private static IEnumerable <IEdmDirectValueAnnotation> TransientAnnotations(object transientAnnotations) { if (transientAnnotations == null) { yield break; } IEdmDirectValueAnnotation singleAnnotation = transientAnnotations as IEdmDirectValueAnnotation; if (singleAnnotation != null) { if (singleAnnotation.Value != null) { yield return(singleAnnotation); } yield break; } VersioningList <IEdmDirectValueAnnotation> annotationsList = (VersioningList <IEdmDirectValueAnnotation>)transientAnnotations; foreach (IEdmDirectValueAnnotation existingAnnotation in annotationsList) { if (existingAnnotation.Value != null) { yield return(existingAnnotation); } } }
private static IEnumerable <IEdmDirectValueAnnotation> TransientAnnotations(object transientAnnotations) { if (transientAnnotations != null) { IEdmDirectValueAnnotation edmDirectValueAnnotation = transientAnnotations as IEdmDirectValueAnnotation; if (edmDirectValueAnnotation == null) { VersioningList <IEdmDirectValueAnnotation> edmDirectValueAnnotations = (VersioningList <IEdmDirectValueAnnotation>)transientAnnotations; foreach (IEdmDirectValueAnnotation edmDirectValueAnnotation1 in edmDirectValueAnnotations) { if (edmDirectValueAnnotation1.Value == null) { continue; } yield return(edmDirectValueAnnotation1); } } else { if (edmDirectValueAnnotation.Value != null) { yield return(edmDirectValueAnnotation); } } } }
private static bool IsEpmAnnotation(this IEdmDirectValueAnnotation annotation) { string str; string str2; return(annotation.IsEpmAnnotation(out str, out str2)); }
private object GetAnnotationValue(IEdmElement element, string namespaceName, string localName, VersioningDictionary <IEdmElement, object> annotationsDictionary) { object value; IEdmDirectValueAnnotation edmDirectValueAnnotation = EdmDirectValueAnnotationsManager.FindTransientAnnotation(EdmDirectValueAnnotationsManager.GetTransientAnnotations(element, annotationsDictionary), namespaceName, localName); if (edmDirectValueAnnotation == null) { IEnumerable <IEdmDirectValueAnnotation> attachedAnnotations = this.GetAttachedAnnotations(element); if (attachedAnnotations != null) { IEnumerator <IEdmDirectValueAnnotation> enumerator = attachedAnnotations.GetEnumerator(); using (enumerator) { while (enumerator.MoveNext()) { IEdmDirectValueAnnotation current = enumerator.Current; if (!(current.NamespaceUri == namespaceName) || !(current.Name == localName)) { continue; } value = current.Value; return(value); } return(null); } return(value); } return(null); } else { return(edmDirectValueAnnotation.Value); } }
public void AnnotableGetAnnotation_ReturnsWhatsBeenSet() { var model = new EdmModel(); foreach (IEdmElement annotatable in this.GetEdmAnnotatables()) { var qualifiedNames = this.GetInterestingQualifiedNames().ToArray(); // set for (int i = 0; i < qualifiedNames.Count(); i++) { MyQualifiedName q = qualifiedNames[i]; model.SetAnnotationValue(annotatable, q.NamespaceName, q.Name, q.MyFullName); Assert.AreEqual(i + 1, model.DirectValueAnnotations(annotatable).Count(), "Wrong # of Annotations on {0}.", annotatable); } // get object result = model.GetAnnotationValue(annotatable, "_Not_Exist_", "_Not_Exist_"); Assert.IsNull(result, "GetAnnotation() on {0}.", annotatable); foreach (MyQualifiedName q in qualifiedNames) { result = model.GetAnnotationValue(annotatable, q.NamespaceName, q.Name); Assert.AreEqual(q.MyFullName, result, "GetAnnotation() on {0}.", annotatable); IEdmDirectValueAnnotation annotation = model.DirectValueAnnotations(annotatable).FirstOrDefault(a => a.NamespaceUri == q.NamespaceName && a.Name == q.Name); Assert.IsNotNull(annotation, "GetAnnotation() on {0}.", annotatable); Assert.AreEqual(q.MyFullName, ((IEdmDirectValueAnnotation)annotation).Value, "GetAnnotation() on {0}.", annotatable); } } }
/// <summary> /// Retrieves an annotation value for an EDM element. Returns null if no annotation with the given name exists. /// </summary> /// <param name="element">The annotated element.</param> /// <param name="namespaceName">Namespace that the annotation belongs to.</param> /// <param name="localName">Local name of the annotation.</param> /// <returns>Returns the annotation that corresponds to the provided name. Returns null if no annotation with the given name exists. </returns> public object GetAnnotationValue(IEdmElement element, string namespaceName, string localName) { List <IEdmDirectValueAnnotation> elementAnnotations = this.FindAnnotations(element, false); IEdmDirectValueAnnotation annotation = FindAnnotation(elementAnnotations, namespaceName, localName); return(annotation != null ? annotation.Value : null); }
internal void WriteAnnotationStringAttribute(IEdmDirectValueAnnotation annotation) { var edmValue = (IEdmPrimitiveValue)annotation.Value; if (edmValue != null) { this.xmlWriter.WriteAttributeString(annotation.Name, annotation.NamespaceUri, EdmValueWriter.PrimitiveValueAsXml(edmValue)); } }
internal void WriteAnnotationStringElement(IEdmDirectValueAnnotation annotation) { var edmValue = (IEdmPrimitiveValue)annotation.Value; if (edmValue != null) { this.xmlWriter.WriteRaw(((IEdmStringValue)edmValue).Value); } }
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); }
private static string ConvertEdmAnnotationValue(IEdmDirectValueAnnotation annotation) { object obj2 = annotation.Value; if (obj2 == null) { return null; } IEdmStringValue value2 = obj2 as IEdmStringValue; if (value2 == null) { throw new ODataException(Microsoft.Data.OData.Strings.EpmExtensionMethods_CannotConvertEdmAnnotationValue(annotation.NamespaceUri, annotation.Name, annotation.GetType().FullName)); } return value2.Value; }
private static void RemoveTransientAnnotation(ref VersioningList <IEdmDirectValueAnnotation> transientAnnotations, string namespaceName, string localName) { if (transientAnnotations != null) { for (int index = 0; index < transientAnnotations.Count; index++) { IEdmDirectValueAnnotation existingAnnotation = transientAnnotations[index]; if (existingAnnotation.NamespaceUri == namespaceName && existingAnnotation.Name == localName) { transientAnnotations = transientAnnotations.RemoveAt(index); return; } } } }
private static IEnumerable <IEdmDirectValueAnnotation> TransientAnnotations(VersioningList <IEdmDirectValueAnnotation> transientAnnotations) { if (transientAnnotations == null) { yield break; } for (int index = 0; index < transientAnnotations.Count; index++) { IEdmDirectValueAnnotation existingAnnotation = transientAnnotations[index]; if (existingAnnotation.Value != null) { yield return(existingAnnotation); } } }
private static string ConvertEdmAnnotationValue(IEdmDirectValueAnnotation annotation) { object obj2 = annotation.Value; if (obj2 == null) { return(null); } IEdmStringValue value2 = obj2 as IEdmStringValue; if (value2 == null) { throw new ODataException(Microsoft.Data.OData.Strings.EpmExtensionMethods_CannotConvertEdmAnnotationValue(annotation.NamespaceUri, annotation.Name, annotation.GetType().FullName)); } return(value2.Value); }
/// <summary> /// Sets an annotation value for an EDM element. If the value is null, no annotation is added and an existing annotation with the same name is removed. /// </summary> /// <param name="element">The annotated element.</param> /// <param name="namespaceName">Namespace that the annotation belongs to.</param> /// <param name="localName">Name of the annotation within the namespace.</param> /// <param name="value">New annotation to set.</param> public void SetAnnotationValue(IEdmElement element, string namespaceName, string localName, object value) { List <IEdmDirectValueAnnotation> elementAnnotations = this.FindAnnotations(element, true); IEdmDirectValueAnnotation annotation = FindAnnotation(elementAnnotations, namespaceName, localName); if (annotation != null) { elementAnnotations.Remove(annotation); } if (value != null) { elementAnnotations.Add(new EdmDirectValueAnnotation(namespaceName, localName, value)); } }
private static bool IsEpmAnnotation(this IEdmDirectValueAnnotation annotation, out string baseName, out string suffix) { string name = annotation.Name; for (int i = 0; i < EpmAnnotationBaseNames.Length; i++) { string str2 = EpmAnnotationBaseNames[i]; if (name.StartsWith(str2, StringComparison.Ordinal)) { baseName = str2; suffix = name.Substring(str2.Length); return(true); } } baseName = null; suffix = null; return(false); }
private static IEdmDirectValueAnnotation FindTransientAnnotation(VersioningList <IEdmDirectValueAnnotation> transientAnnotations, string namespaceName, string localName) { if (transientAnnotations != null) { // This method runs very hot in schemas where direct value annotations are used. // 1. Doing indexed 'for' loop to avoid allocation of VersioningList enumerator. // 2. VersioningList random access is O(1) because it uses ArrayVersioningList. for (int index = 0; index < transientAnnotations.Count; index++) { IEdmDirectValueAnnotation existingAnnotation = transientAnnotations[index]; if (existingAnnotation.NamespaceUri == namespaceName && existingAnnotation.Name == localName) { return(existingAnnotation); } } } return(null); }
private static void RemoveTransientAnnotation(ref object transientAnnotations, string namespaceName, string localName) { if (transientAnnotations != null) { IEdmDirectValueAnnotation edmDirectValueAnnotation = transientAnnotations as IEdmDirectValueAnnotation; if (edmDirectValueAnnotation == null) { VersioningList <IEdmDirectValueAnnotation> edmDirectValueAnnotations = (VersioningList <IEdmDirectValueAnnotation>)transientAnnotations; int num = 0; while (num < edmDirectValueAnnotations.Count) { IEdmDirectValueAnnotation item = edmDirectValueAnnotations[num]; if (!(item.NamespaceUri == namespaceName) || !(item.Name == localName)) { num++; } else { edmDirectValueAnnotations = edmDirectValueAnnotations.RemoveAt(num); if (edmDirectValueAnnotations.Count != 1) { transientAnnotations = edmDirectValueAnnotations; return; } else { transientAnnotations = edmDirectValueAnnotations.Single <IEdmDirectValueAnnotation>(); return; } } } } else { if (edmDirectValueAnnotation.NamespaceUri == namespaceName && edmDirectValueAnnotation.Name == localName) { transientAnnotations = null; return; } } } }
private static IEdmDirectValueAnnotation FindTransientAnnotation(object transientAnnotations, string namespaceName, string localName) { if (transientAnnotations != null) { IEdmDirectValueAnnotation singleAnnotation = transientAnnotations as IEdmDirectValueAnnotation; if (singleAnnotation != null) { if (singleAnnotation.NamespaceUri == namespaceName && singleAnnotation.Name == localName) { return(singleAnnotation); } } else { VersioningList <IEdmDirectValueAnnotation> annotationsList = (VersioningList <IEdmDirectValueAnnotation>)transientAnnotations; return(annotationsList.FirstOrDefault( existingAnnotation => existingAnnotation.NamespaceUri == namespaceName && existingAnnotation.Name == localName)); } } return(null); }
private static void RemoveTransientAnnotation(ref object transientAnnotations, string namespaceName, string localName) { if (transientAnnotations != null) { IEdmDirectValueAnnotation singleAnnotation = transientAnnotations as IEdmDirectValueAnnotation; if (singleAnnotation != null) { if (singleAnnotation.NamespaceUri == namespaceName && singleAnnotation.Name == localName) { transientAnnotations = null; return; } } else { 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); if (annotationsList.Count == 1) { transientAnnotations = annotationsList.Single(); } else { transientAnnotations = annotationsList; } return; } } } } }
private static IEdmDirectValueAnnotation FindTransientAnnotation(object transientAnnotations, string namespaceName, string localName) { Func <IEdmDirectValueAnnotation, bool> func = null; if (transientAnnotations != null) { IEdmDirectValueAnnotation edmDirectValueAnnotation = transientAnnotations as IEdmDirectValueAnnotation; if (edmDirectValueAnnotation == null) { VersioningList <IEdmDirectValueAnnotation> edmDirectValueAnnotations = (VersioningList <IEdmDirectValueAnnotation>)transientAnnotations; VersioningList <IEdmDirectValueAnnotation> edmDirectValueAnnotations1 = edmDirectValueAnnotations; if (func == null) { func = (IEdmDirectValueAnnotation existingAnnotation) => { if (existingAnnotation.NamespaceUri != namespaceName) { return(false); } else { return(existingAnnotation.Name == localName); } } ; } return(edmDirectValueAnnotations1.FirstOrDefault <IEdmDirectValueAnnotation>(func)); } else { if (edmDirectValueAnnotation.NamespaceUri == namespaceName && edmDirectValueAnnotation.Name == localName) { return(edmDirectValueAnnotation); } } } return(null); }
private void ProcessAttributeAnnotation(IEdmDirectValueAnnotation annotation) { this.schemaWriter.WriteAnnotationStringAttribute(annotation); }
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; } }
public void VisitAnnotation(IEdmDirectValueAnnotation annotation) { this.ProcessImmediateValueAnnotation((IEdmDirectValueAnnotation)annotation); }
protected virtual void ProcessImmediateValueAnnotation(IEdmDirectValueAnnotation annotation) { this.ProcessNamedElement(annotation); }
private void CheckImmediateAnnotation(IEdmDirectValueAnnotation immediateAnnotation, string termName, string value) { Assert.AreEqual(termName, immediateAnnotation.Name, "Invalid immediate annotation term."); Assert.AreEqual(value, ((EdmStringConstant)immediateAnnotation.Value).Value, "Invalid immediate annotation value."); }
/// <summary> /// Converts the value of the <paramref name="annotation"/> to a string. /// </summary> /// <param name="annotation">The <see cref="IEdmDirectValueAnnotation"/> to convert.</param> /// <returns>The string representation of the converted annotation value.</returns> private static string ConvertEdmAnnotationValue(IEdmDirectValueAnnotation annotation) { Debug.Assert(annotation != null, "annotation != null"); object annotationValue = annotation.Value; if (annotationValue == null) { return null; } IEdmStringValue stringValue = annotationValue as IEdmStringValue; if (stringValue != null) { return stringValue.Value; } throw new ODataException(o.Strings.EpmExtensionMethods_CannotConvertEdmAnnotationValue(annotation.NamespaceUri, annotation.Name, annotation.GetType().FullName)); }
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); }
private void ProcessElementAnnotation(IEdmDirectValueAnnotation annotation) { this.schemaWriter.WriteAnnotationStringElement(annotation); }
internal abstract void WriteAnnotationStringAttribute(IEdmDirectValueAnnotation annotation);
internal abstract void WriteAnnotationStringElement(IEdmDirectValueAnnotation annotation);
/// <summary> /// Populates test annotation values from the serializable annotation. /// </summary> /// <param name="feedMappingAnnotation">Test annotation to populate values for.</param> /// <param name="serializableAnnotation">Serializable annotation to populate values from.</param> /// <param name="propertyName">The name of the property to create the mapping for; null for mappings on the type.</param> private void PopulateTestAnnotationValues(PropertyMappingAnnotation feedMappingAnnotation, IEdmDirectValueAnnotation serializableAnnotation, string propertyName) { string localName = serializableAnnotation.Name; ExceptionUtilities.CheckObjectNotNull(localName, "localName cannot be null"); if (localName.Count(c => c == UnderScore) == 2) { localName = localName.Remove(localName.LastIndexOf(UnderScore)); } IEdmStringValue edmStringValue = serializableAnnotation.Value as IEdmStringValue; ExceptionUtilities.CheckObjectNotNull(edmStringValue, "edmStringValue cannot be null"); string value = edmStringValue.Value; ExceptionUtilities.CheckObjectNotNull(value, "value cannot be null"); switch (localName) { case ODataConstants.TargetPathAttribute: feedMappingAnnotation.TargetPath = this.HandleTargetPath(value, feedMappingAnnotation); break; case ODataConstants.SourcePathAttribute: if (value == null) { feedMappingAnnotation.SourcePath = propertyName; } else if (propertyName != null && !value.StartsWith(propertyName)) { feedMappingAnnotation.SourcePath = propertyName + "/" + value; } else { feedMappingAnnotation.SourcePath = value; } break; case ODataConstants.ContentKindAttribute: feedMappingAnnotation.SyndicationTextContentKind = ODataExtensions.FromTextContentKindAttributeString(value); break; case ODataConstants.KeepInContentAttribute: feedMappingAnnotation.KeepInContent = bool.Parse(value); break; case ODataConstants.NSPrefixAttribute: feedMappingAnnotation.TargetNamespacePrefix = value; break; case ODataConstants.NSUriAttribute: feedMappingAnnotation.TargetNamespaceUri = value; break; default: throw new TaupoArgumentException( string.Format(CultureInfo.InvariantCulture, "Attribute Name:{0} does not match one of Attribute names for Customizing feeds", localName)); } // if there is no source path, use the property name if (feedMappingAnnotation.SourcePath == null) { feedMappingAnnotation.SourcePath = propertyName; } }
private void VisitDirectAnnotation(IEdmDirectValueAnnotation directAnnotation) { // TODO: }