StoreAnnotationsMap.cs source code in C# .NET

                        
Code:
                         / Dotnetfx_Win7_3.5.1 / Dotnetfx_Win7_3.5.1 / 3.5.1 / DEVDIV / depot / DevDiv / releases / Orcas / NetFXw7 / wpf / src / Framework / MS / Internal / Annotations / Storage / StoreAnnotationsMap.cs / 1 / StoreAnnotationsMap.cs
                        

                        
                            //------------------------------------------------------------------------------ 
//
// 
//    Copyright (C) Microsoft Corporation.  All rights reserved.
//  
//
// Description: 
//     Map of annotation instances handed out by a particular store. 
//     Used to guarantee only one instance of an annotation is ever
//     produced.  Also register for notifications on the instances 
//     and passes change notifications on to the store.
//
//     Spec: http://team/sites/ag/Specifications/CAF%20Storage%20Spec.doc
// 
// History:
//  07/15/2004: magedz:    Added new class. 
//  08/18/2004: magedz:    Added querying capabilities to the map to improve performance 
//  10/20/2004:  rruiz:    Moved class to MS.Internal.
// 
//-----------------------------------------------------------------------------
using System;
using System.Collections.Generic;
using System.Globalization; 
using System.Diagnostics;
using System.IO; 
using System.Windows; 
using System.Windows.Annotations;
using MS.Utility; 


namespace MS.Internal.Annotations.Storage
{ 
    /// 

    /// A map the store uses to maintain having one instance 
    /// of the object model 
    /// 
    internal class StoreAnnotationsMap 
    {
        //-----------------------------------------------------
        //
        //  Constructors 
        //
        //----------------------------------------------------- 
 
        #region Constructors
 
        /// 

        /// Constructor for StoreAnnotationsMap
        /// It takes instances of the AnnotationAuthorChangedEventHandler, AnnotationResourceChangedEventHandler, AnnotationResourceChangedEventHandler delegates
        /// 
 
        /// delegate used to register for AuthorChanged events on all annotations
        /// delegate used to register for AnchorChanged events on all annotations 
        /// delegate used to register for CargoChanged events on all annotations 
        internal StoreAnnotationsMap(AnnotationAuthorChangedEventHandler authorChanged, AnnotationResourceChangedEventHandler anchorChanged, AnnotationResourceChangedEventHandler cargoChanged)
        { 
            Debug.Assert(authorChanged != null && anchorChanged != null && cargoChanged != null,
                         "Author and Anchor and Cargo must not be null");

            _authorChanged = authorChanged; 
            _anchorChanged = anchorChanged;
            _cargoChanged = cargoChanged; 
        } 

        #endregion Constructors 

        //------------------------------------------------------
        //
        //  Public Methods 
        //
        //----------------------------------------------------- 
 
        #region Public Methods
 
        /// 

        /// Add an annotation to the map
        /// throws an exception if the annotation already exists
        /// 
 
        /// instance of annotation to add to the map
        /// the initial dirty flag of the annotation in the map 
        public void AddAnnotation(Annotation annotation, bool dirty) 
        {
            Debug.Assert(FindAnnotation(annotation.Id) == null, "annotation  not found"); 
            annotation.AuthorChanged += OnAuthorChanged;
            annotation.AnchorChanged += OnAnchorChanged;
            annotation.CargoChanged += OnCargoChanged;
            _currentAnnotations.Add(annotation.Id, new CachedAnnotation(annotation, dirty)); 
        }
 
        /// 
 
        /// remove an annotation from the map if it exists
        /// otherwise return 
        /// 
        /// id of the annotation to remove
        public void RemoveAnnotation(Guid id)
        { 
            CachedAnnotation existingCachedAnnot = null;
            if (_currentAnnotations.TryGetValue(id, out existingCachedAnnot)) 
            { 
                existingCachedAnnot.Annotation.AuthorChanged -= OnAuthorChanged;
                existingCachedAnnot.Annotation.AnchorChanged -= OnAnchorChanged; 
                existingCachedAnnot.Annotation.CargoChanged -= OnCargoChanged;
                _currentAnnotations.Remove(id);
            }
        } 

        /// 
 
        ///     Queries the store map for annotations that have an anchor 
        ///     that contains a locator that begins with the locator parts
        ///     in anchorLocator. 
        /// 
        /// the locator we are looking for
        /// 
        ///    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. 
        /// 
        public Dictionary FindAnnotations(ContentLocator anchorLocator) 
        {
            if (anchorLocator == null)
                throw new ArgumentNullException("locator");
 
            Dictionary annotations = new Dictionary();
 
            // 

 
            Dictionary.ValueCollection.Enumerator annotationsEnumerator = _currentAnnotations.Values.GetEnumerator();

            while (annotationsEnumerator.MoveNext())
            { 
                Annotation annotation = annotationsEnumerator.Current.Annotation;
                bool matchesQuery = false; 
 
                foreach (AnnotationResource resource in annotation.Anchors)
                { 
                    foreach (ContentLocatorBase locator in resource.ContentLocators)
                    {
                        ContentLocator ContentLocator = locator as ContentLocator;
                        if (ContentLocator != null) 
                        {
                            if (ContentLocator.StartsWith(anchorLocator)) 
                            { 
                                matchesQuery = true;
                            } 
                        }
                        else
                        {
                            ContentLocatorGroup ContentLocatorGroup = locator as ContentLocatorGroup; 
                            if (ContentLocatorGroup != null)
                            { 
                                foreach(ContentLocator list in ContentLocatorGroup.Locators) 
                                {
                                    if (list.StartsWith(anchorLocator)) 
                                    {
                                        matchesQuery = true;
                                        break;
                                    } 
                                }
                            } 
                        } 

                        if (matchesQuery) 
                        {
                            annotations.Add(annotation.Id, annotation);
                            break;
                        } 
                    }
 
                    if (matchesQuery) 
                        break;
                } 
            }

            return annotations;
        } 

        /// 
 
        /// Returns a dictionary of all annotations in the map 
        /// 
        /// annotations list. Can return an empty list, but never null. 
        public Dictionary FindAnnotations()
        {
            Dictionary annotations = new Dictionary();
            foreach (KeyValuePair annotKV in _currentAnnotations) 
            {
                annotations.Add(annotKV.Key, annotKV.Value.Annotation); 
            } 
            return annotations;
        } 

        /// 

        /// Find an annottaion that has a specific id in the map
        /// returns null if not found 
        /// 
        /// id of the annotation to find 
        public Annotation FindAnnotation(Guid id) 
        {
            CachedAnnotation cachedAnnotation = null; 
            if (_currentAnnotations.TryGetValue(id, out cachedAnnotation))
            {
                return cachedAnnotation.Annotation;
            } 

            return null; 
        } 

        /// 
 
        /// Returns a list of all dirty annotations in the map
        /// 
        /// annotations list. Can return an empty list, but never null.
        public List FindDirtyAnnotations() 
        {
            List annotations = new List(); 
            foreach (KeyValuePair annotKV in _currentAnnotations) 
            {
                if (annotKV.Value.Dirty) 
                {
                    annotations.Add(annotKV.Value.Annotation);
                }
            } 

            return annotations; 
        } 

        /// 
 
        /// Sets all the dirty annotations in the map to clean
        /// 
        public void ValidateDirtyAnnotations()
        { 
            foreach (KeyValuePair annotKV in _currentAnnotations)
            { 
                if (annotKV.Value.Dirty) 
                {
                    annotKV.Value.Dirty = false; 
                }
            }
        }
 
        #endregion Public Methods
 
        //------------------------------------------------------ 
        //
        //  Private Methods 
        //
        //------------------------------------------------------

        #region Private Methods 

        /// 
 
        /// the event handler for AnchorChanged Annotation event 
        /// internally it calls the store AnnotationModified delegate
        /// 
 
        /// annotation that changed
        /// args describing the change
        private void OnAnchorChanged(object sender, AnnotationResourceChangedEventArgs args)
        { 
            _currentAnnotations[args.Annotation.Id].Dirty = true;
            _anchorChanged(sender, args); 
        } 

        /// 
 
        /// the event handler for CargoChanged Annotation event
        /// internally it calls the store AnnotationModified delegate
        /// 
        /// annotation that changed 
        /// args describing the change
        private void OnCargoChanged(object sender, AnnotationResourceChangedEventArgs args) 
        { 
            _currentAnnotations[args.Annotation.Id].Dirty = true;
            _cargoChanged(sender, args); 
        }

        /// 

        /// the event handler for AuthorChanged Annotation event 
        /// internally it calls the store AnnotationModified delegate
        /// 
 
        /// annotation that changed 
        /// args describing the change
        private void OnAuthorChanged(object sender, AnnotationAuthorChangedEventArgs args) 
        {
            _currentAnnotations[args.Annotation.Id].Dirty = true;
            _authorChanged(sender, args);
        } 

        #endregion Private Methods 
 
        //-----------------------------------------------------
        // 
        //  Private Fields
        //
        //------------------------------------------------------
 
        #region Private Fields
 
        // a dictionary that holds an annotation id to an annotation instance 
        private Dictionary _currentAnnotations = new Dictionary();
 
        // The delegates to be notified for Annotation changes
        private AnnotationAuthorChangedEventHandler _authorChanged;
        private AnnotationResourceChangedEventHandler _anchorChanged;
        private AnnotationResourceChangedEventHandler _cargoChanged; 

        #endregion Private Fields 
 
        //-----------------------------------------------------
        // 
        //  Private Classes
        //
        //-----------------------------------------------------
 
        #region Private Classes
 
        /// 
 
        /// This class contains an annotation and a dirty flag
        /// It is needed because when it is time to flush 
        /// the store - we should write only dirty annotations
        /// 
        private class CachedAnnotation
        { 
            /// 

            /// Construct a CachedAnnotation 
            /// 
 
            /// The annotation instance to be cached
            /// A flag to indicate if the annotation is dirty 
            public CachedAnnotation(Annotation annotation, bool dirty)
            {
                Annotation = annotation;
                Dirty = dirty; 
            }
 
            /// 
 
            /// The cached Annotation instance
            /// 
 
            /// 
            public Annotation Annotation
            {
                get { return _annotation; } 
                set { _annotation = value; }
            } 
 
            /// 

            /// A flag to indicate if the cached annotation is dirty or not 
            /// 
            /// 
            public bool Dirty
            { 
                get { return _dirty; }
                set { _dirty = value; } 
            } 

 
            private Annotation _annotation;
            private bool _dirty;
        }
 
        #endregion Private Classes
    } 
} 

// File provided for Reference Use Only by Microsoft Corporation (c) 2007.
// Copyright (c) Microsoft Corporation. All rights reserved.
//------------------------------------------------------------------------------ 
//
// 
//    Copyright (C) Microsoft Corporation.  All rights reserved.
//  
//
// Description: 
//     Map of annotation instances handed out by a particular store. 
//     Used to guarantee only one instance of an annotation is ever
//     produced.  Also register for notifications on the instances 
//     and passes change notifications on to the store.
//
//     Spec: http://team/sites/ag/Specifications/CAF%20Storage%20Spec.doc
// 
// History:
//  07/15/2004: magedz:    Added new class. 
//  08/18/2004: magedz:    Added querying capabilities to the map to improve performance 
//  10/20/2004:  rruiz:    Moved class to MS.Internal.
// 
//-----------------------------------------------------------------------------
using System;
using System.Collections.Generic;
using System.Globalization; 
using System.Diagnostics;
using System.IO; 
using System.Windows; 
using System.Windows.Annotations;
using MS.Utility; 


namespace MS.Internal.Annotations.Storage
{ 
    /// 

    /// A map the store uses to maintain having one instance 
    /// of the object model 
    /// 
    internal class StoreAnnotationsMap 
    {
        //-----------------------------------------------------
        //
        //  Constructors 
        //
        //----------------------------------------------------- 
 
        #region Constructors
 
        /// 

        /// Constructor for StoreAnnotationsMap
        /// It takes instances of the AnnotationAuthorChangedEventHandler, AnnotationResourceChangedEventHandler, AnnotationResourceChangedEventHandler delegates
        /// 
 
        /// delegate used to register for AuthorChanged events on all annotations
        /// delegate used to register for AnchorChanged events on all annotations 
        /// delegate used to register for CargoChanged events on all annotations 
        internal StoreAnnotationsMap(AnnotationAuthorChangedEventHandler authorChanged, AnnotationResourceChangedEventHandler anchorChanged, AnnotationResourceChangedEventHandler cargoChanged)
        { 
            Debug.Assert(authorChanged != null && anchorChanged != null && cargoChanged != null,
                         "Author and Anchor and Cargo must not be null");

            _authorChanged = authorChanged; 
            _anchorChanged = anchorChanged;
            _cargoChanged = cargoChanged; 
        } 

        #endregion Constructors 

        //------------------------------------------------------
        //
        //  Public Methods 
        //
        //----------------------------------------------------- 
 
        #region Public Methods
 
        /// 

        /// Add an annotation to the map
        /// throws an exception if the annotation already exists
        /// 
 
        /// instance of annotation to add to the map
        /// the initial dirty flag of the annotation in the map 
        public void AddAnnotation(Annotation annotation, bool dirty) 
        {
            Debug.Assert(FindAnnotation(annotation.Id) == null, "annotation  not found"); 
            annotation.AuthorChanged += OnAuthorChanged;
            annotation.AnchorChanged += OnAnchorChanged;
            annotation.CargoChanged += OnCargoChanged;
            _currentAnnotations.Add(annotation.Id, new CachedAnnotation(annotation, dirty)); 
        }
 
        /// 
 
        /// remove an annotation from the map if it exists
        /// otherwise return 
        /// 
        /// id of the annotation to remove
        public void RemoveAnnotation(Guid id)
        { 
            CachedAnnotation existingCachedAnnot = null;
            if (_currentAnnotations.TryGetValue(id, out existingCachedAnnot)) 
            { 
                existingCachedAnnot.Annotation.AuthorChanged -= OnAuthorChanged;
                existingCachedAnnot.Annotation.AnchorChanged -= OnAnchorChanged; 
                existingCachedAnnot.Annotation.CargoChanged -= OnCargoChanged;
                _currentAnnotations.Remove(id);
            }
        } 

        /// 
 
        ///     Queries the store map for annotations that have an anchor 
        ///     that contains a locator that begins with the locator parts
        ///     in anchorLocator. 
        /// 
        /// the locator we are looking for
        /// 
        ///    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. 
        /// 
        public Dictionary FindAnnotations(ContentLocator anchorLocator) 
        {
            if (anchorLocator == null)
                throw new ArgumentNullException("locator");
 
            Dictionary annotations = new Dictionary();
 
            // 

 
            Dictionary.ValueCollection.Enumerator annotationsEnumerator = _currentAnnotations.Values.GetEnumerator();

            while (annotationsEnumerator.MoveNext())
            { 
                Annotation annotation = annotationsEnumerator.Current.Annotation;
                bool matchesQuery = false; 
 
                foreach (AnnotationResource resource in annotation.Anchors)
                { 
                    foreach (ContentLocatorBase locator in resource.ContentLocators)
                    {
                        ContentLocator ContentLocator = locator as ContentLocator;
                        if (ContentLocator != null) 
                        {
                            if (ContentLocator.StartsWith(anchorLocator)) 
                            { 
                                matchesQuery = true;
                            } 
                        }
                        else
                        {
                            ContentLocatorGroup ContentLocatorGroup = locator as ContentLocatorGroup; 
                            if (ContentLocatorGroup != null)
                            { 
                                foreach(ContentLocator list in ContentLocatorGroup.Locators) 
                                {
                                    if (list.StartsWith(anchorLocator)) 
                                    {
                                        matchesQuery = true;
                                        break;
                                    } 
                                }
                            } 
                        } 

                        if (matchesQuery) 
                        {
                            annotations.Add(annotation.Id, annotation);
                            break;
                        } 
                    }
 
                    if (matchesQuery) 
                        break;
                } 
            }

            return annotations;
        } 

        /// 
 
        /// Returns a dictionary of all annotations in the map 
        /// 
        /// annotations list. Can return an empty list, but never null. 
        public Dictionary FindAnnotations()
        {
            Dictionary annotations = new Dictionary();
            foreach (KeyValuePair annotKV in _currentAnnotations) 
            {
                annotations.Add(annotKV.Key, annotKV.Value.Annotation); 
            } 
            return annotations;
        } 

        /// 

        /// Find an annottaion that has a specific id in the map
        /// returns null if not found 
        /// 
        /// id of the annotation to find 
        public Annotation FindAnnotation(Guid id) 
        {
            CachedAnnotation cachedAnnotation = null; 
            if (_currentAnnotations.TryGetValue(id, out cachedAnnotation))
            {
                return cachedAnnotation.Annotation;
            } 

            return null; 
        } 

        /// 
 
        /// Returns a list of all dirty annotations in the map
        /// 
        /// annotations list. Can return an empty list, but never null.
        public List FindDirtyAnnotations() 
        {
            List annotations = new List(); 
            foreach (KeyValuePair annotKV in _currentAnnotations) 
            {
                if (annotKV.Value.Dirty) 
                {
                    annotations.Add(annotKV.Value.Annotation);
                }
            } 

            return annotations; 
        } 

        /// 
 
        /// Sets all the dirty annotations in the map to clean
        /// 
        public void ValidateDirtyAnnotations()
        { 
            foreach (KeyValuePair annotKV in _currentAnnotations)
            { 
                if (annotKV.Value.Dirty) 
                {
                    annotKV.Value.Dirty = false; 
                }
            }
        }
 
        #endregion Public Methods
 
        //------------------------------------------------------ 
        //
        //  Private Methods 
        //
        //------------------------------------------------------

        #region Private Methods 

        /// 
 
        /// the event handler for AnchorChanged Annotation event 
        /// internally it calls the store AnnotationModified delegate
        /// 
 
        /// annotation that changed
        /// args describing the change
        private void OnAnchorChanged(object sender, AnnotationResourceChangedEventArgs args)
        { 
            _currentAnnotations[args.Annotation.Id].Dirty = true;
            _anchorChanged(sender, args); 
        } 

        /// 
 
        /// the event handler for CargoChanged Annotation event
        /// internally it calls the store AnnotationModified delegate
        /// 
        /// annotation that changed 
        /// args describing the change
        private void OnCargoChanged(object sender, AnnotationResourceChangedEventArgs args) 
        { 
            _currentAnnotations[args.Annotation.Id].Dirty = true;
            _cargoChanged(sender, args); 
        }

        /// 

        /// the event handler for AuthorChanged Annotation event 
        /// internally it calls the store AnnotationModified delegate
        /// 
 
        /// annotation that changed 
        /// args describing the change
        private void OnAuthorChanged(object sender, AnnotationAuthorChangedEventArgs args) 
        {
            _currentAnnotations[args.Annotation.Id].Dirty = true;
            _authorChanged(sender, args);
        } 

        #endregion Private Methods 
 
        //-----------------------------------------------------
        // 
        //  Private Fields
        //
        //------------------------------------------------------
 
        #region Private Fields
 
        // a dictionary that holds an annotation id to an annotation instance 
        private Dictionary _currentAnnotations = new Dictionary();
 
        // The delegates to be notified for Annotation changes
        private AnnotationAuthorChangedEventHandler _authorChanged;
        private AnnotationResourceChangedEventHandler _anchorChanged;
        private AnnotationResourceChangedEventHandler _cargoChanged; 

        #endregion Private Fields 
 
        //-----------------------------------------------------
        // 
        //  Private Classes
        //
        //-----------------------------------------------------
 
        #region Private Classes
 
        /// 
 
        /// This class contains an annotation and a dirty flag
        /// It is needed because when it is time to flush 
        /// the store - we should write only dirty annotations
        /// 
        private class CachedAnnotation
        { 
            /// 

            /// Construct a CachedAnnotation 
            /// 
 
            /// The annotation instance to be cached
            /// A flag to indicate if the annotation is dirty 
            public CachedAnnotation(Annotation annotation, bool dirty)
            {
                Annotation = annotation;
                Dirty = dirty; 
            }
 
            /// 
 
            /// The cached Annotation instance
            /// 
 
            /// 
            public Annotation Annotation
            {
                get { return _annotation; } 
                set { _annotation = value; }
            } 
 
            /// 

            /// A flag to indicate if the cached annotation is dirty or not 
            /// 
            /// 
            public bool Dirty
            { 
                get { return _dirty; }
                set { _dirty = value; } 
            } 

 
            private Annotation _annotation;
            private bool _dirty;
        }
 
        #endregion Private Classes
    } 
} 

// File provided for Reference Use Only by Microsoft Corporation (c) 2007.
// Copyright (c) Microsoft Corporation. All rights reserved.

                        

                        

                        
                        

Link Menu

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

• TypedTableBase.cs
• _NestedSingleAsyncResult.cs
• DataGridPageChangedEventArgs.cs
• BrushMappingModeValidation.cs
• DataTemplateSelector.cs
• ClockGroup.cs
• XmlSchemaAttributeGroupRef.cs
• ToolTip.cs
• InvokeMethodActivityDesigner.cs
• BigInt.cs
• StrongName.cs
• ControlCollection.cs
• TextAutomationPeer.cs
• SqlProviderManifest.cs
• HandlerFactoryWrapper.cs
• Wildcard.cs
• SessionStateModule.cs
• CollaborationHelperFunctions.cs
• ParallelActivityDesigner.cs
• LeftCellWrapper.cs
• InputBinding.cs
• DetailsViewUpdatedEventArgs.cs
• BindingGroup.cs
• EventLogTraceListener.cs
• DetailsViewUpdatedEventArgs.cs
• SQLCharsStorage.cs
• IndependentAnimationStorage.cs
• COAUTHINFO.cs
• HierarchicalDataBoundControlAdapter.cs
• WebBaseEventKeyComparer.cs
• WebRequestModulesSection.cs
• DataPager.cs
• SqlEnums.cs
• FrameworkElement.cs
• CounterCreationDataConverter.cs
• MediaCommands.cs
• ContentType.cs
• MetadataPropertyCollection.cs
• FileUtil.cs
• SoapSchemaMember.cs
• PageContent.cs
• ping.cs
• SectionUpdates.cs
• AsyncStreamReader.cs
• ToolTipAutomationPeer.cs
• CompilationUtil.cs
• Evaluator.cs
• DataRecordInternal.cs
• XamlLoadErrorInfo.cs
• Section.cs
• DateTimeAutomationPeer.cs
• ReadOnlyCollection.cs
• QueueProcessor.cs
• StatementContext.cs
• SignedXmlDebugLog.cs
• WindowsTab.cs
• ObjectToIdCache.cs
• FrameworkContentElementAutomationPeer.cs
• SuppressMessageAttribute.cs
• LongAverageAggregationOperator.cs
• IRCollection.cs
• sqlnorm.cs
• Roles.cs
• ClientScriptItemCollection.cs
• ConfigXmlAttribute.cs
• XamlToRtfParser.cs
• DataGridViewElement.cs
• LocalizableResourceBuilder.cs
• WebPartConnectionsCancelEventArgs.cs
• DataGridViewElement.cs
• TdsRecordBufferSetter.cs
• SafeFileHandle.cs
• DataGridViewCellStyleConverter.cs
• XmlQueryTypeFactory.cs
• RegexStringValidatorAttribute.cs
• TextEditorLists.cs
• DriveInfo.cs
• XPathNodeInfoAtom.cs
• RuleSetBrowserDialog.cs
• XamlRtfConverter.cs
• AttachedPropertyBrowsableForTypeAttribute.cs
• CodeMemberProperty.cs
• PageFunction.cs
• LongValidator.cs
• HttpCacheVary.cs
• XmlCountingReader.cs
• Module.cs
• ValidationErrorEventArgs.cs
• SearchForVirtualItemEventArgs.cs
• ConfigXmlAttribute.cs
• UnmanagedHandle.cs
• ConfigurationStrings.cs
• CodeNamespaceImportCollection.cs
• WebPartHeaderCloseVerb.cs
• DetailsViewInsertEventArgs.cs
• ToolStripCodeDomSerializer.cs
• Peer.cs
• EndOfStreamException.cs
• NotificationContext.cs
• NgenServicingAttributes.cs