warrentyexpired/ModernUO
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions 1

fix: Fixes map item iteration when multis are moved (#1562)

Browse source
This commit is contained in:
Kamron Batman 2023-10-22 13:22:11 -07:00 • committed by GitHub
parent f6491c0fe5
commit 4d8e9fc515
No known key found for this signature in database
GPG key ID: 4AEE18F83AFDEB23
2 changed files with 25 additions and 7 deletions
Download patch file Download diff file Expand all files Collapse all files

453
Projects/Server/Collections/ValueLinkList.cs Normal file
View file

@ -0,0 +1,453 @@
/*************************************************************************
* ModernUO *
* Copyright 2019-2023 - ModernUO Development Team *
* Email: hi@modernuo.com *
* File: ValueLinkList.cs *
* *
* This program is free software: you can redistribute it and/or modify *
* it under the terms of the GNU General Public License as published by *
* the Free Software Foundation, either version 3 of the License, or *
* (at your option) any later version. *
* *
* You should have received a copy of the GNU General Public License *
* along with this program. If not, see <http://www.gnu.org/licenses/>. *
*************************************************************************/
using System;
using System.Runtime.CompilerServices;
namespace Server.Collections;
public interface IValueLinkListNode<T> where T : class
{
public T Next { get; set; }
public T Previous { get; set; }
public bool OnLinkList { get; set; }
}
public struct ValueLinkList<T> where T : class, IValueLinkListNode<T>
{
public int Count { get; internal set; }
public T First { get; internal set; }
public T Last { get; internal set; }
public void Remove(T node)
{
if (node == null)
{
return;
}
if (!node.OnLinkList)
{
throw new ArgumentException("Attempted to remove a node that is not on the list.");
}
if (node.Previous == null)
{
// If previous is null, then it is the first element.
if (First != node)
{
throw new ArgumentException("Attempted to remove a node that is not on the list.");
}
if (First == Last)
{
Last = null;
First = null;
}
else
{
First = node.Next;
}
if (node.Next != null)
{
node.Next.Previous = null;
}
}
else
{
node.Previous.Next = node.Next;
// If next is null, then it is the last element.
if (node.Next == null)
{
Last = node.Previous;
}
else
{
node.Next.Previous = node.Previous;
}
}
node.Next = null;
node.Previous = null;
node.OnLinkList = false;
Count--;
if (Count < 0)
{
throw new Exception("Count is negative!");
}
}
// Remove all entries before this node, not including this node.
public void RemoveAllBefore(T e)
{
if (e == null)
{
return;
}
if (!e.OnLinkList)
{
throw new ArgumentException("Attempted to remove nodes before a node that is not on the list.");
}
if (e.Previous == null)
{
return;
}
var current = e.Previous;
e.Previous = null;
while (current != null)
{
var previous = current.Previous;
current.OnLinkList = false;
current.Next = null;
current.Previous = null;
Count--;
if (Count < 0)
{
throw new Exception("Count is negative!");
}
current = previous;
}
First = e;
}
// Remove all entries after this node, not including this node.
public void RemoveAllAfter(T e)
{
if (e == null)
{
return;
}
if (!e.OnLinkList)
{
throw new ArgumentException("Attempted to remove nodes after a node that is not on the list.");
}
if (e.Next == null)
{
return;
}
var current = e.Next;
e.Next = null;
while (current != null)
{
var next = current.Next;
current.OnLinkList = false;
current.Next = null;
current.Previous = null;
Count--;
if (Count < 0)
{
throw new Exception("Count is negative!");
}
current = next;
}
Last = e;
}
public void AddLast(T e)
{
if (e == null)
{
return;
}
if (e.OnLinkList)
{
throw new ArgumentException("Attempted to add a node that is already on a list.");
}
if (Last != null)
{
AddAfter(Last, e);
}
else
{
First = e;
Last = e;
Count = 1;
e.OnLinkList = true;
}
}
public void AddFirst(T e)
{
if (e == null)
{
return;
}
if (e.OnLinkList)
{
throw new ArgumentException("Attempted to add a node that is already on a list.");
}
if (First != null)
{
AddBefore(First, e);
}
else
{
First = e;
Last = e;
Count = 1;
e.OnLinkList = true;
}
}
public void AddBefore(T existing, T node)
{
if (node == null)
{
return;
}
ArgumentNullException.ThrowIfNull(existing);
if (!existing.OnLinkList)
{
throw new ArgumentException($"Argument '{nameof(existing)}' must be a node on a list.");
}
if (node.OnLinkList)
{
throw new ArgumentException("Attempted to add a node that is already on a list.");
}
node.Next = existing;
node.Previous = existing.Previous;
if (existing.Previous != null)
{
existing.Previous.Next = node;
}
else
{
First = node;
}
existing.Previous = node;
node.OnLinkList = true;
Count++;
}
public void AddAfter(T existing, T node)
{
if (node == null)
{
return;
}
ArgumentNullException.ThrowIfNull(existing);
if (!existing.OnLinkList)
{
throw new ArgumentException($"Argument '{nameof(existing)}' must be a node on a list.");
}
if (node.OnLinkList)
{
throw new ArgumentException("Attempted to add a node that is already on a list.");
}
node.Previous = existing;
node.Next = existing.Next;
if (existing.Next != null)
{
existing.Next.Previous = node;
}
else
{
Last = node;
}
existing.Next = node;
node.OnLinkList = true;
Count++;
}
public void RemoveAll()
{
var current = First;
while (current != null)
{
var next = current.Next;
current.OnLinkList = false;
current.Next = null;
current.Previous = null;
current = next;
}
First = null;
Last = null;
Count = 0;
}
public void AddLast(ref ValueLinkList<T> otherList, T start, T end)
{
// Should we check if start and end actually exist on the other list?
if (otherList.Count == 0 || otherList.Count == 1 && (start != end || otherList.First != start))
{
throw new ArgumentException("Attempted to add nodes that are not on the specified linklist.");
}
if (start.Previous != null)
{
start.Previous.Next = end.Next;
}
else
{
// Start is first
otherList.First = end.Next;
}
if (end.Next != null)
{
end.Next.Previous = start.Previous;
}
else
{
otherList.Last = start.Previous;
}
var count = 1;
var current = start;
// Assume start and end are in the right order, or bad things happen (crash).
while (current != end)
{
count++;
current = current.Next;
}
otherList.Count -= count;
if (otherList.Count < 0)
{
throw new Exception("Count is negative!");
}
if (Last != null)
{
Last.Next = start;
start.Previous = Last;
}
else
{
First = start;
}
Last = end;
Count += count;
}
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public ValueListEnumerator GetEnumerator() => new(First);
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public DescendingValueListEnumerator ByDescending() => new(Last);
public ref struct ValueListEnumerator
{
private T _head;
private T _current;
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public ValueListEnumerator(T head)
{
_head = head;
_current = null;
}
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public bool MoveNext()
{
if (_current == null)
{
_current = _head;
_head = null;
}
else
{
_current = _current.Next;
}
return _current != null;
}
public T Current
{
[MethodImpl(MethodImplOptions.AggressiveInlining)]
get => _current;
}
}
public ref struct DescendingValueListEnumerator
{
private T _tail;
private T _current;
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public DescendingValueListEnumerator(T head)
{
_tail = head;
_current = null;
}
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public bool MoveNext()
{
if (_current == null)
{
_current = _tail;
_tail = null;
}
else
{
_current = _current.Previous;
}
return _current != null;
}
public T Current
{
[MethodImpl(MethodImplOptions.AggressiveInlining)]
get => _current;
}
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public DescendingValueListEnumerator GetEnumerator() => this;
}
}