/// <summary>
/// Reads a property value starting on a complex value.
/// </summary>
/// <param name="complexValue">The complex value to start with.</param>
/// <param name="complexPropertySegment">The EPM source path segment which points to the <paramref name="complexValue"/>.</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="resourceType">The resource type of the complex value.</param>
/// <param name="metadata">The metadata provider to use.</param>
/// <param name="nullOnParentProperty">true if the value of the property is null because one of its parent properties was null, in this case
/// the return value of the method is always null. false if the value of the property is the actual property value which may or may not be null.</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(
ODataComplexValue complexValue,
EpmSourcePathSegment complexPropertySegment,
EpmValueCache epmValueCache,
int sourceSegmentIndex,
ResourceType resourceType,
DataServiceMetadataProviderWrapper metadata,
out bool nullOnParentProperty)
{
Debug.Assert(this.propertyValuePath != null, "The propertyValuePath should have been initialized by now.");
Debug.Assert(this.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(resourceType != null, "resourceType != null");
if (complexValue == null)
{
nullOnParentProperty = true;
return(null);
}
return(this.ReadPropertyValue(
EpmValueCache.GetComplexValueProperties(epmValueCache, complexPropertySegment, complexValue, false),
sourceSegmentIndex,
resourceType,
metadata,
epmValueCache,
out nullOnParentProperty));
}
/// <summary>
/// Writes out the value of a complex property.
/// </summary>
/// <param name="writer">The <see cref="XmlWriter"/> to write to.</param>
/// <param name="metadata">The metadata provider to use or null if no metadata is available.</param>
/// <param name="complexValue">The complex value to write.</param>
/// <param name="metadataType">The metadata type for the complex value.</param>
/// <param name="isOpenPropertyType">True if the type name belongs to an open property.</param>
/// <param name="isWritingCollection">True if we are writing a collection instead of an entry.</param>
/// <param name="version">The protocol version used for writing.</param>
/// <param name="epmValueCache">Cache of values used in EPM so that we avoid multiple enumerations of properties/items. (can be null)</param>
/// <param name="epmSourcePathSegment">The EPM source path segment which points to the property we're writing. (can be null)</param>
internal static void WriteComplexValue(
XmlWriter writer,
DataServiceMetadataProviderWrapper metadata,
ODataComplexValue complexValue,
ResourceType metadataType,
bool isOpenPropertyType,
bool isWritingCollection,
ODataVersion version,
EpmValueCache epmValueCache,
EpmSourcePathSegment epmSourcePathSegment)
{
DebugUtils.CheckNoExternalCallers();
Debug.Assert(complexValue != null, "complexValue != null");
string typeName = complexValue.TypeName;
// resolve the type name to the resource type; if no type name is specified we will use the
// type inferred from metadata
ResourceType complexValueType = MetadataUtils.ResolveTypeName(metadata, metadataType, ref typeName, ResourceTypeKind.ComplexType, isOpenPropertyType);
if (typeName != null)
{
WritePropertyTypeAttribute(writer, typeName);
}
WriteProperties(
writer,
metadata,
complexValueType,
EpmValueCache.GetComplexValueProperties(epmValueCache, epmSourcePathSegment, complexValue, true),
version,
isWritingCollection,
epmValueCache,
epmSourcePathSegment);
}
/// <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="sourcePathSegment">The source path segment for the property which has this complex value.</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,
EpmSourcePathSegment sourcePathSegment,
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(sourcePathSegment, 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="sourcePathSegment">The source path segment for the property which has this complex value.</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,
EpmSourcePathSegment sourcePathSegment,
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(sourcePathSegment, complexValue, writingContent);
}
}