// Copyright (c) 2010 AlphaSierraPapa for the SharpDevelop Team (for details please see \doc\copyright.txt)
// This code is distributed under MIT X11 license (for details please see \doc\license.txt)
using System;
using System.Threading;
namespace ICSharpCode.NRefactory.Utils
{
///
/// Allows the registration of static "caching types" which can then be used to efficiently retrieve an
/// instance per CacheManager (or even per CacheManager and thread).
///
/// This class is thread-safe
public sealed class CacheManager : IDisposable
{
/* Lots of code commented out because I don't know if it's useful, clients can usually replicate
* the functionality much more easily and only need the Disposed event to ensure cleanup.
*
* Actually, what I've implemented here looks very much like .NET's internal System.LocalDataStore
* (used for Thread.GetData/SetData)
*
static int nextSharedIndex, nextThreadLocalIndex;
///
/// Registers a new cache type. This causes each CacheManager to allocate space for the new cache type.
///
/// Specifies whether this cache is shared (multi-threaded) or whether
/// there is one instance per thread.
/// Returns a token that can be used to access the cache.
public static CacheToken RegisterType(CacheMode mode) where T : class, new()
{
int index;
switch (mode) {
case CacheMode.Shared:
index = Interlocked.Increment(ref nextSharedIndex);
break;
case CacheMode.ThreadLocal:
index = Interlocked.Increment(ref nextThreadLocalIndex);
break;
default:
throw new ArgumentException("Invalid value for CacheMode", "mode");
}
return new CacheToken(mode, index);
}
readonly object lockObj = new object();
volatile object[] _sharedCaches = new object[nextSharedIndex];
ThreadLocal