private static AsyncDataViewModel CreateModel()
{
var idPreset = new ColumnViewModelPreset {
Id = new Guid("A27E5F00-BCA0-4BFE-B43D-EAA4B3F20D42"),
Name = "Id",
IsVisible = true,
Width = 80
}.EnsureFrozen();
var namePreset = new ColumnViewModelPreset {
Id = new Guid("3050F05D-FDCC-43AC-AA63-72CF17E5B7FF"),
Name = "Name",
IsVisible = true,
Width = 200
}.EnsureFrozen();
var template = new AsyncDataViewModelPreset();
var table = new DataTable("Design");
AddColumn(table, template, idPreset, DataColumn.Create(x => x));
AddColumn(table, template, namePreset, DataColumn.Create(x => "Name" + x));
var dataView = new DataView(table, new DefaultFormatProviderSource());
return(new AsyncDataViewModel(
dataView, template, template, new AdvmPresetCollection()));
}
public void Update(string callname, bool lift, ExpressionBlock[] atexprs)
{
CallName = callname;
AttributeExprs = atexprs;
Lift = lift;
Heading = DataHeading.Create(atexprs.Select(a => DataColumn.Create(a.Name, a.DataType)).ToArray());
}
public AstType FunvalType(AstType rtntype, AstField[] argtypes)
{
var ff = argtypes.Select(a => DataColumn.Create(a.Name, a.DataType)).ToArray();
var type = DataTypeCode.Get(rtntype.DataType, ff);
return(new AstType {
DataType = type
});
}
public AstTypedef SubType(string ident, AstType super)
{
var cols = new DataColumn[] { DataColumn.Create("super", super.DataType) };
var ut = DataTypeUser.Get(ident, cols);
Symbols.AddUserType(ident, ut);
return(new AstSubType {
DataType = DataTypes.Void
});
}
// get a heading type
public DataHeading Headingof(IEnumerable <AstField> fields)
{
if (fields == null)
{
return(null);
}
var typelist = fields.Select(f => DataColumn.Create(f.Name, f.DataType));
return(DataHeading.Create(typelist, false));
}
// get a heading type
public DataType Typeof(IEnumerable <AstField> fields)
{
if (fields == null)
{
return(DataTypes.Unknown);
}
var typelist = fields.Select(f => DataColumn.Create(f.Name, f.DataType));
return(Types.Find(typelist));
}
public AstTypedef UserType(string ident, AstField[] fields)
{
var ff = fields.Select(a => DataColumn.Create(a.Name, a.DataType)).ToArray();
var ut = DataTypeUser.Get(ident, ff);
Symbols.AddUserType(ident, ut);
Symbols.AddCatalog(Symbols.FindIdent(ident));
return(new AstUserType {
DataType = DataTypes.Void
});
}
public void Setup()
{
var dataTable = new DataTable("Stub");
var templatePreset = new AsyncDataViewModelPreset();
for (int i = 0; i < 8; ++i)
{
int columnId = i + 1;
var preset = new ColumnViewModelPreset {
Id = new Guid($"{columnId:X8}-0000-0000-0000-000000000000"),
Name = $"Column{columnId}",
IsVisible = true,
Width = 200
}.EnsureFrozen();
var column = DataColumn.Create(x => (x << 16 | columnId));
column.Id = preset.Id;
column.Name = preset.Name;
column.IsVisible = preset.IsVisible;
column.Width = preset.Width;
dataTable.Columns.Add(column);
templatePreset.ConfigurableColumns.Add(preset);
}
dataView = new DataView(dataTable, new DefaultFormatProviderSource());
var defaultPreset = templatePreset.Clone();
var presetCollection = new AdvmPresetCollection();
advModel = new AsyncDataViewModel(
dataView, templatePreset, defaultPreset, presetCollection);
presenterViewModel = new AsyncDataGridCellsPresenterViewModel(advModel);
presenter = new AsyncDataGridCellsPresenter();
presenter.ViewModel = presenterViewModel;
presenter.VisibleColumns = advModel.GridViewModel.ColumnsModel.VisibleColumns;
presenter.HorizontalGridLinesThickness = 0;
presenter.VerticalGridLinesThickness = 0;
presenter.AutoScroll = true;
presenter.Arrange(new Rect(0, 0, 1200, 200));
while (!advModel.IsReady)
{
Dispatcher.CurrentDispatcher.DoEvents();
}
}
// handle generic transform rule and create specific node with all required info
// each element tracks lookup items and folds
public AstField Transfield(string name, string rename = null, AstValue value = null)
{
// Add symbols that were never referenced as variables
if (rename != null) // Rename
{
Symbols.CurrentScope.LookupItems.Add(DataColumn.Create(rename, FindField(rename).DataType));
}
else if (value == null) // Project
{
Symbols.CurrentScope.LookupItems.Add(DataColumn.Create(name, FindField(name).DataType));
}
var lookup = DataHeading.Create(Symbols.CurrentScope.LookupItems.Items);
//Symbols.CurrentScope.LookupItems.Clear();
var accums = _accum.Count;
var haswin = _accum.HasWin;
_accum.Reset(false);
if (name == null)
{
return new AstLift {
Name = "^", Value = value, DataType = value.DataType, Lookup = lookup, Accums = accums, HasWin = haswin,
}
}
;
if (rename != null)
{
return new AstRename {
Name = name, OldName = rename, DataType = FindField(rename).DataType
}
}
;
if (value != null)
{
return new AstExtend {
Name = name, DataType = value.DataType, Value = value, Lookup = lookup, Accums = accums, HasWin = haswin,
}
}
;
return(new AstProject {
Name = name, DataType = FindField(name).DataType
});
}
///============================================================================================
///
/// scopes
///
// Enter scope for a function definition, with accumulator tracking
public bool Enter(string ident, AstType rettype, IList <AstField> arguments)
{
// missing args means lazy; else check for dups
if (arguments != null)
{
var dups = arguments.GroupBy(a => a.Name).Where(g => g.Count() > 1).Select(d => d.Key);
if (dups.Count() > 0)
{
Parser.ParseError($"duplicate parameter '{dups.First()}'");
}
}
var args = (arguments == null) ? null
: arguments.Select(a => DataColumn.Create(a.Name, a.DataType)).ToArray();
var rtype = (rettype == null) ? DataTypes.Unknown : rettype.DataType;
// ident means it's func def not funval
if (ident != null)
{
// if cannot define, then see if can overload
Symbol overfunc = null;
if (!Symbols.CanDefGlobal(ident))
{
overfunc = Symbols.FindIdent(ident);
if (!overfunc.IsCallable)
{
overfunc = null;
}
if (overfunc == null)
{
Parser.ParseError("already defined: {0}", ident);
}
}
// create new symbol or add an overload
// error if dup on args; return type not counter
if (overfunc == null)
{
Symbols.AddDeffun(ident, rtype, args, 0, false);
}
else
{
if (args == null)
{
Parser.ParseError($"overload not allowed: '{ident}'");
}
if (!Symbols.AddOverload(overfunc, rtype, args))
{
Parser.ParseError($"overload argument type conflict: '{ident}'");
}
}
}
// now prepare scope
Symbols.CurrentScope.Push();
if (args != null)
{
foreach (var a in args)
{
Symbols.AddVariable(a.Name, a.DataType, SymKinds.PARAM, false);
}
}
_accum = _accum.Push();
return(true);
}
public DataColumn AsColumn()
{
return(DataColumn.Create(Name, DataType));
}
