File: src\Framework\System\Windows\Annotations\Storage\XmlStreamStore.cs
Project: wpf\PresentationFramework.csproj (PresentationFramework)
//-----------------------------------------------------------------------------
//
// <copyright file="XmlStreamStore.cs" company="Microsoft">
//    Copyright (C) Microsoft Corporation.  All rights reserved.
// </copyright>
//
// Description:
//     An AnnotationStore subclass based on XML streams.  Processes XML
//     streams and returns CAF 2.0 OM objects.  Useful to other
//     AnnotationStore subclass who can get an XML stream of their
//     content.
//     Spec: http://team/sites/ag/Specifications/CAF%20Storage%20Spec.doc
//
// History:
//  10/04/2002: rruiz:    Added header comment to XmlStreamStore.cs.
//  05/29/2003: LGolding: Ported to WCP tree.
//  07/17/2003: rruiz:    Made this a real AnnotationStore subclass; updated with
//                        new APIs; renamed class.
//  01/13/2004  ssimova:  Added revert events
//  02/12/2004  ssimova:  Added locks for thread safety
//  08/18/2004: magedz:   Modify the add/delete/querying capabilities to use the map
//
//-----------------------------------------------------------------------------
using System;
using System.Collections;
using System.Collections.Generic;
using System.Globalization;
using System.Diagnostics;
using System.IO;
using System.Windows;
using System.Windows.Annotations;
using System.Xml;
using System.Xml.Schema;
using System.Xml.XPath;
using System.Xml.Serialization;
using MS.Internal;
using MS.Internal.Annotations;
using MS.Internal.Annotations.Storage;
using MS.Utility;
using System.Windows.Markup;
using MS.Internal.Controls.StickyNote;
using System.Windows.Controls;
 
namespace System.Windows.Annotations.Storage
{
    /// <summary>
    ///     An AnnotationStore subclass based on XML streams.  Processes XML
    ///     streams and returns CAF 2.0 OM objects.  Useful to other
    ///     AnnotationStore subclass who can get an XML stream of their
    ///     content.
    /// </summary>
    public sealed class XmlStreamStore : AnnotationStore
    {
        //------------------------------------------------------
        //
        //  Constructors
        //
        //------------------------------------------------------
 
        #region Constructors
 
        /// <summary>
        /// This ctor initializes the Dictionary with predefined namespases
        /// and their compatibility
        /// </summary>
        static XmlStreamStore()
        {
            _predefinedNamespaces = new Dictionary<Uri, IList<Uri>>(6);
            _predefinedNamespaces.Add(new Uri(AnnotationXmlConstants.Namespaces.CoreSchemaNamespace), null);
            _predefinedNamespaces.Add(new Uri(AnnotationXmlConstants.Namespaces.BaseSchemaNamespace), null);
            _predefinedNamespaces.Add(new Uri(XamlReaderHelper.DefaultNamespaceURI), null);
        }
 
        /// <summary>
        ///     Creates an instance using the XML stream passed in as the
        ///     content. The XML in the stream must be valid XML and conform
        ///     to the CAF 2.0 schema.
        /// </summary>
        /// <param name="stream">stream containing annotation data in XML format</param>
        /// <exception cref="ArgumentNullException">stream is null</exception>
        /// <exception cref="XmlException">stream contains invalid XML</exception>
        public XmlStreamStore(Stream stream)
            : base()
        {
            if (stream == null)
                throw new ArgumentNullException("stream");
 
            if (!stream.CanSeek)
                throw new ArgumentException(SR.Get(SRID.StreamDoesNotSupportSeek));
 
            SetStream(stream, null);
        }
 
        /// <summary>
        ///     Creates an instance using the XML stream passed in as the
        ///     content. The XML in the stream must be valid XML and conform
        ///     to the Annotations V1 schema or a valid future version XML which
        ///     compatibility rules are that when applied they will produce
        ///     a valid Annotations V1 XML. This .ctor allows registration of
        ///     application specific known namespaces.
        /// </summary>
        /// <param name="stream">stream containing annotation data in XML format</param>
        /// <param name="knownNamespaces">A dictionary with known and compatible namespaces. The keys in
        /// this dictionary are known namespaces. The value of each key is a list of namespaces that are compatible with
        /// the key one, i.e. each of the namespaces in the value list will be transformed to the
        /// key namespace while reading the input XML.</param>
        /// <exception cref="ArgumentNullException">stream is null</exception>
        /// <exception cref="XmlException">stream contains invalid XML</exception>
        /// <exception cref="ArgumentException">duplicate namespace in knownNamespaces dictionary</exception>
        /// <exception cref="ArgumentException">null key in knownNamespaces dictionary</exception>
        public XmlStreamStore(Stream stream, IDictionary<Uri, IList<Uri>> knownNamespaces)
            : base()
        {
            if (stream == null)
                throw new ArgumentNullException("stream");
 
            SetStream(stream, knownNamespaces);
        }
 
        #endregion Constructors
 
        //------------------------------------------------------
        //
        //  Public Methods
        //
        //------------------------------------------------------
 
        #region Public Methods
 
        /// <summary>
        ///     Add a new annotation to this store.  The new annotation's Id
        ///     is set to a new value.
        /// </summary>
        /// <param name="newAnnotation">the annotation to be added to the store</param>
        /// <exception cref="ArgumentNullException">newAnnotation is null</exception>
        /// <exception cref="ArgumentException">newAnnotation already exists in this store, as determined by its Id</exception>
        /// <exception cref="InvalidOperationException">if no stream has been set on the store</exception>
        /// <exception cref="ObjectDisposedException">if object has been Disposed</exception>
        public override void AddAnnotation(Annotation newAnnotation)
        {
            if (newAnnotation == null)
                throw new ArgumentNullException("newAnnotation");
 
            // We are going to modify internal data. Lock the object
            // to avoid modifications from other threads
            lock (SyncRoot)
            {
 
                //fire trace event
                EventTrace.EasyTraceEvent(EventTrace.Keyword.KeywordAnnotation, EventTrace.Event.AddAnnotationBegin);
                try
                {
                    CheckStatus();
 
                    XPathNavigator editor = GetAnnotationNodeForId(newAnnotation.Id);
 
                    // we are making sure that the newAnnotation doesn't already exist in the store
                    if (editor != null)
                        throw new ArgumentException(SR.Get(SRID.AnnotationAlreadyExists), "newAnnotation");
 
                    // we are making sure that the newAnnotation doesn't already exist in the store map
                    if (_storeAnnotationsMap.FindAnnotation(newAnnotation.Id) != null)
                        throw new ArgumentException(SR.Get(SRID.AnnotationAlreadyExists), "newAnnotation");
 
                    // simply add the annotation to the map to save on performance
                    // notice that we need to tell the map that this instance of the annotation is dirty
                    _storeAnnotationsMap.AddAnnotation(newAnnotation, true);
                }
                finally
                {
                    //fire trace event
                    EventTrace.EasyTraceEvent(EventTrace.Keyword.KeywordAnnotation, EventTrace.Event.AddAnnotationEnd);
                }
 
            }
 
            OnStoreContentChanged(new StoreContentChangedEventArgs(StoreContentAction.Added, newAnnotation));
        }
 
        /// <summary>
        ///     Delete the specified annotation.
        /// </summary>
        /// <param name="annotationId">the Id of the annotation to be deleted</param>
        /// <returns>the annotation that was deleted, or null if no annotation
        /// with the specified Id was found</returns>
        /// <exception cref="InvalidOperationException">if no stream has been set on the store</exception>
        /// <exception cref="ObjectDisposedException">if object has been disposed</exception>
        public override Annotation DeleteAnnotation(Guid annotationId)
        {
            Annotation annotation = null;
 
            // We are now going to modify internal data. Lock the object
            // to avoid modifications from other threads
            lock (SyncRoot)
            {
 
                //fire trace event
                EventTrace.EasyTraceEvent(EventTrace.Keyword.KeywordAnnotation, EventTrace.Event.DeleteAnnotationBegin);
 
                try
                {
                    CheckStatus();
 
                    annotation = _storeAnnotationsMap.FindAnnotation(annotationId);
 
                    XPathNavigator editor = GetAnnotationNodeForId(annotationId);
                    if (editor != null)
                    {
                        // Only deserialize the annotation if its not already in our map
                        if (annotation == null)
                        {
                            annotation = (Annotation)_serializer.Deserialize(editor.ReadSubtree());
                        }
                        editor.DeleteSelf();
                    }
 
                    // Remove the instance from the map
                    _storeAnnotationsMap.RemoveAnnotation(annotationId);
 
                    // notice that in Add we add the annotation to the map only
                    // but in delete we delete it from both to the Xml and the map
 
                }
                finally
                {
                    //fire trace event
                    EventTrace.EasyTraceEvent(EventTrace.Keyword.KeywordAnnotation, EventTrace.Event.DeleteAnnotationEnd);
                }
            }
 
            // Only fire notification if we actually removed an annotation
            if (annotation != null)
            {
                OnStoreContentChanged(new StoreContentChangedEventArgs(StoreContentAction.Deleted, annotation));
            }
 
            return annotation;
        }
 
        /// <summary>
        ///     Queries the Xml stream for annotations that have an anchor
        ///     that contains a locator that begins with the locator parts
        ///     in anchorLocator.
        /// </summary>
        /// <param name="anchorLocator">the locator we are looking for</param>
        /// <returns>
        ///    A list of annotations that have locators in their anchors
        ///    starting with the same locator parts list as of the input locator
        ///    If no such annotations an empty list will be returned. The method
        ///    never returns null.
        /// </returns>
        /// <exception cref="ObjectDisposedException">if object has been Disposed</exception>
        /// <exception cref="InvalidOperationException">the stream is null</exception>
        public override IList<Annotation> GetAnnotations(ContentLocator anchorLocator)
        {
            // First we generate the XPath expression
            if (anchorLocator == null)
                throw new ArgumentNullException("anchorLocator");
 
            if (anchorLocator.Parts == null)
                throw new ArgumentNullException("anchorLocator.Parts");
 
            //fire trace event
            EventTrace.EasyTraceEvent(EventTrace.Keyword.KeywordAnnotation, EventTrace.Event.GetAnnotationByLocBegin);
            IList<Annotation> annotations = null;
            try
            {
                string query = @"//" + AnnotationXmlConstants.Prefixes.CoreSchemaPrefix + ":" + AnnotationXmlConstants.Elements.ContentLocator;
 
                if (anchorLocator.Parts.Count > 0)
                {
                    query += @"/child::*[1]/self::";
                    for (int i = 0; i < anchorLocator.Parts.Count; i++)
                    {
                        if (anchorLocator.Parts[i] != null)
                        {
                            if (i > 0)
                            {
                                query += @"/following-sibling::";
                            }
 
                            string fragment = anchorLocator.Parts[i].GetQueryFragment(_namespaceManager);
 
                            if (fragment != null)
                            {
                                query += fragment;
                            }
                            else
                            {
                                query += "*";
                            }
                        }
                    }
                }
 
                query += @"/ancestor::" + AnnotationXmlConstants.Prefixes.CoreSchemaPrefix + ":Anchors/ancestor::" + AnnotationXmlConstants.Prefixes.CoreSchemaPrefix + ":Annotation";
 
                annotations = InternalGetAnnotations(query, anchorLocator);
            }
            finally
            {
                //fire trace event
                EventTrace.EasyTraceEvent(EventTrace.Keyword.KeywordAnnotation, EventTrace.Event.GetAnnotationByLocEnd);
            }
 
            return annotations;
        }
 
        /// <summary>
        /// Returns a list of all annotations in the store
        /// </summary>
        /// <returns>annotations list. Can return an empty list, but never null.</returns>
        /// <exception cref="ObjectDisposedException">if object has been disposed</exception>
        public override IList<Annotation> GetAnnotations()
        {
            IList<Annotation> annotations = null;
            //fire trace event
            EventTrace.EasyTraceEvent(EventTrace.Keyword.KeywordAnnotation, EventTrace.Event.GetAnnotationsBegin);
            try
            {
 
                string query = "//" + AnnotationXmlConstants.Prefixes.CoreSchemaPrefix + ":Annotation";
 
                annotations = InternalGetAnnotations(query, null);
            }
            finally
            {
                EventTrace.EasyTraceEvent(EventTrace.Keyword.KeywordAnnotation, EventTrace.Event.GetAnnotationsEnd);
            }
            return annotations;
 
        }
 
        /// <summary>
        /// Finds annotation by Id
        /// </summary>
        /// <param name="annotationId">annotation id</param>
        /// <returns>The annotation. Null if the annotation does not exists</returns>
        /// <exception cref="ObjectDisposedException">if object has been disposed</exception>
        public override Annotation GetAnnotation(Guid annotationId)
        {
            lock (SyncRoot)
            {
                Annotation annotation = null;
                //fire trace event
                EventTrace.EasyTraceEvent(EventTrace.Keyword.KeywordAnnotation, EventTrace.Event.GetAnnotationByIdBegin);
                try
                {
                    CheckStatus();
 
                    annotation = _storeAnnotationsMap.FindAnnotation(annotationId);
 
                    // If there is no pre-existing instance, we deserialize and create an instance.
                    if (annotation != null)
                    {
                        return annotation;
                    }
 
                    XPathNavigator editor = GetAnnotationNodeForId(annotationId);
                    if (editor != null)
                    {
                        annotation = (Annotation)_serializer.Deserialize(editor.ReadSubtree());
 
                        // Add the new instance to the map
                        _storeAnnotationsMap.AddAnnotation(annotation, false);
                    }
                }
                finally
                {
                    //fire trace event
                    EventTrace.EasyTraceEvent(EventTrace.Keyword.KeywordAnnotation, EventTrace.Event.GetAnnotationByIdEnd);
                }
                return annotation;
            }
        }
 
        /// <summary>
        ///     Causes any buffered data to be written to the underlying
        ///     storage mechanism.  Gets called after each operation if
        ///     AutoFlush is set to true.  The stream is truncated to
        ///     the length of the data written out by the store.
        /// </summary>
        /// <exception cref="UnauthorizedAccessException">stream cannot be written to</exception>
        /// <exception cref="InvalidOperationException">if no stream has been set on the store</exception>
        /// <exception cref="ObjectDisposedException">if object has been disposed</exception>
        /// <seealso cref="AutoFlush"/>
        public override void Flush()
        {
            lock (SyncRoot)
            {
                CheckStatus();
                if (!_stream.CanWrite)
                {
                    throw new UnauthorizedAccessException(SR.Get(SRID.StreamCannotBeWritten));
                }
 
                if (_dirty)
                {
                    SerializeAnnotations();
                    _stream.Position = 0;
                    _stream.SetLength(0);
                    _document.PreserveWhitespace = true;
                    _document.Save(_stream);
                    _stream.Flush();
                    _dirty = false;
                }
            }
        }
 
        /// <summary>
        /// Returns a list of namespaces that are compatible with an  input namespace
        /// </summary>
        /// <param name="name">namespace</param>
        /// <returns>a list of compatible namespaces. Can be null</returns>
        /// <remarks>This method works only with built-in AnnotationFramework namespaces.
        /// For any other input namespace the return value will be null even if it is
        /// registered with the XmlStreamStore ctor</remarks>
        public static IList<Uri> GetWellKnownCompatibleNamespaces(Uri name)
        {
            if (name == null)
            {
                throw new ArgumentNullException("name");
            }
            if (_predefinedNamespaces.ContainsKey(name))
                return _predefinedNamespaces[name];
            return null;
        }
 
        #endregion Public Methods
 
        //------------------------------------------------------
        //
        //  Public Operators
        //
        //------------------------------------------------------
        //------------------------------------------------------
        //
        //  Public Events
        //
        //------------------------------------------------------
        //------------------------------------------------------
        //
        //  Public Properties
        //
        //------------------------------------------------------
 
        #region Public Properties
 
        /// <summary>
        ///     When set to true an implementation should call Flush()
        ///     as a side-effect after each operation.
        /// </summary>
        /// <value>
        ///     true if the implementation is set to call Flush() after
        ///     each operation; false otherwise
        /// </value>
        public override bool AutoFlush
        {
            get
            {
                lock (SyncRoot)
                {
                    return _autoFlush;
                }
            }
            set
            {
                lock (SyncRoot)
                {
                    _autoFlush = value;
 
                    // Commit anything that needs to be committed up to this point
                    if (_autoFlush)
                    {
                        Flush();
                    }
                }
            }
        }
 
        /// <summary>
        /// Returns a list of the namespaces that are ignored while loading
        /// the Xml stream
        /// </summary>
        /// <remarks>The value is never null, but can be an empty list if nothing has been ignored</remarks>
        public IList<Uri> IgnoredNamespaces
        {
            get
            {
                return _ignoredNamespaces;
            }
        }
 
        /// <summary>
        /// Returns a list of all namespaces that are internaly used by the framework
        /// </summary>
        public static IList<Uri> WellKnownNamespaces
        {
            get
            {
                Uri[] res = new Uri[_predefinedNamespaces.Keys.Count];
                _predefinedNamespaces.Keys.CopyTo(res, 0);
                return res;
            }
        }
 
 
        #endregion Public Properties
 
        //------------------------------------------------------
        //
        //  Protected Methods
        //
        //------------------------------------------------------
 
        #region Protected Methods
 
        /// <summary>
        ///     Disposes of the resources (other than memory) used by the store.
        /// </summary>
        /// <param name="disposing">true to release both managed and unmanaged
        /// resources; false to release only unmanaged resources</param>
        protected override void Dispose(bool disposing)
        {
            //call the base class first to set _disposed to false
            //in order to avoid working with the store when the resources
            //are released
            base.Dispose(disposing);
 
            if (disposing)
            {
                Cleanup();
            }
        }
 
        /// <summary>
        ///     Called after every annotation action on the store.  We override it
        ///     to update the dirty state of the store.
        /// </summary>
        /// <param name="e">arguments for the event to fire</param>
        protected override void OnStoreContentChanged(StoreContentChangedEventArgs e)
        {
            lock (SyncRoot)
            {
                _dirty = true;
            }
 
            base.OnStoreContentChanged(e);
        }
 
        #endregion Protected Methods
 
        //------------------------------------------------------
        //
        //  Private Methods
        //
        //------------------------------------------------------
 
        #region Private Methods
 
        /// <summary>
        ///     Applies the specified XPath expression to the store and returns
        ///     the results.
        /// </summary>
        /// <param name="queryExpression">the XPath expression to be applied to the store</param>
        /// <returns>
        ///     An IList containing zero or more annotations that match the
        ///     criteria in the XPath expression; never will return null.  If
        ///     no annotations meet the criteria, an empty list is returned.
        /// </returns>
        /// <exception cref="InvalidOperationException">if no stream has been set on the store</exception>
        /// <exception cref="ObjectDisposedException">if object has been Disposed</exception>
        /// <exception cref="ArgumentNullException">queryExpression is null</exception>
        /// <exception cref="ArgumentException">queryExpression is empty string</exception>
        private List<Guid> FindAnnotationIds(string queryExpression)
        {
            Invariant.Assert(queryExpression != null && queryExpression.Length > 0,
                          "Invalid query expression");
 
            Guid annId;
            List<Guid> retObj = null;
 
            // Lock the object so nobody can change the document
            // while the query is executed
            lock (SyncRoot)
            {
                CheckStatus();
 
                XPathNavigator navigator = _document.CreateNavigator();
                XPathNodeIterator iterator = navigator.Select(queryExpression, _namespaceManager);
 
                if (iterator != null && iterator.Count > 0)
                {
                    retObj = new List<Guid>(iterator.Count);
                    foreach (XPathNavigator node in iterator)
                    {
                        string nodeId = node.GetAttribute("Id", "");
                        if (String.IsNullOrEmpty(nodeId))
                        {
                            throw new XmlException(SR.Get(SRID.RequiredAttributeMissing, AnnotationXmlConstants.Attributes.Id, AnnotationXmlConstants.Elements.Annotation));
                        }
 
                        try
                        {
                            annId = XmlConvert.ToGuid(nodeId);
                        }
                        catch (FormatException fe)
                        {
                            throw new InvalidOperationException(SR.Get(SRID.CannotParseId), fe);
                        }
 
                        retObj.Add(annId);
                    }
                }
                else
                {
                    retObj = new List<Guid>(0);
                }
            }
 
            return retObj;
        }
 
        /// <summary>
        ///     Used as AuthorChanged event handler for all annotations
        ///     handed out by the map.
        /// </summary>
        /// <param name="sender">annotation that sent the event</param>
        /// <param name="e">args for the event</param>
        private void HandleAuthorChanged(object sender, AnnotationAuthorChangedEventArgs e)
        {
            lock (SyncRoot)
            {
                _dirty = true;
            }
 
            OnAuthorChanged(e);
        }
 
        /// <summary>
        ///     Used as AnchorChanged event handler for all annotations
        ///     handed out by the map.
        /// </summary>
        /// <param name="sender">annotation that sent the event</param>
        /// <param name="e">args for the event</param>
        private void HandleAnchorChanged(object sender, AnnotationResourceChangedEventArgs e)
        {
            lock (SyncRoot)
            {
                _dirty = true;
            }
 
            OnAnchorChanged(e);
        }
 
        /// <summary>
        ///     Used as CargoChanged event handler for all annotations
        ///     handed out by the map.
        /// </summary>
        /// <param name="sender">annotation that sent the event</param>
        /// <param name="e">args for the event</param>
        private void HandleCargoChanged(object sender, AnnotationResourceChangedEventArgs e)
        {
            lock (SyncRoot)
            {
                _dirty = true;
            }
 
            OnCargoChanged(e);
        }
 
        /// <summary>
        /// 1- Merge Annotations queried from both the map and the Xml stream
        /// 2- Add the annotations found in the Xml stream to the map
        /// </summary>
        /// <param name="mapAnnotations">A dictionary of map annotations</param>
        /// <param name="storeAnnotationsId">A list of annotation ids from the Xml stream</param>
        /// <returns></returns>
        private IList<Annotation> MergeAndCacheAnnotations(Dictionary<Guid, Annotation> mapAnnotations, List<Guid> storeAnnotationsId)
        {
            // first put all annotations from the map in the return list
            List<Annotation> annotations = new List<Annotation>((IEnumerable<Annotation>)mapAnnotations.Values);
 
            // there three possible conditions
            // 1- An annotation exists in xml and in the store map results
            // 2- An annotation exists in xml and not in the store map results
            //      2-1- The annotation is found in the map
            //      2-2- The annotation is not found in the map
 
            // Now, we need to find annotations in the store that are not in the map results
            // and verify that they should be serialized
            foreach (Guid annotationId in storeAnnotationsId)
            {
                Annotation annot;
                bool foundInMapResults = mapAnnotations.TryGetValue(annotationId, out annot);
                if (!foundInMapResults)
                {
                    // it is not in the map - get it from the store
                    annot = GetAnnotation(annotationId);
                    annotations.Add(annot);
                }
            }
 
            return annotations;
        }
 
        /// <summary>
        /// Do the GetAnnotations work inside a lock statement for thread safety reasons
        /// </summary>
        /// <param name="query"></param>
        /// <param name="anchorLocator"></param>
        /// <returns></returns>
        private IList<Annotation> InternalGetAnnotations(string query, ContentLocator anchorLocator)
        {
            // anchorLocator being null is handled appropriately below
            Invariant.Assert(query != null, "Parameter 'query' is null.");
 
            lock (SyncRoot)
            {
                CheckStatus();
 
                List<Guid> annotationIds = FindAnnotationIds(query);
                Dictionary<Guid, Annotation> annotations = null;
 
                // Now, get the annotations in the map that satisfies the query criterion
                if (anchorLocator == null)
                {
                    annotations = _storeAnnotationsMap.FindAnnotations();
                }
                else
                {
                    annotations = _storeAnnotationsMap.FindAnnotations(anchorLocator);
                }
 
                // merge both query results
                return MergeAndCacheAnnotations(annotations, annotationIds);
            }
        }
 
 
        /// <summary>
        ///     Loads the current stream into the XmlDocument used by this
        ///     store as a backing store.  If the stream doesn't contain any
        ///     data we load up a default XmlDocument for the Annotations schema.
        ///     The "http://schemas.microsoft.com/windows/annotations/2003/11/core"
        ///     namespace is registered with "anc" prefix and the
        ///    "http://schemas.microsoft.com/windows/annotations/2003/11/base" namespace
        ///     is registered with "anb" prefix as global namespaces.
        ///     We also select from the newly loaded document the new top
        ///     level node.  This is used later for insertions, etc.
        /// </summary>
        /// <exception cref="XmlException">if the stream contains invalid XML</exception>
        private void LoadStream(IDictionary<Uri, IList<Uri>> knownNamespaces)
        {
            //check input data first
            CheckKnownNamespaces(knownNamespaces);
 
            lock (SyncRoot)
            {
                _document = new XmlDocument();
                _document.PreserveWhitespace = false;
                if (_stream.Length == 0)
                {
                    _document.LoadXml("<?xml version=\"1.0\" encoding=\"utf-8\"?> <" +
                        AnnotationXmlConstants.Prefixes.CoreSchemaPrefix + ":Annotations xmlns:" + AnnotationXmlConstants.Prefixes.CoreSchemaPrefix + "=\"" +
                        AnnotationXmlConstants.Namespaces.CoreSchemaNamespace + "\" xmlns:" + AnnotationXmlConstants.Prefixes.BaseSchemaPrefix + "=\"" + AnnotationXmlConstants.Namespaces.BaseSchemaNamespace + "\" />");
                }
                else
                {
                    _xmlCompatibilityReader = SetupReader(knownNamespaces);
                    _document.Load(_xmlCompatibilityReader);
                }
 
                _namespaceManager = new XmlNamespaceManager(_document.NameTable);
                _namespaceManager.AddNamespace(AnnotationXmlConstants.Prefixes.CoreSchemaPrefix, AnnotationXmlConstants.Namespaces.CoreSchemaNamespace);
                _namespaceManager.AddNamespace(AnnotationXmlConstants.Prefixes.BaseSchemaPrefix, AnnotationXmlConstants.Namespaces.BaseSchemaNamespace);
 
                // This use of an iterator is necessary because SelectSingleNode isn't available in the PD3
                // drop of the CLR.  Eventually we should be able to call SelectSingleNode and not have to
                // use an iterator to get a single node.
 
                XPathNavigator navigator = _document.CreateNavigator();
                XPathNodeIterator iterator = navigator.Select("//" + AnnotationXmlConstants.Prefixes.CoreSchemaPrefix + ":Annotations", _namespaceManager);
                Invariant.Assert(iterator.Count == 1, "More than one annotation returned for the query");
 
                iterator.MoveNext();
                _rootNavigator = (XPathNavigator)iterator.Current;
            }
        }
 
        /// <summary>
        /// Checks if passed external known namespaces are valid
        /// </summary>
        /// <param name="knownNamespaces">namespaces dictionary</param>
        /// <remarks>We do not allow internal namespases in this dictionary nor
        /// duplicates</remarks>
        private void CheckKnownNamespaces(IDictionary<Uri, IList<Uri>> knownNamespaces)
        {
            if (knownNamespaces == null)
                return;
 
            IList<Uri> allNamespaces = new List<Uri>();
 
            //add AnnotationFramework namespaces
            foreach (Uri name in _predefinedNamespaces.Keys)
            {
                allNamespaces.Add(name);
            }
 
            //add external namespaces
            foreach (Uri knownNamespace in knownNamespaces.Keys)
            {
                if (knownNamespace == null)
                {
                    throw new ArgumentException(SR.Get(SRID.NullUri), "knownNamespaces");
                }
                if (allNamespaces.Contains(knownNamespace))
                {
                    throw new ArgumentException(SR.Get(SRID.DuplicatedUri), "knownNamespaces");
                }
                allNamespaces.Add(knownNamespace);
            }
 
            // check compatible namespaces
            foreach (KeyValuePair<Uri, IList<Uri>> item in knownNamespaces)
            {
                if (item.Value != null)
                {
                    foreach (Uri name in item.Value)
                    {
                        if (name == null)
                        {
                            throw new ArgumentException(SR.Get(SRID.NullUri), "knownNamespaces");
                        }
 
                        if (allNamespaces.Contains(name))
                        {
                            throw new ArgumentException(SR.Get(SRID.DuplicatedCompatibleUri), "knownNamespaces");
                        }
                        allNamespaces.Add(name);
                    }//foreach
                }//if
 
            }//foreach
 
        }
 
        /// <summary>
        /// Creates and initializes the XmlCompatibilityReader
        /// </summary>
        /// <param name="knownNamespaces">Dictionary of external known namespaces</param>
        /// <returns>The XmlCompatibilityReader</returns>
        private XmlCompatibilityReader SetupReader(IDictionary<Uri, IList<Uri>> knownNamespaces)
        {
            IList<string> supportedNamespaces = new List<string>();
 
            //add AnnotationFramework namespaces
            foreach (Uri name in _predefinedNamespaces.Keys)
            {
                supportedNamespaces.Add(name.ToString());
            }
 
            //add external namespaces
            if (knownNamespaces != null)
            {
                foreach (Uri knownNamespace in knownNamespaces.Keys)
                {
                    Debug.Assert(knownNamespace != null, "null knownNamespace");
                    supportedNamespaces.Add(knownNamespace.ToString());
                }
            }
 
            //create XmlCompatibilityReader first
            XmlCompatibilityReader reader = new XmlCompatibilityReader(new XmlTextReader(_stream),
            new IsXmlNamespaceSupportedCallback(IsXmlNamespaceSupported), supportedNamespaces);
 
            // Declare compatibility.
            // Skip the Framework ones because they are all null in this version
            if (knownNamespaces != null)
            {
                foreach (KeyValuePair<Uri, IList<Uri>> item in knownNamespaces)
                {
                    if (item.Value != null)
                    {
                        foreach (Uri name in item.Value)
                        {
                            Debug.Assert(name != null, "null compatible namespace");
                            reader.DeclareNamespaceCompatibility(item.Key.ToString(), name.ToString());
                        }//foreach
                    }//if
 
                }//foreach
 
            }//if
 
            //cleanup the _ignoredNamespaces
            _ignoredNamespaces.Clear();
            return reader;
 
        }
 
        /// <summary>
        /// A callback for XmlCompatibilityReader
        /// </summary>
        /// <param name="xmlNamespace">inquired namespace</param>
        /// <param name="newXmlNamespace">the newer subsumming namespace</param>
        /// <returns>true if the namespace is known, false if not</returns>
        /// <remarks>This API always returns false because all known namespaces are registered
        /// before loading the Xml. It stores the namespace as ignored.</remarks>
        private bool IsXmlNamespaceSupported(string xmlNamespace, out string newXmlNamespace)
        {
 
            //store the namespace if needed
            if (!String.IsNullOrEmpty(xmlNamespace))
            {
                if (!Uri.IsWellFormedUriString(xmlNamespace, UriKind.RelativeOrAbsolute))
                {
                    throw new ArgumentException(SR.Get(SRID.InvalidNamespace, xmlNamespace), "xmlNamespace");
                }
                Uri namespaceUri = new Uri(xmlNamespace, UriKind.RelativeOrAbsolute);
                if (!_ignoredNamespaces.Contains(namespaceUri))
                    _ignoredNamespaces.Add(namespaceUri);
            }
 
            newXmlNamespace = null;
            return false;
        }
 
 
 
        /// <summary>
        ///     Selects the annotation XmlElement from the current document
        ///     with the given id.
        /// </summary>
        /// <param name="id">the id to query for in the XmlDocument</param>
        /// <returns>the XmlElement representing the annotation with the given id</returns>
        private XPathNavigator GetAnnotationNodeForId(Guid id)
        {
            XPathNavigator navigator = null;
 
            lock (SyncRoot)
            {
                XPathNavigator tempNavigator = _document.CreateNavigator();
 
                // This use of an iterator is necessary because SelectSingleNode isn't available in the PD3
                // drop of the CLR.  Eventually we should be able to call SelectSingleNode and not have to
                // use an iterator to get a single node.
 
                // We use XmlConvert.ToString to turn the Guid into a string because
                // that's what is used by the Annotation's serialization methods.
                XPathNodeIterator iterator = tempNavigator.Select(@"//" + AnnotationXmlConstants.Prefixes.CoreSchemaPrefix + @":Annotation[@Id=""" + XmlConvert.ToString(id) + @"""]", _namespaceManager);
                if (iterator.MoveNext())
                {
                    navigator = (XPathNavigator)iterator.Current;
                }
            }
 
            return navigator;
        }
 
        /// <summary>
        ///    Verifies the store is in a valid state.  Throws exceptions otherwise.
        /// </summary>
        private void CheckStatus()
        {
            lock (SyncRoot)
            {
                if (IsDisposed)
                    throw new ObjectDisposedException(null, SR.Get(SRID.ObjectDisposed_StoreClosed));
 
                if (_stream == null)
                    throw new InvalidOperationException(SR.Get(SRID.StreamNotSet));
            }
        }
 
        /// <summary>
        /// Called from flush to serialize all annotations in the map
        /// notice that delete takes care of the delete action both in the map
        /// and in the store
        /// </summary>
        private void SerializeAnnotations()
        {
            List<Annotation> mapAnnotations = _storeAnnotationsMap.FindDirtyAnnotations();
            foreach (Annotation annotation in mapAnnotations)
            {
                XPathNavigator editor = GetAnnotationNodeForId(annotation.Id);
                if (editor == null)
                {
                    editor = (XPathNavigator)_rootNavigator.CreateNavigator();
                    XmlWriter writer = editor.AppendChild();
                    _serializer.Serialize(writer, annotation);
                    writer.Close();
                }
                else
                {
                    XmlWriter writer = editor.InsertBefore();
                    _serializer.Serialize(writer, annotation);
                    writer.Close();
                    editor.DeleteSelf();
                }
            }
            _storeAnnotationsMap.ValidateDirtyAnnotations();
        }
 
        /// <summary>
        ///    Discards changes and cleans up references.
        /// </summary>
        private void Cleanup()
        {
            lock (SyncRoot)
            {
                _xmlCompatibilityReader = null;
                _ignoredNamespaces = null;
                _stream = null;
                _document = null;
                _rootNavigator = null;
                _storeAnnotationsMap = null;
            }
        }
 
        /// <summary>
        ///     Sets the stream for this store.  Assumes Cleanup has
        ///     been previously called (or this is a new store).
        /// </summary>
        /// <param name="stream">new stream for this store</param>
        /// <param name="knownNamespaces">List of known and compatible namespaces used to initialize
        /// the XmlCompatibilityReader</param>
        private void SetStream(Stream stream, IDictionary<Uri, IList<Uri>> knownNamespaces)
        {
            try
            {
                lock (SyncRoot)
                {
                    _storeAnnotationsMap = new StoreAnnotationsMap(HandleAuthorChanged, HandleAnchorChanged, HandleCargoChanged);
                    _stream = stream;
                    LoadStream(knownNamespaces);
                }
            }
            catch
            {
                Cleanup();
                throw;
            }
        }
 
        #endregion Private Methods
 
        //------------------------------------------------------
        //
        //  Private Fields
        //
        //------------------------------------------------------
 
        #region Private Fields
 
        // Dirty bit for the store's in-memory cache
        private bool _dirty;
        // Boolean flag represents whether the store should perform a flush
        // after every operation or not
        private bool _autoFlush;
        // XmlDocument used as an in-memory cache of the stream's XML content
        private XmlDocument _document;
        // Namespace manager used for all queries.
        private XmlNamespaceManager _namespaceManager;
        // Stream passed in by the creator of this instance.
        private Stream _stream;
        // The xpath navigator used to navigate the annotations Xml stream
        private XPathNavigator _rootNavigator;
        // map that holds AnnotationId->Annotation
        StoreAnnotationsMap _storeAnnotationsMap;
        //list of ignored namespaces during XmlLoad
        List<Uri> _ignoredNamespaces = new List<Uri>();
 
        //XmlCompatibilityReader - we need to hold that one open, so the underlying stream stays open too
        // if the store is disposed the reader will be disposed and the stream will be closed too.
        XmlCompatibilityReader _xmlCompatibilityReader;
 
        ///
        ///Static fields
        ///
 
        //predefined namespaces
        private static readonly Dictionary<Uri, IList<Uri>> _predefinedNamespaces;
        // Serializer for Annotations
        private static readonly Serializer _serializer = new Serializer(typeof(Annotation));
 
#endregion Private Fields
 
    }
}