public IEnumerable<ColumnDescriptor> EnumerateAllColumnDescriptors(DataSchema dataSchema,
ICollection<Type> startingTypes)
{
var typeQueue = new Queue<Type>(startingTypes);
var processedTypes = new HashSet<Type>();
while (typeQueue.Count > 0)
{
var type = typeQueue.Dequeue();
if (!processedTypes.Add(type))
{
continue;
}
var rootColumn = ColumnDescriptor.RootColumn(dataSchema, type);
foreach (var child in GetChildColumns(rootColumn))
{
typeQueue.Enqueue(child.PropertyType);
yield return child;
foreach (var grandChild in GetChildColumns(child))
{
yield return grandChild;
if (grandChild.GetAttributes().OfType<ChildDisplayNameAttribute>().Any()
&& child.GetAttributes().OfType<ChildDisplayNameAttribute>().Any())
{
Assert.Fail("Two levels of child display names found on property {0} of type {1}",
grandChild.PropertyPath, rootColumn.PropertyType);
}
}
}
}
}
public void TestDataBindingIsSulfur()
{
var dataSchema = new DataSchema();
var viewSpec =
new ViewSpec().SetColumns(new[]
{new ColumnSpec(PropertyPath.Parse("Code")), new ColumnSpec(PropertyPath.Parse("Molecule!*.Key")),})
.SetFilters(new[]
{new FilterSpec(PropertyPath.Parse("Molecule!*.Key"), FilterOperations.OP_EQUALS, "S")});
var bindingListSource = new BindingListSource();
bindingListSource.SetView(new ViewInfo(dataSchema, typeof(AminoAcid), viewSpec), AminoAcid.AMINO_ACIDS);
Assert.AreEqual(2, bindingListSource.Count);
}
public void TestDataBindingChildDisplayName()
{
var dataSchema = new DataSchema();
var coldescRoot = ColumnDescriptor.RootColumn(dataSchema, typeof (RowValue));
var coldescRetentionTime = coldescRoot.ResolveChild("RetentionTime");
var coldescMinRetentionTime = coldescRetentionTime.ResolveChild("Min");
var coldescMeanRetentionTime = coldescRetentionTime.ResolveChild("Mean");
Assert.AreEqual("MinRetentionTime", dataSchema.GetColumnCaption(coldescMinRetentionTime).InvariantCaption);
Assert.AreEqual("AverageRetentionTime", dataSchema.GetColumnCaption(coldescMeanRetentionTime).InvariantCaption);
var coldescParent = coldescRoot.ResolveChild("Parent");
var coldescParentRetentionTime = coldescParent.ResolveChild("RetentionTime");
var coldescParentMeanRetentionTime = coldescParentRetentionTime.ResolveChild("Mean");
Assert.AreEqual("Parent", dataSchema.GetColumnCaption(coldescParent).InvariantCaption);
Assert.AreEqual("ParentRetentionTime", dataSchema.GetColumnCaption(coldescParentRetentionTime).InvariantCaption);
Assert.AreEqual("ParentAverageRetentionTime", dataSchema.GetColumnCaption(coldescParentMeanRetentionTime).InvariantCaption);
}
public static Comparison<RowKey> GetComparison(DataSchema dataSchema, IEnumerable<IdentifierPath> keys)
{
var sortedKeys = keys.ToArray();
Array.Sort(sortedKeys);
return (rowKey1, rowKey2) =>
{
foreach (var key in sortedKeys)
{
var result = dataSchema.Compare(rowKey1.FindValue(key), rowKey2.FindValue(key));
if (result != 0)
{
return result;
}
}
return 0;
};
}
public void TestDataBindingIsNotNullFilter()
{
var dataSchema = new DataSchema();
var viewSpec = new ViewSpec().SetColumns(new[] {new ColumnSpec(PropertyPath.Parse("AminoAcidsDict!*.Value")),})
.SetSublistId(PropertyPath.Parse("AminoAcidsDict!*"));
var viewSpecWithFilter = viewSpec.SetFilters(new[]
{
new FilterSpec(PropertyPath.Parse("AminoAcidsDict!*.Value"),
FilterOperations.OP_IS_NOT_BLANK, null),
});
var bindingListSource = new BindingListSource();
var bindingListSourceWithFilter = new BindingListSource();
bindingListSource.SetView(new ViewInfo(dataSchema, typeof(Peptide), viewSpec), null);
bindingListSourceWithFilter.SetView(new ViewInfo(dataSchema, typeof(Peptide), viewSpecWithFilter), new[] {new Peptide("")});
Assert.AreEqual(0, bindingListSourceWithFilter.Count);
bindingListSource.RowSource = bindingListSourceWithFilter.RowSource;
Assert.AreEqual(1, bindingListSource.Count);
}
public override Type GetOperandType(DataSchema dataSchema, Type columnType)
{
return(null);
}
protected ColumnDescriptor(DataSchema dataSchema)
{
DataSchema = dataSchema;
}
public ViewInfo(DataSchema dataSchema, Type rootType, ViewSpec viewSpec) : this(ColumnDescriptor.RootColumn(dataSchema, rootType), viewSpec)
{
}
public Root(DataSchema dataSchema, Type propertyType, string uiMode) : base(dataSchema)
{
PropertyPath = PropertyPath.Root;
_propertyType = propertyType;
_uiMode = uiMode;
}
public override IEnumerable <Attribute> GetAttributes()
{
return(DataSchema.FilterAttributes(UiMode, _propertyDescriptor.Attributes.Cast <Attribute>()).Concat(base.GetAttributes()));
}
public override bool IsValidFor(DataSchema dataSchema, Type propertyType)
{
if (null == propertyType)
{
return false;
}
var columnType = dataSchema.GetWrappedValueType(propertyType);
columnType = Nullable.GetUnderlyingType(columnType) ?? columnType;
return convertibleTypes.ContainsKey(columnType) && columnType != typeof (string) && columnType != typeof(bool);
}
public abstract bool Matches(DataSchema dataSchema, Type columnType, object columnValue, object operandValue);
public abstract object CalculateValue(DataSchema dataSchema, IEnumerable <object> values);
public override object CalculateValue(DataSchema dataSchema, IEnumerable <object> values)
{
return(_calculator(dataSchema, values));
}
public Comparer(DataSchema dataSchema)
{
_dataSchema = dataSchema;
}
public override bool Matches(DataSchema dataSchema, Type columnType, object columnValue, object operandValue)
{
return(!Equals(ConvertValue(dataSchema, columnType, columnValue), operandValue));
}
public static IComparer <PivotKey> GetComparer(DataSchema dataSchema)
{
return(new Comparer(dataSchema));
}
public static Comparison <PivotKey> GetComparison(DataSchema dataSchema)
{
return(new Comparer(dataSchema).Compare);
}
public override bool Matches(DataSchema dataSchema, Type columnType, object columnValue, object operandValue)
{
return(Matches(columnValue));
}
public virtual bool IsValidFor(DataSchema dataSchema, Type columnType)
{
return true;
}
public override object CalculateValue(DataSchema dataSchema, IEnumerable <object> values)
{
return(values.Count(o => !ReferenceEquals(o, null)));
}
public Predicate<object> MakePredicate(DataSchema dataSchema, Type columnType, string operand)
{
return _fnMakePredicate(dataSchema, columnType, operand);
}
public override bool IsValidForType(DataSchema dataSchema, Type type)
{
return(true);
}
public override bool IsValidFor(DataSchema dataSchema, Type columnType)
{
return(typeof(string) == dataSchema.GetWrappedValueType(columnType));
}
public override bool IsValidForType(DataSchema dataSchema, Type type)
{
type = dataSchema.GetWrappedValueType(type);
return(TypeDescriptor.GetConverter(type).CanConvertTo(typeof(double)));
}
public virtual Type GetOperandType(DataSchema dataSchema, Type columnType)
{
return(GetTypeToConvertOperandTo(dataSchema, columnType));
}
public void GenerateResXFile(TextWriter writer, DataSchema dataSchema, ICollection<Type> startingTypes)
{
var allColumnCaptions = new HashSet<ColumnCaption>();
foreach (var columnDescriptor in EnumerateAllColumnDescriptors(dataSchema, startingTypes))
{
allColumnCaptions.Add(dataSchema.GetColumnCaption(columnDescriptor));
}
WriteResXFile(writer, allColumnCaptions);
}
public static ColumnDescriptor RootColumn(DataSchema dataSchema, Type propertyType, string uiMode)
{
return(new Root(dataSchema, propertyType, dataSchema.NormalizeUiMode(uiMode)));
}
public static Predicate<object> FnIsNotBlank(DataSchema dataSchema, Type columnType, string operand)
{
return value => null != value && !Equals(value, "");
}
public static ColumnDescriptor RootColumn(DataSchema dataSchema, Type propertyType)
{
return(RootColumn(dataSchema, propertyType, dataSchema.DefaultUiMode));
}
public static Predicate<object> FnNotStartsWith(DataSchema dataSchema, Type columnType, string strOperand)
{
return value => null != value && !value.ToString().StartsWith(strOperand);
}
public TestViewContext(DataSchema dataSchema, IEnumerable<RowSourceInfo> rowSourceInfos)
: base(dataSchema, rowSourceInfos)
{
}
public static object ConvertOperand(DataSchema dataSchema, Type columnType, string operand)
{
var type = GetTypeToConvertOperandTo(dataSchema, columnType);
if (null == type)
{
return operand;
}
if (typeof (char) == type)
{
if (operand.Length != 1)
{
return null;
}
return operand[0];
}
if (type.IsEnum)
{
if (string.IsNullOrEmpty(operand))
{
return null;
}
try
{
return Enum.Parse(type, operand);
}
catch
{
return Enum.Parse(type, operand, true);
}
}
if (string.IsNullOrEmpty(operand))
{
return null;
}
return Convert.ChangeType(operand, type);
}
public abstract bool IsValidForType(DataSchema dataSchema, Type type);
public override bool Matches(DataSchema dataSchema, Type columnType, object columnValue, object operandValue)
{
return(null != columnValue && !Equals(columnValue, string.Empty));
}
public static Predicate<object> FnNotEquals(DataSchema dataSchema, Type columnType, string strOperand)
{
object operand = ConvertOperand(dataSchema, columnType, strOperand);
return value => !Equals(ConvertValue(dataSchema, columnType, value), operand);
}
protected AbstractViewContext(DataSchema dataSchema, IEnumerable <RowSourceInfo> rowSources)
{
DataSchema = dataSchema;
RowSources = rowSources;
}
public static Predicate<object> FnNotContains(DataSchema dataSchema, Type columnType, string strOperand)
{
return value => null != value && value.ToString().IndexOf(strOperand, StringComparison.Ordinal) < 0;
}
public Root(DataSchema dataSchema, Type propertyType) : base(dataSchema)
{
PropertyPath = PropertyPath.Root;
_propertyType = propertyType;
}
public static Type GetTypeToConvertOperandTo(DataSchema dataSchema, Type columnType)
{
if (null == columnType)
{
return typeof (string);
}
columnType = dataSchema.GetWrappedValueType(columnType);
columnType = Nullable.GetUnderlyingType(columnType) ?? columnType;
Type typeToConvertTo;
if (convertibleTypes.TryGetValue(columnType, out typeToConvertTo))
{
return typeToConvertTo;
}
return typeof (string);
}
public static ColumnDescriptor RootColumn(DataSchema dataSchema, Type propertyType)
{
return new Root(dataSchema, propertyType);
}
public static object ConvertValue(DataSchema dataSchema, Type columnType, object value)
{
if (value == null)
{
return null;
}
var type = GetTypeToConvertOperandTo(dataSchema, columnType);
if (type == typeof (string))
{
return value.ToString();
}
return Convert.ChangeType(value, type);
}
protected ColumnDescriptor(DataSchema dataSchema)
{
DataSchema = dataSchema;
}
public virtual Type GetOperandType(DataSchema dataSchema, Type columnType)
{
return GetTypeToConvertOperandTo(dataSchema, columnType);
}
public string GetColumnCaption(ColumnCaptionType columnCaptionType)
{
return(DataSchema.GetColumnCaption(DataSchema.GetColumnCaption(this), columnCaptionType));
}
public override bool IsValidFor(DataSchema dataSchema, Type columnType)
{
return typeof (string) == dataSchema.GetWrappedValueType(columnType);
}
public Root(DataSchema dataSchema, Type propertyType) : base(dataSchema)
{
PropertyPath = PropertyPath.Root;
_propertyType = propertyType;
}
public override Type GetOperandType(DataSchema dataSchema, Type columnType)
{
return null;
}
public static ColumnDescriptor RootColumn(DataSchema dataSchema, Type propertyType)
{
return(new Root(dataSchema, propertyType));
}
public string GetColumnCaption(ColumnCaptionType columnCaptionType)
{
return(DataSchema.GetColumnCaption(this).GetCaption(DataSchema.GetDataSchemaLocalizer(columnCaptionType)));
}
public IEnumerable <ColumnDescriptor> GetChildColumns()
{
return(DataSchema.GetPropertyDescriptors(PropertyType).Select(pd => new Reflected(this, pd)));
}
public ViewInfo(DataSchema dataSchema, Type rootType, ViewSpec viewSpec) : this(ColumnDescriptor.RootColumn(dataSchema, rootType), viewSpec)
{
}
public virtual bool IsValidFor(DataSchema dataSchema, Type columnType)
{
return(true);
}
