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); }