private string ConvertToString(IfcProperty ifcProperty) { var ifcPropertySingleValue = ifcProperty as IfcPropertySingleValue; var ifcPropertyEnumeratedValue = ifcProperty as IfcPropertyEnumeratedValue; if (ifcPropertySingleValue != null) { return(ConvertToString(ifcPropertySingleValue)); } if (ifcPropertyEnumeratedValue != null) { if (ifcPropertyEnumeratedValue.EnumerationValues.Count == 1) { return(ifcPropertyEnumeratedValue.EnumerationValues[0].ToString()); } var result = ""; foreach (var enumValue in ifcPropertyEnumeratedValue.EnumerationValues) { result += enumValue + ";"; } return(result.TrimEnd(new[] { ';', ' ' })); } CoBieLiteUkHelper.Logger.WarnFormat("Conversion Error: #{0}={1} [{2}] cannot be converted to s simple value type", ifcProperty.EntityLabel, ifcProperty.Name, ifcProperty.GetType().Name); return(null); }
public override void Parse(int propIndex, IPropertyValue value, int[] nestedIndex) { switch (propIndex) { case 0: case 1: base.Parse(propIndex, value, nestedIndex); return; case 2: _dependingProperty = (IfcProperty)(value.EntityVal); return; case 3: _dependantProperty = (IfcProperty)(value.EntityVal); return; case 4: _expression = value.StringVal; return; default: throw new XbimParserException(string.Format("Attribute index {0} is out of range for {1}", propIndex + 1, GetType().Name.ToUpper())); } }
private static CcManufacturerProductDetail GetDetailsFromProperty(IfcProperty prop) { CcManufacturerProductDetail result = null; if (prop is IfcPropertySingleValue) { IfcPropertySingleValue single = prop as IfcPropertySingleValue; result = new CcManufacturerProductDetail() { AttributeName = single.Name }; result.AttributeValue = GetNominalValue(single.NominalValue); } else if (prop is IfcPropertyEnumeratedValue) { IfcPropertyEnumeratedValue enumval = prop as IfcPropertyEnumeratedValue; result = new CcManufacturerProductDetail() { AttributeName = enumval.Name, AttributeDescription = enumval.Description }; result.AttributeValue = GetEnumeratedValue(enumval.EnumerationValues); } else { throw new NotImplementedException(); } return(result); }
/// <summary> /// Converts the property to a simple type, date, string /// </summary> /// <param name="ifcProperty"></param> /// <returns></returns> static public TValue ConvertToSimpleType <TValue>(IfcProperty ifcProperty) where TValue : struct { var ifcPropertySingleValue = ifcProperty as IfcPropertySingleValue; var ifcPropertyEnumeratedValue = ifcProperty as IfcPropertyEnumeratedValue; var ifcPropertyBoundedValue = ifcProperty as IfcPropertyBoundedValue; var ifcPropertyTableValue = ifcProperty as IfcPropertyTableValue; var ifcPropertyReferenceValue = ifcProperty as IfcPropertyReferenceValue; var ifcPropertyListValue = ifcProperty as IfcPropertyListValue; if (ifcPropertySingleValue != null) { return(ConvertToSimpleType <TValue>(ifcPropertySingleValue)); } if (ifcPropertyEnumeratedValue != null) { if (ifcPropertyEnumeratedValue.EnumerationValues.Count == 1) { return((TValue)Convert.ChangeType(ifcPropertyEnumeratedValue.EnumerationValues[0].ToString(), typeof(TValue))); } var result = ""; foreach (var enumValue in ifcPropertyEnumeratedValue.EnumerationValues) { result += enumValue + ";"; } result = result.TrimEnd(new[] { ';', ' ' }); return((TValue)Convert.ChangeType(result, typeof(TValue))); } if (ifcPropertyBoundedValue != null) { CoBieLiteUkHelper.Logger.WarnFormat("Conversion Error: PropertyBoundedValue #{0}={1} cannot be converted to s simple value type", ifcProperty.EntityLabel, ifcProperty.Name); } else if (ifcPropertyTableValue != null) { CoBieLiteUkHelper.Logger.WarnFormat("Conversion Error: PropertyTableValue #{0}={1} cannot be converted to s simple value type", ifcProperty.EntityLabel, ifcProperty.Name); } else if (ifcPropertyReferenceValue != null) { CoBieLiteUkHelper.Logger.WarnFormat("Conversion Error: PropertyReferenceValue #{0}={1} cannot be converted to s simple value type", ifcProperty.EntityLabel, ifcProperty.Name); } else if (ifcPropertyListValue != null) { CoBieLiteUkHelper.Logger.WarnFormat("Conversion Error: PropertyListValue #{0}={1} cannot be converted to s simple value type", ifcProperty.EntityLabel, ifcProperty.Name); } return(default(TValue)); }
public void InitializeAdditionalProperties() { // default value this.IsLandmarked = false; this.YearOfConstruction = ""; this.NumberOfStoreys = 0; this.OccupancyType = ""; Ifc4.IfcPropertySet ifcPropertySet = this.GetIfcPropertySetFromRelatingPropertyDefinition(); IEnumerable <IfcProperty> ifcPropertyCollection = this.Document.IfcXmlDocument.Items.OfType <IfcProperty>().ToList(); if (ifcPropertySet == null) { ifcPropertySet = new IfcPropertySet(); } if (ifcPropertySet.HasProperties == null) { ifcPropertySet.HasProperties = new IfcPropertySetHasProperties(); } m_IfcPropertySingleValueCollection = new List <IfcPropertySingleValue>(); foreach (IfcProperty ifcPropertyTmp in ifcPropertySet.HasProperties.Items) { if (ifcPropertyTmp.IsRef) { IfcProperty ifcProperty = ifcPropertyCollection.FirstOrDefault(item => item.Id == ifcPropertyTmp.Ref); if (ifcProperty != null && ifcProperty is IfcPropertySingleValue) { m_IfcPropertySingleValueCollection.Add((IfcPropertySingleValue)ifcProperty); } } } IfcPropertySingleValue ifcPropertySingleValue = null; ifcPropertySingleValue = m_IfcPropertySingleValueCollection.FirstOrDefault(item => item.Name.Equals("IsLandmarked", StringComparison.OrdinalIgnoreCase)); if (ifcPropertySingleValue == null) { ifcPropertySingleValue = new Ifc4.IfcPropertySingleValue() { Id = this.Document.GetNextSid(), Name = "IsLandmarked", NominalValue = new Ifc4.IfcPropertySingleValueNominalValue(), }; ifcPropertySingleValue.NominalValue.Item = new Ifc4.IfcLogicalwrapper() { Value = IsLandmarked ? Ifc4.IfcLogical.True : Ifc4.IfcLogical.False }; m_IfcPropertySingleValueCollection.Add(ifcPropertySingleValue); this.Document.IfcXmlDocument.Items.Add(ifcPropertySingleValue); ifcPropertySet.HasProperties.Items.Add(new Ifc4.IfcPropertySingleValue() { Ref = ifcPropertySingleValue.Id }); } else { // read Ifc4.IfcLogicalwrapper ifcLogicalwrapper = ifcPropertySingleValue.NominalValue.Item as Ifc4.IfcLogicalwrapper; if (ifcLogicalwrapper != null) { this.IsLandmarked = ifcLogicalwrapper.Value == IfcLogical.True ? true : false; } } ifcPropertySingleValue = m_IfcPropertySingleValueCollection.FirstOrDefault(item => item.Name.Equals("YearOfConstruction", StringComparison.OrdinalIgnoreCase)); if (ifcPropertySingleValue == null) { ifcPropertySingleValue = new Ifc4.IfcPropertySingleValue() { Id = this.Document.GetNextSid(), Name = "YearOfConstruction", NominalValue = new Ifc4.IfcPropertySingleValueNominalValue(), }; ifcPropertySingleValue.NominalValue.Item = new Ifc4.IfcLabelwrapper() { Value = this.YearOfConstruction }; m_IfcPropertySingleValueCollection.Add(ifcPropertySingleValue); this.Document.IfcXmlDocument.Items.Add(ifcPropertySingleValue); ifcPropertySet.HasProperties.Items.Add(new Ifc4.IfcPropertySingleValue() { Ref = ifcPropertySingleValue.Id }); } else { // read Ifc4.IfcLabelwrapper ifcLabelwrapper = ifcPropertySingleValue.NominalValue.Item as Ifc4.IfcLabelwrapper; if (ifcLabelwrapper != null) { this.YearOfConstruction = ifcLabelwrapper.Value; } } ifcPropertySingleValue = m_IfcPropertySingleValueCollection.FirstOrDefault(item => item.Name.Equals("NumberOfStoreys", StringComparison.OrdinalIgnoreCase)); if (ifcPropertySingleValue == null) { ifcPropertySingleValue = new Ifc4.IfcPropertySingleValue() { Id = this.Document.GetNextSid(), Name = "NumberOfStoreys", NominalValue = new Ifc4.IfcPropertySingleValueNominalValue(), }; ifcPropertySingleValue.NominalValue.Item = new Ifc4.IfcIntegerwrapper() { Value = this.NumberOfStoreys }; m_IfcPropertySingleValueCollection.Add(ifcPropertySingleValue); this.Document.IfcXmlDocument.Items.Add(ifcPropertySingleValue); ifcPropertySet.HasProperties.Items.Add(new Ifc4.IfcPropertySingleValue() { Ref = ifcPropertySingleValue.Id }); } else { // read Ifc4.IfcIntegerwrapper ifcIntegerwrapper = ifcPropertySingleValue.NominalValue.Item as Ifc4.IfcIntegerwrapper; if (ifcIntegerwrapper != null) { this.NumberOfStoreys = ifcIntegerwrapper.Value; } } ifcPropertySingleValue = m_IfcPropertySingleValueCollection.FirstOrDefault(item => item.Name.Equals("OccupancyType", StringComparison.OrdinalIgnoreCase)); if (ifcPropertySingleValue == null) { ifcPropertySingleValue = new Ifc4.IfcPropertySingleValue() { Id = this.Document.GetNextSid(), Name = "OccupancyType", NominalValue = new Ifc4.IfcPropertySingleValueNominalValue(), }; ifcPropertySingleValue.NominalValue.Item = new Ifc4.IfcLabelwrapper() { Value = this.OccupancyType }; m_IfcPropertySingleValueCollection.Add(ifcPropertySingleValue); this.Document.IfcXmlDocument.Items.Add(ifcPropertySingleValue); ifcPropertySet.HasProperties.Items.Add(new Ifc4.IfcPropertySingleValue() { Ref = ifcPropertySingleValue.Id }); } else { // read Ifc4.IfcLabelwrapper ifcLabelwrapper = ifcPropertySingleValue.NominalValue.Item as Ifc4.IfcLabelwrapper; if (ifcLabelwrapper != null) { this.OccupancyType = ifcLabelwrapper.Value; } } if (ifcPropertySet.Id == null) { ifcPropertySet.Id = this.Document.GetNextSid(); ifcPropertySet.Name = "Pset_BuildingCommon"; this.Document.IfcXmlDocument.Items.Add(ifcPropertySet); Ifc4.IfcRelDefinesByProperties ifcRelDefinesByProperties = new Ifc4.IfcRelDefinesByProperties(); ifcRelDefinesByProperties.Id = this.Document.GetNextSid(); //ifcRelDefinesByProperties.RelatedObjects = new Ifc4.IfcBuilding() { Ref = this.Id }; ifcRelDefinesByProperties.RelatedObjects = this.RefInstance(); ifcRelDefinesByProperties.RelatingPropertyDefinition = new Ifc4.IfcRelDefinesByPropertiesRelatingPropertyDefinition(); ifcRelDefinesByProperties.RelatingPropertyDefinition.Item = new Ifc4.IfcPropertySet() { Ref = ifcPropertySet.Id }; this.Document.IfcXmlDocument.Items.Add(ifcRelDefinesByProperties); } // ----------------------------------------- Ifc4.IfcElementQuantity ifcElementQuantity = this.GetIfcElementQuantityFromRelatingPropertyDefinition(); if (ifcElementQuantity != null && ifcElementQuantity.IsRef) { ifcElementQuantity = this.Document.IfcXmlDocument.Items.OfType <IfcElementQuantity>().FirstOrDefault(item => item.Id == ifcElementQuantity.Ref); } IEnumerable <IfcQuantityArea> ifcQuantityAreaCollection = this.Document.IfcXmlDocument.Items.OfType <IfcQuantityArea>(); if (ifcElementQuantity == null) { ifcElementQuantity = new IfcElementQuantity(); } if (ifcElementQuantity.Quantities == null) { ifcElementQuantity.Quantities = new IfcElementQuantityQuantities(); } m_IfcQuantityAreaCollection = new List <IfcQuantityArea>(); foreach (IfcQuantityArea ifcQuantityAreaTmp in ifcElementQuantity.Quantities.Items) { if (ifcQuantityAreaTmp.IsRef) { IfcQuantityArea existingIfcQuantityArea = ifcQuantityAreaCollection.FirstOrDefault(item => item.Id == ifcQuantityAreaTmp.Ref); if (existingIfcQuantityArea != null) { m_IfcQuantityAreaCollection.Add(existingIfcQuantityArea); } } } IfcQuantityArea ifcQuantityArea = null; ifcQuantityArea = m_IfcQuantityAreaCollection.FirstOrDefault(item => item.Name.Equals("GrossFloorArea", StringComparison.OrdinalIgnoreCase)); if (ifcQuantityArea == null) { ifcQuantityArea = new IfcQuantityArea() { Id = this.Document.GetNextSid(), Name = "GrossFloorArea", AreaValue = GrossFloorArea }; m_IfcQuantityAreaCollection.Add(ifcQuantityArea); this.Document.IfcXmlDocument.Items.Add(ifcQuantityArea); ifcElementQuantity.Quantities.Items.Add(new Ifc4.IfcQuantityArea() { Ref = ifcQuantityArea.Id }); } else { // read this.GrossFloorArea = ifcQuantityArea.AreaValue; } ifcQuantityArea = m_IfcQuantityAreaCollection.FirstOrDefault(item => item.Name.Equals("NetFloorArea", StringComparison.OrdinalIgnoreCase)); if (ifcQuantityArea == null) { ifcQuantityArea = new IfcQuantityArea() { Id = this.Document.GetNextSid(), Name = "NetFloorArea", AreaValue = NetFloorArea }; m_IfcQuantityAreaCollection.Add(ifcQuantityArea); this.Document.IfcXmlDocument.Items.Add(ifcQuantityArea); ifcElementQuantity.Quantities.Items.Add(new Ifc4.IfcQuantityArea() { Ref = ifcQuantityArea.Id }); } else { // read this.NetFloorArea = ifcQuantityArea.AreaValue; } if (ifcElementQuantity.Id == null) { ifcElementQuantity.Id = this.Document.GetNextSid(); ifcElementQuantity.Name = "Qto_BuildingBaseQuantities"; this.Document.IfcXmlDocument.Items.Add(ifcElementQuantity); Ifc4.IfcRelDefinesByProperties ifcRelDefinesByProperties = new Ifc4.IfcRelDefinesByProperties(); ifcRelDefinesByProperties.Id = this.Document.GetNextSid(); ifcRelDefinesByProperties.RelatedObjects = this.RefInstance(); ifcRelDefinesByProperties.RelatingPropertyDefinition = new Ifc4.IfcRelDefinesByPropertiesRelatingPropertyDefinition(); // old // ifcRelDefinesByProperties.RelatingPropertyDefinition.Item = new Ifc4.IfcElementQuantity() { Ref = ifcElementQuantity.Id }; // new ifcRelDefinesByProperties.RelatingPropertyDefinition.Item = ((IfcPropertySetDefinition)(new Ifc4.IfcElementQuantity() { Ref = ifcElementQuantity.Id })); this.Document.IfcXmlDocument.Items.Add(ifcRelDefinesByProperties); } }
/// <summary> /// Converts an IfcProperty to a COBie Attribute /// </summary> /// <param name="ifcProperty"></param> /// <returns></returns> static public Attribute ConvertToAttributeType(IfcProperty ifcProperty) { var attributeType = new Attribute { Description = ifcProperty.Description, Name = ifcProperty.Name, Categories = new List <Category> { new Category { Classification = "DPoW Status", Code = "Submitted" }, } //srl we need to define categories, the schema proposes "As Built|Submitted|Approved|Exact Requirement|Maximum Requirement|Minimum Requirement|Requirement", should DPoW set requirements? }; var ifcPropertySingleValue = ifcProperty as IfcPropertySingleValue; var ifcPropertyEnumeratedValue = ifcProperty as IfcPropertyEnumeratedValue; var ifcPropertyBoundedValue = ifcProperty as IfcPropertyBoundedValue; var ifcPropertyTableValue = ifcProperty as IfcPropertyTableValue; var ifcPropertyReferenceValue = ifcProperty as IfcPropertyReferenceValue; var ifcPropertyListValue = ifcProperty as IfcPropertyListValue; if (ifcPropertySingleValue != null) { attributeType.Value = GetAttributeValueType(ifcPropertySingleValue); } else if (ifcPropertyEnumeratedValue != null) { var valueItem = new StringAttributeValue(); attributeType.Value = valueItem; if (ifcPropertyEnumeratedValue.EnumerationReference != null && ifcPropertyEnumeratedValue.EnumerationReference.Unit != null) { valueItem.Unit = ifcPropertyEnumeratedValue.EnumerationReference.Unit.GetName(); } if (ifcPropertyEnumeratedValue.EnumerationValues.Count == 1) { valueItem.Value = ifcPropertyEnumeratedValue.EnumerationValues[0].ToString(); } else { valueItem.Value = ""; foreach (var enumValue in ifcPropertyEnumeratedValue.EnumerationValues) { valueItem.Value += enumValue + ";"; } valueItem.Value = valueItem.Value.TrimEnd(new[] { ';', ' ' }); } //add in the allowed values if (ifcPropertyEnumeratedValue.EnumerationReference != null && ifcPropertyEnumeratedValue.EnumerationReference.EnumerationValues.Count > 0) { var allowedValues = new List <string>(ifcPropertyEnumeratedValue.EnumerationReference.EnumerationValues.Count); foreach (var enumValue in ifcPropertyEnumeratedValue.EnumerationReference.EnumerationValues) { allowedValues.Add(enumValue.ToString()); } } } else if (ifcPropertyBoundedValue != null) { attributeType.Value = GetAttributeValue(ifcPropertyBoundedValue); } else if (ifcPropertyTableValue != null) { //Logger.WarnFormat("Table values are not supported in COBie"); } else if (ifcPropertyReferenceValue != null) { //Logger.WarnFormat("Reference property values are not supported in COBie"); } else if (ifcPropertyListValue != null) { //Logger.WarnFormat("Multiple List values are not supported in COBie"); } return(attributeType); }
/// <summary> /// /// </summary> /// <param name="ifcProperty"></param> /// <typeparam name="TCoBieValueBaseType"></typeparam> /// <returns></returns> public static TCoBieValueBaseType ConvertAttribute <TCoBieValueBaseType>(IfcProperty ifcProperty) where TCoBieValueBaseType : AttributeValue, new() { var ifcPropertySingleValue = ifcProperty as IfcPropertySingleValue; var ifcPropertyEnumeratedValue = ifcProperty as IfcPropertyEnumeratedValue; var ifcPropertyBoundedValue = ifcProperty as IfcPropertyBoundedValue; var ifcPropertyTableValue = ifcProperty as IfcPropertyTableValue; var ifcPropertyReferenceValue = ifcProperty as IfcPropertyReferenceValue; var ifcPropertyListValue = ifcProperty as IfcPropertyListValue; var result = new TCoBieValueBaseType(); if (ifcPropertySingleValue != null) { SetCoBieAttributeValue(result, ifcPropertySingleValue.NominalValue); if (ifcPropertySingleValue.Unit != null) { result.Unit = ifcPropertySingleValue.Unit.GetName(); } } else if (ifcPropertyEnumeratedValue != null) { if (ifcPropertyEnumeratedValue.EnumerationReference != null) { result.Unit = ifcPropertyEnumeratedValue.EnumerationReference.Unit.GetName(); } if (ifcPropertyEnumeratedValue.EnumerationValues.Count == 1) { SetCoBieAttributeValue(result, ifcPropertyEnumeratedValue.EnumerationValues[0]); } else if (result is StringAttributeValue) //if it is a string we can add all the values in a list { var stringValueType = result as StringAttributeValue; foreach (var enumValue in ifcPropertyEnumeratedValue.EnumerationValues) { stringValueType.Value += enumValue + ";"; } stringValueType.Value = stringValueType.Value.TrimEnd(new[] { ';', ' ' }); } else { CoBieLiteUkHelper.Logger.WarnFormat("IfcPropertyEnumeratedValue Conversion: Multiple Enumerated values can only be stored in a string type"); } } else if (ifcPropertyBoundedValue != null) { if (result is StringAttributeValue) //if it is a string we can add the bounded values in a statement { if (ifcPropertyBoundedValue.Unit != null) { result.Unit = ifcPropertyBoundedValue.Unit.GetName(); } var stringValueType = result as StringAttributeValue; stringValueType.Value = ifcPropertyBoundedValue.LowerBoundValue + " to " + ifcPropertyBoundedValue.UpperBoundValue; } else { CoBieLiteUkHelper.Logger.WarnFormat("IfcPropertyBoundedValue Conversion: Bounded values can only be stored in a string type"); } } else if (ifcPropertyTableValue != null) { //Logger.WarnFormat("Table values are not supported in COBie"); } else if (ifcPropertyReferenceValue != null) { //Logger.WarnFormat("Reference property values are not supported in COBie"); } else if (ifcPropertyListValue != null) { if (ifcPropertyListValue.Unit != null) { result.Unit = ifcPropertyListValue.Unit.GetName(); } if (ifcPropertyListValue.ListValues.Count == 1) { SetCoBieAttributeValue(result, ifcPropertyListValue.ListValues[0]); } else if (result is StringAttributeValue) //if it is a string we can add all the values in a list { var stringValueType = result as StringAttributeValue; foreach (var listValue in ifcPropertyListValue.ListValues) { stringValueType.Value += listValue + ";"; } stringValueType.Value = stringValueType.Value.TrimEnd(new[] { ';', ' ' }); } else { CoBieLiteUkHelper.Logger.WarnFormat("IfcPropertyList Conversion: ValueMultiple List values can only be stored in a string type"); } } return(result); }
static public AttributeType ConvertToAttributeType(IfcProperty ifcProperty) { var attributeType = new AttributeType { AttributeDescription = ifcProperty.Description, AttributeName = ifcProperty.Name, AttributeCategory = "Submitted" //srl we need to define categories, the schema proposes "As Built|Submitted|Approved|Exact Requirement|Maximum Requirement|Minimum Requirement|Requirement", should DPoW set requirements? }; var ifcPropertySingleValue = ifcProperty as IfcPropertySingleValue; var ifcPropertyEnumeratedValue = ifcProperty as IfcPropertyEnumeratedValue; var ifcPropertyBoundedValue = ifcProperty as IfcPropertyBoundedValue; var ifcPropertyTableValue = ifcProperty as IfcPropertyTableValue; var ifcPropertyReferenceValue = ifcProperty as IfcPropertyReferenceValue; var ifcPropertyListValue = ifcProperty as IfcPropertyListValue; if (ifcPropertySingleValue != null) { attributeType.AttributeValue = GetAttributeValueType(ifcPropertySingleValue); } else if (ifcPropertyEnumeratedValue != null) { attributeType.AttributeValue = new AttributeValueType(); attributeType.AttributeValue.ItemElementName = ItemChoiceType.AttributeStringValue; var valueItem = new AttributeStringValueType(); attributeType.AttributeValue.Item = valueItem; if (ifcPropertyEnumeratedValue.EnumerationReference != null && ifcPropertyEnumeratedValue.EnumerationReference.Unit != null) { valueItem.UnitName = ifcPropertyEnumeratedValue.EnumerationReference.Unit.GetName(); } if (ifcPropertyEnumeratedValue.EnumerationValues.Count == 1) { valueItem.StringValue = ifcPropertyEnumeratedValue.EnumerationValues[0].ToString(); } else { valueItem.StringValue = ""; foreach (var enumValue in ifcPropertyEnumeratedValue.EnumerationValues) { valueItem.StringValue += enumValue + ";"; } valueItem.StringValue = valueItem.StringValue.TrimEnd(new[] { ';', ' ' }); } //add in the allowed values if (ifcPropertyEnumeratedValue.EnumerationReference != null && ifcPropertyEnumeratedValue.EnumerationReference.EnumerationValues.Count > 0) { var allowedValues = new AllowedValueCollectionType { AttributeAllowedValue = new string[ifcPropertyEnumeratedValue.EnumerationReference.EnumerationValues.Count] }; int i = 0; foreach (var enumValue in ifcPropertyEnumeratedValue.EnumerationReference.EnumerationValues) { allowedValues.AttributeAllowedValue[i] = enumValue.ToString(); i++; } } } else if (ifcPropertyBoundedValue != null) { attributeType.AttributeValue = GetAttributeValue(ifcPropertyBoundedValue); } else if (ifcPropertyTableValue != null) { //Logger.WarnFormat("Table values are not supported in COBie"); } else if (ifcPropertyReferenceValue != null) { //Logger.WarnFormat("Reference property values are not supported in COBie"); } else if (ifcPropertyListValue != null) { //Logger.WarnFormat("Multiple List values are not supported in COBie"); } return(attributeType); }
public virtual void IfcParse(int propIndex, IPropertyValue value) { switch (propIndex) { case 0: _dependingProperty = (IfcProperty) value.EntityVal; break; case 1: _dependantProperty = (IfcProperty) value.EntityVal; break; case 2: _name = value.StringVal; break; case 3: _description = value.StringVal; break; case 4: _expression = value.StringVal; break; default: this.HandleUnexpectedAttribute(propIndex, value); break; } }
private bool InternalRemove() { // throw new NotImplementedException("You must override Remove method."); if (this is Ifc4.Entity) { string sid = ((Ifc4.Entity) this).Id; List <Entity> removeEntities = new List <Entity>(); // ------------------------------------------------------------------------------ foreach (var ifcRelAggregates in this.Document.IfcXmlDocument.Items.OfType <IfcRelAggregates>()) { if (ifcRelAggregates.RelatedObjects != null && ifcRelAggregates.RelatedObjects.Items != null) { ifcRelAggregates.RelatedObjects.Items.RemoveAll(relatedObject => relatedObject.Ref == sid); if (!ifcRelAggregates.RelatedObjects.Items.Any()) // has no items { removeEntities.Add(ifcRelAggregates); } } } // ------------------------------------------------------------------------------ //< IfcRelAssociatesDocument GlobalId="0eDueiBMrB9AOMWod2KzTn"> // <RelatedObjects> // <IfcProject ref="i1" xsi:nil="true" /> // </RelatedObjects> // <RelatingDocument> // <IfcDocumentInformation ref="i3302" xsi:nil="true" /> // </RelatingDocument> //</IfcRelAssociatesDocument> // ------------------------------------------------------------------------------ foreach (var ifcRelAssociatesDocument in this.Document.IfcXmlDocument.Items.OfType <IfcRelAssociatesDocument>()) { if (ifcRelAssociatesDocument.RelatingDocument?.Item?.Ref == sid) { removeEntities.Add(ifcRelAssociatesDocument); } } foreach (var ifcExternalReferenceRelationship in this.Document.IfcXmlDocument.Items.OfType <IfcExternalReferenceRelationship>()) { if ( ifcExternalReferenceRelationship.RelatedResourceObjects?.Items != null && ifcExternalReferenceRelationship.RelatedResourceObjects.Items.Any(item => item.Ref == sid) ) { ifcExternalReferenceRelationship.RelatedResourceObjects.Items.RemoveAll(relatedResourceObject => relatedResourceObject.Ref == sid); if (!ifcExternalReferenceRelationship.RelatedResourceObjects.Items.Any()) // has no items { removeEntities.Add(ifcExternalReferenceRelationship); } } } // ------------------------------------------------------------------------------ if (this.Parent is System.Collections.IList) { var parent = (System.Collections.IList) this.Parent; if (parent != null) { parent.Remove(this); } } // ------------------------------------------------------------------------------ foreach (var ifcRelDefinesByProperties in this.Document.IfcXmlDocument.Items.OfType <IfcRelDefinesByProperties>()) { if (ifcRelDefinesByProperties.RelatedObjects == null || ifcRelDefinesByProperties.RelatedObjects.Ref != sid) { continue; } if (ifcRelDefinesByProperties.RelatingPropertyDefinition == null || ifcRelDefinesByProperties.RelatingPropertyDefinition.Item == null) { continue; } //1. [System.Xml.Serialization.XmlElementAttribute("IfcElementQuantity", typeof(IfcElementQuantity), IsNullable = true)] //2. [System.Xml.Serialization.XmlElementAttribute("IfcPropertySet", typeof(IfcPropertySet), IsNullable=true)] //[System.Xml.Serialization.XmlElementAttribute("IfcPropertySetDefinition", typeof(IfcPropertySetDefinition), IsNullable=true)] //[System.Xml.Serialization.XmlElementAttribute("IfcPropertySetDefinitionSet-wrapper", typeof(IfcPropertySetDefinitionSetwrapper), IsNullable=true)] // -------------------------------------------------------------------------------- // 1. if (ifcRelDefinesByProperties.RelatingPropertyDefinition.Item is IfcElementQuantity) { IfcElementQuantity ifcElementQuantity = (IfcElementQuantity)ifcRelDefinesByProperties.RelatingPropertyDefinition.Item; if (ifcElementQuantity.IsRef) { ifcElementQuantity = this.Document.IfcXmlDocument.Items.OfType <IfcElementQuantity>().FirstOrDefault(item => item.Id == ifcElementQuantity.Ref); } if (ifcElementQuantity.Quantities != null && ifcElementQuantity.Quantities.Items != null) { foreach (var quantityItem in ifcElementQuantity.Quantities.Items) { IfcPhysicalQuantity ifcPhysicalQuantity = quantityItem; if (ifcPhysicalQuantity.IsRef) { ifcPhysicalQuantity = this.Document.IfcXmlDocument.Items.OfType <IfcPhysicalQuantity>().FirstOrDefault(item => item.Id == ifcPhysicalQuantity.Ref); } removeEntities.Add(ifcPhysicalQuantity); } ifcElementQuantity.Quantities.Items.Clear(); removeEntities.Add(ifcElementQuantity); } } // -------------------------------------------------------------------------------- // 2. else if (ifcRelDefinesByProperties.RelatingPropertyDefinition.Item is IfcPropertySet) { IfcPropertySet ifcPropertySet = (IfcPropertySet)ifcRelDefinesByProperties.RelatingPropertyDefinition.Item; if (ifcPropertySet.IsRef) { ifcPropertySet = this.Document.IfcXmlDocument.Items.OfType <IfcPropertySet>().FirstOrDefault(item => item.Id == ifcPropertySet.Ref); } if (ifcPropertySet.HasProperties != null && ifcPropertySet.HasProperties.Items != null) { foreach (var ifcPropertyItem in ifcPropertySet.HasProperties.Items) { IfcProperty ifcProperty = ifcPropertyItem; if (ifcProperty.IsRef) { ifcProperty = this.Document.IfcXmlDocument.Items.OfType <IfcProperty>().FirstOrDefault(item => item.Id == ifcProperty.Ref); } removeEntities.Add(ifcProperty); } ifcPropertySet.HasProperties.Items.Clear(); } // ------------------------------------------------------------------------------ foreach (var ifcRelDefinesByTemplate in this.Document.IfcXmlDocument.Items.OfType <IfcRelDefinesByTemplate>()) { if (ifcRelDefinesByTemplate.RelatedPropertySets != null && ifcRelDefinesByTemplate.RelatedPropertySets.Items != null) { ifcRelDefinesByTemplate.RelatedPropertySets.Items.RemoveAll(relatedPropertySet => relatedPropertySet.Ref == ifcPropertySet.Id); if (!ifcRelDefinesByTemplate.RelatedPropertySets.Items.Any()) // has no items { removeEntities.Add(ifcRelDefinesByTemplate); } } } removeEntities.Add(ifcPropertySet); } else { } removeEntities.Add(ifcRelDefinesByProperties); } // ------------------------------------------------------------------------------ foreach (var ifcRelAssignsToGroup in this.Document.IfcXmlDocument.Items.OfType <IfcRelAssignsToGroup>()) { if (ifcRelAssignsToGroup.RelatedObjects != null && ifcRelAssignsToGroup.RelatedObjects.Items != null) { ifcRelAssignsToGroup.RelatedObjects.Items.RemoveAll(relatedObject => relatedObject.Ref == sid); if (!ifcRelAssignsToGroup.RelatedObjects.Items.Any()) // has no items { removeEntities.Add(ifcRelAssignsToGroup); } } } // ------------------------------------------------------------------------------ foreach (var ifcRelAssociatesClassification in this.Document.IfcXmlDocument.Items.OfType <IfcRelAssociatesClassification>()) { if (ifcRelAssociatesClassification.RelatedObjects != null && ifcRelAssociatesClassification.RelatedObjects.Items != null) { ifcRelAssociatesClassification.RelatedObjects.Items.RemoveAll(relatedObject => relatedObject.Ref == sid); if (!ifcRelAssociatesClassification.RelatedObjects.Items.Any()) // has no items { removeEntities.Add(ifcRelAssociatesClassification); } } } // ------------------------------------------------------------------------------ removeEntities.Add(((Ifc4.Entity) this)); this.Document.IfcXmlDocument.Items.RemoveAll(item => removeEntities.Contains(item)); // ------------------------------------------------------------------------------ } return(true); }
public static int GetPropertyHash(this IfcProperty property) { if (property == null) { return(0); } //check actual value switch (property.GetType().Name) { case "IfcPropertySingleValue": var baseVal = ((IfcPropertySingleValue)(property)).NominalValue; var baseStr = baseVal == null ? "" : baseVal.ToString(); return("IfcPropertySingleValue".GetHashCode() + baseStr.GetHashCode()); case "IfcPropertyEnumeratedValue": var baseEnum = property as IfcPropertyEnumeratedValue; int enumHash = "IfcPropertyEnumeratedValue".GetHashCode(); foreach (var e in baseEnum.EnumerationValues) { enumHash += e.ToString().GetHashCode(); } return(enumHash); case "IfcPropertyBoundedValue": var baseBounded = property as IfcPropertyBoundedValue; return("IfcPropertyBoundedValue".GetHashCode() + baseBounded.UpperBoundValue.ToString().GetHashCode() + baseBounded.LowerBoundValue.ToString().GetHashCode()); case "IfcPropertyTableValue": var baseTable = property as IfcPropertyTableValue; //check all table items int tableHash = "IfcPropertyTableValue".GetHashCode(); for (int i = 0; i < baseTable.DefiningValues.Count; i++) { tableHash += baseTable.DefiningValues[i].ToString().GetHashCode() + baseTable.DefinedValues[i].ToString().GetHashCode(); } return(tableHash); case "IfcPropertyReferenceValue": var baseRef = property as IfcPropertyReferenceValue; var refHash = "IfcPropertyReferenceValue".GetHashCode(); refHash += baseRef.UsageName.ToString().GetHashCode(); refHash += baseRef.PropertyReference.GetType().GetHashCode(); //should go deeper but it would be too complicated for now return(refHash); case "IfcPropertyListValue": var baseList = property as IfcPropertyListValue; var listHash = "IfcPropertyListValue".GetHashCode(); foreach (var item in baseList.ListValues) { listHash += item.ToString().GetHashCode(); } return(listHash); default: break; } throw new NotImplementedException(); }
private bool HasEquivalent(IfcProperty property, IfcPropertySet revisionPset) { //check if property with the same name even exist var candidate = revisionPset.HasProperties.Where(p => p.Name == property.Name).FirstOrDefault(); if (candidate == null) { return(false); } //check actual value switch (property.GetType().Name) { case "IfcPropertySingleValue": var single = candidate as IfcPropertySingleValue; if (single == null) { return(false); } var revVal = single.NominalValue; var baseVal = ((IfcPropertySingleValue)(property)).NominalValue; var revStr = revVal == null ? "" : revVal.ToString(); var baseStr = baseVal == null ? "" : baseVal.ToString(); if (baseStr != revStr) { return(false); } break; case "IfcPropertyEnumeratedValue": var enumerated = candidate as IfcPropertyEnumeratedValue; if (enumerated == null) { return(false); } var baseEnum = property as IfcPropertyEnumeratedValue; if (baseEnum.EnumerationValues.Count != enumerated.EnumerationValues.Count) { return(false); } foreach (var e in baseEnum.EnumerationValues) { if (!enumerated.EnumerationValues.Contains(e)) { return(false); } } break; case "IfcPropertyBoundedValue": var bounded = candidate as IfcPropertyBoundedValue; if (bounded == null) { return(false); } var baseBounded = property as IfcPropertyBoundedValue; if (bounded.LowerBoundValue != baseBounded.LowerBoundValue) { return(false); } if (baseBounded.UpperBoundValue != bounded.UpperBoundValue) { return(false); } break; case "IfcPropertyTableValue": var table = candidate as IfcPropertyTableValue; if (table == null) { return(false); } var baseTable = property as IfcPropertyTableValue; if (baseTable.DefiningValues.Count != table.DefiningValues.Count) { return(false); } //check all table items foreach (var item in baseTable.DefiningValues) { var revDefiningValue = table.DefiningValues.Where(v => v.ToString() == item.ToString()).FirstOrDefault(); if (revDefiningValue == null) { return(false); } var revIndex = table.DefiningValues.IndexOf(revDefiningValue); var baseIndex = baseTable.DefiningValues.IndexOf(item); if (table.DefinedValues[revIndex].ToString() != baseTable.DefinedValues[baseIndex].ToString()) { return(false); } } break; case "IfcPropertyReferenceValue": var reference = candidate as IfcPropertyReferenceValue; if (reference == null) { return(false); } var baseRef = property as IfcPropertyReferenceValue; if (reference.UsageName != baseRef.UsageName) { return(false); } if (reference.PropertyReference.GetType() != baseRef.PropertyReference.GetType()) { return(false); } //should go deeper but it would be too complicated for now break; case "IfcPropertyListValue": var list = candidate as IfcPropertyListValue; if (list == null) { return(false); } var baseList = property as IfcPropertyListValue; if (baseList.ListValues.Count != list.ListValues.Count) { return(false); } foreach (var item in baseList.ListValues) { if (!list.ListValues.Contains(item)) { return(false); } } break; default: break; } return(true); }