/// <summary>
/// Returns the items for the specified multivalue.
/// </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 multivalue.</param>
/// <param name="multiValue">The multivalue to get the items for.</param>
/// <param name="writingContent">If we're writing content of an entry or not.</param>
/// <returns>The items enumeration for the multivalue.</returns>
internal static IEnumerable GetMultiValueItems(
EpmValueCache epmValueCache,
EpmSourcePathSegment sourcePathSegment,
ODataMultiValue multiValue,
bool writingContent)
{
DebugUtils.CheckNoExternalCallers();
Debug.Assert(multiValue != null, "multiValue != null");
Debug.Assert(writingContent || epmValueCache != null, "If we're not writing content, then the EPM value cache must exist.");
if (epmValueCache == null)
{
return(multiValue.Items);
}
else
{
return(epmValueCache.GetMultiValueItems(sourcePathSegment, multiValue, writingContent));
}
}
/// <summary>
/// Returns the items for the specified multivalue.
/// </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 multivalue.</param>
/// <param name="multiValue">The multivalue to get the items for.</param>
/// <param name="writingContent">If we're writing content of an entry or not.</param>
/// <returns>The items enumeration for the multivalue.</returns>
internal static IEnumerable GetMultiValueItems(
EpmValueCache epmValueCache,
EpmSourcePathSegment sourcePathSegment,
ODataMultiValue multiValue,
bool writingContent)
{
DebugUtils.CheckNoExternalCallers();
Debug.Assert(multiValue != null, "multiValue != null");
Debug.Assert(writingContent || epmValueCache != null, "If we're not writing content, then the EPM value cache must exist.");
if (epmValueCache == null)
{
return multiValue.Items;
}
else
{
return epmValueCache.GetMultiValueItems(sourcePathSegment, multiValue, writingContent);
}
}
/// <summary>
/// Write the items in a MultiValue in ATOM format.
/// </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="multiValue">The MultiValue to write.</param>
/// <param name="resourcePropertyType">The resource type of the multi value (or null if not metadata is available).</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 multivalue property we're writing. (can be null)</param>
private static void WriteMultiValue(
XmlWriter writer,
DataServiceMetadataProviderWrapper metadata,
ODataMultiValue multiValue,
ResourceType resourcePropertyType,
bool isOpenPropertyType,
bool isWritingCollection,
ODataVersion version,
EpmValueCache epmValueCache,
EpmSourcePathSegment epmSourcePathSegment)
{
Debug.Assert(multiValue != null, "multiValue != null");
string typeName = multiValue.TypeName;
// resolve the type name to the resource type; if no type name is specified we will use the
// type inferred from metadata
MultiValueResourceType multiValueType = (MultiValueResourceType)MetadataUtils.ResolveTypeName(metadata, resourcePropertyType, ref typeName, ResourceTypeKind.MultiValue, isOpenPropertyType);
if (typeName != null)
{
WritePropertyTypeAttribute(writer, typeName);
}
ResourceType expectedItemType = multiValueType == null ? null : multiValueType.ItemType;
IEnumerable items = EpmValueCache.GetMultiValueItems(epmValueCache, epmSourcePathSegment, multiValue, true);
if (items != null)
{
foreach (object itemValue in items)
{
object item;
EpmMultiValueItemCache epmItemCache = itemValue as EpmMultiValueItemCache;
if (epmItemCache != null)
{
item = epmItemCache.ItemValue;
}
else
{
item = itemValue;
}
ValidationUtils.ValidateMultiValueItem(item);
writer.WriteStartElement(AtomConstants.ODataNamespacePrefix, AtomConstants.ODataMultiValueItemElementName, AtomConstants.ODataNamespace);
ODataComplexValue complexValue = item as ODataComplexValue;
if (complexValue != null)
{
WriteComplexValue(writer, metadata, complexValue, expectedItemType, false, isWritingCollection, version, epmItemCache, epmSourcePathSegment);
}
else
{
ODataMultiValue multiValueItem = item as ODataMultiValue;
if (multiValueItem != null)
{
throw new ODataException(Strings.ODataWriter_NestedMultiValuesAreNotSupported);
}
else
{
AtomValueUtils.WritePrimitiveValue(writer, item, expectedItemType);
}
}
writer.WriteEndElement();
}
}
}
