/// <summary>
/// Desfragmenta.
/// </summary>
/// <returns></returns>
public MemArea DeFragment()
{
MemArea arena2;
MemArea arena = this.FirstArea();
arena2 = arena.NextArea();
while (arena2 != null)
{
if (!arena.IsFree)
{
arena = arena2;
}
else if (arena2.IsFree)
{
arena = MemArea.CoalesceAdjacent(arena2);
}
else
{
MemArea.SwapAdjacent(arena2, arena);
arena = arena2;
}
arena2 = arena.NextArea();
}
this.FreeSpace = arena.Capacity;
this.MaxFreeSpace = arena.Capacity;
this.CalculateAreaMemoryUsage();
return(arena);
}
/// <summary>
/// Adquire uma area adjacente.
/// </summary>
/// <param name="area"></param>
/// <returns></returns>
internal static MemArea CoalesceAdjacent(MemArea area)
{
if (area.IsFree)
{
MemArea arenaCopy = area.NextArea();
int num = 0;
if (arenaCopy != null)
{
uint num2 = 0;
while ((arenaCopy != null) && arenaCopy.IsFree)
{
num++;
num2 += arenaCopy.TotalLength;
arenaCopy = arenaCopy.NextArea();
}
if (num2 > 0)
{
area.Capacity += num2;
uint capacity = area.Capacity;
area = SetNextArea(area, GetActualArea(arenaCopy));
area.Capacity = capacity;
}
}
if (area.HasPrevious)
{
uint num4 = 0;
MemArea arena3 = area;
MemArea arena4 = null;
while (true)
{
arena4 = arena3.PreviousArea();
if ((arena4 == null) || !arena4.IsFree)
{
break;
}
num4 += arena4.TotalLength;
arena3 = arena4;
num++;
}
if (num4 > 0)
{
area.Capacity += num4;
uint num5 = area.Capacity;
area.NextArea();
area = SetNextArea(arena3, GetActualArea(arenaCopy));
area.Capacity = num5;
}
}
if (num > 0)
{
View view = area.View;
view.MyFreeSpace += (uint)(num * Header.Size);
}
}
return(area);
}
/// <summary>
/// Divida a <see cref="MemArea"/> em partes com o tamanhon informado.
/// </summary>
/// <param name="area"></param>
/// <param name="size"></param>
/// <returns></returns>
internal static MemArea SplitArea(MemArea area, uint size)
{
uint num = size + ((uint)Header.Size);
if (area.OffsetNext != 0)
{
area.Capacity = area.OffsetNext - (area.Offset + ((uint)Header.Size));
}
if (num > area.Capacity)
{
return(null);
}
uint num2 = (area.Capacity - size) - ((uint)Header.Size);
if (num2 < SPLIT_THRESHOLD)
{
View view1 = area.View;
view1.MyFreeSpace -= area.Capacity + ((uint)Header.Size);
return(area);
}
area.Capacity = size;
MemArea arena2 = area.View.AreaAtOffset(area.Offset + area.TotalLength);
arena2.Capacity = num2;
View view = area.View;
view.MyFreeSpace -= num;
MemArea arenaCopy = area.NextArea();
SetNextArea(arena2, GetActualArea(arenaCopy));
SetNextArea(area, arena2);
return(arena2);
}
/// <summary>
/// Move para o próximo item.
/// </summary>
/// <returns></returns>
bool IEnumerator.MoveNext()
{
if (_view == null)
{
return(false);
}
_storage._viewManager.OpenView(_view);
if (_area == null)
{
_area = _view.FirstArea();
}
else
{
_area = _area.NextArea();
if (_area == null)
{
_view = _storage._viewManager.GetViewByID(_view.ID + 1);
if (_view != null)
{
_storage._viewManager.OpenView(_view);
_area = _view.FirstArea();
}
}
}
return(_area != null);
}
/// <summary>
/// Calcula a area da memória usada.
/// </summary>
private void CalculateAreaMemoryUsage()
{
MemArea arena = this.FirstArea();
MemArea arena2 = this.FirstArea();
uint capacity = 0;
uint num2 = 0;
while (arena != null)
{
try
{
if (arena.IsFree)
{
num2 += arena.Capacity;
if (arena.Capacity >= capacity)
{
capacity = arena.Capacity;
}
}
arena = arena.NextArea();
if ((arena != null) && (arena.OffsetNext == arena2.Offset))
{
arena.OffsetNext = 0;
}
continue;
}
catch (Exception exception)
{
throw new Exception(exception.Message);
}
}
this.FreeSpace = num2;
this.MaxFreeSpace = capacity;
this.MyFreeSpace = this.FreeSpace + ((uint)MemArea.Header.Size);
}
/// <summary>
/// Recupera o texto que representa a instancia.
/// </summary>
/// <returns></returns>
public override string ToString()
{
StringBuilder builder = new StringBuilder();
builder.Append("View, ID=").Append(this.ID).Append(", maxFree=").Append(this.MaxFreeSpace).Append(", Free=").Append(this.FreeSpace).Append("\r\n");
if (this.IsOpen)
{
for (MemArea arena = this.FirstArea(); arena != null; arena = arena.NextArea())
{
builder.Append(arena.ToString()).Append("\r\n");
}
}
return(builder.ToString());
}
/// <summary>
/// Procura pela primeira <see cref="MemArea"/> livre.
/// </summary>
/// <param name="memRequirements">Quantidade de memória requerida.</param>
/// <returns><see cref="MemArea"/> disponível.</returns>
private MemArea FindFirstFreeArena(uint memRequirements)
{
memRequirements += (uint)MemArea.Header.Size;
MemArea arena = this.FirstArea();
if (arena.OffsetNext != 0)
{
arena.Capacity = arena.OffsetNext - (arena.Offset + ((uint)MemArea.Header.Size));
}
if (((_lastFreeArena == null) || !_lastFreeArena.IsFree) || (_lastFreeArena.Capacity < memRequirements))
{
while (arena != null)
{
if (arena.IsFree && (arena.Capacity >= memRequirements))
{
return(arena);
}
arena = arena.NextArea();
}
return(null);
}
return(_lastFreeArena);
}
