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
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
|
//---------------------------------------------------------------------
// <copyright file="MetadataItemEmitter.cs" company="Microsoft">
// Copyright (c) Microsoft Corporation. All rights reserved.
// </copyright>
//
// @owner [....]
// @backupOwner [....]
//---------------------------------------------------------------------using System;
using System.Collections.Generic;
using System.Text;
using System.Data.Metadata.Edm;
using System.Diagnostics;
using System.CodeDom;
using System.Reflection;
namespace System.Data.EntityModel.Emitters
{
internal abstract class MetadataItemEmitter : Emitter
{
private MetadataItem _item;
protected MetadataItemEmitter(ClientApiGenerator generator, MetadataItem item)
:base(generator)
{
Debug.Assert(item != null, "item is null");
_item = item;
}
protected MetadataItem Item
{
get { return _item; }
}
/// <summary>
/// Emitter-specific validation here
/// </summary>
protected abstract void Validate();
#region Operations for Getting Accessibility
private const string CodeGenerationValueAccessibilityInternal = "Internal";
private const string CodeGenerationValueAccessibilityProtected = "Protected";
private const string CodeGenerationValueAccessibilityPublic = "Public";
private const string CodeGenerationValueAccessibilityPrivate = "Private";
#region Protected Block
protected static MemberAttributes AccessibilityFromGettersAndSetters(EdmMember property)
{
MemberAttributes scope = MemberAttributes.Private;
MemberAttributes getter = GetGetterAccessibility(property);
if (IsLeftMoreAccessableThanRight(getter, scope))
{
scope = getter;
}
MemberAttributes setter = GetSetterAccessibility(property);
if (IsLeftMoreAccessableThanRight(setter, scope))
{
scope = setter;
}
return scope;
}
protected static MemberAttributes GetGetterAccessibility(EdmMember item)
{
return GetAccessibilityValue(item, XmlConstants.GetterAccess);
}
protected static MemberAttributes GetSetterAccessibility(EdmMember item)
{
return GetAccessibilityValue(item, XmlConstants.SetterAccess);
}
protected static MemberAttributes GetFunctionImportAccessibility(EdmFunction item)
{
return GetAccessibilityValue(item, XmlConstants.MethodAccess);
}
protected static MemberAttributes GetEntitySetPropertyAccessibility(EntitySet item)
{
return GetAccessibilityValue(item, XmlConstants.GetterAccess);
}
protected static MemberAttributes GetEntityTypeAccessibility(EntityType item)
{
return GetAccessibilityValue(item, XmlConstants.TypeAccess);
}
protected static int GetAccessibilityRank(MemberAttributes accessibility)
{
Debug.Assert(accessibility == MemberAttributes.Private ||
accessibility == MemberAttributes.Public ||
accessibility == MemberAttributes.Assembly ||
accessibility == MemberAttributes.Family,
"this method is intended to deal with only single access attributes");
switch (accessibility)
{
case MemberAttributes.Public:
return 0;
case MemberAttributes.Assembly:
return 1;
case MemberAttributes.Family:
return 2;
default:
Debug.Assert(accessibility == MemberAttributes.Private, "did a new type get added?");
return 3;
}
}
protected static TypeAttributes GetTypeAccessibilityValue(MetadataItem item)
{
TypeAttributes accessibilty = TypeAttributes.Public;
MetadataProperty metadataProperty;
if (item.MetadataProperties.TryGetValue(Utils.GetFullyQualifiedCodeGenerationAttributeName(XmlConstants.TypeAccess), false, out metadataProperty))
{
accessibilty = GetCodeAccessibilityTypeAttribute(metadataProperty.Value.ToString());
}
return accessibilty;
}
#endregion Protected
#region Private Block
private static MemberAttributes GetAccessibilityValue(MetadataItem item, string attribute)
{
MemberAttributes accessibilty = MemberAttributes.Public;
MetadataProperty metadataProperty;
if (item.MetadataProperties.TryGetValue(Utils.GetFullyQualifiedCodeGenerationAttributeName(attribute), false, out metadataProperty))
{
accessibilty = GetCodeAccessibilityMemberAttribute(metadataProperty.Value.ToString());
}
return accessibilty;
}
private static MemberAttributes GetCodeAccessibilityMemberAttribute(string accessibility)
{
Debug.Assert(accessibility != null, "why does accessibility == null?");
switch (accessibility)
{
case CodeGenerationValueAccessibilityInternal:
return MemberAttributes.Assembly;
case CodeGenerationValueAccessibilityPrivate:
return MemberAttributes.Private;
case CodeGenerationValueAccessibilityProtected:
return MemberAttributes.Family;
default:
Debug.Assert(accessibility == CodeGenerationValueAccessibilityPublic, "found an accessibility other than " + CodeGenerationValueAccessibilityPublic);
return MemberAttributes.Public;
}
}
/// <summary>
/// Given a MemberAttribute, returns a string representation used in CSDL.
/// For e.g: MemebrAttribtue.Family is Protected in our csdl, (protected in C#, Family in VB)
/// Inverse of the method above (GetCodeAccessibilityMemberAttribute)
/// </summary>
protected static string GetAccessibilityCsdlStringFromMemberAttribute(MemberAttributes attribute)
{
switch (attribute)
{
case MemberAttributes.Assembly:
return CodeGenerationValueAccessibilityInternal;
case MemberAttributes.Private:
return CodeGenerationValueAccessibilityPrivate;
case MemberAttributes.Family:
return CodeGenerationValueAccessibilityProtected;
default:
Debug.Assert(attribute == MemberAttributes.Public, "found MemberAttribute other than " + CodeGenerationValueAccessibilityPublic);
return CodeGenerationValueAccessibilityPublic;
}
}
private static bool IsLeftMoreAccessableThanRight(MemberAttributes left, MemberAttributes right)
{
return GetAccessibilityRank(left) < GetAccessibilityRank(right);
}
private static TypeAttributes GetCodeAccessibilityTypeAttribute(string accessibility)
{
Debug.Assert(accessibility != null, "why does accessibility == null?");
if (accessibility == CodeGenerationValueAccessibilityInternal || accessibility == CodeGenerationValueAccessibilityProtected)
{
return TypeAttributes.NotPublic;
}
else
{
Debug.Assert(accessibility == CodeGenerationValueAccessibilityPublic, "found an accessibility other than " + CodeGenerationValueAccessibilityPublic);
return TypeAttributes.Public;
}
}
#endregion Private
#endregion Operations for getting Accessibility
}
}
|
