private void TreatFieldAttribute(PropertyInfo prop, FieldAttribute fieldAttribute) { if (fieldAttribute == null) { return; } if (Fields.Contains(fieldAttribute.Key)) { return; } var field = CreateField(prop, fieldAttribute); if (fieldAttribute.SearchOrder != FieldSearchOrder.NotSearchable || fieldAttribute.RequireUniqueValue) { var newIndex = Index.CreateStandard(GetNameInStore(), field); Indexes.Add(newIndex); } foreach (var index in fieldAttribute.Indexes) { if (!Indexes.Contains(index)) { var newIndex = Index.CreateCustom(index, GetNameInStore(), field); Indexes.Add(newIndex); } else { Indexes[index].AddField(field); } } }
public void RemoveField(Field f) { if (Fields.Contains(f)) { Fields.Remove(f); } }
public void AddField(string field) { if (!Fields.Contains(field)) { Fields.Add(field); } }
public void AddField(Field f) { if (!Fields.Contains(f)) { Fields.Add(f); } }
public override void InitializeRelatedTables(DataProcessor processor, TableDataBuilder table) { if (!InlineFields) { var tables = processor.TableMap.Tables; var current = tables.FirstOrDefault(t => t.Name == TableName) as TableDataBuilder; if (current != null) { if (!current.Schema.FieldsAreEqual(LookupTableBuilder.Schema) || current.GetType() != LookupTableBuilder.GetType()) { throw new InvalidOperationException("Lookup tables with the same name must have the same schema and type to be shared"); } LookupTableBuilder.Schema.ClearRelations(); LookupTableBuilder = current; } else { //Insert dimension tables in the start, since it is referenced by other tables tables.Insert(0, LookupTableBuilder); } table.Schema.Associate(LookupTableBuilder.Schema, table.Schema.Fields.Where(f => Fields.Contains(f)).ToArray(), LookupTableBuilder.Schema.Keys.Select(fp => fp.Value), true); } //Initialize realted tables in field mappers foreach (var fm in FieldMappers) { fm.InitializeRelatedTables(processor, InlineFields ? table : LookupTableBuilder); } base.InitializeRelatedTables(processor, table); }
public void RemoveField(FieldProperties field) { if (field == null || !Fields.Contains(field)) { return; } Fields.Remove(field); }
public void RemoveField(Field field) { if (Fields.Contains(field)) { Fields.Remove(field); //TODO: update board size } }
public void Collect(FieldDefinition fiel) { if (Fields.Contains(fiel)) { return; } Fields.Add(fiel); Collect(fiel.FieldType); }
public DatasetResultSchema GetShapedSchema(DatasetResultSchema actualSchema) { if (actualSchema.Shape == Shape.Dynamic) { return(DatasetResultSchema.For(actualSchema.Shape, actualSchema.Fields)); } var actualFields = actualSchema.Fields.Where(f => Fields.Contains <BaseSchemaField>(f)).ToArray(); return(DatasetResultSchema.For(actualSchema.Shape, actualFields)); }
public IEnumerable <IFieldPath> Add(Node n) { // if node is SubjectNode, add all fields (and defaults for IRelationFields) // if node is FieldNode with an IRelationField, add all fields for the related subject (and defaults for IRelationFields) // if node is FieldNode with an IField, create a path tracing back to the parent if (n is SubjectNode) { var fields = PathFactory.GetFields(((SubjectNode)n).Subject); foreach (var f in fields) { f.Description = null; // this is bad behaviour from the FieldPathFactory if (!Fields.Contains(f)) { Fields.Add(f); } } return(fields); } else if (n is FieldNode && ((FieldNode)n).Field is IRelationField) { var fields = PathFactory.GetFields((IRelationField)((FieldNode)n).Field); foreach (var f in fields) { // ensure hierarchy is maintained var parent = n; while (parent != null && parent is FieldNode) { f.Insert(0, ((FieldNode)parent).Field); parent = parent.Parent; } f.Description = null; if (!Fields.Contains(f)) { Fields.Add(f); } } return(fields); } else { var path = new FieldPath(); var parent = n; while (parent != null && parent is FieldNode) { path.Insert(0, ((FieldNode)parent).Field); parent = parent.Parent; } if (!Fields.Contains(path)) { Fields.Add(path); } return(new IFieldPath[] { path }); } }
/* * Set the given values to the appropriate fields for the given list. */ private void AdjustValues(List <FieldInstance> fields) { foreach (FieldInstance field in fields) { if (Fields.Contains(field.Info.Name)) { int index = Fields.IndexOf(field.Info.Name); field.Value = assignedValues[index]; } } }
private void reportHeader1_BeforePrint(object sender, EventArgs e) { if (Fields.Contains("BillNumber")) { txtBillNumber.DataField = "BillNumber"; } else { txtBillNumber.DataField = "InputID"; } }
private void Apply(FieldsAdded e) { foreach (var f in e.Fields) { if (!Fields.Contains(f)) { Fields.Add(f); } } UpdatedBy = e.UserId; UpdatedDateTime = e.TimeStamp; }
public List <TekField> GetBorderFields() { List <TekField> result = new List <TekField>(); foreach (TekField field in Fields) { foreach (TekField f in field.Influencers) { if (f.Value == 0 && !Fields.Contains(f) && !result.Contains(f)) { result.Add(f); } } } return(result); }
private void TreatFieldAttribute(PropertyInfo prop, FieldAttribute fieldAttribute) { if (fieldAttribute == null) { return; } if (Fields.Contains(fieldAttribute.Key)) { return; } var field = CreateField(prop, fieldAttribute); if (fieldAttribute.SearchOrder != FieldSearchOrder.NotSearchable || fieldAttribute.RequireUniqueValue) { var newIndex = Index.CreateStandard(GetNameInStore(), field); Indexes.Add(newIndex); } foreach (var index in fieldAttribute.Indexes) { if (!Indexes.Contains(index)) { var newIndex = Index.CreateCustom(index, GetNameInStore(), field); Indexes.Add(newIndex); } else { Indexes[index].AddField(field); } } foreach (var indexProperties in _attributes.Where(_ => _ is IndexPropertiesAttribute) .Cast <IndexPropertiesAttribute>()) { if (!Indexes.Contains(indexProperties.IndexName)) { continue; } var index = Indexes[indexProperties.IndexName]; index.IsUnique = indexProperties.RequireUniqueValue; index.SearchOrder = indexProperties.SearchOrder; } }
public bool isFieldsCompatible(CG_PointData inData) { if (Fields.Count == inData.Fields.Count) { foreach (string field in inData.Fields) { if (!Fields.Contains(field)) { return(false); } } return(true); } return(false); }
public bool IsCompact(TekField addingField) { if (!IsCompact() || addingField.Value != 0 || Fields.Contains(addingField)) { return(false); } int i = 0; while (i < Fields.Count) { if (!addingField.Influencers.Contains(Fields[i])) { return(false); } i++; } return(true); }
/// <summary> /// Adds a member to the type. /// </summary> /// <param name="member">The target member.</param> public override void AddMember(IMemberDeclarationModel member) { var ctor = member as ConstructorDeclaration; if (ctor != null && !Constructors.Contains(ctor)) { Constructors.Add(ctor); return; } var field = member as FieldDeclaration; if (field != null && !Fields.Contains(field)) { Fields.Add(field); return; } var prop = member as PropertyDeclaration; if (prop != null && !Properties.Contains(prop)) { Properties.Add(prop); return; } var method = member as MethodDeclaration; if (method != null && !Methods.Contains(method)) { Methods.Add(method); return; } var evt = member as EventDeclaration; if (evt != null && !Events.Contains(evt)) { Events.Add(evt); return; } throw new NotImplementedException("Member insertion not implemented for type: " + member.GetType().FullName); }
public void WriteBinary(IBinaryWriter writer) { writer.WriteStringArray(nameof(Fields), Fields); if (Fields.Contains(nameof(Field1))) { writer.WriteString(nameof(Field1), Field1); } if (Fields.Contains(nameof(Field2))) { writer.WriteString(nameof(Field2), Field2); } if (Fields.Contains(nameof(Field3))) { writer.WriteString(nameof(Field3), Field3); } }
public void ReadBinary(IBinaryReader reader) { Fields = reader.ReadStringArray(nameof(Fields)); if (Fields.Contains(nameof(Field1))) { Field1 = reader.ReadString(nameof(Field1)); } if (Fields.Contains(nameof(Field2))) { Field2 = reader.ReadString(nameof(Field2)); } if (Fields.Contains(nameof(Field3))) { Field3 = reader.ReadString(nameof(Field3)); } }
public void RegisterField(Field field) { if (!Fields.Contains(field)) { Fields.Add(field); field.SetFieldName(string.Format("Field {0}", Fields.Count)); field.SetFieldId(Fields.Count); BoardSize.Update(field); } else { Debug.Log(string.Format("RegisterFiled: {0} is already registered", field.name)); } if (Fields.Count == 1) { foreach (var player in Players) { PlayerToNextField(player, 0); } } }
// METHODS private void AddFields(Type reflectedType) { MemberInfo[] fieldInfoList = reflectedType.FindMembers(MemberTypes.Field, BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.SetField | BindingFlags.SetProperty, null, null); foreach (MemberInfo fieldInfo in fieldInfoList) { object[] attributeList = fieldInfo.GetCustomAttributes(typeof(InjectAttribute), true); if (attributeList.Length > 0) { if (!Fields.Contains((FieldInfo)fieldInfo)) { Fields.AddLast((FieldInfo)fieldInfo); } } } if (reflectedType.BaseType != typeof(object)) { AddFields(reflectedType.BaseType); } }
/// <summary> /// Get revision number for this work item. If the referenceFieldName is defined then /// gets revision number as value from reference field name, if parameter not defined then use System.Rev. /// </summary> /// <param name="referenceFieldName">Reference field name.</param> /// <returns></returns> public int GetFieldRevision(string referenceFieldName) { Guard.ThrowOnArgumentNull(referenceFieldName, "referenceFieldName"); return(Fields.Contains(referenceFieldName) ? Revision : 0); }
public static Dictionary <TKeyType, T> Load <TKeyType, T>(string csvName, string key, Func <T, string, CsvReader, string, bool> onParseEx = null) where T : new() { Dictionary <TKeyType, T> l = new Dictionary <TKeyType, T>();//用反射设置每个字段 Type type = typeof(T); //string csvName = type.Name + "Config"; CsvReader r = LoadReader(csvName); if (r == null) { return(l); } Fields.Clear(); FieldInfos.Clear(); bool endOfRow = true; //第一行为描述,不解析 while (r.Read() && !r.IsEndOfRow) { } //第二行为字段名 while (r.Read()) { Fields.Add(r.Value); if (r.IsEndOfRow) { break; } } if (Fields.Count == 0) { Debuger.LogError(string.Format("{0}.csv解析不到列名", csvName)); return(l); } //找到csv字段对应的类的字段 FieldInfo keyField = null; foreach (FieldInfo info in type.GetFields()) { FieldInfos[info.Name] = info; if (key == info.Name) { keyField = info; } } if (keyField == null) { Debuger.LogError(string.Format("{0}.csv 类找不到对应的键值字段:{1}", csvName, key)); return(l); } if (!keyField.FieldType.Equals(typeof(TKeyType))) { Debuger.LogError(string.Format("{0}.csv 键值字段的类型和Dictionary不一致:{1}", csvName, key)); return(l); } if (!Fields.Contains(key)) { Debuger.LogError(string.Format("{0}.csv 不包含键值列:{1} 是否被删除?", csvName, key)); return(l); } T row = default(T); FieldInfo fieldInfo; string val; object outVal; TKeyType k = default(TKeyType); //剩下的行数据 while (r.Read()) { if (endOfRow) { if (row != null) { if (l.ContainsKey(k)) { Debuger.LogError(string.Format("{0}.csv 行:{1} 键值({2})重复 是不是没有填 ", csvName, r.Row, key)); } l[k] = row; } row = new T(); } endOfRow = r.IsEndOfRow; val = r.Value; if (r.Col >= Fields.Count) { continue; } fieldInfo = FieldInfos.Get(Fields[r.Col]); if (onParseEx != null) { if (!onParseEx(row, Fields[r.Col], r, val))//如果扩展解析出错了,那么这一行不算 { continue; } } if (fieldInfo == null || string.IsNullOrEmpty(val))//空字符的话算默认值 { continue; } if (StringUtil.TryParse(val, fieldInfo.FieldType, out outVal)) { fieldInfo.SetValue(row, outVal); if (fieldInfo.Name == key) { k = (TKeyType)outVal; } } else { Debuger.LogError(string.Format("{0}.csv解析出错 行:{1} 列:{2} 列名:{3} ", csvName, r.Row, r.Col, Fields[r.Col])); } } if (row != null && !l.ContainsKey(k))//最后一行补上 { l[k] = row; } return(l); }
public bool FieldExists(string field) { return(!string.IsNullOrWhiteSpace(Fields) && Fields.Contains(field)); }
public bool ContainsField(ItemFields field) => Fields.Contains(field);
/// <summary> /// Determines if the file contains a Field /// </summary> /// <param name="item">Field to check for</param> /// <returns>True if it does, false otherwise</returns> public bool Contains(IField <T> item) { return(Fields.Contains(item)); }
public bool ContainsField(IField aField) { return(Fields.Contains(aField)); }
/// <summary> /// 校验是否满足约定格式 /// </summary> /// <returns></returns> public bool Exist() { return(Fields.Contains(Field) && Sorts.Contains(SortOrder.ToString())); }
/// <summary> /// Determines whether this instance contains a column with the specified name. /// </summary> /// <param name="name">The name of the column to find.</param> /// <returns><c>true</c> if this instance contains a column with the specified name; otherwise, <c>false</c>.</returns> public bool Contains(string name) { return(Fields.Contains(name)); }