linux-packaging-mono/mcs/class/referencesource/System.Data.Entity/System/Data/Mapping/BaseMetadataMappingVisitor.cs

//---------------------------------------------------------------------
// <copyright file="BaseMetadataMappingVisitor.cs" company="Microsoft">
//      Copyright (c) Microsoft Corporation.  All rights reserved.
// </copyright>

// @owner       Microsoft
// @backupOwner Microsoft
//---------------------------------------------------------------------

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Data.Metadata.Edm;
using System.Data.Common;
using System.Data.Common.Utils;
using System.Data.Mapping;
using System.Diagnostics;
using System.Globalization;

namespace System.Data.Mapping
{
    internal abstract class BaseMetadataMappingVisitor
    {
        protected BaseMetadataMappingVisitor()
        {
        }

        protected virtual void Visit(StorageEntityContainerMapping storageEntityContainerMapping)
        {
            Visit(storageEntityContainerMapping.EdmEntityContainer);
            Visit(storageEntityContainerMapping.StorageEntityContainer);
            foreach (var mapping in storageEntityContainerMapping.EntitySetMaps)
            {
                Visit(mapping);
            }
        }

        protected virtual void Visit(EntitySetBase entitySetBase)
        {
            // this is a switching node, so no object header and footer will be add for this node,
            // also this Visit won't add the object to the seen list

            switch (entitySetBase.BuiltInTypeKind)
            {
                case BuiltInTypeKind.EntitySet:
                    Visit((EntitySet)entitySetBase);
                    break;
                case BuiltInTypeKind.AssociationSet:
                    Visit((AssociationSet)entitySetBase);
                    break;
                default:
                    Debug.Fail(string.Format(CultureInfo.InvariantCulture, "Found type '{0}', did we add a new type?", entitySetBase.BuiltInTypeKind));
                    break;
            }
        }

        protected virtual void Visit(StorageSetMapping storageSetMapping)
        {
            foreach (var typeMapping in storageSetMapping.TypeMappings)
            {
                Visit(typeMapping);
            }
            Visit(storageSetMapping.EntityContainerMapping);
        }

        protected virtual void Visit(EntityContainer entityContainer)
        {
            foreach (var set in entityContainer.BaseEntitySets)
            {
                Visit(set);
            }
        }

        protected virtual void Visit(EntitySet entitySet)
        {
            Visit(entitySet.ElementType);
            Visit(entitySet.EntityContainer);
        }

        protected virtual void Visit(AssociationSet associationSet)
        {
            Visit(associationSet.ElementType);
            Visit(associationSet.EntityContainer);
            foreach (var end in associationSet.AssociationSetEnds)
            {
                Visit(end);
            }
        }
        protected virtual void Visit(EntityType entityType)
        {
            foreach (var kmember in entityType.KeyMembers)
            {
                Visit(kmember);
            }

            foreach (var member in entityType.GetDeclaredOnlyMembers<EdmMember>())
            {
                Visit(member);
            }

            foreach (var nproperty in entityType.NavigationProperties)
            {
                Visit(nproperty);
            }

            foreach (var property in entityType.Properties)
            {
                Visit(property);
            }
        }

        protected virtual void Visit(AssociationType associationType)
        {
            foreach (var endMember in associationType.AssociationEndMembers)
            {
                Visit(endMember);
            }
            Visit(associationType.BaseType);
            foreach (var keyMember in associationType.KeyMembers)
            {
                Visit(keyMember);
            }
            foreach (var member in associationType.GetDeclaredOnlyMembers<EdmMember>())
            {
                Visit(member);
            }
            foreach (var item in associationType.ReferentialConstraints)
            {
                Visit(item);
            }
            foreach (var item in associationType.RelationshipEndMembers)
            {
                Visit(item);
            }
        }

        protected virtual void Visit(AssociationSetEnd associationSetEnd)
        {
            Visit(associationSetEnd.CorrespondingAssociationEndMember);
            Visit(associationSetEnd.EntitySet);
            Visit(associationSetEnd.ParentAssociationSet);
        }
        protected virtual void Visit(EdmProperty edmProperty)
        {
            Visit(edmProperty.TypeUsage);
        }
        protected virtual void Visit(NavigationProperty navigationProperty)
        {
            Visit(navigationProperty.FromEndMember);
            Visit(navigationProperty.RelationshipType);
            Visit(navigationProperty.ToEndMember);
            Visit(navigationProperty.TypeUsage);
        }

        protected virtual void Visit(EdmMember edmMember)
        {
            Visit(edmMember.TypeUsage);
        }
        protected virtual void Visit(AssociationEndMember associationEndMember)
        {
            Visit(associationEndMember.TypeUsage);
        }

        protected virtual void Visit(ReferentialConstraint referentialConstraint)
        {
            foreach (var property in referentialConstraint.FromProperties)
            {
                Visit(property);
            }
            Visit(referentialConstraint.FromRole);

            foreach (var property in referentialConstraint.ToProperties)
            {
                Visit(property);
            }
            Visit(referentialConstraint.ToRole);
        }
        protected virtual void Visit(RelationshipEndMember relationshipEndMember)
        {
            Visit(relationshipEndMember.TypeUsage);
        }
        protected virtual void Visit(TypeUsage typeUsage)
        {
            Visit(typeUsage.EdmType);
            foreach (var facet in typeUsage.Facets)
            {
                Visit(facet);
            }
        }
        protected virtual void Visit(RelationshipType relationshipType)
        {
            // switching node, will not be add to the seen list
            if (relationshipType == null)
            {
                return;
            }

            #region Inner data visit
            switch (relationshipType.BuiltInTypeKind)
            {
                case BuiltInTypeKind.AssociationType:
                    Visit((AssociationType)relationshipType);
                    break;
                default:
                    Debug.Fail(String.Format(CultureInfo.InvariantCulture, "Found type '{0}', did we add a new type?", relationshipType.BuiltInTypeKind));
                    break;
            }
            #endregion
        }
        protected virtual void Visit(EdmType edmType)
        {
            // switching node, will not be add to the seen list
            if (edmType == null)
            {
                return;
            }

            #region Inner data visit
            switch (edmType.BuiltInTypeKind)
            {
                case BuiltInTypeKind.EntityType:
                    Visit((EntityType)edmType);
                    break;
                case BuiltInTypeKind.AssociationType:
                    Visit((AssociationType)edmType);
                    break;
                case BuiltInTypeKind.EdmFunction:
                    Visit((EdmFunction)edmType);
                    break;
                case BuiltInTypeKind.ComplexType:
                    Visit((ComplexType)edmType);
                    break;
                case BuiltInTypeKind.PrimitiveType:
                    Visit((PrimitiveType)edmType);
                    break;
                case BuiltInTypeKind.RefType:
                    Visit((RefType)edmType);
                    break;
                case BuiltInTypeKind.CollectionType:
                    Visit((CollectionType)edmType);
                    break;
                case BuiltInTypeKind.EnumType:
                    Visit((EnumType)edmType);
                    break;
                default:
                    Debug.Fail(String.Format(CultureInfo.InvariantCulture, "Found type '{0}', did we add a new type?", edmType.BuiltInTypeKind));
                    break;
            }
            #endregion
        }
        protected virtual void Visit(Facet facet)
        {
            Visit(facet.FacetType);
        }
        protected virtual void Visit(EdmFunction edmFunction)
        {
            Visit(edmFunction.BaseType);
            foreach (var entitySet in edmFunction.EntitySets)
            {
                if (entitySet != null)
                {
                    Visit(entitySet);
                }
            }
            foreach (var functionParameter in edmFunction.Parameters)
            {
                Visit(functionParameter);
            }
            foreach (var returnParameter in edmFunction.ReturnParameters)
            {
                Visit(returnParameter);
            }
        }
        protected virtual void Visit(PrimitiveType primitiveType)
        {
        }
        protected virtual void Visit(ComplexType complexType)
        {
            Visit(complexType.BaseType);
            foreach (var member in complexType.Members)
            {
                Visit(member);
            }
            foreach (var property in complexType.Properties)
            {
                Visit(property);
            }
        }
        protected virtual void Visit(RefType refType)
        {
            Visit(refType.BaseType);
            Visit(refType.ElementType);
        }
        protected virtual void Visit(EnumType enumType)
        {
            foreach (var member in enumType.Members)
            {
                Visit(member);
            }
        }
        protected virtual void Visit(EnumMember enumMember)
        {
        }
        protected virtual void Visit(CollectionType collectionType)
        {
            Visit(collectionType.BaseType);
            Visit(collectionType.TypeUsage);
        }
        protected virtual void Visit(EntityTypeBase entityTypeBase)
        {
            // switching node
            if (entityTypeBase == null)
            {
                return;
            }
            switch (entityTypeBase.BuiltInTypeKind)
            {
                case BuiltInTypeKind.AssociationType:
                    Visit((AssociationType)entityTypeBase);
                    break;
                case BuiltInTypeKind.EntityType:
                    Visit((EntityType)entityTypeBase);
                    break;
                default:
                    Debug.Fail(String.Format(CultureInfo.InvariantCulture, "Found type '{0}', did we add a new type?", entityTypeBase.BuiltInTypeKind));
                    break;
            }
        }
        protected virtual void Visit(FunctionParameter functionParameter)
        {
            Visit(functionParameter.DeclaringFunction);
            Visit(functionParameter.TypeUsage);
        }
        protected virtual void Visit(DbProviderManifest providerManifest)
        {
        }
        protected virtual void Visit(StorageTypeMapping storageTypeMapping)
        {
            foreach (var type in storageTypeMapping.IsOfTypes)
            {
                Visit(type);
            }

            foreach (var fragment in storageTypeMapping.MappingFragments)
            {
                Visit(fragment);
            }

            Visit(storageTypeMapping.SetMapping);

            foreach (var type in storageTypeMapping.Types)
            {
                Visit(type);
            }
        }
        protected virtual void Visit(StorageMappingFragment storageMappingFragment)
        {
            foreach (var property in storageMappingFragment.AllProperties)
            {
                Visit(property);
            }

            Visit((EntitySetBase)storageMappingFragment.TableSet);
        }
        protected virtual void Visit(StoragePropertyMapping storagePropertyMapping)
        {
            // this is a switching node, so no object header and footer will be add for this node,
            // also this Visit won't add the object to the seen list

            if (storagePropertyMapping.GetType() == typeof(StorageComplexPropertyMapping))
            {
                Visit((StorageComplexPropertyMapping)storagePropertyMapping);
            }
            else if (storagePropertyMapping.GetType() == typeof(StorageConditionPropertyMapping))
            {
                Visit((StorageConditionPropertyMapping)storagePropertyMapping);
            }
            else if (storagePropertyMapping.GetType() == typeof(StorageScalarPropertyMapping))
            {
                Visit((StorageScalarPropertyMapping)storagePropertyMapping);
            }
            else
            {
                Debug.Fail(String.Format(CultureInfo.InvariantCulture, "Found type '{0}', did we add a new type?", storagePropertyMapping.GetType()));
            }
        }
        protected virtual void Visit(StorageComplexPropertyMapping storageComplexPropertyMapping)
        {
            Visit(storageComplexPropertyMapping.EdmProperty);
            foreach (var mapping in storageComplexPropertyMapping.TypeMappings)
            {
                Visit(mapping);
            }
        }
        protected virtual void Visit(StorageConditionPropertyMapping storageConditionPropertyMapping)
        {
            Visit(storageConditionPropertyMapping.ColumnProperty);
            Visit(storageConditionPropertyMapping.EdmProperty);
        }
        protected virtual void Visit(StorageScalarPropertyMapping storageScalarPropertyMapping)
        {
            Visit(storageScalarPropertyMapping.ColumnProperty);
            Visit(storageScalarPropertyMapping.EdmProperty);
        }

        protected virtual void Visit(StorageComplexTypeMapping storageComplexTypeMapping)
        {
            foreach (var property in storageComplexTypeMapping.AllProperties)
            {
                Visit(property);
            }

            foreach (var type in storageComplexTypeMapping.IsOfTypes)
            {
                Visit(type);
            }

            foreach (var type in storageComplexTypeMapping.Types)
            {
                Visit(type);
            }
        }
    }
}