/// <summary>
/// Clears an items reversibly.
/// </summary>
/// <typeparam name = "T">Type of ICollection</typeparam>
/// <param name = "collection">Collection to clear</param>
public static void Clear_Reversible <T>(this ICollection <T> collection)
{
Transaction txn = Transaction.Current;
if (txn != null)
{
txn.AddEdit(new ICollectionClearEdit <T>(collection));
}
collection.Clear();
}
/// <summary>
/// Adds an item reversible
/// </summary>
/// <typeparam name = "T">Type of item to add</typeparam>
/// <param name = "collection">Collection to add item to</param>
/// <param name = "itemToAdd">Item to add</param>
public static void Add_Reversible <T>(this ICollection <T> collection, T itemToAdd)
{
collection.Add(itemToAdd);
Transaction txn = Transaction.Current;
if (txn != null)
{
txn.AddEdit(new ICollectionEdit <T>(ICollectionEditAction.AddItem, collection, itemToAdd));
}
}
/// <summary>
/// Removes an item reversibly.
/// </summary>
/// <typeparam name = "T">Type of item to add</typeparam>
/// <param name = "collection">Collection to remove from</param>
/// <param name = "itemToRemove">Item to remove</param>
public static bool Remove_Reversible <T>(this ICollection <T> collection, T itemToRemove)
{
bool retValue = collection.Remove(itemToRemove);
Transaction txn = Transaction.Current;
if (txn != null)
{
txn.AddEdit(new ICollectionEdit <T>(ICollectionEditAction.RemoveItem, collection, itemToRemove));
}
return(retValue);
}
/// <summary>
/// Inserts an item reversibly.
/// </summary>
/// <typeparam name = "T">Type of list</typeparam>
/// <param name = "list">List to insert in</param>
/// <param name = "index">Index to insert at</param>
/// <param name = "itemToInsert">Item to insert</param>
public static void Insert_Reversible <T>(this IList <T> list, int index, T itemToInsert)
{
Transaction txn = Transaction.Current;
if (txn != null)
{
list.Insert(index, itemToInsert);
txn.AddEdit(new IListEdit <T>(ListEditAction.AddItem, list, itemToInsert, index));
}
else
{
list.Insert(index, itemToInsert);
}
}
/// <summary>
/// Inserts a set of items at a given position in a list (reversibly).
/// </summary>
/// <param name = "index"></param>
/// <param name = "collection"></param>
public static void InsertRange_Reversible <T>(this List <T> list, int index, IEnumerable <T> collection)
{
Transaction txn = Transaction.Current;
if (txn != null)
{
List <T> itemsToInsert = new List <T>(collection);
list.InsertRange(index, itemsToInsert);
txn.AddEdit(new ListRangeEdit <T>(ListEditAction.AddItem, list, itemsToInsert, index));
}
else
{
list.InsertRange(index, collection);
}
}
/// <summary>
/// Sorts a subset of the list (reversible).
/// </summary>
/// <param name = "index">Index of first item to sort</param>
/// <param name = "count">Count of items to sort</param>
/// <param name = "comparer">Comparer to use to sort.</param>
public static void Sort_Reversible <T>(this List <T> list, int index, int count, IComparer <T> comparer)
{
Transaction txn = Transaction.Current;
if (txn != null)
{
List <T> changedItems = list.GetRange(index, count);
list.Sort(index, count, comparer);
txn.AddEdit(new ListRangeEdit <T>(ListEditAction.ChangeItem, list, changedItems, index));
}
else
{
list.Sort(index, count, comparer);
}
}
/// <summary>
/// Sorts the list using a given Comparison (reversible)
/// </summary>
/// <param name = "comparison">Comparision delegate to use.</param>
public static void Sort_Reversible <T>(this List <T> list, Comparison <T> comparison)
{
Transaction txn = Transaction.Current;
if (txn != null)
{
List <T> changedItems = list.GetRange(0, list.Count);
list.Sort(comparison);
txn.AddEdit(new ListRangeEdit <T>(ListEditAction.ChangeItem, list, changedItems, 0));
}
else
{
list.Sort(comparison);
}
}
/// <summary>
/// Removes a range of items in a list (reversibly).
/// </summary>
/// <param name = "index">Index of first item to remove</param>
/// <param name = "count">Count of items to remove.</param>
public static void RemoveRange_Reversible <T>(this List <T> list, int index, int count)
{
Transaction txn = Transaction.Current;
if (txn != null)
{
List <T> removedItems = list.GetRange(index, count);
list.RemoveRange(index, count);
txn.AddEdit(new ListRangeEdit <T>(ListEditAction.RemoveItem, list, removedItems, index));
}
else
{
list.RemoveRange(index, count);
}
}
/// <summary>
/// Sets a list item reversibly.
/// </summary>
/// <typeparam name = "T">Type of list</typeparam>
/// <param name = "list">List to set item in</param>
/// <param name = "index">Index of item to set</param>
/// <param name = "newValue">New value to assign.</param>
public static void Item_SetReversible <T>(this IList <T> list, int index, T newValue)
{
Transaction txn = Transaction.Current;
if (txn != null)
{
T oldValue = list[index];
list[index] = newValue;
txn.AddEdit(new IListEdit <T>(ListEditAction.ChangeItem, list, oldValue, index));
}
else
{
list[index] = newValue;
}
}
/// <summary>
/// Removes an item reversibly.
/// </summary>
/// <typeparam name = "T">Type of list</typeparam>
/// <param name = "list">List to insert in</param>
/// <param name = "index">Index to insert at</param>
public static void RemoveAt_Reversible <T>(this IList <T> list, int index)
{
Transaction txn = Transaction.Current;
if (txn != null)
{
T itemToRemove = list[index];
list.RemoveAt(index);
txn.AddEdit(new IListEdit <T>(ListEditAction.RemoveItem, list, itemToRemove, index));
}
else
{
list.RemoveAt(index);
}
}
