|
|
using System;
|
|
|
using System.Collections.Generic;
|
|
|
using System.Linq;
|
|
|
|
|
|
namespace Implab.Components {
|
|
|
/// <summary>
|
|
|
/// Component container, used to store track components in multi-threaded environmment.
|
|
|
/// </summary>
|
|
|
/// <remarks>Instanses of this class are thread safe.</remarks>
|
|
|
public class ComponentContainer<T> : Disposable, ICollection<T> {
|
|
|
List<T> m_components = new List<T>();
|
|
|
readonly object m_lock = new object();
|
|
|
|
|
|
/// <summary>
|
|
|
/// Removes currently stored compoenents from the container and disposes them if possible.
|
|
|
/// </summary>
|
|
|
/// <remarks>
|
|
|
/// A new components may be added before this method completes.
|
|
|
/// </remarks>
|
|
|
public void Clear() {
|
|
|
List<T> removed;
|
|
|
|
|
|
lock (m_lock) {
|
|
|
removed = m_components;
|
|
|
m_components = new List<T>();
|
|
|
}
|
|
|
|
|
|
foreach (var item in removed.OfType<IDisposable>())
|
|
|
item.Dispose();
|
|
|
}
|
|
|
|
|
|
/// <summary>
|
|
|
/// Checks whether the specified item in the collection.
|
|
|
/// </summary>
|
|
|
/// <param name="item">The item to check.</param>
|
|
|
public bool Contains(T item) {
|
|
|
lock (m_lock)
|
|
|
return m_components.Contains(item);
|
|
|
}
|
|
|
|
|
|
/// <summary>
|
|
|
/// Copies currently stored components to the specified array.
|
|
|
/// </summary>
|
|
|
/// <param name="array">A destination array for components.</param>
|
|
|
/// <param name="arrayIndex">A starting index in the destination array.</param>
|
|
|
public void CopyTo(T[] array, int arrayIndex) {
|
|
|
lock (m_lock)
|
|
|
m_components.CopyTo(array, arrayIndex);
|
|
|
}
|
|
|
|
|
|
/// <summary>
|
|
|
/// Remove the specified item from the collection.
|
|
|
/// </summary>
|
|
|
/// <param name="item">The item to remove.</param>
|
|
|
public bool Remove(T item) {
|
|
|
lock (m_lock)
|
|
|
return m_components.Remove(item);
|
|
|
}
|
|
|
|
|
|
/// <summary>
|
|
|
/// Gets the count of components in the collection.
|
|
|
/// </summary>
|
|
|
public int Count {
|
|
|
get {
|
|
|
lock (m_lock)
|
|
|
return m_components.Count;
|
|
|
}
|
|
|
}
|
|
|
|
|
|
/// <summary>
|
|
|
/// Gets a value indicating whether this instance is read only.
|
|
|
/// </summary>
|
|
|
/// <remarks>
|
|
|
/// Always false.
|
|
|
/// </remarks>
|
|
|
public bool IsReadOnly {
|
|
|
get {
|
|
|
return false;
|
|
|
}
|
|
|
}
|
|
|
|
|
|
/// <summary>
|
|
|
/// Gets the enumerator for components in the collection.
|
|
|
/// </summary>
|
|
|
/// <returns>The enumerator.</returns>
|
|
|
public IEnumerator<T> GetEnumerator() {
|
|
|
T[] items = new T[m_components.Count];
|
|
|
lock (m_lock) {
|
|
|
m_components.CopyTo(items);
|
|
|
}
|
|
|
return (IEnumerator<T>)items.GetEnumerator();
|
|
|
}
|
|
|
|
|
|
System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator() {
|
|
|
return GetEnumerator();
|
|
|
}
|
|
|
|
|
|
/// <summary>
|
|
|
/// Add the specified item to the collection.
|
|
|
/// </summary>
|
|
|
/// <param name="item">The item to add.</param>
|
|
|
/// <remarks>
|
|
|
/// If the collection is alredy disposed, the item isn't added to the collection and disposed if possible.
|
|
|
/// </remarks>
|
|
|
public void Add(T item) {
|
|
|
Safe.ArgumentNotNull(item, "item");
|
|
|
bool dispose = false;
|
|
|
lock (m_lock) {
|
|
|
if (IsDisposed)
|
|
|
dispose = true;
|
|
|
else
|
|
|
m_components.Add(item);
|
|
|
}
|
|
|
if (dispose)
|
|
|
Safe.Dispose(item);
|
|
|
}
|
|
|
|
|
|
/// <summary>
|
|
|
/// Disposes the components stored in the collection.
|
|
|
/// </summary>
|
|
|
/// <param name="disposing">If set to <c>true</c> the collection is disposing.</param>
|
|
|
protected override void Dispose(bool disposing) {
|
|
|
if (disposing)
|
|
|
Clear();
|
|
|
|
|
|
base.Dispose(disposing);
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
|
|
|
|
