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

Added helpers for extents.

Browse Source
This commit is contained in:
Natalia Portillo
2017-06-08 18:41:41 +01:00
parent d1a4af704b
commit afa300a935
9 changed files with 1612 additions and 1 deletions
Download Patch File Download Diff File Expand all files Collapse all files

200
DiscImageChef.Helpers/Extents/ExtentsUInt.cs Normal file
View File

@@ -0,0 +1,200 @@
// /***************************************************************************
// The Disc Image Chef
// ----------------------------------------------------------------------------
//
// Filename : ExtentsUInt.cs
// Author(s) : Natalia Portillo <claunia@claunia.com>
//
// Component : Component
//
// --[ Description ] ----------------------------------------------------------
//
// Description
//
// --[ 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-2017 Natalia Portillo
// ****************************************************************************/
using System;
using System.Collections.Generic;
using System.Linq;
namespace Extents
{
public class ExtentsUInt
{
List<Tuple<uint, uint>> backend;
public ExtentsUInt()
{
backend = new List<Tuple<uint, uint>>();
}
public int Count { get { return backend.Count; } }
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)
{
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();
}
public void Add(uint start, uint end)
{
Add(start, end, false);
}
public void Add(uint start, uint end, bool run)
{
uint realEnd;
if(run)
realEnd = start + end - 1;
else
realEnd = end;
// TODO: Optimize this
for(uint t = start; t <= realEnd; t++)
Add(t);
}
public bool Contains(uint item)
{
foreach(Tuple<uint, uint> extent in backend)
if(item >= extent.Item1 && item <= extent.Item2)
return true;
return false;
}
public void Clear()
{
backend.Clear();
}
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)
{
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;
}
public Tuple<uint, uint>[] ToArray()
{
return backend.ToArray();
}
}
}