linux-packaging-mono/mcs/class/referencesource/System.Data/System/NewXml/XmlBoundElement.cs

//------------------------------------------------------------------------------
// <copyright file="XmlBoundElement.cs" company="Microsoft">
//     Copyright (c) Microsoft Corporation.  All rights reserved.
// </copyright>                                                                
// <owner current="true" primary="true">Microsoft</owner>
// <owner current="false" primary="false">Microsoft</owner>
//------------------------------------------------------------------------------
#pragma warning disable 618 // ignore obsolete warning about XmlDataDocument
namespace System.Xml {
    using System.Data;
    using System.Diagnostics;

    internal enum ElementState {
        None,
        Defoliated,
        WeakFoliation,
        StrongFoliation,
        Foliating,
        Defoliating,
    }

    internal sealed class XmlBoundElement: XmlElement {
        private DataRow row;
        private ElementState state;

        internal XmlBoundElement( string prefix, string localName, string namespaceURI, XmlDocument doc )
        : base( prefix, localName, namespaceURI, doc ) {
            state = ElementState.None;
        }

        public override XmlAttributeCollection Attributes {
            get {
                AutoFoliate();
                return base.Attributes;
            }
        }

        public override bool HasAttributes {
            get { return Attributes.Count > 0; }
        }

        public override XmlNode FirstChild { 
            get { 
                AutoFoliate();
                return base.FirstChild;
            }
        }

        internal XmlNode SafeFirstChild { get { return base.FirstChild; } }

        public override XmlNode LastChild { 
            get { 
                AutoFoliate();
                return base.LastChild;
            }
        }

        public override XmlNode PreviousSibling { 
            get { 
                XmlNode prev = base.PreviousSibling;
                if ( prev == null ) {
                    XmlBoundElement parent = ParentNode as XmlBoundElement;
                    if ( parent != null ) {
                        parent.AutoFoliate();
                        return base.PreviousSibling;
                    }
                }
                return prev;
            }
        }

        internal XmlNode SafePreviousSibling { get { return base.PreviousSibling; } }

        public override XmlNode NextSibling { 
            get { 
                XmlNode next = base.NextSibling;
                if ( next == null ) {
                    XmlBoundElement parent = ParentNode as XmlBoundElement;
                    if ( parent != null ) {
                        parent.AutoFoliate();
                        return base.NextSibling;
                    }
                }
                return next;
            } 
        }

        internal XmlNode SafeNextSibling { get { return base.NextSibling; } }

        public override bool HasChildNodes { 
            get {
                AutoFoliate();
                return base.HasChildNodes;
            }
        }
        
        public override XmlNode InsertBefore(XmlNode newChild, XmlNode refChild) {
            AutoFoliate();
            return base.InsertBefore( newChild, refChild );
        }

        public override XmlNode InsertAfter(XmlNode newChild, XmlNode refChild) {
            AutoFoliate();
            return base.InsertAfter( newChild, refChild );
        }

        public override XmlNode ReplaceChild(XmlNode newChild, XmlNode oldChild) {
            AutoFoliate();
            return base.ReplaceChild( newChild, oldChild );
        }

        public override XmlNode AppendChild(XmlNode newChild) {
            AutoFoliate();
            return base.AppendChild( newChild );
        }

        internal void RemoveAllChildren() {           
            XmlNode child = FirstChild;
            XmlNode sibling = null;

            while ( child != null ) {
                sibling = child.NextSibling;
                RemoveChild( child );
                child = sibling;
            }
        }
        
        public override string InnerXml {
            get {
                return base.InnerXml;
            }
            set {
                
                RemoveAllChildren();
                
                XmlDataDocument doc = (XmlDataDocument) OwnerDocument;
                
                bool bOrigIgnoreXmlEvents = doc.IgnoreXmlEvents;
                bool bOrigIgnoreDataSetEvents = doc.IgnoreDataSetEvents;
                
                doc.IgnoreXmlEvents = true;
                doc.IgnoreDataSetEvents = true;
                
                base.InnerXml = value;

                doc.SyncTree( this );

                doc.IgnoreDataSetEvents = bOrigIgnoreDataSetEvents;
                doc.IgnoreXmlEvents = bOrigIgnoreXmlEvents;
            }
        }
        
        internal DataRow Row {
            get { return row;}
            set { row = value;}
        }

        internal bool IsFoliated {
            get { 
                while ( state == ElementState.Foliating || state == ElementState.Defoliating )
                    System.Threading.Thread.Sleep(0);
                //has to be sure that we are either foliated or defoliated when ask for IsFoliated.
                return state != ElementState.Defoliated;
            }
        }

        internal ElementState ElementState {
            get { return state;}
            set { state = value;}
        }

        internal void Foliate( ElementState newState ) {
            XmlDataDocument doc = (XmlDataDocument) OwnerDocument;
            if ( doc != null )
                doc.Foliate( this, newState );
        }

        // Foliate the node as a side effect of user calling functions on this node (like NextSibling) OR as a side effect of DataDocNav using nodes to do editing
        private void AutoFoliate() {
            XmlDataDocument doc = (XmlDataDocument) OwnerDocument;
            if ( doc != null )
                doc.Foliate( this, doc.AutoFoliationState );
        }

        public override XmlNode CloneNode(bool deep) {
            XmlDataDocument doc = (XmlDataDocument)(this.OwnerDocument);
            ElementState oldAutoFoliationState = doc.AutoFoliationState;
            doc.AutoFoliationState = ElementState.WeakFoliation;
            XmlElement element;
            try {
                Foliate( ElementState.WeakFoliation );
                element = (XmlElement)(base.CloneNode( deep ));
                // Clone should create a XmlBoundElement node
                Debug.Assert( element is XmlBoundElement );
            }
            finally {
                doc.AutoFoliationState = oldAutoFoliationState;
            }

            return element;
        }

        public override void WriteContentTo( XmlWriter w ) {
            DataPointer dp = new DataPointer( (XmlDataDocument)OwnerDocument, this );
            try {
                dp.AddPointer();
                WriteBoundElementContentTo( dp, w );            
            }
            finally {
                dp.SetNoLongerUse();
            }
        }

        public override void WriteTo( XmlWriter w ) {
            DataPointer dp = new DataPointer( (XmlDataDocument)OwnerDocument, this );            
            try {
                dp.AddPointer();
                WriteRootBoundElementTo( dp, w );
            }
            finally {
                dp.SetNoLongerUse();
            }
        }

        private void WriteRootBoundElementTo(DataPointer dp, XmlWriter w) {            
            Debug.Assert( dp.NodeType == XmlNodeType.Element );
            XmlDataDocument doc = (XmlDataDocument)OwnerDocument;
            w.WriteStartElement( dp.Prefix, dp.LocalName, dp.NamespaceURI );            
            int cAttr = dp.AttributeCount;
            bool bHasXSI = false;
            if ( cAttr > 0 ) {
                for ( int iAttr = 0; iAttr < cAttr; iAttr++ ) {
                    dp.MoveToAttribute( iAttr );
                    if ( dp.Prefix == "xmlns" && dp.LocalName == XmlDataDocument.XSI )
                        bHasXSI = true;
                    WriteTo( dp, w );
                    dp.MoveToOwnerElement();
                }
            }
            
            if ( !bHasXSI && doc.bLoadFromDataSet && doc.bHasXSINIL ) 
                w.WriteAttributeString( "xmlns", "xsi", "http://www.w3.org/2000/xmlns/", Keywords.XSINS );
            
            
            WriteBoundElementContentTo( dp, w );
            
            // Force long end tag when the elem is not empty, even if there are no children.
            if ( dp.IsEmptyElement )
                w.WriteEndElement();
            else
                w.WriteFullEndElement();
        }

        private static void WriteBoundElementTo( DataPointer dp, XmlWriter w ) {
            Debug.Assert( dp.NodeType == XmlNodeType.Element );
            w.WriteStartElement( dp.Prefix, dp.LocalName, dp.NamespaceURI );
            int cAttr = dp.AttributeCount;
            if ( cAttr > 0 ) {
                for ( int iAttr = 0; iAttr < cAttr; iAttr++ ) {
                    dp.MoveToAttribute( iAttr );
                    WriteTo( dp, w );
                    dp.MoveToOwnerElement();
                }
            }
            
            WriteBoundElementContentTo( dp, w );
            
            // Force long end tag when the elem is not empty, even if there are no children.
            if ( dp.IsEmptyElement )
                w.WriteEndElement();
            else
                w.WriteFullEndElement();
        }

        private static void WriteBoundElementContentTo( DataPointer dp, XmlWriter w ) {
            if ( !dp.IsEmptyElement && dp.MoveToFirstChild() ) {
                do {
                    WriteTo( dp, w );
                }
                while ( dp.MoveToNextSibling() );

                dp.MoveToParent();
            }
        }
        
        private static void WriteTo( DataPointer dp, XmlWriter w ) {
            switch ( dp.NodeType ) {
                case XmlNodeType.Attribute:
                    if ( !dp.IsDefault ) {
                        w.WriteStartAttribute( dp.Prefix, dp.LocalName, dp.NamespaceURI );

                        if ( dp.MoveToFirstChild() ) {
                            do {
                                WriteTo( dp, w );
                            }
                            while ( dp.MoveToNextSibling() );

                            dp.MoveToParent();
                        }

                        w.WriteEndAttribute();
                    }
                    break;

                case XmlNodeType.Element:
                    WriteBoundElementTo( dp, w );
                    break;

                case XmlNodeType.Text:
                    w.WriteString(dp.Value);
                    break;

                default:
                    Debug.Assert( ((IXmlDataVirtualNode)dp).IsOnColumn( null ) );
                    if ( dp.GetNode() != null )
                        dp.GetNode().WriteTo( w );
                    break;
            }
        }
        
        public override XmlNodeList GetElementsByTagName(string name) { 
            // Retrieving nodes from the returned nodelist may cause foliation which causes new nodes to be created,
            // so the System.Xml iterator will throw if this happens during iteration. To avoid this, foliate everything
            // before iteration, so iteration will not cause foliation (and as a result of this, creation of new nodes).
            XmlNodeList tempNodeList = base.GetElementsByTagName(name);

            int tempint = tempNodeList.Count; 
            return tempNodeList;
        }
    }
}