merge to master

.github/workflows/dotnet-publish-package.yml

@@ -0,0 +1,42 @@
+# Pack NuGet package and push to nam20485's package registry
+# https://docs.github.com/en/packages/working-with-a-github-packages-registry/working-with-the-nuget-registry
+
+name: Pack and Publish .NET
+
+on:
+  push:
+    branches: [ "master", "development" ]
+
+env:
+  VERSION: ${{ vars.VERSION_PREFIX }}.${{ github.run_number }}
+
+jobs:
+  pack-and-push:
+
+    runs-on: ubuntu-22.04
+    permissions:
+      packages: write
+    steps:
+    - uses: actions/checkout@v3
+
+    - name: Setup .NET
+      uses: actions/setup-dotnet@v3
+      with:
+        dotnet-version: 7.0.400
+
+    - name: Build
+      run: dotnet build DataStructures --configuration Release /p:Version=${{ env.VERSION }} 
+
+    - name: Pack NuGet Package
+      run: dotnet pack DataStructures --include-symbols --configuration Release --no-build --no-restore /p:Version=${{ env.VERSION }}    
+
+    - name: Add NuGet Source
+      run: |
+        dotnet nuget add source --username nam20485 --password ${{ secrets.GITHUB_TOKEN }} --store-password-in-clear-text --name github "https://nuget.pkg.github.com/nam20485/index.json"
+
+    - name: Push Package
+      run: |
+        dotnet nuget push "DataStructures/bin/Release/DataStructures.${{ env.VERSION }}.nupkg" --source "github"
+        dotnet nuget push "DataStructures/bin/Release/DataStructures.${{ env.VERSION }}.snupkg" --source "github"
+
+

.github/workflows/dotnet.yml

@@ -0,0 +1,28 @@
+# This workflow will build a .NET project
+# For more information see: https://docs.github.com/en/actions/automating-builds-and-tests/building-and-testing-net
+
+name: Build and Test .NET
+
+on:
+  push:
+    branches: [ "development" ]
+  pull_request:
+    branches: [ "master", "development" ]
+
+jobs:
+  build-and-test:
+
+    runs-on: ubuntu-22.04
+
+    steps:
+    - uses: actions/checkout@v3
+    - name: Setup .NET
+      uses: actions/setup-dotnet@v3
+      with:
+        dotnet-version: 7.0.400
+    - name: Restore dependencies
+      run: dotnet restore
+    - name: Build
+      run: dotnet build --no-restore
+    - name: Test
+      run: dotnet test --no-build --verbosity normal

DataStructures/BinarySearchTree.cs

@@ -0,0 +1,19 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace Library.DataStructures
+{
+    public class BinarySearchTree<TValue> : Tree<TValue> 
+    {
+        //public class BinaryNode : Node
+        //{
+        //    //protected BinaryNode(Node parent, TValue value) : base(parent, value, )
+        //    //{
+        //    //}
+        //}
+
+    }
+}

DataStructures/CircularBuffer.cs

@@ -0,0 +1,224 @@
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace Library.DataStructures
+{
+    public class CircularBuffer<TValue> : DsCollectionBase<TValue>//, ICollection<TValue>
+    {
+        private readonly TValue[] _items;
+
+        private int _readIndex;     // _head
+        private int _writeIndex;    // _tail    
+
+        //private int _head;
+        //private int _tail;  
+        private bool _full;
+
+        public int Capacity => _items.Length;
+
+        public override int Count
+        {
+            get
+            {
+                if (_full)
+                {
+                    return Capacity;
+                }
+                else
+                {
+                    if (_readIndex >= _writeIndex)
+                    {
+                        return _readIndex - _writeIndex;
+                    }
+                    else
+                    {
+                        return Capacity + _readIndex - _writeIndex;
+                    }
+                }
+
+                //size_t size = max_size_;
+
+                //if (!full_)
+                //{
+                //    if (head_ >= tail_)
+                //    {
+                //        size = head_ - tail_;
+                //    }
+                //    else
+                //    {
+                //        size = max_size_ + head_ - tail_;
+                //    }
+                //}
+
+                //return size;
+            }
+        }
+
+        public CircularBuffer(int capacity)
+        {
+            _items = new TValue[capacity];            
+            _readIndex = 0;
+            _writeIndex = 0;
+            _full = false;
+        }
+
+        public CircularBuffer(IEnumerable<TValue> collection)
+            : this(collection.Count())
+        {
+            AddRange(collection);
+        }
+
+        public override void Add(TValue item)
+        {
+            AddLast(item);
+        }
+
+        public void AddLast(TValue item)
+        {
+            var overWroteReadIndex = false;
+            if (_writeIndex == _readIndex)
+            {
+                overWroteReadIndex = true;
+            }
+
+            _items[_writeIndex] = item;
+            Increment(ref _writeIndex);
+
+            if (overWroteReadIndex)
+            {
+                // we just overwrote the oldest item, increment the readIndex;
+                Increment(ref _readIndex);
+            }           
+        }
+
+        public override bool Contains(TValue item)
+        {
+            return IndexOf(item) != -1;
+        }
+
+        public int IndexOf(TValue item)
+        {
+            var index = _readIndex;
+            while (index <= _writeIndex)
+            {
+                if (Equals(_items[index], item))
+                {
+                    return index;
+                }
+                Increment(ref index);
+            }
+            return -1; ;
+        }
+
+        public override void Clear()
+        {
+            _writeIndex = 0;
+            _readIndex = 0;
+            Array.Clear(_items);
+        }
+
+        private void Increment(ref int index)
+        {
+            index++;
+            if (index == Capacity)
+            {
+                index = 0;
+            }
+        }
+
+        private void Decrement(ref int index)
+        {
+            index--;
+            if (index == -1)
+            {
+                index = Capacity - 1;
+            }
+        }
+
+        public override TValue Remove()
+        {
+            return RemoveFirst();
+        }
+
+        public void Enqueue(TValue value)
+        {
+            AddLast(value);
+        }
+
+        public TValue Dequeue()
+        {
+            return RemoveFirst();
+        }
+
+        private TValue RemoveFirst()
+        {
+            if (_writeIndex == _readIndex)
+            {
+                throw new InvalidOperationException("Cannot remove from empty buffer.");
+            }
+            else
+            {
+                var item = Peek();
+                Increment(ref _readIndex);
+                return item;
+            }            
+        }
+
+        public TValue Peek()
+        {
+            if (_writeIndex == _readIndex)
+            {
+                throw new InvalidOperationException("Buffer is empty.");
+            }
+            return _items[_readIndex];
+        }
+
+        public override IEnumerator<TValue> GetEnumerator()
+        {
+            throw new NotImplementedException();
+        }
+
+        public override IDsCollection<TValue> CopyOf()
+        {
+            throw new NotImplementedException();
+        }
+
+        protected override string GetStringRepresentation()
+        {
+            var sb = new StringBuilder();
+            sb.Append(ToList());
+            sb.Append(Environment.NewLine);
+
+            if (_readIndex < _writeIndex)
+            {                
+                sb.Append(new string(' ', _readIndex*3+1));
+                sb.Append('r');
+                sb.Append(new string(' ', (_writeIndex - _readIndex) * 3));
+                sb.Append('w');
+
+            }
+            else if (_writeIndex == _readIndex)
+            {
+                sb.Append(new string(' ', _readIndex * 3+1));
+                sb.Append("rw");
+            }
+            else
+            {
+                sb.Append(new string(' ', _writeIndex * 3+1));
+                sb.Append('r');
+                sb.Append(new string(' ', (_readIndex - _writeIndex) * 3));
+                sb.Append('w');
+            }
+            return sb.ToString();
+        }
+
+        protected override void CopyOnlyItemsTo(TValue[] array, int arrayIndex = 0)
+        {
+
+        }       
+    }
+}

DataStructures/DataStructures.csproj

@@ -1,9 +1,34 @@
-<Project Sdk="Microsoft.NET.Sdk">
+<Project Sdk="Microsoft.NET.Sdk">
 
   <PropertyGroup>
     <TargetFramework>net7.0</TargetFramework>
     <ImplicitUsings>enable</ImplicitUsings>
     <Nullable>enable</Nullable>
+    <RootNamespace>Library.$(MSBuildProjectName.Replace(" ", "_"))</RootNamespace>
+    <GenerateDocumentationFile>True</GenerateDocumentationFile>    
+    <RepositoryUrl>https://github.com/nam20485/Library</RepositoryUrl>
+    <PackageProjectUrl>https://github.com/nam20485/Library</PackageProjectUrl>
+    <Authors>nam20485</Authors>
+    <Company>nam20485.com</Company>
+    <IncludeSymbols>True</IncludeSymbols>
+    <SymbolPackageFormat>symbols.nupkg</SymbolPackageFormat>    
   </PropertyGroup>
 
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|AnyCPU'">
+    <NoWarn>1701;1702;CS1591</NoWarn>
+  </PropertyGroup>
+
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|AnyCPU'">
+    <NoWarn>1701;1702;CS1591</NoWarn>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <ProjectReference Include="..\Utils\Utils.csproj" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <Folder Include="Collections\" />
+    <Folder Include="Sets\" />
+  </ItemGroup>
+
 </Project>