<#@ template language="VB" debug="false" hostspecific="true"#>
<#@ include file="EF.Utility.VB.ttinclude"#><#@
 output extension=".vb"#><#

Const inputFile As String = "..\..\FunctionalTests\TestModels\TemplateModels\Schemas\AdvancedPatterns.edmx"
Dim textTransform As DynamicTextTransformation = DynamicTextTransformation.Create(Me)
Dim code As CodeGenerationTools = New CodeGenerationTools(Me)
Dim ef As MetadataTools = New MetadataTools(Me)
Dim typeMapper As TypeMapper = New TypeMapper(code, ef, textTransform.Errors)
Dim loader As EdmMetadataLoader = New EdmMetadataLoader(textTransform.Host, textTransform.Errors)
Dim itemCollection As IEnumerable(Of GlobalItem) = loader.CreateEdmItemCollection(inputFile)
Dim modelNamespace As String = loader.GetModelNamespace(inputFile)
Dim codeStringGenerator As CodeStringGenerator = New CodeStringGenerator(code, typeMapper, ef)

Dim container As EntityContainer = ItemCollection.OfType(Of EntityContainer)().FirstOrDefault()
If container Is Nothing Then
    Return String.Empty
End If
#>
'------------------------------------------------------------------------------
' <auto-generated>
' <#=GetResourceString("Template_GeneratedCodeCommentLine1")#>
'
' <#=GetResourceString("Template_GeneratedCodeCommentLine2")#>
' <#=GetResourceString("Template_GeneratedCodeCommentLine3")#>
' </auto-generated>
'------------------------------------------------------------------------------

Imports System
Imports System.Data.Entity
Imports System.Data.Entity.Infrastructure
<#
If container.FunctionImports.Any()
#>
Imports System.Data.Entity.Core.Objects
Imports System.Data.Entity.Core.Objects.DataClasses
Imports System.Linq
<#
End If
#>

<#
Dim codeNamespace As String = code.VsNamespaceSuggestion()
If Not String.IsNullOrEmpty(codeNamespace) Then
#>
Namespace <#=code.EscapeNamespace(codeNamespace)#>

<#
    PushIndent("    ")
End If

#>
Partial <#=Accessibility.ForType(container)#> Class <#=code.Escape(container)#>
    Inherits DbContext

    Public Sub New()
        MyBase.New("name=<#=container.Name#>")
<#
If Not loader.IsLazyLoadingEnabled(container) Then
#>
        MyBase.Configuration.LazyLoadingEnabled = False
<#
End If
#>
    End Sub

    Protected Overrides Sub OnModelCreating(modelBuilder As DbModelBuilder)
        Throw New UnintentionalCodeFirstException()
    End Sub

<#
    For Each entitySet As EntitySet In container.BaseEntitySets.OfType(Of EntitySet)()
#>
    <#=codeStringGenerator.DbSet(entitySet)#>
<#
    Next

    For Each edmFunction As EdmFunction In container.FunctionImports
        WriteFunctionImport(typeMapper, codeStringGenerator, edmFunction, modelNamespace, includeMergeOption := False)
    Next
#>

End Class
<#

If Not String.IsNullOrEmpty(codeNamespace) Then
    PopIndent()
#>

End Namespace
<#
End If
#>
<#+
Public Sub WriteFunctionImport(typeMapper As TypeMapper, codeStringGenerator As CodeStringGenerator, edmFunction As EdmFunction, modelNamespace As String, includeMergeOption As Boolean)
    If typeMapper.IsComposable(edmFunction) Then
#>

    <EdmFunction("<#=edmFunction.NamespaceName#>", "<#=edmFunction.Name#>")>
    <#=codeStringGenerator.ComposableFunctionMethod(edmFunction, modelNamespace)#>
<#+
        codeStringGenerator.WriteFunctionParameters(edmFunction, AddressOf WriteFunctionParameter)
#>
         <#=codeStringGenerator.ComposableCreateQuery(edmFunction, modelNamespace)#>
    End Function
<#+
    Else
#>

    <#=codeStringGenerator.FunctionMethod(edmFunction, modelNamespace, includeMergeOption)#>
<#+
        codeStringGenerator.WriteFunctionParameters(edmFunction, AddressOf WriteFunctionParameter)
#>
        <#=codeStringGenerator.ExecuteFunction(edmFunction, modelNamespace, includeMergeOption)#>
    End Function
<#+
        If typeMapper.GenerateMergeOptionFunction(edmFunction, includeMergeOption) Then
            WriteFunctionImport(typeMapper, codeStringGenerator, edmFunction, modelNamespace, includeMergeOption := True)
        End If
    End If
End Sub

Public Sub WriteFunctionParameter(name As String, isNotNull As String, notNullInit As String, nullInit As String)
#>
        Dim <#=name#> As ObjectParameter = If(<#=isNotNull#>, <#=notNullInit#>, <#=nullInit#>)

<#+
End Sub

Public Const TemplateId As String = "VB_DbContext_Context_EF5"

Public Class CodeStringGenerator
    Private ReadOnly _code As CodeGenerationTools
    Private ReadOnly _typeMapper As TypeMapper
    Private ReadOnly _ef As MetadataTools

    Public Sub New(code As CodeGenerationTools, typeMapper As TypeMapper, ef As MetadataTools)
        ArgumentNotNull(code, "code")
        ArgumentNotNull(typeMapper, "typeMapper")
        ArgumentNotNull(ef, "ef")

        _code = code
        _typeMapper = typeMapper
        _ef = ef
    End Sub

    Public Function SimpleProperty(edmProperty As EdmProperty) As String
        Return SimpleOrComplexProperty(edmProperty, _code.StringBefore(" = ", _typeMapper.CreateLiteral(edmProperty.DefaultValue)))
    End Function

    Public Function ComplexProperty(edmProperty As EdmProperty) As String
        Return SimpleOrComplexProperty(edmProperty, " = New " & _typeMapper.GetTypeName(edmProperty.TypeUsage))
    End Function

    Public Function SimpleOrComplexProperty(edmProperty As EdmProperty, defaultValue As String) As String
        Return AnyProperty(
            Accessibility.ForProperty(edmProperty), _
            _typeMapper.GetTypeName(edmProperty.TypeUsage), _
            _code.Escape(edmProperty), _
            _code.SpaceAfter(Accessibility.ForGetter(edmProperty)), _
            _code.SpaceAfter(Accessibility.ForSetter(edmProperty)), _
            defaultValue)
    End Function

    Public Function NavigationProperty(edmProperty As NavigationProperty) As String
        Dim endType = _typeMapper.GetTypeName(edmProperty.ToEndMember.GetEntityType())
        Dim defaultValue = ""
        Dim propertyType = endType

        If(edmProperty.ToEndMember.RelationshipMultiplicity = RelationshipMultiplicity.Many)
            defaultValue = " = New HashSet(Of " & propertyType & ")"
            propertyType = "ICollection(Of " & propertyType & ")"
        End If

        Return AnyProperty(
            PropertyAccessibilityAndVirtual(edmProperty), _
            propertyType, _
            _code.Escape(edmProperty), _
            _code.SpaceAfter(Accessibility.ForGetter(edmProperty)), _
            _code.SpaceAfter(Accessibility.ForSetter(edmProperty)), _
            defaultValue)
    End Function

    Public Function AccessibilityAndVirtual(accessibility As String) As String
        Return accessibility & (If(accessibility <> "Private", " Overridable", ""))
    End Function

    Public Function AnyProperty(accessibility As String, type As String, name As String, getterAccessibility As String, setterAccessibility As String, defaultValue As String)
        If (String.IsNullOrEmpty(getterAccessibility) AndAlso String.IsNullOrEmpty(setterAccessibility))
            Return String.Format( _
                CultureInfo.InvariantCulture, _
                "    {0} Property {1} As {2}{3}", _
                accessibility, _
                name, _
                type, _
                defaultValue)
        Else
            Return String.Format( _
                CultureInfo.InvariantCulture, _
                "{6}    Private _{0} As {1}{2}{6}" & _
                "    {3} Property {0} As {1}{6}" & _
                "        {4}Get{6}" & _
                "            Return _{0}{6}" & _
                "        End Get{6}" & _
                "        {5}Set(ByVal value As {1}){6}" & _
                "            _{0} = value{6}" & _
                "        End Set{6}" & _
                "    End Property",  _
                name, _
                type, _
                defaultValue, _
                accessibility, _
                getterAccessibility, _
                setterAccessibility, _
                Environment.NewLine)
        End If
    End Function

    Public Function PropertyAccessibilityAndVirtual(ByVal member As EdmMember) As String
        Dim propertyAccess As String = Accessibility.ForProperty(member)
        Dim setAccess as String = Accessibility.ForSetter(member)
        Dim getAccess as String = Accessibility.ForGetter(member)
        If propertyAccess <> "Private" AndAlso setAccess <> "Private" AndAlso getAccess <> "Private" Then
            Return propertyAccess & " Overridable"
        End If

        Return propertyAccess
    End Function

    Public Function EntityClassOpening(entity As EntityType) As String
        Return String.Format( _
            CultureInfo.InvariantCulture, _
            "Partial {0} {1}Class {2}{3}", _
            Accessibility.ForType(entity), _
            _code.SpaceAfter(_code.MustInheritOption(entity)), _
            _code.Escape(entity), _
            _code.StringBefore(Environment.NewLine & "         Inherits ", _typeMapper.GetTypeName(entity.BaseType)))
    End Function

    Public Function EnumOpening(enumType As SimpleType) As String
        Return String.Format( _
            CultureInfo.InvariantCulture, _
            "{0} Enum {1} As {2}", _
            Accessibility.ForType(enumType),
            _code.Escape(enumType),
            _code.Escape(_typeMapper.UnderlyingClrType(enumType)))
    End Function

    Public Sub WriteFunctionParameters(edmFunction As EdmFunction, writeParameter As Action(Of String, String, String, String))
        Dim parameters as IEnumerable(Of FunctionImportParameter) = FunctionImportParameter.Create(edmFunction.Parameters, _code, _ef)
        For Each parameter As FunctionImportParameter In parameters.Where(Function(p) p.NeedsLocalVariable)
            Dim isNotNull as String = If(parameter.IsNullableOfT, parameter.FunctionParameterName & ".HasValue", parameter.FunctionParameterName & " IsNot Nothing")
            Dim notNullInit as String = "New ObjectParameter(""" & parameter.EsqlParameterName & """, " & parameter.FunctionParameterName & ")"
            Dim nullInit as String = "New ObjectParameter(""" & parameter.EsqlParameterName & """, GetType(" & parameter.RawClrTypeName & "))"
            writeParameter(parameter.LocalVariableName, isNotNull, notNullInit, nullInit)
        Next
    End Sub

    Public Function ComposableFunctionMethod(edmFunction As EdmFunction, modelNamespace As String) As String
        Dim parameters as IEnumerable(Of FunctionImportParameter) = _typeMapper.GetParameters(edmFunction)

        Return String.Format( _
            CultureInfo.InvariantCulture, _
            "{0} Function {1}({2}) As IQueryable(Of {3})", _
            AccessibilityAndVirtual(Accessibility.ForMethod(edmFunction)), _
            _code.Escape(edmFunction), _
            String.Join(", ", parameters.Select(Function(p) p.FunctionParameterName & " As " & p.FunctionParameterType).ToArray()), _
            _typeMapper.GetTypeName(_typeMapper.GetReturnType(edmFunction), modelNamespace))
    End Function

    Public Function ComposableCreateQuery(edmFunction As EdmFunction, modelNamespace As String) As String
        Dim parameters as IEnumerable(Of FunctionImportParameter) = _typeMapper.GetParameters(edmFunction)

        Return String.Format( _
            CultureInfo.InvariantCulture, _
            "Return DirectCast(Me, IObjectContextAdapter).ObjectContext.CreateQuery(Of {0})(""[{1}].[{2}]({3})""{4})", _
            _typeMapper.GetTypeName(_typeMapper.GetReturnType(edmFunction), modelNamespace), _
            edmFunction.NamespaceName, _
            edmFunction.Name, _
            String.Join(", ", parameters.Select(Function(p) "@" & Convert.ToString(p.EsqlParameterName)).ToArray()), _
            _code.StringBefore(", ", String.Join(", ", parameters.Select(Function(p) p.ExecuteParameterName).ToArray())))
    End Function

    Public Function FunctionMethod(edmFunction As EdmFunction, modelNamespace As String, includeMergeOption As Boolean) As String
        Dim parameters as IEnumerable(Of FunctionImportParameter) = _typeMapper.GetParameters(edmFunction)
        Dim returnType as TypeUsage = _typeMapper.GetReturnType(edmFunction)

        Dim paramList as String = String.Join(", ", parameters.Select(Function(p) p.FunctionParameterName & " As " & p.FunctionParameterType).ToArray())
        If includeMergeOption Then
            paramList = _code.StringAfter(paramList, ", ") & "mergeOption As MergeOption"
        End If

        Return String.Format( _
            CultureInfo.InvariantCulture, _
            "{0} Function {1}({2}) As {3}", _
            AccessibilityAndVirtual(Accessibility.ForMethod(edmFunction)), _
            _code.Escape(edmFunction), _
            paramList, _
            If(returnType Is Nothing, "Integer", "ObjectResult(Of " & _typeMapper.GetTypeName(returnType, modelNamespace) & ")"))
    End Function

    Public Function ExecuteFunction(edmFunction As EdmFunction, modelNamespace As String, includeMergeOption As Boolean) As String
        Dim parameters as IEnumerable(Of FunctionImportParameter) = _typeMapper.GetParameters(edmFunction)
        Dim returnType as TypeUsage = _typeMapper.GetReturnType(edmFunction)

        Dim callParams as String = _code.StringBefore(", ", String.Join(", ", parameters.Select(Function(p) p.ExecuteParameterName).ToArray()))
        If includeMergeOption Then
            callParams = ", mergeOption" & callParams
        End If

        Return String.Format( _
            CultureInfo.InvariantCulture, _
            "Return DirectCast(Me, IObjectContextAdapter).ObjectContext.ExecuteFunction{0}(""{1}""{2})", _
            If(returnType Is Nothing, "", "(Of " & _typeMapper.GetTypeName(returnType, ModelNamespace) & ")"), _
            edmFunction.Name, _
            callParams)
    End Function

    Public Function DbSet(entitySet As EntitySet) As String
        Return String.Format( _
            CultureInfo.InvariantCulture, _
            "{0} Property {1}() As DbSet(Of {2})", _
            Accessibility.ForReadOnlyProperty(entitySet), _
            _code.Escape(entitySet), _
            _typeMapper.GetTypeName(entitySet.ElementType))
    End Function
End Class

Public Class TypeMapper
    Private Const ExternalTypeNameAttributeName As String = "http://schemas.microsoft.com/ado/2006/04/codegeneration:ExternalTypeName"

    Private ReadOnly _errors As System.Collections.IList
    Private ReadOnly _code As CodeGenerationTools
    Private ReadOnly _ef As MetadataTools

    Public Sub New(code As CodeGenerationTools, ef As MetadataTools, errors As System.Collections.IList)
        ArgumentNotNull(code, "code")
        ArgumentNotNull(ef, "ef")
        ArgumentNotNull(errors, "errors")

        _code = code
        _ef = ef
        _errors = errors
    End Sub

    Public Function GetTypeName(typeUsage As TypeUsage) As String
        Return If(typeUsage Is Nothing, Nothing, GetTypeName(typeUsage.EdmType, _ef.IsNullable(typeUsage), modelNamespace := Nothing))
    End Function

    Public Function GetTypeName(edmType As EdmType) As String
        Return GetTypeName(edmType, isNullable := Nothing, modelNamespace := Nothing)
    End Function

    Public Function GetTypeName(typeUsage As TypeUsage, modelNamespace As String) As String
        Return If(typeUsage Is Nothing, Nothing, GetTypeName(typeUsage.EdmType, _ef.IsNullable(typeUsage), modelNamespace))
    End Function

    Public Function GetTypeName(edmType As EdmType, modelNamespace As String) As String
        Return GetTypeName(edmType, isNullable := Nothing, modelNamespace := modelNamespace)
    End Function

    Public Function GetTypeName(edmType As EdmType, isNullable As System.Nullable(Of Boolean), modelNamespace As String) As String
        If edmType Is Nothing Then
            Return Nothing
        End If

        Dim collectionType = TryCast(edmType, CollectionType)
        If collectionType IsNot Nothing Then
            Return String.Format(CultureInfo.InvariantCulture, "ICollection( Of {0})", GetTypeName(collectionType.TypeUsage, modelNamespace))
        End If

        Dim typeName = If(_code.Escape(edmType.MetadataProperties.Where(Function(p) p.Name = ExternalTypeNameAttributeName).Select(Function(p) DirectCast(p.Value, String)).FirstOrDefault()), (If(modelNamespace IsNot Nothing AndAlso edmType.NamespaceName <> modelNamespace, _code.CreateFullName(_code.EscapeNamespace(edmType.NamespaceName), _code.Escape(edmType)), _code.Escape(edmType))))

        If TypeOf edmType Is StructuralType Then
            Return typeName
        End If

        If TypeOf edmType Is SimpleType Then
            Dim clrType = UnderlyingClrType(edmType)
            If Not (IsEnumType(edmType)) Then
                typeName = _code.Escape(clrType)
            End If

            Return If(clrType.IsValueType AndAlso isNullable = True, String.Format(CultureInfo.InvariantCulture, "Nullable(Of {0})", typeName), typeName)
        End If

        Throw New ArgumentException("edmType")
    End Function

    Public Function UnderlyingClrType(edmType As EdmType) As Type
        ArgumentNotNull(edmType, "edmType")

        Dim primitiveType as PrimitiveType = TryCast(edmType, PrimitiveType)
        If primitiveType IsNot Nothing Then
            Return primitiveType.ClrEquivalentType
        End If

        If IsEnumType(edmType) Then
            Return GetEnumUnderlyingType(edmType).ClrEquivalentType
        End If

        Return GetType(Object)
    End Function

    Public Function GetEnumMemberValue(enumMember As MetadataItem) As Object
        ArgumentNotNull(enumMember, "enumMember")

        Dim valueProperty As PropertyInfo = enumMember.GetType().GetProperty("Value")
        Return If(valueProperty Is Nothing, Nothing, valueProperty.GetValue(enumMember, Nothing))
    End Function

    Public Function GetEnumMemberName(enumMember As MetadataItem) As String
        ArgumentNotNull(enumMember, "enumMember")

        Dim nameProperty As PropertyInfo = enumMember.GetType().GetProperty("Name")
        Return If(nameProperty Is Nothing, Nothing, DirectCast(nameProperty.GetValue(enumMember, Nothing), String))
    End Function

    Public Function GetEnumMembers(enumType As EdmType) As System.Collections.IEnumerable
        ArgumentNotNull(enumType, "enumType")

        Dim membersProperty As PropertyInfo = enumType.GetType().GetProperty("Members")
        Return If(membersProperty IsNot Nothing, DirectCast(membersProperty.GetValue(enumType, Nothing), System.Collections.IEnumerable), Enumerable.Empty(Of MetadataItem)())
    End Function

    Public Function EnumIsFlags(enumType As EdmType) As Boolean
        ArgumentNotNull(enumType, "enumType")

        Dim isFlagsProperty As PropertyInfo = enumType.GetType().GetProperty("IsFlags")
        Return isFlagsProperty IsNot Nothing AndAlso CBool(isFlagsProperty.GetValue(enumType, Nothing))
    End Function

    Public Function IsEnumType(edmType As GlobalItem) As Boolean
        ArgumentNotNull(edmType, "edmType")

        Return edmType.GetType().Name = "EnumType"
    End Function

    Public Function GetEnumUnderlyingType(enumType As EdmType) As PrimitiveType
        ArgumentNotNull(enumType, "enumType")

        Return DirectCast(enumType.GetType().GetProperty("UnderlyingType").GetValue(enumType, Nothing), PrimitiveType)
    End Function

    Public Function CreateLiteral(value As Object) As String
        If value Is Nothing OrElse value.GetType() IsNot GetType(TimeSpan) Then
            Return _code.CreateLiteral(value)
        End If

        Return String.Format(CultureInfo.InvariantCulture, "new TimeSpan({0})", DirectCast(value, TimeSpan).Ticks)
    End Function

    Public Function VerifyCaseInsensitiveTypeUniqueness(types As IEnumerable(Of String), sourceFile As String) As Boolean
        ArgumentNotNull(types, "types")
        ArgumentNotNull(sourceFile, "sourceFile")

        Dim hash As HashSet(Of String) = New HashSet(Of String)(StringComparer.InvariantCultureIgnoreCase)
        If types.Any(Function(item) Not hash.Add(item)) Then
            _errors.Add(New CompilerError(sourceFile, -1, -1, "6023", String.Format(CultureInfo.CurrentCulture, GetResourceString("Template_CaseInsensitiveTypeConflict"))))
            Return False
        End If
        Return True
    End Function

    Public Function GetEnumItemsToGenerate(itemCollection As IEnumerable(Of GlobalItem)) As IEnumerable(Of SimpleType)
        Return GetItemsToGenerate(Of SimpleType)(itemCollection).Where(Function(e) IsEnumType(e))
    End Function

    Public Function GetItemsToGenerate(Of T As EdmType)(itemCollection As IEnumerable(Of GlobalItem)) As IEnumerable(Of T)
        Return itemCollection.OfType(Of T)().Where(Function(i) Not i.MetadataProperties.Any(Function(p) p.Name = ExternalTypeNameAttributeName)).OrderBy(Function(i) i.Name)
    End Function

    Public Function GetAllGlobalItems(itemCollection As IEnumerable(Of GlobalItem)) As IEnumerable(Of String)
        Return itemCollection.Where(Function(i) TypeOf i Is EntityType OrElse TypeOf i Is ComplexType OrElse TypeOf i Is EntityContainer OrElse IsEnumType(i)).Select(Function(g) GetGlobalItemName(g))
    End Function

    Public Function GetGlobalItemName(item As GlobalItem) As String
        If TypeOf item Is EdmType Then
            Return DirectCast(item, EdmType).Name
        Else
            Return DirectCast(item, EntityContainer).Name
        End If
    End Function

    Public Function GetSimpleProperties(type As EntityType) As IEnumerable(Of EdmProperty)
        Return type.Properties.Where(Function(p) TypeOf p.TypeUsage.EdmType Is SimpleType AndAlso p.DeclaringType.Equals(type))
    End Function

    Public Function GetSimpleProperties(type As ComplexType) As IEnumerable(Of EdmProperty)
        Return type.Properties.Where(Function(p) TypeOf p.TypeUsage.EdmType Is SimpleType AndAlso p.DeclaringType.Equals(type))
    End Function

    Public Function GetComplexProperties(type As EntityType) As IEnumerable(Of EdmProperty)
        Return type.Properties.Where(Function(p) TypeOf p.TypeUsage.EdmType Is ComplexType AndAlso p.DeclaringType.Equals(type))
    End Function

    Public Function GetComplexProperties(type As ComplexType) As IEnumerable(Of EdmProperty)
        Return type.Properties.Where(Function(p) TypeOf p.TypeUsage.EdmType Is ComplexType AndAlso p.DeclaringType.Equals(type))
    End Function

    Public Function GetPropertiesWithDefaultValues(type As EntityType) As IEnumerable(Of EdmProperty)
        Return type.Properties.Where(Function(p) TypeOf p.TypeUsage.EdmType Is SimpleType AndAlso p.DeclaringType.Equals(type) AndAlso p.DefaultValue IsNot Nothing)
    End Function

    Public Function GetPropertiesWithDefaultValues(type As ComplexType) As IEnumerable(Of EdmProperty)
        Return type.Properties.Where(Function(p) TypeOf p.TypeUsage.EdmType Is SimpleType AndAlso p.DeclaringType.Equals(type) AndAlso p.DefaultValue IsNot Nothing)
    End Function

    Public Function GetNavigationProperties(type As EntityType) As IEnumerable(Of NavigationProperty)
        Return type.NavigationProperties.Where(Function(np) np.DeclaringType.Equals(type))
    End Function

    Public Function GetCollectionNavigationProperties(type As EntityType) As IEnumerable(Of NavigationProperty)
        Return type.NavigationProperties.Where(Function(np) np.DeclaringType.Equals(type) AndAlso np.ToEndMember.RelationshipMultiplicity = RelationshipMultiplicity.Many)
    End Function

    Public Function GetReturnParameter(edmFunction As EdmFunction) As FunctionParameter
        ArgumentNotNull(edmFunction, "edmFunction")

        Dim returnParamsProperty As PropertyInfo = edmFunction.GetType().GetProperty("ReturnParameters")
        Return If(returnParamsProperty Is Nothing, edmFunction.ReturnParameter, DirectCast(returnParamsProperty.GetValue(edmFunction, Nothing), IEnumerable(Of FunctionParameter)).FirstOrDefault())
    End Function

    Public Function IsComposable(edmFunction As EdmFunction) As Boolean
        ArgumentNotNull(edmFunction, "edmFunction")

        Dim isComposableProperty As PropertyInfo = edmFunction.GetType().GetProperty("IsComposableAttribute")
        Return isComposableProperty IsNot Nothing AndAlso CBool(isComposableProperty.GetValue(edmFunction, Nothing))
    End Function

    Public Function GetParameters(edmFunction As EdmFunction) As IEnumerable(Of FunctionImportParameter)
        Return FunctionImportParameter.Create(edmFunction.Parameters, _code, _ef)
    End Function

    Public Function GetReturnType(edmFunction As EdmFunction) As TypeUsage
        Dim returnParam As FunctionParameter = GetReturnParameter(edmFunction)
        Return If(returnParam Is Nothing, Nothing, _ef.GetElementType(returnParam.TypeUsage))
    End Function

    Public Function GenerateMergeOptionFunction(edmFunction As EdmFunction, includeMergeOption As Boolean) As Boolean
        Dim returnType As TypeUsage = GetReturnType(edmFunction)
        Return Not includeMergeOption AndAlso returnType IsNot Nothing AndAlso returnType.EdmType.BuiltInTypeKind = BuiltInTypeKind.EntityType
    End Function
End Class

Public Class EdmMetadataLoader
    Private ReadOnly _host As IDynamicHost
    Private ReadOnly _errors As System.Collections.IList

    Public Sub New(host As IDynamicHost, errors As System.Collections.IList)
        ArgumentNotNull(host, "host")
        ArgumentNotNull(errors, "errors")

        _host = host
        _errors = errors
    End Sub

    Public Function CreateEdmItemCollection(sourcePath As String) As IEnumerable(Of GlobalItem)
        ArgumentNotNull(sourcePath, "sourcePath")

        If Not ValidateInputPath(sourcePath) Then
            Return New EdmItemCollection()
        End If

        Dim schemaElement As XElement = LoadRootElement(_host.ResolvePath(sourcePath))
        If schemaElement IsNot Nothing Then
            Using reader = schemaElement.CreateReader()
                Dim errors As IList(Of EdmSchemaError)
                Dim itemCollection As EdmItemCollection = MetadataItemCollectionFactory.CreateEdmItemCollection(New XmlReader() {reader}, errors)

                ProcessErrors(errors, sourcePath)

                Return itemCollection
            End Using
        End If
        Return New EdmItemCollection()
    End Function

    Public Function GetModelNamespace(sourcePath As String) As String
        ArgumentNotNull(sourcePath, "sourcePath")

        If Not ValidateInputPath(sourcePath) Then
            Return String.Empty
        End If

        Dim model As XElement = LoadRootElement(_host.ResolvePath(sourcePath))
        If model Is Nothing Then
            Return String.Empty
        End If

        Dim attribute As XAttribute = model.Attribute("Namespace")
        Return If(attribute IsNot Nothing, attribute.Value, "")
    End Function

    Private Function ValidateInputPath(sourcePath As String) As Boolean
        If sourcePath = "$" & "edmxInputFile" & "$" Then
            _errors.Add(New CompilerError(If(_host.TemplateFile, sourcePath), 0, 0, String.Empty, GetResourceString("Template_ReplaceVsItemTemplateToken")))
            Return False
        End If

        Return True
    End Function

    Public Function LoadRootElement(sourcePath As String) As XElement
        ArgumentNotNull(sourcePath, "sourcePath")

        Dim root As XElement = XElement.Load(sourcePath, LoadOptions.SetBaseUri Or LoadOptions.SetLineInfo)
        Return If(root.Elements().Where(Function(e) e.Name.LocalName = "Runtime").Elements().Where(Function(e) e.Name.LocalName = "ConceptualModels").Elements().Where(Function(e) e.Name.LocalName = "Schema").FirstOrDefault(), root)
    End Function

    Private Sub ProcessErrors(errors As IEnumerable(Of EdmSchemaError), sourceFilePath As String)
        For Each errorItem As EdmSchemaError In errors
            _errors.Add(New CompilerError(If(errorItem.SchemaLocation, sourceFilePath), errorItem.Line, errorItem.Column, errorItem.ErrorCode.ToString(CultureInfo.InvariantCulture), errorItem.Message) With { _
                .IsWarning = errorItem.Severity = EdmSchemaErrorSeverity.Warning _
            })
        Next
    End Sub

    Public Function IsLazyLoadingEnabled(container As EntityContainer) As Boolean
        Dim lazyLoadingAttributeValue As String
        Dim lazyLoadingAttributeName As String = MetadataConstants.EDM_ANNOTATION_09_02 + ":LazyLoadingEnabled"
        Dim isLazyLoading As Boolean
        Return Not MetadataTools.TryGetStringMetadataPropertySetting(container, lazyLoadingAttributeName, lazyLoadingAttributeValue) OrElse Not Boolean.TryParse(lazyLoadingAttributeValue, isLazyLoading) OrElse isLazyLoading
    End Function
End Class

Public Shared Sub ArgumentNotNull(Of T As Class)(arg As T, name As String)
    If arg Is Nothing Then
        Throw New ArgumentNullException(name)
    End If
End Sub

Private Shared ReadOnly ResourceManager As New Lazy(Of System.Resources.ResourceManager)(Function() New System.Resources.ResourceManager("System.Data.Entity.Design", GetType(MetadataItemCollectionFactory).Assembly), isThreadSafe := True)

Public Shared Function GetResourceString(resourceName As String) As String
    ArgumentNotNull(resourceName, "resourceName")

    Return ResourceManager.Value.GetString(resourceName, Nothing)
End Function

#>