Re-Implemented methods in ICollection interface based on Suggestions

Author: NdubuisiJr

DataStructures/Lists/CircularBuffer.cs

@@ -5,34 +5,67 @@
 
 namespace DataStructures.Lists 
 {
-    public class CircularBuffer<T> : IEnumerable<T> , ICollection<T> where T : IComparable<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
+        /// Returns the length of the buffer
+        /// </summary>
+        public int Length 
+        {
+            get 
+            {
+                return _circularBuffer.Length - 1;
+            }
+        }
+
+        /// <summary>
+        ///  Checks if no element is inserted into the buffer
         /// </summary>
-        public bool CanOverride { get; }
-        public bool IsEmpty { get => _end == _start; }
-        public bool IsFilledUp { get => ((_end + 1) % _circularBuffer.Length == _start) && !_circularBuffer[_start].Equals(_circularBuffer[_end]); }
+        public bool IsEmpty 
+        {
+            get 
+            {
+                return _count == 0;
+            }
+        }
 
+        /// <summary>
+        /// Checks if the buffer is filled up
+        /// </summary>
+        public bool IsFilledUp 
+        {
+            get 
+            {
+                return ((_end + 1) % _circularBuffer.Length == _start) && !_circularBuffer[_start].Equals(_circularBuffer[_end]);
+            }
+        }
+
+        /// <summary>
+        /// Controls whether data should be overridden when it is continously inserted without reading
+        /// </summary>
+        public bool CanOverride 
+        {
+            get;
+        }
 
         /// <summary>
         /// Initializes a circular buffer with initial length of 10
         /// </summary>
-        public CircularBuffer(bool canOverride=true) : this(_defaultBufferLength, canOverride) 
+        public CircularBuffer(bool canOverride = true) : this(_defaultBufferLength, canOverride) 
         {
         }
 
         /// <summary>
         /// Initializes a circular buffer with given length
         /// </summary>
         /// <param name="length">The length of the buffer</param>
-        public CircularBuffer(int length, bool canOverride=true) 
+        public CircularBuffer(int length, bool canOverride = true) 
         {
             if (length < 1) 
             {
@@ -51,18 +84,11 @@ public CircularBuffer(int length, bool canOverride=true)
         /// <param name="value">value to be added to the buffer</param>
         public void Add(T value) 
         {
-            if (CanOverride) 
-            {
-                innerInsert(value);
-            }
-            else 
+            if (CanOverride==false && IsFilledUp==true) 
             {
-                if (IsFilledUp) 
-                {
-                    throw new CircularBufferFullException($"Circular Buffer is filled up. {value} can not be inserted");
-                }
-                innerInsert(value);
+                throw new CircularBufferFullException($"Circular Buffer is filled up. {value} can not be inserted");
             }
+            innerInsert(value);
         }
 
         // Inserts data into the buffer without checking if it is full
@@ -74,6 +100,9 @@ private void innerInsert(T value)
             {
                 _start = (_start + 1) % _circularBuffer.Length;
             }
+
+            // Count should not be greater than the length of the buffer when overriding 
+            _count = _count < Length ? ++_count : _count;
         }
 
         /// <summary>
@@ -84,13 +113,16 @@ public T Pop()
             var result = _circularBuffer[_start];
             _circularBuffer[_start] = _circularBuffer[_end];
             _start = (_start + 1) % _circularBuffer.Length;
+            //Count should not go below Zero when poping an empty buffer.
+            _count = _count > 0 ? --_count : _count;
             return result;
         }
 
         #region IEnumerable Implementation
         public IEnumerator<T> GetEnumerator() 
         {
-            for (int i = 0; i < Count; i++) {
+            for (int i = 0; i < Count; i++) 
+            {
                 yield return _circularBuffer[i];
             }
         }
@@ -102,29 +134,34 @@ IEnumerator IEnumerable.GetEnumerator()
         #endregion
 
         #region ICollection Implementation
+        private int _count;
         /// <summary>
         /// Returns the number of elements.
         /// </summary>
         public int Count 
         {
-            get { return _length; }
+            get 
+            {
+                return _count;
+            }
         }
         /// <summary>
         /// Checks whether this collection is readonly
         /// </summary>
         public bool IsReadOnly 
         {
-            get { return false; }
+            get 
+            {
+                return false;
+            }
         }
         /// <summary>
         /// Clears this instance
         /// </summary>
         public void Clear() 
         {
-            for (int i = 0; i < _circularBuffer.Length; i++) 
-            {
-                _circularBuffer[i] = _default;
-            }
+            _count = 0;
+            _circularBuffer = new T[Length + 1];
         }
         /// <summary>
         /// Checks whether the buffer contains an item
@@ -143,10 +180,11 @@ public void CopyTo(T[] array, int arrayIndex)
                 throw new ArgumentNullException("array can not be null");
             }
 
-            if (array.Length == 0 || arrayIndex >= array.Length || arrayIndex < 0) {
+            if (array.Length == 0 || arrayIndex >= array.Length || arrayIndex < 0) 
+            {
                 throw new IndexOutOfRangeException();
             }
-     
+
             // Get enumerator
             var enumarator = GetEnumerator();
 
@@ -169,26 +207,23 @@ public void CopyTo(T[] array, int arrayIndex)
         /// </summary>
         public bool Remove(T item) 
         {
-            if (Contains(item)) 
+            var result = false;
+            for (int i = 0; i < _circularBuffer.Length; i++) 
             {
-                for (int i = 0; i < _circularBuffer.Length; i++) 
+                if (item.Equals(_circularBuffer[i])) 
                 {
-                    if (item.Equals(_circularBuffer[i])) 
-                    {
-                        _circularBuffer[i] = _default;
-                    }
+                    _circularBuffer[i] = _default;
+                    --_count;
+                    result = true;
                 }
-                return true;
-            }
-            else 
-            {
-                return false;
             }
+            return result;
+
         }
         #endregion
     }
 
-    public class CircularBufferFullException: Exception 
+    public class CircularBufferFullException : Exception 
     {
         public CircularBufferFullException(string message) : base(message) 
         {

UnitTest/DataStructuresTests/CircularBufferTest.cs

@@ -11,7 +11,7 @@ public class CircularBufferTest
         public static void SetsFixedLength() 
         {
             var circularBuffer = new CircularBuffer<byte>(3);
-            var length = circularBuffer.Count;
+            var length = circularBuffer.Length;
             Assert.Equal(3, length);
         }
 
@@ -37,7 +37,7 @@ public static void ChecksIsFilledProperty()
         public static void InitializesWithDefaultLengthOf10() 
         {
             var circularBuffer = new CircularBuffer<byte>();
-            var length = circularBuffer.Count;
+            var length = circularBuffer.Length;
 
             Assert.Equal(10, length);
         }
@@ -159,12 +159,15 @@ public static void TestingICollectionImplementation()
             //Testing Remove
             Assert.True(circularBuffer.Remove(3));
             Assert.False(circularBuffer.Remove(14));
-            
+
+            //Testing Count
+            Assert.Equal(2, circularBuffer.Count);
             //Testing clear
             circularBuffer.Clear();
             Assert.Equal(0, circularBuffer.Pop());
             Assert.Equal(0, circularBuffer.Pop());
             Assert.Equal(0, circularBuffer.Pop());
+            Assert.Empty(circularBuffer);
         }
     }
 }