/// <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); }