private static object Filter(ExpressMetaProperty property, object parentObject) { //leave out geometry and placement of products if (parentObject is Ifc4.Kernel.IfcProduct && (property.PropertyInfo.Name == "Representation" || property.PropertyInfo.Name == "ObjectPlacement")) { return(null); } //leave out representation maps if (parentObject is IfcTypeProduct && property.PropertyInfo.Name == "RepresentationMaps") { return(null); } //leave out eventual connection geometry if (parentObject is IfcRelSpaceBoundary && property.PropertyInfo.Name == "ConnectionGeometry") { return(null); } //return the value for anything else return(property.PropertyInfo.GetValue(parentObject, null)); }
private int getPropertyValue(IPersistEntity entity, HashSet <ExpressType> type) // labvit: sheetcode { //int strLength = "ObjectType".Length; int retVal = 0; ExpressMetaProperty obType = null; if (type == null) { return(0); } if (type != null && !type.Contains(entity.ExpressType)) { return(0); } obType = entity.ExpressType.Properties.ToList()[4].Value; // hard coding, it may be realised function below //foreach (var prop in entity.ExpressType.Properties) // if (string.Compare(prop.Value.Name, "ObjectType", false) == 0) // { // obType = prop.Value; // obType = prop.Value ; var ob = obType.PropertyInfo.GetValue(entity); if (ob != null) { retVal = ob.GetHashCode();// GetType().GetProperty("Value").GetValue(ob).GetHashCode(); } // break; // } return(retVal); }
/// <summary> /// Delegate handling the instance's property transformation. By default all properties (relations and data) are /// forwarded as they are into the transformation queue. /// </summary> /// <param name="property">The meta property descriptor</param> /// <param name="hostObject">The hosting object</param> /// <param name="package">The task's work package</param> /// <param name="cp">Cancelable progress monitor</param> /// <returns></returns> protected virtual object PropertyTransform(ExpressMetaProperty property, object hostObject, T package, CancelableProgressing cp) { if (cp?.State.IsAboutCancelling ?? false) { return(null); } else { return(property?.PropertyInfo.GetValue(hostObject)); } }
private object PropertyTransform(ExpressMetaProperty property, object parentObject) { //only bring over IsDefinedBy and IsTypedBy inverse relationships which will take over all properties and types if (property.EntityAttribute.Order < 0 && CopyPropertySets && !( property.PropertyInfo.Name == nameof(IIfcProduct.IsDefinedBy) || property.PropertyInfo.Name == nameof(IIfcProduct.IsTypedBy) )) { return(null); } return(property.PropertyInfo.GetValue(parentObject, null)); }
private object InsertCopyComponentFilter(ExpressMetaProperty property, object parentObject) { if (!property.IsInverse) { return(property.PropertyInfo.GetValue(parentObject, null)); } if (property.Name == "InSystems") { return(property.PropertyInfo.GetValue(parentObject, null)); } return(null); }
private bool IsIfcProperty(string elementName, out int index, out ExpressMetaProperty prop) { ExpressType expressType; var xmlEntity = _currentNode as XmlEntity; if (xmlEntity != null && !_metadata.TryGetExpressType(elementName.ToUpper(), out expressType)) { var t = _metadata.ExpressType(xmlEntity.Entity); foreach (var p in t.Properties.Where(p => p.Value.PropertyInfo.Name == elementName)) { prop = p.Value; index = p.Key; return(true); } } prop = null; index = -1; return(false); }
private bool getPropertyValue(IPersistEntity entity, HashSet <ExpressType> type, int comparable) // labvit: sheetcode { ExpressMetaProperty obType = null; if (type == null) { return(false); } if (type != null && !type.Contains(entity.ExpressType)) { return(false); } obType = entity.ExpressType.Properties.ToList()[4].Value; var ob = obType.PropertyInfo.GetValue(entity); if (ob != null) { return(comparable == ob.GetHashCode());// GetType().GetProperty("Value").GetValue(ob).GetHashCode(); } return(false); }
private void ReportProp(IPersistEntity entity, ExpressMetaProperty prop, bool verbose) { var propVal = prop.PropertyInfo.GetValue(entity, null); if (propVal == null) { if (!verbose) { return; } propVal = "<null>"; } if (prop.EntityAttribute.IsEnumerable) { var propCollection = propVal as System.Collections.IEnumerable; if (propCollection != null) { var propVals = propCollection.Cast <object>().ToArray(); switch (propVals.Length) { case 0: if (!verbose) { return; } _objectProperties.Add(new PropertyItem { Name = prop.PropertyInfo.Name, Value = "<empty>", PropertySetName = "General" }); break; case 1: var tmpSingle = GetPropItem(propVals[0]); tmpSingle.Name = prop.PropertyInfo.Name + "[0]"; tmpSingle.PropertySetName = "General"; _objectProperties.Add(tmpSingle); break; default: int i = 0; foreach (var item in propVals) { var tmpLoop = GetPropItem(item); tmpLoop.Name = $"{prop.PropertyInfo.Name}[{i++}]"; tmpLoop.PropertySetName = prop.PropertyInfo.Name; _objectProperties.Add(tmpLoop); } break; } } else { if (!verbose) { return; } _objectProperties.Add(new PropertyItem { Name = prop.PropertyInfo.Name, Value = "<not an enumerable>" }); } } else { var tmp = GetPropItem(propVal); tmp.Name = prop.PropertyInfo.Name; tmp.PropertySetName = "General"; _objectProperties.Add(tmp); } }
public XmlMetaProperty(ExpressMetaProperty metaProperty) { MetaProperty = metaProperty; }
private bool IsCollection(ExpressMetaProperty prop) { return(typeof(IExpressEnumerable).IsAssignableFrom(prop.PropertyInfo.PropertyType)); }
private void SetPropertyFromString(ExpressMetaProperty property, IPersistEntity entity, string value, int[] pos, Type valueType = null) { var pIndex = property.EntityAttribute.Order - 1; var type = valueType ?? property.PropertyInfo.PropertyType; type = GetNonNullableType(type); var propVal = new PropertyValue(); if (type.IsValueType || type == typeof(string)) { if (typeof(IExpressComplexType).IsAssignableFrom(type)) { var meta = _metadata.ExpressType(type); var values = value.Split(_separator, StringSplitOptions.RemoveEmptyEntries); var underType = meta.UnderlyingComplexType; foreach (var v in values) { IPropertyValue pv; if (InitPropertyValue(underType, v, out pv)) { entity.Parse(pIndex, pv, pos); } } return; } if (type.IsEnum) { propVal.Init(value, StepParserType.Enum); entity.Parse(pIndex, propVal, pos); return; } //handle other value types if (typeof(IExpressValueType).IsAssignableFrom(type)) { var meta = _metadata.ExpressType(type); type = meta.UnderlyingType; } IPropertyValue pVal; if (InitPropertyValue(type, value, out pVal)) { entity.Parse(pIndex, pVal, pos); } return; } //lists of value types will be serialized as lists. If this is not an IEnumerable this is not the case if (!typeof(IEnumerable).IsAssignableFrom(type) || !type.IsGenericType) { throw new XbimParserException("Unexpected enumerable type " + type.Name); } var genType = type.GetGenericArguments()[0]; if (genType.IsValueType || genType == typeof(string)) { //handle enumerable of value type and string var values = value.Split(_separator, StringSplitOptions.RemoveEmptyEntries); foreach (var v in values) { SetPropertyFromString(property, entity, v, pos, genType); } return; } //rectangular nested lists can also be serialized as attribute if defined in configuration if (typeof(IEnumerable).IsAssignableFrom(genType)) { //handle rectangular nested lists (like IfcPointList3D) var cardinality = property.EntityAttribute.MaxCardinality; if (cardinality != property.EntityAttribute.MinCardinality) { throw new XbimParserException(property.Name + " is not rectangular so it can't be serialized as a simple text string"); } var values = value.Split(_separator, StringSplitOptions.RemoveEmptyEntries); var valType = GetNonGenericType(genType); if (typeof(IExpressValueType).IsAssignableFrom(valType)) { var expValType = _metadata.ExpressType(valType); if (expValType == null) { throw new XbimParserException("Unexpected data type " + valType.Name); } valType = expValType.UnderlyingType; } for (var i = 0; i < values.Length; i++) { IPropertyValue pValue; InitPropertyValue(valType, values[i], out pValue); var idx = i / cardinality; entity.Parse(pIndex, pValue, new [] { idx }); } } }
private void SetPropertyFromElement(ExpressMetaProperty property, IPersistEntity entity, XmlReader input, int[] pos, ExpressType valueType = null) { var name = input.LocalName; var type = valueType != null ? valueType.Type : GetNonNullableType(property.PropertyInfo.PropertyType); var pIndex = property.EntityAttribute.Order - 1; var expType = valueType ?? GetExpresType(input); //select type if (typeof(IExpressSelectType).IsAssignableFrom(type) && type.IsInterface) { //move to inner element which represents the data var sDepth = input.Depth; while (input.Read()) { if (input.NodeType == XmlNodeType.EndElement && input.Depth == sDepth) { return; } if (input.NodeType != XmlNodeType.Element) { continue; } expType = GetExpresType(input); if (expType == null) { throw new XbimParserException("Unexpected select data type " + name); } if (typeof(IExpressValueType).IsAssignableFrom(expType.Type)) { SetPropertyFromElement(property, entity, input, pos, expType); return; } if (typeof(IPersistEntity).IsAssignableFrom(expType.Type)) { SetPropertyFromElement(property, entity, input, pos, expType); return; } //this should either be a defined type or entity throw new XbimParserException("Unexpected select data type " + expType.Name); } return; } //defined type if (typeof(IExpressValueType).IsAssignableFrom(type)) { var cType = expType.UnderlyingComplexType; //if it is just a value we can use 'SetPropertyFromAttribute' if (type == property.PropertyInfo.PropertyType && !(cType != null && typeof(IPersistEntity).IsAssignableFrom(cType))) { var strValue = input.ReadElementContentAsString(); SetPropertyFromString(property, entity, strValue, pos); return; } if (cType != null) { var cInnerValueType = typeof(List <>); cInnerValueType = cInnerValueType.MakeGenericType(cType); var cInnerList = Activator.CreateInstance(cInnerValueType) as IList; if (cInnerList == null) { throw new XbimParserException("Initialization of " + cInnerValueType.Name + " failed."); } if (typeof(IPersistEntity).IsAssignableFrom(cType)) { if (!input.IsEmptyElement) { var cDepth = input.Depth; while (input.Read()) { if (input.NodeType == XmlNodeType.EndElement && input.Depth == cDepth) { break; } if (input.NodeType != XmlNodeType.Element) { continue; } var innerEntity = ReadEntity(input); cInnerList.Add(innerEntity); if (input.NodeType == XmlNodeType.EndElement && input.Depth == cDepth) { break; } } var cValueVal = Activator.CreateInstance(expType.Type, cInnerList); var cpValue = new PropertyValue(); cpValue.Init(cValueVal); entity.Parse(pIndex, cpValue, null); } } else { var cValuesString = input.ReadElementContentAsString(); SetPropertyFromString(property, entity, cValuesString, pos); } return; } //normal defined type has string based constructor which will set the right value var sValue = input.ReadElementContentAsString(); if (property.EnumerableType == expType.Type) { IPropertyValue pValue; InitPropertyValue(expType.UnderlyingType, sValue, out pValue); entity.Parse(pIndex, pValue, pos); return; } else { var pValue = new PropertyValue(); var pValueVal = Activator.CreateInstance(expType.Type, sValue); pValue.Init(pValueVal); entity.Parse(pIndex, pValue, pos); return; } } if (typeof(IPersistEntity).IsAssignableFrom(type) || (typeof(IEnumerable).IsAssignableFrom(type) && property.EntityAttribute.MaxCardinality == 1)) { var value = ReadEntity(input); var pVal = new PropertyValue(); if (property.IsInverse) { pVal.Init(entity); var remotePropName = property.InverseAttributeProperty.RemoteProperty; var remoteProperty = value.ExpressType.Properties.FirstOrDefault(p => p.Value.Name == remotePropName).Value; if (remoteProperty == null) { throw new XbimParserException("Non existing counterpart to " + property.Name); } value.Parse(remoteProperty.EntityAttribute.Order - 1, pVal, null); } else { pVal.Init(value); entity.Parse(pIndex, pVal, null); } return; } //enumeration or inverse enumeration if (typeof(IEnumerable).IsAssignableFrom(type)) { //do nothing with empty list. If it is mandatory it is initialized anyway if (input.IsEmptyElement) { return; } var enumDepth = input.Depth; while (input.Read()) { if (input.NodeType == XmlNodeType.EndElement && input.Depth == enumDepth) { break; } if (input.NodeType != XmlNodeType.Element) { continue; } //position is optional var posAttr = input.GetAttribute("pos"); pos = null; if (!string.IsNullOrWhiteSpace(posAttr)) { var idx = posAttr.Split(_separator, StringSplitOptions.RemoveEmptyEntries) .Select(i => Convert.ToInt32(i)).ToList(); //remove the last one as it is not used in Parse function if (idx.Count > 0) { idx.RemoveAt(idx.Count - 1); } //only set if it has any values in if (idx.Count > 0) { pos = idx.ToArray(); } } //it might be a primitive name = input.LocalName; if (Primitives.ContainsKey(input.LocalName)) { var iVal = input.ReadElementContentAsString(); var pVal = new PropertyValue(); pVal.Init(iVal, Primitives[name]); entity.Parse(pIndex, pVal, pos); if (input.NodeType == XmlNodeType.EndElement && input.Depth == enumDepth) { break; } continue; } var eType = GetExpresType(input); if (eType == null) { throw new XbimParserException("Unexpected type " + name); } SetPropertyFromElement(property, entity, input, pos, eType); if (input.NodeType == XmlNodeType.EndElement && input.Depth == enumDepth) { break; } } return; } throw new XbimParserException("Unexpected type: " + type.Name); }
protected static IEnumerable <ValidationResult> GetSchemaErrors(IPersist instance, ExpressMetaProperty prop, ValidationFlags validateLevel, bool hierarchical) { var attr = prop.EntityAttribute; var propVal = prop.PropertyInfo.GetValue(instance, null); var propName = prop.PropertyInfo.Name; if (propVal is IExpressValueType) { var val = ((IExpressValueType)propVal).Value; var underlyingType = ((IExpressValueType)propVal).UnderlyingSystemType; if (attr.State == EntityAttributeState.Mandatory && val == null && underlyingType != typeof(bool?)) { yield return(new ValidationResult() { Item = instance, IssueType = ValidationFlags.Properties, IssueSource = propName, Message = string.Format("{0}.{1} is not optional.", instance.GetType().Name, propName) }); } if (validateLevel.HasFlag(ValidationFlags.TypeWhereClauses) && propVal is IExpressValidatable) { var hierResult = new ValidationResult() { Item = instance, IssueType = ValidationFlags.None }; foreach (var issue in ((IExpressValidatable)propVal).Validate()) { if (hierarchical) { hierResult.AddDetail(issue); } else { yield return(issue); } } if (hierarchical && hierResult.IssueType != ValidationFlags.None) { // the IssueType is populated if any children have been added. hierResult.Message = string.Format("Property {0} has validation failures.", prop.Name); yield return(hierResult); } } yield break; } if (attr.State == EntityAttributeState.Mandatory && propVal == null) { yield return new ValidationResult() { Item = instance, IssueType = ValidationFlags.Properties, IssueSource = propName, Message = string.Format("{0}.{1} is not optional.", instance.GetType().Name, propName) } } ; if (attr.State == EntityAttributeState.Optional && propVal == null) { //if it is null and optional then it is ok yield break; } if (attr.State == EntityAttributeState.Optional && propVal is IOptionalItemSet && !((IOptionalItemSet)propVal).Initialized) { //if it is non-initialized list and optional then it is ok yield break; } if (attr.IsEnumerable) { if ( (attr.MinCardinality == null || attr.MinCardinality.Length == 0 || attr.MinCardinality.All(c => c < 0)) && (attr.MaxCardinality == null || attr.MaxCardinality.Length == 0 || attr.MaxCardinality.All(c => c < 1))) //we don't care how many so don't check { yield break; } var depth = attr.MinCardinality.Length; if (depth != attr.MaxCardinality.Length) { throw new System.Exception("Inconsistent metadata: minimal and maximal cardinality has to have the same length."); } var sb = new StringBuilder(); var items = (IEnumerable)propVal; CheckCardinality(attr.MinCardinality, attr.MaxCardinality, items, 0, sb); var msg = sb.ToString(); if (string.IsNullOrWhiteSpace(msg)) { yield break; } yield return(new ValidationResult() { Item = instance, IssueType = ValidationFlags.Properties, IssueSource = propName, Message = string.Format("{0}.{1}: {2}", instance.GetType().Name, prop.Name, msg) }); } }
private static object Filter(CopyContext context, ExpressMetaProperty property, object parentObject) { //ignore inverses except for style if (property.IsInverse) { return(property.Name == "StyledByItem" ? property.PropertyInfo.GetValue(parentObject, null) : null); } if (context.PrimaryElements != null && context.PrimaryElements.Any()) { if (typeof(IIfcProduct).IsAssignableFrom(property.PropertyInfo.PropertyType)) { var element = property.PropertyInfo.GetValue(parentObject, null) as IIfcProduct; if (element != null && context.PrimaryElements.Contains(element)) { return(element); } return(null); } if (property.EnumerableType != null && !property.EnumerableType.IsValueType && property.EnumerableType != typeof(string)) { //this can either be a list of IPersistEntity or select type. The very base type is IPersist var entities = property.PropertyInfo.GetValue(parentObject, null) as IEnumerable <IPersist>; if (entities != null) { var persistEntities = entities as IList <IPersist> ?? entities.ToList(); var elementsToRemove = persistEntities.OfType <IIfcProduct>().Where(e => !context.PrimaryElements.Contains(e)).ToList(); //if there are no IfcElements return what is in there with no care if (elementsToRemove.Any()) { //return original values excluding elements not included in the primary set return(persistEntities.Except(elementsToRemove).ToList()); } } } } //if geometry is to be included don't filter it out if (context.IncludeGeometry) { return(property.PropertyInfo.GetValue(parentObject, null)); } //leave out geometry and placement of products if (parentObject is IIfcProduct && (property.PropertyInfo.Name == "Representation" || property.PropertyInfo.Name == "ObjectPlacement") ) { return(null); } //leave out representation maps if (parentObject is IIfcTypeProduct && property.PropertyInfo.Name == "RepresentationMaps") { return(null); } //leave out eventual connection geometry if (parentObject is IIfcRelSpaceBoundary && property.PropertyInfo.Name == "ConnectionGeometry") { return(null); } //return the value for anything else return(property.PropertyInfo.GetValue(parentObject, null)); }
private static object GetFieldValue(IPersistEntity entity, string attributeName, out ExpressMetaProperty prop) { var entType = entity.ExpressType; prop = entType.Properties.FirstOrDefault(x => x.Value.PropertyInfo.Name == attributeName).Value // test direct ?? entType.Inverses.FirstOrDefault(x => x.PropertyInfo.Name == attributeName); // otherwise inverses var propVal = prop?.PropertyInfo.GetValue(entity, null); return(propVal); }