internal MetadataPropertyValue(PropertyInfo propertyInfo, MetadataItem item)
{
Debug.Assert(null != propertyInfo);
Debug.Assert(null != item);
_propertyInfo = propertyInfo;
_item = item;
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="propertySource">The event source</param>
/// <param name="backingFieldName">The name of the field corresponding to the property</param>
/// <param name="returnType">The property return type</param>
public PropertyGeneratedEventArgs(MetadataItem propertySource,
string backingFieldName,
CodeTypeReference returnType)
{
this._propertySource = propertySource;
this._backingFieldName = backingFieldName;
this._returnType = returnType;
}
/// <summary>
/// Throws an appropriate exception if the given item is a readonly, used when an attempt is made to change
/// a property
/// </summary>
/// <param name="item">The item whose readonly is being tested</param>
internal static void ThrowIfReadOnly(MetadataItem item)
{
Debug.Assert(item != null, "The given item is null");
if (item.IsReadOnly)
{
throw new InvalidOperationException(Strings.OperationOnReadOnlyItem);
}
}
/// <summary>
/// Throws an appropriate exception if the given item is a readonly, used when an attempt is made to change
/// a property
/// </summary>
/// <param name="item">The item whose readonly is being tested</param>
internal static void ThrowIfReadOnly(MetadataItem item)
{
Debug.Assert(item != null, "The given item is null");
if (item.IsReadOnly)
{
throw EntityUtil.OperationOnReadOnlyItem();
}
}
public static bool TryGetStringMetadataPropertySetting(MetadataItem item, string propertyName, out string value)
{
value = null;
MetadataProperty property = item.MetadataProperties.FirstOrDefault(p => p.Name == propertyName);
if (property != null)
{
value = (string)property.Value;
}
return value != null;
}
/// <summary>
/// emit all the documentation comments for an element's documentation child
/// (if the element does not have a documentation child emit some standard "missing comments" comment
/// </summary>
/// <param name="element">the element whose documentation is to be displayed</param>
/// <param name="commentCollection">the comment collection of the CodeDom object to be commented</param>
public static void EmitSummaryComments(MetadataItem item, CodeCommentStatementCollection commentCollection)
{
Debug.Assert(item != null, "item parameter is null");
Debug.Assert(commentCollection != null, "commentCollection parameter is null");
Documentation documentation = GetDocumentation(item);
string [] summaryComments = null;
if (documentation != null && !MetadataUtil.IsNullOrEmptyOrWhiteSpace(documentation.Summary))
{
// we have documentation to emit
summaryComments = GetFormattedLines(documentation.Summary, true);
}
else
{
string summaryComment;
// no summary content, so use a default
switch (item.BuiltInTypeKind)
{
case BuiltInTypeKind.EdmProperty:
summaryComment = Strings.MissingPropertyDocumentation(((EdmProperty)item).Name);
break;
case BuiltInTypeKind.ComplexType:
summaryComment = Strings.MissingComplexTypeDocumentation(((ComplexType)item).FullName);
break;
default:
{
PropertyInfo pi = item.GetType().GetProperty("FullName");
if (pi == null)
{
pi = item.GetType().GetProperty("Name");
}
object value = null;
if (pi != null)
{
value = pi.GetValue(item, null);
}
if (value != null)
{
summaryComment = Strings.MissingDocumentation(value.ToString());
}
else
{
summaryComment = Strings.MissingDocumentationNoName;
}
}
break;
}
summaryComments = new string[] { summaryComment };
}
EmitSummaryComments(summaryComments, commentCollection);
EmitOtherDocumentationComments(documentation, commentCollection);
}
/// <summary>
/// Finds the extended property from a collection of extended EFx properties
/// </summary>
/// <param name="metadataItem">MetadataItem that contains the properties to search</param>
/// <param name="propertyName">Name of the extended property</param>
/// <returns>The corresponding MetadataProperty object if found, null otherwise</returns>
internal static MetadataProperty FindExtendedProperty(MetadataItem metadataItem, String propertyName)
{
// MetadataItem.MetadataProperties can contain at most one property with the specified name
string extendedPropertyName = Microsoft.OData.Service.XmlConstants.DataWebMetadataNamespace + ":" + propertyName;
MetadataProperty metadataProperty;
if (metadataItem.MetadataProperties.TryGetValue(extendedPropertyName, false, out metadataProperty))
{
Debug.Assert(metadataProperty.PropertyKind == PropertyKind.Extended, "Metadata properties in the data services namespace should always be extended EDM properties");
return metadataProperty;
}
return null;
}
/// <summary>
/// Override EdmEquals to support value comparison of TypeUsage property
/// </summary>
/// <param name="item"></param>
/// <returns></returns>
internal override bool EdmEquals(MetadataItem item)
{
// short-circuit if this and other are reference equivalent
if (Object.ReferenceEquals(this, item))
{
return(true);
}
// check type of item
if (null == item || BuiltInTypeKind.CollectionType != item.BuiltInTypeKind)
{
return(false);
}
CollectionType other = (CollectionType)item;
// compare type usage
return(this.TypeUsage.EdmEquals(other.TypeUsage));
}
/// <summary>
/// EdmEquals override verifying the equivalence of all members and their type usages.
/// </summary>
/// <param name="item"></param>
/// <returns></returns>
internal override bool EdmEquals(MetadataItem item)
{
// short-circuit if this and other are reference equivalent
if (Object.ReferenceEquals(this, item))
{
return(true);
}
// check type of item
if (null == item || BuiltInTypeKind.RowType != item.BuiltInTypeKind)
{
return(false);
}
RowType other = (RowType)item;
// check each row type has the same number of members
if (this.Members.Count != other.Members.Count)
{
return(false);
}
// verify all members are equivalent
for (int ordinal = 0; ordinal < this.Members.Count; ordinal++)
{
EdmMember thisMember = this.Members[ordinal];
EdmMember otherMember = other.Members[ordinal];
// if members are different, return false
if (!thisMember.EdmEquals(otherMember) ||
!thisMember.TypeUsage.EdmEquals(otherMember.TypeUsage))
{
return(false);
}
}
return(true);
}
//JsrSoft private static void CalculatePropertyAccessibility(MetadataItem item,
public static void CalculatePropertyAccessibility(MetadataItem item,
out string propertyAccessibility,
out string getterAccessibility,
out string setterAccessibility)
{
getterAccessibility = GetAccessibility(item, GETTER_ACCESS);
int getterRank = AccessibilityRankIdLookup[getterAccessibility];
setterAccessibility = GetAccessibility(item, SETTER_ACCESS);
int setterRank = AccessibilityRankIdLookup[setterAccessibility];
int propertyRank = Math.Max(getterRank, setterRank);
if (setterRank == propertyRank)
{
setterAccessibility = String.Empty;
}
if (getterRank == propertyRank)
{
getterAccessibility = String.Empty;
}
propertyAccessibility = AccessibilityRankIdLookup.Where(v => v.Value == propertyRank).Select(v => v.Key).Single();
}
private static void AddOtherContent(Som.SchemaElement element, MetadataItem item)
{
if (element.OtherContent.Count > 0)
{
item.AddMetadataProperties(element.OtherContent);
}
}
internal static void AssertItemHasIdentity(MetadataItem item, string argumentName)
{
Debug.Assert(!string.IsNullOrEmpty(item.Identity), "Item has empty identity.");
EntityUtil.GenericCheckArgumentNull(item, argumentName);
}
/// <summary>
/// Inheritors would override this method to supply custom documetation for the entire document.
/// </summary>
/// <param name="item">A <see cref="MetadataItem"/> object representing the object the documentation is being written for.</param>
/// <returns>The desired documentation.</returns>
protected virtual string WriteDocumentation(MetadataItem item)
{
StringBuilder builder = new StringBuilder();
builder.AppendLine("/*", TabQueue);
builder.AppendLine(string.Format(" * Generated on {0} with {1}", DateTime.Now.ToLongDateString(), this.GetType().FullName), TabQueue);
builder.AppendLine(string.Format(" * Generated by {0}", WindowsIdentity.GetCurrent().Name), TabQueue);
builder.AppendLine(" */", TabQueue);
return builder.ToString();
}
/// <summary>
/// Given an item, returns an instance of the item attribute described by this class.
/// </summary>
/// <param name="item">Item from which to retrieve attribute.</param>
/// <returns>Item attribute.</returns>
internal MetadataProperty GetMetadataProperty(MetadataItem item)
{
return(new MetadataProperty(_propertyInfo.Name, _attribute.Type, _attribute.IsCollectionType,
new MetadataPropertyValue(_propertyInfo, item)));
}
/// <summary>
/// Validate an item object
/// </summary>
/// <param name="item">The item to validate</param>
/// <param name="errors">An error collection for adding validation errors</param>
/// <param name="validatedItems">A dictionary keeping track of items that have been validated</param>
private void InternalValidate(MetadataItem item, List <EdmItemError> errors, HashSet <MetadataItem> validatedItems)
{
Debug.Assert(item != null, "InternalValidate is called with a null item, the caller should check for null first");
// If the item has already been validated or we need to skip readonly items, then skip
if ((item.IsReadOnly && SkipReadOnlyItems) || validatedItems.Contains(item))
{
return;
}
// Add this item to the dictionary so we won't validate this again. Note that we only do this
// in this function because every other function should eventually delegate to here
validatedItems.Add(item);
// Check to make sure the item has an identity
if (string.IsNullOrEmpty(item.Identity))
{
AddError(errors, new EdmItemError(System.Data.Entity.Strings.Validator_EmptyIdentity, item));
}
switch (item.BuiltInTypeKind)
{
case BuiltInTypeKind.CollectionType:
ValidateCollectionType((CollectionType)item, errors, validatedItems);
break;
case BuiltInTypeKind.ComplexType:
ValidateComplexType((ComplexType)item, errors, validatedItems);
break;
case BuiltInTypeKind.EntityType:
ValidateEntityType((EntityType)item, errors, validatedItems);
break;
case BuiltInTypeKind.Facet:
ValidateFacet((Facet)item, errors, validatedItems);
break;
case BuiltInTypeKind.MetadataProperty:
ValidateMetadataProperty((MetadataProperty)item, errors, validatedItems);
break;
case BuiltInTypeKind.NavigationProperty:
ValidateNavigationProperty((NavigationProperty)item, errors, validatedItems);
break;
case BuiltInTypeKind.PrimitiveType:
ValidatePrimitiveType((PrimitiveType)item, errors, validatedItems);
break;
case BuiltInTypeKind.EdmProperty:
ValidateEdmProperty((EdmProperty)item, errors, validatedItems);
break;
case BuiltInTypeKind.RefType:
ValidateRefType((RefType)item, errors, validatedItems);
break;
case BuiltInTypeKind.TypeUsage:
ValidateTypeUsage((TypeUsage)item, errors, validatedItems);
break;
// Abstract classes
case BuiltInTypeKind.EntityTypeBase:
case BuiltInTypeKind.EdmType:
case BuiltInTypeKind.MetadataItem:
case BuiltInTypeKind.EdmMember:
case BuiltInTypeKind.RelationshipEndMember:
case BuiltInTypeKind.RelationshipType:
case BuiltInTypeKind.SimpleType:
case BuiltInTypeKind.StructuralType:
Debug.Assert(false, "An instance with a built in type kind refering to the abstract type " + item.BuiltInTypeKind + " is encountered");
break;
default:
//Debug.Assert(false, String.Format(CultureInfo.InvariantCulture, "Validate not implemented for {0}", item.BuiltInTypeKind));
break;
}
// Performs other custom validation
IEnumerable <EdmItemError> customErrors = CustomValidate(item);
if (customErrors != null)
{
errors.AddRange(customErrors);
}
}
/// <summary>
/// Inheritors would override this method to supply custom documentation for a given method.
/// </summary>
/// <param name="item">A <see cref="MetadataItem"/> object representing the object the documentation is being written for.</param>
/// <returns>The desired documentation.</returns>
protected virtual string WriteDocumentationMethod(MetadataItem item)
{
return string.Empty;
}
/// <summary>
/// Returns all facet descriptions associated with this type.
/// </summary>
/// <returns>Descriptions for all built-in facets for this type.</returns>
internal virtual IEnumerable <FacetDescription> GetAssociatedFacetDescriptions()
{
return(MetadataItem.GetGeneralFacetDescriptions());
}
/// <summary>
/// Just checks for identities to be equal
/// </summary>
/// <param name="item"></param>
/// <returns></returns>
internal virtual bool EdmEquals(MetadataItem item)
{
return ((null != item) &&
((this == item) || // same reference
(BuiltInTypeKind == item.BuiltInTypeKind &&
Identity == item.Identity)));
}
protected PropertyEmitterBase(ClientApiGenerator generator, MetadataItem item, bool declaringTypeUsesStandardBaseType)
: base(generator, item)
{
Debug.Assert(item != null, "item is null");
_declaringTypeUsesStandardBaseType = declaringTypeUsesStandardBaseType;
}
private static Documentation GetDocumentation(MetadataItem item)
{
if (item is Documentation)
return (Documentation)item;
else
return item.Documentation;
}
/// <summary>
/// Inheritors would override this method to supply custom documentation for a given type.
/// </summary>
/// <param name="item">A <see cref="MetadataItem"/> object representing the object the documentation is being written for.</param>
/// <returns>The desired documentation.</returns>
protected virtual string WriteDocumentationType(MetadataItem item)
{
StringBuilder builder = new StringBuilder();
if (item.Documentation != null)
{
builder.AppendLine("/// <summary>", TabQueue);
builder.AppendLine(string.Format("/// {0}", item.Documentation.Summary), TabQueue);
if (!string.IsNullOrWhiteSpace(item.Documentation.LongDescription))
builder.AppendLine(string.Format("/// {0}", item.Documentation.LongDescription), TabQueue);
builder.AppendLine("/// </summary>", TabQueue);
}
return builder.ToString();
}
/// <summary>
/// EdmEquals override verifying the equivalence of all members and their type usages.
/// </summary>
/// <param name="item"></param>
/// <returns></returns>
internal override bool EdmEquals(MetadataItem item)
{
// short-circuit if this and other are reference equivalent
if (Object.ReferenceEquals(this, item)) { return true; }
// check type of item
if (null == item || BuiltInTypeKind.RowType != item.BuiltInTypeKind) { return false; }
RowType other = (RowType)item;
// check each row type has the same number of members
if (this.Members.Count != other.Members.Count) { return false; }
// verify all members are equivalent
for (int ordinal = 0; ordinal < this.Members.Count; ordinal++)
{
EdmMember thisMember = this.Members[ordinal];
EdmMember otherMember = other.Members[ordinal];
// if members are different, return false
if (!thisMember.EdmEquals(otherMember) ||
!thisMember.TypeUsage.EdmEquals(otherMember.TypeUsage))
{
return false;
}
}
return true;
}
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;
}
/// <summary>
/// Construct the EdmItemError with an error message
/// </summary>
/// <param name="message">The error message for this validation error</param>
/// <param name="item">The item that causes the validation error</param>
public EdmItemError(string message, MetadataItem item)
: base(message)
{
_item = item;
}
/// <summary>
/// Allows derived classes to perform additional validation
/// </summary>
/// <param name="item">The item to perform additional validation</param>
/// <returns>A collection of errors</returns>
protected virtual IEnumerable <EdmItemError> CustomValidate(MetadataItem item)
{
return(null);
}
/// <summary>
/// Override EdmEquals to support value comparison of TypeUsage property
/// </summary>
/// <param name="item"></param>
/// <returns></returns>
internal override bool EdmEquals(MetadataItem item)
{
// short-circuit if this and other are reference equivalent
if (Object.ReferenceEquals(this, item)) { return true; }
// check type of item
if (null == item || BuiltInTypeKind.CollectionType != item.BuiltInTypeKind) { return false; }
CollectionType other = (CollectionType)item;
// compare type usage
return this.TypeUsage.EdmEquals(other.TypeUsage);
}
private static string GetAccessibility(MetadataItem item, string name)
{
string accessibility;
if (MetadataTools.TryGetStringMetadataPropertySetting(item, name, out accessibility))
{
return TranslateUserAccessibilityToCSharpAccessibility(accessibility);
}
return "public";
}
public ODataUriItem(MetadataItem item_, UriType uriType_)
{
this.Item = item_;
this.uriType = uriType_;
}
/// <summary>
///
/// </summary>
/// <param name="generator"></param>
/// <param name="schemaType"></param>
protected SchemaTypeEmitter(ClientApiGenerator generator, MetadataItem item)
: base(generator, item)
{
}
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;
}
/// <summary>
/// Static Constructor which initializes all the built in types and primitive types
/// </summary>
static MetadataItem()
{
////////////////////////////////////////////////////////////////////////////////////////////////
// Bootstrapping the builtin types
////////////////////////////////////////////////////////////////////////////////////////////////
_builtInTypes[(int)BuiltInTypeKind.AssociationEndMember] = new ComplexType();
_builtInTypes[(int)BuiltInTypeKind.AssociationSet] = new ComplexType();
_builtInTypes[(int)BuiltInTypeKind.AssociationSetEnd] = new ComplexType();
_builtInTypes[(int)BuiltInTypeKind.AssociationType] = new ComplexType();
_builtInTypes[(int)BuiltInTypeKind.AssociationType] = new ComplexType();
_builtInTypes[(int)BuiltInTypeKind.CollectionKind] = new EnumType();
_builtInTypes[(int)BuiltInTypeKind.CollectionType] = new ComplexType();
_builtInTypes[(int)BuiltInTypeKind.ComplexType] = new ComplexType();
_builtInTypes[(int)BuiltInTypeKind.Documentation] = new ComplexType();
_builtInTypes[(int)BuiltInTypeKind.OperationAction] = new EnumType();
_builtInTypes[(int)BuiltInTypeKind.EdmType] = new ComplexType();
_builtInTypes[(int)BuiltInTypeKind.EntityContainer] = new ComplexType();
_builtInTypes[(int)BuiltInTypeKind.EntitySet] = new ComplexType();
_builtInTypes[(int)BuiltInTypeKind.EntityType] = new ComplexType();
_builtInTypes[(int)BuiltInTypeKind.EntitySetBase] = new ComplexType();
_builtInTypes[(int)BuiltInTypeKind.EntityTypeBase] = new ComplexType();
_builtInTypes[(int)BuiltInTypeKind.EnumType] = new ComplexType();
_builtInTypes[(int)BuiltInTypeKind.EnumMember] = new ComplexType();
_builtInTypes[(int)BuiltInTypeKind.Facet] = new ComplexType();
_builtInTypes[(int)BuiltInTypeKind.EdmFunction] = new ComplexType();
_builtInTypes[(int)BuiltInTypeKind.FunctionParameter] = new ComplexType();
_builtInTypes[(int)BuiltInTypeKind.GlobalItem] = new ComplexType();
_builtInTypes[(int)BuiltInTypeKind.MetadataProperty] = new ComplexType();
_builtInTypes[(int)BuiltInTypeKind.NavigationProperty] = new ComplexType();
_builtInTypes[(int)BuiltInTypeKind.MetadataItem] = new ComplexType();
_builtInTypes[(int)BuiltInTypeKind.EdmMember] = new ComplexType();
_builtInTypes[(int)BuiltInTypeKind.ParameterMode] = new EnumType();
_builtInTypes[(int)BuiltInTypeKind.PrimitiveType] = new ComplexType();
_builtInTypes[(int)BuiltInTypeKind.PrimitiveTypeKind] = new EnumType();
_builtInTypes[(int)BuiltInTypeKind.EdmProperty] = new ComplexType();
_builtInTypes[(int)BuiltInTypeKind.ProviderManifest] = new ComplexType();
_builtInTypes[(int)BuiltInTypeKind.ReferentialConstraint] = new ComplexType();
_builtInTypes[(int)BuiltInTypeKind.RefType] = new ComplexType();
_builtInTypes[(int)BuiltInTypeKind.RelationshipEndMember] = new ComplexType();
_builtInTypes[(int)BuiltInTypeKind.RelationshipMultiplicity] = new EnumType();
_builtInTypes[(int)BuiltInTypeKind.RelationshipSet] = new ComplexType();
_builtInTypes[(int)BuiltInTypeKind.RelationshipType] = new ComplexType();
_builtInTypes[(int)BuiltInTypeKind.RowType] = new ComplexType();
_builtInTypes[(int)BuiltInTypeKind.SimpleType] = new ComplexType();
_builtInTypes[(int)BuiltInTypeKind.StructuralType] = new ComplexType();
_builtInTypes[(int)BuiltInTypeKind.TypeUsage] = new ComplexType();
////////////////////////////////////////////////////////////////////////////////////////////////
// Initialize item attributes for all the built-in complex types
////////////////////////////////////////////////////////////////////////////////////////////////
InitializeBuiltInTypes((ComplexType)GetBuiltInType(BuiltInTypeKind.MetadataItem),
EdmConstants.ItemType,
false /*isAbstract*/,
null);
// populate the attributes for item attributes
InitializeBuiltInTypes((ComplexType)GetBuiltInType(BuiltInTypeKind.MetadataProperty),
EdmConstants.ItemAttribute,
true /*isAbstract*/,
(ComplexType)GetBuiltInType(BuiltInTypeKind.MetadataItem));
InitializeBuiltInTypes((ComplexType)GetBuiltInType(BuiltInTypeKind.GlobalItem),
EdmConstants.GlobalItem,
false /*isAbstract*/,
(ComplexType)GetBuiltInType(BuiltInTypeKind.MetadataItem));
InitializeBuiltInTypes((ComplexType)GetBuiltInType(BuiltInTypeKind.TypeUsage),
EdmConstants.TypeUsage,
false, /*isAbstract*/
(ComplexType)GetBuiltInType(BuiltInTypeKind.MetadataItem));
//populate the attributes for the edm type
InitializeBuiltInTypes((ComplexType)GetBuiltInType(BuiltInTypeKind.EdmType),
EdmConstants.EdmType,
true, /*isAbstract*/
(ComplexType)GetBuiltInType(BuiltInTypeKind.GlobalItem));
InitializeBuiltInTypes((ComplexType)GetBuiltInType(BuiltInTypeKind.SimpleType),
EdmConstants.SimpleType,
true /*isAbstract*/,
(ComplexType)GetBuiltInType(BuiltInTypeKind.EdmType));
InitializeBuiltInTypes((ComplexType)GetBuiltInType(BuiltInTypeKind.EnumType),
EdmConstants.EnumerationType,
false /*isAbstract*/,
(ComplexType)GetBuiltInType(BuiltInTypeKind.SimpleType));
InitializeBuiltInTypes((ComplexType)GetBuiltInType(BuiltInTypeKind.PrimitiveType),
EdmConstants.PrimitiveType,
false /*isAbstract*/,
(ComplexType)GetBuiltInType(BuiltInTypeKind.SimpleType));
InitializeBuiltInTypes((ComplexType)GetBuiltInType(BuiltInTypeKind.CollectionType),
EdmConstants.CollectionType,
false /*isAbstract*/,
(ComplexType)GetBuiltInType(BuiltInTypeKind.EdmType));
InitializeBuiltInTypes((ComplexType)GetBuiltInType(BuiltInTypeKind.RefType),
EdmConstants.RefType,
false /*isAbstract*/,
(ComplexType)GetBuiltInType(BuiltInTypeKind.EdmType));
InitializeBuiltInTypes((ComplexType)GetBuiltInType(BuiltInTypeKind.EdmMember),
EdmConstants.Member,
true /*isAbstract*/,
(ComplexType)GetBuiltInType(BuiltInTypeKind.MetadataItem));
InitializeBuiltInTypes((ComplexType)GetBuiltInType(BuiltInTypeKind.EdmProperty),
EdmConstants.Property,
false /*isAbstract*/,
(ComplexType)GetBuiltInType(BuiltInTypeKind.EdmMember));
InitializeBuiltInTypes((ComplexType)GetBuiltInType(BuiltInTypeKind.NavigationProperty),
EdmConstants.NavigationProperty,
false /*isAbstract*/,
(ComplexType)GetBuiltInType(BuiltInTypeKind.EdmMember));
InitializeBuiltInTypes((ComplexType)GetBuiltInType(BuiltInTypeKind.ProviderManifest),
EdmConstants.ProviderManifest,
true /*isAbstract*/,
(ComplexType)GetBuiltInType(BuiltInTypeKind.MetadataItem));
InitializeBuiltInTypes((ComplexType)GetBuiltInType(BuiltInTypeKind.RelationshipEndMember),
EdmConstants.RelationshipEnd,
true /*isAbstract*/,
(ComplexType)GetBuiltInType(BuiltInTypeKind.EdmMember));
InitializeBuiltInTypes((ComplexType)GetBuiltInType(BuiltInTypeKind.AssociationEndMember),
EdmConstants.AssociationEnd,
false /*isAbstract*/,
(ComplexType)GetBuiltInType(BuiltInTypeKind.RelationshipEndMember));
InitializeBuiltInTypes((ComplexType)GetBuiltInType(BuiltInTypeKind.EnumMember),
EdmConstants.EnumerationMember,
false /*isAbstract*/,
(ComplexType)GetBuiltInType(BuiltInTypeKind.MetadataItem));
InitializeBuiltInTypes((ComplexType)GetBuiltInType(BuiltInTypeKind.ReferentialConstraint),
EdmConstants.ReferentialConstraint,
false /*isAbstract*/,
(ComplexType)GetBuiltInType(BuiltInTypeKind.MetadataItem));
// Structural Type hierarchy
InitializeBuiltInTypes((ComplexType)GetBuiltInType(BuiltInTypeKind.StructuralType),
EdmConstants.StructuralType,
true /*isAbstract*/,
(ComplexType)GetBuiltInType(BuiltInTypeKind.EdmType));
InitializeBuiltInTypes((ComplexType)GetBuiltInType(BuiltInTypeKind.RowType),
EdmConstants.RowType,
false /*isAbstract*/,
(ComplexType)GetBuiltInType(BuiltInTypeKind.StructuralType));
InitializeBuiltInTypes((ComplexType)GetBuiltInType(BuiltInTypeKind.ComplexType),
EdmConstants.ComplexType,
false /*isAbstract*/,
(ComplexType)GetBuiltInType(BuiltInTypeKind.StructuralType));
InitializeBuiltInTypes((ComplexType)GetBuiltInType(BuiltInTypeKind.EntityTypeBase),
EdmConstants.ElementType,
true /*isAbstract*/,
(ComplexType)GetBuiltInType(BuiltInTypeKind.StructuralType));
InitializeBuiltInTypes((ComplexType)GetBuiltInType(BuiltInTypeKind.EntityType),
EdmConstants.EntityType,
false /*isAbstract*/,
(ComplexType)GetBuiltInType(BuiltInTypeKind.EntityTypeBase));
InitializeBuiltInTypes((ComplexType)GetBuiltInType(BuiltInTypeKind.RelationshipType),
EdmConstants.RelationshipType,
true /*isAbstract*/,
(ComplexType)GetBuiltInType(BuiltInTypeKind.EntityTypeBase));
InitializeBuiltInTypes((ComplexType)GetBuiltInType(BuiltInTypeKind.AssociationType),
EdmConstants.AssociationType,
false /*isAbstract*/,
(ComplexType)GetBuiltInType(BuiltInTypeKind.RelationshipType));
InitializeBuiltInTypes((ComplexType)GetBuiltInType(BuiltInTypeKind.Facet),
EdmConstants.Facet,
false /*isAbstract*/,
(ComplexType)GetBuiltInType(BuiltInTypeKind.MetadataItem));
InitializeBuiltInTypes((ComplexType)GetBuiltInType(BuiltInTypeKind.EntityContainer),
EdmConstants.EntityContainerType,
false /*isAbstract*/,
(ComplexType)GetBuiltInType(BuiltInTypeKind.GlobalItem));
InitializeBuiltInTypes((ComplexType)GetBuiltInType(BuiltInTypeKind.EntitySetBase),
EdmConstants.BaseEntitySetType,
true /*isAbstract*/,
(ComplexType)GetBuiltInType(BuiltInTypeKind.MetadataItem));
InitializeBuiltInTypes((ComplexType)GetBuiltInType(BuiltInTypeKind.EntitySet),
EdmConstants.EntitySetType,
false /*isAbstract*/,
(ComplexType)GetBuiltInType(BuiltInTypeKind.EntitySetBase));
InitializeBuiltInTypes((ComplexType)GetBuiltInType(BuiltInTypeKind.RelationshipSet),
EdmConstants.RelationshipSet,
true /*isAbstract*/,
(ComplexType)GetBuiltInType(BuiltInTypeKind.EntitySetBase));
InitializeBuiltInTypes((ComplexType)GetBuiltInType(BuiltInTypeKind.AssociationSet),
EdmConstants.AssociationSetType,
false /*isAbstract*/,
(ComplexType)GetBuiltInType(BuiltInTypeKind.RelationshipSet));
InitializeBuiltInTypes((ComplexType)GetBuiltInType(BuiltInTypeKind.AssociationSetEnd),
EdmConstants.AssociationSetEndType,
false /*isAbstract*/,
(ComplexType)GetBuiltInType(BuiltInTypeKind.MetadataItem));
InitializeBuiltInTypes((ComplexType)GetBuiltInType(BuiltInTypeKind.FunctionParameter),
EdmConstants.FunctionParameter,
false /*isAbstract*/,
(ComplexType)GetBuiltInType(BuiltInTypeKind.MetadataItem));
InitializeBuiltInTypes((ComplexType)GetBuiltInType(BuiltInTypeKind.EdmFunction),
EdmConstants.Function,
false /*isAbstract*/,
(ComplexType)GetBuiltInType(BuiltInTypeKind.EdmType));
InitializeBuiltInTypes((ComplexType)GetBuiltInType(BuiltInTypeKind.Documentation),
EdmConstants.Documentation,
false /*isAbstract*/,
(ComplexType)GetBuiltInType(BuiltInTypeKind.MetadataItem));
////////////////////////////////////////////////////////////////////////////////////////////////
// Initialize item attributes for all the built-in enum types
////////////////////////////////////////////////////////////////////////////////////////////////
InitializeEnumType(BuiltInTypeKind.OperationAction,
EdmConstants.DeleteAction,
new string[] { EdmConstants.None, EdmConstants.Cascade, EdmConstants.Restrict });
InitializeEnumType(BuiltInTypeKind.RelationshipMultiplicity,
EdmConstants.RelationshipMultiplicity,
new string[] { EdmConstants.One, EdmConstants.ZeroToOne, EdmConstants.Many });
InitializeEnumType(BuiltInTypeKind.ParameterMode,
EdmConstants.ParameterMode,
new string[] { EdmConstants.In, EdmConstants.Out, EdmConstants.InOut });
InitializeEnumType(BuiltInTypeKind.CollectionKind,
EdmConstants.CollectionKind,
new string[] { EdmConstants.NoneCollectionKind, EdmConstants.ListCollectionKind, EdmConstants.BagCollectionKind });
InitializeEnumType(BuiltInTypeKind.PrimitiveTypeKind,
EdmConstants.PrimitiveTypeKind,
Enum.GetNames(typeof(PrimitiveTypeKind)));
////////////////////////////////////////////////////////////////////////////////////////////////
// Bootstrapping the general facet descriptions
////////////////////////////////////////////////////////////////////////////////////////////////
// Other type non-specific facets
FacetDescription[] generalFacetDescriptions = new FacetDescription[2];
_nullableFacetDescription = new FacetDescription(DbProviderManifest.NullableFacetName,
EdmProviderManifest.GetPrimitiveType(PrimitiveTypeKind.Boolean),
null,
null,
true);
generalFacetDescriptions[0] = (_nullableFacetDescription);
_defaultValueFacetDescription = new FacetDescription(DbProviderManifest.DefaultValueFacetName,
MetadataItem.GetBuiltInType(BuiltInTypeKind.EdmType),
null,
null,
null);
generalFacetDescriptions[1] = (_defaultValueFacetDescription);
_generalFacetDescriptions = Array.AsReadOnly(generalFacetDescriptions);
_collectionKindFacetDescription = new FacetDescription(XmlConstants.CollectionKind,
MetadataItem.GetBuiltInType(BuiltInTypeKind.EnumType),
null,
null,
null);
////////////////////////////////////////////////////////////////////////////////////////////////
// Add properties for the built-in complex types
////////////////////////////////////////////////////////////////////////////////////////////////
TypeUsage stringTypeUsage = TypeUsage.Create(EdmProviderManifest.GetPrimitiveType(PrimitiveTypeKind.String));
TypeUsage booleanTypeUsage = TypeUsage.Create(EdmProviderManifest.GetPrimitiveType(PrimitiveTypeKind.Boolean));
TypeUsage edmTypeUsage = TypeUsage.Create(MetadataItem.GetBuiltInType(BuiltInTypeKind.EdmType));
TypeUsage typeUsageTypeUsage = TypeUsage.Create(MetadataItem.GetBuiltInType(BuiltInTypeKind.TypeUsage));
TypeUsage complexTypeUsage = TypeUsage.Create(MetadataItem.GetBuiltInType(BuiltInTypeKind.ComplexType));
// populate the attributes for item attributes
AddBuiltInTypeProperties(BuiltInTypeKind.MetadataProperty,
new EdmProperty[] { new EdmProperty(EdmConstants.Name, stringTypeUsage),
new EdmProperty(EdmConstants.TypeUsage, typeUsageTypeUsage),
new EdmProperty(EdmConstants.Value, complexTypeUsage) });
AddBuiltInTypeProperties(BuiltInTypeKind.MetadataItem,
new EdmProperty[] { new EdmProperty(EdmConstants.ItemAttributes, TypeUsage.Create(GetBuiltInType(BuiltInTypeKind.MetadataProperty).GetCollectionType())),
new EdmProperty(EdmConstants.Documentation, TypeUsage.Create(GetBuiltInType(BuiltInTypeKind.Documentation))) });
AddBuiltInTypeProperties(BuiltInTypeKind.TypeUsage,
new EdmProperty[] { new EdmProperty(EdmConstants.EdmType, TypeUsage.Create(GetBuiltInType(BuiltInTypeKind.EdmType))),
new EdmProperty(EdmConstants.Facets, TypeUsage.Create(GetBuiltInType(BuiltInTypeKind.Facet))) });
//populate the attributes for the edm type
AddBuiltInTypeProperties(BuiltInTypeKind.EdmType,
new EdmProperty[] { new EdmProperty(EdmConstants.Name, stringTypeUsage),
new EdmProperty(EdmConstants.Namespace, stringTypeUsage),
new EdmProperty(EdmConstants.Abstract, booleanTypeUsage),
new EdmProperty(EdmConstants.Sealed, booleanTypeUsage),
new EdmProperty(EdmConstants.BaseType, complexTypeUsage) });
AddBuiltInTypeProperties(BuiltInTypeKind.EnumType,
new EdmProperty[] { new EdmProperty(EdmConstants.EnumMembers, stringTypeUsage) });
AddBuiltInTypeProperties(BuiltInTypeKind.CollectionType,
new EdmProperty[] { new EdmProperty(EdmConstants.TypeUsage, typeUsageTypeUsage) });
AddBuiltInTypeProperties(BuiltInTypeKind.RefType,
new EdmProperty[] { new EdmProperty(EdmConstants.EntityType, TypeUsage.Create(GetBuiltInType(BuiltInTypeKind.EntityType))) });
AddBuiltInTypeProperties(BuiltInTypeKind.EdmMember,
new EdmProperty[] { new EdmProperty(EdmConstants.Name, stringTypeUsage),
new EdmProperty(EdmConstants.TypeUsage, TypeUsage.Create(GetBuiltInType(BuiltInTypeKind.TypeUsage))) });
AddBuiltInTypeProperties(BuiltInTypeKind.EdmProperty,
new EdmProperty[] { new EdmProperty(EdmConstants.Nullable, stringTypeUsage),
new EdmProperty(EdmConstants.DefaultValue, complexTypeUsage) });
AddBuiltInTypeProperties(BuiltInTypeKind.NavigationProperty,
new EdmProperty[] { new EdmProperty(EdmConstants.RelationshipTypeName, stringTypeUsage),
new EdmProperty(EdmConstants.ToEndMemberName, stringTypeUsage) });
AddBuiltInTypeProperties(BuiltInTypeKind.RelationshipEndMember,
new EdmProperty[] { new EdmProperty(EdmConstants.OperationBehaviors, complexTypeUsage),
new EdmProperty(EdmConstants.RelationshipMultiplicity, TypeUsage.Create(GetBuiltInType(BuiltInTypeKind.EnumType))) });
AddBuiltInTypeProperties(BuiltInTypeKind.EnumMember,
new EdmProperty[] { new EdmProperty(EdmConstants.Name, stringTypeUsage) });
AddBuiltInTypeProperties(BuiltInTypeKind.ReferentialConstraint,
new EdmProperty[] { new EdmProperty(EdmConstants.ToRole, TypeUsage.Create(GetBuiltInType(BuiltInTypeKind.RelationshipEndMember))),
new EdmProperty(EdmConstants.FromRole, TypeUsage.Create(GetBuiltInType(BuiltInTypeKind.RelationshipEndMember))),
new EdmProperty(EdmConstants.ToProperties, TypeUsage.Create(GetBuiltInType(BuiltInTypeKind.EdmProperty).GetCollectionType())),
new EdmProperty(EdmConstants.FromProperties, TypeUsage.Create(GetBuiltInType(BuiltInTypeKind.EdmProperty).GetCollectionType())) });
// Structural Type hierarchy
AddBuiltInTypeProperties(BuiltInTypeKind.StructuralType,
new EdmProperty[] { new EdmProperty(EdmConstants.Members, TypeUsage.Create(GetBuiltInType(BuiltInTypeKind.EdmMember))) });
AddBuiltInTypeProperties(BuiltInTypeKind.EntityTypeBase,
new EdmProperty[] { new EdmProperty(EdmConstants.KeyMembers, TypeUsage.Create(GetBuiltInType(BuiltInTypeKind.EdmMember))) });
AddBuiltInTypeProperties(BuiltInTypeKind.Facet,
new EdmProperty[] { new EdmProperty(EdmConstants.Name, stringTypeUsage),
new EdmProperty(EdmConstants.EdmType, edmTypeUsage),
new EdmProperty(EdmConstants.Value, TypeUsage.Create(GetBuiltInType(BuiltInTypeKind.EdmType))) });
AddBuiltInTypeProperties(BuiltInTypeKind.EntityContainer,
new EdmProperty[] { new EdmProperty(EdmConstants.Name, stringTypeUsage),
new EdmProperty(EdmConstants.EntitySets, TypeUsage.Create(GetBuiltInType(BuiltInTypeKind.EntitySet))) });
AddBuiltInTypeProperties(BuiltInTypeKind.EntitySetBase,
new EdmProperty[] { new EdmProperty(EdmConstants.Name, stringTypeUsage),
new EdmProperty(EdmConstants.EntityType, TypeUsage.Create(GetBuiltInType(BuiltInTypeKind.EntityType))),
new EdmProperty(EdmConstants.Schema, stringTypeUsage),
new EdmProperty(EdmConstants.Table, stringTypeUsage) });
AddBuiltInTypeProperties(BuiltInTypeKind.AssociationSet,
new EdmProperty[] { new EdmProperty(EdmConstants.AssociationSetEnds, TypeUsage.Create(GetBuiltInType(BuiltInTypeKind.AssociationSetEnd).GetCollectionType())) });
AddBuiltInTypeProperties(BuiltInTypeKind.AssociationSetEnd,
new EdmProperty[] { new EdmProperty(EdmConstants.Role, stringTypeUsage),
new EdmProperty(EdmConstants.EntitySetType, TypeUsage.Create(GetBuiltInType(BuiltInTypeKind.EntitySet))) });
AddBuiltInTypeProperties(BuiltInTypeKind.FunctionParameter,
new EdmProperty[] { new EdmProperty(EdmConstants.Name, stringTypeUsage),
new EdmProperty(EdmConstants.Mode, TypeUsage.Create(GetBuiltInType(BuiltInTypeKind.EnumType))),
new EdmProperty(EdmConstants.TypeUsage, TypeUsage.Create(GetBuiltInType(BuiltInTypeKind.TypeUsage))) });
AddBuiltInTypeProperties(BuiltInTypeKind.EdmFunction,
new EdmProperty[] { new EdmProperty(EdmConstants.Name, stringTypeUsage),
new EdmProperty(EdmConstants.Namespace, stringTypeUsage),
new EdmProperty(EdmConstants.ReturnParameter, TypeUsage.Create(GetBuiltInType(BuiltInTypeKind.FunctionParameter))),
new EdmProperty(EdmConstants.Parameters, TypeUsage.Create(GetBuiltInType(BuiltInTypeKind.FunctionParameter).GetCollectionType())) });
AddBuiltInTypeProperties(BuiltInTypeKind.Documentation,
new EdmProperty[] { new EdmProperty(EdmConstants.Summary, stringTypeUsage),
new EdmProperty(EdmConstants.LongDescription, stringTypeUsage) });
// Set all types to be readonly, used SetReadOnly to skip validation method to
for (int i = 0; i < _builtInTypes.Length; i++)
{
_builtInTypes[i].SetReadOnly();
}
}
protected MetadataItemEmitter(ClientApiGenerator generator, MetadataItem item)
:base(generator)
{
Debug.Assert(item != null, "item is null");
_item = item;
}
/// <summary>
/// Construct the EdmItemError with an error message
/// </summary>
/// <param name="message">The error message for this validation error</param>
/// <param name="item">The item that causes the validation error</param>
public EdmItemError(string message, MetadataItem item)
: base(message)
{
_item = item;
}
/// <summary>
/// Constructor taking item.
/// </summary>
/// <param name="item">Item with which the collection is associated.</param>
internal MetadataPropertyCollection(MetadataItem item)
: base(GetSystemMetadataProperties(item))
{
}
/// <summary>
/// Initializes a new attribute with built in type kind
/// </summary>
/// <param name="builtInTypeKind">Built in type setting Type property</param>
/// <param name="isCollectionType">Sets IsCollectionType property</param>
internal MetadataPropertyAttribute(BuiltInTypeKind builtInTypeKind, bool isCollectionType)
: this(MetadataItem.GetBuiltInType(builtInTypeKind), isCollectionType)
{
}
