Changeset 2132

Timestamp:

5/15/2010 2:50:31 PM (3 years ago)

Author:

lowjoel

Message:

Implemented a new FactoryRegistrar? class which is a registrar, but creates new instances of every object upon enumeration so that multiple copies of the class can exist at any one time.

Location:

trunk/eraser/Eraser.Manager

Files:

• ErasureTarget.cs (modified) (1 diff)
• IRegistrar.cs (modified) (3 diffs)

trunk/eraser/Eraser.Manager/ErasureTarget.cs

@@ -191 +191 @@
     }
 
-    public class ErasureTargetRegistrar : Registrar<ErasureTarget>
+    public class ErasureTargetRegistrar : FactoryRegistrar<ErasureTarget>
     {
     }

trunk/eraser/Eraser.Manager/IRegistrar.cs

@@ -24 +24 @@
 using System.Collections.Generic;
 using System.Text;
+using System.Reflection;
 
 namespace Eraser.Manager
@@ -80 +81 @@
 
     /// <summary>
-    /// Provides a simple Registrar implementation.
+    /// Provides a simple Registrar implementation. This registrar maintains one
+    /// instance of each registered member for the entire application.
     /// </summary>
     /// <typeparam name="T">The registerable's type.</typeparam>
@@ -268 +270 @@
         private Dictionary<Guid, T> Dictionary = new Dictionary<Guid, T>();
     }
+
+    /// <summary>
+    /// Provides a simple Registrar implementation. This registrar creates new instances
+    /// every time it is enumerated (copy on read)
+    /// </summary>
+    /// <typeparam name="T">The registerable's type.</typeparam>
+    public class FactoryRegistrar<T> : IRegistrar<T> where T : IRegisterable
+    {
+        #region IList<T> Members
+
+        public int IndexOf(T item)
+        {
+            lock (List)
+                return List.IndexOf(item.GetType().GetConstructor(Type.EmptyTypes));
+        }
+
+        public void Insert(int index, T item)
+        {
+            //Get the constructor for the class.
+            ConstructorInfo ctor = item.GetType().GetConstructor(Type.EmptyTypes);
+
+            //Check for a valid constructor.
+            if (ctor == null)
+                throw new ArgumentException("Registered FactoryRegistrar items must contain " +
+                    "a parameterless constructor that is called whenever clients request " +
+                    "for an instance of the method.");
+
+            lock (List)
+            {
+                List.Insert(index, ctor);
+                Dictionary.Add(item.Guid, ctor);
+            }
+
+            if (Registered != null)
+                Registered(item, EventArgs.Empty);
+        }
+
+        public void RemoveAt(int index)
+        {
+            ConstructorInfo value = null;
+            lock (List)
+            {
+                value = List[index];
+                List.RemoveAt(index);
+                Dictionary.Remove(value.DeclaringType.GUID);
+            }
+
+            if (Unregistered != null)
+                Unregistered(value.Invoke(new object[0]), EventArgs.Empty);
+        }
+
+        public T this[int index]
+        {
+            get
+            {
+                lock (List)
+                    return (T)List[index].Invoke(new object[0]);
+            }
+            set
+            {
+                lock (List)
+                    List[index] = value.GetType().GetConstructor(Type.EmptyTypes);
+            }
+        }
+
+        #endregion
+
+        #region ICollection<T> Members
+
+        /// <remarks>If the registerable object is added twice, the second registration
+        /// is ignored.</remarks>
+        public void Add(T item)
+        {
+            Insert(Count, item);
+        }
+
+        public void Clear()
+        {
+            lock (List)
+            {
+                if (Unregistered != null)
+                    List.ForEach(item => Unregistered(item, EventArgs.Empty));
+                List.Clear();
+                Dictionary.Clear();
+            }
+        }
+
+        public bool Contains(T item)
+        {
+            lock (List)
+                return List.Contains(item.GetType().GetConstructor(Type.EmptyTypes));
+        }
+
+        public void CopyTo(T[] array, int arrayIndex)
+        {
+            lock (List)
+            {
+                for (int i = arrayIndex, j = 0; i < array.Length; ++i, ++j)
+                {
+                    array[i] = (T)List[j].Invoke(new object[0]);
+                }
+            }
+        }
+
+        public int Count
+        {
+            get
+            {
+                lock (List)
+                    return List.Count;
+            }
+        }
+
+        public bool IsReadOnly
+        {
+            get { return false; }
+        }
+
+        public bool Remove(T item)
+        {
+            bool result = false;
+            lock (List)
+            {
+                result = List.Remove(item.GetType().GetConstructor(Type.EmptyTypes));
+                Dictionary.Remove(item.Guid);
+            }
+
+            if (result && Unregistered != null)
+                Unregistered(item, EventArgs.Empty);
+            return result;
+        }
+
+        #endregion
+
+        #region IEnumerable<T> Members
+
+        public IEnumerator<T> GetEnumerator()
+        {
+            return new Enumerator(List.GetEnumerator());
+        }
+
+        #endregion
+
+        #region IEnumerable Members
+
+        System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator()
+        {
+            return List.GetEnumerator();
+        }
+
+        #endregion
+
+        #region IRegistrar<T> Members
+
+        public T this[Guid key]
+        {
+            get
+            {
+                lock (List)
+                    return (T)Dictionary[key].Invoke(new object[0]);
+            }
+        }
+
+        public bool Contains(Guid key)
+        {
+            lock (List)
+                return Dictionary.ContainsKey(key);
+        }
+
+        public bool Remove(Guid key)
+        {
+            ConstructorInfo ctor = Dictionary[key];
+            bool result = false;
+            lock (List)
+            {
+                result = Dictionary.Remove(key);
+                result = result && List.Remove(ctor);
+            }
+
+            if (result && Unregistered != null)
+                Unregistered(ctor.Invoke(new object[0]), EventArgs.Empty);
+            return result;
+        }
+
+        public EventHandler<EventArgs> Registered { get; set; }
+
+        public EventHandler<EventArgs> Unregistered { get; set; }
+
+        #endregion
+
+        private struct Enumerator : IEnumerator<T>
+        {
+            public Enumerator(List<ConstructorInfo>.Enumerator enumerator)
+            {
+                Enum = enumerator;
+            }
+
+            #region IEnumerator<T> Members
+
+            public T Current
+            {
+                get { return (T)Enum.Current.Invoke(new object[0]); }
+            }
+
+            #endregion
+
+            #region IDisposable Members
+
+            public void Dispose()
+            {
+                Enum.Dispose();
+            }
+
+            #endregion
+
+            #region IEnumerator Members
+
+            object System.Collections.IEnumerator.Current
+            {
+                get { return this.Current; }
+            }
+
+            public bool MoveNext()
+            {
+                return Enum.MoveNext();
+            }
+
+            public void Reset()
+            {
+                ((System.Collections.IEnumerator)Enum).Reset();
+            }
+
+            #endregion
+
+            private List<ConstructorInfo>.Enumerator Enum;
+        }
+
+        /// <summary>
+        /// The backing list for this object.
+        /// </summary>
+        private List<ConstructorInfo> List = new List<ConstructorInfo>();
+
+        /// <summary>
+        /// The backing dictionary for this object.
+        /// </summary>
+        private Dictionary<Guid, ConstructorInfo> Dictionary =
+            new Dictionary<Guid, ConstructorInfo>();
+    }
 }