ModelFunction.cs source code in C# .NET

                        Code:
                         / 4.0 / 4.0 / untmp / DEVDIV_TFS / Dev10 / Releases / RTMRel / ndp / fx / src / DataEntity / System / Data / EntityModel / SchemaObjectModel / ModelFunction.cs / 1305376 / ModelFunction.cs
                        
                        
                            //---------------------------------------------------------------------- 
// 
//      Copyright (c) Microsoft Corporation.  All rights reserved.
// 
// 
// @owner       [....]
// @backupOwner [....] 
//--------------------------------------------------------------------- 

using System; 
using System.Collections;
using System.Collections.Generic;
using System.Collections.Specialized;
using System.Diagnostics; 
using System.Globalization;
using System.Xml; 
using System.Xml.Schema; 
using System.Data;
using System.IO; 
using System.Data.Metadata.Edm;
using System.Data.Entity;

namespace System.Data.EntityModel.SchemaObjectModel 
{
    ///  
    /// class representing the Schema element in the schema 
    /// 
    internal class ModelFunction : Function 
    {

        protected TypeUsageBuilder _typeUsageBuilder;
 
        #region Public Methods
        ///  
        /// ctor for a schema function 
        /// 
        public ModelFunction(Schema parentElement) 
            :
            base(parentElement)
        {
            _isComposable = true; 
            _typeUsageBuilder = new TypeUsageBuilder(this);
        } 
 
        #endregion
 

        public override SchemaType Type
        {
            get 
            {
                return this._type; 
            } 
        }
 
        internal TypeUsage TypeUsage
        {
            get
            { 
                if (_typeUsageBuilder.TypeUsage == null)
                { 
                    return null; 
                }
                else if (CollectionKind != CollectionKind.None) 
                {
                    return TypeUsage.Create(new CollectionType(_typeUsageBuilder.TypeUsage));
                }
                else 
                {
                    return _typeUsageBuilder.TypeUsage; 
                } 

 
            }
        }

        internal void ValidateAndSetTypeUsage(ScalarType scalar) 
        {
            _typeUsageBuilder.ValidateAndSetTypeUsage(scalar, false); 
        } 

        #region Protected Properties 
        protected override bool HandleElement(XmlReader reader)
        {
            if (base.HandleElement(reader))
            { 
                return true;
            } 
            else if (CanHandleElement(reader, XmlConstants.DefiningExpression)) 
            {
                HandleDefiningExpressionElment(reader); 
                return true;
            }
            else if (CanHandleElement(reader, XmlConstants.Parameter))
            { 
                HandleParameterElement(reader);
                return true; 
            } 

            return false; 
        }


        protected override void HandleReturnTypeAttribute(XmlReader reader) 
        {
            base.HandleReturnTypeAttribute(reader); 
            _isComposable = true; 
        }
 


        protected override bool HandleAttribute(XmlReader reader)
        { 
            if (base.HandleAttribute(reader))
            { 
                return true; 
            }
            else if (_typeUsageBuilder.HandleAttribute(reader)) 
            {
                return true;
            }
 
            return false;
        } 
 
        internal override void ResolveTopLevelNames()
        { 
            if (null != UnresolvedReturnType)
            {
                if (Schema.ResolveTypeName(this, UnresolvedReturnType, out _type))
                { 
                    if (_type is ScalarType)
                    { 
                        _typeUsageBuilder.ValidateAndSetTypeUsage(_type as ScalarType, false); 
                    }
                } 

            }

            foreach (Parameter parameter in this.Parameters) 
            {
                parameter.ResolveTopLevelNames(); 
            } 

            if (ReturnType != null) 
            {
                ReturnType.ResolveTopLevelNames();
            }
        } 
        #endregion
 
 

        private void HandleDefiningExpressionElment(XmlReader reader) 
        {
            Debug.Assert(reader != null);

            FunctionCommandText commandText = new FunctionCommandText(this); 
            commandText.Parse(reader);
            _commandText = commandText; 
        } 

 
        internal override void Validate()
        {
            base.Validate();
 

            if (_type != null && _type is ScalarType == false && _typeUsageBuilder.HasUserDefinedFacets) 
            { 
                //Non-scalar return type should not have Facets
                AddError(ErrorCode.ModelFuncionFacetOnNonScalarType, EdmSchemaErrorSeverity.Error, Strings.FacetsOnNonScalarType(_type.FQName)); 
            }

            if (_type == null && _typeUsageBuilder.HasUserDefinedFacets)
            { 
                //Type attribute not specified but facets exist
                AddError(ErrorCode.ModelFunctionIncorrectlyPlacedFacet, EdmSchemaErrorSeverity.Error, Strings.FacetDeclarationRequiresTypeAttribute); 
            } 

            if (_type == null && _returnType == null) 
            {
                //Return type not declared as either attribute or subelement
                AddError(ErrorCode.ModelFunctionReturnTypeNotDeclared, EdmSchemaErrorSeverity.Error, Strings.ReturnTypeMustBeDeclared(FQName));
            } 

 
            if (_type != null && _isRefType &&  !(_type is SchemaEntityType)) 
            {
                //Ref type refers to non entity type 
                AddError(ErrorCode.ReferenceToNonEntityType, EdmSchemaErrorSeverity.Error, Strings.ReferenceToNonEntityType(_type.FQName));
            }

 
            foreach (var param in _parameters)
            { 
                param.ValidateForModelFunction(); 
            }
 
            if (_returnType != null)
            {
                _returnType.ValidateForModelFunction();
            } 
        }
 
    } 
}

// File provided for Reference Use Only by Microsoft Corporation (c) 2007.
Link Menu

Network programming in C#, Network Programming in VB.NET, Network Programming in .NET
This book is available now!
Buy at Amazon US or
Buy at Amazon UK
ModelFunction.cs source code in C# .NET

Source code for the .NET framework in C#

Code:

Link Menu
