Implemented IEnumerable and ICollection interfaces

Author: NdubuisiJr

DataStructures/Lists/CircularBuffer.cs

@@ -1,22 +1,26 @@
 using System;
+using System.Collections;
+using System.Collections.Generic;
+using System.Linq;
 
 namespace DataStructures.Lists 
 {
-    public class CircularBuffer<T> 
-    {
+    public class CircularBuffer<T> : IEnumerable<T> , ICollection<T> where T : IComparable<T> {
         private T[] _circularBuffer;
         private int _end;
         private int _start;
+        private int _length { get => _circularBuffer.Length - 1; }
+        private readonly T _default;
         private static readonly int _defaultBufferLength = 10;
 
         /// <summary>
         /// Controls whether data should be overridden when it is continously inserted without reading
         /// </summary>
         public bool CanOverride { get; }
         public bool IsEmpty { get => _end == _start; }
-        public int Length { get => _circularBuffer.Length - 1; }
         public bool IsFilledUp { get => ((_end + 1) % _circularBuffer.Length == _start) && !_circularBuffer[_start].Equals(_circularBuffer[_end]); }
 
+
         /// <summary>
         /// Initializes a circular buffer with initial length of 10
         /// </summary>
@@ -35,6 +39,7 @@ public CircularBuffer(int length, bool canOverride=true)
                 throw new ArgumentOutOfRangeException("length can not be zero or negative");
             }
             _circularBuffer = new T[length + 1];
+            _default = _circularBuffer[length];
             _end = 0;
             _start = 0;
             CanOverride = canOverride;
@@ -81,6 +86,106 @@ public T Pop()
             _start = (_start + 1) % _circularBuffer.Length;
             return result;
         }
+
+        #region IEnumerable Implementation
+        public IEnumerator<T> GetEnumerator() 
+        {
+            for (int i = 0; i < Count; i++) {
+                yield return _circularBuffer[i];
+            }
+        }
+
+        IEnumerator IEnumerable.GetEnumerator() 
+        {
+            return GetEnumerator();
+        }
+        #endregion
+
+        #region ICollection Implementation
+        /// <summary>
+        /// Returns the number of elements.
+        /// </summary>
+        public int Count 
+        {
+            get { return _length; }
+        }
+        /// <summary>
+        /// Checks whether this collection is readonly
+        /// </summary>
+        public bool IsReadOnly 
+        {
+            get { return false; }
+        }
+        /// <summary>
+        /// Clears this instance
+        /// </summary>
+        public void Clear() 
+        {
+            for (int i = 0; i < _circularBuffer.Length; i++) 
+            {
+                _circularBuffer[i] = _default;
+            }
+        }
+        /// <summary>
+        /// Checks whether the buffer contains an item
+        /// </summary>
+        public bool Contains(T item) 
+        {
+            return _circularBuffer.Contains(item);
+        }
+        /// <summary>
+        /// Copies this buffer to an array
+        /// </summary>
+        public void CopyTo(T[] array, int arrayIndex) 
+        {
+            if (array == null) 
+            {
+                throw new ArgumentNullException("array can not be null");
+            }
+
+            if (array.Length == 0 || arrayIndex >= array.Length || arrayIndex < 0) {
+                throw new IndexOutOfRangeException();
+            }
+     
+            // Get enumerator
+            var enumarator = GetEnumerator();
+
+            // Copy elements if there is any in the buffer and if the index is within the valid range
+            while (arrayIndex < array.Length) 
+            {
+                if (enumarator.MoveNext()) 
+                {
+                    array[arrayIndex] = enumarator.Current;
+                    arrayIndex++;
+                }
+                else 
+                {
+                    break;
+                }
+            }
+        }
+        /// <summary>
+        /// Removes an item from the buffer
+        /// </summary>
+        public bool Remove(T item) 
+        {
+            if (Contains(item)) 
+            {
+                for (int i = 0; i < _circularBuffer.Length; i++) 
+                {
+                    if (item.Equals(_circularBuffer[i])) 
+                    {
+                        _circularBuffer[i] = _default;
+                    }
+                }
+                return true;
+            }
+            else 
+            {
+                return false;
+            }
+        }
+        #endregion
     }
 
     public class CircularBufferFullException: Exception 

UnitTest/DataStructuresTests/CircularBufferTest.cs

@@ -11,7 +11,7 @@ public class CircularBufferTest
         public static void SetsFixedLength() 
         {
             var circularBuffer = new CircularBuffer<byte>(3);
-            var length = circularBuffer.Length;
+            var length = circularBuffer.Count;
             Assert.Equal(3, length);
         }
 
@@ -37,7 +37,7 @@ public static void ChecksIsFilledProperty()
         public static void InitializesWithDefaultLengthOf10() 
         {
             var circularBuffer = new CircularBuffer<byte>();
-            var length = circularBuffer.Length;
+            var length = circularBuffer.Count;
 
             Assert.Equal(10, length);
         }
@@ -138,5 +138,33 @@ public static void TestingWritingAndReadingSimultenouslyWithoutOverriding()
             Assert.Equal(4, result4);
             Assert.Equal(14, result5);
         }
+
+        [Fact]
+        public static void TestingICollectionImplementation() 
+        {
+            var circularBuffer = new CircularBuffer<byte>(3, false);
+            circularBuffer.Add(3);
+            circularBuffer.Add(34);
+            circularBuffer.Add(24);
+            //Testing contains
+            Assert.True(circularBuffer.Contains(3));
+            
+            //Testing CopyTo
+            var array = new byte[3];
+            circularBuffer.CopyTo(array, 0);
+            Assert.Equal(3, array[0]);
+            Assert.Equal(34, array[1]);
+            Assert.Equal(24, array[2]);
+            
+            //Testing Remove
+            Assert.True(circularBuffer.Remove(3));
+            Assert.False(circularBuffer.Remove(14));
+            
+            //Testing clear
+            circularBuffer.Clear();
+            Assert.Equal(0, circularBuffer.Pop());
+            Assert.Equal(0, circularBuffer.Pop());
+            Assert.Equal(0, circularBuffer.Pop());
+        }
     }
 }