mcs/class/referencesource/System.Data.Entity/System/Data/Mapping/BaseMetadataMappingVisitor.cs

   1 //---------------------------------------------------------------------
   2 // <copyright file="BaseMetadataMappingVisitor.cs" company="Microsoft">
   3 //      Copyright (c) Microsoft Corporation.  All rights reserved.
   4 // </copyright>
   5
   6 // @owner       Microsoft
   7 // @backupOwner Microsoft
   8 //---------------------------------------------------------------------
   9
  10 using System;
  11 using System.Collections.Generic;
  12 using System.Linq;
  13 using System.Text;
  14 using System.Data.Metadata.Edm;
  15 using System.Data.Common;
  16 using System.Data.Common.Utils;
  17 using System.Data.Mapping;
  18 using System.Diagnostics;
  19 using System.Globalization;
  20
  21 namespace System.Data.Mapping
  22 {
  23     internal abstract class BaseMetadataMappingVisitor
  24     {
  25         protected BaseMetadataMappingVisitor()
  26         {
  27         }
  28
  29         protected virtual void Visit(StorageEntityContainerMapping storageEntityContainerMapping)
  30         {
  31             Visit(storageEntityContainerMapping.EdmEntityContainer);
  32             Visit(storageEntityContainerMapping.StorageEntityContainer);
  33             foreach (var mapping in storageEntityContainerMapping.EntitySetMaps)
  34             {
  35                 Visit(mapping);
  36             }
  37         }
  38
  39         protected virtual void Visit(EntitySetBase entitySetBase)
  40         {
  41             // this is a switching node, so no object header and footer will be add for this node,
  42             // also this Visit won't add the object to the seen list
  43
  44             switch (entitySetBase.BuiltInTypeKind)
  45             {
  46                 case BuiltInTypeKind.EntitySet:
  47                     Visit((EntitySet)entitySetBase);
  48                     break;
  49                 case BuiltInTypeKind.AssociationSet:
  50                     Visit((AssociationSet)entitySetBase);
  51                     break;
  52                 default:
  53                     Debug.Fail(string.Format(CultureInfo.InvariantCulture, "Found type '{0}', did we add a new type?", entitySetBase.BuiltInTypeKind));
  54                     break;
  55             }
  56         }
  57
  58         protected virtual void Visit(StorageSetMapping storageSetMapping)
  59         {
  60             foreach (var typeMapping in storageSetMapping.TypeMappings)
  61             {
  62                 Visit(typeMapping);
  63             }
  64             Visit(storageSetMapping.EntityContainerMapping);
  65         }
  66
  67         protected virtual void Visit(EntityContainer entityContainer)
  68         {
  69             foreach (var set in entityContainer.BaseEntitySets)
  70             {
  71                 Visit(set);
  72             }
  73         }
  74
  75         protected virtual void Visit(EntitySet entitySet)
  76         {
  77             Visit(entitySet.ElementType);
  78             Visit(entitySet.EntityContainer);
  79         }
  80
  81         protected virtual void Visit(AssociationSet associationSet)
  82         {
  83             Visit(associationSet.ElementType);
  84             Visit(associationSet.EntityContainer);
  85             foreach (var end in associationSet.AssociationSetEnds)
  86             {
  87                 Visit(end);
  88             }
  89         }
  90         protected virtual void Visit(EntityType entityType)
  91         {
  92             foreach (var kmember in entityType.KeyMembers)
  93             {
  94                 Visit(kmember);
  95             }
  96
  97             foreach (var member in entityType.GetDeclaredOnlyMembers<EdmMember>())
  98             {
  99                 Visit(member);
 100             }
 101
 102             foreach (var nproperty in entityType.NavigationProperties)
 103             {
 104                 Visit(nproperty);
 105             }
 106
 107             foreach (var property in entityType.Properties)
 108             {
 109                 Visit(property);
 110             }
 111         }
 112
 113         protected virtual void Visit(AssociationType associationType)
 114         {
 115             foreach (var endMember in associationType.AssociationEndMembers)
 116             {
 117                 Visit(endMember);
 118             }
 119             Visit(associationType.BaseType);
 120             foreach (var keyMember in associationType.KeyMembers)
 121             {
 122                 Visit(keyMember);
 123             }
 124             foreach (var member in associationType.GetDeclaredOnlyMembers<EdmMember>())
 125             {
 126                 Visit(member);
 127             }
 128             foreach (var item in associationType.ReferentialConstraints)
 129             {
 130                 Visit(item);
 131             }
 132             foreach (var item in associationType.RelationshipEndMembers)
 133             {
 134                 Visit(item);
 135             }
 136         }
 137
 138         protected virtual void Visit(AssociationSetEnd associationSetEnd)
 139         {
 140             Visit(associationSetEnd.CorrespondingAssociationEndMember);
 141             Visit(associationSetEnd.EntitySet);
 142             Visit(associationSetEnd.ParentAssociationSet);
 143         }
 144         protected virtual void Visit(EdmProperty edmProperty)
 145         {
 146             Visit(edmProperty.TypeUsage);
 147         }
 148         protected virtual void Visit(NavigationProperty navigationProperty)
 149         {
 150             Visit(navigationProperty.FromEndMember);
 151             Visit(navigationProperty.RelationshipType);
 152             Visit(navigationProperty.ToEndMember);
 153             Visit(navigationProperty.TypeUsage);
 154         }
 155
 156         protected virtual void Visit(EdmMember edmMember)
 157         {
 158             Visit(edmMember.TypeUsage);
 159         }
 160         protected virtual void Visit(AssociationEndMember associationEndMember)
 161         {
 162             Visit(associationEndMember.TypeUsage);
 163         }
 164
 165         protected virtual void Visit(ReferentialConstraint referentialConstraint)
 166         {
 167             foreach (var property in referentialConstraint.FromProperties)
 168             {
 169                 Visit(property);
 170             }
 171             Visit(referentialConstraint.FromRole);
 172
 173             foreach (var property in referentialConstraint.ToProperties)
 174             {
 175                 Visit(property);
 176             }
 177             Visit(referentialConstraint.ToRole);
 178         }
 179         protected virtual void Visit(RelationshipEndMember relationshipEndMember)
 180         {
 181             Visit(relationshipEndMember.TypeUsage);
 182         }
 183         protected virtual void Visit(TypeUsage typeUsage)
 184         {
 185             Visit(typeUsage.EdmType);
 186             foreach (var facet in typeUsage.Facets)
 187             {
 188                 Visit(facet);
 189             }
 190         }
 191         protected virtual void Visit(RelationshipType relationshipType)
 192         {
 193             // switching node, will not be add to the seen list
 194             if (relationshipType == null)
 195             {
 196                 return;
 197             }
 198
 199             #region Inner data visit
 200             switch (relationshipType.BuiltInTypeKind)
 201             {
 202                 case BuiltInTypeKind.AssociationType:
 203                     Visit((AssociationType)relationshipType);
 204                     break;
 205                 default:
 206                     Debug.Fail(String.Format(CultureInfo.InvariantCulture, "Found type '{0}', did we add a new type?", relationshipType.BuiltInTypeKind));
 207                     break;
 208             }
 209             #endregion
 210         }
 211         protected virtual void Visit(EdmType edmType)
 212         {
 213             // switching node, will not be add to the seen list
 214             if (edmType == null)
 215             {
 216                 return;
 217             }
 218
 219             #region Inner data visit
 220             switch (edmType.BuiltInTypeKind)
 221             {
 222                 case BuiltInTypeKind.EntityType:
 223                     Visit((EntityType)edmType);
 224                     break;
 225                 case BuiltInTypeKind.AssociationType:
 226                     Visit((AssociationType)edmType);
 227                     break;
 228                 case BuiltInTypeKind.EdmFunction:
 229                     Visit((EdmFunction)edmType);
 230                     break;
 231                 case BuiltInTypeKind.ComplexType:
 232                     Visit((ComplexType)edmType);
 233                     break;
 234                 case BuiltInTypeKind.PrimitiveType:
 235                     Visit((PrimitiveType)edmType);
 236                     break;
 237                 case BuiltInTypeKind.RefType:
 238                     Visit((RefType)edmType);
 239                     break;
 240                 case BuiltInTypeKind.CollectionType:
 241                     Visit((CollectionType)edmType);
 242                     break;
 243                 case BuiltInTypeKind.EnumType:
 244                     Visit((EnumType)edmType);
 245                     break;
 246                 default:
 247                     Debug.Fail(String.Format(CultureInfo.InvariantCulture, "Found type '{0}', did we add a new type?", edmType.BuiltInTypeKind));
 248                     break;
 249             }
 250             #endregion
 251         }
 252         protected virtual void Visit(Facet facet)
 253         {
 254             Visit(facet.FacetType);
 255         }
 256         protected virtual void Visit(EdmFunction edmFunction)
 257         {
 258             Visit(edmFunction.BaseType);
 259             foreach (var entitySet in edmFunction.EntitySets)
 260             {
 261                 if (entitySet != null)
 262                 {
 263                     Visit(entitySet);
 264                 }
 265             }
 266             foreach (var functionParameter in edmFunction.Parameters)
 267             {
 268                 Visit(functionParameter);
 269             }
 270             foreach (var returnParameter in edmFunction.ReturnParameters)
 271             {
 272                 Visit(returnParameter);
 273             }
 274         }
 275         protected virtual void Visit(PrimitiveType primitiveType)
 276         {
 277         }
 278         protected virtual void Visit(ComplexType complexType)
 279         {
 280             Visit(complexType.BaseType);
 281             foreach (var member in complexType.Members)
 282             {
 283                 Visit(member);
 284             }
 285             foreach (var property in complexType.Properties)
 286             {
 287                 Visit(property);
 288             }
 289         }
 290         protected virtual void Visit(RefType refType)
 291         {
 292             Visit(refType.BaseType);
 293             Visit(refType.ElementType);
 294         }
 295         protected virtual void Visit(EnumType enumType)
 296         {
 297             foreach (var member in enumType.Members)
 298             {
 299                 Visit(member);
 300             }
 301         }
 302         protected virtual void Visit(EnumMember enumMember)
 303         {
 304         }
 305         protected virtual void Visit(CollectionType collectionType)
 306         {
 307             Visit(collectionType.BaseType);
 308             Visit(collectionType.TypeUsage);
 309         }
 310         protected virtual void Visit(EntityTypeBase entityTypeBase)
 311         {
 312             // switching node
 313             if (entityTypeBase == null)
 314             {
 315                 return;
 316             }
 317             switch (entityTypeBase.BuiltInTypeKind)
 318             {
 319                 case BuiltInTypeKind.AssociationType:
 320                     Visit((AssociationType)entityTypeBase);
 321                     break;
 322                 case BuiltInTypeKind.EntityType:
 323                     Visit((EntityType)entityTypeBase);
 324                     break;
 325                 default:
 326                     Debug.Fail(String.Format(CultureInfo.InvariantCulture, "Found type '{0}', did we add a new type?", entityTypeBase.BuiltInTypeKind));
 327                     break;
 328             }
 329         }
 330         protected virtual void Visit(FunctionParameter functionParameter)
 331         {
 332             Visit(functionParameter.DeclaringFunction);
 333             Visit(functionParameter.TypeUsage);
 334         }
 335         protected virtual void Visit(DbProviderManifest providerManifest)
 336         {
 337         }
 338         protected virtual void Visit(StorageTypeMapping storageTypeMapping)
 339         {
 340             foreach (var type in storageTypeMapping.IsOfTypes)
 341             {
 342                 Visit(type);
 343             }
 344
 345             foreach (var fragment in storageTypeMapping.MappingFragments)
 346             {
 347                 Visit(fragment);
 348             }
 349
 350             Visit(storageTypeMapping.SetMapping);
 351
 352             foreach (var type in storageTypeMapping.Types)
 353             {
 354                 Visit(type);
 355             }
 356         }
 357         protected virtual void Visit(StorageMappingFragment storageMappingFragment)
 358         {
 359             foreach (var property in storageMappingFragment.AllProperties)
 360             {
 361                 Visit(property);
 362             }
 363
 364             Visit((EntitySetBase)storageMappingFragment.TableSet);
 365         }
 366         protected virtual void Visit(StoragePropertyMapping storagePropertyMapping)
 367         {
 368             // this is a switching node, so no object header and footer will be add for this node,
 369             // also this Visit won't add the object to the seen list
 370
 371             if (storagePropertyMapping.GetType() == typeof(StorageComplexPropertyMapping))
 372             {
 373                 Visit((StorageComplexPropertyMapping)storagePropertyMapping);
 374             }
 375             else if (storagePropertyMapping.GetType() == typeof(StorageConditionPropertyMapping))
 376             {
 377                 Visit((StorageConditionPropertyMapping)storagePropertyMapping);
 378             }
 379             else if (storagePropertyMapping.GetType() == typeof(StorageScalarPropertyMapping))
 380             {
 381                 Visit((StorageScalarPropertyMapping)storagePropertyMapping);
 382             }
 383             else
 384             {
 385                 Debug.Fail(String.Format(CultureInfo.InvariantCulture, "Found type '{0}', did we add a new type?", storagePropertyMapping.GetType()));
 386             }
 387         }
 388         protected virtual void Visit(StorageComplexPropertyMapping storageComplexPropertyMapping)
 389         {
 390             Visit(storageComplexPropertyMapping.EdmProperty);
 391             foreach (var mapping in storageComplexPropertyMapping.TypeMappings)
 392             {
 393                 Visit(mapping);
 394             }
 395         }
 396         protected virtual void Visit(StorageConditionPropertyMapping storageConditionPropertyMapping)
 397         {
 398             Visit(storageConditionPropertyMapping.ColumnProperty);
 399             Visit(storageConditionPropertyMapping.EdmProperty);
 400         }
 401         protected virtual void Visit(StorageScalarPropertyMapping storageScalarPropertyMapping)
 402         {
 403             Visit(storageScalarPropertyMapping.ColumnProperty);
 404             Visit(storageScalarPropertyMapping.EdmProperty);
 405         }
 406
 407         protected virtual void Visit(StorageComplexTypeMapping storageComplexTypeMapping)
 408         {
 409             foreach (var property in storageComplexTypeMapping.AllProperties)
 410             {
 411                 Visit(property);
 412             }
 413
 414             foreach (var type in storageComplexTypeMapping.IsOfTypes)
 415             {
 416                 Visit(type);
 417             }
 418
 419             foreach (var type in storageComplexTypeMapping.Types)
 420             {
 421                 Visit(type);
 422             }
 423         }
 424     }
 425 }