switch root namespace name to NITLOAD

2026-09-02 18:15:03 +08:00
parent 4218baad48
commit 7c7101ee48
502 changed files with 710 additions and 721 deletions
@@ -0,0 +1,203 @@
+// -----------------------------------------------------------------------------
+// file="CapacityFixedList"
+// Project: StgSharp
+// Copyright (c) Nitload.
+// SPDX-License-Identifier: MIT
+// -----------------------------------------------------------------------------
+
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using System.Runtime.CompilerServices;
+
+namespace Nitload.Common.Collections
+{
+    public static class CapacityFixedListBuilder
+    {
+
+        internal static CapacityFixedList<T> Create<T>(
+                                             ReadOnlySpan<T> values
+        )
+        {
+            return new CapacityFixedList<T>(values);
+        }
+
+    }
+
+    [CollectionBuilder(typeof(CapacityFixedListBuilder), nameof(CapacityFixedListBuilder.Create))]
+    public class CapacityFixedList<T> : IList<T>
+    {
+
+        private T[] _values;
+        private readonly int _capacity;
+        private int _index;
+
+        public CapacityFixedList(
+               int size
+        )
+        {
+            _values = new T[size];
+            _capacity = size;
+        }
+
+        public CapacityFixedList(
+               ReadOnlySpan<T> values
+        )
+        {
+            _values = values.ToArray();
+        }
+
+        public T this[
+                 int index
+        ]
+        {
+            get => index < _index ?
+                   _values[index] :
+                   throw new ArgumentOutOfRangeException(nameof(index));
+            set => _values[index] =
+                   index < _index ? value : throw new ArgumentOutOfRangeException(nameof(index));
+        }
+
+        public bool IsReadOnly => false;
+
+        public int Count => _index + 1;
+
+        public void Add(
+                    T item
+        )
+        {
+            if (_index < _capacity - 1)
+            {
+                _index++;
+                this[_index] = item;
+            }
+        }
+
+        public void Clear()
+        {
+            if (RuntimeHelpers.IsReferenceOrContainsReferences<T>()) {
+                Array.Fill(_values, default);
+            }
+            _index = 0;
+        }
+
+        public bool Contains(
+                    T item
+        )
+        {
+            if (item is null) {
+                return false;
+            }
+            for (int i = 0; i <= _index; i++)
+            {
+                if (item.Equals(_values[i])) {
+                    return true;
+                }
+            }
+            return false;
+        }
+
+        public void CopyTo(
+                    T[] array,
+                    int arrayIndex
+        )
+        {
+            _values.CopyTo(array, arrayIndex);
+        }
+
+        public IEnumerator<T> GetEnumerator()
+        {
+            for (int i = 0; i <= _index; i++) {
+                yield return _values[i];
+            }
+        }
+
+        public int IndexOf(
+                   T item
+        )
+        {
+            T v;
+            for (int i = 0; i <= _index; i++)
+            {
+                if ((v = _values[i]) != null && v.Equals(item)) {
+                    return i;
+                }
+            }
+            return -1;
+        }
+
+        public bool Remove(
+                    T item
+        )
+        {
+            T v;
+            for (int i = 0; i <= _index; i++)
+            {
+                if ((v = _values[i]) != null && v.Equals(item))
+                {
+                    _values[i] = _values[_index];
+                    _index--;
+                    return true;
+                }
+            }
+            return false;
+        }
+
+        public void RemoveAll(
+                    Predicate<T> predicate
+        )
+        {
+            if (predicate is null) {
+                return;
+            }
+            for (int i = _index; i > 0; i--)
+            {
+                if (predicate(_values[i]))
+                {
+                    _values[i] = _values[_index];
+                    _index--;
+                }
+            }
+        }
+
+        public void RemoveAt(
+                    int index
+        )
+        {
+            if (index <= _index)
+            {
+                Array.Copy(_values, index + 1, _values, index, _index - index);
+                if (RuntimeHelpers.IsReferenceOrContainsReferences<T>()) {
+                    _values[_index] = default!;
+                }
+                _index--;
+            }
+        }
+
+        public void Resize(
+                    int newSize
+        )
+        {
+            Array.Resize(ref _values, newSize);
+        }
+
+        internal Span<T> ToSpan()
+        {
+            return _values;
+        }
+
+        IEnumerator IEnumerable.GetEnumerator()
+        {
+            yield return GetEnumerator();
+        }
+
+        void IList<T>.Insert(
+                      int index,
+                      T item
+        )
+        {
+            throw new NotSupportedException();
+        }
+
+    }//------------------------------------- End of Class ------------------------------------------
+}