/// <summary> /// Initializes the EPM annotation with EPM information from the specified type. /// </summary> /// <param name="definingEntityType">Entity type to use the EPM infromation from.</param> /// <param name="affectedEntityType">Entity type for this the EPM information is being built.</param> internal void BuildEpmForType(IEdmEntityType definingEntityType, IEdmEntityType affectedEntityType) { DebugUtils.CheckNoExternalCallers(); Debug.Assert(definingEntityType != null, "definingEntityType != null"); Debug.Assert(affectedEntityType != null, "affectedEntityType != null"); if (definingEntityType.BaseType != null) { this.BuildEpmForType(definingEntityType.BaseEntityType(), affectedEntityType); } ODataEntityPropertyMappingCollection mappingsForType = this.model.GetEntityPropertyMappings(definingEntityType); if (mappingsForType == null) { return; } foreach (EntityPropertyMappingAttribute mapping in mappingsForType) { this.epmSourceTree.Add(new EntityPropertyMappingInfo(mapping, definingEntityType, affectedEntityType)); if (definingEntityType == affectedEntityType) { if (!PropertyExistsOnType(affectedEntityType, mapping)) { this.MappingsForInheritedProperties.Add(mapping); this.MappingsForDeclaredProperties.Remove(mapping); } } } }
internal bool IsDirty(ODataEntityPropertyMappingCollection propertyMappings) { if ((this.mappings == null) && (propertyMappings == null)) { return(false); } return(!object.ReferenceEquals(this.mappings, propertyMappings) || (this.mappings.Count != propertyMappings.Count)); }
internal ODataEntityPropertyMappingCache(ODataEntityPropertyMappingCollection mappings, IEdmModel model, int totalMappingCount) { this.mappings = mappings; this.model = model; this.totalMappingCount = totalMappingCount; this.mappingsForInheritedProperties = new List <EntityPropertyMappingAttribute>(); this.mappingsForDeclaredProperties = (mappings == null) ? new List <EntityPropertyMappingAttribute>() : new List <EntityPropertyMappingAttribute>(mappings); this.epmTargetTree = new Microsoft.Data.OData.Metadata.EpmTargetTree(); this.epmSourceTree = new Microsoft.Data.OData.Metadata.EpmSourceTree(this.epmTargetTree); }
private static ODataEntityPropertyMappingCache EnsureEpmCacheInternal(IEdmModel model, IEdmEntityType entityType, int maxMappingCount, out bool cacheModified) { cacheModified = false; if (entityType == null) { return(null); } IEdmEntityType type = entityType.BaseEntityType(); ODataEntityPropertyMappingCache baseCache = null; if (type != null) { baseCache = EnsureEpmCacheInternal(model, type, maxMappingCount, out cacheModified); } ODataEntityPropertyMappingCache epmCache = model.GetEpmCache(entityType); if (model.HasOwnOrInheritedEpm(entityType)) { ODataEntityPropertyMappingCollection entityPropertyMappings = model.GetEntityPropertyMappings(entityType); if (!(((epmCache == null) || cacheModified) || epmCache.IsDirty(entityPropertyMappings))) { return(epmCache); } cacheModified = true; int totalMappingCount = ValidationUtils.ValidateTotalEntityPropertyMappingCount(baseCache, entityPropertyMappings, maxMappingCount); epmCache = new ODataEntityPropertyMappingCache(entityPropertyMappings, model, totalMappingCount); try { epmCache.BuildEpmForType(entityType, entityType); epmCache.EpmSourceTree.Validate(entityType); model.SetAnnotationValue <ODataEntityPropertyMappingCache>(entityType, epmCache); return(epmCache); } catch { model.RemoveEpmCache(entityType); throw; } } if (epmCache != null) { cacheModified = true; model.RemoveEpmCache(entityType); } return(epmCache); }
private static void LoadEpmAnnotations(IEdmModel model, IEdmEntityType entityType) { string typeName = entityType.ODataFullName(); ODataEntityPropertyMappingCollection mappings = new ODataEntityPropertyMappingCollection(); model.LoadEpmAnnotations(entityType, mappings, typeName, null); IEnumerable <IEdmProperty> declaredProperties = entityType.DeclaredProperties; if (declaredProperties != null) { foreach (IEdmProperty property in declaredProperties) { model.LoadEpmAnnotations(property, mappings, typeName, property); } } model.SetAnnotationValue <ODataEntityPropertyMappingCollection>(entityType, mappings); }
/// <summary> /// Constructor. /// </summary> /// <param name="mappings">The EPM mappings to create the cache for.</param> /// <param name="model">The EDM model.</param> /// <param name="totalMappingCount">The total number of entity property mappings /// for the entity type that this cache is created for (on the type itself and all its base types).</param> internal ODataEntityPropertyMappingCache(ODataEntityPropertyMappingCollection mappings, IEdmModel model, int totalMappingCount) { DebugUtils.CheckNoExternalCallers(); Debug.Assert(model.IsUserModel(), "model.IsUserModel()"); this.mappings = mappings; this.model = model; this.totalMappingCount = totalMappingCount; // Note that we new up everything here eagerly because we will only create the EPM annotation for types // for which we know for sure that they have EPM and thus we will need all of these anyway. this.mappingsForInheritedProperties = new List <EntityPropertyMappingAttribute>(); this.mappingsForDeclaredProperties = mappings == null ? new List <EntityPropertyMappingAttribute>() : new List <EntityPropertyMappingAttribute>(mappings); this.epmTargetTree = new EpmTargetTree(); this.epmSourceTree = new EpmSourceTree(this.epmTargetTree); }
/// <summary> /// Checks whether the current cache is dirty with respect to the <paramref name="propertyMappings"/>. /// </summary> /// <param name="propertyMappings">The EPM mappings to check this cache against.</param> /// <returns>true if the <paramref name="propertyMappings"/> are not the same as the ones the cache has been created for (or have changed).</returns> internal bool IsDirty(ODataEntityPropertyMappingCollection propertyMappings) { DebugUtils.CheckNoExternalCallers(); // NOTE: we only allow adding more mappings to an existing collection; so if the // references of the collections are the same and the counts are the same there has been no change. if (this.mappings == null && propertyMappings == null) { return(false); } if (!object.ReferenceEquals(this.mappings, propertyMappings)) { return(true); } return(this.mappings.Count != propertyMappings.Count); }
internal void BuildEpmForType(IEdmEntityType definingEntityType, IEdmEntityType affectedEntityType) { if (definingEntityType.BaseType != null) { this.BuildEpmForType(definingEntityType.BaseEntityType(), affectedEntityType); } ODataEntityPropertyMappingCollection entityPropertyMappings = this.model.GetEntityPropertyMappings(definingEntityType); if (entityPropertyMappings != null) { foreach (EntityPropertyMappingAttribute attribute in entityPropertyMappings) { this.epmSourceTree.Add(new EntityPropertyMappingInfo(attribute, definingEntityType, affectedEntityType)); if ((definingEntityType == affectedEntityType) && !PropertyExistsOnType(affectedEntityType, attribute)) { this.MappingsForInheritedProperties.Add(attribute); this.MappingsForDeclaredProperties.Remove(attribute); } } } }
private static void LoadEpmAnnotations(this IEdmModel model, IEdmElement annotatable, ODataEntityPropertyMappingCollection mappings, string typeName, IEdmProperty property) { IEnumerable <EpmAnnotationValues> enumerable = model.ParseSerializableEpmAnnotations(annotatable, typeName, property); if (enumerable != null) { foreach (EpmAnnotationValues values in enumerable) { EntityPropertyMappingAttribute mapping = ValidateAnnotationValues(values, typeName, property); mappings.Add(mapping); } } }