private bool IsIfcProperty(string elementName, out int index, out IfcMetaProperty prop) { IfcType ifcType; XmlEntity xmlEntity = _currentNode as XmlEntity; if (xmlEntity != null && !IfcMetaData.TryGetIfcType(elementName.ToUpper(), out ifcType)) { IfcType t = IfcMetaData.IfcType(xmlEntity.Entity); foreach (KeyValuePair <int, IfcMetaProperty> p in t.IfcProperties) { int propIndex = p.Key; if (p.Value.PropertyInfo.Name == elementName) //this is the property to set { prop = p.Value; index = p.Key; return(true); } } } prop = null; index = -1; return(false); }
internal static void AddParent(IfcType child) { Type baseParent = child.Type.BaseType; if (typeof(object) == baseParent || typeof(ValueType) == baseParent) { return; } IfcType ifcParent; if (!TypeToIfcTypeLookup.Contains(baseParent)) { TypeToIfcTypeLookup.Add(ifcParent = new IfcType { Type = baseParent }); string typeLookup = baseParent.Name.ToUpper(); if (!TypeNameToIfcTypeLookup.ContainsKey(typeLookup)) { TypeNameToIfcTypeLookup.Add(typeLookup, ifcParent); } ifcParent.IfcSubTypes.Add(child); child.IfcSuperType = ifcParent; AddParent(ifcParent); AddProperties(ifcParent); } else { ifcParent = TypeToIfcTypeLookup[baseParent]; child.IfcSuperType = ifcParent; if (!ifcParent.IfcSubTypes.Contains(child)) { ifcParent.IfcSubTypes.Add(child); } } }
internal void BeginNestedType(string typeName) { IfcType ifcType = IfcMetaData.IfcType(typeName); _currentInstance = new Part21Entity((IPersistIfc)Activator.CreateInstance(ifcType.Type)); _processStack.Push(_currentInstance); }
public void AddInclude(string ifcEntityName, params int[] propertyIndices) { IfcType ifcType = IfcInstances.IfcTypeLookup[ifcEntityName]; IfcFilter flt = new IfcFilter(ifcType, propertyIndices); Included.Add(flt); }
/// <summary> /// Create a new entity of the specified type, the entity will be blank, all properties with default values /// The entity label will be as specified, an exception will be raised if the label is already in use /// </summary> /// <param name="type">Type of entity to create, this must support IPersistIfcEntity</param> /// <returns>A handle to the entity</returns> internal XbimInstanceHandle AddEntity(Type type, int entityLabel) { IfcType ifcType = IfcMetaData.IfcType(type); XbimInstanceHandle h = new XbimInstanceHandle(this.model, entityLabel, ifcType.TypeId); AddEntity(h.EntityLabel, h.EntityTypeId, null, null, ifcType.IndexedClass); return(h); }
/// <summary> /// Adds an entity, assumes a valid transaction is running /// </summary> /// <param name="toWrite"></param> internal void AddEntity(IPersistIfcEntity toWrite) { MemoryStream ms = new MemoryStream(); BinaryWriter bw = new BinaryWriter(ms); toWrite.WriteEntity(bw); IfcType ifcType = IfcMetaData.IfcType(toWrite); AddEntity(toWrite.EntityLabel, ifcType.TypeId, ifcType.GetIndexedValues(toWrite), ms.ToArray(), ifcType.IndexedClass); }
/// <summary> /// Create a new entity of the specified type, the entity will be blank, all properties with default values /// </summary> /// <param name="type">Type of entity to create, this must support IPersistIfcEntity</param> /// <returns>A handle to the entity</returns> internal XbimInstanceHandle AddEntity(Type type) { //System.Diagnostics.Debug.Assert(typeof(IPersistIfcEntity).IsAssignableFrom(type)); int highest = RetrieveHighestLabel(); IfcType ifcType = IfcMetaData.IfcType(type); XbimInstanceHandle h = new XbimInstanceHandle(this.model, highest + 1, ifcType.TypeId); AddEntity(h.EntityLabel, h.EntityTypeId, null, null, ifcType.IndexedClass); return(h); }
private void AddNonAbstractTypes(IfcType ifcType, List <Type> nonAbstractTypes) { if (!ifcType.Type.IsAbstract) //this is a concrete type so add it { nonAbstractTypes.Add(ifcType.Type); } foreach (IfcType subType in ifcType.IfcSubTypes) { AddNonAbstractTypes(subType, nonAbstractTypes); } }
public void AddExclude(IfcType ifcType) { if (!Excluded.Contains(ifcType)) { IfcFilter flt = new IfcFilter(ifcType); Excluded.Add(flt); } foreach (IfcType subType in ifcType.IfcSubTypes) { AddExclude(subType); } }
private bool IsIfcType(string elementName, out IfcType ifcType) { bool ok = IfcMetaData.TryGetIfcType(elementName.ToUpper(), out ifcType); if (!ok) { if (elementName.Contains("-wrapper") && elementName.StartsWith(_expressNamespace) == false) // we have an inline type definition { string inputName = elementName.Substring(0, elementName.LastIndexOf("-")); ok = IfcMetaData.TryGetIfcType(inputName.ToUpper(), out ifcType); } } return(ok && typeof(ExpressType).IsAssignableFrom(ifcType.Type)); }
private void Write(XbimModel model, int handle, XmlWriter output, int pos = -1) { if (_written.Contains(handle)) //we have already done it { return; } //int nextId = _written.Count + 1; _written.Add(handle); IPersistIfcEntity entity = model.GetInstanceVolatile(handle); //load either the cache or a volatile version of the entity IfcType ifcType = IfcMetaData.IfcType(entity); output.WriteStartElement(ifcType.Type.Name); output.WriteAttributeString("id", string.Format("i{0}", handle)); if (pos > -1) //we are writing out a list element { output.WriteAttributeString("pos", pos.ToString()); } IEnumerable <IfcMetaProperty> toWrite; if (WriteInverses) { List <IfcMetaProperty> l = new List <IfcMetaProperty>(ifcType.IfcProperties.Values); l.AddRange(ifcType.IfcInverses); toWrite = l; } else { toWrite = ifcType.IfcProperties.Values; } foreach (IfcMetaProperty ifcProperty in toWrite) //only write out persistent attributes, ignore inverses { if (ifcProperty.IfcAttribute.State != IfcAttributeState.DerivedOverride) { Type propType = ifcProperty.PropertyInfo.PropertyType; object propVal = ifcProperty.PropertyInfo.GetValue(entity, null); WriteProperty(model, ifcProperty.PropertyInfo.Name, propType, propVal, entity, output, -1, ifcProperty.IfcAttribute); } } output.WriteEndElement(); }
private bool IsConcreteClassOf(string name, IfcType candidate) { IfcType st = candidate; while (st != null) { if (st.Type.Name == name) { return(true); } else { st = st.IfcSuperType; } } return(false); }
/// <summary> /// returns all handles that of of type to include /// </summary> /// <param name="include"></param> /// <returns></returns> public IEnumerable <XbimGeometryHandle> Include(params IfcEntityNameEnum[] include) { HashSet <IfcEntityNameEnum> includeSet = new HashSet <IfcEntityNameEnum>(include); foreach (var inc in include) { IfcType ifcType = IfcMetaData.IfcType((short)inc); foreach (var sub in ifcType.IfcSubTypes) { includeSet.Add(sub.IfcTypeEnum); } } foreach (var h in this) { if (includeSet.Contains((IfcEntityNameEnum)h.IfcTypeId)) { yield return(h); } } }
internal static void AddProperties(IfcType ifcType) { PropertyInfo[] properties = ifcType.Type.GetProperties(BindingFlags.Public | BindingFlags.Instance | BindingFlags.FlattenHierarchy); foreach (PropertyInfo propInfo in properties) { int attributeIdx = -1; IfcAttribute[] ifcAttributes = (IfcAttribute[])propInfo.GetCustomAttributes(typeof(IfcAttribute), false); if (ifcAttributes.GetLength(0) > 0) //we have an ifc property { if (ifcAttributes[0].Order > 0) { // SUPPORT: if the code breaks here there's a problem with the order attribut in a class property ifcType.IfcProperties.Add(ifcAttributes[0].Order, new IfcMetaProperty { PropertyInfo = propInfo, IfcAttribute = ifcAttributes[0] }); attributeIdx = ifcAttributes[0].Order; } else { ifcType.IfcInverses.Add(new IfcMetaProperty { PropertyInfo = propInfo, IfcAttribute = ifcAttributes[0] }); } } IndexedProperty[] ifcIndexes = (IndexedProperty[])propInfo.GetCustomAttributes(typeof(IndexedProperty), false); if (ifcIndexes.GetLength(0) > 0) //we have an index { Debug.Assert(typeof(IPersistIfcEntity).IsAssignableFrom(propInfo.PropertyType) || typeof(IEnumerable <IPersistIfcEntity>).IsAssignableFrom(propInfo.PropertyType)); //only handles to IPersistIfcEntitiess or collecctions of IPersistIfcEntities are indexable ifcType.AddIndexedAttribute(propInfo, attributeIdx); } } }
public static void WriteEntity(this IPersistIfcEntity entity, BinaryWriter entityWriter) { IfcType ifcType = IfcMetaData.IfcType(entity); // entityWriter.Write(Convert.ToByte(P21ParseAction.NewEntity)); entityWriter.Write(Convert.ToByte(P21ParseAction.BeginList)); foreach (IfcMetaProperty ifcProperty in ifcType.IfcProperties.Values) //only write out persistent attributes, ignore inverses { if (ifcProperty.IfcAttribute.State == IfcAttributeState.DerivedOverride) { entityWriter.Write(Convert.ToByte(P21ParseAction.SetOverrideValue)); } else { Type propType = ifcProperty.PropertyInfo.PropertyType; object propVal = ifcProperty.PropertyInfo.GetValue(entity, null); WriteProperty(propType, propVal, entityWriter); } } entityWriter.Write(Convert.ToByte(P21ParseAction.EndList)); entityWriter.Write(Convert.ToByte(P21ParseAction.EndEntity)); }
/// <summary> /// Returns all handles that are not of type to exclude /// </summary> /// <param name="exclude"></param> /// <returns></returns> public IEnumerable <XbimGeometryHandle> Exclude(params IfcEntityNameEnum[] exclude) { HashSet <IfcEntityNameEnum> excludeSet = new HashSet <IfcEntityNameEnum>(exclude); foreach (var ex in exclude) { IfcType ifcType = IfcMetaData.IfcType((short)ex); // bugfix here: loop did not use to include all implementations, but only first level down. foreach (var sub in ifcType.NonAbstractSubTypes) { var ifcSub = IfcMetaData.IfcType(sub); excludeSet.Add(ifcSub.IfcTypeEnum); } } foreach (var h in this) { if (!excludeSet.Contains((IfcEntityNameEnum)h.IfcTypeId)) { yield return(h); } } }
/// <summary> /// Writes the entity to a TextWriter in the Part21 format /// </summary> /// <param name="entityWriter">The TextWriter</param> /// <param name="entity">The entity to write</param> internal static void WriteEntity(this IPersistIfcEntity entity, TextWriter entityWriter, IDictionary <int, int> map = null) { if (map != null && map.Keys.Contains(entity.EntityLabel)) { return; //if the entity is replaced in the map do not write it } entityWriter.Write(string.Format("#{0}={1}(", entity.EntityLabel, entity.GetType().Name.ToUpper())); IfcType ifcType = IfcMetaData.IfcType(entity); bool first = true; foreach (IfcMetaProperty ifcProperty in ifcType.IfcProperties.Values) //only write out persistent attributes, ignore inverses { if (ifcProperty.IfcAttribute.State == IfcAttributeState.DerivedOverride) { if (!first) { entityWriter.Write(','); } entityWriter.Write('*'); first = false; } else { Type propType = ifcProperty.PropertyInfo.PropertyType; object propVal = ifcProperty.PropertyInfo.GetValue(entity, null); if (!first) { entityWriter.Write(','); } WriteProperty(propType, propVal, entityWriter, map); first = false; } } entityWriter.WriteLine(");"); }
public IfcFilter(IfcType type) { _type = type; }
/// <summary> /// Trys to get the specified Ifc Type with the typeName, if the ifcType does not exist false is returned /// </summary> /// <param name="typeName"></param> /// <param name="ifcType"></param> /// <returns></returns> public static bool TryGetIfcType(string typeName, out IfcType ifcType) { return(TypeNameToIfcTypeLookup.TryGetValue(typeName, out ifcType)); }
private void ChildTree(IfcType ot, TextHighliter sb, string indentationHeader, int Indent) { string sSpace = new string(' ', Indent * 2); // sSpace = sSpace.Replace(new string[] { " " }, " "); foreach (var item in ot.IfcSubTypes) { string isAbstract = item.Type.IsAbstract ? " (abstract)" : ""; sb.AppendFormat(indentationHeader + sSpace + "- {0} {1}", item, isAbstract); ChildTree(item, sb, indentationHeader, Indent + 1); } }
public IfcFilter(IfcType type, params int[] propertyIndices) : this(type) { _propertyIndices = propertyIndices; }
private bool IsIfcEntity(string elementName, out IfcType ifcType) { return(IfcMetaData.TryGetIfcType(elementName.ToUpper(), out ifcType)); }
public static IEnumerable <T> Where <T>(this IfcInstances instances, Expression <Func <T, bool> > expr) { Type type = typeof(T); IfcType ifcType = IfcInstances.IfcEntities[type]; foreach (Type itemType in ifcType.NonAbstractSubTypes) { ICollection <long> entities; if (instances.TryGetValue(itemType, out entities)) { bool noIndex = true; XbimIndexedCollection <long> indexColl = entities as XbimIndexedCollection <long>; if (indexColl != null) { //our indexes work from the hash values of that which is indexed, regardless of type object hashRight = null; //indexes only work on equality expressions here if (expr.Body.NodeType == ExpressionType.Equal) { //Equality is a binary expression BinaryExpression binExp = (BinaryExpression)expr.Body; //Get some aliases for either side Expression leftSide = binExp.Left; Expression rightSide = binExp.Right; hashRight = GetRight(leftSide, rightSide); //if we were able to create a hash from the right side (likely) MemberExpression returnedEx = GetIndexablePropertyOnLeft <T>(leftSide); if (returnedEx != null) { //cast to MemberExpression - it allows us to get the property MemberExpression propExp = returnedEx; string property = propExp.Member.Name; if (indexColl.HasIndex(property)) { IEnumerable <long> values = indexColl.GetValues(property, hashRight); if (values != null) { foreach (T item in values.Cast <T>()) { yield return(item); } noIndex = false; } } } } else if (expr.Body.NodeType == ExpressionType.Call) { MethodCallExpression callExp = (MethodCallExpression)expr.Body; if (callExp.Method.Name == "Contains") { Expression keyExpr = callExp.Arguments[0]; if (keyExpr.NodeType == ExpressionType.Constant) { ConstantExpression constExp = (ConstantExpression)keyExpr; object key = constExp.Value; if (callExp.Object.NodeType == ExpressionType.MemberAccess) { MemberExpression memExp = (MemberExpression)callExp.Object; string property = memExp.Member.Name; if (indexColl.HasIndex(property)) { IEnumerable <long> values = indexColl.GetValues(property, key); if (values != null) { foreach (T item in values.Cast <T>()) { yield return(item); } noIndex = false; } } } } } } } if (noIndex) { Func <T, bool> predicate = expr.Compile(); // IEnumerable<T> result = sourceEnum.Where<T>(expr.Compile()); foreach (long handle in entities) { T resultItem = (T)instances.GetOrCreateEntity(handle); if (predicate(resultItem)) { yield return(resultItem); } } } } } }
private void AddEntity(IfcType ifcType, params int[] idx) { int[] includedProperties = idx; if (!Excluded.Contains(ifcType) && !_parseFilter.Contains(ifcType) && !typeof(ExpressType).IsAssignableFrom(ifcType.Type)) { if (!ifcType.Type.IsAbstract) { IfcType superType = ifcType; while (superType != null) { if (Included.Contains(superType)) { IfcFilter flt = Included[superType]; IfcFilter parseFilter = new IfcFilter(ifcType, flt.PropertyIndices); _parseFilter.Add(parseFilter); includedProperties = parseFilter.PropertyIndices; break; } else { superType = superType.IfcSuperType; } } if (superType == null) { _parseFilter.Add(new IfcFilter(ifcType, idx)); } } foreach (Type subType in ifcType.NonAbstractSubTypes) { if (subType != ifcType.Type) { AddEntity(IfcInstances.IfcEntities[subType]); } } foreach (IfcMetaProperty prop in ifcType.IfcProperties.Values) { if (includedProperties == null || includedProperties.Length == 0 || includedProperties.Contains(prop.IfcAttribute.Order - 1)) { Type propType = prop.PropertyInfo.PropertyType; if (typeof(ExpressEnumerable).IsAssignableFrom(propType)) //its a list { Type genType = GetGenericType(propType); if (genType != null && IfcInstances.IfcEntities.Contains(genType)) { AddEntity(IfcInstances.IfcEntities[genType]); } if (genType.IsInterface) { //get the types that are like this foreach (IfcType ent in IfcInstances.IfcEntities) { if (genType.IsAssignableFrom(ent.Type)) { AddEntity(ent); } } } } else if (propType.IsInterface) //its a select type { //get the types that are like this foreach (IfcType ent in IfcInstances.IfcEntities) { if (propType.IsAssignableFrom(ent.Type)) { AddEntity(ent); } } } else if (typeof(IPersistIfc).IsAssignableFrom(propType) && IfcInstances.IfcEntities.Contains(propType)) //its a normal entity { IfcType ifcPropType = IfcInstances.IfcEntities[propType]; AddEntity(ifcPropType); } } } } }
public void AddExclude(string ifcEntityName) { IfcType ifcType = IfcInstances.IfcTypeLookup[ifcEntityName]; AddExclude(ifcType); }
static IfcMetaData() { Module ifcModule = typeof(IfcActor).Module; IEnumerable<Type> typesToProcess = ifcModule.GetTypes().Where( t => typeof(IPersistIfc).IsAssignableFrom(t) && t != typeof(IPersistIfc) && !t.IsEnum && !t.IsAbstract && t.IsPublic && !typeof(ExpressHeaderType).IsAssignableFrom(t)); TypeNameToIfcTypeLookup = new Dictionary<string, IfcType>(typesToProcess.Count()); TypeToIfcTypeLookup = new IfcTypeDictionary(); InterfaceToIfcTypesLookup = new Dictionary<Type, List<IfcType>>(); try { // System.Diagnostics.Debug.Write(typesToProcess.Count()); foreach (Type typeToProcess in typesToProcess) { // Debug.WriteLine(typeToProcess.ToString()); IfcType ifcTypeToProcess; if (TypeToIfcTypeLookup.Contains(typeToProcess)) ifcTypeToProcess = TypeToIfcTypeLookup[typeToProcess]; else { IndexedClass[] ifcTypeIndex = (IndexedClass[])typeToProcess.GetCustomAttributes(typeof(IndexedClass), true); ifcTypeToProcess = new IfcType { Type = typeToProcess, IndexedClass = (ifcTypeIndex.GetLength(0) > 0) }; } string typeLookup = typeToProcess.Name.ToUpperInvariant(); if (!TypeNameToIfcTypeLookup.ContainsKey(typeLookup)) TypeNameToIfcTypeLookup.Add(typeLookup, ifcTypeToProcess); if (!TypeToIfcTypeLookup.Contains(ifcTypeToProcess)) { TypeToIfcTypeLookup.Add(ifcTypeToProcess); AddParent(ifcTypeToProcess); AddProperties(ifcTypeToProcess); } // populate the dictionary lookup by interface // foreach (Type interfaceFound in typeToProcess.GetInterfaces()) { if (!interfaceFound.Namespace.StartsWith("Xbim")) continue; if (interfaceFound.Name == "IfcMaterialSelect") { } if (!InterfaceToIfcTypesLookup.ContainsKey(interfaceFound)) { // add to dictionary InterfaceToIfcTypesLookup.Add(interfaceFound, new List<IfcType>()); } InterfaceToIfcTypesLookup[interfaceFound].Add(ifcTypeToProcess); } } // add the index property to abstract types // foreach (IfcType ifcType in TypeToIfcTypeLookup.Where(t => t.Type.IsAbstract)) { IndexedClass[] ifcTypeIndex = (IndexedClass[])ifcType.Type.GetCustomAttributes(typeof(IndexedClass), true); ifcType.IndexedClass = (ifcTypeIndex.GetLength(0) > 0); } foreach (var entityValue in Enum.GetValues(typeof(IfcEntityNameEnum))) TypeIdToTypeNameLookup.Add((short)entityValue, entityValue.ToString()); //add the Type Ids to each of the IfcTypes foreach (var item in TypeIdToTypeNameLookup) { // in case the code fails here make sure he class where the code breaks is marked public // IfcType ifcType = TypeNameToIfcTypeLookup[item.Value]; TypeIdToIfcTypeLookup.Add(item.Key, ifcType); ifcType.TypeId = item.Key; } } catch (Exception e) { throw new Exception("Error reading Ifc Entity Meta Data", e); } //foreach (var item in TypeNameToIfcTypeLookup) //{ // if (!item.Value.Type.IsAbstract && !item.Value.Type.IsValueType && !typeof(Xbim.Ifc2x3.GeometryResource.IfcRepresentationItem).IsAssignableFrom( item.Value.Type)) // { // if (!item.Value.IndexedClass) Debug.WriteLine(item.Key + " = " + item.Value.IndexedClass); // } //} }
private bool IsIfcType(string elementName, out IfcType ifcType) { bool ok = IfcMetaData.TryGetIfcType(elementName.ToUpper(), out ifcType); if (!ok) { if (elementName.Contains("-wrapper") && elementName.StartsWith(_expressNamespace) == false) // we have an inline type definition { string inputName = elementName.Substring(0, elementName.LastIndexOf("-")); ok = IfcMetaData.TryGetIfcType(inputName.ToUpper(), out ifcType); } } return ok && typeof(ExpressType).IsAssignableFrom(ifcType.Type); }
/// <summary> /// Trys to get the specified Ifc Type with the typeName, if the ifcType does not exist false is returned /// </summary> /// <param name="typeName"></param> /// <param name="ifcType"></param> /// <returns></returns> public static bool TryGetIfcType(string typeName, out IfcType ifcType) { return TypeNameToIfcTypeLookup.TryGetValue(typeName, out ifcType); }
internal static void AddParent(IfcType child) { Type baseParent = child.Type.BaseType; if (typeof(object) == baseParent || typeof(ValueType) == baseParent) return; IfcType ifcParent; if (!TypeToIfcTypeLookup.Contains(baseParent)) { TypeToIfcTypeLookup.Add(ifcParent = new IfcType { Type = baseParent }); string typeLookup = baseParent.Name.ToUpper(); if (!TypeNameToIfcTypeLookup.ContainsKey(typeLookup)) TypeNameToIfcTypeLookup.Add(typeLookup, ifcParent); ifcParent.IfcSubTypes.Add(child); child.IfcSuperType = ifcParent; AddParent(ifcParent); AddProperties(ifcParent); } else { ifcParent = TypeToIfcTypeLookup[baseParent]; child.IfcSuperType = ifcParent; if (!ifcParent.IfcSubTypes.Contains(child)) ifcParent.IfcSubTypes.Add(child); } }
internal static void AddProperties(IfcType ifcType) { PropertyInfo[] properties = ifcType.Type.GetProperties(BindingFlags.Public | BindingFlags.Instance | BindingFlags.FlattenHierarchy); foreach (PropertyInfo propInfo in properties) { int attributeIdx = -1; IfcAttribute[] ifcAttributes = (IfcAttribute[])propInfo.GetCustomAttributes(typeof(IfcAttribute), false); if (ifcAttributes.GetLength(0) > 0) //we have an ifc property { if (ifcAttributes[0].Order > 0) { // SUPPORT: if the code breaks here there's a problem with the order attribut in a class property ifcType.IfcProperties.Add(ifcAttributes[0].Order, new IfcMetaProperty { PropertyInfo = propInfo, IfcAttribute = ifcAttributes[0] }); attributeIdx = ifcAttributes[0].Order; } else ifcType.IfcInverses.Add(new IfcMetaProperty { PropertyInfo = propInfo, IfcAttribute = ifcAttributes[0] }); } IndexedProperty[] ifcIndexes = (IndexedProperty[])propInfo.GetCustomAttributes(typeof(IndexedProperty), false); if (ifcIndexes.GetLength(0) > 0) //we have an index { Debug.Assert(typeof(IPersistIfcEntity).IsAssignableFrom(propInfo.PropertyType) || typeof(IEnumerable<IPersistIfcEntity>).IsAssignableFrom(propInfo.PropertyType)); //only handles to IPersistIfcEntitiess or collecctions of IPersistIfcEntities are indexable ifcType.AddIndexedAttribute(propInfo, attributeIdx); } } }
private bool IsIfcEntity(string elementName, out IfcType ifcType) { return IfcMetaData.TryGetIfcType(elementName.ToUpper(), out ifcType); }
/// <summary> /// Returns true if the named entities attribute is indexed /// </summary> /// <param name="entityTypeName">the name of the Ifc Entity</param> /// <param name="attributeIndex">the index offset of the attribute to check, nb this is a 1 based index</param> /// <returns></returns> public static bool IsIndexedIfcAttribute(string entityTypeName, int attributeIndex) { IfcType ifcType = IfcType(entityTypeName); return(ifcType.IsIndexedIfcAttribute(attributeIndex)); }
static IfcMetaData() { Module ifcModule = typeof(IfcActor).Module; IEnumerable <Type> typesToProcess = ifcModule.GetTypes().Where( t => typeof(IPersistIfc).IsAssignableFrom(t) && t != typeof(IPersistIfc) && !t.IsEnum && !t.IsAbstract && t.IsPublic && !typeof(ExpressHeaderType).IsAssignableFrom(t)); TypeNameToIfcTypeLookup = new Dictionary <string, IfcType>(typesToProcess.Count()); TypeToIfcTypeLookup = new IfcTypeDictionary(); InterfaceToIfcTypesLookup = new Dictionary <Type, List <IfcType> >(); try { // System.Diagnostics.Debug.Write(typesToProcess.Count()); foreach (Type typeToProcess in typesToProcess) { // Debug.WriteLine(typeToProcess.ToString()); IfcType ifcTypeToProcess; if (TypeToIfcTypeLookup.Contains(typeToProcess)) { ifcTypeToProcess = TypeToIfcTypeLookup[typeToProcess]; } else { IndexedClass[] ifcTypeIndex = (IndexedClass[])typeToProcess.GetCustomAttributes(typeof(IndexedClass), true); ifcTypeToProcess = new IfcType { Type = typeToProcess, IndexedClass = (ifcTypeIndex.GetLength(0) > 0) }; } string typeLookup = typeToProcess.Name.ToUpperInvariant(); if (!TypeNameToIfcTypeLookup.ContainsKey(typeLookup)) { TypeNameToIfcTypeLookup.Add(typeLookup, ifcTypeToProcess); } if (!TypeToIfcTypeLookup.Contains(ifcTypeToProcess)) { TypeToIfcTypeLookup.Add(ifcTypeToProcess); AddParent(ifcTypeToProcess); AddProperties(ifcTypeToProcess); } // populate the dictionary lookup by interface // foreach (Type interfaceFound in typeToProcess.GetInterfaces()) { if (!interfaceFound.Namespace.StartsWith("Xbim")) { continue; } if (interfaceFound.Name == "IfcMaterialSelect") { } if (!InterfaceToIfcTypesLookup.ContainsKey(interfaceFound)) { // add to dictionary InterfaceToIfcTypesLookup.Add(interfaceFound, new List <IfcType>()); } InterfaceToIfcTypesLookup[interfaceFound].Add(ifcTypeToProcess); } } // add the index property to abstract types // foreach (IfcType ifcType in TypeToIfcTypeLookup.Where(t => t.Type.IsAbstract)) { IndexedClass[] ifcTypeIndex = (IndexedClass[])ifcType.Type.GetCustomAttributes(typeof(IndexedClass), true); ifcType.IndexedClass = (ifcTypeIndex.GetLength(0) > 0); } foreach (var entityValue in Enum.GetValues(typeof(IfcEntityNameEnum))) { TypeIdToTypeNameLookup.Add((short)entityValue, entityValue.ToString()); } //add the Type Ids to each of the IfcTypes foreach (var item in TypeIdToTypeNameLookup) { // in case the code fails here make sure he class where the code breaks is marked public // IfcType ifcType = TypeNameToIfcTypeLookup[item.Value]; TypeIdToIfcTypeLookup.Add(item.Key, ifcType); ifcType.TypeId = item.Key; } } catch (Exception e) { throw new Exception("Error reading Ifc Entity Meta Data", e); } //foreach (var item in TypeNameToIfcTypeLookup) //{ // if (!item.Value.Type.IsAbstract && !item.Value.Type.IsValueType && !typeof(Xbim.Ifc2x3.GeometryResource.IfcRepresentationItem).IsAssignableFrom( item.Value.Type)) // { // if (!item.Value.IndexedClass) Debug.WriteLine(item.Key + " = " + item.Value.IndexedClass); // } //} }
private void AddNonAbstractTypes(IfcType ifcType, List<Type> nonAbstractTypes) { if (!ifcType.Type.IsAbstract) //this is a concrete type so add it nonAbstractTypes.Add(ifcType.Type); foreach (IfcType subType in ifcType.IfcSubTypes) AddNonAbstractTypes(subType, nonAbstractTypes); }
private bool IsConcreteClassOf(string name, IfcType candidate) { IfcType st = candidate; while (st != null) { if (st.Type.Name == name) return true; else st = st.IfcSuperType; } return false; }
private void AddEntity(IfcType ifcType, params int[] idx) { int[] includedProperties = idx; if (!Excluded.Contains(ifcType) && !_parseFilter.Contains(ifcType) && !typeof (ExpressType).IsAssignableFrom(ifcType.Type)) { if (!ifcType.Type.IsAbstract) { IfcType superType = ifcType; while (superType != null) { if (Included.Contains(superType)) { IfcFilter flt = Included[superType]; IfcFilter parseFilter = new IfcFilter(ifcType, flt.PropertyIndices); _parseFilter.Add(parseFilter); includedProperties = parseFilter.PropertyIndices; break; } else superType = superType.IfcSuperType; } if (superType == null) _parseFilter.Add(new IfcFilter(ifcType, idx)); } foreach (Type subType in ifcType.NonAbstractSubTypes) { if (subType != ifcType.Type) AddEntity(IfcInstances.IfcEntities[subType]); } foreach (IfcMetaProperty prop in ifcType.IfcProperties.Values) { if (includedProperties == null || includedProperties.Length == 0 || includedProperties.Contains(prop.IfcAttribute.Order - 1)) { Type propType = prop.PropertyInfo.PropertyType; if (typeof (ExpressEnumerable).IsAssignableFrom(propType)) //its a list { Type genType = GetGenericType(propType); if (genType != null && IfcInstances.IfcEntities.Contains(genType)) AddEntity(IfcInstances.IfcEntities[genType]); if (genType.IsInterface) { //get the types that are like this foreach (IfcType ent in IfcInstances.IfcEntities) { if (genType.IsAssignableFrom(ent.Type)) AddEntity(ent); } } } else if (propType.IsInterface) //its a select type { //get the types that are like this foreach (IfcType ent in IfcInstances.IfcEntities) { if (propType.IsAssignableFrom(ent.Type)) AddEntity(ent); } } else if (typeof (IPersistIfc).IsAssignableFrom(propType) && IfcInstances.IfcEntities.Contains(propType)) //its a normal entity { IfcType ifcPropType = IfcInstances.IfcEntities[propType]; AddEntity(ifcPropType); } } } } }