/// <summary>
/// Validates that the observed type kind is the expected type kind.
/// </summary>
/// <param name="actualTypeKind">The actual type kind to compare.</param>
/// <param name="expectedTypeKind">The expected type kind to compare against.</param>
/// <param name="expectStructuredType">This value indicates if the <paramref name="actualTypeKind"/> is expected to be complex or entity.
/// True for complex or entity, false for non-structured type kind, null for indetermination.</param>
/// <param name="typeName">The name of the type to use in the error.</param>
internal static void ValidateTypeKind(EdmTypeKind actualTypeKind, EdmTypeKind expectedTypeKind, bool?expectStructuredType, string typeName)
{
if (expectStructuredType.HasValue && expectStructuredType.Value &&
(expectedTypeKind.IsStructured() || expectedTypeKind == EdmTypeKind.None) &&
actualTypeKind.IsStructured())
{
return;
}
if (expectedTypeKind != actualTypeKind)
{
if (typeName == null)
{
throw new ODataException(Strings.ValidationUtils_IncorrectTypeKindNoTypeName(actualTypeKind.ToString(), expectedTypeKind.ToString()));
}
if (actualTypeKind == EdmTypeKind.TypeDefinition && expectedTypeKind == EdmTypeKind.Primitive ||
actualTypeKind == EdmTypeKind.Primitive && expectedTypeKind == EdmTypeKind.TypeDefinition ||
actualTypeKind == EdmTypeKind.Primitive && expectedTypeKind == EdmTypeKind.None)
{
return;
}
throw new ODataException(Strings.ValidationUtils_IncorrectTypeKind(typeName, expectedTypeKind.ToString(), actualTypeKind.ToString()));
}
}
/// <summary>
/// Validates a type name to ensure that it's not an empty string and resolves it against the provided <paramref name="model"/>.
/// </summary>
/// <param name="model">The model to use.</param>
/// <param name="typeName">The type name to validate.</param>
/// <param name="expectedTypeKind">The expected type kind for the given type name.</param>
/// <param name="expectStructuredType">This value indicates if a structured type is expected to be return.
/// True for structured type, false for non-structured type, null for indetermination.</param>
/// <param name="writerValidator">The writer validator to use for validation.</param>
/// <returns>The type with the given name and kind if a user model was available, otherwise null.</returns>
internal static IEdmType ResolveAndValidateTypeName(IEdmModel model, string typeName, EdmTypeKind expectedTypeKind, bool?expectStructuredType, IWriterValidator writerValidator)
{
Debug.Assert(model != null, "model != null");
Debug.Assert(
!expectStructuredType.HasValue ||
!expectStructuredType.Value && !expectedTypeKind.IsStructured() ||
expectStructuredType.Value && (expectedTypeKind.IsStructured() || expectedTypeKind == EdmTypeKind.None),
"!expectStructuredType.HasValue || !expectStructuredType.Value && !expectedTypeKind.IsStructured() || expectStructuredType.Value && (expectedTypeKind.IsStructured() || expectedTypeKind == EdmTypeKind.None)");
if (typeName == null)
{
// if we have metadata, the type name of a resource must not be null
if (model.IsUserModel())
{
throw new ODataException(Strings.WriterValidationUtils_MissingTypeNameWithMetadata);
}
return(null);
}
if (typeName.Length == 0)
{
throw new ODataException(Strings.ValidationUtils_TypeNameMustNotBeEmpty);
}
if (!model.IsUserModel())
{
return(null);
}
// If we do have metadata, lookup the type and translate it to a type.
IEdmType resolvedType = MetadataUtils.ResolveTypeNameForWrite(model, typeName);
if (resolvedType == null)
{
throw new ODataException(Strings.ValidationUtils_UnrecognizedTypeName(typeName));
}
if (resolvedType.TypeKind != EdmTypeKind.Untyped)
{
writerValidator.ValidateTypeKind(resolvedType.TypeKind, expectedTypeKind, expectStructuredType, resolvedType);
}
return(resolvedType);
}
