Пример #1
0
        protected void Check()
        {
            string entity;
            string relatedEntity;

            if (this is ManyToManyRelationship)
            {
                ManyToManyRelationship manyToManyRelationship = this as ManyToManyRelationship;
                entity        = manyToManyRelationship.OneToManyRelationship.Entity;
                relatedEntity = manyToManyRelationship.ManyToOneRelationship.RelatedEntity;
                if (manyToManyRelationship.OneToManyRelationship.RelatedEntity != manyToManyRelationship.ManyToOneRelationship.Entity)
                {
                    throw new SchemaException(SchemaMessages.RelationshipsNonConnected);
                }
            }
            else if (this is PlainRelationship)
            {
                PlainRelationship plainRelationship = this as PlainRelationship;
                entity        = plainRelationship.DirectRelationships[0].Entity;
                relatedEntity = plainRelationship.DirectRelationships[plainRelationship.DirectRelationships.Length - 1].RelatedEntity;
            }
            else //if (this is Relationship)
            {
                entity        = this.DirectRelationships[0].Entity;
                relatedEntity = this.DirectRelationships[this.DirectRelationships.Length - 1].RelatedEntity;
            }
            if (Entity != entity)
            {
                throw new SchemaException(string.Format(SchemaMessages.ConflictingEntities, Entity, entity));
            }
            if (RelatedEntity != relatedEntity)
            {
                throw new SchemaException(string.Format(SchemaMessages.ConflictingRelatedEntities, RelatedEntity, relatedEntity));
            }
        }
Пример #2
0
        private static PlainRelationship Reverse(PlainRelationship relationship)
        {
            string entity        = relationship.RelatedEntity;
            string relatedEntity = relationship.Entity;
            List <DirectRelationship> relationships = new List <DirectRelationship>();

            for (int i = relationship.DirectRelationships.Length - 1; i >= 0; i--)
            {
                relationships.Add(relationship.DirectRelationships[i].Reverse());
            }

            if (relationship is ManyToOneRelationship)
            {
                return(new OneToManyRelationship(entity, relatedEntity, relationships));
            }
            else if (relationship is OneToManyRelationship)
            {
                return(new ManyToOneRelationship(entity, relatedEntity, relationships));
            }
            else if (relationship is OneToOneRelationship)
            {
                return(new OneToOneRelationship(entity, relatedEntity, relationships));
            }
            else
            {
                throw new NotSupportedException(relationship.GetType().ToString()); // never
            }
        }
Пример #3
0
        private static void Connect(PlainRelationship relationship, List <PlainRelationship> decreasing, List <PlainRelationship> list)
        {
            PlainRelationship prev = decreasing.FirstOrDefault(r => r.RelatedEntity == relationship.Entity);

            if (prev == null)
            {
                PlainRelationship rel = decreasing.FirstOrDefault(r => r.Entity == relationship.Entity);
                if (rel is OneToOneRelationship)
                {
                    prev = (PlainRelationship)rel.Reverse();
                    decreasing.Remove(rel);
                }
            }
            else
            {
                decreasing.Remove(prev);
            }
            if (prev != null)
            {
                int index = list.IndexOf(relationship);
                list.Insert(index, prev);
                Connect(prev, decreasing, list);
            }

            PlainRelationship next = decreasing.FirstOrDefault(r => r.Entity == relationship.RelatedEntity);

            if (next == null)
            {
                PlainRelationship rel = decreasing.FirstOrDefault(r => r.RelatedEntity == relationship.RelatedEntity);
                if (rel is OneToOneRelationship)
                {
                    next = (PlainRelationship)rel.Reverse();
                    decreasing.Remove(rel);
                }
            }
            else
            {
                decreasing.Remove(next);
            }
            if (next != null)
            {
                list.Add(next);
                Connect(next, decreasing, list);
            }
        }
Пример #4
0
        protected static IEnumerable <PlainRelationship> Connect(IEnumerable <PlainRelationship> relationships, string relationship)
        {
            List <PlainRelationship> decreasing = new List <PlainRelationship>(relationships);

            List <PlainRelationship> list = new List <PlainRelationship>();

            PlainRelationship first = decreasing.First();

            decreasing.Remove(first);
            list.Add(first);

            Connect(first, decreasing, list);

            if (list.Count < relationships.Count())
            {
                throw new SchemaException(string.Format(SchemaMessages.RelationshipsNonConnected, relationship));
            }

            return(list);
        }
Пример #5
0
        private static XElement PlainRelationshipToXml(PlainRelationship relationship)
        {
            XElement relationshipSchema = new XElement(SchemaVocab.Relationship);

            relationshipSchema.SetAttributeValue(SchemaVocab.Name, relationship.Name);
            string type;

            if (relationship is ManyToOneRelationship)
            {
                type = SchemaVocab.ManyToOne;
            }
            else if (relationship is OneToManyRelationship)
            {
                type = SchemaVocab.OneToMany;
            }
            else if (relationship is OneToOneRelationship)
            {
                type = SchemaVocab.OneToOne;
            }
            else
            {
                throw new NotSupportedException(relationship.GetType().ToString()); // never
            }
            relationshipSchema.SetAttributeValue(SchemaVocab.Type, type);
            relationshipSchema.SetAttributeValue(SchemaVocab.Entity, relationship.Entity);
            relationshipSchema.SetAttributeValue(SchemaVocab.RelatedEntity, relationship.RelatedEntity);
            if (relationship.DirectRelationships.Length == 1)
            {
                DirectRelationship rel = relationship.DirectRelationships[0];
                for (int i = 0; i < rel.Properties.Length; i++)
                {
                    XElement xProperty = new XElement(SchemaVocab.Property);
                    xProperty.SetAttributeValue(SchemaVocab.Name, rel.Properties[i]);
                    xProperty.SetAttributeValue(SchemaVocab.RelatedProperty, rel.RelatedProperties[i]);
                    relationshipSchema.Add(xProperty);
                }
            }
            else
            {
                foreach (DirectRelationship rel in relationship.DirectRelationships)
                {
                    XElement relSchema = new XElement(SchemaVocab.Relationship);
                    string   relType;
                    if (rel is ManyToOneDirectRelationship)
                    {
                        relType = SchemaVocab.ManyToOne;
                    }
                    else if (rel is OneToManyDirectRelationship)
                    {
                        relType = SchemaVocab.OneToMany;
                    }
                    else if (rel is OneToOneDirectRelationship)
                    {
                        relType = SchemaVocab.OneToOne;
                    }
                    else
                    {
                        throw new NotSupportedException(rel.GetType().ToString()); // never
                    }
                    relSchema.SetAttributeValue(SchemaVocab.Type, relType);
                    relSchema.SetAttributeValue(SchemaVocab.Entity, rel.Entity);
                    relSchema.SetAttributeValue(SchemaVocab.RelatedEntity, rel.RelatedEntity);
                    for (int i = 0; i < rel.Properties.Length; i++)
                    {
                        XElement xProperty = new XElement(SchemaVocab.Property);
                        xProperty.SetAttributeValue(SchemaVocab.Name, rel.Properties[i]);
                        xProperty.SetAttributeValue(SchemaVocab.RelatedProperty, rel.RelatedProperties[i]);
                        relSchema.Add(xProperty);
                    }
                    relationshipSchema.Add(relSchema);
                }
            }
            return(relationshipSchema);
        }