diff --git a/.gitattributes b/.gitattributes
new file mode 100644
index 0000000..1ff0c42
--- /dev/null
+++ b/.gitattributes
@@ -0,0 +1,63 @@
+###############################################################################
+# Set default behavior to automatically normalize line endings.
+###############################################################################
+* text=auto
+
+###############################################################################
+# Set default behavior for command prompt diff.
+#
+# This is need for earlier builds of msysgit that does not have it on by
+# default for csharp files.
+# Note: This is only used by command line
+###############################################################################
+#*.cs diff=csharp
+
+###############################################################################
+# Set the merge driver for project and solution files
+#
+# Merging from the command prompt will add diff markers to the files if there
+# are conflicts (Merging from VS is not affected by the settings below, in VS
+# the diff markers are never inserted). Diff markers may cause the following
+# file extensions to fail to load in VS. An alternative would be to treat
+# these files as binary and thus will always conflict and require user
+# intervention with every merge. To do so, just uncomment the entries below
+###############################################################################
+#*.sln merge=binary
+#*.csproj merge=binary
+#*.vbproj merge=binary
+#*.vcxproj merge=binary
+#*.vcproj merge=binary
+#*.dbproj merge=binary
+#*.fsproj merge=binary
+#*.lsproj merge=binary
+#*.wixproj merge=binary
+#*.modelproj merge=binary
+#*.sqlproj merge=binary
+#*.wwaproj merge=binary
+
+###############################################################################
+# behavior for image files
+#
+# image files are treated as binary by default.
+###############################################################################
+#*.jpg binary
+#*.png binary
+#*.gif binary
+
+###############################################################################
+# diff behavior for common document formats
+#
+# Convert binary document formats to text before diffing them. This feature
+# is only available from the command line. Turn it on by uncommenting the
+# entries below.
+###############################################################################
+#*.doc diff=astextplain
+#*.DOC diff=astextplain
+#*.docx diff=astextplain
+#*.DOCX diff=astextplain
+#*.dot diff=astextplain
+#*.DOT diff=astextplain
+#*.pdf diff=astextplain
+#*.PDF diff=astextplain
+#*.rtf diff=astextplain
+#*.RTF diff=astextplain
diff --git a/.gitignore b/.gitignore
new file mode 100644
index 0000000..d86eb9d
--- /dev/null
+++ b/.gitignore
@@ -0,0 +1,190 @@
+## Ignore Visual Studio temporary files, build results, and
+## files generated by popular Visual Studio add-ons.
+
+# User-specific files
+*.suo
+*.user
+*.userosscache
+*.sln.docstates
+.DS_Store
+
+# Build results
+[Dd]ebug/
+[Dd]ebugPublic/
+[Rr]elease/
+[Rr]eleases/
+x64/
+x86/
+build/
+bld/
+[Bb]in/
+[Oo]bj/
+
+# Roslyn cache directories
+*.ide/
+
+# MSTest test Results
+[Tt]est[Rr]esult*/
+[Bb]uild[Ll]og.*
+
+#NUNIT
+*.VisualState.xml
+TestResult.xml
+
+# Build Results of an ATL Project
+[Dd]ebugPS/
+[Rr]eleasePS/
+dlldata.c
+
+*_i.c
+*_p.c
+*_i.h
+*.ilk
+*.meta
+*.obj
+*.pch
+*.pdb
+*.mdb
+*.pgc
+*.pgd
+*.rsp
+*.sbr
+*.tlb
+*.tli
+*.tlh
+*.tmp
+*.tmp_proj
+*.log
+*.vspscc
+*.vssscc
+.builds
+*.pidb
+*.svclog
+*.scc
+
+# Chutzpah Test files
+_Chutzpah*
+
+# Visual C++ cache files
+ipch/
+*.aps
+*.ncb
+*.opensdf
+*.sdf
+*.cachefile
+
+# Visual Studio profiler
+*.psess
+*.vsp
+*.vspx
+
+# TFS 2012 Local Workspace
+$tf/
+
+# Guidance Automation Toolkit
+*.gpState
+
+# ReSharper is a .NET coding add-in
+_ReSharper*/
+*.[Rr]e[Ss]harper
+*.DotSettings.user
+
+# JustCode is a .NET coding addin-in
+.JustCode
+
+# TeamCity is a build add-in
+_TeamCity*
+
+# DotCover is a Code Coverage Tool
+*.dotCover
+
+# NCrunch
+_NCrunch_*
+.*crunch*.local.xml
+
+# MightyMoose
+*.mm.*
+AutoTest.Net/
+
+# Web workbench (sass)
+.sass-cache/
+
+# Installshield output folder
+[Ee]xpress/
+
+# DocProject is a documentation generator add-in
+DocProject/buildhelp/
+DocProject/Help/*.HxT
+DocProject/Help/*.HxC
+DocProject/Help/*.hhc
+DocProject/Help/*.hhk
+DocProject/Help/*.hhp
+DocProject/Help/Html2
+DocProject/Help/html
+
+# Click-Once directory
+publish/
+
+# Publish Web Output
+*.[Pp]ublish.xml
+*.azurePubxml
+# TODO: Comment the next line if you want to checkin your web deploy settings
+# but database connection strings (with potential passwords) will be unencrypted
+*.pubxml
+*.publishproj
+
+# NuGet Packages
+*.nupkg
+# The packages folder can be ignored because of Package Restore
+**/packages/*
+# except build/, which is used as an MSBuild target.
+!**/packages/build/
+# If using the old MSBuild-Integrated Package Restore, uncomment this:
+#!**/packages/repositories.config
+
+# Windows Azure Build Output
+csx/
+*.build.csdef
+
+# Windows Store app package directory
+AppPackages/
+
+# Others
+sql/
+*.Cache
+ClientBin/
+[Ss]tyle[Cc]op.*
+~$*
+*~
+*.dbmdl
+*.dbproj.schemaview
+*.pfx
+*.publishsettings
+node_modules/
+*.msi
+
+# RIA/Silverlight projects
+Generated_Code/
+
+# Backup & report files from converting an old project file
+# to a newer Visual Studio version. Backup files are not needed,
+# because we have git ;-)
+_UpgradeReport_Files/
+Backup*/
+UpgradeLog*.XML
+UpgradeLog*.htm
+
+# SQL Server files
+*.mdf
+*.ldf
+
+# Business Intelligence projects
+*.rdl.data
+*.bim.layout
+*.bim_*.settings
+
+# Microsoft Fakes
+FakesAssemblies/
+
+# Rhino
+*.rui_bak
diff --git a/DLL Projects/GeometryGymIFC.sln b/DLL Projects/GeometryGymIFC.sln
new file mode 100644
index 0000000..61b8b4e
--- /dev/null
+++ b/DLL Projects/GeometryGymIFC.sln
@@ -0,0 +1,40 @@
+
+Microsoft Visual Studio Solution File, Format Version 12.00
+# Visual Studio 2013
+VisualStudioVersion = 12.0.31101.0
+MinimumVisualStudioVersion = 10.0.40219.1
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "GeometryGymIFC", "GeometryGymIFC\GeometryGymIFC.csproj", "{6CD3BE38-25BC-4FCF-9426-D15ED4D4657C}"
+EndProject
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "GeometryGymIFCRhinoCommonx64", "GeometryGymIFCRhinoCommonx64\GeometryGymIFCRhinoCommonx64.csproj", "{0E350E61-D5D6-4C9D-BDC8-494F3FF6E5C1}"
+EndProject
+Global
+ GlobalSection(SolutionConfigurationPlatforms) = preSolution
+ Debug|Any CPU = Debug|Any CPU
+ Debug|x64 = Debug|x64
+ Debug|x86 = Debug|x86
+ Release|Any CPU = Release|Any CPU
+ Release|x64 = Release|x64
+ Release|x86 = Release|x86
+ EndGlobalSection
+ GlobalSection(ProjectConfigurationPlatforms) = postSolution
+ {6CD3BE38-25BC-4FCF-9426-D15ED4D4657C}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+ {6CD3BE38-25BC-4FCF-9426-D15ED4D4657C}.Debug|Any CPU.Build.0 = Debug|Any CPU
+ {6CD3BE38-25BC-4FCF-9426-D15ED4D4657C}.Debug|x64.ActiveCfg = Debug|Any CPU
+ {6CD3BE38-25BC-4FCF-9426-D15ED4D4657C}.Debug|x86.ActiveCfg = Debug|Any CPU
+ {6CD3BE38-25BC-4FCF-9426-D15ED4D4657C}.Release|Any CPU.ActiveCfg = Release|Any CPU
+ {6CD3BE38-25BC-4FCF-9426-D15ED4D4657C}.Release|Any CPU.Build.0 = Release|Any CPU
+ {6CD3BE38-25BC-4FCF-9426-D15ED4D4657C}.Release|x64.ActiveCfg = Release|Any CPU
+ {6CD3BE38-25BC-4FCF-9426-D15ED4D4657C}.Release|x86.ActiveCfg = Release|Any CPU
+ {0E350E61-D5D6-4C9D-BDC8-494F3FF6E5C1}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+ {0E350E61-D5D6-4C9D-BDC8-494F3FF6E5C1}.Debug|Any CPU.Build.0 = Debug|Any CPU
+ {0E350E61-D5D6-4C9D-BDC8-494F3FF6E5C1}.Debug|x64.ActiveCfg = Debug|Any CPU
+ {0E350E61-D5D6-4C9D-BDC8-494F3FF6E5C1}.Debug|x86.ActiveCfg = Debug|Any CPU
+ {0E350E61-D5D6-4C9D-BDC8-494F3FF6E5C1}.Release|Any CPU.ActiveCfg = Release|Any CPU
+ {0E350E61-D5D6-4C9D-BDC8-494F3FF6E5C1}.Release|Any CPU.Build.0 = Release|Any CPU
+ {0E350E61-D5D6-4C9D-BDC8-494F3FF6E5C1}.Release|x64.ActiveCfg = Release|Any CPU
+ {0E350E61-D5D6-4C9D-BDC8-494F3FF6E5C1}.Release|x86.ActiveCfg = Release|Any CPU
+ EndGlobalSection
+ GlobalSection(SolutionProperties) = preSolution
+ HideSolutionNode = FALSE
+ EndGlobalSection
+EndGlobal
diff --git a/DLL Projects/GeometryGymIFC/GeometryGymIFC.csproj b/DLL Projects/GeometryGymIFC/GeometryGymIFC.csproj
new file mode 100644
index 0000000..f23f9c6
--- /dev/null
+++ b/DLL Projects/GeometryGymIFC/GeometryGymIFC.csproj
@@ -0,0 +1,168 @@
+
+
+
+
+ Debug
+ AnyCPU
+ {6CD3BE38-25BC-4FCF-9426-D15ED4D4657C}
+ Library
+ Properties
+ GGYM.IFC
+ GeometryGymIFC
+ v4.5
+ 512
+
+
+ true
+ full
+ false
+ bin\Debug\
+ DEBUG;TRACE
+ prompt
+ 4
+
+
+ pdbonly
+ true
+ bin\Release\
+ TRACE
+ prompt
+ 4
+
+
+ true
+ bin\x64\Debug\
+ DEBUG;TRACE
+ full
+ x64
+ prompt
+ MinimumRecommendedRules.ruleset
+
+
+ bin\x64\Release\
+ TRACE;IFCMODEL IFCPARSE IFCEXPORTONLY GGDLL RHCOMM NOLISTS NOTREEVIEW NOFORMS
+ true
+ pdbonly
+ x64
+ prompt
+ MinimumRecommendedRules.ruleset
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ IFC\BaseClassIFC.cs
+
+
+ IFC\DatabaseIFC.cs
+
+
+ IFC\Enumerations.cs
+
+
+ IFC\IFC A.cs
+
+
+ IFC\IFC B.cs
+
+
+ IFC\IFC C.cs
+
+
+ IFC\IFC D.cs
+
+
+ IFC\IFC E.cs
+
+
+ IFC\IFC F.cs
+
+
+ IFC\IFC G.cs
+
+
+ IFC\IFC H.cs
+
+
+ IFC\IFC I.cs
+
+
+ IFC\IFC J.cs
+
+
+ IFC\IFC L.cs
+
+
+ IFC\IFC M.cs
+
+
+ IFC\IFC N.cs
+
+
+ IFC\IFC O.cs
+
+
+ IFC\IFC P.cs
+
+
+ IFC\IFC Q.cs
+
+
+ IFC\IFC R.cs
+
+
+ IFC\IFC S.cs
+
+
+ IFC\IFC T.cs
+
+
+ IFC\IFC U.cs
+
+
+ IFC\IFC V.cs
+
+
+ IFC\IFC W.cs
+
+
+ IFC\IFC Z.cs
+
+
+ IFC\ParserIFC.cs
+
+
+ STEP\BaseClassSTEP.cs
+
+
+ STEP\ParserSTEP.cs
+
+
+
+
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/DLL Projects/GeometryGymIFC/Properties/AssemblyInfo.cs b/DLL Projects/GeometryGymIFC/Properties/AssemblyInfo.cs
new file mode 100644
index 0000000..3a2cbfd
--- /dev/null
+++ b/DLL Projects/GeometryGymIFC/Properties/AssemblyInfo.cs
@@ -0,0 +1,54 @@
+// MIT License
+// Copyright (c) 2016 Geometry Gym Pty Ltd
+
+// Permission is hereby granted, free of charge, to any person obtaining a copy of this software
+// and associated documentation files (the "Software"), to deal in the Software without restriction,
+// including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense,
+// and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so,
+// subject to the following conditions:
+
+// The above copyright notice and this permission notice shall be included in all copies or substantial
+// portions of the Software.
+
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT
+// LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+// IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+// WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+// SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+using System.Reflection;
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+
+// General Information about an assembly is controlled through the following
+// set of attributes. Change these attribute values to modify the information
+// associated with an assembly.
+[assembly: AssemblyTitle("GeometryGymIFC")]
+[assembly: AssemblyDescription("")]
+[assembly: AssemblyConfiguration("")]
+[assembly: AssemblyCompany("Geometry Gym Pty Ltd")]
+[assembly: AssemblyProduct("GeometryGymIFC")]
+[assembly: AssemblyCopyright("Copyright © Geometry Gym Pty Ltd 2016")]
+[assembly: AssemblyTrademark("")]
+[assembly: AssemblyCulture("")]
+
+// Setting ComVisible to false makes the types in this assembly not visible
+// to COM components. If you need to access a type in this assembly from
+// COM, set the ComVisible attribute to true on that type.
+[assembly: ComVisible(false)]
+
+// The following GUID is for the ID of the typelib if this project is exposed to COM
+[assembly: Guid("c26aa7cc-baf1-4551-b91b-76e56ca15567")]
+
+// Version information for an assembly consists of the following four values:
+//
+// Major Version
+// Minor Version
+// Build Number
+// Revision
+//
+// You can specify all the values or you can default the Build and Revision Numbers
+// by using the '*' as shown below:
+// [assembly: AssemblyVersion("1.0.*")]
+[assembly: AssemblyVersion("0.0.1.0")]
+[assembly: AssemblyFileVersion("0.0.1.0")]
diff --git a/DLL Projects/GeometryGymIFCRhinoCommonx64/GeometryGymIFCRhinoCommonx64.csproj b/DLL Projects/GeometryGymIFCRhinoCommonx64/GeometryGymIFCRhinoCommonx64.csproj
new file mode 100644
index 0000000..61e4a11
--- /dev/null
+++ b/DLL Projects/GeometryGymIFCRhinoCommonx64/GeometryGymIFCRhinoCommonx64.csproj
@@ -0,0 +1,206 @@
+
+
+
+
+ Debug
+ AnyCPU
+ {0E350E61-D5D6-4C9D-BDC8-494F3FF6E5C1}
+ Library
+ Properties
+ GGYM.IFC
+ GeometryGymIFCRhinoCommonx64
+ v4.5
+ 512
+
+
+ true
+ full
+ false
+ bin\Debug\
+ DEBUG;TRACE
+ prompt
+ 4
+
+
+ pdbonly
+ true
+ bin\Release\x64\
+ TRACE
+ prompt
+ 4
+
+
+
+ ..\packages\Rhino3dmIO.dll-AnyCPU-Windows.5.1.30000.25\lib\net40\Rhino3dmIO.dll
+ True
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ IFC\Core\BaseClassIFC.cs
+
+
+ IFC\Core\DatabaseIFC.cs
+
+
+ IFC\Core\Enumerations.cs
+
+
+ IFC\Core\ifc A.cs
+
+
+ IFC\Core\IFC B.cs
+
+
+ IFC\Core\IFC C.cs
+
+
+ IFC\Core\IFC D.cs
+
+
+ IFC\Core\IFC E.cs
+
+
+ IFC\Core\IFC F.cs
+
+
+ IFC\Core\IFC G.cs
+
+
+ IFC\Core\IFC H.cs
+
+
+ IFC\Core\IFC I.cs
+
+
+ IFC\Core\IFC J.cs
+
+
+ IFC\Core\IFC L.cs
+
+
+ IFC\Core\IFC M.cs
+
+
+ IFC\Core\IFC N.cs
+
+
+ IFC\Core\IFC O.cs
+
+
+ IFC\Core\IFC P.cs
+
+
+ IFC\Core\IFC Q.cs
+
+
+ IFC\Core\IFC R.cs
+
+
+ IFC\Core\IFC S.cs
+
+
+ IFC\Core\IFC T.cs
+
+
+ IFC\Core\IFC U.cs
+
+
+ IFC\Core\IFC V.cs
+
+
+ IFC\Core\IFC W.cs
+
+
+ IFC\Core\IFC Z.cs
+
+
+ IFC\Core\ParserIFC.cs
+
+
+ IFC\RhinoCommon\IFC A RhinoCommon.cs
+
+
+ IFC\RhinoCommon\IFC B RhinoCommon.cs
+
+
+ IFC\RhinoCommon\IFC C RhinoCommon.cs
+
+
+ IFC\RhinoCommon\IFC D RhinoCommon.cs
+
+
+ IFC\RhinoCommon\IFC E RhinoCommon.cs
+
+
+ IFC\RhinoCommon\IFC F RhinoCommon.cs
+
+
+ IFC\RhinoCommon\IFC G RhinoCommon.cs
+
+
+ IFC\RhinoCommon\IFC H RhinoCommon.cs
+
+
+ IFC\RhinoCommon\IFC I RhinoCommon.cs
+
+
+ IFC\RhinoCommon\IFC L RhinoCommon.cs
+
+
+ IFC\RhinoCommon\IFC M RhinoCommon.cs
+
+
+ IFC\RhinoCommon\IFC O RhinoCommon.cs
+
+
+ IFC\RhinoCommon\IFC P RhinoCommon.cs
+
+
+ IFC\RhinoCommon\IFC R RhinoCommon.cs
+
+
+ IFC\RhinoCommon\IFC S RhinoCommon.cs
+
+
+ IFC\RhinoCommon\IFC T RhinoCommon.cs
+
+
+ IFC\RhinoCommon\IFC V RhinoCommon.cs
+
+
+ STEP\BaseClassSTEP.cs
+
+
+ STEP\ParserSTEP.cs
+
+
+
+
+
+
+
+
+
+xcopy /s /y "$(SolutionDir)packages\Rhino3dmIO.dll-AnyCPU-Windows.5.1.30000.25\NativeBinaries\x86\*.*" "$(TargetDir)x86\"
+xcopy /s /y "$(SolutionDir)packages\Rhino3dmIO.dll-AnyCPU-Windows.5.1.30000.25\NativeBinaries\x64\*.*" "$(TargetDir)x64\"
+
+
+
+
\ No newline at end of file
diff --git a/DLL Projects/GeometryGymIFCRhinoCommonx64/Properties/AssemblyInfo.cs b/DLL Projects/GeometryGymIFCRhinoCommonx64/Properties/AssemblyInfo.cs
new file mode 100644
index 0000000..1883eba
--- /dev/null
+++ b/DLL Projects/GeometryGymIFCRhinoCommonx64/Properties/AssemblyInfo.cs
@@ -0,0 +1,54 @@
+// MIT License
+// Copyright (c) 2016 Geometry Gym Pty Ltd
+
+// Permission is hereby granted, free of charge, to any person obtaining a copy of this software
+// and associated documentation files (the "Software"), to deal in the Software without restriction,
+// including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense,
+// and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so,
+// subject to the following conditions:
+
+// The above copyright notice and this permission notice shall be included in all copies or substantial
+// portions of the Software.
+
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT
+// LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+// IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+// WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+// SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+using System.Reflection;
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+
+// General Information about an assembly is controlled through the following
+// set of attributes. Change these attribute values to modify the information
+// associated with an assembly.
+[assembly: AssemblyTitle("GeometryGymIFCRhinoCommonx64")]
+[assembly: AssemblyDescription("")]
+[assembly: AssemblyConfiguration("")]
+[assembly: AssemblyCompany("Geometry Gym Pty Ltd")]
+[assembly: AssemblyProduct("GeometryGymIFCRhinoCommonx64")]
+[assembly: AssemblyCopyright("Copyright © Geometry Gym Pty Ltd 2016")]
+[assembly: AssemblyTrademark("")]
+[assembly: AssemblyCulture("")]
+
+// Setting ComVisible to false makes the types in this assembly not visible
+// to COM components. If you need to access a type in this assembly from
+// COM, set the ComVisible attribute to true on that type.
+[assembly: ComVisible(false)]
+
+// The following GUID is for the ID of the typelib if this project is exposed to COM
+[assembly: Guid("c26aa7cc-baf1-4551-b91b-76e56ca15567")]
+
+// Version information for an assembly consists of the following four values:
+//
+// Major Version
+// Minor Version
+// Build Number
+// Revision
+//
+// You can specify all the values or you can default the Build and Revision Numbers
+// by using the '*' as shown below:
+// [assembly: AssemblyVersion("1.0.*")]
+[assembly: AssemblyVersion("0.0.1.0")]
+[assembly: AssemblyFileVersion("0.0.1.0")]
diff --git a/DLL Projects/GeometryGymIFCRhinoCommonx64/packages.config b/DLL Projects/GeometryGymIFCRhinoCommonx64/packages.config
new file mode 100644
index 0000000..344963b
--- /dev/null
+++ b/DLL Projects/GeometryGymIFCRhinoCommonx64/packages.config
@@ -0,0 +1,4 @@
+
+
+
+
\ No newline at end of file
diff --git a/IFC/BaseClassIFC.cs b/IFC/BaseClassIFC.cs
new file mode 100644
index 0000000..35bf0be
--- /dev/null
+++ b/IFC/BaseClassIFC.cs
@@ -0,0 +1,77 @@
+// MIT License
+// Copyright (c) 2016 Geometry Gym Pty Ltd
+
+// Permission is hereby granted, free of charge, to any person obtaining a copy of this software
+// and associated documentation files (the "Software"), to deal in the Software without restriction,
+// including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense,
+// and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so,
+// subject to the following conditions:
+
+// The above copyright notice and this permission notice shall be included in all copies or substantial
+// portions of the Software.
+
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT
+// LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+// IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+// WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+// SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+using System;
+using System.Collections.Generic;
+using System.Collections;
+using System.Text;
+using System.Reflection;
+using System.IO;
+using System.ComponentModel;
+
+using GeometryGym.STEP;
+
+namespace GeometryGym.Ifc
+{
+ public partial class BaseClassIfc : STEPEntity, IfcInterface
+ {
+ internal string mIFCString = "";
+ public virtual string Name { get { return ""; } set { } }
+ internal DatabaseIfc mDatabase = null;
+
+ DatabaseIfc IfcInterface.Database { get { return mDatabase; } }
+
+ internal BaseClassIfc() : base() { }
+ protected BaseClassIfc(BaseClassIfc e) { mIndex = e.mIndex; mDatabase = e.mDatabase; mDatabase.mIfcObjects[e.mIndex] = this; }
+ internal BaseClassIfc(int record, string kw, string line) { mIndex = record; mIFCString = line; }
+ protected BaseClassIfc(DatabaseIfc m) { attachModel(m); }
+
+
+ private void attachModel(DatabaseIfc m)
+ {
+
+ bool added = false;
+ for (int icounter = m.mNextBlank; icounter < m.mIfcObjects.Count; icounter++)
+ {
+ if (m.mIfcObjects[icounter] == null)
+ {
+ added = true;
+ mIndex = icounter;
+ m.mNextBlank = icounter + 1;
+ m.mIfcObjects[icounter] = this;
+ break;
+ }
+ }
+ if (!added)
+ {
+ if (m.mNextBlank > m.mIfcObjects.Count)
+ {
+ int count = m.mNextBlank - m.mIfcObjects.Count;
+ for (int pcounter = 0; pcounter < count; pcounter++)
+ m.mIfcObjects.Add(null);
+ }
+ mIndex = m.mIfcObjects.Count;
+ m.mIfcObjects.Add(this);
+ m.mNextBlank = mIndex + 1;
+ }
+ mDatabase = m;
+ }
+ }
+ public interface IfcInterface { int Index { get; } string Name { get; set; } DatabaseIfc Database { get; } }
+
+}
diff --git a/IFC/DatabaseIFC.cs b/IFC/DatabaseIFC.cs
new file mode 100644
index 0000000..102462a
--- /dev/null
+++ b/IFC/DatabaseIFC.cs
@@ -0,0 +1,979 @@
+// MIT License
+// Copyright (c) 2016 Geometry Gym Pty Ltd
+
+// Permission is hereby granted, free of charge, to any person obtaining a copy of this software
+// and associated documentation files (the "Software"), to deal in the Software without restriction,
+// including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense,
+// and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so,
+// subject to the following conditions:
+
+// The above copyright notice and this permission notice shall be included in all copies or substantial
+// portions of the Software.
+
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT
+// LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+// IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+// WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+// SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+using System;
+using System.Collections.Generic;
+using System.Text;
+using System.Reflection;
+using System.IO;
+using System.ComponentModel;
+using System.Linq;
+using System.Drawing;
+using System.Globalization;
+using System.Threading;
+using GeometryGym.STEP;
+
+namespace GeometryGym.Ifc
+{
+ public enum Schema { IFC2x3, IFC4, IFC4A1 };
+ public enum ModelView { Ifc4Reference, Ifc4DesignTransfer, Ifc4NotAssigned,Ifc2x3Coordination, If2x3NotAssigned };
+ public partial class DatabaseIfc
+ {
+
+ internal partial class Aggregate
+ {
+ //internal List mProfiles = new List();
+ //internal List mWorkPlans = new List();
+ //internal List mRepMaps = new List();
+ //internal List mApplications = new List();
+ internal List mBuildingStories = new List();
+ internal List mComplexProperties = new List();
+ internal List mCoordinateOperations = new List();
+ internal List mEdgeCurves = new List();
+ internal List mExternalRelationships = new List();
+ //internal List mExtrusions = new List();
+ internal List mGeomContexts = new List();
+ internal List mGrids = new List();
+ internal List mGroups = new List();
+ internal List mIndexedColourMap = new List();
+ internal List mIndexedTextureMap = new List();
+ internal List mLocalPlacements = new List();
+ internal List mMappedItems = new List();
+ internal List mMaterials = new List();
+ internal List mMaterialProperties = new List();
+ internal List mMaterialPropertiesSS = new List();
+ //internal List mFasteners = new List();
+ internal List mOwnHistories = new List();
+ internal List mPresentationLayerAssignments = new List();
+ internal List mProducts = new List();
+ internal List mProductReps = new List();
+ internal List mPropertySets = new List();
+ internal List mRelationships = new List();
+ internal List mRepresentations = new List();
+ internal List mConstraintRelationships = new List();
+ internal List mShapeAspects = new List();
+ internal List mSlabs = new List();
+ internal List mStructItems = new List();
+ internal List mStyledItems = new List();
+ internal List mTypeProducts = new List();
+ internal List mWalls = new List();
+ internal List mZones = new List();
+
+ internal Aggregate() { }
+ partial void setCustomAggregate(BaseClassIfc obj);
+ internal void setAggregate(BaseClassIfc obj)
+ {
+ IfcProduct product = obj as IfcProduct;
+ if (product != null)
+ {
+ mProducts.Add(product);
+ IfcBuildingStorey buildingStorey = obj as IfcBuildingStorey;
+ if (buildingStorey != null)
+ mBuildingStories.Add(buildingStorey);
+ IfcGrid grid = obj as IfcGrid;
+ if (grid != null)
+ mGrids.Add(grid);
+ IfcSlab slab = product as IfcSlab;
+ if (slab != null)
+ mSlabs.Add(slab);
+ IfcStructuralItem structuralItem = obj as IfcStructuralItem;
+ if (structuralItem != null)
+ mStructItems.Add(structuralItem);
+ IfcWall wall = product as IfcWall;
+ if (wall != null)
+ mWalls.Add(wall);
+ return;
+ }
+ //IfcApplication application = obj as IfcApplication;
+ //if (application != null)
+ // mApplications.Add(application);
+ IfcComplexProperty cp = obj as IfcComplexProperty;
+ if(cp != null)
+ {
+ mComplexProperties.Add(cp);
+ return;
+ }
+ IfcCoordinateOperation coordOp = obj as IfcCoordinateOperation;
+ if (coordOp != null)
+ {
+ mCoordinateOperations.Add(coordOp);
+ return;
+ }
+
+ IfcEdgeCurve edgeCurve = obj as IfcEdgeCurve;
+ if (edgeCurve != null)
+ {
+ mEdgeCurves.Add(edgeCurve);
+ return;
+ }
+ IfcExternalReferenceRelationship externalReferenceRelationship = obj as IfcExternalReferenceRelationship;
+ if (externalReferenceRelationship != null)
+ {
+ mExternalRelationships.Add(externalReferenceRelationship);
+ return;
+ }
+ //IfcExtrudedAreaSolid extrudedAreaSolid = result as IfcExtrudedAreaSolid;
+ //if(extrudedAreaSolid != null)
+ //{
+ // if(result as IfcExtrudedAreaSolidTapered == null)
+ // aggregate.mExtrusions.Add(extrudedAreaSolid);
+ // return extrudedAreaSolid;
+ //}
+ IfcGeometricRepresentationSubContext geometricRepresentationContext = obj as IfcGeometricRepresentationSubContext;
+ if (geometricRepresentationContext != null)
+ {
+ mGeomContexts.Add(geometricRepresentationContext);
+ return ;
+ }
+
+
+ IfcGroup group = obj as IfcGroup;
+ if (group != null)
+ {
+ IfcZone zone = group as IfcZone;
+ if (zone != null)
+ {
+ mZones.Add(zone);
+ return;
+ }
+ mGroups.Add(group);
+ return;
+ }
+ IfcIndexedColourMap indexedColourMap = obj as IfcIndexedColourMap;
+ if (indexedColourMap != null)
+ {
+ mIndexedColourMap.Add(indexedColourMap);
+ return;
+ }
+ IfcIndexedTextureMap indexedTextureMap = obj as IfcIndexedTextureMap;
+ if (indexedTextureMap != null)
+ {
+ mIndexedTextureMap.Add(indexedTextureMap);
+ return;
+ }
+ IfcLocalPlacement localPlacement = obj as IfcLocalPlacement;
+ if (localPlacement != null)
+ {
+ mLocalPlacements.Add(localPlacement);
+ return;
+ }
+ IfcMappedItem mi = obj as IfcMappedItem;
+ if (mi != null)
+ {
+ mMappedItems.Add(mi);
+ return;
+ }
+ IfcMaterial material = obj as IfcMaterial;
+ if (material != null)
+ {
+ mMaterials.Add(material);
+ return;
+ }
+ IfcMaterialProperties materialProperties = obj as IfcMaterialProperties;
+ if (materialProperties != null)
+ {
+ mMaterialProperties.Add(materialProperties);
+ return;
+ }
+ IfcMaterialPropertiesSuperSeded materialPropertiesSS = obj as IfcMaterialPropertiesSuperSeded;
+ if (materialPropertiesSS != null)
+ {
+ mMaterialPropertiesSS.Add(materialPropertiesSS);
+ return;
+ }
+ // IfcMechanicalFastener mechanicalFastener = result as IfcMechanicalFastener;
+ //if(mechanicalFastener != null)
+ //{
+ // mFasteners.Add(mechanicalFastener);
+ // return mechanicalFastener;
+ //}
+ //IfcOwnerHistory ownerHistory = result as IfcOwnerHistory;
+ //if(ownerHistory != null)
+ //{
+ // mOwnHistories.Add(ownerHistory);
+ // return ownerHistory;
+ //}
+ IfcPresentationLayerAssignment presentationLayerAssignment = obj as IfcPresentationLayerAssignment;
+ if (presentationLayerAssignment != null)
+ {
+ mPresentationLayerAssignments.Add(presentationLayerAssignment);
+ return;
+ }
+ IfcProductRepresentation productRepresentation = obj as IfcProductRepresentation;
+ if (productRepresentation != null)
+ {
+ mProductReps.Add(productRepresentation);
+ return;
+ }
+ IfcPropertySet propSet = obj as IfcPropertySet;
+ if(propSet != null)
+ {
+ mPropertySets.Add(propSet);
+ return;
+ }
+ //IfcProfileDef profileDef = obj as IfcProfileDef;
+ //if (profileDef != null)
+ //{
+ // mProfiles.Add(profileDef);
+ // return profileDef;
+ //}
+ IfcRelationship relationship = obj as IfcRelationship;
+ if (relationship != null)
+ {
+ mRelationships.Add(relationship);
+ return;
+ }
+ IfcRepresentation representation = obj as IfcRepresentation;
+ if (representation != null)
+ {
+ mRepresentations.Add(representation);
+ return;
+ }
+ //IfcRepresentationMap representationMap = obj as IfcRepresentationMap;
+ //if (representationMap != null)
+ //{
+ // mRepMaps.Add(representationMap);
+ // return representationMap;
+ //}
+ IfcResourceConstraintRelationship rcr = obj as IfcResourceConstraintRelationship;
+ if (rcr != null)
+ {
+ mConstraintRelationships.Add(rcr);
+ return;
+ }
+ IfcShapeAspect shapeAspect = obj as IfcShapeAspect;
+ if (shapeAspect != null)
+ {
+ mShapeAspects.Add(shapeAspect);
+ return;
+ }
+ IfcStyledItem styledItem = obj as IfcStyledItem;
+ if (styledItem != null)
+ {
+ mStyledItems.Add(styledItem);
+ return;
+ }
+
+ IfcTypeProduct typeProduct = obj as IfcTypeProduct;
+ if (typeProduct != null)
+ {
+ mTypeProducts.Add(typeProduct);
+ return;
+ }
+ setCustomAggregate(obj);
+ }
+ partial void InitializeOthers(string folder);
+ internal void RelateObjects(string folder)
+ {
+ try
+ {
+ int icounter;
+ for(icounter = 0; icounter < mComplexProperties.Count;icounter++)
+ mComplexProperties[icounter].relate();
+ for (icounter = 0; icounter < mCoordinateOperations.Count; icounter++)
+ mCoordinateOperations[icounter].Relate();
+ for (icounter = 0; icounter < mEdgeCurves.Count; icounter++)
+ mEdgeCurves[icounter].associate();
+ foreach (IfcExternalReferenceRelationship er in mExternalRelationships)
+ {
+ try
+ {
+ er.relate();
+ }
+ catch (Exception) { }
+ }
+ for (icounter = 0; icounter < mProducts.Count; icounter++)
+ mProducts[icounter].relate();
+ foreach (IfcIndexedColourMap icm in mIndexedColourMap)
+ icm.relate();
+ foreach (IfcIndexedTextureMap itm in mIndexedTextureMap)
+ itm.relate();
+ for (icounter = 0; icounter < mLocalPlacements.Count; icounter++)
+ mLocalPlacements[icounter].setReference();
+ for(icounter = 0; icounter < mMappedItems.Count; icounter++)
+ mMappedItems[icounter].MappingSource.mMapUsage.Add(mMappedItems[icounter]);
+ for (icounter = 0; icounter < mMaterialProperties.Count; icounter++)
+ mMaterialProperties[icounter].relate();
+ for (icounter = 0; icounter < mMaterialPropertiesSS.Count; icounter++)
+ mMaterialPropertiesSS[icounter].relate();
+ for (icounter = 0; icounter < mPresentationLayerAssignments.Count; icounter++)
+ mPresentationLayerAssignments[icounter].relate();
+ for (icounter = 0; icounter < mProductReps.Count; icounter++)
+ {
+ try
+ {
+ mProductReps[icounter].relate();
+ }
+ catch (Exception) { }
+ }
+ for (icounter = 0; icounter < mPropertySets.Count; icounter++)
+ mPropertySets[icounter].relate();
+ for (icounter = 0; icounter < mRelationships.Count; icounter++)
+ {
+ try
+ {
+ mRelationships[icounter].relate();
+ }
+ catch (Exception) { }
+ }
+ foreach (IfcRepresentation r in mRepresentations)
+ r.relate();
+ foreach (IfcResourceConstraintRelationship rc in mConstraintRelationships)
+ rc.relate();
+ foreach (IfcShapeAspect sa in mShapeAspects)
+ sa.relate();
+ for(icounter = 0; icounter < mTypeProducts.Count; icounter++)
+ {
+ List repMaps = mTypeProducts[icounter].RepresentationMaps;
+ for (int jcounter = 0; jcounter < repMaps.Count; jcounter++)
+ repMaps[jcounter].mTypeProducts.Add(mTypeProducts[icounter]);
+ }
+ for (icounter = 0; icounter < mStyledItems.Count; icounter++)
+ mStyledItems[icounter].associateItem();
+ InitializeOthers(folder);
+ }
+ catch (Exception)
+ {
+ //logError.printMessage("XXX " + x.ToString());
+ }
+ }
+ }
+ internal Guid id = Guid.NewGuid();
+ internal int mNextBlank = 1;
+
+ internal Schema mSchema = Schema.IFC2x3;
+
+ internal ModelView mModelView = ModelView.If2x3NotAssigned;
+ internal bool mAccuratePreview = false;// mCoordinationView = false;
+ internal string mFolder = "";
+ internal double mPlaneAngleToRadians = 1;
+ internal bool mTimeInDays = false;
+ public int NextObjectRecord { set { mNextBlank = value; } }
+ public Schema IFCSchema
+ {
+ get { return mSchema; }
+ set { mSchema = value; }
+ }
+ public ModelView ModelView
+ {
+ get { return mModelView; }
+ set { mModelView = value; }
+ }
+ public double Tolerance
+ {
+ get { return mModelTolerance; }
+ set { mModelTolerance = Math.Min(0.0005 / mModelSIScale, value); }
+ }
+ public double ScaleSI
+ {
+ get { return mModelSIScale; }
+ set { mModelSIScale = value; }
+ }
+
+ private double mModelTolerance = 0.0001,mModelSIScale = 1;
+ public IfcProject Project
+ {
+ get { return mContext as IfcProject; }
+ }
+ internal List mIfcObjects = new List(new BaseClassIfc[] { new BaseClassIfc() });
+
+ private IfcCartesianPoint mOrigin = null, mWorldOrigin = null,mOrigin2d = null;
+ internal IfcDirection mXAxis, mYAxis, mZAxis;
+ //internal int mTempWorldCoordinatePlacement = 0;
+ private IfcAxis2Placement3D mWorldCoordinatePlacement;
+ internal IfcAxis2Placement3D mPlacementPlaneXY;
+ internal IfcAxis2Placement2D m2DPlaceOrigin;
+ internal IfcSIUnit mSILength, mSIArea, mSIVolume;
+ internal IfcGeometricRepresentationContext mGeomRepContxt;
+ internal IfcGeometricRepresentationSubContext mGeoRepSubContxtBody = null, mGeoRepSubContxtAxis=null, mGeoRepSubContxtAnalysisSurface = null;
+ private IfcApplication mApplication = null;
+ internal IfcApplication Application
+ {
+ get
+ {
+ if (mApplication == null)
+ mApplication = new IfcApplication(this);
+ return mApplication;
+ }
+ }
+ private IfcPersonAndOrganization mPersonOrganization = null;
+ internal IfcPersonAndOrganization PersonOrganization
+ {
+ get
+ {
+ if (mPersonOrganization == null)
+ mPersonOrganization = new IfcPersonAndOrganization(this);
+ return mPersonOrganization;
+ }
+ }
+ private IfcOwnerHistory mOwnerHistoryCreate,mOwnerHistoryModify,mOwnerHistoryDelete;
+ internal IfcOwnerHistory OwnerHistory(IfcChangeActionEnum changeAction)
+ {
+ if(changeAction == IfcChangeActionEnum.ADDED)
+ {
+ if (mOwnerHistoryCreate == null)
+ mOwnerHistoryCreate = new IfcOwnerHistory(PersonOrganization, Application, IfcChangeActionEnum.ADDED);
+ return mOwnerHistoryCreate;
+ }
+ if(changeAction == IfcChangeActionEnum.DELETED)
+ {
+ if (mOwnerHistoryDelete == null)
+ mOwnerHistoryDelete = new IfcOwnerHistory(PersonOrganization, Application, IfcChangeActionEnum.DELETED);
+ return mOwnerHistoryDelete;
+ }
+ if(changeAction == IfcChangeActionEnum.MODIFIED)
+ {
+ if (mOwnerHistoryModify == null)
+ mOwnerHistoryModify = new IfcOwnerHistory(PersonOrganization, Application, IfcChangeActionEnum.MODIFIED);
+ return mOwnerHistoryModify;
+ }
+ return null;
+ }
+
+
+ internal IfcContext mContext = null;
+
+ internal HashSet mGlobalIDs = new HashSet();
+
+ partial void printError(string str);
+ internal void logError(string str) { printError(str); }
+ partial void getApplicationString(ref string app);
+ internal string applicationString
+ {
+ get
+ {
+ string str = "";
+ getApplicationString(ref str);
+ if(string.IsNullOrEmpty(str))
+ {
+ try
+ {
+ Assembly assembly = Assembly.GetExecutingAssembly();
+ AssemblyName name = assembly.GetName();
+ return name.Name + " v" + name.Version;
+ }
+ catch(Exception) { }
+ }
+ return "Unknown Application";
+ }
+ }
+ internal string getHeaderString(string fileName)
+ {
+ string vd = (mModelView == ModelView.Ifc2x3Coordination ? "CoordinationView_V2" :
+ (mModelView == ModelView.Ifc4Reference ? "ReferenceView_V1" : (mModelView == ModelView.Ifc4DesignTransfer ? "DesignTransferView_V1" : "notYetAssigned")));
+ string hdr = "ISO-10303-21;\r\nHEADER;\r\nFILE_DESCRIPTION(('ViewDefinition [" + vd + "]'),'2;1');\r\n";
+
+ hdr += "FILE_NAME(\r\n";
+ hdr += "/* name */ '" + ParserIfc.Encode(fileName.Replace("\\", "\\\\")) + "',\r\n";
+ DateTime now = DateTime.Now;
+ hdr += "/* time_stamp */ '" + now.Year + "-" + (now.Month < 10 ? "0" : "") + now.Month + "-" + (now.Day < 10 ? "0" : "") + now.Day + "T" + (now.Hour < 10 ? "0" : "") + now.Hour + ":" + (now.Minute < 10 ? "0" : "") + now.Minute + ":" + (now.Second < 10 ? "0" : "") + now.Second + "',\r\n";
+ hdr += "/* author */ ('" + System.Environment.UserName + "'),\r\n";
+ hdr += "/* organization */ ('Unknown'),\r\n";
+ hdr += "/* preprocessor_version */ 'GeomGymIFC by Geometry Gym Pty Ltd',\r\n";
+ hdr += "/* originating_system */ '" + applicationString + "',\r\n";
+
+ hdr += "/* authorization */ 'None');\r\n\r\n";
+ hdr += "FILE_SCHEMA (('" + (mSchema == Schema.IFC2x3 ? "IFC2X3" : "IFC4") + "'));\r\n";
+ hdr += "ENDSEC;\r\n";
+ hdr += "\r\nDATA;";
+ return hdr;
+ }
+ internal string getFooterString() { return "ENDSEC;\r\n\r\nEND-ISO-10303-21;\r\n\r\n"; }
+ internal bool mDrawBuildElemProx = true, mDrawSpaceReps = false,mDrawFurnishing = true,mDrawFasteners = false,mDrawPlates = true,mDrawRailings = true, mOutputEssential = false, mCFSasMesh = false;
+
+ public DatabaseIfc(string fileName) : base()
+ {
+ Aggregate aggregate = new Aggregate();
+ ReadFile(getStreamReader(fileName),aggregate,0);
+ }
+ public DatabaseIfc(TextReader stream) : base()
+ {
+ Aggregate aggregate = new Aggregate();
+ ReadFile(stream, aggregate, 0);
+ }
+ public DatabaseIfc(ModelView view) : this(true, view) { }
+ public DatabaseIfc(bool generate, ModelView view) : this(generate, view == ModelView.Ifc2x3Coordination ? Schema.IFC2x3 : Schema.IFC4A1,view) { }
+ public DatabaseIfc(bool generate, Schema schema) : this(generate,schema,schema == Schema.IFC2x3 ? ModelView.If2x3NotAssigned : ModelView.Ifc4NotAssigned) { }
+ private DatabaseIfc(bool generate,Schema schema, ModelView view)
+ {
+ mSchema = schema;
+ mModelView = view;
+#if(RHINO)
+ mModelSIScale = 1 / GGYM.Units.mLengthConversion[(int) GGYM.GGYMRhino.GGRhino.ActiveUnits()];
+ Tolerance = Rhino.RhinoDoc.ActiveDoc.ModelAbsoluteTolerance;
+#endif
+ if (mSchema == Schema.IFC2x3 || mSchema == Schema.IFC4)
+ {
+ OwnerHistory(IfcChangeActionEnum.ADDED);
+ }
+ mGeomRepContxt = new IfcGeometricRepresentationContext(this, 3, Tolerance) { ContextType = "Model" };
+ mGeoRepSubContxtAxis = new IfcGeometricRepresentationSubContext(mGeomRepContxt, 0, IfcGeometricProjectionEnum.MODEL_VIEW) { ContextIdentifier = "Axis" };
+ mGeoRepSubContxtBody = new IfcGeometricRepresentationSubContext(mGeomRepContxt, 0, IfcGeometricProjectionEnum.MODEL_VIEW) { ContextIdentifier = "Body" };
+
+ if (generate)
+ initData();
+ }
+
+
+
+
+ internal void initData()
+ {
+ initGeom();
+ mSILength = new IfcSIUnit(this, IfcUnitEnum.LENGTHUNIT, IfcSIPrefix.NONE, IfcSIUnitName.METRE);
+ mSIArea = new IfcSIUnit(this, IfcUnitEnum.AREAUNIT, IfcSIPrefix.NONE, IfcSIUnitName.SQUARE_METRE);
+ mSIVolume = new IfcSIUnit(this, IfcUnitEnum.VOLUMEUNIT, IfcSIPrefix.NONE, IfcSIUnitName.CUBIC_METRE);
+ }
+ internal void initGeom()
+ {
+ IfcCartesianPoint point = Origin;
+ IfcDirection direction = XAxis;
+ direction = YAxis;
+ direction = ZAxis;
+ IfcAxis2Placement pl = this.WorldCoordinatePlacement;
+ IfcAxis2Placement2D placement = Origin2dPlace;
+ }
+ public override string ToString()
+ {
+ //IFCModel im = new IFCModel(mIFC2x3,true);
+ string result = getHeaderString("") + "\r\n";
+ for (int icounter = 1; icounter < mIfcObjects.Count; icounter++)
+ {
+ BaseClassIfc ie = mIfcObjects[icounter];
+ if (ie != null)
+ {
+ string str = ie.ToString();
+ if (str != "")
+ result += str +"\r\n";
+ }
+ }
+ return result + getFooterString();
+ }
+ internal IfcAxis2Placement2D Origin2dPlace
+ {
+ get
+ {
+ if (m2DPlaceOrigin == null)
+ m2DPlaceOrigin = new IfcAxis2Placement2D(new IfcCartesianPoint(this, 0, 0));
+ return m2DPlaceOrigin;
+ }
+ }
+ internal IfcCartesianPoint WorldOrigin
+ {
+ get
+ {
+ if(mWorldOrigin == null)
+ mWorldOrigin = WorldCoordinatePlacement.Location;
+ return mWorldOrigin;
+ }
+ }
+ internal IfcCartesianPoint Origin2d
+ {
+ get
+ {
+ if (mOrigin2d == null)
+ mOrigin2d = new IfcCartesianPoint(this,0, 0);
+ return mOrigin2d;
+ }
+ }
+ internal IfcAxis2Placement3D WorldCoordinatePlacement
+ {
+ get
+ {
+ if (mWorldCoordinatePlacement == null)
+ {
+ if (mContext != null)
+ {
+ List contexts = mContext.RepresentationContexts;
+ foreach (IfcRepresentationContext context in contexts)
+ {
+ IfcGeometricRepresentationContext grc = context as IfcGeometricRepresentationContext;
+ if (grc == null)
+ continue;
+ IfcAxis2Placement3D pl = grc.WorldCoordinateSystem as IfcAxis2Placement3D;
+ if (pl != null)
+ {
+ mWorldCoordinatePlacement = pl;
+ break;
+ }
+ }
+ }
+ if (mWorldCoordinatePlacement == null)
+ {
+ mWorldCoordinatePlacement = new IfcAxis2Placement3D(new IfcCartesianPoint(this, 0, 0, 0), mZAxis, mXAxis);
+ if (mContext != null)
+ {
+ List contexts = mContext.RepresentationContexts;
+ foreach (IfcRepresentationContext context in contexts)
+ {
+ IfcGeometricRepresentationContext grc = context as IfcGeometricRepresentationContext;
+ if (grc != null)
+ {
+ grc.WorldCoordinateSystem = mWorldCoordinatePlacement;
+ return mWorldCoordinatePlacement;
+ }
+ }
+ }
+ }
+ }
+ return mWorldCoordinatePlacement;
+ }
+ }
+ internal IfcAxis2Placement3D PlaneXYPlacement
+ {
+ get
+ {
+ if (mPlacementPlaneXY == null)
+ mPlacementPlaneXY = new IfcAxis2Placement3D(this);
+ return mPlacementPlaneXY;
+ }
+ }
+ internal IfcCartesianPoint Origin
+ {
+ get
+ {
+ if (mOrigin == null)
+ mOrigin = new IfcCartesianPoint(this, 0, 0, 0);
+ return mOrigin;
+ }
+ }
+ internal IfcDirection XAxis
+ {
+ get
+ {
+ if (mXAxis == null)
+ mXAxis = new IfcDirection(this, 1, 0, 0);
+ return mXAxis;
+ }
+ }
+ internal IfcDirection YAxis
+ {
+ get
+ {
+ if (mYAxis == null)
+ mYAxis = new IfcDirection(this, 0, 1, 0);
+ return mYAxis;
+ }
+ }
+ internal IfcDirection ZAxis
+ {
+ get
+ {
+ if (mZAxis == null)
+ mZAxis = new IfcDirection(this, 0, 0, 1);
+ return mZAxis;
+ }
+ }
+
+ internal static StreamReader getStreamReader(string fileName)
+ {
+ string ext = System.IO.Path.GetExtension(fileName);
+ if (string.Compare(ext, ".IFCZIP", true) == 0)
+ {
+ System.IO.Compression.ZipArchive za = System.IO.Compression.ZipFile.OpenRead(fileName);
+ if (za.Entries.Count != 1)
+ {
+ return null;
+ }
+ return new StreamReader(za.Entries[0].Open(), System.Text.Encoding.GetEncoding("windows-1252"));
+ }
+ return new StreamReader(fileName, System.Text.Encoding.GetEncoding("windows-1252"));
+ }
+
+ private IfcContext ReadFile(TextReader sr, Aggregate aggregate, int offset)
+ {
+ mSchema = Schema.IFC2x3;
+ CultureInfo current = Thread.CurrentThread.CurrentCulture;
+ Thread.CurrentThread.CurrentCulture = new CultureInfo("en-US");
+ string strLine = sr.ReadLine(), str = "";
+ DateTime s = DateTime.Now;
+ if (offset > 0)
+ {
+ while (strLine != null)
+ {
+ int index = strLine.IndexOf("/*");
+ if (index >= 0)
+ {
+ string str2 = "", str3 = strLine;
+ if (index > 0)
+ str2 = strLine.Substring(0, index);
+ int index2 = str3.IndexOf("*/");
+ while (index2 < 0)
+ {
+ str3 = sr.ReadLine();
+ if (strLine == null)
+ break;
+ index2 = str3.IndexOf("*/");
+ }
+ strLine = str2;
+ if (strLine != null && index2 + 2 < str3.Length)
+ strLine += str3.Substring(index2 + 2);
+ }
+ while (!strLine.EndsWith(";"))
+ {
+ str = sr.ReadLine();
+ if (str != null)
+ {
+ index = str.IndexOf("/*");
+ if (index >= 0)
+ {
+ string str2 = "", str3 = str;
+ if (index > 0)
+ str2 = strLine.Substring(0, index);
+ int index2 = str3.IndexOf("*/");
+ while (index2 < 0)
+ {
+ str3 = sr.ReadLine();
+ if (strLine == null)
+ break;
+ index2 = str3.IndexOf("*/");
+ }
+ str = str2;
+ if (strLine != null && index2 + 2 < str3.Length)
+ str += str3.Substring(index2 + 2);
+ }
+ strLine += str;
+ strLine.Trim();
+ }
+ else
+ {
+ strLine = strLine.Trim();
+ strLine += ";";
+ break;
+ }
+ }
+ strLine = ParserSTEP.offsetSTEPRecords(strLine, offset);
+ try
+ {
+ InterpretLine(strLine, aggregate);
+ }
+ catch (Exception ex) { logError("XXX Error in line " + strLine + " " + ex.Message); }
+ strLine = sr.ReadLine();
+ }
+ }
+ else
+ {
+ while (strLine != null)
+ {
+ int index = strLine.IndexOf("/*");
+ if (index >= 0)
+ {
+ string str2 = "", str3 = strLine;
+ if (index > 0)
+ str2 = strLine.Substring(0, index);
+ int index2 = str3.IndexOf("*/");
+ while (index2 < 0)
+ {
+ str3 = sr.ReadLine();
+ if (strLine == null)
+ break;
+ index2 = str3.IndexOf("*/");
+ }
+ strLine = str2;
+ if (strLine != null && index2 + 2 < str3.Length)
+ strLine += str3.Substring(index2 + 2);
+ }
+ strLine = strLine.Trim();
+ while (!strLine.EndsWith(";"))
+ {
+ str = sr.ReadLine();
+ if (str != null)
+ {
+ index = str.IndexOf("/*");
+ if (index >= 0)
+ {
+ string str2 = "", str3 = str;
+ if (index > 0)
+ str2 = strLine.Substring(0, index);
+ int index2 = str3.IndexOf("*/");
+ while (index2 < 0)
+ {
+ str3 = sr.ReadLine();
+ if (strLine == null)
+ break;
+ index2 = str3.IndexOf("*/");
+ }
+ str = str2;
+ if (strLine != null && index2 + 2 < str3.Length)
+ str += str3.Substring(index2 + 2);
+ }
+ strLine += str;
+ strLine.Trim();
+ }
+ else
+ {
+ strLine = strLine.Trim();
+ strLine += ";";
+ break;
+ }
+ }
+ try
+ {
+ InterpretLine(strLine, aggregate);
+ }
+ catch (Exception ex) { logError("XXX Error in line " + strLine + " " + ex.Message); }
+ strLine = sr.ReadLine();
+ }
+ }
+ sr.Close();
+ Thread.CurrentThread.CurrentCulture = current;
+ postImport(aggregate);
+
+ return mContext;
+ }
+
+ partial void customPostImport(Aggregate aggregate);
+ private void postImport(Aggregate aggregate)
+ {
+ mWorldCoordinatePlacement = null;
+ aggregate.RelateObjects(mFolder);
+ if(mContext != null)
+ {
+ mContext.initializeUnitsAndScales();
+
+ if (mContext.mRepresentationContexts.Count > 0)
+ mGeomRepContxt = mIfcObjects[mContext.mRepresentationContexts[0]] as IfcGeometricRepresentationContext;
+ if (mContext.mDeclares.Count == 0)
+ {
+ List lds = aggregate.mTypeProducts.ConvertAll(x => (IfcDefinitionSelect)x);
+ IfcRelDeclares rd = new IfcRelDeclares(mContext, lds) { Name = "DeclaredTypes" };
+ }
+ }
+ customPostImport(aggregate);
+
+ }
+ internal BaseClassIfc InterpretLine(string line,Aggregate aggregate)
+ {
+ if (line.StartsWith("ISO"))
+ return null;
+ string ts = line.Trim().Replace(" ", "");
+ if (ts.StartsWith("FILE_SCHEMA(('IFC2X4", true, System.Globalization.CultureInfo.CurrentCulture) ||
+ ts.StartsWith("FILE_SCHEMA(('IFC4", true, System.Globalization.CultureInfo.CurrentCulture))
+ {
+ mSchema = Schema.IFC4;
+ return null;
+ }
+ BaseClassIfc result = ParserIfc.ParseLine(line, mSchema);
+ if (result == null)
+ {
+ int ifcID = 0;
+ string kw = "", str = "";
+ ParserIfc.GetKeyWord(line, out ifcID, out kw, out str);
+ if (string.IsNullOrEmpty(kw))
+ return null;
+
+ result = new BaseClassIfc(ifcID, kw,str);
+ }
+ if(result == null)
+ return null;
+ IfcApplication application = result as IfcApplication;
+ if (application != null)
+ {
+ IfcApplication ea = mApplication;
+ if (ea != null && ea.mVersion == application.mVersion)
+ {
+ if (string.Compare(ea.ApplicationFullName, application.ApplicationFullName, true) == 0)
+ {
+ if (string.Compare(ea.mApplicationIdentifier, application.mApplicationIdentifier) == 0)
+ {
+ mIfcObjects[ea.mIndex] = null;
+ mApplication = application;
+ OwnerHistory(IfcChangeActionEnum.ADDED).mLastModifyingApplication = application.mIndex;
+ if (mOwnerHistoryModify != null)
+ mOwnerHistoryModify.mLastModifyingApplication = application.mIndex;
+ }
+ }
+ }
+ }
+ IfcContext context = result as IfcContext;
+ if (context != null)
+ mContext = context;
+ IfcGeometricRepresentationContext geometricRepresentationContext = result as IfcGeometricRepresentationContext;
+ if (geometricRepresentationContext != null)
+ {
+ if (string.Compare(geometricRepresentationContext.mContextType, "Plan", true) != 0)
+ mGeomRepContxt = geometricRepresentationContext;
+ if (geometricRepresentationContext.mPrecision > 1e-6)
+ Tolerance = geometricRepresentationContext.mPrecision;
+
+ }
+ IfcSIUnit unit = result as IfcSIUnit;
+ if(unit != null)
+ {
+ if (unit.Name == IfcSIUnitName.METRE && unit.Prefix == IfcSIPrefix.NONE)
+ mSILength = unit;
+ else if (unit.Name == IfcSIUnitName.SQUARE_METRE && unit.Prefix == IfcSIPrefix.NONE)
+ mSIArea = unit;
+ else if (unit.Name == IfcSIUnitName.CUBIC_METRE && unit.Prefix == IfcSIPrefix.NONE)
+ mSIVolume = unit;
+ }
+ aggregate.setAggregate(result);
+ if (mIfcObjects.Count <= result.mIndex)
+ for (int ncounter = mIfcObjects.Count; ncounter <= result.mIndex; ncounter++)
+ mIfcObjects.Add(new BaseClassIfc());
+ mIfcObjects[result.mIndex] = result;
+ result.mDatabase = this;
+
+ //IfcWorkPlan workPlan = result as IfcWorkPlan;
+ //if(workPlan != null)
+ //{
+ // mWorkPlans.Add(workPlan);
+ // return workPlan;
+ //}
+ return result;
+ }
+
+ public bool WriteFile(string filename)
+ {
+ StreamWriter sw = null;
+ bool zip = filename.EndsWith(".ifczip");
+ System.IO.Compression.ZipArchive za = null;
+ if (zip)
+ {
+ if (System.IO.File.Exists(filename))
+ System.IO.File.Delete(filename);
+ za = System.IO.Compression.ZipFile.Open(filename, System.IO.Compression.ZipArchiveMode.Create);
+ System.IO.Compression.ZipArchiveEntry zae = za.CreateEntry(System.IO.Path.GetFileNameWithoutExtension(filename) + ".ifc");
+ sw = new StreamWriter(zae.Open());
+ }
+ else
+ sw = new StreamWriter(filename);
+ CultureInfo current = Thread.CurrentThread.CurrentCulture;
+ Thread.CurrentThread.CurrentCulture = new CultureInfo("en-US");
+ sw.Write(getHeaderString("") + "\r\n");
+ for (int icounter = 1; icounter < mIfcObjects.Count; icounter++)
+ {
+ BaseClassIfc ie = mIfcObjects[icounter];
+ if (ie != null)
+ {
+ string str = ie.ToString();
+ if (!string.IsNullOrEmpty(str))
+ sw.WriteLine(str);
+ }
+ }
+ sw.Write(getFooterString());
+ sw.Close();
+ Thread.CurrentThread.CurrentUICulture = current;
+ if (zip)
+ za.Dispose();
+ return true;
+ }
+ }
+}
+
+
\ No newline at end of file
diff --git a/IFC/Enumerations.cs b/IFC/Enumerations.cs
new file mode 100644
index 0000000..c6cd03a
--- /dev/null
+++ b/IFC/Enumerations.cs
@@ -0,0 +1,276 @@
+// MIT License
+// Copyright (c) 2016 Geometry Gym Pty Ltd
+
+// Permission is hereby granted, free of charge, to any person obtaining a copy of this software
+// and associated documentation files (the "Software"), to deal in the Software without restriction,
+// including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense,
+// and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so,
+// subject to the following conditions:
+
+// The above copyright notice and this permission notice shall be included in all copies or substantial
+// portions of the Software.
+
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT
+// LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+// IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+// WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+// SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+using System;
+using System.Reflection;
+
+namespace GeometryGym.Ifc
+{
+ public enum IfcActionSourceTypeEnum { DEAD_LOAD_G, COMPLETION_G1, LIVE_LOAD_Q, SNOW_S, WIND_W, PRESTRESSING_P, SETTLEMENT_U, TEMPERATURE_T, EARTHQUAKE_E, FIRE, IMPULSE, IMPACT, TRANSPORT, ERECTION, PROPPING, SYSTEM_IMPERFECTION, SHRINKAGE, CREEP, LACK_OF_FIT, BUOYANCY, ICE, CURRENT, WAVE, RAIN, BRAKES, USERDEFINED, NOTDEFINED };
+ public enum IfcActionTypeEnum { PERMANENT_G, VARIABLE_Q, EXTRAORDINARY_A, USERDEFINED, NOTDEFINED };
+ public enum IfcActuatorTypeEnum { ELECTRICACTUATOR, HANDOPERATEDACTUATOR, HYDRAULICACTUATOR, PNEUMATICACTUATOR, THERMOSTATICACTUATOR, USERDEFINED, NOTDEFINED };
+ public enum IfcAddressTypeEnum { OFFICE, SITE, HOME, DISTRIBUTIONPOINT, USERDEFINED, NOTDEFINED };
+ public enum IfcAheadOrBehind { AHEAD, BEHIND }; //OBSELETE IFC4
+ public enum IfcAirTerminalBoxTypeEnum { CONSTANTFLOW, VARIABLEFLOWPRESSUREDEPENDANT, VARIABLEFLOWPRESSUREINDEPENDANT, USERDEFINED, NOTDEFINED };
+ public enum IfcAirTerminalTypeEnum { GRILLE, REGISTER, DIFFUSER,LOUVRE, USERDEFINED, NOTDEFINED, EYEBALL, IRIS, LINEARGRILLE, LINEARDIFFUSER }; //IFC4 DELETED
+ public enum IfcAirToAirHeatRecoveryTypeEnum { FIXEDPLATECOUNTERFLOWEXCHANGER, FIXEDPLATECROSSFLOWEXCHANGER, FIXEDPLATEPARALLELFLOWEXCHANGER, ROTARYWHEEL, RUNAROUNDCOILLOOP, HEATPIPE, TWINTOWERENTHALPYRECOVERYLOOPS, THERMOSIPHONSEALEDTUBEHEATEXCHANGERS, THERMOSIPHONCOILTYPEHEATEXCHANGERS, USERDEFINED, NOTDEFINED };
+ public enum IfcAlarmTypeEnum { BELL, BREAKGLASSBUTTON, LIGHT, MANUALPULLBOX, SIREN, WHISTLE, USERDEFINED, NOTDEFINED };
+ public enum IfcAlignmentTypeEnum { ABSOLUTE, USERDEFINED, NOTDEFINED };
+ public enum IfcAnalysisModelTypeEnum { IN_PLANE_LOADING_2D, OUT_PLANE_LOADING_2D, LOADING_3D, USERDEFINED, NOTDEFINED };
+ public enum IfcAnalysisTheoryTypeEnum { FIRST_ORDER_THEORY, SECOND_ORDER_THEORY, THIRD_ORDER_THEORY, FULL_NONLINEAR_THEORY, USERDEFINED, NOTDEFINED };
+ public enum IfcArithmeticOperatorEnum { ADD, DIVIDE, MULTIPLY, SUBTRACT,NONE }; //GG ADDED NONE
+ public enum IfcAssemblyPlaceEnum { SITE, FACTORY, NOTDEFINED };
+ public enum IfcAudioVisualApplianceTypeEnum { AMPLIFIER, CAMERA, DISPLAY, MICROPHONE, PLAYER, PROJECTOR, RECEIVER, SPEAKER, SWITCHER, TELEPHONE, TUNER, USERDEFINED, NOTDEFINED };
+ public enum IfcBeamTypeEnum { BEAM, HOLLOWCORE, JOIST, LINTEL, SPANDREL, T_BEAM, USERDEFINED, NOTDEFINED };
+ public enum IfcBenchmarkEnum { GREATERTHAN, GREATERTHANOREQUALTO, LESSTHAN, LESSTHANOREQUALTO, EQUALTO, NOTEQUALTO, INCLUDES, NOTINCLUDES, INCLUDEDIN, NOTINCLUDEDIN };
+ public enum IfcBoilerTypeEnum { WATER, STEAM, USERDEFINED, NOTDEFINED };
+ public enum IfcBooleanOperator { UNION, INTERSECTION, DIFFERENCE };
+ public enum IfcBSplineCurveForm { POLYLINE_FORM, CIRCULAR_ARC, ELLIPTIC_ARC, PARABOLIC_ARC, HYPERBOLIC_ARC, UNSPECIFIED };
+ public enum IfcBSplineSurfaceForm { PLANE_SURF, CYLINDRICAL_SURF, CONICAL_SURF, SPHERICAL_SURF, TOROIDAL_SURF, SURF_OF_REVOLUTION, RULED_SURF, GENERALISED_CONE, QUADRIC_SURF, SURF_OF_LINEAR_EXTRUSION, UNSPECIFIED };
+ //public enum IfcBuildingElementEnum { IfcBeam, IfcBuildingElementPart, IfcBuildingElementProxy, IfcColumn, IfcCovering, IfcCurtainWall, IfcDoor, IfcFooting, IfcMember, IfcPile, IfcPlate, IfcRailing, IfcRamp, IfcRampFlight, IfcRoof, IfcSlab, IfcStair, IfcStairFlight, IfcWall, IfcWindow };
+ public enum IfcBuildingElementPartTypeEnum { INSULATION, PRECASTPANEL, USERDEFINED, NOTDEFINED };
+ public enum IfcBuildingElementProxyTypeEnum { COMPLEX, ELEMENT, PARTIAL, PROVISIONFORVOID, USERDEFINED, NOTDEFINED }; // 1st 3 not used
+ public enum IfcBuildingSystemTypeEnum { FENESTRATION, FOUNDATION, LOADBEARING, OUTERSHELL, SHADING, TRANSPORT, USERDEFINED, NOTDEFINED};
+ public enum IfcBurnerTypeEnum { USERDEFINED, NOTDEFINED };
+ public enum IfcCableCarrierFittingTypeEnum { BEND, CROSS, REDUCER, TEE, USERDEFINED, NOTDEFINED };
+ public enum IfcCableCarrierSegmentTypeEnum { CABLELADDERSEGMENT, CABLETRAYSEGMENT, CABLETRUNKINGSEGMENT, CONDUITSEGMENT, USERDEFINED, NOTDEFINED };
+ public enum IfcCableFittingTypeEnum { CONNECTOR, ENTRY, EXIT, JUNCTION, TRANSITION, USERDEFINED, NOTDEFINED };
+ public enum IfcCableSegmentTypeEnum { CABLESEGMENT, CONDUCTORSEGMENT, USERDEFINED, NOTDEFINED };
+ public enum IfcCardinalPointReference { DEFAULT = 0, BOTLEFT = 1, BOTMID = 2, BOTRIGHT = 3, MIDLEFT = 4, MID = 5, MIDRIGHT = 6, TOPLEFT = 7, TOPMID = 8, TOPRIGHT = 9, CENTROID = 10, BOTCENT = 11, LEFTCENT = 12, RIGHTCENT = 13, TOPCENT = 14, SHEARCENT = 15, BOTSHEAR = 16, LEFTSHEAR = 17, RIGHTSHEAR = 18, TOPSHEAR = 19};
+ public enum IfcChangeActionEnum { NOCHANGE, MODIFIED, ADDED, DELETED, NOTDEFINED, MODIFIEDADDED, MODIFIEDDELETED }; //IFC4 MODIFIED DELETED
+ public enum IfcChillerTypeEnum { AIRCOOLED, WATERCOOLED, HEATRECOVERY, USERDEFINED, NOTDEFINED };
+ public enum IfcChimneyTypeEnum { USERDEFINED, NOTDEFINED };
+ public enum IfcCoilTypeEnum { DXCOOLINGCOIL, WATERCOOLINGCOIL, STEAMHEATINGCOIL, WATERHEATINGCOIL, ELECTRICHEATINGCOIL, GASHEATINGCOIL, USERDEFINED, NOTDEFINED };
+ public enum IfcColumnTypeEnum { COLUMN, USERDEFINED, NOTDEFINED };
+ public enum IfcCommunicationsApplianceTypeEnum { ANTENNA, COMPUTER, FAX, GATEWAY, MODEM, NETWORKAPPLIANCE, NETWORKBRIDGE, NETWORKHUB, PRINTER, REPEATER, ROUTER, SCANNER, USERDEFINED, NOTDEFINED };
+ public enum IfcComplexPropertyTemplateTypeEnum { P_COMPLEX, Q_COMPLEX };
+ public enum IfcCompressorTypeEnum { DYNAMIC, RECIPROCATING, ROTARY, SCROLL, TROCHOIDAL, SINGLESTAGE, BOOSTER, OPENTYPE, HERMETIC, SEMIHERMETIC, WELDEDSHELLHERMETIC, ROLLINGPISTON, ROTARYVANE, SINGLESCREW, TWINSCREW, USERDEFINED, NOTDEFINED };
+ public enum IfcCondenserTypeEnum { WATERCOOLEDSHELLTUBE, WATERCOOLEDSHELLCOIL, WATERCOOLEDTUBEINTUBE, WATERCOOLEDBRAZEDPLATE, AIRCOOLED, EVAPORATIVECOOLED, USERDEFINED, NOTDEFINED };
+ public enum IfcConnectionTypeEnum { ATPATH, ATSTART, ATEND, NOTDEFINED };
+ public enum IfcConstraintEnum { HARD, SOFT, ADVISORY, USERDEFINED, NOTDEFINED };
+ public enum IfcControllerTypeEnum { FLOATING, PROPORTIONAL, PROPORTIONALINTEGRAL, PROPORTIONALINTEGRALDERIVATIVE, TIMEDTWOPOSITION, TWOPOSITION, USERDEFINED, NOTDEFINED };
+ public enum IfcConstructionEquipmentResourceTypeEnum { DEMOLISHING, EARTHMOVING, ERECTING, HEATING, LIGHTING, PAVING, PUMPING, TRANSPORTING, USERDEFINED, NOTDEFINED };
+ public enum IfcConstructionMaterialResourceTypeEnum { AGGREGATES, CONCRETE, DRYWALL, FUEL, GYPSUM, MASONRY, METAL, PLASTIC, WOOD, NOTDEFINED, USERDEFINED };
+ public enum IfcConstructionProductResourceTypeEnum { ASSEMBLY, FORMWORK, NOTDEFINED, USERDEFINED };
+ public enum IfcCooledBeamTypeEnum { ACTIVE, PASSIVE, USERDEFINED, NOTDEFINED };
+ public enum IfcCoolingTowerTypeEnum { NATURALDRAFT, MECHANICALINDUCEDDRAFT, MECHANICALFORCEDDRAFT, USERDEFINED, NOTDEFINED };
+ public enum IfcCostItemTypeEnum { USERDEFINED, NOTDEFINED };
+ public enum IfcCostScheduleTypeEnum { BUDGET, COSTPLAN, ESTIMATE, TENDER, PRICEDBILLOFQUANTITIES, UNPRICEDBILLOFQUANTITIES, SCHEDULEOFRATES, USERDEFINED, NOTDEFINED };
+ public enum IfcCoveringTypeEnum { CEILING, CLADDING, FLOORING, MOLDING, ROOFING, SKIRTINGBOARD, USERDEFINED, NOTDEFINED, INSULATION, MEMBRANE, SLEEVING, WRAPPING }; //IFC4 DELETED
+ public enum IfcCrewResourceTypeEnum { OFFICE, SITE, NOTDEFINED, USERDEFINED };
+ public enum IfcCurrencyEnum { AED, AES, ATS, AUD, BBD, BEG, BGL, BHD, BMD, BND, BRL, BSD, BWP, BZD, CAD, CBD, CHF, CLP, CNY, CYS, CZK, DDP, DEM, DKK, EGL, EST, EUR, FAK, FIM, FJD, FKP, FRF, GBP, GIP, GMD, GRX, HKD, HUF, ICK, IDR, ILS, INR, IRP, ITL, JMD, JOD, JPY, KES, KRW, KWD, KYD, LKR, LUF, MTL, MUR, MXN, MYR, NLG, NZD, OMR, PGK, PHP, PKR, PLN, PTN, QAR, RUR, SAR, SCR, SEK, SGD, SKP, THB, TRL, TTD, TWD, USD, VEB, VND, XEU, ZAR, ZWD, NOK };
+ public enum IfcCurtainWallTypeEnum { USERDEFINED, NOTDEFINED };
+ public enum IfcCurveInterpolationEnum { LINEAR, LOG_LINEAR, LOG_LOG, NOTDEFINED }
+ public enum IfcDamperTypeEnum { CONTROLDAMPER, FIREDAMPER, SMOKEDAMPER, FIRESMOKEDAMPER, BACKDRAFTDAMPER, RELIEFDAMPER, BLASTDAMPER, GRAVITYDAMPER, GRAVITYRELIEFDAMPER, BALANCINGDAMPER, FUMEHOODEXHAUST, USERDEFINED, NOTDEFINED };
+ public enum IfcDataOriginEnum { MEASURED, PREDICTED, SIMULATED, USERDEFINED, NOTDEFINED };
+ public enum IfcDerivedUnitEnum
+ {
+ ANGULARVELOCITYUNIT, COMPOUNDPLANEANGLEUNIT, DYNAMICVISCOSITYUNIT, HEATFLUXDENSITYUNIT,
+ INTEGERCOUNTRATEUNIT, ISOTHERMALMOISTURECAPACITYUNIT, KINEMATICVISCOSITYUNIT, LINEARVELOCITYUNIT, MASSDENSITYUNIT,
+ MASSFLOWRATEUNIT, MOISTUREDIFFUSIVITYUNIT, MOLECULARWEIGHTUNIT, SPECIFICHEATCAPACITYUNIT, THERMALADMITTANCEUNIT,
+ THERMALCONDUCTANCEUNIT, THERMALRESISTANCEUNIT, THERMALTRANSMITTANCEUNIT, VAPORPERMEABILITYUNIT, VOLUMETRICFLOWRATEUNIT,
+ ROTATIONALFREQUENCYUNIT, TORQUEUNIT, MOMENTOFINERTIAUNIT, LINEARMOMENTUNIT, LINEARFORCEUNIT, PLANARFORCEUNIT,
+ MODULUSOFELASTICITYUNIT, SHEARMODULUSUNIT, LINEARSTIFFNESSUNIT, ROTATIONALSTIFFNESSUNIT, MODULUSOFSUBGRADEREACTIONUNIT,
+ ACCELERATIONUNIT, CURVATUREUNIT, HEATINGVALUEUNIT, IONCONCENTRATIONUNIT, LUMINOUSINTENSITYDISTRIBUTIONUNIT, MASSPERLENGTHUNIT,
+ MODULUSOFLINEARSUBGRADEREACTIONUNIT, MODULUSOFROTATIONALSUBGRADEREACTIONUNIT, PHUNIT, ROTATIONALMASSUNIT, SECTIONAREAINTEGRALUNIT,
+ SECTIONMODULUSUNIT, SOUNDPOWERUNIT, SOUNDPRESSUREUNIT, TEMPERATUREGRADIENTUNIT, THERMALEXPANSIONCOEFFICIENTUNIT, WARPINGCONSTANTUNIT,
+ WARPINGMOMENTUNIT, AREADENSITYUNIT, SOUNDPRESSURELEVELUNIT, TEMPERATURERATEOFCHANGEUNIT, USERDEFINED
+ };
+ public enum IfcDimensionExtentUsage { ORIGIN, TARGET };
+ public enum IfcDirectionSenseEnum { POSITIVE, NEGATIVE };
+ public enum IfcDiscreteAccessoryTypeEnum { ANCHORPLATE, BRACKET, SHOE, USERDEFINED, NOTDEFINED };
+ public enum IfcDistributionChamberElementTypeEnum { FORMEDDUCT, INSPECTIONCHAMBER, INSPECTIONPIT, MANHOLE, METERCHAMBER, SUMP, TRENCH, VALVECHAMBER, USERDEFINED, NOTDEFINED };
+ public enum IfcDistributionPortTypeEnum { CABLE, CABLECARRIER, DUCT, PIPE, USERDEFINED, NOTDEFINED }
+ public enum IfcDistributionSystemEnum { AIRCONDITIONING, AUDIOVISUAL, CHEMICAL, CHILLEDWATER, COMMUNICATION, COMPRESSEDAIR, CONDENSERWATER,
+ CONTROL, CONVEYING, DATA, DISPOSAL, DOMESTICCOLDWATER, DOMESTICHOTWATER, DRAINAGE, EARTHING, ELECTRICAL, ELECTROACOUSTIC, EXHAUST,
+ FIREPROTECTION, FUEL, GAS, HAZARDOUS, HEATING, LIGHTING, LIGHTNINGPROTECTION, MUNICIPALSOLIDWASTE, OIL, OPERATIONAL, POWERGENERATION,
+ RAINWATER, REFRIGERATION, SECURITY, SEWAGE, SIGNAL, STORMWATER, TELEPHONE, TV, VACUUM, VENT, VENTILATION, WASTEWATER, WATERSUPPLY, USERDEFINED, NOTDEFINED };
+ public enum IfcDistributionSystemEnumPipe { CHEMICAL, CHILLEDWATER, COMPRESSEDAIR, CONDENSERWATER, CONVEYING, DISPOSAL, DOMESTICCOLDWATER,
+ DOMESTICHOTWATER, DRAINAGE, FIREPROTECTION, FUEL, GAS, HAZARDOUS, HEATING, MUNICIPALSOLIDWASTE, OIL, OPERATIONAL, RAINWATER,
+ REFRIGERATION, SEWAGE, STORMWATER, VACUUM, VENT, WASTEWATER, WATERSUPPLY, USERDEFINED, NOTDEFINED };
+ public enum IfcDistributionSystemEnumDuct { AIRCONDITIONING, EXHAUST, VENTILATION, USERDEFINED, NOTDEFINED };
+ public enum IfcDistributionSystemEnumCable { AUDIOVISUAL, COMMUNICATION, CONTROL, DATA, EARTHING, ELECTRICAL, ELECTROACOUSTIC, LIGHTING,
+ LIGHTNINGPROTECTION, POWERGENERATION, SECURITY, SIGNAL, TELEPHONE, TV, USERDEFINED, NOTDEFINED };
+ public enum IfcDistributionSystemEnumCableCarrier { AUDIOVISUAL, COMMUNICATION, CONTROL, DATA, EARTHING, ELECTRICAL, ELECTROACOUSTIC,
+ LIGHTING, LIGHTNINGPROTECTION, POWERGENERATION, SECURITY, SIGNAL, TELEPHONE, TV, USERDEFINED, NOTDEFINED };
+ public enum IfcDocumentConfidentialityEnum { PUBLIC, RESTRICTED, CONFIDENTIAL, PERSONAL, USERDEFINED, NOTDEFINED };
+ public enum IfcDocumentStatusEnum { DRAFT, FINALDRAFT, FINAL, REVISION, NOTDEFINED };
+ public enum IfcDoorPanelOperationEnum { SWINGING, DOUBLE_ACTING, SLIDING, FOLDING, REVOLVING, ROLLINGUP, USERDEFINED, NOTDEFINED };
+ public enum IfcDoorPanelPositionEnum { LEFT, MIDDLE, RIGHT, NOTDEFINED };
+ public enum IfcDoorStyleConstructionEnum { ALUMINIUM, HIGH_GRADE_STEEL, STEEL, WOOD, ALUMINIUM_WOOD, ALUMINIUM_PLASTIC, PLASTIC, USERDEFINED, NOTDEFINED };
+ public enum IfcDoorTypeOperationEnum { SINGLE_SWING_LEFT, SINGLE_SWING_RIGHT, DOUBLE_DOOR_SINGLE_SWING, DOUBLE_DOOR_SINGLE_SWING_OPPOSITE_LEFT, DOUBLE_DOOR_SINGLE_SWING_OPPOSITE_RIGHT, DOUBLE_SWING_LEFT, DOUBLE_SWING_RIGHT, DOUBLE_DOOR_DOUBLE_SWING, SLIDING_TO_LEFT, SLIDING_TO_RIGHT, DOUBLE_DOOR_SLIDING, FOLDING_TO_LEFT, FOLDING_TO_RIGHT, DOUBLE_DOOR_FOLDING, REVOLVING, ROLLINGUP, SWING_FIXED_LEFT, SWING_FIXED_RIGHT, USERDEFINED, NOTDEFINED };
+ public enum IfcDoorTypeEnum { DOOR, GATE, TRAPDOOR, USERDEFINED, NOTDEFINED };
+ public enum IfcDuctFittingTypeEnum { BEND, CONNECTOR, ENTRY, EXIT, JUNCTION, OBSTRUCTION, TRANSITION, USERDEFINED, NOTDEFINED };
+ public enum IfcDuctSegmentTypeEnum { RIGIDSEGMENT, FLEXIBLESEGMENT, USERDEFINED, NOTDEFINED };
+ public enum IfcDuctSilencerTypeEnum { FLATOVAL, RECTANGULAR, ROUND, USERDEFINED, NOTDEFINED };
+ public enum IfcElectricApplianceTypeEnum { COMPUTER, DIRECTWATERHEATER, DISHWASHER, ELECTRICCOOKER, ELECTRICHEATER, FACSIMILE, FREESTANDINGFAN, FREEZER, FRIDGE_FREEZER, HANDDRYER, INDIRECTWATERHEATER, MICROWAVE, PHOTOCOPIER, PRINTER, REFRIGERATOR, RADIANTHEATER, SCANNER, TELEPHONE, TUMBLEDRYER, TV, VENDINGMACHINE, WASHINGMACHINE, WATERHEATER, WATERCOOLER, USERDEFINED, NOTDEFINED };
+ public enum IfcElectricCurrentEnum { ALTERNATING, DIRECT, NOTDEFINED };
+ public enum IfcElectricDistributionBoardTypeEnum { CONSUMERUNIT, DISTRIBUTIONBOARD, MOTORCONTROLCENTRE, SWITCHBOARD, USERDEFINED, NOTDEFINED };
+ public enum IfcElectricDistributionPointFunctionEnum { ALARMPANEL, CONSUMERUNIT, CONTROLPANEL, DISTRIBUTIONBOARD, GASDETECTORPANEL, INDICATORPANEL, MIMICPANEL, MOTORCONTROLCENTRE, SWITCHBOARD, USERDEFINED, NOTDEFINED };
+ public enum IfcElectricFlowStorageDeviceTypeEnum { BATTERY, CAPACITORBANK, HARMONICFILTER, INDUCTORBANK, UPS, USERDEFINED, NOTDEFINED };
+ public enum IfcElectricGeneratorTypeEnum { USERDEFINED, NOTDEFINED };
+ public enum IfcElectricHeaterTypeEnum { ELECTRICPOINTHEATER, ELECTRICCABLEHEATER, ELECTRICMATHEATER, USERDEFINED, NOTDEFINED };
+ public enum IfcElectricMotorTypeEnum { DC, INDUCTION, POLYPHASE, RELUCTANCESYNCHRONOUS, SYNCHRONOUS, USERDEFINED, NOTDEFINED };
+ public enum IfcElectricTimeControlTypeEnum { TIMECLOCK, TIMEDELAY, RELAY, USERDEFINED, NOTDEFINED };
+ public enum IfcElementAssemblyTypeEnum { ACCESSORY_ASSEMBLY, ARCH, BEAM_GRID, BRACED_FRAME, GIRDER, REINFORCEMENT_UNIT, RIGID_FRAME, SLAB_FIELD, TRUSS, USERDEFINED, NOTDEFINED };
+ public enum IfcElementCompositionEnum { COMPLEX, ELEMENT, PARTIAL, NA };
+ public enum IfcEnergySequenceEnum { PRIMARY, SECONDARY, TERTIARY, AUXILIARY, USERDEFINED, NOTDEFINED };
+ public enum IfcEngineTypeEnum { EXTERNALCOMBUSTION, publicCOMBUSTION, USERDEFINED, NOTDEFINED };
+ public enum IfcEnvironmentalImpactCategoryEnum { COMBINEDVALUE, DISPOSAL, EXTRACTION, INSTALLATION, MANUFACTURE, TRANSPORTATION, USERDEFINED, NOTDEFINED };
+ public enum IfcEvaporativeCoolerTypeEnum { DIRECTEVAPORATIVERANDOMMEDIAAIRCOOLER, DIRECTEVAPORATIVERIGIDMEDIAAIRCOOLER, DIRECTEVAPORATIVESLINGERSPACKAGEDAIRCOOLER, DIRECTEVAPORATIVEPACKAGEDROTARYAIRCOOLER, DIRECTEVAPORATIVEAIRWASHER, INDIRECTEVAPORATIVEPACKAGEAIRCOOLER, INDIRECTEVAPORATIVEWETCOIL, INDIRECTEVAPORATIVECOOLINGTOWERORCOILCOOLER, INDIRECTDIRECTCOMBINATION, USERDEFINED, NOTDEFINED };
+ public enum IfcEvaporatorTypeEnum { DIRECTEXPANSIONSHELLANDTUBE, DIRECTEXPANSIONTUBEINTUBE, DIRECTEXPANSIONBRAZEDPLATE, FLOODEDSHELLANDTUBE, SHELLANDCOIL, USERDEFINED, NOTDEFINED };
+ public enum IfcEventTypeEnum { STARTEVENT, ENDEVENT, INTERMEDIATEEVENT, USERDEFINED, NOTDEFINED } //IFC4
+ public enum IfcEventTriggerTypeEnum { EVENTRULE, EVENTMESSAGE, EVENTTIME, EVENTCOMPLEX, USERDEFINED, NOTDEFINED } //IFC4
+ public enum IfcExternalSpatialElementTypeEnum { EXTERNAL, EXTERNAL_EARTH, EXTERNAL_WATER, EXTERNAL_FIRE, USERDEFINED, NOTDEFINED } //IFC4
+ public enum IfcFanTypeEnum { CENTRIFUGALFORWARDCURVED, CENTRIFUGALRADIAL, CENTRIFUGALBACKWARDINCLINEDCURVED, CENTRIFUGALAIRFOIL, TUBEAXIAL, VANEAXIAL, PROPELLORAXIAL, USERDEFINED, NOTDEFINED };
+ public enum IfcFastenerTypeEnum { GLUE, MORTAR, WELD, USERDEFINED, NOTDEFINED } //IFC4
+ public enum IfcFilterTypeEnum { AIRPARTICLEFILTER, ODORFILTER, OILFILTER, STRAINER, WATERFILTER, USERDEFINED, NOTDEFINED };
+ public enum IfcFireSuppressionTerminalTypeEnum { BREECHINGINLET, FIREHYDRANT, HOSEREEL, SPRINKLER, SPRINKLERDEFLECTOR, USERDEFINED, NOTDEFINED };
+ public enum IfcFlowDirectionEnum { SOURCE, SINK, SOURCEANDSINK, NOTDEFINED };
+ public enum IfcFlowInstrumentTypeEnum { PRESSUREGAUGE, THERMOMETER, AMMETER, FREQUENCYMETER, POWERFACTORMETER, PHASEANGLEMETER, VOLTMETER_PEAK, VOLTMETER_RMS, USERDEFINED, NOTDEFINED };
+ public enum IfcFlowMeterTypeEnum { ENERGYMETER, GASMETER, OILMETER, WATERMETER, USERDEFINED, NOTDEFINED, ELECTRICMETER, FLOWMETER }; // IFC4 DELETED
+ public enum IfcFootingTypeEnum { CAISSON_FOUNDATION, FOOTING_BEAM, PAD_FOOTING, PILE_CAP, STRIP_FOOTING, USERDEFINED, NOTDEFINED };
+ public enum IfcFurnitureTypeEnum { CHAIR, TABLE, DESK, BED, FILECABINET, SHELF, SOFA, USERDEFINED, NOTDEFINED };
+ public enum IfcGasTerminalTypeEnum { GASAPPLIANCE, GASBOOSTER, GASBURNER, USERDEFINED, NOTDEFINED };
+ public enum IfcGeographicElementTypeEnum { TERRAIN, USERDEFINED, NOTDEFINED };
+ public enum IfcGeometricProjectionEnum { GRAPH_VIEW, SKETCH_VIEW, MODEL_VIEW, PLAN_VIEW, REFLECTED_PLAN_VIEW, SECTION_VIEW, ELEVATION_VIEW, USERDEFINED, NOTDEFINED };
+ public enum IfcGlobalOrLocalEnum { GLOBAL_COORDS, LOCAL_COORDS };
+ public enum IfcGridTypeEnum { RECTANGULAR, RADIAL, TRIANGULAR, IRREGULAR, USERDEFINED, NOTDEFINED };
+ public enum IfcHeatExchangerTypeEnum { PLATE, SHELLANDTUBE, USERDEFINED, NOTDEFINED };
+ public enum IfcHumidifierTypeEnum { STEAMINJECTION, ADIABATICAIRWASHER, ADIABATICPAN, ADIABATICWETTEDELEMENT, ADIABATICATOMIZING, ADIABATICULTRASONIC, ADIABATICRIGIDMEDIA, ADIABATICCOMPRESSEDAIRNOZZLE, ASSISTEDELECTRIC, ASSISTEDNATURALGAS, ASSISTEDPROPANE, ASSISTEDBUTANE, ASSISTEDSTEAM, USERDEFINED, NOTDEFINED };
+ public enum IfcInternalOrExternalEnum { INTERNAL, EXTERNAL, EXTERNAL_EARTH, EXTERNAL_WATER, EXTERNAL_FIRE, NOTDEFINED };
+ public enum IfcInventoryTypeEnum { ASSETINVENTORY, SPACEINVENTORY, FURNITUREINVENTORY, USERDEFINED, NOTDEFINED };
+ public enum IfcInterceptorTypeEnum { CYCLONIC, GREASE, OIL, PETROL, USERDEFINED, NOTDEFINED };
+ public enum IfcJunctionBoxTypeEnum { USERDEFINED, NOTDEFINED };
+ public enum IfcKnotType { UNIFORM_KNOTS, QUASI_UNIFORM_KNOTS, PIECEWISE_BEZIER_KNOTS, UNSPECIFIED };
+ public enum IfcLaborResourceTypeEnum { ADMINISTRATION ,CARPENTRY ,CLEANING ,CONCRETE ,DRYWALL ,ELECTRIC ,FINISHING ,FLOORING ,GENERAL ,HVAC ,LANDSCAPING ,MASONRY ,PAINTING ,PAVING ,PLUMBING ,ROOFING ,SITEGRADING ,STEELWORK ,SURVEYING ,USERDEFINED ,NOTDEFINED};
+ public enum IfcLampTypeEnum { COMPACTFLUORESCENT, FLUORESCENT, HIGHPRESSUREMERCURY, HIGHPRESSURESODIUM, METALHALIDE, TUNGSTENFILAMENT, USERDEFINED, NOTDEFINED };
+ public enum IfcLayerSetDirectionEnum { AXIS1, AXIS2, AXIS3 };
+ public enum IfcLightDistributionCurveEnum { TYPE_A, TYPE_B, TYPE_C, NOTDEFINED };
+ public enum IfcLightEmissionSourceEnum { COMPACTFLUORESCENT, FLUORESCENT, HIGHPRESSUREMERCURY, HIGHPRESSURESODIUM, LIGHTEMITTINGDIODE, LOWPRESSURESODIUM, LOWVOLTAGEHALOGEN, MAINVOLTAGEHALOGEN, METALHALIDE, TUNGSTENFILAMENT, NOTDEFINED };
+ public enum IfcLightFixtureTypeEnum { POINTSOURCE, DIRECTIONSOURCE, USERDEFINED, NOTDEFINED };
+ public enum IfcLoadGroupTypeEnum { LOAD_GROUP, LOAD_CASE, LOAD_COMBINATION, USERDEFINED, NOTDEFINED, LOAD_COMBINATION_GROUP }; //IFC4 DELETED
+ public enum IfcLogicalEnum { TRUE, FALSE, UNKNOWN };
+ public enum IfcLogicalOperatorEnum { LOGICALAND, LOGICALOR, LOGICALXOR, LOGICALNOTAND, LOGICALNOTOR, NONE };
+ public enum IfcMechanicalFastenerTypeEnum { ANCHORBOLT, BOLT, DOWEL, NAIL, NAILPLATE, RIVET, SCREW, SHEARCONNECTOR, STAPLE, STUDSHEARCONNECTOR, USERDEFINED, NOTDEFINED }
+ public enum IfcMedicalDeviceTypeEnum { AIRSTATION, FEEDAIRUNIT, OXYGENGENERATOR, OXYGENPLANT, VACUUMSTATION, USERDEFINED, NOTDEFINED };
+ public enum IfcMemberTypeEnum { BRACE, CHORD, COLLAR, MEMBER, MULLION, PLATE, POST, PURLIN, RAFTER, STRINGER, STRUT, STUD, USERDEFINED, NOTDEFINED };
+ public enum IfcMotorConnectionTypeEnum { BELTDRIVE, COUPLING, DIRECTDRIVE, USERDEFINED, NOTDEFINED };
+ public enum IfcNullStyle { NULL }; //DEPRECEATED
+ public enum IfcObjectiveEnum { CODECOMPLIANCE, CODEWAIVER, DESIGNINTENT, EXTERNAL, HEALTHANDSAFETY, MERGECONFLICT, MODELVIEW, PARAMETER, REQUIREMENT, SPECIFICATION, TRIGGERCONDITION, USERDEFINED, NOTDEFINED };
+ public enum IfcObjectTypeEnum { PRODUCT, PROCESS, CONTROL, RESOURCE, ACTOR, GROUP, PROJECT, NOTDEFINED };
+ public enum IfcOccupantTypeEnum { ASSIGNEE, ASSIGNOR, LESSEE, LESSOR, LETTINGAGENT, OWNER, TENANT, USERDEFINED, NOTDEFINED };
+ public enum IfcOpeningElementTypeEnum { OPENING, RECESS, USERDEFINED, NOTDEFINED }
+ public enum IfcOutletTypeEnum { AUDIOVISUALOUTLET, COMMUNICATIONSOUTLET, POWEROUTLET, USERDEFINED, NOTDEFINED };
+ public enum IfcPermeableCoveringOperationEnum { GRILL, LOUVER, SCREEN, USERDEFINED, NOTDEFINED };
+ public enum IfcPhysicalOrVirtualEnum { PHYSICAL, VIRTUAL, NOTDEFINED };
+ public enum IfcPileConstructionEnum { BORED, CAST_IN_PLACE, COMPOSITE, DRIVEN, JETGROUTING, PRECAST_CONCRETE, PREFAB_STEEL, USERDEFINED, NOTDEFINED };
+ public enum IfcPileTypeEnum { COHESION, FRICTION, SUPPORT, USERDEFINED, NOTDEFINED };
+ public enum IfcPipeFittingTypeEnum { BEND, CONNECTOR, ENTRY, EXIT, JUNCTION, OBSTRUCTION, TRANSITION, USERDEFINED, NOTDEFINED };
+ public enum IfcPipeSegmentTypeEnum { FLEXIBLESEGMENT, RIGIDSEGMENT, GUTTER, SPOOL, USERDEFINED, NOTDEFINED };
+ public enum IfcPlateTypeEnum { CURTAIN_PANEL, SHEET, USERDEFINED, NOTDEFINED };
+ public enum IfcProcedureTypeEnum { ADVICE_CAUTION, ADVICE_NOTE, ADVICE_WARNING, CALIBRATION, DIAGNOSTIC, SHUTDOWN, STARTUP, USERDEFINED, NOTDEFINED };
+ public enum IfcProfileTypeEnum { CURVE, AREA };
+ public enum IfcProjectedOrTrueLengthEnum { PROJECTED_LENGTH, TRUE_LENGTH };
+ public enum IfcProjectOrderRecordTypeEnum { CHANGE, MAINTENANCE, MOVE, PURCHASE, WORK, USERDEFINED, NOTDEFINED };
+ public enum IfcProjectOrderTypeEnum { CHANGEORDER, MAINTENANCEWORKORDER, MOVEORDER, PURCHASEORDER, WORKORDER, USERDEFINED, NOTDEFINED };
+ public enum IfcProjectionElementTypeEnum { USERDEFINED, NOTDEFINED }
+ public enum IfcPropertySetTemplateTypeEnum { PSET_TYPEDRIVENONLY, PSET_TYPEDRIVENOVERRIDE, PSET_OCCURRENCEDRIVEN, PSET_PERFORMANCEDRIVEN, QTO_TYPEDRIVENONLY, QTO_TYPEDRIVENOVERRIDE, QTO_OCCURRENCEDRIVEN, NOTDEFINED };
+ public enum IfcPropertySourceEnum { DESIGN, DESIGNMAXIMUM, DESIGNMINIMUM, SIMULATED, ASBUILT, COMMISSIONING, MEASURED, USERDEFINED, NOTKNOWN };
+ public enum IfcProtectiveDeviceTrippingUnitTypeEnum { ELECTRONIC, ELECTROMAGNETIC, RESIDUALCURRENT, THERMAL, USERDEFINED, NOTDEFINED };
+ public enum IfcProtectiveDeviceTypeEnum { FUSEDISCONNECTOR, CIRCUITBREAKER, EARTHFAILUREDEVICE, RESIDUALCURRENTCIRCUITBREAKER, RESIDUALCURRENTSWITCH, VARISTOR, USERDEFINED, NOTDEFINED };
+ public enum IfcPumpTypeEnum { CIRCULATOR, ENDSUCTION, SPLITCASE, VERTICALINLINE, VERTICALTURBINE, USERDEFINED, NOTDEFINED };
+ public enum IfcRailingTypeEnum { HANDRAIL, GUARDRAIL, BALUSTRADE, USERDEFINED, NOTDEFINED };
+ public enum IfcRampFlightTypeEnum { STRAIGHT, SPIRAL, USERDEFINED, NOTDEFINED };
+ public enum IfcRampTypeEnum { STRAIGHT_RUN_RAMP, TWO_STRAIGHT_RUN_RAMP, QUARTER_TURN_RAMP, TWO_QUARTER_TURN_RAMP, HALF_TURN_RAMP, SPIRAL_RAMP, USERDEFINED, NOTDEFINED };
+ public enum IfcRecurrenceTypeEnum { DAILY, WEEKLY, MONTHLY_BY_DAY_OF_MONTH, MONTHLY_BY_POSITION, BY_DAY_COUNT, BY_WEEKDAY_COUNT, YEARLY_BY_DAY_OF_MONTH, YEARLY_BY_POSITION };
+ public enum IfcReflectanceMethodEnum { BLINN, FLAT, GLASS, MATT, METAL, MIRROR, PHONG, PLASTIC, STRAUSS, NOTDEFINED };
+ public enum IfcReinforcingBarSurfaceEnum { PLAIN, TEXTURED, NONE };
+ public enum IfcReinforcingBarRoleEnum { MAIN, SHEAR, LIGATURE, STUD, PUNCHING, EDGE, RING, ANCHORING, USERDEFINED, NOTDEFINED };
+ public enum IfcReinforcingBarTypeEnum { MAIN, SHEAR, LIGATURE, STUD, PUNCHING, EDGE, RING, ANCHORING, USERDEFINED, NOTDEFINED };
+ public enum IfcReinforcingMeshTypeEnum { USERDEFINED, NOTDEFINED };
+ public enum IfcResourceConsumptionEnum { CONSUMED, PARTIALLYCONSUMED, NOTCONSUMED, OCCUPIED, PARTIALLYOCCUPIED, NOTOCCUPIED, USERDEFINED, NOTDEFINED };
+ public enum IfcRibPlateDirectionEnum { DIRECTION_X, DIRECTION_Y };
+ public enum IfcRoleEnum { SUPPLIER, MANUFACTURER, CONTRACTOR, SUBCONTRACTOR, ARCHITECT, STRUCTURALENGINEER, COSTENGINEER, CLIENT, BUILDINGOWNER, BUILDINGOPERATOR, MECHANICALENGINEER, ELECTRICALENGINEER, PROJECTMANAGER, FACILITIESMANAGER, CIVILENGINEER, COMMISSIONINGENGINEER, ENGINEER, OWNER, CONSULTANT, CONSTRUCTIONMANAGER, FIELDCONSTRUCTIONMANAGER, RESELLER, USERDEFINED, NOTDEFINED };
+ public enum IfcRoofTypeEnum { FLAT_ROOF, SHED_ROOF, GABLE_ROOF, HIP_ROOF, HIPPED_GABLE_ROOF, GAMBREL_ROOF, MANSARD_ROOF, BARREL_ROOF, RAINBOW_ROOF, BUTTERFLY_ROOF, PAVILION_ROOF, DOME_ROOF, FREEFORM, NOTDEFINED, USERDEFINED };
+ public enum IfcSanitaryTerminalTypeEnum { BATH, BIDET, CISTERN, SHOWER, SINK, SANITARYFOUNTAIN, TOILETPAN, URINAL, WASHHANDBASIN, WCSEAT, USERDEFINED, NOTDEFINED };
+ public enum IfcSectionTypeEnum { UNIFORM, TAPERED };
+ public enum IfcSensorTypeEnum { CO2SENSOR, FIRESENSOR, FLOWSENSOR, GASSENSOR, HEATSENSOR, HUMIDITYSENSOR, LIGHTSENSOR, MOISTURESENSOR, MOVEMENTSENSOR, PRESSURESENSOR, SMOKESENSOR, SOUNDSENSOR, TEMPERATURESENSOR, USERDEFINED, NOTDEFINED };
+ public enum IfcSequenceEnum { START_START, START_FINISH, FINISH_START, FINISH_FINISH, USERDEFINED, NOTDEFINED };
+ public enum IfcServiceLifeTypeEnum { ACTUALSERVICELIFE, EXPECTEDSERVICELIFE, OPTIMISTICREFERENCESERVICELIFE, PESSIMISTICREFERENCESERVICELIFE, REFERENCESERVICELIFE };
+ public enum IfcServiceLifeFactorTypeEnum { A_QUALITYOFCOMPONENTS, B_DESIGNLEVEL, C_WORKEXECUTIONLEVEL, D_INDOORENVIRONMENT, E_OUTDOORENVIRONMENT, F_INUSECONDITIONS, G_MAINTENANCELEVEL, USERDEFINED, NOTDEFINED };
+ public enum IfcShadingDeviceTypeEnum { JALOUSIE, SHUTTER, AWNING, USERDEFINED, NOTDEFINED };
+ public enum IfcSIUnitName { AMPERE, BECQUEREL, CANDELA, COULOMB, CUBIC_METRE, DEGREE_CELSIUS, FARAD, GRAM, GRAY, HENRY, HERTZ, JOULE, KELVIN, LUMEN, LUX, METRE, MOLE, NEWTON, OHM, PASCAL, RADIAN, SECOND, SIEMENS, SIEVERT, SQUARE_METRE, STERADIAN, TESLA, VOLT, WATT, WEBER };
+ public enum IfcSIPrefix { EXA, PETA, TERA, GIGA, MEGA, KILO, HECTO, DECA, DECI, CENTI, MILLI, MICRO, NANO, PICO, FEMTO, ATTO, NONE };
+ public enum IfcSlabTypeEnum { FLOOR, ROOF, LANDING, BASESLAB, USERDEFINED, NOTDEFINED };
+ public enum IfcSolarDeviceTypeEnum { SOLARCOLLECTOR, SOLARPANEL, USERDEFINED, NOTDEFINED };
+ public enum IfcSoundScaleEnum { DBA, DBB, DBC, NC, NR, USERDEFINED, NOTDEFINED };
+ public enum IfcSpaceHeaterTypeEnum { SECTIONALRADIATOR, PANELRADIATOR, TUBULARRADIATOR, CONVECTOR, BASEBOARDHEATER, FINNEDTUBEUNIT, UNITHEATER, USERDEFINED, NOTDEFINED };
+ public enum IfcSpaceTypeEnum { SPACE, PARKING, GFA, INTERNAL, EXTERNAL, USERDEFINED, NOTDEFINED };
+ public enum IfcSpatialZoneTypeEnum { CONSTRUCTION, FIRESAFETY, LIGHTING, OCCUPANCY, SECURITY, THERMAL, VENTILATION, USERDEFINED, NOTDEFINED };
+ public enum IfcStairTypeEnum { STRAIGHT_RUN_STAIR, TWO_STRAIGHT_RUN_STAIR, QUARTER_WINDING_STAIR, QUARTER_TURN_STAIR, HALF_WINDING_STAIR, HALF_TURN_STAIR, TWO_QUARTER_WINDING_STAIR, TWO_QUARTER_TURN_STAIR, THREE_QUARTER_WINDING_STAIR, THREE_QUARTER_TURN_STAIR, SPIRAL_STAIR, DOUBLE_RETURN_STAIR, CURVED_RUN_STAIR, TWO_CURVED_RUN_STAIR, USERDEFINED, NOTDEFINED };
+ public enum IfcStackTerminalTypeEnum { BIRDCAGE, COWL, RAINWATERHOPPER, USERDEFINED, NOTDEFINED };
+ public enum IfcStairFlightTypeEnum { STRAIGHT, WINDER, SPIRAL, CURVED, FREEFORM, USERDEFINED, NOTDEFINED };
+ public enum IfcStateEnum { READWRITE, READONLY, LOCKED, READWRITELOCKED, READONLYLOCKED, NA };
+ public enum IfcStatusEnum { NEW, EXISTING, DEMOLISH, TEMPORARY, OTHER, NOTKNOWN, UNSET };
+ public enum IfcStructuralCurveActivityTypeEnum {CONST, LINEAR, POLYGONAL, EQUIDISTANT, SINUS, PARABOLA, DISCRETE, USERDEFINED, NOTDEFINED}
+ public enum IfcStructuralCurveTypeEnum { RIGID_JOINED_MEMBER, PIN_JOINED_MEMBER, CABLE, TENSION_MEMBER, COMPRESSION_MEMBER, USERDEFINED, NOTDEFINED };
+ public enum IfcStructuralSurfaceActivityTypeEnum {CONST, BILINEAR, DISCRETE, ISOCONTOUR, USERDEFINED, NOTDEFINED}
+ public enum IfcStructuralSurfaceTypeEnum { BENDING_ELEMENT, MEMBRANE_ELEMENT, SHELL, USERDEFINED, NOTDEFINED };
+ public enum IfcSubContractResourceTypeEnum { PURCHASE, WORK, USERDEFINED, NOTDEFINED };
+ public enum IfcSurfaceSide { POSITIVE, NEGATIVE, BOTH };
+ public enum IfcSurfaceTextureEnum { BUMP, OPACITY, REFLECTION, SELFILLUMINATION, SHININESS, SPECULAR, TEXTURE, TRANSPARENCYMAP, NOTDEFINED };
+ public enum IfcSwitchingDeviceTypeEnum { CONTACTOR, EMERGENCYSTOP, STARTER, SWITCHDISCONNECTOR, TOGGLESWITCH, USERDEFINED, NOTDEFINED };
+ public enum IfcSystemFurnitureElementTypeEnum { PANEL, WORKSURFACE, USERDEFINED, NOTDEFINED };
+ public enum IfcTankTypeEnum { EXPANSION, PRESSUREVESSEL, USERDEFINED, NOTDEFINED, PREFORMED, SECTIONAL, }; //IFC4 DELETED
+ public enum IfcTaskTypeEnum { ATTENDANCE, CONSTRUCTION, DEMOLITION, DISMANTLE, DISPOSAL, INSTALLATION, LOGISTIC, MAINTENANCE, MOVE, OPERATION, REMOVAL, RENOVATION, USERDEFINED, NOTDEFINED }; //IFC4
+ public enum IfcTaskDurationEnum { ELAPSEDTIME, WORKTIME, NOTDEFINED };
+ public enum IfcTendonTypeEnum { STRAND, WIRE, BAR, COATED, USERDEFINED, NOTDEFINED };
+ public enum IfcTendonAnchorTypeEnum { COUPLER, FIXED_END, TENSIONING_END, USERDEFINED, NOTDEFINED };
+ public enum IfcTextPath { LEFT, RIGHT, UP, DOWN };
+ public enum IfcThermalLoadSourceEnum { PEOPLE, LIGHTING, EQUIPMENT, VENTILATIONINDOORAIR, VENTILATIONOUTSIDEAIR, RECIRCULATEDAIR, EXHAUSTAIR, AIREXCHANGERATE, DRYBULBTEMPERATURE, RELATIVEHUMIDITY, INFILTRATION, USERDEFINED, NOTDEFINED };
+ public enum IfcThermalLoadTypeEnum { SENSIBLE, LATENT, RADIANT, NOTDEFINED };
+ public enum IfcTimeSeriesDataTypeEnum { CONTINUOUS, DISCRETE, DISCRETEBINARY, PIECEWISEBINARY, PIECEWISECONSTANT, PIECEWISECONTINUOUS, NOTDEFINED };
+ public enum IfcTimeSeriesScheduleTypeEnum { ANNUAL, MONTHLY, WEEKLY, DAILY, USERDEFINED, NOTDEFINED };
+ public enum IfcTransformerTypeEnum { CURRENT, FREQUENCY, VOLTAGE, USERDEFINED, NOTDEFINED };
+ public enum IfcTransitionCode { DISCONTINUOUS, CONTINUOUS, CONTSAMEGRADIENT, CONTSAMEGRADIENTSAMECURVATURE };
+ public enum IfcTransportElementTypeEnum { ELEVATOR, ESCALATOR, MOVINGWALKWAY, USERDEFINED, NOTDEFINED };
+ public enum IfcTrimmingPreference { CARTESIAN, PARAMETER, UNSPECIFIED };
+ public enum IfcTubeBundleTypeEnum { FINNED, USERDEFINED, NOTDEFINED };
+ public enum IfcUnitaryControlElementTypeEnum { ALARMPANEL, CONTROLPANEL, GASDETECTIONPANEL, INDICATORPANEL, MIMICPANEL, HUMIDISTAT, THERMOSTAT, WEATHERSTATION, USERDEFINED, NOTDEFINED };
+ public enum IfcUnitaryEquipmentTypeEnum { AIRHANDLER, AIRCONDITIONINGUNIT, SPLITSYSTEM, ROOFTOPUNIT, USERDEFINED, NOTDEFINED };
+ public enum IfcUnitEnum { ABSORBEDDOSEUNIT, AMOUNTOFSUBSTANCEUNIT, AREAUNIT, DOSEEQUIVALENTUNIT, ELECTRICCAPACITANCEUNIT, ELECTRICCHARGEUNIT, ELECTRICCONDUCTANCEUNIT, ELECTRICCURRENTUNIT, ELECTRICRESISTANCEUNIT, ELECTRICVOLTAGEUNIT, ENERGYUNIT, FORCEUNIT, FREQUENCYUNIT, ILLUMINANCEUNIT, INDUCTANCEUNIT, LENGTHUNIT, LUMINOUSFLUXUNIT, LUMINOUSINTENSITYUNIT, MAGNETICFLUXDENSITYUNIT, MAGNETICFLUXUNIT, MASSUNIT, PLANEANGLEUNIT, POWERUNIT, PRESSUREUNIT, RADIOACTIVITYUNIT, SOLIDANGLEUNIT, THERMODYNAMICTEMPERATUREUNIT, TIMEUNIT, VOLUMEUNIT, USERDEFINED };
+ public enum IfcValveTypeEnum { AIRRELEASE, ANTIVACUUM, CHANGEOVER, CHECK, COMMISSIONING, DIVERTING, DRAWOFFCOCK, DOUBLECHECK, DOUBLEREGULATING, FAUCET, FLUSHING, GASCOCK, GASTAP, ISOLATING, MIXING, PRESSUREREDUCING, PRESSURERELIEF, REGULATING, SAFETYCUTOFF, STEAMTRAP, STOPCOCK, USERDEFINED, NOTDEFINED };
+ public enum IfcVibrationIsolatorTypeEnum { COMPRESSION, SPRING, USERDEFINED, NOTDEFINED };
+ public enum IfcVoidingFeatureTypeEnum { CUTOUT, NOTCH, HOLE, MITER, CHAMFER, EDGE, USERDEFINED, NOTDEFINED };
+ public enum IfcWallTypeEnum { STANDARD, ELEMENTEDWALL, MOVABLE, PARAPET, PARTITIONING, PLUMBINGWALL, POLYGONAL, SHEAR, SOLIDWALL, USERDEFINED, NOTDEFINED }; //IFC4 change STANDARD, POLYGONAL, ELEMENTEDWALL
+ public enum IfcWasteTerminalTypeEnum { FLOORTRAP, FLOORWASTE, GULLYSUMP, GULLYTRAP, ROOFDRAIN, WASTEDISPOSALUNIT, WASTETRAP, USERDEFINED, NOTDEFINED }; // IFC4 GREASEINTERCEPTOR, OILINTERCEPTOR, PETROLINTERCEPTOR
+ public enum IfcWindowPanelOperationEnum { SIDEHUNGRIGHTHAND, SIDEHUNGLEFTHAND, TILTANDTURNRIGHTHAND, TILTANDTURNLEFTHAND, TOPHUNG, BOTTOMHUNG, PIVOTHORIZONTAL, PIVOTVERTICAL, SLIDINGHORIZONTAL, SLIDINGVERTICAL, REMOVABLECASEMENT, FIXEDCASEMENT, OTHEROPERATION, NOTDEFINED };
+ public enum IfcWindowPanelPositionEnum { LEFT, MIDDLE, RIGHT, BOTTOM, TOP, NOTDEFINED };
+ public enum IfcWindowStyleConstructionEnum { ALUMINIUM, HIGH_GRADE_STEEL, STEEL, WOOD, ALUMINIUM_WOOD, PLASTIC, OTHER_CONSTRUCTION, NOTDEFINED };
+ public enum IfcWindowStyleOperationEnum { SINGLE_PANEL, DOUBLE_PANEL_VERTICAL, DOUBLE_PANEL_HORIZONTAL, TRIPLE_PANEL_VERTICAL, TRIPLE_PANEL_BOTTOM, TRIPLE_PANEL_TOP, TRIPLE_PANEL_LEFT, TRIPLE_PANEL_RIGHT, TRIPLE_PANEL_HORIZONTAL, USERDEFINED, NOTDEFINED };
+ public enum IfcWindowTypeEnum { WINDOW, SKYLIGHT, LIGHTDOME, USERDEFINED, NOTDEFINED };
+ public enum IfcWindowTypePartitioningEnum { SINGLE_PANEL, DOUBLE_PANEL_VERTICAL, DOUBLE_PANEL_HORIZONTAL, TRIPLE_PANEL_VERTICAL, TRIPLE_PANEL_BOTTOM, TRIPLE_PANEL_TOP, TRIPLE_PANEL_LEFT, TRIPLE_PANEL_RIGHT, TRIPLE_PANEL_HORIZONTAL, USERDEFINED, NOTDEFINED };
+ public enum IfcWorkCalendarTypeEnum { FIRSTSHIFT, SECONDSHIFT, THIRDSHIFT, USERDEFINED, NOTDEFINED };
+ public enum IfcWorkControlTypeEnum { ACTUAL, BASELINE, PLANNED, USERDEFINED, NOTDEFINED };
+ public enum IfcWorkPlanTypeEnum { ACTUAL, BASELINE, PLANNED, USERDEFINED, NOTDEFINED };
+ public enum IfcWorkScheduleTypeEnum { ACTUAL, BASELINE, PLANNED, USERDEFINED, NOTDEFINED };
+
+ public enum PEnum_DuctConnectionType { BEADEDSLEEVE, COMPRESSION, CRIMP, DRAWBAND, DRIVESLIP, FLANGED, OUTSIDESLEEVE, SLIPON, SOLDERED, SSLIP, STANDINGSEAM, SWEDGE, WELDED, OTHER, NONE, USERDEFINED, NOTDEFINED }
+
+}
diff --git a/IFC/IFC A.cs b/IFC/IFC A.cs
new file mode 100644
index 0000000..4f3fb82
--- /dev/null
+++ b/IFC/IFC A.cs
@@ -0,0 +1,1075 @@
+// MIT License
+// Copyright (c) 2016 Geometry Gym Pty Ltd
+
+// Permission is hereby granted, free of charge, to any person obtaining a copy of this software
+// and associated documentation files (the "Software"), to deal in the Software without restriction,
+// including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense,
+// and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so,
+// subject to the following conditions:
+
+// The above copyright notice and this permission notice shall be included in all copies or substantial
+// portions of the Software.
+
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT
+// LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+// IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+// WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+// SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+using System;
+using System.Collections.Generic;
+using System.Text;
+using System.Reflection;
+using System.IO;
+using System.ComponentModel;
+using System.Linq;
+using System.Drawing;
+using GeometryGym.STEP;
+
+
+namespace GeometryGym.Ifc
+{
+ public class IfcActionRequest : IfcControl
+ {
+ //internal string mRequestID;// : IfcIdentifier; IFC4 relocated
+ internal IfcActionRequest(IfcActionRequest i) : base(i) { }
+ internal IfcActionRequest() : base() { }
+ internal static IfcActionRequest Parse(string strDef,Schema schema) { IfcActionRequest r = new IfcActionRequest(); int ipos = 0; parseFields(r, ParserSTEP.SplitLineFields(strDef), ref ipos,schema); return r; }
+ internal static void parseFields(IfcActionRequest r,List arrFields, ref int ipos,Schema schema)
+ {
+ IfcControl.parseFields(r,arrFields, ref ipos,schema);
+ if(schema == Schema.IFC2x3)
+ r.mIdentification = arrFields[ipos++].Replace("'","");
+ }
+ protected override string BuildString() { return base.BuildString() + (mDatabase.mSchema == Schema.IFC2x3 ? ",'" + mIdentification + "'" : ""); }
+ }
+ public class IfcActor : IfcObject // SUPERTYPE OF(IfcOccupant)
+ {
+ internal int mTheActor;// : IfcActorSelect;
+ //INVERSE
+ internal List mIsActingUpon = new List();// : SET [0:?] OF IfcRelAssignsToActor FOR RelatingActor;
+
+ internal IfcActor(IfcActor o) : base(o) { }
+ internal IfcActor() : base() { }
+ internal IfcActor(IfcActorSelect a) : base(a.Database)
+ {
+ if(mDatabase.mModelView != ModelView.If2x3NotAssigned && mDatabase.mModelView != ModelView.Ifc4NotAssigned )
+ throw new Exception("Invalid Model View for IfcActor : " + mDatabase.ModelView.ToString());
+ mTheActor = a.Index;
+ }
+ internal static IfcActor Parse(string strDef) { IfcActor a = new IfcActor(); int ipos = 0; parseFields(a, ParserSTEP.SplitLineFields(strDef), ref ipos); return a; }
+ internal static void parseFields(IfcActor a, List arrFields, ref int ipos) { IfcObject.parseFields(a, arrFields, ref ipos); a.mTheActor = ParserSTEP.ParseLink(arrFields[ipos++]); }
+ protected override string BuildString() { return base.BuildString() + "," + ParserSTEP.LinkToString(mTheActor); }
+ }
+ public partial class IfcActorRole : BaseClassIfc, IfcResourceObjectSelect
+ {
+ internal IfcRoleEnum mRole = IfcRoleEnum.NOTDEFINED;// : OPTIONAL IfcRoleEnum
+ internal string mUserDefinedRole = "$";// : OPTIONAL IfcLabel
+ internal string mDescription = "$";// : OPTIONAL IfcText;
+ //INVERSE
+ internal List mHasExternalReferences = new List(); //IFC4
+ internal List mHasConstraintRelationships = new List(); //gg
+
+ public IfcRoleEnum Role { get { return mRole; } set { mRole = value; } }
+ public string UserDefinedRole { get { return (mUserDefinedRole == "$" ? "" : ParserIfc.Decode(mUserDefinedRole)); } set { mUserDefinedRole = (string.IsNullOrEmpty(value) ? "$" : ParserIfc.Encode(value.Replace("'", ""))); } }
+ public string Description { get { return (mDescription == "$" ? "" : ParserIfc.Decode(mDescription)); } set { mDescription = (string.IsNullOrEmpty(value) ? "$" : ParserIfc.Encode(value.Replace("'", ""))); } }
+
+ public List HasExternalReferences { get { return mHasExternalReferences; } }
+ public List HasConstraintRelationships { get { return mHasConstraintRelationships; } }
+
+ internal IfcActorRole() : base() { }
+ internal IfcActorRole(IfcActorRole o) : base() { mRole = o.mRole; mDescription = o.mDescription; mUserDefinedRole = o.mUserDefinedRole; }
+
+ internal static void parseFields(IfcActorRole a,List arrFields, ref int ipos)
+ {
+ string str = arrFields[ipos++];
+ if (str != "$")
+ a.mRole = (string.Compare(str, "COMISSIONINGENGINEER", true) == 0 ? IfcRoleEnum.COMMISSIONINGENGINEER : (IfcRoleEnum)Enum.Parse(typeof(IfcRoleEnum), str.Replace(".", "")));
+ a.mUserDefinedRole = arrFields[ipos++].Replace("'","");
+ a.mDescription = arrFields[ipos++].Replace("'","");
+ }
+ internal static IfcActorRole Parse(string strDef) { IfcActorRole a = new IfcActorRole(); int ipos = 0; parseFields(a, ParserSTEP.SplitLineFields(strDef), ref ipos); return a; }
+ protected override string BuildString() { return base.BuildString() + ",." + (mDatabase.mSchema == Schema.IFC2x3 && mRole == IfcRoleEnum.COMMISSIONINGENGINEER ? "COMISSIONINGENGINEER" : mRole.ToString()) + (mUserDefinedRole == "$" ? ".,$," : ".,'" + mUserDefinedRole + "',") + (mDescription == "$" ? "$" : "'" + mDescription + "'") ; }
+ }
+ public interface IfcActorSelect : IfcInterface { }// IfcOrganization, IfcPerson, IfcPersonAndOrganization);
+ public partial class IfcActuator : IfcDistributionControlElement //IFC4
+ {
+ public override string KeyWord { get { return mDatabase.mSchema == Schema.IFC2x3 ? base.KeyWord : "IFCACTUATOR"; } }
+
+ internal IfcActuatorTypeEnum mPredefinedType = IfcActuatorTypeEnum.NOTDEFINED;
+ public IfcActuatorTypeEnum PredefinedType { get { return mPredefinedType; } set { mPredefinedType = value; } }
+
+ internal IfcActuator() : base() { }
+ internal IfcActuator(IfcActuator a) : base(a) { mPredefinedType = a.mPredefinedType; }
+ internal IfcActuator(IfcProduct host, IfcObjectPlacement placement, IfcProductRepresentation representation, IfcDistributionSystem system) : base(host, placement,representation, system) { }
+
+ internal static void parseFields(IfcActuator a, List arrFields, ref int ipos)
+ {
+ IfcDistributionControlElement.parseFields(a, arrFields, ref ipos);
+ string s = arrFields[ipos++];
+ if (s.StartsWith("."))
+ a.mPredefinedType = (IfcActuatorTypeEnum)Enum.Parse(typeof(IfcActuatorTypeEnum), s.Replace(".", ""));
+ }
+ internal new static IfcActuator Parse(string strDef) { IfcActuator d = new IfcActuator(); int ipos = 0; parseFields(d, ParserSTEP.SplitLineFields(strDef), ref ipos); return d; }
+ protected override string BuildString()
+ {
+ return base.BuildString() + (mDatabase.mSchema == Schema.IFC2x3 ? "" : (mPredefinedType == IfcActuatorTypeEnum.NOTDEFINED ? ",$" : ",." + mPredefinedType.ToString() + "."));
+ }
+ }
+ public partial class IfcActuatorType : IfcDistributionControlElementType
+ {
+ internal IfcActuatorTypeEnum mPredefinedType = IfcActuatorTypeEnum.NOTDEFINED;// : IfcActuatorTypeEnum;
+ public IfcActuatorTypeEnum PredefinedType { get { return mPredefinedType; } set { mPredefinedType = value; } }
+
+ internal IfcActuatorType() : base() { }
+ internal IfcActuatorType(IfcActuatorType t) : base(t) { mPredefinedType = t.mPredefinedType; }
+ internal IfcActuatorType(DatabaseIfc m, string name, IfcActuatorTypeEnum t) : base(m) { Name = name; mPredefinedType = t; }
+ internal static void parseFields(IfcActuatorType t,List arrFields, ref int ipos) { IfcDistributionControlElementType.parseFields(t,arrFields, ref ipos); t.mPredefinedType = (IfcActuatorTypeEnum)Enum.Parse(typeof(IfcActuatorTypeEnum),arrFields[ipos++].Replace(".","")); }
+ internal new static IfcActuatorType Parse(string strDef) { IfcActuatorType t = new IfcActuatorType(); int ipos = 0; parseFields(t, ParserSTEP.SplitLineFields(strDef), ref ipos); return t; }
+ protected override string BuildString() { return base.BuildString() + ",." + mPredefinedType.ToString() + "."; }
+ }
+ public abstract partial class IfcAddress : BaseClassIfc //ABSTRACT SUPERTYPE OF(ONEOF(IfcPostalAddress, IfcTelecomAddress));
+ {
+ internal IfcAddressTypeEnum mPurpose = IfcAddressTypeEnum.NOTDEFINED;// : OPTIONAL IfcAddressTypeEnum
+ internal string mDescription = "$";// : OPTIONAL IfcText;
+ internal string mUserDefinedPurpose = "$";// : OPTIONAL IfcLabel
+
+ public IfcAddressTypeEnum Purpose { get { return mPurpose; } set { mPurpose = value; } }
+ public string Description { get { return mDescription == "$" ? "" : ParserIfc.Decode(mDescription); } set { mDescription = (string.IsNullOrEmpty(value) ? "$" : ParserIfc.Encode(value.Replace("'", ""))); } }
+ public string UserDefinedPurpose { get { return mUserDefinedPurpose == "$" ? "" : ParserIfc.Decode(mUserDefinedPurpose); } set { mUserDefinedPurpose = (string.IsNullOrEmpty(value) ? "$" : ParserIfc.Encode(value.Replace("'", ""))); } }
+
+ internal IfcAddress() : base() { }
+ protected IfcAddress(IfcAddress o) : base()
+ {
+ mPurpose = o.mPurpose;
+ mDescription = o.mDescription;
+ mUserDefinedPurpose = o.mUserDefinedPurpose;
+ }
+ protected IfcAddress(DatabaseIfc m, IfcAddressTypeEnum purpose) : base(m) { mPurpose = purpose; }
+ internal static void parseFields(IfcAddress a, List arrFields, ref int ipos)
+ {
+ string str = arrFields[ipos++];
+ if (str != "$")
+ a.mPurpose = (IfcAddressTypeEnum)Enum.Parse(typeof(IfcAddressTypeEnum), str.Replace(".", ""));
+ a.mDescription = arrFields[ipos++].Replace("'", "");
+ a.mUserDefinedPurpose = arrFields[ipos++].Replace("'", "");
+ }
+ protected override string BuildString() { return base.BuildString() + (mPurpose == IfcAddressTypeEnum.NOTDEFINED ? ",$," : ",." + mPurpose.ToString() + ".,") + (mDescription == "$" ? "$," : "'" + mDescription + "',") + (mUserDefinedPurpose == "$" ? "$" : "'" + mUserDefinedPurpose + "'"); }
+ }
+ public partial class IfcAdvancedBrep : IfcManifoldSolidBrep // IFC4
+ {
+ internal IfcAdvancedBrep() : base() { }
+ internal IfcAdvancedBrep(IfcAdvancedBrep p) : base(p) { }
+ public IfcAdvancedBrep(List faces) : base(new IfcClosedShell(faces.ConvertAll(x => (IfcFace)x))) { }
+ internal IfcAdvancedBrep(IfcClosedShell s) : base(s) { }
+
+ internal static IfcAdvancedBrep Parse(string strDef) { IfcAdvancedBrep b = new IfcAdvancedBrep(); int ipos = 0; parseFields(b, ParserSTEP.SplitLineFields(strDef), ref ipos); return b; }
+ internal static void parseFields(IfcAdvancedBrep b, List arrFields, ref int ipos) { IfcManifoldSolidBrep.parseFields(b, arrFields, ref ipos); }
+ protected override string BuildString() { return (mDatabase.mSchema == Schema.IFC2x3 ? "" : base.BuildString()); }
+ }
+ public partial class IfcAdvancedBrepWithVoids : IfcAdvancedBrep
+ {
+ private List mVoids = new List();// : SET [1:?] OF IfcClosedShell
+
+ internal List Voids { get { return mVoids.ConvertAll(x => mDatabase.mIfcObjects[x] as IfcClosedShell); } }
+ internal IfcAdvancedBrepWithVoids() : base() { }
+ internal IfcAdvancedBrepWithVoids(IfcAdvancedBrepWithVoids p) : base((IfcAdvancedBrep)p) { mVoids = new List(p.mVoids.ToArray()); }
+
+ internal new static IfcAdvancedBrepWithVoids Parse(string strDef) { IfcAdvancedBrepWithVoids b = new IfcAdvancedBrepWithVoids(); int ipos = 0; parseFields(b, ParserSTEP.SplitLineFields(strDef), ref ipos); return b; }
+ internal static void parseFields(IfcAdvancedBrepWithVoids b, List arrFields, ref int ipos) { IfcAdvancedBrep.parseFields(b, arrFields, ref ipos); b.mVoids = ParserSTEP.SplitListLinks(arrFields[ipos++]); }
+ protected override string BuildString()
+ {
+ string str = base.BuildString() + ",(";
+ if (mVoids.Count > 0)
+ {
+ str += ParserSTEP.LinkToString(mVoids[0]);
+ for (int icounter = 1; icounter < mVoids.Count; icounter++)
+ str += "," + ParserSTEP.LinkToString(mVoids[icounter]);
+ }
+ return str + ")";
+ }
+ }
+ public partial class IfcAdvancedFace : IfcFaceSurface
+ {
+ internal IfcAdvancedFace() : base() { }
+ internal IfcAdvancedFace(IfcAdvancedFace i) : base(i) { }
+ public IfcAdvancedFace(IfcFaceOuterBound bound, IfcSurface f, bool sense) : base(bound, f, sense) { }
+ public IfcAdvancedFace(List bounds, IfcSurface f, bool sense) : base(bounds, f, sense) { }
+ public IfcAdvancedFace(IfcFaceOuterBound outer, IfcFaceBound inner, IfcSurface f, bool sense) : base(outer,inner, f, sense) { }
+ internal new static IfcAdvancedFace Parse(string strDef) { IfcAdvancedFace f = new IfcAdvancedFace(); int ipos = 0; parseFields(f, ParserSTEP.SplitLineFields(strDef), ref ipos); return f; }
+ internal static void parseFields(IfcAdvancedFace f, List arrFields, ref int ipos) { IfcFaceSurface.parseFields(f, arrFields, ref ipos); }
+ protected override string BuildString() { return (mDatabase.mSchema == Schema.IFC2x3 ? "" : base.BuildString()); }
+ }
+ public class IfcAirTerminal : IfcFlowTerminal //IFC4
+ {
+ internal IfcAirTerminalTypeEnum mPredefinedType = IfcAirTerminalTypeEnum.NOTDEFINED;// OPTIONAL : IfcAirTerminalTypeEnum;
+ public IfcAirTerminalTypeEnum PredefinedType { get { return mPredefinedType; } set { mPredefinedType = value; } }
+
+ internal IfcAirTerminal() : base() { }
+ internal IfcAirTerminal(IfcAirTerminal t) : base(t) { mPredefinedType = t.mPredefinedType; }
+ internal IfcAirTerminal(IfcProduct host, IfcObjectPlacement placement, IfcProductRepresentation representation, IfcDistributionSystem system) : base(host, placement, representation, system) { }
+ internal static void parseFields(IfcAirTerminal s, List arrFields, ref int ipos)
+ {
+ IfcFlowTerminal.parseFields(s, arrFields, ref ipos);
+ string str = arrFields[ipos++];
+ if (str[0] == '.')
+ s.mPredefinedType = (IfcAirTerminalTypeEnum)Enum.Parse(typeof(IfcAirTerminalTypeEnum), str.Substring(1, str.Length - 2));
+ }
+ internal new static IfcAirTerminal Parse(string strDef) { IfcAirTerminal s = new IfcAirTerminal(); int ipos = 0; parseFields(s, ParserSTEP.SplitLineFields(strDef), ref ipos); return s; }
+ protected override string BuildString() { return base.BuildString() + (mDatabase.mSchema == Schema.IFC2x3 ? "" : (mPredefinedType == IfcAirTerminalTypeEnum.NOTDEFINED ? ",$" : ",." + mPredefinedType.ToString() + ".")); }
+
+ }
+ public class IfcAirTerminalBox : IfcFlowController //IFC4
+ {
+ internal IfcAirTerminalBoxTypeEnum mPredefinedType = IfcAirTerminalBoxTypeEnum.NOTDEFINED;// OPTIONAL : IfcAirTerminalBoxTypeEnum;
+ public IfcAirTerminalBoxTypeEnum PredefinedType { get { return mPredefinedType; } set { mPredefinedType = value; } }
+
+ internal IfcAirTerminalBox() : base() { }
+ internal IfcAirTerminalBox(IfcAirTerminalBox b) : base(b) { mPredefinedType = b.mPredefinedType; }
+ internal IfcAirTerminalBox(IfcProduct host, IfcObjectPlacement placement, IfcProductRepresentation representation, IfcDistributionSystem system) : base(host, placement, representation, system) { }
+
+ internal static void parseFields(IfcAirTerminalBox s, List arrFields, ref int ipos)
+ {
+ IfcEnergyConversionDevice.parseFields(s, arrFields, ref ipos);
+ string str = arrFields[ipos++];
+ if (str[0] == '.')
+ s.mPredefinedType = (IfcAirTerminalBoxTypeEnum)Enum.Parse(typeof(IfcAirTerminalBoxTypeEnum), str);
+ }
+ internal new static IfcAirTerminalBox Parse(string strDef) { IfcAirTerminalBox s = new IfcAirTerminalBox(); int ipos = 0; parseFields(s, ParserSTEP.SplitLineFields(strDef), ref ipos); return s; }
+ protected override string BuildString()
+ {
+ return base.BuildString() + (mDatabase.mSchema == Schema.IFC2x3 ? "" : (mPredefinedType == IfcAirTerminalBoxTypeEnum.NOTDEFINED ? ",$" : ",." + mPredefinedType.ToString() + "."));
+ }
+ }
+ public class IfcAirTerminalBoxType : IfcFlowControllerType
+ {
+ internal IfcAirTerminalBoxTypeEnum mPredefinedType = IfcAirTerminalBoxTypeEnum.NOTDEFINED;// : IfcAirTerminalBoxTypeEnum;
+ public IfcAirTerminalBoxTypeEnum PredefinedType { get { return mPredefinedType;} set { mPredefinedType = value; } }
+
+ internal IfcAirTerminalBoxType() : base() { }
+ internal IfcAirTerminalBoxType(IfcAirTerminalBoxType t) : base(t) { mPredefinedType = t.mPredefinedType; }
+ internal IfcAirTerminalBoxType(DatabaseIfc m, string name, IfcAirTerminalBoxTypeEnum type) : base(m) { Name = name; mPredefinedType = type; }
+ internal static void parseFields(IfcAirTerminalBoxType t,List arrFields, ref int ipos) { IfcFlowControllerType.parseFields(t,arrFields, ref ipos); t.mPredefinedType = (IfcAirTerminalBoxTypeEnum)Enum.Parse(typeof(IfcAirTerminalBoxTypeEnum), arrFields[ipos++].Replace(".", "")); }
+ internal new static IfcAirTerminalBoxType Parse(string strDef) { IfcAirTerminalBoxType t = new IfcAirTerminalBoxType(); int ipos = 0; parseFields(t,ParserSTEP.SplitLineFields(strDef), ref ipos); return t; }
+ protected override string BuildString() { return base.BuildString() + ",." + mPredefinedType.ToString() + "."; }
+ }
+ public partial class IfcAirTerminalType : IfcFlowTerminalType
+ {
+ internal IfcAirTerminalTypeEnum mPredefinedType = IfcAirTerminalTypeEnum.NOTDEFINED;// : IfcAirTerminalBoxTypeEnum;
+ public IfcAirTerminalTypeEnum PredefinedType { get { return mPredefinedType; } set { mPredefinedType = value; } }
+
+ internal IfcAirTerminalType(IfcAirTerminalType t) : base(t) { mPredefinedType = t.mPredefinedType; }
+ internal IfcAirTerminalType() : base() { }
+ public IfcAirTerminalType(DatabaseIfc m, string name, IfcAirTerminalTypeEnum type) : base(m) { Name = name; mPredefinedType = type; }
+ internal static void parseFields(IfcAirTerminalType t,List arrFields, ref int ipos) { IfcFlowControllerType.parseFields(t,arrFields, ref ipos); t.mPredefinedType = (IfcAirTerminalTypeEnum)Enum.Parse(typeof(IfcAirTerminalTypeEnum), arrFields[ipos++].Replace(".", "")); }
+ internal new static IfcAirTerminalType Parse(string strDef) { IfcAirTerminalType t = new IfcAirTerminalType(); int ipos = 0; parseFields(t, ParserSTEP.SplitLineFields(strDef), ref ipos); return t; }
+ protected override string BuildString() { return base.BuildString() + ",." + mPredefinedType.ToString() + "."; }
+ }
+ public class IfcAirToAirHeatRecovery : IfcEnergyConversionDevice //IFC4
+ {
+ internal IfcAirToAirHeatRecoveryTypeEnum mPredefinedType = IfcAirToAirHeatRecoveryTypeEnum.NOTDEFINED;
+ public IfcAirToAirHeatRecoveryTypeEnum PredefinedType { get { return mPredefinedType; } set { mPredefinedType = value; } }
+
+ internal IfcAirToAirHeatRecovery() : base() { }
+ internal IfcAirToAirHeatRecovery(IfcAirToAirHeatRecovery a) : base(a) { mPredefinedType = a.mPredefinedType; }
+ internal IfcAirToAirHeatRecovery(IfcProduct host, IfcObjectPlacement placement, IfcProductRepresentation representation, IfcDistributionSystem system) : base(host, placement, representation, system) { }
+ internal static void parseFields(IfcAirToAirHeatRecovery a, List arrFields, ref int ipos)
+ {
+ IfcDistributionControlElement.parseFields(a, arrFields, ref ipos);
+ string s = arrFields[ipos++];
+ if (s.StartsWith("."))
+ a.mPredefinedType = (IfcAirToAirHeatRecoveryTypeEnum)Enum.Parse(typeof(IfcAirToAirHeatRecoveryTypeEnum), s.Replace(".", ""));
+ }
+ internal new static IfcAirToAirHeatRecovery Parse(string strDef) { IfcAirToAirHeatRecovery d = new IfcAirToAirHeatRecovery(); int ipos = 0; parseFields(d, ParserSTEP.SplitLineFields(strDef), ref ipos); return d; }
+ protected override string BuildString()
+ {
+ return base.BuildString() + (mPredefinedType == IfcAirToAirHeatRecoveryTypeEnum.NOTDEFINED ? ",$" : ",." + mPredefinedType.ToString() + ".");
+ }
+ }
+ public class IfcAirToAirHeatRecoveryType : IfcEnergyConversionDeviceType
+ {
+ internal IfcAirToAirHeatRecoveryTypeEnum mPredefinedType = IfcAirToAirHeatRecoveryTypeEnum.NOTDEFINED;// : IfcAirToAirHeatRecoveryTypeEnum;
+ public IfcAirToAirHeatRecoveryTypeEnum PredefinedType { get { return mPredefinedType; } set { mPredefinedType = value; } }
+
+ internal IfcAirToAirHeatRecoveryType(IfcAirToAirHeatRecoveryType be) : base(be) { mPredefinedType = be.mPredefinedType; }
+ internal IfcAirToAirHeatRecoveryType() : base() { }
+ internal IfcAirToAirHeatRecoveryType(DatabaseIfc m, string name, IfcAirToAirHeatRecoveryTypeEnum type) : base(m) { Name = name; mPredefinedType = type; }
+ internal static void parseFields(IfcAirToAirHeatRecoveryType t,List arrFields, ref int ipos) { IfcEnergyConversionDeviceType.parseFields(t,arrFields, ref ipos); t.mPredefinedType = (IfcAirToAirHeatRecoveryTypeEnum)Enum.Parse(typeof(IfcAirToAirHeatRecoveryTypeEnum), arrFields[ipos++].Replace(".", "")); }
+ internal new static IfcAirToAirHeatRecoveryType Parse(string strDef) { IfcAirToAirHeatRecoveryType t = new IfcAirToAirHeatRecoveryType(); int ipos = 0; parseFields(t, ParserSTEP.SplitLineFields(strDef), ref ipos); return t; }
+ protected override string BuildString() { return base.BuildString() + ",." + mPredefinedType.ToString() + "."; }
+ }
+ public class IfcAlarm : IfcDistributionControlElement //IFC4
+ {
+ internal IfcAlarmTypeEnum mPredefinedType = IfcAlarmTypeEnum.NOTDEFINED;
+ internal IfcAlarmTypeEnum PredefinedType { get { return mPredefinedType; } set { mPredefinedType = value; } }
+
+ internal IfcAlarm() : base() { }
+ internal IfcAlarm(IfcAlarm a) : base(a) { mPredefinedType = a.mPredefinedType; }
+ internal IfcAlarm(IfcProduct host, IfcObjectPlacement placement, IfcProductRepresentation representation, IfcDistributionSystem system) : base(host, placement, representation, system) { }
+
+ internal static void parseFields(IfcAlarm a, List arrFields, ref int ipos)
+ {
+ IfcDistributionControlElement.parseFields(a, arrFields, ref ipos);
+ string s = arrFields[ipos++];
+ if (s.StartsWith("."))
+ a.mPredefinedType = (IfcAlarmTypeEnum)Enum.Parse(typeof(IfcAlarmTypeEnum), s.Replace(".", ""));
+ }
+ internal new static IfcAlarm Parse(string strDef) { IfcAlarm a = new IfcAlarm(); int ipos = 0; parseFields(a, ParserSTEP.SplitLineFields(strDef), ref ipos); return a; }
+ protected override string BuildString()
+ {
+ return base.BuildString() + (mDatabase.mSchema == Schema.IFC2x3 ? "" : (mPredefinedType == IfcAlarmTypeEnum.NOTDEFINED ? ",$" : ",." + mPredefinedType.ToString() + "."));
+ }
+ }
+ public class IfcAlarmType : IfcDistributionControlElementType
+ {
+ internal IfcAlarmTypeEnum mPredefinedType = IfcAlarmTypeEnum.NOTDEFINED;// : IfcAlarmTypeEnum;
+ public IfcAlarmTypeEnum PredefinedType { get { return mPredefinedType; } set { mPredefinedType = value; } }
+
+ internal IfcAlarmType(IfcAlarmType t) : base(t) { mPredefinedType = t.mPredefinedType; }
+ internal IfcAlarmType() : base() { }
+ internal IfcAlarmType(DatabaseIfc m, string name, IfcAlarmTypeEnum t) : base(m) { Name = name; mPredefinedType = t; }
+ internal static void parseFields(IfcAlarmType t,List arrFields, ref int ipos) { IfcDistributionControlElementType.parseFields(t,arrFields, ref ipos); t.mPredefinedType = (IfcAlarmTypeEnum)Enum.Parse(typeof(IfcAlarmTypeEnum), arrFields[ipos++].Replace(".", "")); }
+ internal new static IfcAlarmType Parse(string strDef) { IfcAlarmType t = new IfcAlarmType(); int ipos = 0; parseFields(t, ParserSTEP.SplitLineFields(strDef), ref ipos); return t; }
+ protected override string BuildString() { return base.BuildString() + ",." + mPredefinedType.ToString() + "."; }
+ }
+ public partial class IfcAlignment : IfcPositioningElement //IFC4.1
+ {
+ internal IfcAlignmentTypeEnum mPredefinedType;// : OPTIONAL IfcAlignmentTypeEnum;
+ public IfcAlignmentTypeEnum PredefinedType { get { return mPredefinedType; } set { mPredefinedType = value; } }
+ internal int mHorizontal = 0;// : OPTIONAL IfcAlignment2DHorizontal;
+ internal int mVertical = 0;// : OPTIONAL IfcAlignment2DVertical;
+ internal string mLinearRefMethod = "$";// : OPTIONAL IfcLabel;
+
+ internal IfcAlignment() : base() { }
+ internal IfcAlignment(IfcAlignment a) : base(a) { mPredefinedType = a.mPredefinedType; mLinearRefMethod = a.mLinearRefMethod; }
+ internal static void parseFields(IfcAlignment a, List arrFields, ref int ipos)
+ {
+ IfcPositioningElement.parseFields(a, arrFields, ref ipos);
+ string str = arrFields[ipos++];
+ if(str != "$")
+ a.mPredefinedType = (IfcAlignmentTypeEnum)Enum.Parse(typeof(IfcAlignmentTypeEnum), str.Replace(".", ""));
+ a.mHorizontal = ParserSTEP.ParseLink(arrFields[ipos++]);
+ a.mVertical = ParserSTEP.ParseLink(arrFields[ipos++]);
+ a.mLinearRefMethod = arrFields[ipos++].Replace("'", "");
+ }
+ internal static IfcAlignment Parse(string strDef) { IfcAlignment a = new IfcAlignment(); int ipos = 0; parseFields(a, ParserSTEP.SplitLineFields(strDef), ref ipos); return a; }
+ protected override string BuildString()
+ {
+ return base.BuildString() + (mPredefinedType== IfcAlignmentTypeEnum.NOTDEFINED ? ",$," : ",." + mPredefinedType.ToString() + ".,") +
+ ParserSTEP.LinkToString(mHorizontal) + "," + ParserSTEP.LinkToString(mVertical) + "," + ( mLinearRefMethod == "$" ? "$" : "'" + mLinearRefMethod + "'");
+ }
+ }
+ public partial class IfcAlignment2DHorizontal : BaseClassIfc //IFC4.1
+ {
+ internal double mStartDistAlong;// : OPTIONAL IfcLengthMeasure;
+ internal List mSegments = new List();// : LIST [1:?] OF IfcAlignment2DHorizontalSegment;
+
+ internal IfcAlignment2DHorizontal() : base() { }
+ internal IfcAlignment2DHorizontal(IfcAlignment2DHorizontal a) : base() { mStartDistAlong = a.mStartDistAlong; mSegments = new List(a.mSegments.ToArray()); }
+ internal static void parseFields(IfcAlignment2DHorizontal a, List arrFields, ref int ipos)
+ {
+ a.mStartDistAlong = ParserSTEP.ParseDouble(arrFields[ipos++]);
+ a.mSegments = ParserSTEP.SplitListLinks(arrFields[ipos++]);
+ }
+ protected override string BuildString()
+ {
+ string str = base.BuildString() + "," + ParserSTEP.DoubleOptionalToString(mStartDistAlong) + "," + ParserSTEP.LinkToString(mSegments[0]);
+ for (int icounter = 1; icounter < mSegments.Count; icounter++)
+ str += "," + ParserSTEP.LinkToString(mSegments[icounter]);
+ return str + ")";
+ }
+ internal static IfcAlignment2DHorizontal Parse(string strDef) { IfcAlignment2DHorizontal a = new IfcAlignment2DHorizontal(); int ipos = 0; parseFields(a, ParserSTEP.SplitLineFields(strDef), ref ipos); return a; }
+ }
+ public partial class IfcAlignment2DHorizontalSegment : IfcAlignment2DSegment //IFC4.1
+ {
+ internal int mCurveGeometry;// : IfcCurveSegment2D;
+
+ public IfcCurveSegment2D CurveGeometry { get { return mDatabase.mIfcObjects[mCurveGeometry] as IfcCurveSegment2D; } }
+
+ internal IfcAlignment2DHorizontalSegment() : base() { }
+ internal IfcAlignment2DHorizontalSegment(IfcAlignment2DHorizontalSegment p) : base(p) { mCurveGeometry = p.mCurveGeometry; }
+ internal IfcAlignment2DHorizontalSegment(bool tangential, string startTag, string endTag, IfcCurveSegment2D seg) : base(seg.mDatabase, tangential, startTag, endTag) { mCurveGeometry = seg.mIndex; }
+ internal static void parseFields(IfcAlignment2DHorizontalSegment s, List arrFields, ref int ipos)
+ {
+ IfcAlignment2DSegment.parseFields(s, arrFields, ref ipos);
+ s.mCurveGeometry = ParserSTEP.ParseLink(arrFields[ipos++]);
+ }
+ internal static IfcAlignment2DHorizontalSegment Parse(string strDef) { IfcAlignment2DHorizontalSegment a = new IfcAlignment2DHorizontalSegment(); int ipos = 0; parseFields(a, ParserSTEP.SplitLineFields(strDef), ref ipos); return a; }
+ protected override string BuildString() { return base.BuildString() + "," + ParserSTEP.LinkToString(mCurveGeometry); }
+ }
+ public abstract class IfcAlignment2DSegment : BaseClassIfc //IFC4.1
+ {
+ internal IfcLogicalEnum mTangentialContinuity = IfcLogicalEnum.UNKNOWN;// : OPTIONAL IfcBoolean;
+ private string mStartTag = "$";// : OPTIONAL IfcLabel;
+ private string mEndTag = "$";// : OPTIONAL IfcLabel;
+
+ public string StartTag { get { return (mStartTag == "$" ? "" : ParserIfc.Decode(mStartTag)); } set { mStartTag = (string.IsNullOrEmpty(value) ? "$" : ParserIfc.Encode(value.Replace("'", ""))); } }
+ public string EndTag { get { return (mEndTag == "$" ? "" : ParserIfc.Decode(mEndTag)); } set { mEndTag = (string.IsNullOrEmpty(value) ? "$" : ParserIfc.Encode(value.Replace("'", ""))); } }
+
+ protected IfcAlignment2DSegment() : base() { }
+ protected IfcAlignment2DSegment(IfcAlignment2DSegment s) : base() { mTangentialContinuity = s.mTangentialContinuity; mStartTag = s.mStartTag; mEndTag = s.mEndTag; }
+ protected IfcAlignment2DSegment(DatabaseIfc m, bool tangential, string startTag, string endTag) : base(m) { mTangentialContinuity = (tangential ? IfcLogicalEnum.TRUE : IfcLogicalEnum.FALSE); StartTag = startTag; EndTag = endTag; }
+ protected static void parseFields(IfcAlignment2DSegment a, List arrFields, ref int ipos)
+ {
+ a.mTangentialContinuity = ParserIfc.ParseIFCLogical(arrFields[ipos++]);
+ a.mStartTag = arrFields[ipos++].Replace("'", "");
+ a.mEndTag = arrFields[ipos++].Replace("'", "");
+ }
+ protected override string BuildString()
+ {
+ return base.BuildString() + (mTangentialContinuity == IfcLogicalEnum.UNKNOWN ? ",$," : (mTangentialContinuity == IfcLogicalEnum.TRUE ? ",.T.," : ",.F.")) +
+ (mStartTag == "$" ? "$," : "'" + mStartTag + "',") + (mEndTag == "$" ? "$" : "'" + mEndTag + "'");
+ }
+ }
+ public partial class IfcAlignment2DVerSegCircularArc : IfcAlignment2DVerticalSegment //IFC4x1
+ {
+ private double mRadius;// : IfcPositiveLengthMeasure;
+ private bool mIsConvex;// : IfcBoolean;
+
+ internal IfcAlignment2DVerSegCircularArc() : base() { }
+ internal IfcAlignment2DVerSegCircularArc(IfcAlignment2DVerSegCircularArc p) : base(p) { mRadius = p.mRadius; mIsConvex = p.mIsConvex; }
+ internal IfcAlignment2DVerSegCircularArc(DatabaseIfc m, bool tangential, string startTag, string endTag, double startDist, double horizontalLength, double startHeight, double startGradient, double radius, bool isCCW)
+ : base(m, tangential, startTag, endTag, startDist, horizontalLength, startHeight, startGradient)
+ {
+ mRadius = radius;
+ mIsConvex = isCCW;
+ }
+ internal static void parseFields(IfcAlignment2DVerSegCircularArc c, List arrFields, ref int ipos)
+ {
+ IfcAlignment2DVerticalSegment.parseFields(c, arrFields, ref ipos);
+ c.mRadius = ParserSTEP.ParseDouble(arrFields[ipos++]);
+ c.mIsConvex = ParserSTEP.ParseBool(arrFields[ipos++]);
+ }
+ internal static IfcAlignment2DVerSegCircularArc Parse(string strDef) { IfcAlignment2DVerSegCircularArc c = new IfcAlignment2DVerSegCircularArc(); int ipos = 0; parseFields(c, ParserSTEP.SplitLineFields(strDef), ref ipos); return c; }
+ protected override string BuildString() { return base.BuildString() + "," + ParserSTEP.DoubleToString(mRadius) + "," + ParserSTEP.BoolToString(mIsConvex); }
+
+ }
+ public partial class IfcAlignment2DVerSegLine : IfcAlignment2DVerticalSegment //IFC4x1
+ {
+ internal IfcAlignment2DVerSegLine() : base() { }
+ internal IfcAlignment2DVerSegLine(IfcAlignment2DVerSegLine s) : base(s) { }
+ internal IfcAlignment2DVerSegLine(DatabaseIfc m, bool tangential, string startTag, string endTag, double startDist, double horizontalLength, double startHeight, double startGradient)
+ : base(m, tangential, startTag, endTag, startDist, horizontalLength, startHeight, startGradient) { }
+ internal static void parseFields(IfcAlignment2DVerSegLine c, List arrFields, ref int ipos) { IfcAlignment2DVerticalSegment.parseFields(c, arrFields, ref ipos); }
+ internal static IfcAlignment2DVerSegLine Parse(string strDef) { IfcAlignment2DVerSegLine c = new IfcAlignment2DVerSegLine(); int ipos = 0; parseFields(c, ParserSTEP.SplitLineFields(strDef), ref ipos); return c; }
+ }
+ public partial class IfcAlignment2DVerSegParabolicArc : IfcAlignment2DVerticalSegment //IFC4x1
+ {
+ private double mParabolaConstant;// : IfcPositiveLengthMeasure;
+ private bool mIsConvex;// : IfcBoolean;
+
+ internal IfcAlignment2DVerSegParabolicArc() : base() { }
+ internal IfcAlignment2DVerSegParabolicArc(IfcAlignment2DVerSegParabolicArc p) : base(p) { mParabolaConstant = p.mParabolaConstant; mIsConvex = p.mIsConvex; }
+ internal IfcAlignment2DVerSegParabolicArc(DatabaseIfc m, bool tangential, string startTag, string endTag, double startDist, double horizontalLength, double startHeight, double startGradient, double radius, bool isCCW)
+ : base(m, tangential, startTag, endTag, startDist, horizontalLength, startHeight, startGradient)
+ {
+ mParabolaConstant = radius;
+ mIsConvex = isCCW;
+ }
+ internal static void parseFields(IfcAlignment2DVerSegParabolicArc c, List arrFields, ref int ipos)
+ {
+ IfcAlignment2DVerticalSegment.parseFields(c, arrFields, ref ipos);
+ c.mParabolaConstant = ParserSTEP.ParseDouble(arrFields[ipos++]);
+ c.mIsConvex = ParserSTEP.ParseBool(arrFields[ipos++]);
+ }
+ internal static IfcAlignment2DVerSegParabolicArc Parse(string strDef) { IfcAlignment2DVerSegParabolicArc c = new IfcAlignment2DVerSegParabolicArc(); int ipos = 0; parseFields(c, ParserSTEP.SplitLineFields(strDef), ref ipos); return c; }
+ protected override string BuildString() { return base.BuildString() + "," + ParserSTEP.DoubleToString(mParabolaConstant) + "," + ParserSTEP.BoolToString(mIsConvex); }
+ }
+ public partial class IfcAlignment2DVertical : BaseClassIfc //IFC4.1
+ {
+ internal List mSegments = new List();// : LIST [1:?] OF IfcAlignment2DVerticalSegment;
+ internal IfcAlignment2DVertical() : base() { }
+ internal IfcAlignment2DVertical(IfcAlignment2DVertical o) : base() { mSegments = new List(o.mSegments.ToArray()); }
+ internal static void parseFields(IfcAlignment2DVertical a, List arrFields, ref int ipos) { a.mSegments = ParserSTEP.SplitListLinks(arrFields[ipos++]); }
+ protected override string BuildString()
+ {
+ string str = base.BuildString() + "," + ParserSTEP.LinkToString(mSegments[0]);
+ for (int icounter = 1; icounter < mSegments.Count; icounter++)
+ str += "," + ParserSTEP.LinkToString(mSegments[icounter]);
+ return str + ")";
+ }
+ internal static IfcAlignment2DVertical Parse(string strDef) { IfcAlignment2DVertical a = new IfcAlignment2DVertical(); int ipos = 0; parseFields(a, ParserSTEP.SplitLineFields(strDef), ref ipos); return a; }
+ }
+ public abstract class IfcAlignment2DVerticalSegment : IfcAlignment2DSegment //IFC4.1
+ {
+ internal double mStartDistAlong;// : IfcLengthMeasure;
+ internal double mHorizontalLength;// : IfcPositiveLengthMeasure;
+ internal double mStartHeight;// : IfcLengthMeasure;
+ internal double mStartGradient;// : IfcRatioMeasure;
+
+ protected IfcAlignment2DVerticalSegment() : base() { }
+ protected IfcAlignment2DVerticalSegment(IfcAlignment2DVerticalSegment s) : base(s) { mStartDistAlong = s.mStartDistAlong; mHorizontalLength = s.mHorizontalLength; mStartHeight = s.mStartHeight; mStartGradient = s.mStartGradient; }
+ protected IfcAlignment2DVerticalSegment(DatabaseIfc m, bool tangential, string startTag, string endTag, double startDist, double horizontalLength,double startHeight, double startGradient) : base(m, tangential, startTag, endTag) { }
+ protected static void parseFields(IfcAlignment2DVerticalSegment s, List arrFields, ref int ipos)
+ {
+ IfcAlignment2DSegment.parseFields(s, arrFields, ref ipos);
+ s.mStartDistAlong = ParserSTEP.ParseDouble(arrFields[ipos++]);
+ s.mHorizontalLength = ParserSTEP.ParseDouble(arrFields[ipos++]);
+ s.mStartHeight = ParserSTEP.ParseDouble(arrFields[ipos++]);
+ s.mStartGradient = ParserSTEP.ParseDouble(arrFields[ipos++]);
+ }
+ protected override string BuildString() { return base.BuildString() + "," + ParserSTEP.DoubleToString(mStartDistAlong) + "," + ParserSTEP.DoubleToString(mHorizontalLength) + "," + ParserSTEP.DoubleToString(mStartHeight) + "," + ParserSTEP.DoubleToString(mStartGradient); }
+ }
+ public class IfcAngularDimension : IfcDimensionCurveDirectedCallout //IFC4 depreceated
+ {
+ internal IfcAngularDimension(IfcAngularDimension el) : base(el) { }
+ internal IfcAngularDimension() : base() { }
+ internal new static IfcAngularDimension Parse(string strDef) { IfcAngularDimension d = new IfcAngularDimension(); int ipos = 0; parseFields(d, ParserSTEP.SplitLineFields(strDef), ref ipos); return d; }
+ internal static void parseFields(IfcAngularDimension d,List arrFields, ref int ipos) { IfcDimensionCurveDirectedCallout.parseFields(d,arrFields, ref ipos); }
+ }
+ public class IfcAnnotation : IfcProduct
+ { //INVERSE
+ //internal List mContainedInStructure = new List(); //: SET [0:1] OF IfcRelContainedInSpatialStructure FOR RelatedElements;
+ internal IfcAnnotation(IfcAnnotation el) : base(el) { }
+ internal IfcAnnotation() : base() { }
+ internal IfcAnnotation(IfcProduct host) : base(host)
+ {
+ if (mDatabase.mModelView != ModelView.If2x3NotAssigned && mDatabase.mModelView != ModelView.Ifc4NotAssigned)
+ throw new Exception("Invalid Model View for " + KeyWord + " : " + mDatabase.ModelView.ToString());
+ }
+ internal static IfcAnnotation Parse(string strDef) { int ipos = 0; IfcAnnotation a = new IfcAnnotation(); parseFields(a, ParserSTEP.SplitLineFields(strDef), ref ipos); return a; }
+ internal static void parseFields(IfcAnnotation a, List arrFields, ref int ipos) { IfcProduct.parseFields(a,arrFields, ref ipos); }
+#if(rRHINO)
+ internal override bool drawRhino(Transform tr, int layerIndex, List voids, string building, string storey)
+ {
+ List vs = voids;
+ if (vs == null)
+ vs = new List();
+
+ for (int icounter = 0; icounter < mHasOpenings.Count; icounter++)
+ {
+ List v = ((IfcRelVoidsElement)mModel.mIFCobjs[mHasOpenings[icounter]]).getGeom();
+ if (v != null)
+ vs.AddRange(v);
+ }
+ return base.drawRhino(tr, layerIndex, vs, building, storey);
+ }
+#endif
+ }
+ public abstract class IfcAnnotationCurveOccurrence : IfcAnnotationOccurrence //IFC4 Depreceated
+ {
+ protected IfcAnnotationCurveOccurrence(IfcAnnotationCurveOccurrence p) : base((IfcAnnotationOccurrence)p) { }
+ protected IfcAnnotationCurveOccurrence() : base() { }
+ protected static void parseFields(IfcAnnotationCurveOccurrence a,List arrFields, ref int ipos) { IfcAnnotationOccurrence.parseFields(a,arrFields, ref ipos); }
+ }
+ public class IfcAnnotationFillArea : IfcGeometricRepresentationItem //IFC4 Depreceated
+ {
+ internal int mOuterBoundary;// : IfcCurve;
+ internal List mInnerBoundaries = new List();// OPTIONAL SET [1:?] OF IfcCurve;
+ internal IfcAnnotationFillArea(IfcAnnotationFillArea p) : base(p) { mOuterBoundary = p.mOuterBoundary; mInnerBoundaries = new List(p.mInnerBoundaries.ToArray()); }
+ internal IfcAnnotationFillArea() : base() { }
+ internal static void parseFields(IfcAnnotationFillArea a, List arrFields, ref int ipos)
+ {
+ IfcGeometricRepresentationItem.parseFields(a, arrFields, ref ipos);
+ a.mOuterBoundary = ParserSTEP.ParseLink(arrFields[ipos++]);
+ string str = arrFields[ipos++];
+ if (str != "$")
+ a.mInnerBoundaries = ParserSTEP.SplitListLinks(str);
+ }
+ internal static IfcAnnotationFillArea Parse(string strDef) { IfcAnnotationFillArea a = new IfcAnnotationFillArea(); int ipos = 0; parseFields(a, ParserSTEP.SplitLineFields(strDef), ref ipos); return a; }
+ protected override string BuildString()
+ {
+ string str = base.BuildString() + "," + ParserSTEP.LinkToString(mOuterBoundary);
+ if (mInnerBoundaries.Count > 0)
+ {
+ str += ",(" + ParserSTEP.LinkToString(mInnerBoundaries[0]);
+ for (int icounter = 1; icounter < mInnerBoundaries.Count; icounter++)
+ str += "," + ParserSTEP.LinkToString(mInnerBoundaries[icounter]);
+ return str + ")";
+ }
+ return str + ",$";
+ }
+
+ }
+ public class IfcAnnotationFillAreaOccurrence : IfcAnnotationOccurrence //IFC4 Depreceated
+ {
+ internal int mFillStyleTarget;// : OPTIONAL IfcPoint;
+ internal IfcGlobalOrLocalEnum mGlobalOrLocal;// : OPTIONAL IfcGlobalOrLocalEnum;
+ internal IfcAnnotationFillAreaOccurrence(IfcAnnotationFillAreaOccurrence i) : base(i) { }
+ internal IfcAnnotationFillAreaOccurrence() : base() { }
+ internal new static IfcAnnotationFillAreaOccurrence Parse(string strDef) { IfcAnnotationFillAreaOccurrence a = new IfcAnnotationFillAreaOccurrence(); int ipos = 0; parseFields(a, ParserSTEP.SplitLineFields(strDef), ref ipos); return a; }
+ internal static void parseFields(IfcAnnotationFillAreaOccurrence el,List arrFields, ref int ipos)
+ {
+ IfcAnnotationOccurrence.parseFields(el,arrFields, ref ipos);
+ el.mFillStyleTarget = ParserSTEP.ParseLink(arrFields[ipos++]);
+ string str = arrFields[ipos++];
+ if(str != "$")
+ el.mGlobalOrLocal = (IfcGlobalOrLocalEnum)Enum.Parse(typeof(IfcGlobalOrLocalEnum),str.Replace(".",""));
+ }
+ protected override string BuildString() { return base.BuildString() +"," + ParserSTEP.LinkToString(mFillStyleTarget) + ",." + mGlobalOrLocal.ToString() + "."; }
+ }
+ public abstract class IfcAnnotationOccurrence : IfcStyledItem //DEPRECEATED IFC4
+ {
+ protected IfcAnnotationOccurrence(IfcAnnotationOccurrence p) : base((IfcStyledItem)p) { }
+ protected IfcAnnotationOccurrence() : base() { }
+ protected static void parseFields(IfcAnnotationOccurrence a,List arrFields, ref int ipos) { IfcStyledItem.parseFields(a,arrFields, ref ipos); }
+ }
+ public class IfcAnnotationSurface : IfcGeometricRepresentationItem //DEPRECEATED IFC4
+ {
+ internal int mItem;// : IfcGeometricRepresentationItem;
+ internal int mTextureCoordinates;// OPTIONAL IfcTextureCoordinate;
+ internal IfcAnnotationSurface(IfcAnnotationSurface p) : base(p) { mItem = p.mItem; mTextureCoordinates = p.mTextureCoordinates; }
+ internal IfcAnnotationSurface() : base() { }
+ internal static void parseFields(IfcAnnotationSurface s,List arrFields, ref int ipos)
+ {
+ IfcGeometricRepresentationItem.parseFields(s,arrFields, ref ipos);
+ s.mItem = ParserSTEP.ParseLink(arrFields[ipos++]);
+ s.mTextureCoordinates = ParserSTEP.ParseLink(arrFields[ipos++]);
+ }
+ internal static IfcAnnotationSurface Parse(string strDef) { IfcAnnotationSurface a = new IfcAnnotationSurface(); int ipos = 0; parseFields(a, ParserSTEP.SplitLineFields(strDef), ref ipos); return a; }
+ protected override string BuildString() { return base.BuildString() + "," + ParserSTEP.LinkToString(mItem) + "," + ParserSTEP.LinkToString(mTextureCoordinates); }
+ }
+ public class IfcAnnotationSurfaceOccurrence : IfcAnnotationOccurrence //IFC4 Depreceated
+ {
+ internal IfcAnnotationSurfaceOccurrence(IfcAnnotationSurfaceOccurrence i) : base(i) { }
+ internal IfcAnnotationSurfaceOccurrence() : base() { }
+ internal new static IfcAnnotationSurfaceOccurrence Parse(string strDef) { IfcAnnotationSurfaceOccurrence a = new IfcAnnotationSurfaceOccurrence(); int ipos = 0; parseFields(a,ParserSTEP.SplitLineFields(strDef), ref ipos); return a; }
+ internal static void parseFields(IfcAnnotationSurfaceOccurrence a,List arrFields, ref int ipos) { IfcAnnotationOccurrence.parseFields(a,arrFields, ref ipos); }
+ }
+ public class IfcAnnotationSymbolOccurrence : IfcAnnotationOccurrence //IFC4 Depreceated
+ {
+ internal IfcAnnotationSymbolOccurrence(IfcAnnotationSymbolOccurrence i) : base(i) { }
+ internal IfcAnnotationSymbolOccurrence() : base() { }
+ internal new static IfcAnnotationSymbolOccurrence Parse(string strDef) { IfcAnnotationSymbolOccurrence a = new IfcAnnotationSymbolOccurrence(); int ipos = 0; parseFields(a, ParserSTEP.SplitLineFields(strDef), ref ipos); return a; }
+ internal static void parseFields(IfcAnnotationSymbolOccurrence a,List arrFields, ref int ipos) { IfcAnnotationOccurrence.parseFields(a,arrFields, ref ipos); }
+ }
+ public class IfcAnnotationTextOccurrence : IfcAnnotationOccurrence //IFC4 Depreceated
+ {
+ internal IfcAnnotationTextOccurrence() : base() { }
+ internal IfcAnnotationTextOccurrence(IfcAnnotationTextOccurrence i) : base(i) { }
+ internal new static IfcAnnotationTextOccurrence Parse(string strDef) { IfcAnnotationTextOccurrence a = new IfcAnnotationTextOccurrence(); int ipos = 0; parseFields(a, ParserSTEP.SplitLineFields(strDef), ref ipos); return a; }
+ internal static void parseFields(IfcAnnotationTextOccurrence a,List arrFields, ref int ipos) { IfcAnnotationOccurrence.parseFields(a,arrFields, ref ipos); }
+ }
+ public class IfcApplication : BaseClassIfc
+ {
+ internal int mApplicationDeveloper;// : IfcOrganization;
+ internal string mVersion;// : IfcLabel;
+ private string mApplicationFullName;// : IfcLabel;
+ internal string mApplicationIdentifier;// : IfcIdentifier;
+
+ public string ApplicationFullName { get { return ParserIfc.Decode(mApplicationFullName); } set { mApplicationFullName = ParserIfc.Encode(value.Replace("'", "")); } }
+
+ public override string Name { get { return ApplicationFullName; } set { ApplicationFullName = value; } }
+
+ internal IfcApplication() : base() { }
+ internal IfcApplication(IfcApplication o) : base() { mApplicationDeveloper = o.mApplicationDeveloper; mVersion = o.mVersion; mApplicationFullName = o.mApplicationFullName; mApplicationIdentifier = o.mApplicationIdentifier; }
+ internal IfcApplication(DatabaseIfc m) : base(m)
+ {
+ IfcOrganization o = new IfcOrganization(m, "Geometry Gym Pty Ltd");
+ mApplicationDeveloper = o.mIndex;
+ try
+ {
+ mVersion = "'" + System.Reflection.Assembly.GetExecutingAssembly().GetName().Version.ToString() + "'";
+ }
+ catch (Exception) { }
+#if(GH)
+ mApplicationFullName = "'ggGrasshopperIFC - Geometry Gym Plug-in for Grasshopper3d'";
+ mApplicationIdentifier = "'ggGrasshopperIFC'";
+#elif(CONVERTER)
+ mApplicationFullName = "'ggIFCConverter - Geometry Gym Pty Ltd'";
+ mApplicationIdentifier = "'ggIFCConverter'";
+#else
+ mApplicationFullName = "'ggRhinoIFC - Geometry Gym Plug-in for Rhino3d'";
+ mApplicationIdentifier = "'ggRhinoIFC'";
+#endif
+ }
+ internal static void parseFields(IfcApplication a, List arrFields, ref int ipos) { a.mApplicationDeveloper = ParserSTEP.ParseLink(arrFields[ipos++]); a.mVersion = arrFields[ipos++]; a.mApplicationFullName = arrFields[ipos++]; a.mApplicationIdentifier = arrFields[ipos++]; }
+ protected override string BuildString() { return base.BuildString() + "," + ParserSTEP.LinkToString(mApplicationDeveloper) + "," + mVersion + "," + mApplicationFullName + "," + mApplicationIdentifier; }
+ internal static IfcApplication Parse(string strDef) { IfcApplication a = new IfcApplication(); int ipos = 0; parseFields(a, ParserSTEP.SplitLineFields(strDef), ref ipos); return a; }
+ }
+ public partial class IfcAppliedValue : BaseClassIfc, IfcMetricValueSelect, IfcAppliedValueSelect, IfcResourceObjectSelect //SUPERTYPE OF(IfcCostValue);
+ {
+ internal string mName = "$";// : OPTIONAL IfcLabel;
+ internal string mDescription = "$";// : OPTIONAL IfcText;
+ internal int mAppliedValue = 0;// : OPTIONAL IfcAppliedValueSelect
+ internal IfcValue mAppliedValueValue = null;
+ internal int mUnitBasis;// : OPTIONAL IfcMeasureWithUnit;
+ internal string mApplicableDate = "$";// : OPTIONAL IfcDateTimeSelect; 4 IfcDate
+ internal string mFixedUntilDate = "$";// : OPTIONAL IfcDateTimeSelect; 4 IfcDate
+ internal string mCategory = "$";// : OPTIONAL IfcLabel; IFC4
+ internal string mCondition = "$";// : OPTIONAL IfcLabel; IFC4
+ internal IfcArithmeticOperatorEnum mArithmeticOperator = IfcArithmeticOperatorEnum.NONE;// : OPTIONAL IfcArithmeticOperatorEnum; IFC4
+ internal List mComponents = new List();// : OPTIONAL LIST [1:?] OF IfcAppliedValue; IFC4
+ //INVERSE
+ internal List mHasExternalReferences = new List(); //IFC4
+ internal List mHasConstraintRelationships = new List(); //gg
+
+ public override string Name { get { return (mName == "$" ? "" : ParserIfc.Decode(mName)); } set { mName = (string.IsNullOrEmpty(value) ? "$" : ParserIfc.Encode(value.Replace("'", ""))); } }
+ public string Description { get { return (mDescription == "$" ? "" : ParserIfc.Decode(mDescription)); } set { mDescription = (string.IsNullOrEmpty(value) ? "$" : ParserIfc.Encode(value.Replace("'", ""))); } }
+
+ public List HasExternalReferences { get { return mHasExternalReferences; } }
+ public List HasConstraintRelationships { get { return mHasConstraintRelationships; } }
+
+ internal IfcAppliedValue() : base() { }
+ internal IfcAppliedValue(IfcAppliedValue v) : base()
+ {
+ mName = v.mName; mDescription = v.mDescription; mAppliedValue = v.mAppliedValue; mAppliedValueValue = v.mAppliedValueValue; mUnitBasis = v.mUnitBasis; mApplicableDate = v.mApplicableDate;
+ mFixedUntilDate = v.mFixedUntilDate; mCategory = v.mCategory; mCondition = v.mCondition; mArithmeticOperator = v.mArithmeticOperator; mComponents.AddRange(v.mComponents);
+ }
+
+ internal static IfcAppliedValue Parse(string strDef, Schema schema) { IfcAppliedValue v = new IfcAppliedValue(); int ipos = 0; parseFields(v, ParserSTEP.SplitLineFields(strDef), ref ipos, schema); return v; }
+ internal static void parseFields(IfcAppliedValue a, List arrFields, ref int ipos, Schema schema)
+ {
+ a.mName = arrFields[ipos++].Replace("'", "");
+ a.mDescription = arrFields[ipos++].Replace("'", "");
+ string str = arrFields[ipos++];
+ a.mAppliedValueValue = ParserIfc.parseValue(str);
+ if (a.mAppliedValueValue == null)
+ a.mAppliedValue = ParserSTEP.ParseLink(str);
+ a.mUnitBasis = ParserSTEP.ParseLink(arrFields[ipos++]);
+ a.mApplicableDate = arrFields[ipos++];
+ a.mFixedUntilDate = arrFields[ipos++];
+ if (schema != Schema.IFC2x3)
+ {
+ a.mCategory = arrFields[ipos++].Replace("'", "");
+ a.mCondition = arrFields[ipos++].Replace("'", "");
+ string s = arrFields[ipos++];
+ if (s.StartsWith("."))
+ a.mArithmeticOperator = (IfcArithmeticOperatorEnum)Enum.Parse(typeof(IfcArithmeticOperatorEnum), s.Replace(".", ""));
+ a.mComponents = ParserSTEP.SplitListLinks(arrFields[ipos++]);
+ }
+ }
+ protected override string BuildString()
+ {
+ string str = "$";
+ if (mComponents.Count > 0)
+ {
+ str = "(" + ParserSTEP.LinkToString(mComponents[0]);
+ for (int icounter = 1; icounter < mComponents.Count; icounter++)
+ str += "," + ParserSTEP.LinkToString(mComponents[icounter]);
+ str += ")";
+ }
+ return base.BuildString() + (mName == "$" ? ",$," : ",'" + mName + "',") + (mDescription == "$" ? "$," : "'" + mDescription + "',") + (mAppliedValueValue != null ? mAppliedValueValue.ToString() : ParserSTEP.LinkToString(mAppliedValue)) + "," + ParserSTEP.LinkToString(mUnitBasis) + "," + mApplicableDate + "," + mFixedUntilDate +
+ (mDatabase.mSchema == Schema.IFC2x3 ? "" : (mCategory == "$" ? ",$," : ",'" + mCategory + "',") + (mCondition == "$" ? "$," : "'" + mCondition + "',") + (mArithmeticOperator == IfcArithmeticOperatorEnum.NONE ? "$," : "." + mArithmeticOperator.ToString() + ".,") + str);
+ }
+ }
+ public class IfcAppliedValueRelationship : BaseClassIfc //DEPRECEATED IFC4
+ {
+ internal int mComponentOfTotal;// : IfcAppliedValue;
+ internal List< int> mComponents = new List();// : SET [1:?] OF IfcAppliedValue;
+ internal IfcArithmeticOperatorEnum mArithmeticOperator;// : IfcArithmeticOperatorEnum;
+ internal string mName;// : OPTIONAL IfcLabel;
+ internal string mDescription;// : OPTIONAL IfcText
+ internal IfcAppliedValueRelationship() : base() { }
+ internal IfcAppliedValueRelationship(IfcAppliedValueRelationship o) : base()
+ {
+ mComponentOfTotal = o.mComponentOfTotal;
+ mComponents = new List(o.mComponents.ToArray());
+ mArithmeticOperator = o.mArithmeticOperator;
+ mName = o.mName;
+ mDescription = o.mDescription;
+ }
+ internal static void parseFields( IfcAppliedValueRelationship a,List arrFields, ref int ipos)
+ {
+ a.mComponentOfTotal = ParserSTEP.ParseLink(arrFields[ipos++]);
+ a.mComponents = ParserSTEP.SplitListLinks(arrFields[ipos++]);
+ a.mArithmeticOperator =( IfcArithmeticOperatorEnum)Enum.Parse(typeof(IfcArithmeticOperatorEnum), arrFields[ipos++].Replace(".",""));
+ a.mName = arrFields[ipos++];
+ a.mDescription = arrFields[ipos++];
+ }
+ protected override string BuildString()
+ {
+ string str = base.BuildString() + "," + ParserSTEP.LinkToString(mComponentOfTotal) + ",(" +
+ ParserSTEP.LinkToString(mComponents[0]);
+ for(int icounter = 1; icounter < mComponents.Count;icounter++)
+ str += "," + ParserSTEP.LinkToString(mComponents[icounter]);
+ return str + "),." + mArithmeticOperator.ToString() + ".," + mName + "," + mDescription;
+ }
+ internal static IfcAppliedValueRelationship Parse(string strDef) { IfcAppliedValueRelationship a = new IfcAppliedValueRelationship(); int ipos = 0; parseFields(a, ParserSTEP.SplitLineFields(strDef), ref ipos); return a; }
+ }
+ public interface IfcAppliedValueSelect : IfcInterface { }; // IfcMeasureWithUnit, IfcValue, IfcReference); IFC2x3 //IfcRatioMeasure, IfcMeasureWithUnit, IfcMonetaryMeasure);
+ public class IfcApproval : BaseClassIfc, IfcResourceObjectSelect
+ {
+ internal string mDescription = "$";// : OPTIONAL IfcText;
+ internal int mApprovalDateTime;// : IfcDateTimeSelect;
+ internal string mApprovalStatus = "$";// : OPTIONAL IfcLabel;
+ internal string mApprovalLevel = "$";// : OPTIONAL IfcLabel;
+ internal string mApprovalQualifier = "$";// : OPTIONAL IfcText;
+ internal string mName = "$";// :OPTIONAL IfcLabel;
+ internal string mIdentifier = "$";// : OPTIONAL IfcIdentifier;
+ //INVERSE
+ internal List mHasExternalReferences = new List(); //IFC4
+ internal List mHasConstraintRelationships = new List(); //gg
+ [Browsable(false)]
+ public List HasExternalReferences { get { return mHasExternalReferences; } }
+ [Browsable(false)]
+ public List HasConstraintRelationships { get { return mHasConstraintRelationships; } }
+ internal IfcApproval() : base() { }
+ internal IfcApproval(IfcApproval o) : base()
+ {
+ mDescription = o.mDescription;
+ mApprovalDateTime = o.mApprovalDateTime;
+ mApprovalStatus = o.mApprovalStatus;
+ mApprovalLevel = o.mApprovalLevel;
+ mApprovalQualifier = o.mApprovalQualifier;
+ mName = o.mName;
+ mIdentifier = o.mIdentifier;
+ }
+ internal static void parseFields(IfcApproval a,List arrFields, ref int ipos)
+ {
+ a.mDescription = arrFields[ipos++];
+ a.mApprovalDateTime = ParserSTEP.ParseLink(arrFields[ipos++]);
+ a.mApprovalStatus = arrFields[ipos++];
+ a.mApprovalLevel = arrFields[ipos++];
+ a.mApprovalQualifier = arrFields[ipos++];
+ a.mName = arrFields[ipos++];
+ a.mIdentifier = arrFields[ipos++];
+ }
+ protected override string BuildString() { return base.BuildString() + "," + mDescription + "," + ParserSTEP.LinkToString(mApprovalDateTime) + "," + mApprovalStatus + "," + mApprovalLevel + "," + mApprovalQualifier + "," + mName + "," + mIdentifier; }
+ internal static IfcApproval Parse(string strDef) { IfcApproval a = new IfcApproval(); int ipos = 0; parseFields(a, ParserSTEP.SplitLineFields(strDef), ref ipos); return a; }
+ }
+ public class IfcApprovalActorRelationship : BaseClassIfc //DEPRECEATED IFC4
+ {
+ internal int mActor;// : IfcActorSelect;
+ internal int mApproval;// : IfcApproval;
+ internal int mRole;// : IfcActorRole;
+ internal IfcApprovalActorRelationship() : base() { }
+ internal IfcApprovalActorRelationship(IfcApprovalActorRelationship o) : base() { mActor = o.mActor; mApproval = o.mApproval; mRole = o.mRole; }
+ internal static void parseFields(IfcApprovalActorRelationship r,List arrFields, ref int ipos) { r.mActor = ParserSTEP.ParseLink(arrFields[ipos++]); r.mApproval = ParserSTEP.ParseLink(arrFields[ipos++]); r.mRole = ParserSTEP.ParseLink(arrFields[ipos++]); }
+ protected override string BuildString() { return base.BuildString() + "," + ParserSTEP.LinkToString(mActor) + "," + ParserSTEP.LinkToString(mApproval) + "," + ParserSTEP.LinkToString(mRole); }
+ internal static IfcApprovalActorRelationship Parse(string strDef) { IfcApprovalActorRelationship r = new IfcApprovalActorRelationship(); int ipos = 0; parseFields(r, ParserSTEP.SplitLineFields(strDef), ref ipos); return r; }
+ }
+ public class IfcApprovalPropertyRelationship : BaseClassIfc //DEPRECEATED IFC4
+ {
+ internal List mApprovedProperties = new List();// : SET [1:?] OF IfcProperty;
+ internal int mApproval;// : IfcApproval;
+ internal IfcApprovalPropertyRelationship() : base() { }
+ internal IfcApprovalPropertyRelationship(IfcApprovalPropertyRelationship o) : base() { mApprovedProperties = new List(o.mApprovedProperties.ToArray()); mApproval = o.mApproval; }
+ internal static void parseFields(IfcApprovalPropertyRelationship r,List arrFields, ref int ipos) { r.mApprovedProperties = ParserSTEP.SplitListLinks(arrFields[ipos++]); r.mApproval = ParserSTEP.ParseLink(arrFields[ipos++]); }
+ protected override string BuildString()
+ {
+ string str = base.BuildString() + ",(" + ParserSTEP.LinkToString(mApprovedProperties[0]);
+ for(int icounter = 1; icounter < mApprovedProperties.Count; icounter++)
+ str += "," + ParserSTEP.LinkToString(mApprovedProperties[icounter]);
+ str += ")," + ParserSTEP.LinkToString(mApproval);
+ return str;
+ }
+ internal static IfcApprovalPropertyRelationship Parse(string strDef) { IfcApprovalPropertyRelationship r = new IfcApprovalPropertyRelationship(); int ipos = 0; parseFields(r, ParserSTEP.SplitLineFields(strDef), ref ipos); return r; }
+ }
+ public class IfcApprovalRelationship : IfcResourceLevelRelationship //IFC4Change
+ {
+ internal int mRelatedApproval;// : IfcApproval;
+ internal int mRelatingApproval;// : IfcApproval;
+ internal IfcApprovalRelationship() : base() { }
+ internal IfcApprovalRelationship(IfcApprovalRelationship o) : base(o) { mRelatedApproval = o.mRelatedApproval; mRelatingApproval = o.mRelatingApproval; }
+ internal static void parseFields( IfcApprovalRelationship a,List arrFields, ref int ipos,Schema schema)
+ {
+ IfcResourceLevelRelationship.parseFields(a,arrFields,ref ipos,schema);
+ a.mRelatedApproval = ParserSTEP.ParseLink(arrFields[ipos++]);
+ a.mRelatingApproval = ParserSTEP.ParseLink(arrFields[ipos++]);
+ if (schema == Schema.IFC2x3)
+ {
+ a.mDescription = arrFields[ipos++];
+ a.mName = arrFields[ipos++];
+ }
+ }
+ protected override string BuildString() { return base.BuildString() + "," + ParserSTEP.LinkToString(mRelatedApproval) + "," + ParserSTEP.LinkToString(mRelatingApproval) + (mDatabase.mSchema == Schema.IFC2x3 ? (mDescription == "$" ? ",$,'" : ",'" + mDescription + "','") + mName + "'": ""); }
+ internal static IfcApprovalRelationship Parse(string strDef,Schema schema) { IfcApprovalRelationship a = new IfcApprovalRelationship(); int ipos = 0; parseFields(a, ParserSTEP.SplitLineFields(strDef), ref ipos,schema); return a; }
+ }
+ public partial class IfcArbitraryClosedProfileDef : IfcProfileDef
+ {
+ private int mOuterCurve;// : IfcBoundedCurve
+ internal IfcBoundedCurve OuterCurve { get { return mDatabase.mIfcObjects[mOuterCurve] as IfcBoundedCurve; } }
+
+ internal IfcArbitraryClosedProfileDef() : base() { }
+ internal IfcArbitraryClosedProfileDef(IfcArbitraryClosedProfileDef i) : base(i) { mOuterCurve = i.mOuterCurve; }
+ public IfcArbitraryClosedProfileDef(string name, IfcBoundedCurve boundedCurve) : base(boundedCurve.mDatabase) { Name = name; mOuterCurve = boundedCurve.mIndex; }//if (string.Compare(getKW, mKW) == 0) mModel.mArbProfiles.Add(this); }
+
+ internal new static IfcArbitraryClosedProfileDef Parse(string strDef) { IfcArbitraryClosedProfileDef p = new IfcArbitraryClosedProfileDef(); int ipos = 0; parseFields(p, ParserSTEP.SplitLineFields(strDef), ref ipos); return p; }
+ internal static void parseFields(IfcArbitraryClosedProfileDef p, List arrFields, ref int ipos) { IfcProfileDef.parseFields(p, arrFields, ref ipos); p.mOuterCurve = ParserSTEP.ParseLink(arrFields[ipos++]); }
+ protected override string BuildString() { return (mDatabase.mOutputEssential ? "" : base.BuildString() + "," + ParserSTEP.LinkToString(mOuterCurve)); }
+ }
+ public partial class IfcArbitraryOpenProfileDef : IfcProfileDef
+ {
+ private int mCurve;// : IfcBoundedCurve
+ internal IfcBoundedCurve Curve { get { return mDatabase.mIfcObjects[mCurve] as IfcBoundedCurve; } }
+
+ internal IfcArbitraryOpenProfileDef() : base() { }
+ internal IfcArbitraryOpenProfileDef(IfcArbitraryOpenProfileDef i) : base((IfcProfileDef)i) { mCurve = i.mCurve; }
+ internal IfcArbitraryOpenProfileDef(string name, IfcBoundedCurve boundedCurve) : base(boundedCurve.mDatabase) { Name = name; mCurve = boundedCurve.mIndex; }
+ internal new static IfcArbitraryOpenProfileDef Parse(string strDef) { IfcArbitraryOpenProfileDef p = new IfcArbitraryOpenProfileDef(); int ipos = 0; parseFields(p, ParserSTEP.SplitLineFields(strDef), ref ipos); return p; }
+ internal static void parseFields(IfcArbitraryOpenProfileDef p, List arrFields, ref int ipos) { IfcProfileDef.parseFields(p, arrFields, ref ipos); p.mCurve = ParserSTEP.ParseLink(arrFields[ipos++]); }
+ protected override string BuildString() { return base.BuildString() + "," + ParserSTEP.LinkToString(mCurve); }
+ }
+ public partial class IfcArbitraryProfileDefWithVoids : IfcArbitraryClosedProfileDef
+ {
+ private List mInnerCurves = new List();// : SET [1:?] OF IfcCurve;
+ internal List InnerCurves { get { return mInnerCurves.ConvertAll(x => mDatabase.mIfcObjects[x] as IfcCurve); } }
+
+ internal IfcArbitraryProfileDefWithVoids() : base() { }
+ internal IfcArbitraryProfileDefWithVoids(IfcArbitraryProfileDefWithVoids i) : base((IfcArbitraryClosedProfileDef)i) { mInnerCurves = new List(i.mInnerCurves.ToArray()); }
+ internal IfcArbitraryProfileDefWithVoids(string name, IfcBoundedCurve perim, IfcCurve inner) : base(name, perim) { mInnerCurves.Add(inner.mIndex); }
+ internal IfcArbitraryProfileDefWithVoids(string name, IfcBoundedCurve perim, List inner) : base(name, perim) { mInnerCurves = inner.ConvertAll(x => x.mIndex); }
+ internal new static IfcArbitraryProfileDefWithVoids Parse(string strDef) { IfcArbitraryProfileDefWithVoids p = new IfcArbitraryProfileDefWithVoids(); int ipos = 0; parseFields(p, ParserSTEP.SplitLineFields(strDef), ref ipos); return p; }
+ internal static void parseFields(IfcArbitraryProfileDefWithVoids p, List arrFields, ref int ipos) { IfcArbitraryClosedProfileDef.parseFields(p, arrFields, ref ipos); p.mInnerCurves = ParserSTEP.SplitListLinks(arrFields[ipos++]); }
+ protected override string BuildString()
+ {
+ if (mDatabase.mOutputEssential)
+ return "";
+ if (mInnerCurves.Count == 0)
+ return base.BuildString();
+ string str = base.BuildString() + ",(" + ParserSTEP.LinkToString(mInnerCurves[0]);
+ for (int icounter = 1; icounter < mInnerCurves.Count; icounter++)
+ str += "," + ParserSTEP.LinkToString(mInnerCurves[icounter]);
+ return str + ")";
+ }
+ }
+ public class IfcArcIndex : IfcSegmentIndexSelect
+ {
+ internal int mA, mB, mC;
+ public IfcArcIndex(int a, int b, int c) { mA = a; mB = b; mC = c; }
+ public override string ToString() { return "IFCARCINDEX((" + mA + "," + mB + "," + mC + "))"; }
+ }
+ public class IfcAsset : IfcGroup
+ {
+ internal string mAssetID;// : IfcIdentifier;
+ internal int mOriginalValue;// : IfcCostValue;
+ internal int mCurrentValue;// : IfcCostValue;
+ internal int mTotalReplacementCost;// : IfcCostValue;
+ internal int mOwner;// : IfcActorSelect;
+ internal int mUser;// : IfcActorSelect;
+ internal int mResponsiblePerson;// : IfcPerson;
+ internal int mIncorporationDate;// : IfcCalendarDate;
+ internal int mDepreciatedValue;// : IfcCostValue;
+ internal IfcAsset() : base() { }
+ internal IfcAsset(IfcAsset p) : base(p)
+ {
+ mAssetID = p.mAssetID;
+ mOriginalValue = p.mOriginalValue;
+ mCurrentValue = p.mCurrentValue;
+ mTotalReplacementCost = p.mTotalReplacementCost;
+ mOwner = p.mOwner;
+ mUser = p.mUser;
+ mResponsiblePerson = p.mResponsiblePerson;
+ mIncorporationDate = p.mIncorporationDate;
+ mDepreciatedValue = p.mDepreciatedValue;
+ }
+ internal IfcAsset(DatabaseIfc m, string name) : base(m,name) { }
+ internal new static IfcAsset Parse(string strDef) { IfcAsset a = new IfcAsset(); int ipos = 0; parseFields(a, ParserSTEP.SplitLineFields(strDef), ref ipos); return a; }
+ internal static void parseFields(IfcAsset a,List arrFields, ref int ipos)
+ {
+ IfcGroup.parseFields(a,arrFields, ref ipos);
+ a.mAssetID = arrFields[ipos++].Replace("'","");
+ a.mOriginalValue = ParserSTEP.ParseLink(arrFields[ipos++]);
+ a.mCurrentValue = ParserSTEP.ParseLink(arrFields[ipos++]);
+ a.mTotalReplacementCost = ParserSTEP.ParseLink(arrFields[ipos++]);
+ a.mOwner = ParserSTEP.ParseLink(arrFields[ipos++]);
+ a.mUser = ParserSTEP.ParseLink(arrFields[ipos++]);
+ a.mResponsiblePerson = ParserSTEP.ParseLink(arrFields[ipos++]);
+ a.mIncorporationDate = ParserSTEP.ParseLink(arrFields[ipos++]);
+ a.mDepreciatedValue = ParserSTEP.ParseLink(arrFields[ipos++]);
+ }
+ protected override string BuildString()
+ {
+ return base.BuildString() +",'" + mAssetID + "'," + ParserSTEP.LinkToString(mOriginalValue) + "," +ParserSTEP.LinkToString(mCurrentValue) + "," +
+ ParserSTEP.LinkToString(mTotalReplacementCost) + "," +ParserSTEP.LinkToString(mOwner) + "," +
+ ParserSTEP.LinkToString(mUser) + "," +ParserSTEP.LinkToString(mResponsiblePerson) + "," +
+ ParserSTEP.LinkToString(mIncorporationDate) + "," +ParserSTEP.LinkToString(mDepreciatedValue);
+ }
+ }
+ public class IfcAsymmetricIShapeProfileDef : IfcIShapeProfileDef //IFC4 IfcParameterizedProfileDef
+ {
+ internal double mTopFlangeWidth;// : IfcPositiveLengthMeasure;
+ internal double mTopFlangeThickness;// : OPTIONAL IfcPositiveLengthMeasure;
+ internal double mTopFlangeFilletRadius;// : OPTIONAL IfcPositiveLengthMeasure;
+ internal double mCentreOfGravityInY;// : OPTIONAL IfcPositiveLengthMeasure
+ internal IfcAsymmetricIShapeProfileDef() : base() { }
+ internal IfcAsymmetricIShapeProfileDef(IfcAsymmetricIShapeProfileDef i) : base(i)
+ {
+ mTopFlangeWidth = i.mTopFlangeWidth;
+ mTopFlangeThickness = i.mTopFlangeThickness;
+ mTopFlangeFilletRadius = i.mTopFlangeFilletRadius;
+ mCentreOfGravityInY = i.mCentreOfGravityInY;
+ }
+ internal static void parseFields(IfcAsymmetricIShapeProfileDef p, List arrFields, ref int ipos,Schema schema)
+ {
+ IfcIShapeProfileDef.parseFields(p, arrFields, ref ipos,schema);
+ p.mTopFlangeWidth = ParserSTEP.ParseDouble(arrFields[ipos++]);
+ p.mTopFlangeThickness = ParserSTEP.ParseDouble(arrFields[ipos++]);
+ p.mTopFlangeFilletRadius = ParserSTEP.ParseDouble(arrFields[ipos++]);
+ if (schema == Schema.IFC2x3)
+ p.mCentreOfGravityInY = ParserSTEP.ParseDouble(arrFields[ipos++]);
+ }
+ internal new static IfcAsymmetricIShapeProfileDef Parse(string strDef,Schema schema) { IfcAsymmetricIShapeProfileDef p = new IfcAsymmetricIShapeProfileDef(); int ipos = 0; parseFields(p, ParserSTEP.SplitLineFields(strDef), ref ipos,schema); return p; }
+
+ protected override string BuildString()
+ {
+ return base.BuildString() + "," + ParserSTEP.DoubleToString(mTopFlangeWidth) + "," + ParserSTEP.DoubleOptionalToString(mTopFlangeThickness) + "," +
+ ParserSTEP.DoubleOptionalToString(mTopFlangeFilletRadius) + (mDatabase.mSchema == Schema.IFC2x3 ? "," + ParserSTEP.DoubleOptionalToString(mCentreOfGravityInY) : "");
+ }
+ }
+ public class IfcAudioVisualAppliance : IfcFlowTerminal //IFC4
+ {
+ internal IfcAudioVisualApplianceTypeEnum mPredefinedType = IfcAudioVisualApplianceTypeEnum.NOTDEFINED;// OPTIONAL : IfcAudioVisualApplianceTypeEnum;
+ public IfcAudioVisualApplianceTypeEnum PredefinedType { get { return mPredefinedType; } set { mPredefinedType = value; } }
+ internal IfcAudioVisualAppliance(IfcAudioVisualAppliance a) : base(a) { }
+ internal IfcAudioVisualAppliance() : base() { }
+ internal static void parseFields(IfcAudioVisualAppliance s, List arrFields, ref int ipos)
+ {
+ IfcFlowTerminal.parseFields(s, arrFields, ref ipos);
+ string str = arrFields[ipos++];
+ if (str[0] == '.')
+ s.mPredefinedType = (IfcAudioVisualApplianceTypeEnum)Enum.Parse(typeof(IfcAudioVisualApplianceTypeEnum), str.Substring(1, str.Length - 2));
+ }
+ internal new static IfcAudioVisualAppliance Parse(string strDef) { IfcAudioVisualAppliance s = new IfcAudioVisualAppliance(); int ipos = 0; parseFields(s, ParserSTEP.SplitLineFields(strDef), ref ipos); return s; }
+ protected override string BuildString() { return base.BuildString() + (mDatabase.mSchema == Schema.IFC2x3 ? "" : ( mPredefinedType == IfcAudioVisualApplianceTypeEnum.NOTDEFINED ? ",$" : ",." + mPredefinedType.ToString() + ".")); }
+
+ }
+ public partial class IfcAudioVisualApplianceType : IfcFlowTerminalType
+ {
+ internal IfcAudioVisualApplianceTypeEnum mPredefinedType = IfcAudioVisualApplianceTypeEnum.NOTDEFINED;// : IfcAudioVisualApplianceBoxTypeEnum;
+ public IfcAudioVisualApplianceTypeEnum PredefinedType { get { return mPredefinedType; } set { mPredefinedType = value; } }
+ internal IfcAudioVisualApplianceType(IfcAudioVisualApplianceType t) : base(t) { mPredefinedType = t.mPredefinedType; }
+ internal IfcAudioVisualApplianceType() : base() { }
+ internal IfcAudioVisualApplianceType(DatabaseIfc m, string name, IfcAudioVisualApplianceTypeEnum t) : base(m) { Name = name; mPredefinedType = t; }
+ internal static void parseFields(IfcAudioVisualApplianceType t, List arrFields, ref int ipos) { IfcFlowControllerType.parseFields(t, arrFields, ref ipos); t.mPredefinedType = (IfcAudioVisualApplianceTypeEnum)Enum.Parse(typeof(IfcAudioVisualApplianceTypeEnum), arrFields[ipos++].Replace(".", "")); }
+ internal new static IfcAudioVisualApplianceType Parse(string strDef) { IfcAudioVisualApplianceType t = new IfcAudioVisualApplianceType(); int ipos = 0; parseFields(t, ParserSTEP.SplitLineFields(strDef), ref ipos); return t; }
+ protected override string BuildString() { return base.BuildString() + ",." + mPredefinedType.ToString() + "."; }
+ }
+ public partial class IfcAxis1Placement : IfcPlacement
+ {
+ private int mAxis;// : OPTIONAL IfcDirection
+ public IfcDirection Axis { get { return (mAxis > 0 ? mDatabase.mIfcObjects[mAxis] as IfcDirection : null); } }
+
+ internal IfcAxis1Placement() : base() { }
+ internal IfcAxis1Placement(IfcAxis1Placement p) : base(p) { mAxis = p.mAxis; }
+ internal IfcAxis1Placement(DatabaseIfc m) : base(m) { }
+
+ protected override string BuildString() { return (mDatabase.mOutputEssential ? "" : base.BuildString() + "," + ParserSTEP.LinkToString(mAxis)); }
+ internal static IfcAxis1Placement Parse(string strDef) { IfcAxis1Placement p = new IfcAxis1Placement(); int ipos = 0; parseFields(p, ParserSTEP.SplitLineFields(strDef), ref ipos); return p; }
+ internal static void parseFields(IfcAxis1Placement p, List arrFields, ref int ipos) { IfcPlacement.parseFields(p, arrFields, ref ipos); p.mAxis = ParserSTEP.ParseLink(arrFields[ipos++]); }
+ }
+ public partial interface IfcAxis2Placement : IfcInterface { } //SELECT ( IfcAxis2Placement2D, IfcAxis2Placement3D);
+ public partial class IfcAxis2Placement2D : IfcPlacement, IfcAxis2Placement
+ {
+ private int mRefDirection;// : OPTIONAL IfcDirection;
+ public IfcDirection RefDirection { get { return mDatabase.mIfcObjects[mRefDirection] as IfcDirection; } }
+
+ internal IfcAxis2Placement2D() : base() { }
+ internal IfcAxis2Placement2D(IfcAxis2Placement2D i) : base(i) { mRefDirection = i.mRefDirection; }
+ public IfcAxis2Placement2D(DatabaseIfc db) : base(db) { }
+ public IfcAxis2Placement2D(IfcCartesianPoint point) : base(point) { }
+
+ protected override string BuildString() { return (mDatabase.mOutputEssential ? "" : base.BuildString() + "," + ParserSTEP.LinkToString(mRefDirection)); }
+ internal static IfcAxis2Placement2D Parse(string strDef) { IfcAxis2Placement2D p = new IfcAxis2Placement2D(); int ipos = 0; parseFields(p, ParserSTEP.SplitLineFields(strDef), ref ipos); return p; }
+ internal static void parseFields(IfcAxis2Placement2D p, List arrFields, ref int ipos) { IfcPlacement.parseFields(p, arrFields, ref ipos); p.mRefDirection = ParserSTEP.ParseLink(arrFields[ipos++]); }
+ }
+ public partial class IfcAxis2Placement3D : IfcPlacement, IfcAxis2Placement
+ {
+ private int mAxis;// : OPTIONAL IfcDirection;
+ private int mRefDirection;// : OPTIONAL IfcDirection;
+
+ internal IfcDirection Axis { get { return mDatabase.mIfcObjects[mAxis] as IfcDirection; } set { mAxis = (value == null ? 0 : value.mIndex); } }
+ internal IfcDirection RefDirection { get { return mDatabase.mIfcObjects[mRefDirection] as IfcDirection; } set { mRefDirection = (value == null ? 0 : value.mIndex); } }
+
+ internal IfcAxis2Placement3D() : base() { }
+ internal IfcAxis2Placement3D(IfcAxis2Placement3D i) : base(i) { mAxis = i.mAxis; mRefDirection = i.mRefDirection; }
+ public IfcAxis2Placement3D(IfcCartesianPoint p) : base(p) { }
+ public IfcAxis2Placement3D(IfcCartesianPoint p, IfcDirection axis, IfcDirection refDirection) : base(p) { mAxis = (axis == null ? 0 : axis.mIndex); mRefDirection = (refDirection == null ? 0 : refDirection.mIndex); }
+ internal IfcAxis2Placement3D(DatabaseIfc m) : base(m) { }
+
+ internal static IfcAxis2Placement3D Parse(string strDef) { IfcAxis2Placement3D p = new IfcAxis2Placement3D(); int ipos = 0; parseFields(p, ParserSTEP.SplitLineFields(strDef), ref ipos); return p; }
+ internal static void parseFields(IfcAxis2Placement3D p, List arrFields, ref int ipos) { IfcPlacement.parseFields(p, arrFields, ref ipos); p.mAxis = ParserSTEP.ParseLink(arrFields[ipos++]); p.mRefDirection = ParserSTEP.ParseLink(arrFields[ipos++]); }
+ protected override string BuildString() { return (mDatabase.mOutputEssential ? "" : base.BuildString() + (mAxis > 0 ? "," + ParserSTEP.LinkToString(mAxis) : ",$") + (mRefDirection > 0 ? "," + ParserSTEP.LinkToString(mRefDirection) : ",$")); }
+ }
+}
diff --git a/IFC/IFC B.cs b/IFC/IFC B.cs
new file mode 100644
index 0000000..1d914f3
--- /dev/null
+++ b/IFC/IFC B.cs
@@ -0,0 +1,856 @@
+// MIT License
+// Copyright (c) 2016 Geometry Gym Pty Ltd
+
+// Permission is hereby granted, free of charge, to any person obtaining a copy of this software
+// and associated documentation files (the "Software"), to deal in the Software without restriction,
+// including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense,
+// and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so,
+// subject to the following conditions:
+
+// The above copyright notice and this permission notice shall be included in all copies or substantial
+// portions of the Software.
+
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT
+// LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+// IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+// WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+// SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+using System;
+using System.Collections.Generic;
+using System.Text;
+using System.Reflection;
+using System.IO;
+using System.ComponentModel;
+using System.Linq;
+using System.Drawing;
+using GeometryGym.STEP;
+
+
+namespace GeometryGym.Ifc
+{
+ public partial class IfcBeam : IfcBuildingElement
+ {
+ internal IfcBeamTypeEnum mPredefinedType = IfcBeamTypeEnum.NOTDEFINED;//: OPTIONAL IfcBeamTypeEnum; IFC4
+ public IfcBeamTypeEnum PredefinedType { get { return mPredefinedType; } set { mPredefinedType = value; } }
+
+ internal IfcBeam() : base() { }
+ internal IfcBeam(IfcBeam b) : base(b) { mPredefinedType = b.mPredefinedType; }
+ public IfcBeam(IfcProduct host, IfcObjectPlacement p, IfcProductRepresentation r) : base(host, p, r) { }
+
+ internal static void parseFields(IfcBeam b, List arrFields, ref int ipos, Schema schema)
+ {
+ IfcBuildingElement.parseFields(b, arrFields, ref ipos);
+ if (schema != Schema.IFC2x3)
+ {
+ string str = arrFields[ipos++];
+ if (str[0] == '.')
+ b.mPredefinedType = (IfcBeamTypeEnum)Enum.Parse(typeof(IfcBeamTypeEnum), str.Substring(1, str.Length - 2));
+ }
+ }
+ internal static IfcBeam Parse(string strDef, Schema schema) { IfcBeam b = new IfcBeam(); int ipos = 0; parseFields(b, ParserSTEP.SplitLineFields(strDef), ref ipos, schema); return b; }
+ protected override string BuildString() { return base.BuildString() + (mDatabase.mSchema == Schema.IFC2x3 ? "" : (mPredefinedType == IfcBeamTypeEnum.NOTDEFINED ? ",$" : ",." + mPredefinedType.ToString() + ".")); }
+ }
+ public partial class IfcBeamStandardCase : IfcBeam
+ {
+ public override string KeyWord { get { return (mDatabase.mSchema == Schema.IFC2x3 || mDatabase.mModelView == ModelView.Ifc4Reference ? "IFCBEAM" : base.KeyWord); } }
+
+ internal IfcBeamStandardCase() : base() { }
+ internal IfcBeamStandardCase(IfcBeamStandardCase o) : base(o) { }
+
+ internal new static IfcBeamStandardCase Parse(string strDef, Schema schema) { IfcBeamStandardCase c = new IfcBeamStandardCase(); int ipos = 0; parseFields(c, ParserSTEP.SplitLineFields(strDef), ref ipos,schema); return c; }
+ internal static void parseFields(IfcBeamStandardCase c, List arrFields, ref int ipos, Schema schema) { IfcBeam.parseFields(c, arrFields, ref ipos,schema); }
+ }
+ public partial class IfcBeamType : IfcBuildingElementType
+ {
+ internal IfcBeamTypeEnum mPredefinedType;
+ public IfcBeamTypeEnum PredefinedType { get { return mPredefinedType; } set { mPredefinedType = value; } }
+
+ internal IfcBeamType() : base() { }
+ internal IfcBeamType(IfcBeamType b) : base(b) { mPredefinedType = b.mPredefinedType; }
+ public IfcBeamType(DatabaseIfc m, string name, IfcBeamTypeEnum type) : base(m) { Name = name; mPredefinedType = type; }
+ public IfcBeamType(string name, IfcMaterialProfile mp, IfcBeamTypeEnum type) : this(name, new IfcMaterialProfileSet(name, mp), type) { }
+ public IfcBeamType(string name, IfcMaterialProfileSet ps, IfcBeamTypeEnum type) : base(ps.mDatabase) { Name = name; mPredefinedType = type; MaterialSelect = ps; }
+ internal static void parseFields(IfcBeamType t, List arrFields, ref int ipos) { IfcBuildingElementType.parseFields(t, arrFields, ref ipos); t.mPredefinedType = (IfcBeamTypeEnum)Enum.Parse(typeof(IfcBeamTypeEnum), arrFields[ipos++].Replace(".", "")); }
+ internal new static IfcBeamType Parse(string strDef) { IfcBeamType t = new IfcBeamType(); int ipos = 0; parseFields(t, ParserSTEP.SplitLineFields(strDef), ref ipos); return t; }
+ protected override string BuildString() { return base.BuildString() + ",." + mPredefinedType.ToString() + "."; }
+ }
+ public interface IfcBendingParameterSelect { } // IfcLengthMeasure, IfcPlaneAngleMeasure
+ public partial class IfcBezierCurve : IfcBSplineCurve // DEPRECEATED IFC4
+ {
+ internal IfcBezierCurve() : base() { }
+ internal IfcBezierCurve(IfcBezierCurve pl) : base(pl) { }
+ internal static void parseFields(IfcBezierCurve c, List arrFields, ref int ipos) { IfcBSplineCurve.parseFields(c, arrFields, ref ipos); }
+ internal static IfcBezierCurve Parse(string strDef) { IfcBezierCurve c = new IfcBezierCurve(); int ipos = 0; parseFields(c, ParserSTEP.SplitLineFields(strDef), ref ipos); return c; }
+ }
+ public class IfcBlobTexture : IfcSurfaceTexture
+ {
+ internal string mRasterFormat;// : IfcIdentifier;
+ internal bool mRasterCode;// : BOOLEAN;
+ internal IfcBlobTexture() : base() { }
+ internal IfcBlobTexture(IfcBlobTexture i) : base(i) { mRasterFormat = i.mRasterFormat; mRasterCode = i.mRasterCode; }
+ internal static IfcBlobTexture Parse(string strDef, Schema schema) { IfcBlobTexture t = new IfcBlobTexture(); int ipos = 0; parseFields(t, ParserSTEP.SplitLineFields(strDef), ref ipos,schema); return t; }
+ internal static void parseFields(IfcBlobTexture t, List arrFields, ref int ipos, Schema schema) { IfcSurfaceTexture.parseFields(t, arrFields, ref ipos,schema); t.mRasterFormat = arrFields[ipos++].Replace("'", ""); t.mRasterCode = ParserSTEP.ParseBool(arrFields[ipos++]); }
+ protected override string BuildString() { return base.BuildString() + ",'" + mRasterFormat + "'," + ParserSTEP.BoolToString(mRasterCode); }
+ }
+ public partial class IfcBlock : IfcCsgPrimitive3D
+ {
+ private double mXLength, mYLength, mZLength;// : IfcPositiveLengthMeasure;
+
+ public double XLength { get { return mXLength; } }
+ public double YLength { get { return mYLength; } }
+ public double ZLength { get { return mZLength; } }
+
+ internal IfcBlock() : base() { }
+ internal IfcBlock(IfcBlock pl) : base(pl) { mXLength = pl.mXLength; mYLength = pl.mYLength; mZLength = pl.mZLength; }
+ internal static void parseFields(IfcBlock b, List arrFields, ref int ipos) { IfcCsgPrimitive3D.parseFields(b, arrFields, ref ipos); b.mXLength = ParserSTEP.ParseDouble(arrFields[ipos++]); b.mYLength = ParserSTEP.ParseDouble(arrFields[ipos++]); b.mZLength = ParserSTEP.ParseDouble(arrFields[ipos++]); }
+ internal static IfcBlock Parse(string strDef) { IfcBlock b = new IfcBlock(); int ipos = 0; parseFields(b, ParserSTEP.SplitLineFields(strDef), ref ipos); return b; }
+ protected override string BuildString() { return base.BuildString() + "," + ParserSTEP.DoubleToString(mXLength) + "," + ParserSTEP.DoubleToString(mYLength) + "," + ParserSTEP.DoubleToString(mZLength); }
+ }
+ public class IfcBoiler : IfcEnergyConversionDevice //IFC4
+ {
+ internal IfcBoilerTypeEnum mPredefinedType = IfcBoilerTypeEnum.NOTDEFINED;
+ public IfcBoilerTypeEnum PredefinedType { get { return mPredefinedType; } set { mPredefinedType = value; } }
+
+ internal IfcBoiler() : base() { }
+ internal IfcBoiler(IfcBoiler b) : base(b) { mPredefinedType = b.mPredefinedType; }
+ internal IfcBoiler(IfcProduct host, IfcObjectPlacement placement, IfcProductRepresentation representation, IfcDistributionSystem system) : base(host, placement, representation, system) { }
+ internal static void parseFields(IfcBoiler a, List arrFields, ref int ipos)
+ {
+ IfcDistributionControlElement.parseFields(a, arrFields, ref ipos);
+ string s = arrFields[ipos++];
+ if (s.StartsWith("."))
+ a.mPredefinedType = (IfcBoilerTypeEnum)Enum.Parse(typeof(IfcBoilerTypeEnum), s.Replace(".", ""));
+ }
+ internal new static IfcBoiler Parse(string strDef) { IfcBoiler d = new IfcBoiler(); int ipos = 0; parseFields(d, ParserSTEP.SplitLineFields(strDef), ref ipos); return d; }
+ protected override string BuildString()
+ {
+ return base.BuildString() + (mDatabase.mSchema == Schema.IFC2x3 ? "" : (mPredefinedType == IfcBoilerTypeEnum.NOTDEFINED ? ",$" : ",." + mPredefinedType.ToString() + "."));
+ }
+ }
+ public class IfcBoilerType : IfcEnergyConversionDeviceType
+ {
+ internal IfcBoilerTypeEnum mPredefinedType = IfcBoilerTypeEnum.NOTDEFINED;// : IfcBoilerypeEnum;
+ public IfcBoilerTypeEnum PredefinedType { get { return mPredefinedType; } set { mPredefinedType = value; } }
+ internal IfcBoilerType() : base() { }
+ internal IfcBoilerType(IfcBoilerType t) : base(t) { mPredefinedType = t.mPredefinedType; }
+ internal IfcBoilerType(DatabaseIfc m, string name, IfcBoilerTypeEnum type) : base(m) { Name = name; mPredefinedType = type; }
+ internal static void parseFields(IfcBoilerType t, List arrFields, ref int ipos) { IfcEnergyConversionDeviceType.parseFields(t, arrFields, ref ipos); t.mPredefinedType = (IfcBoilerTypeEnum)Enum.Parse(typeof(IfcBoilerTypeEnum), arrFields[ipos++].Replace(".", "")); }
+ internal new static IfcBoilerType Parse(string strDef) { IfcBoilerType t = new IfcBoilerType(); int ipos = 0; parseFields(t, ParserSTEP.SplitLineFields(strDef), ref ipos); return t; }
+ protected override string BuildString() { return base.BuildString() + ",." + mPredefinedType.ToString() + "."; }
+ }
+ public class IfcBooleanClippingResult : IfcBooleanResult
+ {
+ internal IfcBooleanClippingResult() : base() { }
+ internal IfcBooleanClippingResult(IfcBooleanClippingResult c) : base(c) { }
+ internal IfcBooleanClippingResult(IfcBooleanClippingResult bc, IfcHalfSpaceSolid hss) : base(IfcBooleanOperator.DIFFERENCE, bc, hss) { }
+ internal IfcBooleanClippingResult(IfcSweptAreaSolid s, IfcHalfSpaceSolid hss) : base(IfcBooleanOperator.DIFFERENCE, s, hss) { }
+ internal static void parseFields(IfcBooleanClippingResult c, List arrFields, ref int ipos) { IfcBooleanResult.parseFields(c, arrFields, ref ipos); }
+ internal new static IfcBooleanClippingResult Parse(string strDef) { IfcBooleanClippingResult c = new IfcBooleanClippingResult(); int ipos = 0; parseFields(c, ParserSTEP.SplitLineFields(strDef), ref ipos); return c; }
+ }
+ public partial interface IfcBooleanOperand : IfcInterface { } // SELECT (IfcSolidModel ,IfcHalfSpaceSolid ,IfcBooleanResult ,IfcCsgPrimitive3D);
+ public partial class IfcBooleanResult : IfcGeometricRepresentationItem, IfcBooleanOperand, IfcCsgSelect
+ {
+ private IfcBooleanOperator mOperator;// : IfcBooleanOperator;
+ private int mFirstOperand;// : IfcBooleanOperand;
+ private int mSecondOperand;// : IfcBooleanOperand;
+
+ internal IfcBooleanOperator Operator { get { return mOperator; } }
+ internal IfcBooleanOperand FirstOperand { get { return mDatabase.mIfcObjects[mFirstOperand] as IfcBooleanOperand; } }
+ internal IfcBooleanOperand SecondOperand { get { return mDatabase.mIfcObjects[mSecondOperand] as IfcBooleanOperand; } }
+
+ internal IfcBooleanResult() : base() { }
+ internal IfcBooleanResult(IfcBooleanResult b) : base(b) { mOperator = b.mOperator; mFirstOperand = b.mFirstOperand; mSecondOperand = b.mSecondOperand; }
+ public IfcBooleanResult(IfcBooleanOperator op, IfcBooleanOperand first, IfcBooleanOperand second) : base(first.Database)
+ {
+ mOperator = op;
+ mFirstOperand = first.Index;
+ mSecondOperand = second.Index;
+ }
+ internal static void parseFields(IfcBooleanResult b, List arrFields, ref int ipos)
+ {
+ IfcCurve.parseFields(b, arrFields, ref ipos);
+ b.mOperator = (IfcBooleanOperator)Enum.Parse(typeof(IfcBooleanOperator), arrFields[ipos++].Replace(".", ""));
+ b.mFirstOperand = ParserSTEP.ParseLink(arrFields[ipos++]);
+ b.mSecondOperand = ParserSTEP.ParseLink(arrFields[ipos++]);
+ }
+ internal static IfcBooleanResult Parse(string strDef) { IfcBooleanResult b = new IfcBooleanResult(); int ipos = 0; parseFields(b, ParserSTEP.SplitLineFields(strDef), ref ipos); return b; }
+ protected override string BuildString() { return base.BuildString() + ",." + mOperator.ToString() + ".," + ParserSTEP.LinkToString(mFirstOperand) + "," + ParserSTEP.LinkToString(mSecondOperand); }
+ }
+ public abstract class IfcBoundaryCondition : BaseClassIfc //ABSTRACT SUPERTYPE OF (ONEOF (IfcBoundaryEdgeCondition ,IfcBoundaryFaceCondition ,IfcBoundaryNodeCondition));
+ {
+ internal string mName;// : OPTIONAL IfcLabel;
+ public override string Name { get { return (mName == "$" ? "" : ParserIfc.Decode(mName)); } set { mName = (string.IsNullOrEmpty(value) ? "$" : ParserIfc.Encode(value.Replace("'", ""))); } }
+ protected IfcBoundaryCondition() : base() { }
+ protected IfcBoundaryCondition(IfcBoundaryCondition i) : base() { mName = i.mName; }
+ protected IfcBoundaryCondition(DatabaseIfc m, string name) : base(m) { mName = (string.IsNullOrEmpty(name) ? "Boundary Condition" : name.Replace("'", "")); }
+ protected static void parseFields(IfcBoundaryCondition c, List arrFields, ref int ipos) { c.mName = arrFields[ipos++].Replace("'", ""); }
+ protected override string BuildString() { return base.BuildString() + ",'" + mName + "'"; }
+ }
+ public class IfcBoundaryCurve : IfcCompositeCurveOnSurface
+ {
+ internal IfcBoundaryCurve() : base() { }
+ internal IfcBoundaryCurve(IfcBoundaryCurve i) : base(i) { }
+ internal IfcBoundaryCurve(List segs) : base(segs) { }
+ internal new static IfcBoundaryCurve Parse(string strDef) { IfcBoundaryCurve b = new IfcBoundaryCurve(); int ipos = 0; parseFields(b, ParserSTEP.SplitLineFields(strDef), ref ipos); return b; }
+ internal static void parseFields(IfcBoundaryCurve b, List arrFields, ref int ipos) { IfcCompositeCurveOnSurface.parseFields(b, arrFields, ref ipos); }
+ }
+ public class IfcBoundaryEdgeCondition : IfcBoundaryCondition
+ {
+ internal double mLinearStiffnessByLengthX, mLinearStiffnessByLengthY, mLinearStiffnessByLengthZ;// : OPTIONAL IfcModulusOfLinearSubgradeReactionMeasure;
+ internal double mRotationalStiffnessByLengthX, mRotationalStiffnessByLengthY, mRotationalStiffnessByLengthZ;// : OPTIONAL IfcModulusOfRotationalSubgradeReactionMeasure;
+ internal IfcBoundaryEdgeCondition() : base() { }
+ internal IfcBoundaryEdgeCondition(IfcBoundaryEdgeCondition i) : base(i) { mLinearStiffnessByLengthX = i.mLinearStiffnessByLengthX; mLinearStiffnessByLengthY = i.mLinearStiffnessByLengthY; mLinearStiffnessByLengthZ = i.mLinearStiffnessByLengthZ; mRotationalStiffnessByLengthX = i.mRotationalStiffnessByLengthX; mRotationalStiffnessByLengthY = i.mRotationalStiffnessByLengthY; mRotationalStiffnessByLengthZ = i.mRotationalStiffnessByLengthZ; }
+ internal IfcBoundaryEdgeCondition(DatabaseIfc m, string name) : base(m, name) { }
+ internal static IfcBoundaryEdgeCondition Parse(string strDef) { IfcBoundaryEdgeCondition b = new IfcBoundaryEdgeCondition(); int ipos = 0; parseFields(b, ParserSTEP.SplitLineFields(strDef), ref ipos); return b; }
+ internal static void parseFields(IfcBoundaryEdgeCondition b, List arrFields, ref int ipos)
+ {
+ IfcBoundaryCondition.parseFields(b, arrFields, ref ipos);
+ b.mLinearStiffnessByLengthX = ParserSTEP.ParseDouble(arrFields[ipos++]);
+ b.mLinearStiffnessByLengthY = ParserSTEP.ParseDouble(arrFields[ipos++]);
+ b.mLinearStiffnessByLengthZ = ParserSTEP.ParseDouble(arrFields[ipos++]);
+ b.mRotationalStiffnessByLengthX = ParserSTEP.ParseDouble(arrFields[ipos++]);
+ b.mRotationalStiffnessByLengthY = ParserSTEP.ParseDouble(arrFields[ipos++]);
+ b.mRotationalStiffnessByLengthZ = ParserSTEP.ParseDouble(arrFields[ipos++]);
+ }
+ protected override string BuildString() { return base.BuildString() + "," + ParserSTEP.DoubleOptionalToString(mLinearStiffnessByLengthX) + "," + ParserSTEP.DoubleOptionalToString(mLinearStiffnessByLengthY) + "," + ParserSTEP.DoubleOptionalToString(mLinearStiffnessByLengthZ) + "," + ParserSTEP.DoubleOptionalToString(mRotationalStiffnessByLengthX) + "," + ParserSTEP.DoubleOptionalToString(mRotationalStiffnessByLengthY) + "," + ParserSTEP.DoubleOptionalToString(mRotationalStiffnessByLengthZ); }
+ }
+ public class IfcBoundaryFaceCondition : IfcBoundaryCondition
+ {
+ internal double mLinearStiffnessByAreaX, mLinearStiffnessByAreaY, mLinearStiffnessByAreaZ;// : OPTIONAL IfcModulusOfSubgradeReactionMeasure
+ internal IfcBoundaryFaceCondition() : base() { }
+ internal IfcBoundaryFaceCondition(IfcBoundaryFaceCondition i) : base(i) { mLinearStiffnessByAreaX = i.mLinearStiffnessByAreaX; mLinearStiffnessByAreaY = i.mLinearStiffnessByAreaY; mLinearStiffnessByAreaZ = i.mLinearStiffnessByAreaZ; }
+ internal IfcBoundaryFaceCondition(DatabaseIfc m, string name) : base(m, name) { }
+ internal static IfcBoundaryFaceCondition Parse(string strDef) { IfcBoundaryFaceCondition b = new IfcBoundaryFaceCondition(); int ipos = 0; parseFields(b, ParserSTEP.SplitLineFields(strDef), ref ipos); return b; }
+ internal static void parseFields(IfcBoundaryFaceCondition b, List arrFields, ref int ipos) { IfcBoundaryCondition.parseFields(b, arrFields, ref ipos); b.mLinearStiffnessByAreaX = ParserSTEP.ParseDouble(arrFields[ipos++]); b.mLinearStiffnessByAreaY = ParserSTEP.ParseDouble(arrFields[ipos++]); b.mLinearStiffnessByAreaZ = ParserSTEP.ParseDouble(arrFields[ipos++]); }
+ protected override string BuildString() { return base.BuildString() + "," + ParserSTEP.DoubleOptionalToString(mLinearStiffnessByAreaX) + "," + ParserSTEP.DoubleOptionalToString(mLinearStiffnessByAreaY) + "," + ParserSTEP.DoubleOptionalToString(mLinearStiffnessByAreaZ); }
+ }
+ public partial class IfcBoundaryNodeCondition : IfcBoundaryCondition
+ {
+ internal IfcTranslationalStiffnessSelect mTranslationalStiffnessX, mTranslationalStiffnessY, mTranslationalStiffnessZ;// : OPTIONAL IfcTranslationalStiffnessSelect;
+ internal IfcRotationalStiffnessSelect mRotationalStiffnessX, mRotationalStiffnessY, mRotationalStiffnessZ;// : OPTIONAL IfcRotationalStiffnessSelect;
+ internal IfcBoundaryNodeCondition() : base() { }
+ internal IfcBoundaryNodeCondition(IfcBoundaryNodeCondition i) : base(i) { mTranslationalStiffnessX = i.mTranslationalStiffnessX; mTranslationalStiffnessY = i.mTranslationalStiffnessY; mTranslationalStiffnessZ = i.mTranslationalStiffnessZ; mRotationalStiffnessX = i.mRotationalStiffnessX; mRotationalStiffnessY = i.mRotationalStiffnessY; mRotationalStiffnessZ = i.mRotationalStiffnessZ; }
+ public IfcBoundaryNodeCondition(DatabaseIfc m, string name, bool restrainX, bool restrainY, bool restrainZ, bool restrainXX, bool restrainYY, bool restrainZZ)
+ : this(m, name, new IfcTranslationalStiffnessSelect(restrainX), new IfcTranslationalStiffnessSelect(restrainY), new IfcTranslationalStiffnessSelect(restrainZ), new IfcRotationalStiffnessSelect(restrainXX), new IfcRotationalStiffnessSelect(restrainYY), new IfcRotationalStiffnessSelect(restrainZZ)) { }
+ internal IfcBoundaryNodeCondition(DatabaseIfc m, string name, IfcTranslationalStiffnessSelect x, IfcTranslationalStiffnessSelect y, IfcTranslationalStiffnessSelect z, IfcRotationalStiffnessSelect xx, IfcRotationalStiffnessSelect yy, IfcRotationalStiffnessSelect zz)
+ : base(m, name)
+ {
+
+ if (m.mSchema == Schema.IFC2x3)
+ {
+ if (x != null && (x.mRigid || x.mStiffness == null))
+ mTranslationalStiffnessX = new IfcTranslationalStiffnessSelect(x.mRigid ? -1 : 0);
+ if (y != null && (y.mRigid || y.mStiffness == null))
+ mTranslationalStiffnessY = new IfcTranslationalStiffnessSelect(y.mRigid ? -1 : 0);
+ if (z != null && (z.mRigid || z.mStiffness == null))
+ mTranslationalStiffnessZ = new IfcTranslationalStiffnessSelect(z.mRigid ? -1 : 0);
+ if (xx != null && (xx.mRigid || xx.mStiffness == null))
+ mRotationalStiffnessX = new IfcRotationalStiffnessSelect(xx.mRigid ? -1 : 0);
+ if (yy != null && (yy.mRigid || yy.mStiffness == null))
+ mRotationalStiffnessY = new IfcRotationalStiffnessSelect(yy.mRigid ? -1 : 0);
+ if (zz != null && (zz.mRigid || zz.mStiffness == null))
+ mRotationalStiffnessZ = new IfcRotationalStiffnessSelect(zz.mRigid ? -1 : 0);
+ }
+ else
+ {
+ mTranslationalStiffnessX = x;
+ mTranslationalStiffnessY = y;
+ mTranslationalStiffnessZ = z;
+ mRotationalStiffnessX = xx;
+ mRotationalStiffnessY = yy;
+ mRotationalStiffnessZ = zz;
+ }
+ }
+ internal static IfcBoundaryNodeCondition Parse(string strDef) { IfcBoundaryNodeCondition b = new IfcBoundaryNodeCondition(); int ipos = 0; parseFields(b, ParserSTEP.SplitLineFields(strDef), ref ipos); return b; }
+ internal static void parseFields(IfcBoundaryNodeCondition b, List arrFields, ref int ipos, Schema schema)
+ {
+ IfcBoundaryCondition.parseFields(b, arrFields, ref ipos);
+ b.mTranslationalStiffnessX = IfcTranslationalStiffnessSelect.Parse(arrFields[ipos++], schema);
+ b.mTranslationalStiffnessY = IfcTranslationalStiffnessSelect.Parse(arrFields[ipos++], schema);
+ b.mTranslationalStiffnessZ = IfcTranslationalStiffnessSelect.Parse(arrFields[ipos++], schema);
+ b.mRotationalStiffnessX = IfcRotationalStiffnessSelect.Parse(arrFields[ipos++], schema);
+ b.mRotationalStiffnessY = IfcRotationalStiffnessSelect.Parse(arrFields[ipos++], schema);
+ b.mRotationalStiffnessZ = IfcRotationalStiffnessSelect.Parse(arrFields[ipos++], schema);
+ }
+ protected override string BuildString()
+ {
+ if (mDatabase.mSchema == Schema.IFC2x3)
+ return base.BuildString() + "," + (mTranslationalStiffnessX == null ? "$" : ParserSTEP.DoubleToString(mTranslationalStiffnessX.mStiffness.mValue)) + "," +
+ (mTranslationalStiffnessY == null ? "$" : ParserSTEP.DoubleToString(mTranslationalStiffnessY.mStiffness.mValue)) + "," +
+ (mTranslationalStiffnessZ == null ? "$" : ParserSTEP.DoubleToString(mTranslationalStiffnessZ.mStiffness.mValue)) + "," +
+ (mRotationalStiffnessX == null ? "$" : ParserSTEP.DoubleToString(mRotationalStiffnessX.mStiffness.mValue)) + "," +
+ (mRotationalStiffnessY == null ? "$" : ParserSTEP.DoubleToString(mRotationalStiffnessY.mStiffness.mValue)) + "," +
+ (mRotationalStiffnessZ == null ? "$" : ParserSTEP.DoubleToString(mRotationalStiffnessZ.mStiffness.mValue));
+ return base.BuildString() + "," + (mTranslationalStiffnessX == null ? "$" : mTranslationalStiffnessX.ToString()) + "," +
+ (mTranslationalStiffnessY == null ? "$" : mTranslationalStiffnessY.ToString()) + "," +
+ (mTranslationalStiffnessZ == null ? "$" : mTranslationalStiffnessZ.ToString()) + "," +
+ (mRotationalStiffnessX == null ? "$" : mRotationalStiffnessX.ToString()) + "," +
+ (mRotationalStiffnessY == null ? "$" : mRotationalStiffnessY.ToString()) + "," +
+ (mRotationalStiffnessZ == null ? "$" : mRotationalStiffnessZ.ToString());
+ }
+ }
+
+ public class IfcBoundaryNodeConditionWarping : IfcBoundaryNodeCondition
+ {
+ internal IfcWarpingStiffnessSelect mWarpingStiffness;// : OPTIONAL IfcWarpingStiffnessSelect;
+ internal IfcBoundaryNodeConditionWarping() : base() { }
+ internal IfcBoundaryNodeConditionWarping(IfcBoundaryNodeConditionWarping i) : base(i) { mWarpingStiffness = i.mWarpingStiffness; }
+ internal IfcBoundaryNodeConditionWarping(DatabaseIfc m, string name, IfcTranslationalStiffnessSelect x, IfcTranslationalStiffnessSelect y, IfcTranslationalStiffnessSelect z, IfcRotationalStiffnessSelect xx, IfcRotationalStiffnessSelect yy, IfcRotationalStiffnessSelect zz, IfcWarpingStiffnessSelect w)
+ : base(m, name, x, y, z, xx, yy, zz) { mWarpingStiffness = w; }
+ internal new static IfcBoundaryNodeConditionWarping Parse(string strDef) { IfcBoundaryNodeConditionWarping b = new IfcBoundaryNodeConditionWarping(); int ipos = 0; parseFields(b, ParserSTEP.SplitLineFields(strDef), ref ipos); return b; }
+ internal static void parseFields(IfcBoundaryNodeConditionWarping b, List arrFields, ref int ipos) { IfcBoundaryNodeCondition.parseFields(b, arrFields, ref ipos); b.mWarpingStiffness = IfcWarpingStiffnessSelect.Parse(arrFields[ipos++]); }
+ protected override string BuildString() { return base.BuildString() + "," + mWarpingStiffness.ToString(); }
+ }
+ public abstract partial class IfcBoundedCurve : IfcCurve //ABSTRACT SUPERTYPE OF (ONEOF (IfcBSplineCurve ,IfcCompositeCurve ,IfcPolyline ,IfcTrimmedCurve)) IFC4 IfcIndexedPolyCurve IFC4x1 IfcCurveSegment2D
+ {
+ protected IfcBoundedCurve() : base() { }
+ protected IfcBoundedCurve(IfcBoundedCurve pl) : base(pl) { }
+ protected IfcBoundedCurve(DatabaseIfc m) : base(m) { }
+ protected static void parseFields(IfcBoundedCurve c, List arrFields, ref int ipos) { IfcCurve.parseFields(c, arrFields, ref ipos); }
+ }
+ public abstract class IfcBoundedSurface : IfcSurface // ABSTRACT SUPERTYPE OF (ONEOF(IfcCurveBoundedPlane,IfcRectangularTrimmedSurface))
+ {
+ protected IfcBoundedSurface() : base() { }
+ protected IfcBoundedSurface(IfcBoundedSurface p) : base(p) { }
+ protected IfcBoundedSurface(DatabaseIfc db) : base(db) { }
+ protected static void parseFields(IfcBoundedSurface s, List arrFields, ref int ipos) { IfcSurface.parseFields(s, arrFields, ref ipos); }
+ }
+ public partial class IfcBoundingBox : IfcGeometricRepresentationItem
+ {
+ private int mCorner;// : IfcCartesianPoint;
+ private double mXDim, mYDim, mZDim;// : IfcPositiveLengthMeasure
+
+ internal IfcCartesianPoint Corner { get { return mDatabase.mIfcObjects[mCorner] as IfcCartesianPoint; } }
+ internal double XDim { get { return mXDim; } }
+ internal double YDim { get { return mYDim; } }
+ internal double ZDim { get { return mZDim; } }
+
+ internal IfcBoundingBox() : base() { }
+ internal IfcBoundingBox(IfcBoundingBox o) : base(o) { mCorner = o.mCorner; mXDim = o.mXDim; mYDim = o.mYDim; mZDim = o.mZDim; }
+ internal IfcBoundingBox(IfcCartesianPoint pt, double xdim, double ydim, double zdim) : base(pt.mDatabase)
+ {
+ //if (mModel.mModelView != ModelView.NotAssigned && mModel.mModelView != ModelView.IFC2x3Coordination)
+ // throw new Exception("Invalid Model View for IfcBoundingBox : " + m.ModelView.ToString());
+ mCorner = pt.mIndex;
+ mXDim = xdim;
+ mYDim = ydim;
+ mZDim = zdim;
+ }
+ internal static IfcBoundingBox Parse(string strDef) { IfcBoundingBox b = new IfcBoundingBox(); int ipos = 0; parseFields(b, ParserSTEP.SplitLineFields(strDef), ref ipos); return b; }
+ internal static void parseFields(IfcBoundingBox b, List arrFields, ref int ipos)
+ {
+ IfcGeometricRepresentationItem.parseFields(b, arrFields, ref ipos);
+ b.mCorner = ParserSTEP.ParseLink(arrFields[ipos++]);
+ b.mXDim = ParserSTEP.ParseDouble(arrFields[ipos++]);
+ b.mYDim = ParserSTEP.ParseDouble(arrFields[ipos++]);
+ b.mZDim = ParserSTEP.ParseDouble(arrFields[ipos++]);
+ }
+ protected override string BuildString() { return base.BuildString() + "," + ParserSTEP.LinkToString(mCorner) + "," + ParserSTEP.DoubleToString(mXDim) + "," + ParserSTEP.DoubleToString(mYDim) + "," + ParserSTEP.DoubleToString(mZDim); }
+ }
+ public partial class IfcBoxedHalfSpace : IfcHalfSpaceSolid
+ {
+ private int mEnclosure;// : IfcBoundingBox;
+ internal IfcBoundingBox Enclosure { get { return mDatabase.mIfcObjects[mEnclosure] as IfcBoundingBox; } }
+
+ internal IfcBoxedHalfSpace() : base() { }
+ internal IfcBoxedHalfSpace(IfcBoxedHalfSpace pl) : base(pl) { mEnclosure = pl.mEnclosure; }
+ internal static void parseFields(IfcBoxedHalfSpace s, List arrFields, ref int ipos) { IfcHalfSpaceSolid.parseFields(s, arrFields, ref ipos); s.mEnclosure = ParserSTEP.ParseLink(arrFields[ipos++]); }
+ internal new static IfcBoxedHalfSpace Parse(string strDef) { IfcBoxedHalfSpace s = new IfcBoxedHalfSpace(); int ipos = 0; parseFields(s, ParserSTEP.SplitLineFields(strDef), ref ipos); return s; }
+ protected override string BuildString() { return base.BuildString() + "," + ParserSTEP.LinkToString(mEnclosure); }
+ }
+ public abstract partial class IfcBSplineCurve : IfcBoundedCurve //SUPERTYPE OF(IfcBSplineCurveWithKnots)
+ {
+ private int mDegree;// : INTEGER;
+ private List mControlPointsList = new List();// : LIST [2:?] OF IfcCartesianPoint;
+ private IfcBSplineCurveForm mCurveForm;// : IfcBSplineCurveForm;
+ private IfcLogicalEnum mClosedCurve;// : LOGICAL;
+ private IfcLogicalEnum mSelfIntersect;// : LOGICAL;
+
+ internal int Degree { get { return mDegree; } }
+ internal List ControlPointsList { get { return mControlPointsList.ConvertAll(x => mDatabase.mIfcObjects[x] as IfcCartesianPoint); } }
+ internal IfcBSplineCurveForm CurveForm { get { return mCurveForm; } }
+ internal IfcLogicalEnum ClosedCurve { get { return mClosedCurve; } }
+ internal IfcLogicalEnum SelfIntersect { get { return mSelfIntersect; } }
+
+ protected IfcBSplineCurve() : base() { }
+ protected IfcBSplineCurve(IfcBSplineCurve pl)
+ : base(pl)
+ {
+ mDegree = pl.mDegree;
+ mControlPointsList = new List(pl.mControlPointsList.ToArray());
+ mCurveForm = pl.mCurveForm;
+ mClosedCurve = pl.mClosedCurve;
+ mSelfIntersect = pl.mSelfIntersect;
+ }
+ private IfcBSplineCurve(DatabaseIfc m, int degree, IfcBSplineCurveForm form, IfcLogicalEnum closed, IfcLogicalEnum selfIntersect)
+ : base(m)
+ {
+ mDegree = degree;
+ mCurveForm = form;
+ mClosedCurve = closed;
+ mSelfIntersect = selfIntersect;
+ }
+
+ protected static void parseFields(IfcBSplineCurve c, List arrFields, ref int ipos)
+ {
+ IfcBoundedCurve.parseFields(c, arrFields, ref ipos);
+ c.mDegree = int.Parse(arrFields[ipos++]);
+ c.mControlPointsList = ParserSTEP.SplitListLinks(arrFields[ipos++]);
+ c.mCurveForm = (IfcBSplineCurveForm)Enum.Parse(typeof(IfcBSplineCurveForm), arrFields[ipos++].Replace(".", ""));
+ c.mClosedCurve = ParserIfc.ParseIFCLogical(arrFields[ipos++]);
+ c.mSelfIntersect = ParserIfc.ParseIFCLogical(arrFields[ipos++]);
+ }
+ protected override string BuildString()
+ {
+ string str = base.BuildString() + "," + mDegree + ",(";
+ str += ParserSTEP.LinkToString(mControlPointsList[0]);
+ for (int icounter = 1; icounter < mControlPointsList.Count; icounter++)
+ str += "," + ParserSTEP.LinkToString(mControlPointsList[icounter]);
+ return str + "),." + mCurveForm.ToString() + ".," + ParserIfc.LogicalToString(mClosedCurve) + "," +
+ ParserIfc.LogicalToString(mSelfIntersect);
+ }
+ }
+ public partial class IfcBSplineCurveWithKnots : IfcBSplineCurve
+ {
+ private List mMultiplicities = new List();// : LIST [2:?] OF INTEGER;
+ private List mKnots = new List();// : LIST [2:?] OF IfcParameterValue;
+ private IfcKnotType mKnotSpec = IfcKnotType.UNSPECIFIED;//: IfcKnotType;
+
+ internal List Multiplicities { get { return mMultiplicities; } }
+ internal List Knots { get { return mKnots; } }
+ internal IfcKnotType KnotSpec { get { return mKnotSpec; } }
+
+ internal IfcBSplineCurveWithKnots() : base() { }
+ internal IfcBSplineCurveWithKnots(IfcBSplineCurveWithKnots pl)
+ : base(pl)
+ {
+ mMultiplicities = new List(pl.mMultiplicities.ToArray());
+ mKnots = new List(pl.mKnots.ToArray());
+ mKnotSpec = pl.mKnotSpec;
+ }
+
+ internal static void parseFields(IfcBSplineCurveWithKnots c, List arrFields, ref int ipos)
+ {
+ IfcBSplineCurve.parseFields(c, arrFields, ref ipos);
+ string s = arrFields[ipos++];
+ List arrLists = ParserSTEP.SplitLineFields(s.Substring(1, s.Length - 2));
+ for (int icounter = 0; icounter < arrLists.Count; icounter++)
+ c.mMultiplicities.Add(ParserSTEP.ParseInt(arrLists[icounter]));
+ s = arrFields[ipos++];
+ arrLists = ParserSTEP.SplitLineFields(s.Substring(1, s.Length - 2));
+ for (int icounter = 0; icounter < arrLists.Count; icounter++)
+ c.mKnots.Add(ParserSTEP.ParseDouble(arrLists[icounter]));
+ c.mKnotSpec = (IfcKnotType)Enum.Parse(typeof(IfcKnotType), arrFields[ipos++].Replace(".", ""));
+ }
+ internal static IfcBSplineCurveWithKnots Parse(string strDef) { IfcBSplineCurveWithKnots c = new IfcBSplineCurveWithKnots(); int ipos = 0; parseFields(c, ParserSTEP.SplitLineFields(strDef), ref ipos); return c; }
+ protected override string BuildString()
+ {
+ string str = base.BuildString() + ",(" + ParserSTEP.IntToString(mMultiplicities[0]);
+ for (int jcounter = 1; jcounter < mMultiplicities.Count; jcounter++)
+ str += "," + ParserSTEP.IntToString(mMultiplicities[jcounter]);
+ str += "),(" + ParserSTEP.DoubleToString(mKnots[0]);
+ for (int jcounter = 1; jcounter < mKnots.Count; jcounter++)
+ str += "," + ParserSTEP.DoubleToString(mKnots[jcounter]);
+ return str + "),." + mKnotSpec.ToString() + ".";
+ }
+ }
+ public abstract partial class IfcBSplineSurface : IfcBoundedSurface //ABSTRACT SUPERTYPE OF (IfcBSplineSurfaceWithKnots)
+ {
+ private int mUDegree;// : INTEGER;
+ private int mVDegree;// : INTEGER;
+ private List> mControlPointsList = new List>();// : LIST [2:?] OF LIST [2:?] OF IfcCartesianPoint;
+ private IfcBSplineSurfaceForm mSurfaceForm = IfcBSplineSurfaceForm.UNSPECIFIED;// : IfcBSplineSurfaceForm;
+ private IfcLogicalEnum mUClosed = IfcLogicalEnum.UNKNOWN;// : LOGICAL;
+ private IfcLogicalEnum mVClosed = IfcLogicalEnum.UNKNOWN;// : LOGICAL;
+ private IfcLogicalEnum mSelfIntersect = IfcLogicalEnum.UNKNOWN;// : LOGICAL;
+
+ internal int UDegree { get { return mUDegree; } }
+ internal int VDegree { get { return mVDegree; } }
+ internal List> ControlPointsList { get { return mControlPointsList.ConvertAll(x => x.ConvertAll(y => mDatabase.mIfcObjects[y] as IfcCartesianPoint)); } }
+ internal IfcBSplineSurfaceForm SurfaceForm { get { return mSurfaceForm; } }
+ internal IfcLogicalEnum UClosed { get { return mUClosed; } }
+ internal IfcLogicalEnum VClosed { get { return mVClosed; } }
+ internal IfcLogicalEnum SelfIntersect { get { return mSelfIntersect; } }
+
+ protected IfcBSplineSurface() : base() { }
+ protected IfcBSplineSurface(IfcBSplineSurface pl)
+ : base(pl)
+ {
+ mUDegree = pl.mUDegree;
+ mVDegree = pl.mVDegree;
+ for (int icounter = 0; icounter < pl.mControlPointsList.Count; icounter++)
+ mControlPointsList.Add(new List(pl.mControlPointsList[icounter].ToArray()));
+ mSurfaceForm = pl.mSurfaceForm;
+ mUClosed = pl.mUClosed;
+ mVClosed = pl.mVClosed;
+ mSelfIntersect = pl.mSelfIntersect;
+ }
+ private IfcBSplineSurface(DatabaseIfc m, int uDegree, int vDegree, IfcBSplineSurfaceForm form, IfcLogicalEnum uClosed, IfcLogicalEnum vClosed, IfcLogicalEnum selfIntersect)
+ : base(m)
+ {
+ mUDegree = uDegree;
+ mVDegree = vDegree;
+ mSurfaceForm = form;
+ mUClosed = uClosed;
+ mVClosed = vClosed;
+ mSelfIntersect = selfIntersect;
+ }
+ protected IfcBSplineSurface(DatabaseIfc m, int uDegree, int vDegree, List> controlPoints, IfcBSplineSurfaceForm form, IfcLogicalEnum uClosed, IfcLogicalEnum vClosed, IfcLogicalEnum selfIntersect) :
+ this(m, uDegree, vDegree, form, uClosed, vClosed, selfIntersect)
+ {
+ foreach (List cps in controlPoints)
+ mControlPointsList.Add(cps.ConvertAll(x => x.mIndex));
+ }
+
+ protected static void parseFields(IfcBSplineSurface bs, List arrFields, ref int ipos)
+ {
+ IfcBoundedSurface.parseFields(bs, arrFields, ref ipos);
+ bs.mUDegree = int.Parse(arrFields[ipos++]);
+ bs.mVDegree = int.Parse(arrFields[ipos++]);
+ string s = arrFields[ipos++];
+ List arrLists = ParserSTEP.SplitLineFields(s.Substring(1, s.Length - 2));
+ int ilast = arrLists.Count;
+ for (int icounter = 0; icounter < ilast; icounter++)
+ {
+ List points = new List();
+ s = arrLists[icounter];
+ List arrPoints = ParserSTEP.SplitLineFields(s.Substring(1, s.Length - 2));
+ for (int jcounter = 0; jcounter < arrPoints.Count; jcounter++)
+ points.Add(ParserSTEP.ParseLink(arrPoints[jcounter]));
+ bs.mControlPointsList.Add(points);
+ }
+ bs.mSurfaceForm = (IfcBSplineSurfaceForm)Enum.Parse(typeof(IfcBSplineSurfaceForm), arrFields[ipos++].Replace(".", ""));
+ bs.mUClosed = ParserIfc.ParseIFCLogical(arrFields[ipos++]);
+ bs.mVClosed = ParserIfc.ParseIFCLogical(arrFields[ipos++]);
+ bs.mSelfIntersect = ParserIfc.ParseIFCLogical(arrFields[ipos++]);
+ }
+ protected override string BuildString()
+ {
+ List cps = mControlPointsList[0];
+ string str = base.BuildString() + "," + mUDegree + "," + mVDegree + ",((" +
+ ParserSTEP.LinkToString(cps[0]);
+ for (int jcounter = 1; jcounter < cps.Count; jcounter++)
+ str += "," + ParserSTEP.LinkToString(cps[jcounter]);
+ str += ")";
+ for (int icounter = 1; icounter < mControlPointsList.Count; icounter++)
+ {
+ cps = mControlPointsList[icounter];
+ str += ",(" + ParserSTEP.LinkToString(cps[0]);
+ for (int jcounter = 1; jcounter < cps.Count; jcounter++)
+ str += "," + ParserSTEP.LinkToString(cps[jcounter]);
+ str += ")";
+ }
+ return str + "),." + mSurfaceForm.ToString() + ".," + ParserIfc.LogicalToString(mUClosed) + ","
+ + ParserIfc.LogicalToString(mVClosed) + "," + ParserIfc.LogicalToString(mSelfIntersect);
+ }
+ }
+ public partial class IfcBSplineSurfaceWithKnots : IfcBSplineSurface
+ {
+ internal List mUMultiplicities = new List();// : LIST [2:?] OF INTEGER;
+ internal List mVMultiplicities = new List();// : LIST [2:?] OF INTEGER;
+ internal List mUKnots = new List();// : LIST [2:?] OF IfcParameterValue;
+ internal List mVKnots = new List();// : LIST [2:?] OF IfcParameterValue;
+ internal IfcKnotType mKnotSpec = IfcKnotType.UNSPECIFIED;//: IfcKnotType;
+ internal IfcBSplineSurfaceWithKnots() : base() { }
+ internal IfcBSplineSurfaceWithKnots(IfcBSplineSurfaceWithKnots s)
+ : base(s)
+ {
+ mUMultiplicities = new List(s.mUMultiplicities.ToArray());
+ mVMultiplicities = new List(s.mVMultiplicities.ToArray());
+ mUKnots = new List(s.mUKnots.ToArray());
+ mVKnots = new List(s.mVKnots.ToArray());
+ mKnotSpec = s.mKnotSpec;
+ }
+ internal IfcBSplineSurfaceWithKnots(DatabaseIfc m, int uDegree, int vDegree, IfcBSplineSurfaceForm form, List> controlPoints, IfcLogicalEnum uClosed, IfcLogicalEnum vClosed, IfcLogicalEnum selfIntersect, List uMultiplicities, List vMultiplicities, List uKnots, List vKnots, IfcKnotType type)
+ : base(m, uDegree, vDegree, controlPoints, form, uClosed, vClosed, selfIntersect)
+ {
+ mUMultiplicities.AddRange(uMultiplicities);
+ mVMultiplicities.AddRange(vMultiplicities);
+ mUKnots.AddRange(uKnots);
+ mVKnots.AddRange(vKnots);
+ }
+
+ internal static void parseFields(IfcBSplineSurfaceWithKnots ss, List arrFields, ref int ipos)
+ {
+ IfcBSplineSurface.parseFields(ss, arrFields, ref ipos);
+ string s = arrFields[ipos++];
+ List arrLists = ParserSTEP.SplitLineFields(s.Substring(1, s.Length - 2));
+ for (int icounter = 0; icounter < arrLists.Count; icounter++)
+ ss.mUMultiplicities.Add(ParserSTEP.ParseInt(arrLists[icounter]));
+ s = arrFields[ipos++];
+ arrLists = ParserSTEP.SplitLineFields(s.Substring(1, s.Length - 2));
+ for (int icounter = 0; icounter < arrLists.Count; icounter++)
+ ss.mVMultiplicities.Add(ParserSTEP.ParseInt(arrLists[icounter]));
+ s = arrFields[ipos++];
+ arrLists = ParserSTEP.SplitLineFields(s.Substring(1, s.Length - 2));
+ for (int icounter = 0; icounter < arrLists.Count; icounter++)
+ ss.mUKnots.Add(ParserSTEP.ParseDouble(arrLists[icounter]));
+ s = arrFields[ipos++];
+ arrLists = ParserSTEP.SplitLineFields(s.Substring(1, s.Length - 2));
+ for (int icounter = 0; icounter < arrLists.Count; icounter++)
+ ss.mVKnots.Add(ParserSTEP.ParseDouble(arrLists[icounter]));
+ ss.mKnotSpec = (IfcKnotType)Enum.Parse(typeof(IfcKnotType), arrFields[ipos++].Replace(".", ""));
+ }
+ internal static IfcBSplineSurfaceWithKnots Parse(string strDef) { IfcBSplineSurfaceWithKnots s = new IfcBSplineSurfaceWithKnots(); int ipos = 0; parseFields(s, ParserSTEP.SplitLineFields(strDef), ref ipos); return s; }
+ protected override string BuildString()
+ {
+ string str = base.BuildString() + ",(" + ParserSTEP.IntToString(mUMultiplicities[0]);
+ for (int jcounter = 1; jcounter < mUMultiplicities.Count; jcounter++)
+ str += "," + ParserSTEP.IntToString(mUMultiplicities[jcounter]);
+ str += "),(" + ParserSTEP.IntToString(mVMultiplicities[0]);
+ for (int jcounter = 1; jcounter < mVMultiplicities.Count; jcounter++)
+ str += "," + ParserSTEP.IntToString(mVMultiplicities[jcounter]);
+ str += "),(" + ParserSTEP.DoubleToString(mUKnots[0]);
+ for (int jcounter = 1; jcounter < mUKnots.Count; jcounter++)
+ str += "," + ParserSTEP.DoubleToString(mUKnots[jcounter]);
+ str += "),(" + ParserSTEP.DoubleToString(mVKnots[0]);
+ for (int jcounter = 1; jcounter < mVKnots.Count; jcounter++)
+ str += "," + ParserSTEP.DoubleToString(mVKnots[jcounter]);
+ return str + "),." + mKnotSpec.ToString() + ".";
+ }
+ }
+ public partial class IfcBuilding : IfcSpatialStructureElement
+ {
+ internal double mElevationOfRefHeight;// : OPTIONAL IfcLengthMeasure;
+ internal double mElevationOfTerrain;// : OPTIONAL IfcLengthMeasure;
+ internal int mBuildingAddress;// : OPTIONAL IfcPostalAddress;
+
+ internal double ElevationOfRefHeight { get { return mElevationOfRefHeight; } set {mElevationOfRefHeight = value; } }
+ internal double ElevationOfTerrain { get { return mElevationOfTerrain; } set {mElevationOfTerrain = value; } }
+ internal IfcPostalAddress BuildingAddress {get {return mDatabase.mIfcObjects[mBuildingAddress] as IfcPostalAddress;} set { mBuildingAddress = (value == null ? 0 : value.mIndex); }}
+
+ internal IfcBuilding() : base() { }
+ internal IfcBuilding(IfcBuilding p) : base(p) { mElevationOfRefHeight = p.mElevationOfRefHeight; mElevationOfTerrain = p.mElevationOfTerrain; mBuildingAddress = p.mBuildingAddress; }
+ public IfcBuilding(DatabaseIfc db, string name) : base(db) { Name = name; }
+ public IfcBuilding(IfcBuilding host, string name) : base(host, name) { }
+ public IfcBuilding(IfcSite host, string name) : base(host, name) { }
+
+ private void init(IfcSpatialElement container)
+ {
+ IfcRelAggregates ra = new IfcRelAggregates(mDatabase, "Building", "Building Storie", this);
+ if (container != null)
+ container.addBuilding(this);
+ //mBuildingAddress = new IfcPostalAddress(mModel, IfcAddressTypeEnum.NOTDEFINED).mIndex;
+ }
+ internal static IfcBuilding Parse(string strDef) { IfcBuilding b = new IfcBuilding(); int ipos = 0; parseFields(b, ParserSTEP.SplitLineFields(strDef), ref ipos); return b; }
+ internal static void parseFields(IfcBuilding b, List arrFields, ref int ipos) { IfcSpatialStructureElement.parseFields(b, arrFields, ref ipos); b.mElevationOfRefHeight = ParserSTEP.ParseDouble(arrFields[ipos++]); b.mElevationOfTerrain = ParserSTEP.ParseDouble(arrFields[ipos++]); b.mBuildingAddress = ParserSTEP.ParseLink(arrFields[ipos++]); }
+ protected override string BuildString() { return base.BuildString() + "," + ParserSTEP.DoubleOptionalToString(mElevationOfRefHeight) + "," + ParserSTEP.DoubleOptionalToString(mElevationOfTerrain) + "," + ParserSTEP.LinkToString(mBuildingAddress); }
+
+ internal new bool addStorey(IfcBuildingStorey s) { return base.addStorey(s); }
+ }
+ public abstract partial class IfcBuildingElement : IfcElement //ABSTRACT SUPERTYPE OF (ONEOF (IfcBeam,IfcBuildingElementProxy,IfcColumn,IfcCovering,IfcCurtainWall,IfcDoor,IfcFooting
+ { //,IfcMember,IfcPile,IfcPlate,IfcRailing,IfcRamp,IfcRampFlight,IfcRoof,IfcSlab,IfcStair,IfcStairFlight,IfcWall,IfcWindow) IFC2x3 IfcBuildingElementComponent IFC4 IfcShadingDevice
+ internal new enum SubTypes { IfcBeam, IfcBuildingElementProxy, IfcColumn, IfcCovering, IfcCurtainWall, IfcDoor, IfcFooting, IfcMember, IfcPile, IfcPlate, IfcRailing, IfcRamp, IfcRampFlight, IfcRoof, IfcShadingDevice, IfcSlab, IfcStair, IfcStairFlight, IfcWall, IfcWindow }
+ protected IfcBuildingElement() : base() { }
+ protected IfcBuildingElement(IfcBuildingElement e) : base(e) { }
+ protected IfcBuildingElement(DatabaseIfc m) : base(m) { }
+ protected IfcBuildingElement(IfcProduct host, IfcObjectPlacement p, IfcProductRepresentation r) : base(host, p, r) { }
+
+ protected static void parseFields(IfcBuildingElement e, List