Esempio n. 1
0
        /// <summary>
        /// Searches for vocabulary annotations specified by this model.
        /// </summary>
        /// <param name="element">The annotated element.</param>
        /// <returns>The vocabulary annotations for the element.</returns>
        public override IEnumerable <IEdmVocabularyAnnotation> FindDeclaredVocabularyAnnotations(IEdmVocabularyAnnotatable element)
        {
            // Include the inline annotations only if this model is the one that defined them.
            CsdlSemanticsElement semanticsElement = element as CsdlSemanticsElement;
            IEnumerable <IEdmVocabularyAnnotation> inlineAnnotations = semanticsElement != null && semanticsElement.Model == this ? semanticsElement.InlineVocabularyAnnotations : Enumerable.Empty <IEdmVocabularyAnnotation>();

            List <CsdlSemanticsAnnotations> elementAnnotations;
            string fullName = EdmUtil.FullyQualifiedName(element);

            if (fullName != null && this.outOfLineAnnotations.TryGetValue(fullName, out elementAnnotations))
            {
                List <IEdmVocabularyAnnotation> result = new List <IEdmVocabularyAnnotation>();

                foreach (CsdlSemanticsAnnotations annotations in elementAnnotations)
                {
                    foreach (CsdlVocabularyAnnotationBase annotation in annotations.Annotations.Annotations)
                    {
                        result.Add(this.WrapVocabularyAnnotation(annotation, annotations.Context, null, annotations, annotations.Annotations.Qualifier));
                    }
                }

                return(inlineAnnotations.Concat(result));
            }

            return(inlineAnnotations);
        }
        private IEnumerable <string> ComputePrincipalKeyPropertiesNotFoundInPrincipalProperties()
        {
            List <string> strs = null;
            IEnumerator <IEdmStructuralProperty> enumerator = this.PrincipalEnd.EntityType.Key().GetEnumerator();

            using (enumerator)
            {
                Func <CsdlPropertyReference, bool> func = null;
                while (enumerator.MoveNext())
                {
                    IEdmStructuralProperty              current    = enumerator.Current;
                    CsdlReferentialConstraintRole       principal  = this.constraint.Principal;
                    IEnumerable <CsdlPropertyReference> properties = principal.Properties;
                    if (func == null)
                    {
                        func = (CsdlPropertyReference reference) => reference.PropertyName == current.Name;
                    }
                    CsdlPropertyReference csdlPropertyReference = properties.Where <CsdlPropertyReference>(func).FirstOrDefault <CsdlPropertyReference>();
                    if (csdlPropertyReference != null)
                    {
                        continue;
                    }
                    strs = CsdlSemanticsElement.AllocateAndAdd <string>(strs, current.Name);
                }
            }
            List <string>        strs1 = strs;
            IEnumerable <string> strs2 = strs1;

            if (strs1 == null)
            {
                strs2 = Enumerable.Empty <string>();
            }
            return(strs2);
        }
        protected override IEnumerable <IEdmDirectValueAnnotation> GetAttachedAnnotations(IEdmElement element)
        {
            CsdlSemanticsElement csdlElement = element as CsdlSemanticsElement;

            if (csdlElement != null)
            {
                return(csdlElement.DirectValueAnnotations);
            }

            return(Enumerable.Empty <IEdmDirectValueAnnotation>());
        }
        private IEnumerable <EdmError> ComputeErrors()
        {
            List <EdmError> edmErrors = null;

            if (this.EntityType as UnresolvedEntityType != null)
            {
                edmErrors = CsdlSemanticsElement.AllocateAndAdd <EdmError>(edmErrors, this.EntityType.Errors());
            }
            List <EdmError>        edmErrors1 = edmErrors;
            IEnumerable <EdmError> edmErrors2 = edmErrors1;

            if (edmErrors1 == null)
            {
                edmErrors2 = Enumerable.Empty <EdmError>();
            }
            return(edmErrors2);
        }
        private IEnumerable <EdmError> ComputeErrors()
        {
            List <EdmError> edmErrors  = null;
            IEdmEntityType  entityType = this.PrincipalEnd.EntityType;
            CsdlReferentialConstraintRole principal = this.constraint.Principal;
            CsdlReferentialConstraintRole dependent = this.constraint.Dependent;

            if (this.constraint.Principal.Role == this.constraint.Dependent.Role)
            {
                edmErrors = CsdlSemanticsElement.AllocateAndAdd <EdmError>(edmErrors, new EdmError(base.Location, EdmErrorCode.SameRoleReferredInReferentialConstraint, Strings.EdmModel_Validator_Semantic_SameRoleReferredInReferentialConstraint(this.constraint.Principal.Role)));
            }
            if (this.constraint.Dependent.Role != this.context.End1.Name && this.constraint.Dependent.Role != this.context.End2.Name)
            {
                edmErrors = CsdlSemanticsElement.AllocateAndAdd <EdmError>(edmErrors, new EdmError(base.Location, EdmErrorCode.InvalidRoleInRelationshipConstraint, Strings.CsdlParser_InvalidEndRoleInRelationshipConstraint(this.constraint.Dependent.Role, this.context.Name)));
            }
            if (this.constraint.Principal.Role != this.context.End1.Name && this.constraint.Principal.Role != this.context.End2.Name)
            {
                edmErrors = CsdlSemanticsElement.AllocateAndAdd <EdmError>(edmErrors, new EdmError(base.Location, EdmErrorCode.InvalidRoleInRelationshipConstraint, Strings.CsdlParser_InvalidEndRoleInRelationshipConstraint(this.constraint.Principal.Role, this.context.Name)));
            }
            if (edmErrors == null)
            {
                if (principal.Properties.Count <CsdlPropertyReference>() != dependent.Properties.Count <CsdlPropertyReference>())
                {
                    edmErrors = CsdlSemanticsElement.AllocateAndAdd <EdmError>(edmErrors, new EdmError(base.Location, EdmErrorCode.MismatchNumberOfPropertiesInRelationshipConstraint, Strings.EdmModel_Validator_Semantic_MismatchNumberOfPropertiesinRelationshipConstraint));
                }
                if (entityType.Key().Count <IEdmStructuralProperty>() != principal.Properties.Count <CsdlPropertyReference>() || this.PrincipalKeyPropertiesNotFoundInPrincipalProperties.Count <string>() != 0)
                {
                    string str = Strings.EdmModel_Validator_Semantic_InvalidPropertyInRelationshipConstraintPrimaryEnd(string.Concat(this.DependentEnd.DeclaringAssociation.Namespace, (char)46, this.DependentEnd.DeclaringAssociation.Name), this.constraint.Principal.Role);
                    edmErrors = CsdlSemanticsElement.AllocateAndAdd <EdmError>(edmErrors, new EdmError(base.Location, EdmErrorCode.BadPrincipalPropertiesInReferentialConstraint, str));
                }
                foreach (string dependentPropertiesNotFoundInDependentType in this.DependentPropertiesNotFoundInDependentType)
                {
                    string str1 = Strings.EdmModel_Validator_Semantic_InvalidPropertyInRelationshipConstraintDependentEnd(dependentPropertiesNotFoundInDependentType, this.constraint.Dependent.Role);
                    edmErrors = CsdlSemanticsElement.AllocateAndAdd <EdmError>(edmErrors, new EdmError(base.Location, EdmErrorCode.InvalidPropertyInRelationshipConstraint, str1));
                }
            }
            List <EdmError>        edmErrors1 = edmErrors;
            IEnumerable <EdmError> edmErrors2 = edmErrors1;

            if (edmErrors1 == null)
            {
                edmErrors2 = Enumerable.Empty <EdmError>();
            }
            return(edmErrors2);
        }
Esempio n. 6
0
        private IEnumerable <EdmError> ComputeErrors()
        {
            List <EdmError> edmErrors = null;

            if (this.Association as UnresolvedAssociation != null)
            {
                edmErrors = CsdlSemanticsElement.AllocateAndAdd <EdmError>(edmErrors, this.Association.Errors());
            }
            if (this.End1.Role != null && this.End2.Role != null && this.End1.Role.Name == this.End2.Role.Name)
            {
                edmErrors = CsdlSemanticsElement.AllocateAndAdd <EdmError>(edmErrors, new EdmError(this.End2.Location(), EdmErrorCode.InvalidName, Strings.EdmModel_Validator_Semantic_DuplicateEndName(this.End1.Role.Name)));
            }
            List <EdmError>        edmErrors1 = edmErrors;
            IEnumerable <EdmError> edmErrors2 = edmErrors1;

            if (edmErrors1 == null)
            {
                edmErrors2 = Enumerable.Empty <EdmError>();
            }
            return(edmErrors2);
        }
Esempio n. 7
0
        public override IEnumerable <IEdmVocabularyAnnotation> FindDeclaredVocabularyAnnotations(IEdmVocabularyAnnotatable element)
        {
            List <CsdlSemanticsAnnotations>        list;
            CsdlSemanticsElement                   element2 = element as CsdlSemanticsElement;
            IEnumerable <IEdmVocabularyAnnotation> first    = ((element2 != null) && (element2.Model == this)) ? element2.InlineVocabularyAnnotations : Enumerable.Empty <IEdmVocabularyAnnotation>();
            string key = EdmUtil.FullyQualifiedName(element);

            if ((key == null) || !this.outOfLineAnnotations.TryGetValue(key, out list))
            {
                return(first);
            }
            List <IEdmVocabularyAnnotation> second = new List <IEdmVocabularyAnnotation>();

            foreach (CsdlSemanticsAnnotations annotations in list)
            {
                foreach (CsdlVocabularyAnnotationBase base2 in annotations.Annotations.Annotations)
                {
                    second.Add(this.WrapVocabularyAnnotation(base2, annotations.Context, null, annotations, annotations.Annotations.Qualifier));
                }
            }
            return(first.Concat <IEdmVocabularyAnnotation>(second));
        }
        private IEnumerable <string> ComputeDependentPropertiesNotFoundInDependentType()
        {
            List <string>  strs       = new List <string>();
            IEdmEntityType entityType = this.DependentEnd.EntityType;

            foreach (CsdlPropertyReference property in this.constraint.Dependent.Properties)
            {
                if (entityType.FindProperty(property.PropertyName) != null)
                {
                    continue;
                }
                strs = CsdlSemanticsElement.AllocateAndAdd <string>(strs, property.PropertyName);
            }
            List <string>        strs1 = strs;
            IEnumerable <string> strs2 = strs1;

            if (strs1 == null)
            {
                strs2 = Enumerable.Empty <string>();
            }
            return(strs2);
        }
        private IEnumerable <EdmError> ComputeErrors()
        {
            List <EdmError> edmErrors = null;

            if (this.association.End1.Name == this.association.End2.Name)
            {
                List <EdmError> edmErrors1  = edmErrors;
                EdmLocation     location    = this.association.End2.Location;
                EdmLocation     edmLocation = location;
                if (location == null)
                {
                    edmLocation = base.Location;
                }
                edmErrors = CsdlSemanticsElement.AllocateAndAdd <EdmError>(edmErrors1, new EdmError(edmLocation, EdmErrorCode.AlreadyDefined, Strings.EdmModel_Validator_Semantic_EndNameAlreadyDefinedDuplicate(this.association.End1.Name)));
            }
            List <EdmError>        edmErrors2 = edmErrors;
            IEnumerable <EdmError> edmErrors3 = edmErrors2;

            if (edmErrors2 == null)
            {
                edmErrors3 = Enumerable.Empty <EdmError>();
            }
            return(edmErrors3);
        }
Esempio n. 10
0
        internal IEnumerable <IEdmVocabularyAnnotation> WrapInlineVocabularyAnnotations(CsdlSemanticsElement element, CsdlSemanticsSchema schema)
        {
            IEdmVocabularyAnnotatable vocabularyAnnotatableElement = element as IEdmVocabularyAnnotatable;

            if (vocabularyAnnotatableElement != null)
            {
                IEnumerable <CsdlVocabularyAnnotationBase> vocabularyAnnotations = element.Element.VocabularyAnnotations;
                if (vocabularyAnnotations.FirstOrDefault() != null)
                {
                    List <IEdmVocabularyAnnotation> wrappedAnnotations = new List <IEdmVocabularyAnnotation>();
                    foreach (CsdlVocabularyAnnotationBase vocabularyAnnotation in vocabularyAnnotations)
                    {
                        IEdmVocabularyAnnotation vocabAnnotation = this.WrapVocabularyAnnotation(vocabularyAnnotation, schema, vocabularyAnnotatableElement, null, vocabularyAnnotation.Qualifier);
                        vocabAnnotation.SetSerializationLocation(this, EdmVocabularyAnnotationSerializationLocation.Inline);
                        wrappedAnnotations.Add(vocabAnnotation);
                    }

                    return(wrappedAnnotations);
                }
            }

            return(Enumerable.Empty <IEdmVocabularyAnnotation>());
        }
Esempio n. 11
0
        internal IEnumerable <IEdmVocabularyAnnotation> WrapInlineVocabularyAnnotations(CsdlSemanticsElement element, CsdlSemanticsSchema schema)
        {
            IEdmVocabularyAnnotatable targetContext = element as IEdmVocabularyAnnotatable;

            if (targetContext != null)
            {
                IEnumerable <CsdlVocabularyAnnotationBase> vocabularyAnnotations = element.Element.VocabularyAnnotations;
                if (vocabularyAnnotations.FirstOrDefault <CsdlVocabularyAnnotationBase>() != null)
                {
                    List <IEdmVocabularyAnnotation> list = new List <IEdmVocabularyAnnotation>();
                    foreach (CsdlVocabularyAnnotationBase base2 in vocabularyAnnotations)
                    {
                        IEdmVocabularyAnnotation annotation = this.WrapVocabularyAnnotation(base2, schema, targetContext, null, base2.Qualifier);
                        annotation.SetSerializationLocation(this, 0);
                        list.Add(annotation);
                    }
                    return(list);
                }
            }
            return(Enumerable.Empty <IEdmVocabularyAnnotation>());
        }