public void CopyTo(PivotData toPivotData, Func <object[], IAggregator, object[]> mapKey, Func <IAggregator, IAggregator> mapAggr)
{
// remove all totals
toPivotData.totalValues.Clear();
IAggregator aggr;
foreach (var entry in values)
{
var toKey = mapKey(entry.Key, entry.Value);
if (toKey != null)
{
if (!toPivotData.values.TryGetValue(toKey, out aggr))
{
aggr = toPivotData.aggregatorFactory.Create();
toPivotData.values[toKey] = aggr;
}
aggr.Merge(mapAggr(entry.Value));
}
}
if (!toPivotData.lazyTotals)
{
toPivotData.BatchCalcTotals();
}
}
PivotData GetGrandTotalPvtData(IPivotData basePvtData)
{
// this is grand-total
var grandTotalPvtData = new PivotData(emptyStringArray, PvtData.AggregatorFactory);
var grandTotalAggr = grandTotalPvtData[emptyObjectArray];
foreach (var entry in basePvtData)
{
grandTotalAggr.Merge(entry.Value);
}
return(grandTotalPvtData);
}
IPivotData GetBasePivotData(BitArrayMask findMask)
{
PivotData minPvtData = null;
foreach (var cacheEntry in Cache)
{
if (cacheEntry.Key.Match(findMask))
{
if (minPvtData == null || cacheEntry.Value.Count < minPvtData.Count)
{
minPvtData = cacheEntry.Value;
}
}
}
return(minPvtData ?? PvtDataWrapper.PvtData);
}
IPivotData GetBasePivotData(ulong findDimMask)
{
PivotData minPvtData = null;
foreach (var cacheEntry in Cache)
{
if ((cacheEntry.Key.mask & findDimMask) == findDimMask)
{
if (minPvtData == null || cacheEntry.Value.Count < minPvtData.Count)
{
minPvtData = cacheEntry.Value;
}
}
}
return(minPvtData ?? PvtDataWrapper.PvtData);
}
public PivotData Slice(string[] dimensions, bool lazyTotals, Func <object[], IAggregator, bool> predicate)
{
var toPivotData = new PivotData(dimensions, AggregatorFactory, lazyTotals);
int copyDimLen = toPivotData.Dimensions.Length;
var dimIndexes = new int[copyDimLen];
for (int i = 0; i < toPivotData.Dimensions.Length; i++)
{
var dimToCopyIdx = Array.IndexOf(Dimensions, toPivotData.Dimensions[i]);
if (dimToCopyIdx < 0)
{
throw new ArgumentException(String.Format("Dimension {0} does not exist", toPivotData.Dimensions[i]));
}
dimIndexes[i] = dimToCopyIdx;
}
int d;
CopyTo(toPivotData,
(key, aggr) => {
if (!predicate(key, aggr))
{
return(null);
}
var valKeyDims = new object[copyDimLen];
for (d = 0; d < copyDimLen; d++)
{
valKeyDims[d] = key[dimIndexes[d]];
}
return(valKeyDims);
},
(aggr) => {
return(aggr);
}
);
return(toPivotData);
}
public AllValuesCollection(PivotData pvtData)
{
PvtData = pvtData;
}
/// <summary>
/// Execute the query and return operation result as new <see cref="PivotData"/> instance.
/// </summary>
/// <param name="lazyTotals"></param>
/// <returns>data cube that represents query results.</returns>
public PivotData Execute(bool lazyTotals)
{
// compose aggregator handler
var aggrFactory = PvtData.AggregatorFactory;
Func <KeyValuePair <object[], IAggregator>, IAggregator> aggrHandler = (dp) => {
// default handler that returns umodified measure
return(dp.Value);
};
if (AggrSelectors.Count == 1)
{
aggrFactory = AggrSelectors[0].GetFactory(aggrFactory);
aggrHandler = AggrSelectors[0].GetAggregator;
}
else if (AggrSelectors.Count > 1)
{
aggrFactory = new CompositeAggregatorFactory(
AggrSelectors.Select(s => s.GetFactory(aggrFactory)).ToArray()
);
var resAggrHandlers = AggrSelectors.Select(s => s.GetAggregator).ToArray();
var resAggrCnt = AggrSelectors.Count;
int i;
aggrHandler = (dp) => {
var resAggregators = new IAggregator[resAggrCnt];
for (i = 0; i < resAggrCnt; i++)
{
resAggregators[i] = resAggrHandlers[i](dp);
}
return(new CompositeAggregator(resAggregators));
};
}
// compose filter handler
Func <KeyValuePair <object[], IAggregator>, bool> filterHandler = (entry) => { return(true); };
if (FilterHandlers.Count > 0)
{
int i;
var resFilterCnt = FilterHandlers.Count;
var resFilterHandlers = FilterHandlers.ToArray();
filterHandler = (entry) => {
for (i = 0; i < resFilterCnt; i++)
{
if (!resFilterHandlers[i](entry))
{
return(false);
}
}
return(true);
};
}
// compose default value key handler
Func <KeyValuePair <object[], IAggregator>, object[]> valKeyHandler = (dp) => {
// default handler for unmodified dimensions
return(dp.Key);
};
var selectDims = PvtData.Dimensions;
if (DimSelectors.Count > 0)
{
int copyDimLen = DimSelectors.Count;
var resDimKeyHandlers = DimSelectors.Select(s => s.GetDimensionKey).ToArray();
int d;
valKeyHandler = (dp) => {
var valKeyDims = new object[copyDimLen];
for (d = 0; d < copyDimLen; d++)
{
valKeyDims[d] = resDimKeyHandlers[d](dp.Key);
}
return(valKeyDims);
};
selectDims = DimSelectors.Select(ds => ds.Dimension).ToArray();
}
var toPivotData = new PivotData(selectDims, aggrFactory, lazyTotals);
toPivotData.Merge(new FilterPivotData(selectDims, aggrFactory, PvtData,
filterHandler, valKeyHandler, aggrHandler
));
return(toPivotData);
}
