internal static IEnumerable<ODataProperty> GetComplexValueProperties(EpmValueCache epmValueCache, ODataComplexValue complexValue, bool writingContent)
{
if (epmValueCache == null)
{
return complexValue.Properties;
}
return epmValueCache.GetComplexValueProperties(complexValue, writingContent);
}
internal static IEnumerable <ODataProperty> GetComplexValueProperties(EpmValueCache epmValueCache, ODataComplexValue complexValue, bool writingContent)
{
if (epmValueCache == null)
{
return(complexValue.Properties);
}
return(epmValueCache.GetComplexValueProperties(complexValue, writingContent));
}
/// <summary>
/// Returns the properties for the specified complex value.
/// </summary>
/// <param name="epmValueCache">The EPM value cache to use (can be null).</param>
/// <param name="complexValue">The complex value to get the properties for.</param>
/// <param name="writingContent">If we're writing content of an entry or not.</param>
/// <returns>The properties enumeration for the complex value.</returns>
internal static IEnumerable <ODataProperty> GetComplexValueProperties(
EpmValueCache epmValueCache,
ODataComplexValue complexValue,
bool writingContent)
{
DebugUtils.CheckNoExternalCallers();
Debug.Assert(complexValue != null, "complexValue != null");
Debug.Assert(writingContent || epmValueCache != null, "If we're not writing content, then the EPM value cache must exist.");
if (epmValueCache == null)
{
return(complexValue.Properties);
}
else
{
return(epmValueCache.GetComplexValueProperties(complexValue, writingContent));
}
}
/// <summary>
/// Returns the properties for the specified complex value.
/// </summary>
/// <param name="epmValueCache">The EPM value cache to use (can be null).</param>
/// <param name="complexValue">The complex value to get the properties for.</param>
/// <param name="writingContent">If we're writing content of an entry or not.</param>
/// <returns>The properties enumeration for the complex value.</returns>
internal static IEnumerable<ODataProperty> GetComplexValueProperties(
EpmValueCache epmValueCache,
ODataComplexValue complexValue,
bool writingContent)
{
DebugUtils.CheckNoExternalCallers();
Debug.Assert(complexValue != null, "complexValue != null");
Debug.Assert(writingContent || epmValueCache != null, "If we're not writing content, then the EPM value cache must exist.");
if (epmValueCache == null)
{
return complexValue.Properties;
}
else
{
return epmValueCache.GetComplexValueProperties(complexValue, writingContent);
}
}
/// <summary>
/// Reads a property value starting on a complex value.
/// </summary>
/// <param name="epmInfo">The EPM info which describes the mapping for which to read the property value.</param>
/// <param name="complexValue">The complex value to start with.</param>
/// <param name="epmValueCache">The EPM value cache to use.</param>
/// <param name="sourceSegmentIndex">The index in the property value path to start with.</param>
/// <param name="complexType">The type of the complex value.</param>
/// <returns>The value of the property (may be null), or null if the property itself was not found due to one of its parent properties being null.</returns>
private object ReadComplexPropertyValue(
EntityPropertyMappingInfo epmInfo,
ODataComplexValue complexValue,
EpmValueCache epmValueCache,
int sourceSegmentIndex,
IEdmComplexTypeReference complexType)
{
Debug.Assert(epmInfo != null, "epmInfo != null");
Debug.Assert(epmInfo.PropertyValuePath != null, "The PropertyValuePath should have been initialized by now.");
Debug.Assert(epmInfo.PropertyValuePath.Length > sourceSegmentIndex, "The PropertyValuePath must be at least as long as the source segment index.");
Debug.Assert(epmValueCache != null, "epmValueCache != null");
Debug.Assert(sourceSegmentIndex >= 0, "sourceSegmentIndex >= 0");
Debug.Assert(complexType != null, "complexType != null");
Debug.Assert(complexValue != null, "complexValue != null");
return(this.ReadPropertyValue(
epmInfo,
EpmValueCache.GetComplexValueProperties(epmValueCache, complexValue, false),
sourceSegmentIndex,
complexType,
epmValueCache));
}
internal bool WriteComplexValue(
ODataComplexValue complexValue,
IEdmTypeReference metadataTypeReference,
bool isOpenPropertyType,
bool isWritingCollection,
Action beforeValueAction,
Action afterValueAction,
DuplicatePropertyNamesChecker duplicatePropertyNamesChecker,
CollectionWithoutExpectedTypeValidator collectionValidator,
EpmValueCache epmValueCache,
EpmSourcePathSegment epmSourcePathSegment,
ProjectedPropertiesAnnotation projectedProperties)
{
DebugUtils.CheckNoExternalCallers();
Debug.Assert(complexValue != null, "complexValue != null");
string typeName = complexValue.TypeName;
if (collectionValidator != null)
{
collectionValidator.ValidateCollectionItem(typeName, EdmTypeKind.Complex);
}
this.IncreaseRecursionDepth();
// resolve the type name to the type; if no type name is specified we will use the
// type inferred from metadata
IEdmComplexTypeReference complexTypeReference = TypeNameOracle.ResolveAndValidateTypeNameForValue(this.Model, metadataTypeReference, complexValue, isOpenPropertyType).AsComplexOrNull();
string collectionItemTypeName;
typeName = this.AtomOutputContext.TypeNameOracle.GetValueTypeNameForWriting(complexValue, complexTypeReference, complexValue.GetAnnotation <SerializationTypeNameAnnotation>(), collectionValidator, out collectionItemTypeName);
Debug.Assert(collectionItemTypeName == null, "collectionItemTypeName == null");
Action beforeValueCallbackWithTypeName = beforeValueAction;
if (typeName != null)
{
// The beforeValueAction (if specified) will write the actual property element start.
// So if we are to write the type attribute, we must postpone that after the start element was written.
// And so we chain the existing action with our type attribute writing and use that
// as the before action instead.
if (beforeValueAction != null)
{
beforeValueCallbackWithTypeName = () =>
{
beforeValueAction();
this.WritePropertyTypeAttribute(typeName);
};
}
else
{
this.WritePropertyTypeAttribute(typeName);
}
}
// NOTE: see the comments on ODataWriterBehavior.UseV1ProviderBehavior for more information
// NOTE: We have to check for ProjectedPropertiesAnnotation.Empty here to avoid filling the cache for
// complex values we are writing only to ensure we don't have nested EPM-mapped null values
// that will end up in the content eventually.
if (this.MessageWriterSettings.WriterBehavior != null &&
this.MessageWriterSettings.WriterBehavior.UseV1ProviderBehavior &&
!object.ReferenceEquals(projectedProperties, ProjectedPropertiesAnnotation.EmptyProjectedPropertiesInstance))
{
IEdmComplexType complexType = (IEdmComplexType)complexTypeReference.Definition;
CachedPrimitiveKeepInContentAnnotation keepInContentCache = this.Model.EpmCachedKeepPrimitiveInContent(complexType);
if (keepInContentCache == null)
{
// we are about to write the first value of the given type; compute the keep-in-content information for the primitive properties of this type.
List <string> keepInContentPrimitiveProperties = null;
// initialize the cache with all primitive properties
foreach (IEdmProperty edmProperty in complexType.Properties().Where(p => p.Type.IsODataPrimitiveTypeKind()))
{
// figure out the keep-in-content value
EntityPropertyMappingAttribute entityPropertyMapping = EpmWriterUtils.GetEntityPropertyMapping(epmSourcePathSegment, edmProperty.Name);
if (entityPropertyMapping != null && entityPropertyMapping.KeepInContent)
{
if (keepInContentPrimitiveProperties == null)
{
keepInContentPrimitiveProperties = new List <string>();
}
keepInContentPrimitiveProperties.Add(edmProperty.Name);
}
}
this.Model.SetAnnotationValue <CachedPrimitiveKeepInContentAnnotation>(complexType, new CachedPrimitiveKeepInContentAnnotation(keepInContentPrimitiveProperties));
}
}
bool propertyWritten = this.WriteProperties(
complexTypeReference == null ? null : complexTypeReference.ComplexDefinition(),
EpmValueCache.GetComplexValueProperties(epmValueCache, complexValue, true),
isWritingCollection,
beforeValueCallbackWithTypeName,
afterValueAction,
duplicatePropertyNamesChecker,
epmValueCache,
epmSourcePathSegment,
projectedProperties);
this.DecreaseRecursionDepth();
return(propertyWritten);
}
internal bool WriteComplexValue(ODataComplexValue complexValue, IEdmTypeReference metadataTypeReference, bool isOpenPropertyType, bool isWritingCollection, Action beforeValueAction, Action afterValueAction, DuplicatePropertyNamesChecker duplicatePropertyNamesChecker, CollectionWithoutExpectedTypeValidator collectionValidator, EpmValueCache epmValueCache, EpmSourcePathSegment epmSourcePathSegment, ProjectedPropertiesAnnotation projectedProperties)
{
Action action2 = null;
string typeName = complexValue.TypeName;
if (collectionValidator != null)
{
collectionValidator.ValidateCollectionItem(typeName, EdmTypeKind.Complex);
}
this.IncreaseRecursionDepth();
IEdmComplexTypeReference reference = WriterValidationUtils.ResolveTypeNameForWriting(base.Model, metadataTypeReference, ref typeName, EdmTypeKind.Complex, isOpenPropertyType).AsComplexOrNull();
if (((typeName != null) && (collectionValidator != null)) && (string.CompareOrdinal(collectionValidator.ItemTypeNameFromCollection, typeName) == 0))
{
typeName = null;
}
SerializationTypeNameAnnotation annotation = complexValue.GetAnnotation <SerializationTypeNameAnnotation>();
if (annotation != null)
{
typeName = annotation.TypeName;
}
Action beforePropertiesAction = beforeValueAction;
if (typeName != null)
{
if (beforeValueAction != null)
{
if (action2 == null)
{
action2 = delegate {
beforeValueAction();
this.WritePropertyTypeAttribute(typeName);
};
}
beforePropertiesAction = action2;
}
else
{
this.WritePropertyTypeAttribute(typeName);
}
}
if (((base.MessageWriterSettings.WriterBehavior != null) && base.MessageWriterSettings.WriterBehavior.UseV1ProviderBehavior) && !object.ReferenceEquals(projectedProperties, ProjectedPropertiesAnnotation.EmptyProjectedPropertiesMarker))
{
IEdmComplexType definition = (IEdmComplexType)reference.Definition;
if (base.Model.EpmCachedKeepPrimitiveInContent(definition) == null)
{
List <string> keptInContentPropertyNames = null;
foreach (IEdmProperty property in from p in definition.Properties()
where p.Type.IsODataPrimitiveTypeKind()
select p)
{
EntityPropertyMappingAttribute entityPropertyMapping = EpmWriterUtils.GetEntityPropertyMapping(epmSourcePathSegment, property.Name);
if ((entityPropertyMapping != null) && entityPropertyMapping.KeepInContent)
{
if (keptInContentPropertyNames == null)
{
keptInContentPropertyNames = new List <string>();
}
keptInContentPropertyNames.Add(property.Name);
}
}
base.Model.SetAnnotationValue <CachedPrimitiveKeepInContentAnnotation>(definition, new CachedPrimitiveKeepInContentAnnotation(keptInContentPropertyNames));
}
}
bool flag = this.WriteProperties((reference == null) ? null : reference.ComplexDefinition(), EpmValueCache.GetComplexValueProperties(epmValueCache, complexValue, true), isWritingCollection, beforePropertiesAction, afterValueAction, duplicatePropertyNamesChecker, epmValueCache, epmSourcePathSegment, projectedProperties);
this.DecreaseRecursionDepth();
return(flag);
}
private object ReadComplexPropertyValue(EntityPropertyMappingInfo epmInfo, ODataComplexValue complexValue, EpmValueCache epmValueCache, int sourceSegmentIndex, IEdmComplexTypeReference complexType)
{
return(this.ReadPropertyValue(epmInfo, EpmValueCache.GetComplexValueProperties(epmValueCache, complexValue, false), sourceSegmentIndex, complexType, epmValueCache));
}