1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
|
//---------------------------------------------------------------------
// <copyright file="StorageEntitySetMapping.cs" company="Microsoft">
// Copyright (c) Microsoft Corporation. All rights reserved.
// </copyright>
//
// @owner Microsoft
// @backupOwner Microsoft
//---------------------------------------------------------------------
using System;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.Text;
using System.Data.Metadata.Edm;
using System.Diagnostics;
namespace System.Data.Mapping {
/// <summary>
/// Represents the Mapping metadata for an EnitytSet in CS space.
/// </summary>
/// <example>
/// For Example if conceptually you could represent the CS MSL file as following
/// --Mapping
/// --EntityContainerMapping ( CNorthwind-->SNorthwind )
/// --EntitySetMapping
/// --EntityTypeMapping
/// --MappingFragment
/// --EntityTypeMapping
/// --MappingFragment
/// --AssociationSetMapping
/// --AssociationTypeMapping
/// --MappingFragment
/// This class represents the metadata for the EntitySetMapping elements in the
/// above example. And it is possible to access the EntityTypeMaps underneath it.
/// </example>
internal class StorageEntitySetMapping : StorageSetMapping {
#region Constructors
/// <summary>
/// Construct a EntitySet mapping object
/// </summary>
/// <param name="extent">EntitySet metadata object</param>
/// <param name="entityContainerMapping">The entity Container Mapping that contains this Set mapping</param>
internal StorageEntitySetMapping(EntitySet extent, StorageEntityContainerMapping entityContainerMapping)
: base(extent, entityContainerMapping) {
m_modificationFunctionMappings = new List<StorageEntityTypeModificationFunctionMapping>();
m_implicitlyMappedAssociationSetEnds = new List<AssociationSetEnd>();
}
#endregion
#region Fields
private readonly List<StorageEntityTypeModificationFunctionMapping> m_modificationFunctionMappings;
private readonly List<AssociationSetEnd> m_implicitlyMappedAssociationSetEnds;
#endregion
#region Properties
/// <summary>
/// Gets all function mappings for this entity set.
/// </summary>
internal IList<StorageEntityTypeModificationFunctionMapping> ModificationFunctionMappings {
get { return m_modificationFunctionMappings.AsReadOnly(); }
}
/// <summary>
/// Gets all association sets that are implicitly "covered" through function mappings.
/// </summary>
internal IList<AssociationSetEnd> ImplicitlyMappedAssociationSetEnds {
get { return m_implicitlyMappedAssociationSetEnds.AsReadOnly(); }
}
/// <summary>
/// Whether the EntitySetMapping has empty content
/// Returns true if there are no Function Maps and no table Mapping fragments
/// </summary>
internal override bool HasNoContent {
get {
if (m_modificationFunctionMappings.Count != 0) {
return false;
}
return base.HasNoContent;
}
}
#endregion
#region Methods
/// <summary>
/// This method is primarily for debugging purposes.
/// Will be removed shortly.
/// </summary>
internal override void Print(int index) {
StorageEntityContainerMapping.GetPrettyPrintString(ref index);
StringBuilder sb = new StringBuilder();
sb.Append("EntitySetMapping");
sb.Append(" ");
sb.Append("Name:");
sb.Append(this.Set.Name);
if (this.QueryView != null)
{
sb.Append(" ");
sb.Append("Query View:");
sb.Append(this.QueryView);
}
Console.WriteLine(sb.ToString());
foreach (StorageTypeMapping typeMapping in TypeMappings) {
typeMapping.Print(index+5);
}
foreach (StorageEntityTypeModificationFunctionMapping m in m_modificationFunctionMappings)
{
m.Print(index + 10);
}
}
/// <summary>
/// Requires:
/// - Function mapping refers to a sub-type of this entity set's element type
/// - Function mappings for types are not redundantly specified
/// Adds a new function mapping for this class.
/// </summary>
/// <param name="modificationFunctionMapping">Function mapping to add. May not be null.</param>
internal void AddModificationFunctionMapping(StorageEntityTypeModificationFunctionMapping modificationFunctionMapping) {
AssertModificationFunctionMappingInvariants(modificationFunctionMapping);
m_modificationFunctionMappings.Add(modificationFunctionMapping);
// check if any association sets are indirectly mapped within this function mapping
// through association navigation bindings
if (null != modificationFunctionMapping.DeleteFunctionMapping)
{
m_implicitlyMappedAssociationSetEnds.AddRange(modificationFunctionMapping.DeleteFunctionMapping.CollocatedAssociationSetEnds);
}
if (null != modificationFunctionMapping.InsertFunctionMapping)
{
m_implicitlyMappedAssociationSetEnds.AddRange(modificationFunctionMapping.InsertFunctionMapping.CollocatedAssociationSetEnds);
}
if (null != modificationFunctionMapping.UpdateFunctionMapping)
{
m_implicitlyMappedAssociationSetEnds.AddRange(modificationFunctionMapping.UpdateFunctionMapping.CollocatedAssociationSetEnds);
}
}
[Conditional("DEBUG")]
internal void AssertModificationFunctionMappingInvariants(StorageEntityTypeModificationFunctionMapping modificationFunctionMapping) {
Debug.Assert(null != modificationFunctionMapping, "modification function mapping must not be null");
Debug.Assert(modificationFunctionMapping.EntityType.Equals(this.Set.ElementType) ||
Helper.IsSubtypeOf(modificationFunctionMapping.EntityType, this.Set.ElementType),
"attempting to add a modification function mapping with the wrong entity type");
foreach (StorageEntityTypeModificationFunctionMapping existingMapping in m_modificationFunctionMappings) {
Debug.Assert(!existingMapping.EntityType.Equals(modificationFunctionMapping.EntityType),
"modification function mapping already exists for this type");
}
}
#endregion
}
}
|
