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