// basic checks (only for checking name conflicts) public void CheckCommonNamesConflicts(string name, int line, int column) { if (Classes.ContainsKey(name) || Routines.ContainsKey(name) || Fields.ContainsKey(name) || ImportedModules.Contains(name) || ModuleData.Name == name) { ThrowConflictNameException(ModuleData.File, line, column); } }
void ILoadMember.StaticField(bool hasNonPublic) { if (Loaded(3)) { return; } if (Fields == null) { Fields = new ObjectPropertyCollection(Properties.IgnoreCase); } var bf = BindingFlags.Public | BindingFlags.Static; if (hasNonPublic) { bf |= BindingFlags.NonPublic; } foreach (var f in _Type.GetFields(bf)) { if (f.Name.Contains("<") == false && Fields.ContainsKey(f.Name) == false) { Fields.Add(new ObjectProperty(f)); } } Monitor.Exit(this); }
public void CheckRoutineConflicts(ModuleData module, MethodNameTableItem routineItem) { if (Fields.ContainsKey(routineItem.Name)) { ThrowConflictNameException(module.File, routineItem.Line, routineItem.Column); } }
public override bool IsParse(Fields fields) { var express = fields.ContainsKey("express") ? fields["express"] : ""; var m = Regex.Match(express, ParsePattern); return(m.Success && m.Length > 0); }
public override string Parse(Fields fields) { var express = fields.ContainsKey("express") ? fields["express"] : ""; var match = Regex.Match(express, ParsePattern); if (match.Success == false || match.Length == 0) { return(express); } var result = match.Groups["result"].Value; var thired = match.Groups["thired"].Value; var r = Regex.Match(result, RangePattern); result = Regex.Replace(result, RangePattern, new MatchEvaluator(delegate(Match m) { var min = r.Groups["min"].Value; var max = r.Groups["max"].Value; var math = r.Groups["math"].Value; return(string.Format("{0}>={1} and {0}<={2}", math, min, max)); })); result = string.Format("({0})", result.Replace("与", ") and (").Replace("或", ") or (")); MathExpress = result; HasThiredNumber = string.IsNullOrEmpty(thired) == false; express = Regex.Replace(express, ParsePattern, new MatchEvaluator(delegate(Match m) { return(""); })); return(express); }
//mxd public void UpdateFogColor() { if (General.Map.UDMF && Fields.ContainsKey("fadecolor")) { fogcolor = new Color4((int)Fields["fadecolor"].Value); fogmode = SectorFogMode.FADE; } // Sector uses outisde fog when it's ceiling is sky or Sector_Outside effect (87) is set else if (General.Map.Data.MapInfo.HasOutsideFogColor && (ceiltexname == General.Map.Config.SkyFlatName || (effect == 87 && General.Map.Config.SectorEffects.ContainsKey(effect)))) { fogcolor = General.Map.Data.MapInfo.OutsideFogColor; fogmode = SectorFogMode.OUTSIDEFOGDENSITY; } else if (General.Map.Data.MapInfo.HasFadeColor) { fogcolor = General.Map.Data.MapInfo.FadeColor; fogmode = SectorFogMode.FOGDENSITY; } else { fogcolor = new Color4(); fogmode = (brightness < 248 ? SectorFogMode.CLASSIC : SectorFogMode.NONE); } }
void InitFromBase(SqlTable baseTable) { if (Alias == null) { Alias = baseTable.Alias; } if (Database == null) { Database = baseTable.Database; } if (Owner == null) { Owner = baseTable.Owner; } if (PhysicalName == null) { PhysicalName = baseTable.PhysicalName; } foreach (var field in baseTable.Fields.Values) { if (!Fields.ContainsKey(field.Name)) { Fields.Add(new SqlField(field)); } } foreach (var join in baseTable.Joins) { if (Joins.FirstOrDefault(j => j.TableName == join.TableName) == null) { Joins.Add(join); } } }
public void RegisterFieldMapping(SqlField field) { if (!Fields.ContainsKey(field.PhysicalName)) { Fields.Add(field.PhysicalName, new SqlField(field)); } }
void InitFromBase(SqlTable baseTable) { if (_alias == null) { _alias = baseTable._alias; } if (_database == null) { _database = baseTable._database; } if (_owner == null) { _owner = baseTable._owner; } if (_physicalName == null) { _physicalName = baseTable._physicalName; } foreach (var field in baseTable.Fields.Values) { if (!Fields.ContainsKey(field.Name)) { Fields.Add(new SqlField(field)); } } foreach (var join in baseTable.Joins) { if (Joins.Find(j => j.TableName == join.TableName) == null) { Joins.Add(join); } } }
protected override void CreateTable(DbDataReader r) { eInfo.Run(); FieldCount = r.FieldCount; range = eInfo.R.Resize[EachCashRow, FieldCount]; cash = new object[EachCashRow, FieldCount]; for (int i = 0; i < FieldCount; i++) { if (Fields.ContainsKey(r.GetName(i))) { throw new ActionException($"出现相同的标题\"{r.GetName(i)}\""); } else { Fields.Add(r.GetName(i), i); } } //标题 if (withTitle) { foreach (var item in Fields) { SetValue(item.Key, item.Key); } UpdataRow(); } }
public override bool Match(Fields fields) { var sample = fields.ContainsKey("sample") ? fields["sample"] : ""; var match = Regex.Match(sample, MatchPattern); while (match.Success && match.Length > 0) { var number = match.Groups["number"].Value; var sql = string.Format("{0} >= {1} and {0} <= {2}", number, NumberRange.Min, NumberRange.Max); var result = Calculator.Compute(sql, ""); if (result is bool) { var b = bool.Parse(result.ToString()); if (b) { return(true); } } match = match.NextMatch(); } return(false); }
public override object Get(Token name) { if (Fields.ContainsKey(name.Lexeme)) { var foundField = Fields[name.Lexeme]; if (foundField.IsPrivate) { throw new RuntimeError(name, $"'{name.Lexeme}' is inaccessible due to it's protection level"); } return(foundField.Value); } HlangFunction method = GetMethod(name); if (method != null) { return(method.Bind(this)); } if (ParentClass != null) { return(ParentClass.Get(name)); } throw new RuntimeError(name, $"Can't get undefined property '{name.Lexeme}'"); }
public override bool Match(Fields fields) { var sample = fields.ContainsKey("sample") ? fields["sample"] : ""; var match = Regex.Match(sample, MatchPattern); return(match.Success && match.Length > 0); }
protected T GetField <T>(string key, string lazyFieldsKey = null) where T : IFieldWrapper { if (!Fields.ContainsKey(key)) { object lazyValue = null; var typeOfT = typeof(T); object[] constructorArgs; // Attempt to get lazy value if (lazyFieldsKey != null && _lazyFields != null && _lazyFields.ContainsKey(lazyFieldsKey)) { lazyValue = _lazyFields[lazyFieldsKey]; } if (lazyValue == null) { var scField = Item.Fields[key]; constructorArgs = new object[] { scField, _spawnProvider }; } else { constructorArgs = new object[] { key, this, _spawnProvider, lazyValue }; } Fields[key] = (IFieldWrapper)Activator.CreateInstance(typeOfT, constructorArgs); } return((T)Fields[key]); }
protected override void CreateTable(DbDataReader r) { Directory.CreateDirectory(System.IO.Path.GetDirectoryName(Path)); //writer = new StreamWriter(Path, false, new UTF8Encoding(false)); writer = new StreamWriter(Path, false, Encoding.Default); int FieldCount = r.FieldCount; for (int i = 0; i < FieldCount; i++) { if (Fields.ContainsKey(r.GetName(i))) { throw new ActionException($"出现相同的标题\"{r.GetName(i)}\""); } else { Fields.Add(r.GetName(i), i); } } //标题 if (WithTitle) { foreach (var item in Fields) { SetValue(item.Key, item.Key); } UpdataRow(); } }
/// <summary> /// If a single field was indexed with multiple values this will return those values, otherwise it will just return the single /// value stored for that field. If the field is not found it returns an empty collection. /// </summary> /// <param name="key"></param> /// <returns></returns> public IEnumerable <string> GetValues(string key) { return(MultiValueFields.ContainsKey(key) ? MultiValueFields[key] : Fields.ContainsKey(key) ? new[] { Fields[key] } : Enumerable.Empty <string>()); }
public string Get(DE48_CustomerDataType type) { if (Fields.ContainsKey(type)) { return(Fields[type]); } return(null); }
/// <summary> Removes all occurrences of a tag </summary> /// <param name="Tag_Number"> Tag number of the MARC tags to remove </param> public void Remove_Tag(int Tag_Number) { // Remove from the list of Fields if (Fields.ContainsKey(Tag_Number)) { Fields.Remove(Tag_Number); } }
/// <summary> Gets data from a particular subfield within a singular data field </summary> /// <param name="Tag">Tag for new data field</param> /// <param name="Subfield">Code for the subfield in question</param> /// <returns>The value of the subfield, or an empty string </returns> /// <remarks> If there are multiple instances of this subfield, then they are returned /// together with a '|' delimiter between them </remarks> public string Get_Data_Subfield(int Tag, char Subfield) { if ((Fields.ContainsKey(Tag)) && (Fields[Tag][0].has_Subfield(Subfield))) { return(Fields[Tag][0][Subfield]); } return(String.Empty); }
public string this[int uniqueId, string title] { set { Assert.IsTrue(Fields.ContainsKey(uniqueId)); Fields[uniqueId][title] = value; } }
public override TypeExpression ExtractField(string fieldName) { if (Fields.ContainsKey(fieldName)) { return(Fields[fieldName]); } return(new ErrorType(string.Format("There not be a field with name '{0}' in {1}", fieldName, Identifier))); }
public override void AddFieldDefinition(string name, Type type, int size) { if (!Fields.ContainsKey(name)) { this.AddField(name + "_VarID", new FieldHeaderDefinition(name + "_VarID", this.VariableCount++)); this.AddField(name, new VariableFieldDefinition(name, type, size)); } }
protected void setField(string fieldName, IObject value) { if (fields.ContainsKey(fieldName)) { fields.Remove(fieldName); } fields.New(fieldName, value); }
/// <summary> /// Safely the get value. /// </summary> /// <param name="fieldName">Name of the field.</param> /// <returns>System.Object.</returns> public object SafeGetValue(string fieldName) { if (!Fields.ContainsKey(fieldName)) { return(null); } return(Fields[fieldName]); }
public DSTreeView GetField(string bizName) { if (Fields != null && bizName != null && Fields.ContainsKey(bizName)) { return(Fields[bizName]); } return(null); }
EnumField GetConstant(string name) { if (Fields.ContainsKey(name)) { return(Fields[name]); } return(EnumField.Invalid); }
public bool IsMatch(Fields fields) { if (fields.ContainsKey("sample")) { fields["sample"] = fields["sample"].TrunIntegerUseSample(); } return(Match(fields)); }
/// <summary> /// Add a new message error into the handler and attach it to a field /// </summary> /// <param name="field"></param> /// <param name="message"></param> /// <param name="parameters">If a parameter contains {LANGUAGE_KEY}, it means that LANGUAGE_KEY must be replaced by the label of LANGUAGE_KEY for a given language</param> public void AddField(string field, string message, params object[] parameters) { if (!Fields.ContainsKey(field)) { Fields[field] = new List <Error>(); } Fields[field].Add(new Error(message, parameters)); }
public bool AddField(string name, CbType type) { if (Fields.ContainsKey(name)) { return(false); // error -- duplicate field name } Fields[name] = new CbField(name, type, this); return(true); // success }
public void Add(string fieldName, IFieldInfoTypeDescriptor fieldDescriptor) { if (Fields.ContainsKey(fieldName)) { Fields[fieldName] = fieldDescriptor; return; } Fields.Add(fieldName, fieldDescriptor); }