source: branches/PersistentDataStructures/HeuristicLab.Data/3.3/PersistentDataStructures/Adaptations/HistoryArray.cs @ 14657

using System;
using System.Collections;
using System.Collections.Generic;
using System.Linq;
using HeuristicLab.Data.PersistentDataStructures.Implementations;
using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;

namespace HeuristicLab.Data.PersistentDataStructures.Adaptations {

  [StorableClass]
  public class HistoryArray<T> : ICloneable, IList<T>, ICollection, IEnumerable, IStructuralComparable, IStructuralEquatable {

    [Storable]
    private ArrayMappedTrie<T> amt;

    public int Count {
      get { return (int?) amt.MetaInfo ?? 0; }
      private set { amt.MetaInfo = value; }
    }

    public int Length { get { return Count; } }

    [StorableConstructor]
    protected HistoryArray(bool isDeserializing) { }

    private HistoryArray(ArrayMappedTrie<T> amt) {
      this.amt = amt.Clone();
      Count = (int?) amt.MetaInfo ?? 0;
    }

    protected HistoryArray(HistoryArray<T> orig) {
      amt = orig.amt.Clone();
      Count = orig.Count;
    }

    public HistoryArray(int size) {
      amt = new ArrayMappedTrie<T> { SnapshotInterval = 0 };
      Count = size;
    }

    [Obsolete]
    public HistoryArray(IEnumerable<T> elements) {
      amt = new ArrayMappedTrie<T> { SnapshotInterval = 0 };
      Count = 0;
      foreach (var element in elements) {
        Add(element);
      }
    }

    public T this[int index] {
      get {
        if (index < 0 || index >= Count) throw new IndexOutOfRangeException();
        return amt[(UInt32) index];
      }
      set {
        if (index < 0 || index >= Count) throw new IndexOutOfRangeException();
        amt[(UInt32) index] = value;
      }
    }

    IEnumerator IEnumerable.GetEnumerator() { return GetEnumerator(); }

    public IEnumerator<T> GetEnumerator() {
      for (int i = 0; i < Count; i++) {
        yield return this[i];
      }
    }

    public object Clone() { return new HistoryArray<T>(this); }
    public void Add(T item) { amt[(UInt32)Count] = item; Count++; }

    public void Clear() {
      var oldInterval = amt.SnapshotInterval;
      amt.SnapshotInterval = 0;
      for (int i = 0; i < Count; i++)
        this[i] = default(T);
      amt.SnapshotInterval = oldInterval;
      if (oldInterval > 0)
        amt.CreateSnapshot();
    }
    public bool Contains(T item) { return amt.Any(i => i.Equals(item)); }

    public void CopyTo(T[] array, int arrayIndex) {
      for (int i = 0; i < Count && i+arrayIndex < array.Length; i++) {
        array[i + arrayIndex] = this[i];
      }
    }

    public bool Remove(T item) { throw new NotSupportedException(); }
    int ICollection<T>.Count { get { return Count;  } }

    public bool IsReadOnly { get { return false;  } } 
    public int IndexOf(T item) {
      for (int i = 0; i < Count; i++) {
        if (this[i].Equals(item)) return i;
      }
      return -1;
    }
    public void Insert(int index, T item) { throw new NotSupportedException(); }
    public void RemoveAt(int index) { throw new NotSupportedException(); }

    public void CopyTo(Array array, int index) {
      for (int i = 0; i < Count && i < array.Length + index; i++) {
        array.SetValue(this[i], i+index);
      }
    }
    int ICollection.Count { get { return Count;  } }

    public object SyncRoot { get { return this;  } }
    public bool IsSynchronized { get { return true;  } }

    public int CompareTo(object other, IComparer comparer) {
      HistoryArray<T> o = other as HistoryArray<T>;
      if (o == null) return 1;
      for (int i = 0; i < Count && i < o.Count; i++) {
        var result = comparer.Compare(this[i], o[i]);
        if (result != 0)
          return result;
      }
      return Count.CompareTo(o.Count);
    }

    public bool Equals(object other, IEqualityComparer comparer) {
      HistoryArray<T> o = other as HistoryArray<T>;
      if (o == null || o.Count != Count) return false;
      for (int i = 0; i < Count; i++) {
        if (!comparer.Equals(this[i], o[i]))
          return false;
      }
      return true;
    }

    public int GetHashCode(IEqualityComparer comparer) {
      unchecked { // overflow is fine
        int hash = (int)2166136261;
        for (int i = 0; i < Count; i++) {
          hash = (hash * 16777619) ^ (this[i] == null ? 0 : this[i].GetHashCode());
        }
        return hash;
      }
    }

    public void Resize(int newSize) {
      for (int i = newSize; i < Count; i++) {
        amt.Remove((UInt32)i);
      }
      Count = newSize;
    }

    public void CreateSnapshot() {
      amt.CreateSnapshot();
    }

    public IEnumerable<HistoryArray<T>> GetHistory() {
      yield return this;
      var prev = amt.Rollback();
      while (prev != null) {
        yield return new HistoryArray<T>(prev);
        prev = prev.Rollback();
      }
    }
  }
}