public EchonetObject(byte classGroupCode, byte classCode) { ClassGroup = SpecificationMaster.GetInstance().プロファイル.Where(p => p.ClassGroupCode == classGroupCode).FirstOrDefault(); if (ClassGroup == null) { ClassGroup = SpecificationMaster.GetInstance().機器.Where(p => p.ClassGroupCode == classGroupCode).FirstOrDefault(); } if (ClassGroup != null) { //スーパークラスのプロパティを列挙 var superClassFilePath = Path.Combine(Directory.GetCurrentDirectory(), "MasterData", $"{ClassGroup.SuperClass}.json"); if (File.Exists(superClassFilePath)) { var superClassProperties = JsonConvert.DeserializeObject <PropertyMaster>(File.ReadAllText(superClassFilePath, new UTF8Encoding(false))); Properties.AddRange(superClassProperties.Properties); } Class = ClassGroup.ClassList.Where(c => c.Status && c.ClassCode == classCode).FirstOrDefault(); if (Class.Status) { var classFilePath = Path.Combine(Directory.GetCurrentDirectory(), "MasterData", $"0x{ClassGroup.ClassGroupCode:X2}-{ClassGroup.ClassGroupName}", $"0x{Class.ClassCode:X2}-{Class.ClassName}.json"); if (File.Exists(classFilePath)) { //クラスのプロパティを列挙 var classProperties = JsonConvert.DeserializeObject <PropertyMaster>(File.ReadAllText(classFilePath, new UTF8Encoding(false))); Properties.AddRange(classProperties.Properties); } } } }
/// <summary> /// Make sure all available flight properties are represented in the view model /// </summary> /// <param name="availableProperties"></param> public void MergeProperties(List <FlightProperty> availableProperties) { // Identify the list of properties that don't already have values // associated with the flight and add entries to the properties list if (Properties != null) { IEnumerable <int> associatedPropertyIds = Properties.Select(p => p.Property.Id); IEnumerable <FlightProperty> missing = availableProperties.Where(ap => !associatedPropertyIds.Contains(ap.Id)).ToList(); // Add an empty value for available but not associated properties if (missing.Any()) { Properties.AddRange(missing.Select(m => new FlightPropertyValue { Property = m })); } } else { Properties = availableProperties.Select(m => new FlightPropertyValue { Property = m }).ToList(); } // Sort the properties by name Properties = Properties.OrderBy(p => p.Property.Name).ToList(); }
public ModelDefinition(IModelDefinition copyFrom) : base(copyFrom) { if (copyFrom != null && copyFrom.Properties.Any()) { Properties.AddRange(copyFrom.Properties.Select(x => new ModelPropertyDefinition(x))); } }
public void MergeProperties(BotConfiguration configuration) { var existingProperties = Properties.Select(x => x.Property).ToArray(); var propertiesToAdd = configuration.Properties.Where(x => !existingProperties.Contains(x.Property)); Properties.AddRange(propertiesToAdd); }
private async Task RefreshProperties() { var newItems = await AlexGuiDebuggerInteraction.Instance.GetElementTreeItemProperties(ElementTreeItem.Id); Properties.Clear(); Properties.AddRange(newItems); }
public EnumFile(Type type, TsDir rootDir) : base(type, rootDir) { Properties.AddRange(Enum.GetNames(type).Select(name => { var stringValue = ""; var val = (Enum.Parse(type, name)); var t = val.GetType().GetEnumUnderlyingType(); if (t.FullName == typeof(int).FullName) { stringValue = ((int)val).ToString(); } else if (t.FullName == typeof(byte).FullName) { stringValue = ((byte)val).ToString(); } else { Console.WriteLine("Unknown enum underlying type"); } return(new EnumProperty { Name = name, Value = stringValue, }); })); }
/// <summary> /// Initializes a new instance of the PropertyTable class. /// </summary> public TestObjectPropertyBag(TestObjectNurse testNurse) { _testNurse = testNurse; PropertySpec[] specs = AddProperties(); Properties.AddRange(specs); }
public void ReadXml(XmlReader reader) { reader.Read(); XmlSerializer serializer = new XmlSerializer(typeof(List <CompilerProperty>), new XmlRootAttribute("CompilerProperties")); Properties.AddRange(serializer.Deserialize(reader) as List <CompilerProperty>); }
public InstanceInspector(INotifyPropertyChanged inpc) { _type = inpc.GetType(); var properties = GetAllProperties(inpc); Properties.AddRange(properties.Select(pi => new PropertyInspector(pi, inpc))); }
public InterfaceFile(TypeBuilder builder, Type type, TsDir rootDir, bool forceInterfaceForProperties = false) : base(type, rootDir) { if (!Export.StartsWith("I")) { Export = $"I{Export}"; } Properties.AddRange(type.GetProperties().PropertyFilter() .Select(prop => new TypedInterfaceProperty(builder, prop, forceInterfaceForProperties))); Fields.AddRange(type.GetFields().FieldFilter().Select(field => new TypedFieldProperty(builder, field))); }
public SGClass WithProperties(params SGClassProperty[] properties) { if (properties == null || properties.Any(x => x == null)) { throw new ArgumentNullException("Properties cannot be null."); } Properties.AddRange(properties); return(this); }
internal void Inherit(List <IMappingConfig> parentMappingConfigs) { foreach (var m in parentMappingConfigs) { var notFoundProperties = m.Properties.FindAll(p => !PropertyNotFound(p.PropertyName)); Properties.AddRange(notFoundProperties); Links.AddRange(m.Links); } SetLinksAlias(); }
public override void Init() { Config = Compiler.ApiConfig[RootNode]; Functions.AddRange(RootNode.SearchByType <FunctionNode>().Select(f => new AbstractFunction(f))); Properties.AddRange(Compiler.CompilerExtension.GetProperties()); Constructor = Compiler.CompilerExtension.GetConstructor(RootNode.Name, Config); TopOfClassExtra.AddRange(Compiler.CompilerExtension.GetTopOfClassExtra(Config)); }
public WeProductBase(string[] categoryIds, WeProductProperty[] propertys, string name, SkuInfo[] skuInfos, string mainImg, string[] imgs, WeProductDetail[] details) : this(name, mainImg) { TkDebug.AssertArgumentNull(categoryIds, "categoryIds", null); TkDebug.AssertArgumentNull(propertys, "propertys", null); TkDebug.AssertArgumentNull(skuInfos, "propertys", null); TkDebug.AssertArgumentNull(imgs, "img", null); TkDebug.AssertArgumentNull(details, "details", null); CategoryIds.AddRange(categoryIds); Properties.AddRange(propertys); SkuInfos.AddRange(skuInfos); Imgs.AddRange(imgs); Details.AddRange(details); }
public NormalizationApiModel(NormalizationApiModel copyFrom) : base(copyFrom) { if (copyFrom == null) { return; } Description = copyFrom.Description; Discriminator = copyFrom.Discriminator; Name = copyFrom.Name; ResourceName = copyFrom.ResourceName; ResourcePath = copyFrom.ResourcePath; Properties.AddRange(copyFrom.Properties); SubTypes.AddRange(copyFrom.SubTypes); }
public TSInterface(Type type, Func <Type, string> mapType) { var ti = type.GetTypeInfo(); _type = type; _mapType = mapType; ModuleName = type.Namespace; FullName = ti.FullName; //Methods = new List<TSMethod>(); var name = ti.IsGenericType ? type.Name.Split(new[] { '`' }).First() : type.Name; InterFaceName = ti.IsInterface ? name : string.Format(Settings.InterfaceFormat, name); //interfaces Interfaces = ti.GetInterfaces().Where(i => i.GetTypeInfo().Assembly == ti.Assembly && i.Name != InterFaceName).ToList(); if (ti.BaseType != null && ti.BaseType != typeof(object)) { Interfaces.Add(ti.BaseType); } //properties var props = ti.GetProperties(BindingFlags.Instance | BindingFlags.Public | BindingFlags.DeclaredOnly); Properties = props.Select(p => new TSProperty(p, _mapType)).ToList(); //fields, not properties var fields = ti.GetFields(BindingFlags.Instance | BindingFlags.Public | BindingFlags.DeclaredOnly); var addp = fields.Select(f => new TSProperty(f, _mapType)).ToList(); Properties.AddRange(addp); //generic //if (_type.IsGenericType) //{ GenericParameters = ti.GetGenericArguments().Select(a => new TSGenericParameter(a, _mapType)).ToList(); // } //methods var methods = ti.GetMethods(BindingFlags.Instance | BindingFlags.Public | BindingFlags.DeclaredOnly).Where(x => !x.IsSpecialName); Methods = methods.Select(m => new TSMethod(m, _mapType)).ToList(); }
public ClassFile(TypeBuilder builder, Type type, TsDir rootDir) : base(type, rootDir) { Properties.AddRange(type.GetProperties().PropertyFilter() .Select(prop => { var tsProp = new TypedClassProperty(builder, prop); foreach (var decorator in builder.DefaultClassPropertyDecorators) { tsProp.Decorators.Add(decorator); } return(tsProp); })); Fields.AddRange(type.GetFields().FieldFilter().Select(field => new TypedFieldProperty(builder, field))); }
internal DllTypeData(TypeDefinition def, DllConfig config) { _config = config; foreach (var i in def.Interfaces) { ImplementingInterfaces.Add(DllTypeRef.From(i.InterfaceType)); } This = DllTypeRef.From(def); Type = def.IsEnum ? TypeEnum.Enum : (def.IsInterface ? TypeEnum.Interface : (def.IsValueType ? TypeEnum.Struct : TypeEnum.Class)); Info = new TypeInfo { Refness = def.IsValueType ? Refness.ValueType : Refness.ReferenceType }; if (def.BaseType != null) { Parent = DllTypeRef.From(def.BaseType); } // TODO: Parse this eventually TypeDefIndex = -1; if (_config.ParseTypeAttributes && def.HasCustomAttributes) { Attributes.AddRange(def.CustomAttributes.Select(ca => new DllAttribute(ca)).Where(a => !string.IsNullOrEmpty(a.Name))); } Layout = (ITypeData.LayoutKind)(def.Attributes & TypeAttributes.LayoutMask); if (_config.ParseTypeFields) { InstanceFields.AddRange(def.Fields.Where(f => !f.IsStatic).Select(f => new DllField(f))); StaticFields.AddRange(def.Fields.Where(f => f.IsStatic).Select(f => new DllField(f))); } if (_config.ParseTypeProperties) { Properties.AddRange(def.Properties.Select(p => new DllProperty(p))); } if (_config.ParseTypeMethods) { var mappedBaseMethods = new HashSet <MethodDefinition>(); var methods = def.Methods.Select(m => DllMethod.From(m, ref mappedBaseMethods)).ToList(); // It's important that Foo.IBar.func() goes after func() (if present) Methods.AddRange(methods.Where(m => m.ImplementedFrom is null)); Methods.AddRange(methods.Where(m => m.ImplementedFrom != null)); } }
/// <summary> /// Parses the image from the wz filetod /// </summary> /// <param name="wzReader">The BinaryReader that is currently reading the wz file</param> public void ParseImage(bool parseEverything = false) { if (Parsed) { return; } else if (Changed) { Parsed = true; return; } this.parseEverything = parseEverything; reader.BaseStream.Position = offset; byte b = reader.ReadByte(); if (b != 0x73 || reader.ReadString() != "Property" || reader.ReadUInt16() != 0) { return; } Properties.AddRange(WzImageProperty.ParsePropertyList(offset, reader, this, this)); parsed = true; }
public void SetItemsSource(object itemsSource) { ClearCache(); if (itemsSource == null) { return; } _itemsSource = itemsSource; Type itemsSourceType = ItemsSource.GetType(); foreach (Type interfaceType in itemsSourceType.GetInterfaces()) { if (interfaceType.IsGenericType && interfaceType.GetGenericTypeDefinition() == typeof(IList <>)) { Type argumentType = itemsSourceType.GenericTypeArguments[0]; Properties.AddRange(argumentType.GetProperties()); break; } } }
public EntityTypeMapping(IEntityType entityType) { Name = entityType.Name; TableName = entityType.GetTableName(); PrimaryKey = entityType.FindPrimaryKey() !.ToDebugString(MetadataDebugStringOptions.SingleLineDefault); Properties.AddRange( entityType.GetProperties() .Select(p => p.ToDebugString(MetadataDebugStringOptions.SingleLineDefault))); Indexes.AddRange( entityType.GetIndexes().Select(i => $"{i.Properties.Format()} {(i.IsUnique ? "Unique" : "")}")); FKs.AddRange( entityType.GetForeignKeys().Select(f => f.ToDebugString(MetadataDebugStringOptions.SingleLineDefault))); Navigations.AddRange( entityType.GetNavigations().Select(n => n.ToDebugString(MetadataDebugStringOptions.SingleLineDefault))); SkipNavigations.AddRange( entityType.GetSkipNavigations().Select(n => n.ToDebugString(MetadataDebugStringOptions.SingleLineDefault))); }
public ClassRepresentationBuilder WithProperties(params string[] properties) { Properties.AddRange(properties); return(this); }
/// <summary> /// Loads all properties from database into objects. If this method is re-called, it will re-query the database. /// </summary> /// <remarks> /// This optimizes sql calls. This will first check if all of the properties have been loaded. If not, /// then it will query for all property types for the current version from the db. It will then iterate over each /// cmdPropertyData row and store the id and propertyTypeId in a list for lookup later. Once the records have been /// read, we iterate over the cached property types for this ContentType and create a new property based on /// our stored list of proeprtyTypeIds. We then have a cached list of Property objects which will get returned /// on all subsequent calls and is also used to return a property with calls to getProperty. /// </remarks> private void InitializeProperties() { _loadedProperties = new Properties(); if (ContentBase != null) { //NOTE: we will not load any properties where HasIdentity = false - this is because if properties are // added to the property collection that aren't persisted we'll get ysods _loadedProperties.AddRange(ContentBase.Properties.Where(x => x.HasIdentity).Select(x => new Property(x))); return; } if (this.ContentType == null) { return; } //Create anonymous typed list with 2 props, Id and PropertyTypeId of type Int. //This will still be an empty list since the props list is empty. var propData = _loadedProperties.Select(x => new { Id = 0, PropertyTypeId = 0 }).ToList(); string sql = @"select id, propertyTypeId from cmsPropertyData where versionId=@versionId"; using (var sqlHelper = Application.SqlHelper) using (IRecordsReader dr = sqlHelper.ExecuteReader(sql, sqlHelper.CreateParameter("@versionId", Version))) { while (dr.Read()) { //add the item to our list propData.Add(new { Id = dr.Get <int>("id"), PropertyTypeId = dr.Get <int>("propertyTypeId") }); } } foreach (PropertyType pt in this.ContentType.PropertyTypes) { if (pt == null) { continue; } //get the propertyId var property = propData.LastOrDefault(x => x.PropertyTypeId == pt.Id); if (property == null) { continue; //var prop = Property.MakeNew(pt, this, Version); //property = new {Id = prop.Id, PropertyTypeId = pt.Id}; } var propertyId = property.Id; Property p = null; try { p = new Property(propertyId, pt); } catch { continue; //this remains from old code... not sure why we would do this? } _loadedProperties.Add(p); } }
public TypeDefinition AddProperties(IEnumerable <PropertyDefinition> properties) { Must.Assert(properties != null); return(WithProperties(Properties.AddRange(properties))); }
/// <summary> /// Loads all properties from database into objects. If this method is re-called, it will re-query the database. /// </summary> /// <remarks> /// This optimizes sql calls. This will first check if all of the properties have been loaded. If not, /// then it will query for all property types for the current version from the db. It will then iterate over each /// cmdPropertyData row and store the id and propertyTypeId in a list for lookup later. Once the records have been /// read, we iterate over the cached property types for this ContentType and create a new property based on /// our stored list of proeprtyTypeIds. We then have a cached list of Property objects which will get returned /// on all subsequent calls and is also used to return a property with calls to getProperty. /// </remarks> private void InitializeProperties() { m_LoadedProperties = new Properties(); if (ContentBase != null) { m_LoadedProperties.AddRange(ContentBase.Properties.Select(x => new Property(x))); return; } if (this.ContentType == null) return; //Create anonymous typed list with 2 props, Id and PropertyTypeId of type Int. //This will still be an empty list since the props list is empty. var propData = m_LoadedProperties.Select(x => new { Id = 0, PropertyTypeId = 0 }).ToList(); string sql = @"select id, propertyTypeId from cmsPropertyData where versionId=@versionId"; using (IRecordsReader dr = SqlHelper.ExecuteReader(sql, SqlHelper.CreateParameter("@versionId", Version))) { while (dr.Read()) { //add the item to our list propData.Add(new { Id = dr.Get<int>("id"), PropertyTypeId = dr.Get<int>("propertyTypeId") }); } } foreach (PropertyType pt in this.ContentType.PropertyTypes) { if (pt == null) continue; //get the propertyId var property = propData.LastOrDefault(x => x.PropertyTypeId == pt.Id); if (property == null) { continue; //var prop = Property.MakeNew(pt, this, Version); //property = new {Id = prop.Id, PropertyTypeId = pt.Id}; } var propertyId = property.Id; Property p = null; try { p = new Property(propertyId, pt); } catch { continue; //this remains from old code... not sure why we would do this? } m_LoadedProperties.Add(p); } }
public TypeDefinition AddProperties(params PropertyDefinition[] properties) { Must.Assert(properties != null); return(WithProperties(Properties.AddRange(properties))); }
/// <summary> /// Adds a collection of properties to an object /// </summary> /// <param name="prop"></param> public void AddRange(IEnumerable <Property> props) { Properties.AddRange(props); }
public ClassDescripter CreateProperty(params PropertyDescripter[] properties) { Properties.AddRange(properties); return(this); }
protected override void ApplyChanges(BinaryDataWriter bin) { AddNewProperties(); bin.ByteOrder = order; bin.Write((ushort)(Properties.Count + AddedProperties.Count + UnknownPropertiesCount)); bin.Write((ushort)0); bin.Write(new byte[0xC * AddedProperties.Count]); bin.Write(data, 4, data.Length - 4); //write rest of entries, adding new elements first doesn't break relative offets in the struct foreach (var m in Properties) { if ((byte)m.type != 1 && (byte)m.type != 2) { continue; } m.ValueOffset += +0xC * AddedProperties.Count; bin.Position = m.ValueOffset; if (m.value.Length != m.ValueCount) { throw new Exception("Can't change the number of values of an usd1 property"); } for (int i = 0; i < m.ValueCount; i++) { if (m.type == EditableProperty.ValueType.int32) { bin.Write(int.Parse(m.value[i])); } else { bin.Write(float.Parse(m.value[i])); } } } for (int i = 0; i < AddedProperties.Count; i++) { bin.Position = bin.BaseStream.Length; uint DataOffset = (uint)bin.BaseStream.Position; AddedProperties[i].ValueOffset = DataOffset; AddedProperties[i].ValueCount = (ushort)AddedProperties[i].value.Length; for (int j = 0; j < AddedProperties[i].value.Length; j++) { if (AddedProperties[i].type == EditableProperty.ValueType.int32) { bin.Write(int.Parse(AddedProperties[i].value[j])); } else { bin.Write(float.Parse(AddedProperties[i].value[j])); } } uint NameOffest = (uint)bin.BaseStream.Position; bin.Write(AddedProperties[i].Name, BinaryStringFormat.ZeroTerminated); bin.WriteAlign(4); uint entryStart = (uint)(4 + i * 0xC); bin.BaseStream.Position = entryStart; bin.Write(NameOffest - entryStart); bin.Write(DataOffset - entryStart); bin.Write((ushort)AddedProperties[i].ValueCount); bin.Write((byte)AddedProperties[i].type); bin.Write((byte)0); OriginalProperties.Add(AddedProperties[i].Name); } Properties.AddRange(AddedProperties); AddedProperties.Clear(); }
protected override ValidationResult IsValid(object value, ValidationContext validationContext) { // try // { var invalidProperties = new List <string>(); var instance = value ?? validationContext.ObjectInstance; #if DEBUG var timer = new Stopwatch(); timer.Start(); #endif if (!Properties.Any()) { Properties.AddRange(GetTypeProperties()); } #if DEBUG timer.Stop(); var message = string.Format("IP/ED dataset imports - Time of Execution get all diagnosis and procedure codes for dataset row: {0}:{1}", timer.Elapsed.Seconds, timer.Elapsed.Milliseconds); Trace.WriteLine(message); timer.Reset(); #endif if (!Properties.Any()) { return(ValidationResult.Success); } #if DEBUG timer.Start(); #endif var diagnosisValues = Properties.Where(propertyInfo => propertyInfo.Name.ContainsIgnoreCase("Diagnosis") && propertyInfo.GetValue(instance, null) != null) .Select(propertyInfo => new KeyValuePair <string, object>(propertyInfo.Name, propertyInfo.GetValue(instance, null))).ToList(); var isIcd9DiagnosisCodesValid = diagnosisValues.All(code => { if (code.Key.ToString().Equals("PrincipalDiagnosis", StringComparison.InvariantCultureIgnoreCase) || code.Key.ToString().Equals("PrimaryDiagnosis", StringComparison.InvariantCultureIgnoreCase)) { if (!SharedRegularExpressions.EVSpecialCodeRegex.IsMatch(code.Value.ToString()) && ICD9DiagnosticCheck(code.Value.ToString())) { return(true); } invalidProperties.Add(code.Key); return(false); } else { if (ICD9DiagnosticCheck(code.Value.ToString())) { return(true); } invalidProperties.Add(code.Key); return(false); } }); var isIcd10DiagnosisCodesValid = !isIcd9DiagnosisCodesValid && diagnosisValues.All(code => { if (ICD10DiagnosticCheck(code.Value.ToString())) { return(true); } // if (SharedRegularExpressions.ICD10Regex.IsMatch(code.Value.ToString())) return true; invalidProperties.Add(code.Key); return(false); }); #if DEBUG timer.Stop(); message = string.Format("IP/ED dataset imports - Time of Execution process all diagnosis codes: {0}:{1}", timer.Elapsed.Seconds, timer.Elapsed.Milliseconds); Trace.WriteLine(message); timer.Reset(); #endif bool isIcd10ProcedureCodeValid = false, isIcd9ProcedureCodeValid = false; if (PerformProcedureCheck) { #if DEBUG timer.Start(); #endif var procedureValues = Properties .Where(propertyInfo => propertyInfo.Name.ContainsIgnoreCase("Procedure") && propertyInfo.GetValue(instance, null) != null) .Select(propertyInfo => new KeyValuePair <string, object>(propertyInfo.Name, propertyInfo.GetValue(instance, null))) .ToList(); isIcd9ProcedureCodeValid = !procedureValues.Any() || procedureValues.All(code => { if (ICD9ProcedureCheck(code.Value.ToString())) { return(true); } // if (SharedRegularExpressions.ICD9ProcedureRegex.IsMatch(code.Value.ToString())) return true; invalidProperties.Add(code.Key); return(false); }); isIcd10ProcedureCodeValid = !procedureValues.Any() || (!isIcd9ProcedureCodeValid && procedureValues.All( code => { if (ICD10ProcedureCheck(code.Value.ToString())) { return(true); } // if (SharedRegularExpressions.ICD10ProcedureRegex.IsMatch(code.Value.ToString())) return true; invalidProperties.Add(code.Key); return(false); })); #if DEBUG timer.Stop(); message = string.Format("IP/ED dataset imports - Time of Execution process all procedure codes: {0}:{1}", timer.Elapsed.Seconds, timer.Elapsed.Milliseconds); Trace.WriteLine(message); timer.Reset(); #endif } if (PerformProcedureCheck) { if (isIcd9DiagnosisCodesValid && isIcd9ProcedureCodeValid) { return(ValidationResult.Success); } if (isIcd10DiagnosisCodesValid && isIcd10ProcedureCodeValid) { return(ValidationResult.Success); } } else { if (isIcd9DiagnosisCodesValid) { return(ValidationResult.Success); } if (isIcd10DiagnosisCodesValid) { return(ValidationResult.Success); } } //string errorMessage = GetFormattedMessage(PerformProcedureCheck, this._neededProperties, validationContext) return(new ValidationResult("Record deleted because it either contains a mix of ICD-9 and ICD-10 coded data or invalid codes.", /*invalidProperties.Any() ? invalidProperties.Distinct().Select(p => p).ToList() :*/ new List <string>())); //ValidationHelper.IcdCheckProperties.Distinct().Select(p => p.Name).ToList() // } // finally // { // } }
public override void Init() { Properties.AddRange(RootNode.Fields.Select(f => new AbstractProperty <EntityNode>(f, RootNode))); }