public virtual void Populate(FieldMap fieldMap, Entity entity) { var fieldsWithNoValueOnEntity = new List<string>(); var @class = new Class(GetType()); @class.EachField(delegate(FieldInfo fieldInfo) { var uiItem = fieldInfo.GetValue(this) as UIItem; if (uiItem == null || !ControlDictionary.Instance.IsEditable(uiItem)) return; string fieldName = fieldMap.GetFieldNameFor(fieldInfo.Name, fieldInfo.FieldType); if (string.IsNullOrEmpty(fieldName)) return; try { EntityField entityField = entity.Field(fieldName); if (entityField == null) fieldsWithNoValueOnEntity.Add(fieldName); else entityField.SetValueOn(uiItem); } catch (TargetInvocationException e) { throw new AppScreenException( string.Format("Error assigning {0}.{1} to {2}.{3} ", entity.GetType(), fieldName, GetType(), fieldInfo.Name), e.InnerException); } }); if (fieldsWithNoValueOnEntity.Count == 0) return; string message = string.Join(",", fieldsWithNoValueOnEntity.ToArray()); WhiteLogger.Instance.WarnFormat("Mapping to screen: {0} with {1}, No value specified for fields {2}", this, entity.GetType(), message); }
public void AddGroupKeepTypeTest() { // bug found during issue 56 - Group object was losing type after being added FieldMap fm = new FieldMap(); QuickFix.FIX42.News.LinesOfTextGroup linesGroup = new QuickFix.FIX42.News.LinesOfTextGroup(); linesGroup.Text = new QuickFix.Fields.Text("foo"); fm.AddGroup(linesGroup); var rvGroup = fm.GetGroup(1, Tags.LinesOfText); Assert.IsInstanceOf<QuickFix.FIX42.News.LinesOfTextGroup>(rvGroup); }
public void AddGetGroupTest() { Group g1 = new Group(100, 200); Group g2 = new Group(100, 201); FieldMap fm = new FieldMap(); fm.AddGroup(g1); fm.AddGroup(g2); Assert.That(fm.GetGroup(1, 100), Is.EqualTo(g1)); Assert.That(fm.GetGroup(2, 100), Is.EqualTo(g2)); Assert.Throws(typeof(FieldNotFoundException), delegate { fieldmap.GetGroup(0, 101); }); Assert.Throws(typeof(FieldNotFoundException), delegate { fieldmap.GetGroup(3, 100); }); Assert.Throws(typeof(FieldNotFoundException), delegate { fieldmap.GetGroup(1, 101); }); }
protected override void CreateTable(DbDataReader r) { string type = "text"; FieldCount = r.FieldCount; Values = new object[FieldCount]; //InsterStrBuilder StringBuilder ISBer = new StringBuilder($@"INSERT INTO {brackets1}{tableName}{brackets2} ("); for (int i = 0; i < r.FieldCount; i++) { ISBer.Append(brackets1); ISBer.Append(r.GetName(i)); ISBer.Append(brackets2); ISBer.Append(","); } ISBer.Remove(ISBer.Length - 1, 1); ISBer.Append(") VALUES ("); for (int i = 0; i < r.FieldCount; i++) { ISBer.Append("{" + i + "},"); } ISBer.Remove(ISBer.Length - 1, 1); ISBer.Append(")"); InsterStr = ISBer.ToString(); //FieldMap for (int i = 0; i < r.FieldCount; i++) { FieldMap.Add(r.GetName(i), i); } var cmd = conn.CreateCommand(); try { cmd.CommandText = GetCreateTableString(r, type, brackets1, brackets2); cmd.ExecuteNonQuery(); } finally { cmd.Dispose(); } }
private void InstantiateFields() { var i = 0; foreach (var field in _gameBoard.Fields) { var fieldView = _itemPool.GetField(); // Find the node at the field's position and set it as a parent of this field fieldView.transform.SetParent(NodeMap[field.Position].transform); fieldView.Init(field, NodeMap[field.Position], NodeMap[field.ConnectedPosition]); fieldView.name = "Field " + i++; // Keep track of the field in grid space // Since fields are undirected, we should add the opposite direction as well FieldMap.Add(field.Position, field.Direction, fieldView); FieldMap.Add(field.ConnectedPosition, field.Direction.Opposite(), fieldView); } }
/// <summary> /// Reads an object from a JToken /// </summary> /// <remarks> /// The method doesn't change the NDOObjectState. /// </remarks> /// <param name="pc"></param> /// <param name="objectState"></param> public static void FromJToken(this IPersistenceCapable pc, JToken objectState) { Type myType = pc.GetType(); FieldMap fm = new FieldMap(myType); Action setDirty = () => { }; if (pc != null && pc.NDOObjectState == NDOObjectState.Persistent) { if (pc.NDOStateManager == null) // Tests ohne Persistenz { setDirty = () => { pc.NDOObjectState = NDOObjectState.PersistentDirty; } } ; else { setDirty = () => { pc.NDOStateManager.MarkDirty(pc); } }; } foreach (var dictEntry in fm.PersistentFields) { if (!(dictEntry.Value is FieldInfo)) { continue; // This are properties of embedded value types or classes. We should extend the code here, to support embedded members. } FieldInfo fi = (FieldInfo)dictEntry.Value; object oldObj = fi.GetValue(pc); JToken obj = objectState[fi.Name]; if (obj != null) { fi.SetValue(pc, obj.ToObject(fi.FieldType)); } } var ndoStateToken = objectState["NDOObjectState"]; if (ndoStateToken != null) { pc.NDOObjectState = ndoStateToken.ToObject <NDOObjectState>(); } }
private void GetColumnData(TableMap map) { string sql = String.Format(selectColumns, map.TableName); SqlStatement stmt = broker.GetStatement(sql); stmt.StatementType = StatementType.Select; SqlResult sr = stmt.Execute(); for (int i = 0; i < sr.Rows.Count; i++) { // returns columns: Field, Type, Null, Key, Default, Extra string columnName = sr.GetString(i, "Field"); FieldMap fm = map.GetFieldMapFromColumn(columnName); if (fm == null) { fm = new FieldMap(map, columnName); map.Fields.Add(fm); } if (fm != null) { string typeinfo = sr.GetString(i, "Type"); bool isUnsigned; fm.SetDbType(ExtractType(typeinfo, out isUnsigned), isUnsigned); if (fm.DbType == (long)MySqlDbType.Enum) { fm.HandleEnumAsString = true; } fm.SetSize(ExtractSize(typeinfo)); fm.SetIsNullable(sr.GetString(i, "Null").Equals("YES")); fm.SetIsPrimaryKey(sr.GetString(i, "Key").Equals("PRI")); if (fm.IsPrimaryKey) { fm.SetIsAutoGenerated(sr.GetString(i, "Extra").Equals("auto_increment")); } } else // raise an error if we've detected a database/type mismatch { bool hasDefault = sr.GetObject(i, "Default") != null; // TODO disabled due to code restructuring // Check.Verify( isNullable || hasDefault, Error.NoPropertyForNotNullColumn, column, map.Type ); } } }
public void TestObjectMapTraversal() { // make sure all types are known (ObjectMap has been created) before we start the test ObjectFactory.RegisterAssembly(null, Assembly.GetExecutingAssembly()); // perform the test ObjectMap sourceMap = ObjectFactory.GetMap(null, typeof(MemberPicture)); Assert.IsNotNull(sourceMap); FieldMap sourceField = sourceMap.GetFieldMap("MemberId"); Assert.IsNotNull(sourceField); ObjectMap targetMap = ObjectFactory.GetMap(null, sourceField.ForeignKeyTableName); Assert.IsNotNull(targetMap); FieldMap targetField = targetMap.GetFieldMapFromColumn(sourceField.ForeignKeyColumnName); Assert.IsNotNull(targetField); Assert.AreEqual("ListMember.MemberId", targetField.TableColumnName); }
IDictionary <string, object> MakeDict(IPersistenceCapable pc) { var dict = pc.ToDictionary(pm); var shortId = ((IPersistenceCapable)pc).ShortId(); var t = pc.GetType(); FieldMap fm = new FieldMap(t); var mc = Metaclasses.GetClass(t); foreach (var fi in fm.Relations) { var fiName = fi.Name; if (((IPersistenceCapable)pc).NDOGetLoadState(mc.GetRelationOrdinal(fiName))) { object relationObj = fi.GetValue(pc); if (relationObj is IList list) { List <object> dictList = new List <object>(); foreach (IPersistenceCapable relObject in list) { shortId = ((IPersistenceCapable)relObject).ShortId(); dictList.Add(new { _oid = shortId }); } dict.Add(fiName, dictList); } else { // Hollow object means, that we don't want to transfer the object to the other side. if (relationObj == null || ((IPersistenceCapable)relationObj).NDOObjectState == NDOObjectState.Hollow) { dict.Add(fiName, null); } else { IPersistenceCapable relIPersistenceCapable = (IPersistenceCapable)relationObj; shortId = ((IPersistenceCapable)relIPersistenceCapable).ShortId(); dict.Add(fiName, new { _oid = shortId }); } } } } return(dict); }
public DataTableBuilder(Schema schema) { _schema = schema; _fieldMap = null; _fieldOrder = 0; _rowIndex = 0; _rowCountLimit = int.MaxValue; _rowRef = _schema.rangeStartRef; _rows = new List <string[]>(); _rows.Add(new string[schema.fieldCount]); if (_schema.isRotated) { tryAppendCell = _TryAppendCellToRight; } else { tryAppendCell = _TryAppendCellToDown; } }
public void Visit(FieldMap fieldMap) { if (!fieldMap.IsIdentifier) { return; } if (IndentifierField != null) { throw new ArgumentException("There are multiple identifying fields defined on the model map being visited."); } IndentifierField = new ModelMapFieldDetails { FieldName = fieldMap.FieldNames.First(), Property = fieldMap.Property, SchemaFieldType = getSchemaFieldType(fieldMap) }; }
public AssignmentGenerator(Class cls) { this.provider = cls.Provider; FieldMap fm = new FieldMap(cls); foreach (var e in fm.PersistentFields) { if (e.Value.CustomAttributes.Any(c => c.AttributeType == typeof(NDOReadOnlyAttribute))) { continue; } var fieldMapping = cls.FindField((string)e.Key); if (fieldMapping != null) { fields.Add(fieldMapping.Column.Name); } } var relationInfos = new RelationCollector(cls).CollectRelations().ToList(); foreach (RelationFieldInfo ri in relationInfos) { Relation r = ri.Rel; if (r.Multiplicity == RelationMultiplicity.Element && r.MappingTable == null || r.Multiplicity == RelationMultiplicity.List && r.MappingTable == null && r.Parent.FullName != cls.FullName) { foreach (ForeignKeyColumn fkColumn in r.ForeignKeyColumns) { fields.Add(fkColumn.Name); Type systemType = fkColumn.SystemType; } if (r.ForeignKeyTypeColumnName != null) { fields.Add(r.ForeignKeyTypeColumnName); } } } if (cls.TimeStampColumn != null) { fields.Add(cls.TimeStampColumn); } }
private void ExportFieldMapData() { // Reading Palette FDPalette palette = new FDPalette(@".\color"); ShapeDataFile shapeData = new ShapeDataFile(@".\FDSHAP.DAT"); shapeData.LoadData(); FieldDataFile fieldData = new FieldDataFile(@".\FDFIELD.DAT"); fieldData.LoadData(); for (int m = 0; m < 33; m++) { FieldMap map = fieldData.GetField(m); HashSet <int> shapes = new HashSet <int>(); for (int i = 0; i < map.Width; i++) { for (int j = 0; j < map.Height; j++) { var shapeIndex = map.GetShapeIndexAt(i, j); shapes.Add(shapeIndex); } } var shapePanel = shapeData.GetPanel(m); foreach (int shapeIndex in shapes) { ShapeInfo shapeInfo = shapePanel.Shapes[shapeIndex]; FieldShape shape = new FieldShape(); shape.Type = shapeInfo.Type; shape.BattleGroundId = shapeInfo.BattleGroundId; map.Shapes[shapeIndex] = shape; } string mapString = JsonConvert.SerializeObject(map, Formatting.Indented); int mm = m + 1; File.WriteAllText(string.Format(@"D:\Temp\FDII\Chapter_{0}.txt", (mm < 10 ? "0" + mm.ToString() : mm.ToString())), mapString); } }
/// <summary> /// 延迟执行数据库交互,并提交到队列 /// </summary> /// <param name="act">要延迟操作的委托</param> /// <param name="map">字段映射</param> /// <param name="name">表名称</param> /// <param name="isExecute">是否立即执行</param> public override void AppendLazy(string name, FieldMap map, Action <Queue> act, bool isExecute) { try { CreateQueue(name, map); if (isExecute) { act(Queue); return; } Queue.LazyAct = act; if (Queue != null) { _groupQueueList.Add(Queue); } } finally { Clear(); } }
public void GroupDelimTest() { Group g1 = new Group(100, 200); Assert.AreEqual(100, g1.Field); //counter Assert.AreEqual(200, g1.Delim); g1.SetField(new StringField(200, "delim!")); FieldMap fm = new FieldMap(); fm.AddGroup(g1); Assert.AreEqual(1, fm.GetInt(100)); Group g2 = new Group(100, 200); g2.SetField(new StringField(200, "again!")); fm.AddGroup(g2); Assert.AreEqual(2, fm.GetInt(100)); }
/// <summary>Crea o asigna el valor de una posicion en una lista de cadenas</summary> private void SetField(string field, string value, List <FieldMap> lstFields) { FieldMap fdmAdd = new FieldMap(); fdmAdd.name = field; fdmAdd.value = value; fdmAdd.comp = Query.dbCom.Equals; fdmAdd.isModified = true; foreach (FieldMap fldM in lstFieldMap) { if (fldM.name == field) { fldM.value = value; fdmAdd.comp = Query.dbCom.Equals; fldM.isModified = true; return; } } lstFieldMap.Add(fdmAdd); }
public void SaveFieldMap() { BGSCENE_DEF scene = this.fieldMap.scene; Byte[] ebgBin = scene.ebgBin; String mapName = this.fieldMap.mapName; String fieldMapModName = FieldMapEditor.GetFieldMapModName(mapName); String mapResourcePath = FieldMap.GetMapResourcePath(mapName); using (BinaryWriter binaryWriter = new BinaryWriter(new MemoryStream(ebgBin))) { for (Int32 i = 0; i < (Int32)scene.overlayCount; i++) { BGOVERLAY_DEF bgoverlay_DEF = scene.overlayList[i]; UInt32 oriData = bgoverlay_DEF.oriData; UInt16 num = (UInt16)bgoverlay_DEF.transform.localPosition.z; UInt16 num2 = (UInt16)(oriData >> 8 & 4095u); UInt32 num3 = oriData; UInt32 num4 = 1048320u; num3 &= ~num4; num3 |= (UInt32)((Int64)((Int64)num << 8) & (Int64)((UInt64)num4)); global::Debug.Log(String.Concat(new Object[] { i, " : data :", oriData, ", curZ : ", num, ", oriZ : ", num2, ", res : ", num3 })); binaryWriter.BaseStream.Seek(bgoverlay_DEF.startOffset, SeekOrigin.Begin); binaryWriter.Write(num3); } } String path = "Assets/Resources/" + mapResourcePath + fieldMapModName + ".bgs.bytes"; File.WriteAllBytes(path, ebgBin); }
private void UpdateTableMapWithColumnInformation(TableMap map) { SqlResult sr = broker.Execute(String.Format(selectColumns, map.TableName), null, null); // process result set using columns: cid, name, type, notnull, dflt_value, pk for (int i = 0; i < sr.RowsContained; i++) { string columnName = sr.GetString(i, "name"); FieldMap fm = map.GetFieldMapFromColumn(columnName); if (fm == null) { fm = new FieldMap(map, columnName); map.Fields.Add(fm); } // get basic column information fm.SetDbType(sr.GetString(i, "type"), false); fm.SetIsNullable(!sr.GetBoolean(i, "notnull")); fm.SetIsPrimaryKey(sr.GetBoolean(i, "pk")); fm.SetIsAutoGenerated(fm.IsPrimaryKey && (fm.Type == typeof(int) || fm.Type == typeof(long))); } }
public void Awake() { if (Map.current != null) { Destroy(this.gameObject); } else { Map.current = this; current = this; } xOffset = Random.Range(0, 999999); yOffset = Random.Range(0, 999999); graph = new HexGraph(radius); Generate(); SpawnTiles(); setTopography(true); Variagate(Color.cyan, Color.red); Camera.main.GetComponent <CameraFollow>().maxSize = (radius + 1) * Mathf.Sqrt(2.0f / 3); }
public void SetPriorityValueMap(MigrationTestEnvironment env, Configuration config) { // Map P2 to P1 Value v1 = env.NewValue("2", "1"); ValueMap vMap = new ValueMap(); vMap.name = "PriorityValueMap"; vMap.Value.Add(v1); // Map field MappedField mField1 = env.NewMappedField(FIELD_PRIORITY, FIELD_PRIORITY); mField1.valueMap = vMap.name; // Map the rest of the fields using wild card MappedField defaultField = env.NewMappedField("*", "*"); FieldMap fieldMap = new FieldMap(); fieldMap.name = "BugToBugFieldMap"; fieldMap.MappedFields.MappedField.Add(defaultField); fieldMap.MappedFields.MappedField.Add(mField1); // Map work item type WorkItemTypeMappingElement typeMapping = new WorkItemTypeMappingElement(); typeMapping.LeftWorkItemTypeName = "Bug"; typeMapping.RightWorkItemTypeName = "Bug"; typeMapping.fieldMap = fieldMap.name; // Build WIT Session custom setting WITSessionCustomSetting customSetting = new WITSessionCustomSetting(); customSetting.WorkItemTypes.WorkItemType.Add(typeMapping); customSetting.FieldMaps.FieldMap.Add(fieldMap); customSetting.ValueMaps.ValueMap.Add(vMap); SetWitSessionCustomSetting(config, customSetting); }
/// <summary> /// Recupera os dados de todas as chaves estrangeiras. /// </summary> private void GetForeignKeyData() { DataTable dt = GetForeignKeys(null); foreach (DataRow row in dt.Rows) { string fkTableName = (string)row["FK_TABLE_NAME"]; string fkColumnName = (string)row["FK_COLUMN_NAME"]; string pkTableName = (string)row["PK_TABLE_NAME"]; string pkColumnName = (string)row["PK_COLUMN_NAME"]; TableMap map = GetTableMap(fkTableName); if (map != null) { FieldMap fm = map.GetFieldMapFromColumn(fkColumnName); if (fm != null) { fm.ForeignKeyTableName = pkTableName; fm.ForeignKeyColumnName = pkColumnName; } } } }
void RecursivelyAddAdditionalObjects(IPersistenceCapable e, List <IPersistenceCapable> rootObjects, List <IPersistenceCapable> additionalObjects) { var t = e.GetType(); FieldMap fm = new FieldMap(t); var mc = Metaclasses.GetClass(t); foreach (var fi in fm.Relations) { if (((IPersistenceCapable)e).NDOGetLoadState(mc.GetRelationOrdinal(fi.Name))) { object relationObj = fi.GetValue(e); if (relationObj is IList list) { List <object> dictList = new List <object>(); foreach (IPersistenceCapable relIPersistenceCapable in list) { if (!rootObjects.Contains(relIPersistenceCapable) && !additionalObjects.Contains(relIPersistenceCapable)) { additionalObjects.Add(relIPersistenceCapable); RecursivelyAddAdditionalObjects(relIPersistenceCapable, rootObjects, additionalObjects); } } } else { // Hollow object means, that we don't want to transfer the object to the other side. if (relationObj != null && ((IPersistenceCapable)relationObj).NDOObjectState != NDOObjectState.Hollow) { IPersistenceCapable relIPersistenceCapable = (IPersistenceCapable)relationObj; if (!rootObjects.Contains(relIPersistenceCapable) && !additionalObjects.Contains(relIPersistenceCapable)) { additionalObjects.Add(relIPersistenceCapable); RecursivelyAddAdditionalObjects(relIPersistenceCapable, rootObjects, additionalObjects); } } } } } }
public void Visit(BeginProperty instruction) { var key = instruction.Key.Resolve(_services).ToString(); _propertyDef = new PropertyDefinition { Key = instruction.Key.Resolve(_services).ToString() }; if (instruction.Field == null) { return; } _currentFieldMap = new FieldMap { Key = key, FieldNames = new [] { instruction.Field.Resolve(_services).ToString() }, IsIdentifier = instruction.IsIdentifier, PropertyType = PropertyTypes.Parse(instruction.DataType.Resolve(_services).ToString()) }; }
public static IDictionary <string, object> ToDictionary(this IPersistenceCapable pc, IPersistenceManager pm) { if (pc == null) { return(new Dictionary <string, object>()); } if (pm == null) { var sm = pc.NDOStateManager; if (sm == null) { throw new Exception("ToDictionary: pm == null und kann nicht aus dem Objekt ermittelt werden."); } pm = sm.PersistenceManager; } Type myType = pc.GetType(); FieldMap fm = new FieldMap(myType); Dictionary <string, object> result = new Dictionary <string, object>(); foreach (var dictEntry in fm.PersistentFields) { MemberInfo mi = (MemberInfo)dictEntry.Value; if (!(mi is FieldInfo)) { continue; // This are properties of embedded value types or classes. We should extend the code here, to support embedded members. } FieldInfo fi = (FieldInfo)dictEntry.Value; object obj = fi.GetValue(pc); result.Add(dictEntry.Key, obj); } result.Add("_oid", pc.ShortId()); result.Add("NDOObjectState", pc.NDOObjectState); return(result); }
private void TestEnvironment_FieldMapToEmpty(Configuration config) { // Map field MappedField mField1 = new MappedField(); mField1.LeftName = FIELD_PRIORITY; mField1.RightName = string.Empty; mField1.MapFromSide = SourceSideTypeEnum.Left; mField1.valueMap = string.Empty; // set value map name to be empty string // Map the rest of the fields using wild card MappedField defaultField = new MappedField(); defaultField.LeftName = "*"; defaultField.RightName = "*"; defaultField.MapFromSide = SourceSideTypeEnum.Left; FieldMap fieldMap = new FieldMap(); fieldMap.name = "BugToBugFieldMap"; fieldMap.MappedFields.MappedField.Add(defaultField); fieldMap.MappedFields.MappedField.Add(mField1); // Map work item type WorkItemTypeMappingElement typeMapping = new WorkItemTypeMappingElement(); typeMapping.LeftWorkItemTypeName = "Bug"; typeMapping.RightWorkItemTypeName = "Bug"; typeMapping.fieldMap = fieldMap.name; // Build WIT Session custom setting WITSessionCustomSetting customSetting = new WITSessionCustomSetting(); customSetting.WorkItemTypes.WorkItemType.Add(typeMapping); customSetting.FieldMaps.FieldMap.Add(fieldMap); SetWitSessionCustomSetting(config, customSetting); }
public async Task ProcessNestedAggregationsWithAliasesAsync() { var client = GetClient(); var index = CreateRandomIndex <MyType>(client, d => d.Dynamic().Properties(p => p .GeoPoint(g => g.Name(f => f.Field3)) .Object <Dictionary <string, object> >(o1 => o1.Name(f1 => f1.Data).Properties(p1 => p1 .Object <object>(o2 => o2.Name("@user").Properties(p2 => p2 .Text(f3 => f3.Name("identity") .Fields(f => f.Keyword(k => k.Name("keyword").IgnoreAbove(256)))))))))); client.IndexMany(new[] { new MyType { Field1 = "value1" } }, index); await client.Indices.RefreshAsync(index); var aliasMap = new FieldMap { { "user", "*****@*****.**" }, { "alias1", "field1" } }; var processor = new ElasticQueryParser(c => c.SetLoggerFactory(Log).UseMappings(client, index).UseFieldMap(aliasMap)); var aggregations = await processor.BuildAggregationsAsync("terms:(alias1 cardinality:user)"); var actualResponse = client.Search <MyType>(d => d.Index(index).Aggregations(aggregations)); string actualRequest = actualResponse.GetRequest(); _logger.LogInformation("Actual: {Request}", actualRequest); var expectedResponse = client.Search <MyType>(d => d.Index(index).Aggregations(a => a .Terms("terms_alias1", t => t.Field("field1.keyword").Meta(m => m.Add("@field_type", "keyword")) .Aggregations(a1 => a1.Cardinality("cardinality_user", c => c.Field("*****@*****.**")))))); string expectedRequest = expectedResponse.GetRequest(); _logger.LogInformation("Expected: {Request}", expectedRequest); Assert.Equal(expectedRequest, actualRequest); Assert.True(actualResponse.IsValid); Assert.True(expectedResponse.IsValid); Assert.Equal(expectedResponse.Total, actualResponse.Total); }
void TestEnvironment_InsertTwoFieldMapToSameTargetInMappedField(Configuration config) { // Map field MappedField mField1 = new MappedField(); mField1.LeftName = FIELD_PRIORITY; mField1.RightName = FIELD_PRIORITY; mField1.MapFromSide = SourceSideTypeEnum.Left; mField1.valueMap = string.Empty; // set value map name to be empty string // Map to SAME field again MappedField defaultField = new MappedField(); defaultField.LeftName = FIELD_AREA_PATH; defaultField.RightName = FIELD_PRIORITY; defaultField.MapFromSide = SourceSideTypeEnum.Left; FieldMap fieldMap = new FieldMap(); fieldMap.name = "BugToBugFieldMap"; fieldMap.MappedFields.MappedField.Add(defaultField); fieldMap.MappedFields.MappedField.Add(mField1); // Map work item type WorkItemTypeMappingElement typeMapping = new WorkItemTypeMappingElement(); typeMapping.LeftWorkItemTypeName = "Bug"; typeMapping.RightWorkItemTypeName = "Bug"; typeMapping.fieldMap = fieldMap.name; // Build WIT Session custom setting WITSessionCustomSetting customSetting = new WITSessionCustomSetting(); customSetting.WorkItemTypes.WorkItemType.Add(typeMapping); customSetting.FieldMaps.FieldMap.Add(fieldMap); SetWitSessionCustomSetting(config, customSetting); }
/// <summary> /// 取得仅更新的SQL语句 /// </summary> protected virtual string GetSqlCode(TData data) { StringBuilder sql = new StringBuilder(); bool first = true; foreach (var pro in data.__Struct.Properties.Where(p => p.Value.Featrue.HasFlag(PropertyFeatrue.Property))) { if (!FieldMap.ContainsKey(pro.Value.Name)) { continue; } if (first) { first = false; } else { sql.Append(','); } sql.AppendLine($" `{pro.Value.ColumnName}` = ?{pro.Value.Name}"); } return(first ? null : sql.ToString()); }
/// <summary> /// Get calles when Map is displayed. /// </summary> /// <param name="e">Event Arguments.</param> protected override void OnElementChanged(ElementChangedEventArgs <View> e) { base.OnElementChanged(e); if (e.OldElement == null) { this.mapView = Control as MKMapView; this.mapView.ShowsUserLocation = true; this.mapView.DidUpdateUserLocation += this.SetUserPostionOnce; this.mapView.AddGestureRecognizer(this.tapGesture); /* Readd LFHeatMap project first * Found at https://github.com/TreeWatch/LFHeatMaps * Code: * mapView.RegionChanged += ChangeRegion; */ this.myMap = e.NewElement as FieldMap; this.mapView.OverlayRenderer = this.GetOverlayRender; this.AddFields(); } }
/// <summary> /// Este método preenche os dados das colunas da table. /// </summary> private void GetColumnData(TableMap map) { DataTable dt = GetColumns(map.TableName); foreach (DataRow row in dt.Rows) { string columnName = (string)row["COLUMN_NAME"]; FieldMap fm = map.GetFieldMapFromColumn(columnName); if (fm == null) { fm = new FieldMap(map, columnName); map.Fields.Add(fm); } fm.IsNullable = Convert.ToBoolean(row["IS_NULLABLE"]); OleDbType dbType = (OleDbType)row["DATA_TYPE"]; fm.SetDbType((long)dbType); fm.DbTypeName = dbType.ToString(); if (dbType == OleDbType.Decimal || dbType == OleDbType.Numeric || dbType == OleDbType.VarNumeric) { fm.Size = Convert.ToInt32(row["NUMERIC_PRECISION"]); } else if (dbType == OleDbType.LongVarBinary || dbType == OleDbType.LongVarChar || dbType == OleDbType.LongVarWChar || dbType == OleDbType.VarBinary || dbType == OleDbType.VarChar || dbType == OleDbType.VarWChar || dbType == OleDbType.WChar || dbType == OleDbType.Char || dbType == OleDbType.BSTR || dbType == OleDbType.Binary) { fm.Size = Convert.ToInt32(row["CHARACTER_MAXIMUM_LENGTH"]); } int columnFlags = Convert.ToInt32(row["COLUMN_FLAGS"]); int flags = (int)DBCOLUMNFLAGS.ISNULLABLE + (int)DBCOLUMNFLAGS.MAYBENULL; bool isNullableFlag = (columnFlags & flags) != 0; flags = (int)DBCOLUMNFLAGS.WRITE + (int)DBCOLUMNFLAGS.WRITEUNKNOWN; bool isReadOnly = (columnFlags & flags) == 0; fm.IsReadOnly = isReadOnly; if (row["DESCRIPTION"] != DBNull.Value && row["DESCRIPTION"] is string) { fm.Comment = row["DESCRIPTION"].ToString(); } } }
private void SetInvalidFieldValueMap(MigrationTestEnvironment env, Configuration config) { ValueMap vMap = new ValueMap(); vMap.name = "PriorityValues"; var value = env.NewValue("*", "10000"); vMap.Value.Add(value); MappedField mField1 = env.NewMappedField(FIELD_PRIORITY, FIELD_PRIORITY); mField1.valueMap = "PriorityValues"; // Map the rest of the fields using wild card MappedField defaultField = env.NewMappedField("*", "*"); FieldMap fieldMap = new FieldMap(); fieldMap.name = "BugToBugFieldMap"; fieldMap.MappedFields.MappedField.Add(defaultField); fieldMap.MappedFields.MappedField.Add(mField1); WorkItemTypeMappingElement typeMapping = new WorkItemTypeMappingElement(); typeMapping.LeftWorkItemTypeName = "Bug"; typeMapping.RightWorkItemTypeName = "Bug"; typeMapping.fieldMap = fieldMap.name; WITSessionCustomSetting customSetting = new WITSessionCustomSetting(); customSetting.WorkItemTypes.WorkItemType.Add(typeMapping); customSetting.FieldMaps.FieldMap.Add(fieldMap); customSetting.ValueMaps.ValueMap.Add(vMap); SetWitSessionCustomSetting(config, customSetting); }
private void GetColumnData(TableMap map) { string sql = String.Format(selectColumns, map.TableId); SqlResult sr = broker.Execute(sql); for (int i = 0; i < sr.Rows.Count; i++) { string column = sr.GetString(i, "column_name"); FieldMap fm = map.GetFieldMapFromColumn(column); if (fm == null) { fm = new FieldMap(map, column); map.Fields.Add(fm); } bool isNullable = sr.GetString(i, "nulls").Equals("Y"); bool isAutoGenerated = sr.GetString(i, "default").ToLower() == "autoincrement"; fm.ColumnId = sr.GetInt(i, "column_id"); fm.SetDbType(sr.GetString(i, "domain_name"), false); fm.SetIsNullable(isNullable); fm.SetIsAutoGenerated(isAutoGenerated); fm.SetSize(sr.GetInt(i, "width")); } }
private static object GetGenericFieldValue(FieldMap fieldMap, ClarifyDataRow record) { if (fieldMap.FieldNames.Length == 1) { var fieldName = fieldMap.FieldNames[0]; var fieldValueForRecord = record[fieldName]; if (DBNull.Value.Equals(fieldValueForRecord)) { fieldValueForRecord = null; } return(fieldValueForRecord); } if (fieldMap.FieldNames.Length > 1) { var recordValues = Array.ConvertAll(fieldMap.FieldNames, x => record[x].ToString()); return(String.Join(" ", recordValues)); } return(new Exception("No fields were specified for this assignment")); }
protected int SetGroup(StringField grpNoFld, string msgstr, int pos, FieldMap fieldMap, DataDictionary.IGroupSpec dd, DataDictionary.DataDictionary sessionDataDictionary, DataDictionary.DataDictionary appDD) { return SetGroup(grpNoFld, msgstr, pos, fieldMap, dd, sessionDataDictionary, appDD, null); }
public static string GetFieldOrDefault(FieldMap fields, int tag, string defaultValue) { if (!fields.IsSetField(tag)) return defaultValue; try { return fields.GetField(tag); } catch (FieldNotFoundException) { return defaultValue; } }
public string toXMLFields(FieldMap fields, int space) { StringBuilder s = new StringBuilder(); string name = string.Empty; // fields foreach (var f in fields) { s.Append("<field "); if ((dataDictionary_ != null) && ( dataDictionary_.FieldsByTag.ContainsKey(f.Key))) { s.Append("name=\"" + dataDictionary_.FieldsByTag[f.Key].Name + "\" "); } s.Append("number=\"" + f.Key.ToString() + "\">"); s.Append("<![CDATA[" + f.Value.ToString() + "]]>"); s.Append("</field>"); } // now groups List<int> groupTags = fields.GetGroupTags(); foreach (int groupTag in groupTags) { for (int counter = 1; counter <= fields.GroupCount(groupTag); counter++) { s.Append("<group>"); s.Append( toXMLFields( fields.GetGroup(counter, groupTag), space+1)); s.Append("</group>"); } } return s.ToString(); }
/// <summary> /// Initializes a new instance of the <see cref="ValidationScope"/> class. /// </summary> /// <param name="root">The root element of the scope where the initial <see cref="ICollection{IError}"/> has been attached.</param> public ValidationScope(FrameworkElement root) { if (root == null) { throw new ArgumentNullException("root"); } this.fieldList = new FieldMap(); this.errorWatcher = new CollectionWatcher<IError, ValidationError>(this.OnAdded, this.OnRemoved, this.OnCleared); this.reattachErrorCommand = new RunAfterDispatchCommand(this.ReattachConversionErrors); Validation.AddErrorHandler(root, this.HandleDataConversionError); }
public FieldMapTests() { this.fieldmap = new FieldMap(); }
public void ClearAndIsEmptyTest() { FieldMap fieldmap = new FieldMap(); BooleanField field = new BooleanField(200, true); Assert.That(fieldmap.IsEmpty(), Is.EqualTo(true)); fieldmap.SetField(field); Assert.That(fieldmap.IsEmpty(), Is.EqualTo(false)); fieldmap.Clear(); Assert.That(fieldmap.IsEmpty(), Is.EqualTo(true)); Group g = new Group(100, 101); fieldmap.AddGroup(g); Assert.That(fieldmap.IsEmpty(), Is.EqualTo(false)); fieldmap.Clear(); Assert.That(fieldmap.IsEmpty(), Is.EqualTo(true)); }
public static void CheckHasNoRepeatedTags(FieldMap map) { if (map.RepeatedTags.Count > 0) throw new RepeatedTag(map.RepeatedTags[0].Tag); }
public void IsFieldSetTest() { FieldMap fieldmap = new FieldMap(); BooleanField field = new BooleanField(200, true); Assert.That(fieldmap.IsSetField(field), Is.EqualTo(false)); Assert.That(fieldmap.IsSetField(field.Tag), Is.EqualTo(false)); fieldmap.SetField(field); Assert.That(fieldmap.IsSetField(field), Is.EqualTo(true)); Assert.That(fieldmap.IsSetField(field.Tag), Is.EqualTo(true)); }
public void SimpleFieldOrderTest() { int[] fieldord = { 10, 11, 12, 13, 200 }; FieldMap fm = new FieldMap(fieldord); Assert.That(fm.FieldOrder, Is.EqualTo(fieldord)); }
/// <summary> /// Constructs a group and stores it in this Message object /// </summary> /// <param name="grpNoFld"></param> /// <param name="msgstr"></param> /// <param name="pos"></param> /// <param name="fieldMap"></param> /// <param name="dd"></param> /// <param name="sessionDataDictionary"></param> /// <param name="appDD"></param> /// <param name="msgFactory">if this is null, then this method will use the generic Group class constructor</param> /// <returns></returns> protected int SetGroup(StringField grpNoFld, string msgstr, int pos, FieldMap fieldMap, DataDictionary.IGroupSpec dd, DataDictionary.DataDictionary sessionDataDictionary, DataDictionary.DataDictionary appDD, IMessageFactory msgFactory) { int delim = dd.Delim; int grpPos = pos; Group grp = null; while (pos < msgstr.Length) { grpPos = pos; StringField f = ExtractField(msgstr, ref pos, sessionDataDictionary, appDD); if (f.Tag == delim) { if (grp != null) { fieldMap.AddGroup(grp, false); } if (msgFactory != null) grp = msgFactory.Create(Message.ExtractBeginString(msgstr), Message.GetMsgType(msgstr), grpNoFld.Tag); //If above failed, just use a generic Group. if (grp == null) grp = new Group(grpNoFld.Tag, delim); } else if (!dd.IsField(f.Tag)) { if (grp != null) { fieldMap.AddGroup(grp, false); } return grpPos; } grp.SetField(f); if (dd.IsGroup(f.Tag)) { if (FixMessageDescriptorEnabled) { var oldCurrField = _currentGroupField; _currentGroupField = new GroupFixFieldInfo(); _currentGroupField.Tag = f.Tag; DataDictionary.DDField field = null; if (appDD != null && appDD.FieldsByTag.TryGetValue(f.Tag, out field)) { _currentGroupField.Name = field.Name; } else if (sessionDataDictionary != null && sessionDataDictionary.FieldsByTag.TryGetValue(f.Tag, out field)) { _currentGroupField.Name = field.Name; } _currentGroupField.Value = f.getValue(); _currentGroupField.EnumValue = GetEnumValueFromField(f, field); oldCurrField.Fields.Add(_currentGroupField); } pos = SetGroup(f, msgstr, pos, grp, dd.GetGroupSpec(f.Tag), sessionDataDictionary, appDD, msgFactory); } else { if (FixMessageDescriptorEnabled) { FixFieldInfo fi = new FixFieldInfo(); fi.Tag = f.Tag; DataDictionary.DDField field = null; if (appDD != null && appDD.FieldsByTag.TryGetValue(f.Tag, out field)) { _currentGroupField.Name = field.Name; } else if (sessionDataDictionary != null && sessionDataDictionary.FieldsByTag.TryGetValue(f.Tag, out field)) { _currentGroupField.Name = field.Name; } fi.Value = f.getValue(); fi.EnumValue = GetEnumValueFromField(f, field); _currentGroupField.Fields.Add(fi); } } } return grpPos; }
protected void InsertOrigSendingTime(FieldMap header, System.DateTime sendingTime) { if (this.SessionID.BeginString.CompareTo(FixValues.BeginString.FIX42) >= 0) header.SetField(new OrigSendingTime(sendingTime)); else header.SetField(new OrigSendingTime(sendingTime, false)); }
public void Iterate(FieldMap map, string msgType) { DataDictionary.CheckHasNoRepeatedTags(map); // check non-group fields int lastField = 0; foreach (KeyValuePair<int, Fields.IField> kvp in map) { Fields.IField field = kvp.Value; if (lastField != 0 && field.Tag == lastField) throw new RepeatedTag(lastField); CheckHasValue(field); if (null != this.Version && this.Version.Length > 0) { CheckValidFormat(field); if (ShouldCheckTag(field)) { CheckValidTagNumber(field.Tag); CheckValue(field); if (!Message.IsHeaderField(field.Tag, this) && !Message.IsTrailerField(field.Tag, this)) { CheckIsInMessage(field, msgType); CheckGroupCount(field, map, msgType); } } } lastField = field.Tag; } // check contents of each group foreach (int groupTag in map.GetGroupTags()) { for (int i = 1; i <= map.GroupCount(groupTag); i++) { Group g = map.GetGroup(i, groupTag); DDGrp ddg = this.Messages[msgType].GetGroup(groupTag); IterateGroup(g, ddg, msgType); } } }
/// <summary> /// Constructs a group and stores it in this Message object /// </summary> /// <param name="grpNoFld">the group's counter field</param> /// <param name="msgstr">full message string</param> /// <param name="pos">starting character position of group</param> /// <param name="fieldMap">full message as FieldMap</param> /// <param name="dd">group definition structure from dd</param> /// <param name="sessionDataDictionary"></param> /// <param name="appDD"></param> /// <param name="msgFactory">if null, then this method will use the generic Group class constructor</param> /// <returns></returns> protected int SetGroup( StringField grpNoFld, string msgstr, int pos, FieldMap fieldMap, DataDictionary.IGroupSpec dd, DataDictionary.DataDictionary sessionDataDictionary, DataDictionary.DataDictionary appDD, IMessageFactory msgFactory) { int grpEntryDelimiterTag = dd.Delim; int grpPos = pos; Group grp = null; // the group entry being constructed while (pos < msgstr.Length) { grpPos = pos; StringField f = ExtractField(msgstr, ref pos, sessionDataDictionary, appDD); if (f.Tag == grpEntryDelimiterTag) { // This is the start of a group entry. if (grp != null) { // We were already building an entry, so the delimiter means it's done. fieldMap.AddGroup(grp, false); grp = null; // prepare for new Group } // Create a new group! if (msgFactory != null) grp = msgFactory.Create(Message.ExtractBeginString(msgstr), Message.GetMsgType(msgstr), grpNoFld.Tag); //If above failed (shouldn't ever happen), just use a generic Group. if (grp == null) grp = new Group(grpNoFld.Tag, grpEntryDelimiterTag); } else if (!dd.IsField(f.Tag)) { // This field is not in the group, thus the repeating group is done. if (grp != null) { fieldMap.AddGroup(grp, false); } return grpPos; } if (grp == null) { // This means we got into the group's fields without finding a delimiter tag. throw new GroupDelimiterTagException(grpNoFld.Tag, grpEntryDelimiterTag); } // f is just a field in our group entry. Add it and iterate again. grp.SetField(f); if(dd.IsGroup(f.Tag)) { // f is a counter for a nested group. Recurse! pos = SetGroup(f, msgstr, pos, grp, dd.GetGroupSpec(f.Tag), sessionDataDictionary, appDD, msgFactory); } } return grpPos; }
public void GroupDelimTest() { Group g1 = new Group(100, 200); Assert.AreEqual(100, g1.Field); //counter Assert.AreEqual(200, g1.Delim); g1.SetField(new StringField(200, "delim!")); FieldMap fm = new FieldMap(); fm.AddGroup(g1); Assert.AreEqual(1, fm.GetInt(100)); Group g2 = new Group(100, 200); g2.SetField(new StringField(200, "again!")); fm.AddGroup(g2); Assert.AreEqual(2, fm.GetInt(100)); }
protected void InsertSendingTime(FieldMap header) { bool showMilliseconds = false; if (this.SessionID.BeginString == FixValues.BeginString.FIXT11) showMilliseconds = true; else showMilliseconds = this.SessionID.BeginString.CompareTo(FixValues.BeginString.FIX42) >= 0; header.SetField(new Fields.SendingTime(System.DateTime.UtcNow, showMilliseconds && MillisecondsInTimeStamp)); }
protected int SetGroup(StringField grpNoFld, string msgstr, int pos, FieldMap fieldMap, DataDictionary.IGroupSpec dd, DataDictionary.DataDictionary sessionDataDictionary, DataDictionary.DataDictionary appDD) { int delim = dd.Delim; int grpPos = pos; Group grp = null; while (pos < msgstr.Length) { grpPos = pos; StringField f = ExtractField(msgstr, ref pos, sessionDataDictionary, appDD); if (f.Tag == delim) { if (grp != null) { fieldMap.AddGroup(grp, false); } grp = new Group(grpNoFld.Tag, delim); } else if (!dd.IsField(f.Tag)) { if (grp != null) { fieldMap.AddGroup(grp, false); } return grpPos; } grp.SetField(f); if(dd.IsGroup(f.Tag)) { pos = SetGroup(f, msgstr, pos, grp, dd.GetGroupSpec(f.Tag), sessionDataDictionary, appDD); } } return grpPos; }
/// <summary> /// If <paramref name="field"/> is a group-counter for <paramref name="msgType"/>, check that it is accurate, else do nothing. /// </summary> /// <param name="field">a group's counter field</param> /// <param name="map">the FieldMap that contains the group being checked</param> /// <param name="msgType">msg type of message that is/contains <paramref name="map"/></param> public void CheckGroupCount(Fields.IField field, FieldMap map, string msgType) { if(IsGroup(msgType, field.Tag)) { if (map.GetInt(field.Tag) != map.GroupCount(field.Tag)) { throw new RepeatingGroupCountMismatch(field.Tag); } } }
/// <summary> /// Constructs a group and stores it in this Message object /// </summary> /// <param name="grpNoFld"></param> /// <param name="msgstr"></param> /// <param name="pos"></param> /// <param name="fieldMap"></param> /// <param name="dd"></param> /// <param name="sessionDataDictionary"></param> /// <param name="appDD"></param> /// <param name="msgFactory">if this is null, then this method will use the generic Group class constructor</param> /// <returns></returns> protected int SetGroup(StringField grpNoFld, string msgstr, int pos, FieldMap fieldMap, DataDictionary.IGroupSpec dd, DataDictionary.DataDictionary sessionDataDictionary, DataDictionary.DataDictionary appDD, IMessageFactory msgFactory) { int delim = dd.Delim; int grpPos = pos; Group grp = null; while (pos < msgstr.Length) { grpPos = pos; StringField f = ExtractField(msgstr, ref pos, sessionDataDictionary, appDD); if (f.Tag == delim) { if (grp != null) { fieldMap.AddGroup(grp, false); } if (msgFactory != null) grp = msgFactory.Create(Message.ExtractBeginString(msgstr), Message.GetMsgType(msgstr), grpNoFld.Tag); //If above failed, just use a generic Group. if (grp == null) grp = new Group(grpNoFld.Tag, delim); } else if (!dd.IsField(f.Tag)) { if (grp != null) { fieldMap.AddGroup(grp, false); } return grpPos; } grp.SetField(f); if(dd.IsGroup(f.Tag)) { pos = SetGroup(f, msgstr, pos, grp, dd.GetGroupSpec(f.Tag), sessionDataDictionary, appDD, msgFactory); } } return grpPos; }
public void Iterate(FieldMap map, string msgType) { DataDictionary.CheckHasNoRepeatedTags(map); int lastField = 0; foreach (KeyValuePair<int, Fields.IField> kvp in map) { Fields.IField field = kvp.Value; if (lastField != 0 && field.Tag == lastField) throw new RepeatedTag(lastField); CheckHasValue(field); if (null != this.Version && this.Version.Length > 0) { CheckValidFormat(field); if (ShouldCheckTag(field)) { CheckValidTagNumber(field.Tag); CheckValue(field); if (!Message.IsHeaderField(field.Tag, this) && !Message.IsTrailerField(field.Tag, this)) { CheckIsInMessage(field, msgType); CheckGroupCount(field, map, msgType); } } } lastField = field.Tag; } }
protected void InsertSendingTime(FieldMap header) { if (this.SessionID.BeginString.CompareTo(FixValues.BeginString.FIX42) >= 0) header.SetField(new Fields.SendingTime(System.DateTime.UtcNow)); else header.SetField(new Fields.SendingTime(System.DateTime.UtcNow, false)); }