From e8ac54e738995b026946b8f5d8bae93cd10c44a2 Mon Sep 17 00:00:00 2001
From: neuecc <ils@neue.cc>
Date: Wed, 18 Aug 2021 19:48:30 +0900
Subject: [PATCH] working linkedlist

---
 .../ObservableLinkedList.Views.cs             | 64 +++++++++++++++++--
 .../ObservableLinkedList.cs                   | 11 +++-
 2 files changed, 66 insertions(+), 9 deletions(-)

diff --git a/src/ObservableCollections/ObservableLinkedList.Views.cs b/src/ObservableCollections/ObservableLinkedList.Views.cs
index 92439cf..1c8cb20 100644
--- a/src/ObservableCollections/ObservableLinkedList.Views.cs
+++ b/src/ObservableCollections/ObservableLinkedList.Views.cs
@@ -14,6 +14,7 @@ namespace ObservableCollections
         sealed class View<TView> : ISynchronizedView<LinkedListNode<T>, TView>
         {
             readonly ObservableLinkedList<T> source;
+            readonly Dictionary<LinkedListNode<T>, LinkedListNode<(LinkedListNode<T>, TView)>> nodeMap;
             readonly LinkedList<(LinkedListNode<T>, TView)> list;
             readonly Func<LinkedListNode<T>, TView> selector;
 
@@ -72,25 +73,74 @@ namespace ObservableCollections
             {
                 lock (SyncRoot)
                 {
+                    // Range operations is not supported.
                     switch (e.Action)
                     {
                         case NotifyCollectionChangedAction.Add:
                             {
-                                // AddAfter
-                                if (e.OldItem != null)
+                                var view = selector(e.NewItem);
+                                var value = (e.NewItem, view);
+                                LinkedListNode<(LinkedListNode<T>, TView)>? addNode = null;
+
+                                if (e.OldItem == null)
                                 {
+                                    // AddFirst
+                                    if (e.NewStartingIndex == 0)
+                                    {
+                                        addNode = list.AddFirst(value);
+                                    }
+                                    // AddLast
+                                    else
+                                    {
+                                        addNode = list.AddLast(value);
+                                    }
+                                }
+                                else
+                                {
+                                    // AddBefore
+                                    if (e.NewStartingIndex == -1)
+                                    {
+                                        if (nodeMap.TryGetValue(e.OldItem, out var node))
+                                        {
+                                            addNode = list.AddBefore(node, value);
+                                        }
+                                    }
+                                    // AddAfter
+                                    else
+                                    {
+                                        if (nodeMap.TryGetValue(e.OldItem, out var node))
+                                        {
+                                            addNode = list.AddAfter(node, value);
+                                        }
+                                    }
                                 }
 
+                                if (addNode != null)
+                                {
+                                    nodeMap.Add(e.NewItem, addNode);
+                                    // TODO: filter invoke.
+                                }
                             }
                             break;
                         case NotifyCollectionChangedAction.Remove:
-                            break;
-                        case NotifyCollectionChangedAction.Replace:
-                            break;
-                        case NotifyCollectionChangedAction.Move:
+                            {
+                                if (nodeMap.Remove(e.OldItem, out var node))
+                                {
+                                    list.Remove(node);
+                                    // TODO:filter invoke
+                                }
+                            }
                             break;
                         case NotifyCollectionChangedAction.Reset:
+                            {
+                                nodeMap.Clear();
+                                list.Clear();
+
+                                // TODO:filter invoke
+                            }
                             break;
+                        case NotifyCollectionChangedAction.Replace:
+                        case NotifyCollectionChangedAction.Move:
                         default:
                             break;
                     }
@@ -98,4 +148,4 @@ namespace ObservableCollections
             }
         }
     }
-}
+}
\ No newline at end of file
diff --git a/src/ObservableCollections/ObservableLinkedList.cs b/src/ObservableCollections/ObservableLinkedList.cs
index a7b93af..799990f 100644
--- a/src/ObservableCollections/ObservableLinkedList.cs
+++ b/src/ObservableCollections/ObservableLinkedList.cs
@@ -63,8 +63,6 @@ namespace ObservableCollections
             {
                 var newNode = list.AddBefore(node, value);
 
-                // list.
-
                 // special event, oldItem is target, newStartingIndex:-1 = before
                 var ev = new NotifyCollectionChangedEventArgs<LinkedListNode<T>>(
                     NotifyCollectionChangedAction.Add, isSingleItem: true,
@@ -126,6 +124,15 @@ namespace ObservableCollections
             }
         }
 
+        public void Clear()
+        {
+            lock (SyncRoot)
+            {
+                list.Clear();
+                CollectionChanged?.Invoke(NotifyCollectionChangedEventArgs<LinkedListNode<T>>.Reset());
+            }
+        }
+
         public IEnumerator<LinkedListNode<T>> GetEnumerator()
         {
             throw new NotImplementedException();