SortAction.cs source code in C# .NET

                        
Code:
                         / Net / Net / 3.5.50727.3053 / DEVDIV / depot / DevDiv / releases / whidbey / netfxsp / ndp / fx / src / XmlUtils / System / Xml / Xsl / XsltOld / SortAction.cs / 2 / SortAction.cs
                        

                        
                            //------------------------------------------------------------------------------ 
// 
//     Copyright (c) Microsoft Corporation.  All rights reserved.
// 
// [....] 
//-----------------------------------------------------------------------------
 
namespace System.Xml.Xsl.XsltOld { 
    using Res = System.Xml.Utils.Res;
    using System; 
    using System.Diagnostics;
    using System.Globalization;
    using System.Xml;
    using System.Xml.XPath; 

    internal class SortAction : CompiledAction { 
        private int selectKey  = Compiler.InvalidQueryKey; 
        private Avt langAvt;
        private Avt dataTypeAvt; 
        private Avt orderAvt;
        private Avt caseOrderAvt;
        // Compile time precalculated AVTs
        private string        lang; 
        private XmlDataType   dataType  = XmlDataType.Text;
        private XmlSortOrder  order     = XmlSortOrder.Ascending; 
        private XmlCaseOrder  caseOrder = XmlCaseOrder.None; 
        private Sort          sort; //When we not have AVTs at all we can do this. null otherwise.
        private bool      forwardCompatibility; 
        private InputScopeManager  manager;

        private string ParseLang(string value) {
            if(value == null) { // Avt is not constant, or attribute wasn't defined 
                return null;
            } 
            // XmlComplianceUtil.IsValidLanguageID uses the outdated RFC 1766. It would be 
            // better to remove this method completely and not call it here, but that may
            // change exception types for some stylesheets. 
            if (! XmlComplianceUtil.IsValidLanguageID(value.ToCharArray(), 0, value.Length)
                && (value.Length == 0 || CultureInfo.GetCultureInfo(value) == null)
            ) {
                if (this.forwardCompatibility) { 
                    return null;
                } 
                throw XsltException.Create(Res.Xslt_InvalidAttrValue, Keywords.s_Lang, value); 
            }
            return value; 
        }

        private XmlDataType ParseDataType(string value, InputScopeManager manager) {
            if(value == null) { // Avt is not constant, or attribute wasn't defined 
                return XmlDataType.Text;
            } 
            if (value == Keywords.s_Text) { 
                return XmlDataType.Text;
            } 
            if (value == Keywords.s_Number) {
                return XmlDataType.Number;
            }
            String prefix, localname; 
            PrefixQName.ParseQualifiedName(value, out prefix, out localname);
 			manager.ResolveXmlNamespace(prefix); 
            if (prefix.Length == 0 && ! this.forwardCompatibility) { 
                throw XsltException.Create(Res.Xslt_InvalidAttrValue, Keywords.s_DataType, value);
            } 
            return XmlDataType.Text;
        }

        private XmlSortOrder ParseOrder(string value) { 
            if(value == null) { // Avt is not constant, or attribute wasn't defined
                return XmlSortOrder.Ascending; 
            } 
            if (value == Keywords.s_Ascending) {
                return XmlSortOrder.Ascending; 
            }
            if (value == Keywords.s_Descending) {
                return XmlSortOrder.Descending;
            } 
            if (this.forwardCompatibility) {
                return XmlSortOrder.Ascending; 
            } 
            throw XsltException.Create(Res.Xslt_InvalidAttrValue, Keywords.s_Order, value);
        } 

        private XmlCaseOrder ParseCaseOrder(string value) {
            if(value == null) { // Avt is not constant, or attribute wasn't defined
                return XmlCaseOrder.None; 
            }
            if (value == Keywords.s_UpperFirst) { 
                return XmlCaseOrder.UpperFirst; 
            }
            if (value == Keywords.s_LowerFirst) { 
                return XmlCaseOrder.LowerFirst;
            }
            if (this.forwardCompatibility) {
                return XmlCaseOrder.None; 
            }
            throw XsltException.Create(Res.Xslt_InvalidAttrValue, Keywords.s_CaseOrder, value); 
        } 

        internal override void Compile(Compiler compiler) { 
            CompileAttributes(compiler);
            CheckEmpty(compiler);
            if (selectKey == Compiler.InvalidQueryKey) {
                selectKey = compiler.AddQuery("."); 
            }
 
            this.forwardCompatibility = compiler.ForwardCompatibility; 
            this.manager = compiler.CloneScopeManager();
 
            this.lang      = ParseLang(     PrecalculateAvt(ref this.langAvt     ));
            this.dataType  = ParseDataType( PrecalculateAvt(ref this.dataTypeAvt ), manager);
            this.order     = ParseOrder(    PrecalculateAvt(ref this.orderAvt    ));
            this.caseOrder = ParseCaseOrder(PrecalculateAvt(ref this.caseOrderAvt)); 

            if(this.langAvt == null && this.dataTypeAvt == null && this.orderAvt == null && this.caseOrderAvt == null) { 
                this.sort = new Sort(this.selectKey, this.lang, this.dataType, this.order, this.caseOrder); 
            }
        } 

        internal override bool CompileAttribute(Compiler compiler) {
            string name   = compiler.Input.LocalName;
            string value  = compiler.Input.Value; 

            if (Keywords.Equals(name, compiler.Atoms.Select)) { 
                this.selectKey = compiler.AddQuery(value); 
            }
            else if (Keywords.Equals(name, compiler.Atoms.Lang)) { 
                this.langAvt = Avt.CompileAvt(compiler, value);
            }
            else if (Keywords.Equals(name, compiler.Atoms.DataType)) {
                this.dataTypeAvt = Avt.CompileAvt(compiler, value); 
            }
            else if (Keywords.Equals(name, compiler.Atoms.Order)) { 
                this.orderAvt = Avt.CompileAvt(compiler, value); 
            }
            else if (Keywords.Equals(name, compiler.Atoms.CaseOrder)) { 
                this.caseOrderAvt = Avt.CompileAvt(compiler, value);
            }
            else {
                return false; 
            }
            return true; 
        } 

        internal override void Execute(Processor processor, ActionFrame frame) { 
            Debug.Assert(processor != null && frame != null);
            Debug.Assert(frame.State == Initialized);

            processor.AddSort(this.sort != null ? 
                this.sort :
                new Sort( 
                    this.selectKey, 
                    this.langAvt      == null ? this.lang      : ParseLang(     this.langAvt     .Evaluate(processor, frame)),
                    this.dataTypeAvt  == null ? this.dataType  : ParseDataType( this.dataTypeAvt .Evaluate(processor, frame), manager), 
                    this.orderAvt     == null ? this.order     : ParseOrder(    this.orderAvt    .Evaluate(processor, frame)),
                    this.caseOrderAvt == null ? this.caseOrder : ParseCaseOrder(this.caseOrderAvt.Evaluate(processor, frame))
                )
            ); 
            frame.Finished();
        } 
    } 
}

// File provided for Reference Use Only by Microsoft Corporation (c) 2007.
//------------------------------------------------------------------------------ 
// 
//     Copyright (c) Microsoft Corporation.  All rights reserved.
// 
// [....] 
//-----------------------------------------------------------------------------
 
namespace System.Xml.Xsl.XsltOld { 
    using Res = System.Xml.Utils.Res;
    using System; 
    using System.Diagnostics;
    using System.Globalization;
    using System.Xml;
    using System.Xml.XPath; 

    internal class SortAction : CompiledAction { 
        private int selectKey  = Compiler.InvalidQueryKey; 
        private Avt langAvt;
        private Avt dataTypeAvt; 
        private Avt orderAvt;
        private Avt caseOrderAvt;
        // Compile time precalculated AVTs
        private string        lang; 
        private XmlDataType   dataType  = XmlDataType.Text;
        private XmlSortOrder  order     = XmlSortOrder.Ascending; 
        private XmlCaseOrder  caseOrder = XmlCaseOrder.None; 
        private Sort          sort; //When we not have AVTs at all we can do this. null otherwise.
        private bool      forwardCompatibility; 
        private InputScopeManager  manager;

        private string ParseLang(string value) {
            if(value == null) { // Avt is not constant, or attribute wasn't defined 
                return null;
            } 
            // XmlComplianceUtil.IsValidLanguageID uses the outdated RFC 1766. It would be 
            // better to remove this method completely and not call it here, but that may
            // change exception types for some stylesheets. 
            if (! XmlComplianceUtil.IsValidLanguageID(value.ToCharArray(), 0, value.Length)
                && (value.Length == 0 || CultureInfo.GetCultureInfo(value) == null)
            ) {
                if (this.forwardCompatibility) { 
                    return null;
                } 
                throw XsltException.Create(Res.Xslt_InvalidAttrValue, Keywords.s_Lang, value); 
            }
            return value; 
        }

        private XmlDataType ParseDataType(string value, InputScopeManager manager) {
            if(value == null) { // Avt is not constant, or attribute wasn't defined 
                return XmlDataType.Text;
            } 
            if (value == Keywords.s_Text) { 
                return XmlDataType.Text;
            } 
            if (value == Keywords.s_Number) {
                return XmlDataType.Number;
            }
            String prefix, localname; 
            PrefixQName.ParseQualifiedName(value, out prefix, out localname);
 			manager.ResolveXmlNamespace(prefix); 
            if (prefix.Length == 0 && ! this.forwardCompatibility) { 
                throw XsltException.Create(Res.Xslt_InvalidAttrValue, Keywords.s_DataType, value);
            } 
            return XmlDataType.Text;
        }

        private XmlSortOrder ParseOrder(string value) { 
            if(value == null) { // Avt is not constant, or attribute wasn't defined
                return XmlSortOrder.Ascending; 
            } 
            if (value == Keywords.s_Ascending) {
                return XmlSortOrder.Ascending; 
            }
            if (value == Keywords.s_Descending) {
                return XmlSortOrder.Descending;
            } 
            if (this.forwardCompatibility) {
                return XmlSortOrder.Ascending; 
            } 
            throw XsltException.Create(Res.Xslt_InvalidAttrValue, Keywords.s_Order, value);
        } 

        private XmlCaseOrder ParseCaseOrder(string value) {
            if(value == null) { // Avt is not constant, or attribute wasn't defined
                return XmlCaseOrder.None; 
            }
            if (value == Keywords.s_UpperFirst) { 
                return XmlCaseOrder.UpperFirst; 
            }
            if (value == Keywords.s_LowerFirst) { 
                return XmlCaseOrder.LowerFirst;
            }
            if (this.forwardCompatibility) {
                return XmlCaseOrder.None; 
            }
            throw XsltException.Create(Res.Xslt_InvalidAttrValue, Keywords.s_CaseOrder, value); 
        } 

        internal override void Compile(Compiler compiler) { 
            CompileAttributes(compiler);
            CheckEmpty(compiler);
            if (selectKey == Compiler.InvalidQueryKey) {
                selectKey = compiler.AddQuery("."); 
            }
 
            this.forwardCompatibility = compiler.ForwardCompatibility; 
            this.manager = compiler.CloneScopeManager();
 
            this.lang      = ParseLang(     PrecalculateAvt(ref this.langAvt     ));
            this.dataType  = ParseDataType( PrecalculateAvt(ref this.dataTypeAvt ), manager);
            this.order     = ParseOrder(    PrecalculateAvt(ref this.orderAvt    ));
            this.caseOrder = ParseCaseOrder(PrecalculateAvt(ref this.caseOrderAvt)); 

            if(this.langAvt == null && this.dataTypeAvt == null && this.orderAvt == null && this.caseOrderAvt == null) { 
                this.sort = new Sort(this.selectKey, this.lang, this.dataType, this.order, this.caseOrder); 
            }
        } 

        internal override bool CompileAttribute(Compiler compiler) {
            string name   = compiler.Input.LocalName;
            string value  = compiler.Input.Value; 

            if (Keywords.Equals(name, compiler.Atoms.Select)) { 
                this.selectKey = compiler.AddQuery(value); 
            }
            else if (Keywords.Equals(name, compiler.Atoms.Lang)) { 
                this.langAvt = Avt.CompileAvt(compiler, value);
            }
            else if (Keywords.Equals(name, compiler.Atoms.DataType)) {
                this.dataTypeAvt = Avt.CompileAvt(compiler, value); 
            }
            else if (Keywords.Equals(name, compiler.Atoms.Order)) { 
                this.orderAvt = Avt.CompileAvt(compiler, value); 
            }
            else if (Keywords.Equals(name, compiler.Atoms.CaseOrder)) { 
                this.caseOrderAvt = Avt.CompileAvt(compiler, value);
            }
            else {
                return false; 
            }
            return true; 
        } 

        internal override void Execute(Processor processor, ActionFrame frame) { 
            Debug.Assert(processor != null && frame != null);
            Debug.Assert(frame.State == Initialized);

            processor.AddSort(this.sort != null ? 
                this.sort :
                new Sort( 
                    this.selectKey, 
                    this.langAvt      == null ? this.lang      : ParseLang(     this.langAvt     .Evaluate(processor, frame)),
                    this.dataTypeAvt  == null ? this.dataType  : ParseDataType( this.dataTypeAvt .Evaluate(processor, frame), manager), 
                    this.orderAvt     == null ? this.order     : ParseOrder(    this.orderAvt    .Evaluate(processor, frame)),
                    this.caseOrderAvt == null ? this.caseOrder : ParseCaseOrder(this.caseOrderAvt.Evaluate(processor, frame))
                )
            ); 
            frame.Finished();
        } 
    } 
}

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

                        

                        
                        

Link Menu

This book is available now!
Buy at Amazon US or
Buy at Amazon UK

• DiagnosticSection.cs
• AnnouncementSendsAsyncResult.cs
• GeneralTransform2DTo3DTo2D.cs
• COM2IVsPerPropertyBrowsingHandler.cs
• GiveFeedbackEvent.cs
• FormsAuthenticationModule.cs
• CollaborationHelperFunctions.cs
• Schema.cs
• DescriptionAttribute.cs
• StreamGeometry.cs
• PeerTransportListenAddressValidatorAttribute.cs
• RawUIStateInputReport.cs
• BitStack.cs
• Types.cs
• Keyboard.cs
• SmiMetaData.cs
• DesignerFrame.cs
• RequestCachePolicyConverter.cs
• MetadataItemEmitter.cs
• DefaultAuthorizationContext.cs
• Native.cs
• EntityDesignerUtils.cs
• XamlFigureLengthSerializer.cs
• CustomSignedXml.cs
• SmiRecordBuffer.cs
• TypeConverterAttribute.cs
• EntityParameterCollection.cs
• ConfigErrorGlyph.cs
• SynchronizationLockException.cs
• EncodingInfo.cs
• RemoteWebConfigurationHost.cs
• StylusOverProperty.cs
• XmlWhitespace.cs
• QuerySettings.cs
• MemberDomainMap.cs
• sqlstateclientmanager.cs
• PcmConverter.cs
• CanonicalXml.cs
• XPathEmptyIterator.cs
• WebPartConnectionsCloseVerb.cs
• SiteMapNodeItem.cs
• HttpModule.cs
• SystemMulticastIPAddressInformation.cs
• ContextStack.cs
• ObjectSet.cs
• StubHelpers.cs
• StopRoutingHandler.cs
• XamlInt32CollectionSerializer.cs
• CodeSnippetCompileUnit.cs
• FontFamily.cs
• HttpCapabilitiesSectionHandler.cs
• EDesignUtil.cs
• MatrixCamera.cs
• GeometryHitTestParameters.cs
• TreeViewDesigner.cs
• TextServicesLoader.cs
• DeviceContext2.cs
• XmlValidatingReaderImpl.cs
• SortFieldComparer.cs
• Sequence.cs
• _CommandStream.cs
• CodeBinaryOperatorExpression.cs
• SessionStateModule.cs
• Module.cs
• CreateRefExpr.cs
• Model3D.cs
• TextTreeRootNode.cs
• Bezier.cs
• PeerName.cs
• TextServicesContext.cs
• FacetDescriptionElement.cs
• DataGridViewDataErrorEventArgs.cs
• PointUtil.cs
• ManagedCodeMarkers.cs
• PointIndependentAnimationStorage.cs
• BooleanFacetDescriptionElement.cs
• EventLogEntryCollection.cs
• XmlTextEncoder.cs
• MailHeaderInfo.cs
• DelegateBodyWriter.cs
• CssTextWriter.cs
• ScriptControlDescriptor.cs
• TypeTypeConverter.cs
• ZeroOpNode.cs
• StringAnimationBase.cs
• ApplicationInterop.cs
• SyndicationLink.cs
• ApplicationFileCodeDomTreeGenerator.cs
• Number.cs
• UIEndRequest.cs
• ZipIOFileItemStream.cs
• DataGridHyperlinkColumn.cs
• HyperLinkField.cs
• TemplateColumn.cs
• ZipFileInfoCollection.cs
• PrtTicket_Public.cs
• HitTestParameters3D.cs
• XmlSchemaComplexType.cs
• BrowserCapabilitiesFactory.cs
• WindowsListView.cs