public void CommitFromMemory(
IRegistryFileDescriptor registryFileDesc,
SparseClusteredArray <byte> memSCA,
SparseClusteredArray <byte> rtxSCA)
{
memSCA.Lock.EnterUpgradeableReadLock();
rtxSCA.Lock.EnterUpgradeableReadLock();
try
{
foreach (var memStream in memSCA.GetStreams())
{
var memElems = memStream.StreamToStruct <RegMemElem17, RegMemElem17>(
RegMemElem17.SizeOfMemElem,
e => e
);
foreach (var memElemKeyValue in memElems.OrderBy(kv => kv.Value.rtxOffset))
{
var id = memElemKeyValue.Key;
var memElem = memElemKeyValue.Value;
var lower = memElem.rtxOffset - 1;
var upper = memElem.rtxOffset + memElem.rtxLength - 2;
if (upper < lower || upper < 0)
{
LogTo.Warning($"({registryFileDesc.RegistryName}) Invalid rtx offsets, upper: {upper}, lower: {lower}");
continue;
}
SparseClusteredArray <byte> .Bounds rtxBounds = new SparseClusteredArray <byte> .Bounds(
lower,
upper
);
using (var rtStream = rtxSCA.GetSubsetStream(rtxBounds))
{
RegRtElem17 rtxElem = default;
if (rtStream != null)
{
rtxElem = ParseRtStream(rtStream,
memElem);
}
Commit(id, memElem, rtxElem);
}
}
}
memSCA.Clear();
rtxSCA.Clear();
}
finally
{
memSCA.Lock.ExitUpgradeableReadLock();
rtxSCA.Lock.ExitUpgradeableReadLock();
}
}
public void OverlappingTest()
{
int length = 100;
int[] validationArray = GenerateValidationArray(length, -1);
SparseClusteredArray <int> sca = new SparseClusteredArray <int>();
/*
* List<IBounds> boundsArr = new List<IBounds>()
* {
* new Bounds(1, 25),
* new Bounds(26, 30),
* new Bounds(35, 50),
* new Bounds(1, 25),
* new Bounds(5, 25),
* new Bounds(1, 20),
* new Bounds(11, 27),
* new Bounds(32, 70),
* new Bounds(1, 25),
* new Bounds(11, 27),
* new Bounds(1, 25),
* new Bounds(5, 25),
* new Bounds(26, 30),
* new Bounds(35, 50),
* new Bounds(1, 20),
* new Bounds(32, 70),
* new Bounds(2, 65),
* new Bounds(0, 99),
* };
*
* foreach (var bounds in boundsArr)
* {
* var arr = GenerateBytes(bounds, validationArray);
*
* sca.AddOrUpdate(arr, bounds.Lower);
* Validate(sca, validationArray, -1);
* }*/
for (int i = 0; i < 500000; i++)
{
if (i % 10 == 0)
{
sca = new SparseClusteredArray <int>();
validationArray = GenerateValidationArray(length, -1);
}
int lower = _random.Next(98);
int upper = lower + _random.Next(99 - lower) + 1;
SparseClusteredArray <int> .Bounds bounds = new SparseClusteredArray <int> .Bounds(lower, upper);
var arr = GenerateBytes(bounds, validationArray);
sca.Write(arr, bounds.Lower);
Validate(sca, validationArray, -1);
}
}
private int[] GenerateBytes <T>(SparseClusteredArray <T> .IBounds bounds, int[] validationArr)
{
int length = bounds.Length();
int[] ret = new int[length];
for (int i = bounds.Lower; i <= bounds.Upper; i++)
{
validationArr[i] = ret[i - bounds.Lower] = _random.Next();
}
return(ret);
}
protected override void CommitFromMemory()
{
foreach (SegmentStream memStream in MemSCA.GetStreams())
{
var memElems = StreamToStruct <RegMemElem, RegMemElem>(
memStream,
RegMemElem.SizeOfMemElem,
e => e
);
foreach (var memElem in memElems.OrderBy(kv => kv.Value.rtxOffset))
{
var lower = memElem.Value.rtxOffset - 1;
var upper = memElem.Value.rtxOffset + memElem.Value.rtxLength - 2;
if (upper < lower || upper < 0)
{
continue;
}
SparseClusteredArray <byte> .Bounds rtxBounds = new SparseClusteredArray <byte> .Bounds(
lower,
upper
);
using (SegmentStream rtStream = RtxSCA.GetSubsetStream(rtxBounds))
{
RegRtElem rtxElem = default;
if (rtStream != null)
{
rtxElem = ParseRtStream(rtStream,
memElem.Value);
}
Commit(memElem.Key,
memElem.Value,
rtxElem);
}
}
}
MemSCA.Clear();
RtxSCA.Clear();
}
/// <inheritdoc />
public void CommitFromMemory(SparseClusteredArray <byte> contentsSCA, SparseClusteredArray <byte> elementsSCA)
{
var cttElems = new Dictionary <int, InfContentsElem17>();
var elElems = new Dictionary <int, InfElementsElemContainer17>();
foreach (var cttStream in contentsSCA.GetStreams())
{
cttStream.StreamToStruct <InfContentsElem17, InfContentsElem17>(
InfContentsElem17.SizeOfContentsElem,
e => e,
cttElems
);
}
foreach (var elStream in elementsSCA.GetStreams())
{
elStream.StreamToStruct <InfElementsElemContainer17, InfElementsElem17>(
InfElementsElem17.SizeOfElementsElem,
e => new InfElementsElemContainer17(e),
elElems
);
}
foreach (int id in cttElems.Keys)
{
Commit(id,
cttElems.SafeGet(id),
null);
}
foreach (int id in elElems.Keys)
{
Commit(id,
null,
elElems.SafeGet(id));
}
}
// ReSharper disable once ParameterOnlyUsedForPreconditionCheck.Local
private void Validate <T>(SparseClusteredArray <T> sca, T[] vArr, T defaultVal)
{
int idxVal = 0;
foreach (var seg in sca)
{
for (; idxVal < seg._absIdx; idxVal++)
{
Assert.Equal(vArr[idxVal], defaultVal);
}
int fromIdx = seg._fromIdx;
for (; fromIdx <= seg._toIdx; fromIdx++, idxVal++)
{
Assert.Equal(seg._arr[fromIdx], vArr[idxVal]);
}
}
for (; idxVal < vArr.Length; idxVal++)
{
Assert.Equal(vArr[idxVal], defaultVal);
}
}
