From 007016ecd2fabf0bbe789ac6fc0ab6f827ff90b7 Mon Sep 17 00:00:00 2001 From: Jeff Ames Date: Thu, 4 Jun 2009 00:51:02 +0000 Subject: Update svn properties. --- OpenSim/Framework/CnmSynchronizedCache.cs | 1492 ++++++++++++++--------------- 1 file changed, 746 insertions(+), 746 deletions(-) (limited to 'OpenSim/Framework/CnmSynchronizedCache.cs') diff --git a/OpenSim/Framework/CnmSynchronizedCache.cs b/OpenSim/Framework/CnmSynchronizedCache.cs index 418a095..bf588ce 100644 --- a/OpenSim/Framework/CnmSynchronizedCache.cs +++ b/OpenSim/Framework/CnmSynchronizedCache.cs @@ -1,746 +1,746 @@ -/* - * Copyright (c) Contributors, http://opensimulator.org/ - * See CONTRIBUTORS.TXT for a full list of copyright holders. - * - * Redistribution and use in source and binary forms, with or without - * modification, are permitted provided that the following conditions are met: - * * Redistributions of source code must retain the above copyright - * notice, this list of conditions and the following disclaimer. - * * Redistributions in binary form must reproduce the above copyright - * notice, this list of conditions and the following disclaimer in the - * documentation and/or other materials provided with the distribution. - * * Neither the name of the OpenSimulator Project nor the - * names of its contributors may be used to endorse or promote products - * derived from this software without specific prior written permission. - * - * THIS SOFTWARE IS PROVIDED BY THE DEVELOPERS ``AS IS'' AND ANY - * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED - * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE - * DISCLAIMED. IN NO EVENT SHALL THE CONTRIBUTORS BE LIABLE FOR ANY - * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES - * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; - * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND - * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT - * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS - * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. - */ -using System; -using System.Collections; -using System.Collections.Generic; -using System.Threading; - -namespace OpenSim.Framework -{ - /// - /// Synchronized Cenome cache wrapper. - /// - /// - /// The type of keys in the cache. - /// - /// - /// The type of values in the cache. - /// - /// - /// - /// Enumerator will block other threads, until enumerator's method is called. - /// "foreach" statement is automatically calling it. - /// - /// - public class CnmSynchronizedCache : ICnmCache - { - /// - /// The cache object. - /// - private readonly ICnmCache m_cache; - - /// - /// Synchronization root. - /// - private readonly object m_syncRoot; - - /// - /// Initializes a new instance of the class. - /// Initializes a new instance of the class. - /// - /// - /// The cache. - /// - private CnmSynchronizedCache( ICnmCache cache ) - { - m_cache = cache; - m_syncRoot = m_cache.SyncRoot; - } - - /// - /// Returns a wrapper that is synchronized (thread safe). - /// - /// - /// The to synchronize. - /// - /// - /// A wrapper that is synchronized (thread safe). - /// - /// - /// is null. - /// - public static ICnmCache Synchronized( ICnmCache cache ) - { - if( cache == null ) - throw new ArgumentNullException( "cache" ); - return cache.IsSynchronized ? cache : new CnmSynchronizedCache( cache ); - } - - #region Nested type: SynchronizedEnumerator - - /// - /// Synchronized enumerator. - /// - private class SynchronizedEnumerator : IEnumerator> - { - /// - /// Enumerator that is being synchronized. - /// - private readonly IEnumerator> m_enumerator; - - /// - /// Synchronization root. - /// - private object m_syncRoot; - - /// - /// Initializes a new instance of the class. - /// - /// - /// The enumerator that is being synchronized. - /// - /// - /// The sync root. - /// - public SynchronizedEnumerator( IEnumerator> enumerator, object syncRoot ) - { - m_syncRoot = syncRoot; - m_enumerator = enumerator; - Monitor.Enter( m_syncRoot ); - } - - /// - /// Finalizes an instance of the class. - /// - ~SynchronizedEnumerator() - { - Dispose(); - } - - #region IEnumerator> Members - - /// - /// Gets the element in the collection at the current position of the enumerator. - /// - /// - /// The element in the collection at the current position of the enumerator. - /// - /// - /// The enumerator has reach end of collection or is not called. - /// - public KeyValuePair Current - { - get { return m_enumerator.Current; } - } - - /// - /// Gets the current element in the collection. - /// - /// - /// The current element in the collection. - /// - /// - /// The enumerator is positioned before the first element of the collection or after the last element. - /// 2 - object IEnumerator.Current - { - get { return Current; } - } - - /// - /// Releases synchronization lock. - /// - public void Dispose() - { - if( m_syncRoot != null ) - { - Monitor.Exit( m_syncRoot ); - m_syncRoot = null; - } - - m_enumerator.Dispose(); - GC.SuppressFinalize( this ); - } - - /// - /// Advances the enumerator to the next element of the collection. - /// - /// - /// true if the enumerator was successfully advanced to the next element; false if the enumerator has passed the end of the collection. - /// - /// - /// The collection was modified after the enumerator was created. - /// - public bool MoveNext() - { - return m_enumerator.MoveNext(); - } - - /// - /// Sets the enumerator to its initial position, which is before the first element in the collection. - /// - /// - /// The collection was modified after the enumerator was created. - /// - public void Reset() - { - m_enumerator.Reset(); - } - - #endregion - } - - #endregion - - #region ICnmCache Members - - /// - /// Gets current count of elements stored to . - /// - /// - /// - /// When adding an new element to that is limiting element count, - /// will remove less recently used elements until it can fit an new element. - /// - /// - /// - /// - /// - /// - public int Count - { - get - { - lock( m_syncRoot ) - { - return m_cache.Count; - } - } - } - - /// - /// Gets or sets elements expiration time. - /// - /// - /// Elements expiration time. - /// - /// - /// - /// When element has been stored in longer than - /// and it is not accessed through method or element's value is - /// not replaced by method, then it is automatically removed from the - /// . - /// - /// - /// It is possible that implementation removes element before it's expiration time, - /// because total size or count of elements stored to cache is larger than or . - /// - /// - /// It is also possible that element stays in cache longer than . - /// - /// - /// Calling try to remove all elements that are expired. - /// - /// - /// To disable time limit in cache, set to . - /// - /// - /// - /// - /// - /// - /// - /// - /// - /// - public TimeSpan ExpirationTime - { - get - { - lock( m_syncRoot ) - { - return m_cache.ExpirationTime; - } - } - - set - { - lock( m_syncRoot ) - { - m_cache.ExpirationTime = value; - } - } - } - - /// - /// Gets a value indicating whether is limiting count of elements. - /// - /// - /// if the count of elements is limited; - /// otherwise, . - /// - /// - /// - /// When adding an new element to that is limiting element count, - /// will remove less recently used elements until it can fit an new element. - /// - /// - /// - /// - /// - /// - public bool IsCountLimited - { - get - { - lock( m_syncRoot ) - { - return m_cache.IsCountLimited; - } - } - } - - /// - /// Gets a value indicating whether is limiting size of elements. - /// - /// - /// if the total size of elements is limited; - /// otherwise, . - /// - /// - /// - /// When adding an new element to that is limiting total size of elements, - /// will remove less recently used elements until it can fit an new element. - /// - /// - /// - /// - /// - /// - /// - public bool IsSizeLimited - { - get - { - lock( m_syncRoot ) - { - return m_cache.IsSizeLimited; - } - } - } - - /// - /// Gets a value indicating whether or not access to the is synchronized (thread safe). - /// - /// - /// if access to the is synchronized (thread safe); - /// otherwise, . - /// - /// - /// - /// To get synchronized (thread safe) access to object, use - /// in class - /// to retrieve synchronized wrapper for object. - /// - /// - /// - /// - public bool IsSynchronized - { - get { return true; } - } - - /// - /// Gets a value indicating whether elements stored to have limited inactivity time. - /// - /// - /// if the has a fixed total size of elements; - /// otherwise, . - /// - /// - /// If have limited inactivity time and element is not accessed through - /// or methods in , then element is automatically removed from - /// the cache. Depending on implementation of the , some of the elements may - /// stay longer in cache. - /// - /// - /// - /// - /// - public bool IsTimeLimited - { - get - { - lock( m_syncRoot ) - { - return m_cache.IsTimeLimited; - } - } - } - - /// - /// Gets or sets maximal allowed count of elements that can be stored to . - /// - /// - /// , if is not limited by count of elements; - /// otherwise maximal allowed count of elements. - /// - /// - /// - /// When adding an new element to that is limiting element count, - /// will remove less recently used elements until it can fit an new element. - /// - /// - public int MaxCount - { - get - { - lock( m_syncRoot ) - { - return m_cache.MaxCount; - } - } - - set - { - lock( m_syncRoot ) - { - m_cache.MaxCount = value; - } - } - } - - /// - /// Gets maximal allowed element size. - /// - /// - /// Maximal allowed element size. - /// - /// - /// - /// If element's size is larger than , then element is - /// not added to the . - /// - /// - /// - /// - /// - /// - public long MaxElementSize - { - get - { - lock( m_syncRoot ) - { - return m_cache.MaxElementSize; - } - } - } - - /// - /// Gets or sets maximal allowed total size for elements stored to . - /// - /// - /// Maximal allowed total size for elements stored to . - /// - /// - /// - /// Normally size is total bytes used by elements in the cache. But it can be any other suitable unit of measure. - /// - /// - /// When adding an new element to that is limiting total size of elements, - /// will remove less recently used elements until it can fit an new element. - /// - /// - /// value is less than 0. - /// - /// - /// - public long MaxSize - { - get - { - lock( m_syncRoot ) - { - return m_cache.MaxSize; - } - } - - set - { - lock( m_syncRoot ) - { - m_cache.MaxSize = value; - } - } - } - - /// - /// Gets total size of elements stored to . - /// - /// - /// Total size of elements stored to . - /// - /// - /// - /// Normally bytes, but can be any suitable unit of measure. - /// - /// - /// Element's size is given when element is added or replaced by method. - /// - /// - /// When adding an new element to that is limiting total size of elements, - /// will remove less recently used elements until it can fit an new element. - /// - /// - /// - /// - /// - /// - /// - public long Size - { - get - { - lock( m_syncRoot ) - { - return m_cache.Size; - } - } - } - - /// - /// Gets an object that can be used to synchronize access to the . - /// - /// - /// An object that can be used to synchronize access to the . - /// - /// - /// - /// To get synchronized (thread safe) access to , use - /// method to retrieve synchronized wrapper interface to - /// . - /// - /// - /// - /// - public object SyncRoot - { - get { return m_syncRoot; } - } - - /// - /// Removes all elements from the . - /// - /// - /// - /// - /// - /// - public void Clear() - { - lock( m_syncRoot ) - { - m_cache.Clear(); - } - } - - /// - /// Returns an enumerator that iterates through the elements stored to . - /// - /// - /// A that can be used to iterate through the collection. - /// - /// 1 - public IEnumerator> GetEnumerator() - { - lock( m_syncRoot ) - { - return new SynchronizedEnumerator( m_cache.GetEnumerator(), m_syncRoot ); - } - } - - /// - /// Purge expired elements from the . - /// - /// - /// - /// Element becomes expired when last access time to it has been longer time than . - /// - /// - /// Depending on implementation, some of expired elements - /// may stay longer than in the cache. - /// - /// - /// - /// - /// - /// - /// - /// - /// - public void PurgeExpired() - { - lock( m_syncRoot ) - { - m_cache.PurgeExpired(); - } - } - - /// - /// Removes element associated with from the . - /// - /// - /// The key that is associated with element to remove from the . - /// - /// - /// is . - /// - /// - /// - /// - /// - /// - public void Remove( TKey key ) - { - lock( m_syncRoot ) - { - m_cache.Remove( key ); - } - } - - /// - /// Removes elements that are associated with one of from the . - /// - /// - /// The keys that are associated with elements to remove from the . - /// - /// - /// is . - /// - /// - /// - /// - /// - /// - public void RemoveRange( IEnumerable keys ) - { - lock( m_syncRoot ) - { - m_cache.RemoveRange( keys ); - } - } - - /// - /// Add or replace an element with the provided , and to - /// . - /// - /// - /// The object used as the key of the element. Can't be reference. - /// - /// - /// The object used as the value of the element to add or replace. is allowed. - /// - /// - /// The element's size. Normally bytes, but can be any suitable unit of measure. - /// - /// - /// if element has been added successfully to the ; - /// otherwise . - /// - /// - /// is . - /// - /// - /// The element's is less than 0. - /// - /// - /// - /// If element's is larger than , then element is - /// not added to the , however - possible older element is - /// removed from the . - /// - /// - /// When adding an new element to that is limiting total size of elements, - /// will remove less recently used elements until it can fit an new element. - /// - /// - /// When adding an new element to that is limiting element count, - /// will remove less recently used elements until it can fit an new element. - /// - /// - /// - /// - /// - /// - /// - /// - /// - public bool Set( TKey key, TValue value, long size ) - { - lock( m_syncRoot ) - { - return m_cache.Set( key, value, size ); - } - } - - /// - /// Gets the associated with the specified . - /// - /// - /// if the contains an element with - /// the specified key; otherwise, . - /// - /// - /// The key whose to get. - /// - /// - /// When this method returns, the value associated with the specified , - /// if the is found; otherwise, the - /// default value for the type of the parameter. This parameter is passed uninitialized. - /// - /// - /// is . - /// - /// - /// - /// - /// - /// - public bool TryGetValue( TKey key, out TValue value ) - { - lock( m_syncRoot ) - { - return m_cache.TryGetValue( key, out value ); - } - } - - /// - /// Returns an enumerator that iterates through the elements stored to . - /// - /// - /// A that can be used to iterate through the collection. - /// - /// 1 - IEnumerator IEnumerable.GetEnumerator() - { - return GetEnumerator(); - } - - #endregion - } -} +/* + * Copyright (c) Contributors, http://opensimulator.org/ + * See CONTRIBUTORS.TXT for a full list of copyright holders. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are met: + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * * Neither the name of the OpenSimulator Project nor the + * names of its contributors may be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE DEVELOPERS ``AS IS'' AND ANY + * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL THE CONTRIBUTORS BE LIABLE FOR ANY + * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; + * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS + * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ +using System; +using System.Collections; +using System.Collections.Generic; +using System.Threading; + +namespace OpenSim.Framework +{ + /// + /// Synchronized Cenome cache wrapper. + /// + /// + /// The type of keys in the cache. + /// + /// + /// The type of values in the cache. + /// + /// + /// + /// Enumerator will block other threads, until enumerator's method is called. + /// "foreach" statement is automatically calling it. + /// + /// + public class CnmSynchronizedCache : ICnmCache + { + /// + /// The cache object. + /// + private readonly ICnmCache m_cache; + + /// + /// Synchronization root. + /// + private readonly object m_syncRoot; + + /// + /// Initializes a new instance of the class. + /// Initializes a new instance of the class. + /// + /// + /// The cache. + /// + private CnmSynchronizedCache( ICnmCache cache ) + { + m_cache = cache; + m_syncRoot = m_cache.SyncRoot; + } + + /// + /// Returns a wrapper that is synchronized (thread safe). + /// + /// + /// The to synchronize. + /// + /// + /// A wrapper that is synchronized (thread safe). + /// + /// + /// is null. + /// + public static ICnmCache Synchronized( ICnmCache cache ) + { + if( cache == null ) + throw new ArgumentNullException( "cache" ); + return cache.IsSynchronized ? cache : new CnmSynchronizedCache( cache ); + } + + #region Nested type: SynchronizedEnumerator + + /// + /// Synchronized enumerator. + /// + private class SynchronizedEnumerator : IEnumerator> + { + /// + /// Enumerator that is being synchronized. + /// + private readonly IEnumerator> m_enumerator; + + /// + /// Synchronization root. + /// + private object m_syncRoot; + + /// + /// Initializes a new instance of the class. + /// + /// + /// The enumerator that is being synchronized. + /// + /// + /// The sync root. + /// + public SynchronizedEnumerator( IEnumerator> enumerator, object syncRoot ) + { + m_syncRoot = syncRoot; + m_enumerator = enumerator; + Monitor.Enter( m_syncRoot ); + } + + /// + /// Finalizes an instance of the class. + /// + ~SynchronizedEnumerator() + { + Dispose(); + } + + #region IEnumerator> Members + + /// + /// Gets the element in the collection at the current position of the enumerator. + /// + /// + /// The element in the collection at the current position of the enumerator. + /// + /// + /// The enumerator has reach end of collection or is not called. + /// + public KeyValuePair Current + { + get { return m_enumerator.Current; } + } + + /// + /// Gets the current element in the collection. + /// + /// + /// The current element in the collection. + /// + /// + /// The enumerator is positioned before the first element of the collection or after the last element. + /// 2 + object IEnumerator.Current + { + get { return Current; } + } + + /// + /// Releases synchronization lock. + /// + public void Dispose() + { + if( m_syncRoot != null ) + { + Monitor.Exit( m_syncRoot ); + m_syncRoot = null; + } + + m_enumerator.Dispose(); + GC.SuppressFinalize( this ); + } + + /// + /// Advances the enumerator to the next element of the collection. + /// + /// + /// true if the enumerator was successfully advanced to the next element; false if the enumerator has passed the end of the collection. + /// + /// + /// The collection was modified after the enumerator was created. + /// + public bool MoveNext() + { + return m_enumerator.MoveNext(); + } + + /// + /// Sets the enumerator to its initial position, which is before the first element in the collection. + /// + /// + /// The collection was modified after the enumerator was created. + /// + public void Reset() + { + m_enumerator.Reset(); + } + + #endregion + } + + #endregion + + #region ICnmCache Members + + /// + /// Gets current count of elements stored to . + /// + /// + /// + /// When adding an new element to that is limiting element count, + /// will remove less recently used elements until it can fit an new element. + /// + /// + /// + /// + /// + /// + public int Count + { + get + { + lock( m_syncRoot ) + { + return m_cache.Count; + } + } + } + + /// + /// Gets or sets elements expiration time. + /// + /// + /// Elements expiration time. + /// + /// + /// + /// When element has been stored in longer than + /// and it is not accessed through method or element's value is + /// not replaced by method, then it is automatically removed from the + /// . + /// + /// + /// It is possible that implementation removes element before it's expiration time, + /// because total size or count of elements stored to cache is larger than or . + /// + /// + /// It is also possible that element stays in cache longer than . + /// + /// + /// Calling try to remove all elements that are expired. + /// + /// + /// To disable time limit in cache, set to . + /// + /// + /// + /// + /// + /// + /// + /// + /// + /// + public TimeSpan ExpirationTime + { + get + { + lock( m_syncRoot ) + { + return m_cache.ExpirationTime; + } + } + + set + { + lock( m_syncRoot ) + { + m_cache.ExpirationTime = value; + } + } + } + + /// + /// Gets a value indicating whether is limiting count of elements. + /// + /// + /// if the count of elements is limited; + /// otherwise, . + /// + /// + /// + /// When adding an new element to that is limiting element count, + /// will remove less recently used elements until it can fit an new element. + /// + /// + /// + /// + /// + /// + public bool IsCountLimited + { + get + { + lock( m_syncRoot ) + { + return m_cache.IsCountLimited; + } + } + } + + /// + /// Gets a value indicating whether is limiting size of elements. + /// + /// + /// if the total size of elements is limited; + /// otherwise, . + /// + /// + /// + /// When adding an new element to that is limiting total size of elements, + /// will remove less recently used elements until it can fit an new element. + /// + /// + /// + /// + /// + /// + /// + public bool IsSizeLimited + { + get + { + lock( m_syncRoot ) + { + return m_cache.IsSizeLimited; + } + } + } + + /// + /// Gets a value indicating whether or not access to the is synchronized (thread safe). + /// + /// + /// if access to the is synchronized (thread safe); + /// otherwise, . + /// + /// + /// + /// To get synchronized (thread safe) access to object, use + /// in class + /// to retrieve synchronized wrapper for object. + /// + /// + /// + /// + public bool IsSynchronized + { + get { return true; } + } + + /// + /// Gets a value indicating whether elements stored to have limited inactivity time. + /// + /// + /// if the has a fixed total size of elements; + /// otherwise, . + /// + /// + /// If have limited inactivity time and element is not accessed through + /// or methods in , then element is automatically removed from + /// the cache. Depending on implementation of the , some of the elements may + /// stay longer in cache. + /// + /// + /// + /// + /// + public bool IsTimeLimited + { + get + { + lock( m_syncRoot ) + { + return m_cache.IsTimeLimited; + } + } + } + + /// + /// Gets or sets maximal allowed count of elements that can be stored to . + /// + /// + /// , if is not limited by count of elements; + /// otherwise maximal allowed count of elements. + /// + /// + /// + /// When adding an new element to that is limiting element count, + /// will remove less recently used elements until it can fit an new element. + /// + /// + public int MaxCount + { + get + { + lock( m_syncRoot ) + { + return m_cache.MaxCount; + } + } + + set + { + lock( m_syncRoot ) + { + m_cache.MaxCount = value; + } + } + } + + /// + /// Gets maximal allowed element size. + /// + /// + /// Maximal allowed element size. + /// + /// + /// + /// If element's size is larger than , then element is + /// not added to the . + /// + /// + /// + /// + /// + /// + public long MaxElementSize + { + get + { + lock( m_syncRoot ) + { + return m_cache.MaxElementSize; + } + } + } + + /// + /// Gets or sets maximal allowed total size for elements stored to . + /// + /// + /// Maximal allowed total size for elements stored to . + /// + /// + /// + /// Normally size is total bytes used by elements in the cache. But it can be any other suitable unit of measure. + /// + /// + /// When adding an new element to that is limiting total size of elements, + /// will remove less recently used elements until it can fit an new element. + /// + /// + /// value is less than 0. + /// + /// + /// + public long MaxSize + { + get + { + lock( m_syncRoot ) + { + return m_cache.MaxSize; + } + } + + set + { + lock( m_syncRoot ) + { + m_cache.MaxSize = value; + } + } + } + + /// + /// Gets total size of elements stored to . + /// + /// + /// Total size of elements stored to . + /// + /// + /// + /// Normally bytes, but can be any suitable unit of measure. + /// + /// + /// Element's size is given when element is added or replaced by method. + /// + /// + /// When adding an new element to that is limiting total size of elements, + /// will remove less recently used elements until it can fit an new element. + /// + /// + /// + /// + /// + /// + /// + public long Size + { + get + { + lock( m_syncRoot ) + { + return m_cache.Size; + } + } + } + + /// + /// Gets an object that can be used to synchronize access to the . + /// + /// + /// An object that can be used to synchronize access to the . + /// + /// + /// + /// To get synchronized (thread safe) access to , use + /// method to retrieve synchronized wrapper interface to + /// . + /// + /// + /// + /// + public object SyncRoot + { + get { return m_syncRoot; } + } + + /// + /// Removes all elements from the . + /// + /// + /// + /// + /// + /// + public void Clear() + { + lock( m_syncRoot ) + { + m_cache.Clear(); + } + } + + /// + /// Returns an enumerator that iterates through the elements stored to . + /// + /// + /// A that can be used to iterate through the collection. + /// + /// 1 + public IEnumerator> GetEnumerator() + { + lock( m_syncRoot ) + { + return new SynchronizedEnumerator( m_cache.GetEnumerator(), m_syncRoot ); + } + } + + /// + /// Purge expired elements from the . + /// + /// + /// + /// Element becomes expired when last access time to it has been longer time than . + /// + /// + /// Depending on implementation, some of expired elements + /// may stay longer than in the cache. + /// + /// + /// + /// + /// + /// + /// + /// + /// + public void PurgeExpired() + { + lock( m_syncRoot ) + { + m_cache.PurgeExpired(); + } + } + + /// + /// Removes element associated with from the . + /// + /// + /// The key that is associated with element to remove from the . + /// + /// + /// is . + /// + /// + /// + /// + /// + /// + public void Remove( TKey key ) + { + lock( m_syncRoot ) + { + m_cache.Remove( key ); + } + } + + /// + /// Removes elements that are associated with one of from the . + /// + /// + /// The keys that are associated with elements to remove from the . + /// + /// + /// is . + /// + /// + /// + /// + /// + /// + public void RemoveRange( IEnumerable keys ) + { + lock( m_syncRoot ) + { + m_cache.RemoveRange( keys ); + } + } + + /// + /// Add or replace an element with the provided , and to + /// . + /// + /// + /// The object used as the key of the element. Can't be reference. + /// + /// + /// The object used as the value of the element to add or replace. is allowed. + /// + /// + /// The element's size. Normally bytes, but can be any suitable unit of measure. + /// + /// + /// if element has been added successfully to the ; + /// otherwise . + /// + /// + /// is . + /// + /// + /// The element's is less than 0. + /// + /// + /// + /// If element's is larger than , then element is + /// not added to the , however - possible older element is + /// removed from the . + /// + /// + /// When adding an new element to that is limiting total size of elements, + /// will remove less recently used elements until it can fit an new element. + /// + /// + /// When adding an new element to that is limiting element count, + /// will remove less recently used elements until it can fit an new element. + /// + /// + /// + /// + /// + /// + /// + /// + /// + public bool Set( TKey key, TValue value, long size ) + { + lock( m_syncRoot ) + { + return m_cache.Set( key, value, size ); + } + } + + /// + /// Gets the associated with the specified . + /// + /// + /// if the contains an element with + /// the specified key; otherwise, . + /// + /// + /// The key whose to get. + /// + /// + /// When this method returns, the value associated with the specified , + /// if the is found; otherwise, the + /// default value for the type of the parameter. This parameter is passed uninitialized. + /// + /// + /// is . + /// + /// + /// + /// + /// + /// + public bool TryGetValue( TKey key, out TValue value ) + { + lock( m_syncRoot ) + { + return m_cache.TryGetValue( key, out value ); + } + } + + /// + /// Returns an enumerator that iterates through the elements stored to . + /// + /// + /// A that can be used to iterate through the collection. + /// + /// 1 + IEnumerator IEnumerable.GetEnumerator() + { + return GetEnumerator(); + } + + #endregion + } +} -- cgit v1.1