aaru-dps/Aaru.Helpers
1
0
Fork 0
mirror of https://github.com/aaru-dps/Aaru.Helpers.git synced 2025-12-16 19:24:35 +00:00
Code Issues Packages Projects Releases Wiki Activity

Merge branch 'master' into alcoholfix

Browse Source
This commit is contained in:
Natalia Portillo
2018-07-20 20:50:20 +01:00
committed by GitHub
parent 6bf3f9557e 88a8697f48
commit 6ed427421f
9 changed files with 1 additions and 1997 deletions
Download Patch File Download Diff File Expand all files Collapse all files

13
DiscImageChef.Helpers.csproj
View File

@@ -12,7 +12,7 @@
<EnableDefaultCompileItems>false</EnableDefaultCompileItems>
<TargetFramework>net461</TargetFramework>
<GenerateAssemblyInfo>true</GenerateAssemblyInfo>
<Version>4.5.1.1692</Version>
<Version>4.5.99.1693</Version>
<Company>Claunia.com</Company>
<Copyright>Copyright © 2011-2018 Natalia Portillo</Copyright>
<Product>The Disc Image Chef</Product>
@@ -55,14 +55,6 @@
<Compile Include="ArrayIsEmpty.cs" />
<Compile Include="BigEndianMarshal.cs" />
<Compile Include="CompareBytes.cs" />
<Compile Include="Extents\ExtentsLong.cs" />
<Compile Include="Extents\ExtentsULong.cs" />
<Compile Include="Extents\ExtentsInt.cs" />
<Compile Include="Extents\ExtentsUInt.cs" />
<Compile Include="Extents\ExtentsShort.cs" />
<Compile Include="Extents\ExtentsUShort.cs" />
<Compile Include="Extents\ExtentsByte.cs" />
<Compile Include="Extents\ExtentsSByte.cs" />
<Compile Include="CountBits.cs" />
<Compile Include="CHS.cs" />
</ItemGroup>
@@ -77,9 +69,6 @@
<Link>LICENSE.LGPL</Link>
</EmbeddedResource>
</ItemGroup>
<ItemGroup>
<Folder Include="Extents\" />
</ItemGroup>
<ItemGroup>
<PackageReference Include="Unclassified.NetRevisionTask" Version="0.2.2-beta" />
</ItemGroup>

248
Extents/ExtentsByte.cs
View File

@@ -1,248 +0,0 @@
// /***************************************************************************
// The Disc Image Chef
// ----------------------------------------------------------------------------
//
// Filename : ExtentsByte.cs
// Author(s) : Natalia Portillo <claunia@claunia.com>
//
// Component : Extent helpers.
//
// --[ Description ] ----------------------------------------------------------
//
// Provides extents for byte types.
//
// --[ License ] --------------------------------------------------------------
//
// This library is free software; you can redistribute it and/or modify
// it under the terms of the GNU Lesser General Public License as
// published by the Free Software Foundation; either version 2.1 of the
// License, or (at your option) any later version.
//
// This library is distributed in the hope that it will be useful, but
// WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
// Lesser General Public License for more details.
//
// You should have received a copy of the GNU Lesser General Public
// License along with this library; if not, see <http://www.gnu.org/licenses/>.
//
// ----------------------------------------------------------------------------
// Copyright © 2011-2018 Natalia Portillo
// ****************************************************************************/
using System;
using System.Collections.Generic;
using System.Linq;
namespace Extents
{
/// <summary>
/// Implements extents for <see cref="byte" />
/// </summary>
public class ExtentsByte
{
List<Tuple<byte, byte>> backend;
/// <summary>
/// Initialize an empty list of extents
/// </summary>
public ExtentsByte()
{
backend = new List<Tuple<byte, byte>>();
}
/// <summary>
/// Initializes extents with an specific list
/// </summary>
/// <param name="list">List of extents as tuples "start, end"</param>
public ExtentsByte(IEnumerable<Tuple<byte, byte>> list)
{
backend = list.OrderBy(t => t.Item1).ToList();
}
/// <summary>
/// Gets a count of how many extents are stored
/// </summary>
public int Count => backend.Count;
/// <summary>
/// Adds the specified number to the corresponding extent, or creates a new one
/// </summary>
/// <param name="item"></param>
public void Add(byte item)
{
Tuple<byte, byte> removeOne = null;
Tuple<byte, byte> removeTwo = null;
Tuple<byte, byte> itemToAdd = null;
for(int i = 0; i < backend.Count; i++)
{
// Already contained in an extent
if(item >= backend[i].Item1 && item <= backend[i].Item2) return;
// Expands existing extent start
if(item == backend[i].Item1 - 1)
{
removeOne = backend[i];
if(i > 0 && item == backend[i - 1].Item2 + 1)
{
removeTwo = backend[i - 1];
itemToAdd = new Tuple<byte, byte>(backend[i - 1].Item1, backend[i].Item2);
}
else itemToAdd = new Tuple<byte, byte>(item, backend[i].Item2);
break;
}
// Expands existing extent end
if(item != backend[i].Item2 + 1) continue;
removeOne = backend[i];
if(i < backend.Count - 1 && item == backend[i + 1].Item1 - 1)
{
removeTwo = backend[i + 1];
itemToAdd = new Tuple<byte, byte>(backend[i].Item1, backend[i + 1].Item2);
}
else itemToAdd = new Tuple<byte, byte>(backend[i].Item1, item);
break;
}
if(itemToAdd != null)
{
backend.Remove(removeOne);
backend.Remove(removeTwo);
backend.Add(itemToAdd);
}
else backend.Add(new Tuple<byte, byte>(item, item));
// Sort
backend = backend.OrderBy(t => t.Item1).ToList();
}
/// <summary>
/// Adds a new extent
/// </summary>
/// <param name="start">First element of the extent</param>
/// <param name="end">
/// Last element of the extent or if <see cref="run" /> is <c>true</c> how many elements the extent runs
/// for
/// </param>
/// <param name="run">If set to <c>true</c>, <see cref="end" /> indicates how many elements the extent runs for</param>
public void Add(byte start, byte end, bool run = false)
{
byte realEnd;
if(run) realEnd = (byte)(start + end - 1);
else realEnd = end;
// TODO: Optimize this
for(byte t = start; t <= realEnd; t++) Add(t);
}
/// <summary>
/// Checks if the specified item is contained by an extent on this instance
/// </summary>
/// <param name="item">Item to seach for</param>
/// <returns><c>true</c> if any of the extents on this instance contains the item</returns>
public bool Contains(byte item)
{
return backend.Any(extent => item >= extent.Item1 && item <= extent.Item2);
}
/// <summary>
/// Removes all extents from this instance
/// </summary>
public void Clear()
{
backend.Clear();
}
/// <summary>
/// Removes an item from the extents in this instance
/// </summary>
/// <param name="item">Item to remove</param>
/// <returns><c>true</c> if the item was contained in a known extent and removed, false otherwise</returns>
public bool Remove(byte item)
{
Tuple<byte, byte> toRemove = null;
Tuple<byte, byte> toAddOne = null;
Tuple<byte, byte> toAddTwo = null;
foreach(Tuple<byte, byte> extent in backend)
{
// Extent is contained and not a border
if(item > extent.Item1 && item < extent.Item2)
{
toRemove = extent;
toAddOne = new Tuple<byte, byte>(extent.Item1, (byte)(item - 1));
toAddTwo = new Tuple<byte, byte>((byte)(item + 1), extent.Item2);
break;
}
// Extent is left border, but not only element
if(item == extent.Item1 && item != extent.Item2)
{
toRemove = extent;
toAddOne = new Tuple<byte, byte>((byte)(item + 1), extent.Item2);
break;
}
// Extent is right border, but not only element
if(item != extent.Item1 && item == extent.Item2)
{
toRemove = extent;
toAddOne = new Tuple<byte, byte>(extent.Item1, (byte)(item - 1));
break;
}
// Extent is only element
if(item != extent.Item1 || item != extent.Item2) continue;
toRemove = extent;
break;
}
// Item not found
if(toRemove == null) return false;
backend.Remove(toRemove);
if(toAddOne != null) backend.Add(toAddOne);
if(toAddTwo != null) backend.Add(toAddTwo);
// Sort
backend = backend.OrderBy(t => t.Item1).ToList();
return true;
}
/// <summary>
/// Converts the list of extents to an array of <see cref="Tuple" /> where T1 is first element of the extent and T2 is
/// last element
/// </summary>
/// <returns>Array of <see cref="Tuple" /></returns>
public Tuple<byte, byte>[] ToArray()
{
return backend.ToArray();
}
/// <summary>
/// Gets the first element of the extent that contains the specified item
/// </summary>
/// <param name="item">Item</param>
/// <param name="start">First element of extent</param>
/// <returns><c>true</c> if item was found in an extent, false otherwise</returns>
public bool GetStart(byte item, out byte start)
{
start = 0;
foreach(Tuple<byte, byte> extent in backend.Where(extent => item >= extent.Item1 && item <= extent.Item2))
{
start = extent.Item1;
return true;
}
return false;
}
}
}

248
Extents/ExtentsInt.cs
View File

@@ -1,248 +0,0 @@
// /***************************************************************************
// The Disc Image Chef
// ----------------------------------------------------------------------------
//
// Filename : ExtentsInt.cs
// Author(s) : Natalia Portillo <claunia@claunia.com>
//
// Component : Extent helpers.
//
// --[ Description ] ----------------------------------------------------------
//
// Provides extents for int types.
//
// --[ License ] --------------------------------------------------------------
//
// This library is free software; you can redistribute it and/or modify
// it under the terms of the GNU Lesser General Public License as
// published by the Free Software Foundation; either version 2.1 of the
// License, or (at your option) any later version.
//
// This library is distributed in the hope that it will be useful, but
// WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
// Lesser General Public License for more details.
//
// You should have received a copy of the GNU Lesser General Public
// License aint with this library; if not, see <http://www.gnu.org/licenses/>.
//
// ----------------------------------------------------------------------------
// Copyright © 2011-2018 Natalia Portillo
// ****************************************************************************/
using System;
using System.Collections.Generic;
using System.Linq;
namespace Extents
{
/// <summary>
/// Implements extents for <see cref="int" />
/// </summary>
public class ExtentsInt
{
List<Tuple<int, int>> backend;
/// <summary>
/// Initialize an empty list of extents
/// </summary>
public ExtentsInt()
{
backend = new List<Tuple<int, int>>();
}
/// <summary>
/// Initializes extents with an specific list
/// </summary>
/// <param name="list">List of extents as tuples "start, end"</param>
public ExtentsInt(IEnumerable<Tuple<int, int>> list)
{
backend = list.OrderBy(t => t.Item1).ToList();
}
/// <summary>
/// Gets a count of how many extents are stored
/// </summary>
public int Count => backend.Count;
/// <summary>
/// Adds the specified number to the corresponding extent, or creates a new one
/// </summary>
/// <param name="item"></param>
public void Add(int item)
{
Tuple<int, int> removeOne = null;
Tuple<int, int> removeTwo = null;
Tuple<int, int> itemToAdd = null;
for(int i = 0; i < backend.Count; i++)
{
// Already contained in an extent
if(item >= backend[i].Item1 && item <= backend[i].Item2) return;
// Expands existing extent start
if(item == backend[i].Item1 - 1)
{
removeOne = backend[i];
if(i > 0 && item == backend[i - 1].Item2 + 1)
{
removeTwo = backend[i - 1];
itemToAdd = new Tuple<int, int>(backend[i - 1].Item1, backend[i].Item2);
}
else itemToAdd = new Tuple<int, int>(item, backend[i].Item2);
break;
}
// Expands existing extent end
if(item != backend[i].Item2 + 1) continue;
removeOne = backend[i];
if(i < backend.Count - 1 && item == backend[i + 1].Item1 - 1)
{
removeTwo = backend[i + 1];
itemToAdd = new Tuple<int, int>(backend[i].Item1, backend[i + 1].Item2);
}
else itemToAdd = new Tuple<int, int>(backend[i].Item1, item);
break;
}
if(itemToAdd != null)
{
backend.Remove(removeOne);
backend.Remove(removeTwo);
backend.Add(itemToAdd);
}
else backend.Add(new Tuple<int, int>(item, item));
// Sort
backend = backend.OrderBy(t => t.Item1).ToList();
}
/// <summary>
/// Adds a new extent
/// </summary>
/// <param name="start">First element of the extent</param>
/// <param name="end">
/// Last element of the extent or if <see cref="run" /> is <c>true</c> how many elements the extent runs
/// for
/// </param>
/// <param name="run">If set to <c>true</c>, <see cref="end" /> indicates how many elements the extent runs for</param>
public void Add(int start, int end, bool run = false)
{
int realEnd;
if(run) realEnd = start + end - 1;
else realEnd = end;
// TODO: Optimize this
for(int t = start; t <= realEnd; t++) Add(t);
}
/// <summary>
/// Checks if the specified item is contained by an extent on this instance
/// </summary>
/// <param name="item">Item to seach for</param>
/// <returns><c>true</c> if any of the extents on this instance contains the item</returns>
public bool Contains(int item)
{
return backend.Any(extent => item >= extent.Item1 && item <= extent.Item2);
}
/// <summary>
/// Removes all extents from this instance
/// </summary>
public void Clear()
{
backend.Clear();
}
/// <summary>
/// Removes an item from the extents in this instance
/// </summary>
/// <param name="item">Item to remove</param>
/// <returns><c>true</c> if the item was contained in a known extent and removed, false otherwise</returns>
public bool Remove(int item)
{
Tuple<int, int> toRemove = null;
Tuple<int, int> toAddOne = null;
Tuple<int, int> toAddTwo = null;
foreach(Tuple<int, int> extent in backend)
{
// Extent is contained and not a border
if(item > extent.Item1 && item < extent.Item2)
{
toRemove = extent;
toAddOne = new Tuple<int, int>(extent.Item1, item - 1);
toAddTwo = new Tuple<int, int>(item + 1, extent.Item2);
break;
}
// Extent is left border, but not only element
if(item == extent.Item1 && item != extent.Item2)
{
toRemove = extent;
toAddOne = new Tuple<int, int>(item + 1, extent.Item2);
break;
}
// Extent is right border, but not only element
if(item != extent.Item1 && item == extent.Item2)
{
toRemove = extent;
toAddOne = new Tuple<int, int>(extent.Item1, item - 1);
break;
}
// Extent is only element
if(item != extent.Item1 || item != extent.Item2) continue;
toRemove = extent;
break;
}
// Item not found
if(toRemove == null) return false;
backend.Remove(toRemove);
if(toAddOne != null) backend.Add(toAddOne);
if(toAddTwo != null) backend.Add(toAddTwo);
// Sort
backend = backend.OrderBy(t => t.Item1).ToList();
return true;
}
/// <summary>
/// Converts the list of extents to an array of <see cref="Tuple" /> where T1 is first element of the extent and T2 is
/// last element
/// </summary>
/// <returns>Array of <see cref="Tuple" /></returns>
public Tuple<int, int>[] ToArray()
{
return backend.ToArray();
}
/// <summary>
/// Gets the first element of the extent that contains the specified item
/// </summary>
/// <param name="item">Item</param>
/// <param name="start">First element of extent</param>
/// <returns><c>true</c> if item was found in an extent, false otherwise</returns>
public bool GetStart(int item, out int start)
{
start = 0;
foreach(Tuple<int, int> extent in backend.Where(extent => item >= extent.Item1 && item <= extent.Item2))
{
start = extent.Item1;
return true;
}
return false;
}
}
}

248
Extents/ExtentsLong.cs
View File

@@ -1,248 +0,0 @@
// /***************************************************************************
// The Disc Image Chef
// ----------------------------------------------------------------------------
//
// Filename : ExtentsLong.cs
// Author(s) : Natalia Portillo <claunia@claunia.com>
//
// Component : Extent helpers.
//
// --[ Description ] ----------------------------------------------------------
//
// Provides extents for long types.
//
// --[ License ] --------------------------------------------------------------
//
// This library is free software; you can redistribute it and/or modify
// it under the terms of the GNU Lesser General Public License as
// published by the Free Software Foundation; either version 2.1 of the
// License, or (at your option) any later version.
//
// This library is distributed in the hope that it will be useful, but
// WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
// Lesser General Public License for more details.
//
// You should have received a copy of the GNU Lesser General Public
// License along with this library; if not, see <http://www.gnu.org/licenses/>.
//
// ----------------------------------------------------------------------------
// Copyright © 2011-2018 Natalia Portillo
// ****************************************************************************/
using System;
using System.Collections.Generic;
using System.Linq;
namespace Extents
{
/// <summary>
/// Implements extents for <see cref="long" />
/// </summary>
public class ExtentsLong
{
List<Tuple<long, long>> backend;
/// <summary>
/// Initialize an empty list of extents
/// </summary>
public ExtentsLong()
{
backend = new List<Tuple<long, long>>();
}
/// <summary>
/// Initializes extents with an specific list
/// </summary>
/// <param name="list">List of extents as tuples "start, end"</param>
public ExtentsLong(IEnumerable<Tuple<long, long>> list)
{
backend = list.OrderBy(t => t.Item1).ToList();
}
/// <summary>
/// Gets a count of how many extents are stored
/// </summary>
public int Count => backend.Count;
/// <summary>
/// Adds the specified number to the corresponding extent, or creates a new one
/// </summary>
/// <param name="item"></param>
public void Add(long item)
{
Tuple<long, long> removeOne = null;
Tuple<long, long> removeTwo = null;
Tuple<long, long> itemToAdd = null;
for(int i = 0; i < backend.Count; i++)
{
// Already contained in an extent
if(item >= backend[i].Item1 && item <= backend[i].Item2) return;
// Expands existing extent start
if(item == backend[i].Item1 - 1)
{
removeOne = backend[i];
if(i > 0 && item == backend[i - 1].Item2 + 1)
{
removeTwo = backend[i - 1];
itemToAdd = new Tuple<long, long>(backend[i - 1].Item1, backend[i].Item2);
}
else itemToAdd = new Tuple<long, long>(item, backend[i].Item2);
break;
}
// Expands existing extent end
if(item != backend[i].Item2 + 1) continue;
removeOne = backend[i];
if(i < backend.Count - 1 && item == backend[i + 1].Item1 - 1)
{
removeTwo = backend[i + 1];
itemToAdd = new Tuple<long, long>(backend[i].Item1, backend[i + 1].Item2);
}
else itemToAdd = new Tuple<long, long>(backend[i].Item1, item);
break;
}
if(itemToAdd != null)
{
backend.Remove(removeOne);
backend.Remove(removeTwo);
backend.Add(itemToAdd);
}
else backend.Add(new Tuple<long, long>(item, item));
// Sort
backend = backend.OrderBy(t => t.Item1).ToList();
}
/// <summary>
/// Adds a new extent
/// </summary>
/// <param name="start">First element of the extent</param>
/// <param name="end">
/// Last element of the extent or if <see cref="run" /> is <c>true</c> how many elements the extent runs
/// for
/// </param>
/// <param name="run">If set to <c>true</c>, <see cref="end" /> indicates how many elements the extent runs for</param>
public void Add(long start, long end, bool run = false)
{
long realEnd;
if(run) realEnd = start + end - 1;
else realEnd = end;
// TODO: Optimize this
for(long t = start; t <= realEnd; t++) Add(t);
}
/// <summary>
/// Checks if the specified item is contained by an extent on this instance
/// </summary>
/// <param name="item">Item to seach for</param>
/// <returns><c>true</c> if any of the extents on this instance contains the item</returns>
public bool Contains(long item)
{
return backend.Any(extent => item >= extent.Item1 && item <= extent.Item2);
}
/// <summary>
/// Removes all extents from this instance
/// </summary>
public void Clear()
{
backend.Clear();
}
/// <summary>
/// Removes an item from the extents in this instance
/// </summary>
/// <param name="item">Item to remove</param>
/// <returns><c>true</c> if the item was contained in a known extent and removed, false otherwise</returns>
public bool Remove(long item)
{
Tuple<long, long> toRemove = null;
Tuple<long, long> toAddOne = null;
Tuple<long, long> toAddTwo = null;
foreach(Tuple<long, long> extent in backend)
{
// Extent is contained and not a border
if(item > extent.Item1 && item < extent.Item2)
{
toRemove = extent;
toAddOne = new Tuple<long, long>(extent.Item1, item - 1);
toAddTwo = new Tuple<long, long>(item + 1, extent.Item2);
break;
}
// Extent is left border, but not only element
if(item == extent.Item1 && item != extent.Item2)
{
toRemove = extent;
toAddOne = new Tuple<long, long>(item + 1, extent.Item2);
break;
}
// Extent is right border, but not only element
if(item != extent.Item1 && item == extent.Item2)
{
toRemove = extent;
toAddOne = new Tuple<long, long>(extent.Item1, item - 1);
break;
}
// Extent is only element
if(item != extent.Item1 || item != extent.Item2) continue;
toRemove = extent;
break;
}
// Item not found
if(toRemove == null) return false;
backend.Remove(toRemove);
if(toAddOne != null) backend.Add(toAddOne);
if(toAddTwo != null) backend.Add(toAddTwo);
// Sort
backend = backend.OrderBy(t => t.Item1).ToList();
return true;
}
/// <summary>
/// Converts the list of extents to an array of <see cref="Tuple" /> where T1 is first element of the extent and T2 is
/// last element
/// </summary>
/// <returns>Array of <see cref="Tuple" /></returns>
public Tuple<long, long>[] ToArray()
{
return backend.ToArray();
}
/// <summary>
/// Gets the first element of the extent that contains the specified item
/// </summary>
/// <param name="item">Item</param>
/// <param name="start">First element of extent</param>
/// <returns><c>true</c> if item was found in an extent, false otherwise</returns>
public bool GetStart(long item, out long start)
{
start = 0;
foreach(Tuple<long, long> extent in backend.Where(extent => item >= extent.Item1 && item <= extent.Item2))
{
start = extent.Item1;
return true;
}
return false;
}
}
}

248
Extents/ExtentsSByte.cs
View File

@@ -1,248 +0,0 @@
// /***************************************************************************
// The Disc Image Chef
// ----------------------------------------------------------------------------
//
// Filename : ExtentsSByte.cs
// Author(s) : Natalia Portillo <claunia@claunia.com>
//
// Component : Extent helpers.
//
// --[ Description ] ----------------------------------------------------------
//
// Provides extents for sbyte types.
//
// --[ License ] --------------------------------------------------------------
//
// This library is free software; you can redistribute it and/or modify
// it under the terms of the GNU Lesser General Public License as
// published by the Free Software Foundation; either version 2.1 of the
// License, or (at your option) any later version.
//
// This library is distributed in the hope that it will be useful, but
// WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
// Lesser General Public License for more details.
//
// You should have received a copy of the GNU Lesser General Public
// License along with this library; if not, see <http://www.gnu.org/licenses/>.
//
// ----------------------------------------------------------------------------
// Copyright © 2011-2018 Natalia Portillo
// ****************************************************************************/
using System;
using System.Collections.Generic;
using System.Linq;
namespace Extents
{
/// <summary>
/// Implements extents for <see cref="sbyte" />
/// </summary>
public class ExtentsSByte
{
List<Tuple<sbyte, sbyte>> backend;
/// <summary>
/// Initialize an empty list of extents
/// </summary>
public ExtentsSByte()
{
backend = new List<Tuple<sbyte, sbyte>>();
}
/// <summary>
/// Initializes extents with an specific list
/// </summary>
/// <param name="list">List of extents as tuples "start, end"</param>
public ExtentsSByte(IEnumerable<Tuple<sbyte, sbyte>> list)
{
backend = list.OrderBy(t => t.Item1).ToList();
}
/// <summary>
/// Gets a count of how many extents are stored
/// </summary>
public int Count => backend.Count;
/// <summary>
/// Adds the specified number to the corresponding extent, or creates a new one
/// </summary>
/// <param name="item"></param>
public void Add(sbyte item)
{
Tuple<sbyte, sbyte> removeOne = null;
Tuple<sbyte, sbyte> removeTwo = null;
Tuple<sbyte, sbyte> itemToAdd = null;
for(int i = 0; i < backend.Count; i++)
{
// Already contained in an extent
if(item >= backend[i].Item1 && item <= backend[i].Item2) return;
// Expands existing extent start
if(item == backend[i].Item1 - 1)
{
removeOne = backend[i];
if(i > 0 && item == backend[i - 1].Item2 + 1)
{
removeTwo = backend[i - 1];
itemToAdd = new Tuple<sbyte, sbyte>(backend[i - 1].Item1, backend[i].Item2);
}
else itemToAdd = new Tuple<sbyte, sbyte>(item, backend[i].Item2);
break;
}
// Expands existing extent end
if(item != backend[i].Item2 + 1) continue;
removeOne = backend[i];
if(i < backend.Count - 1 && item == backend[i + 1].Item1 - 1)
{
removeTwo = backend[i + 1];
itemToAdd = new Tuple<sbyte, sbyte>(backend[i].Item1, backend[i + 1].Item2);
}
else itemToAdd = new Tuple<sbyte, sbyte>(backend[i].Item1, item);
break;
}
if(itemToAdd != null)
{
backend.Remove(removeOne);
backend.Remove(removeTwo);
backend.Add(itemToAdd);
}
else backend.Add(new Tuple<sbyte, sbyte>(item, item));
// Sort
backend = backend.OrderBy(t => t.Item1).ToList();
}
/// <summary>
/// Adds a new extent
/// </summary>
/// <param name="start">First element of the extent</param>
/// <param name="end">
/// Last element of the extent or if <see cref="run" /> is <c>true</c> how many elements the extent runs
/// for
/// </param>
/// <param name="run">If set to <c>true</c>, <see cref="end" /> indicates how many elements the extent runs for</param>
public void Add(sbyte start, sbyte end, bool run = false)
{
sbyte realEnd;
if(run) realEnd = (sbyte)(start + end - 1);
else realEnd = end;
// TODO: Optimize this
for(sbyte t = start; t <= realEnd; t++) Add(t);
}
/// <summary>
/// Checks if the specified item is contained by an extent on this instance
/// </summary>
/// <param name="item">Item to seach for</param>
/// <returns><c>true</c> if any of the extents on this instance contains the item</returns>
public bool Contains(sbyte item)
{
return backend.Any(extent => item >= extent.Item1 && item <= extent.Item2);
}
/// <summary>
/// Removes all extents from this instance
/// </summary>
public void Clear()
{
backend.Clear();
}
/// <summary>
/// Removes an item from the extents in this instance
/// </summary>
/// <param name="item">Item to remove</param>
/// <returns><c>true</c> if the item was contained in a known extent and removed, false otherwise</returns>
public bool Remove(sbyte item)
{
Tuple<sbyte, sbyte> toRemove = null;
Tuple<sbyte, sbyte> toAddOne = null;
Tuple<sbyte, sbyte> toAddTwo = null;
foreach(Tuple<sbyte, sbyte> extent in backend)
{
// Extent is contained and not a border
if(item > extent.Item1 && item < extent.Item2)
{
toRemove = extent;
toAddOne = new Tuple<sbyte, sbyte>(extent.Item1, (sbyte)(item - 1));
toAddTwo = new Tuple<sbyte, sbyte>((sbyte)(item + 1), extent.Item2);
break;
}
// Extent is left border, but not only element
if(item == extent.Item1 && item != extent.Item2)
{
toRemove = extent;
toAddOne = new Tuple<sbyte, sbyte>((sbyte)(item + 1), extent.Item2);
break;
}
// Extent is right border, but not only element
if(item != extent.Item1 && item == extent.Item2)
{
toRemove = extent;
toAddOne = new Tuple<sbyte, sbyte>(extent.Item1, (sbyte)(item - 1));
break;
}
// Extent is only element
if(item != extent.Item1 || item != extent.Item2) continue;
toRemove = extent;
break;
}
// Item not found
if(toRemove == null) return false;
backend.Remove(toRemove);
if(toAddOne != null) backend.Add(toAddOne);
if(toAddTwo != null) backend.Add(toAddTwo);
// Sort
backend = backend.OrderBy(t => t.Item1).ToList();
return true;
}
/// <summary>
/// Converts the list of extents to an array of <see cref="Tuple" /> where T1 is first element of the extent and T2 is
/// last element
/// </summary>
/// <returns>Array of <see cref="Tuple" /></returns>
public Tuple<sbyte, sbyte>[] ToArray()
{
return backend.ToArray();
}
/// <summary>
/// Gets the first element of the extent that contains the specified item
/// </summary>
/// <param name="item">Item</param>
/// <param name="start">First element of extent</param>
/// <returns><c>true</c> if item was found in an extent, false otherwise</returns>
public bool GetStart(sbyte item, out sbyte start)
{
start = 0;
foreach(Tuple<sbyte, sbyte> extent in backend.Where(extent => item >= extent.Item1 && item <= extent.Item2))
{
start = extent.Item1;
return true;
}
return false;
}
}
}

248
Extents/ExtentsShort.cs
View File

@@ -1,248 +0,0 @@
// /***************************************************************************
// The Disc Image Chef
// ----------------------------------------------------------------------------
//
// Filename : ExtentsShort.cs
// Author(s) : Natalia Portillo <claunia@claunia.com>
//
// Component : Extent helpers.
//
// --[ Description ] ----------------------------------------------------------
//
// Provides extents for short types.
//
// --[ License ] --------------------------------------------------------------
//
// This library is free software; you can redistribute it and/or modify
// it under the terms of the GNU Lesser General Public License as
// published by the Free Software Foundation; either version 2.1 of the
// License, or (at your option) any later version.
//
// This library is distributed in the hope that it will be useful, but
// WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
// Lesser General Public License for more details.
//
// You should have received a copy of the GNU Lesser General Public
// License ashort with this library; if not, see <http://www.gnu.org/licenses/>.
//
// ----------------------------------------------------------------------------
// Copyright © 2011-2018 Natalia Portillo
// ****************************************************************************/
using System;
using System.Collections.Generic;
using System.Linq;
namespace Extents
{
/// <summary>
/// Implements extents for <see cref="short" />
/// </summary>
public class ExtentsShort
{
List<Tuple<short, short>> backend;
/// <summary>
/// Initialize an empty list of extents
/// </summary>
public ExtentsShort()
{
backend = new List<Tuple<short, short>>();
}
/// <summary>
/// Initializes extents with an specific list
/// </summary>
/// <param name="list">List of extents as tuples "start, end"</param>
public ExtentsShort(IEnumerable<Tuple<short, short>> list)
{
backend = list.OrderBy(t => t.Item1).ToList();
}
/// <summary>
/// Gets a count of how many extents are stored
/// </summary>
public int Count => backend.Count;
/// <summary>
/// Adds the specified number to the corresponding extent, or creates a new one
/// </summary>
/// <param name="item"></param>
public void Add(short item)
{
Tuple<short, short> removeOne = null;
Tuple<short, short> removeTwo = null;
Tuple<short, short> itemToAdd = null;
for(int i = 0; i < backend.Count; i++)
{
// Already contained in an extent
if(item >= backend[i].Item1 && item <= backend[i].Item2) return;
// Expands existing extent start
if(item == backend[i].Item1 - 1)
{
removeOne = backend[i];
if(i > 0 && item == backend[i - 1].Item2 + 1)
{
removeTwo = backend[i - 1];
itemToAdd = new Tuple<short, short>(backend[i - 1].Item1, backend[i].Item2);
}
else itemToAdd = new Tuple<short, short>(item, backend[i].Item2);
break;
}
// Expands existing extent end
if(item != backend[i].Item2 + 1) continue;
removeOne = backend[i];
if(i < backend.Count - 1 && item == backend[i + 1].Item1 - 1)
{
removeTwo = backend[i + 1];
itemToAdd = new Tuple<short, short>(backend[i].Item1, backend[i + 1].Item2);
}
else itemToAdd = new Tuple<short, short>(backend[i].Item1, item);
break;
}
if(itemToAdd != null)
{
backend.Remove(removeOne);
backend.Remove(removeTwo);
backend.Add(itemToAdd);
}
else backend.Add(new Tuple<short, short>(item, item));
// Sort
backend = backend.OrderBy(t => t.Item1).ToList();
}
/// <summary>
/// Adds a new extent
/// </summary>
/// <param name="start">First element of the extent</param>
/// <param name="end">
/// Last element of the extent or if <see cref="run" /> is <c>true</c> how many elements the extent runs
/// for
/// </param>
/// <param name="run">If set to <c>true</c>, <see cref="end" /> indicates how many elements the extent runs for</param>
public void Add(short start, short end, bool run = false)
{
short realEnd;
if(run) realEnd = (short)(start + end - 1);
else realEnd = end;
// TODO: Optimize this
for(short t = start; t <= realEnd; t++) Add(t);
}
/// <summary>
/// Checks if the specified item is contained by an extent on this instance
/// </summary>
/// <param name="item">Item to seach for</param>
/// <returns><c>true</c> if any of the extents on this instance contains the item</returns>
public bool Contains(short item)
{
return backend.Any(extent => item >= extent.Item1 && item <= extent.Item2);
}
/// <summary>
/// Removes all extents from this instance
/// </summary>
public void Clear()
{
backend.Clear();
}
/// <summary>
/// Removes an item from the extents in this instance
/// </summary>
/// <param name="item">Item to remove</param>
/// <returns><c>true</c> if the item was contained in a known extent and removed, false otherwise</returns>
public bool Remove(short item)
{
Tuple<short, short> toRemove = null;
Tuple<short, short> toAddOne = null;
Tuple<short, short> toAddTwo = null;
foreach(Tuple<short, short> extent in backend)
{
// Extent is contained and not a border
if(item > extent.Item1 && item < extent.Item2)
{
toRemove = extent;
toAddOne = new Tuple<short, short>(extent.Item1, (short)(item - 1));
toAddTwo = new Tuple<short, short>((short)(item + 1), extent.Item2);
break;
}
// Extent is left border, but not only element
if(item == extent.Item1 && item != extent.Item2)
{
toRemove = extent;
toAddOne = new Tuple<short, short>((short)(item + 1), extent.Item2);
break;
}
// Extent is right border, but not only element
if(item != extent.Item1 && item == extent.Item2)
{
toRemove = extent;
toAddOne = new Tuple<short, short>(extent.Item1, (short)(item - 1));
break;
}
// Extent is only element
if(item != extent.Item1 || item != extent.Item2) continue;
toRemove = extent;
break;
}
// Item not found
if(toRemove == null) return false;
backend.Remove(toRemove);
if(toAddOne != null) backend.Add(toAddOne);
if(toAddTwo != null) backend.Add(toAddTwo);
// Sort
backend = backend.OrderBy(t => t.Item1).ToList();
return true;
}
/// <summary>
/// Converts the list of extents to an array of <see cref="Tuple" /> where T1 is first element of the extent and T2 is
/// last element
/// </summary>
/// <returns>Array of <see cref="Tuple" /></returns>
public Tuple<short, short>[] ToArray()
{
return backend.ToArray();
}
/// <summary>
/// Gets the first element of the extent that contains the specified item
/// </summary>
/// <param name="item">Item</param>
/// <param name="start">First element of extent</param>
/// <returns><c>true</c> if item was found in an extent, false otherwise</returns>
public bool GetStart(short item, out short start)
{
start = 0;
foreach(Tuple<short, short> extent in backend.Where(extent => item >= extent.Item1 && item <= extent.Item2))
{
start = extent.Item1;
return true;
}
return false;
}
}
}

248
Extents/ExtentsUInt.cs
View File

@@ -1,248 +0,0 @@
// /***************************************************************************
// The Disc Image Chef
// ----------------------------------------------------------------------------
//
// Filename : ExtentsUInt.cs
// Author(s) : Natalia Portillo <claunia@claunia.com>
//
// Component : Extent helpers.
//
// --[ Description ] ----------------------------------------------------------
//
// Provides extents for uint types.
//
// --[ License ] --------------------------------------------------------------
//
// This library is free software; you can redistribute it and/or modify
// it under the terms of the GNU Lesser General Public License as
// published by the Free Software Foundation; either version 2.1 of the
// License, or (at your option) any later version.
//
// This library is distributed in the hope that it will be useful, but
// WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
// Lesser General Public License for more details.
//
// You should have received a copy of the GNU Lesser General Public
// License auint with this library; if not, see <http://www.gnu.org/licenses/>.
//
// ----------------------------------------------------------------------------
// Copyright © 2011-2018 Natalia Portillo
// ****************************************************************************/
using System;
using System.Collections.Generic;
using System.Linq;
namespace Extents
{
/// <summary>
/// Implements extents for <see cref="uint" />
/// </summary>
public class ExtentsUInt
{
List<Tuple<uint, uint>> backend;
/// <summary>
/// Initialize an empty list of extents
/// </summary>
public ExtentsUInt()
{
backend = new List<Tuple<uint, uint>>();
}
/// <summary>
/// Initializes extents with an specific list
/// </summary>
/// <param name="list">List of extents as tuples "start, end"</param>
public ExtentsUInt(IEnumerable<Tuple<uint, uint>> list)
{
backend = list.OrderBy(t => t.Item1).ToList();
}
/// <summary>
/// Gets a count of how many extents are stored
/// </summary>
public int Count => backend.Count;
/// <summary>
/// Adds the specified number to the corresponding extent, or creates a new one
/// </summary>
/// <param name="item"></param>
public void Add(uint item)
{
Tuple<uint, uint> removeOne = null;
Tuple<uint, uint> removeTwo = null;
Tuple<uint, uint> itemToAdd = null;
for(int i = 0; i < backend.Count; i++)
{
// Already contained in an extent
if(item >= backend[i].Item1 && item <= backend[i].Item2) return;
// Expands existing extent start
if(item == backend[i].Item1 - 1)
{
removeOne = backend[i];
if(i > 0 && item == backend[i - 1].Item2 + 1)
{
removeTwo = backend[i - 1];
itemToAdd = new Tuple<uint, uint>(backend[i - 1].Item1, backend[i].Item2);
}
else itemToAdd = new Tuple<uint, uint>(item, backend[i].Item2);
break;
}
// Expands existing extent end
if(item != backend[i].Item2 + 1) continue;
removeOne = backend[i];
if(i < backend.Count - 1 && item == backend[i + 1].Item1 - 1)
{
removeTwo = backend[i + 1];
itemToAdd = new Tuple<uint, uint>(backend[i].Item1, backend[i + 1].Item2);
}
else itemToAdd = new Tuple<uint, uint>(backend[i].Item1, item);
break;
}
if(itemToAdd != null)
{
backend.Remove(removeOne);
backend.Remove(removeTwo);
backend.Add(itemToAdd);
}
else backend.Add(new Tuple<uint, uint>(item, item));
// Sort
backend = backend.OrderBy(t => t.Item1).ToList();
}
/// <summary>
/// Adds a new extent
/// </summary>
/// <param name="start">First element of the extent</param>
/// <param name="end">
/// Last element of the extent or if <see cref="run" /> is <c>true</c> how many elements the extent runs
/// for
/// </param>
/// <param name="run">If set to <c>true</c>, <see cref="end" /> indicates how many elements the extent runs for</param>
public void Add(uint start, uint end, bool run = false)
{
uint realEnd;
if(run) realEnd = start + end - 1;
else realEnd = end;
// TODO: Optimize this
for(uint t = start; t <= realEnd; t++) Add(t);
}
/// <summary>
/// Checks if the specified item is contained by an extent on this instance
/// </summary>
/// <param name="item">Item to seach for</param>
/// <returns><c>true</c> if any of the extents on this instance contains the item</returns>
public bool Contains(uint item)
{
return backend.Any(extent => item >= extent.Item1 && item <= extent.Item2);
}
/// <summary>
/// Removes all extents from this instance
/// </summary>
public void Clear()
{
backend.Clear();
}
/// <summary>
/// Removes an item from the extents in this instance
/// </summary>
/// <param name="item">Item to remove</param>
/// <returns><c>true</c> if the item was contained in a known extent and removed, false otherwise</returns>
public bool Remove(uint item)
{
Tuple<uint, uint> toRemove = null;
Tuple<uint, uint> toAddOne = null;
Tuple<uint, uint> toAddTwo = null;
foreach(Tuple<uint, uint> extent in backend)
{
// Extent is contained and not a border
if(item > extent.Item1 && item < extent.Item2)
{
toRemove = extent;
toAddOne = new Tuple<uint, uint>(extent.Item1, item - 1);
toAddTwo = new Tuple<uint, uint>(item + 1, extent.Item2);
break;
}
// Extent is left border, but not only element
if(item == extent.Item1 && item != extent.Item2)
{
toRemove = extent;
toAddOne = new Tuple<uint, uint>(item + 1, extent.Item2);
break;
}
// Extent is right border, but not only element
if(item != extent.Item1 && item == extent.Item2)
{
toRemove = extent;
toAddOne = new Tuple<uint, uint>(extent.Item1, item - 1);
break;
}
// Extent is only element
if(item != extent.Item1 || item != extent.Item2) continue;
toRemove = extent;
break;
}
// Item not found
if(toRemove == null) return false;
backend.Remove(toRemove);
if(toAddOne != null) backend.Add(toAddOne);
if(toAddTwo != null) backend.Add(toAddTwo);
// Sort
backend = backend.OrderBy(t => t.Item1).ToList();
return true;
}
/// <summary>
/// Converts the list of extents to an array of <see cref="Tuple" /> where T1 is first element of the extent and T2 is
/// last element
/// </summary>
/// <returns>Array of <see cref="Tuple" /></returns>
public Tuple<uint, uint>[] ToArray()
{
return backend.ToArray();
}
/// <summary>
/// Gets the first element of the extent that contains the specified item
/// </summary>
/// <param name="item">Item</param>
/// <param name="start">First element of extent</param>
/// <returns><c>true</c> if item was found in an extent, false otherwise</returns>
public bool GetStart(uint item, out uint start)
{
start = 0;
foreach(Tuple<uint, uint> extent in backend.Where(extent => item >= extent.Item1 && item <= extent.Item2))
{
start = extent.Item1;
return true;
}
return false;
}
}
}

248
Extents/ExtentsULong.cs
View File

@@ -1,248 +0,0 @@
// /***************************************************************************
// The Disc Image Chef
// ----------------------------------------------------------------------------
//
// Filename : ExtentsULong.cs
// Author(s) : Natalia Portillo <claunia@claunia.com>
//
// Component : Extent helpers.
//
// --[ Description ] ----------------------------------------------------------
//
// Provides extents for ulong types.
//
// --[ License ] --------------------------------------------------------------
//
// This library is free software; you can redistribute it and/or modify
// it under the terms of the GNU Lesser General Public License as
// published by the Free Software Foundation; either version 2.1 of the
// License, or (at your option) any later version.
//
// This library is distributed in the hope that it will be useful, but
// WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
// Lesser General Public License for more details.
//
// You should have received a copy of the GNU Lesser General Public
// License aulong with this library; if not, see <http://www.gnu.org/licenses/>.
//
// ----------------------------------------------------------------------------
// Copyright © 2011-2018 Natalia Portillo
// ****************************************************************************/
using System;
using System.Collections.Generic;
using System.Linq;
namespace Extents
{
/// <summary>
/// Implements extents for <see cref="ulong" />
/// </summary>
public class ExtentsULong
{
List<Tuple<ulong, ulong>> backend;
/// <summary>
/// Initialize an empty list of extents
/// </summary>
public ExtentsULong()
{
backend = new List<Tuple<ulong, ulong>>();
}
/// <summary>
/// Initializes extents with an specific list
/// </summary>
/// <param name="list">List of extents as tuples "start, end"</param>
public ExtentsULong(IEnumerable<Tuple<ulong, ulong>> list)
{
backend = list.OrderBy(t => t.Item1).ToList();
}
/// <summary>
/// Gets a count of how many extents are stored
/// </summary>
public int Count => backend.Count;
/// <summary>
/// Adds the specified number to the corresponding extent, or creates a new one
/// </summary>
/// <param name="item"></param>
public void Add(ulong item)
{
Tuple<ulong, ulong> removeOne = null;
Tuple<ulong, ulong> removeTwo = null;
Tuple<ulong, ulong> itemToAdd = null;
for(int i = 0; i < backend.Count; i++)
{
// Already contained in an extent
if(item >= backend[i].Item1 && item <= backend[i].Item2) return;
// Expands existing extent start
if(item == backend[i].Item1 - 1)
{
removeOne = backend[i];
if(i > 0 && item == backend[i - 1].Item2 + 1)
{
removeTwo = backend[i - 1];
itemToAdd = new Tuple<ulong, ulong>(backend[i - 1].Item1, backend[i].Item2);
}
else itemToAdd = new Tuple<ulong, ulong>(item, backend[i].Item2);
break;
}
// Expands existing extent end
if(item != backend[i].Item2 + 1) continue;
removeOne = backend[i];
if(i < backend.Count - 1 && item == backend[i + 1].Item1 - 1)
{
removeTwo = backend[i + 1];
itemToAdd = new Tuple<ulong, ulong>(backend[i].Item1, backend[i + 1].Item2);
}
else itemToAdd = new Tuple<ulong, ulong>(backend[i].Item1, item);
break;
}
if(itemToAdd != null)
{
backend.Remove(removeOne);
backend.Remove(removeTwo);
backend.Add(itemToAdd);
}
else backend.Add(new Tuple<ulong, ulong>(item, item));
// Sort
backend = backend.OrderBy(t => t.Item1).ToList();
}
/// <summary>
/// Adds a new extent
/// </summary>
/// <param name="start">First element of the extent</param>
/// <param name="end">
/// Last element of the extent or if <see cref="run" /> is <c>true</c> how many elements the extent runs
/// for
/// </param>
/// <param name="run">If set to <c>true</c>, <see cref="end" /> indicates how many elements the extent runs for</param>
public void Add(ulong start, ulong end, bool run = false)
{
ulong realEnd;
if(run) realEnd = start + end - 1;
else realEnd = end;
// TODO: Optimize this
for(ulong t = start; t <= realEnd; t++) Add(t);
}
/// <summary>
/// Checks if the specified item is contained by an extent on this instance
/// </summary>
/// <param name="item">Item to seach for</param>
/// <returns><c>true</c> if any of the extents on this instance contains the item</returns>
public bool Contains(ulong item)
{
return backend.Any(extent => item >= extent.Item1 && item <= extent.Item2);
}
/// <summary>
/// Removes all extents from this instance
/// </summary>
public void Clear()
{
backend.Clear();
}
/// <summary>
/// Removes an item from the extents in this instance
/// </summary>
/// <param name="item">Item to remove</param>
/// <returns><c>true</c> if the item was contained in a known extent and removed, false otherwise</returns>
public bool Remove(ulong item)
{
Tuple<ulong, ulong> toRemove = null;
Tuple<ulong, ulong> toAddOne = null;
Tuple<ulong, ulong> toAddTwo = null;
foreach(Tuple<ulong, ulong> extent in backend)
{
// Extent is contained and not a border
if(item > extent.Item1 && item < extent.Item2)
{
toRemove = extent;
toAddOne = new Tuple<ulong, ulong>(extent.Item1, item - 1);
toAddTwo = new Tuple<ulong, ulong>(item + 1, extent.Item2);
break;
}
// Extent is left border, but not only element
if(item == extent.Item1 && item != extent.Item2)
{
toRemove = extent;
toAddOne = new Tuple<ulong, ulong>(item + 1, extent.Item2);
break;
}
// Extent is right border, but not only element
if(item != extent.Item1 && item == extent.Item2)
{
toRemove = extent;
toAddOne = new Tuple<ulong, ulong>(extent.Item1, item - 1);
break;
}
// Extent is only element
if(item != extent.Item1 || item != extent.Item2) continue;
toRemove = extent;
break;
}
// Item not found
if(toRemove == null) return false;
backend.Remove(toRemove);
if(toAddOne != null) backend.Add(toAddOne);
if(toAddTwo != null) backend.Add(toAddTwo);
// Sort
backend = backend.OrderBy(t => t.Item1).ToList();
return true;
}
/// <summary>
/// Converts the list of extents to an array of <see cref="Tuple" /> where T1 is first element of the extent and T2 is
/// last element
/// </summary>
/// <returns>Array of <see cref="Tuple" /></returns>
public Tuple<ulong, ulong>[] ToArray()
{
return backend.ToArray();
}
/// <summary>
/// Gets the first element of the extent that contains the specified item
/// </summary>
/// <param name="item">Item</param>
/// <param name="start">First element of extent</param>
/// <returns><c>true</c> if item was found in an extent, false otherwise</returns>
public bool GetStart(ulong item, out ulong start)
{
start = 0;
foreach(Tuple<ulong, ulong> extent in backend.Where(extent => item >= extent.Item1 && item <= extent.Item2))
{
start = extent.Item1;
return true;
}
return false;
}
}
}

249
Extents/ExtentsUShort.cs
View File

@@ -1,249 +0,0 @@
// /***************************************************************************
// The Disc Image Chef
// ----------------------------------------------------------------------------
//
// Filename : ExtentsUShort.cs
// Author(s) : Natalia Portillo <claunia@claunia.com>
//
// Component : Extent helpers.
//
// --[ Description ] ----------------------------------------------------------
//
// Provides extents for ushort types.
//
// --[ License ] --------------------------------------------------------------
//
// This library is free software; you can redistribute it and/or modify
// it under the terms of the GNU Lesser General Public License as
// published by the Free Software Foundation; either version 2.1 of the
// License, or (at your option) any later version.
//
// This library is distributed in the hope that it will be useful, but
// WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
// Lesser General Public License for more details.
//
// You should have received a copy of the GNU Lesser General Public
// License aushort with this library; if not, see <http://www.gnu.org/licenses/>.
//
// ----------------------------------------------------------------------------
// Copyright © 2011-2018 Natalia Portillo
// ****************************************************************************/
using System;
using System.Collections.Generic;
using System.Linq;
namespace Extents
{
/// <summary>
/// Implements extents for <see cref="ushort" />
/// </summary>
public class ExtentsUShort
{
List<Tuple<ushort, ushort>> backend;
/// <summary>
/// Initialize an empty list of extents
/// </summary>
public ExtentsUShort()
{
backend = new List<Tuple<ushort, ushort>>();
}
/// <summary>
/// Initializes extents with an specific list
/// </summary>
/// <param name="list">List of extents as tuples "start, end"</param>
public ExtentsUShort(IEnumerable<Tuple<ushort, ushort>> list)
{
backend = list.OrderBy(t => t.Item1).ToList();
}
/// <summary>
/// Gets a count of how many extents are stored
/// </summary>
public int Count => backend.Count;
/// <summary>
/// Adds the specified number to the corresponding extent, or creates a new one
/// </summary>
/// <param name="item"></param>
public void Add(ushort item)
{
Tuple<ushort, ushort> removeOne = null;
Tuple<ushort, ushort> removeTwo = null;
Tuple<ushort, ushort> itemToAdd = null;
for(int i = 0; i < backend.Count; i++)
{
// Already contained in an extent
if(item >= backend[i].Item1 && item <= backend[i].Item2) return;
// Expands existing extent start
if(item == backend[i].Item1 - 1)
{
removeOne = backend[i];
if(i > 0 && item == backend[i - 1].Item2 + 1)
{
removeTwo = backend[i - 1];
itemToAdd = new Tuple<ushort, ushort>(backend[i - 1].Item1, backend[i].Item2);
}
else itemToAdd = new Tuple<ushort, ushort>(item, backend[i].Item2);
break;
}
// Expands existing extent end
if(item != backend[i].Item2 + 1) continue;
removeOne = backend[i];
if(i < backend.Count - 1 && item == backend[i + 1].Item1 - 1)
{
removeTwo = backend[i + 1];
itemToAdd = new Tuple<ushort, ushort>(backend[i].Item1, backend[i + 1].Item2);
}
else itemToAdd = new Tuple<ushort, ushort>(backend[i].Item1, item);
break;
}
if(itemToAdd != null)
{
backend.Remove(removeOne);
backend.Remove(removeTwo);
backend.Add(itemToAdd);
}
else backend.Add(new Tuple<ushort, ushort>(item, item));
// Sort
backend = backend.OrderBy(t => t.Item1).ToList();
}
/// <summary>
/// Adds a new extent
/// </summary>
/// <param name="start">First element of the extent</param>
/// <param name="end">
/// Last element of the extent or if <see cref="run" /> is <c>true</c> how many elements the extent runs
/// for
/// </param>
/// <param name="run">If set to <c>true</c>, <see cref="end" /> indicates how many elements the extent runs for</param>
public void Add(ushort start, ushort end, bool run = false)
{
ushort realEnd;
if(run) realEnd = (ushort)(start + end - 1);
else realEnd = end;
// TODO: Optimize this
for(ushort t = start; t <= realEnd; t++) Add(t);
}
/// <summary>
/// Checks if the specified item is contained by an extent on this instance
/// </summary>
/// <param name="item">Item to seach for</param>
/// <returns><c>true</c> if any of the extents on this instance contains the item</returns>
public bool Contains(ushort item)
{
return backend.Any(extent => item >= extent.Item1 && item <= extent.Item2);
}
/// <summary>
/// Removes all extents from this instance
/// </summary>
public void Clear()
{
backend.Clear();
}
/// <summary>
/// Removes an item from the extents in this instance
/// </summary>
/// <param name="item">Item to remove</param>
/// <returns><c>true</c> if the item was contained in a known extent and removed, false otherwise</returns>
public bool Remove(ushort item)
{
Tuple<ushort, ushort> toRemove = null;
Tuple<ushort, ushort> toAddOne = null;
Tuple<ushort, ushort> toAddTwo = null;
foreach(Tuple<ushort, ushort> extent in backend)
{
// Extent is contained and not a border
if(item > extent.Item1 && item < extent.Item2)
{
toRemove = extent;
toAddOne = new Tuple<ushort, ushort>(extent.Item1, (ushort)(item - 1));
toAddTwo = new Tuple<ushort, ushort>((ushort)(item + 1), extent.Item2);
break;
}
// Extent is left border, but not only element
if(item == extent.Item1 && item != extent.Item2)
{
toRemove = extent;
toAddOne = new Tuple<ushort, ushort>((ushort)(item + 1), extent.Item2);
break;
}
// Extent is right border, but not only element
if(item != extent.Item1 && item == extent.Item2)
{
toRemove = extent;
toAddOne = new Tuple<ushort, ushort>(extent.Item1, (ushort)(item - 1));
break;
}
// Extent is only element
if(item != extent.Item1 || item != extent.Item2) continue;
toRemove = extent;
break;
}
// Item not found
if(toRemove == null) return false;
backend.Remove(toRemove);
if(toAddOne != null) backend.Add(toAddOne);
if(toAddTwo != null) backend.Add(toAddTwo);
// Sort
backend = backend.OrderBy(t => t.Item1).ToList();
return true;
}
/// <summary>
/// Converts the list of extents to an array of <see cref="Tuple" /> where T1 is first element of the extent and T2 is
/// last element
/// </summary>
/// <returns>Array of <see cref="Tuple" /></returns>
public Tuple<ushort, ushort>[] ToArray()
{
return backend.ToArray();
}
/// <summary>
/// Gets the first element of the extent that contains the specified item
/// </summary>
/// <param name="item">Item</param>
/// <param name="start">First element of extent</param>
/// <returns><c>true</c> if item was found in an extent, false otherwise</returns>
public bool GetStart(ushort item, out ushort start)
{
start = 0;
foreach(Tuple<ushort, ushort> extent in
backend.Where(extent => item >= extent.Item1 && item <= extent.Item2))
{
start = extent.Item1;
return true;
}
return false;
}
}
}