mono/mcs/class/referencesource/System.Data/System/NewXml/XmlDataDocument.cs

//------------------------------------------------------------------------------
// <copyright file="XmlDataDocument.cs" company="Microsoft">
//     Copyright (c) Microsoft Corporation.  All rights reserved.
// </copyright>
// <owner current="true" primary="true">Microsoft</owner>
// <owner current="true" primary="false">Microsoft</owner>
//------------------------------------------------------------------------------
namespace System.Xml {
    using System;
    using System.Collections;
    using System.Collections.Generic;
    using System.ComponentModel;
    using System.Data;
    using System.Diagnostics;
    using System.IO;
    using System.Runtime.Versioning;
    using System.Xml.XPath;

    /// <devdoc>
    ///    <para>
    ///       Represents an entire document. An XmlDataDocument can contain XML
    ///       data or relational data (DataSet).
    ///    </para>
    /// </devdoc>
    [Obsolete("XmlDataDocument class will be removed in a future release.")]
    [System.Security.Permissions.HostProtectionAttribute(Synchronization=true)]
    public class XmlDataDocument: XmlDocument {
        DataSet dataSet;

        DataSetMapper mapper;
        internal Hashtable pointers;         // Hastable w/ all pointer objects used by this XmlDataDocument. Hashtable are guaranteed to work OK w/ one writer and mutiple readers, so as long as we guarantee
                                    // that there is at most one thread in AddPointer we are OK.
        int     countAddPointer;    // Approximate count of how many times AddPointer was called since the last time we removed the unused pointer objects from pointers hashtable.
        ArrayList columnChangeList;
        DataRowState rollbackState;

        bool fBoundToDataSet;       // true if our permanent event listeners are registered to receive DataSet events
        bool fBoundToDocument;      // true if our permanent event listeners are registered to receive XML events. Note that both fBoundToDataSet and fBoundToDataSet should be both true or false.
        bool fDataRowCreatedSpecial;    // true if our special event listener is registered to receive DataRowCreated events. Note that we either have special listeners subsribed or permanent ones (i.e. fDataRowCreatedSpecial and fBoundToDocument/fBoundToDataSet cannot be both true).
        bool ignoreXmlEvents;       // true if XML events should not be processed
        bool ignoreDataSetEvents;   // true if DataSet events should not be processed
        bool isFoliationEnabled;    // true if we should create and reveal the virtual nodes, false if we should reveal only the physical stored nodes
        bool optimizeStorage;       // false if we should only have foilated regions.
        ElementState autoFoliationState;    // When XmlBoundElement will foliate because of memeber functions, this will contain the foliation mode: usually this is
                                    // ElementState.StrongFoliation, however when foliation occurs due to DataDocumentNavigator operations (InsertNode for example),
                                    // it it usually ElementState.WeakFoliation
        bool fAssociateDataRow;     // if true, CreateElement will create and associate data rows w/ the newly created XmlBoundElement.
                                    // If false, then CreateElement will just create the XmlBoundElement nodes. This is usefull for Loading case,
                                    // when CreateElement is called by DOM.
        object foliationLock;
        internal const string XSI_NIL = "xsi:nil";
        internal const string XSI = "xsi";
        private bool bForceExpandEntity = false;
        internal XmlAttribute attrXml = null;
        internal bool bLoadFromDataSet = false;
        internal bool bHasXSINIL = false;

        internal void AddPointer( IXmlDataVirtualNode pointer ) {
            Debug.Assert( pointers.ContainsValue(pointer) == false );
            lock ( pointers ) {
                countAddPointer++;
                if ( countAddPointer >= 5 ) {   // 5 is choosed to be small enough to not affect perf, but high enough so we will not scan all the time
                    ArrayList al = new ArrayList();
                    foreach( DictionaryEntry entry in pointers ) {
                        IXmlDataVirtualNode temp = (IXmlDataVirtualNode)(entry.Value);
                        Debug.Assert( temp != null );
                        if ( ! temp.IsInUse() )
                            al.Add( temp );
                    }
                    for (int i = 0; i < al.Count; i++ ) {
                        pointers.Remove( al[ i ] );
                    }
                    countAddPointer = 0;
                }
                pointers[pointer] = pointer;
            }
        }

        [System.Diagnostics.Conditional("DEBUG")]
        internal void AssertPointerPresent( IXmlDataVirtualNode pointer ) {
#if DEBUG
                object val = pointers[pointer];
                if ( val != ( object ) pointer )
                    Debug.Assert( false );
#endif
        }
        // This function attaches the DataSet to XmlDataDocument
        // We also register a special listener (OnDataRowCreatedSpecial) to DataSet, so we know when we should setup all regular listeners (OnDataRowCreated, OnColumnChanging, etc).
        // We need to do this because of the following scenario:
        //  - XmlDataDocument doc = new XmlDataDocument();
        //  - DataSet ds = doc.DataSet;     // doc.DataSet creates a data-set, however does not sets-up the regular listeners.
        //  - ds.ReadXmlSchema();           // since there are regular listeners in doc that track ds schema changes, doc does not know about the new tables/columns/etc
        //  - ds.ReadXmlData();             // ds is now filled, however doc has no content (since there were no listeners for the new created DataRow's)
        // We can set-up listeners and track each change in schema, but it is more perf-friendly to do it laizily, all at once, when the first DataRow is created
        // (we rely on the fact that DataRowCreated is a DataSet wide event, rather than a DataTable event)
        private void AttachDataSet( DataSet ds ) {
            // You should not have already an associated dataset
            Debug.Assert( dataSet == null );
            Debug.Assert( ds != null );
            if ( ds.FBoundToDocument )
                throw new ArgumentException( Res.GetString(Res.DataDom_MultipleDataSet) );
            ds.FBoundToDocument = true;
            dataSet = ds;
            // Register the special listener to catch the first DataRow event(s)
            BindSpecialListeners();
        }

        // after loading, all detached DataRows are synchronized with the xml tree and inserted to their tables
        // or after setting the innerxml, synchronize the rows and if created new and detached, will be inserted.
        internal void SyncRows( DataRow parentRow, XmlNode node, bool fAddRowsToTable) {
            XmlBoundElement be = node as XmlBoundElement;
            if ( be != null ) {
                DataRow r = be.Row;
                if (r!=null && be.ElementState == ElementState.Defoliated)
                    return; //no need of syncRow

                if ( r != null ) {
                    // get all field values.
                    SynchronizeRowFromRowElement( be );

                    // defoliate if possible
                    be.ElementState = ElementState.WeakFoliation;
                    DefoliateRegion( be );

                    if ( parentRow != null )
                        SetNestedParentRow( r, parentRow );
                    if ( fAddRowsToTable && r.RowState == DataRowState.Detached )
                        r.Table.Rows.Add( r );
                    parentRow = r;
                }
            }

            // Attach all rows from children nodes
            for ( XmlNode child = node.FirstChild; child != null; child = child.NextSibling )
            	SyncRows( parentRow, child, fAddRowsToTable );
        }

        // All detached DataRows are synchronized with the xml tree and inserted to their tables.
        // Synchronize the rows and if created new and detached, will be inserted.
        internal void SyncTree( XmlNode node) {
            XmlBoundElement be = null;
            mapper.GetRegion( node, out be ) ;
            DataRow parentRow = null;
            bool fAddRowsToTable = IsConnected(node) ;

            if ( be != null ) {
                DataRow r = be.Row;
                if (r!=null && be.ElementState == ElementState.Defoliated)
                    return; //no need of syncRow

                if ( r != null ) {
                    // get all field values.
                    SynchronizeRowFromRowElement( be );

                    // defoliation will not be done on the node which is not RowElement, in case of node is externally being used
                    if ( node == be ) {
                         // defoliate if possible
                         be.ElementState = ElementState.WeakFoliation;
                         DefoliateRegion( be );
                    }

                    if ( fAddRowsToTable && r.RowState == DataRowState.Detached )
                        r.Table.Rows.Add( r );

                    parentRow = r;
                }
            }

            // Attach all rows from children nodes
            for ( XmlNode child = node.FirstChild; child != null; child = child.NextSibling )
            	SyncRows( parentRow, child, fAddRowsToTable );
        }

        internal ElementState AutoFoliationState {
            get { return this.autoFoliationState; }
            set { this.autoFoliationState = value; }
        }

        private void BindForLoad() {
            Debug.Assert( ignoreXmlEvents == true );
            ignoreDataSetEvents = true;
            mapper.SetupMapping( this, dataSet );
            if ( dataSet.Tables.Count > 0 ) {
                //at least one table
                LoadDataSetFromTree( );
            }
            BindListeners();
            ignoreDataSetEvents = false;
        }

        private void Bind( bool fLoadFromDataSet ) {
            // If we have a DocumentElement then it is illegal to call this func to load from data-set
            Debug.Assert( DocumentElement == null || ! fLoadFromDataSet );

            ignoreDataSetEvents = true;
            ignoreXmlEvents = true;

            // Do the mapping. This could be a successive mapping in case of this scenario: xd = XmlDataDocument( emptyDataSet ); xd.Load( "file.xml" );
            mapper.SetupMapping(this, dataSet);

            if ( DocumentElement != null ) {
                LoadDataSetFromTree();
                BindListeners();
            }
            else if ( fLoadFromDataSet ) {
                this.bLoadFromDataSet = true;
                LoadTreeFromDataSet( DataSet );
                BindListeners();
            }

            ignoreDataSetEvents = false;
            ignoreXmlEvents = false;
        }

        internal void Bind( DataRow r, XmlBoundElement e ) {
            r.Element = e;
            e.Row = r;
        }

        // Binds special listeners to catch the 1st data-row created. When the 1st DataRow is created, XmlDataDocument will automatically bind all regular listeners.
        private void BindSpecialListeners() {
            Debug.Assert( fDataRowCreatedSpecial == false );
            Debug.Assert( fBoundToDataSet == false && fBoundToDocument == false );
            dataSet.DataRowCreated += new DataRowCreatedEventHandler( this.OnDataRowCreatedSpecial );
            fDataRowCreatedSpecial = true;
        }
        private void UnBindSpecialListeners() {
            Debug.Assert( fDataRowCreatedSpecial == true );
            dataSet.DataRowCreated -= new DataRowCreatedEventHandler( this.OnDataRowCreatedSpecial );
            fDataRowCreatedSpecial = false;
        }

        private void BindListeners() {
            BindToDocument();
            BindToDataSet();
        }

        private void BindToDataSet() {
            // We could be already bound to DataSet in this scenario:
            //     xd = new XmlDataDocument( dataSetThatHasNoData ); xd.Load( "foo.xml" );
            // so we must not rebound again to it.
            if ( fBoundToDataSet ) {
                Debug.Assert( dataSet != null );
                return;
            }

            // Unregister the DataRowCreatedSpecial notification
            if ( fDataRowCreatedSpecial )
                UnBindSpecialListeners();

            dataSet.Tables.CollectionChanging += new CollectionChangeEventHandler( this.OnDataSetTablesChanging );
            dataSet.Relations.CollectionChanging += new CollectionChangeEventHandler( this.OnDataSetRelationsChanging );
            dataSet.DataRowCreated += new DataRowCreatedEventHandler( this.OnDataRowCreated );
            dataSet.PropertyChanging += new PropertyChangedEventHandler( this.OnDataSetPropertyChanging );

            //this is the hack for this release, should change it in the future
            dataSet.ClearFunctionCalled += new DataSetClearEventhandler( this.OnClearCalled );

            if ( dataSet.Tables.Count > 0 ) {
                foreach( DataTable t in dataSet.Tables ) {
                    BindToTable( t );
                }
            }

            foreach ( DataRelation rel in dataSet.Relations ) {
                rel.PropertyChanging += new PropertyChangedEventHandler( this.OnRelationPropertyChanging );
            }
            fBoundToDataSet = true;
        }

        private void BindToDocument() {
            if ( !fBoundToDocument ) {
                NodeInserting +=  new XmlNodeChangedEventHandler( this.OnNodeInserting ) ;
                NodeInserted +=  new XmlNodeChangedEventHandler( this.OnNodeInserted ) ;
                NodeRemoving +=  new XmlNodeChangedEventHandler( this.OnNodeRemoving ) ;
                NodeRemoved +=  new XmlNodeChangedEventHandler( this.OnNodeRemoved ) ;
                NodeChanging +=  new XmlNodeChangedEventHandler( this.OnNodeChanging ) ;
                NodeChanged +=  new XmlNodeChangedEventHandler( this.OnNodeChanged ) ;
                fBoundToDocument = true;
            }
        }

        private void BindToTable( DataTable t ) {
//            t.ColumnChanging  += new DataColumnChangeEventHandler( this.OnColumnChanging );
            t.ColumnChanged   += new DataColumnChangeEventHandler( this.OnColumnChanged );
            t.RowChanging     += new DataRowChangeEventHandler( this.OnRowChanging );
            t.RowChanged      += new DataRowChangeEventHandler( this.OnRowChanged );
            t.RowDeleting     += new DataRowChangeEventHandler( this.OnRowChanging);
            t.RowDeleted      += new DataRowChangeEventHandler( this.OnRowChanged );
            t.PropertyChanging += new PropertyChangedEventHandler( this.OnTablePropertyChanging );
            t.Columns.CollectionChanging += new CollectionChangeEventHandler( this.OnTableColumnsChanging );

            foreach( DataColumn col in t.Columns ) {
                // Hook column properties changes, so we can react properly to ROM changes.
                col.PropertyChanging += new PropertyChangedEventHandler( this.OnColumnPropertyChanging );
            }
        }

        /// <devdoc>
        ///    <para>
        ///       Creates an element with the specified Prefix, LocalName, and
        ///       NamespaceURI.
        ///    </para>
        /// </devdoc>
        public override XmlElement CreateElement( string prefix, string localName, string namespaceURI) {
            //

            // There are three states for the document:
            //  - special listeners ON, no permananent listeners: this is when the data doc was created w/o any dataset, and the 1st time a new row/element
            //    is created we should subscribe the permenent listeners.
            //  - special listeners OFF, permanent listeners ON: this is when the data doc is loaded (from dataset or XML file) and synchronization takes place.
            //  - special listeners OFF, permanent listeners OFF: this is then the data doc is LOADING (from dataset or XML file) - the synchronization is done by code,
            //    not based on listening to events.
#if DEBUG
            // Cannot have both special and permananent listeners ON
            if ( fDataRowCreatedSpecial )
                Debug.Assert( (fBoundToDataSet == false) && (fBoundToDocument == false) );
            // fBoundToDataSet and fBoundToDocument should have the same value
            Debug.Assert( fBoundToDataSet ? fBoundToDocument : (! fBoundToDocument) );
#endif
            if ( prefix == null )
                prefix = String.Empty;
            if ( namespaceURI == null )
                namespaceURI = String.Empty;

            if ( ! fAssociateDataRow ) {
                // Loading state: create just the XmlBoundElement: the LoadTreeFromDataSet/LoadDataSetFromTree will take care of synchronization
                return new XmlBoundElement( prefix, localName, namespaceURI, this );
            }

            // This is the 1st time an element is beeing created on an empty XmlDataDocument - unbind special listeners, bind permanent ones and then go on w/
            // creation of this element
            EnsurePopulatedMode();
            Debug.Assert( fDataRowCreatedSpecial == false );

            // Loaded state: create a DataRow, this in turn will create and associate the XmlBoundElement, which we will return.
            DataTable dt = mapper.SearchMatchingTableSchema( localName, namespaceURI );
            if ( dt != null ) {
                DataRow row = dt.CreateEmptyRow();
                // We need to make sure all fields are DBNull
                foreach( DataColumn col in dt.Columns ) {
                    if ( col.ColumnMapping != MappingType.Hidden )
                        SetRowValueToNull( row, col );
                }
                XmlBoundElement be = row.Element;
                Debug.Assert( be != null );
                be.Prefix = prefix;
                return be;
            }
            // No matching table schema for this element: just create the element
            return new XmlBoundElement( prefix, localName, namespaceURI, this );
        }

        /// <devdoc>
        ///    <para>[To be supplied.]</para>
        /// </devdoc>
        public override XmlEntityReference CreateEntityReference(String name) {
            throw new NotSupportedException( Res.GetString(Res.DataDom_NotSupport_EntRef ) );
        }

        /// <devdoc>
        ///    <para>Gets a DataSet that provides a relational representation of the data in this
        ///       XmlDataDocument.</para>
        /// </devdoc>
        public DataSet DataSet {
            get {
                return dataSet;
            }
        }

        private void DefoliateRegion( XmlBoundElement rowElem ) {
            // You must pass a row element (which s/b associated w/ a DataRow)
            Debug.Assert( rowElem.Row != null );

            if ( !optimizeStorage )
                return;

            if ( rowElem.ElementState != ElementState.WeakFoliation )
                return;

            if ( !mapper.IsRegionRadical( rowElem ) ) {
                //Console.WriteLine("Region is not radical: "+rowElem.GetHashCode());
                return;
            }

            //Console.WriteLine("Defoliating Region: " + rowElem.GetHashCode());

            bool saveIgnore = IgnoreXmlEvents;
            IgnoreXmlEvents = true;

            rowElem.ElementState = ElementState.Defoliating;

            try {
                // drop all attributes
                rowElem.RemoveAllAttributes();

                XmlNode node = rowElem.FirstChild;
                while ( node != null ) {
                    XmlNode next = node.NextSibling;

                    XmlBoundElement be = node as XmlBoundElement;
                    if ( be != null && be.Row != null )
                        break;

                    // The node must be mapped to a column (since the region is radically structured)
                    Debug.Assert( mapper.GetColumnSchemaForNode( rowElem, node ) != null );
                    rowElem.RemoveChild( node );

                    node = next;
                }
#if DEBUG
                // All subsequent siblings must be sub-regions
                for ( ; node != null; node = node.NextSibling ) {
                    Debug.Assert( (node is XmlBoundElement) && (((XmlBoundElement)node).Row != null) );
                }
#endif

                rowElem.ElementState = ElementState.Defoliated;
            }
            finally {
                IgnoreXmlEvents = saveIgnore;
            }
        }

        private XmlElement EnsureDocumentElement() {
            XmlElement docelem = DocumentElement;
            if ( docelem == null ) {
                string docElemName = XmlConvert.EncodeLocalName( this.DataSet.DataSetName );
                if ( docElemName == null || docElemName.Length == 0 )
                    docElemName = "Xml";
                string ns = this.DataSet.Namespace;
                if ( ns == null )
                    ns = String.Empty;
                docelem = new XmlBoundElement( string.Empty, docElemName, ns, this );
                AppendChild( docelem );
            }

            return docelem;
        }
        private XmlElement EnsureNonRowDocumentElement() {
            XmlElement docElem = this.DocumentElement;
            if ( docElem == null )
                return EnsureDocumentElement();

            DataRow rowDocElem = GetRowFromElement( docElem );
            if ( rowDocElem == null )
                return docElem;

            return DemoteDocumentElement();
        }
        private XmlElement DemoteDocumentElement() {
            // Changes of Xml here should not affect ROM
            Debug.Assert( this.ignoreXmlEvents == true );
            // There should be no reason to call this function if docElem is not a rowElem
            Debug.Assert( this.GetRowFromElement( this.DocumentElement ) != null );

            // Remove the DocumentElement and create a new one
            XmlElement oldDocElem = this.DocumentElement;
            RemoveChild( oldDocElem );
            XmlElement docElem = EnsureDocumentElement();
            docElem.AppendChild( oldDocElem );
            // We should have only one child now
            Debug.Assert( docElem.LastChild == docElem.FirstChild );
            return docElem;
        }
        // This function ensures that the special listeners are un-subscribed, the permanent listeners are subscribed and
        // CreateElement will attach DataRows to newly created XmlBoundElement.
        // It should be called when we have special listeners hooked and we need to change from the special-listeners mode to the
        // populated/permanenet mode where all listeners are corectly hooked up and the mapper is correctly set-up.
        private void EnsurePopulatedMode() {
            // Unbind special listeners, bind permanent ones, setup the mapping, etc
#if DEBUG
            bool fDataRowCreatedSpecialOld = fDataRowCreatedSpecial;
            bool fAssociateDataRowOld = fAssociateDataRow;
#endif
            if ( fDataRowCreatedSpecial ) {
                UnBindSpecialListeners();
                // If a special listener was ON, we should not have had an already set-up mapper or permanent listeners subscribed
                Debug.Assert( ! mapper.IsMapped() );
                Debug.Assert( ! fBoundToDocument );
                Debug.Assert( ! fBoundToDataSet );

                mapper.SetupMapping( this, dataSet);
                BindListeners();

                // CreateElement should now create associate DataRows w/ new XmlBoundElement nodes
                // We should do this ONLY if we switch from special listeners to permanent listeners. The reason is
                // that DataDocumentNavigator wants to put XmlDataDocument in a batch mode, where CreateElement will just
                // create a XmlBoundElement (see DataDocumentNavigator.CloneTree)
                fAssociateDataRow = true;
            }

            Debug.Assert( fDataRowCreatedSpecial == false );
            Debug.Assert( mapper.IsMapped() );
            Debug.Assert( fBoundToDataSet && fBoundToDocument );
#if DEBUG
            // In case we EnsurePopulatedMode was called on an already populated mode, we should NOT change fAssociateDataRow
            if ( fDataRowCreatedSpecialOld == false )
                Debug.Assert( fAssociateDataRowOld == fAssociateDataRow );
#endif
        }

        // Move regions that are marked in ROM as nested children of row/rowElement as last children in XML fragment
        private void FixNestedChildren(DataRow row, XmlElement rowElement) {
            foreach( DataRelation dr in GetNestedChildRelations(row) ) {
                foreach( DataRow r in row.GetChildRows(dr) ) {
                    XmlElement childElem = r.Element;
                    // childElem can be null when we create XML from DataSet (XmlDataDocument( DataSet ) is called) and we insert rowElem of the parentRow before
                    // we insert the rowElem of children rows.
                    if ( childElem != null ) {
#if DEBUG
                        bool fIsChildConnected = IsConnected( childElem );
#endif
                        if ( childElem.ParentNode != rowElement ) {
                            childElem.ParentNode.RemoveChild( childElem );
                            rowElement.AppendChild( childElem );
                        }
#if DEBUG
                        // We should not have changed the connected/disconnected state of the node (since the row state did not change)
                        Debug.Assert( fIsChildConnected == IsConnected( childElem ) );
                        Debug.Assert( IsRowLive( r ) ? IsConnected( childElem ) : ! IsConnected( childElem ) );
#endif
                    }
                }
            }
        }

        // This function accepts node params that are not row-elements. In this case, calling this function is a no-op
        internal void Foliate( XmlBoundElement node, ElementState newState ) {

            Debug.Assert( newState == ElementState.WeakFoliation || newState == ElementState.StrongFoliation );
#if DEBUG
            // If we want to strong foliate one of the non-row-elem in a region, then the region MUST be strong-foliated (or there must be no region)
            // Do this only when we are not loading
            if ( IsFoliationEnabled ) {
                if( newState == ElementState.StrongFoliation && node.Row == null ) {
                    XmlBoundElement rowElem;
                    ElementState rowElemState = ElementState.None;
                    if ( mapper.GetRegion( node, out rowElem ) ) {
                        rowElemState = rowElem.ElementState;
                        Debug.Assert( rowElemState == ElementState.StrongFoliation || rowElemState == ElementState.WeakFoliation );
                    }
                    // Add a no-op, so we can still debug in the assert fails

#pragma warning disable 1717 // assignment to self
                    rowElemState = rowElemState;
#pragma warning restore 1717
                }
            }
#endif

            if ( IsFoliationEnabled ) {
                if ( node.ElementState == ElementState.Defoliated ) {
                    ForceFoliation( node, newState );
                }
                else if ( node.ElementState == ElementState.WeakFoliation && newState == ElementState.StrongFoliation ) {
                    // Node must be a row-elem
                    Debug.Assert( node.Row != null );
                    node.ElementState = newState;
                }
            }
        }

        private void Foliate( XmlElement element ) {
            if ( element is XmlBoundElement )
                ((XmlBoundElement)element).Foliate( ElementState.WeakFoliation );
        }

        // Foliate rowElement region if there are DataPointers that points into it
        private void FoliateIfDataPointers( DataRow row, XmlElement rowElement ) {
            if ( !IsFoliated( rowElement) && HasPointers( rowElement ) ) {
                bool wasFoliationEnabled = IsFoliationEnabled;
                IsFoliationEnabled = true;
                try {
                    Foliate( rowElement );
                }
                finally {
                    IsFoliationEnabled = wasFoliationEnabled;
                }
            }
        }

        private void EnsureFoliation( XmlBoundElement rowElem, ElementState foliation ) {
            if ( rowElem.IsFoliated ) //perf reason, avoid unecessary lock.
                return;
            ForceFoliation( rowElem, foliation);
        }

        private void ForceFoliation( XmlBoundElement node, ElementState newState ) {
            lock ( this.foliationLock ) {
                if ( node.ElementState != ElementState.Defoliated )
                    // The region was foliated by an other thread while this thread was locked
                    return;

                // Node must be a row-elem associated w/ a non-deleted row
                Debug.Assert( node.Row != null );
                Debug.Assert( node.Row.RowState != DataRowState.Deleted );

                node.ElementState = ElementState.Foliating;

                bool saveIgnore = IgnoreXmlEvents;
                IgnoreXmlEvents = true;

                try {
                    XmlNode priorNode = null;
                    DataRow row = node.Row;

                    // create new attrs & elements for row
                    // For detached rows: we are in sync w/ temp values
                    // For non-detached rows: we are in sync w/ the current values
                    // For deleted rows: we never sync
                    DataRowVersion rowVersion = ( row.RowState == DataRowState.Detached ) ? DataRowVersion.Proposed : DataRowVersion.Current;
                    foreach( DataColumn col in row.Table.Columns ) {
                        if ( !IsNotMapped(col) ) {
                            object value = row[col, rowVersion];

                            if ( ! Convert.IsDBNull( value ) ) {
                                if ( col.ColumnMapping == MappingType.Attribute ) {
                                    node.SetAttribute( col.EncodedColumnName, col.Namespace, col.ConvertObjectToXml( value ) );
                                }
                                else {
                                    XmlNode newNode = null;
                                    if ( col.ColumnMapping == MappingType.Element ) {
                                        newNode = new XmlBoundElement( string.Empty, col.EncodedColumnName, col.Namespace, this );
                                        newNode.AppendChild( CreateTextNode( col.ConvertObjectToXml( value ) ) );
                                        if ( priorNode != null ) {
                                            node.InsertAfter(newNode, priorNode);
                                        }
                                        else if ( node.FirstChild != null ) {
                                            node.InsertBefore( newNode, node.FirstChild );
                                        }
                                        else {
                                            node.AppendChild( newNode );
                                        }
                                        priorNode = newNode;
                                    }
                                    else {
                                        Debug.Assert( col.ColumnMapping == MappingType.SimpleContent );
                                        newNode = CreateTextNode( col.ConvertObjectToXml( value ) );
                                        if ( node.FirstChild != null )
                                            node.InsertBefore( newNode, node.FirstChild );
                                        else
                                            node.AppendChild( newNode );
                                        if ( priorNode == null )
                                            priorNode = newNode;
                                    }
                                }
                            }
                            else {
                                if ( col.ColumnMapping == MappingType.SimpleContent ) {
                                    XmlAttribute attr = CreateAttribute( XSI, Keywords.XSI_NIL, Keywords.XSINS );
                                    attr.Value = Keywords.TRUE;
                                    node.SetAttributeNode( attr );
                                    this.bHasXSINIL = true;
                                }
                            }
                        }
                    }
                }
                finally {
                    IgnoreXmlEvents = saveIgnore;
                    node.ElementState = newState;
                }
                // update all live pointers
                OnFoliated( node );
            }
        }

        //Determine best radical insert position for inserting column elements
        private XmlNode GetColumnInsertAfterLocation( DataRow row, DataColumn col, XmlBoundElement rowElement ) {
            XmlNode prev = null;
            XmlNode node = null;

            // text only columns appear first
            if ( IsTextOnly( col ) )
                return null;

            // insert location must be after free text
            for ( node = rowElement.FirstChild; node != null; prev = node, node = node.NextSibling ) {
                if ( !IsTextLikeNode( node ) )
                    break;
            }

            for ( ; node != null; prev = node, node = node.NextSibling ) {
                // insert location must be before any non-element nodes
                if ( node.NodeType != XmlNodeType.Element )
                    break;
                XmlElement e = node as XmlElement;

                // insert location must be before any non-mapped elements or separate regions
                if ( mapper.GetRowFromElement( e ) != null )
                    break;

                object schema = mapper.GetColumnSchemaForNode( rowElement, node );
                if ( schema == null || !(schema is DataColumn) )
                    break;

                // insert location must be before any columns logically after this column
                if ( ((DataColumn)schema).Ordinal > col.Ordinal )
                    break;
            }

            return prev;
        }

        private ArrayList GetNestedChildRelations(DataRow row) {
            ArrayList list = new ArrayList();

            foreach( DataRelation r in row.Table.ChildRelations ) {
                if ( r.Nested )
                    list.Add(r);
            }

            return list;
        }

        private DataRow GetNestedParent(DataRow row) {
            DataRelation relation = GetNestedParentRelation(row);
            if ( relation != null )
                return row.GetParentRow(relation);
            return null;
        }

        private static DataRelation GetNestedParentRelation( DataRow row ) {
            DataRelation [] relations = row.Table.NestedParentRelations;
            if (relations.Length == 0)
                return null;
            return relations[0];
        }

        private DataColumn GetTextOnlyColumn( DataRow row ) {
#if DEBUG
            {
                // Make sure there is at most only one text column, and the text column (if present) is the one reported by row.Table.XmlText
                DataColumnCollection columns = row.Table.Columns;
                int cCols = columns.Count;
                int cTextCols = 0;
                for ( int iCol = 0; iCol < cCols; iCol++ ) {
                    DataColumn c = columns[iCol];
                    if ( IsTextOnly( c ) ) {
                        Debug.Assert( c == row.Table.XmlText );
                        ++cTextCols;
                    }
                }
                Debug.Assert( cTextCols == 0 || cTextCols == 1 );
                if ( cTextCols == 0 )
                    Debug.Assert( row.Table.XmlText == null );
            }
#endif
            return row.Table.XmlText;
        }

        /// <devdoc>
        ///    <para>
        ///       <SPAN>Retrieves the
        ///          DataRow associated with the specified XmlElement.</SPAN>
        ///       </para>
        ///    </devdoc>
        public DataRow GetRowFromElement( XmlElement e ) {
            return mapper.GetRowFromElement( e );
        }

        private XmlNode GetRowInsertBeforeLocation(DataRow row, XmlElement rowElement, XmlNode parentElement) {
            DataRow refRow = row;
            int i = 0;
            int pos;

            // Find position
            // int pos = row.Table.Rows[row];
            for (i = 0; i < row.Table.Rows.Count; i++)
                if (row == row.Table.Rows[i])
                    break;
            pos = i;

            DataRow parentRow = GetNestedParent(row);
            for (i = pos + 1; i < row.Table.Rows.Count; i++) {
                refRow = row.Table.Rows[i];
                if (GetNestedParent(refRow) == parentRow && GetElementFromRow(refRow).ParentNode == parentElement)
                    break;
            }

            if (i < row.Table.Rows.Count)
                return GetElementFromRow(refRow);
            else
                return(XmlNode) null;
        }


        /// <devdoc>
        ///    <para><SPAN>Retrieves
        ///       the XmlElement associated with the specified DataRow.</SPAN></para>
        /// </devdoc>
        public XmlElement GetElementFromRow( DataRow r ) {
            XmlBoundElement be = r.Element;
            //
            Debug.Assert( be != null );
            return be;
        }

        internal bool HasPointers( XmlNode node ) {
            while ( true ) {
                try {
                    if ( pointers.Count > 0 ) {
                        object pointer = null;
                        foreach( DictionaryEntry entry in pointers ) {
                            pointer = entry.Value;
                            Debug.Assert( pointer != null );
                            if ( ((IXmlDataVirtualNode)pointer).IsOnNode( node ) )
                                return true;
                        }
                    }
                    return false;
                }
                catch (Exception e) {
                    // This can happens only when some threads are creating navigators (thus modifying this.pointers) while other threads are in the foreach loop.
                    // Solution is to re-try HasPointers.
                    // 
                    if (!System.Data.Common.ADP.IsCatchableExceptionType (e)) {
                        throw;
                    }
                }
            }
            //should never get to this point due to while (true) loop
        }

        internal bool IgnoreXmlEvents {
            get { return ignoreXmlEvents;}
            set { ignoreXmlEvents = value;}
        }

        internal bool IgnoreDataSetEvents {
            get { return this.ignoreDataSetEvents; }
            set { this.ignoreDataSetEvents = value; }
        }

        private bool IsFoliated( XmlElement element ) {
            if ( element is XmlBoundElement ) {
                return((XmlBoundElement)element).IsFoliated;
            }

            return true;
        }
        private bool IsFoliated( XmlBoundElement be ) {
            return be.IsFoliated;
        }

        internal bool IsFoliationEnabled {
            get { return isFoliationEnabled; }
            set { isFoliationEnabled = value; }
        }

        // This creates a tree and synchronize ROM w/ the created tree.
        // It requires the populated mode to be on - in case we are not in populated mode, it will make the XmlDataDocument be in populated mode.
        // It takes advantage of the fAssociateDataRow flag for populated mode, which allows creation of XmlBoundElement w/o associating DataRow objects.
        internal XmlNode CloneTree( DataPointer other ) {
            EnsurePopulatedMode();

            bool oldIgnoreDataSetEvents = ignoreDataSetEvents;
            bool oldIgnoreXmlEvents     = ignoreXmlEvents;
            bool oldFoliationEnabled    = IsFoliationEnabled;
            bool oldAssociateDataRow    = fAssociateDataRow;

            // Caller should ensure that the EnforceConstraints == false. See 60486 for more info about why this was changed from DataSet.EnforceConstraints = false to an assert.
            Debug.Assert( DataSet.EnforceConstraints == false );
            XmlNode newNode;

            try {
                ignoreDataSetEvents = true;
                ignoreXmlEvents     = true;
                IsFoliationEnabled  = false;
                fAssociateDataRow   = false;

                // Create the diconnected tree based on the other navigator
                newNode = CloneTreeInternal( other );
                Debug.Assert( newNode != null );

                // Synchronize DataSet from XML
                LoadRows( null, newNode );
                SyncRows( null, newNode, false );
            }
            finally {
                ignoreDataSetEvents = oldIgnoreDataSetEvents;
                ignoreXmlEvents     = oldIgnoreXmlEvents;
                IsFoliationEnabled  = oldFoliationEnabled;
                fAssociateDataRow   = oldAssociateDataRow;
            }
            return newNode;
        }

        private XmlNode CloneTreeInternal( DataPointer other ) {
            Debug.Assert( ignoreDataSetEvents == true );
            Debug.Assert( ignoreXmlEvents == true );
            Debug.Assert( IsFoliationEnabled == false );

            // Create the diconnected tree based on the other navigator
            XmlNode newNode = CloneNode( other );

            DataPointer dp = new DataPointer( other );
            try {
                dp.AddPointer();
                if (newNode.NodeType == XmlNodeType.Element) {
                    int cAttributes = dp.AttributeCount;
                    for ( int i = 0; i < cAttributes; i++ ) {
                        dp.MoveToOwnerElement();
                        if( dp.MoveToAttribute(i) ) {
                            newNode.Attributes.Append( (XmlAttribute)CloneTreeInternal(dp) );
                        }
                    }

                    dp.MoveTo( other );
                }

                // 
                for ( bool fMore = dp.MoveToFirstChild(); fMore; fMore = dp.MoveToNextSibling() )
                    newNode.AppendChild( CloneTreeInternal( dp ) );
            }
            finally {
                dp.SetNoLongerUse();
            }

            return newNode;
        }

        /// <devdoc>
        ///    <para>[To be supplied.]</para>
        /// </devdoc>
        public override XmlNode CloneNode( bool deep ) {
            XmlDataDocument clone = (XmlDataDocument)(base.CloneNode(false));
            clone.Init(this.DataSet.Clone());

            clone.dataSet.EnforceConstraints = this.dataSet.EnforceConstraints;
            Debug.Assert( clone.FirstChild == null );
            if ( deep ) {
                DataPointer dp = new DataPointer( this, this );
                try {
                    dp.AddPointer();
                    for ( bool fMore = dp.MoveToFirstChild(); fMore; fMore = dp.MoveToNextSibling() ) {
                        XmlNode cloneNode;
                        if ( dp.NodeType == XmlNodeType.Element )
                            cloneNode = clone.CloneTree( dp );
                        else
                            cloneNode = clone.CloneNode( dp );
                        clone.AppendChild( cloneNode );
                    }
                }
                finally{
                    dp.SetNoLongerUse();
                }
            }

            return clone;
        }

        private XmlNode CloneNode( DataPointer dp ) {
            switch (dp.NodeType) {
                //for the nodes without value and have no children
                case XmlNodeType.DocumentFragment:
                    return this.CreateDocumentFragment();
                case XmlNodeType.DocumentType:
                    //
                    return this.CreateDocumentType( dp.Name, dp.PublicId, dp.SystemId, dp.InternalSubset );
                case XmlNodeType.XmlDeclaration:
                    return this.CreateXmlDeclaration( dp.Version, dp.Encoding, dp.Standalone );
                //case XmlNodeType.Notation: -- notation should not be able to be accessed by XmlNavigator
                    //return this.CreateNotation(dp.Name, dp.PublicId, dp.SystemId );

                //for the nodes with value but no children
                case XmlNodeType.Text:
                    return this.CreateTextNode( dp.Value );
                case XmlNodeType.CDATA:
                    return this.CreateCDataSection( dp.Value );
                case XmlNodeType.ProcessingInstruction:
                    return this.CreateProcessingInstruction( dp.Name, dp.Value );
                case XmlNodeType.Comment:
                    return this.CreateComment( dp.Value );
                case XmlNodeType.Whitespace:
                    return this.CreateWhitespace( dp.Value );
                case XmlNodeType.SignificantWhitespace:
                    return this.CreateSignificantWhitespace( dp.Value );
                //for the nodes that don't have values, but might have children -- only clone the node and leave the children untouched
                case XmlNodeType.Element:
                    return this.CreateElement(dp.Prefix, dp.LocalName, dp.NamespaceURI);
                case XmlNodeType.Attribute:
                    return this.CreateAttribute(dp.Prefix, dp.LocalName, dp.NamespaceURI);
                case XmlNodeType.EntityReference:
                    return this.CreateEntityReference( dp.Name );
            }
            throw new InvalidOperationException( Res.GetString(Res.DataDom_CloneNode, dp.NodeType.ToString() ) );
        }

        internal static bool IsTextLikeNode( XmlNode n ) {
            switch ( n.NodeType ) {
                case XmlNodeType.Text:
                case XmlNodeType.CDATA:
                case XmlNodeType.Whitespace:
                case XmlNodeType.SignificantWhitespace:
                    return true;

                case XmlNodeType.EntityReference:
                    Debug.Assert( false );
                    return false;

                default:
                    return false;
            }
        }

        internal bool IsNotMapped( DataColumn c ) {
            return DataSetMapper.IsNotMapped( c );
        }

        private bool IsSame( DataColumn c, int recNo1, int recNo2 ) {
            if ( c.Compare( recNo1, recNo2 ) == 0 )
                return true;

            return false;
        }

        internal bool IsTextOnly( DataColumn c ) {
            return c.ColumnMapping == MappingType.SimpleContent;
        }


        /// <devdoc>
        ///    <para>Loads the XML document from the specified file.</para>
        /// </devdoc>
        [ResourceExposure(ResourceScope.Machine)]
        [ResourceConsumption(ResourceScope.Machine)]
        public override void Load(string filename) {
            this.bForceExpandEntity = true;
            base.Load( filename );
            this.bForceExpandEntity = false;
        }

        /// <devdoc>
        ///    <para>Loads the XML document from the specified Stream.</para>
        /// </devdoc>
        public override void Load( Stream inStream ) {
            this.bForceExpandEntity = true;
            base.Load( inStream );
            this.bForceExpandEntity = false;
        }

        /// <devdoc>
        ///    <para>Loads the XML document from the specified TextReader.</para>
        /// </devdoc>
        public override void Load( TextReader txtReader ) {
            this.bForceExpandEntity = true;
            base.Load( txtReader );
            this.bForceExpandEntity = false;
        }

        /// <devdoc>
        ///    <para>Loads the XML document from the specified XmlReader.</para>
        /// </devdoc>
        public override void Load( XmlReader reader ) {
            if ( this.FirstChild != null )
                throw new InvalidOperationException( Res.GetString(Res.DataDom_MultipleLoad ) );

            try {
                ignoreXmlEvents = true;

                // Unhook the DataRowCreatedSpecial listener, since we no longer base on the first created DataRow to do the Bind
                if ( fDataRowCreatedSpecial )
                    UnBindSpecialListeners();

                // We should NOT create DataRow objects when calling XmlDataDocument.CreateElement
                fAssociateDataRow = false;
                // Foliation s/b disabled
                isFoliationEnabled = false;

                //now if we load from file we need to set the ExpandEntity flag to ExpandEntities
                if ( this.bForceExpandEntity ) {
                    Debug.Assert( reader is XmlTextReader );
                    ((XmlTextReader)reader).EntityHandling = EntityHandling.ExpandEntities;
                }
                base.Load( reader );
                BindForLoad();
            }
            finally {
                ignoreXmlEvents = false;
                isFoliationEnabled = true;
                autoFoliationState = ElementState.StrongFoliation;
                fAssociateDataRow = true;
            }
        }

        private void LoadDataSetFromTree() {
            ignoreDataSetEvents = true;
            ignoreXmlEvents = true;
            bool wasFoliationEnabled = IsFoliationEnabled;
            IsFoliationEnabled = false;
            bool saveEnforce = dataSet.EnforceConstraints;
            dataSet.EnforceConstraints = false;

            try {
                Debug.Assert( DocumentElement != null );
                LoadRows( null, DocumentElement );
                SyncRows( null, DocumentElement, true );

                dataSet.EnforceConstraints = saveEnforce;
            }
            finally {
                ignoreDataSetEvents = false;
                ignoreXmlEvents = false;
                IsFoliationEnabled = wasFoliationEnabled;
            }
        }

        private void LoadTreeFromDataSet( DataSet ds ) {
            ignoreDataSetEvents = true;
            ignoreXmlEvents = true;
            bool wasFoliationEnabled = IsFoliationEnabled;
            IsFoliationEnabled = false;
            this.fAssociateDataRow = false;

            DataTable [] orderedTables = OrderTables(ds); // this  is to fix WebData 103397
            // problem is after we add support for Namespace  for DataTable, when infering we do not guarantee that table would be 
            // in the same sequence that they were in XML because of namespace, some would be on different schema, so since they
            // wont be in the same sequence as in XML, we may end up with having a child table, before its parent (which is not doable
            // with XML; and this happend because they are in different namespace)
            // this kind of problems are known and please see comment in "OnNestedParentChange"
            // so to fix it in general, we try to iterate over ordered tables instead of going over all tables in DataTableCollection with their own sequence

            try {
                for(int i = 0; i < orderedTables.Length; i++) {
                    DataTable t = orderedTables[i];
                    foreach( DataRow r in t.Rows ) {
                        Debug.Assert( r.Element == null );
                        XmlBoundElement rowElem = AttachBoundElementToDataRow( r );
                        // 
                        switch ( r.RowState ) {
                        case DataRowState.Added:
                        case DataRowState.Unchanged:
                        case DataRowState.Modified:
                            // 
                            OnAddRow( r );
                            break;
                        case DataRowState.Deleted:
                            // Nothing to do (the row already has an associated element as a fragment
                            break;
                        case DataRowState.Detached:
                            // We should not get rows in this state
                            Debug.Assert( false );
                            break;
                        default:
                            // Unknown row state
                            Debug.Assert( false );
                            break;
                        }
                    }
                }
            }
            finally {
                ignoreDataSetEvents = false;
                ignoreXmlEvents = false;
                IsFoliationEnabled = wasFoliationEnabled;
                this.fAssociateDataRow = true;
            }
        }

        // load all data from tree structre into datarows
        private void LoadRows( XmlBoundElement rowElem, XmlNode node ) {
            Debug.Assert( node != null );

            XmlBoundElement be = node as XmlBoundElement;
            if ( be != null ) {
                DataTable dt = mapper.SearchMatchingTableSchema( rowElem, be );

                if ( dt != null ) {
                    DataRow r = GetRowFromElement( be );
                    Debug.Assert( r == null );
                    // If the rowElement was just created and has an un-initialized
                    if ( be.ElementState == ElementState.None )
                        be.ElementState = ElementState.WeakFoliation;
                    r = dt.CreateEmptyRow();
                    Bind( r, be );

                    // the region rowElem is now be
                    Debug.Assert( be.Row != null );
                    rowElem = be;
                }
            }
            // recurse down for children
            for ( XmlNode child = node.FirstChild; child != null; child = child.NextSibling )
                LoadRows( rowElem, child );
        }

        internal DataSetMapper Mapper {
            get {
                return mapper;
            }
        }

        internal void OnDataRowCreated( object oDataSet, DataRow row ) {
            Debug.Assert( row.RowState == DataRowState.Detached );
            OnNewRow( row );
        }

        internal void OnClearCalled( object oDataSet, DataTable table ) {
            throw new NotSupportedException( Res.GetString(Res.DataDom_NotSupport_Clear ) );
        }

        internal void OnDataRowCreatedSpecial( object oDataSet, DataRow row ) {
            Debug.Assert( row.RowState == DataRowState.Detached );

            // Register the regular events and un-register this one
            Bind(true);
            // Pass the event to the regular listener
            OnNewRow( row );
        }
        // Called when a new DataRow is created
        internal void OnNewRow( DataRow row ) {
            Debug.Assert( row.Element == null );
            // Allow New state also because we are calling this function from
            Debug.Assert( row.RowState == DataRowState.Detached );

            AttachBoundElementToDataRow( row );
        }

        private XmlBoundElement AttachBoundElementToDataRow( DataRow row ) {
            Debug.Assert( row.Element == null );
            DataTable table = row.Table;
            // We shoould NOT call CreateElement here, since CreateElement will create and attach a new DataRow to the element
            XmlBoundElement rowElement = new XmlBoundElement( string.Empty, table.EncodedTableName, table.Namespace, this );
            rowElement.IsEmpty = false;
            Bind( row, rowElement );
            rowElement.ElementState = ElementState.Defoliated;
            return rowElement;
        }

        private bool NeedXSI_NilAttr( DataRow row ) {
            DataTable tb = row.Table;
            Debug.Assert( tb != null ) ;
            if ( tb.xmlText == null )
                return false;
            object value = row[tb.xmlText];
            return ( Convert.IsDBNull( value ) );
        }

        private void OnAddRow( DataRow row ) {
            // Xml operations in this func should not trigger ROM operations
            Debug.Assert( this.ignoreXmlEvents == true );

            XmlBoundElement rowElement = (XmlBoundElement)(GetElementFromRow( row ));
            Debug.Assert( rowElement != null );

            if ( NeedXSI_NilAttr( row ) && !rowElement.IsFoliated )
                //we need to foliate it because we need to add one more attribute xsi:nil = true;
                ForceFoliation( rowElement, AutoFoliationState );

            Debug.Assert( rowElement != null );
            DataRow rowDocElem = GetRowFromElement( this.DocumentElement );
            if ( rowDocElem != null ) {
                DataRow parentRow = GetNestedParent( row );
                if ( parentRow == null )
                    DemoteDocumentElement();
            }
            EnsureDocumentElement().AppendChild( rowElement );

            // Move the children of the row under
            FixNestedChildren( row, rowElement );
            OnNestedParentChange( row, rowElement, null );
        }

        private void OnColumnValueChanged( DataRow row, DataColumn col, XmlBoundElement rowElement ) {
            // 
            if ( IsNotMapped(col) )
                goto lblDoNestedRelationSync;

            object value = row[col];

            if ( col.ColumnMapping == MappingType.SimpleContent && Convert.IsDBNull( value ) && !rowElement.IsFoliated )
                ForceFoliation( rowElement, ElementState.WeakFoliation);
            else {
                // no need to sync if not foliated
                if ( !IsFoliated( rowElement ) ) {
#if DEBUG
                    // If the new value is null, we should be already foliated if there is a DataPointer that points to the column
                    // (see OnRowChanging, case DataRowAction.Change)
                    if ( Convert.IsDBNull( row[col, DataRowVersion.Current] ) ) {
                        try {
                            if ( pointers.Count > 0 ) {
                                object pointer = null;
                                foreach( DictionaryEntry entry in pointers ) {
                                    pointer = entry.Value;
                                    Debug.Assert( (pointer != null) && ! ((IXmlDataVirtualNode)pointer).IsOnColumn( col ) );
                                }
                            }
                        }
                        catch (Exception e) {
                            // 
                            if (!System.Data.Common.ADP.IsCatchableExceptionType (e)) {
                                throw;
                            }
                            // We may get an exception if we are in foreach and a new pointer has been added to this.pointers. When this happens, we will skip this check and ignore the exceptions
                        }
                    }
#endif
                    goto lblDoNestedRelationSync;
                }
            }

            if ( IsTextOnly( col ) ) {
                if ( Convert.IsDBNull( value ) ) {
                    value = String.Empty;
                    //make sure that rowElement has Attribute xsi:nil and its value is true
                    XmlAttribute attr = rowElement.GetAttributeNode(XSI_NIL);
                    if ( attr == null ) {
                        attr = CreateAttribute( XSI, Keywords.XSI_NIL, Keywords.XSINS );
                        attr.Value = Keywords.TRUE;
                        rowElement.SetAttributeNode( attr );
                        this.bHasXSINIL = true;
                    }
                    else
                        attr.Value = Keywords.TRUE;
                }
                else {
                    //make sure that if rowElement has Attribute xsi:nil, its value is false
                    XmlAttribute attr = rowElement.GetAttributeNode(XSI_NIL);
                    if ( attr != null )
                        attr.Value = Keywords.FALSE;
                }
                ReplaceInitialChildText( rowElement, col.ConvertObjectToXml( value ) );
                goto lblDoNestedRelationSync;
            }

            // update the attribute that maps to the column
            bool fFound = false;

            // Find the field node and set it's value
            if (col.ColumnMapping == MappingType.Attribute) {
                foreach( XmlAttribute attr in rowElement.Attributes ) {
                    if ( attr.LocalName == col.EncodedColumnName && attr.NamespaceURI == col.Namespace ) {
                        if ( Convert.IsDBNull( value ) ) {
                            attr.OwnerElement.Attributes.Remove( attr );
                        }
                        else {
                            attr.Value = col.ConvertObjectToXml( value );
                        }
                        fFound = true;
                        break;
                    }
                }

                // create new attribute if we didn't find one.
                if ( !fFound && ! Convert.IsDBNull( value ) ) {
                    rowElement.SetAttribute( col.EncodedColumnName, col.Namespace, col.ConvertObjectToXml( value ) );
                }
            }
            else {
                // update elements that map to the column...
                RegionIterator iter = new RegionIterator( (XmlBoundElement)rowElement );
                bool fMore = iter.Next();
                while ( fMore ) {
                    if ( iter.CurrentNode.NodeType == XmlNodeType.Element ) {
                        XmlElement e = (XmlElement) iter.CurrentNode;
                        Debug.Assert( e != null );
                        //we should skip the subregion
                        XmlBoundElement be = e as XmlBoundElement;
                        if ( be != null && be.Row != null ) {
                            fMore = iter.NextRight(); //skip over the sub-region
                            continue;
                        }
                        if ( e.LocalName == col.EncodedColumnName && e.NamespaceURI == col.Namespace ) {
                            fFound = true;
                            if ( Convert.IsDBNull( value ) ) {
                                PromoteNonValueChildren( e );
                                fMore = iter.NextRight();
                                e.ParentNode.RemoveChild( e );
                                // keep looking for more matching elements
                                continue;
                            }
                            else {
                                ReplaceInitialChildText( e, col.ConvertObjectToXml( value ) );
                                //make sure that if the Element has Attribute xsi:nil, its value is false
                                XmlAttribute attr = e.GetAttributeNode(XSI_NIL);
                                if ( attr != null )
                                    attr.Value = Keywords.FALSE;
                                // no need to look any further.
                                goto lblDoNestedRelationSync;
                            }
                        }
                    }
                    fMore = iter.Next();
                }

                // create new element if we didn't find one.
                if ( !fFound && ! Convert.IsDBNull( value ) ) {
                    XmlElement newElem = new XmlBoundElement( string.Empty, col.EncodedColumnName, col.Namespace, this );
                    newElem.AppendChild( CreateTextNode( col.ConvertObjectToXml( value ) ) );

                    XmlNode elemBefore = GetColumnInsertAfterLocation( row, col, rowElement );
                    if ( elemBefore != null ) {
                        rowElement.InsertAfter( newElem, elemBefore );
                    }
                    else if ( rowElement.FirstChild != null ) {
                        rowElement.InsertBefore( newElem, rowElement.FirstChild );
                    }
                    else {
                        rowElement.AppendChild( newElem );
                    }
                }
            }
lblDoNestedRelationSync:
            // Change the XML to conform to the (potentially) change in parent nested relation
            DataRelation relation = GetNestedParentRelation(row);
            if ( relation != null ) {
                Debug.Assert( relation.ChildTable == row.Table );
                if ( relation.ChildKey.ContainsColumn( col ) )
                    OnNestedParentChange( row, rowElement, col );
            }
        }

        private void OnColumnChanged( object sender, DataColumnChangeEventArgs args ) {
            // You should not be able to make DataRow field changes if the DataRow is deleted
            Debug.Assert( args.Row.RowState != DataRowState.Deleted );

            if ( ignoreDataSetEvents )
                return;

            bool wasIgnoreXmlEvents = ignoreXmlEvents;
            ignoreXmlEvents = true;
            bool wasFoliationEnabled = IsFoliationEnabled;
            IsFoliationEnabled = false;

            try {
                DataRow row     = args.Row;
                DataColumn col  = args.Column;
                object oVal     = args.ProposedValue;

                if ( row.RowState == DataRowState.Detached ) {
                    XmlBoundElement be = row.Element;
                    Debug.Assert( be != null );
                    if ( be.IsFoliated ) {
                        // Need to sync changes from ROM to DOM
                        OnColumnValueChanged( row, col, be );
                    }
                }
            }
            finally {
                IsFoliationEnabled = wasFoliationEnabled;
                ignoreXmlEvents = wasIgnoreXmlEvents;
            }
        }

        private void OnColumnValuesChanged( DataRow row, XmlBoundElement rowElement ) {
            Debug.Assert( row != null );
            Debug.Assert( rowElement != null );

            // If user has cascading relationships, then columnChangeList will contains the changed columns only for the last row beeing cascaded
            // but there will be multiple ROM events
            if ( columnChangeList.Count > 0 ) {
                if ( ((DataColumn)(columnChangeList[0])).Table == row.Table ) {
                    foreach( DataColumn c in columnChangeList )
                        OnColumnValueChanged( row, c, rowElement );
                }
                else {
                    foreach( DataColumn c in row.Table.Columns )
                        OnColumnValueChanged( row, c, rowElement );
                }
            }
            else {
                foreach( DataColumn c in row.Table.Columns )
                    OnColumnValueChanged( row, c, rowElement );
            }
            columnChangeList.Clear();
        }

        private void OnDeleteRow( DataRow row, XmlBoundElement rowElement ) {
            // IgnoreXmlEvents s/b on since we are manipulating the XML tree and we not want this to reflect in ROM view.
            Debug.Assert( this.ignoreXmlEvents == true );
            // Special case when rowElem is document element: we create a new docElem, move the current one as a child of
            // the new created docElem, then process as if the docElem is not a rowElem
            if ( rowElement == this.DocumentElement )
                DemoteDocumentElement();

            PromoteInnerRegions( rowElement );
            rowElement.ParentNode.RemoveChild( rowElement );
        }

        private void OnDeletingRow( DataRow row, XmlBoundElement rowElement ) {
            // Note that this function is beeing called even if ignoreDataSetEvents == true.

            // Foliate, so we can be able to preserve the nodes even if the DataRow has no longer values for the crtRecord.
            if ( IsFoliated( rowElement ) )
                return;

            bool wasIgnoreXmlEvents  = IgnoreXmlEvents;
            IgnoreXmlEvents          = true;
            bool wasFoliationEnabled = IsFoliationEnabled;
            IsFoliationEnabled       = true;
            try {
                Foliate( rowElement );
            }
            finally {
                IsFoliationEnabled = wasFoliationEnabled;
                IgnoreXmlEvents    = wasIgnoreXmlEvents;
            }
        }

        private void OnFoliated( XmlNode node ) {
            while ( true ) {
                try {
                    if ( pointers.Count > 0 ) {
                        foreach( DictionaryEntry entry in pointers ) {
                            object pointer = entry.Value;
                            Debug.Assert( pointer != null );
                            ((IXmlDataVirtualNode)pointer).OnFoliated( node );
                        }
                    }
                    return;
                }
                catch (Exception e) {
                    // 
                    if (!System.Data.Common.ADP.IsCatchableExceptionType (e)) {
                        throw;
                    }
                    // This can happens only when some threads are creating navigators (thus modifying this.pointers) while other threads are in the foreach loop.
                    // Solution is to re-try OnFoliated.
                }
            }
            // You should never get here in regular cases
        }

        DataColumn FindAssociatedParentColumn( DataRelation relation, DataColumn childCol ) {
            DataColumn[] columns = relation.ChildKey.ColumnsReference;
            for (int i = 0; i < columns.Length; i++) {
                if ( childCol == columns[i] )
                    return relation.ParentKey.ColumnsReference[i];
            }
            return null;
        }

        // Change the childElement position in the tree to conform to the parent nested relationship in ROM
        private void OnNestedParentChange(DataRow child, XmlBoundElement childElement, DataColumn childCol) {
            Debug.Assert( child.Element == childElement && childElement.Row == child );
            // This function is (and s/b) called as a result of ROM changes, therefore XML changes done here should not be sync-ed to ROM
            Debug.Assert( ignoreXmlEvents == true );
#if DEBUG
            // In order to check that this move does not change the connected/disconnected state of the node
            bool fChildElementConnected = IsConnected( childElement );
#endif
            DataRow parentRowInTree;
            if ( childElement == this.DocumentElement || childElement.ParentNode == null )
                parentRowInTree = null;
            else
                parentRowInTree = GetRowFromElement( (XmlElement) childElement.ParentNode );
            DataRow parentRowInRelation = GetNestedParent(child);

            if ( parentRowInTree != parentRowInRelation ) {
                if ( parentRowInRelation != null ) {
                    // 

                    XmlElement newParent = GetElementFromRow( parentRowInRelation );
                    newParent.AppendChild( childElement );
                }
                else {
                    // no parent? Maybe the parentRow is during changing or childCol is the ID is set to null ( detached from the parent row ).
                    DataRelation relation = GetNestedParentRelation(child);
                    if ( childCol == null || relation == null || Convert.IsDBNull(child[childCol]) ) {
                        EnsureNonRowDocumentElement().AppendChild( childElement );
                    }
                    else {
                        DataColumn colInParent = FindAssociatedParentColumn( relation, childCol );
                        Debug.Assert( colInParent != null );
                        object comparedValue = colInParent.ConvertValue(child[childCol]);
                        if (parentRowInTree.tempRecord != -1 && colInParent.CompareValueTo( parentRowInTree.tempRecord, comparedValue ) != 0 ) {
                            EnsureNonRowDocumentElement().AppendChild( childElement );
                        }
                        //else do nothing because its original parentRowInRelation will be changed so that this row will still be its child
                    }
                }
            }
#if DEBUG
            // We should not have changed the connected/disconnected state of the node (since the row state did not change) -- IOW if the original childElem was in dis-connected
            // state and corresponded to a detached/deleted row, by adding it to the main tree we become inconsistent (since we have now a deleted/detached row in the main tree)
            // Same goes when we remove a node from connected tree to make it a child of a row-node corresponding to a non-live row.
            Debug.Assert( fChildElementConnected == IsConnected( childElement ) );
            Debug.Assert( IsRowLive( child ) ? IsConnected( childElement ) : ! IsConnected( childElement ) );
#endif
        }

        private void OnNodeChanged( object sender, XmlNodeChangedEventArgs args ) {
            if ( ignoreXmlEvents )
                return;

            bool wasIgnoreDataSetEvents = ignoreDataSetEvents;
            bool wasIgnoreXmlEvents     = ignoreXmlEvents;
            bool wasFoliationEnabled    = IsFoliationEnabled;
            ignoreDataSetEvents = true;
            ignoreXmlEvents     = true;
            IsFoliationEnabled  = false;
            bool fEnableCascading = DataSet.fEnableCascading;
            DataSet.fEnableCascading = false;

            try {
                // okay to allow text node value changes when bound.
                XmlBoundElement rowElement = null;

                Debug.Assert( DataSet.EnforceConstraints == false );

                if ( mapper.GetRegion( args.Node, out rowElement ) ) {
                    SynchronizeRowFromRowElement( rowElement );
                }
            }
            finally {
                ignoreDataSetEvents = wasIgnoreDataSetEvents;
                ignoreXmlEvents     = wasIgnoreXmlEvents;
                IsFoliationEnabled  = wasFoliationEnabled;
                DataSet.fEnableCascading = fEnableCascading;
            }
        }

        private void OnNodeChanging( object sender, XmlNodeChangedEventArgs args ) {
            if( ignoreXmlEvents )
                return;
            if ( DataSet.EnforceConstraints != false )
                throw new InvalidOperationException( Res.GetString(Res.DataDom_EnforceConstraintsShouldBeOff ) );
        }


        private void OnNodeInserted( object sender, XmlNodeChangedEventArgs args ) {
            if ( ignoreXmlEvents )
                return;

            bool wasIgnoreDataSetEvents = ignoreDataSetEvents;
            bool wasIgnoreXmlEvents     = ignoreXmlEvents;
            bool wasFoliationEnabled    = IsFoliationEnabled;
            ignoreDataSetEvents = true;
            ignoreXmlEvents     = true;
            IsFoliationEnabled  = false;

            Debug.Assert( DataSet.EnforceConstraints == false );

            bool fEnableCascading = DataSet.fEnableCascading;
            DataSet.fEnableCascading = false;

            try {
                // Handle both new node inserted and 2nd part of a move operation.
                // 
                XmlNode node = args.Node;
                XmlNode oldParent = args.OldParent;
                XmlNode newParent = args.NewParent;

                // The code bellow assumes a move operation is fired by DOM in 2 steps: a Remvoe followed by an Insert - this is the 2nd part, the Insert.
                Debug.Assert( oldParent == null );
                if ( IsConnected( newParent ) ) {
                    // Inserting a node to connected tree
                    OnNodeInsertedInTree( node );
                }
                else {
                    // Inserting a node to disconnected tree
                    OnNodeInsertedInFragment( node );
                }
            }
            finally {
                ignoreDataSetEvents = wasIgnoreDataSetEvents;
                ignoreXmlEvents     = wasIgnoreXmlEvents;
                IsFoliationEnabled  = wasFoliationEnabled;
                DataSet.fEnableCascading = fEnableCascading;
            }

        }

        private void OnNodeInserting( object sender, XmlNodeChangedEventArgs args ) {
            if ( ignoreXmlEvents )
                return;
            if ( DataSet.EnforceConstraints != false )
                throw new InvalidOperationException( Res.GetString(Res.DataDom_EnforceConstraintsShouldBeOff ) );
        }


        private void OnNodeRemoved( object sender, XmlNodeChangedEventArgs args ) {
            if ( ignoreXmlEvents )
                return;

            bool wasIgnoreDataSetEvents = ignoreDataSetEvents;
            bool wasIgnoreXmlEvents     = ignoreXmlEvents;
            bool wasFoliationEnabled    = IsFoliationEnabled;
            ignoreDataSetEvents = true;
            ignoreXmlEvents     = true;
            IsFoliationEnabled  = false;

            Debug.Assert( DataSet.EnforceConstraints == false );

            bool fEnableCascading = DataSet.fEnableCascading;
            DataSet.fEnableCascading = false;

            try {
                XmlNode node = args.Node;
                XmlNode oldParent = args.OldParent;
                Debug.Assert( args.NewParent == null );

                if ( IsConnected( oldParent ) ) {
                    // Removing from connected tree to disconnected tree
                    OnNodeRemovedFromTree( node, oldParent );
                }
                else {
                    // Removing from disconnected tree to disconnected tree: just sync the old region
                    OnNodeRemovedFromFragment( node, oldParent );
                }
            }
            finally {
                ignoreDataSetEvents = wasIgnoreDataSetEvents;
                ignoreXmlEvents     = wasIgnoreXmlEvents;
                IsFoliationEnabled  = wasFoliationEnabled;
                DataSet.fEnableCascading = fEnableCascading;
            }
        }

        private void OnNodeRemoving( object sender, XmlNodeChangedEventArgs args ) {
            if ( ignoreXmlEvents )
                return;
            if ( DataSet.EnforceConstraints != false )
                throw new InvalidOperationException( Res.GetString(Res.DataDom_EnforceConstraintsShouldBeOff ) );
        }

        // Node was removed from connected tree to disconnected tree
        private void OnNodeRemovedFromTree( XmlNode node, XmlNode oldParent ) {
            XmlBoundElement oldRowElem;

            // Synchronize values from old region
            if ( mapper.GetRegion( oldParent, out oldRowElem ) )
                SynchronizeRowFromRowElement( oldRowElem );

            // Disconnect all regions, starting w/ node (if it is a row-elem)
            XmlBoundElement rowElem = node as XmlBoundElement;
            if ( rowElem != null && rowElem.Row != null )
                EnsureDisconnectedDataRow( rowElem );
            TreeIterator iter = new TreeIterator( node );
            for ( bool fMore = iter.NextRowElement(); fMore; fMore = iter.NextRowElement() ) {
                rowElem = (XmlBoundElement)(iter.CurrentNode);
                EnsureDisconnectedDataRow( rowElem );
            }

            // Assert that all sub-regions are disconnected
            AssertNonLiveRows( node );
        }
        // Node was removed from the disconnected tree to disconnected tree
        private void OnNodeRemovedFromFragment( XmlNode node, XmlNode oldParent ) {
            XmlBoundElement oldRowElem;

            if ( mapper.GetRegion( oldParent, out oldRowElem ) ) {
                // Sync the old region if it is not deleted
                DataRow row = oldRowElem.Row;
                // Since the old old region was disconnected, then the row can be only Deleted or Detached
                Debug.Assert( ! IsRowLive( row ) );
                if ( oldRowElem.Row.RowState == DataRowState.Detached )
                    SynchronizeRowFromRowElement( oldRowElem );
            }

            // Need to set nested for the sub-regions (if node is a row-elem, we need to set it just for itself)
            XmlBoundElement be = node as XmlBoundElement;
            if ( be != null && be.Row != null ) {
                Debug.Assert( ! IsRowLive( be.Row ) );
                SetNestedParentRegion( be, null );
            }
            else {
                // Set nested parent to null for all child regions
                TreeIterator iter = new TreeIterator( node );
                for ( bool fMore = iter.NextRowElement(); fMore; fMore = iter.NextRightRowElement() ) {
                    XmlBoundElement rowElemChild = (XmlBoundElement)(iter.CurrentNode);
                    SetNestedParentRegion( rowElemChild, null );
                }
            }

            // Assert that all sub-regions are disconnected
            AssertNonLiveRows( node );
        }


        private void OnRowChanged( object sender, DataRowChangeEventArgs args ) {
            if ( ignoreDataSetEvents )
                return;

            ignoreXmlEvents = true;
            bool wasFoliationEnabled = IsFoliationEnabled;
            IsFoliationEnabled = false;

            try {
                DataRow row = args.Row;
                XmlBoundElement rowElement = row.Element;
                // We should have an associated row-elem created when the DataRow was created (or at the load time)
                Debug.Assert( rowElement != null );

                switch ( args.Action ) {
                    case DataRowAction.Add:
                        // 








                        OnAddRow( row );
                        break;

                    case DataRowAction.Delete:
                        OnDeleteRow( row, rowElement );
                        break;

                    case DataRowAction.Rollback:
                        switch ( rollbackState ) {
                            case DataRowState.Deleted:
                                OnUndeleteRow( row, rowElement );
                                UpdateAllColumns( row, rowElement );
                                break;

                            case DataRowState.Added:
                                rowElement.ParentNode.RemoveChild( rowElement );
                                break;

                            case DataRowState.Modified:
                                OnColumnValuesChanged( row, rowElement );
                                break;
                        }
                        break;

                    case DataRowAction.Change:
                        OnColumnValuesChanged( row, rowElement );
                        break;

                    case DataRowAction.Commit:
                        if ( row.RowState == DataRowState.Detached ) {
                            //by now, all the descendent of the element that is not of this region should have been promoted already
                            rowElement.RemoveAll();
                        }
                        break;
                    default:
                        //Console.WriteLine("Other Event");
                        break;
                }
            }
            finally {
                IsFoliationEnabled = wasFoliationEnabled;
                ignoreXmlEvents = false;
            }
        }

        private void OnRowChanging( object sender, DataRowChangeEventArgs args ) {
            // We foliate the region each time the assocaited row gets deleted
            DataRow row = args.Row;
            if ( args.Action == DataRowAction.Delete && row.Element != null ) {
                OnDeletingRow( row, row.Element );
                return;
            }

            if ( ignoreDataSetEvents )
                return;

            bool wasFoliationEnabled = IsFoliationEnabled;
            IsFoliationEnabled = false;

            try {
                ignoreXmlEvents = true;

                XmlElement rowElement = GetElementFromRow( row );

                int nRec1 = -1;
                int nRec2 = -1;

                if ( rowElement != null ) {
                    switch ( args.Action ) {
                        case DataRowAction.Add:
                            // DataRow is beeing added to the table (Table.Rows.Add is beeing called)
                            break;

                        case DataRowAction.Delete:
                            // DataRow is beeing deleted
                            //    - state transition from New (AKA PendingInsert) to Detached (AKA Created)
                            //    - state transition from Unchanged to Deleted (AKA PendingDelete)
                            //    - state transition from Modified (AKA PendingChange) to Delete (AKA PendingDelete)
                            Debug.Assert( false );  // This should have been handled above, irrespective of ignoreDataSetEvents value (true or false)
                            break;

                        case DataRowAction.Rollback:
                            // DataRow gets reverted to previous values (by calling DataRow.RejectChanges):
                            //    - state transition from Detached (AKA Created) to Detached (AKA Created)
                            //    - state transition from New (AKA PendingInsert) to Detached (AKA Created)
                            //    - state transition from Modified (AKA PendingChange) to Unchanged
                            //    - state transition from Deleted (AKA PendingDelete) to Unchanged
                            rollbackState = row.RowState;
                            switch ( rollbackState ) {
                                case DataRowState.Deleted:
                                    break;

                                case DataRowState.Detached:
                                    break;

                                case DataRowState.Added:
                                    break;

                                case DataRowState.Modified:
                                    columnChangeList.Clear();
                                    nRec1 = row.GetRecordFromVersion(DataRowVersion.Original);
                                    nRec2 = row.GetRecordFromVersion(DataRowVersion.Current);
                                    foreach( DataColumn c in row.Table.Columns ) {
                                        if ( !IsSame( c, nRec1, nRec2 ) )
                                            columnChangeList.Add(c);
                                    }
                                    break;

                            }
                            break;

                        case DataRowAction.Change:
                            // A DataRow field is beeing changed
                            //    - state transition from New (AKA PendingInsert) to New (AKA PendingInsert)
                            //    - state transition from Unchanged to Modified (AKA PendingChange)
                            //    - state transition from Modified (AKA PendingChange) to Modified (AKA PendingChange)
                            //
                            columnChangeList.Clear();
                            nRec1 = row.GetRecordFromVersion( DataRowVersion.Proposed );
                            nRec2 = row.GetRecordFromVersion( DataRowVersion.Current );
                            foreach( DataColumn c in row.Table.Columns ) {
                                object proposedValue = row[c, DataRowVersion.Proposed];
                                object currentValue  = row[c, DataRowVersion.Current];
                                // Foliate if proposedValue is DBNull; this way the DataPointer objects will point to a disconnected fragment after
                                // the DBNull value is beeing set
                                if ( Convert.IsDBNull( proposedValue ) && ! Convert.IsDBNull( currentValue ) ) {
                                    // Foliate only for non-hidden columns (since hidden cols are not represented in XML)
                                    if ( c.ColumnMapping != MappingType.Hidden )
                                        FoliateIfDataPointers( row, rowElement );
                                }
                                if ( !IsSame( c, nRec1, nRec2 ) )
                                    columnChangeList.Add(c);
                            }
                            break;

                        case DataRowAction.Commit:
                            break;
                    }
                }
            }
            finally {
                ignoreXmlEvents = false;
                IsFoliationEnabled = wasFoliationEnabled;
            }
        }

        private void OnDataSetPropertyChanging( object oDataSet, PropertyChangedEventArgs args ) {
            if ( args.PropertyName == "DataSetName" )
                throw new InvalidOperationException( Res.GetString(Res.DataDom_DataSetNameChange ) );
            // 
        }
        private void OnColumnPropertyChanging( object oColumn, PropertyChangedEventArgs args ) {
            if ( args.PropertyName == "ColumnName" )
                throw new InvalidOperationException( Res.GetString(Res.DataDom_ColumnNameChange ) );
            if ( args.PropertyName == "Namespace" )
                throw new InvalidOperationException( Res.GetString(Res.DataDom_ColumnNamespaceChange ) );
            if ( args.PropertyName == "ColumnMapping" )
                throw new InvalidOperationException( Res.GetString(Res.DataDom_ColumnMappingChange ) );
        }
        private void OnTablePropertyChanging( object oTable, PropertyChangedEventArgs args ) {
            if ( args.PropertyName == "TableName" )
                throw new InvalidOperationException( Res.GetString(Res.DataDom_TableNameChange ) );
            if ( args.PropertyName == "Namespace" )
                throw new InvalidOperationException( Res.GetString(Res.DataDom_TableNamespaceChange ) );
        }
        private void OnTableColumnsChanging( object oColumnsCollection, CollectionChangeEventArgs args ) {
            // args.Action is one of CollectionChangeAction.Add, CollectionChangeAction.Remove or CollectionChangeAction.Refresh
            // args.Element is one of either the column (for Add and Remove actions or null, if the entire colection of columns is changing)

            // Disallow changing the columns collection (since we are subscribed only in populated mode, we allow changes in any state but non-populated mode)
            throw new InvalidOperationException(  Res.GetString(Res.DataDom_TableColumnsChange ) );
        }

        private void OnDataSetTablesChanging( object oTablesCollection, CollectionChangeEventArgs args ) {
            // args.Action is one of CollectionChangeAction.Add, CollectionChangeAction.Remove or CollectionChangeAction.Refresh
            // args.Element is a table (dont know if it can be null: 

            // Disallow changing the tables collection (since we are subscribed only in populated mode, we allow changes in any state but non-populated mode)
            throw new InvalidOperationException(  Res.GetString(Res.DataDom_DataSetTablesChange ) );
        }

        private void OnDataSetRelationsChanging( object oRelationsCollection, CollectionChangeEventArgs args ) {
            // args.Action is one of CollectionChangeAction.Add, CollectionChangeAction.Remove or CollectionChangeAction.Refresh
            // args.Element is a DataRelation (dont know if it can be null: 

            // Disallow changing the tables collection if there is data loaded and there are nested relationship that are added/refreshed
            DataRelation rel = (DataRelation)(args.Element);
            if ( rel != null && rel.Nested )
                throw new InvalidOperationException(  Res.GetString(Res.DataDom_DataSetNestedRelationsChange ) );

            // If Add and Remove, we should already been throwing if .Nested == false
            Debug.Assert( ! (args.Action == CollectionChangeAction.Add || args.Action == CollectionChangeAction.Remove) || rel.Nested == false );
            if ( args.Action == CollectionChangeAction.Refresh ) {
                foreach ( DataRelation relTemp in (DataRelationCollection)oRelationsCollection ) {
                    if ( relTemp.Nested ) {
                        throw new InvalidOperationException(  Res.GetString(Res.DataDom_DataSetNestedRelationsChange ) );
                    }
                }
            }
        }

        private void OnRelationPropertyChanging( object oRelationsCollection, PropertyChangedEventArgs args ) {
            if ( args.PropertyName == "Nested" )
                throw new InvalidOperationException( Res.GetString(Res.DataDom_DataSetNestedRelationsChange ) );
        }

        private void OnUndeleteRow( DataRow row, XmlElement rowElement ) {
            XmlNode refRow;
            XmlElement parent;

            // make certain we weren't place somewhere else.
            if ( rowElement.ParentNode != null )
                rowElement.ParentNode.RemoveChild( rowElement );

            // Find the parent of RowNode to be inserted
            DataRow parentRowInRelation = GetNestedParent(row);
            if (parentRowInRelation == null) {
                parent = EnsureNonRowDocumentElement();
            }
            else
                parent = GetElementFromRow(parentRowInRelation);

            if ((refRow = GetRowInsertBeforeLocation(row, rowElement, parent)) != null)
                parent.InsertBefore(rowElement, refRow);
            else
                parent.AppendChild( rowElement );

            FixNestedChildren(row, rowElement);
        }

        // Promote the rowElemChild node/region after prevSibling node (as the next sibling)
        private void PromoteChild( XmlNode child, XmlNode prevSibling ) {
            // It makes no sense to move rowElemChild on the same level
            Debug.Assert( child.ParentNode != prevSibling.ParentNode );
            // prevSibling must have a parent, since we want to add a sibling to it
            Debug.Assert( prevSibling.ParentNode != null );
            Debug.Assert( IsFoliationEnabled == false );
            Debug.Assert( IgnoreXmlEvents == true );
            // Should not insert after docElem node
            Debug.Assert( prevSibling != this.DocumentElement );

            if ( child.ParentNode != null )
                child.ParentNode.RemoveChild( child );

            Debug.Assert( child.ParentNode == null );
            prevSibling.ParentNode.InsertAfter( child, prevSibling );
        }

        // Promote child regions under parent as next siblings of parent
        private void PromoteInnerRegions( XmlNode parent ) {
            Debug.Assert( parent != null );
            Debug.Assert( parent.NodeType != XmlNodeType.Attribute );   // We need to get get the grand-parent region
            Debug.Assert( parent != DocumentElement );                  // We cannot promote children of the DocumentElement

            XmlNode prevSibling = parent;
            XmlBoundElement parentRegionRowElem;
            mapper.GetRegion( parent.ParentNode, out parentRegionRowElem );

            TreeIterator iter = new TreeIterator( parent );
            bool fMore = iter.NextRowElement();
            while ( fMore ) {
                Debug.Assert( iter.CurrentNode is XmlBoundElement && ((XmlBoundElement)(iter.CurrentNode)).Row != null );
                XmlBoundElement rowElemChild = (XmlBoundElement)(iter.CurrentNode);
                fMore = iter.NextRightRowElement();
                PromoteChild( rowElemChild, prevSibling );
                SetNestedParentRegion( rowElemChild, parentRegionRowElem );
            }
        }

        private void PromoteNonValueChildren( XmlNode parent ) {
            Debug.Assert( parent != null );
            XmlNode prevSibling = parent;
            XmlNode child = parent.FirstChild;
            bool bTextLikeNode = true;
            XmlNode nextSibling = null;
            while ( child != null ) {
                nextSibling = child.NextSibling;                
                if (!bTextLikeNode || !IsTextLikeNode(child)) {
                    bTextLikeNode = false;
                    nextSibling = child.NextSibling;
                    PromoteChild( child, prevSibling );
                    prevSibling = child;
                }
                child = nextSibling;
            }
        }

        private void RemoveInitialTextNodes( XmlNode node ) {
            while ( node != null && IsTextLikeNode( node ) ) {
                XmlNode sibling = node.NextSibling;
                node.ParentNode.RemoveChild( node );
                node = sibling;
            }
        }

        private void ReplaceInitialChildText( XmlNode parent, string value ) {
            XmlNode n = parent.FirstChild;

            // don't consider whitespace when replacing initial text
            while ( n != null && n.NodeType == XmlNodeType.Whitespace )
                n = n.NextSibling;

            if ( n != null ) {
                if ( n.NodeType == XmlNodeType.Text )
                    n.Value = value;
                else
                    n = parent.InsertBefore( CreateTextNode( value ), n );
                RemoveInitialTextNodes( n.NextSibling );
            }
            else {
                parent.AppendChild( CreateTextNode( value ) );
            }
        }

        internal XmlNode SafeFirstChild( XmlNode n ) {
            XmlBoundElement be = n as XmlBoundElement;
            if ( be != null )
                return be.SafeFirstChild;
            else
                //other type of node should be already foliated.
                return n.FirstChild;
        }

        internal XmlNode SafeNextSibling( XmlNode n ) {
            XmlBoundElement be = n as XmlBoundElement;
            if ( be != null )
                return be.SafeNextSibling;
            else
                //other type of node should be already foliated.
                return n.NextSibling;
        }

        internal XmlNode SafePreviousSibling( XmlNode n ) {
            XmlBoundElement be = n as XmlBoundElement;
            if ( be != null )
                return be.SafePreviousSibling;
            else
                //other type of node should be already foliated.
                return n.PreviousSibling;
        }

        internal static void SetRowValueToNull( DataRow row, DataColumn col ) {
            Debug.Assert( col.ColumnMapping != MappingType.Hidden );
            Debug.Assert( row.Table.DataSet.EnforceConstraints == false );

            // 
            if ( ! ( row.IsNull( col ) ) )
                row[ col ] = Convert.DBNull;
        }

        internal static void SetRowValueFromXmlText( DataRow row, DataColumn col, string xmlText ) {
            Debug.Assert( xmlText != null );
            Debug.Assert( row.Table.DataSet.EnforceConstraints == false );
            object oVal;
            try {
                oVal = col.ConvertXmlToObject( xmlText );
                // This func does not set the field value to null - call SetRowValueToNull in order to do so
                Debug.Assert( oVal != null && ! ( oVal is DBNull ) );
            }
            catch (Exception e) {
                // 
                if (!System.Data.Common.ADP.IsCatchableExceptionType (e)) {
                        throw;
                }
                // Catch data-type errors and set ROM to Unspecified value
                SetRowValueToNull( row, col );
                return;
            }

            if ( ! oVal.Equals( row[col] ) )
                row[ col ] = oVal;
        }

        private void SynchronizeRowFromRowElement( XmlBoundElement rowElement ) {
            SynchronizeRowFromRowElement( rowElement, null );
        }
        // Sync row fields w/ values from rowElem region.
        // If rowElemList is != null, all subregions of rowElem are appended to it.
        private void SynchronizeRowFromRowElement( XmlBoundElement rowElement, ArrayList rowElemList ) {
            DataRow row = rowElement.Row;
            Debug.Assert( row != null );

            // No synchronization needed for deleted rows
            if ( row.RowState == DataRowState.Deleted )
                return;

            row.BeginEdit();
#if DEBUG
            try {
#endif
                SynchronizeRowFromRowElementEx( rowElement, rowElemList );
#if DEBUG
            }
            catch {
                // We should not get any exceptions because we always handle data-type conversion
                Debug.Assert( false );
                throw;
            }
#endif
#if DEBUG
            try {
#endif
                row.EndEdit();
#if DEBUG
            }
            catch {
                // We should not get any exceptions because DataSet.EnforceConstraints should be always off
                // 
                Debug.Assert( false );
                throw;
            }
#endif
        }
        private void SynchronizeRowFromRowElementEx( XmlBoundElement rowElement, ArrayList rowElemList ) {
            Debug.Assert( rowElement != null );
            Debug.Assert( rowElement.Row != null );
            Debug.Assert( this.DataSet.EnforceConstraints == false );

            DataRow row = rowElement.Row;
            Debug.Assert( row != null );
            DataTable table = row.Table;

            // if not foliated, already synch'd
//            if ( !IsFoliated(rowElement) )
//                return;
            //Debug.Assert( IsFoliated(rowElement) ); // If foliated we should not get the event (should be handled directly by DataPointer)

            Hashtable foundColumns = new Hashtable();
            string xsi_attrVal = string.Empty;

            RegionIterator iter = new RegionIterator( rowElement );
            bool fMore;
            // If present, fill up the TextOnly column
            DataColumn column = GetTextOnlyColumn( row );
            if ( column != null ) {
                foundColumns[column] = column;
                string value;
                fMore = iter.NextInitialTextLikeNodes( out value );
                if ( value.Length == 0 && ( ( (xsi_attrVal = rowElement.GetAttribute(XSI_NIL) ) == "1" ) || xsi_attrVal == "true" ) )
                    row[column] = Convert.DBNull;
                else
                    SetRowValueFromXmlText( row, column, value );
            }
            else
                fMore = iter.Next();

            // Fill up the columns mapped to an element
            while ( fMore ) {
                XmlElement e = iter.CurrentNode as XmlElement;
                if ( e == null ) {
                    fMore = iter.Next();
                    continue;
                }

                XmlBoundElement be = e as XmlBoundElement;
                if ( be != null && be.Row != null ) {
                    if ( rowElemList != null )
                        rowElemList.Add( e );
                    // Skip over sub-regions
                    fMore = iter.NextRight();
                    continue;
                }

                DataColumn c = mapper.GetColumnSchemaForNode( rowElement, e );
                if ( c != null ) {
                    Debug.Assert( c.Table == row.Table );
                    if ( foundColumns[c] == null ) {
                        foundColumns[c] = c;
                        string value;
                        fMore = iter.NextInitialTextLikeNodes( out value );
                        if ( value.Length == 0 && ( ( (xsi_attrVal = e.GetAttribute(XSI_NIL) ) == "1" ) || xsi_attrVal == "true" ) )
                            row[c] = Convert.DBNull;
                        else
                            SetRowValueFromXmlText( row, c, value );
                        continue;
                    }
                }

                fMore = iter.Next();
            }

            //
            // Walk the attributes to find attributes that map to columns.
            //
            foreach( XmlAttribute attr in rowElement.Attributes ) {
                DataColumn c = mapper.GetColumnSchemaForNode( rowElement, attr );

                if ( c != null ) {
                    if ( foundColumns[c] == null ) {
                        foundColumns[c] = c;
                        SetRowValueFromXmlText( row, c, attr.Value );
                    }
                }
            }

            // Null all columns values that aren't represented in the tree
            foreach( DataColumn c in row.Table.Columns ) {
                if ( foundColumns[c] == null && !IsNotMapped(c) ) {
                    if (!c.AutoIncrement)
                        SetRowValueToNull( row, c );
                    else
                        c.Init(row.tempRecord);
                }
            }
        }

        private void UpdateAllColumns( DataRow row, XmlBoundElement rowElement ) {
            foreach( DataColumn c in row.Table.Columns ) {
                OnColumnValueChanged( row, c, rowElement );
            }
        }

        /// <devdoc>
        ///    <para>
        ///       Initializes a new instance of the XmlDataDocument class.
        ///    </para>
        /// </devdoc>
        public XmlDataDocument(): base(new XmlDataImplementation()) {
            Init();
            AttachDataSet( new DataSet() );
            this.dataSet.EnforceConstraints = false;
        }

        /// <devdoc>
        ///    <para>
        ///       Initializes a new instance of the XmlDataDocument class with the specified
        ///       DataSet.
        ///    </para>
        /// </devdoc>
        public XmlDataDocument( DataSet dataset ): base(new XmlDataImplementation()) {
            Init( dataset );
        }

        internal XmlDataDocument( XmlImplementation imp ) : base( imp ) {
        }

        private void Init() {
            this.pointers = new Hashtable();
            this.countAddPointer = 0;
            this.columnChangeList = new ArrayList();
            this.ignoreDataSetEvents = false;
            this.isFoliationEnabled = true;
            this.optimizeStorage = true;
            this.fDataRowCreatedSpecial = false;
            autoFoliationState = ElementState.StrongFoliation;
            fAssociateDataRow = true; //this needs to be true for newly created elements should have associated datarows
            mapper = new DataSetMapper();
            this.foliationLock = new object();
            this.ignoreXmlEvents = true;
            this.attrXml = CreateAttribute( "xmlns", "xml", XPathNodePointer.s_strReservedXmlns );
            this.attrXml.Value = XPathNodePointer.s_strReservedXml;
            this.ignoreXmlEvents = false;
        }

        private void Init( DataSet ds ) {
            if ( ds == null )
                throw new ArgumentException(Res.GetString(Res.DataDom_DataSetNull));
            Init();
            if ( ds.FBoundToDocument )
                throw new ArgumentException( Res.GetString(Res.DataDom_MultipleDataSet) );
            ds.FBoundToDocument = true;
            this.dataSet = ds;
            Bind(true);
        }

        private bool IsConnected( XmlNode node ) {
            while ( true ) {
                if ( node == null )
                    return false;
                if ( node == this )
                    return true;

                XmlAttribute attr = node as XmlAttribute;
                if ( attr != null )
                    node = attr.OwnerElement;
                else
                    node = node.ParentNode;
            }
        }
        private bool IsRowLive( DataRow row ) {
            return ( row.RowState & ( DataRowState.Added | DataRowState.Unchanged | DataRowState.Modified ) ) != 0;
        }
        private static void SetNestedParentRow( DataRow childRow, DataRow parentRow ) {
            DataRelation rel = GetNestedParentRelation( childRow );
            //we should not set this row's parentRow if the table doesn't match.
            if ( rel != null ) {
                if ( parentRow == null || rel.ParentKey.Table != parentRow.Table )
                    childRow.SetParentRow( null, rel );
                else
                   childRow.SetParentRow( parentRow, rel );
            }
        }

        // A node (node) was inserted into the main tree (connected) from oldParent==null state
        private void OnNodeInsertedInTree( XmlNode node ) {
            XmlBoundElement be;
            ArrayList rowElemList = new ArrayList();
            if ( mapper.GetRegion( node, out be ) ) {
                // 
                if ( be == node ) {
                    OnRowElementInsertedInTree( be, rowElemList );
                }
                else {
                    OnNonRowElementInsertedInTree( node, be, rowElemList );
                }
            }
            else {
                // We only need to sync the embedded sub-regions
                TreeIterator iter = new TreeIterator( node );
                for (bool fMore = iter.NextRowElement(); fMore; fMore = iter.NextRightRowElement() )
                    rowElemList.Add( iter.CurrentNode );
            }

            // Process subregions, so they make transition from disconnected to connected tree
            while ( rowElemList.Count > 0 ) {
                Debug.Assert(rowElemList[0] != null && rowElemList[0] is XmlBoundElement);
                XmlBoundElement subRowElem = (XmlBoundElement)(rowElemList[0]);
                rowElemList.RemoveAt( 0 );
                // Expect rowElem to have a DataTable schema, since it is a sub-region
                Debug.Assert( subRowElem != null );
                OnRowElementInsertedInTree( subRowElem, rowElemList );
            }

            // Assert that all sub-regions are assoc w/ "live" rows
            AssertLiveRows( node );
        }
        // "node" was inserting into a disconnected tree from oldParent==null state
        private void OnNodeInsertedInFragment( XmlNode node ) {
            XmlBoundElement be;
            if ( mapper.GetRegion( node, out be ) ) {
                if ( be == node ) {
                    Debug.Assert( ! IsRowLive( be.Row ) );
                    SetNestedParentRegion( be );
                }
                else {
                    ArrayList rowElemList = new ArrayList();
                    OnNonRowElementInsertedInFragment( node, be, rowElemList );
                    // Set nested parent for the 1st level subregions (they should already be associated w/ Deleted or Detached rows)
                    while ( rowElemList.Count > 0 ) {
                        Debug.Assert(rowElemList[0] != null && rowElemList[0] is XmlBoundElement);
                        XmlBoundElement subRowElem = (XmlBoundElement)(rowElemList[0]);
                        rowElemList.RemoveAt( 0 );
                        SetNestedParentRegion( subRowElem, be );
                    }
                }

                // Check to make sure all sub-regions are disconnected
                AssertNonLiveRows( node );

                return;
            }

            // Nothing to do, since the node belongs to no region

            // Check to make sure all sub-regions are disconnected
            AssertNonLiveRows( node );
        }

        // A row-elem was inserted into the connected tree (connected) from oldParent==null state
        private void OnRowElementInsertedInTree( XmlBoundElement rowElem, ArrayList rowElemList ) {
            Debug.Assert( rowElem.Row != null );

            DataRow row = rowElem.Row;
            DataRowState rowState = row.RowState;

            switch( rowState ) {
            case DataRowState.Detached:
#if DEBUG
                try {
                    Debug.Assert( row.Table.DataSet.EnforceConstraints == false );
#endif
                    row.Table.Rows.Add( row );
                    SetNestedParentRegion( rowElem );
#if DEBUG
                }
                catch {
                    // We should not get any exceptions here
                    Debug.Assert( false );
                    throw;
                }
#endif
                // Add all sub-regions to the list if the caller needs this
                if ( rowElemList != null ) {
                    RegionIterator iter = new RegionIterator( rowElem );
                    for (bool fMore = iter.NextRowElement(); fMore; fMore = iter.NextRightRowElement() )
                        rowElemList.Add( iter.CurrentNode );
                }
                break;
            case DataRowState.Deleted:
#if DEBUG
                try {
                    Debug.Assert( row.Table.DataSet.EnforceConstraints == false );
#endif
                    // Change the row status to be alive (unchanged)
                    row.RejectChanges();
                    // Set ROM from XML
                    SynchronizeRowFromRowElement( rowElem, rowElemList );
                    // Set nested parent data row according to where is the row positioned in the tree
                    SetNestedParentRegion( rowElem );
#if DEBUG
                }
                catch {
                    // We should not get any exceptions here
                    Debug.Assert( false );
                    throw;
                }
#endif
                break;
            default:
                // Handle your case above
                // 
                Debug.Assert( false );
                break;
            }
            Debug.Assert( IsRowLive( rowElem.Row ) );
        }

        // Disconnect the DataRow associated w/ the rowElem region
        private void EnsureDisconnectedDataRow( XmlBoundElement rowElem ) {
            Debug.Assert( rowElem.Row != null );

            DataRow row = rowElem.Row;
            DataRowState rowState = row.RowState;

            switch( rowState ) {
            case DataRowState.Detached:
#if DEBUG
                try {
                    Debug.Assert( row.Table.DataSet.EnforceConstraints == false );
#endif
                    SetNestedParentRegion( rowElem );
#if DEBUG
                }
                catch {
                    // We should not get any exceptions here
                    Debug.Assert( false );
                    throw;
                }
#endif
                break;

            case DataRowState.Deleted:
                // Nothing to do: moving a region associated w/ a deleted row to another disconnected tree is a NO-OP.
                break;

            case DataRowState.Unchanged:
            case DataRowState.Modified:
                EnsureFoliation( rowElem, ElementState.WeakFoliation );
                row.Delete();
                break;

            case DataRowState.Added:
                EnsureFoliation( rowElem, ElementState.WeakFoliation );
                row.Delete();
                SetNestedParentRegion( rowElem );
                break;

            default:
                // Handle your case above
                // 
                Debug.Assert( false );
                break;
            }

            Debug.Assert( ! IsRowLive( rowElem.Row ) );
        }


        // A non-row-elem was inserted into the connected tree (connected) from oldParent==null state
        private void OnNonRowElementInsertedInTree( XmlNode node, XmlBoundElement rowElement, ArrayList rowElemList ) {
            // non-row-elem is beeing inserted
            DataRow row = rowElement.Row;
            // Region should already have an associated data row (otherwise how was the original row-elem inserted ?)
            Debug.Assert( row != null );
            SynchronizeRowFromRowElement( rowElement );
            if ( rowElemList != null ) {
                TreeIterator iter = new TreeIterator( node );
                for (bool fMore = iter.NextRowElement(); fMore; fMore = iter.NextRightRowElement() )
                    rowElemList.Add( iter.CurrentNode );
            }
        }

        // A non-row-elem was inserted into disconnected tree (fragment) from oldParent==null state (i.e. was disconnected)
        private void OnNonRowElementInsertedInFragment( XmlNode node, XmlBoundElement rowElement, ArrayList rowElemList ) {
            // non-row-elem is beeing inserted
            DataRow row = rowElement.Row;
            // Region should already have an associated data row (otherwise how was the original row-elem inserted ?)
            Debug.Assert( row != null );
            // Since oldParent == null, the only 2 row states should have been Detached or Deleted
            Debug.Assert( row.RowState == DataRowState.Detached || row.RowState == DataRowState.Deleted );

            if ( row.RowState == DataRowState.Detached )
                SynchronizeRowFromRowElementEx( rowElement, rowElemList );
            // Nothing to do if the row is deleted (there is no sync-ing from XML to ROM for deleted rows)
        }

        private void SetNestedParentRegion( XmlBoundElement childRowElem ) {
            Debug.Assert( childRowElem.Row != null );

            XmlBoundElement parentRowElem;
            mapper.GetRegion( childRowElem.ParentNode, out parentRowElem );
            SetNestedParentRegion( childRowElem, parentRowElem );
        }
        private void SetNestedParentRegion( XmlBoundElement childRowElem, XmlBoundElement parentRowElem ) {
            DataRow childRow = childRowElem.Row;
            if ( parentRowElem == null ) {
                SetNestedParentRow( childRow, null );
                return;
            }

            DataRow parentRow = parentRowElem.Row;
            Debug.Assert( parentRow != null );
            // We should set it only if there is a nested relationship between this child and parent regions
            DataRelation [] relations = childRow.Table.NestedParentRelations;
            if (relations.Length != 0 && relations[0].ParentTable == parentRow.Table ) // just backward compatable
                // 
                SetNestedParentRow( childRow, parentRow );
            else
                SetNestedParentRow( childRow, null );
        }

        internal static bool IsTextNode( XmlNodeType nt ) {
            switch( nt ) {
                case XmlNodeType.Text:
                case XmlNodeType.CDATA:
                case XmlNodeType.Whitespace:
                case XmlNodeType.SignificantWhitespace:
                    return true;
                default:
                    return false;
            }
        }

        /*
        internal static bool IsWhiteSpace(char ch) {
            switch ( ch ) {
                case '\u0009' :
                case '\u000a' :
                case '\u000d' :
                case '\u0020' :
                    return true;
                default :
                    return false;
            }
        }

        internal static bool IsOnlyWhitespace( string str ) {
            if (str != null) {
                for (int index = 0; index < str.Length; index ++) {
                    if (! IsWhiteSpace(str[index]))
                        return false;
                }
            }
            return true;
        }
        */

        /// <devdoc>
        ///    <para>[To be supplied.]</para>
        /// </devdoc>
        protected override XPathNavigator CreateNavigator(XmlNode node) {
            Debug.Assert( node.OwnerDocument == this || node == this );
            if ( XPathNodePointer.xmlNodeType_To_XpathNodeType_Map[(int)(node.NodeType)] == -1 )
                return null;
            if ( IsTextNode( node.NodeType ) ) {
                XmlNode parent = node.ParentNode;
                if ( parent != null && parent.NodeType == XmlNodeType.Attribute )
                    return null;
                else {
#if DEBUG
                    //if current node is a text node, its parent node has to be foliated
                    XmlBoundElement be = node.ParentNode as XmlBoundElement;
                    if ( be != null )
                        Debug.Assert( be.IsFoliated );
#endif
                    XmlNode prevSib = node.PreviousSibling;
                    while ( prevSib != null && IsTextNode( prevSib.NodeType ) ) {
                        node = prevSib;
                        prevSib = SafePreviousSibling( node );
                    }
                }
            }
            return new DataDocumentXPathNavigator( this, node );
        }

        [System.Diagnostics.Conditional("DEBUG")]
        private void AssertLiveRows( XmlNode node ) {
            bool wasFoliationEnabled = IsFoliationEnabled;
            IsFoliationEnabled = false;
            try {
                XmlBoundElement rowElement = node as XmlBoundElement;
                if ( rowElement != null && rowElement.Row != null )
                    Debug.Assert( IsRowLive( rowElement.Row ) );
                TreeIterator iter = new TreeIterator( node );
                for (bool fMore = iter.NextRowElement(); fMore; fMore = iter.NextRowElement() ) {
                    rowElement = iter.CurrentNode as XmlBoundElement;
                    Debug.Assert( rowElement.Row != null );
                    Debug.Assert( IsRowLive( rowElement.Row ) );
                }
            }
            finally {
                IsFoliationEnabled = wasFoliationEnabled;
            }
        }
        [System.Diagnostics.Conditional("DEBUG")]
        private void AssertNonLiveRows( XmlNode node ) {
            bool wasFoliationEnabled = IsFoliationEnabled;
            IsFoliationEnabled = false;
            try {
                XmlBoundElement rowElement = node as XmlBoundElement;
                if ( rowElement != null && rowElement.Row != null )
                    Debug.Assert( ! IsRowLive( rowElement.Row ) );
                TreeIterator iter = new TreeIterator( node );
                for (bool fMore = iter.NextRowElement(); fMore; fMore = iter.NextRowElement() ) {
                    rowElement = iter.CurrentNode as XmlBoundElement;
                    Debug.Assert( rowElement.Row != null );
                    Debug.Assert( ! IsRowLive( rowElement.Row ) );
                }
            }
            finally {
                IsFoliationEnabled = wasFoliationEnabled;
            }
        }

        public override XmlElement GetElementById( string elemId ) {
            throw new NotSupportedException( Res.GetString(Res.DataDom_NotSupport_GetElementById ) );
        }
        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;
        }

// Webdata 103397

//  after adding Namespace support foir datatable, DataSet does not guarantee that infered tabels would be in the same sequence as they rae in XML, because
//  of Namespace. if a table is in different namespace than its children and DataSet, that table would efinetely be added to DataSet after its children. Its By Design
// so in order to maintain backward compatability, we reorder the copy of the datatable collection and use it 
        private DataTable[] OrderTables(DataSet ds) {

            DataTable[] retValue = null;         
            if (ds == null ||ds.Tables.Count == 0) {
                retValue = new DataTable[0];
            }
            else if (TablesAreOrdered(ds)) {
                retValue =  new DataTable[ds.Tables.Count];
                ds.Tables.CopyTo(retValue, 0); 
		// XDD assumes PArent table exist before its child, if it does not we wont be handle the case
		// same as Everett
            }
            
            if (null == retValue) {
                retValue =  new DataTable[ds.Tables.Count];
                List<DataTable> tableList = new List<DataTable>(); 
                // first take the root tables that have no parent 
                foreach(DataTable dt in ds.Tables) {
                    if (dt.ParentRelations.Count == 0) {
                        tableList.Add(dt);
                    }
                }

                if (tableList.Count > 0) { // if we have some  table inside; 
                    foreach(DataTable dt in ds.Tables) {
                        if (IsSelfRelatedDataTable(dt)) {
                            tableList.Add(dt);
                        }
                    }
                    for(int readPos = 0 ; readPos < tableList.Count; readPos ++) {
                        Debug.Assert(tableList[readPos] != null, "Temp Array is not supposed to reach to null");
                        foreach(DataRelation r in  tableList[readPos].ChildRelations) {
                            DataTable childTable = r.ChildTable;
                            if (!tableList.Contains(childTable))
                                tableList.Add(childTable);
                        }
                    }
                    tableList.CopyTo(retValue);

                }
                else {//there will not be  any in case just if we have circular relation dependency, just copy as they are in tablecollection use CopyTo of the collection
                    ds.Tables.CopyTo(retValue, 0); 
                }
            }
            return retValue;        
        }
        private bool IsSelfRelatedDataTable(DataTable rootTable) {
            List<DataTable> tableList = new List<DataTable>(); 
            bool retValue = false;
            foreach(DataRelation r in  rootTable.ChildRelations) {
                DataTable childTable = r.ChildTable;
                if (childTable == rootTable) {
                    retValue = true;
                    break;
                }
                else if (!tableList.Contains(childTable)) {
                    tableList.Add(childTable);
                }
            }
            if (!retValue) {
                for(int counter = 0 ; counter < tableList.Count; counter++) {
                    foreach(DataRelation r in  tableList[counter].ChildRelations) {
                        DataTable childTable = r.ChildTable;
                        if (childTable == rootTable) {
                            retValue = true;
                            break;
                        }
                        else if (!tableList.Contains(childTable)) {
                            tableList.Add(childTable);
                        }
                    }
                    if (retValue){
                        break;
                    }
                }
            }
            return retValue;
        }
        private bool TablesAreOrdered(DataSet ds) {
            foreach(DataTable dt in ds.Tables){
                if (dt.Namespace != ds.Namespace) {
                    return false;
                }
            }
            return true;
        }
    }
}