public Task <object> Aggregate(AsyncExprCtx parent, IList data)
{
int i = aggCtx.name2ndx[sData];
var vals = new object[aggCtx.values.Count];
aggCtx.values.CopyTo(vals, 0);
vals[i] = data;
var aec = new AsyncExprCtx(aggCtx, vals, parent);
return(OPs.ConstValueOf(aec, aggCode));
}
public CtxValue(object valueToCalc, AsyncExprCtx context)
{
this.value = (LazyAsync) delegate(AsyncExprCtx ae)
{
if (ae != context)
{
return(OPs.ConstValueOf(context, valueToCalc));
}
else
{
return(OPs.ConstValueOf(ae, valueToCalc));
}
};
}
public static async Task <object> ISERR(AsyncExprCtx ctx, IList args)
{
try
{
object value = await OPs.ConstValueOf(ctx, args[0]);
var lst = value as IList;
if (lst != null)
{
var res = lst.ToArray(item => item is Exception || item is W.Common.ErrorWrapper);
return(res);
}
else
{
return(value is Exception || value is W.Common.ErrorWrapper);
}
}
catch (OperationCanceledException) { throw; }
catch { return(True); }
}
public Task LoadData(AsyncExprCtx rootAec, Expr loadingExpr, CancellationToken ct)
{
int i = aggCtx.IndexOf(sFactory);
if (i >= 0)
{
var f = (WeightedSums.Factory)aggCtx[i];
foreach (var n2i in aggCtx.name2ndx)
{
if (n2i.Key.StartsWith(sAkk))
{
aggCtx[n2i.Value] = f.NewSums();
}
}
}
var loadingCtx = new Generator.Ctx(aggCtx.parent);
loadingCtx.CreateValue(sUsedParamsDict, aggCtx[aggCtx.IndexOf(sUsedParamsDict)]);
loadingCtx.CreateValue(sLoadingInfo, this);
var loadingCode = Generator.Generate(loadingExpr, loadingCtx);
var ae = new AsyncExprCtx(loadingCtx, loadingCtx.values, rootAec);
return(OPs.ConstValueOf(ae, loadingCode));
}
public static async Task <object> AND(AsyncExprCtx ae, IList args)
{
bool[] results = null;
int cnt = args.Count;
for (int j = 0; j < cnt; j++)
{
object v = await OPs.ConstValueOf(ae, args[j]);
try
{
IList lst = v as IList;
if (lst == null)
{
if (!OPs.xl2bool(v))
{
if (results == null)
{
return(False); // scalar, scalar
}
else
{ // vector, scalar
for (int i = results.Length - 1; i >= 0; i--)
{
results[i] = false;
}
return(results);
}
}
}
else
{
bool allFalse = true;
if (results == null)
{ // scalar, vector
int n = lst.Count;
results = new bool[n];
for (int i = n - 1; i >= 0; i--)
{
bool tmp = OPs.xl2bool(lst[i]);
allFalse = allFalse && !tmp;
results[i] = tmp;
}
}
else
{ // vector, vector
int n = Math.Min(results.Length, lst.Count);
if (n < results.Length)
{
Array.Resize <bool>(ref results, n);
}
for (int i = n - 1; i >= 0; i--)
{
if (!results[i])
{
continue;
}
bool tmp = OPs.xl2bool(lst[i]);
allFalse = allFalse && !tmp;
results[i] = tmp;
}
}
if (allFalse)
{
return(results);
}
}
}
catch (OperationCanceledException) { throw; }
catch { }
}
return(results ?? True);
}
public static async Task Load(IDictionary <string, object> dataExprsAndCookies, DateTime StartDate, DateTime EndDate,
long[] ids, string idParamName, string contextInitializationScript,
OnDataLoading onDataLoading,
Action <float> onProgress,
int maxPartSize,
System.Threading.CancellationToken ct)
{
bool timeRange = StartDate < EndDate;
bool withAggr = ids.Length > 1;
int nTotalPartsToLoad = 0;
int nPartsLoaded = 0;
AsyncFn fProgress = async(aec, args) =>
{
if (!ct.IsCancellationRequested)
{
var info = (LoadingInfo)await OPs.ConstValueOf(aec, args[0]);
var value = await OPs.ConstValueOf(aec, args[1]);
var data = value as IList;
if (data != null)
{
var aggData = await info.Aggregate(aec, data);
onDataLoading(info.dataExpr, info.cookie, (IList)aggData);
Interlocked.Increment(ref nPartsLoaded);
}
else // calc n
{
int n = Convert.ToInt32(value);
Interlocked.Add(ref nTotalPartsToLoad, n);
}
if (onProgress != null)
{
onProgress(100f * nPartsLoaded / nTotalPartsToLoad);
}
}
return(string.Empty);
};
// initialize code generator context
var defs = new Dictionary <string, object>(StringComparer.OrdinalIgnoreCase);
defs.Add(idParamName, ids);
defs.Add("PROGRESS", new FuncDef(fProgress, 2, "PROGRESS"));
if (timeRange)
{
defs.Add(nameof(ValueInfo.A_TIME__XT), StartDate.ToOADate());
defs.Add(nameof(ValueInfo.B_TIME__XT), EndDate.ToOADate());
}
else
{
defs.Add(nameof(ValueInfo.At_TIME__XT), StartDate.ToOADate());
}
var rootCtx = new Generator.Ctx(defs, CoreFuncDefs().GetFuncs);
Generator.Generate(Parser.ParseToExpr(contextInitializationScript), rootCtx);
rootCtx.UseFuncs(new FuncDefs().AddFrom(withAggr ? typeof(FuncDefs_Aggr) : typeof(FuncDefs_NoAggr)).GetFuncs);
var infos = new List <LoadingInfo>(dataExprsAndCookies.Count);
var tasks = new List <Task>();
foreach (var pair in dataExprsAndCookies)
{
infos.Add(new LoadingInfo(pair.Key, pair.Value, rootCtx));
}
var loadingExpr = Parser.ParseToExpr(@"(
PartsOfLimitedSize(" + idParamName + " ," + maxPartSize.ToString() + @")
..let(parts)
,let(n,COLUMNS(parts)) .. PROGRESS(" + sLoadingInfo + @"),
,_ParFor(
let(i,0),
i<n,
(
let(" + idParamName + @", parts[i])
,FindSolutionExpr({}, " + sUsedParamsDict + @".Keys()) . ExprToExecutable() . AtNdx(0) .. PROGRESS(" + sLoadingInfo + @")
,let(i, i+1)
)
)
)");
var rootAec = new AsyncExprRootCtx(rootCtx.name2ndx, rootCtx.values, OPs.GlobalMaxParallelismSemaphore);
foreach (var info in infos)
{
tasks.Add(Task.Factory.StartNew(() => info.LoadData(rootAec, loadingExpr, ct)).Unwrap());
}
await TaskEx.WhenAll(tasks);
}
