public IEnumerable <FieldList> YBuildSelect(IEnumerable <T> list, int level)
{
Func <T, int, string> getterFunc = (obj, j) => TypeWrapper.YType.GetField(obj, j);
var q = list.Select((t) => {
var lst = new FieldList();
for (int yi = 0; yi < _maxYDim; yi++)
{
var nonClosureIndex = yi;
if (yi >= level)
{
lst.Add(getterFunc(t, nonClosureIndex));
}
else
{
lst.Add(string.Empty);
}
}
return(lst);
});
return(q);
}
public GeneratedData GeneratePivot(IEnumerable <T> data)
{
#region STAGE I: pivot matrix with no aggregations
var dicX = _dictionaryGenerator.GenerateXDictionary(data);
var dicY = _dictionaryGenerator.GenerateYDictionary(data);
logger.Info("*** Generate new pivot ***");
// build up column and row headers trees
var columnHeaders = Task.Run(() => GenerateColumnHeaders(dicX, _typeWrapper.XType.MaxDim)).Result;
var rowHeaders = Task.Run(() => GenerateRowHeaders(dicY, _typeWrapper.YType.MaxDim)).Result;
string[,] matrix = new string[dicX.Count + _typeWrapper.YType.MaxDim, dicY.Count + _typeWrapper.XType.MaxDim];
//Task.Run(() => );
Func <T, int, string> getterFuncX = (obj, j) => _typeWrapper.XType.GetField(obj, j);
Func <T, int, string> getterFuncY = (obj, j) => _typeWrapper.YType.GetField(obj, j);
Func <T, decimal?> getterFuncValue = (obj) => _typeWrapper.VType.GetValue(obj);
var utilsAggregation = new AggregationTreeGenerator <T, TAggregator>(_typeWrapper);
// populate decimal values (inner matrix)
foreach (var element in data)
{
decimal?value = getterFuncValue(element);
T unclosure_t = element;
// convert physical fields to ListFields X and Y
var fldListX = new FieldList();
var fldListY = new FieldList();
var taskFieldListPopulationX = Task.Run(() =>
{
for (int i = 0; i < _typeWrapper.XType.MaxDim; i++)
{
int unclosure_i = i;
fldListX.Add(getterFuncX(unclosure_t, unclosure_i));
}
});
var taskFieldListPopulationY = Task.Run(() =>
{
for (int i = 0; i < _typeWrapper.YType.MaxDim; i++)
{
int unclosure_i = i;
fldListY.Add(getterFuncY(unclosure_t, unclosure_i));
}
});
Task.WaitAll(taskFieldListPopulationX, taskFieldListPopulationY);
// Find coordinates X and Y from dictionaries
int X = dicX[fldListX];
int Y = dicY[fldListY];
// put value in matrix
matrix[X, Y] = Convert.ToString(value);
}
// populate outer field names
var taskMatrixPopulateByX = Task.Run(() =>
{
foreach (var fldListX in dicX)
{
for (int i = 0; i < _typeWrapper.XType.MaxDim; i++)
{
matrix[fldListX.Value, i] = fldListX.Key.ElementAt(_typeWrapper.XType.MaxDim - i - 1); // reverse field list order
}
}
});
var taskMatrixPopulateByY = Task.Run(() =>
{
foreach (var fldListY in dicY)
{
for (int i = 0; i < _typeWrapper.YType.MaxDim; i++)
{
matrix[i, fldListY.Value] = fldListY.Key.ElementAt(_typeWrapper.YType.MaxDim - i - 1); // reverse field list order
}
}
});
Task.WaitAll(taskMatrixPopulateByX, taskMatrixPopulateByY);
#endregion
#region STAGE II: Prepare aggregation tree
var mmx = new MatrixManipulator();
var mmy = new MatrixManipulator();
mmx.AggregationFunctionVector = _typeWrapper.XType.AggregationFunctionsByLevel;
mmy.AggregationFunctionVector = _typeWrapper.YType.AggregationFunctionsByLevel;
var aggXSeedTree = Task.Run(() => utilsAggregation.GenerateXAggregationTree(dicX)).Result;
var aggYSeedTree = Task.Run(() => utilsAggregation.GenerateYAggregationTree(dicY)).Result;
var daX = Task.Run(() => new DimmensionAggregator(aggXSeedTree)).Result;
var daY = Task.Run(() => new DimmensionAggregator(aggYSeedTree)).Result;
#endregion
#region STAGE III: Traverse matrix and calculate aggregations
// For each calcullable column or X create getters/setters functions calculating by-Y-summary values
var taskCreateGetterSetterByX = Task.Run(() =>
{
for (int x = _typeWrapper.XType.MaxDim - 1; x < (dicX.Count - 1) + _typeWrapper.XType.MaxDim; x++)
{
mmy.getValue = utilsAggregation.CreateYGetter(x, matrix);
mmy.setValue = utilsAggregation.CreateYSetter(x, matrix);
daY.DrillDownTree(mmy);
}
});
// For each calcullable row or Y create getters/setters functions calculating by-X-summary values
var taskCreateGetterSetterByY = Task.Run(() =>
{
for (int y = _typeWrapper.YType.MaxDim - 1; y < (dicY.Count - 1) + _typeWrapper.YType.MaxDim; y++)
{
mmx.getValue = utilsAggregation.CreateXGetter(y, matrix);
mmx.setValue = utilsAggregation.CreateXSetter(y, matrix);
daX.DrillDownTree(mmx);
}
});
Task.WaitAll(taskCreateGetterSetterByX, taskCreateGetterSetterByY);
#endregion
var result = new GeneratedData();
result.Matrix = matrix;
result.Row_Hierarchy_Depth = _typeWrapper.YType.MaxDim;
result.Column_Hierarchy_Depth = _typeWrapper.XType.MaxDim;
result.ColumnHeaders = columnHeaders.ToList();
result.RowHeaders = rowHeaders.ToList();
return(result);
}
