basemetadatamappingvisitor.cs source code in C# .NET

                        Code:
                         / 4.0 / 4.0 / untmp / DEVDIV_TFS / Dev10 / Releases / RTMRel / ndp / fx / src / DataEntity / System / Data / Mapping / basemetadatamappingvisitor.cs / 1305376 / basemetadatamappingvisitor.cs
                        
                        
                            //---------------------------------------------------------------------- 
// 
//      Copyright (c) Microsoft Corporation.  All rights reserved.
// 
 
// @owner       [....]
// @backupOwner [....] 
//--------------------------------------------------------------------- 

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()) 
            { 
                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()) 
            { 
                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);
            Visit(edmFunction.EntitySet); 
            foreach (var functionParameter in edmFunction.Parameters) 
            {
                Visit(functionParameter); 
            }

            Visit(edmFunction.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.EnumMembers) 
            {
                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); 
            }
        } 
    }
}

// File provided for Reference Use Only by Microsoft Corporation (c) 2007.
Link Menu

Network programming in C#, Network Programming in VB.NET, Network Programming in .NET
This book is available now!
Buy at Amazon US or
Buy at Amazon UK
basemetadatamappingvisitor.cs source code in C# .NET

Source code for the .NET framework in C#

Code:

Link Menu
