/// <summary>
/// Process an IFCXML schema file
/// </summary>
/// <param name="ifcxmlSchemaFile">the IfcXML schema file info</param>
public static bool ProcessIFCSchema(FileInfo ifcxmlSchemaFile)
{
if (ifcxmlSchemaFile.Name.Equals(loadedSchema) && IfcSchemaEntityTree.EntityDict.Count > 0)
{
return(false); // The schema file has been processed and loaded before
}
loadedSchema = ifcxmlSchemaFile.Name;
IfcSchemaEntityTree.Initialize(loadedSchema);
XmlTextReader reader = new XmlTextReader(ifcxmlSchemaFile.FullName);
XmlSchema theSchema = XmlSchema.Read(reader, ValidationCallback);
foreach (XmlSchemaObject item in theSchema.Items)
{
if (!(item is XmlSchemaComplexType))
{
continue;
}
XmlSchemaComplexType ct = item as XmlSchemaComplexType;
string entityName = ct.Name;
if (string.Compare(entityName, 0, "Ifc", 0, 3, ignoreCase: true) != 0)
{
continue;
}
string parentName = string.Empty;
if (ct.ContentModel == null)
{
continue;
}
if (ct.ContentModel.Parent == null)
{
continue;
}
if (ct.ContentModel.Parent is XmlSchemaComplexType)
{
XmlSchemaComplexType parent = ct.ContentModel.Parent as XmlSchemaComplexType;
XmlSchemaSimpleContentExtension parentSimpleType = parent.ContentModel.Content as XmlSchemaSimpleContentExtension;
XmlSchemaComplexContentExtension parentComplexType = parent.ContentModel.Content as XmlSchemaComplexContentExtension;
if (parentSimpleType != null)
{
parentName = parentSimpleType.BaseTypeName.Name;
}
if (parentComplexType != null)
{
parentName = parentComplexType.BaseTypeName.Name;
}
}
IfcSchemaEntityTree.Add(entityName, parentName, isAbstract: ct.IsAbstract);
}
return(true);
}
/// <summary>
/// Find a Non ABS supertype entity from the input type name
/// </summary>
/// <param name="context">the IFC schema context</param>
/// <param name="typeName">the type name</param>
/// <returns>the non-abs supertype instance node</returns>
static public IfcSchemaEntityNode FindNonAbsInstanceSuperType(string context, string typeName)
{
IfcSchemaEntityTree ifcEntitySchemaTree = GetEntityDictFor(context);
IfcSchemaEntityNode res = null;
// Note: Implementer's agreement #CV-2x3-166 changes IfcSpaceHeaterType from IfcEnergyConversionDevice to IfcFlowTerminal.
if (context.Equals(Ifc2x3Schema, StringComparison.InvariantCultureIgnoreCase) &&
typeName.Equals("IfcSpaceHeaterType", StringComparison.InvariantCultureIgnoreCase))
{
res = ifcEntitySchemaTree.Find("IfcFlowTerminal");
if (res.isAbstract)
{
return(null);
}
return(res);
}
string theTypeName = typeName.Substring(typeName.Length - 4, 4).Equals("Type", StringComparison.CurrentCultureIgnoreCase) ? typeName : typeName + "Type";
IfcSchemaEntityNode entNode = ifcEntitySchemaTree.Find(theTypeName);
if (entNode != null)
{
while (true)
{
res = entNode.GetParent();
// no more parent node to get
if (res == null)
{
break;
}
entNode = ifcEntitySchemaTree.Find(res.Name.Substring(0, res.Name.Length - 4));
if (entNode != null && !entNode.isAbstract)
{
res = entNode;
break;
}
else
{
entNode = res; // put back the Type Node
}
}
}
return(res);
}
static public IList <IfcSchemaEntityNode> FindAllSuperTypes(string context, string entityName, params string[] stopNode)
{
IfcSchemaEntityTree ifcEntitySchemaTree = GetEntityDictFor(context);
IList <IfcSchemaEntityNode> res = new List <IfcSchemaEntityNode>();
IfcSchemaEntityNode entNode = ifcEntitySchemaTree.Find(entityName);
if (entNode != null)
{
// return the list when it reaches the stop node
foreach (string stopCond in stopNode)
{
if (entNode.Name.Equals(stopCond, StringComparison.InvariantCultureIgnoreCase))
{
return(res);
}
}
bool continueSearch = true;
while (continueSearch)
{
entNode = entNode.GetParent();
// no more parent node to get
if (entNode == null)
{
break;
}
// Stop the search when it reaches the stop node
foreach (string stopCond in stopNode)
{
if (entNode.Name.Equals(stopCond, StringComparison.InvariantCultureIgnoreCase))
{
continueSearch = false;
break;
}
}
if (entNode != null)
{
res.Add(entNode);
}
}
}
return(res);
}
/// <summary>
/// Find a Non-Abstract Super Type in the current IFC Schema
/// </summary>
/// <param name="context">the IFC schema context</param>
/// <param name="typeName">the entity name</param>
/// <param name="stopNode">optional list of entity name(s) to stop the search</param>
/// <returns>the appropriate node or null</returns>
static public IfcSchemaEntityNode FindNonAbsSuperType(string context, string entityName, params string[] stopNode)
{
IfcSchemaEntityTree ifcEntitySchemaTree = GetEntityDictFor(context);
IfcSchemaEntityNode res = null;
IfcSchemaEntityNode entNode = ifcEntitySchemaTree.Find(entityName);
if (entNode != null)
{
foreach (string stopCond in stopNode)
{
if (entNode.Name.Equals(stopCond, StringComparison.InvariantCultureIgnoreCase))
{
return(res);
}
}
while (true)
{
entNode = entNode.GetParent();
// no more parent node to get
if (entNode == null)
{
break;
}
foreach (string stopCond in stopNode)
{
if (entNode.Name.Equals(stopCond, StringComparison.InvariantCultureIgnoreCase))
{
break;
}
}
if (entNode != null && !entNode.isAbstract)
{
res = entNode;
break;
}
}
}
return(res);
}
/// <summary>
/// Get the IFC Entity Dictionary for the given IFC version specified by the schema file name (without extension)
/// </summary>
/// <param name="schemaFile">the IFC schema file name (without extension). Caller must make sure it is the supported schema file</param>
/// <returns>the tree, or null if the schema file is not found</returns>
static public IfcSchemaEntityTree GetEntityDictFor(string schemaFile)
{
if (m_IFCSchemaDict.ContainsKey(schemaFile))
{
return(m_IFCSchemaDict[schemaFile]);
}
// if not found, process the file and add into the static dictionary
IfcSchemaEntityTree entityTree = PopulateEntityDictFor(schemaFile);
if (entityTree == null)
{
return(null);
}
m_IFCSchemaDict.Add(schemaFile, entityTree);
m_IFCEntityPredefTypeDict.Add(schemaFile, entityTree.PredefinedTypeEnumDict);
return(entityTree);
}
/// <summary>
/// Get the PredefinedType list from the given Ifc Entity tree
/// </summary>
/// <param name="context">The IFC version</param>
/// <param name="ifcEntity">the specific Entity to get the PredefinedType list from</param>
/// <returns>List of PredefinedType strings</returns>
static public IList <string> GetPredefinedTypeList(IfcSchemaEntityTree ifcEntitySchemaTree, string ifcEntity)
{
IList <string> predefinedtypeList = new List <string>();
if (ifcEntitySchemaTree == null || ifcEntitySchemaTree.IfcEntityDict == null || ifcEntitySchemaTree.IfcEntityDict.Count == 0)
{
throw new Exception("Unable to locate IFC Schema xsd file! Make sure the relevant xsd exists.");
}
if (string.IsNullOrEmpty(ifcEntity))
{
return(null);
}
// Check for both <name>Enum, and <name>TypeEnum
string entEnum;
string entTypeEnum;
if (ifcEntity.EndsWith("Type", StringComparison.InvariantCultureIgnoreCase))
{
entTypeEnum = ifcEntity + "Enum";
entEnum = ifcEntity.Remove(ifcEntity.Length - 4) + "Enum";
}
else
{
entEnum = ifcEntity + "Enum";
entTypeEnum = ifcEntity + "TypeEnum";
}
if (ifcEntitySchemaTree.PredefinedTypeEnumDict.ContainsKey(entEnum))
{
return(ifcEntitySchemaTree.PredefinedTypeEnumDict[entEnum]);
}
if (ifcEntitySchemaTree.PredefinedTypeEnumDict.ContainsKey(entTypeEnum))
{
return(ifcEntitySchemaTree.PredefinedTypeEnumDict[entTypeEnum]);
}
return(null);
}
/// <summary>
/// Get the PredefinedType list from the processed schema
/// </summary>
/// <param name="context"></param>
/// <param name="ifcEntity"></param>
/// <returns></returns>
static public IList <string> GetPredefinedTypeList(IFCVersion context, string ifcEntity)
{
IfcSchemaEntityTree ifcEntitySchemaTree = GetEntityDictFor(context);
return(GetPredefinedTypeList(ifcEntitySchemaTree, ifcEntity));
}
/// <summary>
/// Process an IFCXML schema file
/// </summary>
/// <param name="ifcxmlSchemaFile">the IfcXML schema file info</param>
public static bool ProcessIFCSchema(FileInfo ifcxmlSchemaFile)
{
if (ifcxmlSchemaFile.Name.Equals(loadedSchema) && IfcSchemaEntityTree.EntityDict.Count > 0)
{
return(false); // The schema file has been processed and loaded before
}
loadedSchema = Path.GetFileNameWithoutExtension(ifcxmlSchemaFile.Name);
IfcSchemaEntityTree.Initialize(loadedSchema);
XmlTextReader reader = new XmlTextReader(ifcxmlSchemaFile.FullName);
XmlSchema theSchema = XmlSchema.Read(reader, ValidationCallback);
foreach (XmlSchemaObject item in theSchema.Items)
{
if (item is XmlSchemaComplexType)
{
XmlSchemaComplexType ct = item as XmlSchemaComplexType;
string entityName = ct.Name;
if (string.Compare(entityName, 0, "Ifc", 0, 3, ignoreCase: true) != 0)
{
continue;
}
string parentName = string.Empty;
if (ct.ContentModel == null)
{
continue;
}
if (ct.ContentModel.Parent == null)
{
continue;
}
string predefTypeEnum = null;
if (ct.ContentModel.Parent is XmlSchemaComplexType)
{
XmlSchemaComplexType parent = ct.ContentModel.Parent as XmlSchemaComplexType;
XmlSchemaSimpleContentExtension parentSimpleType = parent.ContentModel.Content as XmlSchemaSimpleContentExtension;
XmlSchemaComplexContentExtension parentComplexType = parent.ContentModel.Content as XmlSchemaComplexContentExtension;
if (parentSimpleType != null)
{
parentName = parentSimpleType.BaseTypeName.Name;
foreach (XmlSchemaAttribute attr in parentSimpleType.Attributes)
{
if (attr.Name != null && attr.Name.Equals("PredefinedType", StringComparison.InvariantCultureIgnoreCase))
{
predefTypeEnum = attr.SchemaTypeName.Name;
}
}
}
if (parentComplexType != null)
{
parentName = parentComplexType.BaseTypeName.Name;
foreach (XmlSchemaAttribute attr in parentComplexType.Attributes)
{
if (attr.Name != null && attr.Name.Equals("PredefinedType", StringComparison.InvariantCultureIgnoreCase))
{
predefTypeEnum = attr.SchemaTypeName.Name;
break;
}
}
if (string.IsNullOrEmpty(predefTypeEnum) && parentComplexType.Particle != null)
{
XmlSchemaSequence seq = parentComplexType.Particle as XmlSchemaSequence;
if (seq != null)
{
foreach (XmlSchemaElement elem in seq.Items)
{
if (elem.Name != null && elem.Name.Equals("PredefinedType", StringComparison.InvariantCultureIgnoreCase))
{
predefTypeEnum = elem.SchemaTypeName.Name;
break;
}
}
}
}
}
}
IfcSchemaEntityTree.Add(entityName, parentName, predefTypeEnum, isAbstract: ct.IsAbstract);
}
else if (item is XmlSchemaSimpleType)
{
XmlSchemaSimpleType st = item as XmlSchemaSimpleType;
if (st.Name.StartsWith("Ifc", StringComparison.InvariantCultureIgnoreCase) &&
st.Name.EndsWith("Enum", StringComparison.InvariantCultureIgnoreCase))
{
string enumName = st.Name;
XmlSchemaSimpleTypeRestriction enums = st.Content as XmlSchemaSimpleTypeRestriction;
if (enums != null)
{
IList <string> enumValueList = new List <string>();
foreach (XmlSchemaEnumerationFacet enumFacet in enums.Facets)
{
if (IfcSchemaEntityTree.PredefinedTypeEnumDict.ContainsKey(enumName))
{
IfcSchemaEntityTree.PredefinedTypeEnumDict[enumName].Add(enumFacet.Value.ToUpper());
}
else
{
enumValueList.Add(enumFacet.Value.ToUpper());
}
}
if (enumValueList.Count > 0)
{
IfcSchemaEntityTree.PredefinedTypeEnumDict.Add(enumName, enumValueList);
}
}
}
}
}
return(true);
}