internal void WritePrimitiveValue(object value, CollectionWithoutExpectedTypeValidator collectionValidator, IEdmTypeReference expectedTypeReference)
{
IEdmPrimitiveTypeReference primitiveTypeReference = EdmLibraryExtensions.GetPrimitiveTypeReference(value.GetType());
if (primitiveTypeReference == null)
{
throw new ODataException(Microsoft.Data.OData.Strings.ValidationUtils_UnsupportedPrimitiveType(value.GetType().FullName));
}
string collectionItemTypeName = primitiveTypeReference.FullName();
if (collectionValidator != null)
{
collectionValidator.ValidateCollectionItem(collectionItemTypeName, EdmTypeKind.Primitive);
if (string.CompareOrdinal(collectionValidator.ItemTypeNameFromCollection, collectionItemTypeName) == 0)
{
collectionItemTypeName = null;
}
}
if (expectedTypeReference != null)
{
ValidationUtils.ValidateIsExpectedPrimitiveType(value, primitiveTypeReference, expectedTypeReference);
}
if ((collectionItemTypeName != null) && (collectionItemTypeName != "Edm.String"))
{
this.WritePropertyTypeAttribute(collectionItemTypeName);
}
AtomValueUtils.WritePrimitiveValue(base.XmlWriter, value);
}
/// <summary>
/// Writes a primitive value.
/// </summary>
/// <param name="writer">The <see cref="XmlWriter"/> to write to.</param>
/// <param name="value">The value to write.</param>
/// <param name="expectedType">The expected resource type of the primitive value.</param>
internal static void WritePrimitiveValue(XmlWriter writer, object value, ResourceType expectedType)
{
DebugUtils.CheckNoExternalCallers();
Debug.Assert(value != null, "value != null");
string typeName;
if (!MetadataUtils.TryGetPrimitiveTypeName(value, out typeName))
{
throw new ODataException(Strings.ODataWriter_UnsupportedPrimitiveType(value.GetType().FullName));
}
if (typeName != EdmConstants.EdmStringTypeName)
{
WritePropertyTypeAttribute(writer, typeName);
}
AtomValueUtils.WritePrimitiveValue(writer, value, expectedType);
}
/// <summary>
/// Writes an enumeration value.
/// </summary>
/// <param name="value">The value to write.</param>
/// <param name="collectionValidator">The collection validator instance.</param>
/// <param name="expectedTypeReference">The expected type of the enumeration value.</param>
/// <param name="typeNameAnnotation">The optional type name annotation provided by the user on the OM for this enumeration value. The annotation value will override whatever type name is being written.</param>
internal void WriteEnumValue(
ODataEnumValue value,
CollectionWithoutExpectedTypeValidator collectionValidator,
IEdmTypeReference expectedTypeReference,
SerializationTypeNameAnnotation typeNameAnnotation)
{
Debug.Assert(value != null, "value != null");
// write type name without validation:
string collectionItemTypeName;
string typeName = this.AtomOutputContext.TypeNameOracle.GetValueTypeNameForWriting(value, expectedTypeReference, typeNameAnnotation, collectionValidator, out collectionItemTypeName);
Debug.Assert(collectionItemTypeName == null, "collectionItemTypeName == null");
if (typeName != null)
{
Debug.Assert(typeName != EdmConstants.EdmStringTypeName, "Enum typeName != EdmConstants.StringTypeName");
this.WritePropertyTypeAttribute(typeName);
}
// write string value without validation:
AtomValueUtils.WritePrimitiveValue(this.XmlWriter, value.Value);
}
/// <summary>
/// Writes a primitive value.
/// </summary>
/// <param name="value">The value to write.</param>
/// <param name="collectionValidator">The collection validator instance.</param>
/// <param name="expectedTypeReference">The expected type of the primitive value.</param>
internal void WritePrimitiveValue(
object value,
CollectionWithoutExpectedTypeValidator collectionValidator,
IEdmTypeReference expectedTypeReference)
{
DebugUtils.CheckNoExternalCallers();
Debug.Assert(value != null, "value != null");
IEdmPrimitiveTypeReference primitiveTypeReference = EdmLibraryExtensions.GetPrimitiveTypeReference(value.GetType());
if (primitiveTypeReference == null)
{
throw new ODataException(o.Strings.ValidationUtils_UnsupportedPrimitiveType(value.GetType().FullName));
}
string typeName = primitiveTypeReference.FullName();
if (collectionValidator != null)
{
collectionValidator.ValidateCollectionItem(typeName, EdmTypeKind.Primitive);
if (string.CompareOrdinal(collectionValidator.ItemTypeNameFromCollection, typeName) == 0)
{
typeName = null;
}
}
if (expectedTypeReference != null)
{
ValidationUtils.ValidateIsExpectedPrimitiveType(value, primitiveTypeReference, expectedTypeReference);
}
if (typeName != null && typeName != Metadata.EdmConstants.EdmStringTypeName)
{
this.WritePropertyTypeAttribute(typeName);
}
AtomValueUtils.WritePrimitiveValue(this.XmlWriter, value);
}
/// <summary>
/// Writes a primitive value.
/// </summary>
/// <param name="value">The value to write.</param>
/// <param name="collectionValidator">The collection validator instance.</param>
/// <param name="expectedTypeReference">The expected type of the primitive value.</param>
/// <param name="typeNameAnnotation">The optional type name annotation provided by the user on the OM for this primitive value. The annotation value will override whatever type name is being written.</param>
internal void WritePrimitiveValue(
object value,
CollectionWithoutExpectedTypeValidator collectionValidator,
IEdmTypeReference expectedTypeReference,
SerializationTypeNameAnnotation typeNameAnnotation)
{
DebugUtils.CheckNoExternalCallers();
Debug.Assert(value != null, "value != null");
IEdmPrimitiveTypeReference primitiveTypeReference = EdmLibraryExtensions.GetPrimitiveTypeReference(value.GetType());
if (primitiveTypeReference == null)
{
throw new ODataException(ODataErrorStrings.ValidationUtils_UnsupportedPrimitiveType(value.GetType().FullName));
}
if (collectionValidator != null)
{
collectionValidator.ValidateCollectionItem(primitiveTypeReference.FullName(), EdmTypeKind.Primitive);
}
if (expectedTypeReference != null)
{
ValidationUtils.ValidateIsExpectedPrimitiveType(value, primitiveTypeReference, expectedTypeReference);
}
string collectionItemTypeName;
string typeName = this.AtomOutputContext.TypeNameOracle.GetValueTypeNameForWriting(value, primitiveTypeReference, typeNameAnnotation, collectionValidator, out collectionItemTypeName);
Debug.Assert(collectionItemTypeName == null, "collectionItemTypeName == null");
if (typeName != null && typeName != EdmConstants.EdmStringTypeName)
{
this.WritePropertyTypeAttribute(typeName);
}
AtomValueUtils.WritePrimitiveValue(this.XmlWriter, value);
}
/// <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();
}
}
}