public void IndexList_UnitTest_CanInitNormally()
{
IndexList il = new IndexList(null, 5);
Assert.AreEqual(1, il.MinValue);
Assert.AreEqual(5, il.MaxValue);
}
public void IndexList_UnitTest_CanCountCorrectlyWhenMinValueGreaterThan1()
{
HashSet<int> gaps = new HashSet<int> { 1, 5 };
IndexList il = new IndexList(gaps, 4, 3);
Assert.AreEqual(3, il.MinValue);
Assert.AreEqual(4, il.MaxValue);
Assert.AreEqual(1, il.Count());
}
public void IndexList_UnitTest_CanInitWithGaps()
{
HashSet<int> gaps = new HashSet<int> { 1, 3 };
IndexList il = new IndexList(gaps, 5);
Assert.AreEqual(1, il.MinValue);
Assert.AreEqual(5, il.MaxValue);
Assert.AreEqual(3, il.Count());
}
public void IndexList_UnitTest_CanSetMaxValueWhenInGaps()
{
HashSet<int> gaps = new HashSet<int> { 1, 5 };
IndexList il = new IndexList(gaps, 5);
il.SetMaxValue(5, false);
Assert.AreEqual(1, il.MinValue);
Assert.AreEqual(5, il.MaxValue);
Assert.AreEqual(3, il.Count());
}
//MO - Changed : new ctor that accepts the new arguments
public ForEachBootstrapTOOld(enForEachType forEachType, string from, string to, string csvNumbers, string numberOfExecutes, string recordsetName, Guid dlID, IDataListCompiler compiler, out ErrorResultTO errors)
{
errors = new ErrorResultTO();
ForEachType = forEachType;
IDev2IteratorCollection colItr = Dev2ValueObjectFactory.CreateIteratorCollection();
IndexIterator localIndexIterator;
IndexList indexList;
switch(forEachType)
{
case enForEachType.InRecordset:
IBinaryDataListEntry recordset = compiler.Evaluate(dlID, enActionType.User, recordsetName, false, out errors);
if(recordset == null || !recordset.IsRecordset)
{
errors.AddError("When selecting a recordset only valid recordsets can be used");
break;
}
var isEmpty = recordset.IsEmpty();
if(isEmpty)
{
indexList = new IndexList(new HashSet<int> { 1 }, 0);
localIndexIterator = new IndexIterator(new HashSet<int> { 1 }, 0);
}
else
{
indexList = new IndexList(new HashSet<int>(), 0) { MinValue = 1, MaxValue = recordset.FetchLastRecordsetIndex() };
localIndexIterator = new IndexIterator(new HashSet<int>(), 0);
}
localIndexIterator.IndexList = indexList;
IndexIterator = localIndexIterator;
break;
case enForEachType.InRange:
if(string.IsNullOrWhiteSpace(from))
{
errors.AddError("The from field can not be left empty.");
break;
}
if(string.IsNullOrWhiteSpace(to))
{
errors.AddError("The to field can not be left empty.");
break;
}
if(from.Contains("(*)"))
{
errors.AddError("The Star notation is not accepted in the From field.");
break;
}
var fromItr = CreateDataListEvaluateIterator(from, dlID, compiler, colItr, errors);
colItr.AddIterator(fromItr);
int intFrom;
if(!int.TryParse(colItr.FetchNextRow(fromItr).TheValue, out intFrom) || intFrom < 1)
{
errors.AddError("From range must be a whole number from 1 onwards.");
break;
}
if(to.Contains("(*)"))
{
errors.AddError("The Star notation is not accepted in the To field.");
break;
}
var toItr = CreateDataListEvaluateIterator(to, dlID, compiler, colItr, errors);
colItr.AddIterator(toItr);
int intTo;
if(!int.TryParse(colItr.FetchNextRow(toItr).TheValue, out intTo) || intTo < 1)
{
errors.AddError("To range must be a whole number from 1 onwards.");
break;
}
if(intFrom > intTo)
{
indexList = new IndexList(new HashSet<int>(), 0) { MinValue = intFrom, MaxValue = intTo };
ReverseIndexIterator revIdxItr = new ReverseIndexIterator(new HashSet<int>(), 0) { IndexList = indexList };
IndexIterator = revIdxItr;
}
else
{
indexList = new IndexList(new HashSet<int>(), 0) { MinValue = intFrom, MaxValue = intTo };
localIndexIterator = new IndexIterator(new HashSet<int>(), 0) { IndexList = indexList };
IndexIterator = localIndexIterator;
}
break;
case enForEachType.InCSV:
var csvIndexedsItr = CreateDataListEvaluateIterator(csvNumbers, dlID, compiler, colItr, errors);
colItr.AddIterator(csvIndexedsItr);
ErrorResultTO allErrors;
List<int> listOfIndexes = SplitOutCsvIndexes(colItr.FetchNextRow(csvIndexedsItr).TheValue, out allErrors);
if(allErrors.HasErrors())
{
errors.MergeErrors(allErrors);
break;
}
ListIndexIterator listLocalIndexIterator = new ListIndexIterator(listOfIndexes);
ListOfIndex listOfIndex = new ListOfIndex(listOfIndexes);
listLocalIndexIterator.IndexList = listOfIndex;
IndexIterator = listLocalIndexIterator;
break;
default:
if(numberOfExecutes != null && numberOfExecutes.Contains("(*)"))
{
errors.AddError("The Star notation is not accepted in the Numbers field.");
break;
}
int intExNum;
var numOfExItr = CreateDataListEvaluateIterator(numberOfExecutes, dlID, compiler, colItr, errors);
colItr.AddIterator(numOfExItr);
if(!int.TryParse(colItr.FetchNextRow(numOfExItr).TheValue, out intExNum))
{
errors.AddError("Number of executes must be a whole number from 1 onwards.");
}
IndexIterator = new IndexIterator(new HashSet<int>(), intExNum);
break;
}
}
public int MaxIndex()
{
return(IndexList.GetMaxIndex());
}
public ReverseIndexIterator(HashSet <int> gaps, int maxValue)
{
IndexList = new IndexList(gaps, maxValue);
_curValue = 1;
}
//MO - Changed : new ctor that accepts the new arguments
public ForEachBootstrapTO(enForEachType forEachType, string from, string to, string csvNumbers, string numberOfExecutes, string recordsetName, IExecutionEnvironment compiler, out ErrorResultTO errors, int update)
{
errors = new ErrorResultTO();
ForEachType = forEachType;
IIndexIterator localIndexIterator;
switch(forEachType)
{
case enForEachType.InRecordset:
var records = compiler.EvalRecordSetIndexes(recordsetName, update);
if (!compiler.HasRecordSet(recordsetName) )
{
errors.AddError("When selecting a recordset only valid recordsets can be used");
break;
}
localIndexIterator = new IndexListIndexIterator(records);
IndexIterator = localIndexIterator;
break;
case enForEachType.InRange:
if(string.IsNullOrWhiteSpace(@from))
{
errors.AddError("The from field can not be left empty.");
break;
}
if(string.IsNullOrWhiteSpace(to))
{
errors.AddError("The to field can not be left empty.");
break;
}
if(@from.Contains("(*)"))
{
errors.AddError("The Star notation is not accepted in the From field.");
break;
}
var evalledFrom = ExecutionEnvironment.WarewolfEvalResultToString( compiler.Eval(@from, update));
int intFrom;
if (!int.TryParse(evalledFrom, out intFrom) || intFrom < 1)
{
errors.AddError("From range must be a whole number from 1 onwards.");
break;
}
if(to.Contains("(*)"))
{
errors.AddError("The Star notation is not accepted in the To field.");
break;
}
var evalledTo= ExecutionEnvironment.WarewolfEvalResultToString( compiler.Eval(@to, update));
int intTo;
if (!int.TryParse(evalledTo, out intTo) || intTo < 1)
{
errors.AddError("To range must be a whole number from 1 onwards.");
break;
}
IndexList indexList;
if(intFrom > intTo)
{
indexList = new IndexList(new HashSet<int>(), 0) { MinValue = intFrom, MaxValue = intTo };
ReverseIndexIterator revIdxItr = new ReverseIndexIterator(new HashSet<int>(), 0) { IndexList = indexList };
IndexIterator = revIdxItr;
}
else
{
indexList = new IndexList(new HashSet<int>(), 0) { MinValue = intFrom, MaxValue = intTo };
localIndexIterator = new IndexIterator(new HashSet<int>(), 0) { IndexList = indexList };
IndexIterator = localIndexIterator;
}
break;
case enForEachType.InCSV:
var csvIndexedsItr = ExecutionEnvironment.WarewolfEvalResultToString( compiler.Eval(csvNumbers, update));
ErrorResultTO allErrors;
List<int> listOfIndexes = SplitOutCsvIndexes(csvIndexedsItr, out allErrors);
if(allErrors.HasErrors())
{
errors.MergeErrors(allErrors);
break;
}
ListIndexIterator listLocalIndexIterator = new ListIndexIterator(listOfIndexes);
ListOfIndex listOfIndex = new ListOfIndex(listOfIndexes);
listLocalIndexIterator.IndexList = listOfIndex;
IndexIterator = listLocalIndexIterator;
break;
default:
if(numberOfExecutes != null && numberOfExecutes.Contains("(*)"))
{
errors.AddError("The Star notation is not accepted in the Numbers field.");
break;
}
int intExNum;
var numOfExItr = ExecutionEnvironment.WarewolfEvalResultToString( compiler.Eval(numberOfExecutes, update));
if (!int.TryParse(numOfExItr, out intExNum))
{
errors.AddError("Number of executes must be a whole number from 1 onwards.");
}
IndexIterator = new IndexIterator(new HashSet<int>(), intExNum);
break;
}
}
/// <summary>
/// Initializes a new instance of the <see cref="IndexIterator"/> class.
/// </summary>
/// <param name="gaps">The gaps.</param>
/// <param name="maxValue">The maximum value.</param>
/// <param name="minValue">The minimum value.</param>
public IndexIterator(HashSet <int> gaps, int maxValue, int minValue = 1)
{
IndexList = new IndexList(gaps, maxValue, minValue);
_curValue = minValue;
}
/// <summary>
/// Initializes a new instance of the <see cref="IndexIterator"/> class.
/// </summary>
/// <param name="gaps">The gaps.</param>
/// <param name="maxValue">The maximum value.</param>
/// <param name="minValue">The minimum value.</param>
public IndexIterator(HashSet<int> gaps, int maxValue, int minValue = 1)
{
IndexList = new IndexList(gaps, maxValue, minValue);
_curValue = minValue;
}
/// <summary>
/// Inits this instance.
/// </summary>
public void Init(int colCnt, bool createNewStorage = true)
{
if(createNewStorage)
{
_itemStorage = new BinaryDataListStorageLayer();
}
// Construct the alias map for this entry ;)
_keyToAliasMap = new Dictionary<string, BinaryDataListAlias>();
_myKeys = new IndexList(null, 1);
_isEmpty = true;
_internalReturnValue = new List<IBinaryDataListItem>(colCnt); // build the object we require to return data in ;)
for(int i = 0; i < colCnt; i++)
{
_internalReturnValue.Add(new BinaryDataListItem(null, string.Empty));
if(Columns != null)
{
// Handle recordset
_internalReturnValue[i].UpdateRecordset(Namespace); // always the same namespace ;)
_internalReturnValue[i].UpdateField(Columns[i].ColumnName); // always the same column for this entry ;)
}
else
{
// Handle scalars
_internalReturnValue[i].UpdateField(Namespace); // always the same namespace ;)
}
}
// boot strap column cache ;)
short cnt = 1;
if(Columns != null)
{
cnt = (short)Columns.Count;
}
_strToColIdx = new Dictionary<string, int>(cnt);
}
public ReverseIndexIterator(HashSet<int> gaps, int maxValue)
{
IndexList = new IndexList(gaps, maxValue);
_curValue = 1;
}
/// <summary>
/// Copies the data from the clonable instance into the cloned instance ;)
/// </summary>
/// <param name="thisObj">The this object.</param>
public void CopyTo(SBinaryDataListEntry thisObj)
{
// This is dangerous. We need to check for alias keys and use them instead ;)
var keys = thisObj._myKeys;
HashSet<int> gaps = keys.Gaps;
int min = keys.MinValue;
int max = keys.MaxValue;
Columns = thisObj.Columns;
_itemStorage = thisObj._itemStorage;
// avoid referencing issues ;)
_myKeys = new IndexList(gaps, max, min);
DataListKey = thisObj.DataListKey;
IsEmtpy = thisObj.IsEmtpy;
IsRecordset = thisObj.IsRecordset;
IsEvaluationScalar = thisObj.IsEvaluationScalar;
Namespace = thisObj.Namespace;
IsManagmentServicePayload = thisObj.IsManagmentServicePayload;
_strToColIdx = thisObj._strToColIdx;
_keyToAliasMap = thisObj._keyToAliasMap;
}
public bool HasMore()
{
bool result = _curPos < IndexList.Count();
return result;
}
public void IndexList_UnitTest_ContainsOperatesAsExpected()
{
HashSet<int> gaps = new HashSet<int> { 1, 5 };
IndexList il = new IndexList(gaps, 5);
Assert.IsFalse(il.Contains(1));
Assert.IsTrue(il.Contains(4));
}
public int MinIndex()
{
return IndexList.GetMinIndex();
}
public void AddAlias(Guid dlId, string parentColumn, string parentNamespace, string childColumn, out ErrorResultTO errors)
{
errors = new ErrorResultTO();
// TODO : This needs to change so we can track at all levels what the root alias is ;)
IDataListCompiler compiler = DataListFactory.CreateDataListCompiler();
Guid masterId = dlId;
string masterRs = parentNamespace;
string masterCol = parentColumn;
Guid searchId = dlId;
IBinaryDataListEntry masterEntry = null;
int aliasSearchRounds = 0;
BinaryDataListAlias binaryDataListAlias = null;
while(searchId != Guid.Empty)
{
ErrorResultTO invokeErrors;
var bdl = compiler.FetchBinaryDataList(searchId, out invokeErrors);
errors.MergeErrors(invokeErrors);
if(bdl != null)
{
string error;
bdl.TryGetEntry(masterRs, out masterEntry, out error);
errors.AddError(error);
if(masterEntry != null)
{
var aliases = masterEntry.FetchAlias();
if(aliases.TryGetValue(masterCol, out binaryDataListAlias))
{
// we have a hit ;)
masterId = binaryDataListAlias.MasterKeyID;
searchId = masterId;
masterRs = binaryDataListAlias.MasterNamespace;
masterCol = binaryDataListAlias.MasterColumn;
aliasSearchRounds++;
}
else
{
// ensure we copy over the alias entry's keys ;)
if(IsEmtpy)
{
var keyItr = masterEntry.FetchRecordsetIndexes();
_myKeys = new IndexList(keyItr.FetchGaps(), keyItr.MaxIndex(), keyItr.MinIndex());
IsEmtpy = false;
}
searchId = Guid.Empty; // signal end ;)
}
}
else
{
if(aliasSearchRounds == 0)
{
throw new Exception("Missing Entry");
}
// we hit the bottom earlier, handle it ;)
if(binaryDataListAlias != null)
{
masterEntry = binaryDataListAlias.MasterEntry;
}
searchId = Guid.Empty; // signal end ;)
}
}
else
{
throw new Exception("Missing DataList");
}
}
// Check MasterKeyID to see if it contains an alias, if so keep bubbling until we at end ;)
_keyToAliasMap[childColumn] = new BinaryDataListAlias { MasterKeyID = masterId, ChildKey = GenerateKeyPrefix(Namespace, DataListKey), MasterKey = GenerateKeyPrefix(masterRs, masterId), MasterColumn = masterCol, MasterNamespace = masterRs, MasterEntry = masterEntry };
}