BizHawk/BizHawk.Emulation/QuickCollections.cs

using System;
using System.Collections.Generic;

namespace BizHawk
{
    // If you're wondering what the point of this is: It's mostly to have .Clear() be fast.
    // only intended to be used with value types. If used on references you may get GC issues.
    // Also, being in the same assembly means the JITer might inline these calls.
    // There is less overhead by not being dynamically resizable and stuff.
    public sealed class QuickList<T> where T : struct
    {
        private T[] buffer;
        public int Position;

        public QuickList(int capacity)
        {
            buffer = new T[capacity];
        }

        public T this[int index]
        {
            get { return buffer[index]; }
            set { buffer[index] = value; }
        }

        public int Count
        {
            get { return Position; }
        }

        public void Add(T item)
        {
            buffer[Position++] = item;
        }

        public void Clear()
        {
            Position = 0;
        }
    }

    // and the point of this one is to be easier to serialize quickly. AND fast to clear.
    // only intended to be used with value types. If used on references you may get GC issues.
    public class QuickQueue<T> where T : struct
    {
        private T[] buffer;
        private int head;
        private int tail;
        private int size;

        public QuickQueue(int capacity)
        {
            buffer = new T[capacity];
        }

        public int Count { get { return size; } }

        public void Enqueue(T item)
        {
            if (size >= buffer.Length)
                throw new Exception("QuickQueue capacity breached!");

            buffer[tail] = item;
            tail = (tail + 1) % buffer.Length;
            size++;
        }

        public T Dequeue()
        {
            if (size == 0)
                throw new Exception("QuickQueue is empty!");

            T item = buffer[head];
            head = (head + 1) % buffer.Length;
            size--;
            return item;
        }

        public void Clear()
        {
            head = 0;
            tail = 0;
            size = 0;
        }

        public T[] GetBuffer()
        {
            return buffer;
        }

        public void SignalBufferFilled(int count)
        {
            head = 0;
            tail = count;
            size = count;
        }

        // TODO serialization functions
    }

    // .net has no built-in read only dictionary
    public class ReadOnlyDictionary<TKey, TValue> : IDictionary<TKey,TValue>
    {
        private IDictionary<TKey, TValue> dict;

        public ReadOnlyDictionary(IDictionary<TKey, TValue> dictionary)
        {
            dict = dictionary;
        }

        public void Add(TKey key, TValue value)
        {
            throw new InvalidOperationException();
        }

        public bool ContainsKey(TKey key)
        {
            return dict.ContainsKey(key);
        }

        public ICollection<TKey> Keys
        {
            get { return dict.Keys; }
        }

        public bool Remove(TKey key)
        {
            throw new InvalidOperationException();
        }

        public bool TryGetValue(TKey key, out TValue value)
        {
            return dict.TryGetValue(key, out value);
        }

        public ICollection<TValue> Values
        {
            get { return dict.Values; }
        }

        public TValue this[TKey key]
        {
            get { return dict[key]; }
            set { throw new InvalidOperationException(); }
        }

        public void Add(KeyValuePair<TKey, TValue> item)
        {
            throw new InvalidOperationException();
        }

        public void Clear()
        {
            throw new InvalidOperationException();
        }

        public bool Contains(KeyValuePair<TKey, TValue> item)
        {
            return dict.Contains(item);
        }

        public void CopyTo(KeyValuePair<TKey, TValue>[] array, int arrayIndex)
        {
            dict.CopyTo(array, arrayIndex);
        }

        public int Count
        {
            get { return dict.Count; }
        }

        public bool IsReadOnly
        {
            get { return true; }
        }

        public bool Remove(KeyValuePair<TKey, TValue> item)
        {
            throw new InvalidOperationException();
        }

        public IEnumerator<KeyValuePair<TKey, TValue>> GetEnumerator()
        {
            return dict.GetEnumerator();
        }

        System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator()
        {
            return ((System.Collections.IEnumerable)dict).GetEnumerator();
        }
    }
}